Well here it is

apktool.bat

@@ -0,0 +1,5 @@
+@echo off
+if "%PATH_BASE%" == "" set PATH_BASE=%PATH%
+set PATH=%CD%;%PATH_BASE%;
+chcp 65001 2>nul >nul
+java -jar -Duser.language=en -Dfile.encoding=UTF8 "%~dp0\apktool.jar" %*

bin/compressors/lzw.lua

@@ -0,0 +1,73 @@
+--[[
+LZW String Compression demo for Gideros
+This code is MIT licensed, see http://www.opensource.org/licenses/mit-license.php
+(C) 2013 - Guava7
+]]
+CLZWCompression = {}
+function CLZWCompression:InitDictionary(isEncode)
+	self.mDictionary = {}
+	-- local s = " !#$%&'\"()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
+	local s={}
+	for i=1,255 do
+		s[#s+1]=string.char(i)
+	end
+	s=table.concat(s)
+	local len = #s
+	for i = 1, len do
+		if isEncode then
+			self.mDictionary[s:sub(i, i)] = i
+		else
+			self.mDictionary[i] = s:sub(i, i)
+		end
+	end
+	self.mDictionaryLen = len
+end
+function CLZWCompression:Encode(sInput)
+	self:InitDictionary(true)
+	local s = ""
+	local ch
+	local len = #sInput
+	local result = {}
+	local dic = self.mDictionary
+	local temp
+	for i = 1, len do
+		ch = sInput:sub(i, i)
+		temp = s..ch
+		if dic[temp] then
+			s = temp
+		else
+			result[#result + 1] = dic[s]
+			self.mDictionaryLen = self.mDictionaryLen + 1
+			dic[temp] = self.mDictionaryLen
+			s = ch
+		end
+	end
+	result[#result + 1] = dic[s]
+	return result
+end
+function CLZWCompression:Decode(data)
+	self:InitDictionary(false)
+	local dic = self.mDictionary
+	local entry
+	local ch
+	local prevCode, currCode
+	local result = {}
+	prevCode = data[1]
+	result[#result + 1] = dic[prevCode]
+	for i = 2, #data do
+		currCode = data[i]
+		entry = dic[currCode]
+		if entry then
+			ch = entry:sub(1, 1)
+			result[#result + 1] = entry
+		else
+			ch = dic[prevCode]:sub(1, 1)
+			result[#result + 1] = dic[prevCode]..ch
+		end
+		dic[#dic + 1] = dic[prevCode]..ch
+		prevCode = currCode
+	end
+	return table.concat(result)
+end
+
+return CLZWCompression

bin/converters/base64.lua

@@ -0,0 +1,40 @@
+local bin = require("bin")
+local base64={}
+local bs = { [0] =
+   'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
+   'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
+   'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
+   'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/',
+}
+local bsd=table.flip(bs)
+local char=string.char
+function base64.encode(s)
+   local byte, rep, pad = string.byte, string.rep, 2 - ((#s-1) % 3)
+   s = (s..rep('\0', pad)):gsub("...", function(cs)
+      local a, b, c = byte(cs, 1, 3)
+      return bs[bit.rshift(a,2)] .. bs[bit.bor(bit.lshift(bit.band(a,3),4),bit.rshift(b,4))] .. bs[bit.bor(bit.lshift(bit.band(b,15),2),bit.rshift(c,6))] .. bs[bit.band(c,63)]
+   end)
+   return s:sub(1, #s-pad) .. rep('=', pad)
+end
+function base64.decode(s)
+	local s=s:match("["..s.."=]+")
+	local p,cc=s:gsub("=","A")
+	local r=""
+	local n=0
+	s=s:sub(1,#s-#p)..p
+	for c = 1,#s,4 do
+		n = bit.lshift(bsd[s:sub(c, c)], 18) + bit.lshift(bsd[s:sub(c+1, c+1)], 12) + bit.lshift(bsd[s:sub(c + 2, c + 2)], 6) + bsd[s:sub(c + 3, c + 3)]
+		r = r .. char(bit.band(bit.arshift(n, 16), 0xFF)) .. char(bit.band(bit.arshift(n, 8), 0xFF)) .. char(bit.band(n, 0xFF))
+	end
+	return r:sub(1,-(cc+1))
+end
+function bin.newFromBase91(data)
+	return bin.new(bin.fromBase91(data))
+end
+function bin.toBase91(s)
+	return base91.encode(s)
+end
+function bin.fromBase91(s)
+	return base91.decode(s)
+end
+return base64

bin/converters/base91.lua

@@ -0,0 +1,82 @@
+local bin = require("bin")
+local base91={}
+local b91enc={[0]=
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+	'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+	'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+	'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '!', '#', '$',
+	'%', '&', '(', ')', '*', '+', ',', '.', '/', ':', ';', '<', '=',
+	'>', '?', '@', '[', ']', '^', '_', '`', '{', '|', '}', '~', '"'
+}
+local b91dec=table.flip(b91enc)
+function base91.decode(d)
+	local l,v,o,b,n = #d,-1,"",0,0
+	for i in d:gmatch(".") do
+		local c=b91dec[i]
+		if not(c) then
+			-- Continue
+		else
+			if v < 0 then
+				v = c
+			else
+				v = v+c*91
+				b = bit.bor(b, bit.lshift(v,n))
+				if bit.band(v,8191) then
+					n = n + 13
+				else
+					n = n + 14
+				end
+				while true do
+					o=o..string.char(bit.band(b,255))
+					b=bit.rshift(b,8)
+					n=n-8
+					if not (n>7) then
+						break
+					end
+				end
+				v=-1
+			end
+		end
+	end
+	if v + 1>0 then
+		o=o..string.char(bit.band(bit.bor(b,bit.lshift(v,n)),255))
+	end
+	return o
+end
+function base91.encode(d)
+	local b,n,o,l=0,0,"",#d
+	for i in d:gmatch(".") do
+		b=bit.bor(b,bit.lshift(string.byte(i),n))
+		n=n+8
+		if n>13 then
+			v=bit.band(b,8191)
+			if v>88 then
+				b=bit.rshift(b,13)
+				n=n-13
+			else
+				v=bit.band(b,16383)
+				b=bit.rshift(b,14)
+				n=n-14
+			end
+			o=o..b91enc[v % 91] .. b91enc[math.floor(v / 91)]
+		end
+	end
+	if n>0 then
+		o=o..b91enc[b % 91]
+		if n>7 or b>90 then
+			o=o .. b91enc[math.floor(b / 91)]
+		end
+	end
+	return o
+end
+function bin.newFromBase64(data)
+	return bin.new(bin.fromBase64(data))
+end
+function bin.toBase64(s)
+	return base64.encode(s)
+end
+function bin.fromBase64(s)
+	return base64.decode(s)
+end
+return base91

bin/hashes/md5.lua

@@ -0,0 +1,394 @@
+local bin = require("bin")
+local md5 = {
+  _VERSION     = "md5.lua 1.1.0",
+  _DESCRIPTION = "MD5 computation in Lua (5.1-3, LuaJIT)",
+  _URL         = "https://github.com/kikito/md5.lua",
+  _LICENSE     = [[
+    MIT LICENSE
+
+    Copyright (c) 2013 Enrique García Cota + Adam Baldwin + hanzao + Equi 4 Software
+  ]]
+}
+
+-- bit lib implementions
+
+local char, byte, format, rep, sub =
+  string.char, string.byte, string.format, string.rep, string.sub
+local bit_or, bit_and, bit_not, bit_xor, bit_rshift, bit_lshift
+
+local ok, bit = pcall(require, 'bit')
+if ok then
+  bit_or, bit_and, bit_not, bit_xor, bit_rshift, bit_lshift = bit.bor, bit.band, bit.bnot, bit.bxor, bit.rshift, bit.lshift
+else
+  ok, bit = pcall(require, 'bit32')
+
+  if ok then
+
+    bit_not = bit.bnot
+
+    local tobit = function(n)
+      return n <= 0x7fffffff and n or -(bit_not(n) + 1)
+    end
+
+    local normalize = function(f)
+      return function(a,b) return tobit(f(tobit(a), tobit(b))) end
+    end
+
+    bit_or, bit_and, bit_xor = normalize(bit.bor), normalize(bit.band), normalize(bit.bxor)
+    bit_rshift, bit_lshift = normalize(bit.rshift), normalize(bit.lshift)
+
+  else
+
+    local function tbl2number(tbl)
+      local result = 0
+      local power = 1
+      for i = 1, #tbl do
+        result = result + tbl[i] * power
+        power = power * 2
+      end
+      return result
+    end
+
+    local function expand(t1, t2)
+      local big, small = t1, t2
+      if(#big < #small) then
+        big, small = small, big
+      end
+      -- expand small
+      for i = #small + 1, #big do
+        small[i] = 0
+      end
+    end
+
+    local to_bits -- needs to be declared before bit_not
+
+    bit_not = function(n)
+      local tbl = to_bits(n)
+      local size = math.max(#tbl, 32)
+      for i = 1, size do
+        if(tbl[i] == 1) then
+          tbl[i] = 0
+        else
+          tbl[i] = 1
+        end
+      end
+      return tbl2number(tbl)
+    end
+
+    -- defined as local above
+    to_bits = function (n)
+      if(n < 0) then
+        -- negative
+        return to_bits(bit_not(math.abs(n)) + 1)
+      end
+      -- to bits table
+      local tbl = {}
+      local cnt = 1
+      local last
+      while n > 0 do
+        last      = n % 2
+        tbl[cnt]  = last
+        n         = (n-last)/2
+        cnt       = cnt + 1
+      end
+
+      return tbl
+    end
+
+    bit_or = function(m, n)
+      local tbl_m = to_bits(m)
+      local tbl_n = to_bits(n)
+      expand(tbl_m, tbl_n)
+
+      local tbl = {}
+      for i = 1, #tbl_m do
+        if(tbl_m[i]== 0 and tbl_n[i] == 0) then
+          tbl[i] = 0
+        else
+          tbl[i] = 1
+        end
+      end
+
+      return tbl2number(tbl)
+    end
+
+    bit_and = function(m, n)
+      local tbl_m = to_bits(m)
+      local tbl_n = to_bits(n)
+      expand(tbl_m, tbl_n)
+
+      local tbl = {}
+      for i = 1, #tbl_m do
+        if(tbl_m[i]== 0 or tbl_n[i] == 0) then
+          tbl[i] = 0
+        else
+          tbl[i] = 1
+        end
+      end
+
+      return tbl2number(tbl)
+    end
+
+    bit_xor = function(m, n)
+      local tbl_m = to_bits(m)
+      local tbl_n = to_bits(n)
+      expand(tbl_m, tbl_n)
+
+      local tbl = {}
+      for i = 1, #tbl_m do
+        if(tbl_m[i] ~= tbl_n[i]) then
+          tbl[i] = 1
+        else
+          tbl[i] = 0
+        end
+      end
+
+      return tbl2number(tbl)
+    end
+
+    bit_rshift = function(n, bits)
+      local high_bit = 0
+      if(n < 0) then
+        -- negative
+        n = bit_not(math.abs(n)) + 1
+        high_bit = 0x80000000
+      end
+
+      local floor = math.floor
+
+      for i=1, bits do
+        n = n/2
+        n = bit_or(floor(n), high_bit)
+      end
+      return floor(n)
+    end
+
+    bit_lshift = function(n, bits)
+      if(n < 0) then
+        -- negative
+        n = bit_not(math.abs(n)) + 1
+      end
+
+      for i=1, bits do
+        n = n*2
+      end
+      return bit_and(n, 0xFFFFFFFF)
+    end
+  end
+end
+
+-- convert little-endian 32-bit int to a 4-char string
+local function lei2str(i)
+  local f=function (s) return char( bit_and( bit_rshift(i, s), 255)) end
+  return f(0)..f(8)..f(16)..f(24)
+end
+
+-- convert raw string to big-endian int
+local function str2bei(s)
+  local v=0
+  for i=1, #s do
+    v = v * 256 + byte(s, i)
+  end
+  return v
+end
+
+-- convert raw string to little-endian int
+local function str2lei(s)
+  local v=0
+  for i = #s,1,-1 do
+    v = v*256 + byte(s, i)
+  end
+  return v
+end
+
+-- cut up a string in little-endian ints of given size
+local function cut_le_str(s,...)
+  local o, r = 1, {}
+  local args = {...}
+  for i=1, #args do
+    table.insert(r, str2lei(sub(s, o, o + args[i] - 1)))
+    o = o + args[i]
+  end
+  return r
+end
+
+local swap = function (w) return str2bei(lei2str(w)) end
+
+-- An MD5 mplementation in Lua, requires bitlib (hacked to use LuaBit from above, ugh)
+-- 10/02/2001 jcw@equi4.com
+
+local CONSTS = {
+  0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
+  0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
+  0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
+  0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
+  0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
+  0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
+  0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
+  0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
+  0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
+  0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
+  0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
+  0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
+  0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
+  0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
+  0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
+  0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
+  0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476
+}
+
+local f=function (x,y,z) return bit_or(bit_and(x,y),bit_and(-x-1,z)) end
+local g=function (x,y,z) return bit_or(bit_and(x,z),bit_and(y,-z-1)) end
+local h=function (x,y,z) return bit_xor(x,bit_xor(y,z)) end
+local i=function (x,y,z) return bit_xor(y,bit_or(x,-z-1)) end
+local z=function (ff,a,b,c,d,x,s,ac)
+  a=bit_and(a+ff(b,c,d)+x+ac,0xFFFFFFFF)
+  -- be *very* careful that left shift does not cause rounding!
+  return bit_or(bit_lshift(bit_and(a,bit_rshift(0xFFFFFFFF,s)),s),bit_rshift(a,32-s))+b
+end
+
+local function transform(A,B,C,D,X)
+  local a,b,c,d=A,B,C,D
+  local t=CONSTS
+
+  a=z(f,a,b,c,d,X[ 0], 7,t[ 1])
+  d=z(f,d,a,b,c,X[ 1],12,t[ 2])
+  c=z(f,c,d,a,b,X[ 2],17,t[ 3])
+  b=z(f,b,c,d,a,X[ 3],22,t[ 4])
+  a=z(f,a,b,c,d,X[ 4], 7,t[ 5])
+  d=z(f,d,a,b,c,X[ 5],12,t[ 6])
+  c=z(f,c,d,a,b,X[ 6],17,t[ 7])
+  b=z(f,b,c,d,a,X[ 7],22,t[ 8])
+  a=z(f,a,b,c,d,X[ 8], 7,t[ 9])
+  d=z(f,d,a,b,c,X[ 9],12,t[10])
+  c=z(f,c,d,a,b,X[10],17,t[11])
+  b=z(f,b,c,d,a,X[11],22,t[12])
+  a=z(f,a,b,c,d,X[12], 7,t[13])
+  d=z(f,d,a,b,c,X[13],12,t[14])
+  c=z(f,c,d,a,b,X[14],17,t[15])
+  b=z(f,b,c,d,a,X[15],22,t[16])
+
+  a=z(g,a,b,c,d,X[ 1], 5,t[17])
+  d=z(g,d,a,b,c,X[ 6], 9,t[18])
+  c=z(g,c,d,a,b,X[11],14,t[19])
+  b=z(g,b,c,d,a,X[ 0],20,t[20])
+  a=z(g,a,b,c,d,X[ 5], 5,t[21])
+  d=z(g,d,a,b,c,X[10], 9,t[22])
+  c=z(g,c,d,a,b,X[15],14,t[23])
+  b=z(g,b,c,d,a,X[ 4],20,t[24])
+  a=z(g,a,b,c,d,X[ 9], 5,t[25])
+  d=z(g,d,a,b,c,X[14], 9,t[26])
+  c=z(g,c,d,a,b,X[ 3],14,t[27])
+  b=z(g,b,c,d,a,X[ 8],20,t[28])
+  a=z(g,a,b,c,d,X[13], 5,t[29])
+  d=z(g,d,a,b,c,X[ 2], 9,t[30])
+  c=z(g,c,d,a,b,X[ 7],14,t[31])
+  b=z(g,b,c,d,a,X[12],20,t[32])
+
+  a=z(h,a,b,c,d,X[ 5], 4,t[33])
+  d=z(h,d,a,b,c,X[ 8],11,t[34])
+  c=z(h,c,d,a,b,X[11],16,t[35])
+  b=z(h,b,c,d,a,X[14],23,t[36])
+  a=z(h,a,b,c,d,X[ 1], 4,t[37])
+  d=z(h,d,a,b,c,X[ 4],11,t[38])
+  c=z(h,c,d,a,b,X[ 7],16,t[39])
+  b=z(h,b,c,d,a,X[10],23,t[40])
+  a=z(h,a,b,c,d,X[13], 4,t[41])
+  d=z(h,d,a,b,c,X[ 0],11,t[42])
+  c=z(h,c,d,a,b,X[ 3],16,t[43])
+  b=z(h,b,c,d,a,X[ 6],23,t[44])
+  a=z(h,a,b,c,d,X[ 9], 4,t[45])
+  d=z(h,d,a,b,c,X[12],11,t[46])
+  c=z(h,c,d,a,b,X[15],16,t[47])
+  b=z(h,b,c,d,a,X[ 2],23,t[48])
+
+  a=z(i,a,b,c,d,X[ 0], 6,t[49])
+  d=z(i,d,a,b,c,X[ 7],10,t[50])
+  c=z(i,c,d,a,b,X[14],15,t[51])
+  b=z(i,b,c,d,a,X[ 5],21,t[52])
+  a=z(i,a,b,c,d,X[12], 6,t[53])
+  d=z(i,d,a,b,c,X[ 3],10,t[54])
+  c=z(i,c,d,a,b,X[10],15,t[55])
+  b=z(i,b,c,d,a,X[ 1],21,t[56])
+  a=z(i,a,b,c,d,X[ 8], 6,t[57])
+  d=z(i,d,a,b,c,X[15],10,t[58])
+  c=z(i,c,d,a,b,X[ 6],15,t[59])
+  b=z(i,b,c,d,a,X[13],21,t[60])
+  a=z(i,a,b,c,d,X[ 4], 6,t[61])
+  d=z(i,d,a,b,c,X[11],10,t[62])
+  c=z(i,c,d,a,b,X[ 2],15,t[63])
+  b=z(i,b,c,d,a,X[ 9],21,t[64])
+
+  return bit_and(A+a,0xFFFFFFFF),bit_and(B+b,0xFFFFFFFF),
+         bit_and(C+c,0xFFFFFFFF),bit_and(D+d,0xFFFFFFFF)
+end
+
+----------------------------------------------------------------
+
+local function md5_update(self, s)
+  self.pos = self.pos + #s
+  s = self.buf .. s
+  for ii = 1, #s - 63, 64 do
+    local X = cut_le_str(sub(s,ii,ii+63),4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4)
+    assert(#X == 16)
+    X[0] = table.remove(X,1) -- zero based!
+    self.a,self.b,self.c,self.d = transform(self.a,self.b,self.c,self.d,X)
+  end
+  self.buf = sub(s, math.floor(#s/64)*64 + 1, #s)
+  return self
+end
+
+local function md5_finish(self)
+  local msgLen = self.pos
+  local padLen = 56 - msgLen % 64
+
+  if msgLen % 64 > 56 then padLen = padLen + 64 end
+
+  if padLen == 0 then padLen = 64 end
+
+  local s = char(128) .. rep(char(0),padLen-1) .. lei2str(bit_and(8*msgLen, 0xFFFFFFFF)) .. lei2str(math.floor(msgLen/0x20000000))
+  md5_update(self, s)
+
+  assert(self.pos % 64 == 0)
+  return lei2str(self.a) .. lei2str(self.b) .. lei2str(self.c) .. lei2str(self.d)
+end
+
+----------------------------------------------------------------
+
+function md5.new()
+  return { a = CONSTS[65], b = CONSTS[66], c = CONSTS[67], d = CONSTS[68],
+           pos = 0,
+           buf = '',
+           update = md5_update,
+           finish = md5_finish }
+end
+
+function md5.tohex(s)
+  return format("%08x%08x%08x%08x", str2bei(sub(s, 1, 4)), str2bei(sub(s, 5, 8)), str2bei(sub(s, 9, 12)), str2bei(sub(s, 13, 16)))
+end
+
+function md5.sum(s)
+  return md5.new():update(s):finish()
+end
+
+function md5.sumhexa(s)
+  return md5.tohex(md5.sum(s))
+end
+bin.md5 = md5
+function bin:getMD5Hash()
+	self:setSeek(1)
+	local len=self:getSize()
+	local md5=bin.md5.new()
+	local SIZE=2048
+	if len>SIZE then
+		local dat=self:read(SIZE)
+		while dat~=nil do
+			md5:update(dat)
+			dat=self:read(SIZE)
+		end
+		return bin.md5.tohex(md5:finish()):upper()
+	else
+		return bin.md5.sumhexa(self:getData()):upper()
+	end
+end
+return md5

bin/numbers/BigNum.lua

@@ -0,0 +1,683 @@
+RADIX = 10^7 ;
+RADIX_LEN = math.floor( math.log10 ( RADIX ) ) ;
+
+BigNum = {} ;
+BigNum.mt = {} ;
+
+function BigNum.new( num ) --{{{2
+   local bignum = {} ;
+   setmetatable( bignum , BigNum.mt ) ;
+   BigNum.change( bignum , num ) ;
+   return bignum ;
+end
+
+function BigNum.mt.sub( num1 , num2 )
+   local temp = BigNum.new() ;
+   local bnum1 = BigNum.new( num1 ) ;
+   local bnum2 = BigNum.new( num2 ) ;
+   BigNum.sub( bnum1 , bnum2 , temp ) ;
+   return temp ;
+end
+function BigNum.mt.mod( num1 , num2 )
+   return BigNum.new(num1 - (num1/num2)*num2)
+end
+function BigNum.mt.add( num1 , num2 )
+   local temp = BigNum.new() ;
+   local bnum1 = BigNum.new( num1 ) ;
+   local bnum2 = BigNum.new( num2 ) ;
+   BigNum.add( bnum1 , bnum2 , temp ) ;
+   return temp ;
+end
+
+function BigNum.mt.mul( num1 , num2 )
+   local temp = BigNum.new() ;
+   local bnum1 = BigNum.new( num1 ) ;
+   local bnum2 = BigNum.new( num2 ) ;
+   BigNum.mul( bnum1 , bnum2 , temp ) ;
+   return temp ;
+end
+
+function BigNum.mt.div( num1 , num2 )
+   local bnum1 = {} ;
+   local bnum2 = {} ;
+   local bnum3 = BigNum.new() ;
+   local bnum4 = BigNum.new() ;
+   bnum1 = BigNum.new( num1 ) ;
+   bnum2 = BigNum.new( num2 ) ;
+   BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 ) ;
+   return bnum3 , bnum4 ;
+end
+
+function BigNum.mt.tostring( bnum )
+   local i = 0 ;
+   local j = 0 ;
+   local str = "" ;
+   local temp = "" ;
+   if bnum == nil then
+      return "nil" ;
+   elseif bnum.len > 0 then
+      for i = bnum.len - 2 , 0 , -1  do
+         for j = 0 , RADIX_LEN - string.len( bnum[i] ) - 1 do
+            temp = temp .. '0' ;
+         end
+         temp = temp .. bnum[i] ;
+      end
+	  if bnum[bnum.len - 1]==nil then
+		return "nil"
+	  end
+      temp = bnum[bnum.len - 1] .. temp ;
+      if bnum.signal == '-' then
+         temp = bnum.signal .. temp ;
+      end
+      return temp ;
+   else
+      return "" ;
+   end
+end
+
+function BigNum.mt.pow( num1 , num2 )
+   local bnum1 = BigNum.new( num1 ) ;
+   local bnum2 = BigNum.new( num2 ) ;
+   return BigNum.pow( bnum1 , bnum2 ) ;
+end
+
+function BigNum.mt.eq( num1 , num2 )
+   local bnum1 = BigNum.new( num1 ) ;
+   local bnum2 = BigNum.new( num2 ) ;
+   return BigNum.eq( bnum1 , bnum2 ) ;
+end
+
+function BigNum.mt.lt( num1 , num2 )
+   local bnum1 = BigNum.new( num1 ) ;
+   local bnum2 = BigNum.new( num2 ) ;
+   return BigNum.lt( bnum1 , bnum2 ) ;
+end
+
+function BigNum.mt.le( num1 , num2 )
+   local bnum1 = BigNum.new( num1 ) ;
+   local bnum2 = BigNum.new( num2 ) ;
+   return BigNum.le( bnum1 , bnum2 ) ;
+end
+
+function BigNum.mt.unm( num )
+   local ret = BigNum.new( num )
+   if ret.signal == '+' then
+      ret.signal = '-'
+   else
+      ret.signal = '+'
+   end
+   return ret
+end
+
+BigNum.mt.__metatable = "hidden"
+BigNum.mt.__tostring  = BigNum.mt.tostring ;
+BigNum.mt.__add = BigNum.mt.add ;
+BigNum.mt.__sub = BigNum.mt.sub ;
+BigNum.mt.__mul = BigNum.mt.mul ;
+BigNum.mt.__div = BigNum.mt.div ;
+BigNum.mt.__pow = BigNum.mt.pow ;
+BigNum.mt.__unm = BigNum.mt.unm ;
+BigNum.mt.__mod = BigNum.mt.mod ;
+BigNum.mt.__eq = BigNum.mt.eq   ;
+BigNum.mt.__le = BigNum.mt.le   ;
+BigNum.mt.__lt = BigNum.mt.lt   ;
+setmetatable( BigNum.mt, { __index = "inexistent field", __newindex = "not available", __metatable="hidden" } ) ;
+function BigNum.add( bnum1 , bnum2 , bnum3 )
+   local maxlen = 0 ;
+   local i = 0 ;
+   local carry = 0 ;
+   local signal = '+' ;
+   local old_len = 0 ;
+   --Handle the signals
+   if bnum1 == nil or bnum2 == nil or bnum3 == nil then
+      error("Function BigNum.add: parameter nil") ;
+   elseif bnum1.signal == '-' and bnum2.signal == '+' then
+      bnum1.signal = '+' ;
+      BigNum.sub( bnum2 , bnum1 , bnum3 ) ;
+
+      if not rawequal(bnum1, bnum3) then
+         bnum1.signal = '-' ;
+      end
+      return 0 ;
+   elseif bnum1.signal == '+' and bnum2.signal == '-' then
+      bnum2.signal = '+' ;
+      BigNum.sub( bnum1 , bnum2 , bnum3 ) ;
+      if not rawequal(bnum2, bnum3) then
+         bnum2.signal = '-' ;
+      end
+      return 0 ;
+   elseif bnum1.signal == '-' and bnum2.signal == '-' then
+      signal = '-' ;
+   end
+   --
+   old_len = bnum3.len ;
+   if bnum1.len > bnum2.len then
+      maxlen = bnum1.len ;
+   else
+      maxlen = bnum2.len ;
+      bnum1 , bnum2 = bnum2 , bnum1 ;
+   end
+   --School grade sum
+   for i = 0 , maxlen - 1 do
+      if bnum2[i] ~= nil then
+         bnum3[i] = bnum1[i] + bnum2[i] + carry ;
+      else
+         bnum3[i] = bnum1[i] + carry ;
+      end
+      if bnum3[i] >= RADIX then
+         bnum3[i] = bnum3[i] - RADIX ;
+         carry = 1 ;
+      else
+         carry = 0 ;
+      end
+   end
+   --Update the answer's size
+   if carry == 1 then
+      bnum3[maxlen] = 1 ;
+   end
+   bnum3.len = maxlen + carry ;
+   bnum3.signal = signal ;
+   for i = bnum3.len, old_len do
+      bnum3[i] = nil ;
+   end
+   return 0 ;
+end
+
+function BigNum.sub( bnum1 , bnum2 , bnum3 )
+   local maxlen = 0 ;
+   local i = 0 ;
+   local carry = 0 ;
+   local old_len = 0 ;
+   if bnum1 == nil or bnum2 == nil or bnum3 == nil then
+      error("Function BigNum.sub: parameter nil") ;
+   elseif bnum1.signal == '-' and bnum2.signal == '+' then
+      bnum1.signal = '+' ;
+      BigNum.add( bnum1 , bnum2 , bnum3 ) ;
+      bnum3.signal = '-' ;
+      if not rawequal(bnum1, bnum3) then
+         bnum1.signal = '-' ;
+      end
+      return 0 ;
+   elseif bnum1.signal == '-' and bnum2.signal == '-' then
+      bnum1.signal = '+' ;
+      bnum2.signal = '+' ;
+      BigNum.sub( bnum2, bnum1 , bnum3 ) ;
+      if not rawequal(bnum1, bnum3) then
+         bnum1.signal = '-' ;
+      end
+      if not rawequal(bnum2, bnum3) then
+         bnum2.signal = '-' ;
+      end
+      return 0 ;
+   elseif bnum1.signal == '+' and bnum2.signal == '-' then
+      bnum2.signal = '+' ;
+      BigNum.add( bnum1 , bnum2 , bnum3 ) ;
+      if not rawequal(bnum2, bnum3) then
+         bnum2.signal = '-' ;
+      end
+      return 0 ;
+   end
+   --Tests if bnum2 > bnum1
+   if BigNum.compareAbs( bnum1 , bnum2 ) == 2 then
+      BigNum.sub( bnum2 , bnum1 , bnum3 ) ;
+      bnum3.signal = '-' ;
+      return 0 ;
+   else
+      maxlen = bnum1.len ;
+   end
+   old_len = bnum3.len ;
+   bnum3.len = 0 ;
+   --School grade subtraction
+   for i = 0 , maxlen - 1 do
+      if bnum2[i] ~= nil then
+         bnum3[i] = bnum1[i] - bnum2[i] - carry ;
+      else
+         bnum3[i] = bnum1[i] - carry ;
+      end
+      if bnum3[i] < 0 then
+         bnum3[i] = RADIX + bnum3[i] ;
+         carry = 1 ;
+      else
+         carry = 0 ;
+      end
+
+      if bnum3[i] ~= 0 then
+         bnum3.len = i + 1 ;
+      end
+   end
+   bnum3.signal = '+' ;
+   --Check if answer's size if zero
+   if bnum3.len == 0 then
+      bnum3.len = 1 ;
+      bnum3[0]  = 0 ;
+   end
+   if carry == 1 then
+      error( "Error in function sub" ) ;
+   end
+   for i = bnum3.len , max( old_len , maxlen - 1 ) do
+      bnum3[i] = nil ;
+   end
+   return 0 ;
+end
+
+function BigNum.mul( bnum1 , bnum2 , bnum3 )
+   local i = 0 ; j = 0 ;
+   local temp = BigNum.new( ) ;
+   local temp2 = 0 ;
+   local carry = 0 ;
+   local oldLen = bnum3.len ;
+   if bnum1 == nil or bnum2 == nil or bnum3 == nil then
+      error("Function BigNum.mul: parameter nil") ;
+   --Handle the signals
+   elseif bnum1.signal ~= bnum2.signal then
+      BigNum.mul( bnum1 , -bnum2 , bnum3 ) ;
+      bnum3.signal = '-' ;
+      return 0 ;
+   end
+   bnum3.len =  ( bnum1.len ) + ( bnum2.len ) ;
+   --Fill with zeros
+   for i = 1 , bnum3.len do
+      bnum3[i - 1] = 0 ;
+   end
+   --Places nil where passes through this
+   for i = bnum3.len , oldLen do
+      bnum3[i] = nil ;
+   end
+   --School grade multiplication
+   for i = 0 , bnum1.len - 1 do
+      for j = 0 , bnum2.len - 1 do
+         carry =  ( bnum1[i] * bnum2[j] + carry ) ;
+         carry = carry + bnum3[i + j] ;
+         bnum3[i + j] = ( carry % RADIX ) ;
+         temp2 = bnum3[i + j] ;
+         carry =  math.floor ( carry / RADIX ) ;
+      end
+      if carry ~= 0 then
+         bnum3[i + bnum2.len] = carry ;
+      end
+      carry = 0 ;
+   end
+
+   --Update the answer's size
+   for i = bnum3.len - 1 , 1 , -1 do
+      if bnum3[i] ~= nil and bnum3[i] ~= 0 then
+         break ;
+      else
+         bnum3[i] = nil ;
+      end
+      bnum3.len = bnum3.len - 1 ;
+   end
+   return 0 ;
+end
+
+function BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 )
+   local temp = BigNum.new() ;
+   local temp2 = BigNum.new() ;
+   local one = BigNum.new( "1" ) ;
+   local zero = BigNum.new( "0" ) ;
+   --Check division by zero
+   if BigNum.compareAbs( bnum2 , zero ) == 0 then
+      error( "Function BigNum.div: Division by zero" ) ;
+   end
+   --Handle the signals
+   if bnum1 == nil or bnum2 == nil or bnum3 == nil or bnum4 == nil then
+      error( "Function BigNum.div: parameter nil" ) ;
+   elseif bnum1.signal == "+" and bnum2.signal == "-" then
+      bnum2.signal = "+" ;
+      BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 ) ;
+      bnum2.signal = "-" ;
+      bnum3.signal = "-" ;
+      return 0 ;
+   elseif bnum1.signal == "-" and bnum2.signal == "+" then
+      bnum1.signal = "+" ;
+      BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 ) ;
+      bnum1.signal = "-" ;
+      if bnum4 < zero then --Check if remainder is negative
+         BigNum.add( bnum3 , one , bnum3 ) ;
+         BigNum.sub( bnum2 , bnum4 , bnum4 ) ;
+      end
+      bnum3.signal = "-" ;
+      return 0 ;
+   elseif bnum1.signal == "-" and bnum2.signal == "-" then
+      bnum1.signal = "+" ;
+      bnum2.signal = "+" ;
+      BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 ) ;
+      bnum1.signal = "-" ;
+      if bnum4 < zero then --Check if remainder is negative
+         BigNum.add( bnum3 , one , bnum3 ) ;
+         BigNum.sub( bnum2 , bnum4 , bnum4 ) ;
+      end
+      bnum2.signal = "-" ;
+      return 0 ;
+   end
+   temp.len = bnum1.len - bnum2.len - 1 ;
+
+   --Reset variables
+   BigNum.change( bnum3 , "0" ) ;
+   BigNum.change( bnum4 , "0" ) ;
+
+   BigNum.copy( bnum1 , bnum4 ) ;
+
+   --Check if can continue dividing
+   while( BigNum.compareAbs( bnum4 , bnum2 ) ~= 2 ) do
+      if bnum4[bnum4.len - 1] >= bnum2[bnum2.len - 1] then
+         BigNum.put( temp , math.floor( bnum4[bnum4.len - 1] / bnum2[bnum2.len - 1] ) , bnum4.len - bnum2.len ) ;
+         temp.len = bnum4.len - bnum2.len + 1 ;
+      else
+         BigNum.put( temp , math.floor( ( bnum4[bnum4.len - 1] * RADIX + bnum4[bnum4.len - 2] ) / bnum2[bnum2.len -1] ) , bnum4.len - bnum2.len - 1 ) ;
+         temp.len = bnum4.len - bnum2.len ;
+      end
+
+      if bnum4.signal ~= bnum2.signal then
+         temp.signal = "-";
+      else
+         temp.signal = "+";
+      end
+      BigNum.add( temp , bnum3 , bnum3 )  ;
+      temp = temp * bnum2 ;
+      BigNum.sub( bnum4 , temp , bnum4 ) ;
+   end
+
+   --Update if the remainder is negative
+   if bnum4.signal == '-' then
+      decr( bnum3 ) ;
+      BigNum.add( bnum2 , bnum4 , bnum4 ) ;
+   end
+   return 0 ;
+end
+
+function BigNum.pow( bnum1 , bnum2 )
+   local n = BigNum.new( bnum2 ) ;
+   local y = BigNum.new( 1 ) ;
+   local z = BigNum.new( bnum1 ) ;
+   local zero = BigNum.new( "0" ) ;
+   if bnum2 < zero then
+      error( "Function BigNum.exp: domain error" ) ;
+   elseif bnum2 == zero then
+      return y ;
+   end
+   while 1 do
+      if ( n[0] % 2 ) == 0 then
+         n = n / 2 ;
+      else
+         n = n / 2 ;
+         y = z * y  ;
+         if n == zero then
+            return y ;
+         end
+      end
+      z = z * z ;
+   end
+end
+-- Português :
+BigNum.exp = BigNum.pow
+
+function BigNum.gcd( bnum1 , bnum2 )
+   local a = {} ;
+   local b = {} ;
+   local c = {} ;
+   local d = {} ;
+   local zero = {} ;
+   zero = BigNum.new( "0" ) ;
+   if bnum1 == zero or bnum2 == zero then
+      return BigNum.new( "1" ) ;
+   end
+   a = BigNum.new( bnum1 ) ;
+   b = BigNum.new( bnum2 ) ;
+   a.signal = '+' ;
+   b.signal = '+' ;
+   c = BigNum.new() ;
+   d = BigNum.new() ;
+   while b > zero do
+      BigNum.div( a , b , c , d ) ;
+      a , b , d = b , d , a ;
+   end
+   return a ;
+end
+-- Português:
+BigNum.mmc = BigNum.gcd
+
+function BigNum.eq( bnum1 , bnum2 )
+   if BigNum.compare( bnum1 , bnum2 ) == 0 then
+      return true ;
+   else
+      return false ;
+   end
+end
+
+function BigNum.lt( bnum1 , bnum2 )
+   if BigNum.compare( bnum1 , bnum2 ) == 2 then
+      return true ;
+   else
+      return false ;
+   end
+end
+
+function BigNum.le( bnum1 , bnum2 )
+   local temp = -1 ;
+   temp = BigNum.compare( bnum1 , bnum2 )
+   if temp == 0 or temp == 2 then
+      return true ;
+   else
+      return false ;
+   end
+end
+
+function BigNum.compareAbs( bnum1 , bnum2 )
+   if bnum1 == nil or bnum2 == nil then
+      error("Function compare: parameter nil") ;
+   elseif bnum1.len > bnum2.len then
+      return 1 ;
+   elseif bnum1.len < bnum2.len then
+      return 2 ;
+   else
+      local i ;
+      for i = bnum1.len - 1 , 0 , -1 do
+         if bnum1[i] > bnum2[i] then
+            return 1 ;
+         elseif bnum1[i] < bnum2[i] then
+            return 2 ;
+         end
+      end
+   end
+   return 0 ;
+end
+
+function BigNum.compare( bnum1 , bnum2 )
+   local signal = 0 ;
+
+   if bnum1 == nil or bnum2 == nil then
+      error("Funtion BigNum.compare: parameter nil") ;
+   elseif bnum1.signal == '+' and bnum2.signal == '-' then
+      return 1 ;
+   elseif bnum1.signal == '-' and bnum2.signal == '+' then
+      return 2 ;
+   elseif bnum1.signal == '-' and bnum2.signal == '-' then
+      signal = 1 ;
+   end
+   if bnum1.len > bnum2.len then
+      return 1 + signal ;
+   elseif bnum1.len < bnum2.len then
+      return 2 - signal ;
+   else
+      local i ;
+      for i = bnum1.len - 1 , 0 , -1 do
+         if bnum1[i] > bnum2[i] then
+            return 1 + signal ;
+	 elseif bnum1[i] < bnum2[i] then
+	    return 2 - signal ;
+	 end
+      end
+   end
+   return 0 ;
+end
+
+function BigNum.copy( bnum1 , bnum2 )
+   if bnum1 ~= nil and bnum2 ~= nil then
+      local i ;
+      for i = 0 , bnum1.len - 1 do
+         bnum2[i] = bnum1[i] ;
+      end
+      bnum2.len = bnum1.len ;
+   else
+      error("Function BigNum.copy: parameter nil") ;
+   end
+end
+
+function BigNum.change( bnum1 , num )
+   local j = 0 ;
+   local len = 0  ;
+   local num = num ;
+   local l ;
+   local oldLen = 0 ;
+   if bnum1 == nil then
+      error( "BigNum.change: parameter nil" ) ;
+   elseif type( bnum1 ) ~= "table" then
+      error( "BigNum.change: parameter error, type unexpected" ) ;
+   elseif num == nil then
+      bnum1.len = 1 ;
+      bnum1[0] = 0 ;
+      bnum1.signal = "+";
+   elseif type( num ) == "table" and num.len ~= nil then  --check if num is a big number
+      --copy given table to the new one
+      for i = 0 , num.len do
+         bnum1[i] = num[i] ;
+      end
+      if num.signal ~= '-' and num.signal ~= '+' then
+         bnum1.signal = '+' ;
+      else
+         bnum1.signal = num.signal ;
+      end
+      oldLen = bnum1.len ;
+      bnum1.len = num.len ;
+   elseif type( num ) == "string" or type( num ) == "number" then
+      if string.sub( num , 1 , 1 ) == '+' or string.sub( num , 1 , 1 ) == '-' then
+         bnum1.signal = string.sub( num , 1 , 1 ) ;
+         num = string.sub(num, 2) ;
+      else
+         bnum1.signal = '+' ;
+      end
+      num = string.gsub( num , " " , "" ) ;
+      local sf = string.find( num , "e" ) ;
+      --Handles if the number is in exp notation
+      if sf ~= nil then
+         num = string.gsub( num , "%." , "" ) ;
+         local e = string.sub( num , sf + 1 ) ;
+         e = tonumber(e) ;
+         if e ~= nil and e > 0 then
+            e = tonumber(e) ;
+         else
+            error( "Function BigNum.change: string is not a valid number" ) ;
+         end
+         num = string.sub( num , 1 , sf - 2 ) ;
+         for i = string.len( num ) , e do
+            num = num .. "0" ;
+         end
+      else
+         sf = string.find( num , "%." ) ;
+         if sf ~= nil then
+            num = string.sub( num , 1 , sf - 1 ) ;
+         end
+      end
+
+      l = string.len( num ) ;
+      oldLen = bnum1.len ;
+      if (l > RADIX_LEN) then
+         local mod = l-( math.floor( l / RADIX_LEN ) * RADIX_LEN ) ;
+         for i = 1 , l-mod, RADIX_LEN do
+            bnum1[j] = tonumber( string.sub( num, -( i + RADIX_LEN - 1 ) , -i ) );
+            --Check if string dosn't represents a number
+            if bnum1[j] == nil then
+               error( "Function BigNum.change: string is not a valid number" ) ;
+               bnum1.len = 0 ;
+               return 1 ;
+            end
+            j = j + 1 ;
+            len = len + 1 ;
+         end
+         if (mod ~= 0) then
+            bnum1[j] = tonumber( string.sub( num , 1 , mod ) ) ;
+            bnum1.len = len + 1 ;
+         else
+            bnum1.len = len ;
+         end
+         --Eliminate trailing zeros
+         for i = bnum1.len - 1 , 1 , -1 do
+            if bnum1[i] == 0 then
+               bnum1[i] = nil ;
+               bnum1.len = bnum1.len - 1 ;
+            else
+               break ;
+            end
+         end
+
+      else
+         -- string.len(num) <= RADIX_LEN
+         bnum1[j] = tonumber( num ) ;
+         bnum1.len = 1 ;
+      end
+   else
+      error( "Function BigNum.change: parameter error, type unexpected" ) ;
+   end
+
+   --eliminates the deprecated higher order 'algarisms'
+   if oldLen ~= nil then
+      for i = bnum1.len , oldLen do
+         bnum1[i] = nil ;
+      end
+   end
+
+   return 0 ;
+end
+
+function BigNum.put( bnum , int , pos )
+   if bnum == nil then
+      error("Function BigNum.put: parameter nil") ;
+   end
+   local i = 0 ;
+   for i = 0 , pos - 1 do
+      bnum[i] = 0 ;
+   end
+   bnum[pos] = int ;
+   for i = pos + 1 , bnum.len do
+      bnum[i] = nil ;
+   end
+   bnum.len = pos ;
+   return 0 ;
+end
+
+--printraw{{{2
+function printraw( bnum )
+   local i = 0 ;
+   if bnum == nil then
+      error( "Function printraw: parameter nil" ) ;
+   end
+   while 1 == 1 do
+      if bnum[i] == nil then
+         io.write( ' len '..bnum.len ) ;
+         if i ~= bnum.len then
+            io.write( ' ERRO!!!!!!!!' ) ;
+         end
+         io.write( "\n" ) ;
+         return 0 ;
+      end
+      io.write( 'r'..bnum[i] ) ;
+      i = i + 1 ;
+   end
+end
+--max{{{2
+function max( int1 , int2 )
+   if int1 > int2 then
+      return int1 ;
+   else
+      return int2 ;
+   end
+end
+
+--decr{{{2
+function decr( bnum1 )
+   local temp = {} ;
+   temp = BigNum.new( "1" ) ;
+   BigNum.sub( bnum1 , temp , bnum1 ) ;
+   return 0 ;
+end

bin/numbers/BigRat.lua

@@ -0,0 +1,227 @@
+require( "bin.numbers.BigNum" ) ;
+
+BigRat = {} ;
+BigRat.mt = {} ;
+function BigRat.new( num1 , num2 ) --{{{2
+   local bigrat = {} ;
+   local f ;
+   setmetatable(bigrat, BigRat.mt) ;
+   if type( num1 ) == "table" then
+      if num1.num ~= nil and num1.den ~= nil then
+         bigrat.num = BigNum.new( num1.num ) ;
+         bigrat.den = BigNum.new( num1.den ) ;
+      else
+         bigrat.num = BigNum.new( num1 ) ;
+         bigrat.den = BigNum.new( "1" ) ;
+      end
+   elseif num1 ~= nil then
+      if num2 == nil then
+         bigrat.den = BigNum.new( "1" ) ;
+      else
+         bigrat.den = BigNum.new( num2 ) ;
+      end
+      bigrat.num = BigNum.new( num1 ) ;
+   else
+      bigrat.den = BigNum.new( ) ;
+      bigrat.num = BigNum.new( ) ;
+   end
+
+   --Update the signals
+   if bigrat.den.signal == "-" then
+      if bigrat.num.signal == "-" then
+         bigrat.num.signal = "+" ;
+      else
+         bigrat.num.signal = "-" ;
+      end
+      bigrat.den.signal = "+" ;
+   end
+
+   return bigrat ;
+end
+
+function BigRat.mt.sub( num1 , num2 )
+   local temp = BigRat.new() ;
+   local brat1 = BigRat.new( num1 ) ;
+   local brat2 = BigRat.new( num2 ) ;
+   BigRat.sub( brat1 , brat2 , temp ) ;
+   return temp ;
+end
+
+function BigRat.mt.add( num1 , num2 )
+   local temp = BigRat.new() ;
+   local brat1 = BigRat.new( num1 ) ;
+   local brat2 = BigRat.new( num2 ) ;
+   BigRat.add( brat1 , brat2 , temp ) ;
+   return temp ;
+end
+
+function BigRat.mt.mul( num1 , num2 )
+   local temp = BigRat.new() ;
+   local brat1 = BigRat.new( num1 ) ;
+   local brat2 = BigRat.new( num2 ) ;
+   BigRat.mul( brat1 , brat2 , temp ) ;
+   return temp ;
+end
+
+function BigRat.mt.div( num1 , num2 )
+   local brat1 = BigRat.new( num1 ) ;
+   local brat2 = BigRat.new( num2 ) ;
+   local brat3 = BigRat.new() ;
+   local brat4 = BigRat.new() ;
+   BigRat.div( brat1 , brat2 , brat3 , brat4 ) ;
+   return brat3 , brat4 ;
+end
+
+function BigRat.mt.tostring( brat )
+   BigRat.simplify( brat ) ;
+   return BigNum.mt.tostring( brat.num ) .. " / " .. BigNum.mt.tostring( brat.den ) ;
+end
+
+function BigRat.mt.pow ( num1 , num2 )
+   local brat1 = BigRat.new( num1 ) ;
+   local brat2 = BigRat.new( num2 ) ;
+   return BigRat.pow( brat1 , brat2 )
+end
+
+function BigRat.mt.eq ( num1 , num2 )
+   return BigRat.eq( num1 , num2 )
+end
+
+function BigRat.mt.lt ( num1 , num2 )
+   return BigRat.lt( num1 , num2 )
+end
+
+function BigRat.mt.le ( num1 , num2 )
+   return BigRat.le( num1 , num2 )
+end
+
+function BigRat.mt.unm ( num )
+   local ret = BigRat.new( num )
+   if ret.num.signal == '-' then
+      ret.num.signal = '+'
+   else
+      ret.num.signal = '-'
+   end
+   return ret
+end
+
+BigRat.mt.__metatable = "hidden"
+BigRat.mt.__tostring  = BigRat.mt.tostring
+BigRat.mt.__add = BigRat.mt.add
+BigRat.mt.__sub = BigRat.mt.sub
+BigRat.mt.__mul = BigRat.mt.mul
+BigRat.mt.__div = BigRat.mt.div
+BigRat.mt.__pow = BigRat.mt.pow
+BigRat.mt.__unm = BigRat.mt.unm
+BigRat.mt.__eq = BigRat.mt.eq
+BigRat.mt.__le = BigRat.mt.le
+BigRat.mt.__lt = BigRat.mt.lt
+setmetatable( BigRat.mt, { __index = "inexistent field", __newindex = "not available", __metatable="hidden" } ) ;
+function BigRat.add( brat1 , brat2 , brat3 )
+   brat3.den = brat1.den * brat2.den ;
+   brat3.num = ( brat1.num * brat2.den ) + ( brat2.num * brat1.den ) ;
+   return brat3 ;
+end
+function BigRat.sub( brat1 , brat2 , brat3 )
+   brat3.den = brat1.den * brat2.den ;
+   brat3.num = ( brat1.num * brat2.den ) - ( brat2.num * brat1.den ) ;
+   return brat3 ;
+end
+
+function BigRat.mul( brat1 , brat2 , brat3 )
+   brat3.num = brat1.num * brat2.num ;
+   brat3.den = brat1.den * brat2.den ;
+   return 0 ;
+end
+
+function BigRat.div( brat1 , brat2 , brat3 )
+   brat3.num = brat1.num * brat2.den ;
+   brat3.den = brat1.den * brat2.num ;
+   return brat3 ;
+end
+
+function BigRat.pow( bnum1 , bnum2 )
+   if bnum1 == nil or bnum2 == nil then
+      error( "Function BigRat.pow: parameter nil" ) ;
+   end
+   local x = BigRat.new( "8" ) ;
+   local n = BigRat.new( bnum2.den ) ;
+   local n2 ;
+   local y = BigRat.new( ) ;
+   local i ;
+   local temp = BigRat.new( ) ;
+
+   BigRat.simplify( bnum2 ) ;
+   temp.num = BigNum.exp( bnum1.num , bnum2.num ) ;
+   temp.den = BigNum.exp( bnum1.den , bnum2.num ) ;
+   n2 = n - 1 ;
+
+   for i = 0 , 4 do
+      y.num = x.num ^ n2.num ;
+      y.den = x.den ^ n2.num ;
+      x = (( temp / y ) + ( n2 * x )) / n ;
+   end
+   return x ;
+end
+
+function BigRat.simplify( brat )
+   if brat == nil then
+      error( "Function BigRat.simplify: parameter nil" ) ;
+   end
+   local gcd  = BigNum.new( ) ;
+   local temp = BigRat.new( brat ) ;
+   local devnull = BigNum.new( ) ;
+   local zero = BigNum.new( "0" ) ;
+   --Check if numerator is zero
+   if BigNum.compareAbs( brat.num , zero ) == 0 then
+      brat.den = BigNum.new( "1" ) ;
+      return 0 ;
+   end
+   gcd = BigNum.gcd( brat.num , brat.den ) ;
+   BigNum.div( temp.num , gcd , brat.num , devnull ) ;
+   BigNum.div( temp.den , gcd , brat.den , devnull ) ;
+   --Update the signal
+   if brat.num.signal == '-' and brat.den.signal == '-' then
+      brat.num.signal = '+' ;
+      brat.den.signal = '+' ;
+   end
+   return 0 ;
+end
+
+function BigRat.eq( brat1 , brat2 )
+   if BigRat.compare( brat1 , brat2 ) == 0 then
+      return true ;
+   else
+      return false ;
+   end
+end
+
+function BigRat.lt( brat1 , brat2 )
+   if BigRat.compare( brat1 , brat2 ) == 2 then
+      return true ;
+   else
+      return false ;
+   end
+end
+
+function BigRat.le( brat1 , brat2 )
+   local temp = -1 ;
+   temp = BigRat.compare( brat1 , brat2 )
+   if temp == 0 or temp == 2 then
+      return true ;
+   else
+      return false ;
+   end
+end
+
+function BigRat.compare( bnum1 , bnum2 )
+   local temp ;
+   temp = bnum1 - bnum2 ;
+   if temp.num[0] == 0 and temp.num.len == 1 then --Check if is zero
+      return 0 ;
+   elseif temp.num.signal == "-" then
+      return 2 ;
+   else
+      return 1 ;
+   end
+end

bin/numbers/no_jit_bit.lua

@@ -0,0 +1,333 @@
+--[[
+LICENSE
+
+  (c) 2008-2011 David Manura.  Licensed under the same terms as Lua (MIT).
+--]]
+
+local M = {_TYPE='module', _NAME='bit.numberlua', _VERSION='0.3.1.20120131'}
+
+local floor = math.floor
+
+local MOD = 2^32
+local MODM = MOD-1
+
+local function memoize(f)
+  local mt = {}
+  local t = setmetatable({}, mt)
+  function mt:__index(k)
+    local v = f(k); t[k] = v
+    return v
+  end
+  return t
+end
+
+local function make_bitop_uncached(t, m)
+  local function bitop(a, b)
+    local res,p = 0,1
+    while a ~= 0 and b ~= 0 do
+      local am, bm = a%m, b%m
+      res = res + t[am][bm]*p
+      a = (a - am) / m
+      b = (b - bm) / m
+      p = p*m
+    end
+    res = res + (a+b)*p
+    return res
+  end
+  return bitop
+end
+
+local function make_bitop(t)
+  local op1 = make_bitop_uncached(t,2^1)
+  local op2 = memoize(function(a)
+    return memoize(function(b)
+      return op1(a, b)
+    end)
+  end)
+  return make_bitop_uncached(op2, 2^(t.n or 1))
+end
+
+-- ok?  probably not if running on a 32-bit int Lua number type platform
+function M.tobit(x)
+  return x % 2^32
+end
+
+M.bxor = make_bitop {[0]={[0]=0,[1]=1},[1]={[0]=1,[1]=0}, n=4}
+local bxor = M.bxor
+
+function M.bnot(a)   return MODM - a end
+local bnot = M.bnot
+
+function M.band(a,b) return ((a+b) - bxor(a,b))/2 end
+local band = M.band
+
+function M.bor(a,b)  return MODM - band(MODM - a, MODM - b) end
+local bor = M.bor
+
+local lshift, rshift -- forward declare
+
+function M.rshift(a,disp) -- Lua5.2 insipred
+  if disp < 0 then return lshift(a,-disp) end
+  return floor(a % 2^32 / 2^disp)
+end
+rshift = M.rshift
+
+function M.lshift(a,disp) -- Lua5.2 inspired
+  if disp < 0 then return rshift(a,-disp) end 
+  return (a * 2^disp) % 2^32
+end
+lshift = M.lshift
+
+function M.tohex(x, n) -- BitOp style
+  n = n or 8
+  local up
+  if n <= 0 then
+    if n == 0 then return '' end
+    up = true
+    n = - n
+  end
+  x = band(x, 16^n-1)
+  return ('%0'..n..(up and 'X' or 'x')):format(x)
+end
+local tohex = M.tohex
+
+function M.extract(n, field, width) -- Lua5.2 inspired
+  width = width or 1
+  return band(rshift(n, field), 2^width-1)
+end
+local extract = M.extract
+
+function M.replace(n, v, field, width) -- Lua5.2 inspired
+  width = width or 1
+  local mask1 = 2^width-1
+  v = band(v, mask1) -- required by spec?
+  local mask = bnot(lshift(mask1, field))
+  return band(n, mask) + lshift(v, field)
+end
+local replace = M.replace
+
+function M.bswap(x)  -- BitOp style
+  local a = band(x, 0xff); x = rshift(x, 8)
+  local b = band(x, 0xff); x = rshift(x, 8)
+  local c = band(x, 0xff); x = rshift(x, 8)
+  local d = band(x, 0xff)
+  return lshift(lshift(lshift(a, 8) + b, 8) + c, 8) + d
+end
+local bswap = M.bswap
+
+function M.rrotate(x, disp)  -- Lua5.2 inspired
+  disp = disp % 32
+  local low = band(x, 2^disp-1)
+  return rshift(x, disp) + lshift(low, 32-disp)
+end
+local rrotate = M.rrotate
+
+function M.lrotate(x, disp)  -- Lua5.2 inspired
+  return rrotate(x, -disp)
+end
+local lrotate = M.lrotate
+
+M.rol = M.lrotate  -- LuaOp inspired
+M.ror = M.rrotate  -- LuaOp insipred
+
+
+function M.arshift(x, disp) -- Lua5.2 inspired
+  local z = rshift(x, disp)
+  if x >= 0x80000000 then z = z + lshift(2^disp-1, 32-disp) end
+  return z
+end
+local arshift = M.arshift
+
+function M.btest(x, y) -- Lua5.2 inspired
+  return band(x, y) ~= 0
+end
+
+M.bit32 = {} -- Lua 5.2 'bit32' compatibility
+
+
+local function bit32_bnot(x)
+  return (-1 - x) % MOD
+end
+M.bit32.bnot = bit32_bnot
+
+local function bit32_bxor(a, b, c, ...)
+  local z
+  if b then
+    a = a % MOD
+    b = b % MOD
+    z = bxor(a, b)
+    if c then
+      z = bit32_bxor(z, c, ...)
+    end
+    return z
+  elseif a then
+    return a % MOD
+  else
+    return 0
+  end
+end
+M.bit32.bxor = bit32_bxor
+
+local function bit32_band(a, b, c, ...)
+  local z
+  if b then
+    a = a % MOD
+    b = b % MOD
+    z = ((a+b) - bxor(a,b)) / 2
+    if c then
+      z = bit32_band(z, c, ...)
+    end
+    return z
+  elseif a then
+    return a % MOD
+  else
+    return MODM
+  end
+end
+M.bit32.band = bit32_band
+
+local function bit32_bor(a, b, c, ...)
+  local z
+  if b then
+    a = a % MOD
+    b = b % MOD
+    z = MODM - band(MODM - a, MODM - b)
+    if c then
+      z = bit32_bor(z, c, ...)
+    end
+    return z
+  elseif a then
+    return a % MOD
+  else
+    return 0
+  end
+end
+M.bit32.bor = bit32_bor
+
+function M.bit32.btest(...)
+  return bit32_band(...) ~= 0
+end
+
+function M.bit32.lrotate(x, disp)
+  return lrotate(x % MOD, disp)
+end
+
+function M.bit32.rrotate(x, disp)
+  return rrotate(x % MOD, disp)
+end
+
+function M.bit32.lshift(x,disp)
+  if disp > 31 or disp < -31 then return 0 end
+  return lshift(x % MOD, disp)
+end
+
+function M.bit32.rshift(x,disp)
+  if disp > 31 or disp < -31 then return 0 end
+  return rshift(x % MOD, disp)
+end
+
+function M.bit32.arshift(x,disp)
+  x = x % MOD
+  if disp >= 0 then
+    if disp > 31 then
+      return (x >= 0x80000000) and MODM or 0
+    else
+      local z = rshift(x, disp)
+      if x >= 0x80000000 then z = z + lshift(2^disp-1, 32-disp) end
+      return z
+    end
+  else
+    return lshift(x, -disp)
+  end
+end
+
+function M.bit32.extract(x, field, ...)
+  local width = ... or 1
+  if field < 0 or field > 31 or width < 0 or field+width > 32 then error 'out of range' end
+  x = x % MOD
+  return extract(x, field, ...)
+end
+
+function M.bit32.replace(x, v, field, ...)
+  local width = ... or 1
+  if field < 0 or field > 31 or width < 0 or field+width > 32 then error 'out of range' end
+  x = x % MOD
+  v = v % MOD
+  return replace(x, v, field, ...)
+end
+
+M.bit = {} -- LuaBitOp "bit" compatibility
+
+function M.bit.tobit(x)
+  x = x % MOD
+  if x >= 0x80000000 then x = x - MOD end
+  return x
+end
+local bit_tobit = M.bit.tobit
+
+function M.bit.tohex(x, ...)
+  return tohex(x % MOD, ...)
+end
+
+function M.bit.bnot(x)
+  return bit_tobit(bnot(x % MOD))
+end
+
+local function bit_bor(a, b, c, ...)
+  if c then
+    return bit_bor(bit_bor(a, b), c, ...)
+  elseif b then
+    return bit_tobit(bor(a % MOD, b % MOD))
+  else
+    return bit_tobit(a)
+  end
+end
+M.bit.bor = bit_bor
+
+local function bit_band(a, b, c, ...)
+  if c then
+    return bit_band(bit_band(a, b), c, ...)
+  elseif b then
+    return bit_tobit(band(a % MOD, b % MOD))
+  else
+    return bit_tobit(a)
+  end
+end
+M.bit.band = bit_band
+
+local function bit_bxor(a, b, c, ...)
+  if c then
+    return bit_bxor(bit_bxor(a, b), c, ...)
+  elseif b then
+    return bit_tobit(bxor(a % MOD, b % MOD))
+  else
+    return bit_tobit(a)
+  end
+end
+M.bit.bxor = bit_bxor
+
+function M.bit.lshift(x, n)
+  return bit_tobit(lshift(x % MOD, n % 32))
+end
+
+function M.bit.rshift(x, n)
+  return bit_tobit(rshift(x % MOD, n % 32))
+end
+
+function M.bit.arshift(x, n)
+  return bit_tobit(arshift(x % MOD, n % 32))
+end
+
+function M.bit.rol(x, n)
+  return bit_tobit(lrotate(x % MOD, n % 32))
+end
+
+function M.bit.ror(x, n)
+  return bit_tobit(rrotate(x % MOD, n % 32))
+end
+
+function M.bit.bswap(x)
+  return bit_tobit(bswap(x % MOD))
+end
+
+return M

bin/numbers/random.lua

@@ -0,0 +1,232 @@
+--[[----------------------------------------
+Random
+Not all of this is mine
+------------------------------------------]]
+--[[------------------------------------
+RandomLua v0.3.1
+Pure Lua Pseudo-Random Numbers Generator
+Under the MIT license.
+copyright(c) 2011 linux-man
+--]]------------------------------------
+
+local math_floor = math.floor
+
+local function normalize(n)
+	return n % 0x80000000
+end
+
+local function bit_and(a, b)
+	local r = 0
+	local m = 0
+	for m = 0, 31 do
+		if (a % 2 == 1) and (b % 2 == 1) then r = r + 2^m end
+		if a % 2 ~= 0 then a = a - 1 end
+		if b % 2 ~= 0 then b = b - 1 end
+		a = a / 2 b = b / 2
+	end
+	return normalize(r)
+end
+
+local function bit_or(a, b)
+	local r = 0
+	local m = 0
+	for m = 0, 31 do
+		if (a % 2 == 1) or (b % 2 == 1) then r = r + 2^m end
+		if a % 2 ~= 0 then a = a - 1 end
+		if b % 2 ~= 0 then b = b - 1 end
+		a = a / 2 b = b / 2
+	end
+	return normalize(r)
+end
+
+local function bit_xor(a, b)
+	local r = 0
+	local m = 0
+	for m = 0, 31 do
+		if a % 2 ~= b % 2 then r = r + 2^m end
+		if a % 2 ~= 0 then a = a - 1 end
+		if b % 2 ~= 0 then b = b - 1 end
+		a = a / 2 b = b / 2
+	end
+	return normalize(r)
+end
+
+local function seed()
+	return normalize(os.time())
+end
+
+--Mersenne twister
+local mersenne_twister = {}
+mersenne_twister.__index = mersenne_twister
+
+function mersenne_twister:randomseed(s)
+	if not s then s = seed() end
+	self.mt[0] = normalize(s)
+	for i = 1, 623 do
+		self.mt[i] = normalize(0x6c078965 * bit_xor(self.mt[i-1], math_floor(self.mt[i-1] / 0x40000000)) + i)
+	end
+end
+
+function mersenne_twister:random(a, b)
+	local y
+	if self.index == 0 then
+		for i = 0, 623 do
+			y = self.mt[(i + 1) % 624] % 0x80000000
+			self.mt[i] = bit_xor(self.mt[(i + 397) % 624], math_floor(y / 2))
+			if y % 2 ~= 0 then self.mt[i] = bit_xor(self.mt[i], 0x9908b0df) end
+		end
+	end
+	y = self.mt[self.index]
+	y = bit_xor(y, math_floor(y / 0x800))
+	y = bit_xor(y, bit_and(normalize(y * 0x80), 0x9d2c5680))
+	y = bit_xor(y, bit_and(normalize(y * 0x8000), 0xefc60000))
+	y = bit_xor(y, math_floor(y / 0x40000))
+	self.index = (self.index + 1) % 624
+	if not a then return y / 0x80000000
+	elseif not b then
+		if a == 0 then return y
+		else return 1 + (y % a)
+		end
+	else
+		return a + (y % (b - a + 1))
+	end
+end
+
+local function twister(s)
+	local temp = {}
+	setmetatable(temp, mersenne_twister)
+	temp.mt = {}
+	temp.index = 0
+	temp:randomseed(s)
+	return temp
+end
+
+--Linear Congruential Generator
+local linear_congruential_generator = {}
+linear_congruential_generator.__index = linear_congruential_generator
+
+function linear_congruential_generator:random(a, b)
+	local y = (self.a * self.x + self.c) % self.m
+	self.x = y
+	if not a then return y / 0x10000
+	elseif not b then
+		if a == 0 then return y
+		else return 1 + (y % a) end
+	else
+		return a + (y % (b - a + 1))
+	end
+end
+
+function linear_congruential_generator:randomseed(s)
+	if not s then s = seed() end
+	self.x = normalize(s)
+end
+
+local function lcg(s, r)
+	local temp = {}
+	setmetatable(temp, linear_congruential_generator)
+	temp.a, temp.c, temp.m = 1103515245, 12345, 0x10000  --from Ansi C
+	if r then
+		if r == 'nr' then temp.a, temp.c, temp.m = 1664525, 1013904223, 0x10000 --from Numerical Recipes.
+		elseif r == 'mvc' then temp.a, temp.c, temp.m = 214013, 2531011, 0x10000 end--from MVC
+	end
+	temp:randomseed(s)
+	return temp
+end
+
+-- Multiply-with-carry
+local multiply_with_carry = {}
+multiply_with_carry.__index = multiply_with_carry
+
+function multiply_with_carry:random(a, b)
+	local m = self.m
+	local t = self.a * self.x + self.c
+	local y = t % m
+	self.x = y
+	self.c = math_floor(t / m)
+	if not a then return y / 0x10000
+	elseif not b then
+		if a == 0 then return y
+		else return 1 + (y % a) end
+	else
+		return a + (y % (b - a + 1))
+	end
+end
+
+function multiply_with_carry:randomseed(s)
+	if not s then s = seed() end
+	self.c = self.ic
+	self.x = normalize(s)
+end
+
+local function mwc(s, r)
+	local temp = {}
+	setmetatable(temp, multiply_with_carry)
+	temp.a, temp.c, temp.m = 1103515245, 12345, 0x10000  --from Ansi C
+	if r then
+		if r == 'nr' then temp.a, temp.c, temp.m = 1664525, 1013904223, 0x10000 --from Numerical Recipes.
+		elseif r == 'mvc' then temp.a, temp.c, temp.m = 214013, 2531011, 0x10000 end--from MVC
+	end
+	temp.ic = temp.c
+	temp:randomseed(s)
+	return temp
+end
+-- Little bind for the methods: My code starts
+local randomGen={}
+randomGen.__index=randomGen
+function randomGen:new(s)
+	local temp={}
+	setmetatable(temp,randomGen)
+	temp[1]=twister()
+	temp[2]=lcg()
+	temp[3]=mwc()
+	temp.pos=1
+	for i=1,3 do
+		temp[i]:randomseed(s)
+	end
+	return temp
+end
+function randomGen:randomseed(s)
+	self.pos=1
+	self[1]:randomseed(s)
+	self[2]:randomseed(s)
+	self[3]:randomseed(s)
+end
+function randomGen:randomInt(a,b)
+	local t=self[self.pos]:random(a,b)
+	self.pos=self.pos+1
+	if self.pos>3 then
+		self.pos=1
+	end
+	return t
+end
+function randomGen:newND(a,b,s)
+	if not(a) or not(b) then error('You must include a range!') end
+	local temp=randomGen:new(s)
+	temp.a=a
+	temp.b=b
+	temp.range=b-a+1
+	temp.dups={no=0}
+	function temp:nextInt()
+		local t=self:randomInt(self.a,self.b)
+		if self.dups[t]==nil then
+			self.dups[t]=true
+			self.dups.no=self.dups.no+1
+		else
+			return self:nextInt()
+		end
+		if self.dups.no==self.range then
+			function self:nextInt()
+				return 1,true
+			end
+			return t
+		else
+			return t
+		end
+	end
+	function temp:nextIInt()
+		return function() return self:nextInt() end
+	end
+	return temp
+end
+return randomGen

bin/support/vfs.lua

@@ -0,0 +1 @@
+local bin = require("bin")

readme.md

@@ -0,0 +1,9 @@
+This is a simple tool for turning game.love into .apk
+
+Note: This is for testing to see if your app works on andriod! The apk is signed using a debug key! You can sign it your self (The non alinged apk) using: apk-signer-1.8.5.jar This will give it a unique key and will not be in debug mode.
+
+Requirements: java jdk
+
+Useage: run the Compile.exe file and it will run through the steps.
+
+If game.png is present it will compile that for you as well

src/Compile.lua

@@ -0,0 +1,127 @@
+package.path = "./?/init.lua;./?.lua;"
+package.cpath = "./?.dll;"
+local gd = require("gd")
+local bin = require("bin")
+function getInput(msg,list)
+	io.write(msg or "")
+	local dat = io.read()
+	if list then
+		for i=1,#list do
+			if list[i]==dat then
+				return dat
+			end
+		end
+		print("Invalid input: "..dat)
+		return getInput(msg,list)
+	else
+		return dat
+	end
+end
+io.mkDir("dat")
+print("AutoLoveMaker V1.0.0\nEnsure that all your files are in the same directory as the program! game.love, and loveandroid.apk must be present with these filenames for the program to work!")
+name = getInput("Game Name: ")
+_o={l = "sensorLandscape",p = "portrait"}
+if bin.fileExist("dat/"..name..".dat") then
+	b = getInput("You have compiled a game by this name before! Do you want to use the last build settings? (y/n): ",{"y","n"})
+	if b then
+		local file = bin.load("dat/"..name..".dat")
+		local dat = file:getBlock("t")
+		o=dat.o
+		packageName=dat.packageName
+		ver=dat.ver
+		verN=dat.verN
+	else
+		print("We are going to manage Settings that affect your apk...")
+		o = getInput("Svreep Orientation(p - portrait | l - landscape): ",{"o","p"})
+		packageName = "game."..name..".org"
+		ver = getInput("Version Code(number): ")
+		verN = getInput("Version Name(number.number): ")
+		os.execute([[apktool d -s -o love_decoded loveandroid.apk]])
+		io.mkDir("love_decoded/assets")
+		bin.load("game.love"):tofile("love_decoded/assets/game.love")
+		local file = bin.new()
+		file:addBlock({
+			o = o,
+			packageName = packageName,
+			ver = ver,
+			verN = verN,
+		})
+		file:tofile("dat/"..name..".dat")
+	end
+else
+	print("We are going to manage Settings that affect your apk...")
+	o = getInput("Svreep Orientation(p - portrait | l - landscape): ",{"o","p"})
+	packageName = "game."..name..".org"
+	ver = getInput("Version Code(number): ")
+	verN = getInput("Version Name(number.number): ")
+	os.execute([[apktool d -s -o love_decoded loveandroid.apk]])
+	io.mkDir("love_decoded/assets")
+	bin.load("game.love"):tofile("love_decoded/assets/game.love")
+	local file = bin.new()
+	file:addBlock({
+		o = o,
+		packageName = packageName,
+		ver = ver,
+		verN = verN,
+	})
+	file:tofile("dat/"..name..".dat")
+end
+if bin.fileExist("game.png") then
+	print("building icon")
+	local icon = gd.createFromPng("game.png")
+	local i48 = gd.createFromPng("love_decoded/res/drawable-mdpi/love.png")
+	local i96 = gd.createFromPng("love_decoded/res/drawable-xhdpi/love.png")
+	local i144 = gd.createFromPng("love_decoded/res/drawable-xxhdpi/love.png")
+	local i192 = gd.createFromPng("love_decoded/res/drawable-xxxhdpi/love.png")
+	i48:copyResized(icon, 0, 0, 0, 0, 48, 48, 192, 192)
+	i96:copyResized(icon, 0, 0, 0, 0, 96, 96, 192, 192)
+	i144:copyResized(icon, 0, 0, 0, 0, 144, 144, 192, 192)
+	i192:copyResized(icon, 0, 0, 0, 0, 192, 192, 192, 192)
+	i48:pngEx("love_decoded/res/drawable-mdpi/love.png",0)
+	i96:pngEx("love_decoded/res/drawable-xhdpi/love.png",0)
+	i144:pngEx("love_decoded/res/drawable-xxhdpi/love.png",0)
+	i192:pngEx("love_decoded/res/drawable-xxxhdpi/love.png",0)
+end
+bin.new([[<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<manifest package="]]..packageName..[["
+      android:versionCode="]]..ver..[["
+      android:versionName="]]..verN..[["
+      android:installLocation="auto" xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.INTERNET"/>
+    <uses-permission android:name="android.permission.VIBRATE"/>
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+    <uses-feature android:glEsVersion="0x00020000"/>
+    <application
+        android:allowBackup="true"
+        android:icon="@drawable/love"
+        android:label="]]..name..[["
+        android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
+    >
+        <activity
+            android:configChanges="orientation|screenSize"
+            android:label="]]..name..[["
+            android:launchMode="singleTop"
+            android:name="org.love2d.android.GameActivity"
+            android:screenOrientation="]].._o[o]..[["
+        >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+                <category android:name="android.intent.category.LAUNCHER"/>
+                <category android:name="tv.ouya.intent.category.GAME"/>
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>]]):tofile("love_decoded/AndroidManifest.xml")
+temp = bin.load("love_decoded/apktool.yml")
+temp.data:gsub("minSdkVersion: '(%d%d)'","minSdkVersion: '16'")
+temp.data:gsub("targetSdkVersion: '(%d%d)'","targetSdkVersion: '16'")
+temp:tofile("love_decoded/apktool.yml")
+print("Building apk...")
+os.execute([[apktool b -o ]]..name..[[.apk love_decoded]])
+print("Signing apk...")
+os.execute([[java -jar uber-apk-signer.jar -a ]]..name..[[.apk]])
+--minSdkVersion: '16'
+--targetSdkVersion: '16'
+
+--portrait,sensorLandscape