From e77690f7e0a23e20126bac490a24a0ed3c3ea8e8 Mon Sep 17 00:00:00 2001
From: sigonasr2 <sigonasr2@gmail.com>
Date: Fri, 18 Nov 2022 00:46:24 -0700
Subject: [PATCH] Remove unnecessary project files

Co-authored-by: sigonasr2 <sigonasr2@gmail.com>
---
 Block.cpp            |     8 -
 Block.h              |    14 -
 baseboard.png        |   Bin 1454 -> 0 bytes
 border.png           |   Bin 7475 -> 0 bytes
 car.png              |   Bin 36508 -> 0 bytes
 circulardevice.png   |   Bin 1234 -> 0 bytes
 co2.png              |   Bin 5408 -> 0 bytes
 coloredside.png      |   Bin 699 -> 0 bytes
 config.hpp           |    53 -
 data.lua             |    33 -
 dependentClasses.zip |   Bin 1290 -> 0 bytes
 diff                 |    14 -
 dirtblock.png        |   Bin 35629 -> 0 bytes
 forward.hpp          |  1321 --
 grass.png            |   Bin 541 -> 0 bytes
 hills.png            |   Bin 21821 -> 0 bytes
 lightup.png          |   Bin 2593 -> 0 bytes
 main.cpp             |   175 +-
 quickgui.h           |   786 --
 road.png             |   Bin 8452 -> 0 bytes
 sol.hpp              | 28907 -----------------------------------------
 start.png            |   Bin 3141 -> 0 bytes
 22 files changed, 9 insertions(+), 31302 deletions(-)
 delete mode 100644 Block.cpp
 delete mode 100644 Block.h
 delete mode 100644 baseboard.png
 delete mode 100644 border.png
 delete mode 100644 car.png
 delete mode 100644 circulardevice.png
 delete mode 100644 co2.png
 delete mode 100644 coloredside.png
 delete mode 100644 config.hpp
 delete mode 100644 data.lua
 delete mode 100644 dependentClasses.zip
 delete mode 100644 diff
 delete mode 100644 dirtblock.png
 delete mode 100644 forward.hpp
 delete mode 100644 grass.png
 delete mode 100644 hills.png
 delete mode 100644 lightup.png
 delete mode 100644 quickgui.h
 delete mode 100644 road.png
 delete mode 100644 sol.hpp
 delete mode 100644 start.png

diff --git a/Block.cpp b/Block.cpp
deleted file mode 100644
index 5f224f0..0000000
--- a/Block.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "Block.h"
-
-Block::Block(int x, int y, int R, int B, int G)
-{
-    X = x;
-    Y = y;
-    color = std::make_tuple(R, G, B);
-}
\ No newline at end of file
diff --git a/Block.h b/Block.h
deleted file mode 100644
index 2f4a7fd..0000000
--- a/Block.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-#include <tuple>
-
-class Block 
-{
-public:
-    Block(){};
-    Block(int x, int y, int R, int B, int G);
-    void display(float CameraX, float CameraY, float Zoom);
-private:
-    int X;
-    int Y;
-    std::tuple<int, int, int> color;
-};
\ No newline at end of file
diff --git a/baseboard.png b/baseboard.png
deleted file mode 100644
index 484b491015ac1dd7fae9d3030f62eceda031ab96..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1454
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K58911L)MWvCLm;O$)7d$|)7e>}peR2rGbfdS
zL1SX=L|c!;4l+mMqrF|V`N}jNO;~6ZDIhASzSc=lt0ih-DEnmZ{R=#uCp~(ku|rJe
zPsAFl9Tu-&J<#H4l2_>S^Xt+Jdh~yiQ?~?v-|vs_?md1d`yfALMpjub<Ek{tmnlvs
zo`tnu(5@166EN=ZI&<Z@iy`azkEQ(b@$Vnmoc?`h{$l@=vw1#n9@*?;uJefZ(Mn(M
z=X?BR5>-7F?bPK=Uo;)*kC`4@_c*5H#(869H#J*-8AY)!S)FnNZAq<<Duq6Qrl-EA
z$A($t7lvt@UfZQ!pJ=gutxoaWX9ANVjtIGMObB$A6piS(ylP^SlJ9R${{IUei=R}T
zyqd?Yk2PeWQ_-IX^&fUeZ#FP|r`9U$@Zsn-`?kgldKcE*{`P%iuDO510po(DTmN2V
zGx+OSwRi2&zJ`Cf4<7AWd$Rh#Q$B&(ORCOAOBj6X7c%Ubf6@GDLu2%U^s{f*ZtcI!
zuHYQIG_RrAIbn&%&DV18-@SYD_P+7je{~E^+(m2Wv*#`c#tUbGM`SSrgPt-7Ggd6M
zF9Qm)mw5WRvOnYIVVBmuks133C?r|p8d2h$pPQSSSHj?2l$uzQnxasiS(2gP?&%v4
z-pD7;z`#7+)5S5Q;?~={hIxk^7+epk-Z~u+@cyrNeETg|J%K<MBeOj-nHOaI>@Qv7
za_3$DbBjyc);q`7pUo|}_cQ*K{jm?pN-5X%87{pRXL$LQyWz_(R)?y;ObUDJ7$?N-
zXYg1b&#(labp7q=3@_H*=OsxK%uM-YpZt?MYw8c}Y=6n7@HbG2;ga}D1`m5Tu7)rA
zflLc_6X}R}hAW&5j13G93<?Ya3>*wB3{1#eyDK)o<oOQpqKcv^!pH5o{r98IyQ|x4
z*Y31@dfokrK%7ODz5Tr?8>UEmrVVv034b{b{1R;Vs?6}(o#9$P!y0+U2&lvq<_&eb
zfV{g5Yv$)MT=O?)c)eV@;p=7I1HWFfCHyTRT3Wu}L4l#;<~LP_U9ZcTiHaLoFq0Rv
z$h!Lt^S&SdTwMRlJfgVRPJQ0_i+327;0tnmp}FUB2}{h)i}&Y0U^}2JfDv18t@Rea
z`gcAgKk#ZMS8n~ferN2f2A211FV=zL<R{6o@R1`0cjUrjU0oJ6O7|Vpzp^Fjsf<Ty
R8ZaL-c)I$ztaD0e0stAxNNWH9

