From 507243197972f359f7eb356c8e588b30c9425d72 Mon Sep 17 00:00:00 2001
From: lmj01 <lmj01@users.noreply.github.com>
Date: Sat, 27 Apr 2024 14:54:06 +0800
Subject: [PATCH] update

---
 books/Learn OpenGL.md                         |     7 -
 books/Software Engineering at Google.md       |     5 -
 ...32\345\210\260\345\215\223\350\266\212.md" |     9 -
 {babylonjs => cg/babylonjs}/component.md      |     0
 {babylonjs => cg/babylonjs}/dev.md            |     0
 {babylonjs => cg/babylonjs}/index.md          |     0
 {babylonjs => cg/babylonjs}/material.md       |     0
 {babylonjs => cg/babylonjs}/mesh.md           |     0
 {babylonjs => cg/babylonjs}/rendering.md      |     0
 {babylonjs => cg/babylonjs}/shader.md         |     0
 {babylonjs => cg/babylonjs}/webgpu.md         |     0
 {blender => cg/blender}/concepts/addon.md     |     0
 {blender => cg/blender}/concepts/blender.md   |     0
 {blender => cg/blender}/concepts/creator.md   |     0
 {blender => cg/blender}/concepts/data_api.md  |     0
 {blender => cg/blender}/concepts/ghost.md     |     0
 {blender => cg/blender}/concepts/loader.md    |     0
 {blender => cg/blender}/concepts/operator.md  |     0
 {blender => cg/blender}/concepts/python.md    |     0
 {blender => cg/blender}/concepts/splash.md    |     0
 .../blender}/concepts/windowmanager.md        |     0
 {blender => cg/blender}/cycles.md             |     0
 {blender => cg/blender}/dependency-graph.md   |    68 +-
 {blender => cg/blender}/draw/index.md         |     0
 {blender => cg/blender}/guardedalloc.md       |     0
 .../blender}/images/Context_2.5_what.png      |   Bin
 {blender => cg/blender}/index.md              |    26 +-
 {blender => cg/blender}/intern/mem.md         |     0
 {blender => cg/blender}/source/blenkernal.md  |    14 +-
 {blender => cg/blender}/source/camera.md      |     0
 {blender => cg/blender}/source/gizmo.md       |     0
 {blender => cg/blender}/source/makesrna.md    |     0
 .../source/module-editors/interface.md        |     0
 .../blender}/source/module-kernel/context.md  |     0
 .../blender}/source/module-lib/ghash.md       |     0
 .../blender}/source/module-lib/index.md       |     0
 .../blender}/source/module-lib/linklist.md    |     0
 .../blender}/source/module-lib/memarena.md    |     0
 .../blender}/source/module-python/index.md    |     0
 .../blender}/source/module-wm/draw.md         |     0
 {blender => cg/blender}/source/module.md      |     0
 {blender => cg/blender}/source/thinked.md     |    54 +-
 {blender => cg/blender}/source/tmp.md         |     4 +-
 cpl/lua.md                                    |   152 +-
 {lua => cpl}/tests-lua/all.lua                |     0
 {lua => cpl}/tests-lua/api.lua                |     0
 {lua => cpl}/tests-lua/attrib.lua             |     0
 {lua => cpl}/tests-lua/big.lua                |     0
 {lua => cpl}/tests-lua/bitwise.lua            |     0
 {lua => cpl}/tests-lua/calls.lua              |     0
 {lua => cpl}/tests-lua/checktable.lua         |     0
 {lua => cpl}/tests-lua/closure.lua            |     0
 {lua => cpl}/tests-lua/code.lua               |     0
 {lua => cpl}/tests-lua/constructs.lua         |     0
 {lua => cpl}/tests-lua/coroutine.lua          |     0
 {lua => cpl}/tests-lua/db.lua                 |     0
 {lua => cpl}/tests-lua/errors.lua             |     0
 {lua => cpl}/tests-lua/events.lua             |     0
 {lua => cpl}/tests-lua/files.lua              |     0
 {lua => cpl}/tests-lua/gc.lua                 |     0
 {lua => cpl}/tests-lua/goto.lua               |     0
 {lua => cpl}/tests-lua/heavy.lua              |     0
 {lua => cpl}/tests-lua/literals.lua           |     0
 {lua => cpl}/tests-lua/locals.lua             |     0
 {lua => cpl}/tests-lua/main.lua               |     0
 {lua => cpl}/tests-lua/math.lua               |     0
 {lua => cpl}/tests-lua/nextvar.lua            |     0
 {lua => cpl}/tests-lua/pm.lua                 |     0
 {lua => cpl/tests-lua}/skynet.md              |   136 +-
 {lua => cpl}/tests-lua/sort.lua               |     0
 {lua => cpl}/tests-lua/strings.lua            |     0
 {lua => cpl}/tests-lua/tpack.lua              |     0
 {lua => cpl}/tests-lua/utf8.lua               |     0
 {lua => cpl}/tests-lua/vararg.lua             |     0
 {lua => cpl}/tests-lua/verybig.lua            |     0
 dev-note/debug.md                             |     8 -
 dev-note/index.md                             |    18 +
 dev-note/license.md                           |     4 -
 index.html                                    |    10 +-
 index/article-info.md                         |     3 +
 index/article.md                              |    18 -
 books/index.md => index/book-info.md          |    25 +-
 index/community.md                            |     5 +
 lua/lua-5.3.5/Makefile                        |   114 -
 lua/lua-5.3.5/README                          |     6 -
 lua/lua-5.3.5/doc/contents.html               |   619 -
 lua/lua-5.3.5/doc/index.css                   |    21 -
 lua/lua-5.3.5/doc/logo.gif                    |   Bin 9893 -> 0 bytes
 lua/lua-5.3.5/doc/lua.1                       |   112 -
 lua/lua-5.3.5/doc/lua.css                     |   161 -
 lua/lua-5.3.5/doc/luac.1                      |   118 -
 lua/lua-5.3.5/doc/manual.css                  |    21 -
 lua/lua-5.3.5/doc/manual.html                 | 10982 ----------------
 lua/lua-5.3.5/doc/osi-certified-72x60.png     |   Bin 3774 -> 0 bytes
 lua/lua-5.3.5/doc/readme.html                 |   365 -
 lua/lua-5.3.5/src/Makefile                    |   197 -
 lua/lua-5.3.5/src/lapi.c                      |  1299 --
 lua/lua-5.3.5/src/lapi.h                      |    24 -
 lua/lua-5.3.5/src/lauxlib.c                   |  1043 --
 lua/lua-5.3.5/src/lauxlib.h                   |   264 -
 lua/lua-5.3.5/src/lbaselib.c                  |   498 -
 lua/lua-5.3.5/src/lbitlib.c                   |   233 -
 lua/lua-5.3.5/src/lcode.c                     |  1203 --
 lua/lua-5.3.5/src/lcode.h                     |    88 -
 lua/lua-5.3.5/src/lcorolib.c                  |   168 -
 lua/lua-5.3.5/src/lctype.c                    |    55 -
 lua/lua-5.3.5/src/lctype.h                    |    95 -
 lua/lua-5.3.5/src/ldblib.c                    |   456 -
 lua/lua-5.3.5/src/ldebug.c                    |   699 -
 lua/lua-5.3.5/src/ldebug.h                    |    39 -
 lua/lua-5.3.5/src/ldo.c                       |   802 --
 lua/lua-5.3.5/src/ldo.h                       |    58 -
 lua/lua-5.3.5/src/ldump.c                     |   215 -
 lua/lua-5.3.5/src/lfunc.c                     |   151 -
 lua/lua-5.3.5/src/lfunc.h                     |    61 -
 lua/lua-5.3.5/src/lgc.c                       |  1179 --
 lua/lua-5.3.5/src/lgc.h                       |   147 -
 lua/lua-5.3.5/src/liblua.a                    |   Bin 454396 -> 0 bytes
 lua/lua-5.3.5/src/linit.c                     |    68 -
 lua/lua-5.3.5/src/liolib.c                    |   776 --
 lua/lua-5.3.5/src/llex.c                      |   565 -
 lua/lua-5.3.5/src/llex.h                      |    85 -
 lua/lua-5.3.5/src/llimits.h                   |   323 -
 lua/lua-5.3.5/src/lmathlib.c                  |   410 -
 lua/lua-5.3.5/src/lmem.c                      |   100 -
 lua/lua-5.3.5/src/lmem.h                      |    69 -
 lua/lua-5.3.5/src/loadlib.c                   |   790 --
 lua/lua-5.3.5/src/lobject.c                   |   522 -
 lua/lua-5.3.5/src/lobject.h                   |   549 -
 lua/lua-5.3.5/src/lopcodes.c                  |   124 -
 lua/lua-5.3.5/src/lopcodes.h                  |   297 -
 lua/lua-5.3.5/src/loslib.c                    |   409 -
 lua/lua-5.3.5/src/lparser.c                   |  1650 ---
 lua/lua-5.3.5/src/lparser.h                   |   133 -
 lua/lua-5.3.5/src/lprefix.h                   |    45 -
 lua/lua-5.3.5/src/lstate.c                    |   347 -
 lua/lua-5.3.5/src/lstate.h                    |   253 -
 lua/lua-5.3.5/src/lstring.c                   |   248 -
 lua/lua-5.3.5/src/lstring.h                   |    49 -
 lua/lua-5.3.5/src/lstrlib.c                   |  1584 ---
 lua/lua-5.3.5/src/ltable.c                    |   688 -
 lua/lua-5.3.5/src/ltable.h                    |    66 -
 lua/lua-5.3.5/src/ltablib.c                   |   450 -
 lua/lua-5.3.5/src/ltm.c                       |   165 -
 lua/lua-5.3.5/src/ltm.h                       |    76 -
 lua/lua-5.3.5/src/lua                         |   Bin 268752 -> 0 bytes
 lua/lua-5.3.5/src/lua.c                       |   612 -
 lua/lua-5.3.5/src/lua.h                       |   486 -
 lua/lua-5.3.5/src/lua.hpp                     |     9 -
 lua/lua-5.3.5/src/luac                        |   Bin 175208 -> 0 bytes
 lua/lua-5.3.5/src/luac.c                      |   450 -
 lua/lua-5.3.5/src/luaconf.h                   |   790 --
 lua/lua-5.3.5/src/lualib.h                    |    61 -
 lua/lua-5.3.5/src/lundump.c                   |   279 -
 lua/lua-5.3.5/src/lundump.h                   |    32 -
 lua/lua-5.3.5/src/lutf8lib.c                  |   256 -
 lua/lua-5.3.5/src/lvm.c                       |  1322 --
 lua/lua-5.3.5/src/lvm.h                       |   113 -
 lua/lua-5.3.5/src/lzio.c                      |    68 -
 lua/lua-5.3.5/src/lzio.h                      |    66 -
 lua/lua-5.3.5/src/opcode/arithmetic2.lua      |    15 -
 lua/lua-5.3.5/src/opcode/arithmetic3.lua      |    18 -
 lua/lua-5.3.5/src/opcode/call.lua             |    15 -
 lua/lua-5.3.5/src/opcode/call.tail.lua        |     8 -
 lua/lua-5.3.5/src/opcode/closure.lua          |    10 -
 lua/lua-5.3.5/src/opcode/concat.lua           |     9 -
 lua/lua-5.3.5/src/opcode/for.generic.lua      |    10 -
 lua/lua-5.3.5/src/opcode/for.lua              |    14 -
 lua/lua-5.3.5/src/opcode/jmp.lua              |    17 -
 lua/lua-5.3.5/src/opcode/len.lua              |     9 -
 lua/lua-5.3.5/src/opcode/list.lua             |    14 -
 lua/lua-5.3.5/src/opcode/loadbool.lua         |    33 -
 lua/lua-5.3.5/src/opcode/loadk.lua            |    10 -
 lua/lua-5.3.5/src/opcode/loadkx.lua           |    10 -
 lua/lua-5.3.5/src/opcode/loadnil.lua          |    11 -
 lua/lua-5.3.5/src/opcode/luac.out             |   Bin 277 -> 0 bytes
 lua/lua-5.3.5/src/opcode/move.lua             |    10 -
 lua/lua-5.3.5/src/opcode/return.lua           |    11 -
 lua/lua-5.3.5/src/opcode/self.lua             |    15 -
 lua/lua-5.3.5/src/opcode/table.lua            |    12 -
 lua/lua-5.3.5/src/opcode/table.set.get.lua    |    10 -
 lua/lua-5.3.5/src/opcode/test.logic.lua       |    11 -
 lua/lua-5.3.5/src/opcode/test.lua             |    17 -
 lua/lua-5.3.5/src/opcode/upvalue.global.lua   |    26 -
 lua/lua-5.3.5/src/opcode/vararg.lua           |    11 -
 lua/lua-5.3.5/src/test/c-call-lua.c           |    37 -
 lua/lua-5.3.5/src/test/c-lib.c                |    45 -
 lua/lua-5.3.5/src/test/c-lib.lua              |     7 -
 lua/lua-5.3.5/src/test/c-lib.sh               |     3 -
 lua/lua-5.3.5/src/test/c-print.lua            |     6 -
 lua/lua-5.3.5/src/test/callback.lua           |    17 -
 lua/lua-5.3.5/src/test/clib.so                |   Bin 8064 -> 0 bytes
 lua/lua-5.3.5/src/test/coroutine1.lua         |    21 -
 lua/lua-5.3.5/src/test/debug.lua              |    40 -
 lua/lua-5.3.5/src/test/dot.colon.lua          |    23 -
 lua/lua-5.3.5/src/test/dot.colon2.lua         |    23 -
 lua/lua-5.3.5/src/test/error.lua              |    36 -
 lua/lua-5.3.5/src/test/filter.lua             |    45 -
 lua/lua-5.3.5/src/test/io-file.lua            |    22 -
 lua/lua-5.3.5/src/test/lambda-calculus.lua    |   180 -
 lua/lua-5.3.5/src/test/lua.txt                |     1 -
 lua/lua-5.3.5/src/test/luac.out               |   Bin 372 -> 0 bytes
 lua/lua-5.3.5/src/test/module-calla.lua       |     8 -
 lua/lua-5.3.5/src/test/module-callb.lua       |     9 -
 lua/lua-5.3.5/src/test/module.lua             |    19 -
 lua/lua-5.3.5/src/test/nil.lua                |    14 -
 lua/lua-5.3.5/src/test/number.lua             |     9 -
 lua/lua-5.3.5/src/test/oop.lua                |    55 -
 lua/lua-5.3.5/src/test/permutation.lua        |    38 -
 lua/lua-5.3.5/src/test/productor-consumer.lua |    36 -
 lua/lua.md                                    |   154 -
 lua/tests-lua/luac.out                        |   Bin 60095 -> 0 bytes
 212 files changed, 356 insertions(+), 38262 deletions(-)
 delete mode 100644 books/Learn OpenGL.md
 delete mode 100644 books/Software Engineering at Google.md
 delete mode 100644 "books/\350\275\257\344\273\266\350\256\276\350\256\241-\344\273\216\344\270\223\344\270\232\345\210\260\345\215\223\350\266\212.md"
 rename {babylonjs => cg/babylonjs}/component.md (100%)
 rename {babylonjs => cg/babylonjs}/dev.md (100%)
 rename {babylonjs => cg/babylonjs}/index.md (100%)
 rename {babylonjs => cg/babylonjs}/material.md (100%)
 rename {babylonjs => cg/babylonjs}/mesh.md (100%)
 rename {babylonjs => cg/babylonjs}/rendering.md (100%)
 rename {babylonjs => cg/babylonjs}/shader.md (100%)
 rename {babylonjs => cg/babylonjs}/webgpu.md (100%)
 rename {blender => cg/blender}/concepts/addon.md (100%)
 rename {blender => cg/blender}/concepts/blender.md (100%)
 rename {blender => cg/blender}/concepts/creator.md (100%)
 rename {blender => cg/blender}/concepts/data_api.md (100%)
 rename {blender => cg/blender}/concepts/ghost.md (100%)
 rename {blender => cg/blender}/concepts/loader.md (100%)
 rename {blender => cg/blender}/concepts/operator.md (100%)
 rename {blender => cg/blender}/concepts/python.md (100%)
 rename {blender => cg/blender}/concepts/splash.md (100%)
 rename {blender => cg/blender}/concepts/windowmanager.md (100%)
 rename {blender => cg/blender}/cycles.md (100%)
 rename {blender => cg/blender}/dependency-graph.md (98%)
 rename {blender => cg/blender}/draw/index.md (100%)
 rename {blender => cg/blender}/guardedalloc.md (100%)
 rename {blender => cg/blender}/images/Context_2.5_what.png (100%)
 rename {blender => cg/blender}/index.md (78%)
 rename {blender => cg/blender}/intern/mem.md (100%)
 rename {blender => cg/blender}/source/blenkernal.md (91%)
 rename {blender => cg/blender}/source/camera.md (100%)
 rename {blender => cg/blender}/source/gizmo.md (100%)
 rename {blender => cg/blender}/source/makesrna.md (100%)
 rename {blender => cg/blender}/source/module-editors/interface.md (100%)
 rename {blender => cg/blender}/source/module-kernel/context.md (100%)
 rename {blender => cg/blender}/source/module-lib/ghash.md (100%)
 rename {blender => cg/blender}/source/module-lib/index.md (100%)
 rename {blender => cg/blender}/source/module-lib/linklist.md (100%)
 rename {blender => cg/blender}/source/module-lib/memarena.md (100%)
 rename {blender => cg/blender}/source/module-python/index.md (100%)
 rename {blender => cg/blender}/source/module-wm/draw.md (100%)
 rename {blender => cg/blender}/source/module.md (100%)
 rename {blender => cg/blender}/source/thinked.md (99%)
 rename {blender => cg/blender}/source/tmp.md (88%)
 rename {lua => cpl}/tests-lua/all.lua (100%)
 rename {lua => cpl}/tests-lua/api.lua (100%)
 rename {lua => cpl}/tests-lua/attrib.lua (100%)
 rename {lua => cpl}/tests-lua/big.lua (100%)
 rename {lua => cpl}/tests-lua/bitwise.lua (100%)
 rename {lua => cpl}/tests-lua/calls.lua (100%)
 rename {lua => cpl}/tests-lua/checktable.lua (100%)
 rename {lua => cpl}/tests-lua/closure.lua (100%)
 rename {lua => cpl}/tests-lua/code.lua (100%)
 rename {lua => cpl}/tests-lua/constructs.lua (100%)
 rename {lua => cpl}/tests-lua/coroutine.lua (100%)
 rename {lua => cpl}/tests-lua/db.lua (100%)
 rename {lua => cpl}/tests-lua/errors.lua (100%)
 rename {lua => cpl}/tests-lua/events.lua (100%)
 rename {lua => cpl}/tests-lua/files.lua (100%)
 rename {lua => cpl}/tests-lua/gc.lua (100%)
 rename {lua => cpl}/tests-lua/goto.lua (100%)
 rename {lua => cpl}/tests-lua/heavy.lua (100%)
 rename {lua => cpl}/tests-lua/literals.lua (100%)
 rename {lua => cpl}/tests-lua/locals.lua (100%)
 rename {lua => cpl}/tests-lua/main.lua (100%)
 rename {lua => cpl}/tests-lua/math.lua (100%)
 rename {lua => cpl}/tests-lua/nextvar.lua (100%)
 rename {lua => cpl}/tests-lua/pm.lua (100%)
 rename {lua => cpl/tests-lua}/skynet.md (98%)
 rename {lua => cpl}/tests-lua/sort.lua (100%)
 rename {lua => cpl}/tests-lua/strings.lua (100%)
 rename {lua => cpl}/tests-lua/tpack.lua (100%)
 rename {lua => cpl}/tests-lua/utf8.lua (100%)
 rename {lua => cpl}/tests-lua/vararg.lua (100%)
 rename {lua => cpl}/tests-lua/verybig.lua (100%)
 delete mode 100644 dev-note/debug.md
 create mode 100644 dev-note/index.md
 delete mode 100644 dev-note/license.md
 create mode 100644 index/article-info.md
 rename books/index.md => index/book-info.md (66%)
 delete mode 100644 lua/lua-5.3.5/Makefile
 delete mode 100644 lua/lua-5.3.5/README
 delete mode 100644 lua/lua-5.3.5/doc/contents.html
 delete mode 100644 lua/lua-5.3.5/doc/index.css
 delete mode 100644 lua/lua-5.3.5/doc/logo.gif
 delete mode 100644 lua/lua-5.3.5/doc/lua.1
 delete mode 100644 lua/lua-5.3.5/doc/lua.css
 delete mode 100644 lua/lua-5.3.5/doc/luac.1
 delete mode 100644 lua/lua-5.3.5/doc/manual.css
 delete mode 100644 lua/lua-5.3.5/doc/manual.html
 delete mode 100644 lua/lua-5.3.5/doc/osi-certified-72x60.png
 delete mode 100644 lua/lua-5.3.5/doc/readme.html
 delete mode 100644 lua/lua-5.3.5/src/Makefile
 delete mode 100644 lua/lua-5.3.5/src/lapi.c
 delete mode 100644 lua/lua-5.3.5/src/lapi.h
 delete mode 100644 lua/lua-5.3.5/src/lauxlib.c
 delete mode 100644 lua/lua-5.3.5/src/lauxlib.h
 delete mode 100644 lua/lua-5.3.5/src/lbaselib.c
 delete mode 100644 lua/lua-5.3.5/src/lbitlib.c
 delete mode 100644 lua/lua-5.3.5/src/lcode.c
 delete mode 100644 lua/lua-5.3.5/src/lcode.h
 delete mode 100644 lua/lua-5.3.5/src/lcorolib.c
 delete mode 100644 lua/lua-5.3.5/src/lctype.c
 delete mode 100644 lua/lua-5.3.5/src/lctype.h
 delete mode 100644 lua/lua-5.3.5/src/ldblib.c
 delete mode 100644 lua/lua-5.3.5/src/ldebug.c
 delete mode 100644 lua/lua-5.3.5/src/ldebug.h
 delete mode 100644 lua/lua-5.3.5/src/ldo.c
 delete mode 100644 lua/lua-5.3.5/src/ldo.h
 delete mode 100644 lua/lua-5.3.5/src/ldump.c
 delete mode 100644 lua/lua-5.3.5/src/lfunc.c
 delete mode 100644 lua/lua-5.3.5/src/lfunc.h
 delete mode 100644 lua/lua-5.3.5/src/lgc.c
 delete mode 100644 lua/lua-5.3.5/src/lgc.h
 delete mode 100644 lua/lua-5.3.5/src/liblua.a
 delete mode 100644 lua/lua-5.3.5/src/linit.c
 delete mode 100644 lua/lua-5.3.5/src/liolib.c
 delete mode 100644 lua/lua-5.3.5/src/llex.c
 delete mode 100644 lua/lua-5.3.5/src/llex.h
 delete mode 100644 lua/lua-5.3.5/src/llimits.h
 delete mode 100644 lua/lua-5.3.5/src/lmathlib.c
 delete mode 100644 lua/lua-5.3.5/src/lmem.c
 delete mode 100644 lua/lua-5.3.5/src/lmem.h
 delete mode 100644 lua/lua-5.3.5/src/loadlib.c
 delete mode 100644 lua/lua-5.3.5/src/lobject.c
 delete mode 100644 lua/lua-5.3.5/src/lobject.h
 delete mode 100644 lua/lua-5.3.5/src/lopcodes.c
 delete mode 100644 lua/lua-5.3.5/src/lopcodes.h
 delete mode 100644 lua/lua-5.3.5/src/loslib.c
 delete mode 100644 lua/lua-5.3.5/src/lparser.c
 delete mode 100644 lua/lua-5.3.5/src/lparser.h
 delete mode 100644 lua/lua-5.3.5/src/lprefix.h
 delete mode 100644 lua/lua-5.3.5/src/lstate.c
 delete mode 100644 lua/lua-5.3.5/src/lstate.h
 delete mode 100644 lua/lua-5.3.5/src/lstring.c
 delete mode 100644 lua/lua-5.3.5/src/lstring.h
 delete mode 100644 lua/lua-5.3.5/src/lstrlib.c
 delete mode 100644 lua/lua-5.3.5/src/ltable.c
 delete mode 100644 lua/lua-5.3.5/src/ltable.h
 delete mode 100644 lua/lua-5.3.5/src/ltablib.c
 delete mode 100644 lua/lua-5.3.5/src/ltm.c
 delete mode 100644 lua/lua-5.3.5/src/ltm.h
 delete mode 100644 lua/lua-5.3.5/src/lua
 delete mode 100644 lua/lua-5.3.5/src/lua.c
 delete mode 100644 lua/lua-5.3.5/src/lua.h
 delete mode 100644 lua/lua-5.3.5/src/lua.hpp
 delete mode 100644 lua/lua-5.3.5/src/luac
 delete mode 100644 lua/lua-5.3.5/src/luac.c
 delete mode 100644 lua/lua-5.3.5/src/luaconf.h
 delete mode 100644 lua/lua-5.3.5/src/lualib.h
 delete mode 100644 lua/lua-5.3.5/src/lundump.c
 delete mode 100644 lua/lua-5.3.5/src/lundump.h
 delete mode 100644 lua/lua-5.3.5/src/lutf8lib.c
 delete mode 100644 lua/lua-5.3.5/src/lvm.c
 delete mode 100644 lua/lua-5.3.5/src/lvm.h
 delete mode 100644 lua/lua-5.3.5/src/lzio.c
 delete mode 100644 lua/lua-5.3.5/src/lzio.h
 delete mode 100644 lua/lua-5.3.5/src/opcode/arithmetic2.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/arithmetic3.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/call.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/call.tail.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/closure.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/concat.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/for.generic.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/for.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/jmp.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/len.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/list.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/loadbool.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/loadk.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/loadkx.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/loadnil.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/luac.out
 delete mode 100644 lua/lua-5.3.5/src/opcode/move.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/return.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/self.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/table.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/table.set.get.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/test.logic.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/test.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/upvalue.global.lua
 delete mode 100644 lua/lua-5.3.5/src/opcode/vararg.lua
 delete mode 100644 lua/lua-5.3.5/src/test/c-call-lua.c
 delete mode 100644 lua/lua-5.3.5/src/test/c-lib.c
 delete mode 100644 lua/lua-5.3.5/src/test/c-lib.lua
 delete mode 100644 lua/lua-5.3.5/src/test/c-lib.sh
 delete mode 100644 lua/lua-5.3.5/src/test/c-print.lua
 delete mode 100644 lua/lua-5.3.5/src/test/callback.lua
 delete mode 100644 lua/lua-5.3.5/src/test/clib.so
 delete mode 100644 lua/lua-5.3.5/src/test/coroutine1.lua
 delete mode 100644 lua/lua-5.3.5/src/test/debug.lua
 delete mode 100644 lua/lua-5.3.5/src/test/dot.colon.lua
 delete mode 100644 lua/lua-5.3.5/src/test/dot.colon2.lua
 delete mode 100644 lua/lua-5.3.5/src/test/error.lua
 delete mode 100644 lua/lua-5.3.5/src/test/filter.lua
 delete mode 100644 lua/lua-5.3.5/src/test/io-file.lua
 delete mode 100644 lua/lua-5.3.5/src/test/lambda-calculus.lua
 delete mode 100644 lua/lua-5.3.5/src/test/lua.txt
 delete mode 100644 lua/lua-5.3.5/src/test/luac.out
 delete mode 100644 lua/lua-5.3.5/src/test/module-calla.lua
 delete mode 100644 lua/lua-5.3.5/src/test/module-callb.lua
 delete mode 100644 lua/lua-5.3.5/src/test/module.lua
 delete mode 100644 lua/lua-5.3.5/src/test/nil.lua
 delete mode 100644 lua/lua-5.3.5/src/test/number.lua
 delete mode 100644 lua/lua-5.3.5/src/test/oop.lua
 delete mode 100644 lua/lua-5.3.5/src/test/permutation.lua
 delete mode 100644 lua/lua-5.3.5/src/test/productor-consumer.lua
 delete mode 100644 lua/lua.md
 delete mode 100644 lua/tests-lua/luac.out

diff --git a/books/Learn OpenGL.md b/books/Learn OpenGL.md
deleted file mode 100644
index 6b5bd4a..0000000
--- a/books/Learn OpenGL.md	
+++ /dev/null
@@ -1,7 +0,0 @@
-# [Learn OpenGL](https://learnopengl.com/)
-
-## Advanced OpenGL
-
-### Stencil testing
-
-模板测试，Object outlining的流程处理给出了一个方案
\ No newline at end of file
diff --git a/books/Software Engineering at Google.md b/books/Software Engineering at Google.md
deleted file mode 100644
index a23351a..0000000
--- a/books/Software Engineering at Google.md	
+++ /dev/null
@@ -1,5 +0,0 @@
-# 前言
-编程与软件工程的重要因素
-- 时间
-- 规模
-- 权衡取舍
diff --git "a/books/\350\275\257\344\273\266\350\256\276\350\256\241-\344\273\216\344\270\223\344\270\232\345\210\260\345\215\223\350\266\212.md" "b/books/\350\275\257\344\273\266\350\256\276\350\256\241-\344\273\216\344\270\223\344\270\232\345\210\260\345\215\223\350\266\212.md"
deleted file mode 100644
index 0501ece..0000000
--- "a/books/\350\275\257\344\273\266\350\256\276\350\256\241-\344\273\216\344\270\223\344\270\232\345\210\260\345\215\223\350\266\212.md"
+++ /dev/null
@@ -1,9 +0,0 @@
-#
-
-## 优质代码的外部特征
-### 1.3.1 为什么代码难以理解
-业务概念共识是一个很重要的因素，很多问题可能都是因为没有共识，产生了认识与理解上的差异。
-以一种范式理解另一种范式是很容易产生的，这样的问题也会非常多。
-### 1.5.2 提升复用能力的手段
-==选择合适的复用粒度==
-业务模块的复用，也有比较成熟的经验了，就是以领域为中心的设计。通过恰当的确定问题的领域边界，保持各个子域边界之间的抽象和隔离，就是典型的例子。如短信发送、地图服务、聊天消息等模块。
diff --git a/babylonjs/component.md b/cg/babylonjs/component.md
similarity index 100%
rename from babylonjs/component.md
rename to cg/babylonjs/component.md
diff --git a/babylonjs/dev.md b/cg/babylonjs/dev.md
similarity index 100%
rename from babylonjs/dev.md
rename to cg/babylonjs/dev.md
diff --git a/babylonjs/index.md b/cg/babylonjs/index.md
similarity index 100%
rename from babylonjs/index.md
rename to cg/babylonjs/index.md
diff --git a/babylonjs/material.md b/cg/babylonjs/material.md
similarity index 100%
rename from babylonjs/material.md
rename to cg/babylonjs/material.md
diff --git a/babylonjs/mesh.md b/cg/babylonjs/mesh.md
similarity index 100%
rename from babylonjs/mesh.md
rename to cg/babylonjs/mesh.md
diff --git a/babylonjs/rendering.md b/cg/babylonjs/rendering.md
similarity index 100%
rename from babylonjs/rendering.md
rename to cg/babylonjs/rendering.md
diff --git a/babylonjs/shader.md b/cg/babylonjs/shader.md
similarity index 100%
rename from babylonjs/shader.md
rename to cg/babylonjs/shader.md
diff --git a/babylonjs/webgpu.md b/cg/babylonjs/webgpu.md
similarity index 100%
rename from babylonjs/webgpu.md
rename to cg/babylonjs/webgpu.md
diff --git a/blender/concepts/addon.md b/cg/blender/concepts/addon.md
similarity index 100%
rename from blender/concepts/addon.md
rename to cg/blender/concepts/addon.md
diff --git a/blender/concepts/blender.md b/cg/blender/concepts/blender.md
similarity index 100%
rename from blender/concepts/blender.md
rename to cg/blender/concepts/blender.md
diff --git a/blender/concepts/creator.md b/cg/blender/concepts/creator.md
similarity index 100%
rename from blender/concepts/creator.md
rename to cg/blender/concepts/creator.md
diff --git a/blender/concepts/data_api.md b/cg/blender/concepts/data_api.md
similarity index 100%
rename from blender/concepts/data_api.md
rename to cg/blender/concepts/data_api.md
diff --git a/blender/concepts/ghost.md b/cg/blender/concepts/ghost.md
similarity index 100%
rename from blender/concepts/ghost.md
rename to cg/blender/concepts/ghost.md
diff --git a/blender/concepts/loader.md b/cg/blender/concepts/loader.md
similarity index 100%
rename from blender/concepts/loader.md
rename to cg/blender/concepts/loader.md
diff --git a/blender/concepts/operator.md b/cg/blender/concepts/operator.md
similarity index 100%
rename from blender/concepts/operator.md
rename to cg/blender/concepts/operator.md
diff --git a/blender/concepts/python.md b/cg/blender/concepts/python.md
similarity index 100%
rename from blender/concepts/python.md
rename to cg/blender/concepts/python.md
diff --git a/blender/concepts/splash.md b/cg/blender/concepts/splash.md
similarity index 100%
rename from blender/concepts/splash.md
rename to cg/blender/concepts/splash.md
diff --git a/blender/concepts/windowmanager.md b/cg/blender/concepts/windowmanager.md
similarity index 100%
rename from blender/concepts/windowmanager.md
rename to cg/blender/concepts/windowmanager.md
diff --git a/blender/cycles.md b/cg/blender/cycles.md
similarity index 100%
rename from blender/cycles.md
rename to cg/blender/cycles.md
diff --git a/blender/dependency-graph.md b/cg/blender/dependency-graph.md
similarity index 98%
rename from blender/dependency-graph.md
rename to cg/blender/dependency-graph.md
index 4a06838..0f9254b 100644
--- a/blender/dependency-graph.md
+++ b/cg/blender/dependency-graph.md
@@ -1,34 +1,34 @@
-
-# Blender Dependency Graph
-> the depsgraph(dependency graph) and evaluation system in blender is most important one![Depnedency Graph Ideas](https://archive.blender.org/wiki/index.php/User:Brecht/Depsgraph/), [Depsgraph 2012](https://archive.blender.org/wiki/index.php/User:Ton/Depsgraph_2012/)
-
-***
-
-## 介绍
-依赖关系图主要的目的就是在改变下的场景数据以更加高效的方式更新，就是只更新改变的数据。依赖关系图节点是场景中的实体对象，边是这些实体对象之间的关系。2.8之前的场景树主要维护的是层次关系，并不能即使更新变动的某些参数，需要重新绘制，这样会导致渲染的帧数降低。
-简明的说就是依赖关系图的责任就是动态更新场景，那些随着时间变化的值，不是一次次的重新绘制。
-
-## 总览
-![Data Flow 2.8](https://wiki.blender.org/w/images/a/a6/Dev-Blender_2.8_Data_Flow.png)
-从2.7x系列的改变有
-- 直接从外部存储获得DNA数据
-- 依赖关系图作用于所有请求改变的，如修改器，这些都是DNA data的拷贝上产生的
-- 依赖关系图自身保存所有evaluation的结果，不对原始DNA data产生任何作用
-- 渲染引擎仅使用依赖关系图提供的数据，永不接触到原始DNA data
-
-## 依赖关系图的拥有者
-Workspace概念，window拥有依赖关系图，每当更改渲染引擎或场景layer时会重新生成依赖关系图，渲染结构拥有依赖关系图，任何变化都会体现在渲染的结果上。
-过去很长一段时间，Blender使用原始对象的DNA结构进行处理，导致有些算法会在不同需求下对数据进行两次执行，产生副作用。改变就是仅有一个API去获取原始数据
-
-## 依赖关系图的数据何时场景？
-理想的是所有的数据尽可能延迟创建，新数据的成绩应该发生在线程中。当前2.8版本的依赖关系图的设计是在依赖关系图构建的时候，这里使用的是pointers evaluation functions，即创建影子内存块，不填充数据，所有的数据都是拷贝自evaluation threads。
-
-## 如何避免大量数据的拷贝？
-创建一些容器来存放一些轻量的数据结构，如Mesh Structure，这样也可以使用Mesh中的VBOs
-
-## Mesh objects 和 Non-mesh objects
-所有被计算的都保持为Mesh，让我们使用单一的API获取产生的数据和消除临时数据，也使得第三方渲染引擎和导出工具更通用
-针对curves，NURBS，meta balls等Non-mesh对象的处理，遵循两个原则
-- 数据是as-is的关系，不需要改变surface evaluation
-- 转换evaluated result到Mesh，除非渲染引擎告诉我们它自己知道如何处理non-mesh objects
-
+
+# Blender Dependency Graph
+> the depsgraph(dependency graph) and evaluation system in blender is most important one![Depnedency Graph Ideas](https://archive.blender.org/wiki/index.php/User:Brecht/Depsgraph/), [Depsgraph 2012](https://archive.blender.org/wiki/index.php/User:Ton/Depsgraph_2012/)
+
+***
+
+## 介绍
+依赖关系图主要的目的就是在改变下的场景数据以更加高效的方式更新，就是只更新改变的数据。依赖关系图节点是场景中的实体对象，边是这些实体对象之间的关系。2.8之前的场景树主要维护的是层次关系，并不能即使更新变动的某些参数，需要重新绘制，这样会导致渲染的帧数降低。
+简明的说就是依赖关系图的责任就是动态更新场景，那些随着时间变化的值，不是一次次的重新绘制。
+
+## 总览
+![Data Flow 2.8](https://wiki.blender.org/w/images/a/a6/Dev-Blender_2.8_Data_Flow.png)
+从2.7x系列的改变有
+- 直接从外部存储获得DNA数据
+- 依赖关系图作用于所有请求改变的，如修改器，这些都是DNA data的拷贝上产生的
+- 依赖关系图自身保存所有evaluation的结果，不对原始DNA data产生任何作用
+- 渲染引擎仅使用依赖关系图提供的数据，永不接触到原始DNA data
+
+## 依赖关系图的拥有者
+Workspace概念，window拥有依赖关系图，每当更改渲染引擎或场景layer时会重新生成依赖关系图，渲染结构拥有依赖关系图，任何变化都会体现在渲染的结果上。
+过去很长一段时间，Blender使用原始对象的DNA结构进行处理，导致有些算法会在不同需求下对数据进行两次执行，产生副作用。改变就是仅有一个API去获取原始数据
+
+## 依赖关系图的数据何时场景？
+理想的是所有的数据尽可能延迟创建，新数据的成绩应该发生在线程中。当前2.8版本的依赖关系图的设计是在依赖关系图构建的时候，这里使用的是pointers evaluation functions，即创建影子内存块，不填充数据，所有的数据都是拷贝自evaluation threads。
+
+## 如何避免大量数据的拷贝？
+创建一些容器来存放一些轻量的数据结构，如Mesh Structure，这样也可以使用Mesh中的VBOs
+
+## Mesh objects 和 Non-mesh objects
+所有被计算的都保持为Mesh，让我们使用单一的API获取产生的数据和消除临时数据，也使得第三方渲染引擎和导出工具更通用
+针对curves，NURBS，meta balls等Non-mesh对象的处理，遵循两个原则
+- 数据是as-is的关系，不需要改变surface evaluation
+- 转换evaluated result到Mesh，除非渲染引擎告诉我们它自己知道如何处理non-mesh objects
+
diff --git a/blender/draw/index.md b/cg/blender/draw/index.md
similarity index 100%
rename from blender/draw/index.md
rename to cg/blender/draw/index.md
diff --git a/blender/guardedalloc.md b/cg/blender/guardedalloc.md
similarity index 100%
rename from blender/guardedalloc.md
rename to cg/blender/guardedalloc.md
diff --git a/blender/images/Context_2.5_what.png b/cg/blender/images/Context_2.5_what.png
similarity index 100%
rename from blender/images/Context_2.5_what.png
rename to cg/blender/images/Context_2.5_what.png
diff --git a/blender/index.md b/cg/blender/index.md
similarity index 78%
rename from blender/index.md
rename to cg/blender/index.md
index c5bd701..69be1e5 100644
--- a/blender/index.md
+++ b/cg/blender/index.md
@@ -48,20 +48,20 @@ grep -rn "XXXFunction" --include="*.c"
 
 ### 记录
 
-- [一些概念](./concepts/blender.md)
-- [creator](./concepts/creator.md)
-- [splash](./concepts/splash.md)
-- [module window manager](./concepts/windowmanager.md)
-- [module ghost -- General Handy Operating System Toolkit](./concepts/ghost.md)
-- [operator](./concepts/operator.md)
-- [data api](./concepts/data_api.md)
-- [addons](./concepts/addon.md)
-- [python](./concepts/python.md)
-- [draw and shader](./concepts/index.md)
-- [loader -- read and write .blend format](./concepts/loader.md)
+- [一些概念](/cg/blender/concepts/blender.md)
+- [creator](/cg/blender/concepts/creator.md)
+- [splash](/cg/blender/concepts/splash.md)
+- [module window manager](/cg/blender/concepts/windowmanager.md)
+- [module ghost -- General Handy Operating System Toolkit](/cg/blender/concepts/ghost.md)
+- [operator](/cg/blender/concepts/operator.md)
+- [data api](/cg/blender/concepts/data_api.md)
+- [addons](/cg/blender/concepts/addon.md)
+- [python](/cg/blender/concepts/python.md)
+- [draw and shader](/cg/blender/concepts/index.md)
+- [loader -- read and write .blend format](/cg/blender/concepts/loader.md)
 - module editor
-    - [interface](./editors/interface.md)
-- [cycles渲染器](./cycles.md)
+    - [interface](/cg/blender/editors/interface.md)
+- [cycles渲染器](/cg/blender/cycles.md)
 
 ## wiki
 
diff --git a/blender/intern/mem.md b/cg/blender/intern/mem.md
similarity index 100%
rename from blender/intern/mem.md
rename to cg/blender/intern/mem.md
diff --git a/blender/source/blenkernal.md b/cg/blender/source/blenkernal.md
similarity index 91%
rename from blender/source/blenkernal.md
rename to cg/blender/source/blenkernal.md
index 0852ac0..84e925d 100644
--- a/blender/source/blenkernal.md
+++ b/cg/blender/source/blenkernal.md
@@ -1,7 +1,7 @@
-# blenkernal
-
-blender kernel，核心代码逻辑
-
-## BKE_context.h 
-
-
+# blenkernal
+
+blender kernel，核心代码逻辑
+
+## BKE_context.h 
+
+
diff --git a/blender/source/camera.md b/cg/blender/source/camera.md
similarity index 100%
rename from blender/source/camera.md
rename to cg/blender/source/camera.md
diff --git a/blender/source/gizmo.md b/cg/blender/source/gizmo.md
similarity index 100%
rename from blender/source/gizmo.md
rename to cg/blender/source/gizmo.md
diff --git a/blender/source/makesrna.md b/cg/blender/source/makesrna.md
similarity index 100%
rename from blender/source/makesrna.md
rename to cg/blender/source/makesrna.md
diff --git a/blender/source/module-editors/interface.md b/cg/blender/source/module-editors/interface.md
similarity index 100%
rename from blender/source/module-editors/interface.md
rename to cg/blender/source/module-editors/interface.md
diff --git a/blender/source/module-kernel/context.md b/cg/blender/source/module-kernel/context.md
similarity index 100%
rename from blender/source/module-kernel/context.md
rename to cg/blender/source/module-kernel/context.md
diff --git a/blender/source/module-lib/ghash.md b/cg/blender/source/module-lib/ghash.md
similarity index 100%
rename from blender/source/module-lib/ghash.md
rename to cg/blender/source/module-lib/ghash.md
diff --git a/blender/source/module-lib/index.md b/cg/blender/source/module-lib/index.md
similarity index 100%
rename from blender/source/module-lib/index.md
rename to cg/blender/source/module-lib/index.md
diff --git a/blender/source/module-lib/linklist.md b/cg/blender/source/module-lib/linklist.md
similarity index 100%
rename from blender/source/module-lib/linklist.md
rename to cg/blender/source/module-lib/linklist.md
diff --git a/blender/source/module-lib/memarena.md b/cg/blender/source/module-lib/memarena.md
similarity index 100%
rename from blender/source/module-lib/memarena.md
rename to cg/blender/source/module-lib/memarena.md
diff --git a/blender/source/module-python/index.md b/cg/blender/source/module-python/index.md
similarity index 100%
rename from blender/source/module-python/index.md
rename to cg/blender/source/module-python/index.md
diff --git a/blender/source/module-wm/draw.md b/cg/blender/source/module-wm/draw.md
similarity index 100%
rename from blender/source/module-wm/draw.md
rename to cg/blender/source/module-wm/draw.md
diff --git a/blender/source/module.md b/cg/blender/source/module.md
similarity index 100%
rename from blender/source/module.md
rename to cg/blender/source/module.md
diff --git a/blender/source/thinked.md b/cg/blender/source/thinked.md
similarity index 99%
rename from blender/source/thinked.md
rename to cg/blender/source/thinked.md
index 28495db..3e031ba 100644
--- a/blender/source/thinked.md
+++ b/cg/blender/source/thinked.md
@@ -1,27 +1,27 @@
-
-# source/blender/makesrna
-
-> RNA definitions and functions. Sits on top of DNA to provide a low level data access and definitin API.
-
-***
-
-## 作用
-在[2.50](https://archive.blender.org/wiki/index.php/Dev:2.5/Source/Architecture/RNA/)版本的特性，将DNA包装成一个非常nice的API的一套系统，这套API用来读取Blender的数据和属性。
-
-Blender的RNA可以自动生成Python数据访问API，使得一切特性都可以像动画那样。
-
-这样DNA系统放弃文件的可读性，但提高了灵活性和速度。曽传闻XML会替换掉DNA系统，但有趣的是Google内部使用了类似的DNA系统来取代XML。Blender是第一个使用这种DNA系统的应用程序。
-可参考[Data API](<https://archive.blender.org/wiki/index.php/BlenderDev/Blender2.5/DataAPI/>)
-
-## 源文件
-
-## 2020-2-11
-**关于语言层面的思考**
-最近在看UTiCS系列书籍中的关于编程语言模型的那一章，让我明白了很多问题，之前关于DNA的理解还是肤浅的，那就是没法理解到那个时候的那些人对于计算机科学的认识与现在仅对编程这个工作的认识是存在差异的。
-
-既然选择了C作为底层的数据接口，每个数据都是struct结构化的，而其中的ID又是每个关键数据的第一个位置，这就不得不让人思考语言模型的特色了，这样的处理就像面向对象编程的继承方法了，虽然面向对象编程抽象程度高于指令式编程，但底层的实现肯定离不开较低层的语言，就像函数语言还是没法做到immutable对象的，比较在IO层是一个无法回避的问题，即是现在的Rust语言号称内存安全模型的编程语言，也留有unsafe模型来对接其他的编程语言，这就令人需要辩证思维的方式来看待问题了。
-
-常规的流程化的编程，就是写软件的过程，却因为入门是编程语言让人钻入编程语言的逻辑中了，而没有站在软件层面来看问题，语言只是工具，对于软件的成型与最终结果是不关软件用户的事情。反过来，慢慢地发现抽象思维才是区分人物的特定条件，也许之前的文化遗留导致了大家在认知上的一致性，可是真的分类人的天才属性，除掉抽象能力以为真的没有共性了，虽然我没有就这个问题作出科学的那样证明，事实就是如此吧，我把抽象能力是区分天才的公理来使用了。
-
-C语言的模型可以处理很多高级语言的那种固定模式的抽象，C语言的强大是因为它完全可以做到其他语言的能力，只是它需要付出的代价而已，站在工程化上来说它不适合给大众表达抽象能力，但是特定人群使用它还是可以表达出非常高级的抽象能力，这就是我之前的见识短浅的原因吧，C这种编程语言也不是简简单单就可以通过一两本教程能融会贯通的，那肯定是实践出真知。
-
+
+# source/blender/makesrna
+
+> RNA definitions and functions. Sits on top of DNA to provide a low level data access and definitin API.
+
+***
+
+## 作用
+在[2.50](https://archive.blender.org/wiki/index.php/Dev:2.5/Source/Architecture/RNA/)版本的特性，将DNA包装成一个非常nice的API的一套系统，这套API用来读取Blender的数据和属性。
+
+Blender的RNA可以自动生成Python数据访问API，使得一切特性都可以像动画那样。
+
+这样DNA系统放弃文件的可读性，但提高了灵活性和速度。曽传闻XML会替换掉DNA系统，但有趣的是Google内部使用了类似的DNA系统来取代XML。Blender是第一个使用这种DNA系统的应用程序。
+可参考[Data API](<https://archive.blender.org/wiki/index.php/BlenderDev/Blender2.5/DataAPI/>)
+
+## 源文件
+
+## 2020-2-11
+**关于语言层面的思考**
+最近在看UTiCS系列书籍中的关于编程语言模型的那一章，让我明白了很多问题，之前关于DNA的理解还是肤浅的，那就是没法理解到那个时候的那些人对于计算机科学的认识与现在仅对编程这个工作的认识是存在差异的。
+
+既然选择了C作为底层的数据接口，每个数据都是struct结构化的，而其中的ID又是每个关键数据的第一个位置，这就不得不让人思考语言模型的特色了，这样的处理就像面向对象编程的继承方法了，虽然面向对象编程抽象程度高于指令式编程，但底层的实现肯定离不开较低层的语言，就像函数语言还是没法做到immutable对象的，比较在IO层是一个无法回避的问题，即是现在的Rust语言号称内存安全模型的编程语言，也留有unsafe模型来对接其他的编程语言，这就令人需要辩证思维的方式来看待问题了。
+
+常规的流程化的编程，就是写软件的过程，却因为入门是编程语言让人钻入编程语言的逻辑中了，而没有站在软件层面来看问题，语言只是工具，对于软件的成型与最终结果是不关软件用户的事情。反过来，慢慢地发现抽象思维才是区分人物的特定条件，也许之前的文化遗留导致了大家在认知上的一致性，可是真的分类人的天才属性，除掉抽象能力以为真的没有共性了，虽然我没有就这个问题作出科学的那样证明，事实就是如此吧，我把抽象能力是区分天才的公理来使用了。
+
+C语言的模型可以处理很多高级语言的那种固定模式的抽象，C语言的强大是因为它完全可以做到其他语言的能力，只是它需要付出的代价而已，站在工程化上来说它不适合给大众表达抽象能力，但是特定人群使用它还是可以表达出非常高级的抽象能力，这就是我之前的见识短浅的原因吧，C这种编程语言也不是简简单单就可以通过一两本教程能融会贯通的，那肯定是实践出真知。
+
diff --git a/blender/source/tmp.md b/cg/blender/source/tmp.md
similarity index 88%
rename from blender/source/tmp.md
rename to cg/blender/source/tmp.md
index a5d7947..462d8c5 100644
--- a/blender/source/tmp.md
+++ b/cg/blender/source/tmp.md
@@ -1,2 +1,2 @@
-# 操作类型
-
+# 操作类型
+
diff --git a/cpl/lua.md b/cpl/lua.md
index 35fb12e..28bc2f5 100644
--- a/cpl/lua.md
+++ b/cpl/lua.md
@@ -1,8 +1,158 @@
 # [lua](http://www.lua.org/)
 
+注释 
+
+```lua
+-- xxx to c // xxx
+--[[ xxx ]] to c /* xxx */
+```
+
+## 模块与包
+
+lua的模块是由变量，函数等组成的table，其是加载机制通过require来导入
+
+require的路径是全局变量package.path中的，lua启动后，有三个大致范围
+
+```lua
+print(package.path) -- 编译后执行的路径，并未安装
+-- /usr/local/share/lua/x.y/?.lua;/usr/local/share/lua/x.y/?/init.lua;/usr/local/lib/lua/x.y/?.lua;/usr/local/lib/lua/x.y/?/init.lua;./?.lua;./?/init.lua
+-- 添加环境变量 export LUA_PATH="~/lua/?.lua;;" 最后的;;表示加上原来默认的路径
+```
+
+C包，使用C为lua写包，是动态库的调用方式
+
+# lua-src
+
+lua把虚拟机执行代码的效率作为一个设计目标。lua的vm是Register based VM。
+
+```c
+// register based vm
+add a b c;
+// stack based vm
+push b;
+push c;
+add
+mov a
+```
+
+## lopcodes
+
+> 理解lua，直接从这里开始，是最好的，特别是有汇编，C语言的功底后，就相当于先理解lua的汇编指令，再去理解lua的逻辑。
+>
+> > 汇编的本质是CPU二进制指令的文本形式
+
+lua virtual machine op-codes， 指令是一个32bit的unsigned int
+
+|       | 31-24    | 23-16    | 15-8    | 0-7      |
+| ----- | -------- | -------- | ------- | -------- |
+| iABC  | B:9      | C:9      | A:8     | Opcode:6 |
+| iABx  | Bx:18-1  | Bx:18-2  | A:8     | Opcode:6 |
+| iAsBx | sBx:18-1 | sBx:18-2 | A:8     | Opcode:6 |
+| iAx   | Ax:26-1  | Ax:26-2  | Ax:26-3 | Opcode:6 |
+
+基本的四个指令形式，iABC，iABx，iAsBx，iAx。sBx表示signed int，
+
+```c
+pow(2,18)=262144 => [0, 262143] 
+0 use 131071, -1=-1+0=131070, +1 = +1+131071=131072. // 进行了一个变换，类似二进制取补
+```
+
+生成代码对应的指令
+
+```shell
+luac -l -l src.lua
+```
+
+
+
+## 编译系统
+
+编译系统就是将符合语法规则的chunk转成可运行的closure， 即chunk作为输入，closure作为输出。
+
+### 主要概念
+
+#### closure
+
+closure对象是lua运行期一个函数的实例对象，
+
+#### proto
+
+proto对象是lua内部代表一个closure原型的对象，有关函数的大部分信息都保存在它里面
+
+- instructions指令列表，函数编译后生成的虚拟机指令
+- constant table常量表，运行期的所有常量，在指令中，常量通过id在常量表中索引
+- child proto table子proto表，所有内嵌于函数的proto列表，指令OP_CLOSURE的proto就是在这个表中通过id索引
+- local var desc局部变量描述，函数使用的所有局部变量名称，以及生命周期
+- upvalue desc，函数使用到的Upvalue的描述
+
+#### chunk
+
+代表一段符合lua语法的代码，lua_load会对chunk编译生成一个mainfunc proto，内部的所有函数都对应一个proto。整个过程就是生成以mainfunc为根节点的proto树结构
+
+注意，lua编译过程中是一次遍历就生成指令，并没有对源码和语法结构多次遍历，是通过指令回填技术来实现支持的。
+
+### 实现逻辑
+
+lua没有使用llex和yacc生成，而是完全手写的词法和语法分析器，按功能划分，主要有三个模块
+
+#### 词法分析模块
+
+llex.h/c
+
+#### 语法分析模块
+
+lparser.h/c
+
+
+![](./images/lua-opcode.png)
+
+
+```c
+// in lopcodes.c
+#define opmode(t,a,b,c,m) (((t)<<7)|((a)<<6)|((b)<<4)|((c)<<2)|(m))
+```
+
+- t，表示为test，其后的一定是OP_JMP，共五个指令OP_EQ,OP_LT,OP_LE,OP_TEST,OP_TESTSET
+- a，是否为寄存器操作，1表示寄存器
+- b，B参数，OpArgMask类型
+- c，C参数，OpArgMask类型
+- m，op model，就是iABC,iABx,iAsBx,iAx
+
+这里存在些疑惑，Opcode只占6bit，而opmode中的值占8bit，令人不解，多出来的一个bit是什么地方来的？
+
+#### 指令生成模块
+
+lcode.h/c
+
+#### 其他
+
+lprefix.h
+
+luaconf.h
+
+lua.h/c
+
+主要接口
+
+lctype.h/c
+
+针对非ASCII进行定义一些基础字符
+
+lmem.h/c
+
+lzio.h/c
+
+buffered streams，内存是stream形式，与C的File有点类似，核心就是两个函数luaZ_read,luaZ_fill
+
+lobject.h/c
+
+lua的类型定义
+
+
 ## 参考
 - [Lua Awesome-lua官方链接上的记录](https://github.com/LewisJEllis/awesome-lua)
 - [Quickly view and test GLSL fragment shaders while allowing lua scripting to modify uniforms ](https://github.com/nevilc/ShaderPreview)
 - [luafxbuilder is a proof of concept test to use lua as effect file format primarily for shaders](https://github.com/pixeljetstream/luafxbuilder)
 - [lua-cpp一个用C++11封装lua的库](https://gitee.com/linuxtongyong/lua-cpp-wrapper)
-- [LuaChat is an example of how to combine modern C++ and Lua 5.3/5.4. In particular, LuaChat implements a library of C++ primitives called actions.](https://github.com/bluwireless/LuaChat)
\ No newline at end of file
+- [LuaChat is an example of how to combine modern C++ and Lua 5.3/5.4. In particular, LuaChat implements a library of C++ primitives called actions.](https://github.com/bluwireless/LuaChat)
+- [探索Lua5.2内部实现](https://blog.csdn.net/yuanlin2008/article/category/1307277)
diff --git a/lua/tests-lua/all.lua b/cpl/tests-lua/all.lua
similarity index 100%
rename from lua/tests-lua/all.lua
rename to cpl/tests-lua/all.lua
diff --git a/lua/tests-lua/api.lua b/cpl/tests-lua/api.lua
similarity index 100%
rename from lua/tests-lua/api.lua
rename to cpl/tests-lua/api.lua
diff --git a/lua/tests-lua/attrib.lua b/cpl/tests-lua/attrib.lua
similarity index 100%
rename from lua/tests-lua/attrib.lua
rename to cpl/tests-lua/attrib.lua
diff --git a/lua/tests-lua/big.lua b/cpl/tests-lua/big.lua
similarity index 100%
rename from lua/tests-lua/big.lua
rename to cpl/tests-lua/big.lua
diff --git a/lua/tests-lua/bitwise.lua b/cpl/tests-lua/bitwise.lua
similarity index 100%
rename from lua/tests-lua/bitwise.lua
rename to cpl/tests-lua/bitwise.lua
diff --git a/lua/tests-lua/calls.lua b/cpl/tests-lua/calls.lua
similarity index 100%
rename from lua/tests-lua/calls.lua
rename to cpl/tests-lua/calls.lua
diff --git a/lua/tests-lua/checktable.lua b/cpl/tests-lua/checktable.lua
similarity index 100%
rename from lua/tests-lua/checktable.lua
rename to cpl/tests-lua/checktable.lua
diff --git a/lua/tests-lua/closure.lua b/cpl/tests-lua/closure.lua
similarity index 100%
rename from lua/tests-lua/closure.lua
rename to cpl/tests-lua/closure.lua
diff --git a/lua/tests-lua/code.lua b/cpl/tests-lua/code.lua
similarity index 100%
rename from lua/tests-lua/code.lua
rename to cpl/tests-lua/code.lua
diff --git a/lua/tests-lua/constructs.lua b/cpl/tests-lua/constructs.lua
similarity index 100%
rename from lua/tests-lua/constructs.lua
rename to cpl/tests-lua/constructs.lua
diff --git a/lua/tests-lua/coroutine.lua b/cpl/tests-lua/coroutine.lua
similarity index 100%
rename from lua/tests-lua/coroutine.lua
rename to cpl/tests-lua/coroutine.lua
diff --git a/lua/tests-lua/db.lua b/cpl/tests-lua/db.lua
similarity index 100%
rename from lua/tests-lua/db.lua
rename to cpl/tests-lua/db.lua
diff --git a/lua/tests-lua/errors.lua b/cpl/tests-lua/errors.lua
similarity index 100%
rename from lua/tests-lua/errors.lua
rename to cpl/tests-lua/errors.lua
diff --git a/lua/tests-lua/events.lua b/cpl/tests-lua/events.lua
similarity index 100%
rename from lua/tests-lua/events.lua
rename to cpl/tests-lua/events.lua
diff --git a/lua/tests-lua/files.lua b/cpl/tests-lua/files.lua
similarity index 100%
rename from lua/tests-lua/files.lua
rename to cpl/tests-lua/files.lua
diff --git a/lua/tests-lua/gc.lua b/cpl/tests-lua/gc.lua
similarity index 100%
rename from lua/tests-lua/gc.lua
rename to cpl/tests-lua/gc.lua
diff --git a/lua/tests-lua/goto.lua b/cpl/tests-lua/goto.lua
similarity index 100%
rename from lua/tests-lua/goto.lua
rename to cpl/tests-lua/goto.lua
diff --git a/lua/tests-lua/heavy.lua b/cpl/tests-lua/heavy.lua
similarity index 100%
rename from lua/tests-lua/heavy.lua
rename to cpl/tests-lua/heavy.lua
diff --git a/lua/tests-lua/literals.lua b/cpl/tests-lua/literals.lua
similarity index 100%
rename from lua/tests-lua/literals.lua
rename to cpl/tests-lua/literals.lua
diff --git a/lua/tests-lua/locals.lua b/cpl/tests-lua/locals.lua
similarity index 100%
rename from lua/tests-lua/locals.lua
rename to cpl/tests-lua/locals.lua
diff --git a/lua/tests-lua/main.lua b/cpl/tests-lua/main.lua
similarity index 100%
rename from lua/tests-lua/main.lua
rename to cpl/tests-lua/main.lua
diff --git a/lua/tests-lua/math.lua b/cpl/tests-lua/math.lua
similarity index 100%
rename from lua/tests-lua/math.lua
rename to cpl/tests-lua/math.lua
diff --git a/lua/tests-lua/nextvar.lua b/cpl/tests-lua/nextvar.lua
similarity index 100%
rename from lua/tests-lua/nextvar.lua
rename to cpl/tests-lua/nextvar.lua
diff --git a/lua/tests-lua/pm.lua b/cpl/tests-lua/pm.lua
similarity index 100%
rename from lua/tests-lua/pm.lua
rename to cpl/tests-lua/pm.lua
diff --git a/lua/skynet.md b/cpl/tests-lua/skynet.md
similarity index 98%
rename from lua/skynet.md
rename to cpl/tests-lua/skynet.md
index ead9383..fb57037 100644
--- a/lua/skynet.md
+++ b/cpl/tests-lua/skynet.md
@@ -1,68 +1,68 @@
-# skynet
-
-一个轻量级的服务器框架，C语言写的框架，配合胶水语言lua
-[Skynet 设计综述](https://blog.codingnow.com/2012/09/the_design_of_skynet.html)中云风以能够充分利用多核优势，将不同的业务放在独立的执行环境中处理，协同工作，实现了类似Erlang的Actor模型，本质是一个高并发的消息处理框架，消息从底层发给上层的服务去处理。这里的服务，可用C写，可用lua写，大部分都是lua写的，每个lua服务是一个独立的lua虚拟机，这样就隔离了服务之间的环境。lua服务使用协程处理消息，当需要向其他服务通信时，协程可以挂起等待其他服务返回再继续；当协程挂起时，该服务可以处理其他消息，这就保证了消息的高并发。
-
-skynet是一个基于事件的高并发消息处理框架，事件来源于网络、定时器和信号通知等，当事件触发时，skynet将这些事件统一编码成消息结构，派发给感兴趣的服务进行处理，服务在处理消息时，也可以向其他服务发送消息，
-
-## 概念
-
-**服务句柄**
-用于唯一标识服务的，是一个32位的无符号整型，最高8位表示集群ID【已不推荐使用】，剩下24位为服务ID
-
-**服务模块**
-模块以动态库的形式提供，在创建skynet_context时，必须指定模块名字，skynet把模块加载进来，创建模块实例，实例向服务注册一个回调函数，用于处理服务的消息
-
-**消息队列**
-每个服务都有一个消息队列，当队列中有消息时，会主动挂到全局链表，skynet启动了一定数量的工作线程，不断从全局链表取出消息队列，派发消息给服务的回调函数去处理。
-
-## 启动服务
-通过skynet_start函数启动
-1. 初始化各个模块功能，比如句柄、消息队列、模块、定时、socket等
-2. 创建一个logger服务，创建一个bootstrap服务
-3. 创建一定数量的工作线程，这个数量可配置，工作线程的责任就是派发消息
-4. 创建定时器，用于记录时间以及实现timeout事件
-5. 创建socket线程，用于处理socket消息
-6. 创建monitor线程，监控服务状态
-
-绝大多数的服务程序的核心功能就是生产消费者模型，产生消息，消费消息，skynet也是如此的。
-
-## 源码分析
-
-**skynet_main.c**
-启动的地方，是skynet程序的入口，通过读取配置文件来进行相应的设置
-
-先调用skynet_globalinit函数，是在skynet_server中创建主线程的，其对应的函数是skynet_globalexit
-接着设置一个全局的env变量
-接着读取配置config，传入给skynet_start进行启动skynet程序
-
-**skynet_start.c**
-进入正式启动中，看配置文件中是否有守护进程daemon，这个是用来判断当前服务器是否有相同的服务进程运行
-
-skynet_harbor.h/c中是用于cluster集群的，对harbor的高8位编码
-
-skynet_handle.h/c文件
-是用来存储skynet_context对象的，函数skynet_handle_register函数通过一个加锁的结构来生成一个顺序的索引，
-以索引位位置存储在固定的长度中，如果超过一半，继续扩容到两倍大小，算是避免hash的冲突吧
-
-skynet_mq.h/c文件
-消息队列，维护一个全局的消息Q，一个message_queue的单向链表，所有的消息都要存在这个上面。
-
-### 模式
-每个h/c文件对应的是一个模块或功能
-
-
-使用C开发的，每个服务都独立属于一个文件，有一个static的全局对象，每次操作时都需要通过另外一个alias指针来
-操作，如
-```c
-static struct global_queue *Q = NULL;
-void init() {
-    struct global_queue *q = skynet_malloc(sizeof(*q));
-    Q=q;
-}
-void operator1() {
-    struct global_queue *q = Q;
-    // do something with q  
-}
-```
-
+# skynet
+
+一个轻量级的服务器框架，C语言写的框架，配合胶水语言lua
+[Skynet 设计综述](https://blog.codingnow.com/2012/09/the_design_of_skynet.html)中云风以能够充分利用多核优势，将不同的业务放在独立的执行环境中处理，协同工作，实现了类似Erlang的Actor模型，本质是一个高并发的消息处理框架，消息从底层发给上层的服务去处理。这里的服务，可用C写，可用lua写，大部分都是lua写的，每个lua服务是一个独立的lua虚拟机，这样就隔离了服务之间的环境。lua服务使用协程处理消息，当需要向其他服务通信时，协程可以挂起等待其他服务返回再继续；当协程挂起时，该服务可以处理其他消息，这就保证了消息的高并发。
+
+skynet是一个基于事件的高并发消息处理框架，事件来源于网络、定时器和信号通知等，当事件触发时，skynet将这些事件统一编码成消息结构，派发给感兴趣的服务进行处理，服务在处理消息时，也可以向其他服务发送消息，
+
+## 概念
+
+**服务句柄**
+用于唯一标识服务的，是一个32位的无符号整型，最高8位表示集群ID【已不推荐使用】，剩下24位为服务ID
+
+**服务模块**
+模块以动态库的形式提供，在创建skynet_context时，必须指定模块名字，skynet把模块加载进来，创建模块实例，实例向服务注册一个回调函数，用于处理服务的消息
+
+**消息队列**
+每个服务都有一个消息队列，当队列中有消息时，会主动挂到全局链表，skynet启动了一定数量的工作线程，不断从全局链表取出消息队列，派发消息给服务的回调函数去处理。
+
+## 启动服务
+通过skynet_start函数启动
+1. 初始化各个模块功能，比如句柄、消息队列、模块、定时、socket等
+2. 创建一个logger服务，创建一个bootstrap服务
+3. 创建一定数量的工作线程，这个数量可配置，工作线程的责任就是派发消息
+4. 创建定时器，用于记录时间以及实现timeout事件
+5. 创建socket线程，用于处理socket消息
+6. 创建monitor线程，监控服务状态
+
+绝大多数的服务程序的核心功能就是生产消费者模型，产生消息，消费消息，skynet也是如此的。
+
+## 源码分析
+
+**skynet_main.c**
+启动的地方，是skynet程序的入口，通过读取配置文件来进行相应的设置
+
+先调用skynet_globalinit函数，是在skynet_server中创建主线程的，其对应的函数是skynet_globalexit
+接着设置一个全局的env变量
+接着读取配置config，传入给skynet_start进行启动skynet程序
+
+**skynet_start.c**
+进入正式启动中，看配置文件中是否有守护进程daemon，这个是用来判断当前服务器是否有相同的服务进程运行
+
+skynet_harbor.h/c中是用于cluster集群的，对harbor的高8位编码
+
+skynet_handle.h/c文件
+是用来存储skynet_context对象的，函数skynet_handle_register函数通过一个加锁的结构来生成一个顺序的索引，
+以索引位位置存储在固定的长度中，如果超过一半，继续扩容到两倍大小，算是避免hash的冲突吧
+
+skynet_mq.h/c文件
+消息队列，维护一个全局的消息Q，一个message_queue的单向链表，所有的消息都要存在这个上面。
+
+### 模式
+每个h/c文件对应的是一个模块或功能
+
+
+使用C开发的，每个服务都独立属于一个文件，有一个static的全局对象，每次操作时都需要通过另外一个alias指针来
+操作，如
+```c
+static struct global_queue *Q = NULL;
+void init() {
+    struct global_queue *q = skynet_malloc(sizeof(*q));
+    Q=q;
+}
+void operator1() {
+    struct global_queue *q = Q;
+    // do something with q  
+}
+```
+
diff --git a/lua/tests-lua/sort.lua b/cpl/tests-lua/sort.lua
similarity index 100%
rename from lua/tests-lua/sort.lua
rename to cpl/tests-lua/sort.lua
diff --git a/lua/tests-lua/strings.lua b/cpl/tests-lua/strings.lua
similarity index 100%
rename from lua/tests-lua/strings.lua
rename to cpl/tests-lua/strings.lua
diff --git a/lua/tests-lua/tpack.lua b/cpl/tests-lua/tpack.lua
similarity index 100%
rename from lua/tests-lua/tpack.lua
rename to cpl/tests-lua/tpack.lua
diff --git a/lua/tests-lua/utf8.lua b/cpl/tests-lua/utf8.lua
similarity index 100%
rename from lua/tests-lua/utf8.lua
rename to cpl/tests-lua/utf8.lua
diff --git a/lua/tests-lua/vararg.lua b/cpl/tests-lua/vararg.lua
similarity index 100%
rename from lua/tests-lua/vararg.lua
rename to cpl/tests-lua/vararg.lua
diff --git a/lua/tests-lua/verybig.lua b/cpl/tests-lua/verybig.lua
similarity index 100%
rename from lua/tests-lua/verybig.lua
rename to cpl/tests-lua/verybig.lua
diff --git a/dev-note/debug.md b/dev-note/debug.md
deleted file mode 100644
index 4addbe3..0000000
--- a/dev-note/debug.md
+++ /dev/null
@@ -1,8 +0,0 @@
-# Debug
-> 有关调试的
-
-## 参考
-
-**CrackingOysters：Effective Debugging**作者写的
-- [core analyzer -- A power tool to understand memory layout](https://core-analyzer.sourceforge.net/index_files/Page525.html)
-- [Effective Debugging中文翻译开源版](https://celthi.github.io/effective-debugging-zh/)
\ No newline at end of file
diff --git a/dev-note/index.md b/dev-note/index.md
new file mode 100644
index 0000000..3281039
--- /dev/null
+++ b/dev-note/index.md
@@ -0,0 +1,18 @@
+# dev-note 
+
+- [git](/dev-note/git.md)
+- [svn](/dev-note/svn.md)
+- [cmake](/dev-note/cmake.md)
+- [linux](/dev-note/linux.md)
+- [ssh](/dev-note/ssh.md)
+- [powershell](/dev-note/powershell.md)
+- [wsl](/dev-note/wsl.md)
+- [vscode](/dev-note/vscode.md)
+- [cmd](/dev-note/cmd.md)
+- [bazel](/dev-note/bazel.md)
+- [build System](/dev-note/buildSystem.md)
+- [debug](/dev-note/debug.md)
+- [powershell](/dev-note/powershell.md)
+- [nodejs包管理](/web/pkg.md)
+- [包管理C++](/dev-note/pkg.md)
+- [maven](/dev-note/maven.md)
diff --git a/dev-note/license.md b/dev-note/license.md
deleted file mode 100644
index e3c9c5a..0000000
--- a/dev-note/license.md
+++ /dev/null
@@ -1,4 +0,0 @@
-# License
-
-[Licensecc -- a C++ software license manager](https://github.com/open-license-manager/licensecc)
-
diff --git a/index.html b/index.html
index a9b3305..0d97404 100644
--- a/index.html
+++ b/index.html
@@ -12,15 +12,17 @@
   </head>
   <body class="mj-body">
     <section class="side-menu d-flex flex-column">
-      <a href="./books/index.md">book</a>
+      <a href="./index/book-info.md">book</a>
+      <a href="./dev-note/index.md">dev-note</a>
       <a href="./index/article.md">个人笔记</a>
-      <a href="./index/online.md">线上文章</a>
+      <a href="./index/online.md">线上资源</a>
+      <a href="./index/article-info.md">优秀文章</a>
       <a href="./index/standard.md">标准</a>
       <a href="./index/community.md">Community</a>      
       <a href="./index/computerScience.md">CS</a>      
       <a href="./index/medicalScience.md">医学技术</a>
-      <a href="./blender/index.md">Blender</a>
-      <a href="./html/index.html">HTML 入口</a>
+      <a href="./cg/blender/index.md">Blender</a>
+      <a href="./html/index.html">网页</a>
     </section>
     <main class="main-content">
       <div id="content"></div>
diff --git a/index/article-info.md b/index/article-info.md
new file mode 100644
index 0000000..8629dcb
--- /dev/null
+++ b/index/article-info.md
@@ -0,0 +1,3 @@
+# 文章
+
+- [core analyzer -- A power tool to understand memory layout](https://core-analyzer.sourceforge.net/index_files/Page525.html)
\ No newline at end of file
diff --git a/index/article.md b/index/article.md
index f081d8d..877f4cc 100644
--- a/index/article.md
+++ b/index/article.md
@@ -7,24 +7,6 @@
 - [数学概念笔记](../articles/notes/math.md)
 - [软硬件一体的项目](../articles/others/robot.md)
 
-## dev-note 
-- [git](../dev-note/git.md)
-- [svn](../dev-note/svn.md)
-- [cmake](../dev-note/cmake.md)
-- [linux](../dev-note/linux.md)
-- [ssh](../dev-note/ssh.md)
-- [wsl](../dev-note/wsl.md)
-- [vscode](../dev-note/vscode.md)
-- [cmd](../dev-note/cmd.md)
-- [bazel](../dev-note/bazel.md)
-- [Mathjax](../articles/mathjax.md)
-- [build System](../dev-note/buildSystem.md)
-- [debug](../dev-note/debug.md)
-- [powershell](../dev-note/powershell.md)
-- [nodejs包管理](../web/pkg.md)
-- [包管理C++](../dev-note/pkg.md)
-- [maven](../dev-note/maven.md)
-
 ### web
 - [网页开发内容](../web/index.md)
 - [webassembly](../web/webAssembly.md)
diff --git a/books/index.md b/index/book-info.md
similarity index 66%
rename from books/index.md
rename to index/book-info.md
index 5d160a3..e5c23b7 100644
--- a/books/index.md
+++ b/index/book-info.md
@@ -1,7 +1,7 @@
 # Books
 
 ## reading
-- [Learn OpenGL](../books/Learn%20OpenGL.md)
+
 - [vulkan tutorial](https://vulkan-tutorial.com/)
 - [Performance Analysis and Tuning on Modern CPUs 2023]()
     - 3
@@ -10,12 +10,30 @@
 - 毛选，在读
 - 符号学：原理与推演，南京大学出版社，ISBN:9787305160516, 在读
 
+### [Learn OpenGL](../books/Learn%20OpenGL.md)
+
+模板测试，Object outlining的流程处理给出了一个方案
+
+### [Software Engineering at Google]()
+编程与软件工程的重要因素
+- 时间
+- 规模
+- 权衡取舍
+
+### [数学与泛型编程](https://book.douban.com/subject/27116151/)
+
+### [Effective Debugging中文翻译开源版](https://celthi.github.io/effective-debugging-zh/)
+
 ## readed
-- [软件设计-从专业到卓越](../books/%E8%BD%AF%E4%BB%B6%E8%AE%BE%E8%AE%A1-%E4%BB%8E%E4%B8%93%E4%B8%9A%E5%88%B0%E5%8D%93%E8%B6%8A.md)
 - 计算机图形图像设计，2016，中国传媒大学出版社，已读
 - 囚徒的困境-冯·诺依曼、博弈论和原子弹之谜，已读
 - 深度探索 C++对象模型，2001, 侯捷，已读
-- 数学与泛型编程，2017，华章科技·名家金典系列，在读
+### [软件设计-从专业到卓越](https://book.douban.com/subject/35966115/)
+> 豆瓣某编辑送阅的
+
+- 优质代码的外部特征
+    - 1.3.1 为什么代码难以理解，业务概念共识是一个很重要的因素，很多问题可能都是因为没有共识，产生了认识与理解上的差异。以一种范式理解另一种范式是很容易产生的，这样的问题也会非常多。
+    - 1.5.2 提升复用能力的手段， ==选择合适的复用粒度==， 业务模块的复用，也有比较成熟的经验了，就是以领域为中心的设计。通过恰当的确定问题的领域边界，保持各个子域边界之间的抽象和隔离，就是典型的例子。如短信发送、地图服务、聊天消息等模块。
 
 ## online
 
@@ -36,6 +54,7 @@
 - [Modern Robotics: Mechanics, Planning, and Control现代机器人学：机构、规划与控制](http://hades.mech.northwestern.edu/index.php/Modern_Robotics)
 
 
+
 ## 网上资源
 - [世界数字图书馆](https://www.wdl.org/zh/)
 - [英文文学在线书库](http://www.online-literature.com/)
diff --git a/index/community.md b/index/community.md
index 24e8345..603bf4b 100644
--- a/index/community.md
+++ b/index/community.md
@@ -38,6 +38,11 @@
 
 ## 协议
 
+### License
+
+[Licensecc -- a C++ software license manager](https://github.com/open-license-manager/licensecc)
+
+
 ### [IDL(Interface Definition Language)](https://www.omg.org/spec/IDL/)
 
 - [An OMG® Interface Definition Language™ Publication Interface Definition Language™](https://www.omg.org/spec/IDL/4.2/PDF)
diff --git a/lua/lua-5.3.5/Makefile b/lua/lua-5.3.5/Makefile
deleted file mode 100644
index 119110d..0000000
--- a/lua/lua-5.3.5/Makefile
+++ /dev/null
@@ -1,114 +0,0 @@
-# Makefile for installing Lua
-# See doc/readme.html for installation and customization instructions.
-
-# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
-
-# Your platform. See PLATS for possible values.
-PLAT= none
-
-# Where to install. The installation starts in the src and doc directories,
-# so take care if INSTALL_TOP is not an absolute path. See the local target.
-# You may want to make INSTALL_LMOD and INSTALL_CMOD consistent with
-# LUA_ROOT, LUA_LDIR, and LUA_CDIR in luaconf.h.
-INSTALL_TOP= /usr/local
-INSTALL_BIN= $(INSTALL_TOP)/bin
-INSTALL_INC= $(INSTALL_TOP)/include
-INSTALL_LIB= $(INSTALL_TOP)/lib
-INSTALL_MAN= $(INSTALL_TOP)/man/man1
-INSTALL_LMOD= $(INSTALL_TOP)/share/lua/$V
-INSTALL_CMOD= $(INSTALL_TOP)/lib/lua/$V
-
-# How to install. If your install program does not support "-p", then
-# you may have to run ranlib on the installed liblua.a.
-INSTALL= install -p
-INSTALL_EXEC= $(INSTALL) -m 0755
-INSTALL_DATA= $(INSTALL) -m 0644
-#
-# If you don't have "install" you can use "cp" instead.
-# INSTALL= cp -p
-# INSTALL_EXEC= $(INSTALL)
-# INSTALL_DATA= $(INSTALL)
-
-# Other utilities.
-MKDIR= mkdir -p
-RM= rm -f
-
-# == END OF USER SETTINGS -- NO NEED TO CHANGE ANYTHING BELOW THIS LINE =======
-
-# Convenience platforms targets.
-PLATS= aix bsd c89 freebsd generic linux macosx mingw posix solaris
-
-# What to install.
-TO_BIN= lua luac
-TO_INC= lua.h luaconf.h lualib.h lauxlib.h lua.hpp
-TO_LIB= liblua.a
-TO_MAN= lua.1 luac.1
-
-# Lua version and release.
-V= 5.3
-R= $V.4
-
-# Targets start here.
-all:	$(PLAT)
-
-$(PLATS) clean:
-	cd src && $(MAKE) $@
-
-test:	dummy
-	src/lua -v
-
-install: dummy
-	cd src && $(MKDIR) $(INSTALL_BIN) $(INSTALL_INC) $(INSTALL_LIB) $(INSTALL_MAN) $(INSTALL_LMOD) $(INSTALL_CMOD)
-	cd src && $(INSTALL_EXEC) $(TO_BIN) $(INSTALL_BIN)
-	cd src && $(INSTALL_DATA) $(TO_INC) $(INSTALL_INC)
-	cd src && $(INSTALL_DATA) $(TO_LIB) $(INSTALL_LIB)
-	cd doc && $(INSTALL_DATA) $(TO_MAN) $(INSTALL_MAN)
-
-uninstall:
-	cd src && cd $(INSTALL_BIN) && $(RM) $(TO_BIN)
-	cd src && cd $(INSTALL_INC) && $(RM) $(TO_INC)
-	cd src && cd $(INSTALL_LIB) && $(RM) $(TO_LIB)
-	cd doc && cd $(INSTALL_MAN) && $(RM) $(TO_MAN)
-
-local:
-	$(MAKE) install INSTALL_TOP=../install
-
-none:
-	@echo "Please do 'make PLATFORM' where PLATFORM is one of these:"
-	@echo "   $(PLATS)"
-	@echo "See doc/readme.html for complete instructions."
-
-# make may get confused with test/ and install/
-dummy:
-
-# echo config parameters
-echo:
-	@cd src && $(MAKE) -s echo
-	@echo "PLAT= $(PLAT)"
-	@echo "V= $V"
-	@echo "R= $R"
-	@echo "TO_BIN= $(TO_BIN)"
-	@echo "TO_INC= $(TO_INC)"
-	@echo "TO_LIB= $(TO_LIB)"
-	@echo "TO_MAN= $(TO_MAN)"
-	@echo "INSTALL_TOP= $(INSTALL_TOP)"
-	@echo "INSTALL_BIN= $(INSTALL_BIN)"
-	@echo "INSTALL_INC= $(INSTALL_INC)"
-	@echo "INSTALL_LIB= $(INSTALL_LIB)"
-	@echo "INSTALL_MAN= $(INSTALL_MAN)"
-	@echo "INSTALL_LMOD= $(INSTALL_LMOD)"
-	@echo "INSTALL_CMOD= $(INSTALL_CMOD)"
-	@echo "INSTALL_EXEC= $(INSTALL_EXEC)"
-	@echo "INSTALL_DATA= $(INSTALL_DATA)"
-
-# echo pkg-config data
-pc:
-	@echo "version=$R"
-	@echo "prefix=$(INSTALL_TOP)"
-	@echo "libdir=$(INSTALL_LIB)"
-	@echo "includedir=$(INSTALL_INC)"
-
-# list targets that do not create files (but not all makes understand .PHONY)
-.PHONY: all $(PLATS) clean test install local none dummy echo pecho lecho
-
-# (end of Makefile)
diff --git a/lua/lua-5.3.5/README b/lua/lua-5.3.5/README
deleted file mode 100644
index ed424de..0000000
--- a/lua/lua-5.3.5/README
+++ /dev/null
@@ -1,6 +0,0 @@
-
-This is Lua 5.3.5, released on 26 Jun 2018.
-
-For installation instructions, license details, and
-further information about Lua, see doc/readme.html.
-
diff --git a/lua/lua-5.3.5/doc/contents.html b/lua/lua-5.3.5/doc/contents.html
deleted file mode 100644
index c4eb267..0000000
--- a/lua/lua-5.3.5/doc/contents.html
+++ /dev/null
@@ -1,619 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<HTML>
-<HEAD>
-<TITLE>Lua 5.3 Reference Manual - contents</TITLE>
-<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
-<LINK REL="stylesheet" TYPE="text/css" HREF="index.css">
-<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
-</HEAD>
-
-<BODY>
-
-<H1>
-<A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua"></A>
-Lua 5.3 Reference Manual
-</H1>
-
-<P>
-The reference manual is the official definition of the Lua language.
-<BR>
-For a complete introduction to Lua programming, see the book
-<A HREF="http://www.lua.org/pil/">Programming in Lua</A>.
-
-<DIV CLASS="menubar">
-<A HREF="manual.html">start</A>
-&middot;
-<A HREF="#contents">contents</A>
-&middot;
-<A HREF="#index">index</A>
-&middot;
-<A HREF="http://www.lua.org/manual/">other versions</A>
-</DIV>
-
-<P>
-<SMALL>
-Copyright &copy; 2015&ndash;2018 Lua.org, PUC-Rio.
-Freely available under the terms of the
-<A HREF="http://www.lua.org/license.html">Lua license</A>.
-</SMALL>
-
-<H2><A NAME="contents">Contents</A></H2>
-<UL CLASS="contents menubar">
-<LI><A HREF="manual.html">1 &ndash; Introduction</A>
-<P>
-<LI><A HREF="manual.html#2">2 &ndash; Basic Concepts</A>
-<UL>
-<LI><A HREF="manual.html#2.1">2.1 &ndash; Values and Types</A>
-<LI><A HREF="manual.html#2.2">2.2 &ndash; Environments and the Global Environment</A>
-<LI><A HREF="manual.html#2.3">2.3 &ndash; Error Handling</A>
-<LI><A HREF="manual.html#2.4">2.4 &ndash; Metatables and Metamethods</A>
-<LI><A HREF="manual.html#2.5">2.5 &ndash; Garbage Collection</A>
-<UL>
-<LI><A HREF="manual.html#2.5.1">2.5.1 &ndash; Garbage-Collection Metamethods</A>
-<LI><A HREF="manual.html#2.5.2">2.5.2 &ndash; Weak Tables</A>
-</UL>
-<LI><A HREF="manual.html#2.6">2.6 &ndash; Coroutines</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#3">3 &ndash; The Language</A>
-<UL>
-<LI><A HREF="manual.html#3.1">3.1 &ndash; Lexical Conventions</A>
-<LI><A HREF="manual.html#3.2">3.2 &ndash; Variables</A>
-<LI><A HREF="manual.html#3.3">3.3 &ndash; Statements</A>
-<UL>
-<LI><A HREF="manual.html#3.3.1">3.3.1 &ndash; Blocks</A>
-<LI><A HREF="manual.html#3.3.2">3.3.2 &ndash; Chunks</A>
-<LI><A HREF="manual.html#3.3.3">3.3.3 &ndash; Assignment</A>
-<LI><A HREF="manual.html#3.3.4">3.3.4 &ndash; Control Structures</A>
-<LI><A HREF="manual.html#3.3.5">3.3.5 &ndash; For Statement</A>
-<LI><A HREF="manual.html#3.3.6">3.3.6 &ndash; Function Calls as Statements</A>
-<LI><A HREF="manual.html#3.3.7">3.3.7 &ndash; Local Declarations</A>
-</UL>
-<LI><A HREF="manual.html#3.4">3.4 &ndash; Expressions</A>
-<UL>
-<LI><A HREF="manual.html#3.4.1">3.4.1 &ndash; Arithmetic Operators</A>
-<LI><A HREF="manual.html#3.4.2">3.4.2 &ndash; Bitwise Operators</A>
-<LI><A HREF="manual.html#3.4.3">3.4.3 &ndash; Coercions and Conversions</A>
-<LI><A HREF="manual.html#3.4.4">3.4.4 &ndash; Relational Operators</A>
-<LI><A HREF="manual.html#3.4.5">3.4.5 &ndash; Logical Operators</A>
-<LI><A HREF="manual.html#3.4.6">3.4.6 &ndash; Concatenation</A>
-<LI><A HREF="manual.html#3.4.7">3.4.7 &ndash; The Length Operator</A>
-<LI><A HREF="manual.html#3.4.8">3.4.8 &ndash; Precedence</A>
-<LI><A HREF="manual.html#3.4.9">3.4.9 &ndash; Table Constructors</A>
-<LI><A HREF="manual.html#3.4.10">3.4.10 &ndash; Function Calls</A>
-<LI><A HREF="manual.html#3.4.11">3.4.11 &ndash; Function Definitions</A>
-</UL>
-<LI><A HREF="manual.html#3.5">3.5 &ndash; Visibility Rules</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#4">4 &ndash; The Application Program Interface</A>
-<UL>
-<LI><A HREF="manual.html#4.1">4.1 &ndash; The Stack</A>
-<LI><A HREF="manual.html#4.2">4.2 &ndash; Stack Size</A>
-<LI><A HREF="manual.html#4.3">4.3 &ndash; Valid and Acceptable Indices</A>
-<LI><A HREF="manual.html#4.4">4.4 &ndash; C Closures</A>
-<LI><A HREF="manual.html#4.5">4.5 &ndash; Registry</A>
-<LI><A HREF="manual.html#4.6">4.6 &ndash; Error Handling in C</A>
-<LI><A HREF="manual.html#4.7">4.7 &ndash; Handling Yields in C</A>
-<LI><A HREF="manual.html#4.8">4.8 &ndash; Functions and Types</A>
-<LI><A HREF="manual.html#4.9">4.9 &ndash; The Debug Interface</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#5">5 &ndash; The Auxiliary Library</A>
-<UL>
-<LI><A HREF="manual.html#5.1">5.1 &ndash; Functions and Types</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#6">6 &ndash; Standard Libraries</A>
-<UL>
-<LI><A HREF="manual.html#6.1">6.1 &ndash; Basic Functions</A>
-<LI><A HREF="manual.html#6.2">6.2 &ndash; Coroutine Manipulation</A>
-<LI><A HREF="manual.html#6.3">6.3 &ndash; Modules</A>
-<LI><A HREF="manual.html#6.4">6.4 &ndash; String Manipulation</A>
-<UL>
-<LI><A HREF="manual.html#6.4.1">6.4.1 &ndash; Patterns</A>
-<LI><A HREF="manual.html#6.4.2">6.4.2 &ndash; Format Strings for Pack and Unpack</A>
-</UL>
-<LI><A HREF="manual.html#6.5">6.5 &ndash; UTF-8 Support</A>
-<LI><A HREF="manual.html#6.6">6.6 &ndash; Table Manipulation</A>
-<LI><A HREF="manual.html#6.7">6.7 &ndash; Mathematical Functions</A>
-<LI><A HREF="manual.html#6.8">6.8 &ndash; Input and Output Facilities</A>
-<LI><A HREF="manual.html#6.9">6.9 &ndash; Operating System Facilities</A>
-<LI><A HREF="manual.html#6.10">6.10 &ndash; The Debug Library</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#7">7 &ndash; Lua Standalone</A>
-<P>
-<LI><A HREF="manual.html#8">8 &ndash; Incompatibilities with the Previous Version</A>
-<UL>
-<LI><A HREF="manual.html#8.1">8.1 &ndash; Changes in the Language</A>
-<LI><A HREF="manual.html#8.2">8.2 &ndash; Changes in the Libraries</A>
-<LI><A HREF="manual.html#8.3">8.3 &ndash; Changes in the API</A>
-</UL>
-<P>
-<LI><A HREF="manual.html#9">9 &ndash; The Complete Syntax of Lua</A>
-</UL>
-
-<H2><A NAME="index">Index</A></H2>
-<TABLE CLASS="menubar" WIDTH="100%">
-<TR>
-<TD>
-<H3><A NAME="functions">Lua functions</A></H3>
-<P>
-<A HREF="manual.html#6.1">basic</A><BR>
-<A HREF="manual.html#pdf-_G">_G</A><BR>
-<A HREF="manual.html#pdf-_VERSION">_VERSION</A><BR>
-<A HREF="manual.html#pdf-assert">assert</A><BR>
-<A HREF="manual.html#pdf-collectgarbage">collectgarbage</A><BR>
-<A HREF="manual.html#pdf-dofile">dofile</A><BR>
-<A HREF="manual.html#pdf-error">error</A><BR>
-<A HREF="manual.html#pdf-getmetatable">getmetatable</A><BR>
-<A HREF="manual.html#pdf-ipairs">ipairs</A><BR>
-<A HREF="manual.html#pdf-load">load</A><BR>
-<A HREF="manual.html#pdf-loadfile">loadfile</A><BR>
-<A HREF="manual.html#pdf-next">next</A><BR>
-<A HREF="manual.html#pdf-pairs">pairs</A><BR>
-<A HREF="manual.html#pdf-pcall">pcall</A><BR>
-<A HREF="manual.html#pdf-print">print</A><BR>
-<A HREF="manual.html#pdf-rawequal">rawequal</A><BR>
-<A HREF="manual.html#pdf-rawget">rawget</A><BR>
-<A HREF="manual.html#pdf-rawlen">rawlen</A><BR>
-<A HREF="manual.html#pdf-rawset">rawset</A><BR>
-<A HREF="manual.html#pdf-require">require</A><BR>
-<A HREF="manual.html#pdf-select">select</A><BR>
-<A HREF="manual.html#pdf-setmetatable">setmetatable</A><BR>
-<A HREF="manual.html#pdf-tonumber">tonumber</A><BR>
-<A HREF="manual.html#pdf-tostring">tostring</A><BR>
-<A HREF="manual.html#pdf-type">type</A><BR>
-<A HREF="manual.html#pdf-xpcall">xpcall</A><BR>
-
-<P>
-<A HREF="manual.html#6.2">coroutine</A><BR>
-<A HREF="manual.html#pdf-coroutine.create">coroutine.create</A><BR>
-<A HREF="manual.html#pdf-coroutine.isyieldable">coroutine.isyieldable</A><BR>
-<A HREF="manual.html#pdf-coroutine.resume">coroutine.resume</A><BR>
-<A HREF="manual.html#pdf-coroutine.running">coroutine.running</A><BR>
-<A HREF="manual.html#pdf-coroutine.status">coroutine.status</A><BR>
-<A HREF="manual.html#pdf-coroutine.wrap">coroutine.wrap</A><BR>
-<A HREF="manual.html#pdf-coroutine.yield">coroutine.yield</A><BR>
-
-<P>
-<A HREF="manual.html#6.10">debug</A><BR>
-<A HREF="manual.html#pdf-debug.debug">debug.debug</A><BR>
-<A HREF="manual.html#pdf-debug.gethook">debug.gethook</A><BR>
-<A HREF="manual.html#pdf-debug.getinfo">debug.getinfo</A><BR>
-<A HREF="manual.html#pdf-debug.getlocal">debug.getlocal</A><BR>
-<A HREF="manual.html#pdf-debug.getmetatable">debug.getmetatable</A><BR>
-<A HREF="manual.html#pdf-debug.getregistry">debug.getregistry</A><BR>
-<A HREF="manual.html#pdf-debug.getupvalue">debug.getupvalue</A><BR>
-<A HREF="manual.html#pdf-debug.getuservalue">debug.getuservalue</A><BR>
-<A HREF="manual.html#pdf-debug.sethook">debug.sethook</A><BR>
-<A HREF="manual.html#pdf-debug.setlocal">debug.setlocal</A><BR>
-<A HREF="manual.html#pdf-debug.setmetatable">debug.setmetatable</A><BR>
-<A HREF="manual.html#pdf-debug.setupvalue">debug.setupvalue</A><BR>
-<A HREF="manual.html#pdf-debug.setuservalue">debug.setuservalue</A><BR>
-<A HREF="manual.html#pdf-debug.traceback">debug.traceback</A><BR>
-<A HREF="manual.html#pdf-debug.upvalueid">debug.upvalueid</A><BR>
-<A HREF="manual.html#pdf-debug.upvaluejoin">debug.upvaluejoin</A><BR>
-
-<P>
-<A HREF="manual.html#6.8">io</A><BR>
-<A HREF="manual.html#pdf-io.close">io.close</A><BR>
-<A HREF="manual.html#pdf-io.flush">io.flush</A><BR>
-<A HREF="manual.html#pdf-io.input">io.input</A><BR>
-<A HREF="manual.html#pdf-io.lines">io.lines</A><BR>
-<A HREF="manual.html#pdf-io.open">io.open</A><BR>
-<A HREF="manual.html#pdf-io.output">io.output</A><BR>
-<A HREF="manual.html#pdf-io.popen">io.popen</A><BR>
-<A HREF="manual.html#pdf-io.read">io.read</A><BR>
-<A HREF="manual.html#pdf-io.stderr">io.stderr</A><BR>
-<A HREF="manual.html#pdf-io.stdin">io.stdin</A><BR>
-<A HREF="manual.html#pdf-io.stdout">io.stdout</A><BR>
-<A HREF="manual.html#pdf-io.tmpfile">io.tmpfile</A><BR>
-<A HREF="manual.html#pdf-io.type">io.type</A><BR>
-<A HREF="manual.html#pdf-io.write">io.write</A><BR>
-
-<A HREF="manual.html#pdf-file:close">file:close</A><BR>
-<A HREF="manual.html#pdf-file:flush">file:flush</A><BR>
-<A HREF="manual.html#pdf-file:lines">file:lines</A><BR>
-<A HREF="manual.html#pdf-file:read">file:read</A><BR>
-<A HREF="manual.html#pdf-file:seek">file:seek</A><BR>
-<A HREF="manual.html#pdf-file:setvbuf">file:setvbuf</A><BR>
-<A HREF="manual.html#pdf-file:write">file:write</A><BR>
-
-</TD>
-<TD>
-<H3>&nbsp;</H3>
-<P>
-<A HREF="manual.html#6.7">math</A><BR>
-<A HREF="manual.html#pdf-math.abs">math.abs</A><BR>
-<A HREF="manual.html#pdf-math.acos">math.acos</A><BR>
-<A HREF="manual.html#pdf-math.asin">math.asin</A><BR>
-<A HREF="manual.html#pdf-math.atan">math.atan</A><BR>
-<A HREF="manual.html#pdf-math.ceil">math.ceil</A><BR>
-<A HREF="manual.html#pdf-math.cos">math.cos</A><BR>
-<A HREF="manual.html#pdf-math.deg">math.deg</A><BR>
-<A HREF="manual.html#pdf-math.exp">math.exp</A><BR>
-<A HREF="manual.html#pdf-math.floor">math.floor</A><BR>
-<A HREF="manual.html#pdf-math.fmod">math.fmod</A><BR>
-<A HREF="manual.html#pdf-math.huge">math.huge</A><BR>
-<A HREF="manual.html#pdf-math.log">math.log</A><BR>
-<A HREF="manual.html#pdf-math.max">math.max</A><BR>
-<A HREF="manual.html#pdf-math.maxinteger">math.maxinteger</A><BR>
-<A HREF="manual.html#pdf-math.min">math.min</A><BR>
-<A HREF="manual.html#pdf-math.mininteger">math.mininteger</A><BR>
-<A HREF="manual.html#pdf-math.modf">math.modf</A><BR>
-<A HREF="manual.html#pdf-math.pi">math.pi</A><BR>
-<A HREF="manual.html#pdf-math.rad">math.rad</A><BR>
-<A HREF="manual.html#pdf-math.random">math.random</A><BR>
-<A HREF="manual.html#pdf-math.randomseed">math.randomseed</A><BR>
-<A HREF="manual.html#pdf-math.sin">math.sin</A><BR>
-<A HREF="manual.html#pdf-math.sqrt">math.sqrt</A><BR>
-<A HREF="manual.html#pdf-math.tan">math.tan</A><BR>
-<A HREF="manual.html#pdf-math.tointeger">math.tointeger</A><BR>
-<A HREF="manual.html#pdf-math.type">math.type</A><BR>
-<A HREF="manual.html#pdf-math.ult">math.ult</A><BR>
-
-<P>
-<A HREF="manual.html#6.9">os</A><BR>
-<A HREF="manual.html#pdf-os.clock">os.clock</A><BR>
-<A HREF="manual.html#pdf-os.date">os.date</A><BR>
-<A HREF="manual.html#pdf-os.difftime">os.difftime</A><BR>
-<A HREF="manual.html#pdf-os.execute">os.execute</A><BR>
-<A HREF="manual.html#pdf-os.exit">os.exit</A><BR>
-<A HREF="manual.html#pdf-os.getenv">os.getenv</A><BR>
-<A HREF="manual.html#pdf-os.remove">os.remove</A><BR>
-<A HREF="manual.html#pdf-os.rename">os.rename</A><BR>
-<A HREF="manual.html#pdf-os.setlocale">os.setlocale</A><BR>
-<A HREF="manual.html#pdf-os.time">os.time</A><BR>
-<A HREF="manual.html#pdf-os.tmpname">os.tmpname</A><BR>
-
-<P>
-<A HREF="manual.html#6.3">package</A><BR>
-<A HREF="manual.html#pdf-package.config">package.config</A><BR>
-<A HREF="manual.html#pdf-package.cpath">package.cpath</A><BR>
-<A HREF="manual.html#pdf-package.loaded">package.loaded</A><BR>
-<A HREF="manual.html#pdf-package.loadlib">package.loadlib</A><BR>
-<A HREF="manual.html#pdf-package.path">package.path</A><BR>
-<A HREF="manual.html#pdf-package.preload">package.preload</A><BR>
-<A HREF="manual.html#pdf-package.searchers">package.searchers</A><BR>
-<A HREF="manual.html#pdf-package.searchpath">package.searchpath</A><BR>
-
-<P>
-<A HREF="manual.html#6.4">string</A><BR>
-<A HREF="manual.html#pdf-string.byte">string.byte</A><BR>
-<A HREF="manual.html#pdf-string.char">string.char</A><BR>
-<A HREF="manual.html#pdf-string.dump">string.dump</A><BR>
-<A HREF="manual.html#pdf-string.find">string.find</A><BR>
-<A HREF="manual.html#pdf-string.format">string.format</A><BR>
-<A HREF="manual.html#pdf-string.gmatch">string.gmatch</A><BR>
-<A HREF="manual.html#pdf-string.gsub">string.gsub</A><BR>
-<A HREF="manual.html#pdf-string.len">string.len</A><BR>
-<A HREF="manual.html#pdf-string.lower">string.lower</A><BR>
-<A HREF="manual.html#pdf-string.match">string.match</A><BR>
-<A HREF="manual.html#pdf-string.pack">string.pack</A><BR>
-<A HREF="manual.html#pdf-string.packsize">string.packsize</A><BR>
-<A HREF="manual.html#pdf-string.rep">string.rep</A><BR>
-<A HREF="manual.html#pdf-string.reverse">string.reverse</A><BR>
-<A HREF="manual.html#pdf-string.sub">string.sub</A><BR>
-<A HREF="manual.html#pdf-string.unpack">string.unpack</A><BR>
-<A HREF="manual.html#pdf-string.upper">string.upper</A><BR>
-
-<P>
-<A HREF="manual.html#6.6">table</A><BR>
-<A HREF="manual.html#pdf-table.concat">table.concat</A><BR>
-<A HREF="manual.html#pdf-table.insert">table.insert</A><BR>
-<A HREF="manual.html#pdf-table.move">table.move</A><BR>
-<A HREF="manual.html#pdf-table.pack">table.pack</A><BR>
-<A HREF="manual.html#pdf-table.remove">table.remove</A><BR>
-<A HREF="manual.html#pdf-table.sort">table.sort</A><BR>
-<A HREF="manual.html#pdf-table.unpack">table.unpack</A><BR>
-
-<P>
-<A HREF="manual.html#6.5">utf8</A><BR>
-<A HREF="manual.html#pdf-utf8.char">utf8.char</A><BR>
-<A HREF="manual.html#pdf-utf8.charpattern">utf8.charpattern</A><BR>
-<A HREF="manual.html#pdf-utf8.codepoint">utf8.codepoint</A><BR>
-<A HREF="manual.html#pdf-utf8.codes">utf8.codes</A><BR>
-<A HREF="manual.html#pdf-utf8.len">utf8.len</A><BR>
-<A HREF="manual.html#pdf-utf8.offset">utf8.offset</A><BR>
-
-<H3><A NAME="env">environment<BR>variables</A></H3>
-<P>
-<A HREF="manual.html#pdf-LUA_CPATH">LUA_CPATH</A><BR>
-<A HREF="manual.html#pdf-LUA_CPATH_5_3">LUA_CPATH_5_3</A><BR>
-<A HREF="manual.html#pdf-LUA_INIT">LUA_INIT</A><BR>
-<A HREF="manual.html#pdf-LUA_INIT_5_3">LUA_INIT_5_3</A><BR>
-<A HREF="manual.html#pdf-LUA_PATH">LUA_PATH</A><BR>
-<A HREF="manual.html#pdf-LUA_PATH_5_3">LUA_PATH_5_3</A><BR>
-
-</TD>
-<TD>
-<H3><A NAME="api">C API</A></H3>
-<P>
-<A HREF="manual.html#lua_Alloc">lua_Alloc</A><BR>
-<A HREF="manual.html#lua_CFunction">lua_CFunction</A><BR>
-<A HREF="manual.html#lua_Debug">lua_Debug</A><BR>
-<A HREF="manual.html#lua_Hook">lua_Hook</A><BR>
-<A HREF="manual.html#lua_Integer">lua_Integer</A><BR>
-<A HREF="manual.html#lua_KContext">lua_KContext</A><BR>
-<A HREF="manual.html#lua_KFunction">lua_KFunction</A><BR>
-<A HREF="manual.html#lua_Number">lua_Number</A><BR>
-<A HREF="manual.html#lua_Reader">lua_Reader</A><BR>
-<A HREF="manual.html#lua_State">lua_State</A><BR>
-<A HREF="manual.html#lua_Unsigned">lua_Unsigned</A><BR>
-<A HREF="manual.html#lua_Writer">lua_Writer</A><BR>
-
-<P>
-<A HREF="manual.html#lua_absindex">lua_absindex</A><BR>
-<A HREF="manual.html#lua_arith">lua_arith</A><BR>
-<A HREF="manual.html#lua_atpanic">lua_atpanic</A><BR>
-<A HREF="manual.html#lua_call">lua_call</A><BR>
-<A HREF="manual.html#lua_callk">lua_callk</A><BR>
-<A HREF="manual.html#lua_checkstack">lua_checkstack</A><BR>
-<A HREF="manual.html#lua_close">lua_close</A><BR>
-<A HREF="manual.html#lua_compare">lua_compare</A><BR>
-<A HREF="manual.html#lua_concat">lua_concat</A><BR>
-<A HREF="manual.html#lua_copy">lua_copy</A><BR>
-<A HREF="manual.html#lua_createtable">lua_createtable</A><BR>
-<A HREF="manual.html#lua_dump">lua_dump</A><BR>
-<A HREF="manual.html#lua_error">lua_error</A><BR>
-<A HREF="manual.html#lua_gc">lua_gc</A><BR>
-<A HREF="manual.html#lua_getallocf">lua_getallocf</A><BR>
-<A HREF="manual.html#lua_getextraspace">lua_getextraspace</A><BR>
-<A HREF="manual.html#lua_getfield">lua_getfield</A><BR>
-<A HREF="manual.html#lua_getglobal">lua_getglobal</A><BR>
-<A HREF="manual.html#lua_gethook">lua_gethook</A><BR>
-<A HREF="manual.html#lua_gethookcount">lua_gethookcount</A><BR>
-<A HREF="manual.html#lua_gethookmask">lua_gethookmask</A><BR>
-<A HREF="manual.html#lua_geti">lua_geti</A><BR>
-<A HREF="manual.html#lua_getinfo">lua_getinfo</A><BR>
-<A HREF="manual.html#lua_getlocal">lua_getlocal</A><BR>
-<A HREF="manual.html#lua_getmetatable">lua_getmetatable</A><BR>
-<A HREF="manual.html#lua_getstack">lua_getstack</A><BR>
-<A HREF="manual.html#lua_gettable">lua_gettable</A><BR>
-<A HREF="manual.html#lua_gettop">lua_gettop</A><BR>
-<A HREF="manual.html#lua_getupvalue">lua_getupvalue</A><BR>
-<A HREF="manual.html#lua_getuservalue">lua_getuservalue</A><BR>
-<A HREF="manual.html#lua_insert">lua_insert</A><BR>
-<A HREF="manual.html#lua_isboolean">lua_isboolean</A><BR>
-<A HREF="manual.html#lua_iscfunction">lua_iscfunction</A><BR>
-<A HREF="manual.html#lua_isfunction">lua_isfunction</A><BR>
-<A HREF="manual.html#lua_isinteger">lua_isinteger</A><BR>
-<A HREF="manual.html#lua_islightuserdata">lua_islightuserdata</A><BR>
-<A HREF="manual.html#lua_isnil">lua_isnil</A><BR>
-<A HREF="manual.html#lua_isnone">lua_isnone</A><BR>
-<A HREF="manual.html#lua_isnoneornil">lua_isnoneornil</A><BR>
-<A HREF="manual.html#lua_isnumber">lua_isnumber</A><BR>
-<A HREF="manual.html#lua_isstring">lua_isstring</A><BR>
-<A HREF="manual.html#lua_istable">lua_istable</A><BR>
-<A HREF="manual.html#lua_isthread">lua_isthread</A><BR>
-<A HREF="manual.html#lua_isuserdata">lua_isuserdata</A><BR>
-<A HREF="manual.html#lua_isyieldable">lua_isyieldable</A><BR>
-<A HREF="manual.html#lua_len">lua_len</A><BR>
-<A HREF="manual.html#lua_load">lua_load</A><BR>
-<A HREF="manual.html#lua_newstate">lua_newstate</A><BR>
-<A HREF="manual.html#lua_newtable">lua_newtable</A><BR>
-<A HREF="manual.html#lua_newthread">lua_newthread</A><BR>
-<A HREF="manual.html#lua_newuserdata">lua_newuserdata</A><BR>
-<A HREF="manual.html#lua_next">lua_next</A><BR>
-<A HREF="manual.html#lua_numbertointeger">lua_numbertointeger</A><BR>
-<A HREF="manual.html#lua_pcall">lua_pcall</A><BR>
-<A HREF="manual.html#lua_pcallk">lua_pcallk</A><BR>
-<A HREF="manual.html#lua_pop">lua_pop</A><BR>
-<A HREF="manual.html#lua_pushboolean">lua_pushboolean</A><BR>
-<A HREF="manual.html#lua_pushcclosure">lua_pushcclosure</A><BR>
-<A HREF="manual.html#lua_pushcfunction">lua_pushcfunction</A><BR>
-<A HREF="manual.html#lua_pushfstring">lua_pushfstring</A><BR>
-<A HREF="manual.html#lua_pushglobaltable">lua_pushglobaltable</A><BR>
-<A HREF="manual.html#lua_pushinteger">lua_pushinteger</A><BR>
-<A HREF="manual.html#lua_pushlightuserdata">lua_pushlightuserdata</A><BR>
-<A HREF="manual.html#lua_pushliteral">lua_pushliteral</A><BR>
-<A HREF="manual.html#lua_pushlstring">lua_pushlstring</A><BR>
-<A HREF="manual.html#lua_pushnil">lua_pushnil</A><BR>
-<A HREF="manual.html#lua_pushnumber">lua_pushnumber</A><BR>
-<A HREF="manual.html#lua_pushstring">lua_pushstring</A><BR>
-<A HREF="manual.html#lua_pushthread">lua_pushthread</A><BR>
-<A HREF="manual.html#lua_pushvalue">lua_pushvalue</A><BR>
-<A HREF="manual.html#lua_pushvfstring">lua_pushvfstring</A><BR>
-<A HREF="manual.html#lua_rawequal">lua_rawequal</A><BR>
-<A HREF="manual.html#lua_rawget">lua_rawget</A><BR>
-<A HREF="manual.html#lua_rawgeti">lua_rawgeti</A><BR>
-<A HREF="manual.html#lua_rawgetp">lua_rawgetp</A><BR>
-<A HREF="manual.html#lua_rawlen">lua_rawlen</A><BR>
-<A HREF="manual.html#lua_rawset">lua_rawset</A><BR>
-<A HREF="manual.html#lua_rawseti">lua_rawseti</A><BR>
-<A HREF="manual.html#lua_rawsetp">lua_rawsetp</A><BR>
-<A HREF="manual.html#lua_register">lua_register</A><BR>
-<A HREF="manual.html#lua_remove">lua_remove</A><BR>
-<A HREF="manual.html#lua_replace">lua_replace</A><BR>
-<A HREF="manual.html#lua_resume">lua_resume</A><BR>
-<A HREF="manual.html#lua_rotate">lua_rotate</A><BR>
-<A HREF="manual.html#lua_setallocf">lua_setallocf</A><BR>
-<A HREF="manual.html#lua_setfield">lua_setfield</A><BR>
-<A HREF="manual.html#lua_setglobal">lua_setglobal</A><BR>
-<A HREF="manual.html#lua_sethook">lua_sethook</A><BR>
-<A HREF="manual.html#lua_seti">lua_seti</A><BR>
-<A HREF="manual.html#lua_setlocal">lua_setlocal</A><BR>
-<A HREF="manual.html#lua_setmetatable">lua_setmetatable</A><BR>
-<A HREF="manual.html#lua_settable">lua_settable</A><BR>
-<A HREF="manual.html#lua_settop">lua_settop</A><BR>
-<A HREF="manual.html#lua_setupvalue">lua_setupvalue</A><BR>
-<A HREF="manual.html#lua_setuservalue">lua_setuservalue</A><BR>
-<A HREF="manual.html#lua_status">lua_status</A><BR>
-<A HREF="manual.html#lua_stringtonumber">lua_stringtonumber</A><BR>
-<A HREF="manual.html#lua_toboolean">lua_toboolean</A><BR>
-<A HREF="manual.html#lua_tocfunction">lua_tocfunction</A><BR>
-<A HREF="manual.html#lua_tointeger">lua_tointeger</A><BR>
-<A HREF="manual.html#lua_tointegerx">lua_tointegerx</A><BR>
-<A HREF="manual.html#lua_tolstring">lua_tolstring</A><BR>
-<A HREF="manual.html#lua_tonumber">lua_tonumber</A><BR>
-<A HREF="manual.html#lua_tonumberx">lua_tonumberx</A><BR>
-<A HREF="manual.html#lua_topointer">lua_topointer</A><BR>
-<A HREF="manual.html#lua_tostring">lua_tostring</A><BR>
-<A HREF="manual.html#lua_tothread">lua_tothread</A><BR>
-<A HREF="manual.html#lua_touserdata">lua_touserdata</A><BR>
-<A HREF="manual.html#lua_type">lua_type</A><BR>
-<A HREF="manual.html#lua_typename">lua_typename</A><BR>
-<A HREF="manual.html#lua_upvalueid">lua_upvalueid</A><BR>
-<A HREF="manual.html#lua_upvalueindex">lua_upvalueindex</A><BR>
-<A HREF="manual.html#lua_upvaluejoin">lua_upvaluejoin</A><BR>
-<A HREF="manual.html#lua_version">lua_version</A><BR>
-<A HREF="manual.html#lua_xmove">lua_xmove</A><BR>
-<A HREF="manual.html#lua_yield">lua_yield</A><BR>
-<A HREF="manual.html#lua_yieldk">lua_yieldk</A><BR>
-
-</TD>
-<TD>
-<H3><A NAME="auxlib">auxiliary library</A></H3>
-<P>
-<A HREF="manual.html#luaL_Buffer">luaL_Buffer</A><BR>
-<A HREF="manual.html#luaL_Reg">luaL_Reg</A><BR>
-<A HREF="manual.html#luaL_Stream">luaL_Stream</A><BR>
-
-<P>
-<A HREF="manual.html#luaL_addchar">luaL_addchar</A><BR>
-<A HREF="manual.html#luaL_addlstring">luaL_addlstring</A><BR>
-<A HREF="manual.html#luaL_addsize">luaL_addsize</A><BR>
-<A HREF="manual.html#luaL_addstring">luaL_addstring</A><BR>
-<A HREF="manual.html#luaL_addvalue">luaL_addvalue</A><BR>
-<A HREF="manual.html#luaL_argcheck">luaL_argcheck</A><BR>
-<A HREF="manual.html#luaL_argerror">luaL_argerror</A><BR>
-<A HREF="manual.html#luaL_buffinit">luaL_buffinit</A><BR>
-<A HREF="manual.html#luaL_buffinitsize">luaL_buffinitsize</A><BR>
-<A HREF="manual.html#luaL_callmeta">luaL_callmeta</A><BR>
-<A HREF="manual.html#luaL_checkany">luaL_checkany</A><BR>
-<A HREF="manual.html#luaL_checkinteger">luaL_checkinteger</A><BR>
-<A HREF="manual.html#luaL_checklstring">luaL_checklstring</A><BR>
-<A HREF="manual.html#luaL_checknumber">luaL_checknumber</A><BR>
-<A HREF="manual.html#luaL_checkoption">luaL_checkoption</A><BR>
-<A HREF="manual.html#luaL_checkstack">luaL_checkstack</A><BR>
-<A HREF="manual.html#luaL_checkstring">luaL_checkstring</A><BR>
-<A HREF="manual.html#luaL_checktype">luaL_checktype</A><BR>
-<A HREF="manual.html#luaL_checkudata">luaL_checkudata</A><BR>
-<A HREF="manual.html#luaL_checkversion">luaL_checkversion</A><BR>
-<A HREF="manual.html#luaL_dofile">luaL_dofile</A><BR>
-<A HREF="manual.html#luaL_dostring">luaL_dostring</A><BR>
-<A HREF="manual.html#luaL_error">luaL_error</A><BR>
-<A HREF="manual.html#luaL_execresult">luaL_execresult</A><BR>
-<A HREF="manual.html#luaL_fileresult">luaL_fileresult</A><BR>
-<A HREF="manual.html#luaL_getmetafield">luaL_getmetafield</A><BR>
-<A HREF="manual.html#luaL_getmetatable">luaL_getmetatable</A><BR>
-<A HREF="manual.html#luaL_getsubtable">luaL_getsubtable</A><BR>
-<A HREF="manual.html#luaL_gsub">luaL_gsub</A><BR>
-<A HREF="manual.html#luaL_len">luaL_len</A><BR>
-<A HREF="manual.html#luaL_loadbuffer">luaL_loadbuffer</A><BR>
-<A HREF="manual.html#luaL_loadbufferx">luaL_loadbufferx</A><BR>
-<A HREF="manual.html#luaL_loadfile">luaL_loadfile</A><BR>
-<A HREF="manual.html#luaL_loadfilex">luaL_loadfilex</A><BR>
-<A HREF="manual.html#luaL_loadstring">luaL_loadstring</A><BR>
-<A HREF="manual.html#luaL_newlib">luaL_newlib</A><BR>
-<A HREF="manual.html#luaL_newlibtable">luaL_newlibtable</A><BR>
-<A HREF="manual.html#luaL_newmetatable">luaL_newmetatable</A><BR>
-<A HREF="manual.html#luaL_newstate">luaL_newstate</A><BR>
-<A HREF="manual.html#luaL_openlibs">luaL_openlibs</A><BR>
-<A HREF="manual.html#luaL_opt">luaL_opt</A><BR>
-<A HREF="manual.html#luaL_optinteger">luaL_optinteger</A><BR>
-<A HREF="manual.html#luaL_optlstring">luaL_optlstring</A><BR>
-<A HREF="manual.html#luaL_optnumber">luaL_optnumber</A><BR>
-<A HREF="manual.html#luaL_optstring">luaL_optstring</A><BR>
-<A HREF="manual.html#luaL_prepbuffer">luaL_prepbuffer</A><BR>
-<A HREF="manual.html#luaL_prepbuffsize">luaL_prepbuffsize</A><BR>
-<A HREF="manual.html#luaL_pushresult">luaL_pushresult</A><BR>
-<A HREF="manual.html#luaL_pushresultsize">luaL_pushresultsize</A><BR>
-<A HREF="manual.html#luaL_ref">luaL_ref</A><BR>
-<A HREF="manual.html#luaL_requiref">luaL_requiref</A><BR>
-<A HREF="manual.html#luaL_setfuncs">luaL_setfuncs</A><BR>
-<A HREF="manual.html#luaL_setmetatable">luaL_setmetatable</A><BR>
-<A HREF="manual.html#luaL_testudata">luaL_testudata</A><BR>
-<A HREF="manual.html#luaL_tolstring">luaL_tolstring</A><BR>
-<A HREF="manual.html#luaL_traceback">luaL_traceback</A><BR>
-<A HREF="manual.html#luaL_typename">luaL_typename</A><BR>
-<A HREF="manual.html#luaL_unref">luaL_unref</A><BR>
-<A HREF="manual.html#luaL_where">luaL_where</A><BR>
-
-<H3><A NAME="library">standard library</A></H3>
-<P>
-<A HREF="manual.html#pdf-luaopen_base">luaopen_base</A><BR>
-<A HREF="manual.html#pdf-luaopen_coroutine">luaopen_coroutine</A><BR>
-<A HREF="manual.html#pdf-luaopen_debug">luaopen_debug</A><BR>
-<A HREF="manual.html#pdf-luaopen_io">luaopen_io</A><BR>
-<A HREF="manual.html#pdf-luaopen_math">luaopen_math</A><BR>
-<A HREF="manual.html#pdf-luaopen_os">luaopen_os</A><BR>
-<A HREF="manual.html#pdf-luaopen_package">luaopen_package</A><BR>
-<A HREF="manual.html#pdf-luaopen_string">luaopen_string</A><BR>
-<A HREF="manual.html#pdf-luaopen_table">luaopen_table</A><BR>
-<A HREF="manual.html#pdf-luaopen_utf8">luaopen_utf8</A><BR>
-
-<H3><A NAME="constants">constants</A></H3>
-<P>
-<A HREF="manual.html#pdf-LUA_ERRERR">LUA_ERRERR</A><BR>
-<A HREF="manual.html#pdf-LUA_ERRFILE">LUA_ERRFILE</A><BR>
-<A HREF="manual.html#pdf-LUA_ERRGCMM">LUA_ERRGCMM</A><BR>
-<A HREF="manual.html#pdf-LUA_ERRMEM">LUA_ERRMEM</A><BR>
-<A HREF="manual.html#pdf-LUA_ERRRUN">LUA_ERRRUN</A><BR>
-<A HREF="manual.html#pdf-LUA_ERRSYNTAX">LUA_ERRSYNTAX</A><BR>
-<A HREF="manual.html#pdf-LUA_HOOKCALL">LUA_HOOKCALL</A><BR>
-<A HREF="manual.html#pdf-LUA_HOOKCOUNT">LUA_HOOKCOUNT</A><BR>
-<A HREF="manual.html#pdf-LUA_HOOKLINE">LUA_HOOKLINE</A><BR>
-<A HREF="manual.html#pdf-LUA_HOOKRET">LUA_HOOKRET</A><BR>
-<A HREF="manual.html#pdf-LUA_HOOKTAILCALL">LUA_HOOKTAILCALL</A><BR>
-<A HREF="manual.html#pdf-LUA_MASKCALL">LUA_MASKCALL</A><BR>
-<A HREF="manual.html#pdf-LUA_MASKCOUNT">LUA_MASKCOUNT</A><BR>
-<A HREF="manual.html#pdf-LUA_MASKLINE">LUA_MASKLINE</A><BR>
-<A HREF="manual.html#pdf-LUA_MASKRET">LUA_MASKRET</A><BR>
-<A HREF="manual.html#pdf-LUA_MAXINTEGER">LUA_MAXINTEGER</A><BR>
-<A HREF="manual.html#pdf-LUA_MININTEGER">LUA_MININTEGER</A><BR>
-<A HREF="manual.html#pdf-LUA_MINSTACK">LUA_MINSTACK</A><BR>
-<A HREF="manual.html#pdf-LUA_MULTRET">LUA_MULTRET</A><BR>
-<A HREF="manual.html#pdf-LUA_NOREF">LUA_NOREF</A><BR>
-<A HREF="manual.html#pdf-LUA_OK">LUA_OK</A><BR>
-<A HREF="manual.html#pdf-LUA_OPADD">LUA_OPADD</A><BR>
-<A HREF="manual.html#pdf-LUA_OPBAND">LUA_OPBAND</A><BR>
-<A HREF="manual.html#pdf-LUA_OPBNOT">LUA_OPBNOT</A><BR>
-<A HREF="manual.html#pdf-LUA_OPBOR">LUA_OPBOR</A><BR>
-<A HREF="manual.html#pdf-LUA_OPBXOR">LUA_OPBXOR</A><BR>
-<A HREF="manual.html#pdf-LUA_OPDIV">LUA_OPDIV</A><BR>
-<A HREF="manual.html#pdf-LUA_OPEQ">LUA_OPEQ</A><BR>
-<A HREF="manual.html#pdf-LUA_OPIDIV">LUA_OPIDIV</A><BR>
-<A HREF="manual.html#pdf-LUA_OPLE">LUA_OPLE</A><BR>
-<A HREF="manual.html#pdf-LUA_OPLT">LUA_OPLT</A><BR>
-<A HREF="manual.html#pdf-LUA_OPMOD">LUA_OPMOD</A><BR>
-<A HREF="manual.html#pdf-LUA_OPMUL">LUA_OPMUL</A><BR>
-<A HREF="manual.html#pdf-LUA_OPPOW">LUA_OPPOW</A><BR>
-<A HREF="manual.html#pdf-LUA_OPSHL">LUA_OPSHL</A><BR>
-<A HREF="manual.html#pdf-LUA_OPSHR">LUA_OPSHR</A><BR>
-<A HREF="manual.html#pdf-LUA_OPSUB">LUA_OPSUB</A><BR>
-<A HREF="manual.html#pdf-LUA_OPUNM">LUA_OPUNM</A><BR>
-<A HREF="manual.html#pdf-LUA_REFNIL">LUA_REFNIL</A><BR>
-<A HREF="manual.html#pdf-LUA_REGISTRYINDEX">LUA_REGISTRYINDEX</A><BR>
-<A HREF="manual.html#pdf-LUA_RIDX_GLOBALS">LUA_RIDX_GLOBALS</A><BR>
-<A HREF="manual.html#pdf-LUA_RIDX_MAINTHREAD">LUA_RIDX_MAINTHREAD</A><BR>
-<A HREF="manual.html#pdf-LUA_TBOOLEAN">LUA_TBOOLEAN</A><BR>
-<A HREF="manual.html#pdf-LUA_TFUNCTION">LUA_TFUNCTION</A><BR>
-<A HREF="manual.html#pdf-LUA_TLIGHTUSERDATA">LUA_TLIGHTUSERDATA</A><BR>
-<A HREF="manual.html#pdf-LUA_TNIL">LUA_TNIL</A><BR>
-<A HREF="manual.html#pdf-LUA_TNONE">LUA_TNONE</A><BR>
-<A HREF="manual.html#pdf-LUA_TNUMBER">LUA_TNUMBER</A><BR>
-<A HREF="manual.html#pdf-LUA_TSTRING">LUA_TSTRING</A><BR>
-<A HREF="manual.html#pdf-LUA_TTABLE">LUA_TTABLE</A><BR>
-<A HREF="manual.html#pdf-LUA_TTHREAD">LUA_TTHREAD</A><BR>
-<A HREF="manual.html#pdf-LUA_TUSERDATA">LUA_TUSERDATA</A><BR>
-<A HREF="manual.html#pdf-LUA_USE_APICHECK">LUA_USE_APICHECK</A><BR>
-<A HREF="manual.html#pdf-LUA_YIELD">LUA_YIELD</A><BR>
-<A HREF="manual.html#pdf-LUAL_BUFFERSIZE">LUAL_BUFFERSIZE</A><BR>
-
-</TD>
-</TR>
-</TABLE>
-
-<P CLASS="footer">
-Last update:
-Mon Jun 18 22:56:06 -03 2018
-</P>
-<!--
-Last change: revised for Lua 5.3.5
--->
-
-</BODY>
-</HTML>
diff --git a/lua/lua-5.3.5/doc/index.css b/lua/lua-5.3.5/doc/index.css
deleted file mode 100644
index c961835..0000000
--- a/lua/lua-5.3.5/doc/index.css
+++ /dev/null
@@ -1,21 +0,0 @@
-ul {
-	list-style-type: none ;
-}
-
-ul.contents {
-	padding: 0 ;
-}
-
-table {
-	border: none ;
-	border-spacing: 0 ;
-	border-collapse: collapse ;
-}
-
-td {
-	vertical-align: top ;
-	padding: 0 ;
-	text-align: left ;
-	line-height: 1.25 ;
-	width: 15% ;
-}
diff --git a/lua/lua-5.3.5/doc/logo.gif b/lua/lua-5.3.5/doc/logo.gif
deleted file mode 100644
index 5c77eacc3b8f397fb2e87d2aaecd89128e53a117..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 9893
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%0A-^7`I=ZfR-o#M>pI(&x#FQO~-wA&6X`
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
M5|b0H5Z3qqKj-ldMF0Q*

diff --git a/lua/lua-5.3.5/doc/lua.1 b/lua/lua-5.3.5/doc/lua.1
deleted file mode 100644
index d728d0b..0000000
--- a/lua/lua-5.3.5/doc/lua.1
+++ /dev/null
@@ -1,112 +0,0 @@
-.\" $Id: lua.man,v 1.14 2016/10/17 15:43:50 lhf Exp $
-.TH LUA 1 "$Date: 2016/10/17 15:43:50 $"
-.SH NAME
-lua \- Lua interpreter
-.SH SYNOPSIS
-.B lua
-[
-.I options
-]
-[
-.I script
-[
-.I args
-]
-]
-.SH DESCRIPTION
-.B lua
-is the standalone Lua interpreter.
-It loads and executes Lua programs,
-either in textual source form or
-in precompiled binary form.
-(Precompiled binaries are output by
-.BR luac ,
-the Lua compiler.)
-.B lua
-can be used as a batch interpreter and also interactively.
-.LP
-The given
-.I options
-are handled in order and then
-the Lua program in file
-.I script
-is loaded and executed.
-The given
-.I args
-are available to
-.I script
-as strings in a global table named
-.BR arg .
-If no options or arguments are given,
-then
-.B "\-v \-i"
-is assumed when the standard input is a terminal;
-otherwise,
-.B "\-"
-is assumed.
-.LP
-In interactive mode,
-.B lua
-prompts the user,
-reads lines from the standard input,
-and executes them as they are read.
-If the line contains an expression or list of expressions,
-then the line is evaluated and the results are printed.
-If a line does not contain a complete statement,
-then a secondary prompt is displayed and
-lines are read until a complete statement is formed or
-a syntax error is found.
-.LP
-At the very start,
-before even handling the command line,
-.B lua
-checks the contents of the environment variables
-.B LUA_INIT_5_3
-or
-.BR LUA_INIT ,
-in that order.
-If the contents is of the form
-.RI '@ filename ',
-then
-.I filename
-is executed.
-Otherwise, the string is assumed to be a Lua statement and is executed.
-.SH OPTIONS
-.TP
-.BI \-e " stat"
-execute statement
-.IR stat .
-.TP
-.B \-i
-enter interactive mode after executing
-.IR script .
-.TP
-.BI \-l " name"
-execute the equivalent of
-.IB name =require(' name ')
-before executing
-.IR script .
-.TP
-.B \-v
-show version information.
-.TP
-.B \-E
-ignore environment variables.
-.TP
-.B \-\-
-stop handling options.
-.TP
-.B \-
-stop handling options and execute the standard input as a file.
-.SH "SEE ALSO"
-.BR luac (1)
-.br
-The documentation at lua.org,
-especially section 7 of the reference manual.
-.SH DIAGNOSTICS
-Error messages should be self explanatory.
-.SH AUTHORS
-R. Ierusalimschy,
-L. H. de Figueiredo,
-W. Celes
-.\" EOF
diff --git a/lua/lua-5.3.5/doc/lua.css b/lua/lua-5.3.5/doc/lua.css
deleted file mode 100644
index cbd0799..0000000
--- a/lua/lua-5.3.5/doc/lua.css
+++ /dev/null
@@ -1,161 +0,0 @@
-html {
-	background-color: #F8F8F8 ;
-}
-
-body {
-	background-color: #FFFFFF ;
-	color: #000000 ;
-	font-family: Helvetica, Arial, sans-serif ;
-	text-align: justify ;
-	line-height: 1.25 ;
-	margin: 16px auto ;
-	padding: 32px ;
-	border: solid #ccc 1px ;
-	border-radius: 20px ;
-	max-width: 70em ;
-	width: 90% ;
-}
-
-h1, h2, h3, h4 {
-	color: #000080 ;
-	font-family: Verdana, Geneva, sans-serif ;
-	font-weight: normal ;
-	font-style: normal ;
-	text-align: left ;
-}
-
-h1 {
-	font-size: 28pt ;
-}
-
-h1 img {
-	vertical-align: text-bottom ;
-}
-
-h2:before {
-	content: "\2756" ;
-	padding-right: 0.5em ;
-}
-
-a {
-	text-decoration: none ;
-}
-
-a:link {
-	color: #000080 ;
-}
-
-a:link:hover, a:visited:hover {
-	background-color: #D0D0FF ;
-	color: #000080 ;
-	border-radius: 4px ;
-}
-
-a:link:active, a:visited:active {
-	color: #FF0000 ;
-}
-
-div.menubar {
-	padding-bottom: 0.5em ;
-}
-
-p.menubar {
-	margin-left: 2.5em ;
-}
-
-.menubar a:hover  {
-	margin: -3px -3px -3px -3px ;
-	padding: 3px  3px  3px  3px ;
-	border-radius: 4px ;
-}
-
-:target {
-	background-color: #F0F0F0 ;
-	margin: -8px ;
-	padding: 8px ;
-	border-radius: 8px ;
-	outline: none ;
-}
-
-hr {
-	display: none ;
-}
-
-table hr {
-	background-color: #a0a0a0 ;
-	color: #a0a0a0 ;
-	border: 0 ;
-	height: 1px ;
-	display: block ;
-}
-
-.footer {
-	color: gray ;
-	font-size: x-small ;
-	text-transform: lowercase ;
-}
-
-input[type=text] {
-	border: solid #a0a0a0 2px ;
-	border-radius: 2em ;
-	background-image: url('images/search.png') ;
-	background-repeat: no-repeat ;
-	background-position: 4px center ;
-	padding-left: 20px ;
-	height: 2em ;
-}
-
-pre.session {
-	background-color: #F8F8F8 ;
-	padding: 1em ;
-	border-radius: 8px ;
-}
-
-table {
-	border: none ;
-	border-spacing: 0 ;
-	border-collapse: collapse ;
-}
-
-td {
-	padding: 0 ;
-	margin: 0 ;
-}
-
-td.gutter {
-	width: 4% ;
-}
-
-table.columns td {
-	vertical-align: top ;
-	padding-bottom: 1em ;
-	text-align: justify ;
-	line-height: 1.25 ;
-}
-
-table.book td {
-	vertical-align: top ;
-}
-
-table.book td.cover {
-	padding-right: 1em ;
-}
-
-table.book img {
-	border: solid #000080 1px ;
-}
-
-table.book span {
-	font-size: small ;
-	text-align: left ;
-	display: block ;
-	margin-top: 0.25em ;
-}
-
-p.logos a:link:hover, p.logos a:visited:hover {
-	background-color: inherit ;
-}
-
-img {
-	background-color: white ;
-}
diff --git a/lua/lua-5.3.5/doc/luac.1 b/lua/lua-5.3.5/doc/luac.1
deleted file mode 100644
index 33a4ed0..0000000
--- a/lua/lua-5.3.5/doc/luac.1
+++ /dev/null
@@ -1,118 +0,0 @@
-.\" $Id: luac.man,v 1.29 2011/11/16 13:53:40 lhf Exp $
-.TH LUAC 1 "$Date: 2011/11/16 13:53:40 $"
-.SH NAME
-luac \- Lua compiler
-.SH SYNOPSIS
-.B luac
-[
-.I options
-] [
-.I filenames
-]
-.SH DESCRIPTION
-.B luac
-is the Lua compiler.
-It translates programs written in the Lua programming language
-into binary files containing precompiled chunks
-that can be later loaded and executed.
-.LP
-The main advantages of precompiling chunks are:
-faster loading,
-protecting source code from accidental user changes,
-and
-off-line syntax checking.
-Precompiling does not imply faster execution
-because in Lua chunks are always compiled into bytecodes before being executed.
-.B luac
-simply allows those bytecodes to be saved in a file for later execution.
-Precompiled chunks are not necessarily smaller than the corresponding source.
-The main goal in precompiling is faster loading.
-.LP
-In the command line,
-you can mix
-text files containing Lua source and
-binary files containing precompiled chunks.
-.B luac
-produces a single output file containing the combined bytecodes
-for all files given.
-Executing the combined file is equivalent to executing the given files.
-By default,
-the output file is named
-.BR luac.out ,
-but you can change this with the
-.B \-o
-option.
-.LP
-Precompiled chunks are
-.I not
-portable across different architectures.
-Moreover,
-the internal format of precompiled chunks
-is likely to change when a new version of Lua is released.
-Make sure you save the source files of all Lua programs that you precompile.
-.LP
-.SH OPTIONS
-.TP
-.B \-l
-produce a listing of the compiled bytecode for Lua's virtual machine.
-Listing bytecodes is useful to learn about Lua's virtual machine.
-If no files are given, then
-.B luac
-loads
-.B luac.out
-and lists its contents.
-Use
-.B \-l \-l
-for a full listing.
-.TP
-.BI \-o " file"
-output to
-.IR file ,
-instead of the default
-.BR luac.out .
-(You can use
-.B "'\-'"
-for standard output,
-but not on platforms that open standard output in text mode.)
-The output file may be one of the given files because
-all files are loaded before the output file is written.
-Be careful not to overwrite precious files.
-.TP
-.B \-p
-load files but do not generate any output file.
-Used mainly for syntax checking and for testing precompiled chunks:
-corrupted files will probably generate errors when loaded.
-If no files are given, then
-.B luac
-loads
-.B luac.out
-and tests its contents.
-No messages are displayed if the file loads without errors.
-.TP
-.B \-s
-strip debug information before writing the output file.
-This saves some space in very large chunks,
-but if errors occur when running a stripped chunk,
-then the error messages may not contain the full information they usually do.
-In particular,
-line numbers and names of local variables are lost.
-.TP
-.B \-v
-show version information.
-.TP
-.B \-\-
-stop handling options.
-.TP
-.B \-
-stop handling options and process standard input.
-.SH "SEE ALSO"
-.BR lua (1)
-.br
-The documentation at lua.org.
-.SH DIAGNOSTICS
-Error messages should be self explanatory.
-.SH AUTHORS
-R. Ierusalimschy,
-L. H. de Figueiredo,
-W. Celes
-.\" EOF
diff --git a/lua/lua-5.3.5/doc/manual.css b/lua/lua-5.3.5/doc/manual.css
deleted file mode 100644
index aa0e677..0000000
--- a/lua/lua-5.3.5/doc/manual.css
+++ /dev/null
@@ -1,21 +0,0 @@
-h3 code {
-	font-family: inherit ;
-	font-size: inherit ;
-}
-
-pre, code {
-	font-size: 12pt ;
-}
-
-span.apii {
-	color: gray ;
-	float: right ;
-	font-family: inherit ;
-	font-style: normal ;
-	font-size: small ;
-}
-
-h2:before {
-	content: "" ;
-	padding-right: 0em ;
-}
diff --git a/lua/lua-5.3.5/doc/manual.html b/lua/lua-5.3.5/doc/manual.html
deleted file mode 100644
index 89a642a..0000000
--- a/lua/lua-5.3.5/doc/manual.html
+++ /dev/null
@@ -1,10982 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<HTML>
-<HEAD>
-<TITLE>Lua 5.3 Reference Manual</TITLE>
-<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
-<LINK REL="stylesheet" TYPE="text/css" HREF="manual.css">
-<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
-</HEAD>
-
-<BODY>
-
-<H1>
-<A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua"></A>
-Lua 5.3 Reference Manual
-</H1>
-
-<P>
-by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
-
-<P>
-<SMALL>
-Copyright &copy; 2015&ndash;2018 Lua.org, PUC-Rio.
-Freely available under the terms of the
-<a href="http://www.lua.org/license.html">Lua license</a>.
-</SMALL>
-
-<DIV CLASS="menubar">
-<A HREF="contents.html#contents">contents</A>
-&middot;
-<A HREF="contents.html#index">index</A>
-&middot;
-<A HREF="http://www.lua.org/manual/">other versions</A>
-</DIV>
-
-<!-- ====================================================================== -->
-<p>
-
-<!-- $Id: manual.of,v 1.167.1.2 2018/06/26 15:49:07 roberto Exp $ -->
-
-
-
-
-<h1>1 &ndash; <a name="1">Introduction</a></h1>
-
-<p>
-Lua is a powerful, efficient, lightweight, embeddable scripting language.
-It supports procedural programming,
-object-oriented programming, functional programming,
-data-driven programming, and data description.
-
-
-<p>
-Lua combines simple procedural syntax with powerful data description
-constructs based on associative arrays and extensible semantics.
-Lua is dynamically typed,
-runs by interpreting bytecode with a register-based
-virtual machine,
-and has automatic memory management with
-incremental garbage collection,
-making it ideal for configuration, scripting,
-and rapid prototyping.
-
-
-<p>
-Lua is implemented as a library, written in <em>clean C</em>,
-the common subset of Standard&nbsp;C and C++.
-The Lua distribution includes a host program called <code>lua</code>,
-which uses the Lua library to offer a complete,
-standalone Lua interpreter,
-for interactive or batch use.
-Lua is intended to be used both as a powerful, lightweight,
-embeddable scripting language for any program that needs one,
-and as a powerful but lightweight and efficient stand-alone language.
-
-
-<p>
-As an extension language, Lua has no notion of a "main" program:
-it works <em>embedded</em> in a host client,
-called the <em>embedding program</em> or simply the <em>host</em>.
-(Frequently, this host is the stand-alone <code>lua</code> program.)
-The host program can invoke functions to execute a piece of Lua code,
-can write and read Lua variables,
-and can register C&nbsp;functions to be called by Lua code.
-Through the use of C&nbsp;functions, Lua can be augmented to cope with
-a wide range of different domains,
-thus creating customized programming languages sharing a syntactical framework.
-
-
-<p>
-Lua is free software,
-and is provided as usual with no guarantees,
-as stated in its license.
-The implementation described in this manual is available
-at Lua's official web site, <code>www.lua.org</code>.
-
-
-<p>
-Like any other reference manual,
-this document is dry in places.
-For a discussion of the decisions behind the design of Lua,
-see the technical papers available at Lua's web site.
-For a detailed introduction to programming in Lua,
-see Roberto's book, <em>Programming in Lua</em>.
-
-
-
-<h1>2 &ndash; <a name="2">Basic Concepts</a></h1>
-
-<p>
-This section describes the basic concepts of the language.
-
-
-
-<h2>2.1 &ndash; <a name="2.1">Values and Types</a></h2>
-
-<p>
-Lua is a <em>dynamically typed language</em>.
-This means that
-variables do not have types; only values do.
-There are no type definitions in the language.
-All values carry their own type.
-
-
-<p>
-All values in Lua are <em>first-class values</em>.
-This means that all values can be stored in variables,
-passed as arguments to other functions, and returned as results.
-
-
-<p>
-There are eight basic types in Lua:
-<em>nil</em>, <em>boolean</em>, <em>number</em>,
-<em>string</em>, <em>function</em>, <em>userdata</em>,
-<em>thread</em>, and <em>table</em>.
-The type <em>nil</em> has one single value, <b>nil</b>,
-whose main property is to be different from any other value;
-it usually represents the absence of a useful value.
-The type <em>boolean</em> has two values, <b>false</b> and <b>true</b>.
-Both <b>nil</b> and <b>false</b> make a condition false;
-any other value makes it true.
-The type <em>number</em> represents both
-integer numbers and real (floating-point) numbers.
-The type <em>string</em> represents immutable sequences of bytes.
-
-Lua is 8-bit clean:
-strings can contain any 8-bit value,
-including embedded zeros ('<code>\0</code>').
-Lua is also encoding-agnostic;
-it makes no assumptions about the contents of a string.
-
-
-<p>
-The type <em>number</em> uses two internal representations,
-or two subtypes,
-one called <em>integer</em> and the other called <em>float</em>.
-Lua has explicit rules about when each representation is used,
-but it also converts between them automatically as needed (see <a href="#3.4.3">&sect;3.4.3</a>).
-Therefore,
-the programmer may choose to mostly ignore the difference
-between integers and floats
-or to assume complete control over the representation of each number.
-Standard Lua uses 64-bit integers and double-precision (64-bit) floats,
-but you can also compile Lua so that it
-uses 32-bit integers and/or single-precision (32-bit) floats.
-The option with 32 bits for both integers and floats
-is particularly attractive
-for small machines and embedded systems.
-(See macro <code>LUA_32BITS</code> in file <code>luaconf.h</code>.)
-
-
-<p>
-Lua can call (and manipulate) functions written in Lua and
-functions written in C (see <a href="#3.4.10">&sect;3.4.10</a>).
-Both are represented by the type <em>function</em>.
-
-
-<p>
-The type <em>userdata</em> is provided to allow arbitrary C&nbsp;data to
-be stored in Lua variables.
-A userdata value represents a block of raw memory.
-There are two kinds of userdata:
-<em>full userdata</em>,
-which is an object with a block of memory managed by Lua,
-and <em>light userdata</em>,
-which is simply a C&nbsp;pointer value.
-Userdata has no predefined operations in Lua,
-except assignment and identity test.
-By using <em>metatables</em>,
-the programmer can define operations for full userdata values
-(see <a href="#2.4">&sect;2.4</a>).
-Userdata values cannot be created or modified in Lua,
-only through the C&nbsp;API.
-This guarantees the integrity of data owned by the host program.
-
-
-<p>
-The type <em>thread</em> represents independent threads of execution
-and it is used to implement coroutines (see <a href="#2.6">&sect;2.6</a>).
-Lua threads are not related to operating-system threads.
-Lua supports coroutines on all systems,
-even those that do not support threads natively.
-
-
-<p>
-The type <em>table</em> implements associative arrays,
-that is, arrays that can have as indices not only numbers,
-but any Lua value except <b>nil</b> and NaN.
-(<em>Not a Number</em> is a special value used to represent
-undefined or unrepresentable numerical results, such as <code>0/0</code>.)
-Tables can be <em>heterogeneous</em>;
-that is, they can contain values of all types (except <b>nil</b>).
-Any key with value <b>nil</b> is not considered part of the table.
-Conversely, any key that is not part of a table has
-an associated value <b>nil</b>.
-
-
-<p>
-Tables are the sole data-structuring mechanism in Lua;
-they can be used to represent ordinary arrays, lists,
-symbol tables, sets, records, graphs, trees, etc.
-To represent records, Lua uses the field name as an index.
-The language supports this representation by
-providing <code>a.name</code> as syntactic sugar for <code>a["name"]</code>.
-There are several convenient ways to create tables in Lua
-(see <a href="#3.4.9">&sect;3.4.9</a>).
-
-
-<p>
-Like indices,
-the values of table fields can be of any type.
-In particular,
-because functions are first-class values,
-table fields can contain functions.
-Thus tables can also carry <em>methods</em> (see <a href="#3.4.11">&sect;3.4.11</a>).
-
-
-<p>
-The indexing of tables follows
-the definition of raw equality in the language.
-The expressions <code>a[i]</code> and <code>a[j]</code>
-denote the same table element
-if and only if <code>i</code> and <code>j</code> are raw equal
-(that is, equal without metamethods).
-In particular, floats with integral values
-are equal to their respective integers
-(e.g., <code>1.0 == 1</code>).
-To avoid ambiguities,
-any float with integral value used as a key
-is converted to its respective integer.
-For instance, if you write <code>a[2.0] = true</code>,
-the actual key inserted into the table will be the
-integer <code>2</code>.
-(On the other hand,
-2 and "<code>2</code>" are different Lua values and therefore
-denote different table entries.)
-
-
-<p>
-Tables, functions, threads, and (full) userdata values are <em>objects</em>:
-variables do not actually <em>contain</em> these values,
-only <em>references</em> to them.
-Assignment, parameter passing, and function returns
-always manipulate references to such values;
-these operations do not imply any kind of copy.
-
-
-<p>
-The library function <a href="#pdf-type"><code>type</code></a> returns a string describing the type
-of a given value (see <a href="#6.1">&sect;6.1</a>).
-
-
-
-
-
-<h2>2.2 &ndash; <a name="2.2">Environments and the Global Environment</a></h2>
-
-<p>
-As will be discussed in <a href="#3.2">&sect;3.2</a> and <a href="#3.3.3">&sect;3.3.3</a>,
-any reference to a free name
-(that is, a name not bound to any declaration) <code>var</code>
-is syntactically translated to <code>_ENV.var</code>.
-Moreover, every chunk is compiled in the scope of
-an external local variable named <code>_ENV</code> (see <a href="#3.3.2">&sect;3.3.2</a>),
-so <code>_ENV</code> itself is never a free name in a chunk.
-
-
-<p>
-Despite the existence of this external <code>_ENV</code> variable and
-the translation of free names,
-<code>_ENV</code> is a completely regular name.
-In particular,
-you can define new variables and parameters with that name.
-Each reference to a free name uses the <code>_ENV</code> that is
-visible at that point in the program,
-following the usual visibility rules of Lua (see <a href="#3.5">&sect;3.5</a>).
-
-
-<p>
-Any table used as the value of <code>_ENV</code> is called an <em>environment</em>.
-
-
-<p>
-Lua keeps a distinguished environment called the <em>global environment</em>.
-This value is kept at a special index in the C registry (see <a href="#4.5">&sect;4.5</a>).
-In Lua, the global variable <a href="#pdf-_G"><code>_G</code></a> is initialized with this same value.
-(<a href="#pdf-_G"><code>_G</code></a> is never used internally.)
-
-
-<p>
-When Lua loads a chunk,
-the default value for its <code>_ENV</code> upvalue
-is the global environment (see <a href="#pdf-load"><code>load</code></a>).
-Therefore, by default,
-free names in Lua code refer to entries in the global environment
-(and, therefore, they are also called <em>global variables</em>).
-Moreover, all standard libraries are loaded in the global environment
-and some functions there operate on that environment.
-You can use <a href="#pdf-load"><code>load</code></a> (or <a href="#pdf-loadfile"><code>loadfile</code></a>)
-to load a chunk with a different environment.
-(In C, you have to load the chunk and then change the value
-of its first upvalue.)
-
-
-
-
-
-<h2>2.3 &ndash; <a name="2.3">Error Handling</a></h2>
-
-<p>
-Because Lua is an embedded extension language,
-all Lua actions start from C&nbsp;code in the host program
-calling a function from the Lua library.
-(When you use Lua standalone,
-the <code>lua</code> application is the host program.)
-Whenever an error occurs during
-the compilation or execution of a Lua chunk,
-control returns to the host,
-which can take appropriate measures
-(such as printing an error message).
-
-
-<p>
-Lua code can explicitly generate an error by calling the
-<a href="#pdf-error"><code>error</code></a> function.
-If you need to catch errors in Lua,
-you can use <a href="#pdf-pcall"><code>pcall</code></a> or <a href="#pdf-xpcall"><code>xpcall</code></a>
-to call a given function in <em>protected mode</em>.
-
-
-<p>
-Whenever there is an error,
-an <em>error object</em> (also called an <em>error message</em>)
-is propagated with information about the error.
-Lua itself only generates errors whose error object is a string,
-but programs may generate errors with
-any value as the error object.
-It is up to the Lua program or its host to handle such error objects.
-
-
-<p>
-When you use <a href="#pdf-xpcall"><code>xpcall</code></a> or <a href="#lua_pcall"><code>lua_pcall</code></a>,
-you may give a <em>message handler</em>
-to be called in case of errors.
-This function is called with the original error object
-and returns a new error object.
-It is called before the error unwinds the stack,
-so that it can gather more information about the error,
-for instance by inspecting the stack and creating a stack traceback.
-This message handler is still protected by the protected call;
-so, an error inside the message handler
-will call the message handler again.
-If this loop goes on for too long,
-Lua breaks it and returns an appropriate message.
-(The message handler is called only for regular runtime errors.
-It is not called for memory-allocation errors
-nor for errors while running finalizers.)
-
-
-
-
-
-<h2>2.4 &ndash; <a name="2.4">Metatables and Metamethods</a></h2>
-
-<p>
-Every value in Lua can have a <em>metatable</em>.
-This <em>metatable</em> is an ordinary Lua table
-that defines the behavior of the original value
-under certain special operations.
-You can change several aspects of the behavior
-of operations over a value by setting specific fields in its metatable.
-For instance, when a non-numeric value is the operand of an addition,
-Lua checks for a function in the field "<code>__add</code>" of the value's metatable.
-If it finds one,
-Lua calls this function to perform the addition.
-
-
-<p>
-The key for each event in a metatable is a string
-with the event name prefixed by two underscores;
-the corresponding values are called <em>metamethods</em>.
-In the previous example, the key is "<code>__add</code>"
-and the metamethod is the function that performs the addition.
-Unless stated otherwise,
-metamethods should be function values.
-
-
-<p>
-You can query the metatable of any value
-using the <a href="#pdf-getmetatable"><code>getmetatable</code></a> function.
-Lua queries metamethods in metatables using a raw access (see <a href="#pdf-rawget"><code>rawget</code></a>).
-So, to retrieve the metamethod for event <code>ev</code> in object <code>o</code>,
-Lua does the equivalent to the following code:
-
-<pre>
-     rawget(getmetatable(<em>o</em>) or {}, "__<em>ev</em>")
-</pre>
-
-<p>
-You can replace the metatable of tables
-using the <a href="#pdf-setmetatable"><code>setmetatable</code></a> function.
-You cannot change the metatable of other types from Lua code
-(except by using the debug library (<a href="#6.10">&sect;6.10</a>));
-you should use the C&nbsp;API for that.
-
-
-<p>
-Tables and full userdata have individual metatables
-(although multiple tables and userdata can share their metatables).
-Values of all other types share one single metatable per type;
-that is, there is one single metatable for all numbers,
-one for all strings, etc.
-By default, a value has no metatable,
-but the string library sets a metatable for the string type (see <a href="#6.4">&sect;6.4</a>).
-
-
-<p>
-A metatable controls how an object behaves in
-arithmetic operations, bitwise operations,
-order comparisons, concatenation, length operation, calls, and indexing.
-A metatable also can define a function to be called
-when a userdata or a table is garbage collected (<a href="#2.5">&sect;2.5</a>).
-
-
-<p>
-For the unary operators (negation, length, and bitwise NOT),
-the metamethod is computed and called with a dummy second operand,
-equal to the first one.
-This extra operand is only to simplify Lua's internals
-(by making these operators behave like a binary operation)
-and may be removed in future versions.
-(For most uses this extra operand is irrelevant.)
-
-
-<p>
-A detailed list of events controlled by metatables is given next.
-Each operation is identified by its corresponding key.
-
-
-
-<ul>
-
-<li><b><code>__add</code>: </b>
-the addition (<code>+</code>) operation.
-If any operand for an addition is not a number
-(nor a string coercible to a number),
-Lua will try to call a metamethod.
-First, Lua will check the first operand (even if it is valid).
-If that operand does not define a metamethod for <code>__add</code>,
-then Lua will check the second operand.
-If Lua can find a metamethod,
-it calls the metamethod with the two operands as arguments,
-and the result of the call
-(adjusted to one value)
-is the result of the operation.
-Otherwise,
-it raises an error.
-</li>
-
-<li><b><code>__sub</code>: </b>
-the subtraction (<code>-</code>) operation.
-Behavior similar to the addition operation.
-</li>
-
-<li><b><code>__mul</code>: </b>
-the multiplication (<code>*</code>) operation.
-Behavior similar to the addition operation.
-</li>
-
-<li><b><code>__div</code>: </b>
-the division (<code>/</code>) operation.
-Behavior similar to the addition operation.
-</li>
-
-<li><b><code>__mod</code>: </b>
-the modulo (<code>%</code>) operation.
-Behavior similar to the addition operation.
-</li>
-
-<li><b><code>__pow</code>: </b>
-the exponentiation (<code>^</code>) operation.
-Behavior similar to the addition operation.
-</li>
-
-<li><b><code>__unm</code>: </b>
-the negation (unary <code>-</code>) operation.
-Behavior similar to the addition operation.
-</li>
-
-<li><b><code>__idiv</code>: </b>
-the floor division (<code>//</code>) operation.
-Behavior similar to the addition operation.
-</li>
-
-<li><b><code>__band</code>: </b>
-the bitwise AND (<code>&amp;</code>) operation.
-Behavior similar to the addition operation,
-except that Lua will try a metamethod
-if any operand is neither an integer
-nor a value coercible to an integer (see <a href="#3.4.3">&sect;3.4.3</a>).
-</li>
-
-<li><b><code>__bor</code>: </b>
-the bitwise OR (<code>|</code>) operation.
-Behavior similar to the bitwise AND operation.
-</li>
-
-<li><b><code>__bxor</code>: </b>
-the bitwise exclusive OR (binary <code>~</code>) operation.
-Behavior similar to the bitwise AND operation.
-</li>
-
-<li><b><code>__bnot</code>: </b>
-the bitwise NOT (unary <code>~</code>) operation.
-Behavior similar to the bitwise AND operation.
-</li>
-
-<li><b><code>__shl</code>: </b>
-the bitwise left shift (<code>&lt;&lt;</code>) operation.
-Behavior similar to the bitwise AND operation.
-</li>
-
-<li><b><code>__shr</code>: </b>
-the bitwise right shift (<code>&gt;&gt;</code>) operation.
-Behavior similar to the bitwise AND operation.
-</li>
-
-<li><b><code>__concat</code>: </b>
-the concatenation (<code>..</code>) operation.
-Behavior similar to the addition operation,
-except that Lua will try a metamethod
-if any operand is neither a string nor a number
-(which is always coercible to a string).
-</li>
-
-<li><b><code>__len</code>: </b>
-the length (<code>#</code>) operation.
-If the object is not a string,
-Lua will try its metamethod.
-If there is a metamethod,
-Lua calls it with the object as argument,
-and the result of the call
-(always adjusted to one value)
-is the result of the operation.
-If there is no metamethod but the object is a table,
-then Lua uses the table length operation (see <a href="#3.4.7">&sect;3.4.7</a>).
-Otherwise, Lua raises an error.
-</li>
-
-<li><b><code>__eq</code>: </b>
-the equal (<code>==</code>) operation.
-Behavior similar to the addition operation,
-except that Lua will try a metamethod only when the values
-being compared are either both tables or both full userdata
-and they are not primitively equal.
-The result of the call is always converted to a boolean.
-</li>
-
-<li><b><code>__lt</code>: </b>
-the less than (<code>&lt;</code>) operation.
-Behavior similar to the addition operation,
-except that Lua will try a metamethod only when the values
-being compared are neither both numbers nor both strings.
-The result of the call is always converted to a boolean.
-</li>
-
-<li><b><code>__le</code>: </b>
-the less equal (<code>&lt;=</code>) operation.
-Unlike other operations,
-the less-equal operation can use two different events.
-First, Lua looks for the <code>__le</code> metamethod in both operands,
-like in the less than operation.
-If it cannot find such a metamethod,
-then it will try the <code>__lt</code> metamethod,
-assuming that <code>a &lt;= b</code> is equivalent to <code>not (b &lt; a)</code>.
-As with the other comparison operators,
-the result is always a boolean.
-(This use of the <code>__lt</code> event can be removed in future versions;
-it is also slower than a real <code>__le</code> metamethod.)
-</li>
-
-<li><b><code>__index</code>: </b>
-The indexing access operation <code>table[key]</code>.
-This event happens when <code>table</code> is not a table or
-when <code>key</code> is not present in <code>table</code>.
-The metamethod is looked up in <code>table</code>.
-
-
-<p>
-Despite the name,
-the metamethod for this event can be either a function or a table.
-If it is a function,
-it is called with <code>table</code> and <code>key</code> as arguments,
-and the result of the call
-(adjusted to one value)
-is the result of the operation.
-If it is a table,
-the final result is the result of indexing this table with <code>key</code>.
-(This indexing is regular, not raw,
-and therefore can trigger another metamethod.)
-</li>
-
-<li><b><code>__newindex</code>: </b>
-The indexing assignment <code>table[key] = value</code>.
-Like the index event,
-this event happens when <code>table</code> is not a table or
-when <code>key</code> is not present in <code>table</code>.
-The metamethod is looked up in <code>table</code>.
-
-
-<p>
-Like with indexing,
-the metamethod for this event can be either a function or a table.
-If it is a function,
-it is called with <code>table</code>, <code>key</code>, and <code>value</code> as arguments.
-If it is a table,
-Lua does an indexing assignment to this table with the same key and value.
-(This assignment is regular, not raw,
-and therefore can trigger another metamethod.)
-
-
-<p>
-Whenever there is a <code>__newindex</code> metamethod,
-Lua does not perform the primitive assignment.
-(If necessary,
-the metamethod itself can call <a href="#pdf-rawset"><code>rawset</code></a>
-to do the assignment.)
-</li>
-
-<li><b><code>__call</code>: </b>
-The call operation <code>func(args)</code>.
-This event happens when Lua tries to call a non-function value
-(that is, <code>func</code> is not a function).
-The metamethod is looked up in <code>func</code>.
-If present,
-the metamethod is called with <code>func</code> as its first argument,
-followed by the arguments of the original call (<code>args</code>).
-All results of the call
-are the result of the operation.
-(This is the only metamethod that allows multiple results.)
-</li>
-
-</ul>
-
-<p>
-It is a good practice to add all needed metamethods to a table
-before setting it as a metatable of some object.
-In particular, the <code>__gc</code> metamethod works only when this order
-is followed (see <a href="#2.5.1">&sect;2.5.1</a>).
-
-
-<p>
-Because metatables are regular tables,
-they can contain arbitrary fields,
-not only the event names defined above.
-Some functions in the standard library
-(e.g., <a href="#pdf-tostring"><code>tostring</code></a>)
-use other fields in metatables for their own purposes.
-
-
-
-
-
-<h2>2.5 &ndash; <a name="2.5">Garbage Collection</a></h2>
-
-<p>
-Lua performs automatic memory management.
-This means that
-you do not have to worry about allocating memory for new objects
-or freeing it when the objects are no longer needed.
-Lua manages memory automatically by running
-a <em>garbage collector</em> to collect all <em>dead objects</em>
-(that is, objects that are no longer accessible from Lua).
-All memory used by Lua is subject to automatic management:
-strings, tables, userdata, functions, threads, internal structures, etc.
-
-
-<p>
-Lua implements an incremental mark-and-sweep collector.
-It uses two numbers to control its garbage-collection cycles:
-the <em>garbage-collector pause</em> and
-the <em>garbage-collector step multiplier</em>.
-Both use percentage points as units
-(e.g., a value of 100 means an internal value of 1).
-
-
-<p>
-The garbage-collector pause
-controls how long the collector waits before starting a new cycle.
-Larger values make the collector less aggressive.
-Values smaller than 100 mean the collector will not wait to
-start a new cycle.
-A value of 200 means that the collector waits for the total memory in use
-to double before starting a new cycle.
-
-
-<p>
-The garbage-collector step multiplier
-controls the relative speed of the collector relative to
-memory allocation.
-Larger values make the collector more aggressive but also increase
-the size of each incremental step.
-You should not use values smaller than 100,
-because they make the collector too slow and
-can result in the collector never finishing a cycle.
-The default is 200,
-which means that the collector runs at "twice"
-the speed of memory allocation.
-
-
-<p>
-If you set the step multiplier to a very large number
-(larger than 10% of the maximum number of
-bytes that the program may use),
-the collector behaves like a stop-the-world collector.
-If you then set the pause to 200,
-the collector behaves as in old Lua versions,
-doing a complete collection every time Lua doubles its
-memory usage.
-
-
-<p>
-You can change these numbers by calling <a href="#lua_gc"><code>lua_gc</code></a> in C
-or <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> in Lua.
-You can also use these functions to control
-the collector directly (e.g., stop and restart it).
-
-
-
-<h3>2.5.1 &ndash; <a name="2.5.1">Garbage-Collection Metamethods</a></h3>
-
-<p>
-You can set garbage-collector metamethods for tables
-and, using the C&nbsp;API,
-for full userdata (see <a href="#2.4">&sect;2.4</a>).
-These metamethods are also called <em>finalizers</em>.
-Finalizers allow you to coordinate Lua's garbage collection
-with external resource management
-(such as closing files, network or database connections,
-or freeing your own memory).
-
-
-<p>
-For an object (table or userdata) to be finalized when collected,
-you must <em>mark</em> it for finalization.
-
-You mark an object for finalization when you set its metatable
-and the metatable has a field indexed by the string "<code>__gc</code>".
-Note that if you set a metatable without a <code>__gc</code> field
-and later create that field in the metatable,
-the object will not be marked for finalization.
-
-
-<p>
-When a marked object becomes garbage,
-it is not collected immediately by the garbage collector.
-Instead, Lua puts it in a list.
-After the collection,
-Lua goes through that list.
-For each object in the list,
-it checks the object's <code>__gc</code> metamethod:
-If it is a function,
-Lua calls it with the object as its single argument;
-if the metamethod is not a function,
-Lua simply ignores it.
-
-
-<p>
-At the end of each garbage-collection cycle,
-the finalizers for objects are called in
-the reverse order that the objects were marked for finalization,
-among those collected in that cycle;
-that is, the first finalizer to be called is the one associated
-with the object marked last in the program.
-The execution of each finalizer may occur at any point during
-the execution of the regular code.
-
-
-<p>
-Because the object being collected must still be used by the finalizer,
-that object (and other objects accessible only through it)
-must be <em>resurrected</em> by Lua.
-Usually, this resurrection is transient,
-and the object memory is freed in the next garbage-collection cycle.
-However, if the finalizer stores the object in some global place
-(e.g., a global variable),
-then the resurrection is permanent.
-Moreover, if the finalizer marks a finalizing object for finalization again,
-its finalizer will be called again in the next cycle where the
-object is unreachable.
-In any case,
-the object memory is freed only in a GC cycle where
-the object is unreachable and not marked for finalization.
-
-
-<p>
-When you close a state (see <a href="#lua_close"><code>lua_close</code></a>),
-Lua calls the finalizers of all objects marked for finalization,
-following the reverse order that they were marked.
-If any finalizer marks objects for collection during that phase,
-these marks have no effect.
-
-
-
-
-
-<h3>2.5.2 &ndash; <a name="2.5.2">Weak Tables</a></h3>
-
-<p>
-A <em>weak table</em> is a table whose elements are
-<em>weak references</em>.
-A weak reference is ignored by the garbage collector.
-In other words,
-if the only references to an object are weak references,
-then the garbage collector will collect that object.
-
-
-<p>
-A weak table can have weak keys, weak values, or both.
-A table with weak values allows the collection of its values,
-but prevents the collection of its keys.
-A table with both weak keys and weak values allows the collection of
-both keys and values.
-In any case, if either the key or the value is collected,
-the whole pair is removed from the table.
-The weakness of a table is controlled by the
-<code>__mode</code> field of its metatable.
-If the <code>__mode</code> field is a string containing the character&nbsp;'<code>k</code>',
-the keys in the table are weak.
-If <code>__mode</code> contains '<code>v</code>',
-the values in the table are weak.
-
-
-<p>
-A table with weak keys and strong values
-is also called an <em>ephemeron table</em>.
-In an ephemeron table,
-a value is considered reachable only if its key is reachable.
-In particular,
-if the only reference to a key comes through its value,
-the pair is removed.
-
-
-<p>
-Any change in the weakness of a table may take effect only
-at the next collect cycle.
-In particular, if you change the weakness to a stronger mode,
-Lua may still collect some items from that table
-before the change takes effect.
-
-
-<p>
-Only objects that have an explicit construction
-are removed from weak tables.
-Values, such as numbers and light C&nbsp;functions,
-are not subject to garbage collection,
-and therefore are not removed from weak tables
-(unless their associated values are collected).
-Although strings are subject to garbage collection,
-they do not have an explicit construction,
-and therefore are not removed from weak tables.
-
-
-<p>
-Resurrected objects
-(that is, objects being finalized
-and objects accessible only through objects being finalized)
-have a special behavior in weak tables.
-They are removed from weak values before running their finalizers,
-but are removed from weak keys only in the next collection
-after running their finalizers, when such objects are actually freed.
-This behavior allows the finalizer to access properties
-associated with the object through weak tables.
-
-
-<p>
-If a weak table is among the resurrected objects in a collection cycle,
-it may not be properly cleared until the next cycle.
-
-
-
-
-
-
-
-<h2>2.6 &ndash; <a name="2.6">Coroutines</a></h2>
-
-<p>
-Lua supports coroutines,
-also called <em>collaborative multithreading</em>.
-A coroutine in Lua represents an independent thread of execution.
-Unlike threads in multithread systems, however,
-a coroutine only suspends its execution by explicitly calling
-a yield function.
-
-
-<p>
-You create a coroutine by calling <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>.
-Its sole argument is a function
-that is the main function of the coroutine.
-The <code>create</code> function only creates a new coroutine and
-returns a handle to it (an object of type <em>thread</em>);
-it does not start the coroutine.
-
-
-<p>
-You execute a coroutine by calling <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
-When you first call <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
-passing as its first argument
-a thread returned by <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>,
-the coroutine starts its execution by
-calling its main function.
-Extra arguments passed to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> are passed
-as arguments to that function.
-After the coroutine starts running,
-it runs until it terminates or <em>yields</em>.
-
-
-<p>
-A coroutine can terminate its execution in two ways:
-normally, when its main function returns
-(explicitly or implicitly, after the last instruction);
-and abnormally, if there is an unprotected error.
-In case of normal termination,
-<a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>true</b>,
-plus any values returned by the coroutine main function.
-In case of errors, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>false</b>
-plus an error object.
-
-
-<p>
-A coroutine yields by calling <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a>.
-When a coroutine yields,
-the corresponding <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns immediately,
-even if the yield happens inside nested function calls
-(that is, not in the main function,
-but in a function directly or indirectly called by the main function).
-In the case of a yield, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> also returns <b>true</b>,
-plus any values passed to <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a>.
-The next time you resume the same coroutine,
-it continues its execution from the point where it yielded,
-with the call to <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a> returning any extra
-arguments passed to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
-
-
-<p>
-Like <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>,
-the <a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> function also creates a coroutine,
-but instead of returning the coroutine itself,
-it returns a function that, when called, resumes the coroutine.
-Any arguments passed to this function
-go as extra arguments to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
-<a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> returns all the values returned by <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
-except the first one (the boolean error code).
-Unlike <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
-<a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> does not catch errors;
-any error is propagated to the caller.
-
-
-<p>
-As an example of how coroutines work,
-consider the following code:
-
-<pre>
-     function foo (a)
-       print("foo", a)
-       return coroutine.yield(2*a)
-     end
-     
-     co = coroutine.create(function (a,b)
-           print("co-body", a, b)
-           local r = foo(a+1)
-           print("co-body", r)
-           local r, s = coroutine.yield(a+b, a-b)
-           print("co-body", r, s)
-           return b, "end"
-     end)
-     
-     print("main", coroutine.resume(co, 1, 10))
-     print("main", coroutine.resume(co, "r"))
-     print("main", coroutine.resume(co, "x", "y"))
-     print("main", coroutine.resume(co, "x", "y"))
-</pre><p>
-When you run it, it produces the following output:
-
-<pre>
-     co-body 1       10
-     foo     2
-     main    true    4
-     co-body r
-     main    true    11      -9
-     co-body x       y
-     main    true    10      end
-     main    false   cannot resume dead coroutine
-</pre>
-
-<p>
-You can also create and manipulate coroutines through the C API:
-see functions <a href="#lua_newthread"><code>lua_newthread</code></a>, <a href="#lua_resume"><code>lua_resume</code></a>,
-and <a href="#lua_yield"><code>lua_yield</code></a>.
-
-
-
-
-
-<h1>3 &ndash; <a name="3">The Language</a></h1>
-
-<p>
-This section describes the lexis, the syntax, and the semantics of Lua.
-In other words,
-this section describes
-which tokens are valid,
-how they can be combined,
-and what their combinations mean.
-
-
-<p>
-Language constructs will be explained using the usual extended BNF notation,
-in which
-{<em>a</em>}&nbsp;means&nbsp;0 or more <em>a</em>'s, and
-[<em>a</em>]&nbsp;means an optional <em>a</em>.
-Non-terminals are shown like non-terminal,
-keywords are shown like <b>kword</b>,
-and other terminal symbols are shown like &lsquo;<b>=</b>&rsquo;.
-The complete syntax of Lua can be found in <a href="#9">&sect;9</a>
-at the end of this manual.
-
-
-
-<h2>3.1 &ndash; <a name="3.1">Lexical Conventions</a></h2>
-
-<p>
-Lua is a free-form language.
-It ignores spaces (including new lines) and comments
-between lexical elements (tokens),
-except as delimiters between names and keywords.
-
-
-<p>
-<em>Names</em>
-(also called <em>identifiers</em>)
-in Lua can be any string of letters,
-digits, and underscores,
-not beginning with a digit and
-not being a reserved word.
-Identifiers are used to name variables, table fields, and labels.
-
-
-<p>
-The following <em>keywords</em> are reserved
-and cannot be used as names:
-
-
-<pre>
-     and       break     do        else      elseif    end
-     false     for       function  goto      if        in
-     local     nil       not       or        repeat    return
-     then      true      until     while
-</pre>
-
-<p>
-Lua is a case-sensitive language:
-<code>and</code> is a reserved word, but <code>And</code> and <code>AND</code>
-are two different, valid names.
-As a convention,
-programs should avoid creating
-names that start with an underscore followed by
-one or more uppercase letters (such as <a href="#pdf-_VERSION"><code>_VERSION</code></a>).
-
-
-<p>
-The following strings denote other tokens:
-
-<pre>
-     +     -     *     /     %     ^     #
-     &amp;     ~     |     &lt;&lt;    &gt;&gt;    //
-     ==    ~=    &lt;=    &gt;=    &lt;     &gt;     =
-     (     )     {     }     [     ]     ::
-     ;     :     ,     .     ..    ...
-</pre>
-
-<p>
-A <em>short literal string</em>
-can be delimited by matching single or double quotes,
-and can contain the following C-like escape sequences:
-'<code>\a</code>' (bell),
-'<code>\b</code>' (backspace),
-'<code>\f</code>' (form feed),
-'<code>\n</code>' (newline),
-'<code>\r</code>' (carriage return),
-'<code>\t</code>' (horizontal tab),
-'<code>\v</code>' (vertical tab),
-'<code>\\</code>' (backslash),
-'<code>\"</code>' (quotation mark [double quote]),
-and '<code>\'</code>' (apostrophe [single quote]).
-A backslash followed by a line break
-results in a newline in the string.
-The escape sequence '<code>\z</code>' skips the following span
-of white-space characters,
-including line breaks;
-it is particularly useful to break and indent a long literal string
-into multiple lines without adding the newlines and spaces
-into the string contents.
-A short literal string cannot contain unescaped line breaks
-nor escapes not forming a valid escape sequence.
-
-
-<p>
-We can specify any byte in a short literal string by its numeric value
-(including embedded zeros).
-This can be done
-with the escape sequence <code>\x<em>XX</em></code>,
-where <em>XX</em> is a sequence of exactly two hexadecimal digits,
-or with the escape sequence <code>\<em>ddd</em></code>,
-where <em>ddd</em> is a sequence of up to three decimal digits.
-(Note that if a decimal escape sequence is to be followed by a digit,
-it must be expressed using exactly three digits.)
-
-
-<p>
-The UTF-8 encoding of a Unicode character
-can be inserted in a literal string with
-the escape sequence <code>\u{<em>XXX</em>}</code>
-(note the mandatory enclosing brackets),
-where <em>XXX</em> is a sequence of one or more hexadecimal digits
-representing the character code point.
-
-
-<p>
-Literal strings can also be defined using a long format
-enclosed by <em>long brackets</em>.
-We define an <em>opening long bracket of level <em>n</em></em> as an opening
-square bracket followed by <em>n</em> equal signs followed by another
-opening square bracket.
-So, an opening long bracket of level&nbsp;0 is written as <code>[[</code>, 
-an opening long bracket of level&nbsp;1 is written as <code>[=[</code>, 
-and so on.
-A <em>closing long bracket</em> is defined similarly;
-for instance,
-a closing long bracket of level&nbsp;4 is written as  <code>]====]</code>.
-A <em>long literal</em> starts with an opening long bracket of any level and
-ends at the first closing long bracket of the same level.
-It can contain any text except a closing bracket of the same level.
-Literals in this bracketed form can run for several lines,
-do not interpret any escape sequences,
-and ignore long brackets of any other level.
-Any kind of end-of-line sequence
-(carriage return, newline, carriage return followed by newline,
-or newline followed by carriage return)
-is converted to a simple newline.
-
-
-<p>
-For convenience,
-when the opening long bracket is immediately followed by a newline,
-the newline is not included in the string.
-As an example, in a system using ASCII
-(in which '<code>a</code>' is coded as&nbsp;97,
-newline is coded as&nbsp;10, and '<code>1</code>' is coded as&nbsp;49),
-the five literal strings below denote the same string:
-
-<pre>
-     a = 'alo\n123"'
-     a = "alo\n123\""
-     a = '\97lo\10\04923"'
-     a = [[alo
-     123"]]
-     a = [==[
-     alo
-     123"]==]
-</pre>
-
-<p>
-Any byte in a literal string not
-explicitly affected by the previous rules represents itself.
-However, Lua opens files for parsing in text mode,
-and the system file functions may have problems with
-some control characters.
-So, it is safer to represent
-non-text data as a quoted literal with
-explicit escape sequences for the non-text characters.
-
-
-<p>
-A <em>numeric constant</em> (or <em>numeral</em>)
-can be written with an optional fractional part
-and an optional decimal exponent,
-marked by a letter '<code>e</code>' or '<code>E</code>'.
-Lua also accepts hexadecimal constants,
-which start with <code>0x</code> or <code>0X</code>.
-Hexadecimal constants also accept an optional fractional part
-plus an optional binary exponent,
-marked by a letter '<code>p</code>' or '<code>P</code>'.
-A numeric constant with a radix point or an exponent
-denotes a float;
-otherwise,
-if its value fits in an integer,
-it denotes an integer.
-Examples of valid integer constants are
-
-<pre>
-     3   345   0xff   0xBEBADA
-</pre><p>
-Examples of valid float constants are
-
-<pre>
-     3.0     3.1416     314.16e-2     0.31416E1     34e1
-     0x0.1E  0xA23p-4   0X1.921FB54442D18P+1
-</pre>
-
-<p>
-A <em>comment</em> starts with a double hyphen (<code>--</code>)
-anywhere outside a string.
-If the text immediately after <code>--</code> is not an opening long bracket,
-the comment is a <em>short comment</em>,
-which runs until the end of the line.
-Otherwise, it is a <em>long comment</em>,
-which runs until the corresponding closing long bracket.
-Long comments are frequently used to disable code temporarily.
-
-
-
-
-
-<h2>3.2 &ndash; <a name="3.2">Variables</a></h2>
-
-<p>
-Variables are places that store values.
-There are three kinds of variables in Lua:
-global variables, local variables, and table fields.
-
-
-<p>
-A single name can denote a global variable or a local variable
-(or a function's formal parameter,
-which is a particular kind of local variable):
-
-<pre>
-	var ::= Name
-</pre><p>
-Name denotes identifiers, as defined in <a href="#3.1">&sect;3.1</a>.
-
-
-<p>
-Any variable name is assumed to be global unless explicitly declared
-as a local (see <a href="#3.3.7">&sect;3.3.7</a>).
-Local variables are <em>lexically scoped</em>:
-local variables can be freely accessed by functions
-defined inside their scope (see <a href="#3.5">&sect;3.5</a>).
-
-
-<p>
-Before the first assignment to a variable, its value is <b>nil</b>.
-
-
-<p>
-Square brackets are used to index a table:
-
-<pre>
-	var ::= prefixexp &lsquo;<b>[</b>&rsquo; exp &lsquo;<b>]</b>&rsquo;
-</pre><p>
-The meaning of accesses to table fields can be changed via metatables
-(see <a href="#2.4">&sect;2.4</a>).
-
-
-<p>
-The syntax <code>var.Name</code> is just syntactic sugar for
-<code>var["Name"]</code>:
-
-<pre>
-	var ::= prefixexp &lsquo;<b>.</b>&rsquo; Name
-</pre>
-
-<p>
-An access to a global variable <code>x</code>
-is equivalent to <code>_ENV.x</code>.
-Due to the way that chunks are compiled,
-<code>_ENV</code> is never a global name (see <a href="#2.2">&sect;2.2</a>).
-
-
-
-
-
-<h2>3.3 &ndash; <a name="3.3">Statements</a></h2>
-
-<p>
-Lua supports an almost conventional set of statements,
-similar to those in Pascal or C.
-This set includes
-assignments, control structures, function calls,
-and variable declarations.
-
-
-
-<h3>3.3.1 &ndash; <a name="3.3.1">Blocks</a></h3>
-
-<p>
-A block is a list of statements,
-which are executed sequentially:
-
-<pre>
-	block ::= {stat}
-</pre><p>
-Lua has <em>empty statements</em>
-that allow you to separate statements with semicolons,
-start a block with a semicolon
-or write two semicolons in sequence:
-
-<pre>
-	stat ::= &lsquo;<b>;</b>&rsquo;
-</pre>
-
-<p>
-Function calls and assignments
-can start with an open parenthesis.
-This possibility leads to an ambiguity in Lua's grammar.
-Consider the following fragment:
-
-<pre>
-     a = b + c
-     (print or io.write)('done')
-</pre><p>
-The grammar could see it in two ways:
-
-<pre>
-     a = b + c(print or io.write)('done')
-     
-     a = b + c; (print or io.write)('done')
-</pre><p>
-The current parser always sees such constructions
-in the first way,
-interpreting the open parenthesis
-as the start of the arguments to a call.
-To avoid this ambiguity,
-it is a good practice to always precede with a semicolon
-statements that start with a parenthesis:
-
-<pre>
-     ;(print or io.write)('done')
-</pre>
-
-<p>
-A block can be explicitly delimited to produce a single statement:
-
-<pre>
-	stat ::= <b>do</b> block <b>end</b>
-</pre><p>
-Explicit blocks are useful
-to control the scope of variable declarations.
-Explicit blocks are also sometimes used to
-add a <b>return</b> statement in the middle
-of another block (see <a href="#3.3.4">&sect;3.3.4</a>).
-
-
-
-
-
-<h3>3.3.2 &ndash; <a name="3.3.2">Chunks</a></h3>
-
-<p>
-The unit of compilation of Lua is called a <em>chunk</em>.
-Syntactically,
-a chunk is simply a block:
-
-<pre>
-	chunk ::= block
-</pre>
-
-<p>
-Lua handles a chunk as the body of an anonymous function
-with a variable number of arguments
-(see <a href="#3.4.11">&sect;3.4.11</a>).
-As such, chunks can define local variables,
-receive arguments, and return values.
-Moreover, such anonymous function is compiled as in the
-scope of an external local variable called <code>_ENV</code> (see <a href="#2.2">&sect;2.2</a>).
-The resulting function always has <code>_ENV</code> as its only upvalue,
-even if it does not use that variable.
-
-
-<p>
-A chunk can be stored in a file or in a string inside the host program.
-To execute a chunk,
-Lua first <em>loads</em> it,
-precompiling the chunk's code into instructions for a virtual machine,
-and then Lua executes the compiled code
-with an interpreter for the virtual machine.
-
-
-<p>
-Chunks can also be precompiled into binary form;
-see program <code>luac</code> and function <a href="#pdf-string.dump"><code>string.dump</code></a> for details.
-Programs in source and compiled forms are interchangeable;
-Lua automatically detects the file type and acts accordingly (see <a href="#pdf-load"><code>load</code></a>).
-
-
-
-
-
-<h3>3.3.3 &ndash; <a name="3.3.3">Assignment</a></h3>
-
-<p>
-Lua allows multiple assignments.
-Therefore, the syntax for assignment
-defines a list of variables on the left side
-and a list of expressions on the right side.
-The elements in both lists are separated by commas:
-
-<pre>
-	stat ::= varlist &lsquo;<b>=</b>&rsquo; explist
-	varlist ::= var {&lsquo;<b>,</b>&rsquo; var}
-	explist ::= exp {&lsquo;<b>,</b>&rsquo; exp}
-</pre><p>
-Expressions are discussed in <a href="#3.4">&sect;3.4</a>.
-
-
-<p>
-Before the assignment,
-the list of values is <em>adjusted</em> to the length of
-the list of variables.
-If there are more values than needed,
-the excess values are thrown away.
-If there are fewer values than needed,
-the list is extended with as many  <b>nil</b>'s as needed.
-If the list of expressions ends with a function call,
-then all values returned by that call enter the list of values,
-before the adjustment
-(except when the call is enclosed in parentheses; see <a href="#3.4">&sect;3.4</a>).
-
-
-<p>
-The assignment statement first evaluates all its expressions
-and only then the assignments are performed.
-Thus the code
-
-<pre>
-     i = 3
-     i, a[i] = i+1, 20
-</pre><p>
-sets <code>a[3]</code> to 20, without affecting <code>a[4]</code>
-because the <code>i</code> in <code>a[i]</code> is evaluated (to 3)
-before it is assigned&nbsp;4.
-Similarly, the line
-
-<pre>
-     x, y = y, x
-</pre><p>
-exchanges the values of <code>x</code> and <code>y</code>,
-and
-
-<pre>
-     x, y, z = y, z, x
-</pre><p>
-cyclically permutes the values of <code>x</code>, <code>y</code>, and <code>z</code>.
-
-
-<p>
-An assignment to a global name <code>x = val</code>
-is equivalent to the assignment
-<code>_ENV.x = val</code> (see <a href="#2.2">&sect;2.2</a>).
-
-
-<p>
-The meaning of assignments to table fields and
-global variables (which are actually table fields, too)
-can be changed via metatables (see <a href="#2.4">&sect;2.4</a>).
-
-
-
-
-
-<h3>3.3.4 &ndash; <a name="3.3.4">Control Structures</a></h3><p>
-The control structures
-<b>if</b>, <b>while</b>, and <b>repeat</b> have the usual meaning and
-familiar syntax:
-
-
-
-
-<pre>
-	stat ::= <b>while</b> exp <b>do</b> block <b>end</b>
-	stat ::= <b>repeat</b> block <b>until</b> exp
-	stat ::= <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b>
-</pre><p>
-Lua also has a <b>for</b> statement, in two flavors (see <a href="#3.3.5">&sect;3.3.5</a>).
-
-
-<p>
-The condition expression of a
-control structure can return any value.
-Both <b>false</b> and <b>nil</b> are considered false.
-All values different from <b>nil</b> and <b>false</b> are considered true
-(in particular, the number 0 and the empty string are also true).
-
-
-<p>
-In the <b>repeat</b>&ndash;<b>until</b> loop,
-the inner block does not end at the <b>until</b> keyword,
-but only after the condition.
-So, the condition can refer to local variables
-declared inside the loop block.
-
-
-<p>
-The <b>goto</b> statement transfers the program control to a label.
-For syntactical reasons,
-labels in Lua are considered statements too:
-
-
-
-<pre>
-	stat ::= <b>goto</b> Name
-	stat ::= label
-	label ::= &lsquo;<b>::</b>&rsquo; Name &lsquo;<b>::</b>&rsquo;
-</pre>
-
-<p>
-A label is visible in the entire block where it is defined,
-except
-inside nested blocks where a label with the same name is defined and
-inside nested functions.
-A goto may jump to any visible label as long as it does not
-enter into the scope of a local variable.
-
-
-<p>
-Labels and empty statements are called <em>void statements</em>,
-as they perform no actions.
-
-
-<p>
-The <b>break</b> statement terminates the execution of a
-<b>while</b>, <b>repeat</b>, or <b>for</b> loop,
-skipping to the next statement after the loop:
-
-
-<pre>
-	stat ::= <b>break</b>
-</pre><p>
-A <b>break</b> ends the innermost enclosing loop.
-
-
-<p>
-The <b>return</b> statement is used to return values
-from a function or a chunk
-(which is an anonymous function).
-
-Functions can return more than one value,
-so the syntax for the <b>return</b> statement is
-
-<pre>
-	stat ::= <b>return</b> [explist] [&lsquo;<b>;</b>&rsquo;]
-</pre>
-
-<p>
-The <b>return</b> statement can only be written
-as the last statement of a block.
-If it is really necessary to <b>return</b> in the middle of a block,
-then an explicit inner block can be used,
-as in the idiom <code>do return end</code>,
-because now <b>return</b> is the last statement in its (inner) block.
-
-
-
-
-
-<h3>3.3.5 &ndash; <a name="3.3.5">For Statement</a></h3>
-
-<p>
-
-The <b>for</b> statement has two forms:
-one numerical and one generic.
-
-
-<p>
-The numerical <b>for</b> loop repeats a block of code while a
-control variable runs through an arithmetic progression.
-It has the following syntax:
-
-<pre>
-	stat ::= <b>for</b> Name &lsquo;<b>=</b>&rsquo; exp &lsquo;<b>,</b>&rsquo; exp [&lsquo;<b>,</b>&rsquo; exp] <b>do</b> block <b>end</b>
-</pre><p>
-The <em>block</em> is repeated for <em>name</em> starting at the value of
-the first <em>exp</em>, until it passes the second <em>exp</em> by steps of the
-third <em>exp</em>.
-More precisely, a <b>for</b> statement like
-
-<pre>
-     for v = <em>e1</em>, <em>e2</em>, <em>e3</em> do <em>block</em> end
-</pre><p>
-is equivalent to the code:
-
-<pre>
-     do
-       local <em>var</em>, <em>limit</em>, <em>step</em> = tonumber(<em>e1</em>), tonumber(<em>e2</em>), tonumber(<em>e3</em>)
-       if not (<em>var</em> and <em>limit</em> and <em>step</em>) then error() end
-       <em>var</em> = <em>var</em> - <em>step</em>
-       while true do
-         <em>var</em> = <em>var</em> + <em>step</em>
-         if (<em>step</em> &gt;= 0 and <em>var</em> &gt; <em>limit</em>) or (<em>step</em> &lt; 0 and <em>var</em> &lt; <em>limit</em>) then
-           break
-         end
-         local v = <em>var</em>
-         <em>block</em>
-       end
-     end
-</pre>
-
-<p>
-Note the following:
-
-<ul>
-
-<li>
-All three control expressions are evaluated only once,
-before the loop starts.
-They must all result in numbers.
-</li>
-
-<li>
-<code><em>var</em></code>, <code><em>limit</em></code>, and <code><em>step</em></code> are invisible variables.
-The names shown here are for explanatory purposes only.
-</li>
-
-<li>
-If the third expression (the step) is absent,
-then a step of&nbsp;1 is used.
-</li>
-
-<li>
-You can use <b>break</b> and <b>goto</b> to exit a <b>for</b> loop.
-</li>
-
-<li>
-The loop variable <code>v</code> is local to the loop body.
-If you need its value after the loop,
-assign it to another variable before exiting the loop.
-</li>
-
-</ul>
-
-<p>
-The generic <b>for</b> statement works over functions,
-called <em>iterators</em>.
-On each iteration, the iterator function is called to produce a new value,
-stopping when this new value is <b>nil</b>.
-The generic <b>for</b> loop has the following syntax:
-
-<pre>
-	stat ::= <b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b>
-	namelist ::= Name {&lsquo;<b>,</b>&rsquo; Name}
-</pre><p>
-A <b>for</b> statement like
-
-<pre>
-     for <em>var_1</em>, &middot;&middot;&middot;, <em>var_n</em> in <em>explist</em> do <em>block</em> end
-</pre><p>
-is equivalent to the code:
-
-<pre>
-     do
-       local <em>f</em>, <em>s</em>, <em>var</em> = <em>explist</em>
-       while true do
-         local <em>var_1</em>, &middot;&middot;&middot;, <em>var_n</em> = <em>f</em>(<em>s</em>, <em>var</em>)
-         if <em>var_1</em> == nil then break end
-         <em>var</em> = <em>var_1</em>
-         <em>block</em>
-       end
-     end
-</pre><p>
-Note the following:
-
-<ul>
-
-<li>
-<code><em>explist</em></code> is evaluated only once.
-Its results are an <em>iterator</em> function,
-a <em>state</em>,
-and an initial value for the first <em>iterator variable</em>.
-</li>
-
-<li>
-<code><em>f</em></code>, <code><em>s</em></code>, and <code><em>var</em></code> are invisible variables.
-The names are here for explanatory purposes only.
-</li>
-
-<li>
-You can use <b>break</b> to exit a <b>for</b> loop.
-</li>
-
-<li>
-The loop variables <code><em>var_i</em></code> are local to the loop;
-you cannot use their values after the <b>for</b> ends.
-If you need these values,
-then assign them to other variables before breaking or exiting the loop.
-</li>
-
-</ul>
-
-
-
-
-<h3>3.3.6 &ndash; <a name="3.3.6">Function Calls as Statements</a></h3><p>
-To allow possible side-effects,
-function calls can be executed as statements:
-
-<pre>
-	stat ::= functioncall
-</pre><p>
-In this case, all returned values are thrown away.
-Function calls are explained in <a href="#3.4.10">&sect;3.4.10</a>.
-
-
-
-
-
-<h3>3.3.7 &ndash; <a name="3.3.7">Local Declarations</a></h3><p>
-Local variables can be declared anywhere inside a block.
-The declaration can include an initial assignment:
-
-<pre>
-	stat ::= <b>local</b> namelist [&lsquo;<b>=</b>&rsquo; explist]
-</pre><p>
-If present, an initial assignment has the same semantics
-of a multiple assignment (see <a href="#3.3.3">&sect;3.3.3</a>).
-Otherwise, all variables are initialized with <b>nil</b>.
-
-
-<p>
-A chunk is also a block (see <a href="#3.3.2">&sect;3.3.2</a>),
-and so local variables can be declared in a chunk outside any explicit block.
-
-
-<p>
-The visibility rules for local variables are explained in <a href="#3.5">&sect;3.5</a>.
-
-
-
-
-
-
-
-<h2>3.4 &ndash; <a name="3.4">Expressions</a></h2>
-
-<p>
-The basic expressions in Lua are the following:
-
-<pre>
-	exp ::= prefixexp
-	exp ::= <b>nil</b> | <b>false</b> | <b>true</b>
-	exp ::= Numeral
-	exp ::= LiteralString
-	exp ::= functiondef
-	exp ::= tableconstructor
-	exp ::= &lsquo;<b>...</b>&rsquo;
-	exp ::= exp binop exp
-	exp ::= unop exp
-	prefixexp ::= var | functioncall | &lsquo;<b>(</b>&rsquo; exp &lsquo;<b>)</b>&rsquo;
-</pre>
-
-<p>
-Numerals and literal strings are explained in <a href="#3.1">&sect;3.1</a>;
-variables are explained in <a href="#3.2">&sect;3.2</a>;
-function definitions are explained in <a href="#3.4.11">&sect;3.4.11</a>;
-function calls are explained in <a href="#3.4.10">&sect;3.4.10</a>;
-table constructors are explained in <a href="#3.4.9">&sect;3.4.9</a>.
-Vararg expressions,
-denoted by three dots ('<code>...</code>'), can only be used when
-directly inside a vararg function;
-they are explained in <a href="#3.4.11">&sect;3.4.11</a>.
-
-
-<p>
-Binary operators comprise arithmetic operators (see <a href="#3.4.1">&sect;3.4.1</a>),
-bitwise operators (see <a href="#3.4.2">&sect;3.4.2</a>),
-relational operators (see <a href="#3.4.4">&sect;3.4.4</a>), logical operators (see <a href="#3.4.5">&sect;3.4.5</a>),
-and the concatenation operator (see <a href="#3.4.6">&sect;3.4.6</a>).
-Unary operators comprise the unary minus (see <a href="#3.4.1">&sect;3.4.1</a>),
-the unary bitwise NOT (see <a href="#3.4.2">&sect;3.4.2</a>),
-the unary logical <b>not</b> (see <a href="#3.4.5">&sect;3.4.5</a>),
-and the unary <em>length operator</em> (see <a href="#3.4.7">&sect;3.4.7</a>).
-
-
-<p>
-Both function calls and vararg expressions can result in multiple values.
-If a function call is used as a statement (see <a href="#3.3.6">&sect;3.3.6</a>),
-then its return list is adjusted to zero elements,
-thus discarding all returned values.
-If an expression is used as the last (or the only) element
-of a list of expressions,
-then no adjustment is made
-(unless the expression is enclosed in parentheses).
-In all other contexts,
-Lua adjusts the result list to one element,
-either discarding all values except the first one
-or adding a single <b>nil</b> if there are no values.
-
-
-<p>
-Here are some examples:
-
-<pre>
-     f()                -- adjusted to 0 results
-     g(f(), x)          -- f() is adjusted to 1 result
-     g(x, f())          -- g gets x plus all results from f()
-     a,b,c = f(), x     -- f() is adjusted to 1 result (c gets nil)
-     a,b = ...          -- a gets the first vararg argument, b gets
-                        -- the second (both a and b can get nil if there
-                        -- is no corresponding vararg argument)
-     
-     a,b,c = x, f()     -- f() is adjusted to 2 results
-     a,b,c = f()        -- f() is adjusted to 3 results
-     return f()         -- returns all results from f()
-     return ...         -- returns all received vararg arguments
-     return x,y,f()     -- returns x, y, and all results from f()
-     {f()}              -- creates a list with all results from f()
-     {...}              -- creates a list with all vararg arguments
-     {f(), nil}         -- f() is adjusted to 1 result
-</pre>
-
-<p>
-Any expression enclosed in parentheses always results in only one value.
-Thus,
-<code>(f(x,y,z))</code> is always a single value,
-even if <code>f</code> returns several values.
-(The value of <code>(f(x,y,z))</code> is the first value returned by <code>f</code>
-or <b>nil</b> if <code>f</code> does not return any values.)
-
-
-
-<h3>3.4.1 &ndash; <a name="3.4.1">Arithmetic Operators</a></h3><p>
-Lua supports the following arithmetic operators:
-
-<ul>
-<li><b><code>+</code>: </b>addition</li>
-<li><b><code>-</code>: </b>subtraction</li>
-<li><b><code>*</code>: </b>multiplication</li>
-<li><b><code>/</code>: </b>float division</li>
-<li><b><code>//</code>: </b>floor division</li>
-<li><b><code>%</code>: </b>modulo</li>
-<li><b><code>^</code>: </b>exponentiation</li>
-<li><b><code>-</code>: </b>unary minus</li>
-</ul>
-
-<p>
-With the exception of exponentiation and float division,
-the arithmetic operators work as follows:
-If both operands are integers,
-the operation is performed over integers and the result is an integer.
-Otherwise, if both operands are numbers
-or strings that can be converted to
-numbers (see <a href="#3.4.3">&sect;3.4.3</a>),
-then they are converted to floats,
-the operation is performed following the usual rules
-for floating-point arithmetic
-(usually the IEEE 754 standard),
-and the result is a float.
-
-
-<p>
-Exponentiation and float division (<code>/</code>)
-always convert their operands to floats
-and the result is always a float.
-Exponentiation uses the ISO&nbsp;C function <code>pow</code>,
-so that it works for non-integer exponents too.
-
-
-<p>
-Floor division (<code>//</code>) is a division
-that rounds the quotient towards minus infinity,
-that is, the floor of the division of its operands.
-
-
-<p>
-Modulo is defined as the remainder of a division
-that rounds the quotient towards minus infinity (floor division).
-
-
-<p>
-In case of overflows in integer arithmetic,
-all operations <em>wrap around</em>,
-according to the usual rules of two-complement arithmetic.
-(In other words,
-they return the unique representable integer
-that is equal modulo <em>2<sup>64</sup></em> to the mathematical result.)
-
-
-
-<h3>3.4.2 &ndash; <a name="3.4.2">Bitwise Operators</a></h3><p>
-Lua supports the following bitwise operators:
-
-<ul>
-<li><b><code>&amp;</code>: </b>bitwise AND</li>
-<li><b><code>&#124;</code>: </b>bitwise OR</li>
-<li><b><code>~</code>: </b>bitwise exclusive OR</li>
-<li><b><code>&gt;&gt;</code>: </b>right shift</li>
-<li><b><code>&lt;&lt;</code>: </b>left shift</li>
-<li><b><code>~</code>: </b>unary bitwise NOT</li>
-</ul>
-
-<p>
-All bitwise operations convert its operands to integers
-(see <a href="#3.4.3">&sect;3.4.3</a>),
-operate on all bits of those integers,
-and result in an integer.
-
-
-<p>
-Both right and left shifts fill the vacant bits with zeros.
-Negative displacements shift to the other direction;
-displacements with absolute values equal to or higher than
-the number of bits in an integer
-result in zero (as all bits are shifted out).
-
-
-
-
-
-<h3>3.4.3 &ndash; <a name="3.4.3">Coercions and Conversions</a></h3><p>
-Lua provides some automatic conversions between some
-types and representations at run time.
-Bitwise operators always convert float operands to integers.
-Exponentiation and float division
-always convert integer operands to floats.
-All other arithmetic operations applied to mixed numbers
-(integers and floats) convert the integer operand to a float;
-this is called the <em>usual rule</em>.
-The C API also converts both integers to floats and
-floats to integers, as needed.
-Moreover, string concatenation accepts numbers as arguments,
-besides strings.
-
-
-<p>
-Lua also converts strings to numbers,
-whenever a number is expected.
-
-
-<p>
-In a conversion from integer to float,
-if the integer value has an exact representation as a float,
-that is the result.
-Otherwise,
-the conversion gets the nearest higher or
-the nearest lower representable value.
-This kind of conversion never fails.
-
-
-<p>
-The conversion from float to integer
-checks whether the float has an exact representation as an integer
-(that is, the float has an integral value and
-it is in the range of integer representation).
-If it does, that representation is the result.
-Otherwise, the conversion fails.
-
-
-<p>
-The conversion from strings to numbers goes as follows:
-First, the string is converted to an integer or a float,
-following its syntax and the rules of the Lua lexer.
-(The string may have also leading and trailing spaces and a sign.)
-Then, the resulting number (float or integer)
-is converted to the type (float or integer) required by the context
-(e.g., the operation that forced the conversion).
-
-
-<p>
-All conversions from strings to numbers
-accept both a dot and the current locale mark
-as the radix character.
-(The Lua lexer, however, accepts only a dot.)
-
-
-<p>
-The conversion from numbers to strings uses a
-non-specified human-readable format.
-For complete control over how numbers are converted to strings,
-use the <code>format</code> function from the string library
-(see <a href="#pdf-string.format"><code>string.format</code></a>).
-
-
-
-
-
-<h3>3.4.4 &ndash; <a name="3.4.4">Relational Operators</a></h3><p>
-Lua supports the following relational operators:
-
-<ul>
-<li><b><code>==</code>: </b>equality</li>
-<li><b><code>~=</code>: </b>inequality</li>
-<li><b><code>&lt;</code>: </b>less than</li>
-<li><b><code>&gt;</code>: </b>greater than</li>
-<li><b><code>&lt;=</code>: </b>less or equal</li>
-<li><b><code>&gt;=</code>: </b>greater or equal</li>
-</ul><p>
-These operators always result in <b>false</b> or <b>true</b>.
-
-
-<p>
-Equality (<code>==</code>) first compares the type of its operands.
-If the types are different, then the result is <b>false</b>.
-Otherwise, the values of the operands are compared.
-Strings are compared in the obvious way.
-Numbers are equal if they denote the same mathematical value.
-
-
-<p>
-Tables, userdata, and threads
-are compared by reference:
-two objects are considered equal only if they are the same object.
-Every time you create a new object
-(a table, userdata, or thread),
-this new object is different from any previously existing object.
-A closure is always equal to itself.
-Closures with any detectable difference
-(different behavior, different definition) are always different.
-Closures created at different times but with no detectable differences
-may be classified as equal or not
-(depending on internal caching details).
-
-
-<p>
-You can change the way that Lua compares tables and userdata
-by using the "eq" metamethod (see <a href="#2.4">&sect;2.4</a>).
-
-
-<p>
-Equality comparisons do not convert strings to numbers
-or vice versa.
-Thus, <code>"0"==0</code> evaluates to <b>false</b>,
-and <code>t[0]</code> and <code>t["0"]</code> denote different
-entries in a table.
-
-
-<p>
-The operator <code>~=</code> is exactly the negation of equality (<code>==</code>).
-
-
-<p>
-The order operators work as follows.
-If both arguments are numbers,
-then they are compared according to their mathematical values
-(regardless of their subtypes).
-Otherwise, if both arguments are strings,
-then their values are compared according to the current locale.
-Otherwise, Lua tries to call the "lt" or the "le"
-metamethod (see <a href="#2.4">&sect;2.4</a>).
-A comparison <code>a &gt; b</code> is translated to <code>b &lt; a</code>
-and <code>a &gt;= b</code> is translated to <code>b &lt;= a</code>.
-
-
-<p>
-Following the IEEE 754 standard,
-NaN is considered neither smaller than,
-nor equal to, nor greater than any value (including itself).
-
-
-
-
-
-<h3>3.4.5 &ndash; <a name="3.4.5">Logical Operators</a></h3><p>
-The logical operators in Lua are
-<b>and</b>, <b>or</b>, and <b>not</b>.
-Like the control structures (see <a href="#3.3.4">&sect;3.3.4</a>),
-all logical operators consider both <b>false</b> and <b>nil</b> as false
-and anything else as true.
-
-
-<p>
-The negation operator <b>not</b> always returns <b>false</b> or <b>true</b>.
-The conjunction operator <b>and</b> returns its first argument
-if this value is <b>false</b> or <b>nil</b>;
-otherwise, <b>and</b> returns its second argument.
-The disjunction operator <b>or</b> returns its first argument
-if this value is different from <b>nil</b> and <b>false</b>;
-otherwise, <b>or</b> returns its second argument.
-Both <b>and</b> and <b>or</b> use short-circuit evaluation;
-that is,
-the second operand is evaluated only if necessary.
-Here are some examples:
-
-<pre>
-     10 or 20            --&gt; 10
-     10 or error()       --&gt; 10
-     nil or "a"          --&gt; "a"
-     nil and 10          --&gt; nil
-     false and error()   --&gt; false
-     false and nil       --&gt; false
-     false or nil        --&gt; nil
-     10 and 20           --&gt; 20
-</pre><p>
-(In this manual,
-<code>--&gt;</code> indicates the result of the preceding expression.)
-
-
-
-
-
-<h3>3.4.6 &ndash; <a name="3.4.6">Concatenation</a></h3><p>
-The string concatenation operator in Lua is
-denoted by two dots ('<code>..</code>').
-If both operands are strings or numbers, then they are converted to
-strings according to the rules described in <a href="#3.4.3">&sect;3.4.3</a>.
-Otherwise, the <code>__concat</code> metamethod is called (see <a href="#2.4">&sect;2.4</a>).
-
-
-
-
-
-<h3>3.4.7 &ndash; <a name="3.4.7">The Length Operator</a></h3>
-
-<p>
-The length operator is denoted by the unary prefix operator <code>#</code>.
-
-
-<p>
-The length of a string is its number of bytes
-(that is, the usual meaning of string length when each
-character is one byte).
-
-
-<p>
-The length operator applied on a table
-returns a border in that table.
-A <em>border</em> in a table <code>t</code> is any natural number
-that satisfies the following condition:
-
-<pre>
-     (border == 0 or t[border] ~= nil) and t[border + 1] == nil
-</pre><p>
-In words,
-a border is any (natural) index in a table
-where a non-nil value is followed by a nil value
-(or zero, when index 1 is nil).
-
-
-<p>
-A table with exactly one border is called a <em>sequence</em>.
-For instance, the table <code>{10, 20, 30, 40, 50}</code> is a sequence,
-as it has only one border (5).
-The table <code>{10, 20, 30, nil, 50}</code> has two borders (3 and 5),
-and therefore it is not a sequence.
-The table <code>{nil, 20, 30, nil, nil, 60, nil}</code>
-has three borders (0, 3, and 6),
-so it is not a sequence, too.
-The table <code>{}</code> is a sequence with border 0.
-Note that non-natural keys do not interfere
-with whether a table is a sequence.
-
-
-<p>
-When <code>t</code> is a sequence,
-<code>#t</code> returns its only border,
-which corresponds to the intuitive notion of the length of the sequence.
-When <code>t</code> is not a sequence,
-<code>#t</code> can return any of its borders.
-(The exact one depends on details of
-the internal representation of the table,
-which in turn can depend on how the table was populated and
-the memory addresses of its non-numeric keys.)
-
-
-<p>
-The computation of the length of a table
-has a guaranteed worst time of <em>O(log n)</em>,
-where <em>n</em> is the largest natural key in the table.
-
-
-<p>
-A program can modify the behavior of the length operator for
-any value but strings through the <code>__len</code> metamethod (see <a href="#2.4">&sect;2.4</a>).
-
-
-
-
-
-<h3>3.4.8 &ndash; <a name="3.4.8">Precedence</a></h3><p>
-Operator precedence in Lua follows the table below,
-from lower to higher priority:
-
-<pre>
-     or
-     and
-     &lt;     &gt;     &lt;=    &gt;=    ~=    ==
-     |
-     ~
-     &amp;
-     &lt;&lt;    &gt;&gt;
-     ..
-     +     -
-     *     /     //    %
-     unary operators (not   #     -     ~)
-     ^
-</pre><p>
-As usual,
-you can use parentheses to change the precedences of an expression.
-The concatenation ('<code>..</code>') and exponentiation ('<code>^</code>')
-operators are right associative.
-All other binary operators are left associative.
-
-
-
-
-
-<h3>3.4.9 &ndash; <a name="3.4.9">Table Constructors</a></h3><p>
-Table constructors are expressions that create tables.
-Every time a constructor is evaluated, a new table is created.
-A constructor can be used to create an empty table
-or to create a table and initialize some of its fields.
-The general syntax for constructors is
-
-<pre>
-	tableconstructor ::= &lsquo;<b>{</b>&rsquo; [fieldlist] &lsquo;<b>}</b>&rsquo;
-	fieldlist ::= field {fieldsep field} [fieldsep]
-	field ::= &lsquo;<b>[</b>&rsquo; exp &lsquo;<b>]</b>&rsquo; &lsquo;<b>=</b>&rsquo; exp | Name &lsquo;<b>=</b>&rsquo; exp | exp
-	fieldsep ::= &lsquo;<b>,</b>&rsquo; | &lsquo;<b>;</b>&rsquo;
-</pre>
-
-<p>
-Each field of the form <code>[exp1] = exp2</code> adds to the new table an entry
-with key <code>exp1</code> and value <code>exp2</code>.
-A field of the form <code>name = exp</code> is equivalent to
-<code>["name"] = exp</code>.
-Finally, fields of the form <code>exp</code> are equivalent to
-<code>[i] = exp</code>, where <code>i</code> are consecutive integers
-starting with 1.
-Fields in the other formats do not affect this counting.
-For example,
-
-<pre>
-     a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }
-</pre><p>
-is equivalent to
-
-<pre>
-     do
-       local t = {}
-       t[f(1)] = g
-       t[1] = "x"         -- 1st exp
-       t[2] = "y"         -- 2nd exp
-       t.x = 1            -- t["x"] = 1
-       t[3] = f(x)        -- 3rd exp
-       t[30] = 23
-       t[4] = 45          -- 4th exp
-       a = t
-     end
-</pre>
-
-<p>
-The order of the assignments in a constructor is undefined.
-(This order would be relevant only when there are repeated keys.)
-
-
-<p>
-If the last field in the list has the form <code>exp</code>
-and the expression is a function call or a vararg expression,
-then all values returned by this expression enter the list consecutively
-(see <a href="#3.4.10">&sect;3.4.10</a>).
-
-
-<p>
-The field list can have an optional trailing separator,
-as a convenience for machine-generated code.
-
-
-
-
-
-<h3>3.4.10 &ndash; <a name="3.4.10">Function Calls</a></h3><p>
-A function call in Lua has the following syntax:
-
-<pre>
-	functioncall ::= prefixexp args
-</pre><p>
-In a function call,
-first prefixexp and args are evaluated.
-If the value of prefixexp has type <em>function</em>,
-then this function is called
-with the given arguments.
-Otherwise, the prefixexp "call" metamethod is called,
-having as first argument the value of prefixexp,
-followed by the original call arguments
-(see <a href="#2.4">&sect;2.4</a>).
-
-
-<p>
-The form
-
-<pre>
-	functioncall ::= prefixexp &lsquo;<b>:</b>&rsquo; Name args
-</pre><p>
-can be used to call "methods".
-A call <code>v:name(<em>args</em>)</code>
-is syntactic sugar for <code>v.name(v,<em>args</em>)</code>,
-except that <code>v</code> is evaluated only once.
-
-
-<p>
-Arguments have the following syntax:
-
-<pre>
-	args ::= &lsquo;<b>(</b>&rsquo; [explist] &lsquo;<b>)</b>&rsquo;
-	args ::= tableconstructor
-	args ::= LiteralString
-</pre><p>
-All argument expressions are evaluated before the call.
-A call of the form <code>f{<em>fields</em>}</code> is
-syntactic sugar for <code>f({<em>fields</em>})</code>;
-that is, the argument list is a single new table.
-A call of the form <code>f'<em>string</em>'</code>
-(or <code>f"<em>string</em>"</code> or <code>f[[<em>string</em>]]</code>)
-is syntactic sugar for <code>f('<em>string</em>')</code>;
-that is, the argument list is a single literal string.
-
-
-<p>
-A call of the form <code>return <em>functioncall</em></code> is called
-a <em>tail call</em>.
-Lua implements <em>proper tail calls</em>
-(or <em>proper tail recursion</em>):
-in a tail call,
-the called function reuses the stack entry of the calling function.
-Therefore, there is no limit on the number of nested tail calls that
-a program can execute.
-However, a tail call erases any debug information about the
-calling function.
-Note that a tail call only happens with a particular syntax,
-where the <b>return</b> has one single function call as argument;
-this syntax makes the calling function return exactly
-the returns of the called function.
-So, none of the following examples are tail calls:
-
-<pre>
-     return (f(x))        -- results adjusted to 1
-     return 2 * f(x)
-     return x, f(x)       -- additional results
-     f(x); return         -- results discarded
-     return x or f(x)     -- results adjusted to 1
-</pre>
-
-
-
-
-<h3>3.4.11 &ndash; <a name="3.4.11">Function Definitions</a></h3>
-
-<p>
-The syntax for function definition is
-
-<pre>
-	functiondef ::= <b>function</b> funcbody
-	funcbody ::= &lsquo;<b>(</b>&rsquo; [parlist] &lsquo;<b>)</b>&rsquo; block <b>end</b>
-</pre>
-
-<p>
-The following syntactic sugar simplifies function definitions:
-
-<pre>
-	stat ::= <b>function</b> funcname funcbody
-	stat ::= <b>local</b> <b>function</b> Name funcbody
-	funcname ::= Name {&lsquo;<b>.</b>&rsquo; Name} [&lsquo;<b>:</b>&rsquo; Name]
-</pre><p>
-The statement
-
-<pre>
-     function f () <em>body</em> end
-</pre><p>
-translates to
-
-<pre>
-     f = function () <em>body</em> end
-</pre><p>
-The statement
-
-<pre>
-     function t.a.b.c.f () <em>body</em> end
-</pre><p>
-translates to
-
-<pre>
-     t.a.b.c.f = function () <em>body</em> end
-</pre><p>
-The statement
-
-<pre>
-     local function f () <em>body</em> end
-</pre><p>
-translates to
-
-<pre>
-     local f; f = function () <em>body</em> end
-</pre><p>
-not to
-
-<pre>
-     local f = function () <em>body</em> end
-</pre><p>
-(This only makes a difference when the body of the function
-contains references to <code>f</code>.)
-
-
-<p>
-A function definition is an executable expression,
-whose value has type <em>function</em>.
-When Lua precompiles a chunk,
-all its function bodies are precompiled too.
-Then, whenever Lua executes the function definition,
-the function is <em>instantiated</em> (or <em>closed</em>).
-This function instance (or <em>closure</em>)
-is the final value of the expression.
-
-
-<p>
-Parameters act as local variables that are
-initialized with the argument values:
-
-<pre>
-	parlist ::= namelist [&lsquo;<b>,</b>&rsquo; &lsquo;<b>...</b>&rsquo;] | &lsquo;<b>...</b>&rsquo;
-</pre><p>
-When a function is called,
-the list of arguments is adjusted to
-the length of the list of parameters,
-unless the function is a <em>vararg function</em>,
-which is indicated by three dots ('<code>...</code>')
-at the end of its parameter list.
-A vararg function does not adjust its argument list;
-instead, it collects all extra arguments and supplies them
-to the function through a <em>vararg expression</em>,
-which is also written as three dots.
-The value of this expression is a list of all actual extra arguments,
-similar to a function with multiple results.
-If a vararg expression is used inside another expression
-or in the middle of a list of expressions,
-then its return list is adjusted to one element.
-If the expression is used as the last element of a list of expressions,
-then no adjustment is made
-(unless that last expression is enclosed in parentheses).
-
-
-<p>
-As an example, consider the following definitions:
-
-<pre>
-     function f(a, b) end
-     function g(a, b, ...) end
-     function r() return 1,2,3 end
-</pre><p>
-Then, we have the following mapping from arguments to parameters and
-to the vararg expression:
-
-<pre>
-     CALL            PARAMETERS
-     
-     f(3)             a=3, b=nil
-     f(3, 4)          a=3, b=4
-     f(3, 4, 5)       a=3, b=4
-     f(r(), 10)       a=1, b=10
-     f(r())           a=1, b=2
-     
-     g(3)             a=3, b=nil, ... --&gt;  (nothing)
-     g(3, 4)          a=3, b=4,   ... --&gt;  (nothing)
-     g(3, 4, 5, 8)    a=3, b=4,   ... --&gt;  5  8
-     g(5, r())        a=5, b=1,   ... --&gt;  2  3
-</pre>
-
-<p>
-Results are returned using the <b>return</b> statement (see <a href="#3.3.4">&sect;3.3.4</a>).
-If control reaches the end of a function
-without encountering a <b>return</b> statement,
-then the function returns with no results.
-
-
-<p>
-
-There is a system-dependent limit on the number of values
-that a function may return.
-This limit is guaranteed to be larger than 1000.
-
-
-<p>
-The <em>colon</em> syntax
-is used for defining <em>methods</em>,
-that is, functions that have an implicit extra parameter <code>self</code>.
-Thus, the statement
-
-<pre>
-     function t.a.b.c:f (<em>params</em>) <em>body</em> end
-</pre><p>
-is syntactic sugar for
-
-<pre>
-     t.a.b.c.f = function (self, <em>params</em>) <em>body</em> end
-</pre>
-
-
-
-
-
-
-<h2>3.5 &ndash; <a name="3.5">Visibility Rules</a></h2>
-
-<p>
-
-Lua is a lexically scoped language.
-The scope of a local variable begins at the first statement after
-its declaration and lasts until the last non-void statement
-of the innermost block that includes the declaration.
-Consider the following example:
-
-<pre>
-     x = 10                -- global variable
-     do                    -- new block
-       local x = x         -- new 'x', with value 10
-       print(x)            --&gt; 10
-       x = x+1
-       do                  -- another block
-         local x = x+1     -- another 'x'
-         print(x)          --&gt; 12
-       end
-       print(x)            --&gt; 11
-     end
-     print(x)              --&gt; 10  (the global one)
-</pre>
-
-<p>
-Notice that, in a declaration like <code>local x = x</code>,
-the new <code>x</code> being declared is not in scope yet,
-and so the second <code>x</code> refers to the outside variable.
-
-
-<p>
-Because of the lexical scoping rules,
-local variables can be freely accessed by functions
-defined inside their scope.
-A local variable used by an inner function is called
-an <em>upvalue</em>, or <em>external local variable</em>,
-inside the inner function.
-
-
-<p>
-Notice that each execution of a <b>local</b> statement
-defines new local variables.
-Consider the following example:
-
-<pre>
-     a = {}
-     local x = 20
-     for i=1,10 do
-       local y = 0
-       a[i] = function () y=y+1; return x+y end
-     end
-</pre><p>
-The loop creates ten closures
-(that is, ten instances of the anonymous function).
-Each of these closures uses a different <code>y</code> variable,
-while all of them share the same <code>x</code>.
-
-
-
-
-
-<h1>4 &ndash; <a name="4">The Application Program Interface</a></h1>
-
-<p>
-
-This section describes the C&nbsp;API for Lua, that is,
-the set of C&nbsp;functions available to the host program to communicate
-with Lua.
-All API functions and related types and constants
-are declared in the header file <a name="pdf-lua.h"><code>lua.h</code></a>.
-
-
-<p>
-Even when we use the term "function",
-any facility in the API may be provided as a macro instead.
-Except where stated otherwise,
-all such macros use each of their arguments exactly once
-(except for the first argument, which is always a Lua state),
-and so do not generate any hidden side-effects.
-
-
-<p>
-As in most C&nbsp;libraries,
-the Lua API functions do not check their arguments for validity or consistency.
-However, you can change this behavior by compiling Lua
-with the macro <a name="pdf-LUA_USE_APICHECK"><code>LUA_USE_APICHECK</code></a> defined.
-
-
-<p>
-The Lua library is fully reentrant:
-it has no global variables.
-It keeps all information it needs in a dynamic structure,
-called the <em>Lua state</em>.
-
-
-<p>
-Each Lua state has one or more threads,
-which correspond to independent, cooperative lines of execution.
-The type <a href="#lua_State"><code>lua_State</code></a> (despite its name) refers to a thread.
-(Indirectly, through the thread, it also refers to the
-Lua state associated to the thread.)
-
-
-<p>
-A pointer to a thread must be passed as the first argument to
-every function in the library, except to <a href="#lua_newstate"><code>lua_newstate</code></a>,
-which creates a Lua state from scratch and returns a pointer
-to the <em>main thread</em> in the new state.
-
-
-
-<h2>4.1 &ndash; <a name="4.1">The Stack</a></h2>
-
-<p>
-Lua uses a <em>virtual stack</em> to pass values to and from C.
-Each element in this stack represents a Lua value
-(<b>nil</b>, number, string, etc.).
-Functions in the API can access this stack through the
-Lua state parameter that they receive.
-
-
-<p>
-Whenever Lua calls C, the called function gets a new stack,
-which is independent of previous stacks and of stacks of
-C&nbsp;functions that are still active.
-This stack initially contains any arguments to the C&nbsp;function
-and it is where the C&nbsp;function can store temporary
-Lua values and must push its results
-to be returned to the caller (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
-
-
-<p>
-For convenience,
-most query operations in the API do not follow a strict stack discipline.
-Instead, they can refer to any element in the stack
-by using an <em>index</em>:
-A positive index represents an absolute stack position
-(starting at&nbsp;1);
-a negative index represents an offset relative to the top of the stack.
-More specifically, if the stack has <em>n</em> elements,
-then index&nbsp;1 represents the first element
-(that is, the element that was pushed onto the stack first)
-and
-index&nbsp;<em>n</em> represents the last element;
-index&nbsp;-1 also represents the last element
-(that is, the element at the&nbsp;top)
-and index <em>-n</em> represents the first element.
-
-
-
-
-
-<h2>4.2 &ndash; <a name="4.2">Stack Size</a></h2>
-
-<p>
-When you interact with the Lua API,
-you are responsible for ensuring consistency.
-In particular,
-<em>you are responsible for controlling stack overflow</em>.
-You can use the function <a href="#lua_checkstack"><code>lua_checkstack</code></a>
-to ensure that the stack has enough space for pushing new elements.
-
-
-<p>
-Whenever Lua calls C,
-it ensures that the stack has space for
-at least <a name="pdf-LUA_MINSTACK"><code>LUA_MINSTACK</code></a> extra slots.
-<code>LUA_MINSTACK</code> is defined as 20,
-so that usually you do not have to worry about stack space
-unless your code has loops pushing elements onto the stack.
-
-
-<p>
-When you call a Lua function
-without a fixed number of results (see <a href="#lua_call"><code>lua_call</code></a>),
-Lua ensures that the stack has enough space for all results,
-but it does not ensure any extra space.
-So, before pushing anything in the stack after such a call
-you should use <a href="#lua_checkstack"><code>lua_checkstack</code></a>.
-
-
-
-
-
-<h2>4.3 &ndash; <a name="4.3">Valid and Acceptable Indices</a></h2>
-
-<p>
-Any function in the API that receives stack indices
-works only with <em>valid indices</em> or <em>acceptable indices</em>.
-
-
-<p>
-A <em>valid index</em> is an index that refers to a
-position that stores a modifiable Lua value.
-It comprises stack indices between&nbsp;1 and the stack top
-(<code>1 &le; abs(index) &le; top</code>)
-
-plus <em>pseudo-indices</em>,
-which represent some positions that are accessible to C&nbsp;code
-but that are not in the stack.
-Pseudo-indices are used to access the registry (see <a href="#4.5">&sect;4.5</a>)
-and the upvalues of a C&nbsp;function (see <a href="#4.4">&sect;4.4</a>).
-
-
-<p>
-Functions that do not need a specific mutable position,
-but only a value (e.g., query functions),
-can be called with acceptable indices.
-An <em>acceptable index</em> can be any valid index,
-but it also can be any positive index after the stack top
-within the space allocated for the stack,
-that is, indices up to the stack size.
-(Note that 0 is never an acceptable index.)
-Except when noted otherwise,
-functions in the API work with acceptable indices.
-
-
-<p>
-Acceptable indices serve to avoid extra tests
-against the stack top when querying the stack.
-For instance, a C&nbsp;function can query its third argument
-without the need to first check whether there is a third argument,
-that is, without the need to check whether 3 is a valid index.
-
-
-<p>
-For functions that can be called with acceptable indices,
-any non-valid index is treated as if it
-contains a value of a virtual type <a name="pdf-LUA_TNONE"><code>LUA_TNONE</code></a>,
-which behaves like a nil value.
-
-
-
-
-
-<h2>4.4 &ndash; <a name="4.4">C Closures</a></h2>
-
-<p>
-When a C&nbsp;function is created,
-it is possible to associate some values with it,
-thus creating a <em>C&nbsp;closure</em>
-(see <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>);
-these values are called <em>upvalues</em> and are
-accessible to the function whenever it is called.
-
-
-<p>
-Whenever a C&nbsp;function is called,
-its upvalues are located at specific pseudo-indices.
-These pseudo-indices are produced by the macro
-<a href="#lua_upvalueindex"><code>lua_upvalueindex</code></a>.
-The first upvalue associated with a function is at index
-<code>lua_upvalueindex(1)</code>, and so on.
-Any access to <code>lua_upvalueindex(<em>n</em>)</code>,
-where <em>n</em> is greater than the number of upvalues of the
-current function
-(but not greater than 256,
-which is one plus the maximum number of upvalues in a closure),
-produces an acceptable but invalid index.
-
-
-
-
-
-<h2>4.5 &ndash; <a name="4.5">Registry</a></h2>
-
-<p>
-Lua provides a <em>registry</em>,
-a predefined table that can be used by any C&nbsp;code to
-store whatever Lua values it needs to store.
-The registry table is always located at pseudo-index
-<a name="pdf-LUA_REGISTRYINDEX"><code>LUA_REGISTRYINDEX</code></a>.
-Any C&nbsp;library can store data into this table,
-but it must take care to choose keys
-that are different from those used
-by other libraries, to avoid collisions.
-Typically, you should use as key a string containing your library name,
-or a light userdata with the address of a C&nbsp;object in your code,
-or any Lua object created by your code.
-As with variable names,
-string keys starting with an underscore followed by
-uppercase letters are reserved for Lua.
-
-
-<p>
-The integer keys in the registry are used
-by the reference mechanism (see <a href="#luaL_ref"><code>luaL_ref</code></a>)
-and by some predefined values.
-Therefore, integer keys must not be used for other purposes.
-
-
-<p>
-When you create a new Lua state,
-its registry comes with some predefined values.
-These predefined values are indexed with integer keys
-defined as constants in <code>lua.h</code>.
-The following constants are defined:
-
-<ul>
-<li><b><a name="pdf-LUA_RIDX_MAINTHREAD"><code>LUA_RIDX_MAINTHREAD</code></a>: </b> At this index the registry has
-the main thread of the state.
-(The main thread is the one created together with the state.)
-</li>
-
-<li><b><a name="pdf-LUA_RIDX_GLOBALS"><code>LUA_RIDX_GLOBALS</code></a>: </b> At this index the registry has
-the global environment.
-</li>
-</ul>
-
-
-
-
-<h2>4.6 &ndash; <a name="4.6">Error Handling in C</a></h2>
-
-<p>
-Internally, Lua uses the C <code>longjmp</code> facility to handle errors.
-(Lua will use exceptions if you compile it as C++;
-search for <code>LUAI_THROW</code> in the source code for details.)
-When Lua faces any error
-(such as a memory allocation error or a type error)
-it <em>raises</em> an error;
-that is, it does a long jump.
-A <em>protected environment</em> uses <code>setjmp</code>
-to set a recovery point;
-any error jumps to the most recent active recovery point.
-
-
-<p>
-Inside a C&nbsp;function you can raise an error by calling <a href="#lua_error"><code>lua_error</code></a>.
-
-
-<p>
-Most functions in the API can raise an error,
-for instance due to a memory allocation error.
-The documentation for each function indicates whether
-it can raise errors.
-
-
-<p>
-If an error happens outside any protected environment,
-Lua calls a <em>panic function</em> (see <a href="#lua_atpanic"><code>lua_atpanic</code></a>)
-and then calls <code>abort</code>,
-thus exiting the host application.
-Your panic function can avoid this exit by
-never returning
-(e.g., doing a long jump to your own recovery point outside Lua).
-
-
-<p>
-The panic function,
-as its name implies,
-is a mechanism of last resort.
-Programs should avoid it.
-As a general rule,
-when a C&nbsp;function is called by Lua with a Lua state,
-it can do whatever it wants on that Lua state,
-as it should be already protected.
-However,
-when C code operates on other Lua states
-(e.g., a Lua argument to the function,
-a Lua state stored in the registry, or
-the result of <a href="#lua_newthread"><code>lua_newthread</code></a>),
-it should use them only in API calls that cannot raise errors.
-
-
-<p>
-The panic function runs as if it were a message handler (see <a href="#2.3">&sect;2.3</a>);
-in particular, the error object is at the top of the stack.
-However, there is no guarantee about stack space.
-To push anything on the stack,
-the panic function must first check the available space (see <a href="#4.2">&sect;4.2</a>).
-
-
-
-
-
-<h2>4.7 &ndash; <a name="4.7">Handling Yields in C</a></h2>
-
-<p>
-Internally, Lua uses the C <code>longjmp</code> facility to yield a coroutine.
-Therefore, if a C&nbsp;function <code>foo</code> calls an API function
-and this API function yields
-(directly or indirectly by calling another function that yields),
-Lua cannot return to <code>foo</code> any more,
-because the <code>longjmp</code> removes its frame from the C stack.
-
-
-<p>
-To avoid this kind of problem,
-Lua raises an error whenever it tries to yield across an API call,
-except for three functions:
-<a href="#lua_yieldk"><code>lua_yieldk</code></a>, <a href="#lua_callk"><code>lua_callk</code></a>, and <a href="#lua_pcallk"><code>lua_pcallk</code></a>.
-All those functions receive a <em>continuation function</em>
-(as a parameter named <code>k</code>) to continue execution after a yield.
-
-
-<p>
-We need to set some terminology to explain continuations.
-We have a C&nbsp;function called from Lua which we will call
-the <em>original function</em>.
-This original function then calls one of those three functions in the C API,
-which we will call the <em>callee function</em>,
-that then yields the current thread.
-(This can happen when the callee function is <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
-or when the callee function is either <a href="#lua_callk"><code>lua_callk</code></a> or <a href="#lua_pcallk"><code>lua_pcallk</code></a>
-and the function called by them yields.)
-
-
-<p>
-Suppose the running thread yields while executing the callee function.
-After the thread resumes,
-it eventually will finish running the callee function.
-However,
-the callee function cannot return to the original function,
-because its frame in the C stack was destroyed by the yield.
-Instead, Lua calls a <em>continuation function</em>,
-which was given as an argument to the callee function.
-As the name implies,
-the continuation function should continue the task
-of the original function.
-
-
-<p>
-As an illustration, consider the following function:
-
-<pre>
-     int original_function (lua_State *L) {
-       ...     /* code 1 */
-       status = lua_pcall(L, n, m, h);  /* calls Lua */
-       ...     /* code 2 */
-     }
-</pre><p>
-Now we want to allow
-the Lua code being run by <a href="#lua_pcall"><code>lua_pcall</code></a> to yield.
-First, we can rewrite our function like here:
-
-<pre>
-     int k (lua_State *L, int status, lua_KContext ctx) {
-       ...  /* code 2 */
-     }
-     
-     int original_function (lua_State *L) {
-       ...     /* code 1 */
-       return k(L, lua_pcall(L, n, m, h), ctx);
-     }
-</pre><p>
-In the above code,
-the new function <code>k</code> is a
-<em>continuation function</em> (with type <a href="#lua_KFunction"><code>lua_KFunction</code></a>),
-which should do all the work that the original function
-was doing after calling <a href="#lua_pcall"><code>lua_pcall</code></a>.
-Now, we must inform Lua that it must call <code>k</code> if the Lua code
-being executed by <a href="#lua_pcall"><code>lua_pcall</code></a> gets interrupted in some way
-(errors or yielding),
-so we rewrite the code as here,
-replacing <a href="#lua_pcall"><code>lua_pcall</code></a> by <a href="#lua_pcallk"><code>lua_pcallk</code></a>:
-
-<pre>
-     int original_function (lua_State *L) {
-       ...     /* code 1 */
-       return k(L, lua_pcallk(L, n, m, h, ctx2, k), ctx1);
-     }
-</pre><p>
-Note the external, explicit call to the continuation:
-Lua will call the continuation only if needed, that is,
-in case of errors or resuming after a yield.
-If the called function returns normally without ever yielding,
-<a href="#lua_pcallk"><code>lua_pcallk</code></a> (and <a href="#lua_callk"><code>lua_callk</code></a>) will also return normally.
-(Of course, instead of calling the continuation in that case,
-you can do the equivalent work directly inside the original function.)
-
-
-<p>
-Besides the Lua state,
-the continuation function has two other parameters:
-the final status of the call plus the context value (<code>ctx</code>) that
-was passed originally to <a href="#lua_pcallk"><code>lua_pcallk</code></a>.
-(Lua does not use this context value;
-it only passes this value from the original function to the
-continuation function.)
-For <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
-the status is the same value that would be returned by <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
-except that it is <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> when being executed after a yield
-(instead of <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>).
-For <a href="#lua_yieldk"><code>lua_yieldk</code></a> and <a href="#lua_callk"><code>lua_callk</code></a>,
-the status is always <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> when Lua calls the continuation.
-(For these two functions,
-Lua will not call the continuation in case of errors,
-because they do not handle errors.)
-Similarly, when using <a href="#lua_callk"><code>lua_callk</code></a>,
-you should call the continuation function
-with <a href="#pdf-LUA_OK"><code>LUA_OK</code></a> as the status.
-(For <a href="#lua_yieldk"><code>lua_yieldk</code></a>, there is not much point in calling
-directly the continuation function,
-because <a href="#lua_yieldk"><code>lua_yieldk</code></a> usually does not return.)
-
-
-<p>
-Lua treats the continuation function as if it were the original function.
-The continuation function receives the same Lua stack
-from the original function,
-in the same state it would be if the callee function had returned.
-(For instance,
-after a <a href="#lua_callk"><code>lua_callk</code></a> the function and its arguments are
-removed from the stack and replaced by the results from the call.)
-It also has the same upvalues.
-Whatever it returns is handled by Lua as if it were the return
-of the original function.
-
-
-
-
-
-<h2>4.8 &ndash; <a name="4.8">Functions and Types</a></h2>
-
-<p>
-Here we list all functions and types from the C&nbsp;API in
-alphabetical order.
-Each function has an indicator like this:
-<span class="apii">[-o, +p, <em>x</em>]</span>
-
-
-<p>
-The first field, <code>o</code>,
-is how many elements the function pops from the stack.
-The second field, <code>p</code>,
-is how many elements the function pushes onto the stack.
-(Any function always pushes its results after popping its arguments.)
-A field in the form <code>x|y</code> means the function can push (or pop)
-<code>x</code> or <code>y</code> elements,
-depending on the situation;
-an interrogation mark '<code>?</code>' means that
-we cannot know how many elements the function pops/pushes
-by looking only at its arguments
-(e.g., they may depend on what is on the stack).
-The third field, <code>x</code>,
-tells whether the function may raise errors:
-'<code>-</code>' means the function never raises any error;
-'<code>m</code>' means the function may raise out-of-memory errors
-and errors running a <code>__gc</code> metamethod;
-'<code>e</code>' means the function may raise any errors
-(it can run arbitrary Lua code,
-either directly or through metamethods);
-'<code>v</code>' means the function may raise an error on purpose.
-
-
-
-<hr><h3><a name="lua_absindex"><code>lua_absindex</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_absindex (lua_State *L, int idx);</pre>
-
-<p>
-Converts the acceptable index <code>idx</code>
-into an equivalent absolute index
-(that is, one that does not depend on the stack top).
-
-
-
-
-
-<hr><h3><a name="lua_Alloc"><code>lua_Alloc</code></a></h3>
-<pre>typedef void * (*lua_Alloc) (void *ud,
-                             void *ptr,
-                             size_t osize,
-                             size_t nsize);</pre>
-
-<p>
-The type of the memory-allocation function used by Lua states.
-The allocator function must provide a
-functionality similar to <code>realloc</code>,
-but not exactly the same.
-Its arguments are
-<code>ud</code>, an opaque pointer passed to <a href="#lua_newstate"><code>lua_newstate</code></a>;
-<code>ptr</code>, a pointer to the block being allocated/reallocated/freed;
-<code>osize</code>, the original size of the block or some code about what
-is being allocated;
-and <code>nsize</code>, the new size of the block.
-
-
-<p>
-When <code>ptr</code> is not <code>NULL</code>,
-<code>osize</code> is the size of the block pointed by <code>ptr</code>,
-that is, the size given when it was allocated or reallocated.
-
-
-<p>
-When <code>ptr</code> is <code>NULL</code>,
-<code>osize</code> encodes the kind of object that Lua is allocating.
-<code>osize</code> is any of
-<a href="#pdf-LUA_TSTRING"><code>LUA_TSTRING</code></a>, <a href="#pdf-LUA_TTABLE"><code>LUA_TTABLE</code></a>, <a href="#pdf-LUA_TFUNCTION"><code>LUA_TFUNCTION</code></a>,
-<a href="#pdf-LUA_TUSERDATA"><code>LUA_TUSERDATA</code></a>, or <a href="#pdf-LUA_TTHREAD"><code>LUA_TTHREAD</code></a> when (and only when)
-Lua is creating a new object of that type.
-When <code>osize</code> is some other value,
-Lua is allocating memory for something else.
-
-
-<p>
-Lua assumes the following behavior from the allocator function:
-
-
-<p>
-When <code>nsize</code> is zero,
-the allocator must behave like <code>free</code>
-and return <code>NULL</code>.
-
-
-<p>
-When <code>nsize</code> is not zero,
-the allocator must behave like <code>realloc</code>.
-The allocator returns <code>NULL</code>
-if and only if it cannot fulfill the request.
-Lua assumes that the allocator never fails when
-<code>osize &gt;= nsize</code>.
-
-
-<p>
-Here is a simple implementation for the allocator function.
-It is used in the auxiliary library by <a href="#luaL_newstate"><code>luaL_newstate</code></a>.
-
-<pre>
-     static void *l_alloc (void *ud, void *ptr, size_t osize,
-                                                size_t nsize) {
-       (void)ud;  (void)osize;  /* not used */
-       if (nsize == 0) {
-         free(ptr);
-         return NULL;
-       }
-       else
-         return realloc(ptr, nsize);
-     }
-</pre><p>
-Note that Standard&nbsp;C ensures
-that <code>free(NULL)</code> has no effect and that
-<code>realloc(NULL,size)</code> is equivalent to <code>malloc(size)</code>.
-This code assumes that <code>realloc</code> does not fail when shrinking a block.
-(Although Standard&nbsp;C does not ensure this behavior,
-it seems to be a safe assumption.)
-
-
-
-
-
-<hr><h3><a name="lua_arith"><code>lua_arith</code></a></h3><p>
-<span class="apii">[-(2|1), +1, <em>e</em>]</span>
-<pre>void lua_arith (lua_State *L, int op);</pre>
-
-<p>
-Performs an arithmetic or bitwise operation over the two values
-(or one, in the case of negations)
-at the top of the stack,
-with the value at the top being the second operand,
-pops these values, and pushes the result of the operation.
-The function follows the semantics of the corresponding Lua operator
-(that is, it may call metamethods).
-
-
-<p>
-The value of <code>op</code> must be one of the following constants:
-
-<ul>
-
-<li><b><a name="pdf-LUA_OPADD"><code>LUA_OPADD</code></a>: </b> performs addition (<code>+</code>)</li>
-<li><b><a name="pdf-LUA_OPSUB"><code>LUA_OPSUB</code></a>: </b> performs subtraction (<code>-</code>)</li>
-<li><b><a name="pdf-LUA_OPMUL"><code>LUA_OPMUL</code></a>: </b> performs multiplication (<code>*</code>)</li>
-<li><b><a name="pdf-LUA_OPDIV"><code>LUA_OPDIV</code></a>: </b> performs float division (<code>/</code>)</li>
-<li><b><a name="pdf-LUA_OPIDIV"><code>LUA_OPIDIV</code></a>: </b> performs floor division (<code>//</code>)</li>
-<li><b><a name="pdf-LUA_OPMOD"><code>LUA_OPMOD</code></a>: </b> performs modulo (<code>%</code>)</li>
-<li><b><a name="pdf-LUA_OPPOW"><code>LUA_OPPOW</code></a>: </b> performs exponentiation (<code>^</code>)</li>
-<li><b><a name="pdf-LUA_OPUNM"><code>LUA_OPUNM</code></a>: </b> performs mathematical negation (unary <code>-</code>)</li>
-<li><b><a name="pdf-LUA_OPBNOT"><code>LUA_OPBNOT</code></a>: </b> performs bitwise NOT (<code>~</code>)</li>
-<li><b><a name="pdf-LUA_OPBAND"><code>LUA_OPBAND</code></a>: </b> performs bitwise AND (<code>&amp;</code>)</li>
-<li><b><a name="pdf-LUA_OPBOR"><code>LUA_OPBOR</code></a>: </b> performs bitwise OR (<code>|</code>)</li>
-<li><b><a name="pdf-LUA_OPBXOR"><code>LUA_OPBXOR</code></a>: </b> performs bitwise exclusive OR (<code>~</code>)</li>
-<li><b><a name="pdf-LUA_OPSHL"><code>LUA_OPSHL</code></a>: </b> performs left shift (<code>&lt;&lt;</code>)</li>
-<li><b><a name="pdf-LUA_OPSHR"><code>LUA_OPSHR</code></a>: </b> performs right shift (<code>&gt;&gt;</code>)</li>
-
-</ul>
-
-
-
-
-<hr><h3><a name="lua_atpanic"><code>lua_atpanic</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);</pre>
-
-<p>
-Sets a new panic function and returns the old one (see <a href="#4.6">&sect;4.6</a>).
-
-
-
-
-
-<hr><h3><a name="lua_call"><code>lua_call</code></a></h3><p>
-<span class="apii">[-(nargs+1), +nresults, <em>e</em>]</span>
-<pre>void lua_call (lua_State *L, int nargs, int nresults);</pre>
-
-<p>
-Calls a function.
-
-
-<p>
-To call a function you must use the following protocol:
-first, the function to be called is pushed onto the stack;
-then, the arguments to the function are pushed
-in direct order;
-that is, the first argument is pushed first.
-Finally you call <a href="#lua_call"><code>lua_call</code></a>;
-<code>nargs</code> is the number of arguments that you pushed onto the stack.
-All arguments and the function value are popped from the stack
-when the function is called.
-The function results are pushed onto the stack when the function returns.
-The number of results is adjusted to <code>nresults</code>,
-unless <code>nresults</code> is <a name="pdf-LUA_MULTRET"><code>LUA_MULTRET</code></a>.
-In this case, all results from the function are pushed;
-Lua takes care that the returned values fit into the stack space,
-but it does not ensure any extra space in the stack.
-The function results are pushed onto the stack in direct order
-(the first result is pushed first),
-so that after the call the last result is on the top of the stack.
-
-
-<p>
-Any error inside the called function is propagated upwards
-(with a <code>longjmp</code>).
-
-
-<p>
-The following example shows how the host program can do the
-equivalent to this Lua code:
-
-<pre>
-     a = f("how", t.x, 14)
-</pre><p>
-Here it is in&nbsp;C:
-
-<pre>
-     lua_getglobal(L, "f");                  /* function to be called */
-     lua_pushliteral(L, "how");                       /* 1st argument */
-     lua_getglobal(L, "t");                    /* table to be indexed */
-     lua_getfield(L, -1, "x");        /* push result of t.x (2nd arg) */
-     lua_remove(L, -2);                  /* remove 't' from the stack */
-     lua_pushinteger(L, 14);                          /* 3rd argument */
-     lua_call(L, 3, 1);     /* call 'f' with 3 arguments and 1 result */
-     lua_setglobal(L, "a");                         /* set global 'a' */
-</pre><p>
-Note that the code above is <em>balanced</em>:
-at its end, the stack is back to its original configuration.
-This is considered good programming practice.
-
-
-
-
-
-<hr><h3><a name="lua_callk"><code>lua_callk</code></a></h3><p>
-<span class="apii">[-(nargs + 1), +nresults, <em>e</em>]</span>
-<pre>void lua_callk (lua_State *L,
-                int nargs,
-                int nresults,
-                lua_KContext ctx,
-                lua_KFunction k);</pre>
-
-<p>
-This function behaves exactly like <a href="#lua_call"><code>lua_call</code></a>,
-but allows the called function to yield (see <a href="#4.7">&sect;4.7</a>).
-
-
-
-
-
-<hr><h3><a name="lua_CFunction"><code>lua_CFunction</code></a></h3>
-<pre>typedef int (*lua_CFunction) (lua_State *L);</pre>
-
-<p>
-Type for C&nbsp;functions.
-
-
-<p>
-In order to communicate properly with Lua,
-a C&nbsp;function must use the following protocol,
-which defines the way parameters and results are passed:
-a C&nbsp;function receives its arguments from Lua in its stack
-in direct order (the first argument is pushed first).
-So, when the function starts,
-<code>lua_gettop(L)</code> returns the number of arguments received by the function.
-The first argument (if any) is at index 1
-and its last argument is at index <code>lua_gettop(L)</code>.
-To return values to Lua, a C&nbsp;function just pushes them onto the stack,
-in direct order (the first result is pushed first),
-and returns the number of results.
-Any other value in the stack below the results will be properly
-discarded by Lua.
-Like a Lua function, a C&nbsp;function called by Lua can also return
-many results.
-
-
-<p>
-As an example, the following function receives a variable number
-of numeric arguments and returns their average and their sum:
-
-<pre>
-     static int foo (lua_State *L) {
-       int n = lua_gettop(L);    /* number of arguments */
-       lua_Number sum = 0.0;
-       int i;
-       for (i = 1; i &lt;= n; i++) {
-         if (!lua_isnumber(L, i)) {
-           lua_pushliteral(L, "incorrect argument");
-           lua_error(L);
-         }
-         sum += lua_tonumber(L, i);
-       }
-       lua_pushnumber(L, sum/n);        /* first result */
-       lua_pushnumber(L, sum);         /* second result */
-       return 2;                   /* number of results */
-     }
-</pre>
-
-
-
-
-<hr><h3><a name="lua_checkstack"><code>lua_checkstack</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_checkstack (lua_State *L, int n);</pre>
-
-<p>
-Ensures that the stack has space for at least <code>n</code> extra slots
-(that is, that you can safely push up to <code>n</code> values into it).
-It returns false if it cannot fulfill the request,
-either because it would cause the stack
-to be larger than a fixed maximum size
-(typically at least several thousand elements) or
-because it cannot allocate memory for the extra space.
-This function never shrinks the stack;
-if the stack already has space for the extra slots,
-it is left unchanged.
-
-
-
-
-
-<hr><h3><a name="lua_close"><code>lua_close</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>void lua_close (lua_State *L);</pre>
-
-<p>
-Destroys all objects in the given Lua state
-(calling the corresponding garbage-collection metamethods, if any)
-and frees all dynamic memory used by this state.
-In several platforms, you may not need to call this function,
-because all resources are naturally released when the host program ends.
-On the other hand, long-running programs that create multiple states,
-such as daemons or web servers,
-will probably need to close states as soon as they are not needed.
-
-
-
-
-
-<hr><h3><a name="lua_compare"><code>lua_compare</code></a></h3><p>
-<span class="apii">[-0, +0, <em>e</em>]</span>
-<pre>int lua_compare (lua_State *L, int index1, int index2, int op);</pre>
-
-<p>
-Compares two Lua values.
-Returns 1 if the value at index <code>index1</code> satisfies <code>op</code>
-when compared with the value at index <code>index2</code>,
-following the semantics of the corresponding Lua operator
-(that is, it may call metamethods).
-Otherwise returns&nbsp;0.
-Also returns&nbsp;0 if any of the indices is not valid.
-
-
-<p>
-The value of <code>op</code> must be one of the following constants:
-
-<ul>
-
-<li><b><a name="pdf-LUA_OPEQ"><code>LUA_OPEQ</code></a>: </b> compares for equality (<code>==</code>)</li>
-<li><b><a name="pdf-LUA_OPLT"><code>LUA_OPLT</code></a>: </b> compares for less than (<code>&lt;</code>)</li>
-<li><b><a name="pdf-LUA_OPLE"><code>LUA_OPLE</code></a>: </b> compares for less or equal (<code>&lt;=</code>)</li>
-
-</ul>
-
-
-
-
-<hr><h3><a name="lua_concat"><code>lua_concat</code></a></h3><p>
-<span class="apii">[-n, +1, <em>e</em>]</span>
-<pre>void lua_concat (lua_State *L, int n);</pre>
-
-<p>
-Concatenates the <code>n</code> values at the top of the stack,
-pops them, and leaves the result at the top.
-If <code>n</code>&nbsp;is&nbsp;1, the result is the single value on the stack
-(that is, the function does nothing);
-if <code>n</code> is 0, the result is the empty string.
-Concatenation is performed following the usual semantics of Lua
-(see <a href="#3.4.6">&sect;3.4.6</a>).
-
-
-
-
-
-<hr><h3><a name="lua_copy"><code>lua_copy</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>void lua_copy (lua_State *L, int fromidx, int toidx);</pre>
-
-<p>
-Copies the element at index <code>fromidx</code>
-into the valid index <code>toidx</code>,
-replacing the value at that position.
-Values at other positions are not affected.
-
-
-
-
-
-<hr><h3><a name="lua_createtable"><code>lua_createtable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_createtable (lua_State *L, int narr, int nrec);</pre>
-
-<p>
-Creates a new empty table and pushes it onto the stack.
-Parameter <code>narr</code> is a hint for how many elements the table
-will have as a sequence;
-parameter <code>nrec</code> is a hint for how many other elements
-the table will have.
-Lua may use these hints to preallocate memory for the new table.
-This preallocation is useful for performance when you know in advance
-how many elements the table will have.
-Otherwise you can use the function <a href="#lua_newtable"><code>lua_newtable</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_dump"><code>lua_dump</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_dump (lua_State *L,
-                        lua_Writer writer,
-                        void *data,
-                        int strip);</pre>
-
-<p>
-Dumps a function as a binary chunk.
-Receives a Lua function on the top of the stack
-and produces a binary chunk that,
-if loaded again,
-results in a function equivalent to the one dumped.
-As it produces parts of the chunk,
-<a href="#lua_dump"><code>lua_dump</code></a> calls function <code>writer</code> (see <a href="#lua_Writer"><code>lua_Writer</code></a>)
-with the given <code>data</code>
-to write them.
-
-
-<p>
-If <code>strip</code> is true,
-the binary representation may not include all debug information
-about the function,
-to save space.
-
-
-<p>
-The value returned is the error code returned by the last
-call to the writer;
-0&nbsp;means no errors.
-
-
-<p>
-This function does not pop the Lua function from the stack.
-
-
-
-
-
-<hr><h3><a name="lua_error"><code>lua_error</code></a></h3><p>
-<span class="apii">[-1, +0, <em>v</em>]</span>
-<pre>int lua_error (lua_State *L);</pre>
-
-<p>
-Generates a Lua error,
-using the value at the top of the stack as the error object.
-This function does a long jump,
-and therefore never returns
-(see <a href="#luaL_error"><code>luaL_error</code></a>).
-
-
-
-
-
-<hr><h3><a name="lua_gc"><code>lua_gc</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>int lua_gc (lua_State *L, int what, int data);</pre>
-
-<p>
-Controls the garbage collector.
-
-
-<p>
-This function performs several tasks,
-according to the value of the parameter <code>what</code>:
-
-<ul>
-
-<li><b><code>LUA_GCSTOP</code>: </b>
-stops the garbage collector.
-</li>
-
-<li><b><code>LUA_GCRESTART</code>: </b>
-restarts the garbage collector.
-</li>
-
-<li><b><code>LUA_GCCOLLECT</code>: </b>
-performs a full garbage-collection cycle.
-</li>
-
-<li><b><code>LUA_GCCOUNT</code>: </b>
-returns the current amount of memory (in Kbytes) in use by Lua.
-</li>
-
-<li><b><code>LUA_GCCOUNTB</code>: </b>
-returns the remainder of dividing the current amount of bytes of
-memory in use by Lua by 1024.
-</li>
-
-<li><b><code>LUA_GCSTEP</code>: </b>
-performs an incremental step of garbage collection.
-</li>
-
-<li><b><code>LUA_GCSETPAUSE</code>: </b>
-sets <code>data</code> as the new value
-for the <em>pause</em> of the collector (see <a href="#2.5">&sect;2.5</a>)
-and returns the previous value of the pause.
-</li>
-
-<li><b><code>LUA_GCSETSTEPMUL</code>: </b>
-sets <code>data</code> as the new value for the <em>step multiplier</em> of
-the collector (see <a href="#2.5">&sect;2.5</a>)
-and returns the previous value of the step multiplier.
-</li>
-
-<li><b><code>LUA_GCISRUNNING</code>: </b>
-returns a boolean that tells whether the collector is running
-(i.e., not stopped).
-</li>
-
-</ul>
-
-<p>
-For more details about these options,
-see <a href="#pdf-collectgarbage"><code>collectgarbage</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_getallocf"><code>lua_getallocf</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>lua_Alloc lua_getallocf (lua_State *L, void **ud);</pre>
-
-<p>
-Returns the memory-allocation function of a given state.
-If <code>ud</code> is not <code>NULL</code>, Lua stores in <code>*ud</code> the
-opaque pointer given when the memory-allocator function was set.
-
-
-
-
-
-<hr><h3><a name="lua_getfield"><code>lua_getfield</code></a></h3><p>
-<span class="apii">[-0, +1, <em>e</em>]</span>
-<pre>int lua_getfield (lua_State *L, int index, const char *k);</pre>
-
-<p>
-Pushes onto the stack the value <code>t[k]</code>,
-where <code>t</code> is the value at the given index.
-As in Lua, this function may trigger a metamethod
-for the "index" event (see <a href="#2.4">&sect;2.4</a>).
-
-
-<p>
-Returns the type of the pushed value.
-
-
-
-
-
-<hr><h3><a name="lua_getextraspace"><code>lua_getextraspace</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>void *lua_getextraspace (lua_State *L);</pre>
-
-<p>
-Returns a pointer to a raw memory area associated with the
-given Lua state.
-The application can use this area for any purpose;
-Lua does not use it for anything.
-
-
-<p>
-Each new thread has this area initialized with a copy
-of the area of the main thread.
-
-
-<p>
-By default, this area has the size of a pointer to void,
-but you can recompile Lua with a different size for this area.
-(See <code>LUA_EXTRASPACE</code> in <code>luaconf.h</code>.)
-
-
-
-
-
-<hr><h3><a name="lua_getglobal"><code>lua_getglobal</code></a></h3><p>
-<span class="apii">[-0, +1, <em>e</em>]</span>
-<pre>int lua_getglobal (lua_State *L, const char *name);</pre>
-
-<p>
-Pushes onto the stack the value of the global <code>name</code>.
-Returns the type of that value.
-
-
-
-
-
-<hr><h3><a name="lua_geti"><code>lua_geti</code></a></h3><p>
-<span class="apii">[-0, +1, <em>e</em>]</span>
-<pre>int lua_geti (lua_State *L, int index, lua_Integer i);</pre>
-
-<p>
-Pushes onto the stack the value <code>t[i]</code>,
-where <code>t</code> is the value at the given index.
-As in Lua, this function may trigger a metamethod
-for the "index" event (see <a href="#2.4">&sect;2.4</a>).
-
-
-<p>
-Returns the type of the pushed value.
-
-
-
-
-
-<hr><h3><a name="lua_getmetatable"><code>lua_getmetatable</code></a></h3><p>
-<span class="apii">[-0, +(0|1), &ndash;]</span>
-<pre>int lua_getmetatable (lua_State *L, int index);</pre>
-
-<p>
-If the value at the given index has a metatable,
-the function pushes that metatable onto the stack and returns&nbsp;1.
-Otherwise,
-the function returns&nbsp;0 and pushes nothing on the stack.
-
-
-
-
-
-<hr><h3><a name="lua_gettable"><code>lua_gettable</code></a></h3><p>
-<span class="apii">[-1, +1, <em>e</em>]</span>
-<pre>int lua_gettable (lua_State *L, int index);</pre>
-
-<p>
-Pushes onto the stack the value <code>t[k]</code>,
-where <code>t</code> is the value at the given index
-and <code>k</code> is the value at the top of the stack.
-
-
-<p>
-This function pops the key from the stack,
-pushing the resulting value in its place.
-As in Lua, this function may trigger a metamethod
-for the "index" event (see <a href="#2.4">&sect;2.4</a>).
-
-
-<p>
-Returns the type of the pushed value.
-
-
-
-
-
-<hr><h3><a name="lua_gettop"><code>lua_gettop</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_gettop (lua_State *L);</pre>
-
-<p>
-Returns the index of the top element in the stack.
-Because indices start at&nbsp;1,
-this result is equal to the number of elements in the stack;
-in particular, 0&nbsp;means an empty stack.
-
-
-
-
-
-<hr><h3><a name="lua_getuservalue"><code>lua_getuservalue</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>int lua_getuservalue (lua_State *L, int index);</pre>
-
-<p>
-Pushes onto the stack the Lua value associated with the full userdata
-at the given index.
-
-
-<p>
-Returns the type of the pushed value.
-
-
-
-
-
-<hr><h3><a name="lua_insert"><code>lua_insert</code></a></h3><p>
-<span class="apii">[-1, +1, &ndash;]</span>
-<pre>void lua_insert (lua_State *L, int index);</pre>
-
-<p>
-Moves the top element into the given valid index,
-shifting up the elements above this index to open space.
-This function cannot be called with a pseudo-index,
-because a pseudo-index is not an actual stack position.
-
-
-
-
-
-<hr><h3><a name="lua_Integer"><code>lua_Integer</code></a></h3>
-<pre>typedef ... lua_Integer;</pre>
-
-<p>
-The type of integers in Lua.
-
-
-<p>
-By default this type is <code>long long</code>,
-(usually a 64-bit two-complement integer),
-but that can be changed to <code>long</code> or <code>int</code>
-(usually a 32-bit two-complement integer).
-(See <code>LUA_INT_TYPE</code> in <code>luaconf.h</code>.)
-
-
-<p>
-Lua also defines the constants
-<a name="pdf-LUA_MININTEGER"><code>LUA_MININTEGER</code></a> and <a name="pdf-LUA_MAXINTEGER"><code>LUA_MAXINTEGER</code></a>,
-with the minimum and the maximum values that fit in this type.
-
-
-
-
-
-<hr><h3><a name="lua_isboolean"><code>lua_isboolean</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_isboolean (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given index is a boolean,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_iscfunction"><code>lua_iscfunction</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_iscfunction (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given index is a C&nbsp;function,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isfunction"><code>lua_isfunction</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_isfunction (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given index is a function
-(either C or Lua), and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isinteger"><code>lua_isinteger</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_isinteger (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given index is an integer
-(that is, the value is a number and is represented as an integer),
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_islightuserdata"><code>lua_islightuserdata</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_islightuserdata (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given index is a light userdata,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isnil"><code>lua_isnil</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_isnil (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given index is <b>nil</b>,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isnone"><code>lua_isnone</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_isnone (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the given index is not valid,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isnoneornil"><code>lua_isnoneornil</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_isnoneornil (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the given index is not valid
-or if the value at this index is <b>nil</b>,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isnumber"><code>lua_isnumber</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_isnumber (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given index is a number
-or a string convertible to a number,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isstring"><code>lua_isstring</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_isstring (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given index is a string
-or a number (which is always convertible to a string),
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_istable"><code>lua_istable</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_istable (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given index is a table,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isthread"><code>lua_isthread</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_isthread (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given index is a thread,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isuserdata"><code>lua_isuserdata</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_isuserdata (lua_State *L, int index);</pre>
-
-<p>
-Returns 1 if the value at the given index is a userdata
-(either full or light), and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_isyieldable"><code>lua_isyieldable</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_isyieldable (lua_State *L);</pre>
-
-<p>
-Returns 1 if the given coroutine can yield,
-and 0&nbsp;otherwise.
-
-
-
-
-
-<hr><h3><a name="lua_KContext"><code>lua_KContext</code></a></h3>
-<pre>typedef ... lua_KContext;</pre>
-
-<p>
-The type for continuation-function contexts.
-It must be a numeric type.
-This type is defined as <code>intptr_t</code>
-when <code>intptr_t</code> is available,
-so that it can store pointers too.
-Otherwise, it is defined as <code>ptrdiff_t</code>.
-
-
-
-
-
-<hr><h3><a name="lua_KFunction"><code>lua_KFunction</code></a></h3>
-<pre>typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);</pre>
-
-<p>
-Type for continuation functions (see <a href="#4.7">&sect;4.7</a>).
-
-
-
-
-
-<hr><h3><a name="lua_len"><code>lua_len</code></a></h3><p>
-<span class="apii">[-0, +1, <em>e</em>]</span>
-<pre>void lua_len (lua_State *L, int index);</pre>
-
-<p>
-Returns the length of the value at the given index.
-It is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.7">&sect;3.4.7</a>) and
-may trigger a metamethod for the "length" event (see <a href="#2.4">&sect;2.4</a>).
-The result is pushed on the stack.
-
-
-
-
-
-<hr><h3><a name="lua_load"><code>lua_load</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>int lua_load (lua_State *L,
-              lua_Reader reader,
-              void *data,
-              const char *chunkname,
-              const char *mode);</pre>
-
-<p>
-Loads a Lua chunk without running it.
-If there are no errors,
-<code>lua_load</code> pushes the compiled chunk as a Lua
-function on top of the stack.
-Otherwise, it pushes an error message.
-
-
-<p>
-The return values of <code>lua_load</code> are:
-
-<ul>
-
-<li><b><a href="#pdf-LUA_OK"><code>LUA_OK</code></a>: </b> no errors;</li>
-
-<li><b><a name="pdf-LUA_ERRSYNTAX"><code>LUA_ERRSYNTAX</code></a>: </b>
-syntax error during precompilation;</li>
-
-<li><b><a href="#pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>: </b>
-memory allocation (out-of-memory) error;</li>
-
-<li><b><a href="#pdf-LUA_ERRGCMM"><code>LUA_ERRGCMM</code></a>: </b>
-error while running a <code>__gc</code> metamethod.
-(This error has no relation with the chunk being loaded.
-It is generated by the garbage collector.)
-</li>
-
-</ul>
-
-<p>
-The <code>lua_load</code> function uses a user-supplied <code>reader</code> function
-to read the chunk (see <a href="#lua_Reader"><code>lua_Reader</code></a>).
-The <code>data</code> argument is an opaque value passed to the reader function.
-
-
-<p>
-The <code>chunkname</code> argument gives a name to the chunk,
-which is used for error messages and in debug information (see <a href="#4.9">&sect;4.9</a>).
-
-
-<p>
-<code>lua_load</code> automatically detects whether the chunk is text or binary
-and loads it accordingly (see program <code>luac</code>).
-The string <code>mode</code> works as in function <a href="#pdf-load"><code>load</code></a>,
-with the addition that
-a <code>NULL</code> value is equivalent to the string "<code>bt</code>".
-
-
-<p>
-<code>lua_load</code> uses the stack internally,
-so the reader function must always leave the stack
-unmodified when returning.
-
-
-<p>
-If the resulting function has upvalues,
-its first upvalue is set to the value of the global environment
-stored at index <code>LUA_RIDX_GLOBALS</code> in the registry (see <a href="#4.5">&sect;4.5</a>).
-When loading main chunks,
-this upvalue will be the <code>_ENV</code> variable (see <a href="#2.2">&sect;2.2</a>).
-Other upvalues are initialized with <b>nil</b>.
-
-
-
-
-
-<hr><h3><a name="lua_newstate"><code>lua_newstate</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>lua_State *lua_newstate (lua_Alloc f, void *ud);</pre>
-
-<p>
-Creates a new thread running in a new, independent state.
-Returns <code>NULL</code> if it cannot create the thread or the state
-(due to lack of memory).
-The argument <code>f</code> is the allocator function;
-Lua does all memory allocation for this state
-through this function (see <a href="#lua_Alloc"><code>lua_Alloc</code></a>).
-The second argument, <code>ud</code>, is an opaque pointer that Lua
-passes to the allocator in every call.
-
-
-
-
-
-<hr><h3><a name="lua_newtable"><code>lua_newtable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void lua_newtable (lua_State *L);</pre>
-
-<p>
-Creates a new empty table and pushes it onto the stack.
-It is equivalent to <code>lua_createtable(L, 0, 0)</code>.
-
-
-
-
-
-<hr><h3><a name="lua_newthread"><code>lua_newthread</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>lua_State *lua_newthread (lua_State *L);</pre>
-
-<p>
-Creates a new thread, pushes it on the stack,
-and returns a pointer to a <a href="#lua_State"><code>lua_State</code></a> that represents this new thread.
-The new thread returned by this function shares with the original thread
-its global environment,
-but has an independent execution stack.
-
-
-<p>
-There is no explicit function to close or to destroy a thread.
-Threads are subject to garbage collection,
-like any Lua object.
-
-
-
-
-
-<hr><h3><a name="lua_newuserdata"><code>lua_newuserdata</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void *lua_newuserdata (lua_State *L, size_t size);</pre>
-
-<p>
-This function allocates a new block of memory with the given size,
-pushes onto the stack a new full userdata with the block address,
-and returns this address.
-The host program can freely use this memory.
-
-
-
-
-
-<hr><h3><a name="lua_next"><code>lua_next</code></a></h3><p>
-<span class="apii">[-1, +(2|0), <em>e</em>]</span>
-<pre>int lua_next (lua_State *L, int index);</pre>
-
-<p>
-Pops a key from the stack,
-and pushes a key&ndash;value pair from the table at the given index
-(the "next" pair after the given key).
-If there are no more elements in the table,
-then <a href="#lua_next"><code>lua_next</code></a> returns 0 (and pushes nothing).
-
-
-<p>
-A typical traversal looks like this:
-
-<pre>
-     /* table is in the stack at index 't' */
-     lua_pushnil(L);  /* first key */
-     while (lua_next(L, t) != 0) {
-       /* uses 'key' (at index -2) and 'value' (at index -1) */
-       printf("%s - %s\n",
-              lua_typename(L, lua_type(L, -2)),
-              lua_typename(L, lua_type(L, -1)));
-       /* removes 'value'; keeps 'key' for next iteration */
-       lua_pop(L, 1);
-     }
-</pre>
-
-<p>
-While traversing a table,
-do not call <a href="#lua_tolstring"><code>lua_tolstring</code></a> directly on a key,
-unless you know that the key is actually a string.
-Recall that <a href="#lua_tolstring"><code>lua_tolstring</code></a> may change
-the value at the given index;
-this confuses the next call to <a href="#lua_next"><code>lua_next</code></a>.
-
-
-<p>
-See function <a href="#pdf-next"><code>next</code></a> for the caveats of modifying
-the table during its traversal.
-
-
-
-
-
-<hr><h3><a name="lua_Number"><code>lua_Number</code></a></h3>
-<pre>typedef ... lua_Number;</pre>
-
-<p>
-The type of floats in Lua.
-
-
-<p>
-By default this type is double,
-but that can be changed to a single float or a long double.
-(See <code>LUA_FLOAT_TYPE</code> in <code>luaconf.h</code>.)
-
-
-
-
-
-<hr><h3><a name="lua_numbertointeger"><code>lua_numbertointeger</code></a></h3>
-<pre>int lua_numbertointeger (lua_Number n, lua_Integer *p);</pre>
-
-<p>
-Converts a Lua float to a Lua integer.
-This macro assumes that <code>n</code> has an integral value.
-If that value is within the range of Lua integers,
-it is converted to an integer and assigned to <code>*p</code>.
-The macro results in a boolean indicating whether the
-conversion was successful.
-(Note that this range test can be tricky to do
-correctly without this macro,
-due to roundings.)
-
-
-<p>
-This macro may evaluate its arguments more than once.
-
-
-
-
-
-<hr><h3><a name="lua_pcall"><code>lua_pcall</code></a></h3><p>
-<span class="apii">[-(nargs + 1), +(nresults|1), &ndash;]</span>
-<pre>int lua_pcall (lua_State *L, int nargs, int nresults, int msgh);</pre>
-
-<p>
-Calls a function in protected mode.
-
-
-<p>
-Both <code>nargs</code> and <code>nresults</code> have the same meaning as
-in <a href="#lua_call"><code>lua_call</code></a>.
-If there are no errors during the call,
-<a href="#lua_pcall"><code>lua_pcall</code></a> behaves exactly like <a href="#lua_call"><code>lua_call</code></a>.
-However, if there is any error,
-<a href="#lua_pcall"><code>lua_pcall</code></a> catches it,
-pushes a single value on the stack (the error object),
-and returns an error code.
-Like <a href="#lua_call"><code>lua_call</code></a>,
-<a href="#lua_pcall"><code>lua_pcall</code></a> always removes the function
-and its arguments from the stack.
-
-
-<p>
-If <code>msgh</code> is 0,
-then the error object returned on the stack
-is exactly the original error object.
-Otherwise, <code>msgh</code> is the stack index of a
-<em>message handler</em>.
-(This index cannot be a pseudo-index.)
-In case of runtime errors,
-this function will be called with the error object
-and its return value will be the object
-returned on the stack by <a href="#lua_pcall"><code>lua_pcall</code></a>.
-
-
-<p>
-Typically, the message handler is used to add more debug
-information to the error object, such as a stack traceback.
-Such information cannot be gathered after the return of <a href="#lua_pcall"><code>lua_pcall</code></a>,
-since by then the stack has unwound.
-
-
-<p>
-The <a href="#lua_pcall"><code>lua_pcall</code></a> function returns one of the following constants
-(defined in <code>lua.h</code>):
-
-<ul>
-
-<li><b><a name="pdf-LUA_OK"><code>LUA_OK</code></a> (0): </b>
-success.</li>
-
-<li><b><a name="pdf-LUA_ERRRUN"><code>LUA_ERRRUN</code></a>: </b>
-a runtime error.
-</li>
-
-<li><b><a name="pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>: </b>
-memory allocation error.
-For such errors, Lua does not call the message handler.
-</li>
-
-<li><b><a name="pdf-LUA_ERRERR"><code>LUA_ERRERR</code></a>: </b>
-error while running the message handler.
-</li>
-
-<li><b><a name="pdf-LUA_ERRGCMM"><code>LUA_ERRGCMM</code></a>: </b>
-error while running a <code>__gc</code> metamethod.
-For such errors, Lua does not call the message handler
-(as this kind of error typically has no relation
-with the function being called).
-</li>
-
-</ul>
-
-
-
-
-<hr><h3><a name="lua_pcallk"><code>lua_pcallk</code></a></h3><p>
-<span class="apii">[-(nargs + 1), +(nresults|1), &ndash;]</span>
-<pre>int lua_pcallk (lua_State *L,
-                int nargs,
-                int nresults,
-                int msgh,
-                lua_KContext ctx,
-                lua_KFunction k);</pre>
-
-<p>
-This function behaves exactly like <a href="#lua_pcall"><code>lua_pcall</code></a>,
-but allows the called function to yield (see <a href="#4.7">&sect;4.7</a>).
-
-
-
-
-
-<hr><h3><a name="lua_pop"><code>lua_pop</code></a></h3><p>
-<span class="apii">[-n, +0, &ndash;]</span>
-<pre>void lua_pop (lua_State *L, int n);</pre>
-
-<p>
-Pops <code>n</code> elements from the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushboolean"><code>lua_pushboolean</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>void lua_pushboolean (lua_State *L, int b);</pre>
-
-<p>
-Pushes a boolean value with value <code>b</code> onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushcclosure"><code>lua_pushcclosure</code></a></h3><p>
-<span class="apii">[-n, +1, <em>m</em>]</span>
-<pre>void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);</pre>
-
-<p>
-Pushes a new C&nbsp;closure onto the stack.
-
-
-<p>
-When a C&nbsp;function is created,
-it is possible to associate some values with it,
-thus creating a C&nbsp;closure (see <a href="#4.4">&sect;4.4</a>);
-these values are then accessible to the function whenever it is called.
-To associate values with a C&nbsp;function,
-first these values must be pushed onto the stack
-(when there are multiple values, the first value is pushed first).
-Then <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>
-is called to create and push the C&nbsp;function onto the stack,
-with the argument <code>n</code> telling how many values will be
-associated with the function.
-<a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a> also pops these values from the stack.
-
-
-<p>
-The maximum value for <code>n</code> is 255.
-
-
-<p>
-When <code>n</code> is zero,
-this function creates a <em>light C&nbsp;function</em>,
-which is just a pointer to the C&nbsp;function.
-In that case, it never raises a memory error.
-
-
-
-
-
-<hr><h3><a name="lua_pushcfunction"><code>lua_pushcfunction</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>void lua_pushcfunction (lua_State *L, lua_CFunction f);</pre>
-
-<p>
-Pushes a C&nbsp;function onto the stack.
-This function receives a pointer to a C&nbsp;function
-and pushes onto the stack a Lua value of type <code>function</code> that,
-when called, invokes the corresponding C&nbsp;function.
-
-
-<p>
-Any function to be callable by Lua must
-follow the correct protocol to receive its parameters
-and return its results (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
-
-
-
-
-
-<hr><h3><a name="lua_pushfstring"><code>lua_pushfstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>e</em>]</span>
-<pre>const char *lua_pushfstring (lua_State *L, const char *fmt, ...);</pre>
-
-<p>
-Pushes onto the stack a formatted string
-and returns a pointer to this string.
-It is similar to the ISO&nbsp;C function <code>sprintf</code>,
-but has some important differences:
-
-<ul>
-
-<li>
-You do not have to allocate space for the result:
-the result is a Lua string and Lua takes care of memory allocation
-(and deallocation, through garbage collection).
-</li>
-
-<li>
-The conversion specifiers are quite restricted.
-There are no flags, widths, or precisions.
-The conversion specifiers can only be
-'<code>%%</code>' (inserts the character '<code>%</code>'),
-'<code>%s</code>' (inserts a zero-terminated string, with no size restrictions),
-'<code>%f</code>' (inserts a <a href="#lua_Number"><code>lua_Number</code></a>),
-'<code>%I</code>' (inserts a <a href="#lua_Integer"><code>lua_Integer</code></a>),
-'<code>%p</code>' (inserts a pointer as a hexadecimal numeral),
-'<code>%d</code>' (inserts an <code>int</code>),
-'<code>%c</code>' (inserts an <code>int</code> as a one-byte character), and
-'<code>%U</code>' (inserts a <code>long int</code> as a UTF-8 byte sequence).
-</li>
-
-</ul>
-
-<p>
-Unlike other push functions,
-this function checks for the stack space it needs,
-including the slot for its result.
-
-
-
-
-
-<hr><h3><a name="lua_pushglobaltable"><code>lua_pushglobaltable</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>void lua_pushglobaltable (lua_State *L);</pre>
-
-<p>
-Pushes the global environment onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushinteger"><code>lua_pushinteger</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>void lua_pushinteger (lua_State *L, lua_Integer n);</pre>
-
-<p>
-Pushes an integer with value <code>n</code> onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushlightuserdata"><code>lua_pushlightuserdata</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>void lua_pushlightuserdata (lua_State *L, void *p);</pre>
-
-<p>
-Pushes a light userdata onto the stack.
-
-
-<p>
-Userdata represent C&nbsp;values in Lua.
-A <em>light userdata</em> represents a pointer, a <code>void*</code>.
-It is a value (like a number):
-you do not create it, it has no individual metatable,
-and it is not collected (as it was never created).
-A light userdata is equal to "any"
-light userdata with the same C&nbsp;address.
-
-
-
-
-
-<hr><h3><a name="lua_pushliteral"><code>lua_pushliteral</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>const char *lua_pushliteral (lua_State *L, const char *s);</pre>
-
-<p>
-This macro is equivalent to <a href="#lua_pushstring"><code>lua_pushstring</code></a>,
-but should be used only when <code>s</code> is a literal string.
-
-
-
-
-
-<hr><h3><a name="lua_pushlstring"><code>lua_pushlstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>const char *lua_pushlstring (lua_State *L, const char *s, size_t len);</pre>
-
-<p>
-Pushes the string pointed to by <code>s</code> with size <code>len</code>
-onto the stack.
-Lua makes (or reuses) an internal copy of the given string,
-so the memory at <code>s</code> can be freed or reused immediately after
-the function returns.
-The string can contain any binary data,
-including embedded zeros.
-
-
-<p>
-Returns a pointer to the internal copy of the string.
-
-
-
-
-
-<hr><h3><a name="lua_pushnil"><code>lua_pushnil</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>void lua_pushnil (lua_State *L);</pre>
-
-<p>
-Pushes a nil value onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushnumber"><code>lua_pushnumber</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>void lua_pushnumber (lua_State *L, lua_Number n);</pre>
-
-<p>
-Pushes a float with value <code>n</code> onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushstring"><code>lua_pushstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>const char *lua_pushstring (lua_State *L, const char *s);</pre>
-
-<p>
-Pushes the zero-terminated string pointed to by <code>s</code>
-onto the stack.
-Lua makes (or reuses) an internal copy of the given string,
-so the memory at <code>s</code> can be freed or reused immediately after
-the function returns.
-
-
-<p>
-Returns a pointer to the internal copy of the string.
-
-
-<p>
-If <code>s</code> is <code>NULL</code>, pushes <b>nil</b> and returns <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_pushthread"><code>lua_pushthread</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>int lua_pushthread (lua_State *L);</pre>
-
-<p>
-Pushes the thread represented by <code>L</code> onto the stack.
-Returns 1 if this thread is the main thread of its state.
-
-
-
-
-
-<hr><h3><a name="lua_pushvalue"><code>lua_pushvalue</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>void lua_pushvalue (lua_State *L, int index);</pre>
-
-<p>
-Pushes a copy of the element at the given index
-onto the stack.
-
-
-
-
-
-<hr><h3><a name="lua_pushvfstring"><code>lua_pushvfstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>const char *lua_pushvfstring (lua_State *L,
-                              const char *fmt,
-                              va_list argp);</pre>
-
-<p>
-Equivalent to <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>, except that it receives a <code>va_list</code>
-instead of a variable number of arguments.
-
-
-
-
-
-<hr><h3><a name="lua_rawequal"><code>lua_rawequal</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_rawequal (lua_State *L, int index1, int index2);</pre>
-
-<p>
-Returns 1 if the two values in indices <code>index1</code> and
-<code>index2</code> are primitively equal
-(that is, without calling the <code>__eq</code> metamethod).
-Otherwise returns&nbsp;0.
-Also returns&nbsp;0 if any of the indices are not valid.
-
-
-
-
-
-<hr><h3><a name="lua_rawget"><code>lua_rawget</code></a></h3><p>
-<span class="apii">[-1, +1, &ndash;]</span>
-<pre>int lua_rawget (lua_State *L, int index);</pre>
-
-<p>
-Similar to <a href="#lua_gettable"><code>lua_gettable</code></a>, but does a raw access
-(i.e., without metamethods).
-
-
-
-
-
-<hr><h3><a name="lua_rawgeti"><code>lua_rawgeti</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>int lua_rawgeti (lua_State *L, int index, lua_Integer n);</pre>
-
-<p>
-Pushes onto the stack the value <code>t[n]</code>,
-where <code>t</code> is the table at the given index.
-The access is raw,
-that is, it does not invoke the <code>__index</code> metamethod.
-
-
-<p>
-Returns the type of the pushed value.
-
-
-
-
-
-<hr><h3><a name="lua_rawgetp"><code>lua_rawgetp</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>int lua_rawgetp (lua_State *L, int index, const void *p);</pre>
-
-<p>
-Pushes onto the stack the value <code>t[k]</code>,
-where <code>t</code> is the table at the given index and
-<code>k</code> is the pointer <code>p</code> represented as a light userdata.
-The access is raw;
-that is, it does not invoke the <code>__index</code> metamethod.
-
-
-<p>
-Returns the type of the pushed value.
-
-
-
-
-
-<hr><h3><a name="lua_rawlen"><code>lua_rawlen</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>size_t lua_rawlen (lua_State *L, int index);</pre>
-
-<p>
-Returns the raw "length" of the value at the given index:
-for strings, this is the string length;
-for tables, this is the result of the length operator ('<code>#</code>')
-with no metamethods;
-for userdata, this is the size of the block of memory allocated
-for the userdata;
-for other values, it is&nbsp;0.
-
-
-
-
-
-<hr><h3><a name="lua_rawset"><code>lua_rawset</code></a></h3><p>
-<span class="apii">[-2, +0, <em>m</em>]</span>
-<pre>void lua_rawset (lua_State *L, int index);</pre>
-
-<p>
-Similar to <a href="#lua_settable"><code>lua_settable</code></a>, but does a raw assignment
-(i.e., without metamethods).
-
-
-
-
-
-<hr><h3><a name="lua_rawseti"><code>lua_rawseti</code></a></h3><p>
-<span class="apii">[-1, +0, <em>m</em>]</span>
-<pre>void lua_rawseti (lua_State *L, int index, lua_Integer i);</pre>
-
-<p>
-Does the equivalent of <code>t[i] = v</code>,
-where <code>t</code> is the table at the given index
-and <code>v</code> is the value at the top of the stack.
-
-
-<p>
-This function pops the value from the stack.
-The assignment is raw,
-that is, it does not invoke the <code>__newindex</code> metamethod.
-
-
-
-
-
-<hr><h3><a name="lua_rawsetp"><code>lua_rawsetp</code></a></h3><p>
-<span class="apii">[-1, +0, <em>m</em>]</span>
-<pre>void lua_rawsetp (lua_State *L, int index, const void *p);</pre>
-
-<p>
-Does the equivalent of <code>t[p] = v</code>,
-where <code>t</code> is the table at the given index,
-<code>p</code> is encoded as a light userdata,
-and <code>v</code> is the value at the top of the stack.
-
-
-<p>
-This function pops the value from the stack.
-The assignment is raw,
-that is, it does not invoke <code>__newindex</code> metamethod.
-
-
-
-
-
-<hr><h3><a name="lua_Reader"><code>lua_Reader</code></a></h3>
-<pre>typedef const char * (*lua_Reader) (lua_State *L,
-                                    void *data,
-                                    size_t *size);</pre>
-
-<p>
-The reader function used by <a href="#lua_load"><code>lua_load</code></a>.
-Every time it needs another piece of the chunk,
-<a href="#lua_load"><code>lua_load</code></a> calls the reader,
-passing along its <code>data</code> parameter.
-The reader must return a pointer to a block of memory
-with a new piece of the chunk
-and set <code>size</code> to the block size.
-The block must exist until the reader function is called again.
-To signal the end of the chunk,
-the reader must return <code>NULL</code> or set <code>size</code> to zero.
-The reader function may return pieces of any size greater than zero.
-
-
-
-
-
-<hr><h3><a name="lua_register"><code>lua_register</code></a></h3><p>
-<span class="apii">[-0, +0, <em>e</em>]</span>
-<pre>void lua_register (lua_State *L, const char *name, lua_CFunction f);</pre>
-
-<p>
-Sets the C&nbsp;function <code>f</code> as the new value of global <code>name</code>.
-It is defined as a macro:
-
-<pre>
-     #define lua_register(L,n,f) \
-            (lua_pushcfunction(L, f), lua_setglobal(L, n))
-</pre>
-
-
-
-
-<hr><h3><a name="lua_remove"><code>lua_remove</code></a></h3><p>
-<span class="apii">[-1, +0, &ndash;]</span>
-<pre>void lua_remove (lua_State *L, int index);</pre>
-
-<p>
-Removes the element at the given valid index,
-shifting down the elements above this index to fill the gap.
-This function cannot be called with a pseudo-index,
-because a pseudo-index is not an actual stack position.
-
-
-
-
-
-<hr><h3><a name="lua_replace"><code>lua_replace</code></a></h3><p>
-<span class="apii">[-1, +0, &ndash;]</span>
-<pre>void lua_replace (lua_State *L, int index);</pre>
-
-<p>
-Moves the top element into the given valid index
-without shifting any element
-(therefore replacing the value at that given index),
-and then pops the top element.
-
-
-
-
-
-<hr><h3><a name="lua_resume"><code>lua_resume</code></a></h3><p>
-<span class="apii">[-?, +?, &ndash;]</span>
-<pre>int lua_resume (lua_State *L, lua_State *from, int nargs);</pre>
-
-<p>
-Starts and resumes a coroutine in the given thread <code>L</code>.
-
-
-<p>
-To start a coroutine,
-you push onto the thread stack the main function plus any arguments;
-then you call <a href="#lua_resume"><code>lua_resume</code></a>,
-with <code>nargs</code> being the number of arguments.
-This call returns when the coroutine suspends or finishes its execution.
-When it returns, the stack contains all values passed to <a href="#lua_yield"><code>lua_yield</code></a>,
-or all values returned by the body function.
-<a href="#lua_resume"><code>lua_resume</code></a> returns
-<a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> if the coroutine yields,
-<a href="#pdf-LUA_OK"><code>LUA_OK</code></a> if the coroutine finishes its execution
-without errors,
-or an error code in case of errors (see <a href="#lua_pcall"><code>lua_pcall</code></a>).
-
-
-<p>
-In case of errors,
-the stack is not unwound,
-so you can use the debug API over it.
-The error object is on the top of the stack.
-
-
-<p>
-To resume a coroutine,
-you remove any results from the last <a href="#lua_yield"><code>lua_yield</code></a>,
-put on its stack only the values to
-be passed as results from <code>yield</code>,
-and then call <a href="#lua_resume"><code>lua_resume</code></a>.
-
-
-<p>
-The parameter <code>from</code> represents the coroutine that is resuming <code>L</code>.
-If there is no such coroutine,
-this parameter can be <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_rotate"><code>lua_rotate</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>void lua_rotate (lua_State *L, int idx, int n);</pre>
-
-<p>
-Rotates the stack elements between the valid index <code>idx</code>
-and the top of the stack.
-The elements are rotated <code>n</code> positions in the direction of the top,
-for a positive <code>n</code>,
-or <code>-n</code> positions in the direction of the bottom,
-for a negative <code>n</code>.
-The absolute value of <code>n</code> must not be greater than the size
-of the slice being rotated.
-This function cannot be called with a pseudo-index,
-because a pseudo-index is not an actual stack position.
-
-
-
-
-
-<hr><h3><a name="lua_setallocf"><code>lua_setallocf</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);</pre>
-
-<p>
-Changes the allocator function of a given state to <code>f</code>
-with user data <code>ud</code>.
-
-
-
-
-
-<hr><h3><a name="lua_setfield"><code>lua_setfield</code></a></h3><p>
-<span class="apii">[-1, +0, <em>e</em>]</span>
-<pre>void lua_setfield (lua_State *L, int index, const char *k);</pre>
-
-<p>
-Does the equivalent to <code>t[k] = v</code>,
-where <code>t</code> is the value at the given index
-and <code>v</code> is the value at the top of the stack.
-
-
-<p>
-This function pops the value from the stack.
-As in Lua, this function may trigger a metamethod
-for the "newindex" event (see <a href="#2.4">&sect;2.4</a>).
-
-
-
-
-
-<hr><h3><a name="lua_setglobal"><code>lua_setglobal</code></a></h3><p>
-<span class="apii">[-1, +0, <em>e</em>]</span>
-<pre>void lua_setglobal (lua_State *L, const char *name);</pre>
-
-<p>
-Pops a value from the stack and
-sets it as the new value of global <code>name</code>.
-
-
-
-
-
-<hr><h3><a name="lua_seti"><code>lua_seti</code></a></h3><p>
-<span class="apii">[-1, +0, <em>e</em>]</span>
-<pre>void lua_seti (lua_State *L, int index, lua_Integer n);</pre>
-
-<p>
-Does the equivalent to <code>t[n] = v</code>,
-where <code>t</code> is the value at the given index
-and <code>v</code> is the value at the top of the stack.
-
-
-<p>
-This function pops the value from the stack.
-As in Lua, this function may trigger a metamethod
-for the "newindex" event (see <a href="#2.4">&sect;2.4</a>).
-
-
-
-
-
-<hr><h3><a name="lua_setmetatable"><code>lua_setmetatable</code></a></h3><p>
-<span class="apii">[-1, +0, &ndash;]</span>
-<pre>void lua_setmetatable (lua_State *L, int index);</pre>
-
-<p>
-Pops a table from the stack and
-sets it as the new metatable for the value at the given index.
-
-
-
-
-
-<hr><h3><a name="lua_settable"><code>lua_settable</code></a></h3><p>
-<span class="apii">[-2, +0, <em>e</em>]</span>
-<pre>void lua_settable (lua_State *L, int index);</pre>
-
-<p>
-Does the equivalent to <code>t[k] = v</code>,
-where <code>t</code> is the value at the given index,
-<code>v</code> is the value at the top of the stack,
-and <code>k</code> is the value just below the top.
-
-
-<p>
-This function pops both the key and the value from the stack.
-As in Lua, this function may trigger a metamethod
-for the "newindex" event (see <a href="#2.4">&sect;2.4</a>).
-
-
-
-
-
-<hr><h3><a name="lua_settop"><code>lua_settop</code></a></h3><p>
-<span class="apii">[-?, +?, &ndash;]</span>
-<pre>void lua_settop (lua_State *L, int index);</pre>
-
-<p>
-Accepts any index, or&nbsp;0,
-and sets the stack top to this index.
-If the new top is larger than the old one,
-then the new elements are filled with <b>nil</b>.
-If <code>index</code> is&nbsp;0, then all stack elements are removed.
-
-
-
-
-
-<hr><h3><a name="lua_setuservalue"><code>lua_setuservalue</code></a></h3><p>
-<span class="apii">[-1, +0, &ndash;]</span>
-<pre>void lua_setuservalue (lua_State *L, int index);</pre>
-
-<p>
-Pops a value from the stack and sets it as
-the new value associated to the full userdata at the given index.
-
-
-
-
-
-<hr><h3><a name="lua_State"><code>lua_State</code></a></h3>
-<pre>typedef struct lua_State lua_State;</pre>
-
-<p>
-An opaque structure that points to a thread and indirectly
-(through the thread) to the whole state of a Lua interpreter.
-The Lua library is fully reentrant:
-it has no global variables.
-All information about a state is accessible through this structure.
-
-
-<p>
-A pointer to this structure must be passed as the first argument to
-every function in the library, except to <a href="#lua_newstate"><code>lua_newstate</code></a>,
-which creates a Lua state from scratch.
-
-
-
-
-
-<hr><h3><a name="lua_status"><code>lua_status</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_status (lua_State *L);</pre>
-
-<p>
-Returns the status of the thread <code>L</code>.
-
-
-<p>
-The status can be 0 (<a href="#pdf-LUA_OK"><code>LUA_OK</code></a>) for a normal thread,
-an error code if the thread finished the execution
-of a <a href="#lua_resume"><code>lua_resume</code></a> with an error,
-or <a name="pdf-LUA_YIELD"><code>LUA_YIELD</code></a> if the thread is suspended.
-
-
-<p>
-You can only call functions in threads with status <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>.
-You can resume threads with status <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>
-(to start a new coroutine) or <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a>
-(to resume a coroutine).
-
-
-
-
-
-<hr><h3><a name="lua_stringtonumber"><code>lua_stringtonumber</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>size_t lua_stringtonumber (lua_State *L, const char *s);</pre>
-
-<p>
-Converts the zero-terminated string <code>s</code> to a number,
-pushes that number into the stack,
-and returns the total size of the string,
-that is, its length plus one.
-The conversion can result in an integer or a float,
-according to the lexical conventions of Lua (see <a href="#3.1">&sect;3.1</a>).
-The string may have leading and trailing spaces and a sign.
-If the string is not a valid numeral,
-returns 0 and pushes nothing.
-(Note that the result can be used as a boolean,
-true if the conversion succeeds.)
-
-
-
-
-
-<hr><h3><a name="lua_toboolean"><code>lua_toboolean</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_toboolean (lua_State *L, int index);</pre>
-
-<p>
-Converts the Lua value at the given index to a C&nbsp;boolean
-value (0&nbsp;or&nbsp;1).
-Like all tests in Lua,
-<a href="#lua_toboolean"><code>lua_toboolean</code></a> returns true for any Lua value
-different from <b>false</b> and <b>nil</b>;
-otherwise it returns false.
-(If you want to accept only actual boolean values,
-use <a href="#lua_isboolean"><code>lua_isboolean</code></a> to test the value's type.)
-
-
-
-
-
-<hr><h3><a name="lua_tocfunction"><code>lua_tocfunction</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>lua_CFunction lua_tocfunction (lua_State *L, int index);</pre>
-
-<p>
-Converts a value at the given index to a C&nbsp;function.
-That value must be a C&nbsp;function;
-otherwise, returns <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_tointeger"><code>lua_tointeger</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>lua_Integer lua_tointeger (lua_State *L, int index);</pre>
-
-<p>
-Equivalent to <a href="#lua_tointegerx"><code>lua_tointegerx</code></a> with <code>isnum</code> equal to <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_tointegerx"><code>lua_tointegerx</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>lua_Integer lua_tointegerx (lua_State *L, int index, int *isnum);</pre>
-
-<p>
-Converts the Lua value at the given index
-to the signed integral type <a href="#lua_Integer"><code>lua_Integer</code></a>.
-The Lua value must be an integer,
-or a number or string convertible to an integer (see <a href="#3.4.3">&sect;3.4.3</a>);
-otherwise, <code>lua_tointegerx</code> returns&nbsp;0.
-
-
-<p>
-If <code>isnum</code> is not <code>NULL</code>,
-its referent is assigned a boolean value that
-indicates whether the operation succeeded.
-
-
-
-
-
-<hr><h3><a name="lua_tolstring"><code>lua_tolstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>const char *lua_tolstring (lua_State *L, int index, size_t *len);</pre>
-
-<p>
-Converts the Lua value at the given index to a C&nbsp;string.
-If <code>len</code> is not <code>NULL</code>,
-it sets <code>*len</code> with the string length.
-The Lua value must be a string or a number;
-otherwise, the function returns <code>NULL</code>.
-If the value is a number,
-then <code>lua_tolstring</code> also
-<em>changes the actual value in the stack to a string</em>.
-(This change confuses <a href="#lua_next"><code>lua_next</code></a>
-when <code>lua_tolstring</code> is applied to keys during a table traversal.)
-
-
-<p>
-<code>lua_tolstring</code> returns a pointer
-to a string inside the Lua state.
-This string always has a zero ('<code>\0</code>')
-after its last character (as in&nbsp;C),
-but can contain other zeros in its body.
-
-
-<p>
-Because Lua has garbage collection,
-there is no guarantee that the pointer returned by <code>lua_tolstring</code>
-will be valid after the corresponding Lua value is removed from the stack.
-
-
-
-
-
-<hr><h3><a name="lua_tonumber"><code>lua_tonumber</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>lua_Number lua_tonumber (lua_State *L, int index);</pre>
-
-<p>
-Equivalent to <a href="#lua_tonumberx"><code>lua_tonumberx</code></a> with <code>isnum</code> equal to <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_tonumberx"><code>lua_tonumberx</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>lua_Number lua_tonumberx (lua_State *L, int index, int *isnum);</pre>
-
-<p>
-Converts the Lua value at the given index
-to the C&nbsp;type <a href="#lua_Number"><code>lua_Number</code></a> (see <a href="#lua_Number"><code>lua_Number</code></a>).
-The Lua value must be a number or a string convertible to a number
-(see <a href="#3.4.3">&sect;3.4.3</a>);
-otherwise, <a href="#lua_tonumberx"><code>lua_tonumberx</code></a> returns&nbsp;0.
-
-
-<p>
-If <code>isnum</code> is not <code>NULL</code>,
-its referent is assigned a boolean value that
-indicates whether the operation succeeded.
-
-
-
-
-
-<hr><h3><a name="lua_topointer"><code>lua_topointer</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>const void *lua_topointer (lua_State *L, int index);</pre>
-
-<p>
-Converts the value at the given index to a generic
-C&nbsp;pointer (<code>void*</code>).
-The value can be a userdata, a table, a thread, or a function;
-otherwise, <code>lua_topointer</code> returns <code>NULL</code>.
-Different objects will give different pointers.
-There is no way to convert the pointer back to its original value.
-
-
-<p>
-Typically this function is used only for hashing and debug information.
-
-
-
-
-
-<hr><h3><a name="lua_tostring"><code>lua_tostring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>const char *lua_tostring (lua_State *L, int index);</pre>
-
-<p>
-Equivalent to <a href="#lua_tolstring"><code>lua_tolstring</code></a> with <code>len</code> equal to <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_tothread"><code>lua_tothread</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>lua_State *lua_tothread (lua_State *L, int index);</pre>
-
-<p>
-Converts the value at the given index to a Lua thread
-(represented as <code>lua_State*</code>).
-This value must be a thread;
-otherwise, the function returns <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_touserdata"><code>lua_touserdata</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>void *lua_touserdata (lua_State *L, int index);</pre>
-
-<p>
-If the value at the given index is a full userdata,
-returns its block address.
-If the value is a light userdata,
-returns its pointer.
-Otherwise, returns <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="lua_type"><code>lua_type</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_type (lua_State *L, int index);</pre>
-
-<p>
-Returns the type of the value in the given valid index,
-or <code>LUA_TNONE</code> for a non-valid (but acceptable) index.
-The types returned by <a href="#lua_type"><code>lua_type</code></a> are coded by the following constants
-defined in <code>lua.h</code>:
-<a name="pdf-LUA_TNIL"><code>LUA_TNIL</code></a> (0),
-<a name="pdf-LUA_TNUMBER"><code>LUA_TNUMBER</code></a>,
-<a name="pdf-LUA_TBOOLEAN"><code>LUA_TBOOLEAN</code></a>,
-<a name="pdf-LUA_TSTRING"><code>LUA_TSTRING</code></a>,
-<a name="pdf-LUA_TTABLE"><code>LUA_TTABLE</code></a>,
-<a name="pdf-LUA_TFUNCTION"><code>LUA_TFUNCTION</code></a>,
-<a name="pdf-LUA_TUSERDATA"><code>LUA_TUSERDATA</code></a>,
-<a name="pdf-LUA_TTHREAD"><code>LUA_TTHREAD</code></a>,
-and
-<a name="pdf-LUA_TLIGHTUSERDATA"><code>LUA_TLIGHTUSERDATA</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_typename"><code>lua_typename</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>const char *lua_typename (lua_State *L, int tp);</pre>
-
-<p>
-Returns the name of the type encoded by the value <code>tp</code>,
-which must be one the values returned by <a href="#lua_type"><code>lua_type</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_Unsigned"><code>lua_Unsigned</code></a></h3>
-<pre>typedef ... lua_Unsigned;</pre>
-
-<p>
-The unsigned version of <a href="#lua_Integer"><code>lua_Integer</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_upvalueindex"><code>lua_upvalueindex</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_upvalueindex (int i);</pre>
-
-<p>
-Returns the pseudo-index that represents the <code>i</code>-th upvalue of
-the running function (see <a href="#4.4">&sect;4.4</a>).
-
-
-
-
-
-<hr><h3><a name="lua_version"><code>lua_version</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>const lua_Number *lua_version (lua_State *L);</pre>
-
-<p>
-Returns the address of the version number
-(a C static variable)
-stored in the Lua core.
-When called with a valid <a href="#lua_State"><code>lua_State</code></a>,
-returns the address of the version used to create that state.
-When called with <code>NULL</code>,
-returns the address of the version running the call.
-
-
-
-
-
-<hr><h3><a name="lua_Writer"><code>lua_Writer</code></a></h3>
-<pre>typedef int (*lua_Writer) (lua_State *L,
-                           const void* p,
-                           size_t sz,
-                           void* ud);</pre>
-
-<p>
-The type of the writer function used by <a href="#lua_dump"><code>lua_dump</code></a>.
-Every time it produces another piece of chunk,
-<a href="#lua_dump"><code>lua_dump</code></a> calls the writer,
-passing along the buffer to be written (<code>p</code>),
-its size (<code>sz</code>),
-and the <code>data</code> parameter supplied to <a href="#lua_dump"><code>lua_dump</code></a>.
-
-
-<p>
-The writer returns an error code:
-0&nbsp;means no errors;
-any other value means an error and stops <a href="#lua_dump"><code>lua_dump</code></a> from
-calling the writer again.
-
-
-
-
-
-<hr><h3><a name="lua_xmove"><code>lua_xmove</code></a></h3><p>
-<span class="apii">[-?, +?, &ndash;]</span>
-<pre>void lua_xmove (lua_State *from, lua_State *to, int n);</pre>
-
-<p>
-Exchange values between different threads of the same state.
-
-
-<p>
-This function pops <code>n</code> values from the stack <code>from</code>,
-and pushes them onto the stack <code>to</code>.
-
-
-
-
-
-<hr><h3><a name="lua_yield"><code>lua_yield</code></a></h3><p>
-<span class="apii">[-?, +?, <em>e</em>]</span>
-<pre>int lua_yield (lua_State *L, int nresults);</pre>
-
-<p>
-This function is equivalent to <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
-but it has no continuation (see <a href="#4.7">&sect;4.7</a>).
-Therefore, when the thread resumes,
-it continues the function that called
-the function calling <code>lua_yield</code>.
-
-
-
-
-
-<hr><h3><a name="lua_yieldk"><code>lua_yieldk</code></a></h3><p>
-<span class="apii">[-?, +?, <em>e</em>]</span>
-<pre>int lua_yieldk (lua_State *L,
-                int nresults,
-                lua_KContext ctx,
-                lua_KFunction k);</pre>
-
-<p>
-Yields a coroutine (thread).
-
-
-<p>
-When a C&nbsp;function calls <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
-the running coroutine suspends its execution,
-and the call to <a href="#lua_resume"><code>lua_resume</code></a> that started this coroutine returns.
-The parameter <code>nresults</code> is the number of values from the stack
-that will be passed as results to <a href="#lua_resume"><code>lua_resume</code></a>.
-
-
-<p>
-When the coroutine is resumed again,
-Lua calls the given continuation function <code>k</code> to continue
-the execution of the C&nbsp;function that yielded (see <a href="#4.7">&sect;4.7</a>).
-This continuation function receives the same stack
-from the previous function,
-with the <code>n</code> results removed and
-replaced by the arguments passed to <a href="#lua_resume"><code>lua_resume</code></a>.
-Moreover,
-the continuation function receives the value <code>ctx</code>
-that was passed to <a href="#lua_yieldk"><code>lua_yieldk</code></a>.
-
-
-<p>
-Usually, this function does not return;
-when the coroutine eventually resumes,
-it continues executing the continuation function.
-However, there is one special case,
-which is when this function is called
-from inside a line or a count hook (see <a href="#4.9">&sect;4.9</a>).
-In that case, <code>lua_yieldk</code> should be called with no continuation
-(probably in the form of <a href="#lua_yield"><code>lua_yield</code></a>) and no results,
-and the hook should return immediately after the call.
-Lua will yield and,
-when the coroutine resumes again,
-it will continue the normal execution
-of the (Lua) function that triggered the hook.
-
-
-<p>
-This function can raise an error if it is called from a thread
-with a pending C call with no continuation function,
-or it is called from a thread that is not running inside a resume
-(e.g., the main thread).
-
-
-
-
-
-
-
-<h2>4.9 &ndash; <a name="4.9">The Debug Interface</a></h2>
-
-<p>
-Lua has no built-in debugging facilities.
-Instead, it offers a special interface
-by means of functions and <em>hooks</em>.
-This interface allows the construction of different
-kinds of debuggers, profilers, and other tools
-that need "inside information" from the interpreter.
-
-
-
-<hr><h3><a name="lua_Debug"><code>lua_Debug</code></a></h3>
-<pre>typedef struct lua_Debug {
-  int event;
-  const char *name;           /* (n) */
-  const char *namewhat;       /* (n) */
-  const char *what;           /* (S) */
-  const char *source;         /* (S) */
-  int currentline;            /* (l) */
-  int linedefined;            /* (S) */
-  int lastlinedefined;        /* (S) */
-  unsigned char nups;         /* (u) number of upvalues */
-  unsigned char nparams;      /* (u) number of parameters */
-  char isvararg;              /* (u) */
-  char istailcall;            /* (t) */
-  char short_src[LUA_IDSIZE]; /* (S) */
-  /* private part */
-  <em>other fields</em>
-} lua_Debug;</pre>
-
-<p>
-A structure used to carry different pieces of
-information about a function or an activation record.
-<a href="#lua_getstack"><code>lua_getstack</code></a> fills only the private part
-of this structure, for later use.
-To fill the other fields of <a href="#lua_Debug"><code>lua_Debug</code></a> with useful information,
-call <a href="#lua_getinfo"><code>lua_getinfo</code></a>.
-
-
-<p>
-The fields of <a href="#lua_Debug"><code>lua_Debug</code></a> have the following meaning:
-
-<ul>
-
-<li><b><code>source</code>: </b>
-the name of the chunk that created the function.
-If <code>source</code> starts with a '<code>@</code>',
-it means that the function was defined in a file where
-the file name follows the '<code>@</code>'.
-If <code>source</code> starts with a '<code>=</code>',
-the remainder of its contents describe the source in a user-dependent manner.
-Otherwise,
-the function was defined in a string where
-<code>source</code> is that string.
-</li>
-
-<li><b><code>short_src</code>: </b>
-a "printable" version of <code>source</code>, to be used in error messages.
-</li>
-
-<li><b><code>linedefined</code>: </b>
-the line number where the definition of the function starts.
-</li>
-
-<li><b><code>lastlinedefined</code>: </b>
-the line number where the definition of the function ends.
-</li>
-
-<li><b><code>what</code>: </b>
-the string <code>"Lua"</code> if the function is a Lua function,
-<code>"C"</code> if it is a C&nbsp;function,
-<code>"main"</code> if it is the main part of a chunk.
-</li>
-
-<li><b><code>currentline</code>: </b>
-the current line where the given function is executing.
-When no line information is available,
-<code>currentline</code> is set to -1.
-</li>
-
-<li><b><code>name</code>: </b>
-a reasonable name for the given function.
-Because functions in Lua are first-class values,
-they do not have a fixed name:
-some functions can be the value of multiple global variables,
-while others can be stored only in a table field.
-The <code>lua_getinfo</code> function checks how the function was
-called to find a suitable name.
-If it cannot find a name,
-then <code>name</code> is set to <code>NULL</code>.
-</li>
-
-<li><b><code>namewhat</code>: </b>
-explains the <code>name</code> field.
-The value of <code>namewhat</code> can be
-<code>"global"</code>, <code>"local"</code>, <code>"method"</code>,
-<code>"field"</code>, <code>"upvalue"</code>, or <code>""</code> (the empty string),
-according to how the function was called.
-(Lua uses the empty string when no other option seems to apply.)
-</li>
-
-<li><b><code>istailcall</code>: </b>
-true if this function invocation was called by a tail call.
-In this case, the caller of this level is not in the stack.
-</li>
-
-<li><b><code>nups</code>: </b>
-the number of upvalues of the function.
-</li>
-
-<li><b><code>nparams</code>: </b>
-the number of fixed parameters of the function
-(always 0&nbsp;for C&nbsp;functions).
-</li>
-
-<li><b><code>isvararg</code>: </b>
-true if the function is a vararg function
-(always true for C&nbsp;functions).
-</li>
-
-</ul>
-
-
-
-
-<hr><h3><a name="lua_gethook"><code>lua_gethook</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>lua_Hook lua_gethook (lua_State *L);</pre>
-
-<p>
-Returns the current hook function.
-
-
-
-
-
-<hr><h3><a name="lua_gethookcount"><code>lua_gethookcount</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_gethookcount (lua_State *L);</pre>
-
-<p>
-Returns the current hook count.
-
-
-
-
-
-<hr><h3><a name="lua_gethookmask"><code>lua_gethookmask</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_gethookmask (lua_State *L);</pre>
-
-<p>
-Returns the current hook mask.
-
-
-
-
-
-<hr><h3><a name="lua_getinfo"><code>lua_getinfo</code></a></h3><p>
-<span class="apii">[-(0|1), +(0|1|2), <em>e</em>]</span>
-<pre>int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);</pre>
-
-<p>
-Gets information about a specific function or function invocation.
-
-
-<p>
-To get information about a function invocation,
-the parameter <code>ar</code> must be a valid activation record that was
-filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or
-given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>).
-
-
-<p>
-To get information about a function, you push it onto the stack
-and start the <code>what</code> string with the character '<code>&gt;</code>'.
-(In that case,
-<code>lua_getinfo</code> pops the function from the top of the stack.)
-For instance, to know in which line a function <code>f</code> was defined,
-you can write the following code:
-
-<pre>
-     lua_Debug ar;
-     lua_getglobal(L, "f");  /* get global 'f' */
-     lua_getinfo(L, "&gt;S", &amp;ar);
-     printf("%d\n", ar.linedefined);
-</pre>
-
-<p>
-Each character in the string <code>what</code>
-selects some fields of the structure <code>ar</code> to be filled or
-a value to be pushed on the stack:
-
-<ul>
-
-<li><b>'<code>n</code>': </b> fills in the field <code>name</code> and <code>namewhat</code>;
-</li>
-
-<li><b>'<code>S</code>': </b>
-fills in the fields <code>source</code>, <code>short_src</code>,
-<code>linedefined</code>, <code>lastlinedefined</code>, and <code>what</code>;
-</li>
-
-<li><b>'<code>l</code>': </b> fills in the field <code>currentline</code>;
-</li>
-
-<li><b>'<code>t</code>': </b> fills in the field <code>istailcall</code>;
-</li>
-
-<li><b>'<code>u</code>': </b> fills in the fields
-<code>nups</code>, <code>nparams</code>, and <code>isvararg</code>;
-</li>
-
-<li><b>'<code>f</code>': </b>
-pushes onto the stack the function that is
-running at the given level;
-</li>
-
-<li><b>'<code>L</code>': </b>
-pushes onto the stack a table whose indices are the
-numbers of the lines that are valid on the function.
-(A <em>valid line</em> is a line with some associated code,
-that is, a line where you can put a break point.
-Non-valid lines include empty lines and comments.)
-
-
-<p>
-If this option is given together with option '<code>f</code>',
-its table is pushed after the function.
-</li>
-
-</ul>
-
-<p>
-This function returns 0 on error
-(for instance, an invalid option in <code>what</code>).
-
-
-
-
-
-<hr><h3><a name="lua_getlocal"><code>lua_getlocal</code></a></h3><p>
-<span class="apii">[-0, +(0|1), &ndash;]</span>
-<pre>const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);</pre>
-
-<p>
-Gets information about a local variable of
-a given activation record or a given function.
-
-
-<p>
-In the first case,
-the parameter <code>ar</code> must be a valid activation record that was
-filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or
-given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>).
-The index <code>n</code> selects which local variable to inspect;
-see <a href="#pdf-debug.getlocal"><code>debug.getlocal</code></a> for details about variable indices
-and names.
-
-
-<p>
-<a href="#lua_getlocal"><code>lua_getlocal</code></a> pushes the variable's value onto the stack
-and returns its name.
-
-
-<p>
-In the second case, <code>ar</code> must be <code>NULL</code> and the function
-to be inspected must be at the top of the stack.
-In this case, only parameters of Lua functions are visible
-(as there is no information about what variables are active)
-and no values are pushed onto the stack.
-
-
-<p>
-Returns <code>NULL</code> (and pushes nothing)
-when the index is greater than
-the number of active local variables.
-
-
-
-
-
-<hr><h3><a name="lua_getstack"><code>lua_getstack</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>int lua_getstack (lua_State *L, int level, lua_Debug *ar);</pre>
-
-<p>
-Gets information about the interpreter runtime stack.
-
-
-<p>
-This function fills parts of a <a href="#lua_Debug"><code>lua_Debug</code></a> structure with
-an identification of the <em>activation record</em>
-of the function executing at a given level.
-Level&nbsp;0 is the current running function,
-whereas level <em>n+1</em> is the function that has called level <em>n</em>
-(except for tail calls, which do not count on the stack).
-When there are no errors, <a href="#lua_getstack"><code>lua_getstack</code></a> returns 1;
-when called with a level greater than the stack depth,
-it returns 0.
-
-
-
-
-
-<hr><h3><a name="lua_getupvalue"><code>lua_getupvalue</code></a></h3><p>
-<span class="apii">[-0, +(0|1), &ndash;]</span>
-<pre>const char *lua_getupvalue (lua_State *L, int funcindex, int n);</pre>
-
-<p>
-Gets information about the <code>n</code>-th upvalue
-of the closure at index <code>funcindex</code>.
-It pushes the upvalue's value onto the stack
-and returns its name.
-Returns <code>NULL</code> (and pushes nothing)
-when the index <code>n</code> is greater than the number of upvalues.
-
-
-<p>
-For C&nbsp;functions, this function uses the empty string <code>""</code>
-as a name for all upvalues.
-(For Lua functions,
-upvalues are the external local variables that the function uses,
-and that are consequently included in its closure.)
-
-
-<p>
-Upvalues have no particular order,
-as they are active through the whole function.
-They are numbered in an arbitrary order.
-
-
-
-
-
-<hr><h3><a name="lua_Hook"><code>lua_Hook</code></a></h3>
-<pre>typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);</pre>
-
-<p>
-Type for debugging hook functions.
-
-
-<p>
-Whenever a hook is called, its <code>ar</code> argument has its field
-<code>event</code> set to the specific event that triggered the hook.
-Lua identifies these events with the following constants:
-<a name="pdf-LUA_HOOKCALL"><code>LUA_HOOKCALL</code></a>, <a name="pdf-LUA_HOOKRET"><code>LUA_HOOKRET</code></a>,
-<a name="pdf-LUA_HOOKTAILCALL"><code>LUA_HOOKTAILCALL</code></a>, <a name="pdf-LUA_HOOKLINE"><code>LUA_HOOKLINE</code></a>,
-and <a name="pdf-LUA_HOOKCOUNT"><code>LUA_HOOKCOUNT</code></a>.
-Moreover, for line events, the field <code>currentline</code> is also set.
-To get the value of any other field in <code>ar</code>,
-the hook must call <a href="#lua_getinfo"><code>lua_getinfo</code></a>.
-
-
-<p>
-For call events, <code>event</code> can be <code>LUA_HOOKCALL</code>,
-the normal value, or <code>LUA_HOOKTAILCALL</code>, for a tail call;
-in this case, there will be no corresponding return event.
-
-
-<p>
-While Lua is running a hook, it disables other calls to hooks.
-Therefore, if a hook calls back Lua to execute a function or a chunk,
-this execution occurs without any calls to hooks.
-
-
-<p>
-Hook functions cannot have continuations,
-that is, they cannot call <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
-<a href="#lua_pcallk"><code>lua_pcallk</code></a>, or <a href="#lua_callk"><code>lua_callk</code></a> with a non-null <code>k</code>.
-
-
-<p>
-Hook functions can yield under the following conditions:
-Only count and line events can yield;
-to yield, a hook function must finish its execution
-calling <a href="#lua_yield"><code>lua_yield</code></a> with <code>nresults</code> equal to zero
-(that is, with no values).
-
-
-
-
-
-<hr><h3><a name="lua_sethook"><code>lua_sethook</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>void lua_sethook (lua_State *L, lua_Hook f, int mask, int count);</pre>
-
-<p>
-Sets the debugging hook function.
-
-
-<p>
-Argument <code>f</code> is the hook function.
-<code>mask</code> specifies on which events the hook will be called:
-it is formed by a bitwise OR of the constants
-<a name="pdf-LUA_MASKCALL"><code>LUA_MASKCALL</code></a>,
-<a name="pdf-LUA_MASKRET"><code>LUA_MASKRET</code></a>,
-<a name="pdf-LUA_MASKLINE"><code>LUA_MASKLINE</code></a>,
-and <a name="pdf-LUA_MASKCOUNT"><code>LUA_MASKCOUNT</code></a>.
-The <code>count</code> argument is only meaningful when the mask
-includes <code>LUA_MASKCOUNT</code>.
-For each event, the hook is called as explained below:
-
-<ul>
-
-<li><b>The call hook: </b> is called when the interpreter calls a function.
-The hook is called just after Lua enters the new function,
-before the function gets its arguments.
-</li>
-
-<li><b>The return hook: </b> is called when the interpreter returns from a function.
-The hook is called just before Lua leaves the function.
-There is no standard way to access the values
-to be returned by the function.
-</li>
-
-<li><b>The line hook: </b> is called when the interpreter is about to
-start the execution of a new line of code,
-or when it jumps back in the code (even to the same line).
-(This event only happens while Lua is executing a Lua function.)
-</li>
-
-<li><b>The count hook: </b> is called after the interpreter executes every
-<code>count</code> instructions.
-(This event only happens while Lua is executing a Lua function.)
-</li>
-
-</ul>
-
-<p>
-A hook is disabled by setting <code>mask</code> to zero.
-
-
-
-
-
-<hr><h3><a name="lua_setlocal"><code>lua_setlocal</code></a></h3><p>
-<span class="apii">[-(0|1), +0, &ndash;]</span>
-<pre>const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);</pre>
-
-<p>
-Sets the value of a local variable of a given activation record.
-It assigns the value at the top of the stack
-to the variable and returns its name.
-It also pops the value from the stack.
-
-
-<p>
-Returns <code>NULL</code> (and pops nothing)
-when the index is greater than
-the number of active local variables.
-
-
-<p>
-Parameters <code>ar</code> and <code>n</code> are as in function <a href="#lua_getlocal"><code>lua_getlocal</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_setupvalue"><code>lua_setupvalue</code></a></h3><p>
-<span class="apii">[-(0|1), +0, &ndash;]</span>
-<pre>const char *lua_setupvalue (lua_State *L, int funcindex, int n);</pre>
-
-<p>
-Sets the value of a closure's upvalue.
-It assigns the value at the top of the stack
-to the upvalue and returns its name.
-It also pops the value from the stack.
-
-
-<p>
-Returns <code>NULL</code> (and pops nothing)
-when the index <code>n</code> is greater than the number of upvalues.
-
-
-<p>
-Parameters <code>funcindex</code> and <code>n</code> are as in function <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>.
-
-
-
-
-
-<hr><h3><a name="lua_upvalueid"><code>lua_upvalueid</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>void *lua_upvalueid (lua_State *L, int funcindex, int n);</pre>
-
-<p>
-Returns a unique identifier for the upvalue numbered <code>n</code>
-from the closure at index <code>funcindex</code>.
-
-
-<p>
-These unique identifiers allow a program to check whether different
-closures share upvalues.
-Lua closures that share an upvalue
-(that is, that access a same external local variable)
-will return identical ids for those upvalue indices.
-
-
-<p>
-Parameters <code>funcindex</code> and <code>n</code> are as in function <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>,
-but <code>n</code> cannot be greater than the number of upvalues.
-
-
-
-
-
-<hr><h3><a name="lua_upvaluejoin"><code>lua_upvaluejoin</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>void lua_upvaluejoin (lua_State *L, int funcindex1, int n1,
-                                    int funcindex2, int n2);</pre>
-
-<p>
-Make the <code>n1</code>-th upvalue of the Lua closure at index <code>funcindex1</code>
-refer to the <code>n2</code>-th upvalue of the Lua closure at index <code>funcindex2</code>.
-
-
-
-
-
-
-
-<h1>5 &ndash; <a name="5">The Auxiliary Library</a></h1>
-
-<p>
-
-The <em>auxiliary library</em> provides several convenient functions
-to interface C with Lua.
-While the basic API provides the primitive functions for all
-interactions between C and Lua,
-the auxiliary library provides higher-level functions for some
-common tasks.
-
-
-<p>
-All functions and types from the auxiliary library
-are defined in header file <code>lauxlib.h</code> and
-have a prefix <code>luaL_</code>.
-
-
-<p>
-All functions in the auxiliary library are built on
-top of the basic API,
-and so they provide nothing that cannot be done with that API.
-Nevertheless, the use of the auxiliary library ensures
-more consistency to your code.
-
-
-<p>
-Several functions in the auxiliary library use internally some
-extra stack slots.
-When a function in the auxiliary library uses less than five slots,
-it does not check the stack size;
-it simply assumes that there are enough slots.
-
-
-<p>
-Several functions in the auxiliary library are used to
-check C&nbsp;function arguments.
-Because the error message is formatted for arguments
-(e.g., "<code>bad argument #1</code>"),
-you should not use these functions for other stack values.
-
-
-<p>
-Functions called <code>luaL_check*</code>
-always raise an error if the check is not satisfied.
-
-
-
-<h2>5.1 &ndash; <a name="5.1">Functions and Types</a></h2>
-
-<p>
-Here we list all functions and types from the auxiliary library
-in alphabetical order.
-
-
-
-<hr><h3><a name="luaL_addchar"><code>luaL_addchar</code></a></h3><p>
-<span class="apii">[-?, +?, <em>m</em>]</span>
-<pre>void luaL_addchar (luaL_Buffer *B, char c);</pre>
-
-<p>
-Adds the byte <code>c</code> to the buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_addlstring"><code>luaL_addlstring</code></a></h3><p>
-<span class="apii">[-?, +?, <em>m</em>]</span>
-<pre>void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);</pre>
-
-<p>
-Adds the string pointed to by <code>s</code> with length <code>l</code> to
-the buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-The string can contain embedded zeros.
-
-
-
-
-
-<hr><h3><a name="luaL_addsize"><code>luaL_addsize</code></a></h3><p>
-<span class="apii">[-?, +?, &ndash;]</span>
-<pre>void luaL_addsize (luaL_Buffer *B, size_t n);</pre>
-
-<p>
-Adds to the buffer <code>B</code> (see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>)
-a string of length <code>n</code> previously copied to the
-buffer area (see <a href="#luaL_prepbuffer"><code>luaL_prepbuffer</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_addstring"><code>luaL_addstring</code></a></h3><p>
-<span class="apii">[-?, +?, <em>m</em>]</span>
-<pre>void luaL_addstring (luaL_Buffer *B, const char *s);</pre>
-
-<p>
-Adds the zero-terminated string pointed to by <code>s</code>
-to the buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_addvalue"><code>luaL_addvalue</code></a></h3><p>
-<span class="apii">[-1, +?, <em>m</em>]</span>
-<pre>void luaL_addvalue (luaL_Buffer *B);</pre>
-
-<p>
-Adds the value at the top of the stack
-to the buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-Pops the value.
-
-
-<p>
-This is the only function on string buffers that can (and must)
-be called with an extra element on the stack,
-which is the value to be added to the buffer.
-
-
-
-
-
-<hr><h3><a name="luaL_argcheck"><code>luaL_argcheck</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void luaL_argcheck (lua_State *L,
-                    int cond,
-                    int arg,
-                    const char *extramsg);</pre>
-
-<p>
-Checks whether <code>cond</code> is true.
-If it is not, raises an error with a standard message (see <a href="#luaL_argerror"><code>luaL_argerror</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_argerror"><code>luaL_argerror</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_argerror (lua_State *L, int arg, const char *extramsg);</pre>
-
-<p>
-Raises an error reporting a problem with argument <code>arg</code>
-of the C&nbsp;function that called it,
-using a standard message
-that includes <code>extramsg</code> as a comment:
-
-<pre>
-     bad argument #<em>arg</em> to '<em>funcname</em>' (<em>extramsg</em>)
-</pre><p>
-This function never returns.
-
-
-
-
-
-<hr><h3><a name="luaL_Buffer"><code>luaL_Buffer</code></a></h3>
-<pre>typedef struct luaL_Buffer luaL_Buffer;</pre>
-
-<p>
-Type for a <em>string buffer</em>.
-
-
-<p>
-A string buffer allows C&nbsp;code to build Lua strings piecemeal.
-Its pattern of use is as follows:
-
-<ul>
-
-<li>First declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li>
-
-<li>Then initialize it with a call <code>luaL_buffinit(L, &amp;b)</code>.</li>
-
-<li>
-Then add string pieces to the buffer calling any of
-the <code>luaL_add*</code> functions.
-</li>
-
-<li>
-Finish by calling <code>luaL_pushresult(&amp;b)</code>.
-This call leaves the final string on the top of the stack.
-</li>
-
-</ul>
-
-<p>
-If you know beforehand the total size of the resulting string,
-you can use the buffer like this:
-
-<ul>
-
-<li>First declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li>
-
-<li>Then initialize it and preallocate a space of
-size <code>sz</code> with a call <code>luaL_buffinitsize(L, &amp;b, sz)</code>.</li>
-
-<li>Then copy the string into that space.</li>
-
-<li>
-Finish by calling <code>luaL_pushresultsize(&amp;b, sz)</code>,
-where <code>sz</code> is the total size of the resulting string
-copied into that space.
-</li>
-
-</ul>
-
-<p>
-During its normal operation,
-a string buffer uses a variable number of stack slots.
-So, while using a buffer, you cannot assume that you know where
-the top of the stack is.
-You can use the stack between successive calls to buffer operations
-as long as that use is balanced;
-that is,
-when you call a buffer operation,
-the stack is at the same level
-it was immediately after the previous buffer operation.
-(The only exception to this rule is <a href="#luaL_addvalue"><code>luaL_addvalue</code></a>.)
-After calling <a href="#luaL_pushresult"><code>luaL_pushresult</code></a> the stack is back to its
-level when the buffer was initialized,
-plus the final string on its top.
-
-
-
-
-
-<hr><h3><a name="luaL_buffinit"><code>luaL_buffinit</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>void luaL_buffinit (lua_State *L, luaL_Buffer *B);</pre>
-
-<p>
-Initializes a buffer <code>B</code>.
-This function does not allocate any space;
-the buffer must be declared as a variable
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_buffinitsize"><code>luaL_buffinitsize</code></a></h3><p>
-<span class="apii">[-?, +?, <em>m</em>]</span>
-<pre>char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz);</pre>
-
-<p>
-Equivalent to the sequence
-<a href="#luaL_buffinit"><code>luaL_buffinit</code></a>, <a href="#luaL_prepbuffsize"><code>luaL_prepbuffsize</code></a>.
-
-
-
-
-
-<hr><h3><a name="luaL_callmeta"><code>luaL_callmeta</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>e</em>]</span>
-<pre>int luaL_callmeta (lua_State *L, int obj, const char *e);</pre>
-
-<p>
-Calls a metamethod.
-
-
-<p>
-If the object at index <code>obj</code> has a metatable and this
-metatable has a field <code>e</code>,
-this function calls this field passing the object as its only argument.
-In this case this function returns true and pushes onto the
-stack the value returned by the call.
-If there is no metatable or no metamethod,
-this function returns false (without pushing any value on the stack).
-
-
-
-
-
-<hr><h3><a name="luaL_checkany"><code>luaL_checkany</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void luaL_checkany (lua_State *L, int arg);</pre>
-
-<p>
-Checks whether the function has an argument
-of any type (including <b>nil</b>) at position <code>arg</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_checkinteger"><code>luaL_checkinteger</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>lua_Integer luaL_checkinteger (lua_State *L, int arg);</pre>
-
-<p>
-Checks whether the function argument <code>arg</code> is an integer
-(or can be converted to an integer)
-and returns this integer cast to a <a href="#lua_Integer"><code>lua_Integer</code></a>.
-
-
-
-
-
-<hr><h3><a name="luaL_checklstring"><code>luaL_checklstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>const char *luaL_checklstring (lua_State *L, int arg, size_t *l);</pre>
-
-<p>
-Checks whether the function argument <code>arg</code> is a string
-and returns this string;
-if <code>l</code> is not <code>NULL</code> fills <code>*l</code>
-with the string's length.
-
-
-<p>
-This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result,
-so all conversions and caveats of that function apply here.
-
-
-
-
-
-<hr><h3><a name="luaL_checknumber"><code>luaL_checknumber</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>lua_Number luaL_checknumber (lua_State *L, int arg);</pre>
-
-<p>
-Checks whether the function argument <code>arg</code> is a number
-and returns this number.
-
-
-
-
-
-<hr><h3><a name="luaL_checkoption"><code>luaL_checkoption</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_checkoption (lua_State *L,
-                      int arg,
-                      const char *def,
-                      const char *const lst[]);</pre>
-
-<p>
-Checks whether the function argument <code>arg</code> is a string and
-searches for this string in the array <code>lst</code>
-(which must be NULL-terminated).
-Returns the index in the array where the string was found.
-Raises an error if the argument is not a string or
-if the string cannot be found.
-
-
-<p>
-If <code>def</code> is not <code>NULL</code>,
-the function uses <code>def</code> as a default value when
-there is no argument <code>arg</code> or when this argument is <b>nil</b>.
-
-
-<p>
-This is a useful function for mapping strings to C&nbsp;enums.
-(The usual convention in Lua libraries is
-to use strings instead of numbers to select options.)
-
-
-
-
-
-<hr><h3><a name="luaL_checkstack"><code>luaL_checkstack</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void luaL_checkstack (lua_State *L, int sz, const char *msg);</pre>
-
-<p>
-Grows the stack size to <code>top + sz</code> elements,
-raising an error if the stack cannot grow to that size.
-<code>msg</code> is an additional text to go into the error message
-(or <code>NULL</code> for no additional text).
-
-
-
-
-
-<hr><h3><a name="luaL_checkstring"><code>luaL_checkstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>const char *luaL_checkstring (lua_State *L, int arg);</pre>
-
-<p>
-Checks whether the function argument <code>arg</code> is a string
-and returns this string.
-
-
-<p>
-This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result,
-so all conversions and caveats of that function apply here.
-
-
-
-
-
-<hr><h3><a name="luaL_checktype"><code>luaL_checktype</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void luaL_checktype (lua_State *L, int arg, int t);</pre>
-
-<p>
-Checks whether the function argument <code>arg</code> has type <code>t</code>.
-See <a href="#lua_type"><code>lua_type</code></a> for the encoding of types for <code>t</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_checkudata"><code>luaL_checkudata</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void *luaL_checkudata (lua_State *L, int arg, const char *tname);</pre>
-
-<p>
-Checks whether the function argument <code>arg</code> is a userdata
-of the type <code>tname</code> (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>) and
-returns the userdata address (see <a href="#lua_touserdata"><code>lua_touserdata</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_checkversion"><code>luaL_checkversion</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>void luaL_checkversion (lua_State *L);</pre>
-
-<p>
-Checks whether the core running the call,
-the core that created the Lua state,
-and the code making the call are all using the same version of Lua.
-Also checks whether the core running the call
-and the core that created the Lua state
-are using the same address space.
-
-
-
-
-
-<hr><h3><a name="luaL_dofile"><code>luaL_dofile</code></a></h3><p>
-<span class="apii">[-0, +?, <em>e</em>]</span>
-<pre>int luaL_dofile (lua_State *L, const char *filename);</pre>
-
-<p>
-Loads and runs the given file.
-It is defined as the following macro:
-
-<pre>
-     (luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))
-</pre><p>
-It returns false if there are no errors
-or true in case of errors.
-
-
-
-
-
-<hr><h3><a name="luaL_dostring"><code>luaL_dostring</code></a></h3><p>
-<span class="apii">[-0, +?, &ndash;]</span>
-<pre>int luaL_dostring (lua_State *L, const char *str);</pre>
-
-<p>
-Loads and runs the given string.
-It is defined as the following macro:
-
-<pre>
-     (luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))
-</pre><p>
-It returns false if there are no errors
-or true in case of errors.
-
-
-
-
-
-<hr><h3><a name="luaL_error"><code>luaL_error</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_error (lua_State *L, const char *fmt, ...);</pre>
-
-<p>
-Raises an error.
-The error message format is given by <code>fmt</code>
-plus any extra arguments,
-following the same rules of <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>.
-It also adds at the beginning of the message the file name and
-the line number where the error occurred,
-if this information is available.
-
-
-<p>
-This function never returns,
-but it is an idiom to use it in C&nbsp;functions
-as <code>return luaL_error(<em>args</em>)</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_execresult"><code>luaL_execresult</code></a></h3><p>
-<span class="apii">[-0, +3, <em>m</em>]</span>
-<pre>int luaL_execresult (lua_State *L, int stat);</pre>
-
-<p>
-This function produces the return values for
-process-related functions in the standard library
-(<a href="#pdf-os.execute"><code>os.execute</code></a> and <a href="#pdf-io.close"><code>io.close</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_fileresult"><code>luaL_fileresult</code></a></h3><p>
-<span class="apii">[-0, +(1|3), <em>m</em>]</span>
-<pre>int luaL_fileresult (lua_State *L, int stat, const char *fname);</pre>
-
-<p>
-This function produces the return values for
-file-related functions in the standard library
-(<a href="#pdf-io.open"><code>io.open</code></a>, <a href="#pdf-os.rename"><code>os.rename</code></a>, <a href="#pdf-file:seek"><code>file:seek</code></a>, etc.).
-
-
-
-
-
-<hr><h3><a name="luaL_getmetafield"><code>luaL_getmetafield</code></a></h3><p>
-<span class="apii">[-0, +(0|1), <em>m</em>]</span>
-<pre>int luaL_getmetafield (lua_State *L, int obj, const char *e);</pre>
-
-<p>
-Pushes onto the stack the field <code>e</code> from the metatable
-of the object at index <code>obj</code> and returns the type of the pushed value.
-If the object does not have a metatable,
-or if the metatable does not have this field,
-pushes nothing and returns <code>LUA_TNIL</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_getmetatable"><code>luaL_getmetatable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>int luaL_getmetatable (lua_State *L, const char *tname);</pre>
-
-<p>
-Pushes onto the stack the metatable associated with name <code>tname</code>
-in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>)
-(<b>nil</b> if there is no metatable associated with that name).
-Returns the type of the pushed value.
-
-
-
-
-
-<hr><h3><a name="luaL_getsubtable"><code>luaL_getsubtable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>e</em>]</span>
-<pre>int luaL_getsubtable (lua_State *L, int idx, const char *fname);</pre>
-
-<p>
-Ensures that the value <code>t[fname]</code>,
-where <code>t</code> is the value at index <code>idx</code>,
-is a table,
-and pushes that table onto the stack.
-Returns true if it finds a previous table there
-and false if it creates a new table.
-
-
-
-
-
-<hr><h3><a name="luaL_gsub"><code>luaL_gsub</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>const char *luaL_gsub (lua_State *L,
-                       const char *s,
-                       const char *p,
-                       const char *r);</pre>
-
-<p>
-Creates a copy of string <code>s</code> by replacing
-any occurrence of the string <code>p</code>
-with the string <code>r</code>.
-Pushes the resulting string on the stack and returns it.
-
-
-
-
-
-<hr><h3><a name="luaL_len"><code>luaL_len</code></a></h3><p>
-<span class="apii">[-0, +0, <em>e</em>]</span>
-<pre>lua_Integer luaL_len (lua_State *L, int index);</pre>
-
-<p>
-Returns the "length" of the value at the given index
-as a number;
-it is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.7">&sect;3.4.7</a>).
-Raises an error if the result of the operation is not an integer.
-(This case only can happen through metamethods.)
-
-
-
-
-
-<hr><h3><a name="luaL_loadbuffer"><code>luaL_loadbuffer</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>int luaL_loadbuffer (lua_State *L,
-                     const char *buff,
-                     size_t sz,
-                     const char *name);</pre>
-
-<p>
-Equivalent to <a href="#luaL_loadbufferx"><code>luaL_loadbufferx</code></a> with <code>mode</code> equal to <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_loadbufferx"><code>luaL_loadbufferx</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>int luaL_loadbufferx (lua_State *L,
-                      const char *buff,
-                      size_t sz,
-                      const char *name,
-                      const char *mode);</pre>
-
-<p>
-Loads a buffer as a Lua chunk.
-This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the
-buffer pointed to by <code>buff</code> with size <code>sz</code>.
-
-
-<p>
-This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>.
-<code>name</code> is the chunk name,
-used for debug information and error messages.
-The string <code>mode</code> works as in function <a href="#lua_load"><code>lua_load</code></a>.
-
-
-
-
-
-<hr><h3><a name="luaL_loadfile"><code>luaL_loadfile</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>int luaL_loadfile (lua_State *L, const char *filename);</pre>
-
-<p>
-Equivalent to <a href="#luaL_loadfilex"><code>luaL_loadfilex</code></a> with <code>mode</code> equal to <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_loadfilex"><code>luaL_loadfilex</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>int luaL_loadfilex (lua_State *L, const char *filename,
-                                            const char *mode);</pre>
-
-<p>
-Loads a file as a Lua chunk.
-This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the file
-named <code>filename</code>.
-If <code>filename</code> is <code>NULL</code>,
-then it loads from the standard input.
-The first line in the file is ignored if it starts with a <code>#</code>.
-
-
-<p>
-The string <code>mode</code> works as in function <a href="#lua_load"><code>lua_load</code></a>.
-
-
-<p>
-This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>,
-but it has an extra error code <a name="pdf-LUA_ERRFILE"><code>LUA_ERRFILE</code></a>
-for file-related errors
-(e.g., it cannot open or read the file).
-
-
-<p>
-As <a href="#lua_load"><code>lua_load</code></a>, this function only loads the chunk;
-it does not run it.
-
-
-
-
-
-<hr><h3><a name="luaL_loadstring"><code>luaL_loadstring</code></a></h3><p>
-<span class="apii">[-0, +1, &ndash;]</span>
-<pre>int luaL_loadstring (lua_State *L, const char *s);</pre>
-
-<p>
-Loads a string as a Lua chunk.
-This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in
-the zero-terminated string <code>s</code>.
-
-
-<p>
-This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>.
-
-
-<p>
-Also as <a href="#lua_load"><code>lua_load</code></a>, this function only loads the chunk;
-it does not run it.
-
-
-
-
-
-<hr><h3><a name="luaL_newlib"><code>luaL_newlib</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void luaL_newlib (lua_State *L, const luaL_Reg l[]);</pre>
-
-<p>
-Creates a new table and registers there
-the functions in list <code>l</code>.
-
-
-<p>
-It is implemented as the following macro:
-
-<pre>
-     (luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
-</pre><p>
-The array <code>l</code> must be the actual array,
-not a pointer to it.
-
-
-
-
-
-<hr><h3><a name="luaL_newlibtable"><code>luaL_newlibtable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void luaL_newlibtable (lua_State *L, const luaL_Reg l[]);</pre>
-
-<p>
-Creates a new table with a size optimized
-to store all entries in the array <code>l</code>
-(but does not actually store them).
-It is intended to be used in conjunction with <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a>
-(see <a href="#luaL_newlib"><code>luaL_newlib</code></a>).
-
-
-<p>
-It is implemented as a macro.
-The array <code>l</code> must be the actual array,
-not a pointer to it.
-
-
-
-
-
-<hr><h3><a name="luaL_newmetatable"><code>luaL_newmetatable</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>int luaL_newmetatable (lua_State *L, const char *tname);</pre>
-
-<p>
-If the registry already has the key <code>tname</code>,
-returns 0.
-Otherwise,
-creates a new table to be used as a metatable for userdata,
-adds to this new table the pair <code>__name = tname</code>,
-adds to the registry the pair <code>[tname] = new table</code>,
-and returns 1.
-(The entry <code>__name</code> is used by some error-reporting functions.)
-
-
-<p>
-In both cases pushes onto the stack the final value associated
-with <code>tname</code> in the registry.
-
-
-
-
-
-<hr><h3><a name="luaL_newstate"><code>luaL_newstate</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>lua_State *luaL_newstate (void);</pre>
-
-<p>
-Creates a new Lua state.
-It calls <a href="#lua_newstate"><code>lua_newstate</code></a> with an
-allocator based on the standard&nbsp;C <code>realloc</code> function
-and then sets a panic function (see <a href="#4.6">&sect;4.6</a>) that prints
-an error message to the standard error output in case of fatal
-errors.
-
-
-<p>
-Returns the new state,
-or <code>NULL</code> if there is a memory allocation error.
-
-
-
-
-
-<hr><h3><a name="luaL_openlibs"><code>luaL_openlibs</code></a></h3><p>
-<span class="apii">[-0, +0, <em>e</em>]</span>
-<pre>void luaL_openlibs (lua_State *L);</pre>
-
-<p>
-Opens all standard Lua libraries into the given state.
-
-
-
-
-
-<hr><h3><a name="luaL_opt"><code>luaL_opt</code></a></h3><p>
-<span class="apii">[-0, +0, <em>e</em>]</span>
-<pre>T luaL_opt (L, func, arg, dflt);</pre>
-
-<p>
-This macro is defined as follows:
-
-<pre>
-     (lua_isnoneornil(L,(arg)) ? (dflt) : func(L,(arg)))
-</pre><p>
-In words, if the argument <code>arg</code> is nil or absent,
-the macro results in the default <code>dflt</code>.
-Otherwise, it results in the result of calling <code>func</code>
-with the state <code>L</code> and the argument index <code>arg</code> as
-arguments.
-Note that it evaluates the expression <code>dflt</code> only if needed.
-
-
-
-
-
-<hr><h3><a name="luaL_optinteger"><code>luaL_optinteger</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>lua_Integer luaL_optinteger (lua_State *L,
-                             int arg,
-                             lua_Integer d);</pre>
-
-<p>
-If the function argument <code>arg</code> is an integer
-(or convertible to an integer),
-returns this integer.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-
-
-
-<hr><h3><a name="luaL_optlstring"><code>luaL_optlstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>const char *luaL_optlstring (lua_State *L,
-                             int arg,
-                             const char *d,
-                             size_t *l);</pre>
-
-<p>
-If the function argument <code>arg</code> is a string,
-returns this string.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-<p>
-If <code>l</code> is not <code>NULL</code>,
-fills the position <code>*l</code> with the result's length.
-If the result is <code>NULL</code>
-(only possible when returning <code>d</code> and <code>d == NULL</code>),
-its length is considered zero.
-
-
-<p>
-This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result,
-so all conversions and caveats of that function apply here.
-
-
-
-
-
-<hr><h3><a name="luaL_optnumber"><code>luaL_optnumber</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number d);</pre>
-
-<p>
-If the function argument <code>arg</code> is a number,
-returns this number.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-
-
-
-<hr><h3><a name="luaL_optstring"><code>luaL_optstring</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>const char *luaL_optstring (lua_State *L,
-                            int arg,
-                            const char *d);</pre>
-
-<p>
-If the function argument <code>arg</code> is a string,
-returns this string.
-If this argument is absent or is <b>nil</b>,
-returns <code>d</code>.
-Otherwise, raises an error.
-
-
-
-
-
-<hr><h3><a name="luaL_prepbuffer"><code>luaL_prepbuffer</code></a></h3><p>
-<span class="apii">[-?, +?, <em>m</em>]</span>
-<pre>char *luaL_prepbuffer (luaL_Buffer *B);</pre>
-
-<p>
-Equivalent to <a href="#luaL_prepbuffsize"><code>luaL_prepbuffsize</code></a>
-with the predefined size <a name="pdf-LUAL_BUFFERSIZE"><code>LUAL_BUFFERSIZE</code></a>.
-
-
-
-
-
-<hr><h3><a name="luaL_prepbuffsize"><code>luaL_prepbuffsize</code></a></h3><p>
-<span class="apii">[-?, +?, <em>m</em>]</span>
-<pre>char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz);</pre>
-
-<p>
-Returns an address to a space of size <code>sz</code>
-where you can copy a string to be added to buffer <code>B</code>
-(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
-After copying the string into this space you must call
-<a href="#luaL_addsize"><code>luaL_addsize</code></a> with the size of the string to actually add
-it to the buffer.
-
-
-
-
-
-<hr><h3><a name="luaL_pushresult"><code>luaL_pushresult</code></a></h3><p>
-<span class="apii">[-?, +1, <em>m</em>]</span>
-<pre>void luaL_pushresult (luaL_Buffer *B);</pre>
-
-<p>
-Finishes the use of buffer <code>B</code> leaving the final string on
-the top of the stack.
-
-
-
-
-
-<hr><h3><a name="luaL_pushresultsize"><code>luaL_pushresultsize</code></a></h3><p>
-<span class="apii">[-?, +1, <em>m</em>]</span>
-<pre>void luaL_pushresultsize (luaL_Buffer *B, size_t sz);</pre>
-
-<p>
-Equivalent to the sequence <a href="#luaL_addsize"><code>luaL_addsize</code></a>, <a href="#luaL_pushresult"><code>luaL_pushresult</code></a>.
-
-
-
-
-
-<hr><h3><a name="luaL_ref"><code>luaL_ref</code></a></h3><p>
-<span class="apii">[-1, +0, <em>m</em>]</span>
-<pre>int luaL_ref (lua_State *L, int t);</pre>
-
-<p>
-Creates and returns a <em>reference</em>,
-in the table at index <code>t</code>,
-for the object at the top of the stack (and pops the object).
-
-
-<p>
-A reference is a unique integer key.
-As long as you do not manually add integer keys into table <code>t</code>,
-<a href="#luaL_ref"><code>luaL_ref</code></a> ensures the uniqueness of the key it returns.
-You can retrieve an object referred by reference <code>r</code>
-by calling <code>lua_rawgeti(L, t, r)</code>.
-Function <a href="#luaL_unref"><code>luaL_unref</code></a> frees a reference and its associated object.
-
-
-<p>
-If the object at the top of the stack is <b>nil</b>,
-<a href="#luaL_ref"><code>luaL_ref</code></a> returns the constant <a name="pdf-LUA_REFNIL"><code>LUA_REFNIL</code></a>.
-The constant <a name="pdf-LUA_NOREF"><code>LUA_NOREF</code></a> is guaranteed to be different
-from any reference returned by <a href="#luaL_ref"><code>luaL_ref</code></a>.
-
-
-
-
-
-<hr><h3><a name="luaL_Reg"><code>luaL_Reg</code></a></h3>
-<pre>typedef struct luaL_Reg {
-  const char *name;
-  lua_CFunction func;
-} luaL_Reg;</pre>
-
-<p>
-Type for arrays of functions to be registered by
-<a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a>.
-<code>name</code> is the function name and <code>func</code> is a pointer to
-the function.
-Any array of <a href="#luaL_Reg"><code>luaL_Reg</code></a> must end with a sentinel entry
-in which both <code>name</code> and <code>func</code> are <code>NULL</code>.
-
-
-
-
-
-<hr><h3><a name="luaL_requiref"><code>luaL_requiref</code></a></h3><p>
-<span class="apii">[-0, +1, <em>e</em>]</span>
-<pre>void luaL_requiref (lua_State *L, const char *modname,
-                    lua_CFunction openf, int glb);</pre>
-
-<p>
-If <code>modname</code> is not already present in <a href="#pdf-package.loaded"><code>package.loaded</code></a>,
-calls function <code>openf</code> with string <code>modname</code> as an argument
-and sets the call result in <code>package.loaded[modname]</code>,
-as if that function has been called through <a href="#pdf-require"><code>require</code></a>.
-
-
-<p>
-If <code>glb</code> is true,
-also stores the module into global <code>modname</code>.
-
-
-<p>
-Leaves a copy of the module on the stack.
-
-
-
-
-
-<hr><h3><a name="luaL_setfuncs"><code>luaL_setfuncs</code></a></h3><p>
-<span class="apii">[-nup, +0, <em>m</em>]</span>
-<pre>void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup);</pre>
-
-<p>
-Registers all functions in the array <code>l</code>
-(see <a href="#luaL_Reg"><code>luaL_Reg</code></a>) into the table on the top of the stack
-(below optional upvalues, see next).
-
-
-<p>
-When <code>nup</code> is not zero,
-all functions are created sharing <code>nup</code> upvalues,
-which must be previously pushed on the stack
-on top of the library table.
-These values are popped from the stack after the registration.
-
-
-
-
-
-<hr><h3><a name="luaL_setmetatable"><code>luaL_setmetatable</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>void luaL_setmetatable (lua_State *L, const char *tname);</pre>
-
-<p>
-Sets the metatable of the object at the top of the stack
-as the metatable associated with name <code>tname</code>
-in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
-
-
-
-
-
-<hr><h3><a name="luaL_Stream"><code>luaL_Stream</code></a></h3>
-<pre>typedef struct luaL_Stream {
-  FILE *f;
-  lua_CFunction closef;
-} luaL_Stream;</pre>
-
-<p>
-The standard representation for file handles,
-which is used by the standard I/O library.
-
-
-<p>
-A file handle is implemented as a full userdata,
-with a metatable called <code>LUA_FILEHANDLE</code>
-(where <code>LUA_FILEHANDLE</code> is a macro with the actual metatable's name).
-The metatable is created by the I/O library
-(see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
-
-
-<p>
-This userdata must start with the structure <code>luaL_Stream</code>;
-it can contain other data after this initial structure.
-Field <code>f</code> points to the corresponding C stream
-(or it can be <code>NULL</code> to indicate an incompletely created handle).
-Field <code>closef</code> points to a Lua function
-that will be called to close the stream
-when the handle is closed or collected;
-this function receives the file handle as its sole argument and
-must return either <b>true</b> (in case of success)
-or <b>nil</b> plus an error message (in case of error).
-Once Lua calls this field,
-it changes the field value to <code>NULL</code>
-to signal that the handle is closed.
-
-
-
-
-
-<hr><h3><a name="luaL_testudata"><code>luaL_testudata</code></a></h3><p>
-<span class="apii">[-0, +0, <em>m</em>]</span>
-<pre>void *luaL_testudata (lua_State *L, int arg, const char *tname);</pre>
-
-<p>
-This function works like <a href="#luaL_checkudata"><code>luaL_checkudata</code></a>,
-except that, when the test fails,
-it returns <code>NULL</code> instead of raising an error.
-
-
-
-
-
-<hr><h3><a name="luaL_tolstring"><code>luaL_tolstring</code></a></h3><p>
-<span class="apii">[-0, +1, <em>e</em>]</span>
-<pre>const char *luaL_tolstring (lua_State *L, int idx, size_t *len);</pre>
-
-<p>
-Converts any Lua value at the given index to a C&nbsp;string
-in a reasonable format.
-The resulting string is pushed onto the stack and also
-returned by the function.
-If <code>len</code> is not <code>NULL</code>,
-the function also sets <code>*len</code> with the string length.
-
-
-<p>
-If the value has a metatable with a <code>__tostring</code> field,
-then <code>luaL_tolstring</code> calls the corresponding metamethod
-with the value as argument,
-and uses the result of the call as its result.
-
-
-
-
-
-<hr><h3><a name="luaL_traceback"><code>luaL_traceback</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void luaL_traceback (lua_State *L, lua_State *L1, const char *msg,
-                     int level);</pre>
-
-<p>
-Creates and pushes a traceback of the stack <code>L1</code>.
-If <code>msg</code> is not <code>NULL</code> it is appended
-at the beginning of the traceback.
-The <code>level</code> parameter tells at which level
-to start the traceback.
-
-
-
-
-
-<hr><h3><a name="luaL_typename"><code>luaL_typename</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>const char *luaL_typename (lua_State *L, int index);</pre>
-
-<p>
-Returns the name of the type of the value at the given index.
-
-
-
-
-
-<hr><h3><a name="luaL_unref"><code>luaL_unref</code></a></h3><p>
-<span class="apii">[-0, +0, &ndash;]</span>
-<pre>void luaL_unref (lua_State *L, int t, int ref);</pre>
-
-<p>
-Releases reference <code>ref</code> from the table at index <code>t</code>
-(see <a href="#luaL_ref"><code>luaL_ref</code></a>).
-The entry is removed from the table,
-so that the referred object can be collected.
-The reference <code>ref</code> is also freed to be used again.
-
-
-<p>
-If <code>ref</code> is <a href="#pdf-LUA_NOREF"><code>LUA_NOREF</code></a> or <a href="#pdf-LUA_REFNIL"><code>LUA_REFNIL</code></a>,
-<a href="#luaL_unref"><code>luaL_unref</code></a> does nothing.
-
-
-
-
-
-<hr><h3><a name="luaL_where"><code>luaL_where</code></a></h3><p>
-<span class="apii">[-0, +1, <em>m</em>]</span>
-<pre>void luaL_where (lua_State *L, int lvl);</pre>
-
-<p>
-Pushes onto the stack a string identifying the current position
-of the control at level <code>lvl</code> in the call stack.
-Typically this string has the following format:
-
-<pre>
-     <em>chunkname</em>:<em>currentline</em>:
-</pre><p>
-Level&nbsp;0 is the running function,
-level&nbsp;1 is the function that called the running function,
-etc.
-
-
-<p>
-This function is used to build a prefix for error messages.
-
-
-
-
-
-
-
-<h1>6 &ndash; <a name="6">Standard Libraries</a></h1>
-
-<p>
-The standard Lua libraries provide useful functions
-that are implemented directly through the C&nbsp;API.
-Some of these functions provide essential services to the language
-(e.g., <a href="#pdf-type"><code>type</code></a> and <a href="#pdf-getmetatable"><code>getmetatable</code></a>);
-others provide access to "outside" services (e.g., I/O);
-and others could be implemented in Lua itself,
-but are quite useful or have critical performance requirements that
-deserve an implementation in C (e.g., <a href="#pdf-table.sort"><code>table.sort</code></a>).
-
-
-<p>
-All libraries are implemented through the official C&nbsp;API
-and are provided as separate C&nbsp;modules.
-Currently, Lua has the following standard libraries:
-
-<ul>
-
-<li>basic library (<a href="#6.1">&sect;6.1</a>);</li>
-
-<li>coroutine library (<a href="#6.2">&sect;6.2</a>);</li>
-
-<li>package library (<a href="#6.3">&sect;6.3</a>);</li>
-
-<li>string manipulation (<a href="#6.4">&sect;6.4</a>);</li>
-
-<li>basic UTF-8 support (<a href="#6.5">&sect;6.5</a>);</li>
-
-<li>table manipulation (<a href="#6.6">&sect;6.6</a>);</li>
-
-<li>mathematical functions (<a href="#6.7">&sect;6.7</a>) (sin, log, etc.);</li>
-
-<li>input and output (<a href="#6.8">&sect;6.8</a>);</li>
-
-<li>operating system facilities (<a href="#6.9">&sect;6.9</a>);</li>
-
-<li>debug facilities (<a href="#6.10">&sect;6.10</a>).</li>
-
-</ul><p>
-Except for the basic and the package libraries,
-each library provides all its functions as fields of a global table
-or as methods of its objects.
-
-
-<p>
-To have access to these libraries,
-the C&nbsp;host program should call the <a href="#luaL_openlibs"><code>luaL_openlibs</code></a> function,
-which opens all standard libraries.
-Alternatively,
-the host program can open them individually by using
-<a href="#luaL_requiref"><code>luaL_requiref</code></a> to call
-<a name="pdf-luaopen_base"><code>luaopen_base</code></a> (for the basic library),
-<a name="pdf-luaopen_package"><code>luaopen_package</code></a> (for the package library),
-<a name="pdf-luaopen_coroutine"><code>luaopen_coroutine</code></a> (for the coroutine library),
-<a name="pdf-luaopen_string"><code>luaopen_string</code></a> (for the string library),
-<a name="pdf-luaopen_utf8"><code>luaopen_utf8</code></a> (for the UTF8 library),
-<a name="pdf-luaopen_table"><code>luaopen_table</code></a> (for the table library),
-<a name="pdf-luaopen_math"><code>luaopen_math</code></a> (for the mathematical library),
-<a name="pdf-luaopen_io"><code>luaopen_io</code></a> (for the I/O library),
-<a name="pdf-luaopen_os"><code>luaopen_os</code></a> (for the operating system library),
-and <a name="pdf-luaopen_debug"><code>luaopen_debug</code></a> (for the debug library).
-These functions are declared in <a name="pdf-lualib.h"><code>lualib.h</code></a>.
-
-
-
-<h2>6.1 &ndash; <a name="6.1">Basic Functions</a></h2>
-
-<p>
-The basic library provides core functions to Lua.
-If you do not include this library in your application,
-you should check carefully whether you need to provide
-implementations for some of its facilities.
-
-
-<p>
-<hr><h3><a name="pdf-assert"><code>assert (v [, message])</code></a></h3>
-
-
-<p>
-Calls <a href="#pdf-error"><code>error</code></a> if
-the value of its argument <code>v</code> is false (i.e., <b>nil</b> or <b>false</b>);
-otherwise, returns all its arguments.
-In case of error,
-<code>message</code> is the error object;
-when absent, it defaults to "<code>assertion failed!</code>"
-
-
-
-
-<p>
-<hr><h3><a name="pdf-collectgarbage"><code>collectgarbage ([opt [, arg]])</code></a></h3>
-
-
-<p>
-This function is a generic interface to the garbage collector.
-It performs different functions according to its first argument, <code>opt</code>:
-
-<ul>
-
-<li><b>"<code>collect</code>": </b>
-performs a full garbage-collection cycle.
-This is the default option.
-</li>
-
-<li><b>"<code>stop</code>": </b>
-stops automatic execution of the garbage collector.
-The collector will run only when explicitly invoked,
-until a call to restart it.
-</li>
-
-<li><b>"<code>restart</code>": </b>
-restarts automatic execution of the garbage collector.
-</li>
-
-<li><b>"<code>count</code>": </b>
-returns the total memory in use by Lua in Kbytes.
-The value has a fractional part,
-so that it multiplied by 1024
-gives the exact number of bytes in use by Lua
-(except for overflows).
-</li>
-
-<li><b>"<code>step</code>": </b>
-performs a garbage-collection step.
-The step "size" is controlled by <code>arg</code>.
-With a zero value,
-the collector will perform one basic (indivisible) step.
-For non-zero values,
-the collector will perform as if that amount of memory
-(in KBytes) had been allocated by Lua.
-Returns <b>true</b> if the step finished a collection cycle.
-</li>
-
-<li><b>"<code>setpause</code>": </b>
-sets <code>arg</code> as the new value for the <em>pause</em> of
-the collector (see <a href="#2.5">&sect;2.5</a>).
-Returns the previous value for <em>pause</em>.
-</li>
-
-<li><b>"<code>setstepmul</code>": </b>
-sets <code>arg</code> as the new value for the <em>step multiplier</em> of
-the collector (see <a href="#2.5">&sect;2.5</a>).
-Returns the previous value for <em>step</em>.
-</li>
-
-<li><b>"<code>isrunning</code>": </b>
-returns a boolean that tells whether the collector is running
-(i.e., not stopped).
-</li>
-
-</ul>
-
-
-
-<p>
-<hr><h3><a name="pdf-dofile"><code>dofile ([filename])</code></a></h3>
-Opens the named file and executes its contents as a Lua chunk.
-When called without arguments,
-<code>dofile</code> executes the contents of the standard input (<code>stdin</code>).
-Returns all values returned by the chunk.
-In case of errors, <code>dofile</code> propagates the error
-to its caller (that is, <code>dofile</code> does not run in protected mode).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-error"><code>error (message [, level])</code></a></h3>
-Terminates the last protected function called
-and returns <code>message</code> as the error object.
-Function <code>error</code> never returns.
-
-
-<p>
-Usually, <code>error</code> adds some information about the error position
-at the beginning of the message, if the message is a string.
-The <code>level</code> argument specifies how to get the error position.
-With level&nbsp;1 (the default), the error position is where the
-<code>error</code> function was called.
-Level&nbsp;2 points the error to where the function
-that called <code>error</code> was called; and so on.
-Passing a level&nbsp;0 avoids the addition of error position information
-to the message.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-_G"><code>_G</code></a></h3>
-A global variable (not a function) that
-holds the global environment (see <a href="#2.2">&sect;2.2</a>).
-Lua itself does not use this variable;
-changing its value does not affect any environment,
-nor vice versa.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-getmetatable"><code>getmetatable (object)</code></a></h3>
-
-
-<p>
-If <code>object</code> does not have a metatable, returns <b>nil</b>.
-Otherwise,
-if the object's metatable has a <code>__metatable</code> field,
-returns the associated value.
-Otherwise, returns the metatable of the given object.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-ipairs"><code>ipairs (t)</code></a></h3>
-
-
-<p>
-Returns three values (an iterator function, the table <code>t</code>, and 0)
-so that the construction
-
-<pre>
-     for i,v in ipairs(t) do <em>body</em> end
-</pre><p>
-will iterate over the key&ndash;value pairs
-(<code>1,t[1]</code>), (<code>2,t[2]</code>), ...,
-up to the first nil value.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-load"><code>load (chunk [, chunkname [, mode [, env]]])</code></a></h3>
-
-
-<p>
-Loads a chunk.
-
-
-<p>
-If <code>chunk</code> is a string, the chunk is this string.
-If <code>chunk</code> is a function,
-<code>load</code> calls it repeatedly to get the chunk pieces.
-Each call to <code>chunk</code> must return a string that concatenates
-with previous results.
-A return of an empty string, <b>nil</b>, or no value signals the end of the chunk.
-
-
-<p>
-If there are no syntactic errors,
-returns the compiled chunk as a function;
-otherwise, returns <b>nil</b> plus the error message.
-
-
-<p>
-If the resulting function has upvalues,
-the first upvalue is set to the value of <code>env</code>,
-if that parameter is given,
-or to the value of the global environment.
-Other upvalues are initialized with <b>nil</b>.
-(When you load a main chunk,
-the resulting function will always have exactly one upvalue,
-the <code>_ENV</code> variable (see <a href="#2.2">&sect;2.2</a>).
-However,
-when you load a binary chunk created from a function (see <a href="#pdf-string.dump"><code>string.dump</code></a>),
-the resulting function can have an arbitrary number of upvalues.)
-All upvalues are fresh, that is,
-they are not shared with any other function.
-
-
-<p>
-<code>chunkname</code> is used as the name of the chunk for error messages
-and debug information (see <a href="#4.9">&sect;4.9</a>).
-When absent,
-it defaults to <code>chunk</code>, if <code>chunk</code> is a string,
-or to "<code>=(load)</code>" otherwise.
-
-
-<p>
-The string <code>mode</code> controls whether the chunk can be text or binary
-(that is, a precompiled chunk).
-It may be the string "<code>b</code>" (only binary chunks),
-"<code>t</code>" (only text chunks),
-or "<code>bt</code>" (both binary and text).
-The default is "<code>bt</code>".
-
-
-<p>
-Lua does not check the consistency of binary chunks.
-Maliciously crafted binary chunks can crash
-the interpreter.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-loadfile"><code>loadfile ([filename [, mode [, env]]])</code></a></h3>
-
-
-<p>
-Similar to <a href="#pdf-load"><code>load</code></a>,
-but gets the chunk from file <code>filename</code>
-or from the standard input,
-if no file name is given.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-next"><code>next (table [, index])</code></a></h3>
-
-
-<p>
-Allows a program to traverse all fields of a table.
-Its first argument is a table and its second argument
-is an index in this table.
-<code>next</code> returns the next index of the table
-and its associated value.
-When called with <b>nil</b> as its second argument,
-<code>next</code> returns an initial index
-and its associated value.
-When called with the last index,
-or with <b>nil</b> in an empty table,
-<code>next</code> returns <b>nil</b>.
-If the second argument is absent, then it is interpreted as <b>nil</b>.
-In particular,
-you can use <code>next(t)</code> to check whether a table is empty.
-
-
-<p>
-The order in which the indices are enumerated is not specified,
-<em>even for numeric indices</em>.
-(To traverse a table in numerical order,
-use a numerical <b>for</b>.)
-
-
-<p>
-The behavior of <code>next</code> is undefined if,
-during the traversal,
-you assign any value to a non-existent field in the table.
-You may however modify existing fields.
-In particular, you may clear existing fields.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-pairs"><code>pairs (t)</code></a></h3>
-
-
-<p>
-If <code>t</code> has a metamethod <code>__pairs</code>,
-calls it with <code>t</code> as argument and returns the first three
-results from the call.
-
-
-<p>
-Otherwise,
-returns three values: the <a href="#pdf-next"><code>next</code></a> function, the table <code>t</code>, and <b>nil</b>,
-so that the construction
-
-<pre>
-     for k,v in pairs(t) do <em>body</em> end
-</pre><p>
-will iterate over all key&ndash;value pairs of table <code>t</code>.
-
-
-<p>
-See function <a href="#pdf-next"><code>next</code></a> for the caveats of modifying
-the table during its traversal.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-pcall"><code>pcall (f [, arg1, &middot;&middot;&middot;])</code></a></h3>
-
-
-<p>
-Calls function <code>f</code> with
-the given arguments in <em>protected mode</em>.
-This means that any error inside&nbsp;<code>f</code> is not propagated;
-instead, <code>pcall</code> catches the error
-and returns a status code.
-Its first result is the status code (a boolean),
-which is true if the call succeeds without errors.
-In such case, <code>pcall</code> also returns all results from the call,
-after this first result.
-In case of any error, <code>pcall</code> returns <b>false</b> plus the error message.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-print"><code>print (&middot;&middot;&middot;)</code></a></h3>
-Receives any number of arguments
-and prints their values to <code>stdout</code>,
-using the <a href="#pdf-tostring"><code>tostring</code></a> function to convert each argument to a string.
-<code>print</code> is not intended for formatted output,
-but only as a quick way to show a value,
-for instance for debugging.
-For complete control over the output,
-use <a href="#pdf-string.format"><code>string.format</code></a> and <a href="#pdf-io.write"><code>io.write</code></a>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-rawequal"><code>rawequal (v1, v2)</code></a></h3>
-Checks whether <code>v1</code> is equal to <code>v2</code>,
-without invoking the <code>__eq</code> metamethod.
-Returns a boolean.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-rawget"><code>rawget (table, index)</code></a></h3>
-Gets the real value of <code>table[index]</code>,
-without invoking the <code>__index</code> metamethod.
-<code>table</code> must be a table;
-<code>index</code> may be any value.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-rawlen"><code>rawlen (v)</code></a></h3>
-Returns the length of the object <code>v</code>,
-which must be a table or a string,
-without invoking the <code>__len</code> metamethod.
-Returns an integer.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-rawset"><code>rawset (table, index, value)</code></a></h3>
-Sets the real value of <code>table[index]</code> to <code>value</code>,
-without invoking the <code>__newindex</code> metamethod.
-<code>table</code> must be a table,
-<code>index</code> any value different from <b>nil</b> and NaN,
-and <code>value</code> any Lua value.
-
-
-<p>
-This function returns <code>table</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-select"><code>select (index, &middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-If <code>index</code> is a number,
-returns all arguments after argument number <code>index</code>;
-a negative number indexes from the end (-1 is the last argument).
-Otherwise, <code>index</code> must be the string <code>"#"</code>,
-and <code>select</code> returns the total number of extra arguments it received.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-setmetatable"><code>setmetatable (table, metatable)</code></a></h3>
-
-
-<p>
-Sets the metatable for the given table.
-(To change the metatable of other types from Lua code,
-you must use the debug library (<a href="#6.10">&sect;6.10</a>).)
-If <code>metatable</code> is <b>nil</b>,
-removes the metatable of the given table.
-If the original metatable has a <code>__metatable</code> field,
-raises an error.
-
-
-<p>
-This function returns <code>table</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-tonumber"><code>tonumber (e [, base])</code></a></h3>
-
-
-<p>
-When called with no <code>base</code>,
-<code>tonumber</code> tries to convert its argument to a number.
-If the argument is already a number or
-a string convertible to a number,
-then <code>tonumber</code> returns this number;
-otherwise, it returns <b>nil</b>.
-
-
-<p>
-The conversion of strings can result in integers or floats,
-according to the lexical conventions of Lua (see <a href="#3.1">&sect;3.1</a>).
-(The string may have leading and trailing spaces and a sign.)
-
-
-<p>
-When called with <code>base</code>,
-then <code>e</code> must be a string to be interpreted as
-an integer numeral in that base.
-The base may be any integer between 2 and 36, inclusive.
-In bases above&nbsp;10, the letter '<code>A</code>' (in either upper or lower case)
-represents&nbsp;10, '<code>B</code>' represents&nbsp;11, and so forth,
-with '<code>Z</code>' representing 35.
-If the string <code>e</code> is not a valid numeral in the given base,
-the function returns <b>nil</b>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-tostring"><code>tostring (v)</code></a></h3>
-Receives a value of any type and
-converts it to a string in a human-readable format.
-(For complete control of how numbers are converted,
-use <a href="#pdf-string.format"><code>string.format</code></a>.)
-
-
-<p>
-If the metatable of <code>v</code> has a <code>__tostring</code> field,
-then <code>tostring</code> calls the corresponding value
-with <code>v</code> as argument,
-and uses the result of the call as its result.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-type"><code>type (v)</code></a></h3>
-Returns the type of its only argument, coded as a string.
-The possible results of this function are
-"<code>nil</code>" (a string, not the value <b>nil</b>),
-"<code>number</code>",
-"<code>string</code>",
-"<code>boolean</code>",
-"<code>table</code>",
-"<code>function</code>",
-"<code>thread</code>",
-and "<code>userdata</code>".
-
-
-
-
-<p>
-<hr><h3><a name="pdf-_VERSION"><code>_VERSION</code></a></h3>
-
-
-<p>
-A global variable (not a function) that
-holds a string containing the running Lua version.
-The current value of this variable is "<code>Lua 5.3</code>".
-
-
-
-
-<p>
-<hr><h3><a name="pdf-xpcall"><code>xpcall (f, msgh [, arg1, &middot;&middot;&middot;])</code></a></h3>
-
-
-<p>
-This function is similar to <a href="#pdf-pcall"><code>pcall</code></a>,
-except that it sets a new message handler <code>msgh</code>.
-
-
-
-
-
-
-
-<h2>6.2 &ndash; <a name="6.2">Coroutine Manipulation</a></h2>
-
-<p>
-This library comprises the operations to manipulate coroutines,
-which come inside the table <a name="pdf-coroutine"><code>coroutine</code></a>.
-See <a href="#2.6">&sect;2.6</a> for a general description of coroutines.
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.create"><code>coroutine.create (f)</code></a></h3>
-
-
-<p>
-Creates a new coroutine, with body <code>f</code>.
-<code>f</code> must be a function.
-Returns this new coroutine,
-an object with type <code>"thread"</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.isyieldable"><code>coroutine.isyieldable ()</code></a></h3>
-
-
-<p>
-Returns true when the running coroutine can yield.
-
-
-<p>
-A running coroutine is yieldable if it is not the main thread and
-it is not inside a non-yieldable C&nbsp;function.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.resume"><code>coroutine.resume (co [, val1, &middot;&middot;&middot;])</code></a></h3>
-
-
-<p>
-Starts or continues the execution of coroutine <code>co</code>.
-The first time you resume a coroutine,
-it starts running its body.
-The values <code>val1</code>, ... are passed
-as the arguments to the body function.
-If the coroutine has yielded,
-<code>resume</code> restarts it;
-the values <code>val1</code>, ... are passed
-as the results from the yield.
-
-
-<p>
-If the coroutine runs without any errors,
-<code>resume</code> returns <b>true</b> plus any values passed to <code>yield</code>
-(when the coroutine yields) or any values returned by the body function
-(when the coroutine terminates).
-If there is any error,
-<code>resume</code> returns <b>false</b> plus the error message.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.running"><code>coroutine.running ()</code></a></h3>
-
-
-<p>
-Returns the running coroutine plus a boolean,
-true when the running coroutine is the main one.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.status"><code>coroutine.status (co)</code></a></h3>
-
-
-<p>
-Returns the status of coroutine <code>co</code>, as a string:
-<code>"running"</code>,
-if the coroutine is running (that is, it called <code>status</code>);
-<code>"suspended"</code>, if the coroutine is suspended in a call to <code>yield</code>,
-or if it has not started running yet;
-<code>"normal"</code> if the coroutine is active but not running
-(that is, it has resumed another coroutine);
-and <code>"dead"</code> if the coroutine has finished its body function,
-or if it has stopped with an error.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.wrap"><code>coroutine.wrap (f)</code></a></h3>
-
-
-<p>
-Creates a new coroutine, with body <code>f</code>.
-<code>f</code> must be a function.
-Returns a function that resumes the coroutine each time it is called.
-Any arguments passed to the function behave as the
-extra arguments to <code>resume</code>.
-Returns the same values returned by <code>resume</code>,
-except the first boolean.
-In case of error, propagates the error.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-coroutine.yield"><code>coroutine.yield (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Suspends the execution of the calling coroutine.
-Any arguments to <code>yield</code> are passed as extra results to <code>resume</code>.
-
-
-
-
-
-
-
-<h2>6.3 &ndash; <a name="6.3">Modules</a></h2>
-
-<p>
-The package library provides basic
-facilities for loading modules in Lua.
-It exports one function directly in the global environment:
-<a href="#pdf-require"><code>require</code></a>.
-Everything else is exported in a table <a name="pdf-package"><code>package</code></a>.
-
-
-<p>
-<hr><h3><a name="pdf-require"><code>require (modname)</code></a></h3>
-
-
-<p>
-Loads the given module.
-The function starts by looking into the <a href="#pdf-package.loaded"><code>package.loaded</code></a> table
-to determine whether <code>modname</code> is already loaded.
-If it is, then <code>require</code> returns the value stored
-at <code>package.loaded[modname]</code>.
-Otherwise, it tries to find a <em>loader</em> for the module.
-
-
-<p>
-To find a loader,
-<code>require</code> is guided by the <a href="#pdf-package.searchers"><code>package.searchers</code></a> sequence.
-By changing this sequence,
-we can change how <code>require</code> looks for a module.
-The following explanation is based on the default configuration
-for <a href="#pdf-package.searchers"><code>package.searchers</code></a>.
-
-
-<p>
-First <code>require</code> queries <code>package.preload[modname]</code>.
-If it has a value,
-this value (which must be a function) is the loader.
-Otherwise <code>require</code> searches for a Lua loader using the
-path stored in <a href="#pdf-package.path"><code>package.path</code></a>.
-If that also fails, it searches for a C&nbsp;loader using the
-path stored in <a href="#pdf-package.cpath"><code>package.cpath</code></a>.
-If that also fails,
-it tries an <em>all-in-one</em> loader (see <a href="#pdf-package.searchers"><code>package.searchers</code></a>).
-
-
-<p>
-Once a loader is found,
-<code>require</code> calls the loader with two arguments:
-<code>modname</code> and an extra value dependent on how it got the loader.
-(If the loader came from a file,
-this extra value is the file name.)
-If the loader returns any non-nil value,
-<code>require</code> assigns the returned value to <code>package.loaded[modname]</code>.
-If the loader does not return a non-nil value and
-has not assigned any value to <code>package.loaded[modname]</code>,
-then <code>require</code> assigns <b>true</b> to this entry.
-In any case, <code>require</code> returns the
-final value of <code>package.loaded[modname]</code>.
-
-
-<p>
-If there is any error loading or running the module,
-or if it cannot find any loader for the module,
-then <code>require</code> raises an error.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.config"><code>package.config</code></a></h3>
-
-
-<p>
-A string describing some compile-time configurations for packages.
-This string is a sequence of lines:
-
-<ul>
-
-<li>The first line is the directory separator string.
-Default is '<code>\</code>' for Windows and '<code>/</code>' for all other systems.</li>
-
-<li>The second line is the character that separates templates in a path.
-Default is '<code>;</code>'.</li>
-
-<li>The third line is the string that marks the
-substitution points in a template.
-Default is '<code>?</code>'.</li>
-
-<li>The fourth line is a string that, in a path in Windows,
-is replaced by the executable's directory.
-Default is '<code>!</code>'.</li>
-
-<li>The fifth line is a mark to ignore all text after it
-when building the <code>luaopen_</code> function name.
-Default is '<code>-</code>'.</li>
-
-</ul>
-
-
-
-<p>
-<hr><h3><a name="pdf-package.cpath"><code>package.cpath</code></a></h3>
-
-
-<p>
-The path used by <a href="#pdf-require"><code>require</code></a> to search for a C&nbsp;loader.
-
-
-<p>
-Lua initializes the C&nbsp;path <a href="#pdf-package.cpath"><code>package.cpath</code></a> in the same way
-it initializes the Lua path <a href="#pdf-package.path"><code>package.path</code></a>,
-using the environment variable <a name="pdf-LUA_CPATH_5_3"><code>LUA_CPATH_5_3</code></a>,
-or the environment variable <a name="pdf-LUA_CPATH"><code>LUA_CPATH</code></a>,
-or a default path defined in <code>luaconf.h</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.loaded"><code>package.loaded</code></a></h3>
-
-
-<p>
-A table used by <a href="#pdf-require"><code>require</code></a> to control which
-modules are already loaded.
-When you require a module <code>modname</code> and
-<code>package.loaded[modname]</code> is not false,
-<a href="#pdf-require"><code>require</code></a> simply returns the value stored there.
-
-
-<p>
-This variable is only a reference to the real table;
-assignments to this variable do not change the
-table used by <a href="#pdf-require"><code>require</code></a>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.loadlib"><code>package.loadlib (libname, funcname)</code></a></h3>
-
-
-<p>
-Dynamically links the host program with the C&nbsp;library <code>libname</code>.
-
-
-<p>
-If <code>funcname</code> is "<code>*</code>",
-then it only links with the library,
-making the symbols exported by the library
-available to other dynamically linked libraries.
-Otherwise,
-it looks for a function <code>funcname</code> inside the library
-and returns this function as a C&nbsp;function.
-So, <code>funcname</code> must follow the <a href="#lua_CFunction"><code>lua_CFunction</code></a> prototype
-(see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
-
-
-<p>
-This is a low-level function.
-It completely bypasses the package and module system.
-Unlike <a href="#pdf-require"><code>require</code></a>,
-it does not perform any path searching and
-does not automatically adds extensions.
-<code>libname</code> must be the complete file name of the C&nbsp;library,
-including if necessary a path and an extension.
-<code>funcname</code> must be the exact name exported by the C&nbsp;library
-(which may depend on the C&nbsp;compiler and linker used).
-
-
-<p>
-This function is not supported by Standard&nbsp;C.
-As such, it is only available on some platforms
-(Windows, Linux, Mac OS X, Solaris, BSD,
-plus other Unix systems that support the <code>dlfcn</code> standard).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.path"><code>package.path</code></a></h3>
-
-
-<p>
-The path used by <a href="#pdf-require"><code>require</code></a> to search for a Lua loader.
-
-
-<p>
-At start-up, Lua initializes this variable with
-the value of the environment variable <a name="pdf-LUA_PATH_5_3"><code>LUA_PATH_5_3</code></a> or
-the environment variable <a name="pdf-LUA_PATH"><code>LUA_PATH</code></a> or
-with a default path defined in <code>luaconf.h</code>,
-if those environment variables are not defined.
-Any "<code>;;</code>" in the value of the environment variable
-is replaced by the default path.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.preload"><code>package.preload</code></a></h3>
-
-
-<p>
-A table to store loaders for specific modules
-(see <a href="#pdf-require"><code>require</code></a>).
-
-
-<p>
-This variable is only a reference to the real table;
-assignments to this variable do not change the
-table used by <a href="#pdf-require"><code>require</code></a>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.searchers"><code>package.searchers</code></a></h3>
-
-
-<p>
-A table used by <a href="#pdf-require"><code>require</code></a> to control how to load modules.
-
-
-<p>
-Each entry in this table is a <em>searcher function</em>.
-When looking for a module,
-<a href="#pdf-require"><code>require</code></a> calls each of these searchers in ascending order,
-with the module name (the argument given to <a href="#pdf-require"><code>require</code></a>) as its
-sole parameter.
-The function can return another function (the module <em>loader</em>)
-plus an extra value that will be passed to that loader,
-or a string explaining why it did not find that module
-(or <b>nil</b> if it has nothing to say).
-
-
-<p>
-Lua initializes this table with four searcher functions.
-
-
-<p>
-The first searcher simply looks for a loader in the
-<a href="#pdf-package.preload"><code>package.preload</code></a> table.
-
-
-<p>
-The second searcher looks for a loader as a Lua library,
-using the path stored at <a href="#pdf-package.path"><code>package.path</code></a>.
-The search is done as described in function <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>.
-
-
-<p>
-The third searcher looks for a loader as a C&nbsp;library,
-using the path given by the variable <a href="#pdf-package.cpath"><code>package.cpath</code></a>.
-Again,
-the search is done as described in function <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>.
-For instance,
-if the C&nbsp;path is the string
-
-<pre>
-     "./?.so;./?.dll;/usr/local/?/init.so"
-</pre><p>
-the searcher for module <code>foo</code>
-will try to open the files <code>./foo.so</code>, <code>./foo.dll</code>,
-and <code>/usr/local/foo/init.so</code>, in that order.
-Once it finds a C&nbsp;library,
-this searcher first uses a dynamic link facility to link the
-application with the library.
-Then it tries to find a C&nbsp;function inside the library to
-be used as the loader.
-The name of this C&nbsp;function is the string "<code>luaopen_</code>"
-concatenated with a copy of the module name where each dot
-is replaced by an underscore.
-Moreover, if the module name has a hyphen,
-its suffix after (and including) the first hyphen is removed.
-For instance, if the module name is <code>a.b.c-v2.1</code>,
-the function name will be <code>luaopen_a_b_c</code>.
-
-
-<p>
-The fourth searcher tries an <em>all-in-one loader</em>.
-It searches the C&nbsp;path for a library for
-the root name of the given module.
-For instance, when requiring <code>a.b.c</code>,
-it will search for a C&nbsp;library for <code>a</code>.
-If found, it looks into it for an open function for
-the submodule;
-in our example, that would be <code>luaopen_a_b_c</code>.
-With this facility, a package can pack several C&nbsp;submodules
-into one single library,
-with each submodule keeping its original open function.
-
-
-<p>
-All searchers except the first one (preload) return as the extra value
-the file name where the module was found,
-as returned by <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>.
-The first searcher returns no extra value.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-package.searchpath"><code>package.searchpath (name, path [, sep [, rep]])</code></a></h3>
-
-
-<p>
-Searches for the given <code>name</code> in the given <code>path</code>.
-
-
-<p>
-A path is a string containing a sequence of
-<em>templates</em> separated by semicolons.
-For each template,
-the function replaces each interrogation mark (if any)
-in the template with a copy of <code>name</code>
-wherein all occurrences of <code>sep</code>
-(a dot, by default)
-were replaced by <code>rep</code>
-(the system's directory separator, by default),
-and then tries to open the resulting file name.
-
-
-<p>
-For instance, if the path is the string
-
-<pre>
-     "./?.lua;./?.lc;/usr/local/?/init.lua"
-</pre><p>
-the search for the name <code>foo.a</code>
-will try to open the files
-<code>./foo/a.lua</code>, <code>./foo/a.lc</code>, and
-<code>/usr/local/foo/a/init.lua</code>, in that order.
-
-
-<p>
-Returns the resulting name of the first file that it can
-open in read mode (after closing the file),
-or <b>nil</b> plus an error message if none succeeds.
-(This error message lists all file names it tried to open.)
-
-
-
-
-
-
-
-<h2>6.4 &ndash; <a name="6.4">String Manipulation</a></h2>
-
-<p>
-This library provides generic functions for string manipulation,
-such as finding and extracting substrings, and pattern matching.
-When indexing a string in Lua, the first character is at position&nbsp;1
-(not at&nbsp;0, as in C).
-Indices are allowed to be negative and are interpreted as indexing backwards,
-from the end of the string.
-Thus, the last character is at position -1, and so on.
-
-
-<p>
-The string library provides all its functions inside the table
-<a name="pdf-string"><code>string</code></a>.
-It also sets a metatable for strings
-where the <code>__index</code> field points to the <code>string</code> table.
-Therefore, you can use the string functions in object-oriented style.
-For instance, <code>string.byte(s,i)</code>
-can be written as <code>s:byte(i)</code>.
-
-
-<p>
-The string library assumes one-byte character encodings.
-
-
-<p>
-<hr><h3><a name="pdf-string.byte"><code>string.byte (s [, i [, j]])</code></a></h3>
-Returns the internal numeric codes of the characters <code>s[i]</code>,
-<code>s[i+1]</code>, ..., <code>s[j]</code>.
-The default value for <code>i</code> is&nbsp;1;
-the default value for <code>j</code> is&nbsp;<code>i</code>.
-These indices are corrected
-following the same rules of function <a href="#pdf-string.sub"><code>string.sub</code></a>.
-
-
-<p>
-Numeric codes are not necessarily portable across platforms.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.char"><code>string.char (&middot;&middot;&middot;)</code></a></h3>
-Receives zero or more integers.
-Returns a string with length equal to the number of arguments,
-in which each character has the internal numeric code equal
-to its corresponding argument.
-
-
-<p>
-Numeric codes are not necessarily portable across platforms.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.dump"><code>string.dump (function [, strip])</code></a></h3>
-
-
-<p>
-Returns a string containing a binary representation
-(a <em>binary chunk</em>)
-of the given function,
-so that a later <a href="#pdf-load"><code>load</code></a> on this string returns
-a copy of the function (but with new upvalues).
-If <code>strip</code> is a true value,
-the binary representation may not include all debug information
-about the function,
-to save space.
-
-
-<p>
-Functions with upvalues have only their number of upvalues saved.
-When (re)loaded,
-those upvalues receive fresh instances containing <b>nil</b>.
-(You can use the debug library to serialize
-and reload the upvalues of a function
-in a way adequate to your needs.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.find"><code>string.find (s, pattern [, init [, plain]])</code></a></h3>
-
-
-<p>
-Looks for the first match of
-<code>pattern</code> (see <a href="#6.4.1">&sect;6.4.1</a>) in the string <code>s</code>.
-If it finds a match, then <code>find</code> returns the indices of&nbsp;<code>s</code>
-where this occurrence starts and ends;
-otherwise, it returns <b>nil</b>.
-A third, optional numeric argument <code>init</code> specifies
-where to start the search;
-its default value is&nbsp;1 and can be negative.
-A value of <b>true</b> as a fourth, optional argument <code>plain</code>
-turns off the pattern matching facilities,
-so the function does a plain "find substring" operation,
-with no characters in <code>pattern</code> being considered magic.
-Note that if <code>plain</code> is given, then <code>init</code> must be given as well.
-
-
-<p>
-If the pattern has captures,
-then in a successful match
-the captured values are also returned,
-after the two indices.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.format"><code>string.format (formatstring, &middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Returns a formatted version of its variable number of arguments
-following the description given in its first argument (which must be a string).
-The format string follows the same rules as the ISO&nbsp;C function <code>sprintf</code>.
-The only differences are that the options/modifiers
-<code>*</code>, <code>h</code>, <code>L</code>, <code>l</code>, <code>n</code>,
-and <code>p</code> are not supported
-and that there is an extra option, <code>q</code>.
-
-
-<p>
-The <code>q</code> option formats a string between double quotes,
-using escape sequences when necessary to ensure that
-it can safely be read back by the Lua interpreter.
-For instance, the call
-
-<pre>
-     string.format('%q', 'a string with "quotes" and \n new line')
-</pre><p>
-may produce the string:
-
-<pre>
-     "a string with \"quotes\" and \
-      new line"
-</pre>
-
-<p>
-Options
-<code>A</code>, <code>a</code>, <code>E</code>, <code>e</code>, <code>f</code>,
-<code>G</code>, and <code>g</code> all expect a number as argument.
-Options <code>c</code>, <code>d</code>,
-<code>i</code>, <code>o</code>, <code>u</code>, <code>X</code>, and <code>x</code>
-expect an integer.
-When Lua is compiled with a C89 compiler,
-options <code>A</code> and <code>a</code> (hexadecimal floats)
-do not support any modifier (flags, width, length).
-
-
-<p>
-Option <code>s</code> expects a string;
-if its argument is not a string,
-it is converted to one following the same rules of <a href="#pdf-tostring"><code>tostring</code></a>.
-If the option has any modifier (flags, width, length),
-the string argument should not contain embedded zeros.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.gmatch"><code>string.gmatch (s, pattern)</code></a></h3>
-Returns an iterator function that,
-each time it is called,
-returns the next captures from <code>pattern</code> (see <a href="#6.4.1">&sect;6.4.1</a>)
-over the string <code>s</code>.
-If <code>pattern</code> specifies no captures,
-then the whole match is produced in each call.
-
-
-<p>
-As an example, the following loop
-will iterate over all the words from string <code>s</code>,
-printing one per line:
-
-<pre>
-     s = "hello world from Lua"
-     for w in string.gmatch(s, "%a+") do
-       print(w)
-     end
-</pre><p>
-The next example collects all pairs <code>key=value</code> from the
-given string into a table:
-
-<pre>
-     t = {}
-     s = "from=world, to=Lua"
-     for k, v in string.gmatch(s, "(%w+)=(%w+)") do
-       t[k] = v
-     end
-</pre>
-
-<p>
-For this function, a caret '<code>^</code>' at the start of a pattern does not
-work as an anchor, as this would prevent the iteration.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.gsub"><code>string.gsub (s, pattern, repl [, n])</code></a></h3>
-Returns a copy of <code>s</code>
-in which all (or the first <code>n</code>, if given)
-occurrences of the <code>pattern</code> (see <a href="#6.4.1">&sect;6.4.1</a>) have been
-replaced by a replacement string specified by <code>repl</code>,
-which can be a string, a table, or a function.
-<code>gsub</code> also returns, as its second value,
-the total number of matches that occurred.
-The name <code>gsub</code> comes from <em>Global SUBstitution</em>.
-
-
-<p>
-If <code>repl</code> is a string, then its value is used for replacement.
-The character&nbsp;<code>%</code> works as an escape character:
-any sequence in <code>repl</code> of the form <code>%<em>d</em></code>,
-with <em>d</em> between 1 and 9,
-stands for the value of the <em>d</em>-th captured substring.
-The sequence <code>%0</code> stands for the whole match.
-The sequence <code>%%</code> stands for a single&nbsp;<code>%</code>.
-
-
-<p>
-If <code>repl</code> is a table, then the table is queried for every match,
-using the first capture as the key.
-
-
-<p>
-If <code>repl</code> is a function, then this function is called every time a
-match occurs, with all captured substrings passed as arguments,
-in order.
-
-
-<p>
-In any case,
-if the pattern specifies no captures,
-then it behaves as if the whole pattern was inside a capture.
-
-
-<p>
-If the value returned by the table query or by the function call
-is a string or a number,
-then it is used as the replacement string;
-otherwise, if it is <b>false</b> or <b>nil</b>,
-then there is no replacement
-(that is, the original match is kept in the string).
-
-
-<p>
-Here are some examples:
-
-<pre>
-     x = string.gsub("hello world", "(%w+)", "%1 %1")
-     --&gt; x="hello hello world world"
-     
-     x = string.gsub("hello world", "%w+", "%0 %0", 1)
-     --&gt; x="hello hello world"
-     
-     x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
-     --&gt; x="world hello Lua from"
-     
-     x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
-     --&gt; x="home = /home/roberto, user = roberto"
-     
-     x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
-           return load(s)()
-         end)
-     --&gt; x="4+5 = 9"
-     
-     local t = {name="lua", version="5.3"}
-     x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
-     --&gt; x="lua-5.3.tar.gz"
-</pre>
-
-
-
-<p>
-<hr><h3><a name="pdf-string.len"><code>string.len (s)</code></a></h3>
-Receives a string and returns its length.
-The empty string <code>""</code> has length 0.
-Embedded zeros are counted,
-so <code>"a\000bc\000"</code> has length 5.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.lower"><code>string.lower (s)</code></a></h3>
-Receives a string and returns a copy of this string with all
-uppercase letters changed to lowercase.
-All other characters are left unchanged.
-The definition of what an uppercase letter is depends on the current locale.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.match"><code>string.match (s, pattern [, init])</code></a></h3>
-Looks for the first <em>match</em> of
-<code>pattern</code> (see <a href="#6.4.1">&sect;6.4.1</a>) in the string <code>s</code>.
-If it finds one, then <code>match</code> returns
-the captures from the pattern;
-otherwise it returns <b>nil</b>.
-If <code>pattern</code> specifies no captures,
-then the whole match is returned.
-A third, optional numeric argument <code>init</code> specifies
-where to start the search;
-its default value is&nbsp;1 and can be negative.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.pack"><code>string.pack (fmt, v1, v2, &middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Returns a binary string containing the values <code>v1</code>, <code>v2</code>, etc.
-packed (that is, serialized in binary form)
-according to the format string <code>fmt</code> (see <a href="#6.4.2">&sect;6.4.2</a>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.packsize"><code>string.packsize (fmt)</code></a></h3>
-
-
-<p>
-Returns the size of a string resulting from <a href="#pdf-string.pack"><code>string.pack</code></a>
-with the given format.
-The format string cannot have the variable-length options
-'<code>s</code>' or '<code>z</code>' (see <a href="#6.4.2">&sect;6.4.2</a>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.rep"><code>string.rep (s, n [, sep])</code></a></h3>
-Returns a string that is the concatenation of <code>n</code> copies of
-the string <code>s</code> separated by the string <code>sep</code>.
-The default value for <code>sep</code> is the empty string
-(that is, no separator).
-Returns the empty string if <code>n</code> is not positive.
-
-
-<p>
-(Note that it is very easy to exhaust the memory of your machine
-with a single call to this function.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.reverse"><code>string.reverse (s)</code></a></h3>
-Returns a string that is the string <code>s</code> reversed.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.sub"><code>string.sub (s, i [, j])</code></a></h3>
-Returns the substring of <code>s</code> that
-starts at <code>i</code>  and continues until <code>j</code>;
-<code>i</code> and <code>j</code> can be negative.
-If <code>j</code> is absent, then it is assumed to be equal to -1
-(which is the same as the string length).
-In particular,
-the call <code>string.sub(s,1,j)</code> returns a prefix of <code>s</code>
-with length <code>j</code>,
-and <code>string.sub(s, -i)</code> (for a positive <code>i</code>)
-returns a suffix of <code>s</code>
-with length <code>i</code>.
-
-
-<p>
-If, after the translation of negative indices,
-<code>i</code> is less than 1,
-it is corrected to 1.
-If <code>j</code> is greater than the string length,
-it is corrected to that length.
-If, after these corrections,
-<code>i</code> is greater than <code>j</code>,
-the function returns the empty string.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.unpack"><code>string.unpack (fmt, s [, pos])</code></a></h3>
-
-
-<p>
-Returns the values packed in string <code>s</code> (see <a href="#pdf-string.pack"><code>string.pack</code></a>)
-according to the format string <code>fmt</code> (see <a href="#6.4.2">&sect;6.4.2</a>).
-An optional <code>pos</code> marks where
-to start reading in <code>s</code> (default is 1).
-After the read values,
-this function also returns the index of the first unread byte in <code>s</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-string.upper"><code>string.upper (s)</code></a></h3>
-Receives a string and returns a copy of this string with all
-lowercase letters changed to uppercase.
-All other characters are left unchanged.
-The definition of what a lowercase letter is depends on the current locale.
-
-
-
-
-
-<h3>6.4.1 &ndash; <a name="6.4.1">Patterns</a></h3>
-
-<p>
-Patterns in Lua are described by regular strings,
-which are interpreted as patterns by the pattern-matching functions
-<a href="#pdf-string.find"><code>string.find</code></a>,
-<a href="#pdf-string.gmatch"><code>string.gmatch</code></a>,
-<a href="#pdf-string.gsub"><code>string.gsub</code></a>,
-and <a href="#pdf-string.match"><code>string.match</code></a>.
-This section describes the syntax and the meaning
-(that is, what they match) of these strings.
-
-
-
-<h4>Character Class:</h4><p>
-A <em>character class</em> is used to represent a set of characters.
-The following combinations are allowed in describing a character class:
-
-<ul>
-
-<li><b><em>x</em>: </b>
-(where <em>x</em> is not one of the <em>magic characters</em>
-<code>^$()%.[]*+-?</code>)
-represents the character <em>x</em> itself.
-</li>
-
-<li><b><code>.</code>: </b> (a dot) represents all characters.</li>
-
-<li><b><code>%a</code>: </b> represents all letters.</li>
-
-<li><b><code>%c</code>: </b> represents all control characters.</li>
-
-<li><b><code>%d</code>: </b> represents all digits.</li>
-
-<li><b><code>%g</code>: </b> represents all printable characters except space.</li>
-
-<li><b><code>%l</code>: </b> represents all lowercase letters.</li>
-
-<li><b><code>%p</code>: </b> represents all punctuation characters.</li>
-
-<li><b><code>%s</code>: </b> represents all space characters.</li>
-
-<li><b><code>%u</code>: </b> represents all uppercase letters.</li>
-
-<li><b><code>%w</code>: </b> represents all alphanumeric characters.</li>
-
-<li><b><code>%x</code>: </b> represents all hexadecimal digits.</li>
-
-<li><b><code>%<em>x</em></code>: </b> (where <em>x</em> is any non-alphanumeric character)
-represents the character <em>x</em>.
-This is the standard way to escape the magic characters.
-Any non-alphanumeric character
-(including all punctuation characters, even the non-magical)
-can be preceded by a '<code>%</code>'
-when used to represent itself in a pattern.
-</li>
-
-<li><b><code>[<em>set</em>]</code>: </b>
-represents the class which is the union of all
-characters in <em>set</em>.
-A range of characters can be specified by
-separating the end characters of the range,
-in ascending order, with a '<code>-</code>'.
-All classes <code>%</code><em>x</em> described above can also be used as
-components in <em>set</em>.
-All other characters in <em>set</em> represent themselves.
-For example, <code>[%w_]</code> (or <code>[_%w]</code>)
-represents all alphanumeric characters plus the underscore,
-<code>[0-7]</code> represents the octal digits,
-and <code>[0-7%l%-]</code> represents the octal digits plus
-the lowercase letters plus the '<code>-</code>' character.
-
-
-<p>
-You can put a closing square bracket in a set
-by positioning it as the first character in the set.
-You can put a hyphen in a set
-by positioning it as the first or the last character in the set.
-(You can also use an escape for both cases.)
-
-
-<p>
-The interaction between ranges and classes is not defined.
-Therefore, patterns like <code>[%a-z]</code> or <code>[a-%%]</code>
-have no meaning.
-</li>
-
-<li><b><code>[^<em>set</em>]</code>: </b>
-represents the complement of <em>set</em>,
-where <em>set</em> is interpreted as above.
-</li>
-
-</ul><p>
-For all classes represented by single letters (<code>%a</code>, <code>%c</code>, etc.),
-the corresponding uppercase letter represents the complement of the class.
-For instance, <code>%S</code> represents all non-space characters.
-
-
-<p>
-The definitions of letter, space, and other character groups
-depend on the current locale.
-In particular, the class <code>[a-z]</code> may not be equivalent to <code>%l</code>.
-
-
-
-
-
-<h4>Pattern Item:</h4><p>
-A <em>pattern item</em> can be
-
-<ul>
-
-<li>
-a single character class,
-which matches any single character in the class;
-</li>
-
-<li>
-a single character class followed by '<code>*</code>',
-which matches zero or more repetitions of characters in the class.
-These repetition items will always match the longest possible sequence;
-</li>
-
-<li>
-a single character class followed by '<code>+</code>',
-which matches one or more repetitions of characters in the class.
-These repetition items will always match the longest possible sequence;
-</li>
-
-<li>
-a single character class followed by '<code>-</code>',
-which also matches zero or more repetitions of characters in the class.
-Unlike '<code>*</code>',
-these repetition items will always match the shortest possible sequence;
-</li>
-
-<li>
-a single character class followed by '<code>?</code>',
-which matches zero or one occurrence of a character in the class.
-It always matches one occurrence if possible;
-</li>
-
-<li>
-<code>%<em>n</em></code>, for <em>n</em> between 1 and 9;
-such item matches a substring equal to the <em>n</em>-th captured string
-(see below);
-</li>
-
-<li>
-<code>%b<em>xy</em></code>, where <em>x</em> and <em>y</em> are two distinct characters;
-such item matches strings that start with&nbsp;<em>x</em>, end with&nbsp;<em>y</em>,
-and where the <em>x</em> and <em>y</em> are <em>balanced</em>.
-This means that, if one reads the string from left to right,
-counting <em>+1</em> for an <em>x</em> and <em>-1</em> for a <em>y</em>,
-the ending <em>y</em> is the first <em>y</em> where the count reaches 0.
-For instance, the item <code>%b()</code> matches expressions with
-balanced parentheses.
-</li>
-
-<li>
-<code>%f[<em>set</em>]</code>, a <em>frontier pattern</em>;
-such item matches an empty string at any position such that
-the next character belongs to <em>set</em>
-and the previous character does not belong to <em>set</em>.
-The set <em>set</em> is interpreted as previously described.
-The beginning and the end of the subject are handled as if
-they were the character '<code>\0</code>'.
-</li>
-
-</ul>
-
-
-
-
-<h4>Pattern:</h4><p>
-A <em>pattern</em> is a sequence of pattern items.
-A caret '<code>^</code>' at the beginning of a pattern anchors the match at the
-beginning of the subject string.
-A '<code>$</code>' at the end of a pattern anchors the match at the
-end of the subject string.
-At other positions,
-'<code>^</code>' and '<code>$</code>' have no special meaning and represent themselves.
-
-
-
-
-
-<h4>Captures:</h4><p>
-A pattern can contain sub-patterns enclosed in parentheses;
-they describe <em>captures</em>.
-When a match succeeds, the substrings of the subject string
-that match captures are stored (<em>captured</em>) for future use.
-Captures are numbered according to their left parentheses.
-For instance, in the pattern <code>"(a*(.)%w(%s*))"</code>,
-the part of the string matching <code>"a*(.)%w(%s*)"</code> is
-stored as the first capture (and therefore has number&nbsp;1);
-the character matching "<code>.</code>" is captured with number&nbsp;2,
-and the part matching "<code>%s*</code>" has number&nbsp;3.
-
-
-<p>
-As a special case, the empty capture <code>()</code> captures
-the current string position (a number).
-For instance, if we apply the pattern <code>"()aa()"</code> on the
-string <code>"flaaap"</code>, there will be two captures: 3&nbsp;and&nbsp;5.
-
-
-
-
-
-
-
-<h3>6.4.2 &ndash; <a name="6.4.2">Format Strings for Pack and Unpack</a></h3>
-
-<p>
-The first argument to <a href="#pdf-string.pack"><code>string.pack</code></a>,
-<a href="#pdf-string.packsize"><code>string.packsize</code></a>, and <a href="#pdf-string.unpack"><code>string.unpack</code></a>
-is a format string,
-which describes the layout of the structure being created or read.
-
-
-<p>
-A format string is a sequence of conversion options.
-The conversion options are as follows:
-
-<ul>
-<li><b><code>&lt;</code>: </b>sets little endian</li>
-<li><b><code>&gt;</code>: </b>sets big endian</li>
-<li><b><code>=</code>: </b>sets native endian</li>
-<li><b><code>![<em>n</em>]</code>: </b>sets maximum alignment to <code>n</code>
-(default is native alignment)</li>
-<li><b><code>b</code>: </b>a signed byte (<code>char</code>)</li>
-<li><b><code>B</code>: </b>an unsigned byte (<code>char</code>)</li>
-<li><b><code>h</code>: </b>a signed <code>short</code> (native size)</li>
-<li><b><code>H</code>: </b>an unsigned <code>short</code> (native size)</li>
-<li><b><code>l</code>: </b>a signed <code>long</code> (native size)</li>
-<li><b><code>L</code>: </b>an unsigned <code>long</code> (native size)</li>
-<li><b><code>j</code>: </b>a <code>lua_Integer</code></li>
-<li><b><code>J</code>: </b>a <code>lua_Unsigned</code></li>
-<li><b><code>T</code>: </b>a <code>size_t</code> (native size)</li>
-<li><b><code>i[<em>n</em>]</code>: </b>a signed <code>int</code> with <code>n</code> bytes
-(default is native size)</li>
-<li><b><code>I[<em>n</em>]</code>: </b>an unsigned <code>int</code> with <code>n</code> bytes
-(default is native size)</li>
-<li><b><code>f</code>: </b>a <code>float</code> (native size)</li>
-<li><b><code>d</code>: </b>a <code>double</code> (native size)</li>
-<li><b><code>n</code>: </b>a <code>lua_Number</code></li>
-<li><b><code>c<em>n</em></code>: </b>a fixed-sized string with <code>n</code> bytes</li>
-<li><b><code>z</code>: </b>a zero-terminated string</li>
-<li><b><code>s[<em>n</em>]</code>: </b>a string preceded by its length
-coded as an unsigned integer with <code>n</code> bytes
-(default is a <code>size_t</code>)</li>
-<li><b><code>x</code>: </b>one byte of padding</li>
-<li><b><code>X<em>op</em></code>: </b>an empty item that aligns
-according to option <code>op</code>
-(which is otherwise ignored)</li>
-<li><b>'<code> </code>': </b>(empty space) ignored</li>
-</ul><p>
-(A "<code>[<em>n</em>]</code>" means an optional integral numeral.)
-Except for padding, spaces, and configurations
-(options "<code>xX &lt;=&gt;!</code>"),
-each option corresponds to an argument (in <a href="#pdf-string.pack"><code>string.pack</code></a>)
-or a result (in <a href="#pdf-string.unpack"><code>string.unpack</code></a>).
-
-
-<p>
-For options "<code>!<em>n</em></code>", "<code>s<em>n</em></code>", "<code>i<em>n</em></code>", and "<code>I<em>n</em></code>",
-<code>n</code> can be any integer between 1 and 16.
-All integral options check overflows;
-<a href="#pdf-string.pack"><code>string.pack</code></a> checks whether the given value fits in the given size;
-<a href="#pdf-string.unpack"><code>string.unpack</code></a> checks whether the read value fits in a Lua integer.
-
-
-<p>
-Any format string starts as if prefixed by "<code>!1=</code>",
-that is,
-with maximum alignment of 1 (no alignment)
-and native endianness.
-
-
-<p>
-Alignment works as follows:
-For each option,
-the format gets extra padding until the data starts
-at an offset that is a multiple of the minimum between the
-option size and the maximum alignment;
-this minimum must be a power of 2.
-Options "<code>c</code>" and "<code>z</code>" are not aligned;
-option "<code>s</code>" follows the alignment of its starting integer.
-
-
-<p>
-All padding is filled with zeros by <a href="#pdf-string.pack"><code>string.pack</code></a>
-(and ignored by <a href="#pdf-string.unpack"><code>string.unpack</code></a>).
-
-
-
-
-
-
-
-<h2>6.5 &ndash; <a name="6.5">UTF-8 Support</a></h2>
-
-<p>
-This library provides basic support for UTF-8 encoding.
-It provides all its functions inside the table <a name="pdf-utf8"><code>utf8</code></a>.
-This library does not provide any support for Unicode other
-than the handling of the encoding.
-Any operation that needs the meaning of a character,
-such as character classification, is outside its scope.
-
-
-<p>
-Unless stated otherwise,
-all functions that expect a byte position as a parameter
-assume that the given position is either the start of a byte sequence
-or one plus the length of the subject string.
-As in the string library,
-negative indices count from the end of the string.
-
-
-<p>
-<hr><h3><a name="pdf-utf8.char"><code>utf8.char (&middot;&middot;&middot;)</code></a></h3>
-Receives zero or more integers,
-converts each one to its corresponding UTF-8 byte sequence
-and returns a string with the concatenation of all these sequences.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-utf8.charpattern"><code>utf8.charpattern</code></a></h3>
-The pattern (a string, not a function) "<code>[\0-\x7F\xC2-\xF4][\x80-\xBF]*</code>"
-(see <a href="#6.4.1">&sect;6.4.1</a>),
-which matches exactly one UTF-8 byte sequence,
-assuming that the subject is a valid UTF-8 string.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-utf8.codes"><code>utf8.codes (s)</code></a></h3>
-
-
-<p>
-Returns values so that the construction
-
-<pre>
-     for p, c in utf8.codes(s) do <em>body</em> end
-</pre><p>
-will iterate over all characters in string <code>s</code>,
-with <code>p</code> being the position (in bytes) and <code>c</code> the code point
-of each character.
-It raises an error if it meets any invalid byte sequence.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-utf8.codepoint"><code>utf8.codepoint (s [, i [, j]])</code></a></h3>
-Returns the codepoints (as integers) from all characters in <code>s</code>
-that start between byte position <code>i</code> and <code>j</code> (both included).
-The default for <code>i</code> is 1 and for <code>j</code> is <code>i</code>.
-It raises an error if it meets any invalid byte sequence.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-utf8.len"><code>utf8.len (s [, i [, j]])</code></a></h3>
-Returns the number of UTF-8 characters in string <code>s</code>
-that start between positions <code>i</code> and <code>j</code> (both inclusive).
-The default for <code>i</code> is 1 and for <code>j</code> is -1.
-If it finds any invalid byte sequence,
-returns a false value plus the position of the first invalid byte.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-utf8.offset"><code>utf8.offset (s, n [, i])</code></a></h3>
-Returns the position (in bytes) where the encoding of the
-<code>n</code>-th character of <code>s</code>
-(counting from position <code>i</code>) starts.
-A negative <code>n</code> gets characters before position <code>i</code>.
-The default for <code>i</code> is 1 when <code>n</code> is non-negative
-and <code>#s + 1</code> otherwise,
-so that <code>utf8.offset(s, -n)</code> gets the offset of the
-<code>n</code>-th character from the end of the string.
-If the specified character is neither in the subject
-nor right after its end,
-the function returns <b>nil</b>.
-
-
-<p>
-As a special case,
-when <code>n</code> is 0 the function returns the start of the encoding
-of the character that contains the <code>i</code>-th byte of <code>s</code>.
-
-
-<p>
-This function assumes that <code>s</code> is a valid UTF-8 string.
-
-
-
-
-
-
-
-<h2>6.6 &ndash; <a name="6.6">Table Manipulation</a></h2>
-
-<p>
-This library provides generic functions for table manipulation.
-It provides all its functions inside the table <a name="pdf-table"><code>table</code></a>.
-
-
-<p>
-Remember that, whenever an operation needs the length of a table,
-all caveats about the length operator apply (see <a href="#3.4.7">&sect;3.4.7</a>).
-All functions ignore non-numeric keys
-in the tables given as arguments.
-
-
-<p>
-<hr><h3><a name="pdf-table.concat"><code>table.concat (list [, sep [, i [, j]]])</code></a></h3>
-
-
-<p>
-Given a list where all elements are strings or numbers,
-returns the string <code>list[i]..sep..list[i+1] &middot;&middot;&middot; sep..list[j]</code>.
-The default value for <code>sep</code> is the empty string,
-the default for <code>i</code> is 1,
-and the default for <code>j</code> is <code>#list</code>.
-If <code>i</code> is greater than <code>j</code>, returns the empty string.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.insert"><code>table.insert (list, [pos,] value)</code></a></h3>
-
-
-<p>
-Inserts element <code>value</code> at position <code>pos</code> in <code>list</code>,
-shifting up the elements
-<code>list[pos], list[pos+1], &middot;&middot;&middot;, list[#list]</code>.
-The default value for <code>pos</code> is <code>#list+1</code>,
-so that a call <code>table.insert(t,x)</code> inserts <code>x</code> at the end
-of list <code>t</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.move"><code>table.move (a1, f, e, t [,a2])</code></a></h3>
-
-
-<p>
-Moves elements from table <code>a1</code> to table <code>a2</code>,
-performing the equivalent to the following
-multiple assignment:
-<code>a2[t],&middot;&middot;&middot; = a1[f],&middot;&middot;&middot;,a1[e]</code>.
-The default for <code>a2</code> is <code>a1</code>.
-The destination range can overlap with the source range.
-The number of elements to be moved must fit in a Lua integer.
-
-
-<p>
-Returns the destination table <code>a2</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.pack"><code>table.pack (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Returns a new table with all arguments stored into keys 1, 2, etc.
-and with a field "<code>n</code>" with the total number of arguments.
-Note that the resulting table may not be a sequence.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.remove"><code>table.remove (list [, pos])</code></a></h3>
-
-
-<p>
-Removes from <code>list</code> the element at position <code>pos</code>,
-returning the value of the removed element.
-When <code>pos</code> is an integer between 1 and <code>#list</code>,
-it shifts down the elements
-<code>list[pos+1], list[pos+2], &middot;&middot;&middot;, list[#list]</code>
-and erases element <code>list[#list]</code>;
-The index <code>pos</code> can also be 0 when <code>#list</code> is 0,
-or <code>#list + 1</code>;
-in those cases, the function erases the element <code>list[pos]</code>.
-
-
-<p>
-The default value for <code>pos</code> is <code>#list</code>,
-so that a call <code>table.remove(l)</code> removes the last element
-of list <code>l</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.sort"><code>table.sort (list [, comp])</code></a></h3>
-
-
-<p>
-Sorts list elements in a given order, <em>in-place</em>,
-from <code>list[1]</code> to <code>list[#list]</code>.
-If <code>comp</code> is given,
-then it must be a function that receives two list elements
-and returns true when the first element must come
-before the second in the final order
-(so that, after the sort,
-<code>i &lt; j</code> implies <code>not comp(list[j],list[i])</code>).
-If <code>comp</code> is not given,
-then the standard Lua operator <code>&lt;</code> is used instead.
-
-
-<p>
-Note that the <code>comp</code> function must define
-a strict partial order over the elements in the list;
-that is, it must be asymmetric and transitive.
-Otherwise, no valid sort may be possible.
-
-
-<p>
-The sort algorithm is not stable:
-elements considered equal by the given order
-may have their relative positions changed by the sort.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-table.unpack"><code>table.unpack (list [, i [, j]])</code></a></h3>
-
-
-<p>
-Returns the elements from the given list.
-This function is equivalent to
-
-<pre>
-     return list[i], list[i+1], &middot;&middot;&middot;, list[j]
-</pre><p>
-By default, <code>i</code> is&nbsp;1 and <code>j</code> is <code>#list</code>.
-
-
-
-
-
-
-
-<h2>6.7 &ndash; <a name="6.7">Mathematical Functions</a></h2>
-
-<p>
-This library provides basic mathematical functions.
-It provides all its functions and constants inside the table <a name="pdf-math"><code>math</code></a>.
-Functions with the annotation "<code>integer/float</code>" give
-integer results for integer arguments
-and float results for float (or mixed) arguments.
-Rounding functions
-(<a href="#pdf-math.ceil"><code>math.ceil</code></a>, <a href="#pdf-math.floor"><code>math.floor</code></a>, and <a href="#pdf-math.modf"><code>math.modf</code></a>)
-return an integer when the result fits in the range of an integer,
-or a float otherwise.
-
-
-<p>
-<hr><h3><a name="pdf-math.abs"><code>math.abs (x)</code></a></h3>
-
-
-<p>
-Returns the absolute value of <code>x</code>. (integer/float)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.acos"><code>math.acos (x)</code></a></h3>
-
-
-<p>
-Returns the arc cosine of <code>x</code> (in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.asin"><code>math.asin (x)</code></a></h3>
-
-
-<p>
-Returns the arc sine of <code>x</code> (in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.atan"><code>math.atan (y [, x])</code></a></h3>
-
-
-<p>
-
-Returns the arc tangent of <code>y/x</code> (in radians),
-but uses the signs of both arguments to find the
-quadrant of the result.
-(It also handles correctly the case of <code>x</code> being zero.)
-
-
-<p>
-The default value for <code>x</code> is 1,
-so that the call <code>math.atan(y)</code>
-returns the arc tangent of <code>y</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.ceil"><code>math.ceil (x)</code></a></h3>
-
-
-<p>
-Returns the smallest integral value larger than or equal to <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.cos"><code>math.cos (x)</code></a></h3>
-
-
-<p>
-Returns the cosine of <code>x</code> (assumed to be in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.deg"><code>math.deg (x)</code></a></h3>
-
-
-<p>
-Converts the angle <code>x</code> from radians to degrees.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.exp"><code>math.exp (x)</code></a></h3>
-
-
-<p>
-Returns the value <em>e<sup>x</sup></em>
-(where <code>e</code> is the base of natural logarithms).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.floor"><code>math.floor (x)</code></a></h3>
-
-
-<p>
-Returns the largest integral value smaller than or equal to <code>x</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.fmod"><code>math.fmod (x, y)</code></a></h3>
-
-
-<p>
-Returns the remainder of the division of <code>x</code> by <code>y</code>
-that rounds the quotient towards zero. (integer/float)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.huge"><code>math.huge</code></a></h3>
-
-
-<p>
-The float value <code>HUGE_VAL</code>,
-a value larger than any other numeric value.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.log"><code>math.log (x [, base])</code></a></h3>
-
-
-<p>
-Returns the logarithm of <code>x</code> in the given base.
-The default for <code>base</code> is <em>e</em>
-(so that the function returns the natural logarithm of <code>x</code>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.max"><code>math.max (x, &middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Returns the argument with the maximum value,
-according to the Lua operator <code>&lt;</code>. (integer/float)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.maxinteger"><code>math.maxinteger</code></a></h3>
-An integer with the maximum value for an integer.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.min"><code>math.min (x, &middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Returns the argument with the minimum value,
-according to the Lua operator <code>&lt;</code>. (integer/float)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.mininteger"><code>math.mininteger</code></a></h3>
-An integer with the minimum value for an integer.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.modf"><code>math.modf (x)</code></a></h3>
-
-
-<p>
-Returns the integral part of <code>x</code> and the fractional part of <code>x</code>.
-Its second result is always a float.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.pi"><code>math.pi</code></a></h3>
-
-
-<p>
-The value of <em>&pi;</em>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.rad"><code>math.rad (x)</code></a></h3>
-
-
-<p>
-Converts the angle <code>x</code> from degrees to radians.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.random"><code>math.random ([m [, n]])</code></a></h3>
-
-
-<p>
-When called without arguments,
-returns a pseudo-random float with uniform distribution
-in the range  <em>[0,1)</em>.  
-When called with two integers <code>m</code> and <code>n</code>,
-<code>math.random</code> returns a pseudo-random integer
-with uniform distribution in the range <em>[m, n]</em>.
-(The value <em>n-m</em> cannot be negative and must fit in a Lua integer.)
-The call <code>math.random(n)</code> is equivalent to <code>math.random(1,n)</code>.
-
-
-<p>
-This function is an interface to the underling
-pseudo-random generator function provided by C.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.randomseed"><code>math.randomseed (x)</code></a></h3>
-
-
-<p>
-Sets <code>x</code> as the "seed"
-for the pseudo-random generator:
-equal seeds produce equal sequences of numbers.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.sin"><code>math.sin (x)</code></a></h3>
-
-
-<p>
-Returns the sine of <code>x</code> (assumed to be in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.sqrt"><code>math.sqrt (x)</code></a></h3>
-
-
-<p>
-Returns the square root of <code>x</code>.
-(You can also use the expression <code>x^0.5</code> to compute this value.)
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.tan"><code>math.tan (x)</code></a></h3>
-
-
-<p>
-Returns the tangent of <code>x</code> (assumed to be in radians).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.tointeger"><code>math.tointeger (x)</code></a></h3>
-
-
-<p>
-If the value <code>x</code> is convertible to an integer,
-returns that integer.
-Otherwise, returns <b>nil</b>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.type"><code>math.type (x)</code></a></h3>
-
-
-<p>
-Returns "<code>integer</code>" if <code>x</code> is an integer,
-"<code>float</code>" if it is a float,
-or <b>nil</b> if <code>x</code> is not a number.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-math.ult"><code>math.ult (m, n)</code></a></h3>
-
-
-<p>
-Returns a boolean,
-true if and only if integer <code>m</code> is below integer <code>n</code> when
-they are compared as unsigned integers.
-
-
-
-
-
-
-
-<h2>6.8 &ndash; <a name="6.8">Input and Output Facilities</a></h2>
-
-<p>
-The I/O library provides two different styles for file manipulation.
-The first one uses implicit file handles;
-that is, there are operations to set a default input file and a
-default output file,
-and all input/output operations are over these default files.
-The second style uses explicit file handles.
-
-
-<p>
-When using implicit file handles,
-all operations are supplied by table <a name="pdf-io"><code>io</code></a>.
-When using explicit file handles,
-the operation <a href="#pdf-io.open"><code>io.open</code></a> returns a file handle
-and then all operations are supplied as methods of the file handle.
-
-
-<p>
-The table <code>io</code> also provides
-three predefined file handles with their usual meanings from C:
-<a name="pdf-io.stdin"><code>io.stdin</code></a>, <a name="pdf-io.stdout"><code>io.stdout</code></a>, and <a name="pdf-io.stderr"><code>io.stderr</code></a>.
-The I/O library never closes these files.
-
-
-<p>
-Unless otherwise stated,
-all I/O functions return <b>nil</b> on failure
-(plus an error message as a second result and
-a system-dependent error code as a third result)
-and some value different from <b>nil</b> on success.
-In non-POSIX systems,
-the computation of the error message and error code
-in case of errors
-may be not thread safe,
-because they rely on the global C variable <code>errno</code>.
-
-
-<p>
-<hr><h3><a name="pdf-io.close"><code>io.close ([file])</code></a></h3>
-
-
-<p>
-Equivalent to <code>file:close()</code>.
-Without a <code>file</code>, closes the default output file.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.flush"><code>io.flush ()</code></a></h3>
-
-
-<p>
-Equivalent to <code>io.output():flush()</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.input"><code>io.input ([file])</code></a></h3>
-
-
-<p>
-When called with a file name, it opens the named file (in text mode),
-and sets its handle as the default input file.
-When called with a file handle,
-it simply sets this file handle as the default input file.
-When called without arguments,
-it returns the current default input file.
-
-
-<p>
-In case of errors this function raises the error,
-instead of returning an error code.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.lines"><code>io.lines ([filename, &middot;&middot;&middot;])</code></a></h3>
-
-
-<p>
-Opens the given file name in read mode
-and returns an iterator function that
-works like <code>file:lines(&middot;&middot;&middot;)</code> over the opened file.
-When the iterator function detects the end of file,
-it returns no values (to finish the loop) and automatically closes the file.
-
-
-<p>
-The call <code>io.lines()</code> (with no file name) is equivalent
-to <code>io.input():lines("*l")</code>;
-that is, it iterates over the lines of the default input file.
-In this case, the iterator does not close the file when the loop ends.
-
-
-<p>
-In case of errors this function raises the error,
-instead of returning an error code.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.open"><code>io.open (filename [, mode])</code></a></h3>
-
-
-<p>
-This function opens a file,
-in the mode specified in the string <code>mode</code>.
-In case of success,
-it returns a new file handle.
-
-
-<p>
-The <code>mode</code> string can be any of the following:
-
-<ul>
-<li><b>"<code>r</code>": </b> read mode (the default);</li>
-<li><b>"<code>w</code>": </b> write mode;</li>
-<li><b>"<code>a</code>": </b> append mode;</li>
-<li><b>"<code>r+</code>": </b> update mode, all previous data is preserved;</li>
-<li><b>"<code>w+</code>": </b> update mode, all previous data is erased;</li>
-<li><b>"<code>a+</code>": </b> append update mode, previous data is preserved,
-  writing is only allowed at the end of file.</li>
-</ul><p>
-The <code>mode</code> string can also have a '<code>b</code>' at the end,
-which is needed in some systems to open the file in binary mode.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.output"><code>io.output ([file])</code></a></h3>
-
-
-<p>
-Similar to <a href="#pdf-io.input"><code>io.input</code></a>, but operates over the default output file.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.popen"><code>io.popen (prog [, mode])</code></a></h3>
-
-
-<p>
-This function is system dependent and is not available
-on all platforms.
-
-
-<p>
-Starts program <code>prog</code> in a separated process and returns
-a file handle that you can use to read data from this program
-(if <code>mode</code> is <code>"r"</code>, the default)
-or to write data to this program
-(if <code>mode</code> is <code>"w"</code>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.read"><code>io.read (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Equivalent to <code>io.input():read(&middot;&middot;&middot;)</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.tmpfile"><code>io.tmpfile ()</code></a></h3>
-
-
-<p>
-In case of success,
-returns a handle for a temporary file.
-This file is opened in update mode
-and it is automatically removed when the program ends.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.type"><code>io.type (obj)</code></a></h3>
-
-
-<p>
-Checks whether <code>obj</code> is a valid file handle.
-Returns the string <code>"file"</code> if <code>obj</code> is an open file handle,
-<code>"closed file"</code> if <code>obj</code> is a closed file handle,
-or <b>nil</b> if <code>obj</code> is not a file handle.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-io.write"><code>io.write (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Equivalent to <code>io.output():write(&middot;&middot;&middot;)</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:close"><code>file:close ()</code></a></h3>
-
-
-<p>
-Closes <code>file</code>.
-Note that files are automatically closed when
-their handles are garbage collected,
-but that takes an unpredictable amount of time to happen.
-
-
-<p>
-When closing a file handle created with <a href="#pdf-io.popen"><code>io.popen</code></a>,
-<a href="#pdf-file:close"><code>file:close</code></a> returns the same values
-returned by <a href="#pdf-os.execute"><code>os.execute</code></a>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:flush"><code>file:flush ()</code></a></h3>
-
-
-<p>
-Saves any written data to <code>file</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:lines"><code>file:lines (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Returns an iterator function that,
-each time it is called,
-reads the file according to the given formats.
-When no format is given,
-uses "<code>l</code>" as a default.
-As an example, the construction
-
-<pre>
-     for c in file:lines(1) do <em>body</em> end
-</pre><p>
-will iterate over all characters of the file,
-starting at the current position.
-Unlike <a href="#pdf-io.lines"><code>io.lines</code></a>, this function does not close the file
-when the loop ends.
-
-
-<p>
-In case of errors this function raises the error,
-instead of returning an error code.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:read"><code>file:read (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Reads the file <code>file</code>,
-according to the given formats, which specify what to read.
-For each format,
-the function returns a string or a number with the characters read,
-or <b>nil</b> if it cannot read data with the specified format.
-(In this latter case,
-the function does not read subsequent formats.)
-When called without formats,
-it uses a default format that reads the next line
-(see below).
-
-
-<p>
-The available formats are
-
-<ul>
-
-<li><b>"<code>n</code>": </b>
-reads a numeral and returns it as a float or an integer,
-following the lexical conventions of Lua.
-(The numeral may have leading spaces and a sign.)
-This format always reads the longest input sequence that
-is a valid prefix for a numeral;
-if that prefix does not form a valid numeral
-(e.g., an empty string, "<code>0x</code>", or "<code>3.4e-</code>"),
-it is discarded and the function returns <b>nil</b>.
-</li>
-
-<li><b>"<code>a</code>": </b>
-reads the whole file, starting at the current position.
-On end of file, it returns the empty string.
-</li>
-
-<li><b>"<code>l</code>": </b>
-reads the next line skipping the end of line,
-returning <b>nil</b> on end of file.
-This is the default format.
-</li>
-
-<li><b>"<code>L</code>": </b>
-reads the next line keeping the end-of-line character (if present),
-returning <b>nil</b> on end of file.
-</li>
-
-<li><b><em>number</em>: </b>
-reads a string with up to this number of bytes,
-returning <b>nil</b> on end of file.
-If <code>number</code> is zero,
-it reads nothing and returns an empty string,
-or <b>nil</b> on end of file.
-</li>
-
-</ul><p>
-The formats "<code>l</code>" and "<code>L</code>" should be used only for text files.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:seek"><code>file:seek ([whence [, offset]])</code></a></h3>
-
-
-<p>
-Sets and gets the file position,
-measured from the beginning of the file,
-to the position given by <code>offset</code> plus a base
-specified by the string <code>whence</code>, as follows:
-
-<ul>
-<li><b>"<code>set</code>": </b> base is position 0 (beginning of the file);</li>
-<li><b>"<code>cur</code>": </b> base is current position;</li>
-<li><b>"<code>end</code>": </b> base is end of file;</li>
-</ul><p>
-In case of success, <code>seek</code> returns the final file position,
-measured in bytes from the beginning of the file.
-If <code>seek</code> fails, it returns <b>nil</b>,
-plus a string describing the error.
-
-
-<p>
-The default value for <code>whence</code> is <code>"cur"</code>,
-and for <code>offset</code> is 0.
-Therefore, the call <code>file:seek()</code> returns the current
-file position, without changing it;
-the call <code>file:seek("set")</code> sets the position to the
-beginning of the file (and returns 0);
-and the call <code>file:seek("end")</code> sets the position to the
-end of the file, and returns its size.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:setvbuf"><code>file:setvbuf (mode [, size])</code></a></h3>
-
-
-<p>
-Sets the buffering mode for an output file.
-There are three available modes:
-
-<ul>
-
-<li><b>"<code>no</code>": </b>
-no buffering; the result of any output operation appears immediately.
-</li>
-
-<li><b>"<code>full</code>": </b>
-full buffering; output operation is performed only
-when the buffer is full or when
-you explicitly <code>flush</code> the file (see <a href="#pdf-io.flush"><code>io.flush</code></a>).
-</li>
-
-<li><b>"<code>line</code>": </b>
-line buffering; output is buffered until a newline is output
-or there is any input from some special files
-(such as a terminal device).
-</li>
-
-</ul><p>
-For the last two cases, <code>size</code>
-specifies the size of the buffer, in bytes.
-The default is an appropriate size.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-file:write"><code>file:write (&middot;&middot;&middot;)</code></a></h3>
-
-
-<p>
-Writes the value of each of its arguments to <code>file</code>.
-The arguments must be strings or numbers.
-
-
-<p>
-In case of success, this function returns <code>file</code>.
-Otherwise it returns <b>nil</b> plus a string describing the error.
-
-
-
-
-
-
-
-<h2>6.9 &ndash; <a name="6.9">Operating System Facilities</a></h2>
-
-<p>
-This library is implemented through table <a name="pdf-os"><code>os</code></a>.
-
-
-<p>
-<hr><h3><a name="pdf-os.clock"><code>os.clock ()</code></a></h3>
-
-
-<p>
-Returns an approximation of the amount in seconds of CPU time
-used by the program.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.date"><code>os.date ([format [, time]])</code></a></h3>
-
-
-<p>
-Returns a string or a table containing date and time,
-formatted according to the given string <code>format</code>.
-
-
-<p>
-If the <code>time</code> argument is present,
-this is the time to be formatted
-(see the <a href="#pdf-os.time"><code>os.time</code></a> function for a description of this value).
-Otherwise, <code>date</code> formats the current time.
-
-
-<p>
-If <code>format</code> starts with '<code>!</code>',
-then the date is formatted in Coordinated Universal Time.
-After this optional character,
-if <code>format</code> is the string "<code>*t</code>",
-then <code>date</code> returns a table with the following fields:
-<code>year</code>, <code>month</code> (1&ndash;12), <code>day</code> (1&ndash;31),
-<code>hour</code> (0&ndash;23), <code>min</code> (0&ndash;59), <code>sec</code> (0&ndash;61),
-<code>wday</code> (weekday, 1&ndash;7, Sunday is&nbsp;1),
-<code>yday</code> (day of the year, 1&ndash;366),
-and <code>isdst</code> (daylight saving flag, a boolean).
-This last field may be absent
-if the information is not available.
-
-
-<p>
-If <code>format</code> is not "<code>*t</code>",
-then <code>date</code> returns the date as a string,
-formatted according to the same rules as the ISO&nbsp;C function <code>strftime</code>.
-
-
-<p>
-When called without arguments,
-<code>date</code> returns a reasonable date and time representation that depends on
-the host system and on the current locale.
-(More specifically, <code>os.date()</code> is equivalent to <code>os.date("%c")</code>.)
-
-
-<p>
-In non-POSIX systems,
-this function may be not thread safe
-because of its reliance on C&nbsp;function <code>gmtime</code> and C&nbsp;function <code>localtime</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.difftime"><code>os.difftime (t2, t1)</code></a></h3>
-
-
-<p>
-Returns the difference, in seconds,
-from time <code>t1</code> to time <code>t2</code>
-(where the times are values returned by <a href="#pdf-os.time"><code>os.time</code></a>).
-In POSIX, Windows, and some other systems,
-this value is exactly <code>t2</code><em>-</em><code>t1</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.execute"><code>os.execute ([command])</code></a></h3>
-
-
-<p>
-This function is equivalent to the ISO&nbsp;C function <code>system</code>.
-It passes <code>command</code> to be executed by an operating system shell.
-Its first result is <b>true</b>
-if the command terminated successfully,
-or <b>nil</b> otherwise.
-After this first result
-the function returns a string plus a number,
-as follows:
-
-<ul>
-
-<li><b>"<code>exit</code>": </b>
-the command terminated normally;
-the following number is the exit status of the command.
-</li>
-
-<li><b>"<code>signal</code>": </b>
-the command was terminated by a signal;
-the following number is the signal that terminated the command.
-</li>
-
-</ul>
-
-<p>
-When called without a <code>command</code>,
-<code>os.execute</code> returns a boolean that is true if a shell is available.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.exit"><code>os.exit ([code [, close]])</code></a></h3>
-
-
-<p>
-Calls the ISO&nbsp;C function <code>exit</code> to terminate the host program.
-If <code>code</code> is <b>true</b>,
-the returned status is <code>EXIT_SUCCESS</code>;
-if <code>code</code> is <b>false</b>,
-the returned status is <code>EXIT_FAILURE</code>;
-if <code>code</code> is a number,
-the returned status is this number.
-The default value for <code>code</code> is <b>true</b>.
-
-
-<p>
-If the optional second argument <code>close</code> is true,
-closes the Lua state before exiting.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.getenv"><code>os.getenv (varname)</code></a></h3>
-
-
-<p>
-Returns the value of the process environment variable <code>varname</code>,
-or <b>nil</b> if the variable is not defined.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.remove"><code>os.remove (filename)</code></a></h3>
-
-
-<p>
-Deletes the file (or empty directory, on POSIX systems)
-with the given name.
-If this function fails, it returns <b>nil</b>,
-plus a string describing the error and the error code.
-Otherwise, it returns true.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.rename"><code>os.rename (oldname, newname)</code></a></h3>
-
-
-<p>
-Renames the file or directory named <code>oldname</code> to <code>newname</code>.
-If this function fails, it returns <b>nil</b>,
-plus a string describing the error and the error code.
-Otherwise, it returns true.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.setlocale"><code>os.setlocale (locale [, category])</code></a></h3>
-
-
-<p>
-Sets the current locale of the program.
-<code>locale</code> is a system-dependent string specifying a locale;
-<code>category</code> is an optional string describing which category to change:
-<code>"all"</code>, <code>"collate"</code>, <code>"ctype"</code>,
-<code>"monetary"</code>, <code>"numeric"</code>, or <code>"time"</code>;
-the default category is <code>"all"</code>.
-The function returns the name of the new locale,
-or <b>nil</b> if the request cannot be honored.
-
-
-<p>
-If <code>locale</code> is the empty string,
-the current locale is set to an implementation-defined native locale.
-If <code>locale</code> is the string "<code>C</code>",
-the current locale is set to the standard C locale.
-
-
-<p>
-When called with <b>nil</b> as the first argument,
-this function only returns the name of the current locale
-for the given category.
-
-
-<p>
-This function may be not thread safe
-because of its reliance on C&nbsp;function <code>setlocale</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.time"><code>os.time ([table])</code></a></h3>
-
-
-<p>
-Returns the current time when called without arguments,
-or a time representing the local date and time specified by the given table.
-This table must have fields <code>year</code>, <code>month</code>, and <code>day</code>,
-and may have fields
-<code>hour</code> (default is 12),
-<code>min</code> (default is 0),
-<code>sec</code> (default is 0),
-and <code>isdst</code> (default is <b>nil</b>).
-Other fields are ignored.
-For a description of these fields, see the <a href="#pdf-os.date"><code>os.date</code></a> function.
-
-
-<p>
-The values in these fields do not need to be inside their valid ranges.
-For instance, if <code>sec</code> is -10,
-it means -10 seconds from the time specified by the other fields;
-if <code>hour</code> is 1000,
-it means +1000 hours from the time specified by the other fields.
-
-
-<p>
-The returned value is a number, whose meaning depends on your system.
-In POSIX, Windows, and some other systems,
-this number counts the number
-of seconds since some given start time (the "epoch").
-In other systems, the meaning is not specified,
-and the number returned by <code>time</code> can be used only as an argument to
-<a href="#pdf-os.date"><code>os.date</code></a> and <a href="#pdf-os.difftime"><code>os.difftime</code></a>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-os.tmpname"><code>os.tmpname ()</code></a></h3>
-
-
-<p>
-Returns a string with a file name that can
-be used for a temporary file.
-The file must be explicitly opened before its use
-and explicitly removed when no longer needed.
-
-
-<p>
-In POSIX systems,
-this function also creates a file with that name,
-to avoid security risks.
-(Someone else might create the file with wrong permissions
-in the time between getting the name and creating the file.)
-You still have to open the file to use it
-and to remove it (even if you do not use it).
-
-
-<p>
-When possible,
-you may prefer to use <a href="#pdf-io.tmpfile"><code>io.tmpfile</code></a>,
-which automatically removes the file when the program ends.
-
-
-
-
-
-
-
-<h2>6.10 &ndash; <a name="6.10">The Debug Library</a></h2>
-
-<p>
-This library provides
-the functionality of the debug interface (<a href="#4.9">&sect;4.9</a>) to Lua programs.
-You should exert care when using this library.
-Several of its functions
-violate basic assumptions about Lua code
-(e.g., that variables local to a function
-cannot be accessed from outside;
-that userdata metatables cannot be changed by Lua code;
-that Lua programs do not crash)
-and therefore can compromise otherwise secure code.
-Moreover, some functions in this library may be slow.
-
-
-<p>
-All functions in this library are provided
-inside the <a name="pdf-debug"><code>debug</code></a> table.
-All functions that operate over a thread
-have an optional first argument which is the
-thread to operate over.
-The default is always the current thread.
-
-
-<p>
-<hr><h3><a name="pdf-debug.debug"><code>debug.debug ()</code></a></h3>
-
-
-<p>
-Enters an interactive mode with the user,
-running each string that the user enters.
-Using simple commands and other debug facilities,
-the user can inspect global and local variables,
-change their values, evaluate expressions, and so on.
-A line containing only the word <code>cont</code> finishes this function,
-so that the caller continues its execution.
-
-
-<p>
-Note that commands for <code>debug.debug</code> are not lexically nested
-within any function and so have no direct access to local variables.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.gethook"><code>debug.gethook ([thread])</code></a></h3>
-
-
-<p>
-Returns the current hook settings of the thread, as three values:
-the current hook function, the current hook mask,
-and the current hook count
-(as set by the <a href="#pdf-debug.sethook"><code>debug.sethook</code></a> function).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getinfo"><code>debug.getinfo ([thread,] f [, what])</code></a></h3>
-
-
-<p>
-Returns a table with information about a function.
-You can give the function directly
-or you can give a number as the value of <code>f</code>,
-which means the function running at level <code>f</code> of the call stack
-of the given thread:
-level&nbsp;0 is the current function (<code>getinfo</code> itself);
-level&nbsp;1 is the function that called <code>getinfo</code>
-(except for tail calls, which do not count on the stack);
-and so on.
-If <code>f</code> is a number larger than the number of active functions,
-then <code>getinfo</code> returns <b>nil</b>.
-
-
-<p>
-The returned table can contain all the fields returned by <a href="#lua_getinfo"><code>lua_getinfo</code></a>,
-with the string <code>what</code> describing which fields to fill in.
-The default for <code>what</code> is to get all information available,
-except the table of valid lines.
-If present,
-the option '<code>f</code>'
-adds a field named <code>func</code> with the function itself.
-If present,
-the option '<code>L</code>'
-adds a field named <code>activelines</code> with the table of
-valid lines.
-
-
-<p>
-For instance, the expression <code>debug.getinfo(1,"n").name</code> returns
-a name for the current function,
-if a reasonable name can be found,
-and the expression <code>debug.getinfo(print)</code>
-returns a table with all available information
-about the <a href="#pdf-print"><code>print</code></a> function.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getlocal"><code>debug.getlocal ([thread,] f, local)</code></a></h3>
-
-
-<p>
-This function returns the name and the value of the local variable
-with index <code>local</code> of the function at level <code>f</code> of the stack.
-This function accesses not only explicit local variables,
-but also parameters, temporaries, etc.
-
-
-<p>
-The first parameter or local variable has index&nbsp;1, and so on,
-following the order that they are declared in the code,
-counting only the variables that are active
-in the current scope of the function.
-Negative indices refer to vararg arguments;
--1 is the first vararg argument.
-The function returns <b>nil</b> if there is no variable with the given index,
-and raises an error when called with a level out of range.
-(You can call <a href="#pdf-debug.getinfo"><code>debug.getinfo</code></a> to check whether the level is valid.)
-
-
-<p>
-Variable names starting with '<code>(</code>' (open parenthesis) 
-represent variables with no known names
-(internal variables such as loop control variables,
-and variables from chunks saved without debug information).
-
-
-<p>
-The parameter <code>f</code> may also be a function.
-In that case, <code>getlocal</code> returns only the name of function parameters.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getmetatable"><code>debug.getmetatable (value)</code></a></h3>
-
-
-<p>
-Returns the metatable of the given <code>value</code>
-or <b>nil</b> if it does not have a metatable.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getregistry"><code>debug.getregistry ()</code></a></h3>
-
-
-<p>
-Returns the registry table (see <a href="#4.5">&sect;4.5</a>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getupvalue"><code>debug.getupvalue (f, up)</code></a></h3>
-
-
-<p>
-This function returns the name and the value of the upvalue
-with index <code>up</code> of the function <code>f</code>.
-The function returns <b>nil</b> if there is no upvalue with the given index.
-
-
-<p>
-Variable names starting with '<code>(</code>' (open parenthesis) 
-represent variables with no known names
-(variables from chunks saved without debug information).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.getuservalue"><code>debug.getuservalue (u)</code></a></h3>
-
-
-<p>
-Returns the Lua value associated to <code>u</code>.
-If <code>u</code> is not a full userdata,
-returns <b>nil</b>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.sethook"><code>debug.sethook ([thread,] hook, mask [, count])</code></a></h3>
-
-
-<p>
-Sets the given function as a hook.
-The string <code>mask</code> and the number <code>count</code> describe
-when the hook will be called.
-The string mask may have any combination of the following characters,
-with the given meaning:
-
-<ul>
-<li><b>'<code>c</code>': </b> the hook is called every time Lua calls a function;</li>
-<li><b>'<code>r</code>': </b> the hook is called every time Lua returns from a function;</li>
-<li><b>'<code>l</code>': </b> the hook is called every time Lua enters a new line of code.</li>
-</ul><p>
-Moreover,
-with a <code>count</code> different from zero,
-the hook is called also after every <code>count</code> instructions.
-
-
-<p>
-When called without arguments,
-<a href="#pdf-debug.sethook"><code>debug.sethook</code></a> turns off the hook.
-
-
-<p>
-When the hook is called, its first argument is a string
-describing the event that has triggered its call:
-<code>"call"</code> (or <code>"tail call"</code>),
-<code>"return"</code>,
-<code>"line"</code>, and <code>"count"</code>.
-For line events,
-the hook also gets the new line number as its second parameter.
-Inside a hook,
-you can call <code>getinfo</code> with level&nbsp;2 to get more information about
-the running function
-(level&nbsp;0 is the <code>getinfo</code> function,
-and level&nbsp;1 is the hook function).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.setlocal"><code>debug.setlocal ([thread,] level, local, value)</code></a></h3>
-
-
-<p>
-This function assigns the value <code>value</code> to the local variable
-with index <code>local</code> of the function at level <code>level</code> of the stack.
-The function returns <b>nil</b> if there is no local
-variable with the given index,
-and raises an error when called with a <code>level</code> out of range.
-(You can call <code>getinfo</code> to check whether the level is valid.)
-Otherwise, it returns the name of the local variable.
-
-
-<p>
-See <a href="#pdf-debug.getlocal"><code>debug.getlocal</code></a> for more information about
-variable indices and names.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.setmetatable"><code>debug.setmetatable (value, table)</code></a></h3>
-
-
-<p>
-Sets the metatable for the given <code>value</code> to the given <code>table</code>
-(which can be <b>nil</b>).
-Returns <code>value</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.setupvalue"><code>debug.setupvalue (f, up, value)</code></a></h3>
-
-
-<p>
-This function assigns the value <code>value</code> to the upvalue
-with index <code>up</code> of the function <code>f</code>.
-The function returns <b>nil</b> if there is no upvalue
-with the given index.
-Otherwise, it returns the name of the upvalue.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.setuservalue"><code>debug.setuservalue (udata, value)</code></a></h3>
-
-
-<p>
-Sets the given <code>value</code> as
-the Lua value associated to the given <code>udata</code>.
-<code>udata</code> must be a full userdata.
-
-
-<p>
-Returns <code>udata</code>.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.traceback"><code>debug.traceback ([thread,] [message [, level]])</code></a></h3>
-
-
-<p>
-If <code>message</code> is present but is neither a string nor <b>nil</b>,
-this function returns <code>message</code> without further processing.
-Otherwise,
-it returns a string with a traceback of the call stack.
-The optional <code>message</code> string is appended
-at the beginning of the traceback.
-An optional <code>level</code> number tells at which level
-to start the traceback
-(default is 1, the function calling <code>traceback</code>).
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.upvalueid"><code>debug.upvalueid (f, n)</code></a></h3>
-
-
-<p>
-Returns a unique identifier (as a light userdata)
-for the upvalue numbered <code>n</code>
-from the given function.
-
-
-<p>
-These unique identifiers allow a program to check whether different
-closures share upvalues.
-Lua closures that share an upvalue
-(that is, that access a same external local variable)
-will return identical ids for those upvalue indices.
-
-
-
-
-<p>
-<hr><h3><a name="pdf-debug.upvaluejoin"><code>debug.upvaluejoin (f1, n1, f2, n2)</code></a></h3>
-
-
-<p>
-Make the <code>n1</code>-th upvalue of the Lua closure <code>f1</code>
-refer to the <code>n2</code>-th upvalue of the Lua closure <code>f2</code>.
-
-
-
-
-
-
-
-<h1>7 &ndash; <a name="7">Lua Standalone</a></h1>
-
-<p>
-Although Lua has been designed as an extension language,
-to be embedded in a host C&nbsp;program,
-it is also frequently used as a standalone language.
-An interpreter for Lua as a standalone language,
-called simply <code>lua</code>,
-is provided with the standard distribution.
-The standalone interpreter includes
-all standard libraries, including the debug library.
-Its usage is:
-
-<pre>
-     lua [options] [script [args]]
-</pre><p>
-The options are:
-
-<ul>
-<li><b><code>-e <em>stat</em></code>: </b> executes string <em>stat</em>;</li>
-<li><b><code>-l <em>mod</em></code>: </b> "requires" <em>mod</em> and assigns the
-  result to global @<em>mod</em>;</li>
-<li><b><code>-i</code>: </b> enters interactive mode after running <em>script</em>;</li>
-<li><b><code>-v</code>: </b> prints version information;</li>
-<li><b><code>-E</code>: </b> ignores environment variables;</li>
-<li><b><code>--</code>: </b> stops handling options;</li>
-<li><b><code>-</code>: </b> executes <code>stdin</code> as a file and stops handling options.</li>
-</ul><p>
-After handling its options, <code>lua</code> runs the given <em>script</em>.
-When called without arguments,
-<code>lua</code> behaves as <code>lua -v -i</code>
-when the standard input (<code>stdin</code>) is a terminal,
-and as <code>lua -</code> otherwise.
-
-
-<p>
-When called without option <code>-E</code>,
-the interpreter checks for an environment variable <a name="pdf-LUA_INIT_5_3"><code>LUA_INIT_5_3</code></a>
-(or <a name="pdf-LUA_INIT"><code>LUA_INIT</code></a> if the versioned name is not defined)
-before running any argument.
-If the variable content has the format <code>@<em>filename</em></code>,
-then <code>lua</code> executes the file.
-Otherwise, <code>lua</code> executes the string itself.
-
-
-<p>
-When called with option <code>-E</code>,
-besides ignoring <code>LUA_INIT</code>,
-Lua also ignores
-the values of <code>LUA_PATH</code> and <code>LUA_CPATH</code>,
-setting the values of
-<a href="#pdf-package.path"><code>package.path</code></a> and <a href="#pdf-package.cpath"><code>package.cpath</code></a>
-with the default paths defined in <code>luaconf.h</code>.
-
-
-<p>
-All options are handled in order, except <code>-i</code> and <code>-E</code>.
-For instance, an invocation like
-
-<pre>
-     $ lua -e'a=1' -e 'print(a)' script.lua
-</pre><p>
-will first set <code>a</code> to 1, then print the value of <code>a</code>,
-and finally run the file <code>script.lua</code> with no arguments.
-(Here <code>$</code> is the shell prompt. Your prompt may be different.)
-
-
-<p>
-Before running any code,
-<code>lua</code> collects all command-line arguments
-in a global table called <code>arg</code>.
-The script name goes to index 0,
-the first argument after the script name goes to index 1,
-and so on.
-Any arguments before the script name
-(that is, the interpreter name plus its options)
-go to negative indices.
-For instance, in the call
-
-<pre>
-     $ lua -la b.lua t1 t2
-</pre><p>
-the table is like this:
-
-<pre>
-     arg = { [-2] = "lua", [-1] = "-la",
-             [0] = "b.lua",
-             [1] = "t1", [2] = "t2" }
-</pre><p>
-If there is no script in the call,
-the interpreter name goes to index 0,
-followed by the other arguments.
-For instance, the call
-
-<pre>
-     $ lua -e "print(arg[1])"
-</pre><p>
-will print "<code>-e</code>".
-If there is a script,
-the script is called with arguments
-<code>arg[1]</code>, &middot;&middot;&middot;, <code>arg[#arg]</code>.
-(Like all chunks in Lua,
-the script is compiled as a vararg function.)
-
-
-<p>
-In interactive mode,
-Lua repeatedly prompts and waits for a line.
-After reading a line,
-Lua first try to interpret the line as an expression.
-If it succeeds, it prints its value.
-Otherwise, it interprets the line as a statement.
-If you write an incomplete statement,
-the interpreter waits for its completion
-by issuing a different prompt.
-
-
-<p>
-If the global variable <a name="pdf-_PROMPT"><code>_PROMPT</code></a> contains a string,
-then its value is used as the prompt.
-Similarly, if the global variable <a name="pdf-_PROMPT2"><code>_PROMPT2</code></a> contains a string,
-its value is used as the secondary prompt
-(issued during incomplete statements).
-
-
-<p>
-In case of unprotected errors in the script,
-the interpreter reports the error to the standard error stream.
-If the error object is not a string but
-has a metamethod <code>__tostring</code>,
-the interpreter calls this metamethod to produce the final message.
-Otherwise, the interpreter converts the error object to a string
-and adds a stack traceback to it.
-
-
-<p>
-When finishing normally,
-the interpreter closes its main Lua state
-(see <a href="#lua_close"><code>lua_close</code></a>).
-The script can avoid this step by
-calling <a href="#pdf-os.exit"><code>os.exit</code></a> to terminate.
-
-
-<p>
-To allow the use of Lua as a
-script interpreter in Unix systems,
-the standalone interpreter skips
-the first line of a chunk if it starts with <code>#</code>.
-Therefore, Lua scripts can be made into executable programs
-by using <code>chmod +x</code> and the&nbsp;<code>#!</code> form,
-as in
-
-<pre>
-     #!/usr/local/bin/lua
-</pre><p>
-(Of course,
-the location of the Lua interpreter may be different in your machine.
-If <code>lua</code> is in your <code>PATH</code>,
-then
-
-<pre>
-     #!/usr/bin/env lua
-</pre><p>
-is a more portable solution.)
-
-
-
-<h1>8 &ndash; <a name="8">Incompatibilities with the Previous Version</a></h1>
-
-<p>
-Here we list the incompatibilities that you may find when moving a program
-from Lua&nbsp;5.2 to Lua&nbsp;5.3.
-You can avoid some incompatibilities by compiling Lua with
-appropriate options (see file <code>luaconf.h</code>).
-However,
-all these compatibility options will be removed in the future.
-
-
-<p>
-Lua versions can always change the C API in ways that
-do not imply source-code changes in a program,
-such as the numeric values for constants
-or the implementation of functions as macros.
-Therefore,
-you should not assume that binaries are compatible between
-different Lua versions.
-Always recompile clients of the Lua API when
-using a new version.
-
-
-<p>
-Similarly, Lua versions can always change the internal representation
-of precompiled chunks;
-precompiled chunks are not compatible between different Lua versions.
-
-
-<p>
-The standard paths in the official distribution may
-change between versions.
-
-
-
-<h2>8.1 &ndash; <a name="8.1">Changes in the Language</a></h2>
-<ul>
-
-<li>
-The main difference between Lua&nbsp;5.2 and Lua&nbsp;5.3 is the
-introduction of an integer subtype for numbers.
-Although this change should not affect "normal" computations,
-some computations
-(mainly those that involve some kind of overflow)
-can give different results.
-
-
-<p>
-You can fix these differences by forcing a number to be a float
-(in Lua&nbsp;5.2 all numbers were float),
-in particular writing constants with an ending <code>.0</code>
-or using <code>x = x + 0.0</code> to convert a variable.
-(This recommendation is only for a quick fix
-for an occasional incompatibility;
-it is not a general guideline for good programming.
-For good programming,
-use floats where you need floats
-and integers where you need integers.)
-</li>
-
-<li>
-The conversion of a float to a string now adds a <code>.0</code> suffix
-to the result if it looks like an integer.
-(For instance, the float 2.0 will be printed as <code>2.0</code>,
-not as <code>2</code>.)
-You should always use an explicit format
-when you need a specific format for numbers.
-
-
-<p>
-(Formally this is not an incompatibility,
-because Lua does not specify how numbers are formatted as strings,
-but some programs assumed a specific format.)
-</li>
-
-<li>
-The generational mode for the garbage collector was removed.
-(It was an experimental feature in Lua&nbsp;5.2.)
-</li>
-
-</ul>
-
-
-
-
-<h2>8.2 &ndash; <a name="8.2">Changes in the Libraries</a></h2>
-<ul>
-
-<li>
-The <code>bit32</code> library has been deprecated.
-It is easy to require a compatible external library or,
-better yet, to replace its functions with appropriate bitwise operations.
-(Keep in mind that <code>bit32</code> operates on 32-bit integers,
-while the bitwise operators in Lua&nbsp;5.3 operate on Lua integers,
-which by default have 64&nbsp;bits.)
-</li>
-
-<li>
-The Table library now respects metamethods
-for setting and getting elements.
-</li>
-
-<li>
-The <a href="#pdf-ipairs"><code>ipairs</code></a> iterator now respects metamethods and
-its <code>__ipairs</code> metamethod has been deprecated.
-</li>
-
-<li>
-Option names in <a href="#pdf-io.read"><code>io.read</code></a> do not have a starting '<code>*</code>' anymore.
-For compatibility, Lua will continue to accept (and ignore) this character.
-</li>
-
-<li>
-The following functions were deprecated in the mathematical library:
-<code>atan2</code>, <code>cosh</code>, <code>sinh</code>, <code>tanh</code>, <code>pow</code>,
-<code>frexp</code>, and <code>ldexp</code>.
-You can replace <code>math.pow(x,y)</code> with <code>x^y</code>;
-you can replace <code>math.atan2</code> with <code>math.atan</code>,
-which now accepts one or two arguments;
-you can replace <code>math.ldexp(x,exp)</code> with <code>x * 2.0^exp</code>.
-For the other operations,
-you can either use an external library or
-implement them in Lua.
-</li>
-
-<li>
-The searcher for C loaders used by <a href="#pdf-require"><code>require</code></a>
-changed the way it handles versioned names.
-Now, the version should come after the module name
-(as is usual in most other tools).
-For compatibility, that searcher still tries the old format
-if it cannot find an open function according to the new style.
-(Lua&nbsp;5.2 already worked that way,
-but it did not document the change.)
-</li>
-
-<li>
-The call <code>collectgarbage("count")</code> now returns only one result.
-(You can compute that second result from the fractional part
-of the first result.)
-</li>
-
-</ul>
-
-
-
-
-<h2>8.3 &ndash; <a name="8.3">Changes in the API</a></h2>
-
-
-<ul>
-
-<li>
-Continuation functions now receive as arguments what they needed
-to get through <code>lua_getctx</code>,
-so <code>lua_getctx</code> has been removed.
-Adapt your code accordingly.
-</li>
-
-<li>
-Function <a href="#lua_dump"><code>lua_dump</code></a> has an extra parameter, <code>strip</code>.
-Use 0 as the value of this parameter to get the old behavior.
-</li>
-
-<li>
-Functions to inject/project unsigned integers
-(<code>lua_pushunsigned</code>, <code>lua_tounsigned</code>, <code>lua_tounsignedx</code>,
-<code>luaL_checkunsigned</code>, <code>luaL_optunsigned</code>)
-were deprecated.
-Use their signed equivalents with a type cast.
-</li>
-
-<li>
-Macros to project non-default integer types
-(<code>luaL_checkint</code>, <code>luaL_optint</code>, <code>luaL_checklong</code>, <code>luaL_optlong</code>)
-were deprecated.
-Use their equivalent over <a href="#lua_Integer"><code>lua_Integer</code></a> with a type cast
-(or, when possible, use <a href="#lua_Integer"><code>lua_Integer</code></a> in your code).
-</li>
-
-</ul>
-
-
-
-
-<h1>9 &ndash; <a name="9">The Complete Syntax of Lua</a></h1>
-
-<p>
-Here is the complete syntax of Lua in extended BNF.
-As usual in extended BNF,
-{A} means 0 or more As,
-and [A] means an optional A.
-(For operator precedences, see <a href="#3.4.8">&sect;3.4.8</a>;
-for a description of the terminals
-Name, Numeral,
-and LiteralString, see <a href="#3.1">&sect;3.1</a>.)
-
-
-
-
-<pre>
-
-	chunk ::= block
-
-	block ::= {stat} [retstat]
-
-	stat ::=  &lsquo;<b>;</b>&rsquo; | 
-		 varlist &lsquo;<b>=</b>&rsquo; explist | 
-		 functioncall | 
-		 label | 
-		 <b>break</b> | 
-		 <b>goto</b> Name | 
-		 <b>do</b> block <b>end</b> | 
-		 <b>while</b> exp <b>do</b> block <b>end</b> | 
-		 <b>repeat</b> block <b>until</b> exp | 
-		 <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b> | 
-		 <b>for</b> Name &lsquo;<b>=</b>&rsquo; exp &lsquo;<b>,</b>&rsquo; exp [&lsquo;<b>,</b>&rsquo; exp] <b>do</b> block <b>end</b> | 
-		 <b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b> | 
-		 <b>function</b> funcname funcbody | 
-		 <b>local</b> <b>function</b> Name funcbody | 
-		 <b>local</b> namelist [&lsquo;<b>=</b>&rsquo; explist] 
-
-	retstat ::= <b>return</b> [explist] [&lsquo;<b>;</b>&rsquo;]
-
-	label ::= &lsquo;<b>::</b>&rsquo; Name &lsquo;<b>::</b>&rsquo;
-
-	funcname ::= Name {&lsquo;<b>.</b>&rsquo; Name} [&lsquo;<b>:</b>&rsquo; Name]
-
-	varlist ::= var {&lsquo;<b>,</b>&rsquo; var}
-
-	var ::=  Name | prefixexp &lsquo;<b>[</b>&rsquo; exp &lsquo;<b>]</b>&rsquo; | prefixexp &lsquo;<b>.</b>&rsquo; Name 
-
-	namelist ::= Name {&lsquo;<b>,</b>&rsquo; Name}
-
-	explist ::= exp {&lsquo;<b>,</b>&rsquo; exp}
-
-	exp ::=  <b>nil</b> | <b>false</b> | <b>true</b> | Numeral | LiteralString | &lsquo;<b>...</b>&rsquo; | functiondef | 
-		 prefixexp | tableconstructor | exp binop exp | unop exp 
-
-	prefixexp ::= var | functioncall | &lsquo;<b>(</b>&rsquo; exp &lsquo;<b>)</b>&rsquo;
-
-	functioncall ::=  prefixexp args | prefixexp &lsquo;<b>:</b>&rsquo; Name args 
-
-	args ::=  &lsquo;<b>(</b>&rsquo; [explist] &lsquo;<b>)</b>&rsquo; | tableconstructor | LiteralString 
-
-	functiondef ::= <b>function</b> funcbody
-
-	funcbody ::= &lsquo;<b>(</b>&rsquo; [parlist] &lsquo;<b>)</b>&rsquo; block <b>end</b>
-
-	parlist ::= namelist [&lsquo;<b>,</b>&rsquo; &lsquo;<b>...</b>&rsquo;] | &lsquo;<b>...</b>&rsquo;
-
-	tableconstructor ::= &lsquo;<b>{</b>&rsquo; [fieldlist] &lsquo;<b>}</b>&rsquo;
-
-	fieldlist ::= field {fieldsep field} [fieldsep]
-
-	field ::= &lsquo;<b>[</b>&rsquo; exp &lsquo;<b>]</b>&rsquo; &lsquo;<b>=</b>&rsquo; exp | Name &lsquo;<b>=</b>&rsquo; exp | exp
-
-	fieldsep ::= &lsquo;<b>,</b>&rsquo; | &lsquo;<b>;</b>&rsquo;
-
-	binop ::=  &lsquo;<b>+</b>&rsquo; | &lsquo;<b>-</b>&rsquo; | &lsquo;<b>*</b>&rsquo; | &lsquo;<b>/</b>&rsquo; | &lsquo;<b>//</b>&rsquo; | &lsquo;<b>^</b>&rsquo; | &lsquo;<b>%</b>&rsquo; | 
-		 &lsquo;<b>&amp;</b>&rsquo; | &lsquo;<b>~</b>&rsquo; | &lsquo;<b>|</b>&rsquo; | &lsquo;<b>&gt;&gt;</b>&rsquo; | &lsquo;<b>&lt;&lt;</b>&rsquo; | &lsquo;<b>..</b>&rsquo; | 
-		 &lsquo;<b>&lt;</b>&rsquo; | &lsquo;<b>&lt;=</b>&rsquo; | &lsquo;<b>&gt;</b>&rsquo; | &lsquo;<b>&gt;=</b>&rsquo; | &lsquo;<b>==</b>&rsquo; | &lsquo;<b>~=</b>&rsquo; | 
-		 <b>and</b> | <b>or</b>
-
-	unop ::= &lsquo;<b>-</b>&rsquo; | <b>not</b> | &lsquo;<b>#</b>&rsquo; | &lsquo;<b>~</b>&rsquo;
-
-</pre>
-
-<p>
-
-
-
-
-
-
-
-
-<P CLASS="footer">
-Last update:
-Tue Jun 26 13:16:37 -03 2018
-</P>
-<!--
-Last change: revised for Lua 5.3.5
--->
-
-</body></html>
-
diff --git a/lua/lua-5.3.5/doc/osi-certified-72x60.png b/lua/lua-5.3.5/doc/osi-certified-72x60.png
deleted file mode 100644
index 07df5f6ee7a7a8b2108025dcd815f73f145a83af..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

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

diff --git a/lua/lua-5.3.5/doc/readme.html b/lua/lua-5.3.5/doc/readme.html
deleted file mode 100644
index b118f7b..0000000
--- a/lua/lua-5.3.5/doc/readme.html
+++ /dev/null
@@ -1,365 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<HTML>
-<HEAD>
-<TITLE>Lua 5.3 readme</TITLE>
-<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
-<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
-<STYLE TYPE="text/css">
-blockquote, .display {
-	border: solid #a0a0a0 2px ;
-	border-radius: 8px ;
-	padding: 1em ;
-	margin: 0px ;
-}
-
-.display {
-	word-spacing: 0.25em ;
-}
-
-dl.display dd {
-	padding-bottom: 0.2em ;
-}
-
-tt, kbd, code {
-	font-size: 12pt ;
-}
-</STYLE>
-</HEAD>
-
-<BODY>
-
-<H1>
-<A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua"></A>
-Welcome to Lua 5.3
-</H1>
-
-<DIV CLASS="menubar">
-<A HREF="#about">about</A>
-&middot;
-<A HREF="#install">installation</A>
-&middot;
-<A HREF="#changes">changes</A>
-&middot;
-<A HREF="#license">license</A>
-&middot;
-<A HREF="contents.html">reference manual</A>
-</DIV>
-
-<H2><A NAME="about">About Lua</A></H2>
-<P>
-Lua is a powerful, fast, lightweight, embeddable scripting language
-developed by a
-<A HREF="http://www.lua.org/authors.html">team</A>
-at
-<A HREF="http://www.puc-rio.br/">PUC-Rio</A>,
-the Pontifical Catholic University of Rio de Janeiro in Brazil.
-Lua is
-<A HREF="#license">free software</A>
-used in many products and projects around the world.
-
-<P>
-Lua's
-<A HREF="http://www.lua.org/">official web site</A>
-provides complete information
-about Lua,
-including
-an
-<A HREF="http://www.lua.org/about.html">executive summary</A>
-and
-updated
-<A HREF="http://www.lua.org/docs.html">documentation</A>,
-especially the
-<A HREF="http://www.lua.org/manual/5.3/">reference manual</A>,
-which may differ slightly from the
-<A HREF="contents.html">local copy</A>
-distributed in this package.
-
-<H2><A NAME="install">Installing Lua</A></H2>
-<P>
-Lua is distributed in
-<A HREF="http://www.lua.org/ftp/">source</A>
-form.
-You need to build it before using it.
-Building Lua should be straightforward
-because
-Lua is implemented in pure ANSI C and compiles unmodified in all known
-platforms that have an ANSI C compiler.
-Lua also compiles unmodified as C++.
-The instructions given below for building Lua are for Unix-like platforms.
-See also
-<A HREF="#other">instructions for other systems</A>
-and
-<A HREF="#customization">customization options</A>.
-
-<P>
-If you don't have the time or the inclination to compile Lua yourself,
-get a binary from
-<A HREF="http://lua-users.org/wiki/LuaBinaries">LuaBinaries</A>.
-Try also
-<A HREF="http://luadist.org/">LuaDist</A>,
-a multi-platform distribution of Lua that includes batteries.
-
-<H3>Building Lua</H3>
-<P>
-In most Unix-like platforms, simply do "<KBD>make</KBD>" with a suitable target.
-Here are the details.
-
-<OL>
-<LI>
-Open a terminal window and move to
-the top-level directory, which is named <TT>lua-5.3.5</TT>.
-The <TT>Makefile</TT> there controls both the build process and the installation process.
-<P>
-<LI>
-  Do "<KBD>make</KBD>" and see if your platform is listed.
-  The platforms currently supported are:
-<P>
-<P CLASS="display">
-   aix bsd c89 freebsd generic linux macosx mingw posix solaris
-</P>
-<P>
-  If your platform is listed, just do "<KBD>make xxx</KBD>", where xxx
-  is your platform name.
-<P>
-  If your platform is not listed, try the closest one or posix, generic,
-  c89, in this order.
-<P>
-<LI>
-The compilation takes only a few moments
-and produces three files in the <TT>src</TT> directory:
-lua (the interpreter),
-luac (the compiler),
-and liblua.a (the library).
-<P>
-<LI>
-  To check that Lua has been built correctly, do "<KBD>make test</KBD>"
-  after building Lua. This will run the interpreter and print its version.
-</OL>
-<P>
-If you're running Linux and get compilation errors,
-make sure you have installed the <TT>readline</TT> development package
-(which is probably named <TT>libreadline-dev</TT> or <TT>readline-devel</TT>).
-If you get link errors after that,
-then try "<KBD>make linux MYLIBS=-ltermcap</KBD>".
-
-<H3>Installing Lua</H3>
-<P>
-  Once you have built Lua, you may want to install it in an official
-  place in your system. In this case, do "<KBD>make install</KBD>". The official
-  place and the way to install files are defined in the <TT>Makefile</TT>. You'll
-  probably need the right permissions to install files.
-
-<P>
-  To build and install Lua in one step, do "<KBD>make xxx install</KBD>",
-  where xxx is your platform name.
-
-<P>
-  To install Lua locally, do "<KBD>make local</KBD>".
-  This will create a directory <TT>install</TT> with subdirectories
-  <TT>bin</TT>, <TT>include</TT>, <TT>lib</TT>, <TT>man</TT>, <TT>share</TT>,
-  and install Lua as listed below.
-
-  To install Lua locally, but in some other directory, do
-  "<KBD>make install INSTALL_TOP=xxx</KBD>", where xxx is your chosen directory.
-  The installation starts in the <TT>src</TT> and <TT>doc</TT> directories,
-  so take care if <TT>INSTALL_TOP</TT> is not an absolute path.
-
-<DL CLASS="display">
-<DT>
-    bin:
-<DD>
-    lua luac
-<DT>
-    include:
-<DD>
-    lua.h luaconf.h lualib.h lauxlib.h lua.hpp
-<DT>
-    lib:
-<DD>
-    liblua.a
-<DT>
-    man/man1:
-<DD>
-    lua.1 luac.1
-</DL>
-
-<P>
-  These are the only directories you need for development.
-  If you only want to run Lua programs,
-  you only need the files in <TT>bin</TT> and <TT>man</TT>.
-  The files in <TT>include</TT> and <TT>lib</TT> are needed for
-  embedding Lua in C or C++ programs.
-
-<H3><A NAME="customization">Customization</A></H3>
-<P>
-  Three kinds of things can be customized by editing a file:
-<UL>
-    <LI> Where and how to install Lua &mdash; edit <TT>Makefile</TT>.
-    <LI> How to build Lua &mdash; edit <TT>src/Makefile</TT>.
-    <LI> Lua features &mdash; edit <TT>src/luaconf.h</TT>.
-</UL>
-
-<P>
-  You don't actually need to edit the Makefiles because you may set the
-  relevant variables in the command line when invoking make.
-  Nevertheless, it's probably best to edit and save the Makefiles to
-  record the changes you've made.
-
-<P>
-  On the other hand, if you need to customize some Lua features, you'll need
-  to edit <TT>src/luaconf.h</TT> before building and installing Lua.
-  The edited file will be the one installed, and
-  it will be used by any Lua clients that you build, to ensure consistency.
-  Further customization is available to experts by editing the Lua sources.
-
-<H3><A NAME="other">Building Lua on other systems</A></H3>
-<P>
-  If you're not using the usual Unix tools, then the instructions for
-  building Lua depend on the compiler you use. You'll need to create
-  projects (or whatever your compiler uses) for building the library,
-  the interpreter, and the compiler, as follows:
-
-<DL CLASS="display">
-<DT>
-library:
-<DD>
-lapi.c lcode.c lctype.c ldebug.c ldo.c ldump.c lfunc.c lgc.c llex.c
-lmem.c lobject.c lopcodes.c lparser.c lstate.c lstring.c ltable.c
-ltm.c lundump.c lvm.c lzio.c
-lauxlib.c lbaselib.c lbitlib.c lcorolib.c ldblib.c liolib.c
-lmathlib.c loslib.c lstrlib.c ltablib.c lutf8lib.c loadlib.c linit.c
-<DT>
-interpreter:
-<DD>
-  library, lua.c
-<DT>
-compiler:
-<DD>
-  library, luac.c
-</DL>
-
-<P>
-  To use Lua as a library in your own programs you'll need to know how to
-  create and use libraries with your compiler. Moreover, to dynamically load
-  C libraries for Lua you'll need to know how to create dynamic libraries
-  and you'll need to make sure that the Lua API functions are accessible to
-  those dynamic libraries &mdash; but <EM>don't</EM> link the Lua library
-  into each dynamic library. For Unix, we recommend that the Lua library
-  be linked statically into the host program and its symbols exported for
-  dynamic linking; <TT>src/Makefile</TT> does this for the Lua interpreter.
-  For Windows, we recommend that the Lua library be a DLL.
-  In all cases, the compiler luac should be linked statically.
-
-<P>
-  As mentioned above, you may edit <TT>src/luaconf.h</TT> to customize
-  some features before building Lua.
-
-<H2><A NAME="changes">Changes since Lua 5.2</A></H2>
-<P>
-Here are the main changes introduced in Lua 5.3.
-The
-<A HREF="contents.html">reference manual</A>
-lists the
-<A HREF="manual.html#8">incompatibilities</A> that had to be introduced.
-
-<H3>Main changes</H3>
-<UL>
-<LI> integers (64-bit by default)
-<LI> official support for 32-bit numbers
-<LI> bitwise operators
-<LI> basic utf-8 support
-<LI> functions for packing and unpacking values
-
-</UL>
-
-Here are the other changes introduced in Lua 5.3:
-<H3>Language</H3>
-<UL>
-<LI> userdata can have any Lua value as uservalue
-<LI> floor division
-<LI> more flexible rules for some metamethods
-</UL>
-
-<H3>Libraries</H3>
-<UL>
-<LI> <CODE>ipairs</CODE> and the table library respect metamethods
-<LI> strip option in <CODE>string.dump</CODE>
-<LI> table library respects metamethods
-<LI> new function <CODE>table.move</CODE>
-<LI> new function <CODE>string.pack</CODE>
-<LI> new function <CODE>string.unpack</CODE>
-<LI> new function <CODE>string.packsize</CODE>
-</UL>
-
-<H3>C API</H3>
-<UL>
-<LI> simpler API for continuation functions in C
-<LI> <CODE>lua_gettable</CODE> and similar functions return type of resulted value
-<LI> strip option in <CODE>lua_dump</CODE>
-<LI> new function: <CODE>lua_geti</CODE>
-<LI> new function: <CODE>lua_seti</CODE>
-<LI> new function: <CODE>lua_isyieldable</CODE>
-<LI> new function: <CODE>lua_numbertointeger</CODE>
-<LI> new function: <CODE>lua_rotate</CODE>
-<LI> new function: <CODE>lua_stringtonumber</CODE>
-</UL>
-
-<H3>Lua standalone interpreter</H3>
-<UL>
-<LI> can be used as calculator; no need to prefix with '='
-<LI> <CODE>arg</CODE> table available to all code
-</UL>
-
-<H2><A NAME="license">License</A></H2>
-<P>
-<A HREF="http://www.opensource.org/docs/definition.php">
-<IMG SRC="osi-certified-72x60.png" ALIGN="right" ALT="[osi certified]" STYLE="padding-left: 30px ;">
-</A>
-Lua is free software distributed under the terms of the
-<A HREF="http://www.opensource.org/licenses/mit-license.html">MIT license</A>
-reproduced below;
-it may be used for any purpose, including commercial purposes,
-at absolutely no cost without having to ask us.
-
-The only requirement is that if you do use Lua,
-then you should give us credit by including the appropriate copyright notice somewhere in your product or its documentation.
-
-For details, see
-<A HREF="http://www.lua.org/license.html">this</A>.
-
-<BLOCKQUOTE STYLE="padding-bottom: 0em">
-Copyright &copy; 1994&ndash;2017 Lua.org, PUC-Rio.
-
-<P>
-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:
-
-<P>
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-<P>
-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.
-</BLOCKQUOTE>
-<P>
-
-<P CLASS="footer">
-Last update:
-Mon Jun 18 22:57:33 -03 2018
-</P>
-<!--
-Last change: revised for Lua 5.3.5
--->
-
-</BODY>
-</HTML>
diff --git a/lua/lua-5.3.5/src/Makefile b/lua/lua-5.3.5/src/Makefile
deleted file mode 100644
index 64c78f7..0000000
--- a/lua/lua-5.3.5/src/Makefile
+++ /dev/null
@@ -1,197 +0,0 @@
-# Makefile for building Lua
-# See ../doc/readme.html for installation and customization instructions.
-
-# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
-
-# Your platform. See PLATS for possible values.
-PLAT= none
-
-CC= gcc -std=gnu99
-CFLAGS= -O2 -Wall -Wextra -DLUA_COMPAT_5_2 $(SYSCFLAGS) $(MYCFLAGS)
-LDFLAGS= $(SYSLDFLAGS) $(MYLDFLAGS)
-LIBS= -lm $(SYSLIBS) $(MYLIBS)
-
-AR= ar rcu
-RANLIB= ranlib
-RM= rm -f
-
-SYSCFLAGS=
-SYSLDFLAGS=
-SYSLIBS=
-
-MYCFLAGS=
-MYLDFLAGS=
-MYLIBS=
-MYOBJS=
-
-# == END OF USER SETTINGS -- NO NEED TO CHANGE ANYTHING BELOW THIS LINE =======
-
-PLATS= aix bsd c89 freebsd generic linux macosx mingw posix solaris
-
-LUA_A=	liblua.a
-CORE_O=	lapi.o lcode.o lctype.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
-LIB_O=	lauxlib.o lbaselib.o lbitlib.o lcorolib.o ldblib.o liolib.o \
-	lmathlib.o loslib.o lstrlib.o ltablib.o lutf8lib.o loadlib.o linit.o
-BASE_O= $(CORE_O) $(LIB_O) $(MYOBJS)
-
-LUA_T=	lua
-LUA_O=	lua.o
-
-LUAC_T=	luac
-LUAC_O=	luac.o
-
-ALL_O= $(BASE_O) $(LUA_O) $(LUAC_O)
-ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)
-ALL_A= $(LUA_A)
-
-# Targets start here.
-default: $(PLAT)
-
-all:	$(ALL_T)
-
-o:	$(ALL_O)
-
-a:	$(ALL_A)
-
-$(LUA_A): $(BASE_O)
-	$(AR) $@ $(BASE_O)
-	$(RANLIB) $@
-
-$(LUA_T): $(LUA_O) $(LUA_A)
-	$(CC) -o $@ $(LDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)
-
-$(LUAC_T): $(LUAC_O) $(LUA_A)
-	$(CC) -o $@ $(LDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)
-
-clean:
-	$(RM) $(ALL_T) $(ALL_O)
-
-depend:
-	@$(CC) $(CFLAGS) -MM l*.c
-
-echo:
-	@echo "PLAT= $(PLAT)"
-	@echo "CC= $(CC)"
-	@echo "CFLAGS= $(CFLAGS)"
-	@echo "LDFLAGS= $(SYSLDFLAGS)"
-	@echo "LIBS= $(LIBS)"
-	@echo "AR= $(AR)"
-	@echo "RANLIB= $(RANLIB)"
-	@echo "RM= $(RM)"
-
-# Convenience targets for popular platforms
-ALL= all
-
-none:
-	@echo "Please do 'make PLATFORM' where PLATFORM is one of these:"
-	@echo "   $(PLATS)"
-
-aix:
-	$(MAKE) $(ALL) CC="xlc" CFLAGS="-O2 -DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-ldl" SYSLDFLAGS="-brtl -bexpall"
-
-bsd:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-Wl,-E"
-
-c89:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_C89" CC="gcc -std=c89"
-	@echo ''
-	@echo '*** C89 does not guarantee 64-bit integers for Lua.'
-	@echo ''
-
-
-freebsd:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX -DLUA_USE_READLINE -I/usr/include/edit" SYSLIBS="-Wl,-E -ledit" CC="cc"
-
-generic: $(ALL)
-
-linux:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS="-Wl,-E -ldl -lreadline"
-
-macosx:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_MACOSX" SYSLIBS="-lreadline"
-
-mingw:
-	$(MAKE) "LUA_A=lua53.dll" "LUA_T=lua.exe" \
-	"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
-	"SYSCFLAGS=-DLUA_BUILD_AS_DLL" "SYSLIBS=" "SYSLDFLAGS=-s" lua.exe
-	$(MAKE) "LUAC_T=luac.exe" luac.exe
-
-posix:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX"
-
-solaris:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN -D_REENTRANT" SYSLIBS="-ldl"
-
-# list targets that do not create files (but not all makes understand .PHONY)
-.PHONY: all $(PLATS) default o a clean depend echo none
-
-# DO NOT DELETE
-
-lapi.o: lapi.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
- lobject.h ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h lstring.h \
- ltable.h lundump.h lvm.h
-lauxlib.o: lauxlib.c lprefix.h lua.h luaconf.h lauxlib.h
-lbaselib.o: lbaselib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lbitlib.o: lbitlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lcode.o: lcode.c lprefix.h 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 \
- ldo.h lgc.h lstring.h ltable.h lvm.h
-lcorolib.o: lcorolib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lctype.o: lctype.c lprefix.h lctype.h lua.h luaconf.h llimits.h
-ldblib.o: ldblib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-ldebug.o: ldebug.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
- lobject.h ltm.h lzio.h lmem.h lcode.h llex.h lopcodes.h lparser.h \
- ldebug.h ldo.h lfunc.h lstring.h lgc.h ltable.h lvm.h
-ldo.o: ldo.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
- lobject.h ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h lopcodes.h \
- lparser.h lstring.h ltable.h lundump.h lvm.h
-ldump.o: ldump.c lprefix.h lua.h luaconf.h lobject.h llimits.h lstate.h \
- ltm.h lzio.h lmem.h lundump.h
-lfunc.o: lfunc.c lprefix.h lua.h luaconf.h lfunc.h lobject.h llimits.h \
- lgc.h lstate.h ltm.h lzio.h lmem.h
-lgc.o: lgc.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
- llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h
-linit.o: linit.c lprefix.h lua.h luaconf.h lualib.h lauxlib.h
-liolib.o: liolib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-llex.o: llex.c lprefix.h lua.h luaconf.h lctype.h llimits.h ldebug.h \
- lstate.h lobject.h ltm.h lzio.h lmem.h ldo.h lgc.h llex.h lparser.h \
- lstring.h ltable.h
-lmathlib.o: lmathlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lmem.o: lmem.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
- llimits.h ltm.h lzio.h lmem.h ldo.h lgc.h
-loadlib.o: loadlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lobject.o: lobject.c lprefix.h lua.h luaconf.h lctype.h llimits.h \
- ldebug.h lstate.h lobject.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h \
- lvm.h
-lopcodes.o: lopcodes.c lprefix.h lopcodes.h llimits.h lua.h luaconf.h
-loslib.o: loslib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lparser.o: lparser.c lprefix.h 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 \
- ldo.h lfunc.h lstring.h lgc.h ltable.h
-lstate.o: lstate.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
- lobject.h ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h llex.h \
- lstring.h ltable.h
-lstring.o: lstring.c lprefix.h lua.h luaconf.h ldebug.h lstate.h \
- lobject.h llimits.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h
-lstrlib.o: lstrlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-ltable.o: ltable.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
- llimits.h ltm.h lzio.h lmem.h ldo.h lgc.h lstring.h ltable.h lvm.h
-ltablib.o: ltablib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-ltm.o: ltm.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
- llimits.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h ltable.h lvm.h
-lua.o: lua.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-luac.o: luac.c lprefix.h lua.h luaconf.h lauxlib.h lobject.h llimits.h \
- lstate.h ltm.h lzio.h lmem.h lundump.h ldebug.h lopcodes.h
-lundump.o: lundump.c lprefix.h lua.h luaconf.h ldebug.h lstate.h \
- lobject.h llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h \
- lundump.h
-lutf8lib.o: lutf8lib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lvm.o: lvm.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
- llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h \
- ltable.h lvm.h
-lzio.o: lzio.c lprefix.h lua.h luaconf.h llimits.h lmem.h lstate.h \
- lobject.h ltm.h lzio.h
-
-# (end of Makefile)
diff --git a/lua/lua-5.3.5/src/lapi.c b/lua/lua-5.3.5/src/lapi.c
deleted file mode 100644
index 02b7fab..0000000
--- a/lua/lua-5.3.5/src/lapi.c
+++ /dev/null
@@ -1,1299 +0,0 @@
-/*
-** $Id: lapi.c,v 2.259.1.2 2017/12/06 18:35:12 roberto Exp $
-** Lua API
-** See Copyright Notice in lua.h
-*/
-
-#define lapi_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <stdarg.h>
-#include <string.h>
-
-#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[] =
-  "$LuaVersion: " LUA_COPYRIGHT " $"
-  "$LuaAuthors: " LUA_AUTHORS " $";
-
-
-/* value at a non-valid index */
-#define NONVALIDVALUE		cast(TValue *, luaO_nilobject)
-
-/* corresponding test */
-#define isvalid(o)	((o) != luaO_nilobject)
-
-/* test for pseudo index */
-#define ispseudo(i)		((i) <= LUA_REGISTRYINDEX)
-
-/* test for upvalue */
-#define isupvalue(i)		((i) < LUA_REGISTRYINDEX)
-
-/* test for valid but not pseudo index */
-#define isstackindex(i, o)	(isvalid(o) && !ispseudo(i))
-
-#define api_checkvalidindex(l,o)  api_check(l, isvalid(o), "invalid index")
-
-#define api_checkstackindex(l, i, o)  \
-	api_check(l, isstackindex(i, o), "index not in the stack")
-
-
-static TValue *index2addr (lua_State *L, int idx) {
-  CallInfo *ci = L->ci;
-  if (idx > 0) {
-    TValue *o = ci->func + idx;
-    api_check(L, idx <= ci->top - (ci->func + 1), "unacceptable index");
-    if (o >= L->top) return NONVALIDVALUE;
-    else return o;
-  }
-  else if (!ispseudo(idx)) {  /* negative index */
-    api_check(L, idx != 0 && -idx <= L->top - (ci->func + 1), "invalid index");
-    return L->top + idx;
-  }
-  else if (idx == LUA_REGISTRYINDEX)
-    return &G(L)->l_registry;
-  else {  /* upvalues */
-    idx = LUA_REGISTRYINDEX - idx;
-    api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large");
-    if (ttislcf(ci->func))  /* light C function? */
-      return NONVALIDVALUE;  /* it has no upvalues */
-    else {
-      CClosure *func = clCvalue(ci->func);
-      return (idx <= func->nupvalues) ? &func->upvalue[idx-1] : NONVALIDVALUE;
-    }
-  }
-}
-
-
-/*
-** to be called by 'lua_checkstack' in protected mode, to grow stack
-** capturing memory errors
-*/
-static void growstack (lua_State *L, void *ud) {
-  int size = *(int *)ud;
-  luaD_growstack(L, size);
-}
-
-
-LUA_API int lua_checkstack (lua_State *L, int n) {
-  int res;
-  CallInfo *ci = L->ci;
-  lua_lock(L);
-  api_check(L, n >= 0, "negative 'n'");
-  if (L->stack_last - L->top > n)  /* stack large enough? */
-    res = 1;  /* yes; check is OK */
-  else {  /* no; need to grow stack */
-    int inuse = cast_int(L->top - L->stack) + EXTRA_STACK;
-    if (inuse > LUAI_MAXSTACK - n)  /* can grow without overflow? */
-      res = 0;  /* no */
-    else  /* try to grow stack */
-      res = (luaD_rawrunprotected(L, &growstack, &n) == LUA_OK);
-  }
-  if (res && ci->top < L->top + n)
-    ci->top = L->top + n;  /* adjust frame top */
-  lua_unlock(L);
-  return res;
-}
-
-
-LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
-  int i;
-  if (from == to) return;
-  lua_lock(to);
-  api_checknelems(from, n);
-  api_check(from, G(from) == G(to), "moving among independent states");
-  api_check(from, to->ci->top - to->top >= n, "stack overflow");
-  from->top -= n;
-  for (i = 0; i < n; i++) {
-    setobj2s(to, to->top, from->top + i);
-    to->top++;  /* stack already checked by previous 'api_check' */
-  }
-  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 const lua_Number *lua_version (lua_State *L) {
-  static const lua_Number version = LUA_VERSION_NUM;
-  if (L == NULL) return &version;
-  else return G(L)->version;
-}
-
-
-
-/*
-** basic stack manipulation
-*/
-
-
-/*
-** convert an acceptable stack index into an absolute index
-*/
-LUA_API int lua_absindex (lua_State *L, int idx) {
-  return (idx > 0 || ispseudo(idx))
-         ? idx
-         : cast_int(L->top - L->ci->func) + idx;
-}
-
-
-LUA_API int lua_gettop (lua_State *L) {
-  return cast_int(L->top - (L->ci->func + 1));
-}
-
-
-LUA_API void lua_settop (lua_State *L, int idx) {
-  StkId func = L->ci->func;
-  lua_lock(L);
-  if (idx >= 0) {
-    api_check(L, idx <= L->stack_last - (func + 1), "new top too large");
-    while (L->top < (func + 1) + idx)
-      setnilvalue(L->top++);
-    L->top = (func + 1) + idx;
-  }
-  else {
-    api_check(L, -(idx+1) <= (L->top - (func + 1)), "invalid new top");
-    L->top += idx+1;  /* 'subtract' index (index is negative) */
-  }
-  lua_unlock(L);
-}
-
-
-/*
-** Reverse the stack segment from 'from' to 'to'
-** (auxiliary to 'lua_rotate')
-*/
-static void reverse (lua_State *L, StkId from, StkId to) {
-  for (; from < to; from++, to--) {
-    TValue temp;
-    setobj(L, &temp, from);
-    setobjs2s(L, from, to);
-    setobj2s(L, to, &temp);
-  }
-}
-
-
-/*
-** Let x = AB, where A is a prefix of length 'n'. Then,
-** rotate x n == BA. But BA == (A^r . B^r)^r.
-*/
-LUA_API void lua_rotate (lua_State *L, int idx, int n) {
-  StkId p, t, m;
-  lua_lock(L);
-  t = L->top - 1;  /* end of stack segment being rotated */
-  p = index2addr(L, idx);  /* start of segment */
-  api_checkstackindex(L, idx, p);
-  api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'");
-  m = (n >= 0 ? t - n : p - n - 1);  /* end of prefix */
-  reverse(L, p, m);  /* reverse the prefix with length 'n' */
-  reverse(L, m + 1, t);  /* reverse the suffix */
-  reverse(L, p, t);  /* reverse the entire segment */
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) {
-  TValue *fr, *to;
-  lua_lock(L);
-  fr = index2addr(L, fromidx);
-  to = index2addr(L, toidx);
-  api_checkvalidindex(L, to);
-  setobj(L, to, fr);
-  if (isupvalue(toidx))  /* function upvalue? */
-    luaC_barrier(L, clCvalue(L->ci->func), fr);
-  /* LUA_REGISTRYINDEX does not need gc barrier
-     (collector revisits it before finishing collection) */
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushvalue (lua_State *L, int idx) {
-  lua_lock(L);
-  setobj2s(L, L->top, index2addr(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 = index2addr(L, idx);
-  return (isvalid(o) ? ttnov(o) : LUA_TNONE);
-}
-
-
-LUA_API const char *lua_typename (lua_State *L, int t) {
-  UNUSED(L);
-  api_check(L, LUA_TNONE <= t && t < LUA_NUMTAGS, "invalid tag");
-  return ttypename(t);
-}
-
-
-LUA_API int lua_iscfunction (lua_State *L, int idx) {
-  StkId o = index2addr(L, idx);
-  return (ttislcf(o) || (ttisCclosure(o)));
-}
-
-
-LUA_API int lua_isinteger (lua_State *L, int idx) {
-  StkId o = index2addr(L, idx);
-  return ttisinteger(o);
-}
-
-
-LUA_API int lua_isnumber (lua_State *L, int idx) {
-  lua_Number n;
-  const TValue *o = index2addr(L, idx);
-  return tonumber(o, &n);
-}
-
-
-LUA_API int lua_isstring (lua_State *L, int idx) {
-  const TValue *o = index2addr(L, idx);
-  return (ttisstring(o) || cvt2str(o));
-}
-
-
-LUA_API int lua_isuserdata (lua_State *L, int idx) {
-  const TValue *o = index2addr(L, idx);
-  return (ttisfulluserdata(o) || ttislightuserdata(o));
-}
-
-
-LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
-  StkId o1 = index2addr(L, index1);
-  StkId o2 = index2addr(L, index2);
-  return (isvalid(o1) && isvalid(o2)) ? luaV_rawequalobj(o1, o2) : 0;
-}
-
-
-LUA_API void lua_arith (lua_State *L, int op) {
-  lua_lock(L);
-  if (op != LUA_OPUNM && op != LUA_OPBNOT)
-    api_checknelems(L, 2);  /* all other operations expect two operands */
-  else {  /* for unary operations, add fake 2nd operand */
-    api_checknelems(L, 1);
-    setobjs2s(L, L->top, L->top - 1);
-    api_incr_top(L);
-  }
-  /* first operand at top - 2, second at top - 1; result go to top - 2 */
-  luaO_arith(L, op, L->top - 2, L->top - 1, L->top - 2);
-  L->top--;  /* remove second operand */
-  lua_unlock(L);
-}
-
-
-LUA_API int lua_compare (lua_State *L, int index1, int index2, int op) {
-  StkId o1, o2;
-  int i = 0;
-  lua_lock(L);  /* may call tag method */
-  o1 = index2addr(L, index1);
-  o2 = index2addr(L, index2);
-  if (isvalid(o1) && isvalid(o2)) {
-    switch (op) {
-      case LUA_OPEQ: i = luaV_equalobj(L, o1, o2); break;
-      case LUA_OPLT: i = luaV_lessthan(L, o1, o2); break;
-      case LUA_OPLE: i = luaV_lessequal(L, o1, o2); break;
-      default: api_check(L, 0, "invalid option");
-    }
-  }
-  lua_unlock(L);
-  return i;
-}
-
-
-LUA_API size_t lua_stringtonumber (lua_State *L, const char *s) {
-  size_t sz = luaO_str2num(s, L->top);
-  if (sz != 0)
-    api_incr_top(L);
-  return sz;
-}
-
-
-LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *pisnum) {
-  lua_Number n;
-  const TValue *o = index2addr(L, idx);
-  int isnum = tonumber(o, &n);
-  if (!isnum)
-    n = 0;  /* call to 'tonumber' may change 'n' even if it fails */
-  if (pisnum) *pisnum = isnum;
-  return n;
-}
-
-
-LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *pisnum) {
-  lua_Integer res;
-  const TValue *o = index2addr(L, idx);
-  int isnum = tointeger(o, &res);
-  if (!isnum)
-    res = 0;  /* call to 'tointeger' may change 'n' even if it fails */
-  if (pisnum) *pisnum = isnum;
-  return res;
-}
-
-
-LUA_API int lua_toboolean (lua_State *L, int idx) {
-  const TValue *o = index2addr(L, idx);
-  return !l_isfalse(o);
-}
-
-
-LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
-  StkId o = index2addr(L, idx);
-  if (!ttisstring(o)) {
-    if (!cvt2str(o)) {  /* not convertible? */
-      if (len != NULL) *len = 0;
-      return NULL;
-    }
-    lua_lock(L);  /* 'luaO_tostring' may create a new string */
-    luaO_tostring(L, o);
-    luaC_checkGC(L);
-    o = index2addr(L, idx);  /* previous call may reallocate the stack */
-    lua_unlock(L);
-  }
-  if (len != NULL)
-    *len = vslen(o);
-  return svalue(o);
-}
-
-
-LUA_API size_t lua_rawlen (lua_State *L, int idx) {
-  StkId o = index2addr(L, idx);
-  switch (ttype(o)) {
-    case LUA_TSHRSTR: return tsvalue(o)->shrlen;
-    case LUA_TLNGSTR: return tsvalue(o)->u.lnglen;
-    case LUA_TUSERDATA: return uvalue(o)->len;
-    case LUA_TTABLE: return luaH_getn(hvalue(o));
-    default: return 0;
-  }
-}
-
-
-LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
-  StkId o = index2addr(L, idx);
-  if (ttislcf(o)) return fvalue(o);
-  else if (ttisCclosure(o))
-    return clCvalue(o)->f;
-  else return NULL;  /* not a C function */
-}
-
-
-LUA_API void *lua_touserdata (lua_State *L, int idx) {
-  StkId o = index2addr(L, idx);
-  switch (ttnov(o)) {
-    case LUA_TUSERDATA: return getudatamem(uvalue(o));
-    case LUA_TLIGHTUSERDATA: return pvalue(o);
-    default: return NULL;
-  }
-}
-
-
-LUA_API lua_State *lua_tothread (lua_State *L, int idx) {
-  StkId o = index2addr(L, idx);
-  return (!ttisthread(o)) ? NULL : thvalue(o);
-}
-
-
-LUA_API const void *lua_topointer (lua_State *L, int idx) {
-  StkId o = index2addr(L, idx);
-  switch (ttype(o)) {
-    case LUA_TTABLE: return hvalue(o);
-    case LUA_TLCL: return clLvalue(o);
-    case LUA_TCCL: return clCvalue(o);
-    case LUA_TLCF: return cast(void *, cast(size_t, fvalue(o)));
-    case LUA_TTHREAD: return thvalue(o);
-    case LUA_TUSERDATA: return getudatamem(uvalue(o));
-    case LUA_TLIGHTUSERDATA: return pvalue(o);
-    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);
-  setfltvalue(L->top, n);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
-  lua_lock(L);
-  setivalue(L->top, n);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-/*
-** Pushes on the stack a string with given length. Avoid using 's' when
-** 'len' == 0 (as 's' can be NULL in that case), due to later use of
-** 'memcmp' and 'memcpy'.
-*/
-LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) {
-  TString *ts;
-  lua_lock(L);
-  ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len);
-  setsvalue2s(L, L->top, ts);
-  api_incr_top(L);
-  luaC_checkGC(L);
-  lua_unlock(L);
-  return getstr(ts);
-}
-
-
-LUA_API const char *lua_pushstring (lua_State *L, const char *s) {
-  lua_lock(L);
-  if (s == NULL)
-    setnilvalue(L->top);
-  else {
-    TString *ts;
-    ts = luaS_new(L, s);
-    setsvalue2s(L, L->top, ts);
-    s = getstr(ts);  /* internal copy's address */
-  }
-  api_incr_top(L);
-  luaC_checkGC(L);
-  lua_unlock(L);
-  return s;
-}
-
-
-LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
-                                      va_list argp) {
-  const char *ret;
-  lua_lock(L);
-  ret = luaO_pushvfstring(L, fmt, argp);
-  luaC_checkGC(L);
-  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);
-  va_start(argp, fmt);
-  ret = luaO_pushvfstring(L, fmt, argp);
-  va_end(argp);
-  luaC_checkGC(L);
-  lua_unlock(L);
-  return ret;
-}
-
-
-LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
-  lua_lock(L);
-  if (n == 0) {
-    setfvalue(L->top, fn);
-    api_incr_top(L);
-  }
-  else {
-    CClosure *cl;
-    api_checknelems(L, n);
-    api_check(L, n <= MAXUPVAL, "upvalue index too large");
-    cl = luaF_newCclosure(L, n);
-    cl->f = fn;
-    L->top -= n;
-    while (n--) {
-      setobj2n(L, &cl->upvalue[n], L->top + n);
-      /* does not need barrier because closure is white */
-    }
-    setclCvalue(L, L->top, cl);
-    api_incr_top(L);
-    luaC_checkGC(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)
-*/
-
-
-static int auxgetstr (lua_State *L, const TValue *t, const char *k) {
-  const TValue *slot;
-  TString *str = luaS_new(L, k);
-  if (luaV_fastget(L, t, str, slot, luaH_getstr)) {
-    setobj2s(L, L->top, slot);
-    api_incr_top(L);
-  }
-  else {
-    setsvalue2s(L, L->top, str);
-    api_incr_top(L);
-    luaV_finishget(L, t, L->top - 1, L->top - 1, slot);
-  }
-  lua_unlock(L);
-  return ttnov(L->top - 1);
-}
-
-
-LUA_API int lua_getglobal (lua_State *L, const char *name) {
-  Table *reg = hvalue(&G(L)->l_registry);
-  lua_lock(L);
-  return auxgetstr(L, luaH_getint(reg, LUA_RIDX_GLOBALS), name);
-}
-
-
-LUA_API int lua_gettable (lua_State *L, int idx) {
-  StkId t;
-  lua_lock(L);
-  t = index2addr(L, idx);
-  luaV_gettable(L, t, L->top - 1, L->top - 1);
-  lua_unlock(L);
-  return ttnov(L->top - 1);
-}
-
-
-LUA_API int lua_getfield (lua_State *L, int idx, const char *k) {
-  lua_lock(L);
-  return auxgetstr(L, index2addr(L, idx), k);
-}
-
-
-LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) {
-  StkId t;
-  const TValue *slot;
-  lua_lock(L);
-  t = index2addr(L, idx);
-  if (luaV_fastget(L, t, n, slot, luaH_getint)) {
-    setobj2s(L, L->top, slot);
-    api_incr_top(L);
-  }
-  else {
-    setivalue(L->top, n);
-    api_incr_top(L);
-    luaV_finishget(L, t, L->top - 1, L->top - 1, slot);
-  }
-  lua_unlock(L);
-  return ttnov(L->top - 1);
-}
-
-
-LUA_API int lua_rawget (lua_State *L, int idx) {
-  StkId t;
-  lua_lock(L);
-  t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
-  setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));
-  lua_unlock(L);
-  return ttnov(L->top - 1);
-}
-
-
-LUA_API int lua_rawgeti (lua_State *L, int idx, lua_Integer n) {
-  StkId t;
-  lua_lock(L);
-  t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
-  setobj2s(L, L->top, luaH_getint(hvalue(t), n));
-  api_incr_top(L);
-  lua_unlock(L);
-  return ttnov(L->top - 1);
-}
-
-
-LUA_API int lua_rawgetp (lua_State *L, int idx, const void *p) {
-  StkId t;
-  TValue k;
-  lua_lock(L);
-  t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
-  setpvalue(&k, cast(void *, p));
-  setobj2s(L, L->top, luaH_get(hvalue(t), &k));
-  api_incr_top(L);
-  lua_unlock(L);
-  return ttnov(L->top - 1);
-}
-
-
-LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {
-  Table *t;
-  lua_lock(L);
-  t = luaH_new(L);
-  sethvalue(L, L->top, t);
-  api_incr_top(L);
-  if (narray > 0 || nrec > 0)
-    luaH_resize(L, t, narray, nrec);
-  luaC_checkGC(L);
-  lua_unlock(L);
-}
-
-
-LUA_API int lua_getmetatable (lua_State *L, int objindex) {
-  const TValue *obj;
-  Table *mt;
-  int res = 0;
-  lua_lock(L);
-  obj = index2addr(L, objindex);
-  switch (ttnov(obj)) {
-    case LUA_TTABLE:
-      mt = hvalue(obj)->metatable;
-      break;
-    case LUA_TUSERDATA:
-      mt = uvalue(obj)->metatable;
-      break;
-    default:
-      mt = G(L)->mt[ttnov(obj)];
-      break;
-  }
-  if (mt != NULL) {
-    sethvalue(L, L->top, mt);
-    api_incr_top(L);
-    res = 1;
-  }
-  lua_unlock(L);
-  return res;
-}
-
-
-LUA_API int lua_getuservalue (lua_State *L, int idx) {
-  StkId o;
-  lua_lock(L);
-  o = index2addr(L, idx);
-  api_check(L, ttisfulluserdata(o), "full userdata expected");
-  getuservalue(L, uvalue(o), L->top);
-  api_incr_top(L);
-  lua_unlock(L);
-  return ttnov(L->top - 1);
-}
-
-
-/*
-** set functions (stack -> Lua)
-*/
-
-/*
-** t[k] = value at the top of the stack (where 'k' is a string)
-*/
-static void auxsetstr (lua_State *L, const TValue *t, const char *k) {
-  const TValue *slot;
-  TString *str = luaS_new(L, k);
-  api_checknelems(L, 1);
-  if (luaV_fastset(L, t, str, slot, luaH_getstr, L->top - 1))
-    L->top--;  /* pop value */
-  else {
-    setsvalue2s(L, L->top, str);  /* push 'str' (to make it a TValue) */
-    api_incr_top(L);
-    luaV_finishset(L, t, L->top - 1, L->top - 2, slot);
-    L->top -= 2;  /* pop value and key */
-  }
-  lua_unlock(L);  /* lock done by caller */
-}
-
-
-LUA_API void lua_setglobal (lua_State *L, const char *name) {
-  Table *reg = hvalue(&G(L)->l_registry);
-  lua_lock(L);  /* unlock done in 'auxsetstr' */
-  auxsetstr(L, luaH_getint(reg, LUA_RIDX_GLOBALS), name);
-}
-
-
-LUA_API void lua_settable (lua_State *L, int idx) {
-  StkId t;
-  lua_lock(L);
-  api_checknelems(L, 2);
-  t = index2addr(L, idx);
-  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) {
-  lua_lock(L);  /* unlock done in 'auxsetstr' */
-  auxsetstr(L, index2addr(L, idx), k);
-}
-
-
-LUA_API void lua_seti (lua_State *L, int idx, lua_Integer n) {
-  StkId t;
-  const TValue *slot;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  t = index2addr(L, idx);
-  if (luaV_fastset(L, t, n, slot, luaH_getint, L->top - 1))
-    L->top--;  /* pop value */
-  else {
-    setivalue(L->top, n);
-    api_incr_top(L);
-    luaV_finishset(L, t, L->top - 1, L->top - 2, slot);
-    L->top -= 2;  /* pop value and key */
-  }
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_rawset (lua_State *L, int idx) {
-  StkId o;
-  TValue *slot;
-  lua_lock(L);
-  api_checknelems(L, 2);
-  o = index2addr(L, idx);
-  api_check(L, ttistable(o), "table expected");
-  slot = luaH_set(L, hvalue(o), L->top - 2);
-  setobj2t(L, slot, L->top - 1);
-  invalidateTMcache(hvalue(o));
-  luaC_barrierback(L, hvalue(o), L->top-1);
-  L->top -= 2;
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) {
-  StkId o;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  o = index2addr(L, idx);
-  api_check(L, ttistable(o), "table expected");
-  luaH_setint(L, hvalue(o), n, L->top - 1);
-  luaC_barrierback(L, hvalue(o), L->top-1);
-  L->top--;
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) {
-  StkId o;
-  TValue k, *slot;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  o = index2addr(L, idx);
-  api_check(L, ttistable(o), "table expected");
-  setpvalue(&k, cast(void *, p));
-  slot = luaH_set(L, hvalue(o), &k);
-  setobj2t(L, slot, L->top - 1);
-  luaC_barrierback(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 = index2addr(L, objindex);
-  if (ttisnil(L->top - 1))
-    mt = NULL;
-  else {
-    api_check(L, ttistable(L->top - 1), "table expected");
-    mt = hvalue(L->top - 1);
-  }
-  switch (ttnov(obj)) {
-    case LUA_TTABLE: {
-      hvalue(obj)->metatable = mt;
-      if (mt) {
-        luaC_objbarrier(L, gcvalue(obj), mt);
-        luaC_checkfinalizer(L, gcvalue(obj), mt);
-      }
-      break;
-    }
-    case LUA_TUSERDATA: {
-      uvalue(obj)->metatable = mt;
-      if (mt) {
-        luaC_objbarrier(L, uvalue(obj), mt);
-        luaC_checkfinalizer(L, gcvalue(obj), mt);
-      }
-      break;
-    }
-    default: {
-      G(L)->mt[ttnov(obj)] = mt;
-      break;
-    }
-  }
-  L->top--;
-  lua_unlock(L);
-  return 1;
-}
-
-
-LUA_API void lua_setuservalue (lua_State *L, int idx) {
-  StkId o;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  o = index2addr(L, idx);
-  api_check(L, ttisfulluserdata(o), "full userdata expected");
-  setuservalue(L, uvalue(o), L->top - 1);
-  luaC_barrier(L, gcvalue(o), L->top - 1);
-  L->top--;
-  lua_unlock(L);
-}
-
-
-/*
-** 'load' and 'call' functions (run Lua code)
-*/
-
-
-#define checkresults(L,na,nr) \
-     api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)), \
-	"results from function overflow current stack size")
-
-
-LUA_API void lua_callk (lua_State *L, int nargs, int nresults,
-                        lua_KContext ctx, lua_KFunction k) {
-  StkId func;
-  lua_lock(L);
-  api_check(L, k == NULL || !isLua(L->ci),
-    "cannot use continuations inside hooks");
-  api_checknelems(L, nargs+1);
-  api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
-  checkresults(L, nargs, nresults);
-  func = L->top - (nargs+1);
-  if (k != NULL && L->nny == 0) {  /* need to prepare continuation? */
-    L->ci->u.c.k = k;  /* save continuation */
-    L->ci->u.c.ctx = ctx;  /* save context */
-    luaD_call(L, func, nresults);  /* do the call */
-  }
-  else  /* no continuation or no yieldable */
-    luaD_callnoyield(L, func, nresults);  /* just do the call */
-  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_callnoyield(L, c->func, c->nresults);
-}
-
-
-
-LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,
-                        lua_KContext ctx, lua_KFunction k) {
-  struct CallS c;
-  int status;
-  ptrdiff_t func;
-  lua_lock(L);
-  api_check(L, k == NULL || !isLua(L->ci),
-    "cannot use continuations inside hooks");
-  api_checknelems(L, nargs+1);
-  api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
-  checkresults(L, nargs, nresults);
-  if (errfunc == 0)
-    func = 0;
-  else {
-    StkId o = index2addr(L, errfunc);
-    api_checkstackindex(L, errfunc, o);
-    func = savestack(L, o);
-  }
-  c.func = L->top - (nargs+1);  /* function to be called */
-  if (k == NULL || L->nny > 0) {  /* no continuation or no yieldable? */
-    c.nresults = nresults;  /* do a 'conventional' protected call */
-    status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
-  }
-  else {  /* prepare continuation (call is already protected by 'resume') */
-    CallInfo *ci = L->ci;
-    ci->u.c.k = k;  /* save continuation */
-    ci->u.c.ctx = ctx;  /* save context */
-    /* save information for error recovery */
-    ci->extra = savestack(L, c.func);
-    ci->u.c.old_errfunc = L->errfunc;
-    L->errfunc = func;
-    setoah(ci->callstatus, L->allowhook);  /* save value of 'allowhook' */
-    ci->callstatus |= CIST_YPCALL;  /* function can do error recovery */
-    luaD_call(L, c.func, nresults);  /* do the call */
-    ci->callstatus &= ~CIST_YPCALL;
-    L->errfunc = ci->u.c.old_errfunc;
-    status = LUA_OK;  /* if it is here, there were no errors */
-  }
-  adjustresults(L, nresults);
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,
-                      const char *chunkname, const char *mode) {
-  ZIO z;
-  int status;
-  lua_lock(L);
-  if (!chunkname) chunkname = "?";
-  luaZ_init(L, &z, reader, data);
-  status = luaD_protectedparser(L, &z, chunkname, mode);
-  if (status == LUA_OK) {  /* no errors? */
-    LClosure *f = clLvalue(L->top - 1);  /* get newly created function */
-    if (f->nupvalues >= 1) {  /* does it have an upvalue? */
-      /* get global table from registry */
-      Table *reg = hvalue(&G(L)->l_registry);
-      const TValue *gt = luaH_getint(reg, LUA_RIDX_GLOBALS);
-      /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */
-      setobj(L, f->upvals[0]->v, gt);
-      luaC_upvalbarrier(L, f->upvals[0]);
-    }
-  }
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data, int strip) {
-  int status;
-  TValue *o;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  o = L->top - 1;
-  if (isLfunction(o))
-    status = luaU_dump(L, getproto(o), writer, data, strip);
-  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->gcrunning = 0;
-      break;
-    }
-    case LUA_GCRESTART: {
-      luaE_setdebt(g, 0);
-      g->gcrunning = 1;
-      break;
-    }
-    case LUA_GCCOLLECT: {
-      luaC_fullgc(L, 0);
-      break;
-    }
-    case LUA_GCCOUNT: {
-      /* GC values are expressed in Kbytes: #bytes/2^10 */
-      res = cast_int(gettotalbytes(g) >> 10);
-      break;
-    }
-    case LUA_GCCOUNTB: {
-      res = cast_int(gettotalbytes(g) & 0x3ff);
-      break;
-    }
-    case LUA_GCSTEP: {
-      l_mem debt = 1;  /* =1 to signal that it did an actual step */
-      lu_byte oldrunning = g->gcrunning;
-      g->gcrunning = 1;  /* allow GC to run */
-      if (data == 0) {
-        luaE_setdebt(g, -GCSTEPSIZE);  /* to do a "small" step */
-        luaC_step(L);
-      }
-      else {  /* add 'data' to total debt */
-        debt = cast(l_mem, data) * 1024 + g->GCdebt;
-        luaE_setdebt(g, debt);
-        luaC_checkGC(L);
-      }
-      g->gcrunning = oldrunning;  /* restore previous state */
-      if (debt > 0 && g->gcstate == GCSpause)  /* end of cycle? */
-        res = 1;  /* signal it */
-      break;
-    }
-    case LUA_GCSETPAUSE: {
-      res = g->gcpause;
-      g->gcpause = data;
-      break;
-    }
-    case LUA_GCSETSTEPMUL: {
-      res = g->gcstepmul;
-      if (data < 40) data = 40;  /* avoid ridiculous low values (and 0) */
-      g->gcstepmul = data;
-      break;
-    }
-    case LUA_GCISRUNNING: {
-      res = g->gcrunning;
-      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);
-  /* code unreachable; will unlock when control actually leaves the kernel */
-  return 0;  /* to avoid warnings */
-}
-
-
-LUA_API int lua_next (lua_State *L, int idx) {
-  StkId t;
-  int more;
-  lua_lock(L);
-  t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
-  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) {
-    luaV_concat(L, n);
-  }
-  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 */
-  luaC_checkGC(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_len (lua_State *L, int idx) {
-  StkId t;
-  lua_lock(L);
-  t = index2addr(L, idx);
-  luaV_objlen(L, L->top, t);
-  api_incr_top(L);
-  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);
-  u = luaS_newudata(L, size);
-  setuvalue(L, L->top, u);
-  api_incr_top(L);
-  luaC_checkGC(L);
-  lua_unlock(L);
-  return getudatamem(u);
-}
-
-
-
-static const char *aux_upvalue (StkId fi, int n, TValue **val,
-                                CClosure **owner, UpVal **uv) {
-  switch (ttype(fi)) {
-    case LUA_TCCL: {  /* C closure */
-      CClosure *f = clCvalue(fi);
-      if (!(1 <= n && n <= f->nupvalues)) return NULL;
-      *val = &f->upvalue[n-1];
-      if (owner) *owner = f;
-      return "";
-    }
-    case LUA_TLCL: {  /* Lua closure */
-      LClosure *f = clLvalue(fi);
-      TString *name;
-      Proto *p = f->p;
-      if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
-      *val = f->upvals[n-1]->v;
-      if (uv) *uv = f->upvals[n - 1];
-      name = p->upvalues[n-1].name;
-      return (name == NULL) ? "(*no name)" : getstr(name);
-    }
-    default: return NULL;  /* not a closure */
-  }
-}
-
-
-LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {
-  const char *name;
-  TValue *val = NULL;  /* to avoid warnings */
-  lua_lock(L);
-  name = aux_upvalue(index2addr(L, funcindex), n, &val, NULL, NULL);
-  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 = NULL;  /* to avoid warnings */
-  CClosure *owner = NULL;
-  UpVal *uv = NULL;
-  StkId fi;
-  lua_lock(L);
-  fi = index2addr(L, funcindex);
-  api_checknelems(L, 1);
-  name = aux_upvalue(fi, n, &val, &owner, &uv);
-  if (name) {
-    L->top--;
-    setobj(L, val, L->top);
-    if (owner) { luaC_barrier(L, owner, L->top); }
-    else if (uv) { luaC_upvalbarrier(L, uv); }
-  }
-  lua_unlock(L);
-  return name;
-}
-
-
-static UpVal **getupvalref (lua_State *L, int fidx, int n, LClosure **pf) {
-  LClosure *f;
-  StkId fi = index2addr(L, fidx);
-  api_check(L, ttisLclosure(fi), "Lua function expected");
-  f = clLvalue(fi);
-  api_check(L, (1 <= n && n <= f->p->sizeupvalues), "invalid upvalue index");
-  if (pf) *pf = f;
-  return &f->upvals[n - 1];  /* get its upvalue pointer */
-}
-
-
-LUA_API void *lua_upvalueid (lua_State *L, int fidx, int n) {
-  StkId fi = index2addr(L, fidx);
-  switch (ttype(fi)) {
-    case LUA_TLCL: {  /* lua closure */
-      return *getupvalref(L, fidx, n, NULL);
-    }
-    case LUA_TCCL: {  /* C closure */
-      CClosure *f = clCvalue(fi);
-      api_check(L, 1 <= n && n <= f->nupvalues, "invalid upvalue index");
-      return &f->upvalue[n - 1];
-    }
-    default: {
-      api_check(L, 0, "closure expected");
-      return NULL;
-    }
-  }
-}
-
-
-LUA_API void lua_upvaluejoin (lua_State *L, int fidx1, int n1,
-                                            int fidx2, int n2) {
-  LClosure *f1;
-  UpVal **up1 = getupvalref(L, fidx1, n1, &f1);
-  UpVal **up2 = getupvalref(L, fidx2, n2, NULL);
-  luaC_upvdeccount(L, *up1);
-  *up1 = *up2;
-  (*up1)->refcount++;
-  if (upisopen(*up1)) (*up1)->u.open.touched = 1;
-  luaC_upvalbarrier(L, *up1);
-}
-
-
diff --git a/lua/lua-5.3.5/src/lapi.h b/lua/lua-5.3.5/src/lapi.h
deleted file mode 100644
index 8e16ad5..0000000
--- a/lua/lua-5.3.5/src/lapi.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-** $Id: lapi.h,v 2.9.1.1 2017/04/19 17:20:42 roberto Exp $
-** Auxiliary functions from Lua API
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lapi_h
-#define lapi_h
-
-
-#include "llimits.h"
-#include "lstate.h"
-
-#define api_incr_top(L)   {L->top++; api_check(L, L->top <= L->ci->top, \
-				"stack overflow");}
-
-#define adjustresults(L,nres) \
-    { if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; }
-
-#define api_checknelems(L,n)	api_check(L, (n) < (L->top - L->ci->func), \
-				  "not enough elements in the stack")
-
-
-#endif
diff --git a/lua/lua-5.3.5/src/lauxlib.c b/lua/lua-5.3.5/src/lauxlib.c
deleted file mode 100644
index 8bdada5..0000000
--- a/lua/lua-5.3.5/src/lauxlib.c
+++ /dev/null
@@ -1,1043 +0,0 @@
-/*
-** $Id: lauxlib.c,v 1.289.1.1 2017/04/19 17:20:42 roberto Exp $
-** Auxiliary functions for building Lua libraries
-** See Copyright Notice in lua.h
-*/
-
-#define lauxlib_c
-#define LUA_LIB
-
-#include "lprefix.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.
-*/
-
-#include "lua.h"
-
-#include "lauxlib.h"
-
-
-/*
-** {======================================================
-** Traceback
-** =======================================================
-*/
-
-
-#define LEVELS1	10	/* size of the first part of the stack */
-#define LEVELS2	11	/* size of the second part of the stack */
-
-
-
-/*
-** search for 'objidx' in table at index -1.
-** return 1 + string at top if find a good name.
-*/
-static int findfield (lua_State *L, int objidx, int level) {
-  if (level == 0 || !lua_istable(L, -1))
-    return 0;  /* not found */
-  lua_pushnil(L);  /* start 'next' loop */
-  while (lua_next(L, -2)) {  /* for each pair in table */
-    if (lua_type(L, -2) == LUA_TSTRING) {  /* ignore non-string keys */
-      if (lua_rawequal(L, objidx, -1)) {  /* found object? */
-        lua_pop(L, 1);  /* remove value (but keep name) */
-        return 1;
-      }
-      else if (findfield(L, objidx, level - 1)) {  /* try recursively */
-        lua_remove(L, -2);  /* remove table (but keep name) */
-        lua_pushliteral(L, ".");
-        lua_insert(L, -2);  /* place '.' between the two names */
-        lua_concat(L, 3);
-        return 1;
-      }
-    }
-    lua_pop(L, 1);  /* remove value */
-  }
-  return 0;  /* not found */
-}
-
-
-/*
-** Search for a name for a function in all loaded modules
-*/
-static int pushglobalfuncname (lua_State *L, lua_Debug *ar) {
-  int top = lua_gettop(L);
-  lua_getinfo(L, "f", ar);  /* push function */
-  lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
-  if (findfield(L, top + 1, 2)) {
-    const char *name = lua_tostring(L, -1);
-    if (strncmp(name, "_G.", 3) == 0) {  /* name start with '_G.'? */
-      lua_pushstring(L, name + 3);  /* push name without prefix */
-      lua_remove(L, -2);  /* remove original name */
-    }
-    lua_copy(L, -1, top + 1);  /* move name to proper place */
-    lua_pop(L, 2);  /* remove pushed values */
-    return 1;
-  }
-  else {
-    lua_settop(L, top);  /* remove function and global table */
-    return 0;
-  }
-}
-
-
-static void pushfuncname (lua_State *L, lua_Debug *ar) {
-  if (pushglobalfuncname(L, ar)) {  /* try first a global name */
-    lua_pushfstring(L, "function '%s'", lua_tostring(L, -1));
-    lua_remove(L, -2);  /* remove name */
-  }
-  else if (*ar->namewhat != '\0')  /* is there a name from code? */
-    lua_pushfstring(L, "%s '%s'", ar->namewhat, ar->name);  /* use it */
-  else if (*ar->what == 'm')  /* main? */
-      lua_pushliteral(L, "main chunk");
-  else if (*ar->what != 'C')  /* for Lua functions, use <file:line> */
-    lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
-  else  /* nothing left... */
-    lua_pushliteral(L, "?");
-}
-
-
-static int lastlevel (lua_State *L) {
-  lua_Debug ar;
-  int li = 1, le = 1;
-  /* find an upper bound */
-  while (lua_getstack(L, le, &ar)) { li = le; le *= 2; }
-  /* do a binary search */
-  while (li < le) {
-    int m = (li + le)/2;
-    if (lua_getstack(L, m, &ar)) li = m + 1;
-    else le = m;
-  }
-  return le - 1;
-}
-
-
-LUALIB_API void luaL_traceback (lua_State *L, lua_State *L1,
-                                const char *msg, int level) {
-  lua_Debug ar;
-  int top = lua_gettop(L);
-  int last = lastlevel(L1);
-  int n1 = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1;
-  if (msg)
-    lua_pushfstring(L, "%s\n", msg);
-  luaL_checkstack(L, 10, NULL);
-  lua_pushliteral(L, "stack traceback:");
-  while (lua_getstack(L1, level++, &ar)) {
-    if (n1-- == 0) {  /* too many levels? */
-      lua_pushliteral(L, "\n\t...");  /* add a '...' */
-      level = last - LEVELS2 + 1;  /* and skip to last ones */
-    }
-    else {
-      lua_getinfo(L1, "Slnt", &ar);
-      lua_pushfstring(L, "\n\t%s:", ar.short_src);
-      if (ar.currentline > 0)
-        lua_pushfstring(L, "%d:", ar.currentline);
-      lua_pushliteral(L, " in ");
-      pushfuncname(L, &ar);
-      if (ar.istailcall)
-        lua_pushliteral(L, "\n\t(...tail calls...)");
-      lua_concat(L, lua_gettop(L) - top);
-    }
-  }
-  lua_concat(L, lua_gettop(L) - top);
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Error-report functions
-** =======================================================
-*/
-
-LUALIB_API int luaL_argerror (lua_State *L, int arg, const char *extramsg) {
-  lua_Debug ar;
-  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
-    return luaL_error(L, "bad argument #%d (%s)", arg, extramsg);
-  lua_getinfo(L, "n", &ar);
-  if (strcmp(ar.namewhat, "method") == 0) {
-    arg--;  /* do not count 'self' */
-    if (arg == 0)  /* error is in the self argument itself? */
-      return luaL_error(L, "calling '%s' on bad self (%s)",
-                           ar.name, extramsg);
-  }
-  if (ar.name == NULL)
-    ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?";
-  return luaL_error(L, "bad argument #%d to '%s' (%s)",
-                        arg, ar.name, extramsg);
-}
-
-
-static int typeerror (lua_State *L, int arg, const char *tname) {
-  const char *msg;
-  const char *typearg;  /* name for the type of the actual argument */
-  if (luaL_getmetafield(L, arg, "__name") == LUA_TSTRING)
-    typearg = lua_tostring(L, -1);  /* use the given type name */
-  else if (lua_type(L, arg) == LUA_TLIGHTUSERDATA)
-    typearg = "light userdata";  /* special name for messages */
-  else
-    typearg = luaL_typename(L, arg);  /* standard name */
-  msg = lua_pushfstring(L, "%s expected, got %s", tname, typearg);
-  return luaL_argerror(L, arg, msg);
-}
-
-
-static void tag_error (lua_State *L, int arg, int tag) {
-  typeerror(L, arg, lua_typename(L, tag));
-}
-
-
-/*
-** The use of 'lua_pushfstring' ensures this function does not
-** need reserved stack space when called.
-*/
-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_pushfstring(L, "");  /* else, no information available... */
-}
-
-
-/*
-** Again, the use of 'lua_pushvfstring' ensures this function does
-** not need reserved stack space when called. (At worst, it generates
-** an error with "stack overflow" instead of the given message.)
-*/
-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_fileresult (lua_State *L, int stat, const char *fname) {
-  int en = errno;  /* calls to Lua API may change this value */
-  if (stat) {
-    lua_pushboolean(L, 1);
-    return 1;
-  }
-  else {
-    lua_pushnil(L);
-    if (fname)
-      lua_pushfstring(L, "%s: %s", fname, strerror(en));
-    else
-      lua_pushstring(L, strerror(en));
-    lua_pushinteger(L, en);
-    return 3;
-  }
-}
-
-
-#if !defined(l_inspectstat)	/* { */
-
-#if defined(LUA_USE_POSIX)
-
-#include <sys/wait.h>
-
-/*
-** use appropriate macros to interpret 'pclose' return status
-*/
-#define l_inspectstat(stat,what)  \
-   if (WIFEXITED(stat)) { stat = WEXITSTATUS(stat); } \
-   else if (WIFSIGNALED(stat)) { stat = WTERMSIG(stat); what = "signal"; }
-
-#else
-
-#define l_inspectstat(stat,what)  /* no op */
-
-#endif
-
-#endif				/* } */
-
-
-LUALIB_API int luaL_execresult (lua_State *L, int stat) {
-  const char *what = "exit";  /* type of termination */
-  if (stat == -1)  /* error? */
-    return luaL_fileresult(L, 0, NULL);
-  else {
-    l_inspectstat(stat, what);  /* interpret result */
-    if (*what == 'e' && stat == 0)  /* successful termination? */
-      lua_pushboolean(L, 1);
-    else
-      lua_pushnil(L);
-    lua_pushstring(L, what);
-    lua_pushinteger(L, stat);
-    return 3;  /* return true/nil,what,code */
-  }
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Userdata's metatable manipulation
-** =======================================================
-*/
-
-LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
-  if (luaL_getmetatable(L, tname) != LUA_TNIL)  /* name already in use? */
-    return 0;  /* leave previous value on top, but return 0 */
-  lua_pop(L, 1);
-  lua_createtable(L, 0, 2);  /* create metatable */
-  lua_pushstring(L, tname);
-  lua_setfield(L, -2, "__name");  /* metatable.__name = tname */
-  lua_pushvalue(L, -1);
-  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
-  return 1;
-}
-
-
-LUALIB_API void luaL_setmetatable (lua_State *L, const char *tname) {
-  luaL_getmetatable(L, tname);
-  lua_setmetatable(L, -2);
-}
-
-
-LUALIB_API void *luaL_testudata (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? */
-      luaL_getmetatable(L, tname);  /* get correct metatable */
-      if (!lua_rawequal(L, -1, -2))  /* not the same? */
-        p = NULL;  /* value is a userdata with wrong metatable */
-      lua_pop(L, 2);  /* remove both metatables */
-      return p;
-    }
-  }
-  return NULL;  /* value is not a userdata with a metatable */
-}
-
-
-LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
-  void *p = luaL_testudata(L, ud, tname);
-  if (p == NULL) typeerror(L, ud, tname);
-  return p;
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Argument check functions
-** =======================================================
-*/
-
-LUALIB_API int luaL_checkoption (lua_State *L, int arg, const char *def,
-                                 const char *const lst[]) {
-  const char *name = (def) ? luaL_optstring(L, arg, def) :
-                             luaL_checkstring(L, arg);
-  int i;
-  for (i=0; lst[i]; i++)
-    if (strcmp(lst[i], name) == 0)
-      return i;
-  return luaL_argerror(L, arg,
-                       lua_pushfstring(L, "invalid option '%s'", name));
-}
-
-
-/*
-** Ensures the stack has at least 'space' extra slots, raising an error
-** if it cannot fulfill the request. (The error handling needs a few
-** extra slots to format the error message. In case of an error without
-** this extra space, Lua will generate the same 'stack overflow' error,
-** but without 'msg'.)
-*/
-LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) {
-  if (!lua_checkstack(L, space)) {
-    if (msg)
-      luaL_error(L, "stack overflow (%s)", msg);
-    else
-      luaL_error(L, "stack overflow");
-  }
-}
-
-
-LUALIB_API void luaL_checktype (lua_State *L, int arg, int t) {
-  if (lua_type(L, arg) != t)
-    tag_error(L, arg, t);
-}
-
-
-LUALIB_API void luaL_checkany (lua_State *L, int arg) {
-  if (lua_type(L, arg) == LUA_TNONE)
-    luaL_argerror(L, arg, "value expected");
-}
-
-
-LUALIB_API const char *luaL_checklstring (lua_State *L, int arg, size_t *len) {
-  const char *s = lua_tolstring(L, arg, len);
-  if (!s) tag_error(L, arg, LUA_TSTRING);
-  return s;
-}
-
-
-LUALIB_API const char *luaL_optlstring (lua_State *L, int arg,
-                                        const char *def, size_t *len) {
-  if (lua_isnoneornil(L, arg)) {
-    if (len)
-      *len = (def ? strlen(def) : 0);
-    return def;
-  }
-  else return luaL_checklstring(L, arg, len);
-}
-
-
-LUALIB_API lua_Number luaL_checknumber (lua_State *L, int arg) {
-  int isnum;
-  lua_Number d = lua_tonumberx(L, arg, &isnum);
-  if (!isnum)
-    tag_error(L, arg, LUA_TNUMBER);
-  return d;
-}
-
-
-LUALIB_API lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number def) {
-  return luaL_opt(L, luaL_checknumber, arg, def);
-}
-
-
-static void interror (lua_State *L, int arg) {
-  if (lua_isnumber(L, arg))
-    luaL_argerror(L, arg, "number has no integer representation");
-  else
-    tag_error(L, arg, LUA_TNUMBER);
-}
-
-
-LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int arg) {
-  int isnum;
-  lua_Integer d = lua_tointegerx(L, arg, &isnum);
-  if (!isnum) {
-    interror(L, arg);
-  }
-  return d;
-}
-
-
-LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int arg,
-                                                      lua_Integer def) {
-  return luaL_opt(L, luaL_checkinteger, arg, def);
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Generic Buffer manipulation
-** =======================================================
-*/
-
-/* userdata to box arbitrary data */
-typedef struct UBox {
-  void *box;
-  size_t bsize;
-} UBox;
-
-
-static void *resizebox (lua_State *L, int idx, size_t newsize) {
-  void *ud;
-  lua_Alloc allocf = lua_getallocf(L, &ud);
-  UBox *box = (UBox *)lua_touserdata(L, idx);
-  void *temp = allocf(ud, box->box, box->bsize, newsize);
-  if (temp == NULL && newsize > 0) {  /* allocation error? */
-    resizebox(L, idx, 0);  /* free buffer */
-    luaL_error(L, "not enough memory for buffer allocation");
-  }
-  box->box = temp;
-  box->bsize = newsize;
-  return temp;
-}
-
-
-static int boxgc (lua_State *L) {
-  resizebox(L, 1, 0);
-  return 0;
-}
-
-
-static void *newbox (lua_State *L, size_t newsize) {
-  UBox *box = (UBox *)lua_newuserdata(L, sizeof(UBox));
-  box->box = NULL;
-  box->bsize = 0;
-  if (luaL_newmetatable(L, "LUABOX")) {  /* creating metatable? */
-    lua_pushcfunction(L, boxgc);
-    lua_setfield(L, -2, "__gc");  /* metatable.__gc = boxgc */
-  }
-  lua_setmetatable(L, -2);
-  return resizebox(L, -1, newsize);
-}
-
-
-/*
-** check whether buffer is using a userdata on the stack as a temporary
-** buffer
-*/
-#define buffonstack(B)	((B)->b != (B)->initb)
-
-
-/*
-** returns a pointer to a free area with at least 'sz' bytes
-*/
-LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) {
-  lua_State *L = B->L;
-  if (B->size - B->n < sz) {  /* not enough space? */
-    char *newbuff;
-    size_t newsize = B->size * 2;  /* double buffer size */
-    if (newsize - B->n < sz)  /* not big enough? */
-      newsize = B->n + sz;
-    if (newsize < B->n || newsize - B->n < sz)
-      luaL_error(L, "buffer too large");
-    /* create larger buffer */
-    if (buffonstack(B))
-      newbuff = (char *)resizebox(L, -1, newsize);
-    else {  /* no buffer yet */
-      newbuff = (char *)newbox(L, newsize);
-      memcpy(newbuff, B->b, B->n * sizeof(char));  /* copy original content */
-    }
-    B->b = newbuff;
-    B->size = newsize;
-  }
-  return &B->b[B->n];
-}
-
-
-LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
-  if (l > 0) {  /* avoid 'memcpy' when 's' can be NULL */
-    char *b = luaL_prepbuffsize(B, l);
-    memcpy(b, s, l * sizeof(char));
-    luaL_addsize(B, l);
-  }
-}
-
-
-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) {
-  lua_State *L = B->L;
-  lua_pushlstring(L, B->b, B->n);
-  if (buffonstack(B)) {
-    resizebox(L, -2, 0);  /* delete old buffer */
-    lua_remove(L, -2);  /* remove its header from the stack */
-  }
-}
-
-
-LUALIB_API void luaL_pushresultsize (luaL_Buffer *B, size_t sz) {
-  luaL_addsize(B, sz);
-  luaL_pushresult(B);
-}
-
-
-LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
-  lua_State *L = B->L;
-  size_t l;
-  const char *s = lua_tolstring(L, -1, &l);
-  if (buffonstack(B))
-    lua_insert(L, -2);  /* put value below buffer */
-  luaL_addlstring(B, s, l);
-  lua_remove(L, (buffonstack(B)) ? -2 : -1);  /* remove value */
-}
-
-
-LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
-  B->L = L;
-  B->b = B->initb;
-  B->n = 0;
-  B->size = LUAL_BUFFERSIZE;
-}
-
-
-LUALIB_API char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz) {
-  luaL_buffinit(L, B);
-  return luaL_prepbuffsize(B, sz);
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Reference system
-** =======================================================
-*/
-
-/* index of free-list header */
-#define freelist	0
-
-
-LUALIB_API int luaL_ref (lua_State *L, int t) {
-  int ref;
-  if (lua_isnil(L, -1)) {
-    lua_pop(L, 1);  /* remove from stack */
-    return LUA_REFNIL;  /* 'nil' has a unique fixed reference */
-  }
-  t = lua_absindex(L, t);
-  lua_rawgeti(L, t, freelist);  /* get first free element */
-  ref = (int)lua_tointeger(L, -1);  /* ref = t[freelist] */
-  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);  /* (t[freelist] = t[ref]) */
-  }
-  else  /* no free elements */
-    ref = (int)lua_rawlen(L, t) + 1;  /* get a 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 = lua_absindex(L, t);
-    lua_rawgeti(L, t, freelist);
-    lua_rawseti(L, t, ref);  /* t[ref] = t[freelist] */
-    lua_pushinteger(L, ref);
-    lua_rawseti(L, t, freelist);  /* t[freelist] = ref */
-  }
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Load functions
-** =======================================================
-*/
-
-typedef struct LoadF {
-  int n;  /* number of pre-read characters */
-  FILE *f;  /* file being read */
-  char buff[BUFSIZ];  /* area for reading file */
-} LoadF;
-
-
-static const char *getF (lua_State *L, void *ud, size_t *size) {
-  LoadF *lf = (LoadF *)ud;
-  (void)L;  /* not used */
-  if (lf->n > 0) {  /* are there pre-read characters to be read? */
-    *size = lf->n;  /* return them (chars already in buffer) */
-    lf->n = 0;  /* no more pre-read characters */
-  }
-  else {  /* read a block from file */
-    /* 'fread' can return > 0 *and* set the EOF flag. If next call to
-       'getF' called 'fread', it might still wait for user input.
-       The next check avoids this problem. */
-    if (feof(lf->f)) return NULL;
-    *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);  /* read block */
-  }
-  return lf->buff;
-}
-
-
-static int 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;
-}
-
-
-static int skipBOM (LoadF *lf) {
-  const char *p = "\xEF\xBB\xBF";  /* UTF-8 BOM mark */
-  int c;
-  lf->n = 0;
-  do {
-    c = getc(lf->f);
-    if (c == EOF || c != *(const unsigned char *)p++) return c;
-    lf->buff[lf->n++] = c;  /* to be read by the parser */
-  } while (*p != '\0');
-  lf->n = 0;  /* prefix matched; discard it */
-  return getc(lf->f);  /* return next character */
-}
-
-
-/*
-** reads the first character of file 'f' and skips an optional BOM mark
-** in its beginning plus its first line if it starts with '#'. Returns
-** true if it skipped the first line.  In any case, '*cp' has the
-** first "valid" character of the file (after the optional BOM and
-** a first-line comment).
-*/
-static int skipcomment (LoadF *lf, int *cp) {
-  int c = *cp = skipBOM(lf);
-  if (c == '#') {  /* first line is a comment (Unix exec. file)? */
-    do {  /* skip first line */
-      c = getc(lf->f);
-    } while (c != EOF && c != '\n');
-    *cp = getc(lf->f);  /* skip end-of-line, if present */
-    return 1;  /* there was a comment */
-  }
-  else return 0;  /* no comment */
-}
-
-
-LUALIB_API int luaL_loadfilex (lua_State *L, const char *filename,
-                                             const char *mode) {
-  LoadF lf;
-  int status, readstatus;
-  int c;
-  int fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */
-  if (filename == NULL) {
-    lua_pushliteral(L, "=stdin");
-    lf.f = stdin;
-  }
-  else {
-    lua_pushfstring(L, "@%s", filename);
-    lf.f = fopen(filename, "r");
-    if (lf.f == NULL) return errfile(L, "open", fnameindex);
-  }
-  if (skipcomment(&lf, &c))  /* read initial portion */
-    lf.buff[lf.n++] = '\n';  /* add line to correct line numbers */
-  if (c == LUA_SIGNATURE[0] && filename) {  /* binary file? */
-    lf.f = freopen(filename, "rb", lf.f);  /* reopen in binary mode */
-    if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
-    skipcomment(&lf, &c);  /* re-read initial portion */
-  }
-  if (c != EOF)
-    lf.buff[lf.n++] = c;  /* 'c' is the first character of the stream */
-  status = lua_load(L, getF, &lf, lua_tostring(L, -1), mode);
-  readstatus = ferror(lf.f);
-  if (filename) fclose(lf.f);  /* close file (even in case of errors) */
-  if (readstatus) {
-    lua_settop(L, fnameindex);  /* ignore results from 'lua_load' */
-    return 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;  /* not used */
-  if (ls->size == 0) return NULL;
-  *size = ls->size;
-  ls->size = 0;
-  return ls->s;
-}
-
-
-LUALIB_API int luaL_loadbufferx (lua_State *L, const char *buff, size_t size,
-                                 const char *name, const char *mode) {
-  LoadS ls;
-  ls.s = buff;
-  ls.size = size;
-  return lua_load(L, getS, &ls, name, mode);
-}
-
-
-LUALIB_API int luaL_loadstring (lua_State *L, const char *s) {
-  return luaL_loadbuffer(L, s, strlen(s), s);
-}
-
-/* }====================================================== */
-
-
-
-LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
-  if (!lua_getmetatable(L, obj))  /* no metatable? */
-    return LUA_TNIL;
-  else {
-    int tt;
-    lua_pushstring(L, event);
-    tt = lua_rawget(L, -2);
-    if (tt == LUA_TNIL)  /* is metafield nil? */
-      lua_pop(L, 2);  /* remove metatable and metafield */
-    else
-      lua_remove(L, -2);  /* remove only metatable */
-    return tt;  /* return metafield type */
-  }
-}
-
-
-LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
-  obj = lua_absindex(L, obj);
-  if (luaL_getmetafield(L, obj, event) == LUA_TNIL)  /* no metafield? */
-    return 0;
-  lua_pushvalue(L, obj);
-  lua_call(L, 1, 1);
-  return 1;
-}
-
-
-LUALIB_API lua_Integer luaL_len (lua_State *L, int idx) {
-  lua_Integer l;
-  int isnum;
-  lua_len(L, idx);
-  l = lua_tointegerx(L, -1, &isnum);
-  if (!isnum)
-    luaL_error(L, "object length is not an integer");
-  lua_pop(L, 1);  /* remove object */
-  return l;
-}
-
-
-LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {
-  if (luaL_callmeta(L, idx, "__tostring")) {  /* metafield? */
-    if (!lua_isstring(L, -1))
-      luaL_error(L, "'__tostring' must return a string");
-  }
-  else {
-    switch (lua_type(L, idx)) {
-      case LUA_TNUMBER: {
-        if (lua_isinteger(L, idx))
-          lua_pushfstring(L, "%I", (LUAI_UACINT)lua_tointeger(L, idx));
-        else
-          lua_pushfstring(L, "%f", (LUAI_UACNUMBER)lua_tonumber(L, idx));
-        break;
-      }
-      case LUA_TSTRING:
-        lua_pushvalue(L, idx);
-        break;
-      case LUA_TBOOLEAN:
-        lua_pushstring(L, (lua_toboolean(L, idx) ? "true" : "false"));
-        break;
-      case LUA_TNIL:
-        lua_pushliteral(L, "nil");
-        break;
-      default: {
-        int tt = luaL_getmetafield(L, idx, "__name");  /* try name */
-        const char *kind = (tt == LUA_TSTRING) ? lua_tostring(L, -1) :
-                                                 luaL_typename(L, idx);
-        lua_pushfstring(L, "%s: %p", kind, lua_topointer(L, idx));
-        if (tt != LUA_TNIL)
-          lua_remove(L, -2);  /* remove '__name' */
-        break;
-      }
-    }
-  }
-  return lua_tolstring(L, -1, len);
-}
-
-
-/*
-** {======================================================
-** Compatibility with 5.1 module functions
-** =======================================================
-*/
-#if defined(LUA_COMPAT_MODULE)
-
-static const char *luaL_findtable (lua_State *L, int idx,
-                                   const char *fname, int szhint) {
-  const char *e;
-  if (idx) lua_pushvalue(L, idx);
-  do {
-    e = strchr(fname, '.');
-    if (e == NULL) e = fname + strlen(fname);
-    lua_pushlstring(L, fname, e - fname);
-    if (lua_rawget(L, -2) == LUA_TNIL) {  /* 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;
-}
-
-
-/*
-** Count number of elements in a luaL_Reg list.
-*/
-static int libsize (const luaL_Reg *l) {
-  int size = 0;
-  for (; l && l->name; l++) size++;
-  return size;
-}
-
-
-/*
-** Find or create a module table with a given name. The function
-** first looks at the LOADED table and, if that fails, try a
-** global variable with that name. In any case, leaves on the stack
-** the module table.
-*/
-LUALIB_API void luaL_pushmodule (lua_State *L, const char *modname,
-                                 int sizehint) {
-  luaL_findtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE, 1);
-  if (lua_getfield(L, -1, modname) != LUA_TTABLE) {  /* no LOADED[modname]? */
-    lua_pop(L, 1);  /* remove previous result */
-    /* try global variable (and create one if it does not exist) */
-    lua_pushglobaltable(L);
-    if (luaL_findtable(L, 0, modname, sizehint) != NULL)
-      luaL_error(L, "name conflict for module '%s'", modname);
-    lua_pushvalue(L, -1);
-    lua_setfield(L, -3, modname);  /* LOADED[modname] = new table */
-  }
-  lua_remove(L, -2);  /* remove LOADED table */
-}
-
-
-LUALIB_API void luaL_openlib (lua_State *L, const char *libname,
-                               const luaL_Reg *l, int nup) {
-  luaL_checkversion(L);
-  if (libname) {
-    luaL_pushmodule(L, libname, libsize(l));  /* get/create library table */
-    lua_insert(L, -(nup + 1));  /* move library table to below upvalues */
-  }
-  if (l)
-    luaL_setfuncs(L, l, nup);
-  else
-    lua_pop(L, nup);  /* remove upvalues */
-}
-
-#endif
-/* }====================================================== */
-
-/*
-** set functions from list 'l' into table at top - 'nup'; each
-** function gets the 'nup' elements at the top as upvalues.
-** Returns with only the table at the stack.
-*/
-LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
-  luaL_checkstack(L, nup, "too many upvalues");
-  for (; l->name != NULL; l++) {  /* fill the table with given functions */
-    int i;
-    for (i = 0; i < nup; i++)  /* copy upvalues to the top */
-      lua_pushvalue(L, -nup);
-    lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */
-    lua_setfield(L, -(nup + 2), l->name);
-  }
-  lua_pop(L, nup);  /* remove upvalues */
-}
-
-
-/*
-** ensure that stack[idx][fname] has a table and push that table
-** into the stack
-*/
-LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) {
-  if (lua_getfield(L, idx, fname) == LUA_TTABLE)
-    return 1;  /* table already there */
-  else {
-    lua_pop(L, 1);  /* remove previous result */
-    idx = lua_absindex(L, idx);
-    lua_newtable(L);
-    lua_pushvalue(L, -1);  /* copy to be left at top */
-    lua_setfield(L, idx, fname);  /* assign new table to field */
-    return 0;  /* false, because did not find table there */
-  }
-}
-
-
-/*
-** Stripped-down 'require': After checking "loaded" table, calls 'openf'
-** to open a module, registers the result in 'package.loaded' table and,
-** if 'glb' is true, also registers the result in the global table.
-** Leaves resulting module on the top.
-*/
-LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
-                               lua_CFunction openf, int glb) {
-  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
-  lua_getfield(L, -1, modname);  /* LOADED[modname] */
-  if (!lua_toboolean(L, -1)) {  /* package not already loaded? */
-    lua_pop(L, 1);  /* remove field */
-    lua_pushcfunction(L, openf);
-    lua_pushstring(L, modname);  /* argument to open function */
-    lua_call(L, 1, 1);  /* call 'openf' to open module */
-    lua_pushvalue(L, -1);  /* make copy of module (call result) */
-    lua_setfield(L, -3, modname);  /* LOADED[modname] = module */
-  }
-  lua_remove(L, -2);  /* remove LOADED table */
-  if (glb) {
-    lua_pushvalue(L, -1);  /* copy of module */
-    lua_setglobal(L, modname);  /* _G[modname] = module */
-  }
-}
-
-
-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);
-}
-
-
-static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
-  (void)ud; (void)osize;  /* not used */
-  if (nsize == 0) {
-    free(ptr);
-    return NULL;
-  }
-  else
-    return realloc(ptr, nsize);
-}
-
-
-static int panic (lua_State *L) {
-  lua_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n",
-                        lua_tostring(L, -1));
-  return 0;  /* return to Lua to abort */
-}
-
-
-LUALIB_API lua_State *luaL_newstate (void) {
-  lua_State *L = lua_newstate(l_alloc, NULL);
-  if (L) lua_atpanic(L, &panic);
-  return L;
-}
-
-
-LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
-  const lua_Number *v = lua_version(L);
-  if (sz != LUAL_NUMSIZES)  /* check numeric types */
-    luaL_error(L, "core and library have incompatible numeric types");
-  if (v != lua_version(NULL))
-    luaL_error(L, "multiple Lua VMs detected");
-  else if (*v != ver)
-    luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
-                  (LUAI_UACNUMBER)ver, (LUAI_UACNUMBER)*v);
-}
-
diff --git a/lua/lua-5.3.5/src/lauxlib.h b/lua/lua-5.3.5/src/lauxlib.h
deleted file mode 100644
index 9857d3a..0000000
--- a/lua/lua-5.3.5/src/lauxlib.h
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
-** $Id: lauxlib.h,v 1.131.1.1 2017/04/19 17:20:42 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"
-
-
-
-/* extra error code for 'luaL_loadfilex' */
-#define LUA_ERRFILE     (LUA_ERRERR+1)
-
-
-/* key, in the registry, for table of loaded modules */
-#define LUA_LOADED_TABLE	"_LOADED"
-
-
-/* key, in the registry, for table of preloaded loaders */
-#define LUA_PRELOAD_TABLE	"_PRELOAD"
-
-
-typedef struct luaL_Reg {
-  const char *name;
-  lua_CFunction func;
-} luaL_Reg;
-
-
-#define LUAL_NUMSIZES	(sizeof(lua_Integer)*16 + sizeof(lua_Number))
-
-LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);
-#define luaL_checkversion(L)  \
-	  luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)
-
-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 const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
-LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);
-LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg,
-                                                          size_t *l);
-LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg,
-                                          const char *def, size_t *l);
-LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
-LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
-
-LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
-LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
-                                          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 arg, int t);
-LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
-
-LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
-LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);
-LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, 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 arg, const char *def,
-                                   const char *const lst[]);
-
-LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
-LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
-
-/* predefined references */
-#define LUA_NOREF       (-2)
-#define LUA_REFNIL      (-1)
-
-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_loadfilex) (lua_State *L, const char *filename,
-                                               const char *mode);
-
-#define luaL_loadfile(L,f)	luaL_loadfilex(L,f,NULL)
-
-LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
-                                   const char *name, const char *mode);
-LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
-
-LUALIB_API lua_State *(luaL_newstate) (void);
-
-LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);
-
-LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
-                                                  const char *r);
-
-LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
-
-LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
-
-LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
-                                  const char *msg, int level);
-
-LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
-                                 lua_CFunction openf, int glb);
-
-/*
-** ===============================================================
-** some useful macros
-** ===============================================================
-*/
-
-
-#define luaL_newlibtable(L,l)	\
-  lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
-
-#define luaL_newlib(L,l)  \
-  (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
-
-#define luaL_argcheck(L, cond,arg,extramsg)	\
-		((void)((cond) || luaL_argerror(L, (arg), (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_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)))
-
-#define luaL_loadbuffer(L,s,sz,n)	luaL_loadbufferx(L,s,sz,n,NULL)
-
-
-/*
-** {======================================================
-** Generic Buffer manipulation
-** =======================================================
-*/
-
-typedef struct luaL_Buffer {
-  char *b;  /* buffer address */
-  size_t size;  /* buffer size */
-  size_t n;  /* number of characters in buffer */
-  lua_State *L;
-  char initb[LUAL_BUFFERSIZE];  /* initial buffer */
-} luaL_Buffer;
-
-
-#define luaL_addchar(B,c) \
-  ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
-   ((B)->b[(B)->n++] = (c)))
-
-#define luaL_addsize(B,s)	((B)->n += (s))
-
-LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
-LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
-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);
-LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
-LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
-
-#define luaL_prepbuffer(B)	luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
-
-/* }====================================================== */
-
-
-
-/*
-** {======================================================
-** File handles for IO library
-** =======================================================
-*/
-
-/*
-** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
-** initial structure 'luaL_Stream' (it may contain other fields
-** after that initial structure).
-*/
-
-#define LUA_FILEHANDLE          "FILE*"
-
-
-typedef struct luaL_Stream {
-  FILE *f;  /* stream (NULL for incompletely created streams) */
-  lua_CFunction closef;  /* to close stream (NULL for closed streams) */
-} luaL_Stream;
-
-/* }====================================================== */
-
-
-
-/* compatibility with old module system */
-#if defined(LUA_COMPAT_MODULE)
-
-LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
-                                   int sizehint);
-LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
-                                const luaL_Reg *l, int nup);
-
-#define luaL_register(L,n,l)	(luaL_openlib(L,(n),(l),0))
-
-#endif
-
-
-/*
-** {==================================================================
-** "Abstraction Layer" for basic report of messages and errors
-** ===================================================================
-*/
-
-/* print a string */
-#if !defined(lua_writestring)
-#define lua_writestring(s,l)   fwrite((s), sizeof(char), (l), stdout)
-#endif
-
-/* print a newline and flush the output */
-#if !defined(lua_writeline)
-#define lua_writeline()        (lua_writestring("\n", 1), fflush(stdout))
-#endif
-
-/* print an error message */
-#if !defined(lua_writestringerror)
-#define lua_writestringerror(s,p) \
-        (fprintf(stderr, (s), (p)), fflush(stderr))
-#endif
-
-/* }================================================================== */
-
-
-/*
-** {============================================================
-** Compatibility with deprecated conversions
-** =============================================================
-*/
-#if defined(LUA_COMPAT_APIINTCASTS)
-
-#define luaL_checkunsigned(L,a)	((lua_Unsigned)luaL_checkinteger(L,a))
-#define luaL_optunsigned(L,a,d)	\
-	((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))
-
-#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)))
-
-#endif
-/* }============================================================ */
-
-
-
-#endif
-
-
diff --git a/lua/lua-5.3.5/src/lbaselib.c b/lua/lua-5.3.5/src/lbaselib.c
deleted file mode 100644
index 6460e4f..0000000
--- a/lua/lua-5.3.5/src/lbaselib.c
+++ /dev/null
@@ -1,498 +0,0 @@
-/*
-** $Id: lbaselib.c,v 1.314.1.1 2017/04/19 17:39:34 roberto Exp $
-** Basic library
-** See Copyright Notice in lua.h
-*/
-
-#define lbaselib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-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;
-    size_t l;
-    lua_pushvalue(L, -1);  /* function to be called */
-    lua_pushvalue(L, i);   /* value to print */
-    lua_call(L, 1, 1);
-    s = lua_tolstring(L, -1, &l);  /* get result */
-    if (s == NULL)
-      return luaL_error(L, "'tostring' must return a string to 'print'");
-    if (i>1) lua_writestring("\t", 1);
-    lua_writestring(s, l);
-    lua_pop(L, 1);  /* pop result */
-  }
-  lua_writeline();
-  return 0;
-}
-
-
-#define SPACECHARS	" \f\n\r\t\v"
-
-static const char *b_str2int (const char *s, int base, lua_Integer *pn) {
-  lua_Unsigned n = 0;
-  int neg = 0;
-  s += strspn(s, SPACECHARS);  /* skip initial spaces */
-  if (*s == '-') { s++; neg = 1; }  /* handle signal */
-  else if (*s == '+') s++;
-  if (!isalnum((unsigned char)*s))  /* no digit? */
-    return NULL;
-  do {
-    int digit = (isdigit((unsigned char)*s)) ? *s - '0'
-                   : (toupper((unsigned char)*s) - 'A') + 10;
-    if (digit >= base) return NULL;  /* invalid numeral */
-    n = n * base + digit;
-    s++;
-  } while (isalnum((unsigned char)*s));
-  s += strspn(s, SPACECHARS);  /* skip trailing spaces */
-  *pn = (lua_Integer)((neg) ? (0u - n) : n);
-  return s;
-}
-
-
-static int luaB_tonumber (lua_State *L) {
-  if (lua_isnoneornil(L, 2)) {  /* standard conversion? */
-    luaL_checkany(L, 1);
-    if (lua_type(L, 1) == LUA_TNUMBER) {  /* already a number? */
-      lua_settop(L, 1);  /* yes; return it */
-      return 1;
-    }
-    else {
-      size_t l;
-      const char *s = lua_tolstring(L, 1, &l);
-      if (s != NULL && lua_stringtonumber(L, s) == l + 1)
-        return 1;  /* successful conversion to number */
-      /* else not a number */
-    }
-  }
-  else {
-    size_t l;
-    const char *s;
-    lua_Integer n = 0;  /* to avoid warnings */
-    lua_Integer base = luaL_checkinteger(L, 2);
-    luaL_checktype(L, 1, LUA_TSTRING);  /* no numbers as strings */
-    s = lua_tolstring(L, 1, &l);
-    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
-    if (b_str2int(s, (int)base, &n) == s + l) {
-      lua_pushinteger(L, n);
-      return 1;
-    }  /* else not a number */
-  }  /* else not a number */
-  lua_pushnil(L);  /* not a number */
-  return 1;
-}
-
-
-static int luaB_error (lua_State *L) {
-  int level = (int)luaL_optinteger(L, 2, 1);
-  lua_settop(L, 1);
-  if (lua_type(L, 1) == LUA_TSTRING && level > 0) {
-    luaL_where(L, level);   /* add extra information */
-    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") != LUA_TNIL)
-    return luaL_error(L, "cannot change a protected metatable");
-  lua_settop(L, 2);
-  lua_setmetatable(L, 1);
-  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_rawlen (lua_State *L) {
-  int t = lua_type(L, 1);
-  luaL_argcheck(L, t == LUA_TTABLE || t == LUA_TSTRING, 1,
-                   "table or string expected");
-  lua_pushinteger(L, lua_rawlen(L, 1));
-  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_collectgarbage (lua_State *L) {
-  static const char *const opts[] = {"stop", "restart", "collect",
-    "count", "step", "setpause", "setstepmul",
-    "isrunning", NULL};
-  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
-    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
-    LUA_GCISRUNNING};
-  int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
-  int ex = (int)luaL_optinteger(L, 2, 0);
-  int res = lua_gc(L, o, ex);
-  switch (o) {
-    case LUA_GCCOUNT: {
-      int b = lua_gc(L, LUA_GCCOUNTB, 0);
-      lua_pushnumber(L, (lua_Number)res + ((lua_Number)b/1024));
-      return 1;
-    }
-    case LUA_GCSTEP: case LUA_GCISRUNNING: {
-      lua_pushboolean(L, res);
-      return 1;
-    }
-    default: {
-      lua_pushinteger(L, res);
-      return 1;
-    }
-  }
-}
-
-
-static int luaB_type (lua_State *L) {
-  int t = lua_type(L, 1);
-  luaL_argcheck(L, t != LUA_TNONE, 1, "value expected");
-  lua_pushstring(L, lua_typename(L, t));
-  return 1;
-}
-
-
-static int pairsmeta (lua_State *L, const char *method, int iszero,
-                      lua_CFunction iter) {
-  luaL_checkany(L, 1);
-  if (luaL_getmetafield(L, 1, method) == LUA_TNIL) {  /* no metamethod? */
-    lua_pushcfunction(L, iter);  /* will return generator, */
-    lua_pushvalue(L, 1);  /* state, */
-    if (iszero) lua_pushinteger(L, 0);  /* and initial value */
-    else lua_pushnil(L);
-  }
-  else {
-    lua_pushvalue(L, 1);  /* argument 'self' to metamethod */
-    lua_call(L, 1, 3);  /* get 3 values from metamethod */
-  }
-  return 3;
-}
-
-
-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) {
-  return pairsmeta(L, "__pairs", 0, luaB_next);
-}
-
-
-/*
-** Traversal function for 'ipairs'
-*/
-static int ipairsaux (lua_State *L) {
-  lua_Integer i = luaL_checkinteger(L, 2) + 1;
-  lua_pushinteger(L, i);
-  return (lua_geti(L, 1, i) == LUA_TNIL) ? 1 : 2;
-}
-
-
-/*
-** 'ipairs' function. Returns 'ipairsaux', given "table", 0.
-** (The given "table" may not be a table.)
-*/
-static int luaB_ipairs (lua_State *L) {
-#if defined(LUA_COMPAT_IPAIRS)
-  return pairsmeta(L, "__ipairs", 1, ipairsaux);
-#else
-  luaL_checkany(L, 1);
-  lua_pushcfunction(L, ipairsaux);  /* iteration function */
-  lua_pushvalue(L, 1);  /* state */
-  lua_pushinteger(L, 0);  /* initial value */
-  return 3;
-#endif
-}
-
-
-static int load_aux (lua_State *L, int status, int envidx) {
-  if (status == LUA_OK) {
-    if (envidx != 0) {  /* 'env' parameter? */
-      lua_pushvalue(L, envidx);  /* environment for loaded function */
-      if (!lua_setupvalue(L, -2, 1))  /* set it as 1st upvalue */
-        lua_pop(L, 1);  /* remove 'env' if not used by previous call */
-    }
-    return 1;
-  }
-  else {  /* error (message is on top of the stack) */
-    lua_pushnil(L);
-    lua_insert(L, -2);  /* put before error message */
-    return 2;  /* return nil plus error message */
-  }
-}
-
-
-static int luaB_loadfile (lua_State *L) {
-  const char *fname = luaL_optstring(L, 1, NULL);
-  const char *mode = luaL_optstring(L, 2, NULL);
-  int env = (!lua_isnone(L, 3) ? 3 : 0);  /* 'env' index or 0 if no 'env' */
-  int status = luaL_loadfilex(L, fname, mode);
-  return load_aux(L, status, env);
-}
-
-
-/*
-** {======================================================
-** Generic Read function
-** =======================================================
-*/
-
-
-/*
-** reserved slot, above all arguments, to hold a copy of the returned
-** string to avoid it being collected while parsed. 'load' has four
-** optional arguments (chunk, source name, mode, and environment).
-*/
-#define RESERVEDSLOT	5
-
-
-/*
-** 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);  /* not used */
-  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)) {
-    lua_pop(L, 1);  /* pop result */
-    *size = 0;
-    return NULL;
-  }
-  else if (!lua_isstring(L, -1))
-    luaL_error(L, "reader function must return a string");
-  lua_replace(L, RESERVEDSLOT);  /* save string in reserved slot */
-  return lua_tolstring(L, RESERVEDSLOT, size);
-}
-
-
-static int luaB_load (lua_State *L) {
-  int status;
-  size_t l;
-  const char *s = lua_tolstring(L, 1, &l);
-  const char *mode = luaL_optstring(L, 3, "bt");
-  int env = (!lua_isnone(L, 4) ? 4 : 0);  /* 'env' index or 0 if no 'env' */
-  if (s != NULL) {  /* loading a string? */
-    const char *chunkname = luaL_optstring(L, 2, s);
-    status = luaL_loadbufferx(L, s, l, chunkname, mode);
-  }
-  else {  /* loading from a reader function */
-    const char *chunkname = luaL_optstring(L, 2, "=(load)");
-    luaL_checktype(L, 1, LUA_TFUNCTION);
-    lua_settop(L, RESERVEDSLOT);  /* create reserved slot */
-    status = lua_load(L, generic_reader, NULL, chunkname, mode);
-  }
-  return load_aux(L, status, env);
-}
-
-/* }====================================================== */
-
-
-static int dofilecont (lua_State *L, int d1, lua_KContext d2) {
-  (void)d1;  (void)d2;  /* only to match 'lua_Kfunction' prototype */
-  return lua_gettop(L) - 1;
-}
-
-
-static int luaB_dofile (lua_State *L) {
-  const char *fname = luaL_optstring(L, 1, NULL);
-  lua_settop(L, 1);
-  if (luaL_loadfile(L, fname) != LUA_OK)
-    return lua_error(L);
-  lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);
-  return dofilecont(L, 0, 0);
-}
-
-
-static int luaB_assert (lua_State *L) {
-  if (lua_toboolean(L, 1))  /* condition is true? */
-    return lua_gettop(L);  /* return all arguments */
-  else {  /* error */
-    luaL_checkany(L, 1);  /* there must be a condition */
-    lua_remove(L, 1);  /* remove it */
-    lua_pushliteral(L, "assertion failed!");  /* default message */
-    lua_settop(L, 1);  /* leave only message (default if no other one) */
-    return luaB_error(L);  /* call 'error' */
-  }
-}
-
-
-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 {
-    lua_Integer i = luaL_checkinteger(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 - (int)i;
-  }
-}
-
-
-/*
-** Continuation function for 'pcall' and 'xpcall'. Both functions
-** already pushed a 'true' before doing the call, so in case of success
-** 'finishpcall' only has to return everything in the stack minus
-** 'extra' values (where 'extra' is exactly the number of items to be
-** ignored).
-*/
-static int finishpcall (lua_State *L, int status, lua_KContext extra) {
-  if (status != LUA_OK && status != LUA_YIELD) {  /* error? */
-    lua_pushboolean(L, 0);  /* first result (false) */
-    lua_pushvalue(L, -2);  /* error message */
-    return 2;  /* return false, msg */
-  }
-  else
-    return lua_gettop(L) - (int)extra;  /* return all results */
-}
-
-
-static int luaB_pcall (lua_State *L) {
-  int status;
-  luaL_checkany(L, 1);
-  lua_pushboolean(L, 1);  /* first result if no errors */
-  lua_insert(L, 1);  /* put it in place */
-  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall);
-  return finishpcall(L, status, 0);
-}
-
-
-/*
-** Do a protected call with error handling. After 'lua_rotate', the
-** stack will have <f, err, true, f, [args...]>; so, the function passes
-** 2 to 'finishpcall' to skip the 2 first values when returning results.
-*/
-static int luaB_xpcall (lua_State *L) {
-  int status;
-  int n = lua_gettop(L);
-  luaL_checktype(L, 2, LUA_TFUNCTION);  /* check error function */
-  lua_pushboolean(L, 1);  /* first result */
-  lua_pushvalue(L, 1);  /* function */
-  lua_rotate(L, 3, 2);  /* move them below function's arguments */
-  status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall);
-  return finishpcall(L, status, 2);
-}
-
-
-static int luaB_tostring (lua_State *L) {
-  luaL_checkany(L, 1);
-  luaL_tolstring(L, 1, NULL);
-  return 1;
-}
-
-
-static const luaL_Reg base_funcs[] = {
-  {"assert", luaB_assert},
-  {"collectgarbage", luaB_collectgarbage},
-  {"dofile", luaB_dofile},
-  {"error", luaB_error},
-  {"getmetatable", luaB_getmetatable},
-  {"ipairs", luaB_ipairs},
-  {"loadfile", luaB_loadfile},
-  {"load", luaB_load},
-#if defined(LUA_COMPAT_LOADSTRING)
-  {"loadstring", luaB_load},
-#endif
-  {"next", luaB_next},
-  {"pairs", luaB_pairs},
-  {"pcall", luaB_pcall},
-  {"print", luaB_print},
-  {"rawequal", luaB_rawequal},
-  {"rawlen", luaB_rawlen},
-  {"rawget", luaB_rawget},
-  {"rawset", luaB_rawset},
-  {"select", luaB_select},
-  {"setmetatable", luaB_setmetatable},
-  {"tonumber", luaB_tonumber},
-  {"tostring", luaB_tostring},
-  {"type", luaB_type},
-  {"xpcall", luaB_xpcall},
-  /* placeholders */
-  {"_G", NULL},
-  {"_VERSION", NULL},
-  {NULL, NULL}
-};
-
-
-LUAMOD_API int luaopen_base (lua_State *L) {
-  /* open lib into global table */
-  lua_pushglobaltable(L);
-  luaL_setfuncs(L, base_funcs, 0);
-  /* set global _G */
-  lua_pushvalue(L, -1);
-  lua_setfield(L, -2, "_G");
-  /* set global _VERSION */
-  lua_pushliteral(L, LUA_VERSION);
-  lua_setfield(L, -2, "_VERSION");
-  return 1;
-}
-
diff --git a/lua/lua-5.3.5/src/lbitlib.c b/lua/lua-5.3.5/src/lbitlib.c
deleted file mode 100644
index 4786c0d..0000000
--- a/lua/lua-5.3.5/src/lbitlib.c
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
-** $Id: lbitlib.c,v 1.30.1.1 2017/04/19 17:20:42 roberto Exp $
-** Standard library for bitwise operations
-** See Copyright Notice in lua.h
-*/
-
-#define lbitlib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-#if defined(LUA_COMPAT_BITLIB)		/* { */
-
-
-#define pushunsigned(L,n)	lua_pushinteger(L, (lua_Integer)(n))
-#define checkunsigned(L,i)	((lua_Unsigned)luaL_checkinteger(L,i))
-
-
-/* number of bits to consider in a number */
-#if !defined(LUA_NBITS)
-#define LUA_NBITS	32
-#endif
-
-
-/*
-** a lua_Unsigned with its first LUA_NBITS bits equal to 1. (Shift must
-** be made in two parts to avoid problems when LUA_NBITS is equal to the
-** number of bits in a lua_Unsigned.)
-*/
-#define ALLONES		(~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))
-
-
-/* macro to trim extra bits */
-#define trim(x)		((x) & ALLONES)
-
-
-/* builds a number with 'n' ones (1 <= n <= LUA_NBITS) */
-#define mask(n)		(~((ALLONES << 1) << ((n) - 1)))
-
-
-
-static lua_Unsigned andaux (lua_State *L) {
-  int i, n = lua_gettop(L);
-  lua_Unsigned r = ~(lua_Unsigned)0;
-  for (i = 1; i <= n; i++)
-    r &= checkunsigned(L, i);
-  return trim(r);
-}
-
-
-static int b_and (lua_State *L) {
-  lua_Unsigned r = andaux(L);
-  pushunsigned(L, r);
-  return 1;
-}
-
-
-static int b_test (lua_State *L) {
-  lua_Unsigned r = andaux(L);
-  lua_pushboolean(L, r != 0);
-  return 1;
-}
-
-
-static int b_or (lua_State *L) {
-  int i, n = lua_gettop(L);
-  lua_Unsigned r = 0;
-  for (i = 1; i <= n; i++)
-    r |= checkunsigned(L, i);
-  pushunsigned(L, trim(r));
-  return 1;
-}
-
-
-static int b_xor (lua_State *L) {
-  int i, n = lua_gettop(L);
-  lua_Unsigned r = 0;
-  for (i = 1; i <= n; i++)
-    r ^= checkunsigned(L, i);
-  pushunsigned(L, trim(r));
-  return 1;
-}
-
-
-static int b_not (lua_State *L) {
-  lua_Unsigned r = ~checkunsigned(L, 1);
-  pushunsigned(L, trim(r));
-  return 1;
-}
-
-
-static int b_shift (lua_State *L, lua_Unsigned r, lua_Integer i) {
-  if (i < 0) {  /* shift right? */
-    i = -i;
-    r = trim(r);
-    if (i >= LUA_NBITS) r = 0;
-    else r >>= i;
-  }
-  else {  /* shift left */
-    if (i >= LUA_NBITS) r = 0;
-    else r <<= i;
-    r = trim(r);
-  }
-  pushunsigned(L, r);
-  return 1;
-}
-
-
-static int b_lshift (lua_State *L) {
-  return b_shift(L, checkunsigned(L, 1), luaL_checkinteger(L, 2));
-}
-
-
-static int b_rshift (lua_State *L) {
-  return b_shift(L, checkunsigned(L, 1), -luaL_checkinteger(L, 2));
-}
-
-
-static int b_arshift (lua_State *L) {
-  lua_Unsigned r = checkunsigned(L, 1);
-  lua_Integer i = luaL_checkinteger(L, 2);
-  if (i < 0 || !(r & ((lua_Unsigned)1 << (LUA_NBITS - 1))))
-    return b_shift(L, r, -i);
-  else {  /* arithmetic shift for 'negative' number */
-    if (i >= LUA_NBITS) r = ALLONES;
-    else
-      r = trim((r >> i) | ~(trim(~(lua_Unsigned)0) >> i));  /* add signal bit */
-    pushunsigned(L, r);
-    return 1;
-  }
-}
-
-
-static int b_rot (lua_State *L, lua_Integer d) {
-  lua_Unsigned r = checkunsigned(L, 1);
-  int i = d & (LUA_NBITS - 1);  /* i = d % NBITS */
-  r = trim(r);
-  if (i != 0)  /* avoid undefined shift of LUA_NBITS when i == 0 */
-    r = (r << i) | (r >> (LUA_NBITS - i));
-  pushunsigned(L, trim(r));
-  return 1;
-}
-
-
-static int b_lrot (lua_State *L) {
-  return b_rot(L, luaL_checkinteger(L, 2));
-}
-
-
-static int b_rrot (lua_State *L) {
-  return b_rot(L, -luaL_checkinteger(L, 2));
-}
-
-
-/*
-** get field and width arguments for field-manipulation functions,
-** checking whether they are valid.
-** ('luaL_error' called without 'return' to avoid later warnings about
-** 'width' being used uninitialized.)
-*/
-static int fieldargs (lua_State *L, int farg, int *width) {
-  lua_Integer f = luaL_checkinteger(L, farg);
-  lua_Integer w = luaL_optinteger(L, farg + 1, 1);
-  luaL_argcheck(L, 0 <= f, farg, "field cannot be negative");
-  luaL_argcheck(L, 0 < w, farg + 1, "width must be positive");
-  if (f + w > LUA_NBITS)
-    luaL_error(L, "trying to access non-existent bits");
-  *width = (int)w;
-  return (int)f;
-}
-
-
-static int b_extract (lua_State *L) {
-  int w;
-  lua_Unsigned r = trim(checkunsigned(L, 1));
-  int f = fieldargs(L, 2, &w);
-  r = (r >> f) & mask(w);
-  pushunsigned(L, r);
-  return 1;
-}
-
-
-static int b_replace (lua_State *L) {
-  int w;
-  lua_Unsigned r = trim(checkunsigned(L, 1));
-  lua_Unsigned v = trim(checkunsigned(L, 2));
-  int f = fieldargs(L, 3, &w);
-  lua_Unsigned m = mask(w);
-  r = (r & ~(m << f)) | ((v & m) << f);
-  pushunsigned(L, r);
-  return 1;
-}
-
-
-static const luaL_Reg bitlib[] = {
-  {"arshift", b_arshift},
-  {"band", b_and},
-  {"bnot", b_not},
-  {"bor", b_or},
-  {"bxor", b_xor},
-  {"btest", b_test},
-  {"extract", b_extract},
-  {"lrotate", b_lrot},
-  {"lshift", b_lshift},
-  {"replace", b_replace},
-  {"rrotate", b_rrot},
-  {"rshift", b_rshift},
-  {NULL, NULL}
-};
-
-
-
-LUAMOD_API int luaopen_bit32 (lua_State *L) {
-  luaL_newlib(L, bitlib);
-  return 1;
-}
-
-
-#else					/* }{ */
-
-
-LUAMOD_API int luaopen_bit32 (lua_State *L) {
-  return luaL_error(L, "library 'bit32' has been deprecated");
-}
-
-#endif					/* } */
diff --git a/lua/lua-5.3.5/src/lcode.c b/lua/lua-5.3.5/src/lcode.c
deleted file mode 100644
index 12619f5..0000000
--- a/lua/lua-5.3.5/src/lcode.c
+++ /dev/null
@@ -1,1203 +0,0 @@
-/*
-** $Id: lcode.c,v 2.112.1.1 2017/04/19 17:20:42 roberto Exp $
-** Code generator for Lua
-** See Copyright Notice in lua.h
-*/
-
-#define lcode_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <math.h>
-#include <stdlib.h>
-
-#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 "lstring.h"
-#include "ltable.h"
-#include "lvm.h"
-
-
-/* Maximum number of registers in a Lua function (must fit in 8 bits) */
-#define MAXREGS		255
-
-
-#define hasjumps(e)	((e)->t != (e)->f)
-
-
-/*
-** If expression is a numeric constant, fills 'v' with its value
-** and returns 1. Otherwise, returns 0.
-*/
-static int tonumeral(const expdesc *e, TValue *v) {
-  if (hasjumps(e))
-    return 0;  /* not a numeral */
-  switch (e->k) {
-    case VKINT:
-      if (v) setivalue(v, e->u.ival);
-      return 1;
-    case VKFLT:
-      if (v) setfltvalue(v, e->u.nval);
-      return 1;
-    default: return 0;
-  }
-}
-
-
-/*
-** Create a OP_LOADNIL instruction, but try to optimize: if the previous
-** instruction is also OP_LOADNIL and ranges are compatible, adjust
-** range of previous instruction instead of emitting a new one. (For
-** instance, 'local a; local b' will generate a single opcode.)
-*/
-void luaK_nil (FuncState *fs, int from, int n) {
-  Instruction *previous;
-  int l = from + n - 1;  /* last register to set nil */
-  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */
-    previous = &fs->f->code[fs->pc-1];
-    if (GET_OPCODE(*previous) == OP_LOADNIL) {  /* previous is LOADNIL? */
-      int pfrom = GETARG_A(*previous);  /* get previous range */
-      int pl = pfrom + GETARG_B(*previous);
-      if ((pfrom <= from && from <= pl + 1) ||
-          (from <= pfrom && pfrom <= l + 1)) {  /* can connect both? */
-        if (pfrom < from) from = pfrom;  /* from = min(from, pfrom) */
-        if (pl > l) l = pl;  /* l = max(l, pl) */
-        SETARG_A(*previous, from);
-        SETARG_B(*previous, l - from);
-        return;
-      }
-    }  /* else go through */
-  }
-  luaK_codeABC(fs, OP_LOADNIL, from, n - 1, 0);  /* else no optimization */
-}
-
-
-/*
-** Gets the destination address of a jump instruction. Used to traverse
-** a list of jumps.
-*/
-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 */
-}
-
-
-/*
-** Fix jump instruction at position 'pc' to jump to 'dest'.
-** (Jump addresses are relative in Lua)
-*/
-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);
-}
-
-
-/*
-** Concatenate jump-list 'l2' into jump-list 'l1'
-*/
-void luaK_concat (FuncState *fs, int *l1, int l2) {
-  if (l2 == NO_JUMP) return;  /* nothing to concatenate? */
-  else if (*l1 == NO_JUMP)  /* no original list? */
-    *l1 = l2;  /* 'l1' points to 'l2' */
-  else {
-    int list = *l1;
-    int next;
-    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */
-      list = next;
-    fixjump(fs, list, l2);  /* last element links to 'l2' */
-  }
-}
-
-
-/*
-** Create a jump instruction and return its position, so its destination
-** can be fixed later (with 'fixjump'). If there are jumps to
-** this position (kept in 'jpc'), link them all together so that
-** 'patchlistaux' will fix all them directly to the final destination.
-*/
-int luaK_jump (FuncState *fs) {
-  int jpc = fs->jpc;  /* save list of jumps to here */
-  int j;
-  fs->jpc = NO_JUMP;  /* no more jumps to here */
-  j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);
-  luaK_concat(fs, &j, jpc);  /* keep them on hold */
-  return j;
-}
-
-
-/*
-** Code a 'return' instruction
-*/
-void luaK_ret (FuncState *fs, int first, int nret) {
-  luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);
-}
-
-
-/*
-** Code a "conditional jump", that is, a test or comparison opcode
-** followed by a jump. Return jump position.
-*/
-static int condjump (FuncState *fs, OpCode op, int A, int B, int C) {
-  luaK_codeABC(fs, op, A, B, C);
-  return luaK_jump(fs);
-}
-
-
-/*
-** 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;
-}
-
-
-/*
-** Returns the position of the instruction "controlling" a given
-** jump (that is, its condition), or the jump itself if it is
-** unconditional.
-*/
-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;
-}
-
-
-/*
-** Patch destination register for a TESTSET instruction.
-** If instruction in position 'node' is not a TESTSET, return 0 ("fails").
-** Otherwise, if 'reg' is not 'NO_REG', set it as the destination
-** register. Otherwise, change instruction to a simple 'TEST' (produces
-** no register value)
-*/
-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;
-        change instruction to simple test */
-    *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));
-  }
-  return 1;
-}
-
-
-/*
-** Traverse a list of tests ensuring no one produces a value
-*/
-static void removevalues (FuncState *fs, int list) {
-  for (; list != NO_JUMP; list = getjump(fs, list))
-      patchtestreg(fs, list, NO_REG);
-}
-
-
-/*
-** Traverse a list of tests, patching their destination address and
-** registers: tests producing values jump to 'vtarget' (and put their
-** values in 'reg'), other tests jump to 'dtarget'.
-*/
-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;
-  }
-}
-
-
-/*
-** Ensure all pending jumps to current position are fixed (jumping
-** to current position with no values) and reset list of pending
-** jumps
-*/
-static void dischargejpc (FuncState *fs) {
-  patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc);
-  fs->jpc = NO_JUMP;
-}
-
-
-/*
-** Add elements in 'list' to list of pending jumps to "here"
-** (current position)
-*/
-void luaK_patchtohere (FuncState *fs, int list) {
-  luaK_getlabel(fs);  /* mark "here" as a jump target */
-  luaK_concat(fs, &fs->jpc, list);
-}
-
-
-/*
-** Path all jumps in 'list' to jump to 'target'.
-** (The assert means that we cannot fix a jump to a forward address
-** because we only know addresses once code is generated.)
-*/
-void luaK_patchlist (FuncState *fs, int list, int target) {
-  if (target == fs->pc)  /* 'target' is current position? */
-    luaK_patchtohere(fs, list);  /* add list to pending jumps */
-  else {
-    lua_assert(target < fs->pc);
-    patchlistaux(fs, list, target, NO_REG, target);
-  }
-}
-
-
-/*
-** Path all jumps in 'list' to close upvalues up to given 'level'
-** (The assertion checks that jumps either were closing nothing
-** or were closing higher levels, from inner blocks.)
-*/
-void luaK_patchclose (FuncState *fs, int list, int level) {
-  level++;  /* argument is +1 to reserve 0 as non-op */
-  for (; list != NO_JUMP; list = getjump(fs, list)) {
-    lua_assert(GET_OPCODE(fs->f->code[list]) == OP_JMP &&
-                (GETARG_A(fs->f->code[list]) == 0 ||
-                 GETARG_A(fs->f->code[list]) >= level));
-    SETARG_A(fs->f->code[list], level);
-  }
-}
-
-
-/*
-** Emit instruction 'i', checking for array sizes and saving also its
-** line information. Return 'i' position.
-*/
-static int luaK_code (FuncState *fs, Instruction i) {
-  Proto *f = fs->f;
-  dischargejpc(fs);  /* 'pc' will change */
-  /* put new instruction in code array */
-  luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction,
-                  MAX_INT, "opcodes");
-  f->code[fs->pc] = i;
-  /* save corresponding line information */
-  luaM_growvector(fs->ls->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
-                  MAX_INT, "opcodes");
-  f->lineinfo[fs->pc] = fs->ls->lastline;
-  return fs->pc++;
-}
-
-
-/*
-** Format and emit an 'iABC' instruction. (Assertions check consistency
-** of parameters versus opcode.)
-*/
-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);
-  lua_assert(a <= MAXARG_A && b <= MAXARG_B && c <= MAXARG_C);
-  return luaK_code(fs, CREATE_ABC(o, a, b, c));
-}
-
-
-/*
-** Format and emit an 'iABx' instruction.
-*/
-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);
-  lua_assert(a <= MAXARG_A && bc <= MAXARG_Bx);
-  return luaK_code(fs, CREATE_ABx(o, a, bc));
-}
-
-
-/*
-** Emit an "extra argument" instruction (format 'iAx')
-*/
-static int codeextraarg (FuncState *fs, int a) {
-  lua_assert(a <= MAXARG_Ax);
-  return luaK_code(fs, CREATE_Ax(OP_EXTRAARG, a));
-}
-
-
-/*
-** Emit a "load constant" instruction, using either 'OP_LOADK'
-** (if constant index 'k' fits in 18 bits) or an 'OP_LOADKX'
-** instruction with "extra argument".
-*/
-int luaK_codek (FuncState *fs, int reg, int k) {
-  if (k <= MAXARG_Bx)
-    return luaK_codeABx(fs, OP_LOADK, reg, k);
-  else {
-    int p = luaK_codeABx(fs, OP_LOADKX, reg, 0);
-    codeextraarg(fs, k);
-    return p;
-  }
-}
-
-
-/*
-** Check register-stack level, keeping track of its maximum size
-** in field 'maxstacksize'
-*/
-void luaK_checkstack (FuncState *fs, int n) {
-  int newstack = fs->freereg + n;
-  if (newstack > fs->f->maxstacksize) {
-    if (newstack >= MAXREGS)
-      luaX_syntaxerror(fs->ls,
-        "function or expression needs too many registers");
-    fs->f->maxstacksize = cast_byte(newstack);
-  }
-}
-
-
-/*
-** Reserve 'n' registers in register stack
-*/
-void luaK_reserveregs (FuncState *fs, int n) {
-  luaK_checkstack(fs, n);
-  fs->freereg += n;
-}
-
-
-/*
-** Free register 'reg', if it is neither a constant index nor
-** a local variable.
-)
-*/
-static void freereg (FuncState *fs, int reg) {
-  if (!ISK(reg) && reg >= fs->nactvar) {
-    fs->freereg--;
-    lua_assert(reg == fs->freereg);
-  }
-}
-
-
-/*
-** Free register used by expression 'e' (if any)
-*/
-static void freeexp (FuncState *fs, expdesc *e) {
-  if (e->k == VNONRELOC)
-    freereg(fs, e->u.info);
-}
-
-
-/*
-** Free registers used by expressions 'e1' and 'e2' (if any) in proper
-** order.
-*/
-static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) {
-  int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1;
-  int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1;
-  if (r1 > r2) {
-    freereg(fs, r1);
-    freereg(fs, r2);
-  }
-  else {
-    freereg(fs, r2);
-    freereg(fs, r1);
-  }
-}
-
-
-/*
-** Add constant 'v' to prototype's list of constants (field 'k').
-** Use scanner's table to cache position of constants in constant list
-** and try to reuse constants. Because some values should not be used
-** as keys (nil cannot be a key, integer keys can collapse with float
-** keys), the caller must provide a useful 'key' for indexing the cache.
-*/
-static int addk (FuncState *fs, TValue *key, TValue *v) {
-  lua_State *L = fs->ls->L;
-  Proto *f = fs->f;
-  TValue *idx = luaH_set(L, fs->ls->h, key);  /* index scanner table */
-  int k, oldsize;
-  if (ttisinteger(idx)) {  /* is there an index there? */
-    k = cast_int(ivalue(idx));
-    /* correct value? (warning: must distinguish floats from integers!) */
-    if (k < fs->nk && ttype(&f->k[k]) == ttype(v) &&
-                      luaV_rawequalobj(&f->k[k], v))
-      return k;  /* reuse index */
-  }
-  /* constant not found; create a new entry */
-  oldsize = f->sizek;
-  k = fs->nk;
-  /* numerical value does not need GC barrier;
-     table has no metatable, so it does not need to invalidate cache */
-  setivalue(idx, k);
-  luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants");
-  while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
-  setobj(L, &f->k[k], v);
-  fs->nk++;
-  luaC_barrier(L, f, v);
-  return k;
-}
-
-
-/*
-** Add a string to list of constants and return its index.
-*/
-int luaK_stringK (FuncState *fs, TString *s) {
-  TValue o;
-  setsvalue(fs->ls->L, &o, s);
-  return addk(fs, &o, &o);  /* use string itself as key */
-}
-
-
-/*
-** Add an integer to list of constants and return its index.
-** Integers use userdata as keys to avoid collision with floats with
-** same value; conversion to 'void*' is used only for hashing, so there
-** are no "precision" problems.
-*/
-int luaK_intK (FuncState *fs, lua_Integer n) {
-  TValue k, o;
-  setpvalue(&k, cast(void*, cast(size_t, n)));
-  setivalue(&o, n);
-  return addk(fs, &k, &o);
-}
-
-/*
-** Add a float to list of constants and return its index.
-*/
-static int luaK_numberK (FuncState *fs, lua_Number r) {
-  TValue o;
-  setfltvalue(&o, r);
-  return addk(fs, &o, &o);  /* use number itself as key */
-}
-
-
-/*
-** Add a boolean to list of constants and return its index.
-*/
-static int boolK (FuncState *fs, int b) {
-  TValue o;
-  setbvalue(&o, b);
-  return addk(fs, &o, &o);  /* use boolean itself as key */
-}
-
-
-/*
-** Add nil to list of constants and return its index.
-*/
-static int nilK (FuncState *fs) {
-  TValue k, v;
-  setnilvalue(&v);
-  /* cannot use nil as key; instead use table itself to represent nil */
-  sethvalue(fs->ls->L, &k, fs->ls->h);
-  return addk(fs, &k, &v);
-}
-
-
-/*
-** Fix an expression to return the number of results 'nresults'.
-** Either 'e' is a multi-ret expression (function call or vararg)
-** or 'nresults' is LUA_MULTRET (as any expression can satisfy that).
-*/
-void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
-  if (e->k == VCALL) {  /* expression is an open function call? */
-    SETARG_C(getinstruction(fs, e), nresults + 1);
-  }
-  else if (e->k == VVARARG) {
-    Instruction *pc = &getinstruction(fs, e);
-    SETARG_B(*pc, nresults + 1);
-    SETARG_A(*pc, fs->freereg);
-    luaK_reserveregs(fs, 1);
-  }
-  else lua_assert(nresults == LUA_MULTRET);
-}
-
-
-/*
-** Fix an expression to return one result.
-** If expression is not a multi-ret expression (function call or
-** vararg), it already returns one result, so nothing needs to be done.
-** Function calls become VNONRELOC expressions (as its result comes
-** fixed in the base register of the call), while vararg expressions
-** become VRELOCABLE (as OP_VARARG puts its results where it wants).
-** (Calls are created returning one result, so that does not need
-** to be fixed.)
-*/
-void luaK_setoneret (FuncState *fs, expdesc *e) {
-  if (e->k == VCALL) {  /* expression is an open function call? */
-    /* already returns 1 value */
-    lua_assert(GETARG_C(getinstruction(fs, e)) == 2);
-    e->k = VNONRELOC;  /* result has fixed position */
-    e->u.info = GETARG_A(getinstruction(fs, e));
-  }
-  else if (e->k == VVARARG) {
-    SETARG_B(getinstruction(fs, e), 2);
-    e->k = VRELOCABLE;  /* can relocate its simple result */
-  }
-}
-
-
-/*
-** Ensure that expression 'e' is not a variable.
-*/
-void luaK_dischargevars (FuncState *fs, expdesc *e) {
-  switch (e->k) {
-    case VLOCAL: {  /* already in a register */
-      e->k = VNONRELOC;  /* becomes a non-relocatable value */
-      break;
-    }
-    case VUPVAL: {  /* move value to some (pending) register */
-      e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0);
-      e->k = VRELOCABLE;
-      break;
-    }
-    case VINDEXED: {
-      OpCode op;
-      freereg(fs, e->u.ind.idx);
-      if (e->u.ind.vt == VLOCAL) {  /* is 't' in a register? */
-        freereg(fs, e->u.ind.t);
-        op = OP_GETTABLE;
-      }
-      else {
-        lua_assert(e->u.ind.vt == VUPVAL);
-        op = OP_GETTABUP;  /* 't' is in an upvalue */
-      }
-      e->u.info = luaK_codeABC(fs, op, 0, e->u.ind.t, e->u.ind.idx);
-      e->k = VRELOCABLE;
-      break;
-    }
-    case VVARARG: case VCALL: {
-      luaK_setoneret(fs, e);
-      break;
-    }
-    default: break;  /* there is one value available (somewhere) */
-  }
-}
-
-
-/*
-** Ensures expression value is in register 'reg' (and therefore
-** 'e' will become a non-relocatable expression).
-*/
-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_codek(fs, reg, e->u.info);
-      break;
-    }
-    case VKFLT: {
-      luaK_codek(fs, reg, luaK_numberK(fs, e->u.nval));
-      break;
-    }
-    case VKINT: {
-      luaK_codek(fs, reg, luaK_intK(fs, e->u.ival));
-      break;
-    }
-    case VRELOCABLE: {
-      Instruction *pc = &getinstruction(fs, e);
-      SETARG_A(*pc, reg);  /* instruction will put result in 'reg' */
-      break;
-    }
-    case VNONRELOC: {
-      if (reg != e->u.info)
-        luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0);
-      break;
-    }
-    default: {
-      lua_assert(e->k == VJMP);
-      return;  /* nothing to do... */
-    }
-  }
-  e->u.info = reg;
-  e->k = VNONRELOC;
-}
-
-
-/*
-** Ensures expression value is in any register.
-*/
-static void discharge2anyreg (FuncState *fs, expdesc *e) {
-  if (e->k != VNONRELOC) {  /* no fixed register yet? */
-    luaK_reserveregs(fs, 1);  /* get a register */
-    discharge2reg(fs, e, fs->freereg-1);  /* put value there */
-  }
-}
-
-
-static int code_loadbool (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);
-}
-
-
-/*
-** 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 */
-}
-
-
-/*
-** Ensures final expression result (including results from its jump
-** lists) is in register 'reg'.
-** If expression has jumps, need to patch these jumps either to
-** its final position or to "load" instructions (for those tests
-** that do not produce values).
-*/
-static void exp2reg (FuncState *fs, expdesc *e, int reg) {
-  discharge2reg(fs, e, reg);
-  if (e->k == VJMP)  /* expression itself is a test? */
-    luaK_concat(fs, &e->t, e->u.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_loadbool(fs, reg, 0, 1);
-      p_t = code_loadbool(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.info = reg;
-  e->k = VNONRELOC;
-}
-
-
-/*
-** Ensures final expression result (including results from its jump
-** lists) is in next available register.
-*/
-void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
-  luaK_dischargevars(fs, e);
-  freeexp(fs, e);
-  luaK_reserveregs(fs, 1);
-  exp2reg(fs, e, fs->freereg - 1);
-}
-
-
-/*
-** Ensures final expression result (including results from its jump
-** lists) is in some (any) register and return that register.
-*/
-int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
-  luaK_dischargevars(fs, e);
-  if (e->k == VNONRELOC) {  /* expression already has a register? */
-    if (!hasjumps(e))  /* no jumps? */
-      return e->u.info;  /* result is already in a register */
-    if (e->u.info >= fs->nactvar) {  /* reg. is not a local? */
-      exp2reg(fs, e, e->u.info);  /* put final result in it */
-      return e->u.info;
-    }
-  }
-  luaK_exp2nextreg(fs, e);  /* otherwise, use next available register */
-  return e->u.info;
-}
-
-
-/*
-** Ensures final expression result is either in a register or in an
-** upvalue.
-*/
-void luaK_exp2anyregup (FuncState *fs, expdesc *e) {
-  if (e->k != VUPVAL || hasjumps(e))
-    luaK_exp2anyreg(fs, e);
-}
-
-
-/*
-** Ensures final expression result is either in a register or it is
-** a constant.
-*/
-void luaK_exp2val (FuncState *fs, expdesc *e) {
-  if (hasjumps(e))
-    luaK_exp2anyreg(fs, e);
-  else
-    luaK_dischargevars(fs, e);
-}
-
-
-/*
-** Ensures final expression result is in a valid R/K index
-** (that is, it is either in a register or in 'k' with an index
-** in the range of R/K indices).
-** Returns R/K index.
-*/
-int luaK_exp2RK (FuncState *fs, expdesc *e) {
-  luaK_exp2val(fs, e);
-  switch (e->k) {  /* move constants to 'k' */
-    case VTRUE: e->u.info = boolK(fs, 1); goto vk;
-    case VFALSE: e->u.info = boolK(fs, 0); goto vk;
-    case VNIL: e->u.info = nilK(fs); goto vk;
-    case VKINT: e->u.info = luaK_intK(fs, e->u.ival); goto vk;
-    case VKFLT: e->u.info = luaK_numberK(fs, e->u.nval); goto vk;
-    case VK:
-     vk:
-      e->k = VK;
-      if (e->u.info <= MAXINDEXRK)  /* constant fits in 'argC'? */
-        return RKASK(e->u.info);
-      else break;
-    default: break;
-  }
-  /* not a constant in the right range: put it in a register */
-  return luaK_exp2anyreg(fs, e);
-}
-
-
-/*
-** Generate code to store result of expression 'ex' into variable 'var'.
-*/
-void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
-  switch (var->k) {
-    case VLOCAL: {
-      freeexp(fs, ex);
-      exp2reg(fs, ex, var->u.info);  /* compute 'ex' into proper place */
-      return;
-    }
-    case VUPVAL: {
-      int e = luaK_exp2anyreg(fs, ex);
-      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0);
-      break;
-    }
-    case VINDEXED: {
-      OpCode op = (var->u.ind.vt == VLOCAL) ? OP_SETTABLE : OP_SETTABUP;
-      int e = luaK_exp2RK(fs, ex);
-      luaK_codeABC(fs, op, var->u.ind.t, var->u.ind.idx, e);
-      break;
-    }
-    default: lua_assert(0);  /* invalid var kind to store */
-  }
-  freeexp(fs, ex);
-}
-
-
-/*
-** Emit SELF instruction (convert expression 'e' into 'e:key(e,').
-*/
-void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
-  int ereg;
-  luaK_exp2anyreg(fs, e);
-  ereg = e->u.info;  /* register where 'e' was placed */
-  freeexp(fs, e);
-  e->u.info = fs->freereg;  /* base register for op_self */
-  e->k = VNONRELOC;  /* self expression has a fixed register */
-  luaK_reserveregs(fs, 2);  /* function and 'self' produced by op_self */
-  luaK_codeABC(fs, OP_SELF, e->u.info, ereg, luaK_exp2RK(fs, key));
-  freeexp(fs, key);
-}
-
-
-/*
-** Negate condition 'e' (where 'e' is a comparison).
-*/
-static void negatecondition (FuncState *fs, expdesc *e) {
-  Instruction *pc = getjumpcontrol(fs, e->u.info);
-  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
-                                           GET_OPCODE(*pc) != OP_TEST);
-  SETARG_A(*pc, !(GETARG_A(*pc)));
-}
-
-
-/*
-** Emit instruction to jump if 'e' is 'cond' (that is, if 'cond'
-** is true, code will jump if 'e' is true.) Return jump position.
-** Optimize when 'e' is 'not' something, inverting the condition
-** and removing the 'not'.
-*/
-static int jumponcond (FuncState *fs, expdesc *e, int cond) {
-  if (e->k == VRELOCABLE) {
-    Instruction ie = getinstruction(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.info, cond);
-}
-
-
-/*
-** Emit code to go through if 'e' is true, jump otherwise.
-*/
-void luaK_goiftrue (FuncState *fs, expdesc *e) {
-  int pc;  /* pc of new jump */
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VJMP: {  /* condition? */
-      negatecondition(fs, e);  /* jump when it is false */
-      pc = e->u.info;  /* save jump position */
-      break;
-    }
-    case VK: case VKFLT: case VKINT: case VTRUE: {
-      pc = NO_JUMP;  /* always true; do nothing */
-      break;
-    }
-    default: {
-      pc = jumponcond(fs, e, 0);  /* jump when false */
-      break;
-    }
-  }
-  luaK_concat(fs, &e->f, pc);  /* insert new jump in false list */
-  luaK_patchtohere(fs, e->t);  /* true list jumps to here (to go through) */
-  e->t = NO_JUMP;
-}
-
-
-/*
-** Emit code to go through if 'e' is false, jump otherwise.
-*/
-void luaK_goiffalse (FuncState *fs, expdesc *e) {
-  int pc;  /* pc of new jump */
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VJMP: {
-      pc = e->u.info;  /* already jump if true */
-      break;
-    }
-    case VNIL: case VFALSE: {
-      pc = NO_JUMP;  /* always false; do nothing */
-      break;
-    }
-    default: {
-      pc = jumponcond(fs, e, 1);  /* jump if true */
-      break;
-    }
-  }
-  luaK_concat(fs, &e->t, pc);  /* insert new jump in 't' list */
-  luaK_patchtohere(fs, e->f);  /* false list jumps to here (to go through) */
-  e->f = NO_JUMP;
-}
-
-
-/*
-** Code 'not e', doing constant folding.
-*/
-static void codenot (FuncState *fs, expdesc *e) {
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VNIL: case VFALSE: {
-      e->k = VTRUE;  /* true == not nil == not false */
-      break;
-    }
-    case VK: case VKFLT: case VKINT: case VTRUE: {
-      e->k = VFALSE;  /* false == not "x" == not 0.5 == not 1 == not true */
-      break;
-    }
-    case VJMP: {
-      negatecondition(fs, e);
-      break;
-    }
-    case VRELOCABLE:
-    case VNONRELOC: {
-      discharge2anyreg(fs, e);
-      freeexp(fs, e);
-      e->u.info = luaK_codeABC(fs, OP_NOT, 0, e->u.info, 0);
-      e->k = VRELOCABLE;
-      break;
-    }
-    default: lua_assert(0);  /* cannot happen */
-  }
-  /* interchange true and false lists */
-  { int temp = e->f; e->f = e->t; e->t = temp; }
-  removevalues(fs, e->f);  /* values are useless when negated */
-  removevalues(fs, e->t);
-}
-
-
-/*
-** Create expression 't[k]'. 't' must have its final result already in a
-** register or upvalue.
-*/
-void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
-  lua_assert(!hasjumps(t) && (vkisinreg(t->k) || t->k == VUPVAL));
-  t->u.ind.t = t->u.info;  /* register or upvalue index */
-  t->u.ind.idx = luaK_exp2RK(fs, k);  /* R/K index for key */
-  t->u.ind.vt = (t->k == VUPVAL) ? VUPVAL : VLOCAL;
-  t->k = VINDEXED;
-}
-
-
-/*
-** Return false if folding can raise an error.
-** Bitwise operations need operands convertible to integers; division
-** operations cannot have 0 as divisor.
-*/
-static int validop (int op, TValue *v1, TValue *v2) {
-  switch (op) {
-    case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
-    case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: {  /* conversion errors */
-      lua_Integer i;
-      return (tointeger(v1, &i) && tointeger(v2, &i));
-    }
-    case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD:  /* division by 0 */
-      return (nvalue(v2) != 0);
-    default: return 1;  /* everything else is valid */
-  }
-}
-
-
-/*
-** Try to "constant-fold" an operation; return 1 iff successful.
-** (In this case, 'e1' has the final result.)
-*/
-static int constfolding (FuncState *fs, int op, expdesc *e1,
-                                                const expdesc *e2) {
-  TValue v1, v2, res;
-  if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2))
-    return 0;  /* non-numeric operands or not safe to fold */
-  luaO_arith(fs->ls->L, op, &v1, &v2, &res);  /* does operation */
-  if (ttisinteger(&res)) {
-    e1->k = VKINT;
-    e1->u.ival = ivalue(&res);
-  }
-  else {  /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */
-    lua_Number n = fltvalue(&res);
-    if (luai_numisnan(n) || n == 0)
-      return 0;
-    e1->k = VKFLT;
-    e1->u.nval = n;
-  }
-  return 1;
-}
-
-
-/*
-** Emit code for unary expressions that "produce values"
-** (everything but 'not').
-** Expression to produce final result will be encoded in 'e'.
-*/
-static void codeunexpval (FuncState *fs, OpCode op, expdesc *e, int line) {
-  int r = luaK_exp2anyreg(fs, e);  /* opcodes operate only on registers */
-  freeexp(fs, e);
-  e->u.info = luaK_codeABC(fs, op, 0, r, 0);  /* generate opcode */
-  e->k = VRELOCABLE;  /* all those operations are relocatable */
-  luaK_fixline(fs, line);
-}
-
-
-/*
-** Emit code for binary expressions that "produce values"
-** (everything but logical operators 'and'/'or' and comparison
-** operators).
-** Expression to produce final result will be encoded in 'e1'.
-** Because 'luaK_exp2RK' can free registers, its calls must be
-** in "stack order" (that is, first on 'e2', which may have more
-** recent registers to be released).
-*/
-static void codebinexpval (FuncState *fs, OpCode op,
-                           expdesc *e1, expdesc *e2, int line) {
-  int rk2 = luaK_exp2RK(fs, e2);  /* both operands are "RK" */
-  int rk1 = luaK_exp2RK(fs, e1);
-  freeexps(fs, e1, e2);
-  e1->u.info = luaK_codeABC(fs, op, 0, rk1, rk2);  /* generate opcode */
-  e1->k = VRELOCABLE;  /* all those operations are relocatable */
-  luaK_fixline(fs, line);
-}
-
-
-/*
-** Emit code for comparisons.
-** 'e1' was already put in R/K form by 'luaK_infix'.
-*/
-static void codecomp (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) {
-  int rk1 = (e1->k == VK) ? RKASK(e1->u.info)
-                          : check_exp(e1->k == VNONRELOC, e1->u.info);
-  int rk2 = luaK_exp2RK(fs, e2);
-  freeexps(fs, e1, e2);
-  switch (opr) {
-    case OPR_NE: {  /* '(a ~= b)' ==> 'not (a == b)' */
-      e1->u.info = condjump(fs, OP_EQ, 0, rk1, rk2);
-      break;
-    }
-    case OPR_GT: case OPR_GE: {
-      /* '(a > b)' ==> '(b < a)';  '(a >= b)' ==> '(b <= a)' */
-      OpCode op = cast(OpCode, (opr - OPR_NE) + OP_EQ);
-      e1->u.info = condjump(fs, op, 1, rk2, rk1);  /* invert operands */
-      break;
-    }
-    default: {  /* '==', '<', '<=' use their own opcodes */
-      OpCode op = cast(OpCode, (opr - OPR_EQ) + OP_EQ);
-      e1->u.info = condjump(fs, op, 1, rk1, rk2);
-      break;
-    }
-  }
-  e1->k = VJMP;
-}
-
-
-/*
-** Aplly prefix operation 'op' to expression 'e'.
-*/
-void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) {
-  static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP};
-  switch (op) {
-    case OPR_MINUS: case OPR_BNOT:  /* use 'ef' as fake 2nd operand */
-      if (constfolding(fs, op + LUA_OPUNM, e, &ef))
-        break;
-      /* FALLTHROUGH */
-    case OPR_LEN:
-      codeunexpval(fs, cast(OpCode, op + OP_UNM), e, line);
-      break;
-    case OPR_NOT: codenot(fs, e); break;
-    default: lua_assert(0);
-  }
-}
-
-
-/*
-** Process 1st operand 'v' of binary operation 'op' before reading
-** 2nd operand.
-*/
-void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
-  switch (op) {
-    case OPR_AND: {
-      luaK_goiftrue(fs, v);  /* go ahead only if 'v' is true */
-      break;
-    }
-    case OPR_OR: {
-      luaK_goiffalse(fs, v);  /* go ahead only if 'v' is false */
-      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_IDIV:
-    case OPR_MOD: case OPR_POW:
-    case OPR_BAND: case OPR_BOR: case OPR_BXOR:
-    case OPR_SHL: case OPR_SHR: {
-      if (!tonumeral(v, NULL))
-        luaK_exp2RK(fs, v);
-      /* else keep numeral, which may be folded with 2nd operand */
-      break;
-    }
-    default: {
-      luaK_exp2RK(fs, v);
-      break;
-    }
-  }
-}
-
-
-/*
-** Finalize code for binary operation, after reading 2nd operand.
-** For '(a .. b .. c)' (which is '(a .. (b .. c))', because
-** concatenation is right associative), merge second CONCAT into first
-** one.
-*/
-void luaK_posfix (FuncState *fs, BinOpr op,
-                  expdesc *e1, expdesc *e2, int line) {
-  switch (op) {
-    case OPR_AND: {
-      lua_assert(e1->t == NO_JUMP);  /* list closed by 'luK_infix' */
-      luaK_dischargevars(fs, e2);
-      luaK_concat(fs, &e2->f, e1->f);
-      *e1 = *e2;
-      break;
-    }
-    case OPR_OR: {
-      lua_assert(e1->f == NO_JUMP);  /* list closed by 'luK_infix' */
-      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(getinstruction(fs, e2)) == OP_CONCAT) {
-        lua_assert(e1->u.info == GETARG_B(getinstruction(fs, e2))-1);
-        freeexp(fs, e1);
-        SETARG_B(getinstruction(fs, e2), e1->u.info);
-        e1->k = VRELOCABLE; e1->u.info = e2->u.info;
-      }
-      else {
-        luaK_exp2nextreg(fs, e2);  /* operand must be on the 'stack' */
-        codebinexpval(fs, OP_CONCAT, e1, e2, line);
-      }
-      break;
-    }
-    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
-    case OPR_IDIV: case OPR_MOD: case OPR_POW:
-    case OPR_BAND: case OPR_BOR: case OPR_BXOR:
-    case OPR_SHL: case OPR_SHR: {
-      if (!constfolding(fs, op + LUA_OPADD, e1, e2))
-        codebinexpval(fs, cast(OpCode, op + OP_ADD), e1, e2, line);
-      break;
-    }
-    case OPR_EQ: case OPR_LT: case OPR_LE:
-    case OPR_NE: case OPR_GT: case OPR_GE: {
-      codecomp(fs, op, e1, e2);
-      break;
-    }
-    default: lua_assert(0);
-  }
-}
-
-
-/*
-** Change line information associated with current position.
-*/
-void luaK_fixline (FuncState *fs, int line) {
-  fs->f->lineinfo[fs->pc - 1] = line;
-}
-
-
-/*
-** Emit a SETLIST instruction.
-** 'base' is register that keeps table;
-** 'nelems' is #table plus those to be stored now;
-** 'tostore' is number of values (in registers 'base + 1',...) to add to
-** table (or LUA_MULTRET to add up to stack top).
-*/
-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 && tostore <= LFIELDS_PER_FLUSH);
-  if (c <= MAXARG_C)
-    luaK_codeABC(fs, OP_SETLIST, base, b, c);
-  else if (c <= MAXARG_Ax) {
-    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
-    codeextraarg(fs, c);
-  }
-  else
-    luaX_syntaxerror(fs->ls, "constructor too long");
-  fs->freereg = base + 1;  /* free registers with list values */
-}
-
diff --git a/lua/lua-5.3.5/src/lcode.h b/lua/lua-5.3.5/src/lcode.h
deleted file mode 100644
index 882dc9c..0000000
--- a/lua/lua-5.3.5/src/lcode.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
-** $Id: lcode.h,v 1.64.1.1 2017/04/19 17:20:42 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  (ORDER OP)
-*/
-typedef enum BinOpr {
-  OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW,
-  OPR_DIV,
-  OPR_IDIV,
-  OPR_BAND, OPR_BOR, OPR_BXOR,
-  OPR_SHL, OPR_SHR,
-  OPR_CONCAT,
-  OPR_EQ, OPR_LT, OPR_LE,
-  OPR_NE, OPR_GT, OPR_GE,
-  OPR_AND, OPR_OR,
-  OPR_NOBINOPR
-} BinOpr;
-
-
-typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
-
-
-/* get (pointer to) instruction of given 'expdesc' */
-#define getinstruction(fs,e)	((fs)->f->code[(e)->u.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)
-
-#define luaK_jumpto(fs,t)	luaK_patchlist(fs, luaK_jump(fs), t)
-
-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 int luaK_codek (FuncState *fs, int reg, int k);
-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_intK (FuncState *fs, lua_Integer n);
-LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
-LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_exp2anyregup (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_goiffalse (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_patchclose (FuncState *fs, int list, int level);
-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, int line);
-LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
-LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1,
-                            expdesc *v2, int line);
-LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
-
-
-#endif
diff --git a/lua/lua-5.3.5/src/lcorolib.c b/lua/lua-5.3.5/src/lcorolib.c
deleted file mode 100644
index 0b17af9..0000000
--- a/lua/lua-5.3.5/src/lcorolib.c
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
-** $Id: lcorolib.c,v 1.10.1.1 2017/04/19 17:20:42 roberto Exp $
-** Coroutine Library
-** See Copyright Notice in lua.h
-*/
-
-#define lcorolib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <stdlib.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-static lua_State *getco (lua_State *L) {
-  lua_State *co = lua_tothread(L, 1);
-  luaL_argcheck(L, co, 1, "thread expected");
-  return co;
-}
-
-
-static int auxresume (lua_State *L, lua_State *co, int narg) {
-  int status;
-  if (!lua_checkstack(co, narg)) {
-    lua_pushliteral(L, "too many arguments to resume");
-    return -1;  /* error flag */
-  }
-  if (lua_status(co) == LUA_OK && lua_gettop(co) == 0) {
-    lua_pushliteral(L, "cannot resume dead coroutine");
-    return -1;  /* error flag */
-  }
-  lua_xmove(L, co, narg);
-  status = lua_resume(co, L, narg);
-  if (status == LUA_OK || status == LUA_YIELD) {
-    int nres = lua_gettop(co);
-    if (!lua_checkstack(L, nres + 1)) {
-      lua_pop(co, nres);  /* remove results anyway */
-      lua_pushliteral(L, "too many results to resume");
-      return -1;  /* error flag */
-    }
-    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 = getco(L);
-  int r;
-  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_type(L, -1) == LUA_TSTRING) {  /* error object is a string? */
-      luaL_where(L, 1);  /* add extra info */
-      lua_insert(L, -2);
-      lua_concat(L, 2);
-    }
-    return lua_error(L);  /* propagate error */
-  }
-  return r;
-}
-
-
-static int luaB_cocreate (lua_State *L) {
-  lua_State *NL;
-  luaL_checktype(L, 1, LUA_TFUNCTION);
-  NL = lua_newthread(L);
-  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_costatus (lua_State *L) {
-  lua_State *co = getco(L);
-  if (L == co) lua_pushliteral(L, "running");
-  else {
-    switch (lua_status(co)) {
-      case LUA_YIELD:
-        lua_pushliteral(L, "suspended");
-        break;
-      case LUA_OK: {
-        lua_Debug ar;
-        if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
-          lua_pushliteral(L, "normal");  /* it is running */
-        else if (lua_gettop(co) == 0)
-            lua_pushliteral(L, "dead");
-        else
-          lua_pushliteral(L, "suspended");  /* initial state */
-        break;
-      }
-      default:  /* some error occurred */
-        lua_pushliteral(L, "dead");
-        break;
-    }
-  }
-  return 1;
-}
-
-
-static int luaB_yieldable (lua_State *L) {
-  lua_pushboolean(L, lua_isyieldable(L));
-  return 1;
-}
-
-
-static int luaB_corunning (lua_State *L) {
-  int ismain = lua_pushthread(L);
-  lua_pushboolean(L, ismain);
-  return 2;
-}
-
-
-static const luaL_Reg co_funcs[] = {
-  {"create", luaB_cocreate},
-  {"resume", luaB_coresume},
-  {"running", luaB_corunning},
-  {"status", luaB_costatus},
-  {"wrap", luaB_cowrap},
-  {"yield", luaB_yield},
-  {"isyieldable", luaB_yieldable},
-  {NULL, NULL}
-};
-
-
-
-LUAMOD_API int luaopen_coroutine (lua_State *L) {
-  luaL_newlib(L, co_funcs);
-  return 1;
-}
-
diff --git a/lua/lua-5.3.5/src/lctype.c b/lua/lua-5.3.5/src/lctype.c
deleted file mode 100644
index f8ad7a2..0000000
--- a/lua/lua-5.3.5/src/lctype.c
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-** $Id: lctype.c,v 1.12.1.1 2017/04/19 17:20:42 roberto Exp $
-** 'ctype' functions for Lua
-** See Copyright Notice in lua.h
-*/
-
-#define lctype_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include "lctype.h"
-
-#if !LUA_USE_CTYPE	/* { */
-
-#include <limits.h>
-
-LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
-  0x00,  /* EOZ */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 0. */
-  0x00,  0x08,  0x08,  0x08,  0x08,  0x08,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 1. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x0c,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,	/* 2. */
-  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,
-  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,	/* 3. */
-  0x16,  0x16,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,
-  0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 4. */
-  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,
-  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 5. */
-  0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x05,
-  0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 6. */
-  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,
-  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 7. */
-  0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 8. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 9. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* a. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* b. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* c. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* d. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* e. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* f. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-};
-
-#endif			/* } */
diff --git a/lua/lua-5.3.5/src/lctype.h b/lua/lua-5.3.5/src/lctype.h
deleted file mode 100644
index b09b21a..0000000
--- a/lua/lua-5.3.5/src/lctype.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $
-** 'ctype' functions for Lua
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lctype_h
-#define lctype_h
-
-#include "lua.h"
-
-
-/*
-** WARNING: the functions defined here do not necessarily correspond
-** to the similar functions in the standard C ctype.h. They are
-** optimized for the specific needs of Lua
-*/
-
-#if !defined(LUA_USE_CTYPE)
-
-#if 'A' == 65 && '0' == 48
-/* ASCII case: can use its own tables; faster and fixed */
-#define LUA_USE_CTYPE	0
-#else
-/* must use standard C ctype */
-#define LUA_USE_CTYPE	1
-#endif
-
-#endif
-
-
-#if !LUA_USE_CTYPE	/* { */
-
-#include <limits.h>
-
-#include "llimits.h"
-
-
-#define ALPHABIT	0
-#define DIGITBIT	1
-#define PRINTBIT	2
-#define SPACEBIT	3
-#define XDIGITBIT	4
-
-
-#define MASK(B)		(1 << (B))
-
-
-/*
-** add 1 to char to allow index -1 (EOZ)
-*/
-#define testprop(c,p)	(luai_ctype_[(c)+1] & (p))
-
-/*
-** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_'
-*/
-#define lislalpha(c)	testprop(c, MASK(ALPHABIT))
-#define lislalnum(c)	testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))
-#define lisdigit(c)	testprop(c, MASK(DIGITBIT))
-#define lisspace(c)	testprop(c, MASK(SPACEBIT))
-#define lisprint(c)	testprop(c, MASK(PRINTBIT))
-#define lisxdigit(c)	testprop(c, MASK(XDIGITBIT))
-
-/*
-** this 'ltolower' only works for alphabetic characters
-*/
-#define ltolower(c)	((c) | ('A' ^ 'a'))
-
-
-/* two more entries for 0 and -1 (EOZ) */
-LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];
-
-
-#else			/* }{ */
-
-/*
-** use standard C ctypes
-*/
-
-#include <ctype.h>
-
-
-#define lislalpha(c)	(isalpha(c) || (c) == '_')
-#define lislalnum(c)	(isalnum(c) || (c) == '_')
-#define lisdigit(c)	(isdigit(c))
-#define lisspace(c)	(isspace(c))
-#define lisprint(c)	(isprint(c))
-#define lisxdigit(c)	(isxdigit(c))
-
-#define ltolower(c)	(tolower(c))
-
-#endif			/* } */
-
-#endif
-
diff --git a/lua/lua-5.3.5/src/ldblib.c b/lua/lua-5.3.5/src/ldblib.c
deleted file mode 100644
index 9d29afb..0000000
--- a/lua/lua-5.3.5/src/ldblib.c
+++ /dev/null
@@ -1,456 +0,0 @@
-/*
-** $Id: ldblib.c,v 1.151.1.1 2017/04/19 17:20:42 roberto Exp $
-** Interface from Lua to its debug API
-** See Copyright Notice in lua.h
-*/
-
-#define ldblib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/*
-** The hook table at registry[&HOOKKEY] maps threads to their current
-** hook function. (We only need the unique address of 'HOOKKEY'.)
-*/
-static const int HOOKKEY = 0;
-
-
-/*
-** If L1 != L, L1 can be in any state, and therefore there are no
-** guarantees about its stack space; any push in L1 must be
-** checked.
-*/
-static void checkstack (lua_State *L, lua_State *L1, int n) {
-  if (L != L1 && !lua_checkstack(L1, n))
-    luaL_error(L, "stack overflow");
-}
-
-
-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_setmetatable(L, 1);
-  return 1;  /* return 1st argument */
-}
-
-
-static int db_getuservalue (lua_State *L) {
-  if (lua_type(L, 1) != LUA_TUSERDATA)
-    lua_pushnil(L);
-  else
-    lua_getuservalue(L, 1);
-  return 1;
-}
-
-
-static int db_setuservalue (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TUSERDATA);
-  luaL_checkany(L, 2);
-  lua_settop(L, 2);
-  lua_setuservalue(L, 1);
-  return 1;
-}
-
-
-/*
-** Auxiliary function used by several library functions: check for
-** an optional thread as function's first argument and set 'arg' with
-** 1 if this argument is present (so that functions can skip it to
-** access their other arguments)
-*/
-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;  /* function will operate over current thread */
-  }
-}
-
-
-/*
-** Variations of 'lua_settable', used by 'db_getinfo' to put results
-** from 'lua_getinfo' into result table. Key is always a string;
-** value can be a string, an int, or a boolean.
-*/
-static void settabss (lua_State *L, const char *k, const char *v) {
-  lua_pushstring(L, v);
-  lua_setfield(L, -2, k);
-}
-
-static void settabsi (lua_State *L, const char *k, int v) {
-  lua_pushinteger(L, v);
-  lua_setfield(L, -2, k);
-}
-
-static void settabsb (lua_State *L, const char *k, int v) {
-  lua_pushboolean(L, v);
-  lua_setfield(L, -2, k);
-}
-
-
-/*
-** In function 'db_getinfo', the call to 'lua_getinfo' may push
-** results on the stack; later it creates the result table to put
-** these objects. Function 'treatstackoption' puts the result from
-** 'lua_getinfo' on top of the result table so that it can call
-** 'lua_setfield'.
-*/
-static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
-  if (L == L1)
-    lua_rotate(L, -2, 1);  /* exchange object and table */
-  else
-    lua_xmove(L1, L, 1);  /* move object to the "main" stack */
-  lua_setfield(L, -2, fname);  /* put object into table */
-}
-
-
-/*
-** Calls 'lua_getinfo' and collects all results in a new table.
-** L1 needs stack space for an optional input (function) plus
-** two optional outputs (function and line table) from function
-** 'lua_getinfo'.
-*/
-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, "flnStu");
-  checkstack(L, L1, 3);
-  if (lua_isfunction(L, arg + 1)) {  /* info about a function? */
-    options = lua_pushfstring(L, ">%s", options);  /* add '>' to 'options' */
-    lua_pushvalue(L, arg + 1);  /* move function to 'L1' stack */
-    lua_xmove(L, L1, 1);
-  }
-  else {  /* stack level */
-    if (!lua_getstack(L1, (int)luaL_checkinteger(L, arg + 1), &ar)) {
-      lua_pushnil(L);  /* level out of range */
-      return 1;
-    }
-  }
-  if (!lua_getinfo(L1, options, &ar))
-    return luaL_argerror(L, arg+2, "invalid option");
-  lua_newtable(L);  /* table to collect results */
-  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);
-    settabsi(L, "nparams", ar.nparams);
-    settabsb(L, "isvararg", ar.isvararg);
-  }
-  if (strchr(options, 'n')) {
-    settabss(L, "name", ar.name);
-    settabss(L, "namewhat", ar.namewhat);
-  }
-  if (strchr(options, 't'))
-    settabsb(L, "istailcall", ar.istailcall);
-  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;
-  int nvar = (int)luaL_checkinteger(L, arg + 2);  /* local-variable index */
-  if (lua_isfunction(L, arg + 1)) {  /* function argument? */
-    lua_pushvalue(L, arg + 1);  /* push function */
-    lua_pushstring(L, lua_getlocal(L, NULL, nvar));  /* push local name */
-    return 1;  /* return only name (there is no value) */
-  }
-  else {  /* stack-level argument */
-    int level = (int)luaL_checkinteger(L, arg + 1);
-    if (!lua_getstack(L1, level, &ar))  /* out of range? */
-      return luaL_argerror(L, arg+1, "level out of range");
-    checkstack(L, L1, 1);
-    name = lua_getlocal(L1, &ar, nvar);
-    if (name) {
-      lua_xmove(L1, L, 1);  /* move local value */
-      lua_pushstring(L, name);  /* push name */
-      lua_rotate(L, -2, 1);  /* re-order */
-      return 2;
-    }
-    else {
-      lua_pushnil(L);  /* no name (nor value) */
-      return 1;
-    }
-  }
-}
-
-
-static int db_setlocal (lua_State *L) {
-  int arg;
-  const char *name;
-  lua_State *L1 = getthread(L, &arg);
-  lua_Debug ar;
-  int level = (int)luaL_checkinteger(L, arg + 1);
-  int nvar = (int)luaL_checkinteger(L, arg + 2);
-  if (!lua_getstack(L1, level, &ar))  /* out of range? */
-    return luaL_argerror(L, arg+1, "level out of range");
-  luaL_checkany(L, arg+3);
-  lua_settop(L, arg+3);
-  checkstack(L, L1, 1);
-  lua_xmove(L, L1, 1);
-  name = lua_setlocal(L1, &ar, nvar);
-  if (name == NULL)
-    lua_pop(L1, 1);  /* pop value (if not popped by 'lua_setlocal') */
-  lua_pushstring(L, name);
-  return 1;
-}
-
-
-/*
-** get (if 'get' is true) or set an upvalue from a closure
-*/
-static int auxupvalue (lua_State *L, int get) {
-  const char *name;
-  int n = (int)luaL_checkinteger(L, 2);  /* upvalue index */
-  luaL_checktype(L, 1, LUA_TFUNCTION);  /* closure */
-  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));  /* no-op if get is false */
-  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);
-}
-
-
-/*
-** Check whether a given upvalue from a given closure exists and
-** returns its index
-*/
-static int checkupval (lua_State *L, int argf, int argnup) {
-  int nup = (int)luaL_checkinteger(L, argnup);  /* upvalue index */
-  luaL_checktype(L, argf, LUA_TFUNCTION);  /* closure */
-  luaL_argcheck(L, (lua_getupvalue(L, argf, nup) != NULL), argnup,
-                   "invalid upvalue index");
-  return nup;
-}
-
-
-static int db_upvalueid (lua_State *L) {
-  int n = checkupval(L, 1, 2);
-  lua_pushlightuserdata(L, lua_upvalueid(L, 1, n));
-  return 1;
-}
-
-
-static int db_upvaluejoin (lua_State *L) {
-  int n1 = checkupval(L, 1, 2);
-  int n2 = checkupval(L, 3, 4);
-  luaL_argcheck(L, !lua_iscfunction(L, 1), 1, "Lua function expected");
-  luaL_argcheck(L, !lua_iscfunction(L, 3), 3, "Lua function expected");
-  lua_upvaluejoin(L, 1, n1, 3, n2);
-  return 0;
-}
-
-
-/*
-** Call hook function registered at hook table for the current
-** thread (if there is one)
-*/
-static void hookf (lua_State *L, lua_Debug *ar) {
-  static const char *const hooknames[] =
-    {"call", "return", "line", "count", "tail call"};
-  lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY);
-  lua_pushthread(L);
-  if (lua_rawget(L, -2) == LUA_TFUNCTION) {  /* is there a hook function? */
-    lua_pushstring(L, hooknames[(int)ar->event]);  /* push event name */
-    if (ar->currentline >= 0)
-      lua_pushinteger(L, ar->currentline);  /* push current line */
-    else lua_pushnil(L);
-    lua_assert(lua_getinfo(L, "lS", ar));
-    lua_call(L, 2, 0);  /* call hook function */
-  }
-}
-
-
-/*
-** Convert a string mask (for 'sethook') into a bit mask
-*/
-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;
-}
-
-
-/*
-** Convert a bit mask (for 'gethook') into a string 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 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)) {  /* no hook? */
-    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 = (int)luaL_optinteger(L, arg + 3, 0);
-    func = hookf; mask = makemask(smask, count);
-  }
-  if (lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY) == LUA_TNIL) {
-    lua_createtable(L, 0, 2);  /* create a hook table */
-    lua_pushvalue(L, -1);
-    lua_rawsetp(L, LUA_REGISTRYINDEX, &HOOKKEY);  /* set it in position */
-    lua_pushstring(L, "k");
-    lua_setfield(L, -2, "__mode");  /** hooktable.__mode = "k" */
-    lua_pushvalue(L, -1);
-    lua_setmetatable(L, -2);  /* setmetatable(hooktable) = hooktable */
-  }
-  checkstack(L, L1, 1);
-  lua_pushthread(L1); lua_xmove(L1, L, 1);  /* key (thread) */
-  lua_pushvalue(L, arg + 1);  /* value (hook function) */
-  lua_rawset(L, -3);  /* hooktable[L1] = new Lua hook */
-  lua_sethook(L1, func, mask, count);
-  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)  /* no hook? */
-    lua_pushnil(L);
-  else if (hook != hookf)  /* external hook? */
-    lua_pushliteral(L, "external hook");
-  else {  /* hook table must exist */
-    lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY);
-    checkstack(L, L1, 1);
-    lua_pushthread(L1); lua_xmove(L1, L, 1);
-    lua_rawget(L, -2);   /* 1st result = hooktable[L1] */
-    lua_remove(L, -2);  /* remove hook table */
-  }
-  lua_pushstring(L, unmakemask(mask, buff));  /* 2nd result = mask */
-  lua_pushinteger(L, lua_gethookcount(L1));  /* 3rd result = count */
-  return 3;
-}
-
-
-static int db_debug (lua_State *L) {
-  for (;;) {
-    char buffer[250];
-    lua_writestringerror("%s", "lua_debug> ");
-    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))
-      lua_writestringerror("%s\n", lua_tostring(L, -1));
-    lua_settop(L, 0);  /* remove eventual returns */
-  }
-}
-
-
-static int db_traceback (lua_State *L) {
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  const char *msg = lua_tostring(L, arg + 1);
-  if (msg == NULL && !lua_isnoneornil(L, arg + 1))  /* non-string 'msg'? */
-    lua_pushvalue(L, arg + 1);  /* return it untouched */
-  else {
-    int level = (int)luaL_optinteger(L, arg + 2, (L == L1) ? 1 : 0);
-    luaL_traceback(L, L1, msg, level);
-  }
-  return 1;
-}
-
-
-static const luaL_Reg dblib[] = {
-  {"debug", db_debug},
-  {"getuservalue", db_getuservalue},
-  {"gethook", db_gethook},
-  {"getinfo", db_getinfo},
-  {"getlocal", db_getlocal},
-  {"getregistry", db_getregistry},
-  {"getmetatable", db_getmetatable},
-  {"getupvalue", db_getupvalue},
-  {"upvaluejoin", db_upvaluejoin},
-  {"upvalueid", db_upvalueid},
-  {"setuservalue", db_setuservalue},
-  {"sethook", db_sethook},
-  {"setlocal", db_setlocal},
-  {"setmetatable", db_setmetatable},
-  {"setupvalue", db_setupvalue},
-  {"traceback", db_traceback},
-  {NULL, NULL}
-};
-
-
-LUAMOD_API int luaopen_debug (lua_State *L) {
-  luaL_newlib(L, dblib);
-  return 1;
-}
-
diff --git a/lua/lua-5.3.5/src/ldebug.c b/lua/lua-5.3.5/src/ldebug.c
deleted file mode 100644
index e138929..0000000
--- a/lua/lua-5.3.5/src/ldebug.c
+++ /dev/null
@@ -1,699 +0,0 @@
-/*
-** $Id: ldebug.c,v 2.121.1.2 2017/07/10 17:21:50 roberto Exp $
-** Debug Interface
-** See Copyright Notice in lua.h
-*/
-
-#define ldebug_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <stdarg.h>
-#include <stddef.h>
-#include <string.h>
-
-#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"
-
-
-
-#define noLuaClosure(f)		((f) == NULL || (f)->c.tt == LUA_TCCL)
-
-
-/* Active Lua function (given call info) */
-#define ci_func(ci)		(clLvalue((ci)->func))
-
-
-static const char *funcnamefromcode (lua_State *L, CallInfo *ci,
-                                    const char **name);
-
-
-static int currentpc (CallInfo *ci) {
-  lua_assert(isLua(ci));
-  return pcRel(ci->u.l.savedpc, ci_func(ci)->p);
-}
-
-
-static int currentline (CallInfo *ci) {
-  return getfuncline(ci_func(ci)->p, currentpc(ci));
-}
-
-
-/*
-** If function yielded, its 'func' can be in the 'extra' field. The
-** next function restores 'func' to its correct value for debugging
-** purposes. (It exchanges 'func' and 'extra'; so, when called again,
-** after debugging, it also "re-restores" ** 'func' to its altered value.
-*/
-static void swapextra (lua_State *L) {
-  if (L->status == LUA_YIELD) {
-    CallInfo *ci = L->ci;  /* get function that yielded */
-    StkId temp = ci->func;  /* exchange its 'func' and 'extra' values */
-    ci->func = restorestack(L, ci->extra);
-    ci->extra = savestack(L, temp);
-  }
-}
-
-
-/*
-** This function can be called asynchronously (e.g. during a signal).
-** Fields 'oldpc', 'basehookcount', and 'hookcount' (set by
-** 'resethookcount') are for debug only, and it is no problem if they
-** get arbitrary values (causes at most one wrong hook call). 'hookmask'
-** is an atomic value. We assume that pointers are atomic too (e.g., gcc
-** ensures that for all platforms where it runs). Moreover, 'hook' is
-** always checked before being called (see 'luaD_hook').
-*/
-LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
-  if (func == NULL || mask == 0) {  /* turn off hooks? */
-    mask = 0;
-    func = NULL;
-  }
-  if (isLua(L->ci))
-    L->oldpc = L->ci->u.l.savedpc;
-  L->hook = func;
-  L->basehookcount = count;
-  resethookcount(L);
-  L->hookmask = cast_byte(mask);
-}
-
-
-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;
-  if (level < 0) return 0;  /* invalid (negative) level */
-  lua_lock(L);
-  for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous)
-    level--;
-  if (level == 0 && ci != &L->base_ci) {  /* level found? */
-    status = 1;
-    ar->i_ci = ci;
-  }
-  else status = 0;  /* no such level */
-  lua_unlock(L);
-  return status;
-}
-
-
-static const char *upvalname (Proto *p, int uv) {
-  TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name);
-  if (s == NULL) return "?";
-  else return getstr(s);
-}
-
-
-static const char *findvararg (CallInfo *ci, int n, StkId *pos) {
-  int nparams = clLvalue(ci->func)->p->numparams;
-  if (n >= cast_int(ci->u.l.base - ci->func) - nparams)
-    return NULL;  /* no such vararg */
-  else {
-    *pos = ci->func + nparams + n;
-    return "(*vararg)";  /* generic name for any vararg */
-  }
-}
-
-
-static const char *findlocal (lua_State *L, CallInfo *ci, int n,
-                              StkId *pos) {
-  const char *name = NULL;
-  StkId base;
-  if (isLua(ci)) {
-    if (n < 0)  /* access to vararg values? */
-      return findvararg(ci, -n, pos);
-    else {
-      base = ci->u.l.base;
-      name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci));
-    }
-  }
-  else
-    base = ci->func + 1;
-  if (name == NULL) {  /* no 'standard' name? */
-    StkId limit = (ci == L->ci) ? L->top : ci->next->func;
-    if (limit - base >= n && n > 0)  /* is 'n' inside 'ci' stack? */
-      name = "(*temporary)";  /* generic name for any valid slot */
-    else
-      return NULL;  /* no name */
-  }
-  *pos = base + (n - 1);
-  return name;
-}
-
-
-LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
-  const char *name;
-  lua_lock(L);
-  swapextra(L);
-  if (ar == NULL) {  /* information about non-active function? */
-    if (!isLfunction(L->top - 1))  /* not a Lua function? */
-      name = NULL;
-    else  /* consider live variables at function start (parameters) */
-      name = luaF_getlocalname(clLvalue(L->top - 1)->p, n, 0);
-  }
-  else {  /* active function; get information through 'ar' */
-    StkId pos = NULL;  /* to avoid warnings */
-    name = findlocal(L, ar->i_ci, n, &pos);
-    if (name) {
-      setobj2s(L, L->top, pos);
-      api_incr_top(L);
-    }
-  }
-  swapextra(L);
-  lua_unlock(L);
-  return name;
-}
-
-
-LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
-  StkId pos = NULL;  /* to avoid warnings */
-  const char *name;
-  lua_lock(L);
-  swapextra(L);
-  name = findlocal(L, ar->i_ci, n, &pos);
-  if (name) {
-    setobjs2s(L, pos, L->top - 1);
-    L->top--;  /* pop value */
-  }
-  swapextra(L);
-  lua_unlock(L);
-  return name;
-}
-
-
-static void funcinfo (lua_Debug *ar, Closure *cl) {
-  if (noLuaClosure(cl)) {
-    ar->source = "=[C]";
-    ar->linedefined = -1;
-    ar->lastlinedefined = -1;
-    ar->what = "C";
-  }
-  else {
-    Proto *p = cl->l.p;
-    ar->source = p->source ? getstr(p->source) : "=?";
-    ar->linedefined = p->linedefined;
-    ar->lastlinedefined = p->lastlinedefined;
-    ar->what = (ar->linedefined == 0) ? "main" : "Lua";
-  }
-  luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
-}
-
-
-static void collectvalidlines (lua_State *L, Closure *f) {
-  if (noLuaClosure(f)) {
-    setnilvalue(L->top);
-    api_incr_top(L);
-  }
-  else {
-    int i;
-    TValue v;
-    int *lineinfo = f->l.p->lineinfo;
-    Table *t = luaH_new(L);  /* new table to store active lines */
-    sethvalue(L, L->top, t);  /* push it on stack */
-    api_incr_top(L);
-    setbvalue(&v, 1);  /* boolean 'true' to be the value of all indices */
-    for (i = 0; i < f->l.p->sizelineinfo; i++)  /* for all lines with code */
-      luaH_setint(L, t, lineinfo[i], &v);  /* table[line] = true */
-  }
-}
-
-
-static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
-  if (ci == NULL)  /* no 'ci'? */
-    return NULL;  /* no info */
-  else if (ci->callstatus & CIST_FIN) {  /* is this a finalizer? */
-    *name = "__gc";
-    return "metamethod";  /* report it as such */
-  }
-  /* calling function is a known Lua function? */
-  else if (!(ci->callstatus & CIST_TAIL) && isLua(ci->previous))
-    return funcnamefromcode(L, ci->previous, name);
-  else return NULL;  /* no way to find a name */
-}
-
-
-static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
-                       Closure *f, CallInfo *ci) {
-  int status = 1;
-  for (; *what; what++) {
-    switch (*what) {
-      case 'S': {
-        funcinfo(ar, f);
-        break;
-      }
-      case 'l': {
-        ar->currentline = (ci && isLua(ci)) ? currentline(ci) : -1;
-        break;
-      }
-      case 'u': {
-        ar->nups = (f == NULL) ? 0 : f->c.nupvalues;
-        if (noLuaClosure(f)) {
-          ar->isvararg = 1;
-          ar->nparams = 0;
-        }
-        else {
-          ar->isvararg = f->l.p->is_vararg;
-          ar->nparams = f->l.p->numparams;
-        }
-        break;
-      }
-      case 't': {
-        ar->istailcall = (ci) ? ci->callstatus & CIST_TAIL : 0;
-        break;
-      }
-      case 'n': {
-        ar->namewhat = getfuncname(L, ci, &ar->name);
-        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 *cl;
-  CallInfo *ci;
-  StkId func;
-  lua_lock(L);
-  swapextra(L);
-  if (*what == '>') {
-    ci = NULL;
-    func = L->top - 1;
-    api_check(L, ttisfunction(func), "function expected");
-    what++;  /* skip the '>' */
-    L->top--;  /* pop function */
-  }
-  else {
-    ci = ar->i_ci;
-    func = ci->func;
-    lua_assert(ttisfunction(ci->func));
-  }
-  cl = ttisclosure(func) ? clvalue(func) : NULL;
-  status = auxgetinfo(L, what, ar, cl, ci);
-  if (strchr(what, 'f')) {
-    setobjs2s(L, L->top, func);
-    api_incr_top(L);
-  }
-  swapextra(L);  /* correct before option 'L', which can raise a mem. error */
-  if (strchr(what, 'L'))
-    collectvalidlines(L, cl);
-  lua_unlock(L);
-  return status;
-}
-
-
-/*
-** {======================================================
-** Symbolic Execution
-** =======================================================
-*/
-
-static const char *getobjname (Proto *p, int lastpc, int reg,
-                               const char **name);
-
-
-/*
-** find a "name" for the RK value 'c'
-*/
-static void kname (Proto *p, int pc, int c, const char **name) {
-  if (ISK(c)) {  /* is 'c' a constant? */
-    TValue *kvalue = &p->k[INDEXK(c)];
-    if (ttisstring(kvalue)) {  /* literal constant? */
-      *name = svalue(kvalue);  /* it is its own name */
-      return;
-    }
-    /* else no reasonable name found */
-  }
-  else {  /* 'c' is a register */
-    const char *what = getobjname(p, pc, c, name); /* search for 'c' */
-    if (what && *what == 'c') {  /* found a constant name? */
-      return;  /* 'name' already filled */
-    }
-    /* else no reasonable name found */
-  }
-  *name = "?";  /* no reasonable name found */
-}
-
-
-static int filterpc (int pc, int jmptarget) {
-  if (pc < jmptarget)  /* is code conditional (inside a jump)? */
-    return -1;  /* cannot know who sets that register */
-  else return pc;  /* current position sets that register */
-}
-
-
-/*
-** try to find last instruction before 'lastpc' that modified register 'reg'
-*/
-static int findsetreg (Proto *p, int lastpc, int reg) {
-  int pc;
-  int setreg = -1;  /* keep last instruction that changed 'reg' */
-  int jmptarget = 0;  /* any code before this address is conditional */
-  for (pc = 0; pc < lastpc; pc++) {
-    Instruction i = p->code[pc];
-    OpCode op = GET_OPCODE(i);
-    int a = GETARG_A(i);
-    switch (op) {
-      case OP_LOADNIL: {
-        int b = GETARG_B(i);
-        if (a <= reg && reg <= a + b)  /* set registers from 'a' to 'a+b' */
-          setreg = filterpc(pc, jmptarget);
-        break;
-      }
-      case OP_TFORCALL: {
-        if (reg >= a + 2)  /* affect all regs above its base */
-          setreg = filterpc(pc, jmptarget);
-        break;
-      }
-      case OP_CALL:
-      case OP_TAILCALL: {
-        if (reg >= a)  /* affect all registers above base */
-          setreg = filterpc(pc, jmptarget);
-        break;
-      }
-      case OP_JMP: {
-        int b = GETARG_sBx(i);
-        int dest = pc + 1 + b;
-        /* jump is forward and do not skip 'lastpc'? */
-        if (pc < dest && dest <= lastpc) {
-          if (dest > jmptarget)
-            jmptarget = dest;  /* update 'jmptarget' */
-        }
-        break;
-      }
-      default:
-        if (testAMode(op) && reg == a)  /* any instruction that set A */
-          setreg = filterpc(pc, jmptarget);
-        break;
-    }
-  }
-  return setreg;
-}
-
-
-static const char *getobjname (Proto *p, int lastpc, int reg,
-                               const char **name) {
-  int pc;
-  *name = luaF_getlocalname(p, reg + 1, lastpc);
-  if (*name)  /* is a local? */
-    return "local";
-  /* else try symbolic execution */
-  pc = findsetreg(p, lastpc, reg);
-  if (pc != -1) {  /* could find instruction? */
-    Instruction i = p->code[pc];
-    OpCode op = GET_OPCODE(i);
-    switch (op) {
-      case OP_MOVE: {
-        int b = GETARG_B(i);  /* move from 'b' to 'a' */
-        if (b < GETARG_A(i))
-          return getobjname(p, pc, b, name);  /* get name for 'b' */
-        break;
-      }
-      case OP_GETTABUP:
-      case OP_GETTABLE: {
-        int k = GETARG_C(i);  /* key index */
-        int t = GETARG_B(i);  /* table index */
-        const char *vn = (op == OP_GETTABLE)  /* name of indexed variable */
-                         ? luaF_getlocalname(p, t + 1, pc)
-                         : upvalname(p, t);
-        kname(p, pc, k, name);
-        return (vn && strcmp(vn, LUA_ENV) == 0) ? "global" : "field";
-      }
-      case OP_GETUPVAL: {
-        *name = upvalname(p, GETARG_B(i));
-        return "upvalue";
-      }
-      case OP_LOADK:
-      case OP_LOADKX: {
-        int b = (op == OP_LOADK) ? GETARG_Bx(i)
-                                 : GETARG_Ax(p->code[pc + 1]);
-        if (ttisstring(&p->k[b])) {
-          *name = svalue(&p->k[b]);
-          return "constant";
-        }
-        break;
-      }
-      case OP_SELF: {
-        int k = GETARG_C(i);  /* key index */
-        kname(p, pc, k, name);
-        return "method";
-      }
-      default: break;  /* go through to return NULL */
-    }
-  }
-  return NULL;  /* could not find reasonable name */
-}
-
-
-/*
-** Try to find a name for a function based on the code that called it.
-** (Only works when function was called by a Lua function.)
-** Returns what the name is (e.g., "for iterator", "method",
-** "metamethod") and sets '*name' to point to the name.
-*/
-static const char *funcnamefromcode (lua_State *L, CallInfo *ci,
-                                     const char **name) {
-  TMS tm = (TMS)0;  /* (initial value avoids warnings) */
-  Proto *p = ci_func(ci)->p;  /* calling function */
-  int pc = currentpc(ci);  /* calling instruction index */
-  Instruction i = p->code[pc];  /* calling instruction */
-  if (ci->callstatus & CIST_HOOKED) {  /* was it called inside a hook? */
-    *name = "?";
-    return "hook";
-  }
-  switch (GET_OPCODE(i)) {
-    case OP_CALL:
-    case OP_TAILCALL:
-      return getobjname(p, pc, GETARG_A(i), name);  /* get function name */
-    case OP_TFORCALL: {  /* for iterator */
-      *name = "for iterator";
-       return "for iterator";
-    }
-    /* other instructions can do calls through metamethods */
-    case OP_SELF: case OP_GETTABUP: case OP_GETTABLE:
-      tm = TM_INDEX;
-      break;
-    case OP_SETTABUP: case OP_SETTABLE:
-      tm = TM_NEWINDEX;
-      break;
-    case OP_ADD: case OP_SUB: case OP_MUL: case OP_MOD:
-    case OP_POW: case OP_DIV: case OP_IDIV: case OP_BAND:
-    case OP_BOR: case OP_BXOR: case OP_SHL: case OP_SHR: {
-      int offset = cast_int(GET_OPCODE(i)) - cast_int(OP_ADD);  /* ORDER OP */
-      tm = cast(TMS, offset + cast_int(TM_ADD));  /* ORDER TM */
-      break;
-    }
-    case OP_UNM: tm = TM_UNM; break;
-    case OP_BNOT: tm = TM_BNOT; break;
-    case OP_LEN: tm = TM_LEN; break;
-    case OP_CONCAT: tm = TM_CONCAT; break;
-    case OP_EQ: tm = TM_EQ; break;
-    case OP_LT: tm = TM_LT; break;
-    case OP_LE: tm = TM_LE; break;
-    default:
-      return NULL;  /* cannot find a reasonable name */
-  }
-  *name = getstr(G(L)->tmname[tm]);
-  return "metamethod";
-}
-
-/* }====================================================== */
-
-
-
-/*
-** The subtraction of two potentially unrelated pointers is
-** not ISO C, but it should not crash a program; the subsequent
-** checks are ISO C and ensure a correct result.
-*/
-static int isinstack (CallInfo *ci, const TValue *o) {
-  ptrdiff_t i = o - ci->u.l.base;
-  return (0 <= i && i < (ci->top - ci->u.l.base) && ci->u.l.base + i == o);
-}
-
-
-/*
-** Checks whether value 'o' came from an upvalue. (That can only happen
-** with instructions OP_GETTABUP/OP_SETTABUP, which operate directly on
-** upvalues.)
-*/
-static const char *getupvalname (CallInfo *ci, const TValue *o,
-                                 const char **name) {
-  LClosure *c = ci_func(ci);
-  int i;
-  for (i = 0; i < c->nupvalues; i++) {
-    if (c->upvals[i]->v == o) {
-      *name = upvalname(c->p, i);
-      return "upvalue";
-    }
-  }
-  return NULL;
-}
-
-
-static const char *varinfo (lua_State *L, const TValue *o) {
-  const char *name = NULL;  /* to avoid warnings */
-  CallInfo *ci = L->ci;
-  const char *kind = NULL;
-  if (isLua(ci)) {
-    kind = getupvalname(ci, o, &name);  /* check whether 'o' is an upvalue */
-    if (!kind && isinstack(ci, o))  /* no? try a register */
-      kind = getobjname(ci_func(ci)->p, currentpc(ci),
-                        cast_int(o - ci->u.l.base), &name);
-  }
-  return (kind) ? luaO_pushfstring(L, " (%s '%s')", kind, name) : "";
-}
-
-
-l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
-  const char *t = luaT_objtypename(L, o);
-  luaG_runerror(L, "attempt to %s a %s value%s", op, t, varinfo(L, o));
-}
-
-
-l_noret luaG_concaterror (lua_State *L, const TValue *p1, const TValue *p2) {
-  if (ttisstring(p1) || cvt2str(p1)) p1 = p2;
-  luaG_typeerror(L, p1, "concatenate");
-}
-
-
-l_noret luaG_opinterror (lua_State *L, const TValue *p1,
-                         const TValue *p2, const char *msg) {
-  lua_Number temp;
-  if (!tonumber(p1, &temp))  /* first operand is wrong? */
-    p2 = p1;  /* now second is wrong */
-  luaG_typeerror(L, p2, msg);
-}
-
-
-/*
-** Error when both values are convertible to numbers, but not to integers
-*/
-l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) {
-  lua_Integer temp;
-  if (!tointeger(p1, &temp))
-    p2 = p1;
-  luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2));
-}
-
-
-l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
-  const char *t1 = luaT_objtypename(L, p1);
-  const char *t2 = luaT_objtypename(L, p2);
-  if (strcmp(t1, t2) == 0)
-    luaG_runerror(L, "attempt to compare two %s values", t1);
-  else
-    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
-}
-
-
-/* add src:line information to 'msg' */
-const char *luaG_addinfo (lua_State *L, const char *msg, TString *src,
-                                        int line) {
-  char buff[LUA_IDSIZE];
-  if (src)
-    luaO_chunkid(buff, getstr(src), LUA_IDSIZE);
-  else {  /* no source available; use "?" instead */
-    buff[0] = '?'; buff[1] = '\0';
-  }
-  return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
-}
-
-
-l_noret luaG_errormsg (lua_State *L) {
-  if (L->errfunc != 0) {  /* is there an error handling function? */
-    StkId errfunc = restorestack(L, L->errfunc);
-    setobjs2s(L, L->top, L->top - 1);  /* move argument */
-    setobjs2s(L, L->top - 1, errfunc);  /* push function */
-    L->top++;  /* assume EXTRA_STACK */
-    luaD_callnoyield(L, L->top - 2, 1);  /* call it */
-  }
-  luaD_throw(L, LUA_ERRRUN);
-}
-
-
-l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
-  CallInfo *ci = L->ci;
-  const char *msg;
-  va_list argp;
-  luaC_checkGC(L);  /* error message uses memory */
-  va_start(argp, fmt);
-  msg = luaO_pushvfstring(L, fmt, argp);  /* format message */
-  va_end(argp);
-  if (isLua(ci))  /* if Lua function, add source:line information */
-    luaG_addinfo(L, msg, ci_func(ci)->p->source, currentline(ci));
-  luaG_errormsg(L);
-}
-
-
-void luaG_traceexec (lua_State *L) {
-  CallInfo *ci = L->ci;
-  lu_byte mask = L->hookmask;
-  int counthook = (--L->hookcount == 0 && (mask & LUA_MASKCOUNT));
-  if (counthook)
-    resethookcount(L);  /* reset count */
-  else if (!(mask & LUA_MASKLINE))
-    return;  /* no line hook and count != 0; nothing to be done */
-  if (ci->callstatus & CIST_HOOKYIELD) {  /* called hook last time? */
-    ci->callstatus &= ~CIST_HOOKYIELD;  /* erase mark */
-    return;  /* do not call hook again (VM yielded, so it did not move) */
-  }
-  if (counthook)
-    luaD_hook(L, LUA_HOOKCOUNT, -1);  /* call count hook */
-  if (mask & LUA_MASKLINE) {
-    Proto *p = ci_func(ci)->p;
-    int npc = pcRel(ci->u.l.savedpc, p);
-    int newline = getfuncline(p, npc);
-    if (npc == 0 ||  /* call linehook when enter a new function, */
-        ci->u.l.savedpc <= L->oldpc ||  /* when jump back (loop), or when */
-        newline != getfuncline(p, pcRel(L->oldpc, p)))  /* enter a new line */
-      luaD_hook(L, LUA_HOOKLINE, newline);  /* call line hook */
-  }
-  L->oldpc = ci->u.l.savedpc;
-  if (L->status == LUA_YIELD) {  /* did hook yield? */
-    if (counthook)
-      L->hookcount = 1;  /* undo decrement to zero */
-    ci->u.l.savedpc--;  /* undo increment (resume will increment it again) */
-    ci->callstatus |= CIST_HOOKYIELD;  /* mark that it yielded */
-    ci->func = L->top - 1;  /* protect stack below results */
-    luaD_throw(L, LUA_YIELD);
-  }
-}
-
diff --git a/lua/lua-5.3.5/src/ldebug.h b/lua/lua-5.3.5/src/ldebug.h
deleted file mode 100644
index 8cea0ee..0000000
--- a/lua/lua-5.3.5/src/ldebug.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
-** $Id: ldebug.h,v 2.14.1.1 2017/04/19 17:20:42 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 getfuncline(f,pc)	(((f)->lineinfo) ? (f)->lineinfo[pc] : -1)
-
-#define resethookcount(L)	(L->hookcount = L->basehookcount)
-
-
-LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o,
-                                                const char *opname);
-LUAI_FUNC l_noret luaG_concaterror (lua_State *L, const TValue *p1,
-                                                  const TValue *p2);
-LUAI_FUNC l_noret luaG_opinterror (lua_State *L, const TValue *p1,
-                                                 const TValue *p2,
-                                                 const char *msg);
-LUAI_FUNC l_noret luaG_tointerror (lua_State *L, const TValue *p1,
-                                                 const TValue *p2);
-LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1,
-                                                 const TValue *p2);
-LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...);
-LUAI_FUNC const char *luaG_addinfo (lua_State *L, const char *msg,
-                                                  TString *src, int line);
-LUAI_FUNC l_noret luaG_errormsg (lua_State *L);
-LUAI_FUNC void luaG_traceexec (lua_State *L);
-
-
-#endif
diff --git a/lua/lua-5.3.5/src/ldo.c b/lua/lua-5.3.5/src/ldo.c
deleted file mode 100644
index 316e45c..0000000
--- a/lua/lua-5.3.5/src/ldo.c
+++ /dev/null
@@ -1,802 +0,0 @@
-/*
-** $Id: ldo.c,v 2.157.1.1 2017/04/19 17:20:42 roberto Exp $
-** Stack and Call structure of Lua
-** See Copyright Notice in lua.h
-*/
-
-#define ldo_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <setjmp.h>
-#include <stdlib.h>
-#include <string.h>
-
-#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 "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"
-
-
-
-#define errorstatus(s)	((s) > LUA_YIELD)
-
-
-/*
-** {======================================================
-** Error-recovery functions
-** =======================================================
-*/
-
-/*
-** LUAI_THROW/LUAI_TRY define how Lua does exception handling. 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(LUAI_THROW)				/* { */
-
-#if defined(__cplusplus) && !defined(LUA_USE_LONGJMP)	/* { */
-
-/* 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_POSIX)				/* }{ */
-
-/* in POSIX, 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							/* }{ */
-
-/* ISO C 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							/* } */
-
-#endif							/* } */
-
-
-
-/* chain list of long jump buffers */
-struct lua_longjmp {
-  struct lua_longjmp *previous;
-  luai_jmpbuf b;
-  volatile int status;  /* error code */
-};
-
-
-static void seterrorobj (lua_State *L, int errcode, StkId oldtop) {
-  switch (errcode) {
-    case LUA_ERRMEM: {  /* memory error? */
-      setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */
-      break;
-    }
-    case LUA_ERRERR: {
-      setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
-      break;
-    }
-    default: {
-      setobjs2s(L, oldtop, L->top - 1);  /* error message on current top */
-      break;
-    }
-  }
-  L->top = oldtop + 1;
-}
-
-
-l_noret luaD_throw (lua_State *L, int errcode) {
-  if (L->errorJmp) {  /* thread has an error handler? */
-    L->errorJmp->status = errcode;  /* set status */
-    LUAI_THROW(L, L->errorJmp);  /* jump to it */
-  }
-  else {  /* thread has no error handler */
-    global_State *g = G(L);
-    L->status = cast_byte(errcode);  /* mark it as dead */
-    if (g->mainthread->errorJmp) {  /* main thread has a handler? */
-      setobjs2s(L, g->mainthread->top++, L->top - 1);  /* copy error obj. */
-      luaD_throw(g->mainthread, errcode);  /* re-throw in main thread */
-    }
-    else {  /* no handler at all; abort */
-      if (g->panic) {  /* panic function? */
-        seterrorobj(L, errcode, L->top);  /* assume EXTRA_STACK */
-        if (L->ci->top < L->top)
-          L->ci->top = L->top;  /* pushing msg. can break this invariant */
-        lua_unlock(L);
-        g->panic(L);  /* call panic function (last chance to jump out) */
-      }
-      abort();
-    }
-  }
-}
-
-
-int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
-  unsigned short oldnCcalls = L->nCcalls;
-  struct lua_longjmp lj;
-  lj.status = LUA_OK;
-  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 */
-  L->nCcalls = oldnCcalls;
-  return lj.status;
-}
-
-/* }====================================================== */
-
-
-/*
-** {==================================================================
-** Stack reallocation
-** ===================================================================
-*/
-static void correctstack (lua_State *L, TValue *oldstack) {
-  CallInfo *ci;
-  UpVal *up;
-  L->top = (L->top - oldstack) + L->stack;
-  for (up = L->openupval; up != NULL; up = up->u.open.next)
-    up->v = (up->v - oldstack) + L->stack;
-  for (ci = L->ci; ci != NULL; ci = ci->previous) {
-    ci->top = (ci->top - oldstack) + L->stack;
-    ci->func = (ci->func - oldstack) + L->stack;
-    if (isLua(ci))
-      ci->u.l.base = (ci->u.l.base - oldstack) + L->stack;
-  }
-}
-
-
-/* some space for error handling */
-#define ERRORSTACKSIZE	(LUAI_MAXSTACK + 200)
-
-
-void luaD_reallocstack (lua_State *L, int newsize) {
-  TValue *oldstack = L->stack;
-  int lim = L->stacksize;
-  lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE);
-  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK);
-  luaM_reallocvector(L, L->stack, L->stacksize, newsize, TValue);
-  for (; lim < newsize; lim++)
-    setnilvalue(L->stack + lim); /* erase new segment */
-  L->stacksize = newsize;
-  L->stack_last = L->stack + newsize - EXTRA_STACK;
-  correctstack(L, oldstack);
-}
-
-
-void luaD_growstack (lua_State *L, int n) {
-  int size = L->stacksize;
-  if (size > LUAI_MAXSTACK)  /* error after extra size? */
-    luaD_throw(L, LUA_ERRERR);
-  else {
-    int needed = cast_int(L->top - L->stack) + n + EXTRA_STACK;
-    int newsize = 2 * size;
-    if (newsize > LUAI_MAXSTACK) newsize = LUAI_MAXSTACK;
-    if (newsize < needed) newsize = needed;
-    if (newsize > LUAI_MAXSTACK) {  /* stack overflow? */
-      luaD_reallocstack(L, ERRORSTACKSIZE);
-      luaG_runerror(L, "stack overflow");
-    }
-    else
-      luaD_reallocstack(L, newsize);
-  }
-}
-
-
-static int stackinuse (lua_State *L) {
-  CallInfo *ci;
-  StkId lim = L->top;
-  for (ci = L->ci; ci != NULL; ci = ci->previous) {
-    if (lim < ci->top) lim = ci->top;
-  }
-  lua_assert(lim <= L->stack_last);
-  return cast_int(lim - L->stack) + 1;  /* part of stack in use */
-}
-
-
-void luaD_shrinkstack (lua_State *L) {
-  int inuse = stackinuse(L);
-  int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK;
-  if (goodsize > LUAI_MAXSTACK)
-    goodsize = LUAI_MAXSTACK;  /* respect stack limit */
-  if (L->stacksize > LUAI_MAXSTACK)  /* had been handling stack overflow? */
-    luaE_freeCI(L);  /* free all CIs (list grew because of an error) */
-  else
-    luaE_shrinkCI(L);  /* shrink list */
-  /* if thread is currently not handling a stack overflow and its
-     good size is smaller than current size, shrink its stack */
-  if (inuse <= (LUAI_MAXSTACK - EXTRA_STACK) &&
-      goodsize < L->stacksize)
-    luaD_reallocstack(L, goodsize);
-  else  /* don't change stack */
-    condmovestack(L,{},{});  /* (change only for debugging) */
-}
-
-
-void luaD_inctop (lua_State *L) {
-  luaD_checkstack(L, 1);
-  L->top++;
-}
-
-/* }================================================================== */
-
-
-/*
-** Call a hook for the given event. Make sure there is a hook to be
-** called. (Both 'L->hook' and 'L->hookmask', which triggers this
-** function, can be changed asynchronously by signals.)
-*/
-void luaD_hook (lua_State *L, int event, int line) {
-  lua_Hook hook = L->hook;
-  if (hook && L->allowhook) {  /* make sure there is a hook */
-    CallInfo *ci = L->ci;
-    ptrdiff_t top = savestack(L, L->top);
-    ptrdiff_t ci_top = savestack(L, ci->top);
-    lua_Debug ar;
-    ar.event = event;
-    ar.currentline = line;
-    ar.i_ci = ci;
-    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
-    ci->top = L->top + LUA_MINSTACK;
-    lua_assert(ci->top <= L->stack_last);
-    L->allowhook = 0;  /* cannot call hooks inside a hook */
-    ci->callstatus |= CIST_HOOKED;
-    lua_unlock(L);
-    (*hook)(L, &ar);
-    lua_lock(L);
-    lua_assert(!L->allowhook);
-    L->allowhook = 1;
-    ci->top = restorestack(L, ci_top);
-    L->top = restorestack(L, top);
-    ci->callstatus &= ~CIST_HOOKED;
-  }
-}
-
-
-static void callhook (lua_State *L, CallInfo *ci) {
-  int hook = LUA_HOOKCALL;
-  ci->u.l.savedpc++;  /* hooks assume 'pc' is already incremented */
-  if (isLua(ci->previous) &&
-      GET_OPCODE(*(ci->previous->u.l.savedpc - 1)) == OP_TAILCALL) {
-    ci->callstatus |= CIST_TAIL;
-    hook = LUA_HOOKTAILCALL;
-  }
-  luaD_hook(L, hook, -1);
-  ci->u.l.savedpc--;  /* correct 'pc' */
-}
-
-
-static StkId adjust_varargs (lua_State *L, Proto *p, int actual) {
-  int i;
-  int nfixargs = p->numparams;
-  StkId base, fixed;
-  /* 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 < actual; i++) {
-    setobjs2s(L, L->top++, fixed + i);
-    setnilvalue(fixed + i);  /* erase original copy (for GC) */
-  }
-  for (; i < nfixargs; i++)
-    setnilvalue(L->top++);  /* complete missing arguments */
-  return base;
-}
-
-
-/*
-** Check whether __call metafield of 'func' is a function. If so, put
-** it in stack below original 'func' so that 'luaD_precall' can call
-** it. Raise an error if __call metafield is not a function.
-*/
-static void tryfuncTM (lua_State *L, StkId func) {
-  const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);
-  StkId p;
-  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);
-  L->top++;  /* slot ensured by caller */
-  setobj2s(L, func, tm);  /* tag method is the new function to be called */
-}
-
-
-/*
-** Given 'nres' results at 'firstResult', move 'wanted' of them to 'res'.
-** Handle most typical cases (zero results for commands, one result for
-** expressions, multiple results for tail calls/single parameters)
-** separated.
-*/
-static int moveresults (lua_State *L, const TValue *firstResult, StkId res,
-                                      int nres, int wanted) {
-  switch (wanted) {  /* handle typical cases separately */
-    case 0: break;  /* nothing to move */
-    case 1: {  /* one result needed */
-      if (nres == 0)   /* no results? */
-        firstResult = luaO_nilobject;  /* adjust with nil */
-      setobjs2s(L, res, firstResult);  /* move it to proper place */
-      break;
-    }
-    case LUA_MULTRET: {
-      int i;
-      for (i = 0; i < nres; i++)  /* move all results to correct place */
-        setobjs2s(L, res + i, firstResult + i);
-      L->top = res + nres;
-      return 0;  /* wanted == LUA_MULTRET */
-    }
-    default: {
-      int i;
-      if (wanted <= nres) {  /* enough results? */
-        for (i = 0; i < wanted; i++)  /* move wanted results to correct place */
-          setobjs2s(L, res + i, firstResult + i);
-      }
-      else {  /* not enough results; use all of them plus nils */
-        for (i = 0; i < nres; i++)  /* move all results to correct place */
-          setobjs2s(L, res + i, firstResult + i);
-        for (; i < wanted; i++)  /* complete wanted number of results */
-          setnilvalue(res + i);
-      }
-      break;
-    }
-  }
-  L->top = res + wanted;  /* top points after the last result */
-  return 1;
-}
-
-
-/*
-** Finishes a function call: calls hook if necessary, removes CallInfo,
-** moves current number of results to proper place; returns 0 iff call
-** wanted multiple (variable number of) results.
-*/
-int luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult, int nres) {
-  StkId res;
-  int wanted = ci->nresults;
-  if (L->hookmask & (LUA_MASKRET | LUA_MASKLINE)) {
-    if (L->hookmask & LUA_MASKRET) {
-      ptrdiff_t fr = savestack(L, firstResult);  /* hook may change stack */
-      luaD_hook(L, LUA_HOOKRET, -1);
-      firstResult = restorestack(L, fr);
-    }
-    L->oldpc = ci->previous->u.l.savedpc;  /* 'oldpc' for caller function */
-  }
-  res = ci->func;  /* res == final position of 1st result */
-  L->ci = ci->previous;  /* back to caller */
-  /* move results to proper place */
-  return moveresults(L, firstResult, res, nres, wanted);
-}
-
-
-
-#define next_ci(L) (L->ci = (L->ci->next ? L->ci->next : luaE_extendCI(L)))
-
-
-/* macro to check stack size, preserving 'p' */
-#define checkstackp(L,n,p)  \
-  luaD_checkstackaux(L, n, \
-    ptrdiff_t t__ = savestack(L, p);  /* save 'p' */ \
-    luaC_checkGC(L),  /* stack grow uses memory */ \
-    p = restorestack(L, t__))  /* 'pos' part: restore 'p' */
-
-
-/*
-** Prepares a function call: checks the stack, creates a new CallInfo
-** entry, fills in the relevant information, calls hook if needed.
-** If function is a C function, does the call, too. (Otherwise, leave
-** the execution ('luaV_execute') to the caller, to allow stackless
-** calls.) Returns true iff function has been executed (C function).
-*/
-int luaD_precall (lua_State *L, StkId func, int nresults) {
-  lua_CFunction f;
-  CallInfo *ci;
-  switch (ttype(func)) {
-    case LUA_TCCL:  /* C closure */
-      f = clCvalue(func)->f;
-      goto Cfunc;
-    case LUA_TLCF:  /* light C function */
-      f = fvalue(func);
-     Cfunc: {
-      int n;  /* number of returns */
-      checkstackp(L, LUA_MINSTACK, func);  /* ensure minimum stack size */
-      ci = next_ci(L);  /* now 'enter' new function */
-      ci->nresults = nresults;
-      ci->func = func;
-      ci->top = L->top + LUA_MINSTACK;
-      lua_assert(ci->top <= L->stack_last);
-      ci->callstatus = 0;
-      if (L->hookmask & LUA_MASKCALL)
-        luaD_hook(L, LUA_HOOKCALL, -1);
-      lua_unlock(L);
-      n = (*f)(L);  /* do the actual call */
-      lua_lock(L);
-      api_checknelems(L, n);
-      luaD_poscall(L, ci, L->top - n, n);
-      return 1;
-    }
-    case LUA_TLCL: {  /* Lua function: prepare its call */
-      StkId base;
-      Proto *p = clLvalue(func)->p;
-      int n = cast_int(L->top - func) - 1;  /* number of real arguments */
-      int fsize = p->maxstacksize;  /* frame size */
-      checkstackp(L, fsize, func);
-      if (p->is_vararg)
-        base = adjust_varargs(L, p, n);
-      else {  /* non vararg function */
-        for (; n < p->numparams; n++)
-          setnilvalue(L->top++);  /* complete missing arguments */
-        base = func + 1;
-      }
-      ci = next_ci(L);  /* now 'enter' new function */
-      ci->nresults = nresults;
-      ci->func = func;
-      ci->u.l.base = base;
-      L->top = ci->top = base + fsize;
-      lua_assert(ci->top <= L->stack_last);
-      ci->u.l.savedpc = p->code;  /* starting point */
-      ci->callstatus = CIST_LUA;
-      if (L->hookmask & LUA_MASKCALL)
-        callhook(L, ci);
-      return 0;
-    }
-    default: {  /* not a function */
-      checkstackp(L, 1, func);  /* ensure space for metamethod */
-      tryfuncTM(L, func);  /* try to get '__call' metamethod */
-      return luaD_precall(L, func, nresults);  /* now it must be a function */
-    }
-  }
-}
-
-
-/*
-** Check appropriate error for stack overflow ("regular" overflow or
-** overflow while handling stack overflow). If 'nCalls' is larger than
-** LUAI_MAXCCALLS (which means it is handling a "regular" overflow) but
-** smaller than 9/8 of LUAI_MAXCCALLS, does not report an error (to
-** allow overflow handling to work)
-*/
-static void stackerror (lua_State *L) {
-  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 */
-}
-
-
-/*
-** 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)
-    stackerror(L);
-  if (!luaD_precall(L, func, nResults))  /* is a Lua function? */
-    luaV_execute(L);  /* call it */
-  L->nCcalls--;
-}
-
-
-/*
-** Similar to 'luaD_call', but does not allow yields during the call
-*/
-void luaD_callnoyield (lua_State *L, StkId func, int nResults) {
-  L->nny++;
-  luaD_call(L, func, nResults);
-  L->nny--;
-}
-
-
-/*
-** Completes the execution of an interrupted C function, calling its
-** continuation function.
-*/
-static void finishCcall (lua_State *L, int status) {
-  CallInfo *ci = L->ci;
-  int n;
-  /* must have a continuation and must be able to call it */
-  lua_assert(ci->u.c.k != NULL && L->nny == 0);
-  /* error status can only happen in a protected call */
-  lua_assert((ci->callstatus & CIST_YPCALL) || status == LUA_YIELD);
-  if (ci->callstatus & CIST_YPCALL) {  /* was inside a pcall? */
-    ci->callstatus &= ~CIST_YPCALL;  /* continuation is also inside it */
-    L->errfunc = ci->u.c.old_errfunc;  /* with the same error function */
-  }
-  /* finish 'lua_callk'/'lua_pcall'; CIST_YPCALL and 'errfunc' already
-     handled */
-  adjustresults(L, ci->nresults);
-  lua_unlock(L);
-  n = (*ci->u.c.k)(L, status, ci->u.c.ctx);  /* call continuation function */
-  lua_lock(L);
-  api_checknelems(L, n);
-  luaD_poscall(L, ci, L->top - n, n);  /* finish 'luaD_precall' */
-}
-
-
-/*
-** Executes "full continuation" (everything in the stack) of a
-** previously interrupted coroutine until the stack is empty (or another
-** interruption long-jumps out of the loop). If the coroutine is
-** recovering from an error, 'ud' points to the error status, which must
-** be passed to the first continuation function (otherwise the default
-** status is LUA_YIELD).
-*/
-static void unroll (lua_State *L, void *ud) {
-  if (ud != NULL)  /* error status? */
-    finishCcall(L, *(int *)ud);  /* finish 'lua_pcallk' callee */
-  while (L->ci != &L->base_ci) {  /* something in the stack */
-    if (!isLua(L->ci))  /* C function? */
-      finishCcall(L, LUA_YIELD);  /* complete its execution */
-    else {  /* Lua function */
-      luaV_finishOp(L);  /* finish interrupted instruction */
-      luaV_execute(L);  /* execute down to higher C 'boundary' */
-    }
-  }
-}
-
-
-/*
-** Try to find a suspended protected call (a "recover point") for the
-** given thread.
-*/
-static CallInfo *findpcall (lua_State *L) {
-  CallInfo *ci;
-  for (ci = L->ci; ci != NULL; ci = ci->previous) {  /* search for a pcall */
-    if (ci->callstatus & CIST_YPCALL)
-      return ci;
-  }
-  return NULL;  /* no pending pcall */
-}
-
-
-/*
-** Recovers from an error in a coroutine. Finds a recover point (if
-** there is one) and completes the execution of the interrupted
-** 'luaD_pcall'. If there is no recover point, returns zero.
-*/
-static int recover (lua_State *L, int status) {
-  StkId oldtop;
-  CallInfo *ci = findpcall(L);
-  if (ci == NULL) return 0;  /* no recovery point */
-  /* "finish" luaD_pcall */
-  oldtop = restorestack(L, ci->extra);
-  luaF_close(L, oldtop);
-  seterrorobj(L, status, oldtop);
-  L->ci = ci;
-  L->allowhook = getoah(ci->callstatus);  /* restore original 'allowhook' */
-  L->nny = 0;  /* should be zero to be yieldable */
-  luaD_shrinkstack(L);
-  L->errfunc = ci->u.c.old_errfunc;
-  return 1;  /* continue running the coroutine */
-}
-
-
-/*
-** Signal an error in the call to 'lua_resume', not in the execution
-** of the coroutine itself. (Such errors should not be handled by any
-** coroutine error handler and should not kill the coroutine.)
-*/
-static int resume_error (lua_State *L, const char *msg, int narg) {
-  L->top -= narg;  /* remove args from the stack */
-  setsvalue2s(L, L->top, luaS_new(L, msg));  /* push error message */
-  api_incr_top(L);
-  lua_unlock(L);
-  return LUA_ERRRUN;
-}
-
-
-/*
-** Do the work for 'lua_resume' in protected mode. Most of the work
-** depends on the status of the coroutine: initial state, suspended
-** inside a hook, or regularly suspended (optionally with a continuation
-** function), plus erroneous cases: non-suspended coroutine or dead
-** coroutine.
-*/
-static void resume (lua_State *L, void *ud) {
-  int n = *(cast(int*, ud));  /* number of arguments */
-  StkId firstArg = L->top - n;  /* first argument */
-  CallInfo *ci = L->ci;
-  if (L->status == LUA_OK) {  /* starting a coroutine? */
-    if (!luaD_precall(L, firstArg - 1, LUA_MULTRET))  /* Lua function? */
-      luaV_execute(L);  /* call it */
-  }
-  else {  /* resuming from previous yield */
-    lua_assert(L->status == LUA_YIELD);
-    L->status = LUA_OK;  /* mark that it is running (again) */
-    ci->func = restorestack(L, ci->extra);
-    if (isLua(ci))  /* yielded inside a hook? */
-      luaV_execute(L);  /* just continue running Lua code */
-    else {  /* 'common' yield */
-      if (ci->u.c.k != NULL) {  /* does it have a continuation function? */
-        lua_unlock(L);
-        n = (*ci->u.c.k)(L, LUA_YIELD, ci->u.c.ctx); /* call continuation */
-        lua_lock(L);
-        api_checknelems(L, n);
-        firstArg = L->top - n;  /* yield results come from continuation */
-      }
-      luaD_poscall(L, ci, firstArg, n);  /* finish 'luaD_precall' */
-    }
-    unroll(L, NULL);  /* run continuation */
-  }
-}
-
-
-LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) {
-  int status;
-  unsigned short oldnny = L->nny;  /* save "number of non-yieldable" calls */
-  lua_lock(L);
-  if (L->status == LUA_OK) {  /* may be starting a coroutine */
-    if (L->ci != &L->base_ci)  /* not in base level? */
-      return resume_error(L, "cannot resume non-suspended coroutine", nargs);
-  }
-  else if (L->status != LUA_YIELD)
-    return resume_error(L, "cannot resume dead coroutine", nargs);
-  L->nCcalls = (from) ? from->nCcalls + 1 : 1;
-  if (L->nCcalls >= LUAI_MAXCCALLS)
-    return resume_error(L, "C stack overflow", nargs);
-  luai_userstateresume(L, nargs);
-  L->nny = 0;  /* allow yields */
-  api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs);
-  status = luaD_rawrunprotected(L, resume, &nargs);
-  if (status == -1)  /* error calling 'lua_resume'? */
-    status = LUA_ERRRUN;
-  else {  /* continue running after recoverable errors */
-    while (errorstatus(status) && recover(L, status)) {
-      /* unroll continuation */
-      status = luaD_rawrunprotected(L, unroll, &status);
-    }
-    if (errorstatus(status)) {  /* unrecoverable error? */
-      L->status = cast_byte(status);  /* mark thread as 'dead' */
-      seterrorobj(L, status, L->top);  /* push error message */
-      L->ci->top = L->top;
-    }
-    else lua_assert(status == L->status);  /* normal end or yield */
-  }
-  L->nny = oldnny;  /* restore 'nny' */
-  L->nCcalls--;
-  lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int lua_isyieldable (lua_State *L) {
-  return (L->nny == 0);
-}
-
-
-LUA_API int lua_yieldk (lua_State *L, int nresults, lua_KContext ctx,
-                        lua_KFunction k) {
-  CallInfo *ci = L->ci;
-  luai_userstateyield(L, nresults);
-  lua_lock(L);
-  api_checknelems(L, nresults);
-  if (L->nny > 0) {
-    if (L != G(L)->mainthread)
-      luaG_runerror(L, "attempt to yield across a C-call boundary");
-    else
-      luaG_runerror(L, "attempt to yield from outside a coroutine");
-  }
-  L->status = LUA_YIELD;
-  ci->extra = savestack(L, ci->func);  /* save current 'func' */
-  if (isLua(ci)) {  /* inside a hook? */
-    api_check(L, k == NULL, "hooks cannot continue after yielding");
-  }
-  else {
-    if ((ci->u.c.k = k) != NULL)  /* is there a continuation? */
-      ci->u.c.ctx = ctx;  /* save context */
-    ci->func = L->top - nresults - 1;  /* protect stack below results */
-    luaD_throw(L, LUA_YIELD);
-  }
-  lua_assert(ci->callstatus & CIST_HOOKED);  /* must be inside a hook */
-  lua_unlock(L);
-  return 0;  /* return to 'luaD_hook' */
-}
-
-
-int luaD_pcall (lua_State *L, Pfunc func, void *u,
-                ptrdiff_t old_top, ptrdiff_t ef) {
-  int status;
-  CallInfo *old_ci = L->ci;
-  lu_byte old_allowhooks = L->allowhook;
-  unsigned short old_nny = L->nny;
-  ptrdiff_t old_errfunc = L->errfunc;
-  L->errfunc = ef;
-  status = luaD_rawrunprotected(L, func, u);
-  if (status != LUA_OK) {  /* an error occurred? */
-    StkId oldtop = restorestack(L, old_top);
-    luaF_close(L, oldtop);  /* close possible pending closures */
-    seterrorobj(L, status, oldtop);
-    L->ci = old_ci;
-    L->allowhook = old_allowhooks;
-    L->nny = old_nny;
-    luaD_shrinkstack(L);
-  }
-  L->errfunc = old_errfunc;
-  return status;
-}
-
-
-
-/*
-** Execute a protected parser.
-*/
-struct SParser {  /* data to 'f_parser' */
-  ZIO *z;
-  Mbuffer buff;  /* dynamic structure used by the scanner */
-  Dyndata dyd;  /* dynamic structures used by the parser */
-  const char *mode;
-  const char *name;
-};
-
-
-static void checkmode (lua_State *L, const char *mode, const char *x) {
-  if (mode && strchr(mode, x[0]) == NULL) {
-    luaO_pushfstring(L,
-       "attempt to load a %s chunk (mode is '%s')", x, mode);
-    luaD_throw(L, LUA_ERRSYNTAX);
-  }
-}
-
-
-static void f_parser (lua_State *L, void *ud) {
-  LClosure *cl;
-  struct SParser *p = cast(struct SParser *, ud);
-  int c = zgetc(p->z);  /* read first character */
-  if (c == LUA_SIGNATURE[0]) {
-    checkmode(L, p->mode, "binary");
-    cl = luaU_undump(L, p->z, p->name);
-  }
-  else {
-    checkmode(L, p->mode, "text");
-    cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
-  }
-  lua_assert(cl->nupvalues == cl->p->sizeupvalues);
-  luaF_initupvals(L, cl);
-}
-
-
-int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
-                                        const char *mode) {
-  struct SParser p;
-  int status;
-  L->nny++;  /* cannot yield during parsing */
-  p.z = z; p.name = name; p.mode = mode;
-  p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0;
-  p.dyd.gt.arr = NULL; p.dyd.gt.size = 0;
-  p.dyd.label.arr = NULL; p.dyd.label.size = 0;
-  luaZ_initbuffer(L, &p.buff);
-  status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
-  luaZ_freebuffer(L, &p.buff);
-  luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size);
-  luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size);
-  luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size);
-  L->nny--;
-  return status;
-}
-
-
diff --git a/lua/lua-5.3.5/src/ldo.h b/lua/lua-5.3.5/src/ldo.h
deleted file mode 100644
index 3b2983a..0000000
--- a/lua/lua-5.3.5/src/ldo.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-** $Id: ldo.h,v 2.29.1.1 2017/04/19 17:20:42 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"
-
-
-/*
-** Macro to check stack size and grow stack if needed.  Parameters
-** 'pre'/'pos' allow the macro to preserve a pointer into the
-** stack across reallocations, doing the work only when needed.
-** 'condmovestack' is used in heavy tests to force a stack reallocation
-** at every check.
-*/
-#define luaD_checkstackaux(L,n,pre,pos)  \
-	if (L->stack_last - L->top <= (n)) \
-	  { pre; luaD_growstack(L, n); pos; } else { condmovestack(L,pre,pos); }
-
-/* In general, 'pre'/'pos' are empty (nothing to save) */
-#define luaD_checkstack(L,n)	luaD_checkstackaux(L,n,(void)0,(void)0)
-
-
-
-#define savestack(L,p)		((char *)(p) - (char *)L->stack)
-#define restorestack(L,n)	((TValue *)((char *)L->stack + (n)))
-
-
-/* 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,
-                                                  const char *mode);
-LUAI_FUNC void luaD_hook (lua_State *L, int event, int line);
-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 void luaD_callnoyield (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, CallInfo *ci, StkId firstResult,
-                                          int nres);
-LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
-LUAI_FUNC void luaD_growstack (lua_State *L, int n);
-LUAI_FUNC void luaD_shrinkstack (lua_State *L);
-LUAI_FUNC void luaD_inctop (lua_State *L);
-
-LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode);
-LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
-
-#endif
-
diff --git a/lua/lua-5.3.5/src/ldump.c b/lua/lua-5.3.5/src/ldump.c
deleted file mode 100644
index f025aca..0000000
--- a/lua/lua-5.3.5/src/ldump.c
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
-** $Id: ldump.c,v 2.37.1.1 2017/04/19 17:20:42 roberto Exp $
-** save precompiled Lua chunks
-** See Copyright Notice in lua.h
-*/
-
-#define ldump_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <stddef.h>
-
-#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;
-
-
-/*
-** All high-level dumps go through DumpVector; you can change it to
-** change the endianness of the result
-*/
-#define DumpVector(v,n,D)	DumpBlock(v,(n)*sizeof((v)[0]),D)
-
-#define DumpLiteral(s,D)	DumpBlock(s, sizeof(s) - sizeof(char), D)
-
-
-static void DumpBlock (const void *b, size_t size, DumpState *D) {
-  if (D->status == 0 && size > 0) {
-    lua_unlock(D->L);
-    D->status = (*D->writer)(D->L, b, size, D->data);
-    lua_lock(D->L);
-  }
-}
-
-
-#define DumpVar(x,D)		DumpVector(&x,1,D)
-
-
-static void DumpByte (int y, DumpState *D) {
-  lu_byte x = (lu_byte)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 DumpInteger (lua_Integer x, DumpState *D) {
-  DumpVar(x, D);
-}
-
-
-static void DumpString (const TString *s, DumpState *D) {
-  if (s == NULL)
-    DumpByte(0, D);
-  else {
-    size_t size = tsslen(s) + 1;  /* include trailing '\0' */
-    const char *str = getstr(s);
-    if (size < 0xFF)
-      DumpByte(cast_int(size), D);
-    else {
-      DumpByte(0xFF, D);
-      DumpVar(size, D);
-    }
-    DumpVector(str, size - 1, D);  /* no need to save '\0' */
-  }
-}
-
-
-static void DumpCode (const Proto *f, DumpState *D) {
-  DumpInt(f->sizecode, D);
-  DumpVector(f->code, f->sizecode, D);
-}
-
-
-static void DumpFunction(const Proto *f, TString *psource, DumpState *D);
-
-static void DumpConstants (const Proto *f, DumpState *D) {
-  int i;
-  int n = f->sizek;
-  DumpInt(n, D);
-  for (i = 0; i < n; i++) {
-    const TValue *o = &f->k[i];
-    DumpByte(ttype(o), D);
-    switch (ttype(o)) {
-    case LUA_TNIL:
-      break;
-    case LUA_TBOOLEAN:
-      DumpByte(bvalue(o), D);
-      break;
-    case LUA_TNUMFLT:
-      DumpNumber(fltvalue(o), D);
-      break;
-    case LUA_TNUMINT:
-      DumpInteger(ivalue(o), D);
-      break;
-    case LUA_TSHRSTR:
-    case LUA_TLNGSTR:
-      DumpString(tsvalue(o), D);
-      break;
-    default:
-      lua_assert(0);
-    }
-  }
-}
-
-
-static void DumpProtos (const Proto *f, DumpState *D) {
-  int i;
-  int n = f->sizep;
-  DumpInt(n, D);
-  for (i = 0; i < n; i++)
-    DumpFunction(f->p[i], f->source, D);
-}
-
-
-static void DumpUpvalues (const Proto *f, DumpState *D) {
-  int i, n = f->sizeupvalues;
-  DumpInt(n, D);
-  for (i = 0; i < n; i++) {
-    DumpByte(f->upvalues[i].instack, D);
-    DumpByte(f->upvalues[i].idx, D);
-  }
-}
-
-
-static void DumpDebug (const Proto *f, DumpState *D) {
-  int i, n;
-  n = (D->strip) ? 0 : f->sizelineinfo;
-  DumpInt(n, D);
-  DumpVector(f->lineinfo, n, 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].name, D);
-}
-
-
-static void DumpFunction (const Proto *f, TString *psource, DumpState *D) {
-  if (D->strip || f->source == psource)
-    DumpString(NULL, D);  /* no debug info or same source as its parent */
-  else
-    DumpString(f->source, D);
-  DumpInt(f->linedefined, D);
-  DumpInt(f->lastlinedefined, D);
-  DumpByte(f->numparams, D);
-  DumpByte(f->is_vararg, D);
-  DumpByte(f->maxstacksize, D);
-  DumpCode(f, D);
-  DumpConstants(f, D);
-  DumpUpvalues(f, D);
-  DumpProtos(f, D);
-  DumpDebug(f, D);
-}
-
-
-static void DumpHeader (DumpState *D) {
-  DumpLiteral(LUA_SIGNATURE, D);
-  DumpByte(LUAC_VERSION, D);
-  DumpByte(LUAC_FORMAT, D);
-  DumpLiteral(LUAC_DATA, D);
-  DumpByte(sizeof(int), D);
-  DumpByte(sizeof(size_t), D);
-  DumpByte(sizeof(Instruction), D);
-  DumpByte(sizeof(lua_Integer), D);
-  DumpByte(sizeof(lua_Number), D);
-  DumpInteger(LUAC_INT, D);
-  DumpNumber(LUAC_NUM, 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);
-  DumpByte(f->sizeupvalues, &D);
-  DumpFunction(f, NULL, &D);
-  return D.status;
-}
-
diff --git a/lua/lua-5.3.5/src/lfunc.c b/lua/lua-5.3.5/src/lfunc.c
deleted file mode 100644
index ccafbb8..0000000
--- a/lua/lua-5.3.5/src/lfunc.c
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
-** $Id: lfunc.c,v 2.45.1.1 2017/04/19 17:39:34 roberto Exp $
-** Auxiliary functions to manipulate prototypes and closures
-** See Copyright Notice in lua.h
-*/
-
-#define lfunc_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <stddef.h>
-
-#include "lua.h"
-
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-
-
-
-CClosure *luaF_newCclosure (lua_State *L, int n) {
-  GCObject *o = luaC_newobj(L, LUA_TCCL, sizeCclosure(n));
-  CClosure *c = gco2ccl(o);
-  c->nupvalues = cast_byte(n);
-  return c;
-}
-
-
-LClosure *luaF_newLclosure (lua_State *L, int n) {
-  GCObject *o = luaC_newobj(L, LUA_TLCL, sizeLclosure(n));
-  LClosure *c = gco2lcl(o);
-  c->p = NULL;
-  c->nupvalues = cast_byte(n);
-  while (n--) c->upvals[n] = NULL;
-  return c;
-}
-
-/*
-** fill a closure with new closed upvalues
-*/
-void luaF_initupvals (lua_State *L, LClosure *cl) {
-  int i;
-  for (i = 0; i < cl->nupvalues; i++) {
-    UpVal *uv = luaM_new(L, UpVal);
-    uv->refcount = 1;
-    uv->v = &uv->u.value;  /* make it closed */
-    setnilvalue(uv->v);
-    cl->upvals[i] = uv;
-  }
-}
-
-
-UpVal *luaF_findupval (lua_State *L, StkId level) {
-  UpVal **pp = &L->openupval;
-  UpVal *p;
-  UpVal *uv;
-  lua_assert(isintwups(L) || L->openupval == NULL);
-  while (*pp != NULL && (p = *pp)->v >= level) {
-    lua_assert(upisopen(p));
-    if (p->v == level)  /* found a corresponding upvalue? */
-      return p;  /* return it */
-    pp = &p->u.open.next;
-  }
-  /* not found: create a new upvalue */
-  uv = luaM_new(L, UpVal);
-  uv->refcount = 0;
-  uv->u.open.next = *pp;  /* link it to list of open upvalues */
-  uv->u.open.touched = 1;
-  *pp = uv;
-  uv->v = level;  /* current value lives in the stack */
-  if (!isintwups(L)) {  /* thread not in list of threads with upvalues? */
-    L->twups = G(L)->twups;  /* link it to the list */
-    G(L)->twups = L;
-  }
-  return uv;
-}
-
-
-void luaF_close (lua_State *L, StkId level) {
-  UpVal *uv;
-  while (L->openupval != NULL && (uv = L->openupval)->v >= level) {
-    lua_assert(upisopen(uv));
-    L->openupval = uv->u.open.next;  /* remove from 'open' list */
-    if (uv->refcount == 0)  /* no references? */
-      luaM_free(L, uv);  /* free upvalue */
-    else {
-      setobj(L, &uv->u.value, uv->v);  /* move value to upvalue slot */
-      uv->v = &uv->u.value;  /* now current value lives here */
-      luaC_upvalbarrier(L, uv);
-    }
-  }
-}
-
-
-Proto *luaF_newproto (lua_State *L) {
-  GCObject *o = luaC_newobj(L, LUA_TPROTO, sizeof(Proto));
-  Proto *f = gco2p(o);
-  f->k = NULL;
-  f->sizek = 0;
-  f->p = NULL;
-  f->sizep = 0;
-  f->code = NULL;
-  f->cache = NULL;
-  f->sizecode = 0;
-  f->lineinfo = NULL;
-  f->sizelineinfo = 0;
-  f->upvalues = NULL;
-  f->sizeupvalues = 0;
-  f->numparams = 0;
-  f->is_vararg = 0;
-  f->maxstacksize = 0;
-  f->locvars = NULL;
-  f->sizelocvars = 0;
-  f->linedefined = 0;
-  f->lastlinedefined = 0;
-  f->source = NULL;
-  return f;
-}
-
-
-void luaF_freeproto (lua_State *L, Proto *f) {
-  luaM_freearray(L, f->code, f->sizecode);
-  luaM_freearray(L, f->p, f->sizep);
-  luaM_freearray(L, f->k, f->sizek);
-  luaM_freearray(L, f->lineinfo, f->sizelineinfo);
-  luaM_freearray(L, f->locvars, f->sizelocvars);
-  luaM_freearray(L, f->upvalues, f->sizeupvalues);
-  luaM_free(L, f);
-}
-
-
-/*
-** 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/lua/lua-5.3.5/src/lfunc.h b/lua/lua-5.3.5/src/lfunc.h
deleted file mode 100644
index c916e98..0000000
--- a/lua/lua-5.3.5/src/lfunc.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-** $Id: lfunc.h,v 2.15.1.1 2017/04/19 17:39:34 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)))
-
-
-/* test whether thread is in 'twups' list */
-#define isintwups(L)	(L->twups != L)
-
-
-/*
-** maximum number of upvalues in a closure (both C and Lua). (Value
-** must fit in a VM register.)
-*/
-#define MAXUPVAL	255
-
-
-/*
-** Upvalues for Lua closures
-*/
-struct UpVal {
-  TValue *v;  /* points to stack or to its own value */
-  lu_mem refcount;  /* reference counter */
-  union {
-    struct {  /* (when open) */
-      UpVal *next;  /* linked list */
-      int touched;  /* mark to avoid cycles with dead threads */
-    } open;
-    TValue value;  /* the value (when closed) */
-  } u;
-};
-
-#define upisopen(up)	((up)->v != &(up)->u.value)
-
-
-LUAI_FUNC Proto *luaF_newproto (lua_State *L);
-LUAI_FUNC CClosure *luaF_newCclosure (lua_State *L, int nelems);
-LUAI_FUNC LClosure *luaF_newLclosure (lua_State *L, int nelems);
-LUAI_FUNC void luaF_initupvals (lua_State *L, LClosure *cl);
-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 const char *luaF_getlocalname (const Proto *func, int local_number,
-                                         int pc);
-
-
-#endif
diff --git a/lua/lua-5.3.5/src/lgc.c b/lua/lua-5.3.5/src/lgc.c
deleted file mode 100644
index db4df82..0000000
--- a/lua/lua-5.3.5/src/lgc.c
+++ /dev/null
@@ -1,1179 +0,0 @@
-/*
-** $Id: lgc.c,v 2.215.1.2 2017/08/31 16:15:27 roberto Exp $
-** Garbage Collector
-** See Copyright Notice in lua.h
-*/
-
-#define lgc_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <string.h>
-
-#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"
-
-
-/*
-** internal state for collector while inside the atomic phase. The
-** collector should never be in this state while running regular code.
-*/
-#define GCSinsideatomic		(GCSpause + 1)
-
-/*
-** cost of sweeping one element (the size of a small object divided
-** by some adjust for the sweep speed)
-*/
-#define GCSWEEPCOST	((sizeof(TString) + 4) / 4)
-
-/* maximum number of elements to sweep in each single step */
-#define GCSWEEPMAX	(cast_int((GCSTEPSIZE / GCSWEEPCOST) / 4))
-
-/* cost of calling one finalizer */
-#define GCFINALIZECOST	GCSWEEPCOST
-
-
-/*
-** macro to adjust 'stepmul': 'stepmul' is actually used like
-** 'stepmul / STEPMULADJ' (value chosen by tests)
-*/
-#define STEPMULADJ		200
-
-
-/*
-** macro to adjust 'pause': 'pause' is actually used like
-** 'pause / PAUSEADJ' (value chosen by tests)
-*/
-#define PAUSEADJ		100
-
-
-/*
-** 'makewhite' erases all color bits then sets only the current white
-** bit
-*/
-#define maskcolors	(~(bitmask(BLACKBIT) | WHITEBITS))
-#define makewhite(g,x)	\
- (x->marked = cast_byte((x->marked & maskcolors) | luaC_white(g)))
-
-#define white2gray(x)	resetbits(x->marked, WHITEBITS)
-#define black2gray(x)	resetbit(x->marked, BLACKBIT)
-
-
-#define valiswhite(x)   (iscollectable(x) && iswhite(gcvalue(x)))
-
-#define checkdeadkey(n)	lua_assert(!ttisdeadkey(gkey(n)) || ttisnil(gval(n)))
-
-
-#define checkconsistency(obj)  \
-  lua_longassert(!iscollectable(obj) || righttt(obj))
-
-
-#define markvalue(g,o) { checkconsistency(o); \
-  if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); }
-
-#define markobject(g,t)	{ if (iswhite(t)) reallymarkobject(g, obj2gco(t)); }
-
-/*
-** mark an object that can be NULL (either because it is really optional,
-** or it was stripped as debug info, or inside an uncompleted structure)
-*/
-#define markobjectN(g,t)	{ if (t) markobject(g,t); }
-
-static void reallymarkobject (global_State *g, GCObject *o);
-
-
-/*
-** {======================================================
-** Generic functions
-** =======================================================
-*/
-
-
-/*
-** one after last element in a hash array
-*/
-#define gnodelast(h)	gnode(h, cast(size_t, sizenode(h)))
-
-
-/*
-** link collectable object 'o' into list pointed by 'p'
-*/
-#define linkgclist(o,p)	((o)->gclist = (p), (p) = obj2gco(o))
-
-
-/*
-** If key is not marked, mark its entry as dead. This allows key to be
-** collected, but keeps its entry in the table.  A dead node is needed
-** when Lua looks up for a key (it may be part of a chain) and when
-** traversing a weak table (key might be removed from the table during
-** traversal). Other places never manipulate dead keys, because its
-** associated nil value is enough to signal that the entry is logically
-** empty.
-*/
-static void removeentry (Node *n) {
-  lua_assert(ttisnil(gval(n)));
-  if (valiswhite(gkey(n)))
-    setdeadvalue(wgkey(n));  /* unused and unmarked key; remove it */
-}
-
-
-/*
-** 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 objects
-** being finalized, keep them in keys, but not in values
-*/
-static int iscleared (global_State *g, const TValue *o) {
-  if (!iscollectable(o)) return 0;
-  else if (ttisstring(o)) {
-    markobject(g, tsvalue(o));  /* strings are 'values', so are never weak */
-    return 0;
-  }
-  else return iswhite(gcvalue(o));
-}
-
-
-/*
-** barrier that moves collector forward, that is, mark the white object
-** being pointed by a black object. (If in sweep phase, clear the black
-** object to white [sweep it] to avoid other barrier calls for this
-** same object.)
-*/
-void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v) {
-  global_State *g = G(L);
-  lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
-  if (keepinvariant(g))  /* must keep invariant? */
-    reallymarkobject(g, v);  /* restore invariant */
-  else {  /* sweep phase */
-    lua_assert(issweepphase(g));
-    makewhite(g, o);  /* mark main obj. as white to avoid other barriers */
-  }
-}
-
-
-/*
-** barrier that moves collector backward, that is, mark the black object
-** pointing to a white object as gray again.
-*/
-void luaC_barrierback_ (lua_State *L, Table *t) {
-  global_State *g = G(L);
-  lua_assert(isblack(t) && !isdead(g, t));
-  black2gray(t);  /* make table gray (again) */
-  linkgclist(t, g->grayagain);
-}
-
-
-/*
-** barrier for assignments to closed upvalues. Because upvalues are
-** shared among closures, it is impossible to know the color of all
-** closures pointing to it. So, we assume that the object being assigned
-** must be marked.
-*/
-void luaC_upvalbarrier_ (lua_State *L, UpVal *uv) {
-  global_State *g = G(L);
-  GCObject *o = gcvalue(uv->v);
-  lua_assert(!upisopen(uv));  /* ensured by macro luaC_upvalbarrier */
-  if (keepinvariant(g))
-    markobject(g, o);
-}
-
-
-void luaC_fix (lua_State *L, GCObject *o) {
-  global_State *g = G(L);
-  lua_assert(g->allgc == o);  /* object must be 1st in 'allgc' list! */
-  white2gray(o);  /* they will be gray forever */
-  g->allgc = o->next;  /* remove object from 'allgc' list */
-  o->next = g->fixedgc;  /* link it to 'fixedgc' list */
-  g->fixedgc = o;
-}
-
-
-/*
-** create a new collectable object (with given type and size) and link
-** it to 'allgc' list.
-*/
-GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) {
-  global_State *g = G(L);
-  GCObject *o = cast(GCObject *, luaM_newobject(L, novariant(tt), sz));
-  o->marked = luaC_white(g);
-  o->tt = tt;
-  o->next = g->allgc;
-  g->allgc = o;
-  return o;
-}
-
-/* }====================================================== */
-
-
-
-/*
-** {======================================================
-** Mark functions
-** =======================================================
-*/
-
-
-/*
-** mark an object. Userdata, strings, and closed upvalues are visited
-** and turned black here. Other objects are marked gray and added
-** to appropriate list to be visited (and turned black) later. (Open
-** upvalues are already linked in 'headuv' list.)
-*/
-static void reallymarkobject (global_State *g, GCObject *o) {
- reentry:
-  white2gray(o);
-  switch (o->tt) {
-    case LUA_TSHRSTR: {
-      gray2black(o);
-      g->GCmemtrav += sizelstring(gco2ts(o)->shrlen);
-      break;
-    }
-    case LUA_TLNGSTR: {
-      gray2black(o);
-      g->GCmemtrav += sizelstring(gco2ts(o)->u.lnglen);
-      break;
-    }
-    case LUA_TUSERDATA: {
-      TValue uvalue;
-      markobjectN(g, gco2u(o)->metatable);  /* mark its metatable */
-      gray2black(o);
-      g->GCmemtrav += sizeudata(gco2u(o));
-      getuservalue(g->mainthread, gco2u(o), &uvalue);
-      if (valiswhite(&uvalue)) {  /* markvalue(g, &uvalue); */
-        o = gcvalue(&uvalue);
-        goto reentry;
-      }
-      break;
-    }
-    case LUA_TLCL: {
-      linkgclist(gco2lcl(o), g->gray);
-      break;
-    }
-    case LUA_TCCL: {
-      linkgclist(gco2ccl(o), g->gray);
-      break;
-    }
-    case LUA_TTABLE: {
-      linkgclist(gco2t(o), g->gray);
-      break;
-    }
-    case LUA_TTHREAD: {
-      linkgclist(gco2th(o), g->gray);
-      break;
-    }
-    case LUA_TPROTO: {
-      linkgclist(gco2p(o), g->gray);
-      break;
-    }
-    default: lua_assert(0); break;
-  }
-}
-
-
-/*
-** mark metamethods for basic types
-*/
-static void markmt (global_State *g) {
-  int i;
-  for (i=0; i < LUA_NUMTAGS; i++)
-    markobjectN(g, g->mt[i]);
-}
-
-
-/*
-** mark all objects in list of being-finalized
-*/
-static void markbeingfnz (global_State *g) {
-  GCObject *o;
-  for (o = g->tobefnz; o != NULL; o = o->next)
-    markobject(g, o);
-}
-
-
-/*
-** Mark all values stored in marked open upvalues from non-marked threads.
-** (Values from marked threads were already marked when traversing the
-** thread.) Remove from the list threads that no longer have upvalues and
-** not-marked threads.
-*/
-static void remarkupvals (global_State *g) {
-  lua_State *thread;
-  lua_State **p = &g->twups;
-  while ((thread = *p) != NULL) {
-    lua_assert(!isblack(thread));  /* threads are never black */
-    if (isgray(thread) && thread->openupval != NULL)
-      p = &thread->twups;  /* keep marked thread with upvalues in the list */
-    else {  /* thread is not marked or without upvalues */
-      UpVal *uv;
-      *p = thread->twups;  /* remove thread from the list */
-      thread->twups = thread;  /* mark that it is out of list */
-      for (uv = thread->openupval; uv != NULL; uv = uv->u.open.next) {
-        if (uv->u.open.touched) {
-          markvalue(g, uv->v);  /* remark upvalue's value */
-          uv->u.open.touched = 0;
-        }
-      }
-    }
-  }
-}
-
-
-/*
-** mark root set and reset all gray lists, to start a new collection
-*/
-static void restartcollection (global_State *g) {
-  g->gray = g->grayagain = NULL;
-  g->weak = g->allweak = g->ephemeron = NULL;
-  markobject(g, g->mainthread);
-  markvalue(g, &g->l_registry);
-  markmt(g);
-  markbeingfnz(g);  /* mark any finalizing object left from previous cycle */
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Traverse functions
-** =======================================================
-*/
-
-/*
-** Traverse a table with weak values and link it to proper list. During
-** propagate phase, keep it in 'grayagain' list, to be revisited in the
-** atomic phase. In the atomic phase, if table has any white value,
-** put it in 'weak' list, to be cleared.
-*/
-static void traverseweakvalue (global_State *g, Table *h) {
-  Node *n, *limit = gnodelast(h);
-  /* if there is array part, assume it may have white values (it is not
-     worth traversing it now just to check) */
-  int hasclears = (h->sizearray > 0);
-  for (n = gnode(h, 0); n < limit; n++) {  /* traverse hash part */
-    checkdeadkey(n);
-    if (ttisnil(gval(n)))  /* entry is empty? */
-      removeentry(n);  /* remove it */
-    else {
-      lua_assert(!ttisnil(gkey(n)));
-      markvalue(g, gkey(n));  /* mark key */
-      if (!hasclears && iscleared(g, gval(n)))  /* is there a white value? */
-        hasclears = 1;  /* table will have to be cleared */
-    }
-  }
-  if (g->gcstate == GCSpropagate)
-    linkgclist(h, g->grayagain);  /* must retraverse it in atomic phase */
-  else if (hasclears)
-    linkgclist(h, g->weak);  /* has to be cleared later */
-}
-
-
-/*
-** Traverse an ephemeron table and link it to proper list. Returns true
-** iff any object was marked during this traversal (which implies that
-** convergence has to continue). During propagation phase, keep table
-** in 'grayagain' list, to be visited again in the atomic phase. In
-** the atomic phase, if table has any white->white entry, it has to
-** be revisited during ephemeron convergence (as that key may turn
-** black). Otherwise, if it has any white key, table has to be cleared
-** (in the atomic phase).
-*/
-static int traverseephemeron (global_State *g, Table *h) {
-  int marked = 0;  /* true if an object is marked in this traversal */
-  int hasclears = 0;  /* true if table has white keys */
-  int hasww = 0;  /* true if table has entry "white-key -> white-value" */
-  Node *n, *limit = gnodelast(h);
-  unsigned int i;
-  /* traverse array part */
-  for (i = 0; i < h->sizearray; i++) {
-    if (valiswhite(&h->array[i])) {
-      marked = 1;
-      reallymarkobject(g, gcvalue(&h->array[i]));
-    }
-  }
-  /* traverse hash part */
-  for (n = gnode(h, 0); n < limit; n++) {
-    checkdeadkey(n);
-    if (ttisnil(gval(n)))  /* entry is empty? */
-      removeentry(n);  /* remove it */
-    else if (iscleared(g, gkey(n))) {  /* key is not marked (yet)? */
-      hasclears = 1;  /* table must be cleared */
-      if (valiswhite(gval(n)))  /* value not marked yet? */
-        hasww = 1;  /* white-white entry */
-    }
-    else if (valiswhite(gval(n))) {  /* value not marked yet? */
-      marked = 1;
-      reallymarkobject(g, gcvalue(gval(n)));  /* mark it now */
-    }
-  }
-  /* link table into proper list */
-  if (g->gcstate == GCSpropagate)
-    linkgclist(h, g->grayagain);  /* must retraverse it in atomic phase */
-  else if (hasww)  /* table has white->white entries? */
-    linkgclist(h, g->ephemeron);  /* have to propagate again */
-  else if (hasclears)  /* table has white keys? */
-    linkgclist(h, g->allweak);  /* may have to clean white keys */
-  return marked;
-}
-
-
-static void traversestrongtable (global_State *g, Table *h) {
-  Node *n, *limit = gnodelast(h);
-  unsigned int i;
-  for (i = 0; i < h->sizearray; i++)  /* traverse array part */
-    markvalue(g, &h->array[i]);
-  for (n = gnode(h, 0); n < limit; n++) {  /* traverse hash part */
-    checkdeadkey(n);
-    if (ttisnil(gval(n)))  /* entry is empty? */
-      removeentry(n);  /* remove it */
-    else {
-      lua_assert(!ttisnil(gkey(n)));
-      markvalue(g, gkey(n));  /* mark key */
-      markvalue(g, gval(n));  /* mark value */
-    }
-  }
-}
-
-
-static lu_mem traversetable (global_State *g, Table *h) {
-  const char *weakkey, *weakvalue;
-  const TValue *mode = gfasttm(g, h->metatable, TM_MODE);
-  markobjectN(g, h->metatable);
-  if (mode && ttisstring(mode) &&  /* is there a weak mode? */
-      ((weakkey = strchr(svalue(mode), 'k')),
-       (weakvalue = strchr(svalue(mode), 'v')),
-       (weakkey || weakvalue))) {  /* is really weak? */
-    black2gray(h);  /* keep table gray */
-    if (!weakkey)  /* strong keys? */
-      traverseweakvalue(g, h);
-    else if (!weakvalue)  /* strong values? */
-      traverseephemeron(g, h);
-    else  /* all weak */
-      linkgclist(h, g->allweak);  /* nothing to traverse now */
-  }
-  else  /* not weak */
-    traversestrongtable(g, h);
-  return sizeof(Table) + sizeof(TValue) * h->sizearray +
-                         sizeof(Node) * cast(size_t, allocsizenode(h));
-}
-
-
-/*
-** Traverse a prototype. (While a prototype is being build, its
-** arrays can be larger than needed; the extra slots are filled with
-** NULL, so the use of 'markobjectN')
-*/
-static int traverseproto (global_State *g, Proto *f) {
-  int i;
-  if (f->cache && iswhite(f->cache))
-    f->cache = NULL;  /* allow cache to be collected */
-  markobjectN(g, 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 */
-    markobjectN(g, f->upvalues[i].name);
-  for (i = 0; i < f->sizep; i++)  /* mark nested protos */
-    markobjectN(g, f->p[i]);
-  for (i = 0; i < f->sizelocvars; i++)  /* mark local-variable names */
-    markobjectN(g, f->locvars[i].varname);
-  return sizeof(Proto) + sizeof(Instruction) * f->sizecode +
-                         sizeof(Proto *) * f->sizep +
-                         sizeof(TValue) * f->sizek +
-                         sizeof(int) * f->sizelineinfo +
-                         sizeof(LocVar) * f->sizelocvars +
-                         sizeof(Upvaldesc) * f->sizeupvalues;
-}
-
-
-static lu_mem traverseCclosure (global_State *g, CClosure *cl) {
-  int i;
-  for (i = 0; i < cl->nupvalues; i++)  /* mark its upvalues */
-    markvalue(g, &cl->upvalue[i]);
-  return sizeCclosure(cl->nupvalues);
-}
-
-/*
-** open upvalues point to values in a thread, so those values should
-** be marked when the thread is traversed except in the atomic phase
-** (because then the value cannot be changed by the thread and the
-** thread may not be traversed again)
-*/
-static lu_mem traverseLclosure (global_State *g, LClosure *cl) {
-  int i;
-  markobjectN(g, cl->p);  /* mark its prototype */
-  for (i = 0; i < cl->nupvalues; i++) {  /* mark its upvalues */
-    UpVal *uv = cl->upvals[i];
-    if (uv != NULL) {
-      if (upisopen(uv) && g->gcstate != GCSinsideatomic)
-        uv->u.open.touched = 1;  /* can be marked in 'remarkupvals' */
-      else
-        markvalue(g, uv->v);
-    }
-  }
-  return sizeLclosure(cl->nupvalues);
-}
-
-
-static lu_mem traversethread (global_State *g, lua_State *th) {
-  StkId o = th->stack;
-  if (o == NULL)
-    return 1;  /* stack not completely built yet */
-  lua_assert(g->gcstate == GCSinsideatomic ||
-             th->openupval == NULL || isintwups(th));
-  for (; o < th->top; o++)  /* mark live elements in the stack */
-    markvalue(g, o);
-  if (g->gcstate == GCSinsideatomic) {  /* final traversal? */
-    StkId lim = th->stack + th->stacksize;  /* real end of stack */
-    for (; o < lim; o++)  /* clear not-marked stack slice */
-      setnilvalue(o);
-    /* 'remarkupvals' may have removed thread from 'twups' list */
-    if (!isintwups(th) && th->openupval != NULL) {
-      th->twups = g->twups;  /* link it back to the list */
-      g->twups = th;
-    }
-  }
-  else if (g->gckind != KGC_EMERGENCY)
-    luaD_shrinkstack(th); /* do not change stack in emergency cycle */
-  return (sizeof(lua_State) + sizeof(TValue) * th->stacksize +
-          sizeof(CallInfo) * th->nci);
-}
-
-
-/*
-** traverse one gray object, turning it to black (except for threads,
-** which are always gray).
-*/
-static void propagatemark (global_State *g) {
-  lu_mem size;
-  GCObject *o = g->gray;
-  lua_assert(isgray(o));
-  gray2black(o);
-  switch (o->tt) {
-    case LUA_TTABLE: {
-      Table *h = gco2t(o);
-      g->gray = h->gclist;  /* remove from 'gray' list */
-      size = traversetable(g, h);
-      break;
-    }
-    case LUA_TLCL: {
-      LClosure *cl = gco2lcl(o);
-      g->gray = cl->gclist;  /* remove from 'gray' list */
-      size = traverseLclosure(g, cl);
-      break;
-    }
-    case LUA_TCCL: {
-      CClosure *cl = gco2ccl(o);
-      g->gray = cl->gclist;  /* remove from 'gray' list */
-      size = traverseCclosure(g, cl);
-      break;
-    }
-    case LUA_TTHREAD: {
-      lua_State *th = gco2th(o);
-      g->gray = th->gclist;  /* remove from 'gray' list */
-      linkgclist(th, g->grayagain);  /* insert into 'grayagain' list */
-      black2gray(o);
-      size = traversethread(g, th);
-      break;
-    }
-    case LUA_TPROTO: {
-      Proto *p = gco2p(o);
-      g->gray = p->gclist;  /* remove from 'gray' list */
-      size = traverseproto(g, p);
-      break;
-    }
-    default: lua_assert(0); return;
-  }
-  g->GCmemtrav += size;
-}
-
-
-static void propagateall (global_State *g) {
-  while (g->gray) propagatemark(g);
-}
-
-
-static void convergeephemerons (global_State *g) {
-  int changed;
-  do {
-    GCObject *w;
-    GCObject *next = g->ephemeron;  /* get ephemeron list */
-    g->ephemeron = NULL;  /* tables may return to this list when traversed */
-    changed = 0;
-    while ((w = next) != NULL) {
-      next = gco2t(w)->gclist;
-      if (traverseephemeron(g, gco2t(w))) {  /* traverse marked some value? */
-        propagateall(g);  /* propagate changes */
-        changed = 1;  /* will have to revisit all ephemeron tables */
-      }
-    }
-  } while (changed);
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Sweep Functions
-** =======================================================
-*/
-
-
-/*
-** clear entries with unmarked keys from all weaktables in list 'l' up
-** to element 'f'
-*/
-static void clearkeys (global_State *g, GCObject *l, GCObject *f) {
-  for (; l != f; l = gco2t(l)->gclist) {
-    Table *h = gco2t(l);
-    Node *n, *limit = gnodelast(h);
-    for (n = gnode(h, 0); n < limit; n++) {
-      if (!ttisnil(gval(n)) && (iscleared(g, gkey(n)))) {
-        setnilvalue(gval(n));  /* remove value ... */
-      }
-      if (ttisnil(gval(n)))  /* is entry empty? */
-        removeentry(n);  /* remove entry from table */
-    }
-  }
-}
-
-
-/*
-** clear entries with unmarked values from all weaktables in list 'l' up
-** to element 'f'
-*/
-static void clearvalues (global_State *g, GCObject *l, GCObject *f) {
-  for (; l != f; l = gco2t(l)->gclist) {
-    Table *h = gco2t(l);
-    Node *n, *limit = gnodelast(h);
-    unsigned int i;
-    for (i = 0; i < h->sizearray; i++) {
-      TValue *o = &h->array[i];
-      if (iscleared(g, o))  /* value was collected? */
-        setnilvalue(o);  /* remove value */
-    }
-    for (n = gnode(h, 0); n < limit; n++) {
-      if (!ttisnil(gval(n)) && iscleared(g, gval(n))) {
-        setnilvalue(gval(n));  /* remove value ... */
-        removeentry(n);  /* and remove entry from table */
-      }
-    }
-  }
-}
-
-
-void luaC_upvdeccount (lua_State *L, UpVal *uv) {
-  lua_assert(uv->refcount > 0);
-  uv->refcount--;
-  if (uv->refcount == 0 && !upisopen(uv))
-    luaM_free(L, uv);
-}
-
-
-static void freeLclosure (lua_State *L, LClosure *cl) {
-  int i;
-  for (i = 0; i < cl->nupvalues; i++) {
-    UpVal *uv = cl->upvals[i];
-    if (uv)
-      luaC_upvdeccount(L, uv);
-  }
-  luaM_freemem(L, cl, sizeLclosure(cl->nupvalues));
-}
-
-
-static void freeobj (lua_State *L, GCObject *o) {
-  switch (o->tt) {
-    case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
-    case LUA_TLCL: {
-      freeLclosure(L, gco2lcl(o));
-      break;
-    }
-    case LUA_TCCL: {
-      luaM_freemem(L, o, sizeCclosure(gco2ccl(o)->nupvalues));
-      break;
-    }
-    case LUA_TTABLE: luaH_free(L, gco2t(o)); break;
-    case LUA_TTHREAD: luaE_freethread(L, gco2th(o)); break;
-    case LUA_TUSERDATA: luaM_freemem(L, o, sizeudata(gco2u(o))); break;
-    case LUA_TSHRSTR:
-      luaS_remove(L, gco2ts(o));  /* remove it from hash table */
-      luaM_freemem(L, o, sizelstring(gco2ts(o)->shrlen));
-      break;
-    case LUA_TLNGSTR: {
-      luaM_freemem(L, o, sizelstring(gco2ts(o)->u.lnglen));
-      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);
-
-
-/*
-** sweep at most 'count' elements from a list of GCObjects erasing dead
-** objects, where a dead object is one marked with the old (non current)
-** white; change all non-dead objects back to white, preparing for next
-** collection cycle. Return where to continue the traversal or NULL if
-** list is finished.
-*/
-static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
-  global_State *g = G(L);
-  int ow = otherwhite(g);
-  int white = luaC_white(g);  /* current white */
-  while (*p != NULL && count-- > 0) {
-    GCObject *curr = *p;
-    int marked = curr->marked;
-    if (isdeadm(ow, marked)) {  /* is 'curr' dead? */
-      *p = curr->next;  /* remove 'curr' from list */
-      freeobj(L, curr);  /* erase 'curr' */
-    }
-    else {  /* change mark to 'white' */
-      curr->marked = cast_byte((marked & maskcolors) | white);
-      p = &curr->next;  /* go to next element */
-    }
-  }
-  return (*p == NULL) ? NULL : p;
-}
-
-
-/*
-** sweep a list until a live object (or end of list)
-*/
-static GCObject **sweeptolive (lua_State *L, GCObject **p) {
-  GCObject **old = p;
-  do {
-    p = sweeplist(L, p, 1);
-  } while (p == old);
-  return p;
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Finalization
-** =======================================================
-*/
-
-/*
-** If possible, shrink string table
-*/
-static void checkSizes (lua_State *L, global_State *g) {
-  if (g->gckind != KGC_EMERGENCY) {
-    l_mem olddebt = g->GCdebt;
-    if (g->strt.nuse < g->strt.size / 4)  /* string table too big? */
-      luaS_resize(L, g->strt.size / 2);  /* shrink it a little */
-    g->GCestimate += g->GCdebt - olddebt;  /* update estimate */
-  }
-}
-
-
-static GCObject *udata2finalize (global_State *g) {
-  GCObject *o = g->tobefnz;  /* get first element */
-  lua_assert(tofinalize(o));
-  g->tobefnz = o->next;  /* remove it from 'tobefnz' list */
-  o->next = g->allgc;  /* return it to 'allgc' list */
-  g->allgc = o;
-  resetbit(o->marked, FINALIZEDBIT);  /* object is "normal" again */
-  if (issweepphase(g))
-    makewhite(g, o);  /* "sweep" object */
-  return o;
-}
-
-
-static void dothecall (lua_State *L, void *ud) {
-  UNUSED(ud);
-  luaD_callnoyield(L, L->top - 2, 0);
-}
-
-
-static void GCTM (lua_State *L, int propagateerrors) {
-  global_State *g = G(L);
-  const TValue *tm;
-  TValue v;
-  setgcovalue(L, &v, udata2finalize(g));
-  tm = luaT_gettmbyobj(L, &v, TM_GC);
-  if (tm != NULL && ttisfunction(tm)) {  /* is there a finalizer? */
-    int status;
-    lu_byte oldah = L->allowhook;
-    int running  = g->gcrunning;
-    L->allowhook = 0;  /* stop debug hooks during GC metamethod */
-    g->gcrunning = 0;  /* avoid GC steps */
-    setobj2s(L, L->top, tm);  /* push finalizer... */
-    setobj2s(L, L->top + 1, &v);  /* ... and its argument */
-    L->top += 2;  /* and (next line) call the finalizer */
-    L->ci->callstatus |= CIST_FIN;  /* will run a finalizer */
-    status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top - 2), 0);
-    L->ci->callstatus &= ~CIST_FIN;  /* not running a finalizer anymore */
-    L->allowhook = oldah;  /* restore hooks */
-    g->gcrunning = running;  /* restore state */
-    if (status != LUA_OK && propagateerrors) {  /* error while running __gc? */
-      if (status == LUA_ERRRUN) {  /* is there an error object? */
-        const char *msg = (ttisstring(L->top - 1))
-                            ? svalue(L->top - 1)
-                            : "no message";
-        luaO_pushfstring(L, "error in __gc metamethod (%s)", msg);
-        status = LUA_ERRGCMM;  /* error in __gc metamethod */
-      }
-      luaD_throw(L, status);  /* re-throw error */
-    }
-  }
-}
-
-
-/*
-** call a few (up to 'g->gcfinnum') finalizers
-*/
-static int runafewfinalizers (lua_State *L) {
-  global_State *g = G(L);
-  unsigned int i;
-  lua_assert(!g->tobefnz || g->gcfinnum > 0);
-  for (i = 0; g->tobefnz && i < g->gcfinnum; i++)
-    GCTM(L, 1);  /* call one finalizer */
-  g->gcfinnum = (!g->tobefnz) ? 0  /* nothing more to finalize? */
-                    : g->gcfinnum * 2;  /* else call a few more next time */
-  return i;
-}
-
-
-/*
-** call all pending finalizers
-*/
-static void callallpendingfinalizers (lua_State *L) {
-  global_State *g = G(L);
-  while (g->tobefnz)
-    GCTM(L, 0);
-}
-
-
-/*
-** find last 'next' field in list 'p' list (to add elements in its end)
-*/
-static GCObject **findlast (GCObject **p) {
-  while (*p != NULL)
-    p = &(*p)->next;
-  return p;
-}
-
-
-/*
-** move all unreachable objects (or 'all' objects) that need
-** finalization from list 'finobj' to list 'tobefnz' (to be finalized)
-*/
-static void separatetobefnz (global_State *g, int all) {
-  GCObject *curr;
-  GCObject **p = &g->finobj;
-  GCObject **lastnext = findlast(&g->tobefnz);
-  while ((curr = *p) != NULL) {  /* traverse all finalizable objects */
-    lua_assert(tofinalize(curr));
-    if (!(iswhite(curr) || all))  /* not being collected? */
-      p = &curr->next;  /* don't bother with it */
-    else {
-      *p = curr->next;  /* remove 'curr' from 'finobj' list */
-      curr->next = *lastnext;  /* link at the end of 'tobefnz' list */
-      *lastnext = curr;
-      lastnext = &curr->next;
-    }
-  }
-}
-
-
-/*
-** if object 'o' has a finalizer, remove it from 'allgc' list (must
-** search the list to find it) and link it in 'finobj' list.
-*/
-void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) {
-  global_State *g = G(L);
-  if (tofinalize(o) ||                 /* obj. is already marked... */
-      gfasttm(g, mt, TM_GC) == NULL)   /* or has no finalizer? */
-    return;  /* nothing to be done */
-  else {  /* move 'o' to 'finobj' list */
-    GCObject **p;
-    if (issweepphase(g)) {
-      makewhite(g, o);  /* "sweep" object 'o' */
-      if (g->sweepgc == &o->next)  /* should not remove 'sweepgc' object */
-        g->sweepgc = sweeptolive(L, g->sweepgc);  /* change 'sweepgc' */
-    }
-    /* search for pointer pointing to 'o' */
-    for (p = &g->allgc; *p != o; p = &(*p)->next) { /* empty */ }
-    *p = o->next;  /* remove 'o' from 'allgc' list */
-    o->next = g->finobj;  /* link it in 'finobj' list */
-    g->finobj = o;
-    l_setbit(o->marked, FINALIZEDBIT);  /* mark it as such */
-  }
-}
-
-/* }====================================================== */
-
-
-
-/*
-** {======================================================
-** GC control
-** =======================================================
-*/
-
-
-/*
-** Set a reasonable "time" to wait before starting a new GC cycle; cycle
-** will start when memory use hits threshold. (Division by 'estimate'
-** should be OK: it cannot be zero (because Lua cannot even start with
-** less than PAUSEADJ bytes).
-*/
-static void setpause (global_State *g) {
-  l_mem threshold, debt;
-  l_mem estimate = g->GCestimate / PAUSEADJ;  /* adjust 'estimate' */
-  lua_assert(estimate > 0);
-  threshold = (g->gcpause < MAX_LMEM / estimate)  /* overflow? */
-            ? estimate * g->gcpause  /* no overflow */
-            : MAX_LMEM;  /* overflow; truncate to maximum */
-  debt = gettotalbytes(g) - threshold;
-  luaE_setdebt(g, debt);
-}
-
-
-/*
-** Enter first sweep phase.
-** The call to 'sweeplist' tries to make pointer point to an object
-** inside the list (instead of to the header), so that the real sweep do
-** not need to skip objects created between "now" and the start of the
-** real sweep.
-*/
-static void entersweep (lua_State *L) {
-  global_State *g = G(L);
-  g->gcstate = GCSswpallgc;
-  lua_assert(g->sweepgc == NULL);
-  g->sweepgc = sweeplist(L, &g->allgc, 1);
-}
-
-
-void luaC_freeallobjects (lua_State *L) {
-  global_State *g = G(L);
-  separatetobefnz(g, 1);  /* separate all objects with finalizers */
-  lua_assert(g->finobj == NULL);
-  callallpendingfinalizers(L);
-  lua_assert(g->tobefnz == NULL);
-  g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */
-  g->gckind = KGC_NORMAL;
-  sweepwholelist(L, &g->finobj);
-  sweepwholelist(L, &g->allgc);
-  sweepwholelist(L, &g->fixedgc);  /* collect fixed objects */
-  lua_assert(g->strt.nuse == 0);
-}
-
-
-static l_mem atomic (lua_State *L) {
-  global_State *g = G(L);
-  l_mem work;
-  GCObject *origweak, *origall;
-  GCObject *grayagain = g->grayagain;  /* save original list */
-  lua_assert(g->ephemeron == NULL && g->weak == NULL);
-  lua_assert(!iswhite(g->mainthread));
-  g->gcstate = GCSinsideatomic;
-  g->GCmemtrav = 0;  /* start counting work */
-  markobject(g, L);  /* mark running thread */
-  /* registry and global metatables may be changed by API */
-  markvalue(g, &g->l_registry);
-  markmt(g);  /* mark global metatables */
-  /* remark occasional upvalues of (maybe) dead threads */
-  remarkupvals(g);
-  propagateall(g);  /* propagate changes */
-  work = g->GCmemtrav;  /* stop counting (do not recount 'grayagain') */
-  g->gray = grayagain;
-  propagateall(g);  /* traverse 'grayagain' list */
-  g->GCmemtrav = 0;  /* restart counting */
-  convergeephemerons(g);
-  /* at this point, all strongly accessible objects are marked. */
-  /* Clear values from weak tables, before checking finalizers */
-  clearvalues(g, g->weak, NULL);
-  clearvalues(g, g->allweak, NULL);
-  origweak = g->weak; origall = g->allweak;
-  work += g->GCmemtrav;  /* stop counting (objects being finalized) */
-  separatetobefnz(g, 0);  /* separate objects to be finalized */
-  g->gcfinnum = 1;  /* there may be objects to be finalized */
-  markbeingfnz(g);  /* mark objects that will be finalized */
-  propagateall(g);  /* remark, to propagate 'resurrection' */
-  g->GCmemtrav = 0;  /* restart counting */
-  convergeephemerons(g);
-  /* at this point, all resurrected objects are marked. */
-  /* remove dead objects from weak tables */
-  clearkeys(g, g->ephemeron, NULL);  /* clear keys from all ephemeron tables */
-  clearkeys(g, g->allweak, NULL);  /* clear keys from all 'allweak' tables */
-  /* clear values from resurrected weak tables */
-  clearvalues(g, g->weak, origweak);
-  clearvalues(g, g->allweak, origall);
-  luaS_clearcache(g);
-  g->currentwhite = cast_byte(otherwhite(g));  /* flip current white */
-  work += g->GCmemtrav;  /* complete counting */
-  return work;  /* estimate of memory marked by 'atomic' */
-}
-
-
-static lu_mem sweepstep (lua_State *L, global_State *g,
-                         int nextstate, GCObject **nextlist) {
-  if (g->sweepgc) {
-    l_mem olddebt = g->GCdebt;
-    g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
-    g->GCestimate += g->GCdebt - olddebt;  /* update estimate */
-    if (g->sweepgc)  /* is there still something to sweep? */
-      return (GCSWEEPMAX * GCSWEEPCOST);
-  }
-  /* else enter next state */
-  g->gcstate = nextstate;
-  g->sweepgc = nextlist;
-  return 0;
-}
-
-
-static lu_mem singlestep (lua_State *L) {
-  global_State *g = G(L);
-  switch (g->gcstate) {
-    case GCSpause: {
-      g->GCmemtrav = g->strt.size * sizeof(GCObject*);
-      restartcollection(g);
-      g->gcstate = GCSpropagate;
-      return g->GCmemtrav;
-    }
-    case GCSpropagate: {
-      g->GCmemtrav = 0;
-      lua_assert(g->gray);
-      propagatemark(g);
-       if (g->gray == NULL)  /* no more gray objects? */
-        g->gcstate = GCSatomic;  /* finish propagate phase */
-      return g->GCmemtrav;  /* memory traversed in this step */
-    }
-    case GCSatomic: {
-      lu_mem work;
-      propagateall(g);  /* make sure gray list is empty */
-      work = atomic(L);  /* work is what was traversed by 'atomic' */
-      entersweep(L);
-      g->GCestimate = gettotalbytes(g);  /* first estimate */;
-      return work;
-    }
-    case GCSswpallgc: {  /* sweep "regular" objects */
-      return sweepstep(L, g, GCSswpfinobj, &g->finobj);
-    }
-    case GCSswpfinobj: {  /* sweep objects with finalizers */
-      return sweepstep(L, g, GCSswptobefnz, &g->tobefnz);
-    }
-    case GCSswptobefnz: {  /* sweep objects to be finalized */
-      return sweepstep(L, g, GCSswpend, NULL);
-    }
-    case GCSswpend: {  /* finish sweeps */
-      makewhite(g, g->mainthread);  /* sweep main thread */
-      checkSizes(L, g);
-      g->gcstate = GCScallfin;
-      return 0;
-    }
-    case GCScallfin: {  /* call remaining finalizers */
-      if (g->tobefnz && g->gckind != KGC_EMERGENCY) {
-        int n = runafewfinalizers(L);
-        return (n * GCFINALIZECOST);
-      }
-      else {  /* emergency mode or no more finalizers */
-        g->gcstate = GCSpause;  /* finish collection */
-        return 0;
-      }
-    }
-    default: lua_assert(0); return 0;
-  }
-}
-
-
-/*
-** advances the garbage collector until it reaches a state allowed
-** by 'statemask'
-*/
-void luaC_runtilstate (lua_State *L, int statesmask) {
-  global_State *g = G(L);
-  while (!testbit(statesmask, g->gcstate))
-    singlestep(L);
-}
-
-
-/*
-** get GC debt and convert it from Kb to 'work units' (avoid zero debt
-** and overflows)
-*/
-static l_mem getdebt (global_State *g) {
-  l_mem debt = g->GCdebt;
-  int stepmul = g->gcstepmul;
-  if (debt <= 0) return 0;  /* minimal debt */
-  else {
-    debt = (debt / STEPMULADJ) + 1;
-    debt = (debt < MAX_LMEM / stepmul) ? debt * stepmul : MAX_LMEM;
-    return debt;
-  }
-}
-
-/*
-** performs a basic GC step when collector is running
-*/
-void luaC_step (lua_State *L) {
-  global_State *g = G(L);
-  l_mem debt = getdebt(g);  /* GC deficit (be paid now) */
-  if (!g->gcrunning) {  /* not running? */
-    luaE_setdebt(g, -GCSTEPSIZE * 10);  /* avoid being called too often */
-    return;
-  }
-  do {  /* repeat until pause or enough "credit" (negative debt) */
-    lu_mem work = singlestep(L);  /* perform one single step */
-    debt -= work;
-  } while (debt > -GCSTEPSIZE && g->gcstate != GCSpause);
-  if (g->gcstate == GCSpause)
-    setpause(g);  /* pause until next cycle */
-  else {
-    debt = (debt / g->gcstepmul) * STEPMULADJ;  /* convert 'work units' to Kb */
-    luaE_setdebt(g, debt);
-    runafewfinalizers(L);
-  }
-}
-
-
-/*
-** Performs a full GC cycle; if 'isemergency', set a flag to avoid
-** some operations which could change the interpreter state in some
-** unexpected ways (running finalizers and shrinking some structures).
-** Before running the collection, check 'keepinvariant'; if it is true,
-** there may be some objects marked as black, so the collector has
-** to sweep all objects to turn them back to white (as white has not
-** changed, nothing will be collected).
-*/
-void luaC_fullgc (lua_State *L, int isemergency) {
-  global_State *g = G(L);
-  lua_assert(g->gckind == KGC_NORMAL);
-  if (isemergency) g->gckind = KGC_EMERGENCY;  /* set flag */
-  if (keepinvariant(g)) {  /* black objects? */
-    entersweep(L); /* sweep everything to turn them back to white */
-  }
-  /* finish any pending sweep phase to start a new cycle */
-  luaC_runtilstate(L, bitmask(GCSpause));
-  luaC_runtilstate(L, ~bitmask(GCSpause));  /* start new collection */
-  luaC_runtilstate(L, bitmask(GCScallfin));  /* run up to finalizers */
-  /* estimate must be correct after a full GC cycle */
-  lua_assert(g->GCestimate == gettotalbytes(g));
-  luaC_runtilstate(L, bitmask(GCSpause));  /* finish collection */
-  g->gckind = KGC_NORMAL;
-  setpause(g);
-}
-
-/* }====================================================== */
-
-
diff --git a/lua/lua-5.3.5/src/lgc.h b/lua/lua-5.3.5/src/lgc.h
deleted file mode 100644
index 425cd7c..0000000
--- a/lua/lua-5.3.5/src/lgc.h
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
-** $Id: lgc.h,v 2.91.1.1 2017/04/19 17:39:34 roberto Exp $
-** Garbage Collector
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lgc_h
-#define lgc_h
-
-
-#include "lobject.h"
-#include "lstate.h"
-
-/*
-** Collectable objects may have one of three colors: white, which
-** means the object is not marked; gray, which means the
-** object is marked, but its references may be not marked; and
-** black, which means that the object and all its references are marked.
-** The main invariant of the garbage collector, while marking objects,
-** is that a black object can never point to a white one. Moreover,
-** any gray object must be in a "gray list" (gray, grayagain, weak,
-** allweak, ephemeron) so that it can be visited again before finishing
-** the collection cycle. These lists have no meaning when the invariant
-** is not being enforced (e.g., sweep phase).
-*/
-
-
-
-/* how much to allocate before next GC step */
-#if !defined(GCSTEPSIZE)
-/* ~100 small strings */
-#define GCSTEPSIZE	(cast_int(100 * sizeof(TString)))
-#endif
-
-
-/*
-** Possible states of the Garbage Collector
-*/
-#define GCSpropagate	0
-#define GCSatomic	1
-#define GCSswpallgc	2
-#define GCSswpfinobj	3
-#define GCSswptobefnz	4
-#define GCSswpend	5
-#define GCScallfin	6
-#define GCSpause	7
-
-
-#define issweepphase(g)  \
-	(GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend)
-
-
-/*
-** macro to tell when main invariant (white objects cannot point to black
-** ones) must be kept. During a collection, the sweep
-** phase may break the invariant, as objects turned white may point to
-** still-black objects. The invariant is restored when sweep ends and
-** all objects are white again.
-*/
-
-#define keepinvariant(g)	((g)->gcstate <= GCSatomic)
-
-
-/*
-** some useful 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))
-
-
-/* Layout for bit use in 'marked' field: */
-#define WHITE0BIT	0  /* object is white (type 0) */
-#define WHITE1BIT	1  /* object is white (type 1) */
-#define BLACKBIT	2  /* object is black */
-#define FINALIZEDBIT	3  /* object has been marked for finalization */
-/* bit 7 is currently used by tests (luaL_checkmemory) */
-
-#define WHITEBITS	bit2mask(WHITE0BIT, WHITE1BIT)
-
-
-#define iswhite(x)      testbits((x)->marked, WHITEBITS)
-#define isblack(x)      testbit((x)->marked, BLACKBIT)
-#define isgray(x)  /* neither white nor black */  \
-	(!testbits((x)->marked, WHITEBITS | bitmask(BLACKBIT)))
-
-#define tofinalize(x)	testbit((x)->marked, FINALIZEDBIT)
-
-#define otherwhite(g)	((g)->currentwhite ^ WHITEBITS)
-#define isdeadm(ow,m)	(!(((m) ^ WHITEBITS) & (ow)))
-#define isdead(g,v)	isdeadm(otherwhite(g), (v)->marked)
-
-#define changewhite(x)	((x)->marked ^= WHITEBITS)
-#define gray2black(x)	l_setbit((x)->marked, BLACKBIT)
-
-#define luaC_white(g)	cast(lu_byte, (g)->currentwhite & WHITEBITS)
-
-
-/*
-** Does one step of collection when debt becomes positive. 'pre'/'pos'
-** allows some adjustments to be done only when needed. macro
-** 'condchangemem' is used only for heavy tests (forcing a full
-** GC cycle on every opportunity)
-*/
-#define luaC_condGC(L,pre,pos) \
-	{ if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \
-	  condchangemem(L,pre,pos); }
-
-/* more often than not, 'pre'/'pos' are empty */
-#define luaC_checkGC(L)		luaC_condGC(L,(void)0,(void)0)
-
-
-#define luaC_barrier(L,p,v) (  \
-	(iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ?  \
-	luaC_barrier_(L,obj2gco(p),gcvalue(v)) : cast_void(0))
-
-#define luaC_barrierback(L,p,v) (  \
-	(iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ? \
-	luaC_barrierback_(L,p) : cast_void(0))
-
-#define luaC_objbarrier(L,p,o) (  \
-	(isblack(p) && iswhite(o)) ? \
-	luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0))
-
-#define luaC_upvalbarrier(L,uv) ( \
-	(iscollectable((uv)->v) && !upisopen(uv)) ? \
-         luaC_upvalbarrier_(L,uv) : cast_void(0))
-
-LUAI_FUNC void luaC_fix (lua_State *L, GCObject *o);
-LUAI_FUNC void luaC_freeallobjects (lua_State *L);
-LUAI_FUNC void luaC_step (lua_State *L);
-LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
-LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
-LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz);
-LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v);
-LUAI_FUNC void luaC_barrierback_ (lua_State *L, Table *o);
-LUAI_FUNC void luaC_upvalbarrier_ (lua_State *L, UpVal *uv);
-LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt);
-LUAI_FUNC void luaC_upvdeccount (lua_State *L, UpVal *uv);
-
-
-#endif
diff --git a/lua/lua-5.3.5/src/liblua.a b/lua/lua-5.3.5/src/liblua.a
deleted file mode 100644
index e7a4007e86157b0ff6d0064c196faedd174c67c4..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 454396
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
Z;U&L_{=;gCyH}Yg34J_@=~u$|{{|Pur}F>+

diff --git a/lua/lua-5.3.5/src/linit.c b/lua/lua-5.3.5/src/linit.c
deleted file mode 100644
index 480da52..0000000
--- a/lua/lua-5.3.5/src/linit.c
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-** $Id: linit.c,v 1.39.1.1 2017/04/19 17:20:42 roberto Exp $
-** Initialization of libraries for lua.c and other clients
-** See Copyright Notice in lua.h
-*/
-
-
-#define linit_c
-#define LUA_LIB
-
-/*
-** If you embed Lua in your program and need to open the standard
-** libraries, call luaL_openlibs in your program. If you need a
-** different set of libraries, copy this file to your project and edit
-** it to suit your needs.
-**
-** You can also *preload* libraries, so that a later 'require' can
-** open the library, which is already linked to the application.
-** For that, do the following code:
-**
-**  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
-**  lua_pushcfunction(L, luaopen_modname);
-**  lua_setfield(L, -2, modname);
-**  lua_pop(L, 1);  // remove PRELOAD table
-*/
-
-#include "lprefix.h"
-
-
-#include <stddef.h>
-
-#include "lua.h"
-
-#include "lualib.h"
-#include "lauxlib.h"
-
-
-/*
-** these libs are loaded by lua.c and are readily available to any Lua
-** program
-*/
-static const luaL_Reg loadedlibs[] = {
-  {"_G", luaopen_base},
-  {LUA_LOADLIBNAME, luaopen_package},
-  {LUA_COLIBNAME, luaopen_coroutine},
-  {LUA_TABLIBNAME, luaopen_table},
-  {LUA_IOLIBNAME, luaopen_io},
-  {LUA_OSLIBNAME, luaopen_os},
-  {LUA_STRLIBNAME, luaopen_string},
-  {LUA_MATHLIBNAME, luaopen_math},
-  {LUA_UTF8LIBNAME, luaopen_utf8},
-  {LUA_DBLIBNAME, luaopen_debug},
-#if defined(LUA_COMPAT_BITLIB)
-  {LUA_BITLIBNAME, luaopen_bit32},
-#endif
-  {NULL, NULL}
-};
-
-
-LUALIB_API void luaL_openlibs (lua_State *L) {
-  const luaL_Reg *lib;
-  /* "require" functions from 'loadedlibs' and set results to global table */
-  for (lib = loadedlibs; lib->func; lib++) {
-    luaL_requiref(L, lib->name, lib->func, 1);
-    lua_pop(L, 1);  /* remove lib */
-  }
-}
-
diff --git a/lua/lua-5.3.5/src/liolib.c b/lua/lua-5.3.5/src/liolib.c
deleted file mode 100644
index 8a9e75c..0000000
--- a/lua/lua-5.3.5/src/liolib.c
+++ /dev/null
@@ -1,776 +0,0 @@
-/*
-** $Id: liolib.c,v 2.151.1.1 2017/04/19 17:29:57 roberto Exp $
-** Standard I/O (and system) library
-** See Copyright Notice in lua.h
-*/
-
-#define liolib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <ctype.h>
-#include <errno.h>
-#include <locale.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-
-
-/*
-** Change this macro to accept other modes for 'fopen' besides
-** the standard ones.
-*/
-#if !defined(l_checkmode)
-
-/* accepted extensions to 'mode' in 'fopen' */
-#if !defined(L_MODEEXT)
-#define L_MODEEXT	"b"
-#endif
-
-/* Check whether 'mode' matches '[rwa]%+?[L_MODEEXT]*' */
-static int l_checkmode (const char *mode) {
-  return (*mode != '\0' && strchr("rwa", *(mode++)) != NULL &&
-         (*mode != '+' || (++mode, 1)) &&  /* skip if char is '+' */
-         (strspn(mode, L_MODEEXT) == strlen(mode)));  /* check extensions */
-}
-
-#endif
-
-/*
-** {======================================================
-** l_popen spawns a new process connected to the current
-** one through the file streams.
-** =======================================================
-*/
-
-#if !defined(l_popen)		/* { */
-
-#if defined(LUA_USE_POSIX)	/* { */
-
-#define l_popen(L,c,m)		(fflush(NULL), popen(c,m))
-#define l_pclose(L,file)	(pclose(file))
-
-#elif defined(LUA_USE_WINDOWS)	/* }{ */
-
-#define l_popen(L,c,m)		(_popen(c,m))
-#define l_pclose(L,file)	(_pclose(file))
-
-#else				/* }{ */
-
-/* ISO C definitions */
-#define l_popen(L,c,m)  \
-	  ((void)((void)c, m), \
-	  luaL_error(L, "'popen' not supported"), \
-	  (FILE*)0)
-#define l_pclose(L,file)		((void)L, (void)file, -1)
-
-#endif				/* } */
-
-#endif				/* } */
-
-/* }====================================================== */
-
-
-#if !defined(l_getc)		/* { */
-
-#if defined(LUA_USE_POSIX)
-#define l_getc(f)		getc_unlocked(f)
-#define l_lockfile(f)		flockfile(f)
-#define l_unlockfile(f)		funlockfile(f)
-#else
-#define l_getc(f)		getc(f)
-#define l_lockfile(f)		((void)0)
-#define l_unlockfile(f)		((void)0)
-#endif
-
-#endif				/* } */
-
-
-/*
-** {======================================================
-** l_fseek: configuration for longer offsets
-** =======================================================
-*/
-
-#if !defined(l_fseek)		/* { */
-
-#if defined(LUA_USE_POSIX)	/* { */
-
-#include <sys/types.h>
-
-#define l_fseek(f,o,w)		fseeko(f,o,w)
-#define l_ftell(f)		ftello(f)
-#define l_seeknum		off_t
-
-#elif defined(LUA_USE_WINDOWS) && !defined(_CRTIMP_TYPEINFO) \
-   && defined(_MSC_VER) && (_MSC_VER >= 1400)	/* }{ */
-
-/* Windows (but not DDK) and Visual C++ 2005 or higher */
-#define l_fseek(f,o,w)		_fseeki64(f,o,w)
-#define l_ftell(f)		_ftelli64(f)
-#define l_seeknum		__int64
-
-#else				/* }{ */
-
-/* ISO C definitions */
-#define l_fseek(f,o,w)		fseek(f,o,w)
-#define l_ftell(f)		ftell(f)
-#define l_seeknum		long
-
-#endif				/* } */
-
-#endif				/* } */
-
-/* }====================================================== */
-
-
-#define IO_PREFIX	"_IO_"
-#define IOPREF_LEN	(sizeof(IO_PREFIX)/sizeof(char) - 1)
-#define IO_INPUT	(IO_PREFIX "input")
-#define IO_OUTPUT	(IO_PREFIX "output")
-
-
-typedef luaL_Stream LStream;
-
-
-#define tolstream(L)	((LStream *)luaL_checkudata(L, 1, LUA_FILEHANDLE))
-
-#define isclosed(p)	((p)->closef == NULL)
-
-
-static int io_type (lua_State *L) {
-  LStream *p;
-  luaL_checkany(L, 1);
-  p = (LStream *)luaL_testudata(L, 1, LUA_FILEHANDLE);
-  if (p == NULL)
-    lua_pushnil(L);  /* not a file */
-  else if (isclosed(p))
-    lua_pushliteral(L, "closed file");
-  else
-    lua_pushliteral(L, "file");
-  return 1;
-}
-
-
-static int f_tostring (lua_State *L) {
-  LStream *p = tolstream(L);
-  if (isclosed(p))
-    lua_pushliteral(L, "file (closed)");
-  else
-    lua_pushfstring(L, "file (%p)", p->f);
-  return 1;
-}
-
-
-static FILE *tofile (lua_State *L) {
-  LStream *p = tolstream(L);
-  if (isclosed(p))
-    luaL_error(L, "attempt to use a closed file");
-  lua_assert(p->f);
-  return p->f;
-}
-
-
-/*
-** When creating file handles, always creates a 'closed' file handle
-** before opening the actual file; so, if there is a memory error, the
-** handle is in a consistent state.
-*/
-static LStream *newprefile (lua_State *L) {
-  LStream *p = (LStream *)lua_newuserdata(L, sizeof(LStream));
-  p->closef = NULL;  /* mark file handle as 'closed' */
-  luaL_setmetatable(L, LUA_FILEHANDLE);
-  return p;
-}
-
-
-/*
-** Calls the 'close' function from a file handle. The 'volatile' avoids
-** a bug in some versions of the Clang compiler (e.g., clang 3.0 for
-** 32 bits).
-*/
-static int aux_close (lua_State *L) {
-  LStream *p = tolstream(L);
-  volatile lua_CFunction cf = p->closef;
-  p->closef = NULL;  /* mark stream as closed */
-  return (*cf)(L);  /* close it */
-}
-
-
-static int f_close (lua_State *L) {
-  tofile(L);  /* make sure argument is an open stream */
-  return aux_close(L);
-}
-
-
-static int io_close (lua_State *L) {
-  if (lua_isnone(L, 1))  /* no argument? */
-    lua_getfield(L, LUA_REGISTRYINDEX, IO_OUTPUT);  /* use standard output */
-  return f_close(L);
-}
-
-
-static int f_gc (lua_State *L) {
-  LStream *p = tolstream(L);
-  if (!isclosed(p) && p->f != NULL)
-    aux_close(L);  /* ignore closed and incompletely open files */
-  return 0;
-}
-
-
-/*
-** function to close regular files
-*/
-static int io_fclose (lua_State *L) {
-  LStream *p = tolstream(L);
-  int res = fclose(p->f);
-  return luaL_fileresult(L, (res == 0), NULL);
-}
-
-
-static LStream *newfile (lua_State *L) {
-  LStream *p = newprefile(L);
-  p->f = NULL;
-  p->closef = &io_fclose;
-  return p;
-}
-
-
-static void opencheck (lua_State *L, const char *fname, const char *mode) {
-  LStream *p = newfile(L);
-  p->f = fopen(fname, mode);
-  if (p->f == NULL)
-    luaL_error(L, "cannot open file '%s' (%s)", fname, strerror(errno));
-}
-
-
-static int io_open (lua_State *L) {
-  const char *filename = luaL_checkstring(L, 1);
-  const char *mode = luaL_optstring(L, 2, "r");
-  LStream *p = newfile(L);
-  const char *md = mode;  /* to traverse/check mode */
-  luaL_argcheck(L, l_checkmode(md), 2, "invalid mode");
-  p->f = fopen(filename, mode);
-  return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
-}
-
-
-/*
-** function to close 'popen' files
-*/
-static int io_pclose (lua_State *L) {
-  LStream *p = tolstream(L);
-  return luaL_execresult(L, l_pclose(L, p->f));
-}
-
-
-static int io_popen (lua_State *L) {
-  const char *filename = luaL_checkstring(L, 1);
-  const char *mode = luaL_optstring(L, 2, "r");
-  LStream *p = newprefile(L);
-  p->f = l_popen(L, filename, mode);
-  p->closef = &io_pclose;
-  return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
-}
-
-
-static int io_tmpfile (lua_State *L) {
-  LStream *p = newfile(L);
-  p->f = tmpfile();
-  return (p->f == NULL) ? luaL_fileresult(L, 0, NULL) : 1;
-}
-
-
-static FILE *getiofile (lua_State *L, const char *findex) {
-  LStream *p;
-  lua_getfield(L, LUA_REGISTRYINDEX, findex);
-  p = (LStream *)lua_touserdata(L, -1);
-  if (isclosed(p))
-    luaL_error(L, "standard %s file is closed", findex + IOPREF_LEN);
-  return p->f;
-}
-
-
-static int g_iofile (lua_State *L, const char *f, const char *mode) {
-  if (!lua_isnoneornil(L, 1)) {
-    const char *filename = lua_tostring(L, 1);
-    if (filename)
-      opencheck(L, filename, mode);
-    else {
-      tofile(L);  /* check that it's a valid file handle */
-      lua_pushvalue(L, 1);
-    }
-    lua_setfield(L, LUA_REGISTRYINDEX, f);
-  }
-  /* return current value */
-  lua_getfield(L, LUA_REGISTRYINDEX, 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);
-
-
-/*
-** maximum number of arguments to 'f:lines'/'io.lines' (it + 3 must fit
-** in the limit for upvalues of a closure)
-*/
-#define MAXARGLINE	250
-
-static void aux_lines (lua_State *L, int toclose) {
-  int n = lua_gettop(L) - 1;  /* number of arguments to read */
-  luaL_argcheck(L, n <= MAXARGLINE, MAXARGLINE + 2, "too many arguments");
-  lua_pushinteger(L, n);  /* number of arguments to read */
-  lua_pushboolean(L, toclose);  /* close/not close file when finished */
-  lua_rotate(L, 2, 2);  /* move 'n' and 'toclose' to their positions */
-  lua_pushcclosure(L, io_readline, 3 + n);
-}
-
-
-static int f_lines (lua_State *L) {
-  tofile(L);  /* check that it's a valid file handle */
-  aux_lines(L, 0);
-  return 1;
-}
-
-
-static int io_lines (lua_State *L) {
-  int toclose;
-  if (lua_isnone(L, 1)) lua_pushnil(L);  /* at least one argument */
-  if (lua_isnil(L, 1)) {  /* no file name? */
-    lua_getfield(L, LUA_REGISTRYINDEX, IO_INPUT);  /* get default input */
-    lua_replace(L, 1);  /* put it at index 1 */
-    tofile(L);  /* check that it's a valid file handle */
-    toclose = 0;  /* do not close it after iteration */
-  }
-  else {  /* open a new file */
-    const char *filename = luaL_checkstring(L, 1);
-    opencheck(L, filename, "r");
-    lua_replace(L, 1);  /* put file at index 1 */
-    toclose = 1;  /* close it after iteration */
-  }
-  aux_lines(L, toclose);
-  return 1;
-}
-
-
-/*
-** {======================================================
-** READ
-** =======================================================
-*/
-
-
-/* maximum length of a numeral */
-#if !defined (L_MAXLENNUM)
-#define L_MAXLENNUM     200
-#endif
-
-
-/* auxiliary structure used by 'read_number' */
-typedef struct {
-  FILE *f;  /* file being read */
-  int c;  /* current character (look ahead) */
-  int n;  /* number of elements in buffer 'buff' */
-  char buff[L_MAXLENNUM + 1];  /* +1 for ending '\0' */
-} RN;
-
-
-/*
-** Add current char to buffer (if not out of space) and read next one
-*/
-static int nextc (RN *rn) {
-  if (rn->n >= L_MAXLENNUM) {  /* buffer overflow? */
-    rn->buff[0] = '\0';  /* invalidate result */
-    return 0;  /* fail */
-  }
-  else {
-    rn->buff[rn->n++] = rn->c;  /* save current char */
-    rn->c = l_getc(rn->f);  /* read next one */
-    return 1;
-  }
-}
-
-
-/*
-** Accept current char if it is in 'set' (of size 2)
-*/
-static int test2 (RN *rn, const char *set) {
-  if (rn->c == set[0] || rn->c == set[1])
-    return nextc(rn);
-  else return 0;
-}
-
-
-/*
-** Read a sequence of (hex)digits
-*/
-static int readdigits (RN *rn, int hex) {
-  int count = 0;
-  while ((hex ? isxdigit(rn->c) : isdigit(rn->c)) && nextc(rn))
-    count++;
-  return count;
-}
-
-
-/*
-** Read a number: first reads a valid prefix of a numeral into a buffer.
-** Then it calls 'lua_stringtonumber' to check whether the format is
-** correct and to convert it to a Lua number
-*/
-static int read_number (lua_State *L, FILE *f) {
-  RN rn;
-  int count = 0;
-  int hex = 0;
-  char decp[2];
-  rn.f = f; rn.n = 0;
-  decp[0] = lua_getlocaledecpoint();  /* get decimal point from locale */
-  decp[1] = '.';  /* always accept a dot */
-  l_lockfile(rn.f);
-  do { rn.c = l_getc(rn.f); } while (isspace(rn.c));  /* skip spaces */
-  test2(&rn, "-+");  /* optional signal */
-  if (test2(&rn, "00")) {
-    if (test2(&rn, "xX")) hex = 1;  /* numeral is hexadecimal */
-    else count = 1;  /* count initial '0' as a valid digit */
-  }
-  count += readdigits(&rn, hex);  /* integral part */
-  if (test2(&rn, decp))  /* decimal point? */
-    count += readdigits(&rn, hex);  /* fractional part */
-  if (count > 0 && test2(&rn, (hex ? "pP" : "eE"))) {  /* exponent mark? */
-    test2(&rn, "-+");  /* exponent signal */
-    readdigits(&rn, 0);  /* exponent digits */
-  }
-  ungetc(rn.c, rn.f);  /* unread look-ahead char */
-  l_unlockfile(rn.f);
-  rn.buff[rn.n] = '\0';  /* finish string */
-  if (lua_stringtonumber(L, rn.buff))  /* is this a valid number? */
-    return 1;  /* ok */
-  else {  /* invalid format */
-   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);  /* no-op when c == EOF */
-  lua_pushliteral(L, "");
-  return (c != EOF);
-}
-
-
-static int read_line (lua_State *L, FILE *f, int chop) {
-  luaL_Buffer b;
-  int c = '\0';
-  luaL_buffinit(L, &b);
-  while (c != EOF && c != '\n') {  /* repeat until end of line */
-    char *buff = luaL_prepbuffer(&b);  /* preallocate buffer */
-    int i = 0;
-    l_lockfile(f);  /* no memory errors can happen inside the lock */
-    while (i < LUAL_BUFFERSIZE && (c = l_getc(f)) != EOF && c != '\n')
-      buff[i++] = c;
-    l_unlockfile(f);
-    luaL_addsize(&b, i);
-  }
-  if (!chop && c == '\n')  /* want a newline and have one? */
-    luaL_addchar(&b, c);  /* add ending newline to result */
-  luaL_pushresult(&b);  /* close buffer */
-  /* return ok if read something (either a newline or something else) */
-  return (c == '\n' || lua_rawlen(L, -1) > 0);
-}
-
-
-static void read_all (lua_State *L, FILE *f) {
-  size_t nr;
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  do {  /* read file in chunks of LUAL_BUFFERSIZE bytes */
-    char *p = luaL_prepbuffer(&b);
-    nr = fread(p, sizeof(char), LUAL_BUFFERSIZE, f);
-    luaL_addsize(&b, nr);
-  } while (nr == LUAL_BUFFERSIZE);
-  luaL_pushresult(&b);  /* close buffer */
-}
-
-
-static int read_chars (lua_State *L, FILE *f, size_t n) {
-  size_t nr;  /* number of chars actually read */
-  char *p;
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  p = luaL_prepbuffsize(&b, n);  /* prepare buffer to read whole block */
-  nr = fread(p, sizeof(char), n, f);  /* try to read 'n' chars */
-  luaL_addsize(&b, nr);
-  luaL_pushresult(&b);  /* close buffer */
-  return (nr > 0);  /* true iff read something */
-}
-
-
-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, 1);
-    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)luaL_checkinteger(L, n);
-        success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
-      }
-      else {
-        const char *p = luaL_checkstring(L, n);
-        if (*p == '*') p++;  /* skip optional '*' (for compatibility) */
-        switch (*p) {
-          case 'n':  /* number */
-            success = read_number(L, f);
-            break;
-          case 'l':  /* line */
-            success = read_line(L, f, 1);
-            break;
-          case 'L':  /* line with end-of-line */
-            success = read_line(L, f, 0);
-            break;
-          case 'a':  /* file */
-            read_all(L, f);  /* read entire file */
-            success = 1; /* always success */
-            break;
-          default:
-            return luaL_argerror(L, n, "invalid format");
-        }
-      }
-    }
-  }
-  if (ferror(f))
-    return luaL_fileresult(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) {
-  LStream *p = (LStream *)lua_touserdata(L, lua_upvalueindex(1));
-  int i;
-  int n = (int)lua_tointeger(L, lua_upvalueindex(2));
-  if (isclosed(p))  /* file is already closed? */
-    return luaL_error(L, "file is already closed");
-  lua_settop(L , 1);
-  luaL_checkstack(L, n, "too many arguments");
-  for (i = 1; i <= n; i++)  /* push arguments to 'g_read' */
-    lua_pushvalue(L, lua_upvalueindex(3 + i));
-  n = g_read(L, p->f, 2);  /* 'n' is number of results */
-  lua_assert(n > 0);  /* should return at least a nil */
-  if (lua_toboolean(L, -n))  /* read at least one value? */
-    return n;  /* return them */
-  else {  /* first result is nil: EOF or error */
-    if (n > 1) {  /* is there error information? */
-      /* 2nd result is error message */
-      return luaL_error(L, "%s", lua_tostring(L, -n + 1));
-    }
-    if (lua_toboolean(L, lua_upvalueindex(3))) {  /* 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) - arg;
-  int status = 1;
-  for (; nargs--; arg++) {
-    if (lua_type(L, arg) == LUA_TNUMBER) {
-      /* optimization: could be done exactly as for strings */
-      int len = lua_isinteger(L, arg)
-                ? fprintf(f, LUA_INTEGER_FMT,
-                             (LUAI_UACINT)lua_tointeger(L, arg))
-                : fprintf(f, LUA_NUMBER_FMT,
-                             (LUAI_UACNUMBER)lua_tonumber(L, arg));
-      status = status && (len > 0);
-    }
-    else {
-      size_t l;
-      const char *s = luaL_checklstring(L, arg, &l);
-      status = status && (fwrite(s, sizeof(char), l, f) == l);
-    }
-  }
-  if (status) return 1;  /* file handle already on stack top */
-  else return luaL_fileresult(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) {
-  FILE *f = tofile(L);
-  lua_pushvalue(L, 1);  /* push file at the stack top (to be returned) */
-  return g_write(L, f, 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);
-  lua_Integer p3 = luaL_optinteger(L, 3, 0);
-  l_seeknum offset = (l_seeknum)p3;
-  luaL_argcheck(L, (lua_Integer)offset == p3, 3,
-                  "not an integer in proper range");
-  op = l_fseek(f, offset, mode[op]);
-  if (op)
-    return luaL_fileresult(L, 0, NULL);  /* error */
-  else {
-    lua_pushinteger(L, (lua_Integer)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], (size_t)sz);
-  return luaL_fileresult(L, res == 0, NULL);
-}
-
-
-
-static int io_flush (lua_State *L) {
-  return luaL_fileresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
-}
-
-
-static int f_flush (lua_State *L) {
-  return luaL_fileresult(L, fflush(tofile(L)) == 0, NULL);
-}
-
-
-/*
-** functions for 'io' library
-*/
-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}
-};
-
-
-/*
-** methods for file handles
-*/
-static const luaL_Reg flib[] = {
-  {"close", f_close},
-  {"flush", f_flush},
-  {"lines", f_lines},
-  {"read", f_read},
-  {"seek", f_seek},
-  {"setvbuf", f_setvbuf},
-  {"write", f_write},
-  {"__gc", f_gc},
-  {"__tostring", f_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_setfuncs(L, flib, 0);  /* add file methods to new metatable */
-  lua_pop(L, 1);  /* pop new metatable */
-}
-
-
-/*
-** function to (not) close the standard files stdin, stdout, and stderr
-*/
-static int io_noclose (lua_State *L) {
-  LStream *p = tolstream(L);
-  p->closef = &io_noclose;  /* keep file opened */
-  lua_pushnil(L);
-  lua_pushliteral(L, "cannot close standard file");
-  return 2;
-}
-
-
-static void createstdfile (lua_State *L, FILE *f, const char *k,
-                           const char *fname) {
-  LStream *p = newprefile(L);
-  p->f = f;
-  p->closef = &io_noclose;
-  if (k != NULL) {
-    lua_pushvalue(L, -1);
-    lua_setfield(L, LUA_REGISTRYINDEX, k);  /* add file to registry */
-  }
-  lua_setfield(L, -2, fname);  /* add file to module */
-}
-
-
-LUAMOD_API int luaopen_io (lua_State *L) {
-  luaL_newlib(L, iolib);  /* new module */
-  createmeta(L);
-  /* create (and set) default files */
-  createstdfile(L, stdin, IO_INPUT, "stdin");
-  createstdfile(L, stdout, IO_OUTPUT, "stdout");
-  createstdfile(L, stderr, NULL, "stderr");
-  return 1;
-}
-
diff --git a/lua/lua-5.3.5/src/llex.c b/lua/lua-5.3.5/src/llex.c
deleted file mode 100644
index 66fd411..0000000
--- a/lua/lua-5.3.5/src/llex.c
+++ /dev/null
@@ -1,565 +0,0 @@
-/*
-** $Id: llex.c,v 2.96.1.1 2017/04/19 17:20:42 roberto Exp $
-** Lexical Analyzer
-** See Copyright Notice in lua.h
-*/
-
-#define llex_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <locale.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lctype.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lgc.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 */
-static const char *const luaX_tokens [] = {
-    "and", "break", "do", "else", "elseif",
-    "end", "false", "for", "function", "goto", "if",
-    "in", "local", "nil", "not", "or", "repeat",
-    "return", "then", "true", "until", "while",
-    "//", "..", "...", "==", ">=", "<=", "~=",
-    "<<", ">>", "::", "<eof>",
-    "<number>", "<integer>", "<name>", "<string>"
-};
-
-
-#define save_and_next(ls) (save(ls, ls->current), next(ls))
-
-
-static l_noret lexerror (LexState *ls, const char *msg, int token);
-
-
-static void save (LexState *ls, int c) {
-  Mbuffer *b = ls->buff;
-  if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) {
-    size_t newsize;
-    if (luaZ_sizebuffer(b) >= MAX_SIZE/2)
-      lexerror(ls, "lexical element too long", 0);
-    newsize = luaZ_sizebuffer(b) * 2;
-    luaZ_resizebuffer(ls->L, b, newsize);
-  }
-  b->buffer[luaZ_bufflen(b)++] = cast(char, c);
-}
-
-
-void luaX_init (lua_State *L) {
-  int i;
-  TString *e = luaS_newliteral(L, LUA_ENV);  /* create env name */
-  luaC_fix(L, obj2gco(e));  /* never collect this name */
-  for (i=0; i<NUM_RESERVED; i++) {
-    TString *ts = luaS_new(L, luaX_tokens[i]);
-    luaC_fix(L, obj2gco(ts));  /* reserved words are never collected */
-    ts->extra = cast_byte(i+1);  /* reserved word */
-  }
-}
-
-
-const char *luaX_token2str (LexState *ls, int token) {
-  if (token < FIRST_RESERVED) {  /* single-byte symbols? */
-    lua_assert(token == cast_uchar(token));
-    return luaO_pushfstring(ls->L, "'%c'", token);
-  }
-  else {
-    const char *s = luaX_tokens[token - FIRST_RESERVED];
-    if (token < TK_EOS)  /* fixed format (symbols and reserved words)? */
-      return luaO_pushfstring(ls->L, "'%s'", s);
-    else  /* names, strings, and numerals */
-      return s;
-  }
-}
-
-
-static const char *txtToken (LexState *ls, int token) {
-  switch (token) {
-    case TK_NAME: case TK_STRING:
-    case TK_FLT: case TK_INT:
-      save(ls, '\0');
-      return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff));
-    default:
-      return luaX_token2str(ls, token);
-  }
-}
-
-
-static l_noret lexerror (LexState *ls, const char *msg, int token) {
-  msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber);
-  if (token)
-    luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token));
-  luaD_throw(ls->L, LUA_ERRSYNTAX);
-}
-
-
-l_noret luaX_syntaxerror (LexState *ls, const char *msg) {
-  lexerror(ls, msg, ls->t.token);
-}
-
-
-/*
-** creates a new string and anchors it in scanner's table so that
-** it will not be collected until the end of the compilation
-** (by that time it should be anchored somewhere)
-*/
-TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
-  lua_State *L = ls->L;
-  TValue *o;  /* entry for 'str' */
-  TString *ts = luaS_newlstr(L, str, l);  /* create new string */
-  setsvalue2s(L, L->top++, ts);  /* temporarily anchor it in stack */
-  o = luaH_set(L, ls->h, L->top - 1);
-  if (ttisnil(o)) {  /* not in use yet? */
-    /* boolean value does not need GC barrier;
-       table has no metatable, so it does not need to invalidate cache */
-    setbvalue(o, 1);  /* t[string] = true */
-    luaC_checkGC(L);
-  }
-  else {  /* string already present */
-    ts = tsvalue(keyfromval(o));  /* re-use value previously stored */
-  }
-  L->top--;  /* remove string from stack */
-  return ts;
-}
-
-
-/*
-** increment line number and skips newline sequence (any of
-** \n, \r, \n\r, or \r\n)
-*/
-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)
-    lexerror(ls, "chunk has too many lines", 0);
-}
-
-
-void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source,
-                    int firstchar) {
-  ls->t.token = 0;
-  ls->L = L;
-  ls->current = firstchar;
-  ls->lookahead.token = TK_EOS;  /* no look-ahead token */
-  ls->z = z;
-  ls->fs = NULL;
-  ls->linenumber = 1;
-  ls->lastline = 1;
-  ls->source = source;
-  ls->envn = luaS_newliteral(L, LUA_ENV);  /* get env name */
-  luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
-}
-
-
-
-/*
-** =======================================================
-** LEXICAL ANALYZER
-** =======================================================
-*/
-
-
-static int check_next1 (LexState *ls, int c) {
-  if (ls->current == c) {
-    next(ls);
-    return 1;
-  }
-  else return 0;
-}
-
-
-/*
-** Check whether current char is in set 'set' (with two chars) and
-** saves it
-*/
-static int check_next2 (LexState *ls, const char *set) {
-  lua_assert(set[2] == '\0');
-  if (ls->current == set[0] || ls->current == set[1]) {
-    save_and_next(ls);
-    return 1;
-  }
-  else return 0;
-}
-
-
-/* LUA_NUMBER */
-/*
-** this function is quite liberal in what it accepts, as 'luaO_str2num'
-** will reject ill-formed numerals.
-*/
-static int read_numeral (LexState *ls, SemInfo *seminfo) {
-  TValue obj;
-  const char *expo = "Ee";
-  int first = ls->current;
-  lua_assert(lisdigit(ls->current));
-  save_and_next(ls);
-  if (first == '0' && check_next2(ls, "xX"))  /* hexadecimal? */
-    expo = "Pp";
-  for (;;) {
-    if (check_next2(ls, expo))  /* exponent part? */
-      check_next2(ls, "-+");  /* optional exponent sign */
-    if (lisxdigit(ls->current))
-      save_and_next(ls);
-    else if (ls->current == '.')
-      save_and_next(ls);
-    else break;
-  }
-  save(ls, '\0');
-  if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0)  /* format error? */
-    lexerror(ls, "malformed number", TK_FLT);
-  if (ttisinteger(&obj)) {
-    seminfo->i = ivalue(&obj);
-    return TK_INT;
-  }
-  else {
-    lua_assert(ttisfloat(&obj));
-    seminfo->r = fltvalue(&obj);
-    return TK_FLT;
-  }
-}
-
-
-/*
-** skip a sequence '[=*[' or ']=*]'; if sequence is well formed, return
-** its number of '='s; otherwise, return a negative number (-1 iff there
-** are no '='s after initial bracket)
-*/
-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 line = ls->linenumber;  /* initial line (for error message) */
-  save_and_next(ls);  /* skip 2nd '[' */
-  if (currIsNewline(ls))  /* string starts with a newline? */
-    inclinenumber(ls);  /* skip it */
-  for (;;) {
-    switch (ls->current) {
-      case EOZ: {  /* error */
-        const char *what = (seminfo ? "string" : "comment");
-        const char *msg = luaO_pushfstring(ls->L,
-                     "unfinished long %s (starting at line %d)", what, line);
-        lexerror(ls, msg, TK_EOS);
-        break;  /* to avoid warnings */
-      }
-      case ']': {
-        if (skip_sep(ls) == sep) {
-          save_and_next(ls);  /* skip 2nd ']' */
-          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 esccheck (LexState *ls, int c, const char *msg) {
-  if (!c) {
-    if (ls->current != EOZ)
-      save_and_next(ls);  /* add current to buffer for error message */
-    lexerror(ls, msg, TK_STRING);
-  }
-}
-
-
-static int gethexa (LexState *ls) {
-  save_and_next(ls);
-  esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected");
-  return luaO_hexavalue(ls->current);
-}
-
-
-static int readhexaesc (LexState *ls) {
-  int r = gethexa(ls);
-  r = (r << 4) + gethexa(ls);
-  luaZ_buffremove(ls->buff, 2);  /* remove saved chars from buffer */
-  return r;
-}
-
-
-static unsigned long readutf8esc (LexState *ls) {
-  unsigned long r;
-  int i = 4;  /* chars to be removed: '\', 'u', '{', and first digit */
-  save_and_next(ls);  /* skip 'u' */
-  esccheck(ls, ls->current == '{', "missing '{'");
-  r = gethexa(ls);  /* must have at least one digit */
-  while ((save_and_next(ls), lisxdigit(ls->current))) {
-    i++;
-    r = (r << 4) + luaO_hexavalue(ls->current);
-    esccheck(ls, r <= 0x10FFFF, "UTF-8 value too large");
-  }
-  esccheck(ls, ls->current == '}', "missing '}'");
-  next(ls);  /* skip '}' */
-  luaZ_buffremove(ls->buff, i);  /* remove saved chars from buffer */
-  return r;
-}
-
-
-static void utf8esc (LexState *ls) {
-  char buff[UTF8BUFFSZ];
-  int n = luaO_utf8esc(buff, readutf8esc(ls));
-  for (; n > 0; n--)  /* add 'buff' to string */
-    save(ls, buff[UTF8BUFFSZ - n]);
-}
-
-
-static int readdecesc (LexState *ls) {
-  int i;
-  int r = 0;  /* result accumulator */
-  for (i = 0; i < 3 && lisdigit(ls->current); i++) {  /* read up to 3 digits */
-    r = 10*r + ls->current - '0';
-    save_and_next(ls);
-  }
-  esccheck(ls, r <= UCHAR_MAX, "decimal escape too large");
-  luaZ_buffremove(ls->buff, i);  /* remove read digits from buffer */
-  return r;
-}
-
-
-static void read_string (LexState *ls, int del, SemInfo *seminfo) {
-  save_and_next(ls);  /* keep delimiter (for error messages) */
-  while (ls->current != del) {
-    switch (ls->current) {
-      case EOZ:
-        lexerror(ls, "unfinished string", TK_EOS);
-        break;  /* to avoid warnings */
-      case '\n':
-      case '\r':
-        lexerror(ls, "unfinished string", TK_STRING);
-        break;  /* to avoid warnings */
-      case '\\': {  /* escape sequences */
-        int c;  /* final character to be saved */
-        save_and_next(ls);  /* keep '\\' for error messages */
-        switch (ls->current) {
-          case 'a': c = '\a'; goto read_save;
-          case 'b': c = '\b'; goto read_save;
-          case 'f': c = '\f'; goto read_save;
-          case 'n': c = '\n'; goto read_save;
-          case 'r': c = '\r'; goto read_save;
-          case 't': c = '\t'; goto read_save;
-          case 'v': c = '\v'; goto read_save;
-          case 'x': c = readhexaesc(ls); goto read_save;
-          case 'u': utf8esc(ls);  goto no_save;
-          case '\n': case '\r':
-            inclinenumber(ls); c = '\n'; goto only_save;
-          case '\\': case '\"': case '\'':
-            c = ls->current; goto read_save;
-          case EOZ: goto no_save;  /* will raise an error next loop */
-          case 'z': {  /* zap following span of spaces */
-            luaZ_buffremove(ls->buff, 1);  /* remove '\\' */
-            next(ls);  /* skip the 'z' */
-            while (lisspace(ls->current)) {
-              if (currIsNewline(ls)) inclinenumber(ls);
-              else next(ls);
-            }
-            goto no_save;
-          }
-          default: {
-            esccheck(ls, lisdigit(ls->current), "invalid escape sequence");
-            c = readdecesc(ls);  /* digital escape '\ddd' */
-            goto only_save;
-          }
-        }
-       read_save:
-         next(ls);
-         /* go through */
-       only_save:
-         luaZ_buffremove(ls->buff, 1);  /* remove '\\' */
-         save(ls, c);
-         /* go through */
-       no_save: break;
-      }
-      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': {  /* line breaks */
-        inclinenumber(ls);
-        break;
-      }
-      case ' ': case '\f': case '\t': case '\v': {  /* spaces */
-        next(ls);
-        break;
-      }
-      case '-': {  /* '-' or '--' (comment) */
-        next(ls);
-        if (ls->current != '-') return '-';
-        /* else is a comment */
-        next(ls);
-        if (ls->current == '[') {  /* long comment? */
-          int sep = skip_sep(ls);
-          luaZ_resetbuffer(ls->buff);  /* 'skip_sep' may dirty the buffer */
-          if (sep >= 0) {
-            read_long_string(ls, NULL, sep);  /* skip long comment */
-            luaZ_resetbuffer(ls->buff);  /* previous call may dirty the buff. */
-            break;
-          }
-        }
-        /* else short comment */
-        while (!currIsNewline(ls) && ls->current != EOZ)
-          next(ls);  /* skip until end of line (or end of file) */
-        break;
-      }
-      case '[': {  /* long string or simply '[' */
-        int sep = skip_sep(ls);
-        if (sep >= 0) {
-          read_long_string(ls, seminfo, sep);
-          return TK_STRING;
-        }
-        else if (sep != -1)  /* '[=...' missing second bracket */
-          lexerror(ls, "invalid long string delimiter", TK_STRING);
-        return '[';
-      }
-      case '=': {
-        next(ls);
-        if (check_next1(ls, '=')) return TK_EQ;
-        else return '=';
-      }
-      case '<': {
-        next(ls);
-        if (check_next1(ls, '=')) return TK_LE;
-        else if (check_next1(ls, '<')) return TK_SHL;
-        else return '<';
-      }
-      case '>': {
-        next(ls);
-        if (check_next1(ls, '=')) return TK_GE;
-        else if (check_next1(ls, '>')) return TK_SHR;
-        else return '>';
-      }
-      case '/': {
-        next(ls);
-        if (check_next1(ls, '/')) return TK_IDIV;
-        else return '/';
-      }
-      case '~': {
-        next(ls);
-        if (check_next1(ls, '=')) return TK_NE;
-        else return '~';
-      }
-      case ':': {
-        next(ls);
-        if (check_next1(ls, ':')) return TK_DBCOLON;
-        else return ':';
-      }
-      case '"': case '\'': {  /* short literal strings */
-        read_string(ls, ls->current, seminfo);
-        return TK_STRING;
-      }
-      case '.': {  /* '.', '..', '...', or number */
-        save_and_next(ls);
-        if (check_next1(ls, '.')) {
-          if (check_next1(ls, '.'))
-            return TK_DOTS;   /* '...' */
-          else return TK_CONCAT;   /* '..' */
-        }
-        else if (!lisdigit(ls->current)) return '.';
-        else return read_numeral(ls, seminfo);
-      }
-      case '0': case '1': case '2': case '3': case '4':
-      case '5': case '6': case '7': case '8': case '9': {
-        return read_numeral(ls, seminfo);
-      }
-      case EOZ: {
-        return TK_EOS;
-      }
-      default: {
-        if (lislalpha(ls->current)) {  /* identifier or reserved word? */
-          TString *ts;
-          do {
-            save_and_next(ls);
-          } while (lislalnum(ls->current));
-          ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
-                                  luaZ_bufflen(ls->buff));
-          seminfo->ts = ts;
-          if (isreserved(ts))  /* reserved word? */
-            return ts->extra - 1 + FIRST_RESERVED;
-          else {
-            return TK_NAME;
-          }
-        }
-        else {  /* single-char tokens (+ - / ...) */
-          int c = ls->current;
-          next(ls);
-          return c;
-        }
-      }
-    }
-  }
-}
-
-
-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 */
-}
-
-
-int luaX_lookahead (LexState *ls) {
-  lua_assert(ls->lookahead.token == TK_EOS);
-  ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
-  return ls->lookahead.token;
-}
-
diff --git a/lua/lua-5.3.5/src/llex.h b/lua/lua-5.3.5/src/llex.h
deleted file mode 100644
index 2ed0af6..0000000
--- a/lua/lua-5.3.5/src/llex.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-** $Id: llex.h,v 1.79.1.1 2017/04/19 17:20:42 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
-
-
-#if !defined(LUA_ENV)
-#define LUA_ENV		"_ENV"
-#endif
-
-
-/*
-* 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_GOTO, 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_IDIV, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE,
-  TK_SHL, TK_SHR,
-  TK_DBCOLON, TK_EOS,
-  TK_FLT, TK_INT, TK_NAME, TK_STRING
-};
-
-/* number of reserved words */
-#define NUM_RESERVED	(cast(int, TK_WHILE-FIRST_RESERVED+1))
-
-
-typedef union {
-  lua_Number r;
-  lua_Integer i;
-  TString *ts;
-} SemInfo;  /* semantics information */
-
-
-typedef struct Token {
-  int token;
-  SemInfo seminfo;
-} Token;
-
-
-/* state of the lexer plus state of the parser when shared by all
-   functions */
-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;  /* current function (parser) */
-  struct lua_State *L;
-  ZIO *z;  /* input stream */
-  Mbuffer *buff;  /* buffer for tokens */
-  Table *h;  /* to avoid collection/reuse strings */
-  struct Dyndata *dyd;  /* dynamic structures used by the parser */
-  TString *source;  /* current source name */
-  TString *envn;  /* environment variable name */
-} LexState;
-
-
-LUAI_FUNC void luaX_init (lua_State *L);
-LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
-                              TString *source, int firstchar);
-LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
-LUAI_FUNC void luaX_next (LexState *ls);
-LUAI_FUNC int luaX_lookahead (LexState *ls);
-LUAI_FUNC l_noret luaX_syntaxerror (LexState *ls, const char *s);
-LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
-
-
-#endif
diff --git a/lua/lua-5.3.5/src/llimits.h b/lua/lua-5.3.5/src/llimits.h
deleted file mode 100644
index d1036f6..0000000
--- a/lua/lua-5.3.5/src/llimits.h
+++ /dev/null
@@ -1,323 +0,0 @@
-/*
-** $Id: llimits.h,v 1.141.1.1 2017/04/19 17:20:42 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"
-
-/*
-** 'lu_mem' and 'l_mem' are unsigned/signed integers big enough to count
-** the total memory used by Lua (in bytes). Usually, 'size_t' and
-** 'ptrdiff_t' should work, but we use 'long' for 16-bit machines.
-*/
-#if defined(LUAI_MEM)		/* { external definitions? */
-typedef LUAI_UMEM lu_mem;
-typedef LUAI_MEM l_mem;
-#elif LUAI_BITSINT >= 32	/* }{ */
-typedef size_t lu_mem;
-typedef ptrdiff_t l_mem;
-#else  /* 16-bit ints */	/* }{ */
-typedef unsigned long lu_mem;
-typedef long l_mem;
-#endif				/* } */
-
-
-/* chars used as small naturals (so that 'char' is reserved for characters) */
-typedef unsigned char lu_byte;
-
-
-/* maximum value for size_t */
-#define MAX_SIZET	((size_t)(~(size_t)0))
-
-/* maximum size visible for Lua (must be representable in a lua_Integer */
-#define MAX_SIZE	(sizeof(size_t) < sizeof(lua_Integer) ? MAX_SIZET \
-                          : (size_t)(LUA_MAXINTEGER))
-
-
-#define MAX_LUMEM	((lu_mem)(~(lu_mem)0))
-
-#define MAX_LMEM	((l_mem)(MAX_LUMEM >> 1))
-
-
-#define MAX_INT		INT_MAX  /* maximum value of an int */
-
-
-/*
-** conversion of pointer to unsigned integer:
-** this is for hashing only; there is no problem if the integer
-** cannot hold the whole pointer value
-*/
-#define point2uint(p)	((unsigned int)((size_t)(p) & UINT_MAX))
-
-
-
-/* type to ensure maximum alignment */
-#if defined(LUAI_USER_ALIGNMENT_T)
-typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
-#else
-typedef union {
-  lua_Number n;
-  double u;
-  void *s;
-  lua_Integer i;
-  long l;
-} L_Umaxalign;
-#endif
-
-
-
-/* types of 'usual argument conversions' for lua_Number and lua_Integer */
-typedef LUAI_UACNUMBER l_uacNumber;
-typedef LUAI_UACINT l_uacInt;
-
-
-/* internal assertions for in-house debugging */
-#if defined(lua_assert)
-#define check_exp(c,e)		(lua_assert(c), (e))
-/* to avoid problems with conditions too long */
-#define lua_longassert(c)	((c) ? (void)0 : lua_assert(0))
-#else
-#define lua_assert(c)		((void)0)
-#define check_exp(c,e)		(e)
-#define lua_longassert(c)	((void)0)
-#endif
-
-/*
-** assertion for checking API calls
-*/
-#if !defined(luai_apicheck)
-#define luai_apicheck(l,e)	lua_assert(e)
-#endif
-
-#define api_check(l,e,msg)	luai_apicheck(l,(e) && msg)
-
-
-/* macro to avoid warnings about unused variables */
-#if !defined(UNUSED)
-#define UNUSED(x)	((void)(x))
-#endif
-
-
-/* type casts (a macro highlights casts in the code) */
-#define cast(t, exp)	((t)(exp))
-
-#define cast_void(i)	cast(void, (i))
-#define cast_byte(i)	cast(lu_byte, (i))
-#define cast_num(i)	cast(lua_Number, (i))
-#define cast_int(i)	cast(int, (i))
-#define cast_uchar(i)	cast(unsigned char, (i))
-
-
-/* cast a signed lua_Integer to lua_Unsigned */
-#if !defined(l_castS2U)
-#define l_castS2U(i)	((lua_Unsigned)(i))
-#endif
-
-/*
-** cast a lua_Unsigned to a signed lua_Integer; this cast is
-** not strict ISO C, but two-complement architectures should
-** work fine.
-*/
-#if !defined(l_castU2S)
-#define l_castU2S(i)	((lua_Integer)(i))
-#endif
-
-
-/*
-** non-return type
-*/
-#if defined(__GNUC__)
-#define l_noret		void __attribute__((noreturn))
-#elif defined(_MSC_VER) && _MSC_VER >= 1200
-#define l_noret		void __declspec(noreturn)
-#else
-#define l_noret		void
-#endif
-
-
-
-/*
-** maximum depth for nested C calls and syntactical nested non-terminals
-** in a program. (Value must fit in an unsigned short int.)
-*/
-#if !defined(LUAI_MAXCCALLS)
-#define LUAI_MAXCCALLS		200
-#endif
-
-
-
-/*
-** type for virtual-machine instructions;
-** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
-*/
-#if LUAI_BITSINT >= 32
-typedef unsigned int Instruction;
-#else
-typedef unsigned long Instruction;
-#endif
-
-
-
-/*
-** Maximum length for short strings, that is, strings that are
-** internalized. (Cannot be smaller than reserved words or tags for
-** metamethods, as these strings must be internalized;
-** #("function") = 8, #("__newindex") = 10.)
-*/
-#if !defined(LUAI_MAXSHORTLEN)
-#define LUAI_MAXSHORTLEN	40
-#endif
-
-
-/*
-** Initial size for the string table (must be power of 2).
-** The Lua core alone registers ~50 strings (reserved words +
-** metaevent keys + a few others). Libraries would typically add
-** a few dozens more.
-*/
-#if !defined(MINSTRTABSIZE)
-#define MINSTRTABSIZE	128
-#endif
-
-
-/*
-** Size of cache for strings in the API. 'N' is the number of
-** sets (better be a prime) and "M" is the size of each set (M == 1
-** makes a direct cache.)
-*/
-#if !defined(STRCACHE_N)
-#define STRCACHE_N		53
-#define STRCACHE_M		2
-#endif
-
-
-/* minimum size for string buffer */
-#if !defined(LUA_MINBUFFER)
-#define LUA_MINBUFFER	32
-#endif
-
-
-/*
-** macros that are executed whenever program enters the Lua core
-** ('lua_lock') and leaves the core ('lua_unlock')
-*/
-#if !defined(lua_lock)
-#define lua_lock(L)	((void) 0)
-#define lua_unlock(L)	((void) 0)
-#endif
-
-/*
-** macro executed during Lua functions at points where the
-** function can yield.
-*/
-#if !defined(luai_threadyield)
-#define luai_threadyield(L)	{lua_unlock(L); lua_lock(L);}
-#endif
-
-
-/*
-** these macros allow user-specific actions on threads when you defined
-** LUAI_EXTRASPACE and need to do something extra when a thread is
-** created/deleted/resumed/yielded.
-*/
-#if !defined(luai_userstateopen)
-#define luai_userstateopen(L)		((void)L)
-#endif
-
-#if !defined(luai_userstateclose)
-#define luai_userstateclose(L)		((void)L)
-#endif
-
-#if !defined(luai_userstatethread)
-#define luai_userstatethread(L,L1)	((void)L)
-#endif
-
-#if !defined(luai_userstatefree)
-#define luai_userstatefree(L,L1)	((void)L)
-#endif
-
-#if !defined(luai_userstateresume)
-#define luai_userstateresume(L,n)	((void)L)
-#endif
-
-#if !defined(luai_userstateyield)
-#define luai_userstateyield(L,n)	((void)L)
-#endif
-
-
-
-/*
-** The luai_num* macros define the primitive operations over numbers.
-*/
-
-/* floor division (defined as 'floor(a/b)') */
-#if !defined(luai_numidiv)
-#define luai_numidiv(L,a,b)     ((void)L, l_floor(luai_numdiv(L,a,b)))
-#endif
-
-/* float division */
-#if !defined(luai_numdiv)
-#define luai_numdiv(L,a,b)      ((a)/(b))
-#endif
-
-/*
-** modulo: defined as 'a - floor(a/b)*b'; this definition gives NaN when
-** 'b' is huge, but the result should be 'a'. 'fmod' gives the result of
-** 'a - trunc(a/b)*b', and therefore must be corrected when 'trunc(a/b)
-** ~= floor(a/b)'. That happens when the division has a non-integer
-** negative result, which is equivalent to the test below.
-*/
-#if !defined(luai_nummod)
-#define luai_nummod(L,a,b,m)  \
-  { (m) = l_mathop(fmod)(a,b); if ((m)*(b) < 0) (m) += (b); }
-#endif
-
-/* exponentiation */
-#if !defined(luai_numpow)
-#define luai_numpow(L,a,b)      ((void)L, l_mathop(pow)(a,b))
-#endif
-
-/* the others are quite standard operations */
-#if !defined(luai_numadd)
-#define luai_numadd(L,a,b)      ((a)+(b))
-#define luai_numsub(L,a,b)      ((a)-(b))
-#define luai_nummul(L,a,b)      ((a)*(b))
-#define luai_numunm(L,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
-
-
-
-
-
-/*
-** macro to control inclusion of some hard tests on stack reallocation
-*/
-#if !defined(HARDSTACKTESTS)
-#define condmovestack(L,pre,pos)	((void)0)
-#else
-/* realloc stack keeping its size */
-#define condmovestack(L,pre,pos)  \
-	{ int sz_ = (L)->stacksize; pre; luaD_reallocstack((L), sz_); pos; }
-#endif
-
-#if !defined(HARDMEMTESTS)
-#define condchangemem(L,pre,pos)	((void)0)
-#else
-#define condchangemem(L,pre,pos)  \
-	{ if (G(L)->gcrunning) { pre; luaC_fullgc(L, 0); pos; } }
-#endif
-
-#endif
diff --git a/lua/lua-5.3.5/src/lmathlib.c b/lua/lua-5.3.5/src/lmathlib.c
deleted file mode 100644
index 7ef7e59..0000000
--- a/lua/lua-5.3.5/src/lmathlib.c
+++ /dev/null
@@ -1,410 +0,0 @@
-/*
-** $Id: lmathlib.c,v 1.119.1.1 2017/04/19 17:20:42 roberto Exp $
-** Standard mathematical library
-** See Copyright Notice in lua.h
-*/
-
-#define lmathlib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <stdlib.h>
-#include <math.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-#undef PI
-#define PI	(l_mathop(3.141592653589793238462643383279502884))
-
-
-#if !defined(l_rand)		/* { */
-#if defined(LUA_USE_POSIX)
-#define l_rand()	random()
-#define l_srand(x)	srandom(x)
-#define L_RANDMAX	2147483647	/* (2^31 - 1), following POSIX */
-#else
-#define l_rand()	rand()
-#define l_srand(x)	srand(x)
-#define L_RANDMAX	RAND_MAX
-#endif
-#endif				/* } */
-
-
-static int math_abs (lua_State *L) {
-  if (lua_isinteger(L, 1)) {
-    lua_Integer n = lua_tointeger(L, 1);
-    if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n);
-    lua_pushinteger(L, n);
-  }
-  else
-    lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_sin (lua_State *L) {
-  lua_pushnumber(L, l_mathop(sin)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_cos (lua_State *L) {
-  lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_tan (lua_State *L) {
-  lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_asin (lua_State *L) {
-  lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_acos (lua_State *L) {
-  lua_pushnumber(L, l_mathop(acos)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_atan (lua_State *L) {
-  lua_Number y = luaL_checknumber(L, 1);
-  lua_Number x = luaL_optnumber(L, 2, 1);
-  lua_pushnumber(L, l_mathop(atan2)(y, x));
-  return 1;
-}
-
-
-static int math_toint (lua_State *L) {
-  int valid;
-  lua_Integer n = lua_tointegerx(L, 1, &valid);
-  if (valid)
-    lua_pushinteger(L, n);
-  else {
-    luaL_checkany(L, 1);
-    lua_pushnil(L);  /* value is not convertible to integer */
-  }
-  return 1;
-}
-
-
-static void pushnumint (lua_State *L, lua_Number d) {
-  lua_Integer n;
-  if (lua_numbertointeger(d, &n))  /* does 'd' fit in an integer? */
-    lua_pushinteger(L, n);  /* result is integer */
-  else
-    lua_pushnumber(L, d);  /* result is float */
-}
-
-
-static int math_floor (lua_State *L) {
-  if (lua_isinteger(L, 1))
-    lua_settop(L, 1);  /* integer is its own floor */
-  else {
-    lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1));
-    pushnumint(L, d);
-  }
-  return 1;
-}
-
-
-static int math_ceil (lua_State *L) {
-  if (lua_isinteger(L, 1))
-    lua_settop(L, 1);  /* integer is its own ceil */
-  else {
-    lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1));
-    pushnumint(L, d);
-  }
-  return 1;
-}
-
-
-static int math_fmod (lua_State *L) {
-  if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
-    lua_Integer d = lua_tointeger(L, 2);
-    if ((lua_Unsigned)d + 1u <= 1u) {  /* special cases: -1 or 0 */
-      luaL_argcheck(L, d != 0, 2, "zero");
-      lua_pushinteger(L, 0);  /* avoid overflow with 0x80000... / -1 */
-    }
-    else
-      lua_pushinteger(L, lua_tointeger(L, 1) % d);
-  }
-  else
-    lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
-                                     luaL_checknumber(L, 2)));
-  return 1;
-}
-
-
-/*
-** next function does not use 'modf', avoiding problems with 'double*'
-** (which is not compatible with 'float*') when lua_Number is not
-** 'double'.
-*/
-static int math_modf (lua_State *L) {
-  if (lua_isinteger(L ,1)) {
-    lua_settop(L, 1);  /* number is its own integer part */
-    lua_pushnumber(L, 0);  /* no fractional part */
-  }
-  else {
-    lua_Number n = luaL_checknumber(L, 1);
-    /* integer part (rounds toward zero) */
-    lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n);
-    pushnumint(L, ip);
-    /* fractional part (test needed for inf/-inf) */
-    lua_pushnumber(L, (n == ip) ? l_mathop(0.0) : (n - ip));
-  }
-  return 2;
-}
-
-
-static int math_sqrt (lua_State *L) {
-  lua_pushnumber(L, l_mathop(sqrt)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-
-static int math_ult (lua_State *L) {
-  lua_Integer a = luaL_checkinteger(L, 1);
-  lua_Integer b = luaL_checkinteger(L, 2);
-  lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b);
-  return 1;
-}
-
-static int math_log (lua_State *L) {
-  lua_Number x = luaL_checknumber(L, 1);
-  lua_Number res;
-  if (lua_isnoneornil(L, 2))
-    res = l_mathop(log)(x);
-  else {
-    lua_Number base = luaL_checknumber(L, 2);
-#if !defined(LUA_USE_C89)
-    if (base == l_mathop(2.0))
-      res = l_mathop(log2)(x); else
-#endif
-    if (base == l_mathop(10.0))
-      res = l_mathop(log10)(x);
-    else
-      res = l_mathop(log)(x)/l_mathop(log)(base);
-  }
-  lua_pushnumber(L, res);
-  return 1;
-}
-
-static int math_exp (lua_State *L) {
-  lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_deg (lua_State *L) {
-  lua_pushnumber(L, luaL_checknumber(L, 1) * (l_mathop(180.0) / PI));
-  return 1;
-}
-
-static int math_rad (lua_State *L) {
-  lua_pushnumber(L, luaL_checknumber(L, 1) * (PI / l_mathop(180.0)));
-  return 1;
-}
-
-
-static int math_min (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  int imin = 1;  /* index of current minimum value */
-  int i;
-  luaL_argcheck(L, n >= 1, 1, "value expected");
-  for (i = 2; i <= n; i++) {
-    if (lua_compare(L, i, imin, LUA_OPLT))
-      imin = i;
-  }
-  lua_pushvalue(L, imin);
-  return 1;
-}
-
-
-static int math_max (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  int imax = 1;  /* index of current maximum value */
-  int i;
-  luaL_argcheck(L, n >= 1, 1, "value expected");
-  for (i = 2; i <= n; i++) {
-    if (lua_compare(L, imax, i, LUA_OPLT))
-      imax = i;
-  }
-  lua_pushvalue(L, imax);
-  return 1;
-}
-
-/*
-** This function uses 'double' (instead of 'lua_Number') to ensure that
-** all bits from 'l_rand' can be represented, and that 'RANDMAX + 1.0'
-** will keep full precision (ensuring that 'r' is always less than 1.0.)
-*/
-static int math_random (lua_State *L) {
-  lua_Integer low, up;
-  double r = (double)l_rand() * (1.0 / ((double)L_RANDMAX + 1.0));
-  switch (lua_gettop(L)) {  /* check number of arguments */
-    case 0: {  /* no arguments */
-      lua_pushnumber(L, (lua_Number)r);  /* Number between 0 and 1 */
-      return 1;
-    }
-    case 1: {  /* only upper limit */
-      low = 1;
-      up = luaL_checkinteger(L, 1);
-      break;
-    }
-    case 2: {  /* lower and upper limits */
-      low = luaL_checkinteger(L, 1);
-      up = luaL_checkinteger(L, 2);
-      break;
-    }
-    default: return luaL_error(L, "wrong number of arguments");
-  }
-  /* random integer in the interval [low, up] */
-  luaL_argcheck(L, low <= up, 1, "interval is empty");
-  luaL_argcheck(L, low >= 0 || up <= LUA_MAXINTEGER + low, 1,
-                   "interval too large");
-  r *= (double)(up - low) + 1.0;
-  lua_pushinteger(L, (lua_Integer)r + low);
-  return 1;
-}
-
-
-static int math_randomseed (lua_State *L) {
-  l_srand((unsigned int)(lua_Integer)luaL_checknumber(L, 1));
-  (void)l_rand(); /* discard first value to avoid undesirable correlations */
-  return 0;
-}
-
-
-static int math_type (lua_State *L) {
-  if (lua_type(L, 1) == LUA_TNUMBER) {
-      if (lua_isinteger(L, 1))
-        lua_pushliteral(L, "integer");
-      else
-        lua_pushliteral(L, "float");
-  }
-  else {
-    luaL_checkany(L, 1);
-    lua_pushnil(L);
-  }
-  return 1;
-}
-
-
-/*
-** {==================================================================
-** Deprecated functions (for compatibility only)
-** ===================================================================
-*/
-#if defined(LUA_COMPAT_MATHLIB)
-
-static int math_cosh (lua_State *L) {
-  lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_sinh (lua_State *L) {
-  lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_tanh (lua_State *L) {
-  lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_pow (lua_State *L) {
-  lua_Number x = luaL_checknumber(L, 1);
-  lua_Number y = luaL_checknumber(L, 2);
-  lua_pushnumber(L, l_mathop(pow)(x, y));
-  return 1;
-}
-
-static int math_frexp (lua_State *L) {
-  int e;
-  lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e));
-  lua_pushinteger(L, e);
-  return 2;
-}
-
-static int math_ldexp (lua_State *L) {
-  lua_Number x = luaL_checknumber(L, 1);
-  int ep = (int)luaL_checkinteger(L, 2);
-  lua_pushnumber(L, l_mathop(ldexp)(x, ep));
-  return 1;
-}
-
-static int math_log10 (lua_State *L) {
-  lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-#endif
-/* }================================================================== */
-
-
-
-static const luaL_Reg mathlib[] = {
-  {"abs",   math_abs},
-  {"acos",  math_acos},
-  {"asin",  math_asin},
-  {"atan",  math_atan},
-  {"ceil",  math_ceil},
-  {"cos",   math_cos},
-  {"deg",   math_deg},
-  {"exp",   math_exp},
-  {"tointeger", math_toint},
-  {"floor", math_floor},
-  {"fmod",   math_fmod},
-  {"ult",   math_ult},
-  {"log",   math_log},
-  {"max",   math_max},
-  {"min",   math_min},
-  {"modf",   math_modf},
-  {"rad",   math_rad},
-  {"random",     math_random},
-  {"randomseed", math_randomseed},
-  {"sin",   math_sin},
-  {"sqrt",  math_sqrt},
-  {"tan",   math_tan},
-  {"type", math_type},
-#if defined(LUA_COMPAT_MATHLIB)
-  {"atan2", math_atan},
-  {"cosh",   math_cosh},
-  {"sinh",   math_sinh},
-  {"tanh",   math_tanh},
-  {"pow",   math_pow},
-  {"frexp", math_frexp},
-  {"ldexp", math_ldexp},
-  {"log10", math_log10},
-#endif
-  /* placeholders */
-  {"pi", NULL},
-  {"huge", NULL},
-  {"maxinteger", NULL},
-  {"mininteger", NULL},
-  {NULL, NULL}
-};
-
-
-/*
-** Open math library
-*/
-LUAMOD_API int luaopen_math (lua_State *L) {
-  luaL_newlib(L, mathlib);
-  lua_pushnumber(L, PI);
-  lua_setfield(L, -2, "pi");
-  lua_pushnumber(L, (lua_Number)HUGE_VAL);
-  lua_setfield(L, -2, "huge");
-  lua_pushinteger(L, LUA_MAXINTEGER);
-  lua_setfield(L, -2, "maxinteger");
-  lua_pushinteger(L, LUA_MININTEGER);
-  lua_setfield(L, -2, "mininteger");
-  return 1;
-}
-
diff --git a/lua/lua-5.3.5/src/lmem.c b/lua/lua-5.3.5/src/lmem.c
deleted file mode 100644
index 0241cc3..0000000
--- a/lua/lua-5.3.5/src/lmem.c
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
-** $Id: lmem.c,v 1.91.1.1 2017/04/19 17:20:42 roberto Exp $
-** Interface to Memory Manager
-** See Copyright Notice in lua.h
-*/
-
-#define lmem_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <stddef.h>
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lgc.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)
-**
-** * frealloc(ud, NULL, x, s) creates a new block of size 's' (no
-** matter '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 ISO 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 *what) {
-  void *newblock;
-  int newsize;
-  if (*size >= limit/2) {  /* cannot double it? */
-    if (*size >= limit)  /* cannot grow even a little? */
-      luaG_runerror(L, "too many %s (limit is %d)", what, limit);
-    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;
-}
-
-
-l_noret luaM_toobig (lua_State *L) {
-  luaG_runerror(L, "memory allocation error: block too big");
-}
-
-
-
-/*
-** generic allocation routine.
-*/
-void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
-  void *newblock;
-  global_State *g = G(L);
-  size_t realosize = (block) ? osize : 0;
-  lua_assert((realosize == 0) == (block == NULL));
-#if defined(HARDMEMTESTS)
-  if (nsize > realosize && g->gcrunning)
-    luaC_fullgc(L, 1);  /* force a GC whenever possible */
-#endif
-  newblock = (*g->frealloc)(g->ud, block, osize, nsize);
-  if (newblock == NULL && nsize > 0) {
-    lua_assert(nsize > realosize);  /* cannot fail when shrinking a block */
-    if (g->version) {  /* is state fully built? */
-      luaC_fullgc(L, 1);  /* try to free some memory... */
-      newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
-    }
-    if (newblock == NULL)
-      luaD_throw(L, LUA_ERRMEM);
-  }
-  lua_assert((nsize == 0) == (newblock == NULL));
-  g->GCdebt = (g->GCdebt + nsize) - realosize;
-  return newblock;
-}
-
diff --git a/lua/lua-5.3.5/src/lmem.h b/lua/lua-5.3.5/src/lmem.h
deleted file mode 100644
index 357b1e4..0000000
--- a/lua/lua-5.3.5/src/lmem.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
-** $Id: lmem.h,v 1.43.1.1 2017/04/19 17:20:42 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"
-
-
-/*
-** This macro reallocs a vector 'b' from 'on' to 'n' elements, where
-** each element has size 'e'. In case of arithmetic overflow of the
-** product 'n'*'e', it raises an error (calling 'luaM_toobig'). Because
-** 'e' is always constant, it avoids the runtime division MAX_SIZET/(e).
-**
-** (The macro is somewhat complex to avoid warnings:  The 'sizeof'
-** comparison avoids a runtime comparison when overflow cannot occur.
-** The compiler should be able to optimize the real test by itself, but
-** when it does it, it may give a warning about "comparison is always
-** false due to limited range of data type"; the +1 tricks the compiler,
-** avoiding this warning but also this optimization.)
-*/
-#define luaM_reallocv(L,b,on,n,e) \
-  (((sizeof(n) >= sizeof(size_t) && cast(size_t, (n)) + 1 > MAX_SIZET/(e)) \
-      ? luaM_toobig(L) : cast_void(0)) , \
-   luaM_realloc_(L, (b), (on)*(e), (n)*(e)))
-
-/*
-** Arrays of chars do not need any test
-*/
-#define luaM_reallocvchar(L,b,on,n)  \
-    cast(char *, luaM_realloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char)))
-
-#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)   luaM_realloc_(L, (b), (n)*sizeof(*(b)), 0)
-
-#define luaM_malloc(L,s)	luaM_realloc_(L, NULL, 0, (s))
-#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_newobject(L,tag,s)	luaM_realloc_(L, NULL, tag, (s))
-
-#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 l_noret luaM_toobig (lua_State *L);
-
-/* not to be called directly */
-LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
-                                                          size_t size);
-LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,
-                               size_t size_elem, int limit,
-                               const char *what);
-
-#endif
-
diff --git a/lua/lua-5.3.5/src/loadlib.c b/lua/lua-5.3.5/src/loadlib.c
deleted file mode 100644
index 45f44d3..0000000
--- a/lua/lua-5.3.5/src/loadlib.c
+++ /dev/null
@@ -1,790 +0,0 @@
-/*
-** $Id: loadlib.c,v 1.130.1.1 2017/04/19 17:20:42 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 Windows, and a stub for other
-** systems.
-*/
-
-#define loadlib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/*
-** LUA_IGMARK is a mark to ignore all before it when building the
-** luaopen_ function name.
-*/
-#if !defined (LUA_IGMARK)
-#define LUA_IGMARK		"-"
-#endif
-
-
-/*
-** LUA_CSUBSEP is the character that replaces dots in submodule names
-** when searching for a C loader.
-** LUA_LSUBSEP is the character that replaces dots in submodule names
-** when searching for a Lua loader.
-*/
-#if !defined(LUA_CSUBSEP)
-#define LUA_CSUBSEP		LUA_DIRSEP
-#endif
-
-#if !defined(LUA_LSUBSEP)
-#define LUA_LSUBSEP		LUA_DIRSEP
-#endif
-
-
-/* prefix for open functions in C libraries */
-#define LUA_POF		"luaopen_"
-
-/* separator for open functions in C libraries */
-#define LUA_OFSEP	"_"
-
-
-/*
-** unique key for table in the registry that keeps handles
-** for all loaded C libraries
-*/
-static const int CLIBS = 0;
-
-#define LIB_FAIL	"open"
-
-
-#define setprogdir(L)           ((void)0)
-
-
-/*
-** system-dependent functions
-*/
-
-/*
-** unload library 'lib'
-*/
-static void lsys_unloadlib (void *lib);
-
-/*
-** load C library in file 'path'. If 'seeglb', load with all names in
-** the library global.
-** Returns the library; in case of error, returns NULL plus an
-** error string in the stack.
-*/
-static void *lsys_load (lua_State *L, const char *path, int seeglb);
-
-/*
-** Try to find a function named 'sym' in library 'lib'.
-** Returns the function; in case of error, returns NULL plus an
-** error string in the stack.
-*/
-static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym);
-
-
-
-
-#if defined(LUA_USE_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>
-
-/*
-** Macro to convert pointer-to-void* to pointer-to-function. This cast
-** is undefined according to ISO C, but POSIX assumes that it works.
-** (The '__extension__' in gnu compilers is only to avoid warnings.)
-*/
-#if defined(__GNUC__)
-#define cast_func(p) (__extension__ (lua_CFunction)(p))
-#else
-#define cast_func(p) ((lua_CFunction)(p))
-#endif
-
-
-static void lsys_unloadlib (void *lib) {
-  dlclose(lib);
-}
-
-
-static void *lsys_load (lua_State *L, const char *path, int seeglb) {
-  void *lib = dlopen(path, RTLD_NOW | (seeglb ? RTLD_GLOBAL : RTLD_LOCAL));
-  if (lib == NULL) lua_pushstring(L, dlerror());
-  return lib;
-}
-
-
-static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
-  lua_CFunction f = cast_func(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>
-
-
-/*
-** optional flags for LoadLibraryEx
-*/
-#if !defined(LUA_LLE_FLAGS)
-#define LUA_LLE_FLAGS	0
-#endif
-
-
-#undef setprogdir
-
-
-/*
-** Replace in the path (on the top of the stack) any occurrence
-** of LUA_EXEC_DIR with the executable's path.
-*/
-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);  /* get exec. name */
-  if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL)
-    luaL_error(L, "unable to get ModuleFileName");
-  else {
-    *lb = '\0';  /* cut name on the last '\\' to get the path */
-    luaL_gsub(L, lua_tostring(L, -1), LUA_EXEC_DIR, 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)/sizeof(char), NULL))
-    lua_pushstring(L, buffer);
-  else
-    lua_pushfstring(L, "system error %d\n", error);
-}
-
-static void lsys_unloadlib (void *lib) {
-  FreeLibrary((HMODULE)lib);
-}
-
-
-static void *lsys_load (lua_State *L, const char *path, int seeglb) {
-  HMODULE lib = LoadLibraryExA(path, NULL, LUA_LLE_FLAGS);
-  (void)(seeglb);  /* not used: symbols are 'global' by default */
-  if (lib == NULL) pusherror(L);
-  return lib;
-}
-
-
-static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
-  lua_CFunction f = (lua_CFunction)GetProcAddress((HMODULE)lib, sym);
-  if (f == NULL) pusherror(L);
-  return f;
-}
-
-/* }====================================================== */
-
-
-#else				/* }{ */
-/*
-** {======================================================
-** Fallback for other systems
-** =======================================================
-*/
-
-#undef LIB_FAIL
-#define LIB_FAIL	"absent"
-
-
-#define DLMSG	"dynamic libraries not enabled; check your Lua installation"
-
-
-static void lsys_unloadlib (void *lib) {
-  (void)(lib);  /* not used */
-}
-
-
-static void *lsys_load (lua_State *L, const char *path, int seeglb) {
-  (void)(path); (void)(seeglb);  /* not used */
-  lua_pushliteral(L, DLMSG);
-  return NULL;
-}
-
-
-static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
-  (void)(lib); (void)(sym);  /* not used */
-  lua_pushliteral(L, DLMSG);
-  return NULL;
-}
-
-/* }====================================================== */
-#endif				/* } */
-
-
-/*
-** {==================================================================
-** Set Paths
-** ===================================================================
-*/
-
-/*
-** LUA_PATH_VAR and LUA_CPATH_VAR are the names of the environment
-** variables that Lua check to set its paths.
-*/
-#if !defined(LUA_PATH_VAR)
-#define LUA_PATH_VAR    "LUA_PATH"
-#endif
-
-#if !defined(LUA_CPATH_VAR)
-#define LUA_CPATH_VAR   "LUA_CPATH"
-#endif
-
-
-#define AUXMARK         "\1"	/* auxiliary mark */
-
-
-/*
-** return registry.LUA_NOENV as a boolean
-*/
-static int noenv (lua_State *L) {
-  int b;
-  lua_getfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
-  b = lua_toboolean(L, -1);
-  lua_pop(L, 1);  /* remove value */
-  return b;
-}
-
-
-/*
-** Set a path
-*/
-static void setpath (lua_State *L, const char *fieldname,
-                                   const char *envname,
-                                   const char *dft) {
-  const char *nver = lua_pushfstring(L, "%s%s", envname, LUA_VERSUFFIX);
-  const char *path = getenv(nver);  /* use versioned name */
-  if (path == NULL)  /* no environment variable? */
-    path = getenv(envname);  /* try unversioned name */
-  if (path == NULL || noenv(L))  /* no environment variable? */
-    lua_pushstring(L, dft);  /* use default */
-  else {
-    /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
-    path = luaL_gsub(L, path, LUA_PATH_SEP LUA_PATH_SEP,
-                              LUA_PATH_SEP AUXMARK LUA_PATH_SEP);
-    luaL_gsub(L, path, AUXMARK, dft);
-    lua_remove(L, -2); /* remove result from 1st 'gsub' */
-  }
-  setprogdir(L);
-  lua_setfield(L, -3, fieldname);  /* package[fieldname] = path value */
-  lua_pop(L, 1);  /* pop versioned variable name */
-}
-
-/* }================================================================== */
-
-
-/*
-** return registry.CLIBS[path]
-*/
-static void *checkclib (lua_State *L, const char *path) {
-  void *plib;
-  lua_rawgetp(L, LUA_REGISTRYINDEX, &CLIBS);
-  lua_getfield(L, -1, path);
-  plib = lua_touserdata(L, -1);  /* plib = CLIBS[path] */
-  lua_pop(L, 2);  /* pop CLIBS table and 'plib' */
-  return plib;
-}
-
-
-/*
-** registry.CLIBS[path] = plib        -- for queries
-** registry.CLIBS[#CLIBS + 1] = plib  -- also keep a list of all libraries
-*/
-static void addtoclib (lua_State *L, const char *path, void *plib) {
-  lua_rawgetp(L, LUA_REGISTRYINDEX, &CLIBS);
-  lua_pushlightuserdata(L, plib);
-  lua_pushvalue(L, -1);
-  lua_setfield(L, -3, path);  /* CLIBS[path] = plib */
-  lua_rawseti(L, -2, luaL_len(L, -2) + 1);  /* CLIBS[#CLIBS + 1] = plib */
-  lua_pop(L, 1);  /* pop CLIBS table */
-}
-
-
-/*
-** __gc tag method for CLIBS table: calls 'lsys_unloadlib' for all lib
-** handles in list CLIBS
-*/
-static int gctm (lua_State *L) {
-  lua_Integer n = luaL_len(L, 1);
-  for (; n >= 1; n--) {  /* for each handle, in reverse order */
-    lua_rawgeti(L, 1, n);  /* get handle CLIBS[n] */
-    lsys_unloadlib(lua_touserdata(L, -1));
-    lua_pop(L, 1);  /* pop handle */
-  }
-  return 0;
-}
-
-
-
-/* error codes for 'lookforfunc' */
-#define ERRLIB		1
-#define ERRFUNC		2
-
-/*
-** Look for a C function named 'sym' in a dynamically loaded library
-** 'path'.
-** First, check whether the library is already loaded; if not, try
-** to load it.
-** Then, if 'sym' is '*', return true (as library has been loaded).
-** Otherwise, look for symbol 'sym' in the library and push a
-** C function with that symbol.
-** Return 0 and 'true' or a function in the stack; in case of
-** errors, return an error code and an error message in the stack.
-*/
-static int lookforfunc (lua_State *L, const char *path, const char *sym) {
-  void *reg = checkclib(L, path);  /* check loaded C libraries */
-  if (reg == NULL) {  /* must load library? */
-    reg = lsys_load(L, path, *sym == '*');  /* global symbols if 'sym'=='*' */
-    if (reg == NULL) return ERRLIB;  /* unable to load library */
-    addtoclib(L, path, reg);
-  }
-  if (*sym == '*') {  /* loading only library (no function)? */
-    lua_pushboolean(L, 1);  /* return 'true' */
-    return 0;  /* no errors */
-  }
-  else {
-    lua_CFunction f = lsys_sym(L, reg, sym);
-    if (f == NULL)
-      return ERRFUNC;  /* unable to find function */
-    lua_pushcfunction(L, f);  /* else create new function */
-    return 0;  /* no errors */
-  }
-}
-
-
-static int ll_loadlib (lua_State *L) {
-  const char *path = luaL_checkstring(L, 1);
-  const char *init = luaL_checkstring(L, 2);
-  int stat = lookforfunc(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_PATH_SEP) path++;  /* skip separators */
-  if (*path == '\0') return NULL;  /* no more templates */
-  l = strchr(path, *LUA_PATH_SEP);  /* find next separator */
-  if (l == NULL) l = path + strlen(path);
-  lua_pushlstring(L, path, l - path);  /* template */
-  return l;
-}
-
-
-static const char *searchpath (lua_State *L, const char *name,
-                                             const char *path,
-                                             const char *sep,
-                                             const char *dirsep) {
-  luaL_Buffer msg;  /* to build error message */
-  luaL_buffinit(L, &msg);
-  if (*sep != '\0')  /* non-empty separator? */
-    name = luaL_gsub(L, name, sep, dirsep);  /* replace it by 'dirsep' */
-  while ((path = pushnexttemplate(L, path)) != NULL) {
-    const char *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 '%s'", filename);
-    lua_remove(L, -2);  /* remove file name */
-    luaL_addvalue(&msg);  /* concatenate error msg. entry */
-  }
-  luaL_pushresult(&msg);  /* create error message */
-  return NULL;  /* not found */
-}
-
-
-static int ll_searchpath (lua_State *L) {
-  const char *f = searchpath(L, luaL_checkstring(L, 1),
-                                luaL_checkstring(L, 2),
-                                luaL_optstring(L, 3, "."),
-                                luaL_optstring(L, 4, LUA_DIRSEP));
-  if (f != NULL) return 1;
-  else {  /* error message is on top of the stack */
-    lua_pushnil(L);
-    lua_insert(L, -2);
-    return 2;  /* return nil + error message */
-  }
-}
-
-
-static const char *findfile (lua_State *L, const char *name,
-                                           const char *pname,
-                                           const char *dirsep) {
-  const char *path;
-  lua_getfield(L, lua_upvalueindex(1), pname);
-  path = lua_tostring(L, -1);
-  if (path == NULL)
-    luaL_error(L, "'package.%s' must be a string", pname);
-  return searchpath(L, name, path, ".", dirsep);
-}
-
-
-static int checkload (lua_State *L, int stat, const char *filename) {
-  if (stat) {  /* module loaded successfully? */
-    lua_pushstring(L, filename);  /* will be 2nd argument to module */
-    return 2;  /* return open function and file name */
-  }
-  else
-    return luaL_error(L, "error loading module '%s' from file '%s':\n\t%s",
-                          lua_tostring(L, 1), filename, lua_tostring(L, -1));
-}
-
-
-static int searcher_Lua (lua_State *L) {
-  const char *filename;
-  const char *name = luaL_checkstring(L, 1);
-  filename = findfile(L, name, "path", LUA_LSUBSEP);
-  if (filename == NULL) return 1;  /* module not found in this path */
-  return checkload(L, (luaL_loadfile(L, filename) == LUA_OK), filename);
-}
-
-
-/*
-** Try to find a load function for module 'modname' at file 'filename'.
-** First, change '.' to '_' in 'modname'; then, if 'modname' has
-** the form X-Y (that is, it has an "ignore mark"), build a function
-** name "luaopen_X" and look for it. (For compatibility, if that
-** fails, it also tries "luaopen_Y".) If there is no ignore mark,
-** look for a function named "luaopen_modname".
-*/
-static int loadfunc (lua_State *L, const char *filename, const char *modname) {
-  const char *openfunc;
-  const char *mark;
-  modname = luaL_gsub(L, modname, ".", LUA_OFSEP);
-  mark = strchr(modname, *LUA_IGMARK);
-  if (mark) {
-    int stat;
-    openfunc = lua_pushlstring(L, modname, mark - modname);
-    openfunc = lua_pushfstring(L, LUA_POF"%s", openfunc);
-    stat = lookforfunc(L, filename, openfunc);
-    if (stat != ERRFUNC) return stat;
-    modname = mark + 1;  /* else go ahead and try old-style name */
-  }
-  openfunc = lua_pushfstring(L, LUA_POF"%s", modname);
-  return lookforfunc(L, filename, openfunc);
-}
-
-
-static int searcher_C (lua_State *L) {
-  const char *name = luaL_checkstring(L, 1);
-  const char *filename = findfile(L, name, "cpath", LUA_CSUBSEP);
-  if (filename == NULL) return 1;  /* module not found in this path */
-  return checkload(L, (loadfunc(L, filename, name) == 0), filename);
-}
-
-
-static int searcher_Croot (lua_State *L) {
-  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", LUA_CSUBSEP);
-  if (filename == NULL) return 1;  /* root not found */
-  if ((stat = loadfunc(L, filename, name)) != 0) {
-    if (stat != ERRFUNC)
-      return checkload(L, 0, filename);  /* real error */
-    else {  /* open function not found */
-      lua_pushfstring(L, "\n\tno module '%s' in file '%s'", name, filename);
-      return 1;
-    }
-  }
-  lua_pushstring(L, filename);  /* will be 2nd argument to module */
-  return 2;
-}
-
-
-static int searcher_preload (lua_State *L) {
-  const char *name = luaL_checkstring(L, 1);
-  lua_getfield(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
-  if (lua_getfield(L, -1, name) == LUA_TNIL)  /* not found? */
-    lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
-  return 1;
-}
-
-
-static void findloader (lua_State *L, const char *name) {
-  int i;
-  luaL_Buffer msg;  /* to build error message */
-  luaL_buffinit(L, &msg);
-  /* push 'package.searchers' to index 3 in the stack */
-  if (lua_getfield(L, lua_upvalueindex(1), "searchers") != LUA_TTABLE)
-    luaL_error(L, "'package.searchers' must be a table");
-  /*  iterate over available searchers to find a loader */
-  for (i = 1; ; i++) {
-    if (lua_rawgeti(L, 3, i) == LUA_TNIL) {  /* no more searchers? */
-      lua_pop(L, 1);  /* remove nil */
-      luaL_pushresult(&msg);  /* create error message */
-      luaL_error(L, "module '%s' not found:%s", name, lua_tostring(L, -1));
-    }
-    lua_pushstring(L, name);
-    lua_call(L, 1, 2);  /* call it */
-    if (lua_isfunction(L, -2))  /* did it find a loader? */
-      return;  /* module loader found */
-    else if (lua_isstring(L, -2)) {  /* searcher returned error message? */
-      lua_pop(L, 1);  /* remove extra return */
-      luaL_addvalue(&msg);  /* concatenate error message */
-    }
-    else
-      lua_pop(L, 2);  /* remove both returns */
-  }
-}
-
-
-static int ll_require (lua_State *L) {
-  const char *name = luaL_checkstring(L, 1);
-  lua_settop(L, 1);  /* LOADED table will be at index 2 */
-  lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
-  lua_getfield(L, 2, name);  /* LOADED[name] */
-  if (lua_toboolean(L, -1))  /* is it there? */
-    return 1;  /* package is already loaded */
-  /* else must load package */
-  lua_pop(L, 1);  /* remove 'getfield' result */
-  findloader(L, name);
-  lua_pushstring(L, name);  /* pass name as argument to module loader */
-  lua_insert(L, -2);  /* name is 1st argument (before search data) */
-  lua_call(L, 2, 1);  /* run loader to load module */
-  if (!lua_isnil(L, -1))  /* non-nil return? */
-    lua_setfield(L, 2, name);  /* LOADED[name] = returned value */
-  if (lua_getfield(L, 2, name) == LUA_TNIL) {   /* module set no 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
-** =======================================================
-*/
-#if defined(LUA_COMPAT_MODULE)
-
-/*
-** changes the environment variable of calling function
-*/
-static void set_env (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, "'module' not called from a Lua function");
-  lua_pushvalue(L, -2);  /* copy new environment table to top */
-  lua_setupvalue(L, -2, 1);
-  lua_pop(L, 1);  /* remove function */
-}
-
-
-static void dooptions (lua_State *L, int n) {
-  int i;
-  for (i = 2; i <= n; i++) {
-    if (lua_isfunction(L, i)) {  /* avoid 'calling' extra info. */
-      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 lastarg = lua_gettop(L);  /* last parameter */
-  luaL_pushmodule(L, modname, 1);  /* get/create module table */
-  /* check whether table already has a _NAME field */
-  if (lua_getfield(L, -1, "_NAME") != LUA_TNIL)
-    lua_pop(L, 1);  /* table is an initialized module */
-  else {  /* no; initialize it */
-    lua_pop(L, 1);
-    modinit(L, modname);
-  }
-  lua_pushvalue(L, -1);
-  set_env(L);
-  dooptions(L, lastarg);
-  return 1;
-}
-
-
-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_pushglobaltable(L);
-  lua_setfield(L, -2, "__index");  /* mt.__index = _G */
-  return 0;
-}
-
-#endif
-/* }====================================================== */
-
-
-
-static const luaL_Reg pk_funcs[] = {
-  {"loadlib", ll_loadlib},
-  {"searchpath", ll_searchpath},
-#if defined(LUA_COMPAT_MODULE)
-  {"seeall", ll_seeall},
-#endif
-  /* placeholders */
-  {"preload", NULL},
-  {"cpath", NULL},
-  {"path", NULL},
-  {"searchers", NULL},
-  {"loaded", NULL},
-  {NULL, NULL}
-};
-
-
-static const luaL_Reg ll_funcs[] = {
-#if defined(LUA_COMPAT_MODULE)
-  {"module", ll_module},
-#endif
-  {"require", ll_require},
-  {NULL, NULL}
-};
-
-
-static void createsearcherstable (lua_State *L) {
-  static const lua_CFunction searchers[] =
-    {searcher_preload, searcher_Lua, searcher_C, searcher_Croot, NULL};
-  int i;
-  /* create 'searchers' table */
-  lua_createtable(L, sizeof(searchers)/sizeof(searchers[0]) - 1, 0);
-  /* fill it with predefined searchers */
-  for (i=0; searchers[i] != NULL; i++) {
-    lua_pushvalue(L, -2);  /* set 'package' as upvalue for all searchers */
-    lua_pushcclosure(L, searchers[i], 1);
-    lua_rawseti(L, -2, i+1);
-  }
-#if defined(LUA_COMPAT_LOADERS)
-  lua_pushvalue(L, -1);  /* make a copy of 'searchers' table */
-  lua_setfield(L, -3, "loaders");  /* put it in field 'loaders' */
-#endif
-  lua_setfield(L, -2, "searchers");  /* put it in field 'searchers' */
-}
-
-
-/*
-** create table CLIBS to keep track of loaded C libraries,
-** setting a finalizer to close all libraries when closing state.
-*/
-static void createclibstable (lua_State *L) {
-  lua_newtable(L);  /* create CLIBS table */
-  lua_createtable(L, 0, 1);  /* create metatable for CLIBS */
-  lua_pushcfunction(L, gctm);
-  lua_setfield(L, -2, "__gc");  /* set finalizer for CLIBS table */
-  lua_setmetatable(L, -2);
-  lua_rawsetp(L, LUA_REGISTRYINDEX, &CLIBS);  /* set CLIBS table in registry */
-}
-
-
-LUAMOD_API int luaopen_package (lua_State *L) {
-  createclibstable(L);
-  luaL_newlib(L, pk_funcs);  /* create 'package' table */
-  createsearcherstable(L);
-  /* set paths */
-  setpath(L, "path", LUA_PATH_VAR, LUA_PATH_DEFAULT);
-  setpath(L, "cpath", LUA_CPATH_VAR, LUA_CPATH_DEFAULT);
-  /* store config information */
-  lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATH_SEP "\n" LUA_PATH_MARK "\n"
-                     LUA_EXEC_DIR "\n" LUA_IGMARK "\n");
-  lua_setfield(L, -2, "config");
-  /* set field 'loaded' */
-  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
-  lua_setfield(L, -2, "loaded");
-  /* set field 'preload' */
-  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
-  lua_setfield(L, -2, "preload");
-  lua_pushglobaltable(L);
-  lua_pushvalue(L, -2);  /* set 'package' as upvalue for next lib */
-  luaL_setfuncs(L, ll_funcs, 1);  /* open lib into global table */
-  lua_pop(L, 1);  /* pop global table */
-  return 1;  /* return 'package' table */
-}
-
diff --git a/lua/lua-5.3.5/src/lobject.c b/lua/lua-5.3.5/src/lobject.c
deleted file mode 100644
index 2218c8c..0000000
--- a/lua/lua-5.3.5/src/lobject.c
+++ /dev/null
@@ -1,522 +0,0 @@
-/*
-** $Id: lobject.c,v 2.113.1.1 2017/04/19 17:29:57 roberto Exp $
-** Some generic functions over Lua objects
-** See Copyright Notice in lua.h
-*/
-
-#define lobject_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <locale.h>
-#include <math.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lctype.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "lvm.h"
-
-
-
-LUAI_DDEF const TValue luaO_nilobject_ = {NILCONSTANT};
-
-
-/*
-** 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;  /* exponent */
-  if (x < 8) return x;
-  while (x >= (8 << 4)) {  /* coarse steps */
-    x = (x + 0xf) >> 4;  /* x = ceil(x / 16) */
-    e += 4;
-  }
-  while (x >= (8 << 1)) {  /* fine steps */
-    x = (x + 1) >> 1;  /* x = ceil(x / 2) */
-    e++;
-  }
-  return ((e+1) << 3) | (cast_int(x) - 8);
-}
-
-
-/* converts back */
-int luaO_fb2int (int x) {
-  return (x < 8) ? x : ((x & 7) + 8) << ((x >> 3) - 1);
-}
-
-
-/*
-** Computes ceil(log2(x))
-*/
-int luaO_ceillog2 (unsigned int x) {
-  static const lu_byte log_2[256] = {  /* log_2[i] = ceil(log2(i - 1)) */
-    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 = 0;
-  x--;
-  while (x >= 256) { l += 8; x >>= 8; }
-  return l + log_2[x];
-}
-
-
-static lua_Integer intarith (lua_State *L, int op, lua_Integer v1,
-                                                   lua_Integer v2) {
-  switch (op) {
-    case LUA_OPADD: return intop(+, v1, v2);
-    case LUA_OPSUB:return intop(-, v1, v2);
-    case LUA_OPMUL:return intop(*, v1, v2);
-    case LUA_OPMOD: return luaV_mod(L, v1, v2);
-    case LUA_OPIDIV: return luaV_div(L, v1, v2);
-    case LUA_OPBAND: return intop(&, v1, v2);
-    case LUA_OPBOR: return intop(|, v1, v2);
-    case LUA_OPBXOR: return intop(^, v1, v2);
-    case LUA_OPSHL: return luaV_shiftl(v1, v2);
-    case LUA_OPSHR: return luaV_shiftl(v1, -v2);
-    case LUA_OPUNM: return intop(-, 0, v1);
-    case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1);
-    default: lua_assert(0); return 0;
-  }
-}
-
-
-static lua_Number numarith (lua_State *L, int op, lua_Number v1,
-                                                  lua_Number v2) {
-  switch (op) {
-    case LUA_OPADD: return luai_numadd(L, v1, v2);
-    case LUA_OPSUB: return luai_numsub(L, v1, v2);
-    case LUA_OPMUL: return luai_nummul(L, v1, v2);
-    case LUA_OPDIV: return luai_numdiv(L, v1, v2);
-    case LUA_OPPOW: return luai_numpow(L, v1, v2);
-    case LUA_OPIDIV: return luai_numidiv(L, v1, v2);
-    case LUA_OPUNM: return luai_numunm(L, v1);
-    case LUA_OPMOD: {
-      lua_Number m;
-      luai_nummod(L, v1, v2, m);
-      return m;
-    }
-    default: lua_assert(0); return 0;
-  }
-}
-
-
-void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2,
-                 TValue *res) {
-  switch (op) {
-    case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
-    case LUA_OPSHL: case LUA_OPSHR:
-    case LUA_OPBNOT: {  /* operate only on integers */
-      lua_Integer i1; lua_Integer i2;
-      if (tointeger(p1, &i1) && tointeger(p2, &i2)) {
-        setivalue(res, intarith(L, op, i1, i2));
-        return;
-      }
-      else break;  /* go to the end */
-    }
-    case LUA_OPDIV: case LUA_OPPOW: {  /* operate only on floats */
-      lua_Number n1; lua_Number n2;
-      if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
-        setfltvalue(res, numarith(L, op, n1, n2));
-        return;
-      }
-      else break;  /* go to the end */
-    }
-    default: {  /* other operations */
-      lua_Number n1; lua_Number n2;
-      if (ttisinteger(p1) && ttisinteger(p2)) {
-        setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2)));
-        return;
-      }
-      else if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
-        setfltvalue(res, numarith(L, op, n1, n2));
-        return;
-      }
-      else break;  /* go to the end */
-    }
-  }
-  /* could not perform raw operation; try metamethod */
-  lua_assert(L != NULL);  /* should not fail when folding (compile time) */
-  luaT_trybinTM(L, p1, p2, res, cast(TMS, (op - LUA_OPADD) + TM_ADD));
-}
-
-
-int luaO_hexavalue (int c) {
-  if (lisdigit(c)) return c - '0';
-  else return (ltolower(c) - 'a') + 10;
-}
-
-
-static int isneg (const char **s) {
-  if (**s == '-') { (*s)++; return 1; }
-  else if (**s == '+') (*s)++;
-  return 0;
-}
-
-
-
-/*
-** {==================================================================
-** Lua's implementation for 'lua_strx2number'
-** ===================================================================
-*/
-
-#if !defined(lua_strx2number)
-
-/* maximum number of significant digits to read (to avoid overflows
-   even with single floats) */
-#define MAXSIGDIG	30
-
-/*
-** convert an hexadecimal numeric string to a number, following
-** C99 specification for 'strtod'
-*/
-static lua_Number lua_strx2number (const char *s, char **endptr) {
-  int dot = lua_getlocaledecpoint();
-  lua_Number r = 0.0;  /* result (accumulator) */
-  int sigdig = 0;  /* number of significant digits */
-  int nosigdig = 0;  /* number of non-significant digits */
-  int e = 0;  /* exponent correction */
-  int neg;  /* 1 if number is negative */
-  int hasdot = 0;  /* true after seen a dot */
-  *endptr = cast(char *, s);  /* nothing is valid yet */
-  while (lisspace(cast_uchar(*s))) s++;  /* skip initial spaces */
-  neg = isneg(&s);  /* check signal */
-  if (!(*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')))  /* check '0x' */
-    return 0.0;  /* invalid format (no '0x') */
-  for (s += 2; ; s++) {  /* skip '0x' and read numeral */
-    if (*s == dot) {
-      if (hasdot) break;  /* second dot? stop loop */
-      else hasdot = 1;
-    }
-    else if (lisxdigit(cast_uchar(*s))) {
-      if (sigdig == 0 && *s == '0')  /* non-significant digit (zero)? */
-        nosigdig++;
-      else if (++sigdig <= MAXSIGDIG)  /* can read it without overflow? */
-          r = (r * cast_num(16.0)) + luaO_hexavalue(*s);
-      else e++; /* too many digits; ignore, but still count for exponent */
-      if (hasdot) e--;  /* decimal digit? correct exponent */
-    }
-    else break;  /* neither a dot nor a digit */
-  }
-  if (nosigdig + sigdig == 0)  /* no digits? */
-    return 0.0;  /* invalid format */
-  *endptr = cast(char *, s);  /* valid up to here */
-  e *= 4;  /* each digit multiplies/divides value by 2^4 */
-  if (*s == 'p' || *s == 'P') {  /* exponent part? */
-    int exp1 = 0;  /* exponent value */
-    int neg1;  /* exponent signal */
-    s++;  /* skip 'p' */
-    neg1 = isneg(&s);  /* signal */
-    if (!lisdigit(cast_uchar(*s)))
-      return 0.0;  /* invalid; must have at least one digit */
-    while (lisdigit(cast_uchar(*s)))  /* read exponent */
-      exp1 = exp1 * 10 + *(s++) - '0';
-    if (neg1) exp1 = -exp1;
-    e += exp1;
-    *endptr = cast(char *, s);  /* valid up to here */
-  }
-  if (neg) r = -r;
-  return l_mathop(ldexp)(r, e);
-}
-
-#endif
-/* }====================================================== */
-
-
-/* maximum length of a numeral */
-#if !defined (L_MAXLENNUM)
-#define L_MAXLENNUM	200
-#endif
-
-static const char *l_str2dloc (const char *s, lua_Number *result, int mode) {
-  char *endptr;
-  *result = (mode == 'x') ? lua_strx2number(s, &endptr)  /* try to convert */
-                          : lua_str2number(s, &endptr);
-  if (endptr == s) return NULL;  /* nothing recognized? */
-  while (lisspace(cast_uchar(*endptr))) endptr++;  /* skip trailing spaces */
-  return (*endptr == '\0') ? endptr : NULL;  /* OK if no trailing characters */
-}
-
-
-/*
-** Convert string 's' to a Lua number (put in 'result'). Return NULL
-** on fail or the address of the ending '\0' on success.
-** 'pmode' points to (and 'mode' contains) special things in the string:
-** - 'x'/'X' means an hexadecimal numeral
-** - 'n'/'N' means 'inf' or 'nan' (which should be rejected)
-** - '.' just optimizes the search for the common case (nothing special)
-** This function accepts both the current locale or a dot as the radix
-** mark. If the convertion fails, it may mean number has a dot but
-** locale accepts something else. In that case, the code copies 's'
-** to a buffer (because 's' is read-only), changes the dot to the
-** current locale radix mark, and tries to convert again.
-*/
-static const char *l_str2d (const char *s, lua_Number *result) {
-  const char *endptr;
-  const char *pmode = strpbrk(s, ".xXnN");
-  int mode = pmode ? ltolower(cast_uchar(*pmode)) : 0;
-  if (mode == 'n')  /* reject 'inf' and 'nan' */
-    return NULL;
-  endptr = l_str2dloc(s, result, mode);  /* try to convert */
-  if (endptr == NULL) {  /* failed? may be a different locale */
-    char buff[L_MAXLENNUM + 1];
-    const char *pdot = strchr(s, '.');
-    if (strlen(s) > L_MAXLENNUM || pdot == NULL)
-      return NULL;  /* string too long or no dot; fail */
-    strcpy(buff, s);  /* copy string to buffer */
-    buff[pdot - s] = lua_getlocaledecpoint();  /* correct decimal point */
-    endptr = l_str2dloc(buff, result, mode);  /* try again */
-    if (endptr != NULL)
-      endptr = s + (endptr - buff);  /* make relative to 's' */
-  }
-  return endptr;
-}
-
-
-#define MAXBY10		cast(lua_Unsigned, LUA_MAXINTEGER / 10)
-#define MAXLASTD	cast_int(LUA_MAXINTEGER % 10)
-
-static const char *l_str2int (const char *s, lua_Integer *result) {
-  lua_Unsigned a = 0;
-  int empty = 1;
-  int neg;
-  while (lisspace(cast_uchar(*s))) s++;  /* skip initial spaces */
-  neg = isneg(&s);
-  if (s[0] == '0' &&
-      (s[1] == 'x' || s[1] == 'X')) {  /* hex? */
-    s += 2;  /* skip '0x' */
-    for (; lisxdigit(cast_uchar(*s)); s++) {
-      a = a * 16 + luaO_hexavalue(*s);
-      empty = 0;
-    }
-  }
-  else {  /* decimal */
-    for (; lisdigit(cast_uchar(*s)); s++) {
-      int d = *s - '0';
-      if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg))  /* overflow? */
-        return NULL;  /* do not accept it (as integer) */
-      a = a * 10 + d;
-      empty = 0;
-    }
-  }
-  while (lisspace(cast_uchar(*s))) s++;  /* skip trailing spaces */
-  if (empty || *s != '\0') return NULL;  /* something wrong in the numeral */
-  else {
-    *result = l_castU2S((neg) ? 0u - a : a);
-    return s;
-  }
-}
-
-
-size_t luaO_str2num (const char *s, TValue *o) {
-  lua_Integer i; lua_Number n;
-  const char *e;
-  if ((e = l_str2int(s, &i)) != NULL) {  /* try as an integer */
-    setivalue(o, i);
-  }
-  else if ((e = l_str2d(s, &n)) != NULL) {  /* else try as a float */
-    setfltvalue(o, n);
-  }
-  else
-    return 0;  /* conversion failed */
-  return (e - s) + 1;  /* success; return string size */
-}
-
-
-int luaO_utf8esc (char *buff, unsigned long x) {
-  int n = 1;  /* number of bytes put in buffer (backwards) */
-  lua_assert(x <= 0x10FFFF);
-  if (x < 0x80)  /* ascii? */
-    buff[UTF8BUFFSZ - 1] = cast(char, x);
-  else {  /* need continuation bytes */
-    unsigned int mfb = 0x3f;  /* maximum that fits in first byte */
-    do {  /* add continuation bytes */
-      buff[UTF8BUFFSZ - (n++)] = cast(char, 0x80 | (x & 0x3f));
-      x >>= 6;  /* remove added bits */
-      mfb >>= 1;  /* now there is one less bit available in first byte */
-    } while (x > mfb);  /* still needs continuation byte? */
-    buff[UTF8BUFFSZ - n] = cast(char, (~mfb << 1) | x);  /* add first byte */
-  }
-  return n;
-}
-
-
-/* maximum length of the conversion of a number to a string */
-#define MAXNUMBER2STR	50
-
-
-/*
-** Convert a number object to a string
-*/
-void luaO_tostring (lua_State *L, StkId obj) {
-  char buff[MAXNUMBER2STR];
-  size_t len;
-  lua_assert(ttisnumber(obj));
-  if (ttisinteger(obj))
-    len = lua_integer2str(buff, sizeof(buff), ivalue(obj));
-  else {
-    len = lua_number2str(buff, sizeof(buff), fltvalue(obj));
-#if !defined(LUA_COMPAT_FLOATSTRING)
-    if (buff[strspn(buff, "-0123456789")] == '\0') {  /* looks like an int? */
-      buff[len++] = lua_getlocaledecpoint();
-      buff[len++] = '0';  /* adds '.0' to result */
-    }
-#endif
-  }
-  setsvalue2s(L, obj, luaS_newlstr(L, buff, len));
-}
-
-
-static void pushstr (lua_State *L, const char *str, size_t l) {
-  setsvalue2s(L, L->top, luaS_newlstr(L, str, l));
-  luaD_inctop(L);
-}
-
-
-/*
-** this function handles only '%d', '%c', '%f', '%p', and '%s'
-   conventional formats, plus Lua-specific '%I' and '%U'
-*/
-const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
-  int n = 0;
-  for (;;) {
-    const char *e = strchr(fmt, '%');
-    if (e == NULL) break;
-    pushstr(L, fmt, e - fmt);
-    switch (*(e+1)) {
-      case 's': {  /* zero-terminated string */
-        const char *s = va_arg(argp, char *);
-        if (s == NULL) s = "(null)";
-        pushstr(L, s, strlen(s));
-        break;
-      }
-      case 'c': {  /* an 'int' as a character */
-        char buff = cast(char, va_arg(argp, int));
-        if (lisprint(cast_uchar(buff)))
-          pushstr(L, &buff, 1);
-        else  /* non-printable character; print its code */
-          luaO_pushfstring(L, "<\\%d>", cast_uchar(buff));
-        break;
-      }
-      case 'd': {  /* an 'int' */
-        setivalue(L->top, va_arg(argp, int));
-        goto top2str;
-      }
-      case 'I': {  /* a 'lua_Integer' */
-        setivalue(L->top, cast(lua_Integer, va_arg(argp, l_uacInt)));
-        goto top2str;
-      }
-      case 'f': {  /* a 'lua_Number' */
-        setfltvalue(L->top, cast_num(va_arg(argp, l_uacNumber)));
-      top2str:  /* convert the top element to a string */
-        luaD_inctop(L);
-        luaO_tostring(L, L->top - 1);
-        break;
-      }
-      case 'p': {  /* a pointer */
-        char buff[4*sizeof(void *) + 8]; /* should be enough space for a '%p' */
-        void *p = va_arg(argp, void *);
-        int l = lua_pointer2str(buff, sizeof(buff), p);
-        pushstr(L, buff, l);
-        break;
-      }
-      case 'U': {  /* an 'int' as a UTF-8 sequence */
-        char buff[UTF8BUFFSZ];
-        int l = luaO_utf8esc(buff, cast(long, va_arg(argp, long)));
-        pushstr(L, buff + UTF8BUFFSZ - l, l);
-        break;
-      }
-      case '%': {
-        pushstr(L, "%", 1);
-        break;
-      }
-      default: {
-        luaG_runerror(L, "invalid option '%%%c' to 'lua_pushfstring'",
-                         *(e + 1));
-      }
-    }
-    n += 2;
-    fmt = e+2;
-  }
-  luaD_checkstack(L, 1);
-  pushstr(L, fmt, strlen(fmt));
-  if (n > 0) luaV_concat(L, n + 1);
-  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;
-}
-
-
-/* number of chars of a literal string without the ending \0 */
-#define LL(x)	(sizeof(x)/sizeof(char) - 1)
-
-#define RETS	"..."
-#define PRE	"[string \""
-#define POS	"\"]"
-
-#define addstr(a,b,l)	( memcpy(a,b,(l) * sizeof(char)), a += (l) )
-
-void luaO_chunkid (char *out, const char *source, size_t bufflen) {
-  size_t l = strlen(source);
-  if (*source == '=') {  /* 'literal' source */
-    if (l <= bufflen)  /* small enough? */
-      memcpy(out, source + 1, l * sizeof(char));
-    else {  /* truncate it */
-      addstr(out, source + 1, bufflen - 1);
-      *out = '\0';
-    }
-  }
-  else if (*source == '@') {  /* file name */
-    if (l <= bufflen)  /* small enough? */
-      memcpy(out, source + 1, l * sizeof(char));
-    else {  /* add '...' before rest of name */
-      addstr(out, RETS, LL(RETS));
-      bufflen -= LL(RETS);
-      memcpy(out, source + 1 + l - bufflen, bufflen * sizeof(char));
-    }
-  }
-  else {  /* string; format as [string "source"] */
-    const char *nl = strchr(source, '\n');  /* find first new line (if any) */
-    addstr(out, PRE, LL(PRE));  /* add prefix */
-    bufflen -= LL(PRE RETS POS) + 1;  /* save space for prefix+suffix+'\0' */
-    if (l < bufflen && nl == NULL) {  /* small one-line source? */
-      addstr(out, source, l);  /* keep it */
-    }
-    else {
-      if (nl != NULL) l = nl - source;  /* stop at first newline */
-      if (l > bufflen) l = bufflen;
-      addstr(out, source, l);
-      addstr(out, RETS, LL(RETS));
-    }
-    memcpy(out, POS, (LL(POS) + 1) * sizeof(char));
-  }
-}
-
diff --git a/lua/lua-5.3.5/src/lobject.h b/lua/lua-5.3.5/src/lobject.h
deleted file mode 100644
index 2408861..0000000
--- a/lua/lua-5.3.5/src/lobject.h
+++ /dev/null
@@ -1,549 +0,0 @@
-/*
-** $Id: lobject.h,v 2.117.1.1 2017/04/19 17:39:34 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"
-
-
-/*
-** Extra tags for non-values
-*/
-#define LUA_TPROTO	LUA_NUMTAGS		/* function prototypes */
-#define LUA_TDEADKEY	(LUA_NUMTAGS+1)		/* removed keys in tables */
-
-/*
-** number of all possible tags (including LUA_TNONE but excluding DEADKEY)
-*/
-#define LUA_TOTALTAGS	(LUA_TPROTO + 2)
-
-
-/*
-** tags for Tagged Values have the following use of bits:
-** bits 0-3: actual tag (a LUA_T* value)
-** bits 4-5: variant bits
-** bit 6: whether value is collectable
-*/
-
-
-/*
-** LUA_TFUNCTION variants:
-** 0 - Lua function
-** 1 - light C function
-** 2 - regular C function (closure)
-*/
-
-/* Variant tags for functions */
-#define LUA_TLCL	(LUA_TFUNCTION | (0 << 4))  /* Lua closure */
-#define LUA_TLCF	(LUA_TFUNCTION | (1 << 4))  /* light C function */
-#define LUA_TCCL	(LUA_TFUNCTION | (2 << 4))  /* C closure */
-
-
-/* Variant tags for strings */
-#define LUA_TSHRSTR	(LUA_TSTRING | (0 << 4))  /* short strings */
-#define LUA_TLNGSTR	(LUA_TSTRING | (1 << 4))  /* long strings */
-
-
-/* Variant tags for numbers */
-#define LUA_TNUMFLT	(LUA_TNUMBER | (0 << 4))  /* float numbers */
-#define LUA_TNUMINT	(LUA_TNUMBER | (1 << 4))  /* integer numbers */
-
-
-/* Bit mark for collectable types */
-#define BIT_ISCOLLECTABLE	(1 << 6)
-
-/* mark a tag as collectable */
-#define ctb(t)			((t) | BIT_ISCOLLECTABLE)
-
-
-/*
-** Common type for all collectable objects
-*/
-typedef struct 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 type has only the common header
-*/
-struct GCObject {
-  CommonHeader;
-};
-
-
-
-
-/*
-** Tagged Values. This is the basic representation of values in Lua,
-** an actual value plus a tag with its type.
-*/
-
-/*
-** Union of all Lua values
-*/
-typedef union Value {
-  GCObject *gc;    /* collectable objects */
-  void *p;         /* light userdata */
-  int b;           /* booleans */
-  lua_CFunction f; /* light C functions */
-  lua_Integer i;   /* integer numbers */
-  lua_Number n;    /* float numbers */
-} Value;
-
-
-#define TValuefields	Value value_; int tt_
-
-
-typedef struct lua_TValue {
-  TValuefields;
-} TValue;
-
-
-
-/* macro defining a nil value */
-#define NILCONSTANT	{NULL}, LUA_TNIL
-
-
-#define val_(o)		((o)->value_)
-
-
-/* raw type tag of a TValue */
-#define rttype(o)	((o)->tt_)
-
-/* tag with no variants (bits 0-3) */
-#define novariant(x)	((x) & 0x0F)
-
-/* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */
-#define ttype(o)	(rttype(o) & 0x3F)
-
-/* type tag of a TValue with no variants (bits 0-3) */
-#define ttnov(o)	(novariant(rttype(o)))
-
-
-/* Macros to test type */
-#define checktag(o,t)		(rttype(o) == (t))
-#define checktype(o,t)		(ttnov(o) == (t))
-#define ttisnumber(o)		checktype((o), LUA_TNUMBER)
-#define ttisfloat(o)		checktag((o), LUA_TNUMFLT)
-#define ttisinteger(o)		checktag((o), LUA_TNUMINT)
-#define ttisnil(o)		checktag((o), LUA_TNIL)
-#define ttisboolean(o)		checktag((o), LUA_TBOOLEAN)
-#define ttislightuserdata(o)	checktag((o), LUA_TLIGHTUSERDATA)
-#define ttisstring(o)		checktype((o), LUA_TSTRING)
-#define ttisshrstring(o)	checktag((o), ctb(LUA_TSHRSTR))
-#define ttislngstring(o)	checktag((o), ctb(LUA_TLNGSTR))
-#define ttistable(o)		checktag((o), ctb(LUA_TTABLE))
-#define ttisfunction(o)		checktype(o, LUA_TFUNCTION)
-#define ttisclosure(o)		((rttype(o) & 0x1F) == LUA_TFUNCTION)
-#define ttisCclosure(o)		checktag((o), ctb(LUA_TCCL))
-#define ttisLclosure(o)		checktag((o), ctb(LUA_TLCL))
-#define ttislcf(o)		checktag((o), LUA_TLCF)
-#define ttisfulluserdata(o)	checktag((o), ctb(LUA_TUSERDATA))
-#define ttisthread(o)		checktag((o), ctb(LUA_TTHREAD))
-#define ttisdeadkey(o)		checktag((o), LUA_TDEADKEY)
-
-
-/* Macros to access values */
-#define ivalue(o)	check_exp(ttisinteger(o), val_(o).i)
-#define fltvalue(o)	check_exp(ttisfloat(o), val_(o).n)
-#define nvalue(o)	check_exp(ttisnumber(o), \
-	(ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o)))
-#define gcvalue(o)	check_exp(iscollectable(o), val_(o).gc)
-#define pvalue(o)	check_exp(ttislightuserdata(o), val_(o).p)
-#define tsvalue(o)	check_exp(ttisstring(o), gco2ts(val_(o).gc))
-#define uvalue(o)	check_exp(ttisfulluserdata(o), gco2u(val_(o).gc))
-#define clvalue(o)	check_exp(ttisclosure(o), gco2cl(val_(o).gc))
-#define clLvalue(o)	check_exp(ttisLclosure(o), gco2lcl(val_(o).gc))
-#define clCvalue(o)	check_exp(ttisCclosure(o), gco2ccl(val_(o).gc))
-#define fvalue(o)	check_exp(ttislcf(o), val_(o).f)
-#define hvalue(o)	check_exp(ttistable(o), gco2t(val_(o).gc))
-#define bvalue(o)	check_exp(ttisboolean(o), val_(o).b)
-#define thvalue(o)	check_exp(ttisthread(o), gco2th(val_(o).gc))
-/* a dead value may get the 'gc' field, but cannot access its contents */
-#define deadvalue(o)	check_exp(ttisdeadkey(o), cast(void *, val_(o).gc))
-
-#define l_isfalse(o)	(ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
-
-
-#define iscollectable(o)	(rttype(o) & BIT_ISCOLLECTABLE)
-
-
-/* Macros for internal tests */
-#define righttt(obj)		(ttype(obj) == gcvalue(obj)->tt)
-
-#define checkliveness(L,obj) \
-	lua_longassert(!iscollectable(obj) || \
-		(righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))
-
-
-/* Macros to set values */
-#define settt_(o,t)	((o)->tt_=(t))
-
-#define setfltvalue(obj,x) \
-  { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_TNUMFLT); }
-
-#define chgfltvalue(obj,x) \
-  { TValue *io=(obj); lua_assert(ttisfloat(io)); val_(io).n=(x); }
-
-#define setivalue(obj,x) \
-  { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_TNUMINT); }
-
-#define chgivalue(obj,x) \
-  { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); }
-
-#define setnilvalue(obj) settt_(obj, LUA_TNIL)
-
-#define setfvalue(obj,x) \
-  { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_TLCF); }
-
-#define setpvalue(obj,x) \
-  { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_TLIGHTUSERDATA); }
-
-#define setbvalue(obj,x) \
-  { TValue *io=(obj); val_(io).b=(x); settt_(io, LUA_TBOOLEAN); }
-
-#define setgcovalue(L,obj,x) \
-  { TValue *io = (obj); GCObject *i_g=(x); \
-    val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); }
-
-#define setsvalue(L,obj,x) \
-  { TValue *io = (obj); TString *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \
-    checkliveness(L,io); }
-
-#define setuvalue(L,obj,x) \
-  { TValue *io = (obj); Udata *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TUSERDATA)); \
-    checkliveness(L,io); }
-
-#define setthvalue(L,obj,x) \
-  { TValue *io = (obj); lua_State *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTHREAD)); \
-    checkliveness(L,io); }
-
-#define setclLvalue(L,obj,x) \
-  { TValue *io = (obj); LClosure *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TLCL)); \
-    checkliveness(L,io); }
-
-#define setclCvalue(L,obj,x) \
-  { TValue *io = (obj); CClosure *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TCCL)); \
-    checkliveness(L,io); }
-
-#define sethvalue(L,obj,x) \
-  { TValue *io = (obj); Table *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTABLE)); \
-    checkliveness(L,io); }
-
-#define setdeadvalue(obj)	settt_(obj, LUA_TDEADKEY)
-
-
-
-#define setobj(L,obj1,obj2) \
-	{ TValue *io1=(obj1); *io1 = *(obj2); \
-	  (void)L; checkliveness(L,io1); }
-
-
-/*
-** different types of assignments, 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 new object */
-#define setobj2n	setobj
-#define setsvalue2n	setsvalue
-
-/* to table (define it as an expression to be used in macros) */
-#define setobj2t(L,o1,o2)  ((void)L, *(o1)=*(o2), checkliveness(L,(o1)))
-
-
-
-
-/*
-** {======================================================
-** types and prototypes
-** =======================================================
-*/
-
-
-typedef TValue *StkId;  /* index to stack elements */
-
-
-
-
-/*
-** Header for string value; string bytes follow the end of this structure
-** (aligned according to 'UTString'; see next).
-*/
-typedef struct TString {
-  CommonHeader;
-  lu_byte extra;  /* reserved words for short strings; "has hash" for longs */
-  lu_byte shrlen;  /* length for short strings */
-  unsigned int hash;
-  union {
-    size_t lnglen;  /* length for long strings */
-    struct TString *hnext;  /* linked list for hash table */
-  } u;
-} TString;
-
-
-/*
-** Ensures that address after this type is always fully aligned.
-*/
-typedef union UTString {
-  L_Umaxalign dummy;  /* ensures maximum alignment for strings */
-  TString tsv;
-} UTString;
-
-
-/*
-** Get the actual string (array of bytes) from a 'TString'.
-** (Access to 'extra' ensures that value is really a 'TString'.)
-*/
-#define getstr(ts)  \
-  check_exp(sizeof((ts)->extra), cast(char *, (ts)) + sizeof(UTString))
-
-
-/* get the actual string (array of bytes) from a Lua value */
-#define svalue(o)       getstr(tsvalue(o))
-
-/* get string length from 'TString *s' */
-#define tsslen(s)	((s)->tt == LUA_TSHRSTR ? (s)->shrlen : (s)->u.lnglen)
-
-/* get string length from 'TValue *o' */
-#define vslen(o)	tsslen(tsvalue(o))
-
-
-/*
-** Header for userdata; memory area follows the end of this structure
-** (aligned according to 'UUdata'; see next).
-*/
-typedef struct Udata {
-  CommonHeader;
-  lu_byte ttuv_;  /* user value's tag */
-  struct Table *metatable;
-  size_t len;  /* number of bytes */
-  union Value user_;  /* user value */
-} Udata;
-
-
-/*
-** Ensures that address after this type is always fully aligned.
-*/
-typedef union UUdata {
-  L_Umaxalign dummy;  /* ensures maximum alignment for 'local' udata */
-  Udata uv;
-} UUdata;
-
-
-/*
-**  Get the address of memory block inside 'Udata'.
-** (Access to 'ttuv_' ensures that value is really a 'Udata'.)
-*/
-#define getudatamem(u)  \
-  check_exp(sizeof((u)->ttuv_), (cast(char*, (u)) + sizeof(UUdata)))
-
-#define setuservalue(L,u,o) \
-	{ const TValue *io=(o); Udata *iu = (u); \
-	  iu->user_ = io->value_; iu->ttuv_ = rttype(io); \
-	  checkliveness(L,io); }
-
-
-#define getuservalue(L,u,o) \
-	{ TValue *io=(o); const Udata *iu = (u); \
-	  io->value_ = iu->user_; settt_(io, iu->ttuv_); \
-	  checkliveness(L,io); }
-
-
-/*
-** Description of an upvalue for function prototypes
-*/
-typedef struct Upvaldesc {
-  TString *name;  /* upvalue name (for debug information) */
-  lu_byte instack;  /* whether it is in stack (register) */
-  lu_byte idx;  /* index of upvalue (in stack or in outer function's list) */
-} Upvaldesc;
-
-
-/*
-** Description of a local variable for function prototypes
-** (used for debug information)
-*/
-typedef struct LocVar {
-  TString *varname;
-  int startpc;  /* first point where variable is active */
-  int endpc;    /* first point where variable is dead */
-} LocVar;
-
-
-/*
-** Function Prototypes
-*/
-typedef struct Proto {
-  CommonHeader;
-  lu_byte numparams;  /* number of fixed parameters */
-  lu_byte is_vararg;
-  lu_byte maxstacksize;  /* number of registers needed by this function */
-  int sizeupvalues;  /* size of 'upvalues' */
-  int sizek;  /* size of 'k' */
-  int sizecode;
-  int sizelineinfo;
-  int sizep;  /* size of 'p' */
-  int sizelocvars;
-  int linedefined;  /* debug information  */
-  int lastlinedefined;  /* debug information  */
-  TValue *k;  /* constants used by the function */
-  Instruction *code;  /* opcodes */
-  struct Proto **p;  /* functions defined inside the function */
-  int *lineinfo;  /* map from opcodes to source lines (debug information) */
-  LocVar *locvars;  /* information about local variables (debug information) */
-  Upvaldesc *upvalues;  /* upvalue information */
-  struct LClosure *cache;  /* last-created closure with this prototype */
-  TString  *source;  /* used for debug information */
-  GCObject *gclist;
-} Proto;
-
-
-
-/*
-** Lua Upvalues
-*/
-typedef struct UpVal UpVal;
-
-
-/*
-** Closures
-*/
-
-#define ClosureHeader \
-	CommonHeader; lu_byte nupvalues; GCObject *gclist
-
-typedef struct CClosure {
-  ClosureHeader;
-  lua_CFunction f;
-  TValue upvalue[1];  /* list of upvalues */
-} CClosure;
-
-
-typedef struct LClosure {
-  ClosureHeader;
-  struct Proto *p;
-  UpVal *upvals[1];  /* list of upvalues */
-} LClosure;
-
-
-typedef union Closure {
-  CClosure c;
-  LClosure l;
-} Closure;
-
-
-#define isLfunction(o)	ttisLclosure(o)
-
-#define getproto(o)	(clLvalue(o)->p)
-
-
-/*
-** Tables
-*/
-
-typedef union TKey {
-  struct {
-    TValuefields;
-    int next;  /* for chaining (offset for next node) */
-  } nk;
-  TValue tvk;
-} TKey;
-
-
-/* copy a value into a key without messing up field 'next' */
-#define setnodekey(L,key,obj) \
-	{ TKey *k_=(key); const TValue *io_=(obj); \
-	  k_->nk.value_ = io_->value_; k_->nk.tt_ = io_->tt_; \
-	  (void)L; checkliveness(L,io_); }
-
-
-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 */
-  unsigned int sizearray;  /* size of 'array' array */
-  TValue *array;  /* array part */
-  Node *node;
-  Node *lastfree;  /* any free position is before this position */
-  struct Table *metatable;
-  GCObject *gclist;
-} 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))
-
-
-/*
-** (address of) a fixed nil value
-*/
-#define luaO_nilobject		(&luaO_nilobject_)
-
-
-LUAI_DDEC const TValue luaO_nilobject_;
-
-/* size of buffer for 'luaO_utf8esc' function */
-#define UTF8BUFFSZ	8
-
-LUAI_FUNC int luaO_int2fb (unsigned int x);
-LUAI_FUNC int luaO_fb2int (int x);
-LUAI_FUNC int luaO_utf8esc (char *buff, unsigned long x);
-LUAI_FUNC int luaO_ceillog2 (unsigned int x);
-LUAI_FUNC void luaO_arith (lua_State *L, int op, const TValue *p1,
-                           const TValue *p2, TValue *res);
-LUAI_FUNC size_t luaO_str2num (const char *s, TValue *o);
-LUAI_FUNC int luaO_hexavalue (int c);
-LUAI_FUNC void luaO_tostring (lua_State *L, StkId obj);
-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/lua/lua-5.3.5/src/lopcodes.c b/lua/lua-5.3.5/src/lopcodes.c
deleted file mode 100644
index 5ca3eb2..0000000
--- a/lua/lua-5.3.5/src/lopcodes.c
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
-** $Id: lopcodes.c,v 1.55.1.1 2017/04/19 17:20:42 roberto Exp $
-** Opcodes for Lua virtual machine
-** See Copyright Notice in lua.h
-*/
-
-#define lopcodes_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <stddef.h>
-
-#include "lopcodes.h"
-
-
-/* ORDER OP */
-
-LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = {
-  "MOVE",
-  "LOADK",
-  "LOADKX",
-  "LOADBOOL",
-  "LOADNIL",
-  "GETUPVAL",
-  "GETTABUP",
-  "GETTABLE",
-  "SETTABUP",
-  "SETUPVAL",
-  "SETTABLE",
-  "NEWTABLE",
-  "SELF",
-  "ADD",
-  "SUB",
-  "MUL",
-  "MOD",
-  "POW",
-  "DIV",
-  "IDIV",
-  "BAND",
-  "BOR",
-  "BXOR",
-  "SHL",
-  "SHR",
-  "UNM",
-  "BNOT",
-  "NOT",
-  "LEN",
-  "CONCAT",
-  "JMP",
-  "EQ",
-  "LT",
-  "LE",
-  "TEST",
-  "TESTSET",
-  "CALL",
-  "TAILCALL",
-  "RETURN",
-  "FORLOOP",
-  "FORPREP",
-  "TFORCALL",
-  "TFORLOOP",
-  "SETLIST",
-  "CLOSURE",
-  "VARARG",
-  "EXTRAARG",
-  NULL
-};
-
-
-#define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
-
-LUAI_DDEF 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, OpArgN, OpArgN, iABx)		/* OP_LOADKX */
- ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_LOADBOOL */
- ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_LOADNIL */
- ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_GETUPVAL */
- ,opmode(0, 1, OpArgU, OpArgK, iABC)		/* OP_GETTABUP */
- ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_GETTABLE */
- ,opmode(0, 0, OpArgK, OpArgK, iABC)		/* OP_SETTABUP */
- ,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_MOD */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_POW */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_DIV */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_IDIV */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BAND */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BOR */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BXOR */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SHL */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SHR */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_UNM */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_BNOT */
- ,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, 0, OpArgN, 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(0, 0, OpArgN, OpArgU, iABC)		/* OP_TFORCALL */
- ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_TFORLOOP */
- ,opmode(0, 0, OpArgU, OpArgU, iABC)		/* OP_SETLIST */
- ,opmode(0, 1, OpArgU, OpArgN, iABx)		/* OP_CLOSURE */
- ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_VARARG */
- ,opmode(0, 0, OpArgU, OpArgU, iAx)		/* OP_EXTRAARG */
-};
-
diff --git a/lua/lua-5.3.5/src/lopcodes.h b/lua/lua-5.3.5/src/lopcodes.h
deleted file mode 100644
index 6feaa1c..0000000
--- a/lua/lua-5.3.5/src/lopcodes.h
+++ /dev/null
@@ -1,297 +0,0 @@
-/*
-** $Id: lopcodes.h,v 1.149.1.1 2017/04/19 17:20:42 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
-	'Ax' : 26 bits ('A', 'B', and 'C' together)
-	'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, iAx};  /* 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_Ax		(SIZE_C + SIZE_B + SIZE_A)
-
-#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
-#define POS_Ax		POS_A
-
-
-/*
-** 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
-
-#if SIZE_Ax < LUAI_BITSINT-1
-#define MAXARG_Ax	((1<<SIZE_Ax)-1)
-#else
-#define MAXARG_Ax	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(i,pos,size)	(cast(int, ((i)>>pos) & MASK1(size,0)))
-#define setarg(i,v,pos,size)	((i) = (((i)&MASK0(size,pos)) | \
-                ((cast(Instruction, v)<<pos)&MASK1(size,pos))))
-
-#define GETARG_A(i)	getarg(i, POS_A, SIZE_A)
-#define SETARG_A(i,v)	setarg(i, v, POS_A, SIZE_A)
-
-#define GETARG_B(i)	getarg(i, POS_B, SIZE_B)
-#define SETARG_B(i,v)	setarg(i, v, POS_B, SIZE_B)
-
-#define GETARG_C(i)	getarg(i, POS_C, SIZE_C)
-#define SETARG_C(i,v)	setarg(i, v, POS_C, SIZE_C)
-
-#define GETARG_Bx(i)	getarg(i, POS_Bx, SIZE_Bx)
-#define SETARG_Bx(i,v)	setarg(i, v, POS_Bx, SIZE_Bx)
-
-#define GETARG_Ax(i)	getarg(i, POS_Ax, SIZE_Ax)
-#define SETARG_Ax(i,v)	setarg(i, v, POS_Ax, SIZE_Ax)
-
-#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))
-
-#define CREATE_Ax(o,a)		((cast(Instruction, o)<<POS_OP) \
-			| (cast(Instruction, a)<<POS_Ax))
-
-
-/*
-** 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)
-
-#if !defined(MAXINDEXRK)  /* (for debugging only) */
-#define MAXINDEXRK	(BITRK - 1)
-#endif
-
-/* 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_LOADKX,/*	A 	R(A) := Kst(extra arg)				*/
-OP_LOADBOOL,/*	A B C	R(A) := (Bool)B; if (C) pc++			*/
-OP_LOADNIL,/*	A B	R(A), R(A+1), ..., R(A+B) := nil		*/
-OP_GETUPVAL,/*	A B	R(A) := UpValue[B]				*/
-
-OP_GETTABUP,/*	A B C	R(A) := UpValue[B][RK(C)]			*/
-OP_GETTABLE,/*	A B C	R(A) := R(B)[RK(C)]				*/
-
-OP_SETTABUP,/*	A B C	UpValue[A][RK(B)] := RK(C)			*/
-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_MOD,/*	A B C	R(A) := RK(B) % RK(C)				*/
-OP_POW,/*	A B C	R(A) := RK(B) ^ RK(C)				*/
-OP_DIV,/*	A B C	R(A) := RK(B) / RK(C)				*/
-OP_IDIV,/*	A B C	R(A) := RK(B) // RK(C)				*/
-OP_BAND,/*	A B C	R(A) := RK(B) & RK(C)				*/
-OP_BOR,/*	A B C	R(A) := RK(B) | RK(C)				*/
-OP_BXOR,/*	A B C	R(A) := RK(B) ~ RK(C)				*/
-OP_SHL,/*	A B C	R(A) := RK(B) << RK(C)				*/
-OP_SHR,/*	A B C	R(A) := RK(B) >> RK(C)				*/
-OP_UNM,/*	A B	R(A) := -R(B)					*/
-OP_BNOT,/*	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,/*	A sBx	pc+=sBx; if (A) close all upvalues >= R(A - 1)	*/
-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_TFORCALL,/*	A C	R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));	*/
-OP_TFORLOOP,/*	A sBx	if R(A+1) ~= nil then { R(A)=R(A+1); pc += sBx }*/
-
-OP_SETLIST,/*	A B C	R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B	*/
-
-OP_CLOSURE,/*	A Bx	R(A) := closure(KPROTO[Bx])			*/
-
-OP_VARARG,/*	A B	R(A), R(A+1), ..., R(A+B-2) = vararg		*/
-
-OP_EXTRAARG/*	Ax	extra (larger) argument for previous opcode	*/
-} OpCode;
-
-
-#define NUM_OPCODES	(cast(int, OP_EXTRAARG) + 1)
-
-
-
-/*===========================================================================
-  Notes:
-  (*) In OP_CALL, if (B == 0) then B = top. If (C == 0), then 'top' is
-  set 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 EXTRAARG(real C).
-
-  (*) In OP_LOADKX, the next 'instruction' is always EXTRAARG.
-
-  (*) 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 (next instruction must be a jump)
-*/
-
-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_DDEC 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_DDEC 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/lua/lua-5.3.5/src/loslib.c b/lua/lua-5.3.5/src/loslib.c
deleted file mode 100644
index de590c6..0000000
--- a/lua/lua-5.3.5/src/loslib.c
+++ /dev/null
@@ -1,409 +0,0 @@
-/*
-** $Id: loslib.c,v 1.65.1.1 2017/04/19 17:29:57 roberto Exp $
-** Standard Operating System library
-** See Copyright Notice in lua.h
-*/
-
-#define loslib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <errno.h>
-#include <locale.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/*
-** {==================================================================
-** List of valid conversion specifiers for the 'strftime' function;
-** options are grouped by length; group of length 2 start with '||'.
-** ===================================================================
-*/
-#if !defined(LUA_STRFTIMEOPTIONS)	/* { */
-
-/* options for ANSI C 89 (only 1-char options) */
-#define L_STRFTIMEC89		"aAbBcdHIjmMpSUwWxXyYZ%"
-
-/* options for ISO C 99 and POSIX */
-#define L_STRFTIMEC99 "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%" \
-    "||" "EcECExEXEyEY" "OdOeOHOIOmOMOSOuOUOVOwOWOy"  /* two-char options */
-
-/* options for Windows */
-#define L_STRFTIMEWIN "aAbBcdHIjmMpSUwWxXyYzZ%" \
-    "||" "#c#x#d#H#I#j#m#M#S#U#w#W#y#Y"  /* two-char options */
-
-#if defined(LUA_USE_WINDOWS)
-#define LUA_STRFTIMEOPTIONS	L_STRFTIMEWIN
-#elif defined(LUA_USE_C89)
-#define LUA_STRFTIMEOPTIONS	L_STRFTIMEC89
-#else  /* C99 specification */
-#define LUA_STRFTIMEOPTIONS	L_STRFTIMEC99
-#endif
-
-#endif					/* } */
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Configuration for time-related stuff
-** ===================================================================
-*/
-
-#if !defined(l_time_t)		/* { */
-/*
-** type to represent time_t in Lua
-*/
-#define l_timet			lua_Integer
-#define l_pushtime(L,t)		lua_pushinteger(L,(lua_Integer)(t))
-
-static time_t l_checktime (lua_State *L, int arg) {
-  lua_Integer t = luaL_checkinteger(L, arg);
-  luaL_argcheck(L, (time_t)t == t, arg, "time out-of-bounds");
-  return (time_t)t;
-}
-
-#endif				/* } */
-
-
-#if !defined(l_gmtime)		/* { */
-/*
-** By default, Lua uses gmtime/localtime, except when POSIX is available,
-** where it uses gmtime_r/localtime_r
-*/
-
-#if defined(LUA_USE_POSIX)	/* { */
-
-#define l_gmtime(t,r)		gmtime_r(t,r)
-#define l_localtime(t,r)	localtime_r(t,r)
-
-#else				/* }{ */
-
-/* ISO C definitions */
-#define l_gmtime(t,r)		((void)(r)->tm_sec, gmtime(t))
-#define l_localtime(t,r)  	((void)(r)->tm_sec, localtime(t))
-
-#endif				/* } */
-
-#endif				/* } */
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Configuration for 'tmpnam':
-** By default, Lua uses tmpnam except when POSIX is available, where
-** it uses mkstemp.
-** ===================================================================
-*/
-#if !defined(lua_tmpnam)	/* { */
-
-#if defined(LUA_USE_POSIX)	/* { */
-
-#include <unistd.h>
-
-#define LUA_TMPNAMBUFSIZE	32
-
-#if !defined(LUA_TMPNAMTEMPLATE)
-#define LUA_TMPNAMTEMPLATE	"/tmp/lua_XXXXXX"
-#endif
-
-#define lua_tmpnam(b,e) { \
-        strcpy(b, LUA_TMPNAMTEMPLATE); \
-        e = mkstemp(b); \
-        if (e != -1) close(e); \
-        e = (e == -1); }
-
-#else				/* }{ */
-
-/* ISO C definitions */
-#define LUA_TMPNAMBUFSIZE	L_tmpnam
-#define lua_tmpnam(b,e)		{ e = (tmpnam(b) == NULL); }
-
-#endif				/* } */
-
-#endif				/* } */
-/* }================================================================== */
-
-
-
-
-static int os_execute (lua_State *L) {
-  const char *cmd = luaL_optstring(L, 1, NULL);
-  int stat = system(cmd);
-  if (cmd != NULL)
-    return luaL_execresult(L, stat);
-  else {
-    lua_pushboolean(L, stat);  /* true if there is a shell */
-    return 1;
-  }
-}
-
-
-static int os_remove (lua_State *L) {
-  const char *filename = luaL_checkstring(L, 1);
-  return luaL_fileresult(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 luaL_fileresult(L, rename(fromname, toname) == 0, NULL);
-}
-
-
-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);
-}
-
-
-/*
-** Set all fields from structure 'tm' in the table on top of the stack
-*/
-static void setallfields (lua_State *L, struct tm *stm) {
-  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);
-}
-
-
-static int getboolfield (lua_State *L, const char *key) {
-  int res;
-  res = (lua_getfield(L, -1, key) == LUA_TNIL) ? -1 : lua_toboolean(L, -1);
-  lua_pop(L, 1);
-  return res;
-}
-
-
-/* maximum value for date fields (to avoid arithmetic overflows with 'int') */
-#if !defined(L_MAXDATEFIELD)
-#define L_MAXDATEFIELD	(INT_MAX / 2)
-#endif
-
-static int getfield (lua_State *L, const char *key, int d, int delta) {
-  int isnum;
-  int t = lua_getfield(L, -1, key);  /* get field and its type */
-  lua_Integer res = lua_tointegerx(L, -1, &isnum);
-  if (!isnum) {  /* field is not an integer? */
-    if (t != LUA_TNIL)  /* some other value? */
-      return luaL_error(L, "field '%s' is not an integer", key);
-    else if (d < 0)  /* absent field; no default? */
-      return luaL_error(L, "field '%s' missing in date table", key);
-    res = d;
-  }
-  else {
-    if (!(-L_MAXDATEFIELD <= res && res <= L_MAXDATEFIELD))
-      return luaL_error(L, "field '%s' is out-of-bound", key);
-    res -= delta;
-  }
-  lua_pop(L, 1);
-  return (int)res;
-}
-
-
-static const char *checkoption (lua_State *L, const char *conv,
-                                ptrdiff_t convlen, char *buff) {
-  const char *option = LUA_STRFTIMEOPTIONS;
-  int oplen = 1;  /* length of options being checked */
-  for (; *option != '\0' && oplen <= convlen; option += oplen) {
-    if (*option == '|')  /* next block? */
-      oplen++;  /* will check options with next length (+1) */
-    else if (memcmp(conv, option, oplen) == 0) {  /* match? */
-      memcpy(buff, conv, oplen);  /* copy valid option to buffer */
-      buff[oplen] = '\0';
-      return conv + oplen;  /* return next item */
-    }
-  }
-  luaL_argerror(L, 1,
-    lua_pushfstring(L, "invalid conversion specifier '%%%s'", conv));
-  return conv;  /* to avoid warnings */
-}
-
-
-/* maximum size for an individual 'strftime' item */
-#define SIZETIMEFMT	250
-
-
-static int os_date (lua_State *L) {
-  size_t slen;
-  const char *s = luaL_optlstring(L, 1, "%c", &slen);
-  time_t t = luaL_opt(L, l_checktime, 2, time(NULL));
-  const char *se = s + slen;  /* 's' end */
-  struct tm tmr, *stm;
-  if (*s == '!') {  /* UTC? */
-    stm = l_gmtime(&t, &tmr);
-    s++;  /* skip '!' */
-  }
-  else
-    stm = l_localtime(&t, &tmr);
-  if (stm == NULL)  /* invalid date? */
-    return luaL_error(L,
-                 "time result cannot be represented in this installation");
-  if (strcmp(s, "*t") == 0) {
-    lua_createtable(L, 0, 9);  /* 9 = number of fields */
-    setallfields(L, stm);
-  }
-  else {
-    char cc[4];  /* buffer for individual conversion specifiers */
-    luaL_Buffer b;
-    cc[0] = '%';
-    luaL_buffinit(L, &b);
-    while (s < se) {
-      if (*s != '%')  /* not a conversion specifier? */
-        luaL_addchar(&b, *s++);
-      else {
-        size_t reslen;
-        char *buff = luaL_prepbuffsize(&b, SIZETIMEFMT);
-        s++;  /* skip '%' */
-        s = checkoption(L, s, se - s, cc + 1);  /* copy specifier to 'cc' */
-        reslen = strftime(buff, SIZETIMEFMT, cc, stm);
-        luaL_addsize(&b, 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, 0);
-    ts.tm_min = getfield(L, "min", 0, 0);
-    ts.tm_hour = getfield(L, "hour", 12, 0);
-    ts.tm_mday = getfield(L, "day", -1, 0);
-    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);
-    setallfields(L, &ts);  /* update fields with normalized values */
-  }
-  if (t != (time_t)(l_timet)t || t == (time_t)(-1))
-    return luaL_error(L,
-                  "time result cannot be represented in this installation");
-  l_pushtime(L, t);
-  return 1;
-}
-
-
-static int os_difftime (lua_State *L) {
-  time_t t1 = l_checktime(L, 1);
-  time_t t2 = l_checktime(L, 2);
-  lua_pushnumber(L, (lua_Number)difftime(t1, t2));
-  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) {
-  int status;
-  if (lua_isboolean(L, 1))
-    status = (lua_toboolean(L, 1) ? EXIT_SUCCESS : EXIT_FAILURE);
-  else
-    status = (int)luaL_optinteger(L, 1, EXIT_SUCCESS);
-  if (lua_toboolean(L, 2))
-    lua_close(L);
-  if (L) exit(status);  /* 'if' to avoid warnings for unreachable 'return' */
-  return 0;
-}
-
-
-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}
-};
-
-/* }====================================================== */
-
-
-
-LUAMOD_API int luaopen_os (lua_State *L) {
-  luaL_newlib(L, syslib);
-  return 1;
-}
-
diff --git a/lua/lua-5.3.5/src/lparser.c b/lua/lua-5.3.5/src/lparser.c
deleted file mode 100644
index cc54de4..0000000
--- a/lua/lua-5.3.5/src/lparser.c
+++ /dev/null
@@ -1,1650 +0,0 @@
-/*
-** $Id: lparser.c,v 2.155.1.2 2017/04/29 18:11:40 roberto Exp $
-** Lua Parser
-** See Copyright Notice in lua.h
-*/
-
-#define lparser_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <string.h>
-
-#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"
-
-
-
-/* maximum number of local variables per function (must be smaller
-   than 250, due to the bytecode format) */
-#define MAXVARS		200
-
-
-#define hasmultret(k)		((k) == VCALL || (k) == VVARARG)
-
-
-/* because all strings are unified by the scanner, the parser
-   can use pointer equality for string equality */
-#define eqstr(a,b)	((a) == (b))
-
-
-/*
-** nodes for block list (list of active blocks)
-*/
-typedef struct BlockCnt {
-  struct BlockCnt *previous;  /* chain */
-  int firstlabel;  /* index of first label in this block */
-  int firstgoto;  /* index of first pending goto in this block */
-  lu_byte nactvar;  /* # active locals outside the block */
-  lu_byte upval;  /* true if some variable in the block is an upvalue */
-  lu_byte isloop;  /* true if 'block' is a loop */
-} BlockCnt;
-
-
-
-/*
-** prototypes for recursive non-terminal functions
-*/
-static void statement (LexState *ls);
-static void expr (LexState *ls, expdesc *v);
-
-
-/* semantic error */
-static l_noret semerror (LexState *ls, const char *msg) {
-  ls->t.token = 0;  /* remove "near <token>" from final message */
-  luaX_syntaxerror(ls, msg);
-}
-
-
-static l_noret error_expected (LexState *ls, int token) {
-  luaX_syntaxerror(ls,
-      luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token)));
-}
-
-
-static l_noret errorlimit (FuncState *fs, int limit, const char *what) {
-  lua_State *L = fs->ls->L;
-  const char *msg;
-  int line = fs->f->linedefined;
-  const char *where = (line == 0)
-                      ? "main function"
-                      : luaO_pushfstring(L, "function at line %d", line);
-  msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s",
-                             what, limit, where);
-  luaX_syntaxerror(fs->ls, msg);
-}
-
-
-static void checklimit (FuncState *fs, int v, int l, const char *what) {
-  if (v > l) errorlimit(fs, l, what);
-}
-
-
-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,
-             "%s expected (to close %s 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.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, "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++;
-}
-
-
-static void new_localvar (LexState *ls, TString *name) {
-  FuncState *fs = ls->fs;
-  Dyndata *dyd = ls->dyd;
-  int reg = registerlocalvar(ls, name);
-  checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal,
-                  MAXVARS, "local variables");
-  luaM_growvector(ls->L, dyd->actvar.arr, dyd->actvar.n + 1,
-                  dyd->actvar.size, Vardesc, MAX_INT, "local variables");
-  dyd->actvar.arr[dyd->actvar.n++].idx = cast(short, reg);
-}
-
-
-static void new_localvarliteral_ (LexState *ls, const char *name, size_t sz) {
-  new_localvar(ls, luaX_newstring(ls, name, sz));
-}
-
-#define new_localvarliteral(ls,v) \
-	new_localvarliteral_(ls, "" v, (sizeof(v)/sizeof(char))-1)
-
-
-static LocVar *getlocvar (FuncState *fs, int i) {
-  int idx = fs->ls->dyd->actvar.arr[fs->firstlocal + i].idx;
-  lua_assert(idx < fs->nlocvars);
-  return &fs->f->locvars[idx];
-}
-
-
-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 (FuncState *fs, int tolevel) {
-  fs->ls->dyd->actvar.n -= (fs->nactvar - tolevel);
-  while (fs->nactvar > tolevel)
-    getlocvar(fs, --fs->nactvar)->endpc = fs->pc;
-}
-
-
-static int searchupvalue (FuncState *fs, TString *name) {
-  int i;
-  Upvaldesc *up = fs->f->upvalues;
-  for (i = 0; i < fs->nups; i++) {
-    if (eqstr(up[i].name, name)) return i;
-  }
-  return -1;  /* not found */
-}
-
-
-static int newupvalue (FuncState *fs, TString *name, expdesc *v) {
-  Proto *f = fs->f;
-  int oldsize = f->sizeupvalues;
-  checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues");
-  luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues,
-                  Upvaldesc, MAXUPVAL, "upvalues");
-  while (oldsize < f->sizeupvalues)
-    f->upvalues[oldsize++].name = NULL;
-  f->upvalues[fs->nups].instack = (v->k == VLOCAL);
-  f->upvalues[fs->nups].idx = cast_byte(v->u.info);
-  f->upvalues[fs->nups].name = name;
-  luaC_objbarrier(fs->ls->L, f, name);
-  return fs->nups++;
-}
-
-
-static int searchvar (FuncState *fs, TString *n) {
-  int i;
-  for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) {
-    if (eqstr(n, getlocvar(fs, i)->varname))
-      return i;
-  }
-  return -1;  /* not found */
-}
-
-
-/*
-  Mark block where variable at given level was defined
-  (to emit close instructions later).
-*/
-static void markupval (FuncState *fs, int level) {
-  BlockCnt *bl = fs->bl;
-  while (bl->nactvar > level)
-    bl = bl->previous;
-  bl->upval = 1;
-}
-
-
-/*
-  Find variable with given name 'n'. If it is an upvalue, add this
-  upvalue into all intermediate functions.
-*/
-static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
-  if (fs == NULL)  /* no more levels? */
-    init_exp(var, VVOID, 0);  /* default is global */
-  else {
-    int v = searchvar(fs, n);  /* look up locals at current level */
-    if (v >= 0) {  /* found? */
-      init_exp(var, VLOCAL, v);  /* variable is local */
-      if (!base)
-        markupval(fs, v);  /* local will be used as an upval */
-    }
-    else {  /* not found as local at current level; try upvalues */
-      int idx = searchupvalue(fs, n);  /* try existing upvalues */
-      if (idx < 0) {  /* not found? */
-        singlevaraux(fs->prev, n, var, 0);  /* try upper levels */
-        if (var->k == VVOID)  /* not found? */
-          return;  /* it is a global */
-        /* else was LOCAL or UPVAL */
-        idx  = newupvalue(fs, n, var);  /* will be a new upvalue */
-      }
-      init_exp(var, VUPVAL, idx);  /* new or old upvalue */
-    }
-  }
-}
-
-
-static void singlevar (LexState *ls, expdesc *var) {
-  TString *varname = str_checkname(ls);
-  FuncState *fs = ls->fs;
-  singlevaraux(fs, varname, var, 1);
-  if (var->k == VVOID) {  /* global name? */
-    expdesc key;
-    singlevaraux(fs, ls->envn, var, 1);  /* get environment variable */
-    lua_assert(var->k != VVOID);  /* this one must exist */
-    codestring(ls, &key, varname);  /* key is variable name */
-    luaK_indexed(fs, var, &key);  /* env[varname] */
-  }
-}
-
-
-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);
-    }
-  }
-  if (nexps > nvars)
-    ls->fs->freereg -= nexps - nvars;  /* remove extra values */
-}
-
-
-static void enterlevel (LexState *ls) {
-  lua_State *L = ls->L;
-  ++L->nCcalls;
-  checklimit(ls->fs, L->nCcalls, LUAI_MAXCCALLS, "C levels");
-}
-
-
-#define leavelevel(ls)	((ls)->L->nCcalls--)
-
-
-static void closegoto (LexState *ls, int g, Labeldesc *label) {
-  int i;
-  FuncState *fs = ls->fs;
-  Labellist *gl = &ls->dyd->gt;
-  Labeldesc *gt = &gl->arr[g];
-  lua_assert(eqstr(gt->name, label->name));
-  if (gt->nactvar < label->nactvar) {
-    TString *vname = getlocvar(fs, gt->nactvar)->varname;
-    const char *msg = luaO_pushfstring(ls->L,
-      "<goto %s> at line %d jumps into the scope of local '%s'",
-      getstr(gt->name), gt->line, getstr(vname));
-    semerror(ls, msg);
-  }
-  luaK_patchlist(fs, gt->pc, label->pc);
-  /* remove goto from pending list */
-  for (i = g; i < gl->n - 1; i++)
-    gl->arr[i] = gl->arr[i + 1];
-  gl->n--;
-}
-
-
-/*
-** try to close a goto with existing labels; this solves backward jumps
-*/
-static int findlabel (LexState *ls, int g) {
-  int i;
-  BlockCnt *bl = ls->fs->bl;
-  Dyndata *dyd = ls->dyd;
-  Labeldesc *gt = &dyd->gt.arr[g];
-  /* check labels in current block for a match */
-  for (i = bl->firstlabel; i < dyd->label.n; i++) {
-    Labeldesc *lb = &dyd->label.arr[i];
-    if (eqstr(lb->name, gt->name)) {  /* correct label? */
-      if (gt->nactvar > lb->nactvar &&
-          (bl->upval || dyd->label.n > bl->firstlabel))
-        luaK_patchclose(ls->fs, gt->pc, lb->nactvar);
-      closegoto(ls, g, lb);  /* close it */
-      return 1;
-    }
-  }
-  return 0;  /* label not found; cannot close goto */
-}
-
-
-static int newlabelentry (LexState *ls, Labellist *l, TString *name,
-                          int line, int pc) {
-  int n = l->n;
-  luaM_growvector(ls->L, l->arr, n, l->size,
-                  Labeldesc, SHRT_MAX, "labels/gotos");
-  l->arr[n].name = name;
-  l->arr[n].line = line;
-  l->arr[n].nactvar = ls->fs->nactvar;
-  l->arr[n].pc = pc;
-  l->n = n + 1;
-  return n;
-}
-
-
-/*
-** check whether new label 'lb' matches any pending gotos in current
-** block; solves forward jumps
-*/
-static void findgotos (LexState *ls, Labeldesc *lb) {
-  Labellist *gl = &ls->dyd->gt;
-  int i = ls->fs->bl->firstgoto;
-  while (i < gl->n) {
-    if (eqstr(gl->arr[i].name, lb->name))
-      closegoto(ls, i, lb);
-    else
-      i++;
-  }
-}
-
-
-/*
-** export pending gotos to outer level, to check them against
-** outer labels; if the block being exited has upvalues, and
-** the goto exits the scope of any variable (which can be the
-** upvalue), close those variables being exited.
-*/
-static void movegotosout (FuncState *fs, BlockCnt *bl) {
-  int i = bl->firstgoto;
-  Labellist *gl = &fs->ls->dyd->gt;
-  /* correct pending gotos to current block and try to close it
-     with visible labels */
-  while (i < gl->n) {
-    Labeldesc *gt = &gl->arr[i];
-    if (gt->nactvar > bl->nactvar) {
-      if (bl->upval)
-        luaK_patchclose(fs, gt->pc, bl->nactvar);
-      gt->nactvar = bl->nactvar;
-    }
-    if (!findlabel(fs->ls, i))
-      i++;  /* move to next one */
-  }
-}
-
-
-static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) {
-  bl->isloop = isloop;
-  bl->nactvar = fs->nactvar;
-  bl->firstlabel = fs->ls->dyd->label.n;
-  bl->firstgoto = fs->ls->dyd->gt.n;
-  bl->upval = 0;
-  bl->previous = fs->bl;
-  fs->bl = bl;
-  lua_assert(fs->freereg == fs->nactvar);
-}
-
-
-/*
-** create a label named 'break' to resolve break statements
-*/
-static void breaklabel (LexState *ls) {
-  TString *n = luaS_new(ls->L, "break");
-  int l = newlabelentry(ls, &ls->dyd->label, n, 0, ls->fs->pc);
-  findgotos(ls, &ls->dyd->label.arr[l]);
-}
-
-/*
-** generates an error for an undefined 'goto'; choose appropriate
-** message when label name is a reserved word (which can only be 'break')
-*/
-static l_noret undefgoto (LexState *ls, Labeldesc *gt) {
-  const char *msg = isreserved(gt->name)
-                    ? "<%s> at line %d not inside a loop"
-                    : "no visible label '%s' for <goto> at line %d";
-  msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line);
-  semerror(ls, msg);
-}
-
-
-static void leaveblock (FuncState *fs) {
-  BlockCnt *bl = fs->bl;
-  LexState *ls = fs->ls;
-  if (bl->previous && bl->upval) {
-    /* create a 'jump to here' to close upvalues */
-    int j = luaK_jump(fs);
-    luaK_patchclose(fs, j, bl->nactvar);
-    luaK_patchtohere(fs, j);
-  }
-  if (bl->isloop)
-    breaklabel(ls);  /* close pending breaks */
-  fs->bl = bl->previous;
-  removevars(fs, bl->nactvar);
-  lua_assert(bl->nactvar == fs->nactvar);
-  fs->freereg = fs->nactvar;  /* free registers */
-  ls->dyd->label.n = bl->firstlabel;  /* remove local labels */
-  if (bl->previous)  /* inner block? */
-    movegotosout(fs, bl);  /* update pending gotos to outer block */
-  else if (bl->firstgoto < ls->dyd->gt.n)  /* pending gotos in outer block? */
-    undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]);  /* error */
-}
-
-
-/*
-** adds a new prototype into list of prototypes
-*/
-static Proto *addprototype (LexState *ls) {
-  Proto *clp;
-  lua_State *L = ls->L;
-  FuncState *fs = ls->fs;
-  Proto *f = fs->f;  /* prototype of current function */
-  if (fs->np >= f->sizep) {
-    int oldsize = f->sizep;
-    luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions");
-    while (oldsize < f->sizep)
-      f->p[oldsize++] = NULL;
-  }
-  f->p[fs->np++] = clp = luaF_newproto(L);
-  luaC_objbarrier(L, f, clp);
-  return clp;
-}
-
-
-/*
-** codes instruction to create new closure in parent function.
-** The OP_CLOSURE instruction must use the last available register,
-** so that, if it invokes the GC, the GC knows which registers
-** are in use at that time.
-*/
-static void codeclosure (LexState *ls, expdesc *v) {
-  FuncState *fs = ls->fs->prev;
-  init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1));
-  luaK_exp2nextreg(fs, v);  /* fix it at the last register */
-}
-
-
-static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) {
-  Proto *f;
-  fs->prev = ls->fs;  /* linked list of funcstates */
-  fs->ls = ls;
-  ls->fs = fs;
-  fs->pc = 0;
-  fs->lasttarget = 0;
-  fs->jpc = NO_JUMP;
-  fs->freereg = 0;
-  fs->nk = 0;
-  fs->np = 0;
-  fs->nups = 0;
-  fs->nlocvars = 0;
-  fs->nactvar = 0;
-  fs->firstlocal = ls->dyd->actvar.n;
-  fs->bl = NULL;
-  f = fs->f;
-  f->source = ls->source;
-  f->maxstacksize = 2;  /* registers 0/1 are always valid */
-  enterblock(fs, bl, 0);
-}
-
-
-static void close_func (LexState *ls) {
-  lua_State *L = ls->L;
-  FuncState *fs = ls->fs;
-  Proto *f = fs->f;
-  luaK_ret(fs, 0, 0);  /* final return */
-  leaveblock(fs);
-  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, fs->nups, Upvaldesc);
-  f->sizeupvalues = fs->nups;
-  lua_assert(fs->bl == NULL);
-  ls->fs = fs->prev;
-  luaC_checkGC(L);
-}
-
-
-
-/*============================================================*/
-/* GRAMMAR RULES */
-/*============================================================*/
-
-
-/*
-** check whether current token is in the follow set of a block.
-** 'until' closes syntactical blocks, but do not close scope,
-** so it is handled in separate.
-*/
-static int block_follow (LexState *ls, int withuntil) {
-  switch (ls->t.token) {
-    case TK_ELSE: case TK_ELSEIF:
-    case TK_END: case TK_EOS:
-      return 1;
-    case TK_UNTIL: return withuntil;
-    default: return 0;
-  }
-}
-
-
-static void statlist (LexState *ls) {
-  /* statlist -> { stat [';'] } */
-  while (!block_follow(ls, 1)) {
-    if (ls->t.token == TK_RETURN) {
-      statement(ls);
-      return;  /* 'return' must be last statement */
-    }
-    statement(ls);
-  }
-}
-
-
-static void fieldsel (LexState *ls, expdesc *v) {
-  /* fieldsel -> ['.' | ':'] NAME */
-  FuncState *fs = ls->fs;
-  expdesc key;
-  luaK_exp2anyregup(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) {
-    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.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.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.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.info, cc->na, cc->tostore);
-  }
-}
-
-
-static void listfield (LexState *ls, struct ConsControl *cc) {
-  /* listfield -> exp */
-  expr(ls, &cc->v);
-  checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
-  cc->na++;
-  cc->tostore++;
-}
-
-
-static void field (LexState *ls, struct ConsControl *cc) {
-  /* field -> listfield | recfield */
-  switch(ls->t.token) {
-    case TK_NAME: {  /* may be 'listfield' or 'recfield' */
-      if (luaX_lookahead(ls) != '=')  /* expression? */
-        listfield(ls, cc);
-      else
-        recfield(ls, cc);
-      break;
-    }
-    case '[': {
-      recfield(ls, cc);
-      break;
-    }
-    default: {
-      listfield(ls, cc);
-      break;
-    }
-  }
-}
-
-
-static void constructor (LexState *ls, expdesc *t) {
-  /* constructor -> '{' [ field { sep field } [sep] ] '}'
-     sep -> ',' | ';' */
-  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 */
-  checknext(ls, '{');
-  do {
-    lua_assert(cc.v.k == VVOID || cc.tostore > 0);
-    if (ls->t.token == '}') break;
-    closelistfield(fs, &cc);
-    field(ls, &cc);
-  } 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);
-          f->is_vararg = 1;  /* declared vararg */
-          break;
-        }
-        default: luaX_syntaxerror(ls, "<name> or '...' expected");
-      }
-    } while (!f->is_vararg && testnext(ls, ','));
-  }
-  adjustlocalvars(ls, nparams);
-  f->numparams = cast_byte(fs->nactvar);
-  luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */
-}
-
-
-static void body (LexState *ls, expdesc *e, int ismethod, int line) {
-  /* body ->  '(' parlist ')' block END */
-  FuncState new_fs;
-  BlockCnt bl;
-  new_fs.f = addprototype(ls);
-  new_fs.f->linedefined = line;
-  open_func(ls, &new_fs, &bl);
-  checknext(ls, '(');
-  if (ismethod) {
-    new_localvarliteral(ls, "self");  /* create 'self' parameter */
-    adjustlocalvars(ls, 1);
-  }
-  parlist(ls);
-  checknext(ls, ')');
-  statlist(ls);
-  new_fs.f->lastlinedefined = ls->linenumber;
-  check_match(ls, TK_END, TK_FUNCTION, line);
-  codeclosure(ls, e);
-  close_func(ls);
-}
-
-
-static int explist (LexState *ls, expdesc *v) {
-  /* explist -> 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, int line) {
-  FuncState *fs = ls->fs;
-  expdesc args;
-  int base, nparams;
-  switch (ls->t.token) {
-    case '(': {  /* funcargs -> '(' [ explist ] ')' */
-      luaX_next(ls);
-      if (ls->t.token == ')')  /* arg list is empty? */
-        args.k = VVOID;
-      else {
-        explist(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");
-    }
-  }
-  lua_assert(f->k == VNONRELOC);
-  base = f->u.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 primaryexp (LexState *ls, expdesc *v) {
-  /* primaryexp -> 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");
-    }
-  }
-}
-
-
-static void suffixedexp (LexState *ls, expdesc *v) {
-  /* suffixedexp ->
-       primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */
-  FuncState *fs = ls->fs;
-  int line = ls->linenumber;
-  primaryexp(ls, v);
-  for (;;) {
-    switch (ls->t.token) {
-      case '.': {  /* fieldsel */
-        fieldsel(ls, v);
-        break;
-      }
-      case '[': {  /* '[' exp1 ']' */
-        expdesc key;
-        luaK_exp2anyregup(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, line);
-        break;
-      }
-      case '(': case TK_STRING: case '{': {  /* funcargs */
-        luaK_exp2nextreg(fs, v);
-        funcargs(ls, v, line);
-        break;
-      }
-      default: return;
-    }
-  }
-}
-
-
-static void simpleexp (LexState *ls, expdesc *v) {
-  /* simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... |
-                  constructor | FUNCTION body | suffixedexp */
-  switch (ls->t.token) {
-    case TK_FLT: {
-      init_exp(v, VKFLT, 0);
-      v->u.nval = ls->t.seminfo.r;
-      break;
-    }
-    case TK_INT: {
-      init_exp(v, VKINT, 0);
-      v->u.ival = ls->t.seminfo.i;
-      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 '...' outside a vararg function");
-      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: {
-      suffixedexp(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_BNOT;
-    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_MOD;
-    case '^': return OPR_POW;
-    case '/': return OPR_DIV;
-    case TK_IDIV: return OPR_IDIV;
-    case '&': return OPR_BAND;
-    case '|': return OPR_BOR;
-    case '~': return OPR_BXOR;
-    case TK_SHL: return OPR_SHL;
-    case TK_SHR: return OPR_SHR;
-    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 */
-   {10, 10}, {10, 10},           /* '+' '-' */
-   {11, 11}, {11, 11},           /* '*' '%' */
-   {14, 13},                  /* '^' (right associative) */
-   {11, 11}, {11, 11},           /* '/' '//' */
-   {6, 6}, {4, 4}, {5, 5},   /* '&' '|' '~' */
-   {7, 7}, {7, 7},           /* '<<' '>>' */
-   {9, 8},                   /* '..' (right associative) */
-   {3, 3}, {3, 3}, {3, 3},   /* ==, <, <= */
-   {3, 3}, {3, 3}, {3, 3},   /* ~=, >, >= */
-   {2, 2}, {1, 1}            /* and, or */
-};
-
-#define UNARY_PRIORITY	12  /* 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, int limit) {
-  BinOpr op;
-  UnOpr uop;
-  enterlevel(ls);
-  uop = getunopr(ls->t.token);
-  if (uop != OPR_NOUNOPR) {
-    int line = ls->linenumber;
-    luaX_next(ls);
-    subexpr(ls, v, UNARY_PRIORITY);
-    luaK_prefix(ls->fs, uop, v, line);
-  }
-  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;
-    int line = ls->linenumber;
-    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, line);
-    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 void block (LexState *ls) {
-  /* block -> statlist */
-  FuncState *fs = ls->fs;
-  BlockCnt bl;
-  enterblock(fs, &bl, 0);
-  statlist(ls);
-  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 an upvalue/local variable, the
-** upvalue/local variable is begin used in a previous assignment to a
-** table. If so, save original upvalue/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) {  /* check all previous assignments */
-    if (lh->v.k == VINDEXED) {  /* assigning to a table? */
-      /* table is the upvalue/local being assigned now? */
-      if (lh->v.u.ind.vt == v->k && lh->v.u.ind.t == v->u.info) {
-        conflict = 1;
-        lh->v.u.ind.vt = VLOCAL;
-        lh->v.u.ind.t = extra;  /* previous assignment will use safe copy */
-      }
-      /* index is the local being assigned? (index cannot be upvalue) */
-      if (v->k == VLOCAL && lh->v.u.ind.idx == v->u.info) {
-        conflict = 1;
-        lh->v.u.ind.idx = extra;  /* previous assignment will use safe copy */
-      }
-    }
-  }
-  if (conflict) {
-    /* copy upvalue/local value to a temporary (in position 'extra') */
-    OpCode op = (v->k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
-    luaK_codeABC(fs, op, extra, v->u.info, 0);
-    luaK_reserveregs(fs, 1);
-  }
-}
-
-
-static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
-  expdesc e;
-  check_condition(ls, vkisvar(lh->v.k), "syntax error");
-  if (testnext(ls, ',')) {  /* assignment -> ',' suffixedexp assignment */
-    struct LHS_assign nv;
-    nv.prev = lh;
-    suffixedexp(ls, &nv.v);
-    if (nv.v.k != VINDEXED)
-      check_conflict(ls, lh, &nv.v);
-    checklimit(ls->fs, nvars + ls->L->nCcalls, LUAI_MAXCCALLS,
-                    "C levels");
-    assignment(ls, &nv, nvars+1);
-  }
-  else {  /* assignment -> '=' explist */
-    int nexps;
-    checknext(ls, '=');
-    nexps = explist(ls, &e);
-    if (nexps != nvars)
-      adjust_assign(ls, nvars, nexps, &e);
-    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 gotostat (LexState *ls, int pc) {
-  int line = ls->linenumber;
-  TString *label;
-  int g;
-  if (testnext(ls, TK_GOTO))
-    label = str_checkname(ls);
-  else {
-    luaX_next(ls);  /* skip break */
-    label = luaS_new(ls->L, "break");
-  }
-  g = newlabelentry(ls, &ls->dyd->gt, label, line, pc);
-  findlabel(ls, g);  /* close it if label already defined */
-}
-
-
-/* check for repeated labels on the same block */
-static void checkrepeated (FuncState *fs, Labellist *ll, TString *label) {
-  int i;
-  for (i = fs->bl->firstlabel; i < ll->n; i++) {
-    if (eqstr(label, ll->arr[i].name)) {
-      const char *msg = luaO_pushfstring(fs->ls->L,
-                          "label '%s' already defined on line %d",
-                          getstr(label), ll->arr[i].line);
-      semerror(fs->ls, msg);
-    }
-  }
-}
-
-
-/* skip no-op statements */
-static void skipnoopstat (LexState *ls) {
-  while (ls->t.token == ';' || ls->t.token == TK_DBCOLON)
-    statement(ls);
-}
-
-
-static void labelstat (LexState *ls, TString *label, int line) {
-  /* label -> '::' NAME '::' */
-  FuncState *fs = ls->fs;
-  Labellist *ll = &ls->dyd->label;
-  int l;  /* index of new label being created */
-  checkrepeated(fs, ll, label);  /* check for repeated labels */
-  checknext(ls, TK_DBCOLON);  /* skip double colon */
-  /* create new entry for this label */
-  l = newlabelentry(ls, ll, label, line, luaK_getlabel(fs));
-  skipnoopstat(ls);  /* skip other no-op statements */
-  if (block_follow(ls, 0)) {  /* label is last no-op statement in the block? */
-    /* assume that locals are already out of scope */
-    ll->arr[l].nactvar = fs->bl->nactvar;
-  }
-  findgotos(ls, &ll->arr[l]);
-}
-
-
-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_jumpto(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 */
-  statlist(ls);
-  check_match(ls, TK_UNTIL, TK_REPEAT, line);
-  condexit = cond(ls);  /* read condition (inside scope block) */
-  if (bl2.upval)  /* upvalues? */
-    luaK_patchclose(fs, condexit, bl2.nactvar);
-  leaveblock(fs);  /* finish scope */
-  luaK_patchlist(fs, condexit, repeat_init);  /* close the loop */
-  leaveblock(fs);  /* finish loop */
-}
-
-
-static int exp1 (LexState *ls) {
-  expdesc e;
-  int reg;
-  expr(ls, &e);
-  luaK_exp2nextreg(ls->fs, &e);
-  lua_assert(e.k == VNONRELOC);
-  reg = e.u.info;
-  return reg;
-}
-
-
-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);
-  if (isnum)  /* numeric for? */
-    endfor = luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP);
-  else {  /* generic for */
-    luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars);
-    luaK_fixline(fs, line);
-    endfor = luaK_codeAsBx(fs, OP_TFORLOOP, base + 2, NO_JUMP);
-  }
-  luaK_patchlist(fs, endfor, prep + 1);
-  luaK_fixline(fs, line);
-}
-
-
-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)");
-  new_localvarliteral(ls, "(for limit)");
-  new_localvarliteral(ls, "(for step)");
-  new_localvar(ls, varname);
-  checknext(ls, '=');
-  exp1(ls);  /* initial value */
-  checknext(ls, ',');
-  exp1(ls);  /* limit */
-  if (testnext(ls, ','))
-    exp1(ls);  /* optional step */
-  else {  /* default step = 1 */
-    luaK_codek(fs, fs->freereg, luaK_intK(fs, 1));
-    luaK_reserveregs(fs, 1);
-  }
-  forbody(ls, base, line, 1, 1);
-}
-
-
-static void forlist (LexState *ls, TString *indexname) {
-  /* forlist -> NAME {,NAME} IN explist forbody */
-  FuncState *fs = ls->fs;
-  expdesc e;
-  int nvars = 4;  /* gen, state, control, plus at least one declared var */
-  int line;
-  int base = fs->freereg;
-  /* create control variables */
-  new_localvarliteral(ls, "(for generator)");
-  new_localvarliteral(ls, "(for state)");
-  new_localvarliteral(ls, "(for control)");
-  /* create declared variables */
-  new_localvar(ls, indexname);
-  while (testnext(ls, ',')) {
-    new_localvar(ls, str_checkname(ls));
-    nvars++;
-  }
-  checknext(ls, TK_IN);
-  line = ls->linenumber;
-  adjust_assign(ls, 3, explist(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, "'=' or 'in' expected");
-  }
-  check_match(ls, TK_END, TK_FOR, line);
-  leaveblock(fs);  /* loop scope ('break' jumps to this point) */
-}
-
-
-static void test_then_block (LexState *ls, int *escapelist) {
-  /* test_then_block -> [IF | ELSEIF] cond THEN block */
-  BlockCnt bl;
-  FuncState *fs = ls->fs;
-  expdesc v;
-  int jf;  /* instruction to skip 'then' code (if condition is false) */
-  luaX_next(ls);  /* skip IF or ELSEIF */
-  expr(ls, &v);  /* read condition */
-  checknext(ls, TK_THEN);
-  if (ls->t.token == TK_GOTO || ls->t.token == TK_BREAK) {
-    luaK_goiffalse(ls->fs, &v);  /* will jump to label if condition is true */
-    enterblock(fs, &bl, 0);  /* must enter block before 'goto' */
-    gotostat(ls, v.t);  /* handle goto/break */
-    while (testnext(ls, ';')) {}  /* skip colons */
-    if (block_follow(ls, 0)) {  /* 'goto' is the entire block? */
-      leaveblock(fs);
-      return;  /* and that is it */
-    }
-    else  /* must skip over 'then' part if condition is false */
-      jf = luaK_jump(fs);
-  }
-  else {  /* regular case (not goto/break) */
-    luaK_goiftrue(ls->fs, &v);  /* skip over block if condition is false */
-    enterblock(fs, &bl, 0);
-    jf = v.f;
-  }
-  statlist(ls);  /* 'then' part */
-  leaveblock(fs);
-  if (ls->t.token == TK_ELSE ||
-      ls->t.token == TK_ELSEIF)  /* followed by 'else'/'elseif'? */
-    luaK_concat(fs, escapelist, luaK_jump(fs));  /* must jump over it */
-  luaK_patchtohere(fs, jf);
-}
-
-
-static void ifstat (LexState *ls, int line) {
-  /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
-  FuncState *fs = ls->fs;
-  int escapelist = NO_JUMP;  /* exit list for finished parts */
-  test_then_block(ls, &escapelist);  /* IF cond THEN block */
-  while (ls->t.token == TK_ELSEIF)
-    test_then_block(ls, &escapelist);  /* ELSEIF cond THEN block */
-  if (testnext(ls, TK_ELSE))
-    block(ls);  /* 'else' part */
-  check_match(ls, TK_END, TK_IF, line);
-  luaK_patchtohere(fs, escapelist);  /* patch escape list to 'if' end */
-}
-
-
-static void localfunc (LexState *ls) {
-  expdesc b;
-  FuncState *fs = ls->fs;
-  new_localvar(ls, str_checkname(ls));  /* new local variable */
-  adjustlocalvars(ls, 1);  /* enter its scope */
-  body(ls, &b, 0, ls->linenumber);  /* function created in next register */
-  /* debug information will only see the variable after this point! */
-  getlocvar(fs, b.u.info)->startpc = fs->pc;
-}
-
-
-static void localstat (LexState *ls) {
-  /* stat -> LOCAL NAME {',' NAME} ['=' explist] */
-  int nvars = 0;
-  int nexps;
-  expdesc e;
-  do {
-    new_localvar(ls, str_checkname(ls));
-    nvars++;
-  } while (testnext(ls, ','));
-  if (testnext(ls, '='))
-    nexps = explist(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 {fieldsel} [':' NAME] */
-  int ismethod = 0;
-  singlevar(ls, v);
-  while (ls->t.token == '.')
-    fieldsel(ls, v);
-  if (ls->t.token == ':') {
-    ismethod = 1;
-    fieldsel(ls, v);
-  }
-  return ismethod;
-}
-
-
-static void funcstat (LexState *ls, int line) {
-  /* funcstat -> FUNCTION funcname body */
-  int ismethod;
-  expdesc v, b;
-  luaX_next(ls);  /* skip FUNCTION */
-  ismethod = funcname(ls, &v);
-  body(ls, &b, ismethod, 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;
-  suffixedexp(ls, &v.v);
-  if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */
-    v.prev = NULL;
-    assignment(ls, &v, 1);
-  }
-  else {  /* stat -> func */
-    check_condition(ls, v.v.k == VCALL, "syntax error");
-    SETARG_C(getinstruction(fs, &v.v), 1);  /* call statement uses no results */
-  }
-}
-
-
-static void retstat (LexState *ls) {
-  /* stat -> RETURN [explist] [';'] */
-  FuncState *fs = ls->fs;
-  expdesc e;
-  int first, nret;  /* registers with returned values */
-  if (block_follow(ls, 1) || ls->t.token == ';')
-    first = nret = 0;  /* return no values */
-  else {
-    nret = explist(ls, &e);  /* optional return values */
-    if (hasmultret(e.k)) {
-      luaK_setmultret(fs, &e);
-      if (e.k == VCALL && nret == 1) {  /* tail call? */
-        SET_OPCODE(getinstruction(fs,&e), OP_TAILCALL);
-        lua_assert(GETARG_A(getinstruction(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);
-  testnext(ls, ';');  /* skip optional semicolon */
-}
-
-
-static void statement (LexState *ls) {
-  int line = ls->linenumber;  /* may be needed for error messages */
-  enterlevel(ls);
-  switch (ls->t.token) {
-    case ';': {  /* stat -> ';' (empty statement) */
-      luaX_next(ls);  /* skip ';' */
-      break;
-    }
-    case TK_IF: {  /* stat -> ifstat */
-      ifstat(ls, line);
-      break;
-    }
-    case TK_WHILE: {  /* stat -> whilestat */
-      whilestat(ls, line);
-      break;
-    }
-    case TK_DO: {  /* stat -> DO block END */
-      luaX_next(ls);  /* skip DO */
-      block(ls);
-      check_match(ls, TK_END, TK_DO, line);
-      break;
-    }
-    case TK_FOR: {  /* stat -> forstat */
-      forstat(ls, line);
-      break;
-    }
-    case TK_REPEAT: {  /* stat -> repeatstat */
-      repeatstat(ls, line);
-      break;
-    }
-    case TK_FUNCTION: {  /* stat -> funcstat */
-      funcstat(ls, line);
-      break;
-    }
-    case TK_LOCAL: {  /* stat -> localstat */
-      luaX_next(ls);  /* skip LOCAL */
-      if (testnext(ls, TK_FUNCTION))  /* local function? */
-        localfunc(ls);
-      else
-        localstat(ls);
-      break;
-    }
-    case TK_DBCOLON: {  /* stat -> label */
-      luaX_next(ls);  /* skip double colon */
-      labelstat(ls, str_checkname(ls), line);
-      break;
-    }
-    case TK_RETURN: {  /* stat -> retstat */
-      luaX_next(ls);  /* skip RETURN */
-      retstat(ls);
-      break;
-    }
-    case TK_BREAK:   /* stat -> breakstat */
-    case TK_GOTO: {  /* stat -> 'goto' NAME */
-      gotostat(ls, luaK_jump(ls->fs));
-      break;
-    }
-    default: {  /* stat -> func | assignment */
-      exprstat(ls);
-      break;
-    }
-  }
-  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);
-}
-
-/* }====================================================================== */
-
-
-/*
-** compiles the main function, which is a regular vararg function with an
-** upvalue named LUA_ENV
-*/
-static void mainfunc (LexState *ls, FuncState *fs) {
-  BlockCnt bl;
-  expdesc v;
-  open_func(ls, fs, &bl);
-  fs->f->is_vararg = 1;  /* main function is always declared vararg */
-  init_exp(&v, VLOCAL, 0);  /* create and... */
-  newupvalue(fs, ls->envn, &v);  /* ...set environment upvalue */
-  luaX_next(ls);  /* read first token */
-  statlist(ls);  /* parse main body */
-  check(ls, TK_EOS);
-  close_func(ls);
-}
-
-
-LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
-                       Dyndata *dyd, const char *name, int firstchar) {
-  LexState lexstate;
-  FuncState funcstate;
-  LClosure *cl = luaF_newLclosure(L, 1);  /* create main closure */
-  setclLvalue(L, L->top, cl);  /* anchor it (to avoid being collected) */
-  luaD_inctop(L);
-  lexstate.h = luaH_new(L);  /* create table for scanner */
-  sethvalue(L, L->top, lexstate.h);  /* anchor it */
-  luaD_inctop(L);
-  funcstate.f = cl->p = luaF_newproto(L);
-  funcstate.f->source = luaS_new(L, name);  /* create and anchor TString */
-  lua_assert(iswhite(funcstate.f));  /* do not need barrier here */
-  lexstate.buff = buff;
-  lexstate.dyd = dyd;
-  dyd->actvar.n = dyd->gt.n = dyd->label.n = 0;
-  luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar);
-  mainfunc(&lexstate, &funcstate);
-  lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs);
-  /* all scopes should be correctly finished */
-  lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0);
-  L->top--;  /* remove scanner's table */
-  return cl;  /* closure is on the stack, too */
-}
-
diff --git a/lua/lua-5.3.5/src/lparser.h b/lua/lua-5.3.5/src/lparser.h
deleted file mode 100644
index f45b23c..0000000
--- a/lua/lua-5.3.5/src/lparser.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
-** $Id: lparser.h,v 1.76.1.1 2017/04/19 17:20:42 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 and variable descriptor.
-** Code generation for variables and expressions can be delayed to allow
-** optimizations; An 'expdesc' structure describes a potentially-delayed
-** variable/expression. It has a description of its "main" value plus a
-** list of conditional jumps that can also produce its value (generated
-** by short-circuit operators 'and'/'or').
-*/
-
-/* kinds of variables/expressions */
-typedef enum {
-  VVOID,  /* when 'expdesc' describes the last expression a list,
-             this kind means an empty list (so, no expression) */
-  VNIL,  /* constant nil */
-  VTRUE,  /* constant true */
-  VFALSE,  /* constant false */
-  VK,  /* constant in 'k'; info = index of constant in 'k' */
-  VKFLT,  /* floating constant; nval = numerical float value */
-  VKINT,  /* integer constant; nval = numerical integer value */
-  VNONRELOC,  /* expression has its value in a fixed register;
-                 info = result register */
-  VLOCAL,  /* local variable; info = local register */
-  VUPVAL,  /* upvalue variable; info = index of upvalue in 'upvalues' */
-  VINDEXED,  /* indexed variable;
-                ind.vt = whether 't' is register or upvalue;
-                ind.t = table register or upvalue;
-                ind.idx = key's R/K index */
-  VJMP,  /* expression is a test/comparison;
-            info = pc of corresponding jump instruction */
-  VRELOCABLE,  /* expression can put result in any register;
-                  info = instruction pc */
-  VCALL,  /* expression is a function call; info = instruction pc */
-  VVARARG  /* vararg expression; info = instruction pc */
-} expkind;
-
-
-#define vkisvar(k)	(VLOCAL <= (k) && (k) <= VINDEXED)
-#define vkisinreg(k)	((k) == VNONRELOC || (k) == VLOCAL)
-
-typedef struct expdesc {
-  expkind k;
-  union {
-    lua_Integer ival;    /* for VKINT */
-    lua_Number nval;  /* for VKFLT */
-    int info;  /* for generic use */
-    struct {  /* for indexed variables (VINDEXED) */
-      short idx;  /* index (R/K) */
-      lu_byte t;  /* table (register or upvalue) */
-      lu_byte vt;  /* whether 't' is register (VLOCAL) or upvalue (VUPVAL) */
-    } ind;
-  } u;
-  int t;  /* patch list of 'exit when true' */
-  int f;  /* patch list of 'exit when false' */
-} expdesc;
-
-
-/* description of active local variable */
-typedef struct Vardesc {
-  short idx;  /* variable index in stack */
-} Vardesc;
-
-
-/* description of pending goto statements and label statements */
-typedef struct Labeldesc {
-  TString *name;  /* label identifier */
-  int pc;  /* position in code */
-  int line;  /* line where it appeared */
-  lu_byte nactvar;  /* local level where it appears in current block */
-} Labeldesc;
-
-
-/* list of labels or gotos */
-typedef struct Labellist {
-  Labeldesc *arr;  /* array */
-  int n;  /* number of entries in use */
-  int size;  /* array size */
-} Labellist;
-
-
-/* dynamic structures used by the parser */
-typedef struct Dyndata {
-  struct {  /* list of active local variables */
-    Vardesc *arr;
-    int n;
-    int size;
-  } actvar;
-  Labellist gt;  /* list of pending gotos */
-  Labellist label;   /* list of active labels */
-} Dyndata;
-
-
-/* control of blocks */
-struct BlockCnt;  /* defined in lparser.c */
-
-
-/* state needed to generate code for a given function */
-typedef struct FuncState {
-  Proto *f;  /* current function header */
-  struct FuncState *prev;  /* enclosing function */
-  struct LexState *ls;  /* lexical state */
-  struct BlockCnt *bl;  /* chain of current blocks */
-  int pc;  /* next position to code (equivalent to 'ncode') */
-  int lasttarget;   /* 'label' of last 'jump label' */
-  int jpc;  /* list of pending jumps to 'pc' */
-  int nk;  /* number of elements in 'k' */
-  int np;  /* number of elements in 'p' */
-  int firstlocal;  /* index of first local var (in Dyndata array) */
-  short nlocvars;  /* number of elements in 'f->locvars' */
-  lu_byte nactvar;  /* number of active local variables */
-  lu_byte nups;  /* number of upvalues */
-  lu_byte freereg;  /* first free register */
-} FuncState;
-
-
-LUAI_FUNC LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
-                                 Dyndata *dyd, const char *name, int firstchar);
-
-
-#endif
diff --git a/lua/lua-5.3.5/src/lprefix.h b/lua/lua-5.3.5/src/lprefix.h
deleted file mode 100644
index 9a749a3..0000000
--- a/lua/lua-5.3.5/src/lprefix.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
-** $Id: lprefix.h,v 1.2.1.1 2017/04/19 17:20:42 roberto Exp $
-** Definitions for Lua code that must come before any other header file
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lprefix_h
-#define lprefix_h
-
-
-/*
-** Allows POSIX/XSI stuff
-*/
-#if !defined(LUA_USE_C89)	/* { */
-
-#if !defined(_XOPEN_SOURCE)
-#define _XOPEN_SOURCE           600
-#elif _XOPEN_SOURCE == 0
-#undef _XOPEN_SOURCE  /* use -D_XOPEN_SOURCE=0 to undefine it */
-#endif
-
-/*
-** Allows manipulation of large files in gcc and some other compilers
-*/
-#if !defined(LUA_32BITS) && !defined(_FILE_OFFSET_BITS)
-#define _LARGEFILE_SOURCE       1
-#define _FILE_OFFSET_BITS       64
-#endif
-
-#endif				/* } */
-
-
-/*
-** Windows stuff
-*/
-#if defined(_WIN32) 	/* { */
-
-#if !defined(_CRT_SECURE_NO_WARNINGS)
-#define _CRT_SECURE_NO_WARNINGS  /* avoid warnings about ISO C functions */
-#endif
-
-#endif			/* } */
-
-#endif
-
diff --git a/lua/lua-5.3.5/src/lstate.c b/lua/lua-5.3.5/src/lstate.c
deleted file mode 100644
index c1a7664..0000000
--- a/lua/lua-5.3.5/src/lstate.c
+++ /dev/null
@@ -1,347 +0,0 @@
-/*
-** $Id: lstate.c,v 2.133.1.1 2017/04/19 17:39:34 roberto Exp $
-** Global State
-** See Copyright Notice in lua.h
-*/
-
-#define lstate_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <stddef.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lapi.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"
-
-
-#if !defined(LUAI_GCPAUSE)
-#define LUAI_GCPAUSE	200  /* 200% */
-#endif
-
-#if !defined(LUAI_GCMUL)
-#define LUAI_GCMUL	200 /* GC runs 'twice the speed' of memory allocation */
-#endif
-
-
-/*
-** a macro to help the creation of a unique random seed when a state is
-** created; the seed is used to randomize hashes.
-*/
-#if !defined(luai_makeseed)
-#include <time.h>
-#define luai_makeseed()		cast(unsigned int, time(NULL))
-#endif
-
-
-
-/*
-** thread state + extra space
-*/
-typedef struct LX {
-  lu_byte extra_[LUA_EXTRASPACE];
-  lua_State l;
-} LX;
-
-
-/*
-** Main thread combines a thread state and the global state
-*/
-typedef struct LG {
-  LX l;
-  global_State g;
-} LG;
-
-
-
-#define fromstate(L)	(cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l)))
-
-
-/*
-** Compute an initial seed as random as possible. Rely on Address Space
-** Layout Randomization (if present) to increase randomness..
-*/
-#define addbuff(b,p,e) \
-  { size_t t = cast(size_t, e); \
-    memcpy(b + p, &t, sizeof(t)); p += sizeof(t); }
-
-static unsigned int makeseed (lua_State *L) {
-  char buff[4 * sizeof(size_t)];
-  unsigned int h = luai_makeseed();
-  int p = 0;
-  addbuff(buff, p, L);  /* heap variable */
-  addbuff(buff, p, &h);  /* local variable */
-  addbuff(buff, p, luaO_nilobject);  /* global variable */
-  addbuff(buff, p, &lua_newstate);  /* public function */
-  lua_assert(p == sizeof(buff));
-  return luaS_hash(buff, p, h);
-}
-
-
-/*
-** set GCdebt to a new value keeping the value (totalbytes + GCdebt)
-** invariant (and avoiding underflows in 'totalbytes')
-*/
-void luaE_setdebt (global_State *g, l_mem debt) {
-  l_mem tb = gettotalbytes(g);
-  lua_assert(tb > 0);
-  if (debt < tb - MAX_LMEM)
-    debt = tb - MAX_LMEM;  /* will make 'totalbytes == MAX_LMEM' */
-  g->totalbytes = tb - debt;
-  g->GCdebt = debt;
-}
-
-
-CallInfo *luaE_extendCI (lua_State *L) {
-  CallInfo *ci = luaM_new(L, CallInfo);
-  lua_assert(L->ci->next == NULL);
-  L->ci->next = ci;
-  ci->previous = L->ci;
-  ci->next = NULL;
-  L->nci++;
-  return ci;
-}
-
-
-/*
-** free all CallInfo structures not in use by a thread
-*/
-void luaE_freeCI (lua_State *L) {
-  CallInfo *ci = L->ci;
-  CallInfo *next = ci->next;
-  ci->next = NULL;
-  while ((ci = next) != NULL) {
-    next = ci->next;
-    luaM_free(L, ci);
-    L->nci--;
-  }
-}
-
-
-/*
-** free half of the CallInfo structures not in use by a thread
-*/
-void luaE_shrinkCI (lua_State *L) {
-  CallInfo *ci = L->ci;
-  CallInfo *next2;  /* next's next */
-  /* while there are two nexts */
-  while (ci->next != NULL && (next2 = ci->next->next) != NULL) {
-    luaM_free(L, ci->next);  /* free next */
-    L->nci--;
-    ci->next = next2;  /* remove 'next' from the list */
-    next2->previous = ci;
-    ci = next2;  /* keep next's next */
-  }
-}
-
-
-static void stack_init (lua_State *L1, lua_State *L) {
-  int i; CallInfo *ci;
-  /* initialize stack array */
-  L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, TValue);
-  L1->stacksize = BASIC_STACK_SIZE;
-  for (i = 0; i < BASIC_STACK_SIZE; i++)
-    setnilvalue(L1->stack + i);  /* erase new stack */
-  L1->top = L1->stack;
-  L1->stack_last = L1->stack + L1->stacksize - EXTRA_STACK;
-  /* initialize first ci */
-  ci = &L1->base_ci;
-  ci->next = ci->previous = NULL;
-  ci->callstatus = 0;
-  ci->func = L1->top;
-  setnilvalue(L1->top++);  /* 'function' entry for this 'ci' */
-  ci->top = L1->top + LUA_MINSTACK;
-  L1->ci = ci;
-}
-
-
-static void freestack (lua_State *L) {
-  if (L->stack == NULL)
-    return;  /* stack not completely built yet */
-  L->ci = &L->base_ci;  /* free the entire 'ci' list */
-  luaE_freeCI(L);
-  lua_assert(L->nci == 0);
-  luaM_freearray(L, L->stack, L->stacksize);  /* free stack array */
-}
-
-
-/*
-** Create registry table and its predefined values
-*/
-static void init_registry (lua_State *L, global_State *g) {
-  TValue temp;
-  /* create registry */
-  Table *registry = luaH_new(L);
-  sethvalue(L, &g->l_registry, registry);
-  luaH_resize(L, registry, LUA_RIDX_LAST, 0);
-  /* registry[LUA_RIDX_MAINTHREAD] = L */
-  setthvalue(L, &temp, L);  /* temp = L */
-  luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &temp);
-  /* registry[LUA_RIDX_GLOBALS] = table of globals */
-  sethvalue(L, &temp, luaH_new(L));  /* temp = new table (global table) */
-  luaH_setint(L, registry, LUA_RIDX_GLOBALS, &temp);
-}
-
-
-/*
-** open parts of the state that may cause memory-allocation errors.
-** ('g->version' != NULL flags that the state was completely build)
-*/
-static void f_luaopen (lua_State *L, void *ud) {
-  global_State *g = G(L);
-  UNUSED(ud);
-  stack_init(L, L);  /* init stack */
-  init_registry(L, g);
-  luaS_init(L);
-  luaT_init(L);
-  luaX_init(L);
-  g->gcrunning = 1;  /* allow gc */
-  g->version = lua_version(NULL);
-  luai_userstateopen(L);
-}
-
-
-/*
-** preinitialize a thread with consistent values without allocating
-** any memory (to avoid errors)
-*/
-static void preinit_thread (lua_State *L, global_State *g) {
-  G(L) = g;
-  L->stack = NULL;
-  L->ci = NULL;
-  L->nci = 0;
-  L->stacksize = 0;
-  L->twups = L;  /* thread has no upvalues */
-  L->errorJmp = NULL;
-  L->nCcalls = 0;
-  L->hook = NULL;
-  L->hookmask = 0;
-  L->basehookcount = 0;
-  L->allowhook = 1;
-  resethookcount(L);
-  L->openupval = NULL;
-  L->nny = 1;
-  L->status = LUA_OK;
-  L->errfunc = 0;
-}
-
-
-static void close_state (lua_State *L) {
-  global_State *g = G(L);
-  luaF_close(L, L->stack);  /* close all upvalues for this thread */
-  luaC_freeallobjects(L);  /* collect all objects */
-  if (g->version)  /* closing a fully built state? */
-    luai_userstateclose(L);
-  luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
-  freestack(L);
-  lua_assert(gettotalbytes(g) == sizeof(LG));
-  (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0);  /* free main block */
-}
-
-
-LUA_API lua_State *lua_newthread (lua_State *L) {
-  global_State *g = G(L);
-  lua_State *L1;
-  lua_lock(L);
-  luaC_checkGC(L);
-  /* create new thread */
-  L1 = &cast(LX *, luaM_newobject(L, LUA_TTHREAD, sizeof(LX)))->l;
-  L1->marked = luaC_white(g);
-  L1->tt = LUA_TTHREAD;
-  /* link it on list 'allgc' */
-  L1->next = g->allgc;
-  g->allgc = obj2gco(L1);
-  /* anchor it on L stack */
-  setthvalue(L, L->top, L1);
-  api_incr_top(L);
-  preinit_thread(L1, g);
-  L1->hookmask = L->hookmask;
-  L1->basehookcount = L->basehookcount;
-  L1->hook = L->hook;
-  resethookcount(L1);
-  /* initialize L1 extra space */
-  memcpy(lua_getextraspace(L1), lua_getextraspace(g->mainthread),
-         LUA_EXTRASPACE);
-  luai_userstatethread(L, L1);
-  stack_init(L1, L);  /* init stack */
-  lua_unlock(L);
-  return L1;
-}
-
-
-void luaE_freethread (lua_State *L, lua_State *L1) {
-  LX *l = fromstate(L1);
-  luaF_close(L1, L1->stack);  /* close all upvalues for this thread */
-  lua_assert(L1->openupval == NULL);
-  luai_userstatefree(L, L1);
-  freestack(L1);
-  luaM_free(L, l);
-}
-
-
-LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
-  int i;
-  lua_State *L;
-  global_State *g;
-  LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));
-  if (l == NULL) return NULL;
-  L = &l->l.l;
-  g = &l->g;
-  L->next = NULL;
-  L->tt = LUA_TTHREAD;
-  g->currentwhite = bitmask(WHITE0BIT);
-  L->marked = luaC_white(g);
-  preinit_thread(L, g);
-  g->frealloc = f;
-  g->ud = ud;
-  g->mainthread = L;
-  g->seed = makeseed(L);
-  g->gcrunning = 0;  /* no GC while building state */
-  g->GCestimate = 0;
-  g->strt.size = g->strt.nuse = 0;
-  g->strt.hash = NULL;
-  setnilvalue(&g->l_registry);
-  g->panic = NULL;
-  g->version = NULL;
-  g->gcstate = GCSpause;
-  g->gckind = KGC_NORMAL;
-  g->allgc = g->finobj = g->tobefnz = g->fixedgc = NULL;
-  g->sweepgc = NULL;
-  g->gray = g->grayagain = NULL;
-  g->weak = g->ephemeron = g->allweak = NULL;
-  g->twups = NULL;
-  g->totalbytes = sizeof(LG);
-  g->GCdebt = 0;
-  g->gcfinnum = 0;
-  g->gcpause = LUAI_GCPAUSE;
-  g->gcstepmul = LUAI_GCMUL;
-  for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
-  if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
-    /* memory allocation error: free partial state */
-    close_state(L);
-    L = NULL;
-  }
-  return L;
-}
-
-
-LUA_API void lua_close (lua_State *L) {
-  L = G(L)->mainthread;  /* only the main thread can be closed */
-  lua_lock(L);
-  close_state(L);
-}
-
-
diff --git a/lua/lua-5.3.5/src/lstate.h b/lua/lua-5.3.5/src/lstate.h
deleted file mode 100644
index 56b3741..0000000
--- a/lua/lua-5.3.5/src/lstate.h
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
-** $Id: lstate.h,v 2.133.1.1 2017/04/19 17:39:34 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"
-
-
-/*
-
-** Some notes about garbage-collected objects: All objects in Lua must
-** be kept somehow accessible until being freed, so all objects always
-** belong to one (and only one) of these lists, using field 'next' of
-** the 'CommonHeader' for the link:
-**
-** 'allgc': all objects not marked for finalization;
-** 'finobj': all objects marked for finalization;
-** 'tobefnz': all objects ready to be finalized;
-** 'fixedgc': all objects that are not to be collected (currently
-** only small strings, such as reserved words).
-**
-** Moreover, there is another set of lists that control gray objects.
-** These lists are linked by fields 'gclist'. (All objects that
-** can become gray have such a field. The field is not the same
-** in all objects, but it always has this name.)  Any gray object
-** must belong to one of these lists, and all objects in these lists
-** must be gray:
-**
-** 'gray': regular gray objects, still waiting to be visited.
-** 'grayagain': objects that must be revisited at the atomic phase.
-**   That includes
-**   - black objects got in a write barrier;
-**   - all kinds of weak tables during propagation phase;
-**   - all threads.
-** 'weak': tables with weak values to be cleared;
-** 'ephemeron': ephemeron tables with white->white entries;
-** 'allweak': tables with weak keys and/or weak values to be cleared.
-** The last three lists are used only during the atomic phase.
-
-*/
-
-
-struct lua_longjmp;  /* defined in ldo.c */
-
-
-/*
-** Atomic type (relative to signals) to better ensure that 'lua_sethook'
-** is thread safe
-*/
-#if !defined(l_signalT)
-#include <signal.h>
-#define l_signalT	sig_atomic_t
-#endif
-
-
-/* extra stack space to handle TM calls and some other extras */
-#define EXTRA_STACK   5
-
-
-#define BASIC_STACK_SIZE        (2*LUA_MINSTACK)
-
-
-/* kinds of Garbage Collection */
-#define KGC_NORMAL	0
-#define KGC_EMERGENCY	1	/* gc was forced by an allocation failure */
-
-
-typedef struct stringtable {
-  TString **hash;
-  int nuse;  /* number of elements */
-  int size;
-} stringtable;
-
-
-/*
-** Information about a call.
-** When a thread yields, 'func' is adjusted to pretend that the
-** top function has only the yielded values in its stack; in that
-** case, the actual 'func' value is saved in field 'extra'.
-** When a function calls another with a continuation, 'extra' keeps
-** the function index so that, in case of errors, the continuation
-** function can be called with the correct top.
-*/
-typedef struct CallInfo {
-  StkId func;  /* function index in the stack */
-  StkId	top;  /* top for this function */
-  struct CallInfo *previous, *next;  /* dynamic call link */
-  union {
-    struct {  /* only for Lua functions */
-      StkId base;  /* base for this function */
-      const Instruction *savedpc;
-    } l;
-    struct {  /* only for C functions */
-      lua_KFunction k;  /* continuation in case of yields */
-      ptrdiff_t old_errfunc;
-      lua_KContext ctx;  /* context info. in case of yields */
-    } c;
-  } u;
-  ptrdiff_t extra;
-  short nresults;  /* expected number of results from this function */
-  unsigned short callstatus;
-} CallInfo;
-
-
-/*
-** Bits in CallInfo status
-*/
-#define CIST_OAH	(1<<0)	/* original value of 'allowhook' */
-#define CIST_LUA	(1<<1)	/* call is running a Lua function */
-#define CIST_HOOKED	(1<<2)	/* call is running a debug hook */
-#define CIST_FRESH	(1<<3)	/* call is running on a fresh invocation
-                                   of luaV_execute */
-#define CIST_YPCALL	(1<<4)	/* call is a yieldable protected call */
-#define CIST_TAIL	(1<<5)	/* call was tail called */
-#define CIST_HOOKYIELD	(1<<6)	/* last hook called yielded */
-#define CIST_LEQ	(1<<7)  /* using __lt for __le */
-#define CIST_FIN	(1<<8)  /* call is running a finalizer */
-
-#define isLua(ci)	((ci)->callstatus & CIST_LUA)
-
-/* assume that CIST_OAH has offset 0 and that 'v' is strictly 0/1 */
-#define setoah(st,v)	((st) = ((st) & ~CIST_OAH) | (v))
-#define getoah(st)	((st) & CIST_OAH)
-
-
-/*
-** 'global state', shared by all threads of this state
-*/
-typedef struct global_State {
-  lua_Alloc frealloc;  /* function to reallocate memory */
-  void *ud;         /* auxiliary data to 'frealloc' */
-  l_mem totalbytes;  /* number of bytes currently allocated - GCdebt */
-  l_mem GCdebt;  /* bytes allocated not yet compensated by the collector */
-  lu_mem GCmemtrav;  /* memory traversed by the GC */
-  lu_mem GCestimate;  /* an estimate of the non-garbage memory in use */
-  stringtable strt;  /* hash table for strings */
-  TValue l_registry;
-  unsigned int seed;  /* randomized seed for hashes */
-  lu_byte currentwhite;
-  lu_byte gcstate;  /* state of garbage collector */
-  lu_byte gckind;  /* kind of GC running */
-  lu_byte gcrunning;  /* true if GC is running */
-  GCObject *allgc;  /* list of all collectable objects */
-  GCObject **sweepgc;  /* current position of sweep in list */
-  GCObject *finobj;  /* list of collectable objects with finalizers */
-  GCObject *gray;  /* list of gray objects */
-  GCObject *grayagain;  /* list of objects to be traversed atomically */
-  GCObject *weak;  /* list of tables with weak values */
-  GCObject *ephemeron;  /* list of ephemeron tables (weak keys) */
-  GCObject *allweak;  /* list of all-weak tables */
-  GCObject *tobefnz;  /* list of userdata to be GC */
-  GCObject *fixedgc;  /* list of objects not to be collected */
-  struct lua_State *twups;  /* list of threads with open upvalues */
-  unsigned int gcfinnum;  /* number of finalizers to call in each GC step */
-  int gcpause;  /* size of pause between successive GCs */
-  int gcstepmul;  /* GC 'granularity' */
-  lua_CFunction panic;  /* to be called in unprotected errors */
-  struct lua_State *mainthread;
-  const lua_Number *version;  /* pointer to version number */
-  TString *memerrmsg;  /* memory-error message */
-  TString *tmname[TM_N];  /* array with tag-method names */
-  struct Table *mt[LUA_NUMTAGS];  /* metatables for basic types */
-  TString *strcache[STRCACHE_N][STRCACHE_M];  /* cache for strings in API */
-} global_State;
-
-
-/*
-** 'per thread' state
-*/
-struct lua_State {
-  CommonHeader;
-  unsigned short nci;  /* number of items in 'ci' list */
-  lu_byte status;
-  StkId top;  /* first free slot in the stack */
-  global_State *l_G;
-  CallInfo *ci;  /* call info for current function */
-  const Instruction *oldpc;  /* last pc traced */
-  StkId stack_last;  /* last free slot in the stack */
-  StkId stack;  /* stack base */
-  UpVal *openupval;  /* list of open upvalues in this stack */
-  GCObject *gclist;
-  struct lua_State *twups;  /* list of threads with open upvalues */
-  struct lua_longjmp *errorJmp;  /* current error recover point */
-  CallInfo base_ci;  /* CallInfo for first level (C calling Lua) */
-  volatile lua_Hook hook;
-  ptrdiff_t errfunc;  /* current error handling function (stack index) */
-  int stacksize;
-  int basehookcount;
-  int hookcount;
-  unsigned short nny;  /* number of non-yieldable calls in stack */
-  unsigned short nCcalls;  /* number of nested C calls */
-  l_signalT hookmask;
-  lu_byte allowhook;
-};
-
-
-#define G(L)	(L->l_G)
-
-
-/*
-** Union of all collectable objects (only for conversions)
-*/
-union GCUnion {
-  GCObject gc;  /* common header */
-  struct TString ts;
-  struct Udata u;
-  union Closure cl;
-  struct Table h;
-  struct Proto p;
-  struct lua_State th;  /* thread */
-};
-
-
-#define cast_u(o)	cast(union GCUnion *, (o))
-
-/* macros to convert a GCObject into a specific value */
-#define gco2ts(o)  \
-	check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts))
-#define gco2u(o)  check_exp((o)->tt == LUA_TUSERDATA, &((cast_u(o))->u))
-#define gco2lcl(o)  check_exp((o)->tt == LUA_TLCL, &((cast_u(o))->cl.l))
-#define gco2ccl(o)  check_exp((o)->tt == LUA_TCCL, &((cast_u(o))->cl.c))
-#define gco2cl(o)  \
-	check_exp(novariant((o)->tt) == LUA_TFUNCTION, &((cast_u(o))->cl))
-#define gco2t(o)  check_exp((o)->tt == LUA_TTABLE, &((cast_u(o))->h))
-#define gco2p(o)  check_exp((o)->tt == LUA_TPROTO, &((cast_u(o))->p))
-#define gco2th(o)  check_exp((o)->tt == LUA_TTHREAD, &((cast_u(o))->th))
-
-
-/* macro to convert a Lua object into a GCObject */
-#define obj2gco(v) \
-	check_exp(novariant((v)->tt) < LUA_TDEADKEY, (&(cast_u(v)->gc)))
-
-
-/* actual number of total bytes allocated */
-#define gettotalbytes(g)	cast(lu_mem, (g)->totalbytes + (g)->GCdebt)
-
-LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt);
-LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
-LUAI_FUNC CallInfo *luaE_extendCI (lua_State *L);
-LUAI_FUNC void luaE_freeCI (lua_State *L);
-LUAI_FUNC void luaE_shrinkCI (lua_State *L);
-
-
-#endif
-
diff --git a/lua/lua-5.3.5/src/lstring.c b/lua/lua-5.3.5/src/lstring.c
deleted file mode 100644
index 6257f21..0000000
--- a/lua/lua-5.3.5/src/lstring.c
+++ /dev/null
@@ -1,248 +0,0 @@
-/*
-** $Id: lstring.c,v 2.56.1.1 2017/04/19 17:20:42 roberto Exp $
-** String table (keeps all strings handled by Lua)
-** See Copyright Notice in lua.h
-*/
-
-#define lstring_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <string.h>
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-
-
-#define MEMERRMSG       "not enough memory"
-
-
-/*
-** Lua will use at most ~(2^LUAI_HASHLIMIT) bytes from a string to
-** compute its hash
-*/
-#if !defined(LUAI_HASHLIMIT)
-#define LUAI_HASHLIMIT		5
-#endif
-
-
-/*
-** equality for long strings
-*/
-int luaS_eqlngstr (TString *a, TString *b) {
-  size_t len = a->u.lnglen;
-  lua_assert(a->tt == LUA_TLNGSTR && b->tt == LUA_TLNGSTR);
-  return (a == b) ||  /* same instance or... */
-    ((len == b->u.lnglen) &&  /* equal length and ... */
-     (memcmp(getstr(a), getstr(b), len) == 0));  /* equal contents */
-}
-
-
-unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) {
-  unsigned int h = seed ^ cast(unsigned int, l);
-  size_t step = (l >> LUAI_HASHLIMIT) + 1;
-  for (; l >= step; l -= step)
-    h ^= ((h<<5) + (h>>2) + cast_byte(str[l - 1]));
-  return h;
-}
-
-
-unsigned int luaS_hashlongstr (TString *ts) {
-  lua_assert(ts->tt == LUA_TLNGSTR);
-  if (ts->extra == 0) {  /* no hash? */
-    ts->hash = luaS_hash(getstr(ts), ts->u.lnglen, ts->hash);
-    ts->extra = 1;  /* now it has its hash */
-  }
-  return ts->hash;
-}
-
-
-/*
-** resizes the string table
-*/
-void luaS_resize (lua_State *L, int newsize) {
-  int i;
-  stringtable *tb = &G(L)->strt;
-  if (newsize > tb->size) {  /* grow table if needed */
-    luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
-    for (i = tb->size; i < newsize; i++)
-      tb->hash[i] = NULL;
-  }
-  for (i = 0; i < tb->size; i++) {  /* rehash */
-    TString *p = tb->hash[i];
-    tb->hash[i] = NULL;
-    while (p) {  /* for each node in the list */
-      TString *hnext = p->u.hnext;  /* save next */
-      unsigned int h = lmod(p->hash, newsize);  /* new position */
-      p->u.hnext = tb->hash[h];  /* chain it */
-      tb->hash[h] = p;
-      p = hnext;
-    }
-  }
-  if (newsize < tb->size) {  /* shrink table if needed */
-    /* vanishing slice should be empty */
-    lua_assert(tb->hash[newsize] == NULL && tb->hash[tb->size - 1] == NULL);
-    luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
-  }
-  tb->size = newsize;
-}
-
-
-/*
-** Clear API string cache. (Entries cannot be empty, so fill them with
-** a non-collectable string.)
-*/
-void luaS_clearcache (global_State *g) {
-  int i, j;
-  for (i = 0; i < STRCACHE_N; i++)
-    for (j = 0; j < STRCACHE_M; j++) {
-    if (iswhite(g->strcache[i][j]))  /* will entry be collected? */
-      g->strcache[i][j] = g->memerrmsg;  /* replace it with something fixed */
-    }
-}
-
-
-/*
-** Initialize the string table and the string cache
-*/
-void luaS_init (lua_State *L) {
-  global_State *g = G(L);
-  int i, j;
-  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
-  /* pre-create memory-error message */
-  g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
-  luaC_fix(L, obj2gco(g->memerrmsg));  /* it should never be collected */
-  for (i = 0; i < STRCACHE_N; i++)  /* fill cache with valid strings */
-    for (j = 0; j < STRCACHE_M; j++)
-      g->strcache[i][j] = g->memerrmsg;
-}
-
-
-
-/*
-** creates a new string object
-*/
-static TString *createstrobj (lua_State *L, size_t l, int tag, unsigned int h) {
-  TString *ts;
-  GCObject *o;
-  size_t totalsize;  /* total size of TString object */
-  totalsize = sizelstring(l);
-  o = luaC_newobj(L, tag, totalsize);
-  ts = gco2ts(o);
-  ts->hash = h;
-  ts->extra = 0;
-  getstr(ts)[l] = '\0';  /* ending 0 */
-  return ts;
-}
-
-
-TString *luaS_createlngstrobj (lua_State *L, size_t l) {
-  TString *ts = createstrobj(L, l, LUA_TLNGSTR, G(L)->seed);
-  ts->u.lnglen = l;
-  return ts;
-}
-
-
-void luaS_remove (lua_State *L, TString *ts) {
-  stringtable *tb = &G(L)->strt;
-  TString **p = &tb->hash[lmod(ts->hash, tb->size)];
-  while (*p != ts)  /* find previous element */
-    p = &(*p)->u.hnext;
-  *p = (*p)->u.hnext;  /* remove element from its list */
-  tb->nuse--;
-}
-
-
-/*
-** checks whether short string exists and reuses it or creates a new one
-*/
-static TString *internshrstr (lua_State *L, const char *str, size_t l) {
-  TString *ts;
-  global_State *g = G(L);
-  unsigned int h = luaS_hash(str, l, g->seed);
-  TString **list = &g->strt.hash[lmod(h, g->strt.size)];
-  lua_assert(str != NULL);  /* otherwise 'memcmp'/'memcpy' are undefined */
-  for (ts = *list; ts != NULL; ts = ts->u.hnext) {
-    if (l == ts->shrlen &&
-        (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
-      /* found! */
-      if (isdead(g, ts))  /* dead (but not collected yet)? */
-        changewhite(ts);  /* resurrect it */
-      return ts;
-    }
-  }
-  if (g->strt.nuse >= g->strt.size && g->strt.size <= MAX_INT/2) {
-    luaS_resize(L, g->strt.size * 2);
-    list = &g->strt.hash[lmod(h, g->strt.size)];  /* recompute with new size */
-  }
-  ts = createstrobj(L, l, LUA_TSHRSTR, h);
-  memcpy(getstr(ts), str, l * sizeof(char));
-  ts->shrlen = cast_byte(l);
-  ts->u.hnext = *list;
-  *list = ts;
-  g->strt.nuse++;
-  return ts;
-}
-
-
-/*
-** new string (with explicit length)
-*/
-TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
-  if (l <= LUAI_MAXSHORTLEN)  /* short string? */
-    return internshrstr(L, str, l);
-  else {
-    TString *ts;
-    if (l >= (MAX_SIZE - sizeof(TString))/sizeof(char))
-      luaM_toobig(L);
-    ts = luaS_createlngstrobj(L, l);
-    memcpy(getstr(ts), str, l * sizeof(char));
-    return ts;
-  }
-}
-
-
-/*
-** Create or reuse a zero-terminated string, first checking in the
-** cache (using the string address as a key). The cache can contain
-** only zero-terminated strings, so it is safe to use 'strcmp' to
-** check hits.
-*/
-TString *luaS_new (lua_State *L, const char *str) {
-  unsigned int i = point2uint(str) % STRCACHE_N;  /* hash */
-  int j;
-  TString **p = G(L)->strcache[i];
-  for (j = 0; j < STRCACHE_M; j++) {
-    if (strcmp(str, getstr(p[j])) == 0)  /* hit? */
-      return p[j];  /* that is it */
-  }
-  /* normal route */
-  for (j = STRCACHE_M - 1; j > 0; j--)
-    p[j] = p[j - 1];  /* move out last element */
-  /* new element is first in the list */
-  p[0] = luaS_newlstr(L, str, strlen(str));
-  return p[0];
-}
-
-
-Udata *luaS_newudata (lua_State *L, size_t s) {
-  Udata *u;
-  GCObject *o;
-  if (s > MAX_SIZE - sizeof(Udata))
-    luaM_toobig(L);
-  o = luaC_newobj(L, LUA_TUSERDATA, sizeludata(s));
-  u = gco2u(o);
-  u->len = s;
-  u->metatable = NULL;
-  setuservalue(L, u, luaO_nilobject);
-  return u;
-}
-
diff --git a/lua/lua-5.3.5/src/lstring.h b/lua/lua-5.3.5/src/lstring.h
deleted file mode 100644
index d612abd..0000000
--- a/lua/lua-5.3.5/src/lstring.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-** $Id: lstring.h,v 1.61.1.1 2017/04/19 17:20:42 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 sizelstring(l)  (sizeof(union UTString) + ((l) + 1) * sizeof(char))
-
-#define sizeludata(l)	(sizeof(union UUdata) + (l))
-#define sizeudata(u)	sizeludata((u)->len)
-
-#define luaS_newliteral(L, s)	(luaS_newlstr(L, "" s, \
-                                 (sizeof(s)/sizeof(char))-1))
-
-
-/*
-** test whether a string is a reserved word
-*/
-#define isreserved(s)	((s)->tt == LUA_TSHRSTR && (s)->extra > 0)
-
-
-/*
-** equality for short strings, which are always internalized
-*/
-#define eqshrstr(a,b)	check_exp((a)->tt == LUA_TSHRSTR, (a) == (b))
-
-
-LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed);
-LUAI_FUNC unsigned int luaS_hashlongstr (TString *ts);
-LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b);
-LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
-LUAI_FUNC void luaS_clearcache (global_State *g);
-LUAI_FUNC void luaS_init (lua_State *L);
-LUAI_FUNC void luaS_remove (lua_State *L, TString *ts);
-LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s);
-LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
-LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);
-LUAI_FUNC TString *luaS_createlngstrobj (lua_State *L, size_t l);
-
-
-#endif
diff --git a/lua/lua-5.3.5/src/lstrlib.c b/lua/lua-5.3.5/src/lstrlib.c
deleted file mode 100644
index b4bed7e..0000000
--- a/lua/lua-5.3.5/src/lstrlib.c
+++ /dev/null
@@ -1,1584 +0,0 @@
-/*
-** $Id: lstrlib.c,v 1.254.1.1 2017/04/19 17:29:57 roberto Exp $
-** Standard library for string operations and pattern-matching
-** See Copyright Notice in lua.h
-*/
-
-#define lstrlib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <ctype.h>
-#include <float.h>
-#include <limits.h>
-#include <locale.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/*
-** maximum number of captures that a pattern can do during
-** pattern-matching. This limit is arbitrary, but must fit in
-** an unsigned char.
-*/
-#if !defined(LUA_MAXCAPTURES)
-#define LUA_MAXCAPTURES		32
-#endif
-
-
-/* macro to 'unsign' a character */
-#define uchar(c)	((unsigned char)(c))
-
-
-/*
-** Some sizes are better limited to fit in 'int', but must also fit in
-** 'size_t'. (We assume that 'lua_Integer' cannot be smaller than 'int'.)
-*/
-#define MAX_SIZET	((size_t)(~(size_t)0))
-
-#define MAXSIZE  \
-	(sizeof(size_t) < sizeof(int) ? MAX_SIZET : (size_t)(INT_MAX))
-
-
-
-
-static int str_len (lua_State *L) {
-  size_t l;
-  luaL_checklstring(L, 1, &l);
-  lua_pushinteger(L, (lua_Integer)l);
-  return 1;
-}
-
-
-/* translate a relative string position: negative means back from end */
-static lua_Integer posrelat (lua_Integer pos, size_t len) {
-  if (pos >= 0) return pos;
-  else if (0u - (size_t)pos > len) return 0;
-  else return (lua_Integer)len + pos + 1;
-}
-
-
-static int str_sub (lua_State *L) {
-  size_t l;
-  const char *s = luaL_checklstring(L, 1, &l);
-  lua_Integer start = posrelat(luaL_checkinteger(L, 2), l);
-  lua_Integer end = posrelat(luaL_optinteger(L, 3, -1), l);
-  if (start < 1) start = 1;
-  if (end > (lua_Integer)l) end = l;
-  if (start <= end)
-    lua_pushlstring(L, s + start - 1, (size_t)(end - start) + 1);
-  else lua_pushliteral(L, "");
-  return 1;
-}
-
-
-static int str_reverse (lua_State *L) {
-  size_t l, i;
-  luaL_Buffer b;
-  const char *s = luaL_checklstring(L, 1, &l);
-  char *p = luaL_buffinitsize(L, &b, l);
-  for (i = 0; i < l; i++)
-    p[i] = s[l - i - 1];
-  luaL_pushresultsize(&b, l);
-  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);
-  char *p = luaL_buffinitsize(L, &b, l);
-  for (i=0; i<l; i++)
-    p[i] = tolower(uchar(s[i]));
-  luaL_pushresultsize(&b, l);
-  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);
-  char *p = luaL_buffinitsize(L, &b, l);
-  for (i=0; i<l; i++)
-    p[i] = toupper(uchar(s[i]));
-  luaL_pushresultsize(&b, l);
-  return 1;
-}
-
-
-static int str_rep (lua_State *L) {
-  size_t l, lsep;
-  const char *s = luaL_checklstring(L, 1, &l);
-  lua_Integer n = luaL_checkinteger(L, 2);
-  const char *sep = luaL_optlstring(L, 3, "", &lsep);
-  if (n <= 0) lua_pushliteral(L, "");
-  else if (l + lsep < l || l + lsep > MAXSIZE / n)  /* may overflow? */
-    return luaL_error(L, "resulting string too large");
-  else {
-    size_t totallen = (size_t)n * l + (size_t)(n - 1) * lsep;
-    luaL_Buffer b;
-    char *p = luaL_buffinitsize(L, &b, totallen);
-    while (n-- > 1) {  /* first n-1 copies (followed by separator) */
-      memcpy(p, s, l * sizeof(char)); p += l;
-      if (lsep > 0) {  /* empty 'memcpy' is not that cheap */
-        memcpy(p, sep, lsep * sizeof(char));
-        p += lsep;
-      }
-    }
-    memcpy(p, s, l * sizeof(char));  /* last copy (not followed by separator) */
-    luaL_pushresultsize(&b, totallen);
-  }
-  return 1;
-}
-
-
-static int str_byte (lua_State *L) {
-  size_t l;
-  const char *s = luaL_checklstring(L, 1, &l);
-  lua_Integer posi = posrelat(luaL_optinteger(L, 2, 1), l);
-  lua_Integer pose = posrelat(luaL_optinteger(L, 3, posi), l);
-  int n, i;
-  if (posi < 1) posi = 1;
-  if (pose > (lua_Integer)l) pose = l;
-  if (posi > pose) return 0;  /* empty interval; return no values */
-  if (pose - posi >= INT_MAX)  /* arithmetic overflow? */
-    return luaL_error(L, "string slice too long");
-  n = (int)(pose -  posi) + 1;
-  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;
-  char *p = luaL_buffinitsize(L, &b, n);
-  for (i=1; i<=n; i++) {
-    lua_Integer c = luaL_checkinteger(L, i);
-    luaL_argcheck(L, uchar(c) == c, i, "value out of range");
-    p[i - 1] = uchar(c);
-  }
-  luaL_pushresultsize(&b, n);
-  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;
-  int strip = lua_toboolean(L, 2);
-  luaL_checktype(L, 1, LUA_TFUNCTION);
-  lua_settop(L, 1);
-  luaL_buffinit(L,&b);
-  if (lua_dump(L, writer, &b, strip) != 0)
-    return 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 */
-  const char *p_end;  /* end ('\0') of pattern */
-  lua_State *L;
-  int matchdepth;  /* control for recursive depth (to avoid C stack overflow) */
-  unsigned char level;  /* total number of captures (finished or unfinished) */
-  struct {
-    const char *init;
-    ptrdiff_t len;
-  } capture[LUA_MAXCAPTURES];
-} MatchState;
-
-
-/* recursive function */
-static const char *match (MatchState *ms, const char *s, const char *p);
-
-
-/* maximum recursion depth for 'match' */
-#if !defined(MAXCCALLS)
-#define MAXCCALLS	200
-#endif
-
-
-#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 %%%d", l + 1);
-  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 == ms->p_end)
-        luaL_error(ms->L, "malformed pattern (ends with '%%')");
-      return p+1;
-    }
-    case '[': {
-      if (*p == '^') p++;
-      do {  /* look for a ']' */
-        if (p == ms->p_end)
-          luaL_error(ms->L, "malformed pattern (missing ']')");
-        if (*(p++) == L_ESC && p < ms->p_end)
-          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 'g' : res = isgraph(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;  /* deprecated option */
-    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 (MatchState *ms, const char *s, const char *p,
-                        const char *ep) {
-  if (s >= ms->src_end)
-    return 0;
-  else {
-    int c = uchar(*s);
-    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 *matchbalance (MatchState *ms, const char *s,
-                                   const char *p) {
-  if (p >= ms->p_end - 1)
-    luaL_error(ms->L, "malformed pattern (missing arguments to '%%b')");
-  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 (singlematch(ms, 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 (singlematch(ms, 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) {
-  if (ms->matchdepth-- == 0)
-    luaL_error(ms->L, "pattern too complex");
-  init: /* using goto's to optimize tail recursion */
-  if (p != ms->p_end) {  /* end of pattern? */
-    switch (*p) {
-      case '(': {  /* start capture */
-        if (*(p + 1) == ')')  /* position capture? */
-          s = start_capture(ms, s, p + 2, CAP_POSITION);
-        else
-          s = start_capture(ms, s, p + 1, CAP_UNFINISHED);
-        break;
-      }
-      case ')': {  /* end capture */
-        s = end_capture(ms, s, p + 1);
-        break;
-      }
-      case '$': {
-        if ((p + 1) != ms->p_end)  /* is the '$' the last char in pattern? */
-          goto dflt;  /* no; go to default */
-        s = (s == ms->src_end) ? s : NULL;  /* check end of string */
-        break;
-      }
-      case L_ESC: {  /* escaped sequences not in the format class[*+?-]? */
-        switch (*(p + 1)) {
-          case 'b': {  /* balanced string? */
-            s = matchbalance(ms, s, p + 2);
-            if (s != NULL) {
-              p += 4; goto init;  /* return match(ms, s, p + 4); */
-            }  /* else fail (s == NULL) */
-            break;
-          }
-          case 'f': {  /* frontier? */
-            const char *ep; char previous;
-            p += 2;
-            if (*p != '[')
-              luaL_error(ms->L, "missing '[' after '%%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)) {
-              p = ep; goto init;  /* return match(ms, s, ep); */
-            }
-            s = NULL;  /* match failed */
-            break;
-          }
-          case '0': case '1': case '2': case '3':
-          case '4': case '5': case '6': case '7':
-          case '8': case '9': {  /* capture results (%0-%9)? */
-            s = match_capture(ms, s, uchar(*(p + 1)));
-            if (s != NULL) {
-              p += 2; goto init;  /* return match(ms, s, p + 2) */
-            }
-            break;
-          }
-          default: goto dflt;
-        }
-        break;
-      }
-      default: dflt: {  /* pattern class plus optional suffix */
-        const char *ep = classend(ms, p);  /* points to optional suffix */
-        /* does not match at least once? */
-        if (!singlematch(ms, s, p, ep)) {
-          if (*ep == '*' || *ep == '?' || *ep == '-') {  /* accept empty? */
-            p = ep + 1; goto init;  /* return match(ms, s, ep + 1); */
-          }
-          else  /* '+' or no suffix */
-            s = NULL;  /* fail */
-        }
-        else {  /* matched once */
-          switch (*ep) {  /* handle optional suffix */
-            case '?': {  /* optional */
-              const char *res;
-              if ((res = match(ms, s + 1, ep + 1)) != NULL)
-                s = res;
-              else {
-                p = ep + 1; goto init;  /* else return match(ms, s, ep + 1); */
-              }
-              break;
-            }
-            case '+':  /* 1 or more repetitions */
-              s++;  /* 1 match already done */
-              /* FALLTHROUGH */
-            case '*':  /* 0 or more repetitions */
-              s = max_expand(ms, s, p, ep);
-              break;
-            case '-':  /* 0 or more repetitions (minimum) */
-              s = min_expand(ms, s, p, ep);
-              break;
-            default:  /* no suffix */
-              s++; p = ep; goto init;  /* return match(ms, s + 1, ep); */
-          }
-        }
-        break;
-      }
-    }
-  }
-  ms->matchdepth++;
-  return s;
-}
-
-
-
-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 %%%d", i + 1);
-  }
-  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 */
-}
-
-
-/* check whether pattern has no special characters */
-static int nospecials (const char *p, size_t l) {
-  size_t upto = 0;
-  do {
-    if (strpbrk(p + upto, SPECIALS))
-      return 0;  /* pattern has a special character */
-    upto += strlen(p + upto) + 1;  /* may have more after \0 */
-  } while (upto <= l);
-  return 1;  /* no special chars found */
-}
-
-
-static void prepstate (MatchState *ms, lua_State *L,
-                       const char *s, size_t ls, const char *p, size_t lp) {
-  ms->L = L;
-  ms->matchdepth = MAXCCALLS;
-  ms->src_init = s;
-  ms->src_end = s + ls;
-  ms->p_end = p + lp;
-}
-
-
-static void reprepstate (MatchState *ms) {
-  ms->level = 0;
-  lua_assert(ms->matchdepth == MAXCCALLS);
-}
-
-
-static int str_find_aux (lua_State *L, int find) {
-  size_t ls, lp;
-  const char *s = luaL_checklstring(L, 1, &ls);
-  const char *p = luaL_checklstring(L, 2, &lp);
-  lua_Integer init = posrelat(luaL_optinteger(L, 3, 1), ls);
-  if (init < 1) init = 1;
-  else if (init > (lua_Integer)ls + 1) {  /* start after string's end? */
-    lua_pushnil(L);  /* cannot find anything */
-    return 1;
-  }
-  /* explicit request or no special characters? */
-  if (find && (lua_toboolean(L, 4) || nospecials(p, lp))) {
-    /* do a plain search */
-    const char *s2 = lmemfind(s + init - 1, ls - (size_t)init + 1, p, lp);
-    if (s2) {
-      lua_pushinteger(L, (s2 - s) + 1);
-      lua_pushinteger(L, (s2 - s) + lp);
-      return 2;
-    }
-  }
-  else {
-    MatchState ms;
-    const char *s1 = s + init - 1;
-    int anchor = (*p == '^');
-    if (anchor) {
-      p++; lp--;  /* skip anchor character */
-    }
-    prepstate(&ms, L, s, ls, p, lp);
-    do {
-      const char *res;
-      reprepstate(&ms);
-      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);
-}
-
-
-/* state for 'gmatch' */
-typedef struct GMatchState {
-  const char *src;  /* current position */
-  const char *p;  /* pattern */
-  const char *lastmatch;  /* end of last match */
-  MatchState ms;  /* match state */
-} GMatchState;
-
-
-static int gmatch_aux (lua_State *L) {
-  GMatchState *gm = (GMatchState *)lua_touserdata(L, lua_upvalueindex(3));
-  const char *src;
-  gm->ms.L = L;
-  for (src = gm->src; src <= gm->ms.src_end; src++) {
-    const char *e;
-    reprepstate(&gm->ms);
-    if ((e = match(&gm->ms, src, gm->p)) != NULL && e != gm->lastmatch) {
-      gm->src = gm->lastmatch = e;
-      return push_captures(&gm->ms, src, e);
-    }
-  }
-  return 0;  /* not found */
-}
-
-
-static int gmatch (lua_State *L) {
-  size_t ls, lp;
-  const char *s = luaL_checklstring(L, 1, &ls);
-  const char *p = luaL_checklstring(L, 2, &lp);
-  GMatchState *gm;
-  lua_settop(L, 2);  /* keep them on closure to avoid being collected */
-  gm = (GMatchState *)lua_newuserdata(L, sizeof(GMatchState));
-  prepstate(&gm->ms, L, s, ls, p, lp);
-  gm->src = s; gm->p = p; gm->lastmatch = NULL;
-  lua_pushcclosure(L, gmatch_aux, 3);
-  return 1;
-}
-
-
-static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
-                                                   const char *e) {
-  size_t l, i;
-  lua_State *L = ms->L;
-  const char *news = lua_tolstring(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]))) {
-        if (news[i] != L_ESC)
-          luaL_error(L, "invalid use of '%c' in replacement string", L_ESC);
-        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_tolstring(L, -1, NULL);  /* if number, convert it to string */
-        lua_remove(L, -2);  /* remove original value */
-        luaL_addvalue(b);  /* add capture to accumulated result */
-      }
-    }
-  }
-}
-
-
-static void add_value (MatchState *ms, luaL_Buffer *b, const char *s,
-                                       const char *e, int tr) {
-  lua_State *L = ms->L;
-  switch (tr) {
-    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;
-    }
-    default: {  /* LUA_TNUMBER or LUA_TSTRING */
-      add_s(ms, b, s, e);
-      return;
-    }
-  }
-  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, lp;
-  const char *src = luaL_checklstring(L, 1, &srcl);  /* subject */
-  const char *p = luaL_checklstring(L, 2, &lp);  /* pattern */
-  const char *lastmatch = NULL;  /* end of last match */
-  int tr = lua_type(L, 3);  /* replacement type */
-  lua_Integer max_s = luaL_optinteger(L, 4, srcl + 1);  /* max replacements */
-  int anchor = (*p == '^');
-  lua_Integer n = 0;  /* replacement count */
-  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);
-  if (anchor) {
-    p++; lp--;  /* skip anchor character */
-  }
-  prepstate(&ms, L, src, srcl, p, lp);
-  while (n < max_s) {
-    const char *e;
-    reprepstate(&ms);  /* (re)prepare state for new match */
-    if ((e = match(&ms, src, p)) != NULL && e != lastmatch) {  /* match? */
-      n++;
-      add_value(&ms, &b, src, e, tr);  /* add replacement to buffer */
-      src = lastmatch = e;
-    }
-    else if (src < ms.src_end)  /* otherwise, skip one character */
-      luaL_addchar(&b, *src++);
-    else break;  /* end of subject */
-    if (anchor) break;
-  }
-  luaL_addlstring(&b, src, ms.src_end-src);
-  luaL_pushresult(&b);
-  lua_pushinteger(L, n);  /* number of substitutions */
-  return 2;
-}
-
-/* }====================================================== */
-
-
-
-/*
-** {======================================================
-** STRING FORMAT
-** =======================================================
-*/
-
-#if !defined(lua_number2strx)	/* { */
-
-/*
-** Hexadecimal floating-point formatter
-*/
-
-#include <math.h>
-
-#define SIZELENMOD	(sizeof(LUA_NUMBER_FRMLEN)/sizeof(char))
-
-
-/*
-** Number of bits that goes into the first digit. It can be any value
-** between 1 and 4; the following definition tries to align the number
-** to nibble boundaries by making what is left after that first digit a
-** multiple of 4.
-*/
-#define L_NBFD		((l_mathlim(MANT_DIG) - 1)%4 + 1)
-
-
-/*
-** Add integer part of 'x' to buffer and return new 'x'
-*/
-static lua_Number adddigit (char *buff, int n, lua_Number x) {
-  lua_Number dd = l_mathop(floor)(x);  /* get integer part from 'x' */
-  int d = (int)dd;
-  buff[n] = (d < 10 ? d + '0' : d - 10 + 'a');  /* add to buffer */
-  return x - dd;  /* return what is left */
-}
-
-
-static int num2straux (char *buff, int sz, lua_Number x) {
-  /* if 'inf' or 'NaN', format it like '%g' */
-  if (x != x || x == (lua_Number)HUGE_VAL || x == -(lua_Number)HUGE_VAL)
-    return l_sprintf(buff, sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)x);
-  else if (x == 0) {  /* can be -0... */
-    /* create "0" or "-0" followed by exponent */
-    return l_sprintf(buff, sz, LUA_NUMBER_FMT "x0p+0", (LUAI_UACNUMBER)x);
-  }
-  else {
-    int e;
-    lua_Number m = l_mathop(frexp)(x, &e);  /* 'x' fraction and exponent */
-    int n = 0;  /* character count */
-    if (m < 0) {  /* is number negative? */
-      buff[n++] = '-';  /* add signal */
-      m = -m;  /* make it positive */
-    }
-    buff[n++] = '0'; buff[n++] = 'x';  /* add "0x" */
-    m = adddigit(buff, n++, m * (1 << L_NBFD));  /* add first digit */
-    e -= L_NBFD;  /* this digit goes before the radix point */
-    if (m > 0) {  /* more digits? */
-      buff[n++] = lua_getlocaledecpoint();  /* add radix point */
-      do {  /* add as many digits as needed */
-        m = adddigit(buff, n++, m * 16);
-      } while (m > 0);
-    }
-    n += l_sprintf(buff + n, sz - n, "p%+d", e);  /* add exponent */
-    lua_assert(n < sz);
-    return n;
-  }
-}
-
-
-static int lua_number2strx (lua_State *L, char *buff, int sz,
-                            const char *fmt, lua_Number x) {
-  int n = num2straux(buff, sz, x);
-  if (fmt[SIZELENMOD] == 'A') {
-    int i;
-    for (i = 0; i < n; i++)
-      buff[i] = toupper(uchar(buff[i]));
-  }
-  else if (fmt[SIZELENMOD] != 'a')
-    return luaL_error(L, "modifiers for format '%%a'/'%%A' not implemented");
-  return n;
-}
-
-#endif				/* } */
-
-
-/*
-** Maximum size of each formatted item. This maximum size is produced
-** by format('%.99f', -maxfloat), and is equal to 99 + 3 ('-', '.',
-** and '\0') + number of decimal digits to represent maxfloat (which
-** is maximum exponent + 1). (99+3+1 then rounded to 120 for "extra
-** expenses", such as locale-dependent stuff)
-*/
-#define MAX_ITEM        (120 + l_mathlim(MAX_10_EXP))
-
-
-/* valid flags in a format specification */
-#define FLAGS	"-+ #0"
-
-/*
-** maximum size of each format specification (such as "%-099.99d")
-*/
-#define MAX_FORMAT	32
-
-
-static void addquoted (luaL_Buffer *b, const char *s, size_t len) {
-  luaL_addchar(b, '"');
-  while (len--) {
-    if (*s == '"' || *s == '\\' || *s == '\n') {
-      luaL_addchar(b, '\\');
-      luaL_addchar(b, *s);
-    }
-    else if (iscntrl(uchar(*s))) {
-      char buff[10];
-      if (!isdigit(uchar(*(s+1))))
-        l_sprintf(buff, sizeof(buff), "\\%d", (int)uchar(*s));
-      else
-        l_sprintf(buff, sizeof(buff), "\\%03d", (int)uchar(*s));
-      luaL_addstring(b, buff);
-    }
-    else
-      luaL_addchar(b, *s);
-    s++;
-  }
-  luaL_addchar(b, '"');
-}
-
-
-/*
-** Ensures the 'buff' string uses a dot as the radix character.
-*/
-static void checkdp (char *buff, int nb) {
-  if (memchr(buff, '.', nb) == NULL) {  /* no dot? */
-    char point = lua_getlocaledecpoint();  /* try locale point */
-    char *ppoint = (char *)memchr(buff, point, nb);
-    if (ppoint) *ppoint = '.';  /* change it to a dot */
-  }
-}
-
-
-static void addliteral (lua_State *L, luaL_Buffer *b, int arg) {
-  switch (lua_type(L, arg)) {
-    case LUA_TSTRING: {
-      size_t len;
-      const char *s = lua_tolstring(L, arg, &len);
-      addquoted(b, s, len);
-      break;
-    }
-    case LUA_TNUMBER: {
-      char *buff = luaL_prepbuffsize(b, MAX_ITEM);
-      int nb;
-      if (!lua_isinteger(L, arg)) {  /* float? */
-        lua_Number n = lua_tonumber(L, arg);  /* write as hexa ('%a') */
-        nb = lua_number2strx(L, buff, MAX_ITEM, "%" LUA_NUMBER_FRMLEN "a", n);
-        checkdp(buff, nb);  /* ensure it uses a dot */
-      }
-      else {  /* integers */
-        lua_Integer n = lua_tointeger(L, arg);
-        const char *format = (n == LUA_MININTEGER)  /* corner case? */
-                           ? "0x%" LUA_INTEGER_FRMLEN "x"  /* use hexa */
-                           : LUA_INTEGER_FMT;  /* else use default format */
-        nb = l_sprintf(buff, MAX_ITEM, format, (LUAI_UACINT)n);
-      }
-      luaL_addsize(b, nb);
-      break;
-    }
-    case LUA_TNIL: case LUA_TBOOLEAN: {
-      luaL_tolstring(L, arg, NULL);
-      luaL_addvalue(b);
-      break;
-    }
-    default: {
-      luaL_argerror(L, arg, "value has no literal form");
-    }
-  }
-}
-
-
-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)/sizeof(char))
-    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++) = '%';
-  memcpy(form, strfrmt, ((p - strfrmt) + 1) * sizeof(char));
-  form += (p - strfrmt) + 1;
-  *form = '\0';
-  return p;
-}
-
-
-/*
-** add length modifier into formats
-*/
-static void addlenmod (char *form, const char *lenmod) {
-  size_t l = strlen(form);
-  size_t lm = strlen(lenmod);
-  char spec = form[l - 1];
-  strcpy(form + l - 1, lenmod);
-  form[l + lm - 1] = spec;
-  form[l + lm] = '\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 = luaL_prepbuffsize(&b, MAX_ITEM);  /* to put formatted item */
-      int nb = 0;  /* number of bytes in added item */
-      if (++arg > top)
-        luaL_argerror(L, arg, "no value");
-      strfrmt = scanformat(L, strfrmt, form);
-      switch (*strfrmt++) {
-        case 'c': {
-          nb = l_sprintf(buff, MAX_ITEM, form, (int)luaL_checkinteger(L, arg));
-          break;
-        }
-        case 'd': case 'i':
-        case 'o': case 'u': case 'x': case 'X': {
-          lua_Integer n = luaL_checkinteger(L, arg);
-          addlenmod(form, LUA_INTEGER_FRMLEN);
-          nb = l_sprintf(buff, MAX_ITEM, form, (LUAI_UACINT)n);
-          break;
-        }
-        case 'a': case 'A':
-          addlenmod(form, LUA_NUMBER_FRMLEN);
-          nb = lua_number2strx(L, buff, MAX_ITEM, form,
-                                  luaL_checknumber(L, arg));
-          break;
-        case 'e': case 'E': case 'f':
-        case 'g': case 'G': {
-          lua_Number n = luaL_checknumber(L, arg);
-          addlenmod(form, LUA_NUMBER_FRMLEN);
-          nb = l_sprintf(buff, MAX_ITEM, form, (LUAI_UACNUMBER)n);
-          break;
-        }
-        case 'q': {
-          addliteral(L, &b, arg);
-          break;
-        }
-        case 's': {
-          size_t l;
-          const char *s = luaL_tolstring(L, arg, &l);
-          if (form[2] == '\0')  /* no modifiers? */
-            luaL_addvalue(&b);  /* keep entire string */
-          else {
-            luaL_argcheck(L, l == strlen(s), arg, "string contains zeros");
-            if (!strchr(form, '.') && l >= 100) {
-              /* no precision and string is too long to be formatted */
-              luaL_addvalue(&b);  /* keep entire string */
-            }
-            else {  /* format the string into 'buff' */
-              nb = l_sprintf(buff, MAX_ITEM, form, s);
-              lua_pop(L, 1);  /* remove result from 'luaL_tolstring' */
-            }
-          }
-          break;
-        }
-        default: {  /* also treat cases 'pnLlh' */
-          return luaL_error(L, "invalid option '%%%c' to 'format'",
-                               *(strfrmt - 1));
-        }
-      }
-      lua_assert(nb < MAX_ITEM);
-      luaL_addsize(&b, nb);
-    }
-  }
-  luaL_pushresult(&b);
-  return 1;
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** PACK/UNPACK
-** =======================================================
-*/
-
-
-/* value used for padding */
-#if !defined(LUAL_PACKPADBYTE)
-#define LUAL_PACKPADBYTE		0x00
-#endif
-
-/* maximum size for the binary representation of an integer */
-#define MAXINTSIZE	16
-
-/* number of bits in a character */
-#define NB	CHAR_BIT
-
-/* mask for one character (NB 1's) */
-#define MC	((1 << NB) - 1)
-
-/* size of a lua_Integer */
-#define SZINT	((int)sizeof(lua_Integer))
-
-
-/* dummy union to get native endianness */
-static const union {
-  int dummy;
-  char little;  /* true iff machine is little endian */
-} nativeendian = {1};
-
-
-/* dummy structure to get native alignment requirements */
-struct cD {
-  char c;
-  union { double d; void *p; lua_Integer i; lua_Number n; } u;
-};
-
-#define MAXALIGN	(offsetof(struct cD, u))
-
-
-/*
-** Union for serializing floats
-*/
-typedef union Ftypes {
-  float f;
-  double d;
-  lua_Number n;
-  char buff[5 * sizeof(lua_Number)];  /* enough for any float type */
-} Ftypes;
-
-
-/*
-** information to pack/unpack stuff
-*/
-typedef struct Header {
-  lua_State *L;
-  int islittle;
-  int maxalign;
-} Header;
-
-
-/*
-** options for pack/unpack
-*/
-typedef enum KOption {
-  Kint,		/* signed integers */
-  Kuint,	/* unsigned integers */
-  Kfloat,	/* floating-point numbers */
-  Kchar,	/* fixed-length strings */
-  Kstring,	/* strings with prefixed length */
-  Kzstr,	/* zero-terminated strings */
-  Kpadding,	/* padding */
-  Kpaddalign,	/* padding for alignment */
-  Knop		/* no-op (configuration or spaces) */
-} KOption;
-
-
-/*
-** Read an integer numeral from string 'fmt' or return 'df' if
-** there is no numeral
-*/
-static int digit (int c) { return '0' <= c && c <= '9'; }
-
-static int getnum (const char **fmt, int df) {
-  if (!digit(**fmt))  /* no number? */
-    return df;  /* return default value */
-  else {
-    int a = 0;
-    do {
-      a = a*10 + (*((*fmt)++) - '0');
-    } while (digit(**fmt) && a <= ((int)MAXSIZE - 9)/10);
-    return a;
-  }
-}
-
-
-/*
-** Read an integer numeral and raises an error if it is larger
-** than the maximum size for integers.
-*/
-static int getnumlimit (Header *h, const char **fmt, int df) {
-  int sz = getnum(fmt, df);
-  if (sz > MAXINTSIZE || sz <= 0)
-    return luaL_error(h->L, "integral size (%d) out of limits [1,%d]",
-                            sz, MAXINTSIZE);
-  return sz;
-}
-
-
-/*
-** Initialize Header
-*/
-static void initheader (lua_State *L, Header *h) {
-  h->L = L;
-  h->islittle = nativeendian.little;
-  h->maxalign = 1;
-}
-
-
-/*
-** Read and classify next option. 'size' is filled with option's size.
-*/
-static KOption getoption (Header *h, const char **fmt, int *size) {
-  int opt = *((*fmt)++);
-  *size = 0;  /* default */
-  switch (opt) {
-    case 'b': *size = sizeof(char); return Kint;
-    case 'B': *size = sizeof(char); return Kuint;
-    case 'h': *size = sizeof(short); return Kint;
-    case 'H': *size = sizeof(short); return Kuint;
-    case 'l': *size = sizeof(long); return Kint;
-    case 'L': *size = sizeof(long); return Kuint;
-    case 'j': *size = sizeof(lua_Integer); return Kint;
-    case 'J': *size = sizeof(lua_Integer); return Kuint;
-    case 'T': *size = sizeof(size_t); return Kuint;
-    case 'f': *size = sizeof(float); return Kfloat;
-    case 'd': *size = sizeof(double); return Kfloat;
-    case 'n': *size = sizeof(lua_Number); return Kfloat;
-    case 'i': *size = getnumlimit(h, fmt, sizeof(int)); return Kint;
-    case 'I': *size = getnumlimit(h, fmt, sizeof(int)); return Kuint;
-    case 's': *size = getnumlimit(h, fmt, sizeof(size_t)); return Kstring;
-    case 'c':
-      *size = getnum(fmt, -1);
-      if (*size == -1)
-        luaL_error(h->L, "missing size for format option 'c'");
-      return Kchar;
-    case 'z': return Kzstr;
-    case 'x': *size = 1; return Kpadding;
-    case 'X': return Kpaddalign;
-    case ' ': break;
-    case '<': h->islittle = 1; break;
-    case '>': h->islittle = 0; break;
-    case '=': h->islittle = nativeendian.little; break;
-    case '!': h->maxalign = getnumlimit(h, fmt, MAXALIGN); break;
-    default: luaL_error(h->L, "invalid format option '%c'", opt);
-  }
-  return Knop;
-}
-
-
-/*
-** Read, classify, and fill other details about the next option.
-** 'psize' is filled with option's size, 'notoalign' with its
-** alignment requirements.
-** Local variable 'size' gets the size to be aligned. (Kpadal option
-** always gets its full alignment, other options are limited by
-** the maximum alignment ('maxalign'). Kchar option needs no alignment
-** despite its size.
-*/
-static KOption getdetails (Header *h, size_t totalsize,
-                           const char **fmt, int *psize, int *ntoalign) {
-  KOption opt = getoption(h, fmt, psize);
-  int align = *psize;  /* usually, alignment follows size */
-  if (opt == Kpaddalign) {  /* 'X' gets alignment from following option */
-    if (**fmt == '\0' || getoption(h, fmt, &align) == Kchar || align == 0)
-      luaL_argerror(h->L, 1, "invalid next option for option 'X'");
-  }
-  if (align <= 1 || opt == Kchar)  /* need no alignment? */
-    *ntoalign = 0;
-  else {
-    if (align > h->maxalign)  /* enforce maximum alignment */
-      align = h->maxalign;
-    if ((align & (align - 1)) != 0)  /* is 'align' not a power of 2? */
-      luaL_argerror(h->L, 1, "format asks for alignment not power of 2");
-    *ntoalign = (align - (int)(totalsize & (align - 1))) & (align - 1);
-  }
-  return opt;
-}
-
-
-/*
-** Pack integer 'n' with 'size' bytes and 'islittle' endianness.
-** The final 'if' handles the case when 'size' is larger than
-** the size of a Lua integer, correcting the extra sign-extension
-** bytes if necessary (by default they would be zeros).
-*/
-static void packint (luaL_Buffer *b, lua_Unsigned n,
-                     int islittle, int size, int neg) {
-  char *buff = luaL_prepbuffsize(b, size);
-  int i;
-  buff[islittle ? 0 : size - 1] = (char)(n & MC);  /* first byte */
-  for (i = 1; i < size; i++) {
-    n >>= NB;
-    buff[islittle ? i : size - 1 - i] = (char)(n & MC);
-  }
-  if (neg && size > SZINT) {  /* negative number need sign extension? */
-    for (i = SZINT; i < size; i++)  /* correct extra bytes */
-      buff[islittle ? i : size - 1 - i] = (char)MC;
-  }
-  luaL_addsize(b, size);  /* add result to buffer */
-}
-
-
-/*
-** Copy 'size' bytes from 'src' to 'dest', correcting endianness if
-** given 'islittle' is different from native endianness.
-*/
-static void copywithendian (volatile char *dest, volatile const char *src,
-                            int size, int islittle) {
-  if (islittle == nativeendian.little) {
-    while (size-- != 0)
-      *(dest++) = *(src++);
-  }
-  else {
-    dest += size - 1;
-    while (size-- != 0)
-      *(dest--) = *(src++);
-  }
-}
-
-
-static int str_pack (lua_State *L) {
-  luaL_Buffer b;
-  Header h;
-  const char *fmt = luaL_checkstring(L, 1);  /* format string */
-  int arg = 1;  /* current argument to pack */
-  size_t totalsize = 0;  /* accumulate total size of result */
-  initheader(L, &h);
-  lua_pushnil(L);  /* mark to separate arguments from string buffer */
-  luaL_buffinit(L, &b);
-  while (*fmt != '\0') {
-    int size, ntoalign;
-    KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
-    totalsize += ntoalign + size;
-    while (ntoalign-- > 0)
-     luaL_addchar(&b, LUAL_PACKPADBYTE);  /* fill alignment */
-    arg++;
-    switch (opt) {
-      case Kint: {  /* signed integers */
-        lua_Integer n = luaL_checkinteger(L, arg);
-        if (size < SZINT) {  /* need overflow check? */
-          lua_Integer lim = (lua_Integer)1 << ((size * NB) - 1);
-          luaL_argcheck(L, -lim <= n && n < lim, arg, "integer overflow");
-        }
-        packint(&b, (lua_Unsigned)n, h.islittle, size, (n < 0));
-        break;
-      }
-      case Kuint: {  /* unsigned integers */
-        lua_Integer n = luaL_checkinteger(L, arg);
-        if (size < SZINT)  /* need overflow check? */
-          luaL_argcheck(L, (lua_Unsigned)n < ((lua_Unsigned)1 << (size * NB)),
-                           arg, "unsigned overflow");
-        packint(&b, (lua_Unsigned)n, h.islittle, size, 0);
-        break;
-      }
-      case Kfloat: {  /* floating-point options */
-        volatile Ftypes u;
-        char *buff = luaL_prepbuffsize(&b, size);
-        lua_Number n = luaL_checknumber(L, arg);  /* get argument */
-        if (size == sizeof(u.f)) u.f = (float)n;  /* copy it into 'u' */
-        else if (size == sizeof(u.d)) u.d = (double)n;
-        else u.n = n;
-        /* move 'u' to final result, correcting endianness if needed */
-        copywithendian(buff, u.buff, size, h.islittle);
-        luaL_addsize(&b, size);
-        break;
-      }
-      case Kchar: {  /* fixed-size string */
-        size_t len;
-        const char *s = luaL_checklstring(L, arg, &len);
-        luaL_argcheck(L, len <= (size_t)size, arg,
-                         "string longer than given size");
-        luaL_addlstring(&b, s, len);  /* add string */
-        while (len++ < (size_t)size)  /* pad extra space */
-          luaL_addchar(&b, LUAL_PACKPADBYTE);
-        break;
-      }
-      case Kstring: {  /* strings with length count */
-        size_t len;
-        const char *s = luaL_checklstring(L, arg, &len);
-        luaL_argcheck(L, size >= (int)sizeof(size_t) ||
-                         len < ((size_t)1 << (size * NB)),
-                         arg, "string length does not fit in given size");
-        packint(&b, (lua_Unsigned)len, h.islittle, size, 0);  /* pack length */
-        luaL_addlstring(&b, s, len);
-        totalsize += len;
-        break;
-      }
-      case Kzstr: {  /* zero-terminated string */
-        size_t len;
-        const char *s = luaL_checklstring(L, arg, &len);
-        luaL_argcheck(L, strlen(s) == len, arg, "string contains zeros");
-        luaL_addlstring(&b, s, len);
-        luaL_addchar(&b, '\0');  /* add zero at the end */
-        totalsize += len + 1;
-        break;
-      }
-      case Kpadding: luaL_addchar(&b, LUAL_PACKPADBYTE);  /* FALLTHROUGH */
-      case Kpaddalign: case Knop:
-        arg--;  /* undo increment */
-        break;
-    }
-  }
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-static int str_packsize (lua_State *L) {
-  Header h;
-  const char *fmt = luaL_checkstring(L, 1);  /* format string */
-  size_t totalsize = 0;  /* accumulate total size of result */
-  initheader(L, &h);
-  while (*fmt != '\0') {
-    int size, ntoalign;
-    KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
-    size += ntoalign;  /* total space used by option */
-    luaL_argcheck(L, totalsize <= MAXSIZE - size, 1,
-                     "format result too large");
-    totalsize += size;
-    switch (opt) {
-      case Kstring:  /* strings with length count */
-      case Kzstr:    /* zero-terminated string */
-        luaL_argerror(L, 1, "variable-length format");
-        /* call never return, but to avoid warnings: *//* FALLTHROUGH */
-      default:  break;
-    }
-  }
-  lua_pushinteger(L, (lua_Integer)totalsize);
-  return 1;
-}
-
-
-/*
-** Unpack an integer with 'size' bytes and 'islittle' endianness.
-** If size is smaller than the size of a Lua integer and integer
-** is signed, must do sign extension (propagating the sign to the
-** higher bits); if size is larger than the size of a Lua integer,
-** it must check the unread bytes to see whether they do not cause an
-** overflow.
-*/
-static lua_Integer unpackint (lua_State *L, const char *str,
-                              int islittle, int size, int issigned) {
-  lua_Unsigned res = 0;
-  int i;
-  int limit = (size  <= SZINT) ? size : SZINT;
-  for (i = limit - 1; i >= 0; i--) {
-    res <<= NB;
-    res |= (lua_Unsigned)(unsigned char)str[islittle ? i : size - 1 - i];
-  }
-  if (size < SZINT) {  /* real size smaller than lua_Integer? */
-    if (issigned) {  /* needs sign extension? */
-      lua_Unsigned mask = (lua_Unsigned)1 << (size*NB - 1);
-      res = ((res ^ mask) - mask);  /* do sign extension */
-    }
-  }
-  else if (size > SZINT) {  /* must check unread bytes */
-    int mask = (!issigned || (lua_Integer)res >= 0) ? 0 : MC;
-    for (i = limit; i < size; i++) {
-      if ((unsigned char)str[islittle ? i : size - 1 - i] != mask)
-        luaL_error(L, "%d-byte integer does not fit into Lua Integer", size);
-    }
-  }
-  return (lua_Integer)res;
-}
-
-
-static int str_unpack (lua_State *L) {
-  Header h;
-  const char *fmt = luaL_checkstring(L, 1);
-  size_t ld;
-  const char *data = luaL_checklstring(L, 2, &ld);
-  size_t pos = (size_t)posrelat(luaL_optinteger(L, 3, 1), ld) - 1;
-  int n = 0;  /* number of results */
-  luaL_argcheck(L, pos <= ld, 3, "initial position out of string");
-  initheader(L, &h);
-  while (*fmt != '\0') {
-    int size, ntoalign;
-    KOption opt = getdetails(&h, pos, &fmt, &size, &ntoalign);
-    if ((size_t)ntoalign + size > ~pos || pos + ntoalign + size > ld)
-      luaL_argerror(L, 2, "data string too short");
-    pos += ntoalign;  /* skip alignment */
-    /* stack space for item + next position */
-    luaL_checkstack(L, 2, "too many results");
-    n++;
-    switch (opt) {
-      case Kint:
-      case Kuint: {
-        lua_Integer res = unpackint(L, data + pos, h.islittle, size,
-                                       (opt == Kint));
-        lua_pushinteger(L, res);
-        break;
-      }
-      case Kfloat: {
-        volatile Ftypes u;
-        lua_Number num;
-        copywithendian(u.buff, data + pos, size, h.islittle);
-        if (size == sizeof(u.f)) num = (lua_Number)u.f;
-        else if (size == sizeof(u.d)) num = (lua_Number)u.d;
-        else num = u.n;
-        lua_pushnumber(L, num);
-        break;
-      }
-      case Kchar: {
-        lua_pushlstring(L, data + pos, size);
-        break;
-      }
-      case Kstring: {
-        size_t len = (size_t)unpackint(L, data + pos, h.islittle, size, 0);
-        luaL_argcheck(L, pos + len + size <= ld, 2, "data string too short");
-        lua_pushlstring(L, data + pos + size, len);
-        pos += len;  /* skip string */
-        break;
-      }
-      case Kzstr: {
-        size_t len = (int)strlen(data + pos);
-        lua_pushlstring(L, data + pos, len);
-        pos += len + 1;  /* skip string plus final '\0' */
-        break;
-      }
-      case Kpaddalign: case Kpadding: case Knop:
-        n--;  /* undo increment */
-        break;
-    }
-    pos += size;
-  }
-  lua_pushinteger(L, pos + 1);  /* next position */
-  return n + 1;
-}
-
-/* }====================================================== */
-
-
-static const luaL_Reg strlib[] = {
-  {"byte", str_byte},
-  {"char", str_char},
-  {"dump", str_dump},
-  {"find", str_find},
-  {"format", str_format},
-  {"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},
-  {"pack", str_pack},
-  {"packsize", str_packsize},
-  {"unpack", str_unpack},
-  {NULL, NULL}
-};
-
-
-static void createmetatable (lua_State *L) {
-  lua_createtable(L, 0, 1);  /* table to be metatable for strings */
-  lua_pushliteral(L, "");  /* dummy string */
-  lua_pushvalue(L, -2);  /* copy table */
-  lua_setmetatable(L, -2);  /* set table as metatable for strings */
-  lua_pop(L, 1);  /* pop dummy string */
-  lua_pushvalue(L, -2);  /* get string library */
-  lua_setfield(L, -2, "__index");  /* metatable.__index = string */
-  lua_pop(L, 1);  /* pop metatable */
-}
-
-
-/*
-** Open string library
-*/
-LUAMOD_API int luaopen_string (lua_State *L) {
-  luaL_newlib(L, strlib);
-  createmetatable(L);
-  return 1;
-}
-
diff --git a/lua/lua-5.3.5/src/ltable.c b/lua/lua-5.3.5/src/ltable.c
deleted file mode 100644
index ea4fe7f..0000000
--- a/lua/lua-5.3.5/src/ltable.c
+++ /dev/null
@@ -1,688 +0,0 @@
-/*
-** $Id: ltable.c,v 2.118.1.4 2018/06/08 16:22:51 roberto Exp $
-** Lua tables (hash)
-** See Copyright Notice in lua.h
-*/
-
-#define ltable_c
-#define LUA_CORE
-
-#include "lprefix.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
-** more than half the slots between 1 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 <limits.h>
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "lvm.h"
-
-
-/*
-** Maximum size of array part (MAXASIZE) is 2^MAXABITS. MAXABITS is
-** the largest integer such that MAXASIZE fits in an unsigned int.
-*/
-#define MAXABITS	cast_int(sizeof(int) * CHAR_BIT - 1)
-#define MAXASIZE	(1u << MAXABITS)
-
-/*
-** Maximum size of hash part is 2^MAXHBITS. MAXHBITS is the largest
-** integer such that 2^MAXHBITS fits in a signed int. (Note that the
-** maximum number of elements in a table, 2^MAXABITS + 2^MAXHBITS, still
-** fits comfortably in an unsigned int.)
-*/
-#define MAXHBITS	(MAXABITS - 1)
-
-
-#define hashpow2(t,n)		(gnode(t, lmod((n), sizenode(t))))
-
-#define hashstr(t,str)		hashpow2(t, (str)->hash)
-#define hashboolean(t,p)	hashpow2(t, p)
-#define hashint(t,i)		hashpow2(t, i)
-
-
-/*
-** 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, point2uint(p))
-
-
-#define dummynode		(&dummynode_)
-
-static const Node dummynode_ = {
-  {NILCONSTANT},  /* value */
-  {{NILCONSTANT, 0}}  /* key */
-};
-
-
-/*
-** Hash for floating-point numbers.
-** The main computation should be just
-**     n = frexp(n, &i); return (n * INT_MAX) + i
-** but there are some numerical subtleties.
-** In a two-complement representation, INT_MAX does not has an exact
-** representation as a float, but INT_MIN does; because the absolute
-** value of 'frexp' is smaller than 1 (unless 'n' is inf/NaN), the
-** absolute value of the product 'frexp * -INT_MIN' is smaller or equal
-** to INT_MAX. Next, the use of 'unsigned int' avoids overflows when
-** adding 'i'; the use of '~u' (instead of '-u') avoids problems with
-** INT_MIN.
-*/
-#if !defined(l_hashfloat)
-static int l_hashfloat (lua_Number n) {
-  int i;
-  lua_Integer ni;
-  n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN);
-  if (!lua_numbertointeger(n, &ni)) {  /* is 'n' inf/-inf/NaN? */
-    lua_assert(luai_numisnan(n) || l_mathop(fabs)(n) == cast_num(HUGE_VAL));
-    return 0;
-  }
-  else {  /* normal case */
-    unsigned int u = cast(unsigned int, i) + cast(unsigned int, ni);
-    return cast_int(u <= cast(unsigned int, INT_MAX) ? u : ~u);
-  }
-}
-#endif
-
-
-/*
-** 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_TNUMINT:
-      return hashint(t, ivalue(key));
-    case LUA_TNUMFLT:
-      return hashmod(t, l_hashfloat(fltvalue(key)));
-    case LUA_TSHRSTR:
-      return hashstr(t, tsvalue(key));
-    case LUA_TLNGSTR:
-      return hashpow2(t, luaS_hashlongstr(tsvalue(key)));
-    case LUA_TBOOLEAN:
-      return hashboolean(t, bvalue(key));
-    case LUA_TLIGHTUSERDATA:
-      return hashpointer(t, pvalue(key));
-    case LUA_TLCF:
-      return hashpointer(t, fvalue(key));
-    default:
-      lua_assert(!ttisdeadkey(key));
-      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, 0 otherwise.
-*/
-static unsigned int arrayindex (const TValue *key) {
-  if (ttisinteger(key)) {
-    lua_Integer k = ivalue(key);
-    if (0 < k && (lua_Unsigned)k <= MAXASIZE)
-      return cast(unsigned int, k);  /* 'key' is an appropriate array index */
-  }
-  return 0;  /* '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 signaled by 0.
-*/
-static unsigned int findindex (lua_State *L, Table *t, StkId key) {
-  unsigned int i;
-  if (ttisnil(key)) return 0;  /* first iteration */
-  i = arrayindex(key);
-  if (i != 0 && i <= t->sizearray)  /* is 'key' inside array part? */
-    return i;  /* yes; that's the index */
-  else {
-    int nx;
-    Node *n = mainposition(t, key);
-    for (;;) {  /* check whether 'key' is somewhere in the chain */
-      /* key may be dead already, but it is ok to use it in 'next' */
-      if (luaV_rawequalobj(gkey(n), key) ||
-            (ttisdeadkey(gkey(n)) && iscollectable(key) &&
-             deadvalue(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 + 1) + t->sizearray;
-      }
-      nx = gnext(n);
-      if (nx == 0)
-        luaG_runerror(L, "invalid key to 'next'");  /* key not found */
-      else n += nx;
-    }
-  }
-}
-
-
-int luaH_next (lua_State *L, Table *t, StkId key) {
-  unsigned int i = findindex(L, t, key);  /* find original element */
-  for (; i < t->sizearray; i++) {  /* try first array part */
-    if (!ttisnil(&t->array[i])) {  /* a non-nil value? */
-      setivalue(key, i + 1);
-      setobj2s(L, key+1, &t->array[i]);
-      return 1;
-    }
-  }
-  for (i -= t->sizearray; cast_int(i) < sizenode(t); i++) {  /* hash part */
-    if (!ttisnil(gval(gnode(t, i)))) {  /* a non-nil value? */
-      setobj2s(L, key, gkey(gnode(t, i)));
-      setobj2s(L, key+1, gval(gnode(t, i)));
-      return 1;
-    }
-  }
-  return 0;  /* no more elements */
-}
-
-
-/*
-** {=============================================================
-** Rehash
-** ==============================================================
-*/
-
-/*
-** Compute the optimal size for the array part of table 't'. 'nums' is a
-** "count array" where 'nums[i]' is the number of integers in the table
-** between 2^(i - 1) + 1 and 2^i. 'pna' enters with the total number of
-** integer keys in the table and leaves with the number of keys that
-** will go to the array part; return the optimal size.
-*/
-static unsigned int computesizes (unsigned int nums[], unsigned int *pna) {
-  int i;
-  unsigned int twotoi;  /* 2^i (candidate for optimal size) */
-  unsigned int a = 0;  /* number of elements smaller than 2^i */
-  unsigned int na = 0;  /* number of elements to go to array part */
-  unsigned int optimal = 0;  /* optimal size for array part */
-  /* loop while keys can fill more than half of total size */
-  for (i = 0, twotoi = 1;
-       twotoi > 0 && *pna > twotoi / 2;
-       i++, twotoi *= 2) {
-    if (nums[i] > 0) {
-      a += nums[i];
-      if (a > twotoi/2) {  /* more than half elements present? */
-        optimal = twotoi;  /* optimal size (till now) */
-        na = a;  /* all elements up to 'optimal' will go to array part */
-      }
-    }
-  }
-  lua_assert((optimal == 0 || optimal / 2 < na) && na <= optimal);
-  *pna = na;
-  return optimal;
-}
-
-
-static int countint (const TValue *key, unsigned int *nums) {
-  unsigned int k = arrayindex(key);
-  if (k != 0) {  /* is 'key' an appropriate array index? */
-    nums[luaO_ceillog2(k)]++;  /* count as such */
-    return 1;
-  }
-  else
-    return 0;
-}
-
-
-/*
-** Count keys in array part of table 't': Fill 'nums[i]' with
-** number of keys that will go into corresponding slice and return
-** total number of non-nil keys.
-*/
-static unsigned int numusearray (const Table *t, unsigned int *nums) {
-  int lg;
-  unsigned int ttlg;  /* 2^lg */
-  unsigned int ause = 0;  /* summation of 'nums' */
-  unsigned int i = 1;  /* count to traverse all array keys */
-  /* traverse each slice */
-  for (lg = 0, ttlg = 1; lg <= MAXABITS; lg++, ttlg *= 2) {
-    unsigned int lc = 0;  /* counter */
-    unsigned 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, unsigned int *nums, unsigned int *pna) {
-  int totaluse = 0;  /* total number of elements */
-  int ause = 0;  /* elements added to 'nums' (can go to array part) */
-  int i = sizenode(t);
-  while (i--) {
-    Node *n = &t->node[i];
-    if (!ttisnil(gval(n))) {
-      ause += countint(gkey(n), nums);
-      totaluse++;
-    }
-  }
-  *pna += ause;
-  return totaluse;
-}
-
-
-static void setarrayvector (lua_State *L, Table *t, unsigned int size) {
-  unsigned 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, unsigned int size) {
-  if (size == 0) {  /* no elements to hash part? */
-    t->node = cast(Node *, dummynode);  /* use common 'dummynode' */
-    t->lsizenode = 0;
-    t->lastfree = NULL;  /* signal that it is using dummy node */
-  }
-  else {
-    int i;
-    int lsize = luaO_ceillog2(size);
-    if (lsize > MAXHBITS)
-      luaG_runerror(L, "table overflow");
-    size = twoto(lsize);
-    t->node = luaM_newvector(L, size, Node);
-    for (i = 0; i < (int)size; i++) {
-      Node *n = gnode(t, i);
-      gnext(n) = 0;
-      setnilvalue(wgkey(n));
-      setnilvalue(gval(n));
-    }
-    t->lsizenode = cast_byte(lsize);
-    t->lastfree = gnode(t, size);  /* all positions are free */
-  }
-}
-
-
-typedef struct {
-  Table *t;
-  unsigned int nhsize;
-} AuxsetnodeT;
-
-
-static void auxsetnode (lua_State *L, void *ud) {
-  AuxsetnodeT *asn = cast(AuxsetnodeT *, ud);
-  setnodevector(L, asn->t, asn->nhsize);
-}
-
-
-void luaH_resize (lua_State *L, Table *t, unsigned int nasize,
-                                          unsigned int nhsize) {
-  unsigned int i;
-  int j;
-  AuxsetnodeT asn;
-  unsigned int oldasize = t->sizearray;
-  int oldhsize = allocsizenode(t);
-  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 */
-  asn.t = t; asn.nhsize = nhsize;
-  if (luaD_rawrunprotected(L, auxsetnode, &asn) != LUA_OK) {  /* mem. error? */
-    setarrayvector(L, t, oldasize);  /* array back to its original size */
-    luaD_throw(L, LUA_ERRMEM);  /* rethrow memory error */
-  }
-  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]))
-        luaH_setint(L, t, i + 1, &t->array[i]);
-    }
-    /* shrink array */
-    luaM_reallocvector(L, t->array, oldasize, nasize, TValue);
-  }
-  /* re-insert elements from hash part */
-  for (j = oldhsize - 1; j >= 0; j--) {
-    Node *old = nold + j;
-    if (!ttisnil(gval(old))) {
-      /* doesn't need barrier/invalidate cache, as entry was
-         already present in the table */
-      setobjt2t(L, luaH_set(L, t, gkey(old)), gval(old));
-    }
-  }
-  if (oldhsize > 0)  /* not the dummy node? */
-    luaM_freearray(L, nold, cast(size_t, oldhsize)); /* free old hash */
-}
-
-
-void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize) {
-  int nsize = allocsizenode(t);
-  luaH_resize(L, t, nasize, nsize);
-}
-
-/*
-** nums[i] = number of keys 'k' where 2^(i - 1) < k <= 2^i
-*/
-static void rehash (lua_State *L, Table *t, const TValue *ek) {
-  unsigned int asize;  /* optimal size for array part */
-  unsigned int na;  /* number of keys in the array part */
-  unsigned int nums[MAXABITS + 1];
-  int i;
-  int totaluse;
-  for (i = 0; i <= MAXABITS; i++) nums[i] = 0;  /* reset counts */
-  na = numusearray(t, nums);  /* count keys in array part */
-  totaluse = na;  /* all those keys are integer keys */
-  totaluse += numusehash(t, nums, &na);  /* count keys in hash part */
-  /* count extra key */
-  na += countint(ek, nums);
-  totaluse++;
-  /* compute new size for array part */
-  asize = computesizes(nums, &na);
-  /* resize the table to new computed sizes */
-  luaH_resize(L, t, asize, totaluse - na);
-}
-
-
-
-/*
-** }=============================================================
-*/
-
-
-Table *luaH_new (lua_State *L) {
-  GCObject *o = luaC_newobj(L, LUA_TTABLE, sizeof(Table));
-  Table *t = gco2t(o);
-  t->metatable = NULL;
-  t->flags = cast_byte(~0);
-  t->array = NULL;
-  t->sizearray = 0;
-  setnodevector(L, t, 0);
-  return t;
-}
-
-
-void luaH_free (lua_State *L, Table *t) {
-  if (!isdummy(t))
-    luaM_freearray(L, t->node, cast(size_t, sizenode(t)));
-  luaM_freearray(L, t->array, t->sizearray);
-  luaM_free(L, t);
-}
-
-
-static Node *getfreepos (Table *t) {
-  if (!isdummy(t)) {
-    while (t->lastfree > t->node) {
-      t->lastfree--;
-      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;
-  TValue aux;
-  if (ttisnil(key)) luaG_runerror(L, "table index is nil");
-  else if (ttisfloat(key)) {
-    lua_Integer k;
-    if (luaV_tointeger(key, &k, 0)) {  /* does index fit in an integer? */
-      setivalue(&aux, k);
-      key = &aux;  /* insert it as an integer */
-    }
-    else if (luai_numisnan(fltvalue(key)))
-      luaG_runerror(L, "table index is NaN");
-  }
-  mp = mainposition(t, key);
-  if (!ttisnil(gval(mp)) || isdummy(t)) {  /* main position is taken? */
-    Node *othern;
-    Node *f = getfreepos(t);  /* get a free place */
-    if (f == NULL) {  /* cannot find a free place? */
-      rehash(L, t, key);  /* grow table */
-      /* whatever called 'newkey' takes care of TM cache */
-      return luaH_set(L, t, key);  /* insert key into grown table */
-    }
-    lua_assert(!isdummy(t));
-    othern = mainposition(t, gkey(mp));
-    if (othern != mp) {  /* is colliding node out of its main position? */
-      /* yes; move colliding node into free position */
-      while (othern + gnext(othern) != mp)  /* find previous */
-        othern += gnext(othern);
-      gnext(othern) = cast_int(f - othern);  /* rechain to point to 'f' */
-      *f = *mp;  /* copy colliding node into free pos. (mp->next also goes) */
-      if (gnext(mp) != 0) {
-        gnext(f) += cast_int(mp - f);  /* correct 'next' */
-        gnext(mp) = 0;  /* now 'mp' is free */
-      }
-      setnilvalue(gval(mp));
-    }
-    else {  /* colliding node is in its own main position */
-      /* new node will go into free position */
-      if (gnext(mp) != 0)
-        gnext(f) = cast_int((mp + gnext(mp)) - f);  /* chain new position */
-      else lua_assert(gnext(f) == 0);
-      gnext(mp) = cast_int(f - mp);
-      mp = f;
-    }
-  }
-  setnodekey(L, &mp->i_key, key);
-  luaC_barrierback(L, t, key);
-  lua_assert(ttisnil(gval(mp)));
-  return gval(mp);
-}
-
-
-/*
-** search function for integers
-*/
-const TValue *luaH_getint (Table *t, lua_Integer key) {
-  /* (1 <= key && key <= t->sizearray) */
-  if (l_castS2U(key) - 1 < t->sizearray)
-    return &t->array[key - 1];
-  else {
-    Node *n = hashint(t, key);
-    for (;;) {  /* check whether 'key' is somewhere in the chain */
-      if (ttisinteger(gkey(n)) && ivalue(gkey(n)) == key)
-        return gval(n);  /* that's it */
-      else {
-        int nx = gnext(n);
-        if (nx == 0) break;
-        n += nx;
-      }
-    }
-    return luaO_nilobject;
-  }
-}
-
-
-/*
-** search function for short strings
-*/
-const TValue *luaH_getshortstr (Table *t, TString *key) {
-  Node *n = hashstr(t, key);
-  lua_assert(key->tt == LUA_TSHRSTR);
-  for (;;) {  /* check whether 'key' is somewhere in the chain */
-    const TValue *k = gkey(n);
-    if (ttisshrstring(k) && eqshrstr(tsvalue(k), key))
-      return gval(n);  /* that's it */
-    else {
-      int nx = gnext(n);
-      if (nx == 0)
-        return luaO_nilobject;  /* not found */
-      n += nx;
-    }
-  }
-}
-
-
-/*
-** "Generic" get version. (Not that generic: not valid for integers,
-** which may be in array part, nor for floats with integral values.)
-*/
-static const TValue *getgeneric (Table *t, const TValue *key) {
-  Node *n = mainposition(t, key);
-  for (;;) {  /* check whether 'key' is somewhere in the chain */
-    if (luaV_rawequalobj(gkey(n), key))
-      return gval(n);  /* that's it */
-    else {
-      int nx = gnext(n);
-      if (nx == 0)
-        return luaO_nilobject;  /* not found */
-      n += nx;
-    }
-  }
-}
-
-
-const TValue *luaH_getstr (Table *t, TString *key) {
-  if (key->tt == LUA_TSHRSTR)
-    return luaH_getshortstr(t, key);
-  else {  /* for long strings, use generic case */
-    TValue ko;
-    setsvalue(cast(lua_State *, NULL), &ko, key);
-    return getgeneric(t, &ko);
-  }
-}
-
-
-/*
-** main search function
-*/
-const TValue *luaH_get (Table *t, const TValue *key) {
-  switch (ttype(key)) {
-    case LUA_TSHRSTR: return luaH_getshortstr(t, tsvalue(key));
-    case LUA_TNUMINT: return luaH_getint(t, ivalue(key));
-    case LUA_TNIL: return luaO_nilobject;
-    case LUA_TNUMFLT: {
-      lua_Integer k;
-      if (luaV_tointeger(key, &k, 0)) /* index is int? */
-        return luaH_getint(t, k);  /* use specialized version */
-      /* else... */
-    }  /* FALLTHROUGH */
-    default:
-      return getgeneric(t, key);
-  }
-}
-
-
-/*
-** beware: when using this function you probably need to check a GC
-** barrier and invalidate the TM cache.
-*/
-TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
-  const TValue *p = luaH_get(t, key);
-  if (p != luaO_nilobject)
-    return cast(TValue *, p);
-  else return luaH_newkey(L, t, key);
-}
-
-
-void luaH_setint (lua_State *L, Table *t, lua_Integer key, TValue *value) {
-  const TValue *p = luaH_getint(t, key);
-  TValue *cell;
-  if (p != luaO_nilobject)
-    cell = cast(TValue *, p);
-  else {
-    TValue k;
-    setivalue(&k, key);
-    cell = luaH_newkey(L, t, &k);
-  }
-  setobj2t(L, cell, value);
-}
-
-
-static lua_Unsigned unbound_search (Table *t, lua_Unsigned j) {
-  lua_Unsigned 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_getint(t, j))) {
-    i = j;
-    if (j > l_castS2U(LUA_MAXINTEGER) / 2) {  /* overflow? */
-      /* table was built with bad purposes: resort to linear search */
-      i = 1;
-      while (!ttisnil(luaH_getint(t, i))) i++;
-      return i - 1;
-    }
-    j *= 2;
-  }
-  /* now do a binary search between them */
-  while (j - i > 1) {
-    lua_Unsigned m = (i+j)/2;
-    if (ttisnil(luaH_getint(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).
-*/
-lua_Unsigned 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 (isdummy(t))  /* 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 (const Table *t) { return isdummy(t); }
-
-#endif
diff --git a/lua/lua-5.3.5/src/ltable.h b/lua/lua-5.3.5/src/ltable.h
deleted file mode 100644
index 92db0ac..0000000
--- a/lua/lua-5.3.5/src/ltable.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-** $Id: ltable.h,v 2.23.1.2 2018/05/24 19:39:05 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 gval(n)		(&(n)->i_val)
-#define gnext(n)	((n)->i_key.nk.next)
-
-
-/* 'const' to avoid wrong writings that can mess up field 'next' */
-#define gkey(n)		cast(const TValue*, (&(n)->i_key.tvk))
-
-/*
-** writable version of 'gkey'; allows updates to individual fields,
-** but not to the whole (which has incompatible type)
-*/
-#define wgkey(n)		(&(n)->i_key.nk)
-
-#define invalidateTMcache(t)	((t)->flags = 0)
-
-
-/* true when 't' is using 'dummynode' as its hash part */
-#define isdummy(t)		((t)->lastfree == NULL)
-
-
-/* allocated size for hash nodes */
-#define allocsizenode(t)	(isdummy(t) ? 0 : sizenode(t))
-
-
-/* returns the key, given the value of a table entry */
-#define keyfromval(v) \
-  (gkey(cast(Node *, cast(char *, (v)) - offsetof(Node, i_val))))
-
-
-LUAI_FUNC const TValue *luaH_getint (Table *t, lua_Integer key);
-LUAI_FUNC void luaH_setint (lua_State *L, Table *t, lua_Integer key,
-                                                    TValue *value);
-LUAI_FUNC const TValue *luaH_getshortstr (Table *t, TString *key);
-LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
-LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
-LUAI_FUNC TValue *luaH_newkey (lua_State *L, 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);
-LUAI_FUNC void luaH_resize (lua_State *L, Table *t, unsigned int nasize,
-                                                    unsigned int nhsize);
-LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, unsigned 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 lua_Unsigned luaH_getn (Table *t);
-
-
-#if defined(LUA_DEBUG)
-LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key);
-LUAI_FUNC int luaH_isdummy (const Table *t);
-#endif
-
-
-#endif
diff --git a/lua/lua-5.3.5/src/ltablib.c b/lua/lua-5.3.5/src/ltablib.c
deleted file mode 100644
index c534957..0000000
--- a/lua/lua-5.3.5/src/ltablib.c
+++ /dev/null
@@ -1,450 +0,0 @@
-/*
-** $Id: ltablib.c,v 1.93.1.1 2017/04/19 17:20:42 roberto Exp $
-** Library for Table Manipulation
-** See Copyright Notice in lua.h
-*/
-
-#define ltablib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <limits.h>
-#include <stddef.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/*
-** Operations that an object must define to mimic a table
-** (some functions only need some of them)
-*/
-#define TAB_R	1			/* read */
-#define TAB_W	2			/* write */
-#define TAB_L	4			/* length */
-#define TAB_RW	(TAB_R | TAB_W)		/* read/write */
-
-
-#define aux_getn(L,n,w)	(checktab(L, n, (w) | TAB_L), luaL_len(L, n))
-
-
-static int checkfield (lua_State *L, const char *key, int n) {
-  lua_pushstring(L, key);
-  return (lua_rawget(L, -n) != LUA_TNIL);
-}
-
-
-/*
-** Check that 'arg' either is a table or can behave like one (that is,
-** has a metatable with the required metamethods)
-*/
-static void checktab (lua_State *L, int arg, int what) {
-  if (lua_type(L, arg) != LUA_TTABLE) {  /* is it not a table? */
-    int n = 1;  /* number of elements to pop */
-    if (lua_getmetatable(L, arg) &&  /* must have metatable */
-        (!(what & TAB_R) || checkfield(L, "__index", ++n)) &&
-        (!(what & TAB_W) || checkfield(L, "__newindex", ++n)) &&
-        (!(what & TAB_L) || checkfield(L, "__len", ++n))) {
-      lua_pop(L, n);  /* pop metatable and tested metamethods */
-    }
-    else
-      luaL_checktype(L, arg, LUA_TTABLE);  /* force an error */
-  }
-}
-
-
-#if defined(LUA_COMPAT_MAXN)
-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;
-}
-#endif
-
-
-static int tinsert (lua_State *L) {
-  lua_Integer e = aux_getn(L, 1, TAB_RW) + 1;  /* first empty element */
-  lua_Integer 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: {
-      lua_Integer i;
-      pos = luaL_checkinteger(L, 2);  /* 2nd argument is the position */
-      luaL_argcheck(L, 1 <= pos && pos <= e, 2, "position out of bounds");
-      for (i = e; i > pos; i--) {  /* move up elements */
-        lua_geti(L, 1, i - 1);
-        lua_seti(L, 1, i);  /* t[i] = t[i - 1] */
-      }
-      break;
-    }
-    default: {
-      return luaL_error(L, "wrong number of arguments to 'insert'");
-    }
-  }
-  lua_seti(L, 1, pos);  /* t[pos] = v */
-  return 0;
-}
-
-
-static int tremove (lua_State *L) {
-  lua_Integer size = aux_getn(L, 1, TAB_RW);
-  lua_Integer pos = luaL_optinteger(L, 2, size);
-  if (pos != size)  /* validate 'pos' if given */
-    luaL_argcheck(L, 1 <= pos && pos <= size + 1, 1, "position out of bounds");
-  lua_geti(L, 1, pos);  /* result = t[pos] */
-  for ( ; pos < size; pos++) {
-    lua_geti(L, 1, pos + 1);
-    lua_seti(L, 1, pos);  /* t[pos] = t[pos + 1] */
-  }
-  lua_pushnil(L);
-  lua_seti(L, 1, pos);  /* t[pos] = nil */
-  return 1;
-}
-
-
-/*
-** Copy elements (1[f], ..., 1[e]) into (tt[t], tt[t+1], ...). Whenever
-** possible, copy in increasing order, which is better for rehashing.
-** "possible" means destination after original range, or smaller
-** than origin, or copying to another table.
-*/
-static int tmove (lua_State *L) {
-  lua_Integer f = luaL_checkinteger(L, 2);
-  lua_Integer e = luaL_checkinteger(L, 3);
-  lua_Integer t = luaL_checkinteger(L, 4);
-  int tt = !lua_isnoneornil(L, 5) ? 5 : 1;  /* destination table */
-  checktab(L, 1, TAB_R);
-  checktab(L, tt, TAB_W);
-  if (e >= f) {  /* otherwise, nothing to move */
-    lua_Integer n, i;
-    luaL_argcheck(L, f > 0 || e < LUA_MAXINTEGER + f, 3,
-                  "too many elements to move");
-    n = e - f + 1;  /* number of elements to move */
-    luaL_argcheck(L, t <= LUA_MAXINTEGER - n + 1, 4,
-                  "destination wrap around");
-    if (t > e || t <= f || (tt != 1 && !lua_compare(L, 1, tt, LUA_OPEQ))) {
-      for (i = 0; i < n; i++) {
-        lua_geti(L, 1, f + i);
-        lua_seti(L, tt, t + i);
-      }
-    }
-    else {
-      for (i = n - 1; i >= 0; i--) {
-        lua_geti(L, 1, f + i);
-        lua_seti(L, tt, t + i);
-      }
-    }
-  }
-  lua_pushvalue(L, tt);  /* return destination table */
-  return 1;
-}
-
-
-static void addfield (lua_State *L, luaL_Buffer *b, lua_Integer i) {
-  lua_geti(L, 1, i);
-  if (!lua_isstring(L, -1))
-    luaL_error(L, "invalid value (%s) at index %d in table for 'concat'",
-                  luaL_typename(L, -1), i);
-  luaL_addvalue(b);
-}
-
-
-static int tconcat (lua_State *L) {
-  luaL_Buffer b;
-  lua_Integer last = aux_getn(L, 1, TAB_R);
-  size_t lsep;
-  const char *sep = luaL_optlstring(L, 2, "", &lsep);
-  lua_Integer i = luaL_optinteger(L, 3, 1);
-  last = luaL_optinteger(L, 4, last);
-  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;
-}
-
-
-/*
-** {======================================================
-** Pack/unpack
-** =======================================================
-*/
-
-static int pack (lua_State *L) {
-  int i;
-  int n = lua_gettop(L);  /* number of elements to pack */
-  lua_createtable(L, n, 1);  /* create result table */
-  lua_insert(L, 1);  /* put it at index 1 */
-  for (i = n; i >= 1; i--)  /* assign elements */
-    lua_seti(L, 1, i);
-  lua_pushinteger(L, n);
-  lua_setfield(L, 1, "n");  /* t.n = number of elements */
-  return 1;  /* return table */
-}
-
-
-static int unpack (lua_State *L) {
-  lua_Unsigned n;
-  lua_Integer i = luaL_optinteger(L, 2, 1);
-  lua_Integer e = luaL_opt(L, luaL_checkinteger, 3, luaL_len(L, 1));
-  if (i > e) return 0;  /* empty range */
-  n = (lua_Unsigned)e - i;  /* number of elements minus 1 (avoid overflows) */
-  if (n >= (unsigned int)INT_MAX  || !lua_checkstack(L, (int)(++n)))
-    return luaL_error(L, "too many results to unpack");
-  for (; i < e; i++) {  /* push arg[i..e - 1] (to avoid overflows) */
-    lua_geti(L, 1, i);
-  }
-  lua_geti(L, 1, e);  /* push last element */
-  return (int)n;
-}
-
-/* }====================================================== */
-
-
-
-/*
-** {======================================================
-** Quicksort
-** (based on 'Algorithms in MODULA-3', Robert Sedgewick;
-**  Addison-Wesley, 1993.)
-** =======================================================
-*/
-
-
-/* type for array indices */
-typedef unsigned int IdxT;
-
-
-/*
-** Produce a "random" 'unsigned int' to randomize pivot choice. This
-** macro is used only when 'sort' detects a big imbalance in the result
-** of a partition. (If you don't want/need this "randomness", ~0 is a
-** good choice.)
-*/
-#if !defined(l_randomizePivot)		/* { */
-
-#include <time.h>
-
-/* size of 'e' measured in number of 'unsigned int's */
-#define sof(e)		(sizeof(e) / sizeof(unsigned int))
-
-/*
-** Use 'time' and 'clock' as sources of "randomness". Because we don't
-** know the types 'clock_t' and 'time_t', we cannot cast them to
-** anything without risking overflows. A safe way to use their values
-** is to copy them to an array of a known type and use the array values.
-*/
-static unsigned int l_randomizePivot (void) {
-  clock_t c = clock();
-  time_t t = time(NULL);
-  unsigned int buff[sof(c) + sof(t)];
-  unsigned int i, rnd = 0;
-  memcpy(buff, &c, sof(c) * sizeof(unsigned int));
-  memcpy(buff + sof(c), &t, sof(t) * sizeof(unsigned int));
-  for (i = 0; i < sof(buff); i++)
-    rnd += buff[i];
-  return rnd;
-}
-
-#endif					/* } */
-
-
-/* arrays larger than 'RANLIMIT' may use randomized pivots */
-#define RANLIMIT	100u
-
-
-static void set2 (lua_State *L, IdxT i, IdxT j) {
-  lua_seti(L, 1, i);
-  lua_seti(L, 1, j);
-}
-
-
-/*
-** Return true iff value at stack index 'a' is less than the value at
-** index 'b' (according to the order of the sort).
-*/
-static int sort_comp (lua_State *L, int a, int b) {
-  if (lua_isnil(L, 2))  /* no function? */
-    return lua_compare(L, a, b, LUA_OPLT);  /* a < b */
-  else {  /* function */
-    int res;
-    lua_pushvalue(L, 2);    /* push function */
-    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);      /* call function */
-    res = lua_toboolean(L, -1);  /* get result */
-    lua_pop(L, 1);          /* pop result */
-    return res;
-  }
-}
-
-
-/*
-** Does the partition: Pivot P is at the top of the stack.
-** precondition: a[lo] <= P == a[up-1] <= a[up],
-** so it only needs to do the partition from lo + 1 to up - 2.
-** Pos-condition: a[lo .. i - 1] <= a[i] == P <= a[i + 1 .. up]
-** returns 'i'.
-*/
-static IdxT partition (lua_State *L, IdxT lo, IdxT up) {
-  IdxT i = lo;  /* will be incremented before first use */
-  IdxT j = up - 1;  /* will be decremented before first use */
-  /* loop invariant: a[lo .. i] <= P <= a[j .. up] */
-  for (;;) {
-    /* next loop: repeat ++i while a[i] < P */
-    while (lua_geti(L, 1, ++i), sort_comp(L, -1, -2)) {
-      if (i == up - 1)  /* a[i] < P  but a[up - 1] == P  ?? */
-        luaL_error(L, "invalid order function for sorting");
-      lua_pop(L, 1);  /* remove a[i] */
-    }
-    /* after the loop, a[i] >= P and a[lo .. i - 1] < P */
-    /* next loop: repeat --j while P < a[j] */
-    while (lua_geti(L, 1, --j), sort_comp(L, -3, -1)) {
-      if (j < i)  /* j < i  but  a[j] > P ?? */
-        luaL_error(L, "invalid order function for sorting");
-      lua_pop(L, 1);  /* remove a[j] */
-    }
-    /* after the loop, a[j] <= P and a[j + 1 .. up] >= P */
-    if (j < i) {  /* no elements out of place? */
-      /* a[lo .. i - 1] <= P <= a[j + 1 .. i .. up] */
-      lua_pop(L, 1);  /* pop a[j] */
-      /* swap pivot (a[up - 1]) with a[i] to satisfy pos-condition */
-      set2(L, up - 1, i);
-      return i;
-    }
-    /* otherwise, swap a[i] - a[j] to restore invariant and repeat */
-    set2(L, i, j);
-  }
-}
-
-
-/*
-** Choose an element in the middle (2nd-3th quarters) of [lo,up]
-** "randomized" by 'rnd'
-*/
-static IdxT choosePivot (IdxT lo, IdxT up, unsigned int rnd) {
-  IdxT r4 = (up - lo) / 4;  /* range/4 */
-  IdxT p = rnd % (r4 * 2) + (lo + r4);
-  lua_assert(lo + r4 <= p && p <= up - r4);
-  return p;
-}
-
-
-/*
-** QuickSort algorithm (recursive function)
-*/
-static void auxsort (lua_State *L, IdxT lo, IdxT up,
-                                   unsigned int rnd) {
-  while (lo < up) {  /* loop for tail recursion */
-    IdxT p;  /* Pivot index */
-    IdxT n;  /* to be used later */
-    /* sort elements 'lo', 'p', and 'up' */
-    lua_geti(L, 1, lo);
-    lua_geti(L, 1, up);
-    if (sort_comp(L, -1, -2))  /* a[up] < a[lo]? */
-      set2(L, lo, up);  /* swap a[lo] - a[up] */
-    else
-      lua_pop(L, 2);  /* remove both values */
-    if (up - lo == 1)  /* only 2 elements? */
-      return;  /* already sorted */
-    if (up - lo < RANLIMIT || rnd == 0)  /* small interval or no randomize? */
-      p = (lo + up)/2;  /* middle element is a good pivot */
-    else  /* for larger intervals, it is worth a random pivot */
-      p = choosePivot(lo, up, rnd);
-    lua_geti(L, 1, p);
-    lua_geti(L, 1, lo);
-    if (sort_comp(L, -2, -1))  /* a[p] < a[lo]? */
-      set2(L, p, lo);  /* swap a[p] - a[lo] */
-    else {
-      lua_pop(L, 1);  /* remove a[lo] */
-      lua_geti(L, 1, up);
-      if (sort_comp(L, -1, -2))  /* a[up] < a[p]? */
-        set2(L, p, up);  /* swap a[up] - a[p] */
-      else
-        lua_pop(L, 2);
-    }
-    if (up - lo == 2)  /* only 3 elements? */
-      return;  /* already sorted */
-    lua_geti(L, 1, p);  /* get middle element (Pivot) */
-    lua_pushvalue(L, -1);  /* push Pivot */
-    lua_geti(L, 1, up - 1);  /* push a[up - 1] */
-    set2(L, p, up - 1);  /* swap Pivot (a[p]) with a[up - 1] */
-    p = partition(L, lo, up);
-    /* a[lo .. p - 1] <= a[p] == P <= a[p + 1 .. up] */
-    if (p - lo < up - p) {  /* lower interval is smaller? */
-      auxsort(L, lo, p - 1, rnd);  /* call recursively for lower interval */
-      n = p - lo;  /* size of smaller interval */
-      lo = p + 1;  /* tail call for [p + 1 .. up] (upper interval) */
-    }
-    else {
-      auxsort(L, p + 1, up, rnd);  /* call recursively for upper interval */
-      n = up - p;  /* size of smaller interval */
-      up = p - 1;  /* tail call for [lo .. p - 1]  (lower interval) */
-    }
-    if ((up - lo) / 128 > n) /* partition too imbalanced? */
-      rnd = l_randomizePivot();  /* try a new randomization */
-  }  /* tail call auxsort(L, lo, up, rnd) */
-}
-
-
-static int sort (lua_State *L) {
-  lua_Integer n = aux_getn(L, 1, TAB_RW);
-  if (n > 1) {  /* non-trivial interval? */
-    luaL_argcheck(L, n < INT_MAX, 1, "array too big");
-    if (!lua_isnoneornil(L, 2))  /* is there a 2nd argument? */
-      luaL_checktype(L, 2, LUA_TFUNCTION);  /* must be a function */
-    lua_settop(L, 2);  /* make sure there are two arguments */
-    auxsort(L, 1, (IdxT)n, 0);
-  }
-  return 0;
-}
-
-/* }====================================================== */
-
-
-static const luaL_Reg tab_funcs[] = {
-  {"concat", tconcat},
-#if defined(LUA_COMPAT_MAXN)
-  {"maxn", maxn},
-#endif
-  {"insert", tinsert},
-  {"pack", pack},
-  {"unpack", unpack},
-  {"remove", tremove},
-  {"move", tmove},
-  {"sort", sort},
-  {NULL, NULL}
-};
-
-
-LUAMOD_API int luaopen_table (lua_State *L) {
-  luaL_newlib(L, tab_funcs);
-#if defined(LUA_COMPAT_UNPACK)
-  /* _G.unpack = table.unpack */
-  lua_getfield(L, -1, "unpack");
-  lua_setglobal(L, "unpack");
-#endif
-  return 1;
-}
-
diff --git a/lua/lua-5.3.5/src/ltm.c b/lua/lua-5.3.5/src/ltm.c
deleted file mode 100644
index 0e7c713..0000000
--- a/lua/lua-5.3.5/src/ltm.c
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
-** $Id: ltm.c,v 2.38.1.1 2017/04/19 17:39:34 roberto Exp $
-** Tag methods
-** See Copyright Notice in lua.h
-*/
-
-#define ltm_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <string.h>
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lvm.h"
-
-
-static const char udatatypename[] = "userdata";
-
-LUAI_DDEF const char *const luaT_typenames_[LUA_TOTALTAGS] = {
-  "no value",
-  "nil", "boolean", udatatypename, "number",
-  "string", "table", "function", udatatypename, "thread",
-  "proto" /* this last case is used for tests only */
-};
-
-
-void luaT_init (lua_State *L) {
-  static const char *const luaT_eventname[] = {  /* ORDER TM */
-    "__index", "__newindex",
-    "__gc", "__mode", "__len", "__eq",
-    "__add", "__sub", "__mul", "__mod", "__pow",
-    "__div", "__idiv",
-    "__band", "__bor", "__bxor", "__shl", "__shr",
-    "__unm", "__bnot", "__lt", "__le",
-    "__concat", "__call"
-  };
-  int i;
-  for (i=0; i<TM_N; i++) {
-    G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
-    luaC_fix(L, obj2gco(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_getshortstr(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 (ttnov(o)) {
-    case LUA_TTABLE:
-      mt = hvalue(o)->metatable;
-      break;
-    case LUA_TUSERDATA:
-      mt = uvalue(o)->metatable;
-      break;
-    default:
-      mt = G(L)->mt[ttnov(o)];
-  }
-  return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : luaO_nilobject);
-}
-
-
-/*
-** Return the name of the type of an object. For tables and userdata
-** with metatable, use their '__name' metafield, if present.
-*/
-const char *luaT_objtypename (lua_State *L, const TValue *o) {
-  Table *mt;
-  if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) ||
-      (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) {
-    const TValue *name = luaH_getshortstr(mt, luaS_new(L, "__name"));
-    if (ttisstring(name))  /* is '__name' a string? */
-      return getstr(tsvalue(name));  /* use it as type name */
-  }
-  return ttypename(ttnov(o));  /* else use standard type name */
-}
-
-
-void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
-                  const TValue *p2, TValue *p3, int hasres) {
-  ptrdiff_t result = savestack(L, p3);
-  StkId func = L->top;
-  setobj2s(L, func, f);  /* push function (assume EXTRA_STACK) */
-  setobj2s(L, func + 1, p1);  /* 1st argument */
-  setobj2s(L, func + 2, p2);  /* 2nd argument */
-  L->top += 3;
-  if (!hasres)  /* no result? 'p3' is third argument */
-    setobj2s(L, L->top++, p3);  /* 3rd argument */
-  /* metamethod may yield only when called from Lua code */
-  if (isLua(L->ci))
-    luaD_call(L, func, hasres);
-  else
-    luaD_callnoyield(L, func, hasres);
-  if (hasres) {  /* if has result, move it to its place */
-    p3 = restorestack(L, result);
-    setobjs2s(L, p3, --L->top);
-  }
-}
-
-
-int luaT_callbinTM (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;
-  luaT_callTM(L, tm, p1, p2, res, 1);
-  return 1;
-}
-
-
-void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
-                    StkId res, TMS event) {
-  if (!luaT_callbinTM(L, p1, p2, res, event)) {
-    switch (event) {
-      case TM_CONCAT:
-        luaG_concaterror(L, p1, p2);
-      /* call never returns, but to avoid warnings: *//* FALLTHROUGH */
-      case TM_BAND: case TM_BOR: case TM_BXOR:
-      case TM_SHL: case TM_SHR: case TM_BNOT: {
-        lua_Number dummy;
-        if (tonumber(p1, &dummy) && tonumber(p2, &dummy))
-          luaG_tointerror(L, p1, p2);
-        else
-          luaG_opinterror(L, p1, p2, "perform bitwise operation on");
-      }
-      /* calls never return, but to avoid warnings: *//* FALLTHROUGH */
-      default:
-        luaG_opinterror(L, p1, p2, "perform arithmetic on");
-    }
-  }
-}
-
-
-int luaT_callorderTM (lua_State *L, const TValue *p1, const TValue *p2,
-                      TMS event) {
-  if (!luaT_callbinTM(L, p1, p2, L->top, event))
-    return -1;  /* no metamethod */
-  else
-    return !l_isfalse(L->top);
-}
-
diff --git a/lua/lua-5.3.5/src/ltm.h b/lua/lua-5.3.5/src/ltm.h
deleted file mode 100644
index 8170688..0000000
--- a/lua/lua-5.3.5/src/ltm.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
-** $Id: ltm.h,v 2.22.1.1 2017/04/19 17:20:42 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" and "ORDER OP"
-*/
-typedef enum {
-  TM_INDEX,
-  TM_NEWINDEX,
-  TM_GC,
-  TM_MODE,
-  TM_LEN,
-  TM_EQ,  /* last tag method with fast access */
-  TM_ADD,
-  TM_SUB,
-  TM_MUL,
-  TM_MOD,
-  TM_POW,
-  TM_DIV,
-  TM_IDIV,
-  TM_BAND,
-  TM_BOR,
-  TM_BXOR,
-  TM_SHL,
-  TM_SHR,
-  TM_UNM,
-  TM_BNOT,
-  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)
-
-#define ttypename(x)	luaT_typenames_[(x) + 1]
-
-LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS];
-
-
-LUAI_FUNC const char *luaT_objtypename (lua_State *L, const TValue *o);
-
-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);
-
-LUAI_FUNC void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
-                            const TValue *p2, TValue *p3, int hasres);
-LUAI_FUNC int luaT_callbinTM (lua_State *L, const TValue *p1, const TValue *p2,
-                              StkId res, TMS event);
-LUAI_FUNC void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
-                              StkId res, TMS event);
-LUAI_FUNC int luaT_callorderTM (lua_State *L, const TValue *p1,
-                                const TValue *p2, TMS event);
-
-
-
-#endif
diff --git a/lua/lua-5.3.5/src/lua b/lua/lua-5.3.5/src/lua
deleted file mode 100644
index c18746db0a82a40c55ce94aa4f6f2ac69410f520..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 268752
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
Gz5fH#Z8<vt

diff --git a/lua/lua-5.3.5/src/lua.c b/lua/lua-5.3.5/src/lua.c
deleted file mode 100644
index ca5b298..0000000
--- a/lua/lua-5.3.5/src/lua.c
+++ /dev/null
@@ -1,612 +0,0 @@
-/*
-** $Id: lua.c,v 1.230.1.1 2017/04/19 17:29:57 roberto Exp $
-** Lua stand-alone interpreter
-** See Copyright Notice in lua.h
-*/
-
-#define lua_c
-
-#include "lprefix.h"
-
-
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-
-#if !defined(LUA_PROMPT)
-#define LUA_PROMPT		"> "
-#define LUA_PROMPT2		">> "
-#endif
-
-#if !defined(LUA_PROGNAME)
-#define LUA_PROGNAME		"lua"
-#endif
-
-#if !defined(LUA_MAXINPUT)
-#define LUA_MAXINPUT		512
-#endif
-
-#if !defined(LUA_INIT_VAR)
-#define LUA_INIT_VAR		"LUA_INIT"
-#endif
-
-#define LUA_INITVARVERSION	LUA_INIT_VAR LUA_VERSUFFIX
-
-
-/*
-** lua_stdin_is_tty detects whether the standard input is a 'tty' (that
-** is, whether we're running lua interactively).
-*/
-#if !defined(lua_stdin_is_tty)	/* { */
-
-#if defined(LUA_USE_POSIX)	/* { */
-
-#include <unistd.h>
-#define lua_stdin_is_tty()	isatty(0)
-
-#elif defined(LUA_USE_WINDOWS)	/* }{ */
-
-#include <io.h>
-#include <windows.h>
-
-#define lua_stdin_is_tty()	_isatty(_fileno(stdin))
-
-#else				/* }{ */
-
-/* ISO C definition */
-#define lua_stdin_is_tty()	1  /* assume stdin is a tty */
-
-#endif				/* } */
-
-#endif				/* } */
-
-
-/*
-** 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.
-*/
-#if !defined(lua_readline)	/* { */
-
-#if defined(LUA_USE_READLINE)	/* { */
-
-#include <readline/readline.h>
-#include <readline/history.h>
-#define lua_readline(L,b,p)	((void)L, ((b)=readline(p)) != NULL)
-#define lua_saveline(L,line)	((void)L, add_history(line))
-#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,line)	{ (void)L; (void)line; }
-#define lua_freeline(L,b)	{ (void)L; (void)b; }
-
-#endif				/* } */
-
-#endif				/* } */
-
-
-
-
-static lua_State *globalL = NULL;
-
-static const char *progname = LUA_PROGNAME;
-
-
-/*
-** Hook set by signal function to stop the interpreter.
-*/
-static void lstop (lua_State *L, lua_Debug *ar) {
-  (void)ar;  /* unused arg. */
-  lua_sethook(L, NULL, 0, 0);  /* reset hook */
-  luaL_error(L, "interrupted!");
-}
-
-
-/*
-** Function to be called at a C signal. Because a C signal cannot
-** just change a Lua state (as there is no proper synchronization),
-** this function only sets a hook that, when called, will stop the
-** interpreter.
-*/
-static void laction (int i) {
-  signal(i, SIG_DFL); /* if another SIGINT happens, terminate process */
-  lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
-}
-
-
-static void print_usage (const char *badoption) {
-  lua_writestringerror("%s: ", progname);
-  if (badoption[1] == 'e' || badoption[1] == 'l')
-    lua_writestringerror("'%s' needs argument\n", badoption);
-  else
-    lua_writestringerror("unrecognized option '%s'\n", badoption);
-  lua_writestringerror(
-  "usage: %s [options] [script [args]]\n"
-  "Available options are:\n"
-  "  -e stat  execute string 'stat'\n"
-  "  -i       enter interactive mode after executing 'script'\n"
-  "  -l name  require library 'name' into global 'name'\n"
-  "  -v       show version information\n"
-  "  -E       ignore environment variables\n"
-  "  --       stop handling options\n"
-  "  -        stop handling options and execute stdin\n"
-  ,
-  progname);
-}
-
-
-/*
-** Prints an error message, adding the program name in front of it
-** (if present)
-*/
-static void l_message (const char *pname, const char *msg) {
-  if (pname) lua_writestringerror("%s: ", pname);
-  lua_writestringerror("%s\n", msg);
-}
-
-
-/*
-** Check whether 'status' is not OK and, if so, prints the error
-** message on the top of the stack. It assumes that the error object
-** is a string, as it was either generated by Lua or by 'msghandler'.
-*/
-static int report (lua_State *L, int status) {
-  if (status != LUA_OK) {
-    const char *msg = lua_tostring(L, -1);
-    l_message(progname, msg);
-    lua_pop(L, 1);  /* remove message */
-  }
-  return status;
-}
-
-
-/*
-** Message handler used to run all chunks
-*/
-static int msghandler (lua_State *L) {
-  const char *msg = lua_tostring(L, 1);
-  if (msg == NULL) {  /* is error object not a string? */
-    if (luaL_callmeta(L, 1, "__tostring") &&  /* does it have a metamethod */
-        lua_type(L, -1) == LUA_TSTRING)  /* that produces a string? */
-      return 1;  /* that is the message */
-    else
-      msg = lua_pushfstring(L, "(error object is a %s value)",
-                               luaL_typename(L, 1));
-  }
-  luaL_traceback(L, L, msg, 1);  /* append a standard traceback */
-  return 1;  /* return the traceback */
-}
-
-
-/*
-** Interface to 'lua_pcall', which sets appropriate message function
-** and C-signal handler. Used to run all chunks.
-*/
-static int docall (lua_State *L, int narg, int nres) {
-  int status;
-  int base = lua_gettop(L) - narg;  /* function index */
-  lua_pushcfunction(L, msghandler);  /* push message handler */
-  lua_insert(L, base);  /* put it under function and args */
-  globalL = L;  /* to be available to 'laction' */
-  signal(SIGINT, laction);  /* set C-signal handler */
-  status = lua_pcall(L, narg, nres, base);
-  signal(SIGINT, SIG_DFL); /* reset C-signal handler */
-  lua_remove(L, base);  /* remove message handler from the stack */
-  return status;
-}
-
-
-static void print_version (void) {
-  lua_writestring(LUA_COPYRIGHT, strlen(LUA_COPYRIGHT));
-  lua_writeline();
-}
-
-
-/*
-** Create the 'arg' table, which stores all arguments from the
-** command line ('argv'). It should be aligned so that, at index 0,
-** it has 'argv[script]', which is the script name. The arguments
-** to the script (everything after 'script') go to positive indices;
-** other arguments (before the script name) go to negative indices.
-** If there is no script name, assume interpreter's name as base.
-*/
-static void createargtable (lua_State *L, char **argv, int argc, int script) {
-  int i, narg;
-  if (script == argc) script = 0;  /* no script name? */
-  narg = argc - (script + 1);  /* number of positive indices */
-  lua_createtable(L, narg, script + 1);
-  for (i = 0; i < argc; i++) {
-    lua_pushstring(L, argv[i]);
-    lua_rawseti(L, -2, i - script);
-  }
-  lua_setglobal(L, "arg");
-}
-
-
-static int dochunk (lua_State *L, int status) {
-  if (status == LUA_OK) status = docall(L, 0, 0);
-  return report(L, status);
-}
-
-
-static int dofile (lua_State *L, const char *name) {
-  return dochunk(L, luaL_loadfile(L, name));
-}
-
-
-static int dostring (lua_State *L, const char *s, const char *name) {
-  return dochunk(L, luaL_loadbuffer(L, s, strlen(s), name));
-}
-
-
-/*
-** Calls 'require(name)' and stores the result in a global variable
-** with the given name.
-*/
-static int dolibrary (lua_State *L, const char *name) {
-  int status;
-  lua_getglobal(L, "require");
-  lua_pushstring(L, name);
-  status = docall(L, 1, 1);  /* call 'require(name)' */
-  if (status == LUA_OK)
-    lua_setglobal(L, name);  /* global[name] = require return */
-  return report(L, status);
-}
-
-
-/*
-** Returns the string to be used as a prompt by the interpreter.
-*/
-static const char *get_prompt (lua_State *L, int firstline) {
-  const char *p;
-  lua_getglobal(L, firstline ? "_PROMPT" : "_PROMPT2");
-  p = lua_tostring(L, -1);
-  if (p == NULL) p = (firstline ? LUA_PROMPT : LUA_PROMPT2);
-  return p;
-}
-
-/* mark in error messages for incomplete statements */
-#define EOFMARK		"<eof>"
-#define marklen		(sizeof(EOFMARK)/sizeof(char) - 1)
-
-
-/*
-** Check whether 'status' signals a syntax error and the error
-** message at the top of the stack ends with the above mark for
-** incomplete statements.
-*/
-static int incomplete (lua_State *L, int status) {
-  if (status == LUA_ERRSYNTAX) {
-    size_t lmsg;
-    const char *msg = lua_tolstring(L, -1, &lmsg);
-    if (lmsg >= marklen && strcmp(msg + lmsg - marklen, EOFMARK) == 0) {
-      lua_pop(L, 1);
-      return 1;
-    }
-  }
-  return 0;  /* else... */
-}
-
-
-/*
-** Prompt the user, read a line, and push it into the Lua stack.
-*/
-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);
-  int readstatus = lua_readline(L, b, prmt);
-  if (readstatus == 0)
-    return 0;  /* no input (prompt will be popped by caller) */
-  lua_pop(L, 1);  /* remove prompt */
-  l = strlen(b);
-  if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
-    b[--l] = '\0';  /* remove it */
-  if (firstline && b[0] == '=')  /* for compatibility with 5.2, ... */
-    lua_pushfstring(L, "return %s", b + 1);  /* change '=' to 'return' */
-  else
-    lua_pushlstring(L, b, l);
-  lua_freeline(L, b);
-  return 1;
-}
-
-
-/*
-** Try to compile line on the stack as 'return <line>;'; on return, stack
-** has either compiled chunk or original line (if compilation failed).
-*/
-static int addreturn (lua_State *L) {
-  const char *line = lua_tostring(L, -1);  /* original line */
-  const char *retline = lua_pushfstring(L, "return %s;", line);
-  int status = luaL_loadbuffer(L, retline, strlen(retline), "=stdin");
-  if (status == LUA_OK) {
-    lua_remove(L, -2);  /* remove modified line */
-    if (line[0] != '\0')  /* non empty? */
-      lua_saveline(L, line);  /* keep history */
-  }
-  else
-    lua_pop(L, 2);  /* pop result from 'luaL_loadbuffer' and modified line */
-  return status;
-}
-
-
-/*
-** Read multiple lines until a complete Lua statement
-*/
-static int multiline (lua_State *L) {
-  for (;;) {  /* repeat until gets a complete statement */
-    size_t len;
-    const char *line = lua_tolstring(L, 1, &len);  /* get what it has */
-    int status = luaL_loadbuffer(L, line, len, "=stdin");  /* try it */
-    if (!incomplete(L, status) || !pushline(L, 0)) {
-      lua_saveline(L, line);  /* keep history */
-      return status;  /* cannot or should not try to add continuation line */
-    }
-    lua_pushliteral(L, "\n");  /* add newline... */
-    lua_insert(L, -2);  /* ...between the two lines */
-    lua_concat(L, 3);  /* join them */
-  }
-}
-
-
-/*
-** Read a line and try to load (compile) it first as an expression (by
-** adding "return " in front of it) and second as a statement. Return
-** the final status of load/call with the resulting function (if any)
-** in the top of the stack.
-*/
-static int loadline (lua_State *L) {
-  int status;
-  lua_settop(L, 0);
-  if (!pushline(L, 1))
-    return -1;  /* no input */
-  if ((status = addreturn(L)) != LUA_OK)  /* 'return ...' did not work? */
-    status = multiline(L);  /* try as command, maybe with continuation lines */
-  lua_remove(L, 1);  /* remove line from the stack */
-  lua_assert(lua_gettop(L) == 1);
-  return status;
-}
-
-
-/*
-** Prints (calling the Lua 'print' function) any values on the stack
-*/
-static void l_print (lua_State *L) {
-  int n = lua_gettop(L);
-  if (n > 0) {  /* any result to be printed? */
-    luaL_checkstack(L, LUA_MINSTACK, "too many results to print");
-    lua_getglobal(L, "print");
-    lua_insert(L, 1);
-    if (lua_pcall(L, n, 0, 0) != LUA_OK)
-      l_message(progname, lua_pushfstring(L, "error calling 'print' (%s)",
-                                             lua_tostring(L, -1)));
-  }
-}
-
-
-/*
-** Do the REPL: repeatedly read (load) a line, evaluate (call) it, and
-** print any results.
-*/
-static void doREPL (lua_State *L) {
-  int status;
-  const char *oldprogname = progname;
-  progname = NULL;  /* no 'progname' on errors in interactive mode */
-  while ((status = loadline(L)) != -1) {
-    if (status == LUA_OK)
-      status = docall(L, 0, LUA_MULTRET);
-    if (status == LUA_OK) l_print(L);
-    else report(L, status);
-  }
-  lua_settop(L, 0);  /* clear stack */
-  lua_writeline();
-  progname = oldprogname;
-}
-
-
-/*
-** Push on the stack the contents of table 'arg' from 1 to #arg
-*/
-static int pushargs (lua_State *L) {
-  int i, n;
-  if (lua_getglobal(L, "arg") != LUA_TTABLE)
-    luaL_error(L, "'arg' is not a table");
-  n = (int)luaL_len(L, -1);
-  luaL_checkstack(L, n + 3, "too many arguments to script");
-  for (i = 1; i <= n; i++)
-    lua_rawgeti(L, -i, i);
-  lua_remove(L, -i);  /* remove table from the stack */
-  return n;
-}
-
-
-static int handle_script (lua_State *L, char **argv) {
-  int status;
-  const char *fname = argv[0];
-  if (strcmp(fname, "-") == 0 && strcmp(argv[-1], "--") != 0)
-    fname = NULL;  /* stdin */
-  status = luaL_loadfile(L, fname);
-  if (status == LUA_OK) {
-    int n = pushargs(L);  /* push arguments to script */
-    status = docall(L, n, LUA_MULTRET);
-  }
-  return report(L, status);
-}
-
-
-
-/* bits of various argument indicators in 'args' */
-#define has_error	1	/* bad option */
-#define has_i		2	/* -i */
-#define has_v		4	/* -v */
-#define has_e		8	/* -e */
-#define has_E		16	/* -E */
-
-/*
-** Traverses all arguments from 'argv', returning a mask with those
-** needed before running any Lua code (or an error code if it finds
-** any invalid argument). 'first' returns the first not-handled argument
-** (either the script name or a bad argument in case of error).
-*/
-static int collectargs (char **argv, int *first) {
-  int args = 0;
-  int i;
-  for (i = 1; argv[i] != NULL; i++) {
-    *first = i;
-    if (argv[i][0] != '-')  /* not an option? */
-        return args;  /* stop handling options */
-    switch (argv[i][1]) {  /* else check option */
-      case '-':  /* '--' */
-        if (argv[i][2] != '\0')  /* extra characters after '--'? */
-          return has_error;  /* invalid option */
-        *first = i + 1;
-        return args;
-      case '\0':  /* '-' */
-        return args;  /* script "name" is '-' */
-      case 'E':
-        if (argv[i][2] != '\0')  /* extra characters after 1st? */
-          return has_error;  /* invalid option */
-        args |= has_E;
-        break;
-      case 'i':
-        args |= has_i;  /* (-i implies -v) *//* FALLTHROUGH */
-      case 'v':
-        if (argv[i][2] != '\0')  /* extra characters after 1st? */
-          return has_error;  /* invalid option */
-        args |= has_v;
-        break;
-      case 'e':
-        args |= has_e;  /* FALLTHROUGH */
-      case 'l':  /* both options need an argument */
-        if (argv[i][2] == '\0') {  /* no concatenated argument? */
-          i++;  /* try next 'argv' */
-          if (argv[i] == NULL || argv[i][0] == '-')
-            return has_error;  /* no next argument or it is another option */
-        }
-        break;
-      default:  /* invalid option */
-        return has_error;
-    }
-  }
-  *first = i;  /* no script name */
-  return args;
-}
-
-
-/*
-** Processes options 'e' and 'l', which involve running Lua code.
-** Returns 0 if some code raises an error.
-*/
-static int runargs (lua_State *L, char **argv, int n) {
-  int i;
-  for (i = 1; i < n; i++) {
-    int option = argv[i][1];
-    lua_assert(argv[i][0] == '-');  /* already checked */
-    if (option == 'e' || option == 'l') {
-      int status;
-      const char *extra = argv[i] + 2;  /* both options need an argument */
-      if (*extra == '\0') extra = argv[++i];
-      lua_assert(extra != NULL);
-      status = (option == 'e')
-               ? dostring(L, extra, "=(command line)")
-               : dolibrary(L, extra);
-      if (status != LUA_OK) return 0;
-    }
-  }
-  return 1;
-}
-
-
-
-static int handle_luainit (lua_State *L) {
-  const char *name = "=" LUA_INITVARVERSION;
-  const char *init = getenv(name + 1);
-  if (init == NULL) {
-    name = "=" LUA_INIT_VAR;
-    init = getenv(name + 1);  /* try alternative name */
-  }
-  if (init == NULL) return LUA_OK;
-  else if (init[0] == '@')
-    return dofile(L, init+1);
-  else
-    return dostring(L, init, name);
-}
-
-
-/*
-** Main body of stand-alone interpreter (to be called in protected mode).
-** Reads the options and handles them all.
-*/
-static int pmain (lua_State *L) {
-  int argc = (int)lua_tointeger(L, 1);
-  char **argv = (char **)lua_touserdata(L, 2);
-  int script;
-  int args = collectargs(argv, &script);
-  luaL_checkversion(L);  /* check that interpreter has correct version */
-  if (argv[0] && argv[0][0]) progname = argv[0];
-  if (args == has_error) {  /* bad arg? */
-    print_usage(argv[script]);  /* 'script' has index of bad arg. */
-    return 0;
-  }
-  if (args & has_v)  /* option '-v'? */
-    print_version();
-  if (args & has_E) {  /* option '-E'? */
-    lua_pushboolean(L, 1);  /* signal for libraries to ignore env. vars. */
-    lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
-  }
-  luaL_openlibs(L);  /* open standard libraries */
-  createargtable(L, argv, argc, script);  /* create table 'arg' */
-  if (!(args & has_E)) {  /* no option '-E'? */
-    if (handle_luainit(L) != LUA_OK)  /* run LUA_INIT */
-      return 0;  /* error running LUA_INIT */
-  }
-  if (!runargs(L, argv, script))  /* execute arguments -e and -l */
-    return 0;  /* something failed */
-  if (script < argc &&  /* execute main script (if there is one) */
-      handle_script(L, argv + script) != LUA_OK)
-    return 0;
-  if (args & has_i)  /* -i option? */
-    doREPL(L);  /* do read-eval-print loop */
-  else if (script == argc && !(args & (has_e | has_v))) {  /* no arguments? */
-    if (lua_stdin_is_tty()) {  /* running in interactive mode? */
-      print_version();
-      doREPL(L);  /* do read-eval-print loop */
-    }
-    else dofile(L, NULL);  /* executes stdin as a file */
-  }
-  lua_pushboolean(L, 1);  /* signal no errors */
-  return 1;
-}
-
-
-int main (int argc, char **argv) {
-  int status, result;
-  lua_State *L = luaL_newstate();  /* create state */
-  if (L == NULL) {
-    l_message(argv[0], "cannot create state: not enough memory");
-    return EXIT_FAILURE;
-  }
-  lua_pushcfunction(L, &pmain);  /* to call 'pmain' in protected mode */
-  lua_pushinteger(L, argc);  /* 1st argument */
-  lua_pushlightuserdata(L, argv); /* 2nd argument */
-  status = lua_pcall(L, 2, 1, 0);  /* do the call */
-  result = lua_toboolean(L, -1);  /* get result */
-  report(L, status);
-  lua_close(L);
-  return (result && status == LUA_OK) ? EXIT_SUCCESS : EXIT_FAILURE;
-}
-
diff --git a/lua/lua-5.3.5/src/lua.h b/lua/lua-5.3.5/src/lua.h
deleted file mode 100644
index c236e36..0000000
--- a/lua/lua-5.3.5/src/lua.h
+++ /dev/null
@@ -1,486 +0,0 @@
-/*
-** $Id: lua.h,v 1.332.1.2 2018/06/13 16:58:17 roberto Exp $
-** Lua - A Scripting 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_MAJOR	"5"
-#define LUA_VERSION_MINOR	"3"
-#define LUA_VERSION_NUM		503
-#define LUA_VERSION_RELEASE	"5"
-
-#define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
-#define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
-#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2018 Lua.org, PUC-Rio"
-#define LUA_AUTHORS	"R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
-
-
-/* mark for precompiled code ('<esc>Lua') */
-#define LUA_SIGNATURE	"\x1bLua"
-
-/* option for multiple returns in 'lua_pcall' and 'lua_call' */
-#define LUA_MULTRET	(-1)
-
-
-/*
-** Pseudo-indices
-** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty
-** space after that to help overflow detection)
-*/
-#define LUA_REGISTRYINDEX	(-LUAI_MAXSTACK - 1000)
-#define lua_upvalueindex(i)	(LUA_REGISTRYINDEX - (i))
-
-
-/* thread status */
-#define LUA_OK		0
-#define LUA_YIELD	1
-#define LUA_ERRRUN	2
-#define LUA_ERRSYNTAX	3
-#define LUA_ERRMEM	4
-#define LUA_ERRGCMM	5
-#define LUA_ERRERR	6
-
-
-typedef struct lua_State lua_State;
-
-
-/*
-** 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
-
-#define LUA_NUMTAGS		9
-
-
-
-/* minimum Lua stack available to a C function */
-#define LUA_MINSTACK	20
-
-
-/* predefined values in the registry */
-#define LUA_RIDX_MAINTHREAD	1
-#define LUA_RIDX_GLOBALS	2
-#define LUA_RIDX_LAST		LUA_RIDX_GLOBALS
-
-
-/* type of numbers in Lua */
-typedef LUA_NUMBER lua_Number;
-
-
-/* type for integer functions */
-typedef LUA_INTEGER lua_Integer;
-
-/* unsigned integer type */
-typedef LUA_UNSIGNED lua_Unsigned;
-
-/* type for continuation-function contexts */
-typedef LUA_KCONTEXT lua_KContext;
-
-
-/*
-** Type for C functions registered with Lua
-*/
-typedef int (*lua_CFunction) (lua_State *L);
-
-/*
-** Type for continuation functions
-*/
-typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);
-
-
-/*
-** Type for 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);
-
-
-/*
-** Type for memory-allocation functions
-*/
-typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
-
-
-
-/*
-** generic extra include file
-*/
-#if defined(LUA_USER_H)
-#include LUA_USER_H
-#endif
-
-
-/*
-** RCS ident string
-*/
-extern const char lua_ident[];
-
-
-/*
-** 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);
-
-
-LUA_API const lua_Number *(lua_version) (lua_State *L);
-
-
-/*
-** basic stack manipulation
-*/
-LUA_API int   (lua_absindex) (lua_State *L, int idx);
-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_rotate) (lua_State *L, int idx, int n);
-LUA_API void  (lua_copy) (lua_State *L, int fromidx, int toidx);
-LUA_API int   (lua_checkstack) (lua_State *L, int n);
-
-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_isinteger) (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 lua_Number      (lua_tonumberx) (lua_State *L, int idx, int *isnum);
-LUA_API lua_Integer     (lua_tointegerx) (lua_State *L, int idx, int *isnum);
-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_rawlen) (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);
-
-
-/*
-** Comparison and arithmetic functions
-*/
-
-#define LUA_OPADD	0	/* ORDER TM, ORDER OP */
-#define LUA_OPSUB	1
-#define LUA_OPMUL	2
-#define LUA_OPMOD	3
-#define LUA_OPPOW	4
-#define LUA_OPDIV	5
-#define LUA_OPIDIV	6
-#define LUA_OPBAND	7
-#define LUA_OPBOR	8
-#define LUA_OPBXOR	9
-#define LUA_OPSHL	10
-#define LUA_OPSHR	11
-#define LUA_OPUNM	12
-#define LUA_OPBNOT	13
-
-LUA_API void  (lua_arith) (lua_State *L, int op);
-
-#define LUA_OPEQ	0
-#define LUA_OPLT	1
-#define LUA_OPLE	2
-
-LUA_API int   (lua_rawequal) (lua_State *L, int idx1, int idx2);
-LUA_API int   (lua_compare) (lua_State *L, int idx1, int idx2, int op);
-
-
-/*
-** 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 const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len);
-LUA_API const char *(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 int (lua_getglobal) (lua_State *L, const char *name);
-LUA_API int (lua_gettable) (lua_State *L, int idx);
-LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k);
-LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n);
-LUA_API int (lua_rawget) (lua_State *L, int idx);
-LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
-LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p);
-
-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 int  (lua_getuservalue) (lua_State *L, int idx);
-
-
-/*
-** set functions (stack -> Lua)
-*/
-LUA_API void  (lua_setglobal) (lua_State *L, const char *name);
-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_seti) (lua_State *L, int idx, lua_Integer n);
-LUA_API void  (lua_rawset) (lua_State *L, int idx);
-LUA_API void  (lua_rawseti) (lua_State *L, int idx, lua_Integer n);
-LUA_API void  (lua_rawsetp) (lua_State *L, int idx, const void *p);
-LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
-LUA_API void  (lua_setuservalue) (lua_State *L, int idx);
-
-
-/*
-** 'load' and 'call' functions (load and run Lua code)
-*/
-LUA_API void  (lua_callk) (lua_State *L, int nargs, int nresults,
-                           lua_KContext ctx, lua_KFunction k);
-#define lua_call(L,n,r)		lua_callk(L, (n), (r), 0, NULL)
-
-LUA_API int   (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
-                            lua_KContext ctx, lua_KFunction k);
-#define lua_pcall(L,n,r,f)	lua_pcallk(L, (n), (r), (f), 0, NULL)
-
-LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
-                          const char *chunkname, const char *mode);
-
-LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);
-
-
-/*
-** coroutine functions
-*/
-LUA_API int  (lua_yieldk)     (lua_State *L, int nresults, lua_KContext ctx,
-                               lua_KFunction k);
-LUA_API int  (lua_resume)     (lua_State *L, lua_State *from, int narg);
-LUA_API int  (lua_status)     (lua_State *L);
-LUA_API int (lua_isyieldable) (lua_State *L);
-
-#define lua_yield(L,n)		lua_yieldk(L, (n), 0, NULL)
-
-
-/*
-** 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
-#define LUA_GCISRUNNING		9
-
-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 void  (lua_len)    (lua_State *L, int idx);
-
-LUA_API size_t   (lua_stringtonumber) (lua_State *L, const char *s);
-
-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_getextraspace(L)	((void *)((char *)(L) - LUA_EXTRASPACE))
-
-#define lua_tonumber(L,i)	lua_tonumberx(L,(i),NULL)
-#define lua_tointeger(L,i)	lua_tointegerx(L,(i),NULL)
-
-#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_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_pushstring(L, "" s)
-
-#define lua_pushglobaltable(L)  \
-	((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS))
-
-#define lua_tostring(L,i)	lua_tolstring(L, (i), NULL)
-
-
-#define lua_insert(L,idx)	lua_rotate(L, (idx), 1)
-
-#define lua_remove(L,idx)	(lua_rotate(L, (idx), -1), lua_pop(L, 1))
-
-#define lua_replace(L,idx)	(lua_copy(L, -1, (idx)), lua_pop(L, 1))
-
-/* }============================================================== */
-
-
-/*
-** {==============================================================
-** compatibility macros for unsigned conversions
-** ===============================================================
-*/
-#if defined(LUA_COMPAT_APIINTCASTS)
-
-#define lua_pushunsigned(L,n)	lua_pushinteger(L, (lua_Integer)(n))
-#define lua_tounsignedx(L,i,is)	((lua_Unsigned)lua_tointegerx(L,i,is))
-#define lua_tounsigned(L,i)	lua_tounsignedx(L,(i),NULL)
-
-#endif
-/* }============================================================== */
-
-/*
-** {======================================================================
-** Debug API
-** =======================================================================
-*/
-
-
-/*
-** Event codes
-*/
-#define LUA_HOOKCALL	0
-#define LUA_HOOKRET	1
-#define LUA_HOOKLINE	2
-#define LUA_HOOKCOUNT	3
-#define LUA_HOOKTAILCALL 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 debugger 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 void *(lua_upvalueid) (lua_State *L, int fidx, int n);
-LUA_API void  (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
-                                               int fidx2, int n2);
-
-LUA_API void (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 linedefined;	/* (S) */
-  int lastlinedefined;	/* (S) */
-  unsigned char nups;	/* (u) number of upvalues */
-  unsigned char nparams;/* (u) number of parameters */
-  char isvararg;        /* (u) */
-  char istailcall;	/* (t) */
-  char short_src[LUA_IDSIZE]; /* (S) */
-  /* private part */
-  struct CallInfo *i_ci;  /* active function */
-};
-
-/* }====================================================================== */
-
-
-/******************************************************************************
-* Copyright (C) 1994-2018 Lua.org, PUC-Rio.
-*
-* Permission is hereby granted, free of charge, to any person obtaining
-* a copy of this software and associated documentation files (the
-* "Software"), to deal in the Software without restriction, including
-* without limitation the rights to use, copy, modify, merge, publish,
-* distribute, sublicense, and/or sell copies of the Software, and to
-* permit persons to whom the Software is furnished to do so, subject to
-* the following conditions:
-*
-* The above copyright notice and this permission notice shall be
-* included in all copies or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-******************************************************************************/
-
-
-#endif
diff --git a/lua/lua-5.3.5/src/lua.hpp b/lua/lua-5.3.5/src/lua.hpp
deleted file mode 100644
index ec417f5..0000000
--- a/lua/lua-5.3.5/src/lua.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// lua.hpp
-// Lua header files for C++
-// <<extern "C">> not supplied automatically because Lua also compiles as C++
-
-extern "C" {
-#include "lua.h"
-#include "lualib.h"
-#include "lauxlib.h"
-}
diff --git a/lua/lua-5.3.5/src/luac b/lua/lua-5.3.5/src/luac
deleted file mode 100644
index f43ccaafd9bbc9b02941d1121796ee5bafb5a0ee..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 175208
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
G{Qm>UC%ZNP

diff --git a/lua/lua-5.3.5/src/luac.c b/lua/lua-5.3.5/src/luac.c
deleted file mode 100644
index 549ad39..0000000
--- a/lua/lua-5.3.5/src/luac.c
+++ /dev/null
@@ -1,450 +0,0 @@
-/*
-** $Id: luac.c,v 1.76 2018/06/19 01:32:02 lhf Exp $
-** Lua compiler (saves bytecodes to files; also lists bytecodes)
-** See Copyright Notice in lua.h
-*/
-
-#define luac_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-#include <ctype.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-#include "lauxlib.h"
-
-#include "lobject.h"
-#include "lstate.h"
-#include "lundump.h"
-
-static void PrintFunction(const Proto* f, int full);
-#define luaU_print	PrintFunction
-
-#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 '%s'\n",progname,message);
- else
-  fprintf(stderr,"%s: %s\n",progname,message);
- fprintf(stderr,
-  "usage: %s [options] [filenames]\n"
-  "Available options are:\n"
-  "  -l       list (use -l -l for full listing)\n"
-  "  -o name  output to file 'name' (default is \"%s\")\n"
-  "  -p       parse only\n"
-  "  -s       strip debug information\n"
-  "  -v       show version information\n"
-  "  --       stop handling options\n"
-  "  -        stop handling options and process stdin\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 || (*output=='-' && output[1]!=0))
-    usage("'-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\n",LUA_COPYRIGHT);
-  if (version==argc-1) exit(EXIT_SUCCESS);
- }
- return i;
-}
-
-#define FUNCTION "(function()end)();"
-
-static const char* reader(lua_State *L, void *ud, size_t *size)
-{
- UNUSED(L);
- if ((*(int*)ud)--)
- {
-  *size=sizeof(FUNCTION)-1;
-  return FUNCTION;
- }
- else
- {
-  *size=0;
-  return NULL;
- }
-}
-
-#define toproto(L,i) getproto(L->top+(i))
-
-static const Proto* combine(lua_State* L, int n)
-{
- if (n==1)
-  return toproto(L,-1);
- else
- {
-  Proto* f;
-  int i=n;
-  if (lua_load(L,reader,&i,"=(" PROGNAME ")",NULL)!=LUA_OK) fatal(lua_tostring(L,-1));
-  f=toproto(L,-1);
-  for (i=0; i<n; i++)
-  {
-   f->p[i]=toproto(L,i-n-1);
-   if (f->p[i]->sizeupvalues>0) f->p[i]->upvalues[0].instack=0;
-  }
-  f->sizelineinfo=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);
-}
-
-static int pmain(lua_State* L)
-{
- int argc=(int)lua_tointeger(L,1);
- char** argv=(char**)lua_touserdata(L,2);
- 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)!=LUA_OK) 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;
- int i=doargs(argc,argv);
- argc-=i; argv+=i;
- if (argc<=0) usage("no input files given");
- L=luaL_newstate();
- if (L==NULL) fatal("cannot create state: not enough memory");
- lua_pushcfunction(L,&pmain);
- lua_pushinteger(L,argc);
- lua_pushlightuserdata(L,argv);
- if (lua_pcall(L,2,0,0)!=LUA_OK) fatal(lua_tostring(L,-1));
- lua_close(L);
- return EXIT_SUCCESS;
-}
-
-/*
-** $Id: luac.c,v 1.76 2018/06/19 01:32:02 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"
-
-#define VOID(p)		((const void*)(p))
-
-static void PrintString(const TString* ts)
-{
- const char* s=getstr(ts);
- size_t i,n=tsslen(ts);
- printf("%c",'"');
- for (i=0; i<n; i++)
- {
-  int c=(int)(unsigned char)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(c))
-   			printf("%c",c);
-		else
-			printf("\\%03d",c);
-  }
- }
- printf("%c",'"');
-}
-
-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_TNUMFLT:
-	{
-	char buff[100];
-	sprintf(buff,LUA_NUMBER_FMT,fltvalue(o));
-	printf("%s",buff);
-	if (buff[strspn(buff,"-0123456789")]=='\0') printf(".0");
-	break;
-	}
-  case LUA_TNUMINT:
-	printf(LUA_INTEGER_FMT,ivalue(o));
-	break;
-  case LUA_TSHRSTR: case LUA_TLNGSTR:
-	PrintString(tsvalue(o));
-	break;
-  default:				/* cannot happen */
-	printf("? type=%d",ttype(o));
-	break;
- }
-}
-
-#define UPVALNAME(x) ((f->upvalues[x].name) ? getstr(f->upvalues[x].name) : "-")
-#define MYK(x)		(-1-(x))
-
-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 ax=GETARG_Ax(i);
-  int bx=GETARG_Bx(i);
-  int sbx=GETARG_sBx(i);
-  int line=getfuncline(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) ? (MYK(INDEXK(b))) : b);
-    if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (MYK(INDEXK(c))) : c);
-    break;
-   case iABx:
-    printf("%d",a);
-    if (getBMode(o)==OpArgK) printf(" %d",MYK(bx));
-    if (getBMode(o)==OpArgU) printf(" %d",bx);
-    break;
-   case iAsBx:
-    printf("%d %d",a,sbx);
-    break;
-   case iAx:
-    printf("%d",MYK(ax));
-    break;
-  }
-  switch (o)
-  {
-   case OP_LOADK:
-    printf("\t; "); PrintConstant(f,bx);
-    break;
-   case OP_GETUPVAL:
-   case OP_SETUPVAL:
-    printf("\t; %s",UPVALNAME(b));
-    break;
-   case OP_GETTABUP:
-    printf("\t; %s",UPVALNAME(b));
-    if (ISK(c)) { printf(" "); PrintConstant(f,INDEXK(c)); }
-    break;
-   case OP_SETTABUP:
-    printf("\t; %s",UPVALNAME(a));
-    if (ISK(b)) { printf(" "); PrintConstant(f,INDEXK(b)); }
-    if (ISK(c)) { printf(" "); PrintConstant(f,INDEXK(c)); }
-    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_MOD:
-   case OP_POW:
-   case OP_DIV:
-   case OP_IDIV:
-   case OP_BAND:
-   case OP_BOR:
-   case OP_BXOR:
-   case OP_SHL:
-   case OP_SHR:
-   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:
-   case OP_TFORLOOP:
-    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;
-   case OP_EXTRAARG:
-    printf("\t; "); PrintConstant(f,ax);
-    break;
-   default:
-    break;
-  }
-  printf("\n");
- }
-}
-
-#define SS(x)	((x==1)?"":"s")
-#define S(x)	(int)(x),SS(x)
-
-static void PrintHeader(const Proto* f)
-{
- const char* s=f->source ? 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 at %p)\n",
- 	(f->linedefined==0)?"main":"function",s,
-	f->linedefined,f->lastlinedefined,
-	S(f->sizecode),VOID(f));
- printf("%d%s param%s, %d slot%s, %d upvalue%s, ",
-	(int)(f->numparams),f->is_vararg?"+":"",SS(f->numparams),
-	S(f->maxstacksize),S(f->sizeupvalues));
- printf("%d local%s, %d constant%s, %d function%s\n",
-	S(f->sizelocvars),S(f->sizek),S(f->sizep));
-}
-
-static void PrintDebug(const Proto* f)
-{
- int i,n;
- 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");
- }
- 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);
- }
- n=f->sizeupvalues;
- printf("upvalues (%d) for %p:\n",n,VOID(f));
- for (i=0; i<n; i++)
- {
-  printf("\t%d\t%s\t%d\t%d\n",
-  i,UPVALNAME(i),f->upvalues[i].instack,f->upvalues[i].idx);
- }
-}
-
-static void PrintFunction(const Proto* f, int full)
-{
- int i,n=f->sizep;
- PrintHeader(f);
- PrintCode(f);
- if (full) PrintDebug(f);
- for (i=0; i<n; i++) PrintFunction(f->p[i],full);
-}
diff --git a/lua/lua-5.3.5/src/luaconf.h b/lua/lua-5.3.5/src/luaconf.h
deleted file mode 100644
index 9eeeea6..0000000
--- a/lua/lua-5.3.5/src/luaconf.h
+++ /dev/null
@@ -1,790 +0,0 @@
-/*
-** $Id: luaconf.h,v 1.259.1.1 2017/04/19 17:29:57 roberto Exp $
-** Configuration file for Lua
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef luaconf_h
-#define luaconf_h
-
-#include <limits.h>
-#include <stddef.h>
-
-
-/*
-** ===================================================================
-** Search for "@@" to find all configurable definitions.
-** ===================================================================
-*/
-
-
-/*
-** {====================================================================
-** System Configuration: macros to adapt (if needed) Lua to some
-** particular platform, for instance compiling it with 32-bit numbers or
-** restricting it to C89.
-** =====================================================================
-*/
-
-/*
-@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats. You
-** can also define LUA_32BITS in the make file, but changing here you
-** ensure that all software connected to Lua will be compiled with the
-** same configuration.
-*/
-/* #define LUA_32BITS */
-
-
-/*
-@@ LUA_USE_C89 controls the use of non-ISO-C89 features.
-** Define it if you want Lua to avoid the use of a few C99 features
-** or Windows-specific features on Windows.
-*/
-/* #define LUA_USE_C89 */
-
-
-/*
-** By default, Lua on Windows use (some) specific Windows features
-*/
-#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE)
-#define LUA_USE_WINDOWS  /* enable goodies for regular Windows */
-#endif
-
-
-#if defined(LUA_USE_WINDOWS)
-#define LUA_DL_DLL	/* enable support for DLL */
-#define LUA_USE_C89	/* broadly, Windows is C89 */
-#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_USE_DLOPEN		/* MacOS does not need -ldl */
-#define LUA_USE_READLINE	/* needs an extra library: -lreadline */
-#endif
-
-
-/*
-@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for
-** C89 ('long' and 'double'); Windows always has '__int64', so it does
-** not need to use this case.
-*/
-#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS)
-#define LUA_C89_NUMBERS
-#endif
-
-
-
-/*
-@@ LUAI_BITSINT defines the (minimum) number of bits in an 'int'.
-*/
-/* avoid undefined shifts */
-#if ((INT_MAX >> 15) >> 15) >= 1
-#define LUAI_BITSINT	32
-#else
-/* 'int' always must have at least 16 bits */
-#define LUAI_BITSINT	16
-#endif
-
-
-/*
-@@ LUA_INT_TYPE defines the type for Lua integers.
-@@ LUA_FLOAT_TYPE defines the type for Lua floats.
-** Lua should work fine with any mix of these options (if supported
-** by your C compiler). The usual configurations are 64-bit integers
-** and 'double' (the default), 32-bit integers and 'float' (for
-** restricted platforms), and 'long'/'double' (for C compilers not
-** compliant with C99, which may not have support for 'long long').
-*/
-
-/* predefined options for LUA_INT_TYPE */
-#define LUA_INT_INT		1
-#define LUA_INT_LONG		2
-#define LUA_INT_LONGLONG	3
-
-/* predefined options for LUA_FLOAT_TYPE */
-#define LUA_FLOAT_FLOAT		1
-#define LUA_FLOAT_DOUBLE	2
-#define LUA_FLOAT_LONGDOUBLE	3
-
-#if defined(LUA_32BITS)		/* { */
-/*
-** 32-bit integers and 'float'
-*/
-#if LUAI_BITSINT >= 32  /* use 'int' if big enough */
-#define LUA_INT_TYPE	LUA_INT_INT
-#else  /* otherwise use 'long' */
-#define LUA_INT_TYPE	LUA_INT_LONG
-#endif
-#define LUA_FLOAT_TYPE	LUA_FLOAT_FLOAT
-
-#elif defined(LUA_C89_NUMBERS)	/* }{ */
-/*
-** largest types available for C89 ('long' and 'double')
-*/
-#define LUA_INT_TYPE	LUA_INT_LONG
-#define LUA_FLOAT_TYPE	LUA_FLOAT_DOUBLE
-
-#endif				/* } */
-
-
-/*
-** default configuration for 64-bit Lua ('long long' and 'double')
-*/
-#if !defined(LUA_INT_TYPE)
-#define LUA_INT_TYPE	LUA_INT_LONGLONG
-#endif
-
-#if !defined(LUA_FLOAT_TYPE)
-#define LUA_FLOAT_TYPE	LUA_FLOAT_DOUBLE
-#endif
-
-/* }================================================================== */
-
-
-
-
-/*
-** {==================================================================
-** Configuration for Paths.
-** ===================================================================
-*/
-
-/*
-** LUA_PATH_SEP is the character that separates templates in a path.
-** LUA_PATH_MARK is the string that marks the substitution points in a
-** template.
-** LUA_EXEC_DIR in a Windows path is replaced by the executable's
-** directory.
-*/
-#define LUA_PATH_SEP            ";"
-#define LUA_PATH_MARK           "?"
-#define LUA_EXEC_DIR            "!"
-
-
-/*
-@@ 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.
-*/
-#define LUA_VDIR	LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
-#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_SHRDIR	"!\\..\\share\\lua\\" LUA_VDIR "\\"
-#define LUA_PATH_DEFAULT  \
-		LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
-		LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" \
-		LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \
-		".\\?.lua;" ".\\?\\init.lua"
-#define LUA_CPATH_DEFAULT \
-		LUA_CDIR"?.dll;" \
-		LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \
-		LUA_CDIR"loadall.dll;" ".\\?.dll"
-
-#else			/* }{ */
-
-#define LUA_ROOT	"/usr/local/"
-#define LUA_LDIR	LUA_ROOT "share/lua/" LUA_VDIR "/"
-#define LUA_CDIR	LUA_ROOT "lib/lua/" LUA_VDIR "/"
-#define LUA_PATH_DEFAULT  \
-		LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
-		LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua;" \
-		"./?.lua;" "./?/init.lua"
-#define LUA_CPATH_DEFAULT \
-		LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.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
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Marks for exported symbols in the C code
-** ===================================================================
-*/
-
-/*
-@@ LUA_API is a mark for all core API functions.
-@@ LUALIB_API is a mark for all auxiliary library functions.
-@@ LUAMOD_API is a mark for all standard library opening 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
-#define LUAMOD_API	LUALIB_API
-
-
-/*
-@@ LUAI_FUNC is a mark for all extern functions that are not to be
-** exported to outside modules.
-@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables
-** that are not to be exported to outside modules (LUAI_DDEF for
-** definitions and LUAI_DDEC for declarations).
-** 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. Not all elf targets support
-** this attribute. Unfortunately, gcc does not offer a way to check
-** whether the target offers that support, and those without support
-** give a warning about it. To avoid these warnings, change to the
-** default definition.
-*/
-#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
-    defined(__ELF__)		/* { */
-#define LUAI_FUNC	__attribute__((visibility("hidden"))) extern
-#else				/* }{ */
-#define LUAI_FUNC	extern
-#endif				/* } */
-
-#define LUAI_DDEC	LUAI_FUNC
-#define LUAI_DDEF	/* empty */
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Compatibility with previous versions
-** ===================================================================
-*/
-
-/*
-@@ LUA_COMPAT_5_2 controls other macros for compatibility with Lua 5.2.
-@@ LUA_COMPAT_5_1 controls other macros for compatibility with Lua 5.1.
-** You can define it to get all options, or change specific options
-** to fit your specific needs.
-*/
-#if defined(LUA_COMPAT_5_2)	/* { */
-
-/*
-@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated
-** functions in the mathematical library.
-*/
-#define LUA_COMPAT_MATHLIB
-
-/*
-@@ LUA_COMPAT_BITLIB controls the presence of library 'bit32'.
-*/
-#define LUA_COMPAT_BITLIB
-
-/*
-@@ LUA_COMPAT_IPAIRS controls the effectiveness of the __ipairs metamethod.
-*/
-#define LUA_COMPAT_IPAIRS
-
-/*
-@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for
-** manipulating other integer types (lua_pushunsigned, lua_tounsigned,
-** luaL_checkint, luaL_checklong, etc.)
-*/
-#define LUA_COMPAT_APIINTCASTS
-
-#endif				/* } */
-
-
-#if defined(LUA_COMPAT_5_1)	/* { */
-
-/* Incompatibilities from 5.2 -> 5.3 */
-#define LUA_COMPAT_MATHLIB
-#define LUA_COMPAT_APIINTCASTS
-
-/*
-@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
-** You can replace it with 'table.unpack'.
-*/
-#define LUA_COMPAT_UNPACK
-
-/*
-@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'.
-** You can replace it with 'package.searchers'.
-*/
-#define LUA_COMPAT_LOADERS
-
-/*
-@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall.
-** You can call your C function directly (with light C functions).
-*/
-#define lua_cpcall(L,f,u)  \
-	(lua_pushcfunction(L, (f)), \
-	 lua_pushlightuserdata(L,(u)), \
-	 lua_pcall(L,1,0,0))
-
-
-/*
-@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library.
-** You can rewrite 'log10(x)' as 'log(x, 10)'.
-*/
-#define LUA_COMPAT_LOG10
-
-/*
-@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base
-** library. You can rewrite 'loadstring(s)' as 'load(s)'.
-*/
-#define LUA_COMPAT_LOADSTRING
-
-/*
-@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library.
-*/
-#define LUA_COMPAT_MAXN
-
-/*
-@@ The following macros supply trivial compatibility for some
-** changes in the API. The macros themselves document how to
-** change your code to avoid using them.
-*/
-#define lua_strlen(L,i)		lua_rawlen(L, (i))
-
-#define lua_objlen(L,i)		lua_rawlen(L, (i))
-
-#define lua_equal(L,idx1,idx2)		lua_compare(L,(idx1),(idx2),LUA_OPEQ)
-#define lua_lessthan(L,idx1,idx2)	lua_compare(L,(idx1),(idx2),LUA_OPLT)
-
-/*
-@@ LUA_COMPAT_MODULE controls compatibility with previous
-** module functions 'module' (Lua) and 'luaL_register' (C).
-*/
-#define LUA_COMPAT_MODULE
-
-#endif				/* } */
-
-
-/*
-@@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a
-@@ a float mark ('.0').
-** This macro is not on by default even in compatibility mode,
-** because this is not really an incompatibility.
-*/
-/* #define LUA_COMPAT_FLOATSTRING */
-
-/* }================================================================== */
-
-
-
-/*
-** {==================================================================
-** Configuration for Numbers.
-** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_*
-** satisfy your needs.
-** ===================================================================
-*/
-
-/*
-@@ LUA_NUMBER is the floating-point type used by Lua.
-@@ LUAI_UACNUMBER is the result of a 'default argument promotion'
-@@ over a floating number.
-@@ l_mathlim(x) corrects limit name 'x' to the proper float type
-** by prefixing it with one of FLT/DBL/LDBL.
-@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats.
-@@ LUA_NUMBER_FMT is the format for writing floats.
-@@ lua_number2str converts a float to a string.
-@@ l_mathop allows the addition of an 'l' or 'f' to all math operations.
-@@ l_floor takes the floor of a float.
-@@ lua_str2number converts a decimal numeric string to a number.
-*/
-
-
-/* The following definitions are good for most cases here */
-
-#define l_floor(x)		(l_mathop(floor)(x))
-
-#define lua_number2str(s,sz,n)  \
-	l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n))
-
-/*
-@@ lua_numbertointeger converts a float number to an integer, or
-** returns 0 if float is not within the range of a lua_Integer.
-** (The range comparisons are tricky because of rounding. The tests
-** here assume a two-complement representation, where MININTEGER always
-** has an exact representation as a float; MAXINTEGER may not have one,
-** and therefore its conversion to float may have an ill-defined value.)
-*/
-#define lua_numbertointeger(n,p) \
-  ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
-   (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
-      (*(p) = (LUA_INTEGER)(n), 1))
-
-
-/* now the variable definitions */
-
-#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT		/* { single float */
-
-#define LUA_NUMBER	float
-
-#define l_mathlim(n)		(FLT_##n)
-
-#define LUAI_UACNUMBER	double
-
-#define LUA_NUMBER_FRMLEN	""
-#define LUA_NUMBER_FMT		"%.7g"
-
-#define l_mathop(op)		op##f
-
-#define lua_str2number(s,p)	strtof((s), (p))
-
-
-#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE	/* }{ long double */
-
-#define LUA_NUMBER	long double
-
-#define l_mathlim(n)		(LDBL_##n)
-
-#define LUAI_UACNUMBER	long double
-
-#define LUA_NUMBER_FRMLEN	"L"
-#define LUA_NUMBER_FMT		"%.19Lg"
-
-#define l_mathop(op)		op##l
-
-#define lua_str2number(s,p)	strtold((s), (p))
-
-#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE	/* }{ double */
-
-#define LUA_NUMBER	double
-
-#define l_mathlim(n)		(DBL_##n)
-
-#define LUAI_UACNUMBER	double
-
-#define LUA_NUMBER_FRMLEN	""
-#define LUA_NUMBER_FMT		"%.14g"
-
-#define l_mathop(op)		op
-
-#define lua_str2number(s,p)	strtod((s), (p))
-
-#else						/* }{ */
-
-#error "numeric float type not defined"
-
-#endif					/* } */
-
-
-
-/*
-@@ LUA_INTEGER is the integer type used by Lua.
-**
-@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER.
-**
-@@ LUAI_UACINT is the result of a 'default argument promotion'
-@@ over a lUA_INTEGER.
-@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers.
-@@ LUA_INTEGER_FMT is the format for writing integers.
-@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER.
-@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER.
-@@ lua_integer2str converts an integer to a string.
-*/
-
-
-/* The following definitions are good for most cases here */
-
-#define LUA_INTEGER_FMT		"%" LUA_INTEGER_FRMLEN "d"
-
-#define LUAI_UACINT		LUA_INTEGER
-
-#define lua_integer2str(s,sz,n)  \
-	l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n))
-
-/*
-** use LUAI_UACINT here to avoid problems with promotions (which
-** can turn a comparison between unsigneds into a signed comparison)
-*/
-#define LUA_UNSIGNED		unsigned LUAI_UACINT
-
-
-/* now the variable definitions */
-
-#if LUA_INT_TYPE == LUA_INT_INT		/* { int */
-
-#define LUA_INTEGER		int
-#define LUA_INTEGER_FRMLEN	""
-
-#define LUA_MAXINTEGER		INT_MAX
-#define LUA_MININTEGER		INT_MIN
-
-#elif LUA_INT_TYPE == LUA_INT_LONG	/* }{ long */
-
-#define LUA_INTEGER		long
-#define LUA_INTEGER_FRMLEN	"l"
-
-#define LUA_MAXINTEGER		LONG_MAX
-#define LUA_MININTEGER		LONG_MIN
-
-#elif LUA_INT_TYPE == LUA_INT_LONGLONG	/* }{ long long */
-
-/* use presence of macro LLONG_MAX as proxy for C99 compliance */
-#if defined(LLONG_MAX)		/* { */
-/* use ISO C99 stuff */
-
-#define LUA_INTEGER		long long
-#define LUA_INTEGER_FRMLEN	"ll"
-
-#define LUA_MAXINTEGER		LLONG_MAX
-#define LUA_MININTEGER		LLONG_MIN
-
-#elif defined(LUA_USE_WINDOWS) /* }{ */
-/* in Windows, can use specific Windows types */
-
-#define LUA_INTEGER		__int64
-#define LUA_INTEGER_FRMLEN	"I64"
-
-#define LUA_MAXINTEGER		_I64_MAX
-#define LUA_MININTEGER		_I64_MIN
-
-#else				/* }{ */
-
-#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \
-  or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)"
-
-#endif				/* } */
-
-#else				/* }{ */
-
-#error "numeric integer type not defined"
-
-#endif				/* } */
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Dependencies with C99 and other C details
-** ===================================================================
-*/
-
-/*
-@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89.
-** (All uses in Lua have only one format item.)
-*/
-#if !defined(LUA_USE_C89)
-#define l_sprintf(s,sz,f,i)	snprintf(s,sz,f,i)
-#else
-#define l_sprintf(s,sz,f,i)	((void)(sz), sprintf(s,f,i))
-#endif
-
-
-/*
-@@ lua_strx2number converts an hexadecimal numeric string to a number.
-** In C99, 'strtod' does that conversion. Otherwise, you can
-** leave 'lua_strx2number' undefined and Lua will provide its own
-** implementation.
-*/
-#if !defined(LUA_USE_C89)
-#define lua_strx2number(s,p)		lua_str2number(s,p)
-#endif
-
-
-/*
-@@ lua_pointer2str converts a pointer to a readable string in a
-** non-specified way.
-*/
-#define lua_pointer2str(buff,sz,p)	l_sprintf(buff,sz,"%p",p)
-
-
-/*
-@@ lua_number2strx converts a float to an hexadecimal numeric string.
-** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that.
-** Otherwise, you can leave 'lua_number2strx' undefined and Lua will
-** provide its own implementation.
-*/
-#if !defined(LUA_USE_C89)
-#define lua_number2strx(L,b,sz,f,n)  \
-	((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n)))
-#endif
-
-
-/*
-** 'strtof' and 'opf' variants for math functions are not valid in
-** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the
-** availability of these variants. ('math.h' is already included in
-** all files that use these macros.)
-*/
-#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF))
-#undef l_mathop  /* variants not available */
-#undef lua_str2number
-#define l_mathop(op)		(lua_Number)op  /* no variant */
-#define lua_str2number(s,p)	((lua_Number)strtod((s), (p)))
-#endif
-
-
-/*
-@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation
-** functions.  It must be a numerical type; Lua will use 'intptr_t' if
-** available, otherwise it will use 'ptrdiff_t' (the nearest thing to
-** 'intptr_t' in C89)
-*/
-#define LUA_KCONTEXT	ptrdiff_t
-
-#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
-    __STDC_VERSION__ >= 199901L
-#include <stdint.h>
-#if defined(INTPTR_MAX)  /* even in C99 this type is optional */
-#undef LUA_KCONTEXT
-#define LUA_KCONTEXT	intptr_t
-#endif
-#endif
-
-
-/*
-@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point).
-** Change that if you do not want to use C locales. (Code using this
-** macro must include header 'locale.h'.)
-*/
-#if !defined(lua_getlocaledecpoint)
-#define lua_getlocaledecpoint()		(localeconv()->decimal_point[0])
-#endif
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Language Variations
-** =====================================================================
-*/
-
-/*
-@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some
-** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from
-** numbers to strings. Define LUA_NOCVTS2N to turn off automatic
-** coercion from strings to numbers.
-*/
-/* #define LUA_NOCVTN2S */
-/* #define LUA_NOCVTS2N */
-
-
-/*
-@@ LUA_USE_APICHECK turns on several consistency checks on the C API.
-** Define it as a help when debugging C code.
-*/
-#if defined(LUA_USE_APICHECK)
-#include <assert.h>
-#define luai_apicheck(l,e)	assert(e)
-#endif
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Macros that affect the API and must be stable (that is, must be the
-** same when you compile Lua and when you compile code that links to
-** Lua). You probably do not want/need to change them.
-** =====================================================================
-*/
-
-/*
-@@ LUAI_MAXSTACK limits the size of the Lua stack.
-** CHANGE it if you need a different limit. This limit is arbitrary;
-** its only purpose is to stop Lua from consuming unlimited stack
-** space (and to reserve some numbers for pseudo-indices).
-*/
-#if LUAI_BITSINT >= 32
-#define LUAI_MAXSTACK		1000000
-#else
-#define LUAI_MAXSTACK		15000
-#endif
-
-
-/*
-@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
-** a Lua state with very fast access.
-** CHANGE it if you need a different size.
-*/
-#define LUA_EXTRASPACE		(sizeof(void *))
-
-
-/*
-@@ 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
-
-
-/*
-@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
-** CHANGE it if it uses too much C-stack space. (For long double,
-** 'string.format("%.99f", -1e4932)' needs 5034 bytes, so a
-** smaller buffer would force a memory allocation for each call to
-** 'string.format'.)
-*/
-#if LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE
-#define LUAL_BUFFERSIZE		8192
-#else
-#define LUAL_BUFFERSIZE   ((int)(0x80 * sizeof(void*) * sizeof(lua_Integer)))
-#endif
-
-/* }================================================================== */
-
-
-/*
-@@ LUA_QL describes how error messages quote program elements.
-** Lua does not use these macros anymore; they are here for
-** compatibility only.
-*/
-#define LUA_QL(x)	"'" x "'"
-#define LUA_QS		LUA_QL("%s")
-
-
-
-
-/* =================================================================== */
-
-/*
-** Local configuration. You can use this space to add your redefinitions
-** without modifying the main part of the file.
-*/
-
-
-
-
-
-#endif
-
diff --git a/lua/lua-5.3.5/src/lualib.h b/lua/lua-5.3.5/src/lualib.h
deleted file mode 100644
index f5304aa..0000000
--- a/lua/lua-5.3.5/src/lualib.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-** $Id: lualib.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $
-** Lua standard libraries
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lualib_h
-#define lualib_h
-
-#include "lua.h"
-
-
-/* version suffix for environment variable names */
-#define LUA_VERSUFFIX          "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
-
-
-LUAMOD_API int (luaopen_base) (lua_State *L);
-
-#define LUA_COLIBNAME	"coroutine"
-LUAMOD_API int (luaopen_coroutine) (lua_State *L);
-
-#define LUA_TABLIBNAME	"table"
-LUAMOD_API int (luaopen_table) (lua_State *L);
-
-#define LUA_IOLIBNAME	"io"
-LUAMOD_API int (luaopen_io) (lua_State *L);
-
-#define LUA_OSLIBNAME	"os"
-LUAMOD_API int (luaopen_os) (lua_State *L);
-
-#define LUA_STRLIBNAME	"string"
-LUAMOD_API int (luaopen_string) (lua_State *L);
-
-#define LUA_UTF8LIBNAME	"utf8"
-LUAMOD_API int (luaopen_utf8) (lua_State *L);
-
-#define LUA_BITLIBNAME	"bit32"
-LUAMOD_API int (luaopen_bit32) (lua_State *L);
-
-#define LUA_MATHLIBNAME	"math"
-LUAMOD_API int (luaopen_math) (lua_State *L);
-
-#define LUA_DBLIBNAME	"debug"
-LUAMOD_API int (luaopen_debug) (lua_State *L);
-
-#define LUA_LOADLIBNAME	"package"
-LUAMOD_API int (luaopen_package) (lua_State *L);
-
-
-/* open all previous libraries */
-LUALIB_API void (luaL_openlibs) (lua_State *L);
-
-
-
-#if !defined(lua_assert)
-#define lua_assert(x)	((void)0)
-#endif
-
-
-#endif
diff --git a/lua/lua-5.3.5/src/lundump.c b/lua/lua-5.3.5/src/lundump.c
deleted file mode 100644
index 7a67d75..0000000
--- a/lua/lua-5.3.5/src/lundump.c
+++ /dev/null
@@ -1,279 +0,0 @@
-/*
-** $Id: lundump.c,v 2.44.1.1 2017/04/19 17:20:42 roberto Exp $
-** load precompiled Lua chunks
-** See Copyright Notice in lua.h
-*/
-
-#define lundump_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <string.h>
-
-#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"
-
-
-#if !defined(luai_verifycode)
-#define luai_verifycode(L,b,f)  /* empty */
-#endif
-
-
-typedef struct {
-  lua_State *L;
-  ZIO *Z;
-  const char *name;
-} LoadState;
-
-
-static l_noret error(LoadState *S, const char *why) {
-  luaO_pushfstring(S->L, "%s: %s precompiled chunk", S->name, why);
-  luaD_throw(S->L, LUA_ERRSYNTAX);
-}
-
-
-/*
-** All high-level loads go through LoadVector; you can change it to
-** adapt to the endianness of the input
-*/
-#define LoadVector(S,b,n)	LoadBlock(S,b,(n)*sizeof((b)[0]))
-
-static void LoadBlock (LoadState *S, void *b, size_t size) {
-  if (luaZ_read(S->Z, b, size) != 0)
-    error(S, "truncated");
-}
-
-
-#define LoadVar(S,x)		LoadVector(S,&x,1)
-
-
-static lu_byte LoadByte (LoadState *S) {
-  lu_byte x;
-  LoadVar(S, x);
-  return x;
-}
-
-
-static int LoadInt (LoadState *S) {
-  int x;
-  LoadVar(S, x);
-  return x;
-}
-
-
-static lua_Number LoadNumber (LoadState *S) {
-  lua_Number x;
-  LoadVar(S, x);
-  return x;
-}
-
-
-static lua_Integer LoadInteger (LoadState *S) {
-  lua_Integer x;
-  LoadVar(S, x);
-  return x;
-}
-
-
-static TString *LoadString (LoadState *S) {
-  size_t size = LoadByte(S);
-  if (size == 0xFF)
-    LoadVar(S, size);
-  if (size == 0)
-    return NULL;
-  else if (--size <= LUAI_MAXSHORTLEN) {  /* short string? */
-    char buff[LUAI_MAXSHORTLEN];
-    LoadVector(S, buff, size);
-    return luaS_newlstr(S->L, buff, size);
-  }
-  else {  /* long string */
-    TString *ts = luaS_createlngstrobj(S->L, size);
-    LoadVector(S, getstr(ts), size);  /* load directly in final place */
-    return ts;
-  }
-}
-
-
-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);
-}
-
-
-static void LoadFunction(LoadState *S, Proto *f, TString *psource);
-
-
-static void LoadConstants (LoadState *S, Proto *f) {
-  int i;
-  int 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 = LoadByte(S);
-    switch (t) {
-    case LUA_TNIL:
-      setnilvalue(o);
-      break;
-    case LUA_TBOOLEAN:
-      setbvalue(o, LoadByte(S));
-      break;
-    case LUA_TNUMFLT:
-      setfltvalue(o, LoadNumber(S));
-      break;
-    case LUA_TNUMINT:
-      setivalue(o, LoadInteger(S));
-      break;
-    case LUA_TSHRSTR:
-    case LUA_TLNGSTR:
-      setsvalue2n(S->L, o, LoadString(S));
-      break;
-    default:
-      lua_assert(0);
-    }
-  }
-}
-
-
-static void LoadProtos (LoadState *S, Proto *f) {
-  int i;
-  int 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] = luaF_newproto(S->L);
-    LoadFunction(S, f->p[i], f->source);
-  }
-}
-
-
-static void LoadUpvalues (LoadState *S, Proto *f) {
-  int i, n;
-  n = LoadInt(S);
-  f->upvalues = luaM_newvector(S->L, n, Upvaldesc);
-  f->sizeupvalues = n;
-  for (i = 0; i < n; i++)
-    f->upvalues[i].name = NULL;
-  for (i = 0; i < n; i++) {
-    f->upvalues[i].instack = LoadByte(S);
-    f->upvalues[i].idx = LoadByte(S);
-  }
-}
-
-
-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);
-  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);
-  for (i = 0; i < n; i++)
-    f->upvalues[i].name = LoadString(S);
-}
-
-
-static void LoadFunction (LoadState *S, Proto *f, TString *psource) {
-  f->source = LoadString(S);
-  if (f->source == NULL)  /* no source in dump? */
-    f->source = psource;  /* reuse parent's source */
-  f->linedefined = LoadInt(S);
-  f->lastlinedefined = LoadInt(S);
-  f->numparams = LoadByte(S);
-  f->is_vararg = LoadByte(S);
-  f->maxstacksize = LoadByte(S);
-  LoadCode(S, f);
-  LoadConstants(S, f);
-  LoadUpvalues(S, f);
-  LoadProtos(S, f);
-  LoadDebug(S, f);
-}
-
-
-static void checkliteral (LoadState *S, const char *s, const char *msg) {
-  char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */
-  size_t len = strlen(s);
-  LoadVector(S, buff, len);
-  if (memcmp(s, buff, len) != 0)
-    error(S, msg);
-}
-
-
-static void fchecksize (LoadState *S, size_t size, const char *tname) {
-  if (LoadByte(S) != size)
-    error(S, luaO_pushfstring(S->L, "%s size mismatch in", tname));
-}
-
-
-#define checksize(S,t)	fchecksize(S,sizeof(t),#t)
-
-static void checkHeader (LoadState *S) {
-  checkliteral(S, LUA_SIGNATURE + 1, "not a");  /* 1st char already checked */
-  if (LoadByte(S) != LUAC_VERSION)
-    error(S, "version mismatch in");
-  if (LoadByte(S) != LUAC_FORMAT)
-    error(S, "format mismatch in");
-  checkliteral(S, LUAC_DATA, "corrupted");
-  checksize(S, int);
-  checksize(S, size_t);
-  checksize(S, Instruction);
-  checksize(S, lua_Integer);
-  checksize(S, lua_Number);
-  if (LoadInteger(S) != LUAC_INT)
-    error(S, "endianness mismatch in");
-  if (LoadNumber(S) != LUAC_NUM)
-    error(S, "float format mismatch in");
-}
-
-
-/*
-** load precompiled chunk
-*/
-LClosure *luaU_undump(lua_State *L, ZIO *Z, const char *name) {
-  LoadState S;
-  LClosure *cl;
-  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;
-  checkHeader(&S);
-  cl = luaF_newLclosure(L, LoadByte(&S));
-  setclLvalue(L, L->top, cl);
-  luaD_inctop(L);
-  cl->p = luaF_newproto(L);
-  LoadFunction(&S, cl->p, NULL);
-  lua_assert(cl->nupvalues == cl->p->sizeupvalues);
-  luai_verifycode(L, buff, cl->p);
-  return cl;
-}
-
diff --git a/lua/lua-5.3.5/src/lundump.h b/lua/lua-5.3.5/src/lundump.h
deleted file mode 100644
index ce492d6..0000000
--- a/lua/lua-5.3.5/src/lundump.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
-** $Id: lundump.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $
-** load precompiled Lua chunks
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lundump_h
-#define lundump_h
-
-#include "llimits.h"
-#include "lobject.h"
-#include "lzio.h"
-
-
-/* data to catch conversion errors */
-#define LUAC_DATA	"\x19\x93\r\n\x1a\n"
-
-#define LUAC_INT	0x5678
-#define LUAC_NUM	cast_num(370.5)
-
-#define MYINT(s)	(s[0]-'0')
-#define LUAC_VERSION	(MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR))
-#define LUAC_FORMAT	0	/* this is the official format */
-
-/* load one chunk; from lundump.c */
-LUAI_FUNC LClosure* luaU_undump (lua_State* L, ZIO* Z, const char* name);
-
-/* dump one chunk; from ldump.c */
-LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w,
-                         void* data, int strip);
-
-#endif
diff --git a/lua/lua-5.3.5/src/lutf8lib.c b/lua/lua-5.3.5/src/lutf8lib.c
deleted file mode 100644
index 10bd238..0000000
--- a/lua/lua-5.3.5/src/lutf8lib.c
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
-** $Id: lutf8lib.c,v 1.16.1.1 2017/04/19 17:29:57 roberto Exp $
-** Standard library for UTF-8 manipulation
-** See Copyright Notice in lua.h
-*/
-
-#define lutf8lib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <assert.h>
-#include <limits.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-#define MAXUNICODE	0x10FFFF
-
-#define iscont(p)	((*(p) & 0xC0) == 0x80)
-
-
-/* from strlib */
-/* translate a relative string position: negative means back from end */
-static lua_Integer u_posrelat (lua_Integer pos, size_t len) {
-  if (pos >= 0) return pos;
-  else if (0u - (size_t)pos > len) return 0;
-  else return (lua_Integer)len + pos + 1;
-}
-
-
-/*
-** Decode one UTF-8 sequence, returning NULL if byte sequence is invalid.
-*/
-static const char *utf8_decode (const char *o, int *val) {
-  static const unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF};
-  const unsigned char *s = (const unsigned char *)o;
-  unsigned int c = s[0];
-  unsigned int res = 0;  /* final result */
-  if (c < 0x80)  /* ascii? */
-    res = c;
-  else {
-    int count = 0;  /* to count number of continuation bytes */
-    while (c & 0x40) {  /* still have continuation bytes? */
-      int cc = s[++count];  /* read next byte */
-      if ((cc & 0xC0) != 0x80)  /* not a continuation byte? */
-        return NULL;  /* invalid byte sequence */
-      res = (res << 6) | (cc & 0x3F);  /* add lower 6 bits from cont. byte */
-      c <<= 1;  /* to test next bit */
-    }
-    res |= ((c & 0x7F) << (count * 5));  /* add first byte */
-    if (count > 3 || res > MAXUNICODE || res <= limits[count])
-      return NULL;  /* invalid byte sequence */
-    s += count;  /* skip continuation bytes read */
-  }
-  if (val) *val = res;
-  return (const char *)s + 1;  /* +1 to include first byte */
-}
-
-
-/*
-** utf8len(s [, i [, j]]) --> number of characters that start in the
-** range [i,j], or nil + current position if 's' is not well formed in
-** that interval
-*/
-static int utflen (lua_State *L) {
-  int n = 0;
-  size_t len;
-  const char *s = luaL_checklstring(L, 1, &len);
-  lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len);
-  lua_Integer posj = u_posrelat(luaL_optinteger(L, 3, -1), len);
-  luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 2,
-                   "initial position out of string");
-  luaL_argcheck(L, --posj < (lua_Integer)len, 3,
-                   "final position out of string");
-  while (posi <= posj) {
-    const char *s1 = utf8_decode(s + posi, NULL);
-    if (s1 == NULL) {  /* conversion error? */
-      lua_pushnil(L);  /* return nil ... */
-      lua_pushinteger(L, posi + 1);  /* ... and current position */
-      return 2;
-    }
-    posi = s1 - s;
-    n++;
-  }
-  lua_pushinteger(L, n);
-  return 1;
-}
-
-
-/*
-** codepoint(s, [i, [j]])  -> returns codepoints for all characters
-** that start in the range [i,j]
-*/
-static int codepoint (lua_State *L) {
-  size_t len;
-  const char *s = luaL_checklstring(L, 1, &len);
-  lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len);
-  lua_Integer pose = u_posrelat(luaL_optinteger(L, 3, posi), len);
-  int n;
-  const char *se;
-  luaL_argcheck(L, posi >= 1, 2, "out of range");
-  luaL_argcheck(L, pose <= (lua_Integer)len, 3, "out of range");
-  if (posi > pose) return 0;  /* empty interval; return no values */
-  if (pose - posi >= INT_MAX)  /* (lua_Integer -> int) overflow? */
-    return luaL_error(L, "string slice too long");
-  n = (int)(pose -  posi) + 1;
-  luaL_checkstack(L, n, "string slice too long");
-  n = 0;
-  se = s + pose;
-  for (s += posi - 1; s < se;) {
-    int code;
-    s = utf8_decode(s, &code);
-    if (s == NULL)
-      return luaL_error(L, "invalid UTF-8 code");
-    lua_pushinteger(L, code);
-    n++;
-  }
-  return n;
-}
-
-
-static void pushutfchar (lua_State *L, int arg) {
-  lua_Integer code = luaL_checkinteger(L, arg);
-  luaL_argcheck(L, 0 <= code && code <= MAXUNICODE, arg, "value out of range");
-  lua_pushfstring(L, "%U", (long)code);
-}
-
-
-/*
-** utfchar(n1, n2, ...)  -> char(n1)..char(n2)...
-*/
-static int utfchar (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  if (n == 1)  /* optimize common case of single char */
-    pushutfchar(L, 1);
-  else {
-    int i;
-    luaL_Buffer b;
-    luaL_buffinit(L, &b);
-    for (i = 1; i <= n; i++) {
-      pushutfchar(L, i);
-      luaL_addvalue(&b);
-    }
-    luaL_pushresult(&b);
-  }
-  return 1;
-}
-
-
-/*
-** offset(s, n, [i])  -> index where n-th character counting from
-**   position 'i' starts; 0 means character at 'i'.
-*/
-static int byteoffset (lua_State *L) {
-  size_t len;
-  const char *s = luaL_checklstring(L, 1, &len);
-  lua_Integer n  = luaL_checkinteger(L, 2);
-  lua_Integer posi = (n >= 0) ? 1 : len + 1;
-  posi = u_posrelat(luaL_optinteger(L, 3, posi), len);
-  luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 3,
-                   "position out of range");
-  if (n == 0) {
-    /* find beginning of current byte sequence */
-    while (posi > 0 && iscont(s + posi)) posi--;
-  }
-  else {
-    if (iscont(s + posi))
-      return luaL_error(L, "initial position is a continuation byte");
-    if (n < 0) {
-       while (n < 0 && posi > 0) {  /* move back */
-         do {  /* find beginning of previous character */
-           posi--;
-         } while (posi > 0 && iscont(s + posi));
-         n++;
-       }
-     }
-     else {
-       n--;  /* do not move for 1st character */
-       while (n > 0 && posi < (lua_Integer)len) {
-         do {  /* find beginning of next character */
-           posi++;
-         } while (iscont(s + posi));  /* (cannot pass final '\0') */
-         n--;
-       }
-     }
-  }
-  if (n == 0)  /* did it find given character? */
-    lua_pushinteger(L, posi + 1);
-  else  /* no such character */
-    lua_pushnil(L);
-  return 1;
-}
-
-
-static int iter_aux (lua_State *L) {
-  size_t len;
-  const char *s = luaL_checklstring(L, 1, &len);
-  lua_Integer n = lua_tointeger(L, 2) - 1;
-  if (n < 0)  /* first iteration? */
-    n = 0;  /* start from here */
-  else if (n < (lua_Integer)len) {
-    n++;  /* skip current byte */
-    while (iscont(s + n)) n++;  /* and its continuations */
-  }
-  if (n >= (lua_Integer)len)
-    return 0;  /* no more codepoints */
-  else {
-    int code;
-    const char *next = utf8_decode(s + n, &code);
-    if (next == NULL || iscont(next))
-      return luaL_error(L, "invalid UTF-8 code");
-    lua_pushinteger(L, n + 1);
-    lua_pushinteger(L, code);
-    return 2;
-  }
-}
-
-
-static int iter_codes (lua_State *L) {
-  luaL_checkstring(L, 1);
-  lua_pushcfunction(L, iter_aux);
-  lua_pushvalue(L, 1);
-  lua_pushinteger(L, 0);
-  return 3;
-}
-
-
-/* pattern to match a single UTF-8 character */
-#define UTF8PATT	"[\0-\x7F\xC2-\xF4][\x80-\xBF]*"
-
-
-static const luaL_Reg funcs[] = {
-  {"offset", byteoffset},
-  {"codepoint", codepoint},
-  {"char", utfchar},
-  {"len", utflen},
-  {"codes", iter_codes},
-  /* placeholders */
-  {"charpattern", NULL},
-  {NULL, NULL}
-};
-
-
-LUAMOD_API int luaopen_utf8 (lua_State *L) {
-  luaL_newlib(L, funcs);
-  lua_pushlstring(L, UTF8PATT, sizeof(UTF8PATT)/sizeof(char) - 1);
-  lua_setfield(L, -2, "charpattern");
-  return 1;
-}
-
diff --git a/lua/lua-5.3.5/src/lvm.c b/lua/lua-5.3.5/src/lvm.c
deleted file mode 100644
index cc43d87..0000000
--- a/lua/lua-5.3.5/src/lvm.c
+++ /dev/null
@@ -1,1322 +0,0 @@
-/*
-** $Id: lvm.c,v 2.268.1.1 2017/04/19 17:39:34 roberto Exp $
-** Lua virtual machine
-** See Copyright Notice in lua.h
-*/
-
-#define lvm_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-#include <float.h>
-#include <limits.h>
-#include <math.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#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	2000
-
-
-
-/*
-** 'l_intfitsf' checks whether a given integer can be converted to a
-** float without rounding. Used in comparisons. Left undefined if
-** all integers fit in a float precisely.
-*/
-#if !defined(l_intfitsf)
-
-/* number of bits in the mantissa of a float */
-#define NBM		(l_mathlim(MANT_DIG))
-
-/*
-** Check whether some integers may not fit in a float, that is, whether
-** (maxinteger >> NBM) > 0 (that implies (1 << NBM) <= maxinteger).
-** (The shifts are done in parts to avoid shifting by more than the size
-** of an integer. In a worst case, NBM == 113 for long double and
-** sizeof(integer) == 32.)
-*/
-#if ((((LUA_MAXINTEGER >> (NBM / 4)) >> (NBM / 4)) >> (NBM / 4)) \
-	>> (NBM - (3 * (NBM / 4))))  >  0
-
-#define l_intfitsf(i)  \
-  (-((lua_Integer)1 << NBM) <= (i) && (i) <= ((lua_Integer)1 << NBM))
-
-#endif
-
-#endif
-
-
-
-/*
-** Try to convert a value to a float. The float case is already handled
-** by the macro 'tonumber'.
-*/
-int luaV_tonumber_ (const TValue *obj, lua_Number *n) {
-  TValue v;
-  if (ttisinteger(obj)) {
-    *n = cast_num(ivalue(obj));
-    return 1;
-  }
-  else if (cvt2num(obj) &&  /* string convertible to number? */
-            luaO_str2num(svalue(obj), &v) == vslen(obj) + 1) {
-    *n = nvalue(&v);  /* convert result of 'luaO_str2num' to a float */
-    return 1;
-  }
-  else
-    return 0;  /* conversion failed */
-}
-
-
-/*
-** try to convert a value to an integer, rounding according to 'mode':
-** mode == 0: accepts only integral values
-** mode == 1: takes the floor of the number
-** mode == 2: takes the ceil of the number
-*/
-int luaV_tointeger (const TValue *obj, lua_Integer *p, int mode) {
-  TValue v;
- again:
-  if (ttisfloat(obj)) {
-    lua_Number n = fltvalue(obj);
-    lua_Number f = l_floor(n);
-    if (n != f) {  /* not an integral value? */
-      if (mode == 0) return 0;  /* fails if mode demands integral value */
-      else if (mode > 1)  /* needs ceil? */
-        f += 1;  /* convert floor to ceil (remember: n != f) */
-    }
-    return lua_numbertointeger(f, p);
-  }
-  else if (ttisinteger(obj)) {
-    *p = ivalue(obj);
-    return 1;
-  }
-  else if (cvt2num(obj) &&
-            luaO_str2num(svalue(obj), &v) == vslen(obj) + 1) {
-    obj = &v;
-    goto again;  /* convert result from 'luaO_str2num' to an integer */
-  }
-  return 0;  /* conversion failed */
-}
-
-
-/*
-** Try to convert a 'for' limit to an integer, preserving the
-** semantics of the loop.
-** (The following explanation assumes a non-negative step; it is valid
-** for negative steps mutatis mutandis.)
-** If the limit can be converted to an integer, rounding down, that is
-** it.
-** Otherwise, check whether the limit can be converted to a number.  If
-** the number is too large, it is OK to set the limit as LUA_MAXINTEGER,
-** which means no limit.  If the number is too negative, the loop
-** should not run, because any initial integer value is larger than the
-** limit. So, it sets the limit to LUA_MININTEGER. 'stopnow' corrects
-** the extreme case when the initial value is LUA_MININTEGER, in which
-** case the LUA_MININTEGER limit would still run the loop once.
-*/
-static int forlimit (const TValue *obj, lua_Integer *p, lua_Integer step,
-                     int *stopnow) {
-  *stopnow = 0;  /* usually, let loops run */
-  if (!luaV_tointeger(obj, p, (step < 0 ? 2 : 1))) {  /* not fit in integer? */
-    lua_Number n;  /* try to convert to float */
-    if (!tonumber(obj, &n)) /* cannot convert to float? */
-      return 0;  /* not a number */
-    if (luai_numlt(0, n)) {  /* if true, float is larger than max integer */
-      *p = LUA_MAXINTEGER;
-      if (step < 0) *stopnow = 1;
-    }
-    else {  /* float is smaller than min integer */
-      *p = LUA_MININTEGER;
-      if (step >= 0) *stopnow = 1;
-    }
-  }
-  return 1;
-}
-
-
-/*
-** Finish the table access 'val = t[key]'.
-** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to
-** t[k] entry (which must be nil).
-*/
-void luaV_finishget (lua_State *L, const TValue *t, TValue *key, StkId val,
-                      const TValue *slot) {
-  int loop;  /* counter to avoid infinite loops */
-  const TValue *tm;  /* metamethod */
-  for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    if (slot == NULL) {  /* 't' is not a table? */
-      lua_assert(!ttistable(t));
-      tm = luaT_gettmbyobj(L, t, TM_INDEX);
-      if (ttisnil(tm))
-        luaG_typeerror(L, t, "index");  /* no metamethod */
-      /* else will try the metamethod */
-    }
-    else {  /* 't' is a table */
-      lua_assert(ttisnil(slot));
-      tm = fasttm(L, hvalue(t)->metatable, TM_INDEX);  /* table's metamethod */
-      if (tm == NULL) {  /* no metamethod? */
-        setnilvalue(val);  /* result is nil */
-        return;
-      }
-      /* else will try the metamethod */
-    }
-    if (ttisfunction(tm)) {  /* is metamethod a function? */
-      luaT_callTM(L, tm, t, key, val, 1);  /* call it */
-      return;
-    }
-    t = tm;  /* else try to access 'tm[key]' */
-    if (luaV_fastget(L,t,key,slot,luaH_get)) {  /* fast track? */
-      setobj2s(L, val, slot);  /* done */
-      return;
-    }
-    /* else repeat (tail call 'luaV_finishget') */
-  }
-  luaG_runerror(L, "'__index' chain too long; possible loop");
-}
-
-
-/*
-** Finish a table assignment 't[key] = val'.
-** If 'slot' is NULL, 't' is not a table.  Otherwise, 'slot' points
-** to the entry 't[key]', or to 'luaO_nilobject' if there is no such
-** entry.  (The value at 'slot' must be nil, otherwise 'luaV_fastset'
-** would have done the job.)
-*/
-void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
-                     StkId val, const TValue *slot) {
-  int loop;  /* counter to avoid infinite loops */
-  for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    const TValue *tm;  /* '__newindex' metamethod */
-    if (slot != NULL) {  /* is 't' a table? */
-      Table *h = hvalue(t);  /* save 't' table */
-      lua_assert(ttisnil(slot));  /* old value must be nil */
-      tm = fasttm(L, h->metatable, TM_NEWINDEX);  /* get metamethod */
-      if (tm == NULL) {  /* no metamethod? */
-        if (slot == luaO_nilobject)  /* no previous entry? */
-          slot = luaH_newkey(L, h, key);  /* create one */
-        /* no metamethod and (now) there is an entry with given key */
-        setobj2t(L, cast(TValue *, slot), val);  /* set its new value */
-        invalidateTMcache(h);
-        luaC_barrierback(L, h, val);
-        return;
-      }
-      /* else will try the metamethod */
-    }
-    else {  /* not a table; check metamethod */
-      if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
-        luaG_typeerror(L, t, "index");
-    }
-    /* try the metamethod */
-    if (ttisfunction(tm)) {
-      luaT_callTM(L, tm, t, key, val, 0);
-      return;
-    }
-    t = tm;  /* else repeat assignment over 'tm' */
-    if (luaV_fastset(L, t, key, slot, luaH_get, val))
-      return;  /* done */
-    /* else loop */
-  }
-  luaG_runerror(L, "'__newindex' chain too long; possible loop");
-}
-
-
-/*
-** Compare two strings 'ls' x 'rs', returning an integer smaller-equal-
-** -larger than zero if 'ls' is smaller-equal-larger than 'rs'.
-** The code is a little tricky because it allows '\0' in the strings
-** and it uses 'strcoll' (to respect locales) for each segments
-** of the strings.
-*/
-static int l_strcmp (const TString *ls, const TString *rs) {
-  const char *l = getstr(ls);
-  size_t ll = tsslen(ls);
-  const char *r = getstr(rs);
-  size_t lr = tsslen(rs);
-  for (;;) {  /* for each segment */
-    int temp = strcoll(l, r);
-    if (temp != 0)  /* not equal? */
-      return temp;  /* done */
-    else {  /* strings are equal up to a '\0' */
-      size_t len = strlen(l);  /* index of first '\0' in both strings */
-      if (len == lr)  /* 'rs' is finished? */
-        return (len == ll) ? 0 : 1;  /* check 'ls' */
-      else if (len == ll)  /* 'ls' is finished? */
-        return -1;  /* 'ls' is smaller than 'rs' ('rs' is not finished) */
-      /* both strings longer than 'len'; go on comparing after the '\0' */
-      len++;
-      l += len; ll -= len; r += len; lr -= len;
-    }
-  }
-}
-
-
-/*
-** Check whether integer 'i' is less than float 'f'. If 'i' has an
-** exact representation as a float ('l_intfitsf'), compare numbers as
-** floats. Otherwise, if 'f' is outside the range for integers, result
-** is trivial. Otherwise, compare them as integers. (When 'i' has no
-** float representation, either 'f' is "far away" from 'i' or 'f' has
-** no precision left for a fractional part; either way, how 'f' is
-** truncated is irrelevant.) When 'f' is NaN, comparisons must result
-** in false.
-*/
-static int LTintfloat (lua_Integer i, lua_Number f) {
-#if defined(l_intfitsf)
-  if (!l_intfitsf(i)) {
-    if (f >= -cast_num(LUA_MININTEGER))  /* -minint == maxint + 1 */
-      return 1;  /* f >= maxint + 1 > i */
-    else if (f > cast_num(LUA_MININTEGER))  /* minint < f <= maxint ? */
-      return (i < cast(lua_Integer, f));  /* compare them as integers */
-    else  /* f <= minint <= i (or 'f' is NaN)  -->  not(i < f) */
-      return 0;
-  }
-#endif
-  return luai_numlt(cast_num(i), f);  /* compare them as floats */
-}
-
-
-/*
-** Check whether integer 'i' is less than or equal to float 'f'.
-** See comments on previous function.
-*/
-static int LEintfloat (lua_Integer i, lua_Number f) {
-#if defined(l_intfitsf)
-  if (!l_intfitsf(i)) {
-    if (f >= -cast_num(LUA_MININTEGER))  /* -minint == maxint + 1 */
-      return 1;  /* f >= maxint + 1 > i */
-    else if (f >= cast_num(LUA_MININTEGER))  /* minint <= f <= maxint ? */
-      return (i <= cast(lua_Integer, f));  /* compare them as integers */
-    else  /* f < minint <= i (or 'f' is NaN)  -->  not(i <= f) */
-      return 0;
-  }
-#endif
-  return luai_numle(cast_num(i), f);  /* compare them as floats */
-}
-
-
-/*
-** Return 'l < r', for numbers.
-*/
-static int LTnum (const TValue *l, const TValue *r) {
-  if (ttisinteger(l)) {
-    lua_Integer li = ivalue(l);
-    if (ttisinteger(r))
-      return li < ivalue(r);  /* both are integers */
-    else  /* 'l' is int and 'r' is float */
-      return LTintfloat(li, fltvalue(r));  /* l < r ? */
-  }
-  else {
-    lua_Number lf = fltvalue(l);  /* 'l' must be float */
-    if (ttisfloat(r))
-      return luai_numlt(lf, fltvalue(r));  /* both are float */
-    else if (luai_numisnan(lf))  /* 'r' is int and 'l' is float */
-      return 0;  /* NaN < i is always false */
-    else  /* without NaN, (l < r)  <-->  not(r <= l) */
-      return !LEintfloat(ivalue(r), lf);  /* not (r <= l) ? */
-  }
-}
-
-
-/*
-** Return 'l <= r', for numbers.
-*/
-static int LEnum (const TValue *l, const TValue *r) {
-  if (ttisinteger(l)) {
-    lua_Integer li = ivalue(l);
-    if (ttisinteger(r))
-      return li <= ivalue(r);  /* both are integers */
-    else  /* 'l' is int and 'r' is float */
-      return LEintfloat(li, fltvalue(r));  /* l <= r ? */
-  }
-  else {
-    lua_Number lf = fltvalue(l);  /* 'l' must be float */
-    if (ttisfloat(r))
-      return luai_numle(lf, fltvalue(r));  /* both are float */
-    else if (luai_numisnan(lf))  /* 'r' is int and 'l' is float */
-      return 0;  /*  NaN <= i is always false */
-    else  /* without NaN, (l <= r)  <-->  not(r < l) */
-      return !LTintfloat(ivalue(r), lf);  /* not (r < l) ? */
-  }
-}
-
-
-/*
-** Main operation less than; return 'l < r'.
-*/
-int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
-  int res;
-  if (ttisnumber(l) && ttisnumber(r))  /* both operands are numbers? */
-    return LTnum(l, r);
-  else if (ttisstring(l) && ttisstring(r))  /* both are strings? */
-    return l_strcmp(tsvalue(l), tsvalue(r)) < 0;
-  else if ((res = luaT_callorderTM(L, l, r, TM_LT)) < 0)  /* no metamethod? */
-    luaG_ordererror(L, l, r);  /* error */
-  return res;
-}
-
-
-/*
-** Main operation less than or equal to; return 'l <= r'. If it needs
-** a metamethod and there is no '__le', try '__lt', based on
-** l <= r iff !(r < l) (assuming a total order). If the metamethod
-** yields during this substitution, the continuation has to know
-** about it (to negate the result of r<l); bit CIST_LEQ in the call
-** status keeps that information.
-*/
-int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) {
-  int res;
-  if (ttisnumber(l) && ttisnumber(r))  /* both operands are numbers? */
-    return LEnum(l, r);
-  else if (ttisstring(l) && ttisstring(r))  /* both are strings? */
-    return l_strcmp(tsvalue(l), tsvalue(r)) <= 0;
-  else if ((res = luaT_callorderTM(L, l, r, TM_LE)) >= 0)  /* try 'le' */
-    return res;
-  else {  /* try 'lt': */
-    L->ci->callstatus |= CIST_LEQ;  /* mark it is doing 'lt' for 'le' */
-    res = luaT_callorderTM(L, r, l, TM_LT);
-    L->ci->callstatus ^= CIST_LEQ;  /* clear mark */
-    if (res < 0)
-      luaG_ordererror(L, l, r);
-    return !res;  /* result is negated */
-  }
-}
-
-
-/*
-** Main operation for equality of Lua values; return 't1 == t2'.
-** L == NULL means raw equality (no metamethods)
-*/
-int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) {
-  const TValue *tm;
-  if (ttype(t1) != ttype(t2)) {  /* not the same variant? */
-    if (ttnov(t1) != ttnov(t2) || ttnov(t1) != LUA_TNUMBER)
-      return 0;  /* only numbers can be equal with different variants */
-    else {  /* two numbers with different variants */
-      lua_Integer i1, i2;  /* compare them as integers */
-      return (tointeger(t1, &i1) && tointeger(t2, &i2) && i1 == i2);
-    }
-  }
-  /* values have same type and same variant */
-  switch (ttype(t1)) {
-    case LUA_TNIL: return 1;
-    case LUA_TNUMINT: return (ivalue(t1) == ivalue(t2));
-    case LUA_TNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2));
-    case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2);  /* true must be 1 !! */
-    case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
-    case LUA_TLCF: return fvalue(t1) == fvalue(t2);
-    case LUA_TSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2));
-    case LUA_TLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2));
-    case LUA_TUSERDATA: {
-      if (uvalue(t1) == uvalue(t2)) return 1;
-      else if (L == NULL) return 0;
-      tm = fasttm(L, uvalue(t1)->metatable, TM_EQ);
-      if (tm == NULL)
-        tm = fasttm(L, uvalue(t2)->metatable, TM_EQ);
-      break;  /* will try TM */
-    }
-    case LUA_TTABLE: {
-      if (hvalue(t1) == hvalue(t2)) return 1;
-      else if (L == NULL) return 0;
-      tm = fasttm(L, hvalue(t1)->metatable, TM_EQ);
-      if (tm == NULL)
-        tm = fasttm(L, hvalue(t2)->metatable, TM_EQ);
-      break;  /* will try TM */
-    }
-    default:
-      return gcvalue(t1) == gcvalue(t2);
-  }
-  if (tm == NULL)  /* no TM? */
-    return 0;  /* objects are different */
-  luaT_callTM(L, tm, t1, t2, L->top, 1);  /* call TM */
-  return !l_isfalse(L->top);
-}
-
-
-/* macro used by 'luaV_concat' to ensure that element at 'o' is a string */
-#define tostring(L,o)  \
-	(ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1)))
-
-#define isemptystr(o)	(ttisshrstring(o) && tsvalue(o)->shrlen == 0)
-
-/* copy strings in stack from top - n up to top - 1 to buffer */
-static void copy2buff (StkId top, int n, char *buff) {
-  size_t tl = 0;  /* size already copied */
-  do {
-    size_t l = vslen(top - n);  /* length of string being copied */
-    memcpy(buff + tl, svalue(top - n), l * sizeof(char));
-    tl += l;
-  } while (--n > 0);
-}
-
-
-/*
-** Main operation for concatenation: concat 'total' values in the stack,
-** from 'L->top - total' up to 'L->top - 1'.
-*/
-void luaV_concat (lua_State *L, int total) {
-  lua_assert(total >= 2);
-  do {
-    StkId top = L->top;
-    int n = 2;  /* number of elements handled in this pass (at least 2) */
-    if (!(ttisstring(top-2) || cvt2str(top-2)) || !tostring(L, top-1))
-      luaT_trybinTM(L, top-2, top-1, top-2, TM_CONCAT);
-    else if (isemptystr(top - 1))  /* second operand is empty? */
-      cast_void(tostring(L, top - 2));  /* result is first operand */
-    else if (isemptystr(top - 2)) {  /* first operand is an empty string? */
-      setobjs2s(L, top - 2, top - 1);  /* result is second op. */
-    }
-    else {
-      /* at least two non-empty string values; get as many as possible */
-      size_t tl = vslen(top - 1);
-      TString *ts;
-      /* collect total length and number of strings */
-      for (n = 1; n < total && tostring(L, top - n - 1); n++) {
-        size_t l = vslen(top - n - 1);
-        if (l >= (MAX_SIZE/sizeof(char)) - tl)
-          luaG_runerror(L, "string length overflow");
-        tl += l;
-      }
-      if (tl <= LUAI_MAXSHORTLEN) {  /* is result a short string? */
-        char buff[LUAI_MAXSHORTLEN];
-        copy2buff(top, n, buff);  /* copy strings to buffer */
-        ts = luaS_newlstr(L, buff, tl);
-      }
-      else {  /* long string; copy strings directly to final result */
-        ts = luaS_createlngstrobj(L, tl);
-        copy2buff(top, n, getstr(ts));
-      }
-      setsvalue2s(L, top - n, ts);  /* create result */
-    }
-    total -= n-1;  /* got 'n' strings to create 1 new */
-    L->top -= n-1;  /* popped 'n' strings and pushed one */
-  } while (total > 1);  /* repeat until only 1 result left */
-}
-
-
-/*
-** Main operation 'ra' = #rb'.
-*/
-void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) {
-  const TValue *tm;
-  switch (ttype(rb)) {
-    case LUA_TTABLE: {
-      Table *h = hvalue(rb);
-      tm = fasttm(L, h->metatable, TM_LEN);
-      if (tm) break;  /* metamethod? break switch to call it */
-      setivalue(ra, luaH_getn(h));  /* else primitive len */
-      return;
-    }
-    case LUA_TSHRSTR: {
-      setivalue(ra, tsvalue(rb)->shrlen);
-      return;
-    }
-    case LUA_TLNGSTR: {
-      setivalue(ra, tsvalue(rb)->u.lnglen);
-      return;
-    }
-    default: {  /* try metamethod */
-      tm = luaT_gettmbyobj(L, rb, TM_LEN);
-      if (ttisnil(tm))  /* no metamethod? */
-        luaG_typeerror(L, rb, "get length of");
-      break;
-    }
-  }
-  luaT_callTM(L, tm, rb, rb, ra, 1);
-}
-
-
-/*
-** Integer division; return 'm // n', that is, floor(m/n).
-** C division truncates its result (rounds towards zero).
-** 'floor(q) == trunc(q)' when 'q >= 0' or when 'q' is integer,
-** otherwise 'floor(q) == trunc(q) - 1'.
-*/
-lua_Integer luaV_div (lua_State *L, lua_Integer m, lua_Integer n) {
-  if (l_castS2U(n) + 1u <= 1u) {  /* special cases: -1 or 0 */
-    if (n == 0)
-      luaG_runerror(L, "attempt to divide by zero");
-    return intop(-, 0, m);   /* n==-1; avoid overflow with 0x80000...//-1 */
-  }
-  else {
-    lua_Integer q = m / n;  /* perform C division */
-    if ((m ^ n) < 0 && m % n != 0)  /* 'm/n' would be negative non-integer? */
-      q -= 1;  /* correct result for different rounding */
-    return q;
-  }
-}
-
-
-/*
-** Integer modulus; return 'm % n'. (Assume that C '%' with
-** negative operands follows C99 behavior. See previous comment
-** about luaV_div.)
-*/
-lua_Integer luaV_mod (lua_State *L, lua_Integer m, lua_Integer n) {
-  if (l_castS2U(n) + 1u <= 1u) {  /* special cases: -1 or 0 */
-    if (n == 0)
-      luaG_runerror(L, "attempt to perform 'n%%0'");
-    return 0;   /* m % -1 == 0; avoid overflow with 0x80000...%-1 */
-  }
-  else {
-    lua_Integer r = m % n;
-    if (r != 0 && (m ^ n) < 0)  /* 'm/n' would be non-integer negative? */
-      r += n;  /* correct result for different rounding */
-    return r;
-  }
-}
-
-
-/* number of bits in an integer */
-#define NBITS	cast_int(sizeof(lua_Integer) * CHAR_BIT)
-
-/*
-** Shift left operation. (Shift right just negates 'y'.)
-*/
-lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) {
-  if (y < 0) {  /* shift right? */
-    if (y <= -NBITS) return 0;
-    else return intop(>>, x, -y);
-  }
-  else {  /* shift left */
-    if (y >= NBITS) return 0;
-    else return intop(<<, x, y);
-  }
-}
-
-
-/*
-** check whether cached closure in prototype 'p' may be reused, that is,
-** whether there is a cached closure with the same upvalues needed by
-** new closure to be created.
-*/
-static LClosure *getcached (Proto *p, UpVal **encup, StkId base) {
-  LClosure *c = p->cache;
-  if (c != NULL) {  /* is there a cached closure? */
-    int nup = p->sizeupvalues;
-    Upvaldesc *uv = p->upvalues;
-    int i;
-    for (i = 0; i < nup; i++) {  /* check whether it has right upvalues */
-      TValue *v = uv[i].instack ? base + uv[i].idx : encup[uv[i].idx]->v;
-      if (c->upvals[i]->v != v)
-        return NULL;  /* wrong upvalue; cannot reuse closure */
-    }
-  }
-  return c;  /* return cached closure (or NULL if no cached closure) */
-}
-
-
-/*
-** create a new Lua closure, push it in the stack, and initialize
-** its upvalues. Note that the closure is not cached if prototype is
-** already black (which means that 'cache' was already cleared by the
-** GC).
-*/
-static void pushclosure (lua_State *L, Proto *p, UpVal **encup, StkId base,
-                         StkId ra) {
-  int nup = p->sizeupvalues;
-  Upvaldesc *uv = p->upvalues;
-  int i;
-  LClosure *ncl = luaF_newLclosure(L, nup);
-  ncl->p = p;
-  setclLvalue(L, ra, ncl);  /* anchor new closure in stack */
-  for (i = 0; i < nup; i++) {  /* fill in its upvalues */
-    if (uv[i].instack)  /* upvalue refers to local variable? */
-      ncl->upvals[i] = luaF_findupval(L, base + uv[i].idx);
-    else  /* get upvalue from enclosing function */
-      ncl->upvals[i] = encup[uv[i].idx];
-    ncl->upvals[i]->refcount++;
-    /* new closure is white, so we do not need a barrier here */
-  }
-  if (!isblack(p))  /* cache will not break GC invariant? */
-    p->cache = ncl;  /* save it on cache for reuse */
-}
-
-
-/*
-** finish execution of an opcode interrupted by an yield
-*/
-void luaV_finishOp (lua_State *L) {
-  CallInfo *ci = L->ci;
-  StkId base = ci->u.l.base;
-  Instruction inst = *(ci->u.l.savedpc - 1);  /* interrupted instruction */
-  OpCode op = GET_OPCODE(inst);
-  switch (op) {  /* finish its execution */
-    case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: case OP_IDIV:
-    case OP_BAND: case OP_BOR: case OP_BXOR: case OP_SHL: case OP_SHR:
-    case OP_MOD: case OP_POW:
-    case OP_UNM: case OP_BNOT: case OP_LEN:
-    case OP_GETTABUP: case OP_GETTABLE: case OP_SELF: {
-      setobjs2s(L, base + GETARG_A(inst), --L->top);
-      break;
-    }
-    case OP_LE: case OP_LT: case OP_EQ: {
-      int res = !l_isfalse(L->top - 1);
-      L->top--;
-      if (ci->callstatus & CIST_LEQ) {  /* "<=" using "<" instead? */
-        lua_assert(op == OP_LE);
-        ci->callstatus ^= CIST_LEQ;  /* clear mark */
-        res = !res;  /* negate result */
-      }
-      lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_JMP);
-      if (res != GETARG_A(inst))  /* condition failed? */
-        ci->u.l.savedpc++;  /* skip jump instruction */
-      break;
-    }
-    case OP_CONCAT: {
-      StkId top = L->top - 1;  /* top when 'luaT_trybinTM' was called */
-      int b = GETARG_B(inst);      /* first element to concatenate */
-      int total = cast_int(top - 1 - (base + b));  /* yet to concatenate */
-      setobj2s(L, top - 2, top);  /* put TM result in proper position */
-      if (total > 1) {  /* are there elements to concat? */
-        L->top = top - 1;  /* top is one after last element (at top-2) */
-        luaV_concat(L, total);  /* concat them (may yield again) */
-      }
-      /* move final result to final position */
-      setobj2s(L, ci->u.l.base + GETARG_A(inst), L->top - 1);
-      L->top = ci->top;  /* restore top */
-      break;
-    }
-    case OP_TFORCALL: {
-      lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_TFORLOOP);
-      L->top = ci->top;  /* correct top */
-      break;
-    }
-    case OP_CALL: {
-      if (GETARG_C(inst) - 1 >= 0)  /* nresults >= 0? */
-        L->top = ci->top;  /* adjust results */
-      break;
-    }
-    case OP_TAILCALL: case OP_SETTABUP: case OP_SETTABLE:
-      break;
-    default: lua_assert(0);
-  }
-}
-
-
-
-
-/*
-** {==================================================================
-** Function 'luaV_execute': main interpreter loop
-** ===================================================================
-*/
-
-
-/*
-** some macros for common tasks in 'luaV_execute'
-*/
-
-
-#define RA(i)	(base+GETARG_A(i))
-#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))
-
-
-/* execute a jump instruction */
-#define dojump(ci,i,e) \
-  { int a = GETARG_A(i); \
-    if (a != 0) luaF_close(L, ci->u.l.base + a - 1); \
-    ci->u.l.savedpc += GETARG_sBx(i) + e; }
-
-/* for test instructions, execute the jump instruction that follows it */
-#define donextjump(ci)	{ i = *ci->u.l.savedpc; dojump(ci, i, 1); }
-
-
-#define Protect(x)	{ {x;}; base = ci->u.l.base; }
-
-#define checkGC(L,c)  \
-	{ luaC_condGC(L, L->top = (c),  /* limit of live values */ \
-                         Protect(L->top = ci->top));  /* restore top */ \
-           luai_threadyield(L); }
-
-
-/* fetch an instruction and prepare its execution */
-#define vmfetch()	{ \
-  i = *(ci->u.l.savedpc++); \
-  if (L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) \
-    Protect(luaG_traceexec(L)); \
-  ra = RA(i); /* WARNING: any stack reallocation invalidates 'ra' */ \
-  lua_assert(base == ci->u.l.base); \
-  lua_assert(base <= L->top && L->top < L->stack + L->stacksize); \
-}
-
-#define vmdispatch(o)	switch(o)
-#define vmcase(l)	case l:
-#define vmbreak		break
-
-
-/*
-** copy of 'luaV_gettable', but protecting the call to potential
-** metamethod (which can reallocate the stack)
-*/
-#define gettableProtected(L,t,k,v)  { const TValue *slot; \
-  if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
-  else Protect(luaV_finishget(L,t,k,v,slot)); }
-
-
-/* same for 'luaV_settable' */
-#define settableProtected(L,t,k,v) { const TValue *slot; \
-  if (!luaV_fastset(L,t,k,slot,luaH_get,v)) \
-    Protect(luaV_finishset(L,t,k,v,slot)); }
-
-
-
-void luaV_execute (lua_State *L) {
-  CallInfo *ci = L->ci;
-  LClosure *cl;
-  TValue *k;
-  StkId base;
-  ci->callstatus |= CIST_FRESH;  /* fresh invocation of 'luaV_execute" */
- newframe:  /* reentry point when frame changes (call/return) */
-  lua_assert(ci == L->ci);
-  cl = clLvalue(ci->func);  /* local reference to function's closure */
-  k = cl->p->k;  /* local reference to function's constant table */
-  base = ci->u.l.base;  /* local copy of function's base */
-  /* main loop of interpreter */
-  for (;;) {
-    Instruction i;
-    StkId ra;
-    vmfetch();
-    vmdispatch (GET_OPCODE(i)) {
-      vmcase(OP_MOVE) {
-        setobjs2s(L, ra, RB(i));
-        vmbreak;
-      }
-      vmcase(OP_LOADK) {
-        TValue *rb = k + GETARG_Bx(i);
-        setobj2s(L, ra, rb);
-        vmbreak;
-      }
-      vmcase(OP_LOADKX) {
-        TValue *rb;
-        lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG);
-        rb = k + GETARG_Ax(*ci->u.l.savedpc++);
-        setobj2s(L, ra, rb);
-        vmbreak;
-      }
-      vmcase(OP_LOADBOOL) {
-        setbvalue(ra, GETARG_B(i));
-        if (GETARG_C(i)) ci->u.l.savedpc++;  /* skip next instruction (if C) */
-        vmbreak;
-      }
-      vmcase(OP_LOADNIL) {
-        int b = GETARG_B(i);
-        do {
-          setnilvalue(ra++);
-        } while (b--);
-        vmbreak;
-      }
-      vmcase(OP_GETUPVAL) {
-        int b = GETARG_B(i);
-        setobj2s(L, ra, cl->upvals[b]->v);
-        vmbreak;
-      }
-      vmcase(OP_GETTABUP) {
-        TValue *upval = cl->upvals[GETARG_B(i)]->v;
-        TValue *rc = RKC(i);
-        gettableProtected(L, upval, rc, ra);
-        vmbreak;
-      }
-      vmcase(OP_GETTABLE) {
-        StkId rb = RB(i);
-        TValue *rc = RKC(i);
-        gettableProtected(L, rb, rc, ra);
-        vmbreak;
-      }
-      vmcase(OP_SETTABUP) {
-        TValue *upval = cl->upvals[GETARG_A(i)]->v;
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        settableProtected(L, upval, rb, rc);
-        vmbreak;
-      }
-      vmcase(OP_SETUPVAL) {
-        UpVal *uv = cl->upvals[GETARG_B(i)];
-        setobj(L, uv->v, ra);
-        luaC_upvalbarrier(L, uv);
-        vmbreak;
-      }
-      vmcase(OP_SETTABLE) {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        settableProtected(L, ra, rb, rc);
-        vmbreak;
-      }
-      vmcase(OP_NEWTABLE) {
-        int b = GETARG_B(i);
-        int c = GETARG_C(i);
-        Table *t = luaH_new(L);
-        sethvalue(L, ra, t);
-        if (b != 0 || c != 0)
-          luaH_resize(L, t, luaO_fb2int(b), luaO_fb2int(c));
-        checkGC(L, ra + 1);
-        vmbreak;
-      }
-      vmcase(OP_SELF) {
-        const TValue *aux;
-        StkId rb = RB(i);
-        TValue *rc = RKC(i);
-        TString *key = tsvalue(rc);  /* key must be a string */
-        setobjs2s(L, ra + 1, rb);
-        if (luaV_fastget(L, rb, key, aux, luaH_getstr)) {
-          setobj2s(L, ra, aux);
-        }
-        else Protect(luaV_finishget(L, rb, rc, ra, aux));
-        vmbreak;
-      }
-      vmcase(OP_ADD) {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        lua_Number nb; lua_Number nc;
-        if (ttisinteger(rb) && ttisinteger(rc)) {
-          lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc);
-          setivalue(ra, intop(+, ib, ic));
-        }
-        else if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          setfltvalue(ra, luai_numadd(L, nb, nc));
-        }
-        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_ADD)); }
-        vmbreak;
-      }
-      vmcase(OP_SUB) {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        lua_Number nb; lua_Number nc;
-        if (ttisinteger(rb) && ttisinteger(rc)) {
-          lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc);
-          setivalue(ra, intop(-, ib, ic));
-        }
-        else if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          setfltvalue(ra, luai_numsub(L, nb, nc));
-        }
-        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SUB)); }
-        vmbreak;
-      }
-      vmcase(OP_MUL) {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        lua_Number nb; lua_Number nc;
-        if (ttisinteger(rb) && ttisinteger(rc)) {
-          lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc);
-          setivalue(ra, intop(*, ib, ic));
-        }
-        else if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          setfltvalue(ra, luai_nummul(L, nb, nc));
-        }
-        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_MUL)); }
-        vmbreak;
-      }
-      vmcase(OP_DIV) {  /* float division (always with floats) */
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        lua_Number nb; lua_Number nc;
-        if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          setfltvalue(ra, luai_numdiv(L, nb, nc));
-        }
-        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_DIV)); }
-        vmbreak;
-      }
-      vmcase(OP_BAND) {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        lua_Integer ib; lua_Integer ic;
-        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
-          setivalue(ra, intop(&, ib, ic));
-        }
-        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BAND)); }
-        vmbreak;
-      }
-      vmcase(OP_BOR) {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        lua_Integer ib; lua_Integer ic;
-        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
-          setivalue(ra, intop(|, ib, ic));
-        }
-        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BOR)); }
-        vmbreak;
-      }
-      vmcase(OP_BXOR) {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        lua_Integer ib; lua_Integer ic;
-        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
-          setivalue(ra, intop(^, ib, ic));
-        }
-        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BXOR)); }
-        vmbreak;
-      }
-      vmcase(OP_SHL) {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        lua_Integer ib; lua_Integer ic;
-        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
-          setivalue(ra, luaV_shiftl(ib, ic));
-        }
-        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SHL)); }
-        vmbreak;
-      }
-      vmcase(OP_SHR) {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        lua_Integer ib; lua_Integer ic;
-        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
-          setivalue(ra, luaV_shiftl(ib, -ic));
-        }
-        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SHR)); }
-        vmbreak;
-      }
-      vmcase(OP_MOD) {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        lua_Number nb; lua_Number nc;
-        if (ttisinteger(rb) && ttisinteger(rc)) {
-          lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc);
-          setivalue(ra, luaV_mod(L, ib, ic));
-        }
-        else if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          lua_Number m;
-          luai_nummod(L, nb, nc, m);
-          setfltvalue(ra, m);
-        }
-        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_MOD)); }
-        vmbreak;
-      }
-      vmcase(OP_IDIV) {  /* floor division */
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        lua_Number nb; lua_Number nc;
-        if (ttisinteger(rb) && ttisinteger(rc)) {
-          lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc);
-          setivalue(ra, luaV_div(L, ib, ic));
-        }
-        else if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          setfltvalue(ra, luai_numidiv(L, nb, nc));
-        }
-        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_IDIV)); }
-        vmbreak;
-      }
-      vmcase(OP_POW) {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        lua_Number nb; lua_Number nc;
-        if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          setfltvalue(ra, luai_numpow(L, nb, nc));
-        }
-        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_POW)); }
-        vmbreak;
-      }
-      vmcase(OP_UNM) {
-        TValue *rb = RB(i);
-        lua_Number nb;
-        if (ttisinteger(rb)) {
-          lua_Integer ib = ivalue(rb);
-          setivalue(ra, intop(-, 0, ib));
-        }
-        else if (tonumber(rb, &nb)) {
-          setfltvalue(ra, luai_numunm(L, nb));
-        }
-        else {
-          Protect(luaT_trybinTM(L, rb, rb, ra, TM_UNM));
-        }
-        vmbreak;
-      }
-      vmcase(OP_BNOT) {
-        TValue *rb = RB(i);
-        lua_Integer ib;
-        if (tointeger(rb, &ib)) {
-          setivalue(ra, intop(^, ~l_castS2U(0), ib));
-        }
-        else {
-          Protect(luaT_trybinTM(L, rb, rb, ra, TM_BNOT));
-        }
-        vmbreak;
-      }
-      vmcase(OP_NOT) {
-        TValue *rb = RB(i);
-        int res = l_isfalse(rb);  /* next assignment may change this value */
-        setbvalue(ra, res);
-        vmbreak;
-      }
-      vmcase(OP_LEN) {
-        Protect(luaV_objlen(L, ra, RB(i)));
-        vmbreak;
-      }
-      vmcase(OP_CONCAT) {
-        int b = GETARG_B(i);
-        int c = GETARG_C(i);
-        StkId rb;
-        L->top = base + c + 1;  /* mark the end of concat operands */
-        Protect(luaV_concat(L, c - b + 1));
-        ra = RA(i);  /* 'luaV_concat' may invoke TMs and move the stack */
-        rb = base + b;
-        setobjs2s(L, ra, rb);
-        checkGC(L, (ra >= rb ? ra + 1 : rb));
-        L->top = ci->top;  /* restore top */
-        vmbreak;
-      }
-      vmcase(OP_JMP) {
-        dojump(ci, i, 0);
-        vmbreak;
-      }
-      vmcase(OP_EQ) {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        Protect(
-          if (luaV_equalobj(L, rb, rc) != GETARG_A(i))
-            ci->u.l.savedpc++;
-          else
-            donextjump(ci);
-        )
-        vmbreak;
-      }
-      vmcase(OP_LT) {
-        Protect(
-          if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i))
-            ci->u.l.savedpc++;
-          else
-            donextjump(ci);
-        )
-        vmbreak;
-      }
-      vmcase(OP_LE) {
-        Protect(
-          if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i))
-            ci->u.l.savedpc++;
-          else
-            donextjump(ci);
-        )
-        vmbreak;
-      }
-      vmcase(OP_TEST) {
-        if (GETARG_C(i) ? l_isfalse(ra) : !l_isfalse(ra))
-            ci->u.l.savedpc++;
-          else
-          donextjump(ci);
-        vmbreak;
-      }
-      vmcase(OP_TESTSET) {
-        TValue *rb = RB(i);
-        if (GETARG_C(i) ? l_isfalse(rb) : !l_isfalse(rb))
-          ci->u.l.savedpc++;
-        else {
-          setobjs2s(L, ra, rb);
-          donextjump(ci);
-        }
-        vmbreak;
-      }
-      vmcase(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 */
-        if (luaD_precall(L, ra, nresults)) {  /* C function? */
-          if (nresults >= 0)
-            L->top = ci->top;  /* adjust results */
-          Protect((void)0);  /* update 'base' */
-        }
-        else {  /* Lua function */
-          ci = L->ci;
-          goto newframe;  /* restart luaV_execute over new Lua function */
-        }
-        vmbreak;
-      }
-      vmcase(OP_TAILCALL) {
-        int b = GETARG_B(i);
-        if (b != 0) L->top = ra+b;  /* else previous instruction set top */
-        lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);
-        if (luaD_precall(L, ra, LUA_MULTRET)) {  /* C function? */
-          Protect((void)0);  /* update 'base' */
-        }
-        else {
-          /* tail call: put called frame (n) in place of caller one (o) */
-          CallInfo *nci = L->ci;  /* called frame */
-          CallInfo *oci = nci->previous;  /* caller frame */
-          StkId nfunc = nci->func;  /* called function */
-          StkId ofunc = oci->func;  /* caller function */
-          /* last stack slot filled by 'precall' */
-          StkId lim = nci->u.l.base + getproto(nfunc)->numparams;
-          int aux;
-          /* close all upvalues from previous call */
-          if (cl->p->sizep > 0) luaF_close(L, oci->u.l.base);
-          /* move new frame into old one */
-          for (aux = 0; nfunc + aux < lim; aux++)
-            setobjs2s(L, ofunc + aux, nfunc + aux);
-          oci->u.l.base = ofunc + (nci->u.l.base - nfunc);  /* correct base */
-          oci->top = L->top = ofunc + (L->top - nfunc);  /* correct top */
-          oci->u.l.savedpc = nci->u.l.savedpc;
-          oci->callstatus |= CIST_TAIL;  /* function was tail called */
-          ci = L->ci = oci;  /* remove new frame */
-          lua_assert(L->top == oci->u.l.base + getproto(ofunc)->maxstacksize);
-          goto newframe;  /* restart luaV_execute over new Lua function */
-        }
-        vmbreak;
-      }
-      vmcase(OP_RETURN) {
-        int b = GETARG_B(i);
-        if (cl->p->sizep > 0) luaF_close(L, base);
-        b = luaD_poscall(L, ci, ra, (b != 0 ? b - 1 : cast_int(L->top - ra)));
-        if (ci->callstatus & CIST_FRESH)  /* local 'ci' still from callee */
-          return;  /* external invocation: return */
-        else {  /* invocation via reentry: continue execution */
-          ci = L->ci;
-          if (b) L->top = ci->top;
-          lua_assert(isLua(ci));
-          lua_assert(GET_OPCODE(*((ci)->u.l.savedpc - 1)) == OP_CALL);
-          goto newframe;  /* restart luaV_execute over new Lua function */
-        }
-      }
-      vmcase(OP_FORLOOP) {
-        if (ttisinteger(ra)) {  /* integer loop? */
-          lua_Integer step = ivalue(ra + 2);
-          lua_Integer idx = intop(+, ivalue(ra), step); /* increment index */
-          lua_Integer limit = ivalue(ra + 1);
-          if ((0 < step) ? (idx <= limit) : (limit <= idx)) {
-            ci->u.l.savedpc += GETARG_sBx(i);  /* jump back */
-            chgivalue(ra, idx);  /* update internal index... */
-            setivalue(ra + 3, idx);  /* ...and external index */
-          }
-        }
-        else {  /* floating loop */
-          lua_Number step = fltvalue(ra + 2);
-          lua_Number idx = luai_numadd(L, fltvalue(ra), step); /* inc. index */
-          lua_Number limit = fltvalue(ra + 1);
-          if (luai_numlt(0, step) ? luai_numle(idx, limit)
-                                  : luai_numle(limit, idx)) {
-            ci->u.l.savedpc += GETARG_sBx(i);  /* jump back */
-            chgfltvalue(ra, idx);  /* update internal index... */
-            setfltvalue(ra + 3, idx);  /* ...and external index */
-          }
-        }
-        vmbreak;
-      }
-      vmcase(OP_FORPREP) {
-        TValue *init = ra;
-        TValue *plimit = ra + 1;
-        TValue *pstep = ra + 2;
-        lua_Integer ilimit;
-        int stopnow;
-        if (ttisinteger(init) && ttisinteger(pstep) &&
-            forlimit(plimit, &ilimit, ivalue(pstep), &stopnow)) {
-          /* all values are integer */
-          lua_Integer initv = (stopnow ? 0 : ivalue(init));
-          setivalue(plimit, ilimit);
-          setivalue(init, intop(-, initv, ivalue(pstep)));
-        }
-        else {  /* try making all values floats */
-          lua_Number ninit; lua_Number nlimit; lua_Number nstep;
-          if (!tonumber(plimit, &nlimit))
-            luaG_runerror(L, "'for' limit must be a number");
-          setfltvalue(plimit, nlimit);
-          if (!tonumber(pstep, &nstep))
-            luaG_runerror(L, "'for' step must be a number");
-          setfltvalue(pstep, nstep);
-          if (!tonumber(init, &ninit))
-            luaG_runerror(L, "'for' initial value must be a number");
-          setfltvalue(init, luai_numsub(L, ninit, nstep));
-        }
-        ci->u.l.savedpc += GETARG_sBx(i);
-        vmbreak;
-      }
-      vmcase(OP_TFORCALL) {
-        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 = ci->top;
-        i = *(ci->u.l.savedpc++);  /* go to next instruction */
-        ra = RA(i);
-        lua_assert(GET_OPCODE(i) == OP_TFORLOOP);
-        goto l_tforloop;
-      }
-      vmcase(OP_TFORLOOP) {
-        l_tforloop:
-        if (!ttisnil(ra + 1)) {  /* continue loop? */
-          setobjs2s(L, ra, ra + 1);  /* save control variable */
-           ci->u.l.savedpc += GETARG_sBx(i);  /* jump back */
-        }
-        vmbreak;
-      }
-      vmcase(OP_SETLIST) {
-        int n = GETARG_B(i);
-        int c = GETARG_C(i);
-        unsigned int last;
-        Table *h;
-        if (n == 0) n = cast_int(L->top - ra) - 1;
-        if (c == 0) {
-          lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG);
-          c = GETARG_Ax(*ci->u.l.savedpc++);
-        }
-        h = hvalue(ra);
-        last = ((c-1)*LFIELDS_PER_FLUSH) + n;
-        if (last > h->sizearray)  /* needs more space? */
-          luaH_resizearray(L, h, last);  /* preallocate it at once */
-        for (; n > 0; n--) {
-          TValue *val = ra+n;
-          luaH_setint(L, h, last--, val);
-          luaC_barrierback(L, h, val);
-        }
-        L->top = ci->top;  /* correct top (in case of previous open call) */
-        vmbreak;
-      }
-      vmcase(OP_CLOSURE) {
-        Proto *p = cl->p->p[GETARG_Bx(i)];
-        LClosure *ncl = getcached(p, cl->upvals, base);  /* cached closure */
-        if (ncl == NULL)  /* no match? */
-          pushclosure(L, p, cl->upvals, base, ra);  /* create a new one */
-        else
-          setclLvalue(L, ra, ncl);  /* push cashed closure */
-        checkGC(L, ra + 1);
-        vmbreak;
-      }
-      vmcase(OP_VARARG) {
-        int b = GETARG_B(i) - 1;  /* required results */
-        int j;
-        int n = cast_int(base - ci->func) - cl->p->numparams - 1;
-        if (n < 0)  /* less arguments than parameters? */
-          n = 0;  /* no vararg arguments */
-        if (b < 0) {  /* B == 0? */
-          b = n;  /* get all var. arguments */
-          Protect(luaD_checkstack(L, n));
-          ra = RA(i);  /* previous call may change the stack */
-          L->top = ra + n;
-        }
-        for (j = 0; j < b && j < n; j++)
-          setobjs2s(L, ra + j, base - n + j);
-        for (; j < b; j++)  /* complete required results with nil */
-          setnilvalue(ra + j);
-        vmbreak;
-      }
-      vmcase(OP_EXTRAARG) {
-        lua_assert(0);
-        vmbreak;
-      }
-    }
-  }
-}
-
-/* }================================================================== */
-
diff --git a/lua/lua-5.3.5/src/lvm.h b/lua/lua-5.3.5/src/lvm.h
deleted file mode 100644
index a8f954f..0000000
--- a/lua/lua-5.3.5/src/lvm.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-** $Id: lvm.h,v 2.41.1.1 2017/04/19 17:20:42 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"
-
-
-#if !defined(LUA_NOCVTN2S)
-#define cvt2str(o)	ttisnumber(o)
-#else
-#define cvt2str(o)	0	/* no conversion from numbers to strings */
-#endif
-
-
-#if !defined(LUA_NOCVTS2N)
-#define cvt2num(o)	ttisstring(o)
-#else
-#define cvt2num(o)	0	/* no conversion from strings to numbers */
-#endif
-
-
-/*
-** You can define LUA_FLOORN2I if you want to convert floats to integers
-** by flooring them (instead of raising an error if they are not
-** integral values)
-*/
-#if !defined(LUA_FLOORN2I)
-#define LUA_FLOORN2I		0
-#endif
-
-
-#define tonumber(o,n) \
-	(ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n))
-
-#define tointeger(o,i) \
-    (ttisinteger(o) ? (*(i) = ivalue(o), 1) : luaV_tointeger(o,i,LUA_FLOORN2I))
-
-#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2))
-
-#define luaV_rawequalobj(t1,t2)		luaV_equalobj(NULL,t1,t2)
-
-
-/*
-** fast track for 'gettable': if 't' is a table and 't[k]' is not nil,
-** return 1 with 'slot' pointing to 't[k]' (final result).  Otherwise,
-** return 0 (meaning it will have to check metamethod) with 'slot'
-** pointing to a nil 't[k]' (if 't' is a table) or NULL (otherwise).
-** 'f' is the raw get function to use.
-*/
-#define luaV_fastget(L,t,k,slot,f) \
-  (!ttistable(t)  \
-   ? (slot = NULL, 0)  /* not a table; 'slot' is NULL and result is 0 */  \
-   : (slot = f(hvalue(t), k),  /* else, do raw access */  \
-      !ttisnil(slot)))  /* result not nil? */
-
-/*
-** standard implementation for 'gettable'
-*/
-#define luaV_gettable(L,t,k,v) { const TValue *slot; \
-  if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
-  else luaV_finishget(L,t,k,v,slot); }
-
-
-/*
-** Fast track for set table. If 't' is a table and 't[k]' is not nil,
-** call GC barrier, do a raw 't[k]=v', and return true; otherwise,
-** return false with 'slot' equal to NULL (if 't' is not a table) or
-** 'nil'. (This is needed by 'luaV_finishget'.) Note that, if the macro
-** returns true, there is no need to 'invalidateTMcache', because the
-** call is not creating a new entry.
-*/
-#define luaV_fastset(L,t,k,slot,f,v) \
-  (!ttistable(t) \
-   ? (slot = NULL, 0) \
-   : (slot = f(hvalue(t), k), \
-     ttisnil(slot) ? 0 \
-     : (luaC_barrierback(L, hvalue(t), v), \
-        setobj2t(L, cast(TValue *,slot), v), \
-        1)))
-
-
-#define luaV_settable(L,t,k,v) { const TValue *slot; \
-  if (!luaV_fastset(L,t,k,slot,luaH_get,v)) \
-    luaV_finishset(L,t,k,v,slot); }
-
-
-
-LUAI_FUNC int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2);
-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_tonumber_ (const TValue *obj, lua_Number *n);
-LUAI_FUNC int luaV_tointeger (const TValue *obj, lua_Integer *p, int mode);
-LUAI_FUNC void luaV_finishget (lua_State *L, const TValue *t, TValue *key,
-                               StkId val, const TValue *slot);
-LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
-                               StkId val, const TValue *slot);
-LUAI_FUNC void luaV_finishOp (lua_State *L);
-LUAI_FUNC void luaV_execute (lua_State *L);
-LUAI_FUNC void luaV_concat (lua_State *L, int total);
-LUAI_FUNC lua_Integer luaV_div (lua_State *L, lua_Integer x, lua_Integer y);
-LUAI_FUNC lua_Integer luaV_mod (lua_State *L, lua_Integer x, lua_Integer y);
-LUAI_FUNC lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y);
-LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb);
-
-#endif
diff --git a/lua/lua-5.3.5/src/lzio.c b/lua/lua-5.3.5/src/lzio.c
deleted file mode 100644
index 6f79094..0000000
--- a/lua/lua-5.3.5/src/lzio.c
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-** $Id: lzio.c,v 1.37.1.1 2017/04/19 17:20:42 roberto Exp $
-** Buffered streams
-** See Copyright Notice in lua.h
-*/
-
-#define lzio_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <string.h>
-
-#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;  /* discount char being returned */
-  z->p = buff;
-  return cast_uchar(*(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 (z->n == 0) {  /* no bytes in buffer? */
-      if (luaZ_fill(z) == EOZ)  /* try to read more */
-        return n;  /* no more input; return number of missing bytes */
-      else {
-        z->n++;  /* luaZ_fill consumed first byte; put it back */
-        z->p--;
-      }
-    }
-    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;
-}
-
diff --git a/lua/lua-5.3.5/src/lzio.h b/lua/lua-5.3.5/src/lzio.h
deleted file mode 100644
index d897870..0000000
--- a/lua/lua-5.3.5/src/lzio.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-** $Id: lzio.h,v 1.31.1.1 2017/04/19 17:20:42 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 zgetc(z)  (((z)->n--)>0 ?  cast_uchar(*(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_buffremove(buff,i)	((buff)->n -= (i))
-#define luaZ_resetbuffer(buff) ((buff)->n = 0)
-
-
-#define luaZ_resizebuffer(L, buff, size) \
-	((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \
-				(buff)->buffsize, size), \
-	(buff)->buffsize = size)
-
-#define luaZ_freebuffer(L, buff)	luaZ_resizebuffer(L, buff, 0)
-
-
-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 */
-
-
-
-/* --------- Private Part ------------------ */
-
-struct Zio {
-  size_t n;			/* bytes still unread */
-  const char *p;		/* current position in buffer */
-  lua_Reader reader;		/* reader function */
-  void *data;			/* additional data */
-  lua_State *L;			/* Lua state (for reader) */
-};
-
-
-LUAI_FUNC int luaZ_fill (ZIO *z);
-
-#endif
diff --git a/lua/lua-5.3.5/src/opcode/arithmetic2.lua b/lua/lua-5.3.5/src/opcode/arithmetic2.lua
deleted file mode 100644
index 9fe39ca..0000000
--- a/lua/lua-5.3.5/src/opcode/arithmetic2.lua
+++ /dev/null
@@ -1,15 +0,0 @@
-
--- name 	args		desc
--- OP_UNM	A B 		R(A):=-R(B)
--- OP_NOT	A B 		R(A):=notR(B)
--- 
--- 在编译或指令生成阶段，一元，二元操作符表达式的常量表达式折叠优化
--- const expression folding
--- 即直接计算结果，不生成相应的指令
---
-
-local a = 1;
-local b = not a;
-local c = -a;
-local d = 1 + 1;
-local e = not 1;
diff --git a/lua/lua-5.3.5/src/opcode/arithmetic3.lua b/lua/lua-5.3.5/src/opcode/arithmetic3.lua
deleted file mode 100644
index c1efe23..0000000
--- a/lua/lua-5.3.5/src/opcode/arithmetic3.lua
+++ /dev/null
@@ -1,18 +0,0 @@
-
--- name 	args		desc
--- 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)
--- 
-
-local a = 1;
-a = a + 1;
-a = a - 1;
-a = a * 1;
-a = a / 1;
-a = a % 1;
-a = a ^ 1;
-
diff --git a/lua/lua-5.3.5/src/opcode/call.lua b/lua/lua-5.3.5/src/opcode/call.lua
deleted file mode 100644
index ae4867d..0000000
--- a/lua/lua-5.3.5/src/opcode/call.lua
+++ /dev/null
@@ -1,15 +0,0 @@
-
--- name 	args		desc
--- OP_CALL	A B C 		R(A),...,R(A+C-2):=R(A)(R(A+1),...,R(A+B-1))
--- 寄存器A时函数对象， 所有参数的按顺序放置在寄存器A后面的寄存器中
--- B-1表示参数个数，如果参数列表的最后一个表达式是变长的，B会置0，
--- 表示使用A+1到当前栈顶作为参数
---
--- 函数返回值会按顺序放在从寄存器开始的C-1个寄存器中
--- 如果C为0，表示返回值的个数由函数决定
--- 
-
-f();
-local t = {f(...)};
-
-
diff --git a/lua/lua-5.3.5/src/opcode/call.tail.lua b/lua/lua-5.3.5/src/opcode/call.tail.lua
deleted file mode 100644
index 5396249..0000000
--- a/lua/lua-5.3.5/src/opcode/call.tail.lua
+++ /dev/null
@@ -1,8 +0,0 @@
-
--- name 	args		desc
--- OP_TAILCALL	A B C 		return R(A)(R(A+1),...,R(A+B-1))
--- 与Call一样，C永远为0，
--- tailcall只对lua closure进行处理，对c closure与call没区别
-
-return f();
-
diff --git a/lua/lua-5.3.5/src/opcode/closure.lua b/lua/lua-5.3.5/src/opcode/closure.lua
deleted file mode 100644
index 7dbc7fa..0000000
--- a/lua/lua-5.3.5/src/opcode/closure.lua
+++ /dev/null
@@ -1,10 +0,0 @@
-
--- name 	    args		desc
--- OP_CLOSURE	A Bx 		R(A):=closure(KPROTO[Bx])
--- 为指定的函数prototype创建一个closure，并将这个closure保存到寄存器A中
--- Bx是函数prototype的id
---
-
-local function f()
-end
-
diff --git a/lua/lua-5.3.5/src/opcode/concat.lua b/lua/lua-5.3.5/src/opcode/concat.lua
deleted file mode 100644
index aacd2a8..0000000
--- a/lua/lua-5.3.5/src/opcode/concat.lua
+++ /dev/null
@@ -1,9 +0,0 @@
-
--- name 	args		desc
--- OP_CONCAT	A B C 		R(A):=R(B).. ... ..R(C)
--- 将B和C指定范围的字符串按顺序连接到一起，将结果存入到A中
--- 
-
-local a = "foo".."boo".."eoo";
-
-
diff --git a/lua/lua-5.3.5/src/opcode/for.generic.lua b/lua/lua-5.3.5/src/opcode/for.generic.lua
deleted file mode 100644
index 63396ee..0000000
--- a/lua/lua-5.3.5/src/opcode/for.generic.lua
+++ /dev/null
@@ -1,10 +0,0 @@
-
--- name 	    args		desc
--- OP_TFORCALL 	A C 		R(A+3),...,R(A+2+C):=R(A)(R(A+1),R(A+2))
--- OP_TFORLOOP 	A sBx 		if R(A+1)~=nil then {R(A)=R(A+1);pc+=sBx;}
---
-
-for i,v in 1,2,3 do
-    a = 1;
-end
-
diff --git a/lua/lua-5.3.5/src/opcode/for.lua b/lua/lua-5.3.5/src/opcode/for.lua
deleted file mode 100644
index 3940a8a..0000000
--- a/lua/lua-5.3.5/src/opcode/for.lua
+++ /dev/null
@@ -1,14 +0,0 @@
-
--- name 	    args		desc
--- OP_FORLOOP  	A sBx 		R(A)+=R(A+2);if (R(A)<?=R(A+1) then {pc+=sBx; R(A+3)=R(A)}
--- OP_FORPERP  	A sBx 		R(A)-=R(A+2);pc+=sBx;
--- 循环环分两类numeric和generic
--- 对使用者不可见的是FORPERP， 用于准备循环，生成for index, for limit, for step,
--- 局部变量i不是循环计数器，它只是初始值
---
-
-local a;
-for i = 1, 10 do 
-    a = i;
-end
-
diff --git a/lua/lua-5.3.5/src/opcode/jmp.lua b/lua/lua-5.3.5/src/opcode/jmp.lua
deleted file mode 100644
index 868853a..0000000
--- a/lua/lua-5.3.5/src/opcode/jmp.lua
+++ /dev/null
@@ -1,17 +0,0 @@
-
--- name 	    args		desc
--- OP_JMP     	A sBx 		pc+=sBx;if(A) close all upvalues >= R(A)+1
--- 跳转指令，sBx表示偏移量，被加在当前指令的下一条指令上
--- sBx为0，表示不跳转，为1表示跳转到下一条指令，-1表示重新执行当前指令
--- A>0，表示需要关闭所有从寄存器A+1开始的所有local变量，只对UpValue有效
---
-
-::label::
-goto label;
-
-do 
-    local a;
-    function f() a = 1 end
-end
-
-
diff --git a/lua/lua-5.3.5/src/opcode/len.lua b/lua/lua-5.3.5/src/opcode/len.lua
deleted file mode 100644
index 23f36f7..0000000
--- a/lua/lua-5.3.5/src/opcode/len.lua
+++ /dev/null
@@ -1,9 +0,0 @@
-
--- name 	args		desc
--- OP_LEN	A B 		R(A):=length of R(B)
--- 运算符#，返回对象B的长度，保存到A中
--- 
-
-local a = #"foo";
-
-
diff --git a/lua/lua-5.3.5/src/opcode/list.lua b/lua/lua-5.3.5/src/opcode/list.lua
deleted file mode 100644
index 0d14687..0000000
--- a/lua/lua-5.3.5/src/opcode/list.lua
+++ /dev/null
@@ -1,14 +0,0 @@
-
--- name 	args		desc
--- OP_SETLIST	A B C 		R(A)[(C-1)*FPF+i]:=R(A+i),1<=i<=B
--- 配合NEWTABLE来使用，初始化表的数组部分使用的
--- A为table的寄存器的位置，SETLIST将A紧接着的寄存器列表(1--B)
--- 中的值逐个设置给表的数组部分
--- C为是一个段值，数组很大时，会存储在多个段中，
--- 在lopcodes.h中定义了LFIELDS_PER_FLUSH每段中存储的数量
--- 如果超出C的表示范围，C会置0，会生成一个EXTRAARG指令，用Ax存储数量
---
--- 
-
-local a = {1, 1, 1};
-
diff --git a/lua/lua-5.3.5/src/opcode/loadbool.lua b/lua/lua-5.3.5/src/opcode/loadbool.lua
deleted file mode 100644
index 4e0f11e..0000000
--- a/lua/lua-5.3.5/src/opcode/loadbool.lua
+++ /dev/null
@@ -1,33 +0,0 @@
-
--- name 	args		desc
--- OP_LOADBOOL	A B C 		R(A):=(Bool)B; if (C) pc++
--- 将B的Boolean值装载到寄存器A中，B使用0表示false，1表示true，
--- C也是一个Boolean值，如果C为true，跳过下一个指令
--- 
-
-local a = true;
-local b = 1 < 2;
---[[
--- 直接上会认为是先得出 1 < 2 的Boolean值，再赋值给b，
--- 实际上的逻辑是
---
--- 1  [1] LT 		1 -1 -2 ; 1 2
--- 2  [1] JMP		0 1	; to 4
--- 3  [1] LOADBOOL	0 0 1
--- 4  [1] LOADBOOL	0 1 0
--- 5  [1] RETURN 	0 1
--- constants (2) for xxx:
--- 1	1
--- 2 	2
--- 注意到，3和4的指令的作用，如果小于直接跳到4， 如果大于执行3，且跳过下一条指令4
--- 逻辑或关系表达式时故意设计成这样的，是优化了if或循环语句，
---   不用求出值后再判断跳转路径，而是计算过程中就开始跳转，节省很多指令
--- 伪码为
--- local a;
--- if 1 < 2 then
--- 	a = true;
--- else 
--- 	a = false;
--- end
--- 
---]]
diff --git a/lua/lua-5.3.5/src/opcode/loadk.lua b/lua/lua-5.3.5/src/opcode/loadk.lua
deleted file mode 100644
index a54e148..0000000
--- a/lua/lua-5.3.5/src/opcode/loadk.lua
+++ /dev/null
@@ -1,10 +0,0 @@
-
--- name 	args		desc
--- OP_LOADK	A Bx 		R(A):=Kst(Bx)
--- 将Bx表示的常量表中的常量值装载到寄存器A中
--- 
-
-local a = 1;
-local b = "foo";
-
-
diff --git a/lua/lua-5.3.5/src/opcode/loadkx.lua b/lua/lua-5.3.5/src/opcode/loadkx.lua
deleted file mode 100644
index c9661a4..0000000
--- a/lua/lua-5.3.5/src/opcode/loadkx.lua
+++ /dev/null
@@ -1,10 +0,0 @@
-
--- name 	args		desc
--- OP_LOADKx	A 		R(A):=Kst(extra arg)
--- 当生成指令LOADK时，如果索引常量的id超出Bx的范围，262143时，
--- 将生成一个LOADKX指令来取代LOADK，接着继续生成一个EXTRAARG指令
--- 并用Ax来存放这个id
--- 
-
-
-
diff --git a/lua/lua-5.3.5/src/opcode/loadnil.lua b/lua/lua-5.3.5/src/opcode/loadnil.lua
deleted file mode 100644
index d31cf9e..0000000
--- a/lua/lua-5.3.5/src/opcode/loadnil.lua
+++ /dev/null
@@ -1,11 +0,0 @@
-
--- name 	args		desc
--- OP_LOADNIL	A B 		R(A),R(A+1),...,R(A+B):=nil
--- 将A到B范围内的寄存器赋值为nil
--- 
-
-local a,b,c;
-local x;
-local y = 0;
-local z;
-
diff --git a/lua/lua-5.3.5/src/opcode/luac.out b/lua/lua-5.3.5/src/opcode/luac.out
deleted file mode 100644
index c2614913e9bb8d98eb6634f1227beb7b06bfb921..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 277
zcmb34DNPJ!ketlRCB?<U!NS2&5ypT38s!d*f(~i<MSAI}d8tL2$$B}ZiEwE~HVz=0
z5r`cf7#JEG7#QRj7#cVj4m4^4*{c}-*Q+r!Ft7mSg+YoyK$r<aGYB(787xeRAW4V<
zka_HA7+H)HD8~xK0vbR!DS+LSSdw3)2{H_%j|VJXT#{Il3K!!8izVmhl@#UYz(tud
ULGA*X#Z(4kf!x3v@9Gx@0Eyos*#H0l

diff --git a/lua/lua-5.3.5/src/opcode/move.lua b/lua/lua-5.3.5/src/opcode/move.lua
deleted file mode 100644
index d9537f2..0000000
--- a/lua/lua-5.3.5/src/opcode/move.lua
+++ /dev/null
@@ -1,10 +0,0 @@
-
--- name 	args		desc
--- OP_MOVE	A B 		R(A):=R(B)
--- 将寄存器B中的值拷贝到寄存器A中
--- 
-
-local a;
-local b = a;
-
-
diff --git a/lua/lua-5.3.5/src/opcode/return.lua b/lua/lua-5.3.5/src/opcode/return.lua
deleted file mode 100644
index 8f0db6f..0000000
--- a/lua/lua-5.3.5/src/opcode/return.lua
+++ /dev/null
@@ -1,11 +0,0 @@
-
--- name 	args		desc
--- OP_RETURN	A B 		return R(A),...,R(A+B-2)
--- 将返回结果存放在寄存器A到A+B-2中，
--- 如果返回为变长表达式，B为0，表示寄存器A到当前栈顶的所有值返回
--- 
-
---return 1;
-
-return ...;
-
diff --git a/lua/lua-5.3.5/src/opcode/self.lua b/lua/lua-5.3.5/src/opcode/self.lua
deleted file mode 100644
index baf0abb..0000000
--- a/lua/lua-5.3.5/src/opcode/self.lua
+++ /dev/null
@@ -1,15 +0,0 @@
-
--- name 	    args		desc
--- OP_SELF  	A B C 		R(A+1):=R(B); R(A) = R(B)[RK(C)]
--- 运算符 : ，从寄存器B表示的table中，取出C作为key的closure，存入寄存器A中
--- 再将table自己存入到寄存器A+1中，为调用closure做准备
---
--- 运算符:是一个优化的操作，比起常规的表达式要少一个指令
---
-
-a:b();
-
--- equal to 
-
-a.b(a);
-
diff --git a/lua/lua-5.3.5/src/opcode/table.lua b/lua/lua-5.3.5/src/opcode/table.lua
deleted file mode 100644
index e285c2a..0000000
--- a/lua/lua-5.3.5/src/opcode/table.lua
+++ /dev/null
@@ -1,12 +0,0 @@
-
--- name 	args		desc
--- OP_NEWTABLE	A B C 		R(A):={}(size=B,C)
--- 在寄存器A处创建一个table对象，B和C分别用来存储table的数组部分和hash部分的初始大小
--- 初始大小是在编译期计算出来并生成到这个指令中的，避免table填充数据时造成rehash问题
--- B和C使用 floating point byte来表示成(eeeeexxx)的二进制形式
--- 其实际值为(1xxx)*2^(eeeee-1)
--- 
-
-local a = {};
-local b = {a};
-
diff --git a/lua/lua-5.3.5/src/opcode/table.set.get.lua b/lua/lua-5.3.5/src/opcode/table.set.get.lua
deleted file mode 100644
index 1c1d28a..0000000
--- a/lua/lua-5.3.5/src/opcode/table.set.get.lua
+++ /dev/null
@@ -1,10 +0,0 @@
-
--- name 	args		desc
--- OP_GETTABLE	A B C 		R(A):=R(B)[RK(C)]
--- OP_SETTABLE  A B C		R(A)[RK(B)]:=RK(C)
--- 
-
-local a = {};
-a.x = 1;
-local b = a.x;
-
diff --git a/lua/lua-5.3.5/src/opcode/test.logic.lua b/lua/lua-5.3.5/src/opcode/test.logic.lua
deleted file mode 100644
index 5f1df3d..0000000
--- a/lua/lua-5.3.5/src/opcode/test.logic.lua
+++ /dev/null
@@ -1,11 +0,0 @@
-
--- name 	    args		desc
--- 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++
--- test是testset的简化版，不需要赋值操作
--- 用于逻辑 and和or
---
-
-local a,b,c;
-a = b and c;
-
diff --git a/lua/lua-5.3.5/src/opcode/test.lua b/lua/lua-5.3.5/src/opcode/test.lua
deleted file mode 100644
index f5df028..0000000
--- a/lua/lua-5.3.5/src/opcode/test.lua
+++ /dev/null
@@ -1,17 +0,0 @@
-
--- name 	    args		desc
--- 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++
--- 关系指令
--- 常与JMP指令配合使用，实现程序的跳转指令
--- test指令与jmp配合使用时，都会接着生成两个分支的指令区域
--- true的指令与false的指令
--- 当为true时，pc++，跳过后面的JMP指令，继续执行
--- 当为false时，执行JMP指令，跳转到false的指令区域
--- 
---
-
-local a,b,c;
-a = b < c;
-
diff --git a/lua/lua-5.3.5/src/opcode/upvalue.global.lua b/lua/lua-5.3.5/src/opcode/upvalue.global.lua
deleted file mode 100644
index fd5b002..0000000
--- a/lua/lua-5.3.5/src/opcode/upvalue.global.lua
+++ /dev/null
@@ -1,26 +0,0 @@
-
---[[
--- 访问变量a的顺序
--- 1. a是当前函数的local变量
--- 2. a是外层函数的local变量，那么a是当前函数的upvalue
--- 3. a是全局变量
---]]
--- 
--- name 	args		desc
--- OP_GETUPVAL	A B C 		R(A):=UpValue[B]
--- OP_SETUPVAL  A B 		UpValue[B]:=R(A)
--- OP_GETTABUP	A B C		R(A):=UpValue[B][RK(C)]
--- OP_SETTABUP  A B C 		UpValue[A][RK(B)]:=RK(C)
--- 将Bx表示的常量表中的常量值装载到寄存器A中
--- 
-
-local a = 0;
-function f()
-	local loc;
-	a   = 1;
-	loc = a;
-	g   = 1;
-	loc = g;
-end
-
-
diff --git a/lua/lua-5.3.5/src/opcode/vararg.lua b/lua/lua-5.3.5/src/opcode/vararg.lua
deleted file mode 100644
index 6639293..0000000
--- a/lua/lua-5.3.5/src/opcode/vararg.lua
+++ /dev/null
@@ -1,11 +0,0 @@
-
--- name 	    args		desc
--- OP_VARARG	A B 		R(A),R(A+1),...,R(A+B-2):=vararg
--- vararg是运算符...，将B-1个参数拷贝到从寄存器A开始的后续寄存器
--- 如果不足，nil补充，如果B为0，表示拷贝实际的参数数量
---
-
-local a = ...;
-
-f(...);
-
diff --git a/lua/lua-5.3.5/src/test/c-call-lua.c b/lua/lua-5.3.5/src/test/c-call-lua.c
deleted file mode 100644
index c157f28..0000000
--- a/lua/lua-5.3.5/src/test/c-call-lua.c
+++ /dev/null
@@ -1,37 +0,0 @@
-
-#include <stdio.h>
-#include <unistd.h>
-#include <lua.h>
-#include <lauxlib.h>
-#include <lualib.h>
-
-int main(int argc, const char **argv)
-{
-	lua_State *L;
-	if (NULL == (L = luaL_newstate())) 
-	{
-		perror("luaL_newstate failed");
-		return -1;
-	}
-
-	luaL_openlibs(L);
-	if (luaL_loadfile(L, "./c-print.lua")) 
-	{
-		perror("loadfile failed");
-		return -1;
-	}
-
-	// lua handles a chunk as the body of an anonymous function
-	// with a variable number of arguments. call it 
-	lua_pcall(L, 0, 0, 0);	
-	lua_getglobal(L, "x");
-	int x = (int)lua_tonumber(L, -1);
-	printf("x: %d\n\r", x);
-
-	lua_getglobal(L, "printmsg");
-	lua_pcall(L, 0, 0, 0);
-
-	lua_close(L);
-
-	return 0;
-}
diff --git a/lua/lua-5.3.5/src/test/c-lib.c b/lua/lua-5.3.5/src/test/c-lib.c
deleted file mode 100644
index ce3f21d..0000000
--- a/lua/lua-5.3.5/src/test/c-lib.c
+++ /dev/null
@@ -1,45 +0,0 @@
-
-/*
- * this is a c libaray template for lua
- *
- * step 1 write the lua function
- * step 2 construct the struct of the c lib infomation
- * step 3 definition a function to call the struct
- *
- * */
-
-#include <stdio.h>
-#include <math.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <lua.h>
-#include <lauxlib.h>
-#include <lualib.h>
-
-/*
- * lua c register function prototype is 
- * typedef int (*lua_CFunction)(lua_State *L)
- * */
-static int mj_sin(lua_State *L)
-{
-	double d = luaL_checknumber(L, 1);
-
-	lua_pushnumber(L, sin(d));
-	//lua_pushstring(L, "test");
-	// can return multi-result, do this
-	// lua_pushxxx
-
-	return 1; // number of results
-}
-
-static const struct luaL_Reg lib[] = {
-	{"mjsin", mj_sin},
-	{NULL, NULL}
-};
-
-extern int luaopen_clib(lua_State *L)
-{
-	luaL_newlib(L, lib);
-	return 1;
-}
-
diff --git a/lua/lua-5.3.5/src/test/c-lib.lua b/lua/lua-5.3.5/src/test/c-lib.lua
deleted file mode 100644
index 71269d8..0000000
--- a/lua/lua-5.3.5/src/test/c-lib.lua
+++ /dev/null
@@ -1,7 +0,0 @@
-
-local clib = require "clib"
-
-local a, b = clib.mjsin(3.14/2)
-print('call clib.mjsin result is ')
-print(a, b)
-
diff --git a/lua/lua-5.3.5/src/test/c-lib.sh b/lua/lua-5.3.5/src/test/c-lib.sh
deleted file mode 100644
index 3a10e6f..0000000
--- a/lua/lua-5.3.5/src/test/c-lib.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-
-gcc c-lib.c -I../ -fPIC -shared -o clib.so -Wall
-gcc c-call-lua.c -I ../ -fPIC -Wall -L .. -llua -lm -ldl
diff --git a/lua/lua-5.3.5/src/test/c-print.lua b/lua/lua-5.3.5/src/test/c-print.lua
deleted file mode 100644
index 9b8f691..0000000
--- a/lua/lua-5.3.5/src/test/c-print.lua
+++ /dev/null
@@ -1,6 +0,0 @@
-
-function printmsg()
-	print("Hello World.")
-end
-
-x = 10
diff --git a/lua/lua-5.3.5/src/test/callback.lua b/lua/lua-5.3.5/src/test/callback.lua
deleted file mode 100644
index bfd2be2..0000000
--- a/lua/lua-5.3.5/src/test/callback.lua
+++ /dev/null
@@ -1,17 +0,0 @@
-
-local m = {}
-local list = {name="hello", age = 12}
-m.cb_print = function(id)
-    print(id .. "-->" .. list[id])
-end
-
-m.add_list = function(key, value, cb)
-    key = tostring(key)
-    list[key] = value
-    cb(key)
-end
-
-m.add_list("address", "chongqing", m.cb_print);
-
-return m
-
diff --git a/lua/lua-5.3.5/src/test/clib.so b/lua/lua-5.3.5/src/test/clib.so
deleted file mode 100644
index 0d5144122ec209d8cbb3320e607f24211a15f4bf..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

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

diff --git a/lua/lua-5.3.5/src/test/coroutine1.lua b/lua/lua-5.3.5/src/test/coroutine1.lua
deleted file mode 100644
index 603ffc3..0000000
--- a/lua/lua-5.3.5/src/test/coroutine1.lua
+++ /dev/null
@@ -1,21 +0,0 @@
-function foo(a)
-    print("foo", a)
-    return coroutine.yield(2 * a)
-end
-
-co = coroutine.create(function (a, b)
-    print("co-body-1", a, b)
-    local r = foo(a + 1)
-    print("co-body-2", r);
-    local r, s = coroutine.yield(a+b, a-b)
-    print("co-body-3", r, s)
-    return b, "end"
-end)
-
-print("main-1", coroutine.resume(co, 1, 10))
-
-print("main-2", coroutine.resume(co, "r"))
-
-print("main-3", coroutine.resume(co, "x", "y"))
-
-print("main-4", coroutine.resume(co, "x", "y"))
\ No newline at end of file
diff --git a/lua/lua-5.3.5/src/test/debug.lua b/lua/lua-5.3.5/src/test/debug.lua
deleted file mode 100644
index 9756b35..0000000
--- a/lua/lua-5.3.5/src/test/debug.lua
+++ /dev/null
@@ -1,40 +0,0 @@
-
-function myfunc()
-    print(debug.traceback("Stack trace--begin"))
-    print(debug.getinfo(1))
-    print("Stack trace--end")
-    return 10
-end
-
-myfunc()
-print(debug.getinfo(1))
-
-print('------------------------------')
-
-function newCounter()
-    local n = 0
-    local k = 0
-    return function()
-        k = n
-        n = n + 1
-        return n
-    end
-end
-
-counter = newCounter()
-print(counter())
-print(counter())
-
-local i = 1;
-repeat
-    name, val = debug.getupvalue(counter, i)
-    if name then 
-        print("index", i, name, "=", val)
-        if (name == "n") then 
-            debug.setupvalue(counter, 2, 10)
-        end
-        i = i + 1
-    end 
-until not name 
-print(counter())
-
diff --git a/lua/lua-5.3.5/src/test/dot.colon.lua b/lua/lua-5.3.5/src/test/dot.colon.lua
deleted file mode 100644
index 8c45812..0000000
--- a/lua/lua-5.3.5/src/test/dot.colon.lua
+++ /dev/null
@@ -1,23 +0,0 @@
-
-local test = {}
-function test:func(arg1, arg2)
-    print(arg1, arg2, self)
-end
-
-function test.func1(arg1, arg2)
-    print(arg1, arg2, self)
-end
-
-
-print('arg1 \t arg2 \t self')
-
-test:func(1,2) -- arg1=1,arg2=2                   1,2,table
-test.func(1,2) -- self=1,arg1=2,arg2=nil          2,nil,1
-
-test:func1(1,2) -- arg1=table,arg2=1              table,1,nil
-test.func1(1,2) -- arg1=1,arg2=2                  1,2,nil
-
---[[
--- dot点运算符相当于静态方法
--- colon冒号相当于成员方法,省略第一个self参数
---]]
diff --git a/lua/lua-5.3.5/src/test/dot.colon2.lua b/lua/lua-5.3.5/src/test/dot.colon2.lua
deleted file mode 100644
index ba59c04..0000000
--- a/lua/lua-5.3.5/src/test/dot.colon2.lua
+++ /dev/null
@@ -1,23 +0,0 @@
-
-function string.split(str, delimiter)
-    if str == nil or str == '' or delimiter == nil then
-        return nil
-    end
-    local results = {}
-    for match in (str .. delimiter):gmatch('(.-)' .. delimiter) do
-        print(match)
-        table.insert(results, match)
-    end
-    return results
-end
-
---[[
--- (str .. delimiter):gmatch(s,pattern) is string.gmatch(s,pattern)
---]]
-
-
-for i,v in pairs(string.split('a,b,c', ',')) do
-    print(i, v)
-end
-
-    
diff --git a/lua/lua-5.3.5/src/test/error.lua b/lua/lua-5.3.5/src/test/error.lua
deleted file mode 100644
index 9b092df..0000000
--- a/lua/lua-5.3.5/src/test/error.lua
+++ /dev/null
@@ -1,36 +0,0 @@
-
--- assert type
-
-local function add(a, b)
-    assert(type(a) == "number", "a expects number")
-    assert(type(b) == "number", "a expects number")
-    return a + b 
-end
-
--- error type
-local function add2(a, b)
-    error("add function error", 1)
-    return a + b 
-end
-
--- add(10)
---add2(10)
-
--- pcall type
-if pcall(add, 10) then
-    print("no error")
-else 
-    print("error on call")
-    --error("add function err", 2)
-end
-
--- xpcall type
-function handler(err)
-    print("handle error ", err)
-end
-function wrap()
-    add2(10)
-end
-
-print(xpcall(wrap, handler)) 
-
diff --git a/lua/lua-5.3.5/src/test/filter.lua b/lua/lua-5.3.5/src/test/filter.lua
deleted file mode 100644
index 57c2730..0000000
--- a/lua/lua-5.3.5/src/test/filter.lua
+++ /dev/null
@@ -1,45 +0,0 @@
-
-function filter(t, a, r)
-    print((t:gsub("[^" .. a .. "]", r)))
-end
-
-local allowed = "AbC"
-local txt = "dDcCbBaA"
-
-filter(txt, allowed, "")
-filter(txt, allowed, "?")
-
-s = "[" 
-for i=0,255 do
-    s = s .. "%" .. string.char(i) 
-end
-s = s .. "]"
-print(s)
-print("first type")
-for m in ("xyzzy"):gmatch(s) do
-    print(m)
-end
-print("second type")
-for m in ("xyzzy"):gmatch( "[^" .. s:sub(2,-1)) do
-    print(m)
-end
-print("third type")
-string.gsub("abc", "[a]", print);
-string.gsub("abc", "[%a]", print);
-
-local function make_filter(valid_chars)
-    return setmetatable({}, {
-        __index = function(t, c)
-            local r = string.find(valid_chars, c, 1, true) and c or ""
-            t[c] = r
-            return r 
-        end,
-        __call = function(t, s)
-            return (string.gsub(s, '.', t))
-        end
-    })
-end
-
-local filter2 = make_filter("abc[]")
-print(filter2("[abcABCabc]"))
-
diff --git a/lua/lua-5.3.5/src/test/io-file.lua b/lua/lua-5.3.5/src/test/io-file.lua
deleted file mode 100644
index f3d52c6..0000000
--- a/lua/lua-5.3.5/src/test/io-file.lua
+++ /dev/null
@@ -1,22 +0,0 @@
--- simple model
-
-file = io.open("lua.txt", "a")
-io.output(file)
-io.write("-- test io file")
-io.close(file)
-
-file = io.open("lua.txt", "r")
-io.input(file)
-print(io.read())
-io.close(file)
-
--- complete model
-
-file = io.open("lua.txt", "r")
-print(file:read())
-file:close()
-
-file = io.open("lua.txt", "a")
-file:write("-- test complete model")
-file:close()
-
diff --git a/lua/lua-5.3.5/src/test/lambda-calculus.lua b/lua/lua-5.3.5/src/test/lambda-calculus.lua
deleted file mode 100644
index 4435b55..0000000
--- a/lua/lua-5.3.5/src/test/lambda-calculus.lua
+++ /dev/null
@@ -1,180 +0,0 @@
-
---[[
--- functional programming
--- higher-order functions 
--- anonymous functions
---]]
-
--- Identity 
--- (lambda)x.x
-function identity(x)
-    return x;
-end
-
-print("identity")
-print(identity(identity) == identity)
-print(identity)
-
--- Self Application Function
-function self_apply(s)
-    return s(s);
-end
-
-print("self apply")
-print(self_apply(identity) == identity);
-print(self_apply)
-
--- Function Application Function
-function apply(f)
-    return (function(a)
-        return f(a);
-    end);
-end
-
-print("apply")
-print(apply(identity)(identity) == identity);
-print(apply(identity)(identity));
-
-
--- Boolean Values
-function TRUE(f)
-    return (function(s)
-        return f;
-    end);
-end
-
-function FALSE(f)
-    return (function(s)
-        return s;
-    end);
-end
-
-print("boolean value")
-print(TRUE(identity)(apply) == identity)
-print(FALSE(identity)(apply) == apply)
-
--- Condition
-function COND(t)
-    return (function(f)
-        return (function(b)
-            return b(t)(f);
-        end);
-    end);
-end
-
-print("condition ")
-print(COND(identity)(apply)(TRUE) == identity);
-
--- NOT
-function NOT(b)
-    return b(FALSE)(TRUE);
-end
-
-print("not ")
-print(NOT(TRUE)==FALSE);
-print(NOT(NOT(TRUE)) == TRUE);
-
--- AND
-function AND(x)
-    return (function(y)
-        return x(y)(FALSE);
-    end);
-end
-
-print("and")
-print(AND(TRUE)(TRUE) == TRUE);
-print(AND(TRUE)(FALSE) == FALSE);
-print(AND(FALSE)(TRUE) == FALSE);
-print(AND(FALSE)(FALSE) == FALSE);
-
--- OR
-function OR(x)
-    return (function(y)
-        return x(TRUE)(y);
-    end);
-end
-
-print("or")
-print(OR(TRUE)(TRUE) == TRUE);
-print(OR(TRUE)(FALSE) == TRUE);
-print(OR(FALSE)(TRUE) == TRUE);
-print(OR(FALSE)(FALSE) == FALSE);
-
-
--- Natural Numbers
---
-local zero = identity;
-function succ(n)
-    return (function(b)
-        return b(FALSE)(n);
-    end);
-end
-
-print("natural number")
-one = succ(zero);
-print(one)
-
-two = succ(one);
-print(two)
-
-three = succ(two)
-print(three)
-
-four = succ(three);
-print(four)
-
-five = succ(four);
-print(five)
-
-
-six = succ(six);
-print(six)
-
-seven = succ(six);
-print(seven)
-
-eight = succ(seven);
-print(eight)
-
-nine = succ(eight);
-print(nine)
-
-function iszero(n)
-    return n(TRUE);
-end
-
-print(iszero(zero) == TRUE)
-print(iszero(one) == FALSE)
-
-function pred(n)
-    return iszero(n)(zero)(n(FALSE));
-end
-
-print(pred(one) == zero)
-
--- LOOP
-
-function recursive(f)
-    return (function(x)
-        return f(function(dymmy) return x(x) end)
-    end )(function(x)
-        return f(function(dummy) return x(x) end)
-    end)
-end
-
-function stepper(next_step)
-    return (function(n)
-        return COND(function(dummy) 
-            return zero 
-        end)(function(dummy)
-            print("one step");
-            return next_step(identity)(pred(n))
-        end)(iszero(n))(identity)
-    end)
-end
-
-print("loop")
-recursive(stepper)(five)
-
-
-
diff --git a/lua/lua-5.3.5/src/test/lua.txt b/lua/lua-5.3.5/src/test/lua.txt
deleted file mode 100644
index a190800..0000000
--- a/lua/lua-5.3.5/src/test/lua.txt
+++ /dev/null
@@ -1 +0,0 @@
--- test io file-- test io file-- test complete model
\ No newline at end of file
diff --git a/lua/lua-5.3.5/src/test/luac.out b/lua/lua-5.3.5/src/test/luac.out
deleted file mode 100644
index c9aa0eb2a098271684c7382a3e43430b6df8cb46..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 372
zcmZ`!v1$TQ5S;g1pO+I0OHE@TlH$lWtVL3ZjbJCor4vNL5lPCuZ^#c><-0N)b1H%h
zvv1hhoqhYbI8-Z)z6bd@mrSzkYmG}heQJ2n{dV`fJ5=X#kRf?NWPlawuUUd(YUZ^j
zY0IrinB&zHjRyQ26`P}Bst7X}5<Mi<B{xW{B~}vOB)!+${fBglNuV4Mng5bFLF_O&
zol$g?>u{~bsr_H|P5c=nx}VS8&U(E^oZ3hjeyIDn=5@Epuh1uNF(AJOO1uQ<mM_co
EFDBm~0RR91

diff --git a/lua/lua-5.3.5/src/test/module-calla.lua b/lua/lua-5.3.5/src/test/module-calla.lua
deleted file mode 100644
index ab71d81..0000000
--- a/lua/lua-5.3.5/src/test/module-calla.lua
+++ /dev/null
@@ -1,8 +0,0 @@
-require("module")
-
-print(module.constant)
-
-module.func1()
---module.func2()
-module.func3()
-
diff --git a/lua/lua-5.3.5/src/test/module-callb.lua b/lua/lua-5.3.5/src/test/module-callb.lua
deleted file mode 100644
index 0c0fe05..0000000
--- a/lua/lua-5.3.5/src/test/module-callb.lua
+++ /dev/null
@@ -1,9 +0,0 @@
-
-local m = require("module")
-
-print(m.constant)
-
-print(m.func1())
-
-print(m.func3())
-
diff --git a/lua/lua-5.3.5/src/test/module.lua b/lua/lua-5.3.5/src/test/module.lua
deleted file mode 100644
index d2098c5..0000000
--- a/lua/lua-5.3.5/src/test/module.lua
+++ /dev/null
@@ -1,19 +0,0 @@
-
-module = {}
-
-module.constant = "constant value"
-
-function module.func1()
-    io.write("public function\n")
-end
-
-local function func2()
-    print("local function\n")
-end
-
-function module.func3()
-    func2()
-end
-
-return module
-
diff --git a/lua/lua-5.3.5/src/test/nil.lua b/lua/lua-5.3.5/src/test/nil.lua
deleted file mode 100644
index 18d9716..0000000
--- a/lua/lua-5.3.5/src/test/nil.lua
+++ /dev/null
@@ -1,14 +0,0 @@
-
-function r_nil() 
-	return nil
-end
-
-function r()
-	return 
-end
-
-a = r_nil()
-b = r()
-
-print(a .. ", " .. b)
-
diff --git a/lua/lua-5.3.5/src/test/number.lua b/lua/lua-5.3.5/src/test/number.lua
deleted file mode 100644
index 9b231fe..0000000
--- a/lua/lua-5.3.5/src/test/number.lua
+++ /dev/null
@@ -1,9 +0,0 @@
-
-lua_pushNumber(L, 3)
-lua_toString(L, -1)
-print("%s\n", lua_typename(L, lua_type(L, -1)))
-
-lua_pushNumber(L, 3)
-print("%d\n", lua_objlen(L, -1))
-print("%d\n", lua_typename(L, lua_type(L, -1)))
-
diff --git a/lua/lua-5.3.5/src/test/oop.lua b/lua/lua-5.3.5/src/test/oop.lua
deleted file mode 100644
index 1e43092..0000000
--- a/lua/lua-5.3.5/src/test/oop.lua
+++ /dev/null
@@ -1,55 +0,0 @@
-
--- class
---
-Shape = { area = 0 }
-
-function Shape:new (o, side)
-    o = o or {}
-    setmetatable(o, self)
-    self.__index = self
-    side = side or 0
-    self.area = side * side 
-    return o
-end
-
-function Shape:printArea()
-    print("area is ", self.area)
-end
-
-test = Shape:new(nil, 10)
-test:printArea()
-
--- inherit
-Square = Shape:new()
-
-function Square:new(o, side)
-    o = o or Shape:new(o, side)
-    setmetatable(o, self)
-    self.__index = self 
-    return o
-end
-
-function Square:printArea()
-    print("Square area is ", self.area)
-end
-
-test1 = Square:new(nil, 10)
-test1:printArea()
-
-Rectangle = Shape:new()
-function Rectangle:new(o, width, height)
-    o = o or Shape:new(o)
-    setmetatable(o, self)
-    self.__index = self 
-    self.area = width * height
-    return o
-end
-
-function Rectangle:printArea()
-    print("Rectangle area is ", self.area)
-end
-
-test2 = Rectangle:new(nil, 10, 20)
-test2:printArea()
-
-
diff --git a/lua/lua-5.3.5/src/test/permutation.lua b/lua/lua-5.3.5/src/test/permutation.lua
deleted file mode 100644
index 7f67657..0000000
--- a/lua/lua-5.3.5/src/test/permutation.lua
+++ /dev/null
@@ -1,38 +0,0 @@
-
-function permgen(a, n)
-	n = n or #a
-	if n <= 1 then 
-		coroutine.yield(a)
-	else
-		for i=1, n do 
-			a[n], a[i] = a[i], a[n]
-			permgen(a, n-1)
-			a[n], a[i] = a[i], a[n]
-		end
-	end
-end
-
-function prints(a)
-	for i=1, #a do 
-		io.write(a[i], "")
-	end
-	io.write("\n")
-end
-
-function perm(a)
-	local co = coroutine.create(function() permgen(a) end)
-	return function()
-		local code, res = coroutine.resume(co)
-		return res
-	end
-end
-
-local count = 0;
-for p in perm({"a", "b", "c", "d"}) do
-	prints(p)
-	count = count + 1
-end
-
-print('the total order is ', count)
-
-
diff --git a/lua/lua-5.3.5/src/test/productor-consumer.lua b/lua/lua-5.3.5/src/test/productor-consumer.lua
deleted file mode 100644
index 7b21847..0000000
--- a/lua/lua-5.3.5/src/test/productor-consumer.lua
+++ /dev/null
@@ -1,36 +0,0 @@
-
-local newProductor
-
-function productor()
-    local i = 0
-    --while true do 
-    while i < 10 do 
-        i = i + 1
-        send(i) -- send productor to consumer 
-    end
-end
-
-function consumer()
-    local res = true;
-    while res do 
-        local i = receive() -- get from productor
-        print(i)
-        print(type(i))
-        if (type(i) ~= "number") then res = false end 
-        -- assert(type(i) == "number", "expects a number")
-    end
-end
-
-function receive()
-    local status, value = coroutine.resume(newProductor)
-    return value 
-end
-
-function send(x)
-    coroutine.yield(x) -- send the productor and yield 
-end
-
-newProductor = coroutine.create(productor)
-consumer()
-
-
diff --git a/lua/lua.md b/lua/lua.md
deleted file mode 100644
index c348c29..0000000
--- a/lua/lua.md
+++ /dev/null
@@ -1,154 +0,0 @@
-# [lua](https://www.lua.org/)
-
-注释 
-
-```lua
--- xxx to c // xxx
---[[ xxx ]] to c /* xxx */
-```
-
-## 模块与包
-
-lua的模块是由变量，函数等组成的table，其是加载机制通过require来导入
-
-require的路径是全局变量package.path中的，lua启动后，有三个大致范围
-
-```lua
-print(package.path) -- 编译后执行的路径，并未安装
--- /usr/local/share/lua/x.y/?.lua;/usr/local/share/lua/x.y/?/init.lua;/usr/local/lib/lua/x.y/?.lua;/usr/local/lib/lua/x.y/?/init.lua;./?.lua;./?/init.lua
--- 添加环境变量 export LUA_PATH="~/lua/?.lua;;" 最后的;;表示加上原来默认的路径
-```
-
-C包，使用C为lua写包，是动态库的调用方式
-
-# lua-src
-
-lua把虚拟机执行代码的效率作为一个设计目标。lua的vm是Register based VM。
-
-```c
-// register based vm
-add a b c;
-// stack based vm
-push b;
-push c;
-add
-mov a
-```
-
-## lopcodes
-
-> 理解lua，直接从这里开始，是最好的，特别是有汇编，C语言的功底后，就相当于先理解lua的汇编指令，再去理解lua的逻辑。
->
-> > 汇编的本质是CPU二进制指令的文本形式
-
-lua virtual machine op-codes， 指令是一个32bit的unsigned int
-
-|       | 31-24    | 23-16    | 15-8    | 0-7      |
-| ----- | -------- | -------- | ------- | -------- |
-| iABC  | B:9      | C:9      | A:8     | Opcode:6 |
-| iABx  | Bx:18-1  | Bx:18-2  | A:8     | Opcode:6 |
-| iAsBx | sBx:18-1 | sBx:18-2 | A:8     | Opcode:6 |
-| iAx   | Ax:26-1  | Ax:26-2  | Ax:26-3 | Opcode:6 |
-
-基本的四个指令形式，iABC，iABx，iAsBx，iAx。sBx表示signed int，
-
-```c
-pow(2,18)=262144 => [0, 262143] 
-0 use 131071, -1=-1+0=131070, +1 = +1+131071=131072. // 进行了一个变换，类似二进制取补
-```
-
-生成代码对应的指令
-
-```shell
-luac -l -l src.lua
-```
-
-
-
-## 编译系统
-
-编译系统就是将符合语法规则的chunk转成可运行的closure， 即chunk作为输入，closure作为输出。
-
-### 主要概念
-
-#### closure
-
-closure对象是lua运行期一个函数的实例对象，
-
-#### proto
-
-proto对象是lua内部代表一个closure原型的对象，有关函数的大部分信息都保存在它里面
-
-- instructions指令列表，函数编译后生成的虚拟机指令
-- constant table常量表，运行期的所有常量，在指令中，常量通过id在常量表中索引
-- child proto table子proto表，所有内嵌于函数的proto列表，指令OP_CLOSURE的proto就是在这个表中通过id索引
-- local var desc局部变量描述，函数使用的所有局部变量名称，以及生命周期
-- upvalue desc，函数使用到的Upvalue的描述
-
-#### chunk
-
-代表一段符合lua语法的代码，lua_load会对chunk编译生成一个mainfunc proto，内部的所有函数都对应一个proto。整个过程就是生成以mainfunc为根节点的proto树结构
-
-注意，lua编译过程中是一次遍历就生成指令，并没有对源码和语法结构多次遍历，是通过指令回填技术来实现支持的。
-
-### 实现逻辑
-
-lua没有使用llex和yacc生成，而是完全手写的词法和语法分析器，按功能划分，主要有三个模块
-
-#### 词法分析模块
-
-llex.h/c
-
-#### 语法分析模块
-
-lparser.h/c
-
-
-![](./images/lua-opcode.png)
-
-
-```c
-// in lopcodes.c
-#define opmode(t,a,b,c,m) (((t)<<7)|((a)<<6)|((b)<<4)|((c)<<2)|(m))
-```
-
-- t，表示为test，其后的一定是OP_JMP，共五个指令OP_EQ,OP_LT,OP_LE,OP_TEST,OP_TESTSET
-- a，是否为寄存器操作，1表示寄存器
-- b，B参数，OpArgMask类型
-- c，C参数，OpArgMask类型
-- m，op model，就是iABC,iABx,iAsBx,iAx
-
-这里存在些疑惑，Opcode只占6bit，而opmode中的值占8bit，令人不解，多出来的一个bit是什么地方来的？
-
-#### 指令生成模块
-
-lcode.h/c
-
-#### 其他
-
-lprefix.h
-
-luaconf.h
-
-lua.h/c
-
-主要接口
-
-lctype.h/c
-
-针对非ASCII进行定义一些基础字符
-
-lmem.h/c
-
-lzio.h/c
-
-buffered streams，内存是stream形式，与C的File有点类似，核心就是两个函数luaZ_read,luaZ_fill
-
-lobject.h/c
-
-lua的类型定义
-
-## 参考
-
-[探索Lua5.2内部实现](https://blog.csdn.net/yuanlin2008/article/category/1307277)
-
diff --git a/lua/tests-lua/luac.out b/lua/tests-lua/luac.out
deleted file mode 100644
index d8860c850ef92f112525de8c820260177e55740f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

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