threear
Version:
A marker based Augmented Reality library for Three.js
4,230 lines (4,228 loc) • 1.56 MB
JavaScript
var Module;
if (!Module) Module = (typeof Module !== "undefined" ? Module : null) || {};
var moduleOverrides = {};
for (var key in Module) {
if (Module.hasOwnProperty(key)) {
moduleOverrides[key] = Module[key];
}
}
var ENVIRONMENT_IS_WEB = typeof window === "object";
var ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
Module["read"] = function read(url) {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.send(null);
return xhr.responseText;
};
if (typeof arguments != "undefined") {
Module["arguments"] = arguments;
}
if (typeof console !== "undefined") {
if (!Module["print"])
Module["print"] = function print(x) {
console.log(x);
};
if (!Module["printErr"])
Module["printErr"] = function printErr(x) {
console.log(x);
};
} else {
var TRY_USE_DUMP = false;
if (!Module["print"])
Module["print"] =
TRY_USE_DUMP && typeof dump !== "undefined"
? function(x) {
dump(x);
}
: function(x) {};
}
if (ENVIRONMENT_IS_WORKER) {
Module["load"] = importScripts;
}
if (typeof Module["setWindowTitle"] === "undefined") {
Module["setWindowTitle"] = function(title) {
document.title = title;
};
}
} else {
throw "Unknown runtime environment. Where are we?";
}
function globalEval(x) {
eval.call(null, x);
}
if (!Module["load"] && Module["read"]) {
Module["load"] = function load(f) {
globalEval(Module["read"](f));
};
}
if (!Module["print"]) {
Module["print"] = function() {};
}
if (!Module["printErr"]) {
Module["printErr"] = Module["print"];
}
if (!Module["arguments"]) {
Module["arguments"] = [];
}
if (!Module["thisProgram"]) {
Module["thisProgram"] = "./this.program";
}
Module.print = Module["print"];
Module.printErr = Module["printErr"];
Module["preRun"] = [];
Module["postRun"] = [];
for (var key in moduleOverrides) {
if (moduleOverrides.hasOwnProperty(key)) {
Module[key] = moduleOverrides[key];
}
}
var Runtime = {
setTempRet0: function(value) {
tempRet0 = value;
},
getTempRet0: function() {
return tempRet0;
},
stackSave: function() {
return STACKTOP;
},
stackRestore: function(stackTop) {
STACKTOP = stackTop;
},
getNativeTypeSize: function(type) {
switch (type) {
case "i1":
case "i8":
return 1;
case "i16":
return 2;
case "i32":
return 4;
case "i64":
return 8;
case "float":
return 4;
case "double":
return 8;
default: {
if (type[type.length - 1] === "*") {
return Runtime.QUANTUM_SIZE;
} else if (type[0] === "i") {
var bits = parseInt(type.substr(1));
assert(bits % 8 === 0);
return bits / 8;
} else {
return 0;
}
}
}
},
getNativeFieldSize: function(type) {
return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
},
STACK_ALIGN: 16,
prepVararg: function(ptr, type) {
if (type === "double" || type === "i64") {
if (ptr & 7) {
assert((ptr & 7) === 4);
ptr += 4;
}
} else {
assert((ptr & 3) === 0);
}
return ptr;
},
getAlignSize: function(type, size, vararg) {
if (!vararg && (type == "i64" || type == "double")) return 8;
if (!type) return Math.min(size, 8);
return Math.min(
size || (type ? Runtime.getNativeFieldSize(type) : 0),
Runtime.QUANTUM_SIZE
);
},
dynCall: function(sig, ptr, args) {
if (args && args.length) {
if (!args.splice) args = Array.prototype.slice.call(args);
args.splice(0, 0, ptr);
return Module["dynCall_" + sig].apply(null, args);
} else {
return Module["dynCall_" + sig].call(null, ptr);
}
},
functionPointers: [],
addFunction: function(func) {
for (var i = 0; i < Runtime.functionPointers.length; i++) {
if (!Runtime.functionPointers[i]) {
Runtime.functionPointers[i] = func;
return 2 * (1 + i);
}
}
throw "Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.";
},
removeFunction: function(index) {
Runtime.functionPointers[(index - 2) / 2] = null;
},
warnOnce: function(text) {
if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
if (!Runtime.warnOnce.shown[text]) {
Runtime.warnOnce.shown[text] = 1;
Module.printErr(text);
}
},
funcWrappers: {},
getFuncWrapper: function(func, sig) {
assert(sig);
if (!Runtime.funcWrappers[sig]) {
Runtime.funcWrappers[sig] = {};
}
var sigCache = Runtime.funcWrappers[sig];
if (!sigCache[func]) {
sigCache[func] = function dynCall_wrapper() {
return Runtime.dynCall(sig, func, arguments);
};
}
return sigCache[func];
},
getCompilerSetting: function(name) {
throw "You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work";
},
stackAlloc: function(size) {
var ret = STACKTOP;
STACKTOP = (STACKTOP + size) | 0;
STACKTOP = (STACKTOP + 15) & -16;
return ret;
},
staticAlloc: function(size) {
var ret = STATICTOP;
STATICTOP = (STATICTOP + size) | 0;
STATICTOP = (STATICTOP + 15) & -16;
return ret;
},
dynamicAlloc: function(size) {
var ret = DYNAMICTOP;
DYNAMICTOP = (DYNAMICTOP + size) | 0;
DYNAMICTOP = (DYNAMICTOP + 15) & -16;
if (DYNAMICTOP >= TOTAL_MEMORY) {
var success = enlargeMemory();
if (!success) {
DYNAMICTOP = ret;
return 0;
}
}
return ret;
},
alignMemory: function(size, quantum) {
var ret = (size =
Math.ceil(size / (quantum ? quantum : 16)) * (quantum ? quantum : 16));
return ret;
},
makeBigInt: function(low, high, unsigned) {
var ret = unsigned
? +(low >>> 0) + +(high >>> 0) * +4294967296
: +(low >>> 0) + +(high | 0) * +4294967296;
return ret;
},
GLOBAL_BASE: 8,
QUANTUM_SIZE: 4,
__dummy__: 0
};
Module["Runtime"] = Runtime;
var __THREW__ = 0;
var ABORT = false;
var EXITSTATUS = 0;
var undef = 0;
var tempValue,
tempInt,
tempBigInt,
tempInt2,
tempBigInt2,
tempPair,
tempBigIntI,
tempBigIntR,
tempBigIntS,
tempBigIntP,
tempBigIntD,
tempDouble,
tempFloat;
var tempI64, tempI64b;
var tempRet0,
tempRet1,
tempRet2,
tempRet3,
tempRet4,
tempRet5,
tempRet6,
tempRet7,
tempRet8,
tempRet9;
function assert(condition, text) {
if (!condition) {
abort("Assertion failed: " + text);
}
}
var globalScope = this;
function getCFunc(ident) {
var func = Module["_" + ident];
if (!func) {
try {
func = eval("_" + ident);
} catch (e) {}
}
assert(
func,
"Cannot call unknown function " +
ident +
" (perhaps LLVM optimizations or closure removed it?)"
);
return func;
}
var cwrap, ccall;
(function() {
var JSfuncs = {
stackSave: function() {
Runtime.stackSave();
},
stackRestore: function() {
Runtime.stackRestore();
},
arrayToC: function(arr) {
var ret = Runtime.stackAlloc(arr.length);
writeArrayToMemory(arr, ret);
return ret;
},
stringToC: function(str) {
var ret = 0;
if (str !== null && str !== undefined && str !== 0) {
ret = Runtime.stackAlloc((str.length << 2) + 1);
writeStringToMemory(str, ret);
}
return ret;
}
};
var toC = { string: JSfuncs["stringToC"], array: JSfuncs["arrayToC"] };
ccall = function ccallFunc(ident, returnType, argTypes, args, opts) {
var func = getCFunc(ident);
var cArgs = [];
var stack = 0;
if (args) {
for (var i = 0; i < args.length; i++) {
var converter = toC[argTypes[i]];
if (converter) {
if (stack === 0) stack = Runtime.stackSave();
cArgs[i] = converter(args[i]);
} else {
cArgs[i] = args[i];
}
}
}
var ret = func.apply(null, cArgs);
if (returnType === "string") ret = Pointer_stringify(ret);
if (stack !== 0) {
if (opts && opts.async) {
EmterpreterAsync.asyncFinalizers.push(function() {
Runtime.stackRestore(stack);
});
return;
}
Runtime.stackRestore(stack);
}
return ret;
};
var sourceRegex = /^function\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/;
function parseJSFunc(jsfunc) {
var parsed = jsfunc
.toString()
.match(sourceRegex)
.slice(1);
return { arguments: parsed[0], body: parsed[1], returnValue: parsed[2] };
}
var JSsource = {};
for (var fun in JSfuncs) {
if (JSfuncs.hasOwnProperty(fun)) {
JSsource[fun] = parseJSFunc(JSfuncs[fun]);
}
}
cwrap = function cwrap(ident, returnType, argTypes) {
argTypes = argTypes || [];
var cfunc = getCFunc(ident);
var numericArgs = argTypes.every(function(type) {
return type === "number";
});
var numericRet = returnType !== "string";
if (numericRet && numericArgs) {
return cfunc;
}
var argNames = argTypes.map(function(x, i) {
return "$" + i;
});
var funcstr = "(function(" + argNames.join(",") + ") {";
var nargs = argTypes.length;
if (!numericArgs) {
funcstr += "var stack = " + JSsource["stackSave"].body + ";";
for (var i = 0; i < nargs; i++) {
var arg = argNames[i],
type = argTypes[i];
if (type === "number") continue;
var convertCode = JSsource[type + "ToC"];
funcstr += "var " + convertCode.arguments + " = " + arg + ";";
funcstr += convertCode.body + ";";
funcstr += arg + "=" + convertCode.returnValue + ";";
}
}
var cfuncname = parseJSFunc(function() {
return cfunc;
}).returnValue;
funcstr += "var ret = " + cfuncname + "(" + argNames.join(",") + ");";
if (!numericRet) {
var strgfy = parseJSFunc(function() {
return Pointer_stringify;
}).returnValue;
funcstr += "ret = " + strgfy + "(ret);";
}
if (!numericArgs) {
funcstr += JSsource["stackRestore"].body.replace("()", "(stack)") + ";";
}
funcstr += "return ret})";
return eval(funcstr);
};
})();
Module["ccall"] = ccall;
Module["cwrap"] = cwrap;
function setValue(ptr, value, type, noSafe) {
type = type || "i8";
if (type.charAt(type.length - 1) === "*") type = "i32";
switch (type) {
case "i1":
HEAP8[ptr >> 0] = value;
break;
case "i8":
HEAP8[ptr >> 0] = value;
break;
case "i16":
HEAP16[ptr >> 1] = value;
break;
case "i32":
HEAP32[ptr >> 2] = value;
break;
case "i64":
(tempI64 = [
value >>> 0,
((tempDouble = value),
+Math_abs(tempDouble) >= +1
? tempDouble > +0
? (Math_min(+Math_floor(tempDouble / +4294967296), +4294967295) |
0) >>>
0
: ~~+Math_ceil(
(tempDouble - +(~~tempDouble >>> 0)) / +4294967296
) >>> 0
: 0)
]),
(HEAP32[ptr >> 2] = tempI64[0]),
(HEAP32[(ptr + 4) >> 2] = tempI64[1]);
break;
case "float":
HEAPF32[ptr >> 2] = value;
break;
case "double":
HEAPF64[ptr >> 3] = value;
break;
default:
abort("invalid type for setValue: " + type);
}
}
Module["setValue"] = setValue;
function getValue(ptr, type, noSafe) {
type = type || "i8";
if (type.charAt(type.length - 1) === "*") type = "i32";
switch (type) {
case "i1":
return HEAP8[ptr >> 0];
case "i8":
return HEAP8[ptr >> 0];
case "i16":
return HEAP16[ptr >> 1];
case "i32":
return HEAP32[ptr >> 2];
case "i64":
return HEAP32[ptr >> 2];
case "float":
return HEAPF32[ptr >> 2];
case "double":
return HEAPF64[ptr >> 3];
default:
abort("invalid type for setValue: " + type);
}
return null;
}
Module["getValue"] = getValue;
var ALLOC_NORMAL = 0;
var ALLOC_STACK = 1;
var ALLOC_STATIC = 2;
var ALLOC_DYNAMIC = 3;
var ALLOC_NONE = 4;
Module["ALLOC_NORMAL"] = ALLOC_NORMAL;
Module["ALLOC_STACK"] = ALLOC_STACK;
Module["ALLOC_STATIC"] = ALLOC_STATIC;
Module["ALLOC_DYNAMIC"] = ALLOC_DYNAMIC;
Module["ALLOC_NONE"] = ALLOC_NONE;
function allocate(slab, types, allocator, ptr) {
var zeroinit, size;
if (typeof slab === "number") {
zeroinit = true;
size = slab;
} else {
zeroinit = false;
size = slab.length;
}
var singleType = typeof types === "string" ? types : null;
var ret;
if (allocator == ALLOC_NONE) {
ret = ptr;
} else {
ret = [
_malloc,
Runtime.stackAlloc,
Runtime.staticAlloc,
Runtime.dynamicAlloc
][allocator === undefined ? ALLOC_STATIC : allocator](
Math.max(size, singleType ? 1 : types.length)
);
}
if (zeroinit) {
var ptr = ret,
stop;
assert((ret & 3) == 0);
stop = ret + (size & ~3);
for (; ptr < stop; ptr += 4) {
HEAP32[ptr >> 2] = 0;
}
stop = ret + size;
while (ptr < stop) {
HEAP8[ptr++ >> 0] = 0;
}
return ret;
}
if (singleType === "i8") {
if (slab.subarray || slab.slice) {
HEAPU8.set(slab, ret);
} else {
HEAPU8.set(new Uint8Array(slab), ret);
}
return ret;
}
var i = 0,
type,
typeSize,
previousType;
while (i < size) {
var curr = slab[i];
if (typeof curr === "function") {
curr = Runtime.getFunctionIndex(curr);
}
type = singleType || types[i];
if (type === 0) {
i++;
continue;
}
if (type == "i64") type = "i32";
setValue(ret + i, curr, type);
if (previousType !== type) {
typeSize = Runtime.getNativeTypeSize(type);
previousType = type;
}
i += typeSize;
}
return ret;
}
Module["allocate"] = allocate;
function getMemory(size) {
if (!staticSealed) return Runtime.staticAlloc(size);
if ((typeof _sbrk !== "undefined" && !_sbrk.called) || !runtimeInitialized)
return Runtime.dynamicAlloc(size);
return _malloc(size);
}
Module["getMemory"] = getMemory;
function Pointer_stringify(ptr, length) {
if (length === 0 || !ptr) return "";
var hasUtf = 0;
var t;
var i = 0;
while (1) {
t = HEAPU8[(ptr + i) >> 0];
hasUtf |= t;
if (t == 0 && !length) break;
i++;
if (length && i == length) break;
}
if (!length) length = i;
var ret = "";
if (hasUtf < 128) {
var MAX_CHUNK = 1024;
var curr;
while (length > 0) {
curr = String.fromCharCode.apply(
String,
HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK))
);
ret = ret ? ret + curr : curr;
ptr += MAX_CHUNK;
length -= MAX_CHUNK;
}
return ret;
}
return Module["UTF8ToString"](ptr);
}
Module["Pointer_stringify"] = Pointer_stringify;
function AsciiToString(ptr) {
var str = "";
while (1) {
var ch = HEAP8[ptr++ >> 0];
if (!ch) return str;
str += String.fromCharCode(ch);
}
}
Module["AsciiToString"] = AsciiToString;
function stringToAscii(str, outPtr) {
return writeAsciiToMemory(str, outPtr, false);
}
Module["stringToAscii"] = stringToAscii;
function UTF8ArrayToString(u8Array, idx) {
var u0, u1, u2, u3, u4, u5;
var str = "";
while (1) {
u0 = u8Array[idx++];
if (!u0) return str;
if (!(u0 & 128)) {
str += String.fromCharCode(u0);
continue;
}
u1 = u8Array[idx++] & 63;
if ((u0 & 224) == 192) {
str += String.fromCharCode(((u0 & 31) << 6) | u1);
continue;
}
u2 = u8Array[idx++] & 63;
if ((u0 & 240) == 224) {
u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
} else {
u3 = u8Array[idx++] & 63;
if ((u0 & 248) == 240) {
u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | u3;
} else {
u4 = u8Array[idx++] & 63;
if ((u0 & 252) == 248) {
u0 = ((u0 & 3) << 24) | (u1 << 18) | (u2 << 12) | (u3 << 6) | u4;
} else {
u5 = u8Array[idx++] & 63;
u0 =
((u0 & 1) << 30) |
(u1 << 24) |
(u2 << 18) |
(u3 << 12) |
(u4 << 6) |
u5;
}
}
}
if (u0 < 65536) {
str += String.fromCharCode(u0);
} else {
var ch = u0 - 65536;
str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
}
}
}
Module["UTF8ArrayToString"] = UTF8ArrayToString;
function UTF8ToString(ptr) {
return UTF8ArrayToString(HEAPU8, ptr);
}
Module["UTF8ToString"] = UTF8ToString;
function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
if (!(maxBytesToWrite > 0)) return 0;
var startIdx = outIdx;
var endIdx = outIdx + maxBytesToWrite - 1;
for (var i = 0; i < str.length; ++i) {
var u = str.charCodeAt(i);
if (u >= 55296 && u <= 57343)
u = (65536 + ((u & 1023) << 10)) | (str.charCodeAt(++i) & 1023);
if (u <= 127) {
if (outIdx >= endIdx) break;
outU8Array[outIdx++] = u;
} else if (u <= 2047) {
if (outIdx + 1 >= endIdx) break;
outU8Array[outIdx++] = 192 | (u >> 6);
outU8Array[outIdx++] = 128 | (u & 63);
} else if (u <= 65535) {
if (outIdx + 2 >= endIdx) break;
outU8Array[outIdx++] = 224 | (u >> 12);
outU8Array[outIdx++] = 128 | ((u >> 6) & 63);
outU8Array[outIdx++] = 128 | (u & 63);
} else if (u <= 2097151) {
if (outIdx + 3 >= endIdx) break;
outU8Array[outIdx++] = 240 | (u >> 18);
outU8Array[outIdx++] = 128 | ((u >> 12) & 63);
outU8Array[outIdx++] = 128 | ((u >> 6) & 63);
outU8Array[outIdx++] = 128 | (u & 63);
} else if (u <= 67108863) {
if (outIdx + 4 >= endIdx) break;
outU8Array[outIdx++] = 248 | (u >> 24);
outU8Array[outIdx++] = 128 | ((u >> 18) & 63);
outU8Array[outIdx++] = 128 | ((u >> 12) & 63);
outU8Array[outIdx++] = 128 | ((u >> 6) & 63);
outU8Array[outIdx++] = 128 | (u & 63);
} else {
if (outIdx + 5 >= endIdx) break;
outU8Array[outIdx++] = 252 | (u >> 30);
outU8Array[outIdx++] = 128 | ((u >> 24) & 63);
outU8Array[outIdx++] = 128 | ((u >> 18) & 63);
outU8Array[outIdx++] = 128 | ((u >> 12) & 63);
outU8Array[outIdx++] = 128 | ((u >> 6) & 63);
outU8Array[outIdx++] = 128 | (u & 63);
}
}
outU8Array[outIdx] = 0;
return outIdx - startIdx;
}
Module["stringToUTF8Array"] = stringToUTF8Array;
function stringToUTF8(str, outPtr, maxBytesToWrite) {
return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
}
Module["stringToUTF8"] = stringToUTF8;
function lengthBytesUTF8(str) {
var len = 0;
for (var i = 0; i < str.length; ++i) {
var u = str.charCodeAt(i);
if (u >= 55296 && u <= 57343)
u = (65536 + ((u & 1023) << 10)) | (str.charCodeAt(++i) & 1023);
if (u <= 127) {
++len;
} else if (u <= 2047) {
len += 2;
} else if (u <= 65535) {
len += 3;
} else if (u <= 2097151) {
len += 4;
} else if (u <= 67108863) {
len += 5;
} else {
len += 6;
}
}
return len;
}
Module["lengthBytesUTF8"] = lengthBytesUTF8;
function UTF16ToString(ptr) {
var i = 0;
var str = "";
while (1) {
var codeUnit = HEAP16[(ptr + i * 2) >> 1];
if (codeUnit == 0) return str;
++i;
str += String.fromCharCode(codeUnit);
}
}
Module["UTF16ToString"] = UTF16ToString;
function stringToUTF16(str, outPtr, maxBytesToWrite) {
if (maxBytesToWrite === undefined) {
maxBytesToWrite = 2147483647;
}
if (maxBytesToWrite < 2) return 0;
maxBytesToWrite -= 2;
var startPtr = outPtr;
var numCharsToWrite =
maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
for (var i = 0; i < numCharsToWrite; ++i) {
var codeUnit = str.charCodeAt(i);
HEAP16[outPtr >> 1] = codeUnit;
outPtr += 2;
}
HEAP16[outPtr >> 1] = 0;
return outPtr - startPtr;
}
Module["stringToUTF16"] = stringToUTF16;
function lengthBytesUTF16(str) {
return str.length * 2;
}
Module["lengthBytesUTF16"] = lengthBytesUTF16;
function UTF32ToString(ptr) {
var i = 0;
var str = "";
while (1) {
var utf32 = HEAP32[(ptr + i * 4) >> 2];
if (utf32 == 0) return str;
++i;
if (utf32 >= 65536) {
var ch = utf32 - 65536;
str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
} else {
str += String.fromCharCode(utf32);
}
}
}
Module["UTF32ToString"] = UTF32ToString;
function stringToUTF32(str, outPtr, maxBytesToWrite) {
if (maxBytesToWrite === undefined) {
maxBytesToWrite = 2147483647;
}
if (maxBytesToWrite < 4) return 0;
var startPtr = outPtr;
var endPtr = startPtr + maxBytesToWrite - 4;
for (var i = 0; i < str.length; ++i) {
var codeUnit = str.charCodeAt(i);
if (codeUnit >= 55296 && codeUnit <= 57343) {
var trailSurrogate = str.charCodeAt(++i);
codeUnit = (65536 + ((codeUnit & 1023) << 10)) | (trailSurrogate & 1023);
}
HEAP32[outPtr >> 2] = codeUnit;
outPtr += 4;
if (outPtr + 4 > endPtr) break;
}
HEAP32[outPtr >> 2] = 0;
return outPtr - startPtr;
}
Module["stringToUTF32"] = stringToUTF32;
function lengthBytesUTF32(str) {
var len = 0;
for (var i = 0; i < str.length; ++i) {
var codeUnit = str.charCodeAt(i);
if (codeUnit >= 55296 && codeUnit <= 57343) ++i;
len += 4;
}
return len;
}
Module["lengthBytesUTF32"] = lengthBytesUTF32;
function demangle(func) {
var hasLibcxxabi = !!Module["___cxa_demangle"];
if (hasLibcxxabi) {
try {
var buf = _malloc(func.length);
writeStringToMemory(func.substr(1), buf);
var status = _malloc(4);
var ret = Module["___cxa_demangle"](buf, 0, 0, status);
if (getValue(status, "i32") === 0 && ret) {
return Pointer_stringify(ret);
}
} catch (e) {
} finally {
if (buf) _free(buf);
if (status) _free(status);
if (ret) _free(ret);
}
}
var i = 3;
var basicTypes = {
v: "void",
b: "bool",
c: "char",
s: "short",
i: "int",
l: "long",
f: "float",
d: "double",
w: "wchar_t",
a: "signed char",
h: "unsigned char",
t: "unsigned short",
j: "unsigned int",
m: "unsigned long",
x: "long long",
y: "unsigned long long",
z: "..."
};
var subs = [];
var first = true;
function dump(x) {
if (x) Module.print(x);
Module.print(func);
var pre = "";
for (var a = 0; a < i; a++) pre += " ";
Module.print(pre + "^");
}
function parseNested() {
i++;
if (func[i] === "K") i++;
var parts = [];
while (func[i] !== "E") {
if (func[i] === "S") {
i++;
var next = func.indexOf("_", i);
var num = func.substring(i, next) || 0;
parts.push(subs[num] || "?");
i = next + 1;
continue;
}
if (func[i] === "C") {
parts.push(parts[parts.length - 1]);
i += 2;
continue;
}
var size = parseInt(func.substr(i));
var pre = size.toString().length;
if (!size || !pre) {
i--;
break;
}
var curr = func.substr(i + pre, size);
parts.push(curr);
subs.push(curr);
i += pre + size;
}
i++;
return parts;
}
function parse(rawList, limit, allowVoid) {
limit = limit || Infinity;
var ret = "",
list = [];
function flushList() {
return "(" + list.join(", ") + ")";
}
var name;
if (func[i] === "N") {
name = parseNested().join("::");
limit--;
if (limit === 0) return rawList ? [name] : name;
} else {
if (func[i] === "K" || (first && func[i] === "L")) i++;
var size = parseInt(func.substr(i));
if (size) {
var pre = size.toString().length;
name = func.substr(i + pre, size);
i += pre + size;
}
}
first = false;
if (func[i] === "I") {
i++;
var iList = parse(true);
var iRet = parse(true, 1, true);
ret += iRet[0] + " " + name + "<" + iList.join(", ") + ">";
} else {
ret = name;
}
paramLoop: while (i < func.length && limit-- > 0) {
var c = func[i++];
if (c in basicTypes) {
list.push(basicTypes[c]);
} else {
switch (c) {
case "P":
list.push(parse(true, 1, true)[0] + "*");
break;
case "R":
list.push(parse(true, 1, true)[0] + "&");
break;
case "L": {
i++;
var end = func.indexOf("E", i);
var size = end - i;
list.push(func.substr(i, size));
i += size + 2;
break;
}
case "A": {
var size = parseInt(func.substr(i));
i += size.toString().length;
if (func[i] !== "_") throw "?";
i++;
list.push(parse(true, 1, true)[0] + " [" + size + "]");
break;
}
case "E":
break paramLoop;
default:
ret += "?" + c;
break paramLoop;
}
}
}
if (!allowVoid && list.length === 1 && list[0] === "void") list = [];
if (rawList) {
if (ret) {
list.push(ret + "?");
}
return list;
} else {
return ret + flushList();
}
}
var parsed = func;
try {
if (func == "Object._main" || func == "_main") {
return "main()";
}
if (typeof func === "number") func = Pointer_stringify(func);
if (func[0] !== "_") return func;
if (func[1] !== "_") return func;
if (func[2] !== "Z") return func;
switch (func[3]) {
case "n":
return "operator new()";
case "d":
return "operator delete()";
}
parsed = parse();
} catch (e) {
parsed += "?";
}
if (parsed.indexOf("?") >= 0 && !hasLibcxxabi) {
Runtime.warnOnce(
"warning: a problem occurred in builtin C++ name demangling; build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling"
);
}
return parsed;
}
function demangleAll(text) {
return text.replace(/__Z[\w\d_]+/g, function(x) {
var y = demangle(x);
return x === y ? x : x + " [" + y + "]";
});
}
function jsStackTrace() {
var err = new Error();
if (!err.stack) {
try {
throw new Error(0);
} catch (e) {
err = e;
}
if (!err.stack) {
return "(no stack trace available)";
}
}
return err.stack.toString();
}
function stackTrace() {
return demangleAll(jsStackTrace());
}
Module["stackTrace"] = stackTrace;
var PAGE_SIZE = 4096;
function alignMemoryPage(x) {
if (x % 4096 > 0) {
x += 4096 - (x % 4096);
}
return x;
}
var HEAP;
var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
var STATIC_BASE = 0,
STATICTOP = 0,
staticSealed = false;
var STACK_BASE = 0,
STACKTOP = 0,
STACK_MAX = 0;
var DYNAMIC_BASE = 0,
DYNAMICTOP = 0;
function abortOnCannotGrowMemory() {
abort(
"Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value " +
TOTAL_MEMORY +
", (2) compile with -s ALLOW_MEMORY_GROWTH=1 which adjusts the size at runtime but prevents some optimizations, (3) set Module.TOTAL_MEMORY to a higher value before the program runs, or if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 "
);
}
function enlargeMemory() {
abortOnCannotGrowMemory();
}
var TOTAL_STACK = Module["TOTAL_STACK"] || 5242880;
var TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 268435456;
var totalMemory = 64 * 1024;
while (totalMemory < TOTAL_MEMORY || totalMemory < 2 * TOTAL_STACK) {
if (totalMemory < 16 * 1024 * 1024) {
totalMemory *= 2;
} else {
totalMemory += 16 * 1024 * 1024;
}
}
if (totalMemory !== TOTAL_MEMORY) {
TOTAL_MEMORY = totalMemory;
}
assert(
typeof Int32Array !== "undefined" &&
typeof Float64Array !== "undefined" &&
!!new Int32Array(1)["subarray"] &&
!!new Int32Array(1)["set"],
"JS engine does not provide full typed array support"
);
var buffer;
buffer = new ArrayBuffer(TOTAL_MEMORY);
HEAP8 = new Int8Array(buffer);
HEAP16 = new Int16Array(buffer);
HEAP32 = new Int32Array(buffer);
HEAPU8 = new Uint8Array(buffer);
HEAPU16 = new Uint16Array(buffer);
HEAPU32 = new Uint32Array(buffer);
HEAPF32 = new Float32Array(buffer);
HEAPF64 = new Float64Array(buffer);
HEAP32[0] = 255;
assert(
HEAPU8[0] === 255 && HEAPU8[3] === 0,
"Typed arrays 2 must be run on a little-endian system"
);
Module["HEAP"] = HEAP;
Module["buffer"] = buffer;
Module["HEAP8"] = HEAP8;
Module["HEAP16"] = HEAP16;
Module["HEAP32"] = HEAP32;
Module["HEAPU8"] = HEAPU8;
Module["HEAPU16"] = HEAPU16;
Module["HEAPU32"] = HEAPU32;
Module["HEAPF32"] = HEAPF32;
Module["HEAPF64"] = HEAPF64;
function callRuntimeCallbacks(callbacks) {
while (callbacks.length > 0) {
var callback = callbacks.shift();
if (typeof callback == "function") {
callback();
continue;
}
var func = callback.func;
if (typeof func === "number") {
if (callback.arg === undefined) {
Runtime.dynCall("v", func);
} else {
Runtime.dynCall("vi", func, [callback.arg]);
}
} else {
func(callback.arg === undefined ? null : callback.arg);
}
}
}
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATMAIN__ = [];
var __ATEXIT__ = [];
var __ATPOSTRUN__ = [];
var runtimeInitialized = false;
var runtimeExited = false;
function preRun() {
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function")
Module["preRun"] = [Module["preRun"]];
while (Module["preRun"].length) {
addOnPreRun(Module["preRun"].shift());
}
}
callRuntimeCallbacks(__ATPRERUN__);
}
function ensureInitRuntime() {
if (runtimeInitialized) return;
runtimeInitialized = true;
callRuntimeCallbacks(__ATINIT__);
}
function preMain() {
callRuntimeCallbacks(__ATMAIN__);
}
function exitRuntime() {
callRuntimeCallbacks(__ATEXIT__);
runtimeExited = true;
}
function postRun() {
if (Module["postRun"]) {
if (typeof Module["postRun"] == "function")
Module["postRun"] = [Module["postRun"]];
while (Module["postRun"].length) {
addOnPostRun(Module["postRun"].shift());
}
}
callRuntimeCallbacks(__ATPOSTRUN__);
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb);
}
Module["addOnPreRun"] = addOnPreRun;
function addOnInit(cb) {
__ATINIT__.unshift(cb);
}
Module["addOnInit"] = addOnInit;
function addOnPreMain(cb) {
__ATMAIN__.unshift(cb);
}
Module["addOnPreMain"] = addOnPreMain;
function addOnExit(cb) {
__ATEXIT__.unshift(cb);
}
Module["addOnExit"] = addOnExit;
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb);
}
Module["addOnPostRun"] = addOnPostRun;
function intArrayFromString(stringy, dontAddNull, length) {
var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
var u8array = new Array(len);
var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
if (dontAddNull) u8array.length = numBytesWritten;
return u8array;
}
Module["intArrayFromString"] = intArrayFromString;
function intArrayToString(array) {
var ret = [];
for (var i = 0; i < array.length; i++) {
var chr = array[i];
if (chr > 255) {
chr &= 255;
}
ret.push(String.fromCharCode(chr));
}
return ret.join("");
}
Module["intArrayToString"] = intArrayToString;
function writeStringToMemory(string, buffer, dontAddNull) {
var array = intArrayFromString(string, dontAddNull);
var i = 0;
while (i < array.length) {
var chr = array[i];
HEAP8[(buffer + i) >> 0] = chr;
i = i + 1;
}
}
Module["writeStringToMemory"] = writeStringToMemory;
function writeArrayToMemory(array, buffer) {
for (var i = 0; i < array.length; i++) {
HEAP8[buffer++ >> 0] = array[i];
}
}
Module["writeArrayToMemory"] = writeArrayToMemory;
function writeAsciiToMemory(str, buffer, dontAddNull) {
for (var i = 0; i < str.length; ++i) {
HEAP8[buffer++ >> 0] = str.charCodeAt(i);
}
if (!dontAddNull) HEAP8[buffer >> 0] = 0;
}
Module["writeAsciiToMemory"] = writeAsciiToMemory;
function unSign(value, bits, ignore) {
if (value >= 0) {
return value;
}
return bits <= 32
? 2 * Math.abs(1 << (bits - 1)) + value
: Math.pow(2, bits) + value;
}
function reSign(value, bits, ignore) {
if (value <= 0) {
return value;
}
var half = bits <= 32 ? Math.abs(1 << (bits - 1)) : Math.pow(2, bits - 1);
if (value >= half && (bits <= 32 || value > half)) {
value = -2 * half + value;
}
return value;
}
if (!Math["imul"] || Math["imul"](4294967295, 5) !== -5)
Math["imul"] = function imul(a, b) {
var ah = a >>> 16;
var al = a & 65535;
var bh = b >>> 16;
var bl = b & 65535;
return (al * bl + ((ah * bl + al * bh) << 16)) | 0;
};
Math.imul = Math["imul"];
if (!Math["clz32"])
Math["clz32"] = function(x) {
x = x >>> 0;
for (var i = 0; i < 32; i++) {
if (x & (1 << (31 - i))) return i;
}
return 32;
};
Math.clz32 = Math["clz32"];
var Math_abs = Math.abs;
var Math_cos = Math.cos;
var Math_sin = Math.sin;
var Math_tan = Math.tan;
var Math_acos = Math.acos;
var Math_asin = Math.asin;
var Math_atan = Math.atan;
var Math_atan2 = Math.atan2;
var Math_exp = Math.exp;
var Math_log = Math.log;
var Math_sqrt = Math.sqrt;
var Math_ceil = Math.ceil;
var Math_floor = Math.floor;
var Math_pow = Math.pow;
var Math_imul = Math.imul;
var Math_fround = Math.fround;
var Math_min = Math.min;
var Math_clz32 = Math.clz32;
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null;
function getUniqueRunDependency(id) {
return id;
}
function addRunDependency(id) {
runDependencies++;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies);
}
}
Module["addRunDependency"] = addRunDependency;
function removeRunDependency(id) {
runDependencies--;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies);
}
if (runDependencies == 0) {
if (runDependencyWatcher !== null) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null;
}
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback();
}
}
}
Module["removeRunDependency"] = removeRunDependency;
Module["preloadedImages"] = {};
Module["preloadedAudios"] = {};
var memoryInitializer = null;
var ASM_CONSTS = [
function($0, $1, $2, $3) {
{
if (!artoolkit["multiEachMarkerInfo"]) {
artoolkit["multiEachMarkerInfo"] = {};
}
var multiEachMarker = artoolkit["multiEachMarkerInfo"];
multiEachMarker["visible"] = $0;
multiEachMarker["pattId"] = $1;
multiEachMarker["pattType"] = $2;
multiEachMarker["width"] = $3;
}
},
function(
$0,
$1,
$2,
$3,
$4,
$5,
$6,
$7,
$8,
$9,
$10,
$11,
$12,
$13,
$14,
$15,
$16,
$17,
$18,
$19,
$20,
$21,
$22,
$23,
$24,
$25,
$26,
$27,
$28,
$29,
$30,
$31,
$32
) {
{
var $a = arguments;
var i = 12;
if (!Module["markerInfo"]) {
Module["markerInfo"] = {
pos: [0, 0],
line: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]],
vertex: [[0, 0], [0, 0], [0, 0], [0, 0]]
};
}
var markerInfo = Module["markerInfo"];
markerInfo["area"] = $0;
markerInfo["id"] = $1;
markerInfo["idPatt"] = $2;
markerInfo["idMatrix"] = $3;
markerInfo["dir"] = $4;
markerInfo["dirPatt"] = $5;
markerInfo["dirMatrix"] = $6;
markerInfo["cf"] = $7;
markerInfo["cfPatt"] = $8;
markerInfo["cfMatrix"] = $9;
markerInfo["pos"][0] = $10;
markerInfo["pos"][1] = $11;
markerInfo["line"][0][0] = $a[i++];
markerInfo["line"][0][1] = $a[i++];
markerInfo["line"][0][2] = $a[i++];
markerInfo["line"][1][0] = $a[i++];
markerInfo["line"][1][1] = $a[i++];
markerInfo["line"][1][2] = $a[i++];
markerInfo["line"][2][0] = $a[i++];
markerInfo["line"][2][1] = $a[i++];
markerInfo["line"][2][2] = $a[i++];
markerInfo["line"][3][0] = $a[i++];
markerInfo["line"][3][1] = $a[i++];
markerInfo["line"][3][2] = $a[i++];
markerInfo["vertex"][0][0] = $a[i++];
markerInfo["vertex"][0][1] = $a[i++];
markerInfo["vertex"][1][0] = $a[i++];
markerInfo["vertex"][1][1] = $a[i++];
markerInfo["vertex"][2][0] = $a[i++];
markerInfo["vertex"][2][1] = $a[i++];
markerInfo["vertex"][3][0] = $a[i++];
markerInfo["vertex"][3][1] = $a[i++];
markerInfo["errorCorrected"] = $a[i++];
}
},
function($0, $1, $2, $3, $4) {
{
if (!Module["frameMalloc"]) {
Module["frameMalloc"] = {};
}
var frameMalloc = Module["frameMalloc"];
frameMalloc["framepointer"] = $1;
frameMalloc["framesize"] = $2;
frameMalloc["camera"] = $3;
frameMalloc["transform"] = $4;
}
}
];
function _emscripten_asm_const_33(
code,
a0,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15,
a16,
a17,
a18,
a19,
a20,
a21,
a22,
a23,
a24,
a25,
a26,
a27,
a28,
a29,
a30,
a31,
a32
) {
return ASM_CONSTS[code](
a0,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15,
a16,
a17,
a18,
a19,
a20,
a21,
a22,
a23,
a24,
a25,
a26,
a27,
a28,
a29,
a30,
a31,
a32
);
}
function _emscripten_asm_const_4(code, a0, a1, a2, a3) {
return ASM_CONSTS[code](a0, a1, a2, a3);
}
function _emscripten_asm_const_5(code, a0, a1, a2, a3, a4) {
return ASM_CONSTS[code](a0, a1, a2, a3, a4);
}
STATIC_BASE = 8;
STATICTOP = STATIC_BASE + 16496;
__ATINIT__.push(
{
func: function() {
__GLOBAL__sub_I_ARToolKitJS_cpp();
}
},
{
func: function() {
__GLOBAL__sub_I_bind_cpp();
}
}
);
allocate(
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
52,
9,
0,
0,
53,
42,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
128,
1,
0,
0,
0,
0,
0,
0,
228,
8,
0,
0,
116,
42,
0,
0,
52,
9,
0,
0,
136,
47,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
128,
1,
0,
0,
0,
0,
0,
0,
52,
9,
0,
0,
73,
47,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
128,
1,
0,
0,
0,
0,
0,
0,
228,
8,
0,
0,
54,
47,
0,
0,
228,
8,
0,
0,
23,
47,
0,
0,
228,
8,
0,
0,
62,
46,
0,
0,
228,
8,
0,
0,
31,
46,
0,
0,
228,
8,
0,
0,
0,
46,
0,
0,
228,
8,
0,
0,
225,
45,
0,
0,
228,
8,
0,
0,
194,
45,
0,
0,
228,
8,
0,
0,
93,
46,
0,
0,
228,
8,
0,
0,
124,
46,
0,
0,
228,
8,
0,
0,
155,
46,
0,
0,
228,
8,
0,
0,
186,
46,
0,
0,
228,
8,
0,
0,
217,
46,
0,
0,
228,
8,
0,
0,
248,
46,
0,
0,
12,
9,
0,
0,
199,
47,
0,
0,
48,
2,
0,
0,
0,
0,
0,
0,
228,
8,
0,
0,
212,
47,
0,
0,
228,
8,
0,
0,
225,
47,
0,
0,
12,
9,
0,
0,
238,
47,
0,
0,
56,
2,
0,
0,
0,
0,
0,
0,
12,
9,
0,
0,
15,
48,
0,
0,
64,
2,
0,
0,
0,
0,
0,
0,
12,
9,
0,
0,
49,
48,
0,
0,
64,
2,
0,
0,
0,
0,
0,
0,
200,
8,
0,
0,
89,
48,
0,
0,
200,
8,
0,
0,
91,
48,
0,
0,
200,
8,
0,
0,
93,
48,
0,
0,
200,
8,
0,
0,
95,
48,
0,
0,
200,
8,
0,
0,
97,
48,
0,
0,
200,
8,
0,
0,
99,
48,
0,
0,
200,
8,
0,
0,
101,
48,
0,
0,
200,
8,
0,
0,
103,
48,
0,
0,
200,
8,
0,
0,
105,
48,
0,
0,
200,
8,
0,
0,
107,
48,
0,
0,
200,
8,
0,
0,
109,
48,
0,
0,
200,
8,
0,
0,
111,
48,
0,
0,
200,
8,
0,
0,
113,
48,
0,
0,
12,
9,
0,
0,
115,
48,
0,
0,
80,
2,
0,
0,
0,
0,
0,
0,
12,
9,
0,
0,
152,
48,
0,
0,
80,
2,
0,
0,
0,
0,
0,
0,
255,
15,
0,
0,
6,
16,
0,
0,
18,
16,
0,
0,
28,
16,
0,
0,
255,
255,
255,
255,
255,
255,
255,
255,
0,
0,
0,
0,
1,
0,
0,
0,
1,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
255,
255,
255,
255,
0,
0,
0,
0,
1,
0,
0,
0,
1,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
255,
255,
255,
255,
255,
255,
255,
255,
255,
255,
255,
255,
1,
0,
0,
0,
2,
0,
0,
0,
4,
0,
0,
0,
8,
0,
0,
0,
3,
0,
0,
0,
6,
0,
0,
0,
12,
0,
0,
0,
11,
0,
0,
0,
5,
0,
0,
0,
10,
0,
0,
0,
7,
0,
0,
0,
14,
0,
0,
0,
15,
0,
0,
0,
13,
0,
0,
0,
9,
0,
0,
0,
1,
0,
0,
0,
2,
0,
0,
0,
4,
0,
0,
0,
8,
0,
0,
0,
16,
0,
0,
0,
32,
0,
0,
0,
64,
0,
0,
0,
3,
0,
0,
0,
6,
0,
0,
0,
12,
0,
0,
0,
24,
0,
0,
0,
48,
0,
0,
0,
96,
0,
0,
0,
67,
0,
0,
0,
5,
0,
0,
0,
10,
0,
0,
0,
20,
0,
0,
0,
40,
0,
0,
0,
80,
0,
0,
0,
35,
0,
0,
0,
70,
0,
0,
0,
15,
0,
0,
0,
30,
0,
0,
0,
60,
0,
0,
0,
120,
0,
0,
0,
115,
0,
0,
0,
101,
0,
0,
0,
73,
0,
0,
0,
17,
0,
0,
0,
34,
0,
0,
0,
68,
0,
0,
0,
11,
0,
0,
0,
22,
0,
0,
0,
44,
0,
0,
0,
88,
0,
0,
0,
51,
0,
0,
0,
102,
0,
0,
0,
79,
0,
0,
0,
29,
0,
0,
0,
58,
0,
0,
0,
116,
0,
0,
0,
107,
0,
0,
0,
85,
0,
0,
0,
41,
0,
0,
0,
82,
0,
0,
0,
39,
0,
0,
0,
78,
0,
0,
0,
31,
0,
0,
0,
62,
0,
0,
0,
124,
0,
0,
0,
123,
0,
0,
0,
117,
0,
0,
0,
105,
0,
0,
0,
81,
0,
0,
0,
33,
0,
0,
0,
66,
0,
0,
0,
7,
0,
0,
0,
14,
0,
0,
0,
28,
0,
0,
0,
56,
0,
0,
0,
112,
0,
0,
0,
99,
0,
0,
0,
69,
0,
0,
0,
9,
0,
0,
0,
18,
0,
0,
0,
36,
0,
0,
0,
72,
0,
0,
0,
19,
0,
0,
0,
38,
0,
0,
0,
76,
0,
0,
0,
27,
0,
0,
0,
54,
0,
0,
0,
108,
0,
0,
0,
91,
0,
0,
0,
53,
0,
0,
0,
106,
0,
0,
0,
87,
0,
0,
0,
45,
0,
0,
0,
90,
0,
0,
0,
55,
0,
0,
0,
110,
0,
0,
0,
95,
0,
0,
0,
61,
0,
0,
0,
122,
0,
0,
0,
119,
0,
0,
0,
109,
0,
0,
0,
89,
0,
0,
0,
49,
0,
0,
0,
98,
0,
0,
0,
71,
0,
0,
0,
13,
0,
0,
0,
26,
0,
0,
0,
52,
0,
0,
0,
104,
0,
0,
0,
83,
0,
0,
0,
37,
0,
0,
0,
74,
0,
0,
0,
23,
0,
0,
0,
46,
0,
0,
0,
92,
0,
0,
0,
59,
0,
0,
0,
118,
0,
0,
0,
111,
0,
0,
0,
93,
0,
0,
0,
57,
0,
0,
0,
114,
0,
0,
0,
103,
0,
0,
0,
77,
0,
0,
0,
25,
0,
0,
0,
50,
0,
0,
0,
100,
0,
0,
0,
75,
0,
0,
0,
21,
0,
0,
0,
42,
0,
0,
0,
84,
0,
0,
0,
43,
0,
0,
0,
86,
0,
0,
0,
47,
0,
0,
0,
94,
0,
0,
0,
63,
0,
0,
0,
126,
0,
0,
0,
127,
0,
0,
0,
125,
0,
0,
0,
121,
0,
0,
0,
113,
0,
0,
0,
97,
0,
0,
0,
65,
0,
0,
0,
255,
255,
255,
255,
0,
0,
0,
0,
1,
0,
0,
0,
4,
0,
0,
0,
2,
0,
0,
0,
8,
0,
0,
0,
5,
0,
0,
0,
10,
0,
0,
0,
3,
0,
0,
0,
14,
0,
0,
0,
9,
0,
0,
0,
7,
0,
0,
0,
6,
0,
0,
0,
13,
0,
0,
0,
11,
0,
0,
0,
12,
0,
0,
0,
255,
255,
255,
255,
0,
0,
0,
0,
1,
0,
0,
0,
7,
0,
0,
0,
2,
0,
0,
0,
14,
0,
0,
0,
8,
0,
0,
0,
56,
0,
0,
0,
3,
0,
0,
0,
63,
0,
0,
0,
15,
0,
0,
0,
31,
0,
0,
0,
9,
0,
0,
0,
90,
0,
0,
0,
57,
0,
0,
0,
21,
0,
0,
0,
4,
0,
0,
0,
28,
0,
0,
0,
64,
0,
0,
0,
67,
0,
0,
0,
16,
0,
0,
0,
112,
0,
0,
0,
32,
0,
0,
0,
97,
0,
0,
0,
10,
0,
0,
0,
108,
0,
0,
0,
91,
0,
0,
0,
70,
0,
0,
0,
58,
0,
0,
0,
38,
0,
0,
0,
22,
0,
0,
0,
47,
0,
0,
0,
5,
0,
0,
0,
54,
0,
0,
0,
29,
0,
0,
0,
19,
0,
0,
0,
65,
0,
0,
0,
95,
0,
0,
0,
68,
0,
0,
0,
45,
0,
0,
0,
17,
0,
0,
0,
43,
0,
0,
0,
113,
0,
0,
0,
115,
0,
0,
0,
33,
0,
0,
0,
77,
0,
0,
0,
98,
0,
0,
0,
117,
0,
0,
0,
11,
0,
0,
0,
87,
0,
0,
0,
109,
0,
0,
0,
35,
0,
0,
0,
92,
0,
0,
0,
74,
0,
0,
0,
71,
0,
0,
0,
79,
0,
0,
0,
59,
0,
0,
0,
104,
0,
0,
0,
39,
0,
0,
0,
100,
0,
0,
0,
23,
0,
0,
0,
82,
0,
0,
0,
48,
0,
0,
0,
119,
0,
0,
0,
6,
0,
0,
0,
126,
0,
0,
0,
55,
0,
0,
0,
13,
0,
0,
0,
30,
0,
0,
0,
62,
0,
0,
0,
20,
0,
0,
0,
89,
0,
0,
0,
66,
0,
0,
0,
27,
0,
0,
0,
96,
0,
0,
0,
111,
0,
0,
0,
69,
0,
0,
0,
107,
0,
0,
0,
46,
0,
0,
0,
37,
0,
0,
0,
18,
0,
0,
0,
53,
0,
0,
0,
44,
0,
0,
0,
94,
0,
0,
0,
114,
0,
0,
0,
42,
0,
0,
0,
116,
0,
0,
0,
76,
0,
0,
0,
34,
0,
0,
0,
86,
0,
0,
0,
78,
0,
0,
0,
73,
0,
0,
0,
99,
0,
0,
0,
103,
0,
0,
0,
118,
0,
0,
0,
81,
0,
0,
0,
12,
0,
0,
0,
125,
0,
0,
0,
88,
0,
0,
0,
61,
0,
0,
0,
110,
0,
0,
0,
26,
0,
0,
0,
36,
0,
0,
0,
106,
0,
0,
0,
93,
0,
0,
0,
52,
0,
0,
0,
75,
0,
0,
0,
41,
0,
0,
0,
72,
0,
0,
0,
85,
0,
0,
0,
80,
0,
0,
0,
102,
0,
0,
0,
60,
0,
0,
0,
124,
0,
0,
0,
105,
0,
0,
0,
25,
0,
0,
0,
40,
0,
0,
0,
51,
0,
0,
0,
101,
0,
0,
0,
84,
0,
0,
0,
24,
0,
0,
0,
123,
0,
0,
0,
83,
0,
0,
0,
50,
0,
0,
0,
49,
0,
0,
0,
122,
0,
0,
0,
120,
0,
0,
0,
121,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
4,
0,
0,
0,
136,
0,
0,
0,
5,
0,
0,
0,
144,
0,
0,
0,
6,
0,
0,
0,
152,
0,
0,
0,
9,
0,
0,
0,
176,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
255,
255,
255,
255,
253,
255,
255,
255,
254,
255,
255,
255,
0,
0,
0,
0,
112,
2,
0,
0,
168,
2,
0,
0,
200,
2,
0,
0,
112,
2,
0,
0,
168,
2,
0,
0,
168,
2,
0,
0,
208,
2,
0,
0,
168,
2,
0,
0,
112,
2,
0,
0,
168,
2,
0,
0,
208,
2,
0,
0,
168,
2,
0,
0,
112,
2,
0,
0,
168,
2,
0,
0,
168,
2,
0,
0,
104,
1,
0,
0,
168,
2,
0,
0,
168,
2,
0,
0,
168,
2,
0,
0,
168,
2,
0,
0,
168,
2,
0,
0,
104,
1,
0,
0,
168,
2,
0,
0,
168,
2,
0,
0,
168,
2,
0,
0,
168,
2,
0,
0,
168,
2,
0,
0,
168,
2,
0,
0,
0,
0,
0,
0,
32,
2,
0,
0,
1,
0,
0,
0,
2,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
96,
2,
0,
0,
3,
0,
0,
0,
4,
0,
0,
0,
5,
0,
0,
0,
6,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
80,
2,
0,
0,
3,
0,
0,
0,
7,
0,
0,
0,
5,
0,
0,
0,
6,
0,
0,
0,
2,
0,
0,
0,
1,
0,
0,
0,
1,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
216,
2,
0,
0,
3,
0,
0,
0,
8,
0,
0,
0,
5,
0,
0,
0,
6,
0,
0,
0,
2,
0,
0,
0,
2,
0,
0,
0,
2,
0,
0,
0,
2,
0,
0,
0,
0,
0,
0,
0,
232,
2,
0,
0,
3,
0,
0,
0,
9,
0,
0,
0,
5,
0,
0,
0,
6,
0,
0,
0,
2,
0,
0,
0,
3,
0,
0,
0,
3,
0,
0,
0,
3,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
2,
0,
0,
192,
3,
0,
0,
192,
4,
0,
0,
192,
5,
0,
0,
192,
6,
0,
0,
192,
7,
0,
0,
192,
8,
0,
0,
192,
9,
0,
0,
192,
10,
0,
0,
192,
11,
0,
0,
192,
12,
0,
0,
192,
13,
0,
0,
192,
14,
0,
0,
192,
15,
0,
0,
192,
16,
0,
0,
192,
17,
0,
0,
192,
18,
0,
0,
192,
19,
0,
0,
192,
20,
0,
0,
192,
21,
0,
0,
192,
22,
0,
0,
192,
23,
0,
0,
192,
24,
0,
0,
192,
25,
0,
0,
192,
26,
0,
0,
192,
27,
0,
0,
192,
28,
0,
0,
192,
29,
0,
0,
192,
30,
0,
0,
192,
31,
0,
0,
192,
0,
0,
0,
179,
1,
0,
0,
195,
2,
0,
0,
195,
3,
0,
0,
195,
4,
0,
0,
195,
5,
0,
0,
195,
6,
0,
0,
195,
7,
0,
0,
195,
8,
0,
0,
195,
9,
0,
0,
195,
10,
0,
0,
195,
11,
0,
0,
195,
12,
0,
0,
195,
13,
0,
0,
211,
14,
0,
0,
195,
15,
0,
0,
195,
0,
0,
12,
187,
1,
0,
12,
195,
2,
0,
12,
195,
3,
0,
12,
195,
4,
0,
12,
211,
240,
10,
0,
0,
96,
11,
0,
0,
0,
0,
0,
0,
10,
0,
0,
0,
100,
0,
0,
0,
232,
3,
0,
0,
16,
39,
0,
0,
160,
134,
1,
0,
64,
66,
15,
0,
128,
150,
152,
0,
0,
225,
245,
5,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
3,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,