71 files changed, 26014 insertions, 0 deletions

diff --git a/libraries/LuaJIT-1.1.7/src/Makefile b/libraries/LuaJIT-1.1.7/src/Makefile
new file mode 100644
index 0000000..b678fe1
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/Makefile
@@ -0,0 +1,252 @@
+# makefile for building Lua
+# see ../INSTALL for installation instructions
+# see ../Makefile and luaconf.h for further customization
+
+# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
+
+# Your platform. See PLATS for possible values.
+PLAT= none
+
+CC= gcc -m32
+CFLAGS= -O2 -fomit-frame-pointer -Wall $(MYCFLAGS) $(COCOCFLAGS) $(JITCFLAGS)
+AR= ar rcu
+RANLIB= ranlib
+RM= rm -f
+LIBS= -lm $(MYLIBS)
+
+MYCFLAGS=
+MYLDFLAGS=
+MYLIBS=
+
+# ++ Coco =========
+# Default: autodetect gccasm/setjmp/ucontext/fibers context switch method.
+COCOCFLAGS=
+# Force use of setjmp (instead of gccasm).
+#COCOCFLAGS= -DCOCO_USE_SETJMP
+# Force use of ucontext (instead of gccasm or setjmp).
+#COCOCFLAGS= -DCOCO_USE_UCONTEXT
+# Uncomment this if you want to compile LuaJIT without Coco.
+# This effectively disables yielding from JIT compiled functions.
+#COCOCFLAGS= -DCOCO_DISABLE
+# -- Coco =========
+
+# == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE =========
+
+PLATS= linux bsd macosx solaris mingw cygwin posix generic linux_rl bsd_rl macosx_rl
+
+# ++ Coco =========
+COCO_O= lcoco.o
+# -- Coco =========
+
+# ++ LuaJIT =========
+DASMDIR= ../dynasm
+DASMFLAGS=
+DASMDISTFLAGS= -LN
+
+# This assumes you already have a copy of (plain) Lua 5.1 installed
+# You can use luajit, too (built with the pre-processed headers from the dist)
+DASM= lua $(DASMDIR)/dynasm.lua
+
+JITCFLAGS= -I$(DASMDIR)
+JIT_O= ljit_core.o ljit_mem.o ljit_dasm.o ljit_backend.o
+JITLIB_O=  ljitlib.o
+
+ALL_DH = ljit_x86.h
+# -- LuaJIT =========
+
+LUA_A=  liblua.a
+CORE_O= lapi.o lcode.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o \
+        lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o  \
+        lundump.o lvm.o lzio.o $(COCO_O) $(JIT_O)
+LIB_O=  lauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o \
+        lstrlib.o loadlib.o $(JITLIB_O) linit.o
+
+# Standalone has been renamed to avoid conflicts during installation
+LUA_T=  luajit
+LUA_O=  lua.o
+
+LUAC_T= luac
+LUAC_O= luac.o print.o
+
+ALL_O= $(CORE_O) $(LIB_O) $(LUA_O) $(LUAC_O)
+# Do not build luac by default
+#ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)
+ALL_T= $(LUA_A) $(LUA_T)
+ALL_A= $(LUA_A)
+
+default: $(PLAT)
+
+all:    $(ALL_T)
+
+o:      $(ALL_O)
+
+a:      $(ALL_A)
+
+$(LUA_A): $(CORE_O) $(LIB_O)
+        $(AR) $@ $?
+        $(RANLIB) $@
+
+$(LUA_T): $(LUA_O) $(LUA_A)
+        $(CC) -o $@ $(MYLDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)
+
+$(LUAC_T): $(LUAC_O) $(LUA_A)
+        $(CC) -o $@ $(MYLDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)
+
+# ++ LuaJIT =========
+ljit_x86.h: ljit_x86.dasc ljit_x86_inline.dash ljit_x86.dash
+        $(DASM) $(DASMFLAGS) -o $@ ljit_x86.dasc
+
+distclean:      clean
+        $(DASM) $(DASMDISTFLAGS) -o ljit_x86.h ljit_x86.dasc
+
+cleaner:        clean
+        $(RM) $(ALL_DH)
+# -- LuaJIT =========
+
+clean:
+        $(RM) $(ALL_T) $(ALL_O)
+
+depend:
+        @$(CC) $(CFLAGS) -MM l*.c print.c
+
+echo:
+        @echo "PLAT = $(PLAT)"
+        @echo "CC = $(CC)"
+        @echo "CFLAGS = $(CFLAGS)"
+        @echo "AR = $(AR)"
+        @echo "RANLIB = $(RANLIB)"
+        @echo "RM = $(RM)"
+        @echo "MYCFLAGS = $(MYCFLAGS)"
+        @echo "MYLDFLAGS = $(MYLDFLAGS)"
+        @echo "MYLIBS = $(MYLIBS)"
+
+# convenience targets for popular platforms
+
+none:
+        @echo "Please choose a platform:"
+        @echo "  $(PLATS)"
+
+bsd:
+        $(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-Wl,-E"
+
+bsd_rl:
+        $(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN -DLUA_USE_READLINE" MYLIBS="-Wl,-E -lreadline"
+
+generic:
+        $(MAKE) all MYCFLAGS=
+
+linux:
+        $(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-Wl,-E -ldl"
+
+linux_rl:
+        $(MAKE) all MYCFLAGS="-DLUA_USE_LINUX -DLUA_USE_READLINE" MYLIBS="-Wl,-E -ldl -lreadline -lhistory -lncurses"
+
+# Mac OS X on Intel Macs only!
+macosx:
+        $(MAKE) all MYCFLAGS=-DLUA_USE_LINUX
+# use this on Mac OS X 10.3
+#       $(MAKE) all MYCFLAGS=-DLUA_USE_MACOSX
+
+macosx_rl:
+        $(MAKE) all MYCFLAGS="-DLUA_USE_LINUX -DLUA_USE_READLINE" MYLIBS="-lreadline"
+
+mingw:
+        $(MAKE) "LUA_A=lua51.dll" "LUA_T=luajit.exe" \
+        "AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
+        "MYCFLAGS=-DLUA_BUILD_AS_DLL -maccumulate-outgoing-args" \
+        "MYLIBS=" "MYLDFLAGS=-s" luajit.exe
+
+cygwin:
+        $(MAKE) "CC=gcc -mno-cygwin" mingw
+
+posix:
+        $(MAKE) all MYCFLAGS=-DLUA_USE_POSIX
+
+# Solaris x86 only!
+solaris:
+        $(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl"
+
+# list targets that do not create files (but not all makes understand .PHONY)
+.PHONY: all $(PLATS) default o a clean depend echo none cleaner distclean
+
+# DO NOT DELETE
+
+lapi.o: lapi.c lua.h luaconf.h lapi.h lobject.h llimits.h ldebug.h \
+  lstate.h ltm.h lzio.h lmem.h lcoco.h ldo.h lfunc.h lgc.h lstring.h \
+  ltable.h lundump.h lvm.h
+lauxlib.o: lauxlib.c lua.h luaconf.h lauxlib.h
+lbaselib.o: lbaselib.c lua.h luaconf.h lauxlib.h lualib.h lcoco.h
+lcoco.o: lcoco.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h \
+  lzio.h lmem.h lcoco.h ldo.h lvm.h lgc.h
+lcode.o: lcode.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
+  lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h lcoco.h \
+  ldo.h lgc.h ltable.h
+ldblib.o: ldblib.c lua.h luaconf.h lauxlib.h lualib.h
+ldebug.o: ldebug.c lua.h luaconf.h lapi.h lobject.h llimits.h lcode.h \
+  llex.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h \
+  lcoco.h ldo.h lfunc.h lstring.h lgc.h ltable.h lvm.h ljit.h
+ldo.o: ldo.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
+  lzio.h lmem.h lcoco.h ldo.h lfunc.h lgc.h lopcodes.h lparser.h \
+  lstring.h ltable.h lundump.h lvm.h ljit.h
+ldump.o: ldump.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h \
+  lzio.h lmem.h lcoco.h lundump.h
+lfunc.o: lfunc.c lua.h luaconf.h lfunc.h lobject.h llimits.h lgc.h lmem.h \
+  lstate.h ltm.h lzio.h lcoco.h ljit.h
+lgc.o: lgc.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
+  lzio.h lmem.h lcoco.h ldo.h lfunc.h lgc.h lstring.h ltable.h
+linit.o: linit.c lua.h luaconf.h lualib.h lauxlib.h
+liolib.o: liolib.c lua.h luaconf.h lauxlib.h lualib.h
+ljit_backend.o: ljit_backend.c lua.h luaconf.h lobject.h llimits.h \
+  lstate.h ltm.h lzio.h lmem.h lcoco.h ldo.h lfunc.h lgc.h lstring.h \
+  ltable.h lvm.h lopcodes.h ldebug.h ljit.h ljit_hints.h ljit_dasm.h \
+  ../dynasm/dasm_proto.h ljit_x86.h
+ljit_core.o: ljit_core.c lua.h luaconf.h lobject.h llimits.h lstate.h \
+  ltm.h lzio.h lmem.h lcoco.h ldo.h lstring.h lgc.h ltable.h ldebug.h \
+  lopcodes.h ljit.h ljit_hints.h luajit.h
+ljit_dasm.o: ljit_dasm.c lua.h luaconf.h ljit.h lobject.h llimits.h \
+  ljit_dasm.h ../dynasm/dasm_proto.h lmem.h ../dynasm/dasm_x86.h
+ljit_mem.o: ljit_mem.c lua.h luaconf.h lmem.h llimits.h ldo.h lobject.h \
+  lstate.h ltm.h lzio.h lcoco.h ljit.h ljit_dasm.h ../dynasm/dasm_proto.h
+ljitlib.o: ljitlib.c lua.h luaconf.h lauxlib.h luajit.h lualib.h \
+  lobject.h llimits.h lstate.h ltm.h lzio.h lmem.h lcoco.h lstring.h \
+  lgc.h ltable.h lfunc.h lopcodes.h ljit.h ljit_hints.h
+llex.o: llex.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h ltm.h \
+  lzio.h lmem.h lcoco.h llex.h lparser.h lstring.h lgc.h ltable.h
+lmathlib.o: lmathlib.c lua.h luaconf.h lauxlib.h lualib.h
+lmem.o: lmem.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
+  ltm.h lzio.h lmem.h lcoco.h ldo.h
+loadlib.o: loadlib.c lua.h luaconf.h lauxlib.h lualib.h luajit.h
+lobject.o: lobject.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h \
+  ltm.h lzio.h lmem.h lcoco.h lstring.h lgc.h lvm.h
+lopcodes.o: lopcodes.c lopcodes.h llimits.h lua.h luaconf.h
+loslib.o: loslib.c lua.h luaconf.h lauxlib.h lualib.h
+lparser.o: lparser.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
+  lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h lcoco.h \
+  ldo.h lfunc.h lstring.h lgc.h ltable.h
+lstate.o: lstate.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
+  ltm.h lzio.h lmem.h lcoco.h ldo.h lfunc.h lgc.h llex.h lstring.h \
+  ltable.h ljit.h
+lstring.o: lstring.c lua.h luaconf.h lmem.h llimits.h lobject.h lstate.h \
+  ltm.h lzio.h lcoco.h lstring.h lgc.h
+lstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h
+ltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
+  ltm.h lzio.h lmem.h lcoco.h ldo.h lgc.h ltable.h
+ltablib.o: ltablib.c lua.h luaconf.h lauxlib.h lualib.h
+ltm.o: ltm.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h lzio.h \
+  lmem.h lcoco.h lstring.h lgc.h ltable.h
+lua.o: lua.c lua.h luaconf.h lauxlib.h lualib.h luajit.h
+luac.o: luac.c lua.h luaconf.h lauxlib.h ldo.h lobject.h llimits.h \
+  lstate.h ltm.h lzio.h lmem.h lcoco.h lfunc.h lopcodes.h lstring.h lgc.h \
+  lundump.h
+lundump.o: lundump.c lua.h luaconf.h ldebug.h lstate.h lobject.h \
+  llimits.h ltm.h lzio.h lmem.h lcoco.h ldo.h lfunc.h lstring.h lgc.h \
+  lundump.h
+lvm.o: lvm.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
+  lzio.h lmem.h lcoco.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h \
+  lvm.h
+lzio.o: lzio.c lua.h luaconf.h llimits.h lmem.h lstate.h lobject.h ltm.h \
+  lzio.h lcoco.h
+print.o: print.c ldebug.h lstate.h lua.h luaconf.h lobject.h llimits.h \
+  ltm.h lzio.h lmem.h lcoco.h lopcodes.h lundump.h
+
+# (end of Makefile)
diff --git a/libraries/LuaJIT-1.1.7/src/lapi.c b/libraries/LuaJIT-1.1.7/src/lapi.c
new file mode 100644
index 0000000..e8347a2
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lapi.c
@@ -0,0 +1,1082 @@
+/*
+** $Id: lapi.c,v 2.55.1.5 2008/07/04 18:41:18 roberto Exp $
+** Lua API
+** See Copyright Notice in lua.h
+*/
+
+
+#include <assert.h>
+#include <math.h>
+#include <stdarg.h>
+#include <string.h>
+
+#define lapi_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lapi.h"
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lgc.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "ltm.h"
+#include "lundump.h"
+#include "lvm.h"
+
+
+
+const char lua_ident[] =
+  "$Lua: " LUA_RELEASE " " LUA_COPYRIGHT " $\n"
+  "$Authors: " LUA_AUTHORS " $\n"
+  "$URL: www.lua.org $\n";
+
+
+
+#define api_checknelems(L, n)   api_check(L, (n) <= (L->top - L->base))
+
+#define api_checkvalidindex(L, i)       api_check(L, (i) != luaO_nilobject)
+
+#define api_incr_top(L)   {api_check(L, L->top < L->ci->top); L->top++;}
+
+
+
+static TValue *index2adr (lua_State *L, int idx) {
+  if (idx > 0) {
+    TValue *o = L->base + (idx - 1);
+    api_check(L, idx <= L->ci->top - L->base);
+    if (o >= L->top) return cast(TValue *, luaO_nilobject);
+    else return o;
+  }
+  else if (idx > LUA_REGISTRYINDEX) {
+    api_check(L, idx != 0 && -idx <= L->top - L->base);
+    return L->top + idx;
+  }
+  else switch (idx) {  /* pseudo-indices */
+    case LUA_REGISTRYINDEX: return registry(L);
+    case LUA_ENVIRONINDEX: {
+      Closure *func = curr_func(L);
+      sethvalue(L, &L->env, func->c.env);
+      return &L->env;
+    }
+    case LUA_GLOBALSINDEX: return gt(L);
+    default: {
+      Closure *func = curr_func(L);
+      idx = LUA_GLOBALSINDEX - idx;
+      return (idx <= func->c.nupvalues)
+                ? &func->c.upvalue[idx-1]
+                : cast(TValue *, luaO_nilobject);
+    }
+  }
+}
+
+
+static Table *getcurrenv (lua_State *L) {
+  if (L->ci == L->base_ci)  /* no enclosing function? */
+    return hvalue(gt(L));  /* use global table as environment */
+  else {
+    Closure *func = curr_func(L);
+    return func->c.env;
+  }
+}
+
+
+void luaA_pushobject (lua_State *L, const TValue *o) {
+  setobj2s(L, L->top, o);
+  api_incr_top(L);
+}
+
+
+LUA_API int lua_checkstack (lua_State *L, int size) {
+  int res = 1;
+  lua_lock(L);
+  if (size > LUAI_MAXCSTACK || (L->top - L->base + size) > LUAI_MAXCSTACK)
+    res = 0;  /* stack overflow */
+  else if (size > 0) {
+    luaD_checkstack(L, size);
+    if (L->ci->top < L->top + size)
+      L->ci->top = L->top + size;
+  }
+  lua_unlock(L);
+  return res;
+}
+
+
+LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
+  StkId f, t;
+  if (from == to) return;
+  lua_lock(to);
+  api_checknelems(from, n);
+  api_check(from, G(from) == G(to));
+  api_check(from, to->ci->top - to->top >= n);
+  f = from->top;
+  t = to->top = to->top + n;
+  while (--n >= 0) setobj2s(to, --t, --f);
+  from->top = f;
+  lua_unlock(to);
+}
+
+
+LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {
+  lua_CFunction old;
+  lua_lock(L);
+  old = G(L)->panic;
+  G(L)->panic = panicf;
+  lua_unlock(L);
+  return old;
+}
+
+
+LUA_API lua_State *lua_newthread (lua_State *L) {
+  lua_State *L1;
+  lua_lock(L);
+  luaC_checkGC(L);
+  L1 = luaE_newthread(L);
+  setthvalue(L, L->top, L1);
+  api_incr_top(L);
+  lua_unlock(L);
+  luai_userstatethread(L, L1);
+  return L1;
+}
+
+
+
+/*
+** basic stack manipulation
+*/
+
+
+LUA_API int lua_gettop (lua_State *L) {
+  return cast_int(L->top - L->base);
+}
+
+
+LUA_API void lua_settop (lua_State *L, int idx) {
+  lua_lock(L);
+  if (idx >= 0) {
+    api_check(L, idx <= L->stack_last - L->base);
+    while (L->top < L->base + idx)
+      setnilvalue(L->top++);
+    L->top = L->base + idx;
+  }
+  else {
+    api_check(L, -(idx+1) <= (L->top - L->base));
+    L->top += idx+1;  /* `subtract' index (index is negative) */
+  }
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_remove (lua_State *L, int idx) {
+  StkId p;
+  lua_lock(L);
+  p = index2adr(L, idx);
+  api_checkvalidindex(L, p);
+  while (++p < L->top) setobjs2s(L, p-1, p);
+  L->top--;
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_insert (lua_State *L, int idx) {
+  StkId p;
+  StkId q;
+  lua_lock(L);
+  p = index2adr(L, idx);
+  api_checkvalidindex(L, p);
+  for (q = L->top; q>p; q--) setobjs2s(L, q, q-1);
+  setobjs2s(L, p, L->top);
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_replace (lua_State *L, int idx) {
+  StkId o;
+  lua_lock(L);
+  /* explicit test for incompatible code */
+  if (idx == LUA_ENVIRONINDEX && L->ci == L->base_ci)
+    luaG_runerror(L, "no calling environment");
+  api_checknelems(L, 1);
+  o = index2adr(L, idx);
+  api_checkvalidindex(L, o);
+  if (idx == LUA_ENVIRONINDEX) {
+    Closure *func = curr_func(L);
+    api_check(L, ttistable(L->top - 1)); 
+    func->c.env = hvalue(L->top - 1);
+    luaC_barrier(L, func, L->top - 1);
+  }
+  else {
+    setobj(L, o, L->top - 1);
+    if (idx < LUA_GLOBALSINDEX)  /* function upvalue? */
+      luaC_barrier(L, curr_func(L), L->top - 1);
+  }
+  L->top--;
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_pushvalue (lua_State *L, int idx) {
+  lua_lock(L);
+  setobj2s(L, L->top, index2adr(L, idx));
+  api_incr_top(L);
+  lua_unlock(L);
+}
+
+
+
+/*
+** access functions (stack -> C)
+*/
+
+
+LUA_API int lua_type (lua_State *L, int idx) {
+  StkId o = index2adr(L, idx);
+  return (o == luaO_nilobject) ? LUA_TNONE : ttype(o);
+}
+
+
+LUA_API const char *lua_typename (lua_State *L, int t) {
+  UNUSED(L);
+  return (t == LUA_TNONE) ? "no value" : luaT_typenames[t];
+}
+
+
+LUA_API int lua_iscfunction (lua_State *L, int idx) {
+  StkId o = index2adr(L, idx);
+  return iscfunction(o);
+}
+
+
+LUA_API int lua_isnumber (lua_State *L, int idx) {
+  TValue n;
+  const TValue *o = index2adr(L, idx);
+  return tonumber(o, &n);
+}
+
+
+LUA_API int lua_isstring (lua_State *L, int idx) {
+  int t = lua_type(L, idx);
+  return (t == LUA_TSTRING || t == LUA_TNUMBER);
+}
+
+
+LUA_API int lua_isuserdata (lua_State *L, int idx) {
+  const TValue *o = index2adr(L, idx);
+  return (ttisuserdata(o) || ttislightuserdata(o));
+}
+
+
+LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
+  StkId o1 = index2adr(L, index1);
+  StkId o2 = index2adr(L, index2);
+  return (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
+         : luaO_rawequalObj(o1, o2);
+}
+
+
+LUA_API int lua_equal (lua_State *L, int index1, int index2) {
+  StkId o1, o2;
+  int i;
+  lua_lock(L);  /* may call tag method */
+  o1 = index2adr(L, index1);
+  o2 = index2adr(L, index2);
+  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0 : equalobj(L, o1, o2);
+  lua_unlock(L);
+  return i;
+}
+
+
+LUA_API int lua_lessthan (lua_State *L, int index1, int index2) {
+  StkId o1, o2;
+  int i;
+  lua_lock(L);  /* may call tag method */
+  o1 = index2adr(L, index1);
+  o2 = index2adr(L, index2);
+  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
+       : luaV_lessthan(L, o1, o2);
+  lua_unlock(L);
+  return i;
+}
+
+
+
+LUA_API lua_Number lua_tonumber (lua_State *L, int idx) {
+  TValue n;
+  const TValue *o = index2adr(L, idx);
+  if (tonumber(o, &n))
+    return nvalue(o);
+  else
+    return 0;
+}
+
+
+LUA_API lua_Integer lua_tointeger (lua_State *L, int idx) {
+  TValue n;
+  const TValue *o = index2adr(L, idx);
+  if (tonumber(o, &n)) {
+    lua_Integer res;
+    lua_Number num = nvalue(o);
+    lua_number2integer(res, num);
+    return res;
+  }
+  else
+    return 0;
+}
+
+
+LUA_API int lua_toboolean (lua_State *L, int idx) {
+  const TValue *o = index2adr(L, idx);
+  return !l_isfalse(o);
+}
+
+
+LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
+  StkId o = index2adr(L, idx);
+  if (!ttisstring(o)) {
+    lua_lock(L);  /* `luaV_tostring' may create a new string */
+    if (!luaV_tostring(L, o)) {  /* conversion failed? */
+      if (len != NULL) *len = 0;
+      lua_unlock(L);
+      return NULL;
+    }
+    luaC_checkGC(L);
+    o = index2adr(L, idx);  /* previous call may reallocate the stack */
+    lua_unlock(L);
+  }
+  if (len != NULL) *len = tsvalue(o)->len;
+  return svalue(o);
+}
+
+
+LUA_API size_t lua_objlen (lua_State *L, int idx) {
+  StkId o = index2adr(L, idx);
+  switch (ttype(o)) {
+    case LUA_TSTRING: return tsvalue(o)->len;
+    case LUA_TUSERDATA: return uvalue(o)->len;
+    case LUA_TTABLE: return luaH_getn(hvalue(o));
+    case LUA_TNUMBER: {
+      size_t l;
+      lua_lock(L);  /* `luaV_tostring' may create a new string */
+      l = (luaV_tostring(L, o) ? tsvalue(o)->len : 0);
+      lua_unlock(L);
+      return l;
+    }
+    default: return 0;
+  }
+}
+
+
+LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
+  StkId o = index2adr(L, idx);
+  return (!iscfunction(o)) ? NULL : clvalue(o)->c.f;
+}
+
+
+LUA_API void *lua_touserdata (lua_State *L, int idx) {
+  StkId o = index2adr(L, idx);
+  switch (ttype(o)) {
+    case LUA_TUSERDATA: return (rawuvalue(o) + 1);
+    case LUA_TLIGHTUSERDATA: return pvalue(o);
+    default: return NULL;
+  }
+}
+
+
+LUA_API lua_State *lua_tothread (lua_State *L, int idx) {
+  StkId o = index2adr(L, idx);
+  return (!ttisthread(o)) ? NULL : thvalue(o);
+}
+
+
+LUA_API const void *lua_topointer (lua_State *L, int idx) {
+  StkId o = index2adr(L, idx);
+  switch (ttype(o)) {
+    case LUA_TTABLE: return hvalue(o);
+    case LUA_TFUNCTION: return clvalue(o);
+    case LUA_TTHREAD: return thvalue(o);
+    case LUA_TUSERDATA:
+    case LUA_TLIGHTUSERDATA:
+      return lua_touserdata(L, idx);
+    default: return NULL;
+  }
+}
+
+
+
+/*
+** push functions (C -> stack)
+*/
+
+
+LUA_API void lua_pushnil (lua_State *L) {
+  lua_lock(L);
+  setnilvalue(L->top);
+  api_incr_top(L);
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
+  lua_lock(L);
+  setnvalue(L->top, n);
+  api_incr_top(L);
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
+  lua_lock(L);
+  setnvalue(L->top, cast_num(n));
+  api_incr_top(L);
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
+  lua_lock(L);
+  luaC_checkGC(L);
+  setsvalue2s(L, L->top, luaS_newlstr(L, s, len));
+  api_incr_top(L);
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_pushstring (lua_State *L, const char *s) {
+  if (s == NULL)
+    lua_pushnil(L);
+  else
+    lua_pushlstring(L, s, strlen(s));
+}
+
+
+LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
+                                      va_list argp) {
+  const char *ret;
+  lua_lock(L);
+  luaC_checkGC(L);
+  ret = luaO_pushvfstring(L, fmt, argp);
+  lua_unlock(L);
+  return ret;
+}
+
+
+LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {
+  const char *ret;
+  va_list argp;
+  lua_lock(L);
+  luaC_checkGC(L);
+  va_start(argp, fmt);
+  ret = luaO_pushvfstring(L, fmt, argp);
+  va_end(argp);
+  lua_unlock(L);
+  return ret;
+}
+
+
+LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
+  Closure *cl;
+  lua_lock(L);
+  luaC_checkGC(L);
+  api_checknelems(L, n);
+  cl = luaF_newCclosure(L, n, getcurrenv(L));
+  cl->c.f = fn;
+  L->top -= n;
+  while (n--)
+    setobj2n(L, &cl->c.upvalue[n], L->top+n);
+  setclvalue(L, L->top, cl);
+  lua_assert(iswhite(obj2gco(cl)));
+  api_incr_top(L);
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_pushboolean (lua_State *L, int b) {
+  lua_lock(L);
+  setbvalue(L->top, (b != 0));  /* ensure that true is 1 */
+  api_incr_top(L);
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_pushlightuserdata (lua_State *L, void *p) {
+  lua_lock(L);
+  setpvalue(L->top, p);
+  api_incr_top(L);
+  lua_unlock(L);
+}
+
+
+LUA_API int lua_pushthread (lua_State *L) {
+  lua_lock(L);
+  setthvalue(L, L->top, L);
+  api_incr_top(L);
+  lua_unlock(L);
+  return (G(L)->mainthread == L);
+}
+
+
+
+/*
+** get functions (Lua -> stack)
+*/
+
+
+LUA_API void lua_gettable (lua_State *L, int idx) {
+  StkId t;
+  lua_lock(L);
+  t = index2adr(L, idx);
+  api_checkvalidindex(L, t);
+  luaV_gettable(L, t, L->top - 1, L->top - 1);
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
+  StkId t;
+  TValue key;
+  lua_lock(L);
+  t = index2adr(L, idx);
+  api_checkvalidindex(L, t);
+  setsvalue(L, &key, luaS_new(L, k));
+  luaV_gettable(L, t, &key, L->top);
+  api_incr_top(L);
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_rawget (lua_State *L, int idx) {
+  StkId t;
+  lua_lock(L);
+  t = index2adr(L, idx);
+  api_check(L, ttistable(t));
+  setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {
+  StkId o;
+  lua_lock(L);
+  o = index2adr(L, idx);
+  api_check(L, ttistable(o));
+  setobj2s(L, L->top, luaH_getnum(hvalue(o), n));
+  api_incr_top(L);
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {
+  lua_lock(L);
+  luaC_checkGC(L);
+  sethvalue(L, L->top, luaH_new(L, narray, nrec));
+  api_incr_top(L);
+  lua_unlock(L);
+}
+
+
+LUA_API int lua_getmetatable (lua_State *L, int objindex) {
+  const TValue *obj;
+  Table *mt = NULL;
+  int res;
+  lua_lock(L);
+  obj = index2adr(L, objindex);
+  switch (ttype(obj)) {
+    case LUA_TTABLE:
+      mt = hvalue(obj)->metatable;
+      break;
+    case LUA_TUSERDATA:
+      mt = uvalue(obj)->metatable;
+      break;
+    default:
+      mt = G(L)->mt[ttype(obj)];
+      break;
+  }
+  if (mt == NULL)
+    res = 0;
+  else {
+    sethvalue(L, L->top, mt);
+    api_incr_top(L);
+    res = 1;
+  }
+  lua_unlock(L);
+  return res;
+}
+
+
+LUA_API void lua_getfenv (lua_State *L, int idx) {
+  StkId o;
+  lua_lock(L);
+  o = index2adr(L, idx);
+  api_checkvalidindex(L, o);
+  switch (ttype(o)) {
+    case LUA_TFUNCTION:
+      sethvalue(L, L->top, clvalue(o)->c.env);
+      break;
+    case LUA_TUSERDATA:
+      sethvalue(L, L->top, uvalue(o)->env);
+      break;
+    case LUA_TTHREAD:
+      setobj2s(L, L->top,  gt(thvalue(o)));
+      break;
+    default:
+      setnilvalue(L->top);
+      break;
+  }
+  api_incr_top(L);
+  lua_unlock(L);
+}
+
+
+/*
+** set functions (stack -> Lua)
+*/
+
+
+LUA_API void lua_settable (lua_State *L, int idx) {
+  StkId t;
+  lua_lock(L);
+  api_checknelems(L, 2);
+  t = index2adr(L, idx);
+  api_checkvalidindex(L, t);
+  luaV_settable(L, t, L->top - 2, L->top - 1);
+  L->top -= 2;  /* pop index and value */
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
+  StkId t;
+  TValue key;
+  lua_lock(L);
+  api_checknelems(L, 1);
+  t = index2adr(L, idx);
+  api_checkvalidindex(L, t);
+  setsvalue(L, &key, luaS_new(L, k));
+  luaV_settable(L, t, &key, L->top - 1);
+  L->top--;  /* pop value */
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_rawset (lua_State *L, int idx) {
+  StkId t;
+  lua_lock(L);
+  api_checknelems(L, 2);
+  t = index2adr(L, idx);
+  api_check(L, ttistable(t));
+  setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);
+  luaC_barriert(L, hvalue(t), L->top-1);
+  L->top -= 2;
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_rawseti (lua_State *L, int idx, int n) {
+  StkId o;
+  lua_lock(L);
+  api_checknelems(L, 1);
+  o = index2adr(L, idx);
+  api_check(L, ttistable(o));
+  setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top-1);
+  luaC_barriert(L, hvalue(o), L->top-1);
+  L->top--;
+  lua_unlock(L);
+}
+
+
+LUA_API int lua_setmetatable (lua_State *L, int objindex) {
+  TValue *obj;
+  Table *mt;
+  lua_lock(L);
+  api_checknelems(L, 1);
+  obj = index2adr(L, objindex);
+  api_checkvalidindex(L, obj);
+  if (ttisnil(L->top - 1))
+    mt = NULL;
+  else {
+    api_check(L, ttistable(L->top - 1));
+    mt = hvalue(L->top - 1);
+  }
+  switch (ttype(obj)) {
+    case LUA_TTABLE: {
+      hvalue(obj)->metatable = mt;
+      if (mt)
+        luaC_objbarriert(L, hvalue(obj), mt);
+      break;
+    }
+    case LUA_TUSERDATA: {
+      uvalue(obj)->metatable = mt;
+      if (mt)
+        luaC_objbarrier(L, rawuvalue(obj), mt);
+      break;
+    }
+    default: {
+      G(L)->mt[ttype(obj)] = mt;
+      break;
+    }
+  }
+  L->top--;
+  lua_unlock(L);
+  return 1;
+}
+
+
+LUA_API int lua_setfenv (lua_State *L, int idx) {
+  StkId o;
+  int res = 1;
+  lua_lock(L);
+  api_checknelems(L, 1);
+  o = index2adr(L, idx);
+  api_checkvalidindex(L, o);
+  api_check(L, ttistable(L->top - 1));
+  switch (ttype(o)) {
+    case LUA_TFUNCTION:
+      clvalue(o)->c.env = hvalue(L->top - 1);
+      break;
+    case LUA_TUSERDATA:
+      uvalue(o)->env = hvalue(L->top - 1);
+      break;
+    case LUA_TTHREAD:
+      sethvalue(L, gt(thvalue(o)), hvalue(L->top - 1));
+      break;
+    default:
+      res = 0;
+      break;
+  }
+  if (res) luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));
+  L->top--;
+  lua_unlock(L);
+  return res;
+}
+
+
+/*
+** `load' and `call' functions (run Lua code)
+*/
+
+
+#define adjustresults(L,nres) \
+    { if (nres == LUA_MULTRET && L->top >= L->ci->top) L->ci->top = L->top; }
+
+
+#define checkresults(L,na,nr) \
+     api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)))
+        
+
+LUA_API void lua_call (lua_State *L, int nargs, int nresults) {
+  StkId func;
+  lua_lock(L);
+  api_checknelems(L, nargs+1);
+  checkresults(L, nargs, nresults);
+  func = L->top - (nargs+1);
+  luaD_call(L, func, nresults);
+  adjustresults(L, nresults);
+  lua_unlock(L);
+}
+
+
+
+/*
+** Execute a protected call.
+*/
+struct CallS {  /* data to `f_call' */
+  StkId func;
+  int nresults;
+};
+
+
+static void f_call (lua_State *L, void *ud) {
+  struct CallS *c = cast(struct CallS *, ud);
+  luaD_call(L, c->func, c->nresults);
+}
+
+
+
+LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) {
+  struct CallS c;
+  int status;
+  ptrdiff_t func;
+  lua_lock(L);
+  api_checknelems(L, nargs+1);
+  checkresults(L, nargs, nresults);
+  if (errfunc == 0)
+    func = 0;
+  else {
+    StkId o = index2adr(L, errfunc);
+    api_checkvalidindex(L, o);
+    func = savestack(L, o);
+  }
+  c.func = L->top - (nargs+1);  /* function to be called */
+  c.nresults = nresults;
+  status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
+  adjustresults(L, nresults);
+  lua_unlock(L);
+  return status;
+}
+
+
+/*
+** Execute a protected C call.
+*/
+struct CCallS {  /* data to `f_Ccall' */
+  lua_CFunction func;
+  void *ud;
+};
+
+
+static void f_Ccall (lua_State *L, void *ud) {
+  struct CCallS *c = cast(struct CCallS *, ud);
+  Closure *cl;
+  cl = luaF_newCclosure(L, 0, getcurrenv(L));
+  cl->c.f = c->func;
+  setclvalue(L, L->top, cl);  /* push function */
+  api_incr_top(L);
+  setpvalue(L->top, c->ud);  /* push only argument */
+  api_incr_top(L);
+  luaD_call(L, L->top - 2, 0);
+}
+
+
+LUA_API int lua_cpcall (lua_State *L, lua_CFunction func, void *ud) {
+  struct CCallS c;
+  int status;
+  lua_lock(L);
+  c.func = func;
+  c.ud = ud;
+  status = luaD_pcall(L, f_Ccall, &c, savestack(L, L->top), 0);
+  lua_unlock(L);
+  return status;
+}
+
+
+LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,
+                      const char *chunkname) {
+  ZIO z;
+  int status;
+  lua_lock(L);
+  if (!chunkname) chunkname = "?";
+  luaZ_init(L, &z, reader, data);
+  status = luaD_protectedparser(L, &z, chunkname);
+  lua_unlock(L);
+  return status;
+}
+
+
+LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) {
+  int status;
+  TValue *o;
+  lua_lock(L);
+  api_checknelems(L, 1);
+  o = L->top - 1;
+  if (isLfunction(o))
+    status = luaU_dump(L, clvalue(o)->l.p, writer, data, 0);
+  else
+    status = 1;
+  lua_unlock(L);
+  return status;
+}
+
+
+LUA_API int  lua_status (lua_State *L) {
+  return L->status;
+}
+
+
+/*
+** Garbage-collection function
+*/
+
+LUA_API int lua_gc (lua_State *L, int what, int data) {
+  int res = 0;
+  global_State *g;
+  lua_lock(L);
+  g = G(L);
+  switch (what) {
+    case LUA_GCSTOP: {
+      g->GCthreshold = MAX_LUMEM;
+      break;
+    }
+    case LUA_GCRESTART: {
+      g->GCthreshold = g->totalbytes;
+      break;
+    }
+    case LUA_GCCOLLECT: {
+      luaC_fullgc(L);
+      break;
+    }
+    case LUA_GCCOUNT: {
+      /* GC values are expressed in Kbytes: #bytes/2^10 */
+      res = cast_int(g->totalbytes >> 10);
+      break;
+    }
+    case LUA_GCCOUNTB: {
+      res = cast_int(g->totalbytes & 0x3ff);
+      break;
+    }
+    case LUA_GCSTEP: {
+      lu_mem a = (cast(lu_mem, data) << 10);
+      if (a <= g->totalbytes)
+        g->GCthreshold = g->totalbytes - a;
+      else
+        g->GCthreshold = 0;
+      while (g->GCthreshold <= g->totalbytes) {
+        luaC_step(L);
+        if (g->gcstate == GCSpause) {  /* end of cycle? */
+          res = 1;  /* signal it */
+          break;
+        }
+      }
+      break;
+    }
+    case LUA_GCSETPAUSE: {
+      res = g->gcpause;
+      g->gcpause = data;
+      break;
+    }
+    case LUA_GCSETSTEPMUL: {
+      res = g->gcstepmul;
+      g->gcstepmul = data;
+      break;
+    }
+    default: res = -1;  /* invalid option */
+  }
+  lua_unlock(L);
+  return res;
+}
+
+
+
+/*
+** miscellaneous functions
+*/
+
+
+LUA_API int lua_error (lua_State *L) {
+  lua_lock(L);
+  api_checknelems(L, 1);
+  luaG_errormsg(L);
+  lua_unlock(L);
+  return 0;  /* to avoid warnings */
+}
+
+
+LUA_API int lua_next (lua_State *L, int idx) {
+  StkId t;
+  int more;
+  lua_lock(L);
+  t = index2adr(L, idx);
+  api_check(L, ttistable(t));
+  more = luaH_next(L, hvalue(t), L->top - 1);
+  if (more) {
+    api_incr_top(L);
+  }
+  else  /* no more elements */
+    L->top -= 1;  /* remove key */
+  lua_unlock(L);
+  return more;
+}
+
+
+LUA_API void lua_concat (lua_State *L, int n) {
+  lua_lock(L);
+  api_checknelems(L, n);
+  if (n >= 2) {
+    luaC_checkGC(L);
+    luaV_concat(L, n, cast_int(L->top - L->base) - 1);
+    L->top -= (n-1);
+  }
+  else if (n == 0) {  /* push empty string */
+    setsvalue2s(L, L->top, luaS_newlstr(L, "", 0));
+    api_incr_top(L);
+  }
+  /* else n == 1; nothing to do */
+  lua_unlock(L);
+}
+
+
+LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) {
+  lua_Alloc f;
+  lua_lock(L);
+  if (ud) *ud = G(L)->ud;
+  f = G(L)->frealloc;
+  lua_unlock(L);
+  return f;
+}
+
+
+LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) {
+  lua_lock(L);
+  G(L)->ud = ud;
+  G(L)->frealloc = f;
+  lua_unlock(L);
+}
+
+
+LUA_API void *lua_newuserdata (lua_State *L, size_t size) {
+  Udata *u;
+  lua_lock(L);
+  luaC_checkGC(L);
+  u = luaS_newudata(L, size, getcurrenv(L));
+  setuvalue(L, L->top, u);
+  api_incr_top(L);
+  lua_unlock(L);
+  return u + 1;
+}
+
+
+
+
+static const char *aux_upvalue (StkId fi, int n, TValue **val) {
+  Closure *f;
+  if (!ttisfunction(fi)) return NULL;
+  f = clvalue(fi);
+  if (f->c.isC) {
+    if (!(1 <= n && n <= f->c.nupvalues)) return NULL;
+    *val = &f->c.upvalue[n-1];
+    return "";
+  }
+  else {
+    Proto *p = f->l.p;
+    if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
+    *val = f->l.upvals[n-1]->v;
+    return getstr(p->upvalues[n-1]);
+  }
+}
+
+
+LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {
+  const char *name;
+  TValue *val;
+  lua_lock(L);
+  name = aux_upvalue(index2adr(L, funcindex), n, &val);
+  if (name) {
+    setobj2s(L, L->top, val);
+    api_incr_top(L);
+  }
+  lua_unlock(L);
+  return name;
+}
+
+
+LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
+  const char *name;
+  TValue *val;
+  StkId fi;
+  lua_lock(L);
+  fi = index2adr(L, funcindex);
+  api_checknelems(L, 1);
+  name = aux_upvalue(fi, n, &val);
+  if (name) {
+    L->top--;
+    setobj(L, val, L->top);
+    luaC_barrier(L, clvalue(fi), L->top);
+  }
+  lua_unlock(L);
+  return name;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lapi.h b/libraries/LuaJIT-1.1.7/src/lapi.h
new file mode 100644
index 0000000..2c3fab2
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lapi.h
@@ -0,0 +1,16 @@
+/*
+** $Id: lapi.h,v 2.2.1.1 2007/12/27 13:02:25 roberto Exp $
+** Auxiliary functions from Lua API
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lapi_h
+#define lapi_h
+
+
+#include "lobject.h"
+
+
+LUAI_FUNC void luaA_pushobject (lua_State *L, const TValue *o);
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lauxlib.c b/libraries/LuaJIT-1.1.7/src/lauxlib.c
new file mode 100644
index 0000000..10f14e2
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lauxlib.c
@@ -0,0 +1,652 @@
+/*
+** $Id: lauxlib.c,v 1.159.1.3 2008/01/21 13:20:51 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+/* This file uses only the official API of Lua.
+** Any function declared here could be written as an application function.
+*/
+
+#define lauxlib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+
+
+#define FREELIST_REF    0       /* free list of references */
+
+
+/* convert a stack index to positive */
+#define abs_index(L, i)         ((i) > 0 || (i) <= LUA_REGISTRYINDEX ? (i) : \
+                                        lua_gettop(L) + (i) + 1)
+
+
+/*
+** {======================================================
+** Error-report functions
+** =======================================================
+*/
+
+
+LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
+  lua_Debug ar;
+  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
+    return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
+  lua_getinfo(L, "n", &ar);
+  if (strcmp(ar.namewhat, "method") == 0) {
+    narg--;  /* do not count `self' */
+    if (narg == 0)  /* error is in the self argument itself? */
+      return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
+                           ar.name, extramsg);
+  }
+  if (ar.name == NULL)
+    ar.name = "?";
+  return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",
+                        narg, ar.name, extramsg);
+}
+
+
+LUALIB_API int luaL_typerror (lua_State *L, int narg, const char *tname) {
+  const char *msg = lua_pushfstring(L, "%s expected, got %s",
+                                    tname, luaL_typename(L, narg));
+  return luaL_argerror(L, narg, msg);
+}
+
+
+static void tag_error (lua_State *L, int narg, int tag) {
+  luaL_typerror(L, narg, lua_typename(L, tag));
+}
+
+
+LUALIB_API void luaL_where (lua_State *L, int level) {
+  lua_Debug ar;
+  if (lua_getstack(L, level, &ar)) {  /* check function at level */
+    lua_getinfo(L, "Sl", &ar);  /* get info about it */
+    if (ar.currentline > 0) {  /* is there info? */
+      lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline);
+      return;
+    }
+  }
+  lua_pushliteral(L, "");  /* else, no information available... */
+}
+
+
+LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
+  va_list argp;
+  va_start(argp, fmt);
+  luaL_where(L, 1);
+  lua_pushvfstring(L, fmt, argp);
+  va_end(argp);
+  lua_concat(L, 2);
+  return lua_error(L);
+}
+
+/* }====================================================== */
+
+
+LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
+                                 const char *const lst[]) {
+  const char *name = (def) ? luaL_optstring(L, narg, def) :
+                             luaL_checkstring(L, narg);
+  int i;
+  for (i=0; lst[i]; i++)
+    if (strcmp(lst[i], name) == 0)
+      return i;
+  return luaL_argerror(L, narg,
+                       lua_pushfstring(L, "invalid option " LUA_QS, name));
+}
+
+
+LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
+  lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get registry.name */
+  if (!lua_isnil(L, -1))  /* name already in use? */
+    return 0;  /* leave previous value on top, but return 0 */
+  lua_pop(L, 1);
+  lua_newtable(L);  /* create metatable */
+  lua_pushvalue(L, -1);
+  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
+  return 1;
+}
+
+
+LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
+  void *p = lua_touserdata(L, ud);
+  if (p != NULL) {  /* value is a userdata? */
+    if (lua_getmetatable(L, ud)) {  /* does it have a metatable? */
+      lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get correct metatable */
+      if (lua_rawequal(L, -1, -2)) {  /* does it have the correct mt? */
+        lua_pop(L, 2);  /* remove both metatables */
+        return p;
+      }
+    }
+  }
+  luaL_typerror(L, ud, tname);  /* else error */
+  return NULL;  /* to avoid warnings */
+}
+
+
+LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *mes) {
+  if (!lua_checkstack(L, space))
+    luaL_error(L, "stack overflow (%s)", mes);
+}
+
+
+LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) {
+  if (lua_type(L, narg) != t)
+    tag_error(L, narg, t);
+}
+
+
+LUALIB_API void luaL_checkany (lua_State *L, int narg) {
+  if (lua_type(L, narg) == LUA_TNONE)
+    luaL_argerror(L, narg, "value expected");
+}
+
+
+LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) {
+  const char *s = lua_tolstring(L, narg, len);
+  if (!s) tag_error(L, narg, LUA_TSTRING);
+  return s;
+}
+
+
+LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,
+                                        const char *def, size_t *len) {
+  if (lua_isnoneornil(L, narg)) {
+    if (len)
+      *len = (def ? strlen(def) : 0);
+    return def;
+  }
+  else return luaL_checklstring(L, narg, len);
+}
+
+
+LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
+  lua_Number d = lua_tonumber(L, narg);
+  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
+    tag_error(L, narg, LUA_TNUMBER);
+  return d;
+}
+
+
+LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) {
+  return luaL_opt(L, luaL_checknumber, narg, def);
+}
+
+
+LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
+  lua_Integer d = lua_tointeger(L, narg);
+  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
+    tag_error(L, narg, LUA_TNUMBER);
+  return d;
+}
+
+
+LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg,
+                                                      lua_Integer def) {
+  return luaL_opt(L, luaL_checkinteger, narg, def);
+}
+
+
+LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
+  if (!lua_getmetatable(L, obj))  /* no metatable? */
+    return 0;
+  lua_pushstring(L, event);
+  lua_rawget(L, -2);
+  if (lua_isnil(L, -1)) {
+    lua_pop(L, 2);  /* remove metatable and metafield */
+    return 0;
+  }
+  else {
+    lua_remove(L, -2);  /* remove only metatable */
+    return 1;
+  }
+}
+
+
+LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
+  obj = abs_index(L, obj);
+  if (!luaL_getmetafield(L, obj, event))  /* no metafield? */
+    return 0;
+  lua_pushvalue(L, obj);
+  lua_call(L, 1, 1);
+  return 1;
+}
+
+
+LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
+                                const luaL_Reg *l) {
+  luaI_openlib(L, libname, l, 0);
+}
+
+
+static int libsize (const luaL_Reg *l) {
+  int size = 0;
+  for (; l->name; l++) size++;
+  return size;
+}
+
+
+LUALIB_API void luaI_openlib (lua_State *L, const char *libname,
+                              const luaL_Reg *l, int nup) {
+  if (libname) {
+    int size = libsize(l);
+    /* check whether lib already exists */
+    luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1);
+    lua_getfield(L, -1, libname);  /* get _LOADED[libname] */
+    if (!lua_istable(L, -1)) {  /* not found? */
+      lua_pop(L, 1);  /* remove previous result */
+      /* try global variable (and create one if it does not exist) */
+      if (luaL_findtable(L, LUA_GLOBALSINDEX, libname, size) != NULL)
+        luaL_error(L, "name conflict for module " LUA_QS, libname);
+      lua_pushvalue(L, -1);
+      lua_setfield(L, -3, libname);  /* _LOADED[libname] = new table */
+    }
+    lua_remove(L, -2);  /* remove _LOADED table */
+    lua_insert(L, -(nup+1));  /* move library table to below upvalues */
+  }
+  for (; l->name; l++) {
+    int i;
+    for (i=0; i<nup; i++)  /* copy upvalues to the top */
+      lua_pushvalue(L, -nup);
+    lua_pushcclosure(L, l->func, nup);
+    lua_setfield(L, -(nup+2), l->name);
+  }
+  lua_pop(L, nup);  /* remove upvalues */
+}
+
+
+
+/*
+** {======================================================
+** getn-setn: size for arrays
+** =======================================================
+*/
+
+#if defined(LUA_COMPAT_GETN)
+
+static int checkint (lua_State *L, int topop) {
+  int n = (lua_type(L, -1) == LUA_TNUMBER) ? lua_tointeger(L, -1) : -1;
+  lua_pop(L, topop);
+  return n;
+}
+
+
+static void getsizes (lua_State *L) {
+  lua_getfield(L, LUA_REGISTRYINDEX, "LUA_SIZES");
+  if (lua_isnil(L, -1)) {  /* no `size' table? */
+    lua_pop(L, 1);  /* remove nil */
+    lua_newtable(L);  /* create it */
+    lua_pushvalue(L, -1);  /* `size' will be its own metatable */
+    lua_setmetatable(L, -2);
+    lua_pushliteral(L, "kv");
+    lua_setfield(L, -2, "__mode");  /* metatable(N).__mode = "kv" */
+    lua_pushvalue(L, -1);
+    lua_setfield(L, LUA_REGISTRYINDEX, "LUA_SIZES");  /* store in register */
+  }
+}
+
+
+LUALIB_API void luaL_setn (lua_State *L, int t, int n) {
+  t = abs_index(L, t);
+  lua_pushliteral(L, "n");
+  lua_rawget(L, t);
+  if (checkint(L, 1) >= 0) {  /* is there a numeric field `n'? */
+    lua_pushliteral(L, "n");  /* use it */
+    lua_pushinteger(L, n);
+    lua_rawset(L, t);
+  }
+  else {  /* use `sizes' */
+    getsizes(L);
+    lua_pushvalue(L, t);
+    lua_pushinteger(L, n);
+    lua_rawset(L, -3);  /* sizes[t] = n */
+    lua_pop(L, 1);  /* remove `sizes' */
+  }
+}
+
+
+LUALIB_API int luaL_getn (lua_State *L, int t) {
+  int n;
+  t = abs_index(L, t);
+  lua_pushliteral(L, "n");  /* try t.n */
+  lua_rawget(L, t);
+  if ((n = checkint(L, 1)) >= 0) return n;
+  getsizes(L);  /* else try sizes[t] */
+  lua_pushvalue(L, t);
+  lua_rawget(L, -2);
+  if ((n = checkint(L, 2)) >= 0) return n;
+  return (int)lua_objlen(L, t);
+}
+
+#endif
+
+/* }====================================================== */
+
+
+
+LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p,
+                                                               const char *r) {
+  const char *wild;
+  size_t l = strlen(p);
+  luaL_Buffer b;
+  luaL_buffinit(L, &b);
+  while ((wild = strstr(s, p)) != NULL) {
+    luaL_addlstring(&b, s, wild - s);  /* push prefix */
+    luaL_addstring(&b, r);  /* push replacement in place of pattern */
+    s = wild + l;  /* continue after `p' */
+  }
+  luaL_addstring(&b, s);  /* push last suffix */
+  luaL_pushresult(&b);
+  return lua_tostring(L, -1);
+}
+
+
+LUALIB_API const char *luaL_findtable (lua_State *L, int idx,
+                                       const char *fname, int szhint) {
+  const char *e;
+  lua_pushvalue(L, idx);
+  do {
+    e = strchr(fname, '.');
+    if (e == NULL) e = fname + strlen(fname);
+    lua_pushlstring(L, fname, e - fname);
+    lua_rawget(L, -2);
+    if (lua_isnil(L, -1)) {  /* no such field? */
+      lua_pop(L, 1);  /* remove this nil */
+      lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */
+      lua_pushlstring(L, fname, e - fname);
+      lua_pushvalue(L, -2);
+      lua_settable(L, -4);  /* set new table into field */
+    }
+    else if (!lua_istable(L, -1)) {  /* field has a non-table value? */
+      lua_pop(L, 2);  /* remove table and value */
+      return fname;  /* return problematic part of the name */
+    }
+    lua_remove(L, -2);  /* remove previous table */
+    fname = e + 1;
+  } while (*e == '.');
+  return NULL;
+}
+
+
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+
+#define bufflen(B)      ((B)->p - (B)->buffer)
+#define bufffree(B)     ((size_t)(LUAL_BUFFERSIZE - bufflen(B)))
+
+#define LIMIT   (LUA_MINSTACK/2)
+
+
+static int emptybuffer (luaL_Buffer *B) {
+  size_t l = bufflen(B);
+  if (l == 0) return 0;  /* put nothing on stack */
+  else {
+    lua_pushlstring(B->L, B->buffer, l);
+    B->p = B->buffer;
+    B->lvl++;
+    return 1;
+  }
+}
+
+
+static void adjuststack (luaL_Buffer *B) {
+  if (B->lvl > 1) {
+    lua_State *L = B->L;
+    int toget = 1;  /* number of levels to concat */
+    size_t toplen = lua_strlen(L, -1);
+    do {
+      size_t l = lua_strlen(L, -(toget+1));
+      if (B->lvl - toget + 1 >= LIMIT || toplen > l) {
+        toplen += l;
+        toget++;
+      }
+      else break;
+    } while (toget < B->lvl);
+    lua_concat(L, toget);
+    B->lvl = B->lvl - toget + 1;
+  }
+}
+
+
+LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {
+  if (emptybuffer(B))
+    adjuststack(B);
+  return B->buffer;
+}
+
+
+LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
+  while (l--)
+    luaL_addchar(B, *s++);
+}
+
+
+LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) {
+  luaL_addlstring(B, s, strlen(s));
+}
+
+
+LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
+  emptybuffer(B);
+  lua_concat(B->L, B->lvl);
+  B->lvl = 1;
+}
+
+
+LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
+  lua_State *L = B->L;
+  size_t vl;
+  const char *s = lua_tolstring(L, -1, &vl);
+  if (vl <= bufffree(B)) {  /* fit into buffer? */
+    memcpy(B->p, s, vl);  /* put it there */
+    B->p += vl;
+    lua_pop(L, 1);  /* remove from stack */
+  }
+  else {
+    if (emptybuffer(B))
+      lua_insert(L, -2);  /* put buffer before new value */
+    B->lvl++;  /* add new value into B stack */
+    adjuststack(B);
+  }
+}
+
+
+LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
+  B->L = L;
+  B->p = B->buffer;
+  B->lvl = 0;
+}
+
+/* }====================================================== */
+
+
+LUALIB_API int luaL_ref (lua_State *L, int t) {
+  int ref;
+  t = abs_index(L, t);
+  if (lua_isnil(L, -1)) {
+    lua_pop(L, 1);  /* remove from stack */
+    return LUA_REFNIL;  /* `nil' has a unique fixed reference */
+  }
+  lua_rawgeti(L, t, FREELIST_REF);  /* get first free element */
+  ref = (int)lua_tointeger(L, -1);  /* ref = t[FREELIST_REF] */
+  lua_pop(L, 1);  /* remove it from stack */
+  if (ref != 0) {  /* any free element? */
+    lua_rawgeti(L, t, ref);  /* remove it from list */
+    lua_rawseti(L, t, FREELIST_REF);  /* (t[FREELIST_REF] = t[ref]) */
+  }
+  else {  /* no free elements */
+    ref = (int)lua_objlen(L, t);
+    ref++;  /* create new reference */
+  }
+  lua_rawseti(L, t, ref);
+  return ref;
+}
+
+
+LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
+  if (ref >= 0) {
+    t = abs_index(L, t);
+    lua_rawgeti(L, t, FREELIST_REF);
+    lua_rawseti(L, t, ref);  /* t[ref] = t[FREELIST_REF] */
+    lua_pushinteger(L, ref);
+    lua_rawseti(L, t, FREELIST_REF);  /* t[FREELIST_REF] = ref */
+  }
+}
+
+
+
+/*
+** {======================================================
+** Load functions
+** =======================================================
+*/
+
+typedef struct LoadF {
+  int extraline;
+  FILE *f;
+  char buff[LUAL_BUFFERSIZE];
+} LoadF;
+
+
+static const char *getF (lua_State *L, void *ud, size_t *size) {
+  LoadF *lf = (LoadF *)ud;
+  (void)L;
+  if (lf->extraline) {
+    lf->extraline = 0;
+    *size = 1;
+    return "\n";
+  }
+  if (feof(lf->f)) return NULL;
+  *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);
+  return (*size > 0) ? lf->buff : NULL;
+}
+
+
+static int errfile (lua_State *L, const char *what, int fnameindex) {
+  const char *serr = strerror(errno);
+  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;
+}
+
+
+LUALIB_API int luaL_loadfile (lua_State *L, const char *filename) {
+  LoadF lf;
+  int status, readstatus;
+  int c;
+  int fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */
+  lf.extraline = 0;
+  if (filename == NULL) {
+    lua_pushliteral(L, "=stdin");
+    lf.f = stdin;
+  }
+  else {
+    lua_pushfstring(L, "@%s", filename);
+    lf.f = fopen(filename, "r");
+    if (lf.f == NULL) return errfile(L, "open", fnameindex);
+  }
+  c = getc(lf.f);
+  if (c == '#') {  /* Unix exec. file? */
+    lf.extraline = 1;
+    while ((c = getc(lf.f)) != EOF && c != '\n') ;  /* skip first line */
+    if (c == '\n') c = getc(lf.f);
+  }
+  if (c == LUA_SIGNATURE[0] && filename) {  /* binary file? */
+    lf.f = freopen(filename, "rb", lf.f);  /* reopen in binary mode */
+    if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
+    /* skip eventual `#!...' */
+   while ((c = getc(lf.f)) != EOF && c != LUA_SIGNATURE[0]) ;
+    lf.extraline = 0;
+  }
+  ungetc(c, lf.f);
+  status = lua_load(L, getF, &lf, lua_tostring(L, -1));
+  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 errfile(L, "read", fnameindex);
+  }
+  lua_remove(L, fnameindex);
+  return status;
+}
+
+
+typedef struct LoadS {
+  const char *s;
+  size_t size;
+} LoadS;
+
+
+static const char *getS (lua_State *L, void *ud, size_t *size) {
+  LoadS *ls = (LoadS *)ud;
+  (void)L;
+  if (ls->size == 0) return NULL;
+  *size = ls->size;
+  ls->size = 0;
+  return ls->s;
+}
+
+
+LUALIB_API int luaL_loadbuffer (lua_State *L, const char *buff, size_t size,
+                                const char *name) {
+  LoadS ls;
+  ls.s = buff;
+  ls.size = size;
+  return lua_load(L, getS, &ls, name);
+}
+
+
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s) {
+  return luaL_loadbuffer(L, s, strlen(s), s);
+}
+
+
+
+/* }====================================================== */
+
+
+static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
+  (void)ud;
+  (void)osize;
+  if (nsize == 0) {
+    free(ptr);
+    return NULL;
+  }
+  else
+    return realloc(ptr, nsize);
+}
+
+
+static int panic (lua_State *L) {
+  (void)L;  /* to avoid warnings */
+  fprintf(stderr, "PANIC: unprotected error in call to Lua API (%s)\n",
+                   lua_tostring(L, -1));
+  return 0;
+}
+
+
+LUALIB_API lua_State *luaL_newstate (void) {
+  lua_State *L = lua_newstate(l_alloc, NULL);
+  if (L) lua_atpanic(L, &panic);
+  return L;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lauxlib.h b/libraries/LuaJIT-1.1.7/src/lauxlib.h
new file mode 100644
index 0000000..3425823
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lauxlib.h
@@ -0,0 +1,174 @@
+/*
+** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lua.h"
+
+
+#if defined(LUA_COMPAT_GETN)
+LUALIB_API int (luaL_getn) (lua_State *L, int t);
+LUALIB_API void (luaL_setn) (lua_State *L, int t, int n);
+#else
+#define luaL_getn(L,i)          ((int)lua_objlen(L, i))
+#define luaL_setn(L,i,j)        ((void)0)  /* no op! */
+#endif
+
+#if defined(LUA_COMPAT_OPENLIB)
+#define luaI_openlib    luaL_openlib
+#endif
+
+
+/* extra error code for `luaL_load' */
+#define LUA_ERRFILE     (LUA_ERRERR+1)
+
+
+typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+
+
+
+LUALIB_API void (luaI_openlib) (lua_State *L, const char *libname,
+                                const luaL_Reg *l, int nup);
+LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
+                                const luaL_Reg *l);
+LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_typerror) (lua_State *L, int narg, const char *tname);
+LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
+                                                          size_t *l);
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
+                                          const char *def, size_t *l);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
+
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
+                                          lua_Integer def);
+
+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
+
+LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
+
+LUALIB_API void (luaL_where) (lua_State *L, int lvl);
+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
+
+LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
+                                   const char *const lst[]);
+
+LUALIB_API int (luaL_ref) (lua_State *L, int t);
+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
+
+LUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename);
+LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz,
+                                  const char *name);
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
+
+LUALIB_API lua_State *(luaL_newstate) (void);
+
+
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
+                                                  const char *r);
+
+LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,
+                                         const char *fname, int szhint);
+
+
+
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define luaL_argcheck(L, cond,numarg,extramsg)  \
+                ((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
+#define luaL_checkstring(L,n)   (luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L,n,d)   (luaL_optlstring(L, (n), (d), NULL))
+#define luaL_checkint(L,n)      ((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)      ((int)luaL_optinteger(L, (n), (d)))
+#define luaL_checklong(L,n)     ((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)     ((long)luaL_optinteger(L, (n), (d)))
+
+#define luaL_typename(L,i)      lua_typename(L, lua_type(L,(i)))
+
+#define luaL_dofile(L, fn) \
+        (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+        (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L,n)  (lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L,f,n,d)       (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+
+
+typedef struct luaL_Buffer {
+  char *p;                      /* current position in buffer */
+  int lvl;  /* number of strings in the stack (level) */
+  lua_State *L;
+  char buffer[LUAL_BUFFERSIZE];
+} luaL_Buffer;
+
+#define luaL_addchar(B,c) \
+  ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \
+   (*(B)->p++ = (char)(c)))
+
+/* compatibility only */
+#define luaL_putchar(B,c)       luaL_addchar(B,c)
+
+#define luaL_addsize(B,n)       ((B)->p += (n))
+
+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B);
+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
+
+
+/* }====================================================== */
+
+
+/* compatibility with ref system */
+
+/* pre-defined references */
+#define LUA_NOREF       (-2)
+#define LUA_REFNIL      (-1)
+
+#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \
+      (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))
+
+#define lua_unref(L,ref)        luaL_unref(L, LUA_REGISTRYINDEX, (ref))
+
+#define lua_getref(L,ref)       lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))
+
+
+#define luaL_reg        luaL_Reg
+
+#endif
+
+
diff --git a/libraries/LuaJIT-1.1.7/src/lbaselib.c b/libraries/LuaJIT-1.1.7/src/lbaselib.c
new file mode 100644
index 0000000..2366a02
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lbaselib.c
@@ -0,0 +1,679 @@
+/*
+** $Id: lbaselib.c,v 1.191.1.6 2008/02/14 16:46:22 roberto Exp $
+** Basic library
+** See Copyright Notice in lua.h
+*/
+
+
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define lbaselib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+#ifndef COCO_DISABLE
+#include "lcoco.h"
+#endif
+
+
+
+
+/*
+** If your system does not support `stdout', you can just remove this function.
+** If you need, you can define your own `print' function, following this
+** model but changing `fputs' to put the strings at a proper place
+** (a console window or a log file, for instance).
+*/
+static int luaB_print (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  int i;
+  lua_getglobal(L, "tostring");
+  for (i=1; i<=n; i++) {
+    const char *s;
+    lua_pushvalue(L, -1);  /* function to be called */
+    lua_pushvalue(L, i);   /* value to print */
+    lua_call(L, 1, 1);
+    s = lua_tostring(L, -1);  /* get result */
+    if (s == NULL)
+      return luaL_error(L, LUA_QL("tostring") " must return a string to "
+                           LUA_QL("print"));
+    if (i>1) fputs("\t", stdout);
+    fputs(s, stdout);
+    lua_pop(L, 1);  /* pop result */
+  }
+  fputs("\n", stdout);
+  return 0;
+}
+
+
+static int luaB_tonumber (lua_State *L) {
+  int base = luaL_optint(L, 2, 10);
+  if (base == 10) {  /* standard conversion */
+    luaL_checkany(L, 1);
+    if (lua_isnumber(L, 1)) {
+      lua_pushnumber(L, lua_tonumber(L, 1));
+      return 1;
+    }
+  }
+  else {
+    const char *s1 = luaL_checkstring(L, 1);
+    char *s2;
+    unsigned long n;
+    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
+    n = strtoul(s1, &s2, base);
+    if (s1 != s2) {  /* at least one valid digit? */
+      while (isspace((unsigned char)(*s2))) s2++;  /* skip trailing spaces */
+      if (*s2 == '\0') {  /* no invalid trailing characters? */
+        lua_pushnumber(L, (lua_Number)n);
+        return 1;
+      }
+    }
+  }
+  lua_pushnil(L);  /* else not a number */
+  return 1;
+}
+
+
+static int luaB_error (lua_State *L) {
+  int level = luaL_optint(L, 2, 1);
+  lua_settop(L, 1);
+  if (lua_isstring(L, 1) && level > 0) {  /* add extra information? */
+    luaL_where(L, level);
+    lua_pushvalue(L, 1);
+    lua_concat(L, 2);
+  }
+  return lua_error(L);
+}
+
+
+static int luaB_getmetatable (lua_State *L) {
+  luaL_checkany(L, 1);
+  if (!lua_getmetatable(L, 1)) {
+    lua_pushnil(L);
+    return 1;  /* no metatable */
+  }
+  luaL_getmetafield(L, 1, "__metatable");
+  return 1;  /* returns either __metatable field (if present) or metatable */
+}
+
+
+static int luaB_setmetatable (lua_State *L) {
+  int t = lua_type(L, 2);
+  luaL_checktype(L, 1, LUA_TTABLE);
+  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
+                    "nil or table expected");
+  if (luaL_getmetafield(L, 1, "__metatable"))
+    luaL_error(L, "cannot change a protected metatable");
+  lua_settop(L, 2);
+  lua_setmetatable(L, 1);
+  return 1;
+}
+
+
+static void getfunc (lua_State *L, int opt) {
+  if (lua_isfunction(L, 1)) lua_pushvalue(L, 1);
+  else {
+    lua_Debug ar;
+    int level = opt ? luaL_optint(L, 1, 1) : luaL_checkint(L, 1);
+    luaL_argcheck(L, level >= 0, 1, "level must be non-negative");
+    if (lua_getstack(L, level, &ar) == 0)
+      luaL_argerror(L, 1, "invalid level");
+    lua_getinfo(L, "f", &ar);
+    if (lua_isnil(L, -1))
+      luaL_error(L, "no function environment for tail call at level %d",
+                    level);
+  }
+}
+
+
+static int luaB_getfenv (lua_State *L) {
+  getfunc(L, 1);
+  if (lua_iscfunction(L, -1))  /* is a C function? */
+    lua_pushvalue(L, LUA_GLOBALSINDEX);  /* return the thread's global env. */
+  else
+    lua_getfenv(L, -1);
+  return 1;
+}
+
+
+static int luaB_setfenv (lua_State *L) {
+  luaL_checktype(L, 2, LUA_TTABLE);
+  getfunc(L, 0);
+  lua_pushvalue(L, 2);
+  if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {
+    /* change environment of current thread */
+    lua_pushthread(L);
+    lua_insert(L, -2);
+    lua_setfenv(L, -2);
+    return 0;
+  }
+  else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)
+    luaL_error(L,
+          LUA_QL("setfenv") " cannot change environment of given object");
+  return 1;
+}
+
+
+static int luaB_rawequal (lua_State *L) {
+  luaL_checkany(L, 1);
+  luaL_checkany(L, 2);
+  lua_pushboolean(L, lua_rawequal(L, 1, 2));
+  return 1;
+}
+
+
+static int luaB_rawget (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  luaL_checkany(L, 2);
+  lua_settop(L, 2);
+  lua_rawget(L, 1);
+  return 1;
+}
+
+static int luaB_rawset (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  luaL_checkany(L, 2);
+  luaL_checkany(L, 3);
+  lua_settop(L, 3);
+  lua_rawset(L, 1);
+  return 1;
+}
+
+
+static int luaB_gcinfo (lua_State *L) {
+  lua_pushinteger(L, lua_getgccount(L));
+  return 1;
+}
+
+
+static int luaB_collectgarbage (lua_State *L) {
+  static const char *const opts[] = {"stop", "restart", "collect",
+    "count", "step", "setpause", "setstepmul", NULL};
+  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
+    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};
+  int o = luaL_checkoption(L, 1, "collect", opts);
+  int ex = luaL_optint(L, 2, 0);
+  int res = lua_gc(L, optsnum[o], ex);
+  switch (optsnum[o]) {
+    case LUA_GCCOUNT: {
+      int b = lua_gc(L, LUA_GCCOUNTB, 0);
+      lua_pushnumber(L, res + ((lua_Number)b/1024));
+      return 1;
+    }
+    case LUA_GCSTEP: {
+      lua_pushboolean(L, res);
+      return 1;
+    }
+    default: {
+      lua_pushnumber(L, res);
+      return 1;
+    }
+  }
+}
+
+
+static int luaB_type (lua_State *L) {
+  luaL_checkany(L, 1);
+  lua_pushstring(L, luaL_typename(L, 1));
+  return 1;
+}
+
+
+static int luaB_next (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  lua_settop(L, 2);  /* create a 2nd argument if there isn't one */
+  if (lua_next(L, 1))
+    return 2;
+  else {
+    lua_pushnil(L);
+    return 1;
+  }
+}
+
+
+static int luaB_pairs (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
+  lua_pushvalue(L, 1);  /* state, */
+  lua_pushnil(L);  /* and initial value */
+  return 3;
+}
+
+
+static int ipairsaux (lua_State *L) {
+  int i = luaL_checkint(L, 2);
+  luaL_checktype(L, 1, LUA_TTABLE);
+  i++;  /* next value */
+  lua_pushinteger(L, i);
+  lua_rawgeti(L, 1, i);
+  return (lua_isnil(L, -1)) ? 0 : 2;
+}
+
+
+static int luaB_ipairs (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
+  lua_pushvalue(L, 1);  /* state, */
+  lua_pushinteger(L, 0);  /* and initial value */
+  return 3;
+}
+
+
+static int load_aux (lua_State *L, int status) {
+  if (status == 0)  /* OK? */
+    return 1;
+  else {
+    lua_pushnil(L);
+    lua_insert(L, -2);  /* put before error message */
+    return 2;  /* return nil plus error message */
+  }
+}
+
+
+static int luaB_loadstring (lua_State *L) {
+  size_t l;
+  const char *s = luaL_checklstring(L, 1, &l);
+  const char *chunkname = luaL_optstring(L, 2, s);
+  return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));
+}
+
+
+static int luaB_loadfile (lua_State *L) {
+  const char *fname = luaL_optstring(L, 1, NULL);
+  return load_aux(L, luaL_loadfile(L, fname));
+}
+
+
+/*
+** Reader for generic `load' function: `lua_load' uses the
+** stack for internal stuff, so the reader cannot change the
+** stack top. Instead, it keeps its resulting string in a
+** reserved slot inside the stack.
+*/
+static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
+  (void)ud;  /* to avoid warnings */
+  luaL_checkstack(L, 2, "too many nested functions");
+  lua_pushvalue(L, 1);  /* get function */
+  lua_call(L, 0, 1);  /* call it */
+  if (lua_isnil(L, -1)) {
+    *size = 0;
+    return NULL;
+  }
+  else if (lua_isstring(L, -1)) {
+    lua_replace(L, 3);  /* save string in a reserved stack slot */
+    return lua_tolstring(L, 3, size);
+  }
+  else luaL_error(L, "reader function must return a string");
+  return NULL;  /* to avoid warnings */
+}
+
+
+static int luaB_load (lua_State *L) {
+  int status;
+  const char *cname = luaL_optstring(L, 2, "=(load)");
+  luaL_checktype(L, 1, LUA_TFUNCTION);
+  lua_settop(L, 3);  /* function, eventual name, plus one reserved slot */
+  status = lua_load(L, generic_reader, NULL, cname);
+  return load_aux(L, status);
+}
+
+
+static int luaB_dofile (lua_State *L) {
+  const char *fname = luaL_optstring(L, 1, NULL);
+  int n = lua_gettop(L);
+  if (luaL_loadfile(L, fname) != 0) lua_error(L);
+  lua_call(L, 0, LUA_MULTRET);
+  return lua_gettop(L) - n;
+}
+
+
+static int luaB_assert (lua_State *L) {
+  luaL_checkany(L, 1);
+  if (!lua_toboolean(L, 1))
+    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
+  return lua_gettop(L);
+}
+
+
+static int luaB_unpack (lua_State *L) {
+  int i, e, n;
+  luaL_checktype(L, 1, LUA_TTABLE);
+  i = luaL_optint(L, 2, 1);
+  e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));
+  if (i > e) return 0;  /* empty range */
+  n = e - i + 1;  /* number of elements */
+  if (n <= 0 || !lua_checkstack(L, n))  /* n <= 0 means arith. overflow */
+    return luaL_error(L, "too many results to unpack");
+  lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */
+  while (i++ < e)  /* push arg[i + 1...e] */
+    lua_rawgeti(L, 1, i);
+  return n;
+}
+
+
+static int luaB_select (lua_State *L) {
+  int n = lua_gettop(L);
+  if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
+    lua_pushinteger(L, n-1);
+    return 1;
+  }
+  else {
+    int i = luaL_checkint(L, 1);
+    if (i < 0) i = n + i;
+    else if (i > n) i = n;
+    luaL_argcheck(L, 1 <= i, 1, "index out of range");
+    return n - i;
+  }
+}
+
+
+static int luaB_pcall (lua_State *L) {
+  int status;
+  luaL_checkany(L, 1);
+  status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);
+  lua_pushboolean(L, (status == 0));
+  lua_insert(L, 1);
+  return lua_gettop(L);  /* return status + all results */
+}
+
+
+static int luaB_xpcall (lua_State *L) {
+  int status;
+  luaL_checkany(L, 2);
+  lua_settop(L, 2);
+  lua_insert(L, 1);  /* put error function under function to be called */
+  status = lua_pcall(L, 0, LUA_MULTRET, 1);
+  lua_pushboolean(L, (status == 0));
+  lua_replace(L, 1);
+  return lua_gettop(L);  /* return status + all results */
+}
+
+
+static int luaB_tostring (lua_State *L) {
+  luaL_checkany(L, 1);
+  if (luaL_callmeta(L, 1, "__tostring"))  /* is there a metafield? */
+    return 1;  /* use its value */
+  switch (lua_type(L, 1)) {
+    case LUA_TNUMBER:
+      lua_pushstring(L, lua_tostring(L, 1));
+      break;
+    case LUA_TSTRING:
+      lua_pushvalue(L, 1);
+      break;
+    case LUA_TBOOLEAN:
+      lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));
+      break;
+    case LUA_TNIL:
+      lua_pushliteral(L, "nil");
+      break;
+    default:
+      lua_pushfstring(L, "%s: %p", luaL_typename(L, 1), lua_topointer(L, 1));
+      break;
+  }
+  return 1;
+}
+
+
+static int luaB_newproxy (lua_State *L) {
+  lua_settop(L, 1);
+  lua_newuserdata(L, 0);  /* create proxy */
+  if (lua_toboolean(L, 1) == 0)
+    return 1;  /* no metatable */
+  else if (lua_isboolean(L, 1)) {
+    lua_newtable(L);  /* create a new metatable `m' ... */
+    lua_pushvalue(L, -1);  /* ... and mark `m' as a valid metatable */
+    lua_pushboolean(L, 1);
+    lua_rawset(L, lua_upvalueindex(1));  /* weaktable[m] = true */
+  }
+  else {
+    int validproxy = 0;  /* to check if weaktable[metatable(u)] == true */
+    if (lua_getmetatable(L, 1)) {
+      lua_rawget(L, lua_upvalueindex(1));
+      validproxy = lua_toboolean(L, -1);
+      lua_pop(L, 1);  /* remove value */
+    }
+    luaL_argcheck(L, validproxy, 1, "boolean or proxy expected");
+    lua_getmetatable(L, 1);  /* metatable is valid; get it */
+  }
+  lua_setmetatable(L, 2);
+  return 1;
+}
+
+
+static const luaL_Reg base_funcs[] = {
+  {"assert", luaB_assert},
+  {"collectgarbage", luaB_collectgarbage},
+  {"dofile", luaB_dofile},
+  {"error", luaB_error},
+  {"gcinfo", luaB_gcinfo},
+  {"getfenv", luaB_getfenv},
+  {"getmetatable", luaB_getmetatable},
+  {"loadfile", luaB_loadfile},
+  {"load", luaB_load},
+  {"loadstring", luaB_loadstring},
+  {"next", luaB_next},
+  {"pcall", luaB_pcall},
+  {"print", luaB_print},
+  {"rawequal", luaB_rawequal},
+  {"rawget", luaB_rawget},
+  {"rawset", luaB_rawset},
+  {"select", luaB_select},
+  {"setfenv", luaB_setfenv},
+  {"setmetatable", luaB_setmetatable},
+  {"tonumber", luaB_tonumber},
+  {"tostring", luaB_tostring},
+  {"type", luaB_type},
+  {"unpack", luaB_unpack},
+  {"xpcall", luaB_xpcall},
+  {NULL, NULL}
+};
+
+
+/*
+** {======================================================
+** Coroutine library
+** =======================================================
+*/
+
+#define CO_RUN  0       /* running */
+#define CO_SUS  1       /* suspended */
+#define CO_NOR  2       /* 'normal' (it resumed another coroutine) */
+#define CO_DEAD 3
+
+static const char *const statnames[] =
+    {"running", "suspended", "normal", "dead"};
+
+static int costatus (lua_State *L, lua_State *co) {
+  if (L == co) return CO_RUN;
+  switch (lua_status(co)) {
+    case LUA_YIELD:
+      return CO_SUS;
+    case 0: {
+      lua_Debug ar;
+      if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
+        return CO_NOR;  /* it is running */
+      else if (lua_gettop(co) == 0)
+          return CO_DEAD;
+      else
+        return CO_SUS;  /* initial state */
+    }
+    default:  /* some error occured */
+      return CO_DEAD;
+  }
+}
+
+
+static int luaB_costatus (lua_State *L) {
+  lua_State *co = lua_tothread(L, 1);
+  luaL_argcheck(L, co, 1, "coroutine expected");
+  lua_pushstring(L, statnames[costatus(L, co)]);
+  return 1;
+}
+
+
+static int auxresume (lua_State *L, lua_State *co, int narg) {
+  int status = costatus(L, co);
+  if (!lua_checkstack(co, narg))
+    luaL_error(L, "too many arguments to resume");
+  if (status != CO_SUS) {
+    lua_pushfstring(L, "cannot resume %s coroutine", statnames[status]);
+    return -1;  /* error flag */
+  }
+  lua_xmove(L, co, narg);
+  status = lua_resume(co, narg);
+  if (status == 0 || status == LUA_YIELD) {
+    int nres = lua_gettop(co);
+    if (!lua_checkstack(L, nres + 1))
+      luaL_error(L, "too many results to resume");
+    lua_xmove(co, L, nres);  /* move yielded values */
+    return nres;
+  }
+  else {
+    lua_xmove(co, L, 1);  /* move error message */
+    return -1;  /* error flag */
+  }
+}
+
+
+static int luaB_coresume (lua_State *L) {
+  lua_State *co = lua_tothread(L, 1);
+  int r;
+  luaL_argcheck(L, co, 1, "coroutine expected");
+  r = auxresume(L, co, lua_gettop(L) - 1);
+  if (r < 0) {
+    lua_pushboolean(L, 0);
+    lua_insert(L, -2);
+    return 2;  /* return false + error message */
+  }
+  else {
+    lua_pushboolean(L, 1);
+    lua_insert(L, -(r + 1));
+    return r + 1;  /* return true + `resume' returns */
+  }
+}
+
+
+static int luaB_auxwrap (lua_State *L) {
+  lua_State *co = lua_tothread(L, lua_upvalueindex(1));
+  int r = auxresume(L, co, lua_gettop(L));
+  if (r < 0) {
+    if (lua_isstring(L, -1)) {  /* error object is a string? */
+      luaL_where(L, 1);  /* add extra info */
+      lua_insert(L, -2);
+      lua_concat(L, 2);
+    }
+    lua_error(L);  /* propagate error */
+  }
+  return r;
+}
+
+
+#ifndef COCO_DISABLE
+static int luaB_cstacksize (lua_State *L)
+{
+  lua_pushinteger(L, luaCOCO_cstacksize(luaL_optint(L, 1, -1)));
+  return 1;
+}
+#endif
+
+
+static int luaB_cocreate (lua_State *L) {
+#ifdef COCO_DISABLE
+  lua_State *NL = lua_newthread(L);
+  luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1,
+    "Lua function expected");
+#else
+  int cstacksize = luaL_optint(L, 2, 0);
+  lua_State *NL = lua_newcthread(L, cstacksize);
+  luaL_argcheck(L, lua_isfunction(L, 1) &&
+                   (cstacksize >= 0 ? 1 : !lua_iscfunction(L, 1)),
+                1, "Lua function expected");
+#endif
+  lua_pushvalue(L, 1);  /* move function to top */
+  lua_xmove(L, NL, 1);  /* move function from L to NL */
+  return 1;
+}
+
+
+static int luaB_cowrap (lua_State *L) {
+  luaB_cocreate(L);
+  lua_pushcclosure(L, luaB_auxwrap, 1);
+  return 1;
+}
+
+
+static int luaB_yield (lua_State *L) {
+  return lua_yield(L, lua_gettop(L));
+}
+
+
+static int luaB_corunning (lua_State *L) {
+  if (lua_pushthread(L))
+    lua_pushnil(L);  /* main thread is not a coroutine */
+  return 1;
+}
+
+
+static const luaL_Reg co_funcs[] = {
+  {"create", luaB_cocreate},
+  {"resume", luaB_coresume},
+  {"running", luaB_corunning},
+  {"status", luaB_costatus},
+  {"wrap", luaB_cowrap},
+  {"yield", luaB_yield},
+#ifndef COCO_DISABLE
+  {"cstacksize", luaB_cstacksize},
+#endif
+  {NULL, NULL}
+};
+
+/* }====================================================== */
+
+
+static void auxopen (lua_State *L, const char *name,
+                     lua_CFunction f, lua_CFunction u) {
+  lua_pushcfunction(L, u);
+  lua_pushcclosure(L, f, 1);
+  lua_setfield(L, -2, name);
+}
+
+
+static void base_open (lua_State *L) {
+  /* set global _G */
+  lua_pushvalue(L, LUA_GLOBALSINDEX);
+  lua_setglobal(L, "_G");
+  /* open lib into global table */
+  luaL_register(L, "_G", base_funcs);
+  lua_pushliteral(L, LUA_VERSION);
+  lua_setglobal(L, "_VERSION");  /* set global _VERSION */
+  /* `ipairs' and `pairs' need auxliliary functions as upvalues */
+  auxopen(L, "ipairs", luaB_ipairs, ipairsaux);
+  auxopen(L, "pairs", luaB_pairs, luaB_next);
+  /* `newproxy' needs a weaktable as upvalue */
+  lua_createtable(L, 0, 1);  /* new table `w' */
+  lua_pushvalue(L, -1);  /* `w' will be its own metatable */
+  lua_setmetatable(L, -2);
+  lua_pushliteral(L, "kv");
+  lua_setfield(L, -2, "__mode");  /* metatable(w).__mode = "kv" */
+  lua_pushcclosure(L, luaB_newproxy, 1);
+  lua_setglobal(L, "newproxy");  /* set global `newproxy' */
+}
+
+
+LUALIB_API int luaopen_base (lua_State *L) {
+  base_open(L);
+  luaL_register(L, LUA_COLIBNAME, co_funcs);
+#ifndef COCO_DISABLE
+  lua_pushboolean(L, 1); 
+  lua_setfield(L, -2, "coco");
+#endif
+  return 2;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lcoco.c b/libraries/LuaJIT-1.1.7/src/lcoco.c
new file mode 100644
index 0000000..c3acc68
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lcoco.c
@@ -0,0 +1,693 @@
+/*
+** Copyright (C) 2004-2011 Mike Pall. All rights reserved.
+**
+** 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.
+**
+** [ MIT license: http://www.opensource.org/licenses/mit-license.php ]
+*/
+
+/* Coco -- True C coroutines for Lua. http://luajit.org/coco.html */
+#ifndef COCO_DISABLE
+
+#define lcoco_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lobject.h"
+#include "lstate.h"
+#include "ldo.h"
+#include "lvm.h"
+#include "lgc.h"
+
+
+/*
+** Define this if you want to run Coco with valgrind. You will get random
+** errors about accessing memory from newly allocated C stacks if you don't.
+** You need at least valgrind 3.0 for this to work.
+**
+** This macro evaluates to a no-op if not run with valgrind. I.e. you can
+** use the same binary for regular runs, too (without a performance loss).
+*/
+#ifdef USE_VALGRIND
+#include <valgrind/valgrind.h>
+#define STACK_REG(coco, p, sz)  (coco)->vgid = VALGRIND_STACK_REGISTER(p, p+sz);
+#define STACK_DEREG(coco)       VALGRIND_STACK_DEREGISTER((coco)->vgid);
+#define STACK_VGID              unsigned int vgid;
+#else
+#define STACK_REG(coco, p, sz)
+#define STACK_DEREG(id)
+#define STACK_VGID
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+/* Use Windows Fibers. */
+#if defined(COCO_USE_FIBERS)
+
+#define _WIN32_WINNT 0x0400
+#include <windows.h>
+
+#define COCO_MAIN_DECL          CALLBACK
+
+typedef LPFIBER_START_ROUTINE coco_MainFunc;
+
+#define COCO_NEW(OL, NL, cstacksize, mainfunc) \
+  if ((L2COCO(NL)->fib = CreateFiber(cstacksize, mainfunc, NL)) == NULL) \
+    luaD_throw(OL, LUA_ERRMEM);
+
+#define COCO_FREE(L) \
+  DeleteFiber(L2COCO(L)->fib); \
+  L2COCO(L)->fib = NULL;
+
+/* See: http://blogs.msdn.com/oldnewthing/archive/2004/12/31/344799.aspx */
+#define COCO_JUMPIN(coco) \
+  { void *cur = GetCurrentFiber(); \
+    coco->back = (cur == NULL || cur == (void *)0x1e00) ? \
+      ConvertThreadToFiber(NULL) : cur; } \
+  SwitchToFiber(coco->fib);
+
+#define COCO_JUMPOUT(coco) \
+  SwitchToFiber(coco->back);
+
+/* CreateFiber() defaults to STACKSIZE from the Windows module .def file. */
+#define COCO_DEFAULT_CSTACKSIZE         0
+
+/* ------------------------------------------------------------------------ */
+
+#else /* !COCO_USE_FIBERS */
+
+#ifndef COCO_USE_UCONTEXT
+
+/* Try inline asm first. */
+#if __GNUC__ >= 3 && !defined(COCO_USE_SETJMP)
+
+#if defined(__i386) || defined(__i386__)
+
+#ifdef __PIC__
+typedef void *coco_ctx[4];  /* eip, esp, ebp, ebx */
+static inline void coco_switch(coco_ctx from, coco_ctx to)
+{
+  __asm__ __volatile__ (
+    "call 1f\n" "1:\tpopl %%eax\n\t" "addl $(2f-1b),%%eax\n\t"
+    "movl %%eax, (%0)\n\t" "movl %%esp, 4(%0)\n\t"
+    "movl %%ebp, 8(%0)\n\t" "movl %%ebx, 12(%0)\n\t"
+    "movl 12(%1), %%ebx\n\t" "movl 8(%1), %%ebp\n\t"
+    "movl 4(%1), %%esp\n\t" "jmp *(%1)\n" "2:\n"
+    : "+S" (from), "+D" (to) : : "eax", "ecx", "edx", "memory", "cc");
+}
+#else
+typedef void *coco_ctx[3];  /* eip, esp, ebp */
+static inline void coco_switch(coco_ctx from, coco_ctx to)
+{
+  __asm__ __volatile__ (
+    "movl $1f, (%0)\n\t" "movl %%esp, 4(%0)\n\t" "movl %%ebp, 8(%0)\n\t"
+    "movl 8(%1), %%ebp\n\t" "movl 4(%1), %%esp\n\t" "jmp *(%1)\n" "1:\n"
+    : "+S" (from), "+D" (to) : : "eax", "ebx", "ecx", "edx", "memory", "cc");
+}
+#endif
+
+#define COCO_CTX                coco_ctx
+#define COCO_SWITCH(from, to)   coco_switch(from, to);
+#define COCO_MAKECTX(coco, buf, func, stack, a0) \
+  buf[0] = (void *)(func); \
+  buf[1] = (void *)(stack); \
+  buf[2] = (void *)0; \
+  stack[0] = 0xdeadc0c0;  /* Dummy return address. */ \
+  coco->arg0 = (size_t)(a0);
+#define COCO_STATE_HEAD         size_t arg0;
+
+#elif defined(__x86_64__)
+
+static void coco_wrap_main(void)
+{
+  __asm__ __volatile__ ("\tmovq %r13, %rdi\n\tjmpq *%r12\n");
+}
+
+typedef void *coco_ctx[8];  /* rip, rsp, rbp, rbx, r12, r13, r14, r15 */
+static inline void coco_switch(coco_ctx from, coco_ctx to)
+{
+  __asm__ __volatile__ (
+    "leaq 1f(%%rip), %%rax\n\t"
+    "movq %%rax, (%0)\n\t" "movq %%rsp, 8(%0)\n\t" "movq %%rbp, 16(%0)\n\t"
+    "movq %%rbx, 24(%0)\n\t" "movq %%r12, 32(%0)\n\t" "movq %%r13, 40(%0)\n\t"
+    "movq %%r14, 48(%0)\n\t" "movq %%r15, 56(%0)\n\t"
+    "movq 56(%1), %%r15\n\t" "movq 48(%1), %%r14\n\t" "movq 40(%1), %%r13\n\t"
+    "movq 32(%1), %%r12\n\t" "movq 24(%1), %%rbx\n\t" "movq 16(%1), %%rbp\n\t"
+    "movq 8(%1), %%rsp\n\t" "jmpq *(%1)\n" "1:\n"
+    : "+S" (from), "+D" (to) :
+    : "rax", "rcx", "rdx", "r8", "r9", "r10", "r11", "memory", "cc");
+}
+
+#define COCO_CTX                coco_ctx
+#define COCO_SWITCH(from, to)   coco_switch(from, to);
+#define COCO_MAKECTX(coco, buf, func, stack, a0) \
+  buf[0] = (void *)(coco_wrap_main); \
+  buf[1] = (void *)(stack); \
+  buf[2] = (void *)0; \
+  buf[3] = (void *)0; \
+  buf[4] = (void *)(func); \
+  buf[5] = (void *)(a0); \
+  buf[6] = (void *)0; \
+  buf[7] = (void *)0; \
+  stack[0] = 0xdeadc0c0deadc0c0;  /* Dummy return address. */ \
+
+#elif __mips && _MIPS_SIM == _MIPS_SIM_ABI32 && !defined(__mips_eabi)
+
+/* No way to avoid the function prologue with inline assembler. So use this: */
+static const unsigned int coco_switch[] = {
+#ifdef __mips_soft_float
+#define COCO_STACKSAVE          -10
+  0x27bdffd8,  /* addiu sp, sp, -(10*4) */
+#else
+#define COCO_STACKSAVE          -22
+  0x27bdffa8,  /* addiu sp, sp, -(10*4+6*8) */
+  /* sdc1 {$f20-$f30}, offset(sp) */
+  0xf7be0050, 0xf7bc0048, 0xf7ba0040, 0xf7b80038, 0xf7b60030, 0xf7b40028,
+#endif
+  /* sw {gp,s0-s8}, offset(sp) */
+  0xafbe0024, 0xafb70020, 0xafb6001c, 0xafb50018, 0xafb40014, 0xafb30010,
+  0xafb2000c, 0xafb10008, 0xafb00004, 0xafbc0000,
+  /* sw sp, 4(a0); sw ra, 0(a0); lw ra, 0(a1); lw sp, 4(a1); move t9, ra */
+  0xac9d0004, 0xac9f0000, 0x8cbf0000, 0x8cbd0004, 0x03e0c821,
+  /* lw caller-saved-reg, offset(sp) */
+  0x8fbe0024, 0x8fb70020, 0x8fb6001c, 0x8fb50018, 0x8fb40014, 0x8fb30010,
+  0x8fb2000c, 0x8fb10008, 0x8fb00004, 0x8fbc0000,
+#ifdef __mips_soft_float
+  0x03e00008, 0x27bd0028  /* jr ra; addiu sp, sp, 10*4 */
+#else
+  /* ldc1 {$f20-$f30}, offset(sp) */
+  0xd7be0050, 0xd7bc0048, 0xd7ba0040, 0xd7b80038, 0xd7b60030, 0xd7b40028,
+  0x03e00008, 0x27bd0058  /* jr ra; addiu sp, sp, 10*4+6*8 */
+#endif
+};
+
+typedef void *coco_ctx[2];  /* ra, sp */
+#define COCO_CTX                coco_ctx
+#define COCO_SWITCH(from, to) \
+  ((void (*)(coco_ctx, coco_ctx))coco_switch)(from, to);
+#define COCO_MAKECTX(coco, buf, func, stack, a0) \
+  buf[0] = (void *)(func); \
+  buf[1] = (void *)&stack[COCO_STACKSAVE]; \
+  stack[4] = (size_t)(a0);  /* Assumes o32 ABI. */
+#define COCO_STACKADJUST        8
+#define COCO_MAIN_PARAM         int _a, int _b, int _c, int _d, lua_State *L
+
+#elif defined(__sparc__)
+
+typedef void *coco_ctx[4];
+#define COCO_CTX                coco_ctx
+#define COCO_SWITCH(from, to)   coco_switch(from, to);
+#define COCO_STACKADJUST        24
+
+#if defined(__LP64__)
+#define COCO_STACKBIAS          (2047UL)
+#define COCO_PTR2SP(stack)      (((unsigned long)stack)-COCO_STACKBIAS)
+static inline void coco_switch(coco_ctx from, coco_ctx to)
+{
+  void *__stack[16] __attribute__((aligned (16)));
+  unsigned long __tmp_sp = COCO_PTR2SP(__stack);
+  __asm__ __volatile__
+    (/* Flush register window(s) to stack and save the previous stack
+        pointer to capture the current registers, %l0-%l7 and %i0-%i7. */
+     "ta 3\n\t"
+     "stx %%sp,[%0+8]\n\t"
+     /* Move to a temporary stack. If the register window is flushed
+        for some reason (e.g. context switch), not the next stack
+        but the temporary stack should be used so as not to break
+        neither the previous nor next stack */
+     "mov %2,%%sp\n\t"
+     "sethi %%hh(1f),%%g1\n\t"          /* i.e. setx 1f,%%g1 */
+     "or %%g1,%%hm(1f),%%g1\n\t"
+     "sethi %%lm(1f),%%g2\n\t"
+     "or %%g2,%%lo(1f),%%g2\n\t"
+     "sllx %%g1,32,%%g1\n\t"
+     "or %%g1,%%g2,%%g1\n\t"
+     "stx %%g1,[%0]\n\t"
+     /* Restore registers from stack. DO NOT load the next stack
+        pointer directly to %sp. The register window can be possibly
+        flushed and restored asynchronous (e.g. context switch). */
+     "mov %1,%%o1\n\t"
+     "ldx [%%o1+8],%%o2\n\t"
+     "ldx [%%o2+%3],%%l0\n\t"
+     "ldx [%%o2+%3+8],%%l1\n\t"
+     "ldx [%%o2+%3+0x10],%%l2\n\t"
+     "ldx [%%o2+%3+0x18],%%l3\n\t"
+     "ldx [%%o2+%3+0x20],%%l4\n\t"
+     "ldx [%%o2+%3+0x28],%%l5\n\t"
+     "ldx [%%o2+%3+0x30],%%l6\n\t"
+     "ldx [%%o2+%3+0x38],%%l7\n\t"
+     "ldx [%%o2+%3+0x40],%%i0\n\t"
+     "ldx [%%o2+%3+0x48],%%i1\n\t"
+     "ldx [%%o2+%3+0x50],%%i2\n\t"
+     "ldx [%%o2+%3+0x58],%%i3\n\t"
+     "ldx [%%o2+%3+0x60],%%i4\n\t"
+     "ldx [%%o2+%3+0x68],%%i5\n\t"
+     "ldx [%%o2+%3+0x70],%%i6\n\t"
+     "ldx [%%o2+%3+0x78],%%i7\n\t"
+     /* Move to the next stack with the consistent registers atomically */
+     "mov %%o2,%%sp\n\t"
+     "ldx [%%o1],%%o2\n\t"
+     /* Since %o0-%o7 are marked as clobbered, values are safely overwritten
+        across the inline assembly.  %o0-%o7 will have meaningless values
+        after leaving the inline assembly. The only exception is %o0, which
+        serves as an argument to coco_main */
+     "ldx [%%o1+16],%%o0\n\t"
+     "jmpl %%o2,%%g0\n\t"
+     "nop\n\t"
+     "1:\n"
+     /* An assumption is made here; no input operand is assigned to %g1
+        nor %g2. It's the case for the currently avilable gcc's */
+     : : "r"(from),"r"(to),"r"(__tmp_sp),"i"(COCO_STACKBIAS)
+     : "g1","g2","o0","o1","o2","o3","o4","o5","o7","memory","cc");
+}
+
+#define COCO_MAKECTX(coco, buf, func, stack, a0) \
+  buf[0] = (void *)(func); \
+  buf[1] = (void *)COCO_PTR2SP(&(stack)[0]); \
+  buf[2] = (void *)(a0); \
+  stack[0] = 0; \
+  stack[1] = 0; \
+  stack[2] = 0; \
+  stack[3] = 0; \
+  stack[4] = 0; \
+  stack[5] = 0; \
+  stack[6] = 0; \
+  stack[7] = 0; \
+  stack[8] = 0; \
+  stack[9] = 0; \
+  stack[10] = 0; \
+  stack[11] = 0; \
+  stack[12] = 0; \
+  stack[13] = 0; \
+  stack[14] = COCO_PTR2SP(&(stack)[COCO_STACKADJUST]); \
+  stack[15] = 0xdeadc0c0deadc0c0; /* Dummy return address. */ \
+
+#else
+static inline void coco_switch(coco_ctx from, coco_ctx to)
+{
+  void *__tmp_stack[16] __attribute__((aligned (16)));
+  __asm__ __volatile__ 
+    ("ta 3\n\t"
+     "st %%sp,[%0+4]\n\t"
+     "mov %2,%%sp\n\t"
+     "set 1f,%%g1\n\t"
+     "st %%g1,[%0]\n\t"
+     "mov %1,%%o1\n\t"
+     "ld [%%o1+4],%%o2\n\t"
+     "ldd [%%o2],%%l0\n\t"
+     "ldd [%%o2+8],%%l2\n\t"
+     "ldd [%%o2+0x10],%%l4\n\t"
+     "ldd [%%o2+0x18],%%l6\n\t"
+     "ldd [%%o2+0x20],%%i0\n\t"
+     "ldd [%%o2+0x28],%%i2\n\t"
+     "ldd [%%o2+0x30],%%i4\n\t"
+     "ldd [%%o2+0x38],%%i6\n\t"
+     "mov %%o2,%%sp\n\t"
+     "ld [%%o1],%%o2\n\t"
+     "ld [%%o1+8],%%o0\n\t"
+     "jmpl %%o2,%%g0\n\t"
+     "nop\n\t"
+     "1:\n"
+     : : "r"(from),"r"(to),"r"(__tmp_stack)
+     : "g1","o0","o1","o2","o3","o4","o5","o7","memory","cc");
+}
+
+#define COCO_MAKECTX(coco, buf, func, stack, a0) \
+  buf[0] = (void *)(func); \
+  buf[1] = (void *)(stack); \
+  buf[2] = (void *)(a0); \
+  stack[0] = 0; \
+  stack[1] = 0; \
+  stack[2] = 0; \
+  stack[3] = 0; \
+  stack[4] = 0; \
+  stack[5] = 0; \
+  stack[6] = 0; \
+  stack[7] = 0; \
+  stack[8] = 0; \
+  stack[9] = 0; \
+  stack[10] = 0; \
+  stack[11] = 0; \
+  stack[12] = 0; \
+  stack[13] = 0; \
+  stack[14] = (size_t)&stack[COCO_STACKADJUST]; \
+  stack[15] = 0xdeadc0c0; /* Dummy return address. */ \
+
+#endif /* !define(__LP64__) */
+
+#endif /* arch check */
+
+#endif /* !(__GNUC__ >= 3 && !defined(COCO_USE_SETJMP)) */
+
+/* Try _setjmp/_longjmp with a patched jump buffer. */
+#ifndef COCO_MAKECTX
+#include <setjmp.h>
+
+/* Check for supported CPU+OS combinations. */
+#if defined(__i386) || defined(__i386__)
+
+#define COCO_STATE_HEAD         size_t arg0;
+#define COCO_SETJMP_X86(coco, stack, a0) \
+  stack[COCO_STACKADJUST-1] = 0xdeadc0c0;  /* Dummy return address. */ \
+  coco->arg0 = (size_t)(a0);
+
+#if __GLIBC__ == 2 && defined(JB_SP)            /* x86-linux-glibc2 */
+#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
+  buf->__jmpbuf[JB_PC] = (int)(func); \
+  buf->__jmpbuf[JB_SP] = (int)(stack); \
+  buf->__jmpbuf[JB_BP] = 0; \
+  COCO_SETJMP_X86(coco, stack, a0)
+#elif defined(__linux__) && defined(_I386_JMP_BUF_H)    /* x86-linux-libc5 */
+#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
+  buf->__pc = (func); \
+  buf->__sp = (stack); \
+  buf->__bp = NULL; \
+  COCO_SETJMP_X86(coco, stack, a0)
+#elif defined(__FreeBSD__)                      /* x86-FreeBSD */
+#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
+  buf->_jb[0] = (long)(func); \
+  buf->_jb[2] = (long)(stack); \
+  buf->_jb[3] = 0; /* ebp */ \
+  COCO_SETJMP_X86(coco, stack, a0)
+#define COCO_STACKADJUST        2
+#elif defined(__NetBSD__) || defined(__OpenBSD__) /* x86-NetBSD, x86-OpenBSD */
+#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
+  buf[0] = (long)(func); \
+  buf[2] = (long)(stack); \
+  buf[3] = 0; /* ebp */ \
+  COCO_SETJMP_X86(coco, stack, a0)
+#define COCO_STACKADJUST        2
+#elif defined(__solaris__) && _JBLEN == 10      /* x86-solaris */
+#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
+  buf[5] = (int)(func); \
+  buf[4] = (int)(stack); \
+  buf[3] = 0; \
+  COCO_SETJMP_X86(coco, stack, a0)
+#elif defined(__MACH__) && defined(_BSD_I386_SETJMP_H)  /* x86-macosx */
+#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
+  buf[12] = (int)(func); \
+  buf[9] = (int)(stack); \
+  buf[8] = 0; /* ebp */ \
+  COCO_SETJMP_X86(coco, stack, a0)
+#endif
+
+#elif defined(__x86_64__) || defined(__x86_64)
+
+#define COCO_STATE_HEAD         size_t arg0;
+
+#define COCO_MAIN_PARAM \
+  int _a, int _b, int _c, int _d, int _e, int _f, lua_State *L
+
+#if defined(__solaris__) && _JBLEN == 8                 /* x64-solaris */
+#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
+  buf[7] = (long)(func); \
+  buf[6] = (long)(stack); \
+  buf[5] = 0; \
+  stack[0] = 0xdeadc0c0;  /* Dummy return address. */ \
+  coco->arg0 = (size_t)(a0);
+#endif
+
+#elif defined(PPC) || defined(__ppc__) || defined(__PPC__) || \
+      defined(__powerpc__) || defined(__POWERPC__) || defined(_ARCH_PPC)
+
+#define COCO_STACKADJUST        16
+#define COCO_MAIN_PARAM \
+  int _a, int _b, int _c, int _d, int _e, int _f, int _g, int _h, lua_State *L
+
+#if defined(__MACH__) && defined(_BSD_PPC_SETJMP_H_)    /* ppc32-macosx */
+#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
+  buf[21] = (int)(func); \
+  buf[0] = (int)(stack); \
+  stack[6+8] = (size_t)(a0);
+#endif
+
+#elif (defined(MIPS) || defined(MIPSEL) || defined(__mips)) && \
+  _MIPS_SIM == _MIPS_SIM_ABI32 && !defined(__mips_eabi)
+
+/* Stack layout for o32 ABI. */
+#define COCO_STACKADJUST        8
+#define COCO_MAIN_PARAM         int _a, int _b, int _c, int _d, lua_State *L
+
+#if __GLIBC__ == 2 || defined(__UCLIBC__)       /* mips32-linux-glibc2 */
+#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
+  buf->__jmpbuf->__pc = (func); /* = t9 in _longjmp. Reqd. for -mabicalls. */ \
+  buf->__jmpbuf->__sp = (stack); \
+  buf->__jmpbuf->__fp = (void *)0; \
+  stack[4] = (size_t)(a0);
+#endif
+
+#elif defined(__arm__) || defined(__ARM__)
+
+#if __GLIBC__ == 2 || defined(__UCLIBC__)       /* arm-linux-glibc2 */
+#ifndef __JMP_BUF_SP
+#define __JMP_BUF_SP    ((sizeof(__jmp_buf)/sizeof(int))-2)
+#endif
+#define COCO_PATCHCTX(coco, buf, func, stack, a0) \
+  buf->__jmpbuf[__JMP_BUF_SP+1] = (int)(func); /* pc */ \
+  buf->__jmpbuf[__JMP_BUF_SP] = (int)(stack); /* sp */ \
+  buf->__jmpbuf[__JMP_BUF_SP-1] = 0; /* fp */ \
+  stack[0] = (size_t)(a0);
+#define COCO_STACKADJUST        2
+#define COCO_MAIN_PARAM         int _a, int _b, int _c, int _d, lua_State *L
+#endif
+
+#endif /* arch check */
+
+#ifdef COCO_PATCHCTX
+#define COCO_CTX                jmp_buf
+#define COCO_MAKECTX(coco, buf, func, stack, a0) \
+  _setjmp(buf); COCO_PATCHCTX(coco, buf, func, stack, a0)
+#define COCO_SWITCH(from, to)   if (!_setjmp(from)) _longjmp(to, 1);
+#endif
+
+#endif /* !defined(COCO_MAKECTX) */
+
+#endif /* !defined(COCO_USE_UCONTEXT) */
+
+/* ------------------------------------------------------------------------ */
+
+/* Use inline asm or _setjmp/_longjmp if available. */
+#ifdef COCO_MAKECTX
+
+#ifndef COCO_STACKADJUST
+#define COCO_STACKADJUST        1
+#endif
+
+#define COCO_FILL(coco, NL, mainfunc) \
+{ /* Include the return address to get proper stack alignment. */ \
+  size_t *stackptr = &((size_t *)coco)[-COCO_STACKADJUST]; \
+  COCO_MAKECTX(coco, coco->ctx, mainfunc, stackptr, NL) \
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Else fallback to ucontext. Slower, because it saves/restores signals. */
+#else /* !defined(COCO_MAKECTX) */
+
+#include <ucontext.h>
+
+#define COCO_CTX                ucontext_t
+
+/* Ugly workaround for makecontext() deficiencies on 64 bit CPUs. */
+/* Note that WIN64 (which is LLP64) never comes here. See above. */
+#if defined(__LP64__) || defined(_LP64) || INT_MAX != LONG_MAX
+/* 64 bit CPU: split the pointer into two 32 bit ints. */
+#define COCO_MAIN_PARAM         unsigned int lo, unsigned int hi
+#define COCO_MAIN_GETL \
+  lua_State *L = (lua_State *)((((unsigned long)hi)<<32)+(unsigned long)lo);
+#define COCO_MAKECTX(coco, NL, mainfunc) \
+  makecontext(&coco->ctx, mainfunc, 2, \
+    (int)(ptrdiff_t)NL, (int)((ptrdiff_t)NL>>32));
+#else
+/* 32 bit CPU: a pointer fits into an int. */
+#define COCO_MAKECTX(coco, NL, mainfunc) \
+  makecontext(&coco->ctx, mainfunc, 1, (int)NL);
+#endif
+
+#define COCO_FILL(coco, NL, mainfunc) \
+  getcontext(&coco->ctx); \
+  coco->ctx.uc_link = NULL;  /* We never exit from coco_main. */ \
+  coco->ctx.uc_stack.ss_sp = coco->allocptr; \
+  coco->ctx.uc_stack.ss_size = (char *)coco - (char *)(coco->allocptr); \
+  COCO_MAKECTX(coco, NL, mainfunc)
+
+#define COCO_SWITCH(from, to)   swapcontext(&(from), &(to));
+
+#endif /* !defined(COCO_MAKECTX) */
+
+
+/* Common code for inline asm/setjmp/ucontext to allocate/free the stack. */
+
+struct coco_State {
+#ifdef COCO_STATE_HEAD
+  COCO_STATE_HEAD
+#endif
+  COCO_CTX ctx;                 /* Own context. */
+  COCO_CTX back;                /* Context to switch back to. */
+  void *allocptr;               /* Pointer to allocated memory. */
+  int allocsize;                /* Size of allocated memory. */
+  int nargs;                    /* Number of arguments to pass. */
+  STACK_VGID                    /* Optional valgrind stack id. See above. */
+};
+
+typedef void (*coco_MainFunc)(void);
+
+/* Put the Coco state at the end and align it downwards. */
+#define ALIGNED_END(p, s, t) \
+  ((t *)(((char *)0) + ((((char *)(p)-(char *)0)+(s)-sizeof(t)) & -16)))
+
+/* TODO: use mmap. */
+#define COCO_NEW(OL, NL, cstacksize, mainfunc) \
+{ \
+  void *ptr = luaM_malloc(OL, cstacksize); \
+  coco_State *coco = ALIGNED_END(ptr, cstacksize, coco_State); \
+  STACK_REG(coco, ptr, cstacksize) \
+  coco->allocptr = ptr; \
+  coco->allocsize = cstacksize; \
+  COCO_FILL(coco, NL, mainfunc) \
+  L2COCO(NL) = coco; \
+}
+
+#define COCO_FREE(L) \
+  STACK_DEREG(L2COCO(L)) \
+  luaM_freemem(L, L2COCO(L)->allocptr, L2COCO(L)->allocsize); \
+  L2COCO(L) = NULL;
+
+#define COCO_JUMPIN(coco)       COCO_SWITCH(coco->back, coco->ctx)
+#define COCO_JUMPOUT(coco)      COCO_SWITCH(coco->ctx, coco->back)
+
+#endif /* !COCO_USE_FIBERS */
+
+/* ------------------------------------------------------------------------ */
+
+#ifndef COCO_MIN_CSTACKSIZE
+#define COCO_MIN_CSTACKSIZE             (32768+4096)
+#endif
+
+/* Don't use multiples of 64K to avoid D-cache aliasing conflicts. */
+#ifndef COCO_DEFAULT_CSTACKSIZE
+#define COCO_DEFAULT_CSTACKSIZE         (65536-4096)
+#endif
+
+static int defaultcstacksize = COCO_DEFAULT_CSTACKSIZE;
+
+/* Start the Lua or C function. */
+static void coco_start(lua_State *L, void *ud)
+{
+  if (luaD_precall(L, (StkId)ud, LUA_MULTRET) == PCRLUA)
+    luaV_execute(L, L->ci - L->base_ci);
+}
+
+#ifndef COCO_MAIN_PARAM
+#define COCO_MAIN_PARAM         lua_State *L
+#endif
+
+#ifndef COCO_MAIN_DECL
+#define COCO_MAIN_DECL
+#endif
+
+/* Toplevel function for the new coroutine stack. Never exits. */
+static void COCO_MAIN_DECL coco_main(COCO_MAIN_PARAM)
+{
+#ifdef COCO_MAIN_GETL
+  COCO_MAIN_GETL
+#endif
+  coco_State *coco = L2COCO(L);
+  for (;;) {
+    L->status = luaD_rawrunprotected(L, coco_start, L->top - (coco->nargs+1));
+    if (L->status != 0) luaD_seterrorobj(L, L->status, L->top);
+    COCO_JUMPOUT(coco)
+  }
+}
+
+/* Add a C stack to a coroutine. */
+lua_State *lua_newcthread(lua_State *OL, int cstacksize)
+{
+  lua_State *NL = lua_newthread(OL);
+
+  if (cstacksize < 0)
+    return NL;
+  if (cstacksize == 0)
+    cstacksize = defaultcstacksize;
+  else if (cstacksize < COCO_MIN_CSTACKSIZE)
+    cstacksize = COCO_MIN_CSTACKSIZE;
+  cstacksize &= -16;
+
+  COCO_NEW(OL, NL, cstacksize, ((coco_MainFunc)(coco_main)))
+
+  return NL;
+}
+
+/* Free the C stack of a coroutine. Called from lstate.c. */
+void luaCOCO_free(lua_State *L)
+{
+  COCO_FREE(L)
+}
+
+/* Resume a coroutine with a C stack. Called from ldo.c. */
+int luaCOCO_resume(lua_State *L, int nargs)
+{
+  coco_State *coco = L2COCO(L);
+  coco->nargs = nargs;
+  COCO_JUMPIN(coco)
+#ifndef COCO_DISABLE_EARLY_FREE
+  if (L->status != LUA_YIELD) {
+    COCO_FREE(L)
+  }
+#endif
+  return L->status;
+}
+
+/* Yield from a coroutine with a C stack. Called from ldo.c. */
+int luaCOCO_yield(lua_State *L)
+{
+  coco_State *coco = L2COCO(L);
+  L->status = LUA_YIELD;
+  COCO_JUMPOUT(coco)
+  L->status = 0;
+  {
+    StkId base = L->top - coco->nargs;
+    StkId rbase = L->base;
+    if (rbase < base) {  /* Need to move args down? */
+      while (base < L->top)
+        setobjs2s(L, rbase++, base++);
+      L->top = rbase;
+    }
+  }
+  L->base = L->ci->base;  /* Restore invariant. */
+  return coco->nargs;
+}
+
+/* Get/set the default C stack size. */
+int luaCOCO_cstacksize(int cstacksize)
+{
+  int oldsz = defaultcstacksize;
+  if (cstacksize >= 0) {
+    if (cstacksize == 0)
+      cstacksize = COCO_DEFAULT_CSTACKSIZE;
+    else if (cstacksize < COCO_MIN_CSTACKSIZE)
+      cstacksize = COCO_MIN_CSTACKSIZE;
+    defaultcstacksize = cstacksize;
+  }
+  return oldsz;
+}
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lcoco.h b/libraries/LuaJIT-1.1.7/src/lcoco.h
new file mode 100644
index 0000000..9fb6207
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lcoco.h
@@ -0,0 +1,72 @@
+/*
+** Lua/Coco glue.
+** Copyright (C) 2004-2011 Mike Pall. See copyright notice in lcoco.c
+*/
+
+#ifndef lcoco_h
+#define lcoco_h
+
+#define LUACOCO_VERSION         "Coco 1.1.6"
+#define LUACOCO_VERSION_NUM     10106
+
+/* Exported C API to add a C stack to a coroutine. */
+LUA_API lua_State *lua_newcthread(lua_State *L, int cstacksize);
+
+/* Internal support routines. */
+LUAI_FUNC void luaCOCO_free(lua_State *L);
+LUAI_FUNC int luaCOCO_resume(lua_State *L, int nargs);
+LUAI_FUNC int luaCOCO_yield(lua_State *L);
+LUAI_FUNC int luaCOCO_cstacksize(int cstacksize);
+
+/* Forward declaration. */
+typedef struct coco_State coco_State;
+
+/* These are redefined below. */
+#undef LUAI_EXTRASPACE
+#undef luai_userstateopen
+/* luai_userstateclose unused */
+#undef luai_userstatethread
+#undef luai_userstatefree
+#undef luai_userstateresume
+#undef luai_userstateyield
+
+/* Use Windows Fibers (Win98+). */
+#if defined(_WIN32)
+
+/* Fibers allocate their own stack. The whole Coco state is in front of L. */
+struct coco_State {
+  void *fib;                    /* Own fiber (if any). */
+  void *back;                   /* Fiber to switch back to. */
+  int nargs;                    /* Number of arguments to pass. */
+  int dummy_align;
+};
+
+#define L2COCO(L)               (&((coco_State *)(L))[-1])
+#define LHASCOCO(L)             (L2COCO(L)->fib)
+#define LUAI_EXTRASPACE         sizeof(coco_State)
+#define luai_userstateopen(L)   L2COCO(L)->fib = NULL
+#define luai_userstatethread(L,L1)      L2COCO(L1)->fib = NULL
+#define COCO_USE_FIBERS
+
+#else /* !defined(_WIN32) */
+
+/* The Coco state depends on the context switch method used. See lcoco.c. */
+/* It's stored at the end of the stack. Only need a pointer in front of L. */
+#define L2COCO(L)               (((coco_State **)(L))[-1])
+#define LHASCOCO(L)             (L2COCO(L))
+/* This wastes some space on 32 bit systems, but gets better alignment. */
+#define LUAI_EXTRASPACE         sizeof(LUAI_USER_ALIGNMENT_T)
+#define luai_userstateopen(L)   L2COCO(L) = NULL
+#define luai_userstatethread(L,L1)      L2COCO(L1) = NULL
+
+#endif /* !defined(_WIN32) */
+
+#define luai_userstatefree(L)   if (LHASCOCO(L)) luaCOCO_free(L)
+#define luai_userstateresume(L, nargs) \
+  if (LHASCOCO(L)) return luaCOCO_resume(L, nargs)
+#define luai_userstateyield(L, nresults) \
+  do { if (LHASCOCO(L)) { \
+    L->base = L->top - (nresults);  /* Protect stack slots below. */ \
+    return luaCOCO_yield(L); } } while (0)
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lcode.c b/libraries/LuaJIT-1.1.7/src/lcode.c
new file mode 100644
index 0000000..c13066e
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lcode.c
@@ -0,0 +1,831 @@
+/*
+** $Id: lcode.c,v 2.25.1.3 2007/12/28 15:32:23 roberto Exp $
+** Code generator for Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stdlib.h>
+
+#define lcode_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lcode.h"
+#include "ldebug.h"
+#include "ldo.h"
+#include "lgc.h"
+#include "llex.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lparser.h"
+#include "ltable.h"
+
+
+#define hasjumps(e)     ((e)->t != (e)->f)
+
+
+static int isnumeral(expdesc *e) {
+  return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP);
+}
+
+
+void luaK_nil (FuncState *fs, int from, int n) {
+  Instruction *previous;
+  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */
+    if (fs->pc == 0) {  /* function start? */
+      if (from >= fs->nactvar)
+        return;  /* positions are already clean */
+    }
+    else {
+      previous = &fs->f->code[fs->pc-1];
+      if (GET_OPCODE(*previous) == OP_LOADNIL) {
+        int pfrom = GETARG_A(*previous);
+        int pto = GETARG_B(*previous);
+        if (pfrom <= from && from <= pto+1) {  /* can connect both? */
+          if (from+n-1 > pto)
+            SETARG_B(*previous, from+n-1);
+          return;
+        }
+      }
+    }
+  }
+  luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0);  /* else no optimization */
+}
+
+
+int luaK_jump (FuncState *fs) {
+  int jpc = fs->jpc;  /* save list of jumps to here */
+  int j;
+  fs->jpc = NO_JUMP;
+  j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);
+  luaK_concat(fs, &j, jpc);  /* keep them on hold */
+  return j;
+}
+
+
+void luaK_ret (FuncState *fs, int first, int nret) {
+  luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);
+}
+
+
+static int condjump (FuncState *fs, OpCode op, int A, int B, int C) {
+  luaK_codeABC(fs, op, A, B, C);
+  return luaK_jump(fs);
+}
+
+
+static void fixjump (FuncState *fs, int pc, int dest) {
+  Instruction *jmp = &fs->f->code[pc];
+  int offset = dest-(pc+1);
+  lua_assert(dest != NO_JUMP);
+  if (abs(offset) > MAXARG_sBx)
+    luaX_syntaxerror(fs->ls, "control structure too long");
+  SETARG_sBx(*jmp, offset);
+}
+
+
+/*
+** returns current `pc' and marks it as a jump target (to avoid wrong
+** optimizations with consecutive instructions not in the same basic block).
+*/
+int luaK_getlabel (FuncState *fs) {
+  fs->lasttarget = fs->pc;
+  return fs->pc;
+}
+
+
+static int getjump (FuncState *fs, int pc) {
+  int offset = GETARG_sBx(fs->f->code[pc]);
+  if (offset == NO_JUMP)  /* point to itself represents end of list */
+    return NO_JUMP;  /* end of list */
+  else
+    return (pc+1)+offset;  /* turn offset into absolute position */
+}
+
+
+static Instruction *getjumpcontrol (FuncState *fs, int pc) {
+  Instruction *pi = &fs->f->code[pc];
+  if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))
+    return pi-1;
+  else
+    return pi;
+}
+
+
+/*
+** check whether list has any jump that do not produce a value
+** (or produce an inverted value)
+*/
+static int need_value (FuncState *fs, int list) {
+  for (; list != NO_JUMP; list = getjump(fs, list)) {
+    Instruction i = *getjumpcontrol(fs, list);
+    if (GET_OPCODE(i) != OP_TESTSET) return 1;
+  }
+  return 0;  /* not found */
+}
+
+
+static int patchtestreg (FuncState *fs, int node, int reg) {
+  Instruction *i = getjumpcontrol(fs, node);
+  if (GET_OPCODE(*i) != OP_TESTSET)
+    return 0;  /* cannot patch other instructions */
+  if (reg != NO_REG && reg != GETARG_B(*i))
+    SETARG_A(*i, reg);
+  else  /* no register to put value or register already has the value */
+    *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));
+
+  return 1;
+}
+
+
+static void removevalues (FuncState *fs, int list) {
+  for (; list != NO_JUMP; list = getjump(fs, list))
+      patchtestreg(fs, list, NO_REG);
+}
+
+
+static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,
+                          int dtarget) {
+  while (list != NO_JUMP) {
+    int next = getjump(fs, list);
+    if (patchtestreg(fs, list, reg))
+      fixjump(fs, list, vtarget);
+    else
+      fixjump(fs, list, dtarget);  /* jump to default target */
+    list = next;
+  }
+}
+
+
+static void dischargejpc (FuncState *fs) {
+  patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc);
+  fs->jpc = NO_JUMP;
+}
+
+
+void luaK_patchlist (FuncState *fs, int list, int target) {
+  if (target == fs->pc)
+    luaK_patchtohere(fs, list);
+  else {
+    lua_assert(target < fs->pc);
+    patchlistaux(fs, list, target, NO_REG, target);
+  }
+}
+
+
+void luaK_patchtohere (FuncState *fs, int list) {
+  luaK_getlabel(fs);
+  luaK_concat(fs, &fs->jpc, list);
+}
+
+
+void luaK_concat (FuncState *fs, int *l1, int l2) {
+  if (l2 == NO_JUMP) return;
+  else if (*l1 == NO_JUMP)
+    *l1 = l2;
+  else {
+    int list = *l1;
+    int next;
+    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */
+      list = next;
+    fixjump(fs, list, l2);
+  }
+}
+
+
+void luaK_checkstack (FuncState *fs, int n) {
+  int newstack = fs->freereg + n;
+  if (newstack > fs->f->maxstacksize) {
+    if (newstack >= MAXSTACK)
+      luaX_syntaxerror(fs->ls, "function or expression too complex");
+    fs->f->maxstacksize = cast_byte(newstack);
+  }
+}
+
+
+void luaK_reserveregs (FuncState *fs, int n) {
+  luaK_checkstack(fs, n);
+  fs->freereg += n;
+}
+
+
+static void freereg (FuncState *fs, int reg) {
+  if (!ISK(reg) && reg >= fs->nactvar) {
+    fs->freereg--;
+    lua_assert(reg == fs->freereg);
+  }
+}
+
+
+static void freeexp (FuncState *fs, expdesc *e) {
+  if (e->k == VNONRELOC)
+    freereg(fs, e->u.s.info);
+}
+
+
+static int addk (FuncState *fs, TValue *k, TValue *v) {
+  lua_State *L = fs->L;
+  TValue *idx = luaH_set(L, fs->h, k);
+  Proto *f = fs->f;
+  int oldsize = f->sizek;
+  if (ttisnumber(idx)) {
+    lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v));
+    return cast_int(nvalue(idx));
+  }
+  else {  /* constant not found; create a new entry */
+    setnvalue(idx, cast_num(fs->nk));
+    luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,
+                    MAXARG_Bx, "constant table overflow");
+    while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
+    setobj(L, &f->k[fs->nk], v);
+    luaC_barrier(L, f, v);
+    return fs->nk++;
+  }
+}
+
+
+int luaK_stringK (FuncState *fs, TString *s) {
+  TValue o;
+  setsvalue(fs->L, &o, s);
+  return addk(fs, &o, &o);
+}
+
+
+int luaK_numberK (FuncState *fs, lua_Number r) {
+  TValue o;
+  setnvalue(&o, r);
+  return addk(fs, &o, &o);
+}
+
+
+static int boolK (FuncState *fs, int b) {
+  TValue o;
+  setbvalue(&o, b);
+  return addk(fs, &o, &o);
+}
+
+
+static int nilK (FuncState *fs) {
+  TValue k, v;
+  setnilvalue(&v);
+  /* cannot use nil as key; instead use table itself to represent nil */
+  sethvalue(fs->L, &k, fs->h);
+  return addk(fs, &k, &v);
+}
+
+
+void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
+  if (e->k == VCALL) {  /* expression is an open function call? */
+    SETARG_C(getcode(fs, e), nresults+1);
+  }
+  else if (e->k == VVARARG) {
+    SETARG_B(getcode(fs, e), nresults+1);
+    SETARG_A(getcode(fs, e), fs->freereg);
+    luaK_reserveregs(fs, 1);
+  }
+}
+
+
+void luaK_setoneret (FuncState *fs, expdesc *e) {
+  if (e->k == VCALL) {  /* expression is an open function call? */
+    e->k = VNONRELOC;
+    e->u.s.info = GETARG_A(getcode(fs, e));
+  }
+  else if (e->k == VVARARG) {
+    SETARG_B(getcode(fs, e), 2);
+    e->k = VRELOCABLE;  /* can relocate its simple result */
+  }
+}
+
+
+void luaK_dischargevars (FuncState *fs, expdesc *e) {
+  switch (e->k) {
+    case VLOCAL: {
+      e->k = VNONRELOC;
+      break;
+    }
+    case VUPVAL: {
+      e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0);
+      e->k = VRELOCABLE;
+      break;
+    }
+    case VGLOBAL: {
+      e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info);
+      e->k = VRELOCABLE;
+      break;
+    }
+    case VINDEXED: {
+      freereg(fs, e->u.s.aux);
+      freereg(fs, e->u.s.info);
+      e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux);
+      e->k = VRELOCABLE;
+      break;
+    }
+    case VVARARG:
+    case VCALL: {
+      luaK_setoneret(fs, e);
+      break;
+    }
+    default: break;  /* there is one value available (somewhere) */
+  }
+}
+
+
+static int code_label (FuncState *fs, int A, int b, int jump) {
+  luaK_getlabel(fs);  /* those instructions may be jump targets */
+  return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump);
+}
+
+
+static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
+  luaK_dischargevars(fs, e);
+  switch (e->k) {
+    case VNIL: {
+      luaK_nil(fs, reg, 1);
+      break;
+    }
+    case VFALSE:  case VTRUE: {
+      luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
+      break;
+    }
+    case VK: {
+      luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);
+      break;
+    }
+    case VKNUM: {
+      luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));
+      break;
+    }
+    case VRELOCABLE: {
+      Instruction *pc = &getcode(fs, e);
+      SETARG_A(*pc, reg);
+      break;
+    }
+    case VNONRELOC: {
+      if (reg != e->u.s.info)
+        luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);
+      break;
+    }
+    default: {
+      lua_assert(e->k == VVOID || e->k == VJMP);
+      return;  /* nothing to do... */
+    }
+  }
+  e->u.s.info = reg;
+  e->k = VNONRELOC;
+}
+
+
+static void discharge2anyreg (FuncState *fs, expdesc *e) {
+  if (e->k != VNONRELOC) {
+    luaK_reserveregs(fs, 1);
+    discharge2reg(fs, e, fs->freereg-1);
+  }
+}
+
+
+static void exp2reg (FuncState *fs, expdesc *e, int reg) {
+  discharge2reg(fs, e, reg);
+  if (e->k == VJMP)
+    luaK_concat(fs, &e->t, e->u.s.info);  /* put this jump in `t' list */
+  if (hasjumps(e)) {
+    int final;  /* position after whole expression */
+    int p_f = NO_JUMP;  /* position of an eventual LOAD false */
+    int p_t = NO_JUMP;  /* position of an eventual LOAD true */
+    if (need_value(fs, e->t) || need_value(fs, e->f)) {
+      int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
+      p_f = code_label(fs, reg, 0, 1);
+      p_t = code_label(fs, reg, 1, 0);
+      luaK_patchtohere(fs, fj);
+    }
+    final = luaK_getlabel(fs);
+    patchlistaux(fs, e->f, final, reg, p_f);
+    patchlistaux(fs, e->t, final, reg, p_t);
+  }
+  e->f = e->t = NO_JUMP;
+  e->u.s.info = reg;
+  e->k = VNONRELOC;
+}
+
+
+void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
+  luaK_dischargevars(fs, e);
+  freeexp(fs, e);
+  luaK_reserveregs(fs, 1);
+  exp2reg(fs, e, fs->freereg - 1);
+}
+
+
+int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
+  luaK_dischargevars(fs, e);
+  if (e->k == VNONRELOC) {
+    if (!hasjumps(e)) return e->u.s.info;  /* exp is already in a register */
+    if (e->u.s.info >= fs->nactvar) {  /* reg. is not a local? */
+      exp2reg(fs, e, e->u.s.info);  /* put value on it */
+      return e->u.s.info;
+    }
+  }
+  luaK_exp2nextreg(fs, e);  /* default */
+  return e->u.s.info;
+}
+
+
+void luaK_exp2val (FuncState *fs, expdesc *e) {
+  if (hasjumps(e))
+    luaK_exp2anyreg(fs, e);
+  else
+    luaK_dischargevars(fs, e);
+}
+
+
+int luaK_exp2RK (FuncState *fs, expdesc *e) {
+  luaK_exp2val(fs, e);
+  switch (e->k) {
+    case VKNUM:
+    case VTRUE:
+    case VFALSE:
+    case VNIL: {
+      if (fs->nk <= MAXINDEXRK) {  /* constant fit in RK operand? */
+        e->u.s.info = (e->k == VNIL)  ? nilK(fs) :
+                      (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :
+                                        boolK(fs, (e->k == VTRUE));
+        e->k = VK;
+        return RKASK(e->u.s.info);
+      }
+      else break;
+    }
+    case VK: {
+      if (e->u.s.info <= MAXINDEXRK)  /* constant fit in argC? */
+        return RKASK(e->u.s.info);
+      else break;
+    }
+    default: break;
+  }
+  /* not a constant in the right range: put it in a register */
+  return luaK_exp2anyreg(fs, e);
+}
+
+
+void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
+  switch (var->k) {
+    case VLOCAL: {
+      freeexp(fs, ex);
+      exp2reg(fs, ex, var->u.s.info);
+      return;
+    }
+    case VUPVAL: {
+      int e = luaK_exp2anyreg(fs, ex);
+      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);
+      break;
+    }
+    case VGLOBAL: {
+      int e = luaK_exp2anyreg(fs, ex);
+      luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);
+      break;
+    }
+    case VINDEXED: {
+      int e = luaK_exp2RK(fs, ex);
+      luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);
+      break;
+    }
+    default: {
+      lua_assert(0);  /* invalid var kind to store */
+      break;
+    }
+  }
+  freeexp(fs, ex);
+}
+
+
+void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
+  int func;
+  luaK_exp2anyreg(fs, e);
+  freeexp(fs, e);
+  func = fs->freereg;
+  luaK_reserveregs(fs, 2);
+  luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));
+  freeexp(fs, key);
+  e->u.s.info = func;
+  e->k = VNONRELOC;
+}
+
+
+static void invertjump (FuncState *fs, expdesc *e) {
+  Instruction *pc = getjumpcontrol(fs, e->u.s.info);
+  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
+                                           GET_OPCODE(*pc) != OP_TEST);
+  SETARG_A(*pc, !(GETARG_A(*pc)));
+}
+
+
+static int jumponcond (FuncState *fs, expdesc *e, int cond) {
+  if (e->k == VRELOCABLE) {
+    Instruction ie = getcode(fs, e);
+    if (GET_OPCODE(ie) == OP_NOT) {
+      fs->pc--;  /* remove previous OP_NOT */
+      return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);
+    }
+    /* else go through */
+  }
+  discharge2anyreg(fs, e);
+  freeexp(fs, e);
+  return condjump(fs, OP_TESTSET, NO_REG, e->u.s.info, cond);
+}
+
+
+void luaK_goiftrue (FuncState *fs, expdesc *e) {
+  int pc;  /* pc of last jump */
+  luaK_dischargevars(fs, e);
+  switch (e->k) {
+    case VK: case VKNUM: case VTRUE: {
+      pc = NO_JUMP;  /* always true; do nothing */
+      break;
+    }
+    case VJMP: {
+      invertjump(fs, e);
+      pc = e->u.s.info;
+      break;
+    }
+    default: {
+      pc = jumponcond(fs, e, 0);
+      break;
+    }
+  }
+  luaK_concat(fs, &e->f, pc);  /* insert last jump in `f' list */
+  luaK_patchtohere(fs, e->t);
+  e->t = NO_JUMP;
+}
+
+
+static void luaK_goiffalse (FuncState *fs, expdesc *e) {
+  int pc;  /* pc of last jump */
+  luaK_dischargevars(fs, e);
+  switch (e->k) {
+    case VNIL: case VFALSE: {
+      pc = NO_JUMP;  /* always false; do nothing */
+      break;
+    }
+    case VJMP: {
+      pc = e->u.s.info;
+      break;
+    }
+    default: {
+      pc = jumponcond(fs, e, 1);
+      break;
+    }
+  }
+  luaK_concat(fs, &e->t, pc);  /* insert last jump in `t' list */
+  luaK_patchtohere(fs, e->f);
+  e->f = NO_JUMP;
+}
+
+
+static void codenot (FuncState *fs, expdesc *e) {
+  luaK_dischargevars(fs, e);
+  switch (e->k) {
+    case VNIL: case VFALSE: {
+      e->k = VTRUE;
+      break;
+    }
+    case VK: case VKNUM: case VTRUE: {
+      e->k = VFALSE;
+      break;
+    }
+    case VJMP: {
+      invertjump(fs, e);
+      break;
+    }
+    case VRELOCABLE:
+    case VNONRELOC: {
+      discharge2anyreg(fs, e);
+      freeexp(fs, e);
+      e->u.s.info = luaK_codeABC(fs, OP_NOT, 0, e->u.s.info, 0);
+      e->k = VRELOCABLE;
+      break;
+    }
+    default: {
+      lua_assert(0);  /* cannot happen */
+      break;
+    }
+  }
+  /* interchange true and false lists */
+  { int temp = e->f; e->f = e->t; e->t = temp; }
+  removevalues(fs, e->f);
+  removevalues(fs, e->t);
+}
+
+
+void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
+  t->u.s.aux = luaK_exp2RK(fs, k);
+  t->k = VINDEXED;
+}
+
+
+static int constfolding (OpCode op, expdesc *e1, expdesc *e2) {
+  lua_Number v1, v2, r;
+  if (!isnumeral(e1) || !isnumeral(e2)) return 0;
+  v1 = e1->u.nval;
+  v2 = e2->u.nval;
+  switch (op) {
+    case OP_ADD: r = luai_numadd(v1, v2); break;
+    case OP_SUB: r = luai_numsub(v1, v2); break;
+    case OP_MUL: r = luai_nummul(v1, v2); break;
+    case OP_DIV:
+      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
+      r = luai_numdiv(v1, v2); break;
+    case OP_MOD:
+      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
+      r = luai_nummod(v1, v2); break;
+    case OP_POW: r = luai_numpow(v1, v2); break;
+    case OP_UNM: r = luai_numunm(v1); break;
+    case OP_LEN: return 0;  /* no constant folding for 'len' */
+    default: lua_assert(0); r = 0; break;
+  }
+  if (luai_numisnan(r)) return 0;  /* do not attempt to produce NaN */
+  e1->u.nval = r;
+  return 1;
+}
+
+
+static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {
+  if (constfolding(op, e1, e2))
+    return;
+  else {
+    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
+    int o1 = luaK_exp2RK(fs, e1);
+    if (o1 > o2) {
+      freeexp(fs, e1);
+      freeexp(fs, e2);
+    }
+    else {
+      freeexp(fs, e2);
+      freeexp(fs, e1);
+    }
+    e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);
+    e1->k = VRELOCABLE;
+  }
+}
+
+
+static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1,
+                                                          expdesc *e2) {
+  int o1 = luaK_exp2RK(fs, e1);
+  int o2 = luaK_exp2RK(fs, e2);
+  freeexp(fs, e2);
+  freeexp(fs, e1);
+  if (cond == 0 && op != OP_EQ) {
+    int temp;  /* exchange args to replace by `<' or `<=' */
+    temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */
+    cond = 1;
+  }
+  e1->u.s.info = condjump(fs, op, cond, o1, o2);
+  e1->k = VJMP;
+}
+
+
+void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
+  expdesc e2;
+  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
+  switch (op) {
+    case OPR_MINUS: {
+      if (!isnumeral(e))
+        luaK_exp2anyreg(fs, e);  /* cannot operate on non-numeric constants */
+      codearith(fs, OP_UNM, e, &e2);
+      break;
+    }
+    case OPR_NOT: codenot(fs, e); break;
+    case OPR_LEN: {
+      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
+      codearith(fs, OP_LEN, e, &e2);
+      break;
+    }
+    default: lua_assert(0);
+  }
+}
+
+
+void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
+  switch (op) {
+    case OPR_AND: {
+      luaK_goiftrue(fs, v);
+      break;
+    }
+    case OPR_OR: {
+      luaK_goiffalse(fs, v);
+      break;
+    }
+    case OPR_CONCAT: {
+      luaK_exp2nextreg(fs, v);  /* operand must be on the `stack' */
+      break;
+    }
+    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
+    case OPR_MOD: case OPR_POW: {
+      if (!isnumeral(v)) luaK_exp2RK(fs, v);
+      break;
+    }
+    default: {
+      luaK_exp2RK(fs, v);
+      break;
+    }
+  }
+}
+
+
+void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
+  switch (op) {
+    case OPR_AND: {
+      lua_assert(e1->t == NO_JUMP);  /* list must be closed */
+      luaK_dischargevars(fs, e2);
+      luaK_concat(fs, &e2->f, e1->f);
+      *e1 = *e2;
+      break;
+    }
+    case OPR_OR: {
+      lua_assert(e1->f == NO_JUMP);  /* list must be closed */
+      luaK_dischargevars(fs, e2);
+      luaK_concat(fs, &e2->t, e1->t);
+      *e1 = *e2;
+      break;
+    }
+    case OPR_CONCAT: {
+      luaK_exp2val(fs, e2);
+      if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) {
+        lua_assert(e1->u.s.info == GETARG_B(getcode(fs, e2))-1);
+        freeexp(fs, e1);
+        SETARG_B(getcode(fs, e2), e1->u.s.info);
+        e1->k = VRELOCABLE; e1->u.s.info = e2->u.s.info;
+      }
+      else {
+        luaK_exp2nextreg(fs, e2);  /* operand must be on the 'stack' */
+        codearith(fs, OP_CONCAT, e1, e2);
+      }
+      break;
+    }
+    case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
+    case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
+    case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
+    case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
+    case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
+    case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
+    case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
+    case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
+    case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
+    case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
+    case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
+    case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
+    default: lua_assert(0);
+  }
+}
+
+
+void luaK_fixline (FuncState *fs, int line) {
+  fs->f->lineinfo[fs->pc - 1] = line;
+}
+
+
+static int luaK_code (FuncState *fs, Instruction i, int line) {
+  Proto *f = fs->f;
+  dischargejpc(fs);  /* `pc' will change */
+  /* put new instruction in code array */
+  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
+                  MAX_INT, "code size overflow");
+  f->code[fs->pc] = i;
+  /* save corresponding line information */
+  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
+                  MAX_INT, "code size overflow");
+  f->lineinfo[fs->pc] = line;
+  return fs->pc++;
+}
+
+
+int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) {
+  lua_assert(getOpMode(o) == iABC);
+  lua_assert(getBMode(o) != OpArgN || b == 0);
+  lua_assert(getCMode(o) != OpArgN || c == 0);
+  return luaK_code(fs, CREATE_ABC(o, a, b, c), fs->ls->lastline);
+}
+
+
+int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) {
+  lua_assert(getOpMode(o) == iABx || getOpMode(o) == iAsBx);
+  lua_assert(getCMode(o) == OpArgN);
+  return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline);
+}
+
+
+void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
+  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;
+  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
+  lua_assert(tostore != 0);
+  if (c <= MAXARG_C)
+    luaK_codeABC(fs, OP_SETLIST, base, b, c);
+  else {
+    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
+    luaK_code(fs, cast(Instruction, c), fs->ls->lastline);
+  }
+  fs->freereg = base + 1;  /* free registers with list values */
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lcode.h b/libraries/LuaJIT-1.1.7/src/lcode.h
new file mode 100644
index 0000000..b941c60
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lcode.h
@@ -0,0 +1,76 @@
+/*
+** $Id: lcode.h,v 1.48.1.1 2007/12/27 13:02:25 roberto Exp $
+** Code generator for Lua
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lcode_h
+#define lcode_h
+
+#include "llex.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lparser.h"
+
+
+/*
+** Marks the end of a patch list. It is an invalid value both as an absolute
+** address, and as a list link (would link an element to itself).
+*/
+#define NO_JUMP (-1)
+
+
+/*
+** grep "ORDER OPR" if you change these enums
+*/
+typedef enum BinOpr {
+  OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
+  OPR_CONCAT,
+  OPR_NE, OPR_EQ,
+  OPR_LT, OPR_LE, OPR_GT, OPR_GE,
+  OPR_AND, OPR_OR,
+  OPR_NOBINOPR
+} BinOpr;
+
+
+typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
+
+
+#define getcode(fs,e)   ((fs)->f->code[(e)->u.s.info])
+
+#define luaK_codeAsBx(fs,o,A,sBx)       luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
+
+#define luaK_setmultret(fs,e)   luaK_setreturns(fs, e, LUA_MULTRET)
+
+LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
+LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
+LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
+LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
+LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
+LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
+LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
+LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
+LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
+LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
+LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
+LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
+LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
+LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
+LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
+LUAI_FUNC int luaK_jump (FuncState *fs);
+LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
+LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
+LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
+LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
+LUAI_FUNC int luaK_getlabel (FuncState *fs);
+LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);
+LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
+LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);
+LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
+
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ldblib.c b/libraries/LuaJIT-1.1.7/src/ldblib.c
new file mode 100644
index 0000000..21116ac
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ldblib.c
@@ -0,0 +1,398 @@
+/*
+** $Id: ldblib.c,v 1.104.1.3 2008/01/21 13:11:21 roberto Exp $
+** Interface from Lua to its debug API
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define ldblib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+
+
+
+static int db_getregistry (lua_State *L) {
+  lua_pushvalue(L, LUA_REGISTRYINDEX);
+  return 1;
+}
+
+
+static int db_getmetatable (lua_State *L) {
+  luaL_checkany(L, 1);
+  if (!lua_getmetatable(L, 1)) {
+    lua_pushnil(L);  /* no metatable */
+  }
+  return 1;
+}
+
+
+static int db_setmetatable (lua_State *L) {
+  int t = lua_type(L, 2);
+  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
+                    "nil or table expected");
+  lua_settop(L, 2);
+  lua_pushboolean(L, lua_setmetatable(L, 1));
+  return 1;
+}
+
+
+static int db_getfenv (lua_State *L) {
+  luaL_checkany(L, 1);
+  lua_getfenv(L, 1);
+  return 1;
+}
+
+
+static int db_setfenv (lua_State *L) {
+  luaL_checktype(L, 2, LUA_TTABLE);
+  lua_settop(L, 2);
+  if (lua_setfenv(L, 1) == 0)
+    luaL_error(L, LUA_QL("setfenv")
+                  " cannot change environment of given object");
+  return 1;
+}
+
+
+static void settabss (lua_State *L, const char *i, const char *v) {
+  lua_pushstring(L, v);
+  lua_setfield(L, -2, i);
+}
+
+
+static void settabsi (lua_State *L, const char *i, int v) {
+  lua_pushinteger(L, v);
+  lua_setfield(L, -2, i);
+}
+
+
+static lua_State *getthread (lua_State *L, int *arg) {
+  if (lua_isthread(L, 1)) {
+    *arg = 1;
+    return lua_tothread(L, 1);
+  }
+  else {
+    *arg = 0;
+    return L;
+  }
+}
+
+
+static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
+  if (L == L1) {
+    lua_pushvalue(L, -2);
+    lua_remove(L, -3);
+  }
+  else
+    lua_xmove(L1, L, 1);
+  lua_setfield(L, -2, fname);
+}
+
+
+static int db_getinfo (lua_State *L) {
+  lua_Debug ar;
+  int arg;
+  lua_State *L1 = getthread(L, &arg);
+  const char *options = luaL_optstring(L, arg+2, "flnSu");
+  if (lua_isnumber(L, arg+1)) {
+    if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {
+      lua_pushnil(L);  /* level out of range */
+      return 1;
+    }
+  }
+  else if (lua_isfunction(L, arg+1)) {
+    lua_pushfstring(L, ">%s", options);
+    options = lua_tostring(L, -1);
+    lua_pushvalue(L, arg+1);
+    lua_xmove(L, L1, 1);
+  }
+  else
+    return luaL_argerror(L, arg+1, "function or level expected");
+  if (!lua_getinfo(L1, options, &ar))
+    return luaL_argerror(L, arg+2, "invalid option");
+  lua_createtable(L, 0, 2);
+  if (strchr(options, 'S')) {
+    settabss(L, "source", ar.source);
+    settabss(L, "short_src", ar.short_src);
+    settabsi(L, "linedefined", ar.linedefined);
+    settabsi(L, "lastlinedefined", ar.lastlinedefined);
+    settabss(L, "what", ar.what);
+  }
+  if (strchr(options, 'l'))
+    settabsi(L, "currentline", ar.currentline);
+  if (strchr(options, 'u'))
+    settabsi(L, "nups", ar.nups);
+  if (strchr(options, 'n')) {
+    settabss(L, "name", ar.name);
+    settabss(L, "namewhat", ar.namewhat);
+  }
+  if (strchr(options, 'L'))
+    treatstackoption(L, L1, "activelines");
+  if (strchr(options, 'f'))
+    treatstackoption(L, L1, "func");
+  return 1;  /* return table */
+}
+    
+
+static int db_getlocal (lua_State *L) {
+  int arg;
+  lua_State *L1 = getthread(L, &arg);
+  lua_Debug ar;
+  const char *name;
+  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
+    return luaL_argerror(L, arg+1, "level out of range");
+  name = lua_getlocal(L1, &ar, luaL_checkint(L, arg+2));
+  if (name) {
+    lua_xmove(L1, L, 1);
+    lua_pushstring(L, name);
+    lua_pushvalue(L, -2);
+    return 2;
+  }
+  else {
+    lua_pushnil(L);
+    return 1;
+  }
+}
+
+
+static int db_setlocal (lua_State *L) {
+  int arg;
+  lua_State *L1 = getthread(L, &arg);
+  lua_Debug ar;
+  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
+    return luaL_argerror(L, arg+1, "level out of range");
+  luaL_checkany(L, arg+3);
+  lua_settop(L, arg+3);
+  lua_xmove(L, L1, 1);
+  lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2)));
+  return 1;
+}
+
+
+static int auxupvalue (lua_State *L, int get) {
+  const char *name;
+  int n = luaL_checkint(L, 2);
+  luaL_checktype(L, 1, LUA_TFUNCTION);
+  if (lua_iscfunction(L, 1)) return 0;  /* cannot touch C upvalues from Lua */
+  name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
+  if (name == NULL) return 0;
+  lua_pushstring(L, name);
+  lua_insert(L, -(get+1));
+  return get + 1;
+}
+
+
+static int db_getupvalue (lua_State *L) {
+  return auxupvalue(L, 1);
+}
+
+
+static int db_setupvalue (lua_State *L) {
+  luaL_checkany(L, 3);
+  return auxupvalue(L, 0);
+}
+
+
+
+static const char KEY_HOOK = 'h';
+
+
+static void hookf (lua_State *L, lua_Debug *ar) {
+  static const char *const hooknames[] =
+    {"call", "return", "line", "count", "tail return"};
+  lua_pushlightuserdata(L, (void *)&KEY_HOOK);
+  lua_rawget(L, LUA_REGISTRYINDEX);
+  lua_pushlightuserdata(L, L);
+  lua_rawget(L, -2);
+  if (lua_isfunction(L, -1)) {
+    lua_pushstring(L, hooknames[(int)ar->event]);
+    if (ar->currentline >= 0)
+      lua_pushinteger(L, ar->currentline);
+    else lua_pushnil(L);
+    lua_assert(lua_getinfo(L, "lS", ar));
+    lua_call(L, 2, 0);
+  }
+}
+
+
+static int makemask (const char *smask, int count) {
+  int mask = 0;
+  if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
+  if (strchr(smask, 'r')) mask |= LUA_MASKRET;
+  if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
+  if (count > 0) mask |= LUA_MASKCOUNT;
+  return mask;
+}
+
+
+static char *unmakemask (int mask, char *smask) {
+  int i = 0;
+  if (mask & LUA_MASKCALL) smask[i++] = 'c';
+  if (mask & LUA_MASKRET) smask[i++] = 'r';
+  if (mask & LUA_MASKLINE) smask[i++] = 'l';
+  smask[i] = '\0';
+  return smask;
+}
+
+
+static void gethooktable (lua_State *L) {
+  lua_pushlightuserdata(L, (void *)&KEY_HOOK);
+  lua_rawget(L, LUA_REGISTRYINDEX);
+  if (!lua_istable(L, -1)) {
+    lua_pop(L, 1);
+    lua_createtable(L, 0, 1);
+    lua_pushlightuserdata(L, (void *)&KEY_HOOK);
+    lua_pushvalue(L, -2);
+    lua_rawset(L, LUA_REGISTRYINDEX);
+  }
+}
+
+
+static int db_sethook (lua_State *L) {
+  int arg, mask, count;
+  lua_Hook func;
+  lua_State *L1 = getthread(L, &arg);
+  if (lua_isnoneornil(L, arg+1)) {
+    lua_settop(L, arg+1);
+    func = NULL; mask = 0; count = 0;  /* turn off hooks */
+  }
+  else {
+    const char *smask = luaL_checkstring(L, arg+2);
+    luaL_checktype(L, arg+1, LUA_TFUNCTION);
+    count = luaL_optint(L, arg+3, 0);
+    func = hookf; mask = makemask(smask, count);
+  }
+  gethooktable(L);
+  lua_pushlightuserdata(L, L1);
+  lua_pushvalue(L, arg+1);
+  lua_rawset(L, -3);  /* set new hook */
+  lua_pop(L, 1);  /* remove hook table */
+  lua_sethook(L1, func, mask, count);  /* set hooks */
+  return 0;
+}
+
+
+static int db_gethook (lua_State *L) {
+  int arg;
+  lua_State *L1 = getthread(L, &arg);
+  char buff[5];
+  int mask = lua_gethookmask(L1);
+  lua_Hook hook = lua_gethook(L1);
+  if (hook != NULL && hook != hookf)  /* external hook? */
+    lua_pushliteral(L, "external hook");
+  else {
+    gethooktable(L);
+    lua_pushlightuserdata(L, L1);
+    lua_rawget(L, -2);   /* get hook */
+    lua_remove(L, -2);  /* remove hook table */
+  }
+  lua_pushstring(L, unmakemask(mask, buff));
+  lua_pushinteger(L, lua_gethookcount(L1));
+  return 3;
+}
+
+
+static int db_debug (lua_State *L) {
+  for (;;) {
+    char buffer[250];
+    fputs("lua_debug> ", stderr);
+    if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
+        strcmp(buffer, "cont\n") == 0)
+      return 0;
+    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
+        lua_pcall(L, 0, 0, 0)) {
+      fputs(lua_tostring(L, -1), stderr);
+      fputs("\n", stderr);
+    }
+    lua_settop(L, 0);  /* remove eventual returns */
+  }
+}
+
+
+#define LEVELS1 12      /* size of the first part of the stack */
+#define LEVELS2 10      /* size of the second part of the stack */
+
+static int db_errorfb (lua_State *L) {
+  int level;
+  int firstpart = 1;  /* still before eventual `...' */
+  int arg;
+  lua_State *L1 = getthread(L, &arg);
+  lua_Debug ar;
+  if (lua_isnumber(L, arg+2)) {
+    level = (int)lua_tointeger(L, arg+2);
+    lua_pop(L, 1);
+  }
+  else
+    level = (L == L1) ? 1 : 0;  /* level 0 may be this own function */
+  if (lua_gettop(L) == arg)
+    lua_pushliteral(L, "");
+  else if (!lua_isstring(L, arg+1)) return 1;  /* message is not a string */
+  else lua_pushliteral(L, "\n");
+  lua_pushliteral(L, "stack traceback:");
+  while (lua_getstack(L1, level++, &ar)) {
+    if (level > LEVELS1 && firstpart) {
+      /* no more than `LEVELS2' more levels? */
+      if (!lua_getstack(L1, level+LEVELS2, &ar))
+        level--;  /* keep going */
+      else {
+        lua_pushliteral(L, "\n\t...");  /* too many levels */
+        while (lua_getstack(L1, level+LEVELS2, &ar))  /* find last levels */
+          level++;
+      }
+      firstpart = 0;
+      continue;
+    }
+    lua_pushliteral(L, "\n\t");
+    lua_getinfo(L1, "Snl", &ar);
+    lua_pushfstring(L, "%s:", ar.short_src);
+    if (ar.currentline > 0)
+      lua_pushfstring(L, "%d:", ar.currentline);
+    if (*ar.namewhat != '\0')  /* is there a name? */
+        lua_pushfstring(L, " in function " LUA_QS, ar.name);
+    else {
+      if (*ar.what == 'm')  /* main? */
+        lua_pushfstring(L, " in main chunk");
+      else if (*ar.what == 'C' || *ar.what == 't')
+        lua_pushliteral(L, " ?");  /* C function or tail call */
+      else
+        lua_pushfstring(L, " in function <%s:%d>",
+                           ar.short_src, ar.linedefined);
+    }
+    lua_concat(L, lua_gettop(L) - arg);
+  }
+  lua_concat(L, lua_gettop(L) - arg);
+  return 1;
+}
+
+
+static const luaL_Reg dblib[] = {
+  {"debug", db_debug},
+  {"getfenv", db_getfenv},
+  {"gethook", db_gethook},
+  {"getinfo", db_getinfo},
+  {"getlocal", db_getlocal},
+  {"getregistry", db_getregistry},
+  {"getmetatable", db_getmetatable},
+  {"getupvalue", db_getupvalue},
+  {"setfenv", db_setfenv},
+  {"sethook", db_sethook},
+  {"setlocal", db_setlocal},
+  {"setmetatable", db_setmetatable},
+  {"setupvalue", db_setupvalue},
+  {"traceback", db_errorfb},
+  {NULL, NULL}
+};
+
+
+LUALIB_API int luaopen_debug (lua_State *L) {
+  luaL_register(L, LUA_DBLIBNAME, dblib);
+  return 1;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/ldebug.c b/libraries/LuaJIT-1.1.7/src/ldebug.c
new file mode 100644
index 0000000..89891fd
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ldebug.c
@@ -0,0 +1,640 @@
+/*
+** $Id: ldebug.c,v 2.29.1.6 2008/05/08 16:56:26 roberto Exp $
+** Debug Interface
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <string.h>
+
+
+#define ldebug_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lapi.h"
+#include "lcode.h"
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "ltm.h"
+#include "lvm.h"
+#include "ljit.h"
+
+
+
+static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name);
+
+
+static int currentpc (lua_State *L, CallInfo *ci) {
+  if (isLua(ci))  /* must be a Lua function to get current PC */
+    return luaJIT_findpc(ci_func(ci)->l.p,
+                         ci==L->ci ? L->savedpc : ci->savedpc);
+  else
+    return -1;
+}
+
+
+static int currentline (lua_State *L, CallInfo *ci) {
+  int pc = currentpc(L, ci);
+  if (pc < 0)
+    return -1;  /* only active lua functions have current-line information */
+  else
+    return getline(ci_func(ci)->l.p, pc);
+}
+
+
+/*
+** this function can be called asynchronous (e.g. during a signal)
+*/
+LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
+  if (func == NULL || mask == 0) {  /* turn off hooks? */
+    mask = 0;
+    func = NULL;
+  }
+  L->hook = func;
+  L->basehookcount = count;
+  resethookcount(L);
+  L->hookmask = cast_byte(mask);
+  return 1;
+}
+
+
+LUA_API lua_Hook lua_gethook (lua_State *L) {
+  return L->hook;
+}
+
+
+LUA_API int lua_gethookmask (lua_State *L) {
+  return L->hookmask;
+}
+
+
+LUA_API int lua_gethookcount (lua_State *L) {
+  return L->basehookcount;
+}
+
+
+LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
+  int status;
+  CallInfo *ci;
+  lua_lock(L);
+  for (ci = L->ci; level > 0 && ci > L->base_ci; ci--) {
+    level--;
+    if (f_isLua(ci))  /* Lua function? */
+      level -= ci->tailcalls;  /* skip lost tail calls */
+  }
+  if (level == 0 && ci > L->base_ci) {  /* level found? */
+    status = 1;
+    ar->i_ci = cast_int(ci - L->base_ci);
+  }
+  else if (level < 0) {  /* level is of a lost tail call? */
+    status = 1;
+    ar->i_ci = 0;
+  }
+  else status = 0;  /* no such level */
+  lua_unlock(L);
+  return status;
+}
+
+
+static Proto *getluaproto (CallInfo *ci) {
+  return (isLua(ci) ? ci_func(ci)->l.p : NULL);
+}
+
+
+static const char *findlocal (lua_State *L, CallInfo *ci, int n) {
+  const char *name;
+  Proto *fp = getluaproto(ci);
+  if (fp && (name = luaF_getlocalname(fp, n, currentpc(L, ci))) != NULL)
+    return name;  /* is a local variable in a Lua function */
+  else {
+    StkId limit = (ci == L->ci) ? L->top : (ci+1)->func;
+    if (limit - ci->base >= n && n > 0)  /* is 'n' inside 'ci' stack? */
+      return "(*temporary)";
+    else
+      return NULL;
+  }
+}
+
+
+LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
+  CallInfo *ci = L->base_ci + ar->i_ci;
+  const char *name = findlocal(L, ci, n);
+  lua_lock(L);
+  if (name)
+      luaA_pushobject(L, ci->base + (n - 1));
+  lua_unlock(L);
+  return name;
+}
+
+
+LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
+  CallInfo *ci = L->base_ci + ar->i_ci;
+  const char *name = findlocal(L, ci, n);
+  lua_lock(L);
+  if (name)
+      setobjs2s(L, ci->base + (n - 1), L->top - 1);
+  L->top--;  /* pop value */
+  lua_unlock(L);
+  return name;
+}
+
+
+static void funcinfo (lua_Debug *ar, Closure *cl) {
+  if (cl->c.isC) {
+    ar->source = "=[C]";
+    ar->linedefined = -1;
+    ar->lastlinedefined = -1;
+    ar->what = "C";
+  }
+  else {
+    ar->source = getstr(cl->l.p->source);
+    ar->linedefined = cl->l.p->linedefined;
+    ar->lastlinedefined = cl->l.p->lastlinedefined;
+    ar->what = (ar->linedefined == 0) ? "main" : "Lua";
+  }
+  luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
+}
+
+
+static void info_tailcall (lua_Debug *ar) {
+  ar->name = ar->namewhat = "";
+  ar->what = "tail";
+  ar->lastlinedefined = ar->linedefined = ar->currentline = -1;
+  ar->source = "=(tail call)";
+  luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
+  ar->nups = 0;
+}
+
+
+static void collectvalidlines (lua_State *L, Closure *f) {
+  if (f == NULL || f->c.isC) {
+    setnilvalue(L->top);
+  }
+  else {
+    Table *t = luaH_new(L, 0, 0);
+    int *lineinfo = f->l.p->lineinfo;
+    int i;
+    for (i=0; i<f->l.p->sizelineinfo; i++)
+      setbvalue(luaH_setnum(L, t, lineinfo[i]), 1);
+    sethvalue(L, L->top, t); 
+  }
+  incr_top(L);
+}
+
+
+static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
+                    Closure *f, CallInfo *ci) {
+  int status = 1;
+  if (f == NULL) {
+    info_tailcall(ar);
+    return status;
+  }
+  for (; *what; what++) {
+    switch (*what) {
+      case 'S': {
+        funcinfo(ar, f);
+        break;
+      }
+      case 'l': {
+        ar->currentline = (ci) ? currentline(L, ci) : -1;
+        break;
+      }
+      case 'u': {
+        ar->nups = f->c.nupvalues;
+        break;
+      }
+      case 'n': {
+        ar->namewhat = (ci) ? getfuncname(L, ci, &ar->name) : NULL;
+        if (ar->namewhat == NULL) {
+          ar->namewhat = "";  /* not found */
+          ar->name = NULL;
+        }
+        break;
+      }
+      case 'L':
+      case 'f':  /* handled by lua_getinfo */
+        break;
+      default: status = 0;  /* invalid option */
+    }
+  }
+  return status;
+}
+
+
+LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
+  int status;
+  Closure *f = NULL;
+  CallInfo *ci = NULL;
+  lua_lock(L);
+  if (*what == '>') {
+    StkId func = L->top - 1;
+    luai_apicheck(L, ttisfunction(func));
+    what++;  /* skip the '>' */
+    f = clvalue(func);
+    L->top--;  /* pop function */
+  }
+  else if (ar->i_ci != 0) {  /* no tail call? */
+    ci = L->base_ci + ar->i_ci;
+    lua_assert(ttisfunction(ci->func));
+    f = clvalue(ci->func);
+  }
+  status = auxgetinfo(L, what, ar, f, ci);
+  if (strchr(what, 'f')) {
+    if (f == NULL) setnilvalue(L->top);
+    else setclvalue(L, L->top, f);
+    incr_top(L);
+  }
+  if (strchr(what, 'L'))
+    collectvalidlines(L, f);
+  lua_unlock(L);
+  return status;
+}
+
+
+/*
+** {======================================================
+** Symbolic Execution and code checker
+** =======================================================
+*/
+
+#define check(x)                if (!(x)) return 0;
+
+#define checkjump(pt,pc)        check(0 <= pc && pc < pt->sizecode)
+
+#define checkreg(pt,reg)        check((reg) < (pt)->maxstacksize)
+
+
+
+static int precheck (const Proto *pt) {
+  check(pt->maxstacksize <= MAXSTACK);
+  check(pt->numparams+(pt->is_vararg & VARARG_HASARG) <= pt->maxstacksize);
+  check(!(pt->is_vararg & VARARG_NEEDSARG) ||
+              (pt->is_vararg & VARARG_HASARG));
+  check(pt->sizeupvalues <= pt->nups);
+  check(pt->sizelineinfo == pt->sizecode || pt->sizelineinfo == 0);
+  check(pt->sizecode > 0 && GET_OPCODE(pt->code[pt->sizecode-1]) == OP_RETURN);
+  return 1;
+}
+
+
+#define checkopenop(pt,pc)      luaG_checkopenop((pt)->code[(pc)+1])
+
+int luaG_checkopenop (Instruction i) {
+  switch (GET_OPCODE(i)) {
+    case OP_CALL:
+    case OP_TAILCALL:
+    case OP_RETURN:
+    case OP_SETLIST: {
+      check(GETARG_B(i) == 0);
+      return 1;
+    }
+    default: return 0;  /* invalid instruction after an open call */
+  }
+}
+
+
+static int checkArgMode (const Proto *pt, int r, enum OpArgMask mode) {
+  switch (mode) {
+    case OpArgN: check(r == 0); break;
+    case OpArgU: break;
+    case OpArgR: checkreg(pt, r); break;
+    case OpArgK:
+      check(ISK(r) ? INDEXK(r) < pt->sizek : r < pt->maxstacksize);
+      break;
+  }
+  return 1;
+}
+
+
+static Instruction symbexec (const Proto *pt, int lastpc, int reg) {
+  int pc;
+  int last;  /* stores position of last instruction that changed `reg' */
+  last = pt->sizecode-1;  /* points to final return (a `neutral' instruction) */
+  check(precheck(pt));
+  for (pc = 0; pc < lastpc; pc++) {
+    Instruction i = pt->code[pc];
+    OpCode op = GET_OPCODE(i);
+    int a = GETARG_A(i);
+    int b = 0;
+    int c = 0;
+    check(op < NUM_OPCODES);
+    checkreg(pt, a);
+    switch (getOpMode(op)) {
+      case iABC: {
+        b = GETARG_B(i);
+        c = GETARG_C(i);
+        check(checkArgMode(pt, b, getBMode(op)));
+        check(checkArgMode(pt, c, getCMode(op)));
+        break;
+      }
+      case iABx: {
+        b = GETARG_Bx(i);
+        if (getBMode(op) == OpArgK) check(b < pt->sizek);
+        break;
+      }
+      case iAsBx: {
+        b = GETARG_sBx(i);
+        if (getBMode(op) == OpArgR) {
+          int dest = pc+1+b;
+          check(0 <= dest && dest < pt->sizecode);
+          if (dest > 0) {
+            int j;
+            /* check that it does not jump to a setlist count; this
+               is tricky, because the count from a previous setlist may
+               have the same value of an invalid setlist; so, we must
+               go all the way back to the first of them (if any) */
+            for (j = 0; j < dest; j++) {
+              Instruction d = pt->code[dest-1-j];
+              if (!(GET_OPCODE(d) == OP_SETLIST && GETARG_C(d) == 0)) break;
+            }
+            /* if 'j' is even, previous value is not a setlist (even if
+               it looks like one) */
+            check((j&1) == 0);
+          }
+        }
+        break;
+      }
+    }
+    if (testAMode(op)) {
+      if (a == reg) last = pc;  /* change register `a' */
+    }
+    if (testTMode(op)) {
+      check(pc+2 < pt->sizecode);  /* check skip */
+      check(GET_OPCODE(pt->code[pc+1]) == OP_JMP);
+    }
+    switch (op) {
+      case OP_LOADBOOL: {
+        if (c == 1) {  /* does it jump? */
+          check(pc+2 < pt->sizecode);  /* check its jump */
+          check(GET_OPCODE(pt->code[pc+1]) != OP_SETLIST ||
+                GETARG_C(pt->code[pc+1]) != 0);
+        }
+        break;
+      }
+      case OP_LOADNIL: {
+        if (a <= reg && reg <= b)
+          last = pc;  /* set registers from `a' to `b' */
+        break;
+      }
+      case OP_GETUPVAL:
+      case OP_SETUPVAL: {
+        check(b < pt->nups);
+        break;
+      }
+      case OP_GETGLOBAL:
+      case OP_SETGLOBAL: {
+        check(ttisstring(&pt->k[b]));
+        break;
+      }
+      case OP_SELF: {
+        checkreg(pt, a+1);
+        if (reg == a+1) last = pc;
+        break;
+      }
+      case OP_CONCAT: {
+        check(b < c);  /* at least two operands */
+        break;
+      }
+      case OP_TFORLOOP: {
+        check(c >= 1);  /* at least one result (control variable) */
+        checkreg(pt, a+2+c);  /* space for results */
+        if (reg >= a+2) last = pc;  /* affect all regs above its base */
+        break;
+      }
+      case OP_FORLOOP:
+      case OP_FORPREP:
+        checkreg(pt, a+3);
+        /* go through */
+      case OP_JMP: {
+        int dest = pc+1+b;
+        /* not full check and jump is forward and do not skip `lastpc'? */
+        if (reg != NO_REG && pc < dest && dest <= lastpc)
+          pc += b;  /* do the jump */
+        break;
+      }
+      case OP_CALL:
+      case OP_TAILCALL: {
+        if (b != 0) {
+          checkreg(pt, a+b-1);
+        }
+        c--;  /* c = num. returns */
+        if (c == LUA_MULTRET) {
+          check(checkopenop(pt, pc));
+        }
+        else if (c != 0)
+          checkreg(pt, a+c-1);
+        if (reg >= a) last = pc;  /* affect all registers above base */
+        break;
+      }
+      case OP_RETURN: {
+        b--;  /* b = num. returns */
+        if (b > 0) checkreg(pt, a+b-1);
+        break;
+      }
+      case OP_SETLIST: {
+        if (b > 0) checkreg(pt, a + b);
+        if (c == 0) {
+          pc++;
+          check(pc < pt->sizecode - 1);
+        }
+        break;
+      }
+      case OP_CLOSURE: {
+        int nup, j;
+        check(b < pt->sizep);
+        nup = pt->p[b]->nups;
+        check(pc + nup < pt->sizecode);
+        for (j = 1; j <= nup; j++) {
+          OpCode op1 = GET_OPCODE(pt->code[pc + j]);
+          check(op1 == OP_GETUPVAL || op1 == OP_MOVE);
+        }
+        if (reg != NO_REG)  /* tracing? */
+          pc += nup;  /* do not 'execute' these pseudo-instructions */
+        break;
+      }
+      case OP_VARARG: {
+        check((pt->is_vararg & VARARG_ISVARARG) &&
+             !(pt->is_vararg & VARARG_NEEDSARG));
+        b--;
+        if (b == LUA_MULTRET) check(checkopenop(pt, pc));
+        checkreg(pt, a+b-1);
+        break;
+      }
+      default: break;
+    }
+  }
+  return pt->code[last];
+}
+
+#undef check
+#undef checkjump
+#undef checkreg
+
+/* }====================================================== */
+
+
+int luaG_checkcode (const Proto *pt) {
+  return (symbexec(pt, pt->sizecode, NO_REG) != 0);
+}
+
+
+static const char *kname (Proto *p, int c) {
+  if (ISK(c) && ttisstring(&p->k[INDEXK(c)]))
+    return svalue(&p->k[INDEXK(c)]);
+  else
+    return "?";
+}
+
+
+static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,
+                               const char **name) {
+  if (isLua(ci)) {  /* a Lua function? */
+    Proto *p = ci_func(ci)->l.p;
+    int pc = currentpc(L, ci);
+    Instruction i;
+    *name = luaF_getlocalname(p, stackpos+1, pc);
+    if (*name)  /* is a local? */
+      return "local";
+    i = symbexec(p, pc, stackpos);  /* try symbolic execution */
+    lua_assert(pc != -1);
+    switch (GET_OPCODE(i)) {
+      case OP_GETGLOBAL: {
+        int g = GETARG_Bx(i);  /* global index */
+        lua_assert(ttisstring(&p->k[g]));
+        *name = svalue(&p->k[g]);
+        return "global";
+      }
+      case OP_MOVE: {
+        int a = GETARG_A(i);
+        int b = GETARG_B(i);  /* move from `b' to `a' */
+        if (b < a)
+          return getobjname(L, ci, b, name);  /* get name for `b' */
+        break;
+      }
+      case OP_GETTABLE: {
+        int k = GETARG_C(i);  /* key index */
+        *name = kname(p, k);
+        return "field";
+      }
+      case OP_GETUPVAL: {
+        int u = GETARG_B(i);  /* upvalue index */
+        *name = p->upvalues ? getstr(p->upvalues[u]) : "?";
+        return "upvalue";
+      }
+      case OP_SELF: {
+        int k = GETARG_C(i);  /* key index */
+        *name = kname(p, k);
+        return "method";
+      }
+      default: break;
+    }
+  }
+  return NULL;  /* no useful name found */
+}
+
+
+static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
+  Instruction i;
+  if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1))
+    return NULL;  /* calling function is not Lua (or is unknown) */
+  ci--;  /* calling function */
+  i = ci_func(ci)->l.p->code[currentpc(L, ci)];
+  if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||
+      GET_OPCODE(i) == OP_TFORLOOP)
+    return getobjname(L, ci, GETARG_A(i), name);
+  else
+    return NULL;  /* no useful name can be found */
+}
+
+
+/* only ANSI way to check whether a pointer points to an array */
+static int isinstack (CallInfo *ci, const TValue *o) {
+  StkId p;
+  for (p = ci->base; p < ci->top; p++)
+    if (o == p) return 1;
+  return 0;
+}
+
+
+void luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
+  const char *name = NULL;
+  const char *t = luaT_typenames[ttype(o)];
+  const char *kind = (isinstack(L->ci, o)) ?
+                         getobjname(L, L->ci, cast_int(o - L->base), &name) :
+                         NULL;
+  if (kind)
+    luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)",
+                op, kind, name, t);
+  else
+    luaG_runerror(L, "attempt to %s a %s value", op, t);
+}
+
+
+void luaG_concaterror (lua_State *L, StkId p1, StkId p2) {
+  if (ttisstring(p1) || ttisnumber(p1)) p1 = p2;
+  lua_assert(!ttisstring(p1) && !ttisnumber(p1));
+  luaG_typeerror(L, p1, "concatenate");
+}
+
+
+void luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) {
+  TValue temp;
+  if (luaV_tonumber(p1, &temp) == NULL)
+    p2 = p1;  /* first operand is wrong */
+  luaG_typeerror(L, p2, "perform arithmetic on");
+}
+
+
+int luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
+  const char *t1 = luaT_typenames[ttype(p1)];
+  const char *t2 = luaT_typenames[ttype(p2)];
+  if (t1[2] == t2[2])
+    luaG_runerror(L, "attempt to compare two %s values", t1);
+  else
+    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
+  return 0;
+}
+
+
+static void addinfo (lua_State *L, const char *msg) {
+  CallInfo *ci = L->ci;
+  if (isLua(ci)) {  /* is Lua code? */
+    char buff[LUA_IDSIZE];  /* add file:line information */
+    int line = currentline(L, ci);
+    luaO_chunkid(buff, getstr(getluaproto(ci)->source), LUA_IDSIZE);
+    luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
+  }
+}
+
+
+void luaG_errormsg (lua_State *L) {
+  if (L->errfunc != 0) {  /* is there an error handling function? */
+    StkId errfunc = restorestack(L, L->errfunc);
+    if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR);
+    setobjs2s(L, L->top, L->top - 1);  /* move argument */
+    setobjs2s(L, L->top - 1, errfunc);  /* push function */
+    incr_top(L);
+    luaD_call(L, L->top - 2, 1);  /* call it */
+  }
+  luaD_throw(L, LUA_ERRRUN);
+}
+
+
+void luaG_runerror (lua_State *L, const char *fmt, ...) {
+  va_list argp;
+  va_start(argp, fmt);
+  addinfo(L, luaO_pushvfstring(L, fmt, argp));
+  va_end(argp);
+  luaG_errormsg(L);
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/ldebug.h b/libraries/LuaJIT-1.1.7/src/ldebug.h
new file mode 100644
index 0000000..ba28a97
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ldebug.h
@@ -0,0 +1,33 @@
+/*
+** $Id: ldebug.h,v 2.3.1.1 2007/12/27 13:02:25 roberto Exp $
+** Auxiliary functions from Debug Interface module
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ldebug_h
+#define ldebug_h
+
+
+#include "lstate.h"
+
+
+#define pcRel(pc, p)    (cast(int, (pc) - (p)->code) - 1)
+
+#define getline(f,pc)   (((f)->lineinfo) ? (f)->lineinfo[pc] : 0)
+
+#define resethookcount(L)       (L->hookcount = L->basehookcount)
+
+
+LUAI_FUNC void luaG_typeerror (lua_State *L, const TValue *o,
+                                             const char *opname);
+LUAI_FUNC void luaG_concaterror (lua_State *L, StkId p1, StkId p2);
+LUAI_FUNC void luaG_aritherror (lua_State *L, const TValue *p1,
+                                              const TValue *p2);
+LUAI_FUNC int luaG_ordererror (lua_State *L, const TValue *p1,
+                                             const TValue *p2);
+LUAI_FUNC void luaG_runerror (lua_State *L, const char *fmt, ...);
+LUAI_FUNC void luaG_errormsg (lua_State *L);
+LUAI_FUNC int luaG_checkcode (const Proto *pt);
+LUAI_FUNC int luaG_checkopenop (Instruction i);
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ldo.c b/libraries/LuaJIT-1.1.7/src/ldo.c
new file mode 100644
index 0000000..1d9393d
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ldo.c
@@ -0,0 +1,519 @@
+/*
+** $Id: ldo.c,v 2.38.1.3 2008/01/18 22:31:22 roberto Exp $
+** Stack and Call structure of Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#include <setjmp.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define ldo_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lgc.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lparser.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "ltm.h"
+#include "lundump.h"
+#include "lvm.h"
+#include "lzio.h"
+#include "ljit.h"
+
+
+
+
+/*
+** {======================================================
+** Error-recovery functions
+** =======================================================
+*/
+
+
+/* chain list of long jump buffers */
+struct lua_longjmp {
+  struct lua_longjmp *previous;
+  luai_jmpbuf b;
+  volatile int status;  /* error code */
+};
+
+
+void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) {
+  switch (errcode) {
+    case LUA_ERRMEM: {
+      setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));
+      break;
+    }
+    case LUA_ERRERR: {
+      setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
+      break;
+    }
+    case LUA_ERRSYNTAX:
+    case LUA_ERRRUN: {
+      setobjs2s(L, oldtop, L->top - 1);  /* error message on current top */
+      break;
+    }
+  }
+  L->top = oldtop + 1;
+}
+
+
+static void restore_stack_limit (lua_State *L) {
+  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
+  if (L->size_ci > LUAI_MAXCALLS) {  /* there was an overflow? */
+    int inuse = cast_int(L->ci - L->base_ci);
+    if (inuse + 1 < LUAI_MAXCALLS)  /* can `undo' overflow? */
+      luaD_reallocCI(L, LUAI_MAXCALLS);
+  }
+}
+
+
+static void resetstack (lua_State *L, int status) {
+  L->ci = L->base_ci;
+  L->base = L->ci->base;
+  luaF_close(L, L->base);  /* close eventual pending closures */
+  luaD_seterrorobj(L, status, L->base);
+  L->nCcalls = 0;
+  L->allowhook = 1;
+  restore_stack_limit(L);
+  L->errfunc = 0;
+  L->errorJmp = NULL;
+}
+
+
+void luaD_throw (lua_State *L, int errcode) {
+  if (L->errorJmp) {
+    L->errorJmp->status = errcode;
+    LUAI_THROW(L, L->errorJmp);
+  }
+  else {
+    L->status = cast_byte(errcode);
+    if (G(L)->panic) {
+      resetstack(L, errcode);
+      lua_unlock(L);
+      G(L)->panic(L);
+    }
+    exit(EXIT_FAILURE);
+  }
+}
+
+
+int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
+  struct lua_longjmp lj;
+  lj.status = 0;
+  lj.previous = L->errorJmp;  /* chain new error handler */
+  L->errorJmp = &lj;
+  LUAI_TRY(L, &lj,
+    (*f)(L, ud);
+  );
+  L->errorJmp = lj.previous;  /* restore old error handler */
+  return lj.status;
+}
+
+/* }====================================================== */
+
+
+static void correctstack (lua_State *L, TValue *oldstack) {
+  CallInfo *ci;
+  GCObject *up;
+  L->top = (L->top - oldstack) + L->stack;
+  for (up = L->openupval; up != NULL; up = up->gch.next)
+    gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;
+  for (ci = L->base_ci; ci <= L->ci; ci++) {
+    ci->top = (ci->top - oldstack) + L->stack;
+    ci->base = (ci->base - oldstack) + L->stack;
+    ci->func = (ci->func - oldstack) + L->stack;
+  }
+  L->base = (L->base - oldstack) + L->stack;
+}
+
+
+void luaD_reallocstack (lua_State *L, int newsize) {
+  TValue *oldstack = L->stack;
+  int realsize = newsize + 1 + EXTRA_STACK;
+  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
+  luaM_reallocvector(L, L->stack, L->stacksize, realsize, TValue);
+  L->stacksize = realsize;
+  L->stack_last = L->stack+newsize;
+  correctstack(L, oldstack);
+}
+
+
+void luaD_reallocCI (lua_State *L, int newsize) {
+  CallInfo *oldci = L->base_ci;
+  luaM_reallocvector(L, L->base_ci, L->size_ci, newsize, CallInfo);
+  L->size_ci = newsize;
+  L->ci = (L->ci - oldci) + L->base_ci;
+  L->end_ci = L->base_ci + L->size_ci - 1;
+}
+
+
+void luaD_growstack (lua_State *L, int n) {
+  if (n <= L->stacksize)  /* double size is enough? */
+    luaD_reallocstack(L, 2*L->stacksize);
+  else
+    luaD_reallocstack(L, L->stacksize + n);
+}
+
+
+CallInfo *luaD_growCI (lua_State *L) {
+  if (L->size_ci > LUAI_MAXCALLS)  /* overflow while handling overflow? */
+    luaD_throw(L, LUA_ERRERR);
+  else {
+    luaD_reallocCI(L, 2*L->size_ci);
+    if (L->size_ci > LUAI_MAXCALLS)
+      luaG_runerror(L, "stack overflow");
+  }
+  return ++L->ci;
+}
+
+
+void luaD_callhook (lua_State *L, int event, int line) {
+  lua_Hook hook = L->hook;
+  if (hook && L->allowhook) {
+    ptrdiff_t top = savestack(L, L->top);
+    ptrdiff_t ci_top = savestack(L, L->ci->top);
+    lua_Debug ar;
+    ar.event = event;
+    ar.currentline = line;
+    if (event == LUA_HOOKTAILRET)
+      ar.i_ci = 0;  /* tail call; no debug information about it */
+    else
+      ar.i_ci = cast_int(L->ci - L->base_ci);
+    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
+    L->ci->top = L->top + LUA_MINSTACK;
+    lua_assert(L->ci->top <= L->stack_last);
+    L->allowhook = 0;  /* cannot call hooks inside a hook */
+    lua_unlock(L);
+    (*hook)(L, &ar);
+    lua_lock(L);
+    lua_assert(!L->allowhook);
+    L->allowhook = 1;
+    L->ci->top = restorestack(L, ci_top);
+    L->top = restorestack(L, top);
+  }
+}
+
+
+static StkId adjust_varargs (lua_State *L, Proto *p, int actual) {
+  int i;
+  int nfixargs = p->numparams;
+  Table *htab = NULL;
+  StkId base, fixed;
+  for (; actual < nfixargs; ++actual)
+    setnilvalue(L->top++);
+#if defined(LUA_COMPAT_VARARG)
+  if (p->is_vararg & VARARG_NEEDSARG) { /* compat. with old-style vararg? */
+    int nvar = actual - nfixargs;  /* number of extra arguments */
+    lua_assert(p->is_vararg & VARARG_HASARG);
+    luaC_checkGC(L);
+    htab = luaH_new(L, nvar, 1);  /* create `arg' table */
+    for (i=0; i<nvar; i++)  /* put extra arguments into `arg' table */
+      setobj2n(L, luaH_setnum(L, htab, i+1), L->top - nvar + i);
+    /* store counter in field `n' */
+    setnvalue(luaH_setstr(L, htab, luaS_newliteral(L, "n")), cast_num(nvar));
+  }
+#endif
+  /* move fixed parameters to final position */
+  fixed = L->top - actual;  /* first fixed argument */
+  base = L->top;  /* final position of first argument */
+  for (i=0; i<nfixargs; i++) {
+    setobjs2s(L, L->top++, fixed+i);
+    setnilvalue(fixed+i);
+  }
+  /* add `arg' parameter */
+  if (htab) {
+    sethvalue(L, L->top++, htab);
+    lua_assert(iswhite(obj2gco(htab)));
+  }
+  return base;
+}
+
+
+StkId luaD_tryfuncTM (lua_State *L, StkId func) {
+  const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);
+  StkId p;
+  ptrdiff_t funcr = savestack(L, func);
+  if (!ttisfunction(tm))
+    luaG_typeerror(L, func, "call");
+  /* Open a hole inside the stack at `func' */
+  for (p = L->top; p > func; p--) setobjs2s(L, p, p-1);
+  incr_top(L);
+  func = restorestack(L, funcr);  /* previous call may change stack */
+  setobj2s(L, func, tm);  /* tag method is the new function to be called */
+  return func;
+}
+
+
+
+#define inc_ci(L) \
+  ((L->ci == L->end_ci) ? luaD_growCI(L) : \
+   (condhardstacktests(luaD_reallocCI(L, L->size_ci)), ++L->ci))
+
+
+int luaD_precall (lua_State *L, StkId func, int nresults) {
+  LClosure *cl;
+  ptrdiff_t funcr;
+  if (!ttisfunction(func)) /* `func' is not a function? */
+    func = luaD_tryfuncTM(L, func);  /* check the `function' tag method */
+  funcr = savestack(L, func);
+  cl = &clvalue(func)->l;
+  L->ci->savedpc = L->savedpc;
+  if (!cl->isC) {  /* Lua function? prepare its call */
+    CallInfo *ci;
+    StkId st, base;
+    Proto *p = cl->p;
+    if (p->jit_status <= JIT_S_NONE) { /* JIT compiler enabled? */
+      if (p->jit_status == JIT_S_OK)
+        return G(L)->jit_gateLJ(L, func, nresults);  /* Run compiled code. */
+      else
+        return luaJIT_run(L, func, nresults);  /* Compile and run code. */
+    }
+    luaD_checkstack(L, p->maxstacksize);
+    func = restorestack(L, funcr);
+    if (!p->is_vararg) {  /* no varargs? */
+      base = func + 1;
+      if (L->top > base + p->numparams)
+        L->top = base + p->numparams;
+    }
+    else {  /* vararg function */
+      int nargs = cast_int(L->top - func) - 1;
+      base = adjust_varargs(L, p, nargs);
+      func = restorestack(L, funcr);  /* previous call may change the stack */
+    }
+    ci = inc_ci(L);  /* now `enter' new function */
+    ci->func = func;
+    L->base = ci->base = base;
+    ci->top = L->base + p->maxstacksize;
+    lua_assert(ci->top <= L->stack_last);
+    L->savedpc = p->code;  /* starting point */
+    ci->tailcalls = 0;
+    ci->nresults = nresults;
+    for (st = L->top; st < ci->top; st++)
+      setnilvalue(st);
+    L->top = ci->top;
+    if (L->hookmask & LUA_MASKCALL) {
+      L->savedpc++;  /* hooks assume 'pc' is already incremented */
+      luaD_callhook(L, LUA_HOOKCALL, -1);
+      L->savedpc--;  /* correct 'pc' */
+    }
+    return PCRLUA;
+  }
+  else {  /* if is a C function, call it */
+    CallInfo *ci;
+    int n;
+    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
+    ci = inc_ci(L);  /* now `enter' new function */
+    ci->func = restorestack(L, funcr);
+    L->base = ci->base = ci->func + 1;
+    ci->top = L->top + LUA_MINSTACK;
+    lua_assert(ci->top <= L->stack_last);
+    ci->nresults = nresults;
+    if (L->hookmask & LUA_MASKCALL)
+      luaD_callhook(L, LUA_HOOKCALL, -1);
+    lua_unlock(L);
+    n = (*curr_func(L)->c.f)(L);  /* do the actual call */
+    lua_lock(L);
+    if (n < 0)  /* yielding? */
+      return PCRYIELD;
+    else {
+      luaD_poscall(L, L->top - n);
+      return PCRC;
+    }
+  }
+}
+
+
+static StkId callrethooks (lua_State *L, StkId firstResult) {
+  ptrdiff_t fr = savestack(L, firstResult);  /* next call may change stack */
+  luaD_callhook(L, LUA_HOOKRET, -1);
+  if (f_isLua(L->ci)) {  /* Lua function? */
+    while ((L->hookmask & LUA_MASKRET) && L->ci->tailcalls--) /* tail calls */
+      luaD_callhook(L, LUA_HOOKTAILRET, -1);
+  }
+  return restorestack(L, fr);
+}
+
+
+int luaD_poscall (lua_State *L, StkId firstResult) {
+  StkId res;
+  int wanted, i;
+  CallInfo *ci;
+  if (L->hookmask & LUA_MASKRET)
+    firstResult = callrethooks(L, firstResult);
+  ci = L->ci--;
+  res = ci->func;  /* res == final position of 1st result */
+  wanted = ci->nresults;
+  L->base = (ci - 1)->base;  /* restore base */
+  L->savedpc = (ci - 1)->savedpc;  /* restore savedpc */
+  /* move results to correct place */
+  for (i = wanted; i != 0 && firstResult < L->top; i--)
+    setobjs2s(L, res++, firstResult++);
+  while (i-- > 0)
+    setnilvalue(res++);
+  L->top = res;
+  return (wanted - LUA_MULTRET);  /* 0 iff wanted == LUA_MULTRET */
+}
+
+
+/*
+** Call a function (C or Lua). The function to be called is at *func.
+** The arguments are on the stack, right after the function.
+** When returns, all the results are on the stack, starting at the original
+** function position.
+*/ 
+void luaD_call (lua_State *L, StkId func, int nResults) {
+  if (++L->nCcalls >= LUAI_MAXCCALLS) {
+    if (L->nCcalls == LUAI_MAXCCALLS)
+      luaG_runerror(L, "C stack overflow");
+    else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
+      luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
+  }
+  if (luaD_precall(L, func, nResults) == PCRLUA)  /* is a Lua function? */
+    luaV_execute(L, 1);  /* call it */
+  L->nCcalls--;
+  luaC_checkGC(L);
+}
+
+
+static void resume (lua_State *L, void *ud) {
+  StkId firstArg = cast(StkId, ud);
+  CallInfo *ci = L->ci;
+  if (L->status == 0) {  /* start coroutine? */
+    lua_assert(ci == L->base_ci && firstArg > L->base);
+    if (luaD_precall(L, firstArg - 1, LUA_MULTRET) != PCRLUA)
+      return;
+  }
+  else {  /* resuming from previous yield */
+    lua_assert(L->status == LUA_YIELD);
+    L->status = 0;
+    if (!f_isLua(ci)) {  /* `common' yield? */
+      /* finish interrupted execution of `OP_CALL' */
+      lua_assert(GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_CALL ||
+                 GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_TAILCALL);
+      if (luaD_poscall(L, firstArg))  /* complete it... */
+        L->top = L->ci->top;  /* and correct top if not multiple results */
+    }
+    else  /* yielded inside a hook: just continue its execution */
+      L->base = L->ci->base;
+  }
+  luaV_execute(L, cast_int(L->ci - L->base_ci));
+}
+
+
+static int resume_error (lua_State *L, const char *msg) {
+  L->top = L->ci->base;
+  setsvalue2s(L, L->top, luaS_new(L, msg));
+  incr_top(L);
+  lua_unlock(L);
+  return LUA_ERRRUN;
+}
+
+
+LUA_API int lua_resume (lua_State *L, int nargs) {
+  int status;
+  lua_lock(L);
+  if (L->status != LUA_YIELD && (L->status != 0 || L->ci != L->base_ci))
+      return resume_error(L, "cannot resume non-suspended coroutine");
+  luai_userstateresume(L, nargs);
+  lua_assert(L->errfunc == 0 && L->nCcalls == 0);
+  status = luaD_rawrunprotected(L, resume, L->top - nargs);
+  if (status != 0) {  /* error? */
+    L->status = cast_byte(status);  /* mark thread as `dead' */
+    luaD_seterrorobj(L, status, L->top);
+    L->ci->top = L->top;
+  }
+  else
+    status = L->status;
+  lua_unlock(L);
+  return status;
+}
+
+
+LUA_API int lua_yield (lua_State *L, int nresults) {
+  luai_userstateyield(L, nresults);
+  lua_lock(L);
+  if (L->nCcalls > 0)
+    luaG_runerror(L, "attempt to yield across metamethod/C-call boundary");
+  L->base = L->top - nresults;  /* protect stack slots below */
+  L->status = LUA_YIELD;
+  lua_unlock(L);
+  return -1;
+}
+
+
+int luaD_pcall (lua_State *L, Pfunc func, void *u,
+                ptrdiff_t old_top, ptrdiff_t ef) {
+  int status;
+  unsigned short oldnCcalls = L->nCcalls;
+  ptrdiff_t old_ci = saveci(L, L->ci);
+  lu_byte old_allowhooks = L->allowhook;
+  ptrdiff_t old_errfunc = L->errfunc;
+  L->errfunc = ef;
+  status = luaD_rawrunprotected(L, func, u);
+  if (status != 0) {  /* an error occurred? */
+    StkId oldtop = restorestack(L, old_top);
+    luaF_close(L, oldtop);  /* close eventual pending closures */
+    luaD_seterrorobj(L, status, oldtop);
+    L->nCcalls = oldnCcalls;
+    L->ci = restoreci(L, old_ci);
+    L->base = L->ci->base;
+    L->savedpc = L->ci->savedpc;
+    L->allowhook = old_allowhooks;
+    restore_stack_limit(L);
+  }
+  L->errfunc = old_errfunc;
+  return status;
+}
+
+
+
+/*
+** Execute a protected parser.
+*/
+struct SParser {  /* data to `f_parser' */
+  ZIO *z;
+  Mbuffer buff;  /* buffer to be used by the scanner */
+  const char *name;
+};
+
+static void f_parser (lua_State *L, void *ud) {
+  int i;
+  Proto *tf;
+  Closure *cl;
+  struct SParser *p = cast(struct SParser *, ud);
+  int c = luaZ_lookahead(p->z);
+  luaC_checkGC(L);
+  tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,
+                                                             &p->buff, p->name);
+  cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));
+  cl->l.p = tf;
+  for (i = 0; i < tf->nups; i++)  /* initialize eventual upvalues */
+    cl->l.upvals[i] = luaF_newupval(L);
+  setclvalue(L, L->top, cl);
+  incr_top(L);
+}
+
+
+int luaD_protectedparser (lua_State *L, ZIO *z, const char *name) {
+  struct SParser p;
+  int status;
+  p.z = z; p.name = name;
+  luaZ_initbuffer(L, &p.buff);
+  status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
+  luaZ_freebuffer(L, &p.buff);
+  return status;
+}
+
+
diff --git a/libraries/LuaJIT-1.1.7/src/ldo.h b/libraries/LuaJIT-1.1.7/src/ldo.h
new file mode 100644
index 0000000..63760f9
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ldo.h
@@ -0,0 +1,59 @@
+/*
+** $Id: ldo.h,v 2.7.1.1 2007/12/27 13:02:25 roberto Exp $
+** Stack and Call structure of Lua
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ldo_h
+#define ldo_h
+
+
+#include "lobject.h"
+#include "lstate.h"
+#include "lzio.h"
+
+
+#define luaD_checkstack(L,n)    \
+  if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TValue)) \
+    luaD_growstack(L, n); \
+  else condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1));
+
+
+#define incr_top(L) {luaD_checkstack(L,1); L->top++;}
+
+#define savestack(L,p)          ((char *)(p) - (char *)L->stack)
+#define restorestack(L,n)       ((TValue *)((char *)L->stack + (n)))
+
+#define saveci(L,p)             ((char *)(p) - (char *)L->base_ci)
+#define restoreci(L,n)          ((CallInfo *)((char *)L->base_ci + (n)))
+
+
+/* results from luaD_precall */
+#define PCRLUA          0       /* initiated a call to a Lua function */
+#define PCRC            1       /* did a call to a C function */
+#define PCRYIELD        2       /* C function yielded */
+
+
+/* type of protected functions, to be ran by `runprotected' */
+typedef void (*Pfunc) (lua_State *L, void *ud);
+
+LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name);
+LUAI_FUNC void luaD_callhook (lua_State *L, int event, int line);
+LUAI_FUNC StkId luaD_tryfuncTM (lua_State *L, StkId func);
+LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
+LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
+LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
+                                        ptrdiff_t oldtop, ptrdiff_t ef);
+LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult);
+LUAI_FUNC void luaD_reallocCI (lua_State *L, int newsize);
+LUAI_FUNC CallInfo *luaD_growCI (lua_State *L);
+LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
+LUAI_FUNC void luaD_growstack (lua_State *L, int n);
+
+LUAI_FUNC void luaD_throw (lua_State *L, int errcode);
+LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
+
+LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);
+
+#endif
+
diff --git a/libraries/LuaJIT-1.1.7/src/ldump.c b/libraries/LuaJIT-1.1.7/src/ldump.c
new file mode 100644
index 0000000..c9d3d48
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ldump.c
@@ -0,0 +1,164 @@
+/*
+** $Id: ldump.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
+** save precompiled Lua chunks
+** See Copyright Notice in lua.h
+*/
+
+#include <stddef.h>
+
+#define ldump_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lobject.h"
+#include "lstate.h"
+#include "lundump.h"
+
+typedef struct {
+ lua_State* L;
+ lua_Writer writer;
+ void* data;
+ int strip;
+ int status;
+} DumpState;
+
+#define DumpMem(b,n,size,D)     DumpBlock(b,(n)*(size),D)
+#define DumpVar(x,D)            DumpMem(&x,1,sizeof(x),D)
+
+static void DumpBlock(const void* b, size_t size, DumpState* D)
+{
+ if (D->status==0)
+ {
+  lua_unlock(D->L);
+  D->status=(*D->writer)(D->L,b,size,D->data);
+  lua_lock(D->L);
+ }
+}
+
+static void DumpChar(int y, DumpState* D)
+{
+ char x=(char)y;
+ DumpVar(x,D);
+}
+
+static void DumpInt(int x, DumpState* D)
+{
+ DumpVar(x,D);
+}
+
+static void DumpNumber(lua_Number x, DumpState* D)
+{
+ DumpVar(x,D);
+}
+
+static void DumpVector(const void* b, int n, size_t size, DumpState* D)
+{
+ DumpInt(n,D);
+ DumpMem(b,n,size,D);
+}
+
+static void DumpString(const TString* s, DumpState* D)
+{
+ if (s==NULL || getstr(s)==NULL)
+ {
+  size_t size=0;
+  DumpVar(size,D);
+ }
+ else
+ {
+  size_t size=s->tsv.len+1;             /* include trailing '\0' */
+  DumpVar(size,D);
+  DumpBlock(getstr(s),size,D);
+ }
+}
+
+#define DumpCode(f,D)    DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
+
+static void DumpFunction(const Proto* f, const TString* p, DumpState* D);
+
+static void DumpConstants(const Proto* f, DumpState* D)
+{
+ int i,n=f->sizek;
+ DumpInt(n,D);
+ for (i=0; i<n; i++)
+ {
+  const TValue* o=&f->k[i];
+  DumpChar(ttype(o),D);
+  switch (ttype(o))
+  {
+   case LUA_TNIL:
+        break;
+   case LUA_TBOOLEAN:
+        DumpChar(bvalue(o),D);
+        break;
+   case LUA_TNUMBER:
+        DumpNumber(nvalue(o),D);
+        break;
+   case LUA_TSTRING:
+        DumpString(rawtsvalue(o),D);
+        break;
+   default:
+        lua_assert(0);                  /* cannot happen */
+        break;
+  }
+ }
+ n=f->sizep;
+ DumpInt(n,D);
+ for (i=0; i<n; i++) DumpFunction(f->p[i],f->source,D);
+}
+
+static void DumpDebug(const Proto* f, DumpState* D)
+{
+ int i,n;
+ n= (D->strip) ? 0 : f->sizelineinfo;
+ DumpVector(f->lineinfo,n,sizeof(int),D);
+ n= (D->strip) ? 0 : f->sizelocvars;
+ DumpInt(n,D);
+ for (i=0; i<n; i++)
+ {
+  DumpString(f->locvars[i].varname,D);
+  DumpInt(f->locvars[i].startpc,D);
+  DumpInt(f->locvars[i].endpc,D);
+ }
+ n= (D->strip) ? 0 : f->sizeupvalues;
+ DumpInt(n,D);
+ for (i=0; i<n; i++) DumpString(f->upvalues[i],D);
+}
+
+static void DumpFunction(const Proto* f, const TString* p, DumpState* D)
+{
+ DumpString((f->source==p || D->strip) ? NULL : f->source,D);
+ DumpInt(f->linedefined,D);
+ DumpInt(f->lastlinedefined,D);
+ DumpChar(f->nups,D);
+ DumpChar(f->numparams,D);
+ DumpChar(f->is_vararg,D);
+ DumpChar(f->maxstacksize,D);
+ DumpCode(f,D);
+ DumpConstants(f,D);
+ DumpDebug(f,D);
+}
+
+static void DumpHeader(DumpState* D)
+{
+ char h[LUAC_HEADERSIZE];
+ luaU_header(h);
+ DumpBlock(h,LUAC_HEADERSIZE,D);
+}
+
+/*
+** dump Lua function as precompiled chunk
+*/
+int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
+{
+ DumpState D;
+ D.L=L;
+ D.writer=w;
+ D.data=data;
+ D.strip=strip;
+ D.status=0;
+ DumpHeader(&D);
+ DumpFunction(f,NULL,&D);
+ return D.status;
+}
diff --git a/libraries/LuaJIT-1.1.7/src/lfunc.c b/libraries/LuaJIT-1.1.7/src/lfunc.c
new file mode 100644
index 0000000..334e305
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lfunc.c
@@ -0,0 +1,182 @@
+/*
+** $Id: lfunc.c,v 2.12.1.2 2007/12/28 14:58:43 roberto Exp $
+** Auxiliary functions to manipulate prototypes and closures
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stddef.h>
+
+#define lfunc_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lfunc.h"
+#include "lgc.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lstate.h"
+#include "ljit.h"
+
+
+
+Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e) {
+  Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));
+  luaC_link(L, obj2gco(c), LUA_TFUNCTION);
+  c->c.isC = 1;
+  c->c.env = e;
+  c->c.nupvalues = cast_byte(nelems);
+  c->c.jit_gate = G(L)->jit_gateJC;
+  return c;
+}
+
+
+Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e) {
+  Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));
+  luaC_link(L, obj2gco(c), LUA_TFUNCTION);
+  c->l.isC = 0;
+  c->l.env = e;
+  c->l.jit_gate = G(L)->jit_gateJL;
+  c->l.nupvalues = cast_byte(nelems);
+  while (nelems--) c->l.upvals[nelems] = NULL;
+  return c;
+}
+
+
+UpVal *luaF_newupval (lua_State *L) {
+  UpVal *uv = luaM_new(L, UpVal);
+  luaC_link(L, obj2gco(uv), LUA_TUPVAL);
+  uv->v = &uv->u.value;
+  setnilvalue(uv->v);
+  return uv;
+}
+
+
+UpVal *luaF_findupval (lua_State *L, StkId level) {
+  global_State *g = G(L);
+  GCObject **pp = &L->openupval;
+  UpVal *p;
+  UpVal *uv;
+  while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) {
+    lua_assert(p->v != &p->u.value);
+    if (p->v == level) {  /* found a corresponding upvalue? */
+      if (isdead(g, obj2gco(p)))  /* is it dead? */
+        changewhite(obj2gco(p));  /* ressurect it */
+      return p;
+    }
+    pp = &p->next;
+  }
+  uv = luaM_new(L, UpVal);  /* not found: create a new one */
+  uv->tt = LUA_TUPVAL;
+  uv->marked = luaC_white(g);
+  uv->v = level;  /* current value lives in the stack */
+  uv->next = *pp;  /* chain it in the proper position */
+  *pp = obj2gco(uv);
+  uv->u.l.prev = &g->uvhead;  /* double link it in `uvhead' list */
+  uv->u.l.next = g->uvhead.u.l.next;
+  uv->u.l.next->u.l.prev = uv;
+  g->uvhead.u.l.next = uv;
+  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
+  return uv;
+}
+
+
+static void unlinkupval (UpVal *uv) {
+  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
+  uv->u.l.next->u.l.prev = uv->u.l.prev;  /* remove from `uvhead' list */
+  uv->u.l.prev->u.l.next = uv->u.l.next;
+}
+
+
+void luaF_freeupval (lua_State *L, UpVal *uv) {
+  if (uv->v != &uv->u.value)  /* is it open? */
+    unlinkupval(uv);  /* remove from open list */
+  luaM_free(L, uv);  /* free upvalue */
+}
+
+
+void luaF_close (lua_State *L, StkId level) {
+  UpVal *uv;
+  global_State *g = G(L);
+  while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) {
+    GCObject *o = obj2gco(uv);
+    lua_assert(!isblack(o) && uv->v != &uv->u.value);
+    L->openupval = uv->next;  /* remove from `open' list */
+    if (isdead(g, o))
+      luaF_freeupval(L, uv);  /* free upvalue */
+    else {
+      unlinkupval(uv);
+      setobj(L, &uv->u.value, uv->v);
+      uv->v = &uv->u.value;  /* now current value lives here */
+      luaC_linkupval(L, uv);  /* link upvalue into `gcroot' list */
+    }
+  }
+}
+
+
+Proto *luaF_newproto (lua_State *L) {
+  Proto *f = luaM_new(L, Proto);
+  luaC_link(L, obj2gco(f), LUA_TPROTO);
+  f->k = NULL;
+  f->sizek = 0;
+  f->p = NULL;
+  f->sizep = 0;
+  f->code = NULL;
+  f->sizecode = 0;
+  f->sizelineinfo = 0;
+  f->sizeupvalues = 0;
+  f->nups = 0;
+  f->upvalues = NULL;
+  f->numparams = 0;
+  f->is_vararg = 0;
+  f->maxstacksize = 0;
+  f->lineinfo = NULL;
+  f->sizelocvars = 0;
+  f->locvars = NULL;
+  f->linedefined = 0;
+  f->lastlinedefined = 0;
+  f->source = NULL;
+  /* LuaJIT extensions */
+  f->jit_mcode = NULL;
+  f->jit_szmcode = 0;
+  f->jit_status = JIT_S_NONE;
+  return f;
+}
+
+
+void luaF_freeproto (lua_State *L, Proto *f) {
+  luaJIT_freeproto(L, f);
+  luaM_freearray(L, f->code, f->sizecode, Instruction);
+  luaM_freearray(L, f->p, f->sizep, Proto *);
+  luaM_freearray(L, f->k, f->sizek, TValue);
+  luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);
+  luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);
+  luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);
+  luaM_free(L, f);
+}
+
+
+void luaF_freeclosure (lua_State *L, Closure *c) {
+  int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :
+                          sizeLclosure(c->l.nupvalues);
+  luaM_freemem(L, c, size);
+}
+
+
+/*
+** Look for n-th local variable at line `line' in function `func'.
+** Returns NULL if not found.
+*/
+const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
+  int i;
+  for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
+    if (pc < f->locvars[i].endpc) {  /* is variable active? */
+      local_number--;
+      if (local_number == 0)
+        return getstr(f->locvars[i].varname);
+    }
+  }
+  return NULL;  /* not found */
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lfunc.h b/libraries/LuaJIT-1.1.7/src/lfunc.h
new file mode 100644
index 0000000..a68cf51
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lfunc.h
@@ -0,0 +1,34 @@
+/*
+** $Id: lfunc.h,v 2.4.1.1 2007/12/27 13:02:25 roberto Exp $
+** Auxiliary functions to manipulate prototypes and closures
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lfunc_h
+#define lfunc_h
+
+
+#include "lobject.h"
+
+
+#define sizeCclosure(n) (cast(int, sizeof(CClosure)) + \
+                         cast(int, sizeof(TValue)*((n)-1)))
+
+#define sizeLclosure(n) (cast(int, sizeof(LClosure)) + \
+                         cast(int, sizeof(TValue *)*((n)-1)))
+
+
+LUAI_FUNC Proto *luaF_newproto (lua_State *L);
+LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e);
+LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e);
+LUAI_FUNC UpVal *luaF_newupval (lua_State *L);
+LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
+LUAI_FUNC void luaF_close (lua_State *L, StkId level);
+LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
+LUAI_FUNC void luaF_freeclosure (lua_State *L, Closure *c);
+LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv);
+LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
+                                         int pc);
+
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lgc.c b/libraries/LuaJIT-1.1.7/src/lgc.c
new file mode 100644
index 0000000..d9e0b78
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lgc.c
@@ -0,0 +1,711 @@
+/*
+** $Id: lgc.c,v 2.38.1.1 2007/12/27 13:02:25 roberto Exp $
+** Garbage Collector
+** See Copyright Notice in lua.h
+*/
+
+#include <string.h>
+
+#define lgc_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lgc.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "ltm.h"
+
+
+#define GCSTEPSIZE      1024u
+#define GCSWEEPMAX      40
+#define GCSWEEPCOST     10
+#define GCFINALIZECOST  100
+
+
+#define maskmarks       cast_byte(~(bitmask(BLACKBIT)|WHITEBITS))
+
+#define makewhite(g,x)  \
+   ((x)->gch.marked = cast_byte(((x)->gch.marked & maskmarks) | luaC_white(g)))
+
+#define white2gray(x)   reset2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
+#define black2gray(x)   resetbit((x)->gch.marked, BLACKBIT)
+
+#define stringmark(s)   reset2bits((s)->tsv.marked, WHITE0BIT, WHITE1BIT)
+
+
+#define isfinalized(u)          testbit((u)->marked, FINALIZEDBIT)
+#define markfinalized(u)        l_setbit((u)->marked, FINALIZEDBIT)
+
+
+#define KEYWEAK         bitmask(KEYWEAKBIT)
+#define VALUEWEAK       bitmask(VALUEWEAKBIT)
+
+
+
+#define markvalue(g,o) { checkconsistency(o); \
+  if (iscollectable(o) && iswhite(gcvalue(o))) reallymarkobject(g,gcvalue(o)); }
+
+#define markobject(g,t) { if (iswhite(obj2gco(t))) \
+                reallymarkobject(g, obj2gco(t)); }
+
+
+#define setthreshold(g)  (g->GCthreshold = (g->estimate/100) * g->gcpause)
+
+
+static void removeentry (Node *n) {
+  lua_assert(ttisnil(gval(n)));
+  if (iscollectable(gkey(n)))
+    setttype(gkey(n), LUA_TDEADKEY);  /* dead key; remove it */
+}
+
+
+static void reallymarkobject (global_State *g, GCObject *o) {
+  lua_assert(iswhite(o) && !isdead(g, o));
+  white2gray(o);
+  switch (o->gch.tt) {
+    case LUA_TSTRING: {
+      return;
+    }
+    case LUA_TUSERDATA: {
+      Table *mt = gco2u(o)->metatable;
+      gray2black(o);  /* udata are never gray */
+      if (mt) markobject(g, mt);
+      markobject(g, gco2u(o)->env);
+      return;
+    }
+    case LUA_TUPVAL: {
+      UpVal *uv = gco2uv(o);
+      markvalue(g, uv->v);
+      if (uv->v == &uv->u.value)  /* closed? */
+        gray2black(o);  /* open upvalues are never black */
+      return;
+    }
+    case LUA_TFUNCTION: {
+      gco2cl(o)->c.gclist = g->gray;
+      g->gray = o;
+      break;
+    }
+    case LUA_TTABLE: {
+      gco2h(o)->gclist = g->gray;
+      g->gray = o;
+      break;
+    }
+    case LUA_TTHREAD: {
+      gco2th(o)->gclist = g->gray;
+      g->gray = o;
+      break;
+    }
+    case LUA_TPROTO: {
+      gco2p(o)->gclist = g->gray;
+      g->gray = o;
+      break;
+    }
+    default: lua_assert(0);
+  }
+}
+
+
+static void marktmu (global_State *g) {
+  GCObject *u = g->tmudata;
+  if (u) {
+    do {
+      u = u->gch.next;
+      makewhite(g, u);  /* may be marked, if left from previous GC */
+      reallymarkobject(g, u);
+    } while (u != g->tmudata);
+  }
+}
+
+
+/* move `dead' udata that need finalization to list `tmudata' */
+size_t luaC_separateudata (lua_State *L, int all) {
+  global_State *g = G(L);
+  size_t deadmem = 0;
+  GCObject **p = &g->mainthread->next;
+  GCObject *curr;
+  while ((curr = *p) != NULL) {
+    if (!(iswhite(curr) || all) || isfinalized(gco2u(curr)))
+      p = &curr->gch.next;  /* don't bother with them */
+    else if (fasttm(L, gco2u(curr)->metatable, TM_GC) == NULL) {
+      markfinalized(gco2u(curr));  /* don't need finalization */
+      p = &curr->gch.next;
+    }
+    else {  /* must call its gc method */
+      deadmem += sizeudata(gco2u(curr));
+      markfinalized(gco2u(curr));
+      *p = curr->gch.next;
+      /* link `curr' at the end of `tmudata' list */
+      if (g->tmudata == NULL)  /* list is empty? */
+        g->tmudata = curr->gch.next = curr;  /* creates a circular list */
+      else {
+        curr->gch.next = g->tmudata->gch.next;
+        g->tmudata->gch.next = curr;
+        g->tmudata = curr;
+      }
+    }
+  }
+  return deadmem;
+}
+
+
+static int traversetable (global_State *g, Table *h) {
+  int i;
+  int weakkey = 0;
+  int weakvalue = 0;
+  const TValue *mode;
+  if (h->metatable)
+    markobject(g, h->metatable);
+  mode = gfasttm(g, h->metatable, TM_MODE);
+  if (mode && ttisstring(mode)) {  /* is there a weak mode? */
+    weakkey = (strchr(svalue(mode), 'k') != NULL);
+    weakvalue = (strchr(svalue(mode), 'v') != NULL);
+    if (weakkey || weakvalue) {  /* is really weak? */
+      h->marked &= ~(KEYWEAK | VALUEWEAK);  /* clear bits */
+      h->marked |= cast_byte((weakkey << KEYWEAKBIT) |
+                             (weakvalue << VALUEWEAKBIT));
+      h->gclist = g->weak;  /* must be cleared after GC, ... */
+      g->weak = obj2gco(h);  /* ... so put in the appropriate list */
+    }
+  }
+  if (weakkey && weakvalue) return 1;
+  if (!weakvalue) {
+    i = h->sizearray;
+    while (i--)
+      markvalue(g, &h->array[i]);
+  }
+  i = sizenode(h);
+  while (i--) {
+    Node *n = gnode(h, i);
+    lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));
+    if (ttisnil(gval(n)))
+      removeentry(n);  /* remove empty entries */
+    else {
+      lua_assert(!ttisnil(gkey(n)));
+      if (!weakkey) markvalue(g, gkey(n));
+      if (!weakvalue) markvalue(g, gval(n));
+    }
+  }
+  return weakkey || weakvalue;
+}
+
+
+/*
+** All marks are conditional because a GC may happen while the
+** prototype is still being created
+*/
+static void traverseproto (global_State *g, Proto *f) {
+  int i;
+  if (f->source) stringmark(f->source);
+  for (i=0; i<f->sizek; i++)  /* mark literals */
+    markvalue(g, &f->k[i]);
+  for (i=0; i<f->sizeupvalues; i++) {  /* mark upvalue names */
+    if (f->upvalues[i])
+      stringmark(f->upvalues[i]);
+  }
+  for (i=0; i<f->sizep; i++) {  /* mark nested protos */
+    if (f->p[i])
+      markobject(g, f->p[i]);
+  }
+  for (i=0; i<f->sizelocvars; i++) {  /* mark local-variable names */
+    if (f->locvars[i].varname)
+      stringmark(f->locvars[i].varname);
+  }
+}
+
+
+
+static void traverseclosure (global_State *g, Closure *cl) {
+  markobject(g, cl->c.env);
+  if (cl->c.isC) {
+    int i;
+    for (i=0; i<cl->c.nupvalues; i++)  /* mark its upvalues */
+      markvalue(g, &cl->c.upvalue[i]);
+  }
+  else {
+    int i;
+    lua_assert(cl->l.nupvalues == cl->l.p->nups);
+    markobject(g, cl->l.p);
+    for (i=0; i<cl->l.nupvalues; i++)  /* mark its upvalues */
+      markobject(g, cl->l.upvals[i]);
+  }
+}
+
+
+static void checkstacksizes (lua_State *L, StkId max) {
+  int ci_used = cast_int(L->ci - L->base_ci);  /* number of `ci' in use */
+  int s_used = cast_int(max - L->stack);  /* part of stack in use */
+  if (L->size_ci > LUAI_MAXCALLS)  /* handling overflow? */
+    return;  /* do not touch the stacks */
+  if (4*ci_used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci)
+    luaD_reallocCI(L, L->size_ci/2);  /* still big enough... */
+  condhardstacktests(luaD_reallocCI(L, ci_used + 1));
+  if (4*s_used < L->stacksize &&
+      2*(BASIC_STACK_SIZE+EXTRA_STACK) < L->stacksize)
+    luaD_reallocstack(L, L->stacksize/2);  /* still big enough... */
+  condhardstacktests(luaD_reallocstack(L, s_used));
+}
+
+
+static void traversestack (global_State *g, lua_State *l) {
+  StkId o, lim;
+  CallInfo *ci;
+  markvalue(g, gt(l));
+  lim = l->top;
+  for (ci = l->base_ci; ci <= l->ci; ci++) {
+    lua_assert(ci->top <= l->stack_last);
+    if (lim < ci->top) lim = ci->top;
+  }
+  for (o = l->stack; o < l->top; o++)
+    markvalue(g, o);
+  for (; o <= lim; o++)
+    setnilvalue(o);
+  checkstacksizes(l, lim);
+}
+
+
+/*
+** traverse one gray object, turning it to black.
+** Returns `quantity' traversed.
+*/
+static l_mem propagatemark (global_State *g) {
+  GCObject *o = g->gray;
+  lua_assert(isgray(o));
+  gray2black(o);
+  switch (o->gch.tt) {
+    case LUA_TTABLE: {
+      Table *h = gco2h(o);
+      g->gray = h->gclist;
+      if (traversetable(g, h))  /* table is weak? */
+        black2gray(o);  /* keep it gray */
+      return sizeof(Table) + sizeof(TValue) * h->sizearray +
+                             sizeof(Node) * sizenode(h);
+    }
+    case LUA_TFUNCTION: {
+      Closure *cl = gco2cl(o);
+      g->gray = cl->c.gclist;
+      traverseclosure(g, cl);
+      return (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :
+                           sizeLclosure(cl->l.nupvalues);
+    }
+    case LUA_TTHREAD: {
+      lua_State *th = gco2th(o);
+      g->gray = th->gclist;
+      th->gclist = g->grayagain;
+      g->grayagain = o;
+      black2gray(o);
+      traversestack(g, th);
+      return sizeof(lua_State) + sizeof(TValue) * th->stacksize +
+                                 sizeof(CallInfo) * th->size_ci;
+    }
+    case LUA_TPROTO: {
+      Proto *p = gco2p(o);
+      g->gray = p->gclist;
+      traverseproto(g, p);
+      return sizeof(Proto) + sizeof(Instruction) * p->sizecode +
+                             sizeof(Proto *) * p->sizep +
+                             sizeof(TValue) * p->sizek + 
+                             sizeof(int) * p->sizelineinfo +
+                             sizeof(LocVar) * p->sizelocvars +
+                             sizeof(TString *) * p->sizeupvalues;
+    }
+    default: lua_assert(0); return 0;
+  }
+}
+
+
+static size_t propagateall (global_State *g) {
+  size_t m = 0;
+  while (g->gray) m += propagatemark(g);
+  return m;
+}
+
+
+/*
+** The next function tells whether a key or value can be cleared from
+** a weak table. Non-collectable objects are never removed from weak
+** tables. Strings behave as `values', so are never removed too. for
+** other objects: if really collected, cannot keep them; for userdata
+** being finalized, keep them in keys, but not in values
+*/
+static int iscleared (const TValue *o, int iskey) {
+  if (!iscollectable(o)) return 0;
+  if (ttisstring(o)) {
+    stringmark(rawtsvalue(o));  /* strings are `values', so are never weak */
+    return 0;
+  }
+  return iswhite(gcvalue(o)) ||
+    (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));
+}
+
+
+/*
+** clear collected entries from weaktables
+*/
+static void cleartable (GCObject *l) {
+  while (l) {
+    Table *h = gco2h(l);
+    int i = h->sizearray;
+    lua_assert(testbit(h->marked, VALUEWEAKBIT) ||
+               testbit(h->marked, KEYWEAKBIT));
+    if (testbit(h->marked, VALUEWEAKBIT)) {
+      while (i--) {
+        TValue *o = &h->array[i];
+        if (iscleared(o, 0))  /* value was collected? */
+          setnilvalue(o);  /* remove value */
+      }
+    }
+    i = sizenode(h);
+    while (i--) {
+      Node *n = gnode(h, i);
+      if (!ttisnil(gval(n)) &&  /* non-empty entry? */
+          (iscleared(key2tval(n), 1) || iscleared(gval(n), 0))) {
+        setnilvalue(gval(n));  /* remove value ... */
+        removeentry(n);  /* remove entry from table */
+      }
+    }
+    l = h->gclist;
+  }
+}
+
+
+static void freeobj (lua_State *L, GCObject *o) {
+  switch (o->gch.tt) {
+    case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
+    case LUA_TFUNCTION: luaF_freeclosure(L, gco2cl(o)); break;
+    case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;
+    case LUA_TTABLE: luaH_free(L, gco2h(o)); break;
+    case LUA_TTHREAD: {
+      lua_assert(gco2th(o) != L && gco2th(o) != G(L)->mainthread);
+      luaE_freethread(L, gco2th(o));
+      break;
+    }
+    case LUA_TSTRING: {
+      G(L)->strt.nuse--;
+      luaM_freemem(L, o, sizestring(gco2ts(o)));
+      break;
+    }
+    case LUA_TUSERDATA: {
+      luaM_freemem(L, o, sizeudata(gco2u(o)));
+      break;
+    }
+    default: lua_assert(0);
+  }
+}
+
+
+
+#define sweepwholelist(L,p)     sweeplist(L,p,MAX_LUMEM)
+
+
+static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
+  GCObject *curr;
+  global_State *g = G(L);
+  int deadmask = otherwhite(g);
+  while ((curr = *p) != NULL && count-- > 0) {
+    if (curr->gch.tt == LUA_TTHREAD)  /* sweep open upvalues of each thread */
+      sweepwholelist(L, &gco2th(curr)->openupval);
+    if ((curr->gch.marked ^ WHITEBITS) & deadmask) {  /* not dead? */
+      lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));
+      makewhite(g, curr);  /* make it white (for next cycle) */
+      p = &curr->gch.next;
+    }
+    else {  /* must erase `curr' */
+      lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));
+      *p = curr->gch.next;
+      if (curr == g->rootgc)  /* is the first element of the list? */
+        g->rootgc = curr->gch.next;  /* adjust first */
+      freeobj(L, curr);
+    }
+  }
+  return p;
+}
+
+
+static void checkSizes (lua_State *L) {
+  global_State *g = G(L);
+  /* check size of string hash */
+  if (g->strt.nuse < cast(lu_int32, g->strt.size/4) &&
+      g->strt.size > MINSTRTABSIZE*2)
+    luaS_resize(L, g->strt.size/2);  /* table is too big */
+  /* check size of buffer */
+  if (luaZ_sizebuffer(&g->buff) > LUA_MINBUFFER*2) {  /* buffer too big? */
+    size_t newsize = luaZ_sizebuffer(&g->buff) / 2;
+    luaZ_resizebuffer(L, &g->buff, newsize);
+  }
+}
+
+
+static void GCTM (lua_State *L) {
+  global_State *g = G(L);
+  GCObject *o = g->tmudata->gch.next;  /* get first element */
+  Udata *udata = rawgco2u(o);
+  const TValue *tm;
+  /* remove udata from `tmudata' */
+  if (o == g->tmudata)  /* last element? */
+    g->tmudata = NULL;
+  else
+    g->tmudata->gch.next = udata->uv.next;
+  udata->uv.next = g->mainthread->next;  /* return it to `root' list */
+  g->mainthread->next = o;
+  makewhite(g, o);
+  tm = fasttm(L, udata->uv.metatable, TM_GC);
+  if (tm != NULL) {
+    lu_byte oldah = L->allowhook;
+    lu_mem oldt = g->GCthreshold;
+    L->allowhook = 0;  /* stop debug hooks during GC tag method */
+    g->GCthreshold = 2*g->totalbytes;  /* avoid GC steps */
+    setobj2s(L, L->top, tm);
+    setuvalue(L, L->top+1, udata);
+    L->top += 2;
+    luaD_call(L, L->top - 2, 0);
+    L->allowhook = oldah;  /* restore hooks */
+    g->GCthreshold = oldt;  /* restore threshold */
+  }
+}
+
+
+/*
+** Call all GC tag methods
+*/
+void luaC_callGCTM (lua_State *L) {
+  while (G(L)->tmudata)
+    GCTM(L);
+}
+
+
+void luaC_freeall (lua_State *L) {
+  global_State *g = G(L);
+  int i;
+  g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT);  /* mask to collect all elements */
+  sweepwholelist(L, &g->rootgc);
+  for (i = 0; i < g->strt.size; i++)  /* free all string lists */
+    sweepwholelist(L, &g->strt.hash[i]);
+}
+
+
+static void markmt (global_State *g) {
+  int i;
+  for (i=0; i<NUM_TAGS; i++)
+    if (g->mt[i]) markobject(g, g->mt[i]);
+}
+
+
+/* mark root set */
+static void markroot (lua_State *L) {
+  global_State *g = G(L);
+  g->gray = NULL;
+  g->grayagain = NULL;
+  g->weak = NULL;
+  markobject(g, g->mainthread);
+  /* make global table be traversed before main stack */
+  markvalue(g, gt(g->mainthread));
+  markvalue(g, registry(L));
+  markmt(g);
+  g->gcstate = GCSpropagate;
+}
+
+
+static void remarkupvals (global_State *g) {
+  UpVal *uv;
+  for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {
+    lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
+    if (isgray(obj2gco(uv)))
+      markvalue(g, uv->v);
+  }
+}
+
+
+static void atomic (lua_State *L) {
+  global_State *g = G(L);
+  size_t udsize;  /* total size of userdata to be finalized */
+  /* remark occasional upvalues of (maybe) dead threads */
+  remarkupvals(g);
+  /* traverse objects cautch by write barrier and by 'remarkupvals' */
+  propagateall(g);
+  /* remark weak tables */
+  g->gray = g->weak;
+  g->weak = NULL;
+  lua_assert(!iswhite(obj2gco(g->mainthread)));
+  markobject(g, L);  /* mark running thread */
+  markmt(g);  /* mark basic metatables (again) */
+  propagateall(g);
+  /* remark gray again */
+  g->gray = g->grayagain;
+  g->grayagain = NULL;
+  propagateall(g);
+  udsize = luaC_separateudata(L, 0);  /* separate userdata to be finalized */
+  marktmu(g);  /* mark `preserved' userdata */
+  udsize += propagateall(g);  /* remark, to propagate `preserveness' */
+  cleartable(g->weak);  /* remove collected objects from weak tables */
+  /* flip current white */
+  g->currentwhite = cast_byte(otherwhite(g));
+  g->sweepstrgc = 0;
+  g->sweepgc = &g->rootgc;
+  g->gcstate = GCSsweepstring;
+  g->estimate = g->totalbytes - udsize;  /* first estimate */
+}
+
+
+static l_mem singlestep (lua_State *L) {
+  global_State *g = G(L);
+  /*lua_checkmemory(L);*/
+  switch (g->gcstate) {
+    case GCSpause: {
+      markroot(L);  /* start a new collection */
+      return 0;
+    }
+    case GCSpropagate: {
+      if (g->gray)
+        return propagatemark(g);
+      else {  /* no more `gray' objects */
+        atomic(L);  /* finish mark phase */
+        return 0;
+      }
+    }
+    case GCSsweepstring: {
+      lu_mem old = g->totalbytes;
+      sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);
+      if (g->sweepstrgc >= g->strt.size)  /* nothing more to sweep? */
+        g->gcstate = GCSsweep;  /* end sweep-string phase */
+      lua_assert(old >= g->totalbytes);
+      g->estimate -= old - g->totalbytes;
+      return GCSWEEPCOST;
+    }
+    case GCSsweep: {
+      lu_mem old = g->totalbytes;
+      g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
+      if (*g->sweepgc == NULL) {  /* nothing more to sweep? */
+        checkSizes(L);
+        g->gcstate = GCSfinalize;  /* end sweep phase */
+      }
+      lua_assert(old >= g->totalbytes);
+      g->estimate -= old - g->totalbytes;
+      return GCSWEEPMAX*GCSWEEPCOST;
+    }
+    case GCSfinalize: {
+      if (g->tmudata) {
+        GCTM(L);
+        if (g->estimate > GCFINALIZECOST)
+          g->estimate -= GCFINALIZECOST;
+        return GCFINALIZECOST;
+      }
+      else {
+        g->gcstate = GCSpause;  /* end collection */
+        g->gcdept = 0;
+        return 0;
+      }
+    }
+    default: lua_assert(0); return 0;
+  }
+}
+
+
+void luaC_step (lua_State *L) {
+  global_State *g = G(L);
+  l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;
+  if (lim == 0)
+    lim = (MAX_LUMEM-1)/2;  /* no limit */
+  g->gcdept += g->totalbytes - g->GCthreshold;
+  do {
+    lim -= singlestep(L);
+    if (g->gcstate == GCSpause)
+      break;
+  } while (lim > 0);
+  if (g->gcstate != GCSpause) {
+    if (g->gcdept < GCSTEPSIZE)
+      g->GCthreshold = g->totalbytes + GCSTEPSIZE;  /* - lim/g->gcstepmul;*/
+    else {
+      g->gcdept -= GCSTEPSIZE;
+      g->GCthreshold = g->totalbytes;
+    }
+  }
+  else {
+    lua_assert(g->totalbytes >= g->estimate);
+    setthreshold(g);
+  }
+}
+
+
+void luaC_fullgc (lua_State *L) {
+  global_State *g = G(L);
+  if (g->gcstate <= GCSpropagate) {
+    /* reset sweep marks to sweep all elements (returning them to white) */
+    g->sweepstrgc = 0;
+    g->sweepgc = &g->rootgc;
+    /* reset other collector lists */
+    g->gray = NULL;
+    g->grayagain = NULL;
+    g->weak = NULL;
+    g->gcstate = GCSsweepstring;
+  }
+  lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);
+  /* finish any pending sweep phase */
+  while (g->gcstate != GCSfinalize) {
+    lua_assert(g->gcstate == GCSsweepstring || g->gcstate == GCSsweep);
+    singlestep(L);
+  }
+  markroot(L);
+  while (g->gcstate != GCSpause) {
+    singlestep(L);
+  }
+  setthreshold(g);
+}
+
+
+void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {
+  global_State *g = G(L);
+  lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
+  lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
+  lua_assert(ttype(&o->gch) != LUA_TTABLE);
+  /* must keep invariant? */
+  if (g->gcstate == GCSpropagate)
+    reallymarkobject(g, v);  /* restore invariant */
+  else  /* don't mind */
+    makewhite(g, o);  /* mark as white just to avoid other barriers */
+}
+
+
+void luaC_barrierback (lua_State *L, Table *t) {
+  global_State *g = G(L);
+  GCObject *o = obj2gco(t);
+  lua_assert(isblack(o) && !isdead(g, o));
+  lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
+  black2gray(o);  /* make table gray (again) */
+  t->gclist = g->grayagain;
+  g->grayagain = o;
+}
+
+
+void luaC_link (lua_State *L, GCObject *o, lu_byte tt) {
+  global_State *g = G(L);
+  o->gch.next = g->rootgc;
+  g->rootgc = o;
+  o->gch.marked = luaC_white(g);
+  o->gch.tt = tt;
+}
+
+
+void luaC_linkupval (lua_State *L, UpVal *uv) {
+  global_State *g = G(L);
+  GCObject *o = obj2gco(uv);
+  o->gch.next = g->rootgc;  /* link upvalue into `rootgc' list */
+  g->rootgc = o;
+  if (isgray(o)) { 
+    if (g->gcstate == GCSpropagate) {
+      gray2black(o);  /* closed upvalues need barrier */
+      luaC_barrier(L, uv, uv->v);
+    }
+    else {  /* sweep phase: sweep it (turning it into white) */
+      makewhite(g, o);
+      lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
+    }
+  }
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lgc.h b/libraries/LuaJIT-1.1.7/src/lgc.h
new file mode 100644
index 0000000..5a8dc60
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lgc.h
@@ -0,0 +1,110 @@
+/*
+** $Id: lgc.h,v 2.15.1.1 2007/12/27 13:02:25 roberto Exp $
+** Garbage Collector
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lgc_h
+#define lgc_h
+
+
+#include "lobject.h"
+
+
+/*
+** Possible states of the Garbage Collector
+*/
+#define GCSpause        0
+#define GCSpropagate    1
+#define GCSsweepstring  2
+#define GCSsweep        3
+#define GCSfinalize     4
+
+
+/*
+** some userful bit tricks
+*/
+#define resetbits(x,m)  ((x) &= cast(lu_byte, ~(m)))
+#define setbits(x,m)    ((x) |= (m))
+#define testbits(x,m)   ((x) & (m))
+#define bitmask(b)      (1<<(b))
+#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2))
+#define l_setbit(x,b)   setbits(x, bitmask(b))
+#define resetbit(x,b)   resetbits(x, bitmask(b))
+#define testbit(x,b)    testbits(x, bitmask(b))
+#define set2bits(x,b1,b2)       setbits(x, (bit2mask(b1, b2)))
+#define reset2bits(x,b1,b2)     resetbits(x, (bit2mask(b1, b2)))
+#define test2bits(x,b1,b2)      testbits(x, (bit2mask(b1, b2)))
+
+
+
+/*
+** Layout for bit use in `marked' field:
+** bit 0 - object is white (type 0)
+** bit 1 - object is white (type 1)
+** bit 2 - object is black
+** bit 3 - for userdata: has been finalized
+** bit 3 - for tables: has weak keys
+** bit 4 - for tables: has weak values
+** bit 5 - object is fixed (should not be collected)
+** bit 6 - object is "super" fixed (only the main thread)
+*/
+
+
+#define WHITE0BIT       0
+#define WHITE1BIT       1
+#define BLACKBIT        2
+#define FINALIZEDBIT    3
+#define KEYWEAKBIT      3
+#define VALUEWEAKBIT    4
+#define FIXEDBIT        5
+#define SFIXEDBIT       6
+#define WHITEBITS       bit2mask(WHITE0BIT, WHITE1BIT)
+
+
+#define iswhite(x)      test2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
+#define isblack(x)      testbit((x)->gch.marked, BLACKBIT)
+#define isgray(x)       (!isblack(x) && !iswhite(x))
+
+#define otherwhite(g)   (g->currentwhite ^ WHITEBITS)
+#define isdead(g,v)     ((v)->gch.marked & otherwhite(g) & WHITEBITS)
+
+#define changewhite(x)  ((x)->gch.marked ^= WHITEBITS)
+#define gray2black(x)   l_setbit((x)->gch.marked, BLACKBIT)
+
+#define valiswhite(x)   (iscollectable(x) && iswhite(gcvalue(x)))
+
+#define luaC_white(g)   cast(lu_byte, (g)->currentwhite & WHITEBITS)
+
+
+#define luaC_checkGC(L) { \
+  condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1)); \
+  if (G(L)->totalbytes >= G(L)->GCthreshold) \
+        luaC_step(L); }
+
+
+#define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \
+        luaC_barrierf(L,obj2gco(p),gcvalue(v)); }
+
+#define luaC_barriert(L,t,v) { if (valiswhite(v) && isblack(obj2gco(t)))  \
+        luaC_barrierback(L,t); }
+
+#define luaC_objbarrier(L,p,o)  \
+        { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
+                luaC_barrierf(L,obj2gco(p),obj2gco(o)); }
+
+#define luaC_objbarriert(L,t,o)  \
+   { if (iswhite(obj2gco(o)) && isblack(obj2gco(t))) luaC_barrierback(L,t); }
+
+LUAI_FUNC size_t luaC_separateudata (lua_State *L, int all);
+LUAI_FUNC void luaC_callGCTM (lua_State *L);
+LUAI_FUNC void luaC_freeall (lua_State *L);
+LUAI_FUNC void luaC_step (lua_State *L);
+LUAI_FUNC void luaC_fullgc (lua_State *L);
+LUAI_FUNC void luaC_link (lua_State *L, GCObject *o, lu_byte tt);
+LUAI_FUNC void luaC_linkupval (lua_State *L, UpVal *uv);
+LUAI_FUNC void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v);
+LUAI_FUNC void luaC_barrierback (lua_State *L, Table *t);
+
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/linit.c b/libraries/LuaJIT-1.1.7/src/linit.c
new file mode 100644
index 0000000..db24ccd
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/linit.c
@@ -0,0 +1,39 @@
+/*
+** $Id: linit.c,v 1.14.1.1 2007/12/27 13:02:25 roberto Exp $
+** Initialization of libraries for lua.c
+** See Copyright Notice in lua.h
+*/
+
+
+#define linit_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lualib.h"
+#include "lauxlib.h"
+
+
+static const luaL_Reg lualibs[] = {
+  {"", luaopen_base},
+  {LUA_LOADLIBNAME, luaopen_package},
+  {LUA_TABLIBNAME, luaopen_table},
+  {LUA_IOLIBNAME, luaopen_io},
+  {LUA_OSLIBNAME, luaopen_os},
+  {LUA_STRLIBNAME, luaopen_string},
+  {LUA_MATHLIBNAME, luaopen_math},
+  {LUA_DBLIBNAME, luaopen_debug},
+  {LUA_JITLIBNAME, luaopen_jit},
+  {NULL, NULL}
+};
+
+
+LUALIB_API void luaL_openlibs (lua_State *L) {
+  const luaL_Reg *lib = lualibs;
+  for (; lib->func; lib++) {
+    lua_pushcfunction(L, lib->func);
+    lua_pushstring(L, lib->name);
+    lua_call(L, 1, 0);
+  }
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/liolib.c b/libraries/LuaJIT-1.1.7/src/liolib.c
new file mode 100644
index 0000000..8de2547
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/liolib.c
@@ -0,0 +1,556 @@
+/*
+** $Id: liolib.c,v 2.73.1.3 2008/01/18 17:47:43 roberto Exp $
+** Standard I/O (and system) library
+** See Copyright Notice in lua.h
+*/
+
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define liolib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+
+
+
+#define IO_INPUT        1
+#define IO_OUTPUT       2
+
+
+static const char *const fnames[] = {"input", "output"};
+
+
+static int pushresult (lua_State *L, int i, const char *filename) {
+  int en = errno;  /* calls to Lua API may change this value */
+  if (i) {
+    lua_pushboolean(L, 1);
+    return 1;
+  }
+  else {
+    lua_pushnil(L);
+    if (filename)
+      lua_pushfstring(L, "%s: %s", filename, strerror(en));
+    else
+      lua_pushfstring(L, "%s", strerror(en));
+    lua_pushinteger(L, en);
+    return 3;
+  }
+}
+
+
+static void fileerror (lua_State *L, int arg, const char *filename) {
+  lua_pushfstring(L, "%s: %s", filename, strerror(errno));
+  luaL_argerror(L, arg, lua_tostring(L, -1));
+}
+
+
+#define tofilep(L)      ((FILE **)luaL_checkudata(L, 1, LUA_FILEHANDLE))
+
+
+static int io_type (lua_State *L) {
+  void *ud;
+  luaL_checkany(L, 1);
+  ud = lua_touserdata(L, 1);
+  lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);
+  if (ud == NULL || !lua_getmetatable(L, 1) || !lua_rawequal(L, -2, -1))
+    lua_pushnil(L);  /* not a file */
+  else if (*((FILE **)ud) == NULL)
+    lua_pushliteral(L, "closed file");
+  else
+    lua_pushliteral(L, "file");
+  return 1;
+}
+
+
+static FILE *tofile (lua_State *L) {
+  FILE **f = tofilep(L);
+  if (*f == NULL)
+    luaL_error(L, "attempt to use a closed file");
+  return *f;
+}
+
+
+
+/*
+** When creating file handles, always creates a `closed' file handle
+** before opening the actual file; so, if there is a memory error, the
+** file is not left opened.
+*/
+static FILE **newfile (lua_State *L) {
+  FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));
+  *pf = NULL;  /* file handle is currently `closed' */
+  luaL_getmetatable(L, LUA_FILEHANDLE);
+  lua_setmetatable(L, -2);
+  return pf;
+}
+
+
+/*
+** function to (not) close the standard files stdin, stdout, and stderr
+*/
+static int io_noclose (lua_State *L) {
+  lua_pushnil(L);
+  lua_pushliteral(L, "cannot close standard file");
+  return 2;
+}
+
+
+/*
+** function to close 'popen' files
+*/
+static int io_pclose (lua_State *L) {
+  FILE **p = tofilep(L);
+  int ok = lua_pclose(L, *p);
+  *p = NULL;
+  return pushresult(L, ok, NULL);
+}
+
+
+/*
+** function to close regular files
+*/
+static int io_fclose (lua_State *L) {
+  FILE **p = tofilep(L);
+  int ok = (fclose(*p) == 0);
+  *p = NULL;
+  return pushresult(L, ok, NULL);
+}
+
+
+static int aux_close (lua_State *L) {
+  lua_getfenv(L, 1);
+  lua_getfield(L, -1, "__close");
+  return (lua_tocfunction(L, -1))(L);
+}
+
+
+static int io_close (lua_State *L) {
+  if (lua_isnone(L, 1))
+    lua_rawgeti(L, LUA_ENVIRONINDEX, IO_OUTPUT);
+  tofile(L);  /* make sure argument is a file */
+  return aux_close(L);
+}
+
+
+static int io_gc (lua_State *L) {
+  FILE *f = *tofilep(L);
+  /* ignore closed files */
+  if (f != NULL)
+    aux_close(L);
+  return 0;
+}
+
+
+static int io_tostring (lua_State *L) {
+  FILE *f = *tofilep(L);
+  if (f == NULL)
+    lua_pushliteral(L, "file (closed)");
+  else
+    lua_pushfstring(L, "file (%p)", f);
+  return 1;
+}
+
+
+static int io_open (lua_State *L) {
+  const char *filename = luaL_checkstring(L, 1);
+  const char *mode = luaL_optstring(L, 2, "r");
+  FILE **pf = newfile(L);
+  *pf = fopen(filename, mode);
+  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
+}
+
+
+/*
+** this function has a separated environment, which defines the
+** correct __close for 'popen' files
+*/
+static int io_popen (lua_State *L) {
+  const char *filename = luaL_checkstring(L, 1);
+  const char *mode = luaL_optstring(L, 2, "r");
+  FILE **pf = newfile(L);
+  *pf = lua_popen(L, filename, mode);
+  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
+}
+
+
+static int io_tmpfile (lua_State *L) {
+  FILE **pf = newfile(L);
+  *pf = tmpfile();
+  return (*pf == NULL) ? pushresult(L, 0, NULL) : 1;
+}
+
+
+static FILE *getiofile (lua_State *L, int findex) {
+  FILE *f;
+  lua_rawgeti(L, LUA_ENVIRONINDEX, findex);
+  f = *(FILE **)lua_touserdata(L, -1);
+  if (f == NULL)
+    luaL_error(L, "standard %s file is closed", fnames[findex - 1]);
+  return f;
+}
+
+
+static int g_iofile (lua_State *L, int f, const char *mode) {
+  if (!lua_isnoneornil(L, 1)) {
+    const char *filename = lua_tostring(L, 1);
+    if (filename) {
+      FILE **pf = newfile(L);
+      *pf = fopen(filename, mode);
+      if (*pf == NULL)
+        fileerror(L, 1, filename);
+    }
+    else {
+      tofile(L);  /* check that it's a valid file handle */
+      lua_pushvalue(L, 1);
+    }
+    lua_rawseti(L, LUA_ENVIRONINDEX, f);
+  }
+  /* return current value */
+  lua_rawgeti(L, LUA_ENVIRONINDEX, f);
+  return 1;
+}
+
+
+static int io_input (lua_State *L) {
+  return g_iofile(L, IO_INPUT, "r");
+}
+
+
+static int io_output (lua_State *L) {
+  return g_iofile(L, IO_OUTPUT, "w");
+}
+
+
+static int io_readline (lua_State *L);
+
+
+static void aux_lines (lua_State *L, int idx, int toclose) {
+  lua_pushvalue(L, idx);
+  lua_pushboolean(L, toclose);  /* close/not close file when finished */
+  lua_pushcclosure(L, io_readline, 2);
+}
+
+
+static int f_lines (lua_State *L) {
+  tofile(L);  /* check that it's a valid file handle */
+  aux_lines(L, 1, 0);
+  return 1;
+}
+
+
+static int io_lines (lua_State *L) {
+  if (lua_isnoneornil(L, 1)) {  /* no arguments? */
+    /* will iterate over default input */
+    lua_rawgeti(L, LUA_ENVIRONINDEX, IO_INPUT);
+    return f_lines(L);
+  }
+  else {
+    const char *filename = luaL_checkstring(L, 1);
+    FILE **pf = newfile(L);
+    *pf = fopen(filename, "r");
+    if (*pf == NULL)
+      fileerror(L, 1, filename);
+    aux_lines(L, lua_gettop(L), 1);
+    return 1;
+  }
+}
+
+
+/*
+** {======================================================
+** READ
+** =======================================================
+*/
+
+
+static int read_number (lua_State *L, FILE *f) {
+  lua_Number d;
+  if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {
+    lua_pushnumber(L, d);
+    return 1;
+  }
+  else {
+    lua_pushnil(L);  /* "result" to be removed */
+    return 0;  /* read fails */
+  }
+}
+
+
+static int test_eof (lua_State *L, FILE *f) {
+  int c = getc(f);
+  ungetc(c, f);
+  lua_pushlstring(L, NULL, 0);
+  return (c != EOF);
+}
+
+
+static int read_line (lua_State *L, FILE *f) {
+  luaL_Buffer b;
+  luaL_buffinit(L, &b);
+  for (;;) {
+    size_t l;
+    char *p = luaL_prepbuffer(&b);
+    if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) {  /* eof? */
+      luaL_pushresult(&b);  /* close buffer */
+      return (lua_objlen(L, -1) > 0);  /* check whether read something */
+    }
+    l = strlen(p);
+    if (l == 0 || p[l-1] != '\n')
+      luaL_addsize(&b, l);
+    else {
+      luaL_addsize(&b, l - 1);  /* do not include `eol' */
+      luaL_pushresult(&b);  /* close buffer */
+      return 1;  /* read at least an `eol' */
+    }
+  }
+}
+
+
+static int read_chars (lua_State *L, FILE *f, size_t n) {
+  size_t rlen;  /* how much to read */
+  size_t nr;  /* number of chars actually read */
+  luaL_Buffer b;
+  luaL_buffinit(L, &b);
+  rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */
+  do {
+    char *p = luaL_prepbuffer(&b);
+    if (rlen > n) rlen = n;  /* cannot read more than asked */
+    nr = fread(p, sizeof(char), rlen, f);
+    luaL_addsize(&b, nr);
+    n -= nr;  /* still have to read `n' chars */
+  } while (n > 0 && nr == rlen);  /* until end of count or eof */
+  luaL_pushresult(&b);  /* close buffer */
+  return (n == 0 || lua_objlen(L, -1) > 0);
+}
+
+
+static int g_read (lua_State *L, FILE *f, int first) {
+  int nargs = lua_gettop(L) - 1;
+  int success;
+  int n;
+  clearerr(f);
+  if (nargs == 0) {  /* no arguments? */
+    success = read_line(L, f);
+    n = first+1;  /* to return 1 result */
+  }
+  else {  /* ensure stack space for all results and for auxlib's buffer */
+    luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
+    success = 1;
+    for (n = first; nargs-- && success; n++) {
+      if (lua_type(L, n) == LUA_TNUMBER) {
+        size_t l = (size_t)lua_tointeger(L, n);
+        success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
+      }
+      else {
+        const char *p = lua_tostring(L, n);
+        luaL_argcheck(L, p && p[0] == '*', n, "invalid option");
+        switch (p[1]) {
+          case 'n':  /* number */
+            success = read_number(L, f);
+            break;
+          case 'l':  /* line */
+            success = read_line(L, f);
+            break;
+          case 'a':  /* file */
+            read_chars(L, f, ~((size_t)0));  /* read MAX_SIZE_T chars */
+            success = 1; /* always success */
+            break;
+          default:
+            return luaL_argerror(L, n, "invalid format");
+        }
+      }
+    }
+  }
+  if (ferror(f))
+    return pushresult(L, 0, NULL);
+  if (!success) {
+    lua_pop(L, 1);  /* remove last result */
+    lua_pushnil(L);  /* push nil instead */
+  }
+  return n - first;
+}
+
+
+static int io_read (lua_State *L) {
+  return g_read(L, getiofile(L, IO_INPUT), 1);
+}
+
+
+static int f_read (lua_State *L) {
+  return g_read(L, tofile(L), 2);
+}
+
+
+static int io_readline (lua_State *L) {
+  FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
+  int sucess;
+  if (f == NULL)  /* file is already closed? */
+    luaL_error(L, "file is already closed");
+  sucess = read_line(L, f);
+  if (ferror(f))
+    return luaL_error(L, "%s", strerror(errno));
+  if (sucess) return 1;
+  else {  /* EOF */
+    if (lua_toboolean(L, lua_upvalueindex(2))) {  /* generator created file? */
+      lua_settop(L, 0);
+      lua_pushvalue(L, lua_upvalueindex(1));
+      aux_close(L);  /* close it */
+    }
+    return 0;
+  }
+}
+
+/* }====================================================== */
+
+
+static int g_write (lua_State *L, FILE *f, int arg) {
+  int nargs = lua_gettop(L) - 1;
+  int status = 1;
+  for (; nargs--; arg++) {
+    if (lua_type(L, arg) == LUA_TNUMBER) {
+      /* optimization: could be done exactly as for strings */
+      status = status &&
+          fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
+    }
+    else {
+      size_t l;
+      const char *s = luaL_checklstring(L, arg, &l);
+      status = status && (fwrite(s, sizeof(char), l, f) == l);
+    }
+  }
+  return pushresult(L, status, NULL);
+}
+
+
+static int io_write (lua_State *L) {
+  return g_write(L, getiofile(L, IO_OUTPUT), 1);
+}
+
+
+static int f_write (lua_State *L) {
+  return g_write(L, tofile(L), 2);
+}
+
+
+static int f_seek (lua_State *L) {
+  static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
+  static const char *const modenames[] = {"set", "cur", "end", NULL};
+  FILE *f = tofile(L);
+  int op = luaL_checkoption(L, 2, "cur", modenames);
+  long offset = luaL_optlong(L, 3, 0);
+  op = fseek(f, offset, mode[op]);
+  if (op)
+    return pushresult(L, 0, NULL);  /* error */
+  else {
+    lua_pushinteger(L, ftell(f));
+    return 1;
+  }
+}
+
+
+static int f_setvbuf (lua_State *L) {
+  static const int mode[] = {_IONBF, _IOFBF, _IOLBF};
+  static const char *const modenames[] = {"no", "full", "line", NULL};
+  FILE *f = tofile(L);
+  int op = luaL_checkoption(L, 2, NULL, modenames);
+  lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
+  int res = setvbuf(f, NULL, mode[op], sz);
+  return pushresult(L, res == 0, NULL);
+}
+
+
+
+static int io_flush (lua_State *L) {
+  return pushresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
+}
+
+
+static int f_flush (lua_State *L) {
+  return pushresult(L, fflush(tofile(L)) == 0, NULL);
+}
+
+
+static const luaL_Reg iolib[] = {
+  {"close", io_close},
+  {"flush", io_flush},
+  {"input", io_input},
+  {"lines", io_lines},
+  {"open", io_open},
+  {"output", io_output},
+  {"popen", io_popen},
+  {"read", io_read},
+  {"tmpfile", io_tmpfile},
+  {"type", io_type},
+  {"write", io_write},
+  {NULL, NULL}
+};
+
+
+static const luaL_Reg flib[] = {
+  {"close", io_close},
+  {"flush", f_flush},
+  {"lines", f_lines},
+  {"read", f_read},
+  {"seek", f_seek},
+  {"setvbuf", f_setvbuf},
+  {"write", f_write},
+  {"__gc", io_gc},
+  {"__tostring", io_tostring},
+  {NULL, NULL}
+};
+
+
+static void createmeta (lua_State *L) {
+  luaL_newmetatable(L, LUA_FILEHANDLE);  /* create metatable for file handles */
+  lua_pushvalue(L, -1);  /* push metatable */
+  lua_setfield(L, -2, "__index");  /* metatable.__index = metatable */
+  luaL_register(L, NULL, flib);  /* file methods */
+}
+
+
+static void createstdfile (lua_State *L, FILE *f, int k, const char *fname) {
+  *newfile(L) = f;
+  if (k > 0) {
+    lua_pushvalue(L, -1);
+    lua_rawseti(L, LUA_ENVIRONINDEX, k);
+  }
+  lua_pushvalue(L, -2);  /* copy environment */
+  lua_setfenv(L, -2);  /* set it */
+  lua_setfield(L, -3, fname);
+}
+
+
+static void newfenv (lua_State *L, lua_CFunction cls) {
+  lua_createtable(L, 0, 1);
+  lua_pushcfunction(L, cls);
+  lua_setfield(L, -2, "__close");
+}
+
+
+LUALIB_API int luaopen_io (lua_State *L) {
+  createmeta(L);
+  /* create (private) environment (with fields IO_INPUT, IO_OUTPUT, __close) */
+  newfenv(L, io_fclose);
+  lua_replace(L, LUA_ENVIRONINDEX);
+  /* open library */
+  luaL_register(L, LUA_IOLIBNAME, iolib);
+  /* create (and set) default files */
+  newfenv(L, io_noclose);  /* close function for default files */
+  createstdfile(L, stdin, IO_INPUT, "stdin");
+  createstdfile(L, stdout, IO_OUTPUT, "stdout");
+  createstdfile(L, stderr, 0, "stderr");
+  lua_pop(L, 1);  /* pop environment for default files */
+  lua_getfield(L, -1, "popen");
+  newfenv(L, io_pclose);  /* create environment for 'popen' */
+  lua_setfenv(L, -2);  /* set fenv for 'popen' */
+  lua_pop(L, 1);  /* pop 'popen' */
+  return 1;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/ljit.h b/libraries/LuaJIT-1.1.7/src/ljit.h
new file mode 100644
index 0000000..347de3b
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit.h
@@ -0,0 +1,167 @@
+/*
+** Interface to JIT engine.
+** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+#ifndef ljit_h
+#define ljit_h
+
+#include "lobject.h"
+
+
+/* Define this to enable assertions when debugging LuaJIT. */
+#ifdef LUAJIT_ASSERT
+#include <assert.h>
+#define jit_assert(x)   assert(x)
+#define DASM_CHECKS
+#else
+/* A better idea is to define lua_assert() in luaconf.h. */
+#define jit_assert(x)   lua_assert(x)
+#endif
+
+/* Define this to set the C stack size for the compiler thread. */
+/* The compiler runs on the callers C stack otherwise. */
+#undef LUAJIT_COMPILER_CSTACK
+
+/* Hardcoded limits for the backend to avoid useless work. */
+/* Note: mind you, these are very generous limits. Check jit.opt, too. */
+#define LUAJIT_LIM_BYTECODE     3000    /* Max. # of bytecodes. */
+#define LUAJIT_LIM_MCODE        128000  /* Max. mcode size of a function. */
+
+/* Global JIT engine flags. */
+#define JIT_F_ON                0x0001  /* JIT engine is on. */
+#define JIT_F_COMPILING         0x0002  /* Currently compiling. */
+#define JIT_F_INIT_FAILED       0x0004  /* Initialization failed. */
+
+#define JIT_F_CPU_CMOV          0x0010  /* CPU has conditional move support. */
+#define JIT_F_CPU_SSE2          0x0020  /* CPU has SSE2 support. */
+
+#define JIT_F_DEBUG_CALL        0x0100  /* Compile with call hooks. */
+#define JIT_F_DEBUG_INS         0x0200  /* Compile with instruction hooks. */
+#define JIT_F_DEBUG             0x0f00  /* Union of all debug flags. */
+
+/* Temporary backend flags. */
+#define JIT_TF_USED_DEOPT       0x0001  /* Used .deopt segment. */
+
+/* JIT engine status codes for prototypes (grep "ORDER JIT_S"). */
+enum {
+  JIT_S_OK,             /* OK, code has been compiled. */
+  JIT_S_NONE,           /* Nothing compiled yet (default). */
+
+  JIT_S_OFF,            /* Compilation for this prototype disabled. */
+  JIT_S_ENGINE_OFF,     /* JIT engine is turned off. */
+  JIT_S_DELAYED,        /* Compilation delayed (recursive invocation). */
+
+  JIT_S_TOOLARGE,       /* Bytecode or machine code is too large. */
+  JIT_S_COMPILER_ERROR, /* Error from compiler frontend. */
+  JIT_S_DASM_ERROR,     /* Error from DynASM engine. */
+
+  JIT_S_MAX
+};
+
+/* Machine code trailer and mcode fragment map. */
+typedef struct jit_MCTrailer {
+  char *mcode;                  /* Pointer to next machine code block. */
+  size_t sz;                    /* Size of next machine code block. */
+} jit_MCTrailer;
+
+typedef unsigned short jit_Mfm;
+
+/* Deliberately return a void * because the trailer is not fully aligned. */
+#define JIT_MCTRAILER(mcode, sz) \
+  ((void *)(((char *)(mcode))+(sz)-sizeof(jit_MCTrailer)))
+#define JIT_MCMFM(mcode, sz) \
+  ((jit_Mfm *)(((char *)(mcode))+(sz)-sizeof(jit_MCTrailer)-sizeof(jit_Mfm)))
+
+#define JIT_MFM_MAX     0x7ff0  /* Max. mcode fragment length. */
+#define JIT_MFM_MASK    0x7fff  /* Tag mask. */
+#define JIT_MFM_MARK    0x8000  /* Deoptimized (main mfm), seek (deopt mfm). */
+#define JIT_MFM_COMBINE 0xfffd  /* Combined with prev. instruction(s). */
+#define JIT_MFM_DEAD    0xfffe  /* Dead instruction. */
+#define JIT_MFM_STOP    0xffff  /* End of map. */
+
+#define jit_mfm_ismain(mfm)             (!(*(mfm) & JIT_MFM_MARK))
+#define jit_mfm_isdeoptpc(mfm, pc)      ((mfm)[-(pc)] & JIT_MFM_MARK)
+
+/* Deoptimization hints at end of mfm. */
+#define JIT_MFM_DEOPT_PAIRS     0xfffc  /* CALL+TFORLOOP inlined (i)pairs. */
+
+/* Preallocation for the hash part of the compiler state table. */
+#define COMSTATE_PREALLOC       128
+
+/* Forward declaration for DynASM state. */
+struct dasm_State;
+
+/* Frontend wrapper. */
+typedef int (*jit_FrontWrap)(lua_State *L, Table *st);
+
+/* Global JIT state. */
+typedef struct jit_State {
+  /* Permanent backend environment: */
+  struct dasm_State *D; /* DynASM state. Keep this as the first field. */
+  void *mcodeheap;      /* Private heap to allocate executable memory from. */
+  void **jsub;          /* Addresses of JIT subroutines. */
+  void *jsubmcode;      /* Base address of JSUB mcode. */
+  size_t szjsubmcode;   /* Size of JSUB mcode. */
+  int numjsub;          /* Number of JSUBs. */
+
+  /* Temporary backend environment (valid only while running): */
+  lua_State *L;         /* Compiler thread. */
+  Table *comstate;      /* Compiler state table. */
+  Proto *pt;            /* Currently compiled prototype. */
+  const Instruction *nextins;   /* Pointer to next instruction. */
+  jit_Mfm *mfm;         /* Position in temporary mcode fragment map. */
+  int nextpc;           /* Next PC. */
+  int combine;          /* Number of following instructions to combine. */
+  unsigned int tflags;  /* Temporary flags. */
+  int dasmstatus;       /* DynASM status code. */
+
+  /* JIT engine fields: */
+  jit_FrontWrap frontwrap; /* Compiler frontend wrapper. */
+  unsigned int flags;   /* Global JIT engine flags. */
+} jit_State;
+
+
+/* --- ljit_core.c */
+
+/* Initialize and free JIT engine state. */
+LUAI_FUNC void luaJIT_initstate(lua_State *L);
+LUAI_FUNC void luaJIT_freestate(lua_State *L);
+
+/* Compile and run a function. */
+LUAI_FUNC int luaJIT_run(lua_State *L, StkId func, int nresults);
+/* Deoptimize the current instruction. Return new mcode addr to continue. */
+LUAI_FUNC void *luaJIT_deoptimize(lua_State *L);
+
+/* Find relative PC (0 based) for a bytecode pointer or a JIT mcode address. */
+LUAI_FUNC int luaJIT_findpc(Proto *pt, const Instruction *savedpc);
+/* Find mcode address for PC (1 based). */
+LUAI_FUNC void *luaJIT_findmcode(Proto *pt, int pc);
+
+
+/* --- ljit_backend.c */
+
+/* Arch string. */
+LUAI_DATA const char luaJIT_arch[];
+/* Initialize and free compiler backend. */
+LUAI_FUNC int luaJIT_initbackend(lua_State *L);
+LUAI_FUNC void luaJIT_freebackend(lua_State *L);
+/* Compiler backend. */
+LUAI_FUNC int luaJIT_backend(lua_State *L);
+/* Notify backend that the debug mode may have changed. */
+LUAI_FUNC void luaJIT_debugnotify(jit_State *J);
+
+
+/* ---- ljit_mem.c */
+
+/* Free the mcode heap. */
+LUAI_FUNC void luaJIT_freemcodeheap(jit_State *J);
+/* Free mcode. */
+LUAI_FUNC void luaJIT_freemcode(jit_State *J, void *mcode, size_t sz);
+/* Free JIT structures in function prototype. */
+LUAI_FUNC void luaJIT_freeproto(lua_State *L, Proto *pt);
+/* Link generated code. */
+LUAI_FUNC int luaJIT_link(jit_State *J, void **mcodep, size_t *szp);
+
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_backend.c b/libraries/LuaJIT-1.1.7/src/ljit_backend.c
new file mode 100644
index 0000000..698342f
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_backend.c
@@ -0,0 +1,342 @@
+/*
+** LuaJIT wrapper for architecture-specific compiler backend.
+** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+#include <math.h>
+#include <string.h>
+
+#define ljit_backend_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lobject.h"
+#include "lstate.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lgc.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "ltm.h"
+#include "lvm.h"
+#include "lopcodes.h"
+#include "ldebug.h"
+#include "lzio.h"
+
+#include "ljit.h"
+#include "ljit_hints.h"
+#include "ljit_dasm.h"
+
+/* ------------------------------------------------------------------------ */
+
+/* Get target of combined JMP op. */
+static int jit_jmp_target(jit_State *J)
+{
+  J->combine++;
+  jit_assert(GET_OPCODE(*J->nextins)==OP_JMP);
+  return J->nextpc + 1 + GETARG_sBx(*J->nextins);
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Include pre-processed architecture-specific backend. */
+#if defined(__i386) || defined(__i386__) || defined(_M_IX86)
+#ifndef LUA_NUMBER_DOUBLE
+#error "No support for other number types on x86 (yet)"
+#endif
+#include "ljit_x86.h"
+#else
+#error "No support for this architecture (yet)"
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+/* Compile instruction range. */
+static void jit_compile_irange(jit_State *J, int firstpc, int lastpc)
+{
+  J->combine = 0;
+  J->nextpc = firstpc;
+  J->nextins = J->pt->code + (firstpc-1);
+  while (J->nextpc <= lastpc) {
+    Instruction ins = *J->nextins++;
+    OpCode op = GET_OPCODE(ins);
+    int ra = GETARG_A(ins);
+    int rb = GETARG_B(ins);
+    int rc = GETARG_C(ins);
+    int rbx = GETARG_Bx(ins);
+    const TValue *combinehint;
+
+    jit_ins_start(J);
+    J->nextpc++;
+
+    combinehint = hint_get(J, COMBINE);
+    if (ttisboolean(combinehint)) {
+      if (bvalue(combinehint)) {  /* COMBINE = true: combine with next ins. */
+        if (!(J->flags & JIT_F_DEBUG))  /* But not when debugging. */
+          J->combine = 1;
+      } else {  /* COMBINE = false: dead instruction. */
+        *J->mfm++ = JIT_MFM_DEAD;
+        continue;
+      }
+    }  /* Other COMBINE hint value types are not defined (yet). */
+
+    if (J->flags & JIT_F_DEBUG_INS)
+      jit_ins_debug(J, luaG_checkopenop(ins));
+
+    switch (op) {
+    case OP_MOVE: jit_op_move(J, ra, rb); break;
+    case OP_LOADK: jit_op_loadk(J, ra, rbx); break;
+    case OP_LOADBOOL: jit_op_loadbool(J, ra, rb, rc); break;
+    case OP_LOADNIL: jit_op_loadnil(J, ra, rb); break;
+
+    case OP_GETUPVAL: jit_op_getupval(J, ra, rb); break;
+    case OP_SETUPVAL: jit_op_setupval(J, ra, rb); break;
+
+    case OP_GETGLOBAL: jit_op_getglobal(J, ra, rbx); break;
+    case OP_SETGLOBAL: jit_op_setglobal(J, ra, rbx); break;
+
+    case OP_NEWTABLE: jit_op_newtable(J, ra, rb, rc); break;
+    case OP_GETTABLE: jit_op_gettable(J, ra, rb, rc); break;
+    case OP_SETTABLE: jit_op_settable(J, ra, rb, rc); break;
+    case OP_SELF: jit_op_self(J, ra, rb, rc); break;
+    case OP_SETLIST: jit_op_setlist(J, ra, rb, rc); break;
+
+    case OP_ADD: jit_op_arith(J, ra, rb, rc, TM_ADD); break;
+    case OP_SUB: jit_op_arith(J, ra, rb, rc, TM_SUB); break;
+    case OP_MUL: jit_op_arith(J, ra, rb, rc, TM_MUL); break;
+    case OP_DIV: jit_op_arith(J, ra, rb, rc, TM_DIV); break;
+    case OP_MOD: jit_op_arith(J, ra, rb, rc, TM_MOD); break;
+    case OP_POW: jit_op_arith(J, ra, rb, rc, TM_POW); break;
+    case OP_UNM: jit_op_arith(J, ra, rb, rb, TM_UNM); break;  /* rc unused. */
+
+    case OP_LEN: jit_op_len(J, ra, rb); break;
+    case OP_NOT: jit_op_not(J, ra, rb); break;
+
+    case OP_CONCAT: jit_op_concat(J, ra, rb, rc); break;
+
+    case OP_EQ: jit_op_eq(J, ra, rb, rc); break;
+    case OP_LT: jit_op_arith(J, ra, rb, rc, TM_LT); break;
+    case OP_LE: jit_op_arith(J, ra, rb, rc, TM_LE); break;
+
+    case OP_TEST: jit_op_test(J, rc, ra, ra); break;
+    case OP_TESTSET: jit_op_test(J, rc, ra, rb); break;
+
+    case OP_JMP: jit_op_jmp(J, J->nextpc + rbx-MAXARG_sBx); break;
+
+    case OP_CALL: jit_op_call(J, ra, rb-1, rc-1); break;
+    case OP_TAILCALL: jit_op_tailcall(J, ra, rb-1); break;
+    case OP_RETURN: jit_op_return(J, ra, rb-1); break;
+
+    case OP_FORLOOP: jit_op_forloop(J, ra, J->nextpc + rbx-MAXARG_sBx); break;
+    case OP_FORPREP: jit_op_forprep(J, ra, J->nextpc + rbx-MAXARG_sBx); break;
+
+    case OP_TFORLOOP: jit_op_tforloop(J, ra, rc); break;
+
+    case OP_CLOSE: jit_op_close(J, ra); break;
+    case OP_CLOSURE: jit_op_closure(J, ra, rbx); break;
+
+    case OP_VARARG: jit_op_vararg(J, ra, rb-1); break;
+
+    default: jit_assert(0); break;
+    }
+
+    /* Convention: all opcodes start and end with the .code section. */
+    if (dasm_checkstep(Dst, DASM_SECTION_CODE)) { J->nextpc--; return; }
+
+    *J->mfm++ = 0;  /* Placeholder mfm entry. Replaced later. */
+    if (J->combine > 0) {  /* Combine next J->combine ins with prev ins. */
+      J->nextpc += J->combine;
+      J->nextins += J->combine;
+      do { *J->mfm++ = JIT_MFM_COMBINE; } while (--J->combine);
+    }
+  }
+}
+
+/* Merge temporary mfm (forward) with PC labels to inverse mfm in mcode. */
+static void jit_mfm_merge(jit_State *J, jit_Mfm *from, jit_Mfm *to, int maxpc)
+{
+  int pc = 1, ofs = 0;
+  for (;;) {
+    int m = *from++;
+    if (m & JIT_MFM_MARK) {
+      switch (m) {
+      default: pc = m ^ JIT_MFM_MARK; break;
+      case JIT_MFM_COMBINE: case JIT_MFM_DEAD: break;
+      case JIT_MFM_STOP: return;
+      }
+    } else {
+      int idx, nofs;
+      for (idx = 0; from[idx] == JIT_MFM_COMBINE; idx++) ;
+      idx += pc;
+      if (idx == J->nextpc) idx = maxpc + 1;
+      nofs = dasm_getpclabel(Dst, idx);
+      m = nofs - ofs;
+      ofs = nofs;
+      jit_assert(nofs >= 0 && m >= 0 && m < JIT_MFM_MAX);
+    }
+    pc++;
+    *to-- = m;
+  }
+}
+
+/* Compile function prototype. */
+static int jit_compile_proto(jit_State *J, Table *deopt)
+{
+  jit_Mfm *tempmfm;
+  void *mcode;
+  size_t sz;
+  int firstpc = 0, maxpc = J->pt->sizecode;
+  int deoptidx = 1;
+  int status;
+  /* (Ab)use the global string concatenation buffer for the temporary mfm. */
+  /* Caveat: the GC must not be run while the backend is active. */
+  tempmfm = (jit_Mfm *)luaZ_openspace(J->L, &G(J->L)->buff,
+                                      (1+maxpc+1+1+1)*sizeof(jit_Mfm));
+nextdeopt:
+  J->mfm = tempmfm;
+  J->tflags = 0;
+  /* Setup DynASM. */
+  dasm_growpc(Dst, 1+maxpc+2);  /* See jit_ins_last(). */
+  dasm_setup(Dst, jit_actionlist);
+  if (deopt) {  /* Partial deoptimization. */
+    /* TODO: check deopt chain length? problem: pairs TFOR_CTL migration. */
+    int pc, lastpc;
+    lua_Number n;
+    const TValue *obj = luaH_getnum(deopt, deoptidx++);
+    if (ttisnil(obj) && deoptidx != 2) return JIT_S_OK;
+    if (!ttisnumber(obj)) return JIT_S_COMPILER_ERROR;
+    n = nvalue(obj);
+    lua_number2int(pc, n);
+    firstpc = JIT_IH_IDX(pc);
+    lastpc = firstpc + JIT_IH_LIB(pc);
+    if (firstpc < 1 || firstpc > maxpc || lastpc > maxpc ||
+        J->pt->jit_szmcode == 0)
+      return JIT_S_COMPILER_ERROR;
+    *J->mfm++ = JIT_MFM_MARK+firstpc;  /* Seek to firstpc. */
+    jit_compile_irange(J, firstpc, lastpc);
+    jit_assert(J->nextpc == lastpc+1);  /* Problem with combined ins? */
+    if (J->nextpc <= maxpc) jit_ins_chainto(J, J->nextpc);
+    *J->mfm++ = JIT_MFM_MARK+maxpc+1;  /* Seek to .deopt/.tail. */
+    for (pc = 1; pc <= maxpc; pc++)
+      if (dasm_getpclabel(Dst, pc) == -1) {  /* Undefind label referenced? */
+        jit_ins_setpc(J, pc, luaJIT_findmcode(J->pt, pc));  /* => Old mcode. */
+      }
+  } else {  /* Full compile. */
+    *J->mfm++ = 0;  /* Placeholder mfm entry for prologue. */
+    jit_prologue(J);
+    jit_compile_irange(J, 1, maxpc);
+  }
+  *J->mfm++ = 0;  /* Placeholder mfm entry for .deopt/.tail. */
+  *J->mfm = JIT_MFM_STOP;
+  jit_ins_last(J, maxpc, (char *)J->mfm - (char *)tempmfm);
+
+  status = luaJIT_link(J, &mcode, &sz);
+  if (status != JIT_S_OK)
+    return status;
+
+  jit_mfm_merge(J, tempmfm, JIT_MCMFM(mcode, sz), maxpc);
+
+  if (deopt) {
+    jit_MCTrailer tr;
+    /* Patch first instruction to jump to the deoptimized code. */
+    jit_patch_jmp(J, luaJIT_findmcode(J->pt, firstpc), mcode);
+    /* Mark instruction as deoptimized in main mfm. */
+    JIT_MCMFM(J->pt->jit_mcode, J->pt->jit_szmcode)[-firstpc] |= JIT_MFM_MARK;
+    /* Chain deopt mcode block between main mfm and existing mfms. */
+    memcpy(JIT_MCTRAILER(mcode, sz),
+           JIT_MCTRAILER(J->pt->jit_mcode, J->pt->jit_szmcode),
+           sizeof(jit_MCTrailer));
+    tr.mcode = (char *)mcode;
+    tr.sz = sz;
+    memcpy(JIT_MCTRAILER(J->pt->jit_mcode, J->pt->jit_szmcode), (void *)&tr,
+           sizeof(jit_MCTrailer));
+    goto nextdeopt;
+  }
+
+  if (J->pt->jit_szmcode != 0) {  /* Full recompile? */
+    jit_MCTrailer tr;
+    /* Patch old mcode entry so other closures get the new callgate. */
+    jit_patch_jmp(J, J->pt->jit_mcode, J->jsub[JSUB_GATE_JL]);
+    /* Chain old main mfm after new main mfm. */
+    tr.mcode = (char *)J->pt->jit_mcode;
+    tr.sz = J->pt->jit_szmcode;
+    memcpy(JIT_MCTRAILER(mcode, sz), (void *)&tr, sizeof(jit_MCTrailer));
+  }
+  /* Set new main mcode block. */
+  J->pt->jit_mcode = mcode;
+  J->pt->jit_szmcode = sz;
+  return JIT_S_OK;
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Compiler backend. */
+int luaJIT_backend(lua_State *L)
+{
+  jit_State *J = G(L)->jit_state;
+  const TValue *cl;
+  int status = JIT_S_COMPILER_ERROR;
+  lua_lock(L);
+  /* Remember compiler state table. */
+  jit_assert(L->top > L->base && ttistable(L->top-1));
+  J->comstate = hvalue(L->top-1);
+  /* Fetch prototoype. Better check this in case some handler screwed up. */
+  cl = luaH_getstr(J->comstate, luaS_newliteral(L, "func"));
+  if (isLfunction(cl)) {
+    J->pt = clvalue(cl)->l.p;
+    if (J->pt->sizecode > LUAJIT_LIM_BYTECODE) {  /* Hard backend limit. */
+      status = JIT_S_TOOLARGE;
+    } else {
+      const TValue *obj = luaH_getstr(J->comstate,
+                                      luaS_newliteral(J->L, "deopt"));
+      status = jit_compile_proto(J, ttistable(obj) ? hvalue(obj) : (Table *)0);
+    }
+  }
+  lua_unlock(L);
+  J->comstate = NULL;  /* Just in case. */
+  J->pt = NULL;
+  if (status == JIT_S_OK) {
+    return 0;
+  } else {
+    if (status == JIT_S_DASM_ERROR) {
+      lua_pushinteger(L, J->nextpc);
+      lua_setfield(L, 1, "dasm_pc");
+      lua_pushinteger(L, J->dasmstatus);
+      lua_setfield(L, 1, "dasm_err");
+    }
+    lua_pushinteger(L, status);
+    return 1;
+  }
+}
+
+/* Initialize compiler backend. */
+int luaJIT_initbackend(lua_State *L)
+{
+  jit_State *J = G(L)->jit_state;
+  J->L = L;
+  J->pt = NULL;  /* Not in use. */
+  J->D = NULL;
+  J->mcodeheap = NULL;
+  J->jsubmcode = NULL;
+  J->szjsubmcode = 0;
+  J->numjsub = JSUB__MAX;
+  J->jsub = luaM_newvector(J->L, JSUB__MAX, void *);
+  memset((void *)J->jsub, 0, JSUB__MAX*sizeof(void *));  /* Just in case. */
+  dasm_init(Dst, DASM_MAXSECTION);
+  dasm_setupglobal(Dst, J->jsub, JSUB__MAX);
+  return jit_compile_jsub(J);
+}
+
+/* Free compiler backend. */
+void luaJIT_freebackend(lua_State *L)
+{
+  jit_State *J = G(L)->jit_state;
+  J->L = L;
+  if (J->jsub) luaM_freearray(L, J->jsub, JSUB__MAX, void *);
+  luaJIT_freemcodeheap(J);  /* Frees JSUB mcode, too. */
+  dasm_free(Dst);
+}
+
+/* ------------------------------------------------------------------------ */
+
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_core.c b/libraries/LuaJIT-1.1.7/src/ljit_core.c
new file mode 100644
index 0000000..f7385f2
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_core.c
@@ -0,0 +1,385 @@
+/*
+** Interface to JIT engine.
+** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+#define ljit_core_c
+#define LUA_CORE
+
+#include <string.h>
+
+#include "lua.h"
+
+#include "lobject.h"
+#include "lstate.h"
+#include "ldo.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "ldebug.h"
+#include "lopcodes.h"
+
+#include "ljit.h"
+#include "ljit_hints.h"
+#include "luajit.h"
+
+const char luajit_ident[] =
+  "$LuaJIT: " LUAJIT_VERSION " " LUAJIT_COPYRIGHT " " LUAJIT_URL " $\n";
+
+/* ------------------------------------------------------------------------ */
+
+/* Initialize JIT engine state. */
+void luaJIT_initstate(lua_State *L)
+{
+  jit_State *J = luaM_new(L, jit_State);
+  G(L)->jit_state = J;
+  /* Clear JIT engine fields. */
+  J->frontwrap = NULL;  /* Filled in by ljitlib before enabling the engine. */
+  J->flags = 0;  /* Disable the JIT engine by default. */
+  /* Try to initialize the backend. */
+  if (luaJIT_initbackend(L) != JIT_S_OK)
+    J->flags = JIT_F_INIT_FAILED;
+  J->L = NULL;  /* No compiler thread allocated, yet. */
+}
+
+/* Free JIT engine state. */
+void luaJIT_freestate(lua_State *L)
+{
+  jit_State *J = G(L)->jit_state;
+  if (J == NULL) return;
+  luaJIT_freebackend(L);
+  luaM_free(L, J);
+  G(L)->jit_state = NULL;
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Find relative PC (0 based) for a bytecode pointer or a JIT mcode address. */
+int luaJIT_findpc(Proto *pt, const Instruction *savedpc)
+{
+  ptrdiff_t pcdiff = savedpc - pt->code;
+  if (pcdiff >= 0 && pcdiff <= pt->sizecode) { /* Bytecode pointer? */
+    return (int)pcdiff-1;
+  } else {  /* Else translate JIT mcode address to PC. */
+    char *addr = (char *)savedpc;
+    jit_MCTrailer tr;
+    tr.mcode = (char *)pt->jit_mcode;
+    tr.sz = pt->jit_szmcode;
+    /* Follow trailer chain until addr is part of an mcode block. */
+    while (!((size_t)(addr - tr.mcode) < tr.sz)) {
+      memcpy((void *)&tr, JIT_MCTRAILER(tr.mcode, tr.sz),
+             sizeof(jit_MCTrailer));
+      if (tr.mcode == NULL) return -1;  /* Not in chain. */
+    }
+    {
+      jit_Mfm *mfm = JIT_MCMFM(tr.mcode, tr.sz);
+      int ofs = (int)(addr - tr.mcode);
+      int isdeopt = !jit_mfm_ismain(mfm);
+      int pc = 0;  /* Prologue fragment is at start of main mfm. */
+      while (pc <= pt->sizecode) {
+        int m = *mfm--;
+        switch (m) {
+        default:
+          if (m & JIT_MFM_MARK) {
+            m ^= JIT_MFM_MARK;
+            if (isdeopt) { pc = m; continue; }  /* Seek. */
+          }
+          ofs -= m;
+          if (ofs <= 0) return pc-1;  /* Found! */
+        case JIT_MFM_COMBINE:
+        case JIT_MFM_DEAD:
+          pc++;
+          break;
+        case JIT_MFM_STOP:
+          jit_assert(0);  /* Premature STOP found. */
+          return -1;
+        }
+      }
+      jit_assert(0);  /* Address is in .tail. */
+      return -1;
+    }
+  }
+}
+
+/* Lookup mcode address for PC (1 based) in mfm. */
+static void *jit_mfmlookup(jit_Mfm *mfm, char *addr, int mpc)
+{
+  int isdeopt = !jit_mfm_ismain(mfm);
+  int pc = 0;  /* Prologue fragment is at start of main mfm. */
+  while (pc != mpc) {
+    int m = *mfm--;
+    switch (m) {
+    default:
+      if (m & JIT_MFM_MARK) {
+        m ^= JIT_MFM_MARK;
+        if (isdeopt) { pc = m; continue; }  /* Seek. */
+      }
+      addr += m;
+    case JIT_MFM_COMBINE:
+    case JIT_MFM_DEAD:
+      pc++;
+      break;
+    case JIT_MFM_STOP:
+      return NULL;
+    }
+  }
+  return (void *)addr;
+}
+
+/* Find mcode address for PC (1 based). */
+void *luaJIT_findmcode(Proto *pt, int pc)
+{
+  void *addr = NULL;
+  jit_Mfm *mfm;
+  jit_MCTrailer tr;
+  tr.mcode = (char *)pt->jit_mcode;
+  tr.sz = pt->jit_szmcode;
+  mfm = JIT_MCMFM(tr.mcode, tr.sz);
+  jit_assert(pc >= 1 && pc <= pt->sizecode);
+  while (mfm[-pc] == JIT_MFM_COMBINE) pc--;
+  while (mfm[-pc] == JIT_MFM_DEAD) pc++;
+  jit_assert(pc >= 1 && mfm[-pc] < (JIT_MFM_MARK|JIT_MFM_MAX)); /* Valid? */
+  if (jit_mfm_isdeoptpc(mfm, pc)) {  /* Deoptimized instruction. */
+    do {  /* Search through deopt mfm chain. */
+      memcpy((void *)&tr, JIT_MCTRAILER(tr.mcode, tr.sz),
+             sizeof(jit_MCTrailer));
+      if (tr.mcode == NULL) break;  /* Deopt ins missing in chain. */
+      mfm = JIT_MCMFM(tr.mcode, tr.sz);
+      if (jit_mfm_ismain(mfm)) break;  /* Old main mfm stops search, too. */
+      addr = jit_mfmlookup(mfm, tr.mcode, pc);
+    } while (addr == NULL);
+  } else { /* Not deoptimized. Lookup in main mfm. */
+    addr = jit_mfmlookup(mfm, tr.mcode, pc);
+  }
+  jit_assert(addr != NULL);  /* Corrupt mfm chain. */
+  return addr;
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Compile a prototype. */
+/* Note: func pointer may be invalidated because of stack reallocation. */
+static int jit_compile(lua_State *L, StkId func, Table *st, int force)
+{
+  jit_State *J = G(L)->jit_state;
+  Closure *cl = clvalue(func);
+  Proto *pt = cl->l.p;
+  int status;
+
+  /* Check if JIT engine is enabled and prevent recursive invocation. */
+  if ((J->flags & JIT_F_INIT_FAILED) ||
+      (!force && !(J->flags & JIT_F_ON)) ||
+      !J->frontwrap) {
+    status = JIT_S_ENGINE_OFF;
+  } else if (J->flags & JIT_F_COMPILING) {
+    status = JIT_S_DELAYED;
+  } else if (pt->jit_szmcode != 0 && force < 2) {  /* Prevent recompile. */
+    /* TODO: Allow recompiles? Use case? Extra flag for jit.compile()? */
+    status = JIT_S_OK;
+  } else {
+    setclvalue(L, luaH_setstr(L, st, luaS_newliteral(L, "func")), cl);
+    /* Call frontend wrapper. */
+    J->flags |= JIT_F_COMPILING;
+    lua_unlock(L);
+    status = J->frontwrap(L, st);
+    lua_lock(L);
+    J->flags &= ~JIT_F_COMPILING;
+  }
+
+  /* Better sanity check what the frontend returns. */
+  if ((status == JIT_S_OK && pt->jit_szmcode == 0) || status == JIT_S_NONE)
+    status = JIT_S_COMPILER_ERROR;
+
+  /* Update closure callgate and prototype status. */
+  cl->l.jit_gate = (status == JIT_S_OK) ? (lua_CFunction)pt->jit_mcode :
+                                          G(L)->jit_gateJL;
+  pt->jit_status = status;
+  return status;
+}
+
+/* Create the state table and copy the arguments. */
+static Table *jit_createstate(lua_State *L, StkId arg, int nargs)
+{
+  Table *st = luaH_new(L, nargs, COMSTATE_PREALLOC);
+  int i;
+  for (i = 0; i < nargs; i++)
+    setobj2t(L, luaH_setnum(L, st, i+1), arg+i);
+  return st;
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Compile and run a function. To be used by luaD_precall() only. */
+int luaJIT_run(lua_State *L, StkId func, int nresults)
+{
+  ptrdiff_t funcr = savestack(L, func);
+  Table *st = jit_createstate(L, func+1, L->top-(func+1));
+  int status = jit_compile(L, func, st, 0);  /* Compile function. */
+  func = restorestack(L, funcr);
+
+  /* Run the compiled function on success. Fallback to bytecode on failure. */
+  if (status == JIT_S_OK)
+    return G(L)->jit_gateLJ(L, func, nresults);
+  else
+    return luaD_precall(L, func, nresults);
+  /* Note: We are called from luaD_precall and we call it again. */
+  /* So jit_compile makes sure pt->jit_status != JIT_S_NONE. */
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* No more than two ranges for a single deoptimization right now. */
+#define DEOPTRANGE_ALLOC        2
+
+/* Find PC range of combined instructions and return a range hint. */
+static int combinedrange(jit_Mfm *mfm, int pc)
+{
+  int lastpc = pc;
+  while (mfm[-pc] == JIT_MFM_COMBINE) pc--;  /* 1st comb. ins. */
+  while (mfm[-(lastpc+1)] == JIT_MFM_COMBINE) lastpc++;  /* Last comb. ins. */
+  return JIT_IH_MKIDX(lastpc-pc, pc);  /* (#ins-1, pc) in hint format. */
+}
+
+/* Process deoptimization hints for the given PC range. */
+static int deopthints(Proto *pt, jit_Mfm *dh, TValue *dhint, int pcrange)
+{
+  int m;
+  setnvalue(dhint++, (lua_Number)pcrange);
+  while ((m = *dh--) != JIT_MFM_STOP) {
+    if ((unsigned int)(m - JIT_IH_IDX(pcrange)) <=
+        (unsigned int)JIT_IH_LIB(pcrange)) {
+      switch (*dh--) {
+      case JIT_MFM_DEOPT_PAIRS:  /* CALL [i]pairs(): deopt TFORLOOP+JMP. */
+        if (GET_OPCODE(pt->code[m+1-1]) == OP_JMP) {
+          int tfpc = m+2 + GETARG_sBx(pt->code[m+1-1]);
+          if ((unsigned)tfpc < (unsigned)pt->sizecode &&
+              GET_OPCODE(pt->code[tfpc-1]) == OP_TFORLOOP) {
+            setnvalue(dhint++, (lua_Number)JIT_IH_MKIDX(1, tfpc));
+            break;
+          }
+        }
+        return 1;  /* Bad hint. */
+      default:
+        return 1;  /* Cannot tolerate unknown deoptimization hints. */
+      }
+    }
+  }
+  return 0;  /* Ok. */
+}
+
+/* Deoptimize the current instruction. Return new mcode addr to continue. */
+void *luaJIT_deoptimize(lua_State *L)
+{
+  StkId func = L->ci->func;
+  Proto *pt = clvalue(func)->l.p;
+  int pc = luaJIT_findpc(pt, L->savedpc)+1;  /* Get prev. PC (1 based). */
+  jit_Mfm *mfm = JIT_MCMFM(pt->jit_mcode, pt->jit_szmcode);
+  int pcrange = combinedrange(mfm, pc);
+  if (!jit_mfm_isdeoptpc(mfm, JIT_IH_IDX(pcrange))) {  /* Not deopt. yet? */
+    Table *st = jit_createstate(L, NULL, 0);  /* Don't know original args. */
+    Table *deopt = luaH_new(L, DEOPTRANGE_ALLOC, 0);
+    sethvalue(L, luaH_setstr(L, st, luaS_newliteral(L, "deopt")), deopt);
+    if (deopthints(pt, mfm-(pt->sizecode+2), deopt->array, pcrange) ||
+        jit_compile(L, func, st, 2) != JIT_S_OK)
+      luaG_runerror(L, "deoptimization failed");
+  }
+  return luaJIT_findmcode(pt, pc);
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* API function: Compile a Lua function. Pass arguments as hints. */
+LUA_API int luaJIT_compile(lua_State *L, int nargs)
+{
+  StkId func;
+  Table *st;
+  int status;
+  lua_lock(L);
+  api_check(L, (nargs+1) <= (L->top - L->base));
+  func = L->top - (nargs+1);
+  st = jit_createstate(L, func+1, nargs);
+  status = isLfunction(func) ? jit_compile(L, func, st, 1) : -1;
+  lua_unlock(L);
+  return status;
+}
+
+/* Recursively set the mode for all subroutines. */
+static void rec_setmode(Proto *pt, int on)
+{
+  int i;
+  for (i = 0; i < pt->sizep; i++) {
+    Proto *pti = pt->p[i];
+    pti->jit_status = on ? (pti->jit_szmcode?JIT_S_OK:JIT_S_NONE) : JIT_S_OFF;
+    rec_setmode(pti, on);  /* Recurse into proto. */
+  }
+}
+
+/* API function: Set the JIT mode for the whole engine or a function+subs. */
+LUA_API int luaJIT_setmode(lua_State *L, int idx, int mode)
+{
+  jit_State *J = G(L)->jit_state;
+  int mm = mode & LUAJIT_MODE_MASK;
+  if (J->flags & JIT_F_INIT_FAILED) return -1;  /* Init failed. */
+  switch (mm) {
+  case LUAJIT_MODE_ENGINE:              /* Set mode for JIT engine. */
+    if (mode & LUAJIT_MODE_ON)
+      J->flags |= JIT_F_ON;
+    else
+      J->flags &= ~JIT_F_ON;
+    break;
+  case LUAJIT_MODE_DEBUG: {             /* Set debug mode. */
+    int dbg;
+    switch (idx) {
+    case 0: dbg = 0; break;
+    case 1: dbg = JIT_F_DEBUG_CALL; break;
+    case 2: default: dbg = JIT_F_DEBUG_CALL | JIT_F_DEBUG_INS; break;
+    }
+    J->flags = (J->flags & ~JIT_F_DEBUG) | dbg;
+    luaJIT_debugnotify(J);
+    break;
+  }
+  case LUAJIT_MODE_FUNC:                /* Set mode for function. */
+  case LUAJIT_MODE_ALLFUNC:             /* Set mode for function + subfuncs. */
+  case LUAJIT_MODE_ALLSUBFUNC: {        /* Set mode for subfunctions. */
+    StkId func;
+    lua_lock(L);
+    func = idx == 0 ? (L->ci-1)->func :
+           (idx > 0 ? L->base + (idx-1) : L->top + idx);
+    if (isLfunction(func)) {
+      Closure *cl = clvalue(func);
+      Proto *pt = cl->l.p;
+      if (mm != LUAJIT_MODE_ALLSUBFUNC) {
+        if (mode & LUAJIT_MODE_ON) {
+          if (pt->jit_szmcode) {  /* Already compiled? */
+            cl->l.jit_gate = (lua_CFunction)pt->jit_mcode;  /* Reenable. */
+            pt->jit_status = JIT_S_OK;
+          } else {
+            pt->jit_status = JIT_S_NONE;  /* (Re-)enable proto compilation */
+          }
+        } else {
+          cl->l.jit_gate = G(L)->jit_gateJL;  /* Default callgate. */
+          pt->jit_status = JIT_S_OFF;  /* Disable proto compilation. */
+          /* Note: compiled code must be retained for suspended threads. */
+        }
+      }
+      if (mm != LUAJIT_MODE_FUNC)
+        rec_setmode(pt, mode & LUAJIT_MODE_ON);
+      lua_unlock(L);
+    } else {
+      lua_unlock(L);
+      return 0;  /* Failed. */
+    }
+    break;
+  }
+  default:
+    return 0;  /* Failed. */
+  }
+  return 1;  /* OK. */
+}
+
+/* Enforce (dynamic) linker error for version mismatches. See lua.c. */
+LUA_API void LUAJIT_VERSION_SYM(void)
+{
+}
+
+/* ------------------------------------------------------------------------ */
+
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_dasm.c b/libraries/LuaJIT-1.1.7/src/ljit_dasm.c
new file mode 100644
index 0000000..c2d44ee
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_dasm.c
@@ -0,0 +1,38 @@
+/*
+** Wrapper for architecture-specific DynASM encoder.
+** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+#define ljit_dasm_c
+#define LUA_CORE
+
+
+#include "lua.h"
+
+#include "ljit.h"
+#include "ljit_dasm.h"
+#include "lmem.h"
+
+
+/* Glue macros for DynASM memory allocation. */
+#define DASM_M_GROW(J, t, p, sz, need) \
+  do { \
+    size_t _sz = (sz), _need = (need); \
+    if (_sz < _need) { \
+      if (_sz < 16) _sz = 16; \
+      while (_sz < _need) _sz += _sz; \
+      (p) = (t *)luaM_realloc_(J->L, (p), (sz), _sz); \
+      (sz) = _sz; \
+    } \
+  } while(0)
+
+#define DASM_M_FREE(J, p, sz)   luaM_freemem(J->L, p, sz)
+
+/* Embed architecture-specific DynASM encoder. */
+#if defined(__i386) || defined(__i386__) || defined(_M_IX86)
+#include "dasm_x86.h"
+#else
+#error "No support for this architecture (yet)"
+#endif
+
+
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_dasm.h b/libraries/LuaJIT-1.1.7/src/ljit_dasm.h
new file mode 100644
index 0000000..0a9dd5d
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_dasm.h
@@ -0,0 +1,19 @@
+/*
+** Interface to DynASM engine.
+** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+#ifndef ljit_dasm_h
+#define ljit_dasm_h
+
+#include "ljit.h"
+
+/* DynASM glue definitions. */
+#define Dst             J
+#define Dst_DECL        jit_State *J
+#define Dst_REF         (J->D)
+#define DASM_FDEF       LUAI_FUNC
+
+#include "dasm_proto.h"
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_hints.h b/libraries/LuaJIT-1.1.7/src/ljit_hints.h
new file mode 100644
index 0000000..23743bc
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_hints.h
@@ -0,0 +1,137 @@
+/*
+** Hints for the JIT compiler backend.
+** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+#ifdef STRING_HINTS
+#define HH(x, name)             #name
+#define HH_START(x)             static const char *const hints_##x [] = {
+#define HH_END(x)               NULL }
+#else
+#define HH(x, name)             JIT_##x##_##name
+#define HH_START(x)             enum { JIT_##x##_NONE,
+#define HH_END(x)               JIT_##x##_MAX }
+
+/* Macros to access hints. */
+#define JIT_H2NUM(x)            ((x) << 16)
+
+#define fhint_get(J, hh) \
+  (luaH_getnum(J->comstate, JIT_H2NUM(JIT_FH_##hh)))
+#define fhint_isset(J, hh)      (!ttisnil(fhint_get(J, hh)))
+
+#define hint_getpc(J, hh, pc) \
+  (luaH_getnum(J->comstate, (pc)+JIT_H2NUM(JIT_H_##hh)))
+#define hint_get(J, hh)         hint_getpc(J, hh, J->nextpc-1)
+#define hint_issetpc(J, hh, pc) (!ttisnil(hint_getpc(J, hh, pc)))
+#define hint_isset(J, hh)       hint_issetpc(J, hh, J->nextpc-1)
+
+#endif
+
+/* Hints for functions. */
+HH_START(FH)
+  HH(FH, NOCLOSE),              /* No luaF_close() needed. */
+HH_END(FH);
+
+/* Hints for individual bytecode instruction. */
+HH_START(H)
+  HH(H, COMBINE),       /* Combine/dead instruction: true/false. */
+  HH(H, FOR_STEP_K),    /* FORPREP/FORLOOP step is const: step. */
+  HH(H, TYPE),          /* Type hint: typed object. */
+  HH(H, TYPEKEY),       /* Type hint for keys: typed object. */
+  HH(H, INLINE),        /* Inline function call: internal index. */
+HH_END(H);
+
+#undef HH
+#undef HH_START
+#undef HH_END
+
+
+/* Avoid multiple inclusion for the following. */
+#ifndef ljit_hints_h
+#define ljit_hints_h
+
+/* Index numbers for inlining C functions. */
+/* CHECK: the index numbers must match with jit.opt_lib. */
+
+#define JIT_IH_LIB(x)           ((x) >> 16)
+#define JIT_IH_IDX(x)           ((x) & 0xffff)
+#define JIT_IH_MKIDX(l, f)      (((l) << 16) | (f))
+
+/* Library index numbers. */
+enum {
+  JIT_IHLIB_INTERNAL,
+  JIT_IHLIB_BASE,
+  JIT_IHLIB_COROUTINE,
+  JIT_IHLIB_STRING,
+  JIT_IHLIB_TABLE,
+  JIT_IHLIB_MATH,
+  JIT_IHLIB__LAST
+};
+
+/* Internal functions. */
+enum {
+  JIT_IH_INTERNAL_RECURSIVE,  /* Recursive call. */
+  JIT_IH_INTERNAL__LAST
+};
+
+/* Base library functions. */
+enum {
+  JIT_IH_BASE_PAIRS,
+  JIT_IH_BASE_IPAIRS,
+  JIT_IH_BASE__LAST
+};
+
+/* Coroutine library functions. */
+enum {
+  JIT_IH_COROUTINE_YIELD,
+  JIT_IH_COROUTINE_RESUME,
+  JIT_IH_COROUTINE__LAST
+};
+
+/* String library functions. */
+enum {
+  JIT_IH_STRING_LEN,
+  JIT_IH_STRING_SUB,
+  JIT_IH_STRING_CHAR,
+  JIT_IH_STRING__LAST
+};
+
+/* Table library functions. */
+enum {
+  JIT_IH_TABLE_INSERT,
+  JIT_IH_TABLE_REMOVE,
+  JIT_IH_TABLE_GETN,
+  JIT_IH_TABLE__LAST
+};
+
+/* Math library functions. */
+/* CHECK: order must match with function table for jit_inline_math(). */
+enum {
+  /* 1 arg, 1 result. */
+  /* Partially inlined. Call C function from libm: */
+  JIT_IH_MATH_LOG,
+  JIT_IH_MATH_LOG10,
+  JIT_IH_MATH_EXP,
+  JIT_IH_MATH_SINH,
+  JIT_IH_MATH_COSH,
+  JIT_IH_MATH_TANH,
+  JIT_IH_MATH_ASIN,
+  JIT_IH_MATH_ACOS,
+  JIT_IH_MATH_ATAN,
+  /* Fully inlined: */
+  JIT_IH_MATH_SIN,
+  JIT_IH_MATH_COS,
+  JIT_IH_MATH_TAN,
+  JIT_IH_MATH_CEIL,
+  JIT_IH_MATH_FLOOR,
+  JIT_IH_MATH_ABS,
+  JIT_IH_MATH_SQRT,
+  /* 2 args, 1 result. */
+  JIT_IH_MATH_FMOD,
+  JIT_IH_MATH_ATAN2,
+  JIT_IH_MATH__LAST
+};
+
+#define JIT_IH_MATH__21 JIT_IH_MATH_FMOD
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_mem.c b/libraries/LuaJIT-1.1.7/src/ljit_mem.c
new file mode 100644
index 0000000..73ade7f
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_mem.c
@@ -0,0 +1,405 @@
+/*
+** Memory management for machine code.
+** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+#define ljit_mem_c
+#define LUA_CORE
+
+#include <string.h>
+
+#include "lua.h"
+
+#include "lmem.h"
+#include "ldo.h"
+#include "ljit.h"
+#include "ljit_dasm.h"
+
+
+/*
+** Define this if you want to run LuaJIT with valgrind. You will get random
+** errors if you don't. And these errors are usually not caught by valgrind!
+**
+** This macro evaluates to a no-op if not run with valgrind. I.e. you can
+** use the same binary for regular runs, too (without a performance loss).
+*/
+#ifdef USE_VALGRIND
+#include <valgrind/valgrind.h>
+#define MCH_INVALIDATE(ptr, addr) VALGRIND_DISCARD_TRANSLATIONS(ptr, addr)
+#else
+#define MCH_INVALIDATE(ptr, addr) ((void)0)
+#endif
+
+
+/* ------------------------------------------------------------------------ */
+
+#if defined(_WIN32) && !defined(LUAJIT_MCH_USE_MALLOC)
+
+/* Use a private heap with executable memory for Windows. */
+#include <windows.h>
+
+/* No need for serialization. There's already a lock per Lua universe. */
+#ifdef HEAP_CREATE_ENABLE_EXECUTE
+#define MCH_HCFLAGS     (HEAP_NO_SERIALIZE|HEAP_CREATE_ENABLE_EXECUTE)
+#else
+#define MCH_HCFLAGS     (HEAP_NO_SERIALIZE|0x00040000)
+#endif
+
+/* Free the whole mcode heap. */
+void luaJIT_freemcodeheap(jit_State *J)
+{
+  if (J->mcodeheap) HeapDestroy((HANDLE)J->mcodeheap);
+}
+
+/* Allocate a code block from the mcode heap. */
+static void *mcode_alloc(jit_State *J, size_t sz)
+{
+  void *ptr;
+  if (J->mcodeheap == NULL) {
+    J->mcodeheap = (void *)HeapCreate(MCH_HCFLAGS, 0, 0);
+    if (J->mcodeheap == NULL) luaD_throw(J->L, LUA_ERRMEM);
+  }
+  ptr = HeapAlloc(J->mcodeheap, 0, (sz));
+  if (ptr == NULL) luaD_throw(J->L, LUA_ERRMEM);
+  return ptr;
+}
+
+#define mcode_free(L, J, p, sz) HeapFree(J->mcodeheap, 0, (p))
+
+/* ------------------------------------------------------------------------ */
+
+#elif defined(LUA_USE_POSIX) && !defined(LUAJIT_MCH_USE_MALLOC)
+
+/*
+** Allocate EXECUTABLE memory with mmap() on POSIX systems.
+**
+** There is no standard way to reuse malloc(). So this is a very small,
+** but also very naive memory allocator. This should be ok, because:
+**
+** 1. Most apps only allocate mcode while running and free all on exit.
+**
+** 2. Some apps regularly load/unload a bunch of modules ("stages").
+**    Allocs/frees come in groups, so coalescing should work fine.
+**
+** If your app differs, then please elaborate and/or supply code.
+** And no -- including a full blown malloc is NOT an option.
+**
+** Caveat: the mmap()'ed heaps are not freed until exit.
+** This shouldn't be too difficult to add, but I didn't bother.
+*/
+
+#include <sys/types.h>
+#include <sys/mman.h>
+
+/* TODO: move this to luaconf.h */
+#define LUAJIT_MCH_CHUNKSIZE            (1<<17)  /* 128K */
+
+#if defined(MAP_ANONYMOUS)
+#define MCH_MMFLAGS     (MAP_PRIVATE|MAP_ANONYMOUS)
+#elif defined(MAP_ANON)
+#define MCH_MMFLAGS     (MAP_PRIVATE|MAP_ANON)
+#else
+/* I'm too lazy to add /dev/zero support for ancient systems. */
+#error "Your OS has no (easy) support for anonymous mmap(). Please upgrade."
+#endif
+
+/* Chunk header. Used for the free chunk list / heap headers. */
+typedef struct MCodeHead {
+  struct MCodeHead *next;       /* Next free chunk / 1st head: first free. */
+  struct MCodeHead *prev;       /* Prev free chunk / 1st head: next head. */
+  size_t size;                  /* Size of free chunk / Size of heap. */
+  size_t dummy;                 /* May or may not overlap with trailer. */
+} MCodeHead;
+
+/* Allocation granularity. Assumes sizeof(void *) >= sizeof(size_t). */
+#define MCH_GRANULARITY         (4*sizeof(void *))
+#define MCH_ROUNDSIZE(x)        (((x) + MCH_GRANULARITY-1) & -MCH_GRANULARITY)
+#define MCH_ROUNDHEAP(x)        (((x) + 4095) & -4096)
+#define MCH_HEADERSIZE          MCH_ROUNDSIZE(sizeof(MCodeHead))
+
+/* Trailer flags. */
+#define MCH_USED                1       /* Next chunk is in use. */
+#define MCH_LAST                2       /* Next chunk is the last one. */
+#define MCH_FIRST               4       /* Next chunk is the first one. */
+/* Note: the last chunk of each heap doesn't have a trailer. */
+
+/* Trailer macros. */
+#define MCH_PREVTRAILER(mh)     ((size_t *)(mh) - 1)
+#define MCH_TRAILER(mh, sz)     ((size_t *)((char *)(mh) + (sz)) - 1)
+#define MCH_TRFLAGS(tr)         ((tr) & (MCH_USED|MCH_LAST))
+#define MCH_TRSIZE(tr)          ((tr) & ~(MCH_USED|MCH_LAST))
+
+/* Debugging memory allocators is ... oh well. */
+#ifdef MCH_DEBUG
+#include <stdio.h>
+#define MCH_DBGF        stderr
+#define MCH_DBG(x)      fprintf x
+#else
+#define MCH_DBG(x)      ((void)0)
+#endif
+
+/* Free the whole list of mcode heaps. */
+void luaJIT_freemcodeheap(jit_State *J)
+{
+  MCodeHead *mh = (MCodeHead *)J->mcodeheap;
+  while (mh) {
+    MCodeHead *prev = mh->prev;  /* Heaps are in the prev chain. */
+#ifdef MCH_DEBUG
+    munmap((void *)mh, mh->size+4096);
+#else
+    munmap((void *)mh, mh->size);
+#endif
+    mh = prev;
+  }
+  J->mcodeheap = NULL;
+}
+
+/* Allocate a new heap of at least the given size. */
+static void mcode_newheap(jit_State *J, size_t sz)
+{
+  MCodeHead *mh, *mhn, *fh;
+  void *ptr;
+
+  /* Ensure minimum size or round up. */
+  if (sz + MCH_HEADERSIZE <= LUAJIT_MCH_CHUNKSIZE)
+    sz = LUAJIT_MCH_CHUNKSIZE;
+  else
+    sz = MCH_ROUNDHEAP(sz + MCH_HEADERSIZE);
+
+#ifdef MCH_DEBUG
+  /* Allocate a new heap plus a guard page. */
+  ptr = mmap(NULL, sz+4096, PROT_READ|PROT_WRITE|PROT_EXEC, MCH_MMFLAGS, -1, 0);
+  if (ptr == MAP_FAILED) luaD_throw(J->L, LUA_ERRMEM);
+  mprotect((char *)ptr+sz, 4096, PROT_NONE);
+#else
+  /* Allocate a new heap. */
+  ptr = mmap(NULL, sz, PROT_READ|PROT_WRITE|PROT_EXEC, MCH_MMFLAGS, -1, 0);
+  if (ptr == MAP_FAILED) luaD_throw(J->L, LUA_ERRMEM);
+#endif
+
+  /* Initialize free chunk. */
+  fh = (MCodeHead *)((char *)ptr + MCH_HEADERSIZE);
+  fh->size = sz - MCH_HEADERSIZE;
+  *MCH_PREVTRAILER(fh) = MCH_LAST | MCH_FIRST;  /* Zero size, no coalesce. */
+
+  /* Initialize new heap and make it the first heap. */
+  mh = (MCodeHead *)J->mcodeheap;
+  J->mcodeheap = ptr;
+  mhn = (MCodeHead *)ptr;
+  mhn->prev = mh;  /* Heaps are in the prev. chain. */
+  mhn->size = sz;
+  mhn->next = fh;  /* Start of free list is always in the first heap. */
+  fh->prev = mhn;
+  if (mh) {
+    fh->next = mh->next;  /* Old start of free list. */
+    mh->next = NULL; /* Just in case. */
+  } else {
+    fh->next = NULL;  /* No other free chunks yet. */
+  }
+  MCH_DBG((MCH_DBGF, "HEAP %p %5x\n", mhn, sz));
+}
+
+/* Allocate a code block. */
+static void *mcode_alloc(jit_State *J, size_t sz)
+{
+  sz = MCH_ROUNDSIZE(sz + sizeof(size_t));
+  for ( ; ; ) {
+    MCodeHead *mh = (MCodeHead *)J->mcodeheap;
+    if (mh) {  /* Got at least one heap so search free list. */
+#ifdef MCH_DEBUG
+      int slen = 0;
+      for (mh = mh->next; mh ; mh = mh->next, slen++)
+#else
+      for (mh = mh->next; mh ; mh = mh->next)
+#endif
+        if (mh->size >= sz) {  /* Very naive first fit. */
+          size_t *trailer = MCH_TRAILER(mh, sz);
+          size_t *ptrailer = MCH_PREVTRAILER(mh);
+          if (mh->size == sz) {  /* Exact match: just unchain chunk. */
+            mh->prev->next = mh->next;
+            if (mh->next)
+              mh->next->prev = mh->prev;
+            *ptrailer |= MCH_USED;
+            MCH_DBG((MCH_DBGF, "NEW  %p %5x  FIT #%d%s\n",
+                     mh, sz, slen, (*ptrailer & MCH_LAST) ? " LAST" : ""));
+          } else {  /* Chunk is larger: rechain remainder chunk. */
+            MCodeHead *fh = (MCodeHead *)((char *)mh + sz);
+            size_t tr;
+            fh->size = mh->size - sz;
+            (fh->prev = mh->prev)->next = fh;
+            if ((fh->next = mh->next) != NULL)
+              fh->next->prev = fh;
+            tr = *ptrailer;
+            if (tr & MCH_LAST) {
+              *ptrailer = (tr & ~MCH_LAST) | MCH_USED;
+              *trailer = sz | MCH_LAST;
+              MCH_DBG((MCH_DBGF, "NEW  %p %5x  REST %p %5x #%d LAST\n",
+                       mh, sz, fh, fh->size, slen));
+            } else {
+              size_t *ftrailer = MCH_TRAILER(fh, fh->size);
+              *ftrailer = MCH_TRFLAGS(*ftrailer) | fh->size;
+              *ptrailer = tr | MCH_USED;
+              *trailer = sz;
+              MCH_DBG((MCH_DBGF, "NEW  %p %5x  REST %p %5x #%d\n",
+                       mh, sz, fh, fh->size, slen));
+            }
+          }
+          return (void *)mh;
+        }
+    }
+    /* No luck. Allocate a new heap. Next loop iteration will succeed. */
+    mcode_newheap(J, sz);
+  }
+}
+
+/* Free a code block. */
+static void mcode_free_(jit_State *J, void *ptr, size_t sz)
+{
+  MCodeHead *mh = (MCodeHead *)ptr;
+  size_t *trailer = MCH_TRAILER(mh, sz);
+  size_t *ptrailer = MCH_PREVTRAILER(mh);
+  size_t tr = *ptrailer;
+
+#ifdef MCH_DEBUG
+  if (!(tr & MCH_USED)) MCH_DBG((MCH_DBGF, "**unused %p %5x\n", ptr, sz));
+#endif
+
+  if (!(tr & MCH_FIRST)) {
+    MCodeHead *ph = (MCodeHead *)((char *)mh - MCH_TRSIZE(tr));
+    size_t *pptrailer = MCH_PREVTRAILER(ph);
+    if (!(*pptrailer & MCH_USED)) {  /* Prev free? */
+      if (!(tr & MCH_LAST) && !(*trailer & MCH_USED)) {  /* Next free? */
+        /* Coalesce with previous and next chunk. */
+        MCodeHead *nh = (MCodeHead *)((char *)mh + sz);
+        MCH_DBG((MCH_DBGF, "free %p %5x  PN  %p %5x  %p %5x%s\n",
+                 mh, sz, ph, ph->size, nh, nh->size,
+                 (*trailer & MCH_LAST) ? " last" : ""));
+        if ((nh->prev->next = nh->next) != NULL)
+          nh->next->prev = nh->prev;
+        ph->size += sz + nh->size;
+        if (*trailer & MCH_LAST) {
+          *pptrailer |= MCH_LAST;
+        } else {
+          trailer = MCH_TRAILER(nh, nh->size);
+          *trailer = MCH_TRFLAGS(*trailer) | ph->size;
+        }
+        return;
+      }
+      MCH_DBG((MCH_DBGF, "free %p %5x  P-  %p %5x%s\n",
+               mh, sz, ph, ph->size,
+               (tr & MCH_LAST) ? " last" : ""));
+      ph->size += sz;
+      if (tr & MCH_LAST)
+        *pptrailer |= MCH_LAST;
+      else
+        *trailer = MCH_TRFLAGS(*trailer) | ph->size;
+      return;
+    }
+  }
+
+  if (!(tr & MCH_LAST) && !(*trailer & MCH_USED)) {  /* Next free? */
+    /* Coalesce with next chunk. */
+    MCodeHead *nh = (MCodeHead *)((char *)mh + sz);
+    MCH_DBG((MCH_DBGF, "free %p %5x  -N  %p %5x%s\n",
+             mh, sz, nh, nh->size, (*trailer & MCH_LAST) ? " last" : ""));
+    (mh->prev = nh->prev)->next = mh;
+    if ((mh->next = nh->next))
+      mh->next->prev = mh;
+    mh->size = nh->size + sz;
+    if (*trailer & MCH_LAST) {
+      *ptrailer = (tr & ~MCH_USED) | MCH_LAST;
+    } else {
+      trailer = MCH_TRAILER(mh, mh->size);
+      *trailer = MCH_TRFLAGS(*trailer) | mh->size;
+      *ptrailer = tr & ~MCH_USED;
+    }
+  } else {
+    /* No coalesce possible, just add to free list. */
+    MCodeHead *fh = (MCodeHead *)J->mcodeheap;
+    MCH_DBG((MCH_DBGF, "free %p %5x  --%s\n",
+             mh, sz, (tr & MCH_LAST) ? "  last" : ""));
+    if ((mh->next = fh->next))
+      mh->next->prev = mh;
+    fh->next = mh;
+    mh->prev = fh;
+    mh->size = sz;
+    *ptrailer = tr & ~MCH_USED;
+  }
+}
+
+#define mcode_free(L, J, p, sz) \
+  mcode_free_(J, (p), MCH_ROUNDSIZE((sz) + sizeof(size_t)))
+
+/* ------------------------------------------------------------------------ */
+
+#else
+
+/*
+** Fallback to Lua's alloc, i.e. probably malloc().
+**
+** Note: the returned memory is usually not marked executable!
+** Running the code will crash if the CPU/OS checks for this.
+** E.g. on x86 CPUs that support the NX (No eXecute) bit.
+*/
+
+/* There's no heap to free, but the JSUB mcode is. */
+void luaJIT_freemcodeheap(jit_State *J)
+{
+  if (J->jsubmcode) luaM_freemem(J->L, J->jsubmcode, J->szjsubmcode);
+}
+
+#define mcode_alloc(J, sz)      luaM_realloc_(J->L, NULL, 0, (sz))
+#define mcode_free(L, J, p, sz) luaM_freemem(L, p, sz)
+
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+/* Free mcode. */
+void luaJIT_freemcode(jit_State *J, void *mcode, size_t sz)
+{
+  mcode_free(J->L, J, mcode, sz);
+}
+
+/* Free JIT structures in function prototype. */
+void luaJIT_freeproto(lua_State *L, Proto *pt)
+{
+  char *mcode = (char *)pt->jit_mcode;
+  size_t sz = pt->jit_szmcode;
+  pt->jit_mcode = NULL;
+  pt->jit_szmcode = 0;
+  while (sz != 0) {  /* Free whole chain of mcode blocks for this proto. */
+    jit_MCTrailer next;
+    memcpy((void *)&next, JIT_MCTRAILER(mcode, sz), sizeof(jit_MCTrailer));
+    MCH_INVALIDATE(mcode, sz);
+    mcode_free(L, G(L)->jit_state, mcode, sz);
+    mcode = next.mcode;
+    sz = next.sz;
+  }
+}
+
+/* Link generated code. Return mcode address, size and status. */
+int luaJIT_link(jit_State *J, void **mcodep, size_t *szp)
+{
+  size_t sz;
+  void *mcode;
+
+  /* Pass 2: link sections. */
+  if ((J->dasmstatus = dasm_link(Dst, &sz))) return JIT_S_DASM_ERROR;
+
+  /* Check for hardcoded limit on mcode size. */
+  if (sz > LUAJIT_LIM_MCODE) return JIT_S_TOOLARGE;
+
+  /* TODO: mark mcode readonly when we're done. */
+  mcode = mcode_alloc(J, sz);
+
+  /* Pass 3: encode sections. */
+  if ((J->dasmstatus = dasm_encode(Dst, mcode)) != 0) {
+    mcode_free(J->L, J, mcode, sz);
+    return JIT_S_DASM_ERROR;
+  }
+  *mcodep = mcode;
+  *szp = sz;
+  return JIT_S_OK;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_x86.dasc b/libraries/LuaJIT-1.1.7/src/ljit_x86.dasc
new file mode 100644
index 0000000..f7be91e
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_x86.dasc
@@ -0,0 +1,2457 @@
+/*
+** Bytecode to machine code translation for x86 CPUs.
+** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+|// Include common definitions and macros.
+|.include ljit_x86.dash
+|
+|// Place actionlist and globals here at the top of the file.
+|.actionlist jit_actionlist
+|.globals JSUB_
+
+/* ------------------------------------------------------------------------ */
+
+/* Arch string. */
+const char luaJIT_arch[] = "x86";
+
+/* Forward declarations for C functions called from jsubs. */
+static void jit_hookins(lua_State *L, const Instruction *newpc);
+static void jit_gettable_fb(lua_State *L, Table *t, StkId dest);
+static void jit_settable_fb(lua_State *L, Table *t, StkId val);
+
+/* ------------------------------------------------------------------------ */
+
+/* Detect CPU features and set JIT flags. */
+static int jit_cpudetect(jit_State *J)
+{
+  void *mcode;
+  size_t sz;
+  int status;
+  /* Some of the jsubs need the flags. So compile this separately. */
+  unsigned int feature;
+  dasm_setup(Dst, jit_actionlist);
+  |  // Check for CPUID support first.
+  |  pushfd
+  |  pop edx
+  |  mov ecx, edx
+  |  xor edx, 0x00200000                // Toggle ID bit in flags.
+  |  push edx
+  |  popfd
+  |  pushfd
+  |  pop edx
+  |  xor eax, eax                       // Zero means no features supported.
+  |  cmp ecx, edx
+  |  jz >1                              // No ID toggle means no CPUID support.
+  |
+  |  inc eax                            // CPUID function 1.
+  |  push ebx                           // Callee-save ebx modified by CPUID.
+  |  cpuid
+  |  pop ebx
+  |  mov eax, edx                       // Return feature support bits.
+  |1:
+  |  ret
+  (void)dasm_checkstep(Dst, DASM_SECTION_CODE);
+  status = luaJIT_link(J, &mcode, &sz);
+  if (status != JIT_S_OK)
+    return status;
+  /* Check feature bits. See the Intel/AMD manuals for the bit definitions. */
+  feature = ((unsigned int (*)(void))mcode)();
+  if (feature & (1<<15)) J->flags |= JIT_F_CPU_CMOV;
+  if (feature & (1<<26)) J->flags |= JIT_F_CPU_SSE2;
+  luaJIT_freemcode(J, mcode, sz);  /* We don't need this code anymore. */
+  return JIT_S_OK;
+}
+
+/* Check some assumptions. Should compile to nop. */
+static int jit_consistency_check(jit_State *J)
+{
+  do {
+    /* Force a compiler error for inconsistent structure sizes. */
+    /* Check LUA_TVALUE_ALIGN in luaconf.h, too. */
+    ||int check_TVALUE_SIZE_in_ljit_x86_dash[1+TVALUE_SIZE-sizeof(TValue)];
+    ||int check_TVALUE_SIZE_in_ljit_x86_dash_[1+sizeof(TValue)-TVALUE_SIZE];
+    ((void)check_TVALUE_SIZE_in_ljit_x86_dash[0]);
+    ((void)check_TVALUE_SIZE_in_ljit_x86_dash_[0]);
+    if (LUA_TNIL != 0 || LUA_TBOOLEAN != 1 || PCRLUA != 0) break;
+    if ((int)&(((Node *)0)->i_val) != (int)&(((StkId)0)->value)) break;
+    return JIT_S_OK;
+  } while (0);
+  J->dasmstatus = 999999999;  /* Recognizable error. */
+  return JIT_S_COMPILER_ERROR;
+}
+
+/* Compile JIT subroutines (once). */
+static int jit_compile_jsub(jit_State *J)
+{
+  int status = jit_consistency_check(J);
+  if (status != JIT_S_OK) return status;
+  status = jit_cpudetect(J);
+  if (status != JIT_S_OK) return status;
+  dasm_setup(Dst, jit_actionlist);
+  |// Macros to reorder and combine JIT subroutine definitions.
+  |.macro .jsub, name
+  |.capture JSUB                        // Add the entry point.
+  ||//-----------------------------------------------------------------------
+  ||//->name:
+  |  .align 16
+  |->name:
+  |.endmacro
+  |.macro .endjsub;  .endcapture; .endmacro
+  |.macro .dumpjsub;  .dumpcapture JSUB; .endmacro
+  |
+  |.code
+  |//-----------------------------------------------------------------------
+  |  .align 16
+  |  // Must be the first JSUB defined or used.
+  |->STACKPTR:                          // Get stack pointer (for jit.util.*).
+  |  lea eax, [esp+aword*1]             // But adjust for the return address.
+  |  ret
+  |
+  |//-----------------------------------------------------------------------
+  |  .align 16
+  |->GATE_LJ:                           // Lua -> JIT gate. (L, func, nresults)
+  |  push ebp
+  |  mov ebp, esp
+  |  sub esp, LJFRAME_OFFSET
+  |  mov SAVER1, BASE
+  |   mov BASE, CARG2   // func
+  |  mov CARG2, L       // Arg used as savereg. Avoids aword*8 stack frame.
+  |   mov L, CARG1      // L
+  |  mov SAVER2, TOP
+  |   mov TOP, L->top
+  |  mov LCL, BASE->value
+  |   mov CI, L->ci
+  |  // Prevent stackless yields. No limit check -- this is not a real C call.
+  |  inc word L->nCcalls  // short
+  |
+  |  call aword LCL->jit_gate           // Call the compiled code.
+  |
+  |   mov CI, L->ci
+  |  mov L->top, TOP                    // Only correct for LUA_MULTRET.
+  |   mov edx, CI->savedpc
+  |  mov eax, CARG3     // nresults
+  |   mov L->savedpc, edx               // L->savedpc = CI->savedpc
+  |   mov edx, CI->base
+  |  test eax, eax
+  |   mov L->base, edx                  // L->base = CI->base
+  |  js >2                              // Skip for nresults == LUA_MULTRET.
+  |
+  |  TValuemul eax
+  |  add BASE, eax
+  |  xor ecx, ecx
+  |  mov L->top, BASE                   // L->top = &func[nresults]
+  |1:  // No initial check. May use EXTRA_STACK (once).
+  |  mov TOP->tt, ecx                   // Clear unset stack slots.
+  |  add TOP, #TOP
+  |  cmp TOP, BASE
+  |  jb <1
+  |
+  |2:
+  |  dec word L->nCcalls  // short
+  |  mov eax, PCRC
+  |  mov TOP, SAVER2
+  |  mov BASE, SAVER1
+  |  mov L, CARG2
+  |  mov esp, ebp
+  |  pop ebp
+  |  ret
+  |
+  |//-----------------------------------------------------------------------
+  |  .align 16
+  |->GATE_JL:                           // JIT -> Lua callgate.
+  |  mov PROTO:edx, LCL->p
+  |  cmp dword PROTO:edx->jit_status, JIT_S_OK
+  |  jne >1                             // Already compiled?
+  |
+  |  // Yes, copy callgate to closure (so GATE_JL is not called again).
+  |  mov edx, PROTO:edx->jit_mcode
+  |  mov LCL->jit_gate, edx
+  |  jmp edx                            // Chain to compiled code.
+  |
+  |1:  // Let luaD_precall do the hard work: compile & run or fallback.
+  |  sub esp, FRAME_OFFSET
+  |   mov eax, CI->savedpc
+  |  mov L->ci, CI                      // May not be in sync for tailcalls.
+  |   mov L->top, TOP
+  |  mov ARG3, -1                       // LUA_MULTRET
+  |   mov L->savedpc, eax               // luaD_precall expects it there.
+  |  mov ARG2, BASE
+  |   sub BASE, L->stack                // Preserve old BASE (= func).
+  |  mov ARG1, L
+  |  call &luaD_precall                 // luaD_precall(L, func, nresults)
+  |  test eax,eax                       // Assumes: PCRLUA == 0
+  |  jnz >2                             // PCRC? PCRYIELD cannot happen.
+  |
+  |  // Returned PCRLUA: need to call the bytecode interpreter.
+  |  call &luaV_execute, L, 1
+  |  // Indirect yield (L->status == LUA_YIELD) cannot happen.
+  |
+  |2:  // Returned PCRC: compile & run done. Frame is already unwound.
+  |  add esp, FRAME_OFFSET
+  |  add BASE, L->stack  // Restore stack-relative pointers BASE and TOP.
+  |  mov TOP, L->top
+  |  ret
+  |
+  |//-----------------------------------------------------------------------
+  |  .align 16
+  |->GATE_JC:                           // JIT -> C callgate.
+  |  lea eax, TOP[LUA_MINSTACK]
+  |   sub esp, FRAME_OFFSET
+  |  cmp eax, L->stack_last
+  |  jae ->GROW_STACK                   // Stack overflow?
+  |  cmp CI, L->end_ci
+  |   lea CI, CI[1]
+  |  je ->GROW_CI                       // CI overflow?
+  |  mov L->ci, CI
+  |  mov CI->func, BASE
+  |  mov CI->top, eax
+  |  mov CCLOSURE:edx, BASE->value
+  |  add BASE, #BASE
+  |  mov L->top, TOP
+  |  mov L->base, BASE
+  |  mov CI->base, BASE
+  |  // ci->nresults is not set because we don't use luaD_poscall().
+  |
+  |->GATE_JC_PATCH:                     // Patch mark for jmp to GATE_JC_DEBUG.
+  |
+  |  call aword CCLOSURE:edx->f, L      // Call the C function.
+  |
+  |2:                                   // Label used below!
+  |  add esp, FRAME_OFFSET
+  |   mov CI, L->ci
+  |  TValuemul eax                      // eax = nresults*sizeof(TValue)
+  |   mov TOP, CI->func
+  |  jz >4                              // Skip loop if nresults == 0.
+  |                                     // Yield (-1) cannot happen.
+  |  mov BASE, L->top
+  |  mov edx, BASE
+  |  sub BASE, eax                      // BASE = &L->top[-nresults]
+  |3:  // Relocate [L->top-nresults, L->top) -> [ci->func, ci->func+nresults)
+  |  mov eax, [BASE]
+  |  add BASE, aword*1
+  |  mov [TOP], eax
+  |  add TOP, aword*1
+  |  cmp BASE, edx
+  |  jb <3
+  |
+  |4:
+  |  mov BASE, CI->func
+  |  sub CI, #CI
+  |  mov L->ci, CI
+  |  ret
+  |
+  |//-----------------------------------------------------------------------
+  |  nop; nop; nop; nop; nop; nop       // Save area. See DEBUGPATCH_SIZE.
+  |  .align 16
+  |->GATE_JC_DEBUG:                     // JIT -> C callgate for debugging.
+  |  test byte L->hookmask, LUA_MASKCALL // Need to call hook?
+  |  jnz >7
+  |6:
+  |  call aword CCLOSURE:edx->f, L      // Call the C function.
+  |
+  |  test byte L->hookmask, LUA_MASKRET // Need to call hook?
+  |  jz <2
+  |
+  |  // Return hook. TODO: LUA_HOOKTAILRET is not called since tailcalls == 0.
+  |  mov BASE, eax  // BASE (ebx) is callee-save.
+  |  call &luaD_callhook, L, LUA_HOOKRET, -1
+  |  mov eax, BASE
+  |  jmp <2
+  |
+  |7:  // Call hook.
+  |  mov BASE, CCLOSURE:edx  // BASE (ebx) is callee-save.
+  |  call &luaD_callhook, L, LUA_HOOKCALL, -1
+  |  mov CCLOSURE:edx, BASE
+  |  jmp <6
+  |
+  |//-----------------------------------------------------------------------
+  |  .align 16
+  |->GROW_STACK:                        // Grow stack. Jump from/to prologue.
+  |  sub eax, TOP
+  |  TValuediv eax                      // eax = (eax-TOP)/sizeof(TValue).
+  |  mov L->top, TOP
+  |  sub BASE, L->stack
+  |  mov ARG3, CI
+  |  call &luaD_growstack, L, eax
+  |  mov CI, ARG3                       // CI may not be in sync with L->ci.
+  |  add BASE, L->stack                 // Restore stack-relative pointers.
+  |  mov TOP, L->top
+  |  mov LCL, BASE->value
+  |  add esp, FRAME_OFFSET              // Undo esp adjust of prologue/GATE_JC.
+  |  jmp aword LCL->jit_gate            // Retry prologue.
+  |
+  |//-----------------------------------------------------------------------
+  |  .align 16
+  |->GROW_CI:                           // Grow CI. Jump from/to prologue.
+  |  mov L->top, TOP                    // May throw LUA_ERRMEM, so save TOP.
+  |  call &luaD_growCI, L
+  |  lea CI, CINFO:eax[-1]              // Undo ci++ (L->ci reset in prologue).
+  |  mov LCL, BASE->value
+  |  mov L->ci, CI
+  |  add esp, FRAME_OFFSET              // Undo esp adjust of prologue/GATE_JC.
+  |  jmp aword LCL->jit_gate            // Retry prologue.
+  |
+  |//-----------------------------------------------------------------------
+  |.dumpjsub                            // Dump all captured .jsub's.
+  |
+  |// Uncritical jsubs follow. No need to align them.
+  |//-----------------------------------------------------------------------
+  |->DEOPTIMIZE_CALLER:                 // Deoptimize calling instruction.
+  |  pop edx
+  |  jmp ->DEOPTIMIZE
+  |
+  |->DEOPTIMIZE_OPEN:                   // Deoptimize open instruction.
+  |  mov L->top, TOP                    // Save TOP.
+  |
+  |->DEOPTIMIZE:                        // Deoptimize instruction.
+  |  mov L->savedpc, edx                // &J->nextins expected in edx.
+  |  call &luaJIT_deoptimize, L
+  |  mov BASE, L->base
+  |  mov TOP, L->top                    // Restore TOP for open ins.
+  |  jmp eax                            // Continue with new mcode addr.
+  |
+  |  .align 16
+  |//-----------------------------------------------------------------------
+
+  (void)dasm_checkstep(Dst, DASM_SECTION_CODE);
+  status = luaJIT_link(J, &J->jsubmcode, &J->szjsubmcode);
+  if (status != JIT_S_OK)
+    return status;
+
+  /* Copy the callgates from the globals to the global state. */
+  G(J->L)->jit_gateLJ = (luaJIT_GateLJ)J->jsub[JSUB_GATE_LJ];
+  G(J->L)->jit_gateJL = (lua_CFunction)J->jsub[JSUB_GATE_JL];
+  G(J->L)->jit_gateJC = (lua_CFunction)J->jsub[JSUB_GATE_JC];
+  return JIT_S_OK;
+}
+
+/* Match with number of nops above. Avoid confusing the instruction decoder. */
+#define DEBUGPATCH_SIZE         6
+
+/* Notify backend that the debug mode may have changed. */
+void luaJIT_debugnotify(jit_State *J)
+{
+  unsigned char *patch = (unsigned char *)J->jsub[JSUB_GATE_JC_PATCH];
+  unsigned char *target = (unsigned char *)J->jsub[JSUB_GATE_JC_DEBUG];
+  /* Yep, this is self-modifying code -- don't tell anyone. */
+  if (patch[0] == 0xe9) {  /* Debug patch is active. */
+    if (!(J->flags & JIT_F_DEBUG_CALL))  /* Deactivate it. */
+      memcpy(patch, target-DEBUGPATCH_SIZE, DEBUGPATCH_SIZE);
+  } else {  /* Debug patch is inactive. */
+    if (J->flags & JIT_F_DEBUG_CALL) {  /* Activate it. */
+      int rel = target-(patch+5);
+      memcpy(target-DEBUGPATCH_SIZE, patch, DEBUGPATCH_SIZE);
+      patch[0] = 0xe9;  /* jmp */
+      memcpy(patch+1, &rel, 4);  /* Relative address. */
+      memset(patch+5, 0x90, DEBUGPATCH_SIZE-5);  /* nop */
+    }
+  }
+}
+
+/* Patch a jmp into existing mcode. */
+static void jit_patch_jmp(jit_State *J, void *mcode, void *to)
+{
+  unsigned char *patch = (unsigned char *)mcode;
+  int rel = ((unsigned char *)to)-(patch+5);
+  patch[0] = 0xe9;  /* jmp */
+  memcpy((void *)(patch+1), &rel, 4);  /* Relative addr. */
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Call line/count hook. */
+static void jit_hookins(lua_State *L, const Instruction *newpc)
+{
+  Proto *pt = ci_func(L->ci)->l.p;
+  int pc = luaJIT_findpc(pt, newpc);  /* Sloooow with mcode addrs. */
+  const Instruction *savedpc = L->savedpc;
+  L->savedpc = pt->code + pc + 1;
+  if (L->hookmask > LUA_MASKLINE && L->hookcount == 0) {
+    resethookcount(L);
+    luaD_callhook(L, LUA_HOOKCOUNT, -1);
+  }
+  if (L->hookmask & LUA_MASKLINE) {
+    int newline = getline(pt, pc);
+    if (pc != 0) {
+      int oldpc = luaJIT_findpc(pt, savedpc);
+      if (!(pc <= oldpc || newline != getline(pt, oldpc))) return;
+    }
+    luaD_callhook(L, LUA_HOOKLINE, newline);
+  }
+}
+
+/* Insert hook check for each instruction in full debug mode. */
+static void jit_ins_debug(jit_State *J, int openop)
+{
+  if (openop) {
+    |  mov L->top, TOP
+  }
+  |// TODO: Passing bytecode addrs would speed this up (but use more space).
+  |  call ->HOOKINS
+
+  |.jsub HOOKINS
+  |  test byte L->hookmask, LUA_MASKLINE|LUA_MASKCOUNT
+  |  jz >2
+  |  dec dword L->hookcount
+  |  jz >1
+  |  test byte L->hookmask, LUA_MASKLINE
+  |  jz >2
+  |1:
+  |  mov eax, [esp]                     // Current machine code address.
+  |  sub esp, FRAME_OFFSET
+  |  call &jit_hookins, L, eax
+  |  add esp, FRAME_OFFSET
+  |  mov BASE, L->base                  // Restore stack-relative pointers.
+  |  mov TOP, L->top
+  |2:
+  |  ret
+  |.endjsub
+}
+
+/* Called before every instruction. */
+static void jit_ins_start(jit_State *J)
+{
+  |// Always emit PC labels, even for dead code (but not for combined JMP).
+  |=>J->nextpc:
+}
+
+/* Chain to another instruction. */
+static void jit_ins_chainto(jit_State *J, int pc)
+{
+  |  jmp =>pc
+}
+
+/* Set PC label. */
+static void jit_ins_setpc(jit_State *J, int pc, void *target)
+{
+  |.label =>pc, &target
+}
+
+/* Called after the last instruction has been encoded. */
+static void jit_ins_last(jit_State *J, int lastpc, int sizemfm)
+{
+  if (J->tflags & JIT_TF_USED_DEOPT) {  /* Deopt section has been used? */
+    |.deopt
+    |  jmp ->DEOPTIMIZE                 // Yes, need to add final jmp.
+    |.code
+  }
+  |=>lastpc+1:                          // Extra label at the end of .code.
+  |.tail
+  |=>lastpc+2:                          // And at the end of .deopt/.tail.
+  |  .align word                        // Keep next section word aligned.
+  |  .word 0xffff                       // Terminate mfm with JIT_MFM_STOP.
+  |.mfmap
+  |  // <-- Deoptimization hints are inserted here.
+  |  .space sizemfm                     // To be filled in with inverse mfm.
+  |  .aword 0, 0                        // Next mcode block pointer and size.
+  |  // The previous two awords are only word, but not aword aligned.
+  |  // Copying them is easier than aligning them and adjusting mfm handling.
+  |.code
+}
+
+/* Add a deoptimize target for the current instruction. */
+static void jit_deopt_target(jit_State *J, int nargs)
+{
+  |.define L_DEOPTLABEL, 9              // Local deopt label.
+  |.define L_DEOPTIMIZE, <9             // Local deopt target. Use after call.
+  |.define L_DEOPTIMIZEF, >9            // Local deopt target. Use before call.
+  if (nargs != -1) {
+    |// Alas, x86 doesn't have conditional calls. So branch to the .deopt
+    |// section to load J->nextins and jump to JSUB_DEOPTIMIZE.
+    |// Only a single jump is added at the end (if needed) and any
+    |// intervening code sequences are shadowed (lea trick).
+    |.deopt                             // Occupies 6 bytes in .deopt section.
+    |  .byte 0x8d                       // Shadow mov with lea edi, [edx+ofs].
+    |L_DEOPTLABEL:
+    |  mov edx, &J->nextins             // Current instruction + 1.
+    |.code
+    J->tflags |= JIT_TF_USED_DEOPT;
+  } else {
+    |.tail                              // Occupies 10 bytes in .tail section.
+    |L_DEOPTLABEL:
+    |  mov edx, &J->nextins
+    |  jmp ->DEOPTIMIZE_OPEN            // Open ins need to save TOP, too.
+    |  // And TOP (edi) would be overwritten by the lea trick.
+    |  // So checking for open ops later on wouldn't suffice. Sigh.
+    |.code
+  }
+}
+
+/* luaC_checkGC() inlined. Destroys caller-saves + TOP (edi). Uses label 7:. */
+/* Use this only at the _end_ of an instruction. */
+static void jit_checkGC(jit_State *J)
+{
+  |  mov GL:ecx, L->l_G
+  |  mov eax, GL:ecx->totalbytes        // size_t
+  |  mov TOP, >7
+  |  cmp eax, GL:ecx->GCthreshold       // size_t
+  |  jae ->GCSTEP
+  |7:
+
+  |.jsub GCSTEP
+  |  call &luaC_step, L
+  |  mov BASE, L->base
+  |  jmp TOP
+  |.endjsub
+}
+
+/* ------------------------------------------------------------------------ */
+
+|// JIT->JIT calling conventions:
+|//
+|//  Register/Type | Call Setup   | Prologue     | Epilogue     | Call Finish
+|// ===========================================================================
+|//  eax | LCL     | = BASE->value|              | *            | *
+|//  ecx | CI      | = L->ci      | L->ci = ++CI | *            | *
+|//  edx | *       | *            | *            | *            | *
+|// ---------------------------------------------------------------------------
+|//  esi | L       |              |              |              |
+|//  ebx | BASE    | += f         | ++           | --           | -= f
+|//  edi | TOP     | += f+1+nargs | = BASE+maxst | = f+nresults | = BASE+maxst
+|// ---------------------------------------------------------------------------
+|//  L->base       |              | = BASE       |              | = BASE
+|//  L->top        |              | = TOP        |              | = TOP
+|//  L->ci         |              | ++, -> = ... | --           |
+|//  L->ci->savedpc| = &code[pc]  | [ L-> = ]    |              |
+|// ---------------------------------------------------------------------------
+|//  args + vars   |              | setnil       |              |
+|//  results       |              |              | move         | setnil
+|// ---------------------------------------------------------------------------
+
+
+|// Include support for function inlining.
+|.include ljit_x86_inline.dash
+
+
+#ifdef LUA_COMPAT_VARARG
+static void jit_vararg_table(lua_State *L)
+{
+  Table *tab;
+  StkId base, func;
+  int i, num, numparams;
+  luaC_checkGC(L);
+  base = L->base;
+  func = L->ci->func;
+  numparams = clvalue(func)->l.p->numparams;
+  num = base - func - numparams - 1;
+  tab = luaH_new(L, num, 1);
+  for (i = 0; i < num; i++)
+    setobj2n(L, luaH_setnum(L, tab, i+1), base - num + i);
+  setnvalue(luaH_setstr(L, tab, luaS_newliteral(L, "n")), (lua_Number)num);
+  sethvalue(L, base + numparams, tab);
+}
+#endif
+
+/* Encode JIT function prologue. */
+static void jit_prologue(jit_State *J)
+{
+  Proto *pt = J->pt;
+  int numparams = pt->numparams;
+  int stacksize = pt->maxstacksize;
+
+  |// Note: the order of the following instructions has been carefully tuned.
+  |  lea eax, TOP[stacksize]
+  |   sub esp, FRAME_OFFSET
+  |  cmp eax, L->stack_last
+  |  jae ->GROW_STACK                   // Stack overflow?
+  |  // This is a slight overallocation (BASE[1+stacksize] would be enough).
+  |  // We duplicate luaD_precall() behaviour so we can use luaD_growstack().
+  |  cmp CI, L->end_ci
+  |   lea CI, CI[1]
+  |  je ->GROW_CI                       // CI overflow?
+  |  xor eax, eax                       // Assumes: LUA_TNIL == 0
+  |   mov CI->func, BASE
+  |  add BASE, #BASE
+  |   mov L->ci, CI
+
+  if (numparams > 0) {
+    |  lea edx, BASE[numparams]
+    |  cmp TOP, edx                     // L->top >< L->base+numparams ?
+  }
+
+  if (!pt->is_vararg) {  /* Fixarg function. */
+    /* Must cap L->top at L->base+numparams because 1st LOADNIL is omitted. */
+    if (numparams == 0) {
+      |  mov TOP, BASE
+    } else if (J->flags & JIT_F_CPU_CMOV) {
+      |  cmova TOP, edx
+    } else {
+      |  jna >1
+      |  mov TOP, edx
+      |1:
+    }
+    |   lea edx, BASE[stacksize]        // New ci->top.
+    |  mov CI->tailcalls, eax           // 0
+    |   mov CI->top, edx
+    |   mov L->top, edx
+    |  mov L->base, BASE
+    |  mov CI->base, BASE
+  } else {  /* Vararg function. */
+    int i;
+    if (numparams > 0) {
+      |// If some fixargs are missing we need to clear them and
+      |// bump TOP to get a consistent frame layout for OP_VARARG.
+      |  jb >5
+      |4:
+      |.tail
+      |5:  // This is uncommon. So move it to .tail and use a loop.
+      |  mov TOP->tt, eax
+      |  add TOP, #TOP
+      |  cmp TOP, edx
+      |  jb <5
+      |  jmp <4
+      |.code
+    }
+    |  mov L->base, TOP                 // New base is after last arg.
+    |  mov CI->base, TOP
+    |   mov CI->tailcalls, eax          // 0
+    for (i = 0; i < numparams; i++) {  /* Move/clear fixargs. */
+      |// Inline this. Vararg funcs usually have very few fixargs.
+      |  copyslot TOP[i], BASE[i], ecx, edx
+      |  mov BASE[i].tt, eax            // Clear old fixarg slot (help the GC).
+    }
+    if (numparams > 0) {
+      |  mov CI, L->ci                  // Reload CI = ecx (used by move).
+    }
+    |  mov BASE, TOP
+    |   lea edx, BASE[stacksize]        // New ci->top.
+    |  lea TOP, BASE[numparams]         // Start of vars to clear.
+    |   mov CI->top, edx
+    |   mov L->top, edx
+    stacksize -= numparams;             /* Fixargs are already cleared. */
+  }
+
+  /* Clear undefined args and all vars. Still assumes eax = LUA_TNIL = 0. */
+  /* Note: cannot clear only args because L->top has grown. */
+  if (stacksize <= EXTRA_STACK) {  /* Loopless clear. May use EXTRA_STACK. */
+    int i;
+    for (i = 0; i < stacksize; i++) {
+      |  mov TOP[i].tt, eax
+    }
+  } else {  /* Standard loop. */
+    |2:  // Unrolled for 2 stack slots. No initial check. May use EXTRA_STACK.
+    |  mov TOP[0].tt, eax
+    |  mov TOP[1].tt, eax
+    |  add TOP, 2*#TOP
+    |  cmp TOP, edx
+    |  jb <2
+    |// Note: TOP is undefined now. TOP is only valid across calls/open ins.
+  }
+
+#ifdef LUA_COMPAT_VARARG
+  if (pt->is_vararg & VARARG_NEEDSARG) {
+    |  call &jit_vararg_table, L
+  }
+#endif
+
+  /* Call hook check. */
+  if (J->flags & JIT_F_DEBUG_CALL) {
+    |  test byte L->hookmask, LUA_MASKCALL
+    |  jz >9
+    |  call ->HOOKCALL
+    |9:
+
+    |.jsub HOOKCALL
+    |  mov CI, L->ci
+    |  mov TOP, CI->func
+    |  mov LCL, TOP->value
+    |  mov PROTO:edi, LCL->p            // clvalue(L->ci->func)->l.p
+    |  mov eax, PROTO:edi->code
+    |  add eax, 4                       // Hooks expect incremented PC.
+    |  mov L->savedpc, eax
+    |  sub esp, FRAME_OFFSET
+    |  call &luaD_callhook, L, LUA_HOOKCALL, -1
+    |  add esp, FRAME_OFFSET
+    |  mov eax, PROTO:edi->code         // PROTO:edi is callee-save.
+    |  mov L->savedpc, eax              // jit_hookins needs previous PC.
+    |  mov BASE, L->base
+    |  ret
+    |.endjsub
+  }
+}
+
+/* Check if we can combine 'return const'. */
+static int jit_return_k(jit_State *J)
+{
+  if (!J->combine) return 0;  /* COMBINE hint set? */
+  /* May need to close open upvalues. */
+  if (!fhint_isset(J, NOCLOSE)) {
+    |  call &luaF_close, L, BASE
+  }
+  if (!J->pt->is_vararg) {  /* Fixarg function. */
+    |  sub aword L->ci, #CI
+    |  mov TOP, BASE
+    |  sub BASE, #BASE
+    |  add esp, FRAME_OFFSET
+  } else {  /* Vararg function. */
+    |  mov CI, L->ci
+    |  mov BASE, CI->func
+    |  sub CI, #CI
+    |  mov L->ci, CI
+    |  lea TOP, BASE[1]
+    |  add esp, FRAME_OFFSET
+  }
+  jit_assert(J->combine == 1);  /* Required to skip next RETURN instruction. */
+  return 1;
+}
+
+static void jit_op_return(jit_State *J, int rbase, int nresults)
+{
+  /* Return hook check. */
+  if (J->flags & JIT_F_DEBUG_CALL) {
+    if (nresults < 0 && !(J->flags & JIT_F_DEBUG_INS)) {
+      | mov L->top, TOP
+    }
+    |// TODO: LUA_HOOKTAILRET (+ ci->tailcalls counting) or changed debug API.
+    |  test byte L->hookmask, LUA_MASKRET
+    |  jz >7
+    |  call ->HOOKRET
+    |7:
+    if (J->flags & JIT_F_DEBUG_INS) {
+      |  mov eax, FRAME_RETADDR
+      |  mov L->savedpc, eax
+    }
+
+    |.jsub HOOKRET
+    |  mov eax, [esp]                   // Current machine code address.
+    |  mov L->savedpc, eax
+    |  sub esp, FRAME_OFFSET
+    |  call &luaD_callhook, L, LUA_HOOKRET, -1
+    |  add esp, FRAME_OFFSET
+    |  mov BASE, L->base                // Restore stack-relative pointers.
+    |  mov TOP, L->top
+    |  ret
+    |.endjsub
+  }
+
+  /* May need to close open upvalues. */
+  if (!fhint_isset(J, NOCLOSE)) {
+    |  call &luaF_close, L, BASE
+  }
+
+  /* Previous op was open: 'return f()' or 'return ...' */
+  if (nresults < 0) {
+    |// Relocate [BASE+rbase, TOP) -> [ci->func, *).
+    |  mov CI, L->ci
+    |  addidx BASE, rbase
+    |  mov edx, CI->func
+    |  cmp BASE, TOP
+    |  jnb >2
+    |1:
+    |  mov eax, [BASE]
+    |  add BASE, aword*1
+    |  mov [edx], eax
+    |  add edx, aword*1
+    |  cmp BASE, TOP
+    |  jb <1
+    |2:
+    |  add esp, FRAME_OFFSET
+    |  mov BASE, CI->func
+    |  sub CI, #CI
+    |  mov TOP, edx                     // Relocated TOP.
+    |  mov L->ci, CI
+    |  ret
+    return;
+  }
+
+  if (!J->pt->is_vararg) {  /* Fixarg function, nresults >= 0. */
+    int i;
+    |  sub aword L->ci, #CI
+    |// Relocate [BASE+rbase,BASE+rbase+nresults) -> [BASE-1, *).
+    |// TODO: loop for large nresults?
+    |  sub BASE, #BASE
+    for (i = 0; i < nresults; i++) {
+      |  copyslot BASE[i], BASE[rbase+i+1]
+    }
+    |  add esp, FRAME_OFFSET
+    |  lea TOP, BASE[nresults]
+    |  ret
+  } else {  /* Vararg function, nresults >= 0. */
+    int i;
+    |// Relocate [BASE+rbase,BASE+rbase+nresults) -> [ci->func, *).
+    |  mov CI, L->ci
+    |  mov TOP, CI->func
+    |  sub CI, #CI
+    |  mov L->ci, CI                    // CI = ecx is used by copyslot.
+    for (i = 0; i < nresults; i++) {
+      |  copyslot TOP[i], BASE[rbase+i]
+    }
+    |  add esp, FRAME_OFFSET
+    |  mov BASE, TOP
+    |  addidx TOP, nresults
+    |  ret
+  }
+}
+
+static void jit_op_call(jit_State *J, int func, int nargs, int nresults)
+{
+  int cltype = jit_inline_call(J, func, nargs, nresults);
+  if (cltype < 0) return;  /* Inlined? */
+
+  |// Note: the order of the following instructions has been carefully tuned.
+  |  addidx BASE, func
+  |  mov CI, L->ci
+  |   isfunction 0                      // BASE[0] is L->base[func].
+  if (nargs >= 0) {  /* Previous op was not open and did not set TOP. */
+    |  lea TOP, BASE[1+nargs]
+  }
+  |  mov LCL, BASE->value
+  |  mov edx, &J->nextins
+  |  mov CI->savedpc, edx
+  if (cltype == LUA_TFUNCTION) {
+    if (nargs == -1) {
+      | jne ->DEOPTIMIZE_OPEN           // TYPE hint was wrong (open op)?
+    } else {
+      | jne ->DEOPTIMIZE                // TYPE hint was wrong?
+    }
+  } else {
+    |   je >1                           // Skip __call handling for functions.
+    |  call ->METACALL
+    |1:
+
+    |.jsub METACALL                     // CALL to __call metamethod.
+    |  sub esp, FRAME_OFFSET
+    |  mov L->savedpc, edx              // May throw errors. Save PC and TOP.
+    |  mov L->top, TOP
+    |  call &luaD_tryfuncTM, L, BASE    // Resolve __call metamethod.
+    |  add esp, FRAME_OFFSET
+    |  mov BASE, eax                    // Restore stack-relative pointers.
+    |  mov TOP, L->top
+    |  mov LCL, BASE->value
+    |  mov CI, L->ci
+    |  ret
+    |.endjsub
+  }
+  |  call aword LCL->jit_gate           // Call JIT func or GATE_JL/GATE_JC.
+  |  subidx BASE, func
+  |  mov L->base, BASE
+
+  /* Clear undefined results TOP <= o < func+nresults. */
+  if (nresults > 0) {
+    |  xor eax, eax
+    if (nresults <= EXTRA_STACK) {  /* Loopless clear. May use EXTRA_STACK. */
+      int i;
+      for (i = 0; i < nresults; i++) {
+        |  mov TOP[i].tt, eax
+      }
+    } else {  /* Standard loop. TODO: move to .tail? */
+      |  lea edx, BASE[func+nresults]
+      |1:  // Unrolled for 2 stack slots. No initial check. May use EXTRA_STACK.
+      |  mov TOP[0].tt, eax                     // LUA_TNIL
+      |  mov TOP[1].tt, eax                     // LUA_TNIL
+      |  add TOP, 2*#TOP
+      |  cmp TOP, edx
+      |  jb <1
+    }
+  }
+
+  if (nresults >= 0) {  /* Not an open ins. Restore L->top. */
+    |  lea TOP, BASE[J->pt->maxstacksize]  // Faster than getting L->ci->top.
+    |  mov L->top, TOP
+  }  /* Otherwise keep TOP for next instruction. */
+}
+
+static void jit_op_tailcall(jit_State *J, int func, int nargs)
+{
+  int cltype;
+
+  if (!fhint_isset(J, NOCLOSE)) {  /* May need to close open upvalues. */
+    |  call &luaF_close, L, BASE
+  }
+
+  cltype = jit_inline_call(J, func, nargs, -2);
+  if (cltype < 0) goto finish;  /* Inlined? */
+
+  if (cltype == LUA_TFUNCTION) {
+    jit_deopt_target(J, nargs);
+    |  isfunction func
+    |  jne L_DEOPTIMIZE                 // TYPE hint was wrong?
+  } else {
+    |  isfunction func; jne >5          // Handle generic callables first.
+    |.tail
+    |5:  // Fallback for generic callables.
+    |  addidx BASE, func
+    if (nargs >= 0) {
+      |  lea TOP, BASE[1+nargs]
+    }
+    |  mov edx, &J->nextins
+    |  jmp ->METATAILCALL
+    |.code
+
+    |.jsub METATAILCALL                 // TAILCALL to __call metamethod.
+    |  mov L->savedpc, edx
+    |  mov L->top, TOP
+    |  call &luaD_tryfuncTM, L, BASE    // Resolve __call metamethod.
+    |
+    |// Relocate [eax, L->top) -> [L->ci->func, *).
+    |  mov CI, L->ci
+    |  mov edx, L->top
+    |  mov TOP, CI->func
+    |1:
+    |  mov BASE, [eax]
+    |  add eax, aword*1
+    |  mov [TOP], BASE
+    |  add TOP, aword*1
+    |  cmp eax, edx
+    |  jb <1
+    |
+    |  mov BASE, CI->func
+    |  mov LCL, BASE->value
+    |  sub CI, #CI
+    |  add esp, FRAME_OFFSET
+    |  jmp aword LCL->jit_gate          // Chain to callgate.
+    |.endjsub
+  }
+
+  if (nargs >= 0) {  /* Previous op was not open and did not set TOP. */
+    int i;
+    /* Relocate [BASE+func, BASE+func+nargs] -> [ci->func, ci->func+nargs]. */
+    /* TODO: loop for large nargs? */
+    if (!J->pt->is_vararg) {  /* Fixarg function. */
+      |  mov LCL, BASE[func].value
+      for (i = 0; i < nargs; i++) {
+        |  copyslot BASE[i], BASE[func+1+i], ecx, edx
+      }
+      |  lea TOP, BASE[nargs]
+      |   sub BASE, #BASE
+      |  mov CI, L->ci
+      |  mov BASE->value, LCL           // Sufficient to copy func->value.
+    } else {  /* Vararg function. */
+      |   mov CI, L->ci
+      |  lea TOP, BASE[func]
+      |   mov BASE, CI->func
+      |  mov LCL, TOP->value
+      |  mov BASE->value, LCL           // Sufficient to copy func->value.
+      for (i = 0; i < nargs; i++) {
+        |  copyslot BASE[i+1], TOP[i+1], eax, edx
+      }
+      |  lea TOP, BASE[1+nargs]
+      |  mov LCL, BASE->value           // Need to reload LCL = eax.
+    }
+  } else {  /* Previous op was open and set TOP. */
+    |// Relocate [BASE+func, TOP) -> [ci->func, *).
+    |  mov CI, L->ci
+    |  addidx BASE, func
+    |  mov edx, CI->func
+    |1:
+    |  mov eax, [BASE]
+    |  add BASE, aword*1
+    |  mov [edx], eax
+    |  add edx, aword*1
+    |  cmp BASE, TOP
+    |  jb <1
+    |  mov BASE, CI->func
+    |  mov TOP, edx                     // Relocated TOP.
+    |  mov LCL, BASE->value
+  }
+  |  sub CI, #CI
+  |  add esp, FRAME_OFFSET
+  |  jmp aword LCL->jit_gate            // Chain to JIT function.
+
+finish:
+  J->combine++;  /* Combine with following return instruction. */
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_move(jit_State *J, int dest, int src)
+{
+  |  copyslot BASE[dest], BASE[src]
+}
+
+static void jit_op_loadk(jit_State *J, int dest, int kidx)
+{
+  const TValue *kk = &J->pt->k[kidx];
+  int rk = jit_return_k(J);
+  if (rk) dest = 0;
+  |  copyconst BASE[dest], kk
+  if (rk) {
+    |  ret
+  }
+}
+
+static void jit_op_loadnil(jit_State *J, int first, int last)
+{
+  int idx, num = last - first + 1;
+  int rk = jit_return_k(J);
+  |  xor eax, eax  // Assumes: LUA_TNIL == 0
+  if (rk) {
+    |  settt BASE[0], eax
+    |  ret
+  } else if (num <= 8) {
+    for (idx = first; idx <= last; idx++) {
+      |  settt BASE[idx], eax  // 3/6 bytes
+    }
+  } else {
+    |  lea ecx, BASE[first].tt  // 15-21 bytes
+    |  lea edx, BASE[last].tt
+    |1:
+    |  mov [ecx], eax
+    |  cmp ecx, edx
+    |  lea ecx, [ecx+#BASE]  // Preserves CC.
+    |  jbe <1
+  }
+}
+
+static void jit_op_loadbool(jit_State *J, int dest, int b, int dojump)
+{
+  int rk = jit_return_k(J);
+  if (rk) dest = 0;
+  |  setbvalue BASE[dest], b
+  if (rk) {
+    |  ret
+  } else if (dojump) {
+    const TValue *h = hint_getpc(J, COMBINE, J->nextpc);
+    if (!(ttisboolean(h) && bvalue(h) == 0)) {  /* Avoid jmp around dead ins. */
+      |  jmp =>J->nextpc+1
+    }
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_getupval(jit_State *J, int dest, int uvidx)
+{
+  |  getLCL
+  |  mov UPVAL:ecx, LCL->upvals[uvidx]
+  |  mov TOP, UPVAL:ecx->v
+  |  copyslot BASE[dest], TOP[0]
+}
+
+static void jit_op_setupval(jit_State *J, int src, int uvidx)
+{
+  |  getLCL
+  |  mov UPVAL:ecx, LCL->upvals[uvidx]
+  |  mov TOP, UPVAL:ecx->v
+  |  // This is really copyslot TOP[0], BASE[src] with compare mixed in.
+  |   mov eax, BASE[src].tt
+  |   mov GCOBJECT:edx, BASE[src].value
+  |   mov TOP->tt, eax
+  |  cmp eax, LUA_TSTRING                               // iscollectable(val)?
+  |   mov eax, BASE[src].value.na[1]
+  |   mov TOP->value, GCOBJECT:edx
+  |   mov TOP->value.na[1], eax
+  |  jae >5
+  |4:
+  |.tail
+  |5:
+  |  test byte GCOBJECT:edx->gch.marked, WHITEBITS      // && iswhite(val)
+  |  jz <4
+  |  test byte UPVAL:ecx->marked, bitmask(BLACKBIT)     // && isblack(uv)
+  |  jz <4
+  |  call ->BARRIERF                                    // Yes, need barrier.
+  |  jmp <4
+  |.code
+
+  |.jsub BARRIERF                       // luaC_barrierf() with regparms.
+  |  mov ARG4, GCOBJECT:edx
+  |  mov ARG3, UPVAL:ecx
+  |  mov ARG2, L
+  |  jmp &luaC_barrierf                 // Chain to C code.
+  |.endjsub
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Optimized table lookup routines. Enter via jsub, fallback to C. */
+
+/* Fallback for GETTABLE_*. Temporary key is in L->env. */
+static void jit_gettable_fb(lua_State *L, Table *t, StkId dest)
+{
+  Table *mt = t->metatable;
+  const TValue *tm = luaH_getstr(mt, G(L)->tmname[TM_INDEX]);
+  if (ttisnil(tm)) {  /* No __index method? */
+    mt->flags |= 1<<TM_INDEX;  /* Cache this fact. */
+    setnilvalue(dest);
+  } else if (ttisfunction(tm)) {  /* __index function? */
+    ptrdiff_t destr = savestack(L, dest);
+    setobj2s(L, L->top, tm);
+    sethvalue(L, L->top+1, t);
+    setobj2s(L, L->top+2, &L->env);
+    luaD_checkstack(L, 3);
+    L->top += 3;
+    luaD_call(L, L->top - 3, 1);
+    dest = restorestack(L, destr);
+    L->top--;
+    setobjs2s(L, dest, L->top);
+  } else {  /* Let luaV_gettable() continue with the __index object. */
+    luaV_gettable(L, tm, &L->env, dest);
+  }
+
+  |//-----------------------------------------------------------------------
+  |.jsub GETGLOBAL                      // Lookup global variable.
+  |// Call with: TSTRING:edx (key), BASE (dest)
+  |  mov CI, L->ci
+  |  mov TOP, CI->func
+  |  mov LCL, TOP->value
+  |  mov TABLE:edi, LCL->env
+  |  jmp >9
+  |.endjsub
+  |
+  |//-----------------------------------------------------------------------
+  |.jsub GETTABLE_KSTR                  // Lookup constant string in table.
+  |// Call with: TOP (tab), TSTRING:edx (key), BASE (dest)
+  |  cmp dword TOP->tt, LUA_TTABLE
+  |   mov TABLE:edi, TOP->value
+  |  jne ->DEOPTIMIZE_CALLER            // Not a table? Deoptimize.
+  |
+  |// Common entry: TABLE:edi (tab), TSTRING:edx (key), BASE (dest)
+  |// Restores BASE, destroys eax, ecx, edx, edi (TOP).
+  |9:
+  |  movzx ecx, byte TABLE:edi->lsizenode       // hashstr(t, key).
+  |  mov eax, 1
+  |  shl eax, cl
+  |  dec eax
+  |  and eax, TSTRING:edx->tsv.hash
+  |  Nodemul NODE:eax
+  |  add NODE:eax, TABLE:edi->node
+  |
+  |1:  // Start of inner loop. Check node key.
+  |  cmp dword NODE:eax->i_key.nk.tt, LUA_TSTRING
+  |  jne >2
+  |  cmp aword NODE:eax->i_key.nk.value, TSTRING:edx
+  |  jne >2
+  |  // Note: swapping the two checks is faster, but valgrind complains.
+  |// Assumes: (int)&(((Node *)0)->i_val) == (int)&(((StkId)0)->value)
+  |
+  |// Ok, key found. Copy node value to destination (stack) slot.
+  |  mov ecx, NODE:eax->i_val.tt
+  |  test ecx, ecx; je >3                       // Node has nil value?
+  ||if (J->flags & JIT_F_CPU_SSE2) {
+  |  movq xmm0, qword NODE:eax->i_val.value
+  |  movq qword BASE->value, xmm0
+  ||} else {
+  |  mov edx, NODE:eax->i_val.value
+  |  mov edi, NODE:eax->i_val.value.na[1]
+  |  mov BASE->value, edx
+  |  mov BASE->value.na[1], edi
+  ||}
+  |  mov BASE->tt, ecx
+  |  mov BASE, L->base
+  |  ret
+  |2:
+  |  mov NODE:eax, NODE:eax->i_key.nk.next      // Get next key in chain.
+  |  test NODE:eax, NODE:eax
+  |  jnz <1                                     // Loop if non-NULL.
+  |
+  |  xor ecx, ecx
+  |3:
+  |  mov TABLE:eax, TABLE:edi->metatable
+  |  test TABLE:eax, TABLE:eax
+  |  jz >4                                      // No metatable?
+  |  test byte TABLE:eax->flags, 1<<TM_INDEX
+  |  jz >5                                      // Or 'no __index' flag set?
+  |4:
+  |  settt BASE[0], ecx                         // Yes, set to nil.
+  |  mov BASE, L->base
+  |  ret
+  |
+  |5:  // Otherwise chain to C code which eventually calls luaV_gettable.
+  |  setsvalue L->env, TSTRING:edx              // Use L->env as temp key.
+  |  mov ecx, [esp]
+  |  sub esp, FRAME_OFFSET
+  |  mov L->savedpc, ecx
+  |  call &jit_gettable_fb, L, TABLE:edi, BASE
+  |  add esp, FRAME_OFFSET
+  |  mov BASE, L->base
+  |  ret
+  |.endjsub
+  |
+  |//-----------------------------------------------------------------------
+  |.jsub GETTABLE_STR                   // Lookup string in table.
+  |// Call with: TOP (tab), TVALUE:ecx (key), BASE (dest)
+  |  mov eax, TOP->tt; shl eax, 4; or eax, TVALUE:ecx->tt
+  |  cmp eax, LUA_TTABLE_STR
+  |   mov TABLE:edi, TOP->value
+  |   mov TSTRING:edx, TVALUE:ecx->value
+  |  je <9                                      // Types ok? Continue above.
+  |  jmp ->DEOPTIMIZE_CALLER            // Otherwise deoptimize.
+  |.endjsub
+}
+
+/* Fallback for SETTABLE_*STR. Temporary (string) key is in L->env. */
+static void jit_settable_fb(lua_State *L, Table *t, StkId val)
+{
+  Table *mt = t->metatable;
+  const TValue *tm = luaH_getstr(mt, G(L)->tmname[TM_NEWINDEX]);
+  if (ttisnil(tm)) {  /* No __newindex method? */
+    mt->flags |= 1<<TM_NEWINDEX;  /* Cache this fact. */
+    t->flags = 0;  /* But need to clear the cache for the table itself. */
+    setobj2t(L, luaH_setstr(L, t, rawtsvalue(&L->env)), val);
+    luaC_barriert(L, t, val);
+  } else if (ttisfunction(tm)) {  /* __newindex function? */
+    setobj2s(L, L->top, tm);
+    sethvalue(L, L->top+1, t);
+    setobj2s(L, L->top+2, &L->env);
+    setobj2s(L, L->top+3, val);
+    luaD_checkstack(L, 4);
+    L->top += 4;
+    luaD_call(L, L->top - 4, 0);
+  } else {  /* Let luaV_settable() continue with the __newindex object. */
+    luaV_settable(L, tm, &L->env, val);
+  }
+
+  |//-----------------------------------------------------------------------
+  |.jsub BARRIERBACK                    // luaC_barrierback() with regparms.
+  |// Call with: TABLE:edi (table). Destroys ecx, edx.
+  |  mov GL:ecx, L->l_G
+  |   and byte TABLE:edi->marked, (~bitmask(BLACKBIT))&0xff
+  |  mov edx, GL:ecx->grayagain
+  |   mov GL:ecx->grayagain, TABLE:edi
+  |  mov TABLE:edi->gclist, edx
+  |  ret
+  |.endjsub
+  |
+  |//-----------------------------------------------------------------------
+  |.jsub SETGLOBAL                      // Set global variable.
+  |// Call with: TSTRING:edx (key), BASE (val)
+  |  mov CI, L->ci
+  |  mov TOP, CI->func
+  |  mov LCL, TOP->value
+  |  mov TABLE:edi, LCL->env
+  |  jmp >9
+  |.endjsub
+  |
+  |//-----------------------------------------------------------------------
+  |.jsub SETTABLE_KSTR                  // Set constant string entry in table.
+  |// Call with: TOP (tab), TSTRING:edx (key), BASE (val)
+  |  cmp dword TOP->tt, LUA_TTABLE
+  |   mov TABLE:edi, TOP->value
+  |  jne ->DEOPTIMIZE_CALLER            // Not a table? Deoptimize.
+  |
+  |// Common entry: TABLE:edi (tab), TSTRING:edx (key), BASE (val)
+  |// Restores BASE, destroys eax, ecx, edx, edi (TOP).
+  |9:
+  |  movzx ecx, byte TABLE:edi->lsizenode       // hashstr(t, key).
+  |  mov eax, 1
+  |  shl eax, cl
+  |  dec eax
+  |  and eax, TSTRING:edx->tsv.hash
+  |  Nodemul NODE:eax
+  |  add NODE:eax, TABLE:edi->node
+  |
+  |1:  // Start of inner loop. Check node key.
+  |  cmp dword NODE:eax->i_key.nk.tt, LUA_TSTRING
+  |  jne >4
+  |  cmp aword NODE:eax->i_key.nk.value, TSTRING:edx
+  |  jne >4
+  |  // Note: swapping the two checks is faster, but valgrind complains.
+  |
+  |// Ok, key found. Copy new value to node value.
+  |  cmp dword NODE:eax->i_val.tt, LUA_TNIL     // Previous value is nil?
+  |  je >6
+  |  // Assumes: (int)&(((Node *)0)->i_val) == (int)&(((StkId)0)->value)
+  |2:
+  |  mov byte TABLE:edi->flags, 0               // Clear metamethod cache.
+  |3:  // Target for SETTABLE_NUM below.
+  |  test byte TABLE:edi->marked, bitmask(BLACKBIT)  // isblack(table)
+  |  jnz >8                             // Unlikely, but set barrier back.
+  |7:  // Caveat: recycled label.
+  |  copyslot TVALUE:eax[0], BASE[0], ecx, edx, TOP
+  |  mov BASE, L->base
+  |  ret
+  |
+  |8:  // Avoid valiswhite() check -- black2gray(table) is ok.
+  |  call ->BARRIERBACK
+  |  jmp <7
+  |
+  |4:
+  |  mov NODE:eax, NODE:eax->i_key.nk.next      // Get next key in chain.
+  |  test NODE:eax, NODE:eax
+  |  jnz <1                                     // Loop if non-NULL.
+  |
+  |// Key not found. Add a new one, but check metatable first.
+  |  mov TABLE:ecx, TABLE:edi->metatable
+  |  test TABLE:ecx, TABLE:ecx
+  |  jz >5                                      // No metatable?
+  |  test byte TABLE:ecx->flags, 1<<TM_NEWINDEX
+  |  jz >7                                      // Or 'no __newindex' flag set?
+  |
+  |5:  // Add new key.
+  |  // No need for setting L->savedpc since only LUA_ERRMEM may be thrown.
+  |  lea TVALUE:eax, L->env
+  |  setsvalue TVALUE:eax[0], TSTRING:edx
+  |  sub esp, FRAME_OFFSET
+  |  call &luaH_newkey, L, TABLE:edi, TVALUE:eax
+  |  add esp, FRAME_OFFSET
+  |  jmp <2  // Copy to the returned value. See Node/TValue assumption above.
+  |
+  |6:  // Key found, but previous value is nil.
+  |  mov TABLE:ecx, TABLE:edi->metatable
+  |  test TABLE:ecx, TABLE:ecx
+  |  jz <2                                      // No metatable?
+  |  test byte TABLE:ecx->flags, 1<<TM_NEWINDEX
+  |  jnz <2                                     // Or 'no __newindex' flag set?
+  |
+  |7:  // Otherwise chain to C code which eventually calls luaV_settable.
+  |  setsvalue L->env, TSTRING:edx              // Use L->env as temp key.
+  |  mov ecx, [esp]
+  |  sub esp, FRAME_OFFSET
+  |  mov L->savedpc, ecx
+  |  call &jit_settable_fb, L, TABLE:edi, BASE
+  |  add esp, FRAME_OFFSET
+  |  mov BASE, L->base
+  |  ret
+  |.endjsub
+  |
+  |//-----------------------------------------------------------------------
+  |.jsub SETTABLE_STR                   // Set string entry in table.
+  |// Call with: TOP (tab), TVALUE:ecx (key), BASE (val)
+  |  mov eax, TOP->tt; shl eax, 4; or eax, TVALUE:ecx->tt
+  |  cmp eax, LUA_TTABLE_STR
+  |   mov TABLE:edi, TOP->value
+  |   mov TSTRING:edx, TVALUE:ecx->value
+  |  je <9                                      // Types ok? Continue above.
+  |  jmp ->DEOPTIMIZE_CALLER            // Otherwise deoptimize.
+  |.endjsub
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_newtable(jit_State *J, int dest, int lnarray, int lnhash)
+{
+  |  call &luaH_new, L, luaO_fb2int(lnarray), luaO_fb2int(lnhash)
+  |  sethvalue BASE[dest], eax
+  jit_checkGC(J);
+}
+
+static void jit_op_getglobal(jit_State *J, int dest, int kidx)
+{
+  const TValue *kk = &J->pt->k[kidx];
+  jit_assert(ttisstring(kk));
+  |  mov TSTRING:edx, &&kk->value.gc->ts
+  |  addidx BASE, dest
+  |  call ->GETGLOBAL
+}
+
+static void jit_op_setglobal(jit_State *J, int rval, int kidx)
+{
+  const TValue *kk = &J->pt->k[kidx];
+  jit_assert(ttisstring(kk));
+  |  mov TSTRING:edx, &&kk->value.gc->ts
+  |  addidx BASE, rval
+  |  call ->SETGLOBAL
+}
+
+enum { TKEY_KSTR = -2, TKEY_STR = -1, TKEY_ANY = 0 };
+
+/* Optimize key lookup depending on consts or hints type. */
+static int jit_keylookup(jit_State *J, int tab, int rkey)
+{
+  const TValue *tabt = hint_get(J, TYPE);
+  const TValue *key;
+  if (!ttistable(tabt)) return TKEY_ANY;  /* Not a table? Use fallback. */
+  key = ISK(rkey) ? &J->pt->k[INDEXK(rkey)] : hint_get(J, TYPEKEY);
+  if (ttisstring(key)) {  /* String key? */
+    if (ISK(rkey)) {
+      |  lea TOP, BASE[tab]
+      |  mov TSTRING:edx, &&key->value.gc->ts
+      return TKEY_KSTR;  /* Const string key. */
+    } else {
+      |  lea TOP, BASE[tab]
+      |  lea TVALUE:ecx, BASE[rkey]
+      return TKEY_STR;  /* Var string key. */
+    }
+  } else if (ttisnumber(key)) {  /* Number key? */
+    lua_Number n = nvalue(key);
+    int k;
+    lua_number2int(k, n);
+    if (!(k >= 1 && k < (1 << 26) && (lua_Number)k == n))
+      return TKEY_ANY;  /* Not a proper array key? Use fallback. */
+    if (ISK(rkey)) {
+      |  istable tab
+      |   mov TABLE:edi, BASE[tab].value
+      |  jne >9                                 // TYPE hint was wrong?
+      |  mov ecx, k                             // Needed for hash fallback.
+      |   mov TVALUE:eax, TABLE:edi->array
+      |  cmp ecx, TABLE:edi->sizearray; ja >5   // Not in array part?
+      return k;  /* Const array key (>= 1). */
+    } else {
+      |  mov eax, BASE[tab].tt; shl eax, 4; or eax, BASE[rkey].tt
+      |  cmp eax, LUA_TTABLE_NUM; jne >9        // TYPE/TYPEKEY hint was wrong?
+      if (J->flags & JIT_F_CPU_SSE2) {
+        |  movsd xmm0, qword BASE[rkey]
+        |  cvttsd2si eax, xmm0
+        |  cvtsi2sd xmm1, eax
+        |  dec eax
+        |  ucomisd xmm1, xmm0
+        |  mov TABLE:edi, BASE[tab].value
+        |  jne >9; jp >9                        // Not an integer? Deoptimize.
+      } else {
+        |// Annoying x87 stuff: check whether a number is an integer.
+        |// The latency of fist/fild is the real problem here.
+        |  fld qword BASE[rkey].value
+        |  fist dword TMP1
+        |  fild dword TMP1
+        |  fcomparepp                           // eax may be modified.
+        |  jne >9; jp >9                        // Not an integer? Deoptimize.
+        |  mov eax, TMP1
+        |  mov TABLE:edi, BASE[tab].value
+        |  dec eax
+      }
+      |  cmp eax, TABLE:edi->sizearray; jae >5  // Not in array part?
+      |  TValuemul eax
+      |  add eax, TABLE:edi->array
+      return 1;  /* Variable array key. */
+    }
+  }
+  return TKEY_ANY;  /* Use fallback. */
+}
+
+static void jit_op_gettable(jit_State *J, int dest, int tab, int rkey)
+{
+  int k = jit_keylookup(J, tab, rkey);
+  switch (k) {
+  case TKEY_KSTR:  /* Const string key. */
+    |  addidx BASE, dest
+    |  call ->GETTABLE_KSTR
+    break;
+  case TKEY_STR:  /* Variable string key. */
+    |  addidx BASE, dest
+    |  call ->GETTABLE_STR
+    break;
+  case TKEY_ANY:  /* Generic gettable fallback. */
+    if (ISK(rkey)) {
+      |  mov ecx, &&J->pt->k[INDEXK(rkey)]
+    } else {
+      |  lea ecx, BASE[rkey]
+    }
+    |  lea edx, BASE[tab]
+    |  addidx BASE, dest
+    |  mov L->savedpc, &J->nextins
+    |  call &luaV_gettable, L, edx, ecx, BASE
+    |  mov BASE, L->base
+    break;
+  default:  /* Array key. */
+    |// This is really copyslot BASE[dest], TVALUE:eax[k-1] mixed with compare.
+    |1:
+    |  mov edx, TVALUE:eax[k-1].tt
+    |  test edx, edx; je >6                     // Array has nil value?
+    if (J->flags & JIT_F_CPU_SSE2) {
+      |  movq xmm0, qword TVALUE:eax[k-1].value
+      |  movq qword BASE[dest].value, xmm0
+    } else {
+      |  mov ecx, TVALUE:eax[k-1].value
+      |  mov eax, TVALUE:eax[k-1].value.na[1]
+      |  mov BASE[dest].value, ecx
+      |  mov BASE[dest].value.na[1], eax
+    }
+    |2:
+    |  mov BASE[dest].tt, edx
+    |.tail
+    |5:  // Fallback to hash part. TABLE:edi is callee-saved.
+    if (ISK(rkey)) {
+      |  call ->GETTABLE_KNUM
+    } else {
+      |  call ->GETTABLE_NUM
+    }
+    |  jmp <1                                   // Slot is at TVALUE:eax[k-1].
+    |
+    |6:  // Shortcut for tables without an __index metamethod.
+    |  mov TABLE:ecx, TABLE:edi->metatable
+    |  test TABLE:ecx, TABLE:ecx
+    |  jz <2                                    // No metatable?
+    |  test byte TABLE:ecx->flags, 1<<TM_INDEX
+    |  jnz <2                                   // Or 'no __index' flag set?
+    |
+    |9:  // Otherwise deoptimize.
+    |  mov edx, &J->nextins
+    |  jmp ->DEOPTIMIZE
+    |.code
+    break;
+  }
+
+  |.jsub GETTABLE_KNUM          // Gettable fallback for const numeric keys.
+  |  mov TMP2, ecx                              // Save k.
+  |  sub esp, FRAME_OFFSET
+  |  call &luaH_getnum, TABLE:edi, ecx
+  |  add esp, FRAME_OFFSET
+  |  mov ecx, TMP2                              // Restore k.
+  |  TValuemul ecx
+  |  sub TVALUE:eax, ecx                // Compensate for TVALUE:eax[k-1].
+  |  add TVALUE:eax, #TVALUE
+  |  ret
+  |.endjsub
+  |
+  |.jsub GETTABLE_NUM           // Gettable fallback for variable numeric keys.
+  |  inc eax
+  |  mov ARG2, TABLE:edi                        // Really ARG1 and ARG2.
+  |  mov ARG3, eax
+  |  jmp &luaH_getnum                           // Chain to C code.
+  |.endjsub
+}
+
+static void jit_op_settable(jit_State *J, int tab, int rkey, int rval)
+{
+  const TValue *val = ISK(rval) ? &J->pt->k[INDEXK(rval)] : NULL;
+  int k = jit_keylookup(J, tab, rkey);
+  switch (k) {
+  case TKEY_KSTR:  /* Const string key. */
+  case TKEY_STR:  /* Variable string key. */
+    if (ISK(rval)) {
+      |  mov BASE, &val
+    } else {
+      |  addidx BASE, rval
+    }
+    if (k == TKEY_KSTR) {
+      |  call ->SETTABLE_KSTR
+    } else {
+      |  call ->SETTABLE_STR
+    }
+    break;
+  case TKEY_ANY:  /* Generic settable fallback. */
+    if (ISK(rkey)) {
+      |  mov ecx, &&J->pt->k[INDEXK(rkey)]
+    } else {
+      |  lea ecx, BASE[rkey]
+    }
+    if (ISK(rval)) {
+      |  mov edx, &val
+    } else {
+      |  lea edx, BASE[rval]
+    }
+    |  addidx BASE, tab
+    |  mov L->savedpc, &J->nextins
+    |  call &luaV_settable, L, BASE, ecx, edx
+    |  mov BASE, L->base
+    break;
+  default:  /* Array key. */
+    |1:
+    |  tvisnil TVALUE:eax[k-1]; je >6           // Previous value is nil?
+    |2:
+    |.tail
+    |5:  // Fallback to hash part. TABLE:edi is callee-saved.
+    if (ISK(rkey)) {
+      |  call ->SETTABLE_KNUM
+    } else {
+      |  call ->SETTABLE_NUM
+    }
+    |  jmp <1                                   // Slot is at TVALUE:eax[k-1].
+    |
+    |6:  // Shortcut for tables without a __newindex metamethod.
+    |  mov TABLE:ecx, TABLE:edi->metatable
+    |  test TABLE:ecx, TABLE:ecx
+    |  jz <2                                    // No metatable?
+    |  test byte TABLE:ecx->flags, 1<<TM_NEWINDEX
+    |  jnz <2                                   // Or 'no __newindex' flag set?
+    |
+    |9:  // Otherwise deoptimize.
+    |  mov edx, &J->nextins
+    |  jmp ->DEOPTIMIZE
+    |.code
+    if (!ISK(rval) || iscollectable(val)) {
+      |  test byte TABLE:edi->marked, bitmask(BLACKBIT)  // isblack(table)
+      |  jnz >7                         // Unlikely, but set barrier back.
+      |3:
+      |.tail
+      |7:  // Avoid valiswhite() check -- black2gray(table) is ok.
+      |  call ->BARRIERBACK
+      |  jmp <3
+      |.code
+    }
+    if (ISK(rval)) {
+      |  copyconst TVALUE:eax[k-1], val
+    } else {
+      |  copyslot TVALUE:eax[k-1], BASE[rval], ecx, edx, TOP
+    }
+    break;
+  }
+
+  |.jsub SETTABLE_KNUM          // Settable fallback for const numeric keys.
+  |  mov TMP2, ecx                              // Save k.
+  |  sub esp, FRAME_OFFSET
+  |  call &luaH_setnum, L, TABLE:edi, ecx
+  |  add esp, FRAME_OFFSET
+  |  mov ecx, TMP2                              // Restore k.
+  |  TValuemul ecx
+  |  sub TVALUE:eax, ecx                // Compensate for TVALUE:eax[k-1].
+  |  add TVALUE:eax, #TVALUE
+  |  ret
+  |.endjsub
+  |
+  |.jsub SETTABLE_NUM           // Settable fallback for variable numeric keys.
+  |  inc eax
+  |  mov ARG2, L                                // Really ARG1, ARG2 and ARG3.
+  |  mov ARG3, TABLE:edi
+  |  mov ARG4, eax
+  |  jmp &luaH_setnum                           // Chain to C code.
+  |.endjsub
+}
+
+static void jit_op_self(jit_State *J, int dest, int tab, int rkey)
+{
+  |  copyslot BASE[dest+1], BASE[tab]
+  jit_op_gettable(J, dest, tab, rkey);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_setlist(jit_State *J, int ra, int num, int batch)
+{
+  if (batch == 0) { batch = (int)(*J->nextins); J->combine++; }
+  batch = (batch-1)*LFIELDS_PER_FLUSH;
+  if (num == 0) {  /* Previous op was open and set TOP: {f()} or {...}. */
+    |  mov L->env.value, TOP            // Need to save TOP (edi).
+    |  lea eax, BASE[ra+1]
+    |  sub eax, TOP
+    |  neg eax
+    |  TValuediv eax                    // num = (TOP-ra-1)/sizeof(TValue).
+    |  mov TABLE:edi, BASE[ra].value
+    |  jz >4                            // Nothing to set?
+    if (batch > 0) {
+      |  add eax, batch
+    }
+    |  cmp dword TABLE:edi->sizearray, eax
+    |  jae >1                           // Skip resize if not needed.
+    |  // A resize is likely, so inline it.
+    |  call &luaH_resizearray, L, TABLE:edi, eax
+    |1:
+    |  test byte TABLE:edi->marked, bitmask(BLACKBIT)  // isblack(table)
+    |  mov edx, TABLE:edi->array
+    |  jnz >6                           // Unlikely, but set barrier back.
+    |  mov TOP, L->env.value
+    |
+    |.tail
+    |6:  // Avoid lots of valiswhite() checks -- black2gray(table) is ok.
+    |  call ->BARRIERBACK
+    |  jmp <1  // Need to reload edx.
+    |.code
+  } else {  /* Set fixed number of args. */
+    |  mov TABLE:edi, BASE[ra].value    // edi is callee-save.
+    |  cmp dword TABLE:edi->sizearray, batch+num
+    |  jb >5                            // Need to resize array?
+    |1:
+    |  test byte TABLE:edi->marked, bitmask(BLACKBIT)  // isblack(table)
+    |  mov edx, TABLE:edi->array
+    |  jnz >6                           // Unlikely, but set barrier back.
+    |  lea TOP, BASE[ra+1+num]          // Careful: TOP is edi.
+    |
+    |.tail
+    |5:  // A resize is unlikely (impossible?). NEWTABLE should've done it.
+    |  call &luaH_resizearray, L, TABLE:edi, batch+num
+    |  jmp <1
+    |6:  // Avoid lots of valiswhite() checks -- black2gray(table) is ok.
+    |  call ->BARRIERBACK
+    |  jmp <1  // Need to reload edx.
+    |.code
+  }
+  if (batch > 0) {
+    |  add edx, batch*#TVALUE           // edx = &t->array[(batch+1)-1]
+  }
+  |  lea ecx, BASE[ra+1]
+  |3:                                   // Copy stack slots to array.
+  |  mov eax, [ecx]
+  |  add ecx, aword*1
+  |  mov [edx], eax
+  |  add edx, aword*1
+  |  cmp ecx, TOP
+  |  jb <3
+  |
+  |4:
+  if (num == 0) {  /* Previous op was open. Restore L->top. */
+    |  lea TOP, BASE[J->pt->maxstacksize]  // Faster than getting L->ci->top.
+    |  mov L->top, TOP
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_arith(jit_State *J, int dest, int rkb, int rkc, int ev)
+{
+  const TValue *kkb = ISK(rkb) ? &J->pt->k[INDEXK(rkb)] : NULL;
+  const TValue *kkc = ISK(rkc) ? &J->pt->k[INDEXK(rkc)] : NULL;
+  const Value *kval;
+  int idx, rev;
+  int target = (ev == TM_LT || ev == TM_LE) ? jit_jmp_target(J) : 0;
+  int hastail = 0;
+
+  /* The bytecode compiler already folds constants except for: k/0, k%0, */
+  /* NaN results, k1<k2, k1<=k2. No point in optimizing these cases. */
+  if (ISK(rkb&rkc)) goto fallback;
+
+  /* Avoid optimization when non-numeric constants are present. */
+  if (kkb ? !ttisnumber(kkb) : (kkc && !ttisnumber(kkc))) goto fallback;
+
+  /* The TYPE hint selects numeric inlining and/or fallback encoding. */
+  switch (ttype(hint_get(J, TYPE))) {
+  case LUA_TNIL: hastail = 1; break;  /* No hint: numeric + fallback. */
+  case LUA_TNUMBER: break;            /* Numbers: numeric + deoptimization. */
+  default: goto fallback;             /* Mixed/other types: fallback only. */
+  }
+
+  /* The checks above ensure: at most one of the operands is a constant. */
+  /* Reverse operation and swap operands so the 2nd operand is a variable. */
+  if (kkc) { kval = &kkc->value; idx = rkb; rev = 1; }
+  else { kval = kkb ? &kkb->value : NULL; idx = rkc; rev = 0; }
+
+  /* Special handling for some operators. */
+  switch (ev) {
+  case TM_MOD:
+    /* Check for modulo with positive numbers, so we can use fprem. */
+    if (kval) {
+      if (kval->na[1] < 0) { hastail = 0; goto fallback; }  /* x%-k, -k%x */
+      |  isnumber idx
+      |   mov eax, BASE[idx].value.na[1]
+      |  jne L_DEOPTIMIZEF
+      |   test eax, eax; js L_DEOPTIMIZEF
+      |// This will trigger deoptimization in some benchmarks (pidigits).
+      |// But it's still a win.
+      if (kkb) {
+        |  fld qword BASE[rkc].value
+        |  fld qword [kval]
+      } else {
+        |  fld qword [kval]
+        |  fld qword BASE[rkb].value
+      }
+    } else {
+      |  isnumber2 rkb, rkc
+      |   mov eax, BASE[rkb].value.na[1]
+      |  jne L_DEOPTIMIZEF
+      |   or eax, BASE[rkc].value.na[1]; js L_DEOPTIMIZEF
+      |  fld qword BASE[rkc].value
+      |  fld qword BASE[rkb].value
+    }
+    |1: ; fprem; fnstsw ax; sahf; jp <1
+    |  fstp st1
+    goto fpstore;
+  case TM_POW:
+    if (hastail || !kval) break;  /* Avoid this if not optimizing. */
+    if (rev) {  /* x^k for k > 0, k integer. */
+      lua_Number n = kval->n;
+      int k;
+      lua_number2int(k, n);
+      /* All positive integers would work. But need to limit code explosion. */
+      if (k > 0 && k <= 65536 && (lua_Number)k == n) {
+        |  isnumber idx; jne L_DEOPTIMIZEF
+        |  fld qword BASE[idx]
+        for (; (k & 1) == 0; k >>= 1) {  /* Handle leading zeroes (2^k). */
+          |  fmul st0
+        }
+        if ((k >>= 1) != 0) {  /* Handle trailing bits. */
+          |  fld st0
+          |  fmul st0
+          for (; k != 1; k >>= 1) {
+            if (k & 1) {
+              |  fmul st1, st0
+            }
+            |  fmul st0
+          }
+          |  fmulp st1
+        }
+        goto fpstore;
+      }
+    } else if (kval->n > (lua_Number)0) {  /* k^x for k > 0. */
+      int log2kval[3];  /* Enough storage for a tword (80 bits). */
+      log2kval[2] = 0;  /* Avoid leaking garbage. */
+      /* Double precision log2(k) doesn't cut it (3^x != 3 for x = 1). */
+      ((void (*)(int *, double))J->jsub[JSUB_LOG2_TWORD])(log2kval, kval->n);
+      |  mov ARG1, log2kval[0]                  // Abuse stack for tword const.
+      |  mov ARG2, log2kval[1]
+      |  mov ARG3, log2kval[2]                  // TODO: store2load fwd stall.
+      |  isnumber idx; jne L_DEOPTIMIZEF
+      |  fld tword [esp]
+      |  fmul qword BASE[idx].value             // log2(k)*x
+      |  fld st0; frndint; fsub st1, st0; fxch  // Split into fract/int part.
+      |  f2xm1; fld1; faddp st1; fscale         // (2^fract-1 +1) << int.
+      |  fstp st1
+
+      |.jsub LOG2_TWORD         // Calculate log2(k) with max. precision.
+      |// Called with (int *ptr, double k).
+      |  fld1; fld FPARG2                       // Offset ok due to retaddr.
+      |  fyl2x
+      |  mov eax, ARG2                          // Really ARG1.
+      |  fstp tword [eax]
+      |  ret
+      |.endjsub
+      goto fpstore;
+    }
+    break;
+  }
+
+  /* Check number type and load 1st operand. */
+  if (kval) {
+    |  isnumber idx; jne L_DEOPTIMIZEF
+    |  loadnvaluek kval
+  } else {
+    if (rkb == rkc) {
+      |  isnumber rkb
+    } else {
+      |  isnumber2 rkb, rkc
+    }
+    |  jne L_DEOPTIMIZEF
+    |  fld qword BASE[rkb].value
+  }
+
+  /* Encode arithmetic operation with 2nd operand. */
+  switch ((ev<<1)+rev) {
+  case TM_ADD<<1: case (TM_ADD<<1)+1:
+    if (rkb == rkc) {
+      |  fadd st0
+    } else {
+      |  fadd qword BASE[idx].value
+    }
+    break;
+  case TM_SUB<<1:
+    |  fsub qword BASE[idx].value
+    break;
+  case (TM_SUB<<1)+1:
+    |  fsubr qword BASE[idx].value
+    break;
+  case TM_MUL<<1: case (TM_MUL<<1)+1:
+    if (rkb == rkc) {
+      |  fmul st0
+    } else {
+      |  fmul qword BASE[idx].value
+    }
+    break;
+  case TM_DIV<<1:
+    |  fdiv qword BASE[idx].value
+    break;
+  case (TM_DIV<<1)+1:
+    |  fdivr qword BASE[idx].value
+    break;
+  case TM_POW<<1:
+    |  sub esp, S2LFRAME_OFFSET
+    |  fstp FPARG1
+    |  fld qword BASE[idx].value
+    |  fstp FPARG2
+    |  call &pow
+    |  add esp, S2LFRAME_OFFSET
+    break;
+  case (TM_POW<<1)+1:
+    |  sub esp, S2LFRAME_OFFSET
+    |  fstp FPARG2
+    |  fld qword BASE[idx].value
+    |  fstp FPARG1
+    |  call &pow
+    |  add esp, S2LFRAME_OFFSET
+    break;
+  case TM_UNM<<1: case (TM_UNM<<1)+1:
+    |  fchs                             // No 2nd operand.
+    break;
+  default:  /* TM_LT or TM_LE. */
+    |  fld qword BASE[idx].value
+    |  fcomparepp
+    |  jp =>dest?(J->nextpc+1):target   // Unordered means false.
+    jit_assert(dest == 0 || dest == 1);  /* Really cond. */
+    switch (((rev^dest)<<1)+(dest^(ev == TM_LT))) {
+    case 0:
+      |  jb =>target
+      break;
+    case 1:
+      |  jbe =>target
+      break;
+    case 2:
+      |  ja =>target
+      break;
+    case 3:
+      |  jae =>target
+      break;
+    }
+    goto skipstore;
+  }
+fpstore:
+  /* Store result and set result type (if necessary). */
+  |  fstp qword BASE[dest].value
+  if (dest != rkb && dest != rkc) {
+    |  settt BASE[dest], LUA_TNUMBER
+  }
+
+skipstore:
+  if (!hastail) {
+    jit_deopt_target(J, 0);
+    return;
+  }
+
+  |4:
+  |.tail
+  |L_DEOPTLABEL:  // Recycle as fallback label.
+
+fallback:
+  /* Generic fallback for arithmetic ops. */
+  if (kkb) {
+    |  mov ecx, &kkb
+  } else {
+    |  lea ecx, BASE[rkb]
+  }
+  if (kkc) {
+    |  mov edx, &kkc
+  } else {
+    |  lea edx, BASE[rkc]
+  }
+  if (target) {  /* TM_LT or TM_LE. */
+    |  mov L->savedpc, &(J->nextins+1)
+    |  call &ev==TM_LT?luaV_lessthan:luaV_lessequal, L, ecx, edx
+    |  test eax, eax
+    |  mov BASE, L->base
+    if (dest) {  /* cond */
+      |  jnz =>target
+    } else {
+      |  jz =>target
+    }
+  } else {
+    |  addidx BASE, dest
+    |  mov L->savedpc, &J->nextins
+    |  call &luaV_arith, L, BASE, ecx, edx, ev
+    |  mov BASE, L->base
+  }
+
+  if (hastail) {
+    | jmp <4
+    |.code
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_fallback_len(lua_State *L, StkId ra, const TValue *rb)
+{
+  switch (ttype(rb)) {
+  case LUA_TTABLE:
+    setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));
+    break;
+  case LUA_TSTRING:
+    setnvalue(ra, cast_num(tsvalue(rb)->len));
+    break;
+  default: {
+    const TValue *tm = luaT_gettmbyobj(L, rb, TM_LEN);
+    if (ttisfunction(tm)) {
+      ptrdiff_t rasave = savestack(L, ra);
+      setobj2s(L, L->top, tm);
+      setobj2s(L, L->top+1, rb);
+      luaD_checkstack(L, 2);
+      L->top += 2;
+      luaD_call(L, L->top - 2, 1);
+      ra = restorestack(L, rasave);
+      L->top--;
+      setobjs2s(L, ra, L->top);
+    } else {
+      luaG_typeerror(L, rb, "get length of");
+    }
+    break;
+  }
+  }
+}
+
+static void jit_op_len(jit_State *J, int dest, int rb)
+{
+  switch (ttype(hint_get(J, TYPE))) {
+  case LUA_TTABLE:
+    jit_deopt_target(J, 0);
+    |   istable rb
+    |  mov TABLE:ecx, BASE[rb].value
+    |   jne L_DEOPTIMIZE                // TYPE hint was wrong?
+    |  call &luaH_getn, TABLE:ecx
+    |  mov TMP1, eax
+    |  fild dword TMP1
+    |  fstp qword BASE[dest].value
+    |  settt BASE[dest], LUA_TNUMBER
+    break;
+  case LUA_TSTRING:
+    jit_deopt_target(J, 0);
+    |   isstring rb
+    |  mov TSTRING:ecx, BASE[rb].value
+    |   jne L_DEOPTIMIZE                // TYPE hint was wrong?
+    |  fild aword TSTRING:ecx->tsv.len  // size_t
+    |  fstp qword BASE[dest].value
+    |  settt BASE[dest], LUA_TNUMBER
+    break;
+  default:
+    |  lea TVALUE:ecx, BASE[rb]
+    |  addidx BASE, dest
+    |  mov L->savedpc, &J->nextins
+    |  call &jit_fallback_len, L, BASE, TVALUE:ecx
+    |  mov BASE, L->base
+    break;
+  }
+}
+
+static void jit_op_not(jit_State *J, int dest, int rb)
+{
+  /* l_isfalse() without a branch -- truly devious. */
+  /* ((value & tt) | (tt>>1)) is only zero for nil/false. */
+  /* Assumes: LUA_TNIL == 0, LUA_TBOOLEAN == 1, bvalue() == 0/1 */
+  |  mov eax, BASE[rb].tt
+  |  mov ecx, BASE[rb].value
+  |  mov edx, 1
+  |  and ecx, eax
+  |  shr eax, 1
+  |  or ecx, eax
+  |  xor eax, eax
+  |  cmp ecx, edx
+  |  adc eax, eax
+  |  mov BASE[dest].tt, edx
+  |  mov BASE[dest].value, eax
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_concat(jit_State *J, int dest, int first, int last)
+{
+  int num = last-first+1;
+  if (num == 2 && ttisstring(hint_get(J, TYPE))) {  /* Optimize common case. */
+    |  addidx BASE, first
+    |  call ->CONCAT_STR2
+    |  setsvalue BASE[dest], eax
+  } else {  /* Generic fallback. */
+    |  mov L->savedpc, &J->nextins
+    |  call &luaV_concat, L, num, last
+    |  mov BASE, L->base
+    if (dest != first) {
+      |  copyslot BASE[dest], BASE[first]
+    }
+  }
+  jit_checkGC(J);  /* Always do this, even for the optimized variant. */
+
+  |.jsub CONCAT_STR2                    // Concatenate two strings.
+  |// Call with: BASE (first). Destroys all regs. L and BASE restored.
+  |  mov ARG2, L                        // Save L (esi).
+  |  mov eax, BASE[0].tt; shl eax, 4; or eax, BASE[1].tt
+  |  sub eax, LUA_TSTR_STR              // eax = 0 on success.
+  |  jne ->DEOPTIMIZE_CALLER    // Wrong types? Deoptimize.
+  |
+  |1:
+  |   mov GL:edi, L->l_G
+  |  mov TSTRING:esi, BASE[0].value     // Caveat: L (esi) is gone now!
+  |  mov TSTRING:edx, BASE[1].value
+  |  mov ecx, TSTRING:esi->tsv.len      // size_t
+  |  test ecx, ecx
+  |  jz >2                              // 1st string is empty?
+  |  or eax, TSTRING:edx->tsv.len       // eax is known to be zero.
+  |  jz >4                              // 2nd string is empty?
+  |  add eax, ecx
+  |  jc >9                              // Length overflow?
+  |  cmp eax, GL:edi->buff.buffsize     // size_t
+  |  ja >5                              // Temp buffer overflow?
+  |  mov edi, GL:edi->buff.buffer
+  |  add esi, #TSTRING
+  |  rep; movsb                         // Copy first string.
+  |  mov ecx, TSTRING:edx->tsv.len
+  |  lea esi, TSTRING:edx[1]
+  |  rep; movsb                         // Copy second string.
+  |
+  |  sub edi, eax                       // start = end - total.
+  |   mov L, ARG2                       // Restore L (esi). Reuse as 1st arg.
+  |  mov ARG3, edi
+  |  mov ARG4, eax
+  |   mov BASE, L->base                 // Restore BASE.
+  |  jmp &luaS_newlstr
+  |
+  |2:  // 1st string is empty.
+  |  mov eax, TSTRING:edx               // Return 2nd string.
+  |3:
+  |  mov L, ARG2                        // Restore L (esi) and BASE.
+  |  mov BASE, L->base
+  |  ret
+  |
+  |4:  // 2nd string is empty.
+  |  mov eax, TSTRING:esi               // Return 1st string.
+  |  jmp <3
+  |
+  |5:  // Resize temp buffer.
+  |  // No need for setting L->savedpc since only LUA_ERRMEM may be thrown.
+  |  mov L, ARG2                        // Restore L.
+  |  lea ecx, GL:edi->buff
+  |  sub esp, FRAME_OFFSET
+  |  call &luaZ_openspace, L, ecx, eax
+  |  add esp, FRAME_OFFSET
+  |  xor eax, eax                       // BASE (first) and L saved. eax = 0.
+  |  jmp <1                             // Just restart.
+  |
+  |9:  // Length overflow errors are rare (> 2 GB string required).
+  |  mov L, ARG2                        // Need L for deoptimization.
+  |  jmp ->DEOPTIMIZE_CALLER
+  |.endjsub
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_eq(jit_State *J, int cond, int rkb, int rkc)
+{
+  int target = jit_jmp_target(J);
+  int condtarget = cond ? (J->nextpc+1) : target;
+  jit_assert(cond == 0 || cond == 1);
+
+  /* Comparison of two constants. Evaluate at compile time. */
+  if (ISK(rkb&rkc)) {
+    if ((rkb == rkc) == cond) {  /* Constants are already unique. */
+      |  jmp =>target
+    }
+    return;
+  }
+
+  if (ISK(rkb|rkc)) {  /* Compare a variable and a constant. */
+    const TValue *kk;
+    if (ISK(rkb)) { int t = rkc; rkc = rkb; rkb = t; }  /* rkc holds const. */
+    kk = &J->pt->k[INDEXK(rkc)];
+    switch (ttype(kk)) {
+    case LUA_TNIL:
+      |  isnil rkb
+      break;
+    case LUA_TBOOLEAN:
+      if (bvalue(kk)) {
+        |  mov eax, BASE[rkb].tt
+        |  mov ecx, BASE[rkb].value
+        |  dec eax
+        |  dec ecx
+        |  or eax, ecx
+      } else {
+        |  mov eax, BASE[rkb].tt
+        |  dec eax
+        |  or eax, BASE[rkb].value
+      }
+      break;
+    case LUA_TNUMBER:
+      |// Note: bitwise comparison is not faster (and needs to handle -0 == 0).
+      |  isnumber rkb
+      |  jne =>condtarget
+      |  fld qword BASE[rkb].value
+      |  fld qword [&kk->value]
+      |  fcomparepp
+      |  jp =>condtarget  // Unordered means not equal.
+      break;
+    case LUA_TSTRING:
+      |  isstring rkb
+      |  jne =>condtarget
+      |  cmp aword BASE[rkb].value, &rawtsvalue(kk)
+      break;
+    default: jit_assert(0); break;
+    }
+  } else {  /* Compare two variables. */
+    |  mov eax, BASE[rkb].tt
+    |  cmp eax, BASE[rkc].tt
+    |  jne =>condtarget
+    switch (ttype(hint_get(J, TYPE))) {
+    case LUA_TNUMBER:
+      jit_deopt_target(J, 0);
+      |// Note: bitwise comparison is not an option (-0 == 0, NaN ~= NaN).
+      |  cmp eax, LUA_TNUMBER; jne L_DEOPTIMIZE
+      |  fld qword BASE[rkb].value
+      |  fld qword BASE[rkc].value
+      |  fcomparepp
+      |  jp =>condtarget  // Unordered means not equal.
+      break;
+    case LUA_TSTRING:
+      jit_deopt_target(J, 0);
+      |  cmp eax, LUA_TSTRING; jne L_DEOPTIMIZE
+      |  mov ecx, BASE[rkb].value
+      |  cmp ecx, BASE[rkc].value
+      break;
+    default:
+      |// Generic equality comparison fallback.
+      |  lea edx, BASE[rkc]
+      |  lea ecx, BASE[rkb]
+      |  mov L->savedpc, &J->nextins
+      |  call &luaV_equalval, L, ecx, edx
+      |  dec eax
+      |  mov BASE, L->base
+      break;
+    }
+  }
+  if (cond) {
+    |  je =>target
+  } else {
+    |  jne =>target
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_test(jit_State *J, int cond, int dest, int src)
+{
+  int target = jit_jmp_target(J);
+
+  /* l_isfalse() without a branch. But this time preserve tt/value. */
+  /* (((value & tt) * 2 + tt) >> 1) is only zero for nil/false. */
+  /* Assumes: 3*tt < 2^32, LUA_TNIL == 0, LUA_TBOOLEAN == 1, bvalue() == 0/1 */
+  |  mov eax, BASE[src].tt
+  |  mov ecx, BASE[src].value
+  |  mov edx, eax
+  |  and edx, ecx
+  |  lea edx, [eax+edx*2]
+  |  shr edx, 1
+
+  /* Check if we can omit the stack copy. */
+  if (dest == src) {  /* Yes, invert branch condition. */
+    if (cond) {
+      |  jnz =>target
+    } else {
+      |  jz =>target
+    }
+  } else {  /* No, jump around copy code. */
+    if (cond) {
+      |  jz >1
+    } else {
+      |  jnz >1
+    }
+    |  mov edx, BASE[src].value.na[1]
+    |  mov BASE[dest].tt, eax
+    |  mov BASE[dest].value, ecx
+    |  mov BASE[dest].value.na[1], edx
+    |  jmp =>target
+    |1:
+  }
+}
+
+static void jit_op_jmp(jit_State *J, int target)
+{
+  |  jmp =>target
+}
+
+/* ------------------------------------------------------------------------ */
+
+enum { FOR_IDX, FOR_LIM, FOR_STP, FOR_EXT };
+
+static const char *const jit_for_coerce_error[] = {
+  LUA_QL("for") " initial value must be a number",
+  LUA_QL("for") " limit must be a number",
+  LUA_QL("for") " step must be a number",
+};
+
+/* Try to coerce for slots with strings to numbers in place or complain. */
+static void jit_for_coerce(lua_State *L, TValue *o)
+{
+  int i;
+  for (i = FOR_IDX; i <= FOR_STP; i++, o++) {
+    lua_Number num;
+    if (ttisnumber(o)) continue;
+    if (ttisstring(o) && luaO_str2d(svalue(o), &num)) {
+      setnvalue(o, num);
+    } else {
+      luaG_runerror(L, jit_for_coerce_error[i]);
+    }
+  }
+}
+
+static void jit_op_forprep(jit_State *J, int ra, int target)
+{
+  const TValue *step = hint_get(J, FOR_STEP_K);
+  if (ttisnumber(step)) {
+    |  isnumber2 ra+FOR_IDX, ra+FOR_LIM; jne L_DEOPTIMIZEF
+    |4:
+    |  fld qword BASE[ra+FOR_LIM].value // [lim]
+    |  fld qword BASE[ra+FOR_IDX].value // [idx lim]
+    |  fst qword BASE[ra+FOR_EXT].value // extidx = idx
+    |  fcomparepp                       // idx >< lim ?
+    |  settt BASE[ra+FOR_EXT], LUA_TNUMBER
+    if (nvalue(step) < (lua_Number)0) {
+      |  jb =>target+1                  // step < 0 && idx < lim: skip loop.
+    } else {
+      |  ja =>target+1                  // step >= 0 && idx > lim: skip loop.
+    }
+  } else {
+    |4:
+    |  isnumber3 ra+FOR_IDX, ra+FOR_LIM, ra+FOR_STP
+    |   mov eax, BASE[ra+FOR_STP].value.na[1]   // Sign bit is in hi dword.
+    |  jne L_DEOPTIMIZEF
+    |  fld qword BASE[ra+FOR_LIM].value // [lim]        (FP stack notation)
+    |  fld qword BASE[ra+FOR_IDX].value // [idx lim]
+    |  test eax, eax                    // step >< 0 ?
+    |  fst qword BASE[ra+FOR_EXT].value // extidx = idx
+    |  js >1
+    |  fxch                             // if (step > 0) [lim idx]
+    |1:
+    |  fcomparepp                       // step > 0 ? lim < idx : idx < lim
+    |  settt BASE[ra+FOR_EXT], LUA_TNUMBER
+    |  jb =>target+1                    // Skip loop.
+  }
+  if (ttisnumber(hint_get(J, TYPE))) {
+    jit_deopt_target(J, 0);
+  } else {
+    |.tail
+    |L_DEOPTLABEL:  // Recycle as fallback label.
+    |  // Fallback for strings as loop vars. No need to make this fast.
+    |  lea eax, BASE[ra]
+    |  mov L->savedpc, &J->nextins
+    |  call &jit_for_coerce, L, eax     // Coerce strings or throw error.
+    |  jmp <4                           // Easier than reloading eax.
+    |.code
+  }
+}
+
+static void jit_op_forloop(jit_State *J, int ra, int target)
+{
+  const TValue *step = hint_getpc(J, FOR_STEP_K, target-1);
+  if (ttisnumber(step)) {
+    |  fld qword BASE[ra+FOR_LIM].value // [lim]        (FP stack notation)
+    |  fld qword BASE[ra+FOR_IDX].value // [idx lim]
+    |  fadd qword BASE[ra+FOR_STP].value // [nidx lim]
+    |  fst qword BASE[ra+FOR_EXT].value // extidx = nidx
+    |  fst qword BASE[ra+FOR_IDX].value // idx = nidx
+    |  settt BASE[ra+FOR_EXT], LUA_TNUMBER
+    |  fcomparepp                       // nidx >< lim ?
+    if (nvalue(step) < (lua_Number)0) {
+      |  jae =>target                   // step < 0 && nidx >= lim: loop again.
+    } else {
+      |  jbe =>target                   // step >= 0 && nidx <= lim: loop again.
+    }
+  } else {
+    |  mov eax, BASE[ra+FOR_STP].value.na[1]    // Sign bit is in hi dword.
+    |  fld qword BASE[ra+FOR_LIM].value // [lim]        (FP stack notation)
+    |  fld qword BASE[ra+FOR_IDX].value // [idx lim]
+    |  fld qword BASE[ra+FOR_STP].value // [stp idx lim]
+    |  faddp st1                        // [nidx lim]
+    |  fst qword BASE[ra+FOR_IDX].value // idx = nidx
+    |  fst qword BASE[ra+FOR_EXT].value // extidx = nidx
+    |  settt BASE[ra+FOR_EXT], LUA_TNUMBER
+    |  test eax, eax                    // step >< 0 ?
+    |  js >1
+    |  fxch                             // if (step > 0) [lim nidx]
+    |1:
+    |  fcomparepp                       // step > 0 ? lim >= nidx : nidx >= lim
+    |  jae =>target                     // Loop again.
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_tforloop(jit_State *J, int ra, int nresults)
+{
+  int target = jit_jmp_target(J);
+  int i;
+  if (jit_inline_tforloop(J, ra, nresults, target)) return;  /* Inlined? */
+  for (i = 2; i >= 0; i--) {
+    |  copyslot BASE[ra+i+3], BASE[ra+i]  // Copy ctlvar/state/callable.
+  }
+  jit_op_call(J, ra+3, 2, nresults);
+  |  isnil ra+3; je >1
+  |  copyslot BASE[ra+2], BASE[ra+3]    // Save control variable.
+  |  jmp =>target
+  |1:
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_close(jit_State *J, int ra)
+{
+  if (ra) {
+    |  lea eax, BASE[ra]
+    |  mov ARG2, eax
+  } else {
+    |  mov ARG2, BASE
+  }
+  |  call &luaF_close, L  // , StkId level (ARG2)
+}
+
+static void jit_op_closure(jit_State *J, int dest, int ptidx)
+{
+  Proto *npt = J->pt->p[ptidx];
+  int nup = npt->nups;
+  |  getLCL edi                         // LCL:edi is callee-saved.
+  |  mov edx, LCL:edi->env
+  |  call &luaF_newLclosure, L, nup, edx
+  |  mov LCL->p, &npt                   // Store new proto in returned closure.
+  |  mov aword BASE[dest].value, LCL    // setclvalue()
+  |  settt BASE[dest], LUA_TFUNCTION
+  /* Process pseudo-instructions for upvalues. */
+  if (nup > 0) {
+    const Instruction *uvcode = J->nextins;
+    int i, uvuv;
+    /* Check which of the two types we need. */
+    for (i = 0, uvuv = 0; i < nup; i++)
+      if (GET_OPCODE(uvcode[i]) == OP_GETUPVAL) uvuv++;
+    /* Copy upvalues from parent first. */
+    if (uvuv) {
+      /* LCL:eax->upvals (new closure) <-- LCL:edi->upvals (own closure). */
+      for (i = 0; i < nup; i++)
+        if (GET_OPCODE(uvcode[i]) == OP_GETUPVAL) {
+          |  mov UPVAL:edx, LCL:edi->upvals[GETARG_B(uvcode[i])]
+          |  mov LCL->upvals[i], UPVAL:edx
+        }
+    }
+    /* Next find or create upvalues for our own stack slots. */
+    if (nup > uvuv) {
+      |  mov LCL:edi, LCL  // Move new closure to callee-save register. */
+      /* LCL:edi->upvals (new closure) <-- upvalue for stack slot. */
+      for (i = 0; i < nup; i++)
+        if (GET_OPCODE(uvcode[i]) == OP_MOVE) {
+          int rb = GETARG_B(uvcode[i]);
+          if (rb) {
+            |  lea eax, BASE[rb]
+            |  mov ARG2, eax
+          } else {
+            |  mov ARG2, BASE
+          }
+          |  call &luaF_findupval, L  // , StkId level (ARG2)
+          |  mov LCL:edi->upvals[i], UPVAL:eax
+        }
+    }
+    J->combine += nup;  /* Skip pseudo-instructions. */
+  }
+  jit_checkGC(J);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_vararg(jit_State *J, int dest, int num)
+{
+  if (num < 0) {  /* Copy all varargs. */
+    |// Copy [ci->func+1+pt->numparams, BASE) -> [BASE+dest, *).
+    |1:
+    |  mov CI, L->ci
+    |  mov edx, CI->func
+    |  add edx, (1+J->pt->numparams)*#TVALUE  // Start of varargs.
+    |
+    |  // luaD_checkstack(L, nvararg) with nvararg = L->base - vastart.
+    |  // This is a slight overallocation (BASE[dest+nvararg] would be enough).
+    |  // We duplicate OP_VARARG behaviour so we can use luaD_growstack().
+    |  lea eax, [BASE+BASE+J->pt->maxstacksize*#TVALUE]  // L->base + L->top
+    |  sub eax, edx                     // L->top + (L->base - vastart)
+    |  cmp eax, L->stack_last
+    |  jae >5                           // Need to grow stack?
+    |
+    |  lea TOP, BASE[dest]
+    |  cmp edx, BASE
+    |  jnb >3
+    |2:  // Copy loop.
+    |  mov eax, [edx]
+    |  add edx, aword*1
+    |  mov [TOP], eax
+    |  add TOP, aword*1
+    |  cmp edx, BASE
+    |  jb <2
+    |3:
+    |// This is an open ins. Must keep TOP for next instruction.
+    |
+    |.tail
+    |5:  // Grow stack for varargs.
+    |  sub eax, L->top
+    |  TValuediv eax
+    |  call &luaD_growstack, L, eax
+    |  mov BASE, L->base
+    |  jmp <1  // Just restart op to avoid saving/restoring regs.
+    |.code
+  } else if (num > 0) {  /* Copy limited number of varargs. */
+    |// Copy [ci->func+1+pt->numparams, BASE) -> [BASE+dest, BASE+dest+num).
+    |  mov CI, L->ci
+    |  mov edx, CI->func
+    |  add edx, (1+J->pt->numparams)*#TVALUE
+    |  lea TOP, BASE[dest]
+    |  lea ecx, BASE[dest+num]
+    |  cmp edx, BASE                    // No varargs present: only fill.
+    |  jnb >2
+    |
+    |1:  // Copy loop.
+    |  mov eax, [edx]
+    |  add edx, aword*1
+    |  mov [TOP], eax
+    |  add TOP, aword*1
+    |  cmp TOP, ecx                     // Stop if all dest slots got a vararg.
+    |  jnb >4
+    |  cmp edx, BASE                    // Continue if more varargs present.
+    |  jb <1
+    |
+    |2:                                 // Fill remaining slots with nils.
+    |  xor eax, eax                     // Assumes: LUA_TNIL == 0
+    |3:  // Fill loop.
+    |  settt TOP[0], eax
+    |  add TOP, #TVALUE
+    |  cmp TOP, ecx
+    |  jb <3
+    |4:
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_x86.dash b/libraries/LuaJIT-1.1.7/src/ljit_x86.dash
new file mode 100644
index 0000000..432e1c8
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_x86.dash
@@ -0,0 +1,297 @@
+|//
+|// Common DynASM definitions and macros for x86 CPUs.
+|// Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
+|//
+|
+|// Standard DynASM declarations.
+|.arch x86
+|.section code, deopt, tail, mfmap
+|
+|// Type definitions with (almost) global validity.
+|.type L,               lua_State,      esi     // L.
+|.type BASE,            TValue,         ebx     // L->base.
+|.type TOP,             TValue,         edi     // L->top (calls/open ops).
+|.type CI,              CallInfo,       ecx     // L->ci (calls, locally).
+|.type LCL,             LClosure,       eax     // func->value (calls).
+|
+|// Type definitions with local validity.
+|.type GL,              global_State
+|.type TVALUE,          TValue
+|.type VALUE,           Value
+|.type CINFO,           CallInfo
+|.type GCOBJECT,        GCObject
+|.type TSTRING,         TString
+|.type TABLE,           Table
+|.type CCLOSURE,        CClosure
+|.type PROTO,           Proto
+|.type UPVAL,           UpVal
+|.type NODE,            Node
+|
+|// Definitions copied to DynASM domain to avoid unnecessary constant args.
+|// CHECK: must match with the definitions in lua.h!
+|.define LUA_TNIL,              0
+|.define LUA_TBOOLEAN,          1
+|.define LUA_TLIGHTUSERDATA,    2
+|.define LUA_TNUMBER,           3
+|.define LUA_TSTRING,           4
+|.define LUA_TTABLE,            5
+|.define LUA_TFUNCTION,         6
+|.define LUA_TUSERDATA,         7
+|.define LUA_TTHREAD,           8
+|
+|.define LUA_TNUM_NUM,          0x33
+|.define LUA_TNUM_NUM_NUM,      0x333
+|.define LUA_TSTR_STR,          0x44
+|.define LUA_TSTR_NUM,          0x43
+|.define LUA_TSTR_NUM_NUM,      0x433
+|.define LUA_TTABLE_NUM,        0x53
+|.define LUA_TTABLE_STR,        0x54
+|
+|// Macros to test, set and copy stack slots.
+|.macro istt, idx, tp;  cmp dword BASE[idx].tt, tp; .endmacro
+|.macro isnil, idx;  istt idx, LUA_TNIL; .endmacro
+|.macro isnumber, idx;  istt idx, LUA_TNUMBER; .endmacro
+|.macro isstring, idx;  istt idx, LUA_TSTRING; .endmacro
+|.macro istable, idx;  istt idx, LUA_TTABLE; .endmacro
+|.macro isfunction, idx;  istt idx, LUA_TFUNCTION; .endmacro
+|
+|.macro isnumber2, idx1, idx2, reg
+|  mov reg, BASE[idx1].tt;  shl reg, 4;  or reg, BASE[idx2].tt
+|  cmp reg, LUA_TNUM_NUM
+|.endmacro
+|.macro isnumber2, idx1, idx2; isnumber2, idx1, idx2, eax; .endmacro
+|
+|.macro isnumber3, idx1, idx2, idx3, reg
+|  mov reg, BASE[idx1].tt;  shl reg, 4;  or reg, BASE[idx2].tt
+|  shl reg, 4;  or reg, BASE[idx3].tt;  cmp reg, LUA_TNUM_NUM_NUM
+|.endmacro
+|.macro isnumber3, idx1, idx2, idx3; isnumber3, idx1, idx2, idx3, eax; .endmacro
+|
+|.macro tvisnil, tv;  cmp dword tv.tt, LUA_TNIL; .endmacro
+|
+|.macro settt, tv, tp;  mov dword tv.tt, tp; .endmacro
+|.macro setnilvalue, tv;  settt tv, LUA_TNIL; .endmacro
+|
+|.macro setbvalue, tv, val              // May use edx.
+||if (val) {  /* true */
+|   mov edx, LUA_TBOOLEAN
+|   mov dword tv.value, edx             // Assumes: LUA_TBOOLEAN == 1
+|   settt tv, edx
+||} else {  /* false */
+|   mov dword tv.value, 0
+|   settt tv, LUA_TBOOLEAN
+||}
+|.endmacro
+|
+|.macro loadnvaluek, vptr
+||if ((vptr)->n == (lua_Number)0) {
+|  fldz
+||} else if ((vptr)->n == (lua_Number)1) {
+|  fld1
+||} else {
+|  fld qword [vptr]
+||}
+|.endmacro
+|
+|.macro setnvaluek, tv, vptr            // Pass a Value *! With permanent addr.
+|  // SSE2 does not pay off here (I tried).
+|  loadnvaluek vptr
+|  fstp qword tv.value
+|  settt tv, LUA_TNUMBER
+|.endmacro
+|
+|.macro setnvalue, tv, vptr             // Pass a Value *! Temporary ok.
+|  mov dword tv.value, (vptr)->na[0]
+|  mov dword tv.value.na[1], (vptr)->na[1]
+|  settt tv, LUA_TNUMBER
+|.endmacro
+|
+|.macro setsvalue, tv, vptr
+|  mov aword tv.value, vptr
+|  settt tv, LUA_TSTRING
+|.endmacro
+|
+|.macro sethvalue, tv, vptr
+|  mov aword tv.value, vptr
+|  settt tv, LUA_TTABLE
+|.endmacro
+|
+|.macro copyslotSSE, D, S, R1           // May use xmm0.
+|  mov R1, S.tt;  movq xmm0, qword S.value
+|  mov D.tt, R1;  movq qword D.value, xmm0
+|.endmacro
+|
+|.macro copyslot, D, S, R1, R2, R3
+||if (J->flags & JIT_F_CPU_SSE2) {
+|  copyslotSSE D, S, R1
+||} else {
+|  mov R1, S.value;  mov R2, S.value.na[1];  mov R3, S.tt
+|  mov D.value, R1;  mov D.value.na[1], R2;  mov D.tt, R3
+||}
+|.endmacro
+|
+|.macro copyslot, D, S, R1, R2
+||if (J->flags & JIT_F_CPU_SSE2) {
+|  copyslotSSE D, S, R1
+||} else {
+|  mov R1, S.value;  mov R2, S.value.na[1];  mov D.value, R1
+|  mov R1, S.tt;  mov D.value.na[1], R2;  mov D.tt, R1
+||}
+|.endmacro
+|
+|.macro copyslot, D, S
+|  copyslot D, S, ecx, edx, eax
+|.endmacro
+|
+|.macro copyconst, tv, tvk              // May use edx.
+||switch (ttype(tvk)) {
+||case LUA_TNIL:
+|   setnilvalue tv
+||  break;
+||case LUA_TBOOLEAN:
+|   setbvalue tv, bvalue(tvk)           // May use edx.
+||  break;
+||case LUA_TNUMBER: {
+|   setnvaluek tv, &(tvk)->value
+||  break;
+||}
+||case LUA_TSTRING:
+|   setsvalue tv, &gcvalue(tvk)
+||  break;
+||default: lua_assert(0); break;
+||}
+|.endmacro
+|
+|// Macros to get Lua structures.
+|.macro getLCL, reg                     // May use CI and TOP (edi).
+||if (!J->pt->is_vararg) {
+|  mov LCL:reg, BASE[-1].value
+||} else {
+|  mov CI, L->ci
+|  mov TOP, CI->func
+|  mov LCL:reg, TOP->value
+||}
+|.endmacro
+|.macro getLCL;  getLCL eax; .endmacro
+|
+|// Macros to handle variants.
+|.macro addidx, type, idx
+||if (idx) {
+|  add type, idx*#type
+||}
+|.endmacro
+|
+|.macro subidx, type, idx
+||if (idx) {
+|  sub type, idx*#type
+||}
+|.endmacro
+|
+|// Annoying x87 stuff: support for two compare variants.
+|.macro fcomparepp                      // Compare and pop st0 >< st1.
+||if (J->flags & JIT_F_CPU_CMOV) {
+|  fucomip st1
+|  fpop
+||} else {
+|  fucompp
+|  fnstsw ax                            // eax modified!
+|  sahf
+|  // Sometimes test ah, imm8 would be faster.
+|  // But all following compares need to be changed then.
+|  // Don't bother since this is only compatibility stuff for old CPUs.
+||}
+|.endmacro
+|
+|// If you change LUA_TVALUE_ALIGN, be sure to change the Makefile, too:
+|//   DASMFLAGS= -D TVALUE_SIZE=...
+|// Then rerun make. Or change the default below:
+|.if not TVALUE_SIZE; .define TVALUE_SIZE, 16; .endif
+|
+|.if TVALUE_SIZE == 16
+|  .macro TValuemul, reg;  sal reg, 4; .endmacro  // *16
+|  .macro TValuediv, reg;  sar reg, 4; .endmacro  // /16
+|  .macro Nodemul, reg;  sal reg, 5; .endmacro    // *32
+|.elif TVALUE_SIZE == 12
+|  .macro TValuemul, reg;  sal reg, 2;  lea reg, [reg+reg*2]; .endmacro  // *12
+|  .macro TValuediv, reg;  sal reg, 2;  imul reg, 0xaaaaaaab; .endmacro  // /12
+|  .macro Nodemul, reg;  imul reg, 28; .endmacro  // *28
+|.else
+|  .fatal Unsupported TValue size `TVALUE_SIZE'.
+|.endif
+|
+|//
+|// x86 C calling conventions and stack frame layout during a JIT call:
+|//
+|// ebp+aword*4  CARG2     nresults
+|// ebp+aword*3  CARG2     func      (also used as SAVER3 for L)
+|// ebp+aword*2  CARG1     L
+|// -------------------------------  call to GATE_LJ
+|// ebp+aword*1  retaddr
+|// ebp+aword*0  frameptr       ebp
+|// ebp-aword*1  SAVER1    TOP  edi
+|// ebp-aword*2  SAVER2    BASE ebx
+|// -------------------------------
+|//              GATE_LJ retaddr
+|// esp+aword*2  ARG3
+|// esp+aword*1  ARG2
+|// esp+aword*0  ARG1                <-- esp for first JIT frame
+|// -------------------------------
+|//              1st JIT frame retaddr
+|// esp+aword*2  ARG3
+|// esp+aword*1  ARG2
+|// esp+aword*0  ARG1                <-- esp for second JIT frame
+|// -------------------------------
+|//              2nd JIT frame retaddr
+|//
+|// We could omit the fixed frame pointer (ebp) and have one more register
+|// available. But there is no pressing need (could use it for CI).
+|// And it's easier for debugging (gdb is still confused -- why?).
+|//
+|// The stack is aligned to 4 awords (16 bytes). Calls to C functions
+|// with up to 3 arguments do not need any stack pointer adjustment.
+|//
+|
+|.define CARG3, [ebp+aword*4]
+|.define CARG2, [ebp+aword*3]
+|.define CARG1, [ebp+aword*2]
+|.define SAVER1, [ebp-aword*1]
+|.define SAVER2, [ebp-aword*2]
+|.define ARG7, aword [esp+aword*6]      // Requires large frame.
+|.define ARG6, aword [esp+aword*5]      // Requires large frame.
+|.define ARG5, aword [esp+aword*4]      // Requires large frame.
+|.define ARG4, aword [esp+aword*3]      // Requires large frame.
+|.define ARG3, aword [esp+aword*2]
+|.define ARG2, aword [esp+aword*1]
+|.define ARG1, aword [esp]
+|.define FRAME_RETADDR, aword [esp+aword*3]
+|.define TMP3, [esp+aword*2]
+|.define TMP2, [esp+aword*1]
+|.define TMP1, [esp]
+|.define FPARG2, qword [esp+qword*1]    // Requires large frame.
+|.define FPARG1, qword [esp]
+|.define LJFRAME_OFFSET, aword*2        // 16 byte aligned with retaddr + ebp.
+|.define FRAME_OFFSET, aword*3          // 16 byte aligned with retaddr.
+|.define LFRAME_OFFSET, aword*7         // 16 byte aligned with retaddr.
+|.define S2LFRAME_OFFSET, aword*4       // Delta to large frame.
+|
+|.macro call, target, a1
+|  mov ARG1, a1;  call target; .endmacro
+|.macro call, target, a1, a2
+|  mov ARG1, a1;  mov ARG2, a2;  call target; .endmacro
+|.macro call, target, a1, a2, a3
+|  mov ARG1, a1;  mov ARG2, a2;  mov ARG3, a3;  call target; .endmacro
+|.macro call, target, a1, a2, a3, a4
+|  push a4;  push a3;  push a2;  push a1
+|  call target;  add esp, S2LFRAME_OFFSET;  .endmacro
+|.macro call, target, a1, a2, a3, a4, a5
+|  mov ARG1, a5; push a4; push a3;  push a2;  push a1
+|  call target;  add esp, S2LFRAME_OFFSET;  .endmacro
+|
+|// The following macros require a large frame.
+|.macro call_LFRAME, target, a1, a2, a3, a4
+|  mov ARG1, a1;  mov ARG2, a2;  mov ARG3, a3;  mov ARG4, a4
+|  call target; .endmacro
+|.macro call_LFRAME, target, a1, a2, a3, a4, a5
+|  mov ARG1, a1;  mov ARG2, a2;  mov ARG3, a3;  mov ARG4, a4;  mov ARG5, a5
+|  call target; .endmacro
+|
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_x86.h b/libraries/LuaJIT-1.1.7/src/ljit_x86.h
new file mode 100644
index 0000000..fc860bc
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_x86.h
@@ -0,0 +1,2301 @@
+/*
+** This file has been pre-processed with DynASM.
+** http://luajit.org/dynasm.html
+** DynASM version 1.1.4, DynASM x86 version 1.1.4
+** DO NOT EDIT! The original file is in "ljit_x86.dasc".
+*/
+
+#if DASM_VERSION != 10104
+#error "Version mismatch between DynASM and included encoding engine"
+#endif
+
+/*
+** Bytecode to machine code translation for x86 CPUs.
+** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+#define DASM_SECTION_CODE       0
+#define DASM_SECTION_DEOPT      1
+#define DASM_SECTION_TAIL       2
+#define DASM_SECTION_MFMAP      3
+#define DASM_MAXSECTION         4
+#define Dt1(_V) (int)&(((lua_State *)0)_V)
+#define Dt2(_V) (int)&(((TValue *)0)_V)
+#define Dt3(_V) (int)&(((TValue *)0)_V)
+#define Dt4(_V) (int)&(((CallInfo *)0)_V)
+#define Dt5(_V) (int)&(((LClosure *)0)_V)
+#define Dt6(_V) (int)&(((global_State *)0)_V)
+#define Dt7(_V) (int)&(((TValue *)0)_V)
+#define Dt8(_V) (int)&(((Value *)0)_V)
+#define Dt9(_V) (int)&(((CallInfo *)0)_V)
+#define DtA(_V) (int)&(((GCObject *)0)_V)
+#define DtB(_V) (int)&(((TString *)0)_V)
+#define DtC(_V) (int)&(((Table *)0)_V)
+#define DtD(_V) (int)&(((CClosure *)0)_V)
+#define DtE(_V) (int)&(((Proto *)0)_V)
+#define DtF(_V) (int)&(((UpVal *)0)_V)
+#define Dt10(_V) (int)&(((Node *)0)_V)
+static const unsigned char jit_actionlist[5059] = {
+  156,90,137,209,129,252,242,0,0,32,0,82,157,156,90,49,192,57,209,15,132,245,
+  247,64,83,15,162,91,137,208,249,1,195,255,254,0,251,15,249,10,141,68,36,4,
+  195,251,15,249,11,85,137,229,131,252,236,8,137,93,252,252,139,93,12,137,117,
+  12,139,117,8,137,125,252,248,139,190,235,139,131,235,139,142,235,102,252,
+  255,134,235,252,255,144,235,139,142,235,137,190,235,139,145,235,139,69,16,
+  137,150,235,139,145,235,133,192,137,150,235,15,136,245,248,193,224,4,1,195,
+  49,201,137,158,235,249,1,137,143,235,129,199,241,57,223,15,130,245,1,249,
+  2,255,102,252,255,142,235,184,239,139,125,252,248,139,93,252,252,139,117,
+  12,137,252,236,93,195,251,15,249,12,139,144,235,129,186,235,241,15,133,245,
+  247,139,146,235,137,144,235,252,255,226,249,1,131,252,236,12,139,129,235,
+  137,142,235,137,190,235,199,68,36,8,252,255,252,255,252,255,252,255,137,134,
+  235,137,92,36,4,43,158,235,137,52,36,232,244,133,192,15,133,245,248,137,52,
+  36,199,68,36,4,1,0,0,0,232,244,249,2,131,196,12,3,158,235,255,139,190,235,
+  195,251,15,249,13,141,135,235,131,252,236,12,59,134,235,15,131,245,14,59,
+  142,235,141,137,235,15,132,245,15,137,142,235,137,153,235,137,129,235,139,
+  147,235,129,195,241,137,190,235,137,158,235,137,153,235,249,16,137,52,36,
+  252,255,146,235,249,2,131,196,12,139,142,235,255,193,224,4,139,185,235,15,
+  132,245,250,139,158,235,137,218,41,195,249,3,139,3,131,195,4,137,7,131,199,
+  4,57,211,15,130,245,3,249,4,139,153,235,129,233,241,137,142,235,195,144,144,
+  144,144,144,144,251,15,249,17,252,246,134,235,237,15,133,245,253,249,6,137,
+  52,36,252,255,146,235,252,246,134,235,237,15,132,245,2,255,137,195,137,52,
+  36,199,68,36,4,239,199,68,36,8,252,255,252,255,252,255,252,255,232,244,137,
+  216,233,245,2,249,7,137,211,137,52,36,199,68,36,4,239,199,68,36,8,252,255,
+  252,255,252,255,252,255,232,244,137,218,233,245,6,251,15,249,14,41,252,248,
+  193,252,248,4,137,190,235,43,158,235,137,76,36,8,137,52,36,137,68,36,4,232,
+  244,139,76,36,8,3,158,235,139,190,235,139,131,235,131,196,12,252,255,160,
+  235,251,15,249,15,137,190,235,137,52,36,232,244,141,136,235,255,139,131,235,
+  137,142,235,131,196,12,252,255,160,235,255,249,18,90,233,245,19,249,20,137,
+  190,235,249,19,137,150,235,137,52,36,232,244,139,158,235,139,190,235,252,
+  255,224,251,15,255,137,190,235,255,232,245,21,255,251,15,249,21,252,246,134,
+  235,237,15,132,245,248,252,255,142,235,15,132,245,247,252,246,134,235,237,
+  15,132,245,248,249,1,139,4,36,131,252,236,12,137,52,36,137,68,36,4,232,244,
+  131,196,12,139,158,235,139,190,235,249,2,195,255,250,255,233,246,255,250,
+  243,255,254,1,233,245,19,254,0,250,254,2,250,251,1,252,255,252,255,254,3,
+  242,0,0,0,0,0,0,0,0,0,254,0,141,249,9,186,239,254,0,249,9,186,239,233,245,
+  20,254,0,139,142,235,139,129,235,191,247,253,59,129,235,15,131,245,22,249,
+  7,255,251,15,249,22,137,52,36,232,244,139,158,235,252,255,231,255,131,187,
+  235,5,15,133,245,9,49,192,137,131,235,137,131,235,254,3,238,238,254,0,131,
+  190,235,0,15,132,245,9,199,134,235,239,129,195,241,255,141,187,235,255,137,
+  158,235,137,190,235,137,52,36,232,244,139,158,235,139,190,235,255,199,135,
+  235,0,0,0,0,255,139,139,235,252,243,15,126,131,235,137,139,235,102,15,214,
+  131,235,255,139,139,235,139,147,235,139,131,235,137,139,235,137,147,235,137,
+  131,235,255,57,223,15,130,245,9,255,131,187,235,8,15,133,245,9,139,131,235,
+  131,184,235,0,15,132,245,9,199,134,235,239,137,190,235,137,52,36,137,92,36,
+  4,199,68,36,8,239,232,244,139,158,235,255,137,199,255,131,187,235,4,15,133,
+  245,9,139,139,235,219,129,235,199,131,235,3,0,0,0,221,155,235,255,141,187,
+  235,232,245,23,137,131,235,199,131,235,4,0,0,0,255,141,187,235,232,245,24,
+  137,131,235,199,131,235,4,0,0,0,255,131,187,235,3,15,133,245,9,141,134,235,
+  221,131,235,219,24,129,56,252,255,0,0,0,15,135,245,9,137,52,36,137,68,36,
+  4,199,68,36,8,1,0,0,0,232,244,137,131,235,199,131,235,4,0,0,0,255,251,15,
+  249,23,139,135,235,193,224,4,11,135,235,193,224,4,11,135,235,45,51,4,0,0,
+  15,133,245,18,221,135,235,221,135,235,219,92,36,8,219,92,36,4,139,143,235,
+  139,185,235,139,84,36,8,57,215,15,130,245,250,249,1,11,68,36,4,15,142,245,
+  252,249,2,41,194,15,140,245,253,141,140,253,1,235,66,249,3,137,116,36,4,137,
+  76,36,8,137,84,36,12,139,190,235,139,135,235,255,59,135,235,15,131,245,254,
+  233,244,249,4,15,140,245,251,141,84,58,1,233,245,1,249,5,137,252,250,233,
+  245,1,249,6,15,132,245,251,1,252,248,64,15,143,245,2,249,5,184,1,0,0,0,233,
+  245,2,249,7,49,210,233,245,3,255,251,15,249,24,139,135,235,193,224,4,11,135,
+  235,131,232,67,15,133,245,18,221,135,235,219,92,36,4,139,143,235,139,185,
+  235,137,252,250,233,245,1,249,8,131,252,236,12,137,52,36,232,244,131,196,
+  12,139,158,235,233,244,255,131,187,235,5,15,133,245,9,255,141,131,235,137,
+  52,36,137,68,36,4,232,244,255,141,131,235,141,139,235,137,52,36,137,68,36,
+  4,137,76,36,8,232,244,255,139,131,235,137,4,36,232,244,137,4,36,219,4,36,
+  221,155,235,199,131,235,3,0,0,0,255,131,187,235,3,15,133,245,9,221,131,235,
+  255,139,131,235,193,224,4,11,131,235,131,252,248,51,15,133,245,9,255,217,
+  252,254,255,217,252,255,255,217,252,242,221,216,255,217,60,36,217,45,239,
+  217,252,252,217,44,36,255,217,225,255,217,252,250,255,221,131,235,221,131,
+  235,249,1,217,252,248,223,224,158,15,138,245,1,221,217,255,221,131,235,221,
+  131,235,217,252,243,255,221,28,36,232,244,255,131,187,235,6,15,133,245,9,
+  129,187,235,239,15,133,245,9,255,141,131,235,57,199,15,133,245,9,255,141,
+  187,235,137,190,235,255,131,196,12,129,252,235,241,129,174,235,241,195,255,
+  141,187,235,137,52,36,137,124,36,4,232,244,133,192,15,133,246,255,139,131,
+  235,64,139,147,235,137,131,235,137,20,36,137,68,36,4,232,244,139,136,235,
+  133,201,15,132,245,255,219,131,235,199,131,235,3,0,0,0,221,155,235,139,144,
+  235,139,128,235,137,139,235,137,147,235,137,131,235,233,246,249,9,255,141,
+  135,235,131,252,236,12,59,134,235,15,131,245,14,59,142,235,141,137,235,15,
+  132,245,15,49,192,137,153,235,129,195,241,137,142,235,255,141,147,235,57,
+  215,255,137,223,255,15,71,252,250,255,15,134,245,247,137,215,249,1,255,141,
+  147,235,137,129,235,137,145,235,137,150,235,137,158,235,137,153,235,255,15,
+  130,245,251,249,4,254,2,249,5,137,135,235,129,199,241,57,215,15,130,245,5,
+  233,245,4,254,0,137,190,235,137,185,235,137,129,235,255,139,139,235,252,243,
+  15,126,131,235,137,143,235,102,15,214,135,235,255,139,139,235,139,147,235,
+  137,143,235,139,139,235,137,151,235,137,143,235,255,137,252,251,141,147,235,
+  141,187,235,137,145,235,137,150,235,255,137,135,235,255,249,2,137,135,235,
+  137,135,235,129,199,241,57,215,15,130,245,2,255,137,52,36,232,244,255,252,
+  246,134,235,237,15,132,245,255,232,245,25,249,9,255,251,15,249,25,139,142,
+  235,139,185,235,139,135,235,139,184,235,139,135,235,131,192,4,137,134,235,
+  131,252,236,12,137,52,36,199,68,36,4,239,199,68,36,8,252,255,252,255,252,
+  255,252,255,232,244,131,196,12,139,135,235,137,134,235,139,158,235,195,255,
+  137,52,36,137,92,36,4,232,244,255,129,174,235,241,137,223,129,252,235,241,
+  131,196,12,255,139,142,235,139,153,235,129,233,241,137,142,235,141,187,235,
+  131,196,12,255,252,246,134,235,237,15,132,245,253,232,245,26,249,7,255,139,
+  68,36,12,137,134,235,255,251,15,249,26,139,4,36,137,134,235,131,252,236,12,
+  137,52,36,199,68,36,4,239,199,68,36,8,252,255,252,255,252,255,252,255,232,
+  244,131,196,12,139,158,235,139,190,235,195,255,139,145,235,57,252,251,15,
+  131,245,248,249,1,139,3,131,195,4,137,2,131,194,4,57,252,251,15,130,245,1,
+  249,2,131,196,12,139,153,235,129,233,241,137,215,137,142,235,195,255,129,
+  174,235,241,129,252,235,241,255,131,196,12,141,187,235,195,255,139,142,235,
+  139,185,235,129,233,241,137,142,235,255,139,139,235,139,147,235,139,131,235,
+  137,143,235,137,151,235,137,135,235,255,131,196,12,137,252,251,255,129,199,
+  241,255,139,142,235,131,187,235,6,255,139,131,235,186,239,137,145,235,255,
+  15,133,245,20,255,15,133,245,19,255,15,132,245,247,232,245,27,249,1,255,251,
+  15,249,27,131,252,236,12,137,150,235,137,190,235,137,52,36,137,92,36,4,232,
+  244,131,196,12,137,195,139,190,235,139,131,235,139,142,235,195,255,252,255,
+  144,235,255,137,158,235,255,49,192,255,141,147,235,249,1,137,135,235,137,
+  135,235,129,199,241,57,215,15,130,245,1,255,131,187,235,6,15,133,245,9,255,
+  131,187,235,6,15,133,245,251,254,2,249,5,255,186,239,233,245,28,254,0,251,
+  15,249,28,137,150,235,137,190,235,137,52,36,137,92,36,4,232,244,139,142,235,
+  139,150,235,139,185,235,249,1,139,24,131,192,4,137,31,131,199,4,57,208,15,
+  130,245,1,139,153,235,139,131,235,129,233,241,131,196,12,252,255,160,235,
+  255,139,131,235,255,139,139,235,139,147,235,137,139,235,139,139,235,137,147,
+  235,137,139,235,255,141,187,235,129,252,235,241,139,142,235,137,131,235,255,
+  139,142,235,141,187,235,139,153,235,139,135,235,137,131,235,255,139,135,235,
+  252,243,15,126,135,235,137,131,235,102,15,214,131,235,255,139,135,235,139,
+  151,235,137,131,235,139,135,235,137,147,235,137,131,235,255,141,187,235,139,
+  131,235,255,139,145,235,249,1,139,3,131,195,4,137,2,131,194,4,57,252,251,
+  15,130,245,1,139,153,235,137,215,139,131,235,255,199,131,235,0,0,0,0,255,
+  186,1,0,0,0,137,147,235,137,147,235,255,199,131,235,0,0,0,0,199,131,235,1,
+  0,0,0,255,217,252,238,255,217,232,255,221,5,239,255,199,131,235,239,199,131,
+  235,4,0,0,0,255,137,131,235,195,255,141,139,235,141,147,235,249,1,137,1,57,
+  209,141,137,235,15,134,245,1,255,139,142,235,139,185,235,139,135,235,255,
+  139,136,235,139,185,235,255,139,143,235,252,243,15,126,135,235,137,139,235,
+  102,15,214,131,235,255,139,143,235,139,151,235,139,135,235,137,139,235,137,
+  147,235,137,131,235,255,139,136,235,139,185,235,139,131,235,139,147,235,137,
+  135,235,131,252,248,4,139,131,235,137,151,235,137,135,235,15,131,245,251,
+  249,4,254,2,249,5,252,246,130,235,237,15,132,245,4,252,246,129,235,237,15,
+  132,245,4,232,245,29,233,245,4,254,0,251,15,249,29,137,84,36,12,137,76,36,
+  8,137,116,36,4,233,244,255,251,15,249,30,139,142,235,139,185,235,139,135,
+  235,139,184,235,233,245,255,255,251,15,249,31,131,191,235,5,139,191,235,15,
+  133,245,18,249,9,15,182,143,235,184,1,0,0,0,211,224,72,35,130,235,193,224,
+  5,3,135,235,249,1,131,184,235,4,15,133,245,248,57,144,235,15,133,245,248,
+  139,136,235,133,201,15,132,245,249,255,252,243,15,126,128,235,102,15,214,
+  131,235,255,139,144,235,139,184,235,137,147,235,137,187,235,255,137,139,235,
+  139,158,235,195,249,2,139,128,235,133,192,15,133,245,1,49,201,249,3,139,135,
+  235,133,192,15,132,245,250,252,246,128,235,237,15,132,245,251,249,4,137,139,
+  235,139,158,235,195,249,5,137,150,235,199,134,235,4,0,0,0,139,12,36,131,252,
+  236,12,137,142,235,137,52,36,137,124,36,4,137,92,36,8,232,244,131,196,12,
+  139,158,235,255,251,15,249,32,139,135,235,193,224,4,11,129,235,131,252,248,
+  84,139,191,235,139,145,235,15,132,245,9,233,245,18,255,251,15,249,33,139,
+  142,235,128,167,235,237,139,145,235,137,185,235,137,151,235,195,255,251,15,
+  249,34,139,142,235,139,185,235,139,135,235,139,184,235,233,245,255,255,251,
+  15,249,35,131,191,235,5,139,191,235,15,133,245,18,249,9,15,182,143,235,184,
+  1,0,0,0,211,224,72,35,130,235,193,224,5,3,135,235,249,1,131,184,235,4,15,
+  133,245,250,57,144,235,15,133,245,250,131,184,235,0,15,132,245,252,249,2,
+  198,135,235,0,249,3,255,252,246,135,235,237,15,133,245,254,249,7,255,139,
+  139,235,252,243,15,126,131,235,137,136,235,102,15,214,128,235,255,139,139,
+  235,139,147,235,139,187,235,137,136,235,137,144,235,137,184,235,255,139,158,
+  235,195,249,8,232,245,33,233,245,7,249,4,139,128,235,133,192,15,133,245,1,
+  139,143,235,133,201,15,132,245,251,252,246,129,235,237,15,132,245,253,249,
+  5,141,134,235,137,144,235,199,128,235,4,0,0,0,131,252,236,12,137,52,36,137,
+  124,36,4,137,68,36,8,232,244,131,196,12,233,245,2,249,6,255,139,143,235,133,
+  201,15,132,245,2,252,246,129,235,237,15,133,245,2,249,7,137,150,235,199,134,
+  235,4,0,0,0,139,12,36,131,252,236,12,137,142,235,137,52,36,137,124,36,4,137,
+  92,36,8,232,244,131,196,12,139,158,235,195,255,251,15,249,36,139,135,235,
+  193,224,4,11,129,235,131,252,248,84,139,191,235,139,145,235,15,132,245,9,
+  233,245,18,255,137,52,36,199,68,36,4,239,199,68,36,8,239,232,244,137,131,
+  235,199,131,235,5,0,0,0,255,186,239,255,232,245,30,255,232,245,34,255,141,
+  187,235,186,239,255,141,187,235,141,139,235,255,131,187,235,5,139,187,235,
+  15,133,245,255,185,239,139,135,235,59,143,235,15,135,245,251,255,139,131,
+  235,193,224,4,11,131,235,131,252,248,83,15,133,245,255,255,252,242,15,16,
+  131,235,252,242,15,44,192,252,242,15,42,200,72,102,15,46,200,139,187,235,
+  15,133,245,255,15,138,245,255,255,221,131,235,219,20,36,219,4,36,255,223,
+  233,221,216,255,218,233,223,224,158,255,15,133,245,255,15,138,245,255,139,
+  4,36,139,187,235,72,255,59,135,235,15,131,245,251,193,224,4,3,135,235,255,
+  232,245,31,255,232,245,32,255,185,239,255,141,147,235,255,199,134,235,239,
+  83,81,82,86,232,244,131,196,16,139,158,235,255,249,1,139,144,235,133,210,
+  15,132,245,252,255,139,136,235,139,128,235,137,139,235,137,131,235,255,249,
+  2,137,147,235,254,2,232,245,37,255,232,245,38,255,233,245,1,249,6,139,143,
+  235,133,201,15,132,245,2,252,246,129,235,237,15,133,245,2,249,9,186,239,233,
+  245,19,254,0,251,15,249,37,137,76,36,4,131,252,236,12,137,60,36,137,76,36,
+  4,232,244,131,196,12,139,76,36,4,193,225,4,41,200,129,192,241,195,255,251,
+  15,249,38,64,137,124,36,4,137,68,36,8,233,244,255,187,239,255,232,245,35,
+  255,232,245,36,255,199,134,235,239,82,81,83,86,232,244,131,196,16,139,158,
+  235,255,249,1,131,184,235,0,15,132,245,252,249,2,254,2,232,245,39,255,232,
+  245,40,255,252,246,135,235,237,15,133,245,253,249,3,254,2,249,7,232,245,33,
+  233,245,3,254,0,199,128,235,0,0,0,0,255,186,1,0,0,0,137,144,235,137,144,235,
+  255,199,128,235,0,0,0,0,199,128,235,1,0,0,0,255,221,152,235,199,128,235,3,
+  0,0,0,255,199,128,235,239,199,128,235,4,0,0,0,255,251,15,249,39,137,76,36,
+  4,131,252,236,12,137,52,36,137,124,36,4,137,76,36,8,232,244,131,196,12,139,
+  76,36,4,193,225,4,41,200,129,192,241,195,255,251,15,249,40,64,137,116,36,
+  4,137,124,36,8,137,68,36,12,233,244,255,137,190,235,141,131,235,41,252,248,
+  252,247,216,193,252,248,4,139,187,235,15,132,245,250,255,129,192,241,255,
+  57,135,235,15,131,245,247,137,52,36,137,124,36,4,137,68,36,8,232,244,249,
+  1,252,246,135,235,237,139,151,235,15,133,245,252,139,190,235,254,2,249,6,
+  232,245,33,233,245,1,254,0,139,187,235,129,191,235,241,15,130,245,251,249,
+  1,252,246,135,235,237,139,151,235,15,133,245,252,141,187,235,254,2,249,5,
+  137,52,36,137,124,36,4,199,68,36,8,239,232,244,233,245,1,249,6,232,245,33,
+  233,245,1,254,0,129,194,241,255,141,139,235,249,3,139,1,131,193,4,137,2,131,
+  194,4,57,252,249,15,130,245,3,249,4,255,131,187,235,3,139,131,235,15,133,
+  245,255,133,192,15,136,245,255,255,221,131,235,221,5,239,255,221,5,239,221,
+  131,235,255,139,131,235,193,224,4,11,131,235,131,252,248,51,139,131,235,15,
+  133,245,255,11,131,235,15,136,245,255,221,131,235,221,131,235,255,131,187,
+  235,3,15,133,245,255,221,131,235,255,216,200,255,217,192,216,200,255,220,
+  201,255,222,201,255,199,4,36,239,199,68,36,4,239,199,68,36,8,239,131,187,
+  235,3,15,133,245,255,219,44,36,220,139,235,217,192,217,252,252,220,233,217,
+  201,217,252,240,217,232,222,193,217,252,253,221,217,255,251,15,249,41,217,
+  232,221,68,36,8,217,252,241,139,68,36,4,219,56,195,255,131,187,235,3,15,133,
+  245,255,255,131,187,235,3,255,139,131,235,193,224,4,11,131,235,131,252,248,
+  51,255,216,192,255,220,131,235,255,220,163,235,255,220,171,235,255,220,139,
+  235,255,220,179,235,255,220,187,235,255,131,252,236,16,221,28,36,221,131,
+  235,221,92,36,8,232,244,131,196,16,255,131,252,236,16,221,92,36,8,221,131,
+  235,221,28,36,232,244,131,196,16,255,217,224,255,15,138,246,255,15,130,246,
+  255,15,134,246,255,15,135,246,255,15,131,246,255,199,134,235,239,137,52,36,
+  137,76,36,4,137,84,36,8,232,244,133,192,139,158,235,255,15,132,246,255,199,
+  134,235,239,199,4,36,239,82,81,83,86,232,244,131,196,16,139,158,235,255,131,
+  187,235,5,139,139,235,15,133,245,9,137,12,36,232,244,137,4,36,219,4,36,221,
+  155,235,199,131,235,3,0,0,0,255,131,187,235,4,139,139,235,15,133,245,9,219,
+  129,235,221,155,235,199,131,235,3,0,0,0,255,199,134,235,239,137,52,36,137,
+  92,36,4,137,76,36,8,232,244,139,158,235,255,139,131,235,139,139,235,186,1,
+  0,0,0,33,193,209,232,9,193,49,192,57,209,17,192,137,147,235,137,131,235,255,
+  232,245,42,137,131,235,199,131,235,4,0,0,0,255,199,134,235,239,137,52,36,
+  199,68,36,4,239,199,68,36,8,239,232,244,139,158,235,255,251,15,249,42,137,
+  116,36,4,139,131,235,193,224,4,11,131,235,131,232,68,15,133,245,18,249,1,
+  139,190,235,139,179,235,139,147,235,139,142,235,133,201,15,132,245,248,11,
+  130,235,15,132,245,250,1,200,15,130,245,255,59,135,235,15,135,245,251,139,
+  191,235,129,198,241,255,252,243,164,139,138,235,141,178,235,252,243,164,41,
+  199,139,116,36,4,137,124,36,8,137,68,36,12,139,158,235,233,244,249,2,137,
+  208,249,3,139,116,36,4,139,158,235,195,249,4,137,252,240,233,245,3,249,5,
+  139,116,36,4,141,143,235,131,252,236,12,137,52,36,137,76,36,4,137,68,36,8,
+  232,244,131,196,12,49,192,233,245,1,249,9,139,116,36,4,233,245,18,255,131,
+  187,235,0,255,139,131,235,139,139,235,72,73,9,200,255,139,131,235,72,11,131,
+  235,255,131,187,235,3,15,133,246,221,131,235,221,5,239,255,131,187,235,4,
+  15,133,246,129,187,235,239,255,139,131,235,59,131,235,15,133,246,255,131,
+  252,248,3,15,133,245,9,221,131,235,221,131,235,255,131,252,248,4,15,133,245,
+  9,139,139,235,59,139,235,255,141,147,235,141,139,235,199,134,235,239,137,
+  52,36,137,76,36,4,137,84,36,8,232,244,72,139,158,235,255,139,131,235,139,
+  139,235,137,194,33,202,141,20,80,209,234,255,15,132,245,247,255,15,133,245,
+  247,255,139,147,235,137,131,235,137,139,235,137,147,235,233,246,249,1,255,
+  139,131,235,193,224,4,11,131,235,131,252,248,51,15,133,245,255,249,4,221,
+  131,235,221,131,235,221,147,235,255,249,4,139,131,235,193,224,4,11,131,235,
+  193,224,4,11,131,235,61,51,3,0,0,139,131,235,15,133,245,255,221,131,235,221,
+  131,235,133,192,221,147,235,15,136,245,247,217,201,249,1,255,199,131,235,
+  3,0,0,0,15,130,246,255,249,9,141,131,235,199,134,235,239,137,52,36,137,68,
+  36,4,232,244,233,245,4,254,0,221,131,235,221,131,235,220,131,235,221,147,
+  235,221,147,235,199,131,235,3,0,0,0,255,139,131,235,221,131,235,221,131,235,
+  221,131,235,222,193,221,147,235,221,147,235,199,131,235,3,0,0,0,133,192,15,
+  136,245,247,217,201,249,1,255,131,187,235,0,15,132,245,247,255,141,131,235,
+  137,68,36,4,255,137,92,36,4,255,139,187,235,255,139,142,235,139,185,235,139,
+  191,235,255,139,151,235,137,52,36,199,68,36,4,239,137,84,36,8,232,244,199,
+  128,235,239,137,131,235,199,131,235,6,0,0,0,255,139,151,235,137,144,235,255,
+  137,52,36,232,244,137,135,235,255,249,1,139,142,235,139,145,235,129,194,241,
+  141,132,253,27,235,41,208,59,134,235,15,131,245,251,141,187,235,57,218,15,
+  131,245,249,249,2,139,2,131,194,4,137,7,131,199,4,57,218,15,130,245,2,249,
+  3,254,2,249,5,43,134,235,193,252,248,4,137,52,36,137,68,36,4,232,244,139,
+  158,235,233,245,1,254,0,139,142,235,139,145,235,129,194,241,141,187,235,141,
+  139,235,57,218,15,131,245,248,249,1,139,2,131,194,4,137,7,131,199,4,57,207,
+  15,131,245,250,57,218,15,130,245,1,249,2,49,192,249,3,137,135,235,129,199,
+  241,57,207,15,130,245,3,249,4,255
+};
+
+enum {
+  JSUB_STACKPTR,
+  JSUB_GATE_LJ,
+  JSUB_GATE_JL,
+  JSUB_GATE_JC,
+  JSUB_GROW_STACK,
+  JSUB_GROW_CI,
+  JSUB_GATE_JC_PATCH,
+  JSUB_GATE_JC_DEBUG,
+  JSUB_DEOPTIMIZE_CALLER,
+  JSUB_DEOPTIMIZE,
+  JSUB_DEOPTIMIZE_OPEN,
+  JSUB_HOOKINS,
+  JSUB_GCSTEP,
+  JSUB_STRING_SUB3,
+  JSUB_STRING_SUB2,
+  JSUB_HOOKCALL,
+  JSUB_HOOKRET,
+  JSUB_METACALL,
+  JSUB_METATAILCALL,
+  JSUB_BARRIERF,
+  JSUB_GETGLOBAL,
+  JSUB_GETTABLE_KSTR,
+  JSUB_GETTABLE_STR,
+  JSUB_BARRIERBACK,
+  JSUB_SETGLOBAL,
+  JSUB_SETTABLE_KSTR,
+  JSUB_SETTABLE_STR,
+  JSUB_GETTABLE_KNUM,
+  JSUB_GETTABLE_NUM,
+  JSUB_SETTABLE_KNUM,
+  JSUB_SETTABLE_NUM,
+  JSUB_LOG2_TWORD,
+  JSUB_CONCAT_STR2,
+  JSUB__MAX
+};
+
+/* ------------------------------------------------------------------------ */
+
+/* Arch string. */
+const char luaJIT_arch[] = "x86";
+
+/* Forward declarations for C functions called from jsubs. */
+static void jit_hookins(lua_State *L, const Instruction *newpc);
+static void jit_gettable_fb(lua_State *L, Table *t, StkId dest);
+static void jit_settable_fb(lua_State *L, Table *t, StkId val);
+
+/* ------------------------------------------------------------------------ */
+
+/* Detect CPU features and set JIT flags. */
+static int jit_cpudetect(jit_State *J)
+{
+  void *mcode;
+  size_t sz;
+  int status;
+  /* Some of the jsubs need the flags. So compile this separately. */
+  unsigned int feature;
+  dasm_setup(Dst, jit_actionlist);
+  dasm_put(Dst, 0);
+  (void)dasm_checkstep(Dst, DASM_SECTION_CODE);
+  status = luaJIT_link(J, &mcode, &sz);
+  if (status != JIT_S_OK)
+    return status;
+  /* Check feature bits. See the Intel/AMD manuals for the bit definitions. */
+  feature = ((unsigned int (*)(void))mcode)();
+  if (feature & (1<<15)) J->flags |= JIT_F_CPU_CMOV;
+  if (feature & (1<<26)) J->flags |= JIT_F_CPU_SSE2;
+  luaJIT_freemcode(J, mcode, sz);  /* We don't need this code anymore. */
+  return JIT_S_OK;
+}
+
+/* Check some assumptions. Should compile to nop. */
+static int jit_consistency_check(jit_State *J)
+{
+  do {
+    /* Force a compiler error for inconsistent structure sizes. */
+    /* Check LUA_TVALUE_ALIGN in luaconf.h, too. */
+    int check_TVALUE_SIZE_in_ljit_x86_dash[1+16-sizeof(TValue)];
+    int check_TVALUE_SIZE_in_ljit_x86_dash_[1+sizeof(TValue)-16];
+    ((void)check_TVALUE_SIZE_in_ljit_x86_dash[0]);
+    ((void)check_TVALUE_SIZE_in_ljit_x86_dash_[0]);
+    if (LUA_TNIL != 0 || LUA_TBOOLEAN != 1 || PCRLUA != 0) break;
+    if ((int)&(((Node *)0)->i_val) != (int)&(((StkId)0)->value)) break;
+    return JIT_S_OK;
+  } while (0);
+  J->dasmstatus = 999999999;  /* Recognizable error. */
+  return JIT_S_COMPILER_ERROR;
+}
+
+/* Compile JIT subroutines (once). */
+static int jit_compile_jsub(jit_State *J)
+{
+  int status = jit_consistency_check(J);
+  if (status != JIT_S_OK) return status;
+  status = jit_cpudetect(J);
+  if (status != JIT_S_OK) return status;
+  dasm_setup(Dst, jit_actionlist);
+  dasm_put(Dst, 34);
+  dasm_put(Dst, 36, Dt1(->top), Dt2(->value), Dt1(->ci), Dt1(->nCcalls), Dt5(->jit_gate), Dt1(->ci), Dt1(->top), Dt4(->savedpc), Dt1(->savedpc), Dt4(->base), Dt1(->base), Dt1(->top), Dt3(->tt), sizeof(TValue));
+  dasm_put(Dst, 145, Dt1(->nCcalls), PCRC, Dt5(->p), DtE(->jit_status), JIT_S_OK, DtE(->jit_mcode), Dt5(->jit_gate), Dt4(->savedpc), Dt1(->ci), Dt1(->top), Dt1(->savedpc), Dt1(->stack), (ptrdiff_t)(luaD_precall), (ptrdiff_t)(luaV_execute), Dt1(->stack));
+  dasm_put(Dst, 262, Dt1(->top), Dt3([LUA_MINSTACK]), Dt1(->stack_last), Dt1(->end_ci), Dt4([1]), Dt1(->ci), Dt4(->func), Dt4(->top), Dt2(->value), sizeof(TValue), Dt1(->top), Dt1(->base), Dt4(->base), DtD(->f), Dt1(->ci));
+  dasm_put(Dst, 336, Dt4(->func), Dt1(->top), Dt4(->func), sizeof(CallInfo), Dt1(->ci), Dt1(->hookmask), LUA_MASKCALL, DtD(->f), Dt1(->hookmask), LUA_MASKRET);
+  dasm_put(Dst, 421, LUA_HOOKRET, (ptrdiff_t)(luaD_callhook), LUA_HOOKCALL, (ptrdiff_t)(luaD_callhook), Dt1(->top), Dt1(->stack), (ptrdiff_t)(luaD_growstack), Dt1(->stack), Dt1(->top), Dt2(->value), Dt5(->jit_gate), Dt1(->top), (ptrdiff_t)(luaD_growCI), Dt9([-1]));
+  dasm_put(Dst, 547, Dt2(->value), Dt1(->ci), Dt5(->jit_gate));
+  dasm_put(Dst, 602, Dt1(->hookmask), LUA_MASKLINE|LUA_MASKCOUNT, Dt1(->hookcount), Dt1(->hookmask), LUA_MASKLINE, (ptrdiff_t)(jit_hookins), Dt1(->base), Dt1(->top));
+  dasm_put(Dst, 737, (ptrdiff_t)(luaC_step), Dt1(->base));
+  dasm_put(Dst, 1026, Dt3([0].tt), Dt3([1].tt), Dt3([2].tt), Dt3([1].value), Dt3([2].value), Dt3([0].value), DtB(->tsv.len), sizeof(TString)-1, Dt1(->l_G), Dt6(->totalbytes));
+  dasm_put(Dst, 1129, Dt6(->GCthreshold), (ptrdiff_t)(luaS_newlstr));
+  dasm_put(Dst, 1191, Dt3([0].tt), Dt3([1].tt), Dt3([1].value), Dt3([0].value), DtB(->tsv.len), (ptrdiff_t)(luaC_step), Dt1(->base), (ptrdiff_t)(luaS_newlstr));
+    dasm_put(Dst, 1755, Dt1(->ci), Dt4(->func), Dt3(->value), Dt5(->p), DtE(->code), Dt1(->savedpc), LUA_HOOKCALL, (ptrdiff_t)(luaD_callhook), DtE(->code), Dt1(->savedpc), Dt1(->base));
+    dasm_put(Dst, 1886, Dt1(->savedpc), LUA_HOOKRET, (ptrdiff_t)(luaD_callhook), Dt1(->base), Dt1(->top));
+    dasm_put(Dst, 2077, Dt1(->savedpc), Dt1(->top), (ptrdiff_t)(luaD_tryfuncTM), Dt1(->top), Dt2(->value), Dt1(->ci));
+    dasm_put(Dst, 2178, Dt1(->savedpc), Dt1(->top), (ptrdiff_t)(luaD_tryfuncTM), Dt1(->ci), Dt1(->top), Dt4(->func), Dt4(->func), Dt2(->value), sizeof(CallInfo), Dt5(->jit_gate));
+  dasm_put(Dst, 2570, (ptrdiff_t)(luaC_barrierf));
+  dasm_put(Dst, 2589, Dt1(->ci), Dt4(->func), Dt3(->value), Dt5(->env));
+  dasm_put(Dst, 2609, Dt3(->tt), Dt3(->value), DtC(->lsizenode), DtB(->tsv.hash), DtC(->node), Dt10(->i_key.nk.tt), Dt10(->i_key.nk.value), Dt10(->i_val.tt));
+  if (J->flags & JIT_F_CPU_SSE2) {
+  dasm_put(Dst, 2674, Dt10(->i_val.value), Dt2(->value));
+  } else {
+  dasm_put(Dst, 2686, Dt10(->i_val.value), Dt10(->i_val.value.na[1]), Dt2(->value), Dt2(->value.na[1]));
+  }
+  dasm_put(Dst, 2699, Dt2(->tt), Dt1(->base), Dt10(->i_key.nk.next), DtC(->metatable), DtC(->flags), 1<<TM_INDEX, Dt2([0].tt), Dt1(->base), Dt1(->env.value), Dt1(->env.tt), Dt1(->savedpc), (ptrdiff_t)(jit_gettable_fb), Dt1(->base));
+  dasm_put(Dst, 32);
+  dasm_put(Dst, 2790, Dt3(->tt), Dt7(->tt), Dt3(->value), Dt7(->value));
+  dasm_put(Dst, 2821, Dt1(->l_G), DtC(->marked), (~bitmask(BLACKBIT))&0xff, Dt6(->grayagain), Dt6(->grayagain), DtC(->gclist));
+  dasm_put(Dst, 2843, Dt1(->ci), Dt4(->func), Dt3(->value), Dt5(->env));
+  dasm_put(Dst, 2863, Dt3(->tt), Dt3(->value), DtC(->lsizenode), DtB(->tsv.hash), DtC(->node), Dt10(->i_key.nk.tt), Dt10(->i_key.nk.value), Dt10(->i_val.tt), DtC(->flags));
+  dasm_put(Dst, 2935, DtC(->marked), bitmask(BLACKBIT));
+  if (J->flags & JIT_F_CPU_SSE2) {
+  dasm_put(Dst, 2947, Dt2([0].tt), Dt2([0].value), Dt7([0].tt), Dt7([0].value));
+  } else {
+  dasm_put(Dst, 2965, Dt2([0].value), Dt2([0].value.na[1]), Dt2([0].tt), Dt7([0].value), Dt7([0].value.na[1]), Dt7([0].tt));
+  }
+  dasm_put(Dst, 2984, Dt1(->base), Dt10(->i_key.nk.next), DtC(->metatable), DtC(->flags), 1<<TM_NEWINDEX, Dt1(->env), Dt7([0].value), Dt7([0].tt), (ptrdiff_t)(luaH_newkey));
+  dasm_put(Dst, 3066, DtC(->metatable), DtC(->flags), 1<<TM_NEWINDEX, Dt1(->env.value), Dt1(->env.tt), Dt1(->savedpc), (ptrdiff_t)(jit_settable_fb), Dt1(->base));
+  dasm_put(Dst, 3127, Dt3(->tt), Dt7(->tt), Dt3(->value), Dt7(->value));
+  dasm_put(Dst, 3438, (ptrdiff_t)(luaH_getnum), sizeof(TValue));
+  dasm_put(Dst, 3476, (ptrdiff_t)(luaH_getnum));
+  dasm_put(Dst, 3623, (ptrdiff_t)(luaH_setnum), sizeof(TValue));
+  dasm_put(Dst, 3665, (ptrdiff_t)(luaH_setnum));
+      dasm_put(Dst, 3992);
+  dasm_put(Dst, 4325, Dt2([0].tt), Dt2([1].tt), Dt1(->l_G), Dt2([0].value), Dt2([1].value), DtB(->tsv.len), DtB(->tsv.len), Dt6(->buff.buffsize), Dt6(->buff.buffer), sizeof(TString));
+  dasm_put(Dst, 4396, DtB(->tsv.len), DtB([1]), Dt1(->base), (ptrdiff_t)(luaS_newlstr), Dt1(->base), Dt6(->buff), (ptrdiff_t)(luaZ_openspace));
+  dasm_put(Dst, 561, Dt1(->top), Dt1(->savedpc), (ptrdiff_t)(luaJIT_deoptimize), Dt1(->base), Dt1(->top));
+
+  (void)dasm_checkstep(Dst, DASM_SECTION_CODE);
+  status = luaJIT_link(J, &J->jsubmcode, &J->szjsubmcode);
+  if (status != JIT_S_OK)
+    return status;
+
+  /* Copy the callgates from the globals to the global state. */
+  G(J->L)->jit_gateLJ = (luaJIT_GateLJ)J->jsub[JSUB_GATE_LJ];
+  G(J->L)->jit_gateJL = (lua_CFunction)J->jsub[JSUB_GATE_JL];
+  G(J->L)->jit_gateJC = (lua_CFunction)J->jsub[JSUB_GATE_JC];
+  return JIT_S_OK;
+}
+
+/* Match with number of nops above. Avoid confusing the instruction decoder. */
+#define DEBUGPATCH_SIZE         6
+
+/* Notify backend that the debug mode may have changed. */
+void luaJIT_debugnotify(jit_State *J)
+{
+  unsigned char *patch = (unsigned char *)J->jsub[JSUB_GATE_JC_PATCH];
+  unsigned char *target = (unsigned char *)J->jsub[JSUB_GATE_JC_DEBUG];
+  /* Yep, this is self-modifying code -- don't tell anyone. */
+  if (patch[0] == 0xe9) {  /* Debug patch is active. */
+    if (!(J->flags & JIT_F_DEBUG_CALL))  /* Deactivate it. */
+      memcpy(patch, target-DEBUGPATCH_SIZE, DEBUGPATCH_SIZE);
+  } else {  /* Debug patch is inactive. */
+    if (J->flags & JIT_F_DEBUG_CALL) {  /* Activate it. */
+      int rel = target-(patch+5);
+      memcpy(target-DEBUGPATCH_SIZE, patch, DEBUGPATCH_SIZE);
+      patch[0] = 0xe9;  /* jmp */
+      memcpy(patch+1, &rel, 4);  /* Relative address. */
+      memset(patch+5, 0x90, DEBUGPATCH_SIZE-5);  /* nop */
+    }
+  }
+}
+
+/* Patch a jmp into existing mcode. */
+static void jit_patch_jmp(jit_State *J, void *mcode, void *to)
+{
+  unsigned char *patch = (unsigned char *)mcode;
+  int rel = ((unsigned char *)to)-(patch+5);
+  patch[0] = 0xe9;  /* jmp */
+  memcpy((void *)(patch+1), &rel, 4);  /* Relative addr. */
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Call line/count hook. */
+static void jit_hookins(lua_State *L, const Instruction *newpc)
+{
+  Proto *pt = ci_func(L->ci)->l.p;
+  int pc = luaJIT_findpc(pt, newpc);  /* Sloooow with mcode addrs. */
+  const Instruction *savedpc = L->savedpc;
+  L->savedpc = pt->code + pc + 1;
+  if (L->hookmask > LUA_MASKLINE && L->hookcount == 0) {
+    resethookcount(L);
+    luaD_callhook(L, LUA_HOOKCOUNT, -1);
+  }
+  if (L->hookmask & LUA_MASKLINE) {
+    int newline = getline(pt, pc);
+    if (pc != 0) {
+      int oldpc = luaJIT_findpc(pt, savedpc);
+      if (!(pc <= oldpc || newline != getline(pt, oldpc))) return;
+    }
+    luaD_callhook(L, LUA_HOOKLINE, newline);
+  }
+}
+
+/* Insert hook check for each instruction in full debug mode. */
+static void jit_ins_debug(jit_State *J, int openop)
+{
+  if (openop) {
+    dasm_put(Dst, 594, Dt1(->top));
+  }
+  dasm_put(Dst, 598);
+
+}
+
+/* Called before every instruction. */
+static void jit_ins_start(jit_State *J)
+{
+  dasm_put(Dst, 663, J->nextpc);
+}
+
+/* Chain to another instruction. */
+static void jit_ins_chainto(jit_State *J, int pc)
+{
+  dasm_put(Dst, 665, pc);
+}
+
+/* Set PC label. */
+static void jit_ins_setpc(jit_State *J, int pc, void *target)
+{
+  dasm_put(Dst, 668, pc, (ptrdiff_t)(target));
+}
+
+/* Called after the last instruction has been encoded. */
+static void jit_ins_last(jit_State *J, int lastpc, int sizemfm)
+{
+  if (J->tflags & JIT_TF_USED_DEOPT) {  /* Deopt section has been used? */
+    dasm_put(Dst, 671);
+    dasm_put(Dst, 673);
+  }
+  dasm_put(Dst, 678, lastpc+1);
+  dasm_put(Dst, 681, lastpc+2);
+  dasm_put(Dst, 690, sizemfm);
+}
+
+/* Add a deoptimize target for the current instruction. */
+static void jit_deopt_target(jit_State *J, int nargs)
+{
+  if (nargs != -1) {
+    dasm_put(Dst, 671);
+    dasm_put(Dst, 702, (ptrdiff_t)(J->nextins));
+    J->tflags |= JIT_TF_USED_DEOPT;
+  } else {
+    dasm_put(Dst, 679);
+    dasm_put(Dst, 709, (ptrdiff_t)(J->nextins));
+  }
+}
+
+/* luaC_checkGC() inlined. Destroys caller-saves + TOP (edi). Uses label 7:. */
+/* Use this only at the _end_ of an instruction. */
+static void jit_checkGC(jit_State *J)
+{
+  dasm_put(Dst, 718, Dt1(->l_G), Dt6(->totalbytes), Dt6(->GCthreshold));
+
+}
+
+/* ------------------------------------------------------------------------ */
+
+
+
+/*
+** Function inlining support for x86 CPUs.
+** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+/* ------------------------------------------------------------------------ */
+
+/* Private structure holding function inlining info. */
+typedef struct jit_InlineInfo {
+  int func;                     /* Function slot. 1st arg slot = func+1. */
+  int res;                      /* 1st result slot. Overlaps func/ci->func. */
+  int nargs;                    /* Number of args. */
+  int nresults;                 /* Number of results. */
+  int xnargs;                   /* Expected number of args. */
+  int xnresults;                /* Returned number of results. */
+  int hidx;                     /* Library/function index numbers. */
+} jit_InlineInfo;
+
+/* ------------------------------------------------------------------------ */
+
+enum { TFOR_FUNC, TFOR_TAB, TFOR_CTL, TFOR_KEY, TFOR_VAL };
+
+static void jit_inline_base(jit_State *J, jit_InlineInfo *ii)
+{
+  int func = ii->func;
+  switch (JIT_IH_IDX(ii->hidx)) {
+  case JIT_IH_BASE_PAIRS:
+  case JIT_IH_BASE_IPAIRS:
+    dasm_put(Dst, 753, Dt2([func+TFOR_TAB].tt), Dt2([func+TFOR_CTL].tt), Dt2([func+TFOR_CTL].value));
+    dasm_put(Dst, 771, JIT_MFM_DEOPT_PAIRS, J->nextpc-1);
+    break;
+  default:
+    jit_assert(0);
+    break;
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+#ifndef COCO_DISABLE
+
+/* Helper function for inlined coroutine.resume(). */
+static StkId jit_coroutine_resume(lua_State *L, StkId base, int nresults)
+{
+  lua_State *co = thvalue(base-1);
+  /* Check for proper usage. Merge of lua_resume() and auxresume() checks. */
+  if (co->status != LUA_YIELD) {
+    if (co->status > LUA_YIELD) {
+errdead:
+      setsvalue(L, base-1, luaS_newliteral(L, "cannot resume dead coroutine"));
+      goto err;
+    } else if (co->ci != co->base_ci) {
+      setsvalue(L, base-1,
+        luaS_newliteral(L, "cannot resume non-suspended coroutine"));
+      goto err;
+    } else if (co->base == co->top) {
+      goto errdead;
+    }
+  }
+  {
+    ptrdiff_t ndelta = (char *)L->top - (char *)base;
+    int nargs = ndelta/sizeof(TValue);  /* Compute nargs. */
+    int status;
+    if ((char *)co->stack_last-(char *)co->top <= ndelta) {
+      co->ci->top = (StkId)(((char *)co->top) + ndelta);  /* Ok before grow. */
+      luaD_growstack(co, nargs);  /* Grow thread stack. */
+    }
+    /* Copy args. */
+    co->top = (StkId)(((char *)co->top) + ndelta);
+    { StkId t = co->top, f = L->top; while (f > base) setobj2s(co, --t, --f); }
+    L->top = base;
+    status = luaCOCO_resume(co, nargs);  /* Resume Coco thread. */
+    if (status == 0 || status == LUA_YIELD) {  /* Ok. */
+      StkId f;
+      if (nresults == 0) return NULL;
+      if (nresults == -1) {
+        luaD_checkstack(L, co->top - co->base);  /* Grow own stack. */
+      }
+      base = L->top - 2;
+      setbvalue(base++, 1);  /* true */
+      /* Copy results. Fill unused result slots with nil. */
+      f = co->base;
+      while (--nresults != 0 && f < co->top) setobj2s(L, base++, f++);
+      while (nresults-- > 0) setnilvalue(base++);
+      co->top = co->base;
+      return base;
+    } else {  /* Error. */
+      base = L->top;
+      setobj2s(L, base-1, co->top-1);  /* Copy error object. */
+err:
+      setbvalue(base-2, 0);  /* false */
+      nresults -= 2;
+      while (--nresults >= 0) setnilvalue(base+nresults);  /* Fill results. */
+      return base;
+    }
+  }
+}
+
+static void jit_inline_coroutine(jit_State *J, jit_InlineInfo *ii)
+{
+  int arg = ii->func+1;
+  int res = ii->res;
+  int i;
+  switch (JIT_IH_IDX(ii->hidx)) {
+  case JIT_IH_COROUTINE_YIELD:
+    dasm_put(Dst, 775, ((int)&LHASCOCO((lua_State *)0)), Dt1(->savedpc), (ptrdiff_t)(J->nextins), arg*sizeof(TValue));
+    if (ii->nargs >= 0) {  /* Previous op was not open and did not set TOP. */
+      dasm_put(Dst, 791, Dt2([ii->nargs]));
+    }
+    dasm_put(Dst, 795, Dt1(->base), Dt1(->top), (ptrdiff_t)(luaCOCO_yield), Dt1(->base), Dt1(->top));
+    jit_assert(ii->nresults >= 0 && ii->nresults <= EXTRA_STACK);
+    for (i = 0; i < ii->nresults; i++) {
+      dasm_put(Dst, 813, Dt3([i].tt));
+      if (J->flags & JIT_F_CPU_SSE2) {
+      dasm_put(Dst, 821, Dt2([arg+i].tt), Dt2([arg+i].value), Dt2([res+i].tt), Dt2([res+i].value));
+      } else {
+      dasm_put(Dst, 839, Dt2([arg+i].value), Dt2([arg+i].value.na[1]), Dt2([arg+i].tt), Dt2([res+i].value), Dt2([res+i].value.na[1]), Dt2([res+i].tt));
+      }
+    }
+    ii->nargs = -1;  /* Force restore of L->top. */
+    break;
+  case JIT_IH_COROUTINE_RESUME:
+    jit_assert(ii->nargs != 0 && ii->res == ii->func);
+    dasm_put(Dst, 787, (arg+1)*sizeof(TValue));
+    if (ii->nargs >= 0) {  /* Previous op was not open and did not set TOP. */
+      dasm_put(Dst, 791, Dt2([ii->nargs-1]));
+    } else {
+      dasm_put(Dst, 858);
+    }
+    dasm_put(Dst, 865, Dt2([-1].tt), Dt2([-1].value), ((int)&LHASCOCO((lua_State *)0)), Dt1(->savedpc), (ptrdiff_t)(J->nextins), Dt1(->top), ii->nresults, (ptrdiff_t)(jit_coroutine_resume), Dt1(->base));
+    if (ii->nresults == -1) {
+      dasm_put(Dst, 909);
+    }
+    ii->nargs = -1;  /* Force restore of L->top. */
+    break;
+  default:
+    jit_assert(0);
+    break;
+  }
+}
+
+#endif /* COCO_DISABLE */
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_inline_string(jit_State *J, jit_InlineInfo *ii)
+{
+  int arg = ii->func+1;
+  int res = ii->res;
+  switch (JIT_IH_IDX(ii->hidx)) {
+  case JIT_IH_STRING_LEN:
+    dasm_put(Dst, 912, Dt2([arg].tt), Dt2([arg].value), DtB(->tsv.len), Dt2([res].tt), Dt2([res].value));
+    break;
+  case JIT_IH_STRING_SUB:
+    /* TODO: inline numeric constants with help from the optimizer. */
+    /*       But this would save only another 15-20% in a trivial loop. */
+    jit_assert(ii->nargs >= 2);  /* Open op caveat is ok, too. */
+    if (ii->nargs > 2) {
+      dasm_put(Dst, 937, Dt2([arg]), Dt2([res].value), Dt2([res].tt));
+    } else {
+      dasm_put(Dst, 954, Dt2([arg]), Dt2([res].value), Dt2([res].tt));
+    }
+    break;
+  case JIT_IH_STRING_CHAR:
+    dasm_put(Dst, 971, Dt2([arg].tt), Dt1(->env), Dt2([arg].value), (ptrdiff_t)(luaS_newlstr), Dt2([res].value), Dt2([res].tt));
+    break;
+  default:
+    jit_assert(0);
+    break;
+  }
+
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Helper functions for inlined calls to table.*. */
+static void jit_table_insert(lua_State *L, TValue *arg)
+{
+  setobj2t(L, luaH_setnum(L, hvalue(arg), luaH_getn(hvalue(arg))+1), arg+1);
+  luaC_barriert(L, hvalue(arg), arg+1);
+}
+
+static TValue *jit_table_remove(lua_State *L, TValue *arg, TValue *res)
+{
+  int n = luaH_getn(hvalue(arg));
+  if (n == 0) {
+    setnilvalue(res);  /* For the nresults == 1 case. Harmless otherwise. */
+    return res;  /* For the nresults == -1 case. */
+  } else {
+    TValue *val = luaH_setnum(L, hvalue(arg), n);
+    setobj2s(L, res, val);
+    setnilvalue(val);
+    return res+1;  /* For the nresults == -1 case. */
+  }
+}
+
+static void jit_inline_table(jit_State *J, jit_InlineInfo *ii)
+{
+  int arg = ii->func+1;
+  int res = ii->res;
+  dasm_put(Dst, 1250, Dt2([arg].tt));
+  switch (JIT_IH_IDX(ii->hidx)) {
+  case JIT_IH_TABLE_INSERT:
+    dasm_put(Dst, 1259, Dt2([arg]), (ptrdiff_t)(jit_table_insert));
+    break;
+  case JIT_IH_TABLE_REMOVE:
+    dasm_put(Dst, 1272, Dt2([arg]), Dt2([res]), (ptrdiff_t)(jit_table_remove));
+    if (ii->nresults == -1) {
+      ii->xnresults = -1;
+      dasm_put(Dst, 909);
+    }
+    break;
+  case JIT_IH_TABLE_GETN:
+    dasm_put(Dst, 1292, Dt2([arg].value), (ptrdiff_t)(luaH_getn), Dt2([res].value), Dt2([res].tt));
+    break;
+  default:
+    jit_assert(0);
+    break;
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* This typedef must match the libm function signature. */
+/* Serves as a check against wrong lua_Number or wrong calling conventions. */
+typedef lua_Number (*mathfunc_11)(lua_Number);
+
+/* Partially inlined math functions. */
+/* CHECK: must match with jit_hints.h and jit.opt_lib. */
+static const mathfunc_11 jit_mathfuncs_11[JIT_IH_MATH_SIN] = {
+  log, log10, exp,      sinh, cosh, tanh,       asin, acos, atan
+};
+
+/* FPU control words for ceil and floor (exceptions masked, full precision). */
+static const unsigned short jit_fpucw[2] = { 0x0b7f, 0x077f };
+
+static void jit_inline_math(jit_State *J, jit_InlineInfo *ii)
+{
+  int arg = ii->func+1;
+  int res = ii->res;
+  int idx = JIT_IH_IDX(ii->hidx);
+
+  if (idx < JIT_IH_MATH__21) {
+    dasm_put(Dst, 1317, Dt2([arg].tt), Dt2([arg].value));
+  } else {
+    jit_assert(idx < JIT_IH_MATH__LAST);
+    dasm_put(Dst, 1329, Dt2([arg].tt), Dt2([arg+1].tt));
+  }
+  switch (idx) {
+  /* We ignore sin/cos/tan range overflows (2^63 rad) just like -ffast-math. */
+  case JIT_IH_MATH_SIN:
+    dasm_put(Dst, 1347);
+    break;
+  case JIT_IH_MATH_COS:
+    dasm_put(Dst, 1351);
+    break;
+  case JIT_IH_MATH_TAN:
+    dasm_put(Dst, 1355);
+    break;
+  case JIT_IH_MATH_CEIL:
+  case JIT_IH_MATH_FLOOR:
+    dasm_put(Dst, 1361, (ptrdiff_t)&jit_fpucw[idx-JIT_IH_MATH_CEIL]);
+    break;
+  case JIT_IH_MATH_ABS:
+    dasm_put(Dst, 1374);
+    break;
+  case JIT_IH_MATH_SQRT:
+    dasm_put(Dst, 1377);
+    break;
+  case JIT_IH_MATH_FMOD:
+    dasm_put(Dst, 1381, Dt2([arg+1].value), Dt2([arg].value));
+    break;
+  case JIT_IH_MATH_ATAN2:
+    dasm_put(Dst, 1402, Dt2([arg].value), Dt2([arg+1].value));
+    break;
+  default:
+    dasm_put(Dst, 1412, (ptrdiff_t)(jit_mathfuncs_11[idx]));
+    break;
+  }
+  dasm_put(Dst, 926, Dt2([res].tt), Dt2([res].value));
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Try to inline a CALL or TAILCALL instruction. */
+static int jit_inline_call(jit_State *J, int func, int nargs, int nresults)
+{
+  const TValue *callable = hint_get(J, TYPE);  /* TYPE hint = callable. */
+  int cltype = ttype(callable);
+  const TValue *oidx;
+  jit_InlineInfo ii;
+  int idx;
+
+  if (cltype != LUA_TFUNCTION) goto fail;
+  if (J->flags & JIT_F_DEBUG) goto fail;  /* DWIM. */
+
+  oidx = hint_get(J, INLINE);  /* INLINE hint = library/function index. */
+  if (!ttisnumber(oidx)) goto fail;
+
+  ii.hidx = (int)nvalue(oidx);
+  idx = JIT_IH_IDX(ii.hidx);
+
+  if (nresults == -2) {  /* Tailcall. */
+    /* Tailcalls from vararg functions don't work with BASE[-1]. */
+    if (J->pt->is_vararg) goto fail;  /* So forget about this rare case. */
+    ii.res = -1;  /* Careful: 2nd result overlaps 1st stack slot. */
+    ii.nresults = -1;
+  } else {
+    ii.res = func;
+    ii.nresults = nresults;
+  }
+  ii.func = func;
+  ii.nargs = nargs;
+  ii.xnargs = ii.xnresults = 1;  /* Default: 1 arg, 1 result. */
+
+  /* Check for the currently supported cases. */
+  switch (JIT_IH_LIB(ii.hidx)) {
+  case JIT_IHLIB_BASE:
+    switch (idx) {
+    case JIT_IH_BASE_PAIRS:
+    case JIT_IH_BASE_IPAIRS:
+      if (nresults == -2) goto fail;  /* Not useful for tailcalls. */
+      ii.xnresults = 3;
+      goto check;
+    }
+    break;
+#ifndef COCO_DISABLE
+  case JIT_IHLIB_COROUTINE:
+    switch (idx) {
+    case JIT_IH_COROUTINE_YIELD:
+      /* Only support common cases: no tailcalls, low number of results. */
+      if (nresults < 0 || nresults > EXTRA_STACK) goto fail;
+      ii.xnargs = ii.xnresults = -1;
+      goto ok;  /* Anything else is ok. */
+    case JIT_IH_COROUTINE_RESUME:
+      /* Only support common cases: no tailcalls, not with 0 args (error). */
+      if (nresults == -2 || nargs == 0) goto fail;
+      ii.xnargs = ii.xnresults = -1;
+      goto ok;  /* Anything else is ok. */
+    }
+    break;
+#endif
+  case JIT_IHLIB_STRING:
+    switch (idx) {
+    case JIT_IH_STRING_LEN:
+      goto check;
+    case JIT_IH_STRING_SUB:
+      if (nargs < 2) goto fail;  /* No support for open calls, too. */
+      goto ok;  /* 2 or more args are ok. */
+    case JIT_IH_STRING_CHAR:
+      goto check;  /* Only single arg supported. */
+    }
+    break;
+  case JIT_IHLIB_TABLE:
+    switch (idx) {
+    case JIT_IH_TABLE_INSERT:
+      ii.xnargs = 2;
+      goto check;  /* Only push (append) supported. */
+    case JIT_IH_TABLE_REMOVE:
+      goto check;  /* Only pop supported. */
+    case JIT_IH_TABLE_GETN:
+      goto check;
+    }
+    break;
+  case JIT_IHLIB_MATH:
+    if (idx >= JIT_IH_MATH__LAST) goto fail;
+    if (idx >= JIT_IH_MATH__21) ii.xnargs = 2;
+    goto check;
+  }
+fail:
+  return cltype;  /* Call could not be inlined. Return type of callable. */
+
+check:
+  if (nargs != ii.xnargs && nargs != -1) goto fail;
+  /* The optimizer already checks the number of results (avoid setnil). */
+
+ok:  /* Whew, all checks done. Go for it! */
+
+  /* Start with the common leadin for inlined calls. */
+  jit_deopt_target(J, nargs);
+  dasm_put(Dst, 1418, Dt2([func].tt), Dt2([func].value), (ptrdiff_t)(clvalue(callable)));
+  if (nargs == -1 && ii.xnargs >= 0) {
+    dasm_put(Dst, 1435, Dt2([func+1+ii.xnargs]));
+  }
+
+  /* Now inline the function itself. */
+  switch (JIT_IH_LIB(ii.hidx)) {
+  case JIT_IHLIB_BASE: jit_inline_base(J, &ii); break;
+#ifndef COCO_DISABLE
+  case JIT_IHLIB_COROUTINE: jit_inline_coroutine(J, &ii); break;
+#endif
+  case JIT_IHLIB_STRING: jit_inline_string(J, &ii); break;
+  case JIT_IHLIB_TABLE:  jit_inline_table(J, &ii); break;
+  case JIT_IHLIB_MATH:   jit_inline_math(J, &ii); break;
+  default: jit_assert(0); break;
+  }
+
+  /* And add the common leadout for inlined calls. */
+  if (ii.nresults == -1) {
+    if (ii.xnresults >= 0) {
+      dasm_put(Dst, 791, Dt2([ii.res+ii.xnresults]));
+    }
+  } else if (ii.nargs == -1) {  /* Restore L->top only if needed. */
+    dasm_put(Dst, 1445, Dt2([J->pt->maxstacksize]), Dt1(->top));
+  }
+
+  if (nresults == -2) {  /* Results are in place. Add return for tailcalls. */
+    dasm_put(Dst, 1452, sizeof(TValue), Dt1(->ci), sizeof(CallInfo));
+  }
+
+  return -1;  /* Success, call has been inlined. */
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Helper function for inlined iterator code. Paraphrased from luaH_next. */
+/* TODO: GCC has trouble optimizing this. */
+static int jit_table_next(lua_State *L, TValue *ra)
+{
+  Table *t = hvalue(&ra[TFOR_TAB]);
+  int i = ra[TFOR_CTL].value.b;  /* Hidden control variable. */
+  for (; i < t->sizearray; i++) {  /* First the array part. */
+    if (!ttisnil(&t->array[i])) {
+      setnvalue(&ra[TFOR_KEY], cast_num(i+1));
+      setobj2s(L, &ra[TFOR_VAL], &t->array[i]);
+      ra[TFOR_CTL].value.b = i+1;
+      return 1;
+    }
+  }
+  for (i -= t->sizearray; i < sizenode(t); i++) {  /* Then the hash part. */
+    if (!ttisnil(gval(gnode(t, i)))) {
+      setobj2s(L, &ra[TFOR_KEY], key2tval(gnode(t, i)));
+      setobj2s(L, &ra[TFOR_VAL], gval(gnode(t, i)));
+      ra[TFOR_CTL].value.b = i+1+t->sizearray;
+      return 1;
+    }
+  }
+  return 0;  /* End of iteration. */
+}
+
+/* Try to inline a TFORLOOP instruction. */
+static int jit_inline_tforloop(jit_State *J, int ra, int nresults, int target)
+{
+  const TValue *oidx = hint_get(J, INLINE);  /* INLINE hint = lib/func idx. */
+  int idx;
+
+  if (!ttisnumber(oidx)) return 0;  /* No hint: don't inline anything. */
+  idx = (int)nvalue(oidx);
+  if (J->flags & JIT_F_DEBUG) return 0;  /* DWIM. */
+
+  switch (idx) {
+  case JIT_IH_MKIDX(JIT_IHLIB_BASE, JIT_IH_BASE_PAIRS):
+    dasm_put(Dst, 1465, Dt2([ra]), (ptrdiff_t)(jit_table_next), target);
+    return 1;  /* Success, iterator has been inlined. */
+  case JIT_IH_MKIDX(JIT_IHLIB_BASE, JIT_IH_BASE_IPAIRS):
+    dasm_put(Dst, 1483, Dt2([ra+TFOR_CTL].value), Dt2([ra+TFOR_TAB].value), Dt2([ra+TFOR_CTL].value), (ptrdiff_t)(luaH_getnum), Dt7(->tt), Dt2([ra+TFOR_CTL].value), Dt2([ra+TFOR_KEY].tt), Dt2([ra+TFOR_KEY].value), Dt7(->value), Dt7(->value.na[1]), Dt2([ra+TFOR_VAL].tt), Dt2([ra+TFOR_VAL].value), Dt2([ra+TFOR_VAL].value.na[1]), target);
+    return 1;  /* Success, iterator has been inlined. */
+  }
+
+  return 0;  /* No support for inlining any other iterators. */
+}
+
+/* ------------------------------------------------------------------------ */
+
+
+
+#ifdef LUA_COMPAT_VARARG
+static void jit_vararg_table(lua_State *L)
+{
+  Table *tab;
+  StkId base, func;
+  int i, num, numparams;
+  luaC_checkGC(L);
+  base = L->base;
+  func = L->ci->func;
+  numparams = clvalue(func)->l.p->numparams;
+  num = base - func - numparams - 1;
+  tab = luaH_new(L, num, 1);
+  for (i = 0; i < num; i++)
+    setobj2n(L, luaH_setnum(L, tab, i+1), base - num + i);
+  setnvalue(luaH_setstr(L, tab, luaS_newliteral(L, "n")), (lua_Number)num);
+  sethvalue(L, base + numparams, tab);
+}
+#endif
+
+/* Encode JIT function prologue. */
+static void jit_prologue(jit_State *J)
+{
+  Proto *pt = J->pt;
+  int numparams = pt->numparams;
+  int stacksize = pt->maxstacksize;
+
+  dasm_put(Dst, 1544, Dt3([stacksize]), Dt1(->stack_last), Dt1(->end_ci), Dt4([1]), Dt4(->func), sizeof(TValue), Dt1(->ci));
+
+  if (numparams > 0) {
+    dasm_put(Dst, 1580, Dt2([numparams]));
+  }
+
+  if (!pt->is_vararg) {  /* Fixarg function. */
+    /* Must cap L->top at L->base+numparams because 1st LOADNIL is omitted. */
+    if (numparams == 0) {
+      dasm_put(Dst, 1586);
+    } else if (J->flags & JIT_F_CPU_CMOV) {
+      dasm_put(Dst, 1589);
+    } else {
+      dasm_put(Dst, 1594);
+    }
+    dasm_put(Dst, 1603, Dt2([stacksize]), Dt4(->tailcalls), Dt4(->top), Dt1(->top), Dt1(->base), Dt4(->base));
+  } else {  /* Vararg function. */
+    int i;
+    if (numparams > 0) {
+      dasm_put(Dst, 1622);
+      dasm_put(Dst, 1630, Dt3(->tt), sizeof(TValue));
+    }
+    dasm_put(Dst, 1649, Dt1(->base), Dt4(->base), Dt4(->tailcalls));
+    for (i = 0; i < numparams; i++) {  /* Move/clear fixargs. */
+      if (J->flags & JIT_F_CPU_SSE2) {
+      dasm_put(Dst, 1659, Dt2([i].tt), Dt2([i].value), Dt3([i].tt), Dt3([i].value));
+      } else {
+      dasm_put(Dst, 1677, Dt2([i].value), Dt2([i].value.na[1]), Dt3([i].value), Dt2([i].tt), Dt3([i].value.na[1]), Dt3([i].tt));
+      }
+      dasm_put(Dst, 854, Dt2([i].tt));
+    }
+    if (numparams > 0) {
+      dasm_put(Dst, 332, Dt1(->ci));
+    }
+    dasm_put(Dst, 1696, Dt2([stacksize]), Dt2([numparams]), Dt4(->top), Dt1(->top));
+    stacksize -= numparams;             /* Fixargs are already cleared. */
+  }
+
+  /* Clear undefined args and all vars. Still assumes eax = LUA_TNIL = 0. */
+  /* Note: cannot clear only args because L->top has grown. */
+  if (stacksize <= EXTRA_STACK) {  /* Loopless clear. May use EXTRA_STACK. */
+    int i;
+    for (i = 0; i < stacksize; i++) {
+      dasm_put(Dst, 1712, Dt3([i].tt));
+    }
+  } else {  /* Standard loop. */
+    dasm_put(Dst, 1716, Dt3([0].tt), Dt3([1].tt), 2*sizeof(TValue));
+  }
+
+#ifdef LUA_COMPAT_VARARG
+  if (pt->is_vararg & VARARG_NEEDSARG) {
+    dasm_put(Dst, 1734, (ptrdiff_t)(jit_vararg_table));
+  }
+#endif
+
+  /* Call hook check. */
+  if (J->flags & JIT_F_DEBUG_CALL) {
+    dasm_put(Dst, 1740, Dt1(->hookmask), LUA_MASKCALL);
+
+  }
+}
+
+/* Check if we can combine 'return const'. */
+static int jit_return_k(jit_State *J)
+{
+  if (!J->combine) return 0;  /* COMBINE hint set? */
+  /* May need to close open upvalues. */
+  if (!fhint_isset(J, NOCLOSE)) {
+    dasm_put(Dst, 1820, (ptrdiff_t)(luaF_close));
+  }
+  if (!J->pt->is_vararg) {  /* Fixarg function. */
+    dasm_put(Dst, 1830, Dt1(->ci), sizeof(CallInfo), sizeof(TValue));
+  } else {  /* Vararg function. */
+    dasm_put(Dst, 1844, Dt1(->ci), Dt4(->func), sizeof(CallInfo), Dt1(->ci), Dt2([1]));
+  }
+  jit_assert(J->combine == 1);  /* Required to skip next RETURN instruction. */
+  return 1;
+}
+
+static void jit_op_return(jit_State *J, int rbase, int nresults)
+{
+  /* Return hook check. */
+  if (J->flags & JIT_F_DEBUG_CALL) {
+    if (nresults < 0 && !(J->flags & JIT_F_DEBUG_INS)) {
+      dasm_put(Dst, 594, Dt1(->top));
+    }
+    dasm_put(Dst, 1863, Dt1(->hookmask), LUA_MASKRET);
+    if (J->flags & JIT_F_DEBUG_INS) {
+      dasm_put(Dst, 1878, Dt1(->savedpc));
+    }
+
+  }
+
+  /* May need to close open upvalues. */
+  if (!fhint_isset(J, NOCLOSE)) {
+    dasm_put(Dst, 1820, (ptrdiff_t)(luaF_close));
+  }
+
+  /* Previous op was open: 'return f()' or 'return ...' */
+  if (nresults < 0) {
+    dasm_put(Dst, 332, Dt1(->ci));
+    if (rbase) {
+    dasm_put(Dst, 787, rbase*sizeof(TValue));
+    }
+    dasm_put(Dst, 1933, Dt4(->func), Dt4(->func), sizeof(CallInfo), Dt1(->ci));
+    return;
+  }
+
+  if (!J->pt->is_vararg) {  /* Fixarg function, nresults >= 0. */
+    int i;
+    dasm_put(Dst, 1980, Dt1(->ci), sizeof(CallInfo), sizeof(TValue));
+    for (i = 0; i < nresults; i++) {
+      if (J->flags & JIT_F_CPU_SSE2) {
+      dasm_put(Dst, 821, Dt2([rbase+i+1].tt), Dt2([rbase+i+1].value), Dt2([i].tt), Dt2([i].value));
+      } else {
+      dasm_put(Dst, 839, Dt2([rbase+i+1].value), Dt2([rbase+i+1].value.na[1]), Dt2([rbase+i+1].tt), Dt2([i].value), Dt2([i].value.na[1]), Dt2([i].tt));
+      }
+    }
+    dasm_put(Dst, 1989, Dt2([nresults]));
+  } else {  /* Vararg function, nresults >= 0. */
+    int i;
+    dasm_put(Dst, 1997, Dt1(->ci), Dt4(->func), sizeof(CallInfo), Dt1(->ci));
+    for (i = 0; i < nresults; i++) {
+      if (J->flags & JIT_F_CPU_SSE2) {
+      dasm_put(Dst, 1659, Dt2([rbase+i].tt), Dt2([rbase+i].value), Dt3([i].tt), Dt3([i].value));
+      } else {
+      dasm_put(Dst, 2010, Dt2([rbase+i].value), Dt2([rbase+i].value.na[1]), Dt2([rbase+i].tt), Dt3([i].value), Dt3([i].value.na[1]), Dt3([i].tt));
+      }
+    }
+    dasm_put(Dst, 2029);
+    if (nresults) {
+    dasm_put(Dst, 2036, nresults*sizeof(TValue));
+    }
+    dasm_put(Dst, 32);
+  }
+}
+
+static void jit_op_call(jit_State *J, int func, int nargs, int nresults)
+{
+  int cltype = jit_inline_call(J, func, nargs, nresults);
+  if (cltype < 0) return;  /* Inlined? */
+
+  if (func) {
+  dasm_put(Dst, 787, func*sizeof(TValue));
+  }
+  dasm_put(Dst, 2040, Dt1(->ci), Dt2([0].tt));
+  if (nargs >= 0) {  /* Previous op was not open and did not set TOP. */
+    dasm_put(Dst, 791, Dt2([1+nargs]));
+  }
+  dasm_put(Dst, 2048, Dt2(->value), (ptrdiff_t)(J->nextins), Dt4(->savedpc));
+  if (cltype == LUA_TFUNCTION) {
+    if (nargs == -1) {
+      dasm_put(Dst, 2057);
+    } else {
+      dasm_put(Dst, 2062);
+    }
+  } else {
+    dasm_put(Dst, 2067);
+
+  }
+  dasm_put(Dst, 2116, Dt5(->jit_gate));
+  if (func) {
+  dasm_put(Dst, 1984, func*sizeof(TValue));
+  }
+  dasm_put(Dst, 2121, Dt1(->base));
+
+  /* Clear undefined results TOP <= o < func+nresults. */
+  if (nresults > 0) {
+    dasm_put(Dst, 2125);
+    if (nresults <= EXTRA_STACK) {  /* Loopless clear. May use EXTRA_STACK. */
+      int i;
+      for (i = 0; i < nresults; i++) {
+        dasm_put(Dst, 1712, Dt3([i].tt));
+      }
+    } else {  /* Standard loop. TODO: move to .tail? */
+      dasm_put(Dst, 2128, Dt2([func+nresults]), Dt3([0].tt), Dt3([1].tt), 2*sizeof(TValue));
+    }
+  }
+
+  if (nresults >= 0) {  /* Not an open ins. Restore L->top. */
+    dasm_put(Dst, 1445, Dt2([J->pt->maxstacksize]), Dt1(->top));
+  }  /* Otherwise keep TOP for next instruction. */
+}
+
+static void jit_op_tailcall(jit_State *J, int func, int nargs)
+{
+  int cltype;
+
+  if (!fhint_isset(J, NOCLOSE)) {  /* May need to close open upvalues. */
+    dasm_put(Dst, 1820, (ptrdiff_t)(luaF_close));
+  }
+
+  cltype = jit_inline_call(J, func, nargs, -2);
+  if (cltype < 0) goto finish;  /* Inlined? */
+
+  if (cltype == LUA_TFUNCTION) {
+    jit_deopt_target(J, nargs);
+    dasm_put(Dst, 2149, Dt2([func].tt));
+  } else {
+    dasm_put(Dst, 2158, Dt2([func].tt));
+    dasm_put(Dst, 2168);
+    if (func) {
+    dasm_put(Dst, 787, func*sizeof(TValue));
+    }
+    if (nargs >= 0) {
+      dasm_put(Dst, 791, Dt2([1+nargs]));
+    }
+    dasm_put(Dst, 2171, (ptrdiff_t)(J->nextins));
+
+  }
+
+  if (nargs >= 0) {  /* Previous op was not open and did not set TOP. */
+    int i;
+    /* Relocate [BASE+func, BASE+func+nargs] -> [ci->func, ci->func+nargs]. */
+    /* TODO: loop for large nargs? */
+    if (!J->pt->is_vararg) {  /* Fixarg function. */
+      dasm_put(Dst, 2241, Dt2([func].value));
+      for (i = 0; i < nargs; i++) {
+        if (J->flags & JIT_F_CPU_SSE2) {
+        dasm_put(Dst, 821, Dt2([func+1+i].tt), Dt2([func+1+i].value), Dt2([i].tt), Dt2([i].value));
+        } else {
+        dasm_put(Dst, 2245, Dt2([func+1+i].value), Dt2([func+1+i].value.na[1]), Dt2([i].value), Dt2([func+1+i].tt), Dt2([i].value.na[1]), Dt2([i].tt));
+        }
+      }
+      dasm_put(Dst, 2264, Dt2([nargs]), sizeof(TValue), Dt1(->ci), Dt2(->value));
+    } else {  /* Vararg function. */
+      dasm_put(Dst, 2278, Dt1(->ci), Dt2([func]), Dt4(->func), Dt3(->value), Dt2(->value));
+      for (i = 0; i < nargs; i++) {
+        if (J->flags & JIT_F_CPU_SSE2) {
+        dasm_put(Dst, 2294, Dt3([i+1].tt), Dt3([i+1].value), Dt2([i+1].tt), Dt2([i+1].value));
+        } else {
+        dasm_put(Dst, 2312, Dt3([i+1].value), Dt3([i+1].value.na[1]), Dt2([i+1].value), Dt3([i+1].tt), Dt2([i+1].value.na[1]), Dt2([i+1].tt));
+        }
+      }
+      dasm_put(Dst, 2331, Dt2([1+nargs]), Dt2(->value));
+    }
+  } else {  /* Previous op was open and set TOP. */
+    dasm_put(Dst, 332, Dt1(->ci));
+    if (func) {
+    dasm_put(Dst, 787, func*sizeof(TValue));
+    }
+    dasm_put(Dst, 2338, Dt4(->func), Dt4(->func), Dt2(->value));
+  }
+  dasm_put(Dst, 2230, sizeof(CallInfo), Dt5(->jit_gate));
+
+finish:
+  J->combine++;  /* Combine with following return instruction. */
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_move(jit_State *J, int dest, int src)
+{
+  if (J->flags & JIT_F_CPU_SSE2) {
+  dasm_put(Dst, 821, Dt2([src].tt), Dt2([src].value), Dt2([dest].tt), Dt2([dest].value));
+  } else {
+  dasm_put(Dst, 839, Dt2([src].value), Dt2([src].value.na[1]), Dt2([src].tt), Dt2([dest].value), Dt2([dest].value.na[1]), Dt2([dest].tt));
+  }
+}
+
+static void jit_op_loadk(jit_State *J, int dest, int kidx)
+{
+  const TValue *kk = &J->pt->k[kidx];
+  int rk = jit_return_k(J);
+  if (rk) dest = 0;
+  switch (ttype(kk)) {
+  case 0:
+  dasm_put(Dst, 2369, Dt2([dest].tt));
+    break;
+  case 1:
+  if (bvalue(kk)) {  /* true */
+  dasm_put(Dst, 2377, Dt2([dest].value), Dt2([dest].tt));
+  } else {  /* false */
+  dasm_put(Dst, 2389, Dt2([dest].value), Dt2([dest].tt));
+  }
+    break;
+  case 3: {
+  if ((&(kk)->value)->n == (lua_Number)0) {
+  dasm_put(Dst, 2404);
+  } else if ((&(kk)->value)->n == (lua_Number)1) {
+  dasm_put(Dst, 2408);
+  } else {
+  dasm_put(Dst, 2411, &(kk)->value);
+  }
+  dasm_put(Dst, 1306, Dt2([dest].value), Dt2([dest].tt));
+    break;
+  }
+  case 4:
+  dasm_put(Dst, 2415, Dt2([dest].value), (ptrdiff_t)(gcvalue(kk)), Dt2([dest].tt));
+    break;
+  default: lua_assert(0); break;
+  }
+  if (rk) {
+    dasm_put(Dst, 32);
+  }
+}
+
+static void jit_op_loadnil(jit_State *J, int first, int last)
+{
+  int idx, num = last - first + 1;
+  int rk = jit_return_k(J);
+  dasm_put(Dst, 2125);
+  if (rk) {
+    dasm_put(Dst, 2427, Dt2([0].tt));
+  } else if (num <= 8) {
+    for (idx = first; idx <= last; idx++) {
+      dasm_put(Dst, 854, Dt2([idx].tt));
+    }
+  } else {
+    dasm_put(Dst, 2432, Dt2([first].tt), Dt2([last].tt), sizeof(TValue));
+  }
+}
+
+static void jit_op_loadbool(jit_State *J, int dest, int b, int dojump)
+{
+  int rk = jit_return_k(J);
+  if (rk) dest = 0;
+  if (b) {  /* true */
+  dasm_put(Dst, 2377, Dt2([dest].value), Dt2([dest].tt));
+  } else {  /* false */
+  dasm_put(Dst, 2389, Dt2([dest].value), Dt2([dest].tt));
+  }
+  if (rk) {
+    dasm_put(Dst, 32);
+  } else if (dojump) {
+    const TValue *h = hint_getpc(J, COMBINE, J->nextpc);
+    if (!(ttisboolean(h) && bvalue(h) == 0)) {  /* Avoid jmp around dead ins. */
+      dasm_put(Dst, 665, J->nextpc+1);
+    }
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_getupval(jit_State *J, int dest, int uvidx)
+{
+  if (!J->pt->is_vararg) {
+  dasm_put(Dst, 2241, Dt2([-1].value));
+  } else {
+  dasm_put(Dst, 2452, Dt1(->ci), Dt4(->func), Dt3(->value));
+  }
+  dasm_put(Dst, 2462, Dt5(->upvals[uvidx]), DtF(->v));
+  if (J->flags & JIT_F_CPU_SSE2) {
+  dasm_put(Dst, 2469, Dt3([0].tt), Dt3([0].value), Dt2([dest].tt), Dt2([dest].value));
+  } else {
+  dasm_put(Dst, 2487, Dt3([0].value), Dt3([0].value.na[1]), Dt3([0].tt), Dt2([dest].value), Dt2([dest].value.na[1]), Dt2([dest].tt));
+  }
+}
+
+static void jit_op_setupval(jit_State *J, int src, int uvidx)
+{
+  if (!J->pt->is_vararg) {
+  dasm_put(Dst, 2241, Dt2([-1].value));
+  } else {
+  dasm_put(Dst, 2452, Dt1(->ci), Dt4(->func), Dt3(->value));
+  }
+  dasm_put(Dst, 2506, Dt5(->upvals[uvidx]), DtF(->v), Dt2([src].tt), Dt2([src].value), Dt3(->tt), Dt2([src].value.na[1]), Dt3(->value), Dt3(->value.na[1]));
+  dasm_put(Dst, 2542, DtA(->gch.marked), WHITEBITS, DtF(->marked), bitmask(BLACKBIT));
+
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Optimized table lookup routines. Enter via jsub, fallback to C. */
+
+/* Fallback for GETTABLE_*. Temporary key is in L->env. */
+static void jit_gettable_fb(lua_State *L, Table *t, StkId dest)
+{
+  Table *mt = t->metatable;
+  const TValue *tm = luaH_getstr(mt, G(L)->tmname[TM_INDEX]);
+  if (ttisnil(tm)) {  /* No __index method? */
+    mt->flags |= 1<<TM_INDEX;  /* Cache this fact. */
+    setnilvalue(dest);
+  } else if (ttisfunction(tm)) {  /* __index function? */
+    ptrdiff_t destr = savestack(L, dest);
+    setobj2s(L, L->top, tm);
+    sethvalue(L, L->top+1, t);
+    setobj2s(L, L->top+2, &L->env);
+    luaD_checkstack(L, 3);
+    L->top += 3;
+    luaD_call(L, L->top - 3, 1);
+    dest = restorestack(L, destr);
+    L->top--;
+    setobjs2s(L, dest, L->top);
+  } else {  /* Let luaV_gettable() continue with the __index object. */
+    luaV_gettable(L, tm, &L->env, dest);
+  }
+
+}
+
+/* Fallback for SETTABLE_*STR. Temporary (string) key is in L->env. */
+static void jit_settable_fb(lua_State *L, Table *t, StkId val)
+{
+  Table *mt = t->metatable;
+  const TValue *tm = luaH_getstr(mt, G(L)->tmname[TM_NEWINDEX]);
+  if (ttisnil(tm)) {  /* No __newindex method? */
+    mt->flags |= 1<<TM_NEWINDEX;  /* Cache this fact. */
+    t->flags = 0;  /* But need to clear the cache for the table itself. */
+    setobj2t(L, luaH_setstr(L, t, rawtsvalue(&L->env)), val);
+    luaC_barriert(L, t, val);
+  } else if (ttisfunction(tm)) {  /* __newindex function? */
+    setobj2s(L, L->top, tm);
+    sethvalue(L, L->top+1, t);
+    setobj2s(L, L->top+2, &L->env);
+    setobj2s(L, L->top+3, val);
+    luaD_checkstack(L, 4);
+    L->top += 4;
+    luaD_call(L, L->top - 4, 0);
+  } else {  /* Let luaV_settable() continue with the __newindex object. */
+    luaV_settable(L, tm, &L->env, val);
+  }
+
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_newtable(jit_State *J, int dest, int lnarray, int lnhash)
+{
+  dasm_put(Dst, 3158, luaO_fb2int(lnarray), luaO_fb2int(lnhash), (ptrdiff_t)(luaH_new), Dt2([dest].value), Dt2([dest].tt));
+  jit_checkGC(J);
+}
+
+static void jit_op_getglobal(jit_State *J, int dest, int kidx)
+{
+  const TValue *kk = &J->pt->k[kidx];
+  jit_assert(ttisstring(kk));
+  dasm_put(Dst, 3184, (ptrdiff_t)(&kk->value.gc->ts));
+  if (dest) {
+  dasm_put(Dst, 787, dest*sizeof(TValue));
+  }
+  dasm_put(Dst, 3187);
+}
+
+static void jit_op_setglobal(jit_State *J, int rval, int kidx)
+{
+  const TValue *kk = &J->pt->k[kidx];
+  jit_assert(ttisstring(kk));
+  dasm_put(Dst, 3184, (ptrdiff_t)(&kk->value.gc->ts));
+  if (rval) {
+  dasm_put(Dst, 787, rval*sizeof(TValue));
+  }
+  dasm_put(Dst, 3191);
+}
+
+enum { TKEY_KSTR = -2, TKEY_STR = -1, TKEY_ANY = 0 };
+
+/* Optimize key lookup depending on consts or hints type. */
+static int jit_keylookup(jit_State *J, int tab, int rkey)
+{
+  const TValue *tabt = hint_get(J, TYPE);
+  const TValue *key;
+  if (!ttistable(tabt)) return TKEY_ANY;  /* Not a table? Use fallback. */
+  key = ISK(rkey) ? &J->pt->k[INDEXK(rkey)] : hint_get(J, TYPEKEY);
+  if (ttisstring(key)) {  /* String key? */
+    if (ISK(rkey)) {
+      dasm_put(Dst, 3195, Dt2([tab]), (ptrdiff_t)(&key->value.gc->ts));
+      return TKEY_KSTR;  /* Const string key. */
+    } else {
+      dasm_put(Dst, 3201, Dt2([tab]), Dt2([rkey]));
+      return TKEY_STR;  /* Var string key. */
+    }
+  } else if (ttisnumber(key)) {  /* Number key? */
+    lua_Number n = nvalue(key);
+    int k;
+    lua_number2int(k, n);
+    if (!(k >= 1 && k < (1 << 26) && (lua_Number)k == n))
+      return TKEY_ANY;  /* Not a proper array key? Use fallback. */
+    if (ISK(rkey)) {
+      dasm_put(Dst, 3208, Dt2([tab].tt), Dt2([tab].value), k, DtC(->array), DtC(->sizearray));
+      return k;  /* Const array key (>= 1). */
+    } else {
+      dasm_put(Dst, 3232, Dt2([tab].tt), Dt2([rkey].tt));
+      if (J->flags & JIT_F_CPU_SSE2) {
+        dasm_put(Dst, 3250, Dt2([rkey]), Dt2([tab].value));
+      } else {
+        dasm_put(Dst, 3283, Dt2([rkey].value));
+        if (J->flags & JIT_F_CPU_CMOV) {
+        dasm_put(Dst, 3293);
+        } else {
+        dasm_put(Dst, 3298);
+        }
+        dasm_put(Dst, 3304, Dt2([tab].value));
+      }
+      dasm_put(Dst, 3320, DtC(->sizearray), DtC(->array));
+      return 1;  /* Variable array key. */
+    }
+  }
+  return TKEY_ANY;  /* Use fallback. */
+}
+
+static void jit_op_gettable(jit_State *J, int dest, int tab, int rkey)
+{
+  int k = jit_keylookup(J, tab, rkey);
+  switch (k) {
+  case TKEY_KSTR:  /* Const string key. */
+    if (dest) {
+    dasm_put(Dst, 787, dest*sizeof(TValue));
+    }
+    dasm_put(Dst, 3334);
+    break;
+  case TKEY_STR:  /* Variable string key. */
+    if (dest) {
+    dasm_put(Dst, 787, dest*sizeof(TValue));
+    }
+    dasm_put(Dst, 3338);
+    break;
+  case TKEY_ANY:  /* Generic gettable fallback. */
+    if (ISK(rkey)) {
+      dasm_put(Dst, 3342, (ptrdiff_t)(&J->pt->k[INDEXK(rkey)]));
+    } else {
+      dasm_put(Dst, 3204, Dt2([rkey]));
+    }
+    dasm_put(Dst, 3345, Dt2([tab]));
+    if (dest) {
+    dasm_put(Dst, 787, dest*sizeof(TValue));
+    }
+    dasm_put(Dst, 3349, Dt1(->savedpc), (ptrdiff_t)(J->nextins), (ptrdiff_t)(luaV_gettable), Dt1(->base));
+    break;
+  default:  /* Array key. */
+    dasm_put(Dst, 3366, Dt7([k-1].tt));
+    if (J->flags & JIT_F_CPU_SSE2) {
+      dasm_put(Dst, 2674, Dt7([k-1].value), Dt2([dest].value));
+    } else {
+      dasm_put(Dst, 3378, Dt7([k-1].value), Dt7([k-1].value.na[1]), Dt2([dest].value), Dt2([dest].value.na[1]));
+    }
+    dasm_put(Dst, 3391, Dt2([dest].tt));
+    dasm_put(Dst, 2168);
+    if (ISK(rkey)) {
+      dasm_put(Dst, 3398);
+    } else {
+      dasm_put(Dst, 3402);
+    }
+    dasm_put(Dst, 3406, DtC(->metatable), DtC(->flags), 1<<TM_INDEX, (ptrdiff_t)(J->nextins));
+    break;
+  }
+
+}
+
+static void jit_op_settable(jit_State *J, int tab, int rkey, int rval)
+{
+  const TValue *val = ISK(rval) ? &J->pt->k[INDEXK(rval)] : NULL;
+  int k = jit_keylookup(J, tab, rkey);
+  switch (k) {
+  case TKEY_KSTR:  /* Const string key. */
+  case TKEY_STR:  /* Variable string key. */
+    if (ISK(rval)) {
+      dasm_put(Dst, 3492, (ptrdiff_t)(val));
+    } else {
+      if (rval) {
+      dasm_put(Dst, 787, rval*sizeof(TValue));
+      }
+    }
+    if (k == TKEY_KSTR) {
+      dasm_put(Dst, 3495);
+    } else {
+      dasm_put(Dst, 3499);
+    }
+    break;
+  case TKEY_ANY:  /* Generic settable fallback. */
+    if (ISK(rkey)) {
+      dasm_put(Dst, 3342, (ptrdiff_t)(&J->pt->k[INDEXK(rkey)]));
+    } else {
+      dasm_put(Dst, 3204, Dt2([rkey]));
+    }
+    if (ISK(rval)) {
+      dasm_put(Dst, 3184, (ptrdiff_t)(val));
+    } else {
+      dasm_put(Dst, 3345, Dt2([rval]));
+    }
+    if (tab) {
+    dasm_put(Dst, 787, tab*sizeof(TValue));
+    }
+    dasm_put(Dst, 3503, Dt1(->savedpc), (ptrdiff_t)(J->nextins), (ptrdiff_t)(luaV_settable), Dt1(->base));
+    break;
+  default:  /* Array key. */
+    dasm_put(Dst, 3520, Dt7([k-1].tt));
+    dasm_put(Dst, 2168);
+    if (ISK(rkey)) {
+      dasm_put(Dst, 3534);
+    } else {
+      dasm_put(Dst, 3538);
+    }
+    dasm_put(Dst, 3406, DtC(->metatable), DtC(->flags), 1<<TM_NEWINDEX, (ptrdiff_t)(J->nextins));
+    if (!ISK(rval) || iscollectable(val)) {
+      dasm_put(Dst, 3542, DtC(->marked), bitmask(BLACKBIT));
+      dasm_put(Dst, 3555);
+    }
+    if (ISK(rval)) {
+      switch (ttype(val)) {
+      case 0:
+      dasm_put(Dst, 3565, Dt7([k-1].tt));
+        break;
+      case 1:
+      if (bvalue(val)) {  /* true */
+      dasm_put(Dst, 3573, Dt7([k-1].value), Dt7([k-1].tt));
+      } else {  /* false */
+      dasm_put(Dst, 3585, Dt7([k-1].value), Dt7([k-1].tt));
+      }
+        break;
+      case 3: {
+      if ((&(val)->value)->n == (lua_Number)0) {
+      dasm_put(Dst, 2404);
+      } else if ((&(val)->value)->n == (lua_Number)1) {
+      dasm_put(Dst, 2408);
+      } else {
+      dasm_put(Dst, 2411, &(val)->value);
+      }
+      dasm_put(Dst, 3600, Dt7([k-1].value), Dt7([k-1].tt));
+        break;
+      }
+      case 4:
+      dasm_put(Dst, 3611, Dt7([k-1].value), (ptrdiff_t)(gcvalue(val)), Dt7([k-1].tt));
+        break;
+      default: lua_assert(0); break;
+      }
+    } else {
+      if (J->flags & JIT_F_CPU_SSE2) {
+      dasm_put(Dst, 2947, Dt2([rval].tt), Dt2([rval].value), Dt7([k-1].tt), Dt7([k-1].value));
+      } else {
+      dasm_put(Dst, 2965, Dt2([rval].value), Dt2([rval].value.na[1]), Dt2([rval].tt), Dt7([k-1].value), Dt7([k-1].value.na[1]), Dt7([k-1].tt));
+      }
+    }
+    break;
+  }
+
+}
+
+static void jit_op_self(jit_State *J, int dest, int tab, int rkey)
+{
+  if (J->flags & JIT_F_CPU_SSE2) {
+  dasm_put(Dst, 821, Dt2([tab].tt), Dt2([tab].value), Dt2([dest+1].tt), Dt2([dest+1].value));
+  } else {
+  dasm_put(Dst, 839, Dt2([tab].value), Dt2([tab].value.na[1]), Dt2([tab].tt), Dt2([dest+1].value), Dt2([dest+1].value.na[1]), Dt2([dest+1].tt));
+  }
+  jit_op_gettable(J, dest, tab, rkey);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_setlist(jit_State *J, int ra, int num, int batch)
+{
+  if (batch == 0) { batch = (int)(*J->nextins); J->combine++; }
+  batch = (batch-1)*LFIELDS_PER_FLUSH;
+  if (num == 0) {  /* Previous op was open and set TOP: {f()} or {...}. */
+    dasm_put(Dst, 3685, Dt1(->env.value), Dt2([ra+1]), Dt2([ra].value));
+    if (batch > 0) {
+      dasm_put(Dst, 3709, batch);
+    }
+    dasm_put(Dst, 3713, DtC(->sizearray), (ptrdiff_t)(luaH_resizearray), DtC(->marked), bitmask(BLACKBIT), DtC(->array), Dt1(->env.value));
+    dasm_put(Dst, 3752);
+  } else {  /* Set fixed number of args. */
+    dasm_put(Dst, 3762, Dt2([ra].value), DtC(->sizearray), batch+num, DtC(->marked), bitmask(BLACKBIT), DtC(->array), Dt2([ra+1+num]));
+    dasm_put(Dst, 3792, batch+num, (ptrdiff_t)(luaH_resizearray));
+  }
+  if (batch > 0) {
+    dasm_put(Dst, 3821, batch*sizeof(TValue));
+  }
+  dasm_put(Dst, 3825, Dt2([ra+1]));
+  if (num == 0) {  /* Previous op was open. Restore L->top. */
+    dasm_put(Dst, 1445, Dt2([J->pt->maxstacksize]), Dt1(->top));
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_arith(jit_State *J, int dest, int rkb, int rkc, int ev)
+{
+  const TValue *kkb = ISK(rkb) ? &J->pt->k[INDEXK(rkb)] : NULL;
+  const TValue *kkc = ISK(rkc) ? &J->pt->k[INDEXK(rkc)] : NULL;
+  const Value *kval;
+  int idx, rev;
+  int target = (ev == TM_LT || ev == TM_LE) ? jit_jmp_target(J) : 0;
+  int hastail = 0;
+
+  /* The bytecode compiler already folds constants except for: k/0, k%0, */
+  /* NaN results, k1<k2, k1<=k2. No point in optimizing these cases. */
+  if (ISK(rkb&rkc)) goto fallback;
+
+  /* Avoid optimization when non-numeric constants are present. */
+  if (kkb ? !ttisnumber(kkb) : (kkc && !ttisnumber(kkc))) goto fallback;
+
+  /* The TYPE hint selects numeric inlining and/or fallback encoding. */
+  switch (ttype(hint_get(J, TYPE))) {
+  case LUA_TNIL: hastail = 1; break;  /* No hint: numeric + fallback. */
+  case LUA_TNUMBER: break;            /* Numbers: numeric + deoptimization. */
+  default: goto fallback;             /* Mixed/other types: fallback only. */
+  }
+
+  /* The checks above ensure: at most one of the operands is a constant. */
+  /* Reverse operation and swap operands so the 2nd operand is a variable. */
+  if (kkc) { kval = &kkc->value; idx = rkb; rev = 1; }
+  else { kval = kkb ? &kkb->value : NULL; idx = rkc; rev = 0; }
+
+  /* Special handling for some operators. */
+  switch (ev) {
+  case TM_MOD:
+    /* Check for modulo with positive numbers, so we can use fprem. */
+    if (kval) {
+      if (kval->na[1] < 0) { hastail = 0; goto fallback; }  /* x%-k, -k%x */
+      dasm_put(Dst, 3850, Dt2([idx].tt), Dt2([idx].value.na[1]));
+      if (kkb) {
+        dasm_put(Dst, 3868, Dt2([rkc].value), kval);
+      } else {
+        dasm_put(Dst, 3875, kval, Dt2([rkb].value));
+      }
+    } else {
+      dasm_put(Dst, 3882, Dt2([rkb].tt), Dt2([rkc].tt), Dt2([rkb].value.na[1]), Dt2([rkc].value.na[1]), Dt2([rkc].value), Dt2([rkb].value));
+    }
+    dasm_put(Dst, 1387);
+    goto fpstore;
+  case TM_POW:
+    if (hastail || !kval) break;  /* Avoid this if not optimizing. */
+    if (rev) {  /* x^k for k > 0, k integer. */
+      lua_Number n = kval->n;
+      int k;
+      lua_number2int(k, n);
+      /* All positive integers would work. But need to limit code explosion. */
+      if (k > 0 && k <= 65536 && (lua_Number)k == n) {
+        dasm_put(Dst, 3916, Dt2([idx].tt), Dt2([idx]));
+        for (; (k & 1) == 0; k >>= 1) {  /* Handle leading zeroes (2^k). */
+          dasm_put(Dst, 3928);
+        }
+        if ((k >>= 1) != 0) {  /* Handle trailing bits. */
+          dasm_put(Dst, 3931);
+          for (; k != 1; k >>= 1) {
+            if (k & 1) {
+              dasm_put(Dst, 3936);
+            }
+            dasm_put(Dst, 3928);
+          }
+          dasm_put(Dst, 3939);
+        }
+        goto fpstore;
+      }
+    } else if (kval->n > (lua_Number)0) {  /* k^x for k > 0. */
+      int log2kval[3];  /* Enough storage for a tword (80 bits). */
+      log2kval[2] = 0;  /* Avoid leaking garbage. */
+      /* Double precision log2(k) doesn't cut it (3^x != 3 for x = 1). */
+      ((void (*)(int *, double))J->jsub[JSUB_LOG2_TWORD])(log2kval, kval->n);
+      dasm_put(Dst, 3942, log2kval[0], log2kval[1], log2kval[2], Dt2([idx].tt), Dt2([idx].value));
+
+      goto fpstore;
+    }
+    break;
+  }
+
+  /* Check number type and load 1st operand. */
+  if (kval) {
+    dasm_put(Dst, 4013, Dt2([idx].tt));
+    if ((kval)->n == (lua_Number)0) {
+    dasm_put(Dst, 2404);
+    } else if ((kval)->n == (lua_Number)1) {
+    dasm_put(Dst, 2408);
+    } else {
+    dasm_put(Dst, 2411, kval);
+    }
+  } else {
+    if (rkb == rkc) {
+      dasm_put(Dst, 4022, Dt2([rkb].tt));
+    } else {
+      dasm_put(Dst, 4027, Dt2([rkb].tt), Dt2([rkc].tt));
+    }
+    dasm_put(Dst, 3920, Dt2([rkb].value));
+  }
+
+  /* Encode arithmetic operation with 2nd operand. */
+  switch ((ev<<1)+rev) {
+  case TM_ADD<<1: case (TM_ADD<<1)+1:
+    if (rkb == rkc) {
+      dasm_put(Dst, 4041);
+    } else {
+      dasm_put(Dst, 4044, Dt2([idx].value));
+    }
+    break;
+  case TM_SUB<<1:
+    dasm_put(Dst, 4048, Dt2([idx].value));
+    break;
+  case (TM_SUB<<1)+1:
+    dasm_put(Dst, 4052, Dt2([idx].value));
+    break;
+  case TM_MUL<<1: case (TM_MUL<<1)+1:
+    if (rkb == rkc) {
+      dasm_put(Dst, 3928);
+    } else {
+      dasm_put(Dst, 4056, Dt2([idx].value));
+    }
+    break;
+  case TM_DIV<<1:
+    dasm_put(Dst, 4060, Dt2([idx].value));
+    break;
+  case (TM_DIV<<1)+1:
+    dasm_put(Dst, 4064, Dt2([idx].value));
+    break;
+  case TM_POW<<1:
+    dasm_put(Dst, 4068, Dt2([idx].value), (ptrdiff_t)(pow));
+    break;
+  case (TM_POW<<1)+1:
+    dasm_put(Dst, 4088, Dt2([idx].value), (ptrdiff_t)(pow));
+    break;
+  case TM_UNM<<1: case (TM_UNM<<1)+1:
+    dasm_put(Dst, 4108);
+    break;
+  default:  /* TM_LT or TM_LE. */
+    dasm_put(Dst, 1325, Dt2([idx].value));
+    if (J->flags & JIT_F_CPU_CMOV) {
+    dasm_put(Dst, 3293);
+    } else {
+    dasm_put(Dst, 3298);
+    }
+    dasm_put(Dst, 4111, dest?(J->nextpc+1):target);
+    jit_assert(dest == 0 || dest == 1);  /* Really cond. */
+    switch (((rev^dest)<<1)+(dest^(ev == TM_LT))) {
+    case 0:
+      dasm_put(Dst, 4115, target);
+      break;
+    case 1:
+      dasm_put(Dst, 4119, target);
+      break;
+    case 2:
+      dasm_put(Dst, 4123, target);
+      break;
+    case 3:
+      dasm_put(Dst, 4127, target);
+      break;
+    }
+    goto skipstore;
+  }
+fpstore:
+  /* Store result and set result type (if necessary). */
+  dasm_put(Dst, 933, Dt2([dest].value));
+  if (dest != rkb && dest != rkc) {
+    dasm_put(Dst, 1309, Dt2([dest].tt));
+  }
+
+skipstore:
+  if (!hastail) {
+    jit_deopt_target(J, 0);
+    return;
+  }
+
+  dasm_put(Dst, 1626);
+  dasm_put(Dst, 1541);
+
+fallback:
+  /* Generic fallback for arithmetic ops. */
+  if (kkb) {
+    dasm_put(Dst, 3342, (ptrdiff_t)(kkb));
+  } else {
+    dasm_put(Dst, 3204, Dt2([rkb]));
+  }
+  if (kkc) {
+    dasm_put(Dst, 3184, (ptrdiff_t)(kkc));
+  } else {
+    dasm_put(Dst, 3345, Dt2([rkc]));
+  }
+  if (target) {  /* TM_LT or TM_LE. */
+    dasm_put(Dst, 4131, Dt1(->savedpc), (ptrdiff_t)((J->nextins+1)), (ptrdiff_t)(ev==TM_LT?luaV_lessthan:luaV_lessequal), Dt1(->base));
+    if (dest) {  /* cond */
+      dasm_put(Dst, 1479, target);
+    } else {
+      dasm_put(Dst, 4154, target);
+    }
+  } else {
+    if (dest) {
+    dasm_put(Dst, 787, dest*sizeof(TValue));
+    }
+    dasm_put(Dst, 4158, Dt1(->savedpc), (ptrdiff_t)(J->nextins), ev, (ptrdiff_t)(luaV_arith), Dt1(->base));
+  }
+
+  if (hastail) {
+    dasm_put(Dst, 1644);
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_fallback_len(lua_State *L, StkId ra, const TValue *rb)
+{
+  switch (ttype(rb)) {
+  case LUA_TTABLE:
+    setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));
+    break;
+  case LUA_TSTRING:
+    setnvalue(ra, cast_num(tsvalue(rb)->len));
+    break;
+  default: {
+    const TValue *tm = luaT_gettmbyobj(L, rb, TM_LEN);
+    if (ttisfunction(tm)) {
+      ptrdiff_t rasave = savestack(L, ra);
+      setobj2s(L, L->top, tm);
+      setobj2s(L, L->top+1, rb);
+      luaD_checkstack(L, 2);
+      L->top += 2;
+      luaD_call(L, L->top - 2, 1);
+      ra = restorestack(L, rasave);
+      L->top--;
+      setobjs2s(L, ra, L->top);
+    } else {
+      luaG_typeerror(L, rb, "get length of");
+    }
+    break;
+  }
+  }
+}
+
+static void jit_op_len(jit_State *J, int dest, int rb)
+{
+  switch (ttype(hint_get(J, TYPE))) {
+  case LUA_TTABLE:
+    jit_deopt_target(J, 0);
+    dasm_put(Dst, 4179, Dt2([rb].tt), Dt2([rb].value), (ptrdiff_t)(luaH_getn), Dt2([dest].value), Dt2([dest].tt));
+    break;
+  case LUA_TSTRING:
+    jit_deopt_target(J, 0);
+    dasm_put(Dst, 4212, Dt2([rb].tt), Dt2([rb].value), DtB(->tsv.len), Dt2([dest].value), Dt2([dest].tt));
+    break;
+  default:
+    dasm_put(Dst, 3204, Dt2([rb]));
+    if (dest) {
+    dasm_put(Dst, 787, dest*sizeof(TValue));
+    }
+    dasm_put(Dst, 4237, Dt1(->savedpc), (ptrdiff_t)(J->nextins), (ptrdiff_t)(jit_fallback_len), Dt1(->base));
+    break;
+  }
+}
+
+static void jit_op_not(jit_State *J, int dest, int rb)
+{
+  /* l_isfalse() without a branch -- truly devious. */
+  /* ((value & tt) | (tt>>1)) is only zero for nil/false. */
+  /* Assumes: LUA_TNIL == 0, LUA_TBOOLEAN == 1, bvalue() == 0/1 */
+  dasm_put(Dst, 4258, Dt2([rb].tt), Dt2([rb].value), Dt2([dest].tt), Dt2([dest].value));
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_concat(jit_State *J, int dest, int first, int last)
+{
+  int num = last-first+1;
+  if (num == 2 && ttisstring(hint_get(J, TYPE))) {  /* Optimize common case. */
+    if (first) {
+    dasm_put(Dst, 787, first*sizeof(TValue));
+    }
+    dasm_put(Dst, 4288, Dt2([dest].value), Dt2([dest].tt));
+  } else {  /* Generic fallback. */
+    dasm_put(Dst, 4302, Dt1(->savedpc), (ptrdiff_t)(J->nextins), num, last, (ptrdiff_t)(luaV_concat), Dt1(->base));
+    if (dest != first) {
+      if (J->flags & JIT_F_CPU_SSE2) {
+      dasm_put(Dst, 821, Dt2([first].tt), Dt2([first].value), Dt2([dest].tt), Dt2([dest].value));
+      } else {
+      dasm_put(Dst, 839, Dt2([first].value), Dt2([first].value.na[1]), Dt2([first].tt), Dt2([dest].value), Dt2([dest].value.na[1]), Dt2([dest].tt));
+      }
+    }
+  }
+  jit_checkGC(J);  /* Always do this, even for the optimized variant. */
+
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_eq(jit_State *J, int cond, int rkb, int rkc)
+{
+  int target = jit_jmp_target(J);
+  int condtarget = cond ? (J->nextpc+1) : target;
+  jit_assert(cond == 0 || cond == 1);
+
+  /* Comparison of two constants. Evaluate at compile time. */
+  if (ISK(rkb&rkc)) {
+    if ((rkb == rkc) == cond) {  /* Constants are already unique. */
+      dasm_put(Dst, 665, target);
+    }
+    return;
+  }
+
+  if (ISK(rkb|rkc)) {  /* Compare a variable and a constant. */
+    const TValue *kk;
+    if (ISK(rkb)) { int t = rkc; rkc = rkb; rkb = t; }  /* rkc holds const. */
+    kk = &J->pt->k[INDEXK(rkc)];
+    switch (ttype(kk)) {
+    case LUA_TNIL:
+      dasm_put(Dst, 4493, Dt2([rkb].tt));
+      break;
+    case LUA_TBOOLEAN:
+      if (bvalue(kk)) {
+        dasm_put(Dst, 4498, Dt2([rkb].tt), Dt2([rkb].value));
+      } else {
+        dasm_put(Dst, 4509, Dt2([rkb].tt), Dt2([rkb].value));
+      }
+      break;
+    case LUA_TNUMBER:
+      dasm_put(Dst, 4517, Dt2([rkb].tt), condtarget, Dt2([rkb].value), &kk->value);
+      if (J->flags & JIT_F_CPU_CMOV) {
+      dasm_put(Dst, 3293);
+      } else {
+      dasm_put(Dst, 3298);
+      }
+      dasm_put(Dst, 4111, condtarget);
+      break;
+    case LUA_TSTRING:
+      dasm_put(Dst, 4531, Dt2([rkb].tt), condtarget, Dt2([rkb].value), (ptrdiff_t)(rawtsvalue(kk)));
+      break;
+    default: jit_assert(0); break;
+    }
+  } else {  /* Compare two variables. */
+    dasm_put(Dst, 4543, Dt2([rkb].tt), Dt2([rkc].tt), condtarget);
+    switch (ttype(hint_get(J, TYPE))) {
+    case LUA_TNUMBER:
+      jit_deopt_target(J, 0);
+      dasm_put(Dst, 4553, Dt2([rkb].value), Dt2([rkc].value));
+      if (J->flags & JIT_F_CPU_CMOV) {
+      dasm_put(Dst, 3293);
+      } else {
+      dasm_put(Dst, 3298);
+      }
+      dasm_put(Dst, 4111, condtarget);
+      break;
+    case LUA_TSTRING:
+      jit_deopt_target(J, 0);
+      dasm_put(Dst, 4568, Dt2([rkb].value), Dt2([rkc].value));
+      break;
+    default:
+      dasm_put(Dst, 4583, Dt2([rkc]), Dt2([rkb]), Dt1(->savedpc), (ptrdiff_t)(J->nextins), (ptrdiff_t)(luaV_equalval), Dt1(->base));
+      break;
+    }
+  }
+  if (cond) {
+    dasm_put(Dst, 4154, target);
+  } else {
+    dasm_put(Dst, 1479, target);
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_test(jit_State *J, int cond, int dest, int src)
+{
+  int target = jit_jmp_target(J);
+
+  /* l_isfalse() without a branch. But this time preserve tt/value. */
+  /* (((value & tt) * 2 + tt) >> 1) is only zero for nil/false. */
+  /* Assumes: 3*tt < 2^32, LUA_TNIL == 0, LUA_TBOOLEAN == 1, bvalue() == 0/1 */
+  dasm_put(Dst, 4611, Dt2([src].tt), Dt2([src].value));
+
+  /* Check if we can omit the stack copy. */
+  if (dest == src) {  /* Yes, invert branch condition. */
+    if (cond) {
+      dasm_put(Dst, 1479, target);
+    } else {
+      dasm_put(Dst, 4154, target);
+    }
+  } else {  /* No, jump around copy code. */
+    if (cond) {
+      dasm_put(Dst, 4627);
+    } else {
+      dasm_put(Dst, 4632);
+    }
+    dasm_put(Dst, 4637, Dt2([src].value.na[1]), Dt2([dest].tt), Dt2([dest].value), Dt2([dest].value.na[1]), target);
+  }
+}
+
+static void jit_op_jmp(jit_State *J, int target)
+{
+  dasm_put(Dst, 665, target);
+}
+
+/* ------------------------------------------------------------------------ */
+
+enum { FOR_IDX, FOR_LIM, FOR_STP, FOR_EXT };
+
+static const char *const jit_for_coerce_error[] = {
+  LUA_QL("for") " initial value must be a number",
+  LUA_QL("for") " limit must be a number",
+  LUA_QL("for") " step must be a number",
+};
+
+/* Try to coerce for slots with strings to numbers in place or complain. */
+static void jit_for_coerce(lua_State *L, TValue *o)
+{
+  int i;
+  for (i = FOR_IDX; i <= FOR_STP; i++, o++) {
+    lua_Number num;
+    if (ttisnumber(o)) continue;
+    if (ttisstring(o) && luaO_str2d(svalue(o), &num)) {
+      setnvalue(o, num);
+    } else {
+      luaG_runerror(L, jit_for_coerce_error[i]);
+    }
+  }
+}
+
+static void jit_op_forprep(jit_State *J, int ra, int target)
+{
+  const TValue *step = hint_get(J, FOR_STEP_K);
+  if (ttisnumber(step)) {
+    dasm_put(Dst, 4654, Dt2([ra+FOR_IDX].tt), Dt2([ra+FOR_LIM].tt), Dt2([ra+FOR_LIM].value), Dt2([ra+FOR_IDX].value), Dt2([ra+FOR_EXT].value));
+    if (J->flags & JIT_F_CPU_CMOV) {
+    dasm_put(Dst, 3293);
+    } else {
+    dasm_put(Dst, 3298);
+    }
+    dasm_put(Dst, 1309, Dt2([ra+FOR_EXT].tt));
+    if (nvalue(step) < (lua_Number)0) {
+      dasm_put(Dst, 4115, target+1);
+    } else {
+      dasm_put(Dst, 4123, target+1);
+    }
+  } else {
+    dasm_put(Dst, 4683, Dt2([ra+FOR_IDX].tt), Dt2([ra+FOR_LIM].tt), Dt2([ra+FOR_STP].tt), Dt2([ra+FOR_STP].value.na[1]), Dt2([ra+FOR_LIM].value), Dt2([ra+FOR_IDX].value), Dt2([ra+FOR_EXT].value));
+    if (J->flags & JIT_F_CPU_CMOV) {
+    dasm_put(Dst, 3293);
+    } else {
+    dasm_put(Dst, 3298);
+    }
+    dasm_put(Dst, 4732, Dt2([ra+FOR_EXT].tt), target+1);
+  }
+  if (ttisnumber(hint_get(J, TYPE))) {
+    jit_deopt_target(J, 0);
+  } else {
+    dasm_put(Dst, 679);
+    dasm_put(Dst, 4743, Dt2([ra]), Dt1(->savedpc), (ptrdiff_t)(J->nextins), (ptrdiff_t)(jit_for_coerce));
+  }
+}
+
+static void jit_op_forloop(jit_State *J, int ra, int target)
+{
+  const TValue *step = hint_getpc(J, FOR_STEP_K, target-1);
+  if (ttisnumber(step)) {
+    dasm_put(Dst, 4766, Dt2([ra+FOR_LIM].value), Dt2([ra+FOR_IDX].value), Dt2([ra+FOR_STP].value), Dt2([ra+FOR_EXT].value), Dt2([ra+FOR_IDX].value), Dt2([ra+FOR_EXT].tt));
+    if (J->flags & JIT_F_CPU_CMOV) {
+    dasm_put(Dst, 3293);
+    } else {
+    dasm_put(Dst, 3298);
+    }
+    if (nvalue(step) < (lua_Number)0) {
+      dasm_put(Dst, 4127, target);
+    } else {
+      dasm_put(Dst, 4119, target);
+    }
+  } else {
+    dasm_put(Dst, 4789, Dt2([ra+FOR_STP].value.na[1]), Dt2([ra+FOR_LIM].value), Dt2([ra+FOR_IDX].value), Dt2([ra+FOR_STP].value), Dt2([ra+FOR_IDX].value), Dt2([ra+FOR_EXT].value), Dt2([ra+FOR_EXT].tt));
+    if (J->flags & JIT_F_CPU_CMOV) {
+    dasm_put(Dst, 3293);
+    } else {
+    dasm_put(Dst, 3298);
+    }
+    dasm_put(Dst, 4127, target);
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_tforloop(jit_State *J, int ra, int nresults)
+{
+  int target = jit_jmp_target(J);
+  int i;
+  if (jit_inline_tforloop(J, ra, nresults, target)) return;  /* Inlined? */
+  for (i = 2; i >= 0; i--) {
+    if (J->flags & JIT_F_CPU_SSE2) {
+    dasm_put(Dst, 821, Dt2([ra+i].tt), Dt2([ra+i].value), Dt2([ra+i+3].tt), Dt2([ra+i+3].value));
+    } else {
+    dasm_put(Dst, 839, Dt2([ra+i].value), Dt2([ra+i].value.na[1]), Dt2([ra+i].tt), Dt2([ra+i+3].value), Dt2([ra+i+3].value.na[1]), Dt2([ra+i+3].tt));
+    }
+  }
+  jit_op_call(J, ra+3, 2, nresults);
+  dasm_put(Dst, 4827, Dt2([ra+3].tt));
+  if (J->flags & JIT_F_CPU_SSE2) {
+  dasm_put(Dst, 821, Dt2([ra+3].tt), Dt2([ra+3].value), Dt2([ra+2].tt), Dt2([ra+2].value));
+  } else {
+  dasm_put(Dst, 839, Dt2([ra+3].value), Dt2([ra+3].value.na[1]), Dt2([ra+3].tt), Dt2([ra+2].value), Dt2([ra+2].value.na[1]), Dt2([ra+2].tt));
+  }
+  dasm_put(Dst, 4649, target);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_close(jit_State *J, int ra)
+{
+  if (ra) {
+    dasm_put(Dst, 4836, Dt2([ra]));
+  } else {
+    dasm_put(Dst, 4844);
+  }
+  dasm_put(Dst, 1734, (ptrdiff_t)(luaF_close));
+}
+
+static void jit_op_closure(jit_State *J, int dest, int ptidx)
+{
+  Proto *npt = J->pt->p[ptidx];
+  int nup = npt->nups;
+  if (!J->pt->is_vararg) {
+  dasm_put(Dst, 4849, Dt2([-1].value));
+  } else {
+  dasm_put(Dst, 4853, Dt1(->ci), Dt4(->func), Dt3(->value));
+  }
+  dasm_put(Dst, 4863, Dt5(->env), nup, (ptrdiff_t)(luaF_newLclosure), Dt5(->p), (ptrdiff_t)(npt), Dt2([dest].value), Dt2([dest].tt));
+  /* Process pseudo-instructions for upvalues. */
+  if (nup > 0) {
+    const Instruction *uvcode = J->nextins;
+    int i, uvuv;
+    /* Check which of the two types we need. */
+    for (i = 0, uvuv = 0; i < nup; i++)
+      if (GET_OPCODE(uvcode[i]) == OP_GETUPVAL) uvuv++;
+    /* Copy upvalues from parent first. */
+    if (uvuv) {
+      /* LCL:eax->upvals (new closure) <-- LCL:edi->upvals (own closure). */
+      for (i = 0; i < nup; i++)
+        if (GET_OPCODE(uvcode[i]) == OP_GETUPVAL) {
+          dasm_put(Dst, 4895, Dt5(->upvals[GETARG_B(uvcode[i])]), Dt5(->upvals[i]));
+        }
+    }
+    /* Next find or create upvalues for our own stack slots. */
+    if (nup > uvuv) {
+      dasm_put(Dst, 909);
+      /* LCL:edi->upvals (new closure) <-- upvalue for stack slot. */
+      for (i = 0; i < nup; i++)
+        if (GET_OPCODE(uvcode[i]) == OP_MOVE) {
+          int rb = GETARG_B(uvcode[i]);
+          if (rb) {
+            dasm_put(Dst, 4836, Dt2([rb]));
+          } else {
+            dasm_put(Dst, 4844);
+          }
+          dasm_put(Dst, 4902, (ptrdiff_t)(luaF_findupval), Dt5(->upvals[i]));
+        }
+    }
+    J->combine += nup;  /* Skip pseudo-instructions. */
+  }
+  jit_checkGC(J);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_op_vararg(jit_State *J, int dest, int num)
+{
+  if (num < 0) {  /* Copy all varargs. */
+    dasm_put(Dst, 4911, Dt1(->ci), Dt4(->func), (1+J->pt->numparams)*sizeof(TValue), J->pt->maxstacksize*sizeof(TValue), Dt1(->stack_last), Dt2([dest]));
+    dasm_put(Dst, 4967, Dt1(->top), (ptrdiff_t)(luaD_growstack), Dt1(->base));
+  } else if (num > 0) {  /* Copy limited number of varargs. */
+    dasm_put(Dst, 4993, Dt1(->ci), Dt4(->func), (1+J->pt->numparams)*sizeof(TValue), Dt2([dest]), Dt2([dest+num]), Dt3([0].tt), sizeof(TValue));
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
diff --git a/libraries/LuaJIT-1.1.7/src/ljit_x86_inline.dash b/libraries/LuaJIT-1.1.7/src/ljit_x86_inline.dash
new file mode 100644
index 0000000..203642f
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljit_x86_inline.dash
@@ -0,0 +1,625 @@
+/*
+** Function inlining support for x86 CPUs.
+** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+/* ------------------------------------------------------------------------ */
+
+/* Private structure holding function inlining info. */
+typedef struct jit_InlineInfo {
+  int func;                     /* Function slot. 1st arg slot = func+1. */
+  int res;                      /* 1st result slot. Overlaps func/ci->func. */
+  int nargs;                    /* Number of args. */
+  int nresults;                 /* Number of results. */
+  int xnargs;                   /* Expected number of args. */
+  int xnresults;                /* Returned number of results. */
+  int hidx;                     /* Library/function index numbers. */
+} jit_InlineInfo;
+
+/* ------------------------------------------------------------------------ */
+
+enum { TFOR_FUNC, TFOR_TAB, TFOR_CTL, TFOR_KEY, TFOR_VAL };
+
+static void jit_inline_base(jit_State *J, jit_InlineInfo *ii)
+{
+  int func = ii->func;
+  switch (JIT_IH_IDX(ii->hidx)) {
+  case JIT_IH_BASE_PAIRS:
+  case JIT_IH_BASE_IPAIRS:
+    |// Easy for regular calls: res == func. Not inlined for tailcalls.
+    |// Guaranteed to be inlined only if used in conjunction with TFORLOOP.
+    |// So we omit setting the iterator function and fake the control var.
+    |  istable func+TFOR_TAB; jne L_DEOPTIMIZE  // Caveat: deopt TFORLOOP, too!
+    |  xor eax, eax                             // Assumes: LUA_TNIL == 0.
+    |  mov BASE[func+TFOR_CTL].tt, eax          // Fake nil type.
+    |  mov BASE[func+TFOR_CTL].value, eax       // Hidden control var = 0.
+    |//  mov BASE[func+TFOR_FUNC].tt, eax       // Kill function (not needed).
+    |.mfmap
+    |  .word JIT_MFM_DEOPT_PAIRS, J->nextpc-1   // Deoptimize TFORLOOP, too.
+    |.code
+    break;
+  default:
+    jit_assert(0);
+    break;
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+#ifndef COCO_DISABLE
+
+/* Helper function for inlined coroutine.resume(). */
+static StkId jit_coroutine_resume(lua_State *L, StkId base, int nresults)
+{
+  lua_State *co = thvalue(base-1);
+  /* Check for proper usage. Merge of lua_resume() and auxresume() checks. */
+  if (co->status != LUA_YIELD) {
+    if (co->status > LUA_YIELD) {
+errdead:
+      setsvalue(L, base-1, luaS_newliteral(L, "cannot resume dead coroutine"));
+      goto err;
+    } else if (co->ci != co->base_ci) {
+      setsvalue(L, base-1,
+        luaS_newliteral(L, "cannot resume non-suspended coroutine"));
+      goto err;
+    } else if (co->base == co->top) {
+      goto errdead;
+    }
+  }
+  {
+    ptrdiff_t ndelta = (char *)L->top - (char *)base;
+    int nargs = ndelta/sizeof(TValue);  /* Compute nargs. */
+    int status;
+    if ((char *)co->stack_last-(char *)co->top <= ndelta) {
+      co->ci->top = (StkId)(((char *)co->top) + ndelta);  /* Ok before grow. */
+      luaD_growstack(co, nargs);  /* Grow thread stack. */
+    }
+    /* Copy args. */
+    co->top = (StkId)(((char *)co->top) + ndelta);
+    { StkId t = co->top, f = L->top; while (f > base) setobj2s(co, --t, --f); }
+    L->top = base;
+    status = luaCOCO_resume(co, nargs);  /* Resume Coco thread. */
+    if (status == 0 || status == LUA_YIELD) {  /* Ok. */
+      StkId f;
+      if (nresults == 0) return NULL;
+      if (nresults == -1) {
+        luaD_checkstack(L, co->top - co->base);  /* Grow own stack. */
+      }
+      base = L->top - 2;
+      setbvalue(base++, 1);  /* true */
+      /* Copy results. Fill unused result slots with nil. */
+      f = co->base;
+      while (--nresults != 0 && f < co->top) setobj2s(L, base++, f++);
+      while (nresults-- > 0) setnilvalue(base++);
+      co->top = co->base;
+      return base;
+    } else {  /* Error. */
+      base = L->top;
+      setobj2s(L, base-1, co->top-1);  /* Copy error object. */
+err:
+      setbvalue(base-2, 0);  /* false */
+      nresults -= 2;
+      while (--nresults >= 0) setnilvalue(base+nresults);  /* Fill results. */
+      return base;
+    }
+  }
+}
+
+static void jit_inline_coroutine(jit_State *J, jit_InlineInfo *ii)
+{
+  int arg = ii->func+1;
+  int res = ii->res;
+  int i;
+  switch (JIT_IH_IDX(ii->hidx)) {
+  case JIT_IH_COROUTINE_YIELD:
+    |  cmp aword [L+((int)&LHASCOCO((lua_State *)0))], 0  // Got a C stack?
+    |  je L_DEOPTIMIZE
+    |  mov L->savedpc, &J->nextins              // Debugger-friendly.
+    |  add BASE, arg*#TVALUE
+    if (ii->nargs >= 0) {  /* Previous op was not open and did not set TOP. */
+      |  lea TOP, BASE[ii->nargs]
+    }
+    |  mov L->base, BASE
+    |  mov L->top, TOP
+    |  call &luaCOCO_yield, L
+    |  mov BASE, L->base
+    |  mov TOP, L->top
+    jit_assert(ii->nresults >= 0 && ii->nresults <= EXTRA_STACK);
+    for (i = 0; i < ii->nresults; i++) {
+      |  setnilvalue TOP[i]                     // Clear undefined result.
+      |  copyslot BASE[res+i], BASE[arg+i]      // Move result down.
+    }
+    ii->nargs = -1;  /* Force restore of L->top. */
+    break;
+  case JIT_IH_COROUTINE_RESUME:
+    jit_assert(ii->nargs != 0 && ii->res == ii->func);
+    |  add BASE, (arg+1)*#TVALUE
+    if (ii->nargs >= 0) {  /* Previous op was not open and did not set TOP. */
+      |  lea TOP, BASE[ii->nargs-1]
+    } else {
+      |  cmp TOP, BASE; jb L_DEOPTIMIZE         // No thread arg? Deoptimize.
+    }
+    |  istt -1, LUA_TTHREAD; jne L_DEOPTIMIZE   // Wrong type? Deoptimize.
+    |  mov L:eax, BASE[-1].value
+    |  cmp aword [L:eax+((int)&LHASCOCO((lua_State *)0))], 0
+    |  je L_DEOPTIMIZE                          // No C stack? Deoptimize.
+    |  mov L->savedpc, &J->nextins              // Debugger-friendly.
+    |  mov L->top, TOP
+    |  call &jit_coroutine_resume, L, BASE, ii->nresults
+    |  mov BASE, L->base
+    if (ii->nresults == -1) {
+      |  mov TOP, eax
+    }
+    ii->nargs = -1;  /* Force restore of L->top. */
+    break;
+  default:
+    jit_assert(0);
+    break;
+  }
+}
+
+#endif /* COCO_DISABLE */
+
+/* ------------------------------------------------------------------------ */
+
+static void jit_inline_string(jit_State *J, jit_InlineInfo *ii)
+{
+  int arg = ii->func+1;
+  int res = ii->res;
+  switch (JIT_IH_IDX(ii->hidx)) {
+  case JIT_IH_STRING_LEN:
+    |  isstring arg; jne L_DEOPTIMIZE
+    |  mov TSTRING:ecx, BASE[arg].value
+    |  fild aword TSTRING:ecx->tsv.len  // size_t
+    |  settt BASE[res], LUA_TNUMBER
+    |  fstp qword BASE[res].value
+    break;
+  case JIT_IH_STRING_SUB:
+    /* TODO: inline numeric constants with help from the optimizer. */
+    /*       But this would save only another 15-20% in a trivial loop. */
+    jit_assert(ii->nargs >= 2);  /* Open op caveat is ok, too. */
+    if (ii->nargs > 2) {
+      |  lea TOP, BASE[arg]
+      |  call ->STRING_SUB3
+      |  setsvalue BASE[res], eax
+    } else {
+      |  lea TOP, BASE[arg]
+      |  call ->STRING_SUB2
+      |  setsvalue BASE[res], eax
+    }
+    break;
+  case JIT_IH_STRING_CHAR:
+    |  isnumber arg; jne L_DEOPTIMIZE
+    |  lea eax, L->env                  // Abuse L->env to hold temp string.
+    |  fld qword BASE[arg].value
+    |  fistp dword [eax]                // LSB is at start (little-endian).
+    |  cmp dword [eax], 255; ja L_DEOPTIMIZE
+    |  call &luaS_newlstr, L, eax, 1
+    |  setsvalue BASE[res], eax
+    break;
+  default:
+    jit_assert(0);
+    break;
+  }
+
+  |//-----------------------------------------------------------------------
+  |.jsub STRING_SUB3                    // string.sub(str, start, end)
+  |  mov eax, TOP[0].tt; shl eax, 4; or eax, TOP[1].tt; shl eax, 4
+  |  or eax, TOP[2].tt; sub eax, LUA_TSTR_NUM_NUM
+  |  jne ->DEOPTIMIZE_CALLER            // Wrong types? Deoptimize.
+  |  // eax must be zero here!
+  |   fld qword TOP[1].value
+  |  fld qword TOP[2].value
+  |  fistp aword TMP3                   // size_t
+  |   fistp aword TMP2                  // size_t
+  |   mov TSTRING:ecx, TOP[0].value
+  |   mov TOP, aword TSTRING:ecx->tsv.len  // size_t
+  |  mov edx, TMP3
+  |   cmp TOP, edx
+  |  jb >4
+  |1:
+  |  or eax, TMP2                       // eax is known to be zero.
+  |  jle >6                             // start <= 0?
+  |2:
+  |  sub edx, eax                       // newlen = end-start
+  |  jl >7                              // start > end?
+  |  lea ecx, [TSTRING:ecx+eax+#TSTRING-1]  // svalue()-1+start
+  |  inc edx
+  |3:
+  |  mov ARG2, L                        // First arg for tailcall is ARG2.
+  |  mov ARG3, ecx                      // Pointer to start.
+  |  mov ARG4, edx                      // Length.
+  |   mov GL:edi, L->l_G
+  |   mov eax, GL:edi->totalbytes       // size_t
+  |   cmp eax, GL:edi->GCthreshold      // size_t
+  |   jae >8                            // G->totalbytes >= G->GCthreshold?
+  |  jmp &luaS_newlstr                  // Tailcall to C function.
+  |
+  |4:  // Negative end or overflow.
+  |  jl >5
+  |  lea edx, [edx+TOP+1]               // end = end+(len+1)
+  |  jmp <1
+  |5:  // Overflow
+  |  mov edx, TOP                       // end = len
+  |  jmp <1
+  |
+  |6:  // Negative start or underflow.
+  |  je >5
+  |  add eax, TOP                       // start = start+(len+1)
+  |  inc eax
+  |  jg <2                              // start > 0?
+  |5:  // Underflow.
+  |  mov eax, 1                         // start = 1
+  |  jmp <2
+  |
+  |7:  // Range underflow.
+  |  xor edx, edx                       // Zero length.
+  |  jmp <3                             // Any pointer in ecx is ok.
+  |.endjsub
+  |
+  |//-----------------------------------------------------------------------
+  |.jsub STRING_SUB2                    // string.sub(str, start)
+  |  mov eax, TOP[0].tt; shl eax, 4; or eax, TOP[1].tt; sub eax, LUA_TSTR_NUM
+  |  jne ->DEOPTIMIZE_CALLER            // Wrong types? Deoptimize.
+  |  // eax must be zero here!
+  |  fld qword TOP[1].value
+  |  fistp aword TMP2                   // size_t
+  |  mov TSTRING:ecx, TOP[0].value
+  |  mov TOP, aword TSTRING:ecx->tsv.len // size_t
+  |  mov edx, TOP
+  |  jmp <1                             // See STRING_SUB3.
+  |
+  |8:  // GC threshold reached.
+  |  sub esp, FRAME_OFFSET
+  |  call &luaC_step, L
+  |  add esp, FRAME_OFFSET
+  |  mov BASE, L->base
+  |  jmp &luaS_newlstr                  // Tailcall to C function.
+  |.endjsub
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Helper functions for inlined calls to table.*. */
+static void jit_table_insert(lua_State *L, TValue *arg)
+{
+  setobj2t(L, luaH_setnum(L, hvalue(arg), luaH_getn(hvalue(arg))+1), arg+1);
+  luaC_barriert(L, hvalue(arg), arg+1);
+}
+
+static TValue *jit_table_remove(lua_State *L, TValue *arg, TValue *res)
+{
+  int n = luaH_getn(hvalue(arg));
+  if (n == 0) {
+    setnilvalue(res);  /* For the nresults == 1 case. Harmless otherwise. */
+    return res;  /* For the nresults == -1 case. */
+  } else {
+    TValue *val = luaH_setnum(L, hvalue(arg), n);
+    setobj2s(L, res, val);
+    setnilvalue(val);
+    return res+1;  /* For the nresults == -1 case. */
+  }
+}
+
+static void jit_inline_table(jit_State *J, jit_InlineInfo *ii)
+{
+  int arg = ii->func+1;
+  int res = ii->res;
+  |  istable arg; jne L_DEOPTIMIZE
+  switch (JIT_IH_IDX(ii->hidx)) {
+  case JIT_IH_TABLE_INSERT:
+    |  lea TVALUE:eax, BASE[arg]
+    |  call &jit_table_insert, L, TVALUE:eax
+    break;
+  case JIT_IH_TABLE_REMOVE:
+    |  lea TVALUE:eax, BASE[arg]
+    |  lea TVALUE:ecx, BASE[res]
+    |  call &jit_table_remove, L, TVALUE:eax, TVALUE:ecx
+    if (ii->nresults == -1) {
+      ii->xnresults = -1;
+      |  mov TOP, TVALUE:eax
+    }
+    break;
+  case JIT_IH_TABLE_GETN:
+    |  mov TABLE:eax, BASE[arg].value
+    |  call &luaH_getn, TABLE:eax
+    |  mov TMP1, eax
+    |  fild dword TMP1
+    |  fstp qword BASE[res].value
+    |  settt BASE[res], LUA_TNUMBER
+    break;
+  default:
+    jit_assert(0);
+    break;
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* This typedef must match the libm function signature. */
+/* Serves as a check against wrong lua_Number or wrong calling conventions. */
+typedef lua_Number (*mathfunc_11)(lua_Number);
+
+/* Partially inlined math functions. */
+/* CHECK: must match with jit_hints.h and jit.opt_lib. */
+static const mathfunc_11 jit_mathfuncs_11[JIT_IH_MATH_SIN] = {
+  log, log10, exp,      sinh, cosh, tanh,       asin, acos, atan
+};
+
+/* FPU control words for ceil and floor (exceptions masked, full precision). */
+static const unsigned short jit_fpucw[2] = { 0x0b7f, 0x077f };
+
+static void jit_inline_math(jit_State *J, jit_InlineInfo *ii)
+{
+  int arg = ii->func+1;
+  int res = ii->res;
+  int idx = JIT_IH_IDX(ii->hidx);
+
+  if (idx < JIT_IH_MATH__21) {
+    |  isnumber arg; jne L_DEOPTIMIZE
+    |  fld qword BASE[arg].value
+  } else {
+    jit_assert(idx < JIT_IH_MATH__LAST);
+    |  isnumber2 arg, arg+1; jne L_DEOPTIMIZE
+  }
+  switch (idx) {
+  /* We ignore sin/cos/tan range overflows (2^63 rad) just like -ffast-math. */
+  case JIT_IH_MATH_SIN:
+    |  fsin
+    break;
+  case JIT_IH_MATH_COS:
+    |  fcos
+    break;
+  case JIT_IH_MATH_TAN:
+    |  fptan; fpop
+    break;
+  case JIT_IH_MATH_CEIL:
+  case JIT_IH_MATH_FLOOR:
+    |  fnstcw word TMP1
+    |  fldcw word [(ptrdiff_t)&jit_fpucw[idx-JIT_IH_MATH_CEIL]]
+    |  frndint
+    |  fldcw word TMP1
+    break;
+  case JIT_IH_MATH_ABS:
+    |  fabs
+    break;
+  case JIT_IH_MATH_SQRT:
+    |  fsqrt
+    break;
+  case JIT_IH_MATH_FMOD:
+    |  fld qword BASE[arg+1].value
+    |  fld qword BASE[arg].value
+    |1: ; fprem; fnstsw ax; sahf; jp <1
+    |  fstp st1
+    break;
+  case JIT_IH_MATH_ATAN2:
+    |// Inlining is easier than calling atan2().
+    |  fld qword BASE[arg].value
+    |  fld qword BASE[arg+1].value
+    |  fpatan
+    break;
+  default:
+    |// Partially inlined. Just call the libm function (__cdecl!).
+    |  fstp FPARG1
+    |  call &jit_mathfuncs_11[idx]
+    break;
+  }
+  |  settt BASE[res], LUA_TNUMBER
+  |  fstp qword BASE[res].value
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Try to inline a CALL or TAILCALL instruction. */
+static int jit_inline_call(jit_State *J, int func, int nargs, int nresults)
+{
+  const TValue *callable = hint_get(J, TYPE);  /* TYPE hint = callable. */
+  int cltype = ttype(callable);
+  const TValue *oidx;
+  jit_InlineInfo ii;
+  int idx;
+
+  if (cltype != LUA_TFUNCTION) goto fail;
+  if (J->flags & JIT_F_DEBUG) goto fail;  /* DWIM. */
+
+  oidx = hint_get(J, INLINE);  /* INLINE hint = library/function index. */
+  if (!ttisnumber(oidx)) goto fail;
+
+  ii.hidx = (int)nvalue(oidx);
+  idx = JIT_IH_IDX(ii.hidx);
+
+  if (nresults == -2) {  /* Tailcall. */
+    /* Tailcalls from vararg functions don't work with BASE[-1]. */
+    if (J->pt->is_vararg) goto fail;  /* So forget about this rare case. */
+    ii.res = -1;  /* Careful: 2nd result overlaps 1st stack slot. */
+    ii.nresults = -1;
+  } else {
+    ii.res = func;
+    ii.nresults = nresults;
+  }
+  ii.func = func;
+  ii.nargs = nargs;
+  ii.xnargs = ii.xnresults = 1;  /* Default: 1 arg, 1 result. */
+
+  /* Check for the currently supported cases. */
+  switch (JIT_IH_LIB(ii.hidx)) {
+  case JIT_IHLIB_BASE:
+    switch (idx) {
+    case JIT_IH_BASE_PAIRS:
+    case JIT_IH_BASE_IPAIRS:
+      if (nresults == -2) goto fail;  /* Not useful for tailcalls. */
+      ii.xnresults = 3;
+      goto check;
+    }
+    break;
+#ifndef COCO_DISABLE
+  case JIT_IHLIB_COROUTINE:
+    switch (idx) {
+    case JIT_IH_COROUTINE_YIELD:
+      /* Only support common cases: no tailcalls, low number of results. */
+      if (nresults < 0 || nresults > EXTRA_STACK) goto fail;
+      ii.xnargs = ii.xnresults = -1;
+      goto ok;  /* Anything else is ok. */
+    case JIT_IH_COROUTINE_RESUME:
+      /* Only support common cases: no tailcalls, not with 0 args (error). */
+      if (nresults == -2 || nargs == 0) goto fail;
+      ii.xnargs = ii.xnresults = -1;
+      goto ok;  /* Anything else is ok. */
+    }
+    break;
+#endif
+  case JIT_IHLIB_STRING:
+    switch (idx) {
+    case JIT_IH_STRING_LEN:
+      goto check;
+    case JIT_IH_STRING_SUB:
+      if (nargs < 2) goto fail;  /* No support for open calls, too. */
+      goto ok;  /* 2 or more args are ok. */
+    case JIT_IH_STRING_CHAR:
+      goto check;  /* Only single arg supported. */
+    }
+    break;
+  case JIT_IHLIB_TABLE:
+    switch (idx) {
+    case JIT_IH_TABLE_INSERT:
+      ii.xnargs = 2;
+      goto check;  /* Only push (append) supported. */
+    case JIT_IH_TABLE_REMOVE:
+      goto check;  /* Only pop supported. */
+    case JIT_IH_TABLE_GETN:
+      goto check;
+    }
+    break;
+  case JIT_IHLIB_MATH:
+    if (idx >= JIT_IH_MATH__LAST) goto fail;
+    if (idx >= JIT_IH_MATH__21) ii.xnargs = 2;
+    goto check;
+  }
+fail:
+  return cltype;  /* Call could not be inlined. Return type of callable. */
+
+check:
+  if (nargs != ii.xnargs && nargs != -1) goto fail;
+  /* The optimizer already checks the number of results (avoid setnil). */
+
+ok:  /* Whew, all checks done. Go for it! */
+
+  /* Start with the common leadin for inlined calls. */
+  jit_deopt_target(J, nargs);
+  |// Caveat: Must save TOP for open ops if jsub uses DEOPTIMIZE_CALLER.
+  |  isfunction func
+  |  jne L_DEOPTIMIZE                   // Not a function? Deoptimize.
+  |  cmp aword BASE[func].value, &clvalue(callable)
+  |  jne L_DEOPTIMIZE                   // Wrong closure? Deoptimize.
+  if (nargs == -1 && ii.xnargs >= 0) {
+    |  lea eax, BASE[func+1+ii.xnargs]
+    |  cmp TOP, eax
+    |  jne L_DEOPTIMIZE                 // Wrong #args? Deoptimize.
+  }
+
+  /* Now inline the function itself. */
+  switch (JIT_IH_LIB(ii.hidx)) {
+  case JIT_IHLIB_BASE: jit_inline_base(J, &ii); break;
+#ifndef COCO_DISABLE
+  case JIT_IHLIB_COROUTINE: jit_inline_coroutine(J, &ii); break;
+#endif
+  case JIT_IHLIB_STRING: jit_inline_string(J, &ii); break;
+  case JIT_IHLIB_TABLE:  jit_inline_table(J, &ii); break;
+  case JIT_IHLIB_MATH:   jit_inline_math(J, &ii); break;
+  default: jit_assert(0); break;
+  }
+
+  /* And add the common leadout for inlined calls. */
+  if (ii.nresults == -1) {
+    if (ii.xnresults >= 0) {
+      |  lea TOP, BASE[ii.res+ii.xnresults]
+    }
+  } else if (ii.nargs == -1) {  /* Restore L->top only if needed. */
+    |  lea TOP, BASE[J->pt->maxstacksize]
+    |  mov L->top, TOP
+  }
+
+  if (nresults == -2) {  /* Results are in place. Add return for tailcalls. */
+    |  add esp, FRAME_OFFSET
+    |  sub BASE, #BASE
+    |  sub aword L->ci, #CI
+    |  ret
+  }
+
+  return -1;  /* Success, call has been inlined. */
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Helper function for inlined iterator code. Paraphrased from luaH_next. */
+/* TODO: GCC has trouble optimizing this. */
+static int jit_table_next(lua_State *L, TValue *ra)
+{
+  Table *t = hvalue(&ra[TFOR_TAB]);
+  int i = ra[TFOR_CTL].value.b;  /* Hidden control variable. */
+  for (; i < t->sizearray; i++) {  /* First the array part. */
+    if (!ttisnil(&t->array[i])) {
+      setnvalue(&ra[TFOR_KEY], cast_num(i+1));
+      setobj2s(L, &ra[TFOR_VAL], &t->array[i]);
+      ra[TFOR_CTL].value.b = i+1;
+      return 1;
+    }
+  }
+  for (i -= t->sizearray; i < sizenode(t); i++) {  /* Then the hash part. */
+    if (!ttisnil(gval(gnode(t, i)))) {
+      setobj2s(L, &ra[TFOR_KEY], key2tval(gnode(t, i)));
+      setobj2s(L, &ra[TFOR_VAL], gval(gnode(t, i)));
+      ra[TFOR_CTL].value.b = i+1+t->sizearray;
+      return 1;
+    }
+  }
+  return 0;  /* End of iteration. */
+}
+
+/* Try to inline a TFORLOOP instruction. */
+static int jit_inline_tforloop(jit_State *J, int ra, int nresults, int target)
+{
+  const TValue *oidx = hint_get(J, INLINE);  /* INLINE hint = lib/func idx. */
+  int idx;
+
+  if (!ttisnumber(oidx)) return 0;  /* No hint: don't inline anything. */
+  idx = (int)nvalue(oidx);
+  if (J->flags & JIT_F_DEBUG) return 0;  /* DWIM. */
+
+  switch (idx) {
+  case JIT_IH_MKIDX(JIT_IHLIB_BASE, JIT_IH_BASE_PAIRS):
+    |// The type checks can be omitted -- see the iterator constructor.
+    |  lea TOP, BASE[ra]
+    |  call &jit_table_next, L, TOP
+    |  test eax, eax
+    |  jnz =>target
+    return 1;  /* Success, iterator has been inlined. */
+  case JIT_IH_MKIDX(JIT_IHLIB_BASE, JIT_IH_BASE_IPAIRS):
+    |// The type checks can be omitted -- see the iterator constructor.
+    |  mov eax, BASE[ra+TFOR_CTL].value         // Hidden control variable.
+    |  inc eax
+    |   mov TABLE:edx, BASE[ra+TFOR_TAB].value  // Table object.
+    |  mov BASE[ra+TFOR_CTL].value, eax
+    |  call &luaH_getnum, TABLE:edx, eax
+    |  // This is really copyslot BASE[ra+TFOR_VAL], TVALUE:eax[0] plus compare.
+    |  mov ecx, TVALUE:eax->tt
+    |  test ecx, ecx                            // Assumes: LUA_TNIL == 0.
+    |  jz >9                                    // nil value stops iteration.
+    |   fild dword BASE[ra+TFOR_CTL].value      // Set numeric key.
+    |   settt BASE[ra+TFOR_KEY], LUA_TNUMBER
+    |   fstp qword BASE[ra+TFOR_KEY].value
+    |  mov edx, TVALUE:eax->value
+    |  mov eax, TVALUE:eax->value.na[1] // Overwrites eax.
+    |  mov BASE[ra+TFOR_VAL].tt, ecx            // Copy value from table slot.
+    |  mov BASE[ra+TFOR_VAL].value, edx
+    |  mov BASE[ra+TFOR_VAL].value.na[1], eax
+    |  jmp =>target
+    |9:
+    return 1;  /* Success, iterator has been inlined. */
+  }
+
+  return 0;  /* No support for inlining any other iterators. */
+}
+
+/* ------------------------------------------------------------------------ */
+
diff --git a/libraries/LuaJIT-1.1.7/src/ljitlib.c b/libraries/LuaJIT-1.1.7/src/ljitlib.c
new file mode 100644
index 0000000..4efc04d
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ljitlib.c
@@ -0,0 +1,637 @@
+/*
+** Lua library for the JIT engine.
+** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+#include <stdio.h>
+#include <string.h>
+
+#define ljitlib_c
+#define LUA_LIB
+
+#include "lua.h"
+#include "lauxlib.h"
+#include "luajit.h"
+#include "lualib.h"
+
+/* This file is not a pure C API user. Some internals are required. */
+#include "lobject.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "lfunc.h"
+#include "lgc.h"
+#include "lopcodes.h"
+
+#include "ljit.h"
+#include "ljit_hints.h"
+
+#define STRING_HINTS
+#include "ljit_hints.h"
+
+/* ------------------------------------------------------------------------ */
+
+/* Static pointer addresses used as registry keys. */
+/* The values do not matter, but must be different to prevent joining. */
+static const int regkey_frontend = 0x6c6a6c01;
+static const int regkey_comthread = 0x6c6a6c02;
+
+/* Check that the first argument is a Lua function and return its closure. */
+static Closure *check_LCL(lua_State *L)
+{
+  StkId o = L->base;
+  switch (lua_type(L, 1)) {
+  case LUA_TBOOLEAN:
+    o = (L->ci-1)->func;
+  case LUA_TFUNCTION:
+    if (isLfunction(o))
+      return clvalue(o);
+    break;
+  }
+  luaL_argerror(L, 1, "Lua function expected");
+  return NULL;
+}
+
+/* Create a new closure from a prototype. */
+/* Note: upvalues are assumed to be after first two slots. */
+static void push_LCL(lua_State *L, Proto *pt, Table *env)
+{
+  Closure *cl;
+  int i, nup = pt->nups;
+  /* Adjust the number of stack slots to the number of upvalues. */
+  luaL_checkstack(L, nup, "too many upvalues");
+  lua_settop(L, 2+nup);
+  /* Create a closure from the subroutine prototype. */
+  cl = luaF_newLclosure(L, nup, env);
+  cl->l.p = pt;
+  /* Allocate new upvalues and close them. */
+  for (i = 0; i < nup; i++)
+    cl->l.upvals[i] = luaF_findupval(L, L->base + (2+i));
+  luaF_close(L, L->base + 2);
+  lua_settop(L, 2);  /* Remove upvalues. */
+  setclvalue(L, L->top++, cl);  /* Return closure on top of stack. */
+  luaC_checkGC(L);
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Set JIT mode for the engine or a closure and/or its subroutines. */
+static int setmode(lua_State *L, int mode)
+{
+  int idx = 0;
+  switch (lua_type(L, 1)) {
+  case LUA_TNONE:       /* jit.on/off() */
+  case LUA_TNIL:        /* jit.on/off(nil) */
+    luaJIT_setmode(L, 0, mode | LUAJIT_MODE_ENGINE);
+    break;
+  case LUA_TFUNCTION:   /* jit.on/off(func, nil|true|false) */
+    idx = 1;
+  case LUA_TBOOLEAN:    /* jit.on/off(true, nil|true|false) (parent frame) */
+    if (lua_isboolean(L, 2))
+      mode |= lua_toboolean(L, 2)?LUAJIT_MODE_ALLFUNC:LUAJIT_MODE_ALLSUBFUNC;
+    else
+      mode |= LUAJIT_MODE_FUNC;
+    if (luaJIT_setmode(L, idx, mode) == 1)  /* Ok? */
+      break;
+  default:
+    luaL_argerror(L, 1, "Lua function expected");
+    break;
+  }
+  return 0;
+}
+
+/* Set JIT mode to on: (re-)enable compilation. */
+static int j_on(lua_State *L)
+{
+  return setmode(L, LUAJIT_MODE_ON);
+}
+
+/* Set JIT mode to off: disable compilation. */
+static int j_off(lua_State *L)
+{
+  return setmode(L, LUAJIT_MODE_OFF);
+}
+
+/* Set JIT debug level. Defaults to maximum level for use with -j. */
+static int j_debug(lua_State *L)
+{
+  luaJIT_setmode(L, luaL_optinteger(L, 1, 100), LUAJIT_MODE_DEBUG);
+  return 0;
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Report the compilation status. */
+static int compstatus(lua_State *L, int status)
+{
+  if (status == -1)
+    return luaL_argerror(L, 1, "Lua function expected");
+  else if (status == JIT_S_OK)
+    return 0;
+  else {
+    lua_pushinteger(L, status);
+    return 1;
+  }
+}
+
+/* Compile a function. Pass typical args to help the optimizer. */
+static int j_compile(lua_State *L)
+{
+  int nargs = lua_gettop(L) - 1;
+  return compstatus(L, nargs >= 0 ? luaJIT_compile(L, nargs) : -1);
+}
+
+/* Recursively compile all subroutine prototypes. */
+static int rec_compile(lua_State *L, Proto *pt, Table *env, int stoponerror)
+{
+  int rstatus = JIT_S_OK;
+  int i;
+  for (i = 0; i < pt->sizep; i++) {
+    Proto *pti = pt->p[i];
+    int status;
+    push_LCL(L, pti, env);  /* Assumes stack is at 2 (no upvalues). */
+    status = luaJIT_compile(L, 0);
+    lua_settop(L, 2);  /* Clear stack */
+    if (status != JIT_S_OK) {
+      rstatus = status;
+      if (stoponerror) break;
+    }
+    status = rec_compile(L, pti, env, stoponerror);
+    if (status != JIT_S_OK) {
+      rstatus = status;
+      if (stoponerror) break;
+    }
+  }
+  return rstatus;
+}
+
+/* Compile all subroutines of a function. */
+/* Note: the function itself is _not_ compiled (use jit.compile()). */
+static int j_compilesub(lua_State *L)
+{
+  Closure *cl = check_LCL(L);
+  int stoponerror = lua_toboolean(L, 2);  /* Stop on first error? */
+  lua_settop(L, 2);
+  return compstatus(L, rec_compile(L, cl->l.p, cl->l.env, stoponerror));
+}
+
+/* jit.* functions. */
+static const luaL_Reg jitlib[] = {
+  { "on",               j_on },
+  { "off",              j_off },
+  { "debug",            j_debug },
+  { "compile",          j_compile },
+  { "compilesub",       j_compilesub },
+  /* j_attach is added below. */
+  { NULL, NULL }
+};
+
+/* ------------------------------------------------------------------------ */
+
+/* Get the compiler pipeline table from an upvalue (j_attach, j_frontend). */
+#define COMPIPE         lua_upvalueindex(1)
+
+/* Attach/detach handler to/from compiler pipeline. */
+static int j_attach(lua_State *L)
+{
+  int pipesz;
+  luaL_checktype(L, 1, LUA_TFUNCTION);
+  pipesz = lua_objlen(L, COMPIPE);
+  if (lua_isnoneornil(L, 2)) {  /* Detach if no priority given. */
+    int i;
+    for (i = 1; i <= pipesz; i += 2) {
+      lua_rawgeti(L, COMPIPE, i);
+      if (lua_rawequal(L, 1, -1)) {  /* Found: delete from pipeline. */
+        for (; i+2 <= pipesz; i++) {  /* Shift down. */
+          lua_rawgeti(L, COMPIPE, i+2);
+          lua_rawseti(L, COMPIPE, i);
+        }
+        /* Clear last two elements. */
+        lua_pushnil(L); lua_rawseti(L, COMPIPE, i);
+        lua_pushnil(L); lua_rawseti(L, COMPIPE, i+1);
+        return 0;
+      }
+      lua_pop(L, 1);
+    }
+    return 0;  /* Not found: ignore detach request. */
+  } else {  /* Attach if priority given. */
+    int prio = luaL_checkint(L, 2);
+    int pos, i;
+    for (pos = 2; pos <= pipesz; pos += 2) {
+      lua_rawgeti(L, COMPIPE, pos);
+      if (prio > (int)lua_tointeger(L, -1)) break; /* Insertion point found. */
+      lua_pop(L, 1);
+    }
+    for (i = pipesz+2; i > pos; i--) {  /* Shift up. */
+      lua_rawgeti(L, COMPIPE, i-2);
+      lua_rawseti(L, COMPIPE, i);
+    }
+    /* Set handler and priority. */
+    lua_pushvalue(L, 1); lua_rawseti(L, COMPIPE, i-1);
+    lua_pushvalue(L, 2); lua_rawseti(L, COMPIPE, i);
+    return 0;
+  }
+}
+
+/* Compiler frontend. Runs in the compiler thread. */
+/* First and only arg is the compiler state table. */
+static int j_frontend(lua_State *L)
+{
+  int status = JIT_S_OK;
+  int pos;
+  /* Loop through all handlers in the compiler pipeline. */
+  for (pos = 1; ; pos += 2) {
+    if (status != JIT_S_OK) {  /* Pending failure? */
+      int prio;
+      lua_rawgeti(L, COMPIPE, pos+1);  /* Must check for odd/even priority. */
+      if (lua_isnil(L, -1)) break;  /* End of pipeline. */
+      prio = (int)lua_tointeger(L, -1);
+      lua_pop(L, 1);
+      if ((prio & 1) == 0) continue;  /* Skip handlers with even priority. */
+    }
+    /* Call handler with compiler state table and optional failure status. */
+    lua_rawgeti(L, COMPIPE, pos);
+    if (lua_isnil(L, -1)) break;  /* End of pipeline. */
+    lua_pushvalue(L, 1);
+    if (status != JIT_S_OK)
+      lua_pushinteger(L, status);
+    lua_call(L, status ? 2 : 1, 1);
+    if (!lua_isnil(L, -1))  /* Remember failure status. */
+      status = (int)lua_tointeger(L, -1);
+    lua_pop(L, 1);
+  }
+  lua_pushinteger(L, status);
+  return 1;
+}
+
+/* Compiler frontend wrapper. */
+static int frontwrap(lua_State *L, Table *st)
+{
+  jit_State *J = G(L)->jit_state;
+  lua_State *JL;
+  int status;
+
+  /* Allocate compiler thread on demand. */
+  if (J->L == NULL) {
+    if (!lua_checkstack(L, 3)) return JIT_S_COMPILER_ERROR;
+    sethvalue(L, L->top++, st);  /* Prevent GC of state table. */
+    lua_pushlightuserdata(L, (void *)&regkey_comthread);
+    /* Cannot use C stack, since it's deallocated early in Coco. */
+    /* But we don't need one -- the compiler thread never yields, anyway. */
+    J->L = lua_newthread(L);
+    lua_rawset(L, LUA_REGISTRYINDEX);
+    L->top--;  /* Remove state table from this stack. */
+  }
+  JL = J->L;
+
+  /* Initialize compiler thread stack with frontend and state table. */
+  lua_settop(JL, 0);
+  lua_pushlightuserdata(JL, (void *)&regkey_frontend);
+  lua_rawget(JL, LUA_REGISTRYINDEX);
+  sethvalue(JL, JL->top, st);
+  JL->top++;
+
+  /* Start the frontend by resuming the compiler thread. */
+  if (lua_resume(JL, 1) != 0) {  /* Failed? */
+    /* Note: LUA_YIELD is treated like any other error. */
+    J->L = NULL;  /* Get a new thread next time. */
+    fprintf(stderr, "[LuaJIT frontend failed: %s]\n",
+      lua_isstring(JL, -1) ? lua_tostring(JL, -1) : "(unknown error)");
+    return JIT_S_COMPILER_ERROR;
+  }
+
+  /* Get status from terminated thread. */
+  status = (int)lua_tointeger(JL, -1);
+  lua_settop(JL, 0);  /* Help the GC. */
+  return status;
+}
+
+/* Create the compiler pipeline and register it. */
+static void makepipeline(lua_State *L)
+{
+  lua_createtable(L, 20, 0);  /* 10 handlers+priorities should be enough. */
+  lua_pushcfunction(L, luaJIT_backend);
+  lua_rawseti(L, -2, 1);
+  lua_pushinteger(L, 0);  /* Fill in the backend at prio 0. */
+  lua_rawseti(L, -2, 2);
+
+  /* Store the compiler frontend in the registry. */
+  lua_pushlightuserdata(L, (void *)&regkey_frontend);
+  lua_pushvalue(L, -2);  /* Pipeline table as upvalue. */
+  lua_pushcclosure(L, j_frontend, 1);
+  lua_rawset(L, LUA_REGISTRYINDEX);
+
+  /* Register the frontend wrapper. */
+  G(L)->jit_state->frontwrap = frontwrap;
+
+  /* Add jit.attach with the pipeline table as upvalue. */
+  lua_pushcclosure(L, j_attach, 1);
+  lua_setfield(L, -2, "attach");  /* "jit" table must be below. */
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* Calculate total mcode size without mfm and only for active mcode blocks. */
+static size_t mcodesize(Proto *pt)
+{
+  jit_MCTrailer tr;
+  size_t sz = 0;
+  tr.mcode = (char *)pt->jit_mcode;
+  tr.sz = pt->jit_szmcode;
+  do {
+    jit_Mfm *mfm = JIT_MCMFM(tr.mcode, tr.sz);
+    if (sz != 0 && jit_mfm_ismain(mfm)) break;  /* Stop at old main mfm. */
+    while (*mfm != JIT_MFM_STOP) mfm--;  /* Search for end of mcode. */
+    sz += (char *)mfm-(char *)tr.mcode;  /* Add size of mcode without mfm. */
+    memcpy((void *)&tr, JIT_MCTRAILER(tr.mcode, tr.sz), sizeof(jit_MCTrailer));
+  } while (tr.mcode != NULL);
+  return sz;
+}
+
+#define setintfield(name, i) \
+  do { lua_pushinteger(L, i); lua_setfield(L, -2, name); } while (0)
+
+/* local stats = jit.util.stats(func) */
+static int ju_stats(lua_State *L)
+{
+  if (!(L->top > L->base))
+    luaL_argerror(L, 1, "Lua function expected");
+  if (isLfunction(L->base)) {
+    Proto *pt = clvalue(L->base)->l.p;
+    lua_createtable(L, 0, 11);
+    setintfield("status", pt->jit_status);
+    setintfield("stackslots", pt->maxstacksize);
+    setintfield("params", pt->numparams);
+    setintfield("bytecodes", pt->sizecode);
+    setintfield("consts", pt->sizek);
+    setintfield("upvalues", pt->nups);
+    setintfield("subs", pt->sizep);
+    lua_pushboolean(L, pt->is_vararg);
+    lua_setfield(L, -2, "isvararg");
+    lua_getfenv(L, 1);
+    lua_setfield(L, -2, "env");
+    if (pt->jit_szmcode != 0) {
+      setintfield("mcodesize", (int)mcodesize(pt));
+      lua_pushnumber(L, (lua_Number)(size_t)pt->jit_mcode);
+      lua_setfield(L, -2, "mcodeaddr");
+    }
+    return 1;
+  } else {
+    return 0;  /* Don't throw an error like the other util functions. */
+  }
+}
+
+/* local op, a, b, c, test = jit.util.bytecode(func, pc) */
+static int ju_bytecode(lua_State *L)
+{
+  Proto *pt = check_LCL(L)->l.p;
+  int pc = luaL_checkint(L, 2);
+  if (pc >= 1 && pc <= pt->sizecode) {
+    Instruction ins = pt->code[pc-1];
+    OpCode op = GET_OPCODE(ins);
+    if (pc > 1 && (((int)OP_SETLIST) << POS_OP) ==
+        (pt->code[pc-2] & (MASK1(SIZE_OP,POS_OP) | MASK1(SIZE_C,POS_C)))) {
+      lua_pushstring(L, luaP_opnames[OP_SETLIST]);
+      lua_pushnumber(L, (lua_Number)ins);  /* Fake extended op. */
+      return 1;
+    }
+    if (op >= NUM_OPCODES) return 0;  /* Just in case. */
+    lua_pushstring(L, luaP_opnames[op]);
+    lua_pushinteger(L, GETARG_A(ins));
+    switch (getOpMode(op)) {
+    case iABC: {
+      int b = GETARG_B(ins), c = GETARG_C(ins);
+      switch (getBMode(op)) {
+      case OpArgN: lua_pushnil(L); break;
+      case OpArgK: if (ISK(b)) b = -1-INDEXK(b);
+      case OpArgR: case OpArgU: lua_pushinteger(L, b); break;
+      }
+      switch (getCMode(op)) {
+      case OpArgN: lua_pushnil(L); break;
+      case OpArgK: if (ISK(c)) c = -1-INDEXK(c);
+      case OpArgR: case OpArgU: lua_pushinteger(L, c); break;
+      }
+      lua_pushboolean(L, testTMode(op));
+      return 5;
+    }
+    case iABx: {
+      int bx = GETARG_Bx(ins);
+      lua_pushinteger(L, getBMode(op) == OpArgK ? -1-bx : bx);
+      return 3;
+    }
+    case iAsBx:
+      lua_pushinteger(L, GETARG_sBx(ins));
+      return 3;
+    }
+  }
+  return 0;
+}
+
+/* local const, ok = jit.util.const(func, idx) */
+static int ju_const(lua_State *L)
+{
+  Proto *pt = check_LCL(L)->l.p;
+  int idx = luaL_checkint(L, 2);
+  if (idx < 0) idx = -idx;  /* Handle both positive and negative indices. */
+  if (idx >= 1 && idx <= pt->sizek) {
+    setobj2s(L, L->top-1, &pt->k[idx-1]);
+    lua_pushboolean(L, 1);
+    return 2;
+  }
+  lua_pushnil(L);
+  lua_pushboolean(L, 0);
+  return 2;
+}
+
+/* local upvalue, ok = jit.util.upvalue(func, idx) */
+static int ju_upvalue(lua_State *L)
+{
+  Closure *cl = check_LCL(L);
+  Proto *pt = cl->l.p;
+  int idx = luaL_checkint(L, 2);
+  if (idx >= 0 && idx < pt->nups) {
+    setobj2s(L, L->top-1, cl->l.upvals[idx]->v);
+    lua_pushboolean(L, 1);
+    return 2;
+  }
+  lua_pushnil(L);
+  lua_pushboolean(L, 0);
+  return 2;
+}
+
+/* local nup = jit.util.closurenup(func, idx) */
+static int ju_closurenup(lua_State *L)
+{
+  Closure *cl = check_LCL(L);
+  Proto *pt = cl->l.p;
+  int idx = luaL_checkint(L, 2);
+  if (idx >= 0 && idx < pt->sizep) {
+    lua_pushinteger(L, pt->p[idx]->nups);
+    return 1;
+  }
+  return 0;
+}
+
+/* for tag, mark in mfmiter do ... end. */
+static int ju_mfmiter(lua_State *L)
+{
+  jit_Mfm *mfm = (jit_Mfm *)lua_touserdata(L, lua_upvalueindex(1));
+  int m = *mfm--;
+  switch (m) {
+  case JIT_MFM_STOP: return 0;
+  case JIT_MFM_COMBINE: lua_pushliteral(L, "COMBINE"); lua_pushnil(L); break;
+  case JIT_MFM_DEAD: lua_pushliteral(L, "DEAD"); lua_pushnil(L); break;
+  default:
+    lua_pushinteger(L, m & JIT_MFM_MASK);
+    lua_pushboolean(L, m & JIT_MFM_MARK);
+    break;
+  }
+  lua_pushlightuserdata(L, (void *)mfm);
+  lua_replace(L, lua_upvalueindex(1));
+  return 2;
+}
+
+/* local addr, mcode, mfmiter = jit.util.mcode(func, block) */
+static int ju_mcode(lua_State *L)
+{
+  Proto *pt = check_LCL(L)->l.p;
+  if (pt->jit_szmcode == 0) {  /* Not compiled (yet): return nil, status. */
+    lua_pushnil(L);
+    lua_pushinteger(L, pt->jit_status);
+    return 2;
+  } else {
+    jit_Mfm *mfm;
+    jit_MCTrailer tr;
+    int block = luaL_checkint(L, 2);
+    tr.mcode = (char *)pt->jit_mcode;
+    tr.sz = pt->jit_szmcode;
+    while (--block > 0) {
+      void *trp = JIT_MCTRAILER(tr.mcode, tr.sz);
+      memcpy((void *)&tr, trp, sizeof(jit_MCTrailer));
+      if (tr.sz == 0) return 0;
+    }
+    mfm = JIT_MCMFM(tr.mcode, tr.sz);
+    while (*mfm != JIT_MFM_STOP) mfm--;  /* Search for end of mcode. */
+    lua_pushnumber(L, (lua_Number)(size_t)tr.mcode);
+    lua_pushlstring(L, (const char *)tr.mcode, (char *)mfm-(char *)tr.mcode);
+    lua_pushlightuserdata(L, (void *)JIT_MCMFM(tr.mcode, tr.sz));
+    lua_pushvalue(L, 1);  /* Must hold onto function to avoid GC. */
+    lua_pushcclosure(L, ju_mfmiter, 2);
+    return 3;
+  }
+}
+
+/* local addr [, mcode] = jit.util.jsubmcode([idx]) */
+static int ju_jsubmcode(lua_State *L)
+{
+  jit_State *J = G(L)->jit_state;
+  if (lua_isnoneornil(L, 1)) {
+    lua_pushnumber(L, (lua_Number)(size_t)J->jsubmcode);
+    lua_pushlstring(L, (const char *)J->jsubmcode, J->szjsubmcode);
+    return 2;
+  } else {
+    int idx = luaL_checkint(L, 1);
+    if (idx >= 0 && idx < J->numjsub) {
+      lua_pushnumber(L, (lua_Number)(size_t)J->jsub[idx]);
+      return 1;
+    }
+    return 0;
+  }
+}
+
+/* FOR INTERNAL DEBUGGING USE ONLY: local addr = jit.util.stackptr() */
+static int ju_stackptr(lua_State *L)
+{
+  jit_State *J = G(L)->jit_state;
+  size_t addr = cast(size_t (*)(void), J->jsub[0])();  /* JSUB_STACKPTR == 0! */
+  lua_pushnumber(L, (lua_Number)addr);
+  return 1;
+}
+
+/* jit.util.* functions. */
+static const luaL_Reg jitutillib[] = {
+  {"stats",             ju_stats },
+  {"bytecode",          ju_bytecode },
+  {"const",             ju_const },
+  {"upvalue",           ju_upvalue },
+  {"closurenup",        ju_closurenup },
+  {"mcode",             ju_mcode },
+  {"jsubmcode",         ju_jsubmcode },
+  {"stackptr",          ju_stackptr },
+  { NULL, NULL }
+};
+
+/* Make hint name to hint number map. */
+static void makehints(lua_State *L, const char *const *t, int tmax,
+                      const char *name)
+{
+  int i;
+  lua_createtable(L, 0, tmax);
+  for (i = 1; i < tmax; i++) {
+    lua_pushinteger(L, JIT_H2NUM(i));
+    lua_setfield(L, -2, t[i-1]);
+  }
+  lua_setfield(L, -2, name);
+}
+
+/* CHECK: must match with ljit.h (grep "ORDER JIT_S"). */
+static const char *const status_list[] = {
+  "OK",
+  "NONE",
+  "OFF",
+  "ENGINE_OFF",
+  "DELAYED",
+  "TOOLARGE",
+  "COMPILER_ERROR",
+  "DASM_ERROR"
+};
+
+/* Make bidirectional status name to status number map. */
+static void makestatus(lua_State *L, const char *name)
+{
+  int i;
+  lua_createtable(L, JIT_S_MAX-1, JIT_S_MAX+1);  /* Codes are not 1-based. */
+  for (i = 0; i < JIT_S_MAX; i++) {
+    lua_pushstring(L, status_list[i]);
+    lua_pushinteger(L, i);
+    lua_pushvalue(L, -2);
+    lua_rawseti(L, -4, i);
+    lua_rawset(L, -3);
+  }
+  lua_setfield(L, -2, name);
+}
+
+/* ------------------------------------------------------------------------ */
+
+/*
+** Open JIT library
+*/
+LUALIB_API int luaopen_jit(lua_State *L)
+{
+  /* Add the core JIT library. */
+  luaL_register(L, LUA_JITLIBNAME, jitlib);
+  lua_pushliteral(L, LUAJIT_VERSION);
+  lua_setfield(L, -2, "version");
+  setintfield("version_num", LUAJIT_VERSION_NUM);
+  lua_pushstring(L, luaJIT_arch);
+  lua_setfield(L, -2, "arch");
+  makepipeline(L);
+
+  /* Add the utility JIT library. */
+  luaL_register(L, LUA_JITLIBNAME ".util", jitutillib);
+  makestatus(L, "status");
+  makehints(L, hints_H, JIT_H_MAX, "hints");
+  makehints(L, hints_FH, JIT_FH_MAX, "fhints");
+  lua_pop(L, 1);
+
+  /* Everything ok, so turn the JIT engine on. Vroooom! */
+  if (luaJIT_setmode(L, 0, LUAJIT_MODE_ENGINE|LUAJIT_MODE_ON) <= 0) {
+    /* Ouch. Someone screwed up DynASM or the JSUBs. Probably me. */
+    /* But if you get 999999999, look at jit_consistency_check(). */
+    return luaL_error(L, "JIT engine init failed (%d)",
+        G(L)->jit_state->dasmstatus);
+  }
+
+  return 1;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/llex.c b/libraries/LuaJIT-1.1.7/src/llex.c
new file mode 100644
index 0000000..92d6575
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/llex.c
@@ -0,0 +1,463 @@
+/*
+** $Id: llex.c,v 2.20.1.1 2007/12/27 13:02:25 roberto Exp $
+** Lexical Analyzer
+** See Copyright Notice in lua.h
+*/
+
+
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+
+#define llex_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "ldo.h"
+#include "llex.h"
+#include "lobject.h"
+#include "lparser.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "lzio.h"
+
+
+
+#define next(ls) (ls->current = zgetc(ls->z))
+
+
+
+
+#define currIsNewline(ls)       (ls->current == '\n' || ls->current == '\r')
+
+
+/* ORDER RESERVED */
+const char *const luaX_tokens [] = {
+    "and", "break", "do", "else", "elseif",
+    "end", "false", "for", "function", "if",
+    "in", "local", "nil", "not", "or", "repeat",
+    "return", "then", "true", "until", "while",
+    "..", "...", "==", ">=", "<=", "~=",
+    "<number>", "<name>", "<string>", "<eof>",
+    NULL
+};
+
+
+#define save_and_next(ls) (save(ls, ls->current), next(ls))
+
+
+static void save (LexState *ls, int c) {
+  Mbuffer *b = ls->buff;
+  if (b->n + 1 > b->buffsize) {
+    size_t newsize;
+    if (b->buffsize >= MAX_SIZET/2)
+      luaX_lexerror(ls, "lexical element too long", 0);
+    newsize = b->buffsize * 2;
+    luaZ_resizebuffer(ls->L, b, newsize);
+  }
+  b->buffer[b->n++] = cast(char, c);
+}
+
+
+void luaX_init (lua_State *L) {
+  int i;
+  for (i=0; i<NUM_RESERVED; i++) {
+    TString *ts = luaS_new(L, luaX_tokens[i]);
+    luaS_fix(ts);  /* reserved words are never collected */
+    lua_assert(strlen(luaX_tokens[i])+1 <= TOKEN_LEN);
+    ts->tsv.reserved = cast_byte(i+1);  /* reserved word */
+  }
+}
+
+
+#define MAXSRC          80
+
+
+const char *luaX_token2str (LexState *ls, int token) {
+  if (token < FIRST_RESERVED) {
+    lua_assert(token == cast(unsigned char, token));
+    return (iscntrl(token)) ? luaO_pushfstring(ls->L, "char(%d)", token) :
+                              luaO_pushfstring(ls->L, "%c", token);
+  }
+  else
+    return luaX_tokens[token-FIRST_RESERVED];
+}
+
+
+static const char *txtToken (LexState *ls, int token) {
+  switch (token) {
+    case TK_NAME:
+    case TK_STRING:
+    case TK_NUMBER:
+      save(ls, '\0');
+      return luaZ_buffer(ls->buff);
+    default:
+      return luaX_token2str(ls, token);
+  }
+}
+
+
+void luaX_lexerror (LexState *ls, const char *msg, int token) {
+  char buff[MAXSRC];
+  luaO_chunkid(buff, getstr(ls->source), MAXSRC);
+  msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
+  if (token)
+    luaO_pushfstring(ls->L, "%s near " LUA_QS, msg, txtToken(ls, token));
+  luaD_throw(ls->L, LUA_ERRSYNTAX);
+}
+
+
+void luaX_syntaxerror (LexState *ls, const char *msg) {
+  luaX_lexerror(ls, msg, ls->t.token);
+}
+
+
+TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
+  lua_State *L = ls->L;
+  TString *ts = luaS_newlstr(L, str, l);
+  TValue *o = luaH_setstr(L, ls->fs->h, ts);  /* entry for `str' */
+  if (ttisnil(o)) {
+    setbvalue(o, 1);  /* make sure `str' will not be collected */
+    luaC_checkGC(L);
+  }
+  return ts;
+}
+
+
+static void inclinenumber (LexState *ls) {
+  int old = ls->current;
+  lua_assert(currIsNewline(ls));
+  next(ls);  /* skip `\n' or `\r' */
+  if (currIsNewline(ls) && ls->current != old)
+    next(ls);  /* skip `\n\r' or `\r\n' */
+  if (++ls->linenumber >= MAX_INT)
+    luaX_syntaxerror(ls, "chunk has too many lines");
+}
+
+
+void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {
+  ls->decpoint = '.';
+  ls->L = L;
+  ls->lookahead.token = TK_EOS;  /* no look-ahead token */
+  ls->z = z;
+  ls->fs = NULL;
+  ls->linenumber = 1;
+  ls->lastline = 1;
+  ls->source = source;
+  luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
+  next(ls);  /* read first char */
+}
+
+
+
+/*
+** =======================================================
+** LEXICAL ANALYZER
+** =======================================================
+*/
+
+
+
+static int check_next (LexState *ls, const char *set) {
+  if (!strchr(set, ls->current))
+    return 0;
+  save_and_next(ls);
+  return 1;
+}
+
+
+static void buffreplace (LexState *ls, char from, char to) {
+  size_t n = luaZ_bufflen(ls->buff);
+  char *p = luaZ_buffer(ls->buff);
+  while (n--)
+    if (p[n] == from) p[n] = to;
+}
+
+
+static void trydecpoint (LexState *ls, SemInfo *seminfo) {
+  /* format error: try to update decimal point separator */
+  struct lconv *cv = localeconv();
+  char old = ls->decpoint;
+  ls->decpoint = (cv ? cv->decimal_point[0] : '.');
+  buffreplace(ls, old, ls->decpoint);  /* try updated decimal separator */
+  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) {
+    /* format error with correct decimal point: no more options */
+    buffreplace(ls, ls->decpoint, '.');  /* undo change (for error message) */
+    luaX_lexerror(ls, "malformed number", TK_NUMBER);
+  }
+}
+
+
+/* LUA_NUMBER */
+static void read_numeral (LexState *ls, SemInfo *seminfo) {
+  lua_assert(isdigit(ls->current));
+  do {
+    save_and_next(ls);
+  } while (isdigit(ls->current) || ls->current == '.');
+  if (check_next(ls, "Ee"))  /* `E'? */
+    check_next(ls, "+-");  /* optional exponent sign */
+  while (isalnum(ls->current) || ls->current == '_')
+    save_and_next(ls);
+  save(ls, '\0');
+  buffreplace(ls, '.', ls->decpoint);  /* follow locale for decimal point */
+  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r))  /* format error? */
+    trydecpoint(ls, seminfo); /* try to update decimal point separator */
+}
+
+
+static int skip_sep (LexState *ls) {
+  int count = 0;
+  int s = ls->current;
+  lua_assert(s == '[' || s == ']');
+  save_and_next(ls);
+  while (ls->current == '=') {
+    save_and_next(ls);
+    count++;
+  }
+  return (ls->current == s) ? count : (-count) - 1;
+}
+
+
+static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
+  int cont = 0;
+  (void)(cont);  /* avoid warnings when `cont' is not used */
+  save_and_next(ls);  /* skip 2nd `[' */
+  if (currIsNewline(ls))  /* string starts with a newline? */
+    inclinenumber(ls);  /* skip it */
+  for (;;) {
+    switch (ls->current) {
+      case EOZ:
+        luaX_lexerror(ls, (seminfo) ? "unfinished long string" :
+                                   "unfinished long comment", TK_EOS);
+        break;  /* to avoid warnings */
+#if defined(LUA_COMPAT_LSTR)
+      case '[': {
+        if (skip_sep(ls) == sep) {
+          save_and_next(ls);  /* skip 2nd `[' */
+          cont++;
+#if LUA_COMPAT_LSTR == 1
+          if (sep == 0)
+            luaX_lexerror(ls, "nesting of [[...]] is deprecated", '[');
+#endif
+        }
+        break;
+      }
+#endif
+      case ']': {
+        if (skip_sep(ls) == sep) {
+          save_and_next(ls);  /* skip 2nd `]' */
+#if defined(LUA_COMPAT_LSTR) && LUA_COMPAT_LSTR == 2
+          cont--;
+          if (sep == 0 && cont >= 0) break;
+#endif
+          goto endloop;
+        }
+        break;
+      }
+      case '\n':
+      case '\r': {
+        save(ls, '\n');
+        inclinenumber(ls);
+        if (!seminfo) luaZ_resetbuffer(ls->buff);  /* avoid wasting space */
+        break;
+      }
+      default: {
+        if (seminfo) save_and_next(ls);
+        else next(ls);
+      }
+    }
+  } endloop:
+  if (seminfo)
+    seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
+                                     luaZ_bufflen(ls->buff) - 2*(2 + sep));
+}
+
+
+static void read_string (LexState *ls, int del, SemInfo *seminfo) {
+  save_and_next(ls);
+  while (ls->current != del) {
+    switch (ls->current) {
+      case EOZ:
+        luaX_lexerror(ls, "unfinished string", TK_EOS);
+        continue;  /* to avoid warnings */
+      case '\n':
+      case '\r':
+        luaX_lexerror(ls, "unfinished string", TK_STRING);
+        continue;  /* to avoid warnings */
+      case '\\': {
+        int c;
+        next(ls);  /* do not save the `\' */
+        switch (ls->current) {
+          case 'a': c = '\a'; break;
+          case 'b': c = '\b'; break;
+          case 'f': c = '\f'; break;
+          case 'n': c = '\n'; break;
+          case 'r': c = '\r'; break;
+          case 't': c = '\t'; break;
+          case 'v': c = '\v'; break;
+          case '\n':  /* go through */
+          case '\r': save(ls, '\n'); inclinenumber(ls); continue;
+          case EOZ: continue;  /* will raise an error next loop */
+          default: {
+            if (!isdigit(ls->current))
+              save_and_next(ls);  /* handles \\, \", \', and \? */
+            else {  /* \xxx */
+              int i = 0;
+              c = 0;
+              do {
+                c = 10*c + (ls->current-'0');
+                next(ls);
+              } while (++i<3 && isdigit(ls->current));
+              if (c > UCHAR_MAX)
+                luaX_lexerror(ls, "escape sequence too large", TK_STRING);
+              save(ls, c);
+            }
+            continue;
+          }
+        }
+        save(ls, c);
+        next(ls);
+        continue;
+      }
+      default:
+        save_and_next(ls);
+    }
+  }
+  save_and_next(ls);  /* skip delimiter */
+  seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,
+                                   luaZ_bufflen(ls->buff) - 2);
+}
+
+
+static int llex (LexState *ls, SemInfo *seminfo) {
+  luaZ_resetbuffer(ls->buff);
+  for (;;) {
+    switch (ls->current) {
+      case '\n':
+      case '\r': {
+        inclinenumber(ls);
+        continue;
+      }
+      case '-': {
+        next(ls);
+        if (ls->current != '-') return '-';
+        /* else is a comment */
+        next(ls);
+        if (ls->current == '[') {
+          int sep = skip_sep(ls);
+          luaZ_resetbuffer(ls->buff);  /* `skip_sep' may dirty the buffer */
+          if (sep >= 0) {
+            read_long_string(ls, NULL, sep);  /* long comment */
+            luaZ_resetbuffer(ls->buff);
+            continue;
+          }
+        }
+        /* else short comment */
+        while (!currIsNewline(ls) && ls->current != EOZ)
+          next(ls);
+        continue;
+      }
+      case '[': {
+        int sep = skip_sep(ls);
+        if (sep >= 0) {
+          read_long_string(ls, seminfo, sep);
+          return TK_STRING;
+        }
+        else if (sep == -1) return '[';
+        else luaX_lexerror(ls, "invalid long string delimiter", TK_STRING);
+      }
+      case '=': {
+        next(ls);
+        if (ls->current != '=') return '=';
+        else { next(ls); return TK_EQ; }
+      }
+      case '<': {
+        next(ls);
+        if (ls->current != '=') return '<';
+        else { next(ls); return TK_LE; }
+      }
+      case '>': {
+        next(ls);
+        if (ls->current != '=') return '>';
+        else { next(ls); return TK_GE; }
+      }
+      case '~': {
+        next(ls);
+        if (ls->current != '=') return '~';
+        else { next(ls); return TK_NE; }
+      }
+      case '"':
+      case '\'': {
+        read_string(ls, ls->current, seminfo);
+        return TK_STRING;
+      }
+      case '.': {
+        save_and_next(ls);
+        if (check_next(ls, ".")) {
+          if (check_next(ls, "."))
+            return TK_DOTS;   /* ... */
+          else return TK_CONCAT;   /* .. */
+        }
+        else if (!isdigit(ls->current)) return '.';
+        else {
+          read_numeral(ls, seminfo);
+          return TK_NUMBER;
+        }
+      }
+      case EOZ: {
+        return TK_EOS;
+      }
+      default: {
+        if (isspace(ls->current)) {
+          lua_assert(!currIsNewline(ls));
+          next(ls);
+          continue;
+        }
+        else if (isdigit(ls->current)) {
+          read_numeral(ls, seminfo);
+          return TK_NUMBER;
+        }
+        else if (isalpha(ls->current) || ls->current == '_') {
+          /* identifier or reserved word */
+          TString *ts;
+          do {
+            save_and_next(ls);
+          } while (isalnum(ls->current) || ls->current == '_');
+          ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
+                                  luaZ_bufflen(ls->buff));
+          if (ts->tsv.reserved > 0)  /* reserved word? */
+            return ts->tsv.reserved - 1 + FIRST_RESERVED;
+          else {
+            seminfo->ts = ts;
+            return TK_NAME;
+          }
+        }
+        else {
+          int c = ls->current;
+          next(ls);
+          return c;  /* single-char tokens (+ - / ...) */
+        }
+      }
+    }
+  }
+}
+
+
+void luaX_next (LexState *ls) {
+  ls->lastline = ls->linenumber;
+  if (ls->lookahead.token != TK_EOS) {  /* is there a look-ahead token? */
+    ls->t = ls->lookahead;  /* use this one */
+    ls->lookahead.token = TK_EOS;  /* and discharge it */
+  }
+  else
+    ls->t.token = llex(ls, &ls->t.seminfo);  /* read next token */
+}
+
+
+void luaX_lookahead (LexState *ls) {
+  lua_assert(ls->lookahead.token == TK_EOS);
+  ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/llex.h b/libraries/LuaJIT-1.1.7/src/llex.h
new file mode 100644
index 0000000..a9201ce
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/llex.h
@@ -0,0 +1,81 @@
+/*
+** $Id: llex.h,v 1.58.1.1 2007/12/27 13:02:25 roberto Exp $
+** Lexical Analyzer
+** See Copyright Notice in lua.h
+*/
+
+#ifndef llex_h
+#define llex_h
+
+#include "lobject.h"
+#include "lzio.h"
+
+
+#define FIRST_RESERVED  257
+
+/* maximum length of a reserved word */
+#define TOKEN_LEN       (sizeof("function")/sizeof(char))
+
+
+/*
+* WARNING: if you change the order of this enumeration,
+* grep "ORDER RESERVED"
+*/
+enum RESERVED {
+  /* terminal symbols denoted by reserved words */
+  TK_AND = FIRST_RESERVED, TK_BREAK,
+  TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
+  TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
+  TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
+  /* other terminal symbols */
+  TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_NUMBER,
+  TK_NAME, TK_STRING, TK_EOS
+};
+
+/* number of reserved words */
+#define NUM_RESERVED    (cast(int, TK_WHILE-FIRST_RESERVED+1))
+
+
+/* array with token `names' */
+LUAI_DATA const char *const luaX_tokens [];
+
+
+typedef union {
+  lua_Number r;
+  TString *ts;
+} SemInfo;  /* semantics information */
+
+
+typedef struct Token {
+  int token;
+  SemInfo seminfo;
+} Token;
+
+
+typedef struct LexState {
+  int current;  /* current character (charint) */
+  int linenumber;  /* input line counter */
+  int lastline;  /* line of last token `consumed' */
+  Token t;  /* current token */
+  Token lookahead;  /* look ahead token */
+  struct FuncState *fs;  /* `FuncState' is private to the parser */
+  struct lua_State *L;
+  ZIO *z;  /* input stream */
+  Mbuffer *buff;  /* buffer for tokens */
+  TString *source;  /* current source name */
+  char decpoint;  /* locale decimal point */
+} LexState;
+
+
+LUAI_FUNC void luaX_init (lua_State *L);
+LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
+                              TString *source);
+LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
+LUAI_FUNC void luaX_next (LexState *ls);
+LUAI_FUNC void luaX_lookahead (LexState *ls);
+LUAI_FUNC void luaX_lexerror (LexState *ls, const char *msg, int token);
+LUAI_FUNC void luaX_syntaxerror (LexState *ls, const char *s);
+LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
+
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/llimits.h b/libraries/LuaJIT-1.1.7/src/llimits.h
new file mode 100644
index 0000000..ca8dcb7
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/llimits.h
@@ -0,0 +1,128 @@
+/*
+** $Id: llimits.h,v 1.69.1.1 2007/12/27 13:02:25 roberto Exp $
+** Limits, basic types, and some other `installation-dependent' definitions
+** See Copyright Notice in lua.h
+*/
+
+#ifndef llimits_h
+#define llimits_h
+
+
+#include <limits.h>
+#include <stddef.h>
+
+
+#include "lua.h"
+
+
+typedef LUAI_UINT32 lu_int32;
+
+typedef LUAI_UMEM lu_mem;
+
+typedef LUAI_MEM l_mem;
+
+
+
+/* chars used as small naturals (so that `char' is reserved for characters) */
+typedef unsigned char lu_byte;
+
+
+#define MAX_SIZET       ((size_t)(~(size_t)0)-2)
+
+#define MAX_LUMEM       ((lu_mem)(~(lu_mem)0)-2)
+
+
+#define MAX_INT (INT_MAX-2)  /* maximum value of an int (-2 for safety) */
+
+/*
+** conversion of pointer to integer
+** this is for hashing only; there is no problem if the integer
+** cannot hold the whole pointer value
+*/
+#define IntPoint(p)  ((unsigned int)(lu_mem)(p))
+
+
+
+/* type to ensure maximum alignment */
+typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
+
+
+/* result of a `usual argument conversion' over lua_Number */
+typedef LUAI_UACNUMBER l_uacNumber;
+
+
+/* internal assertions for in-house debugging */
+#ifdef lua_assert
+
+#define check_exp(c,e)          (lua_assert(c), (e))
+#define api_check(l,e)          lua_assert(e)
+
+#else
+
+#define lua_assert(c)           ((void)0)
+#define check_exp(c,e)          (e)
+#define api_check               luai_apicheck
+
+#endif
+
+
+#ifndef UNUSED
+#define UNUSED(x)       ((void)(x))     /* to avoid warnings */
+#endif
+
+
+#ifndef cast
+#define cast(t, exp)    ((t)(exp))
+#endif
+
+#define cast_byte(i)    cast(lu_byte, (i))
+#define cast_num(i)     cast(lua_Number, (i))
+#define cast_int(i)     cast(int, (i))
+
+
+
+/*
+** type for virtual-machine instructions
+** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
+*/
+typedef lu_int32 Instruction;
+
+
+
+/* maximum stack for a Lua function */
+#define MAXSTACK        250
+
+
+
+/* minimum size for the string table (must be power of 2) */
+#ifndef MINSTRTABSIZE
+#define MINSTRTABSIZE   32
+#endif
+
+
+/* minimum size for string buffer */
+#ifndef LUA_MINBUFFER
+#define LUA_MINBUFFER   32
+#endif
+
+
+#ifndef lua_lock
+#define lua_lock(L)     ((void) 0) 
+#define lua_unlock(L)   ((void) 0)
+#endif
+
+#ifndef luai_threadyield
+#define luai_threadyield(L)     {lua_unlock(L); lua_lock(L);}
+#endif
+
+
+/*
+** macro to control inclusion of some hard tests on stack reallocation
+*/ 
+#ifndef HARDSTACKTESTS
+#define condhardstacktests(x)   ((void)0)
+#else
+#define condhardstacktests(x)   x
+#endif
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lmathlib.c b/libraries/LuaJIT-1.1.7/src/lmathlib.c
new file mode 100644
index 0000000..441fbf7
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lmathlib.c
@@ -0,0 +1,263 @@
+/*
+** $Id: lmathlib.c,v 1.67.1.1 2007/12/27 13:02:25 roberto Exp $
+** Standard mathematical library
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stdlib.h>
+#include <math.h>
+
+#define lmathlib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+
+
+#undef PI
+#define PI (3.14159265358979323846)
+#define RADIANS_PER_DEGREE (PI/180.0)
+
+
+
+static int math_abs (lua_State *L) {
+  lua_pushnumber(L, fabs(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_sin (lua_State *L) {
+  lua_pushnumber(L, sin(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_sinh (lua_State *L) {
+  lua_pushnumber(L, sinh(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_cos (lua_State *L) {
+  lua_pushnumber(L, cos(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_cosh (lua_State *L) {
+  lua_pushnumber(L, cosh(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_tan (lua_State *L) {
+  lua_pushnumber(L, tan(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_tanh (lua_State *L) {
+  lua_pushnumber(L, tanh(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_asin (lua_State *L) {
+  lua_pushnumber(L, asin(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_acos (lua_State *L) {
+  lua_pushnumber(L, acos(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_atan (lua_State *L) {
+  lua_pushnumber(L, atan(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_atan2 (lua_State *L) {
+  lua_pushnumber(L, atan2(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
+  return 1;
+}
+
+static int math_ceil (lua_State *L) {
+  lua_pushnumber(L, ceil(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_floor (lua_State *L) {
+  lua_pushnumber(L, floor(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_fmod (lua_State *L) {
+  lua_pushnumber(L, fmod(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
+  return 1;
+}
+
+static int math_modf (lua_State *L) {
+  double ip;
+  double fp = modf(luaL_checknumber(L, 1), &ip);
+  lua_pushnumber(L, ip);
+  lua_pushnumber(L, fp);
+  return 2;
+}
+
+static int math_sqrt (lua_State *L) {
+  lua_pushnumber(L, sqrt(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_pow (lua_State *L) {
+  lua_pushnumber(L, pow(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
+  return 1;
+}
+
+static int math_log (lua_State *L) {
+  lua_pushnumber(L, log(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_log10 (lua_State *L) {
+  lua_pushnumber(L, log10(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_exp (lua_State *L) {
+  lua_pushnumber(L, exp(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_deg (lua_State *L) {
+  lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE);
+  return 1;
+}
+
+static int math_rad (lua_State *L) {
+  lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE);
+  return 1;
+}
+
+static int math_frexp (lua_State *L) {
+  int e;
+  lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e));
+  lua_pushinteger(L, e);
+  return 2;
+}
+
+static int math_ldexp (lua_State *L) {
+  lua_pushnumber(L, ldexp(luaL_checknumber(L, 1), luaL_checkint(L, 2)));
+  return 1;
+}
+
+
+
+static int math_min (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  lua_Number dmin = luaL_checknumber(L, 1);
+  int i;
+  for (i=2; i<=n; i++) {
+    lua_Number d = luaL_checknumber(L, i);
+    if (d < dmin)
+      dmin = d;
+  }
+  lua_pushnumber(L, dmin);
+  return 1;
+}
+
+
+static int math_max (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  lua_Number dmax = luaL_checknumber(L, 1);
+  int i;
+  for (i=2; i<=n; i++) {
+    lua_Number d = luaL_checknumber(L, i);
+    if (d > dmax)
+      dmax = d;
+  }
+  lua_pushnumber(L, dmax);
+  return 1;
+}
+
+
+static int math_random (lua_State *L) {
+  /* the `%' avoids the (rare) case of r==1, and is needed also because on
+     some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
+  lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX;
+  switch (lua_gettop(L)) {  /* check number of arguments */
+    case 0: {  /* no arguments */
+      lua_pushnumber(L, r);  /* Number between 0 and 1 */
+      break;
+    }
+    case 1: {  /* only upper limit */
+      int u = luaL_checkint(L, 1);
+      luaL_argcheck(L, 1<=u, 1, "interval is empty");
+      lua_pushnumber(L, floor(r*u)+1);  /* int between 1 and `u' */
+      break;
+    }
+    case 2: {  /* lower and upper limits */
+      int l = luaL_checkint(L, 1);
+      int u = luaL_checkint(L, 2);
+      luaL_argcheck(L, l<=u, 2, "interval is empty");
+      lua_pushnumber(L, floor(r*(u-l+1))+l);  /* int between `l' and `u' */
+      break;
+    }
+    default: return luaL_error(L, "wrong number of arguments");
+  }
+  return 1;
+}
+
+
+static int math_randomseed (lua_State *L) {
+  srand(luaL_checkint(L, 1));
+  return 0;
+}
+
+
+static const luaL_Reg mathlib[] = {
+  {"abs",   math_abs},
+  {"acos",  math_acos},
+  {"asin",  math_asin},
+  {"atan2", math_atan2},
+  {"atan",  math_atan},
+  {"ceil",  math_ceil},
+  {"cosh",   math_cosh},
+  {"cos",   math_cos},
+  {"deg",   math_deg},
+  {"exp",   math_exp},
+  {"floor", math_floor},
+  {"fmod",   math_fmod},
+  {"frexp", math_frexp},
+  {"ldexp", math_ldexp},
+  {"log10", math_log10},
+  {"log",   math_log},
+  {"max",   math_max},
+  {"min",   math_min},
+  {"modf",   math_modf},
+  {"pow",   math_pow},
+  {"rad",   math_rad},
+  {"random",     math_random},
+  {"randomseed", math_randomseed},
+  {"sinh",   math_sinh},
+  {"sin",   math_sin},
+  {"sqrt",  math_sqrt},
+  {"tanh",   math_tanh},
+  {"tan",   math_tan},
+  {NULL, NULL}
+};
+
+
+/*
+** Open math library
+*/
+LUALIB_API int luaopen_math (lua_State *L) {
+  luaL_register(L, LUA_MATHLIBNAME, mathlib);
+  lua_pushnumber(L, PI);
+  lua_setfield(L, -2, "pi");
+  lua_pushnumber(L, HUGE_VAL);
+  lua_setfield(L, -2, "huge");
+#if defined(LUA_COMPAT_MOD)
+  lua_getfield(L, -1, "fmod");
+  lua_setfield(L, -2, "mod");
+#endif
+  return 1;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lmem.c b/libraries/LuaJIT-1.1.7/src/lmem.c
new file mode 100644
index 0000000..ae7d8c9
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lmem.c
@@ -0,0 +1,86 @@
+/*
+** $Id: lmem.c,v 1.70.1.1 2007/12/27 13:02:25 roberto Exp $
+** Interface to Memory Manager
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stddef.h>
+
+#define lmem_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "ldebug.h"
+#include "ldo.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lstate.h"
+
+
+
+/*
+** About the realloc function:
+** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
+** (`osize' is the old size, `nsize' is the new size)
+**
+** Lua ensures that (ptr == NULL) iff (osize == 0).
+**
+** * frealloc(ud, NULL, 0, x) creates a new block of size `x'
+**
+** * frealloc(ud, p, x, 0) frees the block `p'
+** (in this specific case, frealloc must return NULL).
+** particularly, frealloc(ud, NULL, 0, 0) does nothing
+** (which is equivalent to free(NULL) in ANSI C)
+**
+** frealloc returns NULL if it cannot create or reallocate the area
+** (any reallocation to an equal or smaller size cannot fail!)
+*/
+
+
+
+#define MINSIZEARRAY    4
+
+
+void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
+                     int limit, const char *errormsg) {
+  void *newblock;
+  int newsize;
+  if (*size >= limit/2) {  /* cannot double it? */
+    if (*size >= limit)  /* cannot grow even a little? */
+      luaG_runerror(L, errormsg);
+    newsize = limit;  /* still have at least one free place */
+  }
+  else {
+    newsize = (*size)*2;
+    if (newsize < MINSIZEARRAY)
+      newsize = MINSIZEARRAY;  /* minimum size */
+  }
+  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
+  *size = newsize;  /* update only when everything else is OK */
+  return newblock;
+}
+
+
+void *luaM_toobig (lua_State *L) {
+  luaG_runerror(L, "memory allocation error: block too big");
+  return NULL;  /* to avoid warnings */
+}
+
+
+
+/*
+** generic allocation routine.
+*/
+void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
+  global_State *g = G(L);
+  lua_assert((osize == 0) == (block == NULL));
+  block = (*g->frealloc)(g->ud, block, osize, nsize);
+  if (block == NULL && nsize > 0)
+    luaD_throw(L, LUA_ERRMEM);
+  lua_assert((nsize == 0) == (block == NULL));
+  g->totalbytes = (g->totalbytes - osize) + nsize;
+  return block;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lmem.h b/libraries/LuaJIT-1.1.7/src/lmem.h
new file mode 100644
index 0000000..7c2dcb3
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lmem.h
@@ -0,0 +1,49 @@
+/*
+** $Id: lmem.h,v 1.31.1.1 2007/12/27 13:02:25 roberto Exp $
+** Interface to Memory Manager
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lmem_h
+#define lmem_h
+
+
+#include <stddef.h>
+
+#include "llimits.h"
+#include "lua.h"
+
+#define MEMERRMSG       "not enough memory"
+
+
+#define luaM_reallocv(L,b,on,n,e) \
+        ((cast(size_t, (n)+1) <= MAX_SIZET/(e)) ?  /* +1 to avoid warnings */ \
+                luaM_realloc_(L, (b), (on)*(e), (n)*(e)) : \
+                luaM_toobig(L))
+
+#define luaM_freemem(L, b, s)   luaM_realloc_(L, (b), (s), 0)
+#define luaM_free(L, b)         luaM_realloc_(L, (b), sizeof(*(b)), 0)
+#define luaM_freearray(L, b, n, t)   luaM_reallocv(L, (b), n, 0, sizeof(t))
+
+#define luaM_malloc(L,t)        luaM_realloc_(L, NULL, 0, (t))
+#define luaM_new(L,t)           cast(t *, luaM_malloc(L, sizeof(t)))
+#define luaM_newvector(L,n,t) \
+                cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
+
+#define luaM_growvector(L,v,nelems,size,t,limit,e) \
+          if ((nelems)+1 > (size)) \
+            ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
+
+#define luaM_reallocvector(L, v,oldn,n,t) \
+   ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
+
+
+LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
+                                                          size_t size);
+LUAI_FUNC void *luaM_toobig (lua_State *L);
+LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,
+                               size_t size_elem, int limit,
+                               const char *errormsg);
+
+#endif
+
diff --git a/libraries/LuaJIT-1.1.7/src/loadlib.c b/libraries/LuaJIT-1.1.7/src/loadlib.c
new file mode 100644
index 0000000..a2da9fc
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/loadlib.c
@@ -0,0 +1,669 @@
+/*
+** $Id: loadlib.c,v 1.52.1.3 2008/08/06 13:29:28 roberto Exp $
+** Dynamic library loader for Lua
+** See Copyright Notice in lua.h
+**
+** This module contains an implementation of loadlib for Unix systems
+** that have dlfcn, an implementation for Darwin (Mac OS X), an
+** implementation for Windows, and a stub for other systems.
+*/
+
+
+#include <stdlib.h>
+#include <string.h>
+
+
+#define loadlib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+#include "luajit.h"
+
+
+/* prefix for open functions in C libraries */
+#define LUA_POF         "luaopen_"
+
+/* separator for open functions in C libraries */
+#define LUA_OFSEP       "_"
+
+
+#define LIBPREFIX       "LOADLIB: "
+
+#define POF             LUA_POF
+#define LIB_FAIL        "open"
+
+
+/* error codes for ll_loadfunc */
+#define ERRLIB          1
+#define ERRFUNC         2
+
+#define setprogdir(L)           ((void)0)
+
+
+static void ll_unloadlib (void *lib);
+static void *ll_load (lua_State *L, const char *path);
+static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym);
+
+
+
+#if defined(LUA_DL_DLOPEN)
+/*
+** {========================================================================
+** This is an implementation of loadlib based on the dlfcn interface.
+** The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,
+** NetBSD, AIX 4.2, HPUX 11, and  probably most other Unix flavors, at least
+** as an emulation layer on top of native functions.
+** =========================================================================
+*/
+
+#include <dlfcn.h>
+
+static void ll_unloadlib (void *lib) {
+  dlclose(lib);
+}
+
+
+static void *ll_load (lua_State *L, const char *path) {
+  void *lib = dlopen(path, RTLD_NOW);
+  if (lib == NULL) lua_pushstring(L, dlerror());
+  return lib;
+}
+
+
+static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
+  lua_CFunction f = (lua_CFunction)dlsym(lib, sym);
+  if (f == NULL) lua_pushstring(L, dlerror());
+  return f;
+}
+
+/* }====================================================== */
+
+
+
+#elif defined(LUA_DL_DLL)
+/*
+** {======================================================================
+** This is an implementation of loadlib for Windows using native functions.
+** =======================================================================
+*/
+
+#include <windows.h>
+
+
+#undef setprogdir
+
+static void setprogdir (lua_State *L) {
+  char buff[MAX_PATH + 1];
+  char *lb;
+  DWORD nsize = sizeof(buff)/sizeof(char);
+  DWORD n = GetModuleFileNameA(NULL, buff, nsize);
+  if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL)
+    luaL_error(L, "unable to get ModuleFileName");
+  else {
+    *lb = '\0';
+    luaL_gsub(L, lua_tostring(L, -1), LUA_EXECDIR, buff);
+    lua_remove(L, -2);  /* remove original string */
+  }
+}
+
+
+static void pusherror (lua_State *L) {
+  int error = GetLastError();
+  char buffer[128];
+  if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
+      NULL, error, 0, buffer, sizeof(buffer), NULL))
+    lua_pushstring(L, buffer);
+  else
+    lua_pushfstring(L, "system error %d\n", error);
+}
+
+static void ll_unloadlib (void *lib) {
+  FreeLibrary((HINSTANCE)lib);
+}
+
+
+static void *ll_load (lua_State *L, const char *path) {
+  HINSTANCE lib = LoadLibraryA(path);
+  if (lib == NULL) pusherror(L);
+  return lib;
+}
+
+
+static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
+  lua_CFunction f = (lua_CFunction)GetProcAddress((HINSTANCE)lib, sym);
+  if (f == NULL) pusherror(L);
+  return f;
+}
+
+/* }====================================================== */
+
+
+
+#elif defined(LUA_DL_DYLD)
+/*
+** {======================================================================
+** Native Mac OS X / Darwin Implementation
+** =======================================================================
+*/
+
+#include <mach-o/dyld.h>
+
+
+/* Mac appends a `_' before C function names */
+#undef POF
+#define POF     "_" LUA_POF
+
+
+static void pusherror (lua_State *L) {
+  const char *err_str;
+  const char *err_file;
+  NSLinkEditErrors err;
+  int err_num;
+  NSLinkEditError(&err, &err_num, &err_file, &err_str);
+  lua_pushstring(L, err_str);
+}
+
+
+static const char *errorfromcode (NSObjectFileImageReturnCode ret) {
+  switch (ret) {
+    case NSObjectFileImageInappropriateFile:
+      return "file is not a bundle";
+    case NSObjectFileImageArch:
+      return "library is for wrong CPU type";
+    case NSObjectFileImageFormat:
+      return "bad format";
+    case NSObjectFileImageAccess:
+      return "cannot access file";
+    case NSObjectFileImageFailure:
+    default:
+      return "unable to load library";
+  }
+}
+
+
+static void ll_unloadlib (void *lib) {
+  NSUnLinkModule((NSModule)lib, NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES);
+}
+
+
+static void *ll_load (lua_State *L, const char *path) {
+  NSObjectFileImage img;
+  NSObjectFileImageReturnCode ret;
+  /* this would be a rare case, but prevents crashing if it happens */
+  if(!_dyld_present()) {
+    lua_pushliteral(L, "dyld not present");
+    return NULL;
+  }
+  ret = NSCreateObjectFileImageFromFile(path, &img);
+  if (ret == NSObjectFileImageSuccess) {
+    NSModule mod = NSLinkModule(img, path, NSLINKMODULE_OPTION_PRIVATE |
+                       NSLINKMODULE_OPTION_RETURN_ON_ERROR);
+    NSDestroyObjectFileImage(img);
+    if (mod == NULL) pusherror(L);
+    return mod;
+  }
+  lua_pushstring(L, errorfromcode(ret));
+  return NULL;
+}
+
+
+static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
+  NSSymbol nss = NSLookupSymbolInModule((NSModule)lib, sym);
+  if (nss == NULL) {
+    lua_pushfstring(L, "symbol " LUA_QS " not found", sym);
+    return NULL;
+  }
+  return (lua_CFunction)NSAddressOfSymbol(nss);
+}
+
+/* }====================================================== */
+
+
+
+#else
+/*
+** {======================================================
+** Fallback for other systems
+** =======================================================
+*/
+
+#undef LIB_FAIL
+#define LIB_FAIL        "absent"
+
+
+#define DLMSG   "dynamic libraries not enabled; check your Lua installation"
+
+
+static void ll_unloadlib (void *lib) {
+  (void)lib;  /* to avoid warnings */
+}
+
+
+static void *ll_load (lua_State *L, const char *path) {
+  (void)path;  /* to avoid warnings */
+  lua_pushliteral(L, DLMSG);
+  return NULL;
+}
+
+
+static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {
+  (void)lib; (void)sym;  /* to avoid warnings */
+  lua_pushliteral(L, DLMSG);
+  return NULL;
+}
+
+/* }====================================================== */
+#endif
+
+
+
+static void **ll_register (lua_State *L, const char *path) {
+  void **plib;
+  lua_pushfstring(L, "%s%s", LIBPREFIX, path);
+  lua_gettable(L, LUA_REGISTRYINDEX);  /* check library in registry? */
+  if (!lua_isnil(L, -1))  /* is there an entry? */
+    plib = (void **)lua_touserdata(L, -1);
+  else {  /* no entry yet; create one */
+    lua_pop(L, 1);
+    plib = (void **)lua_newuserdata(L, sizeof(const void *));
+    *plib = NULL;
+    luaL_getmetatable(L, "_LOADLIB");
+    lua_setmetatable(L, -2);
+    lua_pushfstring(L, "%s%s", LIBPREFIX, path);
+    lua_pushvalue(L, -2);
+    lua_settable(L, LUA_REGISTRYINDEX);
+  }
+  return plib;
+}
+
+
+/*
+** __gc tag method: calls library's `ll_unloadlib' function with the lib
+** handle
+*/
+static int gctm (lua_State *L) {
+  void **lib = (void **)luaL_checkudata(L, 1, "_LOADLIB");
+  if (*lib) ll_unloadlib(*lib);
+  *lib = NULL;  /* mark library as closed */
+  return 0;
+}
+
+
+static int ll_loadfunc (lua_State *L, const char *path, const char *sym) {
+  void **reg = ll_register(L, path);
+  if (*reg == NULL) *reg = ll_load(L, path);
+  if (*reg == NULL)
+    return ERRLIB;  /* unable to load library */
+  else {
+    lua_CFunction f = ll_sym(L, *reg, sym);
+    if (f == NULL)
+      return ERRFUNC;  /* unable to find function */
+    lua_pushcfunction(L, f);
+    return 0;  /* return function */
+  }
+}
+
+
+static int ll_loadlib (lua_State *L) {
+  const char *path = luaL_checkstring(L, 1);
+  const char *init = luaL_checkstring(L, 2);
+  int stat = ll_loadfunc(L, path, init);
+  if (stat == 0)  /* no errors? */
+    return 1;  /* return the loaded function */
+  else {  /* error; error message is on stack top */
+    lua_pushnil(L);
+    lua_insert(L, -2);
+    lua_pushstring(L, (stat == ERRLIB) ?  LIB_FAIL : "init");
+    return 3;  /* return nil, error message, and where */
+  }
+}
+
+
+
+/*
+** {======================================================
+** 'require' function
+** =======================================================
+*/
+
+
+static int readable (const char *filename) {
+  FILE *f = fopen(filename, "r");  /* try to open file */
+  if (f == NULL) return 0;  /* open failed */
+  fclose(f);
+  return 1;
+}
+
+
+static const char *pushnexttemplate (lua_State *L, const char *path) {
+  const char *l;
+  while (*path == *LUA_PATHSEP) path++;  /* skip separators */
+  if (*path == '\0') return NULL;  /* no more templates */
+  l = strchr(path, *LUA_PATHSEP);  /* find next separator */
+  if (l == NULL) l = path + strlen(path);
+  lua_pushlstring(L, path, l - path);  /* template */
+  return l;
+}
+
+
+static const char *findfile (lua_State *L, const char *name,
+                                           const char *pname) {
+  const char *path;
+  name = luaL_gsub(L, name, ".", LUA_DIRSEP);
+  lua_getfield(L, LUA_ENVIRONINDEX, pname);
+  path = lua_tostring(L, -1);
+  if (path == NULL)
+    luaL_error(L, LUA_QL("package.%s") " must be a string", pname);
+  lua_pushliteral(L, "");  /* error accumulator */
+  while ((path = pushnexttemplate(L, path)) != NULL) {
+    const char *filename;
+    filename = luaL_gsub(L, lua_tostring(L, -1), LUA_PATH_MARK, name);
+    lua_remove(L, -2);  /* remove path template */
+    if (readable(filename))  /* does file exist and is readable? */
+      return filename;  /* return that file name */
+    lua_pushfstring(L, "\n\tno file " LUA_QS, filename);
+    lua_remove(L, -2);  /* remove file name */
+    lua_concat(L, 2);  /* add entry to possible error message */
+  }
+  return NULL;  /* not found */
+}
+
+
+static void loaderror (lua_State *L, const char *filename) {
+  luaL_error(L, "error loading module " LUA_QS " from file " LUA_QS ":\n\t%s",
+                lua_tostring(L, 1), filename, lua_tostring(L, -1));
+}
+
+
+static int loader_Lua (lua_State *L) {
+  const char *filename;
+  const char *name = luaL_checkstring(L, 1);
+  filename = findfile(L, name, "path");
+  if (filename == NULL) return 1;  /* library not found in this path */
+  if (luaL_loadfile(L, filename) != 0)
+    loaderror(L, filename);
+  /* not useful to JIT compile main chunk of a module */
+  luaJIT_setmode(L, -1, LUAJIT_MODE_FUNC|LUAJIT_MODE_OFF);
+  return 1;  /* library loaded successfully */
+}
+
+
+static const char *mkfuncname (lua_State *L, const char *modname) {
+  const char *funcname;
+  const char *mark = strchr(modname, *LUA_IGMARK);
+  if (mark) modname = mark + 1;
+  funcname = luaL_gsub(L, modname, ".", LUA_OFSEP);
+  funcname = lua_pushfstring(L, POF"%s", funcname);
+  lua_remove(L, -2);  /* remove 'gsub' result */
+  return funcname;
+}
+
+
+static int loader_C (lua_State *L) {
+  const char *funcname;
+  const char *name = luaL_checkstring(L, 1);
+  const char *filename = findfile(L, name, "cpath");
+  if (filename == NULL) return 1;  /* library not found in this path */
+  funcname = mkfuncname(L, name);
+  if (ll_loadfunc(L, filename, funcname) != 0)
+    loaderror(L, filename);
+  return 1;  /* library loaded successfully */
+}
+
+
+static int loader_Croot (lua_State *L) {
+  const char *funcname;
+  const char *filename;
+  const char *name = luaL_checkstring(L, 1);
+  const char *p = strchr(name, '.');
+  int stat;
+  if (p == NULL) return 0;  /* is root */
+  lua_pushlstring(L, name, p - name);
+  filename = findfile(L, lua_tostring(L, -1), "cpath");
+  if (filename == NULL) return 1;  /* root not found */
+  funcname = mkfuncname(L, name);
+  if ((stat = ll_loadfunc(L, filename, funcname)) != 0) {
+    if (stat != ERRFUNC) loaderror(L, filename);  /* real error */
+    lua_pushfstring(L, "\n\tno module " LUA_QS " in file " LUA_QS,
+                       name, filename);
+    return 1;  /* function not found */
+  }
+  return 1;
+}
+
+
+static int loader_preload (lua_State *L) {
+  const char *name = luaL_checkstring(L, 1);
+  lua_getfield(L, LUA_ENVIRONINDEX, "preload");
+  if (!lua_istable(L, -1))
+    luaL_error(L, LUA_QL("package.preload") " must be a table");
+  lua_getfield(L, -1, name);
+  if (lua_isnil(L, -1))  /* not found? */
+    lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
+  return 1;
+}
+
+
+static const int sentinel_ = 0;
+#define sentinel        ((void *)&sentinel_)
+
+
+static int ll_require (lua_State *L) {
+  const char *name = luaL_checkstring(L, 1);
+  int i;
+  lua_settop(L, 1);  /* _LOADED table will be at index 2 */
+  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
+  lua_getfield(L, 2, name);
+  if (lua_toboolean(L, -1)) {  /* is it there? */
+    if (lua_touserdata(L, -1) == sentinel)  /* check loops */
+      luaL_error(L, "loop or previous error loading module " LUA_QS, name);
+    return 1;  /* package is already loaded */
+  }
+  /* else must load it; iterate over available loaders */
+  lua_getfield(L, LUA_ENVIRONINDEX, "loaders");
+  if (!lua_istable(L, -1))
+    luaL_error(L, LUA_QL("package.loaders") " must be a table");
+  lua_pushliteral(L, "");  /* error message accumulator */
+  for (i=1; ; i++) {
+    lua_rawgeti(L, -2, i);  /* get a loader */
+    if (lua_isnil(L, -1))
+      luaL_error(L, "module " LUA_QS " not found:%s",
+                    name, lua_tostring(L, -2));
+    lua_pushstring(L, name);
+    lua_call(L, 1, 1);  /* call it */
+    if (lua_isfunction(L, -1))  /* did it find module? */
+      break;  /* module loaded successfully */
+    else if (lua_isstring(L, -1))  /* loader returned error message? */
+      lua_concat(L, 2);  /* accumulate it */
+    else
+      lua_pop(L, 1);
+  }
+  lua_pushlightuserdata(L, sentinel);
+  lua_setfield(L, 2, name);  /* _LOADED[name] = sentinel */
+  lua_pushstring(L, name);  /* pass name as argument to module */
+  lua_call(L, 1, 1);  /* run loaded module */
+  if (!lua_isnil(L, -1))  /* non-nil return? */
+    lua_setfield(L, 2, name);  /* _LOADED[name] = returned value */
+  lua_getfield(L, 2, name);
+  if (lua_touserdata(L, -1) == sentinel) {   /* module did not set a value? */
+    lua_pushboolean(L, 1);  /* use true as result */
+    lua_pushvalue(L, -1);  /* extra copy to be returned */
+    lua_setfield(L, 2, name);  /* _LOADED[name] = true */
+  }
+  return 1;
+}
+
+/* }====================================================== */
+
+
+
+/*
+** {======================================================
+** 'module' function
+** =======================================================
+*/
+  
+
+static void setfenv (lua_State *L) {
+  lua_Debug ar;
+  if (lua_getstack(L, 1, &ar) == 0 ||
+      lua_getinfo(L, "f", &ar) == 0 ||  /* get calling function */
+      lua_iscfunction(L, -1))
+    luaL_error(L, LUA_QL("module") " not called from a Lua function");
+  lua_pushvalue(L, -2);
+  lua_setfenv(L, -2);
+  lua_pop(L, 1);
+}
+
+
+static void dooptions (lua_State *L, int n) {
+  int i;
+  for (i = 2; i <= n; i++) {
+    lua_pushvalue(L, i);  /* get option (a function) */
+    lua_pushvalue(L, -2);  /* module */
+    lua_call(L, 1, 0);
+  }
+}
+
+
+static void modinit (lua_State *L, const char *modname) {
+  const char *dot;
+  lua_pushvalue(L, -1);
+  lua_setfield(L, -2, "_M");  /* module._M = module */
+  lua_pushstring(L, modname);
+  lua_setfield(L, -2, "_NAME");
+  dot = strrchr(modname, '.');  /* look for last dot in module name */
+  if (dot == NULL) dot = modname;
+  else dot++;
+  /* set _PACKAGE as package name (full module name minus last part) */
+  lua_pushlstring(L, modname, dot - modname);
+  lua_setfield(L, -2, "_PACKAGE");
+}
+
+
+static int ll_module (lua_State *L) {
+  const char *modname = luaL_checkstring(L, 1);
+  int loaded = lua_gettop(L) + 1;  /* index of _LOADED table */
+  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
+  lua_getfield(L, loaded, modname);  /* get _LOADED[modname] */
+  if (!lua_istable(L, -1)) {  /* not found? */
+    lua_pop(L, 1);  /* remove previous result */
+    /* try global variable (and create one if it does not exist) */
+    if (luaL_findtable(L, LUA_GLOBALSINDEX, modname, 1) != NULL)
+      return luaL_error(L, "name conflict for module " LUA_QS, modname);
+    lua_pushvalue(L, -1);
+    lua_setfield(L, loaded, modname);  /* _LOADED[modname] = new table */
+  }
+  /* check whether table already has a _NAME field */
+  lua_getfield(L, -1, "_NAME");
+  if (!lua_isnil(L, -1))  /* is table an initialized module? */
+    lua_pop(L, 1);
+  else {  /* no; initialize it */
+    lua_pop(L, 1);
+    modinit(L, modname);
+  }
+  lua_pushvalue(L, -1);
+  setfenv(L);
+  dooptions(L, loaded - 1);
+  return 0;
+}
+
+
+static int ll_seeall (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  if (!lua_getmetatable(L, 1)) {
+    lua_createtable(L, 0, 1); /* create new metatable */
+    lua_pushvalue(L, -1);
+    lua_setmetatable(L, 1);
+  }
+  lua_pushvalue(L, LUA_GLOBALSINDEX);
+  lua_setfield(L, -2, "__index");  /* mt.__index = _G */
+  return 0;
+}
+
+
+/* }====================================================== */
+
+
+
+/* auxiliary mark (for internal use) */
+#define AUXMARK         "\1"
+
+static void setpath (lua_State *L, const char *fieldname, const char *envname,
+                                   const char *def) {
+  const char *path = getenv(envname);
+  if (path == NULL)  /* no environment variable? */
+    lua_pushstring(L, def);  /* use default */
+  else {
+    /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
+    path = luaL_gsub(L, path, LUA_PATHSEP LUA_PATHSEP,
+                              LUA_PATHSEP AUXMARK LUA_PATHSEP);
+    luaL_gsub(L, path, AUXMARK, def);
+    lua_remove(L, -2);
+  }
+  setprogdir(L);
+  lua_setfield(L, -2, fieldname);
+}
+
+
+static const luaL_Reg pk_funcs[] = {
+  {"loadlib", ll_loadlib},
+  {"seeall", ll_seeall},
+  {NULL, NULL}
+};
+
+
+static const luaL_Reg ll_funcs[] = {
+  {"module", ll_module},
+  {"require", ll_require},
+  {NULL, NULL}
+};
+
+
+static const lua_CFunction loaders[] =
+  {loader_preload, loader_Lua, loader_C, loader_Croot, NULL};
+
+
+LUALIB_API int luaopen_package (lua_State *L) {
+  int i;
+  /* create new type _LOADLIB */
+  luaL_newmetatable(L, "_LOADLIB");
+  lua_pushcfunction(L, gctm);
+  lua_setfield(L, -2, "__gc");
+  /* create `package' table */
+  luaL_register(L, LUA_LOADLIBNAME, pk_funcs);
+#if defined(LUA_COMPAT_LOADLIB) 
+  lua_getfield(L, -1, "loadlib");
+  lua_setfield(L, LUA_GLOBALSINDEX, "loadlib");
+#endif
+  lua_pushvalue(L, -1);
+  lua_replace(L, LUA_ENVIRONINDEX);
+  /* create `loaders' table */
+  lua_createtable(L, sizeof(loaders)/sizeof(loaders[0]) - 1, 0);
+  /* fill it with pre-defined loaders */
+  for (i=0; loaders[i] != NULL; i++) {
+    lua_pushcfunction(L, loaders[i]);
+    lua_rawseti(L, -2, i+1);
+  }
+  lua_setfield(L, -2, "loaders");  /* put it in field `loaders' */
+  setpath(L, "path", LUA_PATH, LUA_PATH_DEFAULT);  /* set field `path' */
+  setpath(L, "cpath", LUA_CPATH, LUA_CPATH_DEFAULT); /* set field `cpath' */
+  /* store config information */
+  lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATHSEP "\n" LUA_PATH_MARK "\n"
+                     LUA_EXECDIR "\n" LUA_IGMARK);
+  lua_setfield(L, -2, "config");
+  /* set field `loaded' */
+  luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 2);
+  lua_setfield(L, -2, "loaded");
+  /* set field `preload' */
+  lua_newtable(L);
+  lua_setfield(L, -2, "preload");
+  lua_pushvalue(L, LUA_GLOBALSINDEX);
+  luaL_register(L, NULL, ll_funcs);  /* open lib into global table */
+  lua_pop(L, 1);
+  return 1;  /* return 'package' table */
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lobject.c b/libraries/LuaJIT-1.1.7/src/lobject.c
new file mode 100644
index 0000000..4ff5073
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lobject.c
@@ -0,0 +1,214 @@
+/*
+** $Id: lobject.c,v 2.22.1.1 2007/12/27 13:02:25 roberto Exp $
+** Some generic functions over Lua objects
+** See Copyright Notice in lua.h
+*/
+
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define lobject_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "ldo.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "lvm.h"
+
+
+
+const TValue luaO_nilobject_ = {{NULL}, LUA_TNIL};
+
+
+/*
+** converts an integer to a "floating point byte", represented as
+** (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if
+** eeeee != 0 and (xxx) otherwise.
+*/
+int luaO_int2fb (unsigned int x) {
+  int e = 0;  /* expoent */
+  while (x >= 16) {
+    x = (x+1) >> 1;
+    e++;
+  }
+  if (x < 8) return x;
+  else return ((e+1) << 3) | (cast_int(x) - 8);
+}
+
+
+/* converts back */
+int luaO_fb2int (int x) {
+  int e = (x >> 3) & 31;
+  if (e == 0) return x;
+  else return ((x & 7)+8) << (e - 1);
+}
+
+
+int luaO_log2 (unsigned int x) {
+  static const lu_byte log_2[256] = {
+    0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
+  };
+  int l = -1;
+  while (x >= 256) { l += 8; x >>= 8; }
+  return l + log_2[x];
+
+}
+
+
+int luaO_rawequalObj (const TValue *t1, const TValue *t2) {
+  if (ttype(t1) != ttype(t2)) return 0;
+  else switch (ttype(t1)) {
+    case LUA_TNIL:
+      return 1;
+    case LUA_TNUMBER:
+      return luai_numeq(nvalue(t1), nvalue(t2));
+    case LUA_TBOOLEAN:
+      return bvalue(t1) == bvalue(t2);  /* boolean true must be 1 !! */
+    case LUA_TLIGHTUSERDATA:
+      return pvalue(t1) == pvalue(t2);
+    default:
+      lua_assert(iscollectable(t1));
+      return gcvalue(t1) == gcvalue(t2);
+  }
+}
+
+
+int luaO_str2d (const char *s, lua_Number *result) {
+  char *endptr;
+  *result = lua_str2number(s, &endptr);
+  if (endptr == s) return 0;  /* conversion failed */
+  if (*endptr == 'x' || *endptr == 'X')  /* maybe an hexadecimal constant? */
+    *result = cast_num(strtoul(s, &endptr, 16));
+  if (*endptr == '\0') return 1;  /* most common case */
+  while (isspace(cast(unsigned char, *endptr))) endptr++;
+  if (*endptr != '\0') return 0;  /* invalid trailing characters? */
+  return 1;
+}
+
+
+
+static void pushstr (lua_State *L, const char *str) {
+  setsvalue2s(L, L->top, luaS_new(L, str));
+  incr_top(L);
+}
+
+
+/* this function handles only `%d', `%c', %f, %p, and `%s' formats */
+const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
+  int n = 1;
+  pushstr(L, "");
+  for (;;) {
+    const char *e = strchr(fmt, '%');
+    if (e == NULL) break;
+    setsvalue2s(L, L->top, luaS_newlstr(L, fmt, e-fmt));
+    incr_top(L);
+    switch (*(e+1)) {
+      case 's': {
+        const char *s = va_arg(argp, char *);
+        if (s == NULL) s = "(null)";
+        pushstr(L, s);
+        break;
+      }
+      case 'c': {
+        char buff[2];
+        buff[0] = cast(char, va_arg(argp, int));
+        buff[1] = '\0';
+        pushstr(L, buff);
+        break;
+      }
+      case 'd': {
+        setnvalue(L->top, cast_num(va_arg(argp, int)));
+        incr_top(L);
+        break;
+      }
+      case 'f': {
+        setnvalue(L->top, cast_num(va_arg(argp, l_uacNumber)));
+        incr_top(L);
+        break;
+      }
+      case 'p': {
+        char buff[4*sizeof(void *) + 8]; /* should be enough space for a `%p' */
+        sprintf(buff, "%p", va_arg(argp, void *));
+        pushstr(L, buff);
+        break;
+      }
+      case '%': {
+        pushstr(L, "%");
+        break;
+      }
+      default: {
+        char buff[3];
+        buff[0] = '%';
+        buff[1] = *(e+1);
+        buff[2] = '\0';
+        pushstr(L, buff);
+        break;
+      }
+    }
+    n += 2;
+    fmt = e+2;
+  }
+  pushstr(L, fmt);
+  luaV_concat(L, n+1, cast_int(L->top - L->base) - 1);
+  L->top -= n;
+  return svalue(L->top - 1);
+}
+
+
+const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
+  const char *msg;
+  va_list argp;
+  va_start(argp, fmt);
+  msg = luaO_pushvfstring(L, fmt, argp);
+  va_end(argp);
+  return msg;
+}
+
+
+void luaO_chunkid (char *out, const char *source, size_t bufflen) {
+  if (*source == '=') {
+    strncpy(out, source+1, bufflen);  /* remove first char */
+    out[bufflen-1] = '\0';  /* ensures null termination */
+  }
+  else {  /* out = "source", or "...source" */
+    if (*source == '@') {
+      size_t l;
+      source++;  /* skip the `@' */
+      bufflen -= sizeof(" '...' ");
+      l = strlen(source);
+      strcpy(out, "");
+      if (l > bufflen) {
+        source += (l-bufflen);  /* get last part of file name */
+        strcat(out, "...");
+      }
+      strcat(out, source);
+    }
+    else {  /* out = [string "string"] */
+      size_t len = strcspn(source, "\n\r");  /* stop at first newline */
+      bufflen -= sizeof(" [string \"...\"] ");
+      if (len > bufflen) len = bufflen;
+      strcpy(out, "[string \"");
+      if (source[len] != '\0') {  /* must truncate? */
+        strncat(out, source, len);
+        strcat(out, "...");
+      }
+      else
+        strcat(out, source);
+      strcat(out, "\"]");
+    }
+  }
+}
diff --git a/libraries/LuaJIT-1.1.7/src/lobject.h b/libraries/LuaJIT-1.1.7/src/lobject.h
new file mode 100644
index 0000000..df9c528
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lobject.h
@@ -0,0 +1,386 @@
+/*
+** $Id: lobject.h,v 2.20.1.2 2008/08/06 13:29:48 roberto Exp $
+** Type definitions for Lua objects
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lobject_h
+#define lobject_h
+
+
+#include <stdarg.h>
+
+
+#include "llimits.h"
+#include "lua.h"
+
+
+/* tags for values visible from Lua */
+#define LAST_TAG        LUA_TTHREAD
+
+#define NUM_TAGS        (LAST_TAG+1)
+
+
+/*
+** Extra tags for non-values
+*/
+#define LUA_TPROTO      (LAST_TAG+1)
+#define LUA_TUPVAL      (LAST_TAG+2)
+#define LUA_TDEADKEY    (LAST_TAG+3)
+
+
+/*
+** Union of all collectable objects
+*/
+typedef union GCObject GCObject;
+
+
+/*
+** Common Header for all collectable objects (in macro form, to be
+** included in other objects)
+*/
+#define CommonHeader    GCObject *next; lu_byte tt; lu_byte marked
+
+
+/*
+** Common header in struct form
+*/
+typedef struct GCheader {
+  CommonHeader;
+} GCheader;
+
+
+
+
+/*
+** Union of all Lua values
+*/
+typedef union {
+  GCObject *gc;
+  void *p;
+  lua_Number n;
+  ptrdiff_t na[sizeof(lua_Number)/sizeof(ptrdiff_t)];  /* LuaJIT kludge */
+  int b;
+} Value;
+
+
+/*
+** Tagged Values
+*/
+
+#define TValuefields    Value value; int tt
+
+typedef struct lua_TValue {
+  TValuefields;
+} LUA_TVALUE_ALIGN TValue;
+
+
+/* Macros to test type */
+#define ttisnil(o)      (ttype(o) == LUA_TNIL)
+#define ttisnumber(o)   (ttype(o) == LUA_TNUMBER)
+#define ttisstring(o)   (ttype(o) == LUA_TSTRING)
+#define ttistable(o)    (ttype(o) == LUA_TTABLE)
+#define ttisfunction(o) (ttype(o) == LUA_TFUNCTION)
+#define ttisboolean(o)  (ttype(o) == LUA_TBOOLEAN)
+#define ttisuserdata(o) (ttype(o) == LUA_TUSERDATA)
+#define ttisthread(o)   (ttype(o) == LUA_TTHREAD)
+#define ttislightuserdata(o)    (ttype(o) == LUA_TLIGHTUSERDATA)
+
+/* Macros to access values */
+#define ttype(o)        ((o)->tt)
+#define gcvalue(o)      check_exp(iscollectable(o), (o)->value.gc)
+#define pvalue(o)       check_exp(ttislightuserdata(o), (o)->value.p)
+#define nvalue(o)       check_exp(ttisnumber(o), (o)->value.n)
+#define rawtsvalue(o)   check_exp(ttisstring(o), &(o)->value.gc->ts)
+#define tsvalue(o)      (&rawtsvalue(o)->tsv)
+#define rawuvalue(o)    check_exp(ttisuserdata(o), &(o)->value.gc->u)
+#define uvalue(o)       (&rawuvalue(o)->uv)
+#define clvalue(o)      check_exp(ttisfunction(o), &(o)->value.gc->cl)
+#define hvalue(o)       check_exp(ttistable(o), &(o)->value.gc->h)
+#define bvalue(o)       check_exp(ttisboolean(o), (o)->value.b)
+#define thvalue(o)      check_exp(ttisthread(o), &(o)->value.gc->th)
+
+#define l_isfalse(o)    (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
+
+/*
+** for internal debug only
+*/
+#define checkconsistency(obj) \
+  lua_assert(!iscollectable(obj) || (ttype(obj) == (obj)->value.gc->gch.tt))
+
+#define checkliveness(g,obj) \
+  lua_assert(!iscollectable(obj) || \
+  ((ttype(obj) == (obj)->value.gc->gch.tt) && !isdead(g, (obj)->value.gc)))
+
+
+/* Macros to set values */
+#define setnilvalue(obj) ((obj)->tt=LUA_TNIL)
+
+#define setnvalue(obj,x) \
+  { TValue *i_o=(obj); i_o->value.n=(x); i_o->tt=LUA_TNUMBER; }
+
+#define setpvalue(obj,x) \
+  { TValue *i_o=(obj); i_o->value.p=(x); i_o->tt=LUA_TLIGHTUSERDATA; }
+
+#define setbvalue(obj,x) \
+  { TValue *i_o=(obj); i_o->value.b=(x); i_o->tt=LUA_TBOOLEAN; }
+
+#define setsvalue(L,obj,x) \
+  { TValue *i_o=(obj); \
+    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TSTRING; \
+    checkliveness(G(L),i_o); }
+
+#define setuvalue(L,obj,x) \
+  { TValue *i_o=(obj); \
+    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TUSERDATA; \
+    checkliveness(G(L),i_o); }
+
+#define setthvalue(L,obj,x) \
+  { TValue *i_o=(obj); \
+    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTHREAD; \
+    checkliveness(G(L),i_o); }
+
+#define setclvalue(L,obj,x) \
+  { TValue *i_o=(obj); \
+    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TFUNCTION; \
+    checkliveness(G(L),i_o); }
+
+#define sethvalue(L,obj,x) \
+  { TValue *i_o=(obj); \
+    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTABLE; \
+    checkliveness(G(L),i_o); }
+
+#define setptvalue(L,obj,x) \
+  { TValue *i_o=(obj); \
+    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TPROTO; \
+    checkliveness(G(L),i_o); }
+
+
+
+
+#define setobj(L,obj1,obj2) \
+  { const TValue *o2=(obj2); TValue *o1=(obj1); \
+    o1->value = o2->value; o1->tt=o2->tt; \
+    checkliveness(G(L),o1); }
+
+
+/*
+** different types of sets, according to destination
+*/
+
+/* from stack to (same) stack */
+#define setobjs2s       setobj
+/* to stack (not from same stack) */
+#define setobj2s        setobj
+#define setsvalue2s     setsvalue
+#define sethvalue2s     sethvalue
+#define setptvalue2s    setptvalue
+/* from table to same table */
+#define setobjt2t       setobj
+/* to table */
+#define setobj2t        setobj
+/* to new object */
+#define setobj2n        setobj
+#define setsvalue2n     setsvalue
+
+#define setttype(obj, tt) (ttype(obj) = (tt))
+
+
+#define iscollectable(o)        (ttype(o) >= LUA_TSTRING)
+
+
+
+typedef TValue *StkId;  /* index to stack elements */
+
+
+/*
+** String headers for string table
+*/
+typedef union TString {
+  L_Umaxalign dummy;  /* ensures maximum alignment for strings */
+  struct {
+    CommonHeader;
+    lu_byte reserved;
+    unsigned int hash;
+    size_t len;
+  } tsv;
+} TString;
+
+
+#define getstr(ts)      cast(const char *, (ts) + 1)
+#define svalue(o)       getstr(rawtsvalue(o))
+
+
+
+typedef union Udata {
+  L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
+  struct {
+    CommonHeader;
+    struct Table *metatable;
+    struct Table *env;
+    size_t len;
+  } uv;
+} Udata;
+
+
+
+
+/*
+** Function Prototypes
+*/
+typedef struct Proto {
+  CommonHeader;
+  TValue *k;  /* constants used by the function */
+  Instruction *code;
+  struct Proto **p;  /* functions defined inside the function */
+  int *lineinfo;  /* map from opcodes to source lines */
+  struct LocVar *locvars;  /* information about local variables */
+  TString **upvalues;  /* upvalue names */
+  TString  *source;
+  int sizeupvalues;
+  int sizek;  /* size of `k' */
+  int sizecode;
+  int sizelineinfo;
+  int sizep;  /* size of `p' */
+  int sizelocvars;
+  int linedefined;
+  int lastlinedefined;
+  GCObject *gclist;
+  lu_byte nups;  /* number of upvalues */
+  lu_byte numparams;
+  lu_byte is_vararg;
+  lu_byte maxstacksize;
+  /* LuaJIT extensions */
+  void *jit_mcode;  /* compiled machine code base address */
+  size_t jit_szmcode;  /* size of compiled mcode */
+  int jit_status;  /* JIT engine status code */
+} Proto;
+
+
+/* masks for new-style vararg */
+#define VARARG_HASARG           1
+#define VARARG_ISVARARG         2
+#define VARARG_NEEDSARG         4
+
+
+typedef struct LocVar {
+  TString *varname;
+  int startpc;  /* first point where variable is active */
+  int endpc;    /* first point where variable is dead */
+} LocVar;
+
+
+
+/*
+** Upvalues
+*/
+
+typedef struct UpVal {
+  CommonHeader;
+  TValue *v;  /* points to stack or to its own value */
+  union {
+    TValue value;  /* the value (when closed) */
+    struct {  /* double linked list (when open) */
+      struct UpVal *prev;
+      struct UpVal *next;
+    } l;
+  } u;
+} UpVal;
+
+
+/*
+** Closures
+*/
+
+#define ClosureHeader \
+        CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist; \
+        struct Table *env; lua_CFunction jit_gate
+
+typedef struct CClosure {
+  ClosureHeader;
+  lua_CFunction f;
+  TValue upvalue[1];
+} CClosure;
+
+
+typedef struct LClosure {
+  ClosureHeader;
+  struct Proto *p;
+  UpVal *upvals[1];
+} LClosure;
+
+
+typedef union Closure {
+  CClosure c;
+  LClosure l;
+} Closure;
+
+
+#define iscfunction(o)  (ttype(o) == LUA_TFUNCTION && clvalue(o)->c.isC)
+#define isLfunction(o)  (ttype(o) == LUA_TFUNCTION && !clvalue(o)->c.isC)
+
+
+/*
+** Tables
+*/
+
+typedef union TKey {
+  struct {
+    TValuefields;
+    struct Node *next;  /* for chaining */
+  } nk;
+  TValue tvk;
+} TKey;
+
+
+typedef struct Node {
+  TValue i_val;
+  TKey i_key;
+} Node;
+
+
+typedef struct Table {
+  CommonHeader;
+  lu_byte flags;  /* 1<<p means tagmethod(p) is not present */ 
+  lu_byte lsizenode;  /* log2 of size of `node' array */
+  struct Table *metatable;
+  TValue *array;  /* array part */
+  Node *node;
+  Node *lastfree;  /* any free position is before this position */
+  GCObject *gclist;
+  int sizearray;  /* size of `array' array */
+} Table;
+
+
+
+/*
+** `module' operation for hashing (size is always a power of 2)
+*/
+#define lmod(s,size) \
+        (check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1)))))
+
+
+#define twoto(x)        (1<<(x))
+#define sizenode(t)     (twoto((t)->lsizenode))
+
+
+#define luaO_nilobject          (&luaO_nilobject_)
+
+LUAI_DATA const TValue luaO_nilobject_;
+
+#define ceillog2(x)     (luaO_log2((x)-1) + 1)
+
+LUAI_FUNC int luaO_log2 (unsigned int x);
+LUAI_FUNC int luaO_int2fb (unsigned int x);
+LUAI_FUNC int luaO_fb2int (int x);
+LUAI_FUNC int luaO_rawequalObj (const TValue *t1, const TValue *t2);
+LUAI_FUNC int luaO_str2d (const char *s, lua_Number *result);
+LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
+                                                       va_list argp);
+LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);
+LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len);
+
+
+#endif
+
diff --git a/libraries/LuaJIT-1.1.7/src/lopcodes.c b/libraries/LuaJIT-1.1.7/src/lopcodes.c
new file mode 100644
index 0000000..4cc7452
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lopcodes.c
@@ -0,0 +1,102 @@
+/*
+** $Id: lopcodes.c,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $
+** See Copyright Notice in lua.h
+*/
+
+
+#define lopcodes_c
+#define LUA_CORE
+
+
+#include "lopcodes.h"
+
+
+/* ORDER OP */
+
+const char *const luaP_opnames[NUM_OPCODES+1] = {
+  "MOVE",
+  "LOADK",
+  "LOADBOOL",
+  "LOADNIL",
+  "GETUPVAL",
+  "GETGLOBAL",
+  "GETTABLE",
+  "SETGLOBAL",
+  "SETUPVAL",
+  "SETTABLE",
+  "NEWTABLE",
+  "SELF",
+  "ADD",
+  "SUB",
+  "MUL",
+  "DIV",
+  "MOD",
+  "POW",
+  "UNM",
+  "NOT",
+  "LEN",
+  "CONCAT",
+  "JMP",
+  "EQ",
+  "LT",
+  "LE",
+  "TEST",
+  "TESTSET",
+  "CALL",
+  "TAILCALL",
+  "RETURN",
+  "FORLOOP",
+  "FORPREP",
+  "TFORLOOP",
+  "SETLIST",
+  "CLOSE",
+  "CLOSURE",
+  "VARARG",
+  NULL
+};
+
+
+#define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
+
+const lu_byte luaP_opmodes[NUM_OPCODES] = {
+/*       T  A    B       C     mode                opcode       */
+  opmode(0, 1, OpArgR, OpArgN, iABC)            /* OP_MOVE */
+ ,opmode(0, 1, OpArgK, OpArgN, iABx)            /* OP_LOADK */
+ ,opmode(0, 1, OpArgU, OpArgU, iABC)            /* OP_LOADBOOL */
+ ,opmode(0, 1, OpArgR, OpArgN, iABC)            /* OP_LOADNIL */
+ ,opmode(0, 1, OpArgU, OpArgN, iABC)            /* OP_GETUPVAL */
+ ,opmode(0, 1, OpArgK, OpArgN, iABx)            /* OP_GETGLOBAL */
+ ,opmode(0, 1, OpArgR, OpArgK, iABC)            /* OP_GETTABLE */
+ ,opmode(0, 0, OpArgK, OpArgN, iABx)            /* OP_SETGLOBAL */
+ ,opmode(0, 0, OpArgU, OpArgN, iABC)            /* OP_SETUPVAL */
+ ,opmode(0, 0, OpArgK, OpArgK, iABC)            /* OP_SETTABLE */
+ ,opmode(0, 1, OpArgU, OpArgU, iABC)            /* OP_NEWTABLE */
+ ,opmode(0, 1, OpArgR, OpArgK, iABC)            /* OP_SELF */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)            /* OP_ADD */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)            /* OP_SUB */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)            /* OP_MUL */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)            /* OP_DIV */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)            /* OP_MOD */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)            /* OP_POW */
+ ,opmode(0, 1, OpArgR, OpArgN, iABC)            /* OP_UNM */
+ ,opmode(0, 1, OpArgR, OpArgN, iABC)            /* OP_NOT */
+ ,opmode(0, 1, OpArgR, OpArgN, iABC)            /* OP_LEN */
+ ,opmode(0, 1, OpArgR, OpArgR, iABC)            /* OP_CONCAT */
+ ,opmode(0, 0, OpArgR, OpArgN, iAsBx)           /* OP_JMP */
+ ,opmode(1, 0, OpArgK, OpArgK, iABC)            /* OP_EQ */
+ ,opmode(1, 0, OpArgK, OpArgK, iABC)            /* OP_LT */
+ ,opmode(1, 0, OpArgK, OpArgK, iABC)            /* OP_LE */
+ ,opmode(1, 1, OpArgR, OpArgU, iABC)            /* OP_TEST */
+ ,opmode(1, 1, OpArgR, OpArgU, iABC)            /* OP_TESTSET */
+ ,opmode(0, 1, OpArgU, OpArgU, iABC)            /* OP_CALL */
+ ,opmode(0, 1, OpArgU, OpArgU, iABC)            /* OP_TAILCALL */
+ ,opmode(0, 0, OpArgU, OpArgN, iABC)            /* OP_RETURN */
+ ,opmode(0, 1, OpArgR, OpArgN, iAsBx)           /* OP_FORLOOP */
+ ,opmode(0, 1, OpArgR, OpArgN, iAsBx)           /* OP_FORPREP */
+ ,opmode(1, 0, OpArgN, OpArgU, iABC)            /* OP_TFORLOOP */
+ ,opmode(0, 0, OpArgU, OpArgU, iABC)            /* OP_SETLIST */
+ ,opmode(0, 0, OpArgN, OpArgN, iABC)            /* OP_CLOSE */
+ ,opmode(0, 1, OpArgU, OpArgN, iABx)            /* OP_CLOSURE */
+ ,opmode(0, 1, OpArgU, OpArgN, iABC)            /* OP_VARARG */
+};
+
diff --git a/libraries/LuaJIT-1.1.7/src/lopcodes.h b/libraries/LuaJIT-1.1.7/src/lopcodes.h
new file mode 100644
index 0000000..41224d6
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lopcodes.h
@@ -0,0 +1,268 @@
+/*
+** $Id: lopcodes.h,v 1.125.1.1 2007/12/27 13:02:25 roberto Exp $
+** Opcodes for Lua virtual machine
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lopcodes_h
+#define lopcodes_h
+
+#include "llimits.h"
+
+
+/*===========================================================================
+  We assume that instructions are unsigned numbers.
+  All instructions have an opcode in the first 6 bits.
+  Instructions can have the following fields:
+        `A' : 8 bits
+        `B' : 9 bits
+        `C' : 9 bits
+        `Bx' : 18 bits (`B' and `C' together)
+        `sBx' : signed Bx
+
+  A signed argument is represented in excess K; that is, the number
+  value is the unsigned value minus K. K is exactly the maximum value
+  for that argument (so that -max is represented by 0, and +max is
+  represented by 2*max), which is half the maximum for the corresponding
+  unsigned argument.
+===========================================================================*/
+
+
+enum OpMode {iABC, iABx, iAsBx};  /* basic instruction format */
+
+
+/*
+** size and position of opcode arguments.
+*/
+#define SIZE_C          9
+#define SIZE_B          9
+#define SIZE_Bx         (SIZE_C + SIZE_B)
+#define SIZE_A          8
+
+#define SIZE_OP         6
+
+#define POS_OP          0
+#define POS_A           (POS_OP + SIZE_OP)
+#define POS_C           (POS_A + SIZE_A)
+#define POS_B           (POS_C + SIZE_C)
+#define POS_Bx          POS_C
+
+
+/*
+** limits for opcode arguments.
+** we use (signed) int to manipulate most arguments,
+** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
+*/
+#if SIZE_Bx < LUAI_BITSINT-1
+#define MAXARG_Bx        ((1<<SIZE_Bx)-1)
+#define MAXARG_sBx        (MAXARG_Bx>>1)         /* `sBx' is signed */
+#else
+#define MAXARG_Bx        MAX_INT
+#define MAXARG_sBx        MAX_INT
+#endif
+
+
+#define MAXARG_A        ((1<<SIZE_A)-1)
+#define MAXARG_B        ((1<<SIZE_B)-1)
+#define MAXARG_C        ((1<<SIZE_C)-1)
+
+
+/* creates a mask with `n' 1 bits at position `p' */
+#define MASK1(n,p)      ((~((~(Instruction)0)<<n))<<p)
+
+/* creates a mask with `n' 0 bits at position `p' */
+#define MASK0(n,p)      (~MASK1(n,p))
+
+/*
+** the following macros help to manipulate instructions
+*/
+
+#define GET_OPCODE(i)   (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
+#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
+                ((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
+
+#define GETARG_A(i)     (cast(int, ((i)>>POS_A) & MASK1(SIZE_A,0)))
+#define SETARG_A(i,u)   ((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
+                ((cast(Instruction, u)<<POS_A)&MASK1(SIZE_A,POS_A))))
+
+#define GETARG_B(i)     (cast(int, ((i)>>POS_B) & MASK1(SIZE_B,0)))
+#define SETARG_B(i,b)   ((i) = (((i)&MASK0(SIZE_B,POS_B)) | \
+                ((cast(Instruction, b)<<POS_B)&MASK1(SIZE_B,POS_B))))
+
+#define GETARG_C(i)     (cast(int, ((i)>>POS_C) & MASK1(SIZE_C,0)))
+#define SETARG_C(i,b)   ((i) = (((i)&MASK0(SIZE_C,POS_C)) | \
+                ((cast(Instruction, b)<<POS_C)&MASK1(SIZE_C,POS_C))))
+
+#define GETARG_Bx(i)    (cast(int, ((i)>>POS_Bx) & MASK1(SIZE_Bx,0)))
+#define SETARG_Bx(i,b)  ((i) = (((i)&MASK0(SIZE_Bx,POS_Bx)) | \
+                ((cast(Instruction, b)<<POS_Bx)&MASK1(SIZE_Bx,POS_Bx))))
+
+#define GETARG_sBx(i)   (GETARG_Bx(i)-MAXARG_sBx)
+#define SETARG_sBx(i,b) SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))
+
+
+#define CREATE_ABC(o,a,b,c)     ((cast(Instruction, o)<<POS_OP) \
+                        | (cast(Instruction, a)<<POS_A) \
+                        | (cast(Instruction, b)<<POS_B) \
+                        | (cast(Instruction, c)<<POS_C))
+
+#define CREATE_ABx(o,a,bc)      ((cast(Instruction, o)<<POS_OP) \
+                        | (cast(Instruction, a)<<POS_A) \
+                        | (cast(Instruction, bc)<<POS_Bx))
+
+
+/*
+** Macros to operate RK indices
+*/
+
+/* this bit 1 means constant (0 means register) */
+#define BITRK           (1 << (SIZE_B - 1))
+
+/* test whether value is a constant */
+#define ISK(x)          ((x) & BITRK)
+
+/* gets the index of the constant */
+#define INDEXK(r)       ((int)(r) & ~BITRK)
+
+#define MAXINDEXRK      (BITRK - 1)
+
+/* code a constant index as a RK value */
+#define RKASK(x)        ((x) | BITRK)
+
+
+/*
+** invalid register that fits in 8 bits
+*/
+#define NO_REG          MAXARG_A
+
+
+/*
+** R(x) - register
+** Kst(x) - constant (in constant table)
+** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
+*/
+
+
+/*
+** grep "ORDER OP" if you change these enums
+*/
+
+typedef enum {
+/*----------------------------------------------------------------------
+name            args    description
+------------------------------------------------------------------------*/
+OP_MOVE,/*      A B     R(A) := R(B)                                    */
+OP_LOADK,/*     A Bx    R(A) := Kst(Bx)                                 */
+OP_LOADBOOL,/*  A B C   R(A) := (Bool)B; if (C) pc++                    */
+OP_LOADNIL,/*   A B     R(A) := ... := R(B) := nil                      */
+OP_GETUPVAL,/*  A B     R(A) := UpValue[B]                              */
+
+OP_GETGLOBAL,/* A Bx    R(A) := Gbl[Kst(Bx)]                            */
+OP_GETTABLE,/*  A B C   R(A) := R(B)[RK(C)]                             */
+
+OP_SETGLOBAL,/* A Bx    Gbl[Kst(Bx)] := R(A)                            */
+OP_SETUPVAL,/*  A B     UpValue[B] := R(A)                              */
+OP_SETTABLE,/*  A B C   R(A)[RK(B)] := RK(C)                            */
+
+OP_NEWTABLE,/*  A B C   R(A) := {} (size = B,C)                         */
+
+OP_SELF,/*      A B C   R(A+1) := R(B); R(A) := R(B)[RK(C)]             */
+
+OP_ADD,/*       A B C   R(A) := RK(B) + RK(C)                           */
+OP_SUB,/*       A B C   R(A) := RK(B) - RK(C)                           */
+OP_MUL,/*       A B C   R(A) := RK(B) * RK(C)                           */
+OP_DIV,/*       A B C   R(A) := RK(B) / RK(C)                           */
+OP_MOD,/*       A B C   R(A) := RK(B) % RK(C)                           */
+OP_POW,/*       A B C   R(A) := RK(B) ^ RK(C)                           */
+OP_UNM,/*       A B     R(A) := -R(B)                                   */
+OP_NOT,/*       A B     R(A) := not R(B)                                */
+OP_LEN,/*       A B     R(A) := length of R(B)                          */
+
+OP_CONCAT,/*    A B C   R(A) := R(B).. ... ..R(C)                       */
+
+OP_JMP,/*       sBx     pc+=sBx                                 */
+
+OP_EQ,/*        A B C   if ((RK(B) == RK(C)) ~= A) then pc++            */
+OP_LT,/*        A B C   if ((RK(B) <  RK(C)) ~= A) then pc++            */
+OP_LE,/*        A B C   if ((RK(B) <= RK(C)) ~= A) then pc++            */
+
+OP_TEST,/*      A C     if not (R(A) <=> C) then pc++                   */ 
+OP_TESTSET,/*   A B C   if (R(B) <=> C) then R(A) := R(B) else pc++     */ 
+
+OP_CALL,/*      A B C   R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
+OP_TAILCALL,/*  A B C   return R(A)(R(A+1), ... ,R(A+B-1))              */
+OP_RETURN,/*    A B     return R(A), ... ,R(A+B-2)      (see note)      */
+
+OP_FORLOOP,/*   A sBx   R(A)+=R(A+2);
+                        if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
+OP_FORPREP,/*   A sBx   R(A)-=R(A+2); pc+=sBx                           */
+
+OP_TFORLOOP,/*  A C     R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2)); 
+                        if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++   */ 
+OP_SETLIST,/*   A B C   R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B        */
+
+OP_CLOSE,/*     A       close all variables in the stack up to (>=) R(A)*/
+OP_CLOSURE,/*   A Bx    R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))  */
+
+OP_VARARG/*     A B     R(A), R(A+1), ..., R(A+B-1) = vararg            */
+} OpCode;
+
+
+#define NUM_OPCODES     (cast(int, OP_VARARG) + 1)
+
+
+
+/*===========================================================================
+  Notes:
+  (*) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1,
+      and can be 0: OP_CALL then sets `top' to last_result+1, so
+      next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use `top'.
+
+  (*) In OP_VARARG, if (B == 0) then use actual number of varargs and
+      set top (like in OP_CALL with C == 0).
+
+  (*) In OP_RETURN, if (B == 0) then return up to `top'
+
+  (*) In OP_SETLIST, if (B == 0) then B = `top';
+      if (C == 0) then next `instruction' is real C
+
+  (*) For comparisons, A specifies what condition the test should accept
+      (true or false).
+
+  (*) All `skips' (pc++) assume that next instruction is a jump
+===========================================================================*/
+
+
+/*
+** masks for instruction properties. The format is:
+** bits 0-1: op mode
+** bits 2-3: C arg mode
+** bits 4-5: B arg mode
+** bit 6: instruction set register A
+** bit 7: operator is a test
+*/  
+
+enum OpArgMask {
+  OpArgN,  /* argument is not used */
+  OpArgU,  /* argument is used */
+  OpArgR,  /* argument is a register or a jump offset */
+  OpArgK   /* argument is a constant or register/constant */
+};
+
+LUAI_DATA const lu_byte luaP_opmodes[NUM_OPCODES];
+
+#define getOpMode(m)    (cast(enum OpMode, luaP_opmodes[m] & 3))
+#define getBMode(m)     (cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))
+#define getCMode(m)     (cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))
+#define testAMode(m)    (luaP_opmodes[m] & (1 << 6))
+#define testTMode(m)    (luaP_opmodes[m] & (1 << 7))
+
+
+LUAI_DATA const char *const luaP_opnames[NUM_OPCODES+1];  /* opcode names */
+
+
+/* number of list items to accumulate before a SETLIST instruction */
+#define LFIELDS_PER_FLUSH       50
+
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/loslib.c b/libraries/LuaJIT-1.1.7/src/loslib.c
new file mode 100644
index 0000000..01a02a2
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/loslib.c
@@ -0,0 +1,244 @@
+/*
+** $Id: loslib.c,v 1.19.1.3 2008/01/18 16:38:18 roberto Exp $
+** Standard Operating System library
+** See Copyright Notice in lua.h
+*/
+
+
+#include <errno.h>
+#include <locale.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#define loslib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+
+
+static int os_pushresult (lua_State *L, int i, const char *filename) {
+  int en = errno;  /* calls to Lua API may change this value */
+  if (i) {
+    lua_pushboolean(L, 1);
+    return 1;
+  }
+  else {
+    lua_pushnil(L);
+    lua_pushfstring(L, "%s: %s", filename, strerror(en));
+    lua_pushinteger(L, en);
+    return 3;
+  }
+}
+
+
+static int os_execute (lua_State *L) {
+  lua_pushinteger(L, system(luaL_optstring(L, 1, NULL)));
+  return 1;
+}
+
+
+static int os_remove (lua_State *L) {
+  const char *filename = luaL_checkstring(L, 1);
+  return os_pushresult(L, remove(filename) == 0, filename);
+}
+
+
+static int os_rename (lua_State *L) {
+  const char *fromname = luaL_checkstring(L, 1);
+  const char *toname = luaL_checkstring(L, 2);
+  return os_pushresult(L, rename(fromname, toname) == 0, fromname);
+}
+
+
+static int os_tmpname (lua_State *L) {
+  char buff[LUA_TMPNAMBUFSIZE];
+  int err;
+  lua_tmpnam(buff, err);
+  if (err)
+    return luaL_error(L, "unable to generate a unique filename");
+  lua_pushstring(L, buff);
+  return 1;
+}
+
+
+static int os_getenv (lua_State *L) {
+  lua_pushstring(L, getenv(luaL_checkstring(L, 1)));  /* if NULL push nil */
+  return 1;
+}
+
+
+static int os_clock (lua_State *L) {
+  lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC);
+  return 1;
+}
+
+
+/*
+** {======================================================
+** Time/Date operations
+** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S,
+**   wday=%w+1, yday=%j, isdst=? }
+** =======================================================
+*/
+
+static void setfield (lua_State *L, const char *key, int value) {
+  lua_pushinteger(L, value);
+  lua_setfield(L, -2, key);
+}
+
+static void setboolfield (lua_State *L, const char *key, int value) {
+  if (value < 0)  /* undefined? */
+    return;  /* does not set field */
+  lua_pushboolean(L, value);
+  lua_setfield(L, -2, key);
+}
+
+static int getboolfield (lua_State *L, const char *key) {
+  int res;
+  lua_getfield(L, -1, key);
+  res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1);
+  lua_pop(L, 1);
+  return res;
+}
+
+
+static int getfield (lua_State *L, const char *key, int d) {
+  int res;
+  lua_getfield(L, -1, key);
+  if (lua_isnumber(L, -1))
+    res = (int)lua_tointeger(L, -1);
+  else {
+    if (d < 0)
+      return luaL_error(L, "field " LUA_QS " missing in date table", key);
+    res = d;
+  }
+  lua_pop(L, 1);
+  return res;
+}
+
+
+static int os_date (lua_State *L) {
+  const char *s = luaL_optstring(L, 1, "%c");
+  time_t t = luaL_opt(L, (time_t)luaL_checknumber, 2, time(NULL));
+  struct tm *stm;
+  if (*s == '!') {  /* UTC? */
+    stm = gmtime(&t);
+    s++;  /* skip `!' */
+  }
+  else
+    stm = localtime(&t);
+  if (stm == NULL)  /* invalid date? */
+    lua_pushnil(L);
+  else if (strcmp(s, "*t") == 0) {
+    lua_createtable(L, 0, 9);  /* 9 = number of fields */
+    setfield(L, "sec", stm->tm_sec);
+    setfield(L, "min", stm->tm_min);
+    setfield(L, "hour", stm->tm_hour);
+    setfield(L, "day", stm->tm_mday);
+    setfield(L, "month", stm->tm_mon+1);
+    setfield(L, "year", stm->tm_year+1900);
+    setfield(L, "wday", stm->tm_wday+1);
+    setfield(L, "yday", stm->tm_yday+1);
+    setboolfield(L, "isdst", stm->tm_isdst);
+  }
+  else {
+    char cc[3];
+    luaL_Buffer b;
+    cc[0] = '%'; cc[2] = '\0';
+    luaL_buffinit(L, &b);
+    for (; *s; s++) {
+      if (*s != '%' || *(s + 1) == '\0')  /* no conversion specifier? */
+        luaL_addchar(&b, *s);
+      else {
+        size_t reslen;
+        char buff[200];  /* should be big enough for any conversion result */
+        cc[1] = *(++s);
+        reslen = strftime(buff, sizeof(buff), cc, stm);
+        luaL_addlstring(&b, buff, reslen);
+      }
+    }
+    luaL_pushresult(&b);
+  }
+  return 1;
+}
+
+
+static int os_time (lua_State *L) {
+  time_t t;
+  if (lua_isnoneornil(L, 1))  /* called without args? */
+    t = time(NULL);  /* get current time */
+  else {
+    struct tm ts;
+    luaL_checktype(L, 1, LUA_TTABLE);
+    lua_settop(L, 1);  /* make sure table is at the top */
+    ts.tm_sec = getfield(L, "sec", 0);
+    ts.tm_min = getfield(L, "min", 0);
+    ts.tm_hour = getfield(L, "hour", 12);
+    ts.tm_mday = getfield(L, "day", -1);
+    ts.tm_mon = getfield(L, "month", -1) - 1;
+    ts.tm_year = getfield(L, "year", -1) - 1900;
+    ts.tm_isdst = getboolfield(L, "isdst");
+    t = mktime(&ts);
+  }
+  if (t == (time_t)(-1))
+    lua_pushnil(L);
+  else
+    lua_pushnumber(L, (lua_Number)t);
+  return 1;
+}
+
+
+static int os_difftime (lua_State *L) {
+  lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)),
+                             (time_t)(luaL_optnumber(L, 2, 0))));
+  return 1;
+}
+
+/* }====================================================== */
+
+
+static int os_setlocale (lua_State *L) {
+  static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
+                      LC_NUMERIC, LC_TIME};
+  static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
+     "numeric", "time", NULL};
+  const char *l = luaL_optstring(L, 1, NULL);
+  int op = luaL_checkoption(L, 2, "all", catnames);
+  lua_pushstring(L, setlocale(cat[op], l));
+  return 1;
+}
+
+
+static int os_exit (lua_State *L) {
+  exit(luaL_optint(L, 1, EXIT_SUCCESS));
+  return 0;  /* to avoid warnings */
+}
+
+static const luaL_Reg syslib[] = {
+  {"clock",     os_clock},
+  {"date",      os_date},
+  {"difftime",  os_difftime},
+  {"execute",   os_execute},
+  {"exit",      os_exit},
+  {"getenv",    os_getenv},
+  {"remove",    os_remove},
+  {"rename",    os_rename},
+  {"setlocale", os_setlocale},
+  {"time",      os_time},
+  {"tmpname",   os_tmpname},
+  {NULL, NULL}
+};
+
+/* }====================================================== */
+
+
+
+LUALIB_API int luaopen_os (lua_State *L) {
+  luaL_register(L, LUA_OSLIBNAME, syslib);
+  return 1;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lparser.c b/libraries/LuaJIT-1.1.7/src/lparser.c
new file mode 100644
index 0000000..1e2a9a8
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lparser.c
@@ -0,0 +1,1339 @@
+/*
+** $Id: lparser.c,v 2.42.1.3 2007/12/28 15:32:23 roberto Exp $
+** Lua Parser
+** See Copyright Notice in lua.h
+*/
+
+
+#include <string.h>
+
+#define lparser_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lcode.h"
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "llex.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lparser.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+
+
+
+#define hasmultret(k)           ((k) == VCALL || (k) == VVARARG)
+
+#define getlocvar(fs, i)        ((fs)->f->locvars[(fs)->actvar[i]])
+
+#define luaY_checklimit(fs,v,l,m)       if ((v)>(l)) errorlimit(fs,l,m)
+
+
+/*
+** nodes for block list (list of active blocks)
+*/
+typedef struct BlockCnt {
+  struct BlockCnt *previous;  /* chain */
+  int breaklist;  /* list of jumps out of this loop */
+  lu_byte nactvar;  /* # active locals outside the breakable structure */
+  lu_byte upval;  /* true if some variable in the block is an upvalue */
+  lu_byte isbreakable;  /* true if `block' is a loop */
+} BlockCnt;
+
+
+
+/*
+** prototypes for recursive non-terminal functions
+*/
+static void chunk (LexState *ls);
+static void expr (LexState *ls, expdesc *v);
+
+
+static void anchor_token (LexState *ls) {
+  if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) {
+    TString *ts = ls->t.seminfo.ts;
+    luaX_newstring(ls, getstr(ts), ts->tsv.len);
+  }
+}
+
+
+static void error_expected (LexState *ls, int token) {
+  luaX_syntaxerror(ls,
+      luaO_pushfstring(ls->L, LUA_QS " expected", luaX_token2str(ls, token)));
+}
+
+
+static void errorlimit (FuncState *fs, int limit, const char *what) {
+  const char *msg = (fs->f->linedefined == 0) ?
+    luaO_pushfstring(fs->L, "main function has more than %d %s", limit, what) :
+    luaO_pushfstring(fs->L, "function at line %d has more than %d %s",
+                            fs->f->linedefined, limit, what);
+  luaX_lexerror(fs->ls, msg, 0);
+}
+
+
+static int testnext (LexState *ls, int c) {
+  if (ls->t.token == c) {
+    luaX_next(ls);
+    return 1;
+  }
+  else return 0;
+}
+
+
+static void check (LexState *ls, int c) {
+  if (ls->t.token != c)
+    error_expected(ls, c);
+}
+
+static void checknext (LexState *ls, int c) {
+  check(ls, c);
+  luaX_next(ls);
+}
+
+
+#define check_condition(ls,c,msg)       { if (!(c)) luaX_syntaxerror(ls, msg); }
+
+
+
+static void check_match (LexState *ls, int what, int who, int where) {
+  if (!testnext(ls, what)) {
+    if (where == ls->linenumber)
+      error_expected(ls, what);
+    else {
+      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
+             LUA_QS " expected (to close " LUA_QS " at line %d)",
+              luaX_token2str(ls, what), luaX_token2str(ls, who), where));
+    }
+  }
+}
+
+
+static TString *str_checkname (LexState *ls) {
+  TString *ts;
+  check(ls, TK_NAME);
+  ts = ls->t.seminfo.ts;
+  luaX_next(ls);
+  return ts;
+}
+
+
+static void init_exp (expdesc *e, expkind k, int i) {
+  e->f = e->t = NO_JUMP;
+  e->k = k;
+  e->u.s.info = i;
+}
+
+
+static void codestring (LexState *ls, expdesc *e, TString *s) {
+  init_exp(e, VK, luaK_stringK(ls->fs, s));
+}
+
+
+static void checkname(LexState *ls, expdesc *e) {
+  codestring(ls, e, str_checkname(ls));
+}
+
+
+static int registerlocalvar (LexState *ls, TString *varname) {
+  FuncState *fs = ls->fs;
+  Proto *f = fs->f;
+  int oldsize = f->sizelocvars;
+  luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,
+                  LocVar, SHRT_MAX, "too many local variables");
+  while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL;
+  f->locvars[fs->nlocvars].varname = varname;
+  luaC_objbarrier(ls->L, f, varname);
+  return fs->nlocvars++;
+}
+
+
+#define new_localvarliteral(ls,v,n) \
+  new_localvar(ls, luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char))-1), n)
+
+
+static void new_localvar (LexState *ls, TString *name, int n) {
+  FuncState *fs = ls->fs;
+  luaY_checklimit(fs, fs->nactvar+n+1, LUAI_MAXVARS, "local variables");
+  fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name));
+}
+
+
+static void adjustlocalvars (LexState *ls, int nvars) {
+  FuncState *fs = ls->fs;
+  fs->nactvar = cast_byte(fs->nactvar + nvars);
+  for (; nvars; nvars--) {
+    getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;
+  }
+}
+
+
+static void removevars (LexState *ls, int tolevel) {
+  FuncState *fs = ls->fs;
+  while (fs->nactvar > tolevel)
+    getlocvar(fs, --fs->nactvar).endpc = fs->pc;
+}
+
+
+static int indexupvalue (FuncState *fs, TString *name, expdesc *v) {
+  int i;
+  Proto *f = fs->f;
+  int oldsize = f->sizeupvalues;
+  for (i=0; i<f->nups; i++) {
+    if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->u.s.info) {
+      lua_assert(f->upvalues[i] == name);
+      return i;
+    }
+  }
+  /* new one */
+  luaY_checklimit(fs, f->nups + 1, LUAI_MAXUPVALUES, "upvalues");
+  luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues,
+                  TString *, MAX_INT, "");
+  while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL;
+  f->upvalues[f->nups] = name;
+  luaC_objbarrier(fs->L, f, name);
+  lua_assert(v->k == VLOCAL || v->k == VUPVAL);
+  fs->upvalues[f->nups].k = cast_byte(v->k);
+  fs->upvalues[f->nups].info = cast_byte(v->u.s.info);
+  return f->nups++;
+}
+
+
+static int searchvar (FuncState *fs, TString *n) {
+  int i;
+  for (i=fs->nactvar-1; i >= 0; i--) {
+    if (n == getlocvar(fs, i).varname)
+      return i;
+  }
+  return -1;  /* not found */
+}
+
+
+static void markupval (FuncState *fs, int level) {
+  BlockCnt *bl = fs->bl;
+  while (bl && bl->nactvar > level) bl = bl->previous;
+  if (bl) bl->upval = 1;
+}
+
+
+static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
+  if (fs == NULL) {  /* no more levels? */
+    init_exp(var, VGLOBAL, NO_REG);  /* default is global variable */
+    return VGLOBAL;
+  }
+  else {
+    int v = searchvar(fs, n);  /* look up at current level */
+    if (v >= 0) {
+      init_exp(var, VLOCAL, v);
+      if (!base)
+        markupval(fs, v);  /* local will be used as an upval */
+      return VLOCAL;
+    }
+    else {  /* not found at current level; try upper one */
+      if (singlevaraux(fs->prev, n, var, 0) == VGLOBAL)
+        return VGLOBAL;
+      var->u.s.info = indexupvalue(fs, n, var);  /* else was LOCAL or UPVAL */
+      var->k = VUPVAL;  /* upvalue in this level */
+      return VUPVAL;
+    }
+  }
+}
+
+
+static void singlevar (LexState *ls, expdesc *var) {
+  TString *varname = str_checkname(ls);
+  FuncState *fs = ls->fs;
+  if (singlevaraux(fs, varname, var, 1) == VGLOBAL)
+    var->u.s.info = luaK_stringK(fs, varname);  /* info points to global name */
+}
+
+
+static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
+  FuncState *fs = ls->fs;
+  int extra = nvars - nexps;
+  if (hasmultret(e->k)) {
+    extra++;  /* includes call itself */
+    if (extra < 0) extra = 0;
+    luaK_setreturns(fs, e, extra);  /* last exp. provides the difference */
+    if (extra > 1) luaK_reserveregs(fs, extra-1);
+  }
+  else {
+    if (e->k != VVOID) luaK_exp2nextreg(fs, e);  /* close last expression */
+    if (extra > 0) {
+      int reg = fs->freereg;
+      luaK_reserveregs(fs, extra);
+      luaK_nil(fs, reg, extra);
+    }
+  }
+}
+
+
+static void enterlevel (LexState *ls) {
+  if (++ls->L->nCcalls > LUAI_MAXCCALLS)
+        luaX_lexerror(ls, "chunk has too many syntax levels", 0);
+}
+
+
+#define leavelevel(ls)  ((ls)->L->nCcalls--)
+
+
+static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isbreakable) {
+  bl->breaklist = NO_JUMP;
+  bl->isbreakable = isbreakable;
+  bl->nactvar = fs->nactvar;
+  bl->upval = 0;
+  bl->previous = fs->bl;
+  fs->bl = bl;
+  lua_assert(fs->freereg == fs->nactvar);
+}
+
+
+static void leaveblock (FuncState *fs) {
+  BlockCnt *bl = fs->bl;
+  fs->bl = bl->previous;
+  removevars(fs->ls, bl->nactvar);
+  if (bl->upval)
+    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
+  /* a block either controls scope or breaks (never both) */
+  lua_assert(!bl->isbreakable || !bl->upval);
+  lua_assert(bl->nactvar == fs->nactvar);
+  fs->freereg = fs->nactvar;  /* free registers */
+  luaK_patchtohere(fs, bl->breaklist);
+}
+
+
+static void pushclosure (LexState *ls, FuncState *func, expdesc *v) {
+  FuncState *fs = ls->fs;
+  Proto *f = fs->f;
+  int oldsize = f->sizep;
+  int i;
+  luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *,
+                  MAXARG_Bx, "constant table overflow");
+  while (oldsize < f->sizep) f->p[oldsize++] = NULL;
+  f->p[fs->np++] = func->f;
+  luaC_objbarrier(ls->L, f, func->f);
+  init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));
+  for (i=0; i<func->f->nups; i++) {
+    OpCode o = (func->upvalues[i].k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
+    luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0);
+  }
+}
+
+
+static void open_func (LexState *ls, FuncState *fs) {
+  lua_State *L = ls->L;
+  Proto *f = luaF_newproto(L);
+  fs->f = f;
+  fs->prev = ls->fs;  /* linked list of funcstates */
+  fs->ls = ls;
+  fs->L = L;
+  ls->fs = fs;
+  fs->pc = 0;
+  fs->lasttarget = -1;
+  fs->jpc = NO_JUMP;
+  fs->freereg = 0;
+  fs->nk = 0;
+  fs->np = 0;
+  fs->nlocvars = 0;
+  fs->nactvar = 0;
+  fs->bl = NULL;
+  f->source = ls->source;
+  f->maxstacksize = 2;  /* registers 0/1 are always valid */
+  fs->h = luaH_new(L, 0, 0);
+  /* anchor table of constants and prototype (to avoid being collected) */
+  sethvalue2s(L, L->top, fs->h);
+  incr_top(L);
+  setptvalue2s(L, L->top, f);
+  incr_top(L);
+}
+
+
+static void close_func (LexState *ls) {
+  lua_State *L = ls->L;
+  FuncState *fs = ls->fs;
+  Proto *f = fs->f;
+  removevars(ls, 0);
+  luaK_ret(fs, 0, 0);  /* final return */
+  luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
+  f->sizecode = fs->pc;
+  luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
+  f->sizelineinfo = fs->pc;
+  luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
+  f->sizek = fs->nk;
+  luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
+  f->sizep = fs->np;
+  luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
+  f->sizelocvars = fs->nlocvars;
+  luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *);
+  f->sizeupvalues = f->nups;
+  lua_assert(luaG_checkcode(f));
+  lua_assert(fs->bl == NULL);
+  ls->fs = fs->prev;
+  L->top -= 2;  /* remove table and prototype from the stack */
+  /* last token read was anchored in defunct function; must reanchor it */
+  if (fs) anchor_token(ls);
+}
+
+
+Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
+  struct LexState lexstate;
+  struct FuncState funcstate;
+  lexstate.buff = buff;
+  luaX_setinput(L, &lexstate, z, luaS_new(L, name));
+  open_func(&lexstate, &funcstate);
+  funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
+  luaX_next(&lexstate);  /* read first token */
+  chunk(&lexstate);
+  check(&lexstate, TK_EOS);
+  close_func(&lexstate);
+  lua_assert(funcstate.prev == NULL);
+  lua_assert(funcstate.f->nups == 0);
+  lua_assert(lexstate.fs == NULL);
+  return funcstate.f;
+}
+
+
+
+/*============================================================*/
+/* GRAMMAR RULES */
+/*============================================================*/
+
+
+static void field (LexState *ls, expdesc *v) {
+  /* field -> ['.' | ':'] NAME */
+  FuncState *fs = ls->fs;
+  expdesc key;
+  luaK_exp2anyreg(fs, v);
+  luaX_next(ls);  /* skip the dot or colon */
+  checkname(ls, &key);
+  luaK_indexed(fs, v, &key);
+}
+
+
+static void yindex (LexState *ls, expdesc *v) {
+  /* index -> '[' expr ']' */
+  luaX_next(ls);  /* skip the '[' */
+  expr(ls, v);
+  luaK_exp2val(ls->fs, v);
+  checknext(ls, ']');
+}
+
+
+/*
+** {======================================================================
+** Rules for Constructors
+** =======================================================================
+*/
+
+
+struct ConsControl {
+  expdesc v;  /* last list item read */
+  expdesc *t;  /* table descriptor */
+  int nh;  /* total number of `record' elements */
+  int na;  /* total number of array elements */
+  int tostore;  /* number of array elements pending to be stored */
+};
+
+
+static void recfield (LexState *ls, struct ConsControl *cc) {
+  /* recfield -> (NAME | `['exp1`]') = exp1 */
+  FuncState *fs = ls->fs;
+  int reg = ls->fs->freereg;
+  expdesc key, val;
+  int rkkey;
+  if (ls->t.token == TK_NAME) {
+    luaY_checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
+    checkname(ls, &key);
+  }
+  else  /* ls->t.token == '[' */
+    yindex(ls, &key);
+  cc->nh++;
+  checknext(ls, '=');
+  rkkey = luaK_exp2RK(fs, &key);
+  expr(ls, &val);
+  luaK_codeABC(fs, OP_SETTABLE, cc->t->u.s.info, rkkey, luaK_exp2RK(fs, &val));
+  fs->freereg = reg;  /* free registers */
+}
+
+
+static void closelistfield (FuncState *fs, struct ConsControl *cc) {
+  if (cc->v.k == VVOID) return;  /* there is no list item */
+  luaK_exp2nextreg(fs, &cc->v);
+  cc->v.k = VVOID;
+  if (cc->tostore == LFIELDS_PER_FLUSH) {
+    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);  /* flush */
+    cc->tostore = 0;  /* no more items pending */
+  }
+}
+
+
+static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
+  if (cc->tostore == 0) return;
+  if (hasmultret(cc->v.k)) {
+    luaK_setmultret(fs, &cc->v);
+    luaK_setlist(fs, cc->t->u.s.info, cc->na, LUA_MULTRET);
+    cc->na--;  /* do not count last expression (unknown number of elements) */
+  }
+  else {
+    if (cc->v.k != VVOID)
+      luaK_exp2nextreg(fs, &cc->v);
+    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);
+  }
+}
+
+
+static void listfield (LexState *ls, struct ConsControl *cc) {
+  expr(ls, &cc->v);
+  luaY_checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
+  cc->na++;
+  cc->tostore++;
+}
+
+
+static void constructor (LexState *ls, expdesc *t) {
+  /* constructor -> ?? */
+  FuncState *fs = ls->fs;
+  int line = ls->linenumber;
+  int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);
+  struct ConsControl cc;
+  cc.na = cc.nh = cc.tostore = 0;
+  cc.t = t;
+  init_exp(t, VRELOCABLE, pc);
+  init_exp(&cc.v, VVOID, 0);  /* no value (yet) */
+  luaK_exp2nextreg(ls->fs, t);  /* fix it at stack top (for gc) */
+  checknext(ls, '{');
+  do {
+    lua_assert(cc.v.k == VVOID || cc.tostore > 0);
+    if (ls->t.token == '}') break;
+    closelistfield(fs, &cc);
+    switch(ls->t.token) {
+      case TK_NAME: {  /* may be listfields or recfields */
+        luaX_lookahead(ls);
+        if (ls->lookahead.token != '=')  /* expression? */
+          listfield(ls, &cc);
+        else
+          recfield(ls, &cc);
+        break;
+      }
+      case '[': {  /* constructor_item -> recfield */
+        recfield(ls, &cc);
+        break;
+      }
+      default: {  /* constructor_part -> listfield */
+        listfield(ls, &cc);
+        break;
+      }
+    }
+  } while (testnext(ls, ',') || testnext(ls, ';'));
+  check_match(ls, '}', '{', line);
+  lastlistfield(fs, &cc);
+  SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */
+  SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh));  /* set initial table size */
+}
+
+/* }====================================================================== */
+
+
+
+static void parlist (LexState *ls) {
+  /* parlist -> [ param { `,' param } ] */
+  FuncState *fs = ls->fs;
+  Proto *f = fs->f;
+  int nparams = 0;
+  f->is_vararg = 0;
+  if (ls->t.token != ')') {  /* is `parlist' not empty? */
+    do {
+      switch (ls->t.token) {
+        case TK_NAME: {  /* param -> NAME */
+          new_localvar(ls, str_checkname(ls), nparams++);
+          break;
+        }
+        case TK_DOTS: {  /* param -> `...' */
+          luaX_next(ls);
+#if defined(LUA_COMPAT_VARARG)
+          /* use `arg' as default name */
+          new_localvarliteral(ls, "arg", nparams++);
+          f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;
+#endif
+          f->is_vararg |= VARARG_ISVARARG;
+          break;
+        }
+        default: luaX_syntaxerror(ls, "<name> or " LUA_QL("...") " expected");
+      }
+    } while (!f->is_vararg && testnext(ls, ','));
+  }
+  adjustlocalvars(ls, nparams);
+  f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));
+  luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */
+}
+
+
+static void body (LexState *ls, expdesc *e, int needself, int line) {
+  /* body ->  `(' parlist `)' chunk END */
+  FuncState new_fs;
+  open_func(ls, &new_fs);
+  new_fs.f->linedefined = line;
+  checknext(ls, '(');
+  if (needself) {
+    new_localvarliteral(ls, "self", 0);
+    adjustlocalvars(ls, 1);
+  }
+  parlist(ls);
+  checknext(ls, ')');
+  chunk(ls);
+  new_fs.f->lastlinedefined = ls->linenumber;
+  check_match(ls, TK_END, TK_FUNCTION, line);
+  close_func(ls);
+  pushclosure(ls, &new_fs, e);
+}
+
+
+static int explist1 (LexState *ls, expdesc *v) {
+  /* explist1 -> expr { `,' expr } */
+  int n = 1;  /* at least one expression */
+  expr(ls, v);
+  while (testnext(ls, ',')) {
+    luaK_exp2nextreg(ls->fs, v);
+    expr(ls, v);
+    n++;
+  }
+  return n;
+}
+
+
+static void funcargs (LexState *ls, expdesc *f) {
+  FuncState *fs = ls->fs;
+  expdesc args;
+  int base, nparams;
+  int line = ls->linenumber;
+  switch (ls->t.token) {
+    case '(': {  /* funcargs -> `(' [ explist1 ] `)' */
+      if (line != ls->lastline)
+        luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
+      luaX_next(ls);
+      if (ls->t.token == ')')  /* arg list is empty? */
+        args.k = VVOID;
+      else {
+        explist1(ls, &args);
+        luaK_setmultret(fs, &args);
+      }
+      check_match(ls, ')', '(', line);
+      break;
+    }
+    case '{': {  /* funcargs -> constructor */
+      constructor(ls, &args);
+      break;
+    }
+    case TK_STRING: {  /* funcargs -> STRING */
+      codestring(ls, &args, ls->t.seminfo.ts);
+      luaX_next(ls);  /* must use `seminfo' before `next' */
+      break;
+    }
+    default: {
+      luaX_syntaxerror(ls, "function arguments expected");
+      return;
+    }
+  }
+  lua_assert(f->k == VNONRELOC);
+  base = f->u.s.info;  /* base register for call */
+  if (hasmultret(args.k))
+    nparams = LUA_MULTRET;  /* open call */
+  else {
+    if (args.k != VVOID)
+      luaK_exp2nextreg(fs, &args);  /* close last argument */
+    nparams = fs->freereg - (base+1);
+  }
+  init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
+  luaK_fixline(fs, line);
+  fs->freereg = base+1;  /* call remove function and arguments and leaves
+                            (unless changed) one result */
+}
+
+
+
+
+/*
+** {======================================================================
+** Expression parsing
+** =======================================================================
+*/
+
+
+static void prefixexp (LexState *ls, expdesc *v) {
+  /* prefixexp -> NAME | '(' expr ')' */
+  switch (ls->t.token) {
+    case '(': {
+      int line = ls->linenumber;
+      luaX_next(ls);
+      expr(ls, v);
+      check_match(ls, ')', '(', line);
+      luaK_dischargevars(ls->fs, v);
+      return;
+    }
+    case TK_NAME: {
+      singlevar(ls, v);
+      return;
+    }
+    default: {
+      luaX_syntaxerror(ls, "unexpected symbol");
+      return;
+    }
+  }
+}
+
+
+static void primaryexp (LexState *ls, expdesc *v) {
+  /* primaryexp ->
+        prefixexp { `.' NAME | `[' exp `]' | `:' NAME funcargs | funcargs } */
+  FuncState *fs = ls->fs;
+  prefixexp(ls, v);
+  for (;;) {
+    switch (ls->t.token) {
+      case '.': {  /* field */
+        field(ls, v);
+        break;
+      }
+      case '[': {  /* `[' exp1 `]' */
+        expdesc key;
+        luaK_exp2anyreg(fs, v);
+        yindex(ls, &key);
+        luaK_indexed(fs, v, &key);
+        break;
+      }
+      case ':': {  /* `:' NAME funcargs */
+        expdesc key;
+        luaX_next(ls);
+        checkname(ls, &key);
+        luaK_self(fs, v, &key);
+        funcargs(ls, v);
+        break;
+      }
+      case '(': case TK_STRING: case '{': {  /* funcargs */
+        luaK_exp2nextreg(fs, v);
+        funcargs(ls, v);
+        break;
+      }
+      default: return;
+    }
+  }
+}
+
+
+static void simpleexp (LexState *ls, expdesc *v) {
+  /* simpleexp -> NUMBER | STRING | NIL | true | false | ... |
+                  constructor | FUNCTION body | primaryexp */
+  switch (ls->t.token) {
+    case TK_NUMBER: {
+      init_exp(v, VKNUM, 0);
+      v->u.nval = ls->t.seminfo.r;
+      break;
+    }
+    case TK_STRING: {
+      codestring(ls, v, ls->t.seminfo.ts);
+      break;
+    }
+    case TK_NIL: {
+      init_exp(v, VNIL, 0);
+      break;
+    }
+    case TK_TRUE: {
+      init_exp(v, VTRUE, 0);
+      break;
+    }
+    case TK_FALSE: {
+      init_exp(v, VFALSE, 0);
+      break;
+    }
+    case TK_DOTS: {  /* vararg */
+      FuncState *fs = ls->fs;
+      check_condition(ls, fs->f->is_vararg,
+                      "cannot use " LUA_QL("...") " outside a vararg function");
+      fs->f->is_vararg &= ~VARARG_NEEDSARG;  /* don't need 'arg' */
+      init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));
+      break;
+    }
+    case '{': {  /* constructor */
+      constructor(ls, v);
+      return;
+    }
+    case TK_FUNCTION: {
+      luaX_next(ls);
+      body(ls, v, 0, ls->linenumber);
+      return;
+    }
+    default: {
+      primaryexp(ls, v);
+      return;
+    }
+  }
+  luaX_next(ls);
+}
+
+
+static UnOpr getunopr (int op) {
+  switch (op) {
+    case TK_NOT: return OPR_NOT;
+    case '-': return OPR_MINUS;
+    case '#': return OPR_LEN;
+    default: return OPR_NOUNOPR;
+  }
+}
+
+
+static BinOpr getbinopr (int op) {
+  switch (op) {
+    case '+': return OPR_ADD;
+    case '-': return OPR_SUB;
+    case '*': return OPR_MUL;
+    case '/': return OPR_DIV;
+    case '%': return OPR_MOD;
+    case '^': return OPR_POW;
+    case TK_CONCAT: return OPR_CONCAT;
+    case TK_NE: return OPR_NE;
+    case TK_EQ: return OPR_EQ;
+    case '<': return OPR_LT;
+    case TK_LE: return OPR_LE;
+    case '>': return OPR_GT;
+    case TK_GE: return OPR_GE;
+    case TK_AND: return OPR_AND;
+    case TK_OR: return OPR_OR;
+    default: return OPR_NOBINOPR;
+  }
+}
+
+
+static const struct {
+  lu_byte left;  /* left priority for each binary operator */
+  lu_byte right; /* right priority */
+} priority[] = {  /* ORDER OPR */
+   {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7},  /* `+' `-' `/' `%' */
+   {10, 9}, {5, 4},                 /* power and concat (right associative) */
+   {3, 3}, {3, 3},                  /* equality and inequality */
+   {3, 3}, {3, 3}, {3, 3}, {3, 3},  /* order */
+   {2, 2}, {1, 1}                   /* logical (and/or) */
+};
+
+#define UNARY_PRIORITY  8  /* priority for unary operators */
+
+
+/*
+** subexpr -> (simpleexp | unop subexpr) { binop subexpr }
+** where `binop' is any binary operator with a priority higher than `limit'
+*/
+static BinOpr subexpr (LexState *ls, expdesc *v, unsigned int limit) {
+  BinOpr op;
+  UnOpr uop;
+  enterlevel(ls);
+  uop = getunopr(ls->t.token);
+  if (uop != OPR_NOUNOPR) {
+    luaX_next(ls);
+    subexpr(ls, v, UNARY_PRIORITY);
+    luaK_prefix(ls->fs, uop, v);
+  }
+  else simpleexp(ls, v);
+  /* expand while operators have priorities higher than `limit' */
+  op = getbinopr(ls->t.token);
+  while (op != OPR_NOBINOPR && priority[op].left > limit) {
+    expdesc v2;
+    BinOpr nextop;
+    luaX_next(ls);
+    luaK_infix(ls->fs, op, v);
+    /* read sub-expression with higher priority */
+    nextop = subexpr(ls, &v2, priority[op].right);
+    luaK_posfix(ls->fs, op, v, &v2);
+    op = nextop;
+  }
+  leavelevel(ls);
+  return op;  /* return first untreated operator */
+}
+
+
+static void expr (LexState *ls, expdesc *v) {
+  subexpr(ls, v, 0);
+}
+
+/* }==================================================================== */
+
+
+
+/*
+** {======================================================================
+** Rules for Statements
+** =======================================================================
+*/
+
+
+static int block_follow (int token) {
+  switch (token) {
+    case TK_ELSE: case TK_ELSEIF: case TK_END:
+    case TK_UNTIL: case TK_EOS:
+      return 1;
+    default: return 0;
+  }
+}
+
+
+static void block (LexState *ls) {
+  /* block -> chunk */
+  FuncState *fs = ls->fs;
+  BlockCnt bl;
+  enterblock(fs, &bl, 0);
+  chunk(ls);
+  lua_assert(bl.breaklist == NO_JUMP);
+  leaveblock(fs);
+}
+
+
+/*
+** structure to chain all variables in the left-hand side of an
+** assignment
+*/
+struct LHS_assign {
+  struct LHS_assign *prev;
+  expdesc v;  /* variable (global, local, upvalue, or indexed) */
+};
+
+
+/*
+** check whether, in an assignment to a local variable, the local variable
+** is needed in a previous assignment (to a table). If so, save original
+** local value in a safe place and use this safe copy in the previous
+** assignment.
+*/
+static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
+  FuncState *fs = ls->fs;
+  int extra = fs->freereg;  /* eventual position to save local variable */
+  int conflict = 0;
+  for (; lh; lh = lh->prev) {
+    if (lh->v.k == VINDEXED) {
+      if (lh->v.u.s.info == v->u.s.info) {  /* conflict? */
+        conflict = 1;
+        lh->v.u.s.info = extra;  /* previous assignment will use safe copy */
+      }
+      if (lh->v.u.s.aux == v->u.s.info) {  /* conflict? */
+        conflict = 1;
+        lh->v.u.s.aux = extra;  /* previous assignment will use safe copy */
+      }
+    }
+  }
+  if (conflict) {
+    luaK_codeABC(fs, OP_MOVE, fs->freereg, v->u.s.info, 0);  /* make copy */
+    luaK_reserveregs(fs, 1);
+  }
+}
+
+
+static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
+  expdesc e;
+  check_condition(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED,
+                      "syntax error");
+  if (testnext(ls, ',')) {  /* assignment -> `,' primaryexp assignment */
+    struct LHS_assign nv;
+    nv.prev = lh;
+    primaryexp(ls, &nv.v);
+    if (nv.v.k == VLOCAL)
+      check_conflict(ls, lh, &nv.v);
+    luaY_checklimit(ls->fs, nvars, LUAI_MAXCCALLS - ls->L->nCcalls,
+                    "variables in assignment");
+    assignment(ls, &nv, nvars+1);
+  }
+  else {  /* assignment -> `=' explist1 */
+    int nexps;
+    checknext(ls, '=');
+    nexps = explist1(ls, &e);
+    if (nexps != nvars) {
+      adjust_assign(ls, nvars, nexps, &e);
+      if (nexps > nvars)
+        ls->fs->freereg -= nexps - nvars;  /* remove extra values */
+    }
+    else {
+      luaK_setoneret(ls->fs, &e);  /* close last expression */
+      luaK_storevar(ls->fs, &lh->v, &e);
+      return;  /* avoid default */
+    }
+  }
+  init_exp(&e, VNONRELOC, ls->fs->freereg-1);  /* default assignment */
+  luaK_storevar(ls->fs, &lh->v, &e);
+}
+
+
+static int cond (LexState *ls) {
+  /* cond -> exp */
+  expdesc v;
+  expr(ls, &v);  /* read condition */
+  if (v.k == VNIL) v.k = VFALSE;  /* `falses' are all equal here */
+  luaK_goiftrue(ls->fs, &v);
+  return v.f;
+}
+
+
+static void breakstat (LexState *ls) {
+  FuncState *fs = ls->fs;
+  BlockCnt *bl = fs->bl;
+  int upval = 0;
+  while (bl && !bl->isbreakable) {
+    upval |= bl->upval;
+    bl = bl->previous;
+  }
+  if (!bl)
+    luaX_syntaxerror(ls, "no loop to break");
+  if (upval)
+    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
+  luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
+}
+
+
+static void whilestat (LexState *ls, int line) {
+  /* whilestat -> WHILE cond DO block END */
+  FuncState *fs = ls->fs;
+  int whileinit;
+  int condexit;
+  BlockCnt bl;
+  luaX_next(ls);  /* skip WHILE */
+  whileinit = luaK_getlabel(fs);
+  condexit = cond(ls);
+  enterblock(fs, &bl, 1);
+  checknext(ls, TK_DO);
+  block(ls);
+  luaK_patchlist(fs, luaK_jump(fs), whileinit);
+  check_match(ls, TK_END, TK_WHILE, line);
+  leaveblock(fs);
+  luaK_patchtohere(fs, condexit);  /* false conditions finish the loop */
+}
+
+
+static void repeatstat (LexState *ls, int line) {
+  /* repeatstat -> REPEAT block UNTIL cond */
+  int condexit;
+  FuncState *fs = ls->fs;
+  int repeat_init = luaK_getlabel(fs);
+  BlockCnt bl1, bl2;
+  enterblock(fs, &bl1, 1);  /* loop block */
+  enterblock(fs, &bl2, 0);  /* scope block */
+  luaX_next(ls);  /* skip REPEAT */
+  chunk(ls);
+  check_match(ls, TK_UNTIL, TK_REPEAT, line);
+  condexit = cond(ls);  /* read condition (inside scope block) */
+  if (!bl2.upval) {  /* no upvalues? */
+    leaveblock(fs);  /* finish scope */
+    luaK_patchlist(ls->fs, condexit, repeat_init);  /* close the loop */
+  }
+  else {  /* complete semantics when there are upvalues */
+    breakstat(ls);  /* if condition then break */
+    luaK_patchtohere(ls->fs, condexit);  /* else... */
+    leaveblock(fs);  /* finish scope... */
+    luaK_patchlist(ls->fs, luaK_jump(fs), repeat_init);  /* and repeat */
+  }
+  leaveblock(fs);  /* finish loop */
+}
+
+
+static int exp1 (LexState *ls) {
+  expdesc e;
+  int k;
+  expr(ls, &e);
+  k = e.k;
+  luaK_exp2nextreg(ls->fs, &e);
+  return k;
+}
+
+
+static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
+  /* forbody -> DO block */
+  BlockCnt bl;
+  FuncState *fs = ls->fs;
+  int prep, endfor;
+  adjustlocalvars(ls, 3);  /* control variables */
+  checknext(ls, TK_DO);
+  prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
+  enterblock(fs, &bl, 0);  /* scope for declared variables */
+  adjustlocalvars(ls, nvars);
+  luaK_reserveregs(fs, nvars);
+  block(ls);
+  leaveblock(fs);  /* end of scope for declared variables */
+  luaK_patchtohere(fs, prep);
+  endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) :
+                     luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars);
+  luaK_fixline(fs, line);  /* pretend that `OP_FOR' starts the loop */
+  luaK_patchlist(fs, (isnum ? endfor : luaK_jump(fs)), prep + 1);
+}
+
+
+static void fornum (LexState *ls, TString *varname, int line) {
+  /* fornum -> NAME = exp1,exp1[,exp1] forbody */
+  FuncState *fs = ls->fs;
+  int base = fs->freereg;
+  new_localvarliteral(ls, "(for index)", 0);
+  new_localvarliteral(ls, "(for limit)", 1);
+  new_localvarliteral(ls, "(for step)", 2);
+  new_localvar(ls, varname, 3);
+  checknext(ls, '=');
+  exp1(ls);  /* initial value */
+  checknext(ls, ',');
+  exp1(ls);  /* limit */
+  if (testnext(ls, ','))
+    exp1(ls);  /* optional step */
+  else {  /* default step = 1 */
+    luaK_codeABx(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1));
+    luaK_reserveregs(fs, 1);
+  }
+  forbody(ls, base, line, 1, 1);
+}
+
+
+static void forlist (LexState *ls, TString *indexname) {
+  /* forlist -> NAME {,NAME} IN explist1 forbody */
+  FuncState *fs = ls->fs;
+  expdesc e;
+  int nvars = 0;
+  int line;
+  int base = fs->freereg;
+  /* create control variables */
+  new_localvarliteral(ls, "(for generator)", nvars++);
+  new_localvarliteral(ls, "(for state)", nvars++);
+  new_localvarliteral(ls, "(for control)", nvars++);
+  /* create declared variables */
+  new_localvar(ls, indexname, nvars++);
+  while (testnext(ls, ','))
+    new_localvar(ls, str_checkname(ls), nvars++);
+  checknext(ls, TK_IN);
+  line = ls->linenumber;
+  adjust_assign(ls, 3, explist1(ls, &e), &e);
+  luaK_checkstack(fs, 3);  /* extra space to call generator */
+  forbody(ls, base, line, nvars - 3, 0);
+}
+
+
+static void forstat (LexState *ls, int line) {
+  /* forstat -> FOR (fornum | forlist) END */
+  FuncState *fs = ls->fs;
+  TString *varname;
+  BlockCnt bl;
+  enterblock(fs, &bl, 1);  /* scope for loop and control variables */
+  luaX_next(ls);  /* skip `for' */
+  varname = str_checkname(ls);  /* first variable name */
+  switch (ls->t.token) {
+    case '=': fornum(ls, varname, line); break;
+    case ',': case TK_IN: forlist(ls, varname); break;
+    default: luaX_syntaxerror(ls, LUA_QL("=") " or " LUA_QL("in") " expected");
+  }
+  check_match(ls, TK_END, TK_FOR, line);
+  leaveblock(fs);  /* loop scope (`break' jumps to this point) */
+}
+
+
+static int test_then_block (LexState *ls) {
+  /* test_then_block -> [IF | ELSEIF] cond THEN block */
+  int condexit;
+  luaX_next(ls);  /* skip IF or ELSEIF */
+  condexit = cond(ls);
+  checknext(ls, TK_THEN);
+  block(ls);  /* `then' part */
+  return condexit;
+}
+
+
+static void ifstat (LexState *ls, int line) {
+  /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
+  FuncState *fs = ls->fs;
+  int flist;
+  int escapelist = NO_JUMP;
+  flist = test_then_block(ls);  /* IF cond THEN block */
+  while (ls->t.token == TK_ELSEIF) {
+    luaK_concat(fs, &escapelist, luaK_jump(fs));
+    luaK_patchtohere(fs, flist);
+    flist = test_then_block(ls);  /* ELSEIF cond THEN block */
+  }
+  if (ls->t.token == TK_ELSE) {
+    luaK_concat(fs, &escapelist, luaK_jump(fs));
+    luaK_patchtohere(fs, flist);
+    luaX_next(ls);  /* skip ELSE (after patch, for correct line info) */
+    block(ls);  /* `else' part */
+  }
+  else
+    luaK_concat(fs, &escapelist, flist);
+  luaK_patchtohere(fs, escapelist);
+  check_match(ls, TK_END, TK_IF, line);
+}
+
+
+static void localfunc (LexState *ls) {
+  expdesc v, b;
+  FuncState *fs = ls->fs;
+  new_localvar(ls, str_checkname(ls), 0);
+  init_exp(&v, VLOCAL, fs->freereg);
+  luaK_reserveregs(fs, 1);
+  adjustlocalvars(ls, 1);
+  body(ls, &b, 0, ls->linenumber);
+  luaK_storevar(fs, &v, &b);
+  /* debug information will only see the variable after this point! */
+  getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;
+}
+
+
+static void localstat (LexState *ls) {
+  /* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */
+  int nvars = 0;
+  int nexps;
+  expdesc e;
+  do {
+    new_localvar(ls, str_checkname(ls), nvars++);
+  } while (testnext(ls, ','));
+  if (testnext(ls, '='))
+    nexps = explist1(ls, &e);
+  else {
+    e.k = VVOID;
+    nexps = 0;
+  }
+  adjust_assign(ls, nvars, nexps, &e);
+  adjustlocalvars(ls, nvars);
+}
+
+
+static int funcname (LexState *ls, expdesc *v) {
+  /* funcname -> NAME {field} [`:' NAME] */
+  int needself = 0;
+  singlevar(ls, v);
+  while (ls->t.token == '.')
+    field(ls, v);
+  if (ls->t.token == ':') {
+    needself = 1;
+    field(ls, v);
+  }
+  return needself;
+}
+
+
+static void funcstat (LexState *ls, int line) {
+  /* funcstat -> FUNCTION funcname body */
+  int needself;
+  expdesc v, b;
+  luaX_next(ls);  /* skip FUNCTION */
+  needself = funcname(ls, &v);
+  body(ls, &b, needself, line);
+  luaK_storevar(ls->fs, &v, &b);
+  luaK_fixline(ls->fs, line);  /* definition `happens' in the first line */
+}
+
+
+static void exprstat (LexState *ls) {
+  /* stat -> func | assignment */
+  FuncState *fs = ls->fs;
+  struct LHS_assign v;
+  primaryexp(ls, &v.v);
+  if (v.v.k == VCALL)  /* stat -> func */
+    SETARG_C(getcode(fs, &v.v), 1);  /* call statement uses no results */
+  else {  /* stat -> assignment */
+    v.prev = NULL;
+    assignment(ls, &v, 1);
+  }
+}
+
+
+static void retstat (LexState *ls) {
+  /* stat -> RETURN explist */
+  FuncState *fs = ls->fs;
+  expdesc e;
+  int first, nret;  /* registers with returned values */
+  luaX_next(ls);  /* skip RETURN */
+  if (block_follow(ls->t.token) || ls->t.token == ';')
+    first = nret = 0;  /* return no values */
+  else {
+    nret = explist1(ls, &e);  /* optional return values */
+    if (hasmultret(e.k)) {
+      luaK_setmultret(fs, &e);
+      if (e.k == VCALL && nret == 1) {  /* tail call? */
+        SET_OPCODE(getcode(fs,&e), OP_TAILCALL);
+        lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar);
+      }
+      first = fs->nactvar;
+      nret = LUA_MULTRET;  /* return all values */
+    }
+    else {
+      if (nret == 1)  /* only one single value? */
+        first = luaK_exp2anyreg(fs, &e);
+      else {
+        luaK_exp2nextreg(fs, &e);  /* values must go to the `stack' */
+        first = fs->nactvar;  /* return all `active' values */
+        lua_assert(nret == fs->freereg - first);
+      }
+    }
+  }
+  luaK_ret(fs, first, nret);
+}
+
+
+static int statement (LexState *ls) {
+  int line = ls->linenumber;  /* may be needed for error messages */
+  switch (ls->t.token) {
+    case TK_IF: {  /* stat -> ifstat */
+      ifstat(ls, line);
+      return 0;
+    }
+    case TK_WHILE: {  /* stat -> whilestat */
+      whilestat(ls, line);
+      return 0;
+    }
+    case TK_DO: {  /* stat -> DO block END */
+      luaX_next(ls);  /* skip DO */
+      block(ls);
+      check_match(ls, TK_END, TK_DO, line);
+      return 0;
+    }
+    case TK_FOR: {  /* stat -> forstat */
+      forstat(ls, line);
+      return 0;
+    }
+    case TK_REPEAT: {  /* stat -> repeatstat */
+      repeatstat(ls, line);
+      return 0;
+    }
+    case TK_FUNCTION: {
+      funcstat(ls, line);  /* stat -> funcstat */
+      return 0;
+    }
+    case TK_LOCAL: {  /* stat -> localstat */
+      luaX_next(ls);  /* skip LOCAL */
+      if (testnext(ls, TK_FUNCTION))  /* local function? */
+        localfunc(ls);
+      else
+        localstat(ls);
+      return 0;
+    }
+    case TK_RETURN: {  /* stat -> retstat */
+      retstat(ls);
+      return 1;  /* must be last statement */
+    }
+    case TK_BREAK: {  /* stat -> breakstat */
+      luaX_next(ls);  /* skip BREAK */
+      breakstat(ls);
+      return 1;  /* must be last statement */
+    }
+    default: {
+      exprstat(ls);
+      return 0;  /* to avoid warnings */
+    }
+  }
+}
+
+
+static void chunk (LexState *ls) {
+  /* chunk -> { stat [`;'] } */
+  int islast = 0;
+  enterlevel(ls);
+  while (!islast && !block_follow(ls->t.token)) {
+    islast = statement(ls);
+    testnext(ls, ';');
+    lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
+               ls->fs->freereg >= ls->fs->nactvar);
+    ls->fs->freereg = ls->fs->nactvar;  /* free registers */
+  }
+  leavelevel(ls);
+}
+
+/* }====================================================================== */
diff --git a/libraries/LuaJIT-1.1.7/src/lparser.h b/libraries/LuaJIT-1.1.7/src/lparser.h
new file mode 100644
index 0000000..18836af
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lparser.h
@@ -0,0 +1,82 @@
+/*
+** $Id: lparser.h,v 1.57.1.1 2007/12/27 13:02:25 roberto Exp $
+** Lua Parser
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lparser_h
+#define lparser_h
+
+#include "llimits.h"
+#include "lobject.h"
+#include "lzio.h"
+
+
+/*
+** Expression descriptor
+*/
+
+typedef enum {
+  VVOID,        /* no value */
+  VNIL,
+  VTRUE,
+  VFALSE,
+  VK,           /* info = index of constant in `k' */
+  VKNUM,        /* nval = numerical value */
+  VLOCAL,       /* info = local register */
+  VUPVAL,       /* info = index of upvalue in `upvalues' */
+  VGLOBAL,      /* info = index of table; aux = index of global name in `k' */
+  VINDEXED,     /* info = table register; aux = index register (or `k') */
+  VJMP,         /* info = instruction pc */
+  VRELOCABLE,   /* info = instruction pc */
+  VNONRELOC,    /* info = result register */
+  VCALL,        /* info = instruction pc */
+  VVARARG       /* info = instruction pc */
+} expkind;
+
+typedef struct expdesc {
+  expkind k;
+  union {
+    struct { int info, aux; } s;
+    lua_Number nval;
+  } u;
+  int t;  /* patch list of `exit when true' */
+  int f;  /* patch list of `exit when false' */
+} expdesc;
+
+
+typedef struct upvaldesc {
+  lu_byte k;
+  lu_byte info;
+} upvaldesc;
+
+
+struct BlockCnt;  /* defined in lparser.c */
+
+
+/* state needed to generate code for a given function */
+typedef struct FuncState {
+  Proto *f;  /* current function header */
+  Table *h;  /* table to find (and reuse) elements in `k' */
+  struct FuncState *prev;  /* enclosing function */
+  struct LexState *ls;  /* lexical state */
+  struct lua_State *L;  /* copy of the Lua state */
+  struct BlockCnt *bl;  /* chain of current blocks */
+  int pc;  /* next position to code (equivalent to `ncode') */
+  int lasttarget;   /* `pc' of last `jump target' */
+  int jpc;  /* list of pending jumps to `pc' */
+  int freereg;  /* first free register */
+  int nk;  /* number of elements in `k' */
+  int np;  /* number of elements in `p' */
+  short nlocvars;  /* number of elements in `locvars' */
+  lu_byte nactvar;  /* number of active local variables */
+  upvaldesc upvalues[LUAI_MAXUPVALUES];  /* upvalues */
+  unsigned short actvar[LUAI_MAXVARS];  /* declared-variable stack */
+} FuncState;
+
+
+LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
+                                            const char *name);
+
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lstate.c b/libraries/LuaJIT-1.1.7/src/lstate.c
new file mode 100644
index 0000000..2bf835b
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lstate.c
@@ -0,0 +1,218 @@
+/*
+** $Id: lstate.c,v 2.36.1.2 2008/01/03 15:20:39 roberto Exp $
+** Global State
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stddef.h>
+
+#define lstate_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lgc.h"
+#include "llex.h"
+#include "lmem.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "ltm.h"
+#include "ljit.h"
+
+
+#define state_size(x)   (sizeof(x) + LUAI_EXTRASPACE)
+#define fromstate(l)    (cast(lu_byte *, (l)) - LUAI_EXTRASPACE)
+#define tostate(l)   (cast(lua_State *, cast(lu_byte *, l) + LUAI_EXTRASPACE))
+
+
+/*
+** Main thread combines a thread state and the global state
+*/
+typedef struct LG {
+  lua_State l;
+  global_State g;
+} LG;
+  
+
+
+static void stack_init (lua_State *L1, lua_State *L) {
+  /* initialize CallInfo array */
+  L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);
+  L1->ci = L1->base_ci;
+  L1->size_ci = BASIC_CI_SIZE;
+  L1->end_ci = L1->base_ci + L1->size_ci - 1;
+  /* initialize stack array */
+  L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue);
+  L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK;
+  L1->top = L1->stack;
+  L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;
+  /* initialize first ci */
+  L1->ci->func = L1->top;
+  setnilvalue(L1->top++);  /* `function' entry for this `ci' */
+  L1->base = L1->ci->base = L1->top;
+  L1->ci->top = L1->top + LUA_MINSTACK;
+}
+
+
+static void freestack (lua_State *L, lua_State *L1) {
+  luaM_freearray(L, L1->base_ci, L1->size_ci, CallInfo);
+  luaM_freearray(L, L1->stack, L1->stacksize, TValue);
+}
+
+
+/*
+** open parts that may cause memory-allocation errors
+*/
+static void f_luaopen (lua_State *L, void *ud) {
+  global_State *g = G(L);
+  UNUSED(ud);
+  stack_init(L, L);  /* init stack */
+  sethvalue(L, gt(L), luaH_new(L, 0, 2));  /* table of globals */
+  sethvalue(L, registry(L), luaH_new(L, 0, 2));  /* registry */
+  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
+  luaT_init(L);
+  luaX_init(L);
+  luaS_fix(luaS_newliteral(L, MEMERRMSG));
+  g->GCthreshold = 4*g->totalbytes;
+  luaJIT_initstate(L);
+}
+
+
+static void preinit_state (lua_State *L, global_State *g) {
+  G(L) = g;
+  L->stack = NULL;
+  L->stacksize = 0;
+  L->errorJmp = NULL;
+  L->hook = NULL;
+  L->hookmask = 0;
+  L->basehookcount = 0;
+  L->allowhook = 1;
+  resethookcount(L);
+  L->openupval = NULL;
+  L->size_ci = 0;
+  L->nCcalls = 0;
+  L->status = 0;
+  L->base_ci = L->ci = NULL;
+  L->savedpc = NULL;
+  L->errfunc = 0;
+  setnilvalue(gt(L));
+}
+
+
+static void close_state (lua_State *L) {
+  global_State *g = G(L);
+  luaF_close(L, L->stack);  /* close all upvalues for this thread */
+  luaC_freeall(L);  /* collect all objects */
+  luaJIT_freestate(L);
+  lua_assert(g->rootgc == obj2gco(L));
+  lua_assert(g->strt.nuse == 0);
+  luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);
+  luaZ_freebuffer(L, &g->buff);
+  freestack(L, L);
+  lua_assert(g->totalbytes == sizeof(LG));
+  (*g->frealloc)(g->ud, fromstate(L), state_size(LG), 0);
+}
+
+
+lua_State *luaE_newthread (lua_State *L) {
+  lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State)));
+  luaC_link(L, obj2gco(L1), LUA_TTHREAD);
+  preinit_state(L1, G(L));
+  stack_init(L1, L);  /* init stack */
+  setobj2n(L, gt(L1), gt(L));  /* share table of globals */
+  L1->hookmask = L->hookmask;
+  L1->basehookcount = L->basehookcount;
+  L1->hook = L->hook;
+  resethookcount(L1);
+  lua_assert(iswhite(obj2gco(L1)));
+  return L1;
+}
+
+
+void luaE_freethread (lua_State *L, lua_State *L1) {
+  luaF_close(L1, L1->stack);  /* close all upvalues for this thread */
+  lua_assert(L1->openupval == NULL);
+  luai_userstatefree(L1);
+  freestack(L, L1);
+  luaM_freemem(L, fromstate(L1), state_size(lua_State));
+}
+
+
+LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
+  int i;
+  lua_State *L;
+  global_State *g;
+  void *l = (*f)(ud, NULL, 0, state_size(LG));
+  if (l == NULL) return NULL;
+  L = tostate(l);
+  g = &((LG *)L)->g;
+  L->next = NULL;
+  L->tt = LUA_TTHREAD;
+  g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
+  L->marked = luaC_white(g);
+  set2bits(L->marked, FIXEDBIT, SFIXEDBIT);
+  preinit_state(L, g);
+  g->frealloc = f;
+  g->ud = ud;
+  g->mainthread = L;
+  g->uvhead.u.l.prev = &g->uvhead;
+  g->uvhead.u.l.next = &g->uvhead;
+  g->GCthreshold = 0;  /* mark it as unfinished state */
+  g->strt.size = 0;
+  g->strt.nuse = 0;
+  g->strt.hash = NULL;
+  setnilvalue(registry(L));
+  luaZ_initbuffer(L, &g->buff);
+  g->panic = NULL;
+  g->gcstate = GCSpause;
+  g->rootgc = obj2gco(L);
+  g->sweepstrgc = 0;
+  g->sweepgc = &g->rootgc;
+  g->gray = NULL;
+  g->grayagain = NULL;
+  g->weak = NULL;
+  g->tmudata = NULL;
+  g->totalbytes = sizeof(LG);
+  g->gcpause = LUAI_GCPAUSE;
+  g->gcstepmul = LUAI_GCMUL;
+  g->gcdept = 0;
+  g->jit_state = NULL;
+  for (i=0; i<NUM_TAGS; i++) g->mt[i] = NULL;
+  if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {
+    /* memory allocation error: free partial state */
+    close_state(L);
+    L = NULL;
+  }
+  else
+    luai_userstateopen(L);
+  return L;
+}
+
+
+static void callallgcTM (lua_State *L, void *ud) {
+  UNUSED(ud);
+  luaC_callGCTM(L);  /* call GC metamethods for all udata */
+}
+
+
+LUA_API void lua_close (lua_State *L) {
+  L = G(L)->mainthread;  /* only the main thread can be closed */
+  lua_lock(L);
+  luaF_close(L, L->stack);  /* close all upvalues for this thread */
+  luaC_separateudata(L, 1);  /* separate udata that have GC metamethods */
+  L->errfunc = 0;  /* no error function during GC metamethods */
+  do {  /* repeat until no more errors */
+    L->ci = L->base_ci;
+    L->base = L->top = L->ci->base;
+    L->nCcalls = 0;
+  } while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0);
+  lua_assert(G(L)->tmudata == NULL);
+  luai_userstateclose(L);
+  close_state(L);
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lstate.h b/libraries/LuaJIT-1.1.7/src/lstate.h
new file mode 100644
index 0000000..ddaa554
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lstate.h
@@ -0,0 +1,179 @@
+/*
+** $Id: lstate.h,v 2.24.1.2 2008/01/03 15:20:39 roberto Exp $
+** Global State
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lstate_h
+#define lstate_h
+
+#include "lua.h"
+
+#include "lobject.h"
+#include "ltm.h"
+#include "lzio.h"
+#ifndef COCO_DISABLE
+#include "lcoco.h"
+#endif
+
+
+
+struct lua_longjmp;  /* defined in ldo.c */
+struct jit_State;  /* defined in ljit.c */
+typedef int (*luaJIT_GateLJ)(lua_State *L, StkId func, int nresults);
+
+
+/* table of globals */
+#define gt(L)   (&L->l_gt)
+
+/* registry */
+#define registry(L)     (&G(L)->l_registry)
+
+
+/* extra stack space to handle TM calls and some other extras */
+/* LuaJIT uses more than the default (5) to speed up calls (setnil loop) */
+#define EXTRA_STACK   8
+
+
+#define BASIC_CI_SIZE           8
+
+#define BASIC_STACK_SIZE        (2*LUA_MINSTACK)
+
+
+
+typedef struct stringtable {
+  GCObject **hash;
+  lu_int32 nuse;  /* number of elements */
+  int size;
+} stringtable;
+
+
+/*
+** informations about a call
+*/
+typedef struct CallInfo {
+  StkId base;  /* base for this function */
+  StkId func;  /* function index in the stack */
+  StkId top;  /* top for this function */
+  const Instruction *savedpc;
+  int nresults;  /* expected number of results from this function */
+  int tailcalls;  /* number of tail calls lost under this entry */
+} CallInfo;
+
+
+
+#define curr_func(L)    (clvalue(L->ci->func))
+#define ci_func(ci)     (clvalue((ci)->func))
+#define f_isLua(ci)     (!ci_func(ci)->c.isC)
+#define isLua(ci)       (ttisfunction((ci)->func) && f_isLua(ci))
+
+
+/*
+** `global state', shared by all threads of this state
+*/
+typedef struct global_State {
+  stringtable strt;  /* hash table for strings */
+  lua_Alloc frealloc;  /* function to reallocate memory */
+  void *ud;         /* auxiliary data to `frealloc' */
+  lu_byte currentwhite;
+  lu_byte gcstate;  /* state of garbage collector */
+  int sweepstrgc;  /* position of sweep in `strt' */
+  GCObject *rootgc;  /* list of all collectable objects */
+  GCObject **sweepgc;  /* position of sweep in `rootgc' */
+  GCObject *gray;  /* list of gray objects */
+  GCObject *grayagain;  /* list of objects to be traversed atomically */
+  GCObject *weak;  /* list of weak tables (to be cleared) */
+  GCObject *tmudata;  /* last element of list of userdata to be GC */
+  Mbuffer buff;  /* temporary buffer for string concatentation */
+  lu_mem GCthreshold;
+  lu_mem totalbytes;  /* number of bytes currently allocated */
+  lu_mem estimate;  /* an estimate of number of bytes actually in use */
+  lu_mem gcdept;  /* how much GC is `behind schedule' */
+  int gcpause;  /* size of pause between successive GCs */
+  int gcstepmul;  /* GC `granularity' */
+  lua_CFunction panic;  /* to be called in unprotected errors */
+  TValue l_registry;
+  struct lua_State *mainthread;
+  UpVal uvhead;  /* head of double-linked list of all open upvalues */
+  struct Table *mt[NUM_TAGS];  /* metatables for basic types */
+  TString *tmname[TM_N];  /* array with tag-method names */
+  /* LuaJIT extensions */
+  struct jit_State *jit_state;  /* JIT state */
+  luaJIT_GateLJ jit_gateLJ;  /* Lua -> JIT gate */
+  lua_CFunction jit_gateJL;  /* JIT -> Lua callgate */
+  lua_CFunction jit_gateJC;  /* JIT -> C callgate */
+} global_State;
+
+
+/*
+** `per thread' state
+*/
+struct lua_State {
+  CommonHeader;
+  lu_byte status;
+  StkId top;  /* first free slot in the stack */
+  StkId base;  /* base of current function */
+  global_State *l_G;
+  CallInfo *ci;  /* call info for current function */
+  const Instruction *savedpc;  /* `savedpc' of current function */
+  StkId stack_last;  /* last free slot in the stack */
+  StkId stack;  /* stack base */
+  CallInfo *end_ci;  /* points after end of ci array*/
+  CallInfo *base_ci;  /* array of CallInfo's */
+  int stacksize;
+  int size_ci;  /* size of array `base_ci' */
+  unsigned short nCcalls;  /* number of nested C calls */
+  lu_byte hookmask;
+  lu_byte allowhook;
+  int basehookcount;
+  int hookcount;
+  lua_Hook hook;
+  TValue l_gt;  /* table of globals */
+  TValue env;  /* temporary place for environments */
+  GCObject *openupval;  /* list of open upvalues in this stack */
+  GCObject *gclist;
+  struct lua_longjmp *errorJmp;  /* current error recover point */
+  ptrdiff_t errfunc;  /* current error handling function (stack index) */
+};
+
+
+#define G(L)    (L->l_G)
+
+
+/*
+** Union of all collectable objects
+*/
+union GCObject {
+  GCheader gch;
+  union TString ts;
+  union Udata u;
+  union Closure cl;
+  struct Table h;
+  struct Proto p;
+  struct UpVal uv;
+  struct lua_State th;  /* thread */
+};
+
+
+/* macros to convert a GCObject into a specific value */
+#define rawgco2ts(o)    check_exp((o)->gch.tt == LUA_TSTRING, &((o)->ts))
+#define gco2ts(o)       (&rawgco2ts(o)->tsv)
+#define rawgco2u(o)     check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u))
+#define gco2u(o)        (&rawgco2u(o)->uv)
+#define gco2cl(o)       check_exp((o)->gch.tt == LUA_TFUNCTION, &((o)->cl))
+#define gco2h(o)        check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h))
+#define gco2p(o)        check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p))
+#define gco2uv(o)       check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv))
+#define ngcotouv(o) \
+        check_exp((o) == NULL || (o)->gch.tt == LUA_TUPVAL, &((o)->uv))
+#define gco2th(o)       check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))
+
+/* macro to convert any Lua object into a GCObject */
+#define obj2gco(v)      (cast(GCObject *, (v)))
+
+
+LUAI_FUNC lua_State *luaE_newthread (lua_State *L);
+LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
+
+#endif
+
diff --git a/libraries/LuaJIT-1.1.7/src/lstring.c b/libraries/LuaJIT-1.1.7/src/lstring.c
new file mode 100644
index 0000000..4911315
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lstring.c
@@ -0,0 +1,111 @@
+/*
+** $Id: lstring.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
+** String table (keeps all strings handled by Lua)
+** See Copyright Notice in lua.h
+*/
+
+
+#include <string.h>
+
+#define lstring_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lmem.h"
+#include "lobject.h"
+#include "lstate.h"
+#include "lstring.h"
+
+
+
+void luaS_resize (lua_State *L, int newsize) {
+  GCObject **newhash;
+  stringtable *tb;
+  int i;
+  if (G(L)->gcstate == GCSsweepstring)
+    return;  /* cannot resize during GC traverse */
+  newhash = luaM_newvector(L, newsize, GCObject *);
+  tb = &G(L)->strt;
+  for (i=0; i<newsize; i++) newhash[i] = NULL;
+  /* rehash */
+  for (i=0; i<tb->size; i++) {
+    GCObject *p = tb->hash[i];
+    while (p) {  /* for each node in the list */
+      GCObject *next = p->gch.next;  /* save next */
+      unsigned int h = gco2ts(p)->hash;
+      int h1 = lmod(h, newsize);  /* new position */
+      lua_assert(cast_int(h%newsize) == lmod(h, newsize));
+      p->gch.next = newhash[h1];  /* chain it */
+      newhash[h1] = p;
+      p = next;
+    }
+  }
+  luaM_freearray(L, tb->hash, tb->size, TString *);
+  tb->size = newsize;
+  tb->hash = newhash;
+}
+
+
+static TString *newlstr (lua_State *L, const char *str, size_t l,
+                                       unsigned int h) {
+  TString *ts;
+  stringtable *tb;
+  if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
+    luaM_toobig(L);
+  ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
+  ts->tsv.len = l;
+  ts->tsv.hash = h;
+  ts->tsv.marked = luaC_white(G(L));
+  ts->tsv.tt = LUA_TSTRING;
+  ts->tsv.reserved = 0;
+  memcpy(ts+1, str, l*sizeof(char));
+  ((char *)(ts+1))[l] = '\0';  /* ending 0 */
+  tb = &G(L)->strt;
+  h = lmod(h, tb->size);
+  ts->tsv.next = tb->hash[h];  /* chain new entry */
+  tb->hash[h] = obj2gco(ts);
+  tb->nuse++;
+  if (tb->nuse > cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)
+    luaS_resize(L, tb->size*2);  /* too crowded */
+  return ts;
+}
+
+
+TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
+  GCObject *o;
+  unsigned int h = cast(unsigned int, l);  /* seed */
+  size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */
+  size_t l1;
+  for (l1=l; l1>=step; l1-=step)  /* compute hash */
+    h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
+  for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
+       o != NULL;
+       o = o->gch.next) {
+    TString *ts = rawgco2ts(o);
+    if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) {
+      /* string may be dead */
+      if (isdead(G(L), o)) changewhite(o);
+      return ts;
+    }
+  }
+  return newlstr(L, str, l, h);  /* not found */
+}
+
+
+Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
+  Udata *u;
+  if (s > MAX_SIZET - sizeof(Udata))
+    luaM_toobig(L);
+  u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata)));
+  u->uv.marked = luaC_white(G(L));  /* is not finalized */
+  u->uv.tt = LUA_TUSERDATA;
+  u->uv.len = s;
+  u->uv.metatable = NULL;
+  u->uv.env = e;
+  /* chain it on udata list (after main thread) */
+  u->uv.next = G(L)->mainthread->next;
+  G(L)->mainthread->next = obj2gco(u);
+  return u;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lstring.h b/libraries/LuaJIT-1.1.7/src/lstring.h
new file mode 100644
index 0000000..73a2ff8
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lstring.h
@@ -0,0 +1,31 @@
+/*
+** $Id: lstring.h,v 1.43.1.1 2007/12/27 13:02:25 roberto Exp $
+** String table (keep all strings handled by Lua)
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lstring_h
+#define lstring_h
+
+
+#include "lgc.h"
+#include "lobject.h"
+#include "lstate.h"
+
+
+#define sizestring(s)   (sizeof(union TString)+((s)->len+1)*sizeof(char))
+
+#define sizeudata(u)    (sizeof(union Udata)+(u)->len)
+
+#define luaS_new(L, s)  (luaS_newlstr(L, s, strlen(s)))
+#define luaS_newliteral(L, s)   (luaS_newlstr(L, "" s, \
+                                 (sizeof(s)/sizeof(char))-1))
+
+#define luaS_fix(s)     l_setbit((s)->tsv.marked, FIXEDBIT)
+
+LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
+LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e);
+LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
+
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lstrlib.c b/libraries/LuaJIT-1.1.7/src/lstrlib.c
new file mode 100644
index 0000000..fe452ce
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lstrlib.c
@@ -0,0 +1,871 @@
+/*
+** $Id: lstrlib.c,v 1.132.1.4 2008/07/11 17:27:21 roberto Exp $
+** Standard library for string operations and pattern-matching
+** See Copyright Notice in lua.h
+*/
+
+
+#include <ctype.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define lstrlib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+
+
+/* macro to `unsign' a character */
+#define uchar(c)        ((unsigned char)(c))
+
+
+
+static int str_len (lua_State *L) {
+  size_t l;
+  luaL_checklstring(L, 1, &l);
+  lua_pushinteger(L, l);
+  return 1;
+}
+
+
+static ptrdiff_t posrelat (ptrdiff_t pos, size_t len) {
+  /* relative string position: negative means back from end */
+  if (pos < 0) pos += (ptrdiff_t)len + 1;
+  return (pos >= 0) ? pos : 0;
+}
+
+
+static int str_sub (lua_State *L) {
+  size_t l;
+  const char *s = luaL_checklstring(L, 1, &l);
+  ptrdiff_t start = posrelat(luaL_checkinteger(L, 2), l);
+  ptrdiff_t end = posrelat(luaL_optinteger(L, 3, -1), l);
+  if (start < 1) start = 1;
+  if (end > (ptrdiff_t)l) end = (ptrdiff_t)l;
+  if (start <= end)
+    lua_pushlstring(L, s+start-1, end-start+1);
+  else lua_pushliteral(L, "");
+  return 1;
+}
+
+
+static int str_reverse (lua_State *L) {
+  size_t l;
+  luaL_Buffer b;
+  const char *s = luaL_checklstring(L, 1, &l);
+  luaL_buffinit(L, &b);
+  while (l--) luaL_addchar(&b, s[l]);
+  luaL_pushresult(&b);
+  return 1;
+}
+
+
+static int str_lower (lua_State *L) {
+  size_t l;
+  size_t i;
+  luaL_Buffer b;
+  const char *s = luaL_checklstring(L, 1, &l);
+  luaL_buffinit(L, &b);
+  for (i=0; i<l; i++)
+    luaL_addchar(&b, tolower(uchar(s[i])));
+  luaL_pushresult(&b);
+  return 1;
+}
+
+
+static int str_upper (lua_State *L) {
+  size_t l;
+  size_t i;
+  luaL_Buffer b;
+  const char *s = luaL_checklstring(L, 1, &l);
+  luaL_buffinit(L, &b);
+  for (i=0; i<l; i++)
+    luaL_addchar(&b, toupper(uchar(s[i])));
+  luaL_pushresult(&b);
+  return 1;
+}
+
+static int str_rep (lua_State *L) {
+  size_t l;
+  luaL_Buffer b;
+  const char *s = luaL_checklstring(L, 1, &l);
+  int n = luaL_checkint(L, 2);
+  luaL_buffinit(L, &b);
+  while (n-- > 0)
+    luaL_addlstring(&b, s, l);
+  luaL_pushresult(&b);
+  return 1;
+}
+
+
+static int str_byte (lua_State *L) {
+  size_t l;
+  const char *s = luaL_checklstring(L, 1, &l);
+  ptrdiff_t posi = posrelat(luaL_optinteger(L, 2, 1), l);
+  ptrdiff_t pose = posrelat(luaL_optinteger(L, 3, posi), l);
+  int n, i;
+  if (posi <= 0) posi = 1;
+  if ((size_t)pose > l) pose = l;
+  if (posi > pose) return 0;  /* empty interval; return no values */
+  n = (int)(pose -  posi + 1);
+  if (posi + n <= pose)  /* overflow? */
+    luaL_error(L, "string slice too long");
+  luaL_checkstack(L, n, "string slice too long");
+  for (i=0; i<n; i++)
+    lua_pushinteger(L, uchar(s[posi+i-1]));
+  return n;
+}
+
+
+static int str_char (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  int i;
+  luaL_Buffer b;
+  luaL_buffinit(L, &b);
+  for (i=1; i<=n; i++) {
+    int c = luaL_checkint(L, i);
+    luaL_argcheck(L, uchar(c) == c, i, "invalid value");
+    luaL_addchar(&b, uchar(c));
+  }
+  luaL_pushresult(&b);
+  return 1;
+}
+
+
+static int writer (lua_State *L, const void* b, size_t size, void* B) {
+  (void)L;
+  luaL_addlstring((luaL_Buffer*) B, (const char *)b, size);
+  return 0;
+}
+
+
+static int str_dump (lua_State *L) {
+  luaL_Buffer b;
+  luaL_checktype(L, 1, LUA_TFUNCTION);
+  lua_settop(L, 1);
+  luaL_buffinit(L,&b);
+  if (lua_dump(L, writer, &b) != 0)
+    luaL_error(L, "unable to dump given function");
+  luaL_pushresult(&b);
+  return 1;
+}
+
+
+
+/*
+** {======================================================
+** PATTERN MATCHING
+** =======================================================
+*/
+
+
+#define CAP_UNFINISHED  (-1)
+#define CAP_POSITION    (-2)
+
+typedef struct MatchState {
+  const char *src_init;  /* init of source string */
+  const char *src_end;  /* end (`\0') of source string */
+  lua_State *L;
+  int level;  /* total number of captures (finished or unfinished) */
+  struct {
+    const char *init;
+    ptrdiff_t len;
+  } capture[LUA_MAXCAPTURES];
+} MatchState;
+
+
+#define L_ESC           '%'
+#define SPECIALS        "^$*+?.([%-"
+
+
+static int check_capture (MatchState *ms, int l) {
+  l -= '1';
+  if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
+    return luaL_error(ms->L, "invalid capture index");
+  return l;
+}
+
+
+static int capture_to_close (MatchState *ms) {
+  int level = ms->level;
+  for (level--; level>=0; level--)
+    if (ms->capture[level].len == CAP_UNFINISHED) return level;
+  return luaL_error(ms->L, "invalid pattern capture");
+}
+
+
+static const char *classend (MatchState *ms, const char *p) {
+  switch (*p++) {
+    case L_ESC: {
+      if (*p == '\0')
+        luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")");
+      return p+1;
+    }
+    case '[': {
+      if (*p == '^') p++;
+      do {  /* look for a `]' */
+        if (*p == '\0')
+          luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");
+        if (*(p++) == L_ESC && *p != '\0')
+          p++;  /* skip escapes (e.g. `%]') */
+      } while (*p != ']');
+      return p+1;
+    }
+    default: {
+      return p;
+    }
+  }
+}
+
+
+static int match_class (int c, int cl) {
+  int res;
+  switch (tolower(cl)) {
+    case 'a' : res = isalpha(c); break;
+    case 'c' : res = iscntrl(c); break;
+    case 'd' : res = isdigit(c); break;
+    case 'l' : res = islower(c); break;
+    case 'p' : res = ispunct(c); break;
+    case 's' : res = isspace(c); break;
+    case 'u' : res = isupper(c); break;
+    case 'w' : res = isalnum(c); break;
+    case 'x' : res = isxdigit(c); break;
+    case 'z' : res = (c == 0); break;
+    default: return (cl == c);
+  }
+  return (islower(cl) ? res : !res);
+}
+
+
+static int matchbracketclass (int c, const char *p, const char *ec) {
+  int sig = 1;
+  if (*(p+1) == '^') {
+    sig = 0;
+    p++;  /* skip the `^' */
+  }
+  while (++p < ec) {
+    if (*p == L_ESC) {
+      p++;
+      if (match_class(c, uchar(*p)))
+        return sig;
+    }
+    else if ((*(p+1) == '-') && (p+2 < ec)) {
+      p+=2;
+      if (uchar(*(p-2)) <= c && c <= uchar(*p))
+        return sig;
+    }
+    else if (uchar(*p) == c) return sig;
+  }
+  return !sig;
+}
+
+
+static int singlematch (int c, const char *p, const char *ep) {
+  switch (*p) {
+    case '.': return 1;  /* matches any char */
+    case L_ESC: return match_class(c, uchar(*(p+1)));
+    case '[': return matchbracketclass(c, p, ep-1);
+    default:  return (uchar(*p) == c);
+  }
+}
+
+
+static const char *match (MatchState *ms, const char *s, const char *p);
+
+
+static const char *matchbalance (MatchState *ms, const char *s,
+                                   const char *p) {
+  if (*p == 0 || *(p+1) == 0)
+    luaL_error(ms->L, "unbalanced pattern");
+  if (*s != *p) return NULL;
+  else {
+    int b = *p;
+    int e = *(p+1);
+    int cont = 1;
+    while (++s < ms->src_end) {
+      if (*s == e) {
+        if (--cont == 0) return s+1;
+      }
+      else if (*s == b) cont++;
+    }
+  }
+  return NULL;  /* string ends out of balance */
+}
+
+
+static const char *max_expand (MatchState *ms, const char *s,
+                                 const char *p, const char *ep) {
+  ptrdiff_t i = 0;  /* counts maximum expand for item */
+  while ((s+i)<ms->src_end && singlematch(uchar(*(s+i)), p, ep))
+    i++;
+  /* keeps trying to match with the maximum repetitions */
+  while (i>=0) {
+    const char *res = match(ms, (s+i), ep+1);
+    if (res) return res;
+    i--;  /* else didn't match; reduce 1 repetition to try again */
+  }
+  return NULL;
+}
+
+
+static const char *min_expand (MatchState *ms, const char *s,
+                                 const char *p, const char *ep) {
+  for (;;) {
+    const char *res = match(ms, s, ep+1);
+    if (res != NULL)
+      return res;
+    else if (s<ms->src_end && singlematch(uchar(*s), p, ep))
+      s++;  /* try with one more repetition */
+    else return NULL;
+  }
+}
+
+
+static const char *start_capture (MatchState *ms, const char *s,
+                                    const char *p, int what) {
+  const char *res;
+  int level = ms->level;
+  if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures");
+  ms->capture[level].init = s;
+  ms->capture[level].len = what;
+  ms->level = level+1;
+  if ((res=match(ms, s, p)) == NULL)  /* match failed? */
+    ms->level--;  /* undo capture */
+  return res;
+}
+
+
+static const char *end_capture (MatchState *ms, const char *s,
+                                  const char *p) {
+  int l = capture_to_close(ms);
+  const char *res;
+  ms->capture[l].len = s - ms->capture[l].init;  /* close capture */
+  if ((res = match(ms, s, p)) == NULL)  /* match failed? */
+    ms->capture[l].len = CAP_UNFINISHED;  /* undo capture */
+  return res;
+}
+
+
+static const char *match_capture (MatchState *ms, const char *s, int l) {
+  size_t len;
+  l = check_capture(ms, l);
+  len = ms->capture[l].len;
+  if ((size_t)(ms->src_end-s) >= len &&
+      memcmp(ms->capture[l].init, s, len) == 0)
+    return s+len;
+  else return NULL;
+}
+
+
+static const char *match (MatchState *ms, const char *s, const char *p) {
+  init: /* using goto's to optimize tail recursion */
+  switch (*p) {
+    case '(': {  /* start capture */
+      if (*(p+1) == ')')  /* position capture? */
+        return start_capture(ms, s, p+2, CAP_POSITION);
+      else
+        return start_capture(ms, s, p+1, CAP_UNFINISHED);
+    }
+    case ')': {  /* end capture */
+      return end_capture(ms, s, p+1);
+    }
+    case L_ESC: {
+      switch (*(p+1)) {
+        case 'b': {  /* balanced string? */
+          s = matchbalance(ms, s, p+2);
+          if (s == NULL) return NULL;
+          p+=4; goto init;  /* else return match(ms, s, p+4); */
+        }
+        case 'f': {  /* frontier? */
+          const char *ep; char previous;
+          p += 2;
+          if (*p != '[')
+            luaL_error(ms->L, "missing " LUA_QL("[") " after "
+                               LUA_QL("%%f") " in pattern");
+          ep = classend(ms, p);  /* points to what is next */
+          previous = (s == ms->src_init) ? '\0' : *(s-1);
+          if (matchbracketclass(uchar(previous), p, ep-1) ||
+             !matchbracketclass(uchar(*s), p, ep-1)) return NULL;
+          p=ep; goto init;  /* else return match(ms, s, ep); */
+        }
+        default: {
+          if (isdigit(uchar(*(p+1)))) {  /* capture results (%0-%9)? */
+            s = match_capture(ms, s, uchar(*(p+1)));
+            if (s == NULL) return NULL;
+            p+=2; goto init;  /* else return match(ms, s, p+2) */
+          }
+          goto dflt;  /* case default */
+        }
+      }
+    }
+    case '\0': {  /* end of pattern */
+      return s;  /* match succeeded */
+    }
+    case '$': {
+      if (*(p+1) == '\0')  /* is the `$' the last char in pattern? */
+        return (s == ms->src_end) ? s : NULL;  /* check end of string */
+      else goto dflt;
+    }
+    default: dflt: {  /* it is a pattern item */
+      const char *ep = classend(ms, p);  /* points to what is next */
+      int m = s<ms->src_end && singlematch(uchar(*s), p, ep);
+      switch (*ep) {
+        case '?': {  /* optional */
+          const char *res;
+          if (m && ((res=match(ms, s+1, ep+1)) != NULL))
+            return res;
+          p=ep+1; goto init;  /* else return match(ms, s, ep+1); */
+        }
+        case '*': {  /* 0 or more repetitions */
+          return max_expand(ms, s, p, ep);
+        }
+        case '+': {  /* 1 or more repetitions */
+          return (m ? max_expand(ms, s+1, p, ep) : NULL);
+        }
+        case '-': {  /* 0 or more repetitions (minimum) */
+          return min_expand(ms, s, p, ep);
+        }
+        default: {
+          if (!m) return NULL;
+          s++; p=ep; goto init;  /* else return match(ms, s+1, ep); */
+        }
+      }
+    }
+  }
+}
+
+
+
+static const char *lmemfind (const char *s1, size_t l1,
+                               const char *s2, size_t l2) {
+  if (l2 == 0) return s1;  /* empty strings are everywhere */
+  else if (l2 > l1) return NULL;  /* avoids a negative `l1' */
+  else {
+    const char *init;  /* to search for a `*s2' inside `s1' */
+    l2--;  /* 1st char will be checked by `memchr' */
+    l1 = l1-l2;  /* `s2' cannot be found after that */
+    while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) {
+      init++;   /* 1st char is already checked */
+      if (memcmp(init, s2+1, l2) == 0)
+        return init-1;
+      else {  /* correct `l1' and `s1' to try again */
+        l1 -= init-s1;
+        s1 = init;
+      }
+    }
+    return NULL;  /* not found */
+  }
+}
+
+
+static void push_onecapture (MatchState *ms, int i, const char *s,
+                                                    const char *e) {
+  if (i >= ms->level) {
+    if (i == 0)  /* ms->level == 0, too */
+      lua_pushlstring(ms->L, s, e - s);  /* add whole match */
+    else
+      luaL_error(ms->L, "invalid capture index");
+  }
+  else {
+    ptrdiff_t l = ms->capture[i].len;
+    if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture");
+    if (l == CAP_POSITION)
+      lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1);
+    else
+      lua_pushlstring(ms->L, ms->capture[i].init, l);
+  }
+}
+
+
+static int push_captures (MatchState *ms, const char *s, const char *e) {
+  int i;
+  int nlevels = (ms->level == 0 && s) ? 1 : ms->level;
+  luaL_checkstack(ms->L, nlevels, "too many captures");
+  for (i = 0; i < nlevels; i++)
+    push_onecapture(ms, i, s, e);
+  return nlevels;  /* number of strings pushed */
+}
+
+
+static int str_find_aux (lua_State *L, int find) {
+  size_t l1, l2;
+  const char *s = luaL_checklstring(L, 1, &l1);
+  const char *p = luaL_checklstring(L, 2, &l2);
+  ptrdiff_t init = posrelat(luaL_optinteger(L, 3, 1), l1) - 1;
+  if (init < 0) init = 0;
+  else if ((size_t)(init) > l1) init = (ptrdiff_t)l1;
+  if (find && (lua_toboolean(L, 4) ||  /* explicit request? */
+      strpbrk(p, SPECIALS) == NULL)) {  /* or no special characters? */
+    /* do a plain search */
+    const char *s2 = lmemfind(s+init, l1-init, p, l2);
+    if (s2) {
+      lua_pushinteger(L, s2-s+1);
+      lua_pushinteger(L, s2-s+l2);
+      return 2;
+    }
+  }
+  else {
+    MatchState ms;
+    int anchor = (*p == '^') ? (p++, 1) : 0;
+    const char *s1=s+init;
+    ms.L = L;
+    ms.src_init = s;
+    ms.src_end = s+l1;
+    do {
+      const char *res;
+      ms.level = 0;
+      if ((res=match(&ms, s1, p)) != NULL) {
+        if (find) {
+          lua_pushinteger(L, s1-s+1);  /* start */
+          lua_pushinteger(L, res-s);   /* end */
+          return push_captures(&ms, NULL, 0) + 2;
+        }
+        else
+          return push_captures(&ms, s1, res);
+      }
+    } while (s1++ < ms.src_end && !anchor);
+  }
+  lua_pushnil(L);  /* not found */
+  return 1;
+}
+
+
+static int str_find (lua_State *L) {
+  return str_find_aux(L, 1);
+}
+
+
+static int str_match (lua_State *L) {
+  return str_find_aux(L, 0);
+}
+
+
+static int gmatch_aux (lua_State *L) {
+  MatchState ms;
+  size_t ls;
+  const char *s = lua_tolstring(L, lua_upvalueindex(1), &ls);
+  const char *p = lua_tostring(L, lua_upvalueindex(2));
+  const char *src;
+  ms.L = L;
+  ms.src_init = s;
+  ms.src_end = s+ls;
+  for (src = s + (size_t)lua_tointeger(L, lua_upvalueindex(3));
+       src <= ms.src_end;
+       src++) {
+    const char *e;
+    ms.level = 0;
+    if ((e = match(&ms, src, p)) != NULL) {
+      lua_Integer newstart = e-s;
+      if (e == src) newstart++;  /* empty match? go at least one position */
+      lua_pushinteger(L, newstart);
+      lua_replace(L, lua_upvalueindex(3));
+      return push_captures(&ms, src, e);
+    }
+  }
+  return 0;  /* not found */
+}
+
+
+static int gmatch (lua_State *L) {
+  luaL_checkstring(L, 1);
+  luaL_checkstring(L, 2);
+  lua_settop(L, 2);
+  lua_pushinteger(L, 0);
+  lua_pushcclosure(L, gmatch_aux, 3);
+  return 1;
+}
+
+
+static int gfind_nodef (lua_State *L) {
+  return luaL_error(L, LUA_QL("string.gfind") " was renamed to "
+                       LUA_QL("string.gmatch"));
+}
+
+
+static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
+                                                   const char *e) {
+  size_t l, i;
+  const char *news = lua_tolstring(ms->L, 3, &l);
+  for (i = 0; i < l; i++) {
+    if (news[i] != L_ESC)
+      luaL_addchar(b, news[i]);
+    else {
+      i++;  /* skip ESC */
+      if (!isdigit(uchar(news[i])))
+        luaL_addchar(b, news[i]);
+      else if (news[i] == '0')
+          luaL_addlstring(b, s, e - s);
+      else {
+        push_onecapture(ms, news[i] - '1', s, e);
+        luaL_addvalue(b);  /* add capture to accumulated result */
+      }
+    }
+  }
+}
+
+
+static void add_value (MatchState *ms, luaL_Buffer *b, const char *s,
+                                                       const char *e) {
+  lua_State *L = ms->L;
+  switch (lua_type(L, 3)) {
+    case LUA_TNUMBER:
+    case LUA_TSTRING: {
+      add_s(ms, b, s, e);
+      return;
+    }
+    case LUA_TFUNCTION: {
+      int n;
+      lua_pushvalue(L, 3);
+      n = push_captures(ms, s, e);
+      lua_call(L, n, 1);
+      break;
+    }
+    case LUA_TTABLE: {
+      push_onecapture(ms, 0, s, e);
+      lua_gettable(L, 3);
+      break;
+    }
+  }
+  if (!lua_toboolean(L, -1)) {  /* nil or false? */
+    lua_pop(L, 1);
+    lua_pushlstring(L, s, e - s);  /* keep original text */
+  }
+  else if (!lua_isstring(L, -1))
+    luaL_error(L, "invalid replacement value (a %s)", luaL_typename(L, -1)); 
+  luaL_addvalue(b);  /* add result to accumulator */
+}
+
+
+static int str_gsub (lua_State *L) {
+  size_t srcl;
+  const char *src = luaL_checklstring(L, 1, &srcl);
+  const char *p = luaL_checkstring(L, 2);
+  int  tr = lua_type(L, 3);
+  int max_s = luaL_optint(L, 4, srcl+1);
+  int anchor = (*p == '^') ? (p++, 1) : 0;
+  int n = 0;
+  MatchState ms;
+  luaL_Buffer b;
+  luaL_argcheck(L, tr == LUA_TNUMBER || tr == LUA_TSTRING ||
+                   tr == LUA_TFUNCTION || tr == LUA_TTABLE, 3,
+                      "string/function/table expected");
+  luaL_buffinit(L, &b);
+  ms.L = L;
+  ms.src_init = src;
+  ms.src_end = src+srcl;
+  while (n < max_s) {
+    const char *e;
+    ms.level = 0;
+    e = match(&ms, src, p);
+    if (e) {
+      n++;
+      add_value(&ms, &b, src, e);
+    }
+    if (e && e>src) /* non empty match? */
+      src = e;  /* skip it */
+    else if (src < ms.src_end)
+      luaL_addchar(&b, *src++);
+    else break;
+    if (anchor) break;
+  }
+  luaL_addlstring(&b, src, ms.src_end-src);
+  luaL_pushresult(&b);
+  lua_pushinteger(L, n);  /* number of substitutions */
+  return 2;
+}
+
+/* }====================================================== */
+
+
+/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */
+#define MAX_ITEM        512
+/* valid flags in a format specification */
+#define FLAGS   "-+ #0"
+/*
+** maximum size of each format specification (such as '%-099.99d')
+** (+10 accounts for %99.99x plus margin of error)
+*/
+#define MAX_FORMAT      (sizeof(FLAGS) + sizeof(LUA_INTFRMLEN) + 10)
+
+
+static void addquoted (lua_State *L, luaL_Buffer *b, int arg) {
+  size_t l;
+  const char *s = luaL_checklstring(L, arg, &l);
+  luaL_addchar(b, '"');
+  while (l--) {
+    switch (*s) {
+      case '"': case '\\': case '\n': {
+        luaL_addchar(b, '\\');
+        luaL_addchar(b, *s);
+        break;
+      }
+      case '\r': {
+        luaL_addlstring(b, "\\r", 2);
+        break;
+      }
+      case '\0': {
+        luaL_addlstring(b, "\\000", 4);
+        break;
+      }
+      default: {
+        luaL_addchar(b, *s);
+        break;
+      }
+    }
+    s++;
+  }
+  luaL_addchar(b, '"');
+}
+
+static const char *scanformat (lua_State *L, const char *strfrmt, char *form) {
+  const char *p = strfrmt;
+  while (*p != '\0' && strchr(FLAGS, *p) != NULL) p++;  /* skip flags */
+  if ((size_t)(p - strfrmt) >= sizeof(FLAGS))
+    luaL_error(L, "invalid format (repeated flags)");
+  if (isdigit(uchar(*p))) p++;  /* skip width */
+  if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */
+  if (*p == '.') {
+    p++;
+    if (isdigit(uchar(*p))) p++;  /* skip precision */
+    if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */
+  }
+  if (isdigit(uchar(*p)))
+    luaL_error(L, "invalid format (width or precision too long)");
+  *(form++) = '%';
+  strncpy(form, strfrmt, p - strfrmt + 1);
+  form += p - strfrmt + 1;
+  *form = '\0';
+  return p;
+}
+
+
+static void addintlen (char *form) {
+  size_t l = strlen(form);
+  char spec = form[l - 1];
+  strcpy(form + l - 1, LUA_INTFRMLEN);
+  form[l + sizeof(LUA_INTFRMLEN) - 2] = spec;
+  form[l + sizeof(LUA_INTFRMLEN) - 1] = '\0';
+}
+
+
+static int str_format (lua_State *L) {
+  int top = lua_gettop(L);
+  int arg = 1;
+  size_t sfl;
+  const char *strfrmt = luaL_checklstring(L, arg, &sfl);
+  const char *strfrmt_end = strfrmt+sfl;
+  luaL_Buffer b;
+  luaL_buffinit(L, &b);
+  while (strfrmt < strfrmt_end) {
+    if (*strfrmt != L_ESC)
+      luaL_addchar(&b, *strfrmt++);
+    else if (*++strfrmt == L_ESC)
+      luaL_addchar(&b, *strfrmt++);  /* %% */
+    else { /* format item */
+      char form[MAX_FORMAT];  /* to store the format (`%...') */
+      char buff[MAX_ITEM];  /* to store the formatted item */
+      if (++arg > top)
+        luaL_argerror(L, arg, "no value");
+      strfrmt = scanformat(L, strfrmt, form);
+      switch (*strfrmt++) {
+        case 'c': {
+          sprintf(buff, form, (int)luaL_checknumber(L, arg));
+          break;
+        }
+        case 'd':  case 'i': {
+          addintlen(form);
+          sprintf(buff, form, (LUA_INTFRM_T)luaL_checknumber(L, arg));
+          break;
+        }
+        case 'o':  case 'u':  case 'x':  case 'X': {
+          addintlen(form);
+          sprintf(buff, form, (unsigned LUA_INTFRM_T)luaL_checknumber(L, arg));
+          break;
+        }
+        case 'e':  case 'E': case 'f':
+        case 'g': case 'G': {
+          sprintf(buff, form, (double)luaL_checknumber(L, arg));
+          break;
+        }
+        case 'q': {
+          addquoted(L, &b, arg);
+          continue;  /* skip the 'addsize' at the end */
+        }
+        case 's': {
+          size_t l;
+          const char *s = luaL_checklstring(L, arg, &l);
+          if (!strchr(form, '.') && l >= 100) {
+            /* no precision and string is too long to be formatted;
+               keep original string */
+            lua_pushvalue(L, arg);
+            luaL_addvalue(&b);
+            continue;  /* skip the `addsize' at the end */
+          }
+          else {
+            sprintf(buff, form, s);
+            break;
+          }
+        }
+        default: {  /* also treat cases `pnLlh' */
+          return luaL_error(L, "invalid option " LUA_QL("%%%c") " to "
+                               LUA_QL("format"), *(strfrmt - 1));
+        }
+      }
+      luaL_addlstring(&b, buff, strlen(buff));
+    }
+  }
+  luaL_pushresult(&b);
+  return 1;
+}
+
+
+static const luaL_Reg strlib[] = {
+  {"byte", str_byte},
+  {"char", str_char},
+  {"dump", str_dump},
+  {"find", str_find},
+  {"format", str_format},
+  {"gfind", gfind_nodef},
+  {"gmatch", gmatch},
+  {"gsub", str_gsub},
+  {"len", str_len},
+  {"lower", str_lower},
+  {"match", str_match},
+  {"rep", str_rep},
+  {"reverse", str_reverse},
+  {"sub", str_sub},
+  {"upper", str_upper},
+  {NULL, NULL}
+};
+
+
+static void createmetatable (lua_State *L) {
+  lua_createtable(L, 0, 1);  /* create metatable for strings */
+  lua_pushliteral(L, "");  /* dummy string */
+  lua_pushvalue(L, -2);
+  lua_setmetatable(L, -2);  /* set string metatable */
+  lua_pop(L, 1);  /* pop dummy string */
+  lua_pushvalue(L, -2);  /* string library... */
+  lua_setfield(L, -2, "__index");  /* ...is the __index metamethod */
+  lua_pop(L, 1);  /* pop metatable */
+}
+
+
+/*
+** Open string library
+*/
+LUALIB_API int luaopen_string (lua_State *L) {
+  luaL_register(L, LUA_STRLIBNAME, strlib);
+#if defined(LUA_COMPAT_GFIND)
+  lua_getfield(L, -1, "gmatch");
+  lua_setfield(L, -2, "gfind");
+#endif
+  createmetatable(L);
+  return 1;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/ltable.c b/libraries/LuaJIT-1.1.7/src/ltable.c
new file mode 100644
index 0000000..6b226ad
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ltable.c
@@ -0,0 +1,588 @@
+/*
+** $Id: ltable.c,v 2.32.1.2 2007/12/28 15:32:23 roberto Exp $
+** Lua tables (hash)
+** See Copyright Notice in lua.h
+*/
+
+
+/*
+** Implementation of tables (aka arrays, objects, or hash tables).
+** Tables keep its elements in two parts: an array part and a hash part.
+** Non-negative integer keys are all candidates to be kept in the array
+** part. The actual size of the array is the largest `n' such that at
+** least half the slots between 0 and n are in use.
+** Hash uses a mix of chained scatter table with Brent's variation.
+** A main invariant of these tables is that, if an element is not
+** in its main position (i.e. the `original' position that its hash gives
+** to it), then the colliding element is in its own main position.
+** Hence even when the load factor reaches 100%, performance remains good.
+*/
+
+#include <math.h>
+#include <string.h>
+
+#define ltable_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "ldebug.h"
+#include "ldo.h"
+#include "lgc.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lstate.h"
+#include "ltable.h"
+
+
+/*
+** max size of array part is 2^MAXBITS
+*/
+#if LUAI_BITSINT > 26
+#define MAXBITS         26
+#else
+#define MAXBITS         (LUAI_BITSINT-2)
+#endif
+
+#define MAXASIZE        (1 << MAXBITS)
+
+
+#define hashpow2(t,n)      (gnode(t, lmod((n), sizenode(t))))
+  
+#define hashstr(t,str)  hashpow2(t, (str)->tsv.hash)
+#define hashboolean(t,p)        hashpow2(t, p)
+
+
+/*
+** for some types, it is better to avoid modulus by power of 2, as
+** they tend to have many 2 factors.
+*/
+#define hashmod(t,n)    (gnode(t, ((n) % ((sizenode(t)-1)|1))))
+
+
+#define hashpointer(t,p)        hashmod(t, IntPoint(p))
+
+
+/*
+** number of ints inside a lua_Number
+*/
+#define numints         cast_int(sizeof(lua_Number)/sizeof(int))
+
+
+
+#define dummynode               (&dummynode_)
+
+static const Node dummynode_ = {
+  {{NULL}, LUA_TNIL},  /* value */
+  {{{NULL}, LUA_TNIL, NULL}}  /* key */
+};
+
+
+/*
+** hash for lua_Numbers
+*/
+static Node *hashnum (const Table *t, lua_Number n) {
+  unsigned int a[numints];
+  int i;
+  if (luai_numeq(n, 0))  /* avoid problems with -0 */
+    return gnode(t, 0);
+  memcpy(a, &n, sizeof(a));
+  for (i = 1; i < numints; i++) a[0] += a[i];
+  return hashmod(t, a[0]);
+}
+
+
+
+/*
+** returns the `main' position of an element in a table (that is, the index
+** of its hash value)
+*/
+static Node *mainposition (const Table *t, const TValue *key) {
+  switch (ttype(key)) {
+    case LUA_TNUMBER:
+      return hashnum(t, nvalue(key));
+    case LUA_TSTRING:
+      return hashstr(t, rawtsvalue(key));
+    case LUA_TBOOLEAN:
+      return hashboolean(t, bvalue(key));
+    case LUA_TLIGHTUSERDATA:
+      return hashpointer(t, pvalue(key));
+    default:
+      return hashpointer(t, gcvalue(key));
+  }
+}
+
+
+/*
+** returns the index for `key' if `key' is an appropriate key to live in
+** the array part of the table, -1 otherwise.
+*/
+static int arrayindex (const TValue *key) {
+  if (ttisnumber(key)) {
+    lua_Number n = nvalue(key);
+    int k;
+    lua_number2int(k, n);
+    if (luai_numeq(cast_num(k), n))
+      return k;
+  }
+  return -1;  /* `key' did not match some condition */
+}
+
+
+/*
+** returns the index of a `key' for table traversals. First goes all
+** elements in the array part, then elements in the hash part. The
+** beginning of a traversal is signalled by -1.
+*/
+static int findindex (lua_State *L, Table *t, StkId key) {
+  int i;
+  if (ttisnil(key)) return -1;  /* first iteration */
+  i = arrayindex(key);
+  if (0 < i && i <= t->sizearray)  /* is `key' inside array part? */
+    return i-1;  /* yes; that's the index (corrected to C) */
+  else {
+    Node *n = mainposition(t, key);
+    do {  /* check whether `key' is somewhere in the chain */
+      /* key may be dead already, but it is ok to use it in `next' */
+      if (luaO_rawequalObj(key2tval(n), key) ||
+            (ttype(gkey(n)) == LUA_TDEADKEY && iscollectable(key) &&
+             gcvalue(gkey(n)) == gcvalue(key))) {
+        i = cast_int(n - gnode(t, 0));  /* key index in hash table */
+        /* hash elements are numbered after array ones */
+        return i + t->sizearray;
+      }
+      else n = gnext(n);
+    } while (n);
+    luaG_runerror(L, "invalid key to " LUA_QL("next"));  /* key not found */
+    return 0;  /* to avoid warnings */
+  }
+}
+
+
+int luaH_next (lua_State *L, Table *t, StkId key) {
+  int i = findindex(L, t, key);  /* find original element */
+  for (i++; i < t->sizearray; i++) {  /* try first array part */
+    if (!ttisnil(&t->array[i])) {  /* a non-nil value? */
+      setnvalue(key, cast_num(i+1));
+      setobj2s(L, key+1, &t->array[i]);
+      return 1;
+    }
+  }
+  for (i -= t->sizearray; i < sizenode(t); i++) {  /* then hash part */
+    if (!ttisnil(gval(gnode(t, i)))) {  /* a non-nil value? */
+      setobj2s(L, key, key2tval(gnode(t, i)));
+      setobj2s(L, key+1, gval(gnode(t, i)));
+      return 1;
+    }
+  }
+  return 0;  /* no more elements */
+}
+
+
+/*
+** {=============================================================
+** Rehash
+** ==============================================================
+*/
+
+
+static int computesizes (int nums[], int *narray) {
+  int i;
+  int twotoi;  /* 2^i */
+  int a = 0;  /* number of elements smaller than 2^i */
+  int na = 0;  /* number of elements to go to array part */
+  int n = 0;  /* optimal size for array part */
+  for (i = 0, twotoi = 1; twotoi/2 < *narray; i++, twotoi *= 2) {
+    if (nums[i] > 0) {
+      a += nums[i];
+      if (a > twotoi/2) {  /* more than half elements present? */
+        n = twotoi;  /* optimal size (till now) */
+        na = a;  /* all elements smaller than n will go to array part */
+      }
+    }
+    if (a == *narray) break;  /* all elements already counted */
+  }
+  *narray = n;
+  lua_assert(*narray/2 <= na && na <= *narray);
+  return na;
+}
+
+
+static int countint (const TValue *key, int *nums) {
+  int k = arrayindex(key);
+  if (0 < k && k <= MAXASIZE) {  /* is `key' an appropriate array index? */
+    nums[ceillog2(k)]++;  /* count as such */
+    return 1;
+  }
+  else
+    return 0;
+}
+
+
+static int numusearray (const Table *t, int *nums) {
+  int lg;
+  int ttlg;  /* 2^lg */
+  int ause = 0;  /* summation of `nums' */
+  int i = 1;  /* count to traverse all array keys */
+  for (lg=0, ttlg=1; lg<=MAXBITS; lg++, ttlg*=2) {  /* for each slice */
+    int lc = 0;  /* counter */
+    int lim = ttlg;
+    if (lim > t->sizearray) {
+      lim = t->sizearray;  /* adjust upper limit */
+      if (i > lim)
+        break;  /* no more elements to count */
+    }
+    /* count elements in range (2^(lg-1), 2^lg] */
+    for (; i <= lim; i++) {
+      if (!ttisnil(&t->array[i-1]))
+        lc++;
+    }
+    nums[lg] += lc;
+    ause += lc;
+  }
+  return ause;
+}
+
+
+static int numusehash (const Table *t, int *nums, int *pnasize) {
+  int totaluse = 0;  /* total number of elements */
+  int ause = 0;  /* summation of `nums' */
+  int i = sizenode(t);
+  while (i--) {
+    Node *n = &t->node[i];
+    if (!ttisnil(gval(n))) {
+      ause += countint(key2tval(n), nums);
+      totaluse++;
+    }
+  }
+  *pnasize += ause;
+  return totaluse;
+}
+
+
+static void setarrayvector (lua_State *L, Table *t, int size) {
+  int i;
+  luaM_reallocvector(L, t->array, t->sizearray, size, TValue);
+  for (i=t->sizearray; i<size; i++)
+     setnilvalue(&t->array[i]);
+  t->sizearray = size;
+}
+
+
+static void setnodevector (lua_State *L, Table *t, int size) {
+  int lsize;
+  if (size == 0) {  /* no elements to hash part? */
+    t->node = cast(Node *, dummynode);  /* use common `dummynode' */
+    lsize = 0;
+  }
+  else {
+    int i;
+    lsize = ceillog2(size);
+    if (lsize > MAXBITS)
+      luaG_runerror(L, "table overflow");
+    size = twoto(lsize);
+    t->node = luaM_newvector(L, size, Node);
+    for (i=0; i<size; i++) {
+      Node *n = gnode(t, i);
+      gnext(n) = NULL;
+      setnilvalue(gkey(n));
+      setnilvalue(gval(n));
+    }
+  }
+  t->lsizenode = cast_byte(lsize);
+  t->lastfree = gnode(t, size);  /* all positions are free */
+}
+
+
+static void resize (lua_State *L, Table *t, int nasize, int nhsize) {
+  int i;
+  int oldasize = t->sizearray;
+  int oldhsize = t->lsizenode;
+  Node *nold = t->node;  /* save old hash ... */
+  if (nasize > oldasize)  /* array part must grow? */
+    setarrayvector(L, t, nasize);
+  /* create new hash part with appropriate size */
+  setnodevector(L, t, nhsize);  
+  if (nasize < oldasize) {  /* array part must shrink? */
+    t->sizearray = nasize;
+    /* re-insert elements from vanishing slice */
+    for (i=nasize; i<oldasize; i++) {
+      if (!ttisnil(&t->array[i]))
+        setobjt2t(L, luaH_setnum(L, t, i+1), &t->array[i]);
+    }
+    /* shrink array */
+    luaM_reallocvector(L, t->array, oldasize, nasize, TValue);
+  }
+  /* re-insert elements from hash part */
+  for (i = twoto(oldhsize) - 1; i >= 0; i--) {
+    Node *old = nold+i;
+    if (!ttisnil(gval(old)))
+      setobjt2t(L, luaH_set(L, t, key2tval(old)), gval(old));
+  }
+  if (nold != dummynode)
+    luaM_freearray(L, nold, twoto(oldhsize), Node);  /* free old array */
+}
+
+
+void luaH_resizearray (lua_State *L, Table *t, int nasize) {
+  int nsize = (t->node == dummynode) ? 0 : sizenode(t);
+  resize(L, t, nasize, nsize);
+}
+
+
+static void rehash (lua_State *L, Table *t, const TValue *ek) {
+  int nasize, na;
+  int nums[MAXBITS+1];  /* nums[i] = number of keys between 2^(i-1) and 2^i */
+  int i;
+  int totaluse;
+  for (i=0; i<=MAXBITS; i++) nums[i] = 0;  /* reset counts */
+  nasize = numusearray(t, nums);  /* count keys in array part */
+  totaluse = nasize;  /* all those keys are integer keys */
+  totaluse += numusehash(t, nums, &nasize);  /* count keys in hash part */
+  /* count extra key */
+  nasize += countint(ek, nums);
+  totaluse++;
+  /* compute new size for array part */
+  na = computesizes(nums, &nasize);
+  /* resize the table to new computed sizes */
+  resize(L, t, nasize, totaluse - na);
+}
+
+
+
+/*
+** }=============================================================
+*/
+
+
+Table *luaH_new (lua_State *L, int narray, int nhash) {
+  Table *t = luaM_new(L, Table);
+  luaC_link(L, obj2gco(t), LUA_TTABLE);
+  t->metatable = NULL;
+  t->flags = cast_byte(~0);
+  /* temporary values (kept only if some malloc fails) */
+  t->array = NULL;
+  t->sizearray = 0;
+  t->lsizenode = 0;
+  t->node = cast(Node *, dummynode);
+  setarrayvector(L, t, narray);
+  setnodevector(L, t, nhash);
+  return t;
+}
+
+
+void luaH_free (lua_State *L, Table *t) {
+  if (t->node != dummynode)
+    luaM_freearray(L, t->node, sizenode(t), Node);
+  luaM_freearray(L, t->array, t->sizearray, TValue);
+  luaM_free(L, t);
+}
+
+
+static Node *getfreepos (Table *t) {
+  while (t->lastfree-- > t->node) {
+    if (ttisnil(gkey(t->lastfree)))
+      return t->lastfree;
+  }
+  return NULL;  /* could not find a free place */
+}
+
+
+
+/*
+** inserts a new key into a hash table; first, check whether key's main 
+** position is free. If not, check whether colliding node is in its main 
+** position or not: if it is not, move colliding node to an empty place and 
+** put new key in its main position; otherwise (colliding node is in its main 
+** position), new key goes to an empty position. 
+*/
+TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) {
+  Node *mp = mainposition(t, key);
+  if (!ttisnil(gval(mp)) || mp == dummynode) {
+    Node *othern;
+    Node *n = getfreepos(t);  /* get a free place */
+    if (n == NULL) {  /* cannot find a free place? */
+      rehash(L, t, key);  /* grow table */
+      return luaH_set(L, t, key);  /* re-insert key into grown table */
+    }
+    lua_assert(n != dummynode);
+    othern = mainposition(t, key2tval(mp));
+    if (othern != mp) {  /* is colliding node out of its main position? */
+      /* yes; move colliding node into free position */
+      while (gnext(othern) != mp) othern = gnext(othern);  /* find previous */
+      gnext(othern) = n;  /* redo the chain with `n' in place of `mp' */
+      *n = *mp;  /* copy colliding node into free pos. (mp->next also goes) */
+      gnext(mp) = NULL;  /* now `mp' is free */
+      setnilvalue(gval(mp));
+    }
+    else {  /* colliding node is in its own main position */
+      /* new node will go into free position */
+      gnext(n) = gnext(mp);  /* chain new position */
+      gnext(mp) = n;
+      mp = n;
+    }
+  }
+  gkey(mp)->value = key->value; gkey(mp)->tt = key->tt;
+  luaC_barriert(L, t, key);
+  lua_assert(ttisnil(gval(mp)));
+  return gval(mp);
+}
+
+
+/*
+** search function for integers
+*/
+const TValue *luaH_getnum (Table *t, int key) {
+  /* (1 <= key && key <= t->sizearray) */
+  if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray))
+    return &t->array[key-1];
+  else {
+    lua_Number nk = cast_num(key);
+    Node *n = hashnum(t, nk);
+    do {  /* check whether `key' is somewhere in the chain */
+      if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk))
+        return gval(n);  /* that's it */
+      else n = gnext(n);
+    } while (n);
+    return luaO_nilobject;
+  }
+}
+
+
+/*
+** search function for strings
+*/
+const TValue *luaH_getstr (Table *t, TString *key) {
+  Node *n = hashstr(t, key);
+  do {  /* check whether `key' is somewhere in the chain */
+    if (ttisstring(gkey(n)) && rawtsvalue(gkey(n)) == key)
+      return gval(n);  /* that's it */
+    else n = gnext(n);
+  } while (n);
+  return luaO_nilobject;
+}
+
+
+/*
+** main search function
+*/
+const TValue *luaH_get (Table *t, const TValue *key) {
+  switch (ttype(key)) {
+    case LUA_TNIL: return luaO_nilobject;
+    case LUA_TSTRING: return luaH_getstr(t, rawtsvalue(key));
+    case LUA_TNUMBER: {
+      int k;
+      lua_Number n = nvalue(key);
+      lua_number2int(k, n);
+      if (luai_numeq(cast_num(k), nvalue(key))) /* index is int? */
+        return luaH_getnum(t, k);  /* use specialized version */
+      /* else go through */
+    }
+    default: {
+      Node *n = mainposition(t, key);
+      do {  /* check whether `key' is somewhere in the chain */
+        if (luaO_rawequalObj(key2tval(n), key))
+          return gval(n);  /* that's it */
+        else n = gnext(n);
+      } while (n);
+      return luaO_nilobject;
+    }
+  }
+}
+
+
+TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
+  const TValue *p = luaH_get(t, key);
+  t->flags = 0;
+  if (p != luaO_nilobject)
+    return cast(TValue *, p);
+  else {
+    if (ttisnil(key)) luaG_runerror(L, "table index is nil");
+    else if (ttisnumber(key) && luai_numisnan(nvalue(key)))
+      luaG_runerror(L, "table index is NaN");
+    return luaH_newkey(L, t, key);
+  }
+}
+
+
+TValue *luaH_setnum (lua_State *L, Table *t, int key) {
+  const TValue *p = luaH_getnum(t, key);
+  if (p != luaO_nilobject)
+    return cast(TValue *, p);
+  else {
+    TValue k;
+    setnvalue(&k, cast_num(key));
+    return luaH_newkey(L, t, &k);
+  }
+}
+
+
+TValue *luaH_setstr (lua_State *L, Table *t, TString *key) {
+  const TValue *p = luaH_getstr(t, key);
+  if (p != luaO_nilobject)
+    return cast(TValue *, p);
+  else {
+    TValue k;
+    setsvalue(L, &k, key);
+    return luaH_newkey(L, t, &k);
+  }
+}
+
+
+static int unbound_search (Table *t, unsigned int j) {
+  unsigned int i = j;  /* i is zero or a present index */
+  j++;
+  /* find `i' and `j' such that i is present and j is not */
+  while (!ttisnil(luaH_getnum(t, j))) {
+    i = j;
+    j *= 2;
+    if (j > cast(unsigned int, MAX_INT)) {  /* overflow? */
+      /* table was built with bad purposes: resort to linear search */
+      i = 1;
+      while (!ttisnil(luaH_getnum(t, i))) i++;
+      return i - 1;
+    }
+  }
+  /* now do a binary search between them */
+  while (j - i > 1) {
+    unsigned int m = (i+j)/2;
+    if (ttisnil(luaH_getnum(t, m))) j = m;
+    else i = m;
+  }
+  return i;
+}
+
+
+/*
+** Try to find a boundary in table `t'. A `boundary' is an integer index
+** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil).
+*/
+int luaH_getn (Table *t) {
+  unsigned int j = t->sizearray;
+  if (j > 0 && ttisnil(&t->array[j - 1])) {
+    /* there is a boundary in the array part: (binary) search for it */
+    unsigned int i = 0;
+    while (j - i > 1) {
+      unsigned int m = (i+j)/2;
+      if (ttisnil(&t->array[m - 1])) j = m;
+      else i = m;
+    }
+    return i;
+  }
+  /* else must find a boundary in hash part */
+  else if (t->node == dummynode)  /* hash part is empty? */
+    return j;  /* that is easy... */
+  else return unbound_search(t, j);
+}
+
+
+
+#if defined(LUA_DEBUG)
+
+Node *luaH_mainposition (const Table *t, const TValue *key) {
+  return mainposition(t, key);
+}
+
+int luaH_isdummy (Node *n) { return n == dummynode; }
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ltable.h b/libraries/LuaJIT-1.1.7/src/ltable.h
new file mode 100644
index 0000000..a61c981
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ltable.h
@@ -0,0 +1,41 @@
+/*
+** $Id: ltable.h,v 2.10.1.1 2007/12/27 13:02:25 roberto Exp $
+** Lua tables (hash)
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ltable_h
+#define ltable_h
+
+#include "lobject.h"
+
+
+#define gnode(t,i)      (&(t)->node[i])
+#define gkey(n)         (&(n)->i_key.nk)
+#define gval(n)         (&(n)->i_val)
+#define gnext(n)        ((n)->i_key.nk.next)
+
+#define key2tval(n)     (&(n)->i_key.tvk)
+
+
+LUAI_FUNC const TValue *luaH_getnum (Table *t, int key);
+LUAI_FUNC TValue *luaH_setnum (lua_State *L, Table *t, int key);
+LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
+LUAI_FUNC TValue *luaH_setstr (lua_State *L, Table *t, TString *key);
+LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
+LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key);
+LUAI_FUNC Table *luaH_new (lua_State *L, int narray, int lnhash);
+LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, int nasize);
+LUAI_FUNC void luaH_free (lua_State *L, Table *t);
+LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
+LUAI_FUNC int luaH_getn (Table *t);
+LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key);
+
+
+#if defined(LUA_DEBUG)
+LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key);
+LUAI_FUNC int luaH_isdummy (Node *n);
+#endif
+
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/ltablib.c b/libraries/LuaJIT-1.1.7/src/ltablib.c
new file mode 100644
index 0000000..b6d9cb4
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ltablib.c
@@ -0,0 +1,287 @@
+/*
+** $Id: ltablib.c,v 1.38.1.3 2008/02/14 16:46:58 roberto Exp $
+** Library for Table Manipulation
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stddef.h>
+
+#define ltablib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+
+
+#define aux_getn(L,n)   (luaL_checktype(L, n, LUA_TTABLE), luaL_getn(L, n))
+
+
+static int foreachi (lua_State *L) {
+  int i;
+  int n = aux_getn(L, 1);
+  luaL_checktype(L, 2, LUA_TFUNCTION);
+  for (i=1; i <= n; i++) {
+    lua_pushvalue(L, 2);  /* function */
+    lua_pushinteger(L, i);  /* 1st argument */
+    lua_rawgeti(L, 1, i);  /* 2nd argument */
+    lua_call(L, 2, 1);
+    if (!lua_isnil(L, -1))
+      return 1;
+    lua_pop(L, 1);  /* remove nil result */
+  }
+  return 0;
+}
+
+
+static int foreach (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  luaL_checktype(L, 2, LUA_TFUNCTION);
+  lua_pushnil(L);  /* first key */
+  while (lua_next(L, 1)) {
+    lua_pushvalue(L, 2);  /* function */
+    lua_pushvalue(L, -3);  /* key */
+    lua_pushvalue(L, -3);  /* value */
+    lua_call(L, 2, 1);
+    if (!lua_isnil(L, -1))
+      return 1;
+    lua_pop(L, 2);  /* remove value and result */
+  }
+  return 0;
+}
+
+
+static int maxn (lua_State *L) {
+  lua_Number max = 0;
+  luaL_checktype(L, 1, LUA_TTABLE);
+  lua_pushnil(L);  /* first key */
+  while (lua_next(L, 1)) {
+    lua_pop(L, 1);  /* remove value */
+    if (lua_type(L, -1) == LUA_TNUMBER) {
+      lua_Number v = lua_tonumber(L, -1);
+      if (v > max) max = v;
+    }
+  }
+  lua_pushnumber(L, max);
+  return 1;
+}
+
+
+static int getn (lua_State *L) {
+  lua_pushinteger(L, aux_getn(L, 1));
+  return 1;
+}
+
+
+static int setn (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+#ifndef luaL_setn
+  luaL_setn(L, 1, luaL_checkint(L, 2));
+#else
+  luaL_error(L, LUA_QL("setn") " is obsolete");
+#endif
+  lua_pushvalue(L, 1);
+  return 1;
+}
+
+
+static int tinsert (lua_State *L) {
+  int e = aux_getn(L, 1) + 1;  /* first empty element */
+  int pos;  /* where to insert new element */
+  switch (lua_gettop(L)) {
+    case 2: {  /* called with only 2 arguments */
+      pos = e;  /* insert new element at the end */
+      break;
+    }
+    case 3: {
+      int i;
+      pos = luaL_checkint(L, 2);  /* 2nd argument is the position */
+      if (pos > e) e = pos;  /* `grow' array if necessary */
+      for (i = e; i > pos; i--) {  /* move up elements */
+        lua_rawgeti(L, 1, i-1);
+        lua_rawseti(L, 1, i);  /* t[i] = t[i-1] */
+      }
+      break;
+    }
+    default: {
+      return luaL_error(L, "wrong number of arguments to " LUA_QL("insert"));
+    }
+  }
+  luaL_setn(L, 1, e);  /* new size */
+  lua_rawseti(L, 1, pos);  /* t[pos] = v */
+  return 0;
+}
+
+
+static int tremove (lua_State *L) {
+  int e = aux_getn(L, 1);
+  int pos = luaL_optint(L, 2, e);
+  if (!(1 <= pos && pos <= e))  /* position is outside bounds? */
+   return 0;  /* nothing to remove */
+  luaL_setn(L, 1, e - 1);  /* t.n = n-1 */
+  lua_rawgeti(L, 1, pos);  /* result = t[pos] */
+  for ( ;pos<e; pos++) {
+    lua_rawgeti(L, 1, pos+1);
+    lua_rawseti(L, 1, pos);  /* t[pos] = t[pos+1] */
+  }
+  lua_pushnil(L);
+  lua_rawseti(L, 1, e);  /* t[e] = nil */
+  return 1;
+}
+
+
+static void addfield (lua_State *L, luaL_Buffer *b, int i) {
+  lua_rawgeti(L, 1, i);
+  if (!lua_isstring(L, -1))
+    luaL_error(L, "invalid value (%s) at index %d in table for "
+                  LUA_QL("concat"), luaL_typename(L, -1), i);
+    luaL_addvalue(b);
+}
+
+
+static int tconcat (lua_State *L) {
+  luaL_Buffer b;
+  size_t lsep;
+  int i, last;
+  const char *sep = luaL_optlstring(L, 2, "", &lsep);
+  luaL_checktype(L, 1, LUA_TTABLE);
+  i = luaL_optint(L, 3, 1);
+  last = luaL_opt(L, luaL_checkint, 4, luaL_getn(L, 1));
+  luaL_buffinit(L, &b);
+  for (; i < last; i++) {
+    addfield(L, &b, i);
+    luaL_addlstring(&b, sep, lsep);
+  }
+  if (i == last)  /* add last value (if interval was not empty) */
+    addfield(L, &b, i);
+  luaL_pushresult(&b);
+  return 1;
+}
+
+
+
+/*
+** {======================================================
+** Quicksort
+** (based on `Algorithms in MODULA-3', Robert Sedgewick;
+**  Addison-Wesley, 1993.)
+*/
+
+
+static void set2 (lua_State *L, int i, int j) {
+  lua_rawseti(L, 1, i);
+  lua_rawseti(L, 1, j);
+}
+
+static int sort_comp (lua_State *L, int a, int b) {
+  if (!lua_isnil(L, 2)) {  /* function? */
+    int res;
+    lua_pushvalue(L, 2);
+    lua_pushvalue(L, a-1);  /* -1 to compensate function */
+    lua_pushvalue(L, b-2);  /* -2 to compensate function and `a' */
+    lua_call(L, 2, 1);
+    res = lua_toboolean(L, -1);
+    lua_pop(L, 1);
+    return res;
+  }
+  else  /* a < b? */
+    return lua_lessthan(L, a, b);
+}
+
+static void auxsort (lua_State *L, int l, int u) {
+  while (l < u) {  /* for tail recursion */
+    int i, j;
+    /* sort elements a[l], a[(l+u)/2] and a[u] */
+    lua_rawgeti(L, 1, l);
+    lua_rawgeti(L, 1, u);
+    if (sort_comp(L, -1, -2))  /* a[u] < a[l]? */
+      set2(L, l, u);  /* swap a[l] - a[u] */
+    else
+      lua_pop(L, 2);
+    if (u-l == 1) break;  /* only 2 elements */
+    i = (l+u)/2;
+    lua_rawgeti(L, 1, i);
+    lua_rawgeti(L, 1, l);
+    if (sort_comp(L, -2, -1))  /* a[i]<a[l]? */
+      set2(L, i, l);
+    else {
+      lua_pop(L, 1);  /* remove a[l] */
+      lua_rawgeti(L, 1, u);
+      if (sort_comp(L, -1, -2))  /* a[u]<a[i]? */
+        set2(L, i, u);
+      else
+        lua_pop(L, 2);
+    }
+    if (u-l == 2) break;  /* only 3 elements */
+    lua_rawgeti(L, 1, i);  /* Pivot */
+    lua_pushvalue(L, -1);
+    lua_rawgeti(L, 1, u-1);
+    set2(L, i, u-1);
+    /* a[l] <= P == a[u-1] <= a[u], only need to sort from l+1 to u-2 */
+    i = l; j = u-1;
+    for (;;) {  /* invariant: a[l..i] <= P <= a[j..u] */
+      /* repeat ++i until a[i] >= P */
+      while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) {
+        if (i>u) luaL_error(L, "invalid order function for sorting");
+        lua_pop(L, 1);  /* remove a[i] */
+      }
+      /* repeat --j until a[j] <= P */
+      while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) {
+        if (j<l) luaL_error(L, "invalid order function for sorting");
+        lua_pop(L, 1);  /* remove a[j] */
+      }
+      if (j<i) {
+        lua_pop(L, 3);  /* pop pivot, a[i], a[j] */
+        break;
+      }
+      set2(L, i, j);
+    }
+    lua_rawgeti(L, 1, u-1);
+    lua_rawgeti(L, 1, i);
+    set2(L, u-1, i);  /* swap pivot (a[u-1]) with a[i] */
+    /* a[l..i-1] <= a[i] == P <= a[i+1..u] */
+    /* adjust so that smaller half is in [j..i] and larger one in [l..u] */
+    if (i-l < u-i) {
+      j=l; i=i-1; l=i+2;
+    }
+    else {
+      j=i+1; i=u; u=j-2;
+    }
+    auxsort(L, j, i);  /* call recursively the smaller one */
+  }  /* repeat the routine for the larger one */
+}
+
+static int sort (lua_State *L) {
+  int n = aux_getn(L, 1);
+  luaL_checkstack(L, 40, "");  /* assume array is smaller than 2^40 */
+  if (!lua_isnoneornil(L, 2))  /* is there a 2nd argument? */
+    luaL_checktype(L, 2, LUA_TFUNCTION);
+  lua_settop(L, 2);  /* make sure there is two arguments */
+  auxsort(L, 1, n);
+  return 0;
+}
+
+/* }====================================================== */
+
+
+static const luaL_Reg tab_funcs[] = {
+  {"concat", tconcat},
+  {"foreach", foreach},
+  {"foreachi", foreachi},
+  {"getn", getn},
+  {"maxn", maxn},
+  {"insert", tinsert},
+  {"remove", tremove},
+  {"setn", setn},
+  {"sort", sort},
+  {NULL, NULL}
+};
+
+
+LUALIB_API int luaopen_table (lua_State *L) {
+  luaL_register(L, LUA_TABLIBNAME, tab_funcs);
+  return 1;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/ltm.c b/libraries/LuaJIT-1.1.7/src/ltm.c
new file mode 100644
index 0000000..c27f0f6
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ltm.c
@@ -0,0 +1,75 @@
+/*
+** $Id: ltm.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
+** Tag methods
+** See Copyright Notice in lua.h
+*/
+
+
+#include <string.h>
+
+#define ltm_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lobject.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "ltm.h"
+
+
+
+const char *const luaT_typenames[] = {
+  "nil", "boolean", "userdata", "number",
+  "string", "table", "function", "userdata", "thread",
+  "proto", "upval"
+};
+
+
+void luaT_init (lua_State *L) {
+  static const char *const luaT_eventname[] = {  /* ORDER TM */
+    "__index", "__newindex",
+    "__gc", "__mode", "__eq",
+    "__add", "__sub", "__mul", "__div", "__mod",
+    "__pow", "__unm", "__len", "__lt", "__le",
+    "__concat", "__call"
+  };
+  int i;
+  for (i=0; i<TM_N; i++) {
+    G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
+    luaS_fix(G(L)->tmname[i]);  /* never collect these names */
+  }
+}
+
+
+/*
+** function to be used with macro "fasttm": optimized for absence of
+** tag methods
+*/
+const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
+  const TValue *tm = luaH_getstr(events, ename);
+  lua_assert(event <= TM_EQ);
+  if (ttisnil(tm)) {  /* no tag method? */
+    events->flags |= cast_byte(1u<<event);  /* cache this fact */
+    return NULL;
+  }
+  else return tm;
+}
+
+
+const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
+  Table *mt;
+  switch (ttype(o)) {
+    case LUA_TTABLE:
+      mt = hvalue(o)->metatable;
+      break;
+    case LUA_TUSERDATA:
+      mt = uvalue(o)->metatable;
+      break;
+    default:
+      mt = G(L)->mt[ttype(o)];
+  }
+  return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject);
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/ltm.h b/libraries/LuaJIT-1.1.7/src/ltm.h
new file mode 100644
index 0000000..64343b7
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/ltm.h
@@ -0,0 +1,54 @@
+/*
+** $Id: ltm.h,v 2.6.1.1 2007/12/27 13:02:25 roberto Exp $
+** Tag methods
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ltm_h
+#define ltm_h
+
+
+#include "lobject.h"
+
+
+/*
+* WARNING: if you change the order of this enumeration,
+* grep "ORDER TM"
+*/
+typedef enum {
+  TM_INDEX,
+  TM_NEWINDEX,
+  TM_GC,
+  TM_MODE,
+  TM_EQ,  /* last tag method with `fast' access */
+  TM_ADD,
+  TM_SUB,
+  TM_MUL,
+  TM_DIV,
+  TM_MOD,
+  TM_POW,
+  TM_UNM,
+  TM_LEN,
+  TM_LT,
+  TM_LE,
+  TM_CONCAT,
+  TM_CALL,
+  TM_N          /* number of elements in the enum */
+} TMS;
+
+
+
+#define gfasttm(g,et,e) ((et) == NULL ? NULL : \
+  ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
+
+#define fasttm(l,et,e)  gfasttm(G(l), et, e)
+
+LUAI_DATA const char *const luaT_typenames[];
+
+
+LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename);
+LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,
+                                                       TMS event);
+LUAI_FUNC void luaT_init (lua_State *L);
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lua.c b/libraries/LuaJIT-1.1.7/src/lua.c
new file mode 100644
index 0000000..a4b413f
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lua.c
@@ -0,0 +1,463 @@
+/*
+** $Id: lua.c,v 1.160.1.2 2007/12/28 15:32:23 roberto Exp $
+** Lua stand-alone interpreter
+** See Copyright Notice in lua.h
+*/
+
+
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define lua_c
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+#include "luajit.h"
+
+
+
+static lua_State *globalL = NULL;
+
+static const char *progname = LUA_PROGNAME;
+
+
+
+static void lstop (lua_State *L, lua_Debug *ar) {
+  (void)ar;  /* unused arg. */
+  lua_sethook(L, NULL, 0, 0);
+  luaL_error(L, "interrupted!");
+}
+
+
+static void laction (int i) {
+  signal(i, SIG_DFL); /* if another SIGINT happens before lstop,
+                              terminate process (default action) */
+  lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
+}
+
+
+static void print_usage (void) {
+  fprintf(stderr,
+  "usage: %s [options] [script [args]].\n"
+  "Available options are:\n"
+  "  -e stat  execute string " LUA_QL("stat") "\n"
+  "  -l name  require library " LUA_QL("name") "\n"
+  "  -j cmd   perform LuaJIT control command\n"
+  "  -O[lvl]  set LuaJIT optimization level\n"
+  "  -i       enter interactive mode after executing " LUA_QL("script") "\n"
+  "  -v       show version information\n"
+  "  --       stop handling options\n"
+  "  -        execute stdin and stop handling options\n"
+  ,
+  progname);
+  fflush(stderr);
+}
+
+
+static void l_message (const char *pname, const char *msg) {
+  if (pname) fprintf(stderr, "%s: ", pname);
+  fprintf(stderr, "%s\n", msg);
+  fflush(stderr);
+}
+
+
+static int report (lua_State *L, int status) {
+  if (status && !lua_isnil(L, -1)) {
+    const char *msg = lua_tostring(L, -1);
+    if (msg == NULL) msg = "(error object is not a string)";
+    l_message(progname, msg);
+    lua_pop(L, 1);
+  }
+  return status;
+}
+
+
+static int traceback (lua_State *L) {
+  if (!lua_isstring(L, 1))  /* 'message' not a string? */
+    return 1;  /* keep it intact */
+  lua_getfield(L, LUA_GLOBALSINDEX, "debug");
+  if (!lua_istable(L, -1)) {
+    lua_pop(L, 1);
+    return 1;
+  }
+  lua_getfield(L, -1, "traceback");
+  if (!lua_isfunction(L, -1)) {
+    lua_pop(L, 2);
+    return 1;
+  }
+  lua_pushvalue(L, 1);  /* pass error message */
+  lua_pushinteger(L, 2);  /* skip this function and traceback */
+  lua_call(L, 2, 1);  /* call debug.traceback */
+  return 1;
+}
+
+
+static int docall (lua_State *L, int narg, int clear) {
+  int status;
+  int base = lua_gettop(L) - narg;  /* function index */
+  lua_pushcfunction(L, traceback);  /* push traceback function */
+  lua_insert(L, base);  /* put it under chunk and args */
+  signal(SIGINT, laction);
+  status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
+  signal(SIGINT, SIG_DFL);
+  lua_remove(L, base);  /* remove traceback function */
+  /* force a complete garbage collection in case of errors */
+  if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0);
+  return status;
+}
+
+
+static void print_version (void) {
+  l_message(NULL, LUA_RELEASE "  " LUA_COPYRIGHT);
+  l_message(NULL, LUAJIT_VERSION "  " LUAJIT_COPYRIGHT ", " LUAJIT_URL);
+}
+
+
+static int getargs (lua_State *L, char **argv, int n) {
+  int narg;
+  int i;
+  int argc = 0;
+  while (argv[argc]) argc++;  /* count total number of arguments */
+  narg = argc - (n + 1);  /* number of arguments to the script */
+  luaL_checkstack(L, narg + 3, "too many arguments to script");
+  for (i=n+1; i < argc; i++)
+    lua_pushstring(L, argv[i]);
+  lua_createtable(L, narg, n + 1);
+  for (i=0; i < argc; i++) {
+    lua_pushstring(L, argv[i]);
+    lua_rawseti(L, -2, i - n);
+  }
+  return narg;
+}
+
+
+static int dofile (lua_State *L, const char *name) {
+  int status = luaL_loadfile(L, name) || docall(L, 0, 1);
+  return report(L, status);
+}
+
+
+static int dostring (lua_State *L, const char *s, const char *name) {
+  int status = luaL_loadbuffer(L, s, strlen(s), name) || docall(L, 0, 1);
+  return report(L, status);
+}
+
+
+static int dolibrary (lua_State *L, const char *name) {
+  lua_getglobal(L, "require");
+  lua_pushstring(L, name);
+  return report(L, docall(L, 1, 1));
+}
+
+
+static const char *get_prompt (lua_State *L, int firstline) {
+  const char *p;
+  lua_getfield(L, LUA_GLOBALSINDEX, firstline ? "_PROMPT" : "_PROMPT2");
+  p = lua_tostring(L, -1);
+  if (p == NULL) p = (firstline ? LUA_PROMPT : LUA_PROMPT2);
+  lua_pop(L, 1);  /* remove global */
+  return p;
+}
+
+
+static int incomplete (lua_State *L, int status) {
+  if (status == LUA_ERRSYNTAX) {
+    size_t lmsg;
+    const char *msg = lua_tolstring(L, -1, &lmsg);
+    const char *tp = msg + lmsg - (sizeof(LUA_QL("<eof>")) - 1);
+    if (strstr(msg, LUA_QL("<eof>")) == tp) {
+      lua_pop(L, 1);
+      return 1;
+    }
+  }
+  return 0;  /* else... */
+}
+
+
+static int pushline (lua_State *L, int firstline) {
+  char buffer[LUA_MAXINPUT];
+  char *b = buffer;
+  size_t l;
+  const char *prmt = get_prompt(L, firstline);
+  if (lua_readline(L, b, prmt) == 0)
+    return 0;  /* no input */
+  l = strlen(b);
+  if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
+    b[l-1] = '\0';  /* remove it */
+  if (firstline && b[0] == '=')  /* first line starts with `=' ? */
+    lua_pushfstring(L, "return %s", b+1);  /* change it to `return' */
+  else
+    lua_pushstring(L, b);
+  lua_freeline(L, b);
+  return 1;
+}
+
+
+static int loadline (lua_State *L) {
+  int status;
+  lua_settop(L, 0);
+  if (!pushline(L, 1))
+    return -1;  /* no input */
+  for (;;) {  /* repeat until gets a complete line */
+    status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
+    if (!incomplete(L, status)) break;  /* cannot try to add lines? */
+    if (!pushline(L, 0))  /* no more input? */
+      return -1;
+    lua_pushliteral(L, "\n");  /* add a new line... */
+    lua_insert(L, -2);  /* ...between the two lines */
+    lua_concat(L, 3);  /* join them */
+  }
+  lua_saveline(L, 1);
+  lua_remove(L, 1);  /* remove line */
+  return status;
+}
+
+
+static void dotty (lua_State *L) {
+  int status;
+  const char *oldprogname = progname;
+  progname = NULL;
+  while ((status = loadline(L)) != -1) {
+    if (status == 0) status = docall(L, 0, 0);
+    report(L, status);
+    if (status == 0 && lua_gettop(L) > 0) {  /* any result to print? */
+      lua_getglobal(L, "print");
+      lua_insert(L, 1);
+      if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)
+        l_message(progname, lua_pushfstring(L,
+                               "error calling " LUA_QL("print") " (%s)",
+                               lua_tostring(L, -1)));
+    }
+  }
+  lua_settop(L, 0);  /* clear stack */
+  fputs("\n", stdout);
+  fflush(stdout);
+  progname = oldprogname;
+}
+
+
+static int handle_script (lua_State *L, char **argv, int n) {
+  int status;
+  const char *fname;
+  int narg = getargs(L, argv, n);  /* collect arguments */
+  lua_setglobal(L, "arg");
+  fname = argv[n];
+  if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0) 
+    fname = NULL;  /* stdin */
+  status = luaL_loadfile(L, fname);
+  lua_insert(L, -(narg+1));
+  if (status == 0)
+    status = docall(L, narg, 0);
+  else
+    lua_pop(L, narg);      
+  return report(L, status);
+}
+
+/* ---- start of LuaJIT extensions */
+
+static int loadjitmodule (lua_State *L, const char *notfound) {
+  lua_getglobal(L, "require");
+  lua_pushliteral(L, "jit.");
+  lua_pushvalue(L, -3);
+  lua_concat(L, 2);
+  if (lua_pcall(L, 1, 1, 0)) {
+    const char *msg = lua_tostring(L, -1);
+    if (msg && !strncmp(msg, "module ", 7)) {
+      l_message(progname, notfound);
+      return 1;
+    }
+    else
+      return report(L, 1);
+  }
+  lua_getfield(L, -1, "start");
+  lua_remove(L, -2);  /* drop module table */
+  return 0;
+}
+
+/* JIT engine control command: try jit library first or load add-on module */
+static int dojitcmd (lua_State *L, const char *cmd) {
+  const char *val = strchr(cmd, '=');
+  lua_pushlstring(L, cmd, val ? val - cmd : strlen(cmd));
+  lua_getglobal(L, "jit");  /* get jit.* table */
+  lua_pushvalue(L, -2);
+  lua_gettable(L, -2);  /* lookup library function */
+  if (!lua_isfunction(L, -1)) {
+    lua_pop(L, 2);  /* drop non-function and jit.* table, keep module name */
+    if (loadjitmodule(L, "unknown luaJIT command"))
+      return 1;
+  }
+  else {
+    lua_remove(L, -2);  /* drop jit.* table */
+  }
+  lua_remove(L, -2);  /* drop module name */
+  if (val) lua_pushstring(L, val+1);
+  return report(L, lua_pcall(L, val ? 1 : 0, 0, 0));
+}
+
+/* start optimizer */
+static int dojitopt (lua_State *L, const char *opt) {
+  lua_pushliteral(L, "opt");
+  if (loadjitmodule(L, "LuaJIT optimizer module not installed"))
+    return 1;
+  lua_remove(L, -2);  /* drop module name */
+  if (*opt) lua_pushstring(L, opt);
+  return report(L, lua_pcall(L, *opt ? 1 : 0, 0, 0));
+}
+
+/* ---- end of LuaJIT extensions */
+
+/* check that argument has no extra characters at the end */
+#define notail(x)       {if ((x)[2] != '\0') return -1;}
+
+
+static int collectargs (char **argv, int *pi, int *pv, int *pe) {
+  int i;
+  for (i = 1; argv[i] != NULL; i++) {
+    if (argv[i][0] != '-')  /* not an option? */
+        return i;
+    switch (argv[i][1]) {  /* option */
+      case '-':
+        notail(argv[i]);
+        return (argv[i+1] != NULL ? i+1 : 0);
+      case '\0':
+        return i;
+      case 'i':
+        notail(argv[i]);
+        *pi = 1;  /* go through */
+      case 'v':
+        notail(argv[i]);
+        *pv = 1;
+        break;
+      case 'e':
+        *pe = 1;  /* go through */
+      case 'j':  /* LuaJIT extension */
+      case 'l':
+        if (argv[i][2] == '\0') {
+          i++;
+          if (argv[i] == NULL) return -1;
+        }
+        break;
+      case 'O': break;  /* LuaJIT extension */
+      default: return -1;  /* invalid option */
+    }
+  }
+  return 0;
+}
+
+
+static int runargs (lua_State *L, char **argv, int n) {
+  int i;
+  for (i = 1; i < n; i++) {
+    if (argv[i] == NULL) continue;
+    lua_assert(argv[i][0] == '-');
+    switch (argv[i][1]) {  /* option */
+      case 'e': {
+        const char *chunk = argv[i] + 2;
+        if (*chunk == '\0') chunk = argv[++i];
+        lua_assert(chunk != NULL);
+        if (dostring(L, chunk, "=(command line)") != 0)
+          return 1;
+        break;
+      }
+      case 'l': {
+        const char *filename = argv[i] + 2;
+        if (*filename == '\0') filename = argv[++i];
+        lua_assert(filename != NULL);
+        if (dolibrary(L, filename))
+          return 1;  /* stop if file fails */
+        break;
+      }
+      case 'j': {  /* LuaJIT extension */
+        const char *cmd = argv[i] + 2;
+        if (*cmd == '\0') cmd = argv[++i];
+        lua_assert(cmd != NULL);
+        if (dojitcmd(L, cmd))
+          return 1;
+        break;
+      }
+      case 'O':  /* LuaJIT extension */
+        if (dojitopt(L, argv[i] + 2))
+          return 1;
+        break;
+      default: break;
+    }
+  }
+  return 0;
+}
+
+
+static int handle_luainit (lua_State *L) {
+  const char *init = getenv(LUA_INIT);
+  if (init == NULL) return 0;  /* status OK */
+  else if (init[0] == '@')
+    return dofile(L, init+1);
+  else
+    return dostring(L, init, "=" LUA_INIT);
+}
+
+
+struct Smain {
+  int argc;
+  char **argv;
+  int status;
+};
+
+
+static int pmain (lua_State *L) {
+  struct Smain *s = (struct Smain *)lua_touserdata(L, 1);
+  char **argv = s->argv;
+  int script;
+  int has_i = 0, has_v = 0, has_e = 0;
+  globalL = L;
+  if (argv[0] && argv[0][0]) progname = argv[0];
+  LUAJIT_VERSION_SYM();  /* linker-enforced version check */
+  lua_gc(L, LUA_GCSTOP, 0);  /* stop collector during initialization */
+  luaL_openlibs(L);  /* open libraries */
+  lua_gc(L, LUA_GCRESTART, 0);
+  s->status = handle_luainit(L);
+  if (s->status != 0) return 0;
+  script = collectargs(argv, &has_i, &has_v, &has_e);
+  if (script < 0) {  /* invalid args? */
+    print_usage();
+    s->status = 1;
+    return 0;
+  }
+  if (has_v) print_version();
+  s->status = runargs(L, argv, (script > 0) ? script : s->argc);
+  if (s->status != 0) return 0;
+  if (script)
+    s->status = handle_script(L, argv, script);
+  if (s->status != 0) return 0;
+  if (has_i)
+    dotty(L);
+  else if (script == 0 && !has_e && !has_v) {
+    if (lua_stdin_is_tty()) {
+      print_version();
+      dotty(L);
+    }
+    else dofile(L, NULL);  /* executes stdin as a file */
+  }
+  return 0;
+}
+
+
+int main (int argc, char **argv) {
+  int status;
+  struct Smain s;
+  lua_State *L = lua_open();  /* create state */
+  if (L == NULL) {
+    l_message(argv[0], "cannot create state: not enough memory");
+    return EXIT_FAILURE;
+  }
+  s.argc = argc;
+  s.argv = argv;
+  status = lua_cpcall(L, &pmain, &s);
+  report(L, status);
+  lua_close(L);
+  return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lua.h b/libraries/LuaJIT-1.1.7/src/lua.h
new file mode 100644
index 0000000..7d6ee45
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lua.h
@@ -0,0 +1,385 @@
+/*
+** $Id: lua.h,v 1.218.1.5 2008/08/06 13:30:12 roberto Exp $
+** Lua - An Extensible Extension Language
+** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
+** See Copyright Notice at the end of this file
+*/
+
+
+#ifndef lua_h
+#define lua_h
+
+#include <stdarg.h>
+#include <stddef.h>
+
+
+#include "luaconf.h"
+
+
+#define LUA_VERSION     "Lua 5.1"
+#define LUA_RELEASE     "Lua 5.1.4"
+#define LUA_VERSION_NUM 501
+#define LUA_COPYRIGHT   "Copyright (C) 1994-2008 Lua.org, PUC-Rio"
+#define LUA_AUTHORS     "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
+
+
+/* mark for precompiled code (`<esc>Lua') */
+#define LUA_SIGNATURE   "\033Lua"
+
+/* option for multiple returns in `lua_pcall' and `lua_call' */
+#define LUA_MULTRET     (-1)
+
+
+/*
+** pseudo-indices
+*/
+#define LUA_REGISTRYINDEX       (-10000)
+#define LUA_ENVIRONINDEX        (-10001)
+#define LUA_GLOBALSINDEX        (-10002)
+#define lua_upvalueindex(i)     (LUA_GLOBALSINDEX-(i))
+
+
+/* thread status; 0 is OK */
+#define LUA_YIELD       1
+#define LUA_ERRRUN      2
+#define LUA_ERRSYNTAX   3
+#define LUA_ERRMEM      4
+#define LUA_ERRERR      5
+
+
+typedef struct lua_State lua_State;
+
+typedef int (*lua_CFunction) (lua_State *L);
+
+
+/*
+** functions that read/write blocks when loading/dumping Lua chunks
+*/
+typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
+
+typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud);
+
+
+/*
+** prototype for memory-allocation functions
+*/
+typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
+
+
+/*
+** basic types
+*/
+#define LUA_TNONE               (-1)
+
+#define LUA_TNIL                0
+#define LUA_TBOOLEAN            1
+#define LUA_TLIGHTUSERDATA      2
+#define LUA_TNUMBER             3
+#define LUA_TSTRING             4
+#define LUA_TTABLE              5
+#define LUA_TFUNCTION           6
+#define LUA_TUSERDATA           7
+#define LUA_TTHREAD             8
+
+
+
+/* minimum Lua stack available to a C function */
+#define LUA_MINSTACK    20
+
+
+/*
+** generic extra include file
+*/
+#if defined(LUA_USER_H)
+#include LUA_USER_H
+#endif
+
+
+/* type of numbers in Lua */
+typedef LUA_NUMBER lua_Number;
+
+
+/* type for integer functions */
+typedef LUA_INTEGER lua_Integer;
+
+
+
+/*
+** state manipulation
+*/
+LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
+LUA_API void       (lua_close) (lua_State *L);
+LUA_API lua_State *(lua_newthread) (lua_State *L);
+
+LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
+
+
+/*
+** basic stack manipulation
+*/
+LUA_API int   (lua_gettop) (lua_State *L);
+LUA_API void  (lua_settop) (lua_State *L, int idx);
+LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
+LUA_API void  (lua_remove) (lua_State *L, int idx);
+LUA_API void  (lua_insert) (lua_State *L, int idx);
+LUA_API void  (lua_replace) (lua_State *L, int idx);
+LUA_API int   (lua_checkstack) (lua_State *L, int sz);
+
+LUA_API void  (lua_xmove) (lua_State *from, lua_State *to, int n);
+
+
+/*
+** access functions (stack -> C)
+*/
+
+LUA_API int             (lua_isnumber) (lua_State *L, int idx);
+LUA_API int             (lua_isstring) (lua_State *L, int idx);
+LUA_API int             (lua_iscfunction) (lua_State *L, int idx);
+LUA_API int             (lua_isuserdata) (lua_State *L, int idx);
+LUA_API int             (lua_type) (lua_State *L, int idx);
+LUA_API const char     *(lua_typename) (lua_State *L, int tp);
+
+LUA_API int            (lua_equal) (lua_State *L, int idx1, int idx2);
+LUA_API int            (lua_rawequal) (lua_State *L, int idx1, int idx2);
+LUA_API int            (lua_lessthan) (lua_State *L, int idx1, int idx2);
+
+LUA_API lua_Number      (lua_tonumber) (lua_State *L, int idx);
+LUA_API lua_Integer     (lua_tointeger) (lua_State *L, int idx);
+LUA_API int             (lua_toboolean) (lua_State *L, int idx);
+LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
+LUA_API size_t          (lua_objlen) (lua_State *L, int idx);
+LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);
+LUA_API void           *(lua_touserdata) (lua_State *L, int idx);
+LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);
+LUA_API const void     *(lua_topointer) (lua_State *L, int idx);
+
+
+/*
+** push functions (C -> stack)
+*/
+LUA_API void  (lua_pushnil) (lua_State *L);
+LUA_API void  (lua_pushnumber) (lua_State *L, lua_Number n);
+LUA_API void  (lua_pushinteger) (lua_State *L, lua_Integer n);
+LUA_API void  (lua_pushlstring) (lua_State *L, const char *s, size_t l);
+LUA_API void  (lua_pushstring) (lua_State *L, const char *s);
+LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
+                                                      va_list argp);
+LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
+LUA_API void  (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
+LUA_API void  (lua_pushboolean) (lua_State *L, int b);
+LUA_API void  (lua_pushlightuserdata) (lua_State *L, void *p);
+LUA_API int   (lua_pushthread) (lua_State *L);
+
+
+/*
+** get functions (Lua -> stack)
+*/
+LUA_API void  (lua_gettable) (lua_State *L, int idx);
+LUA_API void  (lua_getfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_rawget) (lua_State *L, int idx);
+LUA_API void  (lua_rawgeti) (lua_State *L, int idx, int n);
+LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
+LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
+LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
+LUA_API void  (lua_getfenv) (lua_State *L, int idx);
+
+
+/*
+** set functions (stack -> Lua)
+*/
+LUA_API void  (lua_settable) (lua_State *L, int idx);
+LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_rawset) (lua_State *L, int idx);
+LUA_API void  (lua_rawseti) (lua_State *L, int idx, int n);
+LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
+LUA_API int   (lua_setfenv) (lua_State *L, int idx);
+
+
+/*
+** `load' and `call' functions (load and run Lua code)
+*/
+LUA_API void  (lua_call) (lua_State *L, int nargs, int nresults);
+LUA_API int   (lua_pcall) (lua_State *L, int nargs, int nresults, int errfunc);
+LUA_API int   (lua_cpcall) (lua_State *L, lua_CFunction func, void *ud);
+LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
+                                        const char *chunkname);
+
+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
+
+
+/*
+** coroutine functions
+*/
+LUA_API int  (lua_yield) (lua_State *L, int nresults);
+LUA_API int  (lua_resume) (lua_State *L, int narg);
+LUA_API int  (lua_status) (lua_State *L);
+
+/*
+** garbage-collection function and options
+*/
+
+#define LUA_GCSTOP              0
+#define LUA_GCRESTART           1
+#define LUA_GCCOLLECT           2
+#define LUA_GCCOUNT             3
+#define LUA_GCCOUNTB            4
+#define LUA_GCSTEP              5
+#define LUA_GCSETPAUSE          6
+#define LUA_GCSETSTEPMUL        7
+
+LUA_API int (lua_gc) (lua_State *L, int what, int data);
+
+
+/*
+** miscellaneous functions
+*/
+
+LUA_API int   (lua_error) (lua_State *L);
+
+LUA_API int   (lua_next) (lua_State *L, int idx);
+
+LUA_API void  (lua_concat) (lua_State *L, int n);
+
+LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
+LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
+
+
+
+/* 
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define lua_pop(L,n)            lua_settop(L, -(n)-1)
+
+#define lua_newtable(L)         lua_createtable(L, 0, 0)
+
+#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+
+#define lua_pushcfunction(L,f)  lua_pushcclosure(L, (f), 0)
+
+#define lua_strlen(L,i)         lua_objlen(L, (i))
+
+#define lua_isfunction(L,n)     (lua_type(L, (n)) == LUA_TFUNCTION)
+#define lua_istable(L,n)        (lua_type(L, (n)) == LUA_TTABLE)
+#define lua_islightuserdata(L,n)        (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
+#define lua_isnil(L,n)          (lua_type(L, (n)) == LUA_TNIL)
+#define lua_isboolean(L,n)      (lua_type(L, (n)) == LUA_TBOOLEAN)
+#define lua_isthread(L,n)       (lua_type(L, (n)) == LUA_TTHREAD)
+#define lua_isnone(L,n)         (lua_type(L, (n)) == LUA_TNONE)
+#define lua_isnoneornil(L, n)   (lua_type(L, (n)) <= 0)
+
+#define lua_pushliteral(L, s)   \
+        lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
+
+#define lua_setglobal(L,s)      lua_setfield(L, LUA_GLOBALSINDEX, (s))
+#define lua_getglobal(L,s)      lua_getfield(L, LUA_GLOBALSINDEX, (s))
+
+#define lua_tostring(L,i)       lua_tolstring(L, (i), NULL)
+
+
+
+/*
+** compatibility macros and functions
+*/
+
+#define lua_open()      luaL_newstate()
+
+#define lua_getregistry(L)      lua_pushvalue(L, LUA_REGISTRYINDEX)
+
+#define lua_getgccount(L)       lua_gc(L, LUA_GCCOUNT, 0)
+
+#define lua_Chunkreader         lua_Reader
+#define lua_Chunkwriter         lua_Writer
+
+
+
+/*
+** {======================================================================
+** Debug API
+** =======================================================================
+*/
+
+
+/*
+** Event codes
+*/
+#define LUA_HOOKCALL    0
+#define LUA_HOOKRET     1
+#define LUA_HOOKLINE    2
+#define LUA_HOOKCOUNT   3
+#define LUA_HOOKTAILRET 4
+
+
+/*
+** Event masks
+*/
+#define LUA_MASKCALL    (1 << LUA_HOOKCALL)
+#define LUA_MASKRET     (1 << LUA_HOOKRET)
+#define LUA_MASKLINE    (1 << LUA_HOOKLINE)
+#define LUA_MASKCOUNT   (1 << LUA_HOOKCOUNT)
+
+typedef struct lua_Debug lua_Debug;  /* activation record */
+
+
+/* Functions to be called by the debuger in specific events */
+typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
+
+
+LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar);
+LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
+LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n);
+LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n);
+
+LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count);
+LUA_API lua_Hook lua_gethook (lua_State *L);
+LUA_API int lua_gethookmask (lua_State *L);
+LUA_API int lua_gethookcount (lua_State *L);
+
+
+struct lua_Debug {
+  int event;
+  const char *name;     /* (n) */
+  const char *namewhat; /* (n) `global', `local', `field', `method' */
+  const char *what;     /* (S) `Lua', `C', `main', `tail' */
+  const char *source;   /* (S) */
+  int currentline;      /* (l) */
+  int nups;             /* (u) number of upvalues */
+  int linedefined;      /* (S) */
+  int lastlinedefined;  /* (S) */
+  char short_src[LUA_IDSIZE]; /* (S) */
+  /* private part */
+  int i_ci;  /* active function */
+};
+
+/* }====================================================================== */
+
+
+/******************************************************************************
+* Copyright (C) 1994-2008 Lua.org, PUC-Rio.  All rights reserved.
+*
+* 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.
+******************************************************************************/
+
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/luac.c b/libraries/LuaJIT-1.1.7/src/luac.c
new file mode 100644
index 0000000..d070173
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/luac.c
@@ -0,0 +1,200 @@
+/*
+** $Id: luac.c,v 1.54 2006/06/02 17:37:11 lhf Exp $
+** Lua compiler (saves bytecodes to files; also list bytecodes)
+** See Copyright Notice in lua.h
+*/
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define luac_c
+#define LUA_CORE
+
+#include "lua.h"
+#include "lauxlib.h"
+
+#include "ldo.h"
+#include "lfunc.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lstring.h"
+#include "lundump.h"
+
+#define PROGNAME        "luac"          /* default program name */
+#define OUTPUT          PROGNAME ".out" /* default output file */
+
+static int listing=0;                   /* list bytecodes? */
+static int dumping=1;                   /* dump bytecodes? */
+static int stripping=0;                 /* strip debug information? */
+static char Output[]={ OUTPUT };        /* default output file name */
+static const char* output=Output;       /* actual output file name */
+static const char* progname=PROGNAME;   /* actual program name */
+
+static void fatal(const char* message)
+{
+ fprintf(stderr,"%s: %s\n",progname,message);
+ exit(EXIT_FAILURE);
+}
+
+static void cannot(const char* what)
+{
+ fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno));
+ exit(EXIT_FAILURE);
+}
+
+static void usage(const char* message)
+{
+ if (*message=='-')
+  fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message);
+ else
+  fprintf(stderr,"%s: %s\n",progname,message);
+ fprintf(stderr,
+ "usage: %s [options] [filenames].\n"
+ "Available options are:\n"
+ "  -        process stdin\n"
+ "  -l       list\n"
+ "  -o name  output to file " LUA_QL("name") " (default is \"%s\")\n"
+ "  -p       parse only\n"
+ "  -s       strip debug information\n"
+ "  -v       show version information\n"
+ "  --       stop handling options\n",
+ progname,Output);
+ exit(EXIT_FAILURE);
+}
+
+#define IS(s)   (strcmp(argv[i],s)==0)
+
+static int doargs(int argc, char* argv[])
+{
+ int i;
+ int version=0;
+ if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0];
+ for (i=1; i<argc; i++)
+ {
+  if (*argv[i]!='-')                    /* end of options; keep it */
+   break;
+  else if (IS("--"))                    /* end of options; skip it */
+  {
+   ++i;
+   if (version) ++version;
+   break;
+  }
+  else if (IS("-"))                     /* end of options; use stdin */
+   break;
+  else if (IS("-l"))                    /* list */
+   ++listing;
+  else if (IS("-o"))                    /* output file */
+  {
+   output=argv[++i];
+   if (output==NULL || *output==0) usage(LUA_QL("-o") " needs argument");
+   if (IS("-")) output=NULL;
+  }
+  else if (IS("-p"))                    /* parse only */
+   dumping=0;
+  else if (IS("-s"))                    /* strip debug information */
+   stripping=1;
+  else if (IS("-v"))                    /* show version */
+   ++version;
+  else                                  /* unknown option */
+   usage(argv[i]);
+ }
+ if (i==argc && (listing || !dumping))
+ {
+  dumping=0;
+  argv[--i]=Output;
+ }
+ if (version)
+ {
+  printf("%s  %s\n",LUA_RELEASE,LUA_COPYRIGHT);
+  if (version==argc-1) exit(EXIT_SUCCESS);
+ }
+ return i;
+}
+
+#define toproto(L,i) (clvalue(L->top+(i))->l.p)
+
+static const Proto* combine(lua_State* L, int n)
+{
+ if (n==1)
+  return toproto(L,-1);
+ else
+ {
+  int i,pc;
+  Proto* f=luaF_newproto(L);
+  setptvalue2s(L,L->top,f); incr_top(L);
+  f->source=luaS_newliteral(L,"=(" PROGNAME ")");
+  f->maxstacksize=1;
+  pc=2*n+1;
+  f->code=luaM_newvector(L,pc,Instruction);
+  f->sizecode=pc;
+  f->p=luaM_newvector(L,n,Proto*);
+  f->sizep=n;
+  pc=0;
+  for (i=0; i<n; i++)
+  {
+   f->p[i]=toproto(L,i-n-1);
+   f->code[pc++]=CREATE_ABx(OP_CLOSURE,0,i);
+   f->code[pc++]=CREATE_ABC(OP_CALL,0,1,1);
+  }
+  f->code[pc++]=CREATE_ABC(OP_RETURN,0,1,0);
+  return f;
+ }
+}
+
+static int writer(lua_State* L, const void* p, size_t size, void* u)
+{
+ UNUSED(L);
+ return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0);
+}
+
+struct Smain {
+ int argc;
+ char** argv;
+};
+
+static int pmain(lua_State* L)
+{
+ struct Smain* s = (struct Smain*)lua_touserdata(L, 1);
+ int argc=s->argc;
+ char** argv=s->argv;
+ const Proto* f;
+ int i;
+ if (!lua_checkstack(L,argc)) fatal("too many input files");
+ for (i=0; i<argc; i++)
+ {
+  const char* filename=IS("-") ? NULL : argv[i];
+  if (luaL_loadfile(L,filename)!=0) fatal(lua_tostring(L,-1));
+ }
+ f=combine(L,argc);
+ if (listing) luaU_print(f,listing>1);
+ if (dumping)
+ {
+  FILE* D= (output==NULL) ? stdout : fopen(output,"wb");
+  if (D==NULL) cannot("open");
+  lua_lock(L);
+  luaU_dump(L,f,writer,D,stripping);
+  lua_unlock(L);
+  if (ferror(D)) cannot("write");
+  if (fclose(D)) cannot("close");
+ }
+ return 0;
+}
+
+int main(int argc, char* argv[])
+{
+ lua_State* L;
+ struct Smain s;
+ int i=doargs(argc,argv);
+ argc-=i; argv+=i;
+ if (argc<=0) usage("no input files given");
+ L=lua_open();
+ if (L==NULL) fatal("not enough memory for state");
+ s.argc=argc;
+ s.argv=argv;
+ if (lua_cpcall(L,pmain,&s)!=0) fatal(lua_tostring(L,-1));
+ lua_close(L);
+ return EXIT_SUCCESS;
+}
diff --git a/libraries/LuaJIT-1.1.7/src/luaconf.h b/libraries/LuaJIT-1.1.7/src/luaconf.h
new file mode 100644
index 0000000..35a6bd1
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/luaconf.h
@@ -0,0 +1,786 @@
+/*
+** $Id: luaconf.h,v 1.82.1.7 2008/02/11 16:25:08 roberto Exp $
+** Configuration file for Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lconfig_h
+#define lconfig_h
+
+#include <limits.h>
+#include <stddef.h>
+
+
+/*
+** ==================================================================
+** Search for "@@" to find all configurable definitions.
+** ===================================================================
+*/
+
+
+/*
+@@ LUA_ANSI controls the use of non-ansi features.
+** CHANGE it (define it) if you want Lua to avoid the use of any
+** non-ansi feature or library.
+*/
+#if defined(__STRICT_ANSI__)
+#define LUA_ANSI
+#endif
+
+
+#if !defined(LUA_ANSI) && defined(_WIN32)
+#define LUA_WIN
+#endif
+
+#if defined(LUA_USE_LINUX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN          /* needs an extra library: -ldl */
+/* #define LUA_USE_READLINE */  /* needs some extra libraries */
+#endif
+
+#if defined(LUA_USE_MACOSX)
+#define LUA_USE_POSIX
+#define LUA_DL_DYLD             /* does not need extra library */
+#endif
+
+
+
+/*
+@@ LUA_USE_POSIX includes all functionallity listed as X/Open System
+@* Interfaces Extension (XSI).
+** CHANGE it (define it) if your system is XSI compatible.
+*/
+#if defined(LUA_USE_POSIX)
+#define LUA_USE_MKSTEMP
+#define LUA_USE_ISATTY
+#define LUA_USE_POPEN
+#define LUA_USE_ULONGJMP
+#endif
+
+
+/*
+@@ LUA_PATH and LUA_CPATH are the names of the environment variables that
+@* Lua check to set its paths.
+@@ LUA_INIT is the name of the environment variable that Lua
+@* checks for initialization code.
+** CHANGE them if you want different names.
+*/
+#define LUA_PATH        "LUA_PATH"
+#define LUA_CPATH       "LUA_CPATH"
+#define LUA_INIT        "LUA_INIT"
+
+
+/*
+@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
+@* Lua libraries.
+@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
+@* C libraries.
+** CHANGE them if your machine has a non-conventional directory
+** hierarchy or if you want to install your libraries in
+** non-conventional directories.
+*/
+#if defined(_WIN32)
+/*
+** In Windows, any exclamation mark ('!') in the path is replaced by the
+** path of the directory of the executable file of the current process.
+*/
+#define LUA_LDIR        "!\\lua\\"
+#define LUA_CDIR        "!\\"
+#define LUA_PATH_DEFAULT  \
+                ".\\?.lua;"  LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
+                             LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua"
+#define LUA_CPATH_DEFAULT \
+        ".\\?.dll;"  LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll"
+
+#else
+#define LUA_ROOT        "/usr/local/"
+#define LUA_LDIR        LUA_ROOT "share/lua/5.1/"
+#define LUA_CDIR        LUA_ROOT "lib/lua/5.1/"
+#define LUA_PATH_DEFAULT  \
+                "./?.lua;"  LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
+                            LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua"
+#define LUA_CPATH_DEFAULT \
+        "./?.so;"  LUA_CDIR"?.so;" LUA_CDIR"loadall.so"
+#endif
+
+
+/*
+@@ LUA_DIRSEP is the directory separator (for submodules).
+** CHANGE it if your machine does not use "/" as the directory separator
+** and is not Windows. (On Windows Lua automatically uses "\".)
+*/
+#if defined(_WIN32)
+#define LUA_DIRSEP      "\\"
+#else
+#define LUA_DIRSEP      "/"
+#endif
+
+
+/*
+@@ LUA_PATHSEP is the character that separates templates in a path.
+@@ LUA_PATH_MARK is the string that marks the substitution points in a
+@* template.
+@@ LUA_EXECDIR in a Windows path is replaced by the executable's
+@* directory.
+@@ LUA_IGMARK is a mark to ignore all before it when bulding the
+@* luaopen_ function name.
+** CHANGE them if for some reason your system cannot use those
+** characters. (E.g., if one of those characters is a common character
+** in file/directory names.) Probably you do not need to change them.
+*/
+#define LUA_PATHSEP     ";"
+#define LUA_PATH_MARK   "?"
+#define LUA_EXECDIR     "!"
+#define LUA_IGMARK      "-"
+
+
+/*
+@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.
+** CHANGE that if ptrdiff_t is not adequate on your machine. (On most
+** machines, ptrdiff_t gives a good choice between int or long.)
+*/
+#define LUA_INTEGER     ptrdiff_t
+
+
+/*
+@@ LUA_API is a mark for all core API functions.
+@@ LUALIB_API is a mark for all standard library functions.
+** CHANGE them if you need to define those functions in some special way.
+** For instance, if you want to create one Windows DLL with the core and
+** the libraries, you may want to use the following definition (define
+** LUA_BUILD_AS_DLL to get it).
+*/
+#if defined(LUA_BUILD_AS_DLL)
+
+#if defined(LUA_CORE) || defined(LUA_LIB)
+#define LUA_API __declspec(dllexport)
+#else
+#define LUA_API __declspec(dllimport)
+#endif
+
+#else
+
+#define LUA_API         extern
+
+#endif
+
+/* more often than not the libs go together with the core */
+#define LUALIB_API      LUA_API
+
+
+/*
+@@ LUAI_FUNC is a mark for all extern functions that are not to be
+@* exported to outside modules.
+@@ LUAI_DATA is a mark for all extern (const) variables that are not to
+@* be exported to outside modules.
+** CHANGE them if you need to mark them in some special way. Elf/gcc
+** (versions 3.2 and later) mark them as "hidden" to optimize access
+** when Lua is compiled as a shared library.
+*/
+#if defined(luaall_c)
+#define LUAI_FUNC       static
+#define LUAI_DATA       /* empty */
+
+#elif defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
+      defined(__ELF__)
+#define LUAI_FUNC       __attribute__((visibility("hidden"))) extern
+#define LUAI_DATA       LUAI_FUNC
+
+#else
+#define LUAI_FUNC       extern
+#define LUAI_DATA       extern
+#endif
+
+
+
+/*
+@@ LUA_QL describes how error messages quote program elements.
+** CHANGE it if you want a different appearance.
+*/
+#define LUA_QL(x)       "'" x "'"
+#define LUA_QS          LUA_QL("%s")
+
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@* of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+#define LUA_IDSIZE      60
+
+
+/*
+** {==================================================================
+** Stand-alone configuration
+** ===================================================================
+*/
+
+#if defined(lua_c) || defined(luaall_c)
+
+/*
+@@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that
+@* is, whether we're running lua interactively).
+** CHANGE it if you have a better definition for non-POSIX/non-Windows
+** systems.
+*/
+#if defined(LUA_USE_ISATTY)
+#include <unistd.h>
+#define lua_stdin_is_tty()      isatty(0)
+#elif defined(LUA_WIN)
+#include <io.h>
+#include <stdio.h>
+#define lua_stdin_is_tty()      _isatty(_fileno(stdin))
+#else
+#define lua_stdin_is_tty()      1  /* assume stdin is a tty */
+#endif
+
+
+/*
+@@ LUA_PROMPT is the default prompt used by stand-alone Lua.
+@@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua.
+** CHANGE them if you want different prompts. (You can also change the
+** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.)
+*/
+#define LUA_PROMPT              "> "
+#define LUA_PROMPT2             ">> "
+
+
+/*
+@@ LUA_PROGNAME is the default name for the stand-alone Lua program.
+** CHANGE it if your stand-alone interpreter has a different name and
+** your system is not able to detect that name automatically.
+*/
+#define LUA_PROGNAME            "luajit"
+
+
+/*
+@@ LUA_MAXINPUT is the maximum length for an input line in the
+@* stand-alone interpreter.
+** CHANGE it if you need longer lines.
+*/
+#define LUA_MAXINPUT    512
+
+
+/*
+@@ lua_readline defines how to show a prompt and then read a line from
+@* the standard input.
+@@ lua_saveline defines how to "save" a read line in a "history".
+@@ lua_freeline defines how to free a line read by lua_readline.
+** CHANGE them if you want to improve this functionality (e.g., by using
+** GNU readline and history facilities).
+*/
+#if defined(LUA_USE_READLINE)
+#include <stdio.h>
+#include <readline/readline.h>
+#include <readline/history.h>
+#define lua_readline(L,b,p)     ((void)L, ((b)=readline(p)) != NULL)
+#define lua_saveline(L,idx) \
+        if (lua_strlen(L,idx) > 0)  /* non-empty line? */ \
+          add_history(lua_tostring(L, idx));  /* add it to history */
+#define lua_freeline(L,b)       ((void)L, free(b))
+#else
+#define lua_readline(L,b,p)     \
+        ((void)L, fputs(p, stdout), fflush(stdout),  /* show prompt */ \
+        fgets(b, LUA_MAXINPUT, stdin) != NULL)  /* get line */
+#define lua_saveline(L,idx)     { (void)L; (void)idx; }
+#define lua_freeline(L,b)       { (void)L; (void)b; }
+#endif
+
+#endif
+
+/* }================================================================== */
+
+
+/*
+@@ LUAI_GCPAUSE defines the default pause between garbage-collector cycles
+@* as a percentage.
+** CHANGE it if you want the GC to run faster or slower (higher values
+** mean larger pauses which mean slower collection.) You can also change
+** this value dynamically.
+*/
+#define LUAI_GCPAUSE    200  /* 200% (wait memory to double before next GC) */
+
+
+/*
+@@ LUAI_GCMUL defines the default speed of garbage collection relative to
+@* memory allocation as a percentage.
+** CHANGE it if you want to change the granularity of the garbage
+** collection. (Higher values mean coarser collections. 0 represents
+** infinity, where each step performs a full collection.) You can also
+** change this value dynamically.
+*/
+#define LUAI_GCMUL      200 /* GC runs 'twice the speed' of memory allocation */
+
+
+
+/*
+@@ LUA_COMPAT_GETN controls compatibility with old getn behavior.
+** CHANGE it (define it) if you want exact compatibility with the
+** behavior of setn/getn in Lua 5.0.
+**
+** Note: this is not supported by LuaJIT. Leave it undefined.
+*/
+#undef LUA_COMPAT_GETN
+
+/*
+@@ LUA_COMPAT_LOADLIB controls compatibility about global loadlib.
+** CHANGE it to undefined as soon as you do not need a global 'loadlib'
+** function (the function is still available as 'package.loadlib').
+*/
+#undef LUA_COMPAT_LOADLIB
+
+/*
+@@ LUA_COMPAT_VARARG controls compatibility with old vararg feature.
+** CHANGE it to undefined as soon as your programs use only '...' to
+** access vararg parameters (instead of the old 'arg' table).
+**
+** Note: this has a slightly negative performance impact with LuaJIT
+** for all vararg functions. Leave it off if possible and upgrade your
+** code (replace unpack(arg) with ... and/or add local arg = {...}).
+*/
+#undef LUA_COMPAT_VARARG
+
+/*
+@@ LUA_COMPAT_MOD controls compatibility with old math.mod function.
+** CHANGE it to undefined as soon as your programs use 'math.fmod' or
+** the new '%' operator instead of 'math.mod'.
+*/
+#define LUA_COMPAT_MOD
+
+/*
+@@ LUA_COMPAT_LSTR controls compatibility with old long string nesting
+@* facility.
+** CHANGE it to 2 if you want the old behaviour, or undefine it to turn
+** off the advisory error when nesting [[...]].
+*/
+#define LUA_COMPAT_LSTR         1
+
+/*
+@@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name.
+** CHANGE it to undefined as soon as you rename 'string.gfind' to
+** 'string.gmatch'.
+*/
+#define LUA_COMPAT_GFIND
+
+/*
+@@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib'
+@* behavior.
+** CHANGE it to undefined as soon as you replace to 'luaL_register'
+** your uses of 'luaL_openlib'
+*/
+#define LUA_COMPAT_OPENLIB
+
+
+
+/*
+@@ luai_apicheck is the assert macro used by the Lua-C API.
+** CHANGE luai_apicheck if you want Lua to perform some checks in the
+** parameters it gets from API calls. This may slow down the interpreter
+** a bit, but may be quite useful when debugging C code that interfaces
+** with Lua. A useful redefinition is to use assert.h.
+*/
+#if defined(LUA_USE_APICHECK)
+#include <assert.h>
+#define luai_apicheck(L,o)      { (void)L; assert(o); }
+#else
+#define luai_apicheck(L,o)      { (void)L; }
+#endif
+
+
+/*
+@@ LUAI_BITSINT defines the number of bits in an int.
+** CHANGE here if Lua cannot automatically detect the number of bits of
+** your machine. Probably you do not need to change this.
+*/
+/* avoid overflows in comparison */
+#if INT_MAX-20 < 32760
+#define LUAI_BITSINT    16
+#elif INT_MAX > 2147483640L
+/* int has at least 32 bits */
+#define LUAI_BITSINT    32
+#else
+#error "you must define LUA_BITSINT with number of bits in an integer"
+#endif
+
+
+/*
+@@ LUAI_UINT32 is an unsigned integer with at least 32 bits.
+@@ LUAI_INT32 is an signed integer with at least 32 bits.
+@@ LUAI_UMEM is an unsigned integer big enough to count the total
+@* memory used by Lua.
+@@ LUAI_MEM is a signed integer big enough to count the total memory
+@* used by Lua.
+** CHANGE here if for some weird reason the default definitions are not
+** good enough for your machine. (The definitions in the 'else'
+** part always works, but may waste space on machines with 64-bit
+** longs.) Probably you do not need to change this.
+*/
+#if LUAI_BITSINT >= 32
+#define LUAI_UINT32     unsigned int
+#define LUAI_INT32      int
+#define LUAI_MAXINT32   INT_MAX
+#define LUAI_UMEM       size_t
+#define LUAI_MEM        ptrdiff_t
+#else
+/* 16-bit ints */
+#define LUAI_UINT32     unsigned long
+#define LUAI_INT32      long
+#define LUAI_MAXINT32   LONG_MAX
+#define LUAI_UMEM       unsigned long
+#define LUAI_MEM        long
+#endif
+
+
+/*
+@@ LUAI_MAXCALLS limits the number of nested calls.
+** CHANGE it if you need really deep recursive calls. This limit is
+** arbitrary; its only purpose is to stop infinite recursion before
+** exhausting memory.
+*/
+#define LUAI_MAXCALLS   20000
+
+
+/*
+@@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function
+@* can use.
+** CHANGE it if you need lots of (Lua) stack space for your C
+** functions. This limit is arbitrary; its only purpose is to stop C
+** functions to consume unlimited stack space. (must be smaller than
+** -LUA_REGISTRYINDEX)
+*/
+#define LUAI_MAXCSTACK  8000
+
+
+/*
+** {==================================================================
+** CHANGE (to smaller values) the following definitions if your system
+** has a small C stack. (Or you may want to change them to larger
+** values if your system has a large C stack and these limits are
+** too rigid for you.) Some of these constants control the size of
+** stack-allocated arrays used by the compiler or the interpreter, while
+** others limit the maximum number of recursive calls that the compiler
+** or the interpreter can perform. Values too large may cause a C stack
+** overflow for some forms of deep constructs.
+** ===================================================================
+*/
+
+
+/*
+@@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and
+@* syntactical nested non-terminals in a program.
+*/
+#define LUAI_MAXCCALLS          200
+
+
+/*
+@@ LUAI_MAXVARS is the maximum number of local variables per function
+@* (must be smaller than 250).
+*/
+#define LUAI_MAXVARS            200
+
+
+/*
+@@ LUAI_MAXUPVALUES is the maximum number of upvalues per function
+@* (must be smaller than 250).
+*/
+#define LUAI_MAXUPVALUES        60
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+*/
+#define LUAL_BUFFERSIZE         BUFSIZ
+
+/* }================================================================== */
+
+
+
+
+/*
+** {==================================================================
+@@ LUA_NUMBER is the type of numbers in Lua.
+** CHANGE the following definitions only if you want to build Lua
+** with a number type different from double. You may also need to
+** change lua_number2int & lua_number2integer.
+** ===================================================================
+*/
+
+#define LUA_NUMBER_DOUBLE
+#define LUA_NUMBER      double
+
+/*
+@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
+@* over a number.
+*/
+#define LUAI_UACNUMBER  double
+
+
+/*
+@@ LUA_NUMBER_SCAN is the format for reading numbers.
+@@ LUA_NUMBER_FMT is the format for writing numbers.
+@@ lua_number2str converts a number to a string.
+@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
+@@ lua_str2number converts a string to a number.
+*/
+#define LUA_NUMBER_SCAN         "%lf"
+#define LUA_NUMBER_FMT          "%.14g"
+#define lua_number2str(s,n)     sprintf((s), LUA_NUMBER_FMT, (n))
+#define LUAI_MAXNUMBER2STR      32 /* 16 digits, sign, point, and \0 */
+#define lua_str2number(s,p)     strtod((s), (p))
+
+
+/*
+@@ The luai_num* macros define the primitive operations over numbers.
+*/
+#if defined(LUA_CORE)
+#include <math.h>
+#define luai_numadd(a,b)        ((a)+(b))
+#define luai_numsub(a,b)        ((a)-(b))
+#define luai_nummul(a,b)        ((a)*(b))
+#define luai_numdiv(a,b)        ((a)/(b))
+#define luai_nummod(a,b)        ((a) - floor((a)/(b))*(b))
+#define luai_numpow(a,b)        (pow(a,b))
+#define luai_numunm(a)          (-(a))
+#define luai_numeq(a,b)         ((a)==(b))
+#define luai_numlt(a,b)         ((a)<(b))
+#define luai_numle(a,b)         ((a)<=(b))
+#define luai_numisnan(a)        (!luai_numeq((a), (a)))
+#endif
+
+
+/*
+@@ lua_number2int is a macro to convert lua_Number to int.
+@@ lua_number2integer is a macro to convert lua_Number to lua_Integer.
+** CHANGE them if you know a faster way to convert a lua_Number to
+** int (with any rounding method and without throwing errors) in your
+** system. In Pentium machines, a naive typecast from double to int
+** in C is extremely slow, so any alternative is worth trying.
+*/
+
+/* On a Pentium, resort to a trick */
+#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \
+    (defined(__i386) || defined (_M_IX86) || defined(__i386__))
+
+/* On a Microsoft compiler, use assembler */
+#if defined(_MSC_VER)
+
+#define lua_number2int(i,d)   __asm fld d   __asm fistp i
+#define lua_number2integer(i,n)         lua_number2int(i, n)
+
+/* the next trick should work on any Pentium, but sometimes clashes
+   with a DirectX idiosyncrasy */
+#else
+
+union luai_Cast { double l_d; long l_l; };
+#define lua_number2int(i,d) \
+  { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; }
+#define lua_number2integer(i,n)         lua_number2int(i, n)
+
+#endif
+
+
+/* this option always works, but may be slow */
+#else
+#define lua_number2int(i,d)     ((i)=(int)(d))
+#define lua_number2integer(i,d) ((i)=(lua_Integer)(d))
+
+#endif
+
+
+/*
+@@ LUA_TVALUE_ALIGN specifies extra alignment constraints for the
+@@ tagged value structure to get better lua_Number alignment.
+** CHANGE it to an empty define if you want to save some space
+** at the cost of execution time. Note that this is only needed
+** for the x86 ABI on most POSIX systems, but not on Windows and
+** not for most other CPUs. If you change it then you need to follow
+** the instructions in ljit_x86.dash, too (look for TVALUE_SIZE).
+*/
+
+#if defined(LUA_NUMBER_DOUBLE) && defined(__GNUC__) && \
+    (defined(__i386) || defined(__i386__)) && !defined(_WIN32)
+#define LUA_TVALUE_ALIGN        __attribute__ ((aligned(8)))
+#else
+#define LUA_TVALUE_ALIGN
+#endif
+
+/* }================================================================== */
+
+
+/*
+@@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment.
+** CHANGE it if your system requires alignments larger than double. (For
+** instance, if your system supports long doubles and they must be
+** aligned in 16-byte boundaries, then you should add long double in the
+** union.) Probably you do not need to change this.
+*/
+#define LUAI_USER_ALIGNMENT_T   union { double u; void *s; long l; }
+
+
+/*
+@@ LUAI_THROW/LUAI_TRY define how Lua does exception handling.
+** CHANGE them if you prefer to use longjmp/setjmp even with C++
+** or if want/don't to use _longjmp/_setjmp instead of regular
+** longjmp/setjmp. By default, Lua handles errors with exceptions when
+** compiling as C++ code, with _longjmp/_setjmp when asked to use them,
+** and with longjmp/setjmp otherwise.
+*/
+#if defined(__cplusplus)
+/* C++ exceptions */
+#define LUAI_THROW(L,c) throw(c)
+#define LUAI_TRY(L,c,a) try { a } catch(...) \
+        { if ((c)->status == 0) (c)->status = -1; }
+#define luai_jmpbuf     int  /* dummy variable */
+
+#elif defined(LUA_USE_ULONGJMP)
+/* in Unix, try _longjmp/_setjmp (more efficient) */
+#define LUAI_THROW(L,c) _longjmp((c)->b, 1)
+#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a }
+#define luai_jmpbuf     jmp_buf
+
+#else
+/* default handling with long jumps */
+#define LUAI_THROW(L,c) longjmp((c)->b, 1)
+#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a }
+#define luai_jmpbuf     jmp_buf
+
+#endif
+
+
+/*
+@@ LUA_MAXCAPTURES is the maximum number of captures that a pattern
+@* can do during pattern-matching.
+** CHANGE it if you need more captures. This limit is arbitrary.
+*/
+#define LUA_MAXCAPTURES         32
+
+
+/*
+@@ lua_tmpnam is the function that the OS library uses to create a
+@* temporary name.
+@@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam.
+** CHANGE them if you have an alternative to tmpnam (which is considered
+** insecure) or if you want the original tmpnam anyway.  By default, Lua
+** uses tmpnam except when POSIX is available, where it uses mkstemp.
+*/
+#if defined(loslib_c) || defined(luaall_c)
+
+#if defined(LUA_USE_MKSTEMP)
+#include <unistd.h>
+#define LUA_TMPNAMBUFSIZE       32
+#define lua_tmpnam(b,e) { \
+        strcpy(b, "/tmp/lua_XXXXXX"); \
+        e = mkstemp(b); \
+        if (e != -1) close(e); \
+        e = (e == -1); }
+
+#else
+#define LUA_TMPNAMBUFSIZE       L_tmpnam
+#define lua_tmpnam(b,e)         { e = (tmpnam(b) == NULL); }
+#endif
+
+#endif
+
+
+/*
+@@ lua_popen spawns a new process connected to the current one through
+@* the file streams.
+** CHANGE it if you have a way to implement it in your system.
+*/
+#if defined(LUA_USE_POPEN)
+
+#define lua_popen(L,c,m)        ((void)L, fflush(NULL), popen(c,m))
+#define lua_pclose(L,file)      ((void)L, (pclose(file) != -1))
+
+#elif defined(LUA_WIN)
+
+#define lua_popen(L,c,m)        ((void)L, _popen(c,m))
+#define lua_pclose(L,file)      ((void)L, (_pclose(file) != -1))
+
+#else
+
+#define lua_popen(L,c,m)        ((void)((void)c, m),  \
+                luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
+#define lua_pclose(L,file)              ((void)((void)L, file), 0)
+
+#endif
+
+/*
+@@ LUA_DL_* define which dynamic-library system Lua should use.
+** CHANGE here if Lua has problems choosing the appropriate
+** dynamic-library system for your platform (either Windows' DLL, Mac's
+** dyld, or Unix's dlopen). If your system is some kind of Unix, there
+** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for
+** it.  To use dlopen you also need to adapt the src/Makefile (probably
+** adding -ldl to the linker options), so Lua does not select it
+** automatically.  (When you change the makefile to add -ldl, you must
+** also add -DLUA_USE_DLOPEN.)
+** If you do not want any kind of dynamic library, undefine all these
+** options.
+** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD.
+*/
+#if defined(LUA_USE_DLOPEN)
+#define LUA_DL_DLOPEN
+#endif
+
+#if defined(LUA_WIN)
+#define LUA_DL_DLL
+#endif
+
+
+/*
+@@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State
+@* (the data goes just *before* the lua_State pointer).
+** CHANGE (define) this if you really need that. This value must be
+** a multiple of the maximum alignment required for your machine.
+*/
+#define LUAI_EXTRASPACE         0
+
+
+/*
+@@ luai_userstate* allow user-specific actions on threads.
+** CHANGE them if you defined LUAI_EXTRASPACE and need to do something
+** extra when a thread is created/deleted/resumed/yielded.
+*/
+#define luai_userstateopen(L)           ((void)L)
+#define luai_userstateclose(L)          ((void)L)
+#define luai_userstatethread(L,L1)      ((void)L)
+#define luai_userstatefree(L)           ((void)L)
+#define luai_userstateresume(L,n)       ((void)L)
+#define luai_userstateyield(L,n)        ((void)L)
+
+
+/*
+@@ LUA_INTFRMLEN is the length modifier for integer conversions
+@* in 'string.format'.
+@@ LUA_INTFRM_T is the integer type correspoding to the previous length
+@* modifier.
+** CHANGE them if your system supports long long or does not support long.
+*/
+
+#if defined(LUA_USELONGLONG)
+
+#define LUA_INTFRMLEN           "ll"
+#define LUA_INTFRM_T            long long
+
+#else
+
+#define LUA_INTFRMLEN           "l"
+#define LUA_INTFRM_T            long
+
+#endif
+
+
+
+/* =================================================================== */
+
+/*
+** Local configuration. You can use this space to add your redefinitions
+** without modifying the main part of the file.
+*/
+
+
+
+#endif
+
diff --git a/libraries/LuaJIT-1.1.7/src/luajit.h b/libraries/LuaJIT-1.1.7/src/luajit.h
new file mode 100644
index 0000000..fa32e17
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/luajit.h
@@ -0,0 +1,68 @@
+/*
+** Copyright (C) 2005-2011 Mike Pall. All rights reserved.
+**
+** 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.
+**
+** [ MIT license: http://www.opensource.org/licenses/mit-license.php ]
+*/
+
+/* LuaJIT -- a Just-In-Time Compiler for Lua. http://luajit.org/ */
+
+/* LuaJIT public C API. */
+#ifndef luajit_h
+#define luajit_h
+
+#include "lua.h"
+
+
+#define LUAJIT_VERSION          "LuaJIT 1.1.7"
+#define LUAJIT_VERSION_NUM      10107  /* Version 1.1.7 = 01.01.07. */
+#define LUAJIT_VERSION_SYM      luaJIT_version_1_1_7
+#define LUAJIT_COPYRIGHT        "Copyright (C) 2005-2011 Mike Pall"
+#define LUAJIT_URL              "http://luajit.org/"
+
+/* Modes for luaJIT_setmode. */
+#define LUAJIT_MODE_MASK        0x00ff
+
+enum {
+  LUAJIT_MODE_ENGINE,           /* Set mode for whole JIT engine. */
+  LUAJIT_MODE_DEBUG,            /* Set debug mode (idx = level). */
+
+  LUAJIT_MODE_FUNC,             /* Change mode for a function. */
+  LUAJIT_MODE_ALLFUNC,          /* Recurse into subroutine protos. */
+  LUAJIT_MODE_ALLSUBFUNC,       /* Change only the subroutines. */
+  LUAJIT_MODE_MAX
+};
+
+/* Flags or'ed in to the mode. */
+#define LUAJIT_MODE_OFF         0x0000  /* Disable JIT compilation. */
+#define LUAJIT_MODE_ON          0x0100  /* (Re-)enable JIT compilation. */
+
+
+/* Compile a Lua function. Pass arguments as hints. */
+LUA_API int luaJIT_compile(lua_State *L, int nargs);
+
+/* Set the JIT mode for the whole engine or a function (idx = 0: self). */
+LUA_API int luaJIT_setmode(lua_State *L, int idx, int mode);
+
+/* Enforce (dynamic) linker error for version mismatches. Call from main. */
+LUA_API void LUAJIT_VERSION_SYM(void);
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lualib.h b/libraries/LuaJIT-1.1.7/src/lualib.h
new file mode 100644
index 0000000..c4567e9
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lualib.h
@@ -0,0 +1,56 @@
+/*
+** $Id: lualib.h,v 1.36 2005/12/27 17:12:00 roberto Exp $
+** Lua standard libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lualib_h
+#define lualib_h
+
+#include "lua.h"
+
+
+/* Key to file-handle type */
+#define LUA_FILEHANDLE          "FILE*"
+
+
+#define LUA_COLIBNAME   "coroutine"
+LUALIB_API int (luaopen_base) (lua_State *L);
+
+#define LUA_TABLIBNAME  "table"
+LUALIB_API int (luaopen_table) (lua_State *L);
+
+#define LUA_IOLIBNAME   "io"
+LUALIB_API int (luaopen_io) (lua_State *L);
+
+#define LUA_OSLIBNAME   "os"
+LUALIB_API int (luaopen_os) (lua_State *L);
+
+#define LUA_STRLIBNAME  "string"
+LUALIB_API int (luaopen_string) (lua_State *L);
+
+#define LUA_MATHLIBNAME "math"
+LUALIB_API int (luaopen_math) (lua_State *L);
+
+#define LUA_DBLIBNAME   "debug"
+LUALIB_API int (luaopen_debug) (lua_State *L);
+
+#define LUA_LOADLIBNAME "package"
+LUALIB_API int (luaopen_package) (lua_State *L);
+
+#define LUA_JITLIBNAME "jit"
+LUALIB_API int (luaopen_jit) (lua_State *L);
+
+
+/* open all previous libraries */
+LUALIB_API void (luaL_openlibs) (lua_State *L); 
+
+
+
+#ifndef lua_assert
+#define lua_assert(x)   ((void)0)
+#endif
+
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lundump.c b/libraries/LuaJIT-1.1.7/src/lundump.c
new file mode 100644
index 0000000..8010a45
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lundump.c
@@ -0,0 +1,227 @@
+/*
+** $Id: lundump.c,v 2.7.1.4 2008/04/04 19:51:41 roberto Exp $
+** load precompiled Lua chunks
+** See Copyright Notice in lua.h
+*/
+
+#include <string.h>
+
+#define lundump_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lstring.h"
+#include "lundump.h"
+#include "lzio.h"
+
+typedef struct {
+ lua_State* L;
+ ZIO* Z;
+ Mbuffer* b;
+ const char* name;
+} LoadState;
+
+#ifdef LUAC_TRUST_BINARIES
+#define IF(c,s)
+#define error(S,s)
+#else
+#define IF(c,s)         if (c) error(S,s)
+
+static void error(LoadState* S, const char* why)
+{
+ luaO_pushfstring(S->L,"%s: %s in precompiled chunk",S->name,why);
+ luaD_throw(S->L,LUA_ERRSYNTAX);
+}
+#endif
+
+#define LoadMem(S,b,n,size)     LoadBlock(S,b,(n)*(size))
+#define LoadByte(S)             (lu_byte)LoadChar(S)
+#define LoadVar(S,x)            LoadMem(S,&x,1,sizeof(x))
+#define LoadVector(S,b,n,size)  LoadMem(S,b,n,size)
+
+static void LoadBlock(LoadState* S, void* b, size_t size)
+{
+ size_t r=luaZ_read(S->Z,b,size);
+ IF (r!=0, "unexpected end");
+}
+
+static int LoadChar(LoadState* S)
+{
+ char x;
+ LoadVar(S,x);
+ return x;
+}
+
+static int LoadInt(LoadState* S)
+{
+ int x;
+ LoadVar(S,x);
+ IF (x<0, "bad integer");
+ return x;
+}
+
+static lua_Number LoadNumber(LoadState* S)
+{
+ lua_Number x;
+ LoadVar(S,x);
+ return x;
+}
+
+static TString* LoadString(LoadState* S)
+{
+ size_t size;
+ LoadVar(S,size);
+ if (size==0)
+  return NULL;
+ else
+ {
+  char* s=luaZ_openspace(S->L,S->b,size);
+  LoadBlock(S,s,size);
+  return luaS_newlstr(S->L,s,size-1);           /* remove trailing '\0' */
+ }
+}
+
+static void LoadCode(LoadState* S, Proto* f)
+{
+ int n=LoadInt(S);
+ f->code=luaM_newvector(S->L,n,Instruction);
+ f->sizecode=n;
+ LoadVector(S,f->code,n,sizeof(Instruction));
+}
+
+static Proto* LoadFunction(LoadState* S, TString* p);
+
+static void LoadConstants(LoadState* S, Proto* f)
+{
+ int i,n;
+ n=LoadInt(S);
+ f->k=luaM_newvector(S->L,n,TValue);
+ f->sizek=n;
+ for (i=0; i<n; i++) setnilvalue(&f->k[i]);
+ for (i=0; i<n; i++)
+ {
+  TValue* o=&f->k[i];
+  int t=LoadChar(S);
+  switch (t)
+  {
+   case LUA_TNIL:
+        setnilvalue(o);
+        break;
+   case LUA_TBOOLEAN:
+        setbvalue(o,LoadChar(S)!=0);
+        break;
+   case LUA_TNUMBER:
+        setnvalue(o,LoadNumber(S));
+        break;
+   case LUA_TSTRING:
+        setsvalue2n(S->L,o,LoadString(S));
+        break;
+   default:
+        error(S,"bad constant");
+        break;
+  }
+ }
+ n=LoadInt(S);
+ f->p=luaM_newvector(S->L,n,Proto*);
+ f->sizep=n;
+ for (i=0; i<n; i++) f->p[i]=NULL;
+ for (i=0; i<n; i++) f->p[i]=LoadFunction(S,f->source);
+}
+
+static void LoadDebug(LoadState* S, Proto* f)
+{
+ int i,n;
+ n=LoadInt(S);
+ f->lineinfo=luaM_newvector(S->L,n,int);
+ f->sizelineinfo=n;
+ LoadVector(S,f->lineinfo,n,sizeof(int));
+ n=LoadInt(S);
+ f->locvars=luaM_newvector(S->L,n,LocVar);
+ f->sizelocvars=n;
+ for (i=0; i<n; i++) f->locvars[i].varname=NULL;
+ for (i=0; i<n; i++)
+ {
+  f->locvars[i].varname=LoadString(S);
+  f->locvars[i].startpc=LoadInt(S);
+  f->locvars[i].endpc=LoadInt(S);
+ }
+ n=LoadInt(S);
+ f->upvalues=luaM_newvector(S->L,n,TString*);
+ f->sizeupvalues=n;
+ for (i=0; i<n; i++) f->upvalues[i]=NULL;
+ for (i=0; i<n; i++) f->upvalues[i]=LoadString(S);
+}
+
+static Proto* LoadFunction(LoadState* S, TString* p)
+{
+ Proto* f;
+ if (++S->L->nCcalls > LUAI_MAXCCALLS) error(S,"code too deep");
+ f=luaF_newproto(S->L);
+ setptvalue2s(S->L,S->L->top,f); incr_top(S->L);
+ f->source=LoadString(S); if (f->source==NULL) f->source=p;
+ f->linedefined=LoadInt(S);
+ f->lastlinedefined=LoadInt(S);
+ f->nups=LoadByte(S);
+ f->numparams=LoadByte(S);
+ f->is_vararg=LoadByte(S);
+ f->maxstacksize=LoadByte(S);
+ LoadCode(S,f);
+ LoadConstants(S,f);
+ LoadDebug(S,f);
+ IF (!luaG_checkcode(f), "bad code");
+ S->L->top--;
+ S->L->nCcalls--;
+ return f;
+}
+
+static void LoadHeader(LoadState* S)
+{
+ char h[LUAC_HEADERSIZE];
+ char s[LUAC_HEADERSIZE];
+ luaU_header(h);
+ LoadBlock(S,s,LUAC_HEADERSIZE);
+ IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
+}
+
+/*
+** load precompiled chunk
+*/
+Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
+{
+ LoadState S;
+ if (*name=='@' || *name=='=')
+  S.name=name+1;
+ else if (*name==LUA_SIGNATURE[0])
+  S.name="binary string";
+ else
+  S.name=name;
+ S.L=L;
+ S.Z=Z;
+ S.b=buff;
+ LoadHeader(&S);
+ return LoadFunction(&S,luaS_newliteral(L,"=?"));
+}
+
+/*
+* make header
+*/
+void luaU_header (char* h)
+{
+ int x=1;
+ memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-1);
+ h+=sizeof(LUA_SIGNATURE)-1;
+ *h++=(char)LUAC_VERSION;
+ *h++=(char)LUAC_FORMAT;
+ *h++=(char)*(char*)&x;                         /* endianness */
+ *h++=(char)sizeof(int);
+ *h++=(char)sizeof(size_t);
+ *h++=(char)sizeof(Instruction);
+ *h++=(char)sizeof(lua_Number);
+ *h++=(char)(((lua_Number)0.5)==0);             /* is lua_Number integral? */
+}
diff --git a/libraries/LuaJIT-1.1.7/src/lundump.h b/libraries/LuaJIT-1.1.7/src/lundump.h
new file mode 100644
index 0000000..c80189d
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lundump.h
@@ -0,0 +1,36 @@
+/*
+** $Id: lundump.h,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $
+** load precompiled Lua chunks
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lundump_h
+#define lundump_h
+
+#include "lobject.h"
+#include "lzio.h"
+
+/* load one chunk; from lundump.c */
+LUAI_FUNC Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);
+
+/* make header; from lundump.c */
+LUAI_FUNC void luaU_header (char* h);
+
+/* dump one chunk; from ldump.c */
+LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip);
+
+#ifdef luac_c
+/* print one chunk; from print.c */
+LUAI_FUNC void luaU_print (const Proto* f, int full);
+#endif
+
+/* for header of binary files -- this is Lua 5.1 */
+#define LUAC_VERSION            0x51
+
+/* for header of binary files -- this is the official format */
+#define LUAC_FORMAT             0
+
+/* size of header of binary files */
+#define LUAC_HEADERSIZE         12
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lvm.c b/libraries/LuaJIT-1.1.7/src/lvm.c
new file mode 100644
index 0000000..d24f43c
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lvm.c
@@ -0,0 +1,766 @@
+/*
+** $Id: lvm.c,v 2.63.1.3 2007/12/28 15:32:23 roberto Exp $
+** Lua virtual machine
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define lvm_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lgc.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "ltm.h"
+#include "lvm.h"
+
+
+
+/* limit for table tag-method chains (to avoid loops) */
+#define MAXTAGLOOP      100
+
+
+const TValue *luaV_tonumber (const TValue *obj, TValue *n) {
+  lua_Number num;
+  if (ttisnumber(obj)) return obj;
+  if (ttisstring(obj) && luaO_str2d(svalue(obj), &num)) {
+    setnvalue(n, num);
+    return n;
+  }
+  else
+    return NULL;
+}
+
+
+int luaV_tostring (lua_State *L, StkId obj) {
+  if (!ttisnumber(obj))
+    return 0;
+  else {
+    char s[LUAI_MAXNUMBER2STR];
+    lua_Number n = nvalue(obj);
+    lua_number2str(s, n);
+    setsvalue2s(L, obj, luaS_new(L, s));
+    return 1;
+  }
+}
+
+
+static void traceexec (lua_State *L, const Instruction *pc) {
+  lu_byte mask = L->hookmask;
+  const Instruction *oldpc = L->savedpc;
+  L->savedpc = pc;
+  if ((mask & LUA_MASKCOUNT) && L->hookcount == 0) {
+    resethookcount(L);
+    luaD_callhook(L, LUA_HOOKCOUNT, -1);
+  }
+  if (mask & LUA_MASKLINE) {
+    Proto *p = ci_func(L->ci)->l.p;
+    int npc = pcRel(pc, p);
+    int newline = getline(p, npc);
+    /* call linehook when enter a new function, when jump back (loop),
+       or when enter a new line */
+    if (npc == 0 || pc <= oldpc || newline != getline(p, pcRel(oldpc, p)))
+      luaD_callhook(L, LUA_HOOKLINE, newline);
+  }
+}
+
+
+static void callTMres (lua_State *L, StkId res, const TValue *f,
+                        const TValue *p1, const TValue *p2) {
+  ptrdiff_t result = savestack(L, res);
+  setobj2s(L, L->top, f);  /* push function */
+  setobj2s(L, L->top+1, p1);  /* 1st argument */
+  setobj2s(L, L->top+2, p2);  /* 2nd argument */
+  luaD_checkstack(L, 3);
+  L->top += 3;
+  luaD_call(L, L->top - 3, 1);
+  res = restorestack(L, result);
+  L->top--;
+  setobjs2s(L, res, L->top);
+}
+
+
+
+static void callTM (lua_State *L, const TValue *f, const TValue *p1,
+                    const TValue *p2, const TValue *p3) {
+  setobj2s(L, L->top, f);  /* push function */
+  setobj2s(L, L->top+1, p1);  /* 1st argument */
+  setobj2s(L, L->top+2, p2);  /* 2nd argument */
+  setobj2s(L, L->top+3, p3);  /* 3th argument */
+  luaD_checkstack(L, 4);
+  L->top += 4;
+  luaD_call(L, L->top - 4, 0);
+}
+
+
+void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {
+  int loop;
+  for (loop = 0; loop < MAXTAGLOOP; loop++) {
+    const TValue *tm;
+    if (ttistable(t)) {  /* `t' is a table? */
+      Table *h = hvalue(t);
+      const TValue *res = luaH_get(h, key); /* do a primitive get */
+      if (!ttisnil(res) ||  /* result is no nil? */
+          (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
+        setobj2s(L, val, res);
+        return;
+      }
+      /* else will try the tag method */
+    }
+    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))
+      luaG_typeerror(L, t, "index");
+    if (ttisfunction(tm)) {
+      callTMres(L, val, tm, t, key);
+      return;
+    }
+    t = tm;  /* else repeat with `tm' */ 
+  }
+  luaG_runerror(L, "loop in gettable");
+}
+
+
+void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {
+  int loop;
+  TValue temp;
+  for (loop = 0; loop < MAXTAGLOOP; loop++) {
+    const TValue *tm;
+    if (ttistable(t)) {  /* `t' is a table? */
+      Table *h = hvalue(t);
+      TValue *oldval = luaH_set(L, h, key); /* do a primitive set */
+      if (!ttisnil(oldval) ||  /* result is no nil? */
+          (tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL) { /* or no TM? */
+        setobj2t(L, oldval, val);
+        luaC_barriert(L, h, val);
+        return;
+      }
+      /* else will try the tag method */
+    }
+    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
+      luaG_typeerror(L, t, "index");
+    if (ttisfunction(tm)) {
+      callTM(L, tm, t, key, val);
+      return;
+    }
+    /* else repeat with `tm' */
+    setobj(L, &temp, tm);  /* avoid pointing inside table (may rehash) */
+    t = &temp;
+  }
+  luaG_runerror(L, "loop in settable");
+}
+
+
+static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,
+                       StkId res, TMS event) {
+  const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
+  if (ttisnil(tm))
+    tm = luaT_gettmbyobj(L, p2, event);  /* try second operand */
+  if (ttisnil(tm)) return 0;
+  callTMres(L, res, tm, p1, p2);
+  return 1;
+}
+
+
+static const TValue *get_compTM (lua_State *L, Table *mt1, Table *mt2,
+                                  TMS event) {
+  const TValue *tm1 = fasttm(L, mt1, event);
+  const TValue *tm2;
+  if (tm1 == NULL) return NULL;  /* no metamethod */
+  if (mt1 == mt2) return tm1;  /* same metatables => same metamethods */
+  tm2 = fasttm(L, mt2, event);
+  if (tm2 == NULL) return NULL;  /* no metamethod */
+  if (luaO_rawequalObj(tm1, tm2))  /* same metamethods? */
+    return tm1;
+  return NULL;
+}
+
+
+static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2,
+                         TMS event) {
+  const TValue *tm1 = luaT_gettmbyobj(L, p1, event);
+  const TValue *tm2;
+  if (ttisnil(tm1)) return -1;  /* no metamethod? */
+  tm2 = luaT_gettmbyobj(L, p2, event);
+  if (!luaO_rawequalObj(tm1, tm2))  /* different metamethods? */
+    return -1;
+  callTMres(L, L->top, tm1, p1, p2);
+  return !l_isfalse(L->top);
+}
+
+
+static int l_strcmp (const TString *ls, const TString *rs) {
+  const char *l = getstr(ls);
+  size_t ll = ls->tsv.len;
+  const char *r = getstr(rs);
+  size_t lr = rs->tsv.len;
+  for (;;) {
+    int temp = strcoll(l, r);
+    if (temp != 0) return temp;
+    else {  /* strings are equal up to a `\0' */
+      size_t len = strlen(l);  /* index of first `\0' in both strings */
+      if (len == lr)  /* r is finished? */
+        return (len == ll) ? 0 : 1;
+      else if (len == ll)  /* l is finished? */
+        return -1;  /* l is smaller than r (because r is not finished) */
+      /* both strings longer than `len'; go on comparing (after the `\0') */
+      len++;
+      l += len; ll -= len; r += len; lr -= len;
+    }
+  }
+}
+
+
+int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
+  int res;
+  if (ttype(l) != ttype(r))
+    return luaG_ordererror(L, l, r);
+  else if (ttisnumber(l))
+    return luai_numlt(nvalue(l), nvalue(r));
+  else if (ttisstring(l))
+    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
+  else if ((res = call_orderTM(L, l, r, TM_LT)) != -1)
+    return res;
+  return luaG_ordererror(L, l, r);
+}
+
+
+int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) {
+  int res;
+  if (ttype(l) != ttype(r))
+    return luaG_ordererror(L, l, r);
+  else if (ttisnumber(l))
+    return luai_numle(nvalue(l), nvalue(r));
+  else if (ttisstring(l))
+    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
+  else if ((res = call_orderTM(L, l, r, TM_LE)) != -1)  /* first try `le' */
+    return res;
+  else if ((res = call_orderTM(L, r, l, TM_LT)) != -1)  /* else try `lt' */
+    return !res;
+  return luaG_ordererror(L, l, r);
+}
+
+
+int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2) {
+  const TValue *tm;
+  lua_assert(ttype(t1) == ttype(t2));
+  switch (ttype(t1)) {
+    case LUA_TNIL: return 1;
+    case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2));
+    case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2);  /* true must be 1 !! */
+    case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
+    case LUA_TUSERDATA: {
+      if (uvalue(t1) == uvalue(t2)) return 1;
+      tm = get_compTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable,
+                         TM_EQ);
+      break;  /* will try TM */
+    }
+    case LUA_TTABLE: {
+      if (hvalue(t1) == hvalue(t2)) return 1;
+      tm = get_compTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);
+      break;  /* will try TM */
+    }
+    default: return gcvalue(t1) == gcvalue(t2);
+  }
+  if (tm == NULL) return 0;  /* no TM? */
+  callTMres(L, L->top, tm, t1, t2);  /* call TM */
+  return !l_isfalse(L->top);
+}
+
+
+void luaV_concat (lua_State *L, int total, int last) {
+  do {
+    StkId top = L->base + last + 1;
+    int n = 2;  /* number of elements handled in this pass (at least 2) */
+    if (!(ttisstring(top-2) || ttisnumber(top-2)) || !tostring(L, top-1)) {
+      if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT))
+        luaG_concaterror(L, top-2, top-1);
+    } else if (tsvalue(top-1)->len == 0)  /* second op is empty? */
+      (void)tostring(L, top - 2);  /* result is first op (as string) */
+    else {
+      /* at least two string values; get as many as possible */
+      size_t tl = tsvalue(top-1)->len;
+      char *buffer;
+      int i;
+      /* collect total length */
+      for (n = 1; n < total && tostring(L, top-n-1); n++) {
+        size_t l = tsvalue(top-n-1)->len;
+        if (l >= MAX_SIZET - tl) luaG_runerror(L, "string length overflow");
+        tl += l;
+      }
+      buffer = luaZ_openspace(L, &G(L)->buff, tl);
+      tl = 0;
+      for (i=n; i>0; i--) {  /* concat all strings */
+        size_t l = tsvalue(top-i)->len;
+        memcpy(buffer+tl, svalue(top-i), l);
+        tl += l;
+      }
+      setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl));
+    }
+    total -= n-1;  /* got `n' strings to create 1 new */
+    last -= n-1;
+  } while (total > 1);  /* repeat until only 1 result left */
+}
+
+
+void luaV_arith (lua_State *L, StkId ra, const TValue *rb,
+                 const TValue *rc, TMS op) {
+  TValue tempb, tempc;
+  const TValue *b, *c;
+  if ((b = luaV_tonumber(rb, &tempb)) != NULL &&
+      (c = luaV_tonumber(rc, &tempc)) != NULL) {
+    lua_Number nb = nvalue(b), nc = nvalue(c);
+    switch (op) {
+      case TM_ADD: setnvalue(ra, luai_numadd(nb, nc)); break;
+      case TM_SUB: setnvalue(ra, luai_numsub(nb, nc)); break;
+      case TM_MUL: setnvalue(ra, luai_nummul(nb, nc)); break;
+      case TM_DIV: setnvalue(ra, luai_numdiv(nb, nc)); break;
+      case TM_MOD: setnvalue(ra, luai_nummod(nb, nc)); break;
+      case TM_POW: setnvalue(ra, luai_numpow(nb, nc)); break;
+      case TM_UNM: setnvalue(ra, luai_numunm(nb)); break;
+      default: lua_assert(0); break;
+    }
+  }
+  else if (!call_binTM(L, rb, rc, ra, op))
+    luaG_aritherror(L, rb, rc);
+}
+
+
+
+/*
+** some macros for common tasks in `luaV_execute'
+*/
+
+#define runtime_check(L, c)     { if (!(c)) break; }
+
+#define RA(i)   (base+GETARG_A(i))
+/* to be used after possible stack reallocation */
+#define RB(i)   check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))
+#define RC(i)   check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i))
+#define RKB(i)  check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \
+        ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i))
+#define RKC(i)  check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \
+        ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))
+#define KBx(i)  check_exp(getBMode(GET_OPCODE(i)) == OpArgK, k+GETARG_Bx(i))
+
+
+#define dojump(L,pc,i)  {(pc) += (i); luai_threadyield(L);}
+
+
+#define Protect(x)      { L->savedpc = pc; {x;}; base = L->base; }
+
+
+#define arith_op(op,tm) { \
+        TValue *rb = RKB(i); \
+        TValue *rc = RKC(i); \
+        if (ttisnumber(rb) && ttisnumber(rc)) { \
+          lua_Number nb = nvalue(rb), nc = nvalue(rc); \
+          setnvalue(ra, op(nb, nc)); \
+        } \
+        else \
+          Protect(luaV_arith(L, ra, rb, rc, tm)); \
+      }
+
+
+
+void luaV_execute (lua_State *L, int nexeccalls) {
+  LClosure *cl;
+  StkId base;
+  TValue *k;
+  const Instruction *pc;
+ reentry:  /* entry point */
+  lua_assert(isLua(L->ci));
+  pc = L->savedpc;
+  cl = &clvalue(L->ci->func)->l;
+  base = L->base;
+  k = cl->p->k;
+  /* main loop of interpreter */
+  for (;;) {
+    const Instruction i = *pc++;
+    StkId ra;
+    if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
+        (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
+      traceexec(L, pc);
+      if (L->status == LUA_YIELD) {  /* did hook yield? */
+        L->savedpc = pc - 1;
+        return;
+      }
+      base = L->base;
+    }
+    /* warning!! several calls may realloc the stack and invalidate `ra' */
+    ra = RA(i);
+    lua_assert(base == L->base && L->base == L->ci->base);
+    lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
+    lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
+    switch (GET_OPCODE(i)) {
+      case OP_MOVE: {
+        setobjs2s(L, ra, RB(i));
+        continue;
+      }
+      case OP_LOADK: {
+        setobj2s(L, ra, KBx(i));
+        continue;
+      }
+      case OP_LOADBOOL: {
+        setbvalue(ra, GETARG_B(i));
+        if (GETARG_C(i)) pc++;  /* skip next instruction (if C) */
+        continue;
+      }
+      case OP_LOADNIL: {
+        TValue *rb = RB(i);
+        do {
+          setnilvalue(rb--);
+        } while (rb >= ra);
+        continue;
+      }
+      case OP_GETUPVAL: {
+        int b = GETARG_B(i);
+        setobj2s(L, ra, cl->upvals[b]->v);
+        continue;
+      }
+      case OP_GETGLOBAL: {
+        TValue g;
+        TValue *rb = KBx(i);
+        sethvalue(L, &g, cl->env);
+        lua_assert(ttisstring(rb));
+        Protect(luaV_gettable(L, &g, rb, ra));
+        continue;
+      }
+      case OP_GETTABLE: {
+        Protect(luaV_gettable(L, RB(i), RKC(i), ra));
+        continue;
+      }
+      case OP_SETGLOBAL: {
+        TValue g;
+        sethvalue(L, &g, cl->env);
+        lua_assert(ttisstring(KBx(i)));
+        Protect(luaV_settable(L, &g, KBx(i), ra));
+        continue;
+      }
+      case OP_SETUPVAL: {
+        UpVal *uv = cl->upvals[GETARG_B(i)];
+        setobj(L, uv->v, ra);
+        luaC_barrier(L, uv, ra);
+        continue;
+      }
+      case OP_SETTABLE: {
+        Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
+        continue;
+      }
+      case OP_NEWTABLE: {
+        int b = GETARG_B(i);
+        int c = GETARG_C(i);
+        sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
+        Protect(luaC_checkGC(L));
+        continue;
+      }
+      case OP_SELF: {
+        StkId rb = RB(i);
+        setobjs2s(L, ra+1, rb);
+        Protect(luaV_gettable(L, rb, RKC(i), ra));
+        continue;
+      }
+      case OP_ADD: {
+        arith_op(luai_numadd, TM_ADD);
+        continue;
+      }
+      case OP_SUB: {
+        arith_op(luai_numsub, TM_SUB);
+        continue;
+      }
+      case OP_MUL: {
+        arith_op(luai_nummul, TM_MUL);
+        continue;
+      }
+      case OP_DIV: {
+        arith_op(luai_numdiv, TM_DIV);
+        continue;
+      }
+      case OP_MOD: {
+        arith_op(luai_nummod, TM_MOD);
+        continue;
+      }
+      case OP_POW: {
+        arith_op(luai_numpow, TM_POW);
+        continue;
+      }
+      case OP_UNM: {
+        TValue *rb = RB(i);
+        if (ttisnumber(rb)) {
+          lua_Number nb = nvalue(rb);
+          setnvalue(ra, luai_numunm(nb));
+        }
+        else {
+          Protect(luaV_arith(L, ra, rb, rb, TM_UNM));
+        }
+        continue;
+      }
+      case OP_NOT: {
+        int res = l_isfalse(RB(i));  /* next assignment may change this value */
+        setbvalue(ra, res);
+        continue;
+      }
+      case OP_LEN: {
+        const TValue *rb = RB(i);
+        switch (ttype(rb)) {
+          case LUA_TTABLE: {
+            setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));
+            break;
+          }
+          case LUA_TSTRING: {
+            setnvalue(ra, cast_num(tsvalue(rb)->len));
+            break;
+          }
+          default: {  /* try metamethod */
+            Protect(
+              if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN))
+                luaG_typeerror(L, rb, "get length of");
+            )
+          }
+        }
+        continue;
+      }
+      case OP_CONCAT: {
+        int b = GETARG_B(i);
+        int c = GETARG_C(i);
+        Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L));
+        setobjs2s(L, RA(i), base+b);
+        continue;
+      }
+      case OP_JMP: {
+        dojump(L, pc, GETARG_sBx(i));
+        continue;
+      }
+      case OP_EQ: {
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        Protect(
+          if (equalobj(L, rb, rc) == GETARG_A(i))
+            dojump(L, pc, GETARG_sBx(*pc));
+        )
+        pc++;
+        continue;
+      }
+      case OP_LT: {
+        Protect(
+          if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))
+            dojump(L, pc, GETARG_sBx(*pc));
+        )
+        pc++;
+        continue;
+      }
+      case OP_LE: {
+        Protect(
+          if (luaV_lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))
+            dojump(L, pc, GETARG_sBx(*pc));
+        )
+        pc++;
+        continue;
+      }
+      case OP_TEST: {
+        if (l_isfalse(ra) != GETARG_C(i))
+          dojump(L, pc, GETARG_sBx(*pc));
+        pc++;
+        continue;
+      }
+      case OP_TESTSET: {
+        TValue *rb = RB(i);
+        if (l_isfalse(rb) != GETARG_C(i)) {
+          setobjs2s(L, ra, rb);
+          dojump(L, pc, GETARG_sBx(*pc));
+        }
+        pc++;
+        continue;
+      }
+      case OP_CALL: {
+        int b = GETARG_B(i);
+        int nresults = GETARG_C(i) - 1;
+        if (b != 0) L->top = ra+b;  /* else previous instruction set top */
+        L->savedpc = pc;
+        switch (luaD_precall(L, ra, nresults)) {
+          case PCRLUA: {
+            nexeccalls++;
+            goto reentry;  /* restart luaV_execute over new Lua function */
+          }
+          case PCRC: {
+            /* it was a C function (`precall' called it); adjust results */
+            if (nresults >= 0) L->top = L->ci->top;
+            base = L->base;
+            continue;
+          }
+          default: {
+            return;  /* yield */
+          }
+        }
+      }
+      case OP_TAILCALL: {
+        int b = GETARG_B(i);
+        if (b != 0) L->top = ra+b;  /* else previous instruction set top */
+        L->savedpc = pc;
+        lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);
+        switch (luaD_precall(L, ra, LUA_MULTRET)) {
+          case PCRLUA: {
+            /* tail call: put new frame in place of previous one */
+            CallInfo *ci = L->ci - 1;  /* previous frame */
+            int aux;
+            StkId func = ci->func;
+            StkId pfunc = (ci+1)->func;  /* previous function index */
+            if (L->openupval) luaF_close(L, ci->base);
+            L->base = ci->base = ci->func + ((ci+1)->base - pfunc);
+            for (aux = 0; pfunc+aux < L->top; aux++)  /* move frame down */
+              setobjs2s(L, func+aux, pfunc+aux);
+            ci->top = L->top = func+aux;  /* correct top */
+            lua_assert(L->top == L->base + clvalue(func)->l.p->maxstacksize);
+            ci->savedpc = L->savedpc;
+            ci->tailcalls++;  /* one more call lost */
+            L->ci--;  /* remove new frame */
+            goto reentry;
+          }
+          case PCRC: {  /* it was a C function (`precall' called it) */
+            base = L->base;
+            continue;
+          }
+          default: {
+            return;  /* yield */
+          }
+        }
+      }
+      case OP_RETURN: {
+        int b = GETARG_B(i);
+        if (b != 0) L->top = ra+b-1;
+        if (L->openupval) luaF_close(L, base);
+        L->savedpc = pc;
+        b = luaD_poscall(L, ra);
+        if (--nexeccalls == 0)  /* was previous function running `here'? */
+          return;  /* no: return */
+        else {  /* yes: continue its execution */
+          if (b) L->top = L->ci->top;
+          lua_assert(isLua(L->ci));
+          lua_assert(GET_OPCODE(*((L->ci)->savedpc - 1)) == OP_CALL);
+          goto reentry;
+        }
+      }
+      case OP_FORLOOP: {
+        lua_Number step = nvalue(ra+2);
+        lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
+        lua_Number limit = nvalue(ra+1);
+        if (luai_numlt(0, step) ? luai_numle(idx, limit)
+                                : luai_numle(limit, idx)) {
+          dojump(L, pc, GETARG_sBx(i));  /* jump back */
+          setnvalue(ra, idx);  /* update internal index... */
+          setnvalue(ra+3, idx);  /* ...and external index */
+        }
+        continue;
+      }
+      case OP_FORPREP: {
+        const TValue *init = ra;
+        const TValue *plimit = ra+1;
+        const TValue *pstep = ra+2;
+        L->savedpc = pc;  /* next steps may throw errors */
+        if (!tonumber(init, ra))
+          luaG_runerror(L, LUA_QL("for") " initial value must be a number");
+        else if (!tonumber(plimit, ra+1))
+          luaG_runerror(L, LUA_QL("for") " limit must be a number");
+        else if (!tonumber(pstep, ra+2))
+          luaG_runerror(L, LUA_QL("for") " step must be a number");
+        setnvalue(ra, luai_numsub(nvalue(ra), nvalue(pstep)));
+        dojump(L, pc, GETARG_sBx(i));
+        continue;
+      }
+      case OP_TFORLOOP: {
+        StkId cb = ra + 3;  /* call base */
+        setobjs2s(L, cb+2, ra+2);
+        setobjs2s(L, cb+1, ra+1);
+        setobjs2s(L, cb, ra);
+        L->top = cb+3;  /* func. + 2 args (state and index) */
+        Protect(luaD_call(L, cb, GETARG_C(i)));
+        L->top = L->ci->top;
+        cb = RA(i) + 3;  /* previous call may change the stack */
+        if (!ttisnil(cb)) {  /* continue loop? */
+          setobjs2s(L, cb-1, cb);  /* save control variable */
+          dojump(L, pc, GETARG_sBx(*pc));  /* jump back */
+        }
+        pc++;
+        continue;
+      }
+      case OP_SETLIST: {
+        int n = GETARG_B(i);
+        int c = GETARG_C(i);
+        int last;
+        Table *h;
+        if (n == 0) {
+          n = cast_int(L->top - ra) - 1;
+          L->top = L->ci->top;
+        }
+        if (c == 0) c = cast_int(*pc++);
+        runtime_check(L, ttistable(ra));
+        h = hvalue(ra);
+        last = ((c-1)*LFIELDS_PER_FLUSH) + n;
+        if (last > h->sizearray)  /* needs more space? */
+          luaH_resizearray(L, h, last);  /* pre-alloc it at once */
+        for (; n > 0; n--) {
+          TValue *val = ra+n;
+          setobj2t(L, luaH_setnum(L, h, last--), val);
+          luaC_barriert(L, h, val);
+        }
+        continue;
+      }
+      case OP_CLOSE: {
+        luaF_close(L, ra);
+        continue;
+      }
+      case OP_CLOSURE: {
+        Proto *p;
+        Closure *ncl;
+        int nup, j;
+        p = cl->p->p[GETARG_Bx(i)];
+        nup = p->nups;
+        ncl = luaF_newLclosure(L, nup, cl->env);
+        ncl->l.p = p;
+        for (j=0; j<nup; j++, pc++) {
+          if (GET_OPCODE(*pc) == OP_GETUPVAL)
+            ncl->l.upvals[j] = cl->upvals[GETARG_B(*pc)];
+          else {
+            lua_assert(GET_OPCODE(*pc) == OP_MOVE);
+            ncl->l.upvals[j] = luaF_findupval(L, base + GETARG_B(*pc));
+          }
+        }
+        setclvalue(L, ra, ncl);
+        Protect(luaC_checkGC(L));
+        continue;
+      }
+      case OP_VARARG: {
+        int b = GETARG_B(i) - 1;
+        int j;
+        CallInfo *ci = L->ci;
+        int n = cast_int(ci->base - ci->func) - cl->p->numparams - 1;
+        if (b == LUA_MULTRET) {
+          Protect(luaD_checkstack(L, n));
+          ra = RA(i);  /* previous call may change the stack */
+          b = n;
+          L->top = ra + n;
+        }
+        for (j = 0; j < b; j++) {
+          if (j < n) {
+            setobjs2s(L, ra + j, ci->base - n + j);
+          }
+          else {
+            setnilvalue(ra + j);
+          }
+        }
+        continue;
+      }
+    }
+  }
+}
+
diff --git a/libraries/LuaJIT-1.1.7/src/lvm.h b/libraries/LuaJIT-1.1.7/src/lvm.h
new file mode 100644
index 0000000..506a294
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lvm.h
@@ -0,0 +1,40 @@
+/*
+** $Id: lvm.h,v 2.5.1.1 2007/12/27 13:02:25 roberto Exp $
+** Lua virtual machine
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lvm_h
+#define lvm_h
+
+
+#include "ldo.h"
+#include "lobject.h"
+#include "ltm.h"
+
+
+#define tostring(L,o) ((ttype(o) == LUA_TSTRING) || (luaV_tostring(L, o)))
+
+#define tonumber(o,n)   (ttype(o) == LUA_TNUMBER || \
+                         (((o) = luaV_tonumber(o,n)) != NULL))
+
+#define equalobj(L,o1,o2) \
+        (ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2))
+
+
+LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);
+LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r);
+LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2);
+LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);
+LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
+LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key,
+                                            StkId val);
+LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key,
+                                            StkId val);
+LUAI_FUNC void luaV_arith (lua_State *L, StkId ra, const TValue *rb,
+                                         const TValue *rc, TMS op);
+
+LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls);
+LUAI_FUNC void luaV_concat (lua_State *L, int total, int last);
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/lzio.c b/libraries/LuaJIT-1.1.7/src/lzio.c
new file mode 100644
index 0000000..293edd5
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lzio.c
@@ -0,0 +1,82 @@
+/*
+** $Id: lzio.c,v 1.31.1.1 2007/12/27 13:02:25 roberto Exp $
+** a generic input stream interface
+** See Copyright Notice in lua.h
+*/
+
+
+#include <string.h>
+
+#define lzio_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "llimits.h"
+#include "lmem.h"
+#include "lstate.h"
+#include "lzio.h"
+
+
+int luaZ_fill (ZIO *z) {
+  size_t size;
+  lua_State *L = z->L;
+  const char *buff;
+  lua_unlock(L);
+  buff = z->reader(L, z->data, &size);
+  lua_lock(L);
+  if (buff == NULL || size == 0) return EOZ;
+  z->n = size - 1;
+  z->p = buff;
+  return char2int(*(z->p++));
+}
+
+
+int luaZ_lookahead (ZIO *z) {
+  if (z->n == 0) {
+    if (luaZ_fill(z) == EOZ)
+      return EOZ;
+    else {
+      z->n++;  /* luaZ_fill removed first byte; put back it */
+      z->p--;
+    }
+  }
+  return char2int(*z->p);
+}
+
+
+void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) {
+  z->L = L;
+  z->reader = reader;
+  z->data = data;
+  z->n = 0;
+  z->p = NULL;
+}
+
+
+/* --------------------------------------------------------------- read --- */
+size_t luaZ_read (ZIO *z, void *b, size_t n) {
+  while (n) {
+    size_t m;
+    if (luaZ_lookahead(z) == EOZ)
+      return n;  /* return number of missing bytes */
+    m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
+    memcpy(b, z->p, m);
+    z->n -= m;
+    z->p += m;
+    b = (char *)b + m;
+    n -= m;
+  }
+  return 0;
+}
+
+/* ------------------------------------------------------------------------ */
+char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) {
+  if (n > buff->buffsize) {
+    if (n < LUA_MINBUFFER) n = LUA_MINBUFFER;
+    luaZ_resizebuffer(L, buff, n);
+  }
+  return buff->buffer;
+}
+
+
diff --git a/libraries/LuaJIT-1.1.7/src/lzio.h b/libraries/LuaJIT-1.1.7/src/lzio.h
new file mode 100644
index 0000000..51d695d
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/lzio.h
@@ -0,0 +1,67 @@
+/*
+** $Id: lzio.h,v 1.21.1.1 2007/12/27 13:02:25 roberto Exp $
+** Buffered streams
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lzio_h
+#define lzio_h
+
+#include "lua.h"
+
+#include "lmem.h"
+
+
+#define EOZ     (-1)                    /* end of stream */
+
+typedef struct Zio ZIO;
+
+#define char2int(c)     cast(int, cast(unsigned char, (c)))
+
+#define zgetc(z)  (((z)->n--)>0 ?  char2int(*(z)->p++) : luaZ_fill(z))
+
+typedef struct Mbuffer {
+  char *buffer;
+  size_t n;
+  size_t buffsize;
+} Mbuffer;
+
+#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
+
+#define luaZ_buffer(buff)       ((buff)->buffer)
+#define luaZ_sizebuffer(buff)   ((buff)->buffsize)
+#define luaZ_bufflen(buff)      ((buff)->n)
+
+#define luaZ_resetbuffer(buff) ((buff)->n = 0)
+
+
+#define luaZ_resizebuffer(L, buff, size) \
+        (luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \
+        (buff)->buffsize = size)
+
+#define luaZ_freebuffer(L, buff)        luaZ_resizebuffer(L, buff, 0)
+
+
+LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n);
+LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
+                                        void *data);
+LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n); /* read next n bytes */
+LUAI_FUNC int luaZ_lookahead (ZIO *z);
+
+
+
+/* --------- Private Part ------------------ */
+
+struct Zio {
+  size_t n;                     /* bytes still unread */
+  const char *p;                /* current position in buffer */
+  lua_Reader reader;
+  void* data;                   /* additional data */
+  lua_State *L;                 /* Lua state (for reader) */
+};
+
+
+LUAI_FUNC int luaZ_fill (ZIO *z);
+
+#endif
diff --git a/libraries/LuaJIT-1.1.7/src/print.c b/libraries/LuaJIT-1.1.7/src/print.c
new file mode 100644
index 0000000..e240cfc
--- /dev/null
+++ b/libraries/LuaJIT-1.1.7/src/print.c
@@ -0,0 +1,227 @@
+/*
+** $Id: print.c,v 1.55a 2006/05/31 13:30:05 lhf Exp $
+** print bytecodes
+** See Copyright Notice in lua.h
+*/
+
+#include <ctype.h>
+#include <stdio.h>
+
+#define luac_c
+#define LUA_CORE
+
+#include "ldebug.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lundump.h"
+
+#define PrintFunction   luaU_print
+
+#define Sizeof(x)       ((int)sizeof(x))
+#define VOID(p)         ((const void*)(p))
+
+static void PrintString(const TString* ts)
+{
+ const char* s=getstr(ts);
+ size_t i,n=ts->tsv.len;
+ putchar('"');
+ for (i=0; i<n; i++)
+ {
+  int c=s[i];
+  switch (c)
+  {
+   case '"': printf("\\\""); break;
+   case '\\': printf("\\\\"); break;
+   case '\a': printf("\\a"); break;
+   case '\b': printf("\\b"); break;
+   case '\f': printf("\\f"); break;
+   case '\n': printf("\\n"); break;
+   case '\r': printf("\\r"); break;
+   case '\t': printf("\\t"); break;
+   case '\v': printf("\\v"); break;
+   default:     if (isprint((unsigned char)c))
+                        putchar(c);
+                else
+                        printf("\\%03u",(unsigned char)c);
+  }
+ }
+ putchar('"');
+}
+
+static void PrintConstant(const Proto* f, int i)
+{
+ const TValue* o=&f->k[i];
+ switch (ttype(o))
+ {
+  case LUA_TNIL:
+        printf("nil");
+        break;
+  case LUA_TBOOLEAN:
+        printf(bvalue(o) ? "true" : "false");
+        break;
+  case LUA_TNUMBER:
+        printf(LUA_NUMBER_FMT,nvalue(o));
+        break;
+  case LUA_TSTRING:
+        PrintString(rawtsvalue(o));
+        break;
+  default:                              /* cannot happen */
+        printf("? type=%d",ttype(o));
+        break;
+ }
+}
+
+static void PrintCode(const Proto* f)
+{
+ const Instruction* code=f->code;
+ int pc,n=f->sizecode;
+ for (pc=0; pc<n; pc++)
+ {
+  Instruction i=code[pc];
+  OpCode o=GET_OPCODE(i);
+  int a=GETARG_A(i);
+  int b=GETARG_B(i);
+  int c=GETARG_C(i);
+  int bx=GETARG_Bx(i);
+  int sbx=GETARG_sBx(i);
+  int line=getline(f,pc);
+  printf("\t%d\t",pc+1);
+  if (line>0) printf("[%d]\t",line); else printf("[-]\t");
+  printf("%-9s\t",luaP_opnames[o]);
+  switch (getOpMode(o))
+  {
+   case iABC:
+    printf("%d",a);
+    if (getBMode(o)!=OpArgN) printf(" %d",ISK(b) ? (-1-INDEXK(b)) : b);
+    if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (-1-INDEXK(c)) : c);
+    break;
+   case iABx:
+    if (getBMode(o)==OpArgK) printf("%d %d",a,-1-bx); else printf("%d %d",a,bx);
+    break;
+   case iAsBx:
+    if (o==OP_JMP) printf("%d",sbx); else printf("%d %d",a,sbx);
+    break;
+  }
+  switch (o)
+  {
+   case OP_LOADK:
+    printf("\t; "); PrintConstant(f,bx);
+    break;
+   case OP_GETUPVAL:
+   case OP_SETUPVAL:
+    printf("\t; %s", (f->sizeupvalues>0) ? getstr(f->upvalues[b]) : "-");
+    break;
+   case OP_GETGLOBAL:
+   case OP_SETGLOBAL:
+    printf("\t; %s",svalue(&f->k[bx]));
+    break;
+   case OP_GETTABLE:
+   case OP_SELF:
+    if (ISK(c)) { printf("\t; "); PrintConstant(f,INDEXK(c)); }
+    break;
+   case OP_SETTABLE:
+   case OP_ADD:
+   case OP_SUB:
+   case OP_MUL:
+   case OP_DIV:
+   case OP_POW:
+   case OP_EQ:
+   case OP_LT:
+   case OP_LE:
+    if (ISK(b) || ISK(c))
+    {
+     printf("\t; ");
+     if (ISK(b)) PrintConstant(f,INDEXK(b)); else printf("-");
+     printf(" ");
+     if (ISK(c)) PrintConstant(f,INDEXK(c)); else printf("-");
+    }
+    break;
+   case OP_JMP:
+   case OP_FORLOOP:
+   case OP_FORPREP:
+    printf("\t; to %d",sbx+pc+2);
+    break;
+   case OP_CLOSURE:
+    printf("\t; %p",VOID(f->p[bx]));
+    break;
+   case OP_SETLIST:
+    if (c==0) printf("\t; %d",(int)code[++pc]);
+    else printf("\t; %d",c);
+    break;
+   default:
+    break;
+  }
+  printf("\n");
+ }
+}
+
+#define SS(x)   (x==1)?"":"s"
+#define S(x)    x,SS(x)
+
+static void PrintHeader(const Proto* f)
+{
+ const char* s=getstr(f->source);
+ if (*s=='@' || *s=='=')
+  s++;
+ else if (*s==LUA_SIGNATURE[0])
+  s="(bstring)";
+ else
+  s="(string)";
+ printf("\n%s <%s:%d,%d> (%d instruction%s, %d bytes at %p)\n",
+        (f->linedefined==0)?"main":"function",s,
+        f->linedefined,f->lastlinedefined,
+        S(f->sizecode),f->sizecode*Sizeof(Instruction),VOID(f));
+ printf("%d%s param%s, %d slot%s, %d upvalue%s, ",
+        f->numparams,f->is_vararg?"+":"",SS(f->numparams),
+        S(f->maxstacksize),S(f->nups));
+ printf("%d local%s, %d constant%s, %d function%s\n",
+        S(f->sizelocvars),S(f->sizek),S(f->sizep));
+}
+
+static void PrintConstants(const Proto* f)
+{
+ int i,n=f->sizek;
+ printf("constants (%d) for %p:\n",n,VOID(f));
+ for (i=0; i<n; i++)
+ {
+  printf("\t%d\t",i+1);
+  PrintConstant(f,i);
+  printf("\n");
+ }
+}
+
+static void PrintLocals(const Proto* f)
+{
+ int i,n=f->sizelocvars;
+ printf("locals (%d) for %p:\n",n,VOID(f));
+ for (i=0; i<n; i++)
+ {
+  printf("\t%d\t%s\t%d\t%d\n",
+  i,getstr(f->locvars[i].varname),f->locvars[i].startpc+1,f->locvars[i].endpc+1);
+ }
+}
+
+static void PrintUpvalues(const Proto* f)
+{
+ int i,n=f->sizeupvalues;
+ printf("upvalues (%d) for %p:\n",n,VOID(f));
+ if (f->upvalues==NULL) return;
+ for (i=0; i<n; i++)
+ {
+  printf("\t%d\t%s\n",i,getstr(f->upvalues[i]));
+ }
+}
+
+void PrintFunction(const Proto* f, int full)
+{
+ int i,n=f->sizep;
+ PrintHeader(f);
+ PrintCode(f);
+ if (full)
+ {
+  PrintConstants(f);
+  PrintLocals(f);
+  PrintUpvalues(f);
+ }
+ for (i=0; i<n; i++) PrintFunction(f->p[i],full);
+}