From 37de6068e7e66e22b229fefb92fedcac7b24d022 Mon Sep 17 00:00:00 2001
From: sigonasr2 <sigonasr2@gmail.com>
Date: Sun, 23 Oct 2022 02:38:22 -0500
Subject: [PATCH] Update C++

Co-authored-by: sigonasr2 <sigonasr2@gmail.com>
---
 C++/scripts/build.sh |    14 +-
 C++/scripts/md5      |     2 +-
 C++ProjectTemplate   |   Bin 711408 -> 62528 bytes
 config.hpp           |    53 +
 data.lua             |    33 +
 forward.hpp          |  1321 ++
 main.cpp             |  1268 +-
 sig                  |     2 +-
 sol.hpp              | 28907 +++++++++++++++++++++++++++++++++++++++++
 sol/config.hpp       |    53 +
 10 files changed, 30418 insertions(+), 1235 deletions(-)
 create mode 100644 config.hpp
 create mode 100644 data.lua
 create mode 100644 forward.hpp
 create mode 100644 sol.hpp
 create mode 100644 sol/config.hpp

diff --git a/C++/scripts/build.sh b/C++/scripts/build.sh
index 0656a8a..29e31cc 100755
--- a/C++/scripts/build.sh
+++ b/C++/scripts/build.sh
@@ -1,7 +1,15 @@
-#Compiles the entire program then runs it, producing an executable.
+#Compiles the entire program then runs it, producing an executable. If the "test" argument is included, will try and run tests too (in the test folder)
 #C++
 printf "Running program...\n\n\n"
-if g++ $(find . -type f -name "*.cpp") ${CUSTOM_PARAMS} -o ${PROJECT_NAME}; then
-    ./${PROJECT_NAME} "$@"
+if [ "$1" = "test" ]
+then
+    printf "Running tests...\n"
+    if g++ $(find . -type f -name "*.cpp") ${CUSTOM_PARAMS} -o ${PROJECT_NAME}; then
+        ./${PROJECT_NAME} "$@"
+    fi
+else
+    if g++ $(find . -type f -name "*.cpp" -not -path "./test/*") ${CUSTOM_PARAMS} -o ${PROJECT_NAME}; then
+        ./${PROJECT_NAME} "$@"
+    fi
 fi
 printf "\n\n"
diff --git a/C++/scripts/md5 b/C++/scripts/md5
index add9549..0dfebb2 100644
--- a/C++/scripts/md5
+++ b/C++/scripts/md5
@@ -1,4 +1,4 @@
-build.sh:530634457ea9041267c05d4ced95eee1  -
+build.sh:ca58f10d4e30d807987ea0105930ae51  -
 commit.sh:d03a46e721060c22ccb146e19d27e70a  -
 debug.sh:abbbb0c6d9f2409f3a90738ab3d9d44f  -
 lines.sh:3b907786f7fc9204025993016c9080de  -
diff --git a/C++ProjectTemplate b/C++ProjectTemplate
index cfee198c0d825b24ab6c9279282042d02fe82841..0f82c229ae4d860e3038e42830f4ba58f401a843 100755
GIT binary patch
literal 62528
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
b!1qJzmugqxPR32V`f2+l$23O;N74Ad(UCbN

literal 711408
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

diff --git a/config.hpp b/config.hpp
new file mode 100644
index 0000000..807bae4
--- /dev/null
+++ b/config.hpp
@@ -0,0 +1,53 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 Rapptz, ThePhD and contributors
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// 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 OR
+// COPYRIGHT HOLDERS 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.
+
+// This file was generated with a script.
+// Generated 2022-10-23 03:24:40.304940 UTC
+// This header was generated with sol v3.3.0 (revision 0386513a)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_CONFIG_HPP
+#define SOL_SINGLE_CONFIG_HPP
+
+// beginning of sol/config.hpp
+
+/* Base, empty configuration file!
+
+     To override, place a file in your include paths of the form:
+
+. (your include path here)
+| sol (directory, or equivalent)
+  | config.hpp (your config.hpp file)
+
+     So that when sol2 includes the file
+
+#include <sol/config.hpp>
+
+     it gives you the configuration values you desire. Configuration values can be
+seen in the safety.rst of the doc/src, or at
+https://sol2.readthedocs.io/en/latest/safety.html ! You can also pass them through
+the build system, or the command line options of your compiler.
+
+*/
+
+// end of sol/config.hpp
+
+#endif // SOL_SINGLE_CONFIG_HPP
diff --git a/data.lua b/data.lua
new file mode 100644
index 0000000..0da8e6a
--- /dev/null
+++ b/data.lua
@@ -0,0 +1,33 @@
+return 
+{
+    Name = "Weapon", -- used for Engine::GetResearch()
+    offset = {0,0},
+    Icon =
+    {
+        FileName = "Assets/Research/Icons/WeaponUpgradeIcon.png",--Maybe Have multi_Icon based on lvl of upgrade?
+        size = {32,32},
+        FileSize = {64,64}
+    },    
+    Parameters =
+    {
+        Oncer = false, --Only get one upgrade
+        InitialCost = 120,
+        CostScale = 2, --How Much more it costs per upgrade??? Use Math Equation
+        ResearchTime = 22 --Seconds
+    },
+    Requirements =
+    {
+        Buildings = {"Castle","StoneTower"}
+    },
+    Reward = 
+    {
+        Stats =
+        {
+        Damage = 5,    
+        Armor = 5,
+        Health = 10, 
+        MoveSpeed= 4
+        },
+        Unlocks = {"Archer"}
+    }
+}
\ No newline at end of file
diff --git a/forward.hpp b/forward.hpp
new file mode 100644
index 0000000..14bbfc8
--- /dev/null
+++ b/forward.hpp
@@ -0,0 +1,1321 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 Rapptz, ThePhD and contributors
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// 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 OR
+// COPYRIGHT HOLDERS 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.
+
+// This file was generated with a script.
+// Generated 2022-10-23 03:24:40.299252 UTC
+// This header was generated with sol v3.3.0 (revision 0386513a)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_INCLUDE_FORWARD_HPP
+#define SOL_SINGLE_INCLUDE_FORWARD_HPP
+
+// beginning of sol/forward.hpp
+
+#ifndef SOL_FORWARD_HPP
+#define SOL_FORWARD_HPP
+
+// beginning of sol/version.hpp
+
+#include <sol/config.hpp>
+
+#define SOL_VERSION_MAJOR 3
+#define SOL_VERSION_MINOR 2
+#define SOL_VERSION_PATCH 3
+#define SOL_VERSION_STRING "3.2.3"
+#define SOL_VERSION ((SOL_VERSION_MAJOR * 100000) + (SOL_VERSION_MINOR * 100) + (SOL_VERSION_PATCH))
+
+#define SOL_TOKEN_TO_STRING_POST_EXPANSION_I_(_TOKEN) #_TOKEN
+#define SOL_TOKEN_TO_STRING_I_(_TOKEN) SOL_TOKEN_TO_STRING_POST_EXPANSION_I_(_TOKEN)
+
+#define SOL_CONCAT_TOKENS_POST_EXPANSION_I_(_LEFT, _RIGHT) _LEFT##_RIGHT
+#define SOL_CONCAT_TOKENS_I_(_LEFT, _RIGHT) SOL_CONCAT_TOKENS_POST_EXPANSION_I_(_LEFT, _RIGHT)
+
+#define SOL_RAW_IS_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) != 0)
+#define SOL_RAW_IS_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3) == 0)
+#define SOL_RAW_IS_DEFAULT_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) > 3)
+#define SOL_RAW_IS_DEFAULT_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3 OP_SYMBOL 3) < 0)
+
+#define SOL_IS_ON(OP_SYMBOL) SOL_RAW_IS_ON(OP_SYMBOL ## _I_)
+#define SOL_IS_OFF(OP_SYMBOL) SOL_RAW_IS_OFF(OP_SYMBOL ## _I_)
+#define SOL_IS_DEFAULT_ON(OP_SYMBOL) SOL_RAW_IS_DEFAULT_ON(OP_SYMBOL ## _I_)
+#define SOL_IS_DEFAULT_OFF(OP_SYMBOL) SOL_RAW_IS_DEFAULT_OFF(OP_SYMBOL ## _I_)
+
+#define SOL_ON          |
+#define SOL_OFF         ^
+#define SOL_DEFAULT_ON  +
+#define SOL_DEFAULT_OFF -
+
+#if defined(SOL_BUILD_CXX_MODE)
+	#if (SOL_BUILD_CXX_MODE != 0)
+		#define SOL_BUILD_CXX_MODE_I_ SOL_ON
+	#else
+		#define SOL_BUILD_CXX_MODE_I_ SOL_OFF
+	#endif
+#elif defined(__cplusplus)
+	#define SOL_BUILD_CXX_MODE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_BUILD_CXX_MODE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_BUILD_C_MODE)
+	#if (SOL_BUILD_C_MODE != 0)
+		#define SOL_BUILD_C_MODE_I_ SOL_ON
+	#else
+		#define SOL_BUILD_C_MODE_I_ SOL_OFF
+	#endif
+#elif defined(__STDC__)
+	#define SOL_BUILD_C_MODE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_BUILD_C_MODE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SOL_IS_ON(SOL_BUILD_C_MODE)
+	#include <stddef.h>
+	#include <stdint.h>
+	#include <limits.h>
+#else
+	#include <cstddef>
+	#include <cstdint>
+	#include <climits>
+#endif
+
+#if defined(SOL_COMPILER_VCXX)
+	#if defined(SOL_COMPILER_VCXX != 0)
+		#define SOL_COMPILER_VCXX_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_VCXX_I_ SOL_OFF
+	#endif
+#elif defined(_MSC_VER)
+	#define SOL_COMPILER_VCXX_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_VCXX_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_GCC)
+	#if defined(SOL_COMPILER_GCC != 0)
+		#define SOL_COMPILER_GCC_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_GCC_I_ SOL_OFF
+	#endif
+#elif defined(__GNUC__)
+	#define SOL_COMPILER_GCC_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_GCC_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_CLANG)
+	#if defined(SOL_COMPILER_CLANG != 0)
+		#define SOL_COMPILER_CLANG_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_CLANG_I_ SOL_OFF
+	#endif
+#elif defined(__clang__)
+	#define SOL_COMPILER_CLANG_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_CLANG_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_EDG)
+	#if defined(SOL_COMPILER_EDG != 0)
+		#define SOL_COMPILER_EDG_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_EDG_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_COMPILER_EDG_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_MINGW)
+	#if (SOL_COMPILER_MINGW != 0)
+		#define SOL_COMPILER_MINGW_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_MINGW_I_ SOL_OFF
+	#endif
+#elif defined(__MINGW32__)
+	#define SOL_COMPILER_MINGW_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_MINGW_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SIZE_MAX <= 0xFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_ON
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#elif SIZE_MAX <= 0xFFFFFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_ON
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#else
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_ON
+#endif
+
+#define SOL_PLATFORM_ARM32_I_ SOL_OFF
+#define SOL_PLATFORM_ARM64_I_ SOL_OFF
+
+#if defined(SOL_PLATFORM_WINDOWS)
+	#if (SOL_PLATFORM_WINDOWS != 0)
+		#define SOL_PLATFORM_WINDOWS_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_WINDOWS_I_ SOL_OFF
+	#endif
+#elif defined(_WIN32)
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_CYGWIN)
+	#if (SOL_PLATFORM_CYGWIN != 0)
+		#define SOL_PLATFORM_CYGWIN_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_CYGWIN_I_ SOL_ON
+	#endif
+#elif defined(__CYGWIN__)
+	#define SOL_PLATFORM_CYGWIN_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_CYGWIN_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_APPLE)
+	#if (SOL_PLATFORM_APPLE != 0)
+		#define SOL_PLATFORM_APPLE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_APPLE_I_ SOL_OFF
+	#endif
+#elif defined(__APPLE__)
+	#define SOL_PLATFORM_APPLE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_APPLE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_UNIX)
+	#if (SOL_PLATFORM_UNIX != 0)
+		#define SOL_PLATFORM_UNIXLIKE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_UNIXLIKE_I_ SOL_OFF
+	#endif
+#elif defined(__unix__)
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_DEFAUKT_ON
+#else
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_LINUX)
+	#if (SOL_PLATFORM_LINUX != 0)
+		#define SOL_PLATFORM_LINUXLIKE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_LINUXLIKE_I_ SOL_OFF
+	#endif
+#elif defined(__LINUX__)
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_DEFAUKT_ON
+#else
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_DEFAULT_OFF
+#endif
+
+#define SOL_PLATFORM_APPLE_IPHONE_I_ SOL_OFF
+#define SOL_PLATFORM_BSDLIKE_I_      SOL_OFF
+
+#if defined(SOL_IN_DEBUG_DETECTED)
+	#if SOL_IN_DEBUG_DETECTED != 0
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#elif !defined(NDEBUG)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX) && defined(_DEBUG)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#elif (SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)) && !defined(__OPTIMIZE__)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEBUG_BUILD_I_ SOL_DEFAULT_OFF
+#endif // We are in a debug mode of some sort
+
+#if defined(SOL_NO_EXCEPTIONS)
+	#if (SOL_NO_EXCEPTIONS != 0)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	#if !defined(_CPPUNWIND)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)
+	#if !defined(__EXCEPTIONS)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#else
+	#define SOL_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_RTTI)
+	#if (SOL_NO_RTTI != 0)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	#if !defined(_CPPRTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)
+	#if !defined(__GXX_RTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#else
+	#define SOL_RTTI_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_THREAD_LOCAL)
+	#if SOL_NO_THREAD_LOCAL != 0
+		#define SOL_USE_THREAD_LOCAL_I_ SOL_OFF
+	#else
+		#define SOL_USE_THREAD_LOCAL_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_THREAD_LOCAL_I_ SOL_DEFAULT_ON
+#endif // thread_local keyword is bjorked on some platforms
+
+#if defined(SOL_ALL_SAFETIES_ON)
+	#if SOL_ALL_SAFETIES_ON != 0
+		#define SOL_ALL_SAFETIES_ON_I_ SOL_ON
+	#else
+		#define SOL_ALL_SAFETIES_ON_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_ALL_SAFETIES_ON_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_GETTER)
+	#if SOL_SAFE_GETTER != 0
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_USERTYPE)
+	#if SOL_SAFE_USERTYPE != 0
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_REFERENCES)
+	#if SOL_SAFE_REFERENCES != 0
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTIONS)
+	#if SOL_SAFE_FUNCTIONS != 0
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_OFF
+	#endif
+#elif defined (SOL_SAFE_FUNCTION_OBJECTS)
+	#if SOL_SAFE_FUNCTION_OBJECTS != 0
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTION_CALLS)
+	#if SOL_SAFE_FUNCTION_CALLS != 0
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_PROXIES)
+	#if SOL_SAFE_PROXIES != 0
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_NUMERICS)
+	#if SOL_SAFE_NUMERICS != 0
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_ALL_INTEGER_VALUES_FIT)
+	#if (SOL_ALL_INTEGER_VALUES_FIT != 0)
+		#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_ON
+	#else
+		#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_OFF
+	#endif
+#elif !SOL_IS_DEFAULT_OFF(SOL_SAFE_NUMERICS) && SOL_IS_OFF(SOL_SAFE_NUMERICS)
+	// if numerics is intentionally turned off, flip this on
+	#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_DEFAULT_ON
+#else
+	// default to off
+	#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_STACK_CHECK)
+	#if SOL_SAFE_STACK_CHECK != 0
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_CHECK_NUMBER_PRECISION)
+	#if SOL_NO_CHECK_NUMBER_PRECISION != 0
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#endif
+#elif defined(SOL_NO_CHECKING_NUMBER_PRECISION)
+	#if SOL_NO_CHECKING_NUMBER_PRECISION != 0
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_SAFE_NUMERICS)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_STRINGS_ARE_NUMBERS)
+	#if (SOL_STRINGS_ARE_NUMBERS != 0)
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_ON
+	#else
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_ENABLE_INTEROP)
+	#if SOL_ENABLE_INTEROP != 0
+		#define SOL_USE_INTEROP_I_ SOL_ON
+	#else
+		#define SOL_USE_INTEROP_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_INTEROP)
+	#if SOL_USE_INTEROP != 0
+		#define SOL_USE_INTEROP_I_ SOL_ON
+	#else
+		#define SOL_USE_INTEROP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_INTEROP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_NIL)
+	#if (SOL_NO_NIL != 0)
+		#define SOL_NIL_I_ SOL_OFF
+	#else
+		#define SOL_NIL_I_ SOL_ON
+	#endif
+#elif defined(__MAC_OS_X_VERSION_MAX_ALLOWED) || defined(__OBJC__) || defined(nil)
+	#define SOL_NIL_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_NIL_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USERTYPE_TYPE_BINDING_INFO)
+	#if (SOL_USERTYPE_TYPE_BINDING_INFO != 0)
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_ON
+	#else
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_DEFAULT_ON
+#endif // We should generate a my_type.__type table with lots of class information for usertypes
+
+#if defined(SOL_AUTOMAGICAL_TYPES_BY_DEFAULT)
+	#if (SOL_AUTOMAGICAL_TYPES_BY_DEFAULT != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#elif defined(SOL_DEFAULT_AUTOMAGICAL_USERTYPES)
+	#if (SOL_DEFAULT_AUTOMAGICAL_USERTYPES != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_DEFAULT_ON
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_STD_VARIANT)
+	#if (SOL_STD_VARIANT != 0)
+		#define SOL_STD_VARIANT_I_ SOL_ON
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_COMPILER_CLANG) && SOL_IS_ON(SOL_PLATFORM_APPLE)
+		#if defined(__has_include)
+			#if __has_include(<variant>)
+				#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+			#else
+				#define SOL_STD_VARIANT_I_ SOL_DEFAULT_OFF
+			#endif
+		#else
+			#define SOL_STD_VARIANT_I_ SOL_DEFAULT_OFF
+		#endif
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+	#endif
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_NOEXCEPT_FUNCTION_TYPE)
+	#if (SOL_NOEXCEPT_FUNCTION_TYPE != 0)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_noexcept_function_type)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_COMPILER_VCXX) && (defined(_MSVC_LANG) && (_MSVC_LANG < 201403L))
+		// There is a bug in the VC++ compiler??
+		// on /std:c++latest under x86 conditions (VS 15.5.2),
+		// compiler errors are tossed for noexcept markings being on function types
+		// that are identical in every other way to their non-noexcept marked types function types...
+		// VS 2019: There is absolutely a bug.
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_DEFAULT_ON
+	#endif
+#endif // noexcept is part of a function's type
+
+#if defined(SOL_STACK_STRING_OPTIMIZATION_SIZE) && SOL_STACK_STRING_OPTIMIZATION_SIZE > 0
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ SOL_STACK_STRING_OPTIMIZATION_SIZE
+#else
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ 1024
+#endif
+
+#if defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_ID_SIZE_I_ SOL_ID_SIZE
+#else
+	#define SOL_ID_SIZE_I_ 512
+#endif
+
+#if defined(LUA_IDSIZE) && LUA_IDSIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ LUA_IDSIZE
+#elif defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ SOL_FILE_ID_SIZE
+#else
+	#define SOL_FILE_ID_SIZE_I_ 2048
+#endif
+
+#if defined(SOL_PRINT_ERRORS)
+	#if (SOL_PRINT_ERRORS != 0)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_PRINT_ERRORS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#endif
+
+#if defined(SOL_DEFAULT_PASS_ON_ERROR)
+	#if (SOL_DEFAULT_PASS_ON_ERROR != 0)
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUA)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUA)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUA_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUAJIT)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUAJIT)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUAJIT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_LUA_HPP)
+	#if (SOL_NO_LUA_HPP != 0)
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#endif
+#elif defined(SOL_USING_CXX_LUA)
+	#define SOL_USE_LUA_HPP_I_ SOL_OFF
+#elif defined(__has_include)
+	#if __has_include(<lua.hpp>)
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_LUA_HPP_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_CONTAINERS_START)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START
+#elif defined(SOL_CONTAINERS_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START_INDEX
+#elif defined(SOL_CONTAINER_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINER_START_INDEX
+#else
+	#define SOL_CONTAINER_START_INDEX_I_ 1
+#endif
+
+#if defined (SOL_NO_MEMORY_ALIGNMENT)
+	#if (SOL_NO_MEMORY_ALIGNMENT != 0)
+		#define SOL_ALIGN_MEMORY_I_ SOL_OFF
+	#else
+		#define SOL_ALIGN_MEMORY_I_ SOL_ON
+	#endif
+#else
+	#define SOL_ALIGN_MEMORY_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USE_BOOST)
+	#if (SOL_USE_BOOST != 0)
+		#define SOL_USE_BOOST_I_ SOL_ON
+	#else
+		#define SOL_USE_BOOST_I_ SOL_OFF
+	#endif
+#else
+		#define SOL_USE_BOOST_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USE_UNSAFE_BASE_LOOKUP)
+	#if (SOL_USE_UNSAFE_BASE_LOOKUP != 0)
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_ON
+	#else
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_INSIDE_UNREAL)
+	#if (SOL_INSIDE_UNREAL != 0)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(UE_BUILD_DEBUG) || defined(UE_BUILD_DEVELOPMENT) || defined(UE_BUILD_TEST) || defined(UE_BUILD_SHIPPING) || defined(UE_SERVER)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_COMPAT)
+	#if (SOL_NO_COMPAT != 0)
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_OFF
+	#else
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_GET_FUNCTION_POINTER_UNSAFE)
+	#if (SOL_GET_FUNCTION_POINTER_UNSAFE != 0)
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_ON
+	#else
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
+	#if (SOL_FUNCTION_CALL_VALUE_SEMANTICS != 0)
+		#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_ON
+	#else
+		#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_MINGW_CCTYPE_IS_POISONED)
+	#if (SOL_MINGW_CCTYPE_IS_POISONED != 0)
+		#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_ON
+	#else
+		#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_MINGW) && defined(__GNUC__) && (__GNUC__ < 6)
+	// MinGW is off its rocker in some places...
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_CHAR8_T)
+	#if (SOL_CHAR8_T != 0)
+		#define SOL_CHAR8_T_I_ SOL_ON
+	#else
+		#define SOL_CHAR8_T_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_char8_t)
+		#define SOL_CHAR8_T_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_CHAR8_T_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+	#include <boost/version.hpp>
+
+	#if BOOST_VERSION >= 107500 // Since Boost 1.75.0 boost::none is constexpr
+		#define SOL_BOOST_NONE_CONSTEXPR_I_ constexpr
+	#else
+		#define SOL_BOOST_NONE_CONSTEXPR_I_ const
+	#endif // BOOST_VERSION
+#else
+	// assume boost isn't using a garbage version
+	#define SOL_BOOST_NONE_CONSTEXPR_I_ constexpr
+#endif
+
+#if defined(SOL2_CI)
+	#if (SOL2_CI != 0)
+		#define SOL2_CI_I_ SOL_ON
+	#else
+		#define SOL2_CI_I_ SOL_OFF
+	#endif
+#else
+	#define SOL2_CI_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_C_ASSERT)
+	#define SOL_USER_C_ASSERT_I_ SOL_ON
+#else
+	#define SOL_USER_C_ASSERT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_M_ASSERT)
+	#define SOL_USER_M_ASSERT_I_ SOL_ON
+#else
+	#define SOL_USER_M_ASSERT_I_ SOL_DEFAULT_OFF
+#endif
+
+// beginning of sol/prologue.hpp
+
+#if defined(SOL_PROLOGUE_I_)
+	#error "[sol2] Library Prologue was already included in translation unit and not properly ended with an epilogue."
+#endif
+
+#define SOL_PROLOGUE_I_ 1
+
+#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+	#define _FWD(...) static_cast<decltype( __VA_ARGS__ )&&>( __VA_ARGS__ )
+
+	#if SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define _MOVE(...) static_cast<__typeof( __VA_ARGS__ )&&>( __VA_ARGS__ )
+	#else
+		#include <type_traits>
+		
+		#define _MOVE(...) static_cast<::std::remove_reference_t<( __VA_ARGS__ )>&&>( __VA_OPT__(,) )
+	#endif
+#endif
+
+// end of sol/prologue.hpp
+
+// beginning of sol/epilogue.hpp
+
+#if !defined(SOL_PROLOGUE_I_)
+	#error "[sol2] Library Prologue is missing from this translation unit."
+#else
+	#undef SOL_PROLOGUE_I_
+#endif
+
+#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+	#undef _FWD
+	#undef _MOVE
+#endif
+
+// end of sol/epilogue.hpp
+
+// beginning of sol/detail/build_version.hpp
+
+#if defined(SOL_DLL)
+	#if (SOL_DLL != 0)
+		#define SOL_DLL_I_ SOL_ON
+	#else
+		#define SOL_DLL_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX) && (defined(DLL_) || defined(_DLL))
+	#define SOL_DLL_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_DLL_I_ SOL_DEFAULT_OFF
+#endif // DLL definition
+
+#if defined(SOL_HEADER_ONLY)
+	#if (SOL_HEADER_ONLY != 0)
+		#define SOL_HEADER_ONLY_I_ SOL_ON
+	#else
+		#define SOL_HEADER_ONLY_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_HEADER_ONLY_I_ SOL_DEFAULT_OFF
+#endif // Header only library
+
+#if defined(SOL_BUILD)
+	#if (SOL_BUILD != 0)
+		#define SOL_BUILD_I_ SOL_ON
+	#else
+		#define SOL_BUILD_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_BUILD_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_BUILD_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_UNITY_BUILD)
+	#if (SOL_UNITY_BUILD != 0)
+		#define SOL_UNITY_BUILD_I_ SOL_ON
+	#else
+		#define SOL_UNITY_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_UNITY_BUILD_I_ SOL_DEFAULT_OFF
+#endif // Header only library
+
+#if defined(SOL_C_FUNCTION_LINKAGE)
+	#define SOL_C_FUNCTION_LINKAGE_I_ SOL_C_FUNCTION_LINKAGE
+#else
+	#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+		// C++
+		#define SOL_C_FUNCTION_LINKAGE_I_ extern "C"
+	#else
+		// normal
+		#define SOL_C_FUNCTION_LINKAGE_I_
+	#endif // C++ or not
+#endif // Linkage specification for C functions
+
+#if defined(SOL_API_LINKAGE)
+	#define SOL_API_LINKAGE_I_ SOL_API_LINKAGE
+#else
+	#if SOL_IS_ON(SOL_DLL)
+		#if SOL_IS_ON(SOL_COMPILER_VCXX) || SOL_IS_ON(SOL_PLATFORM_WINDOWS) || SOL_IS_ON(SOL_PLATFORM_CYGWIN)
+			// MSVC Compiler; or, Windows, or Cygwin platforms
+			#if SOL_IS_ON(SOL_BUILD)
+				// Building the library
+				#if SOL_IS_ON(SOL_COMPILER_GCC)
+					// Using GCC
+					#define SOL_API_LINKAGE_I_ __attribute__((dllexport))
+				#else
+					// Using Clang, MSVC, etc...
+					#define SOL_API_LINKAGE_I_ __declspec(dllexport)
+				#endif
+			#else
+				#if SOL_IS_ON(SOL_COMPILER_GCC)
+					#define SOL_API_LINKAGE_I_ __attribute__((dllimport))
+				#else
+					#define SOL_API_LINKAGE_I_ __declspec(dllimport)
+				#endif
+			#endif
+		#else
+			// extern if building normally on non-MSVC
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#elif SOL_IS_ON(SOL_UNITY_BUILD)
+		// Built-in library, like how stb typical works
+		#if SOL_IS_ON(SOL_HEADER_ONLY)
+			// Header only, so functions are defined "inline"
+			#define SOL_API_LINKAGE_I_ inline
+		#else
+			// Not header only, so seperately compiled files
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#else
+		// Normal static library
+		#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+			#define SOL_API_LINKAGE_I_
+		#else
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#endif // DLL or not
+#endif // Build definitions
+
+#if defined(SOL_PUBLIC_FUNC_DECL)
+	#define SOL_PUBLIC_FUNC_DECL_I_ SOL_PUBLIC_FUNC_DECL
+#else
+	#define SOL_PUBLIC_FUNC_DECL_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_INTERNAL_FUNC_DECL_)
+	#define SOL_INTERNAL_FUNC_DECL_I_ SOL_INTERNAL_FUNC_DECL_
+#else
+	#define SOL_INTERNAL_FUNC_DECL_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_PUBLIC_FUNC_DEF)
+	#define SOL_PUBLIC_FUNC_DEF_I_ SOL_PUBLIC_FUNC_DEF
+#else
+	#define SOL_PUBLIC_FUNC_DEF_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_INTERNAL_FUNC_DEF)
+	#define SOL_INTERNAL_FUNC_DEF_I_ SOL_INTERNAL_FUNC_DEF
+#else
+	#define SOL_INTERNAL_FUNC_DEF_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_FUNC_DECL)
+	#define SOL_FUNC_DECL_I_ SOL_FUNC_DECL
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_FUNC_DECL_I_ 
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_FUNC_DECL_I_ extern __declspec(dllexport)
+		#else
+			#define SOL_FUNC_DECL_I_ extern __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_FUNC_DECL_I_ extern __attribute__((visibility("default")))
+	#else
+		#define SOL_FUNC_DECL_I_ extern
+	#endif
+#endif
+
+#if defined(SOL_FUNC_DEFN)
+	#define SOL_FUNC_DEFN_I_ SOL_FUNC_DEFN
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_FUNC_DEFN_I_ inline
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_FUNC_DEFN_I_ __declspec(dllexport)
+		#else
+			#define SOL_FUNC_DEFN_I_ __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_FUNC_DEFN_I_ __attribute__((visibility("default")))
+	#else
+		#define SOL_FUNC_DEFN_I_
+	#endif
+#endif
+
+#if defined(SOL_HIDDEN_FUNC_DECL)
+	#define SOL_HIDDEN_FUNC_DECL_I_ SOL_HIDDEN_FUNC_DECL
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_HIDDEN_FUNC_DECL_I_ 
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllexport)
+		#else
+			#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_HIDDEN_FUNC_DECL_I_ extern __attribute__((visibility("default")))
+	#else
+		#define SOL_HIDDEN_FUNC_DECL_I_ extern
+	#endif
+#endif
+
+#if defined(SOL_HIDDEN_FUNC_DEFN)
+	#define SOL_HIDDEN_FUNC_DEFN_I_ SOL_HIDDEN_FUNC_DEFN
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_HIDDEN_FUNC_DEFN_I_ inline
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_HIDDEN_FUNC_DEFN_I_ 
+		#else
+			#define SOL_HIDDEN_FUNC_DEFN_I_ 
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_HIDDEN_FUNC_DEFN_I_ __attribute__((visibility("hidden")))
+	#else
+		#define SOL_HIDDEN_FUNC_DEFN_I_
+	#endif
+#endif
+
+// end of sol/detail/build_version.hpp
+
+// end of sol/version.hpp
+
+#include <utility>
+#include <type_traits>
+#include <string_view>
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA) || SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+struct lua_State;
+#else
+extern "C" {
+struct lua_State;
+}
+#endif // C++ Mangling for Lua vs. Not
+
+namespace sol {
+
+	enum class type;
+
+	class stateless_reference;
+	template <bool b>
+	class basic_reference;
+	using reference = basic_reference<false>;
+	using main_reference = basic_reference<true>;
+	class stateless_stack_reference;
+	class stack_reference;
+
+	template <typename A>
+	class basic_bytecode;
+
+	struct lua_value;
+
+	struct proxy_base_tag;
+	template <typename>
+	struct proxy_base;
+	template <typename, typename>
+	struct table_proxy;
+
+	template <bool, typename>
+	class basic_table_core;
+	template <bool b>
+	using table_core = basic_table_core<b, reference>;
+	template <bool b>
+	using main_table_core = basic_table_core<b, main_reference>;
+	template <bool b>
+	using stack_table_core = basic_table_core<b, stack_reference>;
+	template <typename base_type>
+	using basic_table = basic_table_core<false, base_type>;
+	using table = table_core<false>;
+	using global_table = table_core<true>;
+	using main_table = main_table_core<false>;
+	using main_global_table = main_table_core<true>;
+	using stack_table = stack_table_core<false>;
+	using stack_global_table = stack_table_core<true>;
+
+	template <typename>
+	struct basic_lua_table;
+	using lua_table = basic_lua_table<reference>;
+	using stack_lua_table = basic_lua_table<stack_reference>;
+
+	template <typename T, typename base_type>
+	class basic_usertype;
+	template <typename T>
+	using usertype = basic_usertype<T, reference>;
+	template <typename T>
+	using stack_usertype = basic_usertype<T, stack_reference>;
+
+	template <typename base_type>
+	class basic_metatable;
+	using metatable = basic_metatable<reference>;
+	using stack_metatable = basic_metatable<stack_reference>;
+
+	template <typename base_t>
+	struct basic_environment;
+	using environment = basic_environment<reference>;
+	using main_environment = basic_environment<main_reference>;
+	using stack_environment = basic_environment<stack_reference>;
+
+	template <typename T, bool>
+	class basic_function;
+	template <typename T, bool, typename H>
+	class basic_protected_function;
+	using unsafe_function = basic_function<reference, false>;
+	using safe_function = basic_protected_function<reference, false, reference>;
+	using main_unsafe_function = basic_function<main_reference, false>;
+	using main_safe_function = basic_protected_function<main_reference, false, reference>;
+	using stack_unsafe_function = basic_function<stack_reference, false>;
+	using stack_safe_function = basic_protected_function<stack_reference, false, reference>;
+	using stack_aligned_unsafe_function = basic_function<stack_reference, true>;
+	using stack_aligned_safe_function = basic_protected_function<stack_reference, true, reference>;
+	using protected_function = safe_function;
+	using main_protected_function = main_safe_function;
+	using stack_protected_function = stack_safe_function;
+	using stack_aligned_protected_function = stack_aligned_safe_function;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+	using function = protected_function;
+	using main_function = main_protected_function;
+	using stack_function = stack_protected_function;
+	using stack_aligned_function = stack_aligned_safe_function;
+#else
+	using function = unsafe_function;
+	using main_function = main_unsafe_function;
+	using stack_function = stack_unsafe_function;
+	using stack_aligned_function = stack_aligned_unsafe_function;
+#endif
+	using stack_aligned_stack_handler_function = basic_protected_function<stack_reference, true, stack_reference>;
+
+	struct unsafe_function_result;
+	struct protected_function_result;
+	using safe_function_result = protected_function_result;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+	using function_result = safe_function_result;
+#else
+	using function_result = unsafe_function_result;
+#endif
+
+	template <typename base_t>
+	class basic_object_base;
+	template <typename base_t>
+	class basic_object;
+	template <typename base_t>
+	class basic_userdata;
+	template <typename base_t>
+	class basic_lightuserdata;
+	template <typename base_t>
+	class basic_coroutine;
+	template <typename base_t>
+	class basic_packaged_coroutine;
+	template <typename base_t>
+	class basic_thread;
+
+	using object = basic_object<reference>;
+	using userdata = basic_userdata<reference>;
+	using lightuserdata = basic_lightuserdata<reference>;
+	using thread = basic_thread<reference>;
+	using coroutine = basic_coroutine<reference>;
+	using packaged_coroutine = basic_packaged_coroutine<reference>;
+	using main_object = basic_object<main_reference>;
+	using main_userdata = basic_userdata<main_reference>;
+	using main_lightuserdata = basic_lightuserdata<main_reference>;
+	using main_coroutine = basic_coroutine<main_reference>;
+	using stack_object = basic_object<stack_reference>;
+	using stack_userdata = basic_userdata<stack_reference>;
+	using stack_lightuserdata = basic_lightuserdata<stack_reference>;
+	using stack_thread = basic_thread<stack_reference>;
+	using stack_coroutine = basic_coroutine<stack_reference>;
+
+	struct stack_proxy_base;
+	struct stack_proxy;
+	struct variadic_args;
+	struct variadic_results;
+	struct stack_count;
+	struct this_state;
+	struct this_main_state;
+	struct this_environment;
+
+	class state_view;
+	class state;
+
+	template <typename T>
+	struct as_table_t;
+	template <typename T>
+	struct as_container_t;
+	template <typename T>
+	struct nested;
+	template <typename T>
+	struct light;
+	template <typename T>
+	struct user;
+	template <typename T>
+	struct as_args_t;
+	template <typename T>
+	struct protect_t;
+	template <typename F, typename... Policies>
+	struct policy_wrapper;
+
+	template <typename T>
+	struct usertype_traits;
+	template <typename T>
+	struct unique_usertype_traits;
+
+	template <typename... Args>
+	struct types {
+		typedef std::make_index_sequence<sizeof...(Args)> indices;
+		static constexpr std::size_t size() {
+			return sizeof...(Args);
+		}
+	};
+
+	template <typename T>
+	struct derive : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct base : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct weak_derive {
+		static bool value;
+	};
+
+	template <typename T>
+	bool weak_derive<T>::value = false;
+
+	namespace stack {
+		struct record;
+	}
+
+#if SOL_IS_OFF(SOL_USE_BOOST)
+	template <class T>
+	class optional;
+
+	template <class T>
+	class optional<T&>;
+#endif
+
+	using check_handler_type = int(lua_State*, int, type, type, const char*);
+
+} // namespace sol
+
+#define SOL_BASE_CLASSES(T, ...)                       \
+	namespace sol {                                   \
+		template <>                                  \
+		struct base<T> : std::true_type {            \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+#define SOL_DERIVED_CLASSES(T, ...)                    \
+	namespace sol {                                   \
+		template <>                                  \
+		struct derive<T> : std::true_type {          \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+
+#endif // SOL_FORWARD_HPP
+// end of sol/forward.hpp
+
+#endif // SOL_SINGLE_INCLUDE_FORWARD_HPP
diff --git a/main.cpp b/main.cpp
index 048720d..9db767a 100644
--- a/main.cpp
+++ b/main.cpp
@@ -1,1242 +1,50 @@
-//========================================================================================================================================
-//		F4 Racing
-//----------------------------------------------------------------------------------------------------------------------------------------
-//		This is an advancement in my game making skills, building off the back of my work on the "Collect the Balls" game.
-//----------------------------------------------------------------------------------------------------------------------------------------
-//		created by Rune
-//		black box code by Sigonasr2 from the OLC (one lone coder) Discord server
-//========================================================================================================================================
-#define OLC_PGE_APPLICATION
-#include "pixelGameEngine.h"	// used for drawing the game
+#include <iostream>
+#include <map>
 
-//========================================================================================================================================
-//		protected variables
-//========================================================================================================================================
-class Racer : public olc::PixelGameEngine
-{
-public:
-	Racer()
-	{
-		sAppName = "F4 Racing";
-	}
-
-private:
-	float car_pos = 0.f;	// track the horizontal location of player
-	float distance = 0.f;	// track the "vertical" location of player; basically, they're somewhere on the track between the start and finish line
-	float speed = 0.f;
-
-	float curvature = 0.f;	// probably the player's horizontal position in relation to the track's curve
-	float track_curve = 0.f;
-	float car_curve = 0.f;	// wtf....
-	float track_dist = 0.f;	// total distance of the circuit
-
-	float cur_lap_time = 0.f;
-
-	std::vector<std::pair<float, float>> vecTrack;
-	std::list<float> list_times;
-
-	bool bothKeysPressed = false;	// checking for dual key press; could probably work with more than 2 keys
-
-	// custom controls template
-	olc::Key Move_Up = olc::UP;
-	olc::Key Move_Down = olc::DOWN;
-	olc::Key Move_Left = olc::LEFT;
-	olc::Key Move_Right = olc::RIGHT;
-
-	std::array<std::string, 4> keyslist = { "UP", "DOWN", "LEFT", "RIGHT" };
-	int configKeyIndex = -1;
-	char pressedKey;
-
-	// selection screen variables
-	int cup = -1;
-	int track = -1;
-	int player = 0;
-
-//========================================================================================================================================	
-//		Menu Setup
-//========================================================================================================================================
-public:
-	bool activeOption = true;	// highlighting current option
-	int highlighted;
-
-	struct MenuItem
-	{
-		std::string label;	// label
-		olc::vi2d pos;		// label's position
-		std::string label2;	// another label to right of label
-	};
-
-	struct Object
-	{
-		olc::vf2d pos{ 0, 0 };	// the x position represents how far to the left/right it is from the center. -1 ~ 1: road's range; the y position is how far along the track it is
-		olc::vf2d size{ 1, 1 };
-		olc::Decal* decal = nullptr;
-		olc::vf2d offset{ 0, 0 };	// how far off the image will be
-		bool rendered = false;
-		olc::vf2d drawPos;
-		olc::vf2d drawSize;
-		olc::vf2d drawOffsetPos;
-	};
-
-	std::vector<MenuItem> mainMenu;
-	std::vector<MenuItem> playGame;
-	std::vector<MenuItem> pickTrack;
-	std::vector<MenuItem> grandPrix;
-	std::vector<MenuItem> selectCar;
-	std::vector<MenuItem> controls;
-	std::vector<MenuItem> pause;
-	std::vector<std::string> gameOver;
-
-	std::vector<Object> gameObjects;
-
-	enum class state
-	{
-		MAIN_MENU, PLAY_GAME, RUN_GAME, CONTROLS, PAUSED, RESUME,	// main
-		TRACK_SELECT, CUP_SELECT, CAR_SELECT,	// game
-		INDIE, STREET, PRO, GRAND_PRIX	// cups
-	};
-
-	state gameState = state::MAIN_MENU;
-
-//========================================================================================================================================
-//		Variables
-//========================================================================================================================================
-
-	// lap times
-
-	// player
-	int score = 0;	// score at end of track; based on final place
-	int lap = 0;	// current lap player is on
-	int place;	// current place player is in
-	int tracks_left;
-
-	// initialize sprites
-	olc::Decal* car;
-	olc::Decal* cars;
-	olc::Decal* hill;
-	olc::Decal* grass;
-	olc::Decal* road;
-	olc::Decal* banner;
-	olc::Decal* title;
-	olc::Decal* cups;
-	//olc::Decal* select;
-
-	std::string KeyToString(olc::Key key)
-	{
-		const std::array<std::string, 98> keyStrings =
-		{
-			"NONE","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","0","1","2","3","4","5","6","7","8","9",
-			"F1","F2","F3","F4","F5","F6","F7","F8","F9","F10","F11","F12","UP","DOWN","LEFT","RIGHT","SPACE","TAB","SHIFT","CTRL","INS","DEL","HOME","END","PGUP","PGDN","BACK","ESCAPE","ENTER","ENTER",
-			"PAUSE","SCROLL LK","Kp-0","Kp-1","Kp-2","Kp-3","Kp-4","Kp-5","Kp-6","Kp-7","Kp-8","Kp-9","Kp-*","Kp-/","Kp-+","Kp--","Kp-.",".","=",",","-","OEM_1",
-			"OEM_2","OEM_3","OEM_4","OEM_5","OEM_6","OEM_7","OEM_8","CAPS LOCK","END"
-		};
-		return keyStrings[key];
-	}
-
-	// add laps to a new track struct
-
-	struct Track
-	{
-		std::vector <std::pair <float, float>> curves;	// curves
-		std::string name;	// names
-		int laps;	// laps
-	};
-
-	// special track ;)
-	Track javidx9 =
-	{
-		// they'll likely be wonky for the game as it's not really modified to fit my units of
-		// these happen to be measured in meters, as per Javid's original construction measure
-		{{0.f, 10.f}, {0.f, 200.f}, {1.f, 200.f}, {0.f, 400.f}, {-1.f, 100.f},
-		{0.f, 200.f}, {-1.f, 200.f}, {1.f, 200.f}, {0.f, 200.f}, {0.2f, 500.f}, {0.f, 200.f}}, "JAVIDX9", 3
-	};
-
-	// all 9 tracks below are running on yards for their distance units
-	// this means the end results are in miles; rather than kilometers
-	// enjoy the US measures of Burgers per Freedom Eagle
-	//==================================================================================================
-	Track circuit =
-	{
-		// Classic Oval; 1 mile loop, 1,760 yards
-		{ {0.f, 10.f}, {0.f, 270.f}, {-1.f, 330.f}, {0.f, 550.f}, {-1.f, 330.f}, {0.f, 270.f} }, "CIRCUIT", 3
-	};
-
-	Track infinity =
-	{
-		// figure eight
-		{{0.f, 10.f},	// flag (straight); this is positioned somewhere after the intersection
-		{0.f, 190.f }, {-1.f, 200.f},
-		{0.f, 500.f },	// straight; this crosses the first straight, to provide for chances of crashing
-		{1.f, 200.f }, {0.f, 300.f }}, "INFINITY", 3
-	};
-
-	Track arrow_head =
-	{
-		// fancy triangle
-		{{0.f, 10.f}, {0.f, 490.f}, {1.f, 130.f}, {0.f, 1000.f}, {1.f, 130.f},
-		{0.f, 500.f}, {-1.f, 130.f}, {0.f, 500.f}, {1.f, 130.f}, {0.f, 500.f}}, "ARROW HEAD", 3
-	};
-
-	Track track_4 =	// ???
-	{
-		{{0.f, 10.f},}, "Track 4", 3
-	};
-
-	Track overpass =
-	{
-		// kind of a folded figure eight
-		{{0.f, 10.f},
-		{0.f, 0.f},
-		{1.f, 0.f},
-		{0.f, 0.f},
-		{1.f, 0.f},
-		{1.f, 0.f},
-		{0.f, 0.f},
-		{1.f, 0.f},
-		{0.f, 0.f}}, "OVERPASS", 3
-	};
-
-	Track peanut=
-	{
-		// No more rhymes now. I mean it!
-		// Anybody want a peanut?
-		// GAH!!!
-		{{0.f, 10.f},}, "PEANUT", 4
-	};
-
-	Track track_7 =	// ???
-	{
-		{{0.f, 10.f},}, "Track 7", 3
-	};
-
-	Track trident =
-	{
-		// is your preferred Neptune or Poseidon?
-		{{0.f, 10.f},}, "TRIDENT", 3
-	};
-
-	Track star =
-	{
-		// spangled banner; oh say can you see....
-		// look, I suck at singing, and not gonna look up the lyrics, just, enjoy American awesomeness
-		{{0.f, 10.f},}, "STAR", 3
-	};
-
-	std::vector <Track> trackList =
-	{
-		javidx9,
-		circuit, infinity, arrow_head,
-		track_4, overpass, peanut,
-		track_7, trident, star
-	};
-
-
-//========================================================================================================================================
-//		Create Game Objects
-//========================================================================================================================================
-	bool OnUserCreate() override
-	{
-		mainMenu =	// show menu options
-		{
-			{ "START GAME", { ScreenWidth() / 2, ScreenHeight() / 5 * 3} },
-			{ "CONTROLS", { ScreenWidth() / 2, ScreenHeight() / 5 * 3 + 64} },
-			{ "QUIT", {ScreenWidth() / 2, ScreenHeight() / 5 * 3 + 128 } }
-		};
-
-		playGame =
-		{
-			{ "TRACK SELECTION", { ScreenWidth() / 2, ScreenHeight() / 4 } },
-			{ "GRAND PRIX", { ScreenWidth() / 2, ScreenHeight() / 2 } },
-			{ "BACK", { ScreenWidth() / 2, ScreenHeight() / 6 * 5} }
-		};
-
-		pickTrack =	// show track options
-		{
-			{ "CIRCUIT", { ScreenWidth() / 4, ScreenHeight() / 4 } }, { "INFINITY", { ScreenWidth() / 2, ScreenHeight() / 4 } },
-			{ "ARROWHEAD", { ScreenWidth() / 4 * 3, ScreenHeight() / 4 } }, { "Track 4", { ScreenWidth() / 4, ScreenHeight() / 2 }},
-			{ "OVERPASS", { ScreenWidth() / 2, ScreenHeight() / 2 } }, { "PEANUT", { ScreenWidth() / 4 * 3, ScreenHeight() / 2 } } ,
-			{ "Track 7", { ScreenWidth() / 4, ScreenHeight() / 4 * 3 } }, { "TRIDENT", { ScreenWidth() / 2, ScreenHeight() / 4 * 3 } },
-			{ "STAR", { ScreenWidth() / 4 * 3, ScreenHeight() / 4 * 3 } }, { "BACK", { ScreenWidth() / 2, ScreenHeight() / 6 * 5} }
-		};
-
-		grandPrix =	// show race cups
-		{
-			{ "INDIE CUP", { ScreenWidth() / 3, ScreenHeight() / 3 } }, { "STREET CUP", { ScreenWidth() / 3 * 2, ScreenHeight() / 3 } },
-			{ "PRO CUP", { ScreenWidth() / 3, ScreenHeight() / 3 * 2 } }, { "GRAND PRIX", { ScreenWidth() / 3 * 2, ScreenHeight() / 3 * 2 } },
-			{ "BACK", { ScreenWidth() / 2, ScreenHeight() / 6 * 5 } }
-		};
-
-		selectCar =	// pick a color
-		{
-			{ "RED", { ScreenWidth() / 5, ScreenHeight() / 3 } }, { "BLUE", { ScreenWidth() / 5 * 2, ScreenHeight() / 3 } },
-			{ "GREEN", { ScreenWidth() / 5 * 3, ScreenHeight() / 3 } }, { "GOLD", { ScreenWidth() / 5 * 4, ScreenHeight() / 3 } },
-			{ "PURPLE", { ScreenWidth() / 5, ScreenHeight() / 3 * 2 } }, { "WHITE", { ScreenWidth() / 5 * 2, ScreenHeight() / 3 * 2 } },
-			{ "ORANGE", { ScreenWidth() / 5 * 3, ScreenHeight() / 3 * 2 } }, { "BLACK", { ScreenWidth() / 5 * 4, ScreenHeight() / 3 * 2 } },
-			{ "BACK", { ScreenWidth() / 2, ScreenHeight() / 6 * 5} }
-		};
-
-		controls =	// customize controls
-		{
-			{ "FORWARD", { ScreenWidth() / 3, ScreenHeight() / 9 * 2 }, KeyToString(Move_Up) }, { "BACK", { ScreenWidth() / 3, ScreenHeight() / 9 * 3 }, KeyToString(Move_Down) },
-			{ "LEFT", { ScreenWidth() / 3, ScreenHeight() / 9 * 4 }, KeyToString(Move_Left) }, { "RIGHT", { ScreenWidth() / 3, ScreenHeight() / 9 * 5 }, KeyToString(Move_Right) },
-			{ "DEFAULT", { ScreenWidth() / 2, ScreenHeight() / 9 * 6} }, { "BACK", { ScreenWidth() / 2, ScreenHeight() / 6 * 5} }
-		};
-
-		pause =
-		{
-			{ "RESUME", { ScreenWidth() / 2, ScreenHeight() / 9 * 3} }, { "RESTART", { ScreenWidth() / 2, ScreenHeight() / 9 * 4} },
-			{ "MENU", { ScreenWidth() / 2, ScreenHeight() / 9 * 5} }, { "QUIT", { ScreenWidth() / 2, ScreenHeight() / 9 * 6} }
-		};
-
-		gameOver = { "Return to Main Menu" };
-
-//========================================================================================================================================
-		// load sprites
-		car = new olc::Decal(new olc::Sprite("art/car.png"));	// will contain 8 cars, with 3 angles per car
-		cars = new olc::Decal(new olc::Sprite("art/cars.png"));	// temp file; holds all 8 cars
-		hill = new olc::Decal(new olc::Sprite("art/hills.png"), false, false);
-		grass = new olc::Decal(new olc::Sprite("art/grass.png"), false, false);
-		road = new olc::Decal(new olc::Sprite("art/road.png"), false, false);	// holds both road and flag line
-		banner = new olc::Decal(new olc::Sprite("art/start.png"), false, false);
-		title = new olc::Decal(new olc::Sprite("art/title.png"));
-		cups = new olc::Decal(new olc::Sprite("art/cups.png"));		// 64 px tiles; 128 px image
-		//select = new olc::Decal(new olc::Sprite("art/selection.png"));
-
-		// track stuff
-		list_times = { 0,0,0,0,0 };	// this needs modification, as most tracks will likely have 4 laps, some with 3, and some with 5
-		gameObjects.push_back({ /*{-1.5,track_dist - 50}, {10,6}, {0,240}*/ });
-
-		return true;
-	}
-
-//========================================================================================================================================
-//		reset game
-//========================================================================================================================================
-
-	void Reset()
-	{
-		car_pos = 0.0f;
-		distance = 0.0f;
-		speed = 0.0f;
-
-		curvature = 0.0f;
-		track_curve = 0.0f;
-		car_curve = 0.0f;
-		track_dist = 0.0f;
-
-		cur_lap_time = 0.0f;
-		lap = 0;
-
-		// Note: the following all need to be reset during the process, when they've been implemented
-		// -player position (on screen)
-		// -player position (on track)
-		// -track section
-		// -all lap times
-		// -score
-		// 
-		// if called from other parts of the program, other than the 'F1' key, it should be resetting to the menu
-		// the 'F1' key is meant to reset the player on the current track they're on
-		//	
-	}
-
-	void DrawTrack()
-	{
-		vecTrack.clear();
-		for (int i = 0; i < trackList[track].curves.size(); i++)
-		{
-			vecTrack.push_back(trackList[track].curves[i]);
-			track_dist += vecTrack[i].second;
-		}
-	}
-
-//========================================================================================================================================
-//		main menu
-//========================================================================================================================================
-	void DisplayMenu(std::vector<MenuItem> list)
-	{
-		// drawing and coloring menu selections
-		for (int i = 0; i < list.size(); i++)
-		{
-			olc::vi2d textSize = GetTextSize(list[i].label) / 2 * 4;
-			olc::Pixel textCol = olc::GREY;	// greys out unselected options
-			if (highlighted == i)
-			{
-				textCol = olc::Pixel(255, 201, 14);	// gold
-			}
-
-			DrawStringDecal(list[i].pos - textSize, list[i].label, textCol, { 4.0f, 4.0f });
-			if (list[i].label2.size() > 0)
-			{
-				olc::vi2d offset = { ScreenWidth() / 3, -textSize.y / 2 };
-				DrawStringDecal(list[i].pos + offset, list[i].label2, textCol, { 4.0f, 4.0f });
-			}
-		}
-
-		// selecting options
-		highlighted = std::clamp(highlighted, 0, (int)list.size() - 1);	// loop if out of range
-
-		int shortest = 9999999;
-		int largest = -9999999;
-		int targetItem = highlighted;
-
-//========================================================================================================================================
-		if (GetKey(olc::Key::DOWN).bPressed)
-		{
-			for (int i = 0; i < list.size(); i++)
-			{
-				if (highlighted != i)
-				{
-					if (list[highlighted].pos.x == list[i].pos.x)
-					{
-						if (list[highlighted].pos.y < list[i].pos.y)
-						{
-							// it's below us
-							int dist = abs(list[highlighted].pos.y - list[i].pos.y);
-
-							if (dist < shortest)
-							{
-								targetItem = i;
-								shortest = dist;
-							}
+int main() {
+	std::map<std::string,bool> vals;
+	for (int i=1;i<=15;i++) {
+		for (int j=1;j<=15;j++) {
+			for (int k=1;k<=15;k++) {
+				if (i+j+k==15) {
+					std::string testStr;
+					int val1=i,val2=j,val3=k;
+					if (i<j&&i<k) {
+						val1=i;
+						if (j<k) {
+							val2=j;
+							val3=k;
+						} else {
+							val2=k;
+							val3=j;
 						}
 					}
-				}
-			}
-			for (int i = 0; i < list.size(); i++)
-			{
-				if (highlighted != i)
-				{
-					if (list[highlighted].pos.y < list[i].pos.y)
-					{
-						// it's above us
-						int dist = abs(list[highlighted].pos.y - list[i].pos.y);
-
-						if (dist < shortest)
-						{
-							targetItem = i;
-							shortest = dist;
+					if (j<i&&j<k) {
+						val1=j;
+						if (i<k) {
+							val2=i;
+							val3=k;
+						} else {
+							val2=k;
+							val3=i;
 						}
 					}
-				}
-			}
-
-			// it failed, try another method
-			if (highlighted == targetItem)
-			{
-				targetItem = 0;
-			}
-			highlighted = targetItem;
-		}
-
-//========================================================================================================================================
-		if (GetKey(olc::Key::UP).bPressed)
-		{
-			for (int i = 0; i < list.size(); i++)
-			{
-				if (highlighted != i)
-				{
-					if (list[highlighted].pos.x == list[i].pos.x)
-					{
-						if (list[highlighted].pos.y > list[i].pos.y)
-						{
-							// it's above us
-							int dist = abs(list[highlighted].pos.y - list[i].pos.y);
-
-							if (dist < shortest)
-							{
-								targetItem = i;
-								shortest = dist;
-							}
+					if (k<i&&k<j) {
+						val1=k;
+						if (i<j) {
+							val2=i;
+							val3=j;
+						} else {
+							val2=j;
+							val3=i;
 						}
 					}
-				}
-			}
-			for (int i = 0; i < list.size(); i++)
-			{
-				if (highlighted != i)
-				{
-					if (list[highlighted].pos.y > list[i].pos.y)
-					{
-						// it's below us
-						int dist = abs(list[highlighted].pos.y - list[i].pos.y);
-
-						if (dist < shortest)
-						{
-							targetItem = i;
-							shortest = dist;
-						}
+					if (!vals.count(std::to_string(val1)+"_"+std::to_string(val2)+"_"+std::to_string(val3))) {
+						std::cout<<std::to_string(val1)+"_"+std::to_string(val2)+"_"+std::to_string(val3)<<std::endl;
+						vals[std::to_string(val1)+"_"+std::to_string(val2)+"_"+std::to_string(val3)]=true;
 					}
 				}
 			}
-
-			// it failed, try another method
-			if (highlighted == targetItem)
-			{
-				targetItem = list.size() - 1;
-			}
-			highlighted = targetItem;
-		}
-
-//========================================================================================================================================
-		if (GetKey(olc::Key::RIGHT).bPressed)
-		{
-			for (int i = 0; i < list.size(); i++)
-			{
-				if (highlighted != i)
-				{
-					if (list[highlighted].pos.y == list[i].pos.y)
-					{
-						if (list[highlighted].pos.x < list[i].pos.x)
-						{
-							// it's to the right
-							int dist = abs(list[highlighted].pos.x - list[i].pos.x);
-
-							if (dist < shortest)
-							{
-								targetItem = i;
-								shortest = dist;
-							}
-						}
-					}
-				}
-			}
-			if (highlighted == targetItem)
-			{
-				for (int i = 0; i < list.size(); i++)
-				{
-					if (highlighted != i)
-					{
-						if (list[highlighted].pos.y == list[i].pos.y)
-						{
-							if (list[highlighted].pos.x > list[i].pos.x)
-							{
-								// it's to the left
-								int dist = abs(list[highlighted].pos.x - list[i].pos.x);
-
-								if (dist > largest)
-								{
-									targetItem = i;
-									largest = dist;
-								}
-							}
-						}
-					}
-				}
-			}
-			highlighted = targetItem;
-		}
-
-//========================================================================================================================================
-		if (GetKey(olc::Key::LEFT).bPressed)
-		{
-			for (int i = 0; i < list.size(); i++)
-			{
-				if (highlighted != i)
-				{
-					if (list[highlighted].pos.y == list[i].pos.y)
-					{
-						if (list[highlighted].pos.x > list[i].pos.x)
-						{
-							// it's to the right
-							int dist = abs(list[highlighted].pos.x - list[i].pos.x);
-
-							if (dist < shortest)
-							{
-								targetItem = i;
-								shortest = dist;
-							}
-						}
-					}
-				}
-			}
-			if (highlighted == targetItem)
-			{
-				for (int i = 0; i < list.size(); i++)
-				{
-					if (highlighted != i)
-					{
-						if (list[highlighted].pos.y == list[i].pos.y)
-						{
-							if (list[highlighted].pos.x < list[i].pos.x)
-							{
-								// it's to the left
-								int dist = abs(list[highlighted].pos.x - list[i].pos.x);
-
-								if (dist > largest)
-								{
-									targetItem = i;
-									largest = dist;
-								}
-							}
-						}
-					}
-				}
-			}
-			highlighted = targetItem;
-		}
-
-		//========================================
-		if (highlighted >= (int)list.size())
-		{
-			highlighted = 0;	// wrap around when above max
-		}
-		if (highlighted < 0)
-		{
-			highlighted = list.size() - 1;	// wrap around when below zero
-		}
-	}
-
-//========================================================================================================================================
-//		controls
-//========================================================================================================================================
-	void GetAnyKeyPress(olc::Key keypress) override
-	{
-		if (configKeyIndex != -1)
-		{
-			switch (configKeyIndex)
-			{
-			case 0:
-			{
-				Move_Up = keypress;
-			}break;
-			case 1:
-			{
-				Move_Right = keypress;
-			}break;
-			case 2:
-			{
-				Move_Left = keypress;
-			}break;
-			case 3:
-			{
-				Move_Down = keypress;
-			}break;
-			}
-			controls[configKeyIndex].label2 = KeyToString(keypress);
-			configKeyIndex = -1;
 		}
 	}
-
-//========================================================================================================================================
-//		Main Game Function
-//========================================================================================================================================
-	bool OnUserUpdate(float fElapsedTime) override
-	{
-		if (GetKey(olc::Key::CTRL).bHeld && GetKey(olc::Key::F12).bHeld && !bothKeysPressed)
-		{
-			return false;
-		}
-
-		// draw skybox
-		GradientFillRectDecal({ 0.0f, 0.0f }, { ScreenWidth() + 0.0f, ScreenHeight() / 2 + 0.0f }, olc::DARK_BLUE, olc::BLUE, olc::BLUE, olc::DARK_BLUE);
-		// the hills have eyes; y'know, like in Super Mario Bros. What reference did you think was going to be here?
-		DrawPartialDecal({ 0.0f, ScreenHeight() / 2 - 100.0f }, hill, { 0.0f + track_curve * 200, 0.0f }, { ScreenWidth() + 0.0f, (float)hill->sprite->height }, { 1.5f, 1.0f });
-		//DrawPartialDecal({ 180.0f, ScreenHeight() / 2 - 100.0f }, hill, { 0.0f + track_curve * 200, 0.0f }, { ScreenWidth() + 0.0f, (float)hill->sprite->height });
-		DrawPartialWarpedDecal	// draw grass
-		(
-			grass, { { 0.0f, ScreenHeight() / 2 + 0.0f },
-			{ -ScreenWidth() * 2 + 0.0f, ScreenHeight() + 0.0f},
-			{ ScreenWidth() * 2 + ScreenWidth() + 0.0f, ScreenHeight() + 0.0f },
-			{ ScreenWidth() + 0.0f, ScreenHeight() / 2 + 0.0f } },
-			{ 0.0f, -distance }, { 1 * 32, 4 * 64 }
-		);
-
-//========================================================================================================================================
-		if (gameState == state::MAIN_MENU)
-		{
-			FillRectDecal({ 0, 0 }, { ScreenWidth() + 0.f, ScreenHeight() + 0.f }, olc::Pixel(0, 0, 0, 16));
-			// display title
-			DrawDecal({ 95.5f, 95.5f }, title/*, {0.4f, 0.4f}*/);
-			DisplayMenu(mainMenu);
-			//DrawStringDecal({ ScreenWidth() / 2 + 0.0f, ScreenHeight() / 2 + 0.0f }, "START GAME", olc::WHITE, { 4.0f, 4.0f });
-
-			if (GetKey(olc::Key::ENTER).bPressed || GetKey(olc::Key::SPACE).bPressed)
-			{
-				// vertical menu
-				if (highlighted == 0)
-				{
-					gameState = state::PLAY_GAME;
-					highlighted = 0;
-				}
-				else if (highlighted == 1)
-				{
-					gameState = state::CONTROLS;
-					highlighted = 0;
-				}
-				else
-				{
-					return false;	// quit game
-				}
-			}
-			if (GetKey(olc::Key::ESCAPE).bPressed)
-			{
-				return false;	// exit via Escape key
-			}
-		}
-
-//========================================================================================================================================
-		else if (gameState == state::PLAY_GAME)
-		{
-			FillRectDecal({ 0, 0 }, { ScreenWidth() + 0.f, ScreenHeight() + 0.f }, olc::Pixel(0, 0, 0, 16));
-			DisplayMenu(playGame);
-			if (GetKey(olc::Key::ENTER).bPressed || GetKey(olc::Key::SPACE).bPressed)
-			{
-				// vertical menu
-				if (highlighted == 0)
-				{
-					gameState = state::TRACK_SELECT;
-					highlighted = 0;
-				}
-				else if (highlighted == 1)
-				{
-					gameState = state::CUP_SELECT;
-					highlighted = 0;
-				}
-				else
-				{
-					gameState = state::MAIN_MENU;	// return to menu
-					highlighted = 0;
-				}
-			}
-			if (GetKey(olc::Key::ESCAPE).bPressed || GetKey(olc::Key::BACK).bPressed)
-			{
-				gameState = state::MAIN_MENU;
-				highlighted = 0;
-			}
-		}
-
-//========================================================================================================================================
-		else if (gameState == state::TRACK_SELECT)
-		{
-			FillRectDecal({ 0, 0 }, { ScreenWidth() + 0.f, ScreenHeight() + 0.f }, olc::Pixel(0, 0, 0, 16));
-			DisplayMenu(pickTrack);
-			if (GetKey(olc::Key::ENTER).bPressed || GetKey(olc::Key::SPACE).bPressed)
-			{
-				if (highlighted >= 0 && highlighted <= 8)
-				{
-					track = highlighted + 1;
-					gameState = state::CAR_SELECT;
-					highlighted = 0;
-				}
-				else
-				{
-					gameState = state::PLAY_GAME;
-					highlighted = 0;
-					track = -1;
-				}
-			}
-			if (GetKey(olc::Key::CTRL).bHeld && GetKey(olc::Key::F9).bHeld)
-			{
-				// cheat code for Javidx9's original track
-				track = 0;
-				gameState = state::CAR_SELECT;
-			}
-			if (GetKey(olc::Key::ESCAPE).bPressed || GetKey(olc::Key::BACK).bPressed)
-			{
-				gameState = state::PLAY_GAME;
-				highlighted = 0;
-			}
-		}
-
-//========================================================================================================================================
-		else if (gameState == state::CUP_SELECT)
-		{
-			FillRectDecal({ 0, 0 }, { ScreenWidth() + 0.f, ScreenHeight() + 0.f }, olc::Pixel(0, 0, 0, 16));
-			DrawPartialDecal({ ScreenWidth() / 3 - 96.f, ScreenHeight() / 3 - 192.f }, cups, { 0, 0 }, { 64, 64 }, { 3.0f, 3.0f }, (highlighted == 0) ? olc::WHITE : olc::DARK_GREY);	// bronze
-			DrawPartialDecal({ ScreenWidth() / 3 * 2 - 96.f, ScreenHeight() / 3 - 192.f }, cups, { 64, 0 }, { 64, 64 }, { 3.0f, 3.0f }, (highlighted == 1) ? olc::WHITE : olc::DARK_GREY);		// silver
-			DrawPartialDecal({ ScreenWidth() / 3 - 96.f, ScreenHeight() / 3 * 2 - 192.f }, cups, { 0, 64 }, { 64, 64 }, { 3.0f, 3.0f }, (highlighted == 2) ? olc::WHITE : olc::DARK_GREY);		// gold
-			DrawPartialDecal({ ScreenWidth() / 3 * 2 - 96.f, ScreenHeight() / 3 * 2 - 192.f }, cups, { 64, 64 }, { 64, 64 }, { 3.0f, 3.0f }, (highlighted == 3) ? olc::WHITE : olc::DARK_GREY);	// platinum
-			DisplayMenu(grandPrix);
-
-			if (GetKey(olc::Key::ENTER).bPressed || GetKey(olc::Key::SPACE).bPressed)
-			{
-				// 2 x 2 menu
-				std::array<state, 4> gameStates = { state::INDIE, state::STREET, state::PRO, state::GRAND_PRIX };
-				if (highlighted >= 0 && highlighted <= 3)
-				{
-					gameState = gameStates[highlighted];
-					cup = highlighted + 1;
-					gameState = state::CAR_SELECT;
-					tracks_left = 3;
-					track = 1 + highlighted * 3;
-					if (highlighted == 3)
-					{
-						tracks_left = 9;
-					}
-					highlighted = 0;
-				}
-				//if (highlighted == 0)
-				//{
-				//	gameState = state::INDIE;
-				//	cup = 1;
-				//	gameState = state::CAR_SELECT;
-				//	highlighted = 0;
-				//}
-				//else if (highlighted == 1)
-				//{
-				//	gameState = state::STREET;
-				//	cup = 2;
-				//	gameState = state::CAR_SELECT;
-				//	highlighted = 0;
-				//}
-				//else if (highlighted == 2)
-				//{
-				//	gameState = state::PRO;
-				//	cup = 3;
-				//	gameState = state::CAR_SELECT;
-				//	highlighted = 0;
-				//}
-				//else if (highlighted == 3)
-				//{
-				//	gameState = state::GRAND_PRIX;
-				//	cup = 4;
-				//	gameState = state::CAR_SELECT;
-				//	highlighted = 0;
-				//}
-				else
-				{
-					gameState = state::PLAY_GAME;	// return to menu
-					cup = -1;
-					highlighted = 0;
-				}
-			}
-			if (GetKey(olc::Key::CTRL).bHeld && GetKey(olc::Key::F9).bHeld)
-			{
-				// cheat code for Javidx9 Grand Prix Cup
-				// add's Javid's track to the end of the standard Grand Prix
-				cup = 0;
-				gameState = state::CAR_SELECT;
-				tracks_left = 10;
-			}
-			if (GetKey(olc::Key::ESCAPE).bPressed || GetKey(olc::Key::BACK).bPressed)
-			{
-				gameState = state::PLAY_GAME;
-				cup = -1;
-				highlighted = 0;
-			}
-		}
-
-//========================================================================================================================================
-		else if (gameState == state::CAR_SELECT)
-		{
-			FillRectDecal({ 0, 0 }, { ScreenWidth() + 0.f, ScreenHeight() + 0.f }, olc::Pixel(0, 0, 0, 16));
-			DrawPartialDecal({ ScreenWidth() / 5 - 96.f, ScreenHeight() / 3 - 192.f }, cars, { 0, 0 }, { 256, 192}, { .75f, .75f }, (highlighted == 0) ? olc::WHITE : olc::DARK_GREY);	// red
-			DrawPartialDecal({ ScreenWidth() / 5 * 2 - 96.f, ScreenHeight() / 3 - 192.f }, cars, { 256, 0 }, { 256, 192 }, { .75f, .75f }, (highlighted == 1) ? olc::WHITE : olc::DARK_GREY);	// blue
-			DrawPartialDecal({ ScreenWidth() / 5 * 3 - 96.f, ScreenHeight() / 3 - 192.f }, cars, { 512, 0 }, { 256, 192 }, { .75f, .75f }, (highlighted == 2) ? olc::WHITE : olc::DARK_GREY);	// green
-			DrawPartialDecal({ ScreenWidth() / 5 * 4 - 96.f, ScreenHeight() / 3 - 192.f }, cars, { 768, 0 }, { 256, 192 }, { .75f, .75f }, (highlighted == 3) ? olc::WHITE : olc::DARK_GREY);	// gold
-			DrawPartialDecal({ ScreenWidth() / 5 - 96.f, ScreenHeight() / 3 * 2 - 192.f }, cars, { 0, 192 }, { 256, 192 }, { .75f, .75f }, (highlighted == 4) ? olc::WHITE : olc::DARK_GREY);	// purple
-			DrawPartialDecal({ ScreenWidth() / 5 * 2 - 96.f, ScreenHeight() / 3 * 2 - 192.f }, cars, { 256, 192 }, { 256, 192 }, { .75f, .75f }, (highlighted == 5) ? olc::WHITE : olc::DARK_GREY);	// white
-			DrawPartialDecal({ ScreenWidth() / 5 * 3 - 96.f, ScreenHeight() / 3 * 2 - 192.f }, cars, { 512, 192 }, { 256, 192 }, { .75f, .75f }, (highlighted == 6) ? olc::WHITE : olc::DARK_GREY);	// orange
-			DrawPartialDecal({ ScreenWidth() / 5 * 4 - 96.f, ScreenHeight() / 3 * 2 - 192.f }, cars, { 768, 192 }, { 256, 192 }, { .75f, .75f }, (highlighted == 7) ? olc::WHITE : olc::DARK_GREY);	// black
-
-			DisplayMenu(selectCar);
-			if (GetKey(olc::Key::ENTER).bPressed || GetKey(olc::Key::SPACE).bPressed)
-			{
-				if (highlighted >= 0 && highlighted <= 7)
-				{
-					player = highlighted;
-					gameState = state::RUN_GAME;
-
-					DrawTrack();
-					//vecTrack.clear();
-					//for (int i = 0; i < trackList[track].size(); i++)
-					//{
-					//	vecTrack.push_back(trackList[track][i]);
-					//	track_dist += vecTrack[i].second;
-					//}
-				}
-				else
-				{
-					if (cup != -1)
-					{
-						// return to cup select
-						gameState = state::CUP_SELECT;
-					}
-					if (track != -1)
-					{
-						// return to track select
-						gameState = state::TRACK_SELECT;
-					}
-					highlighted = 0;
-				}
-			}
-			if (GetKey(olc::Key::ESCAPE).bPressed || GetKey(olc::Key::BACK).bPressed)
-			{
-				if (cup != -1)
-				{
-					// return to cup select
-					gameState = state::CUP_SELECT;
-				}
-				if (track != -1)
-				{
-					// return to track select
-					gameState = state::TRACK_SELECT;
-				}
-				highlighted = 0;
-			}
-		}
-
-//========================================================================================================================================
-		else if (gameState == state::CONTROLS)
-		{
-			FillRectDecal({ 0, 0 }, { ScreenWidth() + 0.f, ScreenHeight() + 0.f }, olc::Pixel(0, 0, 0, 16));
-			DisplayMenu(controls);
-			if (GetKey(olc::Key::ENTER).bPressed || GetKey(olc::Key::SPACE).bPressed)
-			{
-				if (highlighted >= 0 && highlighted <= 3)
-				{
-					configKeyIndex = highlighted;
-				}
-				else if (highlighted == 4)
-				{
-					// reset default controls
-					DisplayMenu(controls);
-					Move_Up = olc::W;
-					Move_Down = olc::S;
-					Move_Left = olc::A;
-					Move_Right = olc::D;
-
-				}
-				else
-				{
-					gameState = state::MAIN_MENU;
-					highlighted = 0;
-				}
-			}
-			if (GetKey(olc::Key::ESCAPE).bPressed || GetKey(olc::Key::BACK).bPressed)
-			{
-				gameState = state::MAIN_MENU;
-			}
-		}
-
-//========================================================================================================================================
-		else if (gameState == state::PAUSED)	// pause menu
-		{
-			FillRectDecal({ 0, 0 }, { ScreenWidth() + 0.f, ScreenHeight() + 0.f }, olc::Pixel(0, 0, 0, 64));
-			DisplayMenu(pause);
-			if (GetKey(olc::Key::ENTER).bPressed || GetKey(olc::Key::SPACE).bPressed)
-			{
-				if (highlighted == 0)
-				{
-					gameState = state::RUN_GAME;
-					highlighted = 0;
-				}
-				if (highlighted == 1)
-				{
-					// restart the track
-					// this will ONLY work on tracks after the track selection screen
-					// or on the first track in each cup (1, 4, 7, 1)
-					Reset();
-					gameState = state::RUN_GAME;
-					highlighted = 0;
-				}
-				if (highlighted == 2)
-				{
-					// main menu
-					Reset();
-					gameState = state::MAIN_MENU;
-					highlighted = 0;
-				}
-				if (highlighted == 3)
-				{
-					return false;
-				}
-			}
-		}
-
-//========================================================================================================================================
-//========================================================================================================================================
-		else if (gameState == state::RUN_GAME)	// run main game loop
-		{
-			Clear(olc::BLACK);	// this still needed? we've since replaced it with the gradient sky box
-
-			if (GetKey(olc::Key::ESCAPE).bPressed || GetKey(olc::Key::PAUSE).bPressed)
-			{
-				gameState = state::PAUSED;
-			}
-
-			// debug quick-reset
-			if (GetKey(olc::Key::F4).bPressed)
-			{
-				Reset();
-			}
-
-			// jump to end of lap
-			if (GetKey(olc::Key::F12).bPressed)
-			{
-				distance = track_dist - 50.f;
-			}
-
-			// get a point on the track
-			float offset = 0;
-			int TrackSection = 0;
-
-			cur_lap_time += fElapsedTime;
-
-			// record lap time
-			if (distance >= track_dist)
-			{
-				distance -= track_dist;
-				list_times.push_front(cur_lap_time);	// push time to front
-				list_times.pop_back();	// pop time to back
-				cur_lap_time = 0.0f;
-				lap++;
-			}
-
-			if (cup >= 0 && lap >= 1)
-			{
-				track++;
-				Reset();
-				DrawTrack();
-			}
-
-			if (track != -1)
-			{
-				//olc::vi2d textSize = GetTextSize() / 2 * 4;
-				olc::vi2d textSize0 = GetTextSize("JAVIDX9") / 2 * 4;
-				olc::vi2d textSize1 = GetTextSize("CIRCUIT") / 2 * 4;
-
-				switch (track)
-				{
-				case 0:
-					DrawStringDecal({ ScreenWidth() / 2 - 0.f, ScreenHeight() / 8 + 0.f }, "JAVIDX9", olc::WHITE, { 3.f, 3.f });
-					break;
-				case 1:
-					DrawStringDecal({ ScreenWidth() / 2 - 0.f, ScreenHeight() / 8 + 0.f }, "CIRCUIT", olc::WHITE, { 3.f, 3.f });
-					break;
-				case 2:
-					DrawStringDecal({ ScreenWidth() / 2 - 0.f, ScreenHeight() / 8 + 0.f }, "INFINITY", olc::WHITE, { 3.f, 3.f });
-					break;
-				case 3:
-					DrawStringDecal({ ScreenWidth() / 2 - 0.f, ScreenHeight() / 8 + 0.f }, "ARROWHEAD", olc::WHITE, { 3.f, 3.f });
-					break;
-				case 4:
-					DrawStringDecal({ ScreenWidth() / 2 - 0.f, ScreenHeight() / 8 + 0.f }, "TRACK 4", olc::WHITE, { 3.f, 3.f });
-					break;
-				case 5:
-					DrawStringDecal({ ScreenWidth() / 2 - 0.f, ScreenHeight() / 8 + 0.f }, "OVERPASS", olc::WHITE, { 3.f, 3.f });
-					break;
-				case 6:
-					DrawStringDecal({ ScreenWidth() / 2 - 0.f, ScreenHeight() / 8 + 0.f }, "PEANUT", olc::WHITE, { 3.f, 3.f });
-					break;
-				case 7:
-					DrawStringDecal({ ScreenWidth() / 2 - 0.f, ScreenHeight() / 8 + 0.f }, "TRACK 7", olc::WHITE, { 3.f, 3.f });
-					break;
-				case 8:
-					DrawStringDecal({ ScreenWidth() / 2 - 0.f, ScreenHeight() / 8 + 0.f }, "TRIDENT", olc::WHITE, { 3.f, 3.f });
-					break;
-				case 9:
-					DrawStringDecal({ ScreenWidth() / 2 - 0.f, ScreenHeight() / 8 + 0.f }, "STAR", olc::WHITE, { 3.f, 3.f });
-					break;
-				}
-			}
-			
-			// find position on track (could optimize) << should probably optimize given the complexity of this game
-			while (TrackSection < vecTrack.size() && offset <= distance)
-			{
-				offset += vecTrack[TrackSection].second;
-				TrackSection++;
-			}
-
-			float TargetCurvature = vecTrack[TrackSection - 1].first;	// drawing curves to screen
-
-			float TrackCurveDiff = (TargetCurvature - curvature) * fElapsedTime * speed;	// correcting the drawing of curves to the screen
-			curvature += TrackCurveDiff;	// update track curve difference
-
-			track_curve += (curvature)*fElapsedTime * speed;
-
-//========================================================================================================================================
-//	|	|	draw racetrack canvas
-//========================================================================================================================================
-
-			std::vector<olc::vf2d> pos;
-			std::vector<olc::vf2d> uvs;
-			for (int y = 0; y < ScreenHeight() / 2; y++)
-			{
-				// racetrack canvas variables
-				float perspective = (float)y / (ScreenHeight() / 2.0f);
-
-				float mid_point = 0.5f + curvature * powf((1.0f - perspective), 3);
-				float road_width = 0.1f + perspective * 0.8f;
-				float curb_width = road_width * 0.15f;
-
-				road_width *= 0.5f;
-
-				int lf_curb = (mid_point - road_width) * ScreenWidth();
-				int rt_curb = (mid_point + road_width) * ScreenWidth();
-
-				int row = ScreenHeight() / 2 + y;
-
-				float horizon = powf(1.0f - perspective, 2) * 80;
-
-				// check for finish line
-				if (distance + horizon > track_dist - 20 && distance + horizon < track_dist)
-				{
-					// draw checkerboard pattern
-					uvs.push_back({ 0, (float)fmod(((distance + horizon) - (track_dist - 20)) / 20.0f, 0.5f) + 0.5f });
-					uvs.push_back({ 1, (float)fmod(((distance + horizon) - (track_dist - 20)) / 20.0f, 0.5f) + 0.5f });
-				}
-				else
-				{
-					// draw standard track piece
-					uvs.push_back({ 0, sinf(80.0f * powf(1.0f - perspective, 2) + distance) / 4 + 0.25f });
-					uvs.push_back({ 1, sinf(80.0f * powf(1.0f - perspective, 2) + distance) / 4 + 0.25f });
-				}
-
-				// drawing grass and curb
-				pos.push_back({ lf_curb + 0.0f, row + 0.0f });
-				pos.push_back({ rt_curb + 0.0f, row + 0.0f });
-
-				// black box rendering shenanigans; if I ever understand programming enough at a later date, I can figure out wtf is going on here
-				int i = 0;
-				for (Object& obj : gameObjects)
-				{
-					float horizonRange = powf(1.0f - perspective, 2) * ((distance + horizon) - obj.pos.y) / horizon;
-					if (!obj.rendered && (distance + horizon) > obj.pos.y && (distance + horizon) < obj.pos.y + 80 && row >= ScreenHeight() / 2 + ScreenHeight() / 2 * horizonRange)
-					{
-						obj.drawPos = { (mid_point + road_width * obj.pos.x) * ScreenWidth(), horizonRange * (ScreenHeight() / 2) + ScreenHeight() / 2 };
-						obj.drawOffsetPos = { obj.offset.x, obj.size.y * road_width * -obj.offset.y };
-						obj.drawSize = { obj.size.x * road_width, obj.size.y * road_width };
-						obj.rendered = true;
-
-						// yeah.... so, even after copying it manually, i still have no clue what this thing is doing, lol
-					}
-				}
-			}
-
-			// on the road again; drawing the track
-			SetDecalStructure(olc::DecalStructure::STRIP);
-			DrawPolygonDecal(road, pos, uvs);
-			SetDecalStructure(olc::DecalStructure::FAN);
-
-			// draw trackside props
-			for (Object& obj : gameObjects)
-			{
-				if (obj.rendered)
-				{
-					if (obj.decal != nullptr)
-					{
-						DrawDecal(obj.drawPos + obj.drawOffsetPos, obj.decal, obj.drawSize);
-					}
-					else
-					{
-						FillRectDecal(obj.drawPos, obj.drawSize, olc::BLUE);
-					}
-				}
-			}
-
-//========================================================================================================================================
-//	|	|	car movement
-//========================================================================================================================================
-			int car_dir = 0;	// default car facing
-
-			if (GetKey(Move_Up).bHeld)
-			{
-				speed += 2.0f * fElapsedTime;
-			}
-			else	// might remove this in a later stage of development
-			{
-				speed -= 1.0f * fElapsedTime;
-			}
-			if (GetKey(Move_Down).bHeld)
-			{
-				// move back ?
-				distance -= 20.0f * fElapsedTime;
-			}
-			if (GetKey(Move_Left).bHeld)
-			{
-				car_curve -= 0.7f * fElapsedTime;
-				car_dir = -1;
-			}
-			if (GetKey(Move_Right).bHeld)
-			{
-				car_curve += 0.7f * fElapsedTime;
-				car_dir = +1;
-			}
-
-			// slow car if on grass
-			if (fabs(car_curve - track_curve) >= 0.8f)
-			{
-				speed -= 5.0f * fElapsedTime;
-			}
-
-			// clamp speed
-			if (speed < 0.0f) speed = 0.0f;
-			if (speed > 1.0f) speed = 1.0f;
-
-			// move car along track according to car speed
-			distance += (70.0f * speed) * fElapsedTime;
-
-			// draw car
-			car_pos = car_curve - track_curve;
-			DrawDecal({ ScreenWidth() / 2 - 128 + car_pos * ScreenWidth() / 2, ScreenHeight() / 4 * 3.0f - 128 }, car);
-			SetPixelMode(olc::Pixel::ALPHA);
-
-//========================================================================================================================================
-//========================================================================================================================================
-			// spedometer
-			std::string mph = std::to_string(speed);
-			DrawString(4, 4, mph);
-
-			// show time
-			auto disp_time = [](float t)
-			{
-				int min = t / 60.0f;
-				int sec = t - (min * 60.0f);
-				int milli = (t - (float)sec) * 1000.0f;
-
-				// need to change this out to a 'DrawString()' function instead
-				return std::to_string(min) + "." + std::to_string(sec) + ":" + std::to_string(milli);
-			};
-
-			// correct for the first '0' in the seconds timer
-			//if ()
-			//{
-			//	// draw min + '0' + sec + milli
-			//	DrawString(4, 16, disp_time(cur_lap_time));
-			//}
-			//else
-			//{
-			DrawString(4, 16, disp_time(cur_lap_time));
-			//}
-
-			// display last 5 lap times
-			int j = 30;
-			for (auto l : list_times)
-			{
-				DrawString(10, j, disp_time(l));
-				j += 10;
-			}
-
-			// debug code
-			//std::string numb1 = std::to_string(car_pos);
-			//DrawString(4, 26, numb1);
-			//std::string numb2 = std::to_string(track_dist);
-			//DrawString(4, 38, numb2);
-		}
-
-		return true;
-	}
-};
-
-//========================================================================================================================================
-
-int main()
-{
-	std::vector<std::string> test= {"Apple","Apple","Pear","Something","Tire","Orange","Orange","Orange"};
-	std::vector<std::string>::iterator it = std::unique(test.begin(),test.end());
-	test.erase(it,test.end());
-	for (int i=0;i<test.size();i++) {
-		std::cout<<test[i]<<"\n";
-	}
-
-	Racer game;
-	if (game.Construct(1280, 720, 1, 1))
-		game.Start();
-
-	return 0;
-}
-
-//========================================================================================================================================
-//		END OF FILE
-//========================================================================================================================================
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/sig b/sig
index 65804b4..b30e9ff 100755
--- a/sig
+++ b/sig
@@ -3,7 +3,7 @@ export AUTO_UPDATE=true
 source utils/define.sh
 
 define PROJECT_NAME "C++ProjectTemplate"
-define CUSTOM_PARAMS "-std=c++17 -lX11 -lGL -lpthread -lpng -lstdc++fs -lpulse -lpulse-simple"
+define CUSTOM_PARAMS "-std=c++17 -lX11 -lGL -lpthread -lpng -lstdc++fs -lpulse -lpulse-simple -I/usr/include/lua5.3"
 define LANGUAGE "C++"
 
 source utils/main.sh
diff --git a/sol.hpp b/sol.hpp
new file mode 100644
index 0000000..01a508e
--- /dev/null
+++ b/sol.hpp
@@ -0,0 +1,28907 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 Rapptz, ThePhD and contributors
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// 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 OR
+// COPYRIGHT HOLDERS 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.
+
+// This file was generated with a script.
+// Generated 2022-10-23 03:24:40.159358 UTC
+// This header was generated with sol v3.3.0 (revision 0386513a)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_INCLUDE_HPP
+#define SOL_SINGLE_INCLUDE_HPP
+
+// beginning of sol/sol.hpp
+
+#ifndef SOL_HPP
+#define SOL_HPP
+
+// beginning of sol/version.hpp
+
+#include "config.hpp"
+
+#define SOL_VERSION_MAJOR 3
+#define SOL_VERSION_MINOR 2
+#define SOL_VERSION_PATCH 3
+#define SOL_VERSION_STRING "3.2.3"
+#define SOL_VERSION ((SOL_VERSION_MAJOR * 100000) + (SOL_VERSION_MINOR * 100) + (SOL_VERSION_PATCH))
+
+#define SOL_TOKEN_TO_STRING_POST_EXPANSION_I_(_TOKEN) #_TOKEN
+#define SOL_TOKEN_TO_STRING_I_(_TOKEN) SOL_TOKEN_TO_STRING_POST_EXPANSION_I_(_TOKEN)
+
+#define SOL_CONCAT_TOKENS_POST_EXPANSION_I_(_LEFT, _RIGHT) _LEFT##_RIGHT
+#define SOL_CONCAT_TOKENS_I_(_LEFT, _RIGHT) SOL_CONCAT_TOKENS_POST_EXPANSION_I_(_LEFT, _RIGHT)
+
+#define SOL_RAW_IS_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) != 0)
+#define SOL_RAW_IS_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3) == 0)
+#define SOL_RAW_IS_DEFAULT_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) > 3)
+#define SOL_RAW_IS_DEFAULT_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3 OP_SYMBOL 3) < 0)
+
+#define SOL_IS_ON(OP_SYMBOL) SOL_RAW_IS_ON(OP_SYMBOL ## _I_)
+#define SOL_IS_OFF(OP_SYMBOL) SOL_RAW_IS_OFF(OP_SYMBOL ## _I_)
+#define SOL_IS_DEFAULT_ON(OP_SYMBOL) SOL_RAW_IS_DEFAULT_ON(OP_SYMBOL ## _I_)
+#define SOL_IS_DEFAULT_OFF(OP_SYMBOL) SOL_RAW_IS_DEFAULT_OFF(OP_SYMBOL ## _I_)
+
+#define SOL_ON          |
+#define SOL_OFF         ^
+#define SOL_DEFAULT_ON  +
+#define SOL_DEFAULT_OFF -
+
+#if defined(SOL_BUILD_CXX_MODE)
+	#if (SOL_BUILD_CXX_MODE != 0)
+		#define SOL_BUILD_CXX_MODE_I_ SOL_ON
+	#else
+		#define SOL_BUILD_CXX_MODE_I_ SOL_OFF
+	#endif
+#elif defined(__cplusplus)
+	#define SOL_BUILD_CXX_MODE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_BUILD_CXX_MODE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_BUILD_C_MODE)
+	#if (SOL_BUILD_C_MODE != 0)
+		#define SOL_BUILD_C_MODE_I_ SOL_ON
+	#else
+		#define SOL_BUILD_C_MODE_I_ SOL_OFF
+	#endif
+#elif defined(__STDC__)
+	#define SOL_BUILD_C_MODE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_BUILD_C_MODE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SOL_IS_ON(SOL_BUILD_C_MODE)
+	#include <stddef.h>
+	#include <stdint.h>
+	#include <limits.h>
+#else
+	#include <cstddef>
+	#include <cstdint>
+	#include <climits>
+#endif
+
+#if defined(SOL_COMPILER_VCXX)
+	#if defined(SOL_COMPILER_VCXX != 0)
+		#define SOL_COMPILER_VCXX_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_VCXX_I_ SOL_OFF
+	#endif
+#elif defined(_MSC_VER)
+	#define SOL_COMPILER_VCXX_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_VCXX_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_GCC)
+	#if defined(SOL_COMPILER_GCC != 0)
+		#define SOL_COMPILER_GCC_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_GCC_I_ SOL_OFF
+	#endif
+#elif defined(__GNUC__)
+	#define SOL_COMPILER_GCC_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_GCC_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_CLANG)
+	#if defined(SOL_COMPILER_CLANG != 0)
+		#define SOL_COMPILER_CLANG_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_CLANG_I_ SOL_OFF
+	#endif
+#elif defined(__clang__)
+	#define SOL_COMPILER_CLANG_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_CLANG_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_EDG)
+	#if defined(SOL_COMPILER_EDG != 0)
+		#define SOL_COMPILER_EDG_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_EDG_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_COMPILER_EDG_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_MINGW)
+	#if (SOL_COMPILER_MINGW != 0)
+		#define SOL_COMPILER_MINGW_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_MINGW_I_ SOL_OFF
+	#endif
+#elif defined(__MINGW32__)
+	#define SOL_COMPILER_MINGW_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_MINGW_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SIZE_MAX <= 0xFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_ON
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#elif SIZE_MAX <= 0xFFFFFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_ON
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#else
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_ON
+#endif
+
+#define SOL_PLATFORM_ARM32_I_ SOL_OFF
+#define SOL_PLATFORM_ARM64_I_ SOL_OFF
+
+#if defined(SOL_PLATFORM_WINDOWS)
+	#if (SOL_PLATFORM_WINDOWS != 0)
+		#define SOL_PLATFORM_WINDOWS_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_WINDOWS_I_ SOL_OFF
+	#endif
+#elif defined(_WIN32)
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_CYGWIN)
+	#if (SOL_PLATFORM_CYGWIN != 0)
+		#define SOL_PLATFORM_CYGWIN_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_CYGWIN_I_ SOL_ON
+	#endif
+#elif defined(__CYGWIN__)
+	#define SOL_PLATFORM_CYGWIN_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_CYGWIN_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_APPLE)
+	#if (SOL_PLATFORM_APPLE != 0)
+		#define SOL_PLATFORM_APPLE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_APPLE_I_ SOL_OFF
+	#endif
+#elif defined(__APPLE__)
+	#define SOL_PLATFORM_APPLE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_APPLE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_UNIX)
+	#if (SOL_PLATFORM_UNIX != 0)
+		#define SOL_PLATFORM_UNIXLIKE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_UNIXLIKE_I_ SOL_OFF
+	#endif
+#elif defined(__unix__)
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_DEFAUKT_ON
+#else
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_LINUX)
+	#if (SOL_PLATFORM_LINUX != 0)
+		#define SOL_PLATFORM_LINUXLIKE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_LINUXLIKE_I_ SOL_OFF
+	#endif
+#elif defined(__LINUX__)
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_DEFAUKT_ON
+#else
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_DEFAULT_OFF
+#endif
+
+#define SOL_PLATFORM_APPLE_IPHONE_I_ SOL_OFF
+#define SOL_PLATFORM_BSDLIKE_I_      SOL_OFF
+
+#if defined(SOL_IN_DEBUG_DETECTED)
+	#if SOL_IN_DEBUG_DETECTED != 0
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#elif !defined(NDEBUG)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX) && defined(_DEBUG)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#elif (SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)) && !defined(__OPTIMIZE__)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEBUG_BUILD_I_ SOL_DEFAULT_OFF
+#endif // We are in a debug mode of some sort
+
+#if defined(SOL_NO_EXCEPTIONS)
+	#if (SOL_NO_EXCEPTIONS != 0)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	#if !defined(_CPPUNWIND)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)
+	#if !defined(__EXCEPTIONS)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#else
+	#define SOL_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_RTTI)
+	#if (SOL_NO_RTTI != 0)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	#if !defined(_CPPRTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)
+	#if !defined(__GXX_RTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#else
+	#define SOL_RTTI_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_THREAD_LOCAL)
+	#if SOL_NO_THREAD_LOCAL != 0
+		#define SOL_USE_THREAD_LOCAL_I_ SOL_OFF
+	#else
+		#define SOL_USE_THREAD_LOCAL_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_THREAD_LOCAL_I_ SOL_DEFAULT_ON
+#endif // thread_local keyword is bjorked on some platforms
+
+#if defined(SOL_ALL_SAFETIES_ON)
+	#if SOL_ALL_SAFETIES_ON != 0
+		#define SOL_ALL_SAFETIES_ON_I_ SOL_ON
+	#else
+		#define SOL_ALL_SAFETIES_ON_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_ALL_SAFETIES_ON_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_GETTER)
+	#if SOL_SAFE_GETTER != 0
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_USERTYPE)
+	#if SOL_SAFE_USERTYPE != 0
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_REFERENCES)
+	#if SOL_SAFE_REFERENCES != 0
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTIONS)
+	#if SOL_SAFE_FUNCTIONS != 0
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_OFF
+	#endif
+#elif defined (SOL_SAFE_FUNCTION_OBJECTS)
+	#if SOL_SAFE_FUNCTION_OBJECTS != 0
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTION_CALLS)
+	#if SOL_SAFE_FUNCTION_CALLS != 0
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_PROXIES)
+	#if SOL_SAFE_PROXIES != 0
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_NUMERICS)
+	#if SOL_SAFE_NUMERICS != 0
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_ALL_INTEGER_VALUES_FIT)
+	#if (SOL_ALL_INTEGER_VALUES_FIT != 0)
+		#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_ON
+	#else
+		#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_OFF
+	#endif
+#elif !SOL_IS_DEFAULT_OFF(SOL_SAFE_NUMERICS) && SOL_IS_OFF(SOL_SAFE_NUMERICS)
+	// if numerics is intentionally turned off, flip this on
+	#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_DEFAULT_ON
+#else
+	// default to off
+	#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_STACK_CHECK)
+	#if SOL_SAFE_STACK_CHECK != 0
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_CHECK_NUMBER_PRECISION)
+	#if SOL_NO_CHECK_NUMBER_PRECISION != 0
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#endif
+#elif defined(SOL_NO_CHECKING_NUMBER_PRECISION)
+	#if SOL_NO_CHECKING_NUMBER_PRECISION != 0
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_SAFE_NUMERICS)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_STRINGS_ARE_NUMBERS)
+	#if (SOL_STRINGS_ARE_NUMBERS != 0)
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_ON
+	#else
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_ENABLE_INTEROP)
+	#if SOL_ENABLE_INTEROP != 0
+		#define SOL_USE_INTEROP_I_ SOL_ON
+	#else
+		#define SOL_USE_INTEROP_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_INTEROP)
+	#if SOL_USE_INTEROP != 0
+		#define SOL_USE_INTEROP_I_ SOL_ON
+	#else
+		#define SOL_USE_INTEROP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_INTEROP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_NIL)
+	#if (SOL_NO_NIL != 0)
+		#define SOL_NIL_I_ SOL_OFF
+	#else
+		#define SOL_NIL_I_ SOL_ON
+	#endif
+#elif defined(__MAC_OS_X_VERSION_MAX_ALLOWED) || defined(__OBJC__) || defined(nil)
+	#define SOL_NIL_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_NIL_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USERTYPE_TYPE_BINDING_INFO)
+	#if (SOL_USERTYPE_TYPE_BINDING_INFO != 0)
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_ON
+	#else
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_DEFAULT_ON
+#endif // We should generate a my_type.__type table with lots of class information for usertypes
+
+#if defined(SOL_AUTOMAGICAL_TYPES_BY_DEFAULT)
+	#if (SOL_AUTOMAGICAL_TYPES_BY_DEFAULT != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#elif defined(SOL_DEFAULT_AUTOMAGICAL_USERTYPES)
+	#if (SOL_DEFAULT_AUTOMAGICAL_USERTYPES != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_DEFAULT_ON
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_STD_VARIANT)
+	#if (SOL_STD_VARIANT != 0)
+		#define SOL_STD_VARIANT_I_ SOL_ON
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_COMPILER_CLANG) && SOL_IS_ON(SOL_PLATFORM_APPLE)
+		#if defined(__has_include)
+			#if __has_include(<variant>)
+				#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+			#else
+				#define SOL_STD_VARIANT_I_ SOL_DEFAULT_OFF
+			#endif
+		#else
+			#define SOL_STD_VARIANT_I_ SOL_DEFAULT_OFF
+		#endif
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+	#endif
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_NOEXCEPT_FUNCTION_TYPE)
+	#if (SOL_NOEXCEPT_FUNCTION_TYPE != 0)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_noexcept_function_type)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_COMPILER_VCXX) && (defined(_MSVC_LANG) && (_MSVC_LANG < 201403L))
+		// There is a bug in the VC++ compiler??
+		// on /std:c++latest under x86 conditions (VS 15.5.2),
+		// compiler errors are tossed for noexcept markings being on function types
+		// that are identical in every other way to their non-noexcept marked types function types...
+		// VS 2019: There is absolutely a bug.
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_DEFAULT_ON
+	#endif
+#endif // noexcept is part of a function's type
+
+#if defined(SOL_STACK_STRING_OPTIMIZATION_SIZE) && SOL_STACK_STRING_OPTIMIZATION_SIZE > 0
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ SOL_STACK_STRING_OPTIMIZATION_SIZE
+#else
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ 1024
+#endif
+
+#if defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_ID_SIZE_I_ SOL_ID_SIZE
+#else
+	#define SOL_ID_SIZE_I_ 512
+#endif
+
+#if defined(LUA_IDSIZE) && LUA_IDSIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ LUA_IDSIZE
+#elif defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ SOL_FILE_ID_SIZE
+#else
+	#define SOL_FILE_ID_SIZE_I_ 2048
+#endif
+
+#if defined(SOL_PRINT_ERRORS)
+	#if (SOL_PRINT_ERRORS != 0)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_PRINT_ERRORS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#endif
+
+#if defined(SOL_DEFAULT_PASS_ON_ERROR)
+	#if (SOL_DEFAULT_PASS_ON_ERROR != 0)
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUA)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUA)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUA_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUAJIT)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUAJIT)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUAJIT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_LUA_HPP)
+	#if (SOL_NO_LUA_HPP != 0)
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#endif
+#elif defined(SOL_USING_CXX_LUA)
+	#define SOL_USE_LUA_HPP_I_ SOL_OFF
+#elif defined(__has_include)
+	#if __has_include(<lua.hpp>)
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_LUA_HPP_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_CONTAINERS_START)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START
+#elif defined(SOL_CONTAINERS_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START_INDEX
+#elif defined(SOL_CONTAINER_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINER_START_INDEX
+#else
+	#define SOL_CONTAINER_START_INDEX_I_ 1
+#endif
+
+#if defined (SOL_NO_MEMORY_ALIGNMENT)
+	#if (SOL_NO_MEMORY_ALIGNMENT != 0)
+		#define SOL_ALIGN_MEMORY_I_ SOL_OFF
+	#else
+		#define SOL_ALIGN_MEMORY_I_ SOL_ON
+	#endif
+#else
+	#define SOL_ALIGN_MEMORY_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USE_BOOST)
+	#if (SOL_USE_BOOST != 0)
+		#define SOL_USE_BOOST_I_ SOL_ON
+	#else
+		#define SOL_USE_BOOST_I_ SOL_OFF
+	#endif
+#else
+		#define SOL_USE_BOOST_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USE_UNSAFE_BASE_LOOKUP)
+	#if (SOL_USE_UNSAFE_BASE_LOOKUP != 0)
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_ON
+	#else
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_INSIDE_UNREAL)
+	#if (SOL_INSIDE_UNREAL != 0)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(UE_BUILD_DEBUG) || defined(UE_BUILD_DEVELOPMENT) || defined(UE_BUILD_TEST) || defined(UE_BUILD_SHIPPING) || defined(UE_SERVER)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_COMPAT)
+	#if (SOL_NO_COMPAT != 0)
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_OFF
+	#else
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_GET_FUNCTION_POINTER_UNSAFE)
+	#if (SOL_GET_FUNCTION_POINTER_UNSAFE != 0)
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_ON
+	#else
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
+	#if (SOL_FUNCTION_CALL_VALUE_SEMANTICS != 0)
+		#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_ON
+	#else
+		#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_MINGW_CCTYPE_IS_POISONED)
+	#if (SOL_MINGW_CCTYPE_IS_POISONED != 0)
+		#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_ON
+	#else
+		#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_MINGW) && defined(__GNUC__) && (__GNUC__ < 6)
+	// MinGW is off its rocker in some places...
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_CHAR8_T)
+	#if (SOL_CHAR8_T != 0)
+		#define SOL_CHAR8_T_I_ SOL_ON
+	#else
+		#define SOL_CHAR8_T_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_char8_t)
+		#define SOL_CHAR8_T_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_CHAR8_T_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+	#include <boost/version.hpp>
+
+	#if BOOST_VERSION >= 107500 // Since Boost 1.75.0 boost::none is constexpr
+		#define SOL_BOOST_NONE_CONSTEXPR_I_ constexpr
+	#else
+		#define SOL_BOOST_NONE_CONSTEXPR_I_ const
+	#endif // BOOST_VERSION
+#else
+	// assume boost isn't using a garbage version
+	#define SOL_BOOST_NONE_CONSTEXPR_I_ constexpr
+#endif
+
+#if defined(SOL2_CI)
+	#if (SOL2_CI != 0)
+		#define SOL2_CI_I_ SOL_ON
+	#else
+		#define SOL2_CI_I_ SOL_OFF
+	#endif
+#else
+	#define SOL2_CI_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_C_ASSERT)
+	#define SOL_USER_C_ASSERT_I_ SOL_ON
+#else
+	#define SOL_USER_C_ASSERT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_M_ASSERT)
+	#define SOL_USER_M_ASSERT_I_ SOL_ON
+#else
+	#define SOL_USER_M_ASSERT_I_ SOL_DEFAULT_OFF
+#endif
+
+// beginning of sol/prologue.hpp
+
+#if defined(SOL_PROLOGUE_I_)
+	#error "[sol2] Library Prologue was already included in translation unit and not properly ended with an epilogue."
+#endif
+
+#define SOL_PROLOGUE_I_ 1
+
+#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+	#define _FWD(...) static_cast<decltype( __VA_ARGS__ )&&>( __VA_ARGS__ )
+
+	#if SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define _MOVE(...) static_cast<__typeof( __VA_ARGS__ )&&>( __VA_ARGS__ )
+	#else
+		#include <type_traits>
+		
+		#define _MOVE(...) static_cast<::std::remove_reference_t<( __VA_ARGS__ )>&&>( __VA_OPT__(,) )
+	#endif
+#endif
+
+// end of sol/prologue.hpp
+
+// beginning of sol/epilogue.hpp
+
+#if !defined(SOL_PROLOGUE_I_)
+	#error "[sol2] Library Prologue is missing from this translation unit."
+#else
+	#undef SOL_PROLOGUE_I_
+#endif
+
+#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+	#undef _FWD
+	#undef _MOVE
+#endif
+
+// end of sol/epilogue.hpp
+
+// beginning of sol/detail/build_version.hpp
+
+#if defined(SOL_DLL)
+	#if (SOL_DLL != 0)
+		#define SOL_DLL_I_ SOL_ON
+	#else
+		#define SOL_DLL_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX) && (defined(DLL_) || defined(_DLL))
+	#define SOL_DLL_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_DLL_I_ SOL_DEFAULT_OFF
+#endif // DLL definition
+
+#if defined(SOL_HEADER_ONLY)
+	#if (SOL_HEADER_ONLY != 0)
+		#define SOL_HEADER_ONLY_I_ SOL_ON
+	#else
+		#define SOL_HEADER_ONLY_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_HEADER_ONLY_I_ SOL_DEFAULT_OFF
+#endif // Header only library
+
+#if defined(SOL_BUILD)
+	#if (SOL_BUILD != 0)
+		#define SOL_BUILD_I_ SOL_ON
+	#else
+		#define SOL_BUILD_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_BUILD_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_BUILD_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_UNITY_BUILD)
+	#if (SOL_UNITY_BUILD != 0)
+		#define SOL_UNITY_BUILD_I_ SOL_ON
+	#else
+		#define SOL_UNITY_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_UNITY_BUILD_I_ SOL_DEFAULT_OFF
+#endif // Header only library
+
+#if defined(SOL_C_FUNCTION_LINKAGE)
+	#define SOL_C_FUNCTION_LINKAGE_I_ SOL_C_FUNCTION_LINKAGE
+#else
+	#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+		// C++
+		#define SOL_C_FUNCTION_LINKAGE_I_ extern "C"
+	#else
+		// normal
+		#define SOL_C_FUNCTION_LINKAGE_I_
+	#endif // C++ or not
+#endif // Linkage specification for C functions
+
+#if defined(SOL_API_LINKAGE)
+	#define SOL_API_LINKAGE_I_ SOL_API_LINKAGE
+#else
+	#if SOL_IS_ON(SOL_DLL)
+		#if SOL_IS_ON(SOL_COMPILER_VCXX) || SOL_IS_ON(SOL_PLATFORM_WINDOWS) || SOL_IS_ON(SOL_PLATFORM_CYGWIN)
+			// MSVC Compiler; or, Windows, or Cygwin platforms
+			#if SOL_IS_ON(SOL_BUILD)
+				// Building the library
+				#if SOL_IS_ON(SOL_COMPILER_GCC)
+					// Using GCC
+					#define SOL_API_LINKAGE_I_ __attribute__((dllexport))
+				#else
+					// Using Clang, MSVC, etc...
+					#define SOL_API_LINKAGE_I_ __declspec(dllexport)
+				#endif
+			#else
+				#if SOL_IS_ON(SOL_COMPILER_GCC)
+					#define SOL_API_LINKAGE_I_ __attribute__((dllimport))
+				#else
+					#define SOL_API_LINKAGE_I_ __declspec(dllimport)
+				#endif
+			#endif
+		#else
+			// extern if building normally on non-MSVC
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#elif SOL_IS_ON(SOL_UNITY_BUILD)
+		// Built-in library, like how stb typical works
+		#if SOL_IS_ON(SOL_HEADER_ONLY)
+			// Header only, so functions are defined "inline"
+			#define SOL_API_LINKAGE_I_ inline
+		#else
+			// Not header only, so seperately compiled files
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#else
+		// Normal static library
+		#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+			#define SOL_API_LINKAGE_I_
+		#else
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#endif // DLL or not
+#endif // Build definitions
+
+#if defined(SOL_PUBLIC_FUNC_DECL)
+	#define SOL_PUBLIC_FUNC_DECL_I_ SOL_PUBLIC_FUNC_DECL
+#else
+	#define SOL_PUBLIC_FUNC_DECL_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_INTERNAL_FUNC_DECL_)
+	#define SOL_INTERNAL_FUNC_DECL_I_ SOL_INTERNAL_FUNC_DECL_
+#else
+	#define SOL_INTERNAL_FUNC_DECL_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_PUBLIC_FUNC_DEF)
+	#define SOL_PUBLIC_FUNC_DEF_I_ SOL_PUBLIC_FUNC_DEF
+#else
+	#define SOL_PUBLIC_FUNC_DEF_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_INTERNAL_FUNC_DEF)
+	#define SOL_INTERNAL_FUNC_DEF_I_ SOL_INTERNAL_FUNC_DEF
+#else
+	#define SOL_INTERNAL_FUNC_DEF_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_FUNC_DECL)
+	#define SOL_FUNC_DECL_I_ SOL_FUNC_DECL
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_FUNC_DECL_I_ 
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_FUNC_DECL_I_ extern __declspec(dllexport)
+		#else
+			#define SOL_FUNC_DECL_I_ extern __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_FUNC_DECL_I_ extern __attribute__((visibility("default")))
+	#else
+		#define SOL_FUNC_DECL_I_ extern
+	#endif
+#endif
+
+#if defined(SOL_FUNC_DEFN)
+	#define SOL_FUNC_DEFN_I_ SOL_FUNC_DEFN
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_FUNC_DEFN_I_ inline
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_FUNC_DEFN_I_ __declspec(dllexport)
+		#else
+			#define SOL_FUNC_DEFN_I_ __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_FUNC_DEFN_I_ __attribute__((visibility("default")))
+	#else
+		#define SOL_FUNC_DEFN_I_
+	#endif
+#endif
+
+#if defined(SOL_HIDDEN_FUNC_DECL)
+	#define SOL_HIDDEN_FUNC_DECL_I_ SOL_HIDDEN_FUNC_DECL
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_HIDDEN_FUNC_DECL_I_ 
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllexport)
+		#else
+			#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_HIDDEN_FUNC_DECL_I_ extern __attribute__((visibility("default")))
+	#else
+		#define SOL_HIDDEN_FUNC_DECL_I_ extern
+	#endif
+#endif
+
+#if defined(SOL_HIDDEN_FUNC_DEFN)
+	#define SOL_HIDDEN_FUNC_DEFN_I_ SOL_HIDDEN_FUNC_DEFN
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_HIDDEN_FUNC_DEFN_I_ inline
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_HIDDEN_FUNC_DEFN_I_ 
+		#else
+			#define SOL_HIDDEN_FUNC_DEFN_I_ 
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_HIDDEN_FUNC_DEFN_I_ __attribute__((visibility("hidden")))
+	#else
+		#define SOL_HIDDEN_FUNC_DEFN_I_
+	#endif
+#endif
+
+// end of sol/detail/build_version.hpp
+
+// end of sol/version.hpp
+
+#if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE)
+#ifdef check
+#pragma push_macro("check")
+#undef check
+#endif
+#endif // Unreal Engine 4 Bullshit
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#pragma GCC diagnostic ignored "-Wconversion"
+#if __GNUC__ > 6
+#pragma GCC diagnostic ignored "-Wnoexcept-type"
+#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG)
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+#pragma warning(push)
+#pragma warning(disable : 4505) // unreferenced local function has been removed GEE THANKS
+#endif                          // clang++ vs. g++ vs. VC++
+
+// beginning of sol/forward.hpp
+
+#ifndef SOL_FORWARD_HPP
+#define SOL_FORWARD_HPP
+
+#include <utility>
+#include <type_traits>
+#include <string_view>
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA) || SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+struct lua_State;
+#else
+extern "C" {
+struct lua_State;
+}
+#endif // C++ Mangling for Lua vs. Not
+
+namespace sol {
+
+	enum class type;
+
+	class stateless_reference;
+	template <bool b>
+	class basic_reference;
+	using reference = basic_reference<false>;
+	using main_reference = basic_reference<true>;
+	class stateless_stack_reference;
+	class stack_reference;
+
+	template <typename A>
+	class basic_bytecode;
+
+	struct lua_value;
+
+	struct proxy_base_tag;
+	template <typename>
+	struct proxy_base;
+	template <typename, typename>
+	struct table_proxy;
+
+	template <bool, typename>
+	class basic_table_core;
+	template <bool b>
+	using table_core = basic_table_core<b, reference>;
+	template <bool b>
+	using main_table_core = basic_table_core<b, main_reference>;
+	template <bool b>
+	using stack_table_core = basic_table_core<b, stack_reference>;
+	template <typename base_type>
+	using basic_table = basic_table_core<false, base_type>;
+	using table = table_core<false>;
+	using global_table = table_core<true>;
+	using main_table = main_table_core<false>;
+	using main_global_table = main_table_core<true>;
+	using stack_table = stack_table_core<false>;
+	using stack_global_table = stack_table_core<true>;
+
+	template <typename>
+	struct basic_lua_table;
+	using lua_table = basic_lua_table<reference>;
+	using stack_lua_table = basic_lua_table<stack_reference>;
+
+	template <typename T, typename base_type>
+	class basic_usertype;
+	template <typename T>
+	using usertype = basic_usertype<T, reference>;
+	template <typename T>
+	using stack_usertype = basic_usertype<T, stack_reference>;
+
+	template <typename base_type>
+	class basic_metatable;
+	using metatable = basic_metatable<reference>;
+	using stack_metatable = basic_metatable<stack_reference>;
+
+	template <typename base_t>
+	struct basic_environment;
+	using environment = basic_environment<reference>;
+	using main_environment = basic_environment<main_reference>;
+	using stack_environment = basic_environment<stack_reference>;
+
+	template <typename T, bool>
+	class basic_function;
+	template <typename T, bool, typename H>
+	class basic_protected_function;
+	using unsafe_function = basic_function<reference, false>;
+	using safe_function = basic_protected_function<reference, false, reference>;
+	using main_unsafe_function = basic_function<main_reference, false>;
+	using main_safe_function = basic_protected_function<main_reference, false, reference>;
+	using stack_unsafe_function = basic_function<stack_reference, false>;
+	using stack_safe_function = basic_protected_function<stack_reference, false, reference>;
+	using stack_aligned_unsafe_function = basic_function<stack_reference, true>;
+	using stack_aligned_safe_function = basic_protected_function<stack_reference, true, reference>;
+	using protected_function = safe_function;
+	using main_protected_function = main_safe_function;
+	using stack_protected_function = stack_safe_function;
+	using stack_aligned_protected_function = stack_aligned_safe_function;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+	using function = protected_function;
+	using main_function = main_protected_function;
+	using stack_function = stack_protected_function;
+	using stack_aligned_function = stack_aligned_safe_function;
+#else
+	using function = unsafe_function;
+	using main_function = main_unsafe_function;
+	using stack_function = stack_unsafe_function;
+	using stack_aligned_function = stack_aligned_unsafe_function;
+#endif
+	using stack_aligned_stack_handler_function = basic_protected_function<stack_reference, true, stack_reference>;
+
+	struct unsafe_function_result;
+	struct protected_function_result;
+	using safe_function_result = protected_function_result;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+	using function_result = safe_function_result;
+#else
+	using function_result = unsafe_function_result;
+#endif
+
+	template <typename base_t>
+	class basic_object_base;
+	template <typename base_t>
+	class basic_object;
+	template <typename base_t>
+	class basic_userdata;
+	template <typename base_t>
+	class basic_lightuserdata;
+	template <typename base_t>
+	class basic_coroutine;
+	template <typename base_t>
+	class basic_packaged_coroutine;
+	template <typename base_t>
+	class basic_thread;
+
+	using object = basic_object<reference>;
+	using userdata = basic_userdata<reference>;
+	using lightuserdata = basic_lightuserdata<reference>;
+	using thread = basic_thread<reference>;
+	using coroutine = basic_coroutine<reference>;
+	using packaged_coroutine = basic_packaged_coroutine<reference>;
+	using main_object = basic_object<main_reference>;
+	using main_userdata = basic_userdata<main_reference>;
+	using main_lightuserdata = basic_lightuserdata<main_reference>;
+	using main_coroutine = basic_coroutine<main_reference>;
+	using stack_object = basic_object<stack_reference>;
+	using stack_userdata = basic_userdata<stack_reference>;
+	using stack_lightuserdata = basic_lightuserdata<stack_reference>;
+	using stack_thread = basic_thread<stack_reference>;
+	using stack_coroutine = basic_coroutine<stack_reference>;
+
+	struct stack_proxy_base;
+	struct stack_proxy;
+	struct variadic_args;
+	struct variadic_results;
+	struct stack_count;
+	struct this_state;
+	struct this_main_state;
+	struct this_environment;
+
+	class state_view;
+	class state;
+
+	template <typename T>
+	struct as_table_t;
+	template <typename T>
+	struct as_container_t;
+	template <typename T>
+	struct nested;
+	template <typename T>
+	struct light;
+	template <typename T>
+	struct user;
+	template <typename T>
+	struct as_args_t;
+	template <typename T>
+	struct protect_t;
+	template <typename F, typename... Policies>
+	struct policy_wrapper;
+
+	template <typename T>
+	struct usertype_traits;
+	template <typename T>
+	struct unique_usertype_traits;
+
+	template <typename... Args>
+	struct types {
+		typedef std::make_index_sequence<sizeof...(Args)> indices;
+		static constexpr std::size_t size() {
+			return sizeof...(Args);
+		}
+	};
+
+	template <typename T>
+	struct derive : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct base : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct weak_derive {
+		static bool value;
+	};
+
+	template <typename T>
+	bool weak_derive<T>::value = false;
+
+	namespace stack {
+		struct record;
+	}
+
+#if SOL_IS_OFF(SOL_USE_BOOST)
+	template <class T>
+	class optional;
+
+	template <class T>
+	class optional<T&>;
+#endif
+
+	using check_handler_type = int(lua_State*, int, type, type, const char*);
+
+} // namespace sol
+
+#define SOL_BASE_CLASSES(T, ...)                       \
+	namespace sol {                                   \
+		template <>                                  \
+		struct base<T> : std::true_type {            \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+#define SOL_DERIVED_CLASSES(T, ...)                    \
+	namespace sol {                                   \
+		template <>                                  \
+		struct derive<T> : std::true_type {          \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+
+#endif // SOL_FORWARD_HPP
+// end of sol/forward.hpp
+
+// beginning of sol/forward_detail.hpp
+
+#ifndef SOL_FORWARD_DETAIL_HPP
+#define SOL_FORWARD_DETAIL_HPP
+
+// beginning of sol/traits.hpp
+
+// beginning of sol/tuple.hpp
+
+// beginning of sol/base_traits.hpp
+
+#include <type_traits>
+
+namespace sol {
+	namespace detail {
+		struct unchecked_t { };
+		const unchecked_t unchecked = unchecked_t {};
+	} // namespace detail
+
+	namespace meta {
+		using sfinae_yes_t = std::true_type;
+		using sfinae_no_t = std::false_type;
+
+		template <typename...>
+		using void_t = void;
+
+		template <typename T>
+		using unqualified = std::remove_cv<std::remove_reference_t<T>>;
+
+		template <typename T>
+		using unqualified_t = typename unqualified<T>::type;
+
+		namespace meta_detail {
+			template <typename T>
+			struct unqualified_non_alias : unqualified<T> { };
+
+			template <template <class...> class Test, class, class... Args>
+			struct is_detected : std::false_type { };
+
+			template <template <class...> class Test, class... Args>
+			struct is_detected<Test, void_t<Test<Args...>>, Args...> : std::true_type { };
+		} // namespace meta_detail
+
+		template <template <class...> class Trait, class... Args>
+		using is_detected = typename meta_detail::is_detected<Trait, void, Args...>::type;
+
+		template <template <class...> class Trait, class... Args>
+		constexpr inline bool is_detected_v = is_detected<Trait, Args...>::value;
+
+		template <std::size_t I>
+		using index_value = std::integral_constant<std::size_t, I>;
+
+		template <bool>
+		struct conditional {
+			template <typename T, typename U>
+			using type = T;
+		};
+
+		template <>
+		struct conditional<false> {
+			template <typename T, typename U>
+			using type = U;
+		};
+
+		template <bool B, typename T, typename U>
+		using conditional_t = typename conditional<B>::template type<T, U>;
+
+		namespace meta_detail {
+			template <typename T, template <typename...> class Templ>
+			struct is_specialization_of : std::false_type { };
+			template <typename... T, template <typename...> class Templ>
+			struct is_specialization_of<Templ<T...>, Templ> : std::true_type { };
+		} // namespace meta_detail
+
+		template <typename T, template <typename...> class Templ>
+		using is_specialization_of = meta_detail::is_specialization_of<std::remove_cv_t<T>, Templ>;
+
+		template <typename T, template <typename...> class Templ>
+		inline constexpr bool is_specialization_of_v = is_specialization_of<std::remove_cv_t<T>, Templ>::value;
+
+		template <typename T>
+		struct identity {
+			typedef T type;
+		};
+
+		template <typename T>
+		using identity_t = typename identity<T>::type;
+
+		template <typename T>
+		using is_builtin_type = std::integral_constant<bool, std::is_arithmetic<T>::value || std::is_pointer<T>::value || std::is_array<T>::value>;
+
+		namespace meta_detail {
+			template <typename T, typename = void>
+			struct has_internal_marker_impl : std::false_type { };
+			template <typename T>
+			struct has_internal_marker_impl<T, void_t<typename T::SOL_INTERNAL_UNSPECIALIZED_MARKER_>> : std::true_type { };
+
+			template <typename T>
+			using has_internal_marker = has_internal_marker_impl<T>;
+
+			template <typename T>
+			constexpr inline bool has_internal_marker_v = has_internal_marker<T>::value;
+		} // namespace meta_detail
+
+	} // namespace meta
+} // namespace sol
+
+// end of sol/base_traits.hpp
+
+#include <tuple>
+#include <cstddef>
+
+namespace sol {
+	namespace detail {
+		using swallow = std::initializer_list<int>;
+	} // namespace detail
+
+	namespace meta {
+		template <typename T>
+		using is_tuple = is_specialization_of<T, std::tuple>;
+
+		template <typename T>
+		constexpr inline bool is_tuple_v = is_tuple<T>::value;
+
+		namespace detail {
+			template <typename... Args>
+			struct tuple_types_ {
+				typedef types<Args...> type;
+			};
+
+			template <typename... Args>
+			struct tuple_types_<std::tuple<Args...>> {
+				typedef types<Args...> type;
+			};
+		} // namespace detail
+
+		template <typename... Args>
+		using tuple_types = typename detail::tuple_types_<Args...>::type;
+
+		template <typename Arg>
+		struct pop_front_type;
+
+		template <typename Arg>
+		using pop_front_type_t = typename pop_front_type<Arg>::type;
+
+		template <typename... Args>
+		struct pop_front_type<types<Args...>> {
+			typedef void front_type;
+			typedef types<Args...> type;
+		};
+
+		template <typename Arg, typename... Args>
+		struct pop_front_type<types<Arg, Args...>> {
+			typedef Arg front_type;
+			typedef types<Args...> type;
+		};
+
+		template <std::size_t N, typename Tuple>
+		using tuple_element = std::tuple_element<N, std::remove_reference_t<Tuple>>;
+
+		template <std::size_t N, typename Tuple>
+		using tuple_element_t = std::tuple_element_t<N, std::remove_reference_t<Tuple>>;
+
+		template <std::size_t N, typename Tuple>
+		using unqualified_tuple_element = unqualified<tuple_element_t<N, Tuple>>;
+
+		template <std::size_t N, typename Tuple>
+		using unqualified_tuple_element_t = unqualified_t<tuple_element_t<N, Tuple>>;
+
+	} // namespace meta
+} // namespace sol
+
+// end of sol/tuple.hpp
+
+// beginning of sol/bind_traits.hpp
+
+namespace sol { namespace meta {
+	namespace meta_detail {
+		template <typename F>
+		using detect_deducible_signature = decltype(&F::operator());
+	} // namespace meta_detail
+
+	template <typename F>
+	using call_operator_deducible = typename is_detected<meta_detail::detect_deducible_signature, F>::type;
+
+	template <typename F>
+	constexpr inline bool call_operator_deducible_v = call_operator_deducible<F>::value;
+
+	namespace meta_detail {
+
+		template <std::size_t I, typename T>
+		struct void_tuple_element : meta::tuple_element<I, T> { };
+
+		template <std::size_t I>
+		struct void_tuple_element<I, std::tuple<>> {
+			typedef void type;
+		};
+
+		template <std::size_t I, typename T>
+		using void_tuple_element_t = typename void_tuple_element<I, T>::type;
+
+		template <bool it_is_noexcept, bool has_c_variadic, typename T, typename R, typename... Args>
+		struct basic_traits {
+		private:
+			using first_type = meta::conditional_t<std::is_void<T>::value, int, T>&;
+
+		public:
+			inline static constexpr const bool is_noexcept = it_is_noexcept;
+			inline static constexpr bool is_member_function = std::is_void<T>::value;
+			inline static constexpr bool has_c_var_arg = has_c_variadic;
+			inline static constexpr std::size_t arity = sizeof...(Args);
+			inline static constexpr std::size_t free_arity = sizeof...(Args) + static_cast<std::size_t>(!std::is_void<T>::value);
+			typedef types<Args...> args_list;
+			typedef std::tuple<Args...> args_tuple;
+			typedef T object_type;
+			typedef R return_type;
+			typedef tuple_types<R> returns_list;
+			typedef R(function_type)(Args...);
+			typedef meta::conditional_t<std::is_void<T>::value, args_list, types<first_type, Args...>> free_args_list;
+			typedef meta::conditional_t<std::is_void<T>::value, R(Args...), R(first_type, Args...)> free_function_type;
+			typedef meta::conditional_t<std::is_void<T>::value, R (*)(Args...), R (*)(first_type, Args...)> free_function_pointer_type;
+			typedef std::remove_pointer_t<free_function_pointer_type> signature_type;
+			template <std::size_t i>
+			using arg_at = void_tuple_element_t<i, args_tuple>;
+		};
+
+		template <typename Signature, bool b = call_operator_deducible<Signature>::value>
+		struct fx_traits : public basic_traits<false, false, void, void> { };
+
+		// Free Functions
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args...), false> : public basic_traits<false, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args...), false> : public basic_traits<false, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args..., ...), false> : public basic_traits<false, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args..., ...), false> : public basic_traits<false, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...);
+		};
+
+		// Member Functions
+		/* C-Style Variadics */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...), false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...);
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...), false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...);
+		};
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile;
+		};
+
+		/* Member Function Qualifiers */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) &;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) &;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) &&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)&&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) &&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const&&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile&&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile&&;
+		};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args..., ...) noexcept, false> : public basic_traits<true, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args..., ...) noexcept, false> : public basic_traits<true, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) & noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) & noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) && noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) && noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const&& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const&& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile&& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile&& noexcept;
+		};
+
+#endif // noexcept is part of a function's type
+
+#if SOL_IS_ON(SOL_COMPILER_VCXX) && SOL_IS_ON(SOL_PLATFORM_X86)
+		template <typename R, typename... Args>
+		struct fx_traits<R __stdcall(Args...), false> : public basic_traits<false, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(__stdcall*)(Args...), false> : public basic_traits<false, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...);
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...), false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...);
+		};
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile;
+		};
+
+		/* Member Function Qualifiers */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) &;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) &&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&&;
+		};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+
+		template <typename R, typename... Args>
+		struct fx_traits<R __stdcall(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(__stdcall*)(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...) noexcept;
+		};
+
+		/* __stdcall cannot be applied to functions with varargs*/
+		/*template <typename R, typename... Args>
+		struct fx_traits<__stdcall R(Args..., ...) noexcept, false> : public basic_traits<true, true, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (__stdcall *)(Args..., ...) noexcept, false> : public basic_traits<true, true, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args..., ...) noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) noexcept;
+		};*/
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) & noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) & noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) & noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const& noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile& noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) && noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) && noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) && noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const&& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const&& noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile&& noexcept;
+		};*/
+#endif // noexcept is part of a function's type
+#endif // __stdcall x86 VC++ bug
+
+		template <typename Signature>
+		struct fx_traits<Signature, true> : public fx_traits<typename fx_traits<decltype(&Signature::operator())>::function_type, false> { };
+
+		template <typename Signature, bool b = std::is_member_object_pointer<Signature>::value>
+		struct callable_traits : public fx_traits<std::decay_t<Signature>> { };
+
+		template <typename R, typename T>
+		struct callable_traits<R(T::*), true> {
+			typedef meta::conditional_t<std::is_array_v<R>, std::add_lvalue_reference_t<R>, R> return_type;
+			typedef return_type Arg;
+			typedef T object_type;
+			using signature_type = R(T::*);
+			inline static constexpr bool is_noexcept = false;
+			inline static constexpr bool is_member_function = false;
+			inline static constexpr std::size_t arity = 1;
+			inline static constexpr std::size_t free_arity = 2;
+			typedef std::tuple<Arg> args_tuple;
+			typedef types<Arg> args_list;
+			typedef types<T, Arg> free_args_list;
+			typedef meta::tuple_types<return_type> returns_list;
+			typedef return_type(function_type)(T&, return_type);
+			typedef return_type (*function_pointer_type)(T&, Arg);
+			typedef return_type (*free_function_pointer_type)(T&, Arg);
+			template <std::size_t i>
+			using arg_at = void_tuple_element_t<i, args_tuple>;
+		};
+
+	} // namespace meta_detail
+
+	template <typename Signature>
+	using bind_traits = meta_detail::callable_traits<Signature>;
+
+	namespace meta_detail {
+		template <typename, bool>
+		struct is_probably_stateless_lambda : std::false_type { };
+
+		template <typename T>
+		struct is_probably_stateless_lambda<T, true> : std::is_convertible<T, typename bind_traits<T>::function_type*>::type { };
+	} // namespace meta_detail
+
+	template <typename T>
+	using is_probably_stateless_lambda = typename meta_detail::is_probably_stateless_lambda<T, std::is_empty_v<T> && call_operator_deducible_v<T>>::type;
+
+	template <typename T>
+	inline constexpr bool is_probably_stateless_lambda_v = is_probably_stateless_lambda<T>::value;
+
+	template <typename Signature>
+	using function_args_t = typename bind_traits<Signature>::args_list;
+
+	template <typename Signature>
+	using function_signature_t = typename bind_traits<Signature>::signature_type;
+
+	template <typename Signature>
+	using function_return_t = typename bind_traits<Signature>::return_type;
+}} // namespace sol::meta
+
+// end of sol/bind_traits.hpp
+
+// beginning of sol/pointer_like.hpp
+
+#include <utility>
+#include <type_traits>
+#include <memory>
+
+namespace sol {
+
+	namespace meta {
+		namespace meta_detail {
+			template <typename T>
+			using is_dereferenceable_test = decltype(*std::declval<T>());
+
+			template <typename T>
+			using is_explicitly_dereferenceable_test = decltype(std::declval<T>().operator*());
+		} // namespace meta_detail
+
+		template <typename T>
+		using is_pointer_like = std::integral_constant<bool,
+		     !std::is_array_v<T> && (std::is_pointer_v<T> || is_detected_v<meta_detail::is_explicitly_dereferenceable_test, T>)>;
+
+		template <typename T>
+		constexpr inline bool is_pointer_like_v = is_pointer_like<T>::value;
+	} // namespace meta
+
+	namespace detail {
+
+		template <typename T>
+		auto unwrap(T&& item) -> decltype(std::forward<T>(item)) {
+			return std::forward<T>(item);
+		}
+
+		template <typename T>
+		T& unwrap(std::reference_wrapper<T> arg) {
+			return arg.get();
+		}
+
+		template <typename T>
+		inline decltype(auto) deref(T&& item) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::is_pointer_like_v<Tu>) {
+				return *std::forward<T>(item);
+			}
+			else {
+				return std::forward<T>(item);
+			}
+		}
+
+		template <typename T>
+		inline decltype(auto) deref_move_only(T&& item) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::is_pointer_like_v<Tu> && !std::is_pointer_v<Tu> && !std::is_copy_constructible_v<Tu>) {
+				return *std::forward<T>(item);
+			}
+			else {
+				return std::forward<T>(item);
+			}
+		}
+
+		template <typename T>
+		inline T* ptr(T& val) {
+			return std::addressof(val);
+		}
+
+		template <typename T>
+		inline T* ptr(std::reference_wrapper<T> val) {
+			return std::addressof(val.get());
+		}
+
+		template <typename T>
+		inline T* ptr(T* val) {
+			return val;
+		}
+	} // namespace detail
+} // namespace sol
+
+// end of sol/pointer_like.hpp
+
+// beginning of sol/string_view.hpp
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <functional>
+
+namespace sol {
+	template <typename C, typename T = std::char_traits<C>>
+	using basic_string_view = std::basic_string_view<C, T>;
+
+	typedef std::string_view string_view;
+	typedef std::wstring_view wstring_view;
+	typedef std::u16string_view u16string_view;
+	typedef std::u32string_view u32string_view;
+	typedef std::hash<std::string_view> string_view_hash;
+} // namespace sol
+
+// end of sol/string_view.hpp
+
+#include <type_traits>
+#include <cstdint>
+#include <memory>
+#include <functional>
+#include <array>
+#include <iterator>
+#include <iosfwd>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // variant is weird on XCode, thanks XCode
+
+namespace sol { namespace meta {
+	template <typename T>
+	struct unwrapped {
+		typedef T type;
+	};
+
+	template <typename T>
+	struct unwrapped<std::reference_wrapper<T>> {
+		typedef T type;
+	};
+
+	template <typename T>
+	using unwrapped_t = typename unwrapped<T>::type;
+
+	template <typename T>
+	struct unwrap_unqualified : unwrapped<unqualified_t<T>> { };
+
+	template <typename T>
+	using unwrap_unqualified_t = typename unwrap_unqualified<T>::type;
+
+	template <typename T>
+	struct remove_member_pointer;
+
+	template <typename R, typename T>
+	struct remove_member_pointer<R T::*> {
+		typedef R type;
+	};
+
+	template <typename R, typename T>
+	struct remove_member_pointer<R T::*const> {
+		typedef R type;
+	};
+
+	template <typename T>
+	using remove_member_pointer_t = remove_member_pointer<T>;
+
+	template <typename T, typename...>
+	struct all_same : std::true_type { };
+
+	template <typename T, typename U, typename... Args>
+	struct all_same<T, U, Args...> : std::integral_constant<bool, std::is_same<T, U>::value && all_same<T, Args...>::value> { };
+
+	template <typename T, typename...>
+	struct any_same : std::false_type { };
+
+	template <typename T, typename U, typename... Args>
+	struct any_same<T, U, Args...> : std::integral_constant<bool, std::is_same<T, U>::value || any_same<T, Args...>::value> { };
+
+	template <typename T, typename... Args>
+	constexpr inline bool any_same_v = any_same<T, Args...>::value;
+
+	template <bool B>
+	using boolean = std::integral_constant<bool, B>;
+
+	template <bool B>
+	constexpr inline bool boolean_v = boolean<B>::value;
+
+	template <typename T>
+	using neg = boolean<!T::value>;
+
+	template <typename T>
+	constexpr inline bool neg_v = neg<T>::value;
+
+	template <typename... Args>
+	struct all : boolean<true> { };
+
+	template <typename T, typename... Args>
+	struct all<T, Args...> : std::conditional_t<T::value, all<Args...>, boolean<false>> { };
+
+	template <typename... Args>
+	struct any : boolean<false> { };
+
+	template <typename T, typename... Args>
+	struct any<T, Args...> : std::conditional_t<T::value, boolean<true>, any<Args...>> { };
+
+	template <typename... Args>
+	constexpr inline bool all_v = all<Args...>::value;
+
+	template <typename... Args>
+	constexpr inline bool any_v = any<Args...>::value;
+
+	enum class enable_t { _ };
+
+	constexpr const auto enabler = enable_t::_;
+
+	template <bool value, typename T = void>
+	using disable_if_t = std::enable_if_t<!value, T>;
+
+	template <typename... Args>
+	using enable = std::enable_if_t<all<Args...>::value, enable_t>;
+
+	template <typename... Args>
+	using disable = std::enable_if_t<neg<all<Args...>>::value, enable_t>;
+
+	template <typename... Args>
+	using enable_any = std::enable_if_t<any<Args...>::value, enable_t>;
+
+	template <typename... Args>
+	using disable_any = std::enable_if_t<neg<any<Args...>>::value, enable_t>;
+
+	template <typename V, typename... Vs>
+	struct find_in_pack_v : boolean<false> { };
+
+	template <typename V, typename Vs1, typename... Vs>
+	struct find_in_pack_v<V, Vs1, Vs...> : any<boolean<(V::value == Vs1::value)>, find_in_pack_v<V, Vs...>> { };
+
+	namespace meta_detail {
+		template <std::size_t I, typename T, typename... Args>
+		struct index_in_pack : std::integral_constant<std::size_t, SIZE_MAX> { };
+
+		template <std::size_t I, typename T, typename T1, typename... Args>
+		struct index_in_pack<I, T, T1, Args...>
+		: conditional_t<std::is_same<T, T1>::value, std::integral_constant<std::ptrdiff_t, I>, index_in_pack<I + 1, T, Args...>> { };
+	} // namespace meta_detail
+
+	template <typename T, typename... Args>
+	struct index_in_pack : meta_detail::index_in_pack<0, T, Args...> { };
+
+	template <typename T, typename List>
+	struct index_in : meta_detail::index_in_pack<0, T, List> { };
+
+	template <typename T, typename... Args>
+	struct index_in<T, types<Args...>> : meta_detail::index_in_pack<0, T, Args...> { };
+
+	template <std::size_t I, typename... Args>
+	struct at_in_pack { };
+
+	template <std::size_t I, typename... Args>
+	using at_in_pack_t = typename at_in_pack<I, Args...>::type;
+
+	template <std::size_t I, typename Arg, typename... Args>
+	struct at_in_pack<I, Arg, Args...> : std::conditional<I == 0, Arg, at_in_pack_t<I - 1, Args...>> { };
+
+	template <typename Arg, typename... Args>
+	struct at_in_pack<0, Arg, Args...> {
+		typedef Arg type;
+	};
+
+	namespace meta_detail {
+		template <typename, typename TI>
+		using on_even = meta::boolean<(TI::value % 2) == 0>;
+
+		template <typename, typename TI>
+		using on_odd = meta::boolean<(TI::value % 2) == 1>;
+
+		template <typename, typename>
+		using on_always = std::true_type;
+
+		template <template <typename...> class When, std::size_t Limit, std::size_t I, template <typename...> class Pred, typename... Ts>
+		struct count_when_for_pack : std::integral_constant<std::size_t, 0> { };
+		template <template <typename...> class When, std::size_t Limit, std::size_t I, template <typename...> class Pred, typename T, typename... Ts>
+			          struct count_when_for_pack<When, Limit, I, Pred, T, Ts...> : conditional_t < sizeof...(Ts)
+			     == 0
+			|| Limit<2, std::integral_constant<std::size_t, I + static_cast<std::size_t>(Limit != 0 && Pred<T>::value)>,
+			     count_when_for_pack<When, Limit - static_cast<std::size_t>(When<T, std::integral_constant<std::size_t, I>>::value),
+			          I + static_cast<std::size_t>(When<T, std::integral_constant<std::size_t, I>>::value&& Pred<T>::value), Pred, Ts...>> { };
+	} // namespace meta_detail
+
+	template <template <typename...> class Pred, typename... Ts>
+	struct count_for_pack : meta_detail::count_when_for_pack<meta_detail::on_always, sizeof...(Ts), 0, Pred, Ts...> { };
+
+	template <template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_for_pack_v = count_for_pack<Pred, Ts...>::value;
+
+	template <template <typename...> class Pred, typename List>
+	struct count_for;
+
+	template <template <typename...> class Pred, typename... Args>
+	struct count_for<Pred, types<Args...>> : count_for_pack<Pred, Args...> { };
+
+	template <std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	struct count_for_to_pack : meta_detail::count_when_for_pack<meta_detail::on_always, Limit, 0, Pred, Ts...> { };
+
+	template <std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_for_to_pack_v = count_for_to_pack<Limit, Pred, Ts...>::value;
+
+	template <template <typename...> class When, std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	struct count_when_for_to_pack : meta_detail::count_when_for_pack<When, Limit, 0, Pred, Ts...> { };
+
+	template <template <typename...> class When, std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_when_for_to_pack_v = count_when_for_to_pack<When, Limit, Pred, Ts...>::value;
+
+	template <template <typename...> class Pred, typename... Ts>
+	using count_even_for_pack = count_when_for_to_pack<meta_detail::on_even, sizeof...(Ts), Pred, Ts...>;
+
+	template <template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_even_for_pack_v = count_even_for_pack<Pred, Ts...>::value;
+
+	template <template <typename...> class Pred, typename... Ts>
+	using count_odd_for_pack = count_when_for_to_pack<meta_detail::on_odd, sizeof...(Ts), Pred, Ts...>;
+
+	template <template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_odd_for_pack_v = count_odd_for_pack<Pred, Ts...>::value;
+
+	template <typename... Args>
+	struct return_type {
+		typedef std::tuple<Args...> type;
+	};
+
+	template <typename T>
+	struct return_type<T> {
+		typedef T type;
+	};
+
+	template <>
+	struct return_type<> {
+		typedef void type;
+	};
+
+	template <typename... Args>
+	using return_type_t = typename return_type<Args...>::type;
+
+	namespace meta_detail {
+		template <typename>
+		struct always_true : std::true_type { };
+		struct is_invokable_tester {
+			template <typename Fun, typename... Args>
+			static always_true<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
+			template <typename...>
+			static std::false_type test(...);
+		};
+	} // namespace meta_detail
+
+	template <typename T>
+	struct is_invokable;
+	template <typename Fun, typename... Args>
+	struct is_invokable<Fun(Args...)> : decltype(meta_detail::is_invokable_tester::test<Fun, Args...>(0)) { };
+
+	namespace meta_detail {
+
+		template <typename T, typename = void>
+		struct is_invocable : std::is_function<std::remove_pointer_t<T>> { };
+
+		template <typename T>
+		struct is_invocable<T,
+			std::enable_if_t<std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+			     && std::is_same<decltype(void(&T::operator())), void>::value>> { };
+
+		template <typename T>
+		struct is_invocable<T,
+			std::enable_if_t<!std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+			     && std::is_destructible<unqualified_t<T>>::value>> {
+			struct F {
+				void operator()() {};
+			};
+			struct Derived : T, F { };
+			template <typename U, U>
+			struct Check;
+
+			template <typename V>
+			static sfinae_no_t test(Check<void (F::*)(), &V::operator()>*);
+
+			template <typename>
+			static sfinae_yes_t test(...);
+
+			static constexpr bool value = std::is_same_v<decltype(test<Derived>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct is_invocable<T,
+			std::enable_if_t<!std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+			     && !std::is_destructible<unqualified_t<T>>::value>> {
+			struct F {
+				void operator()() {};
+			};
+			struct Derived : T, F {
+				~Derived() = delete;
+			};
+			template <typename U, U>
+			struct Check;
+
+			template <typename V>
+			static sfinae_no_t test(Check<void (F::*)(), &V::operator()>*);
+
+			template <typename>
+			static sfinae_yes_t test(...);
+
+			static constexpr bool value = std::is_same_v<decltype(test<Derived>(0)), sfinae_yes_t>;
+		};
+
+		struct has_begin_end_impl {
+			template <typename T, typename U = unqualified_t<T>, typename B = decltype(std::declval<U&>().begin()),
+				typename E = decltype(std::declval<U&>().end())>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_key_type_impl {
+			template <typename T, typename U = unqualified_t<T>, typename V = typename U::key_type>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_key_comp_impl {
+			template <typename T, typename V = decltype(std::declval<unqualified_t<T>>().key_comp())>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_load_factor_impl {
+			template <typename T, typename V = decltype(std::declval<unqualified_t<T>>().load_factor())>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_mapped_type_impl {
+			template <typename T, typename V = typename unqualified_t<T>::mapped_type>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_value_type_impl {
+			template <typename T, typename V = typename unqualified_t<T>::value_type>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_iterator_impl {
+			template <typename T, typename V = typename unqualified_t<T>::iterator>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_key_value_pair_impl {
+			template <typename T, typename U = unqualified_t<T>, typename V = typename U::value_type, typename F = decltype(std::declval<V&>().first),
+				typename S = decltype(std::declval<V&>().second)>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		template <typename T>
+		struct has_push_back_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().push_back(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_insert_with_iterator_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().insert(
+				std::declval<std::add_rvalue_reference_t<typename C::iterator>>(), std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = !std::is_same_v<decltype(test<T>(0)), sfinae_no_t>;
+		};
+
+		template <typename T>
+		struct has_insert_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().insert(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = !std::is_same_v<decltype(test<T>(0)), sfinae_no_t>;
+		};
+
+		template <typename T>
+		struct has_insert_after_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().insert_after(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>(),
+				std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_size_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().size())*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_max_size_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().max_size())*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_to_string_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().to_string())*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_less_test : public std::false_type { };
+		template <typename T, typename U>
+		class supports_op_less_test<T, U, void_t<decltype(std::declval<T&>() < std::declval<U&>())>>
+		: public std::integral_constant<bool,
+#if SOL_IS_ON(SOL_STD_VARIANT)
+			  !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
+#else
+			  true
+#endif
+			  > {
+		};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_equal_test : public std::false_type { };
+		template <typename T, typename U>
+		class supports_op_equal_test<T, U, void_t<decltype(std::declval<T&>() == std::declval<U&>())>>
+		: public std::integral_constant<bool,
+#if SOL_IS_ON(SOL_STD_VARIANT)
+			  !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
+#else
+			  true
+#endif
+			  > {
+		};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_less_equal_test : public std::false_type { };
+		template <typename T, typename U>
+		class supports_op_less_equal_test<T, U, void_t<decltype(std::declval<T&>() <= std::declval<U&>())>>
+		: public std::integral_constant<bool,
+#if SOL_IS_ON(SOL_STD_VARIANT)
+			  !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
+#else
+			  true
+#endif
+			  > {
+		};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_left_shift_test : public std::false_type { };
+		template <typename T, typename U>
+		class supports_op_left_shift_test<T, U, void_t<decltype(std::declval<T&>() << std::declval<U&>())>> : public std::true_type { };
+
+		template <typename T, typename = void>
+		class supports_adl_to_string_test : public std::false_type { };
+		template <typename T>
+		class supports_adl_to_string_test<T, void_t<decltype(to_string(std::declval<const T&>()))>> : public std::true_type { };
+
+		template <typename T, bool b>
+		struct is_matched_lookup_impl : std::false_type { };
+		template <typename T>
+		struct is_matched_lookup_impl<T, true> : std::is_same<typename T::key_type, typename T::value_type> { };
+
+		template <typename T>
+		using non_void_t = meta::conditional_t<std::is_void_v<T>, ::sol::detail::unchecked_t, T>;
+	} // namespace meta_detail
+
+	template <typename T, typename U = T>
+	class supports_op_less : public meta_detail::supports_op_less_test<T, U> { };
+
+	template <typename T, typename U = T>
+	class supports_op_equal : public meta_detail::supports_op_equal_test<T, U> { };
+
+	template <typename T, typename U = T>
+	class supports_op_less_equal : public meta_detail::supports_op_less_equal_test<T, U> { };
+
+	template <typename T, typename U = T>
+	class supports_op_left_shift : public meta_detail::supports_op_left_shift_test<T, U> { };
+
+	template <typename T>
+	class supports_adl_to_string : public meta_detail::supports_adl_to_string_test<T> { };
+
+	template <typename T>
+	class supports_to_string_member : public meta::boolean<meta_detail::has_to_string_test<meta_detail::non_void_t<T>>::value> { };
+
+	template <typename T>
+	using is_invocable = boolean<meta_detail::is_invocable<T>::value>;
+
+	template <typename T>
+	constexpr inline bool is_invocable_v = is_invocable<T>::value;
+
+	template <typename T>
+	struct has_begin_end : decltype(meta_detail::has_begin_end_impl::test<T>(0)) { };
+
+	template <typename T>
+	constexpr inline bool has_begin_end_v = has_begin_end<T>::value;
+
+	template <typename T>
+	struct has_key_value_pair : decltype(meta_detail::has_key_value_pair_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_key_type : decltype(meta_detail::has_key_type_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_key_comp : decltype(meta_detail::has_key_comp_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_load_factor : decltype(meta_detail::has_load_factor_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_mapped_type : decltype(meta_detail::has_mapped_type_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_iterator : decltype(meta_detail::has_iterator_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_value_type : decltype(meta_detail::has_value_type_impl::test<T>(0)) { };
+
+	template <typename T>
+	using has_push_back = meta::boolean<meta_detail::has_push_back_test<T>::value>;
+
+	template <typename T>
+	using has_max_size = meta::boolean<meta_detail::has_max_size_test<T>::value>;
+
+	template <typename T>
+	using has_insert = meta::boolean<meta_detail::has_insert_test<T>::value>;
+
+	template <typename T>
+	using has_insert_with_iterator = meta::boolean<meta_detail::has_insert_with_iterator_test<T>::value>;
+
+	template <typename T>
+	using has_insert_after = meta::boolean<meta_detail::has_insert_after_test<T>::value>;
+
+	template <typename T>
+	using has_size = meta::boolean<meta_detail::has_size_test<T>::value>;
+
+	template <typename T>
+	using is_associative = meta::all<has_key_type<T>, has_key_value_pair<T>, has_mapped_type<T>>;
+
+	template <typename T>
+	using is_lookup = meta::all<has_key_type<T>, has_value_type<T>>;
+
+	template <typename T>
+	using is_ordered = meta::all<has_key_comp<T>, meta::neg<has_load_factor<T>>>;
+
+	template <typename T>
+	using is_matched_lookup = meta_detail::is_matched_lookup_impl<T, is_lookup<T>::value>;
+
+	template <typename T>
+	using is_initializer_list = meta::is_specialization_of<T, std::initializer_list>;
+
+	template <typename T>
+	constexpr inline bool is_initializer_list_v = is_initializer_list<T>::value;
+
+	template <typename T, typename CharT = char>
+	using is_string_literal_array_of = boolean<std::is_array_v<T> && std::is_same_v<std::remove_all_extents_t<T>, CharT>>;
+
+	template <typename T, typename CharT = char>
+	constexpr inline bool is_string_literal_array_of_v = is_string_literal_array_of<T, CharT>::value;
+
+	template <typename T>
+	using is_string_literal_array = boolean<std::is_array_v<T> && any_same_v<std::remove_all_extents_t<T>, char,
+#if SOL_IS_ON(SOL_CHAR8_T)
+	char8_t,
+#endif
+	char16_t, char32_t, wchar_t>>;
+
+	template <typename T>
+	constexpr inline bool is_string_literal_array_v = is_string_literal_array<T>::value;
+
+	template <typename T, typename CharT>
+	struct is_string_of : std::false_type { };
+
+	template <typename CharT, typename CharTargetT, typename TraitsT, typename AllocT>
+	struct is_string_of<std::basic_string<CharT, TraitsT, AllocT>, CharTargetT> : std::is_same<CharT, CharTargetT> { };
+
+	template <typename T, typename CharT>
+	constexpr inline bool is_string_of_v = is_string_of<T, CharT>::value;
+
+	template <typename T, typename CharT>
+	struct is_string_view_of : std::false_type { };
+
+	template <typename CharT, typename CharTargetT, typename TraitsT>
+	struct is_string_view_of<std::basic_string_view<CharT, TraitsT>, CharTargetT> : std::is_same<CharT, CharTargetT> { };
+
+	template <typename T, typename CharT>
+	constexpr inline bool is_string_view_of_v = is_string_view_of<T, CharT>::value;
+
+	template <typename T>
+	using is_string_like
+		= meta::boolean<is_specialization_of_v<T, std::basic_string> || is_specialization_of_v<T, std::basic_string_view> || is_string_literal_array_v<T>>;
+
+	template <typename T>
+	constexpr inline bool is_string_like_v = is_string_like<T>::value;
+
+	template <typename T, typename CharT = char>
+	using is_string_constructible = meta::boolean<
+		is_string_literal_array_of_v<T,
+		     CharT> || std::is_same_v<T, const CharT*> || std::is_same_v<T, CharT> || is_string_of_v<T, CharT> || std::is_same_v<T, std::initializer_list<CharT>> || is_string_view_of_v<T, CharT> || std::is_null_pointer_v<T>>;
+
+	template <typename T, typename CharT = char>
+	constexpr inline bool is_string_constructible_v = is_string_constructible<T, CharT>::value;
+
+	template <typename T>
+	using is_string_like_or_constructible = meta::boolean<is_string_like_v<T> || is_string_constructible_v<T>>;
+
+	template <typename T>
+	struct is_pair : std::false_type { };
+
+	template <typename T1, typename T2>
+	struct is_pair<std::pair<T1, T2>> : std::true_type { };
+
+	template <typename T, typename Char>
+	using is_c_str_of = any<std::is_same<T, const Char*>, std::is_same<T, Char const* const>, std::is_same<T, Char*>, is_string_literal_array_of<T, Char>>;
+
+	template <typename T, typename Char>
+	constexpr inline bool is_c_str_of_v = is_c_str_of<T, Char>::value;
+
+	template <typename T>
+	using is_c_str = is_c_str_of<T, char>;
+
+	template <typename T>
+	constexpr inline bool is_c_str_v = is_c_str<T>::value;
+
+	template <typename T, typename Char>
+	using is_c_str_or_string_of = any<is_c_str_of<T, Char>, is_string_of<T, Char>>;
+
+	template <typename T, typename Char>
+	constexpr inline bool is_c_str_or_string_of_v = is_c_str_or_string_of<T, Char>::value;
+
+	template <typename T>
+	using is_c_str_or_string = is_c_str_or_string_of<T, char>;
+
+	template <typename T>
+	constexpr inline bool is_c_str_or_string_v = is_c_str_or_string<T>::value;
+
+	template <typename T>
+	struct is_move_only : all<neg<std::is_reference<T>>, neg<std::is_copy_constructible<unqualified_t<T>>>, std::is_move_constructible<unqualified_t<T>>> { };
+
+	template <typename T>
+	using is_not_move_only = neg<is_move_only<T>>;
+
+	namespace meta_detail {
+		template <typename T>
+		decltype(auto) force_tuple(T&& x) {
+			if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::tuple>) {
+				return std::forward<T>(x);
+			}
+			else {
+				return std::tuple<T>(std::forward<T>(x));
+			}
+		}
+	} // namespace meta_detail
+
+	template <typename... X>
+	decltype(auto) tuplefy(X&&... x) {
+		return std::tuple_cat(meta_detail::force_tuple(std::forward<X>(x))...);
+	}
+
+	template <typename T, typename = void>
+	struct iterator_tag {
+		using type = std::input_iterator_tag;
+	};
+
+	template <typename T>
+	struct iterator_tag<T, conditional_t<false, typename std::iterator_traits<T>::iterator_category, void>> {
+		using type = typename std::iterator_traits<T>::iterator_category;
+	};
+
+}} // namespace sol::meta
+
+// end of sol/traits.hpp
+
+namespace sol {
+	namespace detail {
+		const bool default_safe_function_calls =
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_CALLS)
+		     true;
+#else
+		     false;
+#endif
+	} // namespace detail
+
+	namespace meta { namespace meta_detail {
+	}} // namespace meta::meta_detail
+
+	namespace stack { namespace stack_detail {
+		using undefined_method_func = void (*)(stack_reference);
+
+		template <typename T>
+		void set_undefined_methods_on(stack_reference);
+
+		struct undefined_metatable;
+	}} // namespace stack::stack_detail
+} // namespace sol
+
+#endif // SOL_FORWARD_DETAIL_HPP
+// end of sol/forward_detail.hpp
+
+// beginning of sol/assert.hpp
+
+#if SOL_IS_ON(SOL2_CI)
+
+struct pre_main {
+	pre_main() {
+#ifdef _MSC_VER
+		_set_abort_behavior(0, _WRITE_ABORT_MSG);
+#endif
+	}
+} inline sol2_ci_dont_lock_ci_please = {};
+
+#endif // Prevent lockup when doing Continuous Integration
+
+#if SOL_IS_ON(SOL_USER_C_ASSERT)
+	#define sol_c_assert(...) SOL_C_ASSERT(__VA_ARGS__)
+#else
+	#if SOL_IS_ON(SOL_DEBUG_BUILD)
+		#include <exception>
+		#include <iostream>
+		#include <cstdlib>
+
+			#define sol_c_assert(...)                                                                                               \
+				do {                                                                                                               \
+					if (!(__VA_ARGS__)) {                                                                                           \
+						std::cerr << "Assertion `" #__VA_ARGS__ "` failed in " << __FILE__ << " line " << __LINE__ << std::endl; \
+						std::terminate();                                                                                        \
+					}                                                                                                             \
+				} while (false)
+	#else
+		#define sol_c_assert(...)           \
+			do {                           \
+				if (false) {              \
+					(void)(__VA_ARGS__); \
+				}                         \
+			} while (false)
+	#endif
+#endif
+
+#if SOL_IS_ON(SOL_USER_M_ASSERT)
+	#define sol_m_assert(message, ...) SOL_M_ASSERT(message, __VA_ARGS__)
+#else
+	#if SOL_IS_ON(SOL_DEBUG_BUILD)
+		#include <exception>
+		#include <iostream>
+		#include <cstdlib>
+
+		#define sol_m_assert(message, ...)                                                                                                         \
+			do {                                                                                                                                  \
+				if (!(__VA_ARGS__)) {                                                                                                              \
+					std::cerr << "Assertion `" #__VA_ARGS__ "` failed in " << __FILE__ << " line " << __LINE__ << ": " << message << std::endl; \
+					std::terminate();                                                                                                           \
+				}                                                                                                                                \
+			} while (false)
+	#else
+		#define sol_m_assert(message, ...)    \
+			do {                             \
+				if (false) {                \
+					(void)(__VA_ARGS__);   \
+					(void)sizeof(message); \
+				}                           \
+			} while (false)
+	#endif
+#endif
+
+// end of sol/assert.hpp
+
+// beginning of sol/bytecode.hpp
+
+// beginning of sol/compatibility.hpp
+
+// beginning of sol/compatibility/lua_version.hpp
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA)
+	#include <lua.h>
+	#include <lualib.h>
+	#include <lauxlib.h>
+#elif SOL_IS_ON(SOL_USE_LUA_HPP)
+	#include <lua.hpp>
+#else
+	extern "C" {
+		#include <lua.h>
+		#include <lauxlib.h>
+		#include <lualib.h>
+	}
+#endif // C++ Mangling for Lua vs. Not
+
+#if defined(SOL_LUAJIT)
+	#if (SOL_LUAJIT != 0)
+		#define SOL_USE_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_LUAJIT_I_ SOL_OFF
+	#endif
+#elif defined(LUAJIT_VERSION)
+	#define SOL_USE_LUAJIT_I_ SOL_ON
+#else
+	#define SOL_USE_LUAJIT_I_ SOL_DEFAULT_OFF
+#endif // luajit
+
+#if SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+	#include <luajit.h>
+#elif SOL_IS_ON(SOL_USE_LUAJIT)
+	extern "C" {
+		#include <luajit.h>
+	}
+#endif // C++ LuaJIT ... whatever that means
+
+#if defined(SOL_LUAJIT_VERSION)
+	#define SOL_LUAJIT_VERSION_I_ SOL_LUAJIT_VERSION
+#elif SOL_IS_ON(SOL_USE_LUAJIT)
+	#define SOL_LUAJIT_VERSION_I_ LUAJIT_VERSION_NUM
+#else
+	#define SOL_LUAJIT_VERSION_I_ 0
+#endif
+
+#if defined(SOL_LUAJIT_FFI_DISABLED)
+	#define SOL_LUAJIT_FFI_DISABLED_I_ SOL_ON
+#elif defined(LUAJIT_DISABLE_FFI)
+	#define SOL_LUAJIT_FFI_DISABLED_I_ SOL_ON
+#else
+	#define SOL_LUAJIT_FFI_DISABLED_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(MOONJIT_VERSION)
+	#define SOL_USE_MOONJIT_I_ SOL_ON
+#else
+	#define SOL_USE_MOONJIT_I_ SOL_OFF
+#endif
+
+#if !defined(SOL_LUA_VERSION)
+	#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 502
+		#define SOL_LUA_VERSION LUA_VERSION_NUM
+	#elif defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+		#define SOL_LUA_VERSION LUA_VERSION_NUM
+	#elif !defined(LUA_VERSION_NUM) || !(LUA_VERSION_NUM)
+		// Definitely 5.0
+		#define SOL_LUA_VERSION 500
+	#else
+		// ??? Not sure, assume latest?
+		#define SOL_LUA_VERSION 504
+	#endif // Lua Version 503, 502, 501 || luajit, 500
+#endif // SOL_LUA_VERSION
+
+#if defined(SOL_LUA_VERSION)
+	#define SOL_LUA_VERSION_I_ SOL_LUA_VERSION
+#else
+	#define SOL_LUA_VERSION_I_ 504
+#endif
+
+#if defined(SOL_EXCEPTIONS_ALWAYS_UNSAFE)
+	#if (SOL_EXCEPTIONS_ALWAYS_UNSAFE != 0)
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
+	#if (SOL_EXCEPTIONS_SAFE_PROPAGATION != 0)
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_ON
+	#else
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+	#endif
+#elif SOL_LUAJIT_VERSION_I_ >= 20100
+	// LuaJIT 2.1.0-beta3 and better have exception support locked in for all platforms (mostly)
+	#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#elif SOL_LUAJIT_VERSION_I_ >= 20000
+	// LuaJIT 2.0.x have exception support only on x64 builds
+	#if SOL_IS_ON(SOL_PLATFORM_X64)
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+	#endif
+#else
+	// otherwise, there is no exception safety for
+	// shoving exceptions through Lua and errors should
+	// always be serialized
+	#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_EXCEPTIONS_CATCH_ALL)
+	#if (SOL_EXCEPTIONS_CATCH_ALL != 0)
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_ON
+	#else
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_USE_LUAJIT)
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
+	#elif SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
+	#elif SOL_IS_ON(SOL_USE_CXX_LUA)
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
+	#else
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_ON
+	#endif
+#endif
+
+#if defined(SOL_LUAJIT_USE_EXCEPTION_TRAMPOLINE)
+	#if (SOL_LUAJIT_USE_EXCEPTION_TRAMPOLINE != 0)
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_ON
+	#else
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS) && SOL_IS_ON(SOL_USE_LUAJIT)
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_ON
+	#else
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_LUAL_STREAM_HAS_CLOSE_FUNCTION)
+	#if (SOL_LUAL_STREAM_HAS_CLOSE_FUNCTION != 0)
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_ON
+	#else
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_OFF(SOL_USE_LUAJIT) && (SOL_LUA_VERSION > 501)
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_ON
+	#else
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined (SOL_LUA_BIT32_LIB)
+	#if SOL_LUA_BIT32_LIB != 0
+		#define SOL_LUA_BIT32_LIB_I_ SOL_ON
+	#else
+		#define SOL_LUA_BIT32_LIB_I_ SOL_OFF
+	#endif
+#else
+	// Lua 5.2 only (deprecated in 5.3 (503)) (Can be turned on with Compat flags)
+	// Lua 5.2, or other versions of Lua with the compat flag, or Lua that is not 5.2 with the specific define (5.4.1 either removed it entirely or broke it)
+	#if (SOL_LUA_VERSION_I_ == 502) || (defined(LUA_COMPAT_BITLIB) && (LUA_COMPAT_BITLIB != 0)) || (SOL_LUA_VERSION_I_ < 504 && (defined(LUA_COMPAT_5_2) && (LUA_COMPAT_5_2 != 0)))
+		#define SOL_LUA_BIT32_LIB_I_ SOL_ON
+	#else
+		#define SOL_LUA_BIT32_LIB_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined (SOL_LUA_NIL_IN_TABLES)
+	#if SOL_LUA_NIL_IN_TABLES != 0
+		#define SOL_LUA_NIL_IN_TABLES_I_ SOL_ON
+	#else
+		#define SOL_LUA_NIL_IN_TABLES_I_ SOL_OFF
+	#endif
+#else
+	#if defined(LUA_NILINTABLE) && (LUA_NILINTABLE != 0)
+		#define SOL_LUA_NIL_IN_TABLES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_LUA_NIL_IN_TABLES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+// end of sol/compatibility/lua_version.hpp
+
+#if SOL_IS_ON(SOL_USE_COMPATIBILITY_LAYER)
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA) || SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+#ifndef COMPAT53_LUA_CPP
+#define COMPAT53_LUA_CPP 1
+#endif // Build Lua Compat layer as C++
+#endif
+#ifndef COMPAT53_INCLUDE_SOURCE
+#define COMPAT53_INCLUDE_SOURCE 1
+#endif // Build Compat Layer Inline
+
+// beginning of sol/compatibility/compat-5.3.h
+
+#ifndef KEPLER_PROJECT_COMPAT53_H_
+#define KEPLER_PROJECT_COMPAT53_H_
+
+#include <stddef.h>
+#include <limits.h>
+#include <string.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+extern "C" {
+#endif
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+}
+#endif
+
+#ifndef COMPAT53_PREFIX
+/* we chose this name because many other lua bindings / libs have
+* their own compatibility layer, and that use the compat53 declaration
+* frequently, causing all kinds of linker / compiler issues
+*/
+#  define COMPAT53_PREFIX kp_compat53
+#endif // COMPAT53_PREFIX
+
+#ifndef COMPAT53_API
+#  if defined(COMPAT53_INCLUDE_SOURCE) && COMPAT53_INCLUDE_SOURCE
+#    if defined(__GNUC__) || defined(__clang__)
+#      define COMPAT53_API __attribute__((__unused__)) static inline 
+#    else
+#      define COMPAT53_API static inline 
+#    endif /* Clang/GCC */
+#  else /* COMPAT53_INCLUDE_SOURCE */
+/* we are not including source, so everything is extern */
+#      define COMPAT53_API extern
+#  endif /* COMPAT53_INCLUDE_SOURCE */
+#endif /* COMPAT53_PREFIX */
+
+#define COMPAT53_CONCAT_HELPER(a, b) a##b
+#define COMPAT53_CONCAT(a, b) COMPAT53_CONCAT_HELPER(a, b)
+
+/* declarations for Lua 5.1 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+
+/* XXX not implemented:
+* lua_arith (new operators)
+* lua_upvalueid
+* lua_upvaluejoin
+* lua_version
+* lua_yieldk
+*/
+
+#ifndef LUA_OK
+#  define LUA_OK 0
+#endif
+#ifndef LUA_OPADD
+#  define LUA_OPADD 0
+#endif
+#ifndef LUA_OPSUB
+#  define LUA_OPSUB 1
+#endif
+#ifndef LUA_OPMUL
+#  define LUA_OPMUL 2
+#endif
+#ifndef LUA_OPDIV
+#  define LUA_OPDIV 3
+#endif
+#ifndef LUA_OPMOD
+#  define LUA_OPMOD 4
+#endif
+#ifndef LUA_OPPOW
+#  define LUA_OPPOW 5
+#endif
+#ifndef LUA_OPUNM
+#  define LUA_OPUNM 6
+#endif
+#ifndef LUA_OPEQ
+#  define LUA_OPEQ 0
+#endif
+#ifndef LUA_OPLT
+#  define LUA_OPLT 1
+#endif
+#ifndef LUA_OPLE
+#  define LUA_OPLE 2
+#endif
+
+/* LuaJIT/Lua 5.1 does not have the updated
+* error codes for thread status/function returns (but some patched versions do)
+* define it only if it's not found
+*/
+#if !defined(LUA_ERRGCMM)
+/* Use + 2 because in some versions of Lua (Lua 5.1)
+* LUA_ERRFILE is defined as (LUA_ERRERR+1)
+* so we need to avoid it (LuaJIT might have something at this
+* integer value too)
+*/
+#  define LUA_ERRGCMM (LUA_ERRERR + 2)
+#endif /* LUA_ERRGCMM define */
+
+#if !defined(MOONJIT_VERSION)
+typedef size_t lua_Unsigned;
+#endif
+
+typedef struct luaL_Buffer_53 {
+	luaL_Buffer b; /* make incorrect code crash! */
+	char *ptr;
+	size_t nelems;
+	size_t capacity;
+	lua_State *L2;
+} luaL_Buffer_53;
+#define luaL_Buffer luaL_Buffer_53
+
+/* In PUC-Rio 5.1, userdata is a simple FILE*
+* In LuaJIT, it's a struct where the first member is a FILE*
+* We can't support the `closef` member
+*/
+typedef struct luaL_Stream {
+	FILE *f;
+} luaL_Stream;
+
+#define lua_absindex COMPAT53_CONCAT(COMPAT53_PREFIX, _absindex)
+COMPAT53_API int lua_absindex(lua_State *L, int i);
+
+#define lua_arith COMPAT53_CONCAT(COMPAT53_PREFIX, _arith)
+COMPAT53_API void lua_arith(lua_State *L, int op);
+
+#define lua_compare COMPAT53_CONCAT(COMPAT53_PREFIX, _compare)
+COMPAT53_API int lua_compare(lua_State *L, int idx1, int idx2, int op);
+
+#define lua_copy COMPAT53_CONCAT(COMPAT53_PREFIX, _copy)
+COMPAT53_API void lua_copy(lua_State *L, int from, int to);
+
+#define lua_getuservalue(L, i) \
+  (lua_getfenv((L), (i)), lua_type((L), -1))
+#define lua_setuservalue(L, i) \
+  (luaL_checktype((L), -1, LUA_TTABLE), lua_setfenv((L), (i)))
+
+#define lua_len COMPAT53_CONCAT(COMPAT53_PREFIX, _len)
+COMPAT53_API void lua_len(lua_State *L, int i);
+
+#define lua_pushstring(L, s) \
+  (lua_pushstring((L), (s)), lua_tostring((L), -1))
+
+#define lua_pushlstring(L, s, len) \
+  ((((len) == 0) ? lua_pushlstring((L), "", 0) : lua_pushlstring((L), (s), (len))), lua_tostring((L), -1))
+
+#ifndef luaL_newlibtable
+#  define luaL_newlibtable(L, l) \
+  (lua_createtable((L), 0, sizeof((l))/sizeof(*(l))-1))
+#endif
+#ifndef luaL_newlib
+#  define luaL_newlib(L, l) \
+  (luaL_newlibtable((L), (l)), luaL_register((L), NULL, (l)))
+#endif
+
+#ifndef lua_pushglobaltable
+#  define lua_pushglobaltable(L) \
+  lua_pushvalue((L), LUA_GLOBALSINDEX)
+#endif
+#define lua_rawgetp COMPAT53_CONCAT(COMPAT53_PREFIX, _rawgetp)
+COMPAT53_API int lua_rawgetp(lua_State *L, int i, const void *p);
+
+#define lua_rawsetp COMPAT53_CONCAT(COMPAT53_PREFIX, _rawsetp)
+COMPAT53_API void lua_rawsetp(lua_State *L, int i, const void *p);
+
+#define lua_rawlen(L, i) lua_objlen((L), (i))
+
+#define lua_tointeger(L, i) lua_tointegerx((L), (i), NULL)
+
+#define lua_tonumberx COMPAT53_CONCAT(COMPAT53_PREFIX, _tonumberx)
+COMPAT53_API lua_Number lua_tonumberx(lua_State *L, int i, int *isnum);
+
+#define luaL_checkversion COMPAT53_CONCAT(COMPAT53_PREFIX, L_checkversion)
+COMPAT53_API void luaL_checkversion(lua_State *L);
+
+#define lua_load COMPAT53_CONCAT(COMPAT53_PREFIX, _load_53)
+COMPAT53_API int lua_load(lua_State *L, lua_Reader reader, void *data, const char* source, const char* mode);
+
+#define luaL_loadfilex COMPAT53_CONCAT(COMPAT53_PREFIX, L_loadfilex)
+COMPAT53_API int luaL_loadfilex(lua_State *L, const char *filename, const char *mode);
+
+#define luaL_loadbufferx COMPAT53_CONCAT(COMPAT53_PREFIX, L_loadbufferx)
+COMPAT53_API int luaL_loadbufferx(lua_State *L, const char *buff, size_t sz, const char *name, const char *mode);
+
+#define luaL_checkstack COMPAT53_CONCAT(COMPAT53_PREFIX, L_checkstack_53)
+COMPAT53_API void luaL_checkstack(lua_State *L, int sp, const char *msg);
+
+#define luaL_getsubtable COMPAT53_CONCAT(COMPAT53_PREFIX, L_getsubtable)
+COMPAT53_API int luaL_getsubtable(lua_State* L, int i, const char *name);
+
+#define luaL_len COMPAT53_CONCAT(COMPAT53_PREFIX, L_len)
+COMPAT53_API lua_Integer luaL_len(lua_State *L, int i);
+
+#define luaL_setfuncs COMPAT53_CONCAT(COMPAT53_PREFIX, L_setfuncs)
+COMPAT53_API void luaL_setfuncs(lua_State *L, const luaL_Reg *l, int nup);
+
+#define luaL_setmetatable COMPAT53_CONCAT(COMPAT53_PREFIX, L_setmetatable)
+COMPAT53_API void luaL_setmetatable(lua_State *L, const char *tname);
+
+#define luaL_testudata COMPAT53_CONCAT(COMPAT53_PREFIX, L_testudata)
+COMPAT53_API void *luaL_testudata(lua_State *L, int i, const char *tname);
+
+#define luaL_traceback COMPAT53_CONCAT(COMPAT53_PREFIX, L_traceback)
+COMPAT53_API void luaL_traceback(lua_State *L, lua_State *L1, const char *msg, int level);
+
+#define luaL_fileresult COMPAT53_CONCAT(COMPAT53_PREFIX, L_fileresult)
+COMPAT53_API int luaL_fileresult(lua_State *L, int stat, const char *fname);
+
+#define luaL_execresult COMPAT53_CONCAT(COMPAT53_PREFIX, L_execresult)
+COMPAT53_API int luaL_execresult(lua_State *L, int stat);
+
+#define lua_callk(L, na, nr, ctx, cont) \
+  ((void)(ctx), (void)(cont), lua_call((L), (na), (nr)))
+#define lua_pcallk(L, na, nr, err, ctx, cont) \
+  ((void)(ctx), (void)(cont), lua_pcall((L), (na), (nr), (err)))
+
+#define lua_resume(L, from, nargs) \
+  ((void)(from), lua_resume((L), (nargs)))
+
+#define luaL_buffinit COMPAT53_CONCAT(COMPAT53_PREFIX, _buffinit_53)
+COMPAT53_API void luaL_buffinit(lua_State *L, luaL_Buffer_53 *B);
+
+#define luaL_prepbuffsize COMPAT53_CONCAT(COMPAT53_PREFIX, _prepbufsize_53)
+COMPAT53_API char *luaL_prepbuffsize(luaL_Buffer_53 *B, size_t s);
+
+#define luaL_addlstring COMPAT53_CONCAT(COMPAT53_PREFIX, _addlstring_53)
+COMPAT53_API void luaL_addlstring(luaL_Buffer_53 *B, const char *s, size_t l);
+
+#define luaL_addvalue COMPAT53_CONCAT(COMPAT53_PREFIX, _addvalue_53)
+COMPAT53_API void luaL_addvalue(luaL_Buffer_53 *B);
+
+#define luaL_pushresult COMPAT53_CONCAT(COMPAT53_PREFIX, _pushresult_53)
+COMPAT53_API void luaL_pushresult(luaL_Buffer_53 *B);
+
+#undef luaL_buffinitsize
+#define luaL_buffinitsize(L, B, s) \
+  (luaL_buffinit((L), (B)), luaL_prepbuffsize((B), (s)))
+
+#undef luaL_prepbuffer
+#define luaL_prepbuffer(B) \
+  luaL_prepbuffsize((B), LUAL_BUFFERSIZE)
+
+#undef luaL_addchar
+#define luaL_addchar(B, c) \
+  ((void)((B)->nelems < (B)->capacity || luaL_prepbuffsize((B), 1)), \
+   ((B)->ptr[(B)->nelems++] = (c)))
+
+#undef luaL_addsize
+#define luaL_addsize(B, s) \
+  ((B)->nelems += (s))
+
+#undef luaL_addstring
+#define luaL_addstring(B, s) \
+  luaL_addlstring((B), (s), strlen((s)))
+
+#undef luaL_pushresultsize
+#define luaL_pushresultsize(B, s) \
+  (luaL_addsize((B), (s)), luaL_pushresult((B)))
+
+#if defined(LUA_COMPAT_APIINTCASTS)
+#define lua_pushunsigned(L, n) \
+  lua_pushinteger((L), (lua_Integer)(n))
+#define lua_tounsignedx(L, i, is) \
+  ((lua_Unsigned)lua_tointegerx((L), (i), (is)))
+#define lua_tounsigned(L, i) \
+  lua_tounsignedx((L), (i), NULL)
+#define luaL_checkunsigned(L, a) \
+  ((lua_Unsigned)luaL_checkinteger((L), (a)))
+#define luaL_optunsigned(L, a, d) \
+  ((lua_Unsigned)luaL_optinteger((L), (a), (lua_Integer)(d)))
+#endif
+
+#endif /* Lua 5.1 only */
+
+/* declarations for Lua 5.1 and 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 502
+
+typedef int lua_KContext;
+
+typedef int(*lua_KFunction)(lua_State *L, int status, lua_KContext ctx);
+
+#define lua_dump(L, w, d, s) \
+  ((void)(s), lua_dump((L), (w), (d)))
+
+#define lua_getfield(L, i, k) \
+  (lua_getfield((L), (i), (k)), lua_type((L), -1))
+
+#define lua_gettable(L, i) \
+  (lua_gettable((L), (i)), lua_type((L), -1))
+
+#define lua_geti COMPAT53_CONCAT(COMPAT53_PREFIX, _geti)
+COMPAT53_API int lua_geti(lua_State *L, int index, lua_Integer i);
+
+#define lua_isinteger COMPAT53_CONCAT(COMPAT53_PREFIX, _isinteger)
+COMPAT53_API int lua_isinteger(lua_State *L, int index);
+
+#define lua_tointegerx COMPAT53_CONCAT(COMPAT53_PREFIX, _tointegerx_53)
+COMPAT53_API lua_Integer lua_tointegerx(lua_State *L, int i, int *isnum);
+
+#define lua_numbertointeger(n, p) \
+  ((*(p) = (lua_Integer)(n)), 1)
+
+#define lua_rawget(L, i) \
+  (lua_rawget((L), (i)), lua_type((L), -1))
+
+#define lua_rawgeti(L, i, n) \
+  (lua_rawgeti((L), (i), (n)), lua_type((L), -1))
+
+#define lua_rotate COMPAT53_CONCAT(COMPAT53_PREFIX, _rotate)
+COMPAT53_API void lua_rotate(lua_State *L, int idx, int n);
+
+#define lua_seti COMPAT53_CONCAT(COMPAT53_PREFIX, _seti)
+COMPAT53_API void lua_seti(lua_State *L, int index, lua_Integer i);
+
+#define lua_stringtonumber COMPAT53_CONCAT(COMPAT53_PREFIX, _stringtonumber)
+COMPAT53_API size_t lua_stringtonumber(lua_State *L, const char *s);
+
+#define luaL_tolstring COMPAT53_CONCAT(COMPAT53_PREFIX, L_tolstring)
+COMPAT53_API const char *luaL_tolstring(lua_State *L, int idx, size_t *len);
+
+#define luaL_getmetafield(L, o, e) \
+  (luaL_getmetafield((L), (o), (e)) ? lua_type((L), -1) : LUA_TNIL)
+
+#define luaL_newmetatable(L, tn) \
+  (luaL_newmetatable((L), (tn)) ? (lua_pushstring((L), (tn)), lua_setfield((L), -2, "__name"), 1) : 0)
+
+#define luaL_requiref COMPAT53_CONCAT(COMPAT53_PREFIX, L_requiref_53)
+COMPAT53_API void luaL_requiref(lua_State *L, const char *modname,
+	lua_CFunction openf, int glb);
+
+#endif /* Lua 5.1 and Lua 5.2 */
+
+/* declarations for Lua 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 502
+
+/* XXX not implemented:
+* lua_isyieldable
+* lua_getextraspace
+* lua_arith (new operators)
+* lua_pushfstring (new formats)
+*/
+
+#define lua_getglobal(L, n) \
+  (lua_getglobal((L), (n)), lua_type((L), -1))
+
+#define lua_getuservalue(L, i) \
+  (lua_getuservalue((L), (i)), lua_type((L), -1))
+
+#define lua_pushlstring(L, s, len) \
+  (((len) == 0) ? lua_pushlstring((L), "", 0) : lua_pushlstring((L), (s), (len)))
+
+#define lua_rawgetp(L, i, p) \
+  (lua_rawgetp((L), (i), (p)), lua_type((L), -1))
+
+#define LUA_KFUNCTION(_name) \
+  static int (_name)(lua_State *L, int status, lua_KContext ctx); \
+  static int (_name ## _52)(lua_State *L) { \
+    lua_KContext ctx; \
+    int status = lua_getctx(L, &ctx); \
+    return (_name)(L, status, ctx); \
+  } \
+  static int (_name)(lua_State *L, int status, lua_KContext ctx)
+
+#define lua_pcallk(L, na, nr, err, ctx, cont) \
+  lua_pcallk((L), (na), (nr), (err), (ctx), cont ## _52)
+
+#define lua_callk(L, na, nr, ctx, cont) \
+  lua_callk((L), (na), (nr), (ctx), cont ## _52)
+
+#define lua_yieldk(L, nr, ctx, cont) \
+  lua_yieldk((L), (nr), (ctx), cont ## _52)
+
+#ifdef lua_call
+#  undef lua_call
+#  define lua_call(L, na, nr) \
+  (lua_callk)((L), (na), (nr), 0, NULL)
+#endif
+
+#ifdef lua_pcall
+#  undef lua_pcall
+#  define lua_pcall(L, na, nr, err) \
+  (lua_pcallk)((L), (na), (nr), (err), 0, NULL)
+#endif
+
+#ifdef lua_yield
+#  undef lua_yield
+#  define lua_yield(L, nr) \
+  (lua_yieldk)((L), (nr), 0, NULL)
+#endif
+
+#endif /* Lua 5.2 only */
+
+/* other Lua versions */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501 || LUA_VERSION_NUM > 504
+
+#  error "unsupported Lua version (i.e. not Lua 5.1, 5.2, 5.3, or 5.4)"
+
+#endif /* other Lua versions except 5.1, 5.2, 5.3, and 5.4 */
+
+/* helper macro for defining continuation functions (for every version
+* *except* Lua 5.2) */
+#ifndef LUA_KFUNCTION
+#define LUA_KFUNCTION(_name) \
+  static int (_name)(lua_State *L, int status, lua_KContext ctx)
+#endif
+
+#if defined(COMPAT53_INCLUDE_SOURCE) && COMPAT53_INCLUDE_SOURCE == 1
+// beginning of sol/compatibility/compat-5.3.c.h
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+
+/* don't compile it again if it already is included via compat53.h */
+#ifndef KEPLER_PROJECT_COMPAT53_C_
+#define KEPLER_PROJECT_COMPAT53_C_
+
+/* definitions for Lua 5.1 only */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+
+#ifndef COMPAT53_FOPEN_NO_LOCK
+#if defined(_MSC_VER)
+#define COMPAT53_FOPEN_NO_LOCK 1
+#else /* otherwise */
+#define COMPAT53_FOPEN_NO_LOCK 0
+#endif /* VC++ only so far */
+#endif /* No-lock fopen_s usage if possible */
+
+#if defined(_MSC_VER) && COMPAT53_FOPEN_NO_LOCK
+#include <share.h>
+#endif /* VC++ _fsopen for share-allowed file read */
+
+#ifndef COMPAT53_HAVE_STRERROR_R
+#if defined(__GLIBC__) || defined(_POSIX_VERSION) || defined(__APPLE__) || (!defined(__MINGW32__) && defined(__GNUC__) && (__GNUC__ < 6))
+#define COMPAT53_HAVE_STRERROR_R 1
+#else /* none of the defines matched: define to 0 */
+#define COMPAT53_HAVE_STRERROR_R 0
+#endif /* have strerror_r of some form */
+#endif /* strerror_r */
+
+#ifndef COMPAT53_HAVE_STRERROR_S
+#if defined(_MSC_VER) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || (defined(__STDC_LIB_EXT1__) && __STDC_LIB_EXT1__)
+#define COMPAT53_HAVE_STRERROR_S 1
+#else /* not VC++ or C11 */
+#define COMPAT53_HAVE_STRERROR_S 0
+#endif /* strerror_s from VC++ or C11 */
+#endif /* strerror_s */
+
+#ifndef COMPAT53_LUA_FILE_BUFFER_SIZE
+#define COMPAT53_LUA_FILE_BUFFER_SIZE 4096
+#endif /* Lua File Buffer Size */
+
+static char* compat53_strerror(int en, char* buff, size_t sz) {
+#if COMPAT53_HAVE_STRERROR_R
+	/* use strerror_r here, because it's available on these specific platforms */
+	if (sz > 0) {
+		buff[0] = '\0';
+		/* we don't care whether the GNU version or the XSI version is used: */
+		if (strerror_r(en, buff, sz)) {
+			/* Yes, we really DO want to ignore the return value!
+			 * GCC makes that extra hard, not even a (void) cast will do. */
+		}
+		if (buff[0] == '\0') {
+			/* Buffer is unchanged, so we probably have called GNU strerror_r which
+			 * returned a static constant string. Chances are that strerror will
+			 * return the same static constant string and therefore be thread-safe. */
+			return strerror(en);
+		}
+	}
+	return buff; /* sz is 0 *or* strerror_r wrote into the buffer */
+#elif COMPAT53_HAVE_STRERROR_S
+	/* for MSVC and other C11 implementations, use strerror_s since it's
+	 * provided by default by the libraries */
+	strerror_s(buff, sz, en);
+	return buff;
+#else
+	/* fallback, but strerror is not guaranteed to be threadsafe due to modifying
+	 * errno itself and some impls not locking a static buffer for it ... but most
+	 * known systems have threadsafe errno: this might only change if the locale
+	 * is changed out from under someone while this function is being called */
+	(void)buff;
+	(void)sz;
+	return strerror(en);
+#endif
+}
+
+COMPAT53_API int lua_absindex(lua_State* L, int i) {
+	if (i < 0 && i > LUA_REGISTRYINDEX)
+		i += lua_gettop(L) + 1;
+	return i;
+}
+
+static void compat53_call_lua(lua_State* L, char const code[], size_t len, int nargs, int nret) {
+	lua_rawgetp(L, LUA_REGISTRYINDEX, (void*)code);
+	if (lua_type(L, -1) != LUA_TFUNCTION) {
+		lua_pop(L, 1);
+		if (luaL_loadbuffer(L, code, len, "=none"))
+			lua_error(L);
+		lua_pushvalue(L, -1);
+		lua_rawsetp(L, LUA_REGISTRYINDEX, (void*)code);
+	}
+	lua_insert(L, -nargs - 1);
+	lua_call(L, nargs, nret);
+}
+
+COMPAT53_API void lua_arith(lua_State* L, int op) {
+	static const char compat53_arith_code[]
+	     = "local op,a,b=...\n"
+	       "if op==0 then return a+b\n"
+	       "elseif op==1 then return a-b\n"
+	       "elseif op==2 then return a*b\n"
+	       "elseif op==3 then return a/b\n"
+	       "elseif op==4 then return a%b\n"
+	       "elseif op==5 then return a^b\n"
+	       "elseif op==6 then return -a\n"
+	       "end\n";
+
+	if (op < LUA_OPADD || op > LUA_OPUNM)
+		luaL_error(L, "invalid 'op' argument for lua_arith");
+	luaL_checkstack(L, 5, "not enough stack slots");
+	if (op == LUA_OPUNM)
+		lua_pushvalue(L, -1);
+	lua_pushnumber(L, op);
+	lua_insert(L, -3);
+	compat53_call_lua(L, compat53_arith_code, sizeof(compat53_arith_code) - 1, 3, 1);
+}
+
+COMPAT53_API int lua_compare(lua_State* L, int idx1, int idx2, int op) {
+	static const char compat53_compare_code[]
+	     = "local a,b=...\n"
+	       "return a<=b\n";
+
+	int result = 0;
+	switch (op) {
+	case LUA_OPEQ:
+		return lua_equal(L, idx1, idx2);
+	case LUA_OPLT:
+		return lua_lessthan(L, idx1, idx2);
+	case LUA_OPLE:
+		luaL_checkstack(L, 5, "not enough stack slots");
+		idx1 = lua_absindex(L, idx1);
+		idx2 = lua_absindex(L, idx2);
+		lua_pushvalue(L, idx1);
+		lua_pushvalue(L, idx2);
+		compat53_call_lua(L, compat53_compare_code, sizeof(compat53_compare_code) - 1, 2, 1);
+		result = lua_toboolean(L, -1);
+		lua_pop(L, 1);
+		return result;
+	default:
+		luaL_error(L, "invalid 'op' argument for lua_compare");
+	}
+	return 0;
+}
+
+COMPAT53_API void lua_copy(lua_State* L, int from, int to) {
+	int abs_to = lua_absindex(L, to);
+	luaL_checkstack(L, 1, "not enough stack slots");
+	lua_pushvalue(L, from);
+	lua_replace(L, abs_to);
+}
+
+COMPAT53_API void lua_len(lua_State* L, int i) {
+	switch (lua_type(L, i)) {
+	case LUA_TSTRING:
+		lua_pushnumber(L, (lua_Number)lua_objlen(L, i));
+		break;
+	case LUA_TTABLE:
+		if (!luaL_callmeta(L, i, "__len"))
+			lua_pushnumber(L, (lua_Number)lua_objlen(L, i));
+		break;
+	case LUA_TUSERDATA:
+		if (luaL_callmeta(L, i, "__len"))
+			break;
+		/* FALLTHROUGH */
+	default:
+		luaL_error(L, "attempt to get length of a %s value", lua_typename(L, lua_type(L, i)));
+	}
+}
+
+COMPAT53_API int lua_rawgetp(lua_State* L, int i, const void* p) {
+	int abs_i = lua_absindex(L, i);
+	lua_pushlightuserdata(L, (void*)p);
+	lua_rawget(L, abs_i);
+	return lua_type(L, -1);
+}
+
+COMPAT53_API void lua_rawsetp(lua_State* L, int i, const void* p) {
+	int abs_i = lua_absindex(L, i);
+	luaL_checkstack(L, 1, "not enough stack slots");
+	lua_pushlightuserdata(L, (void*)p);
+	lua_insert(L, -2);
+	lua_rawset(L, abs_i);
+}
+
+COMPAT53_API lua_Number lua_tonumberx(lua_State* L, int i, int* isnum) {
+	lua_Number n = lua_tonumber(L, i);
+	if (isnum != NULL) {
+		*isnum = (n != 0 || lua_isnumber(L, i));
+	}
+	return n;
+}
+
+COMPAT53_API void luaL_checkversion(lua_State* L) {
+	(void)L;
+}
+
+COMPAT53_API void luaL_checkstack(lua_State* L, int sp, const char* msg) {
+	if (!lua_checkstack(L, sp + LUA_MINSTACK)) {
+		if (msg != NULL)
+			luaL_error(L, "stack overflow (%s)", msg);
+		else {
+			lua_pushliteral(L, "stack overflow");
+			lua_error(L);
+		}
+	}
+}
+
+COMPAT53_API int luaL_getsubtable(lua_State* L, int i, const char* name) {
+	int abs_i = lua_absindex(L, i);
+	luaL_checkstack(L, 3, "not enough stack slots");
+	lua_pushstring(L, name);
+	lua_gettable(L, abs_i);
+	if (lua_istable(L, -1))
+		return 1;
+	lua_pop(L, 1);
+	lua_newtable(L);
+	lua_pushstring(L, name);
+	lua_pushvalue(L, -2);
+	lua_settable(L, abs_i);
+	return 0;
+}
+
+COMPAT53_API lua_Integer luaL_len(lua_State* L, int i) {
+	lua_Integer res = 0;
+	int isnum = 0;
+	luaL_checkstack(L, 1, "not enough stack slots");
+	lua_len(L, i);
+	res = lua_tointegerx(L, -1, &isnum);
+	lua_pop(L, 1);
+	if (!isnum)
+		luaL_error(L, "object length is not an integer");
+	return res;
+}
+
+COMPAT53_API void luaL_setfuncs(lua_State* L, const luaL_Reg* l, int nup) {
+	luaL_checkstack(L, nup + 1, "too many upvalues");
+	for (; l->name != NULL; l++) { /* fill the table with given functions */
+		int i;
+		lua_pushstring(L, l->name);
+		for (i = 0; i < nup; i++) /* copy upvalues to the top */
+			lua_pushvalue(L, -(nup + 1));
+		lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */
+		lua_settable(L, -(nup + 3));       /* table must be below the upvalues, the name and the closure */
+	}
+	lua_pop(L, nup); /* remove upvalues */
+}
+
+COMPAT53_API void luaL_setmetatable(lua_State* L, const char* tname) {
+	luaL_checkstack(L, 1, "not enough stack slots");
+	luaL_getmetatable(L, tname);
+	lua_setmetatable(L, -2);
+}
+
+COMPAT53_API void* luaL_testudata(lua_State* L, int i, const char* tname) {
+	void* p = lua_touserdata(L, i);
+	luaL_checkstack(L, 2, "not enough stack slots");
+	if (p == NULL || !lua_getmetatable(L, i))
+		return NULL;
+	else {
+		int res = 0;
+		luaL_getmetatable(L, tname);
+		res = lua_rawequal(L, -1, -2);
+		lua_pop(L, 2);
+		if (!res)
+			p = NULL;
+	}
+	return p;
+}
+
+static int compat53_countlevels(lua_State* L) {
+	lua_Debug ar;
+	int li = 1, le = 1;
+	/* find an upper bound */
+	while (lua_getstack(L, le, &ar)) {
+		li = le;
+		le *= 2;
+	}
+	/* do a binary search */
+	while (li < le) {
+		int m = (li + le) / 2;
+		if (lua_getstack(L, m, &ar))
+			li = m + 1;
+		else
+			le = m;
+	}
+	return le - 1;
+}
+
+static int compat53_findfield(lua_State* L, int objidx, int level) {
+	if (level == 0 || !lua_istable(L, -1))
+		return 0;                               /* not found */
+	lua_pushnil(L);                              /* start 'next' loop */
+	while (lua_next(L, -2)) {                    /* for each pair in table */
+		if (lua_type(L, -2) == LUA_TSTRING) {   /* ignore non-string keys */
+			if (lua_rawequal(L, objidx, -1)) { /* found object? */
+				lua_pop(L, 1);                /* remove value (but keep name) */
+				return 1;
+			}
+			else if (compat53_findfield(L, objidx, level - 1)) { /* try recursively */
+				lua_remove(L, -2);                              /* remove table (but keep name) */
+				lua_pushliteral(L, ".");
+				lua_insert(L, -2); /* place '.' between the two names */
+				lua_concat(L, 3);
+				return 1;
+			}
+		}
+		lua_pop(L, 1); /* remove value */
+	}
+	return 0; /* not found */
+}
+
+static int compat53_pushglobalfuncname(lua_State* L, lua_Debug* ar) {
+	int top = lua_gettop(L);
+	lua_getinfo(L, "f", ar); /* push function */
+	lua_pushvalue(L, LUA_GLOBALSINDEX);
+	if (compat53_findfield(L, top + 1, 2)) {
+		lua_copy(L, -1, top + 1); /* move name to proper place */
+		lua_pop(L, 2);            /* remove pushed values */
+		return 1;
+	}
+	else {
+		lua_settop(L, top); /* remove function and global table */
+		return 0;
+	}
+}
+
+static void compat53_pushfuncname(lua_State* L, lua_Debug* ar) {
+	if (*ar->namewhat != '\0') /* is there a name? */
+		lua_pushfstring(L, "function " LUA_QS, ar->name);
+	else if (*ar->what == 'm') /* main? */
+		lua_pushliteral(L, "main chunk");
+	else if (*ar->what == 'C') {
+		if (compat53_pushglobalfuncname(L, ar)) {
+			lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1));
+			lua_remove(L, -2); /* remove name */
+		}
+		else
+			lua_pushliteral(L, "?");
+	}
+	else
+		lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
+}
+
+#define COMPAT53_LEVELS1 12 /* size of the first part of the stack */
+#define COMPAT53_LEVELS2 10 /* size of the second part of the stack */
+
+COMPAT53_API void luaL_traceback(lua_State* L, lua_State* L1, const char* msg, int level) {
+	lua_Debug ar;
+	int top = lua_gettop(L);
+	int numlevels = compat53_countlevels(L1);
+	int mark = (numlevels > COMPAT53_LEVELS1 + COMPAT53_LEVELS2) ? COMPAT53_LEVELS1 : 0;
+	if (msg)
+		lua_pushfstring(L, "%s\n", msg);
+	lua_pushliteral(L, "stack traceback:");
+	while (lua_getstack(L1, level++, &ar)) {
+		if (level == mark) {                       /* too many levels? */
+			lua_pushliteral(L, "\n\t...");        /* add a '...' */
+			level = numlevels - COMPAT53_LEVELS2; /* and skip to last ones */
+		}
+		else {
+			lua_getinfo(L1, "Slnt", &ar);
+			lua_pushfstring(L, "\n\t%s:", ar.short_src);
+			if (ar.currentline > 0)
+				lua_pushfstring(L, "%d:", ar.currentline);
+			lua_pushliteral(L, " in ");
+			compat53_pushfuncname(L, &ar);
+			lua_concat(L, lua_gettop(L) - top);
+		}
+	}
+	lua_concat(L, lua_gettop(L) - top);
+}
+
+COMPAT53_API int luaL_fileresult(lua_State* L, int stat, const char* fname) {
+	const char* serr = NULL;
+	int en = errno; /* calls to Lua API may change this value */
+	char buf[512] = { 0 };
+	if (stat) {
+		lua_pushboolean(L, 1);
+		return 1;
+	}
+	else {
+		lua_pushnil(L);
+		serr = compat53_strerror(en, buf, sizeof(buf));
+		if (fname)
+			lua_pushfstring(L, "%s: %s", fname, serr);
+		else
+			lua_pushstring(L, serr);
+		lua_pushnumber(L, (lua_Number)en);
+		return 3;
+	}
+}
+
+static int compat53_checkmode(lua_State* L, const char* mode, const char* modename, int err) {
+	if (mode && strchr(mode, modename[0]) == NULL) {
+		lua_pushfstring(L, "attempt to load a %s chunk (mode is '%s')", modename, mode);
+		return err;
+	}
+	return LUA_OK;
+}
+
+typedef struct {
+	lua_Reader reader;
+	void* ud;
+	int has_peeked_data;
+	const char* peeked_data;
+	size_t peeked_data_size;
+} compat53_reader_data;
+
+static const char* compat53_reader(lua_State* L, void* ud, size_t* size) {
+	compat53_reader_data* data = (compat53_reader_data*)ud;
+	if (data->has_peeked_data) {
+		data->has_peeked_data = 0;
+		*size = data->peeked_data_size;
+		return data->peeked_data;
+	}
+	else
+		return data->reader(L, data->ud, size);
+}
+
+COMPAT53_API int lua_load(lua_State* L, lua_Reader reader, void* data, const char* source, const char* mode) {
+	int status = LUA_OK;
+	compat53_reader_data compat53_data = { reader, data, 1, 0, 0 };
+	compat53_data.peeked_data = reader(L, data, &(compat53_data.peeked_data_size));
+	if (compat53_data.peeked_data && compat53_data.peeked_data_size && compat53_data.peeked_data[0] == LUA_SIGNATURE[0]) /* binary file? */
+		status = compat53_checkmode(L, mode, "binary", LUA_ERRSYNTAX);
+	else
+		status = compat53_checkmode(L, mode, "text", LUA_ERRSYNTAX);
+	if (status != LUA_OK)
+		return status;
+		/* we need to call the original 5.1 version of lua_load! */
+#undef lua_load
+	return lua_load(L, compat53_reader, &compat53_data, source);
+#define lua_load COMPAT53_CONCAT(COMPAT53_PREFIX, _load_53)
+}
+
+typedef struct {
+	int n;                                    /* number of pre-read characters */
+	FILE* f;                                  /* file being read */
+	char buff[COMPAT53_LUA_FILE_BUFFER_SIZE]; /* area for reading file */
+} compat53_LoadF;
+
+static const char* compat53_getF(lua_State* L, void* ud, size_t* size) {
+	compat53_LoadF* lf = (compat53_LoadF*)ud;
+	(void)L;            /* not used */
+	if (lf->n > 0) {    /* are there pre-read characters to be read? */
+		*size = lf->n; /* return them (chars already in buffer) */
+		lf->n = 0;     /* no more pre-read characters */
+	}
+	else { /* read a block from file */
+		  /* 'fread' can return > 0 *and* set the EOF flag. If next call to
+		  'compat53_getF' called 'fread', it might still wait for user input.
+		  The next check avoids this problem. */
+		if (feof(lf->f))
+			return NULL;
+		*size = fread(lf->buff, 1, sizeof(lf->buff), lf->f); /* read block */
+	}
+	return lf->buff;
+}
+
+static int compat53_errfile(lua_State* L, const char* what, int fnameindex) {
+	char buf[512] = { 0 };
+	const char* serr = compat53_strerror(errno, buf, sizeof(buf));
+	const char* filename = lua_tostring(L, fnameindex) + 1;
+	lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
+	lua_remove(L, fnameindex);
+	return LUA_ERRFILE;
+}
+
+static int compat53_skipBOM(compat53_LoadF* lf) {
+	const char* p = "\xEF\xBB\xBF"; /* UTF-8 BOM mark */
+	int c;
+	lf->n = 0;
+	do {
+		c = getc(lf->f);
+		if (c == EOF || c != *(const unsigned char*)p++)
+			return c;
+		lf->buff[lf->n++] = (char)c; /* to be read by the parser */
+	} while (*p != '\0');
+	lf->n = 0;          /* prefix matched; discard it */
+	return getc(lf->f); /* return next character */
+}
+
+/*
+** reads the first character of file 'f' and skips an optional BOM mark
+** in its beginning plus its first line if it starts with '#'. Returns
+** true if it skipped the first line.  In any case, '*cp' has the
+** first "valid" character of the file (after the optional BOM and
+** a first-line comment).
+*/
+static int compat53_skipcomment(compat53_LoadF* lf, int* cp) {
+	int c = *cp = compat53_skipBOM(lf);
+	if (c == '#') { /* first line is a comment (Unix exec. file)? */
+		do {       /* skip first line */
+			c = getc(lf->f);
+		} while (c != EOF && c != '\n');
+		*cp = getc(lf->f); /* skip end-of-line, if present */
+		return 1;          /* there was a comment */
+	}
+	else
+		return 0; /* no comment */
+}
+
+COMPAT53_API int luaL_loadfilex(lua_State* L, const char* filename, const char* mode) {
+	compat53_LoadF lf;
+	int status, readstatus;
+	int c;
+	int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */
+	if (filename == NULL) {
+		lua_pushliteral(L, "=stdin");
+		lf.f = stdin;
+	}
+	else {
+		lua_pushfstring(L, "@%s", filename);
+#if defined(_MSC_VER)
+		/* This code is here to stop a deprecation error that stops builds
+		 * if a certain macro is defined. While normally not caring would
+		 * be best, some header-only libraries and builds can't afford to
+		 * dictate this to the user. A quick check shows that fopen_s this
+		 * goes back to VS 2005, and _fsopen goes back to VS 2003 .NET,
+		 * possibly even before that so we don't need to do any version
+		 * number checks, since this has been there since forever.  */
+
+		/* TO USER: if you want the behavior of typical fopen_s/fopen,
+		 * which does lock the file on VC++, define the macro used below to 0 */
+#if COMPAT53_FOPEN_NO_LOCK
+		lf.f = _fsopen(filename, "r", _SH_DENYNO); /* do not lock the file in any way */
+		if (lf.f == NULL)
+			return compat53_errfile(L, "open", fnameindex);
+#else  /* use default locking version */
+		if (fopen_s(&lf.f, filename, "r") != 0)
+			return compat53_errfile(L, "open", fnameindex);
+#endif /* Locking vs. No-locking fopen variants */
+#else
+		lf.f = fopen(filename, "r"); /* default stdlib doesn't forcefully lock files here */
+		if (lf.f == NULL)
+			return compat53_errfile(L, "open", fnameindex);
+#endif
+	}
+	if (compat53_skipcomment(&lf, &c))       /* read initial portion */
+		lf.buff[lf.n++] = '\n';             /* add line to correct line numbers */
+	if (c == LUA_SIGNATURE[0] && filename) { /* binary file? */
+#if defined(_MSC_VER)
+		if (freopen_s(&lf.f, filename, "rb", lf.f) != 0)
+			return compat53_errfile(L, "reopen", fnameindex);
+#else
+		lf.f = freopen(filename, "rb", lf.f); /* reopen in binary mode */
+		if (lf.f == NULL)
+			return compat53_errfile(L, "reopen", fnameindex);
+#endif
+		compat53_skipcomment(&lf, &c); /* re-read initial portion */
+	}
+	if (c != EOF)
+		lf.buff[lf.n++] = (char)c; /* 'c' is the first character of the stream */
+	status = lua_load(L, &compat53_getF, &lf, lua_tostring(L, -1), mode);
+	readstatus = ferror(lf.f);
+	if (filename)
+		fclose(lf.f); /* close file (even in case of errors) */
+	if (readstatus) {
+		lua_settop(L, fnameindex); /* ignore results from 'lua_load' */
+		return compat53_errfile(L, "read", fnameindex);
+	}
+	lua_remove(L, fnameindex);
+	return status;
+}
+
+COMPAT53_API int luaL_loadbufferx(lua_State* L, const char* buff, size_t sz, const char* name, const char* mode) {
+	int status = LUA_OK;
+	if (sz > 0 && buff[0] == LUA_SIGNATURE[0]) {
+		status = compat53_checkmode(L, mode, "binary", LUA_ERRSYNTAX);
+	}
+	else {
+		status = compat53_checkmode(L, mode, "text", LUA_ERRSYNTAX);
+	}
+	if (status != LUA_OK)
+		return status;
+	return luaL_loadbuffer(L, buff, sz, name);
+}
+
+#if !defined(l_inspectstat) \
+     && (defined(unix) || defined(__unix) || defined(__unix__) || defined(__TOS_AIX__) || defined(_SYSTYPE_BSD) || (defined(__APPLE__) && defined(__MACH__)))
+/* some form of unix; check feature macros in unistd.h for details */
+#include <unistd.h>
+/* check posix version; the relevant include files and macros probably
+ * were available before 2001, but I'm not sure */
+#if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112L
+#include <sys/wait.h>
+#define l_inspectstat(stat, what)   \
+	if (WIFEXITED(stat)) {         \
+		stat = WEXITSTATUS(stat); \
+	}                              \
+	else if (WIFSIGNALED(stat)) {  \
+		stat = WTERMSIG(stat);    \
+		what = "signal";          \
+	}
+#endif
+#endif
+
+/* provide default (no-op) version */
+#if !defined(l_inspectstat)
+#define l_inspectstat(stat, what) ((void)0)
+#endif
+
+COMPAT53_API int luaL_execresult(lua_State* L, int stat) {
+	const char* what = "exit";
+	if (stat == -1)
+		return luaL_fileresult(L, 0, NULL);
+	else {
+		l_inspectstat(stat, what);
+		if (*what == 'e' && stat == 0)
+			lua_pushboolean(L, 1);
+		else
+			lua_pushnil(L);
+		lua_pushstring(L, what);
+		lua_pushinteger(L, stat);
+		return 3;
+	}
+}
+
+COMPAT53_API void luaL_buffinit(lua_State* L, luaL_Buffer_53* B) {
+	/* make it crash if used via pointer to a 5.1-style luaL_Buffer */
+	B->b.p = NULL;
+	B->b.L = NULL;
+	B->b.lvl = 0;
+	/* reuse the buffer from the 5.1-style luaL_Buffer though! */
+	B->ptr = B->b.buffer;
+	B->capacity = LUAL_BUFFERSIZE;
+	B->nelems = 0;
+	B->L2 = L;
+}
+
+COMPAT53_API char* luaL_prepbuffsize(luaL_Buffer_53* B, size_t s) {
+	if (B->capacity - B->nelems < s) { /* needs to grow */
+		char* newptr = NULL;
+		size_t newcap = B->capacity * 2;
+		if (newcap - B->nelems < s)
+			newcap = B->nelems + s;
+		if (newcap < B->capacity) /* overflow */
+			luaL_error(B->L2, "buffer too large");
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 504
+		newptr = (char*)lua_newuserdatauv(B->L2, newcap, 0);
+#else
+		newptr = (char*)lua_newuserdata(B->L2, newcap);
+#endif
+		memcpy(newptr, B->ptr, B->nelems);
+		if (B->ptr != B->b.buffer)
+			lua_replace(B->L2, -2); /* remove old buffer */
+		B->ptr = newptr;
+		B->capacity = newcap;
+	}
+	return B->ptr + B->nelems;
+}
+
+COMPAT53_API void luaL_addlstring(luaL_Buffer_53* B, const char* s, size_t l) {
+	memcpy(luaL_prepbuffsize(B, l), s, l);
+	luaL_addsize(B, l);
+}
+
+COMPAT53_API void luaL_addvalue(luaL_Buffer_53* B) {
+	size_t len = 0;
+	const char* s = lua_tolstring(B->L2, -1, &len);
+	if (!s)
+		luaL_error(B->L2, "cannot convert value to string");
+	if (B->ptr != B->b.buffer)
+		lua_insert(B->L2, -2); /* userdata buffer must be at stack top */
+	luaL_addlstring(B, s, len);
+	lua_remove(B->L2, B->ptr != B->b.buffer ? -2 : -1);
+}
+
+void luaL_pushresult(luaL_Buffer_53* B) {
+	lua_pushlstring(B->L2, B->ptr, B->nelems);
+	if (B->ptr != B->b.buffer)
+		lua_replace(B->L2, -2); /* remove userdata buffer */
+}
+
+#endif /* Lua 5.1 */
+
+/* definitions for Lua 5.1 and Lua 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 502
+
+COMPAT53_API int lua_geti(lua_State* L, int index, lua_Integer i) {
+	index = lua_absindex(L, index);
+	lua_pushinteger(L, i);
+	lua_gettable(L, index);
+	return lua_type(L, -1);
+}
+
+COMPAT53_API int lua_isinteger(lua_State* L, int index) {
+	if (lua_type(L, index) == LUA_TNUMBER) {
+		lua_Number n = lua_tonumber(L, index);
+		lua_Integer i = lua_tointeger(L, index);
+		if (i == n)
+			return 1;
+	}
+	return 0;
+}
+
+COMPAT53_API lua_Integer lua_tointegerx(lua_State* L, int i, int* isnum) {
+	int ok = 0;
+	lua_Number n = lua_tonumberx(L, i, &ok);
+	if (ok) {
+		if (n == (lua_Integer)n) {
+			if (isnum)
+				*isnum = 1;
+			return (lua_Integer)n;
+		}
+	}
+	if (isnum)
+		*isnum = 0;
+	return 0;
+}
+
+static void compat53_reverse(lua_State* L, int a, int b) {
+	for (; a < b; ++a, --b) {
+		lua_pushvalue(L, a);
+		lua_pushvalue(L, b);
+		lua_replace(L, a);
+		lua_replace(L, b);
+	}
+}
+
+COMPAT53_API void lua_rotate(lua_State* L, int idx, int n) {
+	int n_elems = 0;
+	idx = lua_absindex(L, idx);
+	n_elems = lua_gettop(L) - idx + 1;
+	if (n < 0)
+		n += n_elems;
+	if (n > 0 && n < n_elems) {
+		luaL_checkstack(L, 2, "not enough stack slots available");
+		n = n_elems - n;
+		compat53_reverse(L, idx, idx + n - 1);
+		compat53_reverse(L, idx + n, idx + n_elems - 1);
+		compat53_reverse(L, idx, idx + n_elems - 1);
+	}
+}
+
+COMPAT53_API void lua_seti(lua_State* L, int index, lua_Integer i) {
+	luaL_checkstack(L, 1, "not enough stack slots available");
+	index = lua_absindex(L, index);
+	lua_pushinteger(L, i);
+	lua_insert(L, -2);
+	lua_settable(L, index);
+}
+
+#if !defined(lua_str2number)
+#define lua_str2number(s, p) strtod((s), (p))
+#endif
+
+COMPAT53_API size_t lua_stringtonumber(lua_State* L, const char* s) {
+	char* endptr;
+	lua_Number n = lua_str2number(s, &endptr);
+	if (endptr != s) {
+		while (*endptr != '\0' && isspace((unsigned char)*endptr))
+			++endptr;
+		if (*endptr == '\0') {
+			lua_pushnumber(L, n);
+			return endptr - s + 1;
+		}
+	}
+	return 0;
+}
+
+COMPAT53_API const char* luaL_tolstring(lua_State* L, int idx, size_t* len) {
+	if (!luaL_callmeta(L, idx, "__tostring")) {
+		int t = lua_type(L, idx), tt = 0;
+		char const* name = NULL;
+		switch (t) {
+		case LUA_TNIL:
+			lua_pushliteral(L, "nil");
+			break;
+		case LUA_TSTRING:
+		case LUA_TNUMBER:
+			lua_pushvalue(L, idx);
+			break;
+		case LUA_TBOOLEAN:
+			if (lua_toboolean(L, idx))
+				lua_pushliteral(L, "true");
+			else
+				lua_pushliteral(L, "false");
+			break;
+		default:
+			tt = luaL_getmetafield(L, idx, "__name");
+			name = (tt == LUA_TSTRING) ? lua_tostring(L, -1) : lua_typename(L, t);
+			lua_pushfstring(L, "%s: %p", name, lua_topointer(L, idx));
+			if (tt != LUA_TNIL)
+				lua_replace(L, -2);
+			break;
+		}
+	}
+	else {
+		if (!lua_isstring(L, -1))
+			luaL_error(L, "'__tostring' must return a string");
+	}
+	return lua_tolstring(L, -1, len);
+}
+
+COMPAT53_API void luaL_requiref(lua_State* L, const char* modname, lua_CFunction openf, int glb) {
+	luaL_checkstack(L, 3, "not enough stack slots available");
+	luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
+	if (lua_getfield(L, -1, modname) == LUA_TNIL) {
+		lua_pop(L, 1);
+		lua_pushcfunction(L, openf);
+		lua_pushstring(L, modname);
+		lua_call(L, 1, 1);
+		lua_pushvalue(L, -1);
+		lua_setfield(L, -3, modname);
+	}
+	if (glb) {
+		lua_pushvalue(L, -1);
+		lua_setglobal(L, modname);
+	}
+	lua_replace(L, -2);
+}
+
+#endif /* Lua 5.1 and 5.2 */
+
+#endif /* KEPLER_PROJECT_COMPAT53_C_ */
+
+/*********************************************************************
+ * This file contains parts of Lua 5.2's and Lua 5.3's source code:
+ *
+ * Copyright (C) 1994-2014 Lua.org, PUC-Rio.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 OR COPYRIGHT HOLDERS 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.
+ *********************************************************************/
+// end of sol/compatibility/compat-5.3.c.h
+
+#endif
+
+#endif /* KEPLER_PROJECT_COMPAT53_H_ */
+
+// end of sol/compatibility/compat-5.3.h
+
+// beginning of sol/compatibility/compat-5.4.h
+
+#ifndef NOT_KEPLER_PROJECT_COMPAT54_H_
+#define NOT_KEPLER_PROJECT_COMPAT54_H_
+
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+extern "C" {
+#endif
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+}
+#endif
+
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 504
+
+#if !defined(LUA_ERRGCMM)
+/* So Lua 5.4 actually removes this, which breaks sol2...
+ man, this API is quite unstable...!
+*/
+#  define LUA_ERRGCMM (LUA_ERRERR + 2)
+#endif /* LUA_ERRGCMM define */
+
+#endif // Lua 5.4 only
+
+#endif // NOT_KEPLER_PROJECT_COMPAT54_H_// end of sol/compatibility/compat-5.4.h
+
+#endif
+
+// end of sol/compatibility.hpp
+
+#include <vector>
+#include <cstdint>
+#include <cstddef>
+
+namespace sol {
+
+	template <typename Allocator = std::allocator<std::byte>>
+	class basic_bytecode : private std::vector<std::byte, Allocator> {
+	private:
+		using base_t = std::vector<std::byte, Allocator>;
+
+	public:
+		using typename base_t::allocator_type;
+		using typename base_t::const_iterator;
+		using typename base_t::const_pointer;
+		using typename base_t::const_reference;
+		using typename base_t::const_reverse_iterator;
+		using typename base_t::difference_type;
+		using typename base_t::iterator;
+		using typename base_t::pointer;
+		using typename base_t::reference;
+		using typename base_t::reverse_iterator;
+		using typename base_t::size_type;
+		using typename base_t::value_type;
+
+		using base_t::base_t;
+		using base_t::operator=;
+
+		using base_t::data;
+		using base_t::empty;
+		using base_t::max_size;
+		using base_t::size;
+
+		using base_t::at;
+		using base_t::operator[];
+		using base_t::back;
+		using base_t::front;
+
+		using base_t::begin;
+		using base_t::cbegin;
+		using base_t::cend;
+		using base_t::end;
+
+		using base_t::crbegin;
+		using base_t::crend;
+		using base_t::rbegin;
+		using base_t::rend;
+
+		using base_t::get_allocator;
+		using base_t::swap;
+
+		using base_t::clear;
+		using base_t::emplace;
+		using base_t::emplace_back;
+		using base_t::erase;
+		using base_t::insert;
+		using base_t::pop_back;
+		using base_t::push_back;
+		using base_t::reserve;
+		using base_t::resize;
+		using base_t::shrink_to_fit;
+
+		string_view as_string_view() const {
+			return string_view(reinterpret_cast<const char*>(this->data()), this->size());
+		}
+	};
+
+	template <typename Container>
+	inline int basic_insert_dump_writer(lua_State*, const void* memory, size_t memory_size, void* userdata_pointer) {
+		using storage_t = Container;
+		const std::byte* p_code = static_cast<const std::byte*>(memory);
+		storage_t& bc = *static_cast<storage_t*>(userdata_pointer);
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		bc.insert(bc.cend(), p_code, p_code + memory_size);
+#else
+		try {
+			bc.insert(bc.cend(), p_code, p_code + memory_size);
+		}
+		catch (...) {
+			return -1;
+		}
+#endif
+		return 0;
+	}
+
+	using bytecode = basic_bytecode<>;
+
+	constexpr inline auto bytecode_dump_writer = &basic_insert_dump_writer<bytecode>;
+
+} // namespace sol
+
+// end of sol/bytecode.hpp
+
+// beginning of sol/stack.hpp
+
+// beginning of sol/trampoline.hpp
+
+// beginning of sol/types.hpp
+
+// beginning of sol/error.hpp
+
+#include <stdexcept>
+#include <string>
+#include <array>
+
+namespace sol {
+	namespace detail {
+		struct direct_error_tag { };
+		const auto direct_error = direct_error_tag {};
+
+		struct error_result {
+			int results;
+			const char* format_string;
+			std::array<const char*, 4> argument_strings;
+
+			error_result() : results(0), format_string(nullptr) {
+			}
+
+			error_result(int results_) : results(results_), format_string(nullptr) {
+			}
+
+			error_result(const char* format_string_, const char* first_message_) : results(0), format_string(format_string_), argument_strings() {
+				argument_strings[0] = first_message_;
+			}
+		};
+
+		inline int handle_errors(lua_State* L, const error_result& er) {
+			if (er.format_string == nullptr) {
+				return er.results;
+			}
+			return luaL_error(L, er.format_string, er.argument_strings[0], er.argument_strings[1], er.argument_strings[2], er.argument_strings[3]);
+		}
+	} // namespace detail
+
+	class error : public std::runtime_error {
+	private:
+		// Because VC++ is upsetting, most of the time!
+		std::string what_reason;
+
+	public:
+		error(const std::string& str) : error(detail::direct_error, "lua: error: " + str) {
+		}
+		error(std::string&& str) : error(detail::direct_error, "lua: error: " + std::move(str)) {
+		}
+		error(detail::direct_error_tag, const std::string& str) : std::runtime_error(""), what_reason(str) {
+		}
+		error(detail::direct_error_tag, std::string&& str) : std::runtime_error(""), what_reason(std::move(str)) {
+		}
+
+		error(const error& e) = default;
+		error(error&& e) = default;
+		error& operator=(const error& e) = default;
+		error& operator=(error&& e) = default;
+
+		virtual const char* what() const noexcept override {
+			return what_reason.c_str();
+		}
+	};
+
+} // namespace sol
+
+// end of sol/error.hpp
+
+// beginning of sol/optional.hpp
+
+// beginning of sol/in_place.hpp
+
+#include <cstddef>
+#include <utility>
+
+namespace sol {
+
+	using in_place_t = std::in_place_t;
+	constexpr std::in_place_t in_place {};
+	constexpr std::in_place_t in_place_of {};
+
+	template <typename T>
+	using in_place_type_t = std::in_place_type_t<T>;
+	template <typename T>
+	constexpr std::in_place_type_t<T> in_place_type {};
+
+	template <size_t I>
+	using in_place_index_t = std::in_place_index_t<I>;
+	template <size_t I>
+	constexpr in_place_index_t<I> in_place_index {};
+
+} // namespace sol
+
+// end of sol/in_place.hpp
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+#include <boost/optional.hpp>
+#else
+// beginning of sol/optional_implementation.hpp
+
+#define SOL_TL_OPTIONAL_VERSION_MAJOR 0
+#define SOL_TL_OPTIONAL_VERSION_MINOR 5
+
+#include <exception>
+#include <functional>
+#include <new>
+#include <type_traits>
+#include <utility>
+#include <cstdlib>
+#include <optional>
+
+#if (defined(_MSC_VER) && _MSC_VER == 1900)
+#define SOL_TL_OPTIONAL_MSVC2015
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC49
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC54
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC55
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_NO_CONSTRR
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::has_trivial_copy_constructor<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::has_trivial_copy_assign<T>::value
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+
+#elif (defined(__GNUC__) && __GNUC__ < 8 && !defined(__clang__))
+#ifndef SOL_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+#define SOL_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+namespace sol { namespace detail {
+	template <class T>
+	struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T> { };
+#ifdef _GLIBCXX_VECTOR
+	template <class T, class A>
+	struct is_trivially_copy_constructible<std::vector<T, A>> : std::is_trivially_copy_constructible<T> { };
+#endif
+}} // namespace sol::detail
+#endif
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) sol::detail::is_trivially_copy_constructible<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#else
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::is_trivially_copy_constructible<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#endif
+
+#if __cplusplus > 201103L
+#define SOL_TL_OPTIONAL_CXX14
+#endif
+
+#if (__cplusplus == 201103L || defined(SOL_TL_OPTIONAL_MSVC2015) || defined(SOL_TL_OPTIONAL_GCC49))
+#define SOL_TL_OPTIONAL_11_CONSTEXPR
+#else
+   /// \exclude
+#define SOL_TL_OPTIONAL_11_CONSTEXPR constexpr
+#endif
+
+namespace sol {
+#ifndef SOL_TL_MONOSTATE_INPLACE_MUTEX
+#define SOL_TL_MONOSTATE_INPLACE_MUTEX
+	/// \brief Used to represent an optional with no data; essentially a bool
+	class monostate { };
+#endif
+
+	template <class T>
+	class optional;
+
+	/// \exclude
+	namespace detail {
+#ifndef SOL_TL_TRAITS_MUTEX
+#define SOL_TL_TRAITS_MUTEX
+		// C++14-style aliases for brevity
+		template <class T>
+		using remove_const_t = typename std::remove_const<T>::type;
+		template <class T>
+		using remove_reference_t = typename std::remove_reference<T>::type;
+		template <class T>
+		using decay_t = typename std::decay<T>::type;
+		template <bool E, class T = void>
+		using enable_if_t = typename std::enable_if<E, T>::type;
+		template <bool B, class T, class F>
+		using conditional_t = typename std::conditional<B, T, F>::type;
+
+		// std::conjunction from C++17
+		template <class...>
+		struct conjunction : std::true_type { };
+		template <class B>
+		struct conjunction<B> : B { };
+		template <class B, class... Bs>
+		struct conjunction<B, Bs...> : std::conditional<bool(B::value), conjunction<Bs...>, B>::type { };
+
+#if defined(_LIBCPP_VERSION) && __cplusplus == 201103L
+#define SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+#endif
+
+#ifdef SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+		template <class T>
+		struct is_pointer_to_non_const_member_func : std::false_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)&> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &&> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile&> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile&&> : std::true_type { };
+
+		template <class T>
+		struct is_const_or_const_ref : std::false_type { };
+		template <class T>
+		struct is_const_or_const_ref<T const&> : std::true_type { };
+		template <class T>
+		struct is_const_or_const_ref<T const> : std::true_type { };
+#endif
+
+		// std::invoke from C++17
+		// https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
+		template <typename Fn, typename... Args,
+#ifdef SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+		     typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value && is_const_or_const_ref<Args...>::value)>,
+#endif
+		     typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>, int = 0>
+		constexpr auto invoke(Fn&& f, Args&&... args) noexcept(noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
+		     -> decltype(std::mem_fn(f)(std::forward<Args>(args)...)) {
+			return std::mem_fn(f)(std::forward<Args>(args)...);
+		}
+
+		template <typename Fn, typename... Args, typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
+		constexpr auto invoke(Fn&& f, Args&&... args) noexcept(noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
+		     -> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)) {
+			return std::forward<Fn>(f)(std::forward<Args>(args)...);
+		}
+
+		// std::invoke_result from C++17
+		template <class F, class, class... Us>
+		struct invoke_result_impl;
+
+		template <class F, class... Us>
+		struct invoke_result_impl<F, decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()), Us...> {
+			using type = decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
+		};
+
+		template <class F, class... Us>
+		using invoke_result = invoke_result_impl<F, void, Us...>;
+
+		template <class F, class... Us>
+		using invoke_result_t = typename invoke_result<F, Us...>::type;
+#endif
+
+		// std::void_t from C++17
+		template <class...>
+		struct voider {
+			using type = void;
+		};
+		template <class... Ts>
+		using void_t = typename voider<Ts...>::type;
+
+		// Trait for checking if a type is a sol::optional
+		template <class T>
+		struct is_optional_impl : std::false_type { };
+		template <class T>
+		struct is_optional_impl<optional<T>> : std::true_type { };
+		template <class T>
+		using is_optional = is_optional_impl<decay_t<T>>;
+
+		// Change void to sol::monostate
+		template <class U>
+		using fixup_void = conditional_t<std::is_void<U>::value, monostate, U>;
+
+		template <class F, class U, class = invoke_result_t<F, U>>
+		using get_map_return = optional<fixup_void<invoke_result_t<F, U>>>;
+
+		// Check if invoking F for some Us returns void
+		template <class F, class = void, class... U>
+		struct returns_void_impl;
+		template <class F, class... U>
+		struct returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...> : std::is_void<invoke_result_t<F, U...>> { };
+		template <class F, class... U>
+		using returns_void = returns_void_impl<F, void, U...>;
+
+		template <class T, class... U>
+		using enable_if_ret_void = enable_if_t<returns_void<T&&, U...>::value>;
+
+		template <class T, class... U>
+		using disable_if_ret_void = enable_if_t<!returns_void<T&&, U...>::value>;
+
+		template <class T, class U>
+		using enable_forward_value = detail::enable_if_t<std::is_constructible<T, U&&>::value && !std::is_same<detail::decay_t<U>, in_place_t>::value
+		     && !std::is_same<optional<T>, detail::decay_t<U>>::value>;
+
+		template <class T, class U, class Other>
+		using enable_from_other = detail::enable_if_t<std::is_constructible<T, Other>::value && !std::is_constructible<T, optional<U>&>::value
+		     && !std::is_constructible<T, optional<U>&&>::value && !std::is_constructible<T, const optional<U>&>::value
+		     && !std::is_constructible<T, const optional<U>&&>::value && !std::is_convertible<optional<U>&, T>::value
+		     && !std::is_convertible<optional<U>&&, T>::value && !std::is_convertible<const optional<U>&, T>::value
+		     && !std::is_convertible<const optional<U>&&, T>::value>;
+
+		template <class T, class U>
+		using enable_assign_forward = detail::enable_if_t<!std::is_same<optional<T>, detail::decay_t<U>>::value
+		     && !detail::conjunction<std::is_scalar<T>, std::is_same<T, detail::decay_t<U>>>::value && std::is_constructible<T, U>::value
+		     && std::is_assignable<T&, U>::value>;
+
+		template <class T, class U, class Other>
+		using enable_assign_from_other = detail::enable_if_t<std::is_constructible<T, Other>::value && std::is_assignable<T&, Other>::value
+		     && !std::is_constructible<T, optional<U>&>::value && !std::is_constructible<T, optional<U>&&>::value
+		     && !std::is_constructible<T, const optional<U>&>::value && !std::is_constructible<T, const optional<U>&&>::value
+		     && !std::is_convertible<optional<U>&, T>::value && !std::is_convertible<optional<U>&&, T>::value
+		     && !std::is_convertible<const optional<U>&, T>::value && !std::is_convertible<const optional<U>&&, T>::value
+		     && !std::is_assignable<T&, optional<U>&>::value && !std::is_assignable<T&, optional<U>&&>::value
+		     && !std::is_assignable<T&, const optional<U>&>::value && !std::is_assignable<T&, const optional<U>&&>::value>;
+
+#ifdef _MSC_VER
+		// TODO make a version which works with MSVC
+		template <class T, class U = T>
+		struct is_swappable : std::true_type { };
+
+		template <class T, class U = T>
+		struct is_nothrow_swappable : std::true_type { };
+#else
+		// https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept
+		namespace swap_adl_tests {
+			// if swap ADL finds this then it would call std::swap otherwise (same
+			// signature)
+			struct tag { };
+
+			template <class T>
+			tag swap(T&, T&);
+			template <class T, std::size_t N>
+			tag swap(T (&a)[N], T (&b)[N]);
+
+			// helper functions to test if an unqualified swap is possible, and if it
+			// becomes std::swap
+			template <class, class>
+			std::false_type can_swap(...) noexcept(false);
+			template <class T, class U, class = decltype(swap(std::declval<T&>(), std::declval<U&>()))>
+			std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T&>(), std::declval<U&>())));
+
+			template <class, class>
+			std::false_type uses_std(...);
+			template <class T, class U>
+			std::is_same<decltype(swap(std::declval<T&>(), std::declval<U&>())), tag> uses_std(int);
+
+			template <class T>
+			struct is_std_swap_noexcept
+			: std::integral_constant<bool, std::is_nothrow_move_constructible<T>::value && std::is_nothrow_move_assignable<T>::value> { };
+
+			template <class T, std::size_t N>
+			struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> { };
+
+			template <class T, class U>
+			struct is_adl_swap_noexcept : std::integral_constant<bool, noexcept(can_swap<T, U>(0))> { };
+		} // namespace swap_adl_tests
+
+		template <class T, class U = T>
+		struct is_swappable : std::integral_constant<bool,
+		                           decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value
+		                                && (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
+		                                     || (std::is_move_assignable<T>::value && std::is_move_constructible<T>::value))> { };
+
+		template <class T, std::size_t N>
+		struct is_swappable<T[N], T[N]> : std::integral_constant<bool,
+		                                       decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value
+		                                            && (!decltype(detail::swap_adl_tests::uses_std<T[N], T[N]>(0))::value || is_swappable<T, T>::value)> { };
+
+		template <class T, class U = T>
+		struct is_nothrow_swappable
+		: std::integral_constant<bool,
+		       is_swappable<T, U>::value
+		            && ((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value&& detail::swap_adl_tests::is_std_swap_noexcept<T>::value)
+		                 || (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value&& detail::swap_adl_tests::is_adl_swap_noexcept<T, U>::value))> { };
+#endif
+
+		// The storage base manages the actual storage, and correctly propagates
+		// trivial destroyion from T. This case is for when T is not trivially
+		// destructible.
+		template <class T, bool = ::std::is_trivially_destructible<T>::value>
+		struct optional_storage_base {
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {
+			}
+
+			template <class... U>
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U&&... u) : m_value(std::forward<U>(u)...), m_has_value(true) {
+			}
+
+			~optional_storage_base() {
+				if (m_has_value) {
+					m_value.~T();
+					m_has_value = false;
+				}
+			}
+
+			struct dummy { };
+			union {
+				dummy m_dummy;
+				T m_value;
+			};
+
+			bool m_has_value;
+		};
+
+		// This case is for when T is trivially destructible.
+		template <class T>
+		struct optional_storage_base<T, true> {
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {
+			}
+
+			template <class... U>
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U&&... u) : m_value(std::forward<U>(u)...), m_has_value(true) {
+			}
+
+			// No destructor, so this class is trivially destructible
+
+			struct dummy { };
+			union {
+				dummy m_dummy;
+				T m_value;
+			};
+
+			bool m_has_value = false;
+		};
+
+		// This base class provides some handy member functions which can be used in
+		// further derived classes
+		template <class T>
+		struct optional_operations_base : optional_storage_base<T> {
+			using optional_storage_base<T>::optional_storage_base;
+
+			void hard_reset() noexcept {
+				get().~T();
+				this->m_has_value = false;
+			}
+
+			template <class... Args>
+			void construct(Args&&... args) noexcept {
+				new (std::addressof(this->m_value)) T(std::forward<Args>(args)...);
+				this->m_has_value = true;
+			}
+
+			template <class Opt>
+			void assign(Opt&& rhs) {
+				if (this->has_value()) {
+					if (rhs.has_value()) {
+						this->m_value = std::forward<Opt>(rhs).get();
+					}
+					else {
+						this->m_value.~T();
+						this->m_has_value = false;
+					}
+				}
+
+				else if (rhs.has_value()) {
+					construct(std::forward<Opt>(rhs).get());
+				}
+			}
+
+			bool has_value() const {
+				return this->m_has_value;
+			}
+
+			SOL_TL_OPTIONAL_11_CONSTEXPR T& get() & {
+				return this->m_value;
+			}
+			SOL_TL_OPTIONAL_11_CONSTEXPR const T& get() const& {
+				return this->m_value;
+			}
+			SOL_TL_OPTIONAL_11_CONSTEXPR T&& get() && {
+				return std::move(this->m_value);
+			}
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+			constexpr const T&& get() const&& {
+				return std::move(this->m_value);
+			}
+#endif
+		};
+
+		// This class manages conditionally having a trivial copy constructor
+		// This specialization is for when T is trivially copy constructible
+		template <class T, bool = SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>
+		struct optional_copy_base : optional_operations_base<T> {
+			using optional_operations_base<T>::optional_operations_base;
+		};
+
+		// This specialization is for when T is not trivially copy constructible
+		template <class T>
+		struct optional_copy_base<T, false> : optional_operations_base<T> {
+			using base_t = optional_operations_base<T>;
+
+			using base_t::base_t;
+
+			optional_copy_base() = default;
+			optional_copy_base(const optional_copy_base& rhs) : base_t() {
+				if (rhs.has_value()) {
+					this->construct(rhs.get());
+				}
+				else {
+					this->m_has_value = false;
+				}
+			}
+
+			optional_copy_base(optional_copy_base&& rhs) = default;
+			optional_copy_base& operator=(const optional_copy_base& rhs) = default;
+			optional_copy_base& operator=(optional_copy_base&& rhs) = default;
+		};
+
+#ifndef SOL_TL_OPTIONAL_GCC49
+		template <class T, bool = std::is_trivially_move_constructible<T>::value>
+		struct optional_move_base : optional_copy_base<T> {
+			using optional_copy_base<T>::optional_copy_base;
+		};
+#else
+		template <class T, bool = false>
+		struct optional_move_base;
+#endif
+		template <class T>
+		struct optional_move_base<T, false> : optional_copy_base<T> {
+			using optional_copy_base<T>::optional_copy_base;
+
+			optional_move_base() = default;
+			optional_move_base(const optional_move_base& rhs) = default;
+
+			optional_move_base(optional_move_base&& rhs) noexcept(std::is_nothrow_move_constructible<T>::value) {
+				if (rhs.has_value()) {
+					this->construct(std::move(rhs.get()));
+				}
+				else {
+					this->m_has_value = false;
+				}
+			}
+			optional_move_base& operator=(const optional_move_base& rhs) = default;
+			optional_move_base& operator=(optional_move_base&& rhs) = default;
+		};
+
+		// This class manages conditionally having a trivial copy assignment operator
+		template <class T,
+		     bool = SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) && SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)
+		          && SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T)>
+		struct optional_copy_assign_base : optional_move_base<T> {
+			using optional_move_base<T>::optional_move_base;
+		};
+
+		template <class T>
+		struct optional_copy_assign_base<T, false> : optional_move_base<T> {
+			using optional_move_base<T>::optional_move_base;
+
+			optional_copy_assign_base() = default;
+			optional_copy_assign_base(const optional_copy_assign_base& rhs) = default;
+
+			optional_copy_assign_base(optional_copy_assign_base&& rhs) = default;
+			optional_copy_assign_base& operator=(const optional_copy_assign_base& rhs) {
+				this->assign(rhs);
+				return *this;
+			}
+			optional_copy_assign_base& operator=(optional_copy_assign_base&& rhs) = default;
+		};
+
+#ifndef SOL_TL_OPTIONAL_GCC49
+		template <class T,
+		     bool = std::is_trivially_destructible<T>::value&& std::is_trivially_move_constructible<T>::value&& std::is_trivially_move_assignable<T>::value>
+		struct optional_move_assign_base : optional_copy_assign_base<T> {
+			using optional_copy_assign_base<T>::optional_copy_assign_base;
+		};
+#else
+		template <class T, bool = false>
+		struct optional_move_assign_base;
+#endif
+
+		template <class T>
+		struct optional_move_assign_base<T, false> : optional_copy_assign_base<T> {
+			using optional_copy_assign_base<T>::optional_copy_assign_base;
+
+			optional_move_assign_base() = default;
+			optional_move_assign_base(const optional_move_assign_base& rhs) = default;
+
+			optional_move_assign_base(optional_move_assign_base&& rhs) = default;
+
+			optional_move_assign_base& operator=(const optional_move_assign_base& rhs) = default;
+
+			optional_move_assign_base& operator=(optional_move_assign_base&& rhs) noexcept(
+			     std::is_nothrow_move_constructible<T>::value&& std::is_nothrow_move_assignable<T>::value) {
+				this->assign(std::move(rhs));
+				return *this;
+			}
+		};
+
+		// optional_delete_ctor_base will conditionally delete copy and move
+		// constructors depending on whether T is copy/move constructible
+		template <class T, bool EnableCopy = std::is_copy_constructible<T>::value, bool EnableMove = std::is_move_constructible<T>::value>
+		struct optional_delete_ctor_base {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = default;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_ctor_base<T, true, false> {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = delete;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_ctor_base<T, false, true> {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = delete;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = default;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_ctor_base<T, false, false> {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = delete;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = delete;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		// optional_delete_assign_base will conditionally delete copy and move
+		// constructors depending on whether T is copy/move constructible + assignable
+		template <class T, bool EnableCopy = (std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value),
+		     bool EnableMove = (std::is_move_constructible<T>::value && std::is_move_assignable<T>::value)>
+		struct optional_delete_assign_base {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_assign_base<T, true, false> {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = delete;
+		};
+
+		template <class T>
+		struct optional_delete_assign_base<T, false, true> {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = delete;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_assign_base<T, false, false> {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = delete;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = delete;
+		};
+
+	} // namespace detail
+
+	/// \brief A tag type to represent an empty optional
+	using nullopt_t = std::nullopt_t;
+
+	/// \brief Represents an empty optional
+	/// \synopsis static constexpr nullopt_t nullopt;
+	///
+	/// *Examples*:
+	/// ```
+	/// sol::optional<int> a = sol::nullopt;
+	/// void foo (sol::optional<int>);
+	/// foo(sol::nullopt); //pass an empty optional
+	/// ```
+	using std::nullopt;
+
+	/// @brief An exception for when an optional is accessed through specific methods while it is not engaged.
+	class bad_optional_access : public std::exception {
+	public:
+		/// @brief Default-constructs an optional exception.
+		bad_optional_access() = default;
+		/// @brief Returns a pointer to a null-terminated string containing the reason for the exception.
+		const char* what() const noexcept override {
+			return "Optional has no value";
+		}
+	};
+
+	/// An optional object is an object that contains the storage for another
+	/// object and manages the lifetime of this contained object, if any. The
+	/// contained object may be initialized after the optional object has been
+	/// initialized, and may be destroyed before the optional object has been
+	/// destroyed. The initialization state of the contained object is tracked by
+	/// the optional object.
+	template <class T>
+	class optional : private detail::optional_move_assign_base<T>,
+	                 private detail::optional_delete_ctor_base<T>,
+	                 private detail::optional_delete_assign_base<T> {
+		using base = detail::optional_move_assign_base<T>;
+
+		static_assert(!std::is_same<T, in_place_t>::value, "instantiation of optional with in_place_t is ill-formed");
+		static_assert(!std::is_same<detail::decay_t<T>, nullopt_t>::value, "instantiation of optional with nullopt_t is ill-formed");
+
+	public:
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+		/// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+		/// `std::optional<U>`. The return value is empty if `*this` is empty,
+		/// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+		/// is returned.
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr auto and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr auto and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+#endif
+#else
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise the return value of
+		/// `std::invoke(std::forward<F>(f), value())` is returned.
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&&> and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&&> and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+#endif
+#endif
+
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) & {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) && {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&;
+		template <class F>
+		constexpr auto map(F&& f) const& {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&&;
+		template <class F>
+		constexpr auto map(F&& f) const&& {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#else
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional&>(), std::declval<F&&>())) map(F&& f) & {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional&&>(), std::declval<F&&>())) map(F&& f) && {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&;
+		template <class F>
+		constexpr decltype(optional_map_impl(std::declval<const optional&>(), std::declval<F&&>())) map(F&& f) const& {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&&;
+		template <class F>
+		constexpr decltype(optional_map_impl(std::declval<const optional&&>(), std::declval<F&&>())) map(F&& f) const&& {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#endif
+#endif
+
+		/// \brief Calls `f` if the optional is empty
+		/// \requires `std::invoke_result_t<F>` must be void or convertible to
+		/// `optional<T>`.
+		/// \effects If `*this` has a value, returns `*this`.
+		/// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
+		/// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
+		///
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &&;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) && {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) && {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) const &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const& {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) const& {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise returns
+		/// `u`.
+		///
+		/// \details If there is a value stored, then `f` is called with `**this`
+		/// and the value is returned. Otherwise `u` is returned.
+		///
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise calls
+		/// `u` and returns the result.
+		///
+		/// \details If there is a value stored, then `f` is
+		/// called with `**this` and the value is returned. Otherwise
+		/// `std::forward<U>(u)()` is returned.
+		///
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u) &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// const &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// const &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+#endif
+
+		/// \returns `u` if `*this` has a value, otherwise an empty optional.
+		template <class U>
+		constexpr optional<typename std::decay<U>::type> conjunction(U&& u) const {
+			using result = optional<detail::decay_t<U>>;
+			return has_value() ? result { u } : result { nullopt };
+		}
+
+		/// \returns `rhs` if `*this` is empty, otherwise the current value.
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) & {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const& {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) && {
+			return has_value() ? std::move(*this) : rhs;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const&& {
+			return has_value() ? std::move(*this) : rhs;
+		}
+#endif
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) & {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const& {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) && {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const&& {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+#endif
+
+		/// Takes the value out of the optional, leaving it empty
+		/// \group take
+		optional take() & {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() const& {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() && {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group take
+		optional take() const&& {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+#endif
+
+		using value_type = T;
+
+		/// Constructs an optional that does not contain a value.
+		/// \group ctor_empty
+		constexpr optional() noexcept = default;
+
+		/// \group ctor_empty
+		constexpr optional(nullopt_t) noexcept {
+		}
+
+		/// Copy constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(const optional& rhs) = default;
+
+		/// Move constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(optional&& rhs) = default;
+
+		/// Constructs the stored value in-place using the given arguments.
+		/// \group in_place
+		/// \synopsis template <class... Args> constexpr explicit optional(in_place_t, Args&&... args);
+		template <class... Args>
+		constexpr explicit optional(detail::enable_if_t<std::is_constructible<T, Args...>::value, in_place_t>, Args&&... args)
+		: base(in_place, std::forward<Args>(args)...) {
+		}
+
+		/// \group in_place
+		/// \synopsis template <class U, class... Args> \n constexpr explicit optional(in_place_t, std::initializer_list<U>&, Args&&... args);
+		template <class U, class... Args>
+		SOL_TL_OPTIONAL_11_CONSTEXPR explicit optional(detail::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, in_place_t>,
+		     std::initializer_list<U> il, Args&&... args) {
+			this->construct(il, std::forward<Args>(args)...);
+		}
+
+#if 0 // SOL_MODIFICATION
+      /// Constructs the stored value with `u`.
+      /// \synopsis template <class U=T> constexpr optional(U &&u);
+		template <class U = T, detail::enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr, detail::enable_forward_value<T, U>* = nullptr>
+		constexpr optional(U&& u) : base(in_place, std::forward<U>(u)) {
+		}
+
+		/// \exclude
+		template <class U = T, detail::enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr, detail::enable_forward_value<T, U>* = nullptr>
+		constexpr explicit optional(U&& u) : base(in_place, std::forward<U>(u)) {
+		}
+#else
+		/// Constructs the stored value with `u`.
+		/// \synopsis template <class U=T> constexpr optional(U &&u);
+		constexpr optional(T&& u) : base(in_place, std::move(u)) {
+		}
+
+		/// \exclude
+		constexpr optional(const T& u) : base(in_place, u) {
+		}
+#endif // sol2 modification
+
+		/// Converting copy constructor.
+		/// \synopsis template <class U> optional(const optional<U> &rhs);
+		template <class U, detail::enable_from_other<T, U, const U&>* = nullptr, detail::enable_if_t<std::is_convertible<const U&, T>::value>* = nullptr>
+		optional(const optional<U>& rhs) {
+			if (rhs.has_value()) {
+				this->construct(*rhs);
+			}
+		}
+
+		/// \exclude
+		template <class U, detail::enable_from_other<T, U, const U&>* = nullptr, detail::enable_if_t<!std::is_convertible<const U&, T>::value>* = nullptr>
+		explicit optional(const optional<U>& rhs) {
+			if (rhs.has_value()) {
+				this->construct(*rhs);
+			}
+		}
+
+		/// Converting move constructor.
+		/// \synopsis template <class U> optional(optional<U> &&rhs);
+		template <class U, detail::enable_from_other<T, U, U&&>* = nullptr, detail::enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr>
+		optional(optional<U>&& rhs) {
+			if (rhs.has_value()) {
+				this->construct(std::move(*rhs));
+			}
+		}
+
+		/// \exclude
+		template <class U, detail::enable_from_other<T, U, U&&>* = nullptr, detail::enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr>
+		explicit optional(optional<U>&& rhs) {
+			this->construct(std::move(*rhs));
+		}
+
+		/// Destroys the stored value if there is one.
+		~optional() = default;
+
+		/// Assignment to empty.
+		///
+		/// Destroys the current value if there is one.
+		optional& operator=(nullopt_t) noexcept {
+			if (has_value()) {
+				this->m_value.~T();
+				this->m_has_value = false;
+			}
+
+			return *this;
+		}
+
+		/// Copy assignment.
+		///
+		/// Copies the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		optional& operator=(const optional& rhs) = default;
+
+		/// Move assignment.
+		///
+		/// Moves the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		optional& operator=(optional&& rhs) = default;
+
+		/// Assigns the stored value from `u`, destroying the old value if there was
+		/// one.
+		/// \synopsis optional &operator=(U &&u);
+		template <class U = T, detail::enable_assign_forward<T, U>* = nullptr>
+		optional& operator=(U&& u) {
+			if (has_value()) {
+				this->m_value = std::forward<U>(u);
+			}
+			else {
+				this->construct(std::forward<U>(u));
+			}
+
+			return *this;
+		}
+
+		/// Converting copy assignment operator.
+		///
+		/// Copies the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		/// \synopsis optional &operator=(const optional<U> & rhs);
+		template <class U, detail::enable_assign_from_other<T, U, const U&>* = nullptr>
+		optional& operator=(const optional<U>& rhs) {
+			if (has_value()) {
+				if (rhs.has_value()) {
+					this->m_value = *rhs;
+				}
+				else {
+					this->hard_reset();
+				}
+			}
+
+			if (rhs.has_value()) {
+				this->construct(*rhs);
+			}
+
+			return *this;
+		}
+
+		// TODO check exception guarantee
+		/// Converting move assignment operator.
+		///
+		/// Moves the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		/// \synopsis optional &operator=(optional<U> && rhs);
+		template <class U, detail::enable_assign_from_other<T, U, U>* = nullptr>
+		optional& operator=(optional<U>&& rhs) {
+			if (has_value()) {
+				if (rhs.has_value()) {
+					this->m_value = std::move(*rhs);
+				}
+				else {
+					this->hard_reset();
+				}
+			}
+
+			if (rhs.has_value()) {
+				this->construct(std::move(*rhs));
+			}
+
+			return *this;
+		}
+
+		/// Constructs the value in-place, destroying the current one if there is
+		/// one.
+		/// \group emplace
+		template <class... Args>
+		T& emplace(Args&&... args) {
+			static_assert(std::is_constructible<T, Args&&...>::value, "T must be constructible with Args");
+
+			*this = nullopt;
+			this->construct(std::forward<Args>(args)...);
+			return value();
+		}
+
+		/// \group emplace
+		/// \synopsis template <class U, class... Args> \n T& emplace(std::initializer_list<U> il, Args &&... args);
+		template <class U, class... Args>
+		detail::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, T&> emplace(std::initializer_list<U> il, Args&&... args) {
+			*this = nullopt;
+			this->construct(il, std::forward<Args>(args)...);
+			return value();
+		}
+
+		/// Swaps this optional with the other.
+		///
+		/// If neither optionals have a value, nothing happens.
+		/// If both have a value, the values are swapped.
+		/// If one has a value, it is moved to the other and the movee is left
+		/// valueless.
+		void swap(optional& rhs) noexcept(std::is_nothrow_move_constructible<T>::value&& detail::is_nothrow_swappable<T>::value) {
+			if (has_value()) {
+				if (rhs.has_value()) {
+					using std::swap;
+					swap(**this, *rhs);
+				}
+				else {
+					new (std::addressof(rhs.m_value)) T(std::move(this->m_value));
+					this->m_value.T::~T();
+				}
+			}
+			else if (rhs.has_value()) {
+				new (std::addressof(this->m_value)) T(std::move(rhs.m_value));
+				rhs.m_value.T::~T();
+			}
+		}
+
+		/// \returns a pointer to the stored value
+		/// \requires a value is stored
+		/// \group pointer
+		/// \synopsis constexpr const T *operator->() const;
+		constexpr const T* operator->() const {
+			return std::addressof(this->m_value);
+		}
+
+		/// \group pointer
+		/// \synopsis constexpr T *operator->();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T* operator->() {
+			return std::addressof(this->m_value);
+		}
+
+		/// \returns the stored value
+		/// \requires a value is stored
+		/// \group deref
+		/// \synopsis constexpr T &operator*();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& operator*() & {
+			return this->m_value;
+		}
+
+		/// \group deref
+		/// \synopsis constexpr const T &operator*() const;
+		constexpr const T& operator*() const& {
+			return this->m_value;
+		}
+
+		/// \exclude
+		SOL_TL_OPTIONAL_11_CONSTEXPR T&& operator*() && {
+			return std::move(this->m_value);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		constexpr const T&& operator*() const&& {
+			return std::move(this->m_value);
+		}
+#endif
+
+		/// \returns whether or not the optional has a value
+		/// \group has_value
+		constexpr bool has_value() const noexcept {
+			return this->m_has_value;
+		}
+
+		/// \group has_value
+		constexpr explicit operator bool() const noexcept {
+			return this->m_has_value;
+		}
+
+		/// \returns the contained value if there is one, otherwise throws
+		/// [bad_optional_access]
+		/// \group value
+		/// \synopsis constexpr T &value();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& value() & {
+			if (has_value())
+				return this->m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+		/// \group value
+		/// \synopsis constexpr const T &value() const;
+		SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const& {
+			if (has_value())
+				return this->m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+		/// \exclude
+		SOL_TL_OPTIONAL_11_CONSTEXPR T&& value() && {
+			if (has_value())
+				return std::move(this->m_value);
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		SOL_TL_OPTIONAL_11_CONSTEXPR const T&& value() const&& {
+			if (has_value())
+				return std::move(this->m_value);
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+#endif
+
+		/// \returns the stored value if there is one, otherwise returns `u`
+		/// \group value_or
+		template <class U>
+		constexpr T value_or(U&& u) const& {
+			static_assert(std::is_copy_constructible<T>::value && std::is_convertible<U&&, T>::value, "T must be copy constructible and convertible from U");
+			return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+		}
+
+		/// \group value_or
+		template <class U>
+		SOL_TL_OPTIONAL_11_CONSTEXPR T value_or(U&& u) && {
+			static_assert(std::is_move_constructible<T>::value && std::is_convertible<U&&, T>::value, "T must be move constructible and convertible from U");
+			return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+		}
+
+		/// Destroys the stored value if one exists, making the optional empty
+		void reset() noexcept {
+			if (has_value()) {
+				this->m_value.~T();
+				this->m_has_value = false;
+			}
+		}
+	}; // namespace sol
+
+	/// \group relop
+	/// \brief Compares two optional objects
+	/// \details If both optionals contain a value, they are compared with `T`s
+	/// relational operators. Otherwise `lhs` and `rhs` are equal only if they are
+	/// both empty, and `lhs` is less than `rhs` only if `rhs` is empty and `lhs`
+	/// is not.
+	template <class T, class U>
+	inline constexpr bool operator==(const optional<T>& lhs, const optional<U>& rhs) {
+		return lhs.has_value() == rhs.has_value() && (!lhs.has_value() || *lhs == *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator!=(const optional<T>& lhs, const optional<U>& rhs) {
+		return lhs.has_value() != rhs.has_value() || (lhs.has_value() && *lhs != *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator<(const optional<T>& lhs, const optional<U>& rhs) {
+		return rhs.has_value() && (!lhs.has_value() || *lhs < *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator>(const optional<T>& lhs, const optional<U>& rhs) {
+		return lhs.has_value() && (!rhs.has_value() || *lhs > *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator<=(const optional<T>& lhs, const optional<U>& rhs) {
+		return !lhs.has_value() || (rhs.has_value() && *lhs <= *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator>=(const optional<T>& lhs, const optional<U>& rhs) {
+		return !rhs.has_value() || (lhs.has_value() && *lhs >= *rhs);
+	}
+
+	/// \group relop_nullopt
+	/// \brief Compares an optional to a `nullopt`
+	/// \details Equivalent to comparing the optional to an empty optional
+	template <class T>
+	inline constexpr bool operator==(const optional<T>& lhs, nullopt_t) noexcept {
+		return !lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator==(nullopt_t, const optional<T>& rhs) noexcept {
+		return !rhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator!=(const optional<T>& lhs, nullopt_t) noexcept {
+		return lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator!=(nullopt_t, const optional<T>& rhs) noexcept {
+		return rhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
+		return false;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<(nullopt_t, const optional<T>& rhs) noexcept {
+		return rhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<=(const optional<T>& lhs, nullopt_t) noexcept {
+		return !lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
+		return true;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>(const optional<T>& lhs, nullopt_t) noexcept {
+		return lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
+		return false;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
+		return true;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>=(nullopt_t, const optional<T>& rhs) noexcept {
+		return !rhs.has_value();
+	}
+
+	/// \group relop_t
+	/// \brief Compares the optional with a value.
+	/// \details If the optional has a value, it is compared with the other value
+	/// using `T`s relational operators. Otherwise, the optional is considered
+	/// less than the value.
+	template <class T, class U>
+	inline constexpr bool operator==(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs == rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator==(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs == *rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator!=(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs != rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator!=(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs != *rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs < rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs < *rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<=(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs <= rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<=(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs <= *rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs > rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs > *rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>=(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs >= rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>=(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs >= *rhs : true;
+	}
+
+	/// \synopsis template <class T>  \n  void swap(optional<T> &lhs, optional<T> &rhs);
+	template <class T, detail::enable_if_t<std::is_move_constructible<T>::value>* = nullptr, detail::enable_if_t<detail::is_swappable<T>::value>* = nullptr>
+	void swap(optional<T>& lhs, optional<T>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+		return lhs.swap(rhs);
+	}
+
+	namespace detail {
+		struct i_am_secret { };
+	} // namespace detail
+
+	template <class T = detail::i_am_secret, class U, class Ret = detail::conditional_t<std::is_same<T, detail::i_am_secret>::value, detail::decay_t<U>, T>>
+	inline constexpr optional<Ret> make_optional(U&& v) {
+		return optional<Ret>(std::forward<U>(v));
+	}
+
+	template <class T, class... Args>
+	inline constexpr optional<T> make_optional(Args&&... args) {
+		return optional<T>(in_place, std::forward<Args>(args)...);
+	}
+	template <class T, class U, class... Args>
+	inline constexpr optional<T> make_optional(std::initializer_list<U> il, Args&&... args) {
+		return optional<T>(in_place, il, std::forward<Args>(args)...);
+	}
+
+#if __cplusplus >= 201703L
+	template <class T>
+	optional(T) -> optional<T>;
+#endif
+
+	/// \exclude
+	namespace detail {
+#ifdef SOL_TL_OPTIONAL_CXX14
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<!std::is_void<Ret>::value>* = nullptr>
+		constexpr auto optional_map_impl(Opt&& opt, F&& f) {
+			return opt.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt)) : optional<Ret>(nullopt);
+		}
+
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<std::is_void<Ret>::value>* = nullptr>
+		auto optional_map_impl(Opt&& opt, F&& f) {
+			if (opt.has_value()) {
+				detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+				return make_optional(monostate {});
+			}
+
+			return optional<monostate>(nullopt);
+		}
+#else
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<!std::is_void<Ret>::value>* = nullptr>
+
+		constexpr auto optional_map_impl(Opt&& opt, F&& f) -> optional<Ret> {
+			return opt.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt)) : optional<Ret>(nullopt);
+		}
+
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<std::is_void<Ret>::value>* = nullptr>
+
+		auto optional_map_impl(Opt&& opt, F&& f) -> optional<monostate> {
+			if (opt.has_value()) {
+				detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+				return monostate {};
+			}
+
+			return nullopt;
+		}
+#endif
+	} // namespace detail
+
+	/// Specialization for when `T` is a reference. `optional<T&>` acts similarly
+	/// to a `T*`, but provides more operations and shows intent more clearly.
+	///
+	/// *Examples*:
+	///
+	/// ```
+	/// int i = 42;
+	/// sol::optional<int&> o = i;
+	/// *o == 42; //true
+	/// i = 12;
+	/// *o = 12; //true
+	/// &*o == &i; //true
+	/// ```
+	///
+	/// Assignment has rebind semantics rather than assign-through semantics:
+	///
+	/// ```
+	/// int j = 8;
+	/// o = j;
+	///
+	/// &*o == &j; //true
+	/// ```
+	template <class T>
+	class optional<T&> {
+	public:
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+		/// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+		/// `std::optional<U>`. The return value is empty if `*this` is empty,
+		/// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+		/// is returned.
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr auto and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr auto and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+#endif
+#else
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+		/// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+		/// `std::optional<U>`. The return value is empty if `*this` is empty,
+		/// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+		/// is returned.
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+#endif
+#endif
+
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) & {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) && {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&;
+		template <class F>
+		constexpr auto map(F&& f) const& {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&&;
+		template <class F>
+		constexpr auto map(F&& f) const&& {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#else
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional&>(), std::declval<F&&>())) map(F&& f) & {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional&&>(), std::declval<F&&>())) map(F&& f) && {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&;
+		template <class F>
+		constexpr decltype(detail::optional_map_impl(std::declval<const optional&>(), std::declval<F&&>())) map(F&& f) const& {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&&;
+		template <class F>
+		constexpr decltype(detail::optional_map_impl(std::declval<const optional&&>(), std::declval<F&&>())) map(F&& f) const&& {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#endif
+#endif
+
+		/// \brief Calls `f` if the optional is empty
+		/// \requires `std::invoke_result_t<F>` must be void or convertible to
+		/// `optional<T>`. \effects If `*this` has a value, returns `*this`.
+		/// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
+		/// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
+		///
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &&;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) && {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) && {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) const &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const& {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) const& {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise returns
+		/// `u`.
+		///
+		/// \details If there is a value stored, then `f` is called with `**this`
+		/// and the value is returned. Otherwise `u` is returned.
+		///
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise calls
+		/// `u` and returns the result.
+		///
+		/// \details If there is a value stored, then `f` is
+		/// called with `**this` and the value is returned. Otherwise
+		/// `std::forward<U>(u)()` is returned.
+		///
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u) &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// const &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// const &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+#endif
+
+		/// \returns `u` if `*this` has a value, otherwise an empty optional.
+		template <class U>
+		constexpr optional<typename std::decay<U>::type> conjunction(U&& u) const {
+			using result = optional<detail::decay_t<U>>;
+			return has_value() ? result { u } : result { nullopt };
+		}
+
+		/// \returns `rhs` if `*this` is empty, otherwise the current value.
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) & {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const& {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) && {
+			return has_value() ? std::move(*this) : rhs;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const&& {
+			return has_value() ? std::move(*this) : rhs;
+		}
+#endif
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) & {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const& {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) && {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const&& {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+#endif
+
+		/// Takes the value out of the optional, leaving it empty
+		/// \group take
+		optional take() & {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() const& {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() && {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group take
+		optional take() const&& {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+#endif
+
+		using value_type = T&;
+
+		/// Constructs an optional that does not contain a value.
+		/// \group ctor_empty
+		constexpr optional() noexcept : m_value(nullptr) {
+		}
+
+		/// \group ctor_empty
+		constexpr optional(nullopt_t) noexcept : m_value(nullptr) {
+		}
+
+		/// Copy constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(const optional& rhs) noexcept = default;
+
+		/// Move constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(optional&& rhs) = default;
+
+		/// Constructs the stored value with `u`.
+		/// \synopsis template <class U=T> constexpr optional(U &&u);
+		template <class U = T, detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>* = nullptr>
+		constexpr optional(U&& u) : m_value(std::addressof(u)) {
+			static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+		}
+
+		/// \exclude
+		template <class U>
+		constexpr explicit optional(const optional<U>& rhs) : optional(*rhs) {
+		}
+
+		/// No-op
+		~optional() = default;
+
+		/// Assignment to empty.
+		///
+		/// Destroys the current value if there is one.
+		optional& operator=(nullopt_t) noexcept {
+			m_value = nullptr;
+			return *this;
+		}
+
+		/// Copy assignment.
+		///
+		/// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+		/// resets the stored value in `*this`.
+		optional& operator=(const optional& rhs) = default;
+
+		/// Rebinds this optional to `u`.
+		///
+		/// \requires `U` must be an lvalue reference.
+		/// \synopsis optional &operator=(U &&u);
+		template <class U = T, detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>* = nullptr>
+		optional& operator=(U&& u) {
+			static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+			m_value = std::addressof(u);
+			return *this;
+		}
+
+		/// Converting copy assignment operator.
+		///
+		/// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+		/// resets the stored value in `*this`.
+		template <class U>
+		optional& operator=(const optional<U>& rhs) {
+			m_value = std::addressof(rhs.value());
+			return *this;
+		}
+
+		/// Constructs the value in-place, destroying the current one if there is
+		/// one.
+		///
+		/// \group emplace
+		template <class... Args>
+		T& emplace(Args&&... args) noexcept {
+			static_assert(std::is_constructible<T, Args&&...>::value, "T must be constructible with Args");
+
+			*this = nullopt;
+			this->construct(std::forward<Args>(args)...);
+		}
+
+		/// Swaps this optional with the other.
+		///
+		/// If neither optionals have a value, nothing happens.
+		/// If both have a value, the values are swapped.
+		/// If one has a value, it is moved to the other and the movee is left
+		/// valueless.
+		void swap(optional& rhs) noexcept {
+			std::swap(m_value, rhs.m_value);
+		}
+
+		/// \returns a pointer to the stored value
+		/// \requires a value is stored
+		/// \group pointer
+		/// \synopsis constexpr const T *operator->() const;
+		constexpr const T* operator->() const {
+			return m_value;
+		}
+
+		/// \group pointer
+		/// \synopsis constexpr T *operator->();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T* operator->() {
+			return m_value;
+		}
+
+		/// \returns the stored value
+		/// \requires a value is stored
+		/// \group deref
+		/// \synopsis constexpr T &operator*();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& operator*() {
+			return *m_value;
+		}
+
+		/// \group deref
+		/// \synopsis constexpr const T &operator*() const;
+		constexpr const T& operator*() const {
+			return *m_value;
+		}
+
+		/// \returns whether or not the optional has a value
+		/// \group has_value
+		constexpr bool has_value() const noexcept {
+			return m_value != nullptr;
+		}
+
+		/// \group has_value
+		constexpr explicit operator bool() const noexcept {
+			return m_value != nullptr;
+		}
+
+		/// \returns the contained value if there is one, otherwise throws
+		/// [bad_optional_access]
+		/// \group value
+		/// synopsis constexpr T &value();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& value() {
+			if (has_value())
+				return *m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+		/// \group value
+		/// \synopsis constexpr const T &value() const;
+		SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const {
+			if (has_value())
+				return *m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+
+		/// \returns the stored value if there is one, otherwise returns `u`
+		/// \group value_or
+		template <class U>
+		constexpr T& value_or(U&& u) const {
+			static_assert(std::is_convertible<U&&, T&>::value, "T must be convertible from U");
+			return has_value() ? const_cast<T&>(**this) : static_cast<T&>(std::forward<U>(u));
+		}
+
+		/// Destroys the stored value if one exists, making the optional empty
+		void reset() noexcept {
+			m_value = nullptr;
+		}
+
+	private:
+		T* m_value;
+	};
+
+} // namespace sol
+
+namespace std {
+	// TODO SFINAE
+	template <class T>
+	struct hash<::sol::optional<T>> {
+		::std::size_t operator()(const ::sol::optional<T>& o) const {
+			if (!o.has_value())
+				return 0;
+
+			return ::std::hash<::sol::detail::remove_const_t<T>>()(*o);
+		}
+	};
+} // namespace std
+
+// end of sol/optional_implementation.hpp
+
+#endif // Boost vs. Better optional
+
+#include <optional>
+
+namespace sol {
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+	template <typename T>
+	using optional = boost::optional<T>;
+	using nullopt_t = boost::none_t;
+	SOL_BOOST_NONE_CONSTEXPR_I_ nullopt_t nullopt = boost::none;
+#endif // Boost vs. Better optional
+
+	namespace meta {
+		template <typename T>
+		using is_optional = any<is_specialization_of<T, optional>, is_specialization_of<T, std::optional>>;
+
+		template <typename T>
+		constexpr inline bool is_optional_v = is_optional<T>::value;
+	} // namespace meta
+
+	namespace detail {
+		template <typename T>
+		struct associated_nullopt {
+			inline static constexpr std::nullopt_t value = std::nullopt;
+		};
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+		template <typename T>
+		struct associated_nullopt<boost::optional<T>> {
+			inline static SOL_BOOST_NONE_CONSTEXPR_I_ boost::none_t value = boost::none;
+		};
+#endif // Boost nullopt
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+		template <typename T>
+		inline SOL_BOOST_NONE_CONSTEXPR_I_ auto associated_nullopt_v = associated_nullopt<T>::value;
+#else
+		template <typename T>
+		inline constexpr auto associated_nullopt_v = associated_nullopt<T>::value;
+#endif // Boost continues to lag behind, to not many people's surprise...
+	} // namespace detail
+} // namespace sol
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+#undef SOL_BOOST_NONE_CONSTEXPR_I_
+#endif
+
+// end of sol/optional.hpp
+
+// beginning of sol/raii.hpp
+
+#include <memory>
+
+namespace sol {
+	namespace detail {
+		struct default_construct {
+			template <typename T, typename... Args>
+			static void construct(T&& obj, Args&&... args) {
+				typedef meta::unqualified_t<T> Tu;
+				std::allocator<Tu> alloc {};
+				std::allocator_traits<std::allocator<Tu>>::construct(alloc, std::forward<T>(obj), std::forward<Args>(args)...);
+			}
+
+			template <typename T, typename... Args>
+			void operator()(T&& obj, Args&&... args) const {
+				construct(std::forward<T>(obj), std::forward<Args>(args)...);
+			}
+		};
+
+		struct default_destroy {
+			template <typename T>
+			static void destroy(T&& obj) {
+				std::allocator<meta::unqualified_t<T>> alloc {};
+				alloc.destroy(obj);
+			}
+
+			template <typename T>
+			void operator()(T&& obj) const {
+				destroy(std::forward<T>(obj));
+			}
+		};
+
+		struct deleter {
+			template <typename T>
+			void operator()(T* p) const {
+				delete p;
+			}
+		};
+
+		struct state_deleter {
+			void operator()(lua_State* L) const {
+				lua_close(L);
+			}
+		};
+
+		template <typename T, typename Dx, typename... Args>
+		inline std::unique_ptr<T, Dx> make_unique_deleter(Args&&... args) {
+			return std::unique_ptr<T, Dx>(new T(std::forward<Args>(args)...));
+		}
+
+		template <typename Tag, typename T>
+		struct tagged {
+		private:
+			T value_;
+
+		public:
+			template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, tagged>> = meta::enabler>
+			tagged(Arg&& arg, Args&&... args) : value_(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+			}
+
+			T& value() & {
+				return value_;
+			}
+
+			T const& value() const& {
+				return value_;
+			}
+
+			T&& value() && {
+				return std::move(value_);
+			}
+		};
+	} // namespace detail
+
+	template <typename... Args>
+	struct constructor_list { };
+
+	template <typename... Args>
+	using constructors = constructor_list<Args...>;
+
+	const auto default_constructor = constructors<types<>> {};
+
+	struct no_construction { };
+	const auto no_constructor = no_construction {};
+
+	struct call_construction { };
+	const auto call_constructor = call_construction {};
+
+	template <typename... Functions>
+	struct constructor_wrapper {
+		std::tuple<Functions...> functions;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, constructor_wrapper>> = meta::enabler>
+		constructor_wrapper(Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename... Functions>
+	inline auto initializers(Functions&&... functions) {
+		return constructor_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
+	}
+
+	template <typename... Functions>
+	struct factory_wrapper {
+		std::tuple<Functions...> functions;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, factory_wrapper>> = meta::enabler>
+		factory_wrapper(Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename... Functions>
+	inline auto factories(Functions&&... functions) {
+		return factory_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
+	}
+
+	template <typename Function>
+	struct destructor_wrapper {
+		Function fx;
+		destructor_wrapper(Function f) : fx(std::move(f)) {
+		}
+	};
+
+	template <>
+	struct destructor_wrapper<void> { };
+
+	const destructor_wrapper<void> default_destructor {};
+
+	template <typename Fx>
+	inline auto destructor(Fx&& fx) {
+		return destructor_wrapper<std::decay_t<Fx>>(std::forward<Fx>(fx));
+	}
+
+} // namespace sol
+
+// end of sol/raii.hpp
+
+// beginning of sol/policies.hpp
+
+#include <array>
+
+namespace sol {
+	namespace detail {
+		struct policy_base_tag { };
+	} // namespace detail
+
+	template <int Target, int... In>
+	struct static_stack_dependencies : detail::policy_base_tag { };
+	typedef static_stack_dependencies<-1, 1> self_dependency;
+	template <int... In>
+	struct returns_self_with : detail::policy_base_tag { };
+	typedef returns_self_with<> returns_self;
+
+	struct stack_dependencies : detail::policy_base_tag {
+		int target;
+		std::array<int, 64> stack_indices;
+		std::size_t len;
+
+		template <typename... Args>
+		stack_dependencies(int stack_target, Args&&... args) : target(stack_target), stack_indices(), len(sizeof...(Args)) {
+			std::size_t i = 0;
+			(void)detail::swallow { int(), (stack_indices[i++] = static_cast<int>(std::forward<Args>(args)), int())... };
+		}
+
+		int& operator[](std::size_t i) {
+			return stack_indices[i];
+		}
+
+		const int& operator[](std::size_t i) const {
+			return stack_indices[i];
+		}
+
+		std::size_t size() const {
+			return len;
+		}
+	};
+
+	template <typename F, typename... Policies>
+	struct policy_wrapper {
+		typedef std::index_sequence_for<Policies...> indices;
+
+		F value;
+		std::tuple<Policies...> policies;
+
+		template <typename Fx, typename... Args, meta::enable<meta::neg<std::is_same<meta::unqualified_t<Fx>, policy_wrapper>>> = meta::enabler>
+		policy_wrapper(Fx&& fx, Args&&... args) : value(std::forward<Fx>(fx)), policies(std::forward<Args>(args)...) {
+		}
+
+		policy_wrapper(const policy_wrapper&) = default;
+		policy_wrapper& operator=(const policy_wrapper&) = default;
+		policy_wrapper(policy_wrapper&&) = default;
+		policy_wrapper& operator=(policy_wrapper&&) = default;
+	};
+
+	template <typename F, typename... Args>
+	auto policies(F&& f, Args&&... args) {
+		return policy_wrapper<std::decay_t<F>, std::decay_t<Args>...>(std::forward<F>(f), std::forward<Args>(args)...);
+	}
+
+	namespace detail {
+		template <typename T>
+		using is_policy = meta::is_specialization_of<T, policy_wrapper>;
+
+		template <typename T>
+		inline constexpr bool is_policy_v = is_policy<T>::value;
+	} // namespace detail
+} // namespace sol
+
+// end of sol/policies.hpp
+
+// beginning of sol/ebco.hpp
+
+#include <type_traits>
+#include <utility>
+#include <memory>
+
+namespace sol { namespace detail {
+
+	template <typename T, std::size_t tag = 0, typename = void>
+	struct ebco {
+		T m_value;
+
+		ebco() = default;
+		ebco(const ebco&) = default;
+		ebco(ebco&&) = default;
+		ebco& operator=(const ebco&) = default;
+		ebco& operator=(ebco&&) = default;
+		ebco(const T& v) noexcept(std::is_nothrow_copy_constructible_v<T>) : m_value(v) {};
+		ebco(T&& v) noexcept(std::is_nothrow_move_constructible_v<T>) : m_value(std::move(v)) {};
+		ebco& operator=(const T& v) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			m_value = v;
+			return *this;
+		}
+		ebco& operator=(T&& v) noexcept(std::is_nothrow_move_assignable_v<T>) {
+			m_value = std::move(v);
+			return *this;
+		};
+		template <typename Arg, typename... Args,
+			typename = std::enable_if_t<
+			     !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>,
+			          ebco> && !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>, T> && (sizeof...(Args) > 0 || !std::is_convertible_v<Arg, T>)>>
+		ebco(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Arg, Args...>)
+		: m_value(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		T& value() & noexcept {
+			return m_value;
+		}
+
+		T const& value() const& noexcept {
+			return m_value;
+		}
+
+		T&& value() && noexcept {
+			return std::move(m_value);
+		}
+	};
+
+	template <typename T, std::size_t tag>
+	struct ebco<T, tag, std::enable_if_t<!std::is_reference_v<T> && std::is_class_v<T> && !std::is_final_v<T>>> : T {
+		ebco() = default;
+		ebco(const ebco&) = default;
+		ebco(ebco&&) = default;
+		ebco(const T& v) noexcept(std::is_nothrow_copy_constructible_v<T>) : T(v) {};
+		ebco(T&& v) noexcept(std::is_nothrow_move_constructible_v<T>) : T(std::move(v)) {};
+		template <typename Arg, typename... Args,
+			typename = std::enable_if_t<
+			     !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>,
+			          ebco> && !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>, T> && (sizeof...(Args) > 0 || !std::is_convertible_v<Arg, T>)>>
+		ebco(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Arg, Args...>) : T(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		ebco& operator=(const ebco&) = default;
+		ebco& operator=(ebco&&) = default;
+		ebco& operator=(const T& v) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			static_cast<T&>(*this) = v;
+			return *this;
+		}
+		ebco& operator=(T&& v) noexcept(std::is_nothrow_move_assignable_v<T>) {
+			static_cast<T&>(*this) = std::move(v);
+			return *this;
+		};
+
+		T& value() & noexcept {
+			return static_cast<T&>(*this);
+		}
+
+		T const& value() const& noexcept {
+			return static_cast<T const&>(*this);
+		}
+
+		T&& value() && noexcept {
+			return std::move(static_cast<T&>(*this));
+		}
+	};
+
+	template <typename T, std::size_t tag>
+	struct ebco<T&, tag> {
+	private:
+		T* m_ref;
+
+	public:
+		ebco() = default;
+		ebco(const ebco&) = default;
+		ebco(ebco&&) = default;
+		ebco(T& v) noexcept : m_ref(std::addressof(v)) {};
+
+		ebco& operator=(const ebco&) = default;
+		ebco& operator=(ebco&&) = default;
+		ebco& operator=(T& v) noexcept {
+			m_ref = std::addressof(v);
+			return *this;
+		}
+
+		T& value() const noexcept {
+			return *(const_cast<ebco<T&, tag>&>(*this).m_ref);
+		}
+	};
+
+	template <typename T, std::size_t tag>
+	struct ebco<T&&, tag> {
+		T&& ref;
+
+		ebco() = default;
+		ebco(const ebco&) = delete;
+		ebco(ebco&&) = default;
+		ebco(T&& v) noexcept : ref(v) {};
+
+		ebco& operator=(const ebco&) = delete;
+		ebco& operator=(ebco&&) = delete;
+
+		T& value() & noexcept {
+			return ref;
+		}
+
+		const T& value() const& noexcept {
+			return ref;
+		}
+
+		T&& value() && noexcept {
+			return std::move(ref);
+		}
+	};
+
+}} // namespace sol::detail
+
+// end of sol/ebco.hpp
+
+#include <array>
+#include <initializer_list>
+#include <string>
+#include <string_view>
+#include <optional>
+#include <memory>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // variant shenanigans (thanks, Mac OSX)
+
+namespace sol {
+	namespace d {
+		// shortest possible hidden detail namespace
+		// when types are transcribed, this saves
+		// quite a bit of space, actually.
+		// it's a little unfortunate, but here we are?
+		template <typename T>
+		struct u { };
+	} // namespace d
+
+	namespace detail {
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		typedef int (*lua_CFunction_noexcept)(lua_State* L) noexcept;
+#else
+		typedef int (*lua_CFunction_noexcept)(lua_State* L);
+#endif // noexcept function type for lua_CFunction
+
+		template <typename T>
+		struct implicit_wrapper {
+			T& value;
+
+			implicit_wrapper(T* value_) : value(*value_) {
+			}
+
+			implicit_wrapper(T& value_) : value(value_) {
+			}
+
+			operator T&() {
+				return value;
+			}
+
+			operator T*() {
+				return std::addressof(value);
+			}
+		};
+
+		struct yield_tag_t { };
+		inline constexpr yield_tag_t yield_tag {};
+	} // namespace detail
+
+	struct lua_nil_t { };
+	inline constexpr lua_nil_t lua_nil {};
+	inline bool operator==(lua_nil_t, lua_nil_t) {
+		return true;
+	}
+	inline bool operator!=(lua_nil_t, lua_nil_t) {
+		return false;
+	}
+#if SOL_IS_ON(SOL_NIL)
+	using nil_t = lua_nil_t;
+	inline constexpr const nil_t& nil = lua_nil;
+#endif
+
+	namespace detail {
+		struct non_lua_nil_t { };
+	} // namespace detail
+
+	struct metatable_key_t { };
+	inline constexpr metatable_key_t metatable_key {};
+
+	struct global_tag_t {
+	} inline constexpr global_tag {};
+
+	struct env_key_t { };
+	inline constexpr env_key_t env_key {};
+
+	struct no_metatable_t { };
+	inline constexpr no_metatable_t no_metatable {};
+
+	template <typename T>
+	struct yielding_t {
+		T func;
+
+		yielding_t() = default;
+		yielding_t(const yielding_t&) = default;
+		yielding_t(yielding_t&&) = default;
+		yielding_t& operator=(const yielding_t&) = default;
+		yielding_t& operator=(yielding_t&&) = default;
+		template <typename Arg,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<Arg>, yielding_t>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<Arg>>>> = meta::enabler>
+		yielding_t(Arg&& arg) : func(std::forward<Arg>(arg)) {
+		}
+		template <typename Arg0, typename Arg1, typename... Args>
+		yielding_t(Arg0&& arg0, Arg1&& arg1, Args&&... args) : func(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename F>
+	inline yielding_t<std::decay_t<F>> yielding(F&& f) {
+		return yielding_t<std::decay_t<F>>(std::forward<F>(f));
+	}
+
+	typedef std::remove_pointer_t<lua_CFunction> lua_CFunction_ref;
+
+	template <typename T>
+	struct non_null { };
+
+	template <typename... Args>
+	struct function_sig { };
+
+	struct upvalue_index {
+		int index;
+		upvalue_index(int idx) : index(lua_upvalueindex(idx)) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct raw_index {
+		int index;
+		raw_index(int i) : index(i) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct absolute_index {
+		int index;
+		absolute_index(lua_State* L, int idx) : index(lua_absindex(L, idx)) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct ref_index {
+		int index;
+		ref_index(int idx) : index(idx) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct stack_count {
+		int count;
+
+		stack_count(int cnt) : count(cnt) {
+		}
+	};
+
+	struct lightuserdata_value {
+		void* value;
+		lightuserdata_value(void* data) : value(data) {
+		}
+		operator void*() const {
+			return value;
+		}
+	};
+
+	struct userdata_value {
+	private:
+		void* m_value;
+
+	public:
+		userdata_value(void* data) : m_value(data) {
+		}
+
+		void* value() const {
+			return m_value;
+		}
+
+		operator void*() const {
+			return value();
+		}
+	};
+
+	template <typename T>
+	struct light {
+	private:
+		static_assert(!std::is_void_v<T>, "the type for light will never be void");
+		T* m_value;
+
+	public:
+		light(T& x) : m_value(std::addressof(x)) {
+		}
+		light(T* x) : m_value(x) {
+		}
+		explicit light(void* x) : m_value(static_cast<T*>(x)) {
+		}
+
+		T* value() const {
+			return m_value;
+		}
+
+		operator T*() const {
+			return m_value;
+		}
+		operator T&() const {
+			return *m_value;
+		}
+
+		void* void_value() const {
+			return m_value;
+		}
+	};
+
+	template <typename T>
+	auto make_light(T& l) {
+		typedef meta::unwrapped_t<std::remove_pointer_t<std::remove_pointer_t<T>>> L;
+		return light<L>(l);
+	}
+
+	template <typename T>
+	struct user : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+
+		using base_t::value;
+
+		operator std::add_pointer_t<std::remove_reference_t<T>>() {
+			return std::addressof(this->base_t::value());
+		}
+
+		operator std::add_pointer_t<std::add_const_t<std::remove_reference_t<T>>>() const {
+			return std::addressof(this->base_t::value());
+		}
+
+		operator std::add_lvalue_reference_t<T>() {
+			return this->base_t::value();
+		}
+
+		operator std::add_const_t<std::add_lvalue_reference_t<T>>&() const {
+			return this->base_t::value();
+		}
+	};
+
+	template <typename T>
+	auto make_user(T&& u) {
+		typedef meta::unwrapped_t<meta::unqualified_t<T>> U;
+		return user<U>(std::forward<T>(u));
+	}
+
+	template <typename T>
+	struct metatable_registry_key : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+
+		using base_t::value;
+	};
+
+	template <typename T>
+	auto meta_registry_key(T&& key) {
+		typedef meta::unqualified_t<T> K;
+		return metatable_registry_key<K>(std::forward<T>(key));
+	}
+
+	template <typename... Upvalues>
+	struct closure {
+		lua_CFunction c_function;
+		std::tuple<Upvalues...> upvalues;
+		closure(lua_CFunction f, Upvalues... targetupvalues) : c_function(f), upvalues(std::forward<Upvalues>(targetupvalues)...) {
+		}
+	};
+
+	template <>
+	struct closure<> {
+		lua_CFunction c_function;
+		int upvalues;
+		closure(lua_CFunction f, int upvalue_count = 0) : c_function(f), upvalues(upvalue_count) {
+		}
+	};
+
+	typedef closure<> c_closure;
+
+	template <typename... Args>
+	closure<Args...> make_closure(lua_CFunction f, Args&&... args) {
+		return closure<Args...>(f, std::forward<Args>(args)...);
+	}
+
+	template <typename Sig, typename... Ps>
+	struct function_arguments {
+		std::tuple<Ps...> arguments;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, function_arguments>> = meta::enabler>
+		function_arguments(Arg&& arg, Args&&... args) : arguments(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename Sig = function_sig<>, typename... Args>
+	auto as_function(Args&&... args) {
+		return function_arguments<Sig, std::decay_t<Args>...>(std::forward<Args>(args)...);
+	}
+
+	template <typename Sig = function_sig<>, typename... Args>
+	auto as_function_reference(Args&&... args) {
+		return function_arguments<Sig, Args...>(std::forward<Args>(args)...);
+	}
+
+	template <typename T>
+	struct as_table_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		as_table_t() = default;
+		as_table_t(const as_table_t&) = default;
+		as_table_t(as_table_t&&) = default;
+		as_table_t& operator=(const as_table_t&) = default;
+		as_table_t& operator=(as_table_t&&) = default;
+		as_table_t(const meta::unqualified_t<T>& obj) noexcept(std::is_nothrow_constructible_v<base_t, const meta::unqualified_t<T>&>) : base_t(obj) {
+		}
+		as_table_t(meta::unqualified_t<T>&& obj) noexcept(std::is_nothrow_constructible_v<base_t, meta::unqualified_t<T>&&>) : base_t(std::move(obj)) {
+		}
+		template <typename Arg, typename... Args,
+		     std::enable_if_t<
+		          !std::is_same_v<as_table_t, meta::unqualified_t<Arg>> && !std::is_same_v<meta::unqualified_t<T>, meta::unqualified_t<Arg>>>* = nullptr>
+		as_table_t(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<base_t, Arg, Args...>)
+		: base_t(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		using base_t::value;
+
+		operator std::add_lvalue_reference_t<T>() {
+			return this->base_t::value();
+		}
+
+		operator std::add_const_t<std::add_lvalue_reference_t<T>>() const {
+			return this->base_t::value();
+		}
+	};
+
+	template <typename T>
+	struct nested : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using nested_type = T;
+
+		nested() = default;
+		nested(const nested&) = default;
+		nested(nested&&) = default;
+		nested& operator=(const nested&) = default;
+		nested& operator=(nested&&) = default;
+		nested(const meta::unqualified_t<T>& obj) noexcept(std::is_nothrow_constructible_v<base_t, const meta::unqualified_t<T>&>) : base_t(obj) {
+		}
+		nested(meta::unqualified_t<T>&& obj) noexcept(std::is_nothrow_constructible_v<base_t, meta::unqualified_t<T>&&>) : base_t(std::move(obj)) {
+		}
+		template <typename Arg, typename... Args,
+		     std::enable_if_t<
+		          !std::is_same_v<nested, meta::unqualified_t<Arg>> && !std::is_same_v<meta::unqualified_t<T>, meta::unqualified_t<Arg>>>* = nullptr>
+		nested(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<base_t, Arg, Args...>)
+		: base_t(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		using base_t::value;
+
+		operator std::add_lvalue_reference_t<T>() {
+			return this->base_t::value();
+		}
+
+		operator std::add_const_t<std::add_lvalue_reference_t<T>>() const {
+			return this->base_t::value();
+		}
+	};
+
+	struct nested_tag_t { };
+	constexpr inline nested_tag_t nested_tag {};
+
+	template <typename T>
+	as_table_t<T> as_table_ref(T&& container) {
+		return as_table_t<T>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	as_table_t<meta::unqualified_t<T>> as_table(T&& container) {
+		return as_table_t<meta::unqualified_t<T>>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	nested<T> as_nested_ref(T&& container) {
+		return nested<T>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	nested<meta::unqualified_t<T>> as_nested(T&& container) {
+		return nested<meta::unqualified_t<T>>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	struct as_container_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using type = T;
+
+		as_container_t() = default;
+		as_container_t(const as_container_t&) = default;
+		as_container_t(as_container_t&&) = default;
+		as_container_t& operator=(const as_container_t&) = default;
+		as_container_t& operator=(as_container_t&&) = default;
+
+		using base_t::base_t;
+
+		using base_t::value;
+
+		operator std::add_lvalue_reference_t<T>() {
+			return value();
+		}
+	};
+
+	template <typename T>
+	auto as_container(T&& value) {
+		return as_container_t<T>(std::forward<T>(value));
+	}
+
+	template <typename T>
+	struct push_invoke_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		push_invoke_t() = default;
+		push_invoke_t(const push_invoke_t&) = default;
+		push_invoke_t(push_invoke_t&&) = default;
+		push_invoke_t& operator=(const push_invoke_t&) = default;
+		push_invoke_t& operator=(push_invoke_t&&) = default;
+
+		using base_t::base_t;
+
+		using base_t::value;
+	};
+
+	template <typename Fx>
+	auto push_invoke(Fx&& fx) {
+		return push_invoke_t<Fx>(std::forward<Fx>(fx));
+	}
+
+	template <typename T>
+	struct forward_as_value_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		forward_as_value_t() = default;
+		forward_as_value_t(const forward_as_value_t&) = default;
+		forward_as_value_t(forward_as_value_t&&) = default;
+		forward_as_value_t& operator=(const forward_as_value_t&) = default;
+		forward_as_value_t& operator=(forward_as_value_t&&) = default;
+
+		using base_t::base_t;
+
+		using base_t::value;
+	};
+
+	template <typename T>
+	auto pass_as_value(T& value_ref_) {
+		return forward_as_value_t<T>(value_ref_);
+	}
+
+	struct override_value_t { };
+	constexpr inline override_value_t override_value = override_value_t();
+	struct update_if_empty_t { };
+	constexpr inline update_if_empty_t update_if_empty = update_if_empty_t();
+	struct create_if_nil_t { };
+	constexpr inline create_if_nil_t create_if_nil = create_if_nil_t();
+
+	namespace detail {
+		enum insert_mode { none = 0x0, update_if_empty = 0x01, override_value = 0x02, create_if_nil = 0x04 };
+
+		template <typename T, typename...>
+		using is_insert_mode = std::integral_constant<bool,
+		     std::is_same_v<T, override_value_t> || std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, create_if_nil_t>>;
+
+		template <typename T, typename...>
+		using is_not_insert_mode = meta::neg<is_insert_mode<T>>;
+	} // namespace detail
+
+	struct this_state {
+		lua_State* L;
+
+		this_state(lua_State* Ls) : L(Ls) {
+		}
+
+		operator lua_State*() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* operator->() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		}
+	};
+
+	struct this_main_state {
+		lua_State* L;
+
+		this_main_state(lua_State* Ls) : L(Ls) {
+		}
+
+		operator lua_State*() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* operator->() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		}
+	};
+
+	struct new_table {
+		int sequence_hint = 0;
+		int map_hint = 0;
+
+		new_table() = default;
+		new_table(const new_table&) = default;
+		new_table(new_table&&) = default;
+		new_table& operator=(const new_table&) = default;
+		new_table& operator=(new_table&&) = default;
+
+		new_table(int sequence_hint_, int map_hint_ = 0) noexcept : sequence_hint(sequence_hint_), map_hint(map_hint_) {
+		}
+	};
+
+	const new_table create = {};
+
+	enum class lib : unsigned char {
+		// print, assert, and other base functions
+		base,
+		// require and other package functions
+		package,
+		// coroutine functions and utilities
+		coroutine,
+		// string library
+		string,
+		// functionality from the OS
+		os,
+		// all things math
+		math,
+		// the table manipulator and observer functions
+		table,
+		// the debug library
+		debug,
+		// the bit library: different based on which you're using
+		bit32,
+		// input/output library
+		io,
+		// LuaJIT only
+		ffi,
+		// LuaJIT only
+		jit,
+		// library for handling utf8: new to Lua
+		utf8,
+		// do not use
+		count
+	};
+
+	enum class call_syntax { dot = 0, colon = 1 };
+
+	enum class load_mode {
+		any = 0,
+		text = 1,
+		binary = 2,
+	};
+
+	enum class call_status : int {
+		ok = LUA_OK,
+		yielded = LUA_YIELD,
+		runtime = LUA_ERRRUN,
+		memory = LUA_ERRMEM,
+		handler = LUA_ERRERR,
+		gc = LUA_ERRGCMM,
+		syntax = LUA_ERRSYNTAX,
+		file = LUA_ERRFILE,
+	};
+
+	enum class thread_status : int {
+		ok = LUA_OK,
+		yielded = LUA_YIELD,
+		runtime = LUA_ERRRUN,
+		memory = LUA_ERRMEM,
+		gc = LUA_ERRGCMM,
+		handler = LUA_ERRERR,
+		dead = -1,
+	};
+
+	enum class load_status : int {
+		ok = LUA_OK,
+		syntax = LUA_ERRSYNTAX,
+		memory = LUA_ERRMEM,
+		gc = LUA_ERRGCMM,
+		file = LUA_ERRFILE,
+	};
+
+	enum class gc_mode : int {
+		incremental = 0,
+		generational = 1,
+		default_value = incremental,
+	};
+
+	enum class type : int {
+		none = LUA_TNONE,
+		lua_nil = LUA_TNIL,
+#if SOL_IS_ON(SOL_NIL)
+		nil = lua_nil,
+#endif // Objective C/C++ Keyword that's found in OSX SDK and OBJC -- check for all forms to protect
+		string = LUA_TSTRING,
+		number = LUA_TNUMBER,
+		thread = LUA_TTHREAD,
+		boolean = LUA_TBOOLEAN,
+		function = LUA_TFUNCTION,
+		userdata = LUA_TUSERDATA,
+		lightuserdata = LUA_TLIGHTUSERDATA,
+		table = LUA_TTABLE,
+		poly = -0xFFFF
+	};
+
+	inline const std::string& to_string(call_status c) {
+		static const std::array<std::string, 10> names { { "ok",
+			"yielded",
+			"runtime",
+			"memory",
+			"handler",
+			"gc",
+			"syntax",
+			"file",
+			"CRITICAL_EXCEPTION_FAILURE",
+			"CRITICAL_INDETERMINATE_STATE_FAILURE" } };
+		switch (c) {
+		case call_status::ok:
+			return names[0];
+		case call_status::yielded:
+			return names[1];
+		case call_status::runtime:
+			return names[2];
+		case call_status::memory:
+			return names[3];
+		case call_status::handler:
+			return names[4];
+		case call_status::gc:
+			return names[5];
+		case call_status::syntax:
+			return names[6];
+		case call_status::file:
+			return names[7];
+		}
+		if (static_cast<std::ptrdiff_t>(c) == -1) {
+			// One of the many cases where a critical exception error has occurred
+			return names[8];
+		}
+		return names[9];
+	}
+
+	inline bool is_indeterminate_call_failure(call_status c) {
+		switch (c) {
+		case call_status::ok:
+		case call_status::yielded:
+		case call_status::runtime:
+		case call_status::memory:
+		case call_status::handler:
+		case call_status::gc:
+		case call_status::syntax:
+		case call_status::file:
+			return false;
+		}
+		return true;
+	}
+
+	inline const std::string& to_string(load_status c) {
+		static const std::array<std::string, 7> names {
+			{ "ok", "memory", "gc", "syntax", "file", "CRITICAL_EXCEPTION_FAILURE", "CRITICAL_INDETERMINATE_STATE_FAILURE" }
+		};
+		switch (c) {
+		case load_status::ok:
+			return names[0];
+		case load_status::memory:
+			return names[1];
+		case load_status::gc:
+			return names[2];
+		case load_status::syntax:
+			return names[3];
+		case load_status::file:
+			return names[4];
+		}
+		if (static_cast<int>(c) == -1) {
+			// One of the many cases where a critical exception error has occurred
+			return names[5];
+		}
+		return names[6];
+	}
+
+	inline const std::string& to_string(load_mode c) {
+		static const std::array<std::string, 3> names { {
+			"bt",
+			"t",
+			"b",
+		} };
+		return names[static_cast<std::size_t>(c)];
+	}
+
+	enum class meta_function : unsigned {
+		construct,
+		index,
+		new_index,
+		mode,
+		call,
+		call_function = call,
+		metatable,
+		to_string,
+		length,
+		unary_minus,
+		addition,
+		subtraction,
+		multiplication,
+		division,
+		modulus,
+		power_of,
+		involution = power_of,
+		concatenation,
+		equal_to,
+		less_than,
+		less_than_or_equal_to,
+		garbage_collect,
+		floor_division,
+		bitwise_left_shift,
+		bitwise_right_shift,
+		bitwise_not,
+		bitwise_and,
+		bitwise_or,
+		bitwise_xor,
+		pairs,
+		ipairs,
+		next,
+		type,
+		type_info,
+		call_construct,
+		storage,
+		gc_names,
+		static_index,
+		static_new_index,
+	};
+
+	typedef meta_function meta_method;
+
+	inline const std::array<std::string, 37>& meta_function_names() {
+		static const std::array<std::string, 37> names = { { "new",
+			"__index",
+			"__newindex",
+			"__mode",
+			"__call",
+			"__metatable",
+			"__tostring",
+			"__len",
+			"__unm",
+			"__add",
+			"__sub",
+			"__mul",
+			"__div",
+			"__mod",
+			"__pow",
+			"__concat",
+			"__eq",
+			"__lt",
+			"__le",
+			"__gc",
+
+			"__idiv",
+			"__shl",
+			"__shr",
+			"__bnot",
+			"__band",
+			"__bor",
+			"__bxor",
+
+			"__pairs",
+			"__ipairs",
+			"next",
+
+			"__type",
+			"__typeinfo",
+			"__sol.call_new",
+			"__sol.storage",
+			"__sol.gc_names",
+			"__sol.static_index",
+			"__sol.static_new_index" } };
+		return names;
+	}
+
+	inline const std::string& to_string(meta_function mf) {
+		return meta_function_names()[static_cast<std::size_t>(mf)];
+	}
+
+	inline type type_of(lua_State* L, int index) {
+		return static_cast<type>(lua_type(L, index));
+	}
+
+	inline std::string type_name(lua_State* L, type t) {
+		return lua_typename(L, static_cast<int>(t));
+	}
+
+	template <typename T>
+	struct is_stateless_lua_reference
+	: std::integral_constant<bool,
+	       (std::is_base_of_v<stateless_stack_reference, T> || std::is_base_of_v<stateless_reference, T>)&&(
+	            !std::is_base_of_v<stack_reference, T> && !std::is_base_of_v<reference, T> && !std::is_base_of_v<main_reference, T>)> { };
+
+	template <typename T>
+	inline constexpr bool is_stateless_lua_reference_v = is_stateless_lua_reference<T>::value;
+
+	template <typename T>
+	struct is_lua_reference
+	: std::integral_constant<bool,
+	       std::is_base_of_v<reference,
+	            T> || std::is_base_of_v<main_reference, T> || std::is_base_of_v<stack_reference, T> || std::is_base_of_v<stateless_stack_reference, T> || std::is_base_of_v<stateless_reference, T>> {
+	};
+
+	template <typename T>
+	inline constexpr bool is_lua_reference_v = is_lua_reference<T>::value;
+
+	template <typename T>
+	struct is_lua_reference_or_proxy : std::integral_constant<bool, is_lua_reference_v<T> || meta::is_specialization_of_v<T, table_proxy>> { };
+
+	template <typename T>
+	inline constexpr bool is_lua_reference_or_proxy_v = is_lua_reference_or_proxy<T>::value;
+
+	template <typename T>
+	struct is_transparent_argument
+	: std::integral_constant<bool,
+	       std::is_same_v<meta::unqualified_t<T>,
+	            this_state> || std::is_same_v<meta::unqualified_t<T>, this_main_state> || std::is_same_v<meta::unqualified_t<T>, this_environment> || std::is_same_v<meta::unqualified_t<T>, variadic_args>> {
+	};
+
+	template <typename T>
+	constexpr inline bool is_transparent_argument_v = is_transparent_argument<T>::value;
+
+	template <typename T>
+	struct is_variadic_arguments : meta::any<std::is_same<T, variadic_args>, meta::is_optional<T>> { };
+
+	template <typename T>
+	struct is_container
+	: std::integral_constant<bool,
+	       !std::is_same_v<state_view,
+	            T> && !std::is_same_v<state, T> && !meta::is_initializer_list_v<T> && !meta::is_string_like_v<T> && !meta::is_string_literal_array_v<T> && !is_transparent_argument_v<T> && !is_lua_reference_v<T> && (meta::has_begin_end_v<T> || std::is_array_v<T>)> {
+	};
+
+	template <typename T>
+	constexpr inline bool is_container_v = is_container<T>::value;
+
+	template <typename T>
+	struct is_to_stringable : meta::any<meta::supports_to_string_member<meta::unqualified_t<T>>, meta::supports_adl_to_string<meta::unqualified_t<T>>,
+	                               meta::supports_op_left_shift<std::ostream, meta::unqualified_t<T>>> { };
+
+	template <typename T>
+	inline constexpr bool is_to_stringable_v = is_to_stringable<T>::value;
+
+	template <typename T>
+	struct is_callable : std::true_type { };
+
+	template <typename T>
+	inline constexpr bool is_callable_v = is_callable<T>::value;
+
+	namespace detail {
+		template <typename T, typename = void>
+		struct lua_type_of : std::integral_constant<type, type::userdata> { };
+
+		template <typename C, typename T, typename A>
+		struct lua_type_of<std::basic_string<C, T, A>> : std::integral_constant<type, type::string> { };
+
+		template <typename C, typename T>
+		struct lua_type_of<basic_string_view<C, T>> : std::integral_constant<type, type::string> { };
+
+		template <std::size_t N>
+		struct lua_type_of<char[N]> : std::integral_constant<type, type::string> { };
+
+		template <std::size_t N>
+		struct lua_type_of<wchar_t[N]> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+		template <std::size_t N>
+		struct lua_type_of<char8_t[N]> : std::integral_constant<type, type::string> { };
+#endif
+
+		template <std::size_t N>
+		struct lua_type_of<char16_t[N]> : std::integral_constant<type, type::string> { };
+
+		template <std::size_t N>
+		struct lua_type_of<char32_t[N]> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<char> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<wchar_t> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+		template <>
+		struct lua_type_of<char8_t> : std::integral_constant<type, type::string> { };
+#endif
+
+		template <>
+		struct lua_type_of<char16_t> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<char32_t> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<const char*> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<const wchar_t*> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+		template <>
+		struct lua_type_of<const char8_t*> : std::integral_constant<type, type::string> { };
+#endif
+
+		template <>
+		struct lua_type_of<const char16_t*> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<const char32_t*> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<bool> : std::integral_constant<type, type::boolean> { };
+
+		template <>
+		struct lua_type_of<lua_nil_t> : std::integral_constant<type, type::lua_nil> { };
+
+		template <>
+		struct lua_type_of<nullopt_t> : std::integral_constant<type, type::lua_nil> { };
+
+		template <>
+		struct lua_type_of<lua_value> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<detail::non_lua_nil_t> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<std::nullptr_t> : std::integral_constant<type, type::lua_nil> { };
+
+		template <>
+		struct lua_type_of<error> : std::integral_constant<type, type::string> { };
+
+		template <bool b, typename Base>
+		struct lua_type_of<basic_table_core<b, Base>> : std::integral_constant<type, type::table> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_lua_table<Base>> : std::integral_constant<type, type::table> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_metatable<Base>> : std::integral_constant<type, type::table> { };
+
+		template <typename T, typename Base>
+		struct lua_type_of<basic_usertype<T, Base>> : std::integral_constant<type, type::table> { };
+
+		template <>
+		struct lua_type_of<metatable_key_t> : std::integral_constant<type, type::table> { };
+
+		template <typename B>
+		struct lua_type_of<basic_environment<B>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<env_key_t> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<new_table> : std::integral_constant<type, type::table> { };
+
+		template <typename T>
+		struct lua_type_of<as_table_t<T>> : std::integral_constant<type, type::table> { };
+
+		template <typename T>
+		struct lua_type_of<std::initializer_list<T>> : std::integral_constant<type, type::table> { };
+
+		template <bool b>
+		struct lua_type_of<basic_reference<b>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<stack_reference> : std::integral_constant<type, type::poly> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_object<Base>> : std::integral_constant<type, type::poly> { };
+
+		template <typename... Args>
+		struct lua_type_of<std::tuple<Args...>> : std::integral_constant<type, type::poly> { };
+
+		template <typename A, typename B>
+		struct lua_type_of<std::pair<A, B>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<void*> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <>
+		struct lua_type_of<const void*> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <>
+		struct lua_type_of<lightuserdata_value> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <>
+		struct lua_type_of<userdata_value> : std::integral_constant<type, type::userdata> { };
+
+		template <typename T>
+		struct lua_type_of<light<T>> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <typename T>
+		struct lua_type_of<user<T>> : std::integral_constant<type, type::userdata> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_lightuserdata<Base>> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_userdata<Base>> : std::integral_constant<type, type::userdata> { };
+
+		template <>
+		struct lua_type_of<lua_CFunction> : std::integral_constant<type, type::function> { };
+
+		template <>
+		struct lua_type_of<std::remove_pointer_t<lua_CFunction>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base, bool aligned>
+		struct lua_type_of<basic_function<Base, aligned>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base, bool aligned, typename Handler>
+		struct lua_type_of<basic_protected_function<Base, aligned, Handler>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_coroutine<Base>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_thread<Base>> : std::integral_constant<type, type::thread> { };
+
+		template <typename Signature>
+		struct lua_type_of<std::function<Signature>> : std::integral_constant<type, type::function> { };
+
+		template <typename T>
+		struct lua_type_of<optional<T>> : std::integral_constant<type, type::poly> { };
+
+		template <typename T>
+		struct lua_type_of<std::optional<T>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<variadic_args> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<variadic_results> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<stack_count> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<this_state> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<this_main_state> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<this_environment> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<type> : std::integral_constant<type, type::poly> { };
+
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+		template <typename T>
+		struct lua_type_of<T*> : std::integral_constant<type, std::is_function_v<T> ? type::function : type::userdata> { };
+#else
+		template <typename T>
+		struct lua_type_of<T*> : std::integral_constant<type, type::userdata> { };
+#endif
+
+		template <typename T>
+		struct lua_type_of<T, std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, lua_Number> || std::is_same_v<T, lua_Integer>>>
+		: std::integral_constant<type, type::number> { };
+
+		template <typename T>
+		struct lua_type_of<T, std::enable_if_t<std::is_function_v<T>>> : std::integral_constant<type, type::function> { };
+
+		template <typename T>
+		struct lua_type_of<T, std::enable_if_t<std::is_enum_v<T>>> : std::integral_constant<type, type::number> { };
+
+		template <>
+		struct lua_type_of<meta_function> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+		template <typename... Tn>
+		struct lua_type_of<std::variant<Tn...>> : std::integral_constant<type, type::poly> { };
+#endif // std::variant deployment sucks on Clang
+
+		template <typename T>
+		struct lua_type_of<nested<T>> : meta::conditional_t<::sol::is_container_v<T>, std::integral_constant<type, type::table>, lua_type_of<T>> { };
+
+		template <typename C, C v, template <typename...> class V, typename... Args>
+		struct accumulate : std::integral_constant<C, v> { };
+
+		template <typename C, C v, template <typename...> class V, typename T, typename... Args>
+		struct accumulate<C, v, V, T, Args...> : accumulate<C, v + V<T>::value, V, Args...> { };
+
+		template <typename C, C v, template <typename...> class V, typename List>
+		struct accumulate_list;
+
+		template <typename C, C v, template <typename...> class V, typename... Args>
+		struct accumulate_list<C, v, V, types<Args...>> : accumulate<C, v, V, Args...> { };
+	} // namespace detail
+
+	template <typename T>
+	struct lua_type_of : detail::lua_type_of<T> {
+		typedef int SOL_INTERNAL_UNSPECIALIZED_MARKER_;
+	};
+
+	template <typename T>
+	inline constexpr type lua_type_of_v = lua_type_of<T>::value;
+
+	template <typename T>
+	struct lua_size : std::integral_constant<int, 1> {
+		typedef int SOL_INTERNAL_UNSPECIALIZED_MARKER_;
+	};
+
+	template <typename A, typename B>
+	struct lua_size<std::pair<A, B>> : std::integral_constant<int, lua_size<A>::value + lua_size<B>::value> { };
+
+	template <typename... Args>
+	struct lua_size<std::tuple<Args...>> : std::integral_constant<int, detail::accumulate<int, 0, lua_size, Args...>::value> { };
+
+	template <typename T>
+	inline constexpr int lua_size_v = lua_size<T>::value;
+
+	namespace detail {
+		// MSVC's decltype detection is broken, which breaks other
+		// parts of the code. So we add more workarounds. The moment it's fixed,
+		// we take it away and break everyone that doesn't upgrade.
+		template <typename T>
+		using is_msvc_callable_rigged = meta::any<meta::is_specialization_of<T, push_invoke_t>, meta::is_specialization_of<T, as_table_t>,
+		     meta::is_specialization_of<T, forward_as_value_t>, meta::is_specialization_of<T, as_container_t>, meta::is_specialization_of<T, nested>,
+		     meta::is_specialization_of<T, yielding_t>>;
+
+		template <typename T>
+		inline constexpr bool is_msvc_callable_rigged_v = is_msvc_callable_rigged<T>::value;
+	} // namespace detail
+
+	template <typename T>
+	struct is_lua_primitive
+	: std::integral_constant<bool,
+	       type::userdata
+	                 != lua_type_of_v<
+	                      T> || ((type::userdata == lua_type_of_v<T>)&&meta::meta_detail::has_internal_marker_v<lua_type_of<T>> && !meta::meta_detail::has_internal_marker_v<lua_size<T>>)
+	            || is_lua_reference_or_proxy_v<T> || meta::is_specialization_of_v<T, std::tuple> || meta::is_specialization_of_v<T, std::pair>> { };
+
+	template <typename T>
+	constexpr inline bool is_lua_primitive_v = is_lua_primitive<T>::value;
+
+	template <typename T>
+	struct is_value_semantic_for_function
+#if SOL_IS_ON(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
+	: std::true_type {
+	};
+#else
+	: std::false_type {
+	};
+#endif
+
+	template <typename T>
+	constexpr inline bool is_value_semantic_for_function_v = is_value_semantic_for_function<T>::value;
+
+	template <typename T>
+	struct is_main_threaded : std::is_base_of<main_reference, T> { };
+
+	template <typename T>
+	inline constexpr bool is_main_threaded_v = is_main_threaded<T>::value;
+
+	template <typename T>
+	struct is_stack_based : std::is_base_of<stack_reference, T> { };
+	template <>
+	struct is_stack_based<variadic_args> : std::true_type { };
+	template <>
+	struct is_stack_based<unsafe_function_result> : std::true_type { };
+	template <>
+	struct is_stack_based<protected_function_result> : std::true_type { };
+	template <>
+	struct is_stack_based<stack_proxy> : std::true_type { };
+	template <>
+	struct is_stack_based<stack_proxy_base> : std::true_type { };
+	template <>
+	struct is_stack_based<stack_count> : std::true_type { };
+
+	template <typename T>
+	constexpr inline bool is_stack_based_v = is_stack_based<T>::value;
+
+	template <typename T>
+	struct is_lua_primitive<T*> : std::true_type { };
+	template <>
+	struct is_lua_primitive<unsafe_function_result> : std::true_type { };
+	template <>
+	struct is_lua_primitive<protected_function_result> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<std::reference_wrapper<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<user<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<light<T>> : is_lua_primitive<T*> { };
+	template <typename T>
+	struct is_lua_primitive<optional<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<std::optional<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<as_table_t<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<nested<T>> : std::true_type { };
+	template <>
+	struct is_lua_primitive<userdata_value> : std::true_type { };
+	template <>
+	struct is_lua_primitive<lightuserdata_value> : std::true_type { };
+	template <>
+	struct is_lua_primitive<stack_proxy> : std::true_type { };
+	template <>
+	struct is_lua_primitive<stack_proxy_base> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<non_null<T>> : is_lua_primitive<T*> { };
+
+	template <typename T>
+	struct is_lua_index : std::is_integral<T> { };
+	template <>
+	struct is_lua_index<raw_index> : std::true_type { };
+	template <>
+	struct is_lua_index<absolute_index> : std::true_type { };
+	template <>
+	struct is_lua_index<ref_index> : std::true_type { };
+	template <>
+	struct is_lua_index<upvalue_index> : std::true_type { };
+
+	template <typename Signature>
+	struct lua_bind_traits : meta::bind_traits<Signature> {
+	private:
+		typedef meta::bind_traits<Signature> base_t;
+
+	public:
+		typedef std::integral_constant<bool, meta::count_for<is_variadic_arguments, typename base_t::args_list>::value != 0> runtime_variadics_t;
+		static const std::size_t true_arity = base_t::arity;
+		static const std::size_t arity = detail::accumulate_list<std::size_t, 0, lua_size, typename base_t::args_list>::value
+		     - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
+		static const std::size_t true_free_arity = base_t::free_arity;
+		static const std::size_t free_arity = detail::accumulate_list<std::size_t, 0, lua_size, typename base_t::free_args_list>::value
+		     - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
+	};
+
+	template <typename T>
+	struct is_table : std::false_type { };
+	template <bool x, typename T>
+	struct is_table<basic_table_core<x, T>> : std::true_type { };
+	template <typename T>
+	struct is_table<basic_lua_table<T>> : std::true_type { };
+
+	template <typename T>
+	inline constexpr bool is_table_v = is_table<T>::value;
+
+	template <typename T>
+	struct is_global_table : std::false_type { };
+	template <typename T>
+	struct is_global_table<basic_table_core<true, T>> : std::true_type { };
+
+	template <typename T>
+	inline constexpr bool is_global_table_v = is_global_table<T>::value;
+
+	template <typename T>
+	struct is_stack_table : std::false_type { };
+	template <bool x, typename T>
+	struct is_stack_table<basic_table_core<x, T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> { };
+	template <typename T>
+	struct is_stack_table<basic_lua_table<T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> { };
+
+	template <typename T>
+	inline constexpr bool is_stack_table_v = is_stack_table<T>::value;
+
+	template <typename T>
+	struct is_function : std::false_type { };
+	template <typename T, bool aligned>
+	struct is_function<basic_function<T, aligned>> : std::true_type { };
+	template <typename T, bool aligned, typename Handler>
+	struct is_function<basic_protected_function<T, aligned, Handler>> : std::true_type { };
+
+	template <typename T>
+	using is_lightuserdata = meta::is_specialization_of<T, basic_lightuserdata>;
+
+	template <typename T>
+	inline constexpr bool is_lightuserdata_v = is_lightuserdata<T>::value;
+
+	template <typename T>
+	using is_userdata = meta::is_specialization_of<T, basic_userdata>;
+
+	template <typename T>
+	inline constexpr bool is_userdata_v = is_userdata<T>::value;
+
+	template <typename T>
+	using is_environment = std::integral_constant<bool, is_userdata_v<T> || is_table_v<T> || meta::is_specialization_of_v<T, basic_environment>>;
+
+	template <typename T>
+	inline constexpr bool is_environment_v = is_environment<T>::value;
+
+	template <typename T>
+	using is_table_like = std::integral_constant<bool, is_table_v<T> || is_environment_v<T> || is_userdata_v<T>>;
+
+	template <typename T>
+	inline constexpr bool is_table_like_v = is_table_like<T>::value;
+
+	template <typename T>
+	struct is_automagical
+	: std::integral_constant<bool,
+	       (SOL_IS_ON(SOL_DEFAULT_AUTOMAGICAL_USERTYPES))
+	            || (std::is_array_v<
+	                     meta::unqualified_t<T>> || (!std::is_same_v<meta::unqualified_t<T>, state> && !std::is_same_v<meta::unqualified_t<T>, state_view>))> {
+	};
+
+	template <typename T>
+	inline type type_of() {
+		return lua_type_of<meta::unqualified_t<T>>::value;
+	}
+
+	namespace detail {
+		template <typename T>
+		struct is_non_factory_constructor : std::false_type { };
+
+		template <typename... Args>
+		struct is_non_factory_constructor<constructors<Args...>> : std::true_type { };
+
+		template <typename... Args>
+		struct is_non_factory_constructor<constructor_wrapper<Args...>> : std::true_type { };
+
+		template <>
+		struct is_non_factory_constructor<no_construction> : std::true_type { };
+
+		template <typename T>
+		inline constexpr bool is_non_factory_constructor_v = is_non_factory_constructor<T>::value;
+
+		template <typename T>
+		struct is_constructor : is_non_factory_constructor<T> { };
+
+		template <typename... Args>
+		struct is_constructor<factory_wrapper<Args...>> : std::true_type { };
+
+		template <typename T>
+		struct is_constructor<protect_t<T>> : is_constructor<meta::unqualified_t<T>> { };
+
+		template <typename F, typename... Policies>
+		struct is_constructor<policy_wrapper<F, Policies...>> : is_constructor<meta::unqualified_t<F>> { };
+
+		template <typename T>
+		inline constexpr bool is_constructor_v = is_constructor<T>::value;
+
+		template <typename... Args>
+		using any_is_constructor = meta::any<is_constructor<meta::unqualified_t<Args>>...>;
+
+		template <typename... Args>
+		inline constexpr bool any_is_constructor_v = any_is_constructor<Args...>::value;
+
+		template <typename T>
+		struct is_destructor : std::false_type { };
+
+		template <typename Fx>
+		struct is_destructor<destructor_wrapper<Fx>> : std::true_type { };
+
+		template <typename... Args>
+		using any_is_destructor = meta::any<is_destructor<meta::unqualified_t<Args>>...>;
+
+		template <typename... Args>
+		inline constexpr bool any_is_destructor_v = any_is_destructor<Args...>::value;
+	} // namespace detail
+
+	template <typename T>
+	using is_lua_c_function = meta::any<std::is_same<lua_CFunction, T>, std::is_same<detail::lua_CFunction_noexcept, T>, std::is_same<lua_CFunction_ref, T>>;
+
+	template <typename T>
+	inline constexpr bool is_lua_c_function_v = is_lua_c_function<T>::value;
+
+	enum class automagic_flags : unsigned {
+		none = 0x000u,
+		default_constructor = 0x001,
+		destructor = 0x002u,
+		pairs_operator = 0x004u,
+		to_string_operator = 0x008u,
+		call_operator = 0x010u,
+		less_than_operator = 0x020u,
+		less_than_or_equal_to_operator = 0x040u,
+		length_operator = 0x080u,
+		equal_to_operator = 0x100u,
+		all = default_constructor | destructor | pairs_operator | to_string_operator | call_operator | less_than_operator | less_than_or_equal_to_operator
+		     | length_operator | equal_to_operator
+	};
+
+	inline constexpr automagic_flags operator|(automagic_flags left, automagic_flags right) noexcept {
+		return static_cast<automagic_flags>(
+		     static_cast<std::underlying_type_t<automagic_flags>>(left) | static_cast<std::underlying_type_t<automagic_flags>>(right));
+	}
+
+	inline constexpr automagic_flags operator&(automagic_flags left, automagic_flags right) noexcept {
+		return static_cast<automagic_flags>(
+		     static_cast<std::underlying_type_t<automagic_flags>>(left) & static_cast<std::underlying_type_t<automagic_flags>>(right));
+	}
+
+	inline constexpr automagic_flags& operator|=(automagic_flags& left, automagic_flags right) noexcept {
+		left = left | right;
+		return left;
+	}
+
+	inline constexpr automagic_flags& operator&=(automagic_flags& left, automagic_flags right) noexcept {
+		left = left & right;
+		return left;
+	}
+
+	template <typename Left, typename Right>
+	constexpr bool has_flag(Left left, Right right) noexcept {
+		return (left & right) == right;
+	}
+
+	template <typename Left, typename Right>
+	constexpr bool has_any_flag(Left left, Right right) noexcept {
+		return (left & right) != static_cast<Left>(static_cast<std::underlying_type_t<Left>>(0));
+	}
+
+	template <typename Left, typename Right>
+	constexpr auto clear_flags(Left left, Right right) noexcept {
+		return static_cast<Left>(static_cast<std::underlying_type_t<Left>>(left) & ~static_cast<std::underlying_type_t<Right>>(right));
+	}
+
+	struct automagic_enrollments {
+		bool default_constructor = true;
+		bool destructor = true;
+		bool pairs_operator = true;
+		bool to_string_operator = true;
+		bool call_operator = true;
+		bool less_than_operator = true;
+		bool less_than_or_equal_to_operator = true;
+		bool length_operator = true;
+		bool equal_to_operator = true;
+	};
+
+	template <automagic_flags compile_time_defaults = automagic_flags::all>
+	struct constant_automagic_enrollments : public automagic_enrollments { };
+
+} // namespace sol
+
+// end of sol/types.hpp
+
+#include <exception>
+#include <cstring>
+
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+#include <iostream>
+#endif
+
+namespace sol {
+	// must push a single object to be the error object
+	// NOTE: the VAST MAJORITY of all Lua libraries -- C or otherwise -- expect a string for the type of error
+	// break this convention at your own risk
+	using exception_handler_function = int (*)(lua_State*, optional<const std::exception&>, string_view);
+
+	namespace detail {
+		inline const char (&default_exception_handler_name())[11] {
+			static const char name[11] = "sol.\xE2\x98\xA2\xE2\x98\xA2";
+			return name;
+		}
+
+		// must push at least 1 object on the stack
+		inline int default_exception_handler(lua_State* L, optional<const std::exception&>, string_view what) {
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+			std::cerr << "[sol2] An exception occurred: ";
+			std::cerr.write(what.data(), static_cast<std::streamsize>(what.size()));
+			std::cerr << std::endl;
+#endif
+			lua_pushlstring(L, what.data(), what.size());
+			return 1;
+		}
+
+		inline int call_exception_handler(lua_State* L, optional<const std::exception&> maybe_ex, string_view what) {
+			lua_getglobal(L, default_exception_handler_name());
+			type t = static_cast<type>(lua_type(L, -1));
+			if (t != type::lightuserdata) {
+				lua_pop(L, 1);
+				return default_exception_handler(L, std::move(maybe_ex), std::move(what));
+			}
+			void* vfunc = lua_touserdata(L, -1);
+			lua_pop(L, 1);
+			if (vfunc == nullptr) {
+				return default_exception_handler(L, std::move(maybe_ex), std::move(what));
+			}
+			exception_handler_function exfunc = reinterpret_cast<exception_handler_function>(vfunc);
+			return exfunc(L, std::move(maybe_ex), std::move(what));
+		}
+
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		template <lua_CFunction f>
+		int static_trampoline(lua_State* L) noexcept {
+			return f(L);
+		}
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		template <lua_CFunction_noexcept f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#else
+		template <lua_CFunction f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#endif
+
+		template <typename Fx, typename... Args>
+		int trampoline(lua_State* L, Fx&& f, Args&&... args) noexcept {
+			return f(L, std::forward<Args>(args)...);
+		}
+
+		inline int c_trampoline(lua_State* L, lua_CFunction f) noexcept {
+			return trampoline(L, f);
+		}
+#else
+
+		inline int lua_cfunction_trampoline(lua_State* L, lua_CFunction f) {
+#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS)
+			return f(L);
+#else
+			try {
+				return f(L);
+			}
+			catch (const char* cs) {
+				call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(cs));
+			}
+			catch (const std::string& s) {
+				call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(s.c_str(), s.size()));
+			}
+			catch (const std::exception& e) {
+				call_exception_handler(L, optional<const std::exception&>(e), e.what());
+			}
+#if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL)
+			// LuaJIT cannot have the catchall when the safe propagation is on
+			// but LuaJIT will swallow all C++ errors
+			// if we don't at least catch std::exception ones
+			catch (...) {
+				call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception");
+			}
+#endif // LuaJIT cannot have the catchall, but we must catch std::exceps for it
+			return lua_error(L);
+#endif // Safe exceptions
+		}
+
+		template <lua_CFunction f>
+		int static_trampoline(lua_State* L) {
+			return lua_cfunction_trampoline(L, f);
+		}
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		template <lua_CFunction_noexcept f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#else
+		template <lua_CFunction f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#endif
+
+		template <typename Fx, typename... Args>
+		int trampoline(lua_State* L, Fx&& f, Args&&... args) {
+			if constexpr (meta::bind_traits<meta::unqualified_t<Fx>>::is_noexcept) {
+				return f(L, std::forward<Args>(args)...);
+			}
+			else {
+#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS)
+				return f(L, std::forward<Args>(args)...);
+#else
+				try {
+					return f(L, std::forward<Args>(args)...);
+				}
+				catch (const char* cs) {
+					call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(cs));
+				}
+				catch (const std::string& s) {
+					call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(s.c_str(), s.size()));
+				}
+				catch (const std::exception& e) {
+					call_exception_handler(L, optional<const std::exception&>(e), e.what());
+				}
+#if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL)
+				// LuaJIT cannot have the catchall when the safe propagation is on
+				// but LuaJIT will swallow all C++ errors
+				// if we don't at least catch std::exception ones
+				catch (...) {
+					call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception");
+				}
+#endif
+				return lua_error(L);
+#endif
+			}
+		}
+
+		inline int c_trampoline(lua_State* L, lua_CFunction f) {
+			return trampoline(L, f);
+		}
+#endif // Exceptions vs. No Exceptions
+
+		template <typename F, F fx>
+		inline int typed_static_trampoline(lua_State* L) {
+#if 0
+			// TODO: you must evaluate the get/check_get of every
+			// argument, to ensure it doesn't throw
+			// (e.g., for the sol_lua_check_access extension point!)
+			// This incluudes properly noexcept-ing all the above
+			// trampolines / safety nets
+			if constexpr (meta::bind_traits<F>::is_noexcept) {
+				return static_trampoline_noexcept<fx>(L);
+			}
+			else
+#endif
+			{ return static_trampoline<fx>(L); }
+		}
+	} // namespace detail
+
+	inline void set_default_exception_handler(lua_State* L, exception_handler_function exf = &detail::default_exception_handler) {
+		static_assert(sizeof(void*) >= sizeof(exception_handler_function),
+		     "void* storage is too small to transport the exception handler: please file a bug on the sol2 issue tracker to get this looked at!");
+		void* storage;
+		std::memcpy(&storage, &exf, sizeof(exception_handler_function));
+		lua_pushlightuserdata(L, storage);
+		lua_setglobal(L, detail::default_exception_handler_name());
+	}
+} // namespace sol
+
+// end of sol/trampoline.hpp
+
+// beginning of sol/stack_core.hpp
+
+// beginning of sol/inheritance.hpp
+
+// beginning of sol/usertype_traits.hpp
+
+// beginning of sol/demangle.hpp
+
+#include <string>
+#include <array>
+#include <cctype>
+#if SOL_IS_ON(SOL_MINGW_CCTYPE_IS_POISONED)
+extern "C" {
+#include <ctype.h>
+}
+#endif // MinGW is on some stuff
+#include <locale>
+
+namespace sol { namespace detail {
+	inline constexpr std::array<string_view, 9> removals { { "{anonymous}",
+		"(anonymous namespace)",
+		"public:",
+		"private:",
+		"protected:",
+		"struct ",
+		"class ",
+		"`anonymous-namespace'",
+		"`anonymous namespace'" } };
+
+#if SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+	inline std::string ctti_get_type_name_from_sig(std::string name) {
+		// cardinal sins from MINGW
+		using namespace std;
+		std::size_t start = name.find_first_of('[');
+		start = name.find_first_of('=', start);
+		std::size_t end = name.find_last_of(']');
+		if (end == std::string::npos)
+			end = name.size();
+		if (start == std::string::npos)
+			start = 0;
+		if (start < name.size() - 1)
+			start += 1;
+		name = name.substr(start, end - start);
+		start = name.rfind("seperator_mark");
+		if (start != std::string::npos) {
+			name.erase(start - 2, name.length());
+		}
+		while (!name.empty() && isblank(name.front()))
+			name.erase(name.begin());
+		while (!name.empty() && isblank(name.back()))
+			name.pop_back();
+
+		for (std::size_t r = 0; r < removals.size(); ++r) {
+			auto found = name.find(removals[r]);
+			while (found != std::string::npos) {
+				name.erase(found, removals[r].size());
+				found = name.find(removals[r]);
+			}
+		}
+
+		return name;
+	}
+
+	template <typename T, class seperator_mark = int>
+	inline std::string ctti_get_type_name() {
+		return ctti_get_type_name_from_sig(__PRETTY_FUNCTION__);
+	}
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	inline std::string ctti_get_type_name_from_sig(std::string name) {
+		std::size_t start = name.find("get_type_name");
+		if (start == std::string::npos)
+			start = 0;
+		else
+			start += 13;
+		if (start < name.size() - 1)
+			start += 1;
+		std::size_t end = name.find_last_of('>');
+		if (end == std::string::npos)
+			end = name.size();
+		name = name.substr(start, end - start);
+		if (name.find("struct", 0) == 0)
+			name.replace(0, 6, "", 0);
+		if (name.find("class", 0) == 0)
+			name.replace(0, 5, "", 0);
+		while (!name.empty() && isblank(name.front()))
+			name.erase(name.begin());
+		while (!name.empty() && isblank(name.back()))
+			name.pop_back();
+
+		for (std::size_t r = 0; r < removals.size(); ++r) {
+			auto found = name.find(removals[r]);
+			while (found != std::string::npos) {
+				name.erase(found, removals[r].size());
+				found = name.find(removals[r]);
+			}
+		}
+
+		return name;
+	}
+
+	template <typename T>
+	std::string ctti_get_type_name() {
+		return ctti_get_type_name_from_sig(__FUNCSIG__);
+	}
+#else
+#error Compiler not supported for demangling
+#endif // compilers
+
+	template <typename T>
+	std::string demangle_once() {
+		std::string realname = ctti_get_type_name<T>();
+		return realname;
+	}
+
+	inline std::string short_demangle_from_type_name(std::string realname) {
+		// This isn't the most complete but it'll do for now...?
+		static const std::array<std::string, 10> ops = {
+			{ "operator<", "operator<<", "operator<<=", "operator<=", "operator>", "operator>>", "operator>>=", "operator>=", "operator->", "operator->*" }
+		};
+		int level = 0;
+		std::size_t idx = 0;
+		for (idx = static_cast<std::size_t>(realname.empty() ? 0 : realname.size() - 1); idx > 0; --idx) {
+			if (level == 0 && realname[idx] == ':') {
+				break;
+			}
+			bool isleft = realname[idx] == '<';
+			bool isright = realname[idx] == '>';
+			if (!isleft && !isright)
+				continue;
+			bool earlybreak = false;
+			for (const auto& op : ops) {
+				std::size_t nisop = realname.rfind(op, idx);
+				if (nisop == std::string::npos)
+					continue;
+				std::size_t nisopidx = idx - op.size() + 1;
+				if (nisop == nisopidx) {
+					idx = static_cast<std::size_t>(nisopidx);
+					earlybreak = true;
+				}
+				break;
+			}
+			if (earlybreak) {
+				continue;
+			}
+			level += isleft ? -1 : 1;
+		}
+		if (idx > 0) {
+			realname.erase(0, realname.length() < static_cast<std::size_t>(idx) ? realname.length() : idx + 1);
+		}
+		return realname;
+	}
+
+	template <typename T>
+	std::string short_demangle_once() {
+		std::string realname = ctti_get_type_name<T>();
+		return short_demangle_from_type_name(realname);
+	}
+
+	template <typename T>
+	const std::string& demangle() {
+		static const std::string d = demangle_once<T>();
+		return d;
+	}
+
+	template <typename T>
+	const std::string& short_demangle() {
+		static const std::string d = short_demangle_once<T>();
+		return d;
+	}
+}} // namespace sol::detail
+
+// end of sol/demangle.hpp
+
+namespace sol {
+
+	template <typename T>
+	struct usertype_traits {
+		static const std::string& name() {
+			static const std::string& n = detail::short_demangle<T>();
+			return n;
+		}
+		static const std::string& qualified_name() {
+			static const std::string& q_n = detail::demangle<T>();
+			return q_n;
+		}
+		static const std::string& metatable() {
+			static const std::string m = std::string("sol.").append(detail::demangle<T>());
+			return m;
+		}
+		static const std::string& user_metatable() {
+			static const std::string u_m = std::string("sol.").append(detail::demangle<T>()).append(".user");
+			return u_m;
+		}
+		static const std::string& user_gc_metatable() {
+			static const std::string u_g_m = std::string("sol.").append(detail::demangle<T>()).append(".user\xE2\x99\xBB");
+			return u_g_m;
+		}
+		static const std::string& gc_table() {
+			static const std::string g_t = std::string("sol.").append(detail::demangle<T>()).append(".\xE2\x99\xBB");
+			return g_t;
+		}
+	};
+
+} // namespace sol
+
+// end of sol/usertype_traits.hpp
+
+// beginning of sol/unique_usertype_traits.hpp
+
+#include <memory>
+
+namespace sol {
+
+	namespace detail {
+		template <typename T>
+		struct unique_fallback {
+			using SOL_INTERNAL_UNSPECIALIZED_MARKER_ = int;
+		};
+
+		template <typename T>
+		struct unique_fallback<std::shared_ptr<T>> {
+		private:
+			using pointer = typename std::pointer_traits<std::shared_ptr<T>>::element_type*;
+
+		public:
+			// rebind is non-void
+			// if and only if unique usertype
+			// is cast-capable
+			template <typename X>
+			using rebind_actual_type = std::shared_ptr<X>;
+
+			static bool is_null(lua_State*, const std::shared_ptr<T>& p) noexcept {
+				return p == nullptr;
+			}
+
+			static pointer get(lua_State*, const std::shared_ptr<T>& p) noexcept {
+				return p.get();
+			}
+		};
+
+		template <typename T, typename D>
+		struct unique_fallback<std::unique_ptr<T, D>> {
+		private:
+			using pointer = typename std::unique_ptr<T, D>::pointer;
+
+		public:
+			static bool is_null(lua_State*, const std::unique_ptr<T, D>& p) noexcept {
+				return p == nullptr;
+			}
+
+			static pointer get(lua_State*, const std::unique_ptr<T, D>& p) noexcept {
+				return p.get();
+			}
+		};
+	} // namespace detail
+
+	namespace meta { namespace meta_detail {
+		template <typename T, typename = void>
+		struct unique_actual_type;
+
+		template <typename T>
+		struct unique_actual_type<T, meta::void_t<typename T::actual_type>> {
+			using type = typename T::actual_type;
+		};
+
+		template <typename T, typename... Rest, template <typename...> class Templ>
+		struct unique_actual_type<Templ<T, Rest...>> {
+			using type = T;
+		};
+
+	}} // namespace meta::meta_detail
+
+	template <typename T>
+	using unique_usertype_actual_t = typename meta::meta_detail::unique_actual_type<unique_usertype_traits<T>>::type;
+
+	namespace meta { namespace meta_detail {
+		template <typename T>
+		using value_test_t = decltype(T::value);
+
+		template <typename T>
+		using type_test_t = typename T::type;
+
+		template <typename T>
+		using type_element_type_t = typename T::element_type;
+
+		template <typename T, typename = void>
+		struct unique_element_type {
+			using type = typename std::pointer_traits<typename unique_actual_type<T>::type>::element_type;
+		};
+
+		template <typename T>
+		struct unique_element_type<T, std::enable_if_t<meta::is_detected_v<type_element_type_t, T>>> {
+			using type = typename T::element_type;
+		};
+
+		template <typename T>
+		struct unique_element_type<T, std::enable_if_t<meta::is_detected_v<type_test_t, T>>> {
+			using type = typename T::type;
+		};
+
+		template <typename T, typename = void>
+		struct unique_valid : std::integral_constant<bool, !has_internal_marker_v<T>> { };
+
+		template <typename T>
+		struct unique_valid<T, meta::void_t<decltype(T::value)>> : std::integral_constant<bool, T::value> { };
+	}} // namespace meta::meta_detail
+
+	template <typename T>
+	using unique_usertype_element_t = typename meta::meta_detail::unique_element_type<unique_usertype_traits<T>>::type;
+
+	template <typename T, typename Element = void>
+	using unique_usertype_rebind_actual_t = typename unique_usertype_traits<T>::template rebind_actual_type<Element>;
+
+	template <typename T>
+	struct unique_usertype_traits : public detail::unique_fallback<T> { };
+
+	template <typename T>
+	struct is_unique_usertype : std::integral_constant<bool, meta::meta_detail::unique_valid<unique_usertype_traits<T>>::value> { };
+
+	template <typename T>
+	inline constexpr bool is_unique_usertype_v = is_unique_usertype<T>::value;
+
+	namespace meta { namespace meta_detail {
+		template <typename T>
+		using adl_sol_lua_check_access_test_t
+			= decltype(sol_lua_check_access(types<T>(), static_cast<lua_State*>(nullptr), -1, std::declval<stack::record&>()));
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_check_access_v = meta::is_detected_v<adl_sol_lua_check_access_test_t, T>;
+
+		template <typename T>
+		using unique_usertype_get_with_state_test_t
+			= decltype(unique_usertype_traits<T>::get(static_cast<lua_State*>(nullptr), std::declval<unique_usertype_actual_t<T>>()));
+
+		template <typename T>
+		inline constexpr bool unique_usertype_get_with_state_v = meta::is_detected_v<unique_usertype_get_with_state_test_t, T>;
+
+		template <typename T>
+		using unique_usertype_is_null_with_state_test_t
+			= decltype(unique_usertype_traits<T>::is_null(static_cast<lua_State*>(nullptr), std::declval<unique_usertype_actual_t<T>>()));
+
+		template <typename T>
+		inline constexpr bool unique_usertype_is_null_with_state_v = meta::is_detected_v<unique_usertype_is_null_with_state_test_t, T>;
+	}} // namespace meta::meta_detail
+
+	namespace detail {
+		template <typename T>
+		constexpr bool unique_is_null_noexcept() noexcept {
+			if constexpr (meta::meta_detail::unique_usertype_is_null_with_state_v<std::remove_cv_t<T>>) {
+				return noexcept(
+				     unique_usertype_traits<T>::is_null(static_cast<lua_State*>(nullptr), std::declval<unique_usertype_actual_t<std::remove_cv_t<T>>>()));
+			}
+			else {
+				return noexcept(unique_usertype_traits<T>::is_null(std::declval<unique_usertype_actual_t<std::remove_cv_t<T>>>()));
+			}
+		}
+
+		template <typename T>
+		bool unique_is_null(lua_State* L_, T& value_) noexcept(unique_is_null_noexcept<std::remove_cv_t<T>>()) {
+			using Tu = std::remove_cv_t<T>;
+			if constexpr (meta::meta_detail::unique_usertype_is_null_with_state_v<Tu>) {
+				return unique_usertype_traits<Tu>::is_null(L_, value_);
+			}
+			else {
+				return unique_usertype_traits<Tu>::is_null(value_);
+			}
+		}
+
+		template <typename T>
+		constexpr bool unique_get_noexcept() noexcept {
+			if constexpr (meta::meta_detail::unique_usertype_get_with_state_v<std::remove_cv_t<T>>) {
+				return noexcept(
+				     unique_usertype_traits<T>::get(static_cast<lua_State*>(nullptr), std::declval<unique_usertype_actual_t<std::remove_cv_t<T>>>()));
+			}
+			else {
+				return noexcept(unique_usertype_traits<T>::get(std::declval<unique_usertype_actual_t<std::remove_cv_t<T>>>()));
+			}
+		}
+
+		template <typename T>
+		auto unique_get(lua_State* L_, T& value_) noexcept(unique_get_noexcept<std::remove_cv_t<T>>()) {
+			using Tu = std::remove_cv_t<T>;
+			if constexpr (meta::meta_detail::unique_usertype_get_with_state_v<Tu>) {
+				return unique_usertype_traits<Tu>::get(L_, value_);
+			}
+			else {
+				return unique_usertype_traits<Tu>::get(value_);
+			}
+		}
+	} // namespace detail
+
+	namespace meta { namespace meta_detail {
+		template <typename T, typename Element = void>
+		using is_rebind_actual_type_test_t = typename T::template rebind_actual_type<Element>;
+
+		template <typename T, typename Element = void>
+		using is_rebind_actual_type = meta::is_detected<is_rebind_actual_type_test_t, T, Element>;
+
+		template <typename T, typename Element = void>
+		inline constexpr bool is_rebind_actual_type_v = is_rebind_actual_type<T, Element>::value;
+
+		template <typename T, typename Element, bool = is_rebind_actual_type_v<T, Element>>
+		struct is_actual_type_rebindable_for_test : std::false_type { };
+
+		template <typename T, typename Element>
+		struct is_actual_type_rebindable_for_test<T, Element, true>
+		: std::integral_constant<bool, !std::is_void_v<typename T::template rebind_actual_type<Element>>> { };
+	}} // namespace meta::meta_detail
+
+	template <typename T, typename Element = void>
+	using is_actual_type_rebindable_for = typename meta::meta_detail::is_actual_type_rebindable_for_test<unique_usertype_traits<T>, Element>::type;
+
+	template <typename T, typename Element = void>
+	inline constexpr bool is_actual_type_rebindable_for_v = is_actual_type_rebindable_for<T, Element>::value;
+
+} // namespace sol
+
+// end of sol/unique_usertype_traits.hpp
+
+namespace sol {
+	template <typename... Args>
+	struct base_list { };
+	template <typename... Args>
+	using bases = base_list<Args...>;
+
+	typedef bases<> base_classes_tag;
+	const auto base_classes = base_classes_tag();
+
+	template <typename... Args>
+	struct is_to_stringable<base_list<Args...>> : std::false_type { };
+
+	namespace detail {
+
+		inline decltype(auto) base_class_check_key() {
+			static const auto& key = "class_check";
+			return key;
+		}
+
+		inline decltype(auto) base_class_cast_key() {
+			static const auto& key = "class_cast";
+			return key;
+		}
+
+		inline decltype(auto) base_class_index_propogation_key() {
+			static const auto& key = u8"\xF0\x9F\x8C\xB2.index";
+			return key;
+		}
+
+		inline decltype(auto) base_class_new_index_propogation_key() {
+			static const auto& key = u8"\xF0\x9F\x8C\xB2.new_index";
+			return key;
+		}
+
+		template <typename T>
+		struct inheritance {
+			typedef typename base<T>::type bases_t;
+
+			static bool type_check_bases(types<>, const string_view&) {
+				return false;
+			}
+
+			template <typename Base, typename... Args>
+			static bool type_check_bases(types<Base, Args...>, const string_view& ti) {
+				return ti == usertype_traits<Base>::qualified_name() || type_check_bases(types<Args...>(), ti);
+			}
+
+			static bool type_check(const string_view& ti) {
+				return ti == usertype_traits<T>::qualified_name() || type_check_bases(bases_t(), ti);
+			}
+
+			template <typename... Bases>
+			static bool type_check_with(const string_view& ti) {
+				return ti == usertype_traits<T>::qualified_name() || type_check_bases(types<Bases...>(), ti);
+			}
+
+			static void* type_cast_bases(types<>, T*, const string_view&) {
+				return nullptr;
+			}
+
+			template <typename Base, typename... Args>
+			static void* type_cast_bases(types<Base, Args...>, T* data, const string_view& ti) {
+				// Make sure to convert to T first, and then dynamic cast to the proper type
+				return ti != usertype_traits<Base>::qualified_name() ? type_cast_bases(types<Args...>(), data, ti)
+				                                                     : static_cast<void*>(static_cast<Base*>(data));
+			}
+
+			static void* type_cast(void* voiddata, const string_view& ti) {
+				T* data = static_cast<T*>(voiddata);
+				return static_cast<void*>(ti != usertype_traits<T>::qualified_name() ? type_cast_bases(bases_t(), data, ti) : data);
+			}
+
+			template <typename... Bases>
+			static void* type_cast_with(void* voiddata, const string_view& ti) {
+				T* data = static_cast<T*>(voiddata);
+				return static_cast<void*>(ti != usertype_traits<T>::qualified_name() ? type_cast_bases(types<Bases...>(), data, ti) : data);
+			}
+
+			template <typename U>
+			static bool type_unique_cast_bases(types<>, void*, void*, const string_view&) {
+				return 0;
+			}
+
+			template <typename U, typename Base, typename... Args>
+			static int type_unique_cast_bases(types<Base, Args...>, void* source_data, void* target_data, const string_view& ti) {
+				using uu_traits = unique_usertype_traits<U>;
+				using base_ptr = typename uu_traits::template rebind_actual_type<Base>;
+				string_view base_ti = usertype_traits<Base>::qualified_name();
+				if (base_ti == ti) {
+					if (target_data != nullptr) {
+						U* source = static_cast<U*>(source_data);
+						base_ptr* target = static_cast<base_ptr*>(target_data);
+						// perform proper derived -> base conversion
+						*target = *source;
+					}
+					return 2;
+				}
+				return type_unique_cast_bases<U>(types<Args...>(), source_data, target_data, ti);
+			}
+
+			template <typename U>
+			static int type_unique_cast(void* source_data, void* target_data, const string_view& ti, const string_view& rebind_ti) {
+				if constexpr (is_actual_type_rebindable_for_v<U>) {
+					using rebound_actual_type = unique_usertype_rebind_actual_t<U>;
+					using maybe_bases_or_empty = meta::conditional_t<std::is_void_v<rebound_actual_type>, types<>, bases_t>;
+					string_view this_rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+					if (rebind_ti != this_rebind_ti) {
+						// this is not even of the same unique type
+						return 0;
+					}
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(maybe_bases_or_empty(), source_data, target_data, ti);
+				}
+				else {
+					(void)rebind_ti;
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(types<>(), source_data, target_data, ti);
+				}
+			}
+
+			template <typename U, typename... Bases>
+			static int type_unique_cast_with(void* source_data, void* target_data, const string_view& ti, const string_view& rebind_ti) {
+				using uc_bases_t = types<Bases...>;
+				if constexpr (is_actual_type_rebindable_for_v<U>) {
+					using rebound_actual_type = unique_usertype_rebind_actual_t<U>;
+					using cond_bases_t = meta::conditional_t<std::is_void_v<rebound_actual_type>, types<>, uc_bases_t>;
+					string_view this_rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+					if (rebind_ti != this_rebind_ti) {
+						// this is not even of the same unique type
+						return 0;
+					}
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(cond_bases_t(), source_data, target_data, ti);
+				}
+				else {
+					(void)rebind_ti;
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(types<>(), source_data, target_data, ti);
+				}
+			}
+		};
+
+		using inheritance_check_function = decltype(&inheritance<void>::type_check);
+		using inheritance_cast_function = decltype(&inheritance<void>::type_cast);
+		using inheritance_unique_cast_function = decltype(&inheritance<void>::type_unique_cast<void>);
+	} // namespace detail
+} // namespace sol
+
+// end of sol/inheritance.hpp
+
+// beginning of sol/error_handler.hpp
+
+#include <cstdio>
+
+namespace sol {
+
+	namespace detail {
+		constexpr const char* not_a_number = "not a numeric type";
+		constexpr const char* not_a_number_or_number_string = "not a numeric type or numeric string";
+		constexpr const char* not_a_number_integral = "not a numeric type that fits exactly an integer (number maybe has significant decimals)";
+		constexpr const char* not_a_number_or_number_string_integral
+		     = "not a numeric type or a numeric string that fits exactly an integer (e.g. number maybe has significant decimals)";
+
+		constexpr const char* not_enough_stack_space = "not enough space left on Lua stack";
+		constexpr const char* not_enough_stack_space_floating = "not enough space left on Lua stack for a floating point number";
+		constexpr const char* not_enough_stack_space_integral = "not enough space left on Lua stack for an integral number";
+		constexpr const char* not_enough_stack_space_string = "not enough space left on Lua stack for a string";
+		constexpr const char* not_enough_stack_space_meta_function_name = "not enough space left on Lua stack for the name of a meta_function";
+		constexpr const char* not_enough_stack_space_userdata = "not enough space left on Lua stack to create a sol2 userdata";
+		constexpr const char* not_enough_stack_space_generic = "not enough space left on Lua stack to push valuees";
+		constexpr const char* not_enough_stack_space_environment = "not enough space left on Lua stack to retrieve environment";
+		constexpr const char* protected_function_error = "caught (...) unknown error during protected_function call";
+
+		inline void accumulate_and_mark(const std::string& n, std::string& aux_message, int& marker) {
+			if (marker > 0) {
+				aux_message += ", ";
+			}
+			aux_message += n;
+			++marker;
+		}
+	} // namespace detail
+
+	inline std::string associated_type_name(lua_State* L, int index, type t) {
+		switch (t) {
+		case type::poly:
+			return "anything";
+		case type::userdata: {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 2, "not enough space to push get the type name");
+#endif // make sure stack doesn't overflow
+			if (lua_getmetatable(L, index) == 0) {
+				break;
+			}
+			lua_pushlstring(L, "__name", 6);
+			lua_rawget(L, -2);
+			size_t sz;
+			const char* name = lua_tolstring(L, -1, &sz);
+			std::string tn(name, static_cast<std::string::size_type>(sz));
+			lua_pop(L, 2);
+			return tn;
+		}
+		default:
+			break;
+		}
+		return lua_typename(L, static_cast<int>(t));
+	}
+
+	inline int push_type_panic_string(lua_State* L, int index, type expected, type actual, string_view message, string_view aux_message) noexcept {
+		const char* err = message.size() == 0
+		     ? (aux_message.size() == 0 ? "stack index %d, expected %s, received %s" : "stack index %d, expected %s, received %s: %s")
+		     : "stack index %d, expected %s, received %s: %s %s";
+		const char* type_name = expected == type::poly ? "anything" : lua_typename(L, static_cast<int>(expected));
+		{
+			std::string actual_name = associated_type_name(L, index, actual);
+			lua_pushfstring(L, err, index, type_name, actual_name.c_str(), message.data(), aux_message.data());
+		}
+		return 1;
+	}
+
+	inline int type_panic_string(lua_State* L, int index, type expected, type actual, string_view message = "") noexcept(false) {
+		push_type_panic_string(L, index, expected, actual, message, "");
+		return lua_error(L);
+	}
+
+	inline int type_panic_c_str(lua_State* L, int index, type expected, type actual, const char* message = nullptr) noexcept(false) {
+		push_type_panic_string(L, index, expected, actual, message == nullptr ? "" : message, "");
+		return lua_error(L);
+	}
+
+	struct type_panic_t {
+		int operator()(lua_State* L, int index, type expected, type actual) const noexcept(false) {
+			return type_panic_c_str(L, index, expected, actual, nullptr);
+		}
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			return type_panic_c_str(L, index, expected, actual, message.data());
+		}
+	};
+
+	const type_panic_t type_panic = {};
+
+	struct constructor_handler {
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			push_type_panic_string(L, index, expected, actual, message, "(type check failed in constructor)");
+			return lua_error(L);
+		}
+	};
+
+	template <typename F = void>
+	struct argument_handler {
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			push_type_panic_string(L, index, expected, actual, message, "(bad argument to variable or function call)");
+			return lua_error(L);
+		}
+	};
+
+	template <typename R, typename... Args>
+	struct argument_handler<types<R, Args...>> {
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			{
+				std::string aux_message = "(bad argument into '";
+				aux_message += detail::demangle<R>();
+				aux_message += "(";
+				int marker = 0;
+				(void)detail::swallow { int(), (detail::accumulate_and_mark(detail::demangle<Args>(), aux_message, marker), int())... };
+				aux_message += ")')";
+				push_type_panic_string(L, index, expected, actual, message, aux_message);
+			}
+			return lua_error(L);
+		}
+	};
+
+	// Specify this function as the handler for lua::check if you know there's nothing wrong
+	inline int no_panic(lua_State*, int, type, type, const char* = nullptr) noexcept {
+		return 0;
+	}
+
+	inline void type_error(lua_State* L, int expected, int actual) noexcept(false) {
+		luaL_error(L, "expected %s, received %s", lua_typename(L, expected), lua_typename(L, actual));
+	}
+
+	inline void type_error(lua_State* L, type expected, type actual) noexcept(false) {
+		type_error(L, static_cast<int>(expected), static_cast<int>(actual));
+	}
+
+	inline void type_assert(lua_State* L, int index, type expected, type actual) noexcept(false) {
+		if (expected != type::poly && expected != actual) {
+			type_panic_c_str(L, index, expected, actual, nullptr);
+		}
+	}
+
+	inline void type_assert(lua_State* L, int index, type expected) {
+		type actual = type_of(L, index);
+		type_assert(L, index, expected, actual);
+	}
+
+} // namespace sol
+
+// end of sol/error_handler.hpp
+
+// beginning of sol/reference.hpp
+
+// beginning of sol/stack_reference.hpp
+
+namespace sol {
+	namespace detail {
+		inline bool xmovable(lua_State* leftL, lua_State* rightL) {
+			if (rightL == nullptr || leftL == nullptr || leftL == rightL) {
+				return false;
+			}
+			const void* leftregistry = lua_topointer(leftL, LUA_REGISTRYINDEX);
+			const void* rightregistry = lua_topointer(rightL, LUA_REGISTRYINDEX);
+			return leftregistry == rightregistry;
+		}
+	} // namespace detail
+
+	class stateless_stack_reference {
+	private:
+		friend class stack_reference;
+
+		int m_index = 0;
+
+		int registry_index() const noexcept {
+			return LUA_NOREF;
+		}
+
+	public:
+		stateless_stack_reference() noexcept = default;
+		stateless_stack_reference(lua_nil_t) noexcept : stateless_stack_reference() {};
+		stateless_stack_reference(lua_State* L_, int index_) noexcept : stateless_stack_reference(absolute_index(L_, index_)) {
+		}
+		stateless_stack_reference(lua_State*, absolute_index index_) noexcept : stateless_stack_reference(index_) {
+		}
+		stateless_stack_reference(lua_State*, raw_index index_) noexcept : stateless_stack_reference(index_) {
+		}
+		stateless_stack_reference(absolute_index index_) noexcept : m_index(index_) {
+		}
+		stateless_stack_reference(raw_index index_) noexcept : m_index(index_) {
+		}
+		stateless_stack_reference(lua_State*, ref_index) noexcept = delete;
+		stateless_stack_reference(ref_index) noexcept = delete;
+		stateless_stack_reference(const reference&) noexcept = delete;
+		stateless_stack_reference(const stateless_stack_reference&) noexcept = default;
+		stateless_stack_reference(stateless_stack_reference&& o) noexcept = default;
+		stateless_stack_reference& operator=(stateless_stack_reference&&) noexcept = default;
+		stateless_stack_reference& operator=(const stateless_stack_reference&) noexcept = default;
+
+		int push(lua_State* L_) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push a single reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L_, m_index);
+			return 1;
+		}
+
+		void pop(lua_State* L_, int pop_count = 1) const noexcept {
+			lua_pop(L_, pop_count);
+		}
+
+		int stack_index() const noexcept {
+			return m_index;
+		}
+
+		const void* pointer(lua_State* L_) const noexcept {
+			const void* pointer_id = lua_topointer(L_, stack_index());
+			return pointer_id;
+		}
+
+		type get_type(lua_State* L_) const noexcept {
+			int untyped_value = lua_type(L_, stack_index());
+			return static_cast<type>(untyped_value);
+		}
+
+		bool valid(lua_State* L) const noexcept {
+			type t = get_type(L);
+			return t != type::lua_nil && t != type::none;
+		}
+
+		void reset(lua_State*) noexcept {
+			m_index = 0;
+		}
+
+		void reset(lua_State* L_, int index_) noexcept {
+			m_index = absolute_index(L_, index_);
+		}
+
+		void abandon(lua_State* = nullptr) noexcept {
+			m_index = 0;
+		}
+
+		stateless_stack_reference copy(lua_State* L_) const noexcept {
+			return stateless_stack_reference(L_, raw_index(m_index));
+		}
+
+		void copy_assign(lua_State*, const stateless_stack_reference& right) noexcept {
+			m_index = right.m_index;
+		}
+
+		bool equals(lua_State* L_, const stateless_stack_reference& r) const noexcept {
+			return lua_compare(L_, this->stack_index(), r.stack_index(), LUA_OPEQ) == 1;
+		}
+
+		bool equals(lua_State* L_, lua_nil_t) const noexcept {
+			return valid(L_);
+		}
+	};
+
+	class stack_reference : public stateless_stack_reference {
+	private:
+		lua_State* luastate = nullptr;
+
+	public:
+		stack_reference() noexcept = default;
+		stack_reference(lua_nil_t) noexcept : stack_reference() {};
+		stack_reference(lua_State* L, lua_nil_t) noexcept : stateless_stack_reference(L, 0), luastate(L) {
+		}
+		stack_reference(lua_State* L, int i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+		}
+		stack_reference(lua_State* L, absolute_index i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+		}
+		stack_reference(lua_State* L, raw_index i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+		}
+		stack_reference(lua_State* L, ref_index i) noexcept = delete;
+		stack_reference(lua_State* L, const reference& r) noexcept = delete;
+		stack_reference(lua_State* L, const stack_reference& r) noexcept : luastate(L) {
+			if (!r.valid()) {
+				m_index = 0;
+				return;
+			}
+			int i = r.stack_index();
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, "not enough Lua stack space to push a single reference value");
+#endif // make sure stack doesn't overflow
+				lua_pushvalue(r.lua_state(), r.stack_index());
+				lua_xmove(r.lua_state(), luastate, 1);
+				i = absolute_index(luastate, -1);
+			}
+			m_index = i;
+		}
+		stack_reference(stack_reference&& o) noexcept = default;
+		stack_reference& operator=(stack_reference&&) noexcept = default;
+		stack_reference(const stack_reference&) noexcept = default;
+		stack_reference& operator=(const stack_reference&) noexcept = default;
+
+		int push() const noexcept {
+			return push(lua_state());
+		}
+
+		int push(lua_State* L_) const noexcept {
+			return stateless_stack_reference::push(L_);
+		}
+
+		void pop() const noexcept {
+			pop(lua_state());
+		}
+
+		void pop(lua_State* L_, int pop_count_ = 1) const noexcept {
+			stateless_stack_reference::pop(L_, pop_count_);
+		}
+
+		const void* pointer() const noexcept {
+			return stateless_stack_reference::pointer(lua_state());
+		}
+
+		type get_type() const noexcept {
+			return stateless_stack_reference::get_type(lua_state());
+		}
+
+		lua_State* lua_state() const noexcept {
+			return luastate;
+		}
+
+		bool valid() const noexcept {
+			return stateless_stack_reference::valid(lua_state());
+		}
+
+		void abandon() {
+			stateless_stack_reference::abandon(lua_state());
+		}
+	};
+
+	inline bool operator==(const stack_reference& l, const stack_reference& r) {
+		return lua_compare(l.lua_state(), l.stack_index(), r.stack_index(), LUA_OPEQ) == 1;
+	}
+
+	inline bool operator!=(const stack_reference& l, const stack_reference& r) {
+		return !operator==(l, r);
+	}
+
+	inline bool operator==(const stack_reference& lhs, const lua_nil_t&) {
+		return !lhs.valid();
+	}
+
+	inline bool operator==(const lua_nil_t&, const stack_reference& rhs) {
+		return !rhs.valid();
+	}
+
+	inline bool operator!=(const stack_reference& lhs, const lua_nil_t&) {
+		return lhs.valid();
+	}
+
+	inline bool operator!=(const lua_nil_t&, const stack_reference& rhs) {
+		return rhs.valid();
+	}
+
+	inline bool operator==(const stateless_stack_reference& l, const stateless_stack_reference& r) {
+		return l.stack_index() == r.stack_index();
+	}
+
+	inline bool operator!=(const stateless_stack_reference& l, const stateless_stack_reference& r) {
+		return l.stack_index() != r.stack_index();
+	}
+
+	struct stateless_stack_reference_equals {
+		using is_transparent = std::true_type;
+
+		stateless_stack_reference_equals(lua_State* L_) noexcept : m_L(L_) {
+		}
+
+		lua_State* lua_state() const noexcept {
+			return m_L;
+		}
+
+		bool operator()(const stateless_stack_reference& lhs, const stateless_stack_reference& rhs) const {
+			return lhs.equals(lua_state(), rhs);
+		}
+
+		bool operator()(lua_nil_t lhs, const stateless_stack_reference& rhs) const {
+			return rhs.equals(lua_state(), lhs);
+		}
+
+		bool operator()(const stateless_stack_reference& lhs, lua_nil_t rhs) const {
+			return lhs.equals(lua_state(), rhs);
+		}
+
+	private:
+		lua_State* m_L;
+	};
+
+	struct stack_reference_equals {
+		using is_transparent = std::true_type;
+
+		bool operator()(const lua_nil_t& lhs, const stack_reference& rhs) const {
+			return lhs == rhs;
+		}
+
+		bool operator()(const stack_reference& lhs, const lua_nil_t& rhs) const {
+			return lhs == rhs;
+		}
+
+		bool operator()(const stack_reference& lhs, const stack_reference& rhs) const {
+			return lhs == rhs;
+		}
+	};
+
+	struct stateless_stack_reference_hash {
+		using argument_type = stateless_stack_reference;
+		using result_type = std::size_t;
+		using is_transparent = std::true_type;
+
+		stateless_stack_reference_hash(lua_State* L_) noexcept : m_L(L_) {
+		}
+
+		lua_State* lua_state() const noexcept {
+			return m_L;
+		}
+
+		result_type operator()(const argument_type& lhs) const noexcept {
+			std::hash<const void*> h;
+			return h(lhs.pointer(lua_state()));
+		}
+
+	private:
+		lua_State* m_L;
+	};
+
+	struct stack_reference_hash {
+		using argument_type = stack_reference;
+		using result_type = std::size_t;
+		using is_transparent = std::true_type;
+
+		result_type operator()(const argument_type& lhs) const noexcept {
+			std::hash<const void*> h;
+			return h(lhs.pointer());
+		}
+	};
+} // namespace sol
+
+// end of sol/stack_reference.hpp
+
+#include <functional>
+
+namespace sol {
+	namespace detail {
+		inline const char (&default_main_thread_name())[9] {
+			static const char name[9] = "sol.\xF0\x9F\x93\x8C";
+			return name;
+		}
+	} // namespace detail
+
+	namespace stack {
+		inline void remove(lua_State* L_, int rawindex, int count) {
+			if (count < 1)
+				return;
+			int top = lua_gettop(L_);
+			if (top < 1) {
+				return;
+			}
+			if (rawindex == -count || top == rawindex) {
+				// Slice them right off the top
+				lua_pop(L_, static_cast<int>(count));
+				return;
+			}
+
+			// Remove each item one at a time using stack operations
+			// Probably slower, maybe, haven't benchmarked,
+			// but necessary
+			int index = lua_absindex(L_, rawindex);
+			if (index < 0) {
+				index = lua_gettop(L_) + (index + 1);
+			}
+			int last = index + count;
+			for (int i = index; i < last; ++i) {
+				lua_remove(L_, index);
+			}
+		}
+
+		struct push_popper_at {
+			lua_State* L;
+			int index;
+			int count;
+			push_popper_at(lua_State* L_, int index_ = -1, int count_ = 1) : L(L_), index(index_), count(count_) {
+			}
+			~push_popper_at() {
+				remove(L, index, count);
+			}
+		};
+
+		template <bool top_level>
+		struct push_popper_n {
+			lua_State* L;
+			int pop_count;
+			push_popper_n(lua_State* L_, int pop_count_) : L(L_), pop_count(pop_count_) {
+			}
+			push_popper_n(const push_popper_n&) = delete;
+			push_popper_n(push_popper_n&&) = default;
+			push_popper_n& operator=(const push_popper_n&) = delete;
+			push_popper_n& operator=(push_popper_n&&) = default;
+			~push_popper_n() {
+				lua_pop(L, pop_count);
+			}
+		};
+
+		template <>
+		struct push_popper_n<true> {
+			push_popper_n(lua_State*, int) {
+			}
+		};
+
+		template <bool, typename T, typename = void>
+		struct push_popper {
+			using Tu = meta::unqualified_t<T>;
+			T m_object;
+			int m_index;
+
+			push_popper(T object_) noexcept : m_object(object_), m_index(lua_absindex(m_object.lua_state(), -m_object.push())) {
+			}
+
+			int index_of(const Tu&) const noexcept {
+				return m_index;
+			}
+
+			~push_popper() {
+				m_object.pop();
+			}
+		};
+
+		template <typename T, typename C>
+		struct push_popper<true, T, C> {
+			using Tu = meta::unqualified_t<T>;
+
+			push_popper(T) noexcept {
+			}
+
+			int index_of(const Tu&) const noexcept {
+				return -1;
+			}
+
+			~push_popper() {
+			}
+		};
+
+		template <typename T>
+		struct push_popper<false, T, std::enable_if_t<is_stack_based_v<meta::unqualified_t<T>>>> {
+			using Tu = meta::unqualified_t<T>;
+
+			push_popper(T) noexcept {
+			}
+
+			int index_of(const Tu& object_) const noexcept {
+				return object_.stack_index();
+			}
+
+			~push_popper() {
+			}
+		};
+
+		template <bool, typename T, typename = void>
+		struct stateless_push_popper {
+			using Tu = meta::unqualified_t<T>;
+			lua_State* m_L;
+			T m_object;
+			int m_index;
+
+			stateless_push_popper(lua_State* L_, T object_) noexcept : m_L(L_), m_object(object_), m_index(lua_absindex(m_L, -m_object.push(m_L))) {
+			}
+
+			int index_of(const Tu&) const noexcept {
+				return m_index;
+			}
+
+			~stateless_push_popper() {
+				m_object.pop(m_L);
+			}
+		};
+
+		template <typename T, typename C>
+		struct stateless_push_popper<true, T, C> {
+			using Tu = meta::unqualified_t<T>;
+
+			stateless_push_popper(lua_State*, T) noexcept {
+			}
+
+			int index_of(lua_State*, const Tu&) const noexcept {
+				return -1;
+			}
+
+			~stateless_push_popper() {
+			}
+		};
+
+		template <typename T>
+		struct stateless_push_popper<false, T, std::enable_if_t<is_stack_based_v<meta::unqualified_t<T>>>> {
+			using Tu = meta::unqualified_t<T>;
+			lua_State* m_L;
+
+			stateless_push_popper(lua_State* L_, T) noexcept : m_L(L_) {
+			}
+
+			int index_of(const Tu& object_) const noexcept {
+				return object_.stack_index();
+			}
+
+			~stateless_push_popper() {
+			}
+		};
+
+		template <bool top_level = false, typename T>
+		push_popper<top_level, T> push_pop(T&& x) {
+			return push_popper<top_level, T>(std::forward<T>(x));
+		}
+
+		template <bool top_level = false, typename T>
+		stateless_push_popper<top_level, T> push_pop(lua_State* L_, T&& object_) {
+			return stateless_push_popper<top_level, T>(L_, std::forward<T>(object_));
+		}
+
+		template <typename T>
+		push_popper_at push_pop_at(T&& object_) {
+			int push_count = object_.push();
+			lua_State* L = object_.lua_state();
+			return push_popper_at(L, lua_absindex(L, -push_count), push_count);
+		}
+
+		template <bool top_level = false>
+		push_popper_n<top_level> pop_n(lua_State* L_, int pop_count_) {
+			return push_popper_n<top_level>(L_, pop_count_);
+		}
+	} // namespace stack
+
+	inline lua_State* main_thread(lua_State* L_, lua_State* backup_if_unsupported_ = nullptr) {
+#if SOL_LUA_VERSION_I_ < 502
+		if (L_ == nullptr)
+			return backup_if_unsupported_;
+		lua_getglobal(L_, detail::default_main_thread_name());
+		auto pp = stack::pop_n(L_, 1);
+		if (type_of(L_, -1) == type::thread) {
+			return lua_tothread(L_, -1);
+		}
+		return backup_if_unsupported_;
+#else
+		if (L_ == nullptr)
+			return backup_if_unsupported_;
+		lua_rawgeti(L_, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD);
+		lua_State* Lmain = lua_tothread(L_, -1);
+		lua_pop(L_, 1);
+		return Lmain;
+#endif // Lua 5.2+ has the main thread unqualified_getter
+	}
+
+	namespace detail {
+		struct no_safety_tag {
+		} inline constexpr no_safety {};
+
+		template <bool b>
+		inline lua_State* pick_main_thread(lua_State* L_, lua_State* backup_if_unsupported = nullptr) {
+			(void)L_;
+			(void)backup_if_unsupported;
+			if (b) {
+				return main_thread(L_, backup_if_unsupported);
+			}
+			return L_;
+		}
+	} // namespace detail
+
+	class stateless_reference {
+	private:
+		template <bool o_main_only>
+		friend class basic_reference;
+
+		int ref = LUA_NOREF;
+
+		int copy_ref(lua_State* L_) const noexcept {
+			if (ref == LUA_NOREF)
+				return LUA_NOREF;
+			push(L_);
+			return luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+
+		lua_State* copy_assign_ref(lua_State* L_, lua_State* rL, const stateless_reference& r) {
+			if (valid(L_)) {
+				deref(L_);
+			}
+			ref = r.copy_ref(L_);
+			return rL;
+		}
+
+		lua_State* move_assign(lua_State* L_, lua_State* rL, stateless_reference&& r) {
+			if (valid(L_)) {
+				deref(L_);
+			}
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+			return rL;
+		}
+
+	protected:
+		int stack_index() const noexcept {
+			return -1;
+		}
+
+		stateless_reference(lua_State* L_, global_tag_t) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushglobaltable(L_);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+
+		stateless_reference(int raw_ref_index) noexcept : ref(raw_ref_index) {
+		}
+
+	public:
+		stateless_reference() noexcept = default;
+		stateless_reference(lua_nil_t) noexcept : stateless_reference() {
+		}
+		stateless_reference(const stack_reference& r) noexcept : stateless_reference(r.lua_state(), r.stack_index()) {
+		}
+		stateless_reference(stack_reference&& r) noexcept : stateless_reference(r.lua_state(), r.stack_index()) {
+		}
+		stateless_reference(lua_State* L_, const stateless_reference& r) noexcept {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || L_ == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			ref = r.copy_ref(L_);
+		}
+
+		stateless_reference(lua_State* L_, stateless_reference&& r) noexcept {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || L_ == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+		}
+
+		stateless_reference(lua_State* L_, const stack_reference& r) noexcept {
+			if (L_ == nullptr || r.lua_state() == nullptr || r.get_type() == type::none) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (r.get_type() == type::lua_nil) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (L_ != r.lua_state() && !detail::xmovable(L_, r.lua_state())) {
+				return;
+			}
+			r.push(L_);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+
+		stateless_reference(lua_State* L_, const stateless_stack_reference& r) noexcept : stateless_reference(L_, r.stack_index()) {
+		}
+
+		stateless_reference(lua_State* L_, int index = -1) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L_, index);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+		stateless_reference(lua_State* L_, absolute_index index_) noexcept : stateless_reference(L_, index_.index) {
+		}
+		stateless_reference(lua_State* L_, ref_index index_) noexcept {
+			lua_rawgeti(L_, LUA_REGISTRYINDEX, index_.index);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+		stateless_reference(lua_State*, lua_nil_t) noexcept {
+		}
+
+		~stateless_reference() noexcept = default;
+
+		stateless_reference(const stateless_reference& o) noexcept = delete;
+		stateless_reference& operator=(const stateless_reference& r) noexcept = delete;
+
+		stateless_reference(stateless_reference&& o) noexcept : ref(o.ref) {
+			o.ref = LUA_NOREF;
+		}
+
+		stateless_reference& operator=(stateless_reference&& o) noexcept {
+			ref = o.ref;
+			o.ref = LUA_NOREF;
+			return *this;
+		}
+
+		int push(lua_State* L_) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_rawgeti(L_, LUA_REGISTRYINDEX, ref);
+			return 1;
+		}
+
+		void pop(lua_State* L_, int n = 1) const noexcept {
+			lua_pop(L_, n);
+		}
+
+		int registry_index() const noexcept {
+			return ref;
+		}
+
+		void reset(lua_State* L_) noexcept {
+			if (valid(L_)) {
+				deref(L_);
+			}
+			ref = LUA_NOREF;
+		}
+
+		void reset(lua_State* L_, int index_) noexcept {
+			reset(L_);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L_, index_);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+
+		bool valid(lua_State*) const noexcept {
+			return !(ref == LUA_NOREF || ref == LUA_REFNIL);
+		}
+
+		const void* pointer(lua_State* L_) const noexcept {
+			int si = push(L_);
+			const void* vp = lua_topointer(L_, -si);
+			lua_pop(L_, si);
+			return vp;
+		}
+
+		type get_type(lua_State* L_) const noexcept {
+			int p = push(L_);
+			int result = lua_type(L_, -1);
+			pop(L_, p);
+			return static_cast<type>(result);
+		}
+
+		void abandon(lua_State* = nullptr) {
+			ref = LUA_NOREF;
+		}
+
+		void deref(lua_State* L_) const noexcept {
+			luaL_unref(L_, LUA_REGISTRYINDEX, ref);
+		}
+
+		stateless_reference copy(lua_State* L_) const noexcept {
+			if (!valid(L_)) {
+				return {};
+			}
+			return stateless_reference(copy_ref(L_));
+		}
+
+		void copy_assign(lua_State* L_, const stateless_reference& right) noexcept {
+			if (valid(L_)) {
+				deref(L_);
+			}
+			if (!right.valid(L_)) {
+				return;
+			}
+			ref = right.copy_ref(L_);
+		}
+
+		bool equals(lua_State* L_, const stateless_reference& r) const noexcept {
+			auto ppl = stack::push_pop(L_, *this);
+			auto ppr = stack::push_pop(L_, r);
+			return lua_compare(L_, -1, -2, LUA_OPEQ) == 1;
+		}
+
+		bool equals(lua_State* L_, const stateless_stack_reference& r) const noexcept {
+			auto ppl = stack::push_pop(L_, *this);
+			return lua_compare(L_, -1, r.stack_index(), LUA_OPEQ) == 1;
+		}
+
+		bool equals(lua_State* L_, lua_nil_t) const noexcept {
+			return valid(L_);
+		}
+	};
+
+	template <bool main_only = false>
+	class basic_reference : public stateless_reference {
+	private:
+		template <bool o_main_only>
+		friend class basic_reference;
+		lua_State* luastate = nullptr; // non-owning
+
+		template <bool r_main_only>
+		void copy_assign_complex(const basic_reference<r_main_only>& r) {
+			if (valid()) {
+				deref();
+			}
+			if (r.ref == LUA_REFNIL) {
+				luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF) {
+				luastate = r.luastate;
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+			luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+			ref = r.copy_ref();
+		}
+
+		template <bool r_main_only>
+		void move_assign(basic_reference<r_main_only>&& r) {
+			if (valid()) {
+				deref();
+			}
+			if (r.ref == LUA_REFNIL) {
+				luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF) {
+				luastate = r.luastate;
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+
+			luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+			r.luastate = nullptr;
+		}
+
+	protected:
+		basic_reference(lua_State* L_, global_tag_t) noexcept : basic_reference(detail::pick_main_thread<main_only>(L_, L_), global_tag, global_tag) {
+		}
+
+		basic_reference(lua_State* L_, global_tag_t, global_tag_t) noexcept : stateless_reference(L_, global_tag), luastate(L_) {
+		}
+
+		basic_reference(lua_State* oL, const basic_reference<!main_only>& o) noexcept : stateless_reference(oL, o), luastate(oL) {
+		}
+
+		void deref() const noexcept {
+			return stateless_reference::deref(lua_state());
+		}
+
+		int copy_ref() const noexcept {
+			return copy_ref(lua_state());
+		}
+
+		int copy_ref(lua_State* L_) const noexcept {
+			return stateless_reference::copy_ref(L_);
+		}
+
+	public:
+		basic_reference() noexcept = default;
+		basic_reference(lua_nil_t) noexcept : basic_reference() {
+		}
+		basic_reference(const stack_reference& r) noexcept : basic_reference(r.lua_state(), r.stack_index()) {
+		}
+		basic_reference(stack_reference&& r) noexcept : basic_reference(r.lua_state(), r.stack_index()) {
+		}
+		template <bool r_main_only>
+		basic_reference(lua_State* L_, const basic_reference<r_main_only>& r) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || lua_state() == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+			ref = r.copy_ref();
+		}
+
+		template <bool r_main_only>
+		basic_reference(lua_State* L_, basic_reference<r_main_only>&& r) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || lua_state() == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+			r.luastate = nullptr;
+		}
+
+		basic_reference(lua_State* L_, const stack_reference& r) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			if (lua_state() == nullptr || r.lua_state() == nullptr || r.get_type() == type::none) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (r.get_type() == type::lua_nil) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (lua_state() != r.lua_state() && !detail::xmovable(lua_state(), r.lua_state())) {
+				return;
+			}
+			r.push(lua_state());
+			ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+		}
+		basic_reference(lua_State* L_, int index = -1) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			// use L_ to stick with that state's execution stack
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L_, index);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+		basic_reference(lua_State* L_, ref_index index) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			lua_rawgeti(lua_state(), LUA_REGISTRYINDEX, index.index);
+			ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+		}
+		basic_reference(lua_State* L_, lua_nil_t) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+		}
+
+		~basic_reference() noexcept {
+			if (lua_state() == nullptr || ref == LUA_NOREF)
+				return;
+			deref();
+		}
+
+		basic_reference(const basic_reference& o) noexcept : stateless_reference(o.copy_ref()), luastate(o.lua_state()) {
+		}
+
+		basic_reference(basic_reference&& o) noexcept : stateless_reference(std::move(o)), luastate(o.lua_state()) {
+			o.luastate = nullptr;
+		}
+
+		basic_reference(const basic_reference<!main_only>& o) noexcept
+		: basic_reference(detail::pick_main_thread<main_only>(o.lua_state(), o.lua_state()), o) {
+		}
+
+		basic_reference(basic_reference<!main_only>&& o) noexcept
+		: stateless_reference(std::move(o)), luastate(detail::pick_main_thread<main_only>(o.lua_state(), o.lua_state())) {
+			o.luastate = nullptr;
+			o.ref = LUA_NOREF;
+		}
+
+		basic_reference& operator=(basic_reference&& r) noexcept {
+			move_assign(std::move(r));
+			return *this;
+		}
+
+		basic_reference& operator=(const basic_reference& r) noexcept {
+			copy_assign_complex(r);
+			return *this;
+		}
+
+		basic_reference& operator=(basic_reference<!main_only>&& r) noexcept {
+			move_assign(std::move(r));
+			return *this;
+		}
+
+		basic_reference& operator=(const basic_reference<!main_only>& r) noexcept {
+			copy_assign_complex(r);
+			return *this;
+		}
+
+		basic_reference& operator=(const lua_nil_t&) noexcept {
+			reset();
+			return *this;
+		}
+
+		template <typename Super>
+		basic_reference& operator=(proxy_base<Super>&& r);
+
+		template <typename Super>
+		basic_reference& operator=(const proxy_base<Super>& r);
+
+		int push() const noexcept {
+			return push(lua_state());
+		}
+
+		void reset() noexcept {
+			stateless_reference::reset(luastate);
+			luastate = nullptr;
+		}
+
+		int push(lua_State* L_) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			if (lua_state() == nullptr) {
+				lua_pushnil(L_);
+				return 1;
+			}
+			lua_rawgeti(lua_state(), LUA_REGISTRYINDEX, ref);
+			if (L_ != lua_state()) {
+				lua_xmove(lua_state(), L_, 1);
+			}
+			return 1;
+		}
+
+		void pop() const noexcept {
+			pop(lua_state());
+		}
+
+		void pop(lua_State* L_, int n = 1) const noexcept {
+			stateless_reference::pop(L_, n);
+		}
+
+		int registry_index() const noexcept {
+			return stateless_reference::registry_index();
+		}
+
+		bool valid() const noexcept {
+			return stateless_reference::valid(lua_state());
+		}
+
+		bool valid(lua_State* L_) const noexcept {
+			return stateless_reference::valid(L_);
+		}
+
+		const void* pointer() const noexcept {
+			return stateless_reference::pointer(lua_state());
+		}
+
+		explicit operator bool() const noexcept {
+			return valid();
+		}
+
+		type get_type() const noexcept {
+			return stateless_reference::get_type(lua_state());
+		}
+
+		lua_State* lua_state() const noexcept {
+			return luastate;
+		}
+	};
+
+	template <bool lb, bool rb>
+	inline bool operator==(const basic_reference<lb>& l, const basic_reference<rb>& r) noexcept {
+		auto ppl = stack::push_pop(l);
+		auto ppr = stack::push_pop(r);
+		return lua_compare(l.lua_state(), -1, -2, LUA_OPEQ) == 1;
+	}
+
+	template <bool lb, bool rb>
+	inline bool operator!=(const basic_reference<lb>& l, const basic_reference<rb>& r) noexcept {
+		return !operator==(l, r);
+	}
+
+	template <bool lb>
+	inline bool operator==(const basic_reference<lb>& l, const stack_reference& r) noexcept {
+		auto ppl = stack::push_pop(l);
+		return lua_compare(l.lua_state(), -1, r.stack_index(), LUA_OPEQ) == 1;
+	}
+
+	template <bool lb>
+	inline bool operator!=(const basic_reference<lb>& l, const stack_reference& r) noexcept {
+		return !operator==(l, r);
+	}
+
+	template <bool rb>
+	inline bool operator==(const stack_reference& l, const basic_reference<rb>& r) noexcept {
+		auto ppr = stack::push_pop(r);
+		return lua_compare(l.lua_state(), -1, r.stack_index(), LUA_OPEQ) == 1;
+	}
+
+	template <bool rb>
+	inline bool operator!=(const stack_reference& l, const basic_reference<rb>& r) noexcept {
+		return !operator==(l, r);
+	}
+
+	template <bool lb>
+	inline bool operator==(const basic_reference<lb>& lhs, const lua_nil_t&) noexcept {
+		return !lhs.valid();
+	}
+
+	template <bool rb>
+	inline bool operator==(const lua_nil_t&, const basic_reference<rb>& rhs) noexcept {
+		return !rhs.valid();
+	}
+
+	template <bool lb>
+	inline bool operator!=(const basic_reference<lb>& lhs, const lua_nil_t&) noexcept {
+		return lhs.valid();
+	}
+
+	template <bool rb>
+	inline bool operator!=(const lua_nil_t&, const basic_reference<rb>& rhs) noexcept {
+		return rhs.valid();
+	}
+
+	inline bool operator==(const stateless_reference& l, const stateless_reference& r) noexcept {
+		return l.registry_index() == r.registry_index();
+	}
+
+	inline bool operator!=(const stateless_reference& l, const stateless_reference& r) noexcept {
+		return l.registry_index() != r.registry_index();
+	}
+
+	inline bool operator==(const stateless_reference& lhs, const lua_nil_t&) noexcept {
+		return lhs.registry_index() == LUA_REFNIL;
+	}
+
+	inline bool operator==(const lua_nil_t&, const stateless_reference& rhs) noexcept {
+		return rhs.registry_index() == LUA_REFNIL;
+	}
+
+	inline bool operator!=(const stateless_reference& lhs, const lua_nil_t&) noexcept {
+		return lhs.registry_index() != LUA_REFNIL;
+	}
+
+	inline bool operator!=(const lua_nil_t&, const stateless_reference& rhs) noexcept {
+		return rhs.registry_index() != LUA_REFNIL;
+	}
+
+	struct stateless_reference_equals : public stateless_stack_reference_equals {
+		using is_transparent = std::true_type;
+
+		stateless_reference_equals(lua_State* L_) noexcept : stateless_stack_reference_equals(L_) {
+		}
+
+		bool operator()(const lua_nil_t& lhs, const stateless_reference& rhs) const noexcept {
+			return rhs.equals(lua_state(), lhs);
+		}
+
+		bool operator()(const stateless_reference& lhs, const lua_nil_t& rhs) const noexcept {
+			return lhs.equals(lua_state(), rhs);
+		}
+
+		bool operator()(const stateless_reference& lhs, const stateless_reference& rhs) const noexcept {
+			return lhs.equals(lua_state(), rhs);
+		}
+	};
+
+	struct reference_equals : public stack_reference_equals {
+		using is_transparent = std::true_type;
+
+		template <bool rb>
+		bool operator()(const lua_nil_t& lhs, const basic_reference<rb>& rhs) const noexcept {
+			return lhs == rhs;
+		}
+
+		template <bool lb>
+		bool operator()(const basic_reference<lb>& lhs, const lua_nil_t& rhs) const noexcept {
+			return lhs == rhs;
+		}
+
+		template <bool lb, bool rb>
+		bool operator()(const basic_reference<lb>& lhs, const basic_reference<rb>& rhs) const noexcept {
+			return lhs == rhs;
+		}
+
+		template <bool lb>
+		bool operator()(const basic_reference<lb>& lhs, const stack_reference& rhs) const noexcept {
+			return lhs == rhs;
+		}
+
+		template <bool rb>
+		bool operator()(const stack_reference& lhs, const basic_reference<rb>& rhs) const noexcept {
+			return lhs == rhs;
+		}
+	};
+
+	struct stateless_reference_hash : public stateless_stack_reference_hash {
+		using argument_type = stateless_reference;
+		using result_type = std::size_t;
+		using is_transparent = std::true_type;
+
+		stateless_reference_hash(lua_State* L_) noexcept : stateless_stack_reference_hash(L_) {
+		}
+
+		result_type operator()(const stateless_reference& lhs) const noexcept {
+			std::hash<const void*> h;
+			return h(lhs.pointer(lua_state()));
+		}
+	};
+
+	struct reference_hash : public stack_reference_hash {
+		using argument_type = reference;
+		using result_type = std::size_t;
+		using is_transparent = std::true_type;
+
+		template <bool lb>
+		result_type operator()(const basic_reference<lb>& lhs) const noexcept {
+			std::hash<const void*> h;
+			return h(lhs.pointer());
+		}
+	};
+} // namespace sol
+
+// end of sol/reference.hpp
+
+// beginning of sol/tie.hpp
+
+namespace sol {
+
+	namespace detail {
+		template <typename T>
+		struct is_speshul : std::false_type { };
+	} // namespace detail
+
+	template <typename T>
+	struct tie_size : std::tuple_size<T> { };
+
+	template <typename T>
+	struct is_tieable : std::integral_constant<bool, (::sol::tie_size<T>::value > 0)> { };
+
+	template <typename... Tn>
+	struct tie_t : public std::tuple<std::add_lvalue_reference_t<Tn>...> {
+	private:
+		typedef std::tuple<std::add_lvalue_reference_t<Tn>...> base_t;
+
+		template <typename T>
+		void set(std::false_type, T&& target) {
+			std::get<0>(*this) = std::forward<T>(target);
+		}
+
+		template <typename T>
+		void set(std::true_type, T&& target) {
+			typedef tie_size<meta::unqualified_t<T>> value_size;
+			typedef tie_size<std::tuple<Tn...>> tie_size;
+			typedef meta::conditional_t<(value_size::value < tie_size::value), value_size, tie_size> indices_size;
+			typedef std::make_index_sequence<indices_size::value> indices;
+			set_extra(detail::is_speshul<meta::unqualified_t<T>>(), indices(), std::forward<T>(target));
+		}
+
+		template <std::size_t... I, typename T>
+		void set_extra(std::true_type, std::index_sequence<I...>, T&& target) {
+			using std::get;
+			(void)detail::swallow { 0, (get<I>(static_cast<base_t&>(*this)) = get<I>(types<Tn...>(), target), 0)..., 0 };
+		}
+
+		template <std::size_t... I, typename T>
+		void set_extra(std::false_type, std::index_sequence<I...>, T&& target) {
+			using std::get;
+			(void)detail::swallow { 0, (get<I>(static_cast<base_t&>(*this)) = get<I>(target), 0)..., 0 };
+		}
+
+	public:
+		using base_t::base_t;
+
+		template <typename T>
+		tie_t& operator=(T&& value) {
+			typedef is_tieable<meta::unqualified_t<T>> tieable;
+			set(tieable(), std::forward<T>(value));
+			return *this;
+		}
+	};
+
+	template <typename... Tn>
+	struct tie_size<tie_t<Tn...>> : std::tuple_size<std::tuple<Tn...>> { };
+
+	namespace adl_barrier_detail {
+		template <typename... Tn>
+		inline tie_t<std::remove_reference_t<Tn>...> tie(Tn&&... argn) {
+			return tie_t<std::remove_reference_t<Tn>...>(std::forward<Tn>(argn)...);
+		}
+	} // namespace adl_barrier_detail
+
+	using namespace adl_barrier_detail;
+
+} // namespace sol
+
+// end of sol/tie.hpp
+
+// beginning of sol/stack_guard.hpp
+
+#include <functional>
+
+namespace sol {
+	namespace detail {
+		inline void stack_fail(int, int) {
+#if SOL_IS_ON(SOL_EXCEPTIONS)
+			throw error(detail::direct_error, "imbalanced stack after operation finish");
+#else
+			// Lol, what do you want, an error printout? :3c
+			// There's no sane default here. The right way would be C-style abort(), and that's not acceptable, so
+			// hopefully someone will register their own stack_fail thing for the `fx` parameter of stack_guard.
+#endif // No Exceptions
+		}
+	} // namespace detail
+
+	struct stack_guard {
+		lua_State* L;
+		int top;
+		std::function<void(int, int)> on_mismatch;
+
+		stack_guard(lua_State* L) : stack_guard(L, lua_gettop(L)) {
+		}
+		stack_guard(lua_State* L, int top, std::function<void(int, int)> fx = detail::stack_fail) : L(L), top(top), on_mismatch(std::move(fx)) {
+		}
+		bool check_stack(int modification = 0) const {
+			int bottom = lua_gettop(L) + modification;
+			if (top == bottom) {
+				return true;
+			}
+			on_mismatch(top, bottom);
+			return false;
+		}
+		~stack_guard() {
+			check_stack();
+		}
+	};
+} // namespace sol
+
+// end of sol/stack_guard.hpp
+
+#include <vector>
+#include <bitset>
+#include <forward_list>
+#include <string>
+#include <limits>
+#include <algorithm>
+#include <sstream>
+#include <optional>
+#include <type_traits>
+
+namespace sol {
+	namespace detail {
+		struct with_function_tag { };
+		struct as_reference_tag { };
+		template <typename T>
+		struct as_pointer_tag { };
+		template <typename T>
+		struct as_value_tag { };
+		template <typename T>
+		struct as_unique_tag { };
+		template <typename T>
+		struct as_table_tag { };
+
+		template <typename Tag>
+		inline constexpr bool is_tagged_v
+		     = meta::is_specialization_of_v<Tag,
+		            detail::
+		                 as_pointer_tag> || meta::is_specialization_of_v<Tag, as_value_tag> || meta::is_specialization_of_v<Tag, as_unique_tag> || meta::is_specialization_of_v<Tag, as_table_tag> || std::is_same_v<Tag, as_reference_tag> || std::is_same_v<Tag, with_function_tag>;
+
+		using lua_reg_table = luaL_Reg[64];
+
+		using unique_destructor = void (*)(void*);
+		using unique_tag = detail::inheritance_unique_cast_function;
+
+		inline void* alloc_newuserdata(lua_State* L, std::size_t bytesize) {
+#if SOL_LUA_VERSION_I_ >= 504
+			return lua_newuserdatauv(L, bytesize, 1);
+#else
+			return lua_newuserdata(L, bytesize);
+#endif
+		}
+
+		constexpr std::uintptr_t align(std::size_t alignment, std::uintptr_t ptr, std::size_t& space) {
+			// this handles arbitrary alignments...
+			// make this into a power-of-2-only?
+			// actually can't: this is a C++14-compatible framework,
+			// power of 2 alignment is C++17
+			std::uintptr_t offby = static_cast<std::uintptr_t>(ptr % alignment);
+			std::uintptr_t padding = (alignment - offby) % alignment;
+			ptr += padding;
+			space -= padding;
+			return ptr;
+		}
+
+		inline void* align(std::size_t alignment, void* ptr, std::size_t& space) {
+			return reinterpret_cast<void*>(align(alignment, reinterpret_cast<std::uintptr_t>(ptr), space));
+		}
+
+		constexpr std::uintptr_t align_one(std::size_t alignment, std::size_t size, std::uintptr_t ptr) {
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(alignment, ptr, space) + size;
+		}
+
+		template <typename... Args>
+		constexpr std::size_t aligned_space_for(std::uintptr_t ptr) {
+			std::uintptr_t end = ptr;
+			((end = align_one(alignof(Args), sizeof(Args), end)), ...);
+			return static_cast<std::size_t>(end - ptr);
+		}
+
+		template <typename... Args>
+		constexpr std::size_t aligned_space_for() {
+			static_assert(sizeof...(Args) > 0);
+
+			constexpr std::size_t max_arg_alignment = (std::max)({ alignof(Args)... });
+			if constexpr (max_arg_alignment <= alignof(std::max_align_t)) {
+				// If all types are `good enough`, simply calculate alignment in case of the worst allocator
+				std::size_t worst_required_size = 0;
+				for (std::size_t ptr = 0; ptr < max_arg_alignment; ptr++) {
+					worst_required_size = (std::max)(worst_required_size, aligned_space_for<Args...>(ptr));
+				}
+				return worst_required_size;
+			}
+			else {
+				// For over-aligned types let's assume that every Arg in Args starts at the worst aligned address
+				return (aligned_space_for<Args>(0x1) + ...);
+			}
+		}
+
+		inline void* align_usertype_pointer(void* ptr) {
+			using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<void*>::value > 1)
+#endif
+			     >;
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of<void*>::value, ptr, space);
+		}
+
+		template <bool pre_aligned = false, bool pre_shifted = false>
+		void* align_usertype_unique_destructor(void* ptr) {
+			using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<unique_destructor>::value > 1)
+#endif
+			     >;
+			if (!pre_aligned) {
+				ptr = align_usertype_pointer(ptr);
+			}
+			if (!pre_shifted) {
+				ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(void*));
+			}
+			if (!use_align::value) {
+				return static_cast<void*>(static_cast<void**>(ptr) + 1);
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of<unique_destructor>::value, ptr, space);
+		}
+
+		template <bool pre_aligned = false, bool pre_shifted = false>
+		void* align_usertype_unique_tag(void* ptr) {
+			using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<unique_tag>::value > 1)
+#endif
+			     >;
+			if (!pre_aligned) {
+				ptr = align_usertype_unique_destructor(ptr);
+			}
+			if (!pre_shifted) {
+				ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(unique_destructor));
+			}
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of<unique_tag>::value, ptr, space);
+		}
+
+		template <typename T, bool pre_aligned = false, bool pre_shifted = false>
+		void* align_usertype_unique(void* ptr) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!pre_aligned) {
+				ptr = align_usertype_unique_tag(ptr);
+			}
+			if (!pre_shifted) {
+				ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(unique_tag));
+			}
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of_v<T>, ptr, space);
+		}
+
+		template <typename T>
+		void* align_user(void* ptr) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of_v<T>, ptr, space);
+		}
+
+		template <typename T>
+		T** usertype_allocate_pointer(lua_State* L) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<T*>::value > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				T** pointerpointer = static_cast<T**>(alloc_newuserdata(L, sizeof(T*)));
+				return pointerpointer;
+			}
+			constexpr std::size_t initial_size = aligned_space_for<T*>();
+
+			std::size_t allocated_size = initial_size;
+			void* unadjusted = alloc_newuserdata(L, initial_size);
+			void* adjusted = align(std::alignment_of<T*>::value, unadjusted, allocated_size);
+			if (adjusted == nullptr) {
+				// trash allocator can burn in hell
+				lua_pop(L, 1);
+				// luaL_error(L, "if you are the one that wrote this allocator you should feel bad for doing a
+				// worse job than malloc/realloc and should go read some books, yeah?");
+				luaL_error(L, "cannot properly align memory for '%s'", detail::demangle<T*>().data());
+			}
+			return static_cast<T**>(adjusted);
+		}
+
+		inline bool attempt_alloc(lua_State* L, std::size_t ptr_align, std::size_t ptr_size, std::size_t value_align,
+		     std::size_t allocated_size, void*& pointer_adjusted, void*& data_adjusted) {
+			void* adjusted = alloc_newuserdata(L, allocated_size);
+			pointer_adjusted = align(ptr_align, adjusted, allocated_size);
+			if (pointer_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			// subtract size of what we're going to allocate there
+			allocated_size -= ptr_size;
+			adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + ptr_size);
+			data_adjusted = align(value_align, adjusted, allocated_size);
+			if (data_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			return true;
+		}
+
+		inline bool attempt_alloc_unique(lua_State* L, std::size_t ptr_align, std::size_t ptr_size, std::size_t real_align,
+		     std::size_t allocated_size, void*& pointer_adjusted, void*& dx_adjusted, void*& id_adjusted, void*& data_adjusted) {
+			void* adjusted = alloc_newuserdata(L, allocated_size);
+			pointer_adjusted = align(ptr_align, adjusted, allocated_size);
+			if (pointer_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			allocated_size -= ptr_size;
+
+			adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + ptr_size);
+			dx_adjusted = align(std::alignment_of_v<unique_destructor>, adjusted, allocated_size);
+			if (dx_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			allocated_size -= sizeof(unique_destructor);
+
+			adjusted = static_cast<void*>(static_cast<char*>(dx_adjusted) + sizeof(unique_destructor));
+
+			id_adjusted = align(std::alignment_of_v<unique_tag>, adjusted, allocated_size);
+			if (id_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			allocated_size -= sizeof(unique_tag);
+
+			adjusted = static_cast<void*>(static_cast<char*>(id_adjusted) + sizeof(unique_tag));
+			data_adjusted = align(real_align, adjusted, allocated_size);
+			if (data_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			return true;
+		}
+
+		template <typename T>
+		T* usertype_allocate(lua_State* L) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<T*>::value > 1 || std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				T** pointerpointer = static_cast<T**>(alloc_newuserdata(L, sizeof(T*) + sizeof(T)));
+				T*& pointerreference = *pointerpointer;
+				T* allocationtarget = reinterpret_cast<T*>(pointerpointer + 1);
+				pointerreference = allocationtarget;
+				return allocationtarget;
+			}
+
+			constexpr std::size_t initial_size = aligned_space_for<T*, T>();
+
+			void* pointer_adjusted;
+			void* data_adjusted;
+			bool result
+			     = attempt_alloc(L, std::alignment_of_v<T*>, sizeof(T*), std::alignment_of_v<T>, initial_size, pointer_adjusted, data_adjusted);
+			if (!result) {
+				if (pointer_adjusted == nullptr) {
+					luaL_error(L, "aligned allocation of userdata block (pointer section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				else {
+					luaL_error(L, "aligned allocation of userdata block (data section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				return nullptr;
+			}
+
+			T** pointerpointer = reinterpret_cast<T**>(pointer_adjusted);
+			T*& pointerreference = *pointerpointer;
+			T* allocationtarget = reinterpret_cast<T*>(data_adjusted);
+			pointerreference = allocationtarget;
+			return allocationtarget;
+		}
+
+		template <typename T, typename Real>
+		Real* usertype_unique_allocate(lua_State* L, T**& pref, unique_destructor*& dx, unique_tag*& id) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<T*>::value > 1 || std::alignment_of<unique_tag>::value > 1 || std::alignment_of<unique_destructor>::value > 1
+			          || std::alignment_of<Real>::value > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				pref = static_cast<T**>(alloc_newuserdata(L, sizeof(T*) + sizeof(detail::unique_destructor) + sizeof(unique_tag) + sizeof(Real)));
+				dx = static_cast<detail::unique_destructor*>(static_cast<void*>(pref + 1));
+				id = static_cast<unique_tag*>(static_cast<void*>(dx + 1));
+				Real* mem = static_cast<Real*>(static_cast<void*>(id + 1));
+				return mem;
+			}
+
+			constexpr std::size_t initial_size = aligned_space_for<T*, unique_destructor, unique_tag, Real>();
+
+			void* pointer_adjusted;
+			void* dx_adjusted;
+			void* id_adjusted;
+			void* data_adjusted;
+			bool result = attempt_alloc_unique(L,
+			     std::alignment_of_v<T*>,
+			     sizeof(T*),
+			     std::alignment_of_v<Real>,
+			     initial_size,
+			     pointer_adjusted,
+			     dx_adjusted,
+			     id_adjusted,
+			     data_adjusted);
+			if (!result) {
+				if (pointer_adjusted == nullptr) {
+					luaL_error(L, "aligned allocation of userdata block (pointer section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				else if (dx_adjusted == nullptr) {
+					luaL_error(L, "aligned allocation of userdata block (deleter section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				else {
+					luaL_error(L, "aligned allocation of userdata block (data section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				return nullptr;
+			}
+
+			pref = static_cast<T**>(pointer_adjusted);
+			dx = static_cast<detail::unique_destructor*>(dx_adjusted);
+			id = static_cast<unique_tag*>(id_adjusted);
+			Real* mem = static_cast<Real*>(data_adjusted);
+			return mem;
+		}
+
+		template <typename T>
+		T* user_allocate(lua_State* L) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				T* pointer = static_cast<T*>(alloc_newuserdata(L, sizeof(T)));
+				return pointer;
+			}
+
+			constexpr std::size_t initial_size = aligned_space_for<T>();
+
+			std::size_t allocated_size = initial_size;
+			void* unadjusted = alloc_newuserdata(L, allocated_size);
+			void* adjusted = align(std::alignment_of_v<T>, unadjusted, allocated_size);
+			if (adjusted == nullptr) {
+				lua_pop(L, 1);
+				luaL_error(L, "cannot properly align memory for '%s'", detail::demangle<T>().data());
+			}
+			return static_cast<T*>(adjusted);
+		}
+
+		template <typename T>
+		int usertype_alloc_destroy(lua_State* L) noexcept {
+			void* memory = lua_touserdata(L, 1);
+			memory = align_usertype_pointer(memory);
+			T** pdata = static_cast<T**>(memory);
+			T* data = *pdata;
+			std::allocator<T> alloc {};
+			std::allocator_traits<std::allocator<T>>::destroy(alloc, data);
+			return 0;
+		}
+
+		template <typename T>
+		int unique_destroy(lua_State* L) noexcept {
+			void* memory = lua_touserdata(L, 1);
+			memory = align_usertype_unique_destructor(memory);
+			unique_destructor& dx = *static_cast<unique_destructor*>(memory);
+			memory = align_usertype_unique_tag<true>(memory);
+			(dx)(memory);
+			return 0;
+		}
+
+		template <typename T>
+		int user_alloc_destroy(lua_State* L) noexcept {
+			void* memory = lua_touserdata(L, 1);
+			void* aligned_memory = align_user<T>(memory);
+			T* typed_memory = static_cast<T*>(aligned_memory);
+			std::allocator<T> alloc;
+			std::allocator_traits<std::allocator<T>>::destroy(alloc, typed_memory);
+			return 0;
+		}
+
+		template <typename T, typename Real>
+		void usertype_unique_alloc_destroy(void* memory) {
+			void* aligned_memory = align_usertype_unique<Real, true>(memory);
+			Real* typed_memory = static_cast<Real*>(aligned_memory);
+			std::allocator<Real> alloc;
+			std::allocator_traits<std::allocator<Real>>::destroy(alloc, typed_memory);
+		}
+
+		template <typename T>
+		int cannot_destroy(lua_State* L) {
+			return luaL_error(L,
+			     "cannot call the destructor for '%s': it is either hidden (protected/private) or removed with '= "
+			     "delete' and thusly this type is being destroyed without properly destroying, invoking undefined "
+			     "behavior: please bind a usertype and specify a custom destructor to define the behavior properly",
+			     detail::demangle<T>().data());
+		}
+
+		template <typename T>
+		void reserve(T&, std::size_t) {
+		}
+
+		template <typename T, typename Al>
+		void reserve(std::vector<T, Al>& vec, std::size_t hint) {
+			vec.reserve(hint);
+		}
+
+		template <typename T, typename Tr, typename Al>
+		void reserve(std::basic_string<T, Tr, Al>& str, std::size_t hint) {
+			str.reserve(hint);
+		}
+
+		inline bool property_always_true(meta_function) {
+			return true;
+		}
+
+		struct properties_enrollment_allowed {
+			int& times_through;
+			std::bitset<64>& properties;
+			automagic_enrollments& enrollments;
+
+			properties_enrollment_allowed(int& times_through_, std::bitset<64>& properties_, automagic_enrollments& enrollments_)
+			: times_through(times_through_), properties(properties_), enrollments(enrollments_) {
+			}
+
+			bool operator()(meta_function mf) const {
+				bool p = properties[static_cast<std::size_t>(mf)];
+				if (times_through > 0) {
+					return p;
+				}
+				switch (mf) {
+				case meta_function::length:
+					return enrollments.length_operator && !p;
+				case meta_function::pairs:
+					return enrollments.pairs_operator && !p;
+				case meta_function::call:
+					return enrollments.call_operator && !p;
+				case meta_function::less_than:
+					return enrollments.less_than_operator && !p;
+				case meta_function::less_than_or_equal_to:
+					return enrollments.less_than_or_equal_to_operator && !p;
+				case meta_function::equal_to:
+					return enrollments.equal_to_operator && !p;
+				default:
+					break;
+				}
+				return !p;
+			}
+		};
+
+		struct indexed_insert {
+			lua_reg_table& registration_table;
+			int& index;
+
+			indexed_insert(lua_reg_table& registration_table_, int& index_ref_) : registration_table(registration_table_), index(index_ref_) {
+			}
+			void operator()(meta_function meta_function_name_, lua_CFunction c_function_) {
+				registration_table[index] = luaL_Reg { to_string(meta_function_name_).c_str(), c_function_ };
+				++index;
+			}
+		};
+	} // namespace detail
+
+	namespace stack {
+
+		template <typename T, bool global = false, bool raw = false, typename = void>
+		struct field_getter;
+		template <typename T, typename P, bool global = false, bool raw = false, typename = void>
+		struct probe_field_getter;
+
+		template <typename T, bool global = false, bool raw = false, typename = void>
+		struct field_setter;
+
+		template <typename T, typename = void>
+		struct unqualified_getter;
+		template <typename T, typename = void>
+		struct qualified_getter;
+
+		template <typename T, typename = void>
+		struct qualified_interop_getter;
+		template <typename T, typename = void>
+		struct unqualified_interop_getter;
+
+		template <typename T, typename = void>
+		struct popper;
+
+		template <typename T, typename = void>
+		struct unqualified_pusher;
+
+		template <typename T, type t, typename = void>
+		struct unqualified_checker;
+		template <typename T, type t, typename = void>
+		struct qualified_checker;
+
+		template <typename T, typename = void>
+		struct unqualified_check_getter;
+		template <typename T, typename = void>
+		struct qualified_check_getter;
+
+		struct probe {
+			bool success;
+			int levels;
+
+			probe(bool s, int l) : success(s), levels(l) {
+			}
+
+			operator bool() const {
+				return success;
+			};
+		};
+
+		struct record {
+			int last;
+			int used;
+
+			record() noexcept : last(), used() {
+			}
+			void use(int count) noexcept {
+				last = count;
+				used += count;
+			}
+		};
+
+		namespace stack_detail {
+			template <typename Function>
+			Function* get_function_pointer(lua_State*, int, record&) noexcept;
+			template <typename Function, typename Handler>
+			bool check_function_pointer(lua_State* L, int index, Handler&& handler, record& tracking) noexcept;
+		} // namespace stack_detail
+
+	} // namespace stack
+
+	namespace meta { namespace meta_detail {
+		template <typename T>
+		using adl_sol_lua_get_test_t = decltype(sol_lua_get(types<T>(), static_cast<lua_State*>(nullptr), -1, std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_interop_get_test_t
+			= decltype(sol_lua_interop_get(types<T>(), static_cast<lua_State*>(nullptr), -1, static_cast<void*>(nullptr), std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_check_test_t = decltype(sol_lua_check(types<T>(), static_cast<lua_State*>(nullptr), -1, &no_panic, std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_interop_check_test_t
+			= decltype(sol_lua_interop_check(types<T>(), static_cast<lua_State*>(nullptr), -1, type::none, &no_panic, std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_check_get_test_t
+			= decltype(sol_lua_check_get(types<T>(), static_cast<lua_State*>(nullptr), -1, &no_panic, std::declval<stack::record&>()));
+
+		template <typename... Args>
+		using adl_sol_lua_push_test_t = decltype(sol_lua_push(static_cast<lua_State*>(nullptr), std::declval<Args>()...));
+
+		template <typename T, typename... Args>
+		using adl_sol_lua_push_exact_test_t = decltype(sol_lua_push(types<T>(), static_cast<lua_State*>(nullptr), std::declval<Args>()...));
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_get_v = meta::is_detected_v<adl_sol_lua_get_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_interop_get_v = meta::is_detected_v<adl_sol_lua_interop_get_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_check_v = meta::is_detected_v<adl_sol_lua_check_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_interop_check_v = meta::is_detected_v<adl_sol_lua_interop_check_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_check_get_v = meta::is_detected_v<adl_sol_lua_check_get_test_t, T>;
+
+		template <typename... Args>
+		inline constexpr bool is_adl_sol_lua_push_v = meta::is_detected_v<adl_sol_lua_push_test_t, Args...>;
+
+		template <typename T, typename... Args>
+		inline constexpr bool is_adl_sol_lua_push_exact_v = meta::is_detected_v<adl_sol_lua_push_exact_test_t, T, Args...>;
+	}} // namespace meta::meta_detail
+
+	namespace stack {
+		namespace stack_detail {
+			constexpr const char* not_enough_stack_space = "not enough space left on Lua stack";
+			constexpr const char* not_enough_stack_space_floating = "not enough space left on Lua stack for a floating point number";
+			constexpr const char* not_enough_stack_space_integral = "not enough space left on Lua stack for an integral number";
+			constexpr const char* not_enough_stack_space_string = "not enough space left on Lua stack for a string";
+			constexpr const char* not_enough_stack_space_meta_function_name = "not enough space left on Lua stack for the name of a meta_function";
+			constexpr const char* not_enough_stack_space_userdata = "not enough space left on Lua stack to create a sol2 userdata";
+			constexpr const char* not_enough_stack_space_generic = "not enough space left on Lua stack to push valuees";
+			constexpr const char* not_enough_stack_space_environment = "not enough space left on Lua stack to retrieve environment";
+
+			template <typename T>
+			struct strip {
+				typedef T type;
+			};
+			template <typename T>
+			struct strip<std::reference_wrapper<T>> {
+				typedef T& type;
+			};
+			template <typename T>
+			struct strip<user<T>> {
+				typedef T& type;
+			};
+			template <typename T>
+			struct strip<non_null<T>> {
+				typedef T type;
+			};
+			template <typename T>
+			using strip_t = typename strip<T>::type;
+
+			template <typename C>
+			static int get_size_hint(C& c) {
+				return static_cast<int>(c.size());
+			}
+
+			template <typename V, typename Al>
+			static int get_size_hint(const std::forward_list<V, Al>&) {
+				// forward_list makes me sad
+				return static_cast<int>(32);
+			}
+
+			template <typename T>
+			decltype(auto) unchecked_unqualified_get(lua_State* L, int index, record& tracking) {
+				using Tu = meta::unqualified_t<T>;
+				if constexpr (meta::meta_detail::is_adl_sol_lua_get_v<Tu>) {
+					return sol_lua_get(types<Tu>(), L, index, tracking);
+				}
+				else {
+					unqualified_getter<Tu> g {};
+					return g.get(L, index, tracking);
+				}
+			}
+
+			template <typename T>
+			decltype(auto) unchecked_get(lua_State* L, int index, record& tracking) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_get_v<T>) {
+					return sol_lua_get(types<T>(), L, index, tracking);
+				}
+				else {
+					qualified_getter<T> g {};
+					return g.get(L, index, tracking);
+				}
+			}
+
+			template <typename T>
+			decltype(auto) unqualified_interop_get(lua_State* L, int index, void* unadjusted_pointer, record& tracking) {
+				using Tu = meta::unqualified_t<T>;
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_get_v<Tu>) {
+					return sol_lua_interop_get(types<Tu>(), L, index, unadjusted_pointer, tracking);
+				}
+				else {
+					(void)L;
+					(void)index;
+					(void)unadjusted_pointer;
+					(void)tracking;
+					using Ti = stack_detail::strip_t<Tu>;
+					return std::pair<bool, Ti*> { false, nullptr };
+				}
+			}
+
+			template <typename T>
+			decltype(auto) interop_get(lua_State* L, int index, void* unadjusted_pointer, record& tracking) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_get_v<T>) {
+					return sol_lua_interop_get(types<T>(), L, index, unadjusted_pointer, tracking);
+				}
+				else {
+					return unqualified_interop_get<T>(L, index, unadjusted_pointer, tracking);
+				}
+			}
+
+			template <typename T, typename Handler>
+			bool unqualified_interop_check(lua_State* L, int index, type index_type, Handler&& handler, record& tracking) {
+				using Tu = meta::unqualified_t<T>;
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_check_v<Tu>) {
+					return sol_lua_interop_check(types<Tu>(), L, index, index_type, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					(void)L;
+					(void)index;
+					(void)index_type;
+					(void)handler;
+					(void)tracking;
+					return false;
+				}
+			}
+
+			template <typename T, typename Handler>
+			bool interop_check(lua_State* L, int index, type index_type, Handler&& handler, record& tracking) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_check_v<T>) {
+					return sol_lua_interop_check(types<T>(), L, index, index_type, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					return unqualified_interop_check<T>(L, index, index_type, std::forward<Handler>(handler), tracking);
+				}
+			}
+
+			using undefined_method_func = void (*)(stack_reference);
+
+			struct undefined_metatable {
+				lua_State* L;
+				const char* key;
+				undefined_method_func on_new_table;
+
+				undefined_metatable(lua_State* l, const char* k, undefined_method_func umf) : L(l), key(k), on_new_table(umf) {
+				}
+
+				void operator()() const {
+					if (luaL_newmetatable(L, key) == 1) {
+						on_new_table(stack_reference(L, -1));
+					}
+					lua_setmetatable(L, -2);
+				}
+			};
+		} // namespace stack_detail
+
+		inline bool maybe_indexable(lua_State* L, int index = -1) {
+			type t = type_of(L, index);
+			return t == type::userdata || t == type::table;
+		}
+
+		inline int top(lua_State* L) {
+			return lua_gettop(L);
+		}
+
+		inline bool is_main_thread(lua_State* L) {
+			int ismainthread = lua_pushthread(L);
+			lua_pop(L, 1);
+			return ismainthread == 1;
+		}
+
+		inline void coroutine_create_guard(lua_State* L) {
+			if (is_main_thread(L)) {
+				return;
+			}
+			int stacksize = lua_gettop(L);
+			if (stacksize < 1) {
+				return;
+			}
+			if (type_of(L, 1) != type::function) {
+				return;
+			}
+			// well now we're screwed...
+			// we can clean the stack and pray it doesn't destroy anything?
+			lua_pop(L, stacksize);
+		}
+
+		inline void clear(lua_State* L, int table_index) {
+			lua_pushnil(L);
+			while (lua_next(L, table_index) != 0) {
+				// remove value
+				lua_pop(L, 1);
+				// duplicate key to protect form rawset
+				lua_pushvalue(L, -1);
+				// push new value
+				lua_pushnil(L);
+				// table_index%[key] = nil
+				lua_rawset(L, table_index);
+			}
+		}
+
+		inline void clear(reference& r) {
+			auto pp = push_pop<false>(r);
+			int stack_index = pp.index_of(r);
+			clear(r.lua_state(), stack_index);
+		}
+
+		inline void clear(stack_reference& r) {
+			clear(r.lua_state(), r.stack_index());
+		}
+
+		inline void clear(lua_State* L_, stateless_reference& r) {
+			r.push(L_);
+			int stack_index = absolute_index(L_, -1);
+			clear(L_, stack_index);
+			r.pop(L_);
+		}
+
+		inline void clear(lua_State* L_, stateless_stack_reference& r) {
+			clear(L_, r.stack_index());
+		}
+
+		template <typename T, typename... Args>
+		int push(lua_State* L, T&& t, Args&&... args) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<T, T, Args...>) {
+				return sol_lua_push(types<T>(), L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<Tu, T, Args...>) {
+				return sol_lua_push(types<Tu>(), L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_v<T, Args...>) {
+				return sol_lua_push(L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+			else {
+				unqualified_pusher<Tu> p {};
+				return p.push(L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+		}
+
+		// overload allows to use a pusher of a specific type, but pass in any kind of args
+		template <typename T, typename Arg, typename... Args, typename = std::enable_if_t<!std::is_same<T, Arg>::value>>
+		int push(lua_State* L, Arg&& arg, Args&&... args) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<T, Arg, Args...>) {
+				return sol_lua_push(types<T>(), L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<Tu, Arg, Args...>) {
+				return sol_lua_push(types<Tu>(), L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_v<Arg, Args...> && !detail::is_tagged_v<Tu>) {
+				return sol_lua_push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+			else {
+				unqualified_pusher<Tu> p {};
+				return p.push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+
+		template <typename T, typename... Args>
+		int push_userdata(lua_State* L, T&& t, Args&&... args) {
+			using U = meta::unqualified_t<T>;
+			using Tr = meta::conditional_t<std::is_pointer_v<U>,
+			     detail::as_pointer_tag<std::remove_pointer_t<U>>,
+			     meta::conditional_t<is_unique_usertype_v<U>, detail::as_unique_tag<U>, detail::as_value_tag<U>>>;
+			return stack::push<Tr>(L, std::forward<T>(t), std::forward<Args>(args)...);
+		}
+
+		template <typename T, typename Arg, typename... Args>
+		int push_userdata(lua_State* L, Arg&& arg, Args&&... args) {
+			using U = meta::unqualified_t<T>;
+			using Tr = meta::conditional_t<std::is_pointer_v<U>,
+			     detail::as_pointer_tag<std::remove_pointer_t<U>>,
+			     meta::conditional_t<is_unique_usertype_v<U>, detail::as_unique_tag<U>, detail::as_value_tag<U>>>;
+			return stack::push<Tr>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+		}
+
+		namespace stack_detail {
+
+			template <typename T, typename Arg, typename... Args>
+			int push_reference(lua_State* L, Arg&& arg, Args&&... args) {
+				// clang-format off
+				using use_reference_tag =
+				meta::all<
+					meta::neg<is_value_semantic_for_function<T>>
+#if SOL_IS_OFF(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
+					, std::is_lvalue_reference<T>,
+					meta::neg<std::is_const<std::remove_reference_t<T>>>,
+					meta::neg<is_lua_primitive<meta::unqualified_t<T>>>,
+					meta::neg<is_unique_usertype<meta::unqualified_t<T>>>
+#endif
+				>;
+				// clang-format on
+				using Tr = meta::conditional_t<use_reference_tag::value, detail::as_reference_tag, meta::unqualified_t<T>>;
+				return stack::push<Tr>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+
+		} // namespace stack_detail
+
+		template <typename T, typename... Args>
+		int push_reference(lua_State* L, T&& t, Args&&... args) {
+			return stack_detail::push_reference<T>(L, std::forward<T>(t), std::forward<Args>(args)...);
+		}
+
+		template <typename T, typename Arg, typename... Args>
+		int push_reference(lua_State* L, Arg&& arg, Args&&... args) {
+			return stack_detail::push_reference<T>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+		}
+
+		inline int multi_push(lua_State*) {
+			// do nothing
+			return 0;
+		}
+
+		template <typename T, typename... Args>
+		int multi_push(lua_State* L, T&& t, Args&&... args) {
+			int pushcount = push(L, std::forward<T>(t));
+			void(detail::swallow { (pushcount += stack::push(L, std::forward<Args>(args)), 0)... });
+			return pushcount;
+		}
+
+		inline int multi_push_reference(lua_State*) {
+			// do nothing
+			return 0;
+		}
+
+		template <typename T, typename... Args>
+		int multi_push_reference(lua_State* L, T&& t, Args&&... args) {
+			int pushcount = stack::push_reference(L, std::forward<T>(t));
+			void(detail::swallow { (pushcount += stack::push_reference(L, std::forward<Args>(args)), 0)... });
+			return pushcount;
+		}
+
+		template <typename T, typename Handler>
+		bool unqualified_check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_v<Tu>) {
+				return sol_lua_check(types<Tu>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				unqualified_checker<Tu, lua_type_of_v<Tu>> c{};
+				return c.check(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		bool unqualified_check(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return unqualified_check<T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T>
+		bool unqualified_check(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return unqualified_check<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_v<T>) {
+				return sol_lua_check(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				using Tu = meta::unqualified_t<T>;
+				qualified_checker<T, lua_type_of_v<Tu>> c{};
+				return c.check(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		bool check(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return check<T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T>
+		bool check(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return check<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		bool check_usertype(lua_State* L, int index, type, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			using detail_t = meta::conditional_t<std::is_pointer_v<T>, detail::as_pointer_tag<Tu>, detail::as_value_tag<Tu>>;
+			return check<detail_t>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T, typename Handler>
+		bool check_usertype(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			using detail_t = meta::conditional_t<std::is_pointer_v<T>, detail::as_pointer_tag<Tu>, detail::as_value_tag<Tu>>;
+			return check<detail_t>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T, typename Handler>
+		bool check_usertype(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return check_usertype<T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T>
+		bool check_usertype(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return check_usertype<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) unqualified_check_get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<T>) {
+				return sol_lua_check_get(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<Tu>) {
+				return sol_lua_check_get(types<Tu>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				unqualified_check_getter<Tu> cg {};
+				return cg.get(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) unqualified_check_get(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return unqualified_check_get<T>(L, index, handler, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) unqualified_check_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return unqualified_check_get<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) check_get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<T>) {
+				return sol_lua_check_get(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				qualified_check_getter<T> cg {};
+				return cg.get(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) check_get(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return check_get<T>(L, index, handler, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) check_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return check_get<T>(L, index, handler);
+		}
+
+		namespace stack_detail {
+
+			template <typename Handler>
+			bool check_types(lua_State*, int, Handler&&, record&) {
+				return true;
+			}
+
+			template <typename T, typename... Args, typename Handler>
+			bool check_types(lua_State* L, int firstargument, Handler&& handler, record& tracking) {
+				if (!stack::check<T>(L, firstargument + tracking.used, handler, tracking))
+					return false;
+				return check_types<Args...>(L, firstargument, std::forward<Handler>(handler), tracking);
+			}
+
+			template <typename... Args, typename Handler>
+			bool check_types(types<Args...>, lua_State* L, int index, Handler&& handler, record& tracking) {
+				return check_types<Args...>(L, index, std::forward<Handler>(handler), tracking);
+			}
+
+		} // namespace stack_detail
+
+		template <typename... Args, typename Handler>
+		bool multi_check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return stack_detail::check_types<Args...>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename... Args, typename Handler>
+		bool multi_check(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return multi_check<Args...>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename... Args>
+		bool multi_check(lua_State* L, int index) {
+			return multi_check<Args...>(L, index);
+		}
+
+		template <typename T>
+		auto unqualified_get(lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_unqualified_get<T>(L, index, tracking)) {
+#if SOL_IS_ON(SOL_SAFE_GETTER)
+			static constexpr bool is_op = meta::is_optional_v<T>;
+			if constexpr (is_op) {
+				return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+			}
+			else {
+				if (is_lua_reference<T>::value) {
+					return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+				}
+				auto op = unqualified_check_get<T>(L, index, type_panic_c_str, tracking);
+				return *std::move(op);
+			}
+#else
+			return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+#endif
+		}
+
+		template <typename T>
+		decltype(auto) unqualified_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			record tracking {};
+			return unqualified_get<T>(L, index, tracking);
+		}
+
+		template <typename T>
+		auto get(lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_get<T>(L, index, tracking)) {
+#if SOL_IS_ON(SOL_SAFE_GETTER)
+			static constexpr bool is_op = meta::is_optional_v<T>;
+			if constexpr (is_op) {
+				return stack_detail::unchecked_get<T>(L, index, tracking);
+			}
+			else {
+				if (is_lua_reference<T>::value) {
+					return stack_detail::unchecked_get<T>(L, index, tracking);
+				}
+				auto op = check_get<T>(L, index, type_panic_c_str, tracking);
+				return *std::move(op);
+			}
+#else
+			return stack_detail::unchecked_get<T>(L, index, tracking);
+#endif
+		}
+
+		template <typename T>
+		decltype(auto) get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			record tracking {};
+			return get<T>(L, index, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) get_usertype(lua_State* L, int index, record& tracking) {
+			using UT = meta::conditional_t<std::is_pointer<T>::value, detail::as_pointer_tag<std::remove_pointer_t<T>>, detail::as_value_tag<T>>;
+			return get<UT>(L, index, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) get_usertype(lua_State* L, int index = -lua_size_v<meta::unqualified_t<T>>) {
+			record tracking {};
+			return get_usertype<T>(L, index, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) pop(lua_State* L) {
+			return popper<T> {}.pop(L);
+		}
+
+		template <bool global = false, bool raw = false, typename Key>
+		void get_field(lua_State* L, Key&& key) {
+			field_getter<meta::unqualified_t<Key>, global, raw> {}.get(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, bool raw = false, typename Key>
+		void get_field(lua_State* L, Key&& key, int tableindex) {
+			field_getter<meta::unqualified_t<Key>, global, raw> {}.get(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, typename Key>
+		void raw_get_field(lua_State* L, Key&& key) {
+			get_field<global, true>(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, typename Key>
+		void raw_get_field(lua_State* L, Key&& key, int tableindex) {
+			get_field<global, true>(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_get_field(lua_State* L, Key&& key) {
+			return probe_field_getter<meta::unqualified_t<Key>, C, global, raw> {}.get(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_get_field(lua_State* L, Key&& key, int tableindex) {
+			return probe_field_getter<meta::unqualified_t<Key>, C, global, raw> {}.get(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_raw_get_field(lua_State* L, Key&& key) {
+			return probe_get_field<global, true, C>(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_raw_get_field(lua_State* L, Key&& key, int tableindex) {
+			return probe_get_field<global, true, C>(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, bool raw = false, typename Key, typename Value>
+		void set_field(lua_State* L, Key&& key, Value&& value) {
+			field_setter<meta::unqualified_t<Key>, global, raw> {}.set(L, std::forward<Key>(key), std::forward<Value>(value));
+		}
+
+		template <bool global = false, bool raw = false, typename Key, typename Value>
+		void set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
+			field_setter<meta::unqualified_t<Key>, global, raw> {}.set(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
+		}
+
+		template <bool global = false, typename Key, typename Value>
+		void raw_set_field(lua_State* L, Key&& key, Value&& value) {
+			set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value));
+		}
+
+		template <bool global = false, typename Key, typename Value>
+		void raw_set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
+			set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
+		}
+
+		template <typename T, typename F>
+		void modify_unique_usertype_as(const stack_reference& obj, F&& f) {
+			void* raw = lua_touserdata(obj.lua_state(), obj.stack_index());
+			void* ptr_memory = detail::align_usertype_pointer(raw);
+			void* uu_memory = detail::align_usertype_unique<T>(raw);
+			T& uu = *static_cast<T*>(uu_memory);
+			f(uu);
+			*static_cast<void**>(ptr_memory) = static_cast<void*>(detail::unique_get(obj.lua_state(), uu));
+		}
+
+		template <typename F>
+		void modify_unique_usertype(const stack_reference& obj, F&& f) {
+			using bt = meta::bind_traits<meta::unqualified_t<F>>;
+			using T = typename bt::template arg_at<0>;
+			using Tu = meta::unqualified_t<T>;
+			modify_unique_usertype_as<Tu>(obj, std::forward<F>(f));
+		}
+
+		namespace stack_detail {
+			template <typename T, typename Handler>
+			decltype(auto) check_get_arg(lua_State* L_, int index_, Handler&& handler_, record& tracking_) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_check_access_v<T>) {
+					sol_lua_check_access(types<meta::unqualified_t<T>>(), L_, index_, tracking_);
+				}
+				return check_get<T>(L_, index_, std::forward<Handler>(handler_), tracking_);
+			}
+
+			template <typename T>
+			decltype(auto) unchecked_get_arg(lua_State* L_, int index_, record& tracking_) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_check_access_v<T>) {
+					sol_lua_check_access(types<meta::unqualified_t<T>>(), L_, index_, tracking_);
+				}
+				return unchecked_get<T>(L_, index_, tracking_);
+			}
+		} // namespace stack_detail
+
+	} // namespace stack
+
+	namespace detail {
+
+		template <typename T>
+		lua_CFunction make_destructor(std::true_type) {
+			if constexpr (is_unique_usertype_v<T>) {
+				return &unique_destroy<T>;
+			}
+			else if constexpr (!std::is_pointer_v<T>) {
+				return &usertype_alloc_destroy<T>;
+			}
+			else {
+				return &cannot_destroy<T>;
+			}
+		}
+
+		template <typename T>
+		lua_CFunction make_destructor(std::false_type) {
+			return &cannot_destroy<T>;
+		}
+
+		template <typename T>
+		lua_CFunction make_destructor() {
+			return make_destructor<T>(std::is_destructible<T>());
+		}
+
+		struct no_comp {
+			template <typename A, typename B>
+			bool operator()(A&&, B&&) const {
+				return false;
+			}
+		};
+
+		template <typename T>
+		int is_check(lua_State* L) {
+			return stack::push(L, stack::check<T>(L, 1, &no_panic));
+		}
+
+		template <typename T>
+		int member_default_to_string(std::true_type, lua_State* L) {
+			decltype(auto) ts = stack::get<T>(L, 1).to_string();
+			return stack::push(L, std::forward<decltype(ts)>(ts));
+		}
+
+		template <typename T>
+		int member_default_to_string(std::false_type, lua_State* L) {
+			return luaL_error(L,
+			     "cannot perform to_string on '%s': no 'to_string' overload in namespace, 'to_string' member "
+			     "function, or operator<<(ostream&, ...) present",
+			     detail::demangle<T>().data());
+		}
+
+		template <typename T>
+		int adl_default_to_string(std::true_type, lua_State* L) {
+			using namespace std;
+			decltype(auto) ts = to_string(stack::get<T>(L, 1));
+			return stack::push(L, std::forward<decltype(ts)>(ts));
+		}
+
+		template <typename T>
+		int adl_default_to_string(std::false_type, lua_State* L) {
+			return member_default_to_string<T>(meta::supports_to_string_member<T>(), L);
+		}
+
+		template <typename T>
+		int oss_default_to_string(std::true_type, lua_State* L) {
+			std::ostringstream oss;
+			oss << stack::unqualified_get<T>(L, 1);
+			return stack::push(L, oss.str());
+		}
+
+		template <typename T>
+		int oss_default_to_string(std::false_type, lua_State* L) {
+			return adl_default_to_string<T>(meta::supports_adl_to_string<T>(), L);
+		}
+
+		template <typename T>
+		int default_to_string(lua_State* L) {
+			return oss_default_to_string<T>(meta::supports_op_left_shift<std::ostream, T>(), L);
+		}
+
+		template <typename T>
+		int default_size(lua_State* L) {
+			decltype(auto) self = stack::unqualified_get<T>(L, 1);
+			return stack::push(L, self.size());
+		}
+
+		template <typename T, typename Op>
+		int comparsion_operator_wrap(lua_State* L) {
+			if constexpr (std::is_void_v<T>) {
+				return stack::push(L, false);
+			}
+			else {
+				auto maybel = stack::unqualified_check_get<T>(L, 1);
+				if (!maybel) {
+					return stack::push(L, false);
+				}
+				auto mayber = stack::unqualified_check_get<T>(L, 2);
+				if (!mayber) {
+					return stack::push(L, false);
+				}
+				decltype(auto) l = *maybel;
+				decltype(auto) r = *mayber;
+				if constexpr (std::is_same_v<no_comp, Op>) {
+					std::equal_to<> op;
+					return stack::push(L, op(detail::ptr(l), detail::ptr(r)));
+				}
+				else {
+					if constexpr (std::is_same_v<std::equal_to<>, Op> // clang-format hack
+					     || std::is_same_v<std::less_equal<>, Op>     //
+					     || std::is_same_v<std::less_equal<>, Op>) {  //
+						if (detail::ptr(l) == detail::ptr(r)) {
+							return stack::push(L, true);
+						}
+					}
+					Op op;
+					return stack::push(L, op(detail::deref(l), detail::deref(r)));
+				}
+			}
+		}
+
+		template <typename T, typename IFx, typename Fx>
+		void insert_default_registrations(IFx&& ifx, Fx&& fx);
+
+		template <typename T, bool, bool>
+		struct get_is_primitive : is_lua_primitive<T> { };
+
+		template <typename T>
+		struct get_is_primitive<T, true, false>
+		: meta::neg<std::is_reference<decltype(sol_lua_get(types<T>(), nullptr, -1, std::declval<stack::record&>()))>> { };
+
+		template <typename T>
+		struct get_is_primitive<T, false, true>
+		: meta::neg<std::is_reference<decltype(sol_lua_get(types<meta::unqualified_t<T>>(), nullptr, -1, std::declval<stack::record&>()))>> { };
+
+		template <typename T>
+		struct get_is_primitive<T, true, true> : get_is_primitive<T, true, false> { };
+
+	} // namespace detail
+
+	template <typename T>
+	struct is_proxy_primitive
+	: detail::get_is_primitive<T, meta::meta_detail::is_adl_sol_lua_get_v<T>, meta::meta_detail::is_adl_sol_lua_get_v<meta::unqualified_t<T>>> { };
+
+} // namespace sol
+
+// end of sol/stack_core.hpp
+
+// beginning of sol/stack_check.hpp
+
+// beginning of sol/stack_check_unqualified.hpp
+
+#include <memory>
+#include <functional>
+#include <utility>
+#include <cmath>
+#include <optional>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // variant shenanigans
+
+namespace sol { namespace stack {
+	template <typename Handler>
+	bool loose_table_check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+		tracking.use(1);
+		type t = type_of(L_, index);
+		if (t == type::table) {
+			return true;
+		}
+		if (t != type::userdata) {
+			handler(L_, index, type::table, t, "value is not a table or a userdata that can behave like one");
+			return false;
+		}
+		return true;
+	}
+
+	namespace stack_detail {
+		inline bool impl_check_metatable(lua_State* L_, int index, const std::string& metakey, bool poptable) {
+			luaL_getmetatable(L_, &metakey[0]);
+			const type expectedmetatabletype = static_cast<type>(lua_type(L_, -1));
+			if (expectedmetatabletype != type::lua_nil) {
+				if (lua_rawequal(L_, -1, index) == 1) {
+					lua_pop(L_, 1 + static_cast<int>(poptable));
+					return true;
+				}
+			}
+			lua_pop(L_, 1);
+			return false;
+		}
+
+		template <typename T, bool poptable = true>
+		inline bool check_metatable(lua_State* L_, int index = -2) {
+			return impl_check_metatable(L_, index, usertype_traits<T>::metatable(), poptable);
+		}
+
+		template <type expected, int (*check_func)(lua_State*, int)>
+		struct basic_check {
+			template <typename Handler>
+			static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+				tracking.use(1);
+				bool success = check_func(L_, index) == 1;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, expected, type_of(L_, index), "");
+				}
+				return success;
+			}
+		};
+	} // namespace stack_detail
+
+	template <typename T, typename>
+	struct unqualified_interop_checker {
+		template <typename Handler>
+		static bool check(lua_State*, int, type, Handler&&, record&) {
+			return false;
+		}
+	};
+
+	template <typename T, typename>
+	struct qualified_interop_checker {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, type index_type, Handler&& handler, record& tracking) {
+			return stack_detail::unqualified_interop_check<T>(L_, index, index_type, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename T, type expected, typename>
+	struct unqualified_checker {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			if constexpr (std::is_same_v<T, bool>) {
+				tracking.use(1);
+				bool success = lua_isboolean(L_, index) == 1;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, expected, type_of(L_, index), "");
+				}
+				return success;
+			}
+			else if constexpr (meta::any_same_v<T,
+				                   char
+#if SOL_IS_ON(SOL_CHAR8_T)
+				                   ,
+				                   char8_t
+#endif
+				                   ,
+				                   char16_t,
+				                   char32_t>) {
+				return stack::check<std::basic_string<T>>(L_, index, std::forward<Handler>(handler), tracking);
+			}
+			else if constexpr (std::is_integral_v<T> || std::is_same_v<T, lua_Integer>) {
+				tracking.use(1);
+#if SOL_LUA_VERSION_I_ >= 503
+				// Lua 5.3 and greater checks for numeric precision
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS)
+				// imprecise, sloppy conversions
+				int isnum = 0;
+				lua_tointegerx(L_, index, &isnum);
+				const bool success = isnum != 0;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_or_number_string_integral);
+				}
+#elif SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+				// this check is precise, do not convert
+				if (lua_isinteger(L_, index) == 1) {
+					return true;
+				}
+				const bool success = false;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_integral);
+				}
+#else
+				// Numerics are neither safe nor string-convertible
+				type t = type_of(L_, index);
+				const bool success = t == type::number;
+#endif
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number);
+				}
+				return success;
+#else
+				// Lua 5.2 and below checks
+#if SOL_IS_OFF(SOL_STRINGS_ARE_NUMBERS)
+				// must pre-check, because it will convert
+				type t = type_of(L_, index);
+				if (t != type::number) {
+					// expected type, actual type
+					handler(L_, index, type::number, t, detail::not_a_number);
+					return false;
+				}
+#endif // Do not allow strings to be numbers
+
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+				int isnum = 0;
+				const lua_Number v = lua_tonumberx(L_, index, &isnum);
+				const bool success = isnum != 0 && static_cast<lua_Number>(llround(v)) == v;
+#else
+				const bool success = true;
+#endif // Safe numerics and number precision checking
+				if (!success) {
+					// Use defines to provide a better error message!
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS)
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_or_number_string);
+#elif SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+					handler(L_, index, type::number, t, detail::not_a_number_or_number_string);
+#else
+					handler(L_, index, type::number, t, detail::not_a_number);
+#endif
+				}
+				return success;
+#endif
+			}
+			else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+				tracking.use(1);
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS)
+				bool success = lua_isnumber(L_, index) == 1;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_or_number_string);
+				}
+				return success;
+#else
+				type t = type_of(L_, index);
+				bool success = t == type::number;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, t, detail::not_a_number);
+				}
+				return success;
+#endif // Strings are Numbers
+			}
+			else if constexpr (meta::any_same_v<T, type, this_state, this_main_state, this_environment, variadic_args>) {
+				(void)L_;
+				(void)index;
+				(void)handler;
+				tracking.use(0);
+				return true;
+			}
+			else if constexpr (is_unique_usertype_v<T>) {
+				using element = unique_usertype_element_t<T>;
+				using actual = unique_usertype_actual_t<T>;
+				const type indextype = type_of(L_, index);
+				tracking.use(1);
+				if (indextype != type::userdata) {
+					handler(L_, index, type::userdata, indextype, "value is not a userdata");
+					return false;
+				}
+				if (lua_getmetatable(L_, index) == 0) {
+					return true;
+				}
+				int metatableindex = lua_gettop(L_);
+				if (stack_detail::check_metatable<d::u<element>>(L_, metatableindex)) {
+					void* memory = lua_touserdata(L_, index);
+					memory = detail::align_usertype_unique_destructor(memory);
+					detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+					bool success = &detail::usertype_unique_alloc_destroy<element, actual> == pdx;
+					if (!success) {
+						memory = detail::align_usertype_unique_tag<true>(memory);
+#if 0
+						// New version, one day
+#else
+						const char*& name_tag = *static_cast<const char**>(memory);
+						success = usertype_traits<T>::qualified_name() == name_tag;
+#endif
+						if (!success) {
+							handler(L_, index, type::userdata, indextype, "value is a userdata but is not the correct unique usertype");
+						}
+					}
+					return success;
+				}
+				lua_pop(L_, 1);
+				handler(L_, index, type::userdata, indextype, "unrecognized userdata (not pushed by sol?)");
+				return false;
+			}
+			else if constexpr (meta::any_same_v<T, lua_nil_t, std::nullopt_t, nullopt_t>) {
+				bool success = lua_isnil(L_, index);
+				if (success) {
+					tracking.use(1);
+					return success;
+				}
+				tracking.use(0);
+				success = lua_isnone(L_, index);
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, expected, type_of(L_, index), "");
+				}
+				return success;
+			}
+			else if constexpr (std::is_same_v<T, env_key_t>) {
+				tracking.use(1);
+				type t = type_of(L_, index);
+				if (t == type::table || t == type::none || t == type::lua_nil || t == type::userdata) {
+					return true;
+				}
+				handler(L_, index, type::table, t, "value cannot not have a valid environment");
+				return true;
+			}
+			else if constexpr (std::is_same_v<T, detail::non_lua_nil_t>) {
+				return !stack::unqualified_check<lua_nil_t>(L_, index, std::forward<Handler>(handler), tracking);
+			}
+			else if constexpr (meta::is_specialization_of_v<T, basic_lua_table>) {
+				tracking.use(1);
+				type t = type_of(L_, index);
+				if (t != type::table) {
+					handler(L_, index, type::table, t, "value is not a table");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (meta::is_specialization_of_v<T, basic_bytecode>) {
+				tracking.use(1);
+				type t = type_of(L_, index);
+				if (t != type::function) {
+					handler(L_, index, type::function, t, "value is not a function that can be dumped");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (meta::is_specialization_of_v<T, basic_environment>) {
+				tracking.use(1);
+				if (lua_getmetatable(L_, index) == 0) {
+					return true;
+				}
+				type t = type_of(L_, -1);
+				if (t == type::table || t == type::none || t == type::lua_nil) {
+					lua_pop(L_, 1);
+					return true;
+				}
+				if (t != type::userdata) {
+					lua_pop(L_, 1);
+					handler(L_, index, type::table, t, "value does not have a valid metatable");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (std::is_same_v<T, metatable_key_t>) {
+				tracking.use(1);
+				if (lua_getmetatable(L_, index) == 0) {
+					return true;
+				}
+				type t = type_of(L_, -1);
+				if (t == type::table || t == type::none || t == type::lua_nil) {
+					lua_pop(L_, 1);
+					return true;
+				}
+				if (t != type::userdata) {
+					lua_pop(L_, 1);
+					handler(L_, index, expected, t, "value does not have a valid metatable");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (std::is_same_v<T, luaL_Stream*> || std::is_same_v<T, luaL_Stream>) {
+				if (lua_getmetatable(L_, index) == 0) {
+					type t = type_of(L_, index);
+					handler(L_, index, expected, t, "value is not a valid luaL_Stream (has no metatable/is not a valid value)");
+					return false;
+				}
+				luaL_getmetatable(L_, LUA_FILEHANDLE);
+				if (type_of(L_, index) != type::table) {
+					type t = type_of(L_, index);
+					lua_pop(L_, 1);
+					handler(L_,
+						index,
+						expected,
+						t,
+						"value is not a valid luaL_Stream (there is no metatable for luaL_Stream -- did you forget to "
+						"my_lua_state.open_libraries(sol::lib::state) or equivalent?)");
+					return false;
+				}
+				int is_stream_table = lua_compare(L_, -1, -2, LUA_OPEQ);
+				lua_pop(L_, 2);
+				if (is_stream_table == 0) {
+					type t = type_of(L_, index);
+					handler(L_, index, expected, t, "value is not a valid luaL_Stream (incorrect metatable)");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (meta::is_optional_v<T>) {
+				using ValueType = typename T::value_type;
+				(void)handler;
+				type t = type_of(L_, index);
+				if (t == type::none) {
+					tracking.use(0);
+					return true;
+				}
+				if (t == type::lua_nil) {
+					tracking.use(1);
+					return true;
+				}
+				return stack::unqualified_check<ValueType>(L_, index, &no_panic, tracking);
+			}
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+			else if constexpr (std::is_function_v<T> || (std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>)) {
+				return stack_detail::check_function_pointer<std::remove_pointer_t<T>>(L_, index, std::forward<Handler>(handler), tracking);
+			}
+#endif
+			else if constexpr (expected == type::userdata) {
+				if constexpr (meta::any_same_v<T, userdata_value> || meta::is_specialization_of_v<T, basic_userdata>) {
+					tracking.use(1);
+					type t = type_of(L_, index);
+					bool success = t == type::userdata;
+					if (!success) {
+						// expected type, actual type
+						handler(L_, index, type::userdata, t, "");
+					}
+					return success;
+				}
+				else if constexpr (meta::is_specialization_of_v<T, user>) {
+					unqualified_checker<lightuserdata_value, type::userdata> c;
+					(void)c;
+					return c.check(L_, index, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					if constexpr (std::is_pointer_v<T>) {
+						return check_usertype<T>(L_, index, std::forward<Handler>(handler), tracking);
+					}
+					else if constexpr (meta::is_specialization_of_v<T, std::reference_wrapper>) {
+						using T_internal = typename T::type;
+						return stack::check<T_internal>(L_, index, std::forward<Handler>(handler), tracking);
+					}
+					else {
+						return check_usertype<T>(L_, index, std::forward<Handler>(handler), tracking);
+					}
+				}
+			}
+			else if constexpr (expected == type::poly) {
+				tracking.use(1);
+				bool success = is_lua_reference_v<T> || !lua_isnone(L_, index);
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::poly, type_of(L_, index), "");
+				}
+				return success;
+			}
+			else if constexpr (expected == type::lightuserdata) {
+				tracking.use(1);
+				type t = type_of(L_, index);
+				bool success = t == type::userdata || t == type::lightuserdata;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::lightuserdata, t, "");
+				}
+				return success;
+			}
+			else if constexpr (expected == type::function) {
+				if constexpr (meta::any_same_v<T, lua_CFunction, std::remove_pointer_t<lua_CFunction>, c_closure>) {
+					tracking.use(1);
+					bool success = lua_iscfunction(L_, index) == 1;
+					if (!success) {
+						// expected type, actual type
+						handler(L_, index, expected, type_of(L_, index), "");
+					}
+					return success;
+				}
+				else {
+					tracking.use(1);
+					type t = type_of(L_, index);
+					if (t == type::lua_nil || t == type::none || t == type::function) {
+						// allow for lua_nil to be returned
+						return true;
+					}
+					if (t != type::userdata && t != type::table) {
+						handler(L_, index, type::function, t, "must be a function or table or a userdata");
+						return false;
+					}
+					// Do advanced check for call-style userdata?
+					static const auto& callkey = to_string(meta_function::call);
+					if (lua_getmetatable(L_, index) == 0) {
+						// No metatable, no __call key possible
+						handler(L_, index, type::function, t, "value is not a function and does not have overriden metatable");
+						return false;
+					}
+					if (lua_isnoneornil(L_, -1)) {
+						lua_pop(L_, 1);
+						handler(L_, index, type::function, t, "value is not a function and does not have valid metatable");
+						return false;
+					}
+					lua_getfield(L_, -1, &callkey[0]);
+					if (lua_isnoneornil(L_, -1)) {
+						lua_pop(L_, 2);
+						handler(L_, index, type::function, t, "value's metatable does not have __call overridden in metatable, cannot call this type");
+						return false;
+					}
+					// has call, is definitely a function
+					lua_pop(L_, 2);
+					return true;
+				}
+			}
+			else if constexpr (expected == type::table) {
+				return stack::loose_table_check(L_, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				tracking.use(1);
+				const type indextype = type_of(L_, index);
+				bool success = expected == indextype;
+				if (!success) {
+					// expected type, actual type, message
+					handler(L_, index, expected, indextype, "");
+				}
+				return success;
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_checker<non_null<T>, type::userdata> : unqualified_checker<T, lua_type_of_v<T>> { };
+
+	template <typename T>
+	struct unqualified_checker<detail::as_value_tag<T>, type::userdata> {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			const type indextype = type_of(L_, index);
+			return check(types<T>(), L_, index, indextype, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename U, typename Handler>
+		static bool check(types<U>, lua_State* L_, int index, type indextype, Handler&& handler, record& tracking) {
+			if constexpr (
+				std::is_same_v<T,
+				     lightuserdata_value> || std::is_same_v<T, userdata_value> || std::is_same_v<T, userdata> || std::is_same_v<T, lightuserdata>) {
+				tracking.use(1);
+				if (indextype != type::userdata) {
+					handler(L_, index, type::userdata, indextype, "value is not a valid userdata");
+					return false;
+				}
+				return true;
+			}
+			else {
+#if SOL_IS_ON(SOL_USE_INTEROP)
+				if (stack_detail::interop_check<U>(L_, index, indextype, handler, tracking)) {
+					return true;
+				}
+#endif // interop extensibility
+				tracking.use(1);
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+				if (lua_iscfunction(L_, index) != 0) {
+					// a potential match...
+					return true;
+				}
+#endif
+				if (indextype != type::userdata) {
+					handler(L_, index, type::userdata, indextype, "value is not a valid userdata");
+					return false;
+				}
+				if (lua_getmetatable(L_, index) == 0) {
+					return true;
+				}
+				int metatableindex = lua_gettop(L_);
+				if (stack_detail::check_metatable<U>(L_, metatableindex))
+					return true;
+				if (stack_detail::check_metatable<U*>(L_, metatableindex))
+					return true;
+				if (stack_detail::check_metatable<d::u<U>>(L_, metatableindex))
+					return true;
+				if (stack_detail::check_metatable<as_container_t<U>>(L_, metatableindex))
+					return true;
+				bool success = false;
+				bool has_derived = derive<T>::value || weak_derive<T>::value;
+				if (has_derived) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+					luaL_checkstack(L_, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+					auto pn = stack::pop_n(L_, 1);
+					lua_pushstring(L_, &detail::base_class_check_key()[0]);
+					lua_rawget(L_, metatableindex);
+					if (type_of(L_, -1) != type::lua_nil) {
+						void* basecastdata = lua_touserdata(L_, -1);
+						detail::inheritance_check_function ic = reinterpret_cast<detail::inheritance_check_function>(basecastdata);
+						success = ic(usertype_traits<T>::qualified_name());
+					}
+				}
+				lua_pop(L_, 1);
+				if (!success) {
+					handler(L_, index, type::userdata, indextype, "value at this index does not properly reflect the desired type");
+					return false;
+				}
+				return true;
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_checker<detail::as_pointer_tag<T>, type::userdata> {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, type indextype, Handler&& handler, record& tracking) {
+			if (indextype == type::lua_nil) {
+				tracking.use(1);
+				return true;
+			}
+			return check_usertype<std::remove_pointer_t<T>>(L_, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			const type indextype = type_of(L_, index);
+			return check(L_, index, indextype, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename... Args>
+	struct unqualified_checker<std::tuple<Args...>, type::poly> {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			return stack::multi_check<Args...>(L_, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename A, typename B>
+	struct unqualified_checker<std::pair<A, B>, type::poly> {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			return stack::multi_check<A, B>(L_, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+
+	template <typename... Tn>
+	struct unqualified_checker<std::variant<Tn...>, type::poly> {
+		typedef std::variant<Tn...> V;
+		typedef std::variant_size<V> V_size;
+		typedef std::integral_constant<bool, V_size::value == 0> V_is_empty;
+
+		template <typename Handler>
+		static bool is_one(std::integral_constant<std::size_t, 0>, lua_State* L_, int index, Handler&& handler, record& tracking) {
+			if constexpr (V_is_empty::value) {
+				if (lua_isnone(L_, index)) {
+					return true;
+				}
+			}
+			tracking.use(1);
+			handler(L_, index, type::poly, type_of(L_, index), "value does not fit any type present in the variant");
+			return false;
+		}
+
+		template <std::size_t I, typename Handler>
+		static bool is_one(std::integral_constant<std::size_t, I>, lua_State* L_, int index, Handler&& handler, record& tracking) {
+			typedef std::variant_alternative_t<I - 1, V> T;
+			record temp_tracking = tracking;
+			if (stack::check<T>(L_, index, &no_panic, temp_tracking)) {
+				tracking = temp_tracking;
+				return true;
+			}
+			return is_one(std::integral_constant<std::size_t, I - 1>(), L_, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			return is_one(std::integral_constant<std::size_t, V_size::value>(), L_, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+#endif // variant shenanigans
+
+}} // namespace sol::stack
+
+// end of sol/stack_check_unqualified.hpp
+
+// beginning of sol/stack_check_qualified.hpp
+
+namespace sol { namespace stack {
+
+	template <typename X, type expected, typename>
+	struct qualified_checker {
+		template <typename Handler>
+		static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using no_cv_X = meta::unqualified_t<X>;
+			if constexpr (!std::is_reference_v<X> && is_unique_usertype_v<no_cv_X>) {
+				using element = unique_usertype_element_t<no_cv_X>;
+				if constexpr (is_actual_type_rebindable_for_v<no_cv_X>) {
+					using rebound_actual_type = unique_usertype_rebind_actual_t<no_cv_X>;
+					// we have a unique pointer type that can be
+					// rebound to a base/derived type
+					const type indextype = type_of(L, index);
+					tracking.use(1);
+					if (indextype != type::userdata) {
+						handler(L, index, type::userdata, indextype, "value is not a userdata");
+						return false;
+					}
+					void* memory = lua_touserdata(L, index);
+					memory = detail::align_usertype_unique_destructor(memory);
+					detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+					if (&detail::usertype_unique_alloc_destroy<element, no_cv_X> == pdx) {
+						return true;
+					}
+					if constexpr (derive<element>::value) {
+						memory = detail::align_usertype_unique_tag<true, false>(memory);
+						detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory);
+						string_view ti = usertype_traits<element>::qualified_name();
+						string_view rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+						if (ic(nullptr, nullptr, ti, rebind_ti) != 0) {
+							return true;
+						}
+					}
+					handler(L, index, type::userdata, indextype, "value is a userdata but is not the correct unique usertype");
+					return false;
+				}
+				else {
+					return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+				}
+			}
+			else if constexpr (!std::is_reference_v<X> && is_container_v<no_cv_X>) {
+				if (type_of(L, index) == type::userdata) {
+					return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					return stack::unqualified_check<nested<X>>(L, index, std::forward<Handler>(handler), tracking);
+				}
+			}
+			else if constexpr (!std::is_reference_v<X> && meta::is_specialization_of_v<X, nested>) {
+				using NestedX = typename meta::unqualified_t<X>::nested_type;
+				return stack::check<NestedX>(L, index, ::std::forward<Handler>(handler), tracking);
+			}
+			else {
+				return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+	};
+}} // namespace sol::stack
+
+// end of sol/stack_check_qualified.hpp
+
+// end of sol/stack_check.hpp
+
+// beginning of sol/stack_get.hpp
+
+// beginning of sol/stack_get_unqualified.hpp
+
+// beginning of sol/overload.hpp
+
+#include <utility>
+
+namespace sol {
+	template <typename... Functions>
+	struct overload_set {
+		std::tuple<Functions...> functions;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<overload_set, meta::unqualified_t<Arg>>> = meta::enabler>
+		overload_set(Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+		overload_set(const overload_set&) = default;
+		overload_set(overload_set&&) = default;
+		overload_set& operator=(const overload_set&) = default;
+		overload_set& operator=(overload_set&&) = default;
+	};
+
+	template <typename... Args>
+	decltype(auto) overload(Args&&... args) {
+		return overload_set<std::decay_t<Args>...>(std::forward<Args>(args)...);
+	}
+} // namespace sol
+
+// end of sol/overload.hpp
+
+// beginning of sol/unicode.hpp
+
+#include <array>
+#include <cstring>
+
+namespace sol {
+	// Everything here was lifted pretty much straight out of
+	// ogonek, because fuck figuring it out=
+	namespace unicode {
+		enum class error_code {
+			ok = 0,
+			invalid_code_point,
+			invalid_code_unit,
+			invalid_leading_surrogate,
+			invalid_trailing_surrogate,
+			sequence_too_short,
+			overlong_sequence,
+		};
+
+		inline const string_view& to_string(error_code ec) {
+			static const string_view storage[7] = { "ok",
+				"invalid code points",
+				"invalid code unit",
+				"invalid leading surrogate",
+				"invalid trailing surrogate",
+				"sequence too short",
+				"overlong sequence" };
+			return storage[static_cast<std::size_t>(ec)];
+		}
+
+		template <typename It>
+		struct decoded_result {
+			error_code error;
+			char32_t codepoint;
+			It next;
+		};
+
+		template <typename C>
+		struct encoded_result {
+			error_code error;
+			std::size_t code_units_size;
+			std::array<C, 4> code_units;
+		};
+
+		struct unicode_detail {
+			// codepoint related
+			static constexpr char32_t last_code_point = 0x10FFFF;
+
+			static constexpr char32_t first_lead_surrogate = 0xD800;
+			static constexpr char32_t last_lead_surrogate = 0xDBFF;
+
+			static constexpr char32_t first_trail_surrogate = 0xDC00;
+			static constexpr char32_t last_trail_surrogate = 0xDFFF;
+
+			static constexpr char32_t first_surrogate = first_lead_surrogate;
+			static constexpr char32_t last_surrogate = last_trail_surrogate;
+
+			static constexpr bool is_lead_surrogate(char32_t u) {
+				return u >= first_lead_surrogate && u <= last_lead_surrogate;
+			}
+			static constexpr bool is_trail_surrogate(char32_t u) {
+				return u >= first_trail_surrogate && u <= last_trail_surrogate;
+			}
+			static constexpr bool is_surrogate(char32_t u) {
+				return u >= first_surrogate && u <= last_surrogate;
+			}
+
+			// utf8 related
+			static constexpr auto last_1byte_value = 0x7Fu;
+			static constexpr auto last_2byte_value = 0x7FFu;
+			static constexpr auto last_3byte_value = 0xFFFFu;
+
+			static constexpr auto start_2byte_mask = 0x80u;
+			static constexpr auto start_3byte_mask = 0xE0u;
+			static constexpr auto start_4byte_mask = 0xF0u;
+
+			static constexpr auto continuation_mask = 0xC0u;
+			static constexpr auto continuation_signature = 0x80u;
+
+			static constexpr bool is_invalid(unsigned char b) {
+				return b == 0xC0 || b == 0xC1 || b > 0xF4;
+			}
+
+			static constexpr bool is_continuation(unsigned char b) {
+				return (b & unicode_detail::continuation_mask) == unicode_detail::continuation_signature;
+			}
+
+			static constexpr bool is_overlong(char32_t u, std::size_t bytes) {
+				return u <= unicode_detail::last_1byte_value || (u <= unicode_detail::last_2byte_value && bytes > 2)
+				     || (u <= unicode_detail::last_3byte_value && bytes > 3);
+			}
+
+			static constexpr int sequence_length(unsigned char b) {
+				return (b & start_2byte_mask) == 0                ? 1
+				     : (b & start_3byte_mask) != start_3byte_mask ? 2
+				     : (b & start_4byte_mask) != start_4byte_mask ? 3
+				                                                  : 4;
+			}
+
+			static constexpr char32_t decode(unsigned char b0, unsigned char b1) {
+				return (static_cast<char32_t>((b0 & 0x1Fu) << 6u) | static_cast<char32_t>(b1 & 0x3Fu));
+			}
+			static constexpr char32_t decode(unsigned char b0, unsigned char b1, unsigned char b2) {
+				return static_cast<char32_t>((b0 & 0x0Fu) << 12u) | static_cast<char32_t>((b1 & 0x3Fu) << 6u) | static_cast<char32_t>(b2 & 0x3Fu);
+			}
+			static constexpr char32_t decode(unsigned char b0, unsigned char b1, unsigned char b2, unsigned char b3) {
+				return static_cast<char32_t>(static_cast<char32_t>((b0 & 0x07u) << 18u) | static_cast<char32_t>((b1 & 0x3F) << 12)
+				     | static_cast<char32_t>((b2 & 0x3Fu) << 6u) | static_cast<char32_t>(b3 & 0x3Fu));
+			}
+
+			// utf16 related
+			static constexpr char32_t last_bmp_value = 0xFFFF;
+			static constexpr char32_t normalizing_value = 0x10000;
+			static constexpr int lead_surrogate_bitmask = 0xFFC00;
+			static constexpr int trail_surrogate_bitmask = 0x3FF;
+			static constexpr int lead_shifted_bits = 10;
+			static constexpr char32_t replacement = 0xFFFD;
+
+			static char32_t combine_surrogates(char16_t lead, char16_t trail) {
+				auto hi = lead - first_lead_surrogate;
+				auto lo = trail - first_trail_surrogate;
+				return normalizing_value + ((hi << lead_shifted_bits) | lo);
+			}
+		};
+
+		inline encoded_result<char> code_point_to_utf8(char32_t codepoint) {
+			encoded_result<char> er;
+			er.error = error_code::ok;
+			if (codepoint <= unicode_detail::last_1byte_value) {
+				er.code_units_size = 1;
+				er.code_units = std::array<char, 4> { { static_cast<char>(codepoint) } };
+			}
+			else if (codepoint <= unicode_detail::last_2byte_value) {
+				er.code_units_size = 2;
+				er.code_units = std::array<char, 4> { {
+					static_cast<char>(0xC0 | ((codepoint & 0x7C0) >> 6)),
+					static_cast<char>(0x80 | (codepoint & 0x3F)),
+				} };
+			}
+			else if (codepoint <= unicode_detail::last_3byte_value) {
+				er.code_units_size = 3;
+				er.code_units = std::array<char, 4> { {
+					static_cast<char>(0xE0 | ((codepoint & 0xF000) >> 12)),
+					static_cast<char>(0x80 | ((codepoint & 0xFC0) >> 6)),
+					static_cast<char>(0x80 | (codepoint & 0x3F)),
+				} };
+			}
+			else {
+				er.code_units_size = 4;
+				er.code_units = std::array<char, 4> { {
+					static_cast<char>(0xF0 | ((codepoint & 0x1C0000) >> 18)),
+					static_cast<char>(0x80 | ((codepoint & 0x3F000) >> 12)),
+					static_cast<char>(0x80 | ((codepoint & 0xFC0) >> 6)),
+					static_cast<char>(0x80 | (codepoint & 0x3F)),
+				} };
+			}
+			return er;
+		}
+
+		inline encoded_result<char16_t> code_point_to_utf16(char32_t codepoint) {
+			encoded_result<char16_t> er;
+
+			if (codepoint <= unicode_detail::last_bmp_value) {
+				er.code_units_size = 1;
+				er.code_units = std::array<char16_t, 4> { { static_cast<char16_t>(codepoint) } };
+				er.error = error_code::ok;
+			}
+			else {
+				auto normal = codepoint - unicode_detail::normalizing_value;
+				auto lead = unicode_detail::first_lead_surrogate + ((normal & unicode_detail::lead_surrogate_bitmask) >> unicode_detail::lead_shifted_bits);
+				auto trail = unicode_detail::first_trail_surrogate + (normal & unicode_detail::trail_surrogate_bitmask);
+				er.code_units = std::array<char16_t, 4> { { static_cast<char16_t>(lead), static_cast<char16_t>(trail) } };
+				er.code_units_size = 2;
+				er.error = error_code::ok;
+			}
+			return er;
+		}
+
+		inline encoded_result<char32_t> code_point_to_utf32(char32_t codepoint) {
+			encoded_result<char32_t> er;
+			er.code_units_size = 1;
+			er.code_units[0] = codepoint;
+			er.error = error_code::ok;
+			return er;
+		}
+
+		template <typename It>
+		inline decoded_result<It> utf8_to_code_point(It it, It last) {
+			decoded_result<It> dr;
+			if (it == last) {
+				dr.next = it;
+				dr.error = error_code::sequence_too_short;
+				return dr;
+			}
+
+			unsigned char b0 = static_cast<unsigned char>(*it);
+			std::size_t length = static_cast<std::size_t>(unicode_detail::sequence_length(b0));
+
+			if (length == 1) {
+				dr.codepoint = static_cast<char32_t>(b0);
+				dr.error = error_code::ok;
+				++it;
+				dr.next = it;
+				return dr;
+			}
+
+			if (unicode_detail::is_invalid(b0) || unicode_detail::is_continuation(b0)) {
+				dr.error = error_code::invalid_code_unit;
+				dr.next = it;
+				return dr;
+			}
+
+			++it;
+			std::array<unsigned char, 4> b;
+			b[0] = b0;
+			for (std::size_t i = 1; i < length; ++i) {
+				b[i] = static_cast<unsigned char>(*it);
+				if (!unicode_detail::is_continuation(b[i])) {
+					dr.error = error_code::invalid_code_unit;
+					dr.next = it;
+					return dr;
+				}
+				++it;
+			}
+
+			char32_t decoded;
+			switch (length) {
+			case 2:
+				decoded = unicode_detail::decode(b[0], b[1]);
+				break;
+			case 3:
+				decoded = unicode_detail::decode(b[0], b[1], b[2]);
+				break;
+			default:
+				decoded = unicode_detail::decode(b[0], b[1], b[2], b[3]);
+				break;
+			}
+
+			if (unicode_detail::is_overlong(decoded, length)) {
+				dr.error = error_code::overlong_sequence;
+				return dr;
+			}
+			if (unicode_detail::is_surrogate(decoded) || decoded > unicode_detail::last_code_point) {
+				dr.error = error_code::invalid_code_point;
+				return dr;
+			}
+
+			// then everything is fine
+			dr.codepoint = decoded;
+			dr.error = error_code::ok;
+			dr.next = it;
+			return dr;
+		}
+
+		template <typename It>
+		inline decoded_result<It> utf16_to_code_point(It it, It last) {
+			decoded_result<It> dr;
+			if (it == last) {
+				dr.next = it;
+				dr.error = error_code::sequence_too_short;
+				return dr;
+			}
+
+			char16_t lead = static_cast<char16_t>(*it);
+
+			if (!unicode_detail::is_surrogate(lead)) {
+				++it;
+				dr.codepoint = static_cast<char32_t>(lead);
+				dr.next = it;
+				dr.error = error_code::ok;
+				return dr;
+			}
+			if (!unicode_detail::is_lead_surrogate(lead)) {
+				dr.error = error_code::invalid_leading_surrogate;
+				dr.next = it;
+				return dr;
+			}
+
+			++it;
+			auto trail = *it;
+			if (!unicode_detail::is_trail_surrogate(trail)) {
+				dr.error = error_code::invalid_trailing_surrogate;
+				dr.next = it;
+				return dr;
+			}
+
+			dr.codepoint = unicode_detail::combine_surrogates(lead, trail);
+			dr.next = ++it;
+			dr.error = error_code::ok;
+			return dr;
+		}
+
+		template <typename It>
+		inline decoded_result<It> utf32_to_code_point(It it, It last) {
+			decoded_result<It> dr;
+			if (it == last) {
+				dr.next = it;
+				dr.error = error_code::sequence_too_short;
+				return dr;
+			}
+			dr.codepoint = static_cast<char32_t>(*it);
+			dr.next = ++it;
+			dr.error = error_code::ok;
+			return dr;
+		}
+	} // namespace unicode
+} // namespace sol
+// end of sol/unicode.hpp
+
+#include <memory>
+#include <functional>
+#include <utility>
+#include <cstdlib>
+#include <cmath>
+#include <string_view>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // Apple clang screwed up
+
+namespace sol { namespace stack {
+
+	namespace stack_detail {
+		template <typename Ch>
+		struct count_code_units_utf {
+			std::size_t needed_size;
+
+			count_code_units_utf() : needed_size(0) {
+			}
+
+			void operator()(const unicode::encoded_result<Ch> er) {
+				needed_size += er.code_units_size;
+			}
+		};
+
+		template <typename Ch, typename ErCh>
+		struct copy_code_units_utf {
+			Ch* target_;
+
+			copy_code_units_utf(Ch* target) : target_(target) {
+			}
+
+			void operator()(const unicode::encoded_result<ErCh> er) {
+				std::memcpy(target_, er.code_units.data(), er.code_units_size * sizeof(ErCh));
+				target_ += er.code_units_size;
+			}
+		};
+
+		template <typename Ch, typename F>
+		inline void convert(const char* strb, const char* stre, F&& f) {
+			char32_t cp = 0;
+			for (const char* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf8_to_code_point(strtarget, stre);
+				if (dr.error != unicode::error_code::ok) {
+					cp = unicode::unicode_detail::replacement;
+					++strtarget;
+				}
+				else {
+					cp = dr.codepoint;
+					strtarget = dr.next;
+				}
+				if constexpr (std::is_same_v<Ch, char32_t>) {
+					auto er = unicode::code_point_to_utf32(cp);
+					f(er);
+				}
+				else {
+					auto er = unicode::code_point_to_utf16(cp);
+					f(er);
+				}
+			}
+		}
+
+		template <typename BaseCh, typename S>
+		inline S get_into(lua_State* L, int index, record& tracking) {
+			using Ch = typename S::value_type;
+			tracking.use(1);
+			size_t len;
+			auto utf8p = lua_tolstring(L, index, &len);
+			if (len < 1)
+				return S();
+			const char* strb = utf8p;
+			const char* stre = utf8p + len;
+			stack_detail::count_code_units_utf<BaseCh> count_units;
+			convert<BaseCh>(strb, stre, count_units);
+			S r(count_units.needed_size, static_cast<Ch>(0));
+			r.resize(count_units.needed_size);
+			Ch* target = &r[0];
+			stack_detail::copy_code_units_utf<Ch, BaseCh> copy_units(target);
+			convert<BaseCh>(strb, stre, copy_units);
+			return r;
+		}
+	} // namespace stack_detail
+
+	template <typename T, typename>
+	struct unqualified_getter {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			if constexpr (std::is_same_v<T, bool>) {
+				tracking.use(1);
+				return lua_toboolean(L, index) != 0;
+			}
+			else if constexpr (std::is_enum_v<T>) {
+				tracking.use(1);
+				return static_cast<T>(lua_tointegerx(L, index, nullptr));
+			}
+			else if constexpr (std::is_integral_v<T> || std::is_same_v<T, lua_Integer>) {
+				tracking.use(1);
+#if SOL_LUA_VERSION_I_ >= 503
+				if (lua_isinteger(L, index) != 0) {
+					return static_cast<T>(lua_tointeger(L, index));
+				}
+#endif
+				return static_cast<T>(llround(lua_tonumber(L, index)));
+			}
+			else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+				tracking.use(1);
+				return static_cast<T>(lua_tonumber(L, index));
+			}
+			else if constexpr (is_lua_reference_v<T>) {
+				if constexpr (is_global_table_v<T>) {
+					tracking.use(1);
+					return T(L, global_tag);
+				}
+				else {
+					tracking.use(1);
+					return T(L, index);
+				}
+			}
+			else if constexpr (is_unique_usertype_v<T>) {
+				using actual = unique_usertype_actual_t<T>;
+
+				tracking.use(1);
+				void* memory = lua_touserdata(L, index);
+				void* aligned_memory = detail::align_usertype_unique<actual>(memory);
+				actual* typed_memory = static_cast<actual*>(aligned_memory);
+				return *typed_memory;
+			}
+			else if constexpr (meta::is_optional_v<T>) {
+				using ValueType = typename T::value_type;
+				return unqualified_check_getter<ValueType>::template get_using<T>(L, index, &no_panic, tracking);
+			}
+			else if constexpr (std::is_same_v<T, luaL_Stream*>) {
+				luaL_Stream* pstream = static_cast<luaL_Stream*>(lua_touserdata(L, index));
+				return pstream;
+			}
+			else if constexpr (std::is_same_v<T, luaL_Stream>) {
+				luaL_Stream* pstream = static_cast<luaL_Stream*>(lua_touserdata(L, index));
+				return *pstream;
+			}
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+			else if constexpr (std::is_function_v<T> || (std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>)) {
+				return stack_detail::get_function_pointer<std::remove_pointer_t<T>>(L, index, tracking);
+			}
+#endif
+			else {
+				return stack_detail::unchecked_unqualified_get<detail::as_value_tag<T>>(L, index, tracking);
+			}
+		}
+	};
+
+	template <typename X, typename>
+	struct qualified_getter {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			using Tu = meta::unqualified_t<X>;
+			static constexpr bool is_userdata_of_some_kind
+				= !std::is_reference_v<
+				       X> && is_container_v<Tu> && std::is_default_constructible_v<Tu> && !is_lua_primitive_v<Tu> && !is_transparent_argument_v<Tu>;
+			if constexpr (is_userdata_of_some_kind) {
+				if (type_of(L, index) == type::userdata) {
+					return static_cast<Tu>(stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking));
+				}
+				else {
+					return stack_detail::unchecked_unqualified_get<sol::nested<Tu>>(L, index, tracking);
+				}
+			}
+			else if constexpr (!std::is_reference_v<X> && is_unique_usertype_v<Tu> && !is_actual_type_rebindable_for_v<Tu>) {
+				using element = unique_usertype_element_t<Tu>;
+				using actual = unique_usertype_actual_t<Tu>;
+				tracking.use(1);
+				void* memory = lua_touserdata(L, index);
+				memory = detail::align_usertype_unique_destructor(memory);
+				detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+				if (&detail::usertype_unique_alloc_destroy<element, Tu> == pdx) {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					memory = detail::align_usertype_unique<actual, true, false>(memory);
+					actual* mem = static_cast<actual*>(memory);
+					return static_cast<actual>(*mem);
+				}
+				actual r {};
+				if constexpr (!derive<element>::value) {
+#if SOL_IS_ON(SOL_DEBUG_BUILD)
+					// In debug mode we would rather abort you for this grave failure rather
+					// than let you deref a null pointer and fuck everything over
+					std::abort();
+#endif
+					return static_cast<actual>(std::move(r));
+				}
+				else {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory);
+					memory = detail::align_usertype_unique<actual, true, false>(memory);
+					string_view ti = usertype_traits<element>::qualified_name();
+					int cast_operation;
+					if constexpr (is_actual_type_rebindable_for_v<Tu>) {
+						using rebound_actual_type = unique_usertype_rebind_actual_t<Tu, void>;
+						string_view rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					else {
+						string_view rebind_ti("");
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					switch (cast_operation) {
+					case 1: {
+						// it's a perfect match,
+						// alias memory directly
+						actual* mem = static_cast<actual*>(memory);
+						return static_cast<actual>(*mem);
+					}
+					case 2:
+						// it's a base match, return the
+						// aliased creation
+						return static_cast<actual>(std::move(r));
+					default:
+						// uh oh..
+						break;
+					}
+#if SOL_IS_ON(SOL_DEBUG_BUILD)
+					// In debug mode we would rather abort you for this grave failure rather
+					// than let you deref a null pointer and fuck everything over
+					std::abort();
+#endif
+					return static_cast<actual>(r);
+				}
+			}
+			else {
+				return stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<as_table_t<T>> {
+		using Tu = meta::unqualified_t<T>;
+
+		template <typename V>
+		static void push_back_at_end(std::true_type, types<V>, lua_State* L, T& cont, std::size_t) {
+			cont.push_back(stack::get<V>(L, -lua_size<V>::value));
+		}
+
+		template <typename V>
+		static void push_back_at_end(std::false_type, types<V> t, lua_State* L, T& cont, std::size_t idx) {
+			insert_at_end(meta::has_insert<Tu>(), t, L, cont, idx);
+		}
+
+		template <typename V>
+		static void insert_at_end(std::true_type, types<V>, lua_State* L, T& cont, std::size_t) {
+			using std::cend;
+			cont.insert(cend(cont), stack::get<V>(L, -lua_size<V>::value));
+		}
+
+		template <typename V>
+		static void insert_at_end(std::false_type, types<V>, lua_State* L, T& cont, std::size_t idx) {
+			cont[idx] = stack::get<V>(L, -lua_size<V>::value);
+		}
+
+		static bool max_size_check(std::false_type, T&, std::size_t) {
+			return false;
+		}
+
+		static bool max_size_check(std::true_type, T& cont, std::size_t idx) {
+			return idx >= cont.max_size();
+		}
+
+		static T get(lua_State* L, int relindex, record& tracking) {
+			return get(meta::is_associative<Tu>(), L, relindex, tracking);
+		}
+
+		static T get(std::false_type, lua_State* L, int relindex, record& tracking) {
+			typedef typename Tu::value_type V;
+			return get(types<V>(), L, relindex, tracking);
+		}
+
+		template <typename V>
+		static T get(types<V> t, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+
+			// the W4 flag is really great,
+			// so great that it can tell my for loops (twice nested)
+			// below never actually terminate
+			// without hitting where the gotos have infested
+
+			// so now I would get the error W4XXX unreachable
+			// me that the return cont at the end of this function
+			// which is fair until other compilers complain
+			// that there isn't a return and that based on
+			// SOME MAGICAL FORCE
+			// control flow falls off the end of a non-void function
+			// so it needs to be there for the compilers that are
+			// too flimsy to analyze the basic blocks...
+			// (I'm sure I should file a bug but those compilers are already
+			// in the wild; it doesn't matter if I fix them,
+			// someone else is still going to get some old-ass compiler
+			// and then bother me about the unclean build for the 30th
+			// time)
+
+			// "Why not an IIFE?"
+			// Because additional lambdas / functions which serve as
+			// capture-all-and-then-invoke bloat binary sizes
+			// by an actually detectable amount
+			// (one user uses sol2 pretty heavily and 22 MB of binary size
+			// was saved by reducing reliance on lambdas in templates)
+
+			// This would really be solved by having break N;
+			// be a real, proper thing...
+			// but instead, we have to use labels and gotos
+			// and earn the universal vitriol of the dogmatic
+			// programming community
+
+			// all in all: W4 is great!~
+
+			int index = lua_absindex(L, relindex);
+			T cont;
+			std::size_t idx = 0;
+#if SOL_LUA_VERSION_I_ >= 503
+			// This method is HIGHLY performant over regular table iteration
+			// thanks to the Lua API changes in 5.3
+			// Questionable in 5.4
+			for (lua_Integer i = 0;; i += lua_size<V>::value) {
+				if (max_size_check(meta::has_max_size<Tu>(), cont, idx)) {
+					// see above comment
+					goto done;
+				}
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+#if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES) && SOL_LUA_VERSION_I_ >= 600
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+					luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+					lua_pushinteger(L, static_cast<lua_Integer>(i + vi));
+					if (lua_keyin(L, index) == 0) {
+						// it's time to stop
+						isnil = true;
+					}
+					else {
+						// we have a key, have to get the value
+						lua_geti(L, index, i + vi);
+					}
+#else
+					type vt = static_cast<type>(lua_geti(L, index, i + vi));
+					isnil = vt == type::none || vt == type::lua_nil;
+#endif
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+#if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES) && SOL_LUA_VERSION_I_ >= 600
+						lua_pop(L, vi);
+#else
+						lua_pop(L, (vi + 1));
+#endif
+						// see above comment
+						goto done;
+					}
+				}
+				if (isnil) {
+#if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES) && SOL_LUA_VERSION_I_ >= 600
+#else
+					lua_pop(L, lua_size<V>::value);
+#endif
+					continue;
+				}
+
+				push_back_at_end(meta::has_push_back<Tu>(), t, L, cont, idx);
+				++idx;
+				lua_pop(L, lua_size<V>::value);
+			}
+#else
+			// Zzzz slower but necessary thanks to the lower version API and missing functions qq
+			for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+				if (idx >= cont.max_size()) {
+					// see above comment
+					goto done;
+				}
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 2, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+					lua_pushinteger(L, i);
+					lua_gettable(L, index);
+					type vt = type_of(L, -1);
+					isnil = vt == type::lua_nil;
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+						lua_pop(L, (vi + 1));
+						// see above comment
+						goto done;
+					}
+				}
+				if (isnil)
+					continue;
+				push_back_at_end(meta::has_push_back<Tu>(), t, L, cont, idx);
+				++idx;
+			}
+#endif
+		done:
+			return cont;
+		}
+
+		static T get(std::true_type, lua_State* L, int index, record& tracking) {
+			typedef typename Tu::value_type P;
+			typedef typename P::first_type K;
+			typedef typename P::second_type V;
+			return get(types<K, V>(), L, index, tracking);
+		}
+
+		template <typename K, typename V>
+		static T get(types<K, V>, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+			T associative;
+			int index = lua_absindex(L, relindex);
+			lua_pushnil(L);
+			while (lua_next(L, index) != 0) {
+				decltype(auto) key = stack::check_get<K>(L, -2);
+				if (!key) {
+					lua_pop(L, 1);
+					continue;
+				}
+				associative.emplace(std::forward<decltype(*key)>(*key), stack::get<V>(L, -1));
+				lua_pop(L, 1);
+			}
+			return associative;
+		}
+	};
+
+	template <typename T, typename Al>
+	struct unqualified_getter<as_table_t<std::forward_list<T, Al>>> {
+		typedef std::forward_list<T, Al> C;
+
+		static C get(lua_State* L, int relindex, record& tracking) {
+			return get(meta::has_key_value_pair<C>(), L, relindex, tracking);
+		}
+
+		static C get(std::true_type, lua_State* L, int index, record& tracking) {
+			typedef typename T::value_type P;
+			typedef typename P::first_type K;
+			typedef typename P::second_type V;
+			return get(types<K, V>(), L, index, tracking);
+		}
+
+		static C get(std::false_type, lua_State* L, int relindex, record& tracking) {
+			typedef typename C::value_type V;
+			return get(types<V>(), L, relindex, tracking);
+		}
+
+		template <typename V>
+		static C get(types<V>, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+			int index = lua_absindex(L, relindex);
+			C cont;
+			auto at = cont.cbefore_begin();
+			std::size_t idx = 0;
+#if SOL_LUA_VERSION_I_ >= 503
+			// This method is HIGHLY performant over regular table iteration thanks to the Lua API changes in 5.3
+			for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+				if (idx >= cont.max_size()) {
+					goto done;
+				}
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+					type t = static_cast<type>(lua_geti(L, index, i + vi));
+					isnil = t == type::lua_nil;
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+						lua_pop(L, (vi + 1));
+						goto done;
+					}
+				}
+				if (isnil)
+					continue;
+				at = cont.insert_after(at, stack::get<V>(L, -lua_size<V>::value));
+				++idx;
+			}
+#else
+			// Zzzz slower but necessary thanks to the lower version API and missing functions qq
+			for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+				if (idx >= cont.max_size()) {
+					goto done;
+				}
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+					lua_pushinteger(L, i);
+					lua_gettable(L, index);
+					type t = type_of(L, -1);
+					isnil = t == type::lua_nil;
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+						lua_pop(L, (vi + 1));
+						goto done;
+					}
+				}
+				if (isnil)
+					continue;
+				at = cont.insert_after(at, stack::get<V>(L, -lua_size<V>::value));
+				++idx;
+			}
+#endif
+		done:
+			return cont;
+		}
+
+		template <typename K, typename V>
+		static C get(types<K, V>, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+			C associative;
+			auto at = associative.cbefore_begin();
+			int index = lua_absindex(L, relindex);
+			lua_pushnil(L);
+			while (lua_next(L, index) != 0) {
+				decltype(auto) key = stack::check_get<K>(L, -2);
+				if (!key) {
+					lua_pop(L, 1);
+					continue;
+				}
+				at = associative.emplace_after(at, std::forward<decltype(*key)>(*key), stack::get<V>(L, -1));
+				lua_pop(L, 1);
+			}
+			return associative;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<nested<T>> {
+		static T get(lua_State* L, int index, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (is_container_v<Tu>) {
+				if constexpr (meta::is_associative<Tu>::value) {
+					typedef typename T::value_type P;
+					typedef typename P::first_type K;
+					typedef typename P::second_type V;
+					unqualified_getter<as_table_t<T>> g{};
+					return g.get(types<K, nested<V>>(), L, index, tracking);
+				}
+				else {
+					typedef typename T::value_type V;
+					unqualified_getter<as_table_t<T>> g{};
+					return g.get(types<nested<V>>(), L, index, tracking);
+				}
+			}
+			else {
+				unqualified_getter<Tu> g{};
+				return g.get(L, index, tracking);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<as_container_t<T>> {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			return stack::unqualified_get<T>(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<as_container_t<T>*> {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			return stack::unqualified_get<T*>(L, index, tracking);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<userdata_value> {
+		static userdata_value get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return userdata_value(lua_touserdata(L, index));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<lightuserdata_value> {
+		static lightuserdata_value get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lightuserdata_value(lua_touserdata(L, index));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<light<T>> {
+		static light<T> get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			void* memory = lua_touserdata(L, index);
+			return light<T>(static_cast<T*>(memory));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<user<T>> {
+		static std::add_lvalue_reference_t<T> get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			void* memory = lua_touserdata(L, index);
+			memory = detail::align_user<T>(memory);
+			return *static_cast<std::remove_reference_t<T>*>(memory);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<user<T*>> {
+		static T* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			void* memory = lua_touserdata(L, index);
+			memory = detail::align_user<T*>(memory);
+			return static_cast<T*>(memory);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<type> {
+		static type get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return static_cast<type>(lua_type(L, index));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<std::string> {
+		static std::string get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			std::size_t len;
+			auto str = lua_tolstring(L, index, &len);
+			return std::string(str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<const char*> {
+		static const char* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t sz;
+			return lua_tolstring(L, index, &sz);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<char> {
+		static char get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t len;
+			auto str = lua_tolstring(L, index, &len);
+			return len > 0 ? str[0] : '\0';
+		}
+	};
+
+	template <typename Traits>
+	struct unqualified_getter<basic_string_view<char, Traits>> {
+		static string_view get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t sz;
+			const char* str = lua_tolstring(L, index, &sz);
+			return basic_string_view<char, Traits>(str, sz);
+		}
+	};
+
+	template <typename Traits, typename Al>
+	struct unqualified_getter<std::basic_string<wchar_t, Traits, Al>> {
+		using S = std::basic_string<wchar_t, Traits, Al>;
+		static S get(lua_State* L, int index, record& tracking) {
+			using Ch = meta::conditional_t<sizeof(wchar_t) == 2, char16_t, char32_t>;
+			return stack_detail::get_into<Ch, S>(L, index, tracking);
+		}
+	};
+
+	template <typename Traits, typename Al>
+	struct unqualified_getter<std::basic_string<char16_t, Traits, Al>> {
+		static std::basic_string<char16_t, Traits, Al> get(lua_State* L, int index, record& tracking) {
+			return stack_detail::get_into<char16_t, std::basic_string<char16_t, Traits, Al>>(L, index, tracking);
+		}
+	};
+
+	template <typename Traits, typename Al>
+	struct unqualified_getter<std::basic_string<char32_t, Traits, Al>> {
+		static std::basic_string<char32_t, Traits, Al> get(lua_State* L, int index, record& tracking) {
+			return stack_detail::get_into<char32_t, std::basic_string<char32_t, Traits, Al>>(L, index, tracking);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<char16_t> {
+		static char16_t get(lua_State* L, int index, record& tracking) {
+			string_view utf8 = stack::get<string_view>(L, index, tracking);
+			const char* strb = utf8.data();
+			const char* stre = utf8.data() + utf8.size();
+			char32_t cp = 0;
+			auto dr = unicode::utf8_to_code_point(strb, stre);
+			if (dr.error != unicode::error_code::ok) {
+				cp = unicode::unicode_detail::replacement;
+			}
+			else {
+				cp = dr.codepoint;
+			}
+			auto er = unicode::code_point_to_utf16(cp);
+			return er.code_units[0];
+		}
+	};
+
+	template <>
+	struct unqualified_getter<char32_t> {
+		static char32_t get(lua_State* L, int index, record& tracking) {
+			string_view utf8 = stack::get<string_view>(L, index, tracking);
+			const char* strb = utf8.data();
+			const char* stre = utf8.data() + utf8.size();
+			char32_t cp = 0;
+			auto dr = unicode::utf8_to_code_point(strb, stre);
+			if (dr.error != unicode::error_code::ok) {
+				cp = unicode::unicode_detail::replacement;
+			}
+			else {
+				cp = dr.codepoint;
+			}
+			auto er = unicode::code_point_to_utf32(cp);
+			return er.code_units[0];
+		}
+	};
+
+	template <>
+	struct unqualified_getter<wchar_t> {
+		static wchar_t get(lua_State* L, int index, record& tracking) {
+			typedef meta::conditional_t<sizeof(wchar_t) == 2, char16_t, char32_t> Ch;
+			unqualified_getter<Ch> g;
+			(void)g;
+			auto c = g.get(L, index, tracking);
+			return static_cast<wchar_t>(c);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<meta_function> {
+		static meta_function get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			const char* name = unqualified_getter<const char*> {}.get(L, index, tracking);
+			const auto& mfnames = meta_function_names();
+			for (std::size_t i = 0; i < mfnames.size(); ++i)
+				if (mfnames[i] == name)
+					return static_cast<meta_function>(i);
+			return meta_function::construct;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<lua_nil_t> {
+		static lua_nil_t get(lua_State*, int, record& tracking) {
+			tracking.use(1);
+			return lua_nil;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<std::nullptr_t> {
+		static std::nullptr_t get(lua_State*, int, record& tracking) {
+			tracking.use(1);
+			return nullptr;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<nullopt_t> {
+		static nullopt_t get(lua_State*, int, record& tracking) {
+			tracking.use(1);
+			return nullopt;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<this_state> {
+		static this_state get(lua_State* L, int, record& tracking) {
+			tracking.use(0);
+			return this_state(L);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<this_main_state> {
+		static this_main_state get(lua_State* L, int, record& tracking) {
+			tracking.use(0);
+			return this_main_state(main_thread(L, L));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<lua_CFunction> {
+		static lua_CFunction get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lua_tocfunction(L, index);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<c_closure> {
+		static c_closure get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return c_closure(lua_tocfunction(L, index), -1);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<error> {
+		static error get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t sz = 0;
+			const char* err = lua_tolstring(L, index, &sz);
+			if (err == nullptr) {
+				return error(detail::direct_error, "");
+			}
+			return error(detail::direct_error, std::string(err, sz));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<void*> {
+		static void* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lua_touserdata(L, index);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<const void*> {
+		static const void* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lua_touserdata(L, index);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<detail::as_value_tag<T>> {
+		static T* get_no_lua_nil(lua_State* L, int index, record& tracking) {
+			void* memory = lua_touserdata(L, index);
+#if SOL_IS_ON(SOL_USE_INTEROP)
+			auto ugr = stack_detail::interop_get<T>(L, index, memory, tracking);
+			if (ugr.first) {
+				return ugr.second;
+			}
+#endif // interop extensibility
+			tracking.use(1);
+			void* rawdata = detail::align_usertype_pointer(memory);
+			void** pudata = static_cast<void**>(rawdata);
+			void* udata = *pudata;
+			return get_no_lua_nil_from(L, udata, index, tracking);
+		}
+
+		static T* get_no_lua_nil_from(lua_State* L, void* udata, int index, record&) {
+			bool has_derived = derive<T>::value || weak_derive<T>::value;
+			if (has_derived) {
+				if (lua_getmetatable(L, index) == 1) {
+					lua_getfield(L, -1, &detail::base_class_cast_key()[0]);
+					if (type_of(L, -1) != type::lua_nil) {
+						void* basecastdata = lua_touserdata(L, -1);
+						detail::inheritance_cast_function ic = reinterpret_cast<detail::inheritance_cast_function>(basecastdata);
+						// use the casting function to properly adjust the pointer for the desired T
+						udata = ic(udata, usertype_traits<T>::qualified_name());
+					}
+					lua_pop(L, 2);
+				}
+			}
+			if constexpr (std::is_function_v<T>) {
+				T* func = reinterpret_cast<T*>(udata);
+				return func;
+			}
+			else {
+				T* obj = static_cast<T*>(udata);
+				return obj;
+			}
+		}
+
+		static T& get(lua_State* L, int index, record& tracking) {
+			return *get_no_lua_nil(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<detail::as_pointer_tag<T>> {
+		static T* get(lua_State* L, int index, record& tracking) {
+			type t = type_of(L, index);
+			if (t == type::lua_nil) {
+				tracking.use(1);
+				return nullptr;
+			}
+			unqualified_getter<detail::as_value_tag<T>> g{};
+			return g.get_no_lua_nil(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<non_null<T*>> {
+		static T* get(lua_State* L, int index, record& tracking) {
+			unqualified_getter<detail::as_value_tag<T>> g{};
+			return g.get_no_lua_nil(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<T&> {
+		static T& get(lua_State* L, int index, record& tracking) {
+			unqualified_getter<detail::as_value_tag<T>> g{};
+			return g.get(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<std::reference_wrapper<T>> {
+		static T& get(lua_State* L, int index, record& tracking) {
+			unqualified_getter<T&> g{};
+			return g.get(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<T*> {
+		static T* get(lua_State* L, int index, record& tracking) {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+			if constexpr (std::is_function_v<T>) {
+				return stack_detail::get_function_pointer<T>(L, index, tracking);
+			}
+			else {
+				unqualified_getter<detail::as_pointer_tag<T>> g{};
+				return g.get(L, index, tracking);
+			}
+#else
+			unqualified_getter<detail::as_pointer_tag<T>> g{};
+			return g.get(L, index, tracking);
+#endif
+		}
+	};
+
+	template <typename... Tn>
+	struct unqualified_getter<std::tuple<Tn...>> {
+		typedef std::tuple<decltype(stack::get<Tn>(nullptr, 0))...> R;
+
+		template <typename... Args>
+		static R apply(std::index_sequence<>, lua_State*, int, record&, Args&&... args) {
+			// Fuck you too, VC++
+			return R { std::forward<Args>(args)... };
+		}
+
+		template <std::size_t I, std::size_t... Ix, typename... Args>
+		static R apply(std::index_sequence<I, Ix...>, lua_State* L, int index, record& tracking, Args&&... args) {
+			// Fuck you too, VC++
+			typedef std::tuple_element_t<I, std::tuple<Tn...>> T;
+			return apply(std::index_sequence<Ix...>(), L, index, tracking, std::forward<Args>(args)..., stack::get<T>(L, index + tracking.used, tracking));
+		}
+
+		static R get(lua_State* L, int index, record& tracking) {
+			return apply(std::make_index_sequence<sizeof...(Tn)>(), L, index, tracking);
+		}
+	};
+
+	template <typename A, typename B>
+	struct unqualified_getter<std::pair<A, B>> {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			return std::pair<decltype(stack::get<A>(L, index)), decltype(stack::get<B>(L, index))> { stack::get<A>(L, index, tracking),
+				stack::get<B>(L, index + tracking.used, tracking) };
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+
+	template <typename... Tn>
+	struct unqualified_getter<std::variant<Tn...>> {
+		using V = std::variant<Tn...>;
+
+		static V get_one(std::integral_constant<std::size_t, std::variant_size_v<V>>, lua_State* L, int index, record& tracking) {
+			(void)L;
+			(void)index;
+			(void)tracking;
+			if constexpr (std::variant_size_v<V> == 0) {
+				return V();
+			}
+			else {
+				// using T = std::variant_alternative_t<0, V>;
+				std::abort();
+				// return V(std::in_place_index<0>, stack::get<T>(L, index, tracking));
+			}
+		}
+
+		template <std::size_t I>
+		static V get_one(std::integral_constant<std::size_t, I>, lua_State* L, int index, record& tracking) {
+			typedef std::variant_alternative_t<I, V> T;
+			record temp_tracking = tracking;
+			if (stack::check<T>(L, index, &no_panic, temp_tracking)) {
+				tracking = temp_tracking;
+				return V(std::in_place_index<I>, stack::get<T>(L, index));
+			}
+			return get_one(std::integral_constant<std::size_t, I + 1>(), L, index, tracking);
+		}
+
+		static V get(lua_State* L, int index, record& tracking) {
+			return get_one(std::integral_constant<std::size_t, 0>(), L, index, tracking);
+		}
+	};
+#endif // variant
+
+}} // namespace sol::stack
+
+// end of sol/stack_get_unqualified.hpp
+
+// beginning of sol/stack_get_qualified.hpp
+
+namespace sol { namespace stack {
+
+	// There are no more enable_ifs that can be used here,
+	// so this is just for posterity, I guess?
+	// maybe I'll fill this file in later.
+
+}} // namespace sol::stack
+
+// end of sol/stack_get_qualified.hpp
+
+// end of sol/stack_get.hpp
+
+// beginning of sol/stack_check_get.hpp
+
+// beginning of sol/stack_check_get_unqualified.hpp
+
+#include <cstdlib>
+#include <cmath>
+#include <optional>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // variant shenanigans (thanks, Mac OSX)
+
+namespace sol { namespace stack {
+	template <typename T, typename>
+	struct unqualified_check_getter {
+		typedef decltype(stack_detail::unchecked_unqualified_get<T>(nullptr, -1, std::declval<record&>())) R;
+
+		template <typename Optional, typename Handler>
+		static Optional get_using(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (!meta::meta_detail::is_adl_sol_lua_check_v<T> && !meta::meta_detail::is_adl_sol_lua_get_v<T>) {
+				if constexpr (is_lua_reference_v<T>) {
+					if constexpr (is_global_table_v<T>) {
+						(void)L;
+						(void)index;
+						(void)handler;
+						tracking.use(1);
+						return true;
+					}
+					else {
+						// actually check if it's none here, otherwise
+						// we'll have a none object inside an optional!
+						bool success = lua_isnoneornil(L, index) == 0 && stack::check<T>(L, index, &no_panic);
+						if (!success) {
+							// expected type, actual type
+							tracking.use(static_cast<int>(success));
+							handler(L, index, type::poly, type_of(L, index), "");
+							return detail::associated_nullopt_v<Optional>;
+						}
+						return stack_detail::unchecked_get<T>(L, index, tracking);
+					}
+				}
+				else if constexpr ((std::is_integral_v<T> || std::is_same_v<T, lua_Integer>)&&!std::is_same_v<T, bool>) {
+#if SOL_LUA_VERSION_I_ >= 503
+					if (lua_isinteger(L, index) != 0) {
+						tracking.use(1);
+						return static_cast<T>(lua_tointeger(L, index));
+					}
+#endif
+					int isnum = 0;
+					const lua_Number value = lua_tonumberx(L, index, &isnum);
+					if (isnum != 0) {
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+						const auto integer_value = llround(value);
+						if (static_cast<lua_Number>(integer_value) == value) {
+							tracking.use(1);
+							return static_cast<T>(integer_value);
+						}
+#else
+						tracking.use(1);
+						return static_cast<T>(value);
+#endif
+					}
+					const type t = type_of(L, index);
+					tracking.use(static_cast<int>(t != type::none));
+					handler(L, index, type::number, t, "not an integer");
+					return detail::associated_nullopt_v<Optional>;
+				}
+				else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+					int isnum = 0;
+					lua_Number value = lua_tonumberx(L, index, &isnum);
+					if (isnum == 0) {
+						type t = type_of(L, index);
+						tracking.use(static_cast<int>(t != type::none));
+						handler(L, index, type::number, t, "not a valid floating point number");
+						return detail::associated_nullopt_v<Optional>;
+					}
+					tracking.use(1);
+					return static_cast<T>(value);
+				}
+				else if constexpr (std::is_enum_v<T> && !meta::any_same_v<T, meta_function, type>) {
+					int isnum = 0;
+					lua_Integer value = lua_tointegerx(L, index, &isnum);
+					if (isnum == 0) {
+						type t = type_of(L, index);
+						tracking.use(static_cast<int>(t != type::none));
+						handler(L, index, type::number, t, "not a valid enumeration value");
+						return detail::associated_nullopt_v<Optional>;
+					}
+					tracking.use(1);
+					return static_cast<T>(value);
+				}
+				else {
+					if (!unqualified_check<T>(L, index, std::forward<Handler>(handler))) {
+						tracking.use(static_cast<int>(!lua_isnone(L, index)));
+						return detail::associated_nullopt_v<Optional>;
+					}
+					return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+				}
+			}
+			else {
+				if (!unqualified_check<T>(L, index, std::forward<Handler>(handler))) {
+					tracking.use(static_cast<int>(!lua_isnone(L, index)));
+					return detail::associated_nullopt_v<Optional>;
+				}
+				return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+			}
+		}
+
+		template <typename Handler>
+		static optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return get_using<optional<R>>(L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+	template <typename... Tn, typename C>
+	struct unqualified_check_getter<std::variant<Tn...>, C> {
+		typedef std::variant<Tn...> V;
+		typedef std::variant_size<V> V_size;
+		typedef std::integral_constant<bool, V_size::value == 0> V_is_empty;
+
+		template <typename Handler>
+		static optional<V> get_empty(std::true_type, lua_State*, int, Handler&&, record&) {
+			return nullopt;
+		}
+
+		template <typename Handler>
+		static optional<V> get_empty(std::false_type, lua_State* L, int index, Handler&& handler, record&) {
+			// This should never be reached...
+			// please check your code and understand what you did to bring yourself here
+			// maybe file a bug report, or 5
+			handler(
+				L, index, type::poly, type_of(L, index), "this variant code should never be reached: if it has, you have done something so terribly wrong");
+			return nullopt;
+		}
+
+		template <typename Handler>
+		static optional<V> get_one(std::integral_constant<std::size_t, 0>, lua_State* L, int index, Handler&& handler, record& tracking) {
+			return get_empty(V_is_empty(), L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <std::size_t I, typename Handler>
+		static optional<V> get_one(std::integral_constant<std::size_t, I>, lua_State* L, int index, Handler&& handler, record& tracking) {
+			typedef std::variant_alternative_t<I - 1, V> T;
+			if (stack::check<T>(L, index, &no_panic, tracking)) {
+				return V(std::in_place_index<I - 1>, stack::get<T>(L, index));
+			}
+			return get_one(std::integral_constant<std::size_t, I - 1>(), L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename Handler>
+		static optional<V> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return get_one(std::integral_constant<std::size_t, V_size::value>(), L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+#endif // standard variant
+}}     // namespace sol::stack
+
+// end of sol/stack_check_get_unqualified.hpp
+
+// beginning of sol/stack_check_get_qualified.hpp
+
+namespace sol { namespace stack {
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
+	namespace stack_detail {
+		template <typename OptionalType, typename T, typename Handler>
+		OptionalType get_optional(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+
+			if constexpr (is_lua_reference_v<T>) {
+				if constexpr (is_global_table_v<Tu>) {
+					(void)L;
+					(void)index;
+					(void)handler;
+					tracking.use(1);
+					return true;
+				}
+				else {
+					// actually check if it's none here, otherwise
+					// we'll have a none object inside an optional!
+					bool success = lua_isnoneornil(L, index) == 0 && stack::check<T>(L, index, &no_panic);
+					if (!success) {
+						// expected type, actual type
+						tracking.use(static_cast<int>(success));
+						handler(L, index, type::poly, type_of(L, index), "");
+						return {};
+					}
+					return OptionalType(stack_detail::unchecked_get<T>(L, index, tracking));
+				}
+			}
+			else if constexpr (!std::is_reference_v<T> && is_unique_usertype_v<Tu> && !is_actual_type_rebindable_for_v<Tu>) {
+				// we can take shortcuts here to save on separate checking, and just return nullopt!
+				using element = unique_usertype_element_t<Tu>;
+				using actual = unique_usertype_actual_t<Tu>;
+				tracking.use(1);
+				void* memory = lua_touserdata(L, index);
+				memory = detail::align_usertype_unique_destructor(memory);
+				detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+				if (&detail::usertype_unique_alloc_destroy<element, Tu> == pdx) {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					memory = detail::align_usertype_unique<actual, true, false>(memory);
+					actual* mem = static_cast<actual*>(memory);
+					return static_cast<actual>(*mem);
+				}
+				if constexpr (!derive<element>::value) {
+					return OptionalType();
+				}
+				else {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory);
+					memory = detail::align_usertype_unique<actual, true, false>(memory);
+					string_view ti = usertype_traits<element>::qualified_name();
+					int cast_operation;
+					actual r {};
+					if constexpr (is_actual_type_rebindable_for_v<Tu>) {
+						using rebound_actual_type = unique_usertype_rebind_actual_t<Tu, void>;
+						string_view rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					else {
+						string_view rebind_ti("");
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					switch (cast_operation) {
+					case 1: {
+						// it's a perfect match,
+						// alias memory directly
+						actual* mem = static_cast<actual*>(memory);
+						return OptionalType(*mem);
+					}
+					case 2:
+						// it's a base match, return the
+						// aliased creation
+						return OptionalType(std::move(r));
+					default:
+						break;
+					}
+					return OptionalType();
+				}
+			}
+			else {
+				if (!check<T>(L, index, std::forward<Handler>(handler))) {
+					tracking.use(static_cast<int>(!lua_isnone(L, index)));
+					return OptionalType();
+				}
+				return OptionalType(stack_detail::unchecked_get<T>(L, index, tracking));
+			}
+		}
+	} // namespace stack_detail
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic pop
+#endif
+
+	template <typename T, typename>
+	struct qualified_check_getter {
+		typedef decltype(stack_detail::unchecked_get<T>(nullptr, -1, std::declval<record&>())) R;
+
+		template <typename Handler>
+		optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return stack_detail::get_optional<optional<R>, T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename Optional>
+	struct qualified_getter<Optional, std::enable_if_t<meta::is_optional_v<Optional>>> {
+		static Optional get(lua_State* L, int index, record& tracking) {
+			using T = typename meta::unqualified_t<Optional>::value_type;
+			return stack_detail::get_optional<Optional, T>(L, index, &no_panic, tracking);
+		}
+	};
+
+}} // namespace sol::stack
+
+// end of sol/stack_check_get_qualified.hpp
+
+// end of sol/stack_check_get.hpp
+
+// beginning of sol/stack_push.hpp
+
+#include <memory>
+#include <type_traits>
+#include <cassert>
+#include <limits>
+#include <cmath>
+#include <string_view>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // Can use variant
+
+// beginning of sol/debug.hpp
+
+#include <iostream>
+
+namespace sol { namespace detail { namespace debug {
+	inline std::string dump_types(lua_State* L) {
+		std::string visual;
+		std::size_t size = lua_gettop(L) + 1;
+		for (std::size_t i = 1; i < size; ++i) {
+			if (i != 1) {
+				visual += " | ";
+			}
+			visual += type_name(L, stack::get<type>(L, static_cast<int>(i)));
+		}
+		return visual;
+	}
+
+	inline void print_stack(lua_State* L) {
+		std::cout << dump_types(L) << std::endl;
+	}
+
+	inline void print_section(const std::string& message, lua_State* L) {
+		std::cout << "-- " << message << " -- [ " << dump_types(L) << " ]" << std::endl;
+	}
+}}} // namespace sol::detail::debug
+
+// end of sol/debug.hpp
+
+namespace sol { namespace stack {
+	namespace stack_detail {
+		template <typename T>
+		inline bool integer_value_fits(const T& value) {
+			// We check if we can rely on casts or a lack of padding bits to satisfy
+			// the requirements here
+			// If it lacks padding bits, we can jump back and forth between lua_Integer and whatever type without
+			// loss of information
+			constexpr bool is_same_signedness
+				= (std::is_signed_v<T> && std::is_signed_v<lua_Integer>) || (std::is_unsigned_v<T> && std::is_unsigned_v<lua_Integer>);
+			constexpr bool probaby_fits_within_lua_Integer = sizeof(T) == sizeof(lua_Integer)
+#if SOL_IS_ON(SOL_ALL_INTEGER_VALUES_FIT)
+				&& ((std::has_unique_object_representations_v<T> && std::has_unique_object_representations_v<lua_Integer>) ? true : is_same_signedness)
+#else
+				&& is_same_signedness
+#endif
+				;
+			if constexpr (sizeof(T) < sizeof(lua_Integer) || probaby_fits_within_lua_Integer) {
+				(void)value;
+				return true;
+			}
+			else {
+				auto u_min = static_cast<std::intmax_t>((std::numeric_limits<lua_Integer>::min)());
+				auto u_max = static_cast<std::uintmax_t>((std::numeric_limits<lua_Integer>::max)());
+				auto t_min = static_cast<std::intmax_t>((std::numeric_limits<T>::min)());
+				auto t_max = static_cast<std::uintmax_t>((std::numeric_limits<T>::max)());
+				return (u_min <= t_min || value >= static_cast<T>(u_min)) && (u_max >= t_max || value <= static_cast<T>(u_max));
+			}
+		}
+
+		template <typename T>
+		int msvc_is_ass_with_if_constexpr_push_enum(std::true_type, lua_State* L, const T& value) {
+			if constexpr (meta::any_same_v<std::underlying_type_t<T>,
+				              char
+#if SOL_IS_ON(SOL_CHAR8_T)
+				              ,
+				              char8_t
+#endif
+				              ,
+				              char16_t,
+				              char32_t>) {
+				if constexpr (std::is_signed_v<T>) {
+					return stack::push(L, static_cast<std::int_least32_t>(value));
+				}
+				else {
+					return stack::push(L, static_cast<std::uint_least32_t>(value));
+				}
+			}
+			else {
+				return stack::push(L, static_cast<std::underlying_type_t<T>>(value));
+			}
+		}
+
+		template <typename T>
+		int msvc_is_ass_with_if_constexpr_push_enum(std::false_type, lua_State*, const T&) {
+			return 0;
+		}
+	} // namespace stack_detail
+
+	inline int push_environment_of(lua_State* L, int target_index = -1) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+		luaL_checkstack(L, 1, detail::not_enough_stack_space_environment);
+#endif // make sure stack doesn't overflow
+#if SOL_LUA_VERSION_I_ < 502
+		// Use lua_getfenv
+		lua_getfenv(L, target_index);
+#else
+
+		if (lua_iscfunction(L, target_index) != 0) {
+			const char* maybe_upvalue_name = lua_getupvalue(L, target_index, 1);
+			if (maybe_upvalue_name != nullptr) {
+				// it worked, take this one
+				return 1;
+			}
+		}
+		// Nominally, we search for the `"_ENV"` value.
+		// If we don't find it.... uh, well. We've got a problem?
+		for (int upvalue_index = 1;; ++upvalue_index) {
+			const char* maybe_upvalue_name = lua_getupvalue(L, target_index, upvalue_index);
+			if (maybe_upvalue_name == nullptr) {
+				push(L, lua_nil);
+				break;
+			}
+
+			string_view upvalue_name(maybe_upvalue_name);
+			if (upvalue_name == "_ENV") {
+				// Keep this one!
+				break;
+			}
+			// Discard what we received, loop back around
+			lua_pop(L, 1);
+		}
+#endif
+		return 1;
+	}
+
+	template <typename T>
+	int push_environment_of(const T& target) {
+		lua_State* target_L = target.lua_state();
+		int target_index = absolute_index(target_L, -target.push());
+		int env_count = push_environment_of(target_L, target_index);
+		sol_c_assert(env_count == 1);
+		lua_rotate(target_L, target_index, 1);
+		lua_pop(target_L, 1);
+		return env_count;
+	}
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_value_tag<T>> {
+		template <typename F, typename... Args>
+		static int push_fx(lua_State* L, F&& f, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+       // Basically, we store all user-data like this:
+       // If it's a movable/copyable value (no std::ref(x)), then we store the pointer to the new
+       // data in the first sizeof(T*) bytes, and then however many bytes it takes to
+       // do the actual object. Things that are std::ref or plain T* are stored as
+       // just the sizeof(T*), and nothing else.
+			T* obj = detail::usertype_allocate<T>(L);
+			f();
+			std::allocator<T> alloc {};
+			std::allocator_traits<std::allocator<T>>::construct(alloc, obj, std::forward<Args>(args)...);
+			return 1;
+		}
+
+		template <typename K, typename... Args>
+		static int push_keyed(lua_State* L, K&& k, Args&&... args) {
+			stack_detail::undefined_metatable fx(L, &k[0], &stack::stack_detail::set_undefined_methods_on<T>);
+			return push_fx(L, fx, std::forward<Args>(args)...);
+		}
+
+		template <typename Arg, typename... Args>
+		static int push(lua_State* L, Arg&& arg, Args&&... args) {
+			if constexpr (std::is_same_v<meta::unqualified_t<Arg>, detail::with_function_tag>) {
+				(void)arg;
+				return push_fx(L, std::forward<Args>(args)...);
+			}
+			else {
+				return push_keyed(L, usertype_traits<T>::metatable(), std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+
+		static int push(lua_State* L) {
+			return push_keyed(L, usertype_traits<T>::metatable());
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_pointer_tag<T>> {
+		typedef meta::unqualified_t<T> U;
+
+		template <typename F>
+		static int push_fx(lua_State* L, F&& f, T* obj) {
+			if (obj == nullptr)
+				return stack::push(L, lua_nil);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+			T** pref = detail::usertype_allocate_pointer<T>(L);
+			f();
+			*pref = obj;
+			return 1;
+		}
+
+		template <typename K>
+		static int push_keyed(lua_State* L, K&& k, T* obj) {
+			stack_detail::undefined_metatable fx(L, &k[0], &stack::stack_detail::set_undefined_methods_on<U*>);
+			return push_fx(L, fx, obj);
+		}
+
+		template <typename Arg, typename... Args>
+		static int push(lua_State* L, Arg&& arg, Args&&... args) {
+			if constexpr (std::is_same_v<meta::unqualified_t<Arg>, detail::with_function_tag>) {
+				(void)arg;
+				return push_fx(L, std::forward<Args>(args)...);
+			}
+			else {
+				return push_keyed(L, usertype_traits<U*>::metatable(), std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<detail::as_reference_tag> {
+		template <typename T>
+		static int push(lua_State* L, T&& obj) {
+			return stack::push(L, detail::ptr(obj));
+		}
+	};
+
+	namespace stack_detail {
+		template <typename T>
+		struct uu_pusher {
+			using element = unique_usertype_element_t<T>;
+			using actual = unique_usertype_actual_t<T>;
+
+			template <typename Arg, typename... Args>
+			static int push(lua_State* L, Arg&& arg, Args&&... args) {
+				if constexpr (std::is_base_of_v<actual, meta::unqualified_t<Arg>>) {
+					if (detail::unique_is_null(L, arg)) {
+						return stack::push(L, lua_nil);
+					}
+					return push_deep(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+				}
+				else {
+					return push_deep(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+				}
+			}
+
+			template <typename... Args>
+			static int push_deep(lua_State* L, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+				element** pointer_to_memory = nullptr;
+				detail::unique_destructor* fx = nullptr;
+				detail::unique_tag* id = nullptr;
+				actual* typed_memory = detail::usertype_unique_allocate<element, actual>(L, pointer_to_memory, fx, id);
+				if (luaL_newmetatable(L, &usertype_traits<d::u<std::remove_cv_t<element>>>::metatable()[0]) == 1) {
+					detail::lua_reg_table registration_table {};
+					int index = 0;
+					detail::indexed_insert insert_callable(registration_table, index);
+					detail::insert_default_registrations<element>(insert_callable, detail::property_always_true);
+					registration_table[index] = { to_string(meta_function::garbage_collect).c_str(), detail::make_destructor<T>() };
+					luaL_setfuncs(L, registration_table, 0);
+				}
+				lua_setmetatable(L, -2);
+				*fx = detail::usertype_unique_alloc_destroy<element, actual>;
+				*id = &detail::inheritance<element>::template type_unique_cast<actual>;
+				detail::default_construct::construct(typed_memory, std::forward<Args>(args)...);
+				*pointer_to_memory = detail::unique_get<T>(L, *typed_memory);
+				return 1;
+			}
+		};
+	} // namespace stack_detail
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_unique_tag<T>> {
+		template <typename... Args>
+		static int push(lua_State* L, Args&&... args) {
+			stack_detail::uu_pusher<T> p;
+			(void)p;
+			return p.push(L, std::forward<Args>(args)...);
+		}
+	};
+
+	template <typename T, typename>
+	struct unqualified_pusher {
+		template <typename... Args>
+		static int push(lua_State* L, Args&&... args) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (is_lua_reference_v<Tu>) {
+				using int_arr = int[];
+				int_arr p { (std::forward<Args>(args).push(L))... };
+				return p[0];
+			}
+			else if constexpr (std::is_same_v<Tu, bool>) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				lua_pushboolean(L, std::forward<Args>(args)...);
+				return 1;
+			}
+			else if constexpr (std::is_integral_v<Tu> || std::is_same_v<Tu, lua_Integer>) {
+				const Tu& value(std::forward<Args>(args)...);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_integral);
+#endif // make sure stack doesn't overflow
+#if SOL_LUA_VERSION_I_ >= 503
+				if (stack_detail::integer_value_fits<Tu>(value)) {
+					lua_pushinteger(L, static_cast<lua_Integer>(value));
+					return 1;
+				}
+#endif // Lua 5.3 and above
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+				if (static_cast<T>(llround(static_cast<lua_Number>(value))) != value) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+					// Is this really worth it?
+					sol_m_assert(false, "integer value will be misrepresented in lua");
+					lua_pushinteger(L, static_cast<lua_Integer>(value));
+					return 1;
+#else
+					throw error(detail::direct_error, "integer value will be misrepresented in lua");
+#endif // No Exceptions
+				}
+#endif // Safe Numerics and Number Precision Check
+				lua_pushnumber(L, static_cast<lua_Number>(value));
+				return 1;
+			}
+			else if constexpr (std::is_floating_point_v<Tu> || std::is_same_v<Tu, lua_Number>) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_floating);
+#endif // make sure stack doesn't overflow
+				lua_pushnumber(L, std::forward<Args>(args)...);
+				return 1;
+			}
+			else if constexpr (std::is_same_v<Tu, luaL_Stream*>) {
+				luaL_Stream* source { std::forward<Args>(args)... };
+				luaL_Stream* stream = static_cast<luaL_Stream*>(detail::alloc_newuserdata(L, sizeof(luaL_Stream)));
+				stream->f = source->f;
+#if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION)
+				stream->closef = source->closef;
+#endif // LuaJIT and Lua 5.1 and below do not have
+				return 1;
+			}
+			else if constexpr (std::is_same_v<Tu, luaL_Stream>) {
+				luaL_Stream& source(std::forward<Args>(args)...);
+				luaL_Stream* stream = static_cast<luaL_Stream*>(detail::alloc_newuserdata(L, sizeof(luaL_Stream)));
+				stream->f = source.f;
+#if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION)
+				stream->closef = source.closef;
+#endif // LuaJIT and Lua 5.1 and below do not have
+				return 1;
+			}
+			else if constexpr (std::is_enum_v<Tu>) {
+				return stack_detail::msvc_is_ass_with_if_constexpr_push_enum(std::true_type(), L, std::forward<Args>(args)...);
+			}
+			else if constexpr (std::is_pointer_v<Tu>) {
+				return stack::push<detail::as_pointer_tag<std::remove_pointer_t<T>>>(L, std::forward<Args>(args)...);
+			}
+			else if constexpr (is_unique_usertype_v<Tu>) {
+				return stack::push<detail::as_unique_tag<T>>(L, std::forward<Args>(args)...);
+			}
+			else {
+				return stack::push<detail::as_value_tag<T>>(L, std::forward<Args>(args)...);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<std::reference_wrapper<T>> {
+		static int push(lua_State* L, const std::reference_wrapper<T>& t) {
+			return stack::push(L, std::addressof(detail::deref(t.get())));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_table_tag<T>> {
+		using has_kvp = meta::has_key_value_pair<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+		static int push(lua_State* L, const T& tablecont) {
+			return push(has_kvp(), std::false_type(), L, tablecont);
+		}
+
+		static int push(lua_State* L, const T& tablecont, nested_tag_t) {
+			return push(has_kvp(), std::true_type(), L, tablecont);
+		}
+
+		static int push(std::true_type, lua_State* L, const T& tablecont) {
+			return push(has_kvp(), std::true_type(), L, tablecont);
+		}
+
+		static int push(std::false_type, lua_State* L, const T& tablecont) {
+			return push(has_kvp(), std::false_type(), L, tablecont);
+		}
+
+		template <bool is_nested>
+		static int push(std::true_type, std::integral_constant<bool, is_nested>, lua_State* L, const T& tablecont) {
+			auto& cont = detail::deref(detail::unwrap(tablecont));
+			lua_createtable(L, static_cast<int>(cont.size()), 0);
+			int tableindex = lua_gettop(L);
+			for (const auto& pair : cont) {
+				if (is_nested) {
+					set_field(L, pair.first, as_nested_ref(pair.second), tableindex);
+				}
+				else {
+					set_field(L, pair.first, pair.second, tableindex);
+				}
+			}
+			return 1;
+		}
+
+		template <bool is_nested>
+		static int push(std::false_type, std::integral_constant<bool, is_nested>, lua_State* L, const T& tablecont) {
+			auto& cont = detail::deref(detail::unwrap(tablecont));
+			lua_createtable(L, stack_detail::get_size_hint(cont), 0);
+			int tableindex = lua_gettop(L);
+			std::size_t index = 1;
+			for (const auto& i : cont) {
+#if SOL_LUA_VERSION_I_ >= 503
+				int p = is_nested ? stack::push(L, as_nested_ref(i)) : stack::push(L, i);
+				for (int pi = 0; pi < p; ++pi) {
+					lua_seti(L, tableindex, static_cast<lua_Integer>(index++));
+				}
+#else
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				lua_pushinteger(L, static_cast<lua_Integer>(index));
+				int p = is_nested ? stack::push(L, as_nested_ref(i)) : stack::push(L, i);
+				if (p == 1) {
+					++index;
+					lua_settable(L, tableindex);
+				}
+				else {
+					int firstindex = tableindex + 1 + 1;
+					for (int pi = 0; pi < p; ++pi) {
+						stack::push(L, index);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+						luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+						lua_pushvalue(L, firstindex);
+						lua_settable(L, tableindex);
+						++index;
+						++firstindex;
+					}
+					lua_pop(L, 1 + p);
+				}
+#endif // Lua Version 5.3 and others
+			}
+			// TODO: figure out a better way to do this...?
+			// set_field(L, -1, cont.size());
+			return 1;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<as_table_t<T>> {
+		static int push(lua_State* L, const as_table_t<T>& value_) {
+			using inner_t = std::remove_pointer_t<meta::unwrap_unqualified_t<T>>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, value_.value());
+			}
+			else {
+				return stack::push(L, value_.value());
+			}
+		}
+
+		static int push(lua_State* L, const T& value_) {
+			using inner_t = std::remove_pointer_t<meta::unwrap_unqualified_t<T>>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, value_);
+			}
+			else {
+				return stack::push(L, value_);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<nested<T>> {
+		static int push(lua_State* L, const T& nested_value) noexcept {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			using inner_t = std::remove_pointer_t<Tu>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, nested_value, nested_tag);
+			}
+			else {
+				return stack::push<Tu>(L, nested_value);
+			}
+		}
+
+		static int push(lua_State* L, const nested<T>& nested_wrapper_) noexcept {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			using inner_t = std::remove_pointer_t<Tu>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, nested_wrapper_.value(), nested_tag);
+			}
+			else {
+				return stack::push<Tu>(L, nested_wrapper_.value());
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<std::initializer_list<T>> {
+		static int push(lua_State* L, const std::initializer_list<T>& il) noexcept {
+			unqualified_pusher<detail::as_table_tag<std::initializer_list<T>>> p {};
+			return p.push(L, il);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<lua_nil_t> {
+		static int push(lua_State* L, lua_nil_t) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushnil(L);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<stack_count> {
+		static int push(lua_State*, stack_count st) noexcept {
+			return st.count;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<metatable_key_t> {
+		static int push(lua_State* L, metatable_key_t) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, to_string(meta_function::metatable).c_str(), 4);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<std::remove_pointer_t<lua_CFunction>> {
+		static int push(lua_State* L, lua_CFunction func, int n = 0) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<lua_CFunction> {
+		static int push(lua_State* L, lua_CFunction func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+	template <>
+	struct unqualified_pusher<std::remove_pointer_t<detail::lua_CFunction_noexcept>> {
+		static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<detail::lua_CFunction_noexcept> {
+		static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+#endif // noexcept function type
+
+	template <>
+	struct unqualified_pusher<c_closure> {
+		static int push(lua_State* L, c_closure cc) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, cc.c_function, cc.upvalues);
+			return 1;
+		}
+	};
+
+	template <typename Arg, typename... Args>
+	struct unqualified_pusher<closure<Arg, Args...>> {
+		template <std::size_t... I, typename T>
+		static int push(std::index_sequence<I...>, lua_State* L, T&& c) {
+			using f_tuple = decltype(std::forward<T>(c).upvalues);
+			int pushcount = multi_push(L, std::get<I>(std::forward<f_tuple>(std::forward<T>(c).upvalues))...);
+			return stack::push(L, c_closure(c.c_function, pushcount));
+		}
+
+		template <typename T>
+		static int push(lua_State* L, T&& c) {
+			return push(std::make_index_sequence<1 + sizeof...(Args)>(), L, std::forward<T>(c));
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<void*> {
+		static int push(lua_State* L, void* userdata) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, userdata);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const void*> {
+		static int push(lua_State* L, const void* userdata) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, const_cast<void*>(userdata));
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<lightuserdata_value> {
+		static int push(lua_State* L, lightuserdata_value userdata) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, userdata);
+			return 1;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<light<T>> {
+		static int push(lua_State* L, light<T> l) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, static_cast<void*>(l.value()));
+			return 1;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<user<T>> {
+		template <bool with_meta = true, typename Key, typename... Args>
+		static int push_with(lua_State* L, Key&& name, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+       // A dumb pusher
+			T* data = detail::user_allocate<T>(L);
+			if (with_meta) {
+				// Make sure we have a plain GC set for this data
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				if (luaL_newmetatable(L, name) != 0) {
+					lua_CFunction cdel = detail::user_alloc_destroy<T>;
+					lua_pushcclosure(L, cdel, 0);
+					lua_setfield(L, -2, "__gc");
+				}
+				lua_setmetatable(L, -2);
+			}
+			std::allocator<T> alloc {};
+			std::allocator_traits<std::allocator<T>>::construct(alloc, data, std::forward<Args>(args)...);
+			return 1;
+		}
+
+		template <typename Arg, typename... Args>
+		static int push(lua_State* L, Arg&& arg, Args&&... args) {
+			if constexpr (std::is_same_v<meta::unqualified_t<Arg>, metatable_key_t>) {
+				const auto name = &arg[0];
+				return push_with<true>(L, name, std::forward<Args>(args)...);
+			}
+			else if constexpr (std::is_same_v<meta::unqualified_t<Arg>, no_metatable_t>) {
+				(void)arg;
+				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+				return push_with<false>(L, name, std::forward<Args>(args)...);
+			}
+			else {
+				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+				return push_with(L, name, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+
+		static int push(lua_State* L, const user<T>& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with(L, name, u.value);
+		}
+
+		static int push(lua_State* L, user<T>&& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with(L, name, std::move(u.value()));
+		}
+
+		static int push(lua_State* L, no_metatable_t, const user<T>& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with<false>(L, name, u.value());
+		}
+
+		static int push(lua_State* L, no_metatable_t, user<T>&& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with<false>(L, name, std::move(u.value()));
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<userdata_value> {
+		static int push(lua_State* L, userdata_value data) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+			void** ud = detail::usertype_allocate_pointer<void>(L);
+			*ud = data.value();
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const char*> {
+		static int push_sized(lua_State* L, const char* str, std::size_t len) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, len);
+			return 1;
+		}
+
+		static int push(lua_State* L, const char* str) {
+			if (str == nullptr)
+				return stack::push(L, lua_nil);
+			return push_sized(L, str, std::char_traits<char>::length(str));
+		}
+
+		static int push(lua_State* L, const char* strb, const char* stre) {
+			return push_sized(L, strb, static_cast<std::size_t>(stre - strb));
+		}
+
+		static int push(lua_State* L, const char* str, std::size_t len) {
+			return push_sized(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char*> {
+		static int push_sized(lua_State* L, const char* str, std::size_t len) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push_sized(L, str, len);
+		}
+
+		static int push(lua_State* L, const char* str) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char* strb, const char* stre) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char* str, std::size_t len) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char[N]> {
+		static int push(lua_State* L, const char (&str)[N]) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, std::char_traits<char>::length(str));
+			return 1;
+		}
+
+		static int push(lua_State* L, const char (&str)[N], std::size_t sz) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, sz);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char> {
+		static int push(lua_State* L, char c) {
+			const char str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char*>(str), 1u);
+		}
+	};
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+	template <>
+	struct unqualified_pusher<const char8_t*> {
+		static int push_sized(lua_State* L, const char8_t* str, std::size_t len) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, reinterpret_cast<const char*>(str), len);
+			return 1;
+		}
+
+		static int push(lua_State* L, const char8_t* str) {
+			if (str == nullptr)
+				return stack::push(L, lua_nil);
+			return push_sized(L, str, std::char_traits<char>::length(reinterpret_cast<const char*>(str)));
+		}
+
+		static int push(lua_State* L, const char8_t* strb, const char8_t* stre) {
+			return push_sized(L, strb, static_cast<std::size_t>(stre - strb));
+		}
+
+		static int push(lua_State* L, const char8_t* str, std::size_t len) {
+			return push_sized(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char8_t*> {
+		static int push_sized(lua_State* L, const char8_t* str, std::size_t len) {
+			unqualified_pusher<const char8_t*> p {};
+			(void)p;
+			return p.push_sized(L, str, len);
+		}
+
+		static int push(lua_State* L, const char8_t* str) {
+			unqualified_pusher<const char8_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char8_t* strb, const char8_t* stre) {
+			unqualified_pusher<const char8_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char8_t* str, std::size_t len) {
+			unqualified_pusher<const char8_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char8_t[N]> {
+		static int push(lua_State* L, const char8_t (&str)[N]) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			const char* str_as_char = reinterpret_cast<const char*>(static_cast<const char8_t*>(str));
+			lua_pushlstring(L, str_as_char, std::char_traits<char>::length(str_as_char));
+			return 1;
+		}
+
+		static int push(lua_State* L, const char8_t (&str)[N], std::size_t sz) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, sz);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char8_t> {
+		static int push(lua_State* L, char8_t c) {
+			const char8_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char8_t*>(str), 1u);
+		}
+	};
+#endif // char8_t
+
+	template <typename Ch, typename Traits, typename Al>
+	struct unqualified_pusher<std::basic_string<Ch, Traits, Al>> {
+		static int push(lua_State* L, const std::basic_string<Ch, Traits, Al>& str) {
+			if constexpr (!std::is_same_v<Ch, char>) {
+				return stack::push(L, str.data(), str.size());
+			}
+			else {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+				lua_pushlstring(L, str.c_str(), str.size());
+				return 1;
+			}
+		}
+
+		static int push(lua_State* L, const std::basic_string<Ch, Traits, Al>& str, std::size_t sz) {
+			if constexpr (!std::is_same_v<Ch, char>) {
+				return stack::push(L, str.data(), sz);
+			}
+			else {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+				lua_pushlstring(L, str.c_str(), sz);
+				return 1;
+			}
+		}
+	};
+
+	template <typename Ch, typename Traits>
+	struct unqualified_pusher<basic_string_view<Ch, Traits>> {
+		static int push(lua_State* L, const basic_string_view<Ch, Traits>& sv) {
+			return stack::push(L, sv.data(), sv.length());
+		}
+
+		static int push(lua_State* L, const basic_string_view<Ch, Traits>& sv, std::size_t n) {
+			return stack::push(L, sv.data(), n);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<meta_function> {
+		static int push(lua_State* L, meta_function m) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_meta_function_name);
+#endif // make sure stack doesn't overflow
+			const std::string& str = to_string(m);
+			lua_pushlstring(L, str.c_str(), str.size());
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<absolute_index> {
+		static int push(lua_State* L, absolute_index ai) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L, ai);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<raw_index> {
+		static int push(lua_State* L, raw_index ri) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L, ri);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<ref_index> {
+		static int push(lua_State* L, ref_index ri) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_rawgeti(L, LUA_REGISTRYINDEX, ri);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const wchar_t*> {
+		static int push(lua_State* L, const wchar_t* wstr) {
+			return push(L, wstr, std::char_traits<wchar_t>::length(wstr));
+		}
+
+		static int push(lua_State* L, const wchar_t* wstr, std::size_t sz) {
+			return push(L, wstr, wstr + sz);
+		}
+
+		static int push(lua_State* L, const wchar_t* strb, const wchar_t* stre) {
+			if constexpr (sizeof(wchar_t) == 2) {
+				const char16_t* sb = reinterpret_cast<const char16_t*>(strb);
+				const char16_t* se = reinterpret_cast<const char16_t*>(stre);
+				return stack::push(L, sb, se);
+			}
+			else {
+				const char32_t* sb = reinterpret_cast<const char32_t*>(strb);
+				const char32_t* se = reinterpret_cast<const char32_t*>(stre);
+				return stack::push(L, sb, se);
+			}
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<wchar_t*> {
+		static int push(lua_State* L, const wchar_t* str) {
+			unqualified_pusher<const wchar_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const wchar_t* strb, const wchar_t* stre) {
+			unqualified_pusher<const wchar_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const wchar_t* str, std::size_t len) {
+			unqualified_pusher<const wchar_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const char16_t*> {
+		static int convert_into(lua_State* L, char* start, std::size_t, const char16_t* strb, const char16_t* stre) {
+			char* target = start;
+			char32_t cp = 0;
+			for (const char16_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf16_to_code_point(strtarget, stre);
+				if (dr.error != unicode::error_code::ok) {
+					cp = unicode::unicode_detail::replacement;
+				}
+				else {
+					cp = dr.codepoint;
+				}
+				auto er = unicode::code_point_to_utf8(cp);
+				const char* utf8data = er.code_units.data();
+				std::memcpy(target, utf8data, er.code_units_size);
+				target += er.code_units_size;
+				strtarget = dr.next;
+			}
+
+			return stack::push(L, start, target);
+		}
+
+		static int push(lua_State* L, const char16_t* u16str) {
+			return push(L, u16str, std::char_traits<char16_t>::length(u16str));
+		}
+
+		static int push(lua_State* L, const char16_t* u16str, std::size_t sz) {
+			return push(L, u16str, u16str + sz);
+		}
+
+		static int push(lua_State* L, const char16_t* strb, const char16_t* stre) {
+			char sbo[SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_];
+			// if our max string space is small enough, use SBO
+			// right off the bat
+			std::size_t max_possible_code_units = static_cast<std::size_t>(static_cast<std::size_t>(stre - strb) * static_cast<std::size_t>(4));
+			if (max_possible_code_units <= SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, max_possible_code_units, strb, stre);
+			}
+			// otherwise, we must manually count/check size
+			std::size_t needed_size = 0;
+			for (const char16_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf16_to_code_point(strtarget, stre);
+				auto er = unicode::code_point_to_utf8(dr.codepoint);
+				needed_size += er.code_units_size;
+				strtarget = dr.next;
+			}
+			if (needed_size < SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, needed_size, strb, stre);
+			}
+			std::string u8str("", 0);
+			u8str.resize(needed_size);
+			char* target = const_cast<char*>(u8str.data());
+			return convert_into(L, target, needed_size, strb, stre);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char16_t*> {
+		static int push(lua_State* L, const char16_t* str) {
+			unqualified_pusher<const char16_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char16_t* strb, const char16_t* stre) {
+			unqualified_pusher<const char16_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char16_t* str, std::size_t len) {
+			unqualified_pusher<const char16_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const char32_t*> {
+		static int convert_into(lua_State* L, char* start, std::size_t, const char32_t* strb, const char32_t* stre) {
+			char* target = start;
+			char32_t cp = 0;
+			for (const char32_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf32_to_code_point(strtarget, stre);
+				if (dr.error != unicode::error_code::ok) {
+					cp = unicode::unicode_detail::replacement;
+				}
+				else {
+					cp = dr.codepoint;
+				}
+				auto er = unicode::code_point_to_utf8(cp);
+				const char* data = er.code_units.data();
+				std::memcpy(target, data, er.code_units_size);
+				target += er.code_units_size;
+				strtarget = dr.next;
+			}
+			return stack::push(L, start, target);
+		}
+
+		static int push(lua_State* L, const char32_t* u32str) {
+			return push(L, u32str, u32str + std::char_traits<char32_t>::length(u32str));
+		}
+
+		static int push(lua_State* L, const char32_t* u32str, std::size_t sz) {
+			return push(L, u32str, u32str + sz);
+		}
+
+		static int push(lua_State* L, const char32_t* strb, const char32_t* stre) {
+			char sbo[SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_];
+			// if our max string space is small enough, use SBO
+			// right off the bat
+			std::size_t max_possible_code_units = static_cast<std::size_t>(static_cast<std::size_t>(stre - strb) * static_cast<std::size_t>(4));
+			if (max_possible_code_units <= SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, max_possible_code_units, strb, stre);
+			}
+			// otherwise, we must manually count/check size
+			std::size_t needed_size = 0;
+			for (const char32_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf32_to_code_point(strtarget, stre);
+				auto er = unicode::code_point_to_utf8(dr.codepoint);
+				needed_size += er.code_units_size;
+				strtarget = dr.next;
+			}
+			if (needed_size < SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, needed_size, strb, stre);
+			}
+			std::string u8str("", 0);
+			u8str.resize(needed_size);
+			char* target = const_cast<char*>(u8str.data());
+			return convert_into(L, target, needed_size, strb, stre);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char32_t*> {
+		static int push(lua_State* L, const char32_t* str) {
+			unqualified_pusher<const char32_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char32_t* strb, const char32_t* stre) {
+			unqualified_pusher<const char32_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char32_t* str, std::size_t len) {
+			unqualified_pusher<const char32_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<wchar_t[N]> {
+		static int push(lua_State* L, const wchar_t (&str)[N]) {
+			return push(L, str, std::char_traits<wchar_t>::length(str));
+		}
+
+		static int push(lua_State* L, const wchar_t (&str)[N], std::size_t sz) {
+			const wchar_t* str_ptr = static_cast<const wchar_t*>(str);
+			return stack::push<const wchar_t*>(L, str_ptr, str_ptr + sz);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char16_t[N]> {
+		static int push(lua_State* L, const char16_t (&str)[N]) {
+			return push(L, str, std::char_traits<char16_t>::length(str));
+		}
+
+		static int push(lua_State* L, const char16_t (&str)[N], std::size_t sz) {
+			const char16_t* str_ptr = static_cast<const char16_t*>(str);
+			return stack::push<const char16_t*>(L, str_ptr, str_ptr + sz);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char32_t[N]> {
+		static int push(lua_State* L, const char32_t (&str)[N]) {
+			return push(L, str, std::char_traits<char32_t>::length(str));
+		}
+
+		static int push(lua_State* L, const char32_t (&str)[N], std::size_t sz) {
+			const char32_t* str_ptr = static_cast<const char32_t*>(str);
+			return stack::push<const char32_t*>(L, str_ptr, str_ptr + sz);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<wchar_t> {
+		static int push(lua_State* L, wchar_t c) {
+			const wchar_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const wchar_t*>(str), 1u);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char16_t> {
+		static int push(lua_State* L, char16_t c) {
+			const char16_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char16_t*>(str), 1u);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char32_t> {
+		static int push(lua_State* L, char32_t c) {
+			const char32_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char32_t*>(str), 1u);
+		}
+	};
+
+	template <typename... Args>
+	struct unqualified_pusher<std::tuple<Args...>> {
+		template <std::size_t... I, typename T>
+		static int push(std::index_sequence<I...>, lua_State* L, T&& t) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, static_cast<int>(sizeof...(I)), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			int pushcount = 0;
+			(void)detail::swallow { 0, (pushcount += stack::push(L, std::get<I>(std::forward<T>(t))), 0)... };
+			return pushcount;
+		}
+
+		template <typename T>
+		static int push(lua_State* L, T&& t) {
+			return push(std::index_sequence_for<Args...>(), L, std::forward<T>(t));
+		}
+	};
+
+	template <typename A, typename B>
+	struct unqualified_pusher<std::pair<A, B>> {
+		template <typename T>
+		static int push(lua_State* L, T&& t) {
+			int pushcount = stack::push(L, std::get<0>(std::forward<T>(t)));
+			pushcount += stack::push(L, std::get<1>(std::forward<T>(t)));
+			return pushcount;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<T, std::enable_if_t<meta::is_optional_v<T>>> {
+		using ValueType = typename meta::unqualified_t<T>::value_type;
+
+		template <typename Optional>
+		static int push(lua_State* L, Optional&& op) {
+			using QualifiedValueType = meta::conditional_t<std::is_lvalue_reference_v<Optional>, ValueType&, ValueType&&>;
+			if (!op) {
+				return stack::push(L, nullopt);
+			}
+			return stack::push(L, static_cast<QualifiedValueType>(op.value()));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<forward_as_value_t<T>> {
+		static int push(lua_State* L, const forward_as_value_t<T>& value_) {
+			return stack::push<T>(L, value_.value());
+		}
+
+		static int push(lua_State* L, forward_as_value_t<T>&& value_) {
+			return stack::push<T>(L, std::move(value_).value());
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<nullopt_t> {
+		static int push(lua_State* L, nullopt_t) noexcept {
+			return stack::push(L, lua_nil);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<std::nullptr_t> {
+		static int push(lua_State* L, std::nullptr_t) noexcept {
+			return stack::push(L, lua_nil);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<this_state> {
+		static int push(lua_State*, const this_state&) noexcept {
+			return 0;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<this_main_state> {
+		static int push(lua_State*, const this_main_state&) noexcept {
+			return 0;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<new_table> {
+		static int push(lua_State* L, const new_table& nt) {
+			lua_createtable(L, nt.sequence_hint, nt.map_hint);
+			return 1;
+		}
+	};
+
+	template <typename Allocator>
+	struct unqualified_pusher<basic_bytecode<Allocator>> {
+		template <typename T>
+		static int push(lua_State* L, T&& bc, const char* bytecode_name) {
+			const auto first = bc.data();
+			const auto bcsize = bc.size();
+			// pushes either the function, or an error
+			// if it errors, shit goes south, and people can test that upstream
+			(void)luaL_loadbuffer(
+				L, reinterpret_cast<const char*>(first), static_cast<std::size_t>(bcsize * (sizeof(*first) / sizeof(const char))), bytecode_name);
+			return 1;
+		}
+
+		template <typename T>
+		static int push(lua_State* L, T&& bc) {
+			return push(L, std::forward<bc>(bc), "bytecode");
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+	namespace stack_detail {
+
+		struct push_function {
+			lua_State* L;
+
+			push_function(lua_State* L_) noexcept : L(L_) {
+			}
+
+			template <typename T>
+			int operator()(T&& value) const {
+				return stack::push<T>(L, std::forward<T>(value));
+			}
+		};
+
+	} // namespace stack_detail
+
+	template <typename... Tn>
+	struct unqualified_pusher<std::variant<Tn...>> {
+		static int push(lua_State* L, const std::variant<Tn...>& v) {
+			return std::visit(stack_detail::push_function(L), v);
+		}
+
+		static int push(lua_State* L, std::variant<Tn...>&& v) {
+			return std::visit(stack_detail::push_function(L), std::move(v));
+		}
+	};
+#endif // Variant because Clang is terrible
+
+}} // namespace sol::stack
+
+// end of sol/stack_push.hpp
+
+// beginning of sol/stack_pop.hpp
+
+#include <utility>
+#include <tuple>
+
+namespace sol { namespace stack {
+	template <typename T, typename>
+	struct popper {
+		inline static decltype(auto) pop(lua_State* L) {
+			if constexpr (is_stack_based_v<meta::unqualified_t<T>>) {
+				static_assert(!is_stack_based_v<meta::unqualified_t<T>>,
+					"You cannot pop something that lives solely on the stack: it will not remain on the stack when popped and thusly will go out of "
+					"scope!");
+			}
+			else {
+				record tracking {};
+				decltype(auto) r = get<T>(L, -lua_size<T>::value, tracking);
+				lua_pop(L, tracking.used);
+				return r;
+			}
+		}
+	};
+}} // namespace sol::stack
+
+// end of sol/stack_pop.hpp
+
+// beginning of sol/stack_field.hpp
+
+namespace sol { namespace stack {
+
+	namespace stack_detail {
+		template <typename T, bool global, bool raw>
+		inline constexpr bool is_get_direct_tableless_v = (global && !raw && meta::is_c_str_or_string_v<T>);
+
+		template <typename T, bool global, bool raw>
+		inline constexpr bool is_get_direct_v = (is_get_direct_tableless_v<T, global, raw>) // cf-hack
+			|| (!global && !raw && (meta::is_c_str_or_string_v<T> || meta::is_string_of_v<T, char>)) // cf-hack
+			|| (!global && raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))
+#if SOL_LUA_VERSION_I_ >= 503
+			|| (!global && !raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))
+#endif // integer keys 5.3 or better
+#if SOL_LUA_VERSION_I_ >= 502
+			|| (!global && raw && std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>)
+#endif // void pointer keys 5.2 or better
+			;
+
+		template <typename T, bool global, bool raw>
+		inline constexpr bool is_set_direct_tableless_v = (global && !raw && meta::is_c_str_or_string_v<T>);
+
+		template <typename T, bool global, bool raw>
+		inline constexpr bool is_set_direct_v = (is_set_direct_tableless_v<T, global, raw>) // cf-hack
+			|| (!global && !raw && (meta::is_c_str_or_string_v<T> || meta::is_string_of_v<T, char>)) // cf-hack
+			|| (!global && raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))     // cf-hack
+#if SOL_LUA_VERSION_I_ >= 503
+			|| (!global && !raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))
+#endif // integer keys 5.3 or better
+#if SOL_LUA_VERSION_I_ >= 502
+			|| (!global && raw && (std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>))
+#endif // void pointer keys 5.2 or better
+			;
+	} // namespace stack_detail
+
+	template <typename T, bool global, bool raw, typename>
+	struct field_getter {
+		static inline constexpr int default_table_index
+			= meta::conditional_t<stack_detail::is_get_direct_v<T, global, raw>, std::integral_constant<int, -1>, std::integral_constant<int, -2>>::value;
+
+		template <typename Key>
+		void get(lua_State* L, Key&& key, int tableindex = default_table_index) {
+			if constexpr (std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, override_value_t> || std::is_same_v<T, create_if_nil_t>) {
+				(void)L;
+				(void)key;
+				(void)tableindex;
+			}
+			else if constexpr (std::is_same_v<T, env_key_t>) {
+				(void)key;
+#if SOL_LUA_VERSION_I_ < 502
+				// Use lua_setfenv
+				lua_getfenv(L, tableindex);
+#else
+				// Use upvalues as explained in Lua 5.2 and beyond's manual
+				if (lua_getupvalue(L, tableindex, 1) == nullptr) {
+					push(L, lua_nil);
+				}
+#endif
+			}
+			else if constexpr (std::is_same_v<T, metatable_key_t>) {
+				(void)key;
+				if (lua_getmetatable(L, tableindex) == 0)
+					push(L, lua_nil);
+			}
+			else if constexpr (raw) {
+				if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					lua_rawgeti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#if SOL_LUA_VERSION_I_ >= 502
+				else if constexpr (std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>) {
+					lua_rawgetp(L, tableindex, key);
+				}
+#endif // Lua 5.2.x+
+				else {
+					push(L, std::forward<Key>(key));
+					lua_rawget(L, tableindex);
+				}
+			}
+			else {
+				if constexpr (meta::is_c_str_or_string_v<T>) {
+					if constexpr (global) {
+						(void)tableindex;
+						lua_getglobal(L, &key[0]);
+					}
+					else {
+						lua_getfield(L, tableindex, &key[0]);
+					}
+				}
+				else if constexpr (std::is_same_v<T, meta_function>) {
+					const auto& real_key = to_string(key);
+					lua_getfield(L, tableindex, &real_key[0]);
+				}
+#if SOL_LUA_VERSION_I_ >= 503
+				else if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					lua_geti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#endif // Lua 5.3.x+
+				else {
+					push(L, std::forward<Key>(key));
+					lua_gettable(L, tableindex);
+				}
+			}
+		}
+	};
+
+	template <typename... Args, bool b, bool raw, typename C>
+	struct field_getter<std::tuple<Args...>, b, raw, C> {
+		template <std::size_t... I, typename Keys>
+		void apply(std::index_sequence<0, I...>, lua_State* L, Keys&& keys, int tableindex) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+			void(detail::swallow { (get_field<false, raw>(L, std::get<I>(std::forward<Keys>(keys))), 0)... });
+			reference saved(L, -1);
+			lua_pop(L, static_cast<int>(sizeof...(I)));
+			saved.push();
+		}
+
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys) {
+			apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), lua_absindex(L, -1));
+		}
+
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys, int tableindex) {
+			apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), tableindex);
+		}
+	};
+
+	template <typename A, typename B, bool b, bool raw, typename C>
+	struct field_getter<std::pair<A, B>, b, raw, C> {
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys, int tableindex) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+			get_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)));
+			reference saved(L, -1);
+			lua_pop(L, static_cast<int>(2));
+			saved.push();
+		}
+
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)));
+			get_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)));
+			reference saved(L, -1);
+			lua_pop(L, static_cast<int>(2));
+			saved.push();
+		}
+	};
+
+	template <typename T, bool global, bool raw, typename>
+	struct field_setter {
+		static constexpr int default_table_index
+			= meta::conditional_t<stack_detail::is_set_direct_v<T, global, raw>, std::integral_constant<int, -2>, std::integral_constant<int, -3>>::value;
+
+		template <typename Key, typename Value>
+		void set(lua_State* L, Key&& key, Value&& value, int tableindex = default_table_index) {
+			if constexpr (std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, override_value_t>) {
+				(void)L;
+				(void)key;
+				(void)value;
+				(void)tableindex;
+			}
+			else if constexpr (std::is_same_v<T, metatable_key_t>) {
+				(void)key;
+				push(L, std::forward<Value>(value));
+				lua_setmetatable(L, tableindex);
+			}
+			else if constexpr (raw) {
+				if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					push(L, std::forward<Value>(value));
+					lua_rawseti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#if SOL_LUA_VERSION_I_ >= 502
+				else if constexpr (std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>) {
+					push(L, std::forward<Value>(value));
+					lua_rawsetp(L, tableindex, std::forward<Key>(key));
+				}
+#endif // Lua 5.2.x
+				else {
+					push(L, std::forward<Key>(key));
+					push(L, std::forward<Value>(value));
+					lua_rawset(L, tableindex);
+				}
+			}
+			else {
+				if constexpr (meta::is_c_str_or_string_v<T>) {
+					if constexpr (global) {
+						push(L, std::forward<Value>(value));
+						lua_setglobal(L, &key[0]);
+						(void)tableindex;
+					}
+					else {
+						push(L, std::forward<Value>(value));
+						lua_setfield(L, tableindex, &key[0]);
+					}
+				}
+#if SOL_LUA_VERSION_I_ >= 503
+				else if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					push(L, std::forward<Value>(value));
+					lua_seti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#endif // Lua 5.3.x
+				else {
+					push(L, std::forward<Key>(key));
+					push(L, std::forward<Value>(value));
+					lua_settable(L, tableindex);
+				}
+			}
+		}
+	};
+
+	template <typename... Args, bool b, bool raw, typename C>
+	struct field_setter<std::tuple<Args...>, b, raw, C> {
+		template <bool g, std::size_t I, typename Keys, typename Value>
+		void apply(std::index_sequence<I>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+			I < 1 ? set_field<g, raw>(L, std::get<I>(std::forward<Keys>(keys)), std::forward<Value>(value), tableindex)
+				 : set_field<g, raw>(L, std::get<I>(std::forward<Keys>(keys)), std::forward<Value>(value));
+		}
+
+		template <bool g, std::size_t I0, std::size_t I1, std::size_t... I, typename Keys, typename Value>
+		void apply(std::index_sequence<I0, I1, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+			I0 < 1 ? get_field<g, raw>(L, std::get<I0>(std::forward<Keys>(keys)), tableindex)
+				  : get_field<g, raw>(L, std::get<I0>(std::forward<Keys>(keys)), -1);
+			apply<false>(std::index_sequence<I1, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), -1);
+		}
+
+		template <bool g, std::size_t I0, std::size_t... I, typename Keys, typename Value>
+		void top_apply(std::index_sequence<I0, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+			apply<g>(std::index_sequence<I0, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
+			lua_pop(L, static_cast<int>(sizeof...(I)));
+		}
+
+		template <typename Keys, typename Value>
+		void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -3) {
+			top_apply<b>(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
+		}
+	};
+
+	template <typename A, typename B, bool b, bool raw, typename C>
+	struct field_setter<std::pair<A, B>, b, raw, C> {
+		template <typename Keys, typename Value>
+		void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -1) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+			set_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)), std::forward<Value>(value), lua_gettop(L));
+			lua_pop(L, 1);
+		}
+	};
+}} // namespace sol::stack
+
+// end of sol/stack_field.hpp
+
+// beginning of sol/stack_probe.hpp
+
+namespace sol { namespace stack {
+	template <typename T, typename P, bool b, bool raw, typename>
+	struct probe_field_getter {
+		template <typename Key>
+		probe get(lua_State* L, Key&& key, int tableindex = -2) {
+			if constexpr (!b) {
+				if (!maybe_indexable(L, tableindex)) {
+					return probe(false, 0);
+				}
+			}
+			get_field<b, raw>(L, std::forward<Key>(key), tableindex);
+			return probe(check<P>(L), 1);
+		}
+	};
+
+	template <typename A, typename B, typename P, bool b, bool raw, typename C>
+	struct probe_field_getter<std::pair<A, B>, P, b, raw, C> {
+		template <typename Keys>
+		probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
+			if (!b && !maybe_indexable(L, tableindex)) {
+				return probe(false, 0);
+			}
+			get_field<b, raw>(L, std::get<0>(keys), tableindex);
+			if (!maybe_indexable(L)) {
+				return probe(false, 1);
+			}
+			get_field<false, raw>(L, std::get<1>(keys), tableindex);
+			return probe(check<P>(L), 2);
+		}
+	};
+
+	template <typename... Args, typename P, bool b, bool raw, typename C>
+	struct probe_field_getter<std::tuple<Args...>, P, b, raw, C> {
+		template <std::size_t I, typename Keys>
+		probe apply(std::index_sequence<I>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
+			get_field<(I < 1) && b, raw>(L, std::get<I>(keys), tableindex);
+			return probe(check<P>(L), sofar);
+		}
+
+		template <std::size_t I, std::size_t I1, std::size_t... In, typename Keys>
+		probe apply(std::index_sequence<I, I1, In...>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
+			get_field < I<1 && b, raw>(L, std::get<I>(keys), tableindex);
+			if (!maybe_indexable(L)) {
+				return probe(false, sofar);
+			}
+			return apply(std::index_sequence<I1, In...>(), sofar + 1, L, std::forward<Keys>(keys), -1);
+		}
+
+		template <typename Keys>
+		probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
+			if constexpr (!b) {
+				if (!maybe_indexable(L, tableindex)) {
+					return probe(false, 0);
+				}
+				return apply(std::index_sequence_for<Args...>(), 1, L, std::forward<Keys>(keys), tableindex);
+			}
+			else {
+				return apply(std::index_sequence_for<Args...>(), 1, L, std::forward<Keys>(keys), tableindex);
+			}
+		}
+	};
+}} // namespace sol::stack
+
+// end of sol/stack_probe.hpp
+
+#include <cstring>
+#include <array>
+
+namespace sol {
+	namespace detail {
+		using typical_chunk_name_t = char[SOL_ID_SIZE_I_];
+		using typical_file_chunk_name_t = char[SOL_FILE_ID_SIZE_I_];
+
+		inline const std::string& default_chunk_name() {
+			static const std::string name = "";
+			return name;
+		}
+
+		template <std::size_t N>
+		const char* make_chunk_name(const string_view& code, const std::string& chunkname, char (&basechunkname)[N]) {
+			if (chunkname.empty()) {
+				auto it = code.cbegin();
+				auto e = code.cend();
+				std::size_t i = 0;
+				static const std::size_t n = N - 4;
+				for (i = 0; i < n && it != e; ++i, ++it) {
+					basechunkname[i] = *it;
+				}
+				if (it != e) {
+					for (std::size_t c = 0; c < 3; ++i, ++c) {
+						basechunkname[i] = '.';
+					}
+				}
+				basechunkname[i] = '\0';
+				return &basechunkname[0];
+			}
+			else {
+				return chunkname.c_str();
+			}
+		}
+
+		inline void clear_entries(stack_reference r) {
+			stack::push(r.lua_state(), lua_nil);
+			while (lua_next(r.lua_state(), -2)) {
+				absolute_index key(r.lua_state(), -2);
+				auto pn = stack::pop_n(r.lua_state(), 1);
+				stack::set_field<false, true>(r.lua_state(), key, lua_nil, r.stack_index());
+			}
+		}
+
+		inline void clear_entries(const reference& registry_reference) {
+			auto pp = stack::push_pop(registry_reference);
+			stack_reference ref(registry_reference.lua_state(), -1);
+			clear_entries(ref);
+		}
+	} // namespace detail
+
+	namespace stack {
+		namespace stack_detail {
+			template <typename T>
+			inline int push_as_upvalues(lua_State* L, T& item) {
+				typedef std::decay_t<T> TValue;
+				static const std::size_t itemsize = sizeof(TValue);
+				static const std::size_t voidsize = sizeof(void*);
+				static const std::size_t voidsizem1 = voidsize - 1;
+				static const std::size_t data_t_count = (sizeof(TValue) + voidsizem1) / voidsize;
+				typedef std::array<void*, data_t_count> data_t;
+
+				data_t data { {} };
+				std::memcpy(&data[0], std::addressof(item), itemsize);
+				int pushcount = 0;
+				for (const auto& v : data) {
+					lua_pushlightuserdata(L, v);
+					pushcount += 1;
+				}
+				return pushcount;
+			}
+
+			template <typename T>
+			inline std::pair<T, int> get_as_upvalues(lua_State* L, int index = 2) {
+				static const std::size_t data_t_count = (sizeof(T) + (sizeof(void*) - 1)) / sizeof(void*);
+				typedef std::array<void*, data_t_count> data_t;
+				data_t voiddata { {} };
+				for (std::size_t i = 0, d = 0; d < sizeof(T); ++i, d += sizeof(void*)) {
+					voiddata[i] = lua_touserdata(L, upvalue_index(index++));
+				}
+				return std::pair<T, int>(*reinterpret_cast<T*>(static_cast<void*>(voiddata.data())), index);
+			}
+
+			template <typename T>
+			inline std::pair<T, int> get_as_upvalues_using_function(lua_State* L, int function_index = -1) {
+				static const std::size_t data_t_count = (sizeof(T) + (sizeof(void*) - 1)) / sizeof(void*);
+				typedef std::array<void*, data_t_count> data_t;
+				function_index = lua_absindex(L, function_index);
+				int index = 0;
+				data_t voiddata { {} };
+				for (std::size_t d = 0; d < sizeof(T); d += sizeof(void*)) {
+					// first upvalue is nullptr to respect environment shenanigans
+					// So +2 instead of +1
+					const char* upvalue_name = lua_getupvalue(L, function_index, index + 2);
+					if (upvalue_name == nullptr) {
+						// We should freak out here...
+						break;
+					}
+					voiddata[index] = lua_touserdata(L, -1);
+					++index;
+				}
+				lua_pop(L, index);
+				return std::pair<T, int>(*reinterpret_cast<T*>(static_cast<void*>(voiddata.data())), index);
+			}
+
+			template <bool checked, typename Handler, typename Fx, typename... Args>
+			static decltype(auto) eval(types<>, std::index_sequence<>, lua_State*, int, Handler&&, record&, Fx&& fx, Args&&... args) {
+				return std::forward<Fx>(fx)(std::forward<Args>(args)...);
+			}
+
+			template <bool checked, typename Arg, typename... Args, std::size_t I, std::size_t... Is, typename Handler, typename Fx, typename... FxArgs>
+			static decltype(auto) eval(types<Arg, Args...>, std::index_sequence<I, Is...>, lua_State* L_, int start_index_, Handler&& handler_,
+			     record& tracking_, Fx&& fx_, FxArgs&&... fxargs_) {
+#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS)
+				// We can save performance/time by letting errors unwind produced arguments
+				// rather than checking everything once, and then potentially re-doing work
+				if constexpr (checked) {
+					return eval<checked>(types<Args...>(),
+					     std::index_sequence<Is...>(),
+					     L_,
+					     start_index_,
+					     std::forward<Handler>(handler_),
+					     tracking_,
+					     std::forward<Fx>(fx_),
+					     std::forward<FxArgs>(fxargs_)...,
+					     *stack_detail::check_get_arg<Arg>(L_, start_index_ + tracking_.used, handler_, tracking_));
+				}
+				else
+#endif
+				{
+					return eval<checked>(types<Args...>(),
+					     std::index_sequence<Is...>(),
+					     L_,
+					     start_index_,
+					     std::forward<Handler>(handler_),
+					     tracking_,
+					     std::forward<Fx>(fx_),
+					     std::forward<FxArgs>(fxargs_)...,
+					     stack_detail::unchecked_get_arg<Arg>(L_, start_index_ + tracking_.used, tracking_));
+				}
+			}
+
+			template <bool checkargs = detail::default_safe_function_calls, std::size_t... I, typename R, typename... Args, typename Fx, typename... FxArgs>
+			inline decltype(auto) call(types<R>, types<Args...> argument_types_, std::index_sequence<I...> argument_indices_, lua_State* L_,
+			     int start_index_, Fx&& fx_, FxArgs&&... args_) {
+				static_assert(meta::all_v<meta::is_not_move_only<Args>...>,
+				     "One of the arguments being bound is a move-only type, and it is not being taken by reference: this will break your code. Please take "
+				     "a reference and std::move it manually if this was your intention.");
+				argument_handler<types<R, Args...>> handler {};
+				record tracking {};
+#if SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS)
+				if constexpr (checkargs) {
+					multi_check<Args...>(L_, start_index_, handler);
+				}
+#endif
+				if constexpr (std::is_void_v<R>) {
+					eval<checkargs>(
+					     argument_types_, argument_indices_, L_, start_index_, handler, tracking, std::forward<Fx>(fx_), std::forward<FxArgs>(args_)...);
+				}
+				else {
+					return eval<checkargs>(
+					     argument_types_, argument_indices_, L_, start_index_, handler, tracking, std::forward<Fx>(fx_), std::forward<FxArgs>(args_)...);
+				}
+			}
+
+			template <typename T>
+			void raw_table_set(lua_State* L, T&& arg, int tableindex = -2) {
+				int push_count = push(L, std::forward<T>(arg));
+				sol_c_assert(push_count == 1);
+				std::size_t unique_index = static_cast<std::size_t>(luaL_len(L, tableindex) + 1u);
+				lua_rawseti(L, tableindex, static_cast<int>(unique_index));
+			}
+
+		} // namespace stack_detail
+
+		template <typename T>
+		int set_ref(lua_State* L, T&& arg, int tableindex = -2) {
+			int push_count = push(L, std::forward<T>(arg));
+			sol_c_assert(push_count == 1);
+			return luaL_ref(L, tableindex);
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+		inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
+			using args_indices = std::make_index_sequence<sizeof...(Args)>;
+			if constexpr (std::is_void_v<R>) {
+				stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+			else {
+				return stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+		inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
+			if constexpr (std::is_void_v<R>) {
+				call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+			else {
+				return call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+		inline decltype(auto) call_from_top(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
+			using expected_count_t = meta::count_for_pack<lua_size, Args...>;
+			if constexpr (std::is_void_v<R>) {
+				call<check_args>(tr,
+				     ta,
+				     L,
+				     (std::max)(static_cast<int>(lua_gettop(L) - expected_count_t::value), static_cast<int>(0)),
+				     std::forward<Fx>(fx),
+				     std::forward<FxArgs>(args)...);
+			}
+			else {
+				return call<check_args>(tr,
+				     ta,
+				     L,
+				     (std::max)(static_cast<int>(lua_gettop(L) - expected_count_t::value), static_cast<int>(0)),
+				     std::forward<Fx>(fx),
+				     std::forward<FxArgs>(args)...);
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Ret0, typename... Ret, typename... Args,
+		     typename Fx, typename... FxArgs>
+		inline int call_into_lua(types<Ret0, Ret...> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
+			if constexpr (std::is_void_v<Ret0>) {
+				call<check_args>(tr, ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+				if constexpr (clean_stack) {
+					lua_settop(L, 0);
+				}
+				return 0;
+			}
+			else {
+				(void)tr;
+				decltype(auto) r
+				     = call<check_args>(types<meta::return_type_t<Ret0, Ret...>>(), ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+				using R = meta::unqualified_t<decltype(r)>;
+				using is_stack = meta::any<is_stack_based<R>, std::is_same<R, absolute_index>, std::is_same<R, ref_index>, std::is_same<R, raw_index>>;
+				if constexpr (clean_stack && !is_stack::value) {
+					lua_settop(L, 0);
+				}
+				return push_reference(L, std::forward<decltype(r)>(r));
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Fx, typename... FxArgs>
+		inline int call_lua(lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
+			using traits_type = lua_bind_traits<meta::unqualified_t<Fx>>;
+			using args_list = typename traits_type::args_list;
+			using returns_list = typename traits_type::returns_list;
+			return call_into_lua<check_args, clean_stack>(returns_list(), args_list(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+		}
+
+		inline call_syntax get_call_syntax(lua_State* L, const string_view& key, int index) {
+			if (lua_gettop(L) < 1) {
+				return call_syntax::dot;
+			}
+			luaL_getmetatable(L, key.data());
+			auto pn = pop_n(L, 1);
+			if (lua_compare(L, -1, index, LUA_OPEQ) != 1) {
+				return call_syntax::dot;
+			}
+			return call_syntax::colon;
+		}
+
+		inline void script(
+		     lua_State* L, lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			if (lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+		}
+
+		inline void script(
+		     lua_State* L, const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			if (luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+		}
+
+		inline void script_file(lua_State* L, const std::string& filename, load_mode mode = load_mode::any) {
+			if (luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+		}
+
+		inline void luajit_exception_handler(lua_State* L, int (*handler)(lua_State*, lua_CFunction) = detail::c_trampoline) {
+#if SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE)
+			if (L == nullptr) {
+				return;
+			}
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, (void*)handler);
+			auto pn = pop_n(L, 1);
+			luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_ON);
+#else
+			(void)L;
+			(void)handler;
+#endif
+		}
+
+		inline void luajit_exception_off(lua_State* L) {
+#if SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE)
+			if (L == nullptr) {
+				return;
+			}
+			luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_OFF);
+#else
+			(void)L;
+#endif
+		}
+	} // namespace stack
+} // namespace sol
+
+// end of sol/stack.hpp
+
+// beginning of sol/object.hpp
+
+// beginning of sol/make_reference.hpp
+
+namespace sol {
+
+	template <typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T>
+	R make_reference(lua_State* L, T&& value) {
+		int backpedal = stack::push(L, std::forward<T>(value));
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+	template <typename T, typename R = reference, bool should_pop = !is_stack_based_v<R>, typename... Args>
+	R make_reference(lua_State* L, Args&&... args) {
+		int backpedal = stack::push<T>(L, std::forward<Args>(args)...);
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+	template <typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T>
+	R make_reference_userdata(lua_State* L, T&& value) {
+		int backpedal = stack::push_userdata(L, std::forward<T>(value));
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+	template <typename T, typename R = reference, bool should_pop = !is_stack_based_v<R>, typename... Args>
+	R make_reference_userdata(lua_State* L, Args&&... args) {
+		int backpedal = stack::push_userdata<T>(L, std::forward<Args>(args)...);
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+} // namespace sol
+
+// end of sol/make_reference.hpp
+
+// beginning of sol/object_base.hpp
+
+namespace sol {
+
+	template <typename ref_t>
+	class basic_object_base : public ref_t {
+	private:
+		using base_t = ref_t;
+
+		template <typename T>
+		decltype(auto) as_stack(std::true_type) const {
+			return stack::get<T>(base_t::lua_state(), base_t::stack_index());
+		}
+
+		template <typename T>
+		decltype(auto) as_stack(std::false_type) const {
+			base_t::push();
+			return stack::pop<T>(base_t::lua_state());
+		}
+
+		template <typename T>
+		bool is_stack(std::true_type) const {
+			return stack::check<T>(base_t::lua_state(), base_t::stack_index(), &no_panic);
+		}
+
+		template <typename T>
+		bool is_stack(std::false_type) const {
+			int r = base_t::registry_index();
+			if (r == LUA_REFNIL)
+				return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
+			if (r == LUA_NOREF)
+				return false;
+			auto pp = stack::push_pop(*this);
+			return stack::check<T>(base_t::lua_state(), -1, &no_panic);
+		}
+
+	public:
+		basic_object_base() noexcept = default;
+		basic_object_base(const basic_object_base&) = default;
+		basic_object_base(basic_object_base&&) = default;
+		basic_object_base& operator=(const basic_object_base&) = default;
+		basic_object_base& operator=(basic_object_base&&) = default;
+		template <typename T, typename... Args, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object_base>>> = meta::enabler>
+		basic_object_base(T&& arg, Args&&... args) : base_t(std::forward<T>(arg), std::forward<Args>(args)...) {
+		}
+
+		template <typename T>
+		decltype(auto) as() const {
+			return as_stack<T>(is_stack_based<base_t>());
+		}
+
+		template <typename T>
+		bool is() const {
+			return is_stack<T>(is_stack_based<base_t>());
+		}
+	};
+} // namespace sol
+
+// end of sol/object_base.hpp
+
+namespace sol {
+
+	template <typename base_type>
+	class basic_object : public basic_object_base<base_type> {
+	private:
+		typedef basic_object_base<base_type> base_t;
+
+		template <bool invert_and_pop = false>
+		basic_object(std::integral_constant<bool, invert_and_pop>, lua_State* L_, int index_ = -1) noexcept : base_t(L_, index_) {
+			if (invert_and_pop) {
+				lua_pop(L_, -index_);
+			}
+		}
+
+	protected:
+		basic_object(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+		}
+		basic_object(detail::no_safety_tag, lua_State* L_, int index_) : base_t(L_, index_) {
+		}
+		basic_object(detail::no_safety_tag, lua_State* L_, ref_index index_) : base_t(L_, index_) {
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_object>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(detail::no_safety_tag, lua_State* L_, T&& r) noexcept : base_t(L_, std::forward<T>(r)) {
+		}
+
+	public:
+		basic_object() noexcept = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(T&& r) : base_t(std::forward<T>(r)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(lua_State* L_, T&& r) : base_t(L_, std::forward<T>(r)) {
+		}
+		basic_object(lua_State* L_, global_tag_t t) : base_t(L_, t) {
+		}
+		basic_object(lua_nil_t r) : base_t(r) {
+		}
+		basic_object(const basic_object&) = default;
+		basic_object(basic_object&&) = default;
+		basic_object(const stack_reference& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {
+		}
+		basic_object(stack_reference&& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {
+		}
+		template <typename Super>
+		basic_object(const proxy_base<Super>& r) noexcept : basic_object(r.operator basic_object()) {
+		}
+		template <typename Super>
+		basic_object(proxy_base<Super>&& r) noexcept : basic_object(r.operator basic_object()) {
+		}
+		basic_object(lua_State* L_, lua_nil_t r) noexcept : base_t(L_, r) {
+		}
+		basic_object(lua_State* L_, int index_ = -1) noexcept : base_t(L_, index_) {
+		}
+		basic_object(lua_State* L_, absolute_index index_) noexcept : base_t(L_, index_) {
+		}
+		basic_object(lua_State* L_, raw_index index_) noexcept : base_t(L_, index_) {
+		}
+		basic_object(lua_State* L_, ref_index index_) noexcept : base_t(L_, index_) {
+		}
+		template <typename T, typename... Args>
+		basic_object(lua_State* L_, in_place_type_t<T>, Args&&... args) noexcept
+		: basic_object(std::integral_constant<bool, !is_stack_based<base_t>::value>(), L_, -stack::push<T>(L_, std::forward<Args>(args)...)) {
+		}
+		template <typename T, typename... Args>
+		basic_object(lua_State* L_, in_place_t, T&& arg, Args&&... args) noexcept
+		: basic_object(L_, in_place_type<T>, std::forward<T>(arg), std::forward<Args>(args)...) {
+		}
+		basic_object& operator=(const basic_object&) = default;
+		basic_object& operator=(basic_object&&) = default;
+		basic_object& operator=(const base_type& b) {
+			base_t::operator=(b);
+			return *this;
+		}
+		basic_object& operator=(base_type&& b) {
+			base_t::operator=(std::move(b));
+			return *this;
+		}
+		template <typename Super>
+		basic_object& operator=(const proxy_base<Super>& r) {
+			this->operator=(r.operator basic_object());
+			return *this;
+		}
+		template <typename Super>
+		basic_object& operator=(proxy_base<Super>&& r) {
+			this->operator=(r.operator basic_object());
+			return *this;
+		}
+	};
+
+	template <typename T>
+	object make_object(lua_State* L_, T&& value) {
+		return make_reference<object, true>(L_, std::forward<T>(value));
+	}
+
+	template <typename T, typename... Args>
+	object make_object(lua_State* L_, Args&&... args) {
+		return make_reference<T, object, true>(L_, std::forward<Args>(args)...);
+	}
+
+	template <typename T>
+	object make_object_userdata(lua_State* L_, T&& value) {
+		return make_reference_userdata<object, true>(L_, std::forward<T>(value));
+	}
+
+	template <typename T, typename... Args>
+	object make_object_userdata(lua_State* L_, Args&&... args) {
+		return make_reference_userdata<T, object, true>(L_, std::forward<Args>(args)...);
+	}
+} // namespace sol
+
+// end of sol/object.hpp
+
+// beginning of sol/function.hpp
+
+// beginning of sol/unsafe_function.hpp
+
+// beginning of sol/function_result.hpp
+
+// beginning of sol/protected_function_result.hpp
+
+// beginning of sol/proxy_base.hpp
+
+namespace sol {
+	struct proxy_base_tag { };
+
+	namespace detail {
+		template <typename T>
+		using proxy_key_t = meta::conditional_t<meta::is_specialization_of_v<meta::unqualified_t<T>, std::tuple>, T,
+		     std::tuple<meta::conditional_t<std::is_array_v<meta::unqualified_t<T>>, std::remove_reference_t<T>&, meta::unqualified_t<T>>>>;
+	}
+
+	template <typename Super>
+	struct proxy_base : public proxy_base_tag {
+		lua_State* lua_state() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.lua_state();
+		}
+
+		operator std::string() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.template get<std::string>();
+		}
+
+		template <typename T, meta::enable<meta::neg<meta::is_string_constructible<T>>, is_proxy_primitive<meta::unqualified_t<T>>> = meta::enabler>
+		operator T() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.template get<T>();
+		}
+
+		template <typename T,
+		     meta::enable<meta::neg<meta::is_string_constructible<T>>, meta::neg<is_proxy_primitive<meta::unqualified_t<T>>>> = meta::enabler>
+		operator T&() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.template get<T&>();
+		}
+	};
+
+} // namespace sol
+
+// end of sol/proxy_base.hpp
+
+// beginning of sol/stack_iterator.hpp
+
+#include <limits>
+#include <iterator>
+
+namespace sol {
+	template <typename proxy_t, bool is_const>
+	struct stack_iterator {
+		typedef meta::conditional_t<is_const, const proxy_t, proxy_t> reference;
+		typedef meta::conditional_t<is_const, const proxy_t*, proxy_t*> pointer;
+		typedef proxy_t value_type;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::random_access_iterator_tag iterator_category;
+		lua_State* L;
+		int index;
+		int stacktop;
+		proxy_t sp;
+
+		stack_iterator() : L(nullptr), index((std::numeric_limits<int>::max)()), stacktop((std::numeric_limits<int>::max)()), sp() {
+		}
+		stack_iterator(const stack_iterator<proxy_t, true>& r) : L(r.L), index(r.index), stacktop(r.stacktop), sp(r.sp) {
+		}
+		stack_iterator(lua_State* luastate, int idx, int topidx) : L(luastate), index(idx), stacktop(topidx), sp(luastate, idx) {
+		}
+
+		reference operator*() {
+			return proxy_t(L, index);
+		}
+
+		reference operator*() const {
+			return proxy_t(L, index);
+		}
+
+		pointer operator->() {
+			sp = proxy_t(L, index);
+			return &sp;
+		}
+
+		pointer operator->() const {
+			const_cast<proxy_t&>(sp) = proxy_t(L, index);
+			return &sp;
+		}
+
+		stack_iterator& operator++() {
+			++index;
+			return *this;
+		}
+
+		stack_iterator operator++(int) {
+			auto r = *this;
+			this->operator++();
+			return r;
+		}
+
+		stack_iterator& operator--() {
+			--index;
+			return *this;
+		}
+
+		stack_iterator operator--(int) {
+			auto r = *this;
+			this->operator--();
+			return r;
+		}
+
+		stack_iterator& operator+=(difference_type idx) {
+			index += static_cast<int>(idx);
+			return *this;
+		}
+
+		stack_iterator& operator-=(difference_type idx) {
+			index -= static_cast<int>(idx);
+			return *this;
+		}
+
+		difference_type operator-(const stack_iterator& r) const {
+			return index - r.index;
+		}
+
+		stack_iterator operator+(difference_type idx) const {
+			stack_iterator r = *this;
+			r += idx;
+			return r;
+		}
+
+		reference operator[](difference_type idx) const {
+			return proxy_t(L, index + static_cast<int>(idx));
+		}
+
+		bool operator==(const stack_iterator& r) const {
+			if (stacktop == (std::numeric_limits<int>::max)()) {
+				return r.index == r.stacktop;
+			}
+			else if (r.stacktop == (std::numeric_limits<int>::max)()) {
+				return index == stacktop;
+			}
+			return index == r.index;
+		}
+
+		bool operator!=(const stack_iterator& r) const {
+			return !(this->operator==(r));
+		}
+
+		bool operator<(const stack_iterator& r) const {
+			return index < r.index;
+		}
+
+		bool operator>(const stack_iterator& r) const {
+			return index > r.index;
+		}
+
+		bool operator<=(const stack_iterator& r) const {
+			return index <= r.index;
+		}
+
+		bool operator>=(const stack_iterator& r) const {
+			return index >= r.index;
+		}
+	};
+
+	template <typename proxy_t, bool is_const>
+	inline stack_iterator<proxy_t, is_const> operator+(
+	     typename stack_iterator<proxy_t, is_const>::difference_type n, const stack_iterator<proxy_t, is_const>& r) {
+		return r + n;
+	}
+} // namespace sol
+
+// end of sol/stack_iterator.hpp
+
+// beginning of sol/stack_proxy.hpp
+
+// beginning of sol/stack_proxy_base.hpp
+
+namespace sol {
+	struct stack_proxy_base : public proxy_base<stack_proxy_base> {
+	private:
+		lua_State* m_L;
+		int m_index;
+
+	public:
+		stack_proxy_base() : m_L(nullptr), m_index(0) {
+		}
+		stack_proxy_base(lua_State* L_, int index_) : m_L(L_), m_index(index_) {
+		}
+
+		template <typename T>
+		decltype(auto) get() const {
+			return stack::get<T>(m_L, stack_index());
+		}
+
+		template <typename T>
+		bool is() const {
+			return stack::check<T>(m_L, stack_index());
+		}
+
+		template <typename T>
+		decltype(auto) as() const {
+			return get<T>();
+		}
+
+		type get_type() const noexcept {
+			return type_of(lua_state(), stack_index());
+		}
+
+		int push() const {
+			return push(m_L);
+		}
+
+		int push(lua_State* L_) const {
+			lua_pushvalue(L_, m_index);
+			return 1;
+		}
+
+		lua_State* lua_state() const {
+			return m_L;
+		}
+		int stack_index() const {
+			return m_index;
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<stack_proxy_base> {
+			static stack_proxy_base get(lua_State* L_, int index_ = -1) {
+				return stack_proxy_base(L_, index_);
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<stack_proxy_base> {
+			static int push(lua_State*, const stack_proxy_base& proxy_reference) {
+				return proxy_reference.push();
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/stack_proxy_base.hpp
+
+namespace sol {
+	struct stack_proxy : public stack_proxy_base {
+	public:
+		stack_proxy() : stack_proxy_base() {
+		}
+		stack_proxy(lua_State* L, int index) : stack_proxy_base(L, index) {
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args);
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<stack_proxy> {
+			static stack_proxy get(lua_State* L, int index, record& tracking) {
+				tracking.use(0);
+				return stack_proxy(L, index);
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<stack_proxy> {
+			static int push(lua_State*, const stack_proxy& ref) {
+				return ref.push();
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/stack_proxy.hpp
+
+#include <cstdint>
+
+namespace sol {
+	struct protected_function_result : public proxy_base<protected_function_result> {
+	private:
+		lua_State* L;
+		int index;
+		int returncount;
+		int popcount;
+		call_status err;
+
+	public:
+		typedef stack_proxy reference_type;
+		typedef stack_proxy value_type;
+		typedef stack_proxy* pointer;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::size_t size_type;
+		typedef stack_iterator<stack_proxy, false> iterator;
+		typedef stack_iterator<stack_proxy, true> const_iterator;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		protected_function_result() noexcept : protected_function_result(nullptr) {}
+		protected_function_result(lua_State* Ls, int idx = -1, int retnum = 0, int popped = 0, call_status pferr = call_status::ok) noexcept
+		: L(Ls), index(idx), returncount(retnum), popcount(popped), err(pferr) {
+		}
+
+		// We do not want anyone to copy these around willy-nilly
+		// Will likely break people, but also will probably get rid of quiet bugs that have
+		// been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+		// LuaJIT and other Lua engines will implode and segfault at random later times.)
+		protected_function_result(const protected_function_result&) = delete;
+		protected_function_result& operator=(const protected_function_result&) = delete;
+
+		protected_function_result(protected_function_result&& o) noexcept
+		: L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.abandon();
+		}
+		protected_function_result& operator=(protected_function_result&& o) noexcept {
+			L = o.L;
+			index = o.index;
+			returncount = o.returncount;
+			popcount = o.popcount;
+			err = o.err;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.abandon();
+			return *this;
+		}
+
+		protected_function_result(const unsafe_function_result& o) = delete;
+		protected_function_result& operator=(const unsafe_function_result& o) = delete;
+		protected_function_result(unsafe_function_result&& o) noexcept;
+		protected_function_result& operator=(unsafe_function_result&& o) noexcept;
+
+		call_status status() const noexcept {
+			return err;
+		}
+
+		bool valid() const noexcept {
+			return status() == call_status::ok || status() == call_status::yielded;
+		}
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
+		template <typename T>
+		decltype(auto) get(int index_offset = 0) const {
+			using UT = meta::unqualified_t<T>;
+			int target = index + index_offset;
+			if constexpr (meta::is_optional_v<UT>) {
+				using ValueType = typename UT::value_type;
+				if constexpr (std::is_same_v<ValueType, error>) {
+					if (valid()) {
+						return UT();
+					}
+					return UT(error(detail::direct_error, stack::get<std::string>(L, target)));
+				}
+				else {
+					if (!valid()) {
+						return UT();
+					}
+					return stack::get<UT>(L, target);
+				}
+			}
+			else {
+				if constexpr (std::is_same_v<T, error>) {
+#if SOL_IS_ON(SOL_SAFE_PROXIES)
+					if (valid()) {
+						type t = type_of(L, target);
+						type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is an error)");
+					}
+#endif // Check Argument Safety
+					return error(detail::direct_error, stack::get<std::string>(L, target));
+				}
+				else {
+#if SOL_IS_ON(SOL_SAFE_PROXIES)
+					if (!valid()) {
+						type t = type_of(L, target);
+						type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is not an error)");
+					}
+#endif // Check Argument Safety
+					return stack::get<T>(L, target);
+				}
+			}
+		}
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic pop
+#endif
+
+		type get_type(int index_offset = 0) const noexcept {
+			return type_of(L, index + static_cast<int>(index_offset));
+		}
+
+		stack_proxy operator[](difference_type index_offset) const {
+			return stack_proxy(L, index + static_cast<int>(index_offset));
+		}
+
+		iterator begin() {
+			return iterator(L, index, stack_index() + return_count());
+		}
+		iterator end() {
+			return iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator begin() const {
+			return const_iterator(L, index, stack_index() + return_count());
+		}
+		const_iterator end() const {
+			return const_iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator cbegin() const {
+			return begin();
+		}
+		const_iterator cend() const {
+			return end();
+		}
+
+		reverse_iterator rbegin() {
+			return std::reverse_iterator<iterator>(begin());
+		}
+		reverse_iterator rend() {
+			return std::reverse_iterator<iterator>(end());
+		}
+		const_reverse_iterator rbegin() const {
+			return std::reverse_iterator<const_iterator>(begin());
+		}
+		const_reverse_iterator rend() const {
+			return std::reverse_iterator<const_iterator>(end());
+		}
+		const_reverse_iterator crbegin() const {
+			return std::reverse_iterator<const_iterator>(cbegin());
+		}
+		const_reverse_iterator crend() const {
+			return std::reverse_iterator<const_iterator>(cend());
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		};
+		int stack_index() const noexcept {
+			return index;
+		};
+		int return_count() const noexcept {
+			return returncount;
+		};
+		int pop_count() const noexcept {
+			return popcount;
+		};
+		void abandon() noexcept {
+			// L = nullptr;
+			index = 0;
+			returncount = 0;
+			popcount = 0;
+			err = call_status::runtime;
+		}
+		~protected_function_result() {
+			if (L == nullptr)
+				return;
+			stack::remove(L, index, popcount);
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<protected_function_result> {
+			static int push(lua_State* L, const protected_function_result& pfr) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, static_cast<int>(pfr.pop_count()), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				int p = 0;
+				for (int i = 0; i < pfr.pop_count(); ++i) {
+					lua_pushvalue(L, i + pfr.stack_index());
+					++p;
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/protected_function_result.hpp
+
+// beginning of sol/unsafe_function_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+	struct unsafe_function_result : public proxy_base<unsafe_function_result> {
+	private:
+		lua_State* L;
+		int index;
+		int returncount;
+
+	public:
+		typedef stack_proxy reference_type;
+		typedef stack_proxy value_type;
+		typedef stack_proxy* pointer;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::size_t size_type;
+		typedef stack_iterator<stack_proxy, false> iterator;
+		typedef stack_iterator<stack_proxy, true> const_iterator;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		unsafe_function_result() noexcept : unsafe_function_result(nullptr) {}
+		unsafe_function_result(lua_State* Ls, int idx = -1, int retnum = 0) noexcept : L(Ls), index(idx), returncount(retnum) {
+		}
+
+		// We do not want anyone to copy these around willy-nilly
+		// Will likely break people, but also will probably get rid of quiet bugs that have
+		// been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+		// LuaJIT and other Lua engines will implode and segfault at random later times.)
+		unsafe_function_result(const unsafe_function_result&) = delete;
+		unsafe_function_result& operator=(const unsafe_function_result&) = delete;
+
+		unsafe_function_result(unsafe_function_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.abandon();
+		}
+		unsafe_function_result& operator=(unsafe_function_result&& o) noexcept {
+			L = o.L;
+			index = o.index;
+			returncount = o.returncount;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.abandon();
+			return *this;
+		}
+
+		unsafe_function_result(const protected_function_result& o) = delete;
+		unsafe_function_result& operator=(const protected_function_result& o) = delete;
+		unsafe_function_result(protected_function_result&& o) noexcept;
+		unsafe_function_result& operator=(protected_function_result&& o) noexcept;
+
+		template <typename T>
+		decltype(auto) get(difference_type index_offset = 0) const {
+			return stack::get<T>(L, index + static_cast<int>(index_offset));
+		}
+
+		type get_type(difference_type index_offset = 0) const noexcept {
+			return type_of(L, index + static_cast<int>(index_offset));
+		}
+
+		stack_proxy operator[](difference_type index_offset) const {
+			return stack_proxy(L, index + static_cast<int>(index_offset));
+		}
+
+		iterator begin() {
+			return iterator(L, index, stack_index() + return_count());
+		}
+		iterator end() {
+			return iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator begin() const {
+			return const_iterator(L, index, stack_index() + return_count());
+		}
+		const_iterator end() const {
+			return const_iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator cbegin() const {
+			return begin();
+		}
+		const_iterator cend() const {
+			return end();
+		}
+
+		reverse_iterator rbegin() {
+			return std::reverse_iterator<iterator>(begin());
+		}
+		reverse_iterator rend() {
+			return std::reverse_iterator<iterator>(end());
+		}
+		const_reverse_iterator rbegin() const {
+			return std::reverse_iterator<const_iterator>(begin());
+		}
+		const_reverse_iterator rend() const {
+			return std::reverse_iterator<const_iterator>(end());
+		}
+		const_reverse_iterator crbegin() const {
+			return std::reverse_iterator<const_iterator>(cbegin());
+		}
+		const_reverse_iterator crend() const {
+			return std::reverse_iterator<const_iterator>(cend());
+		}
+
+		call_status status() const noexcept {
+			return call_status::ok;
+		}
+
+		bool valid() const noexcept {
+			return status() == call_status::ok || status() == call_status::yielded;
+		}
+
+		lua_State* lua_state() const {
+			return L;
+		};
+		int stack_index() const {
+			return index;
+		};
+		int return_count() const {
+			return returncount;
+		};
+		void abandon() noexcept {
+			// L = nullptr;
+			index = 0;
+			returncount = 0;
+		}
+		~unsafe_function_result() {
+			if (L != nullptr) {
+				lua_pop(L, returncount);
+			}
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<unsafe_function_result> {
+			static int push(lua_State* L, const unsafe_function_result& fr) {
+				int p = 0;
+				for (int i = 0; i < fr.return_count(); ++i) {
+					lua_pushvalue(L, i + fr.stack_index());
+					++p;
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/unsafe_function_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+
+	namespace detail {
+		template <>
+		struct is_speshul<unsafe_function_result> : std::true_type { };
+		template <>
+		struct is_speshul<protected_function_result> : std::true_type { };
+
+		template <std::size_t I, typename... Args, typename T>
+		stack_proxy get(types<Args...>, meta::index_value<0>, meta::index_value<I>, const T& fr) {
+			return stack_proxy(fr.lua_state(), fr.stack_index() + static_cast<int>(I));
+		}
+
+		template <std::size_t I, std::size_t N, typename Arg, typename... Args, typename T, meta::enable<meta::boolean<(N > 0)>> = meta::enabler>
+		stack_proxy get(types<Arg, Args...>, meta::index_value<N>, meta::index_value<I>, const T& fr) {
+			return get(types<Args...>(), meta::index_value<N - 1>(), meta::index_value<I + lua_size<Arg>::value>(), fr);
+		}
+	} // namespace detail
+
+	template <>
+	struct tie_size<unsafe_function_result> : std::integral_constant<std::size_t, SIZE_MAX> { };
+
+	template <>
+	struct tie_size<protected_function_result> : std::integral_constant<std::size_t, SIZE_MAX> { };
+
+	template <std::size_t I>
+	stack_proxy get(const unsafe_function_result& fr) {
+		return stack_proxy(fr.lua_state(), fr.stack_index() + static_cast<int>(I));
+	}
+
+	template <std::size_t I, typename... Args>
+	stack_proxy get(types<Args...> t, const unsafe_function_result& fr) {
+		return detail::get(t, meta::index_value<I>(), meta::index_value<0>(), fr);
+	}
+
+	template <std::size_t I>
+	stack_proxy get(const protected_function_result& fr) {
+		return stack_proxy(fr.lua_state(), fr.stack_index() + static_cast<int>(I));
+	}
+
+	template <std::size_t I, typename... Args>
+	stack_proxy get(types<Args...> t, const protected_function_result& fr) {
+		return detail::get(t, meta::index_value<I>(), meta::index_value<0>(), fr);
+	}
+} // namespace sol
+
+// end of sol/function_result.hpp
+
+// beginning of sol/function_types.hpp
+
+// beginning of sol/function_types_core.hpp
+
+// beginning of sol/wrapper.hpp
+
+namespace sol {
+
+	namespace detail {
+		template <typename T>
+		using array_return_type = meta::conditional_t<std::is_array<T>::value, std::add_lvalue_reference_t<T>, T>;
+	}
+
+	template <typename F, typename = void>
+	struct wrapper {
+		typedef lua_bind_traits<meta::unqualified_t<F>> traits_type;
+		typedef typename traits_type::args_list args_list;
+		typedef typename traits_type::args_list free_args_list;
+		typedef typename traits_type::returns_list returns_list;
+
+		template <typename... Args>
+		static decltype(auto) call(F& f, Args&&... args) {
+			return f(std::forward<Args>(args)...);
+		}
+
+		struct caller {
+			template <typename... Args>
+			decltype(auto) operator()(F& fx, Args&&... args) const {
+				return call(fx, std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename F>
+	struct wrapper<F, std::enable_if_t<std::is_function<std::remove_pointer_t<meta::unqualified_t<F>>>::value>> {
+		typedef lua_bind_traits<std::remove_pointer_t<meta::unqualified_t<F>>> traits_type;
+		typedef typename traits_type::args_list args_list;
+		typedef typename traits_type::args_list free_args_list;
+		typedef typename traits_type::returns_list returns_list;
+
+		template <F fx, typename... Args>
+		static decltype(auto) invoke(Args&&... args) {
+			return fx(std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		static decltype(auto) call(F& fx, Args&&... args) {
+			return fx(std::forward<Args>(args)...);
+		}
+
+		struct caller {
+			template <typename... Args>
+			decltype(auto) operator()(F& fx, Args&&... args) const {
+				return call(fx, std::forward<Args>(args)...);
+			}
+		};
+
+		template <F fx>
+		struct invoker {
+			template <typename... Args>
+			decltype(auto) operator()(Args&&... args) const {
+				return invoke<fx>(std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename F>
+	struct wrapper<F, std::enable_if_t<std::is_member_object_pointer<meta::unqualified_t<F>>::value>> {
+		typedef lua_bind_traits<meta::unqualified_t<F>> traits_type;
+		typedef typename traits_type::object_type object_type;
+		typedef typename traits_type::return_type return_type;
+		typedef typename traits_type::args_list args_list;
+		typedef types<object_type&, return_type> free_args_list;
+		typedef typename traits_type::returns_list returns_list;
+
+		template <F fx>
+		static auto call(object_type& mem) -> detail::array_return_type<decltype(mem.*fx)> {
+			return mem.*fx;
+		}
+
+		template <F fx, typename Arg, typename... Args>
+		static decltype(auto) invoke(object_type& mem, Arg&& arg, Args&&...) {
+			return mem.*fx = std::forward<Arg>(arg);
+		}
+
+		template <typename Fx>
+		static auto call(Fx&& fx, object_type& mem) -> detail::array_return_type<decltype(mem.*fx)> {
+			return mem.*fx;
+		}
+
+		template <typename Fx, typename Arg, typename... Args>
+		static void call(Fx&& fx, object_type& mem, Arg&& arg, Args&&...) {
+			using actual_type = meta::unqualified_t<detail::array_return_type<decltype(mem.*fx)>>;
+			if constexpr (std::is_array_v<actual_type>) {
+				using std::cbegin;
+				using std::cend;
+				auto first = cbegin(arg);
+				auto last = cend(arg);
+				for (std::size_t i = 0; first != last; ++i, ++first) {
+					(mem.*fx)[i] = *first;
+				}
+			}
+			else {
+				(mem.*fx) = std::forward<Arg>(arg);
+			}
+		}
+
+		struct caller {
+			template <typename Fx, typename... Args>
+			decltype(auto) operator()(Fx&& fx, object_type& mem, Args&&... args) const {
+				return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
+			}
+		};
+
+		template <F fx>
+		struct invoker {
+			template <typename... Args>
+			decltype(auto) operator()(Args&&... args) const {
+				return invoke<fx>(std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename F, typename R, typename O, typename... FArgs>
+	struct member_function_wrapper {
+		typedef O object_type;
+		typedef lua_bind_traits<F> traits_type;
+		typedef typename traits_type::args_list args_list;
+		typedef types<object_type&, FArgs...> free_args_list;
+		typedef meta::tuple_types<R> returns_list;
+
+		template <F fx, typename... Args>
+		static R invoke(O& mem, Args&&... args) {
+			return (mem.*fx)(std::forward<Args>(args)...);
+		}
+
+		template <typename Fx, typename... Args>
+		static R call(Fx&& fx, O& mem, Args&&... args) {
+			return (mem.*fx)(std::forward<Args>(args)...);
+		}
+
+		struct caller {
+			template <typename Fx, typename... Args>
+			decltype(auto) operator()(Fx&& fx, O& mem, Args&&... args) const {
+				return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
+			}
+		};
+
+		template <F fx>
+		struct invoker {
+			template <typename... Args>
+			decltype(auto) operator()(O& mem, Args&&... args) const {
+				return invoke<fx>(mem, std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)> : public member_function_wrapper<R (O::*)(Args...), R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const> : public member_function_wrapper<R (O::*)(Args...) const, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile> : public member_function_wrapper<R (O::*)(Args...) const volatile, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)&> : public member_function_wrapper<R (O::*)(Args...)&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const&> : public member_function_wrapper<R (O::*)(Args...) const&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile&> : public member_function_wrapper<R (O::*)(Args...) const volatile&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...)&> : public member_function_wrapper<R (O::*)(Args..., ...)&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const&> : public member_function_wrapper<R (O::*)(Args..., ...) const&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile&> : public member_function_wrapper<R (O::*)(Args..., ...) const volatile&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) &&> : public member_function_wrapper<R (O::*)(Args...)&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const&&> : public member_function_wrapper<R (O::*)(Args...) const&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile&&> : public member_function_wrapper<R (O::*)(Args...) const volatile&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) &&> : public member_function_wrapper<R (O::*)(Args..., ...)&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const&&> : public member_function_wrapper<R (O::*)(Args..., ...) const&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile&&> : public member_function_wrapper<R (O::*)(Args..., ...) const volatile&, R, O, Args...> { };
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+	// noexcept has become a part of a function's type
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) noexcept> : public member_function_wrapper<R (O::*)(Args...) noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const noexcept> : public member_function_wrapper<R (O::*)(Args...) const noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)& noexcept> : public member_function_wrapper<R (O::*)(Args...)& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const& noexcept> : public member_function_wrapper<R (O::*)(Args...) const& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile& noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...)& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...)& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) const& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile& noexcept>
+	: public member_function_wrapper<R (O::*)(Args..., ...) const volatile& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)&& noexcept> : public member_function_wrapper<R (O::*)(Args...)& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const&& noexcept> : public member_function_wrapper<R (O::*)(Args...) const& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile&& noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile& noexcept, R, O, Args...> {
+	};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...)&& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...)& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const&& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) const& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile&& noexcept>
+	: public member_function_wrapper<R (O::*)(Args..., ...) const volatile& noexcept, R, O, Args...> { };
+
+#endif // noexcept is part of a function's type
+
+} // namespace sol
+
+// end of sol/wrapper.hpp
+
+#include <memory>
+
+namespace sol { namespace function_detail {
+	template <typename Fx, int start = 1, bool is_yielding = false>
+	int call(lua_State* L) {
+		Fx& fx = stack::get<user<Fx>>(L, upvalue_index(start));
+		int nr = fx(L);
+		if (is_yielding) {
+			return lua_yield(L, nr);
+		}
+		else {
+			return nr;
+		}
+	}
+}} // namespace sol::function_detail
+
+// end of sol/function_types_core.hpp
+
+// beginning of sol/function_types_templated.hpp
+
+// beginning of sol/call.hpp
+
+// beginning of sol/property.hpp
+
+#include <type_traits>
+#include <utility>
+
+namespace sol {
+	namespace detail {
+		struct no_prop { };
+	} // namespace detail
+
+	template <typename R, typename W>
+	struct property_wrapper : detail::ebco<R, 0>, detail::ebco<W, 1> {
+	private:
+		using read_base_t = detail::ebco<R, 0>;
+		using write_base_t = detail::ebco<W, 1>;
+
+	public:
+		template <typename Rx, typename Wx>
+		property_wrapper(Rx&& r, Wx&& w) : read_base_t(std::forward<Rx>(r)), write_base_t(std::forward<Wx>(w)) {
+		}
+
+		W& write() {
+			return write_base_t::value();
+		}
+
+		const W& write() const {
+			return write_base_t::value();
+		}
+
+		R& read() {
+			return read_base_t::value();
+		}
+
+		const R& read() const {
+			return read_base_t::value();
+		}
+	};
+
+	template <typename F, typename G>
+	inline decltype(auto) property(F&& f, G&& g) {
+		typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
+		typedef lua_bind_traits<meta::unqualified_t<G>> right_traits;
+		if constexpr (left_traits::free_arity < right_traits::free_arity) {
+			return property_wrapper<std::decay_t<F>, std::decay_t<G>>(std::forward<F>(f), std::forward<G>(g));
+		}
+		else {
+			return property_wrapper<std::decay_t<G>, std::decay_t<F>>(std::forward<G>(g), std::forward<F>(f));
+		}
+	}
+
+	template <typename F>
+	inline decltype(auto) property(F&& f) {
+		typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
+		if constexpr (left_traits::free_arity < 2) {
+			return property_wrapper<std::decay_t<F>, detail::no_prop>(std::forward<F>(f), detail::no_prop());
+		}
+		else {
+			return property_wrapper<detail::no_prop, std::decay_t<F>>(detail::no_prop(), std::forward<F>(f));
+		}
+	}
+
+	template <typename F>
+	inline decltype(auto) readonly_property(F&& f) {
+		return property_wrapper<std::decay_t<F>, detail::no_prop>(std::forward<F>(f), detail::no_prop());
+	}
+
+	template <typename F>
+	inline decltype(auto) writeonly_property(F&& f) {
+		return property_wrapper<detail::no_prop, std::decay_t<F>>(detail::no_prop(), std::forward<F>(f));
+	}
+
+	template <typename T>
+	struct readonly_wrapper : detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+
+		operator T&() {
+			return base_t::value();
+		}
+		operator const T&() const {
+			return base_t::value();
+		}
+	};
+
+	// Allow someone to make a member variable readonly (const)
+	template <typename R, typename T>
+	inline auto readonly(R T::*v) {
+		return readonly_wrapper<meta::unqualified_t<decltype(v)>>(v);
+	}
+
+	template <typename T>
+	struct var_wrapper : detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+	};
+
+	template <typename V>
+	inline auto var(V&& v) {
+		typedef std::decay_t<V> T;
+		return var_wrapper<T>(std::forward<V>(v));
+	}
+
+	namespace meta {
+		template <typename T>
+		using is_member_object = std::integral_constant<bool, std::is_member_object_pointer_v<T> || is_specialization_of_v<T, readonly_wrapper>>;
+
+		template <typename T>
+		inline constexpr bool is_member_object_v = is_member_object<T>::value;
+
+		template <typename T>
+		using is_member_object_or_function = std::integral_constant<bool, is_member_object_v<T> || std::is_member_pointer_v<T>>;
+
+		template <typename T>
+		inline constexpr bool is_member_object_or_function_v = is_member_object_or_function<T>::value;
+	} // namespace meta
+
+} // namespace sol
+
+// end of sol/property.hpp
+
+// beginning of sol/protect.hpp
+
+#include <utility>
+
+namespace sol {
+
+	template <typename T>
+	struct protect_t {
+		T value;
+
+		template <typename Arg, typename... Args, meta::disable<std::is_same<protect_t, meta::unqualified_t<Arg>>> = meta::enabler>
+		protect_t(Arg&& arg, Args&&... args) : value(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		protect_t(const protect_t&) = default;
+		protect_t(protect_t&&) = default;
+		protect_t& operator=(const protect_t&) = default;
+		protect_t& operator=(protect_t&&) = default;
+	};
+
+	template <typename T>
+	auto protect(T&& value) {
+		return protect_t<std::decay_t<T>>(std::forward<T>(value));
+	}
+
+} // namespace sol
+
+// end of sol/protect.hpp
+
+namespace sol {
+	namespace u_detail {
+
+	} // namespace u_detail
+
+	namespace policy_detail {
+		template <int I, int... In>
+		inline void handle_policy(static_stack_dependencies<I, In...>, lua_State* L, int&) {
+			if constexpr (sizeof...(In) == 0) {
+				(void)L;
+				return;
+			}
+			else {
+				absolute_index ai(L, I);
+				if (type_of(L, ai) != type::userdata) {
+					return;
+				}
+				lua_createtable(L, static_cast<int>(sizeof...(In)), 0);
+				stack_reference deps(L, -1);
+				auto per_dep = [&L, &deps](int i) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+					luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+					lua_pushvalue(L, i);
+					luaL_ref(L, deps.stack_index());
+				};
+				(void)per_dep;
+				(void)detail::swallow { int(), (per_dep(In), int())... };
+				lua_setuservalue(L, ai);
+			}
+		}
+
+		template <int... In>
+		inline void handle_policy(returns_self_with<In...>, lua_State* L, int& pushed) {
+			pushed = stack::push(L, raw_index(1));
+			handle_policy(static_stack_dependencies<-1, In...>(), L, pushed);
+		}
+
+		inline void handle_policy(const stack_dependencies& sdeps, lua_State* L, int&) {
+			absolute_index ai(L, sdeps.target);
+			if (type_of(L, ai) != type::userdata) {
+				return;
+			}
+			lua_createtable(L, static_cast<int>(sdeps.size()), 0);
+			stack_reference deps(L, -1);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, static_cast<int>(sdeps.size()), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			for (std::size_t i = 0; i < sdeps.size(); ++i) {
+				lua_pushvalue(L, sdeps.stack_indices[i]);
+				luaL_ref(L, deps.stack_index());
+			}
+			lua_setuservalue(L, ai);
+		}
+
+		template <typename P, meta::disable<std::is_base_of<detail::policy_base_tag, meta::unqualified_t<P>>> = meta::enabler>
+		inline void handle_policy(P&& p, lua_State* L, int& pushed) {
+			pushed = std::forward<P>(p)(L, pushed);
+		}
+	} // namespace policy_detail
+
+	namespace function_detail {
+		inline int no_construction_error(lua_State* L) {
+			return luaL_error(L, "sol: cannot call this constructor (tagged as non-constructible)");
+		}
+	} // namespace function_detail
+
+	namespace call_detail {
+
+		template <typename R, typename W>
+		inline auto& pick(std::true_type, property_wrapper<R, W>& f) {
+			return f.read();
+		}
+
+		template <typename R, typename W>
+		inline auto& pick(std::false_type, property_wrapper<R, W>& f) {
+			return f.write();
+		}
+
+		template <typename T, typename List>
+		struct void_call : void_call<T, meta::function_args_t<List>> { };
+
+		template <typename T, typename... Args>
+		struct void_call<T, types<Args...>> {
+			static void call(Args...) {
+			}
+		};
+
+		template <typename T, bool checked, bool clean_stack>
+		struct constructor_match {
+			T* obj_;
+			reference* obj_lua_ref_;
+			stack::stack_detail::undefined_metatable* p_umf_;
+
+			constructor_match(T* obj_ptr, reference& obj_lua_ref, stack::stack_detail::undefined_metatable& umf)
+			: obj_(obj_ptr), obj_lua_ref_(&obj_lua_ref), p_umf_(&umf) {
+			}
+
+			template <typename Fx, std::size_t I, typename... R, typename... Args>
+			int operator()(types<Fx>, meta::index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) const {
+				detail::default_construct func {};
+				int result = stack::call_into_lua<checked, clean_stack>(r, a, L, start, func, this->obj_);
+				// construct userdata table
+				// SPECIFICALLY, after we've created it successfully.
+				// If the constructor exits for any reason we have to break things down...
+				if constexpr (clean_stack) {
+					obj_lua_ref_->push();
+					(*this->p_umf_)();
+					obj_lua_ref_->pop();
+				}
+				else {
+					(*this->p_umf_)();
+				}
+				return result;
+			}
+		};
+
+		namespace overload_detail {
+			template <std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity(types<>, std::index_sequence<>, std::index_sequence<M...>, Match&&, lua_State* L, int, int, Args&&...) {
+				return luaL_error(L, "sol: no matching function call takes this number of arguments and the specified types");
+			}
+
+			template <typename Fx, typename... Fxs, std::size_t I, std::size_t... In, std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity(types<Fx, Fxs...>, std::index_sequence<I, In...>, std::index_sequence<M...>, Match&& matchfx, lua_State* L,
+			     int fxarity, int start, Args&&... args) {
+				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+				typedef meta::tuple_types<typename traits::return_type> return_types;
+				typedef typename traits::free_args_list args_list;
+				// compile-time eliminate any functions that we know ahead of time are of improper arity
+				if constexpr (!traits::runtime_variadics_t::value
+				     && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+					return overload_match_arity(types<Fxs...>(),
+					     std::index_sequence<In...>(),
+					     std::index_sequence<M...>(),
+					     std::forward<Match>(matchfx),
+					     L,
+					     fxarity,
+					     start,
+					     std::forward<Args>(args)...);
+				}
+				else {
+					if constexpr (!traits::runtime_variadics_t::value) {
+						if (traits::free_arity != fxarity) {
+							return overload_match_arity(types<Fxs...>(),
+							     std::index_sequence<In...>(),
+							     std::index_sequence<traits::free_arity, M...>(),
+							     std::forward<Match>(matchfx),
+							     L,
+							     fxarity,
+							     start,
+							     std::forward<Args>(args)...);
+						}
+					}
+					stack::record tracking {};
+					if (!stack::stack_detail::check_types(args_list(), L, start, &no_panic, tracking)) {
+						return overload_match_arity(types<Fxs...>(),
+						     std::index_sequence<In...>(),
+						     std::index_sequence<M...>(),
+						     std::forward<Match>(matchfx),
+						     L,
+						     fxarity,
+						     start,
+						     std::forward<Args>(args)...);
+					}
+					return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+				}
+			}
+
+			template <std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity_single(
+			     types<>, std::index_sequence<>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+				return overload_match_arity(types<>(),
+				     std::index_sequence<>(),
+				     std::index_sequence<M...>(),
+				     std::forward<Match>(matchfx),
+				     L,
+				     fxarity,
+				     start,
+				     std::forward<Args>(args)...);
+			}
+
+			template <typename Fx, std::size_t I, std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity_single(
+			     types<Fx>, std::index_sequence<I>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+				typedef meta::tuple_types<typename traits::return_type> return_types;
+				typedef typename traits::free_args_list args_list;
+				// compile-time eliminate any functions that we know ahead of time are of improper arity
+				if constexpr (!traits::runtime_variadics_t::value
+				     && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+					return overload_match_arity(types<>(),
+					     std::index_sequence<>(),
+					     std::index_sequence<M...>(),
+					     std::forward<Match>(matchfx),
+					     L,
+					     fxarity,
+					     start,
+					     std::forward<Args>(args)...);
+				}
+				if constexpr (!traits::runtime_variadics_t::value) {
+					if (traits::free_arity != fxarity) {
+						return overload_match_arity(types<>(),
+						     std::index_sequence<>(),
+						     std::index_sequence<traits::free_arity, M...>(),
+						     std::forward<Match>(matchfx),
+						     L,
+						     fxarity,
+						     start,
+						     std::forward<Args>(args)...);
+					}
+				}
+				return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+			}
+
+			template <typename Fx, typename Fx1, typename... Fxs, std::size_t I, std::size_t I1, std::size_t... In, std::size_t... M, typename Match,
+			     typename... Args>
+			inline int overload_match_arity_single(types<Fx, Fx1, Fxs...>, std::index_sequence<I, I1, In...>, std::index_sequence<M...>, Match&& matchfx,
+			     lua_State* L, int fxarity, int start, Args&&... args) {
+				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+				typedef meta::tuple_types<typename traits::return_type> return_types;
+				typedef typename traits::free_args_list args_list;
+				// compile-time eliminate any functions that we know ahead of time are of improper arity
+				if constexpr (!traits::runtime_variadics_t::value
+				     && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+					return overload_match_arity(types<Fx1, Fxs...>(),
+					     std::index_sequence<I1, In...>(),
+					     std::index_sequence<M...>(),
+					     std::forward<Match>(matchfx),
+					     L,
+					     fxarity,
+					     start,
+					     std::forward<Args>(args)...);
+				}
+				else {
+					if constexpr (!traits::runtime_variadics_t::value) {
+						if (traits::free_arity != fxarity) {
+							return overload_match_arity(types<Fx1, Fxs...>(),
+							     std::index_sequence<I1, In...>(),
+							     std::index_sequence<traits::free_arity, M...>(),
+							     std::forward<Match>(matchfx),
+							     L,
+							     fxarity,
+							     start,
+							     std::forward<Args>(args)...);
+						}
+					}
+					stack::record tracking {};
+					if (!stack::stack_detail::check_types(args_list(), L, start, &no_panic, tracking)) {
+						return overload_match_arity(types<Fx1, Fxs...>(),
+						     std::index_sequence<I1, In...>(),
+						     std::index_sequence<M...>(),
+						     std::forward<Match>(matchfx),
+						     L,
+						     fxarity,
+						     start,
+						     std::forward<Args>(args)...);
+					}
+					return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+				}
+			}
+		} // namespace overload_detail
+
+		template <typename... Functions, typename Match, typename... Args>
+		inline int overload_match_arity(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+			return overload_detail::overload_match_arity_single(types<Functions...>(),
+			     std::make_index_sequence<sizeof...(Functions)>(),
+			     std::index_sequence<>(),
+			     std::forward<Match>(matchfx),
+			     L,
+			     fxarity,
+			     start,
+			     std::forward<Args>(args)...);
+		}
+
+		template <typename... Functions, typename Match, typename... Args>
+		inline int overload_match(Match&& matchfx, lua_State* L, int start, Args&&... args) {
+			int fxarity = lua_gettop(L) - (start - 1);
+			return overload_match_arity<Functions...>(std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
+		}
+
+		template <typename T, typename... TypeLists, typename Match, typename... Args>
+		inline int construct_match(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+			// use same overload resolution matching as all other parts of the framework
+			return overload_match_arity<decltype(void_call<T, TypeLists>::call)...>(
+			     std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
+		}
+
+		template <typename T, bool checked, bool clean_stack, typename... TypeLists>
+		inline int construct_trampolined(lua_State* L) {
+			static const auto& meta = usertype_traits<T>::metatable();
+			int argcount = lua_gettop(L);
+			call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1) : call_syntax::dot;
+			argcount -= static_cast<int>(syntax);
+
+			T* obj = detail::usertype_allocate<T>(L);
+			reference userdataref(L, -1);
+			stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+
+			// put userdata at the first index
+			lua_insert(L, 1);
+			construct_match<T, TypeLists...>(constructor_match<T, checked, clean_stack>(obj, userdataref, umf), L, argcount, 1 + static_cast<int>(syntax));
+
+			userdataref.push();
+			return 1;
+		}
+
+		template <typename T, bool checked, bool clean_stack, typename... TypeLists>
+		inline int construct(lua_State* L) {
+			return detail::static_trampoline<&construct_trampolined<T, checked, clean_stack, TypeLists...>>(L);
+		}
+
+		template <typename F, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename = void>
+		struct agnostic_lua_call_wrapper {
+			template <typename Fx, typename... Args>
+			static int call(lua_State* L, Fx&& f, Args&&... args) {
+				using uFx = meta::unqualified_t<Fx>;
+				static constexpr bool is_ref = is_lua_reference_v<uFx>;
+				if constexpr (is_ref) {
+					if constexpr (is_index) {
+						return stack::push(L, std::forward<Fx>(f), std::forward<Args>(args)...);
+					}
+					else {
+						std::forward<Fx>(f) = stack::unqualified_get<F>(L, boost + (is_variable ? 3 : 1));
+						return 0;
+					}
+				}
+				else {
+					using wrap = wrapper<uFx>;
+					using traits_type = typename wrap::traits_type;
+					using fp_t = typename traits_type::function_pointer_type;
+					constexpr bool is_function_pointer_convertible = std::is_class_v<uFx> && std::is_convertible_v<std::decay_t<Fx>, fp_t>;
+					if constexpr (is_function_pointer_convertible) {
+						fp_t fx = f;
+						return agnostic_lua_call_wrapper<fp_t, is_index, is_variable, checked, boost, clean_stack> {}.call(
+						     L, fx, std::forward<Args>(args)...);
+					}
+					else {
+						using returns_list = typename wrap::returns_list;
+						using args_list = typename wrap::free_args_list;
+						using caller = typename wrap::caller;
+						return stack::call_into_lua<checked, clean_stack>(
+						     returns_list(), args_list(), L, boost + 1, caller(), std::forward<Fx>(f), std::forward<Args>(args)...);
+					}
+				}
+			}
+		};
+
+		template <typename T, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<var_wrapper<T>, is_index, is_variable, checked, boost, clean_stack, C> {
+			template <typename F>
+			static int call(lua_State* L, F&& f) {
+				if constexpr (is_index) {
+					constexpr bool is_stack = is_stack_based_v<meta::unqualified_t<decltype(detail::unwrap(f.value()))>>;
+					if constexpr (clean_stack && !is_stack) {
+						lua_settop(L, 0);
+					}
+					return stack::push_reference(L, detail::unwrap(f.value()));
+				}
+				else {
+					if constexpr (std::is_const_v<meta::unwrapped_t<T>>) {
+						(void)f;
+						return luaL_error(L, "sol: cannot write to a readonly (const) variable");
+					}
+					else {
+						using R = meta::unwrapped_t<T>;
+						if constexpr (std::is_assignable_v<std::add_lvalue_reference_t<meta::unqualified_t<R>>, R>) {
+							detail::unwrap(f.value()) = stack::unqualified_get<meta::unwrapped_t<T>>(L, boost + (is_variable ? 3 : 1));
+							if (clean_stack) {
+								lua_settop(L, 0);
+							}
+							return 0;
+						}
+						else {
+							return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
+						}
+					}
+				}
+			}
+		};
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<lua_CFunction_ref, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, lua_CFunction_ref f) {
+				return f(L);
+			}
+		};
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<lua_CFunction, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, lua_CFunction f) {
+				return f(L);
+			}
+		};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<detail::lua_CFunction_noexcept, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, detail::lua_CFunction_noexcept f) {
+				return f(L);
+			}
+		};
+#endif // noexcept function types
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<detail::no_prop, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, const detail::no_prop&) {
+				return luaL_error(L, is_index ? "sol: cannot read from a writeonly property" : "sol: cannot write to a readonly property");
+			}
+		};
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<no_construction, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, const no_construction&) {
+				return function_detail::no_construction_error(L);
+			}
+		};
+
+		template <typename... Args, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<bases<Args...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State*, const bases<Args...>&) {
+				// Uh. How did you even call this, lul
+				return 0;
+			}
+		};
+
+		template <typename T, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<std::reference_wrapper<T>, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, std::reference_wrapper<T> f) {
+				agnostic_lua_call_wrapper<T, is_index, is_variable, checked, boost, clean_stack> alcw {};
+				return alcw.call(L, f.get());
+			}
+		};
+
+		template <typename T, typename F, bool is_index, bool is_variable, bool checked = detail::default_safe_function_calls, int boost = 0,
+		     bool clean_stack = true, typename = void>
+		struct lua_call_wrapper {
+			template <typename Fx, typename... Args>
+			static int call(lua_State* L, Fx&& fx, Args&&... args) {
+				if constexpr (std::is_member_function_pointer_v<F>) {
+					using wrap = wrapper<F>;
+					using object_type = typename wrap::object_type;
+					if constexpr (sizeof...(Args) < 1) {
+						using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+						static_assert(std::is_base_of_v<object_type, Ta>,
+						     "It seems like you might have accidentally bound a class type with a member function method that does not correspond to the "
+						     "class. For example, there could be a small type in your new_usertype<T>(...) binding, where you specify one class \"T\" "
+						     "but then bind member methods from a complete unrelated class. Check things over!");
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+						auto maybeo = stack::check_get<Ta*>(L, 1);
+						if (!maybeo || maybeo.value() == nullptr) {
+							return luaL_error(L,
+							     "sol: received nil for 'self' argument (use ':' for accessing member functions, make sure member variables are "
+							     "preceeded by the "
+							     "actual object with '.' syntax)");
+						}
+						object_type* o = static_cast<object_type*>(maybeo.value());
+						return call(L, std::forward<Fx>(fx), *o);
+#else
+						object_type& o = static_cast<object_type&>(*stack::unqualified_get<non_null<Ta*>>(L, 1));
+						return call(L, std::forward<Fx>(fx), o);
+#endif // Safety
+					}
+					else {
+						using returns_list = typename wrap::returns_list;
+						using args_list = typename wrap::args_list;
+						using caller = typename wrap::caller;
+						return stack::call_into_lua<checked, clean_stack>(
+						     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), std::forward<Fx>(fx), std::forward<Args>(args)...);
+					}
+				}
+				else if constexpr (std::is_member_object_pointer_v<F>) {
+					using wrap = wrapper<F>;
+					using object_type = typename wrap::object_type;
+					if constexpr (is_index) {
+						if constexpr (sizeof...(Args) < 1) {
+							using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+							static_assert(std::is_base_of_v<object_type, Ta>,
+							     "It seems like you might have accidentally bound a class type with a member function method that does not correspond "
+							     "to the class. For example, there could be a small type in your new_usertype<T>(...) binding, where you specify one "
+							     "class \"T\" but then bind member methods from a complete unrelated class. Check things over!");
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+							auto maybeo = stack::check_get<Ta*>(L, 1);
+							if (!maybeo || maybeo.value() == nullptr) {
+								if (is_variable) {
+									return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)");
+								}
+								return luaL_error(L, "sol: 'self' argument is lua_nil (pass 'self' as first argument)");
+							}
+							object_type* o = static_cast<object_type*>(maybeo.value());
+							return call(L, std::forward<Fx>(fx), *o);
+#else
+							object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
+							return call(L, std::forward<Fx>(fx), o);
+#endif // Safety
+						}
+						else {
+							using returns_list = typename wrap::returns_list;
+							using caller = typename wrap::caller;
+							return stack::call_into_lua<checked, clean_stack>(returns_list(),
+							     types<>(),
+							     L,
+							     boost + (is_variable ? 3 : 2),
+							     caller(),
+							     std::forward<Fx>(fx),
+							     std::forward<Args>(args)...);
+						}
+					}
+					else {
+						using traits_type = lua_bind_traits<F>;
+						using return_type = typename traits_type::return_type;
+						constexpr bool ret_is_const = std::is_const_v<std::remove_reference_t<return_type>>;
+						if constexpr (ret_is_const) {
+							(void)fx;
+							(void)detail::swallow { 0, (static_cast<void>(args), 0)... };
+							return luaL_error(L, "sol: cannot write to a readonly (const) variable");
+						}
+						else {
+							using u_return_type = meta::unqualified_t<return_type>;
+							constexpr bool is_assignable = std::is_copy_assignable_v<u_return_type> || std::is_array_v<u_return_type>;
+							if constexpr (!is_assignable) {
+								(void)fx;
+								(void)detail::swallow { 0, ((void)args, 0)... };
+								return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
+							}
+							else {
+								using args_list = typename wrap::args_list;
+								using caller = typename wrap::caller;
+								if constexpr (sizeof...(Args) > 0) {
+									return stack::call_into_lua<checked, clean_stack>(types<void>(),
+									     args_list(),
+									     L,
+									     boost + (is_variable ? 3 : 2),
+									     caller(),
+									     std::forward<Fx>(fx),
+									     std::forward<Args>(args)...);
+								}
+								else {
+									using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+									auto maybeo = stack::check_get<Ta*>(L, 1);
+									if (!maybeo || maybeo.value() == nullptr) {
+										if (is_variable) {
+											return luaL_error(L, "sol: received nil for 'self' argument (bad '.' access?)");
+										}
+										return luaL_error(L, "sol: received nil for 'self' argument (pass 'self' as first argument)");
+									}
+									object_type* po = static_cast<object_type*>(maybeo.value());
+									object_type& o = *po;
+#else
+									object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
+#endif // Safety
+
+									return stack::call_into_lua<checked, clean_stack>(
+									     types<void>(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), std::forward<Fx>(fx), o);
+								}
+							}
+						}
+					}
+				}
+				else {
+					agnostic_lua_call_wrapper<F, is_index, is_variable, checked, boost, clean_stack> alcw {};
+					return alcw.call(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+				}
+			}
+		};
+
+		template <typename T, typename F, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, readonly_wrapper<F>, is_index, is_variable, checked, boost, clean_stack, C> {
+			using traits_type = lua_bind_traits<F>;
+			using wrap = wrapper<F>;
+			using object_type = typename wrap::object_type;
+
+			static int call(lua_State* L, readonly_wrapper<F>&& rw) {
+				if constexpr (!is_index) {
+					(void)rw;
+					return luaL_error(L, "sol: cannot write to a sol::readonly variable");
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, std::move(rw.value()));
+				}
+			}
+
+			static int call(lua_State* L, readonly_wrapper<F>&& rw, object_type& o) {
+				if constexpr (!is_index) {
+					(void)o;
+					return call(L, std::move(rw));
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, rw.value(), o);
+				}
+			}
+
+			static int call(lua_State* L, const readonly_wrapper<F>& rw) {
+				if constexpr (!is_index) {
+					(void)rw;
+					return luaL_error(L, "sol: cannot write to a sol::readonly variable");
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, rw.value());
+				}
+			}
+
+			static int call(lua_State* L, const readonly_wrapper<F>& rw, object_type& o) {
+				if constexpr (!is_index) {
+					(void)o;
+					return call(L, rw);
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, rw.value(), o);
+				}
+			}
+		};
+
+		template <typename T, typename... Args, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, constructor_list<Args...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef constructor_list<Args...> F;
+
+			static int call(lua_State* L, F&) {
+				const auto& meta = usertype_traits<T>::metatable();
+				int argcount = lua_gettop(L);
+				call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1) : call_syntax::dot;
+				argcount -= static_cast<int>(syntax);
+
+				T* obj = detail::usertype_allocate<T>(L);
+				reference userdataref(L, -1);
+				stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+
+				// put userdata at the first index
+				lua_insert(L, 1);
+				// Because of the way constructors work,
+				// we have to kill the data, but only if the cosntructor is successfulyl invoked...
+				// if it's not successfully invoked and we panic,
+				// we cannot actually deallcoate/delete the data.
+				construct_match<T, Args...>(
+				     constructor_match<T, checked, clean_stack>(obj, userdataref, umf), L, argcount, boost + 1 + 1 + static_cast<int>(syntax));
+
+				userdataref.push();
+				return 1;
+			}
+		};
+
+		template <typename T, typename... Cxs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, constructor_wrapper<Cxs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef constructor_wrapper<Cxs...> F;
+
+			struct onmatch {
+				template <typename Fx, std::size_t I, typename... R, typename... Args>
+				int operator()(types<Fx>, meta::index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start, F& f) {
+					const auto& meta = usertype_traits<T>::metatable();
+					T* obj = detail::usertype_allocate<T>(L);
+					reference userdataref(L, -1);
+					stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+					umf();
+
+					auto& func = std::get<I>(f.functions);
+					// put userdata at the first index
+					lua_insert(L, 1);
+					stack::call_into_lua<checked, clean_stack>(r, a, L, boost + 1 + start, func, detail::implicit_wrapper<T>(obj));
+
+					userdataref.push();
+					return 1;
+				}
+			};
+
+			static int call(lua_State* L, F& f) {
+				call_syntax syntax = stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1);
+				int syntaxval = static_cast<int>(syntax);
+				int argcount = lua_gettop(L) - syntaxval;
+				return construct_match<T, meta::pop_front_type_t<meta::function_args_t<Cxs>>...>(onmatch(), L, argcount, 1 + syntaxval, f);
+			}
+		};
+
+		template <typename T, typename Fx, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, destructor_wrapper<Fx>, is_index, is_variable, checked, boost, clean_stack, C> {
+
+			template <typename F>
+			static int call(lua_State* L, F&& f) {
+				if constexpr (std::is_void_v<Fx>) {
+					return detail::usertype_alloc_destroy<T>(L);
+				}
+				else {
+					using uFx = meta::unqualified_t<Fx>;
+					lua_call_wrapper<T, uFx, is_index, is_variable, checked, boost, clean_stack> lcw {};
+					return lcw.call(L, std::forward<F>(f).fx);
+				}
+			}
+		};
+
+		template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, overload_set<Fs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef overload_set<Fs...> F;
+
+			struct on_match {
+				template <typename Fx, std::size_t I, typename... R, typename... Args>
+				int operator()(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
+					auto& f = std::get<I>(fx.functions);
+					return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost> {}.call(L, f);
+				}
+			};
+
+			static int call(lua_State* L, F& fx) {
+				return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L), 1, fx);
+			}
+		};
+
+		template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, factory_wrapper<Fs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef factory_wrapper<Fs...> F;
+
+			struct on_match {
+				template <typename Fx, std::size_t I, typename... R, typename... Args>
+				int operator()(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
+					auto& f = std::get<I>(fx.functions);
+					return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost, clean_stack> {}.call(L, f);
+				}
+			};
+
+			static int call(lua_State* L, F& fx) {
+				return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L) - boost, 1 + boost, fx);
+			}
+		};
+
+		template <typename T, typename R, typename W, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, property_wrapper<R, W>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef meta::conditional_t<is_index, R, W> P;
+			typedef meta::unqualified_t<P> U;
+			typedef wrapper<U> wrap;
+			typedef lua_bind_traits<U> traits_type;
+			typedef meta::unqualified_t<typename traits_type::template arg_at<0>> object_type;
+
+			template <typename F, typename... Args>
+			static int call(lua_State* L, F&& f, Args&&... args) {
+				constexpr bool is_specialized = meta::any<std::is_same<U, detail::no_prop>,
+				     meta::is_specialization_of<U, var_wrapper>,
+				     meta::is_specialization_of<U, constructor_wrapper>,
+				     meta::is_specialization_of<U, constructor_list>,
+				     std::is_member_pointer<U>>::value;
+				if constexpr (is_specialized) {
+					if constexpr (is_index) {
+						decltype(auto) p = f.read();
+						lua_call_wrapper<T, meta::unqualified_t<decltype(p)>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+						return lcw.call(L, p, std::forward<Args>(args)...);
+					}
+					else {
+						decltype(auto) p = f.write();
+						lua_call_wrapper<T, meta::unqualified_t<decltype(p)>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+						return lcw.call(L, p, std::forward<Args>(args)...);
+					}
+				}
+				else {
+					constexpr bool non_class_object_type = meta::any<std::is_void<object_type>,
+					     meta::boolean<lua_type_of<meta::unwrap_unqualified_t<object_type>>::value != type::userdata>>::value;
+					if constexpr (non_class_object_type) {
+						// The type being void means we don't have any arguments, so it might be a free functions?
+						using args_list = typename traits_type::free_args_list;
+						using returns_list = typename wrap::returns_list;
+						using caller = typename wrap::caller;
+						if constexpr (is_index) {
+							decltype(auto) pf = f.read();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf);
+						}
+						else {
+							decltype(auto) pf = f.write();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf);
+						}
+					}
+					else {
+						using args_list = meta::pop_front_type_t<typename traits_type::free_args_list>;
+						using Ta = T;
+						using Oa = std::remove_pointer_t<object_type>;
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+						auto maybeo = stack::check_get<Ta*>(L, 1);
+						if (!maybeo || maybeo.value() == nullptr) {
+							if (is_variable) {
+								return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)");
+							}
+							return luaL_error(L, "sol: 'self' argument is lua_nil (pass 'self' as first argument)");
+						}
+						Oa* o = static_cast<Oa*>(maybeo.value());
+#else
+						Oa* o = static_cast<Oa*>(stack::get<non_null<Ta*>>(L, 1));
+#endif // Safety
+						using returns_list = typename wrap::returns_list;
+						using caller = typename wrap::caller;
+						if constexpr (is_index) {
+							decltype(auto) pf = f.read();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf, detail::implicit_wrapper<Oa>(*o));
+						}
+						else {
+							decltype(auto) pf = f.write();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf, detail::implicit_wrapper<Oa>(*o));
+						}
+					}
+				}
+			}
+		};
+
+		template <typename T, typename V, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, protect_t<V>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef protect_t<V> F;
+
+			template <typename... Args>
+			static int call(lua_State* L, F& fx, Args&&... args) {
+				return lua_call_wrapper<T, V, is_index, is_variable, true, boost, clean_stack> {}.call(L, fx.value, std::forward<Args>(args)...);
+			}
+		};
+
+		template <typename T, typename F, typename... Policies, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, policy_wrapper<F, Policies...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef policy_wrapper<F, Policies...> P;
+
+			template <std::size_t... In>
+			static int call(std::index_sequence<In...>, lua_State* L, P& fx) {
+				int pushed = lua_call_wrapper<T, F, is_index, is_variable, checked, boost, false, C> {}.call(L, fx.value);
+				(void)detail::swallow { int(), (policy_detail::handle_policy(std::get<In>(fx.policies), L, pushed), int())... };
+				return pushed;
+			}
+
+			static int call(lua_State* L, P& fx) {
+				typedef typename P::indices indices;
+				return call(indices(), L, fx);
+			}
+		};
+
+		template <typename T, typename Y, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, yielding_t<Y>, is_index, is_variable, checked, boost, clean_stack, C> {
+			template <typename F>
+			static int call(lua_State* L, F&& f) {
+				return lua_call_wrapper<T, meta::unqualified_t<Y>, is_index, is_variable, checked, boost, clean_stack> {}.call(L, f.func);
+			}
+		};
+
+		template <typename T, typename Sig, typename P, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, function_arguments<Sig, P>, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, const function_arguments<Sig, P>& f) {
+				lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::get<0>(f.arguments));
+			}
+
+			static int call(lua_State* L, function_arguments<Sig, P>& f) {
+				lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::get<0>(f.arguments));
+			}
+
+			static int call(lua_State* L, function_arguments<Sig, P>&& f) {
+				lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::get<0>(std::move(f.arguments)));
+			}
+		};
+
+		template <typename T, bool is_index, bool is_variable, int boost = 0, bool checked = detail::default_safe_function_calls, bool clean_stack = true,
+		     typename Fx, typename... Args>
+		inline int call_wrapped(lua_State* L, Fx&& fx, Args&&... args) {
+			using uFx = meta::unqualified_t<Fx>;
+			if constexpr (meta::is_specialization_of_v<uFx, yielding_t>) {
+				using real_fx = meta::unqualified_t<decltype(std::forward<Fx>(fx).func)>;
+				lua_call_wrapper<T, real_fx, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::forward<Fx>(fx).func, std::forward<Args>(args)...);
+			}
+			else {
+				lua_call_wrapper<T, uFx, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <typename T, bool is_index, bool is_variable, typename F, int start = 1, bool checked = detail::default_safe_function_calls,
+		     bool clean_stack = true>
+		inline int call_user(lua_State* L) {
+			auto& fx = stack::unqualified_get<user<F>>(L, upvalue_index(start));
+			using uFx = meta::unqualified_t<F>;
+			int nr = call_wrapped<T, is_index, is_variable, 0, checked, clean_stack>(L, fx);
+			if constexpr (meta::is_specialization_of_v<uFx, yielding_t>) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		template <typename T, typename = void>
+		struct is_var_bind : std::false_type { };
+
+		template <typename T>
+		struct is_var_bind<T, std::enable_if_t<std::is_member_object_pointer<T>::value>> : std::true_type { };
+
+		template <typename T>
+		struct is_var_bind<T, std::enable_if_t<is_lua_reference_or_proxy<T>::value>> : std::true_type { };
+
+		template <>
+		struct is_var_bind<detail::no_prop> : std::true_type { };
+
+		template <typename R, typename W>
+		struct is_var_bind<property_wrapper<R, W>> : std::true_type { };
+
+		template <typename T>
+		struct is_var_bind<var_wrapper<T>> : std::true_type { };
+
+		template <typename T>
+		struct is_var_bind<readonly_wrapper<T>> : is_var_bind<meta::unqualified_t<T>> { };
+
+		template <typename F, typename... Policies>
+		struct is_var_bind<policy_wrapper<F, Policies...>> : is_var_bind<meta::unqualified_t<F>> { };
+	} // namespace call_detail
+
+	template <typename T>
+	struct is_variable_binding : call_detail::is_var_bind<meta::unqualified_t<T>> { };
+
+	template <typename T>
+	using is_var_wrapper = meta::is_specialization_of<T, var_wrapper>;
+
+	template <typename T>
+	struct is_function_binding : meta::neg<is_variable_binding<T>> { };
+
+} // namespace sol
+
+// end of sol/call.hpp
+
+namespace sol {
+	namespace function_detail {
+		template <typename F, F fx>
+		inline int call_wrapper_variable(std::false_type, lua_State* L) {
+			typedef meta::bind_traits<meta::unqualified_t<F>> traits_type;
+			typedef typename traits_type::args_list args_list;
+			typedef meta::tuple_types<typename traits_type::return_type> return_type;
+			return stack::call_into_lua(return_type(), args_list(), L, 1, fx);
+		}
+
+		template <typename R, typename V, V, typename T>
+		inline int call_set_assignable(std::false_type, T&&, lua_State* L) {
+			return luaL_error(L, "cannot write to this type: copy assignment/constructor not available");
+		}
+
+		template <typename R, typename V, V variable, typename T>
+		inline int call_set_assignable(std::true_type, lua_State* L, T&& mem) {
+			(mem.*variable) = stack::get<R>(L, 2);
+			return 0;
+		}
+
+		template <typename R, typename V, V, typename T>
+		inline int call_set_variable(std::false_type, lua_State* L, T&&) {
+			return luaL_error(L, "cannot write to a const variable");
+		}
+
+		template <typename R, typename V, V variable, typename T>
+		inline int call_set_variable(std::true_type, lua_State* L, T&& mem) {
+			return call_set_assignable<R, V, variable>(std::is_assignable<std::add_lvalue_reference_t<R>, R>(), L, std::forward<T>(mem));
+		}
+
+		template <typename V, V variable>
+		inline int call_wrapper_variable(std::true_type, lua_State* L) {
+			typedef meta::bind_traits<meta::unqualified_t<V>> traits_type;
+			typedef typename traits_type::object_type T;
+			typedef typename traits_type::return_type R;
+			auto& mem = stack::get<T>(L, 1);
+			switch (lua_gettop(L)) {
+			case 1: {
+				decltype(auto) r = (mem.*variable);
+				stack::push_reference(L, std::forward<decltype(r)>(r));
+				return 1;
+			}
+			case 2:
+				return call_set_variable<R, V, variable>(meta::neg<std::is_const<R>>(), L, mem);
+			default:
+				return luaL_error(L, "incorrect number of arguments to member variable function call");
+			}
+		}
+
+		template <typename F, F fx>
+		inline int call_wrapper_function(std::false_type, lua_State* L) {
+			return call_wrapper_variable<F, fx>(std::is_member_object_pointer<F>(), L);
+		}
+
+		template <typename F, F fx>
+		inline int call_wrapper_function(std::true_type, lua_State* L) {
+			return call_detail::call_wrapped<void, false, false>(L, fx);
+		}
+
+		template <typename F, F fx>
+		int call_wrapper_entry(lua_State* L) noexcept(meta::bind_traits<F>::is_noexcept) {
+			return call_wrapper_function<F, fx>(std::is_member_function_pointer<meta::unqualified_t<F>>(), L);
+		}
+
+		template <typename... Fxs>
+		struct c_call_matcher {
+			template <typename Fx, std::size_t I, typename R, typename... Args>
+			int operator()(types<Fx>, meta::index_value<I>, types<R>, types<Args...>, lua_State* L, int, int) const {
+				typedef meta::at_in_pack_t<I, Fxs...> target;
+				return target::call(L);
+			}
+		};
+
+		template <typename F, F fx>
+		inline int c_call_raw(std::true_type, lua_State* L) {
+			return fx(L);
+		}
+
+		template <typename F, F fx>
+		inline int c_call_raw(std::false_type, lua_State* L) {
+#ifdef __clang__
+			return detail::trampoline(L, function_detail::call_wrapper_entry<F, fx>);
+#else
+			return detail::typed_static_trampoline<decltype(&function_detail::call_wrapper_entry<F, fx>), (&function_detail::call_wrapper_entry<F, fx>)>(L);
+#endif // fuck you clang :c
+		}
+
+	} // namespace function_detail
+
+	template <typename F, F fx>
+	inline int c_call(lua_State* L) {
+		typedef meta::unqualified_t<F> Fu;
+		typedef std::integral_constant<bool,
+		     std::is_same<Fu, lua_CFunction>::value
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		          || std::is_same<Fu, detail::lua_CFunction_noexcept>::value
+#endif
+		     >
+		     is_raw;
+		return function_detail::c_call_raw<F, fx>(is_raw(), L);
+	}
+
+	template <typename F, F f>
+	struct wrap {
+		typedef F type;
+
+		static int call(lua_State* L) noexcept(noexcept(c_call<type, f>(L))) {
+			return c_call<type, f>(L);
+		}
+	};
+
+	template <typename... Fxs>
+	inline int c_call(lua_State* L) {
+		if constexpr (sizeof...(Fxs) < 2) {
+			using target = meta::at_in_pack_t<0, Fxs...>;
+			return target::call(L);
+		}
+		else {
+			return call_detail::overload_match_arity<typename Fxs::type...>(function_detail::c_call_matcher<Fxs...>(), L, lua_gettop(L), 1);
+		}
+	}
+
+} // namespace sol
+
+// end of sol/function_types_templated.hpp
+
+// beginning of sol/function_types_stateless.hpp
+
+namespace sol { namespace function_detail {
+	template <typename Function>
+	struct upvalue_free_function {
+		using function_type = std::remove_pointer_t<std::decay_t<Function>>;
+		using traits_type = meta::bind_traits<function_type>;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			auto udata = stack::stack_detail::get_as_upvalues<function_type*>(L);
+			function_type* fx = udata.first;
+			return call_detail::call_wrapped<void, true, false>(L, fx);
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L) {
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_member_function {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member function pointer
+			// idx n + 1: is the object's void pointer
+			// We don't need to store the size, because the other side is templated
+			// with the same member function pointer type
+			function_type& memfx = stack::get<user<function_type>>(L, upvalue_index(2));
+			auto& item = *static_cast<T*>(stack::get<void*>(L, upvalue_index(3)));
+			return call_detail::call_wrapped<T, true, false, -1>(L, memfx, item);
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_member_variable {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			// idx n + 1: is the object's void pointer
+			// We don't need to store the size, because the other side is templated
+			// with the same member function pointer type
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
+			auto& mem = *objdata.first;
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 0:
+				return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
+			case 1:
+				return call_detail::call_wrapped<T, false, false, -1>(L, var, mem);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_member_variable<T, readonly_wrapper<Function>> {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			// idx n + 1: is the object's void pointer
+			// We don't need to store the size, because the other side is templated
+			// with the same member function pointer type
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
+			auto& mem = *objdata.first;
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 0:
+				return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_this_member_function {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			function_type& memfx = stack::get<user<function_type>>(L, upvalue_index(2));
+			return call_detail::call_wrapped<T, false, false>(L, memfx);
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_this_member_variable {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+
+		static int real_call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 1:
+				return call_detail::call_wrapped<T, true, false>(L, var);
+			case 2:
+				return call_detail::call_wrapped<T, false, false>(L, var);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_this_member_variable<T, readonly_wrapper<Function>> {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 1:
+				return call_detail::call_wrapped<T, true, false>(L, var);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			return call(L);
+		}
+	};
+}} // namespace sol::function_detail
+
+// end of sol/function_types_stateless.hpp
+
+// beginning of sol/function_types_stateful.hpp
+
+namespace sol { namespace function_detail {
+	template <typename Func, bool is_yielding, bool no_trampoline>
+	struct functor_function {
+		typedef std::decay_t<meta::unwrap_unqualified_t<Func>> function_type;
+		function_type invocation;
+
+		template <typename... Args>
+		functor_function(function_type f, Args&&... args) noexcept(std::is_nothrow_constructible_v<function_type, function_type, Args...>)
+		: invocation(std::move(f), std::forward<Args>(args)...) {
+		}
+
+		static int call(lua_State* L, functor_function& self) noexcept(noexcept(call_detail::call_wrapped<void, true, false>(L, self.invocation))) {
+			int nr = call_detail::call_wrapped<void, true, false>(L, self.invocation);
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) noexcept(noexcept(call_detail::call_wrapped<void, true, false>(L, invocation))) {
+			if constexpr (no_trampoline) {
+				return call(L, *this);
+			}
+			else {
+				return detail::trampoline(L, &call, *this);
+			}
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding, bool no_trampoline>
+	struct member_function {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef meta::function_return_t<function_type> return_type;
+		typedef meta::function_args_t<function_type> args_lists;
+		using traits_type = meta::bind_traits<function_type>;
+		function_type invocation;
+		T member;
+
+		template <typename... Args>
+		member_function(function_type f, Args&&... args) noexcept(
+			std::is_nothrow_constructible_v<function_type, function_type>&& std::is_nothrow_constructible_v<T, Args...>)
+		: invocation(std::move(f)), member(std::forward<Args>(args)...) {
+		}
+
+		static int call(lua_State* L, member_function& self)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr = call_detail::call_wrapped<T, true, false, -1>(L, self.invocation, detail::unwrap(detail::deref(self.member)));
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			if constexpr (no_trampoline) {
+				return call(L, *this);
+			}
+			else {
+				return detail::trampoline(L, &call, *this);
+			}
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding, bool no_trampoline>
+	struct member_variable {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef typename meta::bind_traits<function_type>::return_type return_type;
+		typedef typename meta::bind_traits<function_type>::args_list args_lists;
+		function_type var;
+		T member;
+		typedef std::add_lvalue_reference_t<meta::unwrapped_t<std::remove_reference_t<decltype(detail::deref(member))>>> M;
+
+		template <typename... Args>
+		member_variable(function_type v, Args&&... args) noexcept(
+			std::is_nothrow_constructible_v<function_type, function_type>&& std::is_nothrow_constructible_v<T, Args...>)
+		: var(std::move(v)), member(std::forward<Args>(args)...) {
+		}
+
+		static int call(lua_State* L, member_variable& self) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			int nr;
+			{
+				M mem = detail::unwrap(detail::deref(self.member));
+				switch (lua_gettop(L)) {
+				case 0:
+					nr = call_detail::call_wrapped<T, true, false, -1>(L, self.var, mem);
+					break;
+				case 1:
+					nr = call_detail::call_wrapped<T, false, false, -1>(L, self.var, mem);
+					break;
+				default:
+					nr = luaL_error(L, "sol: incorrect number of arguments to member variable function");
+					break;
+				}
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			if constexpr (no_trampoline) {
+				return call(L, *this);
+			}
+			else {
+				return detail::trampoline(L, &call, *this);
+			}
+		}
+	};
+}} // namespace sol::function_detail
+
+// end of sol/function_types_stateful.hpp
+
+// beginning of sol/function_types_overloaded.hpp
+
+namespace sol { namespace function_detail {
+	template <int start_skew, typename... Functions>
+	struct overloaded_function {
+		typedef std::tuple<Functions...> overload_list;
+		typedef std::make_index_sequence<sizeof...(Functions)> indices;
+		overload_list overloads;
+
+		overloaded_function(overload_list set) : overloads(std::move(set)) {
+		}
+
+		overloaded_function(Functions... fxs) : overloads(fxs...) {
+		}
+
+		template <typename Fx, std::size_t I, typename... R, typename... Args>
+		static int call(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, overload_list& ol) {
+			auto& func = std::get<I>(ol);
+			int nr = call_detail::call_wrapped<void, true, false, start_skew>(L, func);
+			return nr;
+		}
+
+		struct on_success {
+			template <typename... Args>
+			int operator()(Args&&... args) const {
+				return call(std::forward<Args>(args)...);
+			}
+		};
+
+		int operator()(lua_State* L) {
+			on_success call_obj {};
+			return call_detail::overload_match<Functions...>(call_obj, L, 1 + start_skew, overloads);
+		}
+	};
+}} // namespace sol::function_detail
+
+// end of sol/function_types_overloaded.hpp
+
+// beginning of sol/resolve.hpp
+
+namespace sol {
+
+#ifndef __clang__
+	// constexpr is fine for not-clang
+
+	namespace detail {
+		template <typename R, typename... Args, typename F, typename = std::invoke_result_t<meta::unqualified_t<F>, Args...>>
+		inline constexpr auto resolve_i(types<R(Args...)>, F&&) -> R (meta::unqualified_t<F>::*)(Args...) {
+			using Sig = R(Args...);
+			typedef meta::unqualified_t<F> Fu;
+			return static_cast<Sig Fu::*>(&Fu::operator());
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline constexpr auto resolve_f(std::true_type, F&& f)
+		     -> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
+			return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
+		}
+
+		template <typename F>
+		inline constexpr void resolve_f(std::false_type, F&&) {
+			static_assert(meta::call_operator_deducible_v<F>, "Cannot use no-template-parameter call with an overloaded functor: specify the signature");
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline constexpr auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::call_operator_deducible<U>(), std::forward<F>(f))) {
+			return resolve_f(meta::call_operator_deducible<U> {}, std::forward<F>(f));
+		}
+
+		template <typename... Args, typename F, typename R = std::invoke_result_t<F&, Args...>>
+		inline constexpr auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
+			return resolve_i(types<R(Args...)>(), std::forward<F>(f));
+		}
+
+		template <typename Sig, typename C>
+		inline constexpr Sig C::*resolve_v(std::false_type, Sig C::*mem_func_ptr) {
+			return mem_func_ptr;
+		}
+
+		template <typename Sig, typename C>
+		inline constexpr Sig C::*resolve_v(std::true_type, Sig C::*mem_variable_ptr) {
+			return mem_variable_ptr;
+		}
+	} // namespace detail
+
+	template <typename... Args, typename R>
+	inline constexpr auto resolve(R fun_ptr(Args...)) -> R (*)(Args...) {
+		return fun_ptr;
+	}
+
+	template <typename Sig>
+	inline constexpr Sig* resolve(Sig* fun_ptr) {
+		return fun_ptr;
+	}
+
+	template <typename... Args, typename R, typename C>
+	inline constexpr auto resolve(R (C::*mem_ptr)(Args...)) -> R (C::*)(Args...) {
+		return mem_ptr;
+	}
+
+	template <typename Sig, typename C>
+	inline constexpr Sig C::*resolve(Sig C::*mem_ptr) {
+		return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
+	}
+
+	template <typename... Sig, typename F, meta::disable<std::is_function<meta::unqualified_t<F>>> = meta::enabler>
+	inline constexpr auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
+		return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
+	}
+#else
+
+	// Clang has distinct problems with constexpr arguments,
+	// so don't use the constexpr versions inside of clang.
+
+	namespace detail {
+		template <typename R, typename... Args, typename F, typename = std::invoke_result_t<meta::unqualified_t<F>, Args...>>
+		inline auto resolve_i(types<R(Args...)>, F&&) -> R (meta::unqualified_t<F>::*)(Args...) {
+			using Sig = R(Args...);
+			typedef meta::unqualified_t<F> Fu;
+			return static_cast<Sig Fu::*>(&Fu::operator());
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline auto resolve_f(std::true_type, F&& f)
+		     -> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
+			return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
+		}
+
+		template <typename F>
+		inline void resolve_f(std::false_type, F&&) {
+			static_assert(meta::call_operator_deducible_v<F>, "Cannot use no-template-parameter call with an overloaded functor: specify the signature");
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::call_operator_deducible<U>(), std::forward<F>(f))) {
+			return resolve_f(meta::call_operator_deducible<U> {}, std::forward<F>(f));
+		}
+
+		template <typename... Args, typename F, typename R = std::invoke_result_t<F&, Args...>>
+		inline auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
+			return resolve_i(types<R(Args...)>(), std::forward<F>(f));
+		}
+
+		template <typename Sig, typename C>
+		inline Sig C::*resolve_v(std::false_type, Sig C::*mem_func_ptr) {
+			return mem_func_ptr;
+		}
+
+		template <typename Sig, typename C>
+		inline Sig C::*resolve_v(std::true_type, Sig C::*mem_variable_ptr) {
+			return mem_variable_ptr;
+		}
+	} // namespace detail
+
+	template <typename... Args, typename R>
+	inline auto resolve(R fun_ptr(Args...)) -> R (*)(Args...) {
+		return fun_ptr;
+	}
+
+	template <typename Sig>
+	inline Sig* resolve(Sig* fun_ptr) {
+		return fun_ptr;
+	}
+
+	template <typename... Args, typename R, typename C>
+	inline auto resolve(R (C::*mem_ptr)(Args...)) -> R (C::*)(Args...) {
+		return mem_ptr;
+	}
+
+	template <typename Sig, typename C>
+	inline Sig C::*resolve(Sig C::*mem_ptr) {
+		return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
+	}
+
+	template <typename... Sig, typename F>
+	inline auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
+		return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
+	}
+
+#endif
+
+} // namespace sol
+
+// end of sol/resolve.hpp
+
+namespace sol {
+	namespace function_detail {
+		template <typename T>
+		struct class_indicator {
+			using type = T;
+		};
+
+		struct call_indicator { };
+
+		template <bool yielding>
+		int lua_c_wrapper(lua_State* L) {
+			lua_CFunction cf = lua_tocfunction(L, lua_upvalueindex(2));
+			int nr = cf(L);
+			if constexpr (yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		template <bool yielding>
+		int lua_c_noexcept_wrapper(lua_State* L) noexcept {
+			detail::lua_CFunction_noexcept cf = reinterpret_cast<detail::lua_CFunction_noexcept>(lua_tocfunction(L, lua_upvalueindex(2)));
+			int nr = cf(L);
+			if constexpr (yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		struct c_function_invocation { };
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select(lua_State* L, Fx&& fx, Args&&... args);
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select_set_fx(lua_State* L, Args&&... args) {
+			lua_CFunction freefunc = no_trampoline ? function_detail::call<meta::unqualified_t<Fx>, 2, is_yielding>
+			                                       : detail::static_trampoline<function_detail::call<meta::unqualified_t<Fx>, 2, is_yielding>>;
+
+			int upvalues = 0;
+			upvalues += stack::push(L, nullptr);
+			upvalues += stack::push<user<Fx>>(L, std::forward<Args>(args)...);
+			stack::push(L, c_closure(freefunc, upvalues));
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename R, typename... A, typename Fx, typename... Args>
+		void select_convertible(types<R(A...)>, lua_State* L, Fx&& fx, Args&&... args) {
+			using dFx = std::decay_t<meta::unwrap_unqualified_t<Fx>>;
+			using fx_ptr_t = R (*)(A...);
+			constexpr bool is_convertible = std::is_convertible_v<dFx, fx_ptr_t>;
+			if constexpr (is_convertible) {
+				fx_ptr_t fxptr = detail::unwrap(std::forward<Fx>(fx));
+				select<is_yielding, no_trampoline>(L, std::move(fxptr), std::forward<Args>(args)...);
+			}
+			else {
+				using F = function_detail::functor_function<dFx, false, true>;
+				select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select_convertible(types<>, lua_State* L, Fx&& fx, Args&&... args) {
+			typedef meta::function_signature_t<meta::unwrap_unqualified_t<Fx>> Sig;
+			select_convertible<is_yielding, no_trampoline>(types<Sig>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select_member_variable(lua_State* L, Fx&& fx, Args&&... args) {
+			using uFx = meta::unqualified_t<Fx>;
+			if constexpr (sizeof...(Args) < 1) {
+				using C = typename meta::bind_traits<uFx>::object_type;
+				lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<C, Fx>::template call<is_yielding, no_trampoline>;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::stack_detail::push_as_upvalues(L, fx);
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else if constexpr (sizeof...(Args) < 2) {
+				using Tu = typename meta::meta_detail::unqualified_non_alias<Args...>::type;
+				constexpr bool is_reference = meta::is_specialization_of_v<Tu, std::reference_wrapper> || std::is_pointer_v<Tu>;
+				if constexpr (meta::is_specialization_of_v<Tu, function_detail::class_indicator>) {
+					lua_CFunction freefunc
+					     = &function_detail::upvalue_this_member_variable<typename Tu::type, Fx>::template call<is_yielding, no_trampoline>;
+
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::stack_detail::push_as_upvalues(L, fx);
+					stack::push(L, c_closure(freefunc, upvalues));
+				}
+				else if constexpr (is_reference) {
+					typedef std::decay_t<Fx> dFx;
+					dFx memfxptr(std::forward<Fx>(fx));
+					auto userptr = detail::ptr(std::forward<Args>(args)...);
+					lua_CFunction freefunc = &function_detail::upvalue_member_variable<std::decay_t<decltype(*userptr)>,
+					     meta::unqualified_t<Fx>>::template call<is_yielding, no_trampoline>;
+
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::stack_detail::push_as_upvalues(L, memfxptr);
+					upvalues += stack::push(L, static_cast<void const*>(userptr));
+					stack::push(L, c_closure(freefunc, upvalues));
+				}
+				else {
+					using clean_fx = std::remove_pointer_t<std::decay_t<Fx>>;
+					using F = function_detail::member_variable<Tu, clean_fx, is_yielding, no_trampoline>;
+					select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+				}
+			}
+			else {
+				using C = typename meta::bind_traits<uFx>::object_type;
+				using clean_fx = std::remove_pointer_t<std::decay_t<Fx>>;
+				using F = function_detail::member_variable<C, clean_fx, is_yielding, no_trampoline>;
+				select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename T, typename... Args>
+		void select_member_function_with(lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
+			using dFx = std::decay_t<Fx>;
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::is_specialization_of_v<Tu, function_detail::class_indicator>) {
+				(void)obj;
+				using C = typename Tu::type;
+				lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, dFx>::template call<is_yielding, no_trampoline>;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else {
+				constexpr bool is_reference = meta::is_specialization_of_v<Tu, std::reference_wrapper> || std::is_pointer_v<Tu>;
+				if constexpr (is_reference) {
+					auto userptr = detail::ptr(std::forward<T>(obj));
+					lua_CFunction freefunc
+					     = &function_detail::upvalue_member_function<std::decay_t<decltype(*userptr)>, dFx>::template call<is_yielding, no_trampoline>;
+
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+					upvalues += stack::push(L, lightuserdata_value(static_cast<void*>(userptr)));
+					stack::push(L, c_closure(freefunc, upvalues));
+				}
+				else {
+					using F = function_detail::member_function<Tu, dFx, is_yielding, no_trampoline>;
+					select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
+				}
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select_member_function(lua_State* L, Fx&& fx, Args&&... args) {
+			using dFx = std::decay_t<Fx>;
+			if constexpr (sizeof...(Args) < 1) {
+				using C = typename meta::bind_traits<meta::unqualified_t<Fx>>::object_type;
+				lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, dFx>::template call<is_yielding, no_trampoline>;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx));
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else {
+				select_member_function_with<is_yielding, no_trampoline>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select(lua_State* L, Fx&& fx, Args&&... args) {
+			using uFx = meta::unqualified_t<Fx>;
+			if constexpr (is_lua_reference_v<uFx>) {
+				// TODO: hoist into lambda in this case for yielding???
+				stack::push(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+			else if constexpr (is_lua_c_function_v<uFx>) {
+				if constexpr (no_trampoline) {
+					if (is_yielding) {
+						int upvalues = 0;
+						upvalues += stack::push(L, nullptr);
+						upvalues += stack::push(L, std::forward<Fx>(fx));
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+						if constexpr (std::is_nothrow_invocable_r_v<int, uFx, lua_State*>) {
+							detail::lua_CFunction_noexcept cf = &lua_c_noexcept_wrapper<true>;
+							lua_pushcclosure(L, reinterpret_cast<lua_CFunction>(cf), upvalues);
+						}
+						else
+#endif
+						{
+							lua_CFunction cf = &function_detail::lua_c_wrapper<true>;
+							lua_pushcclosure(L, cf, upvalues);
+						}
+					}
+					else {
+						lua_pushcclosure(L, std::forward<Fx>(fx), 0);
+					}
+				}
+				else {
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::push(L, std::forward<Fx>(fx));
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+					if constexpr (std::is_nothrow_invocable_r_v<int, uFx, lua_State*>) {
+						detail::lua_CFunction_noexcept cf = &lua_c_noexcept_wrapper<is_yielding>;
+						lua_pushcclosure(L, reinterpret_cast<lua_CFunction>(cf), upvalues);
+					}
+					else {
+						lua_CFunction cf = &function_detail::lua_c_wrapper<is_yielding>;
+						lua_pushcclosure(L, cf, upvalues);
+					}
+#else
+					lua_CFunction cf = &function_detail::lua_c_wrapper<is_yielding>;
+					lua_pushcclosure(L, cf, upvalues);
+#endif
+				}
+			}
+			else if constexpr (std::is_function_v<std::remove_pointer_t<uFx>>) {
+				std::decay_t<Fx> target(std::forward<Fx>(fx), std::forward<Args>(args)...);
+				lua_CFunction freefunc = &function_detail::upvalue_free_function<Fx>::template call<is_yielding, no_trampoline>;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::stack_detail::push_as_upvalues(L, target);
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else if constexpr (std::is_member_function_pointer_v<uFx>) {
+				select_member_function<is_yielding, no_trampoline>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::is_member_object_v<uFx>) {
+				select_member_variable<is_yielding, no_trampoline>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+			else {
+				select_convertible<is_yielding, no_trampoline>(types<>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+	} // namespace function_detail
+
+	namespace stack {
+		template <typename... Sigs>
+		struct unqualified_pusher<function_sig<Sigs...>> {
+			template <bool is_yielding, typename Arg0, typename... Args>
+			static int push_yielding(lua_State* L, Arg0&& arg0, Args&&... args) {
+				if constexpr (meta::is_specialization_of_v<meta::unqualified_t<Arg0>, std::function>) {
+					if constexpr (is_yielding) {
+						return stack::push<meta::unqualified_t<Arg0>>(L, detail::yield_tag, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+					}
+					else {
+						return stack::push(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+					}
+				}
+				else {
+					function_detail::select<is_yielding, false>(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+					return 1;
+				}
+			}
+
+			template <typename Arg0, typename... Args>
+			static int push(lua_State* L, Arg0&& arg0, Args&&... args) {
+				if constexpr (std::is_same_v<meta::unqualified_t<Arg0>, detail::yield_tag_t>) {
+					push_yielding<true>(L, std::forward<Args>(args)...);
+				}
+				else if constexpr (meta::is_specialization_of_v<meta::unqualified_t<Arg0>, yielding_t>) {
+					push_yielding<true>(L, std::forward<Arg0>(arg0).func, std::forward<Args>(args)...);
+				}
+				else {
+					push_yielding<false>(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+				}
+				return 1;
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<yielding_t<T>> {
+			template <typename... Args>
+			static int push(lua_State* L, const yielding_t<T>& f, Args&&... args) {
+				if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::function>) {
+					return stack::push<T>(L, detail::yield_tag, f.func, std::forward<Args>(args)...);
+				}
+				else {
+					function_detail::select<true, false>(L, f.func, std::forward<Args>(args)...);
+					return 1;
+				}
+			}
+
+			template <typename... Args>
+			static int push(lua_State* L, yielding_t<T>&& f, Args&&... args) {
+				if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::function>) {
+					return stack::push<T>(L, detail::yield_tag, std::move(f.func), std::forward<Args>(args)...);
+				}
+				else {
+					function_detail::select<true, false>(L, std::move(f.func), std::forward<Args>(args)...);
+					return 1;
+				}
+			}
+		};
+
+		template <typename T, typename... Args>
+		struct unqualified_pusher<function_arguments<T, Args...>> {
+			template <std::size_t... I, typename FP>
+			static int push_func(std::index_sequence<I...>, lua_State* L, FP&& fp) {
+				return stack::push<T>(L, std::get<I>(std::forward<FP>(fp).arguments)...);
+			}
+
+			static int push(lua_State* L, const function_arguments<T, Args...>& fp) {
+				return push_func(std::make_index_sequence<sizeof...(Args)>(), L, fp);
+			}
+
+			static int push(lua_State* L, function_arguments<T, Args...>&& fp) {
+				return push_func(std::make_index_sequence<sizeof...(Args)>(), L, std::move(fp));
+			}
+		};
+
+		template <typename Signature>
+		struct unqualified_pusher<std::function<Signature>> {
+			using TargetFunctor = function_detail::functor_function<std::function<Signature>, false, true>;
+
+			static int push(lua_State* L, detail::yield_tag_t, const std::function<Signature>& fx) {
+				if (fx) {
+					function_detail::select_set_fx<true, false, TargetFunctor>(L, fx);
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+
+			static int push(lua_State* L, detail::yield_tag_t, std::function<Signature>&& fx) {
+				if (fx) {
+					function_detail::select_set_fx<true, false, TargetFunctor>(L, std::move(fx));
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+
+			static int push(lua_State* L, const std::function<Signature>& fx) {
+				if (fx) {
+					function_detail::select_set_fx<false, false, TargetFunctor>(L, fx);
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+
+			static int push(lua_State* L, std::function<Signature>&& fx) {
+				if (fx) {
+					function_detail::select_set_fx<false, false, TargetFunctor>(L, std::move(fx));
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+		};
+
+		template <typename Signature>
+		struct unqualified_pusher<Signature, std::enable_if_t<meta::is_member_object_or_function_v<Signature>>> {
+			template <typename... Args>
+			static int push(lua_State* L, Args&&... args) {
+				function_detail::select<false, false>(L, std::forward<Args>(args)...);
+				return 1;
+			}
+		};
+
+		template <typename Signature>
+		struct unqualified_pusher<Signature,
+		     std::enable_if_t<meta::all<std::is_function<std::remove_pointer_t<Signature>>, meta::neg<std::is_same<Signature, lua_CFunction>>,
+		          meta::neg<std::is_same<Signature, std::remove_pointer_t<lua_CFunction>>>
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		          ,
+		          meta::neg<std::is_same<Signature, detail::lua_CFunction_noexcept>>,
+		          meta::neg<std::is_same<Signature, std::remove_pointer_t<detail::lua_CFunction_noexcept>>>
+#endif // noexcept function types
+		          >::value>> {
+			template <typename F>
+			static int push(lua_State* L, F&& f) {
+				function_detail::select<false, true>(L, std::forward<F>(f));
+				return 1;
+			}
+		};
+
+		template <typename... Functions>
+		struct unqualified_pusher<overload_set<Functions...>> {
+			static int push(lua_State* L, overload_set<Functions...>&& set) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, std::move(set.functions));
+				return 1;
+			}
+
+			static int push(lua_State* L, const overload_set<Functions...>& set) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, set.functions);
+				return 1;
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<protect_t<T>> {
+			static int push(lua_State* L, protect_t<T>&& pw) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<protect_t<T>>>(L, std::move(pw.value));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const protect_t<T>& pw) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<protect_t<T>>>(L, pw.value);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename F, typename G>
+		struct unqualified_pusher<property_wrapper<F, G>> {
+			static int push(lua_State* L, property_wrapper<F, G>&& pw) {
+				if constexpr (std::is_void_v<F>) {
+					return stack::push(L, std::move(pw.write()));
+				}
+				else if constexpr (std::is_void_v<G>) {
+					return stack::push(L, std::move(pw.read()));
+				}
+				else {
+					return stack::push(L, overload(std::move(pw.read()), std::move(pw.write())));
+				}
+			}
+
+			static int push(lua_State* L, const property_wrapper<F, G>& pw) {
+				if constexpr (std::is_void_v<F>) {
+					return stack::push(L, pw.write);
+				}
+				else if constexpr (std::is_void_v<G>) {
+					return stack::push(L, pw.read);
+				}
+				else {
+					return stack::push(L, overload(pw.read, pw.write));
+				}
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<var_wrapper<T>> {
+			static int push(lua_State* L, var_wrapper<T>&& vw) {
+				return stack::push(L, std::move(vw.value()));
+			}
+			static int push(lua_State* L, const var_wrapper<T>& vw) {
+				return stack::push(L, vw.value());
+			}
+		};
+
+		template <typename... Functions>
+		struct unqualified_pusher<factory_wrapper<Functions...>> {
+			static int push(lua_State* L, const factory_wrapper<Functions...>& fw) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, fw.functions);
+				return 1;
+			}
+
+			static int push(lua_State* L, factory_wrapper<Functions...>&& fw) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, std::move(fw.functions));
+				return 1;
+			}
+
+			static int push(lua_State* L, const factory_wrapper<Functions...>& fw, function_detail::call_indicator) {
+				using F = function_detail::overloaded_function<1, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, fw.functions);
+				return 1;
+			}
+
+			static int push(lua_State* L, factory_wrapper<Functions...>&& fw, function_detail::call_indicator) {
+				using F = function_detail::overloaded_function<1, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, std::move(fw.functions));
+				return 1;
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<no_construction> {
+			static int push(lua_State* L, no_construction) {
+				lua_CFunction cf = &function_detail::no_construction_error;
+				return stack::push(L, cf);
+			}
+
+			static int push(lua_State* L, no_construction c, function_detail::call_indicator) {
+				return push(L, c);
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<detail::tagged<T, no_construction>> {
+			static int push(lua_State* L, detail::tagged<T, no_construction>) {
+				lua_CFunction cf = &function_detail::no_construction_error;
+				return stack::push(L, cf);
+			}
+
+			static int push(lua_State* L, no_construction, function_detail::call_indicator) {
+				lua_CFunction cf = &function_detail::no_construction_error;
+				return stack::push(L, cf);
+			}
+		};
+
+		template <typename T, typename... Lists>
+		struct unqualified_pusher<detail::tagged<T, constructor_list<Lists...>>> {
+			static int push(lua_State* L, detail::tagged<T, constructor_list<Lists...>>) {
+				lua_CFunction cf = call_detail::construct<T, detail::default_safe_function_calls, true, Lists...>;
+				return stack::push(L, cf);
+			}
+
+			static int push(lua_State* L, constructor_list<Lists...>) {
+				lua_CFunction cf = call_detail::construct<T, detail::default_safe_function_calls, true, Lists...>;
+				return stack::push(L, cf);
+			}
+		};
+
+		template <typename L0, typename... Lists>
+		struct unqualified_pusher<constructor_list<L0, Lists...>> {
+			typedef constructor_list<L0, Lists...> cl_t;
+			static int push(lua_State* L, cl_t cl) {
+				typedef typename meta::bind_traits<L0>::return_type T;
+				return stack::push<detail::tagged<T, cl_t>>(L, cl);
+			}
+		};
+
+		template <typename T, typename... Fxs>
+		struct unqualified_pusher<detail::tagged<T, constructor_wrapper<Fxs...>>> {
+			static int push(lua_State* L, detail::tagged<T, constructor_wrapper<Fxs...>>&& c) {
+				return push(L, std::move(c.value()));
+			}
+
+			static int push(lua_State* L, const detail::tagged<T, const constructor_wrapper<Fxs...>>& c) {
+				return push(L, c.value());
+			}
+
+			static int push(lua_State* L, constructor_wrapper<Fxs...>&& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, constructor_wrapper<Fxs...>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<constructor_wrapper<Fxs...>>>(L, std::move(c));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const constructor_wrapper<Fxs...>& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, constructor_wrapper<Fxs...>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<constructor_wrapper<Fxs...>>>(L, c);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename F, typename... Fxs>
+		struct unqualified_pusher<constructor_wrapper<F, Fxs...>> {
+			static int push(lua_State* L, const constructor_wrapper<F, Fxs...>& c) {
+				typedef typename meta::bind_traits<F>::template arg_at<0> arg0;
+				typedef meta::unqualified_t<std::remove_pointer_t<arg0>> T;
+				return stack::push<detail::tagged<T, constructor_wrapper<F, Fxs...>>>(L, c);
+			}
+
+			static int push(lua_State* L, constructor_wrapper<F, Fxs...>&& c) {
+				typedef typename meta::bind_traits<F>::template arg_at<0> arg0;
+				typedef meta::unqualified_t<std::remove_pointer_t<arg0>> T;
+				return stack::push<detail::tagged<T, constructor_wrapper<F, Fxs...>>>(L, std::move(c));
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<detail::tagged<T, destructor_wrapper<void>>> {
+			static int push(lua_State* L, destructor_wrapper<void>) {
+				lua_CFunction cf = detail::usertype_alloc_destroy<T>;
+				return stack::push(L, cf);
+			}
+		};
+
+		template <typename T, typename Fx>
+		struct unqualified_pusher<detail::tagged<T, destructor_wrapper<Fx>>> {
+			static int push(lua_State* L, destructor_wrapper<Fx>&& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, std::move(c));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const destructor_wrapper<Fx>& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, c);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename Fx>
+		struct unqualified_pusher<destructor_wrapper<Fx>> {
+			static int push(lua_State* L, destructor_wrapper<Fx>&& c) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, std::move(c));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const destructor_wrapper<Fx>& c) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, c);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename F, typename... Policies>
+		struct unqualified_pusher<policy_wrapper<F, Policies...>> {
+			using P = policy_wrapper<F, Policies...>;
+
+			static int push(lua_State* L, const P& p) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, p);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, P&& p) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, std::move(p));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename T, typename F, typename... Policies>
+		struct unqualified_pusher<detail::tagged<T, policy_wrapper<F, Policies...>>> {
+			using P = policy_wrapper<F, Policies...>;
+			using Tagged = detail::tagged<T, P>;
+
+			static int push(lua_State* L, const Tagged& p) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, p.value());
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, Tagged&& p) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, std::move(p.value()));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<push_invoke_t<T>> {
+			static int push(lua_State* L, push_invoke_t<T>&& pi) {
+				if constexpr (std::is_invocable_v<std::add_rvalue_reference_t<T>, lua_State*>) {
+					return stack::push(L, std::move(pi.value())(L));
+				}
+				else {
+					return stack::push(L, std::move(pi.value())());
+				}
+			}
+
+			static int push(lua_State* L, const push_invoke_t<T>& pi) {
+				if constexpr (std::is_invocable_v<const T, lua_State*>) {
+					return stack::push(L, pi.value()(L));
+				}
+				else {
+					return stack::push(L, pi.value()());
+				}
+			}
+		};
+
+		namespace stack_detail {
+			template <typename Function, typename Handler>
+			bool check_function_pointer(lua_State* L, int index, Handler&& handler, record& tracking) noexcept {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+				tracking.use(1);
+				bool success = lua_iscfunction(L, index) == 1;
+				if (success) {
+					// there must be at LEAST 2 upvalues; otherwise, we didn't serialize it.
+					const char* upvalue_name = lua_getupvalue(L, index, 2);
+					lua_pop(L, 1);
+					success = upvalue_name != nullptr;
+				}
+				if (!success) {
+					// expected type, actual type
+					handler(
+					     L, index, type::function, type_of(L, index), "type must be a Lua C Function gotten from a function pointer serialized by sol2");
+				}
+				return success;
+#else
+				(void)L;
+				(void)index;
+				(void)handler;
+				(void)tracking;
+				return false;
+#endif
+			}
+
+			template <typename Function>
+			Function* get_function_pointer(lua_State* L, int index, record& tracking) noexcept {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+				tracking.use(1);
+				auto udata = stack::stack_detail::get_as_upvalues_using_function<Function*>(L, index);
+				Function* fx = udata.first;
+				return fx;
+#else
+				(void)L;
+				(void)index;
+				(void)tracking;
+				static_assert(meta::meta_detail::always_true<Function>::value,
+#if SOL_IS_DEFAULT_OFF(SOL_GET_FUNCTION_POINTER_UNSAFE)
+				     "You are attempting to retrieve a function pointer type. "
+				     "This is inherently unsafe in sol2. In order to do this, you must turn on the "
+				     "SOL_GET_FUNCTION_POINTER_UNSAFE configuration macro, as detailed in the documentation. "
+				     "Please be careful!"
+#else
+				     "You are attempting to retrieve a function pointer type. "
+				     "You explicitly turned off the ability to do this by defining "
+				     "SOL_GET_FUNCTION_POINTER_UNSAFE or similar to be off. "
+				     "Please reconsider this!"
+#endif
+				);
+				return nullptr;
+#endif
+			}
+		} // namespace stack_detail
+	}      // namespace stack
+} // namespace sol
+
+// end of sol/function_types.hpp
+
+// beginning of sol/dump_handler.hpp
+
+#include <cstdint>
+#include <exception>
+
+namespace sol {
+
+	class dump_error : public error {
+	private:
+		int m_ec;
+
+	public:
+		dump_error(int error_code_) : error("dump returned non-zero error of " + std::to_string(error_code_)), m_ec(error_code_) {
+		}
+
+		int error_code() const {
+			return m_ec;
+		}
+	};
+
+	inline int dump_pass_on_error(lua_State* L_, int result_code, lua_Writer writer_function, void* userdata_pointer_, bool strip) {
+		(void)L_;
+		(void)writer_function;
+		(void)userdata_pointer_;
+		(void)strip;
+		return result_code;
+	}
+
+	inline int dump_panic_on_error(lua_State* L_, int result_code, lua_Writer writer_function, void* userdata_pointer_, bool strip) {
+		(void)L_;
+		(void)writer_function;
+		(void)userdata_pointer_;
+		(void)strip;
+		return luaL_error(L_, "a non-zero error code (%d) was returned by the lua_Writer for the dump function", result_code);
+	}
+
+	inline int dump_throw_on_error(lua_State* L_, int result_code, lua_Writer writer_function, void* userdata_pointer_, bool strip) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		return dump_panic_on_error(L_, result_code, writer_function, userdata_pointer_, strip);
+#else
+		(void)L_;
+		(void)writer_function;
+		(void)userdata_pointer_;
+		(void)strip;
+		throw dump_error(result_code);
+#endif // no exceptions stuff
+	}
+
+} // namespace sol
+
+// end of sol/dump_handler.hpp
+
+#include <cstdint>
+
+namespace sol {
+	template <typename ref_t, bool aligned = false>
+	class basic_function : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+		void luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount) const {
+			lua_call(lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount));
+		}
+
+		template <std::size_t... I, typename... Ret>
+		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) const {
+			luacall(n, lua_size<std::tuple<Ret...>>::value);
+			return stack::pop<std::tuple<Ret...>>(lua_state());
+		}
+
+		template <std::size_t I, typename Ret, meta::enable<meta::neg<std::is_void<Ret>>> = meta::enabler>
+		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) const {
+			luacall(n, lua_size<Ret>::value);
+			return stack::pop<Ret>(lua_state());
+		}
+
+		template <std::size_t I>
+		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) const {
+			luacall(n, 0);
+		}
+
+		unsafe_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) const {
+			int stacksize = lua_gettop(lua_state());
+			int firstreturn = (std::max)(1, stacksize - static_cast<int>(n));
+			luacall(n, LUA_MULTRET);
+			int poststacksize = lua_gettop(lua_state());
+			int returncount = poststacksize - (firstreturn - 1);
+			return unsafe_function_result(lua_state(), firstreturn, returncount);
+		}
+
+	public:
+		using base_t::lua_state;
+
+		basic_function() = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_function>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_function(T&& r) noexcept : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_function<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_function>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_function(const basic_function&) = default;
+		basic_function& operator=(const basic_function&) = default;
+		basic_function(basic_function&&) = default;
+		basic_function& operator=(basic_function&&) = default;
+		basic_function(const stack_reference& r) : basic_function(r.lua_state(), r.stack_index()) {
+		}
+		basic_function(stack_reference&& r) : basic_function(r.lua_state(), r.stack_index()) {
+		}
+		basic_function(lua_nil_t n) : base_t(n) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_function(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_function(lua_State* L, int index = -1) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_function>(L, index, handler);
+#endif // Safety
+		}
+		basic_function(lua_State* L, ref_index index) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		template <typename Fx>
+		int dump(lua_Writer writer, void* userdata, bool strip, Fx&& on_error) const {
+			this->push();
+			auto ppn = stack::push_popper_n<false>(this->lua_state(), 1);
+			int r = lua_dump(this->lua_state(), writer, userdata, strip ? 1 : 0);
+			if (r != 0) {
+				return on_error(this->lua_state(), r, writer, userdata, strip);
+			}
+			return r;
+		}
+
+		int dump(lua_Writer writer, void* userdata, bool strip = false) const {
+			return dump(writer, userdata, strip, &dump_throw_on_error);
+		}
+
+		template <typename Container = bytecode>
+		Container dump() const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, &dump_panic_on_error);
+			return bc;
+		}
+
+		template <typename Container = bytecode, typename Fx>
+		Container dump(Fx&& on_error) const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, std::forward<Fx>(on_error));
+			return bc;
+		}
+
+		template <typename... Args>
+		unsafe_function_result operator()(Args&&... args) const {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) operator()(types<Ret...>, Args&&... args) const {
+			return call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) const {
+			if (!aligned) {
+				base_t::push();
+			}
+			int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+			return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), static_cast<std::ptrdiff_t>(pushcount));
+		}
+	};
+} // namespace sol
+
+// end of sol/unsafe_function.hpp
+
+// beginning of sol/protected_function.hpp
+
+// beginning of sol/protected_handler.hpp
+
+#include <cstdint>
+
+namespace sol { namespace detail {
+	inline const char (&default_handler_name())[9] {
+		static const char name[9] = "sol.\xF0\x9F\x94\xA9";
+		return name;
+	}
+
+	template <bool ShouldPush, typename Target = reference>
+	struct protected_handler {
+		lua_State* m_L;
+		const Target& target;
+		int stack_index;
+
+		protected_handler(std::false_type, lua_State* L_, const Target& target_) : m_L(L_), target(target_), stack_index(0) {
+			if (ShouldPush) {
+				stack_index = lua_gettop(L_) + 1;
+				target.push(L_);
+			}
+		}
+
+		protected_handler(std::true_type, lua_State* L_, const Target& target_) : m_L(L_), target(target_), stack_index(0) {
+			if (ShouldPush) {
+				stack_index = target.stack_index();
+			}
+		}
+
+		protected_handler(lua_State* L_, const Target& target_) : protected_handler(meta::boolean<is_stack_based_v<Target>>(), L_, target_) {
+		}
+
+		bool valid() const noexcept {
+			return ShouldPush;
+		}
+
+		~protected_handler() {
+			if constexpr (!is_stack_based_v<Target>) {
+				if (stack_index != 0) {
+					lua_remove(m_L, stack_index);
+				}
+			}
+		}
+	};
+
+	template <typename Base, typename T>
+	inline basic_function<Base> force_cast(T& p) {
+		return p;
+	}
+
+	template <typename Reference, bool IsMainReference = false>
+	inline Reference get_default_handler(lua_State* L_) {
+		if (is_stack_based_v<Reference> || L_ == nullptr)
+			return Reference(L_, lua_nil);
+		L_ = IsMainReference ? main_thread(L_, L_) : L_;
+		lua_getglobal(L_, default_handler_name());
+		auto pp = stack::pop_n(L_, 1);
+		return Reference(L_, -1);
+	}
+
+	template <typename T>
+	inline void set_default_handler(lua_State* L, const T& ref) {
+		if (L == nullptr) {
+			return;
+		}
+		if (!ref.valid()) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushnil(L);
+			lua_setglobal(L, default_handler_name());
+		}
+		else {
+			ref.push(L);
+			lua_setglobal(L, default_handler_name());
+		}
+	}
+}} // namespace sol::detail
+
+// end of sol/protected_handler.hpp
+
+#include <cstdint>
+#include <algorithm>
+
+namespace sol {
+
+	namespace detail {
+		template <bool ShouldPush_, typename Handler_>
+		inline void handle_protected_exception(
+		     lua_State* L_, optional<const std::exception&> maybe_ex, const char* error, detail::protected_handler<ShouldPush_, Handler_>& handler_) {
+			handler_.stack_index = 0;
+			if (ShouldPush_) {
+				handler_.target.push(L_);
+				detail::call_exception_handler(L_, maybe_ex, error);
+				lua_call(L_, 1, 1);
+			}
+			else {
+				detail::call_exception_handler(L_, maybe_ex, error);
+			}
+		}
+	} // namespace detail
+
+	template <typename Reference, bool Aligned = false, typename Handler = reference>
+	class basic_protected_function : public basic_object<Reference> {
+	private:
+		using base_t = basic_object<Reference>;
+		using handler_t = Handler;
+		inline static constexpr bool is_stack_handler_v = is_stack_based_v<handler_t>;
+
+		basic_protected_function(std::true_type, const basic_protected_function& other_) noexcept
+		: base_t(other_), m_error_handler(other_.m_error_handler.copy(lua_state())) {
+		}
+
+		basic_protected_function(std::false_type, const basic_protected_function& other_) noexcept : base_t(other_), m_error_handler(other_.m_error_handler) {
+		}
+
+	public:
+		basic_protected_function() = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_protected_function>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<T>>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_protected_function(T&& r) noexcept : base_t(std::forward<T>(r)), m_error_handler(get_default_handler(r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_function<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_protected_function>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_protected_function(const basic_protected_function& other_) noexcept
+		: basic_protected_function(meta::boolean<is_stateless_lua_reference_v<Handler>>(), other_) {
+		}
+		basic_protected_function& operator=(const basic_protected_function& other_) {
+			base_t::operator=(other_);
+			if constexpr (is_stateless_lua_reference_v<Handler>) {
+				m_error_handler.copy_assign(lua_state(), other_.m_error_handler);
+			}
+			else {
+				m_error_handler = other_.m_error_handler;
+			}
+			return *this;
+		}
+		basic_protected_function(basic_protected_function&&) = default;
+		basic_protected_function& operator=(basic_protected_function&&) = default;
+		basic_protected_function(const basic_function<base_t>& b) : basic_protected_function(b, get_default_handler(b.lua_state())) {
+		}
+		basic_protected_function(basic_function<base_t>&& b) : basic_protected_function(std::move(b), get_default_handler(b.lua_state())) {
+		}
+		basic_protected_function(const basic_function<base_t>& b, handler_t eh) : base_t(b), m_error_handler(std::move(eh)) {
+		}
+		basic_protected_function(basic_function<base_t>&& b, handler_t eh) : base_t(std::move(b)), m_error_handler(std::move(eh)) {
+		}
+		basic_protected_function(const stack_reference& r) : basic_protected_function(r.lua_state(), r.stack_index(), get_default_handler(r.lua_state())) {
+		}
+		basic_protected_function(stack_reference&& r) : basic_protected_function(r.lua_state(), r.stack_index(), get_default_handler(r.lua_state())) {
+		}
+		basic_protected_function(const stack_reference& r, handler_t eh) : basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+		basic_protected_function(stack_reference&& r, handler_t eh) : basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+
+		template <typename Super>
+		basic_protected_function(const proxy_base<Super>& p) : basic_protected_function(p, get_default_handler(p.lua_state())) {
+		}
+		template <typename Super>
+		basic_protected_function(proxy_base<Super>&& p) : basic_protected_function(std::move(p), get_default_handler(p.lua_state())) {
+		}
+		template <typename Proxy, typename HandlerReference,
+		     meta::enable<std::is_base_of<proxy_base_tag, meta::unqualified_t<Proxy>>,
+		          meta::neg<is_lua_index<meta::unqualified_t<HandlerReference>>>> = meta::enabler>
+		basic_protected_function(Proxy&& p, HandlerReference&& eh)
+		: basic_protected_function(detail::force_cast<base_t>(p), make_reference<handler_t>(p.lua_state(), std::forward<HandlerReference>(eh))) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_protected_function(lua_State* L_, T&& r) : basic_protected_function(L_, std::forward<T>(r), get_default_handler(L_)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_protected_function(lua_State* L_, T&& r, handler_t eh) : base_t(L_, std::forward<T>(r)), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		basic_protected_function(lua_nil_t n) : base_t(n), m_error_handler(n) {
+		}
+
+		basic_protected_function(lua_State* L_, int index_ = -1) : basic_protected_function(L_, index_, get_default_handler(L_)) {
+		}
+		basic_protected_function(lua_State* L_, int index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(L_, index_, handler);
+#endif // Safety
+		}
+		basic_protected_function(lua_State* L_, absolute_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) {
+		}
+		basic_protected_function(lua_State* L_, absolute_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(L_, index_, handler);
+#endif // Safety
+		}
+		basic_protected_function(lua_State* L_, raw_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) {
+		}
+		basic_protected_function(lua_State* L_, raw_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(L_, index_, handler);
+#endif // Safety
+		}
+		basic_protected_function(lua_State* L_, ref_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) {
+		}
+		basic_protected_function(lua_State* L_, ref_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		using base_t::lua_state;
+
+		template <typename Fx>
+		int dump(lua_Writer writer, void* userdata_pointer_, bool strip, Fx&& on_error) const {
+			this->push();
+			auto ppn = stack::push_popper_n<false>(this->lua_state(), 1);
+			int r = lua_dump(this->lua_state(), writer, userdata_pointer_, strip ? 1 : 0);
+			if (r != 0) {
+				return on_error(this->lua_state(), r, writer, userdata_pointer_, strip);
+			}
+			return r;
+		}
+
+		int dump(lua_Writer writer, void* userdata_pointer_, bool strip = false) const {
+			return dump(writer, userdata_pointer_, strip, &dump_pass_on_error);
+		}
+
+		template <typename Container = bytecode>
+		Container dump() const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, &dump_throw_on_error);
+			return bc;
+		}
+
+		template <typename Container = bytecode, typename Fx>
+		Container dump(Fx&& on_error) const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, std::forward<Fx>(on_error));
+			return bc;
+		}
+
+		template <typename... Args>
+		protected_function_result operator()(Args&&... args) const {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) operator()(types<Ret...>, Args&&... args) const {
+			return call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) const {
+			if constexpr (!Aligned) {
+				// we do not expect the function to already be on the stack: push it
+				if (m_error_handler.valid(lua_state())) {
+					detail::protected_handler<true, handler_t> h(lua_state(), m_error_handler);
+					base_t::push();
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+				else {
+					detail::protected_handler<false, handler_t> h(lua_state(), m_error_handler);
+					base_t::push();
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+			}
+			else {
+				// the function is already on the stack at the right location
+				if (m_error_handler.valid()) {
+					// the handler will be pushed onto the stack manually,
+					// since it's not already on the stack this means we need to push our own
+					// function on the stack too and swap things to be in-place
+					if constexpr (!is_stack_handler_v) {
+						// so, we need to remove the function at the top and then dump the handler out ourselves
+						base_t::push();
+					}
+					detail::protected_handler<true, handler_t> h(lua_state(), m_error_handler);
+					if constexpr (!is_stack_handler_v) {
+						lua_replace(lua_state(), -3);
+						h.stack_index = lua_absindex(lua_state(), -2);
+					}
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+				else {
+					detail::protected_handler<false, handler_t> h(lua_state(), m_error_handler);
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+			}
+		}
+
+		~basic_protected_function() {
+			if constexpr (is_stateless_lua_reference_v<handler_t>) {
+				this->m_error_handler.reset(lua_state());
+			}
+		}
+
+		static handler_t get_default_handler(lua_State* L_) {
+			return detail::get_default_handler<handler_t, is_main_threaded_v<base_t>>(L_);
+		}
+
+		template <typename T>
+		static void set_default_handler(const T& ref) {
+			detail::set_default_handler(ref.lua_state(), ref);
+		}
+
+		auto get_error_handler() const noexcept {
+			if constexpr (is_stateless_lua_reference_v<handler_t>) {
+				if constexpr (is_stack_based_v<handler_t>) {
+					return stack_reference(lua_state(), m_error_handler.stack_index());
+				}
+				else {
+					return basic_reference<is_main_threaded_v<base_t>>(lua_state(), ref_index(m_error_handler.registry_index()));
+				}
+			}
+			else {
+				return m_error_handler;
+			}
+		}
+
+		template <typename ErrorHandler_>
+		void set_error_handler(ErrorHandler_&& error_handler_) noexcept {
+			static_assert(!is_stack_based_v<handler_t> || is_stack_based_v<ErrorHandler_>,
+			     "A stack-based error handler can only be set from a parameter that is also stack-based.");
+			if constexpr (std::is_rvalue_reference_v<ErrorHandler_>) {
+				m_error_handler = std::forward<ErrorHandler_>(error_handler_);
+			}
+			else {
+				m_error_handler.copy_assign(lua_state(), std::forward<ErrorHandler_>(error_handler_));
+			}
+		}
+
+		void abandon () noexcept {
+			this->m_error_handler.abandon();
+			base_t::abandon();
+		}
+
+	private:
+		handler_t m_error_handler;
+
+		template <bool b>
+		call_status luacall(std::ptrdiff_t argcount, std::ptrdiff_t result_count_, detail::protected_handler<b, handler_t>& h) const {
+			return static_cast<call_status>(lua_pcall(lua_state(), static_cast<int>(argcount), static_cast<int>(result_count_), h.stack_index));
+		}
+
+		template <std::size_t... I, bool b, typename... Ret>
+		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			luacall(n, sizeof...(Ret), h);
+			return stack::pop<std::tuple<Ret...>>(lua_state());
+		}
+
+		template <std::size_t I, bool b, typename Ret>
+		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			luacall(n, 1, h);
+			return stack::pop<Ret>(lua_state());
+		}
+
+		template <std::size_t I, bool b>
+		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			luacall(n, 0, h);
+		}
+
+		template <bool b>
+		protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			int stacksize = lua_gettop(lua_state());
+			int poststacksize = stacksize;
+			int firstreturn = 1;
+			int returncount = 0;
+			call_status code = call_status::ok;
+#if SOL_IS_ON(SOL_EXCEPTIONS) && SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS)
+			try {
+#endif // No Exceptions
+				firstreturn = (std::max)(1, static_cast<int>(stacksize - n - static_cast<int>(h.valid() && !is_stack_handler_v)));
+				code = luacall(n, LUA_MULTRET, h);
+				poststacksize = lua_gettop(lua_state()) - static_cast<int>(h.valid() && !is_stack_handler_v);
+				returncount = poststacksize - (firstreturn - 1);
+#if SOL_IS_ON(SOL_EXCEPTIONS) && SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS)
+			}
+			// Handle C++ errors thrown from C++ functions bound inside of lua
+			catch (const char* error) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), error, h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+			catch (const std::string& error) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), error.c_str(), h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+			catch (const std::exception& error) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(error), error.what(), h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+#if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL)
+			// LuaJIT cannot have the catchall when the safe propagation is on
+			// but LuaJIT will swallow all C++ errors
+			// if we don't at least catch std::exception ones
+			catch (...) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), detail::protected_function_error, h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+#endif // Always catch edge case
+#else
+			// do not handle exceptions: they can be propogated into C++ and keep all type information / rich information
+#endif // Exceptions vs. No Exceptions
+			return protected_function_result(lua_state(), firstreturn, returncount, returncount, code);
+		}
+	};
+} // namespace sol
+
+// end of sol/protected_function.hpp
+
+#include <functional>
+
+namespace sol {
+	template <typename... Ret, typename... Args>
+	decltype(auto) stack_proxy::call(Args&&... args) {
+		stack_function sf(this->lua_state(), this->stack_index());
+		return sf.template call<Ret...>(std::forward<Args>(args)...);
+	}
+
+	inline protected_function_result::protected_function_result(unsafe_function_result&& o) noexcept
+	: L(o.lua_state()), index(o.stack_index()), returncount(o.return_count()), popcount(o.return_count()), err(o.status()) {
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+	}
+
+	inline protected_function_result& protected_function_result::operator=(unsafe_function_result&& o) noexcept {
+		L = o.lua_state();
+		index = o.stack_index();
+		returncount = o.return_count();
+		popcount = o.return_count();
+		err = o.status();
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+		return *this;
+	}
+
+	inline unsafe_function_result::unsafe_function_result(protected_function_result&& o) noexcept
+	: L(o.lua_state()), index(o.stack_index()), returncount(o.return_count()) {
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+	}
+	inline unsafe_function_result& unsafe_function_result::operator=(protected_function_result&& o) noexcept {
+		L = o.lua_state();
+		index = o.stack_index();
+		returncount = o.return_count();
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+		return *this;
+	}
+
+	namespace detail {
+		template <typename... R>
+		struct std_shim {
+			unsafe_function lua_func_;
+
+			std_shim(unsafe_function lua_func) : lua_func_(std::move(lua_func)) {
+			}
+
+			template <typename... Args>
+			meta::return_type_t<R...> operator()(Args&&... args) {
+				return lua_func_.call<R...>(std::forward<Args>(args)...);
+			}
+		};
+
+		template <>
+		struct std_shim<void> {
+			unsafe_function lua_func_;
+
+			std_shim(unsafe_function lua_func) : lua_func_(std::move(lua_func)) {
+			}
+
+			template <typename... Args>
+			void operator()(Args&&... args) {
+				lua_func_.call<void>(std::forward<Args>(args)...);
+			}
+		};
+	} // namespace detail
+
+	namespace stack {
+		template <typename Signature>
+		struct unqualified_getter<std::function<Signature>> {
+			typedef meta::bind_traits<Signature> fx_t;
+			typedef typename fx_t::args_list args_lists;
+			typedef meta::tuple_types<typename fx_t::return_type> return_types;
+
+			template <typename... R>
+			static std::function<Signature> get_std_func(types<R...>, lua_State* L, int index) {
+				detail::std_shim<R...> fx(unsafe_function(L, index));
+				return fx;
+			}
+
+			static std::function<Signature> get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				type t = type_of(L, index);
+				if (t == type::none || t == type::lua_nil) {
+					return nullptr;
+				}
+				return get_std_func(return_types(), L, index);
+			}
+		};
+
+		template <typename Allocator>
+		struct unqualified_getter<basic_bytecode<Allocator>> {
+			static basic_bytecode<Allocator> get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				stack_function sf(L, index);
+				return sf.dump(&dump_panic_on_error);
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/function.hpp
+
+// beginning of sol/usertype.hpp
+
+// beginning of sol/usertype_core.hpp
+
+// beginning of sol/deprecate.hpp
+
+#ifndef SOL_DEPRECATED
+#ifdef _MSC_VER
+#define SOL_DEPRECATED __declspec(deprecated)
+#elif __GNUC__
+#define SOL_DEPRECATED __attribute__((deprecated))
+#else
+#define SOL_DEPRECATED [[deprecated]]
+#endif // compilers
+#endif // SOL_DEPRECATED
+
+namespace sol { namespace detail {
+	template <typename T>
+	struct SOL_DEPRECATED deprecate_type {
+		using type = T;
+	};
+}} // namespace sol::detail
+
+// end of sol/deprecate.hpp
+
+// beginning of sol/usertype_container_launch.hpp
+
+// beginning of sol/usertype_container.hpp
+
+namespace sol {
+
+	template <typename T>
+	struct usertype_container;
+
+	namespace container_detail {
+
+		template <typename T>
+		struct has_clear_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::clear));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_empty_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::empty));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_erase_after_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(
+			     decltype(std::declval<C>().erase_after(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T, typename = void>
+		struct has_find_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().find(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_find_test<T, std::enable_if_t<meta::is_lookup<T>::value>> {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().find(std::declval<std::add_rvalue_reference_t<typename C::key_type>>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_erase_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().erase(std::declval<typename C::iterator>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_erase_key_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().erase(std::declval<typename C::key_type>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_find_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::find));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_index_of_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::index_of));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_insert_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::insert));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_erase_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::erase));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_index_set_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::index_set));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_index_get_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::index_get));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_set_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::set));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_get_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::get));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_at_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::at));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_pairs_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::pairs));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_ipairs_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::ipairs));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_next_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::next));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_add_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::add));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_size_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::size));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		using has_clear = meta::boolean<has_clear_test<T>::value>;
+
+		template <typename T>
+		using has_empty = meta::boolean<has_empty_test<T>::value>;
+
+		template <typename T>
+		using has_find = meta::boolean<has_find_test<T>::value>;
+
+		template <typename T>
+		using has_erase = meta::boolean<has_erase_test<T>::value>;
+
+		template <typename T>
+		using has_erase_key = meta::boolean<has_erase_key_test<T>::value>;
+
+		template <typename T>
+		using has_erase_after = meta::boolean<has_erase_after_test<T>::value>;
+
+		template <typename T>
+		using has_traits_get = meta::boolean<has_traits_get_test<T>::value>;
+
+		template <typename T>
+		using has_traits_at = meta::boolean<has_traits_at_test<T>::value>;
+
+		template <typename T>
+		using has_traits_set = meta::boolean<has_traits_set_test<T>::value>;
+
+		template <typename T>
+		using has_traits_index_get = meta::boolean<has_traits_index_get_test<T>::value>;
+
+		template <typename T>
+		using has_traits_index_set = meta::boolean<has_traits_index_set_test<T>::value>;
+
+		template <typename T>
+		using has_traits_pairs = meta::boolean<has_traits_pairs_test<T>::value>;
+
+		template <typename T>
+		using has_traits_ipairs = meta::boolean<has_traits_ipairs_test<T>::value>;
+
+		template <typename T>
+		using has_traits_next = meta::boolean<has_traits_next_test<T>::value>;
+
+		template <typename T>
+		using has_traits_add = meta::boolean<has_traits_add_test<T>::value>;
+
+		template <typename T>
+		using has_traits_size = meta::boolean<has_traits_size_test<T>::value>;
+
+		template <typename T>
+		using has_traits_clear = has_clear<T>;
+
+		template <typename T>
+		using has_traits_empty = has_empty<T>;
+
+		template <typename T>
+		using has_traits_find = meta::boolean<has_traits_find_test<T>::value>;
+
+		template <typename T>
+		using has_traits_index_of = meta::boolean<has_traits_index_of_test<T>::value>;
+
+		template <typename T>
+		using has_traits_insert = meta::boolean<has_traits_insert_test<T>::value>;
+
+		template <typename T>
+		using has_traits_erase = meta::boolean<has_traits_erase_test<T>::value>;
+
+		template <typename T>
+		struct is_forced_container : is_container<T> { };
+
+		template <typename T>
+		struct is_forced_container<as_container_t<T>> : std::true_type { };
+
+		template <typename T>
+		struct container_decay {
+			typedef T type;
+		};
+
+		template <typename T>
+		struct container_decay<as_container_t<T>> {
+			typedef T type;
+		};
+
+		template <typename T>
+		using container_decay_t = typename container_decay<meta::unqualified_t<T>>::type;
+
+		template <typename T>
+		decltype(auto) get_key(std::false_type, T&& t) {
+			return std::forward<T>(t);
+		}
+
+		template <typename T>
+		decltype(auto) get_key(std::true_type, T&& t) {
+			return t.first;
+		}
+
+		template <typename T>
+		decltype(auto) get_value(std::false_type, T&& t) {
+			return std::forward<T>(t);
+		}
+
+		template <typename T>
+		decltype(auto) get_value(std::true_type, T&& t) {
+			return t.second;
+		}
+
+		template <typename X, typename = void>
+		struct usertype_container_default {
+		private:
+			typedef std::remove_pointer_t<meta::unwrap_unqualified_t<X>> T;
+
+		public:
+			typedef lua_nil_t iterator;
+			typedef lua_nil_t value_type;
+
+			static int at(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'at(index)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int get(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'get(key)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int index_get(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'container[key]' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int set(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'set(key, value)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int index_set(lua_State* L_) {
+				return luaL_error(
+				     L_, "sol: cannot call 'container[key] = value' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int add(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'add' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int insert(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'insert' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int find(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'find' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int index_of(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'index_of' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int size(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'end' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int clear(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'clear' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int empty(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'empty' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int erase(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'erase' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int next(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'next' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int pairs(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call '__pairs/pairs' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int ipairs(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call '__ipairs' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static iterator begin(lua_State* L_, T&) {
+				luaL_error(L_, "sol: cannot call 'being' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+				return lua_nil;
+			}
+
+			static iterator end(lua_State* L_, T&) {
+				luaL_error(L_, "sol: cannot call 'end' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+				return lua_nil;
+			}
+		};
+
+		template <typename X>
+		struct usertype_container_default<X,
+		     std::enable_if_t<meta::all<is_forced_container<meta::unqualified_t<X>>, meta::has_value_type<meta::unqualified_t<container_decay_t<X>>>,
+		          meta::has_iterator<meta::unqualified_t<container_decay_t<X>>>>::value>> {
+		private:
+			using T = std::remove_pointer_t<meta::unwrap_unqualified_t<container_decay_t<X>>>;
+
+		private:
+			using deferred_uc = usertype_container<X>;
+			using is_associative = meta::is_associative<T>;
+			using is_lookup = meta::is_lookup<T>;
+			using is_ordered = meta::is_ordered<T>;
+			using is_matched_lookup = meta::is_matched_lookup<T>;
+			using iterator = typename T::iterator;
+			using value_type = typename T::value_type;
+			typedef meta::conditional_t<is_matched_lookup::value, std::pair<value_type, value_type>,
+			     meta::conditional_t<is_associative::value || is_lookup::value, value_type, std::pair<std::ptrdiff_t, value_type>>>
+			     KV;
+			typedef typename KV::first_type K;
+			typedef typename KV::second_type V;
+			typedef meta::conditional_t<is_matched_lookup::value, std::ptrdiff_t, K> next_K;
+			typedef decltype(*std::declval<iterator&>()) iterator_return;
+			typedef meta::conditional_t<is_associative::value || is_matched_lookup::value, std::add_lvalue_reference_t<V>,
+			     meta::conditional_t<is_lookup::value, V, iterator_return>>
+			     captured_type;
+			typedef typename meta::iterator_tag<iterator>::type iterator_category;
+			typedef std::is_same<iterator_category, std::input_iterator_tag> is_input_iterator;
+			typedef meta::conditional_t<is_input_iterator::value, V, decltype(detail::deref_move_only(std::declval<captured_type>()))> push_type;
+			typedef std::is_copy_assignable<V> is_copyable;
+			typedef meta::neg<meta::any<std::is_const<V>, std::is_const<std::remove_reference_t<iterator_return>>, meta::neg<is_copyable>>> is_writable;
+			typedef meta::unqualified_t<decltype(get_key(is_associative(), std::declval<std::add_lvalue_reference_t<value_type>>()))> key_type;
+			typedef meta::all<std::is_integral<K>, meta::neg<meta::any<is_associative, is_lookup>>> is_linear_integral;
+
+			struct iter {
+				reference keep_alive;
+				T& source;
+				iterator it;
+				std::size_t index;
+
+				iter(lua_State* L_, int stack_index, T& source_, iterator it_) : keep_alive(sol::main_thread(L_, L_), stack_index), source(source_), it(std::move(it_)), index(0) {
+				}
+
+				~iter() {
+				}
+			};
+
+			static auto& get_src(lua_State* L_) {
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+				auto p = stack::unqualified_check_get<T*>(L_, 1);
+				if (!p) {
+					luaL_error(L_,
+					     "sol: 'self' is not of type '%s' (pass 'self' as first argument with ':' or call on proper type)",
+					     detail::demangle<T>().c_str());
+				}
+				if (p.value() == nullptr) {
+					luaL_error(
+					     L_, "sol: 'self' argument is nil (pass 'self' as first argument with ':' or call on a '%s' type)", detail::demangle<T>().c_str());
+				}
+				return *p.value();
+#else
+				return stack::unqualified_get<T>(L_, 1);
+#endif // Safe getting with error
+			}
+
+			static detail::error_result at_category(std::input_iterator_tag, lua_State* L_, T& self, std::ptrdiff_t pos) {
+				pos += deferred_uc::index_adjustment(L_, self);
+				if (pos < 0) {
+					return stack::push(L_, lua_nil);
+				}
+				auto it = deferred_uc::begin(L_, self);
+				auto e = deferred_uc::end(L_, self);
+				if (it == e) {
+					return stack::push(L_, lua_nil);
+				}
+				while (pos > 0) {
+					--pos;
+					++it;
+					if (it == e) {
+						return stack::push(L_, lua_nil);
+					}
+				}
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result at_category(std::random_access_iterator_tag, lua_State* L_, T& self, std::ptrdiff_t pos) {
+				std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L_, self));
+				pos += deferred_uc::index_adjustment(L_, self);
+				if (pos < 0 || pos >= len) {
+					return stack::push(L_, lua_nil);
+				}
+				auto it = std::next(deferred_uc::begin(L_, self), pos);
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result at_start(lua_State* L_, T& self, std::ptrdiff_t pos) {
+				return at_category(iterator_category(), L_, self, pos);
+			}
+
+			template <typename Iter>
+			static detail::error_result get_associative(std::true_type, lua_State* L_, Iter& it) {
+				decltype(auto) v = *it;
+				return stack::stack_detail::push_reference<push_type>(L_, detail::deref_move_only(v.second));
+			}
+
+			template <typename Iter>
+			static detail::error_result get_associative(std::false_type, lua_State* L_, Iter& it) {
+				return stack::stack_detail::push_reference<push_type>(L_, detail::deref_move_only(*it));
+			}
+
+			static detail::error_result get_category(std::input_iterator_tag, lua_State* L_, T& self, K& key) {
+				key = static_cast<K>(key + deferred_uc::index_adjustment(L_, self));
+				if (key < 0) {
+					return stack::push(L_, lua_nil);
+				}
+				auto it = deferred_uc::begin(L_, self);
+				auto e = deferred_uc::end(L_, self);
+				if (it == e) {
+					return stack::push(L_, lua_nil);
+				}
+				while (key > 0) {
+					--key;
+					++it;
+					if (it == e) {
+						return stack::push(L_, lua_nil);
+					}
+				}
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result get_category(std::random_access_iterator_tag, lua_State* L_, T& self, K& key) {
+				std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L_, self));
+				key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				if (key < 0 || key >= len) {
+					return stack::push(L_, lua_nil);
+				}
+				auto it = std::next(deferred_uc::begin(L_, self), key);
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result get_it(std::true_type, lua_State* L_, T& self, K& key) {
+				return get_category(iterator_category(), L_, self, key);
+			}
+
+			static detail::error_result get_comparative(std::true_type, lua_State* L_, T& self, K& key) {
+				auto fx = [&](const value_type& r) -> bool { return key == get_key(is_associative(), r); };
+				auto e = deferred_uc::end(L_, self);
+				auto it = std::find_if(deferred_uc::begin(L_, self), e, std::ref(fx));
+				if (it == e) {
+					return stack::push(L_, lua_nil);
+				}
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result get_comparative(std::false_type, lua_State*, T&, K&) {
+				return detail::error_result("cannot get this key on '%s': no suitable way to increment iterator and compare to key value '%s'",
+				     detail::demangle<T>().data(),
+				     detail::demangle<K>().data());
+			}
+
+			static detail::error_result get_it(std::false_type, lua_State* L_, T& self, K& key) {
+				return get_comparative(meta::supports_op_equal<K, key_type>(), L_, self, key);
+			}
+
+			static detail::error_result set_associative(std::true_type, iterator& it, stack_object value) {
+				decltype(auto) v = *it;
+				v.second = value.as<V>();
+				return {};
+			}
+
+			static detail::error_result set_associative(std::false_type, iterator& it, stack_object value) {
+				decltype(auto) v = *it;
+				v = value.as<V>();
+				return {};
+			}
+
+			static detail::error_result set_writable(std::true_type, lua_State*, T&, iterator& it, stack_object value) {
+				return set_associative(is_associative(), it, std::move(value));
+			}
+
+			static detail::error_result set_writable(std::false_type, lua_State*, T&, iterator&, stack_object) {
+				return detail::error_result(
+				     "cannot perform a 'set': '%s's iterator reference is not writable (non-copy-assignable or const)", detail::demangle<T>().data());
+			}
+
+			static detail::error_result set_category(std::input_iterator_tag, lua_State* L_, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				auto e = deferred_uc::end(L_, self);
+				auto it = deferred_uc::begin(L_, self);
+				auto backit = it;
+				for (; key > 0 && it != e; --key, ++it) {
+					backit = it;
+				}
+				if (it == e) {
+					if (key == 0) {
+						return add_copyable(is_copyable(), L_, self, std::move(value), meta::has_insert_after<T>::value ? backit : it);
+					}
+					return detail::error_result("out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				return set_writable(is_writable(), L_, self, it, std::move(value));
+			}
+
+			static detail::error_result set_category(std::random_access_iterator_tag, lua_State* L_, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				if (key < 0) {
+					return detail::error_result("sol: out of bounds (too small) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L_, self));
+				if (key == len) {
+					return add_copyable(is_copyable(), L_, self, std::move(value));
+				}
+				else if (key >= len) {
+					return detail::error_result("sol: out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				auto it = std::next(deferred_uc::begin(L_, self), key);
+				return set_writable(is_writable(), L_, self, it, std::move(value));
+			}
+
+			static detail::error_result set_comparative(std::true_type, lua_State* L_, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				if (!is_writable::value) {
+					return detail::error_result(
+					     "cannot perform a 'set': '%s's iterator reference is not writable (non-copy-assignable or const)", detail::demangle<T>().data());
+				}
+				auto fx = [&](const value_type& r) -> bool { return key == get_key(is_associative(), r); };
+				auto e = deferred_uc::end(L_, self);
+				auto it = std::find_if(deferred_uc::begin(L_, self), e, std::ref(fx));
+				if (it == e) {
+					return {};
+				}
+				return set_writable(is_writable(), L_, self, it, std::move(value));
+			}
+
+			static detail::error_result set_comparative(std::false_type, lua_State*, T&, stack_object, stack_object) {
+				return detail::error_result("cannot set this value on '%s': no suitable way to increment iterator or compare to '%s' key",
+				     detail::demangle<T>().data(),
+				     detail::demangle<K>().data());
+			}
+
+			template <typename Iter>
+			static detail::error_result set_associative_insert(std::true_type, lua_State*, T& self, Iter& it, K& key, stack_object value) {
+				if constexpr (meta::has_insert_with_iterator<T>::value) {
+					self.insert(it, value_type(key, value.as<V>()));
+					return {};
+				}
+				else if constexpr (meta::has_insert<T>::value) {
+					self.insert(value_type(key, value.as<V>()));
+					return {};
+				}
+				else {
+					(void)self;
+					(void)it;
+					(void)key;
+					return detail::error_result(
+					     "cannot call 'set' on '%s': there is no 'insert' function on this associative type", detail::demangle<T>().c_str());
+				}
+			}
+
+			template <typename Iter>
+			static detail::error_result set_associative_insert(std::false_type, lua_State*, T& self, Iter& it, K& key, stack_object) {
+				if constexpr (meta::has_insert_with_iterator<T>::value) {
+					self.insert(it, key);
+					return {};
+				}
+				else if constexpr (meta::has_insert<T>::value) {
+					self.insert(key);
+					return {};
+				}
+				else {
+					(void)self;
+					(void)it;
+					(void)key;
+					return detail::error_result(
+					     "cannot call 'set' on '%s': there is no 'insert' function on this non-associative type", detail::demangle<T>().c_str());
+				}
+			}
+
+			static detail::error_result set_associative_find(std::true_type, lua_State* L_, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				auto it = self.find(key);
+				if (it == deferred_uc::end(L_, self)) {
+					return set_associative_insert(is_associative(), L_, self, it, key, std::move(value));
+				}
+				return set_writable(is_writable(), L_, self, it, std::move(value));
+			}
+
+			static detail::error_result set_associative_find(std::false_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return set_comparative(meta::supports_op_equal<K, key_type>(), L_, self, std::move(key), std::move(value));
+			}
+
+			static detail::error_result set_it(std::true_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return set_category(iterator_category(), L_, self, std::move(key), std::move(value));
+			}
+
+			static detail::error_result set_it(std::false_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return set_associative_find(meta::all<has_find<T>, meta::any<is_associative, is_lookup>>(), L_, self, std::move(key), std::move(value));
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has_associative_lookup(std::true_type, lua_State* L_, T& self) {
+				if constexpr (!is_ordered::value && idx_of) {
+					(void)L_;
+					(void)self;
+					return detail::error_result("cannot perform an 'index_of': '%s's is not an ordered container", detail::demangle<T>().data());
+				}
+				else {
+					decltype(auto) key = stack::unqualified_get<K>(L_, 2);
+					auto it = self.find(key);
+					if (it == deferred_uc::end(L_, self)) {
+						return stack::push(L_, lua_nil);
+					}
+					if constexpr (idx_of) {
+						auto dist = std::distance(deferred_uc::begin(L_, self), it);
+						dist -= deferred_uc::index_adjustment(L_, self);
+						return stack::push(L_, dist);
+					}
+					else {
+						return get_associative(is_associative(), L_, it);
+					}
+				}
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has_associative_lookup(std::false_type, lua_State* L_, T& self) {
+				if constexpr (!is_ordered::value && idx_of) {
+					(void)L_;
+					(void)self;
+					return detail::error_result("cannot perform an 'index_of': '%s's is not an ordered container", detail::demangle<T>().data());
+				}
+				else {
+					decltype(auto) value = stack::unqualified_get<V>(L_, 2);
+					auto it = self.find(value);
+					if (it == deferred_uc::end(L_, self)) {
+						return stack::push(L_, lua_nil);
+					}
+					if constexpr (idx_of) {
+						auto dist = std::distance(deferred_uc::begin(L_, self), it);
+						dist -= deferred_uc::index_adjustment(L_, self);
+						return stack::push(L_, dist);
+					}
+					else {
+						return get_associative(is_associative(), L_, it);
+					}
+				}
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has(std::true_type, lua_State* L_, T& self) {
+				return find_has_associative_lookup<idx_of>(meta::any<is_lookup, is_associative>(), L_, self);
+			}
+
+			template <typename Iter>
+			static detail::error_result find_associative_lookup(std::true_type, lua_State* L_, T&, Iter& it, std::size_t) {
+				return get_associative(is_associative(), L_, it);
+			}
+
+			template <typename Iter>
+			static detail::error_result find_associative_lookup(std::false_type, lua_State* L_, T& self, Iter&, std::size_t idx) {
+				idx = static_cast<std::size_t>(static_cast<std::ptrdiff_t>(idx) - deferred_uc::index_adjustment(L_, self));
+				return stack::push(L_, idx);
+			}
+
+			template <bool = false>
+			static detail::error_result find_comparative(std::false_type, lua_State*, T&) {
+				return detail::error_result("cannot call 'find' on '%s': there is no 'find' function and the value_type is not equality comparable",
+				     detail::demangle<T>().c_str());
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_comparative(std::true_type, lua_State* L_, T& self) {
+				decltype(auto) value = stack::unqualified_get<V>(L_, 2);
+				auto it = deferred_uc::begin(L_, self);
+				auto e = deferred_uc::end(L_, self);
+				std::size_t idx = 0;
+				for (;; ++it, ++idx) {
+					if (it == e) {
+						return stack::push(L_, lua_nil);
+					}
+					if (value == get_value(is_associative(), *it)) {
+						break;
+					}
+				}
+				return find_associative_lookup(meta::all<meta::boolean<!idx_of>, meta::any<is_lookup, is_associative>>(), L_, self, it, idx);
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has(std::false_type, lua_State* L_, T& self) {
+				return find_comparative<idx_of>(meta::supports_op_equal<V>(), L_, self);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert_after(std::false_type, lua_State* L_, T& self, stack_object value, Iter&) {
+				return add_insert_after(std::false_type(), L_, self, value);
+			}
+
+			static detail::error_result add_insert_after(std::false_type, lua_State*, T&, stack_object) {
+				return detail::error_result("cannot call 'add' on type '%s': no suitable insert/push_back C++ functions", detail::demangle<T>().data());
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert_after(std::true_type, lua_State*, T& self, stack_object value, Iter& pos) {
+				self.insert_after(pos, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result add_insert_after(std::true_type, lua_State* L_, T& self, stack_object value) {
+				auto backit = self.before_begin();
+				{
+					auto e = deferred_uc::end(L_, self);
+					for (auto it = deferred_uc::begin(L_, self); it != e; ++backit, ++it) { }
+				}
+				return add_insert_after(std::true_type(), L_, self, value, backit);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert(std::true_type, lua_State*, T& self, stack_object value, Iter& pos) {
+				self.insert(pos, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result add_insert(std::true_type, lua_State* L_, T& self, stack_object value) {
+				auto pos = deferred_uc::end(L_, self);
+				return add_insert(std::true_type(), L_, self, value, pos);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert(std::false_type, lua_State* L_, T& self, stack_object value, Iter& pos) {
+				return add_insert_after(meta::has_insert_after<T>(), L_, self, std::move(value), pos);
+			}
+
+			static detail::error_result add_insert(std::false_type, lua_State* L_, T& self, stack_object value) {
+				return add_insert_after(meta::has_insert_after<T>(), L_, self, std::move(value));
+			}
+
+			template <typename Iter>
+			static detail::error_result add_push_back(std::true_type, lua_State*, T& self, stack_object value, Iter&) {
+				self.push_back(value.as<V>());
+				return {};
+			}
+
+			static detail::error_result add_push_back(std::true_type, lua_State*, T& self, stack_object value) {
+				self.push_back(value.as<V>());
+				return {};
+			}
+
+			template <typename Iter>
+			static detail::error_result add_push_back(std::false_type, lua_State* L_, T& self, stack_object value, Iter& pos) {
+				return add_insert(
+				     std::integral_constant < bool, meta::has_insert<T>::value || meta::has_insert_with_iterator<T>::value > (), L_, self, value, pos);
+			}
+
+			static detail::error_result add_push_back(std::false_type, lua_State* L_, T& self, stack_object value) {
+				return add_insert(
+				     std::integral_constant < bool, meta::has_insert<T>::value || meta::has_insert_with_iterator<T>::value > (), L_, self, value);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_associative(std::true_type, lua_State* L_, T& self, stack_object key, Iter& pos) {
+				if constexpr (meta::has_insert_with_iterator<T>::value) {
+					self.insert(pos, value_type(key.as<K>(), stack::unqualified_get<V>(L_, 3)));
+					return {};
+				}
+				else if constexpr (meta::has_insert<T>::value) {
+					self.insert(value_type(key.as<K>(), stack::unqualified_get<V>(L_, 3)));
+					return {};
+				}
+				else {
+					(void)L_;
+					(void)self;
+					(void)key;
+					(void)pos;
+					return detail::error_result(
+					     "cannot call 'insert' on '%s': there is no 'insert' function on this associative type", detail::demangle<T>().c_str());
+				}
+			}
+
+			static detail::error_result add_associative(std::true_type, lua_State* L_, T& self, stack_object key) {
+				auto pos = deferred_uc::end(L_, self);
+				return add_associative(std::true_type(), L_, self, std::move(key), pos);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_associative(std::false_type, lua_State* L_, T& self, stack_object value, Iter& pos) {
+				return add_push_back(meta::has_push_back<T>(), L_, self, value, pos);
+			}
+
+			static detail::error_result add_associative(std::false_type, lua_State* L_, T& self, stack_object value) {
+				return add_push_back(meta::has_push_back<T>(), L_, self, value);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_copyable(std::true_type, lua_State* L_, T& self, stack_object value, Iter& pos) {
+				return add_associative(is_associative(), L_, self, std::move(value), pos);
+			}
+
+			static detail::error_result add_copyable(std::true_type, lua_State* L_, T& self, stack_object value) {
+				return add_associative(is_associative(), L_, self, value);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_copyable(std::false_type, lua_State* L_, T& self, stack_object value, Iter&) {
+				return add_copyable(std::false_type(), L_, self, std::move(value));
+			}
+
+			static detail::error_result add_copyable(std::false_type, lua_State*, T&, stack_object) {
+				return detail::error_result("cannot call 'add' on '%s': value_type is non-copyable", detail::demangle<T>().data());
+			}
+
+			static detail::error_result insert_lookup(std::true_type, lua_State* L_, T& self, stack_object, stack_object value) {
+				// TODO: should we warn or error about someone calling insert on an ordered / lookup container with no associativity?
+				return add_copyable(std::true_type(), L_, self, std::move(value));
+			}
+
+			static detail::error_result insert_lookup(std::false_type, lua_State* L_, T& self, stack_object where, stack_object value) {
+				auto it = deferred_uc::begin(L_, self);
+				auto key = where.as<K>();
+				key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				std::advance(it, key);
+				self.insert(it, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result insert_after_has(std::true_type, lua_State* L_, T& self, stack_object where, stack_object value) {
+				auto key = where.as<K>();
+				auto backit = self.before_begin();
+				{
+					key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+					auto e = deferred_uc::end(L_, self);
+					for (auto it = deferred_uc::begin(L_, self); key > 0; ++backit, ++it, --key) {
+						if (backit == e) {
+							return detail::error_result("sol: out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+						}
+					}
+				}
+				self.insert_after(backit, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result insert_after_has(std::false_type, lua_State*, T&, stack_object, stack_object) {
+				return detail::error_result(
+				     "cannot call 'insert' on '%s': no suitable or similar functionality detected on this container", detail::demangle<T>().data());
+			}
+
+			static detail::error_result insert_has(std::true_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return insert_lookup(meta::any<is_associative, is_lookup>(), L_, self, std::move(key), std::move(value));
+			}
+
+			static detail::error_result insert_has(std::false_type, lua_State* L_, T& self, stack_object where, stack_object value) {
+				return insert_after_has(meta::has_insert_after<T>(), L_, self, where, value);
+			}
+
+			static detail::error_result insert_copyable(std::true_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return insert_has(std::integral_constant < bool,
+				     meta::has_insert<T>::value || meta::has_insert_with_iterator<T>::value > (),
+				     L_,
+				     self,
+				     std::move(key),
+				     std::move(value));
+			}
+
+			static detail::error_result insert_copyable(std::false_type, lua_State*, T&, stack_object, stack_object) {
+				return detail::error_result("cannot call 'insert' on '%s': value_type is non-copyable", detail::demangle<T>().data());
+			}
+
+			static detail::error_result erase_integral(std::true_type, lua_State* L_, T& self, K& key) {
+				auto it = deferred_uc::begin(L_, self);
+				key = (static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				std::advance(it, key);
+				self.erase(it);
+
+				return {};
+			}
+
+			static detail::error_result erase_integral(std::false_type, lua_State* L_, T& self, const K& key) {
+				auto fx = [&](const value_type& r) -> bool { return key == r; };
+				auto e = deferred_uc::end(L_, self);
+				auto it = std::find_if(deferred_uc::begin(L_, self), e, std::ref(fx));
+				if (it == e) {
+					return {};
+				}
+				self.erase(it);
+
+				return {};
+			}
+
+			static detail::error_result erase_associative_lookup(std::true_type, lua_State*, T& self, const K& key) {
+				self.erase(key);
+				return {};
+			}
+
+			static detail::error_result erase_associative_lookup(std::false_type, lua_State* L_, T& self, K& key) {
+				return erase_integral(std::is_integral<K>(), L_, self, key);
+			}
+
+			static detail::error_result erase_after_has(std::true_type, lua_State* L_, T& self, K& key) {
+				auto backit = self.before_begin();
+				{
+					key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+					auto e = deferred_uc::end(L_, self);
+					for (auto it = deferred_uc::begin(L_, self); key > 0; ++backit, ++it, --key) {
+						if (backit == e) {
+							return detail::error_result("sol: out of bounds for erase on '%s'", detail::demangle<T>().c_str());
+						}
+					}
+				}
+				self.erase_after(backit);
+				return {};
+			}
+
+			static detail::error_result erase_after_has(std::false_type, lua_State*, T&, const K&) {
+				return detail::error_result("sol: cannot call erase on '%s'", detail::demangle<T>().c_str());
+			}
+
+			static detail::error_result erase_key_has(std::true_type, lua_State* L_, T& self, K& key) {
+				return erase_associative_lookup(meta::any<is_associative, is_lookup>(), L_, self, key);
+			}
+
+			static detail::error_result erase_key_has(std::false_type, lua_State* L_, T& self, K& key) {
+				return erase_after_has(has_erase_after<T>(), L_, self, key);
+			}
+
+			static detail::error_result erase_has(std::true_type, lua_State* L_, T& self, K& key) {
+				return erase_associative_lookup(meta::any<is_associative, is_lookup>(), L_, self, key);
+			}
+
+			static detail::error_result erase_has(std::false_type, lua_State* L_, T& self, K& key) {
+				return erase_key_has(has_erase_key<T>(), L_, self, key);
+			}
+
+			static auto size_has(std::false_type, lua_State* L_, T& self) {
+				return std::distance(deferred_uc::begin(L_, self), deferred_uc::end(L_, self));
+			}
+
+			static auto size_has(std::true_type, lua_State*, T& self) {
+				return self.size();
+			}
+
+			static void clear_has(std::true_type, lua_State*, T& self) {
+				self.clear();
+			}
+
+			static void clear_has(std::false_type, lua_State* L_, T&) {
+				luaL_error(L_, "sol: cannot call clear on '%s'", detail::demangle<T>().c_str());
+			}
+
+			static bool empty_has(std::true_type, lua_State*, T& self) {
+				return self.empty();
+			}
+
+			static bool empty_has(std::false_type, lua_State* L_, T& self) {
+				return deferred_uc::begin(L_, self) == deferred_uc::end(L_, self);
+			}
+
+			static detail::error_result get_associative_find(std::true_type, lua_State* L_, T& self, K& key) {
+				auto it = self.find(key);
+				if (it == deferred_uc::end(L_, self)) {
+					stack::push(L_, lua_nil);
+					return {};
+				}
+				return get_associative(std::true_type(), L_, it);
+			}
+
+			static detail::error_result get_associative_find(std::false_type, lua_State* L_, T& self, K& key) {
+				return get_it(is_linear_integral(), L_, self, key);
+			}
+
+			static detail::error_result get_start(lua_State* L_, T& self, K& key) {
+				return get_associative_find(std::integral_constant < bool, is_associative::value&& has_find<T>::value > (), L_, self, key);
+			}
+
+			static detail::error_result set_start(lua_State* L_, T& self, stack_object key, stack_object value) {
+				return set_it(is_linear_integral(), L_, self, std::move(key), std::move(value));
+			}
+
+			static std::size_t size_start(lua_State* L_, T& self) {
+				return static_cast<std::size_t>(size_has(meta::has_size<T>(), L_, self));
+			}
+
+			static void clear_start(lua_State* L_, T& self) {
+				clear_has(has_clear<T>(), L_, self);
+			}
+
+			static bool empty_start(lua_State* L_, T& self) {
+				return empty_has(has_empty<T>(), L_, self);
+			}
+
+			static detail::error_result erase_start(lua_State* L_, T& self, K& key) {
+				return erase_has(has_erase<T>(), L_, self, key);
+			}
+
+			template <bool ip>
+			static int next_associative(std::true_type, lua_State* L_) {
+				iter& i = stack::unqualified_get<user<iter>>(L_, 1);
+				auto& source = i.source;
+				auto& it = i.it;
+				if (it == deferred_uc::end(L_, source)) {
+					return stack::push(L_, lua_nil);
+				}
+				int p;
+				if constexpr (ip) {
+					++i.index;
+					p = stack::push_reference(L_, i.index);
+				}
+				else {
+					p = stack::push_reference(L_, it->first);
+				}
+				p += stack::stack_detail::push_reference<push_type>(L_, detail::deref_move_only(it->second));
+				std::advance(it, 1);
+				return p;
+			}
+
+			template <bool>
+			static int next_associative(std::false_type, lua_State* L_) {
+				iter& i = stack::unqualified_get<user<iter>>(L_, 1);
+				auto& source = i.source;
+				auto& it = i.it;
+				next_K k = stack::unqualified_get<next_K>(L_, 2);
+				if (it == deferred_uc::end(L_, source)) {
+					return stack::push(L_, lua_nil);
+				}
+				int p;
+				if constexpr (std::is_integral_v<next_K>) {
+					p = stack::push_reference(L_, k + 1);
+				}
+				else {
+					p = stack::stack_detail::push_reference(L_, k + 1);
+				}
+				p += stack::stack_detail::push_reference<push_type>(L_, detail::deref_move_only(*it));
+				std::advance(it, 1);
+				return p;
+			}
+
+			template <bool ip>
+			static int next_iter(lua_State* L_) {
+				typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+				return next_associative<ip>(is_assoc(), L_);
+			}
+
+			template <bool ip>
+			static int pairs_associative(std::true_type, lua_State* L_) {
+				auto& src = get_src(L_);
+				stack::push(L_, next_iter<ip>);
+				stack::push<user<iter>>(L_, L_, 1, src, deferred_uc::begin(L_, src));
+				stack::push(L_, lua_nil);
+				return 3;
+			}
+
+			template <bool ip>
+			static int pairs_associative(std::false_type, lua_State* L_) {
+				auto& src = get_src(L_);
+				stack::push(L_, next_iter<ip>);
+				stack::push<user<iter>>(L_, L_, 1, src, deferred_uc::begin(L_, src));
+				stack::push(L_, 0);
+				return 3;
+			}
+
+		public:
+			static int at(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er;
+				{
+					std::ptrdiff_t pos = stack::unqualified_get<std::ptrdiff_t>(L_, 2);
+					er = at_start(L_, self, pos);
+				}
+				return handle_errors(L_, er);
+			}
+
+			static int get(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er;
+				{
+					decltype(auto) key = stack::unqualified_get<K>(L_);
+					er = get_start(L_, self, key);
+				}
+				return handle_errors(L_, er);
+			}
+
+			static int index_get(lua_State* L_) {
+				return get(L_);
+			}
+
+			static int set(lua_State* L_) {
+				stack_object value = stack_object(L_, raw_index(3));
+				if constexpr (is_linear_integral::value) {
+					// for non-associative containers,
+					// erasure only happens if it is the
+					// last index in the container
+					auto key = stack::get<K>(L_, 2);
+					auto self_size = deferred_uc::size(L_);
+					if (key == static_cast<K>(self_size)) {
+						if (type_of(L_, 3) == type::lua_nil) {
+							return erase(L_);
+						}
+					}
+				}
+				else {
+					if (type_of(L_, 3) == type::lua_nil) {
+						return erase(L_);
+					}
+				}
+				auto& self = get_src(L_);
+				detail::error_result er = set_start(L_, self, stack_object(L_, raw_index(2)), std::move(value));
+				return handle_errors(L_, er);
+			}
+
+			static int index_set(lua_State* L_) {
+				return set(L_);
+			}
+
+			static int add(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er = add_copyable(is_copyable(), L_, self, stack_object(L_, raw_index(2)));
+				return handle_errors(L_, er);
+			}
+
+			static int insert(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er = insert_copyable(is_copyable(), L_, self, stack_object(L_, raw_index(2)), stack_object(L_, raw_index(3)));
+				return handle_errors(L_, er);
+			}
+
+			static int find(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er = find_has(has_find<T>(), L_, self);
+				return handle_errors(L_, er);
+			}
+
+			static int index_of(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er = find_has<true>(has_find<T>(), L_, self);
+				return handle_errors(L_, er);
+			}
+
+			static iterator begin(lua_State*, T& self) {
+				if constexpr (meta::has_begin_end_v<T>) {
+					return self.begin();
+				}
+				else {
+					using std::begin;
+					return begin(self);
+				}
+			}
+
+			static iterator end(lua_State*, T& self) {
+				if constexpr (meta::has_begin_end_v<T>) {
+					return self.end();
+				}
+				else {
+					using std::end;
+					return end(self);
+				}
+			}
+
+			static int size(lua_State* L_) {
+				auto& self = get_src(L_);
+				std::size_t r = size_start(L_, self);
+				return stack::push(L_, r);
+			}
+
+			static int clear(lua_State* L_) {
+				auto& self = get_src(L_);
+				clear_start(L_, self);
+				return 0;
+			}
+
+			static int erase(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er;
+				{
+					decltype(auto) key = stack::unqualified_get<K>(L_, 2);
+					er = erase_start(L_, self, key);
+				}
+				return handle_errors(L_, er);
+			}
+
+			static int empty(lua_State* L_) {
+				auto& self = get_src(L_);
+				return stack::push(L_, empty_start(L_, self));
+			}
+
+			static std::ptrdiff_t index_adjustment(lua_State*, T&) {
+				return static_cast<std::ptrdiff_t>((SOL_CONTAINER_START_INDEX_I_) == 0 ? 0 : -(SOL_CONTAINER_START_INDEX_I_));
+			}
+
+			static int pairs(lua_State* L_) {
+				typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+				return pairs_associative<false>(is_assoc(), L_);
+			}
+
+			static int ipairs(lua_State* L_) {
+				typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+				return pairs_associative<true>(is_assoc(), L_);
+			}
+
+			static int next(lua_State* L_) {
+				return stack::push(L_, next_iter<false>);
+			}
+		};
+
+		template <typename X>
+		struct usertype_container_default<X, std::enable_if_t<std::is_array<std::remove_pointer_t<meta::unwrap_unqualified_t<X>>>::value>> {
+		private:
+			typedef std::remove_pointer_t<meta::unwrap_unqualified_t<X>> T;
+			typedef usertype_container<X> deferred_uc;
+
+		public:
+			typedef std::remove_extent_t<T> value_type;
+			typedef value_type* iterator;
+
+		private:
+			struct iter {
+				reference keep_alive;
+				T& source;
+				iterator it;
+
+				iter(lua_State* L_, int stack_index, T& source, iterator it) noexcept
+				: keep_alive(sol::main_thread(L_, L_), stack_index), source(source), it(std::move(it)) {
+				}
+
+				~iter() {
+
+				}
+			};
+
+			static auto& get_src(lua_State* L_) {
+				auto p = stack::unqualified_check_get<T*>(L_, 1);
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+				if (!p) {
+					luaL_error(L_,
+					     "sol: 'self' is not of type '%s' (pass 'self' as first argument with ':' or call on proper type)",
+					     detail::demangle<T>().c_str());
+				}
+				if (p.value() == nullptr) {
+					luaL_error(
+					     L_, "sol: 'self' argument is nil (pass 'self' as first argument with ':' or call on a '%s' type)", detail::demangle<T>().c_str());
+				}
+#endif // Safe getting with error
+				return *p.value();
+			}
+
+			static int find(std::true_type, lua_State* L_) {
+				T& self = get_src(L_);
+				decltype(auto) value = stack::unqualified_get<value_type>(L_, 2);
+				std::size_t N = std::extent<T>::value;
+				for (std::size_t idx = 0; idx < N; ++idx) {
+					using v_t = std::add_const_t<decltype(self[idx])>;
+					v_t v = self[idx];
+					if (v == value) {
+						idx = static_cast<std::size_t>(static_cast<std::ptrdiff_t>(idx) - deferred_uc::index_adjustment(L_, self));
+						return stack::push(L_, idx);
+					}
+				}
+				return stack::push(L_, lua_nil);
+			}
+
+			static int find(std::false_type, lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'find' on '%s': no supported comparison operator for the value type", detail::demangle<T>().c_str());
+			}
+
+			static int next_iter(lua_State* L_) {
+				iter& i = stack::unqualified_get<user<iter>>(L_, 1);
+				auto& source = i.source;
+				auto& it = i.it;
+				std::size_t k = stack::unqualified_get<std::size_t>(L_, 2);
+				if (it == deferred_uc::end(L_, source)) {
+					return 0;
+				}
+				int p;
+				p = stack::push(L_, k + 1);
+				p += stack::push_reference(L_, detail::deref_move_only(*it));
+				std::advance(it, 1);
+				return p;
+			}
+
+		public:
+			static int clear(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'clear' on type '%s': cannot remove all items from a fixed array", detail::demangle<T>().c_str());
+			}
+
+			static int erase(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'erase' on type '%s': cannot remove an item from fixed arrays", detail::demangle<T>().c_str());
+			}
+
+			static int add(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'add' on type '%s': cannot add to fixed arrays", detail::demangle<T>().c_str());
+			}
+
+			static int insert(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'insert' on type '%s': cannot insert new entries into fixed arrays", detail::demangle<T>().c_str());
+			}
+
+			static int at(lua_State* L_) {
+				return get(L_);
+			}
+
+			static int get(lua_State* L_) {
+				T& self = get_src(L_);
+				std::ptrdiff_t idx = stack::unqualified_get<std::ptrdiff_t>(L_, 2);
+				idx += deferred_uc::index_adjustment(L_, self);
+				if (idx >= static_cast<std::ptrdiff_t>(std::extent<T>::value) || idx < 0) {
+					return stack::push(L_, lua_nil);
+				}
+				return stack::push_reference(L_, detail::deref_move_only(self[idx]));
+			}
+
+			static int index_get(lua_State* L_) {
+				return get(L_);
+			}
+
+			static int set(lua_State* L_) {
+				T& self = get_src(L_);
+				std::ptrdiff_t idx = stack::unqualified_get<std::ptrdiff_t>(L_, 2);
+				idx += deferred_uc::index_adjustment(L_, self);
+				if (idx >= static_cast<std::ptrdiff_t>(std::extent<T>::value)) {
+					return luaL_error(L_, "sol: index out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				if (idx < 0) {
+					return luaL_error(L_, "sol: index out of bounds (too small) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				self[idx] = stack::unqualified_get<value_type>(L_, 3);
+				return 0;
+			}
+
+			static int index_set(lua_State* L_) {
+				return set(L_);
+			}
+
+			static int index_of(lua_State* L_) {
+				return find(L_);
+			}
+
+			static int find(lua_State* L_) {
+				return find(meta::supports_op_equal<value_type, value_type>(), L_);
+			}
+
+			static int size(lua_State* L_) {
+				return stack::push(L_, std::extent<T>::value);
+			}
+
+			static int empty(lua_State* L_) {
+				return stack::push(L_, std::extent<T>::value > 0);
+			}
+
+			static int pairs(lua_State* L_) {
+				auto& src = get_src(L_);
+				stack::push(L_, next_iter);
+				stack::push<user<iter>>(L_, L_, 1, src, deferred_uc::begin(L_, src));
+				stack::push(L_, 0);
+				return 3;
+			}
+
+			static int ipairs(lua_State* L_) {
+				return pairs(L_);
+			}
+
+			static int next(lua_State* L_) {
+				return stack::push(L_, next_iter);
+			}
+
+			static std::ptrdiff_t index_adjustment(lua_State*, T&) {
+				return (SOL_CONTAINER_START_INDEX_I_) == 0 ? 0 : -(SOL_CONTAINER_START_INDEX_I_);
+			}
+
+			static iterator begin(lua_State*, T& self) {
+				return std::addressof(self[0]);
+			}
+
+			static iterator end(lua_State*, T& self) {
+				return std::addressof(self[0]) + std::extent<T>::value;
+			}
+		};
+
+		template <typename X>
+		struct usertype_container_default<usertype_container<X>> : usertype_container_default<X> { };
+	} // namespace container_detail
+
+	template <typename T>
+	struct usertype_container : container_detail::usertype_container_default<T> { };
+
+} // namespace sol
+
+// end of sol/usertype_container.hpp
+
+#include <unordered_map>
+
+namespace sol {
+
+	namespace container_detail {
+		template <typename X>
+		struct u_c_launch {
+			using T = std::remove_pointer_t<meta::unqualified_t<X>>;
+			using uc = usertype_container<T>;
+			using default_uc = usertype_container_default<T>;
+
+			static inline int real_index_get_traits(std::true_type, lua_State* L) {
+				return uc::index_get(L);
+			}
+
+			static inline int real_index_get_traits(std::false_type, lua_State* L) {
+				return default_uc::index_get(L);
+			}
+
+			static inline int real_index_call(lua_State* L) {
+				static const std::unordered_map<string_view, lua_CFunction> calls {
+					{ "at", &real_at_call },
+					{ "get", &real_get_call },
+					{ "set", &real_set_call },
+					{ "size", &real_length_call },
+					{ "add", &real_add_call },
+					{ "empty", &real_empty_call },
+					{ "insert", &real_insert_call },
+					{ "clear", &real_clear_call },
+					{ "find", &real_find_call },
+					{ "index_of", &real_index_of_call },
+					{ "erase", &real_erase_call },
+					{ "pairs", &pairs_call },
+					{ "next", &next_call },
+				};
+				auto maybenameview = stack::unqualified_check_get<string_view>(L, 2);
+				if (maybenameview) {
+					const string_view& name = *maybenameview;
+					auto it = calls.find(name);
+					if (it != calls.cend()) {
+						return stack::push(L, it->second);
+					}
+				}
+				return real_index_get_traits(container_detail::has_traits_index_get<uc>(), L);
+			}
+
+			static inline int real_at_traits(std::true_type, lua_State* L) {
+				return uc::at(L);
+			}
+
+			static inline int real_at_traits(std::false_type, lua_State* L) {
+				return default_uc::at(L);
+			}
+
+			static inline int real_at_call(lua_State* L) {
+				return real_at_traits(container_detail::has_traits_at<uc>(), L);
+			}
+
+			static inline int real_get_traits(std::true_type, lua_State* L) {
+				return uc::get(L);
+			}
+
+			static inline int real_get_traits(std::false_type, lua_State* L) {
+				return default_uc::get(L);
+			}
+
+			static inline int real_get_call(lua_State* L) {
+				return real_get_traits(container_detail::has_traits_get<uc>(), L);
+			}
+
+			static inline int real_set_traits(std::true_type, lua_State* L) {
+				return uc::set(L);
+			}
+
+			static inline int real_set_traits(std::false_type, lua_State* L) {
+				return default_uc::set(L);
+			}
+
+			static inline int real_set_call(lua_State* L) {
+				return real_set_traits(container_detail::has_traits_set<uc>(), L);
+			}
+
+			static inline int real_index_set_traits(std::true_type, lua_State* L) {
+				return uc::index_set(L);
+			}
+
+			static inline int real_index_set_traits(std::false_type, lua_State* L) {
+				return default_uc::index_set(L);
+			}
+
+			static inline int real_new_index_call(lua_State* L) {
+				return real_index_set_traits(container_detail::has_traits_index_set<uc>(), L);
+			}
+
+			static inline int real_pairs_traits(std::true_type, lua_State* L) {
+				return uc::pairs(L);
+			}
+
+			static inline int real_pairs_traits(std::false_type, lua_State* L) {
+				return default_uc::pairs(L);
+			}
+
+			static inline int real_pairs_call(lua_State* L) {
+				return real_pairs_traits(container_detail::has_traits_pairs<uc>(), L);
+			}
+
+			static inline int real_ipairs_traits(std::true_type, lua_State* L) {
+				return uc::ipairs(L);
+			}
+
+			static inline int real_ipairs_traits(std::false_type, lua_State* L) {
+				return default_uc::ipairs(L);
+			}
+
+			static inline int real_ipairs_call(lua_State* L) {
+				return real_ipairs_traits(container_detail::has_traits_ipairs<uc>(), L);
+			}
+
+			static inline int real_next_traits(std::true_type, lua_State* L) {
+				return uc::next(L);
+			}
+
+			static inline int real_next_traits(std::false_type, lua_State* L) {
+				return default_uc::next(L);
+			}
+
+			static inline int real_next_call(lua_State* L) {
+				return real_next_traits(container_detail::has_traits_next<uc>(), L);
+			}
+
+			static inline int real_size_traits(std::true_type, lua_State* L) {
+				return uc::size(L);
+			}
+
+			static inline int real_size_traits(std::false_type, lua_State* L) {
+				return default_uc::size(L);
+			}
+
+			static inline int real_length_call(lua_State* L) {
+				return real_size_traits(container_detail::has_traits_size<uc>(), L);
+			}
+
+			static inline int real_add_traits(std::true_type, lua_State* L) {
+				return uc::add(L);
+			}
+
+			static inline int real_add_traits(std::false_type, lua_State* L) {
+				return default_uc::add(L);
+			}
+
+			static inline int real_add_call(lua_State* L) {
+				return real_add_traits(container_detail::has_traits_add<uc>(), L);
+			}
+
+			static inline int real_insert_traits(std::true_type, lua_State* L) {
+				return uc::insert(L);
+			}
+
+			static inline int real_insert_traits(std::false_type, lua_State* L) {
+				return default_uc::insert(L);
+			}
+
+			static inline int real_insert_call(lua_State* L) {
+				return real_insert_traits(container_detail::has_traits_insert<uc>(), L);
+			}
+
+			static inline int real_clear_traits(std::true_type, lua_State* L) {
+				return uc::clear(L);
+			}
+
+			static inline int real_clear_traits(std::false_type, lua_State* L) {
+				return default_uc::clear(L);
+			}
+
+			static inline int real_clear_call(lua_State* L) {
+				return real_clear_traits(container_detail::has_traits_clear<uc>(), L);
+			}
+
+			static inline int real_empty_traits(std::true_type, lua_State* L) {
+				return uc::empty(L);
+			}
+
+			static inline int real_empty_traits(std::false_type, lua_State* L) {
+				return default_uc::empty(L);
+			}
+
+			static inline int real_empty_call(lua_State* L) {
+				return real_empty_traits(container_detail::has_traits_empty<uc>(), L);
+			}
+
+			static inline int real_erase_traits(std::true_type, lua_State* L) {
+				return uc::erase(L);
+			}
+
+			static inline int real_erase_traits(std::false_type, lua_State* L) {
+				return default_uc::erase(L);
+			}
+
+			static inline int real_erase_call(lua_State* L) {
+				return real_erase_traits(container_detail::has_traits_erase<uc>(), L);
+			}
+
+			static inline int real_find_traits(std::true_type, lua_State* L) {
+				return uc::find(L);
+			}
+
+			static inline int real_find_traits(std::false_type, lua_State* L) {
+				return default_uc::find(L);
+			}
+
+			static inline int real_find_call(lua_State* L) {
+				return real_find_traits(container_detail::has_traits_find<uc>(), L);
+			}
+
+			static inline int real_index_of_call(lua_State* L) {
+				if constexpr (container_detail::has_traits_index_of<uc>()) {
+					return uc::index_of(L);
+				}
+				else {
+					return default_uc::index_of(L);
+				}
+			}
+
+			static inline int add_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_add_call), (&real_add_call)>(L);
+			}
+
+			static inline int erase_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_erase_call), (&real_erase_call)>(L);
+			}
+
+			static inline int insert_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_insert_call), (&real_insert_call)>(L);
+			}
+
+			static inline int clear_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_clear_call), (&real_clear_call)>(L);
+			}
+
+			static inline int empty_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_empty_call), (&real_empty_call)>(L);
+			}
+
+			static inline int find_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_find_call), (&real_find_call)>(L);
+			}
+
+			static inline int index_of_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_index_of_call), (&real_index_of_call)>(L);
+			}
+
+			static inline int length_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_length_call), (&real_length_call)>(L);
+			}
+
+			static inline int pairs_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_pairs_call), (&real_pairs_call)>(L);
+			}
+
+			static inline int ipairs_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_ipairs_call), (&real_ipairs_call)>(L);
+			}
+
+			static inline int next_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_next_call), (&real_next_call)>(L);
+			}
+
+			static inline int at_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_at_call), (&real_at_call)>(L);
+			}
+
+			static inline int get_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_get_call), (&real_get_call)>(L);
+			}
+
+			static inline int set_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_set_call), (&real_set_call)>(L);
+			}
+
+			static inline int index_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_index_call), (&real_index_call)>(L);
+			}
+
+			static inline int new_index_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_new_index_call), (&real_new_index_call)>(L);
+			}
+		};
+	} // namespace container_detail
+
+	namespace stack {
+		namespace stack_detail {
+			template <typename T, bool is_shim = false>
+			struct metatable_setup {
+				lua_State* L;
+
+				metatable_setup(lua_State* L) : L(L) {
+				}
+
+				void operator()() {
+					using meta_usertype_container
+					     = container_detail::u_c_launch<meta::conditional_t<is_shim, as_container_t<std::remove_pointer_t<T>>, std::remove_pointer_t<T>>>;
+					static const char* metakey
+					     = is_shim ? &usertype_traits<as_container_t<std::remove_pointer_t<T>>>::metatable()[0] : &usertype_traits<T>::metatable()[0];
+					static const std::array<luaL_Reg, 20> reg = { {
+						// clang-format off
+						{ "__pairs", &meta_usertype_container::pairs_call },
+						{ "__ipairs", &meta_usertype_container::ipairs_call },
+						{ "__len", &meta_usertype_container::length_call },
+						{ "__index", &meta_usertype_container::index_call },
+						{ "__newindex", &meta_usertype_container::new_index_call },
+						{ "pairs", &meta_usertype_container::pairs_call },
+						{ "next", &meta_usertype_container::next_call },
+						{ "at", &meta_usertype_container::at_call },
+						{ "get", &meta_usertype_container::get_call },
+						{ "set", &meta_usertype_container::set_call },
+						{ "size", &meta_usertype_container::length_call },
+						{ "empty", &meta_usertype_container::empty_call },
+						{ "clear", &meta_usertype_container::clear_call },
+						{ "insert", &meta_usertype_container::insert_call },
+						{ "add", &meta_usertype_container::add_call },
+						{ "find", &meta_usertype_container::find_call },
+						{ "index_of", &meta_usertype_container::index_of_call },
+						{ "erase", &meta_usertype_container::erase_call },
+						std::is_pointer<T>::value ? luaL_Reg{ nullptr, nullptr } : luaL_Reg{ "__gc", &detail::usertype_alloc_destroy<T> },
+						{ nullptr, nullptr }
+						// clang-format on 
+					} };
+
+					if (luaL_newmetatable(L, metakey) == 1) {
+						luaL_setfuncs(L, reg.data(), 0);
+					}
+					lua_setmetatable(L, -2);
+				}
+			};
+		} // namespace stack_detail
+
+		template <typename T>
+		struct unqualified_pusher<as_container_t<T>> {
+			using C = meta::unqualified_t<T>;
+
+			static int push_lvalue(std::true_type, lua_State* L, const C& cont) {
+				stack_detail::metatable_setup<C*, true> fx(L);
+				return stack::push<detail::as_pointer_tag<const C>>(L, detail::with_function_tag(), fx, detail::ptr(cont));
+			}
+
+			static int push_lvalue(std::false_type, lua_State* L, const C& cont) {
+				stack_detail::metatable_setup<C, true> fx(L);
+				return stack::push<detail::as_value_tag<C>>(L, detail::with_function_tag(), fx, cont);
+			}
+
+			static int push_rvalue(std::true_type, lua_State* L, C&& cont) {
+				stack_detail::metatable_setup<C, true> fx(L);
+				return stack::push<detail::as_value_tag<C>>(L, detail::with_function_tag(), fx, std::move(cont));
+			}
+
+			static int push_rvalue(std::false_type, lua_State* L, const C& cont) {
+				return push_lvalue(std::is_lvalue_reference<T>(), L, cont);
+			}
+
+			static int push(lua_State* L, const as_container_t<T>& as_cont) {
+				return push_lvalue(std::is_lvalue_reference<T>(), L, as_cont.value());
+			}
+
+			static int push(lua_State* L, as_container_t<T>&& as_cont) {
+				return push_rvalue(meta::all<std::is_rvalue_reference<T>, meta::neg<std::is_lvalue_reference<T>>>(), L, std::forward<T>(as_cont.value()));
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<as_container_t<T*>> {
+			using C = std::add_pointer_t<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+			static int push(lua_State* L, T* cont) {
+				stack_detail::metatable_setup<C> fx(L);
+				return stack::push<detail::as_pointer_tag<T>>(L, detail::with_function_tag(), fx, cont);
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<T, std::enable_if_t<is_container_v<T>>> {
+			using C = T;
+
+			template <typename... Args>
+			static int push(lua_State* L, Args&&... args) {
+				stack_detail::metatable_setup<C> fx(L);
+				return stack::push<detail::as_value_tag<T>>(L, detail::with_function_tag(), fx, std::forward<Args>(args)...);
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<T*, std::enable_if_t<is_container_v<T>>> {
+			using C = std::add_pointer_t<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+			static int push(lua_State* L, T* cont) {
+				stack_detail::metatable_setup<C> fx(L);
+				return stack::push<detail::as_pointer_tag<T>>(L, detail::with_function_tag(), fx, cont);
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/usertype_container_launch.hpp
+
+#include <sstream>
+#include <type_traits>
+
+namespace sol {
+	namespace u_detail {
+		constexpr const lua_Integer toplevel_magic = static_cast<lua_Integer>(0xCCC2CCC1);
+
+		constexpr const int environment_index = 1;
+		constexpr const int usertype_storage_index = 2;
+		constexpr const int usertype_storage_base_index = 3;
+		constexpr const int exact_function_index = 4;
+		constexpr const int magic_index = 5;
+
+		constexpr const int simple_usertype_storage_index = 2;
+		constexpr const int index_function_index = 3;
+		constexpr const int new_index_function_index = 4;
+
+		constexpr const int base_walking_failed_index = -32467;
+		constexpr const int lookup_failed_index = -42469;
+
+		enum class submetatable_type {
+			// must be sequential
+			value,
+			reference,
+			unique,
+			const_reference,
+			const_value,
+			// must be LAST!
+			named
+		};
+
+		inline auto make_string_view(string_view s) {
+			return s;
+		}
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+		inline auto make_string_view(const char8_t* s) {
+			return string_view(reinterpret_cast<const char*>(s));
+		}
+#endif
+
+		inline auto make_string_view(call_construction) {
+			return string_view(to_string(meta_function::call_function));
+		}
+
+		inline auto make_string_view(meta_function mf) {
+			return string_view(to_string(mf));
+		}
+
+		inline auto make_string_view(base_classes_tag) {
+			return string_view(detail::base_class_cast_key());
+		}
+
+		template <typename Arg>
+		inline std::string make_string(Arg&& arg) {
+			string_view s = make_string_view(arg);
+			return std::string(s.data(), s.size());
+		}
+
+		inline int is_indexer(string_view s) {
+			if (s == to_string(meta_function::index)) {
+				return 1;
+			}
+			else if (s == to_string(meta_function::new_index)) {
+				return 2;
+			}
+			return 0;
+		}
+
+		inline int is_indexer(meta_function mf) {
+			if (mf == meta_function::index) {
+				return 1;
+			}
+			else if (mf == meta_function::new_index) {
+				return 2;
+			}
+			return 0;
+		}
+
+		inline int is_indexer(call_construction) {
+			return 0;
+		}
+	} // namespace u_detail
+
+	namespace detail {
+
+		template <typename T, typename IFx, typename Fx>
+		inline void insert_default_registrations(IFx&& ifx, Fx&& fx) {
+			(void)ifx;
+			(void)fx;
+			if constexpr (is_automagical<T>::value) {
+				if (fx(meta_function::less_than)) {
+					if constexpr (meta::supports_op_less<T>::value) {
+						lua_CFunction f = &comparsion_operator_wrap<T, std::less<>>;
+						ifx(meta_function::less_than, f);
+					}
+				}
+				if (fx(meta_function::less_than_or_equal_to)) {
+					if constexpr (meta::supports_op_less_equal<T>::value) {
+						lua_CFunction f = &comparsion_operator_wrap<T, std::less_equal<>>;
+						ifx(meta_function::less_than_or_equal_to, f);
+					}
+				}
+				if (fx(meta_function::equal_to)) {
+					if constexpr (meta::supports_op_equal<T>::value) {
+						lua_CFunction f = &comparsion_operator_wrap<T, std::equal_to<>>;
+						ifx(meta_function::equal_to, f);
+					}
+					else {
+						lua_CFunction f = &comparsion_operator_wrap<T, no_comp>;
+						ifx(meta_function::equal_to, f);
+					}
+				}
+				if (fx(meta_function::pairs)) {
+					ifx(meta_function::pairs, &container_detail::u_c_launch<as_container_t<T>>::pairs_call);
+				}
+				if (fx(meta_function::length)) {
+					if constexpr (meta::has_size<const T>::value || meta::has_size<T>::value) {
+						auto f = &default_size<T>;
+						ifx(meta_function::length, f);
+					}
+				}
+				if (fx(meta_function::to_string)) {
+					if constexpr (is_to_stringable_v<T>) {
+						if constexpr (!meta::is_probably_stateless_lambda_v<T> && !std::is_member_pointer_v<T>) {
+							auto f = &detail::static_trampoline<&default_to_string<T>>;
+							ifx(meta_function::to_string, f);
+						}
+					}
+				}
+				if (fx(meta_function::call_function)) {
+					if constexpr (is_callable_v<T>) {
+						if constexpr (meta::call_operator_deducible_v<T>) {
+							auto f = &c_call<decltype(&T::operator()), &T::operator()>;
+							ifx(meta_function::call_function, f);
+						}
+					}
+				}
+			}
+		}
+	} // namespace detail
+
+	namespace stack { namespace stack_detail {
+		template <typename X>
+		void set_undefined_methods_on(stack_reference t) {
+			using T = std::remove_pointer_t<X>;
+
+			lua_State* L = t.lua_state();
+
+			t.push();
+
+			detail::lua_reg_table l {};
+			int index = 0;
+			detail::indexed_insert insert_fx(l, index);
+			detail::insert_default_registrations<T>(insert_fx, detail::property_always_true);
+			if constexpr (!std::is_pointer_v<X>) {
+				l[index] = luaL_Reg { to_string(meta_function::garbage_collect).c_str(), detail::make_destructor<T>() };
+			}
+			luaL_setfuncs(L, l, 0);
+
+			// __type table
+			lua_createtable(L, 0, 2);
+			const std::string& name = detail::demangle<T>();
+			lua_pushlstring(L, name.c_str(), name.size());
+			lua_setfield(L, -2, "name");
+			lua_CFunction is_func = &detail::is_check<T>;
+			lua_pushcclosure(L, is_func, 0);
+			lua_setfield(L, -2, "is");
+			lua_setfield(L, t.stack_index(), to_string(meta_function::type).c_str());
+
+			t.pop();
+		}
+	}} // namespace stack::stack_detail
+} // namespace sol
+
+// end of sol/usertype_core.hpp
+
+// beginning of sol/usertype_storage.hpp
+
+#include <bitset>
+#include <unordered_map>
+#include <memory>
+
+namespace sol { namespace u_detail {
+
+	struct usertype_storage_base;
+	template <typename T>
+	struct usertype_storage;
+
+	optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L_, int index);
+	usertype_storage_base& get_usertype_storage_base(lua_State* L_, const char* gcmetakey);
+	template <typename T>
+	optional<usertype_storage<T>&> maybe_get_usertype_storage(lua_State* L_);
+	template <typename T>
+	usertype_storage<T>& get_usertype_storage(lua_State* L_);
+
+	using index_call_function = int(lua_State*, void*);
+	using change_indexing_mem_func = void (usertype_storage_base::*)(
+		lua_State*, submetatable_type, void*, stateless_stack_reference&, lua_CFunction, lua_CFunction, lua_CFunction, lua_CFunction);
+
+	struct index_call_storage {
+		index_call_function* index;
+		index_call_function* new_index;
+		void* binding_data;
+	};
+
+	struct new_index_call_storage : index_call_storage {
+		void* new_binding_data;
+	};
+
+	struct binding_base {
+		virtual void* data() = 0;
+		virtual ~binding_base() {
+		}
+	};
+
+	template <typename K, typename Fq, typename T = void>
+	struct binding : binding_base {
+		using uF = meta::unqualified_t<Fq>;
+		using F = meta::conditional_t<meta::is_c_str_of_v<uF, char>
+#if SOL_IS_ON(SOL_CHAR8_T)
+			     || meta::is_c_str_of_v<uF, char8_t>
+#endif
+			     || meta::is_c_str_of_v<uF, char16_t> || meta::is_c_str_of_v<uF, char32_t> || meta::is_c_str_of_v<uF, wchar_t>,
+			std::add_pointer_t<std::add_const_t<std::remove_all_extents_t<Fq>>>, std::decay_t<Fq>>;
+		F data_;
+
+		template <typename... Args>
+		binding(Args&&... args) : data_(std::forward<Args>(args)...) {
+		}
+
+		virtual void* data() override {
+			return static_cast<void*>(std::addressof(data_));
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int call_with_(lua_State* L_, void* target) {
+			constexpr int boost = !detail::is_non_factory_constructor<F>::value && std::is_same<K, call_construction>::value ? 1 : 0;
+			auto& f = *static_cast<F*>(target);
+			return call_detail::call_wrapped<T, is_index, is_variable, boost>(L_, f);
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int call_(lua_State* L_) {
+			void* f = stack::get<void*>(L_, upvalue_index(usertype_storage_index));
+			return call_with_<is_index, is_variable>(L_, f);
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int call(lua_State* L_) {
+			int r = detail::typed_static_trampoline<decltype(&call_<is_index, is_variable>), (&call_<is_index, is_variable>)>(L_);
+			if constexpr (meta::is_specialization_of_v<uF, yielding_t>) {
+				return lua_yield(L_, r);
+			}
+			else {
+				return r;
+			}
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int index_call_with_(lua_State* L_, void* target) {
+			if constexpr (!is_variable) {
+				if constexpr (is_lua_c_function_v<std::decay_t<F>>) {
+					auto& f = *static_cast<std::decay_t<F>*>(target);
+					return stack::push(L_, f);
+				}
+				else {
+					// set up upvalues
+					// for a chained call
+					int upvalues = 0;
+					upvalues += stack::push(L_, nullptr);
+					upvalues += stack::push(L_, target);
+					auto cfunc = &call<is_index, is_variable>;
+					return stack::push(L_, c_closure(cfunc, upvalues));
+				}
+			}
+			else {
+				constexpr int boost = !detail::is_non_factory_constructor<F>::value && std::is_same<K, call_construction>::value ? 1 : 0;
+				auto& f = *static_cast<F*>(target);
+				return call_detail::call_wrapped<T, is_index, is_variable, boost>(L_, f);
+			}
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int index_call_(lua_State* L_) {
+			void* f = stack::get<void*>(L_, upvalue_index(usertype_storage_index));
+			return index_call_with_<is_index, is_variable>(L_, f);
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int index_call(lua_State* L_) {
+			int r = detail::typed_static_trampoline<decltype(&index_call_<is_index, is_variable>), (&index_call_<is_index, is_variable>)>(L_);
+			if constexpr (meta::is_specialization_of_v<uF, yielding_t>) {
+				return lua_yield(L_, r);
+			}
+			else {
+				return r;
+			}
+		}
+	};
+
+	inline int index_fail(lua_State* L_) {
+		if (lua_getmetatable(L_, 1) == 1) {
+			int metatarget = lua_gettop(L_);
+			stack::get_field<false, true>(L_, stack_reference(L_, raw_index(2)), metatarget);
+			return 1;
+		}
+		// With runtime extensibility, we can't
+		// hard-error things. They have to
+		// return nil, like regular table types
+		return stack::push(L_, lua_nil);
+	}
+
+	inline int index_target_fail(lua_State* L_, void*) {
+		return index_fail(L_);
+	}
+
+	inline int new_index_fail(lua_State* L_) {
+		return luaL_error(L_, "sol: cannot set (new_index) into this object: no defined new_index operation on usertype");
+	}
+
+	inline int new_index_target_fail(lua_State* L_, void*) {
+		return new_index_fail(L_);
+	}
+
+	struct string_for_each_metatable_func {
+		bool is_destruction = false;
+		bool is_index = false;
+		bool is_new_index = false;
+		bool is_static_index = false;
+		bool is_static_new_index = false;
+		bool poison_indexing = false;
+		bool is_unqualified_lua_CFunction = false;
+		bool is_unqualified_lua_reference = false;
+		std::string* p_key = nullptr;
+		reference* p_binding_ref = nullptr;
+		lua_CFunction call_func = nullptr;
+		index_call_storage* p_ics = nullptr;
+		usertype_storage_base* p_usb = nullptr;
+		void* p_derived_usb = nullptr;
+		lua_CFunction idx_call = nullptr, new_idx_call = nullptr, meta_idx_call = nullptr, meta_new_idx_call = nullptr;
+		change_indexing_mem_func change_indexing;
+
+		void operator()(lua_State* L_, submetatable_type smt_, stateless_reference& fast_index_table_) {
+			std::string& key = *p_key;
+			usertype_storage_base& usb = *p_usb;
+			index_call_storage& ics = *p_ics;
+
+			if (smt_ == submetatable_type::named) {
+				// do not override __call or
+				// other specific meta functions on named metatable:
+				// we need that for call construction
+				// and other amenities
+				return;
+			}
+			int fast_index_table_push = fast_index_table_.push(L_);
+			stateless_stack_reference t(L_, -fast_index_table_push);
+			if (poison_indexing) {
+				(usb.*change_indexing)(L_, smt_, p_derived_usb, t, idx_call, new_idx_call, meta_idx_call, meta_new_idx_call);
+			}
+			if (is_destruction
+				&& (smt_ == submetatable_type::reference || smt_ == submetatable_type::const_reference || smt_ == submetatable_type::named
+				     || smt_ == submetatable_type::unique)) {
+				// gc does not apply to us here
+				// for reference types (raw T*, std::ref)
+				// for the named metatable itself,
+				// or for unique_usertypes, which do their own custom destroyion
+				t.pop(L_);
+				return;
+			}
+			if (is_index || is_new_index || is_static_index || is_static_new_index) {
+				// do not serialize the new_index and index functions here directly
+				// we control those...
+				t.pop(L_);
+				return;
+			}
+			if (is_unqualified_lua_CFunction) {
+				stack::set_field<false, true>(L_, key, call_func, t.stack_index());
+			}
+			else if (is_unqualified_lua_reference) {
+				reference& binding_ref = *p_binding_ref;
+				stack::set_field<false, true>(L_, key, binding_ref, t.stack_index());
+			}
+			else {
+				stack::set_field<false, true>(L_, key, make_closure(call_func, nullptr, ics.binding_data), t.stack_index());
+			}
+			t.pop(L_);
+		}
+	};
+
+	struct lua_reference_func {
+		reference key;
+		reference value;
+
+		void operator()(lua_State* L_, submetatable_type smt_, stateless_reference& fast_index_table_) {
+			if (smt_ == submetatable_type::named) {
+				return;
+			}
+			int fast_index_table_push = fast_index_table_.push(L_);
+			stateless_stack_reference t(L_, -fast_index_table_push);
+			stack::set_field<false, true>(L_, key, value, t.stack_index());
+			t.pop(L_);
+		}
+	};
+
+	struct update_bases_func {
+		detail::inheritance_check_function base_class_check_func;
+		detail::inheritance_cast_function base_class_cast_func;
+		lua_CFunction idx_call, new_idx_call, meta_idx_call, meta_new_idx_call;
+		usertype_storage_base* p_usb;
+		void* p_derived_usb;
+		change_indexing_mem_func change_indexing;
+
+		void operator()(lua_State* L_, submetatable_type smt_, stateless_reference& fast_index_table_) {
+			int fast_index_table_push = fast_index_table_.push(L_);
+			stateless_stack_reference t(L_, -fast_index_table_push);
+			stack::set_field(L_, detail::base_class_check_key(), reinterpret_cast<void*>(base_class_check_func), t.stack_index());
+			stack::set_field(L_, detail::base_class_cast_key(), reinterpret_cast<void*>(base_class_cast_func), t.stack_index());
+			// change indexing, forcefully
+			(p_usb->*change_indexing)(L_, smt_, p_derived_usb, t, idx_call, new_idx_call, meta_idx_call, meta_new_idx_call);
+			t.pop(L_);
+		}
+	};
+
+	struct binding_data_equals {
+		void* binding_data;
+
+		binding_data_equals(void* b) : binding_data(b) {
+		}
+
+		bool operator()(const std::unique_ptr<binding_base>& ptr) const {
+			return binding_data == ptr->data();
+		}
+	};
+
+	struct usertype_storage_base {
+	public:
+		lua_State* m_L;
+		std::vector<std::unique_ptr<binding_base>> storage;
+		std::vector<std::unique_ptr<char[]>> string_keys_storage;
+		std::unordered_map<string_view, index_call_storage> string_keys;
+		std::unordered_map<stateless_reference, stateless_reference, stateless_reference_hash, stateless_reference_equals> auxiliary_keys;
+		stateless_reference value_index_table;
+		stateless_reference reference_index_table;
+		stateless_reference unique_index_table;
+		stateless_reference const_reference_index_table;
+		stateless_reference const_value_index_table;
+		stateless_reference named_index_table;
+		stateless_reference type_table;
+		stateless_reference gc_names_table;
+		stateless_reference named_metatable;
+		new_index_call_storage base_index;
+		new_index_call_storage static_base_index;
+		bool is_using_index;
+		bool is_using_new_index;
+		std::bitset<64> properties;
+
+		usertype_storage_base(lua_State* L_)
+		: m_L(L_)
+		, storage()
+		, string_keys_storage()
+		, string_keys()
+		, auxiliary_keys(0, stateless_reference_hash(L_), stateless_reference_equals(L_))
+		, value_index_table()
+		, reference_index_table()
+		, unique_index_table()
+		, const_reference_index_table()
+		, const_value_index_table()
+		, named_index_table()
+		, type_table(make_reference<stateless_reference>(L_, create))
+		, gc_names_table(make_reference<stateless_reference>(L_, create))
+		, named_metatable(make_reference<stateless_reference>(L_, create))
+		, base_index()
+		, static_base_index()
+		, is_using_index(false)
+		, is_using_new_index(false)
+		, properties() {
+			base_index.binding_data = nullptr;
+			base_index.index = index_target_fail;
+			base_index.new_index = new_index_target_fail;
+			base_index.new_binding_data = nullptr;
+			static_base_index.binding_data = nullptr;
+			static_base_index.index = index_target_fail;
+			static_base_index.new_binding_data = this;
+			static_base_index.new_index = new_index_target_set;
+		}
+
+		template <typename Fx>
+		void for_each_table(lua_State* L_, Fx&& fx) {
+			for (int i = 0; i < 6; ++i) {
+				submetatable_type smt = static_cast<submetatable_type>(i);
+				stateless_reference* p_fast_index_table = nullptr;
+				switch (smt) {
+				case submetatable_type::const_value:
+					p_fast_index_table = &this->const_value_index_table;
+					break;
+				case submetatable_type::reference:
+					p_fast_index_table = &this->reference_index_table;
+					break;
+				case submetatable_type::unique:
+					p_fast_index_table = &this->unique_index_table;
+					break;
+				case submetatable_type::const_reference:
+					p_fast_index_table = &this->const_reference_index_table;
+					break;
+				case submetatable_type::named:
+					p_fast_index_table = &this->named_index_table;
+					break;
+				case submetatable_type::value:
+				default:
+					p_fast_index_table = &this->value_index_table;
+					break;
+				}
+				fx(L_, smt, *p_fast_index_table);
+			}
+		}
+
+		void add_entry(string_view sv, index_call_storage ics) {
+			string_keys_storage.emplace_back(new char[sv.size()]);
+			std::unique_ptr<char[]>& sv_storage = string_keys_storage.back();
+			std::memcpy(sv_storage.get(), sv.data(), sv.size());
+			string_view stored_sv(sv_storage.get(), sv.size());
+			string_keys.insert_or_assign(std::move(stored_sv), std::move(ics));
+		}
+
+		template <typename T, typename... Bases>
+		void update_bases(lua_State* L_, bases<Bases...>) {
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: Please file "
+				"a bug report.");
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: Please file "
+				"a bug report.");
+			static_assert(!meta::any_same<T, Bases...>::value, "base classes cannot list the original class as part of the bases");
+			if constexpr (sizeof...(Bases) > 0) {
+				(void)detail::swallow { 0, ((weak_derive<Bases>::value = true), 0)... };
+
+				void* derived_this = static_cast<void*>(static_cast<usertype_storage<T>*>(this));
+
+				update_bases_func for_each_fx;
+				for_each_fx.base_class_check_func = &detail::inheritance<T>::template type_check_with<Bases...>;
+				for_each_fx.base_class_cast_func = &detail::inheritance<T>::template type_cast_with<Bases...>;
+				for_each_fx.idx_call = &usertype_storage<T>::template index_call_with_bases<false, Bases...>;
+				for_each_fx.new_idx_call = &usertype_storage<T>::template index_call_with_bases<true, Bases...>;
+				for_each_fx.meta_idx_call = &usertype_storage<T>::template meta_index_call_with_bases<false, Bases...>;
+				for_each_fx.meta_new_idx_call = &usertype_storage<T>::template meta_index_call_with_bases<true, Bases...>;
+				for_each_fx.p_usb = this;
+				for_each_fx.p_derived_usb = derived_this;
+				for_each_fx.change_indexing = &usertype_storage_base::change_indexing;
+				for_each_fx.p_derived_usb = derived_this;
+				this->for_each_table(L_, for_each_fx);
+			}
+			else {
+				(void)L_;
+			}
+		}
+
+		void clear() {
+			if (value_index_table.valid(m_L)) {
+				stack::clear(m_L, value_index_table);
+			}
+			if (reference_index_table.valid(m_L)) {
+				stack::clear(m_L, reference_index_table);
+			}
+			if (unique_index_table.valid(m_L)) {
+				stack::clear(m_L, unique_index_table);
+			}
+			if (const_reference_index_table.valid(m_L)) {
+				stack::clear(m_L, const_reference_index_table);
+			}
+			if (const_value_index_table.valid(m_L)) {
+				stack::clear(m_L, const_value_index_table);
+			}
+			if (named_index_table.valid(m_L)) {
+				stack::clear(m_L, named_index_table);
+			}
+			if (type_table.valid(m_L)) {
+				stack::clear(m_L, type_table);
+			}
+			if (gc_names_table.valid(m_L)) {
+				stack::clear(m_L, gc_names_table);
+			}
+			if (named_metatable.valid(m_L)) {
+				auto pp = stack::push_pop(m_L, named_metatable);
+				int named_metatable_index = pp.index_of(named_metatable);
+				if (lua_getmetatable(m_L, named_metatable_index) == 1) {
+					stack::clear(m_L, absolute_index(m_L, -1));
+				}
+				stack::clear(m_L, named_metatable);
+			}
+
+			value_index_table.reset(m_L);
+			reference_index_table.reset(m_L);
+			unique_index_table.reset(m_L);
+			const_reference_index_table.reset(m_L);
+			const_value_index_table.reset(m_L);
+			named_index_table.reset(m_L);
+			type_table.reset(m_L);
+			gc_names_table.reset(m_L);
+			named_metatable.reset(m_L);
+
+			storage.clear();
+			string_keys.clear();
+			auxiliary_keys.clear();
+			string_keys_storage.clear();
+		}
+
+		template <bool is_new_index, typename Base>
+		static void base_walk_index(lua_State* L_, usertype_storage_base& self, bool& keep_going, int& base_result) {
+			using bases = typename base<Base>::type;
+			if (!keep_going) {
+				return;
+			}
+			(void)L_;
+			(void)self;
+#if SOL_IS_ON(SOL_USE_UNSAFE_BASE_LOOKUP)
+			usertype_storage_base& base_storage = get_usertype_storage<Base>(L_);
+			base_result = self_index_call<is_new_index, true>(bases(), L_, base_storage);
+#else
+			optional<usertype_storage<Base>&> maybe_base_storage = maybe_get_usertype_storage<Base>(L_);
+			if (static_cast<bool>(maybe_base_storage)) {
+				base_result = self_index_call<is_new_index, true>(bases(), L_, *maybe_base_storage);
+				keep_going = base_result == base_walking_failed_index;
+			}
+#endif // Fast versus slow, safe base lookup
+		}
+
+		template <bool is_new_index = false, bool base_walking = false, bool from_named_metatable = false, typename... Bases>
+		static inline int self_index_call(types<Bases...>, lua_State* L, usertype_storage_base& self) {
+			if constexpr (!from_named_metatable || !is_new_index) {
+				type k_type = stack::get<type>(L, 2);
+				if (k_type == type::string) {
+					index_call_storage* target = nullptr;
+					string_view k = stack::get<string_view>(L, 2);
+					{
+						auto it = self.string_keys.find(k);
+						if (it != self.string_keys.cend()) {
+							target = &it->second;
+						}
+					}
+					if (target != nullptr) {
+						// let the target decide what to do, unless it's named...
+						if constexpr (is_new_index) {
+							return (target->new_index)(L, target->binding_data);
+						}
+						else {
+							return (target->index)(L, target->binding_data);
+						}
+					}
+				}
+				else if (k_type != type::lua_nil && k_type != type::none) {
+					stateless_reference* target = nullptr;
+					{
+						stack_reference k = stack::get<stack_reference>(L, 2);
+						auto it = self.auxiliary_keys.find(k);
+						if (it != self.auxiliary_keys.cend()) {
+							target = &it->second;
+						}
+					}
+					if (target != nullptr) {
+						if constexpr (is_new_index) {
+							// set value and return
+							target->reset(L, 3);
+							return 0;
+						}
+						else {
+							// push target to return
+							// what we found
+							return stack::push(L, *target);
+						}
+					}
+				}
+			}
+
+			// retrieve bases and walk through them.
+			bool keep_going = true;
+			int base_result;
+			(void)keep_going;
+			(void)base_result;
+			(void)detail::swallow { 1, (base_walk_index<is_new_index, Bases>(L, self, keep_going, base_result), 1)... };
+			if constexpr (sizeof...(Bases) > 0) {
+				if (!keep_going) {
+					return base_result;
+				}
+			}
+			if constexpr (base_walking) {
+				// if we're JUST base-walking then don't index-fail, just
+				// return the false bits
+				return base_walking_failed_index;
+			}
+			else if constexpr (from_named_metatable) {
+				if constexpr (is_new_index) {
+					return self.static_base_index.new_index(L, self.static_base_index.new_binding_data);
+				}
+				else {
+					return self.static_base_index.index(L, self.static_base_index.binding_data);
+				}
+			}
+			else {
+				if constexpr (is_new_index) {
+					return self.base_index.new_index(L, self.base_index.new_binding_data);
+				}
+				else {
+					return self.base_index.index(L, self.base_index.binding_data);
+				}
+			}
+		}
+
+		void change_indexing(lua_State* L_, submetatable_type submetatable_, void* derived_this_, stateless_stack_reference& t_, lua_CFunction index_,
+			lua_CFunction new_index_, lua_CFunction meta_index_, lua_CFunction meta_new_index_) {
+			usertype_storage_base& this_base = *this;
+			void* base_this = static_cast<void*>(&this_base);
+
+			this->is_using_index |= true;
+			this->is_using_new_index |= true;
+			if (submetatable_ == submetatable_type::named) {
+				stack::set_field(L_, metatable_key, named_index_table, t_.stack_index());
+				stateless_stack_reference stack_metametatable(L_, -named_metatable.push(L_));
+				stack::set_field<false, true>(L_,
+					meta_function::index,
+					make_closure(meta_index_, nullptr, derived_this_, base_this, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack::set_field<false, true>(L_,
+					meta_function::new_index,
+					make_closure(meta_new_index_, nullptr, derived_this_, base_this, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack_metametatable.pop(L_);
+			}
+			else {
+				stack::set_field<false, true>(
+					L_, meta_function::index, make_closure(index_, nullptr, derived_this_, base_this, nullptr, toplevel_magic), t_.stack_index());
+				stack::set_field<false, true>(
+					L_, meta_function::new_index, make_closure(new_index_, nullptr, derived_this_, base_this, nullptr, toplevel_magic), t_.stack_index());
+			}
+		}
+
+		template <typename T = void, typename Key, typename Value>
+		void set(lua_State* L, Key&& key, Value&& value);
+
+		static int new_index_target_set(lua_State* L, void* target) {
+			usertype_storage_base& self = *static_cast<usertype_storage_base*>(target);
+			self.set(L, reference(L, raw_index(2)), reference(L, raw_index(3)));
+			return 0;
+		}
+
+		~usertype_storage_base() {
+			value_index_table.reset(m_L);
+			reference_index_table.reset(m_L);
+			unique_index_table.reset(m_L);
+			const_reference_index_table.reset(m_L);
+			const_value_index_table.reset(m_L);
+			named_index_table.reset(m_L);
+			type_table.reset(m_L);
+			gc_names_table.reset(m_L);
+			named_metatable.reset(m_L);
+
+			auto auxiliary_first = auxiliary_keys.cbegin();
+			auto auxiliary_last = auxiliary_keys.cend();
+			while (auxiliary_first != auxiliary_last) {
+				// save a copy to what we're going to destroy
+				auto auxiliary_target = auxiliary_first;
+				// move the iterator up by 1
+				++auxiliary_first;
+				// extract the node and destroy the key
+				auto extracted_node = auxiliary_keys.extract(auxiliary_target);
+				extracted_node.key().reset(m_L);
+				extracted_node.mapped().reset(m_L);
+				// continue if auxiliary_first hasn't been exhausted
+			}
+		}
+	};
+
+	template <typename T>
+	struct usertype_storage : usertype_storage_base {
+
+		using usertype_storage_base::usertype_storage_base;
+
+		template <bool is_new_index, bool from_named_metatable>
+		static inline int index_call_(lua_State* L) {
+			using bases = typename base<T>::type;
+			usertype_storage_base& self = stack::get<light<usertype_storage_base>>(L, upvalue_index(usertype_storage_index));
+			return self_index_call<is_new_index, false, from_named_metatable>(bases(), L, self);
+		}
+
+		template <bool is_new_index, bool from_named_metatable, typename... Bases>
+		static inline int index_call_with_bases_(lua_State* L) {
+			using bases = types<Bases...>;
+			usertype_storage_base& self = stack::get<light<usertype_storage_base>>(L, upvalue_index(usertype_storage_index));
+			return self_index_call<is_new_index, false, from_named_metatable>(bases(), L, self);
+		}
+
+		template <bool is_new_index>
+		static inline int index_call(lua_State* L) {
+			return detail::static_trampoline<&index_call_<is_new_index, false>>(L);
+		}
+
+		template <bool is_new_index, typename... Bases>
+		static inline int index_call_with_bases(lua_State* L) {
+			return detail::static_trampoline<&index_call_with_bases_<is_new_index, false, Bases...>>(L);
+		}
+
+		template <bool is_new_index>
+		static inline int meta_index_call(lua_State* L) {
+			return detail::static_trampoline<&index_call_<is_new_index, true>>(L);
+		}
+
+		template <bool is_new_index, typename... Bases>
+		static inline int meta_index_call_with_bases(lua_State* L) {
+			return detail::static_trampoline<&index_call_with_bases_<is_new_index, true, Bases...>>(L);
+		}
+
+		template <typename Key, typename Value>
+		inline void set(lua_State* L, Key&& key, Value&& value);
+	};
+
+	template <typename T, typename Key, typename Value>
+	void usertype_storage_base::set(lua_State* L, Key&& key, Value&& value) {
+		using ValueU = meta::unwrap_unqualified_t<Value>;
+		using KeyU = meta::unwrap_unqualified_t<Key>;
+		using Binding = binding<KeyU, ValueU, T>;
+		using is_var_bind = is_variable_binding<ValueU>;
+		if constexpr (std::is_same_v<KeyU, call_construction>) {
+			(void)key;
+			std::unique_ptr<Binding> p_binding = std::make_unique<Binding>(std::forward<Value>(value));
+			Binding& b = *p_binding;
+			this->storage.push_back(std::move(p_binding));
+
+			this->named_index_table.push(L);
+			absolute_index metametatable_index(L, -1);
+			std::string_view call_metamethod_name = to_string(meta_function::call);
+			lua_pushlstring(L, call_metamethod_name.data(), call_metamethod_name.size());
+			stack::push(L, nullptr);
+			stack::push(L, b.data());
+			lua_CFunction target_func = &b.template call<false, false>;
+			lua_pushcclosure(L, target_func, 2);
+			lua_rawset(L, metametatable_index);
+			this->named_index_table.pop(L);
+		}
+		else if constexpr (std::is_same_v<KeyU, base_classes_tag>) {
+			(void)key;
+			this->update_bases<T>(L, std::forward<Value>(value));
+		}
+		else if constexpr ((meta::is_string_like_or_constructible<KeyU>::value || std::is_same_v<KeyU, meta_function>)) {
+			std::string s = u_detail::make_string(std::forward<Key>(key));
+			auto storage_it = this->storage.end();
+			auto string_it = this->string_keys.find(s);
+			if (string_it != this->string_keys.cend()) {
+				const auto& binding_data = string_it->second.binding_data;
+				storage_it = std::find_if(this->storage.begin(), this->storage.end(), binding_data_equals(binding_data));
+				this->string_keys.erase(string_it);
+			}
+
+			std::unique_ptr<Binding> p_binding = std::make_unique<Binding>(std::forward<Value>(value));
+			Binding& b = *p_binding;
+			if (storage_it != this->storage.cend()) {
+				*storage_it = std::move(p_binding);
+			}
+			else {
+				this->storage.push_back(std::move(p_binding));
+			}
+
+			bool is_index = (s == to_string(meta_function::index));
+			bool is_new_index = (s == to_string(meta_function::new_index));
+			bool is_static_index = (s == to_string(meta_function::static_index));
+			bool is_static_new_index = (s == to_string(meta_function::static_new_index));
+			bool is_destruction = s == to_string(meta_function::garbage_collect);
+			bool poison_indexing = (!is_using_index || !is_using_new_index) && (is_var_bind::value || is_index || is_new_index);
+			void* derived_this = static_cast<void*>(static_cast<usertype_storage<T>*>(this));
+			index_call_storage ics;
+			ics.binding_data = b.data();
+			ics.index = is_index || is_static_index ? &Binding::template call_with_<true, is_var_bind::value>
+				                                   : &Binding::template index_call_with_<true, is_var_bind::value>;
+			ics.new_index = is_new_index || is_static_new_index ? &Binding::template call_with_<false, is_var_bind::value>
+				                                               : &Binding::template index_call_with_<false, is_var_bind::value>;
+
+			string_for_each_metatable_func for_each_fx;
+			for_each_fx.is_destruction = is_destruction;
+			for_each_fx.is_index = is_index;
+			for_each_fx.is_new_index = is_new_index;
+			for_each_fx.is_static_index = is_static_index;
+			for_each_fx.is_static_new_index = is_static_new_index;
+			for_each_fx.poison_indexing = poison_indexing;
+			for_each_fx.p_key = &s;
+			for_each_fx.p_ics = &ics;
+			if constexpr (is_lua_c_function_v<ValueU>) {
+				for_each_fx.is_unqualified_lua_CFunction = true;
+				for_each_fx.call_func = *static_cast<lua_CFunction*>(ics.binding_data);
+			}
+			else if constexpr (is_lua_reference_or_proxy_v<ValueU>) {
+				for_each_fx.is_unqualified_lua_reference = true;
+				for_each_fx.p_binding_ref = static_cast<reference*>(ics.binding_data);
+			}
+			else {
+				for_each_fx.call_func = &b.template call<false, is_var_bind::value>;
+			}
+			for_each_fx.p_usb = this;
+			for_each_fx.p_derived_usb = derived_this;
+			for_each_fx.idx_call = &usertype_storage<T>::template index_call<false>;
+			for_each_fx.new_idx_call = &usertype_storage<T>::template index_call<true>;
+			for_each_fx.meta_idx_call = &usertype_storage<T>::template meta_index_call<false>;
+			for_each_fx.meta_new_idx_call = &usertype_storage<T>::template meta_index_call<true>;
+			for_each_fx.change_indexing = &usertype_storage_base::change_indexing;
+			// set base index and base new_index
+			// functions here
+			if (is_index) {
+				this->base_index.index = ics.index;
+				this->base_index.binding_data = ics.binding_data;
+			}
+			if (is_new_index) {
+				this->base_index.new_index = ics.new_index;
+				this->base_index.new_binding_data = ics.binding_data;
+			}
+			if (is_static_index) {
+				this->static_base_index.index = ics.index;
+				this->static_base_index.binding_data = ics.binding_data;
+			}
+			if (is_static_new_index) {
+				this->static_base_index.new_index = ics.new_index;
+				this->static_base_index.new_binding_data = ics.binding_data;
+			}
+			this->for_each_table(L, for_each_fx);
+			this->add_entry(s, std::move(ics));
+		}
+		else {
+			// the reference-based implementation might compare poorly and hash
+			// poorly in some cases...
+			if constexpr (is_lua_reference_v<KeyU> && is_lua_reference_v<ValueU>) {
+				if (key.get_type() == type::string) {
+					stack::push(L, key);
+					std::string string_key = stack::pop<std::string>(L);
+					this->set<T>(L, string_key, std::forward<Value>(value));
+				}
+				else {
+					lua_reference_func ref_additions_fx { key, value };
+
+					this->for_each_table(L, ref_additions_fx);
+					this->auxiliary_keys.insert_or_assign(std::forward<Key>(key), std::forward<Value>(value));
+				}
+			}
+			else {
+				reference ref_key = make_reference(L, std::forward<Key>(key));
+				reference ref_value = make_reference(L, std::forward<Value>(value));
+				lua_reference_func ref_additions_fx { ref_key, ref_value };
+
+				this->for_each_table(L, ref_additions_fx);
+				this->auxiliary_keys.insert_or_assign(std::move(ref_key), std::move(ref_value));
+			}
+		}
+	}
+
+	template <typename T>
+	template <typename Key, typename Value>
+	void usertype_storage<T>::set(lua_State* L, Key&& key, Value&& value) {
+		static_cast<usertype_storage_base&>(*this).set<T>(L, std::forward<Key>(key), std::forward<Value>(value));
+	}
+
+	template <typename T>
+	inline void clear_usertype_registry_names(lua_State* L) {
+		using u_traits = usertype_traits<T>;
+		using u_const_traits = usertype_traits<const T>;
+		using u_unique_traits = usertype_traits<d::u<T>>;
+		using u_ref_traits = usertype_traits<T*>;
+		using u_const_ref_traits = usertype_traits<T const*>;
+
+		stack_reference registry(L, raw_index(LUA_REGISTRYINDEX));
+		registry.push();
+		// eliminate all named entries for this usertype
+		// in the registry (luaL_newmetatable does
+		// [name] = new table
+		// in registry upon creation
+		stack::set_field(L, &u_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_const_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_const_ref_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_ref_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_unique_traits::metatable()[0], lua_nil, registry.stack_index());
+		registry.pop();
+	}
+
+	template <typename T>
+	inline int destroy_usertype_storage(lua_State* L) noexcept {
+		clear_usertype_registry_names<T>(L);
+		return detail::user_alloc_destroy<usertype_storage<T>>(L);
+	}
+
+	template <typename T>
+	inline usertype_storage<T>& create_usertype_storage(lua_State* L) {
+		const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+
+		// Make sure userdata's memory is properly in lua first,
+		// otherwise all the light userdata we make later will become invalid
+		int usertype_storage_push_count = stack::push<user<usertype_storage<T>>>(L, no_metatable, L);
+		stack_reference usertype_storage_ref(L, -usertype_storage_push_count);
+
+		// create and push onto the stack a table to use as metatable for this GC
+		// we create a metatable to attach to the regular gc_table
+		// so that the destructor is called for the usertype storage
+		int usertype_storage_metatabe_count = stack::push(L, new_table(0, 1));
+		stack_reference usertype_storage_metatable(L, -usertype_storage_metatabe_count);
+		// set the destroyion routine on the metatable
+		stack::set_field(L, meta_function::garbage_collect, &destroy_usertype_storage<T>, usertype_storage_metatable.stack_index());
+		// set the metatable on the usertype storage userdata
+		stack::set_field(L, metatable_key, usertype_storage_metatable, usertype_storage_ref.stack_index());
+		usertype_storage_metatable.pop();
+
+		// set the usertype storage and its metatable
+		// into the global table...
+		stack::set_field<true>(L, gcmetakey, usertype_storage_ref);
+		usertype_storage_ref.pop();
+
+		// then retrieve the lua-stored version so we have a well-pinned
+		// reference that does not die
+		stack::get_field<true>(L, gcmetakey);
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		return target_umt;
+	}
+
+	inline optional<usertype_storage_base&> maybe_as_usertype_storage_base(lua_State* L, int index) {
+		if (type_of(L, index) != type::lightuserdata) {
+			return nullopt;
+		}
+		usertype_storage_base& base_storage = *static_cast<usertype_storage_base*>(stack::get<void*>(L, index));
+		return base_storage;
+	}
+
+	inline optional<usertype_storage_base&> maybe_get_usertype_storage_base_inside(lua_State* L, int index) {
+		// okay, maybe we're looking at a table that is nested?
+		if (type_of(L, index) != type::table) {
+			return nullopt;
+		}
+		stack::get_field(L, meta_function::storage, index);
+		auto maybe_storage_base = maybe_as_usertype_storage_base(L, -1);
+		lua_pop(L, 1);
+		return maybe_storage_base;
+	}
+
+	inline optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L, int index) {
+		// If we can get the index directly as this type, go for it
+		auto maybe_already_is_usertype_storage_base = maybe_as_usertype_storage_base(L, index);
+		if (maybe_already_is_usertype_storage_base) {
+			return maybe_already_is_usertype_storage_base;
+		}
+		return maybe_get_usertype_storage_base_inside(L, index);
+	}
+
+	inline optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L, const char* gcmetakey) {
+		stack::get_field<true>(L, gcmetakey);
+		auto maybe_storage = maybe_as_usertype_storage_base(L, lua_gettop(L));
+		lua_pop(L, 1);
+		return maybe_storage;
+	}
+
+	inline usertype_storage_base& get_usertype_storage_base(lua_State* L, const char* gcmetakey) {
+		stack::get_field<true>(L, gcmetakey);
+		stack::record tracking;
+		usertype_storage_base& target_umt = stack::stack_detail::unchecked_unqualified_get<user<usertype_storage_base>>(L, -1, tracking);
+		lua_pop(L, 1);
+		return target_umt;
+	}
+
+	template <typename T>
+	inline optional<usertype_storage<T>&> maybe_get_usertype_storage(lua_State* L) {
+		const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+		stack::get_field<true>(L, gcmetakey);
+		int target = lua_gettop(L);
+		if (!stack::check<user<usertype_storage<T>>>(L, target)) {
+			return nullopt;
+		}
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		return target_umt;
+	}
+
+	template <typename T>
+	inline usertype_storage<T>& get_usertype_storage(lua_State* L) {
+		const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+		stack::get_field<true>(L, gcmetakey);
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		return target_umt;
+	}
+
+	template <typename T>
+	inline void clear_usertype_storage(lua_State* L) {
+		using u_traits = usertype_traits<T>;
+
+		const char* gcmetakey = &u_traits::gc_table()[0];
+		stack::get_field<true>(L, gcmetakey);
+		if (!stack::check<user<usertype_storage<T>>>(L)) {
+			lua_pop(L, 1);
+			return;
+		}
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		target_umt.clear();
+
+		clear_usertype_registry_names<T>(L);
+
+		stack::set_field<true>(L, gcmetakey, lua_nil);
+	}
+
+	template <typename T, automagic_flags enrollment_flags>
+	inline int register_usertype(lua_State* L_, automagic_enrollments enrollments_ = {}) {
+		using u_traits = usertype_traits<T>;
+		using u_const_traits = usertype_traits<const T>;
+		using u_unique_traits = usertype_traits<d::u<T>>;
+		using u_ref_traits = usertype_traits<T*>;
+		using u_const_ref_traits = usertype_traits<T const*>;
+		using uts = usertype_storage<T>;
+
+		// always have __new_index point to usertype_storage method
+		// have __index always point to regular fast-lookup
+		// meta_method table
+		// if __new_index is invoked, runtime-swap
+		// to slow __index if necessary
+		// (no speed penalty because function calls
+		// are all read-only -- only depend on __index
+		// to retrieve function and then call happens VIA Lua)
+
+		// __type entry:
+		// table contains key -> value lookup,
+		// where key is entry in metatable
+		// and value is type information as a string as
+		// best as we can give it
+
+		// name entry:
+		// string that contains raw class name,
+		// as defined from C++
+
+		// is entry:
+		// checks if argument supplied is of type T
+
+		// __storage entry:
+		// a light userdata pointing to the storage
+		// mostly to enable this new abstraction
+		// to not require the type name `T`
+		// to get at the C++ usertype storage within
+
+		// we then let typical definitions potentially override these intrinsics
+		// it's the user's fault if they override things or screw them up:
+		// these names have been reserved and documented since sol2
+
+		// STEP 0: tell the old usertype (if it exists)
+		// to fuck off
+		clear_usertype_storage<T>(L_);
+
+		// STEP 1: Create backing store for usertype storage
+		// Pretty much the most important step.
+		// STEP 2: Create Lua tables used for fast method indexing.
+		// This is done inside of the storage table's constructor
+		usertype_storage<T>& storage = create_usertype_storage<T>(L_);
+		usertype_storage_base& base_storage = storage;
+		void* light_storage = static_cast<void*>(&storage);
+		void* light_base_storage = static_cast<void*>(&base_storage);
+
+		// STEP 3: set up GC escape hatch table entirely
+		storage.gc_names_table.push(L_);
+		stateless_stack_reference gnt(L_, -1);
+		stack::set_field(L_, submetatable_type::named, &u_traits::gc_table()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::const_value, &u_const_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::const_reference, &u_const_ref_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::reference, &u_ref_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::unique, &u_unique_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::value, &u_traits::metatable()[0], gnt.stack_index());
+		gnt.pop(L_);
+
+		// STEP 4: add some useful information to the type table
+		stateless_stack_reference stacked_type_table(L_, -storage.type_table.push(L_));
+		stack::set_field(L_, "name", detail::demangle<T>(), stacked_type_table.stack_index());
+		stack::set_field(L_, "is", &detail::is_check<T>, stacked_type_table.stack_index());
+		stacked_type_table.pop(L_);
+
+		// STEP 5: create and hook up metatable,
+		// add intrinsics
+		// this one is the actual meta-handling table,
+		// the next one will be the one for
+		int for_each_backing_metatable_calls = 0;
+		auto for_each_backing_metatable = [&](lua_State* L_, submetatable_type smt_, stateless_reference& fast_index_table_) {
+			// Pointer types, AKA "references" from C++
+			const char* metakey = nullptr;
+			switch (smt_) {
+			case submetatable_type::const_value:
+				metakey = &u_const_traits::metatable()[0];
+				break;
+			case submetatable_type::reference:
+				metakey = &u_ref_traits::metatable()[0];
+				break;
+			case submetatable_type::unique:
+				metakey = &u_unique_traits::metatable()[0];
+				break;
+			case submetatable_type::const_reference:
+				metakey = &u_const_ref_traits::metatable()[0];
+				break;
+			case submetatable_type::named:
+				metakey = &u_traits::user_metatable()[0];
+				break;
+			case submetatable_type::value:
+			default:
+				metakey = &u_traits::metatable()[0];
+				break;
+			}
+
+			luaL_newmetatable(L_, metakey);
+			if (smt_ == submetatable_type::named) {
+				// the named table itself
+				// gets the associated name value
+				storage.named_metatable.reset(L_, -1);
+				lua_pop(L_, 1);
+				// but the thing we perform the methods on
+				// is still the metatable of the named
+				// table
+				lua_createtable(L_, 0, 6);
+			}
+			stateless_stack_reference t(L_, -1);
+			fast_index_table_.reset(L_, t.stack_index());
+			stack::set_field<false, true>(L_, meta_function::type, storage.type_table, t.stack_index());
+			// destructible? serialize default destructor here
+			// otherwise, not destructible: serialize a "hey you messed up"
+			switch (smt_) {
+			case submetatable_type::const_reference:
+			case submetatable_type::reference:
+			case submetatable_type::named:
+				break;
+			case submetatable_type::unique:
+				if constexpr (std::is_destructible_v<T>) {
+					stack::set_field<false, true>(L_, meta_function::garbage_collect, &detail::unique_destroy<T>, t.stack_index());
+				}
+				else {
+					stack::set_field<false, true>(L_, meta_function::garbage_collect, &detail::cannot_destroy<T>, t.stack_index());
+				}
+				break;
+			case submetatable_type::value:
+			case submetatable_type::const_value:
+			default:
+				if constexpr (std::is_destructible_v<T>) {
+					stack::set_field<false, true>(L_, meta_function::garbage_collect, detail::make_destructor<T>(), t.stack_index());
+				}
+				else {
+					stack::set_field<false, true>(L_, meta_function::garbage_collect, &detail::cannot_destroy<T>, t.stack_index());
+				}
+				break;
+			}
+
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: file a bug "
+				"report.");
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: file a bug "
+				"report.");
+			stack::set_field<false, true>(L_, detail::base_class_check_key(), reinterpret_cast<void*>(&detail::inheritance<T>::type_check), t.stack_index());
+			stack::set_field<false, true>(L_, detail::base_class_cast_key(), reinterpret_cast<void*>(&detail::inheritance<T>::type_cast), t.stack_index());
+
+			auto prop_fx = detail::properties_enrollment_allowed(for_each_backing_metatable_calls, storage.properties, enrollments_);
+			auto insert_fx = [&L_, &t, &storage](meta_function mf, lua_CFunction reg) {
+				stack::set_field<false, true>(L_, mf, reg, t.stack_index());
+				storage.properties[static_cast<std::size_t>(mf)] = true;
+			};
+			detail::insert_default_registrations<T>(insert_fx, prop_fx);
+
+			// There are no variables, so serialize the fast function stuff
+			// be sure to reset the index stuff to the non-fast version
+			// if the user ever adds something later!
+			if (smt_ == submetatable_type::named) {
+				// add escape hatch storage pointer and gc names
+				stack::set_field<false, true>(L_, meta_function::storage, light_base_storage, t.stack_index());
+				stack::set_field<false, true>(L_, meta_function::gc_names, storage.gc_names_table, t.stack_index());
+
+				// fancy new_indexing when using the named table
+				{
+					absolute_index named_metatable_index(L_, -storage.named_metatable.push(L_));
+					stack::set_field<false, true>(L_, metatable_key, t, named_metatable_index);
+					storage.named_metatable.pop(L_);
+				}
+				stack_reference stack_metametatable(L_, -storage.named_index_table.push(L_));
+				stack::set_field<false, true>(L_,
+					meta_function::index,
+					make_closure(uts::template meta_index_call<false>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack::set_field<false, true>(L_,
+					meta_function::new_index,
+					make_closure(uts::template meta_index_call<true>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack_metametatable.pop();
+			}
+			else {
+				// otherwise just plain for index,
+				// and elaborated for new_index
+				stack::set_field<false, true>(L_, meta_function::index, t, t.stack_index());
+				stack::set_field<false, true>(L_,
+					meta_function::new_index,
+					make_closure(uts::template index_call<true>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+					t.stack_index());
+				storage.is_using_new_index = true;
+			}
+
+			++for_each_backing_metatable_calls;
+			fast_index_table_.reset(L_, t.stack_index());
+			t.pop(L_);
+		};
+
+		storage.for_each_table(L_, for_each_backing_metatable);
+
+		// can only use set AFTER we initialize all the metatables
+		if constexpr (std::is_default_constructible_v<T> && has_flag(enrollment_flags, automagic_flags::default_constructor)) {
+			if (enrollments_.default_constructor) {
+				storage.set(L_, meta_function::construct, constructors<T()>());
+			}
+		}
+
+		// return the named metatable we want names linked into
+		storage.named_metatable.push(L_);
+		return 1;
+	}
+}} // namespace sol::u_detail
+
+// end of sol/usertype_storage.hpp
+
+// beginning of sol/usertype_proxy.hpp
+
+namespace sol {
+	template <typename Table, typename Key>
+	struct usertype_proxy : public proxy_base<usertype_proxy<Table, Key>> {
+	private:
+		using key_type = detail::proxy_key_t<Key>;
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) const& {
+			return tbl.template traverse_get<T>(std::get<I>(key)...);
+		}
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) && {
+			return tbl.template traverse_get<T>(std::get<I>(std::move(key))...);
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) & {
+			if constexpr (sizeof...(I) > 1) {
+				tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value));
+			}
+			else {
+				tbl.set(std::get<I>(key)..., std::forward<T>(value));
+			}
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) && {
+			if constexpr (sizeof...(I) > 1) {
+				tbl.traverse_set(std::get<I>(std::move(key))..., std::forward<T>(value));
+			}
+			else {
+				tbl.set(std::get<I>(std::move(key))..., std::forward<T>(value));
+			}
+		}
+
+	public:
+		Table tbl;
+		key_type key;
+
+		template <typename T>
+		usertype_proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {
+		}
+
+		template <typename T>
+		usertype_proxy& set(T&& item) & {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			tuple_set(idx_seq(), std::forward<T>(item));
+			return *this;
+		}
+
+		template <typename T>
+		usertype_proxy&& set(T&& item) && {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			std::move(*this).tuple_set(idx_seq(), std::forward<T>(item));
+			return std::move(*this);
+		}
+
+		template <typename T>
+		usertype_proxy& operator=(T&& other) & {
+			return set(std::forward<T>(other));
+		}
+
+		template <typename T>
+		usertype_proxy&& operator=(T&& other) && {
+			return std::move(*this).set(std::forward<T>(other));
+		}
+
+		template <typename T>
+		usertype_proxy& operator=(std::initializer_list<T> other) & {
+			return set(std::move(other));
+		}
+
+		template <typename T>
+		usertype_proxy&& operator=(std::initializer_list<T> other) && {
+			return std::move(*this).set(std::move(other));
+		}
+
+		template <typename T>
+		decltype(auto) get() const& {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return tuple_get<T>(idx_seq());
+		}
+
+		template <typename T>
+		decltype(auto) get() && {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return std::move(*this).template tuple_get<T>(idx_seq());
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) const& {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) & {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) && {
+			auto keys = meta::tuplefy(std::move(key), std::forward<K>(k));
+			return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+#if !defined(__clang__) && defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 191200000
+			// MSVC is ass sometimes
+			return get<function>().call<Ret...>(std::forward<Args>(args)...);
+#else
+			return get<function>().template call<Ret...>(std::forward<Args>(args)...);
+#endif
+		}
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		bool valid() const {
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+		int push() const noexcept {
+			return push(this->lua_state());
+		}
+
+		int push(lua_State* L) const noexcept {
+			return get<reference>().push(L);
+		}
+
+		type get_type() const {
+			type t = type::none;
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			if (p) {
+				t = type_of(lua_state(), -1);
+			}
+			lua_pop(lua_state(), p.levels);
+			return t;
+		}
+
+		lua_State* lua_state() const {
+			return tbl.lua_state();
+		}
+	};
+} // namespace sol
+
+// end of sol/usertype_proxy.hpp
+
+// beginning of sol/metatable.hpp
+
+// beginning of sol/table_core.hpp
+
+// beginning of sol/table_proxy.hpp
+
+namespace sol {
+
+	template <typename Table, typename Key>
+	struct table_proxy : public proxy_base<table_proxy<Table, Key>> {
+	private:
+		using key_type = detail::proxy_key_t<Key>;
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) const& {
+			return tbl.template traverse_get<T>(std::get<I>(key)...);
+		}
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) && {
+			return tbl.template traverse_get<T>(std::get<I>(std::move(key))...);
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) & {
+			tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value));
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) && {
+			tbl.traverse_set(std::get<I>(std::move(key))..., std::forward<T>(value));
+		}
+
+		auto setup_table(std::true_type) {
+			auto p = stack::probe_get_field<std::is_same_v<meta::unqualified_t<Table>, global_table>>(lua_state(), key, tbl.stack_index());
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+		bool is_valid(std::false_type) {
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same_v<meta::unqualified_t<Table>, global_table>>(lua_state(), key, lua_gettop(lua_state()));
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+	public:
+		Table tbl;
+		key_type key;
+
+		template <typename T>
+		table_proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {
+		}
+
+		template <typename T>
+		table_proxy& set(T&& item) & {
+			tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
+			return *this;
+		}
+
+		template <typename T>
+		table_proxy&& set(T&& item) && {
+			std::move(*this).tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
+			return std::move(*this);
+		}
+
+		template <typename... Args>
+		table_proxy& set_function(Args&&... args) & {
+			tbl.set_function(key, std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		table_proxy&& set_function(Args&&... args) && {
+			tbl.set_function(std::move(key), std::forward<Args>(args)...);
+			return std::move(*this);
+		}
+
+		template <typename T>
+		table_proxy& operator=(T&& other) & {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_invocable_v<Tu>) {
+				return set_function(std::forward<T>(other));
+			}
+			else {
+				return set(std::forward<T>(other));
+			}
+		}
+
+		template <typename T>
+		table_proxy&& operator=(T&& other) && {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_invocable_v<Tu> && !detail::is_msvc_callable_rigged_v<T>) {
+				return std::move(*this).set_function(std::forward<T>(other));
+			}
+			else {
+				return std::move(*this).set(std::forward<T>(other));
+			}
+		}
+
+		template <typename T>
+		table_proxy& operator=(std::initializer_list<T> other) & {
+			return set(std::move(other));
+		}
+
+		template <typename T>
+		table_proxy&& operator=(std::initializer_list<T> other) && {
+			return std::move(*this).set(std::move(other));
+		}
+
+		template <typename T>
+		bool is() const {
+			typedef decltype(get<T>()) U;
+			optional<U> option = this->get<optional<U>>();
+			return option.has_value();
+		}
+
+		template <typename T>
+		decltype(auto) get() const& {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return tuple_get<T>(idx_seq());
+		}
+
+		template <typename T>
+		decltype(auto) get() && {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return std::move(*this).template tuple_get<T>(idx_seq());
+		}
+
+		template <typename T>
+		decltype(auto) get_or(T&& otherwise) const {
+			typedef decltype(get<T>()) U;
+			optional<U> option = get<optional<U>>();
+			if (option) {
+				return static_cast<U>(option.value());
+			}
+			return static_cast<U>(std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename D>
+		decltype(auto) get_or(D&& otherwise) const {
+			optional<T> option = get<optional<T>>();
+			if (option) {
+				return static_cast<T>(option.value());
+			}
+			return static_cast<T>(std::forward<D>(otherwise));
+		}
+
+		template <typename T>
+		decltype(auto) get_or_create() {
+			return get_or_create<T>(new_table());
+		}
+
+		template <typename T, typename Otherwise>
+		decltype(auto) get_or_create(Otherwise&& other) {
+			if (!this->valid()) {
+				this->set(std::forward<Otherwise>(other));
+			}
+			return get<T>();
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) const& {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) & {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) && {
+			auto keys = meta::tuplefy(std::move(key), std::forward<K>(k));
+			return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+			lua_State* L = this->lua_state();
+			push(L);
+			int idx = lua_gettop(L);
+			stack_aligned_function func(L, idx);
+			return func.call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		bool valid() const {
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+		int push() const noexcept {
+			return push(this->lua_state());
+		}
+
+		int push(lua_State* L) const noexcept {
+			if constexpr (std::is_same_v<meta::unqualified_t<Table>, global_table> || is_stack_table_v<meta::unqualified_t<Table>>) {
+				auto pp = stack::push_pop<true>(tbl);
+				int tableindex = pp.index_of(tbl);
+				int top_index = lua_gettop(L);
+				stack::get_field<true>(lua_state(), key, tableindex);
+				lua_replace(L, top_index + 1);
+				lua_settop(L, top_index + 1);
+			}
+			else {
+				auto pp = stack::push_pop<false>(tbl);
+				int tableindex = pp.index_of(tbl);
+				int aftertableindex = lua_gettop(L);
+				stack::get_field<false>(lua_state(), key, tableindex);
+				lua_replace(L, tableindex);
+				lua_settop(L, aftertableindex + 1);
+			}
+			return 1;
+		}
+
+		type get_type() const {
+			type t = type::none;
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			if (p) {
+				t = type_of(lua_state(), -1);
+			}
+			lua_pop(lua_state(), p.levels);
+			return t;
+		}
+
+		lua_State* lua_state() const {
+			return tbl.lua_state();
+		}
+
+		table_proxy& force() {
+			if (!this->valid()) {
+				this->set(new_table());
+			}
+			return *this;
+		}
+	};
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator==(T&& left, const table_proxy<Table, Key>& right) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() == left;
+	}
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator==(const table_proxy<Table, Key>& right, T&& left) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() == left;
+	}
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator!=(T&& left, const table_proxy<Table, Key>& right) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() != left;
+	}
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator!=(const table_proxy<Table, Key>& right, T&& left) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() != left;
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator==(lua_nil_t, const table_proxy<Table, Key>& right) {
+		return !right.valid();
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator==(const table_proxy<Table, Key>& right, lua_nil_t) {
+		return !right.valid();
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator!=(lua_nil_t, const table_proxy<Table, Key>& right) {
+		return right.valid();
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator!=(const table_proxy<Table, Key>& right, lua_nil_t) {
+		return right.valid();
+	}
+
+	template <bool b>
+	template <typename Super>
+	basic_reference<b>& basic_reference<b>::operator=(proxy_base<Super>&& r) {
+		basic_reference<b> v = r;
+		this->operator=(std::move(v));
+		return *this;
+	}
+
+	template <bool b>
+	template <typename Super>
+	basic_reference<b>& basic_reference<b>::operator=(const proxy_base<Super>& r) {
+		basic_reference<b> v = r;
+		this->operator=(std::move(v));
+		return *this;
+	}
+
+	namespace stack {
+		template <typename Table, typename Key>
+		struct unqualified_pusher<table_proxy<Table, Key>> {
+			static int push(lua_State* L, const table_proxy<Table, Key>& p) {
+				return p.push(L);
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/table_proxy.hpp
+
+// beginning of sol/table_iterator.hpp
+
+#include <iterator>
+
+namespace sol {
+
+	template <typename reference_type>
+	class basic_table_iterator {
+	public:
+		typedef object key_type;
+		typedef object mapped_type;
+		typedef std::pair<object, object> value_type;
+		typedef std::input_iterator_tag iterator_category;
+		typedef std::ptrdiff_t difference_type;
+		typedef value_type* pointer;
+		typedef value_type& reference;
+		typedef const value_type& const_reference;
+
+	private:
+		std::pair<object, object> kvp;
+		reference_type ref;
+		int tableidx = 0;
+		int keyidx = 0;
+		std::ptrdiff_t idx = 0;
+
+	public:
+		basic_table_iterator() noexcept : keyidx(-1), idx(-1) {
+		}
+
+		basic_table_iterator(reference_type x) noexcept : ref(std::move(x)) {
+			ref.push();
+			tableidx = lua_gettop(ref.lua_state());
+			stack::push(ref.lua_state(), lua_nil);
+			this->operator++();
+			if (idx == -1) {
+				return;
+			}
+			--idx;
+		}
+
+		basic_table_iterator& operator++() noexcept {
+			if (idx == -1)
+				return *this;
+
+			if (lua_next(ref.lua_state(), tableidx) == 0) {
+				idx = -1;
+				keyidx = -1;
+				return *this;
+			}
+			++idx;
+			kvp.first = object(ref.lua_state(), -2);
+			kvp.second = object(ref.lua_state(), -1);
+			lua_pop(ref.lua_state(), 1);
+			// leave key on the stack
+			keyidx = lua_gettop(ref.lua_state());
+			return *this;
+		}
+
+		basic_table_iterator operator++(int) noexcept {
+			auto saved = *this;
+			this->operator++();
+			return saved;
+		}
+
+		reference operator*() const noexcept {
+			return const_cast<reference>(kvp);
+		}
+
+		bool operator==(const basic_table_iterator& right) const noexcept {
+			return idx == right.idx;
+		}
+
+		bool operator!=(const basic_table_iterator& right) const noexcept {
+			return idx != right.idx;
+		}
+
+		~basic_table_iterator() {
+			if (keyidx != -1) {
+				stack::remove(ref.lua_state(), keyidx, 1);
+			}
+			if (ref.lua_state() != nullptr && ref.valid()) {
+				stack::remove(ref.lua_state(), tableidx, 1);
+			}
+		}
+	};
+
+} // namespace sol
+
+// end of sol/table_iterator.hpp
+
+// beginning of sol/pairs_iterator.hpp
+
+// beginning of sol/stack/detail/pairs.hpp
+
+#include <optional>
+
+namespace sol { namespace stack { namespace stack_detail {
+
+	inline bool maybe_push_lua_next_function(lua_State* L_) {
+		stack::get_field<true, false>(L_, "next");
+		bool is_next = stack::check<protected_function>(L_);
+		if (is_next) {
+			return true;
+		}
+		stack::get_field<true, false>(L_, "table");
+		stack::record tracking{};
+		if (!stack::loose_table_check(L_, -1, &no_panic, tracking)) {
+			return false;
+		}
+		lua_getfield(L_, -1, "next");
+		bool is_table_next_func = stack::check<protected_function>(L_, -1);
+		if (is_table_next_func) {
+			return true;
+		}
+		lua_pop(L_, 1);
+		return false;
+	}
+
+	inline std::optional<protected_function> find_lua_next_function(lua_State* L_) {
+		if (maybe_push_lua_next_function(L_)) {
+			return stack::pop<protected_function>(L_);
+		}
+		return std::nullopt;
+	}
+
+	inline int c_lua_next(lua_State* L_) noexcept {
+		stack_reference table_stack_ref(L_, raw_index(1));
+		stateless_stack_reference key_stack_ref(L_, raw_index(2));
+		int result = lua_next(table_stack_ref.lua_state(), table_stack_ref.stack_index());
+		if (result == 0) {
+			stack::push(L_, lua_nil);
+			return 1;
+		}
+		return 2;
+	}
+
+	inline int readonly_pairs(lua_State* L_) noexcept {
+		int pushed = 0;
+		if (!maybe_push_lua_next_function(L_)) {
+			// we do not have the "next" function in the global namespace
+			// from the "table" global entiry, use our own
+			pushed += stack::push(L_, &c_lua_next);
+		}
+		else {
+			pushed += 1;
+		}
+		int metatable_exists = lua_getmetatable(L_, 1);
+		sol_c_assert(metatable_exists == 1);
+		const auto& index_key = to_string(sol::meta_function::index);
+		lua_getfield(L_, lua_gettop(L_), index_key.c_str());
+		lua_remove(L_, -2);
+		pushed += 1;
+		pushed += stack::push(L_, lua_nil);
+		return pushed;
+	}
+
+}}} // sol::stack::stack_detail
+
+// end of sol/stack/detail/pairs.hpp
+
+namespace sol {
+
+	struct pairs_sentinel { };
+
+	class pairs_iterator {
+	private:
+		inline static constexpr int empty_key_index = -1;
+
+	public:
+		using key_type = object;
+		using mapped_type = object;
+		using value_type = std::pair<object, object>;
+		using iterator_category = std::input_iterator_tag;
+		using difference_type = std::ptrdiff_t;
+		using pointer = value_type*;
+		using const_pointer = value_type const*;
+		using reference = value_type&;
+		using const_reference = const value_type&;
+
+		pairs_iterator() noexcept
+		: m_L(nullptr)
+		, m_next_function_ref(lua_nil)
+		, m_table_ref(lua_nil)
+		, m_cached_key_value_pair({ lua_nil, lua_nil })
+		, m_key_index(empty_key_index)
+		, m_iteration_index(0) {
+		}
+
+		pairs_iterator(const pairs_iterator&) = delete;
+		pairs_iterator& operator=(const pairs_iterator&) = delete;
+
+		pairs_iterator(pairs_iterator&& right) noexcept
+		: m_L(right.m_L)
+		, m_next_function_ref(std::move(right.m_next_function_ref))
+		, m_table_ref(std::move(right.m_table_ref))
+		, m_cached_key_value_pair(std::move(right.m_cached_key_value_pair))
+		, m_key_index(right.m_key_index)
+		, m_iteration_index(right.m_iteration_index) {
+			right.m_key_index = empty_key_index;
+		}
+
+		pairs_iterator& operator=(pairs_iterator&& right) noexcept {
+			m_L = right.m_L;
+			m_next_function_ref = std::move(right.m_next_function_ref);
+			m_table_ref = std::move(right.m_table_ref);
+			m_cached_key_value_pair = std::move(right.m_cached_key_value_pair);
+			m_key_index = right.m_key_index;
+			m_iteration_index = right.m_iteration_index;
+			right.m_key_index = empty_key_index;
+			return *this;
+		}
+
+		template <typename Source>
+		pairs_iterator(const Source& source_) noexcept : m_L(source_.lua_state()), m_key_index(empty_key_index), m_iteration_index(0) {
+			if (m_L == nullptr || !source_.valid()) {
+				m_key_index = empty_key_index;
+				return;
+			}
+			int source_index = -source_.push(m_L);
+			int abs_source_index = lua_absindex(m_L, source_index);
+			int metatable_exists = lua_getmetatable(m_L, abs_source_index);
+			lua_remove(m_L, abs_source_index);
+			if (metatable_exists == 1) {
+				// just has a metatable, but does it have __pairs ?
+				stack_reference metatable(m_L, raw_index(abs_source_index));
+				stack::get_field<is_global_table_v<Source>, true>(m_L, meta_function::pairs, metatable.stack_index());
+				optional<protected_function> maybe_pairs_function = stack::pop<optional<protected_function>>(m_L);
+				if (maybe_pairs_function.has_value()) {
+					protected_function& pairs_function = *maybe_pairs_function;
+					protected_function_result next_fn_and_table_and_first_key = pairs_function(source_);
+					if (next_fn_and_table_and_first_key.valid()) {
+						m_next_function_ref = next_fn_and_table_and_first_key.get<protected_function>(0);
+						m_table_ref = next_fn_and_table_and_first_key.get<sol::reference>(1);
+						m_key_index = next_fn_and_table_and_first_key.stack_index() - 1;
+						// remove next function and table
+						lua_remove(m_L, m_key_index);
+						lua_remove(m_L, m_key_index);
+						next_fn_and_table_and_first_key.abandon();
+						lua_remove(m_L, abs_source_index);
+						this->operator++();
+						m_iteration_index = 0;
+						return;
+					}
+				}
+			}
+
+			{
+				auto maybe_next = stack::stack_detail::find_lua_next_function(m_L);
+				if (maybe_next.has_value()) {
+					m_next_function_ref = std::move(*maybe_next);
+					m_table_ref = source_;
+
+					stack::push(m_L, lua_nil);
+					m_key_index = lua_gettop(m_L);
+					this->operator++();
+					m_iteration_index = 0;
+					return;
+				}
+			}
+
+			// okay, so none of the above worked and now we need to create
+			// a shim / polyfill instead
+			stack::push(m_L, &stack::stack_detail::c_lua_next);
+			m_next_function_ref = stack::pop<protected_function>(m_L);
+			m_table_ref = source_;
+			stack::push(m_L, lua_nil);
+			m_key_index = lua_gettop(m_L);
+			this->operator++();
+			m_iteration_index = 0;
+		}
+
+		pairs_iterator& operator++() {
+			if (m_key_index == empty_key_index) {
+				return *this;
+			}
+			{
+				sol::protected_function_result next_results = m_next_function_ref(m_table_ref, stack_reference(m_L, m_key_index));
+				if (!next_results.valid()) {
+					// TODO: abort, or throw an error?
+					m_clear();
+					m_key_index = empty_key_index;
+					return *this;
+				}
+				int next_results_count = next_results.return_count();
+				if (next_results_count < 2) {
+					// iteration is over!
+					next_results.abandon();
+					lua_settop(m_L, m_key_index - 1);
+					m_key_index = empty_key_index;
+					++m_iteration_index;
+					return *this;
+				}
+				else {
+					lua_remove(m_L, m_key_index);
+					m_key_index = next_results.stack_index() - 1;
+					m_cached_key_value_pair.first = stack::get<object>(m_L, m_key_index);
+					m_cached_key_value_pair.second = stack::get<object>(m_L, m_key_index + 1);
+					lua_settop(m_L, m_key_index);
+					next_results.abandon();
+				}
+			}
+			++m_iteration_index;
+			return *this;
+		}
+
+		std::ptrdiff_t index() const {
+			return static_cast<std::ptrdiff_t>(m_iteration_index);
+		}
+
+		const_reference operator*() const noexcept {
+			return m_cached_key_value_pair;
+		}
+
+		reference operator*() noexcept {
+			return m_cached_key_value_pair;
+		}
+
+		friend bool operator==(const pairs_iterator& left, const pairs_iterator& right) noexcept {
+			return left.m_table_ref == right.m_table_ref && left.m_iteration_index == right.m_iteration_index;
+		}
+
+		friend bool operator!=(const pairs_iterator& left, const pairs_iterator& right) noexcept {
+			return left.m_table_ref != right.m_table_ref || left.m_iteration_index != right.m_iteration_index;
+		}
+
+		friend bool operator==(const pairs_iterator& left, const pairs_sentinel&) noexcept {
+			return left.m_key_index == empty_key_index;
+		}
+
+		friend bool operator!=(const pairs_iterator& left, const pairs_sentinel&) noexcept {
+			return left.m_key_index != empty_key_index;
+		}
+
+		friend bool operator==(const pairs_sentinel&, const pairs_iterator& left) noexcept {
+			return left.m_key_index == empty_key_index;
+		}
+
+		friend bool operator!=(const pairs_sentinel&, const pairs_iterator& left) noexcept {
+			return left.m_key_index != empty_key_index;
+		}
+
+		~pairs_iterator() {
+			if (m_key_index != empty_key_index) {
+				m_clear();
+			}
+		}
+
+	private:
+		void m_clear() noexcept {
+			lua_remove(m_L, m_key_index);
+		}
+
+		lua_State* m_L;
+		protected_function m_next_function_ref;
+		sol::reference m_table_ref;
+		std::pair<object, object> m_cached_key_value_pair;
+		int m_key_index;
+		int m_iteration_index;
+	};
+
+	template <typename Source>
+	class basic_pairs_range {
+	private:
+		using source_t = std::add_lvalue_reference_t<Source>;
+		source_t m_source;
+
+	public:
+		using iterator = pairs_iterator;
+		using const_iterator = pairs_iterator;
+
+		basic_pairs_range(source_t source_) noexcept : m_source(source_) {
+		}
+
+		iterator begin() noexcept {
+			return iterator(m_source);
+		}
+
+		iterator begin() const noexcept {
+			return iterator(m_source);
+		}
+
+		const_iterator cbegin() const noexcept {
+			return const_iterator(m_source);
+		}
+
+		pairs_sentinel end() noexcept {
+			return {};
+		}
+
+		pairs_sentinel end() const noexcept {
+			return {};
+		}
+
+		pairs_sentinel cend() const noexcept {
+			return {};
+		}
+	};
+} // namespace sol
+
+// end of sol/pairs_iterator.hpp
+
+namespace sol {
+	namespace detail {
+		template <std::size_t n>
+		struct clean {
+			lua_State* L;
+			clean(lua_State* luastate) : L(luastate) {
+			}
+			~clean() {
+				lua_pop(L, static_cast<int>(n));
+			}
+		};
+
+		struct ref_clean {
+			lua_State* L;
+			int& pop_count;
+
+			ref_clean(lua_State* L_, int& pop_count_) noexcept : L(L_), pop_count(pop_count_) {
+			}
+			~ref_clean() {
+				lua_pop(L, static_cast<int>(pop_count));
+			}
+		};
+
+		inline int fail_on_newindex(lua_State* L_) {
+			return luaL_error(L_, "sol: cannot modify the elements of an enumeration table");
+		}
+
+	} // namespace detail
+
+	template <bool top_level, typename ref_t>
+	class basic_table_core : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+		friend class state;
+		friend class state_view;
+		template <typename, typename>
+		friend class basic_usertype;
+		template <typename>
+		friend class basic_metatable;
+
+		template <typename T>
+		using is_get_direct_tableless = meta::boolean<stack::stack_detail::is_get_direct_tableless_v<T, top_level, false>>;
+
+		template <typename T>
+		using is_raw_get_direct_tableless = std::false_type;
+
+		template <typename T>
+		using is_set_direct_tableless = meta::boolean<stack::stack_detail::is_set_direct_tableless_v<T, top_level, false>>;
+
+		template <typename T>
+		using is_raw_set_direct_tableless = std::false_type;
+
+		template <bool raw, typename... Ret, typename... Keys>
+		decltype(auto) tuple_get(int table_index, Keys&&... keys) const {
+			if constexpr (sizeof...(Ret) < 2) {
+				return traverse_get_single_maybe_tuple<raw, Ret...>(table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				using multi_ret = decltype(stack::pop<std::tuple<Ret...>>(nullptr));
+				return multi_ret(traverse_get_single_maybe_tuple<raw, Ret>(table_index, std::forward<Keys>(keys))...);
+			}
+		}
+
+		template <bool raw, typename Ret, size_t... I, typename Key>
+		decltype(auto) traverse_get_single_tuple(int table_index, std::index_sequence<I...>, Key&& key) const {
+			return traverse_get_single<raw, Ret>(table_index, std::get<I>(std::forward<Key>(key))...);
+		}
+
+		template <bool raw, typename Ret, typename Key>
+		decltype(auto) traverse_get_single_maybe_tuple(int table_index, Key&& key) const {
+			if constexpr (meta::is_tuple_v<meta::unqualified_t<Key>>) {
+				return traverse_get_single_tuple<raw, Ret>(
+				     table_index, std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<Key>>>(), std::forward<Key>(key));
+			}
+			else {
+				return traverse_get_single<raw, Ret>(table_index, std::forward<Key>(key));
+			}
+		}
+
+		template <bool raw, typename Ret, typename... Keys>
+		decltype(auto) traverse_get_single(int table_index, Keys&&... keys) const {
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_get_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			if constexpr (meta::is_optional_v<meta::unqualified_t<Ret>>) {
+				int popcount = 0;
+				detail::ref_clean c(base_t::lua_state(), popcount);
+				return traverse_get_deep_optional<global, raw, detail::insert_mode::none, Ret>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				detail::clean<sizeof...(Keys) - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>> c(base_t::lua_state());
+				return traverse_get_deep<global, raw, detail::insert_mode::none, Ret>(table_index, std::forward<Keys>(keys)...);
+			}
+		}
+
+		template <bool raw, typename Pairs, std::size_t... I>
+		void tuple_set(std::index_sequence<I...>, Pairs&& pairs) {
+			constexpr static bool global = (meta::count_even_for_pack_v < is_set_direct_tableless,
+			     meta::unqualified_t<decltype(std::get<I * 2>(std::forward<Pairs>(pairs)))>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			(void)table_index;
+			(void)L;
+			void(detail::swallow { (stack::set_field<(top_level), raw>(
+			                             L, std::get<I * 2>(std::forward<Pairs>(pairs)), std::get<I * 2 + 1>(std::forward<Pairs>(pairs)), table_index),
+			     0)... });
+		}
+
+		template <bool global, bool raw, detail::insert_mode mode, typename T, typename Key, typename... Keys>
+		decltype(auto) traverse_get_deep(int table_index, Key&& key, Keys&&... keys) const {
+			if constexpr (std::is_same_v<meta::unqualified_t<Key>, create_if_nil_t>) {
+				(void)key;
+				return traverse_get_deep<false, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil), T>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				lua_State* L = base_t::lua_state();
+				stack::get_field<global, raw>(L, std::forward<Key>(key), table_index);
+				if constexpr (sizeof...(Keys) > 0) {
+					if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+						type t = type_of(L, -1);
+						if (t == type::lua_nil || t == type::none) {
+							lua_pop(L, 1);
+							stack::push(L, new_table(0, 0));
+						}
+					}
+					return traverse_get_deep<false, raw, mode, T>(lua_gettop(L), std::forward<Keys>(keys)...);
+				}
+				else {
+					if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+						type t = type_of(L, -1);
+						if ((t == type::lua_nil || t == type::none) && (is_table_like_v<T>)) {
+							lua_pop(L, 1);
+							stack::push(L, new_table(0, 0));
+						}
+					}
+					return stack::get<T>(L);
+				}
+			}
+		}
+
+		template <bool global, bool raw, detail::insert_mode mode, typename T, typename Key, typename... Keys>
+		decltype(auto) traverse_get_deep_optional(int& popcount, int table_index, Key&& key, Keys&&... keys) const {
+			if constexpr (std::is_same_v<meta::unqualified_t<Key>, create_if_nil_t>) {
+				constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil);
+				(void)key;
+				return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<meta::unqualified_t<Key>, update_if_empty_t>) {
+				constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::update_if_empty);
+				(void)key;
+				return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<meta::unqualified_t<Key>, override_value_t>) {
+				constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::override_value);
+				(void)key;
+				return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				if constexpr (sizeof...(Keys) > 0) {
+					lua_State* L = base_t::lua_state();
+					auto p = stack::probe_get_field<global, raw>(L, std::forward<Key>(key), table_index);
+					popcount += p.levels;
+					if (!p.success) {
+						if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+							lua_pop(L, 1);
+							constexpr bool is_seq = meta::count_for_to_pack_v < 1, std::is_integral, Keys... >> 0;
+							stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+							stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+						}
+						else {
+							return T(nullopt);
+						}
+					}
+					return traverse_get_deep_optional<false, raw, mode, T>(popcount, lua_gettop(L), std::forward<Keys>(keys)...);
+				}
+				else {
+					using R = decltype(stack::get<T>(nullptr));
+					using value_type = typename meta::unqualified_t<R>::value_type;
+					lua_State* L = base_t::lua_state();
+					auto p = stack::probe_get_field<global, raw, value_type>(L, key, table_index);
+					popcount += p.levels;
+					if (!p.success) {
+						if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+							lua_pop(L, 1);
+							stack::push(L, new_table(0, 0));
+							stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+							if (stack::check<value_type>(L, lua_gettop(L), &no_panic)) {
+								return stack::get<T>(L);
+							}
+						}
+						return R(nullopt);
+					}
+					return stack::get<T>(L);
+				}
+			}
+		}
+
+		template <bool global, bool raw, detail::insert_mode mode, typename Key, typename... Keys>
+		void traverse_set_deep(int table_index, Key&& key, Keys&&... keys) const {
+			using KeyU = meta::unqualified_t<Key>;
+			if constexpr (std::is_same_v<KeyU, update_if_empty_t>) {
+				(void)key;
+				traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::update_if_empty)>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<KeyU, create_if_nil_t>) {
+				(void)key;
+				traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil)>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<KeyU, override_value_t>) {
+				(void)key;
+				traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::override_value)>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				lua_State* L = base_t::lua_state();
+				if constexpr (sizeof...(Keys) == 1) {
+					if constexpr ((mode & detail::insert_mode::update_if_empty) == detail::insert_mode::update_if_empty) {
+						auto p = stack::probe_get_field<global, raw>(L, key, table_index);
+						lua_pop(L, p.levels);
+						if (!p.success) {
+							stack::set_field<global, raw>(L, std::forward<Key>(key), std::forward<Keys>(keys)..., table_index);
+						}
+					}
+					else {
+						stack::set_field<global, raw>(L, std::forward<Key>(key), std::forward<Keys>(keys)..., table_index);
+					}
+				}
+				else {
+					if constexpr (mode != detail::insert_mode::none) {
+						stack::get_field<global, raw>(L, key, table_index);
+						type vt = type_of(L, -1);
+						if constexpr ((mode & detail::insert_mode::update_if_empty) == detail::insert_mode::update_if_empty
+						     || (mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+							if (vt == type::lua_nil || vt == type::none) {
+								constexpr bool is_seq = meta::count_for_to_pack_v < 1, std::is_integral, Keys... >> 0;
+								lua_pop(L, 1);
+								stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+								stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+							}
+						}
+						else {
+							if (vt != type::table) {
+								constexpr bool is_seq = meta::count_for_to_pack_v < 1, std::is_integral, Keys... >> 0;
+								lua_pop(L, 1);
+								stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+								stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+							}
+						}
+					}
+					else {
+						stack::get_field<global, raw>(L, std::forward<Key>(key), table_index);
+					}
+					traverse_set_deep<false, raw, mode>(lua_gettop(L), std::forward<Keys>(keys)...);
+				}
+			}
+		}
+
+	protected:
+		basic_table_core(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+		}
+		basic_table_core(detail::no_safety_tag, lua_State* L, int index) : base_t(L, index) {
+		}
+		basic_table_core(detail::no_safety_tag, lua_State* L, ref_index index) : base_t(L, index) {
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<ref_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(detail::no_safety_tag, lua_State* L, T&& r) noexcept : base_t(L, std::forward<T>(r)) {
+		}
+
+	public:
+		using iterator = basic_table_iterator<ref_t>;
+		using const_iterator = iterator;
+
+		using base_t::lua_state;
+
+		basic_table_core() noexcept = default;
+		basic_table_core(const basic_table_core&) = default;
+		basic_table_core(basic_table_core&&) = default;
+		basic_table_core& operator=(const basic_table_core&) = default;
+		basic_table_core& operator=(basic_table_core&&) = default;
+
+		basic_table_core(const stack_reference& r) : basic_table_core(r.lua_state(), r.stack_index()) {
+		}
+
+		basic_table_core(stack_reference&& r) : basic_table_core(r.lua_state(), r.stack_index()) {
+		}
+
+		template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			constructor_handler handler {};
+			stack::check<basic_table_core>(lua_state(), table_index, handler);
+#endif // Safety
+		}
+
+		basic_table_core(lua_State* L, const new_table& nt) : base_t(L, -stack::push(L, nt)) {
+			if (!is_stack_based<meta::unqualified_t<ref_t>>::value) {
+				lua_pop(L, 1);
+			}
+		}
+
+		basic_table_core(lua_State* L, int index = -1) : basic_table_core(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_table_core>(L, index, handler);
+#endif // Safety
+		}
+
+		basic_table_core(lua_State* L, ref_index index) : basic_table_core(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			constructor_handler handler {};
+			stack::check<basic_table_core>(lua_state(), table_index, handler);
+#endif // Safety
+		}
+
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<ref_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(T&& r) noexcept : basic_table_core(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_table<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				int table_index = pp.index_of(*this);
+				constructor_handler handler {};
+				stack::check<basic_table_core>(lua_state(), table_index, handler);
+			}
+#endif // Safety
+		}
+
+		basic_table_core(lua_nil_t r) noexcept : basic_table_core(detail::no_safety, r) {
+		}
+
+		basic_table_core(lua_State* L, global_tag_t t) noexcept : base_t(L, t) {
+		}
+
+		iterator begin() const {
+			if (this->get_type() == type::table) {
+				return iterator(*this);
+			}
+			return iterator();
+		}
+
+		iterator end() const {
+			return iterator();
+		}
+
+		const_iterator cbegin() const {
+			return begin();
+		}
+
+		const_iterator cend() const {
+			return end();
+		}
+
+		basic_pairs_range<basic_table_core> pairs() noexcept {
+			return basic_pairs_range<basic_table_core>(*this);
+		}
+
+		basic_pairs_range<const basic_table_core> pairs() const noexcept {
+			return basic_pairs_range<const basic_table_core>(*this);
+		}
+
+		void clear() {
+			auto pp = stack::push_pop<false>(*this);
+			int table_index = pp.index_of(*this);
+			stack::clear(lua_state(), table_index);
+		}
+
+		template <typename... Ret, typename... Keys>
+		decltype(auto) get(Keys&&... keys) const {
+			static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
+			constexpr static bool global = meta::all<meta::boolean<top_level>, is_get_direct_tableless<meta::unqualified_t<Keys>>...>::value;
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return tuple_get<false, Ret...>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename T, typename Key>
+		decltype(auto) get_or(Key&& key, T&& otherwise) const {
+			typedef decltype(get<T>("")) U;
+			optional<U> option = get<optional<U>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<U>(option.value());
+			}
+			return static_cast<U>(std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename Key, typename D>
+		decltype(auto) get_or(Key&& key, D&& otherwise) const {
+			optional<T> option = get<optional<T>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<T>(option.value());
+			}
+			return static_cast<T>(std::forward<D>(otherwise));
+		}
+
+		template <typename T, typename... Keys>
+		decltype(auto) traverse_get(Keys&&... keys) const {
+			static_assert(sizeof...(Keys) > 0, "must pass at least 1 key to get");
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_get_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return traverse_get_single<false, T>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename... Keys>
+		basic_table_core& traverse_set(Keys&&... keys) {
+			static_assert(sizeof...(Keys) > 1, "must pass at least 1 key and 1 value to set");
+			constexpr static bool global
+			     = (meta::count_when_for_to_pack_v < detail::is_not_insert_mode, 1, is_set_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			auto pn = stack::pop_n(L, static_cast<int>(sizeof...(Keys) - 2 - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>));
+			traverse_set_deep<top_level, false, detail::insert_mode::none>(table_index, std::forward<Keys>(keys)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		basic_table_core& set(Args&&... args) {
+			if constexpr (sizeof...(Args) == 2) {
+				traverse_set(std::forward<Args>(args)...);
+			}
+			else {
+				tuple_set<false>(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+			}
+			return *this;
+		}
+
+		template <typename... Ret, typename... Keys>
+		decltype(auto) raw_get(Keys&&... keys) const {
+			static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_raw_get_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return tuple_get<true, Ret...>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename T, typename Key>
+		decltype(auto) raw_get_or(Key&& key, T&& otherwise) const {
+			typedef decltype(raw_get<T>("")) U;
+			optional<U> option = raw_get<optional<U>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<U>(option.value());
+			}
+			return static_cast<U>(std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename Key, typename D>
+		decltype(auto) raw_get_or(Key&& key, D&& otherwise) const {
+			optional<T> option = raw_get<optional<T>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<T>(option.value());
+			}
+			return static_cast<T>(std::forward<D>(otherwise));
+		}
+
+		template <typename T, typename... Keys>
+		decltype(auto) traverse_raw_get(Keys&&... keys) const {
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_raw_get_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return traverse_get_single<true, T>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename... Keys>
+		basic_table_core& traverse_raw_set(Keys&&... keys) {
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_raw_set_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			lua_State* L = base_t::lua_state();
+			auto pn = stack::pop_n(L, static_cast<int>(sizeof...(Keys) - 2 - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>));
+			traverse_set_deep<top_level, true, false>(std::forward<Keys>(keys)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		basic_table_core& raw_set(Args&&... args) {
+			tuple_set<true>(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+			return *this;
+		}
+
+		template <typename Class, typename Key>
+		usertype<Class> new_usertype(Key&& key);
+
+		template <typename Class, typename Key, automagic_flags enrollment_flags>
+		usertype<Class> new_usertype(Key&& key, constant_automagic_enrollments<enrollment_flags> enrollment);
+
+		template <typename Class, typename Key>
+		usertype<Class> new_usertype(Key&& key, automagic_enrollments enrollment);
+
+		template <typename Class, typename Key, typename Arg, typename... Args,
+		     typename = std::enable_if_t<!std::is_base_of_v<automagic_enrollments, meta::unqualified_t<Arg>>>>
+		usertype<Class> new_usertype(Key&& key, Arg&& arg, Args&&... args);
+
+		template <bool read_only = true, typename... Args>
+		table new_enum(const string_view& name, Args&&... args) {
+			table target = create_with(std::forward<Args>(args)...);
+			if constexpr (read_only) {
+				// Need to create a special iterator to handle this
+				table x
+				     = create_with(meta_function::new_index, detail::fail_on_newindex, meta_function::index, target, meta_function::pairs, stack::stack_detail::readonly_pairs);
+				table shim = create_named(name, metatable_key, x);
+				return shim;
+			}
+			else {
+				set(name, target);
+				return target;
+			}
+		}
+
+		template <typename T, bool read_only = true>
+		table new_enum(const string_view& name, std::initializer_list<std::pair<string_view, T>> items) {
+			table target = create(static_cast<int>(items.size()), static_cast<int>(0));
+			for (const auto& kvp : items) {
+				target.set(kvp.first, kvp.second);
+			}
+			if constexpr (read_only) {
+				table x = create_with(meta_function::new_index, detail::fail_on_newindex, meta_function::index, target);
+				table shim = create_named(name, metatable_key, x);
+				return shim;
+			}
+			else {
+				set(name, target);
+				return target;
+			}
+		}
+
+		template <typename Key = object, typename Value = object, typename Fx>
+		void for_each(Fx&& fx) const {
+			lua_State* L = base_t::lua_state();
+			if constexpr (std::is_invocable_v<Fx, Key, Value>) {
+				auto pp = stack::push_pop(*this);
+				int table_index = pp.index_of(*this);
+				stack::push(L, lua_nil);
+				while (lua_next(L, table_index)) {
+					Key key(L, -2);
+					Value value(L, -1);
+					auto pn = stack::pop_n(L, 1);
+					fx(key, value);
+				}
+			}
+			else {
+				auto pp = stack::push_pop(*this);
+				int table_index = pp.index_of(*this);
+				stack::push(L, lua_nil);
+				while (lua_next(L, table_index)) {
+					Key key(L, -2);
+					Value value(L, -1);
+					auto pn = stack::pop_n(L, 1);
+					std::pair<Key&, Value&> keyvalue(key, value);
+					fx(keyvalue);
+				}
+			}
+		}
+
+		size_t size() const {
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			lua_len(L, table_index);
+			return stack::pop<size_t>(L);
+		}
+
+		bool empty() const {
+			return cbegin() == cend();
+		}
+
+		template <typename T>
+		auto operator[](T&& key) & {
+			return table_proxy<basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
+		}
+
+		template <typename T>
+		auto operator[](T&& key) const& {
+			return table_proxy<const basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
+		}
+
+		template <typename T>
+		auto operator[](T&& key) && {
+			return table_proxy<basic_table_core, detail::proxy_key_t<T>>(std::move(*this), std::forward<T>(key));
+		}
+
+		template <typename Sig, typename Key, typename... Args>
+		basic_table_core& set_function(Key&& key, Args&&... args) {
+			set_fx(types<Sig>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Key, typename... Args>
+		basic_table_core& set_function(Key&& key, Args&&... args) {
+			set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		basic_table_core& add(Args&&... args) {
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			(void)detail::swallow { 0, (stack::stack_detail::raw_table_set(L, std::forward<Args>(args), table_index), 0)... };
+			return *this;
+		}
+
+	private:
+		template <typename R, typename... Args, typename Fx, typename Key, typename = std::invoke_result_t<Fx, Args...>>
+		void set_fx(types<R(Args...)>, Key&& key, Fx&& fx) {
+			set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, meta::enable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx) {
+			set(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, typename... Args,
+		     meta::disable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
+		}
+
+		template <typename... Sig, typename... Args, typename Key>
+		void set_resolved_function(Key&& key, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
+		}
+
+	public:
+		static inline table create(lua_State* L, int narr = 0, int nrec = 0) {
+			lua_createtable(L, narr, nrec);
+			table result(L);
+			lua_pop(L, 1);
+			return result;
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		static inline table create(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			lua_createtable(L, narr, nrec);
+			table result(L);
+			result.set(std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+			lua_pop(L, 1);
+			return result;
+		}
+
+		template <typename... Args>
+		static inline table create_with(lua_State* L, Args&&... args) {
+			static_assert(sizeof...(Args) % 2 == 0, "You must have an even number of arguments for a key, value ... list.");
+			constexpr int narr = static_cast<int>(meta::count_odd_for_pack_v<std::is_integral, Args...>);
+			return create(L, narr, static_cast<int>((sizeof...(Args) / 2) - narr), std::forward<Args>(args)...);
+		}
+
+		table create(int narr = 0, int nrec = 0) {
+			return create(base_t::lua_state(), narr, nrec);
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		table create(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename Name>
+		table create(Name&& name, int narr = 0, int nrec = 0) {
+			table x = create(base_t::lua_state(), narr, nrec);
+			this->set(std::forward<Name>(name), x);
+			return x;
+		}
+
+		template <typename Name, typename Key, typename Value, typename... Args>
+		table create(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			table x = create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+			this->set(std::forward<Name>(name), x);
+			return x;
+		}
+
+		template <typename... Args>
+		table create_with(Args&&... args) {
+			return create_with(base_t::lua_state(), std::forward<Args>(args)...);
+		}
+
+		template <typename Name, typename... Args>
+		table create_named(Name&& name, Args&&... args) {
+			static const int narr = static_cast<int>(meta::count_even_for_pack_v<std::is_integral, Args...>);
+			return create(std::forward<Name>(name), narr, (sizeof...(Args) / 2) - narr, std::forward<Args>(args)...);
+		}
+	};
+} // namespace sol
+
+// end of sol/table_core.hpp
+
+namespace sol {
+
+	template <typename base_type>
+	class basic_metatable : public basic_table<base_type> {
+		typedef basic_table<base_type> base_t;
+		friend class state;
+		friend class state_view;
+
+	protected:
+		basic_metatable(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+		}
+		basic_metatable(detail::no_safety_tag, lua_State* L, int index) : base_t(L, index) {
+		}
+		basic_metatable(detail::no_safety_tag, lua_State* L, ref_index index) : base_t(L, index) {
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_metatable>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(detail::no_safety_tag, lua_State* L, T&& r) noexcept : base_t(L, std::forward<T>(r)) {
+		}
+
+		template <typename R, typename... Args, typename Fx, typename Key, typename = std::invoke_result_t<Fx, Args...>>
+		void set_fx(types<R(Args...)>, Key&& key, Fx&& fx) {
+			set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, meta::enable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx) {
+			set(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, typename... Args,
+		     meta::disable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
+		}
+
+		template <typename... Sig, typename... Args, typename Key>
+		void set_resolved_function(Key&& key, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
+		}
+
+	public:
+		using base_t::lua_state;
+
+		basic_metatable() noexcept = default;
+		basic_metatable(const basic_metatable&) = default;
+		basic_metatable(basic_metatable&&) = default;
+		basic_metatable& operator=(const basic_metatable&) = default;
+		basic_metatable& operator=(basic_metatable&&) = default;
+		basic_metatable(const stack_reference& r) : basic_metatable(r.lua_state(), r.stack_index()) {
+		}
+		basic_metatable(stack_reference&& r) : basic_metatable(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_metatable>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_metatable(lua_State* L, int index = -1) : basic_metatable(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_metatable>(L, index, handler);
+#endif // Safety
+		}
+		basic_metatable(lua_State* L, ref_index index) : basic_metatable(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_metatable>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_metatable>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(T&& r) noexcept : basic_metatable(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_table<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_metatable>(base_t::lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_metatable(lua_nil_t r) noexcept : basic_metatable(detail::no_safety, r) {
+		}
+
+		template <typename Key, typename Value>
+		basic_metatable<base_type>& set(Key&& key, Value&& value);
+
+		template <typename Sig, typename Key, typename... Args>
+		basic_metatable& set_function(Key&& key, Args&&... args) {
+			set_fx(types<Sig>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Key, typename... Args>
+		basic_metatable& set_function(Key&& key, Args&&... args) {
+			set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		void unregister() {
+			using ustorage_base = u_detail::usertype_storage_base;
+
+			lua_State* L = this->lua_state();
+
+			auto pp = stack::push_pop(*this);
+			int top = lua_gettop(L);
+
+			stack_reference mt(L, -1);
+			stack::get_field(L, meta_function::gc_names, mt.stack_index());
+			if (type_of(L, -1) != type::table) {
+				lua_settop(L, top);
+				return;
+			}
+			stack_reference gc_names_table(L, -1);
+			stack::get_field(L, meta_function::storage, mt.stack_index());
+			if (type_of(L, -1) != type::lightuserdata) {
+				lua_settop(L, top);
+				return;
+			}
+			ustorage_base& base_storage = *static_cast<ustorage_base*>(stack::get<void*>(L, -1));
+			std::array<string_view, 6> registry_traits;
+			for (std::size_t i = 0; i < registry_traits.size(); ++i) {
+				u_detail::submetatable_type smt = static_cast<u_detail::submetatable_type>(i);
+				stack::get_field<false, true>(L, smt, gc_names_table.stack_index());
+				registry_traits[i] = stack::get<string_view>(L, -1);
+			}
+
+			// get the registry
+			stack_reference registry(L, raw_index(LUA_REGISTRYINDEX));
+			registry.push();
+			// eliminate all named entries for this usertype
+			// in the registry (luaL_newmetatable does
+			// [name] = new table
+			// in registry upon creation)
+			for (std::size_t i = 0; i < registry_traits.size(); ++i) {
+				u_detail::submetatable_type smt = static_cast<u_detail::submetatable_type>(i);
+				const string_view& gcmetakey = registry_traits[i];
+				if (smt == u_detail::submetatable_type::named) {
+					// use .data() to make it treat it like a c string,
+					// which it is...
+					stack::set_field<true>(L, gcmetakey.data(), lua_nil);
+				}
+				else {
+					// do not change the values in the registry: they need to be present
+					// no matter what, for safety's sake
+					// stack::set_field(L, gcmetakey, lua_nil, registry.stack_index());
+				}
+			}
+
+			// destroy all storage and tables
+			base_storage.clear();
+
+			// 6 strings from gc_names table,
+			// + 1 registry,
+			// + 1 gc_names table
+			// + 1 light userdata of storage
+			// + 1 registry
+			// 10 total, 4 left since popping off 6 gc_names tables
+			lua_settop(L, top);
+		}
+	};
+
+} // namespace sol
+
+// end of sol/metatable.hpp
+
+namespace sol {
+
+	template <typename T, typename base_type>
+	class basic_usertype : private basic_metatable<base_type> {
+	private:
+		using base_t = basic_metatable<base_type>;
+		using table_base_t = basic_table<base_type>;
+
+		template <typename>
+		friend class basic_metatable;
+
+		template <bool, typename>
+		friend class basic_table_core;
+
+		template <std::size_t... I, typename... Args>
+		void tuple_set(std::index_sequence<I...>, std::tuple<Args...>&& args) {
+			(void)args;
+			(void)detail::swallow { 0, (this->set(std::get<I * 2>(std::move(args)), std::get<I * 2 + 1>(std::move(args))), 0)... };
+		}
+
+		template <typename R, typename... Args, typename Fx, typename Key, typename = std::invoke_result_t<Fx, Args...>>
+		void set_fx(types<R(Args...)>, Key&& key, Fx&& fx) {
+			set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, meta::enable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx) {
+			set(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, typename... Args,
+		     meta::disable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
+		}
+
+		template <typename... Sig, typename... Args, typename Key>
+		void set_resolved_function(Key&& key, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
+		}
+
+	public:
+		using base_t::base_t;
+
+		using base_t::get;
+		using base_t::lua_state;
+		using base_t::pop;
+		using base_t::push;
+		using base_t::traverse_get;
+		using base_t::traverse_set;
+		using base_t::unregister;
+
+		template <typename Key, typename Value>
+		basic_usertype& set(Key&& key, Value&& value) {
+			optional<u_detail::usertype_storage<T>&> maybe_uts = u_detail::maybe_get_usertype_storage<T>(this->lua_state());
+			if (maybe_uts) {
+				u_detail::usertype_storage<T>& uts = *maybe_uts;
+				uts.set(this->lua_state(), std::forward<Key>(key), std::forward<Value>(value));
+			}
+			else {
+				using ValueU = meta::unqualified_t<Value>;
+				// cannot get metatable: try regular table set?
+				if constexpr (detail::is_non_factory_constructor_v<ValueU> || detail::is_policy_v<ValueU>) {
+					// tag constructors so we don't get destroyed by lack of info
+					table_base_t::set(std::forward<Key>(key), detail::tagged<T, Value>(std::forward<Value>(value)));
+				}
+				else {
+					table_base_t::set(std::forward<Key>(key), std::forward<Value>(value));
+				}
+			}
+			return *this;
+		}
+
+		template <typename Sig, typename Key, typename... Args>
+		basic_usertype& set_function(Key&& key, Args&&... args) {
+			set_fx(types<Sig>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Key, typename... Args>
+		basic_usertype& set_function(Key&& key, Args&&... args) {
+			set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Key>
+		usertype_proxy<basic_usertype&, std::decay_t<Key>> operator[](Key&& key) {
+			return usertype_proxy<basic_usertype&, std::decay_t<Key>>(*this, std::forward<Key>(key));
+		}
+
+		template <typename Key>
+		usertype_proxy<const basic_usertype&, std::decay_t<Key>> operator[](Key&& key) const {
+			return usertype_proxy<const basic_usertype&, std::decay_t<Key>>(*this, std::forward<Key>(key));
+		}
+	};
+
+} // namespace sol
+
+// end of sol/usertype.hpp
+
+// beginning of sol/table.hpp
+
+// beginning of sol/lua_table.hpp
+
+namespace sol {
+
+	template <typename ref_t>
+	struct basic_lua_table : basic_table_core<false, ref_t> {
+	private:
+		using base_t = basic_table_core<false, ref_t>;
+
+		friend class state;
+		friend class state_view;
+
+	public:
+		using base_t::lua_state;
+
+		basic_lua_table() noexcept = default;
+		basic_lua_table(const basic_lua_table&) = default;
+		basic_lua_table(basic_lua_table&&) = default;
+		basic_lua_table& operator=(const basic_lua_table&) = default;
+		basic_lua_table& operator=(basic_lua_table&&) = default;
+		basic_lua_table(const stack_reference& r) : basic_lua_table(r.lua_state(), r.stack_index()) {
+		}
+		basic_lua_table(stack_reference&& r) : basic_lua_table(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lua_table(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_lua_table>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_lua_table(lua_State* L, const new_table& nt) : base_t(L, nt) {
+			if (!is_stack_based<meta::unqualified_t<ref_t>>::value) {
+				lua_pop(L, 1);
+			}
+		}
+		basic_lua_table(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_lua_table>(L, index, handler);
+#endif // Safety
+		}
+		basic_lua_table(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_lua_table>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_lua_table>>, meta::neg<std::is_same<ref_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lua_table(T&& r) noexcept : basic_lua_table(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_table<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_lua_table>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_lua_table(lua_nil_t r) noexcept : basic_lua_table(detail::no_safety, r) {
+		}
+	};
+
+} // namespace sol
+
+// end of sol/lua_table.hpp
+
+namespace sol {
+	typedef table_core<false> table;
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key) {
+		constant_automagic_enrollments<> enrollments {};
+		return this->new_usertype<Class>(std::forward<Key>(key), std::move(enrollments));
+	}
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key, automagic_flags enrollment_flags>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, constant_automagic_enrollments<enrollment_flags> enrollments) {
+		int mt_index = u_detail::register_usertype<Class, enrollment_flags>(this->lua_state(), std::move(enrollments));
+		usertype<Class> mt(this->lua_state(), -mt_index);
+		lua_pop(this->lua_state(), 1);
+		set(std::forward<Key>(key), mt);
+		return mt;
+	}
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, automagic_enrollments enrollments) {
+		int mt_index = u_detail::register_usertype<Class, automagic_flags::all>(this->lua_state(), std::move(enrollments));
+		usertype<Class> mt(this->lua_state(), -mt_index);
+		lua_pop(this->lua_state(), 1);
+		set(std::forward<Key>(key), mt);
+		return mt;
+	}
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key, typename Arg, typename... Args, typename>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, Arg&& arg, Args&&... args) {
+		constexpr automagic_flags enrollment_flags = meta::any_same_v<no_construction, meta::unqualified_t<Arg>, meta::unqualified_t<Args>...>
+		     ? clear_flags(automagic_flags::all, automagic_flags::default_constructor)
+		     : automagic_flags::all;
+		constant_automagic_enrollments<enrollment_flags> enrollments;
+		enrollments.default_constructor = !detail::any_is_constructor_v<Arg, Args...>;
+		enrollments.destructor = !detail::any_is_destructor_v<Arg, Args...>;
+		usertype<Class> ut = this->new_usertype<Class>(std::forward<Key>(key), std::move(enrollments));
+		static_assert(sizeof...(Args) % 2 == static_cast<std::size_t>(!detail::any_is_constructor_v<Arg>),
+		     "you must pass an even number of arguments to new_usertype after first passing a constructor");
+		if constexpr (detail::any_is_constructor_v<Arg>) {
+			ut.set(meta_function::construct, std::forward<Arg>(arg));
+			ut.tuple_set(std::make_index_sequence<(sizeof...(Args)) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+		}
+		else {
+			ut.tuple_set(std::make_index_sequence<(sizeof...(Args) + 1) / 2>(), std::forward_as_tuple(std::forward<Arg>(arg), std::forward<Args>(args)...));
+		}
+		return ut;
+	}
+
+	template <typename base_type>
+	template <typename Key, typename Value>
+	basic_metatable<base_type>& basic_metatable<base_type>::set(Key&& key, Value&& value) {
+		this->push();
+		lua_State* L = this->lua_state();
+		int target = lua_gettop(L);
+		optional<u_detail::usertype_storage_base&> maybe_uts = nullopt;
+		maybe_uts = u_detail::maybe_get_usertype_storage_base(L, target);
+		if (maybe_uts) {
+			u_detail::usertype_storage_base& uts = *maybe_uts;
+			uts.set(L, std::forward<Key>(key), std::forward<Value>(value));
+			return *this;
+		}
+		else {
+			base_t::set(std::forward<Key>(key), std::forward<Value>(value));
+		}
+		this->pop();
+		return *this;
+	}
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<metatable_key_t> {
+			static metatable get(lua_State* L, int index = -1) {
+				if (lua_getmetatable(L, index) == 0) {
+					return metatable(L, ref_index(LUA_REFNIL));
+				}
+				return metatable(L, -1);
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/table.hpp
+
+// beginning of sol/state.hpp
+
+// beginning of sol/state_view.hpp
+
+// beginning of sol/environment.hpp
+
+namespace sol {
+
+	template <typename base_type>
+	struct basic_environment : basic_table<base_type> {
+	private:
+		typedef basic_table<base_type> base_t;
+
+	public:
+		using base_t::lua_state;
+
+		basic_environment() noexcept = default;
+		basic_environment(const basic_environment&) = default;
+		basic_environment(basic_environment&&) = default;
+		basic_environment& operator=(const basic_environment&) = default;
+		basic_environment& operator=(basic_environment&&) = default;
+		basic_environment(const stack_reference& r) : basic_environment(r.lua_state(), r.stack_index()) {
+		}
+		basic_environment(stack_reference&& r) : basic_environment(r.lua_state(), r.stack_index()) {
+		}
+
+		basic_environment(lua_State* L, new_table nt) : base_t(L, std::move(nt)) {
+		}
+		template <bool b>
+		basic_environment(lua_State* L, new_table t, const basic_reference<b>& fallback) : basic_environment(L, std::move(t)) {
+			stack_table mt(L, new_table(0, 1));
+			mt.set(meta_function::index, fallback);
+			this->set(metatable_key, mt);
+			mt.pop();
+		}
+
+		basic_environment(env_key_t, const stack_reference& extraction_target)
+		: base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<env_key_t>(this->lua_state(), -1, handler);
+#endif // Safety
+			lua_pop(this->lua_state(), 1);
+		}
+		template <bool b>
+		basic_environment(env_key_t, const basic_reference<b>& extraction_target)
+		: base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<env_key_t>(this->lua_state(), -1, handler);
+#endif // Safety
+			lua_pop(this->lua_state(), 1);
+		}
+		basic_environment(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_environment>(L, index, handler);
+#endif // Safety
+		}
+		basic_environment(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_environment>(L, -1, handler);
+#endif // Safety
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_environment>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_environment(T&& r) noexcept : base_t(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_environment<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_environment>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_environment(lua_nil_t r) noexcept : base_t(detail::no_safety, r) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_environment(lua_State* L, T&& r) noexcept : base_t(detail::no_safety, L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_environment<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_environment>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+
+		template <typename T>
+		bool set_on(const T& target) const {
+			lua_State* L = target.lua_state();
+			auto pp = stack::push_pop(target);
+			int target_index = pp.index_of(target);
+#if SOL_LUA_VERSION_I_ < 502
+			// Use lua_setfenv
+			this->push();
+			int success_result = lua_setfenv(L, target_index);
+			return success_result != 0;
+#else
+			// If this is a C function, the environment is always placed in
+			// the first value, as is expected of sol2 (all upvalues have an empty name, "")
+			if (lua_iscfunction(L, target_index) != 0) {
+				const char* maybe_upvalue_name = lua_getupvalue(L, target_index, 1);
+				if (maybe_upvalue_name == nullptr) {
+					return false;
+				}
+				string_view upvalue_name(maybe_upvalue_name);
+				if (upvalue_name == "") {
+					this->push();
+					const char* success = lua_setupvalue(L, target_index, 1);
+					if (success == nullptr) {
+						// left things alone on the stack, pop them off
+						lua_pop(L, 2);
+						return false;
+					}
+					lua_pop(L, 1);
+					return true;
+				}
+				lua_pop(L, 1);
+				return false;
+			}
+			else {
+				// Must search for the right upvalue target on index
+				for (int upvalue_index = 1;; ++upvalue_index) {
+					const char* maybe_upvalue_name = lua_getupvalue(L, target_index, upvalue_index);
+					if (maybe_upvalue_name == nullptr) {
+						break;
+					}
+					string_view upvalue_name(maybe_upvalue_name);
+					if (upvalue_name == "_ENV") {
+						lua_pop(L, 1);
+						this->push();
+						const char* success = lua_setupvalue(L, target_index, upvalue_index);
+						if (success == nullptr) {
+							// left things alone on the stack, pop them off
+							lua_pop(L, 1);
+							break;
+						}
+						// whether or not we succeeded, we found _ENV
+						// so we need to break
+						return true;
+					}
+					lua_pop(L, 1);
+				}
+				// if we get here,
+				// we did not find an _ENV here...
+				return false;
+			}
+#endif
+		}
+	};
+
+	template <typename T, typename E>
+	bool set_environment(const basic_environment<E>& env, const T& target) {
+		return env.set_on(target);
+	}
+
+	template <typename E = reference, typename T>
+	basic_environment<E> get_environment(const T& target) {
+		lua_State* L = target.lua_state();
+		auto pp = stack::pop_n(L, stack::push_environment_of(target));
+		return basic_environment<E>(L, -1);
+	}
+
+	struct this_environment {
+		optional<environment> env;
+
+		this_environment() : env(nullopt) {
+		}
+		this_environment(environment e) : env(std::move(e)) {
+		}
+		this_environment(const this_environment&) = default;
+		this_environment(this_environment&&) = default;
+		this_environment& operator=(const this_environment&) = default;
+		this_environment& operator=(this_environment&&) = default;
+
+		explicit operator bool() const {
+			return static_cast<bool>(env);
+		}
+
+		operator optional<environment>&() {
+			return env;
+		}
+
+		operator const optional<environment>&() const {
+			return env;
+		}
+
+		operator environment&() {
+			return env.value();
+		}
+
+		operator const environment&() const {
+			return env.value();
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<env_key_t> {
+			static environment get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				return get_environment(stack_reference(L, raw_index(index)));
+			}
+		};
+
+		template <>
+		struct unqualified_getter<this_environment> {
+			static this_environment get(lua_State* L, int, record& tracking) {
+				tracking.use(0);
+				lua_Debug info;
+				// Level 0 means current function (this C function, which may or may not be useful for us?)
+				// Level 1 means next call frame up the stack. (Can be nothing if function called directly from C++ with lua_p/call)
+				int pre_stack_size = lua_gettop(L);
+				if (lua_getstack(L, 1, &info) != 1) {
+					if (lua_getstack(L, 0, &info) != 1) {
+						lua_settop(L, pre_stack_size);
+						return this_environment();
+					}
+				}
+				if (lua_getinfo(L, "f", &info) == 0) {
+					lua_settop(L, pre_stack_size);
+					return this_environment();
+				}
+
+				stack_reference f(L, -1);
+				environment env(env_key, f);
+				if (!env.valid()) {
+					lua_settop(L, pre_stack_size);
+					return this_environment();
+				}
+				return this_environment(std::move(env));
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/environment.hpp
+
+// beginning of sol/load_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+	struct load_result : public proxy_base<load_result> {
+	private:
+		lua_State* L;
+		int index;
+		int returncount;
+		int popcount;
+		load_status err;
+
+	public:
+		load_result() noexcept : load_result(nullptr) {}
+		load_result(lua_State* Ls, int stackindex = -1, int retnum = 0, int popnum = 0, load_status lerr = load_status::ok) noexcept
+		: L(Ls), index(stackindex), returncount(retnum), popcount(popnum), err(lerr) {
+		}
+
+		// We do not want anyone to copy these around willy-nilly
+		// Will likely break people, but also will probably get rid of quiet bugs that have
+		// been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+		// LuaJIT and other Lua engines will implode and segfault at random later times.)
+		load_result(const load_result&) = delete;
+		load_result& operator=(const load_result&) = delete;
+
+		load_result(load_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.returncount = 0;
+			o.popcount = 0;
+			o.err = load_status::syntax;
+		}
+		load_result& operator=(load_result&& o) noexcept {
+			L = o.L;
+			index = o.index;
+			returncount = o.returncount;
+			popcount = o.popcount;
+			err = o.err;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.returncount = 0;
+			o.popcount = 0;
+			o.err = load_status::syntax;
+			return *this;
+		}
+
+		load_status status() const noexcept {
+			return err;
+		}
+
+		bool valid() const noexcept {
+			return status() == load_status::ok;
+		}
+
+		template <typename T>
+		T get() const {
+			using UT = meta::unqualified_t<T>;
+			if constexpr (meta::is_optional_v<UT>) {
+				using ValueType = typename UT::value_type;
+				if constexpr (std::is_same_v<ValueType, error>) {
+					if (valid()) {
+						return UT(nullopt);
+					}
+					return error(detail::direct_error, stack::get<std::string>(L, index));
+				}
+				else {
+					if (!valid()) {
+						return UT(nullopt);
+					}
+					return stack::get<UT>(L, index);
+				}
+			}
+			else {
+				if constexpr (std::is_same_v<T, error>) {
+#if SOL_IS_ON(SOL_SAFE_PROXIES)
+					if (valid()) {
+						type_panic_c_str(L, index, type_of(L, index), type::none, "expecting an error type (a string, from Lua)");
+					}
+#endif // Check proxy type's safety
+					return error(detail::direct_error, stack::get<std::string>(L, index));
+				}
+				else {
+#if SOL_IS_ON(SOL_SAFE_PROXIES)
+					if (!valid()) {
+						type_panic_c_str(L, index, type_of(L, index), type::none);
+					}
+#endif // Check proxy type's safety
+					return stack::get<T>(L, index);
+				}
+			}
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+			return get<protected_function>().template call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		};
+		int stack_index() const noexcept {
+			return index;
+		};
+
+		~load_result() {
+			if (L != nullptr) {
+				stack::remove(L, index, popcount);
+			}
+		}
+	};
+} // namespace sol
+
+// end of sol/load_result.hpp
+
+// beginning of sol/state_handling.hpp
+
+// beginning of sol/lua_value.hpp
+
+namespace sol {
+	struct lua_value {
+	public:
+		struct arr : detail::ebco<std::initializer_list<lua_value>> {
+		private:
+			using base_t = detail::ebco<std::initializer_list<lua_value>>;
+
+		public:
+			using base_t::base_t;
+		};
+
+	private:
+		template <typename T>
+		using is_reference_or_lua_value_init_list
+		     = meta::any<meta::is_specialization_of<T, std::initializer_list>, std::is_same<T, reference>, std::is_same<T, arr>>;
+
+		template <typename T>
+		using is_lua_value_single_constructible = meta::any<std::is_same<T, lua_value>, is_reference_or_lua_value_init_list<T>>;
+
+		static lua_State*& thread_local_lua_state() {
+#if SOL_IS_ON(SOL_USE_THREAD_LOCAL)
+			static thread_local lua_State* L = nullptr;
+#else
+			static lua_State* L = nullptr;
+#endif
+			return L;
+		}
+
+		reference ref_value;
+
+	public:
+		static void set_lua_state(lua_State* L) {
+			thread_local_lua_state() = L;
+		}
+
+		template <typename T, meta::disable<is_reference_or_lua_value_init_list<meta::unqualified_t<T>>> = meta::enabler>
+		lua_value(lua_State* L_, T&& value) : lua_value(((set_lua_state(L_)), std::forward<T>(value))) {
+		}
+
+		template <typename T, meta::disable<is_lua_value_single_constructible<meta::unqualified_t<T>>> = meta::enabler>
+		lua_value(T&& value) : ref_value(make_reference(thread_local_lua_state(), std::forward<T>(value))) {
+		}
+
+		lua_value(lua_State* L_, std::initializer_list<std::pair<lua_value, lua_value>> il)
+		: lua_value([&L_, &il]() {
+			set_lua_state(L_);
+			return std::move(il);
+		}()) {
+		}
+
+		lua_value(std::initializer_list<std::pair<lua_value, lua_value>> il) : ref_value(make_reference(thread_local_lua_state(), std::move(il))) {
+		}
+
+		lua_value(lua_State* L_, arr il)
+		: lua_value([&L_, &il]() {
+			set_lua_state(L_);
+			return std::move(il);
+		}()) {
+		}
+
+		lua_value(arr il) : ref_value(make_reference(thread_local_lua_state(), std::move(il.value()))) {
+		}
+
+		lua_value(lua_State* L_, reference r)
+		: lua_value([&L_, &r]() {
+			set_lua_state(L_);
+			return std::move(r);
+		}()) {
+		}
+
+		lua_value(reference r) : ref_value(std::move(r)) {
+		}
+
+		lua_value(const lua_value&) noexcept = default;
+		lua_value(lua_value&&) = default;
+		lua_value& operator=(const lua_value&) = default;
+		lua_value& operator=(lua_value&&) = default;
+
+		const reference& value() const& {
+			return ref_value;
+		}
+
+		reference& value() & {
+			return ref_value;
+		}
+
+		reference&& value() && {
+			return std::move(ref_value);
+		}
+
+		template <typename T>
+		decltype(auto) as() const {
+			ref_value.push();
+			return stack::pop<T>(ref_value.lua_state());
+		}
+
+		template <typename T>
+		bool is() const {
+			int r = ref_value.registry_index();
+			if (r == LUA_REFNIL)
+				return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
+			if (r == LUA_NOREF)
+				return false;
+			auto pp = stack::push_pop(ref_value);
+			return stack::check<T>(ref_value.lua_state(), -1, &no_panic);
+		}
+	};
+
+	using array_value = typename lua_value::arr;
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<lua_value> {
+			static int push(lua_State* L, const lua_value& lv) {
+				return stack::push(L, lv.value());
+			}
+
+			static int push(lua_State* L, lua_value&& lv) {
+				return stack::push(L, std::move(lv).value());
+			}
+		};
+
+		template <>
+		struct unqualified_getter<lua_value> {
+			static lua_value get(lua_State* L, int index, record& tracking) {
+				return lua_value(L, stack::get<reference>(L, index, tracking));
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/lua_value.hpp
+
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+#include <iostream>
+#endif
+
+namespace sol {
+	inline void register_main_thread(lua_State* L) {
+#if SOL_LUA_VERSION_I_ < 502
+		if (L == nullptr) {
+			lua_pushnil(L);
+			lua_setglobal(L, detail::default_main_thread_name());
+			return;
+		}
+		lua_pushthread(L);
+		lua_setglobal(L, detail::default_main_thread_name());
+#else
+		(void)L;
+#endif
+	}
+
+	inline int default_at_panic(lua_State* L) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		(void)L;
+		return -1;
+#else
+		size_t messagesize;
+		const char* message = lua_tolstring(L, -1, &messagesize);
+		if (message) {
+			std::string err(message, messagesize);
+			lua_settop(L, 0);
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+			std::cerr << "[sol2] An error occurred and panic has been invoked: ";
+			std::cerr << err;
+			std::cerr << std::endl;
+#endif
+			throw error(err);
+		}
+		lua_settop(L, 0);
+		throw error(std::string("An unexpected error occurred and panic has been invoked"));
+#endif // Printing Errors
+	}
+
+	inline int default_traceback_error_handler(lua_State* L) {
+		std::string msg = "An unknown error has triggered the default error handler";
+		optional<string_view> maybetopmsg = stack::unqualified_check_get<string_view>(L, 1, &no_panic);
+		if (maybetopmsg) {
+			const string_view& topmsg = maybetopmsg.value();
+			msg.assign(topmsg.data(), topmsg.size());
+		}
+		luaL_traceback(L, L, msg.c_str(), 1);
+		optional<string_view> maybetraceback = stack::unqualified_check_get<string_view>(L, -1, &no_panic);
+		if (maybetraceback) {
+			const string_view& traceback = maybetraceback.value();
+			msg.assign(traceback.data(), traceback.size());
+		}
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+		// std::cerr << "[sol2] An error occurred and was caught in traceback: ";
+		// std::cerr << msg;
+		// std::cerr << std::endl;
+#endif // Printing
+		return stack::push(L, msg);
+	}
+
+	inline void set_default_state(lua_State* L, lua_CFunction panic_function = &default_at_panic,
+	     lua_CFunction traceback_function = c_call<decltype(&default_traceback_error_handler), &default_traceback_error_handler>,
+	     exception_handler_function exf = detail::default_exception_handler) {
+		lua_atpanic(L, panic_function);
+		protected_function::set_default_handler(object(L, in_place, traceback_function));
+		set_default_exception_handler(L, exf);
+		register_main_thread(L);
+		stack::luajit_exception_handler(L);
+		lua_value::set_lua_state(L);
+	}
+
+	inline std::size_t total_memory_used(lua_State* L) {
+		std::size_t kb = static_cast<std::size_t>(lua_gc(L, LUA_GCCOUNT, 0));
+		kb *= 1024;
+		kb += static_cast<std::size_t>(lua_gc(L, LUA_GCCOUNTB, 0));
+		return kb;
+	}
+
+	inline protected_function_result script_pass_on_error(lua_State*, protected_function_result result) {
+		return result;
+	}
+
+	inline protected_function_result script_throw_on_error(lua_State* L, protected_function_result result) {
+		type t = type_of(L, result.stack_index());
+		std::string err = "sol: ";
+		err += to_string(result.status());
+		err += " error";
+#if SOL_IS_ON(SOL_EXCEPTIONS)
+		std::exception_ptr eptr = std::current_exception();
+		if (eptr) {
+			err += " with a ";
+			try {
+				std::rethrow_exception(eptr);
+			}
+			catch (const std::exception& ex) {
+				err += "std::exception -- ";
+				err.append(ex.what());
+			}
+			catch (const std::string& message) {
+				err += "thrown message -- ";
+				err.append(message);
+			}
+			catch (const char* message) {
+				err += "thrown message -- ";
+				err.append(message);
+			}
+			catch (...) {
+				err.append("thrown but unknown type, cannot serialize into error message");
+			}
+		}
+#endif // serialize exception information if possible
+		if (t == type::string) {
+			err += ": ";
+			string_view serr = stack::unqualified_get<string_view>(L, result.stack_index());
+			err.append(serr.data(), serr.size());
+		}
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+		std::cerr << "[sol2] An error occurred and has been passed to an error handler: ";
+		std::cerr << err;
+		std::cerr << std::endl;
+#endif
+		// replacing information of stack error into pfr
+		int target = result.stack_index();
+		if (result.pop_count() > 0) {
+			stack::remove(L, target, result.pop_count());
+		}
+		stack::push(L, err);
+		int top = lua_gettop(L);
+		int towards = top - target;
+		if (towards != 0) {
+			lua_rotate(L, top, towards);
+		}
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		return result;
+#else
+		// just throw our error
+		throw error(detail::direct_error, err);
+#endif // If exceptions are allowed
+	}
+
+	inline protected_function_result script_default_on_error(lua_State* L, protected_function_result pfr) {
+#if SOL_IS_ON(SOL_DEFAULT_PASS_ON_ERROR)
+		return script_pass_on_error(L, std::move(pfr));
+#else
+		return script_throw_on_error(L, std::move(pfr));
+#endif
+	}
+
+	namespace stack {
+		inline error get_traceback_or_errors(lua_State* L) {
+			int p = default_traceback_error_handler(L);
+			sol::error err = stack::get<sol::error>(L, -p);
+			lua_pop(L, p);
+			return err;
+		}
+	} // namespace stack
+} // namespace sol
+
+// end of sol/state_handling.hpp
+
+#include <memory>
+#include <cstddef>
+
+namespace sol {
+
+	class state_view {
+	private:
+		lua_State* L;
+		table reg;
+		global_table global;
+
+		optional<object> is_loaded_package(const std::string& key) {
+			auto loaded = reg.traverse_get<optional<object>>("_LOADED", key);
+			bool is53mod = loaded && !(loaded->is<bool>() && !loaded->as<bool>());
+			if (is53mod)
+				return loaded;
+#if SOL_LUA_VERSION_I_ <= 501
+			auto loaded51 = global.traverse_get<optional<object>>("package", "loaded", key);
+			bool is51mod = loaded51 && !(loaded51->is<bool>() && !loaded51->as<bool>());
+			if (is51mod)
+				return loaded51;
+#endif
+			return nullopt;
+		}
+
+		template <typename T>
+		void ensure_package(const std::string& key, T&& sr) {
+#if SOL_LUA_VERSION_I_ <= 501
+			auto pkg = global["package"];
+			if (!pkg.valid()) {
+				pkg = create_table_with("loaded", create_table_with(key, sr));
+			}
+			else {
+				auto ld = pkg["loaded"];
+				if (!ld.valid()) {
+					ld = create_table_with(key, sr);
+				}
+				else {
+					ld[key] = sr;
+				}
+			}
+#endif
+			auto loaded = reg["_LOADED"];
+			if (!loaded.valid()) {
+				loaded = create_table_with(key, sr);
+			}
+			else {
+				loaded[key] = sr;
+			}
+		}
+
+		template <typename Fx>
+		object require_core(const std::string& key, Fx&& action, bool create_global = true) {
+			optional<object> loaded = is_loaded_package(key);
+			if (loaded && loaded->valid())
+				return std::move(*loaded);
+			int before = lua_gettop(L);
+			action();
+			int after = lua_gettop(L);
+			if (before == after) {
+				// I mean, you were supposed to return
+				// something, ANYTHING, from your requires script. I guess I'll just
+				// but some trash in here, it's on you after that?
+				ensure_package(key, static_cast<void*>(L));
+				return object(L, lua_nil);
+			}
+			stack_reference sr(L, -1);
+			if (create_global)
+				set(key, sr);
+			ensure_package(key, sr);
+			return stack::pop<object>(L);
+		}
+
+	public:
+		using iterator = typename global_table::iterator;
+		using const_iterator = typename global_table::const_iterator;
+
+		state_view(lua_State* Ls) : L(Ls), reg(Ls, LUA_REGISTRYINDEX), global(Ls, global_tag) {
+		}
+
+		state_view(this_state Ls) : state_view(Ls.L) {
+		}
+
+		lua_State* lua_state() const {
+			return L;
+		}
+
+		template <typename... Args>
+		void open_libraries(Args&&... args) {
+			static_assert(meta::all_same<lib, meta::unqualified_t<Args>...>::value, "all types must be libraries");
+			if constexpr (sizeof...(args) == 0) {
+				luaL_openlibs(L);
+				return;
+			}
+			else {
+				lib libraries[1 + sizeof...(args)] = { lib::count, std::forward<Args>(args)... };
+
+				for (auto&& library : libraries) {
+					switch (library) {
+#if SOL_LUA_VERSION_I_ <= 501 && SOL_IS_ON(SOL_USE_LUAJIT)
+					case lib::coroutine:
+#endif // luajit opens coroutine base stuff
+					case lib::base:
+						luaL_requiref(L, "base", luaopen_base, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::package:
+						luaL_requiref(L, "package", luaopen_package, 1);
+						lua_pop(L, 1);
+						break;
+#if SOL_IS_OFF(SOL_USE_LUAJIT)
+					case lib::coroutine:
+#if SOL_LUA_VERSION_I_ > 501
+						luaL_requiref(L, "coroutine", luaopen_coroutine, 1);
+						lua_pop(L, 1);
+#endif // Lua 5.2+ only
+						break;
+#endif // Not LuaJIT - comes builtin
+					case lib::string:
+						luaL_requiref(L, "string", luaopen_string, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::table:
+						luaL_requiref(L, "table", luaopen_table, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::math:
+						luaL_requiref(L, "math", luaopen_math, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::bit32:
+#if SOL_IS_ON(SOL_USE_LUAJIT)
+						luaL_requiref(L, "bit32", luaopen_bit, 1);
+						lua_pop(L, 1);
+#elif SOL_IS_ON(SOL_LUA_BIT32_LIB)
+						luaL_requiref(L, "bit32", luaopen_bit32, 1);
+						lua_pop(L, 1);
+#else
+#endif
+						break;
+					case lib::io:
+						luaL_requiref(L, "io", luaopen_io, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::os:
+						luaL_requiref(L, "os", luaopen_os, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::debug:
+						luaL_requiref(L, "debug", luaopen_debug, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::utf8:
+#if SOL_LUA_VERSION_I_ > 502 && SOL_IS_OFF(SOL_USE_LUAJIT)
+						luaL_requiref(L, "utf8", luaopen_utf8, 1);
+						lua_pop(L, 1);
+#endif // Lua 5.3+ only
+						break;
+					case lib::ffi:
+#if SOL_IS_ON(SOL_USE_LUAJIT) && SOL_IS_OFF(SOL_LUAJIT_FFI_DISABLED)
+						luaL_requiref(L, "ffi", luaopen_ffi, 1);
+						lua_pop(L, 1);
+#endif // LuaJIT only
+						break;
+					case lib::jit:
+#if SOL_IS_ON(SOL_USE_LUAJIT)
+						luaL_requiref(L, "jit", luaopen_jit, 0);
+						lua_pop(L, 1);
+#endif // LuaJIT Only
+						break;
+					case lib::count:
+					default:
+						break;
+					}
+				}
+			}
+		}
+
+		object require(const std::string& key, lua_CFunction open_function, bool create_global = true) {
+			luaL_requiref(L, key.c_str(), open_function, create_global ? 1 : 0);
+			return stack::pop<object>(L);
+		}
+
+		object require_script(const std::string& key, const string_view& code, bool create_global = true,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			auto action = [this, &code, &chunkname, &mode]() { stack::script(L, code, chunkname, mode); };
+			return require_core(key, action, create_global);
+		}
+
+		object require_file(const std::string& key, const std::string& filename, bool create_global = true, load_mode mode = load_mode::any) {
+			auto action = [this, &filename, &mode]() { stack::script_file(L, filename, mode); };
+			return require_core(key, action, create_global);
+		}
+
+		void clear_package_loaders() {
+			optional<table> maybe_package = this->global["package"];
+			if (!maybe_package) {
+				// package lib wasn't opened
+				// open package lib
+				return;
+			}
+			table& package = *maybe_package;
+			// yay for version differences...
+			// one day Lua 5.1 will die a peaceful death
+			// and its old bones will find blissful rest
+			auto loaders_proxy = package
+#if SOL_LUA_VERSION_I_ < 502
+			     ["loaders"]
+#else
+			     ["searchers"]
+#endif
+			     ;
+			if (!loaders_proxy.valid()) {
+				// nothing to clear
+				return;
+			}
+			// we need to create the table for loaders
+			// table does not exist, so create and move forward
+			loaders_proxy = new_table(1, 0);
+		}
+
+		template <typename Fx>
+		void add_package_loader(Fx&& fx, bool clear_all_package_loaders = false) {
+			optional<table> maybe_package = this->global["package"];
+			if (!maybe_package) {
+				// package lib wasn't opened
+				// open package lib
+				return;
+			}
+			table& package = *maybe_package;
+			// yay for version differences...
+			// one day Lua 5.1 will die a peaceful death
+			// and its old bones will find blissful rest
+			auto loaders_proxy = package
+#if SOL_LUA_VERSION_I_ < 502
+			     ["loaders"]
+#else
+			     ["searchers"]
+#endif
+			     ;
+			bool make_new_table = clear_all_package_loaders || !loaders_proxy.valid();
+			if (make_new_table) {
+				// we need to create the table for loaders
+				// table does not exist, so create and move forward
+				loaders_proxy = new_table(1, 0);
+			}
+			optional<table> maybe_loaders = loaders_proxy;
+			if (!maybe_loaders) {
+				// loaders/searches
+				// thing exists in package, but it
+				// ain't a table or a table-alike...!
+				return;
+			}
+			table loaders = loaders_proxy;
+			loaders.add(std::forward<Fx>(fx));
+		}
+
+		template <typename E>
+		protected_function_result do_reader(lua_Reader reader, void* data, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			set_environment(env, pf);
+			return pf();
+		}
+
+		protected_function_result do_reader(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			return pf();
+		}
+
+		template <typename E>
+		protected_function_result do_string(const string_view& code, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			set_environment(env, pf);
+			return pf();
+		}
+
+		protected_function_result do_string(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			return pf();
+		}
+
+		template <typename E>
+		protected_function_result do_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+			load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			set_environment(env, pf);
+			return pf();
+		}
+
+		protected_function_result do_file(const std::string& filename, load_mode mode = load_mode::any) {
+			load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			return pf();
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result safe_script(
+		     lua_Reader reader, void* data, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_reader(reader, data, chunkname, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		protected_function_result safe_script(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(reader, data, script_default_on_error, chunkname, mode);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result safe_script(
+		     const string_view& code, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_string(code, chunkname, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result safe_script(const string_view& code, const basic_environment<E>& env, Fx&& on_error,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_string(code, env, chunkname, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename E>
+		protected_function_result safe_script(const string_view& code, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, env, script_default_on_error, chunkname, mode);
+		}
+
+		protected_function_result safe_script(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, script_default_on_error, chunkname, mode);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result safe_script_file(const std::string& filename, Fx&& on_error, load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_file(filename, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result safe_script_file(
+		     const std::string& filename, const basic_environment<E>& env, Fx&& on_error, load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_file(filename, env, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename E>
+		protected_function_result safe_script_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, env, script_default_on_error, mode);
+		}
+
+		protected_function_result safe_script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, script_default_on_error, mode);
+		}
+
+		template <typename E>
+		unsafe_function_result unsafe_script(lua_Reader reader, void* data, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			int index = lua_gettop(L);
+			if (lua_load(L, reader, data, chunknametarget, to_string(mode).c_str())) {
+				lua_error(L);
+			}
+			set_environment(env, stack_reference(L, raw_index(index + 1)));
+			if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		unsafe_function_result unsafe_script(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			stack::script(L, reader, data, chunkname, mode);
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		template <typename E>
+		unsafe_function_result unsafe_script(const string_view& code, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			int index = lua_gettop(L);
+			if (luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str())) {
+				lua_error(L);
+			}
+			set_environment(env, stack_reference(L, raw_index(index + 1)));
+			if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		unsafe_function_result unsafe_script(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			stack::script(L, code, chunkname, mode);
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		template <typename E>
+		unsafe_function_result unsafe_script_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			if (luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str())) {
+				lua_error(L);
+			}
+			set_environment(env, stack_reference(L, raw_index(index + 1)));
+			if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		unsafe_function_result unsafe_script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			stack::script_file(L, filename, mode);
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result script(
+		     const string_view& code, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, std::forward<Fx>(on_error), chunkname, mode);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result script_file(const std::string& filename, Fx&& on_error, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, std::forward<Fx>(on_error), mode);
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result script(const string_view& code, const basic_environment<E>& env, Fx&& on_error,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, env, std::forward<Fx>(on_error), chunkname, mode);
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result script_file(const std::string& filename, const basic_environment<E>& env, Fx&& on_error, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, env, std::forward<Fx>(on_error), mode);
+		}
+
+		protected_function_result script(
+		     const string_view& code, const environment& env, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, env, script_default_on_error, chunkname, mode);
+		}
+
+		protected_function_result script_file(const std::string& filename, const environment& env, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, env, script_default_on_error, mode);
+		}
+
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+		protected_function_result script(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(reader, data, chunkname, mode);
+		}
+
+		protected_function_result script(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, chunkname, mode);
+		}
+
+		protected_function_result script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, mode);
+		}
+#else
+		unsafe_function_result script(const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return unsafe_script(code, chunkname, mode);
+		}
+
+		unsafe_function_result script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			return unsafe_script_file(filename, mode);
+		}
+#endif
+		load_result load(const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+			return load_result(L, absolute_index(L, -1), 1, 1, x);
+		}
+
+		load_result load_buffer(const char* buff, size_t size, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return load(string_view(buff, size), chunkname, mode);
+		}
+
+		load_result load_buffer(
+		     const std::byte* buff, size_t size, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return load(string_view(reinterpret_cast<const char*>(buff), size), chunkname, mode);
+		}
+
+		load_result load_file(const std::string& filename, load_mode mode = load_mode::any) {
+			load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+			return load_result(L, absolute_index(L, -1), 1, 1, x);
+		}
+
+		load_result load(lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+			return load_result(L, absolute_index(L, -1), 1, 1, x);
+		}
+
+		iterator begin() const {
+			return global.begin();
+		}
+
+		iterator end() const {
+			return global.end();
+		}
+
+		const_iterator cbegin() const {
+			return global.cbegin();
+		}
+
+		const_iterator cend() const {
+			return global.cend();
+		}
+
+		global_table globals() const {
+			// if we return a reference
+			// we'll be screwed a bit
+			return global;
+		}
+
+		global_table& globals() {
+			return global;
+		}
+
+		table registry() const {
+			return reg;
+		}
+
+		std::size_t memory_used() const {
+			return total_memory_used(lua_state());
+		}
+
+		int stack_top() const {
+			return stack::top(L);
+		}
+
+		int stack_clear() {
+			int s = stack_top();
+			lua_pop(L, s);
+			return s;
+		}
+
+		bool supports_gc_mode(gc_mode mode) const noexcept {
+#if SOL_LUA_VERSION_I_ >= 504
+			// supports all modes
+			(void)mode;
+			return true;
+#endif
+			return mode == gc_mode::default_value;
+		}
+
+		bool is_gc_on() const {
+#if SOL_LUA_VERSION_I_ >= 502
+			return lua_gc(lua_state(), LUA_GCISRUNNING, 0) == 1;
+#else
+			// You cannot turn it off in Lua 5.1
+			return true;
+#endif
+		}
+
+		void collect_garbage() {
+			lua_gc(lua_state(), LUA_GCCOLLECT, 0);
+		}
+
+		void collect_gc() {
+			collect_garbage();
+		}
+
+		bool step_gc(int step_size_kilobytes) {
+			// THOUGHT: std::chrono-alikes to map "kilobyte size" here...?
+			// Make it harder to give MB or KB to a B parameter...?
+			// Probably overkill for now.
+#if SOL_LUA_VERSION_I_ >= 504
+			// The manual implies that this function is almost always successful...
+			// is it?? It could depend on the GC mode...
+			return lua_gc(lua_state(), LUA_GCSTEP, step_size_kilobytes) != 0;
+#else
+			return lua_gc(lua_state(), LUA_GCSTEP, step_size_kilobytes) == 1;
+#endif
+		}
+
+		void restart_gc() {
+			lua_gc(lua_state(), LUA_GCRESTART, 0);
+		}
+
+		void stop_gc() {
+			lua_gc(lua_state(), LUA_GCSTOP, 0);
+		}
+
+		// Returns the old GC mode. Check support using the supports_gc_mode function.
+		gc_mode change_gc_mode_incremental(int pause, int step_multiplier, int step_byte_size) {
+			// "What the fuck does any of this mean??"
+			// http://www.lua.org/manual/5.4/manual.html#2.5.1
+
+			// THOUGHT: std::chrono-alikes to map "byte size" here...?
+			// Make it harder to give MB or KB to a B parameter...?
+			// Probably overkill for now.
+#if SOL_LUA_VERSION_I_ >= 504
+			int old_mode = lua_gc(lua_state(), LUA_GCINC, pause, step_multiplier, step_byte_size);
+			if (old_mode == LUA_GCGEN) {
+				return gc_mode::generational;
+			}
+			else if (old_mode == LUA_GCINC) {
+				return gc_mode::incremental;
+			}
+#else
+			lua_gc(lua_state(), LUA_GCSETPAUSE, pause);
+			lua_gc(lua_state(), LUA_GCSETSTEPMUL, step_multiplier);
+			(void)step_byte_size; // means nothing in older versions
+#endif
+			return gc_mode::default_value;
+		}
+
+		// Returns the old GC mode. Check support using the supports_gc_mode function.
+		gc_mode change_gc_mode_generational(int minor_multiplier, int major_multiplier) {
+#if SOL_LUA_VERSION_I_ >= 504
+			// "What does this shit mean?"
+			// http://www.lua.org/manual/5.4/manual.html#2.5.2
+			int old_mode = lua_gc(lua_state(), LUA_GCGEN, minor_multiplier, major_multiplier);
+			if (old_mode == LUA_GCGEN) {
+				return gc_mode::generational;
+			}
+			else if (old_mode == LUA_GCINC) {
+				return gc_mode::incremental;
+			}
+#else
+			(void)minor_multiplier;
+			(void)major_multiplier;
+#endif
+			return gc_mode::default_value;
+		}
+
+		operator lua_State*() const {
+			return lua_state();
+		}
+
+		void set_panic(lua_CFunction panic) {
+			lua_atpanic(lua_state(), panic);
+		}
+
+		void set_exception_handler(exception_handler_function handler) {
+			set_default_exception_handler(lua_state(), handler);
+		}
+
+		template <typename... Args, typename... Keys>
+		decltype(auto) get(Keys&&... keys) const {
+			return global.get<Args...>(std::forward<Keys>(keys)...);
+		}
+
+		template <typename T, typename Key>
+		decltype(auto) get_or(Key&& key, T&& otherwise) const {
+			return global.get_or(std::forward<Key>(key), std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename Key, typename D>
+		decltype(auto) get_or(Key&& key, D&& otherwise) const {
+			return global.get_or<T>(std::forward<Key>(key), std::forward<D>(otherwise));
+		}
+
+		template <typename... Args>
+		state_view& set(Args&&... args) {
+			global.set(std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename T, typename... Keys>
+		decltype(auto) traverse_get(Keys&&... keys) const {
+			return global.traverse_get<T>(std::forward<Keys>(keys)...);
+		}
+
+		template <typename... Args>
+		state_view& traverse_set(Args&&... args) {
+			global.traverse_set(std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Class, typename... Args>
+		usertype<Class> new_usertype(Args&&... args) {
+			return global.new_usertype<Class>(std::forward<Args>(args)...);
+		}
+
+		template <bool read_only = true, typename... Args>
+		state_view& new_enum(const string_view& name, Args&&... args) {
+			global.new_enum<read_only>(name, std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename T, bool read_only = true>
+		state_view& new_enum(const string_view& name, std::initializer_list<std::pair<string_view, T>> items) {
+			global.new_enum<T, read_only>(name, std::move(items));
+			return *this;
+		}
+
+		template <typename Fx>
+		void for_each(Fx&& fx) {
+			global.for_each(std::forward<Fx>(fx));
+		}
+
+		template <typename T>
+		table_proxy<global_table&, detail::proxy_key_t<T>> operator[](T&& key) {
+			return global[std::forward<T>(key)];
+		}
+
+		template <typename T>
+		table_proxy<const global_table&, detail::proxy_key_t<T>> operator[](T&& key) const {
+			return global[std::forward<T>(key)];
+		}
+
+		template <typename Sig, typename... Args, typename Key>
+		state_view& set_function(Key&& key, Args&&... args) {
+			global.set_function<Sig>(std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename... Args, typename Key>
+		state_view& set_function(Key&& key, Args&&... args) {
+			global.set_function(std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Name>
+		table create_table(Name&& name, int narr = 0, int nrec = 0) {
+			return global.create(std::forward<Name>(name), narr, nrec);
+		}
+
+		template <typename Name, typename Key, typename Value, typename... Args>
+		table create_table(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return global.create(std::forward<Name>(name), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename Name, typename... Args>
+		table create_named_table(Name&& name, Args&&... args) {
+			table x = global.create_with(std::forward<Args>(args)...);
+			global.set(std::forward<Name>(name), x);
+			return x;
+		}
+
+		table create_table(int narr = 0, int nrec = 0) {
+			return create_table(lua_state(), narr, nrec);
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		table create_table(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return create_table(lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		table create_table_with(Args&&... args) {
+			return create_table_with(lua_state(), std::forward<Args>(args)...);
+		}
+
+		static inline table create_table(lua_State* L, int narr = 0, int nrec = 0) {
+			return global_table::create(L, narr, nrec);
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		static inline table create_table(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return global_table::create(L, narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		static inline table create_table_with(lua_State* L, Args&&... args) {
+			return global_table::create_with(L, std::forward<Args>(args)...);
+		}
+	};
+} // namespace sol
+
+// end of sol/state_view.hpp
+
+// beginning of sol/thread.hpp
+
+namespace sol {
+	struct lua_thread_state {
+		lua_State* L;
+
+		lua_thread_state(lua_State* Ls) : L(Ls) {
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		}
+		operator lua_State*() const noexcept {
+			return lua_state();
+		}
+		lua_State* operator->() const noexcept {
+			return lua_state();
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<lua_thread_state> {
+			int push(lua_State*, lua_thread_state lts) {
+				lua_pushthread(lts.L);
+				return 1;
+			}
+		};
+
+		template <>
+		struct unqualified_getter<lua_thread_state> {
+			lua_thread_state get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				lua_thread_state lts(lua_tothread(L, index));
+				return lts;
+			}
+		};
+
+		template <>
+		struct unqualified_check_getter<lua_thread_state> {
+			template <typename Handler>
+			optional<lua_thread_state> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+				lua_thread_state lts(lua_tothread(L, index));
+				if (lts.lua_state() == nullptr) {
+					handler(L, index, type::thread, type_of(L, index), "value is not a valid thread type");
+					return nullopt;
+				}
+				tracking.use(1);
+				return lts;
+			}
+		};
+	} // namespace stack
+
+	template <typename ref_t>
+	class basic_thread : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+	public:
+		using base_t::lua_state;
+
+		basic_thread() noexcept = default;
+		basic_thread(const basic_thread&) = default;
+		basic_thread(basic_thread&&) = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_thread>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_thread(T&& r) : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_thread(const stack_reference& r) : basic_thread(r.lua_state(), r.stack_index()) {};
+		basic_thread(stack_reference&& r) : basic_thread(r.lua_state(), r.stack_index()) {};
+		basic_thread& operator=(const basic_thread&) = default;
+		basic_thread& operator=(basic_thread&&) = default;
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_thread(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_thread(lua_State* L, int index = -1) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_thread>(L, index, handler);
+#endif // Safety
+		}
+		basic_thread(lua_State* L, ref_index index) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_thread(lua_State* L, lua_State* actualthread) : basic_thread(L, lua_thread_state { actualthread }) {
+		}
+		basic_thread(lua_State* L, this_state actualthread) : basic_thread(L, lua_thread_state { actualthread.L }) {
+		}
+		basic_thread(lua_State* L, lua_thread_state actualthread) : base_t(L, -stack::push(L, actualthread)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+			if (!is_stack_based<base_t>::value) {
+				lua_pop(lua_state(), 1);
+			}
+		}
+
+		state_view state() const {
+			return state_view(this->thread_state());
+		}
+
+		bool is_main_thread() const {
+			return stack::is_main_thread(this->thread_state());
+		}
+
+		lua_State* thread_state() const {
+			auto pp = stack::push_pop(*this);
+			lua_State* lthread = lua_tothread(lua_state(), -1);
+			return lthread;
+		}
+
+		thread_status status() const {
+			lua_State* lthread = thread_state();
+			auto lstat = static_cast<thread_status>(lua_status(lthread));
+			if (lstat == thread_status::ok) {
+				lua_Debug ar;
+				if (lua_getstack(lthread, 0, &ar) > 0)
+					return thread_status::ok;
+				else if (lua_gettop(lthread) == 0)
+					return thread_status::dead;
+				else
+					return thread_status::yielded;
+			}
+			return lstat;
+		}
+
+		basic_thread create() {
+			return create(lua_state());
+		}
+
+		static basic_thread create(lua_State* L) {
+			lua_newthread(L);
+			basic_thread result(L);
+			if (!is_stack_based<base_t>::value) {
+				lua_pop(L, 1);
+			}
+			return result;
+		}
+	};
+
+	typedef basic_thread<reference> thread;
+	typedef basic_thread<stack_reference> stack_thread;
+} // namespace sol
+
+// end of sol/thread.hpp
+
+namespace sol {
+
+	class state : private std::unique_ptr<lua_State, detail::state_deleter>, public state_view {
+	private:
+		typedef std::unique_ptr<lua_State, detail::state_deleter> unique_base;
+
+	public:
+		state(lua_CFunction panic = default_at_panic) : unique_base(luaL_newstate()), state_view(unique_base::get()) {
+			set_default_state(unique_base::get(), panic);
+		}
+
+		state(lua_CFunction panic, lua_Alloc alfunc, void* alpointer = nullptr)
+		: unique_base(lua_newstate(alfunc, alpointer)), state_view(unique_base::get()) {
+			set_default_state(unique_base::get(), panic);
+		}
+
+		state(const state&) = delete;
+		state(state&&) = default;
+		state& operator=(const state&) = delete;
+		state& operator=(state&& that) {
+			state_view::operator=(std::move(that));
+			unique_base::operator=(std::move(that));
+			return *this;
+		}
+
+		using state_view::get;
+
+		~state() {
+		}
+	};
+} // namespace sol
+
+// end of sol/state.hpp
+
+// beginning of sol/coroutine.hpp
+
+namespace sol {
+	template <typename Reference>
+	class basic_coroutine : public basic_object<Reference> {
+	private:
+		using base_t = basic_object<Reference>;
+		using handler_t = reference;
+
+	private:
+		call_status stats = call_status::yielded;
+
+		void luacall(std::ptrdiff_t argcount, std::ptrdiff_t) {
+#if SOL_LUA_VERSION_I_ >= 504
+			int nresults;
+			stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount), &nresults));
+#else
+			stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount)));
+#endif
+		}
+
+		template <std::size_t... I, typename... Ret>
+		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) {
+			luacall(n, sizeof...(Ret));
+			return stack::pop<std::tuple<Ret...>>(lua_state());
+		}
+
+		template <std::size_t I, typename Ret>
+		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) {
+			luacall(n, 1);
+			return stack::pop<Ret>(lua_state());
+		}
+
+		template <std::size_t I>
+		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) {
+			luacall(n, 0);
+		}
+
+		protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) {
+			int firstreturn = 1;
+			luacall(n, LUA_MULTRET);
+			int poststacksize = lua_gettop(this->lua_state());
+			int returncount = poststacksize - (firstreturn - 1);
+			if (error()) {
+				if (m_error_handler.valid()) {
+					string_view err = stack::get<string_view>(this->lua_state(), poststacksize);
+					m_error_handler.push();
+					stack::push(this->lua_state(), err);
+					lua_call(lua_state(), 1, 1);
+				}
+				return protected_function_result(this->lua_state(), lua_absindex(this->lua_state(), -1), 1, returncount, status());
+			}
+			return protected_function_result(this->lua_state(), firstreturn, returncount, returncount, status());
+		}
+
+	public:
+		using base_t::lua_state;
+
+		basic_coroutine() = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_coroutine>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<T>>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_coroutine(T&& r) noexcept
+		: base_t(std::forward<T>(r)), m_error_handler(detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_function<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_coroutine>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+
+		basic_coroutine(const basic_coroutine& other) = default;
+		basic_coroutine& operator=(const basic_coroutine&) = default;
+
+		basic_coroutine(basic_coroutine&& other) noexcept : base_t(std::move(other)), m_error_handler(this->lua_state(), std::move(other.m_error_handler)) {
+		}
+
+		basic_coroutine& operator=(basic_coroutine&& other) noexcept {
+			base_t::operator=(std::move(other));
+			// must change the state, since it could change on the coroutine type
+			m_error_handler = handler_t(this->lua_state(), std::move(other.m_error_handler));
+			return *this;
+		}
+
+		basic_coroutine(const basic_function<base_t>& b) noexcept
+		: basic_coroutine(b, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(b.lua_state())) {
+		}
+		basic_coroutine(basic_function<base_t>&& b) noexcept
+		: basic_coroutine(std::move(b), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(b.lua_state())) {
+		}
+		basic_coroutine(const basic_function<base_t>& b, handler_t eh) noexcept : base_t(b), m_error_handler(std::move(eh)) {
+		}
+		basic_coroutine(basic_function<base_t>&& b, handler_t eh) noexcept : base_t(std::move(b)), m_error_handler(std::move(eh)) {
+		}
+		basic_coroutine(const stack_reference& r) noexcept
+		: basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+		}
+		basic_coroutine(stack_reference&& r) noexcept
+		: basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+		}
+		basic_coroutine(const stack_reference& r, handler_t eh) noexcept : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+		basic_coroutine(stack_reference&& r, handler_t eh) noexcept : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+
+		template <typename Super>
+		basic_coroutine(const proxy_base<Super>& p)
+		: basic_coroutine(p, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
+		}
+		template <typename Super>
+		basic_coroutine(proxy_base<Super>&& p)
+		: basic_coroutine(std::move(p), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
+		}
+		template <typename Proxy, typename HandlerReference,
+		     meta::enable<std::is_base_of<proxy_base_tag, meta::unqualified_t<Proxy>>,
+		          meta::neg<is_lua_index<meta::unqualified_t<HandlerReference>>>> = meta::enabler>
+		basic_coroutine(Proxy&& p, HandlerReference&& eh) : basic_coroutine(detail::force_cast<base_t>(p), std::forward<HandlerReference>(eh)) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_coroutine(lua_State* L, T&& r) noexcept
+		: basic_coroutine(L, std::forward<T>(r), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_coroutine(lua_State* L, T&& r, handler_t eh) : base_t(L, std::forward<T>(r)), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		basic_coroutine(lua_nil_t n) : base_t(n), m_error_handler(n) {
+		}
+
+		basic_coroutine(lua_State* L, int index = -1)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, int index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
+#ifdef SOL_SAFE_REFERENCES
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+		}
+		basic_coroutine(lua_State* L, absolute_index index)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, absolute_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+		}
+		basic_coroutine(lua_State* L, raw_index index)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, raw_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+		}
+		basic_coroutine(lua_State* L, ref_index index)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, ref_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		call_status status() const noexcept {
+			return stats;
+		}
+
+		bool error() const noexcept {
+			call_status cs = status();
+			return cs != call_status::ok && cs != call_status::yielded;
+		}
+
+		bool runnable() const noexcept {
+			return base_t::valid() && (status() == call_status::yielded);
+		}
+
+		explicit operator bool() const noexcept {
+			return runnable();
+		}
+
+		template <typename... Args>
+		protected_function_result operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) operator()(types<Ret...>, Args&&... args) {
+			return call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+			// some users screw up coroutine.create
+			// and try to use it with sol::coroutine without ever calling the first resume in Lua
+			// this makes the stack incompatible with other kinds of stacks: protect against this
+			// make sure coroutines don't screw us over
+			base_t::push();
+			int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+			return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount);
+		}
+
+	private:
+		handler_t m_error_handler;
+	};
+} // namespace sol
+
+// end of sol/coroutine.hpp
+
+// beginning of sol/userdata.hpp
+
+namespace sol {
+	template <typename base_type>
+	class basic_userdata : public basic_table<base_type> {
+	private:
+		using base_t = basic_table<base_type>;
+
+	public:
+		using base_t::lua_state;
+
+		basic_userdata() noexcept = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_userdata>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_userdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_userdata<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				type_assert(lua_state(), -1, type::userdata);
+			}
+#endif // Safety
+		}
+		basic_userdata(const basic_userdata&) = default;
+		basic_userdata(basic_userdata&&) = default;
+		basic_userdata& operator=(const basic_userdata&) = default;
+		basic_userdata& operator=(basic_userdata&&) = default;
+		basic_userdata(const stack_reference& r) : basic_userdata(r.lua_state(), r.stack_index()) {
+		}
+		basic_userdata(stack_reference&& r) : basic_userdata(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_userdata(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_userdata>(L, -1, handler);
+#endif // Safety
+		}
+		basic_userdata(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_userdata>(L, index, handler);
+#endif // Safety
+		}
+		basic_userdata(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_userdata>(L, -1, handler);
+#endif // Safety
+		}
+	};
+
+	template <typename base_type>
+	class basic_lightuserdata : public basic_object_base<base_type> {
+		typedef basic_object_base<base_type> base_t;
+
+	public:
+		using base_t::lua_state;
+
+		basic_lightuserdata() noexcept = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_lightuserdata>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lightuserdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_lightuserdata<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				type_assert(lua_state(), -1, type::lightuserdata);
+			}
+#endif // Safety
+		}
+		basic_lightuserdata(const basic_lightuserdata&) = default;
+		basic_lightuserdata(basic_lightuserdata&&) = default;
+		basic_lightuserdata& operator=(const basic_lightuserdata&) = default;
+		basic_lightuserdata& operator=(basic_lightuserdata&&) = default;
+		basic_lightuserdata(const stack_reference& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {
+		}
+		basic_lightuserdata(stack_reference&& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lightuserdata(lua_State* L, T&& r) : basic_lightuserdata(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_lightuserdata>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_lightuserdata(lua_State* L, int index = -1) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_lightuserdata>(L, index, handler);
+#endif // Safety
+		}
+		basic_lightuserdata(lua_State* L, ref_index index) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_lightuserdata>(lua_state(), index, handler);
+#endif // Safety
+		}
+	};
+
+} // namespace sol
+
+// end of sol/userdata.hpp
+
+// beginning of sol/as_args.hpp
+
+namespace sol {
+	template <typename T>
+	struct as_args_t {
+		T src;
+	};
+
+	template <typename Source>
+	auto as_args(Source&& source) {
+		return as_args_t<Source> { std::forward<Source>(source) };
+	}
+
+	namespace stack {
+		template <typename T>
+		struct unqualified_pusher<as_args_t<T>> {
+			int push(lua_State* L, const as_args_t<T>& e) {
+				int p = 0;
+				for (const auto& i : e.src) {
+					p += stack::push(L, i);
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/as_args.hpp
+
+// beginning of sol/variadic_args.hpp
+
+#include <limits>
+#include <iterator>
+
+namespace sol {
+	struct variadic_args {
+	private:
+		lua_State* L;
+		int index;
+		int stacktop;
+
+	public:
+		typedef stack_proxy reference_type;
+		typedef stack_proxy value_type;
+		typedef stack_proxy* pointer;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::size_t size_type;
+		typedef stack_iterator<stack_proxy, false> iterator;
+		typedef stack_iterator<stack_proxy, true> const_iterator;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		variadic_args() = default;
+		variadic_args(lua_State* luastate, int stackindex = -1) : L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lua_gettop(luastate)) {
+		}
+		variadic_args(lua_State* luastate, int stackindex, int lastindex) : L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lastindex) {
+		}
+		variadic_args(const variadic_args&) = default;
+		variadic_args& operator=(const variadic_args&) = default;
+		variadic_args(variadic_args&& o) : L(o.L), index(o.index), stacktop(o.stacktop) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.stacktop = 0;
+		}
+		variadic_args& operator=(variadic_args&& o) {
+			L = o.L;
+			index = o.index;
+			stacktop = o.stacktop;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.stacktop = 0;
+			return *this;
+		}
+
+		iterator begin() {
+			return iterator(L, index, stacktop + 1);
+		}
+		iterator end() {
+			return iterator(L, stacktop + 1, stacktop + 1);
+		}
+		const_iterator begin() const {
+			return const_iterator(L, index, stacktop + 1);
+		}
+		const_iterator end() const {
+			return const_iterator(L, stacktop + 1, stacktop + 1);
+		}
+		const_iterator cbegin() const {
+			return begin();
+		}
+		const_iterator cend() const {
+			return end();
+		}
+
+		reverse_iterator rbegin() {
+			return std::reverse_iterator<iterator>(begin());
+		}
+		reverse_iterator rend() {
+			return std::reverse_iterator<iterator>(end());
+		}
+		const_reverse_iterator rbegin() const {
+			return std::reverse_iterator<const_iterator>(begin());
+		}
+		const_reverse_iterator rend() const {
+			return std::reverse_iterator<const_iterator>(end());
+		}
+		const_reverse_iterator crbegin() const {
+			return std::reverse_iterator<const_iterator>(cbegin());
+		}
+		const_reverse_iterator crend() const {
+			return std::reverse_iterator<const_iterator>(cend());
+		}
+
+		int push() const {
+			return push(L);
+		}
+
+		int push(lua_State* target) const {
+			int pushcount = 0;
+			for (int i = index; i <= stacktop; ++i) {
+				lua_pushvalue(L, i);
+				pushcount += 1;
+			}
+			if (target != L) {
+				lua_xmove(L, target, pushcount);
+			}
+			return pushcount;
+		}
+
+		template <typename T>
+		decltype(auto) get(difference_type index_offset = 0) const {
+			return stack::get<T>(L, index + static_cast<int>(index_offset));
+		}
+
+		type get_type(difference_type index_offset = 0) const noexcept {
+			return type_of(L, index + static_cast<int>(index_offset));
+		}
+
+		stack_proxy operator[](difference_type index_offset) const {
+			return stack_proxy(L, index + static_cast<int>(index_offset));
+		}
+
+		lua_State* lua_state() const {
+			return L;
+		};
+		int stack_index() const {
+			return index;
+		};
+		int leftover_count() const {
+			return stacktop - (index - 1);
+		}
+		std::size_t size() const {
+			return static_cast<std::size_t>(leftover_count());
+		}
+		int top() const {
+			return stacktop;
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<variadic_args> {
+			static variadic_args get(lua_State* L, int index, record& tracking) {
+				tracking.last = 0;
+				return variadic_args(L, index);
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<variadic_args> {
+			static int push(lua_State* L, const variadic_args& ref) {
+				return ref.push(L);
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/variadic_args.hpp
+
+// beginning of sol/variadic_results.hpp
+
+// beginning of sol/as_returns.hpp
+
+namespace sol {
+	template <typename T>
+	struct as_returns_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+		using base_t::value;
+	};
+
+	template <typename Source>
+	auto as_returns(Source&& source) {
+		return as_returns_t<std::decay_t<Source>> { std::forward<Source>(source) };
+	}
+
+	namespace stack {
+		template <typename T>
+		struct unqualified_pusher<as_returns_t<T>> {
+			int push(lua_State* L, const as_returns_t<T>& e) {
+				auto& src = detail::unwrap(e.value());
+				int p = 0;
+				for (const auto& i : src) {
+					p += stack::push(L, i);
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/as_returns.hpp
+
+#include <vector>
+
+namespace sol {
+
+	template <typename Al = typename std::allocator<object>>
+	struct basic_variadic_results : public std::vector<object, Al> {
+	private:
+		using base_t = std::vector<object, Al>;
+
+	public:
+		basic_variadic_results() : base_t() {
+		}
+
+		basic_variadic_results(unsafe_function_result fr) : base_t() {
+			this->reserve(fr.return_count());
+			this->insert(this->cend(), fr.begin(), fr.end());
+		}
+
+		basic_variadic_results(protected_function_result fr) : base_t() {
+			this->reserve(fr.return_count());
+			this->insert(this->cend(), fr.begin(), fr.end());
+		}
+
+		template <typename Arg0, typename... Args,
+		     meta::disable_any<std::is_same<meta::unqualified_t<Arg0>, basic_variadic_results>, std::is_same<meta::unqualified_t<Arg0>, function_result>,
+		          std::is_same<meta::unqualified_t<Arg0>, protected_function_result>> = meta::enabler>
+		basic_variadic_results(Arg0&& arg0, Args&&... args) : base_t(std::forward<Arg0>(arg0), std::forward<Args>(args)...) {
+		}
+
+		basic_variadic_results(const basic_variadic_results&) = default;
+		basic_variadic_results(basic_variadic_results&&) = default;
+	};
+
+	struct variadic_results : public basic_variadic_results<> {
+	private:
+		using base_t = basic_variadic_results<>;
+
+	public:
+		using base_t::base_t;
+	};
+
+	template <typename Al>
+	struct is_container<basic_variadic_results<Al>> : std::false_type { };
+
+	template <>
+	struct is_container<variadic_results> : std::false_type { };
+
+	namespace stack {
+		template <typename Al>
+		struct unqualified_pusher<basic_variadic_results<Al>> {
+			int push(lua_State* L, const basic_variadic_results<Al>& e) {
+				int p = 0;
+				for (const auto& i : e) {
+					p += stack::push(L, i);
+				}
+				return p;
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<variadic_results> {
+			int push(lua_State* L, const variadic_results& r) {
+				using base_t = basic_variadic_results<>;
+				return stack::push(L, static_cast<const base_t&>(r));
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/variadic_results.hpp
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic pop
+#elif SOL_IS_ON(SOL_COMPILER_CLANG)
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+#pragma warning(pop)
+#endif // g++
+
+#if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE)
+#undef check
+#pragma pop_macro("check")
+#endif // Unreal Engine 4 Bullshit
+
+#endif // SOL_HPP
+// end of sol/sol.hpp
+
+#endif // SOL_SINGLE_INCLUDE_HPP
diff --git a/sol/config.hpp b/sol/config.hpp
new file mode 100644
index 0000000..c7c4719
--- /dev/null
+++ b/sol/config.hpp
@@ -0,0 +1,53 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 Rapptz, ThePhD and contributors
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// 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 OR
+// COPYRIGHT HOLDERS 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.
+
+// This file was generated with a script.
+// Generated 2022-06-25 08:14:19.336233 UTC
+// This header was generated with sol v3.3.0 (revision eba86625)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_CONFIG_HPP
+#define SOL_SINGLE_CONFIG_HPP
+
+// beginning of sol/config.hpp
+
+/* Base, empty configuration file!
+
+     To override, place a file in your include paths of the form:
+
+. (your include path here)
+| sol (directory, or equivalent)
+  | config.hpp (your config.hpp file)
+
+     So that when sol2 includes the file
+
+#include <sol/config.hpp>
+
+     it gives you the configuration values you desire. Configuration values can be
+seen in the safety.rst of the doc/src, or at
+https://sol2.readthedocs.io/en/latest/safety.html ! You can also pass them through
+the build system, or the command line options of your compiler.
+
+*/
+
+// end of sol/config.hpp
+
+#endif // SOL_SINGLE_CONFIG_HPP
\ No newline at end of file