diff --git a/border.png b/border.png
deleted file mode 100644
index 683feb5392eb9dc84c6d8d638295667b03a1c975..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7475
zcmV-39n9j1P)<h;3K|Lk000e1NJLTq004CW003hM1^@s6rHfBG0004nX+uL$Nkc;*
zaB^>EX>4Tx04R}tkvmAkP!xv$rfQ{B9PHq0$WWauh>AFB6^c-y)C#RSnB4RQO&XFE
z7e~Rh;NWAi>fqw6tAnc`2tGg@otzY1q{MTRLW>v=T<*tz&;N7pxqwhFGu7-E2UN{6
zQt_CW$*zilR|GMDF8DAcF;kyQCKK?iuY2mFx{LBG@4i2)N6DEC@QK8;OgAjz4dUrd
zOXs{#9A-sHAwDM_Gw6cEk6f2se&bwlSm2pqBb}Nj4ik%oHkR9%6%Cbmia4UE8s!Ta
zmle)ioYiubHSft^7|LlY%Uq{5j5rptgd{}BsG@{2EJSJ7NHLM3^O%Q!(D5h9C6lWJ
zMvetkph9x|;D7LYwq|~E!c7XrfX)}&{uluQyFjC6+uz5w-8cdK&%l+|@>lA>%qQu!
zmKHezdbfd#>y{?(0hc>K|C25mk|X(P3Hdzmen#Jv1^RA*;F>$P<~dFufHci2aRVG2
z0;2`WUiWx+cl+G_?P<>M2OHjUgcidRwEzGB24YJ`L;za=GXPs`6qXPG000SaNLh0L
z04^f{04^f|c%?sf00007bV*G`2j&VH1_d7Io#!6_02?n!L_t(|+U=cPj3ilh*MIjT
zZbU{#W@T07)buvJz2jjtEX#V$hhJc2qeaL98QB6^D};oQk&uOqc(9R$5Kr*HGctlV
z5Dz?9;t32360F&k3<9C`vb)}o_TZiA>FutruCB_;jEuN(<9_gvQQ2KHwd-lIGu12Q
zUn+H1byVMo^Ur(k|DJR12?3PA2&jfX4WIzQ4lg?r5C8|XKn=8dAoTz^0uBdqGeGWa
z_R=E){Xpg!Z~{Elz!-S-AO4L${pHqn?Cl@1y0{=SkXK`b?eIxZRV97wNPWabPcB9%
z1t({ZnN)}9Op$y~jEPaTN7J{+E}&#dms-Zf2<v)+uhB|l`<~U}3>^hYWlX30cp_lY
z*@S78lS0B&BZ3R`4s;P{TSqPgPV{I$M#_lPlBQjfVx(^aR%93fT1D2aW&iM1F3uNZ
z2C}k5bR7}NbUNno(;Af`T1BjL%=V91JUz!0;(gEGc}waeQAV;<AVlJHal)iJ#N?Xb
z93;rcQ)G&Cz5^stBt!>FEArWhi_>$;@ra9y1*^pwGO)G5W-3{vuBb{w3W;J`lKM#3
zC1mdDohM7+M2~bO#sE_A_x|aB{As}I!Q~#r82G!N{|V}4!|Qi{97;(se+^=U#W5V*
zf|-WXW8AXAP;UObdjyTdH^*3SDa{;-#(9Ty9*1GEJZ3(d<9wu?O*c1<<n-(T%adbH
zYRemUKF$1R{u1?9zD(r~Sh|OlQ-dx_&?Phy^eIf|#E18>+EMD)iS-GxoYMFQn|o>^
zzA(76nn;cHZg{3oU;9kU<C713?Tb7=F;d$Ts)IXFXdZm!n;hM`gPB&;i-%MPbBOVW
zVuRoK&Hu)){`3FL;BlYmVGXT>k{lh(`R~8?f4O)52=6*Ve#)rGiD8N20VGH71I?<V
z%rm-mkB{GCS@(>qNKlC)n}CxTDG?di&LI@gKSJsZYb~SFkc{8V04=Cn!?z!NhvGZu
zh!n`uF|ekWEz&DYQPDOQodrS=WTL~VfbLIOuTGil-$Iy{wF}tAidSy!bNu!rbe>UU
zIi||Ecm9aZwlF%S8jtAR0^)sQ?0NF;G5N@lDT5m6Kk)gxwL>d~Z#_|bo5h7=Tt#{!
zWids0g~}7Yvq*7_p5(aY1^(Uw;VdeLeEftitlnpX@mm-8t|ONfO14<mS8R~y3D<uI
znOZ`Y_^W^R4z_Q|g<x1Zb3KTnY*I`pj_x4T6Mp%h{9EQi(vi6E0VxCsNsI|81qgvi
ziChYr5J)khv?L`+DIujokVpsw2_FJdDwGr$1U5yINQiV*i%BWbN#IgqUkJJs$(5uf
z(S}Ga6l0NCMd*nL*xXMN#1uF81wbJ9gpdM(KubvuXaN@~u`d+oF+fZt5fKQ45TwMF
zYtKXEP-!kwB!);SB~41#KEIR#DJ3x_gpe4K=o1Jji78?L5ZDlqLV|!K5{k|5JcGap
zi5IY!pi7ZV2wD=ofGo)?Hux()_2ZaHfsKhvEu;sPD;Mh(^+}CiI{?0RvixnJ8~$Al
z!s#PZ#1CJR|NHm`RnUX?E8RG#-2~*n^4EUyvl<CPf=FC)q%VJ?EJwKI8Ew7BY*y>;
zAOD@t{kiCRh=SI(_>h>r`f=LEG08kGbR;K8GN6!1Szwzb<Gnd;zaq4fd?fHFWDKOf
zMNh{Fp-?HK^$y`ZN-K)dnBY2cp?Q3EMwS(fXCpEsy>j$1qwhLOCCKv}U5+^a-a~}e
z6jerd;pmAFCDOqDIHzt~g2>5z!kI`4E6VH;nFSsk*F-U9Humh5hQ?a@WEdlGCen8o
zl-VI!k$Csfia^PDoHH6_+voSm(YFbqA_@uQIJ;uJH%A#siizI0_#h}MgX=u5Ut^Lc
zp(u)ywd=MvFhxn~9fis`d3uJ@`PK$O_jEyTZSePh{Xc#26R*FHUDiY!Ddn^Iwk36x
zX{wn-OGmev%8X>rum1AS;C;=#uf4?^pZt?7qNR|MY4lJ@Vl9yvh!G!aqKnAs4C@-I
z=@Iwe`Wm<Iyhf}WoVUoSK^Ieq4(BA!FR^va?KeLIXEjs>aj^t#kTVTFg3+9vE|C^Y
zY$$IZad!Vc+P#XChWYI&r^jcThpQ^0@sxVABh$qJ&FKO&0~sYv?WpF4dg=Mby<<N0
z=Ftbf_Rbq`Vzm1}&)?K%l+z=;T~Zv}!rK#~GeliOG}LD`)1&DN+u+}Q;p_Z^fA${$
zc=GTe-hB+~dfMk)_?Fa|dQ3HCw7-WKp0RNjq~tfh^bYGq%a^|PTbMn?el;Pi0#0|N
z;1O-XsG4!He22aLLs~q&O%&xm7mFwK|MOikpD2qFaxW*vNMSU|1-$Ob^#SSYU&eQy
ze6&v&mm7a0ELs>6ipOUSqo^^tBNLkBJ!{+28`z)Bc>MT#C~wH8BZ_H`QF|oYQ(t@&
zEgjY2KHhoqy%8w}R8sWoCEtF0#wgpra_wk;kK`le{uu9j@RDd(eCxsgA||(eek&|m
zMPi-5@A*?mWcncqNx%9!x=57f5KB$FT9S_^Wcd%afsz8BTC^}=6Tk46{|uw?W-A5g
z{b`PiOMF)o{57Oz*&f7_<l|PiOez6|q_Zu*_AkCj3<;woesJC)Mue247!g8}(&l?e
z#0V*Yl7QH_B2wC{%3DDLN=Z_Z7y?~N#3Vp~AYJN);aWlP0VySE_*AB}5kpc+Lf8l&
zsWp&LO5uHk7*R@Kq(DZ<q@YV_vn-{AMO?X7NH9W>NrjQnhPb`9L!jW==T}N?#2R8)
z@;1UN6Ouj#q#A4>pb!kgMr>^mqM#6QGoFx0B}g%DZ4iCrFMRehTg?N=i`5!aPSJTb
zEVu6=HR%L%v-u=%j3!*nIXO9n(TuUw{N9trzXIL`o&xr{MSF)IE-uAsF+}<9{G(s`
z+~0hU<`LOwgfW^T%de2IB~_82Zb&hZ4U4Xbo}=5ZF)CJ@S+*hcJA)`(4<FhcsUHrh
zm(jjkK>B`~r<l%Bqwj9K!24!u3J@K5Nk3e$T6DzY2gI<XNs(cO9uI1}9^#HWQa?OW
zC&TyiYcvm+nx`-&TC4Yy>TCmXNwllY`T|H@;%Wy`u`eax+qm5IK<IKu>W4~dHvD}J
z*lRQo&ugCNBM4hkO+E!*vFIa8Z+`4;M^VjD;vsvRFjN>^ZvWiZj?@o_R0dmnz+a<z
zc(3MpAE{ai&<-J<Et6|k6QiZ~fk!c1Mm4Vc+Tp{=m2U0(0W}XipELCWoQ3^rf*3w0
z>n`A=p;>j<wBznZ8UA3J=PIf7*#)tVgjGNe{Qc1%yG7v|@=POkg%CH252AVAM{1OU
z)8!dfSh7oX<t^Nr;#+@3GVk!w;|FUVf2nz{l8Wy+x;;k_aKlV)o51l~5AZRtuXfcf
zH;E6Zd9IQgM2}n4h_*lvu2zdgeO9xqd)8^^es2;lqIsT8KV_h-h~sRN!UD2F^Twy|
zGT)o*Y71`|tJMNs6!iWX6}N6z)XN8iwL@^tnyRu9K1Q0gh09qPOPYlz6%w~wQg0M*
zy!lC_hIX~w{w%B`m7ZZnk{GX1zx0yI6dWFowqd9cdWvd>!0fi8H;mu?>hIu|HTif#
z97JnbRZtb=<9+0H>NohFMcq)>-E;fc4jCI{*In7%?(orLHl1^JYVlpaT~obZ<9$6;
zYh9y$tNoJ3d5UtM{F3#U<8?t)J3?=KP3=}xvkFx9Oc7@pRap}1mh3srvnBQX{1hW2
z7mFvfzTbG{WN8*>^nJf`zBh~)(L7sHMar1nx`Xu|r8b+}&UY-DGm?nUvhX|H3|>I<
zJPQ+ESln4n5!tSvV_h;Y=g6S0EW|r}^mq}?vt>%A9&a1U;#q1(Wf`(CNS*C;(hcK9
zG|w}kR2q;GCK(K=orI&1hIP{-<SzPflXwx$vn6#hdxgedieqspukbjkD&Or>Zx}D4
zdA6jk?V6+cj7+O%1jdLfmn7r2@!%b91}~y{wts8t4jn=INV+62YD_c3CxLq|3$VjS
zj~CHATT+X1ge(fY?qSHH=Mp5Ikw~N+sW*zFPy8WfcW;xGiC2a+sBNBdc6^_vX|_aP
zCDkZmtk7citguNboR+jMzUR2z4j(nT+Tj)r08fWWr?MPV79{NDQH-mkqI+bqKt{_%
z522{gqNO8r2_>_gWp8qy+BGcC7G!3;T^^N^R7FW2{5Hsch1B2`%abL(^E88!%ESm6
zXB7KK{8&-!EPI16g}}&$cG*x2{N?!=JvG?2+m^UoA@!o^@bUni?@<nEfQUj)4@kb}
z?Y`St_6Cugg6ZvB=rP!VH7x|Xm~k|p6Z|#hER)F;GmUs^)|YE)*AthPTvo`m3lrX~
z`pt;WZ(1s(4S_Nf#Ci!vAg;^Oj8(v3ulz?NGeQ;;SP#eacDO01u|gkBan@4~4FFE-
zHB4_&PG3Q&Yxb!=1|*&&EX5EK)JA}7=w-Xj4D4_-@LdnlGn#1fVOG8}-A7g>#I*T(
zFR3mArUos{wwSx~7RqAN@<r?-N;irWz)9LR@}%Fm-}UMO{3*U!Ty@pY?Pzc(4GFdN
z&p|ZcYm_O;cVWUCCe=cH%Ke9nEp5RC@S41uF}lwEY7$W!9-h|J!&HuBG}hv*qutg0
z-mLqLIVU!9c<W=E-cdkl#vmP8sjjd4jY3f$pHX3W)^1@$SstOYz~&U=4mYNLrAJDK
zR(>12?~(`SX;+KuljH`;d_KqIj!RZ$Y{7U!5R9eTS@s6uJj@T~WI}9fe1lLlr!`&M
zU7t@~)aO{cAQPHOUixg{EFx3OMesYz-sF<%5}Z296fwg}m<2~!7&Q5nQ;Azr^SlBK
z-u2XB<7zL~=QQz@kR^6Y>dm6*T54G%3o*3N1wAQnONVc|D>8OV>Z9X_G`7Y%yLG<@
zdo#3@=zc=Q&i&pb#*-3>$6Ilk8Rh)x1ulBZ`5ygqo^(s<Y`RA|o6;M$S%4@L$jEwi
z%6b=3x={q{kjn~%-WKD##&LRP@lK$g(>%{gMB5H&O7<r+l)BugMsUTZpYAUBaHGh~
zh~nTDB5mtZ7)>%}2a&#8Tqz8E7SNxLSe`!Q(W3{1uyMaR8m%2s?_$3<4cj-I9DkKQ
z+AVELXe^#S^w)1`nni;@i)1n1UeF4GFAA(ryPgj>j3O^Nx^tK06LBalvfeYRjxc(1
zeT~xIe8%lh-zA@phNh7ax{hX9V;8F{H84AT^oYV^afq_qmWWQOeP|>aMXs({Q$>)x
z^_BZ9Pr7ZyKcyb;EJ*~?uI~3nA(STiNM~zCgTBeKo?;3q#p~TKnPGl+%F)ptqoFiH
z<r%Z1DF+9yQYpQ&>`kg)7twM?KH9?#6RcfXTvOBb%k9sukSg`&jS9L**den%DhxV$
z-136D?{}8H$u-rKNNosxiyuU*&MSyhit6CXwa)_j)>3#$uJ^gz2s!UTSNLR*Y8QOC
zNz}~}dwR;K+S_{Cq<hR!h04_Rv0st($Qksq*+!K5;5mJ8pJ<!iKJ|v7bdISa&MnD@
z+^I<ccY4CfcOM|)HKe{s_m3Sudgv%H<~GS|+~rhNIW89L%?__jx-F?M(*0wH8&JOm
zM7<;`yHUHq@?t@(m*`P(edWW8bpP1lqlb~OJUxM=w{PAuvY?ns?E0Lwzb2snBHcfB
z_~>D~j&e4~*7lhwG8txeo1&Urf0S|8@$BVB+jv}KF$G+{t|Z3It2{~O`Y_?H<Jn8@
zehUM-051>&L3w6~XG^4(aGg-vbv%2y5mREhsEN_Qa0JHLK&&+0Uwu8$uH)H{%1l)m
zx9?0bRoJv%2ecU>DS&jn``vXsd&z~8b1cqkyi?nah)g}QX^6eOeAVWAB1*fCXD>DS
z5UFOjDMwRM9A5n^HBm=|57(ci*>ya7xuHbj<oIn)j_-3xMQ<CdwRrSaJY6Am*YWJ-
zMp5liJIDUvE8D_A+qXm+SvQL-`R-lEvmX(J)=_y#w%fjjw9HDh*G$LL&3ohDOX{xU
z*-O5q@s4RV#fN?y`xROvO@R+ryXWjWp8cpmB$yY7k>1vj6+*FCEHUHJw)fQ)Qg<EC
zUUKyt6B1Bn#I}fmz`;QY^w&p}ZoRTcBw}s5Rlib2^n8X9CHs2UN9jg|(m3bANsaYk
zOJI<InWC5=#WmH0yHjs3H(cFtK!I><cPAq=Mi(B`id<f^rtVI?z1%3vF-2+7$!$q9
zDiXa!k0!&5>)%7_?$q1M4ewhDX&CQMnO&YFZxS*t>CT_>d;#z7)Z33vObORm7N<|Q
zFU7TKjV~g-^!RIEjIcZP_HwIV@2G8!^nu52lW>tjqV1fqIzl|xk#0L{Kj5i1an08b
zAHuHmy*AE@99w{w`q=~%k>%-qoLz1kW?dom1D<+Q!|!A~d%OKE)b!zynhmzrfELPd
zdwz@Q{u$-glV(hBzk$r3UYTB7Qn#nxzV+@8I`vinW1zb93OiCiG*UG%8SGtj&60cf
zzR7Y?(+r+e$^d3T7oK9DOO0+x{eY+54uM<4udD&TBlSZibv)SnAU262mZW~Q&B#Qp
zX<S5;U&+#JNnO_Gy!NTr$-nmY_5v*=CTb36^UHkd$A`=3fMwG$Ye(vbL#i4);~{Wo
z^6HFoJ|!<Mw$+|}*HIsz;=6QNV0e{Or3G(&`z!44<;acCPSxyy>C~W2!ROw*&7b(|
zcYo1#4voRJ9g|sw_Y&8yaK0zcDpVAtl<0j=Kx4ZVRap^2MCCbB24sX)dx2|e)}3d6
zdc?=y{1lHLewRFqX!;AXTvHf>6q?=%kPW6NvGoOB21@p^ZjH_hT)aR;P4eLADMx$6
z*rO4w+6%gRMbifk_g>{=fB28^<oF%3zQBeh`6$Ea3@J3hOOOp&Ub4P8$ICz^4{*Lg
zW;xa`P-NS24rhmyrDC<Nv7JN4jOcpCdt<zp*lvlBo;<6_kc1HF!kWC?Bh!+nPo7fb
zB_T$#q5wQbN><GUcD-U{dtRB{!eoYj|6jhr&;PMcKo>5T&lH0vN{^-6rc1AoIv$n0
z`I$GkcmB?$;EF2C;AqOv{lx=*?q}Zw=V?xB%EI854i`PAXO`JP#IiZ6P9rI%5S_$Y
zOOz4qHz}gUV#&clNh}>MN-7ztn}}~B)$P}b?vogK04#`liF6u@8NP1Ng(rH6j7xkG
z(RR-A^gh$uZ-80QxJZ3`N|YYilz+fDpZcMUbL+J?K)M&Qi)(6#Q_N9CeRA@FZS!k?
z`)4uofP1UoVu%C9+2oM<^mS%?iz}56&oy38XkC$FVowSlf+u=@<KO%by!DKV2~l{u
zq%gii%|@J`oYO2@s#%Vf8Ebc+{n;zzMNi*nG^-U&S2G(;iApin88-Czye0P)F?hTZ
zDB;mxeT>LUeA`oG0#Z-Xnh-25cuY1y>quWmY+RwFL@J2?`w>zFVwT~%4(A**Goi<m
zMi$YI5JXZYA@x_r85auIS!AAFJ5DdwknVwqFpNWPXxA;l_Y_}xmukF+^&MX5YwcpR
zVP!XV(Wb*KEi#{wGROIob0+x&oo8f8ZSPsTF){e<J&UhALXWD!HkxwdetnD`PSyxD
zVt>QgRZ^wNKuWA_k;5|i>;L+Tv>}0zq?m{)5L4n6ld%#IW7??Vln_FZh-jsWF_ID_
zHpyElBudI{hZiXYB!Nx|CxDdD2m*qb5+kL^Qld@~AsG_Da+5Pmn}*XyZ~6(vm@q)M
z`36V`DUnhP2fa3>=uT`rl#Focz;Y?K<D_jh-ew$$zy*(f?p$sm1Ra7H1}P!b6}!Az
z7%o!6`-m9E6DUFoNU0#D&FMiQKqO*JXnA?IG+kLz3n@08LEmGWTuAa^R=Q-7M&d%^
z{5tg;gNCI;=8E%8?lk}XlhqfWTeRh+Up}SXNttW#A=@Rfkwcf_G|$WkZ4R*A?_TMi
zqc1Nml%{Dc$p_xN`wGAG^RIn&G*+}-<k88By~8<~j%Xn;A&?c4-U&1ckrFmoQb>q=
zMDH5L<&5+5$4vJ23AQ7pKr#}k3#5pIAn1Kd?0e?(Te#MtGlgwCkcy&Ih?q!HuvmAf
zC{W2!O)AdL&ygV#gkn4?XxA;tCsdX}A5oP;>SE)<k|acn?;Hn*ui_eq$u+j^kXmC3
zNeU6A6=$_Yc*sP*9Y@Es8E0CsTCPbxkr{*ZiO2Pt$-yB?28@yvDIzokFR$1|L`bF}
z^exJaiN0ezp3pf<>KuLOQ6r7i1*AaVv$<#In9pzFZI3Y;Yda!xYn%W2+uz}DeSU%P
zm)?vBBt0<SUo6(RX36LO{GZ|%e)=cSM^lI%oP_$66C07zF+Z5YsoOL^#3Pp##lbC3
zj=##$ox4~Z(ML>io0H?WsokbvYFbTUULb+OXrzlcV=?j;_?p-_WO+p7Y)B^5XjuZ9
zd-u;cpr9x%g*3RvQrj9^!0q`h?%n$)MJy@jQ%>J*c<m?eek9|3`j5|F*e+VmklJ8R
zPkCsU|6jKGm0$cR?%h8l*zL};2ciZXP)iZ{!tcC;`PK;{<zzEMziuIUNG+rhQS|ig
z9imM%-I{8z!Z#LEjA^=>$-NbQ>JeIV{`4Cd1;uoq)OPgtK8S<|s__V!KxP?2JVvUT
z)kRB`W6W3}V}~HXNaL3dk!3VbS4^f8dbb8NK6L2O2%*ntm*<4~jQzWZJbC+!@jH*{
zVq$Mnk_kytikKdeWerVj=~IawC5-f>=uwrSJGUgMamzL1s`|d;(3~^9({lX#Pr0{x
zOb7)!3s}3c%c`x}pHFeCc59dNTT9S^Bo*F9#^sd7;wh$@;cH9m?;{noKC(9{kqNRq
zrw`BWIfx3GhwVLI+9pX&^!26tT?0-7EpYZPzwm!3#U?~F5{f7iIS@%SKqVw5Z6Xe5
zLlT{oNFpJGz(_?55kI*9LMa-*=_2j>%_m7KMWHoq2*ePPQf`9NBEhhK7D6%-i7q9g
z03`$(=p&Rs9Ro@!I_FSQZG@PV#1P0#hDZ=XAXl0$#Vg}T1u-OiOem!oi9|2Jr-Vpg
z<VKJbF;T~W5R%^a+i|qsJd4tsGCU(-suZ~pv@v~OyAacGq(4zAjZKL-h^81e;!a7q
zz2{BrU0kt^kBKbP<SA}#BhqI53<$=XApcXK5kqw705}?=7u66<-j(FP{D_0gt${P(
x1bC`}X1Jgmm^RNV-5p+PTq<HW@VEw={|9x_E)gy@1jGOU002ovPDHLkV1m2?O#=V`

diff --git a/car.png b/car.png
deleted file mode 100644
index 5341b13737c5aa30609a603a411650662c6ec0bd..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 36508
zcmV)PK()V#P)<h;3K|Lk000e1NJLTq007be004vt1^@s6<xX{|0004oX+uL$Nkc;*
zaB^>EX>4Tx04R}tkv&MmP!xqvTcuJeB6bjQ2vVIah>8d<T7@E12(?114kj=CgC-40
zii@M*T5#}ZvFhOBtgC~oAPD||I665gx=4xlC509-UU<BZ^X@skcOT%dmzipIi~*`<
z8L32E$YfWA;44D#p%*h4l9;K_iDD9-^>t6ZRCh6+<=yvZbt^fO0X~6vmg$B?yg@v*
zY3ZEzi6g8iDa7Z*qXu1&_>t?f%Ws?u4*Pj##7L*+i6g{9p^fD>W<^6Ko+OScsz&+#
zjLQn=EzWAW%9{7&FAV3jm1VBe8bkt%Sb_)vGO8${3=1*ZHBwBZ=sfP>A8`C4xny#c
zz{s(H3RFmrAN&t~&(_ROjJrwUIMDfG+aJR~a2IIQZ2SAzwi_ov;2F5mTK-BMnEoWa
z*3zO!K+iUCaoy77J>YT&=zr2BLvo}5Eq^`_yr0oGWr4n1AhhPrt$B{q2Ov$eO5Okm
zhrmdIve!M{-PJy~e|wtq`vIL&a=3KwmrMWv00v@9M??S)0KEVJi}h$-00009a7bBm
z000%>000%>0gY5FH~;_u2XskIMF-{z0TKWR@4V92001BWNkl<Zc-ri}*^*@0b*A^N
zwf8=Q4>4tC<WyNBNRS|*mKtPBW|F#PCiG>SOc#{ip!*TXN8l^89--TGCDV-vnJCFj
zQd@(RL=YkiKozPg=OG3UAI`9crHkX4RUjKE8j6KR0lCe>GQ%Un{S50rYx>u};q`jG
zUa!~d^?JQtuh;AKdc9t+*X#9qx#ZX7MBl2^sw$wW0GJtO_Uh+mhB$p~5no_sEr=;T
z8QuzB9Z{9b1dn#RUuj$OzYaI}%^>!*qhtQz+*8*zs!B?UoHMG5h>&xB4WuuOB%wIL
zNYurc`HG!5{%XDB`&#U;H@&<D(pPvL*DZGs4*6$C4Q<=vy=NE(a?UvC5D`*JAo3av
zUtrZK&<7*wNNa_I&~Ry<rJOT#TmE|U+9Q3X){REL>$CsX<2cIoTK?6&dEob(z+qbh
z1=7gOD-s-~lqtro1CH>SP%lrf%ctRA`I0Z!XG6`OD^CBC9|R7aLSoAP`V^3Y$n@Ej
z2#t3n96k?(oR}-zodtelKI6?)?32|L;@zG%W+pt@b@CcWzhvv{bz^TI&3SuP(ORJ^
z#WKRZs^yrP^WJ|791%nWGkNvB<?+?)(~DCc_40co{aOR56h3o(bpHh}pEXm63?_y|
zhc95EqCt3Tk@;snkd_Pcs)(yN>m%=@_UF5;yav)QQ!Z3_{_*h<zkf1gPET*fSSr#O
zh)H>{+TUn1L_k#l*&DE7WJF|NkdRjeiI-1Yv+_%R1?)?G_h<!W0+EQIrqhGSCQp^B
zf{;)%h)Rh{-6-v>=FKMan+r!RN+XUejvsfCio(+z?cp%WYaso5SV!K!dzsRQpMCA#
zVa1!XnmbiZ5F=w4GtO0c*o{2f8YvY@DX1!{F9EU#j0>Of3WA8fGLq?~!msl(ovwx2
z{$aEae|3L(#!+x(#G8;xpo@-qH14|0=?qTVhE|1OMi!-nz&k_B?cEg*hfhD}n)82r
zmeU`-2GTDgggczE3`&e0B95l2dGD}gt~INjr&x`6N3g(dj11YxMW?T9s0ogjrSJ(j
z8Bflcee}1l=sC=cQp%SeI{mUQ-N$eWh#De>Qm~iB&g_w_Ac|Q<5>Ic1J{segSoaN`
z6DR{kGEtQ~Rn32LaLAigYi5}c0y{Atb;BQiv`zoweC+?bufnzY%2~$kfc=wehy0T}
zw|R43W8;oAMuG-*rN-x)u@8(1LI?yY46$chB3E%n&iPf|^VyyfK+LiSQhD|B$zwq&
z1^4S-mNP?jdcZhu`y%I5a4<7GHRL$uN?OqsL8Wk5Cl)&3v_id-Eg=+YCj_q)XBg1<
z2$k|IN4|T0$)7$x=P$3m8X@0T&LiFSHD3=)z9B95T!l4(7!n2L!CHAX8qYV0G(zPK
z@kY+zt-||))5!y=3L^W)EEBLAjYuW?oM>+(p8=ZMuQ!hJtLJW^m|-TE2)1`gqG>8f
zsKZI2(E=1=QqD?+FAy=3IJ`NID&fvi;Ktlhxse$yLgGdeI%&D@=RDJV{;cGa*FgIF
zEGEpZ+1=2x=v#J=c06l3m<RH_q4<hIVP~1MGD0jg=Ex!-j=9u0+r08d#^h-}n-d*2
zhWDNjDnuqPWaNFmB*?Ejkkpe>VHgYjm`JIBc|cM1WbMc*C=;_G5D`(LdAd|l`H|gV
zj9CeyI0{{XJ`Z%`C0G4|&=2%|&ukFx<|E$l)$y3O?_TE3hp$7sFSt(Y#rZedqvQ8V
zU^cAz`mmtV3mOyV;X149!tBOvMhk4O*2FQh9tQlPos#2JXtF?%S8N7VrIbR95$7CL
zRdG5?95=#oBLouJz(gq~)06f~E`RqSQxzc;$Qao<L=|7a7wEKteg8&fpY&(I_PHFx
z-@k##r|ki;kzEO#?HrFch4lzU6?KMK+=s&+vY^FqMZrN*7$xCG1DTUj!s(8>@wCl?
zd8LH3M&92MbB7YS!1ypYF4~5V-N^qVE1sUOerfIXE8&rrMUD@Oa%XV^=GVzj=j_Tg
zIx<~cu#p|xs}WL1jFC`R)YMZ05yPA?su56%6|4Xv6cda+P)w+*M5rC17Ak~-QB<)a
zlu`)(%e`DpX`mRQhGX)8LP5k32XhzqA(l}L3WkZi3PDx<mkOkqAw-9aQ=X(|SebH3
z#gS741eNK!jt&Y1mkX5%qeg-h)C<Kqta$p1kthY371Hd8-6+Vg#s|lpqZ97=nxpNC
zxLfh`b!hhm4J;-W8o6_2`2XUF#eaQ`@Wu@QhKEZ2{u72jea^0p6t5iA4M8$4CJN9y
z<0=nq5Mqj$8O}|mgPb!`gdiia8#pv&nS>x^@<vl#YO36&{N>&Z^9+^|uN;Po6Yp7=
zq8P;qAx1ibRnA<*NM91-6m>u`O8%l;!SYjq1V9kFq+ImE^FFf~go4L8hf*j~aM^G;
zQcyZgNXZ=GxlWB$1y7+kV{}3pAV2F_`$RaL(f+q@a{JB!2eoHB>$v>jii_{P;Of~(
zu?ASZ2GSS1y(4+(+3<|(@11b)pIzhhcMcHmc=7(0-ZotR>BmUtC{=-65Ce?`oX|_*
z$*|>nX-7)wRUheP4++3I$6xlsEC_Qqd4gg>kv%QOGX6{UNSkp-S0dgSZ_khUo%V>k
zp`}tIEBMjzykvgVcl=<x<vjK{73S)wEF+=$a^n9zn8tERGS4nLwu3T6FmxYg8dL!t
zGtQv*uyvWb81Gg~O0C=!Pbfkzk)jDJirGL)nda6_Zhup_{jF=9Tt8&}$rTU&cVqR@
zBX;?UPP^B|hA*5uP}maLkhpu=^3EG~`0YFQK!hKzp0GK2$YUo|IZ&pUXS(^pF{*G;
z1|IZV{>|?B=f>DazIiuD`B!4)-DLVlMf5vr<=aAeHy6Itp2nqp+F<_HVrRNsl53$B
zokApWe3A-(w#)qaX8W&S^qc?Y(`sgGUEaL+#Sl||8j#)vP|4p$l(Sg==%?JMPuFMC
zHJzEwUBmToM6v1KI5V7OB8gHZniI!w-+hxi@4P{KBk-a`y6eirrU%YRmR|$ui+dzb
z5=Y<!XNI^J6rT}ss9oYyrp?!gY@vXe(2FrR<AsfUG;Vn?_J22HPW^|#@BNLJf8k9*
z*VQEF*=2``kaMB9$TscB{eX|<4?g?*kJH}+`SYh&C0_#kJO8fm@AKBhFmT_kIr0rB
zB`^<DzUsxZLm4chspm3Xabi2>eui@}qIA|U$}#3fNLR0c^o5K{0wRHRf$jMf<<S*o
zHVx_J$7|M?YhIA30q;Ep<1BSNE<GO)TkelN=Oz8qufn;$7Y^-hH|I?^<Aw%;0BQ(|
zS?0hTUvmwMnd3pM?LoigDZkuJ%a3v|vAeQpg;QyGce&scC75SqM#>|4S!man=!5&n
zuEIYUXjhqeT2k2|me#;)Abl|)nc`4Ra5T?XlplP;YIg=siH|yXaYjQXi^tV9<~*xm
z;FIx^A8fC9Wa%qW=Kp3@+t&`3e7(KKv3XnpahdF<T&`h3hz-{`<Si-O9(Gjnf^oR|
z_C@Kw^UHj057SN_Zg%{(pWC7q4s=e)N^&jOK-em)_n)$)$DhFJNyo*5f$jDj(G8Uh
z@Jk%seMK6w0ik8x_UMxt@xw=q-GHh`9@ZQ__8i|d`WH$Qj2#0Ti=2(=-wC24@$Y)<
zkBiuMP{Bk$G_wy;;c|>00^CslUB!JXiu{Z7{P)B6I#Kt}RrTAiA}O;EUy?I#HLd-Y
zJLI0sxnV+;Gb074sbYmD=)y?As4P>9A(hfIW6kg<7u~0!-3{lyt5&{+2!q;tm(l)S
znwdx5zdOa+d$Ov!Z=)VF`S2ok-#M+?^ReXLyG-Lx{k-R8`>!8#vp;xyd4rkr#O91e
zNHkq${@{w1bJ9W2ZdGtkj__$ol0wWEud8-nJV%OP2?;f6baX3WTN$kuTn|UJa`$@8
zrc$zVbUBl<C;gPuTRQ*2t!BYNsQy6qC2%W(B!lJDtaVlhq725rd|vv0`E=OuBo05f
zXM3Za+k3ivRd#<_EzCLpAwX4CocNkq)exjc{X_`O9+D*-`_i!(qu72fsN$NN^IMg0
z!rY=5PN4!kQ-7xuK6svXocA41^3SiE@J@SbZ}|$Z4yQma<dQI(Mo*+Uq<9ahe2~p}
zkvsmfyZl?9SL%cBSO|Ym%1BjJ+&*e)o0hxt8tYc{XN9pdx)sE$5g7|kM=TG&)HeE+
z0Frry5b#wXje-7oq#tU$7yM`(tI-@OFRIMNCSys-MJVoXXU|8f@7@V>zA?Yf&CsHG
z(ryqDN;hInpahxN5T^7}_@J9cFP{9I$A8b)_IADC_o`#O_dmfVe>uXTsyH=TGc3ia
z(JDsC2{4Lg8mWk8B$<Zlyf{v+VbLh>`4-SgGeHX8gjy>)g&*~od>AuN^6uw4{#(-8
z?YiMV^nu`Oyn4t`Qr^#S6>tWwp^C;>jQ8`J7dF_F{wIqdV!Z1xa_I@qak2~?&5Yx=
zLvw{(80oU6><qh7yg)S*+*bIKi6y`KK+0rr6VWvFh5pP@x(2O09tbKlt}ukmIst=H
z5Q_iXK)R{T2XEI)-u5jgQh_;&1N9E?3que_3Y8f166g_PrSwJl-sa)Yb^JHnjJMn&
zcU+(f)ieZ`(ks1)QYQAaRUVCoi;Ba6f|^IjI5CKZ7Y8bcIGjzqw$?j}hfo}25TY0%
z8FL(iQ~D5CR{_SK@A{v5xGROXn+m}rR3Hus4sno4WD-7uSBL^Ti9GZzPx#6HPsqa`
zl3NV0;s}+}%m$p>((Y#D9&!rg5z=NP=R^sG!Kc?i`ohJAY*Z!)BNhXe3MG4_35bFZ
zMwSBIjCd7^JI~NN`s!049aZ7ox2^r)UbEz0J!65x<%~Hf3RwzeD{S+~ZXBtTf(Z%5
zS<N9w{2tgyPsVUTaJ9VhE>lsYCXCbQ^%#V$Myg`G;TGJWAr*(@sll6z!{jB9_V2SQ
z<UUh+LoD!e&_@6#f;qutIxZFP&d>@<<H)r`3PdqRjFJo9GG@>axE2<Ct9JHsj6_xc
zR+zaB%DgCkD0F!`(>b0uW5eC`oc=0IUe7Wn84ciChgJpCLLEHGPw#(H0^bNrs)e_Y
z(vFAyMgWG)Ki%%!pX_u-Ck?3qtusv+apQCkQdDAwI4Z>)S(K!|+zL-$2_OwY=sY+9
zbp<4m)rcyn6;de-M0UGF`mQHNp|^o<;Ll!#SM{|IzSS%_a)A@AaaJhm$WBONj5*Pk
zIg+NQxn$cz1{#E$)KoIVteu2Dw3<R3HInVcKqR9cyeQENy)!6<<Dwjzk#hiE4hjmT
zyqt&H>qqn>ISCmBF$6>QMxG4Doc0X#$uIaQh$+P@Stnv`jzY3T$%1A@v(Re8P48LG
z8a@l8zd5KV0@eQbHe+HmBUs?jltpqx7W+}ij4@Kk_{s<x2z5m&nbA+970Xofn|Kbw
z3?D0c%YS?}bboYFhVQH?Y;$3=%?!0dtyFEr=o3~siVT$O(4t5NDN~sG8c1JoRd_5G
zQe(K<6Xu05H?&Sb!9*y@2!3Gh25y*f{R~bz|E<(D-@cCjllT0BuQi9L8FiVG^(;ot
z1wm=eV@Ep<RdDJsDU^^gXDnp$I&Zle&5HCM`n{p5f<lo(k^x0f6jUfSjk`OuiF|5?
zYI)@WL_YOq-g}ZuSWv7gm<QFge}5rkcvG?!EEi-HToxqnNvxuT;wVxu0fHh-)SX6T
z;<~|4<Yb@qMk0dG)8EFKkwU<=HE0IQ1W`&JaH7+Qc}kRINb#5z(l`+#BshvQDuJ0Q
zt*`0K*s=Y?GrB*zq0M)1F5%We;-v0rmJT^kvQu(ZP{~M)&?$0N!LFcPVixT+kp5Qk
z8fshkn$`t8f|SXiitN=+W1%D?`iYi*J5}5rYR0Bul~A8l%nmd2xq^DKc>Gu)p-^4H
zkp!MRu6X{mMW5zBxwbWKT4rX7m9ig|R$@-1F;i<`Q8nauuDHIKb1<(dvqGF3ZsDk;
zphIL#f_8!NMWTN^5HCk44i^+t!_4nl(Tb)i#8ZXnAX4zeSH}BNjVI@+lw4JY9#puc
zLk|?@hOa<thdCvSQT3T*kfKpK;L2bHX<bM|Mv_e)OAUgMFmfL8<|Yjb3qJvz&#KL;
zDrG2)K9grKJ8f9rYS2YutOu--$-q;l><o5+w655lDXXW2^~FdvOiHV+Qc6lVbIhFM
z27$ZD)45|iJc8eSr{$ZsYVOX2S!2v9C8bO)bE+y+hK}YE=Hh5q%FG;xIR0UCVv$1H
z4`K#Uq)f+eDnuM6&|9X<ktf4iex-qQ-8cM}E;+3h<jOIoNL!SR4oHTksWE|W>}Xug
zEC<ReF~5R%l3AQ4syi*aHgnT5SGJ>ZH6bPzHyf_f$bY;ruIr2+znHU2nWL_z%zJVr
zq~xg)D)a2ll+I<Eudld$;CSO+;o$TfH;?$k1+H0=MG+NTKjU)sgw45O+Q3C3Rs-((
zjJop_9hoRJKZQo4Q1s<kwnwuPheC0M<^b~bOm!ToPQe|69XO~f@QR2cS&_cLx+kv^
z<r32KKzvdW&mC4>;+(@2Ov)>Oh)p_uRy;pBf+j!teO1`(dS;6S?OP7syCU2Xn$X}=
zL!Wo}ZKCOnVYB1;<t0~#hY%aiKaTWq$4rmW(2%Q+D;*F^%*LAE%=b9qoOf?5dFP&T
z?@hR|aMYHmea4AW>y9fG!p^uhD?GEz?orLja6&09HxJIIaMbiuPp&#eCApw=KyVD%
zxZiD&80~TS#i+af!hv*BhkyP?J>xf;CAY$qZw%^?B4l4reFK@ondm)^3O6W&4q$=G
z*GLtqL&UcV7+T!)d-JJ**(N2Iit${DN6O{8=fEp!4$E<>)B;)z?;PG&)Mm`Xj(H^<
z&l<u}Ko48WOtD~7RnMS0Z&?&at~^<cu{cULYHy6;XD7rW`_Rj#Q3G|J3Z=M0aE`^o
zQ_rB9D{d*svO;Fz<q#^79_fV~JVj+{R3_+mBg0rIW0)#|ZUWM$+I<E^FpWRk7<Q94
zZJn^3Ded(I)eQxwNK|6oqF0$_BMf!Lm^;RGg)2bLc$uLn&Jraj!~`)R$kf|9UAEl0
z)^hKL@y3n9;k@87fDuz6h_DDX&d(V89#cWI&@gb*XXecv<TDQ`$EW943W%TnzYB&(
zI7=HI55Hm_>Bv{_9{Q6H-t04P53po|v6=?CU10Q%rU(>4tbiI`p;*rt1BSyev<NX~
z=!~kahzg}BAv$u5ICX^VY5L4^6qZ>SQo&gPYmt)hCJ2*Ev1Jcdv0Ei#s@Qgc*-r4a
zk)1N;OsNa5He$NOZH;kVlQ$qyC@SP6s27IMp|F@4xT$I<#qb8jJUK_=XpH@asuIH1
z6Y79-hFV5~kx57rq=URN;uWN|F|G&tU8WxrRbC)A8JN8q$eTQmW!PKoPj7t3nyiIh
zK*mJg2!3T`EqK?^uSfjK=r@6K<rvQz;+ZF}3ocC!@RGq(@JvI0VxAz-goKGQFG4#e
z>Ml}=A=xn+#AH)d)_J6Ox^1D1f|8JO$-MN84+kLQFdRzWgD5jq#;>7Ms|3#xiCa|k
z9NM$W-n$&HKK#l9=|;Q!?pw|LTc;Rz(#XxU!TCaGBbKLW&sB!gw3o#Naw#O(D<;ed
zEJ%6}HigZlu^vHIjzJTnW#;2R_609SDg*s_N4#i}<ZzY4)zeImkWg2lC?m!wk(7n_
zY{dU?!|GY!*?plpRBRbw?$A~Vjc_H7dhO|+D&s2Rb0o*Yu*#Eg%IC;+m28Ng3I>|N
zGYKpvGK7qC9(O7D3y&=n*D6{Ak}x7ZR>-JW@5sH8yF%F&(#o)HA@vFMvR7#-6q!Kv
zX=U(d&nx9!X3&hTpm_jGsc}zXl#Eu15=Xeo_{~6B3+v0s>fCX01sjcMW-t1@S7<Vi
znIhisO+j@***JEOBik|HTg5UY^^6q6C5jbtDeP8?3=Ne)BmyfukFmYcy1hV+*{8wj
z!<K23!@z0H*L=$xvqK&^`{0LL<AeUo%b9*5Ksq+}t+%N82cc#;n-e$ZY;8-)Mhh&8
zM@yM{6rz(}ffZCCn4?&sFj5~k*lNcZgx#jXUj%j<DS1Tm2-=d=Gcd5*7W!==I|uWC
zEQM4?oFp($F^ANS`nceFLtN(hj}KV|s9Vrlpi;D&cCVl$IE1<rcG(zGq9#KT`mGW2
zq@MFLJrYxS+{~~nlhKtz5&>_>iwc5a6%=on#(j=6U?tMm8@vTHc`WV2nJoBG(C85F
zP=z8!-mAxoDEd<9<?|#uN}-DeXPJ7VEFXY4Sm%-43^dOhBsz37@)$`yqzJKhw9MhS
z!_|(W0_G+y33Z4|XccIxKu*T)T-c@x=N);BWS=RaPz+Mc^z>ZqMuxS~Z3078Q~Uw-
zZenH(`+5rYX_lwJVK)KU2=r83*BRa|sAS}YxUYU_=f;jU2g2e8%Wu4mym8E}dnYWH
zOPW-01vW!RC$Jr-ii;1*VN+3=vR!RBKf9v(-Y1MNK7xZ8%oix0I#g4Csq&M`hBySn
zLZo=lU`CgxidOJ$V(#?`u}pguSl))pDIq9%IsIImQJj%VhB%PdMt`wI|7=c-nH&s%
z%cw&kxQ0d?DuwZLw}sJ(31HI`+nXb212tT&_?e-NKy4IXz)v}kN{!)(67c4c(UHeQ
z8Y4u|!J(s)3W!sR6!g_508=@Bs?PoFS)x`esv@Wf`B|cS|B_6B6PVqpk#{n#5>%&r
z#ubkik7j{vjOT%VC+x0-)Emwhya&W#KrAb=IEv3uDH1>>f@Z`;ROie>0Ex6F)XxTj
z)SUiD{{bg&9TM){#Wc{TLN`qPuvz73gCj^`=R6DXq<&!a{0zJQjQq)S>SqsV#`M((
z(r5!?yu?<4`p(x0|L8rAfAc+VT)#Obiyjs^GF(QUZML|SSu{1b4;GxLa`EsHAH4t9
ztnWWz`0z1JdxQ4gjMf$AwZQ1;d`-(hF-5a7Th}xia4$f+j5EO<1RS2-Hd9LC@Ro4v
z4LG`H94>|3sbH$;%u~V?URGm6eo<II1V#ssjMO^hn$WlrNlJ2#QX=N$bAe=1DA+U_
zQiK@O)OVQ)a&sUo6n_l5^vK+BHE0NveDctsqfoYmyfMbBDPPKGMp|cbQp6Q-U^ac0
zenw4JK1Xudl}r+&)|!}w-BnLmdY0c@aPZ9q!`&V~cVr()DdCgD?+W>9Bz2L^)4<dF
z!sg5vc0$vDx`|~Gdni>Q%xVs9EA!LLyf&l=h9{d6bEa0uSO#WKx0LM}!*G}D-}uMe
z{m*}w!#8e|wB~XwytwSJoH<$6+*s7K-sswfg*rCd6;JPf$nM{KpQlegVzv8(QHHNR
zkg|suBfHY!Z=Z1eo4?JwU;hWZeeEtWB?ecBdF11DWVc#F77ph#ZX7JQT`7y>k69;U
zSo|ep$~22Dvp04G?WwAYv4bHv+OWo=N0K8{g>Y371pEk95oGT1=E>VgCJ|g<aWr!M
zrg8m52-n*woI6lbC}e|bEU*+V1=hbil6*q6#a;8b9I>I0nnIFDlYh3M$|MmoRqZ69
z*%-$NYBURvENhx0rMjiKYX%1%n<-LHMAVcL(u1rs<uX$)AU-vQXbfY9AgFgZCz!tM
z7fnxY^3-ejnaAg09eY|YI8%~usBe10?<V-IOAc=Z{6ZPMkt2k`QD4=>=f-#$xt|KF
zXG$53+=B+inGutcc7>DzKFnzjd%{VNYX`hk7!A8IF`pYVf!IZcVGC(R9GCbThcxfL
z#jS6AjnOs8wy=A#p`^s&@r;|t4GVA7;;4XU>kFuq&BH4$>IK={)X<}R#Y4LYy#$i2
zIdCmE>SJ!)Ibp0lgL%9_9s_e#T=WDL=0`J5jw|M=!%kYle9mTe#3`Q4nxTG&gV{}F
zyiYt_a5^MX<#6?q)B%1VRBlfWZP?|GWrS^$C}e5^2}83mi^gbcLT>4Upuyqy+Hqrm
z>=K^DL4U&I@CfG$^K?Ya0dr70kB#l88rVM-NO9W1LHCVh-EVM4p=3vpH6_%<P?3Y;
zG~sZ#;xX|!>k&M~ggzHy&Qp_>00fXT3IW7ZWGYfXLGcrt^m7a;IhdCgH!7rpRf(-1
zn9Gc|wBSKTWf5C)PQ+m(%0Q|Ty+%q|lj~Ew^ElgaW>?&-uc2EbhRm!~SWf7?AV&pj
zDy%dRp{*RX??4iZu;lsduL!9{`xd>{a{Xw*^7x4CT6P|q*buEC2Ng2&G!;O>3!EMt
za52K=(TDWD$4Mq;`RaS52qZF16X=(ot6J$(W>FXFQCR~IhK^@Ba3Kj3M-syXB-G$N
zCSZ(Y5;!Phk5xSsa8AIW9vtFEvPE=^^cS#xp6Ih<4it%4Hk=ET9Jo45Jp6G$Hx={l
zh~~veH#20JscMIXiXLVAbfkNlnO$|f7$zq6rRyoBkOkbh_ZFWk#X9x9C<&42eR52A
z6}BY&S;57E4GAs;=7O6kR!zN}E`vtU4af#$m9fi6+(7OfgDI*RWMa%0GP*BqNfFBD
zmA{#o5fdd#=!T4LgyjpNohw)F1(jA*6430BuHbhSc3Cr?2iEuJtnLT;7nv5N_6>Ch
z-74b|B0b}_P_`Mr6B-9DPgJ8qCc74LA{QZz5Qh;-MqM0E9JNz+0x1}~DzY0BIu_b4
zV8v0-YXl?Zh>V3gL9>6l6=z@SgzYZ`Na`l`^0pr^Gp^~3BWW0bje{qvfe*)l^R8p;
zM`qq*y(8tC#8erwm~cht_wOeoSj<@VWCV-QxBz5w9xxMP5uykQA=M7t)W2~-h<W7v
z#lY1j@_1HL|EOYqc){oeb8WCb001BWNkl<ZYR9Y!xKNXwr;H%Gmf^fG^eq5&l8J!2
zFT*BN+~@316sb@#EN7I0cZw8;ick&0rmk_Fz*$0EK^!<g!b|C}mx=u#$ml7tP=-hv
zjB$wgakk$Fw@hkEC@O*$KWzlye)jQA+TK&ORI`#}jjV*~M?!cypg+2{uLw@wD0K-o
zBf3^>2i<yP)j38Yq0Y=2M@fYw8E-IpBWh+GA&(A;0kdhaGKpc?u$0lFXaUoVVrXPi
zy&W>ROpXI7_w4$fJUHkY`ljZl1P*43x{7enV!;z_%F(~<t*w4Bp<RYb1s9-ScdVbB
zb9VhX`Q8c72hS%jwmde&6=9))6X#iGLq=m1h|wTH7-tkf{ESKhRV`@r6DhP3N;L_e
zWUbIcVfj|gt&L~1@{IjJk%Sh<;q6J=+h#S{2TTQX@N7G2wfhL$b)lSRhRr}Aa8NDj
zPIqASG*6WO=57}5b3><0K~=C~U<FZ6DV`xsTcnKl8-hU~qmocpP%Vf~dCut8Q^J`X
z6gLT?R4u8RNS_)<d?<L`OOn~7)bn!Fv?4z{_6!>6^FS7xn!ytAgQNfPNVi=R`WAHs
zyOt=+gqwLPCr~S{@#s8qqi#r@Lf&C!bh}Ks1$9$c9#_ooI`mqBxsYoQW<*~|PN?WH
zP1L5eZA~~D&<(_xxg0V#2O$S&igAJ>RP+(fqi{JYMI!Z(@$ri7{rjZLHC`Q}p1~!E
zUv(fcX;&|0$#}lu`LhR94=S|V@?>1{@fz0G4tS#~oVK3Zt)o(7RN=`G*>of4!+_5j
zTR>@yYE}q`9X3Q9iAn-RBB&!IrFEIxiw=LBSe-RId62mL7+Mo<zFjjv9+@8p^4uu(
zL>^65Loh>kLV1$ez2C8Ve~0z3^bn66-iKF%cy4c)w$~Fc@_EdLjB`^HHk%`v=V}m2
zpBa*HqZ(*E%xBOZIyiRN0<1DjjoG*)_7GQvbOyr(Z2HV*jPxFkPLz2gG<8O8;^sM-
zZgIAReh!dob#&1aHKShes)RvF7oN?P5JIMXry~4Dg}Z0?<A7;mObL_7qVoh1))&U*
zGvVryGK_`AEyvN_!pZH#(NW^~I8)C+!U!3}3?GzG29S)4APbM34wN%THzdx|$j4)$
zafJ{9ca{enczC!ge7wy(+hyE($HA<l9v*Ri|HnLk@(F2(EK0@ol6e0s?~!nLzo4-t
z;d>A0#{Z2^e)vA!8^6KFH-Cp8FHTsVobX;PTsx>aT?(-zE)|}wBdcA<vwp-4SIloh
zJ~Hee(H*W~gj5W535gk1M@>a;GBX{Ros6trB(f!TPY<a^;pDpK<joDo*B~B%od^NN
z8VJRRyUcjzNY@Tnx5D@=QO{?jgFPwKKHXb(60)C^Tg&H!c0zpR#S%)FC*o5aGN#In
zN;qiY+I8jNuHkPh90E0X6=GZyyF$7Uh9{n@M{vHH2%IGd*WJi+t{luVo`PjJDaJCD
z`@`n|NtooEO@*RUp(4~3PK0QI&0){cH$BZaJ>j0xp44D1!!Upp+KV1rUvfDw9J?9M
zUj(|c<KTwl_HRb+-Rr35N*$)5Lr}Chyn;E!2o$H3jnT~-^68fHkz?0IR$V0aBR3k)
zX<Ko<nXc8w!LHl!$+oAQJtJTKh~rQGoXdyzx%$ylWZl!c1x-%;+#|xjEI>+4%h0s!
znj5VC>V2O5#s9))*~0Jqmpu7)%O~$T-mPZ%YECo4Y=Dd0bCo>LUaZ+XTQQt>ly%Sb
zyHMS_Lv`ma`Nn`tvnfG0#hC}~P!;CI5h|e_26X0GtUB68;cC*Op3UH7S<@|m6UST|
zV%Xw{tec)#9My5fVip<Ph?Bsfn`1If)V?yl@^U}g&j-@WT_mQKyk}#MT}jMxK}$tm
zblAM$Pcrq5Om!;QGU1(0`gUVY@`-VTu9~)wyiA2uj9y_z!x4^SKLM!#Mn#cAwt+zX
zIXPUyTfm8uB$6#sRUY34;ylx|fs?}nszb=L$h;1CDv|_>6gUh>*+R_Nnd5A0<c(1u
zv>e<OuDx?e-By@R%m^t{?&tPn5Lm!B1-r@+9o5|dt!He`){KwOI6S;yPA193HmPF8
ztT%MECB9hmgGWypzVknE^MC&DskWC$I3!%V#rFCE4`YGz7hi24tw<Lu;rQQ{72mK+
z<_ySsp!)9nREtm0a!BJAY-G)5>sYms^Ks-^4!n50WBl+b{U<Mo8_)bV?lM398q3@7
z!D&yh>o6FWjO=HO`3cTPf?MF)L+b60UVHqL=Qw-F>TJ!$v&g}nj-$HaYJe_x%q3H*
zmfBZr2gl}IkY^R;lf?KzAykg-Tf;PADl#z$J`>`(eNp3Q$9C?O{(=DAn7KHQTwWQY
zIF?qC>ddf(t{7c5@=?G!!Q<(QBkv$TkCgjH|1p$vk4LGT^2~LVjl+&Io<vEyFEV6I
zBlbD5XV!vCF9!%C#YdbJY%|h5ACNl3sS<7)B@B!dg6kQEfkY-=&Y16DyBm1?yyO0Z
z%tc>w@8p<+Hwufpw+QpaG$PZFNHKzYNj%Ne2(nOE4IHsx^`OIrhO4tHR`;JGddOmX
z$o#}%&Tz4zyKv+OJM8I()BpP^$KQKIvwcBF;X%2e44x+$7{A=Xz+VWEp7s67v;Hx^
zqm5kz<6ZOo7E3flZe9F2haZfD^%K^o7d$^cVkg2X51ff2Tafo(F#OveARm7p_h0>|
zxO+$J-nqr%^ctiBmmMiISQrRpf!9FNf;q*@8@Td<>f;Mm*BUN%E1vuxLKWWT<JBd{
zCyDW+%vjaL`kaN$DBH;Pc~AF481E~=Dj2tnKXCgJ_Qag~$$6f=r}>%1?{VT2PC{FZ
z2qVfsVze!17?%<5f0U^n8?&Rp?Ai=#VU!WyHRQ`gex4{hNC;aTmqgY%u_*B1N#V(p
z33$^E<kOba)2%L_>oE;u;>PRb&B)VqFP>(c@%aDjI4VoryES&r$Tm#{6CI)J8M_f(
zwVZ$7xV#$Kxh-{DlTS}cZ`>fv=ZG2gI8K@oB3Q}<RdU<m`rDM#kvcviA3EgL`;7nV
zUl5i@*!GJ4(IF4LaM=XNaJEV`D|l-)uz2<(M6c-l0jqS$ivsVDJ06+*+4KJL_kLyO
zk-lGgd9%#zpgp3rr!0%dE+3$O`3M)3F}8f*3eHbE<q3|m8Q}R9vx^Jje1?QT)0|NI
z8x)o}pJ7>Jb&cgRH4?o?o$g1gJ)`!-aKIv5a)#qF3ElTc;zynq!%0J5SNM`>iYE>g
z**m(65sRJzbO8>>@P*Fb_NL8#Al+aR_OJ>tI%HB;Ety@)tac#hg%XUxz`G6`3(_gz
zad?br^WzrJ%E}~^g1lmVzih)Af0rk6e)XV`{l5jBU?s4rH)s}~{KXpoq2L<9J4f1#
zxD?pUJ(7h33q1S5Ga%5`%F)pgP8a0*1gqx=LUto%zYC)I{ph>v$vWUt&9)Y1H{Pc1
zp40S?aR0;q$m%ZxalRy3p$-l&Mjm=xHm(gLhutA!TedfDaXHldV6)=?-L8H$2m3yW
zTbWl2I|1&FJLZob)AUc7nGx}vlZYNlfkW@HF%uDbHB$c$&z@g!{NfOQwx%L;<O|K1
zaNRgnsA8PzgkGj{VNw?3j_ZxWVNW{g8CJ^KSw(rVWSuHhlvTZ>?bkpDK6Cf?m)!YB
zp4)eiu(@%iLQY?dK^)Z~X1D@c6u<8em6xLqvL8>+)vIB(#H81d6{K_%v-;&ueiP4u
zVBn>&rkei#W&XCuj{TiYNidtZ)GtRu%-nthX24Fdi@^GakstnFk0`4^TNZdb#t>Fq
zQ90o<Kj%0IzFPD3-@nCTxgo?ke$ydEK$I|kn)pxS@yZ}eO1Z=~#)Hcps~1~VXFIy;
zKFeX`@UI<39orJwV$?V)jF!L*VU1_q&Uv_8@c+4rkHo+Ci?Zu~FQevvwS6jmiuOiS
z-YJRqs8}-6kZ6HQ9h;P~(Qwp6D*k`!-mJ;8>$>m!?dc46%$s9n4XDCMfTRG5l-i26
z-F7&7a74d!_`x5+UqSu|?eEgVQ+G$WEf3wYT4G3~D3JgG0tKMv%B&pjc+T0=>W6bH
zt3XizEl{L%BPuHDR%P9D?%8Xvwb%L&k_|`PWc6X>-rfo8d1icLNUSpllE_L?mqH9Z
z%C|RL?wO(Xa>J}yFnZ5`I^^t$<>3R%^0P>ZP)NYG3w&`%@EN`5+5KM4;ddMEypb^u
zR>@JfgRgbp*(k`pWu=jA&}><rsLa}SkQFAYKBtH#31k#XTU;3RLMXNeq$&}#1d5!n
zB5Z8=B6zl14Dw&FA1mD}&OTQ)y6U<bg|Uixy1-v5PLDLp^@Ioi?}j9XOoule(^TP8
z%V4MG=BouaUL8|j3+xpaxC=%8Xh|#z3@@}Qlv4c|IA`wXh;B9W`H-idUC{o)n*3;p
z=N7AS#il#yr*W<qT5%?!eUIV@C_d6HpLZRfq=t|E;@7J8{u@&f`m{S&jj3cXm~nl0
zj5n5CPOt%rq|u8trDX6Cmo+_SYtH!(pR#yTarytv*?oP8zTt5P5j|BT?deVR^mYf$
zC`qIUHVBjGaknN63(IB$m-id89wVcIdg`$ES0ps`j&OKebNH&_;JRjLN5BEAeEzlW
zSz%tv7WwK_@|-s`(6%>0lOD6JR1fXxUDneUp&*ECRa&>Q#n1H_Ca9MJNd1Ds?JL^z
z%4{<dTVL8fz>VpFu-BW{cvi2NKbdoM`+!IP=`(h4D7(g8Ppt15vM#7*j`3?X`)_vC
z^#$YRgz|AqbCO;(pkLC~%Q+J}&q-IY{7cP8rwz+b0=u6J16mAYVwcH$2c08jWyvJ!
z>6FI8c@bFameaEn?lmhuZWh0G(}Z7JARXxHPo0du7i9Hkf%acs!d;y@Bqp*hXo{NZ
z(FH06av9lsXN-Q!;AcWHw3NDHuN`v#-V+voIp^UYJ?7aTMdW5j{adj6_K10xhzUaK
zXFHaJF^Xa^#12NRCPP|lx!A1OEF+=ma47sDA?psqVeewT_H^fp*jBWi!+0U*mh?3n
zKT2YME>J@5;el5z^Q@ps!(OIXZFxkJQCeWDl+&5et01L5n<-;Ss-H;($qcu0TKrsF
zLGxGN`^6WS>G^>A3zQ47sc+n*HJfIEahmh_Db^W$2o%Zk<lZ9+G!eMCn6p?8xj5f2
zyQ%R{ALGMg){C~M_lsb+hS=8jn@7_$m><tr{SfA?@wKA(y+f+EG`GrYq^ck{72zV0
zAHlO9E#Tbaa$r1asOl9@+6iUzLYDa&NTmvvM*W+!*!}Cj_knb1>hq&wG`mymk(Ty*
zKCeGnvSEbd*e6Dt0BBZWN@9)gPI=|l5l8PC%A1bqq@cv{SUn-%@0boWcOSR-P2luF
z!^f9Ue7L5xJ$JwJAfXrBFa@}AM=^<{a?N_Jc=XV-ILQ=hK(Gx#Wh8WX^AML5{#ncY
z?>{4&itgT!vd%PVj%g0QX0st(36f-9)|4|_Ok#s`4(;sLXt_V?qk5H`SoQ<p=jRHQ
zI#S3zTQx>(-ZohDOHSljzR*|v^3tv!G)q=j*ZCYPskO$NH5d0i%a02_`Hy$eamIqk
zv>HP*Le!j)JL<;r>7Sf3SnuLL^Ed*F%Q^Y1!~2W@wj!^+ooE&|o5cOgB~O5j*4+N?
z9@qc5V*09K$88W%cz4O_^T_#+6rcaa6PDdBhKkXurgjDUn+>m$sX!EleY=kvOn9s|
zzyC@5^k1EHarf_aAPr10+pov`R%ywNL!}WbsVP;>C~0Qdfile5fa_@8oZ(T&@oO~)
zZ#X79mgqCrn?p|P$i1_c&u+CWJ_pt9lUJ6!E-~^9r7Lo_7!;OBBGCfL7HB$DDi9e1
znTmpCSW}=W5H8(02Xa8s4mtl1fz?li`_n)%QFJbYKl^%Tr0p*Me1VJfXQt;(hqP~~
zhXYJi5ZO}6mAX1p=x7lO%J%3A<pX)uAgdN>Jgw-fY=-LH#e4Y%K?7gKBzP`Zsg$`2
zZjpr6y~pm_Hn;~h;p2wu+@Pbyy9KAs6L#$ZtK3jZMbTBLuH^222D8;;z#ihf;PDuG
zZF6C(rUW!JSTfzDLVV`V+lSn_UGVz#9b|WfxFJnDV(vPsP2}SnCtNNgZI{7WoYG89
z<_%Nx3WAL#BXt0F%D`RFa4|dS{`Oe1f9tj6)a|_XjZl5^ElR%Uc3FN~7~b0BU^b!A
zE7C>5>cb_=@PLwCCbuT+f3x8B?-ty7S2Mk7aKoB5XzEU}xv<=OzvH7H&UyH0L-qz+
z7Co8mD`*Ts6h`$6*C{X>wDcMgk`>0R`URgeF({&Uq-c8E$(*pZ?9VORqAbU){I7C2
z?TFH=LW&6bCAjhPFF7i6<wEiN*K^2`_a1l8^5DbAOg24hv?Jh9oU>+ThJ@6jbi!&w
z7b6rUyRRNn-YQVLAjXkHB*#AU8Kryr$#W4%%oQ5r>bkb)F^yv75;|{{VU_9uz|waZ
zoi@0%gu);Li<F>@pp{@#FYzp@>gQw%`bk8uy&>D;Qhx<QS1uCb0y{^BSKl4++IuB?
zcND5lh|YBBoN#)Z4?pO*{L^PV`hMo*e!!lcQ5AbM?|8<01(aiwU*hg(=6~MusJr9`
z?SdcFo7XR!%e#NCGSZQ*<<QmaTE~8fT+<bsklDL&gX4ejDmPx+Bb6=ZKV5QvaS#1$
z#`M3v#jSU4a`@(y-RqjcUc%Lastal?nN!@PWWQ2ybi|GG3}P`>f!@~lU-qDEzreJT
zZCCF_+gVT$2Rzp=$x+B2a?EG}rJ>80C=6EhLWDheE+Z=UVk63Zp%eAuT-{%o+ae*9
zdQo~kw|QyXmXpsGEdKD4#sBe$&?-iH3NA6s69@`nOwN&<15pbH?@YP#Pp@<Mom~dk
zD^Q9QBeD%7jk*e?ta_t>FLv_e=N5y8{9JuiBc|8D=(!G=Rvg+0h1EFwoOHS^|3s7Q
z>gwKd>ND!|{|i8Ug>j<IB_Rij8g{N3M#m1unI0cysM<)izr*$SE|?ro8UB`I_|YY&
zf7r5k*zoE*Z*uEfGX}?pJoxN$I=kWCe}11L2EJX-aH2kWR%!0%^~H(rcK==k(p1;H
zQB=G!8e!Wdb?SJ=1=kPX<nY}?uDy2+I|5zY=kX68;ZAD~UK#M_cdl{tjRT62>lbG5
z5IyJ)(PMOF*tzDI%nT}<tyFL#;nC{LZ^xx{wRoPFSxIl-(S{s!pK+8zNLLUbwi3Bw
zjxnk)$DWsDX4`2CSum)+w8H!x>U;Z{I$i}(&OOkzC<=1Utk-L1(+lLR<KzEr&VmJ#
ztl5}LCgy+?HjKv*mx(}PX&a_*A2a)hLk@oLfYITQsSNszl>TZU0q7(z(an3}q^MrD
zOSYQmq76BLV78q>$T<>YBo0QH94NC;Zu3k|kdz{811j`b52d!6cH7LijofU$V!1hW
zCGuYt3hTBr0&ys1>2#tTR$QBw$k74&`-)26BmKY;W5e!i2i*R>BL=S=kPjoz7MG+t
z(k)M!G*kZZbi!R%6SJG0oIm~hk&#9gcHNLeJw^?oTd&!F!*ckBVgI&ba-=bZq1uCb
zSF`e(qOeqBg&8$;YJ-VGa;HfqBQB!D7)iOG+!tFxdID)%QkkzX(9yZPTG(d0GwYXj
zXk9nGt7Gm3AGJ|r)r;YaD1r<zT0lA^c{IJ$uFe*G!WH=iLLjT3o8e@<=0&q1E3{VF
zt@2PO5K1A}3MCFt!eHT0C{;-e!X`E3Mv<c>C&OScVmuhKTaMW=Q?m6)smW2$U-;zy
zGj(!TbEX%Hr7t>tUWL9%uN+pnEjpsl`smybZxXQmzWXn;A15ngkx*}mj_R+0NPW2g
zNl><DJ8w6D82cs*1eA(IqbXyHwh?hdawWu4;cbE2Q&hW#(NRG$hT~Vq$ZJbp|A#Xk
zfBylj69?spW!kXUtT@2_=_&Dd{>}!{tzj+KWWddK%A}pr+QjiYJM6uE#Pl7{E5D^V
z+}SXc1!1l*VNO|PHkU1DA1*k#`HV(g5)q7_qS_%rCsGlp(s{29hhS`fI2P%5R;@Mp
zEBd=(+bVjltYfwimA*6qZ(3BaxNNDkqCn7DdKN1V$xrb{(Pe0Izmsd%_17Y4OXb$v
zp{9JHtqfq2{nCtdx;W)zbHc{7EYq4P9&HNRbwqNea5Y)yzJ(&0<$A%>r;o7@V6~i5
zQ1=-r=NFmb`E@8oXZvjWd>CwA67%oRFeMw`19JzqV2q}S5hD?06)Gq?ps|Y1DT3|K
zrA9J}7M0qo>?W$$*L&XL&kCxLzG9;rd|{BBvyf6EZ#`?5F0ivonB4}{jP-eD`SCgH
zPdk*3D0Km0Kq;0T)8el$_~t(!uz%+kPk&}P`42*6YTlAv4C#B1%tkIsc(hrozf*y9
z%OdYqW8O74soT28lf`q&+rs1@!yDfovoqT;Fb`q5A)P_Ie1N1S%~{LIzx^?P`Roz;
z709(?V2`kQMynMo(=wo^ELhEpS&T@3VAl4Fi}x3fNt*4#(I7oyThmJ<8>N`zvB@#Y
zjvXb8l&4OfQaK7$B6iLq7@oEzr{1tu3RS?M&J;yvoy|6oUhd+^3lWlBe&LMty!|U8
zbX`aOB(c617`hn~E99<1)|q+J;dDR+k0^z87Hb@fhaC_8=z`U!!eDrgueM#cEMGu4
zJl|+q-Sop=0h6~I$<<(2p_i7m-;kwYRymHGVWKtmdD~t`*2-}q1?Qq@mF;B&B%x9d
z(GuzP7q|)_dEt6tz8o3ibRg&0)5^0YOG%b(`(H)cor>|J7CU%CUIqN=g7Xj0dGfw+
z_`4Ode$49WhH=$mHw*R-7RdK9_01htMT`GWLK{}>W0(z(c{p70qj<uj&EKJnw4;jG
zzESM(wmD#@Nq8>loM-l?aP-|F*WMj6z2z9&2*oKmEl8clcaPAbC}TzYLBYxW0o^2#
zLZDbY!gimdOdu8=r%iR`JtUG)TVad7kJh7>zwA{Jx5(?>@<g`i?H=u>@CD?M8EM7!
zUBiu|j2<V%X*|6u=rf-==`^QZ!F;V~77^BozWvbCzk39O+I~_(2q+RkL&^!Q^i{Ta
zQR-#vq#(G=&Y<LIFd=&|#$tB`ry;2w^b{&A<Mj~UPjr8I%H!@4Iwu<XroeOP(aV9P
zR8OSRFLmz(O+<Q43xvoTJ26al4Kh+xm8L98C>%*akR{8F;o(W<{^P)9r?EH+1xSlf
zqqh**o~HL)$D+?m4PRjvrj{>_jV(yopEr#M<;hX8W}mzpSUZhQf?Zz6b|YrapxOmt
zGbd~soPohE%!URtQXD^W@IP37`lnBb7mnR(kHQ$%UCV`P<eq#znW3*8NPD{apU1ZR
z{n{1mtf!c$$iv9>e|kv$nqmKT=EmEO-JKdY+S)+4Ic+n?i=y>UiD5#;jP?KY9{X?I
z;m*M>_Q^S`Km0z+AN~o>-$OMC#a<sQx&OM=*3_#f3xunZ?XP>SR6&rQ7~skHt=G<T
zN`&_X9Sw_=8O&;K{`Qpmb&DMcU5;o!pu%%tGK1_{J{3;>qT}K(0-MXsj5P|4>p8&~
zl|jNbkOJfEdkHWBBf3{HeQD7bbBnKqdZ^fA2N6eg;_w3@ua`tyAkI^bT<-(awuCn0
zWsO3p=v&sBmo&c-kY4*cvA4yAtL=B72nZdKfH3(71xK&%aqYDclXA@@t{JNp)|p;|
zJs0Gs5%U)-+VeT<E@2tq(Fi?iLvJ5(2^iIT{95{Qa{3jb30_7RQZJmp-Q)xhX@$@L
z71i$R<bUxV!*^bzLXaOk<D>um2Rv#2h#So@Mtj<{!HxDHSlqxc8fm`u<^h$QQNDVe
z&F2%AA4XOmKVd(YeAC>dRzW_DkJN80klrk3zyCJ7xblLV>s?mfb8asA=3AcG@3!20
z_lUtjF&zm-%!I1P>JD5%Q^Ul3#K$L}5#Rk6eB;0VCVT(r_c)kcBR_q_`j$iadzc@7
zN@pP+9Bo_IeUqT~{gJETVbB{?uKN;7CzK5!iL_FrwMM#%q!VYk;W2>@$7rxa-fSod
zG?bi@2&2U8zu95(PlWo_A<j8!5n657PnX=n;Pi|~t2H0K^Mp7W(f*%fN?P{Sl0DtK
zEX1wjo=qzxKW2dKk=)ztX?n}$?H=9>{L}ORba;u)Ip3CPkzOQz`HM$_8lk1y+I6-V
zz*Ev;QO48Ch@sjcCdHD6=(1wjy~14r&FCJt{@E?w`T#>fyuV$`-p!8E?J!8U@S7Fc
zB<kUWkUYc3OU4t6Jgy0g0VNfM%&DrD&<^P_D#DHuZb<G)oJNsH1=YwS*<no4JIQZb
z=piJGaVQ-yA(K-gT1&1=bmy@r3fDzYE&R*3Q2*mUW_IUIE=}fVw;!>WPbuGjN;Hp9
z@*T?Rm@E#hpbCN+j99+i@QuR()vJ~d|9nn!sp&o%bIgE|KIdBPxF(14etYp}ry=~#
zuRV|^wq#!om`oL6zN9V<<5!35-x_dqv*O@jL{$jZdZZI1Y&$;NIzDC%R^yyuxHsX|
zSB`jP=YXU(oF9*w9~SsZF*z!6uhdulpO+8PS7#$r_pOAi5hEy5_hnAdsHkYnhGka}
znlZ5}(W^kriC8Lz<1zCG4FhKxz2cZ%ubEyq%x(<ORo~hjEgfcX4Qc}sW^=`@_BPG6
zhKu?s1FhLRF1fWgqtcd`)&wy`bp-AJ(u%0$s(3M56u4~1G5Raea9@R$b2?M1dfUqG
zP)ZR@#W)9wutb+P(QUx!66&{@uNyx6U`ZX}`nPX#cyqwf%^`cY1!D?~uOO6Q1&qbF
z1scQA8<A_@m=35&RsaAX07*naRI@tWz|v#1rYiQ(gNQYXL2bD{cHAg3GaIqikeng2
zL9)i#nv@br1&rxi-bxvS0XAn;%5+-D&S6sl)r#;)NCVC2`hfa)!fb!S#2Lb~j&@M8
z2#J_9MBP(0vTUcqf-{yuT~b|hcp}YNraj(pUawG%Fc}n7^^`>u*)h%cPDA+hW~5!K
z{*~>7LIn=X0qr|2!<~xV*AzR)nekXr>(Jw>f`?Wk$rE+J;*cicTLWx$7uKG<S+O#i
zc=3R^xMb6{tU93xfhw=bqDWdJ*eisxR=pW=iUuKoN{Cme)E|aNBh6@H7z|g0G)A3f
zmY;99Tx=j%q9n4(?7m?cT^q6U1{~bcl%pOLs#Qcxz|@v52iBWJ^oi9u_=RIKR=oZl
zI0%v1^@@5&QL!erCm21$kKdr%c?YVSSESnh0KRQcJ%2BMc~|SJC=o#-kqVU{C{Hd7
zf@QeAWHNtB@OM%E83qT%4x`3$TqRT|4DOVuyrx+?)|Umg1|w@q8!?4};3?`6UEMG|
z(%gKnBzsTySP@SPHs>WPwZf}NE*xQOG1oNJNJC1j=An0&=mJH~C?%xap<vtPgrqCV
z+*|Vm$;6oY^36sre59ULXx~saOH#XnU@*%ytP?3aQdf{W2OZ=X$UdTC@4Q|)3ocVv
zfrCAd{|4k|HThiQSCRRdrfQ({zk$+D5_f$JG;A=|aqGR3{o?_%Tf%rJU}B~{&6H(9
z^erY7L??&=og;FYiA{mTG4XtZdjBqq{Q-IA2#-$ae)fd(%YwPyL&uV0Rg*;#q=(RC
z)elg$WRL`^MCf{R;LZ?RO*Kdy?<nePhFLwuXvc+#)K5LO0dhscl3L5|+h^Q*YsB7d
z#bo9o2<@3dDuXK=gf$oIHRtOR|FmLrKap0RohoqczZ$UHDi~$5S>xMh*zg25DA*hv
zusL{#v+*~<YSK24jP&D~elW__0P}B*_tJr!t3JJ%L@F&>guU}8xRXy&Pd`DYQ&j5t
z$MxQrH*Pp)t*|OQ&1vNR_g6gqaKP>@VRF#0v*W4DlGJE2OS;P?)+lbhRWd0Q7k4wC
z{V;R?$(n*)Fb!p?86GOC+ktYX@heLwaC$oA<k=<G7^=De<xpGmXc6$@Fey@+{yU12
zsh!27J<iRNaXMiA*@F1zKf#{2tR->zqo*{VpEIm)qr(PS7o>}fHi6`O6<4<bRcO3K
z@}gs6I_w)IwVSbgm^k_IiqlWm_>>69uRoA3ME;!zS_Foc$zjLwYl_2HET;0PpplD6
z(7pU^tpeg8IU)FnS_rxup#{RTCEb7g_p}fHg5j(}mXW8Y8y;Rn*5jKP>tJpXQRF23
zH%~@n>)EO@Mj~P$Ws6@L!de*YWb7?rSZ8)8B`J7J<*5e+g|ReQ1D?TAV*j<08*dft
zA1joL=uJk}En8a!VidwgSbQ9~`v-ycVdT|s7>-`|j3$ZQT(T*^=Y(rJs@xHW!scj~
zeC-bBhqu6*p5T`<I?ENYFY_x9=THG9RZj@i5notb&bToQi#f+?pRkHp6;Nht8N&({
z72~4j!Ka41cNZ+fhSz_4hu6NB85{@7+L0SYmsi*nC|$+Q^@5=Rq~YXgMtv5Di-bv<
zLM)}rFbFh5PZtMth2qhL<@1Lgh)ky%S7`E;vwLqy7P~-UHOe^JtSF4a<N>WaW*v8^
zfASFb>;cp1AJgebyxS2zY2nTU6AD;5;+e;|h@@WZUvxlJBw{GDrFI2_BTKT1fX6)O
z<()gF>Et)mY>3+7fn0(spq@nPQAUX(x0>h^$q1x^m;*#XB~9)?cNrxkthK1NA^!9y
z_zyiorW3_!vCn6d1J-qo3z=c=MbZZfO5H1pYO^J=X^VsaRuMDUvZt%p1BI~}pM?w4
z(q&8AITkButWfW2#;?P*Z?#;zb;xwLVmwkv_DD>0?V8kjHZ8=s$NXZ&@~0ikAA8g?
zQr>Y4tuU-CBte&%B7sQ>l^~mpstStnjPc<Ol(S^B9muBM>lCesTetPEb4F4*kX5lQ
z10$uYaVb&77S%qZI2#ZfFgl}LKTNV(7>ZydGRh8~1vY0JmLtb%TH;zq8Y_$>ih;$s
zvTyjf%y<g3W4QiJ$2tk?pGBIp4SuCrT^KrVs72AGj1QTzNDOO1GE^?(s=i4SV?UhM
zIuUa0&vx{@vYuh1ka~wr%*;N!%k2HTEJ6eaE{xInknZ&n<N>KO<W0o7&}Y1$NI8)u
zpp?a0OHme>QZt+ib`a22uXxv}j2HEr38b7eq7qqRkN#B(pIQo4qGFFUPAa0TMQ24O
zAgbKb1B8eHQ=wT=Go~t6<lGRW;0ld#1xZ<4j<lg=TquU6uv;mHCS#mNj74m3e3eZi
z6H()c_6A!Uv?#hKnU60!(#G-dL&c-J8)Bh&<9jvN-Yb~h5vH{Qy~KA4r%PN>kfoz(
zEl<w_mybHm&pman_|ESPs9a>{PNJ+jYF*=XL}`tZfYQ=ymMcwBI(A0`q)sTO5UaNu
z*Do?s`W1*%TcwGLt$4nmtinW1F%XKn-3rQNP>C#_Bo%{dh)s&F@f;o--hFSv*;&9&
zHH#C?d}TPeY1!Qi82S=7<%S$PtTD_EEXHc;sp8~j<iVdQE<Z|q{!@#t3N~xVO(ZQf
z*C!jMrU0>63)Uqty(G0(3f)C~(R=Z(LV}<<51vi#y?RTdP$^Mp$h`m&l|YT5a|0ro
zEP~2;dv5Oa4wX_krI4HuF+|BEB{(bF4cQP=Z$T==-%KDGG=(T!7P?N+MIod}T@Ijd
zXp>3GBSy9`8$m3X-0KeboQN7Ufye>stvjS+kE{ZNivjhSWwnlsltoI#wA36971!#-
z*k+VfWNQ)QFd3rl5L)aoQ|6L{<9wsJ*m%zMfXze0>Bku*B{$x-+<Cj?@Kwj;NHeS>
zKCK9%P-3vIASBB&6g)gnJo?~*O|#<lo3Qt0%V6BXz~I-4+``62L_8)&NC~Y#X^qp0
z(m>@LrgUI5$s|<FIMw&+lH{vF>EE>3P$Xz|KO1sdQCNkDA!$n%-Me|DK%wa~cS@{Q
z87sEO{*C9{`PPV|jpp$)&rd#IbKwhKi6yVrEp|GiE)6zWLfbD|V*<N}1?5l^2a3xl
z15Q6wJbGm4a$xVYWoKa7HDmUQa}KKlqf5HrQA#jYZ39UtoFhrW+Goxiddy+UbX(@L
zHVHeKGQ9IP!{L}Nc+%aDcw$kZCaE>q2+9e{^hN@rdR=vGbZ-V%SdtY&@PsB4)(t8S
zG1L^wP>A{U2hy>wWRf+dt_a!nqKQe6lxe#aHV=p?gLzJ5%ZM4G{f31Nq+-Y@EU=*k
zrYua$J{jA1yp$+wI2<>OhOqIOnJn2k*kw2?sRo&mZqUio1!36+V(6W}d%?!u%QT6l
zxk#Km>9|~sIq`E;ZJE8PIr^S3er3sMN3$~=kg7GsW&~Y{Hn3Wp(fG{rM3~?Ato|2+
z9cyO)q+oa7VU@uo(@SUNfb|8@d4eC4{0Hde4$5w@u^-MlYbl%|DM;C1okar?A&JK7
zuPQ6P{O>ypwM~ra4b`#%aS&=lV8BwwaG~*4Vv{l@1y(7Ru|wCIs@)+CBe7U83N_b0
znQ`*tHLJ$3xG`XF99T&~Q8==6Xd?{k5m}W;nYg|Pbnl$7*=%_B!GOyrBf2MJblEUE
zzF>W$Vm}&mYRS&AS_NihjWe3LTQM3}s0yr8(1JhpbY~e;YQ!08ohS#2Mptyo(<;qL
zw?i&EoSdR^y@fnwqNLu=ruVa;O$uj(Hb?3dQCeZWMr+5s5=uNXu?)Ym!2T5m(vhv?
zRyE}S%dJ(-Aoo(dWo{_5!lj54P|;&j+WMI)5+0K*B`r!coli(!(HX}^35JTN>&(a%
zl(uACI7%H6<!BqBbVJM}as4=PbEiL7oNO%fCk4yL3H3A++cm0NV+j}_=^<xgSWDuJ
z6?K`p`Ryq;-!<&N-m<&XJJdM|5ER-7!3E|Wtk(sL$BE57;Iqi_5vV#-YLA~sVi&O1
z;Wq(A0g?$tM#qS(pnKL}q(<Elw6P=`3EK47>!L?k^bcCLK&7uL@4oyYSJHz>wZ#4`
zsvU}qi5}m1;(5g0PpBI5f$sGdv>~GqmuQ${HU{Y|vJ?upVt02*9S!Rb6d!b+!>QwN
z=BTHJV(id`pqmqh-Ga6r^UCeakb)<J%!5C_;QaB5$6dldHC+2Vur?5*C%6KVWmOJ{
zQ$zjMA)9H#a0lu#V>SvyMV(-??n^-H6iM~IxtFbC(ZaKJ<T65~EH~A%Kbz+ca)(I`
z<YGJQ4wz^`X_O6QWk_8n2ann^s`n^)(~db9jpX6_l8?hi{jCPl9XsH+t9|yhp<Y{(
zY{&$1==uv!nV2&wMq=_H^k*T}58I3gD)w3fy*G}glSD`b{#j-g4Tn?BtnAnw2$jyg
zll7<~?6mA028KI{%bZv)#yojka{gq)a<M|_&;$$}nncQh6`D1$L~-qg=K601?!2cM
z?FDop#0aZZrrOy<J4jlyUckf8Ef4-=#o$D-yQvu8j3`@Ei>7%JQA%U9q3bfvC}LCu
zXK=~FnPKy=!*vS#t%4{OUK!jL{IVrU5P-A=2?^$Fo{=EZyZfnPi~c|pY|WCAcw$L^
zo{2U1w+n1GG!Z)MC{$wOHdqQ&9H1M+?xaD#s>xWMeIHJrI>PG?_l`wRHC7;QJhEw^
z+h7XI-ce>WRuolYxmoaJxn#altlA-sBy<!y62w3$2HiAlTFv!WMyP5{eP|gBBX$ue
z<A`Bn@se;Bq%f=nmTSe+h3Bl*%%i3uV@!dHD{@SP*kc^YnjFIx0^>o`yBB6bG-NEI
z4OVF!ntkP%=qVJA50fTp<g@OV3#R|#Kzg;Za@&o#=>|-tNBA!3-2@m<QIip7rcug5
zw&>syEj=<=S(F%r7Oe%X41>vnX_Z;AVo6}V0bLdhhnh((*dkGCjrd+p%DGH5kux1=
zDDYl$u?RfPiuCqv>VpcsXNhGG#?f9V+Jp*;YgTjgO62&rExT_T>XCzF5HIAEnEMVx
zAhm(z6XEesGJpB+&p6&_-n~{cea)e51+AjJNFW7P8G?^cC{!wFRqW{;Pir>!8j3+l
zb(YcdH9LzXwkmsyKulYU`>h75GvxU7Eag&4Jqkf9tQd?fP{|Wc&yZ(x<jk<T+b1?P
zD?wY<8&7bSEP+rB30=k}FxD_0Rg`67b*6aylgQ<VF#JcF;bF$@Whzr+az!#z<j^p-
z3PqrbnK(+^vYv1dSYH%aH9$>UL^8EiNK%+a(>-ojKe*)VtYH>}U2Uj~Owb<D9#lrF
zNaZw*ifC);l;!ctGjBZ>%|t~;&QaC7l%pexsqPyYskiFPx<{^OLQhyU(u-^+iyqCP
zNMttD6pSQMtD44op5~6vy3MaPBi$%#xz3P-LCG~U#)+bfzDF9M&{ah~x`jU8!`!Mc
zwt}R|u|u?w#iB&_H(~?gGUa(<);;ExPtLI{c*L4jut+Re#mt5GXrow=>2gM`6y?&g
zxiDlZT&P%mu;%jq25ug4{NE2be)~F;S4Man$q8IEC@-j#8R!Ysq+xdGsrDR&t5DRC
z`jT*caYi_uGyn7<mmfBCpN%k!A&Q975u+1@sYnS_2YM^5rDMdXL=xK%hEbpf*izx7
zMCOn2pZ<gupo<=GDk*O*DYw`=Yp!Is{-&>SHbmRcW3%+~s1hUT!Bg_XIk~yOIMshv
z>aAW(&KR-e)M3LOshgu!*Sls&#vqhAFj0Y9!7zH((0thPR1EgD36sNP?CvghcSuzW
zk^(wLb`CVJA8Tgc6}rZtaD+ii@*TtBkdTGtqGkEB1=SyX!t#&rbAHV+8x`bE(=7~n
z2~7tfWQJC=&VpBwv(7M&8p)XnYX;&u9`Cbzbe-vqn+#tWffFPsVh0#Q)ETP-g2NF>
zM#w|KEgzwV&&ZtjYy!zdB@ArATkKLMD-Y9}Gn#*M7Q(;&T7h)4sO4rg;oD}H@zAmp
z9V&X7)RIsnm2ic@?H}U~uTfl^pzUD$L|f28jt*@$Bymvm4t{aiFum}|&Kh(}kQS?l
zG{Cy`Ad1$PNX{gcD3ZfH7DB7(#+JcK^X$)_G2b*C|95Y3_}yE)_1^1Tzq5;wk!(>E
zeY;a9bY9~M!5DDG_9U(iXocP^@J+$#lf(!A?wn^IJSNSrF&i8)trK}X2SeWxQki0?
zu=IiCl0w@AIZ%qi*@P{2al?R_jWB1Q5`J`!fAk1d^uSg1y!E{eB(WMTUvHAMh(fbP
zNt9WmRPQj67c11sIXay)`PMN`4`>FOHm@kF66*}D&loaED+(uMy1u`hU^F(o{!K-$
z4Q<}=@K4YA{GMg~&u(%1);>qq_o?<rpe;%SmlZB)s+*db@7-*b>X&fnJj3yjhQ!0m
z6{klR@N~t~|L4a%{INzFnCus%RFE1+Tq>e3a9I<vbbdqUD~ug7Hj#bK7^#+5cP9+4
zA27Lo1Flb@(2xY%X0kRUqcFyzk^>c~OhT2O>NMd-Em~=UY*0C4u#^UFn-ROJWRglg
zO7q`83m0E6kfz#kWGimFA*Ia>v&NO0#u!#~WC>^$DQwU9)UMtFNVjq_TBCIVHeq6q
z5=cNu3eh#TC@2fVPEZ8n@MxAzCUyl;4e4SFWk5wsPJ#S1(<)D~f%QUYF_Z?%k)fU%
z${oX&uK{97xkXHdRA6=8+nu05CzJ-1q0>X!uHwnPf{%U>=^jCCI`(%8im_m-$g1)9
ztdSJSSrN9-7E}QtZWW0%Q6;n;!c=3#(S7te-H+D<|9|zZ?=6+L(0vvP<n8?Ft8CG~
zJdl)uwe<QEb?&JR(e?pfbl~ef^4>LUs>xlZQwpUFMN+Ip<MNu64Z&JcZ2QA`ED>jM
zM-eX_=@HC-3imz@G&d5X?;55In3(An_ubzMN>f;Hbwc`qB3eoU6;>O@WM(<A7&?lb
zF}|$u^9}LCNb#T~>!LSC%K}NEbOuwBqd?9?u~da(LdI>0hoWnO8ekdqBpaik4BKI^
zkfTCr*RKtoNJf!u0lHV0LK-S#7&yUdg~KpbhIMFp`W3T>Un-DXf}tqJrWb9WXv3tg
z=tOgRmbnNmmP9i@rM(;yrW$OwWotG)4LmxGi})s@a=|6Ae!3<;ZU~p2%QoN%_!QV|
zS}wwhk|A9dTJady;>AIVl-dweAYw_(V9?N<F9}az@vy_V1*rfd1$aS1Ls<$<21BH4
z^!CBDSSKh`aCzBs_VALEdmZN|B|~Oxl5n=36T3jA1Id+G`+Q1ndNxz;y^=%>E~l-B
zZ9r^qhGo_n_3R1Z{3&daTyYBsDtqM!!j@g7zb3Z9A#4DHqec_y`adhnKpgtD9TvL|
z(+I;3;;>-pg~BJ6m8Ldpd>EpfA^FU}Xz+$?J$bM~Hi|SKvywg9repOma&~ut+nvyK
z6_pdB_v9GSxo7_xyY;UXLG&fj^-YSg2x{Jv@1DZ54(T){W7>7aa$O*3j7m5iU@PmD
zb*45EgJ%&Mrh}fQ86<MH*kGQtgxw7aiy0UuMp5OAHa+(Y6);j!=uBf3&Dzs#8baqu
z*)viwtqR6f!3Ca_fh<&6_43(YH;`5cZGc#8DC3abUCnO!1lyG4vSOJsJW;6A#OD3`
z>@DWFq9VjV$}I*%Aw!bgaJflbv?HFK!P5sD@}m`lAFYWre5?=q*>aZ|%8(4KS@e9P
zu!F@TKuA3u&l6Et+-Ab#KUyMhe@uI_V0QC>>@rPkkPJ@syM5M%7~>YU-%DX>t$T%>
z7}>lpJo)KEtc&<qGGKse109Kb8^ieOyDVOkvy!U?E?ZL-7;N8*y$}jhU`)PpG1Wge
z8~SBu7hm4hi(95ISDr>CO1WNz2Z!7>a5ux12+8xu?}6TZZ#$9N-ecy4UF4vb`%;QI
zmWDw0lM9O3DPiGwd~}A&-3waz^Se{MX|+<SNB9?l6#W8~i^%GOIgkGM9?57nX|R=Q
z+4NmZQTX&i@G_HVQjHN9VOVVpKW2wPxkvSX2VD7t^5e+f+cPG!6}rw?Q&JBKoL<wU
z0V-#38cR#KSW(`E(Z?3-n2|BOa#%9m?HKzF&z1$AF+P@bq59Qz?K)s=Ev|sVD$0Rn
zG_7#CqX~ia2OqHBcvcHVVJvND$fPSF#+;y8DB6dP%lAD$`{|sEwq)SO42L%vbnSNM
z(pzn8{bG@cLMwOmpkB!Rz7SiS|Jw_iYQ<;nE<t%j5?1$oRYJPbM|fGJ@j0I<=Zp#o
zJ8wA-4y$X#n5}?Ez)R-5`0}orQRWxSPq$tzC{+3uf19rtLMQ$GA<wz8eTf^@`j`9p
zzqYazj22uj*ozjm652ohjC()+glIfQO}_Z=U(%*fN<lOv6-m-R8>0$Ls7Q-~p+2V8
z-Cz0Hm;a9|2MgIE<#S(}CrPvkKKWmNMk+sN_fE+hZwu3J59!7V?;4tPNtH`tOytrL
zEvz<yi^ny~l_HlLMng+AuoQ)0rNGz%X@w;HHUCNiNhw8Af*2trq1kG^>0yCsOWH1B
z9<C92M!UGc$4u}Q*c#D^7$XM9Gw-=rgA7Z)@!bhwI>78`O6$m~+19$f>J8iJipZ7-
zXnxTH?*&mn&}SQb+u+*`F|@rpsBt|SI`s(Ommkc_rpf^EaKx~vDa)FyH9=*PQHa=W
zm(6`8uY{jJ=cwGD)qaVA>emK;Z)bHPF9p2V?dNKY8hkBKY*Q>z;;ATcV$nX)tuOJL
zH8Hdl?W6uKwf@2;_5Al}YIM%1+y{~?3*2~&8;;4=;!XT3!SjXEb!#S_q!(=I^KR-{
z04g&(b+jvw^3TZrf{O>1O-ht1Ff0O_1j-Azf>;!^tzmsJ#;->dLjwa%rv;rLWJg4A
z)n>mMgJ*x)AbJim^)d5oomgO~4J<<@Y0y5S+R^{d-kbecmR;$6zqN;R&K+WooT^v@
zSw$9$>~1!@)h)@eEeV2Qz_4WlwjT_`fM5LRKgiF9;a39!{9vFVTWz=GCZSeS9Gk_O
zbBf4}>E3&$JuE-$6OmcPtc)TvsTSZmPgN0lZ=7lEz1FwB^?jtXkq{#`WzZQ}8rEIp
zVl~pHJ;GZx`g?|h1IzBRDaE%AIBjw4e`beydL@L?NBW|htg4JA5W`U1&2!PeLxns^
z_XbH<uHsjO+e>$HV`y|SrF(_@rbaO0uvyTQ==^ZaeX9O#iZ(stCYUL3^XGP%qMBr6
zyoSs7{DRu%TUWceGai$bJZ!@lF$$;E`kBw~a={u*agX;}+7TjxR2C{nw#qW>Ja<>T
z)V3%F1D0&cmF8TW+XsJ6lN)qXvwq;&JZ^aK%fQwqai@W_cY=?Kn7XuKI)}NKV>fdu
z@jOZ`sZBH?(<Pw`hNMNA_d5F4mwK{hvf!wUA;-vBv?w*sRgA+xOo>Hutj?gxOR9B4
zErKzQF~Xyx$iust`;~C#)qP$&ta<JA%)yq$SkIWt-`J#!a&z_B>*S?(&*y{b^5)wp
z7#h4x^1B#9PGn;X<66^mQ<;nsWgtsJCXH~L4U$aJe6-Kclk>B*$Dc-fO!%F~k;zY|
zluz$32}opZUMRJza)GkdD%pl7qWrlSWgeuRXQp*e&r4m_gfeOW879OmC%P(Jdk#70
z&(vOEu2S=b9^$Pq#K1i}=cC69-v96%bN7_<dEoXtx2cT~RUs+;Xb62n?#l?wNwkDE
z(@5EWM2qQ~6@$0-#RKW8CQ&J5Kft(oVKc-L>kK(r`nKadK*r-zaqy0D<ov|aZD!cI
zr&{$?o1UsmH1nD)B`pkNVo}eY2%6|q1@`4?ke|OJshG)@M2lXHp{!h4$Ps3vJhQ&K
z{8?>GQ5LcWYfC_<q@~R974`U=)EN0mI(I4Adz~EBi>7v04c%f~_IbEG+vlIZy`~==
znB$Et6tGyd`ox+dFcXz(62QEadH#G*%}|2CD4A%AuDD+50D77>KA)ItY*`Ga_ux{O
z5Q-5&RVBJ{L&~wpB)69EsK=iJ)U1DD=^Pk4l8n+DSm#7P_5`E&s-iLuuNiV8Ybv#v
zkts!f!9dD6lXIq5Vd>$}XO=Z2n|SO-E?PrBTAVs0N4l8MwGf7cq=ZYB22V9+W+#HV
zTexrW;goL0KocXUGM4mY^7OfS6sBlu+iQ~e*gOFuE?2J0R8Cdt#Qqwh^mGu^!4Zf=
zQ;Jzh6LjkgxgNQu-b74+v&##tpGEf6fI0u&rgqPK37;$)DOA^{@XzP+olT-OisVTc
z-;^;0fQ=i!aAzxELn<JWD0zCOnx|Avr3@B6=R8y|^$ef%)UI^Kfz&8{5{&W0hmqy|
zj@xZwz_U6xbmzrLAvKDbTXJ2o&cZq+@Rl3(z(GBuv6l6i*o=`OSdwP?%*zR+loA^Z
zcO2|DBZrNUY{D3&ixua+5MxE0L2ZkWMLQ-0SfFfG%IgP?+?_N0wB_PMgSZ8QsWBR9
z(!gL1<}!Vo8jJa<?8sar4w42f4Pj$SAf-I{ehX;g!hSY2{CrSFQ@Y?_s1h_;uqq4^
z=vY%<lP7DQ#I-&XNKd`s`n#=>@@2q&K_j;+I$vLW|E|G8q8-pEm~5#gM~;{iQ4*NX
zr{vGr(aapH5vK{C;}y>^i9wC9Htll*+hkW949Nvey>!}`h9hSwG3X3TLeJ0GI#s^4
zH{;aLc(Cd?jZ4Nf0EWiTFs@?L_6#ZGe9fLa=H|>Xt319hAcF}-B0B0z2&BstXrT#B
zxwsEVF{s}%hTR&%e9aiQI9+wj=Abvuuy4(AcEPQ^$kN_pC+|WKayLg$l^i2Z0|esc
zWdHym07*naR4SIil;!EOfuDXOR7rq9|G9MJH(Sr`^fwc*`P=}*_1|^fbY<di^XOmr
z8|+oU_KaV!_dV~^7gu*FKI6&CwF^c1f@fBaRtzR@u##yii`%Yn2acS2Y)Z7IWjr6z
zFy~>X+&Jo>g5}ImHyJnE!pca^hNW?wrG^|TBrEkb*~D)IHi!s)avTqqAuF@V?RvjX
zEUYQb*3Kc;G21ch-$^W+$c=?C%N5RDlzSEgigqLUG6%hck6$45xV8`S)#v|KKmWTv
z6o+UTGq)93@4yO6z^n3|vEj5ftTq$Cg|a(y9Be6--{3^p^oFx`!9}vHGGsU6&48rz
za&{zR4Ayx1Y<aj5P9(DJl^Y9Tzk#M!>b7SSGhK4bcPw{a>p0wrY*ii!6~PBY4U&rN
zuuN=#;#>fd?N=}2SAq1~SBP4MCdHH~Sv3(WmfBdh#qe5Gj!uM6A9)_MkrW1&V!1s}
z%*>jzJm<WxdDu3bXvWzAwGnHt&qaQtq}@yiOVXmxoJ`RKFvj7np&k>&Om2kwl_mS%
zTyS`xG*v^+5W|y}<dw*~d<Nh8>iFvT?T=*2q=6JijN$=hsHD83&aBxy%*?8W>Zm33
zJ=#^+XmRrj9SkGTY9OS9%L!`>qNpze{=QsoVvH;+!%nR%t+J?u#v9sbxCn;T@xVF`
zq<PK!wSAhm_nF;UQZ*IHj<`+z?Ea8^^$vV>yo?>mOxaCgcZd|`yT<`SYBsn}*Hkhv
z`{bBa&aBS^N6U&WyTgz(brZQ&b!-h8=^S0C$uTpU>gAwzm$358!HtDwuU5P$ZOR<4
z2Tr=o*acPumUU)+V+a4rYuMNCATxt=Eot=VR4}Ths{oR(QlI}{eE#1~p>%21Q~aN7
znUg7CM^(`@kEze^QSWRxC389i!coV<%{Z7_mQ7-}O7w%U(u#g;2ze};j4x|P60yZy
z!76_0lg5zgBW(Iez#!I9Sxa46Y~wInHB?1}%=)L`*ry+gUOkCxZ_+hS@~hAPyZrgz
zb!I1%arV^;U0CDAHCiAEZdQ}MDFcsFUbG2;91Mq4R9Ts+Asa(>hS3XY3^;uWfppd6
zWFo9arL&Y^a+Y~**;dc7TbC2=BXPZEvpHto&#1==pAtpnKTl1(;-ynq45rY3jDEGE
zf3+k1)<@J>geG-L^RzU6#oJ=t*^lH+AvF(iK&)k^4fR4;EFGSR35k@2K9wQK-Uf_K
zG%tg+YHgX_@sjA1<-yu<-U`bqvt1`{%{uPXBWJTMezEG12&<zD^l!GPx=--)7E&PS
z@&$Ko`3%YQ^9%;jak9kBsF=dm&N6l0GhZElyGNBNL{ll~t<y=-M-;p;euiT7%p&6&
zG)xQp3zKKoWCLmxYYje(Y#yJHA7&O0m5mx+Va02=_ZgamjWZsO%EKYiWrH7-CM0}z
z1iQr-7*qWgsGV`dtgMHTUL%@d<~`0<%xgz`Ao%Esz0f~AVf|6dX)n}%1g&x7@M3|K
zp9B(9AYI<{EJDKZ#Iv<9p3ATGtGD>yfn%_qED4=bd!wchL#M^BN&5WVPp%6jx$+dg
zBtI(&V+1vZwQ-!E_pCpy7|t@*S5$MyY-#aL;-v2wx=d&dAp#nUONbpYyu{QlW~Fk5
z+F5F&)U{x&En8tQ^ji^Db<wQ5e?e?c8P7(dM2zf_<Jn87CH2>a@-EW~OI2Jc(1}X&
z<o8MSD|r2PjhbDP+V$$l8nIWNwz<quO)ULE(yx8rZ_=AmqiB9Y12Yq-B?8u32B{d=
ziTGenzSzRdmyFxWnutq1gLQc4*cOKXS&9LKNs7zE%L$}{+zB%ehfB*&1&syGhLcw5
z`pg*}y=m|&=$Vr4D*2q^l`10}sb3V3`ND^$s)#N65FUq^JZYEaD*}p${i=rfoz_6l
z|Gbp}QNfBw)eurFoVl!|Q5jAB+~<4U_df|dd1^;03P#pissz$0dJ>UQh;_wL>KIRZ
zW-j5Eo}EhB-&4*8I3GQyQHW|Mw);!kk&H3S9PIhPK^3qFr^#_X7>-+^PeRTXOJ?W|
z>toMsGY7dKYeG}=f@@y>wHx>J7=$hb$)1#(!W5TCmRQ*1UqV{stK-G9h37xLH9j@O
z+z>T0%2?7oK%)B$srT7|^!z87r|&ZQ^n`A4=1^nE6xp%3NoXwgn(Hw$B-pB!yk=o*
zo|rd1CJ4hxO&%J?U<vspj8R-(Sk94@gp@KlgAv6FSO?B$8m(w^@!d(zFuIE9E1WAL
zASUVyKB)Ye?fz-dA*Dn-QNkL+MM4L`*n-$#iyVmLuWF^=Z6H1W_n{H$RH2<ADY(6g
zYCBU^P+3Fv@u|`D{MiNbb3c3L%PgOpHPh*xF-5*G2akG>R!Zs=&9O+8xthk$sB%xv
znU2Jm1tnv0!eTL11M%X;0_l>pszkczdDMCO1an^${`Y5@rB8IN<>R){)Mxvi#SO#O
zcBZKuXhWY~bVBsAJJ8j6sgjb=-k;MZcyz3c=in<(Jr}Ys_A&OWIQm;X`qWU5HSI}2
zZRFsfX8#cCospeoMR4*Nahs?0G|F?A>uaRx-`GnEnhIhRXDm7jF?gy+2I-(Vi|kZz
zxMiuUfSAPDXxR*oO%l?mSUS9opOGl|tpn*Yh4S9gtL1(xxE6LQ<@UC4W3DV*=14OS
zl9IG$wrkmbC9~Y?Xk13Jr%v??#!>!tfWg|Ud8sqsa6S&)KZ<PD!py;JR*b!dX*TJr
z8t8BD^H!D&I^&!~%!ztS*uJfBn5g$N^H@Jsk3VCQIm@;1_hn!5DzzhFDK%0c)AtUK
zMLx;+kU5+iUR^}+JtwL>?iwDhW~3}Eq{Gr;v?HaL!EDHaA<?FeJzvE8f`wR&qG{AJ
zhK^xaP^FR1_6&_s*9-hsjW&TMc=8MGNNOEfN32lfxzu8<hpcq{3bRba%5vI{bVE&_
z9eM5;Lrb>BiO4EAwHPcZD}yS*3E~~|G%%!$;;E&<VMr;`n~~%qRkoDu!hB}cGg4gQ
zqE@BZY>JvtqDW$0IjvuFyBmGd8`G(2U53}ni{)cgNSS^TnN%&sJLP(!gkM{=%L_HF
zrV?P%A-HUam$WHkR7qkd3RfxERXnI6Px4t}dxWM4Z(@K<Hi?9i1*!;Y62@7EA>bxu
z)XEuB2n6SG@r)ivkX^RDu-~-IwihfbOP=?{WYFx(s65395;Dd(@-;hB7DcDQ#v-?w
z0gIVZJEw-NB#0ZRx94=5k<n*z13rLdiBrXq7*yynC^aG@b9otH!{jjC$O7XM+h$<D
zmV(*|+#4J@&N;sj`mvfE?<chxXTX)Z3VAWx62TzqCt<VlLR;^PkE~l@&LhrRDqE3o
zSWU$S(PWSc4OJP3x@1;ZWhTljD>@b#Vn+jFi8c`EF(hW%;L|n(?ewrR8AH@EPgNSl
zMHW|bf}F9EFyb)iQxj{?U(o}x=tH=|7Srhky_6<X^TYw%h$--ilrFwx#o7F1829p}
zQz!$40t$H&kxW@gDrC*m`BOwlCKV!Q3`P=GCf7R>E+3LK6EqVU5fgDysMTPzkfkB!
z5lq78GVN?84Lai$8B;k=iVdaD1}_HhEpBc|c19jEF&NaC5=_(LqSz~*<`?dG#yz!*
z*@^wl<k%;Sam3DMNR=70Fs6#rO~60S%zcA1fju9Y?;6%>>BoxIFe8SMo|mE7phYs)
zjh1QwyUWCzbt&dQ9pR|A3>TJ*$7}jDV<8@E14Z9L5GQCfFWeS2NwC%<qNtg+dspD~
zpc!k67=~4gLGdQztf1Br#8R2!MH(d$$rD&o3@0TC!8CYNsQ5`DiG+y3B!L((maB2<
zM4m{uMPp6H;>8wpa(Y>fC{89Fhc5x&s!gAfvr<*;<qE5yRYH;=xd`rCbE)%|$P%$n
ze}9?Pe<~f*A_L6S)JBU-$mD3JVlWv*Gf3&VITSPfzse+jBZ9LDX9O`0qZX5jsjF>f
zxa=U0STUqj#u=iPdpEB<Mm<a}9y4pHZH-ixTm=#p$pw;@UD23gf*??Kqc1@PESGDp
zL{T75vVOv71+_(S7vo4qc+`)yj{=7~dmJp*>^8zd6*wCP9*&X6siBK7#+M++m8Y4Z
zF$5%4_*9n^CkrMdWQ=UOjy^^L2~34I0#a%hLGi{xjxQESHecn*s)?jZj)|CruFr(z
zh{=#OlL=U-C6GnP8EV^;a>nWu1ezgBNn}KDIZcuWiiuEZgBV9J%G!@K>an6&o2I7k
z^n!{OEv#I`;<J_=A!l2}4Ar8dSE=9^9n~Zne@TV9gmKOEazrf@7@JEfC!)nQ-GsvC
zNV8w7SA?ff&N5MkF_E(A72%Sr^AF{kvIsdrOgg1grD@u^3mm0zcNArvoHJP>$qw|J
zM|fw7qq}WLL2&h)EM@T%Dd=j@R2Ju8h=XU{3Z@#%^`oT+sJSE_;wLHS>nUDO>l9u}
zg%x9FP&GK`*o1(Pu&yZJMiT89SdWqYt)j+WN2Q5@TA{WD8}Pn{@dX3P7=!m7zg5E~
zadL0Npc!w<NbmmsoY`&1nN~c0lu2n*ykjT#z7)VDg%^dt&1B+bgrtd-Atz6}v0R)P
zPEVk1!PFL8C8U{l4pZ{wVTknW3sQT5BjCzj24t*tG<L?YJYbyfq2ifoqRt7dL9HhR
z!Fyr57Un)tPfcIdgyu>0(+F|$EL{)Kj#{8pu~$3D7e0)O()i1vq?uMqdQ(^cN)lHl
zi!akPr%0V)=CGA#l&8PnJOvO;yIWQo4_mdJ&cCE=MZ&D??qUr|pbfC@p$$qf4#Xld
z78(waf}m}S_8Uw*rD9D=<y{$KBAP9-Te5XfW1J_T7-A9Kbb?AC1m*ORVk%Eep6v>n
z2AaB*206z`eZZhOUf)oc%S9+ZLG4gfOOQD=Xoy(N5PLL@9Lz0?!wM@s<NFsp9x5IM
z%gSW>nL+2Nn9s%j#djnxhRRsh!v;Ma>BgR(iXDXQG_uXe-omhTV~cThK^I5DpyXT?
z*`^rC{m6@Q-XbG{#nlbYR17h4aVp&Vc;w!vfs4~(1!JAXFAb(Dt{~o6YG)94$T(zr
zS`r-)3*#3sjD!%-bbzr-sB2O>Wf)u1;Bje5k~P*@W=`0j3k$E<3^`xwi9@zRz;MwE
zF+{oyAttgInri}SY#~jyp_i_*GOfqurMOaLB$LprSP{JO2##d>ry7yZfRa_Q&M^0e
zgN3m0l-lO<{PAR~MN+>n=iLP%#sV#G<t4@`;tXmNY7!DhTv%g?fFtCHk{NUH&s9>9
zjh145;Ab8y6(J9Fo6Oz!23C)S8?OlZiemO0b1N7VAt)(Na>1IeS4UyWGJrhoZU)e#
zU=__76TzvFh8|1c)%`<m-cfQt5btKrx{f1+3xwL%*rlg2mRaMUcn|#6sa;IuA+S~L
z;=Z;d*nzfDoX;%nl11GxPnpf8rAkcBbwY{;O<<GaQz_kFh}V!UBBoG|fOZWh_moe5
zp?vU*L>{1?M`m-VYQ<MIaTw8lB<q?!wN$$e{?)h0GdHQP3Sm%EACaioVW8?CV}g*K
zAxe$0hB^-zuQV>vSfP?cr69J*=O$yRB#}iiWNMR`Tf^W>s*+V{t`X)-cS^rPta&yq
zMoT)P#WS-23JFMxX!=YsUTQ2p10!36d8N!;IlmeZr)ah$HCR=$Ermwql(`qiNO3gG
z8Oarl9rPW7Ak~um$~PJ7Z<6asHWo379czn*T^9(e7T=FFMhV%Ft;M(on}mKna{f`~
zk<F}bCCr~zkPKd+uF3+1mJB3oo=~{w5tOF>A_kdSC0R4&b_zL0a<phR2o*IJJ0@h)
zbEEPc|K2{LO471;um)|Fu`Tb=3-3rNjP!K$s}+a;_?ztf2d}X8s$)*1zQ1Dq7oYO*
zpZ$!}v?PTkwcnyLN{U6PwAM_8(7oWeinBH280ou_p%1Li6KBT_>&J82vxbU9W`rhT
zo#L${hJkjoX6%nK3(M=@{zLBkdw+s_{Tr<7ZB}c?`B7l?sHMMmg#YEA!O#C0E<^Tj
zpoeeamYJD5W2SQ&8>n4Cb70I<N@uDfQ5JjD2ob?*MdM-5IF=Z)WNg01-{{RiRaxrB
zA;yq$AU-A0tEynYI)lNJdx#f_{wy+XA{xzAD*lAn`=mxv95WZGY#_yfK29*bc(U<S
zIiN|2QnUbPRaJf-grKk*Thi)?e0~gCBM09iz4;E|-FFDD9P;)7EGjr?9O3>w9{=cP
z{OZsDZ_Lp{mKt!cyj4IL3zc;kacG|zFl;{UIDT`)yG&ETd|nV(>xwhG8hb5s!eTC+
z-zIyT3Eh+_(RB{Z5Te1@3XAgS=!Bs^VtMBl;Xiwa#jS?d4j1g6EA0=?Is3s8>Er^2
zm*Pe-Kx(l%WAUct-S5@h_}(F!8%}?8#`_<vIPNcqbUc)nxAP%URy4C2&AdaCBR7Fr
ztUjZJDpF81l}r|>vnOgS!WEZkkQS`T7z1How8~i<xp$N}{nRrY*JzvAc55QS_N-=1
zN}SEGA+p{}>^}aKIV1hXV!w5h=I?)-SHAvz{Qg_~_-@br2OWR?@Ps+P<c)j3<RV)d
z5*qHY)FlgMyj{&O@|a{QHraEpTQFpU6I1#~DG_xK6>wHrx`Cal<Ax@ZIFe}ysX)v!
zt(qjm&<DgQvt^ClaqJves;x+NO2#sbLW(24GQ@20Dl{IP9qId#_K~5}if&y|OG~OO
zu_~hpR+Wn4@NI}hg(x+fRC78sggl{eCLuX7;z?TJF>F_nnVhjR7lPa3(OMY87N=()
zaY)YzJ*%N({rbCn@_XOso40QxZ$!SaeaJ1RtUmk^&YpAnzkS4c?$HKh9mt1UY_i3V
z8|v7ytQ%6E6ZS?f9xez2w4>qXZNtH?vQq_`3Sv~!H4R^pK(>}77S!T2<3z9~mJUJ^
zW>tf0dYEtMWCPmq;Npz2Kj5u5zQ+FFJ!E#<a`w@hPc9tYkI#vHPmuWB%H+%Skq}bO
zBx7*P8TH{7TZcO|GJ~6$v|Dj+4y)+seZ?ITb5;Cg;$?GL3D$%HO6G|tCsQtuEh<A=
zx*X-SCg?V&f+_)n%e0${^P@TUe;l~?%K^s7Z0?!gm=TgdWf0BS7;$~ZiqN}5F6h{c
z8MFO5^E-dY%{y<?%{|S`(fOM5p(4EVh|SRr{7(+4+DFuEVFL6fa#X|D?TkJNsZ}=Z
zz-p8$+LA$uxfq~T-k@{CVpdaCxzLzI7_`SqL8L4t#qbiqDDwu)PGY%lnQbX535-Fq
zE9tQ*ZX9UFSc@8m?G+moe-?1_P&Dc*ndTWw{bogq*%+3}SlS@OA+qT*tC5LnB^WXh
zK~qm-J@ryq&Sxwt!>EQPj<^Px%{l8Tw4Sm3oo}-F+5z3c7V-8CcHfwBaM0i-;^IyE
zk8hK{{yli_eNx|1?aawxLzO*VJicmRyD7D_n{)Po@W^$XA1k~&V^LLXEet`GaY7uQ
z+t3b%B!ZZP=8R|&GR-C<CSyY^;7O;@IRZ5;Yr2COyMOp9v)hKP+YL8f+s9<X*_{i<
z`h<~lg1!W>L8o9^<ucnIMniwvlT9GinOFY(w^?remwfbL&+$hW48PcL_URd?+n$z$
zvo$V`v?gItDiNwFXBRb-nYX!8?<~zUQ{btbCdgUne4;;Z=#MM9`;PTlCZm`-Gusg)
z2@%M_U^g4gW}xz0q}Si&e6fwZ^%nM(ce&Y)tk!E*(Gf?7dGMH9n}LH$`J;dM_u2V_
zUE0U@ID7wy$3OXit>ee+x1R9of+0a4GhN7Zqmaa6jl&>>6iEn`LggH5uT(ZMC*ftl
zxs08lT{G3izAksTagi~Mn9(A^AU0rarmibQnV1IyF$pnGP0L=eW2Q<YK{~8&FfJj!
z)M*9UH$;S}o>7%PDQ!q>Mrebe6xTu|mj-RfWT*7O5VayFp<lOjkI(2XE;#&?-(&w<
z|1mqS-DbA`E&eq(xIcFEt254i^@yQApk9pF=-6z%$;E&8PdLBvH`qsyc%?f>S07=L
z$Ifq(j7R5+NeP=Bxvf|+5Qofa-!j}1`q@DAN>Yg9^Bb}u3#vmQ5Fo@XL}N<bXCRqG
zyH3ahgFG_Kzw;XNZ+@Nn&A^R!-ooB=bSZIuK5%+(#l^)1ZCK-+rHKvC)2jV)Tsth{
zJo9Rs&HHD(_rL!Q7jJKI^X*&6jV0UP-evENhMON}e))fX!pDE{LmsyqK8QQiZ`Ckc
zU{$D+!AoW?k-5#(QdIw$I`on9-%rS;1*bBi7^4J}=~o?Tm2h5JG=Z!ZV-w?8s3Zdw
z6&br(6WbLsZ^+;MJ@Omh;m5DM&NpYCTlY4khd&_eNIc6lADwZqzs+}F-Q(S_zs2tS
z4emYo6#d~(c=*A`oPY3u2Pc7M`7R+_+F(eg!g`ApkCEv%nlLdLgf<B$T_nZKj!!Hs
zEQ~L|*Mz9SWJ}g*BsyB`k!9=*x(jZ{W40}6VKF9`zKD9#0C8;@&V}(b!MehAmc~L-
zFhp$DNxW8wS`!j%QsB`b^a0kvkc`85iyC`Xe;JWNGcw91!D(mc`^eex87Ge)lX2{R
z_Zw{eqrb=2o3}ae`+V=y2zO8D{>6vH!;a$*mz>T$$K#BjUM%?N>wn5({svo*@1g(d
z&q((lQDq1I20?_>j93)YLp{&TI!DtOBnso>mM(1Yu3Y;NpKtWmSphL9i6L3qSh2~I
z9JYm)n&Dy3_*bXgeHhvKPww!I|MYFX@trMZH@8@I8%`gL9R1({r$0Mk{b8UQb}+OP
zVE2N7WUQx|EtuDH*8l1*pZxhl=C?fW{uh75xBlxt=4)@=Vzz(}&3o+Lf{(^T9Bc0V
zDB;$g&IFuB8m(A3IGDlS43f==7JgX9pe8+G0ZbzgR-R}sR2YU~r0qwd5&Vutvc-AO
zs8|C72?N-1Ah9M5Bk5~*FyHwO!&|TM<HwKaAKv4&pZ`k^e)cbT{OA8K$L#X@fBWC@
z#_#_FZoIb3*7hzNQ_<Z%V?LkJk~tz_*F}{^u_P>ZA}tuk$w4Dyjes~pR89i)PDnFP
zo;!RhJVC)u%|=_S>q)2@<euZqbeR3j&g(ObcW9NNPKdQ=@PttrPoVucFdijLa#(9f
zrXgwsN!XmQ0!}J|TH2_b51D&wN6JFXg?wf&MGrMXN@VZwwp>G-l-LVZ7B1G2mW<kt
z<^DErz4k6!-+lx2Lf8L_TmR3$<`@6d|H@JSknYY7=3DP@^mqRwK6>{b@bKn7HxGBn
z@AcgN<s3qXofeNvcZq^{TJrW9KNIT4k$PoyH{u_|%#=Q4d(F6acBTlIW>^iD<2LiS
zw~U$#>>rn$v>ok{(pQ!@Up2h)hULyTwvby3_)z)qFMiIC{^!4<`^g5Qo~D{n*K-=5
zpgVuDK(gN9n;AhPTdPcJ6S`j0{hNmje|knfT(H?za-~FHC^?!8X^gmgk+F~T<BCTt
z*l7}GJJak6t_q-`P)Sr!=cd4#;9RkY6tpHL#b?8L7B*55qDPGdF&N1p1<oA+G?CL-
zh&m}z@7LUTb%&c<w@C+ER6qEblRx|C#9#d-LSWm2`Q=|QKKy+)?|RJE4*kv@R<@ap
zpGP9l23I&}W~##wgfOvjGMe)hax`Yxq>^q}YY^}7t}l#$oY4fvl$x+yZ-f(AjUBE7
z77pf#$|P(MtWSi|FkWQZGv(sp!1{i`(cpG0v57ddn9S574zQ*K(kdzI1nb}?kf%6{
zTaz%VprM?9QXnA4F^rjzXY?v;k`%xv1-c;-QiHeyIs!SuayVhuzDG<O?tS`zdbMVJ
z_wVqvtvPQT-sE7{V$MGyE~<&|m%x@$OQV)Rp^;@L7;DI)Y*xzIrueu<$>fyK`uXGD
zUW;dZiiW;3oSnj>O-TnEtB^(-dKAN$g`_R5_OwCK2P^u!M~uJxnDp20(X1?v19smy
zU?FQv7<rzV$CsRtoha;chwCESIA&OO&sNBLkGQZ6XFHywdl%gM)e7evm1J&vVR0br
z4-M_b$S0k}IW1<+Ua7pGQ*S66ca_c=#zJs4maLv(G=!`iwT=y$);UBPoJiq}N$Jys
z>`5+?HG#(Bc^(6MTbA8dXY9OL(`h99DspefaVj;*SR{-LfBBbu`ak@SbZ1Z-=<a7W
z=aHHUL(SR@RF||Hz4Qbswj?EwvSi~BjZ=^rthJ~LT}oVZ14+SKx$6H|YYV2PfE172
zb@J4Mp*pv?Mqz-aF73`3GkvF=pDV|`r41G%4Q?!&ZeAfz3s2FoC<Am|QrcKF3@(8Y
zBU-3Ok^v76@bN(eV=Njc_wfk?%3^U?$Vx?G$82*Jlz(&4vp6cu>U1~p@aT-AxM8;#
zs&n(?jGcp;{Z|^cZ+Xs#nunh#t6Av;4S<@Fnbw%#=%uj6z0OE7fJFLeIg1vYrLP0V
z4BT+fXEt~eg2RZx28Vc$cbT~p_GiLkuV&fR96$5~gw@9@?*HNfqb*xwqW|=a*-_6M
z-Y_z9W?C-BHJdOnjxRy8A*RF_1EVDD!f^A>Az!N_RB-fHKj;0Qf6B)@bL8Q`=5FNn
ze4E*J%WKODvlG~)1@6qSb>>-krCwxQ6R|##bH=E{nz|r-QcyZ$G8i|pe=RX&PU{8z
zxFMtwk$@A6h$k6k%!(0<`bmFJBBMs;W6y4_yt7|(XW4Nc0+06&Xy1C1_kQ{pm_D$>
zoa7Jr`G+md%@t;~fyWp4lQr`pGee52oMCzyr)D2IF{mdaFJs9$;&R3sLv8HD+)jiz
zaC}}DL=Q8iqJ=yeb0|bkJcBmOf~7vUNbbq!3J&s^Ns?G4;iNS@>MJhp>D&MS3};D1
zK~y%Wumq|hGsZxb!j&nTYQ|_n#4>2HQK_z&=p~RcI{B}Hh`~~!IdG|*=$)q`QA=h<
z;5<9RF!JcEWpnqGRw|mKj>TEzz<2_MGBzLJ@J_|;{g$uq!ch-fvx>j23avH*DiKeO
z$qprx?T8B=Y{2+P!qH|68cXYBIbwMJJX^Fy_$Fh~%77TEM%bDe_P1cU*J3U@Y_-RB
z+{Ju+!3Y2Jr@a5Q6Bd=>Ry)!>ioE^mZN{z4$7aU;Y)L~+3U%qwzEF*%8LMFPK$w@F
zhb|WAagYAXhpghKWEu>fByjfHoc+TcYTL4_hRSR>uLY?_q8aHlu~wN1Z7C0w0cRai
z9inrHWrjVfW0MoDCLWE6lnRt<t;Jp1JE}|%CDFvP!gjtvM$5^}^9SQVZXYs^J21Aa
z7XxQ^USs#2|B9tuvHR98>EKQJ?IrIYo%2aMXYX{wJ9k&?=fsMhrt;)G@vE;0p-<gF
z1sfwGt~5dw>|_O!)Uj4eFgoR))5@AMPneK~z=(Ju#ejPhU}eEO1`;kuM&r3ihV#L&
zj+V8DtRp^VeDbWGn%DXKke!IdKgF@peCaJ@%h@EzI)HeFV6e`Bj%XTL)C+RkkximG
z8Tio$r`+$(*fYXA0=wUPhx)bu9{<;OxqISSf9Jd8e4DyoA?_Ui_?Rp`E}yYx&K^*W
zk<(^mj$xiMtuZt%VvHqaLmWMt96<!>Ey)V&`uR=KI(Y(-Q8PofBs^jx-UsGQW;Z7`
z+e?;><?PX#ho6A{Y-GVt2&_=%G;hq|c0;Hm?m{sEv@*=vm%#qE*5a(k**QT2$D`88
zNR=Wo6LvR3<p<8xv$2JmpT$94W4uB%BvoRnX=7nEs|a&nip|nXGAP4D@z2GD+hnq2
z+9A`85%M^pd?h7OF;`4*fL<yj7<@3;vB6OhbH(|`_pv|z1#~OAe#X%w$H~{ePy65e
zF*n~3UcY774qMzl%eY6U#Gl@UPwvt@dO#c$F*gZgdSY~?&z=m;<RYubv(2L8`25>F
z>Ln1NxF|>z2CFm_=fF`Cn+z98>5?$!;#!v|mQznl8vJ_iQqd}X34}IJLx`7c+yvf`
zUB#d^=KeWb^-qvZ%dOXM@y2b>>u-LaUGp72`6rf--@o9aG$$_>Eba#C<DYWz;6BH{
z`W4+tKv<N)P%6+GqcxfWIAt6`twBXexsXkX%BnBqr{kyC?ay5BDI%c};UXyQkjOD(
zvf!j*Pe*)!p&yxd!qyP6jO<CEA%Kr;QlcA_E*km(DJ2r=iShJ{j+(18%+idE;iL^*
zguu43+`P5LEh4zcao6BFrH=;PlvG4TurV`>hS3NyTDlQdSn6@2$xk$x<eCBnGif+u
z$>JCj1RT+n-;zshk|*oK%eN*vu<FWX%?os1HSplaKjZx3h?AQ$j&6L9_iuie<2&Ew
zmHk`1`IhCo2Q6E@5YIm5%|HJM?VtZ&grB~T8CouK%doW%O-=KKlFE9e8St!^_-ZD|
zUh_0;g=i*Iu`$J2dxe&{An|3OPK413(b<UzBUdwHU!+NK8R(-tzo|H;!jd;ki`&H7
zz*p#On|*(a@ozq&{_!tyuOITpfBp~o#=C!y*T4M-ESFp46ZrYwF&`ea+<&}A|IJ<Q
zef*c$i+kLEe9G$K1<B3mtR>r0dxaDkW2Ey+<Lfd3Y!cZSNJ3OYXO)m)(_W)eWIT3S
zSceE*3^*y~+M}`bKC?+e>tUQjb)#axnsaBdWNGJ|w3c&YINu0iG)OFCC5;G;^DiDq
zBe04Co%UFh(WsaKYz^af19Qdufvvvc;xv<bOCO<4hE>drIpdsR-}D5No{%lo6o&JJ
zfaT!JSTWOp83tp7IvX5@xpjr*V7Z!neEMb8&?3fTd`-VQ$63Xsj?G{F5dFbGC&EX6
z()0d5{u;x#zs{{@j#QRmVHlUf!NZZw-4A&0pZ`<#^9FCW*?apNv_mF$8L?kZ7w_3p
zQefTlcZ4x_Pv(dw!s%t~>a<(<LS8^7F+~w`HG*yRIwjI;Y7AH7iCB%OCbIDb^r@E6
zM2<|4e{{@VdrW$-X8Y4a>Wi<_<hNPaIkP!z?cKnio-jN(;pm4y<NW{lUpVYOMG$Vk
z`A5j%9#X+z4Nirv2))hpGmB{pimMc-5;YD{Q)csWy53mSmXUdb;xy41sGTy;iu8e2
zpp8X?F@#d|+FEdp;tWvNT&$J*Yax%8If>|sgL{rI!Le^0htuP3wfCbcv0FFnYt3%3
zq-42pLMGyD;5-Ia$<tvl+3_ej#t_h~3<h4=izF42II@~zd#PnhwxUE81Y4#uu~+Qp
zVk%%TliKC8G%!?^+9*l}4<i;|S^SuIc(P)M1IK`Vc*Ne%e?^|vG_2V8hLf{_YBU_Z
z{~^Qi5esQq&=G9F`dw}|OSX1A7xBe3C$hOlK;zQ6P%IfGUYd4XjYha>{5#_&X|jS0
zxM|?xI@|Z>|NS84n><ApD@!IDe?@+MRUEoWtlNR(ek6bTfYnELd9?pN?beF-JE47i
z#?D6@^wS5p;|Hv}BNk-#w<@-(o@Uz<D`-Qc&M-@vAw|MGGMg1C07NGMBwxu+s~WD;
z%8e3B17Dwzc5P8QU=-zioUsZ@KWZ7iw3(o=4w+Gub>A^|4h=JUHC*JtX;|^A;ewC*
z^@|76Q5yEEEP7X0yyCa{eZS9+S>mLokA~PPwa(~rgkUi-Giv4{3CUaLUYS>xMctPb
zP7+BWXRZvPtSH9xDCslq*q5t$k>2{OBe^~`$fl|UaS$_}0Zp04R+zbk+xwiKpVO}A
zG-GD>qhFBi1Kh&{9=<mxHcB;GRwqZSfAKNK&uJ{Y`RYDfyEWDuV!L7KUyQw;uMrv4
z945h&c(u!1Ns)*xLw!=xucstU%D+-mT+N^Nu-)^E^&v;RW~|0({>v6I6H`*Wtionb
zxajBfgEF3Uq@RAo`T2mWEM1;cou2c`$w<0?L9@AwxFuVXxluK2Erj{f5=<rp@EBY&
zg@Ne}CKLqZa-z6A>IhmUbgxtLLDJ+}S27vvl#qpf$aKB%FlO3O8M3*WLOajOI9g1u
zX*xrtj)nJ}gn_?lPx)Xt;huJHooRgk`L*S5c-)xHe)#?Q-XDM8?{m{F87<@-ndgj=
znnWa|kueG;J8F|S+)@sA4R6luR1`j~>0Fd@5J9#3jCjT6`0!;Q<ruDJbuK3o3QK$v
z$S^fA4b;{kAyAu!Y#gV3;;8GmcOK}vJ(LmQguE&Eg%HRHVKyUbW^aGV;g;cR+lC#N
zsj?zj7~Pi}mH)hK)m5se{+dbTXJ}m;xdKznQ|q3JUM)CMsAN~{=r5AZQpRg`OpDcg
zl~(78`eY>G$ec>id2f5i{f9lrk4JJcjNu$-B6Y4A$jH26tSwc&U~W9O7Ma`InWa&h
zSxrtuX-M0OtVMX#O%$igKq$f`mo6e^A_rd+M<#)KGz-=!#%7|zd1pCq;g_9Z=p(Ad
zT}27R>E3EC{76t%jJ(&a_~F?jejYErRE)UaG?0$F?(aNKP9N5mt{ONK7(-$ag<fX3
zsz>ceNQM*|Y);%TBe$E#2cyAgQLikwOA+gcl-16NkS1n0#y;73F0EX0#!TF>oHNRk
zEj*#reV}s@Ss2J8E_veU>Fk0>{m3VFP1u~{#|JE?)w^d#U?h^Lx{ARpSZ2rVRB`X<
zl*2h}7#Wsx=4<^@!Sh9dB-gkpBrdfYrWqu287z4kSeq(Hu?1+EUO1D>XR^7@%=-C{
zI~A3YtG`q9elk`AmXRvfoRT=ka;n0~*kKhq9^t)W2f?E($4uYCfMa+29X=Fc?k_mB
zkvbNiB8LIr&`#XLDrLsWuT|8R#Y0ljqR_HfK3x+(`vNm)#sAmdy{kqH15p_Mr5Rhs
zq)L<bf4C3=Da?|M6<L=pWXwW}CA&q6%=ZXVA?bk5v<kw8%0_O&5(k#E@ES+9uWwX@
zdFt=+R129Nm5=I~TBNy^_wCF={6)jn9bUrRo@8Y5iZ(|pbx+UAQK3|?KBVd35%D|^
zw-(~T-n*(lCRNm0k5Y`!HTO8Pl%tmF_*qFKqo{L)K?tJ~R8i?|K>ZXb{AX$J#48z6
zs-%?2CHL$29*0~<(c%SFMO6_I=HUNy|3Bi5H<s@+Xp?KKW#cWLY`U>A#u#IaF~;2C
Y0-2COfY$1;GXMYp07*qoM6N<$g5oy1@c;k-

diff --git a/circulardevice.png b/circulardevice.png
deleted file mode 100644
index 1b0f339645c31904dd5b1baf69749c156f1ea9bd..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1234
zcmV;@1TFiCP)<h;3K|Lk000e1NJLTq002M$002M`1^@s6`uVM$0004lX+uL$Nkc;*
zaB^>EX>4Tx04R}tkv&MmKpe$i(@LdO9PA+KkfAzR5G~@URVYG*P%E_RU~>J0CJjl7
zi=*ILaPVWX>fqw6tAnc`2!4P#Iyou2NQwVT3N2zhIPS;0dyl(!fY7Wm)eKAks%9DK
zWJ1j5R>j~eLKsE>aR@Rq^*KpO!E=1w!^hXV7|-%P_vh%#7fc5DMB-Vd8y4{f@${yp
zbKWP8u(F&dJ|`YG=z_$LTvuFv<6LrB;F%F4lb$Dz5R0WQR=Sv#4V5@f9L=j5<qKJt
z^PIOhtJOMd-;=*ET+mjQxlVHgNi1Rs5=1Ddqk<|d#Aww>F_EVIgol5~@k``V$W;L&
z#{z0lAv=EXKlt6PS)7`5lfnt0=f$=^MuFfi&}!KB_pxoaP5}QiaHVzpwI(q0NqVEB
zMUQ~~ZQ$a%qbYm9<qk0Tq|1ivNPe0^u?W1M(KqFQfm<N7=JwX!$LRx*p{`Olz`-Ff
zR-){6k9YTW_xA6Zc7H!y`f{EIqdUz2000JJOGiWiTL3cvTWl1T5C8xG32;bRa{vG?
zBLDy{BLR4&KXw2B00(qQO+^Rh3L6AAE|a3JW&i*J&`Cr=RCwC$ow07hFc5}gE2`+g
z)Y2U>RDA)|g_Sp{P&Xc>TZQ^2tSl8TP<24;rCSG3hti=%LJ=Wxa<=cz|Gy%kg#Yt@
zXUD-NQ>Kg0&aCse-~0Oh@9W)U_iT)o-^;+@v;i?NJZ&Hhj7}R2qt*Dqq(AR}(0$)(
zwjQr<^nqZc8a|lx=fkhlpKZ22@1S?tc|Qfna`ZNm2ZZ5n{5hk`6a#?r<Y)#)C=iSW
z!#M-M9SEz*cnKOzhKsuepI*ttGTx`*oD+a58K@G$YBD~hWS~j}3**xU!TP@;7$34%
z@D4y-;$VDO5Sk`|h4E>FVCgOp#!D;>d93+oD79U~r+%goN(bMnri(^f<gaGy@v<ww
zIip@bC<CD}09=gsZMYO5sz4|Mz-B@f+j!Rz$W=zl$me1>_hfKQ0-Hfe%X07brHy><
zrJ?9^?F0xN{ZfsO4T5XwK?y(!K;)-f5^|T??{}lck-D14+-AGG<<kpPCV<qX(9~7e
zH#Q}}*S>p>C63d5q6tJ32mt^H06+i$0ss&IU_Nh6WqytXfOr6q$^wlx)%7hu>=3DX
zCeXVKbK$+|Uqrq>=>l)~FkJjce~@2tm95Wye()V7040E@?x#AM!lRKd8-Q4mEER-U
z#xGx%BNv}+u_hoCb*t!eF6F|DNx-d1<R0~9YW!vpmuQX+0vF?}qQ5NR^GvuxCxg_H
zPM!c<o3!G-Me4VMuYN+Uh|o5D&M${b1;O{mRW1OuHNN&V5VHdv-G1wJ0Pf9LDsr9Y
zlL1hdD1g8_@>?eWK+s`4c?kdryrZ5R09WDwf*<4CHtDSs03gUTzV<qRtD64N1l2l%
zly!in5l=lWC+`88USKN8z{PlP2@pFOxFrBL!=nMv7KFNB!~%e-Ygc<{ly4x4!m)8e
w0Pqb0SK;8uM8Lq&v55hJ!=sf0qV4hcFEAdL1>2ts`~Uy|07*qoM6N<$f|O!6tN;K2

diff --git a/co2.png b/co2.png
deleted file mode 100644
index a9a48aaf3c48d221fe2ed8819183783a141a1057..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5408
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
KMNUMnLSTZ5L3sH9

diff --git a/coloredside.png b/coloredside.png
deleted file mode 100644
index 7628956a9bf43b2b237e433eb7f7ee2ac6446212..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 699
zcmV;s0!00ZP)<h;3K|Lk000e1NJLTq001BW001Bm1^@s6BkHEN0004lX+uL$Nkc;*
zaB^>EX>4Tx04R}tkv&MmKpe$i(@LdO9PA+KkfAzR5G~@URVYG*P%E_RU~>J0CJjl7
zi=*ILaPVWX>fqw6tAnc`2!4P#Iyou2NQwVT3N2zhIPS;0dyl(!fY7Wm)eKAks%9DK
zWJ1j5R>j~eLKsE>aR@Rq^*KpO!E=1w!^hXV7|-%P_vh%#7fc5DMB-Vd8y4{f@${yp
zbKWP8u(F&dJ|`YG=z_$LTvuFv<6LrB;F%F4lb$Dz5R0WQR=Sv#4V5@f9L=j5<qKJt
z^PIOhtJOMd-;=*ET+mjQxlVHgNi1Rs5=1Ddqk<|d#Aww>F_EVIgol5~@k``V$W;L&
z#{z0lAv=EXKlt6PS)7`5lfnt0=f$=^MuFfi&}!KB_pxoaP5}QiaHVzpwI(q0NqVEB
zMUQ~~ZQ$a%qbYm9<qk0Tq|1ivNPe0^u?W1M(KqFQfm<N7=JwX!$LRx*p{`Olz`-Ff
zR-){6k9YTW_xA6Zc7H!y`f{EIqdUz2000JJOGiWiTL3cvTWl1T5C8xG32;bRa{vG?
zBLDy{BLR4&KXw2B00(qQO+^Rh3L6AC38*VJg8%>kxk*GpRA}Dqn6VK6AqWKJ$7Zx0
zZPR)z$4`um<X;el3k{sv<8VOdOeT|N!L48+g%nb2*Ba2e#`BnCj(Pqbe=6uId2PU>
z9<AWp6R-<-djh0@vl}1{oXr5K;N%8K2PZS&6!7H+oCbc(B=}dg)KUuo*)AZh^3X-T
z4N3vW0*f7mxxqgtU{~c=0bi2<H3m>s9^C@m(WeHt7LaNHSLM-@AojEIngq;#FIx)`
h&+PUHngM12iC(2!it&?poYVjS002ovPDHLkV1nH&F~tA?

diff --git a/config.hpp b/config.hpp
deleted file mode 100644
index 807bae4..0000000
--- a/config.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-// 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
deleted file mode 100644
index 0da8e6a..0000000
--- a/data.lua
+++ /dev/null
@@ -1,33 +0,0 @@
-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/dependentClasses.zip b/dependentClasses.zip
deleted file mode 100644
index 207b66d6b7f2c7de8a42cc97d22b16a3effb9890..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1290
zcmWIWW@Zs#-~d9y6pv5_D7XrwIT#ceauYN2^pXn-LPK~N*z>nICfk>pC4=bF3T_5Q
zmKV$n3}7Po+!^n4n!cW)0iS$zE}RZ{6x7De@<b(UnONhI9Y&wMM2dusKbx3{uG(qQ
zs3rO-=yc;0Q*m_{(GLDZ##V)*Dpsy-Tv-uEyo0*EO-vMPR><z`G&m~YENEnKG-Fli
z+X=pmx7!3(u`&dBvvchDqnw-pbRWo#0dUs~A-UcOD8mkPy>DUx-0`MBNBeAYOa{?}
z9REn`^m(5^hN3lVyuc1xy;G!N!2%8A^(wy3CzVar)#X)WCof-;c{cR)QHYzkDjqV~
z18oJ_jBry%G9p9^fHJI5H)Vi>^DEFbAwVpK#YK7=UOwl2Lr$Fc_Inxx3)>BvdY&iG
zTtB_x@guKuo;rGA949>2_~>qGE36gfUIlieiKe>oO|CO+j2%{MnX-3yMAoHsIeBIk
zcD5}u4PR>t4!<Ki)~iMWT?29v!mR>G;pYvM;R3ofASbahwFn-B20(`f038gXaRwn5
z*iDy!NdOXx4IkFx48>JSYW|*=XRV&r%?)<hD-OPIpb!Mvk8oKgQYhvFWkBf?>M}?`
zeh0cK9Ef?axQn=e{NSszp=~2`k&t$9H(Ee0uv!~4A!>#Lwvar#c5+}8&_y6u1$Z+u
zi7+E_5^^d9xflkvG=f;f<||}VK`9(Loq<v~3~XuK2V@eN-jNLjB~j!A0ZO7Uu%$7G
z5n?F81dD7WC?z4sBq$}pz?Q~;KqHAySIFjq(gAXaqlW4XCb+o-Q$>I`D;vl~tU$O1
M=pGMXF~-0E0Ln&V4*&oF

diff --git a/diff b/diff
deleted file mode 100644
index 68dbe45..0000000
--- a/diff
+++ /dev/null
@@ -1,14 +0,0 @@
-1114d1113
-< 		void SetFPSDisplay(bool display);
-1176,1177c1175
-< 		int			nFrameCount = 0;	
-< 		bool		showFPS = true;
----
-> 		int			nFrameCount = 0;		
-3203,3204d3200
-< 	void PixelGameEngine::SetFPSDisplay(bool display)
-< 	{ showFPS=display; }
-3543c3539
-< 			std::string sTitle = "OneLoneCoder.com - Pixel Game Engine - " + sAppName + ((showFPS)?" - FPS: " + std::to_string(nFrameCount):"");
----
-> 			std::string sTitle = "OneLoneCoder.com - Pixel Game Engine - " + sAppName + " - FPS: " + std::to_string(nFrameCount);
diff --git a/dirtblock.png b/dirtblock.png
deleted file mode 100644
index af8bd9194d19cb226b0ebc392c2a80044008ad90..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

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

diff --git a/forward.hpp b/forward.hpp
deleted file mode 100644
index 14bbfc8..0000000
--- a/forward.hpp
+++ /dev/null
@@ -1,1321 +0,0 @@
-// 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/grass.png b/grass.png
deleted file mode 100644
index 32120250f6d77c8324566839524ae6688796d11e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 541
zcmV+&0^<FNP)<h;3K|Lk000e1NJLTq000310006I1^@s6$q{N~0004mX+uL$Nkc;*
zaB^>EX>4Tx04R}tkv&MmKpe$iQ;Q!|1nnTwAw%tCK~%(1t5Adrp;l<s!Q|2}Xws0R
zxHt-~1qVMCs}3&Cx;nTDg5U>;qmz@Oi<J1kq|hSPgX4a@yZ5+z2MF~t)2yy>K+|nA
zm57U(?5f!Pie7{fKoo;Avy3@ON}}WVx`&UicQKyT`P`qQU(Hzz@QK8;%rI@@4dUrd
z+u*!U9AZUTB|aw}GwFiFk6c$ge&bwlS>Tx=Go6|z4iSrmHdfl06-|wJia4TbI^_!)
zk5$fFoV9Y5HSft^7|iJ_%Uq`!Mgogif&>u?swklh8!=jSQY@rsKi<JV;`$|WDdZ}F
zkz)ZBXpmh$_#gc4*2+&#cuB!H5O{H%k5Qm|7iiQR=lj@k8Yh7N8MxA0{z@H~`6Rv8
z(jrH|z&3Dk-O`jj;Bp5TellcJb|pVeA)g1{&*+=7z|bwwx90WM+{ftykfyGZH^9Lm
z5G_#ldWU!SwD<P!nPz`KWLI*bGU)MG00006VoOIv01g1X004{iXk7pR010qNS#tmY
zE+YT{E+YYWr9XB6000McNliru<_R1HEg!J|O_%@x02)a|K~xCWW8gE`C&s|=|3A}D
fpJiqY3=9kaG$92vaTdrk00000NkvXXu0mjf!#m?Y

diff --git a/hills.png b/hills.png
deleted file mode 100644
index 1101b9f6915377cfd866fcb2cb97c7704b64f39c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 21821
zcmYhi1zeNe`#+9~3L@%gk&y0E2GU4}fQ*y@Ly#PybPW_y>Cq)2ougz!YKT%wj2MhY
zsR3gkj?Vv{=ktAjum5>%_r0CC?{ltmoh#nwI?+!JwP|m#-k_kMpw-pU08vm-ekK3@
zLv@XOT@7auB;TlC>OAwIprE1u=X;4FJBNjwdEY??WI#a?%tt}-`Yi>;(FOUwMnM6h
zqPWCpNkJi>K|#Ung|p&Jq@XbUuB-9bG;n$|S0sR^f3&pUik9*!EiLW6{a#kj!1u71
zXo!r;a~WyrdymPfGr}JDDR;|Pe*11vMJ4{3J|TygzLA`k5!J-aoga3F4>yAMI%Fw7
z;(%{lD3iM&DSEMean8wliQFr4zarj>huszB<ox#^`SN<)`xEtlf9(2CqYj52B;EQi
zM`5+&9CtBHC1Rh4msmlgHD4=n+@9Iic}MwwO<w;FQsjs=Ukb}E{X!-Aj;=H6+Lix`
z3SN#khbwaIv)UyHN?skY`|mB1H}ecQ%3SqgDaH!K{~^}D$(N5eR46R)mSomZGK!uJ
zt{o})Uy+Me^`DYQl%wpqg0D7r0!5EMX#ZD4fy~4QMUQ;m{aT~`gW3aNPxbu2qNi_z
z^31gCN4MK9TYCCV_IhQk8zCh3{znILC6}Rs)lS+=w1Aucwa6~u?!F}jp`-l&WqFsw
zF6*<dEFS(>iGosBY{pFVwXSBg@uUAoM*C>S&V=5j-S2#MB~;+vrTTI^<^Ni|ra_(*
z{aD(G8m%J}kR9GzU0yS)Q+FE>FZln4ct^AGn&rE~qyO5}IarTCgxIXCUGxn3|I7R;
z-5m{)Y8m75eT|*A6$gmyKPrBF`G2KfZ#>4_(c=EAzoSWEvX~|miWGkd|CdewDThW3
zUh1APF}-)p@D*#A(9X%?O6I(OQytT4kgat6`_~+oOhfeCG_DhW6{Ki$nl4`Egn!sj
zrD3P~zl!GH)SN!D^)Bu73ot`(EbF*@yQlWw?A`pXh>11OKk92x|K4{W>)AX#&b6Y7
zDEi8VFS+u66j!xSyE<*6DM|Sm<6r)_^)0a<$=xYPb^ZSy4|U4Jck_j1wP;sU?FT9{
zxfS-tzLxXwOH{NRkc!lhG&TOeiZ1Vs4sZOX_m2yoLCzaz2d$l)!KayP{WGf1?)_8c
zHSiDQf)MUPN%5M|ZsOqQxG;9RF_$*~$>V`LKIyL6dHa*|>8LwPU`k7x-_);Y{_n9`
z-Hhvu^nNeK6n7Vl3D5@QZ|*=*!oqDaPhRJ$pHbUm|1p+o>Qi2jXC!EGJH5Sek34SQ
zPpQN}74O>*)Lx<B+^>vo8ol;+7|LwB8~*R3>!>*ekmshl^2<X<?xeBx;!*WIXF7!3
z5%=FGXB&yZpK=laK5aSMRdWox7>yS!uOD&7oZ4qyVe$H3bFFk$_L}=zRt~$bggsdv
ziHZ-FY9*$L(Cj=7yfSxhq)jNt`}ID}b@EdGC-FGY<WNV8H)nsiJMw}D^k+&h5tBUj
zzC@7g2|MBbaCEYS>W0(HpO;!BxZ`C1ZNW0<C8ght-G?h*gy7c``ga9Jho-dTk$DED
zH<qd5o<eWhVahKj)<plj(|PCHzfJ5|+_t}D7CnnI1-Ek>s*GlcZ|I4n{d&6eyoV!2
zQ1bPlsPO6+hs}Q{Ue(9+%wBA6hyEk_H@%%GIw5Uroq;H^vUVS-srbC`v~yBNQg?2x
zE}bc^-IcqC;srB&@>Th_5Z%~+Wz1{9X@)h(_g(7tbY$J+!VG2mh)%mQ<Q{g||JFCz
zkF&b=VQ<T?4u>t$Wm^L}|JOSP6@lYcDf!4obAS&FmCK;L!(}pK3A@+{4AhjY5Uk?_
zuXP2Rg{R;$oVDasc{2ze)CP}ge*E~}B-oH&D`C_qLqW00xM@Q1T0Td@CvB<pQ1$LP
zh;F(*0}j;u)&x?X8Iv{`+w(W_$S-N6wa!i$4dI>M(;m1&qJFa4U21I_+gC#%qEC;H
zVm{OU`h6Dq>IOuOdy+YIxHO@Y<toK%B|s%3Sxh<>AB%_&@@Uai1f6GwON=YlG|l`y
z4Y09NK7B}n8j)Xu@82WcCMinP8+(@ktm%3)OCzZy7pS!-C&mI`_<lyf&985S!m^h1
z&bD^~b5?_x*sI*0KZ4Y_6*}hpD;QKCcx~g$8&xglDnLmqzVdQse7JhQf@<E;^|R1t
zVHd|ozU^~pWG87|dQPQA|Lg*nk%8HETg=$LI`{w<WjD6lG+{+_k^Sgp_028jm&x^;
zs_6$L$5+u1EvXPfB#UrV{#&~LF$INveKe&0nY(<2U->{suAx9x6aztFWrL%4=~b`_
zB>e=Iw{>vT-!UgvXkB<%Vp%E_R&*))Bzg7e^xcW&&4*$Xhwo}LgH*Xat~~yCAyWjO
z9Mf@I{;YR^@qty<egXx#-1Al%_U7j?<~voWF9JWf_UyF+tYPtFL3jTxU8i-DJs<u5
z#IEWMK6%aRg+;ngp~}Wvz;ZfizJm%hG{z1SeTjA(-@hA%4#e2-C<vAy?2n$GORg>!
z-$)!^+bzhw;tSZ!4-eaJm>(wkLrPt<ZPDARjnVsoRM?8??~8X7-aDX*{Z>X=&uiei
zq(kiH6^hq`wcQMz*C|eg0KOOK7o?iW?QX1=#iCiIQ?fU0#Q@1cJ~u&*cn@|Vb--W3
zSK>Zfelf$<W1QyZyVg&BN$R1W{4<(tiLnKu(Q`siz&Dotch{<-MR&En%5r5rrTL$N
z;yuktWxl9KgPwGm5WaGm+|lbaUtJ}h<t(eOVy#7*F_}7&bI!S?KQ;gOs9gg4CmtM-
z3d2$Im)5>zL_1`}B%@Tnuw>Fb*DVzP<dOWBIRBIWUse4Y<gHQ1(JR`G&mSZ$^?N2N
zyDwV&Xx>95Qk8nMe-GGP+IhsjD^aYRX=Q9Tdi1$|A?41u)X8FHGGB7OTg=wBIC@uW
zcTcRR_wej=<-8Fi4bVkZz2jjxW0b$f{XY$%1NzKw8S_4w4q+N>Bej5xwsYFe&<l~S
zmEso`UuEUH+KF{Id#O}BnW&5l2pOkJp?Vk^5&{7c-e#$#h;;bp;mN#fR^jE_Y|Uiz
zL&+`oXbaG`8sxvV8PGa6ekQv5)%b$&gU`0KlMu5mx6~1SHtRbl1cTb`wek6knI!O)
zoc=RbRRxr-J_{<o_;%rma>0_`v98p?9r*=LNEk}%O?$pX=K$x5{!lKoyW&K8?<QoB
zz$tf|7kk)FvwZUHw|(qsM@N1JSphy1ydV-`Bk;46gIWO}uEQCw1c-b_vnuvZr+CJ;
zg7rr3uOr`^F?Oq7sfQ(7>K(Nzz^+2gx=qcUu-2<QuhG8y5&kgpiV%yj^GYw*f+d$f
z`&92cU`VgI^N+~XQauRrY&!9kXZKTR>s!6vx3^$Vnarlb@8|QC1u)>xUSn67YS0ym
zTRomvR4ENIKR;K}|Ne^lxl#nX^<$+~<Z0qdZ@$>p5=CtCQt#~2PT(m68cmBjApIqG
zxNNddLSLI&oKD7Azn}_vptAzxjaX;bX71R1yhz`9em*#Tlw8zl-&N}c+c#=iH`#j8
z3<PYFrG@p4FOgJE3C#J^p6B47EZUU+kd);E(E0UOna~`Di-lbyds&LOog|P(U8+x4
zlwCmxRkWQ<$6(WUN4Keu^LJHHB$cyc%!RFW?$@@pOb<Q>Beo?=oO@j|JIC&JM_bz?
z<|}+RDySsEscBpqq2f&Si#Tb6AvOP+MlBmkA2Hk2iKeo#A4dwG^D>W{Qd;Zs{EU66
zZOQWc_~>}iGIVSR@X(b5-s>u2A4^moJg=Uv+pA%dTVey;w1X87h?c27o-jQ>JMgF<
zd|2Uli-KZ5fl$)nF@OHYBhwkz<{x0_(Z9C@lBRHNFVOh@=PKavw0txqTF8;H^>eWZ
zd&4`bQixAq`e^~ga`0CDb@#$V4#0}led&m|N6)^>Jx#I`j?nM$gf%>@J$QDKC-nZG
z<<vpwm7gx^EY+p2P#dwu!J`^2#B!yFn{&PL?fD1AG}tPz+7>%%z<GR7&4Z)fC%eER
zrAu}lUm|NUN5-*RS~ssy{8^GX_^U)(@|8E>{P>zHvh!)`i(;$>GsYdAdRJ#jk9c#g
zcAKrfo1ncr18T@p=J{&xDJZM<q90(lu>gTUI*KW?X(G{*hcQEBonj--OjyXz1=x_9
z!i|Dr&oj>%25{FcHl+0aFk)J*y%wfzqV1w_2hs+wf)-<dRCZo~*7Tl)b*7Z8F1e`7
zS1g$kJYWAIqHY${9jSDQ;@52y`-;b1Uerxy;)0A+#|E&V3GKA3_1g6tURLEvMDkiK
z!v%Wx3tE0%$~6N8HN8MIc^I-EWV$@azumMiSf^h8uvo?u@sVW&fNQp`HQW&?H4(I4
zv@kPPoBK{Q53LT$iw$`D#o8-Bf4G^>64X@-{In60W*zX82@P^+*;T~%`(;s3-2A6g
z#z_#lnaB?9wx<*nlQd)rC9@+kAuh`{JdUY#vT>P+tA%O8tivq(mG6MRx0P<)0b7Wy
zu#Sfl9K<GWOT(1UOoF|TVJ1t>Mk&UWkcP}N)+mF{n2J|qi?o!mCr>usz5F^$*S8IY
z&{vmM0iV<=;Fzrzdt+-a*`(c{@I-tnHK{-RgGQ|iF8Ct(#@+8HN8AtW+{D?YNqXXo
z+k~Qeg=C##p7(!o4z)s&S%sC%Cjx3W?I409RoJI|jQ1#%-S^>COt7UgSjkRMWL!CI
z$CCwB`p4$D1Sh?Aw7DR_9S-Qi!T$nfE=HE#G7%YA@13p8*wmx;f0K1FNDu;NcnA|Q
zp;X8<w2{tXYjtG+6SO_J?8L4)y6F^#|86sokdVmVL!!0c=k8wZ5eXIAB8hT8brd!K
zG0Wb44#Q{R<pjf~uEmS*u5;tIAu1hb9$lB#Efw2h-$MUN06KTkVo4FR+zkWcw>DX*
z>o|G4Y9&ZNdv9SHMO8zd{1#g2{<I4`t(Ur(_%UaqB$9u~_tpN<wmPb8ce;VE#%gZ$
z@<L-Y3oFSU?R&j<(jom=eN_q@URBR<Z;yXHV=A-<YnREvrqx!SuBKr)X*WPYingjW
zu@=t|+z|<g_(2S%16pozRwUNrUZSn(1r}PxBSYz1+{5)t%qr(TUx?|xWY+%7*>dcr
z_bPbr468f3e-8)L6{T#?XQyz-Jmx}N{iIa-hr!|Yc-u7`lBL4dV5~(;3z_12@*y<F
zct&cRdC*3d?aVc+R45h1@|V4`kpQf7eO7oo+ZRT*rTEI)9`~s{xUkW?pG<X)YFr3v
z^OJx1VjcL?`X0pu+7O&w{)4M*2Q0hB#6+3GfkfLU-s!Ma0jZktPO{zkPPSd1ojqpm
zbTc;5F^<iiH_W?Qxbck$rYi37xD9v$lQg)5de?a9IK;QTjlaru^Al|i`!zBD5fI@N
zZDk=2wrxc_dJsM6%^zH4_B#3E4*t*~70FV{+)_*68R}P5iC8S)N({=cC>qQdEk_6C
zWmxX?KTuYC1V7miv&Cw=A>ctZhz)N28Hs`x+oD+uFMxX=RUOCes-9-grWxOM+m16L
z|5JC{Wav9W5G*Lm7Ghg^q8NTdv7lSBjEEDD;1gwqFrl$?^4>FnB0?ikb`&#Q=BIk`
z!N{HSFx!D|y%hJg^^*1yKj-*tO_IDcDNPPev;(u4ZGJ^HLq4Bp9M2zg^iG|>!JmpH
z3$0|W*r5;WG$&J!W5SEj9FS>a=5ObygC8>&W+5zl8=@GZv>f+fVa<W9N(r%lPbbE<
z#%}?&U)7<1Bmz9;Sn$JPjX*`)?h57;ZORr3Q>*!$qV0RJ7b1YoKt+D$gt*^FzTOj5
zG>qRZ7A=U!_N#jpga<_(-rlt(>gKS^F{U0uW5Z90^v~~$%6T}5&niJly6~pSLD6#B
zYjt74SVuVyIK=<r7@xl|z(c_(<>ocTcCvZ=7}!NWIC0B1qkerv+E4t3S94x59vd^0
z&pe+GTr75LI6K*%v1e*(8t+PL0FV2H*WQLbam8qQ)Hofd-NlT`aOCY0+M5vg#^M*(
z;%hE7{xz{Va5&aN#I9744k~F%7iw#wtGO?`^Q!G-sD=02h;F@QPVw2PBu2T;zui?$
z6rQ#n>-+OA<3rxg%*j!#U8YqLG*$7HpBNvq$D51prd{qSxd$M9^2C(GLP7+DZ+@~K
z)=5~F+U)68G#?N+2v(P<+tZN@5v%Xm&nGBbH8!7|8>WW@2W}lC4a>mSd{!qX_y{o=
z8JTx)hg$%8A7xEAJUkf2%=JzikhO_k$R}eAPlBZ13b=<o+1Trff&l$J8gq-fgWTBq
z<F1X3afcj+2lHAI1(8p|73YUV-3GPK1^Uv#B^zF-;y;>ix=&I3dX%m6o{*XmB%!Dl
z)8(%9RDn)ZAf^v#Ru}B4Jda@>QQS$|*wAffyh}t=s3y?;t}3N1jJ4Zf+q_Q=){13{
z*}}^enpDTLg={YE9&+EGy{92QRYR<Dk&2~K<-?HznvRb?+wJB17H9)GS9y}5!9hXi
zzA=2qCGDJP+md%<%8#5rEBMpNm~ae+J)d%ao{jI_{rmTHN=x=lgM<_jfvZTM{z?VY
zp4k~|&*RsEm27%K{?3+oL}AaDPYnC}8bBX^qCy;L6b8pR^KHW~1cY~y#jp5SE63Go
zb0u~Yt$QWIGg<==yM!|+R)f(_#}34ImbF0t*15L;T`7Pc=nRO2cgNT{6@=hEV=rtj
zT7~F1;M#<lR4f6$P5{xvM6`kX2V{(=k<U>Eg;4kM+Sd2DSM2Lif5su@-u}-Vmw62M
zoC<$B)ondyD>D*`(4S>{dCK3ISr~hlcB$$6Rz7Nc9o+SkXFVIVDv9%x+fr|XH-m_w
zI0l~AB`CNp&!(?DEZR0^Pr=<IYe~BTI&w8{l6edDfE(?nK6tMH|LNe>OuG=^iPv>7
zy9_v_3$=arT}A(g3<w>w-jO4Llkg~S8mZ!6g*{t(Xu_dx{It2{ZLt?!2%1hx;sxjU
zoxbAf;*$BIe5mE6>XMYaU^EM$I-SDl25+<BJH)<4tgJC^hUjw{E;hPF^EiF8Rxc?*
z>4Slel+TI{cgFel#&)UT+C6=;ALtGdXYZ}RRKGwA2KiGwb@dRltSVjiDmJTO=RQkk
z0f@#)FuLr@7`qxDlV(3tmC`)R3syI(S<w0I^T%Lh^-zi+c=Ge0@F4I0osxm)%Fk;`
zshk$(c6Lf^4D%P?Da5~GqPuRuHFj##cQ8D&^GK;0+RamG!vTq`H3f8wzUJhKFc_0Q
zJ3ZQ%QvI#0ly5lZARngn=3U-fM7zyBz~uCScQfT%A^Wr8#KRT0C5Q?{<>KPVTTE}J
zS}bCm!G&xT(_N}I?X4&wNjGUCWe$_PeZWRiZb5K9uCC^agd0k9`YPtcm+m&dZ@0gC
z^-gQzX37&Wx?1L*j(Jc0wXDfecE24F-peq?ryb1nqO|%%r8j8_9j2G)DJ+Y8R%25M
zFH63=Gul-9%0=-sMT^XtGw-@VTHU@c?M&JPlA<9$Jx}c_p52*qlmJ7n8Qyj_Z66$h
zDYL)jwu~9fbJN$KoJafi_bM7`f4KN_x|7>#o}t&E5v!5^lsm}?Yix1)$NH_o>5Zu&
zRJgv)2k{KTZsEAP`N50*sovA!EsfEI9F>#DHD4G>_c9J0Ne_3o^$tCO#IUm<oU+Bx
zjzM@c7ClAt0c&`F?=>GvpmypK*m{iYy_~?d=Bc-O%)8BQwsifONF22}xmzOYsYms2
zL3)}gafax5wtP3TtdL+%T%Or#(*AwQgfC!G{wn`tj?Xd}-B}msHI`#P!gEkhc6UKb
z$9sc}pc5R?-{R_oW=&P2T^p}dL>$NO)X%P1()yv$wWFcm!gikOB?vw$#%CDJUe4;#
zj!<wp{QTRD-vvm`a`Tnb_v<4n;v+v-s@PPNS3i5RYuo3=?&y-$BOdS4=NlY;#uGWX
zFfHjXI(fWG^gr=_^3ltllU~5NuG@xw%(E$^{*#%=VWGvyK{8V7Z}8qpt=KGr*v#%0
z!@-jI>L9QK15uWm<w-kj)70Pp0`zVL-*_PRMWZfdMa;Z9(edOX@c=l(ho5X#FuP2F
zWq4pUCCC%2G<tbR5YR1^sSsOv;Z-VswAHlSwy`v0CXEevQn2wojK&tX;{9wZoqay^
zn}yCH*^VCD3-&l?!yiepmwhlf)th=_P5l^?)ymp4J%WnBJ51JuYt|*NAu<=T6_|$>
zY*`l2Q)BgNx&seWEy1B9vP1O&?J&}w{b_T`j{B@@8eGET5V*LVx~biwA&H|ooi%OG
zzN-W6w~O7oG`PR7`CtoHBuP5|M-Dpct_PO9UtH@kMi6M&aqc)gzA^fKY8bxq(yIJ>
ztj023hkY#F2P`3*`<WZ()7X^SFK6TQL`E>KKfq>#1xUhb*IZ4fQ$8gd-3uLIAex(>
z_FJ;0;dv3<>H}@IA$dQu?ltAyaP>631MV-j_(%pg#75;x(eUFfm5b9bVI?oadq<=5
z?g~I#@r-UKl2WN6So@VSq#EZ{3e&ZVeZ5oSzg{As=ISdGT9G6L09CGqY)Y91#ZKnR
zs2c~PeTSdkE8a|Xo#`I-hf6Jt<d+eHO+Z=>kgvUQni+z|iyt%5d6*1^JVV{WVlhAL
zu0H5gXRlRdamKnatOadR#bg<$iv4z5PpL`lOvX1ZPc6gu`Dr%sw8(-d-m0q1oV^aa
zR60TBBgQ07Hn6I>Evt=(H;(X%w_(3_%WcX&WD%NoajKO?h#CvGnF<FiLpBu0Dl!%P
zsN@#Qh!e#Uod`qqV9z97%cHE;q5bmfOk+)^7b6$Ay|bpKgKmr3elrWvCU{RV|3;FX
z><2_yEUyrEruR44h%LN#X(ot|QVLQK!i+kusz2O#+g*G(NK$NXQ&iBD9Gj3Gy_7Mw
zo+>R9y6#sBtIWqZ9rR+gJ}YI^%D7sdj$RCAd}D?3geUY5Y|=-+Vr>W*&+#U6w1y-&
z-g!^9J^kZRs8Jan?%(FTfNw$<YF3b4ruDrQxwYOnv~sIV1ypFO_^{bYC1$4x_4IRl
zw^FFq>!S^d6<-F6Uf1Ti6_@4BFBvIsYne`-YGjDNPD4BXunD!FZ#gW?Ry!I)%gO@z
z6>+2%%_xY>6~V^WS}b3=mqZ&Coa0f0j61;^Z?b^hla6$%_ndWo)_w@HEMs}x*{`B9
zsOpAmaw=Lql{w(Wf|Yb?u>O5T1BY2=DW{NC@k^qPu#2-3+*rOm<Um5^qrn$%&9O}X
z#e-L@3)>PIv3*;W&4rfb6B&cICN31ZQSCHa?=$~`9Y0hpkjbXvDzlP2CSK#r>6Q|d
zm%?*(FT~`)PK)ndUO|wDa;NzCg--5g?|=+=eHARpPU_OFf^zYUx>b@zXoVk0VWgJ>
z>^+xW=^@JQlE^x>)e5)0Y#ASgAY*M1$~x?&kJEy{oV9Ve%Wvki+=(Di)Tltj5oKNG
z)sbGZYY95hW$pxhi!0HPq`o9t+6POZU?Ob;H6^1RN~5-f@Ue`YyCHgv-{vtHpLpKg
zxt7TPIv10{r)4Pw=u{heB6i6=yL27@6HmE7`T_9Yl{qz&<C`-x>fhrQbM(nfPR(PO
z(Q1-X6N=MwU*mh-9T&}T=?UC3CjPjA+D^{jBaX_S>@m!4WAba$o&WxspIIkm^_&fz
z!rY6&m4mehOKe;N44&%TWSAv%0ExaQ)C@FP)!&>QX5BrmkB+Fdu_ii)E%@D>(Xx^9
z0lD6IvAGTEt}_Kxn+m!mRpML2G7K88UaIy#;Q+Bh)P&L$S8Wrgt%8U8PKJyZO}c9*
z!xFi_W~Qils_38PK4W;`|DkuvL{P<-7Ah{B^<V@y>8PQi{c|W$W~bjjep7~ecwxA*
zo?|cjA@1BgbaC}4^x05Cvmca5Pv>JpEH2{{!kaO^RxyMd6>teKZm<ZM^~OM?V9Kd^
z6$|<3kI!Si_&m@94KVsgo34L4KC_L>-BDZ22=nOmLd}lMD1+`fXi}rBRALpJf+5nf
z@CKU<qStmpurJThU_sE|;8r6XIJ7Iri|tFyf(p$E6(Uq@;njrgA0>Vs3E%woh}hzp
z_V*WM2|+He=%Mq2UbnUWD18AB;yj|SeETXn1b<=aw)xQHeL6HCHPe5n`P#w@LB0s`
z@)A}s?1`}x!aO`^B_ko!(dOHiu9J5)@89MN>q1L$cGv3$5!#&I2=E_^@SF7^%`5z?
zN3_s$4AAyZdkDN!#}CF%d&=vd`74@+_diS)`!rjlL*3*{S~8t)K=}3%uC0ge&+^66
zTR#6<@jg4vw9hA;`;uMN^V#n^AMcna|IM8C8gv*UospI{KCE_hmnv>xp4b?zDPuCA
ze&MRehf*D6HncZk+Y85aEXAI0th7!9M@#rgAZ>@sCS{%G2<EV`!Ra654UD|7bJBwT
zfH+ePL*pcUH;X|?=lDGO*ahU8i2fmUVDNR_x8Vk)B6l2jeb5x0?RCL->@p~Z@CkU9
z<nm!@M=<-u>m!fV;8iJn%Cu&xsm|oX`l3DtWqY!RUObJf(*=#ygd^OqPfucdbM{Hp
zk9(Jlc|EWKubXRRdt^{B0U%MTRHlY_Qt6q9k@J`9UR{vD&B%sSm5hbUv&Y7ae{g>W
z$)f(4!e05Ns!U^A=E@)BV1Ius&{4`?V83@)AiMen{cFpR3kCo%025QLpvj4`=+*1!
zA+1=YN^y;p`EYyNkL?(!NcJ|hVtoFrgl;BeCOcBvqw|+6kbeZ+PQ+J_e>KEf!(KM7
z^^BfmEDozZauEVm-whWlQ)zt{Ie(h==|e^@`jrBtX2?FJ!dOA5BDCUtAVTerP0o)#
zg5*L=kGM5rT1$!91nUk!Zz`aJPejb_QP>?o!OH@rw-$5&HYE|GE8aF_1J3)2OA$xD
z=}y(M+|)F>F@6Z&pPUjs>?VuIoc5OyP@Q^<W__%zuoc>DNQPKj$k5;>!bAfh`UBOx
z;0QYO&T+Qr%Gj0_4(><Nm)3fCHhmoLL215e#*Z~-L+T6Djt;UVd~B8(LNG{$k`v#d
z>7>^AWsQir?a!8H^HvgYSeV^lgLu(#6pC3KC4J1{09+17S#kP2YP4Jq!Bcw0n{o}v
z==O+ni*r4xoLBu>_)<Q%i`(1#x|^HuvJ3s^qxAb_N;U`lzwhftr%9zW5Ur6+cSi4D
znyBA8h|=N=3Jb*C>CpO3JZo#a%H0vXJCa%6Fi9FBEn#RzyIPddzV)_CHT(MW!?z+(
zR@KVS2N-Ud97k7iWC}$LGCg)P4AjkCyq9BGMpj>Z&nQENrcLjkXKvVfT%8-=t2h@m
z7Ut=dsZkR6ay-!fHzB&<giR@=s+T5idOZ;xB^aG?z=H~>1#GV4RW91QaxA@Nn^Pa(
z{b*h%b46u$pDUHS0-ch~x^AVYH>~c;H-9biZ^oXfbp^GeK&W4&Z{O&vq}IfDqr7et
zYUOhKyCKPFrctg-i<C65fv!@^;%W)0j{dtBatfFh5EFJG1jAUeXyMs{hT0gq-ZnWD
z)(t@_fzPH&&^pn`G`00al#dDrd>v2dm%aXsnZcI~u{y=cvg%4MYT66<f_G!Zki&jP
zHCE4$x7EH`Y@W4j^|#rcS^1378kLP@<Sy6{OTsazx23Vx9o$-qV<&Zc?@nRj{>cub
zM2CEz^?L9A-;>j$aks`#Jaumr$>pb4msAiH?S)^s%Dd=gL*i)buXz(iE1ZJ`VRZ<~
zA~CLKUt}FW=&Y9`u-w}fm}#?Nn=>2XZf<^V;fYr<Qsr73A4=#Gmjj8p(^%oqN2SB(
ztU)Rerai7jTF^_)jno@g`3Q*`wEd$Cc@j8`6!Q9#Olf{<sD!LXFMr;6<w;>#Q<uiO
zNit?Uu`5sVs>f|1w8!sTX=yfhPd9@W2i&83^cXw5Hv_=JFJh}{x(WTUW@NMhtbWMx
z?B&IgK5f$nr0A0$*>^;+ySMuO#9sk}gJs(UsjL!XD51|tO&RH*GK!*`-)AxdH<tQc
z?&g9Ns&<1o>^mm=qZdqGoz9*Z06L57q9LHG00Y2)tWGgMa`JJS!VfHqN;@I&U7Y=7
zK*;@wH^t=uRtuo}yL1JG_(sx1pFg;~Behhqw6SUMJSr$D+2p(Q_<kn7m%K@<(tUYv
zr$qVvMxEZ4U@qZQWJDbX>XJG;TAqz9K3r*7NSjQtg3GR=)9O~}4V;W@8t%x{uk5X?
z%xE{XhdO}d^|>c{qksIW7{8_rsMfkj`vbQ+HUUnUm_)`z|BBi1(5`>0MS>S=)TwV=
z^_)t&Cl+AtZJfC1-x|Wx!5eT@SI)okPCEE)(Xy=;W2ZMi{a$+#4X8BXESu=&pr2$1
zje9ypgPZZl!Uz5HDRuS1RN&v=Mb>;@4MaG`jZ1$W4=&=q=D|rVz=gaYHuO1TLqe!G
z`WarWx2kzHL!-FW-43#T8@B~Vg-ZZ#t9evHLi%+iI9r~kc^j0H4UIYFB0RR2;k$jL
z@{AL$P+_F$1=KiQVD%7f6(p2ohoqUp{bZRMl^3*evb+689c?4wAXoic3;bSu|7MD`
zf|pyAs|R`DKOJfSqR*oybUsEm`>*Fd3D%5wH(y-3Wj+O!@@=p8;v&2G{wCbx?FMxU
z()9)xp^qC>o0k*b7END8+(jP3woT#LYGtXg!V7a|j^eEm)GB<~B9)en4*Ddi-~2%T
z!q9d3$-w7o*N&?FsQAk!%UV#O`tEc+S5(Jc##Op+dYY>Y0MT8L<wA5VZWb^tU09Zw
zJuTy;VOlK#OwN}O)7aYtL#-_I$rDjUuM2!S=u>qGm`s&E{oGBou%Nt_<1O#*L}5U%
zoqKo+-8Ze=Q?2||F!n44crBRvc|nVf*S0g1ox6P%H^H=oc-cP3v=Y}CHPJTj*}vxx
zb~jw!<%%S4bsB%OaAVas1RR^Hf7beWHlg#%KGXwX5-Eo?!k4CD8{a@ZA3Ozlm74Qf
z4)};YGxFfh6uaS$+I;Qu`8MxpkCx?alde0|t!qa`nP|E%srQS#_&?PGYRc<w&y+VW
zWQt@WcQ2{rd)#N;3~hEoK3|8WohtKvvWq>})s^hc+w=neD7L%>4O|mm6d12dmRt-@
zt`gLbv6K5|F(}=~pk3BDX!7?$pPxgBtNMent<`oHYQ2-G>5oA{8Wod?^$de>XraaS
z$(ve1uAko)kI{hUG+%Mtkz4G5oR9PRml~i%9Cw_qW;n9EKqiLDeDTH1ra^`5BJiCT
zX;RAHr<xry8W5Ufrwn*fGPRzcj*2wuD>p#6a3PC|=}<LIAA#HhOpN=-fB#PP^6Hm&
z9S10PwrXXiCO7{H%U5~JIAG-UoEMj$aApuckPWPvfx=B?aqr0xP#<hq>0a}y`o#68
zhL)>>Zw(l)4aUz3#~;TC@k%sb(S`1Cn`0}8edBHTRAtT<|BtUAMYP%<2ej3gYppM*
zi<|3~lx6j%X^f*9if4&THgOG_;e({pBla@~Ia5>c5UDNFpTgwU(8&?Vad51t$tR({
zY0w|_`g|Zb+77i{Y8{)U$A^5|fUSuW10}glb^g4DvdI_v+LkXd<&)Bnwo%Ya9L4XO
zCJk6Kt5qa8A?j``XoSvlbi(7?hjM5i^5Q?wFFqYwwJyT)dma^fKxLljQU+~$-B#lC
zguc38#uLvUw&Lq=GY|tn6_2tzEYxAyzQ}RwyEA0IFb?|>X4`^v-|&f>GZS(WO_D#j
zuG^_oBH5!H9_=%8oYF`ogCP~(8|eWr+uV4bS1wWOuz37&B3&0xBd5p10xg;Og4ejZ
z9G5%M6H1tdG#8c}wPq7d!ITek|E9|Rf(C?wre%D@&Sq&z+tWMF9|lM(^6l;URT>!l
z?AuC$={*aN+Tnym5MD+T_>rYFFMhYp<J>b+M?4zH(@3*I6^2gzDzUB~zvWX*`FnFu
z)3%1nKT-Z!t>K9M1J_qWR%>ow#NDSN>sXQKU`;n&kCg1cC(~fg1FJ9Y?;|`20YVNH
zW*?E|7vmx5zz`J)ITG^j8Q&hio*t#iq6K9upi{Z<SK&x*BEGJkg@IwvVODHiv%+6P
z53po<smsj%6SkldnNaI0(1(>t3VuFjMM;9mmPt$%c7inPa=tB~N!WzTBCaItzM1j!
z)nf=$y?Az75vW;b+N#YB1eHAAIMX!pktT$_+c3*QTgD3VRLI){J=9?5e+E?$L=bg&
zwS{V@%jPTfJgcQ+ZQT#%w+qwm`^)EMKSIdSfH8#VW~PT%wMGiRz&tsHh~U+GW+Y4W
zpT*&He9d`2YlC%bepzDyVY<XEr7?70?!9f5ZXm+T)jm&mpj}Ad{Gc}9s2P{+k}5Lt
z%XONihN>Drwmy~>c%ErwXeD2qH*X(82*086HtSY=kS$40SI)QKXdF3&2%61u_(KjK
zaChhxNJxuAn(u>L!s_MPPz%^bdJ`PqoVj3qt%>YK1=m{Fz}aZ)?05svs{PcPI$H{Z
z56dsZ<M(g1Sv?H(IrfRDvjaPb`rz;njph)h%%R@B&kVwG2bbkmEjMO`@Id^{1;cd2
z>3sH55M_ALo)UgH+WZ_0KN)Z(sIPw~PJI$AIJ&G)P+ZT<woArLN~iP9-$8DAC1adY
z*{iJPNrH<O1R1Pu#c#$CgJfJD{on%(sVUfuy63QTlv{m0LC8=q=95bdWYsI*s0@RV
zK7uqXmr{@CfwdU=cjcX(lvL7CYsb3@Y$CZ3(Acuuv}}duti#Q~nH|t3)0|u_l9auT
z)*m}}gRA?^)#&V5-IGnz5+WPKF4CE{;;L>+YaYx9zWzc#^Q0qtW#993%@gg=2`HA{
znqWVeIw|I=bp6L;ekB*E!jER$gP*ENE+IBItHff`qI6oMvh1JqMh@fMzjJ_T+!-Fb
z_^PYjb!<Kx_B{+XIIO>=^8}19r9rpnXN+FnNAF7@ewQ{GRXfz&n49Th0;}9$Ijmy-
zX8QYxC8>XPAcs44B7^D&z8|R@xg$t&?hnzM`_#)9k#)}=TX``KRj%>C6;lZyr|&xr
z_E+ed|IJNq008roysngHC$S1$eodU-I(X(DaKQFTBy~RTIApz^pX)2CycR3ZCuL6M
z>UyFdWhc}zxW_lqu)lIGqdF-^YU5;Z3=@7HlGIY3O&{r+gA41Ey4*{ZTUGjbfjfr3
zNlR^OIoV`WiT|CLbVY_DPc;5M-_N+U#&oQB#R#UDwvr6F7ma1Of3p}uemJ&q*YVzb
zsK5cAI5G7@SYHe1tJ~izyWQz$=9+|(hoDeWu{Tw~8Wek>dkd}8W2Xp_tKQk00EnD|
zNl7(h^W_gvPmJF$lQF%}ThZH(nxPR@v`}qQZ|P16OM_g+W1xF>W{~*!P;`)xa}|Jz
zr==V9*sUeREyluNCMXZTDc9?`Fg{!Vz!wGyP!#iO%52owV@L8wPGr%YY@LN3H3Vr?
z5V^)DfO%eqjRmRs%#|W68+c$0K|i&*LT+1Ms{plIqP@EvJXb|HQ7INL-AhOe{*Zp_
z_pDojyQ>1O#s6$-d`n;aEhIXtCJ{9DMZ_=Eisg;ivCekbg1v3!(W>(5BpD5;kN+M{
zj`CyhvIanklznD0M|tLLA$jeW;RY1J^LAbE=UrlQLvbQ{o@5}XGTN+cOsW~(zp$i~
zUCmf?&Q=bda3^{J=e_YLCJ7p~Ubq2u^>2oWI#>JcUULy??Z92R`eZ_z##{kiQj=Yt
zD64u6LAYK(Z`<smJ%&;Q@C~cD4VJYpYy(ZiCLWHDrH|(mUHtO&ukzunt)R?H>Ch67
zTQ;$Sv2ff(M;&tTO=%2tz&PNYHS~Gwd|@J@uGQ;ubkN&-^o6-5Ptlsf7{N1vi9iD>
zZ|H=k>-ZK*`4fm;e~jG&NACuSmcG02uz7xK0x@C|@4EmCef0ffIW^Pgq9u21xE!Pg
zG9ign&qf#w`syH|78pNn-*{-9h@M9>(5u{dV=}(cv)TP|{&&|H4OGN>4Jj3Cs;^6f
zVBeFDICH<JEv|rA38cx@Ul{SG&GaFi9Q`#o-I(Ik`)sWBOvHZU5HV*IwX?Es$r&nf
zkV6XfSWwwz`9zl)8xVU7PK82reiXJJx4Q43SqI`8u;2}Pp)Rzy@I03$?Wmn$>0B;x
zg9<XU=-nQ~E|O6vDE44Ise>*;CmzZMQ^MvR0;BEaxHBWAW~=xus}1f>GYIx_#UYFI
z*)gfPDCi`tq{2`cFgn1*qIuXyMp_7g<APDOkrElS92*%3_lb$UJAAO1Q7c69qIxa9
z_*`5Llcs#a1nk`BjZAy_>r$$bEtsiOOQLJOb&fCo5Rl(H(Yxh>CsC(}<->?;uP0^P
zcHW238rv1HbC$XOop95IrR!0W*!4BZyI;ocVqEJxLV)f`C{d>(#qnXKpL3W9^nGI@
zs7e)GdmaUC(l)V{QW26V^)0sE2m&))$OiZ}M$eawKxKA@W`Rb+56Z9!mioMtiWp-d
zc>C(ASUPoddl@z)W8Mb6&(Ba4Wd~*Q!nrUXTKe610T--G68OR9;7U`dzuo3nu|FU4
zvduZErg#!T@NlU;pVOnP@|f+N?Pb-FtdQNwAc$==lLhQr5MM8bW9;7kYMbs16*>yf
zA#v;u&_3R(a{B3A!EUTh32j%d@E^fEdpP}&pH9MzQlx^1$w~l9{TzYI%Y&+}zrQMk
z&c@{H3=Stw{!RiGZ?n{_-`if9I?jV19jI6Jc&)hWi}sZ$<iy)k)tXU`#eZkJ(v(q@
zl)bfLwXD{A*TxQXwZdniruV#b#U4Z=dJOFNEZC>9sz_n#n^>OfhYv_iHi2%7?w>mx
zubwG~>qncyeh0TQ%30U%F%`5KG%;Ld0z=1~>9L|$?rd}%hqCJ75XN;K-CjNc9RA41
zTMt<a!kh^NH+EVklPaI=(eBzj;IdlxVhLtE___)t)djxSq-kZhE}ywkhHxC5O}0t2
z;{H|FGsN~_D>%xo$ghF5xhF)oWX&&hhO*V%DfYYQNUz=)o0V8&k@zCtfy&0AZ2UIE
zPQSNNf3GtYIaax_Or^)&X1nS`X-*<`&m)gBUqP$%(Mo%_=thT!vr>Z1J!nUDUo)ql
zI}BaFXYfPbv)&jiL~2<UFDy7Q{g%-j;<V9^OmB_BH86r8ZU=&i+u)D9JRMd_3#Jz}
zD9n@|W&hkr*zJANH13(Lco>o9gSo)QtG7zuXhXcjz#q+1v}uwmi{aQD9n>hqTSM|p
z)=569KWom!u$?@`@)R}MkL#Bp!M9wFP{21^YGe-6*BSPHeiDzN){XBue#pT&xZ1@*
z`eXIXgdtPnY=$p$&0dwZtgiI%1sHFQL9Fz%Mx&EjT;JAun4U!byo{Y4zQ2d|>FQ@t
zkS<dxm)<uocac2%Tz1qhT`8?anZi_{-%VE`_oe%@A>$$HS_uyt)eX<q%JiJYZoT9L
zPb+ZxBS^jIto6IL(}f7A-*Ara(9`gTu^(6WjTUZcgJ5C$DSmn#Kc;RzPxWtTN2ZGx
zW|`EP+I-L$*)jL|3MpHY$~6QCh4cWaH8_O<n-z|n55}bau|-12c%tM_5l7k>sh05o
zQwB?77+Y(|Y&z{TpEkW}14J)zdIsI}nXBC&n>Xg*F5!_-ROEO_RpAps*O`}ZWU!6@
z{C*kc`B$yA$I9-QvjYF4xn@G4>^QV~@<_Yk42&Rve4s;GSE!5~UQPz@Y8U|L_iW^w
zPD$VyrtOk5yQ=O#>JeS*zSCXpO)++xNBiJhu>BLgZQs4>@k!TCvgb)YWuhEeRk$XF
zOMnMUXA%ZmV*YxMKl(YvCC<CsBrKOm0{agln{ZJCS5Md{WHobHj}OT3qrQgeQJ%J7
zw!(p80n~F&Td&8=C1BFJW0~xSLFFg3qHXCkXSM5^_tzGh^Kv!n&z>sOBI3aZeu=-I
ze*U~7xG;Jvz(rCYlJYFlFZSDePr*H%=v2W3SB@fc;TLW{ld2><qO)P8X#mqA460=T
z$lPs;G;r5y(`TUbew5*w%>*t8&9DP9M%kgU02?ZDfFwk@*(<?kwV!1v5KG+R>sdCB
zn*_$#i4}f!YmD_0XLU79uOqq>ai43)tq&&ZxQsUCt@L7}YUlSM@o0u%W8hEuU$KG7
zL%x<gK$Gmp=~oQy$Vx4*?$z3~MKymgSF?2csE6;z8@}M<o}6aB0?DsGLugd9>=0vx
zBF3Xy`Vixi)BekH@50K~p}}^2N2zzdyGLZu6<cYsRrq%01l2FgRW4$ASXz{LFucbh
z@Sr)qCvkLQIJc&bbVEIO1QF?WSiITD#}(1-8F&Z!VWOcQJP=*LyeW6~$*=x&+GlsV
ztIz!GVK*+`;QJoqDCB$gY->7cx*;3YQ?ODDxIy%AbxD143qhLzVB)l}ia)>WcfTpH
zif!W_NI~6`+NU~uQDbZI>G%31Lsu5Z-=CxH>m&4HGEJ*)V@Tgc!Yb6-R#$KEL3>E+
zyUhwk;_r29m1^w2;bveh^IK+x*?jpyA`a52-exmYHFDY+Q7<Y`dfTZRqajtusytIC
zwXMl#Rd2EClqRsi$i+io<Q)rMPnTOaO8)3Z+aU`(v;duM+xv3Kw-c>!l|2t#UM&DU
zUj5{XAAFwrxRD=pv!4l|!=v;az({1cQtg)+8sp-&Rr%%Ju?*^j>Mo4u-~#*ZB^jVG
zUD8#f(hcG<4+$Ia)ADdIY?#j!>;5~|oQYrL-fdoA;v4a4M&?>66RaQ4`l6exTI(|c
zAH;l5nvrmrejwBSMH~F3ro*h!b<=BCra$@yVWbJ{9D_}utjayk<cUDK%%n#3A)|$W
zwi{)60k?r~qAwG^7wp{^23*p5@QZg8hZ2rhPjDwdQ*Znj)J3}2-x1dKE%x}zx24^Z
zt2NLGA*qR*_5Wx>v}cKDXWy8zAAAbilRH1r|7L0Fw&1+QLLABG>vgWO`HcFu?#nta
zC=suy154l|0_dLO)+o}bW{}%BYa@432xbQ?qFId{8M1L82mWKcZ__D%6+{pANxTl3
z5C!Wid~lQVlIwT&z17YfX_Y&K{Dll8B-7<}ln&*$vWHZOc{to$!m6bJk7K%aOf@ne
zRO19A-sMCvX)ZUZ4GJPBkIWWx=rE^p#sihjtD$%9pjJ!L4%6hfcPHz`oy2RUw)Mte
zq}pQmeu}5cha5W>BejH+!GE)|gaYdwble>BavToP%+uDw2a|HB=eq6cV7C|XYOA9p
zEw^FS_1MWtq!v+lJ@#}1cnv&FqVt#^4RDcThMPO1WWklU(N}LF<gIRBmqFck+Ume#
zC!^#reOGv!5(D5({9HU-NY5-^){od3dcMf`#mp{^l5Y8{NSYV=n}YH`)#euw!5+>c
zP4VsuR_|^s>BlkKxYO*eJ2p@~Fa6_Z#KJu4cXh8>NoK{klIo1gRamKKvhN#ud)im3
zV4`I#*d!%WigAqpIGau3y_*xYjytRAaU2wTA=X^W#GUz~y_^jo`l9x|h9tqT|NR<c
z>%Es%Qj<Pm)vi_9=L0&*_G=}4g+`p=6yMm2;|UB7P2C#&^=UpL*C!{oq!zZH@zy&^
z?d15Ui5o)HDO09ZKWR7i2;RCIYa61aFJk<@)j*?#IWC^Td19Y^$tyPIFov<itwedl
z2hL%fEf06^u1lL0b*y@ifZpOTqpUK9{`B8=yS_A<>jc#@PMyDqGG65aXaTp&dWTTx
zzn7a)sp66EG-}iRtq|-;=uB~qbEE%^0-v`^V-~Bb$Ss6G{d_mkoBw`3ReDNZA{Z_#
z{djj)Ue<ZX&DB>&JhKK-t{-qC)jh?w=Zyx|@yBAePfaG;cuDLP{Fr(asjcN3qo$yK
zem1Yz6_{E2;7v_i`wL8ak6;Cp!c{n027Ve*!26)M^m7>9EJe|3@cq3)4AM2;l(*aq
zR#QJw?l2LyzOZq(G}TJC8I^hY00;_%qUx~^z1GKSR`}|6Yu2IGA<si^wHt~S9QNE$
zFR)qFW6qdJSTpC3uzjBw`N)*V(F{bH5+_P<jhcyL#3|`g4JqANY6>$PRlubcKOUb}
zQ{Z#cgU{B<HPoDh47K48BTg2^o}x}m8_if>RH44xaXO>*$mX|4|7cY0$V|H<ZP~EZ
zpFqVJLf}-MD?)mnZlpqkQYT1vi?Fn@eO#)K*epx;aYkf(MEs<VZy3_qnje~`7F*+f
zeZ)XYlzP4u!K~n7&tu}fF?L9qW@XGLUKV7qp7@Ak2jiEz6o2jxQ+SgwTU(rG67$AG
zK3%LALS(*0KKt9U@I9eI#Bqc_D)&Jw;bR90@k(#^FEylS$g6qe2TB<X#XZufJC^yX
z0|*g<N%9Rk$3mTBY&NrLpjr`GIFMCuKYwKWZXE1eDx%$<C&`)+<q<#i_nJ*|n8{XK
zM#vDyx%to1=c5D}RoYu*mo~LC6?9PfLQRT!;OUpT^XO;R)+r!Di-lN@AC5a)UaDy_
zIQ{f*3yrb6)C-{^;Z@?Am1doo{8Oa~mc3I4jk-JHog2!S2{=Kv#wDqvBZzkp2__#m
zyW1~EN;EA#&d#^^Nm@^1wIMrDF*@u9rb&11*g(TP08ct@pRw{%qM5iY2iZSri>0Ck
z6cjY0QaAJwc|IF76Ji-RU+?)ut@k0ARx;OWXS)le$IDHN?~T;OR0uJd6iWhyYsQOH
z{_eZ?tEq3FAnNZlJl%7>x1jjc!CCA_n2D9MJ|ui7gW%gb*RdJn*MZ63>)lGaS`WiD
zYVkBI$M3H>*s8_NraZI)Q&#QW)UpImy!hC7M?qbpN?%iwWGSXmH!8?sp-UA#kci!e
zC#GANSc*2M=XLS|PsG1Y%QfaOfQFJ%VlsUO>1dqRHLR;(4zx<qbC2|93RjBtqH5xN
z9MG30#!{dP+e$@WQ88VawPyMyU6R<Muil!HCZ~VH4|Z0p(NqsevWU1<;3HmOQ3c;d
z8n#@U&(BLEtZ&*E%BCVVBUn1*Iq0Vfzjm*J2};E0a7T3SZs(k<fK+VWDnU-({c#zw
z<C%;A6V&g2e?G{Z-zrk*dmWzp(rW7guK%}$LF}fn`U?Vm-V4sU5~a)}@%CIQp;v7$
zE&)}*GL#|F<iLXw{)m;R=l{4`A(aUk`jj&bhsbnjh8upCSxYfC>;TtNe&9k1jCaWb
zXw)Ib72}c4AlVp8_4Zm@9M9fmE<W~#p3GIgKKV`Owcatp_JwG>yn38!$wfFsUe^_y
zhE?i$5~vhc%drS{Ypq^snNY4Mn=LaMh|<;Fy8Di?WnmWDZ-Cnv=?HEcH0vcF2#-=j
zRMO_<6Jb+LAB!ZWMI4t>#@1c#s_cL#yd2R#gghml@nG@AsS{9LA_3w5I6<i6jss`c
z1nvP2yR>8JSJpMVTlKVcxjI8>+nMq@CUgQA5Yazn{EEg=LhFa5>xgrS-o!442wj#M
zPhM4-jY{F!O~T?Z+1_O7;E@Y%j`dhK?`y^}3eQ6x+B=%^L{fV;JR+PI?$ar(?lNiW
zZSnYD|8B({QuB7f`^jE#)n-UYNb6kL4Dp<}jnb(jt*}1vd$P{Cx|INC?f~`ZZXBk~
z^96JT`xO}rzra@0rzv1cJ)IhRPzw#PwB(=>{ejK;p?8}nN|V^4_^fmZjgYyJema@r
zqqmfuRCUw2@-p)3aN)$3`E0#ras(!FrbGLMWu??NURfX^rT*Q3{#ATBMjA+0t=ZVy
zH)1z>`Mb`wim7W75|{<F1N{%sOogLC1#m#2AT06tLA4ew<C#1-E*Gfzx<rw4MxGwp
zp*tltDxsk*xY1r3|DxFTe0kPq<1?F|N9B<sR7)p*!iX;b><*OGKPW?J8z6J~?G!YK
zm#5sW$BOw)<TRNmZS|HFf2a|$h?baper+R;7A8<)J|hd4Wb(PWI2y5|wDESYT2rPH
zP*C`7*QnOdrRu%8Cojv@AGiQ7r2y9X>=YAld4(K0I3eSyfhgFcRBWJq66>%4B{Z<K
z|7>+fK2mmvk27>yu!mw1NPRfo=RNpcNNG+H{>81m;ec1wb4^+@PpojxF8^OUU;YmD
z7ry_pgzTd%S+j*CRK{KuV<NJYWWq$k3@M73WGNDZ2u)?lmMp^%V~Y@m$jCCI8B3Oo
zZSt0_h(51T*Z2DV^7#)w=cjXC=bY!c&;2~-TytG#&aE6XB)s8HuG3XiUQ>?D3Vk>9
z>!^j3Kg3*O<sL=J1Y2K5A&#R)sBo$JsyN9-AB1HAnZbKC?}oSbWJcw)RLkGE<)y%Q
z_mhL)`Wgc344k^k+|XYpRJ<loKBdzz?Lm=6T<pAt2$Yl`Eey5aH2t){WLVn>yrNpj
zP}KWvzu|W5REI0Wdo31KgDB-8I?BHyg;)jKroqHR5qsUyK~0Fp-;18qnj0GuQg`?a
zmt(%)vR<%Us(+g&Iz-mLl=R8SnXVa&eA0T=Ph1*dd#C#|7rMU2x!T!;BL5{&j=0yY
zdh0Trb3p_Aox!NkakWBa>NlP$HPutC`!kk|#5fHgdNp!ZaLGx^Yq=D{)Oc1#h4C<|
zi56Mlr|ii+D6&eKj$f=6*qG5A3cV#npVA7oI68-|YcHK!+;UOcST_o2yQaqQsbZfi
z>NwNwmtEuDhCLLucJFw`)1bmX8?<Ob2G5?g?H3;InhLmS9DXgg8!Hy?QjUUoB@%9w
z>$3+~H`EqTi1_WE0yF8LJ}I<~-$ir-^|*>R8%*geAmziT?8leg;-`jvGK=bZT7TwQ
zeguKUc>dPm`31wZo2VLtq@knDGL{}rm=jJmQtOs`rEb+U;}*~p$g_j?*kAYKgwv0^
zSq{A_9@RwPpKFk4Z~SBpEow%(Zh`+KVtQ3vZ^&!!*pGpjP+t&vnR<&8hXUj1#4Krw
z^WC>KH(S~+^cs;(mrJgX7Ju${M1A)@Z2aAlrarTQ)=Gs5pNF)}S9vXsPQ!wEHWp1N
zN1`iYyqr9+sn=bmY20Q?b#%05Q6u_5b_#pSQnYzVQ?;jCg8rU+(gECmXj~-6c$Y-?
z6C{IvM7c&4lv_c0z9e{gy*eqmueQ@T=AkeVcBb{+(pdF?Gvx>J(>z-DtI4`b5R-Ps
zc=&U0<A{|8!O<hAYJKsRpFVUT*6<hce!8(aLFda129?)%>;k7#v81aAP4>7d@j|xA
zq_jP|BVI-U(mHA9PYxtKSv@ZCr4}7#tbBS{HUlf^(a7k1qV|5xh4CVY8ebQVa%b+N
zEblO{Ba$|7W6zGiM#H!gMzYX{bsf&|JZ*YSG3C&RG7Yu3&1lMx@eA-CeNG8DX%M~*
zEz)lBFxvW@IW<y4%6U`Zs8bAEoJt9+E8rof-|p1uA>px|eIWt7vE>ySm>yBZcqF1Y
zX}+NYU$AXi1z9HtQL=TY9Ow|HGL-Bcmgi}iub%tvqUlanSZa?Z?zJcdP`^X8(DZda
zhC{@ZS>@jtsu#jGuTPoe+C+chzMB{_m1}+&cAg{mVi-1gNn^tqBGAFq%ug;XmqU;5
zt#+g*&~$71NFFoZ84F>(6FSUX=bh0kYNnkV!Bk36QShT!FLX7the{;)u|3N>C{wMp
zCPt{?NjD@7N*^bl(5C-#ZWLvT3K-N+*c*ygP8;!Xc^D|^eey)p$Jz-x@61Ll<(?hx
zR!~M_uPr4KBG1}LmE~mbs~fy;liOI+eU&Lw)Bcd~noSFpP$t_UeW#_#un|QfIeNeX
z9>H(cJkIAyN8Pr1v_nb^p-bCIn(J9=&+U)Yyu>M`Z5*&P6}CEBh;Ze$OI$rqJG_I7
zMFv1SXFUpF0^f|2?qrug7OHa*%oDo(H3Ul};1k4>-I~ljleXVj(CfwgeIRdOk=N)U
z4oL^p`PXsrfo;EsM}yab2KL-QxFp$HE8BnEEH6}Syw@7U245&yJZFWeswIjkNK8o*
zdm?Q<9GtmNjQ`$KPfSp;KkE8W;w)#0PikQtvKrNfb%h%-p6AE$)xSy;kzp8IDwTkK
z#7PZxNrv=Fhh?>@A+j5lmn%Kc<hMba7f^Pqki2Hf?J`N`B}}jf6jCyt?fuLTRHxar
znL&r1AyB*s7R%?7rfu!ywNG=Ez8Ct1ol5nR-fU8zv@{6KzeATxB28ok+n8PI3H(py
zkvCzxN2=_kmZcK9cays>J|lH!q~dK1d`pb@Z8jN6v==DYcqMoK$K|uI^^JKUjHKHW
zl4<>i#THzeq_74}-3v%E($_xFo@1u@?7xeMs^K3$-5P9h`vk<c4$)3z1#G64$eKR}
znr2RZr<IKag+od2^IuE4w}vubW_0!>qoWE=zfTM25<!oT<u*Gf;33R?z8~*~U#}vb
z=6rw;^fvC)jw0cFYpQMn*rQjl(DP?0Tq{Ge>R%H2*S7{U6)Z~m(gS5GAbWIzZZjLD
z)D!*3LsS`?%A8)54JNGxBiwRjL44g7bL#3U5CPdTk4NYJ=3Sk(4eaxE$#*KbCBCnV
zn0{96dZg5?5^tvsoSPNT2E4=dyWZ;Ft9kKPQWi`~kEc27UcW#>Rv94CLDw)u>#p8A
z1<Z5%aoDiv6?(aK;QX%yu{{)2Q)+Mjmxj!jlU{2C0X9p$K}n;g3jz}8DEi019Dla$
zBiqgn{7E9W%(J}$_%jDXuPHN+70Zilm7?O1`1aJ)%o7%2HxzpgG%DJoDgU(*!I!*a
zaRV=%F>lk~XwB<+Yeaok>8Ad2W+I!K^ZEH!zs{{~gr_I-S5{NKzr-mTyUTkQF<O-P
z5W#v@WxAfvS~9lM;Cwz6D|X!>3N?-nU00}zI%Vec1cUd5H%#n4Ks0@_htYAy_umjR
z+w_cOlkDzj$%lsxe>Cb3G=A)JW|2}KNbs{(?hh7`TUqsxh|UR$yoUVm$gD-P#C&jL
z@tA}4vP~;4<y{k`zZq>#n)MGTh|aa+9IJk3e6+C%SM#l)A&Q722V`IB)oT}XN_v`r
z2NbJTUgRaCTxte!h1nnA(nLL{%kLs?IwSdwVq^@PMin>aV+*P<zIONMO99~xF<ykB
zPeJZbV{g0J%kDP_Oc8Y%7vi@N_o|BM%%SU}1#(kTt7iQ-0Ex&lwI_&drS)rs@`<`W
z3L!>6=e4}+@c_$XDe9i3lv48nkKRtT&<y%c!Fw;45<~GpTAb@-Z9(#-`k%_lg3n*p
z3xrW?HBLPpc|(Wv|JWD~uNiF8S?slcnX<#D7zsdepbmr{PoBgPe4>W@$sx<R0hu*N
z!~@1yO?`*6PWw$?`l)f6f>T$8m6_IC^0zUs-mpGh((Do@M6f9Ar8seWQ&quf(<uRu
zhh@hk>-BLmrO)$g12Y`4=xmBwvUbDWYT;v;L7!r~jRe0>qhwW;R=awQPy5?Ocv|h3
z&y9aO&Nvx3pfL9`jM`*e_E^UuEazR)4g4r({QQl$lO}w^%{N2YUgb<Rq=n>|e?$sF
zeEq7OV8PR9|Dq=DtyeP{^4gkbW0A_#C+b<BRVt$E!e1?QWj{D6l=lFLSz!mHbYfi;
zE_&<M$*x>dWmjLnqA@dwk4K6`#WE#IgMY1<*r3p4Ojm;HOGe%7?^xuP>k8o)+cb40
zbxDhIRp4Mm#VkiNj1iN1!MDi3L}$rL`~%8DH2QlUqYk0(Q@4FO9Qs-!hNE^gM2&Ho
z-m%<iINYj4Ikj$3hU3U#{6s7)vnl29+~+QIH+#elbYw_58&--KhNej?Zq&?dQ$}Pe
zhek#laE*g7ZsP1g%DZ<^{AiG|%o@#*x-Llq@FZ;$0XjQUU6_sXrIrJb@VW5>{<t*k
zREkdqUZ6{ioSSBn(hnnM5@R32{Re1ajf_NZjd|X62@>#=!{iT#1UDx^@Tm>CCIbL4
zT0JP3DbsT&sNlI}VRz+Di|V!vfF$pzHp`j-Qr9N0im*o{&lK9LRKg%@u7RHCAxGNb
zc+tiw`Z?2F8AvN_aG^V73=_vr$H;L4NY{tP5dbvebNtUe0OCZt(hSkgUIx77bl$TW
z_`Q+HlOB*bn3=zh68aju`rabL7(kA)4Ikw}g2EB<lhlD?S*PyxD-Uv<213Z9En0+c
zTf-FkVER$Ife61mKj0J$5V;#n*a7~<pKDMQWu7xJ1*#k-qejkiMCB}Hg%%Q+o`P>O
zp(uJ?VCt=rDd*V_0D*KTwoZu10|A{F2IX7a{0*ZGRZMSMG@YEgfANLLUQe=BunnrJ
z&X3V+m*t1wjH+gU!fuO_5jzJX*Z_X-+t?~81(<D9%kaRhGM64{NU6UY`twX#rXgna
zst<#or4EJ+XN@gw>l&S`ei+1+8kDiIKC%kW5=%a<NNf=!-6uok%sH(Z#i(VKMTYp8
z8L|0Cptc8=j~x_5;h&oZA4W^H$d|d0KPYz|e3-T&kBGaeF)_U6YmvbDbkR$V6nlUS
zzO4p;sYrke&{ECQw>56#M-)@DqSI2g(#Mc&k?0;q;}D$CzwmhU$}4kTgGtb`iJWjV
z06=?b(MdYuB;D)>zve!R=c85RA0~`%Q0`|9hn%a_+)PxI(O?PK`I!J5z;NWg26Gi(
zzE-PZ;X`ZE4rmp~a{EuG0qMzl|02v2J;7F%T@1_aD?SbB<}sVsCHJ4I*;KvjO%0U4
zi_fODe)9(Jh8HZ2W7@Xs6i)4`Fwvq|uxnT9J(Z-Jbu11&cXxVYjG`W*IgHb%u2jw>
zD2J|}eR)$Otpm#vDeDvD)B*(?un*pIb352`noQFedSAK&%XL)XHF7Ks851cM0LMv!
z{iCAn5A+|K2$vF+`sP3rBkh9k_S=hc9}h@XGtRBN2p~tZ4BE<p1|u>F;@oIH1zcNj
z0Qqrey{1yIwRGJ$+|4ZkW6n}9dBX}vb7BSsB2y|!t$KDF-W6o=)BR+!#M|nvCuW=O
z%>5lHQ^zg9$PIF^@dHRNxTrtu$Q&P2sF9H@8y1*<pDY2&R5^*WGFrXhM9S5C_=9vi
zBxXr-FomONSwSP}*Ct~&%rQVvkrzyxSAwj81oguE{=LfX;;GnYStP`n_e1572~cAY
z>AM@fuT?X!HTdAb=klxFiQi{?bxnj$2f}^j?u7XZupiyS(ukq3fxv-S{cuHtVrZmo
zu^<f`#(n_4t|DHfFf2B3({ICxm&IGekyGC6Km=2tP?6{$z&&U*(`l1YPpmeaR3l5j
zx+LeP!<`V2Br^5mu93nukP#kJ&Rs@6LCOo(s_W;Y=Cbj6<3RHjmIhJyZoUwvqF2%w
zsUp^UdSrTJ@|y2~1RUgG;pz3Iq8CPwmaSiYJMj1}8-5F-U_H7F-vX7WQXhc%0F>MW
z5LfclV(_2m%zj5nPO)!3*bNpJYj#BY95vHM`aJU7!G{SzAOsBhNfujr4xglFbqs%_
zg<FMHk(w)AG@gPhAXJku7F$8n5o<xt)Y;z?rR-X=-k>mG#M-W}Pl~#!!o>7gh)b>F
z$2~y)j3~GQZ*G>SufQaMJr>KsIk`%_<_gm3y$k<qEwBC`0L#(oM;?ZHmVtOXSwRO1
zMM=Cs<;=c78&ioALyO~=K<Cpe9}y4s0L||zj|sPcru%ovDS8|Cffuk}dA#$!PtXj^
z>4>{5lwjeKzX&&DC0*>UQ42mVUI5vy<qv*&Xv*4$`iEswR+T~cQ7lfra<g26IdL$+
z4Sp~R1X;@(72#gU2LK(oq}^S%$U20Ybqo2pL0i~gdMehL`qJQBLsrni60xjpu9e+)
z$4K_^{2p+Z9b^Y>M%jpg2a*1zt=tc>EIdDV&m;h7{y5PN4vJvy9M)U`WIWey(tZ_U
zg#j#5t@~Sd*ZOZs(7is%;OB4_Ft7}(T5|4ASQlim3|fpaWjSCG!|FDQMS{5>{BLql
z#NotUfkF)Dzm;0pN`rce>pcG^3xYZZV3YIzHDyHpzow1+Zj=3QFU!8K<X_;d`tXT=
zkij~^=buNgjvQby_O~>@{)ZcEMp*CW%-@ceTz>(vT2O)ibMTjy|DB>wf8>CaD<qXO
SGwnO9v1iR~%*sw9qy7iw0wtdS

diff --git a/lightup.png b/lightup.png
deleted file mode 100644
index 5afa3242d9ad4c42e69d257bbb947d327c663941..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2593
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
DL(chI

diff --git a/main.cpp b/main.cpp
index 8eb04dd..7860e9e 100644
--- a/main.cpp
+++ b/main.cpp
@@ -1,188 +1,31 @@
 #define OLC_PGE_APPLICATION
 #include "pixelGameEngine.h"
 
-// PGEX Require the presence of olc::PixelGameEngine
-#define OLC_PGEX_QUICKGUI
-#include "quickgui.h"
-
-namespace olc::QuickGUI{
-    class PictureBox : public olc::QuickGUI::BaseControl{
-        private:
-            olc::vi2d clickPos;
-        public:
-            PictureBox(olc::QuickGUI::Manager& manager, // Associate with a Manager
-                const olc::vf2d& pos,
-                const olc::vf2d& size,
-                const olc::vf2d& offset,
-                olc::Renderable& image);
-
-        public:
-            // Minium value
-            olc::vf2d offset;
-            olc::vf2d pos;
-            olc::vf2d size;
-            olc::Renderable&image;
-
-        public: // BaseControl overrides
-            void Update(olc::PixelGameEngine* pge) override;
-            void Draw(olc::PixelGameEngine* pge) override;
-            void DrawDecal(olc::PixelGameEngine* pge) override;
-    };
-
-    PictureBox::PictureBox(olc::QuickGUI::Manager& manager, const olc::vf2d& pos, const olc::vf2d& size, const olc::vf2d& offset,olc::Renderable& image) 
-		: BaseControl(manager),pos(pos),size(size),offset(offset),image(image){}
-
-	void PictureBox::Update(olc::PixelGameEngine* pge)
-	{
-		bPressed = false;
-		bReleased = false;
-		float fElapsedTime = pge->GetElapsedTime();
-
-		olc::vf2d vMouse = pge->GetMousePos();
-		if (m_state != State::Click)
-		{
-			if (vMouse.x >= pos.x && vMouse.x < pos.x + size.x &&
-				vMouse.y >= pos.y && vMouse.y < pos.y + size.y)
-			{
-				m_fTransition += fElapsedTime * m_manager.fHoverSpeedOn;
-				m_state = State::Hover;
-
-				bPressed = pge->GetMouse(olc::Mouse::LEFT).bPressed;				
-				if (bPressed)
-				{
-					m_state = State::Click;
-                    clickPos = vMouse;
-				}
-
-				bHeld = pge->GetMouse(olc::Mouse::LEFT).bHeld;
-			}
-			else
-			{
-				m_fTransition -= fElapsedTime * m_manager.fHoverSpeedOff;
-				m_state = State::Normal;
-			}
-		}
-		else
-		{	
-			bHeld = pge->GetMouse(olc::Mouse::LEFT).bHeld;
-			bReleased = pge->GetMouse(olc::Mouse::LEFT).bReleased;
-			if (bReleased) m_state = State::Normal;
-            offset+=clickPos-vMouse;
-            offset.x=std::clamp((int)offset.x,0,image.Sprite()->width-(int)size.x);
-            offset.y=std::clamp((int)offset.y,0,image.Sprite()->height-(int)size.y);
-            clickPos=vMouse;
-		}
-	}
-
-	void PictureBox::Draw(olc::PixelGameEngine* pge)
-	{
-		if (!bVisible)
-			return;
-		switch (m_state)
-		{
-            case State::Disabled: {
-                pge->FillRect(pos,size,m_manager.colDisable);
-            }break;
-            case State::Normal:
-            case State::Hover: {
-                pge->FillRect(pos,size,olc::PixelLerp(m_manager.colNormal, m_manager.colHover, m_fTransition));
-            }break;
-            case State::Click: {
-                pge->FillRect(pos,size,m_manager.colClick);
-            }break;
-		}
-        pge->DrawPartialSprite({(int)pos.x+1,(int)pos.y+1},image.Sprite(),offset,{(int)size.x-2,(int)size.y-2});
-        pge->DrawRect(pos,size,m_manager.colBorder);
-	}
-
-	void PictureBox::DrawDecal(olc::PixelGameEngine* pge)
-	{
-		if (!bVisible)
-			return;
-
-		switch (m_state)
-		{
-            case State::Disabled: {
-                pge->FillRectDecal(pos,size,olc::PixelLerp(m_manager.colNormal, m_manager.colHover, m_fTransition));
-            }break;
-            case State::Normal:
-            case State::Hover: {
-                pge->FillRectDecal(pos,size,olc::PixelLerp(m_manager.colNormal, m_manager.colHover, m_fTransition));
-            }break;
-            case State::Click: {
-                pge->FillRectDecal(pos,size,m_manager.colClick);
-            }break;
-		}
-        pge->DrawPartialDecal({pos.x+1,pos.y+1},image.Decal(),offset,{size.x-2,size.y-2});
-        pge->SetDecalMode(olc::DecalMode::WIREFRAME);
-        pge->DrawRectDecal(pos,size,m_manager.colBorder);
-        pge->SetDecalMode(olc::DecalMode::NORMAL);
-	}
-
-}
-
-
-class olcDemo_QuickGUI : public olc::PixelGameEngine
+class Meteos : public olc::PixelGameEngine
 {
-public:
-	olcDemo_QuickGUI()
+	public:
+	Meteos()
 	{
-		sAppName = "olcDemo_QuickGUI";
+		sAppName = "Meteos";
 	}
 
-protected:
-	olc::QuickGUI::Manager guiManager;
-
-	olc::QuickGUI::PictureBox* pictureBox = nullptr;
-	olc::QuickGUI::Slider* pictureBoxSliderX = nullptr;
-	olc::QuickGUI::Slider* pictureBoxSliderY = nullptr;
-    olc::Renderable dirtimg;
-
-public:
 	bool OnUserCreate() override
 	{
-        dirtimg.Load("dirtblock.png");
-
-		pictureBox = new olc::QuickGUI::PictureBox(guiManager, 
-			{ 10.0f, 10.0f }, { 128.0f, 128.0f }, {0,0}, dirtimg);
-        pictureBoxSliderX = new olc::QuickGUI::Slider(guiManager,{pictureBox->pos.x,pictureBox->pos.y+pictureBox->size.y+16},{pictureBox->pos.x+pictureBox->size.x,pictureBox->pos.y+pictureBox->size.y+16},
-            0,pictureBox->image.Sprite()->width-(int)pictureBox->size.x,pictureBox->offset.x);
-        pictureBoxSliderY = new olc::QuickGUI::Slider(guiManager,{pictureBox->pos.x+pictureBox->size.x+16,pictureBox->pos.y},{pictureBox->pos.x+pictureBox->size.x+16,pictureBox->pos.y+pictureBox->size.y},
-            0,pictureBox->image.Sprite()->height-(int)pictureBox->size.y,pictureBox->offset.y);
-
-        guiManager.AddControl(pictureBox);
-        guiManager.AddControl(pictureBoxSliderX);
+        
 		return true;
 	}
 
 	bool OnUserUpdate(float fElapsedTime) override
 	{
-		guiManager.Update(this);
-
-        if (pictureBoxSliderX->bHeld) {
-            pictureBox->offset.x=pictureBoxSliderX->fValue;
-        } else {
-            pictureBoxSliderX->fValue=pictureBox->offset.x;
-        }
-
-        if (pictureBoxSliderY->bHeld) {
-            pictureBox->offset.y=pictureBoxSliderY->fValue;
-        } else {
-            pictureBoxSliderY->fValue=pictureBox->offset.y;
-        }
-
-		// Draw Stuff!
-		Clear(olc::BLACK);
-
-        guiManager.DrawDecal(this);
+		
 		return true;
 	}
 };
 
 int main()
 {
-	olcDemo_QuickGUI demo;
-	if (demo.Construct(256, 240, 4, 4))
-		demo.Start();
+	Meteos game;
+	if (game.Construct(256, 240, 4, 4))
+		game.Start();
 	return 0;
 }
\ No newline at end of file
diff --git a/quickgui.h b/quickgui.h
deleted file mode 100644
index c445acf..0000000
--- a/quickgui.h
+++ /dev/null
@@ -1,786 +0,0 @@
-/*
-	OneLoneCoder - QuickGUI v1.00
-	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	A semi-immediate mode GUI for very simple GUI stuff. 
-	Includes:
-		Label		- Displays a single-line string
-		TextBox		- Click to enter/edit single-line text
-		Button		- A clickable labelled rectangle
-		CheckBox	- A clickable labelled rectangle that retains state
-		Slider		- An omnidirectional draggable handle between two values
-
-	License (OLC-3)
-	~~~~~~~~~~~~~~~
-
-	Copyright 2018 - 2021 OneLoneCoder.com
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions or derivations of source code must retain the above
-	copyright notice, this list of conditions and the following disclaimer.
-
-	2. Redistributions or derivative works in binary form must reproduce
-	the above copyright notice. This list of conditions and the following
-	disclaimer must be reproduced in the documentation and/or other
-	materials provided with the distribution.
-
-	3. Neither the name of the copyright holder nor the names of its
-	contributors may be used to endorse or promote products derived
-	from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-	LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-	Links
-	~~~~~
-	YouTube:	https://www.youtube.com/javidx9
-	Discord:	https://discord.gg/WhwHUMV
-	Twitter:	https://www.twitter.com/javidx9
-	Twitch:		https://www.twitch.tv/javidx9
-	GitHub:		https://www.github.com/onelonecoder
-	Homepage:	https://www.onelonecoder.com
-
-	Author
-	~~~~~~
-	David Barr, aka javidx9, ©OneLoneCoder 2019, 2020, 2021, 2022
-
-*/
-
-#ifndef OLC_PGEX_QUICKGUI_H
-#define OLC_PGEX_QUICKGUI_H
-
-#include "pixelGameEngine.h"
-
-
-namespace olc::QuickGUI
-{
-	class Manager;
-
-	// Virtual base class for all controls
-	class BaseControl
-	{
-	public:
-		BaseControl(olc::QuickGUI::Manager& manager);
-		virtual ~BaseControl();
-
-	public:
-		// Switches the control on/off
-		void Enable(const bool bEnable);
-		// Sets whether or not the control is interactive/displayed
-		bool bVisible = true;
-
-		// True on single frame control begins being manipulated
-		bool bPressed = false;
-		// True on all frames control is under user manipulation
-		bool bHeld = false;
-		// True on single frame control ceases being manipulated
-		bool bReleased = false;
-
-	public:
-		// Updates the controls behvaiour
-		virtual void Update(olc::PixelGameEngine* pge) = 0;
-		// Draws the control using "sprite" based CPU operations
-		virtual void Draw(olc::PixelGameEngine* pge) = 0;
-		// Draws the control using "decal" based GPU operations
-		virtual void DrawDecal(olc::PixelGameEngine* pge) = 0;
-
-	protected:
-		// Controls are related to a manager, where the theme resides
-		// and control groups can be implemented
-		olc::QuickGUI::Manager& m_manager;
-
-		// All controls exists in one of four states
-		// Disabled - Greyed out and not interactive
-		// Normal - interactive and operational
-		// Hover - currently under the users mouse focus
-		// Click - user is interacting with the control
-		enum class State { Disabled, Normal, Hover, Click } m_state = State::Normal;
-		
-		// To add a "swish" to things, controls can fade between states
-		float m_fTransition = 0.0;
-	};
-
-
-	// A QuickGUI::Manager acts as a convenient grouping of controls
-	class Manager
-	{
-	public:
-		// Construct Manager, bCleanUpForMe will automatically DELETE any controls
-		// given to this manager via AddControl() if true
-		Manager(const bool bCleanUpForMe = true);
-		virtual ~Manager();
-	
-	public:
-		// Add a gui element derived form BaseControl to this manager
-		void AddControl(BaseControl* control);
-		// Updates all controls this manager operates
-		void Update(olc::PixelGameEngine* pge);
-		// Draws as "sprite" all controls this manager operates
-		void Draw(olc::PixelGameEngine* pge);
-		// Draws as "decal" all controls this manager operates
-		void DrawDecal(olc::PixelGameEngine* pge);
-		
-	public: // This managers "Theme" can be set here
-		// Various element colours
-		olc::Pixel colNormal = olc::DARK_BLUE;
-		olc::Pixel colHover = olc::BLUE;
-		olc::Pixel colClick = olc::CYAN;
-		olc::Pixel colDisable = olc::DARK_GREY;
-		olc::Pixel colBorder = olc::WHITE;
-		olc::Pixel colText = olc::WHITE;
-		// Speed to transiton from Normal -> Hover
-		float fHoverSpeedOn = 10.0f;
-		// Speed to transiton from Hover -> Normal
-		float fHoverSpeedOff = 4.0f;
-
-	private:
-		// Should this manager call delete on the controls it opeerates?
-		bool m_bEraseControlsOnDestroy = true;
-		// Container of controls
-		std::vector<BaseControl*> m_vControls;
-	};
-
-
-	// Creates a Label Control - it's just text!
-	class Label : public BaseControl
-	{
-	public:
-		Label(olc::QuickGUI::Manager& manager,  // Associate with a Manager
-			const std::string& text,			// Text to display
-			const olc::vf2d& pos,				// Location of label top-left
-			const olc::vf2d& size);				// Size of label
-
-	public:
-		// Position of button
-		olc::vf2d vPos;
-		// Size of button
-		olc::vf2d vSize;
-		// Text displayed on button
-		std::string sText;
-		// Show a border?
-		bool bHasBorder = false;
-		// Show a background?
-		bool bHasBackground = false;
-		// Where should the text be positioned?
-		enum class Alignment
-		{Left, Centre, Right} nAlign = Alignment::Centre;
-
-	public: // BaseControl overrides
-		void Update(olc::PixelGameEngine* pge) override;
-		void Draw(olc::PixelGameEngine* pge) override;
-		void DrawDecal(olc::PixelGameEngine* pge) override;
-	};
-
-	class TextBox : public Label
-	{
-	public:
-		TextBox(olc::QuickGUI::Manager& manager,	// Associate with a Manager
-			const std::string& text,				// Text to display
-			const olc::vf2d& pos,					// Location of text box top-left
-			const olc::vf2d& size);					// Size of text box
-
-	public: // BaseControl overrides
-		void Update(olc::PixelGameEngine* pge) override;
-		void Draw(olc::PixelGameEngine* pge) override;
-		void DrawDecal(olc::PixelGameEngine* pge) override;
-
-	protected:
-		bool m_bTextEdit = false;
-
-	};
-
-	// Creates a Button Control - a clickable, labelled rectangle
-	class Button : public BaseControl
-	{
-	public:
-		Button(olc::QuickGUI::Manager& manager, // Associate with a Manager
-			const std::string& text,			// Text to display
-			const olc::vf2d& pos,				// Location of button top-left
-			const olc::vf2d& size);				// Size of button
-				
-	public:
-		// Position of button
-		olc::vf2d vPos;	
-		// Size of button
-		olc::vf2d vSize;
-		// Text displayed on button
-		std::string sText;
-
-	public: // BaseControl overrides
-		void Update(olc::PixelGameEngine* pge) override;
-		void Draw(olc::PixelGameEngine* pge) override;
-		void DrawDecal(olc::PixelGameEngine* pge) override;
-	};
-
-	// Creates a Button Control - a clickable, labelled rectangle
-	class CheckBox : public Button
-	{
-	public:
-		CheckBox(olc::QuickGUI::Manager& manager,	// Associate with a Manager
-			const std::string& text,				// Text to display
-			const bool check,						// Is checked or not?
-			const olc::vf2d& pos,					// Location of button top-left
-			const olc::vf2d& size);					// Size of button
-
-	public:
-		bool bChecked = false;
-
-	public: // BaseControl overrides
-		void Update(olc::PixelGameEngine* pge) override;
-		void Draw(olc::PixelGameEngine* pge) override;
-		void DrawDecal(olc::PixelGameEngine* pge) override;
-	};
-
-
-	// Creates a Slider Control - a grabbable handle that slides between two locations 
-	class Slider : public BaseControl
-	{
-	public:
-		Slider(olc::QuickGUI::Manager& manager, // Associate with a Manager
-			const olc::vf2d& posmin,			// Screen location of "minimum"
-			const olc::vf2d& posmax,			// Screen location of "maximum"
-			const float valmin,					// Value of minimum
-			const float valmax,					// Value of maximum
-			const float value);					// Starting value
-
-	public:
-		// Minium value
-		float fMin = -100.0f;
-		// Maximum value
-		float fMax = +100.0f;
-		// Current value
-		float fValue = 0.0f;
-		// Size of grab handle
-		float fGrabRad = 8.0f;
-		// Location of minimum/start
-		olc::vf2d vPosMin;
-		// Location of maximum/end
-		olc::vf2d vPosMax;
-
-	public: // BaseControl overrides
-		void Update(olc::PixelGameEngine* pge) override;
-		void Draw(olc::PixelGameEngine* pge) override;
-		void DrawDecal(olc::PixelGameEngine* pge) override;
-	};
-
-}
-
-
-#ifdef OLC_PGEX_QUICKGUI
-#undef OLC_PGEX_QUICKGUI
-namespace olc::QuickGUI
-{
-
-#pragma region BaseControl
-	BaseControl::BaseControl(olc::QuickGUI::Manager& manager) : m_manager(manager)
-	{
-		m_manager.AddControl(this);
-	}
-
-	BaseControl::~BaseControl()
-	{
-
-	}
-
-	void BaseControl::Enable(const bool bEnable)
-	{
-		m_state = bEnable ? State::Normal : State::Disabled;
-	}
-#pragma endregion
-
-#pragma region Manager
-	Manager::Manager(const bool bCleanUpForMe)
-	{
-		m_bEraseControlsOnDestroy = bCleanUpForMe;
-	}
-
-	Manager::~Manager()
-	{
-		if (m_bEraseControlsOnDestroy)
-			for (auto& p : m_vControls)
-				delete p;
-
-		m_vControls.clear();
-	}
-
-	void Manager::AddControl(BaseControl* control)
-	{
-		m_vControls.push_back(control);
-	}
-
-	void Manager::Update(olc::PixelGameEngine* pge)
-	{
-		for (auto& p : m_vControls) p->Update(pge);
-	}
-
-	void Manager::Draw(olc::PixelGameEngine* pge)
-	{
-		for (auto& p : m_vControls) p->Draw(pge);
-	}
-
-	void Manager::DrawDecal(olc::PixelGameEngine* pge)
-	{
-		for (auto& p : m_vControls) p->DrawDecal(pge);
-	}
-#pragma endregion
-
-#pragma region Label
-	Label::Label(olc::QuickGUI::Manager& manager, const std::string& text, const olc::vf2d& pos, const olc::vf2d& size)
-		: BaseControl(manager)
-	{
-		vPos = pos; vSize = size; sText = text;
-	}
-	
-	void Label::Update(olc::PixelGameEngine* pge)
-	{
-
-	}
-
-	void Label::Draw(olc::PixelGameEngine* pge)
-	{
-		if (!bVisible)
-			return;
-
-		if (bHasBackground)
-		{
-			pge->FillRect(vPos + olc::vf2d(1, 1), vSize - olc::vf2d(2, 2), m_manager.colNormal);
-		}
-
-		if(bHasBorder)
-			pge->DrawRect(vPos, vSize - olc::vf2d(1, 1), m_manager.colBorder);
-
-		olc::vf2d vText = pge->GetTextSizeProp(sText);
-		switch (nAlign)
-		{
-		case Alignment::Left:
-			pge->DrawStringProp(olc::vf2d( vPos.x + 2.0f, vPos.y + (vSize.y - vText.y) * 0.5f ), sText, m_manager.colText);
-			break;
-		case Alignment::Centre:
-			pge->DrawStringProp(vPos + (vSize - vText) * 0.5f, sText, m_manager.colText);
-			break;
-		case Alignment::Right:
-			pge->DrawStringProp(olc::vf2d{ vPos.x + vSize.x - vText.x - 2.0f, vPos.y + (vSize.y - vText.y) * 0.5f }, sText, m_manager.colText);
-			break;
-		}
-	}
-
-	void Label::DrawDecal(olc::PixelGameEngine* pge)
-	{
-		if (!bVisible)
-			return;
-
-		if (bHasBackground)
-		{
-			pge->FillRectDecal(vPos + olc::vf2d(1, 1), vSize - olc::vf2d(2, 2), m_manager.colNormal);
-		}
-
-		if (bHasBorder)
-		{
-			pge->SetDecalMode(olc::DecalMode::WIREFRAME);
-			pge->FillRectDecal(vPos + olc::vf2d(1, 1), vSize - olc::vf2d(2,2), m_manager.colBorder);
-			pge->SetDecalMode(olc::DecalMode::NORMAL);
-		}
-
-		olc::vf2d vText = pge->GetTextSizeProp(sText);
-		switch (nAlign)
-		{
-		case Alignment::Left:
-			pge->DrawStringPropDecal({ vPos.x + 2.0f, vPos.y + (vSize.y - vText.y) * 0.5f }, sText, m_manager.colText);
-			break;
-		case Alignment::Centre:
-			pge->DrawStringPropDecal(vPos + (vSize - vText) * 0.5f, sText, m_manager.colText);
-			break;
-		case Alignment::Right:
-			pge->DrawStringPropDecal({ vPos.x + vSize.x - vText.x - 2.0f, vPos.y + (vSize.y - vText.y) * 0.5f }, sText, m_manager.colText);
-			break;
-		}
-	}
-#pragma endregion
-
-
-#pragma region TextBox
-	TextBox::TextBox(olc::QuickGUI::Manager& manager, const std::string& text, const olc::vf2d& pos, const olc::vf2d& size)
-		: Label(manager, text, pos, size)
-	{
-		nAlign = Alignment::Left;
-		bHasBorder = true;
-		bHasBackground = false;
-	}
-
-	void TextBox::Update(olc::PixelGameEngine* pge)
-	{
-		if (m_state == State::Disabled || !bVisible)
-			return;
-
-		bPressed = false;
-		bReleased = false;
-	
-		olc::vf2d vMouse = pge->GetMousePos();
-		
-		if (vMouse.x >= vPos.x && vMouse.x < vPos.x + vSize.x &&
-			vMouse.y >= vPos.y && vMouse.y < vPos.y + vSize.y)
-		{
-			// Released inside box does nothing to me, but i may have
-			// to finish off the neighbours... oo err
-			bReleased = pge->GetMouse(olc::Mouse::LEFT).bReleased;
-			if (bReleased && pge->IsTextEntryEnabled() && !m_bTextEdit)
-			{
-				pge->TextEntryEnable(false);
-			}
-
-			bPressed = pge->GetMouse(olc::Mouse::LEFT).bPressed;
-			if (bPressed && !pge->IsTextEntryEnabled() && !m_bTextEdit)
-			{				
-				pge->TextEntryEnable(true, sText);
-				m_bTextEdit = true;
-			}
-
-			bHeld = pge->GetMouse(olc::Mouse::LEFT).bHeld;
-
-			
-		}
-		else
-		{
-			// Released outside box
-			bReleased = pge->GetMouse(olc::Mouse::LEFT).bReleased;
-			if (bReleased && m_bTextEdit)
-			{
-				sText = pge->TextEntryGetString();
-				pge->TextEntryEnable(false);
-				m_bTextEdit = false;
-			}
-		}	
-
-		if (m_bTextEdit && pge->IsTextEntryEnabled())
-			sText = pge->TextEntryGetString();
-	}
-
-	void TextBox::Draw(olc::PixelGameEngine* pge)
-	{
-		if (!bVisible)
-			return;
-
-		if (bHasBackground)
-		{
-			pge->FillRect(vPos + olc::vf2d(1, 1), vSize - olc::vf2d(2, 2), m_manager.colNormal);
-		}
-
-		if (bHasBorder)
-			pge->DrawRect(vPos, vSize - olc::vf2d(1, 1), m_manager.colBorder);
-
-		if (m_bTextEdit && pge->IsTextEntryEnabled())
-		{
-			// Draw Cursor
-			int32_t i = pge->TextEntryGetCursor();
-			olc::vf2d vCursorPos = pge->GetTextSizeProp(sText.substr(0, i));
-			pge->FillRect(olc::vf2d(vPos.x + 2.0f + vCursorPos.x, (vPos.y + (vSize.y - 10.0f) * 0.5f)), { 2, 10 }, m_manager.colText);
-		}
-		
-		// Draw Text
-		olc::vf2d vText = pge->GetTextSizeProp(sText);
-		pge->DrawStringProp(olc::vf2d(vPos.x + 2.0f, vPos.y + (vSize.y - vText.y) * 0.5f), sText, m_manager.colText);
-				
-	}
-
-	void TextBox::DrawDecal(olc::PixelGameEngine* pge)
-	{
-		if (!bVisible)
-			return;
-
-		if (bHasBackground)
-		{
-			pge->FillRectDecal(vPos + olc::vf2d(1, 1), vSize - olc::vf2d(2, 2), m_manager.colNormal);
-		}
-
-		if (bHasBorder)
-		{
-			pge->SetDecalMode(olc::DecalMode::WIREFRAME);
-			pge->FillRectDecal(vPos + olc::vf2d(1, 1), vSize - olc::vf2d(2, 2), m_manager.colBorder);
-			pge->SetDecalMode(olc::DecalMode::NORMAL);
-		}
-
-		if (m_bTextEdit && pge->IsTextEntryEnabled())
-		{
-			// Draw Cursor
-			int32_t i = pge->TextEntryGetCursor();
-			olc::vf2d vCursorPos = pge->GetTextSizeProp(sText.substr(0, i));
-			pge->FillRectDecal(olc::vf2d(vPos.x + 2.0f + vCursorPos.x, (vPos.y + (vSize.y - 10.0f) * 0.5f)), { 2, 10 }, m_manager.colText);
-		}
-
-		// Draw Text
-		olc::vf2d vText = pge->GetTextSizeProp(sText);
-		pge->DrawStringPropDecal(olc::vf2d(vPos.x + 2.0f, vPos.y + (vSize.y - vText.y) * 0.5f), sText, m_manager.colText);
-	}
-#pragma endregion
-
-#pragma region Button
-	Button::Button(olc::QuickGUI::Manager& manager, const std::string& text, const olc::vf2d& pos, const olc::vf2d& size) 
-		: BaseControl(manager)
-	{
-		vPos = pos; vSize = size; sText = text;
-	}
-
-	void Button::Update(olc::PixelGameEngine* pge)
-	{
-		if (m_state == State::Disabled || !bVisible)
-			return;
-
-		bPressed = false;
-		bReleased = false;
-		float fElapsedTime = pge->GetElapsedTime();
-
-		olc::vf2d vMouse = pge->GetMousePos();
-		if (m_state != State::Click)
-		{
-			if (vMouse.x >= vPos.x && vMouse.x < vPos.x + vSize.x &&
-				vMouse.y >= vPos.y && vMouse.y < vPos.y + vSize.y)
-			{
-				m_fTransition += fElapsedTime * m_manager.fHoverSpeedOn;
-				m_state = State::Hover;
-
-				bPressed = pge->GetMouse(olc::Mouse::LEFT).bPressed;				
-				if (bPressed)
-				{
-					m_state = State::Click;
-				}
-
-				bHeld = pge->GetMouse(olc::Mouse::LEFT).bHeld;
-			}
-			else
-			{
-				m_fTransition -= fElapsedTime * m_manager.fHoverSpeedOff;
-				m_state = State::Normal;
-			}
-		}
-		else
-		{	
-			bHeld = pge->GetMouse(olc::Mouse::LEFT).bHeld;
-			bReleased = pge->GetMouse(olc::Mouse::LEFT).bReleased;
-			if (bReleased) m_state = State::Normal;
-		}
-
-		m_fTransition = std::clamp(m_fTransition, 0.0f, 1.0f);
-	}
-
-	void Button::Draw(olc::PixelGameEngine* pge)
-	{
-		if (!bVisible)
-			return;
-
-		switch (m_state)
-		{
-		case State::Disabled:
-			pge->FillRect(vPos, vSize, m_manager.colDisable);
-			break;
-		case State::Normal:
-		case State::Hover:
-			pge->FillRect(vPos, vSize, olc::PixelLerp(m_manager.colNormal, m_manager.colHover, m_fTransition));
-			break;
-		case State::Click:
-			pge->FillRect(vPos, vSize, m_manager.colClick);
-			break;
-		}
-
-		pge->DrawRect(vPos, vSize - olc::vf2d(1, 1), m_manager.colBorder);
-		olc::vf2d vText = pge->GetTextSizeProp(sText);
-		pge->DrawStringProp(vPos + (vSize - vText) * 0.5f, sText, m_manager.colText);
-	}
-
-	void Button::DrawDecal(olc::PixelGameEngine* pge)
-	{
-		if (!bVisible)
-			return;
-
-		switch (m_state)
-		{
-		case State::Disabled:
-			pge->FillRectDecal(vPos + olc::vf2d(1, 1), vSize - olc::vf2d(2, 2), m_manager.colDisable);
-			break;
-		case State::Normal:
-		case State::Hover:
-			pge->FillRectDecal(vPos + olc::vf2d(1, 1), vSize - olc::vf2d(2, 2), olc::PixelLerp(m_manager.colNormal, m_manager.colHover, m_fTransition));
-			break;
-		case State::Click:
-			pge->FillRectDecal(vPos + olc::vf2d(1, 1), vSize - olc::vf2d(2, 2), m_manager.colClick);
-			break;
-		}
-		pge->SetDecalMode(olc::DecalMode::WIREFRAME);
-		pge->FillRectDecal(vPos + olc::vf2d(1, 1), vSize - olc::vf2d(2, 2), m_manager.colBorder);
-		pge->SetDecalMode(olc::DecalMode::NORMAL);
-
-		olc::vf2d vText = pge->GetTextSizeProp(sText);
-		pge->DrawStringPropDecal(vPos + (vSize - vText) * 0.5f, sText, m_manager.colText);
-	}
-#pragma endregion
-
-
-#pragma region CheckBox
-	CheckBox::CheckBox(olc::QuickGUI::Manager& manager, const std::string& text, const bool check, const olc::vf2d& pos, const olc::vf2d& size)
-		: Button(manager, text, pos, size)
-	{
-		bChecked = check;
-	}
-
-	void CheckBox::Update(olc::PixelGameEngine* pge)
-	{
-		if (m_state == State::Disabled || !bVisible)
-			return;
-
-		Button::Update(pge);
-		if (bPressed) bChecked = !bChecked;
-	}
-
-	void CheckBox::Draw(olc::PixelGameEngine* pge)
-	{
-		if (!bVisible)
-			return;
-
-		Button::Draw(pge);
-
-		if (bChecked)
-			pge->DrawRect(vPos + olc::vf2d(2, 2), vSize - olc::vi2d(4, 4), m_manager.colBorder);
-	}
-
-	void CheckBox::DrawDecal(olc::PixelGameEngine* pge)
-	{
-		if (!bVisible)
-			return;
-
-		Button::DrawDecal(pge);
-
-		pge->SetDecalMode(olc::DecalMode::WIREFRAME);
-		pge->FillRectDecal(vPos + olc::vf2d(2,2), vSize - olc::vf2d(4, 4), m_manager.colBorder);
-		pge->SetDecalMode(olc::DecalMode::NORMAL);
-
-		olc::vf2d vText = pge->GetTextSizeProp(sText);
-		pge->DrawStringPropDecal(vPos + (vSize - vText) * 0.5f, sText, m_manager.colText);
-	}
-#pragma endregion
-
-#pragma region Slider
-	Slider::Slider(olc::QuickGUI::Manager& manager, const olc::vf2d& posmin, const olc::vf2d& posmax, const float valmin, const float valmax, const float value) 
-		: BaseControl(manager)
-	{
-		vPosMin = posmin; vPosMax = posmax; fMin = valmin; fMax = valmax; fValue = value;
-	}
-
-	void Slider::Update(olc::PixelGameEngine* pge)
-	{
-		if (m_state == State::Disabled || !bVisible)
-			return;
-		
-		float fElapsedTime = pge->GetElapsedTime();
-
-		olc::vf2d vMouse = pge->GetMousePos();
-		bHeld = false;
-		if (m_state == State::Click)
-		{
-			olc::vf2d d = vPosMax - vPosMin;
-			float u = d.dot(vMouse - vPosMin) / d.mag2();
-			fValue = u * (fMax - fMin) + fMin;
-			bHeld = true;
-		}
-		else
-		{
-			olc::vf2d vSliderPos = vPosMin + (vPosMax - vPosMin) * ((fValue - fMin) / (fMax - fMin));
-			if ((vMouse - vSliderPos).mag2() <= int32_t(fGrabRad) * int32_t(fGrabRad))
-			{
-				m_fTransition += fElapsedTime * m_manager.fHoverSpeedOn;
-				m_state = State::Hover;
-				if (pge->GetMouse(olc::Mouse::LEFT).bPressed)
-				{
-					m_state = State::Click;
-					bPressed = true;
-				}
-			}
-			else
-				m_state = State::Normal;
-		}
-
-		if (pge->GetMouse(olc::Mouse::LEFT).bReleased)
-		{
-			m_state = State::Normal;
-			bReleased = true;
-		}
-
-		if (m_state == State::Normal)
-		{
-			m_fTransition -= fElapsedTime * m_manager.fHoverSpeedOff;
-			m_state = State::Normal;
-			bHeld = false;		
-		}
-
-		fValue = std::clamp(fValue, fMin, fMax);
-		m_fTransition = std::clamp(m_fTransition, 0.0f, 1.0f);
-	}
-
-	void Slider::Draw(olc::PixelGameEngine* pge)
-	{
-		if (!bVisible)
-			return;
-
-		pge->DrawLine(vPosMin, vPosMax, m_manager.colBorder);
-		olc::vf2d vSliderPos = vPosMin + (vPosMax - vPosMin) * ((fValue - fMin) / (fMax - fMin));
-
-		switch (m_state)
-		{
-		case State::Disabled:
-			pge->FillCircle(vSliderPos, int32_t(fGrabRad), m_manager.colDisable);
-			break;
-		case State::Normal:
-		case State::Hover:
-			pge->FillCircle(vSliderPos, int32_t(fGrabRad), olc::PixelLerp(m_manager.colNormal, m_manager.colHover, m_fTransition));
-			break;
-		case State::Click:
-			pge->FillCircle(vSliderPos, int32_t(fGrabRad), m_manager.colClick);
-			break;
-		}
-
-
-		pge->DrawCircle(vSliderPos, int32_t(fGrabRad), m_manager.colBorder);
-	}
-
-	void Slider::DrawDecal(olc::PixelGameEngine* pge)
-	{
-		if (!bVisible)
-			return;
-
-		pge->DrawLineDecal(vPosMin, vPosMax, m_manager.colBorder);
-		olc::vf2d vSliderPos = vPosMin + (vPosMax - vPosMin) * ((fValue - fMin) / (fMax - fMin));
-
-		switch (m_state)
-		{
-		case State::Disabled:
-			pge->FillRectDecal(vSliderPos - olc::vf2d(fGrabRad, fGrabRad), olc::vf2d(fGrabRad, fGrabRad) * 2.0f, m_manager.colDisable);
-			break;
-		case State::Normal:
-		case State::Hover:
-			pge->FillRectDecal(vSliderPos - olc::vf2d(fGrabRad, fGrabRad), olc::vf2d(fGrabRad, fGrabRad) * 2.0f, olc::PixelLerp(m_manager.colNormal, m_manager.colHover, m_fTransition));
-			break;
-		case State::Click:
-			pge->FillRectDecal(vSliderPos - olc::vf2d(fGrabRad, fGrabRad), olc::vf2d(fGrabRad, fGrabRad) * 2.0f, m_manager.colClick);
-			break;
-		}
-
-		pge->SetDecalMode(olc::DecalMode::WIREFRAME);
-		pge->FillRectDecal(vSliderPos - olc::vf2d(fGrabRad, fGrabRad), olc::vf2d(fGrabRad, fGrabRad) * 2.0f, m_manager.colBorder);
-		pge->SetDecalMode(olc::DecalMode::NORMAL);
-	}
-
-
-#pragma endregion
-
-}
-#endif // OLC_PGEX_QUICKGUI
-#endif // OLC_PGEX_QUICKGUI_H
\ No newline at end of file
diff --git a/road.png b/road.png
deleted file mode 100644
index d188bd398fa6c4ef94b9533ce437d3ed3b76d590..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

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

diff --git a/sol.hpp b/sol.hpp
deleted file mode 100644
index 01a508e..0000000
--- a/sol.hpp
+++ /dev/null
@@ -1,28907 +0,0 @@
-// 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/start.png b/start.png
deleted file mode 100644
index 20dccae056b7ceb389657cd1ac384bed0080ce2d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3141
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
H{(k*WELt!I