17865 lines
472 KiB
JavaScript
17865 lines
472 KiB
JavaScript
|
// Note: Some Emscripten settings will significantly limit the speed of the generated code.
|
||
|
|
// Note: Some Emscripten settings may limit the speed of the generated code.
|
||
|
|
// The Module object: Our interface to the outside world. We import
|
||
|
|
// and export values on it, and do the work to get that through
|
||
|
|
// closure compiler if necessary. There are various ways Module can be used:
|
||
|
|
// 1. Not defined. We create it here
|
||
|
|
// 2. A function parameter, function(Module) { ..generated code.. }
|
||
|
|
// 3. pre-run appended it, var Module = {}; ..generated code..
|
||
|
|
// 4. External script tag defines var Module.
|
||
|
|
// We need to do an eval in order to handle the closure compiler
|
||
|
|
// case, where this code here is minified but Module was defined
|
||
|
|
// elsewhere (e.g. case 4 above). We also need to check if Module
|
||
|
|
// already exists (e.g. case 3 above).
|
||
|
|
// Note that if you want to run closure, and also to use Module
|
||
|
|
// after the generated code, you will need to define var Module = {};
|
||
|
|
// before the code. Then that object will be used in the code, and you
|
||
|
|
// can continue to use Module afterwards as well.
|
||
|
|
var Module = { };
|
||
|
|
//if (!Module) { Module = eval('(function() { try { return Module || {} } catch(e) { return {} } })()'); }
|
||
|
|
|
||
|
|
// Sometimes an existing Module object exists with properties
|
||
|
|
// meant to overwrite the default module functionality. Here
|
||
|
|
// we collect those properties and reapply _after_ we configure
|
||
|
|
// the current environment's defaults to avoid having to be so
|
||
|
|
// defensive during initialization.
|
||
|
|
var moduleOverrides = {};
|
||
|
|
for (var key in Module) {
|
||
|
|
if (Module.hasOwnProperty(key)) {
|
||
|
|
moduleOverrides[key] = Module[key];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// The environment setup code below is customized to use Module.
|
||
|
|
// *** Environment setup code ***
|
||
|
|
var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function';
|
||
|
|
var ENVIRONMENT_IS_WEB = typeof window === 'object';
|
||
|
|
var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
|
||
|
|
var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
|
||
|
|
|
||
|
|
if (ENVIRONMENT_IS_NODE) {
|
||
|
|
// Expose functionality in the same simple way that the shells work
|
||
|
|
// Note that we pollute the global namespace here, otherwise we break in node
|
||
|
|
if (!Module['print']) Module['print'] = function print(x) {
|
||
|
|
process['stdout'].write(x + '\n');
|
||
|
|
};
|
||
|
|
if (!Module['printErr']) Module['printErr'] = function printErr(x) {
|
||
|
|
process['stderr'].write(x + '\n');
|
||
|
|
};
|
||
|
|
|
||
|
|
var nodeFS = require('fs');
|
||
|
|
var nodePath = require('path');
|
||
|
|
|
||
|
|
Module['read'] = function read(filename, binary) {
|
||
|
|
filename = nodePath['normalize'](filename);
|
||
|
|
var ret = nodeFS['readFileSync'](filename);
|
||
|
|
// The path is absolute if the normalized version is the same as the resolved.
|
||
|
|
if (!ret && filename != nodePath['resolve'](filename)) {
|
||
|
|
filename = path.join(__dirname, '..', 'src', filename);
|
||
|
|
ret = nodeFS['readFileSync'](filename);
|
||
|
|
}
|
||
|
|
if (ret && !binary) ret = ret.toString();
|
||
|
|
return ret;
|
||
|
|
};
|
||
|
|
|
||
|
|
Module['readBinary'] = function readBinary(filename) { return Module['read'](filename, true) };
|
||
|
|
|
||
|
|
Module['load'] = function load(f) {
|
||
|
|
globalEval(read(f));
|
||
|
|
};
|
||
|
|
|
||
|
|
Module['arguments'] = process['argv'].slice(2);
|
||
|
|
|
||
|
|
module['exports'] = Module;
|
||
|
|
}
|
||
|
|
else if (ENVIRONMENT_IS_SHELL) {
|
||
|
|
if (!Module['print']) Module['print'] = print;
|
||
|
|
if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm
|
||
|
|
|
||
|
|
if (typeof read != 'undefined') {
|
||
|
|
Module['read'] = read;
|
||
|
|
} else {
|
||
|
|
Module['read'] = function read() { throw 'no read() available (jsc?)' };
|
||
|
|
}
|
||
|
|
|
||
|
|
Module['readBinary'] = function readBinary(f) {
|
||
|
|
return read(f, 'binary');
|
||
|
|
};
|
||
|
|
|
||
|
|
if (typeof scriptArgs != 'undefined') {
|
||
|
|
Module['arguments'] = scriptArgs;
|
||
|
|
} else if (typeof arguments != 'undefined') {
|
||
|
|
Module['arguments'] = arguments;
|
||
|
|
}
|
||
|
|
|
||
|
|
this['Module'] = Module;
|
||
|
|
|
||
|
|
eval("if (typeof gc === 'function' && gc.toString().indexOf('[native code]') > 0) var gc = undefined"); // wipe out the SpiderMonkey shell 'gc' function, which can confuse closure (uses it as a minified name, and it is then initted to a non-falsey value unexpectedly)
|
||
|
|
}
|
||
|
|
else 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 {
|
||
|
|
// Probably a worker, and without console.log. We can do very little here...
|
||
|
|
var TRY_USE_DUMP = false;
|
||
|
|
if (!Module['print']) Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
|
||
|
|
dump(x);
|
||
|
|
}) : (function(x) {
|
||
|
|
// self.postMessage(x); // enable this if you want stdout to be sent as messages
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ENVIRONMENT_IS_WEB) {
|
||
|
|
this['Module'] = Module;
|
||
|
|
} else {
|
||
|
|
Module['load'] = importScripts;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// Unreachable because SHELL is dependant on the others
|
||
|
|
throw 'Unknown runtime environment. Where are we?';
|
||
|
|
}
|
||
|
|
|
||
|
|
function globalEval(x) {
|
||
|
|
eval.call(null, x);
|
||
|
|
}
|
||
|
|
if (!Module['load'] == 'undefined' && 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'] = [];
|
||
|
|
}
|
||
|
|
// *** Environment setup code ***
|
||
|
|
|
||
|
|
// Closure helpers
|
||
|
|
Module.print = Module['print'];
|
||
|
|
Module.printErr = Module['printErr'];
|
||
|
|
|
||
|
|
// Callbacks
|
||
|
|
Module['preRun'] = [];
|
||
|
|
Module['postRun'] = [];
|
||
|
|
|
||
|
|
// Merge back in the overrides
|
||
|
|
for (var key in moduleOverrides) {
|
||
|
|
if (moduleOverrides.hasOwnProperty(key)) {
|
||
|
|
Module[key] = moduleOverrides[key];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// === Auto-generated preamble library stuff ===
|
||
|
|
|
||
|
|
//========================================
|
||
|
|
// Runtime code shared with compiler
|
||
|
|
//========================================
|
||
|
|
|
||
|
|
var Runtime = {
|
||
|
|
stackSave: function () {
|
||
|
|
return STACKTOP;
|
||
|
|
},
|
||
|
|
stackRestore: function (stackTop) {
|
||
|
|
STACKTOP = stackTop;
|
||
|
|
},
|
||
|
|
forceAlign: function (target, quantum) {
|
||
|
|
quantum = quantum || 4;
|
||
|
|
if (quantum == 1) return target;
|
||
|
|
if (isNumber(target) && isNumber(quantum)) {
|
||
|
|
return Math.ceil(target/quantum)*quantum;
|
||
|
|
} else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
|
||
|
|
return '(((' +target + ')+' + (quantum-1) + ')&' + -quantum + ')';
|
||
|
|
}
|
||
|
|
return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
|
||
|
|
},
|
||
|
|
isNumberType: function (type) {
|
||
|
|
return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
|
||
|
|
},
|
||
|
|
isPointerType: function isPointerType(type) {
|
||
|
|
return type[type.length-1] == '*';
|
||
|
|
},
|
||
|
|
isStructType: function isStructType(type) {
|
||
|
|
if (isPointerType(type)) return false;
|
||
|
|
if (isArrayType(type)) return true;
|
||
|
|
if (/<?{ ?[^}]* ?}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
|
||
|
|
// See comment in isStructPointerType()
|
||
|
|
return type[0] == '%';
|
||
|
|
},
|
||
|
|
INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
|
||
|
|
FLOAT_TYPES: {"float":0,"double":0},
|
||
|
|
or64: function (x, y) {
|
||
|
|
var l = (x | 0) | (y | 0);
|
||
|
|
var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
|
||
|
|
return l + h;
|
||
|
|
},
|
||
|
|
and64: function (x, y) {
|
||
|
|
var l = (x | 0) & (y | 0);
|
||
|
|
var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
|
||
|
|
return l + h;
|
||
|
|
},
|
||
|
|
xor64: function (x, y) {
|
||
|
|
var l = (x | 0) ^ (y | 0);
|
||
|
|
var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
|
||
|
|
return l + h;
|
||
|
|
},
|
||
|
|
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; // A pointer
|
||
|
|
} 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);
|
||
|
|
},
|
||
|
|
dedup: function dedup(items, ident) {
|
||
|
|
var seen = {};
|
||
|
|
if (ident) {
|
||
|
|
return items.filter(function(item) {
|
||
|
|
if (seen[item[ident]]) return false;
|
||
|
|
seen[item[ident]] = true;
|
||
|
|
return true;
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
return items.filter(function(item) {
|
||
|
|
if (seen[item]) return false;
|
||
|
|
seen[item] = true;
|
||
|
|
return true;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
},
|
||
|
|
set: function set() {
|
||
|
|
var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
|
||
|
|
var ret = {};
|
||
|
|
for (var i = 0; i < args.length; i++) {
|
||
|
|
ret[args[i]] = 0;
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
},
|
||
|
|
STACK_ALIGN: 8,
|
||
|
|
getAlignSize: function (type, size, vararg) {
|
||
|
|
// we align i64s and doubles on 64-bit boundaries, unlike x86
|
||
|
|
if (vararg) return 8;
|
||
|
|
if (!vararg && (type == 'i64' || type == 'double')) return 8;
|
||
|
|
if (!type) return Math.min(size, 8); // align structures internally to 64 bits
|
||
|
|
return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE);
|
||
|
|
},
|
||
|
|
calculateStructAlignment: function calculateStructAlignment(type) {
|
||
|
|
type.flatSize = 0;
|
||
|
|
type.alignSize = 0;
|
||
|
|
var diffs = [];
|
||
|
|
var prev = -1;
|
||
|
|
var index = 0;
|
||
|
|
type.flatIndexes = type.fields.map(function(field) {
|
||
|
|
index++;
|
||
|
|
var size, alignSize;
|
||
|
|
if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
|
||
|
|
size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
|
||
|
|
alignSize = Runtime.getAlignSize(field, size);
|
||
|
|
} else if (Runtime.isStructType(field)) {
|
||
|
|
if (field[1] === '0') {
|
||
|
|
// this is [0 x something]. When inside another structure like here, it must be at the end,
|
||
|
|
// and it adds no size
|
||
|
|
// XXX this happens in java-nbody for example... assert(index === type.fields.length, 'zero-length in the middle!');
|
||
|
|
size = 0;
|
||
|
|
if (Types.types[field]) {
|
||
|
|
alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
|
||
|
|
} else {
|
||
|
|
alignSize = type.alignSize || QUANTUM_SIZE;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
size = Types.types[field].flatSize;
|
||
|
|
alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
|
||
|
|
}
|
||
|
|
} else if (field[0] == 'b') {
|
||
|
|
// bN, large number field, like a [N x i8]
|
||
|
|
size = field.substr(1)|0;
|
||
|
|
alignSize = 1;
|
||
|
|
} else if (field[0] === '<') {
|
||
|
|
// vector type
|
||
|
|
size = alignSize = Types.types[field].flatSize; // fully aligned
|
||
|
|
} else if (field[0] === 'i') {
|
||
|
|
// illegal integer field, that could not be legalized because it is an internal structure field
|
||
|
|
// it is ok to have such fields, if we just use them as markers of field size and nothing more complex
|
||
|
|
size = alignSize = parseInt(field.substr(1))/8;
|
||
|
|
assert(size % 1 === 0, 'cannot handle non-byte-size field ' + field);
|
||
|
|
} else {
|
||
|
|
assert(false, 'invalid type for calculateStructAlignment');
|
||
|
|
}
|
||
|
|
if (type.packed) alignSize = 1;
|
||
|
|
type.alignSize = Math.max(type.alignSize, alignSize);
|
||
|
|
var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
|
||
|
|
type.flatSize = curr + size;
|
||
|
|
if (prev >= 0) {
|
||
|
|
diffs.push(curr-prev);
|
||
|
|
}
|
||
|
|
prev = curr;
|
||
|
|
return curr;
|
||
|
|
});
|
||
|
|
if (type.name_ && type.name_[0] === '[') {
|
||
|
|
// arrays have 2 elements, so we get the proper difference. then we scale here. that way we avoid
|
||
|
|
// allocating a potentially huge array for [999999 x i8] etc.
|
||
|
|
type.flatSize = parseInt(type.name_.substr(1))*type.flatSize/2;
|
||
|
|
}
|
||
|
|
type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
|
||
|
|
if (diffs.length == 0) {
|
||
|
|
type.flatFactor = type.flatSize;
|
||
|
|
} else if (Runtime.dedup(diffs).length == 1) {
|
||
|
|
type.flatFactor = diffs[0];
|
||
|
|
}
|
||
|
|
type.needsFlattening = (type.flatFactor != 1);
|
||
|
|
return type.flatIndexes;
|
||
|
|
},
|
||
|
|
generateStructInfo: function (struct, typeName, offset) {
|
||
|
|
var type, alignment;
|
||
|
|
if (typeName) {
|
||
|
|
offset = offset || 0;
|
||
|
|
type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
|
||
|
|
if (!type) return null;
|
||
|
|
if (type.fields.length != struct.length) {
|
||
|
|
printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
alignment = type.flatIndexes;
|
||
|
|
} else {
|
||
|
|
var type = { fields: struct.map(function(item) { return item[0] }) };
|
||
|
|
alignment = Runtime.calculateStructAlignment(type);
|
||
|
|
}
|
||
|
|
var ret = {
|
||
|
|
__size__: type.flatSize
|
||
|
|
};
|
||
|
|
if (typeName) {
|
||
|
|
struct.forEach(function(item, i) {
|
||
|
|
if (typeof item === 'string') {
|
||
|
|
ret[item] = alignment[i] + offset;
|
||
|
|
} else {
|
||
|
|
// embedded struct
|
||
|
|
var key;
|
||
|
|
for (var k in item) key = k;
|
||
|
|
ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
struct.forEach(function(item, i) {
|
||
|
|
ret[item[1]] = alignment[i];
|
||
|
|
});
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
},
|
||
|
|
dynCall: function (sig, ptr, args) {
|
||
|
|
if (args && args.length) {
|
||
|
|
assert(args.length == sig.length-1);
|
||
|
|
return FUNCTION_TABLE[ptr].apply(null, args);
|
||
|
|
} else {
|
||
|
|
assert(sig.length == 1);
|
||
|
|
return FUNCTION_TABLE[ptr]();
|
||
|
|
}
|
||
|
|
},
|
||
|
|
addFunction: function (func) {
|
||
|
|
var table = FUNCTION_TABLE;
|
||
|
|
var ret = table.length;
|
||
|
|
assert(ret % 2 === 0);
|
||
|
|
table.push(func);
|
||
|
|
for (var i = 0; i < 2-1; i++) table.push(0);
|
||
|
|
return ret;
|
||
|
|
},
|
||
|
|
removeFunction: function (index) {
|
||
|
|
var table = FUNCTION_TABLE;
|
||
|
|
table[index] = null;
|
||
|
|
},
|
||
|
|
getAsmConst: function (code, numArgs) {
|
||
|
|
// code is a constant string on the heap, so we can cache these
|
||
|
|
if (!Runtime.asmConstCache) Runtime.asmConstCache = {};
|
||
|
|
var func = Runtime.asmConstCache[code];
|
||
|
|
if (func) return func;
|
||
|
|
var args = [];
|
||
|
|
for (var i = 0; i < numArgs; i++) {
|
||
|
|
args.push(String.fromCharCode(36) + i); // $0, $1 etc
|
||
|
|
}
|
||
|
|
code = Pointer_stringify(code);
|
||
|
|
if (code[0] === '"') {
|
||
|
|
// tolerate EM_ASM("..code..") even though EM_ASM(..code..) is correct
|
||
|
|
if (code.indexOf('"', 1) === code.length-1) {
|
||
|
|
code = code.substr(1, code.length-2);
|
||
|
|
} else {
|
||
|
|
// something invalid happened, e.g. EM_ASM("..code($0)..", input)
|
||
|
|
abort('invalid EM_ASM input |' + code + '|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return Runtime.asmConstCache[code] = eval('(function(' + args.join(',') + '){ ' + code + ' })'); // new Function does not allow upvars in node
|
||
|
|
},
|
||
|
|
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[func]) {
|
||
|
|
Runtime.funcWrappers[func] = function dynCall_wrapper() {
|
||
|
|
return Runtime.dynCall(sig, func, arguments);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
return Runtime.funcWrappers[func];
|
||
|
|
},
|
||
|
|
UTF8Processor: function () {
|
||
|
|
var buffer = [];
|
||
|
|
var needed = 0;
|
||
|
|
this.processCChar = function (code) {
|
||
|
|
code = code & 0xFF;
|
||
|
|
|
||
|
|
if (buffer.length == 0) {
|
||
|
|
if ((code & 0x80) == 0x00) { // 0xxxxxxx
|
||
|
|
return String.fromCharCode(code);
|
||
|
|
}
|
||
|
|
buffer.push(code);
|
||
|
|
if ((code & 0xE0) == 0xC0) { // 110xxxxx
|
||
|
|
needed = 1;
|
||
|
|
} else if ((code & 0xF0) == 0xE0) { // 1110xxxx
|
||
|
|
needed = 2;
|
||
|
|
} else { // 11110xxx
|
||
|
|
needed = 3;
|
||
|
|
}
|
||
|
|
return '';
|
||
|
|
}
|
||
|
|
|
||
|
|
if (needed) {
|
||
|
|
buffer.push(code);
|
||
|
|
needed--;
|
||
|
|
if (needed > 0) return '';
|
||
|
|
}
|
||
|
|
|
||
|
|
var c1 = buffer[0];
|
||
|
|
var c2 = buffer[1];
|
||
|
|
var c3 = buffer[2];
|
||
|
|
var c4 = buffer[3];
|
||
|
|
var ret;
|
||
|
|
if (buffer.length == 2) {
|
||
|
|
ret = String.fromCharCode(((c1 & 0x1F) << 6) | (c2 & 0x3F));
|
||
|
|
} else if (buffer.length == 3) {
|
||
|
|
ret = String.fromCharCode(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
|
||
|
|
} else {
|
||
|
|
// http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
|
||
|
|
var codePoint = ((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) |
|
||
|
|
((c3 & 0x3F) << 6) | (c4 & 0x3F);
|
||
|
|
ret = String.fromCharCode(
|
||
|
|
Math.floor((codePoint - 0x10000) / 0x400) + 0xD800,
|
||
|
|
(codePoint - 0x10000) % 0x400 + 0xDC00);
|
||
|
|
}
|
||
|
|
buffer.length = 0;
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
this.processJSString = function processJSString(string) {
|
||
|
|
string = unescape(encodeURIComponent(string));
|
||
|
|
var ret = [];
|
||
|
|
for (var i = 0; i < string.length; i++) {
|
||
|
|
ret.push(string.charCodeAt(i));
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+7)&-8);(assert((STACKTOP|0) < (STACK_MAX|0))|0); return ret; },
|
||
|
|
staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + (assert(!staticSealed),size))|0;STATICTOP = (((STATICTOP)+7)&-8); return ret; },
|
||
|
|
dynamicAlloc: function (size) { var ret = DYNAMICTOP;DYNAMICTOP = (DYNAMICTOP + (assert(DYNAMICTOP > 0),size))|0;DYNAMICTOP = (((DYNAMICTOP)+7)&-8); if (DYNAMICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
|
||
|
|
alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 8))*(quantum ? quantum : 8); 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;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
//========================================
|
||
|
|
// Runtime essentials
|
||
|
|
//========================================
|
||
|
|
|
||
|
|
var __THREW__ = 0; // Used in checking for thrown exceptions.
|
||
|
|
var setjmpId = 1; // Used in setjmp/longjmp
|
||
|
|
var setjmpLabels = {};
|
||
|
|
|
||
|
|
var ABORT = false; // whether we are quitting the application. no code should run after this. set in exit() and abort()
|
||
|
|
var EXITSTATUS = 0;
|
||
|
|
|
||
|
|
var undef = 0;
|
||
|
|
// tempInt is used for 32-bit signed values or smaller. tempBigInt is used
|
||
|
|
// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
|
||
|
|
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;
|
||
|
|
|
||
|
|
// C calling interface. A convenient way to call C functions (in C files, or
|
||
|
|
// defined with extern "C").
|
||
|
|
//
|
||
|
|
// Note: LLVM optimizations can inline and remove functions, after which you will not be
|
||
|
|
// able to call them. Closure can also do so. To avoid that, add your function to
|
||
|
|
// the exports using something like
|
||
|
|
//
|
||
|
|
// -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
|
||
|
|
//
|
||
|
|
// @param ident The name of the C function (note that C++ functions will be name-mangled - use extern "C")
|
||
|
|
// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
|
||
|
|
// 'array' for JavaScript arrays and typed arrays; note that arrays are 8-bit).
|
||
|
|
// @param argTypes An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
|
||
|
|
// except that 'array' is not possible (there is no way for us to know the length of the array)
|
||
|
|
// @param args An array of the arguments to the function, as native JS values (as in returnType)
|
||
|
|
// Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
|
||
|
|
// @return The return value, as a native JS value (as in returnType)
|
||
|
|
function ccall(ident, returnType, argTypes, args) {
|
||
|
|
return ccallFunc(getCFunc(ident), returnType, argTypes, args);
|
||
|
|
}
|
||
|
|
Module["ccall"] = ccall;
|
||
|
|
|
||
|
|
// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
|
||
|
|
function getCFunc(ident) {
|
||
|
|
try {
|
||
|
|
var func = Module['_' + ident]; // closure exported function
|
||
|
|
if (!func) func = eval('_' + ident); // explicit lookup
|
||
|
|
} catch(e) {
|
||
|
|
}
|
||
|
|
assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
|
||
|
|
return func;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Internal function that does a C call using a function, not an identifier
|
||
|
|
function ccallFunc(func, returnType, argTypes, args) {
|
||
|
|
var stack = 0;
|
||
|
|
function toC(value, type) {
|
||
|
|
if (type == 'string') {
|
||
|
|
if (value === null || value === undefined || value === 0) return 0; // null string
|
||
|
|
value = intArrayFromString(value);
|
||
|
|
type = 'array';
|
||
|
|
}
|
||
|
|
if (type == 'array') {
|
||
|
|
if (!stack) stack = Runtime.stackSave();
|
||
|
|
var ret = Runtime.stackAlloc(value.length);
|
||
|
|
writeArrayToMemory(value, ret);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
function fromC(value, type) {
|
||
|
|
if (type == 'string') {
|
||
|
|
return Pointer_stringify(value);
|
||
|
|
}
|
||
|
|
assert(type != 'array');
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
var i = 0;
|
||
|
|
var cArgs = args ? args.map(function(arg) {
|
||
|
|
return toC(arg, argTypes[i++]);
|
||
|
|
}) : [];
|
||
|
|
var ret = fromC(func.apply(null, cArgs), returnType);
|
||
|
|
if (stack) Runtime.stackRestore(stack);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns a native JS wrapper for a C function. This is similar to ccall, but
|
||
|
|
// returns a function you can call repeatedly in a normal way. For example:
|
||
|
|
//
|
||
|
|
// var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
|
||
|
|
// alert(my_function(5, 22));
|
||
|
|
// alert(my_function(99, 12));
|
||
|
|
//
|
||
|
|
function cwrap(ident, returnType, argTypes) {
|
||
|
|
var func = getCFunc(ident);
|
||
|
|
return function() {
|
||
|
|
return ccallFunc(func, returnType, argTypes, Array.prototype.slice.call(arguments));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Module["cwrap"] = cwrap;
|
||
|
|
|
||
|
|
// Sets a value in memory in a dynamic way at run-time. Uses the
|
||
|
|
// type data. This is the same as makeSetValue, except that
|
||
|
|
// makeSetValue is done at compile-time and generates the needed
|
||
|
|
// code then, whereas this function picks the right code at
|
||
|
|
// run-time.
|
||
|
|
// Note that setValue and getValue only do *aligned* writes and reads!
|
||
|
|
// Note that ccall uses JS types as for defining types, while setValue and
|
||
|
|
// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
|
||
|
|
function setValue(ptr, value, type, noSafe) {
|
||
|
|
type = type || 'i8';
|
||
|
|
if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
|
||
|
|
switch(type) {
|
||
|
|
case 'i1': HEAP8[(ptr)]=value; break;
|
||
|
|
case 'i8': HEAP8[(ptr)]=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 : (~~(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;
|
||
|
|
|
||
|
|
// Parallel to setValue.
|
||
|
|
function getValue(ptr, type, noSafe) {
|
||
|
|
type = type || 'i8';
|
||
|
|
if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
|
||
|
|
switch(type) {
|
||
|
|
case 'i1': return HEAP8[(ptr)];
|
||
|
|
case 'i8': return HEAP8[(ptr)];
|
||
|
|
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; // Tries to use _malloc()
|
||
|
|
var ALLOC_STACK = 1; // Lives for the duration of the current function call
|
||
|
|
var ALLOC_STATIC = 2; // Cannot be freed
|
||
|
|
var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk
|
||
|
|
var ALLOC_NONE = 4; // Do not allocate
|
||
|
|
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;
|
||
|
|
|
||
|
|
// allocate(): This is for internal use. You can use it yourself as well, but the interface
|
||
|
|
// is a little tricky (see docs right below). The reason is that it is optimized
|
||
|
|
// for multiple syntaxes to save space in generated code. So you should
|
||
|
|
// normally not use allocate(), and instead allocate memory using _malloc(),
|
||
|
|
// initialize it with setValue(), and so forth.
|
||
|
|
// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
|
||
|
|
// in *bytes* (note that this is sometimes confusing: the next parameter does not
|
||
|
|
// affect this!)
|
||
|
|
// @types: Either an array of types, one for each byte (or 0 if no type at that position),
|
||
|
|
// or a single type which is used for the entire block. This only matters if there
|
||
|
|
// is initial data - if @slab is a number, then this does not matter at all and is
|
||
|
|
// ignored.
|
||
|
|
// @allocator: How to allocate memory, see ALLOC_*
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
assert(type, 'Must know what type to store in allocate!');
|
||
|
|
|
||
|
|
if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
|
||
|
|
|
||
|
|
setValue(ret+i, curr, type);
|
||
|
|
|
||
|
|
// no need to look up size unless type changes, so cache it
|
||
|
|
if (previousType !== type) {
|
||
|
|
typeSize = Runtime.getNativeTypeSize(type);
|
||
|
|
previousType = type;
|
||
|
|
}
|
||
|
|
i += typeSize;
|
||
|
|
}
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
Module['allocate'] = allocate;
|
||
|
|
|
||
|
|
function Pointer_stringify(ptr, /* optional */ length) {
|
||
|
|
// TODO: use TextDecoder
|
||
|
|
// Find the length, and check for UTF while doing so
|
||
|
|
var hasUtf = false;
|
||
|
|
var t;
|
||
|
|
var i = 0;
|
||
|
|
while (1) {
|
||
|
|
assert(ptr + i < TOTAL_MEMORY);
|
||
|
|
t = HEAPU8[(((ptr)+(i))|0)];
|
||
|
|
if (t >= 128) hasUtf = true;
|
||
|
|
else if (t == 0 && !length) break;
|
||
|
|
i++;
|
||
|
|
if (length && i == length) break;
|
||
|
|
}
|
||
|
|
if (!length) length = i;
|
||
|
|
|
||
|
|
var ret = '';
|
||
|
|
|
||
|
|
if (!hasUtf) {
|
||
|
|
var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
var utf8 = new Runtime.UTF8Processor();
|
||
|
|
for (i = 0; i < length; i++) {
|
||
|
|
assert(ptr + i < TOTAL_MEMORY);
|
||
|
|
t = HEAPU8[(((ptr)+(i))|0)];
|
||
|
|
ret += utf8.processCChar(t);
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
Module['Pointer_stringify'] = Pointer_stringify;
|
||
|
|
|
||
|
|
// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
|
||
|
|
// a copy of that string as a Javascript String object.
|
||
|
|
function UTF16ToString(ptr) {
|
||
|
|
var i = 0;
|
||
|
|
|
||
|
|
var str = '';
|
||
|
|
while (1) {
|
||
|
|
var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
|
||
|
|
if (codeUnit == 0)
|
||
|
|
return str;
|
||
|
|
++i;
|
||
|
|
// fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
|
||
|
|
str += String.fromCharCode(codeUnit);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Module['UTF16ToString'] = UTF16ToString;
|
||
|
|
|
||
|
|
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
|
||
|
|
// null-terminated and encoded in UTF16LE form. The copy will require at most (str.length*2+1)*2 bytes of space in the HEAP.
|
||
|
|
function stringToUTF16(str, outPtr) {
|
||
|
|
for(var i = 0; i < str.length; ++i) {
|
||
|
|
// charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
|
||
|
|
var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
|
||
|
|
HEAP16[(((outPtr)+(i*2))>>1)]=codeUnit;
|
||
|
|
}
|
||
|
|
// Null-terminate the pointer to the HEAP.
|
||
|
|
HEAP16[(((outPtr)+(str.length*2))>>1)]=0;
|
||
|
|
}
|
||
|
|
Module['stringToUTF16'] = stringToUTF16;
|
||
|
|
|
||
|
|
// Given a pointer 'ptr' to a null-terminated UTF32LE-encoded string in the emscripten HEAP, returns
|
||
|
|
// a copy of that string as a Javascript String object.
|
||
|
|
function UTF32ToString(ptr) {
|
||
|
|
var i = 0;
|
||
|
|
|
||
|
|
var str = '';
|
||
|
|
while (1) {
|
||
|
|
var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
|
||
|
|
if (utf32 == 0)
|
||
|
|
return str;
|
||
|
|
++i;
|
||
|
|
// Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
|
||
|
|
if (utf32 >= 0x10000) {
|
||
|
|
var ch = utf32 - 0x10000;
|
||
|
|
str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
|
||
|
|
} else {
|
||
|
|
str += String.fromCharCode(utf32);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Module['UTF32ToString'] = UTF32ToString;
|
||
|
|
|
||
|
|
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
|
||
|
|
// null-terminated and encoded in UTF32LE form. The copy will require at most (str.length+1)*4 bytes of space in the HEAP,
|
||
|
|
// but can use less, since str.length does not return the number of characters in the string, but the number of UTF-16 code units in the string.
|
||
|
|
function stringToUTF32(str, outPtr) {
|
||
|
|
var iChar = 0;
|
||
|
|
for(var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
|
||
|
|
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
|
||
|
|
var codeUnit = str.charCodeAt(iCodeUnit); // possibly a lead surrogate
|
||
|
|
if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
|
||
|
|
var trailSurrogate = str.charCodeAt(++iCodeUnit);
|
||
|
|
codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
|
||
|
|
}
|
||
|
|
HEAP32[(((outPtr)+(iChar*4))>>2)]=codeUnit;
|
||
|
|
++iChar;
|
||
|
|
}
|
||
|
|
// Null-terminate the pointer to the HEAP.
|
||
|
|
HEAP32[(((outPtr)+(iChar*4))>>2)]=0;
|
||
|
|
}
|
||
|
|
Module['stringToUTF32'] = stringToUTF32;
|
||
|
|
|
||
|
|
function demangle(func) {
|
||
|
|
try {
|
||
|
|
// Special-case the entry point, since its name differs from other name mangling.
|
||
|
|
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; // C function
|
||
|
|
if (func[2] !== 'Z') return func;
|
||
|
|
switch (func[3]) {
|
||
|
|
case 'n': return 'operator new()';
|
||
|
|
case 'd': return 'operator delete()';
|
||
|
|
}
|
||
|
|
var i = 3;
|
||
|
|
// params, etc.
|
||
|
|
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': '...'
|
||
|
|
};
|
||
|
|
function dump(x) {
|
||
|
|
//return;
|
||
|
|
if (x) Module.print(x);
|
||
|
|
Module.print(func);
|
||
|
|
var pre = '';
|
||
|
|
for (var a = 0; a < i; a++) pre += ' ';
|
||
|
|
Module.print (pre + '^');
|
||
|
|
}
|
||
|
|
var subs = [];
|
||
|
|
function parseNested() {
|
||
|
|
i++;
|
||
|
|
if (func[i] === 'K') i++; // ignore const
|
||
|
|
var parts = [];
|
||
|
|
while (func[i] !== 'E') {
|
||
|
|
if (func[i] === 'S') { // substitution
|
||
|
|
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') { // constructor
|
||
|
|
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; } // counter i++ below us
|
||
|
|
var curr = func.substr(i + pre, size);
|
||
|
|
parts.push(curr);
|
||
|
|
subs.push(curr);
|
||
|
|
i += pre + size;
|
||
|
|
}
|
||
|
|
i++; // skip E
|
||
|
|
return parts;
|
||
|
|
}
|
||
|
|
var first = true;
|
||
|
|
function parse(rawList, limit, allowVoid) { // main parser
|
||
|
|
limit = limit || Infinity;
|
||
|
|
var ret = '', list = [];
|
||
|
|
function flushList() {
|
||
|
|
return '(' + list.join(', ') + ')';
|
||
|
|
}
|
||
|
|
var name;
|
||
|
|
if (func[i] === 'N') {
|
||
|
|
// namespaced N-E
|
||
|
|
name = parseNested().join('::');
|
||
|
|
limit--;
|
||
|
|
if (limit === 0) return rawList ? [name] : name;
|
||
|
|
} else {
|
||
|
|
// not namespaced
|
||
|
|
if (func[i] === 'K' || (first && func[i] === 'L')) i++; // ignore const and first 'L'
|
||
|
|
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) {
|
||
|
|
//dump('paramLoop');
|
||
|
|
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; // pointer
|
||
|
|
case 'R': list.push(parse(true, 1, true)[0] + '&'); break; // reference
|
||
|
|
case 'L': { // literal
|
||
|
|
i++; // skip basic type
|
||
|
|
var end = func.indexOf('E', i);
|
||
|
|
var size = end - i;
|
||
|
|
list.push(func.substr(i, size));
|
||
|
|
i += size + 2; // size + 'EE'
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 'A': { // array
|
||
|
|
var size = parseInt(func.substr(i));
|
||
|
|
i += size.toString().length;
|
||
|
|
if (func[i] !== '_') throw '?';
|
||
|
|
i++; // skip _
|
||
|
|
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 = []; // avoid (void)
|
||
|
|
return rawList ? list : ret + flushList();
|
||
|
|
}
|
||
|
|
return parse();
|
||
|
|
} catch(e) {
|
||
|
|
return func;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function demangleAll(text) {
|
||
|
|
return text.replace(/__Z[\w\d_]+/g, function(x) { var y = demangle(x); return x === y ? x : (x + ' [' + y + ']') });
|
||
|
|
}
|
||
|
|
|
||
|
|
function stackTrace() {
|
||
|
|
var stack = new Error().stack;
|
||
|
|
return stack ? demangleAll(stack) : '(no stack trace available)'; // Stack trace is not available at least on IE10 and Safari 6.
|
||
|
|
}
|
||
|
|
|
||
|
|
// Memory management
|
||
|
|
|
||
|
|
var PAGE_SIZE = 4096;
|
||
|
|
function alignMemoryPage(x) {
|
||
|
|
return (x+4095)&-4096;
|
||
|
|
}
|
||
|
|
|
||
|
|
var HEAP;
|
||
|
|
var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
|
||
|
|
|
||
|
|
var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false; // static area
|
||
|
|
var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0; // stack area
|
||
|
|
var DYNAMIC_BASE = 0, DYNAMICTOP = 0; // dynamic area handled by sbrk
|
||
|
|
|
||
|
|
function enlargeMemory() {
|
||
|
|
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 ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.');
|
||
|
|
}
|
||
|
|
|
||
|
|
var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
|
||
|
|
var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 16777216;
|
||
|
|
var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
|
||
|
|
|
||
|
|
|
||
|
|
// Initialize the runtime's memory
|
||
|
|
// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
|
||
|
|
assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
|
||
|
|
'Cannot fallback to non-typed array case: Code is too specialized');
|
||
|
|
|
||
|
|
var 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);
|
||
|
|
|
||
|
|
// Endianness check (note: assumes compiler arch was little-endian)
|
||
|
|
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['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__ = []; // functions called before the runtime is initialized
|
||
|
|
var __ATINIT__ = []; // functions called during startup
|
||
|
|
var __ATMAIN__ = []; // functions called when main() is to be run
|
||
|
|
var __ATEXIT__ = []; // functions called during shutdown
|
||
|
|
var __ATPOSTRUN__ = []; // functions called after the runtime has exited
|
||
|
|
|
||
|
|
var runtimeInitialized = false;
|
||
|
|
|
||
|
|
function preRun() {
|
||
|
|
// compatibility - merge in anything from Module['preRun'] at this time
|
||
|
|
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__);
|
||
|
|
}
|
||
|
|
|
||
|
|
function postRun() {
|
||
|
|
// compatibility - merge in anything from Module['postRun'] at this time
|
||
|
|
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'] = Module.addOnPreRun = addOnPreRun;
|
||
|
|
|
||
|
|
function addOnInit(cb) {
|
||
|
|
__ATINIT__.unshift(cb);
|
||
|
|
}
|
||
|
|
Module['addOnInit'] = Module.addOnInit = addOnInit;
|
||
|
|
|
||
|
|
function addOnPreMain(cb) {
|
||
|
|
__ATMAIN__.unshift(cb);
|
||
|
|
}
|
||
|
|
Module['addOnPreMain'] = Module.addOnPreMain = addOnPreMain;
|
||
|
|
|
||
|
|
function addOnExit(cb) {
|
||
|
|
__ATEXIT__.unshift(cb);
|
||
|
|
}
|
||
|
|
Module['addOnExit'] = Module.addOnExit = addOnExit;
|
||
|
|
|
||
|
|
function addOnPostRun(cb) {
|
||
|
|
__ATPOSTRUN__.unshift(cb);
|
||
|
|
}
|
||
|
|
Module['addOnPostRun'] = Module.addOnPostRun = addOnPostRun;
|
||
|
|
|
||
|
|
// Tools
|
||
|
|
|
||
|
|
// This processes a JS string into a C-line array of numbers, 0-terminated.
|
||
|
|
// For LLVM-originating strings, see parser.js:parseLLVMString function
|
||
|
|
function intArrayFromString(stringy, dontAddNull, length /* optional */) {
|
||
|
|
var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
|
||
|
|
if (length) {
|
||
|
|
ret.length = length;
|
||
|
|
}
|
||
|
|
if (!dontAddNull) {
|
||
|
|
ret.push(0);
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
Module['intArrayFromString'] = intArrayFromString;
|
||
|
|
|
||
|
|
function intArrayToString(array) {
|
||
|
|
var ret = [];
|
||
|
|
for (var i = 0; i < array.length; i++) {
|
||
|
|
var chr = array[i];
|
||
|
|
if (chr > 0xFF) {
|
||
|
|
assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.');
|
||
|
|
chr &= 0xFF;
|
||
|
|
}
|
||
|
|
ret.push(String.fromCharCode(chr));
|
||
|
|
}
|
||
|
|
return ret.join('');
|
||
|
|
}
|
||
|
|
Module['intArrayToString'] = intArrayToString;
|
||
|
|
|
||
|
|
// Write a Javascript array to somewhere in the heap
|
||
|
|
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)+(i))|0)]=array[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Module['writeArrayToMemory'] = writeArrayToMemory;
|
||
|
|
|
||
|
|
function writeAsciiToMemory(str, buffer, dontAddNull) {
|
||
|
|
for (var i = 0; i < str.length; i++) {
|
||
|
|
assert(str.charCodeAt(i) === str.charCodeAt(i)&0xff);
|
||
|
|
HEAP8[(((buffer)+(i))|0)]=str.charCodeAt(i);
|
||
|
|
}
|
||
|
|
if (!dontAddNull) HEAP8[(((buffer)+(str.length))|0)]=0;
|
||
|
|
}
|
||
|
|
Module['writeAsciiToMemory'] = writeAsciiToMemory;
|
||
|
|
|
||
|
|
function unSign(value, bits, ignore, sig) {
|
||
|
|
if (value >= 0) {
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
|
||
|
|
: Math.pow(2, bits) + value;
|
||
|
|
}
|
||
|
|
function reSign(value, bits, ignore, sig) {
|
||
|
|
if (value <= 0) {
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
|
||
|
|
: Math.pow(2, bits-1);
|
||
|
|
if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
|
||
|
|
// but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
|
||
|
|
// TODO: In i64 mode 1, resign the two parts separately and safely
|
||
|
|
value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
|
||
|
|
}
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 )
|
||
|
|
if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) {
|
||
|
|
var ah = a >>> 16;
|
||
|
|
var al = a & 0xffff;
|
||
|
|
var bh = b >>> 16;
|
||
|
|
var bl = b & 0xffff;
|
||
|
|
return (al*bl + ((ah*bl + al*bh) << 16))|0;
|
||
|
|
};
|
||
|
|
Math.imul = Math['imul'];
|
||
|
|
|
||
|
|
|
||
|
|
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;
|
||
|
|
|
||
|
|
// A counter of dependencies for calling run(). If we need to
|
||
|
|
// do asynchronous work before running, increment this and
|
||
|
|
// decrement it. Incrementing must happen in a place like
|
||
|
|
// PRE_RUN_ADDITIONS (used by emcc to add file preloading).
|
||
|
|
// Note that you can add dependencies in preRun, even though
|
||
|
|
// it happens right before run - run will be postponed until
|
||
|
|
// the dependencies are met.
|
||
|
|
var runDependencies = 0;
|
||
|
|
var runDependencyWatcher = null;
|
||
|
|
var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
|
||
|
|
var runDependencyTracking = {};
|
||
|
|
|
||
|
|
function addRunDependency(id) {
|
||
|
|
runDependencies++;
|
||
|
|
if (Module['monitorRunDependencies']) {
|
||
|
|
Module['monitorRunDependencies'](runDependencies);
|
||
|
|
}
|
||
|
|
if (id) {
|
||
|
|
assert(!runDependencyTracking[id]);
|
||
|
|
runDependencyTracking[id] = 1;
|
||
|
|
if (runDependencyWatcher === null && typeof setInterval !== 'undefined') {
|
||
|
|
// Check for missing dependencies every few seconds
|
||
|
|
runDependencyWatcher = setInterval(function() {
|
||
|
|
var shown = false;
|
||
|
|
for (var dep in runDependencyTracking) {
|
||
|
|
if (!shown) {
|
||
|
|
shown = true;
|
||
|
|
Module.printErr('still waiting on run dependencies:');
|
||
|
|
}
|
||
|
|
Module.printErr('dependency: ' + dep);
|
||
|
|
}
|
||
|
|
if (shown) {
|
||
|
|
Module.printErr('(end of list)');
|
||
|
|
}
|
||
|
|
}, 10000);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
Module.printErr('warning: run dependency added without ID');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Module['addRunDependency'] = addRunDependency;
|
||
|
|
function removeRunDependency(id) {
|
||
|
|
runDependencies--;
|
||
|
|
if (Module['monitorRunDependencies']) {
|
||
|
|
Module['monitorRunDependencies'](runDependencies);
|
||
|
|
}
|
||
|
|
if (id) {
|
||
|
|
assert(runDependencyTracking[id]);
|
||
|
|
delete runDependencyTracking[id];
|
||
|
|
} else {
|
||
|
|
Module.printErr('warning: run dependency removed without ID');
|
||
|
|
}
|
||
|
|
if (runDependencies == 0) {
|
||
|
|
if (runDependencyWatcher !== null) {
|
||
|
|
clearInterval(runDependencyWatcher);
|
||
|
|
runDependencyWatcher = null;
|
||
|
|
}
|
||
|
|
if (dependenciesFulfilled) {
|
||
|
|
var callback = dependenciesFulfilled;
|
||
|
|
dependenciesFulfilled = null;
|
||
|
|
callback(); // can add another dependenciesFulfilled
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Module['removeRunDependency'] = removeRunDependency;
|
||
|
|
|
||
|
|
Module["preloadedImages"] = {}; // maps url to image data
|
||
|
|
Module["preloadedAudios"] = {}; // maps url to audio data
|
||
|
|
|
||
|
|
|
||
|
|
var memoryInitializer = null;
|
||
|
|
|
||
|
|
// === Body ===
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
STATIC_BASE = 8;
|
||
|
|
|
||
|
|
STATICTOP = STATIC_BASE + 504;
|
||
|
|
|
||
|
|
|
||
|
|
/* global initializers */ __ATINIT__.push({ func: function() { runPostSets() } });
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* memory initializer */ allocate([255,255,255,0,0,0,0,0], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
|
||
|
|
function runPostSets() {
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);
|
||
|
|
|
||
|
|
assert(tempDoublePtr % 8 == 0);
|
||
|
|
|
||
|
|
function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much
|
||
|
|
|
||
|
|
HEAP8[tempDoublePtr] = HEAP8[ptr];
|
||
|
|
|
||
|
|
HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
|
||
|
|
|
||
|
|
HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
|
||
|
|
|
||
|
|
HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
function copyTempDouble(ptr) {
|
||
|
|
|
||
|
|
HEAP8[tempDoublePtr] = HEAP8[ptr];
|
||
|
|
|
||
|
|
HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
|
||
|
|
|
||
|
|
HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
|
||
|
|
|
||
|
|
HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
|
||
|
|
|
||
|
|
HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];
|
||
|
|
|
||
|
|
HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];
|
||
|
|
|
||
|
|
HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];
|
||
|
|
|
||
|
|
HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
function _memset(ptr, value, num) {
|
||
|
|
ptr = ptr|0; value = value|0; num = num|0;
|
||
|
|
var stop = 0, value4 = 0, stop4 = 0, unaligned = 0;
|
||
|
|
stop = (ptr + num)|0;
|
||
|
|
if ((num|0) >= 20) {
|
||
|
|
// This is unaligned, but quite large, so work hard to get to aligned settings
|
||
|
|
value = value & 0xff;
|
||
|
|
unaligned = ptr & 3;
|
||
|
|
value4 = value | (value << 8) | (value << 16) | (value << 24);
|
||
|
|
stop4 = stop & ~3;
|
||
|
|
if (unaligned) {
|
||
|
|
unaligned = (ptr + 4 - unaligned)|0;
|
||
|
|
while ((ptr|0) < (unaligned|0)) { // no need to check for stop, since we have large num
|
||
|
|
HEAP8[(ptr)]=value;
|
||
|
|
ptr = (ptr+1)|0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
while ((ptr|0) < (stop4|0)) {
|
||
|
|
HEAP32[((ptr)>>2)]=value4;
|
||
|
|
ptr = (ptr+4)|0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
while ((ptr|0) < (stop|0)) {
|
||
|
|
HEAP8[(ptr)]=value;
|
||
|
|
ptr = (ptr+1)|0;
|
||
|
|
}
|
||
|
|
return (ptr-num)|0;
|
||
|
|
}var _llvm_memset_p0i8_i32=_memset;
|
||
|
|
|
||
|
|
|
||
|
|
function _memcpy(dest, src, num) {
|
||
|
|
dest = dest|0; src = src|0; num = num|0;
|
||
|
|
var ret = 0;
|
||
|
|
ret = dest|0;
|
||
|
|
if ((dest&3) == (src&3)) {
|
||
|
|
while (dest & 3) {
|
||
|
|
if ((num|0) == 0) return ret|0;
|
||
|
|
HEAP8[(dest)]=HEAP8[(src)];
|
||
|
|
dest = (dest+1)|0;
|
||
|
|
src = (src+1)|0;
|
||
|
|
num = (num-1)|0;
|
||
|
|
}
|
||
|
|
while ((num|0) >= 4) {
|
||
|
|
HEAP32[((dest)>>2)]=HEAP32[((src)>>2)];
|
||
|
|
dest = (dest+4)|0;
|
||
|
|
src = (src+4)|0;
|
||
|
|
num = (num-4)|0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
while ((num|0) > 0) {
|
||
|
|
HEAP8[(dest)]=HEAP8[(src)];
|
||
|
|
dest = (dest+1)|0;
|
||
|
|
src = (src+1)|0;
|
||
|
|
num = (num-1)|0;
|
||
|
|
}
|
||
|
|
return ret|0;
|
||
|
|
}var _llvm_memcpy_p0i8_p0i8_i32=_memcpy;
|
||
|
|
|
||
|
|
function _abort() {
|
||
|
|
Module['abort']();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
var ___errno_state=0;function ___setErrNo(value) {
|
||
|
|
// For convenient setting and returning of errno.
|
||
|
|
HEAP32[((___errno_state)>>2)]=value;
|
||
|
|
return value;
|
||
|
|
}function ___errno_location() {
|
||
|
|
return ___errno_state;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _sbrk(bytes) {
|
||
|
|
// Implement a Linux-like 'memory area' for our 'process'.
|
||
|
|
// Changes the size of the memory area by |bytes|; returns the
|
||
|
|
// address of the previous top ('break') of the memory area
|
||
|
|
// We control the "dynamic" memory - DYNAMIC_BASE to DYNAMICTOP
|
||
|
|
var self = _sbrk;
|
||
|
|
if (!self.called) {
|
||
|
|
DYNAMICTOP = alignMemoryPage(DYNAMICTOP); // make sure we start out aligned
|
||
|
|
self.called = true;
|
||
|
|
assert(Runtime.dynamicAlloc);
|
||
|
|
self.alloc = Runtime.dynamicAlloc;
|
||
|
|
Runtime.dynamicAlloc = function() { abort('cannot dynamically allocate, sbrk now has control') };
|
||
|
|
}
|
||
|
|
var ret = DYNAMICTOP;
|
||
|
|
if (bytes != 0) self.alloc(bytes);
|
||
|
|
return ret; // Previous break location.
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};function _sysconf(name) {
|
||
|
|
// long sysconf(int name);
|
||
|
|
// http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html
|
||
|
|
switch(name) {
|
||
|
|
case 30: return PAGE_SIZE;
|
||
|
|
case 132:
|
||
|
|
case 133:
|
||
|
|
case 12:
|
||
|
|
case 137:
|
||
|
|
case 138:
|
||
|
|
case 15:
|
||
|
|
case 235:
|
||
|
|
case 16:
|
||
|
|
case 17:
|
||
|
|
case 18:
|
||
|
|
case 19:
|
||
|
|
case 20:
|
||
|
|
case 149:
|
||
|
|
case 13:
|
||
|
|
case 10:
|
||
|
|
case 236:
|
||
|
|
case 153:
|
||
|
|
case 9:
|
||
|
|
case 21:
|
||
|
|
case 22:
|
||
|
|
case 159:
|
||
|
|
case 154:
|
||
|
|
case 14:
|
||
|
|
case 77:
|
||
|
|
case 78:
|
||
|
|
case 139:
|
||
|
|
case 80:
|
||
|
|
case 81:
|
||
|
|
case 79:
|
||
|
|
case 82:
|
||
|
|
case 68:
|
||
|
|
case 67:
|
||
|
|
case 164:
|
||
|
|
case 11:
|
||
|
|
case 29:
|
||
|
|
case 47:
|
||
|
|
case 48:
|
||
|
|
case 95:
|
||
|
|
case 52:
|
||
|
|
case 51:
|
||
|
|
case 46:
|
||
|
|
return 200809;
|
||
|
|
case 27:
|
||
|
|
case 246:
|
||
|
|
case 127:
|
||
|
|
case 128:
|
||
|
|
case 23:
|
||
|
|
case 24:
|
||
|
|
case 160:
|
||
|
|
case 161:
|
||
|
|
case 181:
|
||
|
|
case 182:
|
||
|
|
case 242:
|
||
|
|
case 183:
|
||
|
|
case 184:
|
||
|
|
case 243:
|
||
|
|
case 244:
|
||
|
|
case 245:
|
||
|
|
case 165:
|
||
|
|
case 178:
|
||
|
|
case 179:
|
||
|
|
case 49:
|
||
|
|
case 50:
|
||
|
|
case 168:
|
||
|
|
case 169:
|
||
|
|
case 175:
|
||
|
|
case 170:
|
||
|
|
case 171:
|
||
|
|
case 172:
|
||
|
|
case 97:
|
||
|
|
case 76:
|
||
|
|
case 32:
|
||
|
|
case 173:
|
||
|
|
case 35:
|
||
|
|
return -1;
|
||
|
|
case 176:
|
||
|
|
case 177:
|
||
|
|
case 7:
|
||
|
|
case 155:
|
||
|
|
case 8:
|
||
|
|
case 157:
|
||
|
|
case 125:
|
||
|
|
case 126:
|
||
|
|
case 92:
|
||
|
|
case 93:
|
||
|
|
case 129:
|
||
|
|
case 130:
|
||
|
|
case 131:
|
||
|
|
case 94:
|
||
|
|
case 91:
|
||
|
|
return 1;
|
||
|
|
case 74:
|
||
|
|
case 60:
|
||
|
|
case 69:
|
||
|
|
case 70:
|
||
|
|
case 4:
|
||
|
|
return 1024;
|
||
|
|
case 31:
|
||
|
|
case 42:
|
||
|
|
case 72:
|
||
|
|
return 32;
|
||
|
|
case 87:
|
||
|
|
case 26:
|
||
|
|
case 33:
|
||
|
|
return 2147483647;
|
||
|
|
case 34:
|
||
|
|
case 1:
|
||
|
|
return 47839;
|
||
|
|
case 38:
|
||
|
|
case 36:
|
||
|
|
return 99;
|
||
|
|
case 43:
|
||
|
|
case 37:
|
||
|
|
return 2048;
|
||
|
|
case 0: return 2097152;
|
||
|
|
case 3: return 65536;
|
||
|
|
case 28: return 32768;
|
||
|
|
case 44: return 32767;
|
||
|
|
case 75: return 16384;
|
||
|
|
case 39: return 1000;
|
||
|
|
case 89: return 700;
|
||
|
|
case 71: return 256;
|
||
|
|
case 40: return 255;
|
||
|
|
case 2: return 100;
|
||
|
|
case 180: return 64;
|
||
|
|
case 25: return 20;
|
||
|
|
case 5: return 16;
|
||
|
|
case 6: return 6;
|
||
|
|
case 73: return 4;
|
||
|
|
case 84: return 1;
|
||
|
|
}
|
||
|
|
___setErrNo(ERRNO_CODES.EINVAL);
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _time(ptr) {
|
||
|
|
var ret = Math.floor(Date.now()/1000);
|
||
|
|
if (ptr) {
|
||
|
|
HEAP32[((ptr)>>2)]=ret;
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
function _strlen(ptr) {
|
||
|
|
ptr = ptr|0;
|
||
|
|
var curr = 0;
|
||
|
|
curr = ptr;
|
||
|
|
while (HEAP8[(curr)]) {
|
||
|
|
curr = (curr + 1)|0;
|
||
|
|
}
|
||
|
|
return (curr - ptr)|0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"Cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Not a typewriter",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read only file system",31:"Too many links",32:"Broken pipe",33:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"};
|
||
|
|
|
||
|
|
var TTY={ttys:[],init:function () {
|
||
|
|
// https://github.com/kripken/emscripten/pull/1555
|
||
|
|
// if (ENVIRONMENT_IS_NODE) {
|
||
|
|
// // currently, FS.init does not distinguish if process.stdin is a file or TTY
|
||
|
|
// // device, it always assumes it's a TTY device. because of this, we're forcing
|
||
|
|
// // process.stdin to UTF8 encoding to at least make stdin reading compatible
|
||
|
|
// // with text files until FS.init can be refactored.
|
||
|
|
// process['stdin']['setEncoding']('utf8');
|
||
|
|
// }
|
||
|
|
},shutdown:function () {
|
||
|
|
// https://github.com/kripken/emscripten/pull/1555
|
||
|
|
// if (ENVIRONMENT_IS_NODE) {
|
||
|
|
// // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
|
||
|
|
// // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
|
||
|
|
// // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
|
||
|
|
// // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
|
||
|
|
// // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
|
||
|
|
// process['stdin']['pause']();
|
||
|
|
// }
|
||
|
|
},register:function (dev, ops) {
|
||
|
|
TTY.ttys[dev] = { input: [], output: [], ops: ops };
|
||
|
|
FS.registerDevice(dev, TTY.stream_ops);
|
||
|
|
},stream_ops:{open:function (stream) {
|
||
|
|
var tty = TTY.ttys[stream.node.rdev];
|
||
|
|
if (!tty) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
|
||
|
|
}
|
||
|
|
stream.tty = tty;
|
||
|
|
stream.seekable = false;
|
||
|
|
},close:function (stream) {
|
||
|
|
// flush any pending line data
|
||
|
|
if (stream.tty.output.length) {
|
||
|
|
stream.tty.ops.put_char(stream.tty, 10);
|
||
|
|
}
|
||
|
|
},read:function (stream, buffer, offset, length, pos /* ignored */) {
|
||
|
|
if (!stream.tty || !stream.tty.ops.get_char) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
|
||
|
|
}
|
||
|
|
var bytesRead = 0;
|
||
|
|
for (var i = 0; i < length; i++) {
|
||
|
|
var result;
|
||
|
|
try {
|
||
|
|
result = stream.tty.ops.get_char(stream.tty);
|
||
|
|
} catch (e) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EIO);
|
||
|
|
}
|
||
|
|
if (result === undefined && bytesRead === 0) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
|
||
|
|
}
|
||
|
|
if (result === null || result === undefined) break;
|
||
|
|
bytesRead++;
|
||
|
|
buffer[offset+i] = result;
|
||
|
|
}
|
||
|
|
if (bytesRead) {
|
||
|
|
stream.node.timestamp = Date.now();
|
||
|
|
}
|
||
|
|
return bytesRead;
|
||
|
|
},write:function (stream, buffer, offset, length, pos) {
|
||
|
|
if (!stream.tty || !stream.tty.ops.put_char) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
|
||
|
|
}
|
||
|
|
for (var i = 0; i < length; i++) {
|
||
|
|
try {
|
||
|
|
stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
|
||
|
|
} catch (e) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EIO);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (length) {
|
||
|
|
stream.node.timestamp = Date.now();
|
||
|
|
}
|
||
|
|
return i;
|
||
|
|
}},default_tty_ops:{get_char:function (tty) {
|
||
|
|
if (!tty.input.length) {
|
||
|
|
var result = null;
|
||
|
|
if (ENVIRONMENT_IS_NODE) {
|
||
|
|
result = process['stdin']['read']();
|
||
|
|
if (!result) {
|
||
|
|
if (process['stdin']['_readableState'] && process['stdin']['_readableState']['ended']) {
|
||
|
|
return null; // EOF
|
||
|
|
}
|
||
|
|
return undefined; // no data available
|
||
|
|
}
|
||
|
|
} else if (typeof window != 'undefined' &&
|
||
|
|
typeof window.prompt == 'function') {
|
||
|
|
// Browser.
|
||
|
|
result = window.prompt('Input: '); // returns null on cancel
|
||
|
|
if (result !== null) {
|
||
|
|
result += '\n';
|
||
|
|
}
|
||
|
|
} else if (typeof readline == 'function') {
|
||
|
|
// Command line.
|
||
|
|
result = readline();
|
||
|
|
if (result !== null) {
|
||
|
|
result += '\n';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!result) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
tty.input = intArrayFromString(result, true);
|
||
|
|
}
|
||
|
|
return tty.input.shift();
|
||
|
|
},put_char:function (tty, val) {
|
||
|
|
if (val === null || val === 10) {
|
||
|
|
Module['print'](tty.output.join(''));
|
||
|
|
tty.output = [];
|
||
|
|
} else {
|
||
|
|
tty.output.push(TTY.utf8.processCChar(val));
|
||
|
|
}
|
||
|
|
}},default_tty1_ops:{put_char:function (tty, val) {
|
||
|
|
if (val === null || val === 10) {
|
||
|
|
Module['printErr'](tty.output.join(''));
|
||
|
|
tty.output = [];
|
||
|
|
} else {
|
||
|
|
tty.output.push(TTY.utf8.processCChar(val));
|
||
|
|
}
|
||
|
|
}}};
|
||
|
|
|
||
|
|
var MEMFS={ops_table:null,CONTENT_OWNING:1,CONTENT_FLEXIBLE:2,CONTENT_FIXED:3,mount:function (mount) {
|
||
|
|
return MEMFS.createNode(null, '/', 16384 | 0777, 0);
|
||
|
|
},createNode:function (parent, name, mode, dev) {
|
||
|
|
if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
|
||
|
|
// no supported
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
|
||
|
|
}
|
||
|
|
if (!MEMFS.ops_table) {
|
||
|
|
MEMFS.ops_table = {
|
||
|
|
dir: {
|
||
|
|
node: {
|
||
|
|
getattr: MEMFS.node_ops.getattr,
|
||
|
|
setattr: MEMFS.node_ops.setattr,
|
||
|
|
lookup: MEMFS.node_ops.lookup,
|
||
|
|
mknod: MEMFS.node_ops.mknod,
|
||
|
|
mknod: MEMFS.node_ops.mknod,
|
||
|
|
rename: MEMFS.node_ops.rename,
|
||
|
|
unlink: MEMFS.node_ops.unlink,
|
||
|
|
rmdir: MEMFS.node_ops.rmdir,
|
||
|
|
readdir: MEMFS.node_ops.readdir,
|
||
|
|
symlink: MEMFS.node_ops.symlink
|
||
|
|
},
|
||
|
|
stream: {
|
||
|
|
llseek: MEMFS.stream_ops.llseek
|
||
|
|
}
|
||
|
|
},
|
||
|
|
file: {
|
||
|
|
node: {
|
||
|
|
getattr: MEMFS.node_ops.getattr,
|
||
|
|
setattr: MEMFS.node_ops.setattr
|
||
|
|
},
|
||
|
|
stream: {
|
||
|
|
llseek: MEMFS.stream_ops.llseek,
|
||
|
|
read: MEMFS.stream_ops.read,
|
||
|
|
write: MEMFS.stream_ops.write,
|
||
|
|
allocate: MEMFS.stream_ops.allocate,
|
||
|
|
mmap: MEMFS.stream_ops.mmap
|
||
|
|
}
|
||
|
|
},
|
||
|
|
link: {
|
||
|
|
node: {
|
||
|
|
getattr: MEMFS.node_ops.getattr,
|
||
|
|
setattr: MEMFS.node_ops.setattr,
|
||
|
|
readlink: MEMFS.node_ops.readlink
|
||
|
|
},
|
||
|
|
stream: {}
|
||
|
|
},
|
||
|
|
chrdev: {
|
||
|
|
node: {
|
||
|
|
getattr: MEMFS.node_ops.getattr,
|
||
|
|
setattr: MEMFS.node_ops.setattr
|
||
|
|
},
|
||
|
|
stream: FS.chrdev_stream_ops
|
||
|
|
},
|
||
|
|
};
|
||
|
|
}
|
||
|
|
var node = FS.createNode(parent, name, mode, dev);
|
||
|
|
if (FS.isDir(node.mode)) {
|
||
|
|
node.node_ops = MEMFS.ops_table.dir.node;
|
||
|
|
node.stream_ops = MEMFS.ops_table.dir.stream;
|
||
|
|
node.contents = {};
|
||
|
|
} else if (FS.isFile(node.mode)) {
|
||
|
|
node.node_ops = MEMFS.ops_table.file.node;
|
||
|
|
node.stream_ops = MEMFS.ops_table.file.stream;
|
||
|
|
node.contents = [];
|
||
|
|
node.contentMode = MEMFS.CONTENT_FLEXIBLE;
|
||
|
|
} else if (FS.isLink(node.mode)) {
|
||
|
|
node.node_ops = MEMFS.ops_table.link.node;
|
||
|
|
node.stream_ops = MEMFS.ops_table.link.stream;
|
||
|
|
} else if (FS.isChrdev(node.mode)) {
|
||
|
|
node.node_ops = MEMFS.ops_table.chrdev.node;
|
||
|
|
node.stream_ops = MEMFS.ops_table.chrdev.stream;
|
||
|
|
}
|
||
|
|
node.timestamp = Date.now();
|
||
|
|
// add the new node to the parent
|
||
|
|
if (parent) {
|
||
|
|
parent.contents[name] = node;
|
||
|
|
}
|
||
|
|
return node;
|
||
|
|
},ensureFlexible:function (node) {
|
||
|
|
if (node.contentMode !== MEMFS.CONTENT_FLEXIBLE) {
|
||
|
|
var contents = node.contents;
|
||
|
|
node.contents = Array.prototype.slice.call(contents);
|
||
|
|
node.contentMode = MEMFS.CONTENT_FLEXIBLE;
|
||
|
|
}
|
||
|
|
},node_ops:{getattr:function (node) {
|
||
|
|
var attr = {};
|
||
|
|
// device numbers reuse inode numbers.
|
||
|
|
attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
|
||
|
|
attr.ino = node.id;
|
||
|
|
attr.mode = node.mode;
|
||
|
|
attr.nlink = 1;
|
||
|
|
attr.uid = 0;
|
||
|
|
attr.gid = 0;
|
||
|
|
attr.rdev = node.rdev;
|
||
|
|
if (FS.isDir(node.mode)) {
|
||
|
|
attr.size = 4096;
|
||
|
|
} else if (FS.isFile(node.mode)) {
|
||
|
|
attr.size = node.contents.length;
|
||
|
|
} else if (FS.isLink(node.mode)) {
|
||
|
|
attr.size = node.link.length;
|
||
|
|
} else {
|
||
|
|
attr.size = 0;
|
||
|
|
}
|
||
|
|
attr.atime = new Date(node.timestamp);
|
||
|
|
attr.mtime = new Date(node.timestamp);
|
||
|
|
attr.ctime = new Date(node.timestamp);
|
||
|
|
// NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
|
||
|
|
// but this is not required by the standard.
|
||
|
|
attr.blksize = 4096;
|
||
|
|
attr.blocks = Math.ceil(attr.size / attr.blksize);
|
||
|
|
return attr;
|
||
|
|
},setattr:function (node, attr) {
|
||
|
|
if (attr.mode !== undefined) {
|
||
|
|
node.mode = attr.mode;
|
||
|
|
}
|
||
|
|
if (attr.timestamp !== undefined) {
|
||
|
|
node.timestamp = attr.timestamp;
|
||
|
|
}
|
||
|
|
if (attr.size !== undefined) {
|
||
|
|
MEMFS.ensureFlexible(node);
|
||
|
|
var contents = node.contents;
|
||
|
|
if (attr.size < contents.length) contents.length = attr.size;
|
||
|
|
else while (attr.size > contents.length) contents.push(0);
|
||
|
|
}
|
||
|
|
},lookup:function (parent, name) {
|
||
|
|
throw FS.genericErrors[ERRNO_CODES.ENOENT];
|
||
|
|
},mknod:function (parent, name, mode, dev) {
|
||
|
|
return MEMFS.createNode(parent, name, mode, dev);
|
||
|
|
},rename:function (old_node, new_dir, new_name) {
|
||
|
|
// if we're overwriting a directory at new_name, make sure it's empty.
|
||
|
|
if (FS.isDir(old_node.mode)) {
|
||
|
|
var new_node;
|
||
|
|
try {
|
||
|
|
new_node = FS.lookupNode(new_dir, new_name);
|
||
|
|
} catch (e) {
|
||
|
|
}
|
||
|
|
if (new_node) {
|
||
|
|
for (var i in new_node.contents) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// do the internal rewiring
|
||
|
|
delete old_node.parent.contents[old_node.name];
|
||
|
|
old_node.name = new_name;
|
||
|
|
new_dir.contents[new_name] = old_node;
|
||
|
|
old_node.parent = new_dir;
|
||
|
|
},unlink:function (parent, name) {
|
||
|
|
delete parent.contents[name];
|
||
|
|
},rmdir:function (parent, name) {
|
||
|
|
var node = FS.lookupNode(parent, name);
|
||
|
|
for (var i in node.contents) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
|
||
|
|
}
|
||
|
|
delete parent.contents[name];
|
||
|
|
},readdir:function (node) {
|
||
|
|
var entries = ['.', '..']
|
||
|
|
for (var key in node.contents) {
|
||
|
|
if (!node.contents.hasOwnProperty(key)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
entries.push(key);
|
||
|
|
}
|
||
|
|
return entries;
|
||
|
|
},symlink:function (parent, newname, oldpath) {
|
||
|
|
var node = MEMFS.createNode(parent, newname, 0777 | 40960, 0);
|
||
|
|
node.link = oldpath;
|
||
|
|
return node;
|
||
|
|
},readlink:function (node) {
|
||
|
|
if (!FS.isLink(node.mode)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
return node.link;
|
||
|
|
}},stream_ops:{read:function (stream, buffer, offset, length, position) {
|
||
|
|
var contents = stream.node.contents;
|
||
|
|
if (position >= contents.length)
|
||
|
|
return 0;
|
||
|
|
var size = Math.min(contents.length - position, length);
|
||
|
|
assert(size >= 0);
|
||
|
|
if (size > 8 && contents.subarray) { // non-trivial, and typed array
|
||
|
|
buffer.set(contents.subarray(position, position + size), offset);
|
||
|
|
} else
|
||
|
|
{
|
||
|
|
for (var i = 0; i < size; i++) {
|
||
|
|
buffer[offset + i] = contents[position + i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return size;
|
||
|
|
},write:function (stream, buffer, offset, length, position, canOwn) {
|
||
|
|
var node = stream.node;
|
||
|
|
node.timestamp = Date.now();
|
||
|
|
var contents = node.contents;
|
||
|
|
if (length && contents.length === 0 && position === 0 && buffer.subarray) {
|
||
|
|
// just replace it with the new data
|
||
|
|
assert(buffer.length);
|
||
|
|
if (canOwn && offset === 0) {
|
||
|
|
node.contents = buffer; // this could be a subarray of Emscripten HEAP, or allocated from some other source.
|
||
|
|
node.contentMode = (buffer.buffer === HEAP8.buffer) ? MEMFS.CONTENT_OWNING : MEMFS.CONTENT_FIXED;
|
||
|
|
} else {
|
||
|
|
node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
|
||
|
|
node.contentMode = MEMFS.CONTENT_FIXED;
|
||
|
|
}
|
||
|
|
return length;
|
||
|
|
}
|
||
|
|
MEMFS.ensureFlexible(node);
|
||
|
|
var contents = node.contents;
|
||
|
|
while (contents.length < position) contents.push(0);
|
||
|
|
for (var i = 0; i < length; i++) {
|
||
|
|
contents[position + i] = buffer[offset + i];
|
||
|
|
}
|
||
|
|
return length;
|
||
|
|
},llseek:function (stream, offset, whence) {
|
||
|
|
var position = offset;
|
||
|
|
if (whence === 1) { // SEEK_CUR.
|
||
|
|
position += stream.position;
|
||
|
|
} else if (whence === 2) { // SEEK_END.
|
||
|
|
if (FS.isFile(stream.node.mode)) {
|
||
|
|
position += stream.node.contents.length;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (position < 0) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
stream.ungotten = [];
|
||
|
|
stream.position = position;
|
||
|
|
return position;
|
||
|
|
},allocate:function (stream, offset, length) {
|
||
|
|
MEMFS.ensureFlexible(stream.node);
|
||
|
|
var contents = stream.node.contents;
|
||
|
|
var limit = offset + length;
|
||
|
|
while (limit > contents.length) contents.push(0);
|
||
|
|
},mmap:function (stream, buffer, offset, length, position, prot, flags) {
|
||
|
|
if (!FS.isFile(stream.node.mode)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
|
||
|
|
}
|
||
|
|
var ptr;
|
||
|
|
var allocated;
|
||
|
|
var contents = stream.node.contents;
|
||
|
|
// Only make a new copy when MAP_PRIVATE is specified.
|
||
|
|
if ( !(flags & 2) &&
|
||
|
|
(contents.buffer === buffer || contents.buffer === buffer.buffer) ) {
|
||
|
|
// We can't emulate MAP_SHARED when the file is not backed by the buffer
|
||
|
|
// we're mapping to (e.g. the HEAP buffer).
|
||
|
|
allocated = false;
|
||
|
|
ptr = contents.byteOffset;
|
||
|
|
} else {
|
||
|
|
// Try to avoid unnecessary slices.
|
||
|
|
if (position > 0 || position + length < contents.length) {
|
||
|
|
if (contents.subarray) {
|
||
|
|
contents = contents.subarray(position, position + length);
|
||
|
|
} else {
|
||
|
|
contents = Array.prototype.slice.call(contents, position, position + length);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
allocated = true;
|
||
|
|
ptr = _malloc(length);
|
||
|
|
if (!ptr) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
|
||
|
|
}
|
||
|
|
buffer.set(contents, ptr);
|
||
|
|
}
|
||
|
|
return { ptr: ptr, allocated: allocated };
|
||
|
|
}}};
|
||
|
|
|
||
|
|
var IDBFS={dbs:{},indexedDB:function () {
|
||
|
|
return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
|
||
|
|
},DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",mount:function (mount) {
|
||
|
|
return MEMFS.mount.apply(null, arguments);
|
||
|
|
},syncfs:function (mount, populate, callback) {
|
||
|
|
IDBFS.getLocalSet(mount, function(err, local) {
|
||
|
|
if (err) return callback(err);
|
||
|
|
|
||
|
|
IDBFS.getRemoteSet(mount, function(err, remote) {
|
||
|
|
if (err) return callback(err);
|
||
|
|
|
||
|
|
var src = populate ? remote : local;
|
||
|
|
var dst = populate ? local : remote;
|
||
|
|
|
||
|
|
IDBFS.reconcile(src, dst, callback);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
},reconcile:function (src, dst, callback) {
|
||
|
|
var total = 0;
|
||
|
|
|
||
|
|
var create = {};
|
||
|
|
for (var key in src.files) {
|
||
|
|
if (!src.files.hasOwnProperty(key)) continue;
|
||
|
|
var e = src.files[key];
|
||
|
|
var e2 = dst.files[key];
|
||
|
|
if (!e2 || e.timestamp > e2.timestamp) {
|
||
|
|
create[key] = e;
|
||
|
|
total++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var remove = {};
|
||
|
|
for (var key in dst.files) {
|
||
|
|
if (!dst.files.hasOwnProperty(key)) continue;
|
||
|
|
var e = dst.files[key];
|
||
|
|
var e2 = src.files[key];
|
||
|
|
if (!e2) {
|
||
|
|
remove[key] = e;
|
||
|
|
total++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!total) {
|
||
|
|
// early out
|
||
|
|
return callback(null);
|
||
|
|
}
|
||
|
|
|
||
|
|
var completed = 0;
|
||
|
|
function done(err) {
|
||
|
|
if (err) return callback(err);
|
||
|
|
if (++completed >= total) {
|
||
|
|
return callback(null);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
// create a single transaction to handle and IDB reads / writes we'll need to do
|
||
|
|
var db = src.type === 'remote' ? src.db : dst.db;
|
||
|
|
var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
|
||
|
|
transaction.onerror = function transaction_onerror() { callback(this.error); };
|
||
|
|
var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
|
||
|
|
|
||
|
|
for (var path in create) {
|
||
|
|
if (!create.hasOwnProperty(path)) continue;
|
||
|
|
var entry = create[path];
|
||
|
|
|
||
|
|
if (dst.type === 'local') {
|
||
|
|
// save file to local
|
||
|
|
try {
|
||
|
|
if (FS.isDir(entry.mode)) {
|
||
|
|
FS.mkdir(path, entry.mode);
|
||
|
|
} else if (FS.isFile(entry.mode)) {
|
||
|
|
var stream = FS.open(path, 'w+', 0666);
|
||
|
|
FS.write(stream, entry.contents, 0, entry.contents.length, 0, true /* canOwn */);
|
||
|
|
FS.close(stream);
|
||
|
|
}
|
||
|
|
done(null);
|
||
|
|
} catch (e) {
|
||
|
|
return done(e);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// save file to IDB
|
||
|
|
var req = store.put(entry, path);
|
||
|
|
req.onsuccess = function req_onsuccess() { done(null); };
|
||
|
|
req.onerror = function req_onerror() { done(this.error); };
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (var path in remove) {
|
||
|
|
if (!remove.hasOwnProperty(path)) continue;
|
||
|
|
var entry = remove[path];
|
||
|
|
|
||
|
|
if (dst.type === 'local') {
|
||
|
|
// delete file from local
|
||
|
|
try {
|
||
|
|
if (FS.isDir(entry.mode)) {
|
||
|
|
// TODO recursive delete?
|
||
|
|
FS.rmdir(path);
|
||
|
|
} else if (FS.isFile(entry.mode)) {
|
||
|
|
FS.unlink(path);
|
||
|
|
}
|
||
|
|
done(null);
|
||
|
|
} catch (e) {
|
||
|
|
return done(e);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// delete file from IDB
|
||
|
|
var req = store.delete(path);
|
||
|
|
req.onsuccess = function req_onsuccess() { done(null); };
|
||
|
|
req.onerror = function req_onerror() { done(this.error); };
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},getLocalSet:function (mount, callback) {
|
||
|
|
var files = {};
|
||
|
|
|
||
|
|
function isRealDir(p) {
|
||
|
|
return p !== '.' && p !== '..';
|
||
|
|
};
|
||
|
|
function toAbsolute(root) {
|
||
|
|
return function(p) {
|
||
|
|
return PATH.join2(root, p);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var check = FS.readdir(mount.mountpoint)
|
||
|
|
.filter(isRealDir)
|
||
|
|
.map(toAbsolute(mount.mountpoint));
|
||
|
|
|
||
|
|
while (check.length) {
|
||
|
|
var path = check.pop();
|
||
|
|
var stat, node;
|
||
|
|
|
||
|
|
try {
|
||
|
|
var lookup = FS.lookupPath(path);
|
||
|
|
node = lookup.node;
|
||
|
|
stat = FS.stat(path);
|
||
|
|
} catch (e) {
|
||
|
|
return callback(e);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FS.isDir(stat.mode)) {
|
||
|
|
check.push.apply(check, FS.readdir(path)
|
||
|
|
.filter(isRealDir)
|
||
|
|
.map(toAbsolute(path)));
|
||
|
|
|
||
|
|
files[path] = { mode: stat.mode, timestamp: stat.mtime };
|
||
|
|
} else if (FS.isFile(stat.mode)) {
|
||
|
|
files[path] = { contents: node.contents, mode: stat.mode, timestamp: stat.mtime };
|
||
|
|
} else {
|
||
|
|
return callback(new Error('node type not supported'));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return callback(null, { type: 'local', files: files });
|
||
|
|
},getDB:function (name, callback) {
|
||
|
|
// look it up in the cache
|
||
|
|
var db = IDBFS.dbs[name];
|
||
|
|
if (db) {
|
||
|
|
return callback(null, db);
|
||
|
|
}
|
||
|
|
var req;
|
||
|
|
try {
|
||
|
|
req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
|
||
|
|
} catch (e) {
|
||
|
|
return onerror(e);
|
||
|
|
}
|
||
|
|
req.onupgradeneeded = function req_onupgradeneeded() {
|
||
|
|
db = req.result;
|
||
|
|
db.createObjectStore(IDBFS.DB_STORE_NAME);
|
||
|
|
};
|
||
|
|
req.onsuccess = function req_onsuccess() {
|
||
|
|
db = req.result;
|
||
|
|
// add to the cache
|
||
|
|
IDBFS.dbs[name] = db;
|
||
|
|
callback(null, db);
|
||
|
|
};
|
||
|
|
req.onerror = function req_onerror() {
|
||
|
|
callback(this.error);
|
||
|
|
};
|
||
|
|
},getRemoteSet:function (mount, callback) {
|
||
|
|
var files = {};
|
||
|
|
|
||
|
|
IDBFS.getDB(mount.mountpoint, function(err, db) {
|
||
|
|
if (err) return callback(err);
|
||
|
|
|
||
|
|
var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
|
||
|
|
transaction.onerror = function transaction_onerror() { callback(this.error); };
|
||
|
|
|
||
|
|
var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
|
||
|
|
store.openCursor().onsuccess = function store_openCursor_onsuccess(event) {
|
||
|
|
var cursor = event.target.result;
|
||
|
|
if (!cursor) {
|
||
|
|
return callback(null, { type: 'remote', db: db, files: files });
|
||
|
|
}
|
||
|
|
|
||
|
|
files[cursor.key] = cursor.value;
|
||
|
|
cursor.continue();
|
||
|
|
};
|
||
|
|
});
|
||
|
|
}};
|
||
|
|
|
||
|
|
var NODEFS={isWindows:false,staticInit:function () {
|
||
|
|
NODEFS.isWindows = !!process.platform.match(/^win/);
|
||
|
|
},mount:function (mount) {
|
||
|
|
assert(ENVIRONMENT_IS_NODE);
|
||
|
|
return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
|
||
|
|
},createNode:function (parent, name, mode, dev) {
|
||
|
|
if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
var node = FS.createNode(parent, name, mode);
|
||
|
|
node.node_ops = NODEFS.node_ops;
|
||
|
|
node.stream_ops = NODEFS.stream_ops;
|
||
|
|
return node;
|
||
|
|
},getMode:function (path) {
|
||
|
|
var stat;
|
||
|
|
try {
|
||
|
|
stat = fs.lstatSync(path);
|
||
|
|
if (NODEFS.isWindows) {
|
||
|
|
// On Windows, directories return permission bits 'rw-rw-rw-', even though they have 'rwxrwxrwx', so
|
||
|
|
// propagate write bits to execute bits.
|
||
|
|
stat.mode = stat.mode | ((stat.mode & 146) >> 1);
|
||
|
|
}
|
||
|
|
} catch (e) {
|
||
|
|
if (!e.code) throw e;
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
return stat.mode;
|
||
|
|
},realPath:function (node) {
|
||
|
|
var parts = [];
|
||
|
|
while (node.parent !== node) {
|
||
|
|
parts.push(node.name);
|
||
|
|
node = node.parent;
|
||
|
|
}
|
||
|
|
parts.push(node.mount.opts.root);
|
||
|
|
parts.reverse();
|
||
|
|
return PATH.join.apply(null, parts);
|
||
|
|
},flagsToPermissionStringMap:{0:"r",1:"r+",2:"r+",64:"r",65:"r+",66:"r+",129:"rx+",193:"rx+",514:"w+",577:"w",578:"w+",705:"wx",706:"wx+",1024:"a",1025:"a",1026:"a+",1089:"a",1090:"a+",1153:"ax",1154:"ax+",1217:"ax",1218:"ax+",4096:"rs",4098:"rs+"},flagsToPermissionString:function (flags) {
|
||
|
|
if (flags in NODEFS.flagsToPermissionStringMap) {
|
||
|
|
return NODEFS.flagsToPermissionStringMap[flags];
|
||
|
|
} else {
|
||
|
|
return flags;
|
||
|
|
}
|
||
|
|
},node_ops:{getattr:function (node) {
|
||
|
|
var path = NODEFS.realPath(node);
|
||
|
|
var stat;
|
||
|
|
try {
|
||
|
|
stat = fs.lstatSync(path);
|
||
|
|
} catch (e) {
|
||
|
|
if (!e.code) throw e;
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
// node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
|
||
|
|
// See http://support.microsoft.com/kb/140365
|
||
|
|
if (NODEFS.isWindows && !stat.blksize) {
|
||
|
|
stat.blksize = 4096;
|
||
|
|
}
|
||
|
|
if (NODEFS.isWindows && !stat.blocks) {
|
||
|
|
stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
|
||
|
|
}
|
||
|
|
return {
|
||
|
|
dev: stat.dev,
|
||
|
|
ino: stat.ino,
|
||
|
|
mode: stat.mode,
|
||
|
|
nlink: stat.nlink,
|
||
|
|
uid: stat.uid,
|
||
|
|
gid: stat.gid,
|
||
|
|
rdev: stat.rdev,
|
||
|
|
size: stat.size,
|
||
|
|
atime: stat.atime,
|
||
|
|
mtime: stat.mtime,
|
||
|
|
ctime: stat.ctime,
|
||
|
|
blksize: stat.blksize,
|
||
|
|
blocks: stat.blocks
|
||
|
|
};
|
||
|
|
},setattr:function (node, attr) {
|
||
|
|
var path = NODEFS.realPath(node);
|
||
|
|
try {
|
||
|
|
if (attr.mode !== undefined) {
|
||
|
|
fs.chmodSync(path, attr.mode);
|
||
|
|
// update the common node structure mode as well
|
||
|
|
node.mode = attr.mode;
|
||
|
|
}
|
||
|
|
if (attr.timestamp !== undefined) {
|
||
|
|
var date = new Date(attr.timestamp);
|
||
|
|
fs.utimesSync(path, date, date);
|
||
|
|
}
|
||
|
|
if (attr.size !== undefined) {
|
||
|
|
fs.truncateSync(path, attr.size);
|
||
|
|
}
|
||
|
|
} catch (e) {
|
||
|
|
if (!e.code) throw e;
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
},lookup:function (parent, name) {
|
||
|
|
var path = PATH.join2(NODEFS.realPath(parent), name);
|
||
|
|
var mode = NODEFS.getMode(path);
|
||
|
|
return NODEFS.createNode(parent, name, mode);
|
||
|
|
},mknod:function (parent, name, mode, dev) {
|
||
|
|
var node = NODEFS.createNode(parent, name, mode, dev);
|
||
|
|
// create the backing node for this in the fs root as well
|
||
|
|
var path = NODEFS.realPath(node);
|
||
|
|
try {
|
||
|
|
if (FS.isDir(node.mode)) {
|
||
|
|
fs.mkdirSync(path, node.mode);
|
||
|
|
} else {
|
||
|
|
fs.writeFileSync(path, '', { mode: node.mode });
|
||
|
|
}
|
||
|
|
} catch (e) {
|
||
|
|
if (!e.code) throw e;
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
return node;
|
||
|
|
},rename:function (oldNode, newDir, newName) {
|
||
|
|
var oldPath = NODEFS.realPath(oldNode);
|
||
|
|
var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
|
||
|
|
try {
|
||
|
|
fs.renameSync(oldPath, newPath);
|
||
|
|
} catch (e) {
|
||
|
|
if (!e.code) throw e;
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
},unlink:function (parent, name) {
|
||
|
|
var path = PATH.join2(NODEFS.realPath(parent), name);
|
||
|
|
try {
|
||
|
|
fs.unlinkSync(path);
|
||
|
|
} catch (e) {
|
||
|
|
if (!e.code) throw e;
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
},rmdir:function (parent, name) {
|
||
|
|
var path = PATH.join2(NODEFS.realPath(parent), name);
|
||
|
|
try {
|
||
|
|
fs.rmdirSync(path);
|
||
|
|
} catch (e) {
|
||
|
|
if (!e.code) throw e;
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
},readdir:function (node) {
|
||
|
|
var path = NODEFS.realPath(node);
|
||
|
|
try {
|
||
|
|
return fs.readdirSync(path);
|
||
|
|
} catch (e) {
|
||
|
|
if (!e.code) throw e;
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
},symlink:function (parent, newName, oldPath) {
|
||
|
|
var newPath = PATH.join2(NODEFS.realPath(parent), newName);
|
||
|
|
try {
|
||
|
|
fs.symlinkSync(oldPath, newPath);
|
||
|
|
} catch (e) {
|
||
|
|
if (!e.code) throw e;
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
},readlink:function (node) {
|
||
|
|
var path = NODEFS.realPath(node);
|
||
|
|
try {
|
||
|
|
return fs.readlinkSync(path);
|
||
|
|
} catch (e) {
|
||
|
|
if (!e.code) throw e;
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
}},stream_ops:{open:function (stream) {
|
||
|
|
var path = NODEFS.realPath(stream.node);
|
||
|
|
try {
|
||
|
|
if (FS.isFile(stream.node.mode)) {
|
||
|
|
stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
|
||
|
|
}
|
||
|
|
} catch (e) {
|
||
|
|
if (!e.code) throw e;
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
},close:function (stream) {
|
||
|
|
try {
|
||
|
|
if (FS.isFile(stream.node.mode) && stream.nfd) {
|
||
|
|
fs.closeSync(stream.nfd);
|
||
|
|
}
|
||
|
|
} catch (e) {
|
||
|
|
if (!e.code) throw e;
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
},read:function (stream, buffer, offset, length, position) {
|
||
|
|
// FIXME this is terrible.
|
||
|
|
var nbuffer = new Buffer(length);
|
||
|
|
var res;
|
||
|
|
try {
|
||
|
|
res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
|
||
|
|
} catch (e) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
if (res > 0) {
|
||
|
|
for (var i = 0; i < res; i++) {
|
||
|
|
buffer[offset + i] = nbuffer[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return res;
|
||
|
|
},write:function (stream, buffer, offset, length, position) {
|
||
|
|
// FIXME this is terrible.
|
||
|
|
var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
|
||
|
|
var res;
|
||
|
|
try {
|
||
|
|
res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
|
||
|
|
} catch (e) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
return res;
|
||
|
|
},llseek:function (stream, offset, whence) {
|
||
|
|
var position = offset;
|
||
|
|
if (whence === 1) { // SEEK_CUR.
|
||
|
|
position += stream.position;
|
||
|
|
} else if (whence === 2) { // SEEK_END.
|
||
|
|
if (FS.isFile(stream.node.mode)) {
|
||
|
|
try {
|
||
|
|
var stat = fs.fstatSync(stream.nfd);
|
||
|
|
position += stat.size;
|
||
|
|
} catch (e) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (position < 0) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
|
||
|
|
stream.position = position;
|
||
|
|
return position;
|
||
|
|
}}};
|
||
|
|
|
||
|
|
var _stdin=allocate(1, "i32*", ALLOC_STATIC);
|
||
|
|
|
||
|
|
var _stdout=allocate(1, "i32*", ALLOC_STATIC);
|
||
|
|
|
||
|
|
var _stderr=allocate(1, "i32*", ALLOC_STATIC);
|
||
|
|
|
||
|
|
function _fflush(stream) {
|
||
|
|
// int fflush(FILE *stream);
|
||
|
|
// http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html
|
||
|
|
// we don't currently perform any user-space buffering of data
|
||
|
|
}var FS={root:null,mounts:[],devices:[null],streams:[null],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
|
||
|
|
if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
|
||
|
|
return ___setErrNo(e.errno);
|
||
|
|
},lookupPath:function (path, opts) {
|
||
|
|
path = PATH.resolve(FS.cwd(), path);
|
||
|
|
opts = opts || { recurse_count: 0 };
|
||
|
|
|
||
|
|
if (opts.recurse_count > 8) { // max recursive lookup of 8
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
|
||
|
|
}
|
||
|
|
|
||
|
|
// split the path
|
||
|
|
var parts = PATH.normalizeArray(path.split('/').filter(function(p) {
|
||
|
|
return !!p;
|
||
|
|
}), false);
|
||
|
|
|
||
|
|
// start at the root
|
||
|
|
var current = FS.root;
|
||
|
|
var current_path = '/';
|
||
|
|
|
||
|
|
for (var i = 0; i < parts.length; i++) {
|
||
|
|
var islast = (i === parts.length-1);
|
||
|
|
if (islast && opts.parent) {
|
||
|
|
// stop resolving
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
current = FS.lookupNode(current, parts[i]);
|
||
|
|
current_path = PATH.join2(current_path, parts[i]);
|
||
|
|
|
||
|
|
// jump to the mount's root node if this is a mountpoint
|
||
|
|
if (FS.isMountpoint(current)) {
|
||
|
|
current = current.mount.root;
|
||
|
|
}
|
||
|
|
|
||
|
|
// follow symlinks
|
||
|
|
// by default, lookupPath will not follow a symlink if it is the final path component.
|
||
|
|
// setting opts.follow = true will override this behavior.
|
||
|
|
if (!islast || opts.follow) {
|
||
|
|
var count = 0;
|
||
|
|
while (FS.isLink(current.mode)) {
|
||
|
|
var link = FS.readlink(current_path);
|
||
|
|
current_path = PATH.resolve(PATH.dirname(current_path), link);
|
||
|
|
|
||
|
|
var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
|
||
|
|
current = lookup.node;
|
||
|
|
|
||
|
|
if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return { path: current_path, node: current };
|
||
|
|
},getPath:function (node) {
|
||
|
|
var path;
|
||
|
|
while (true) {
|
||
|
|
if (FS.isRoot(node)) {
|
||
|
|
var mount = node.mount.mountpoint;
|
||
|
|
if (!path) return mount;
|
||
|
|
return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
|
||
|
|
}
|
||
|
|
path = path ? node.name + '/' + path : node.name;
|
||
|
|
node = node.parent;
|
||
|
|
}
|
||
|
|
},hashName:function (parentid, name) {
|
||
|
|
var hash = 0;
|
||
|
|
|
||
|
|
|
||
|
|
for (var i = 0; i < name.length; i++) {
|
||
|
|
hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
|
||
|
|
}
|
||
|
|
return ((parentid + hash) >>> 0) % FS.nameTable.length;
|
||
|
|
},hashAddNode:function (node) {
|
||
|
|
var hash = FS.hashName(node.parent.id, node.name);
|
||
|
|
node.name_next = FS.nameTable[hash];
|
||
|
|
FS.nameTable[hash] = node;
|
||
|
|
},hashRemoveNode:function (node) {
|
||
|
|
var hash = FS.hashName(node.parent.id, node.name);
|
||
|
|
if (FS.nameTable[hash] === node) {
|
||
|
|
FS.nameTable[hash] = node.name_next;
|
||
|
|
} else {
|
||
|
|
var current = FS.nameTable[hash];
|
||
|
|
while (current) {
|
||
|
|
if (current.name_next === node) {
|
||
|
|
current.name_next = node.name_next;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
current = current.name_next;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},lookupNode:function (parent, name) {
|
||
|
|
var err = FS.mayLookup(parent);
|
||
|
|
if (err) {
|
||
|
|
throw new FS.ErrnoError(err);
|
||
|
|
}
|
||
|
|
var hash = FS.hashName(parent.id, name);
|
||
|
|
for (var node = FS.nameTable[hash]; node; node = node.name_next) {
|
||
|
|
var nodeName = node.name;
|
||
|
|
if (node.parent.id === parent.id && nodeName === name) {
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// if we failed to find it in the cache, call into the VFS
|
||
|
|
return FS.lookup(parent, name);
|
||
|
|
},createNode:function (parent, name, mode, rdev) {
|
||
|
|
if (!FS.FSNode) {
|
||
|
|
FS.FSNode = function(parent, name, mode, rdev) {
|
||
|
|
this.id = FS.nextInode++;
|
||
|
|
this.name = name;
|
||
|
|
this.mode = mode;
|
||
|
|
this.node_ops = {};
|
||
|
|
this.stream_ops = {};
|
||
|
|
this.rdev = rdev;
|
||
|
|
this.parent = null;
|
||
|
|
this.mount = null;
|
||
|
|
if (!parent) {
|
||
|
|
parent = this; // root node sets parent to itself
|
||
|
|
}
|
||
|
|
this.parent = parent;
|
||
|
|
this.mount = parent.mount;
|
||
|
|
FS.hashAddNode(this);
|
||
|
|
};
|
||
|
|
|
||
|
|
// compatibility
|
||
|
|
var readMode = 292 | 73;
|
||
|
|
var writeMode = 146;
|
||
|
|
|
||
|
|
FS.FSNode.prototype = {};
|
||
|
|
|
||
|
|
// NOTE we must use Object.defineProperties instead of individual calls to
|
||
|
|
// Object.defineProperty in order to make closure compiler happy
|
||
|
|
Object.defineProperties(FS.FSNode.prototype, {
|
||
|
|
read: {
|
||
|
|
get: function() { return (this.mode & readMode) === readMode; },
|
||
|
|
set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
|
||
|
|
},
|
||
|
|
write: {
|
||
|
|
get: function() { return (this.mode & writeMode) === writeMode; },
|
||
|
|
set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
|
||
|
|
},
|
||
|
|
isFolder: {
|
||
|
|
get: function() { return FS.isDir(this.mode); },
|
||
|
|
},
|
||
|
|
isDevice: {
|
||
|
|
get: function() { return FS.isChrdev(this.mode); },
|
||
|
|
},
|
||
|
|
});
|
||
|
|
}
|
||
|
|
return new FS.FSNode(parent, name, mode, rdev);
|
||
|
|
},destroyNode:function (node) {
|
||
|
|
FS.hashRemoveNode(node);
|
||
|
|
},isRoot:function (node) {
|
||
|
|
return node === node.parent;
|
||
|
|
},isMountpoint:function (node) {
|
||
|
|
return node.mounted;
|
||
|
|
},isFile:function (mode) {
|
||
|
|
return (mode & 61440) === 32768;
|
||
|
|
},isDir:function (mode) {
|
||
|
|
return (mode & 61440) === 16384;
|
||
|
|
},isLink:function (mode) {
|
||
|
|
return (mode & 61440) === 40960;
|
||
|
|
},isChrdev:function (mode) {
|
||
|
|
return (mode & 61440) === 8192;
|
||
|
|
},isBlkdev:function (mode) {
|
||
|
|
return (mode & 61440) === 24576;
|
||
|
|
},isFIFO:function (mode) {
|
||
|
|
return (mode & 61440) === 4096;
|
||
|
|
},isSocket:function (mode) {
|
||
|
|
return (mode & 49152) === 49152;
|
||
|
|
},flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function (str) {
|
||
|
|
var flags = FS.flagModes[str];
|
||
|
|
if (typeof flags === 'undefined') {
|
||
|
|
throw new Error('Unknown file open mode: ' + str);
|
||
|
|
}
|
||
|
|
return flags;
|
||
|
|
},flagsToPermissionString:function (flag) {
|
||
|
|
var accmode = flag & 2097155;
|
||
|
|
var perms = ['r', 'w', 'rw'][accmode];
|
||
|
|
if ((flag & 512)) {
|
||
|
|
perms += 'w';
|
||
|
|
}
|
||
|
|
return perms;
|
||
|
|
},nodePermissions:function (node, perms) {
|
||
|
|
if (FS.ignorePermissions) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
// return 0 if any user, group or owner bits are set.
|
||
|
|
if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
|
||
|
|
return ERRNO_CODES.EACCES;
|
||
|
|
} else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
|
||
|
|
return ERRNO_CODES.EACCES;
|
||
|
|
} else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
|
||
|
|
return ERRNO_CODES.EACCES;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
},mayLookup:function (dir) {
|
||
|
|
return FS.nodePermissions(dir, 'x');
|
||
|
|
},mayCreate:function (dir, name) {
|
||
|
|
try {
|
||
|
|
var node = FS.lookupNode(dir, name);
|
||
|
|
return ERRNO_CODES.EEXIST;
|
||
|
|
} catch (e) {
|
||
|
|
}
|
||
|
|
return FS.nodePermissions(dir, 'wx');
|
||
|
|
},mayDelete:function (dir, name, isdir) {
|
||
|
|
var node;
|
||
|
|
try {
|
||
|
|
node = FS.lookupNode(dir, name);
|
||
|
|
} catch (e) {
|
||
|
|
return e.errno;
|
||
|
|
}
|
||
|
|
var err = FS.nodePermissions(dir, 'wx');
|
||
|
|
if (err) {
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
if (isdir) {
|
||
|
|
if (!FS.isDir(node.mode)) {
|
||
|
|
return ERRNO_CODES.ENOTDIR;
|
||
|
|
}
|
||
|
|
if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
|
||
|
|
return ERRNO_CODES.EBUSY;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (FS.isDir(node.mode)) {
|
||
|
|
return ERRNO_CODES.EISDIR;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
},mayOpen:function (node, flags) {
|
||
|
|
if (!node) {
|
||
|
|
return ERRNO_CODES.ENOENT;
|
||
|
|
}
|
||
|
|
if (FS.isLink(node.mode)) {
|
||
|
|
return ERRNO_CODES.ELOOP;
|
||
|
|
} else if (FS.isDir(node.mode)) {
|
||
|
|
if ((flags & 2097155) !== 0 || // opening for write
|
||
|
|
(flags & 512)) {
|
||
|
|
return ERRNO_CODES.EISDIR;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
|
||
|
|
},MAX_OPEN_FDS:4096,nextfd:function (fd_start, fd_end) {
|
||
|
|
fd_start = fd_start || 1;
|
||
|
|
fd_end = fd_end || FS.MAX_OPEN_FDS;
|
||
|
|
for (var fd = fd_start; fd <= fd_end; fd++) {
|
||
|
|
if (!FS.streams[fd]) {
|
||
|
|
return fd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
|
||
|
|
},getStream:function (fd) {
|
||
|
|
return FS.streams[fd];
|
||
|
|
},createStream:function (stream, fd_start, fd_end) {
|
||
|
|
if (!FS.FSStream) {
|
||
|
|
FS.FSStream = function(){};
|
||
|
|
FS.FSStream.prototype = {};
|
||
|
|
// compatibility
|
||
|
|
Object.defineProperties(FS.FSStream.prototype, {
|
||
|
|
object: {
|
||
|
|
get: function() { return this.node; },
|
||
|
|
set: function(val) { this.node = val; }
|
||
|
|
},
|
||
|
|
isRead: {
|
||
|
|
get: function() { return (this.flags & 2097155) !== 1; }
|
||
|
|
},
|
||
|
|
isWrite: {
|
||
|
|
get: function() { return (this.flags & 2097155) !== 0; }
|
||
|
|
},
|
||
|
|
isAppend: {
|
||
|
|
get: function() { return (this.flags & 1024); }
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
if (stream.__proto__) {
|
||
|
|
// reuse the object
|
||
|
|
stream.__proto__ = FS.FSStream.prototype;
|
||
|
|
} else {
|
||
|
|
var newStream = new FS.FSStream();
|
||
|
|
for (var p in stream) {
|
||
|
|
newStream[p] = stream[p];
|
||
|
|
}
|
||
|
|
stream = newStream;
|
||
|
|
}
|
||
|
|
var fd = FS.nextfd(fd_start, fd_end);
|
||
|
|
stream.fd = fd;
|
||
|
|
FS.streams[fd] = stream;
|
||
|
|
return stream;
|
||
|
|
},closeStream:function (fd) {
|
||
|
|
FS.streams[fd] = null;
|
||
|
|
},chrdev_stream_ops:{open:function (stream) {
|
||
|
|
var device = FS.getDevice(stream.node.rdev);
|
||
|
|
// override node's stream ops with the device's
|
||
|
|
stream.stream_ops = device.stream_ops;
|
||
|
|
// forward the open call
|
||
|
|
if (stream.stream_ops.open) {
|
||
|
|
stream.stream_ops.open(stream);
|
||
|
|
}
|
||
|
|
},llseek:function () {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
|
||
|
|
}},major:function (dev) {
|
||
|
|
return ((dev) >> 8);
|
||
|
|
},minor:function (dev) {
|
||
|
|
return ((dev) & 0xff);
|
||
|
|
},makedev:function (ma, mi) {
|
||
|
|
return ((ma) << 8 | (mi));
|
||
|
|
},registerDevice:function (dev, ops) {
|
||
|
|
FS.devices[dev] = { stream_ops: ops };
|
||
|
|
},getDevice:function (dev) {
|
||
|
|
return FS.devices[dev];
|
||
|
|
},syncfs:function (populate, callback) {
|
||
|
|
if (typeof(populate) === 'function') {
|
||
|
|
callback = populate;
|
||
|
|
populate = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
var completed = 0;
|
||
|
|
var total = FS.mounts.length;
|
||
|
|
function done(err) {
|
||
|
|
if (err) {
|
||
|
|
return callback(err);
|
||
|
|
}
|
||
|
|
if (++completed >= total) {
|
||
|
|
callback(null);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
// sync all mounts
|
||
|
|
for (var i = 0; i < FS.mounts.length; i++) {
|
||
|
|
var mount = FS.mounts[i];
|
||
|
|
if (!mount.type.syncfs) {
|
||
|
|
done(null);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
mount.type.syncfs(mount, populate, done);
|
||
|
|
}
|
||
|
|
},mount:function (type, opts, mountpoint) {
|
||
|
|
var lookup;
|
||
|
|
if (mountpoint) {
|
||
|
|
lookup = FS.lookupPath(mountpoint, { follow: false });
|
||
|
|
mountpoint = lookup.path; // use the absolute path
|
||
|
|
}
|
||
|
|
var mount = {
|
||
|
|
type: type,
|
||
|
|
opts: opts,
|
||
|
|
mountpoint: mountpoint,
|
||
|
|
root: null
|
||
|
|
};
|
||
|
|
// create a root node for the fs
|
||
|
|
var root = type.mount(mount);
|
||
|
|
root.mount = mount;
|
||
|
|
mount.root = root;
|
||
|
|
// assign the mount info to the mountpoint's node
|
||
|
|
if (lookup) {
|
||
|
|
lookup.node.mount = mount;
|
||
|
|
lookup.node.mounted = true;
|
||
|
|
// compatibility update FS.root if we mount to /
|
||
|
|
if (mountpoint === '/') {
|
||
|
|
FS.root = mount.root;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// add to our cached list of mounts
|
||
|
|
FS.mounts.push(mount);
|
||
|
|
return root;
|
||
|
|
},lookup:function (parent, name) {
|
||
|
|
return parent.node_ops.lookup(parent, name);
|
||
|
|
},mknod:function (path, mode, dev) {
|
||
|
|
var lookup = FS.lookupPath(path, { parent: true });
|
||
|
|
var parent = lookup.node;
|
||
|
|
var name = PATH.basename(path);
|
||
|
|
var err = FS.mayCreate(parent, name);
|
||
|
|
if (err) {
|
||
|
|
throw new FS.ErrnoError(err);
|
||
|
|
}
|
||
|
|
if (!parent.node_ops.mknod) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
|
||
|
|
}
|
||
|
|
return parent.node_ops.mknod(parent, name, mode, dev);
|
||
|
|
},create:function (path, mode) {
|
||
|
|
mode = mode !== undefined ? mode : 0666;
|
||
|
|
mode &= 4095;
|
||
|
|
mode |= 32768;
|
||
|
|
return FS.mknod(path, mode, 0);
|
||
|
|
},mkdir:function (path, mode) {
|
||
|
|
mode = mode !== undefined ? mode : 0777;
|
||
|
|
mode &= 511 | 512;
|
||
|
|
mode |= 16384;
|
||
|
|
return FS.mknod(path, mode, 0);
|
||
|
|
},mkdev:function (path, mode, dev) {
|
||
|
|
if (typeof(dev) === 'undefined') {
|
||
|
|
dev = mode;
|
||
|
|
mode = 0666;
|
||
|
|
}
|
||
|
|
mode |= 8192;
|
||
|
|
return FS.mknod(path, mode, dev);
|
||
|
|
},symlink:function (oldpath, newpath) {
|
||
|
|
var lookup = FS.lookupPath(newpath, { parent: true });
|
||
|
|
var parent = lookup.node;
|
||
|
|
var newname = PATH.basename(newpath);
|
||
|
|
var err = FS.mayCreate(parent, newname);
|
||
|
|
if (err) {
|
||
|
|
throw new FS.ErrnoError(err);
|
||
|
|
}
|
||
|
|
if (!parent.node_ops.symlink) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
|
||
|
|
}
|
||
|
|
return parent.node_ops.symlink(parent, newname, oldpath);
|
||
|
|
},rename:function (old_path, new_path) {
|
||
|
|
var old_dirname = PATH.dirname(old_path);
|
||
|
|
var new_dirname = PATH.dirname(new_path);
|
||
|
|
var old_name = PATH.basename(old_path);
|
||
|
|
var new_name = PATH.basename(new_path);
|
||
|
|
// parents must exist
|
||
|
|
var lookup, old_dir, new_dir;
|
||
|
|
try {
|
||
|
|
lookup = FS.lookupPath(old_path, { parent: true });
|
||
|
|
old_dir = lookup.node;
|
||
|
|
lookup = FS.lookupPath(new_path, { parent: true });
|
||
|
|
new_dir = lookup.node;
|
||
|
|
} catch (e) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
|
||
|
|
}
|
||
|
|
// need to be part of the same mount
|
||
|
|
if (old_dir.mount !== new_dir.mount) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
|
||
|
|
}
|
||
|
|
// source must exist
|
||
|
|
var old_node = FS.lookupNode(old_dir, old_name);
|
||
|
|
// old path should not be an ancestor of the new path
|
||
|
|
var relative = PATH.relative(old_path, new_dirname);
|
||
|
|
if (relative.charAt(0) !== '.') {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
// new path should not be an ancestor of the old path
|
||
|
|
relative = PATH.relative(new_path, old_dirname);
|
||
|
|
if (relative.charAt(0) !== '.') {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
|
||
|
|
}
|
||
|
|
// see if the new path already exists
|
||
|
|
var new_node;
|
||
|
|
try {
|
||
|
|
new_node = FS.lookupNode(new_dir, new_name);
|
||
|
|
} catch (e) {
|
||
|
|
// not fatal
|
||
|
|
}
|
||
|
|
// early out if nothing needs to change
|
||
|
|
if (old_node === new_node) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
// we'll need to delete the old entry
|
||
|
|
var isdir = FS.isDir(old_node.mode);
|
||
|
|
var err = FS.mayDelete(old_dir, old_name, isdir);
|
||
|
|
if (err) {
|
||
|
|
throw new FS.ErrnoError(err);
|
||
|
|
}
|
||
|
|
// need delete permissions if we'll be overwriting.
|
||
|
|
// need create permissions if new doesn't already exist.
|
||
|
|
err = new_node ?
|
||
|
|
FS.mayDelete(new_dir, new_name, isdir) :
|
||
|
|
FS.mayCreate(new_dir, new_name);
|
||
|
|
if (err) {
|
||
|
|
throw new FS.ErrnoError(err);
|
||
|
|
}
|
||
|
|
if (!old_dir.node_ops.rename) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
|
||
|
|
}
|
||
|
|
if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
|
||
|
|
}
|
||
|
|
// if we are going to change the parent, check write permissions
|
||
|
|
if (new_dir !== old_dir) {
|
||
|
|
err = FS.nodePermissions(old_dir, 'w');
|
||
|
|
if (err) {
|
||
|
|
throw new FS.ErrnoError(err);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// remove the node from the lookup hash
|
||
|
|
FS.hashRemoveNode(old_node);
|
||
|
|
// do the underlying fs rename
|
||
|
|
try {
|
||
|
|
old_dir.node_ops.rename(old_node, new_dir, new_name);
|
||
|
|
} catch (e) {
|
||
|
|
throw e;
|
||
|
|
} finally {
|
||
|
|
// add the node back to the hash (in case node_ops.rename
|
||
|
|
// changed its name)
|
||
|
|
FS.hashAddNode(old_node);
|
||
|
|
}
|
||
|
|
},rmdir:function (path) {
|
||
|
|
var lookup = FS.lookupPath(path, { parent: true });
|
||
|
|
var parent = lookup.node;
|
||
|
|
var name = PATH.basename(path);
|
||
|
|
var node = FS.lookupNode(parent, name);
|
||
|
|
var err = FS.mayDelete(parent, name, true);
|
||
|
|
if (err) {
|
||
|
|
throw new FS.ErrnoError(err);
|
||
|
|
}
|
||
|
|
if (!parent.node_ops.rmdir) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
|
||
|
|
}
|
||
|
|
if (FS.isMountpoint(node)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
|
||
|
|
}
|
||
|
|
parent.node_ops.rmdir(parent, name);
|
||
|
|
FS.destroyNode(node);
|
||
|
|
},readdir:function (path) {
|
||
|
|
var lookup = FS.lookupPath(path, { follow: true });
|
||
|
|
var node = lookup.node;
|
||
|
|
if (!node.node_ops.readdir) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
|
||
|
|
}
|
||
|
|
return node.node_ops.readdir(node);
|
||
|
|
},unlink:function (path) {
|
||
|
|
var lookup = FS.lookupPath(path, { parent: true });
|
||
|
|
var parent = lookup.node;
|
||
|
|
var name = PATH.basename(path);
|
||
|
|
var node = FS.lookupNode(parent, name);
|
||
|
|
var err = FS.mayDelete(parent, name, false);
|
||
|
|
if (err) {
|
||
|
|
// POSIX says unlink should set EPERM, not EISDIR
|
||
|
|
if (err === ERRNO_CODES.EISDIR) err = ERRNO_CODES.EPERM;
|
||
|
|
throw new FS.ErrnoError(err);
|
||
|
|
}
|
||
|
|
if (!parent.node_ops.unlink) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
|
||
|
|
}
|
||
|
|
if (FS.isMountpoint(node)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
|
||
|
|
}
|
||
|
|
parent.node_ops.unlink(parent, name);
|
||
|
|
FS.destroyNode(node);
|
||
|
|
},readlink:function (path) {
|
||
|
|
var lookup = FS.lookupPath(path, { follow: false });
|
||
|
|
var link = lookup.node;
|
||
|
|
if (!link.node_ops.readlink) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
return link.node_ops.readlink(link);
|
||
|
|
},stat:function (path, dontFollow) {
|
||
|
|
var lookup = FS.lookupPath(path, { follow: !dontFollow });
|
||
|
|
var node = lookup.node;
|
||
|
|
if (!node.node_ops.getattr) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
|
||
|
|
}
|
||
|
|
return node.node_ops.getattr(node);
|
||
|
|
},lstat:function (path) {
|
||
|
|
return FS.stat(path, true);
|
||
|
|
},chmod:function (path, mode, dontFollow) {
|
||
|
|
var node;
|
||
|
|
if (typeof path === 'string') {
|
||
|
|
var lookup = FS.lookupPath(path, { follow: !dontFollow });
|
||
|
|
node = lookup.node;
|
||
|
|
} else {
|
||
|
|
node = path;
|
||
|
|
}
|
||
|
|
if (!node.node_ops.setattr) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
|
||
|
|
}
|
||
|
|
node.node_ops.setattr(node, {
|
||
|
|
mode: (mode & 4095) | (node.mode & ~4095),
|
||
|
|
timestamp: Date.now()
|
||
|
|
});
|
||
|
|
},lchmod:function (path, mode) {
|
||
|
|
FS.chmod(path, mode, true);
|
||
|
|
},fchmod:function (fd, mode) {
|
||
|
|
var stream = FS.getStream(fd);
|
||
|
|
if (!stream) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EBADF);
|
||
|
|
}
|
||
|
|
FS.chmod(stream.node, mode);
|
||
|
|
},chown:function (path, uid, gid, dontFollow) {
|
||
|
|
var node;
|
||
|
|
if (typeof path === 'string') {
|
||
|
|
var lookup = FS.lookupPath(path, { follow: !dontFollow });
|
||
|
|
node = lookup.node;
|
||
|
|
} else {
|
||
|
|
node = path;
|
||
|
|
}
|
||
|
|
if (!node.node_ops.setattr) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
|
||
|
|
}
|
||
|
|
node.node_ops.setattr(node, {
|
||
|
|
timestamp: Date.now()
|
||
|
|
// we ignore the uid / gid for now
|
||
|
|
});
|
||
|
|
},lchown:function (path, uid, gid) {
|
||
|
|
FS.chown(path, uid, gid, true);
|
||
|
|
},fchown:function (fd, uid, gid) {
|
||
|
|
var stream = FS.getStream(fd);
|
||
|
|
if (!stream) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EBADF);
|
||
|
|
}
|
||
|
|
FS.chown(stream.node, uid, gid);
|
||
|
|
},truncate:function (path, len) {
|
||
|
|
if (len < 0) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
var node;
|
||
|
|
if (typeof path === 'string') {
|
||
|
|
var lookup = FS.lookupPath(path, { follow: true });
|
||
|
|
node = lookup.node;
|
||
|
|
} else {
|
||
|
|
node = path;
|
||
|
|
}
|
||
|
|
if (!node.node_ops.setattr) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
|
||
|
|
}
|
||
|
|
if (FS.isDir(node.mode)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
|
||
|
|
}
|
||
|
|
if (!FS.isFile(node.mode)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
var err = FS.nodePermissions(node, 'w');
|
||
|
|
if (err) {
|
||
|
|
throw new FS.ErrnoError(err);
|
||
|
|
}
|
||
|
|
node.node_ops.setattr(node, {
|
||
|
|
size: len,
|
||
|
|
timestamp: Date.now()
|
||
|
|
});
|
||
|
|
},ftruncate:function (fd, len) {
|
||
|
|
var stream = FS.getStream(fd);
|
||
|
|
if (!stream) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EBADF);
|
||
|
|
}
|
||
|
|
if ((stream.flags & 2097155) === 0) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
FS.truncate(stream.node, len);
|
||
|
|
},utime:function (path, atime, mtime) {
|
||
|
|
var lookup = FS.lookupPath(path, { follow: true });
|
||
|
|
var node = lookup.node;
|
||
|
|
node.node_ops.setattr(node, {
|
||
|
|
timestamp: Math.max(atime, mtime)
|
||
|
|
});
|
||
|
|
},open:function (path, flags, mode, fd_start, fd_end) {
|
||
|
|
flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
|
||
|
|
mode = typeof mode === 'undefined' ? 0666 : mode;
|
||
|
|
if ((flags & 64)) {
|
||
|
|
mode = (mode & 4095) | 32768;
|
||
|
|
} else {
|
||
|
|
mode = 0;
|
||
|
|
}
|
||
|
|
var node;
|
||
|
|
if (typeof path === 'object') {
|
||
|
|
node = path;
|
||
|
|
} else {
|
||
|
|
path = PATH.normalize(path);
|
||
|
|
try {
|
||
|
|
var lookup = FS.lookupPath(path, {
|
||
|
|
follow: !(flags & 131072)
|
||
|
|
});
|
||
|
|
node = lookup.node;
|
||
|
|
} catch (e) {
|
||
|
|
// ignore
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// perhaps we need to create the node
|
||
|
|
if ((flags & 64)) {
|
||
|
|
if (node) {
|
||
|
|
// if O_CREAT and O_EXCL are set, error out if the node already exists
|
||
|
|
if ((flags & 128)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// node doesn't exist, try to create it
|
||
|
|
node = FS.mknod(path, mode, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!node) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
|
||
|
|
}
|
||
|
|
// can't truncate a device
|
||
|
|
if (FS.isChrdev(node.mode)) {
|
||
|
|
flags &= ~512;
|
||
|
|
}
|
||
|
|
// check permissions
|
||
|
|
var err = FS.mayOpen(node, flags);
|
||
|
|
if (err) {
|
||
|
|
throw new FS.ErrnoError(err);
|
||
|
|
}
|
||
|
|
// do truncation if necessary
|
||
|
|
if ((flags & 512)) {
|
||
|
|
FS.truncate(node, 0);
|
||
|
|
}
|
||
|
|
// we've already handled these, don't pass down to the underlying vfs
|
||
|
|
flags &= ~(128 | 512);
|
||
|
|
|
||
|
|
// register the stream with the filesystem
|
||
|
|
var stream = FS.createStream({
|
||
|
|
node: node,
|
||
|
|
path: FS.getPath(node), // we want the absolute path to the node
|
||
|
|
flags: flags,
|
||
|
|
seekable: true,
|
||
|
|
position: 0,
|
||
|
|
stream_ops: node.stream_ops,
|
||
|
|
// used by the file family libc calls (fopen, fwrite, ferror, etc.)
|
||
|
|
ungotten: [],
|
||
|
|
error: false
|
||
|
|
}, fd_start, fd_end);
|
||
|
|
// call the new stream's open function
|
||
|
|
if (stream.stream_ops.open) {
|
||
|
|
stream.stream_ops.open(stream);
|
||
|
|
}
|
||
|
|
if (Module['logReadFiles'] && !(flags & 1)) {
|
||
|
|
if (!FS.readFiles) FS.readFiles = {};
|
||
|
|
if (!(path in FS.readFiles)) {
|
||
|
|
FS.readFiles[path] = 1;
|
||
|
|
Module['printErr']('read file: ' + path);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return stream;
|
||
|
|
},close:function (stream) {
|
||
|
|
try {
|
||
|
|
if (stream.stream_ops.close) {
|
||
|
|
stream.stream_ops.close(stream);
|
||
|
|
}
|
||
|
|
} catch (e) {
|
||
|
|
throw e;
|
||
|
|
} finally {
|
||
|
|
FS.closeStream(stream.fd);
|
||
|
|
}
|
||
|
|
},llseek:function (stream, offset, whence) {
|
||
|
|
if (!stream.seekable || !stream.stream_ops.llseek) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
|
||
|
|
}
|
||
|
|
return stream.stream_ops.llseek(stream, offset, whence);
|
||
|
|
},read:function (stream, buffer, offset, length, position) {
|
||
|
|
if (length < 0 || position < 0) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
if ((stream.flags & 2097155) === 1) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EBADF);
|
||
|
|
}
|
||
|
|
if (FS.isDir(stream.node.mode)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
|
||
|
|
}
|
||
|
|
if (!stream.stream_ops.read) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
var seeking = true;
|
||
|
|
if (typeof position === 'undefined') {
|
||
|
|
position = stream.position;
|
||
|
|
seeking = false;
|
||
|
|
} else if (!stream.seekable) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
|
||
|
|
}
|
||
|
|
var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
|
||
|
|
if (!seeking) stream.position += bytesRead;
|
||
|
|
return bytesRead;
|
||
|
|
},write:function (stream, buffer, offset, length, position, canOwn) {
|
||
|
|
if (length < 0 || position < 0) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
if ((stream.flags & 2097155) === 0) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EBADF);
|
||
|
|
}
|
||
|
|
if (FS.isDir(stream.node.mode)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
|
||
|
|
}
|
||
|
|
if (!stream.stream_ops.write) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
var seeking = true;
|
||
|
|
if (typeof position === 'undefined') {
|
||
|
|
position = stream.position;
|
||
|
|
seeking = false;
|
||
|
|
} else if (!stream.seekable) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
|
||
|
|
}
|
||
|
|
if (stream.flags & 1024) {
|
||
|
|
// seek to the end before writing in append mode
|
||
|
|
FS.llseek(stream, 0, 2);
|
||
|
|
}
|
||
|
|
var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
|
||
|
|
if (!seeking) stream.position += bytesWritten;
|
||
|
|
return bytesWritten;
|
||
|
|
},allocate:function (stream, offset, length) {
|
||
|
|
if (offset < 0 || length <= 0) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
|
||
|
|
}
|
||
|
|
if ((stream.flags & 2097155) === 0) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EBADF);
|
||
|
|
}
|
||
|
|
if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
|
||
|
|
}
|
||
|
|
if (!stream.stream_ops.allocate) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
|
||
|
|
}
|
||
|
|
stream.stream_ops.allocate(stream, offset, length);
|
||
|
|
},mmap:function (stream, buffer, offset, length, position, prot, flags) {
|
||
|
|
// TODO if PROT is PROT_WRITE, make sure we have write access
|
||
|
|
if ((stream.flags & 2097155) === 1) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EACCES);
|
||
|
|
}
|
||
|
|
if (!stream.stream_ops.mmap) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
|
||
|
|
}
|
||
|
|
return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags);
|
||
|
|
},ioctl:function (stream, cmd, arg) {
|
||
|
|
if (!stream.stream_ops.ioctl) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
|
||
|
|
}
|
||
|
|
return stream.stream_ops.ioctl(stream, cmd, arg);
|
||
|
|
},readFile:function (path, opts) {
|
||
|
|
opts = opts || {};
|
||
|
|
opts.flags = opts.flags || 'r';
|
||
|
|
opts.encoding = opts.encoding || 'binary';
|
||
|
|
var ret;
|
||
|
|
var stream = FS.open(path, opts.flags);
|
||
|
|
var stat = FS.stat(path);
|
||
|
|
var length = stat.size;
|
||
|
|
var buf = new Uint8Array(length);
|
||
|
|
FS.read(stream, buf, 0, length, 0);
|
||
|
|
if (opts.encoding === 'utf8') {
|
||
|
|
ret = '';
|
||
|
|
var utf8 = new Runtime.UTF8Processor();
|
||
|
|
for (var i = 0; i < length; i++) {
|
||
|
|
ret += utf8.processCChar(buf[i]);
|
||
|
|
}
|
||
|
|
} else if (opts.encoding === 'binary') {
|
||
|
|
ret = buf;
|
||
|
|
} else {
|
||
|
|
throw new Error('Invalid encoding type "' + opts.encoding + '"');
|
||
|
|
}
|
||
|
|
FS.close(stream);
|
||
|
|
return ret;
|
||
|
|
},writeFile:function (path, data, opts) {
|
||
|
|
opts = opts || {};
|
||
|
|
opts.flags = opts.flags || 'w';
|
||
|
|
opts.encoding = opts.encoding || 'utf8';
|
||
|
|
var stream = FS.open(path, opts.flags, opts.mode);
|
||
|
|
if (opts.encoding === 'utf8') {
|
||
|
|
var utf8 = new Runtime.UTF8Processor();
|
||
|
|
var buf = new Uint8Array(utf8.processJSString(data));
|
||
|
|
FS.write(stream, buf, 0, buf.length, 0);
|
||
|
|
} else if (opts.encoding === 'binary') {
|
||
|
|
FS.write(stream, data, 0, data.length, 0);
|
||
|
|
} else {
|
||
|
|
throw new Error('Invalid encoding type "' + opts.encoding + '"');
|
||
|
|
}
|
||
|
|
FS.close(stream);
|
||
|
|
},cwd:function () {
|
||
|
|
return FS.currentPath;
|
||
|
|
},chdir:function (path) {
|
||
|
|
var lookup = FS.lookupPath(path, { follow: true });
|
||
|
|
if (!FS.isDir(lookup.node.mode)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
|
||
|
|
}
|
||
|
|
var err = FS.nodePermissions(lookup.node, 'x');
|
||
|
|
if (err) {
|
||
|
|
throw new FS.ErrnoError(err);
|
||
|
|
}
|
||
|
|
FS.currentPath = lookup.path;
|
||
|
|
},createDefaultDirectories:function () {
|
||
|
|
FS.mkdir('/tmp');
|
||
|
|
},createDefaultDevices:function () {
|
||
|
|
// create /dev
|
||
|
|
FS.mkdir('/dev');
|
||
|
|
// setup /dev/null
|
||
|
|
FS.registerDevice(FS.makedev(1, 3), {
|
||
|
|
read: function() { return 0; },
|
||
|
|
write: function() { return 0; }
|
||
|
|
});
|
||
|
|
FS.mkdev('/dev/null', FS.makedev(1, 3));
|
||
|
|
// setup /dev/tty and /dev/tty1
|
||
|
|
// stderr needs to print output using Module['printErr']
|
||
|
|
// so we register a second tty just for it.
|
||
|
|
TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
|
||
|
|
TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
|
||
|
|
FS.mkdev('/dev/tty', FS.makedev(5, 0));
|
||
|
|
FS.mkdev('/dev/tty1', FS.makedev(6, 0));
|
||
|
|
// we're not going to emulate the actual shm device,
|
||
|
|
// just create the tmp dirs that reside in it commonly
|
||
|
|
FS.mkdir('/dev/shm');
|
||
|
|
FS.mkdir('/dev/shm/tmp');
|
||
|
|
},createStandardStreams:function () {
|
||
|
|
// TODO deprecate the old functionality of a single
|
||
|
|
// input / output callback and that utilizes FS.createDevice
|
||
|
|
// and instead require a unique set of stream ops
|
||
|
|
|
||
|
|
// by default, we symlink the standard streams to the
|
||
|
|
// default tty devices. however, if the standard streams
|
||
|
|
// have been overwritten we create a unique device for
|
||
|
|
// them instead.
|
||
|
|
if (Module['stdin']) {
|
||
|
|
FS.createDevice('/dev', 'stdin', Module['stdin']);
|
||
|
|
} else {
|
||
|
|
FS.symlink('/dev/tty', '/dev/stdin');
|
||
|
|
}
|
||
|
|
if (Module['stdout']) {
|
||
|
|
FS.createDevice('/dev', 'stdout', null, Module['stdout']);
|
||
|
|
} else {
|
||
|
|
FS.symlink('/dev/tty', '/dev/stdout');
|
||
|
|
}
|
||
|
|
if (Module['stderr']) {
|
||
|
|
FS.createDevice('/dev', 'stderr', null, Module['stderr']);
|
||
|
|
} else {
|
||
|
|
FS.symlink('/dev/tty1', '/dev/stderr');
|
||
|
|
}
|
||
|
|
|
||
|
|
// open default streams for the stdin, stdout and stderr devices
|
||
|
|
var stdin = FS.open('/dev/stdin', 'r');
|
||
|
|
HEAP32[((_stdin)>>2)]=stdin.fd;
|
||
|
|
assert(stdin.fd === 1, 'invalid handle for stdin (' + stdin.fd + ')');
|
||
|
|
|
||
|
|
var stdout = FS.open('/dev/stdout', 'w');
|
||
|
|
HEAP32[((_stdout)>>2)]=stdout.fd;
|
||
|
|
assert(stdout.fd === 2, 'invalid handle for stdout (' + stdout.fd + ')');
|
||
|
|
|
||
|
|
var stderr = FS.open('/dev/stderr', 'w');
|
||
|
|
HEAP32[((_stderr)>>2)]=stderr.fd;
|
||
|
|
assert(stderr.fd === 3, 'invalid handle for stderr (' + stderr.fd + ')');
|
||
|
|
},ensureErrnoError:function () {
|
||
|
|
if (FS.ErrnoError) return;
|
||
|
|
FS.ErrnoError = function ErrnoError(errno) {
|
||
|
|
this.errno = errno;
|
||
|
|
for (var key in ERRNO_CODES) {
|
||
|
|
if (ERRNO_CODES[key] === errno) {
|
||
|
|
this.code = key;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.message = ERRNO_MESSAGES[errno];
|
||
|
|
if (this.stack) this.stack = demangleAll(this.stack);
|
||
|
|
};
|
||
|
|
FS.ErrnoError.prototype = new Error();
|
||
|
|
FS.ErrnoError.prototype.constructor = FS.ErrnoError;
|
||
|
|
// Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
|
||
|
|
[ERRNO_CODES.ENOENT].forEach(function(code) {
|
||
|
|
FS.genericErrors[code] = new FS.ErrnoError(code);
|
||
|
|
FS.genericErrors[code].stack = '<generic error, no stack>';
|
||
|
|
});
|
||
|
|
},staticInit:function () {
|
||
|
|
FS.ensureErrnoError();
|
||
|
|
|
||
|
|
FS.nameTable = new Array(4096);
|
||
|
|
|
||
|
|
FS.root = FS.createNode(null, '/', 16384 | 0777, 0);
|
||
|
|
FS.mount(MEMFS, {}, '/');
|
||
|
|
|
||
|
|
FS.createDefaultDirectories();
|
||
|
|
FS.createDefaultDevices();
|
||
|
|
},init:function (input, output, error) {
|
||
|
|
assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
|
||
|
|
FS.init.initialized = true;
|
||
|
|
|
||
|
|
FS.ensureErrnoError();
|
||
|
|
|
||
|
|
// Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
|
||
|
|
Module['stdin'] = input || Module['stdin'];
|
||
|
|
Module['stdout'] = output || Module['stdout'];
|
||
|
|
Module['stderr'] = error || Module['stderr'];
|
||
|
|
|
||
|
|
FS.createStandardStreams();
|
||
|
|
},quit:function () {
|
||
|
|
FS.init.initialized = false;
|
||
|
|
for (var i = 0; i < FS.streams.length; i++) {
|
||
|
|
var stream = FS.streams[i];
|
||
|
|
if (!stream) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
FS.close(stream);
|
||
|
|
}
|
||
|
|
},getMode:function (canRead, canWrite) {
|
||
|
|
var mode = 0;
|
||
|
|
if (canRead) mode |= 292 | 73;
|
||
|
|
if (canWrite) mode |= 146;
|
||
|
|
return mode;
|
||
|
|
},joinPath:function (parts, forceRelative) {
|
||
|
|
var path = PATH.join.apply(null, parts);
|
||
|
|
if (forceRelative && path[0] == '/') path = path.substr(1);
|
||
|
|
return path;
|
||
|
|
},absolutePath:function (relative, base) {
|
||
|
|
return PATH.resolve(base, relative);
|
||
|
|
},standardizePath:function (path) {
|
||
|
|
return PATH.normalize(path);
|
||
|
|
},findObject:function (path, dontResolveLastLink) {
|
||
|
|
var ret = FS.analyzePath(path, dontResolveLastLink);
|
||
|
|
if (ret.exists) {
|
||
|
|
return ret.object;
|
||
|
|
} else {
|
||
|
|
___setErrNo(ret.error);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
},analyzePath:function (path, dontResolveLastLink) {
|
||
|
|
// operate from within the context of the symlink's target
|
||
|
|
try {
|
||
|
|
var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
|
||
|
|
path = lookup.path;
|
||
|
|
} catch (e) {
|
||
|
|
}
|
||
|
|
var ret = {
|
||
|
|
isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
|
||
|
|
parentExists: false, parentPath: null, parentObject: null
|
||
|
|
};
|
||
|
|
try {
|
||
|
|
var lookup = FS.lookupPath(path, { parent: true });
|
||
|
|
ret.parentExists = true;
|
||
|
|
ret.parentPath = lookup.path;
|
||
|
|
ret.parentObject = lookup.node;
|
||
|
|
ret.name = PATH.basename(path);
|
||
|
|
lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
|
||
|
|
ret.exists = true;
|
||
|
|
ret.path = lookup.path;
|
||
|
|
ret.object = lookup.node;
|
||
|
|
ret.name = lookup.node.name;
|
||
|
|
ret.isRoot = lookup.path === '/';
|
||
|
|
} catch (e) {
|
||
|
|
ret.error = e.errno;
|
||
|
|
};
|
||
|
|
return ret;
|
||
|
|
},createFolder:function (parent, name, canRead, canWrite) {
|
||
|
|
var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
|
||
|
|
var mode = FS.getMode(canRead, canWrite);
|
||
|
|
return FS.mkdir(path, mode);
|
||
|
|
},createPath:function (parent, path, canRead, canWrite) {
|
||
|
|
parent = typeof parent === 'string' ? parent : FS.getPath(parent);
|
||
|
|
var parts = path.split('/').reverse();
|
||
|
|
while (parts.length) {
|
||
|
|
var part = parts.pop();
|
||
|
|
if (!part) continue;
|
||
|
|
var current = PATH.join2(parent, part);
|
||
|
|
try {
|
||
|
|
FS.mkdir(current);
|
||
|
|
} catch (e) {
|
||
|
|
// ignore EEXIST
|
||
|
|
}
|
||
|
|
parent = current;
|
||
|
|
}
|
||
|
|
return current;
|
||
|
|
},createFile:function (parent, name, properties, canRead, canWrite) {
|
||
|
|
var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
|
||
|
|
var mode = FS.getMode(canRead, canWrite);
|
||
|
|
return FS.create(path, mode);
|
||
|
|
},createDataFile:function (parent, name, data, canRead, canWrite, canOwn) {
|
||
|
|
var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
|
||
|
|
var mode = FS.getMode(canRead, canWrite);
|
||
|
|
var node = FS.create(path, mode);
|
||
|
|
if (data) {
|
||
|
|
if (typeof data === 'string') {
|
||
|
|
var arr = new Array(data.length);
|
||
|
|
for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
|
||
|
|
data = arr;
|
||
|
|
}
|
||
|
|
// make sure we can write to the file
|
||
|
|
FS.chmod(node, mode | 146);
|
||
|
|
var stream = FS.open(node, 'w');
|
||
|
|
FS.write(stream, data, 0, data.length, 0, canOwn);
|
||
|
|
FS.close(stream);
|
||
|
|
FS.chmod(node, mode);
|
||
|
|
}
|
||
|
|
return node;
|
||
|
|
},createDevice:function (parent, name, input, output) {
|
||
|
|
var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
|
||
|
|
var mode = FS.getMode(!!input, !!output);
|
||
|
|
if (!FS.createDevice.major) FS.createDevice.major = 64;
|
||
|
|
var dev = FS.makedev(FS.createDevice.major++, 0);
|
||
|
|
// Create a fake device that a set of stream ops to emulate
|
||
|
|
// the old behavior.
|
||
|
|
FS.registerDevice(dev, {
|
||
|
|
open: function(stream) {
|
||
|
|
stream.seekable = false;
|
||
|
|
},
|
||
|
|
close: function(stream) {
|
||
|
|
// flush any pending line data
|
||
|
|
if (output && output.buffer && output.buffer.length) {
|
||
|
|
output(10);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
read: function(stream, buffer, offset, length, pos /* ignored */) {
|
||
|
|
var bytesRead = 0;
|
||
|
|
for (var i = 0; i < length; i++) {
|
||
|
|
var result;
|
||
|
|
try {
|
||
|
|
result = input();
|
||
|
|
} catch (e) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EIO);
|
||
|
|
}
|
||
|
|
if (result === undefined && bytesRead === 0) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
|
||
|
|
}
|
||
|
|
if (result === null || result === undefined) break;
|
||
|
|
bytesRead++;
|
||
|
|
buffer[offset+i] = result;
|
||
|
|
}
|
||
|
|
if (bytesRead) {
|
||
|
|
stream.node.timestamp = Date.now();
|
||
|
|
}
|
||
|
|
return bytesRead;
|
||
|
|
},
|
||
|
|
write: function(stream, buffer, offset, length, pos) {
|
||
|
|
for (var i = 0; i < length; i++) {
|
||
|
|
try {
|
||
|
|
output(buffer[offset+i]);
|
||
|
|
} catch (e) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EIO);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (length) {
|
||
|
|
stream.node.timestamp = Date.now();
|
||
|
|
}
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return FS.mkdev(path, mode, dev);
|
||
|
|
},createLink:function (parent, name, target, canRead, canWrite) {
|
||
|
|
var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
|
||
|
|
return FS.symlink(target, path);
|
||
|
|
},forceLoadFile:function (obj) {
|
||
|
|
if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
|
||
|
|
var success = true;
|
||
|
|
if (typeof XMLHttpRequest !== 'undefined') {
|
||
|
|
throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
|
||
|
|
} else if (Module['read']) {
|
||
|
|
// Command-line.
|
||
|
|
try {
|
||
|
|
// WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
|
||
|
|
// read() will try to parse UTF8.
|
||
|
|
obj.contents = intArrayFromString(Module['read'](obj.url), true);
|
||
|
|
} catch (e) {
|
||
|
|
success = false;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
throw new Error('Cannot load without read() or XMLHttpRequest.');
|
||
|
|
}
|
||
|
|
if (!success) ___setErrNo(ERRNO_CODES.EIO);
|
||
|
|
return success;
|
||
|
|
},createLazyFile:function (parent, name, url, canRead, canWrite) {
|
||
|
|
if (typeof XMLHttpRequest !== 'undefined') {
|
||
|
|
if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
|
||
|
|
// Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
|
||
|
|
function LazyUint8Array() {
|
||
|
|
this.lengthKnown = false;
|
||
|
|
this.chunks = []; // Loaded chunks. Index is the chunk number
|
||
|
|
}
|
||
|
|
LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
|
||
|
|
if (idx > this.length-1 || idx < 0) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
var chunkOffset = idx % this.chunkSize;
|
||
|
|
var chunkNum = Math.floor(idx / this.chunkSize);
|
||
|
|
return this.getter(chunkNum)[chunkOffset];
|
||
|
|
}
|
||
|
|
LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
|
||
|
|
this.getter = getter;
|
||
|
|
}
|
||
|
|
LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
|
||
|
|
// Find length
|
||
|
|
var xhr = new XMLHttpRequest();
|
||
|
|
xhr.open('HEAD', url, false);
|
||
|
|
xhr.send(null);
|
||
|
|
if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
|
||
|
|
var datalength = Number(xhr.getResponseHeader("Content-length"));
|
||
|
|
var header;
|
||
|
|
var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
|
||
|
|
var chunkSize = 1024*1024; // Chunk size in bytes
|
||
|
|
|
||
|
|
if (!hasByteServing) chunkSize = datalength;
|
||
|
|
|
||
|
|
// Function to get a range from the remote URL.
|
||
|
|
var doXHR = (function(from, to) {
|
||
|
|
if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
|
||
|
|
if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
|
||
|
|
|
||
|
|
// TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
|
||
|
|
var xhr = new XMLHttpRequest();
|
||
|
|
xhr.open('GET', url, false);
|
||
|
|
if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
|
||
|
|
|
||
|
|
// Some hints to the browser that we want binary data.
|
||
|
|
if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
|
||
|
|
if (xhr.overrideMimeType) {
|
||
|
|
xhr.overrideMimeType('text/plain; charset=x-user-defined');
|
||
|
|
}
|
||
|
|
|
||
|
|
xhr.send(null);
|
||
|
|
if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
|
||
|
|
if (xhr.response !== undefined) {
|
||
|
|
return new Uint8Array(xhr.response || []);
|
||
|
|
} else {
|
||
|
|
return intArrayFromString(xhr.responseText || '', true);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
var lazyArray = this;
|
||
|
|
lazyArray.setDataGetter(function(chunkNum) {
|
||
|
|
var start = chunkNum * chunkSize;
|
||
|
|
var end = (chunkNum+1) * chunkSize - 1; // including this byte
|
||
|
|
end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
|
||
|
|
if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
|
||
|
|
lazyArray.chunks[chunkNum] = doXHR(start, end);
|
||
|
|
}
|
||
|
|
if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
|
||
|
|
return lazyArray.chunks[chunkNum];
|
||
|
|
});
|
||
|
|
|
||
|
|
this._length = datalength;
|
||
|
|
this._chunkSize = chunkSize;
|
||
|
|
this.lengthKnown = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
var lazyArray = new LazyUint8Array();
|
||
|
|
Object.defineProperty(lazyArray, "length", {
|
||
|
|
get: function() {
|
||
|
|
if(!this.lengthKnown) {
|
||
|
|
this.cacheLength();
|
||
|
|
}
|
||
|
|
return this._length;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
Object.defineProperty(lazyArray, "chunkSize", {
|
||
|
|
get: function() {
|
||
|
|
if(!this.lengthKnown) {
|
||
|
|
this.cacheLength();
|
||
|
|
}
|
||
|
|
return this._chunkSize;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
var properties = { isDevice: false, contents: lazyArray };
|
||
|
|
} else {
|
||
|
|
var properties = { isDevice: false, url: url };
|
||
|
|
}
|
||
|
|
|
||
|
|
var node = FS.createFile(parent, name, properties, canRead, canWrite);
|
||
|
|
// This is a total hack, but I want to get this lazy file code out of the
|
||
|
|
// core of MEMFS. If we want to keep this lazy file concept I feel it should
|
||
|
|
// be its own thin LAZYFS proxying calls to MEMFS.
|
||
|
|
if (properties.contents) {
|
||
|
|
node.contents = properties.contents;
|
||
|
|
} else if (properties.url) {
|
||
|
|
node.contents = null;
|
||
|
|
node.url = properties.url;
|
||
|
|
}
|
||
|
|
// override each stream op with one that tries to force load the lazy file first
|
||
|
|
var stream_ops = {};
|
||
|
|
var keys = Object.keys(node.stream_ops);
|
||
|
|
keys.forEach(function(key) {
|
||
|
|
var fn = node.stream_ops[key];
|
||
|
|
stream_ops[key] = function forceLoadLazyFile() {
|
||
|
|
if (!FS.forceLoadFile(node)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EIO);
|
||
|
|
}
|
||
|
|
return fn.apply(null, arguments);
|
||
|
|
};
|
||
|
|
});
|
||
|
|
// use a custom read function
|
||
|
|
stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
|
||
|
|
if (!FS.forceLoadFile(node)) {
|
||
|
|
throw new FS.ErrnoError(ERRNO_CODES.EIO);
|
||
|
|
}
|
||
|
|
var contents = stream.node.contents;
|
||
|
|
if (position >= contents.length)
|
||
|
|
return 0;
|
||
|
|
var size = Math.min(contents.length - position, length);
|
||
|
|
assert(size >= 0);
|
||
|
|
if (contents.slice) { // normal array
|
||
|
|
for (var i = 0; i < size; i++) {
|
||
|
|
buffer[offset + i] = contents[position + i];
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
|
||
|
|
buffer[offset + i] = contents.get(position + i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return size;
|
||
|
|
};
|
||
|
|
node.stream_ops = stream_ops;
|
||
|
|
return node;
|
||
|
|
},createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn) {
|
||
|
|
Browser.init();
|
||
|
|
// TODO we should allow people to just pass in a complete filename instead
|
||
|
|
// of parent and name being that we just join them anyways
|
||
|
|
var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent;
|
||
|
|
function processData(byteArray) {
|
||
|
|
function finish(byteArray) {
|
||
|
|
if (!dontCreateFile) {
|
||
|
|
FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
|
||
|
|
}
|
||
|
|
if (onload) onload();
|
||
|
|
removeRunDependency('cp ' + fullname);
|
||
|
|
}
|
||
|
|
var handled = false;
|
||
|
|
Module['preloadPlugins'].forEach(function(plugin) {
|
||
|
|
if (handled) return;
|
||
|
|
if (plugin['canHandle'](fullname)) {
|
||
|
|
plugin['handle'](byteArray, fullname, finish, function() {
|
||
|
|
if (onerror) onerror();
|
||
|
|
removeRunDependency('cp ' + fullname);
|
||
|
|
});
|
||
|
|
handled = true;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
if (!handled) finish(byteArray);
|
||
|
|
}
|
||
|
|
addRunDependency('cp ' + fullname);
|
||
|
|
if (typeof url == 'string') {
|
||
|
|
Browser.asyncLoad(url, function(byteArray) {
|
||
|
|
processData(byteArray);
|
||
|
|
}, onerror);
|
||
|
|
} else {
|
||
|
|
processData(url);
|
||
|
|
}
|
||
|
|
},indexedDB:function () {
|
||
|
|
return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
|
||
|
|
},DB_NAME:function () {
|
||
|
|
return 'EM_FS_' + window.location.pathname;
|
||
|
|
},DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function (paths, onload, onerror) {
|
||
|
|
onload = onload || function(){};
|
||
|
|
onerror = onerror || function(){};
|
||
|
|
var indexedDB = FS.indexedDB();
|
||
|
|
try {
|
||
|
|
var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
|
||
|
|
} catch (e) {
|
||
|
|
return onerror(e);
|
||
|
|
}
|
||
|
|
openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
|
||
|
|
console.log('creating db');
|
||
|
|
var db = openRequest.result;
|
||
|
|
db.createObjectStore(FS.DB_STORE_NAME);
|
||
|
|
};
|
||
|
|
openRequest.onsuccess = function openRequest_onsuccess() {
|
||
|
|
var db = openRequest.result;
|
||
|
|
var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
|
||
|
|
var files = transaction.objectStore(FS.DB_STORE_NAME);
|
||
|
|
var ok = 0, fail = 0, total = paths.length;
|
||
|
|
function finish() {
|
||
|
|
if (fail == 0) onload(); else onerror();
|
||
|
|
}
|
||
|
|
paths.forEach(function(path) {
|
||
|
|
var putRequest = files.put(FS.analyzePath(path).object.contents, path);
|
||
|
|
putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
|
||
|
|
putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
|
||
|
|
});
|
||
|
|
transaction.onerror = onerror;
|
||
|
|
};
|
||
|
|
openRequest.onerror = onerror;
|
||
|
|
},loadFilesFromDB:function (paths, onload, onerror) {
|
||
|
|
onload = onload || function(){};
|
||
|
|
onerror = onerror || function(){};
|
||
|
|
var indexedDB = FS.indexedDB();
|
||
|
|
try {
|
||
|
|
var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
|
||
|
|
} catch (e) {
|
||
|
|
return onerror(e);
|
||
|
|
}
|
||
|
|
openRequest.onupgradeneeded = onerror; // no database to load from
|
||
|
|
openRequest.onsuccess = function openRequest_onsuccess() {
|
||
|
|
var db = openRequest.result;
|
||
|
|
try {
|
||
|
|
var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
|
||
|
|
} catch(e) {
|
||
|
|
onerror(e);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var files = transaction.objectStore(FS.DB_STORE_NAME);
|
||
|
|
var ok = 0, fail = 0, total = paths.length;
|
||
|
|
function finish() {
|
||
|
|
if (fail == 0) onload(); else onerror();
|
||
|
|
}
|
||
|
|
paths.forEach(function(path) {
|
||
|
|
var getRequest = files.get(path);
|
||
|
|
getRequest.onsuccess = function getRequest_onsuccess() {
|
||
|
|
if (FS.analyzePath(path).exists) {
|
||
|
|
FS.unlink(path);
|
||
|
|
}
|
||
|
|
FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
|
||
|
|
ok++;
|
||
|
|
if (ok + fail == total) finish();
|
||
|
|
};
|
||
|
|
getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
|
||
|
|
});
|
||
|
|
transaction.onerror = onerror;
|
||
|
|
};
|
||
|
|
openRequest.onerror = onerror;
|
||
|
|
}};var PATH={splitPath:function (filename) {
|
||
|
|
var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
|
||
|
|
return splitPathRe.exec(filename).slice(1);
|
||
|
|
},normalizeArray:function (parts, allowAboveRoot) {
|
||
|
|
// if the path tries to go above the root, `up` ends up > 0
|
||
|
|
var up = 0;
|
||
|
|
for (var i = parts.length - 1; i >= 0; i--) {
|
||
|
|
var last = parts[i];
|
||
|
|
if (last === '.') {
|
||
|
|
parts.splice(i, 1);
|
||
|
|
} else if (last === '..') {
|
||
|
|
parts.splice(i, 1);
|
||
|
|
up++;
|
||
|
|
} else if (up) {
|
||
|
|
parts.splice(i, 1);
|
||
|
|
up--;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// if the path is allowed to go above the root, restore leading ..s
|
||
|
|
if (allowAboveRoot) {
|
||
|
|
for (; up--; up) {
|
||
|
|
parts.unshift('..');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return parts;
|
||
|
|
},normalize:function (path) {
|
||
|
|
var isAbsolute = path.charAt(0) === '/',
|
||
|
|
trailingSlash = path.substr(-1) === '/';
|
||
|
|
// Normalize the path
|
||
|
|
path = PATH.normalizeArray(path.split('/').filter(function(p) {
|
||
|
|
return !!p;
|
||
|
|
}), !isAbsolute).join('/');
|
||
|
|
if (!path && !isAbsolute) {
|
||
|
|
path = '.';
|
||
|
|
}
|
||
|
|
if (path && trailingSlash) {
|
||
|
|
path += '/';
|
||
|
|
}
|
||
|
|
return (isAbsolute ? '/' : '') + path;
|
||
|
|
},dirname:function (path) {
|
||
|
|
var result = PATH.splitPath(path),
|
||
|
|
root = result[0],
|
||
|
|
dir = result[1];
|
||
|
|
if (!root && !dir) {
|
||
|
|
// No dirname whatsoever
|
||
|
|
return '.';
|
||
|
|
}
|
||
|
|
if (dir) {
|
||
|
|
// It has a dirname, strip trailing slash
|
||
|
|
dir = dir.substr(0, dir.length - 1);
|
||
|
|
}
|
||
|
|
return root + dir;
|
||
|
|
},basename:function (path) {
|
||
|
|
// EMSCRIPTEN return '/'' for '/', not an empty string
|
||
|
|
if (path === '/') return '/';
|
||
|
|
var lastSlash = path.lastIndexOf('/');
|
||
|
|
if (lastSlash === -1) return path;
|
||
|
|
return path.substr(lastSlash+1);
|
||
|
|
},extname:function (path) {
|
||
|
|
return PATH.splitPath(path)[3];
|
||
|
|
},join:function () {
|
||
|
|
var paths = Array.prototype.slice.call(arguments, 0);
|
||
|
|
return PATH.normalize(paths.join('/'));
|
||
|
|
},join2:function (l, r) {
|
||
|
|
return PATH.normalize(l + '/' + r);
|
||
|
|
},resolve:function () {
|
||
|
|
var resolvedPath = '',
|
||
|
|
resolvedAbsolute = false;
|
||
|
|
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
||
|
|
var path = (i >= 0) ? arguments[i] : FS.cwd();
|
||
|
|
// Skip empty and invalid entries
|
||
|
|
if (typeof path !== 'string') {
|
||
|
|
throw new TypeError('Arguments to path.resolve must be strings');
|
||
|
|
} else if (!path) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
resolvedPath = path + '/' + resolvedPath;
|
||
|
|
resolvedAbsolute = path.charAt(0) === '/';
|
||
|
|
}
|
||
|
|
// At this point the path should be resolved to a full absolute path, but
|
||
|
|
// handle relative paths to be safe (might happen when process.cwd() fails)
|
||
|
|
resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) {
|
||
|
|
return !!p;
|
||
|
|
}), !resolvedAbsolute).join('/');
|
||
|
|
return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
|
||
|
|
},relative:function (from, to) {
|
||
|
|
from = PATH.resolve(from).substr(1);
|
||
|
|
to = PATH.resolve(to).substr(1);
|
||
|
|
function trim(arr) {
|
||
|
|
var start = 0;
|
||
|
|
for (; start < arr.length; start++) {
|
||
|
|
if (arr[start] !== '') break;
|
||
|
|
}
|
||
|
|
var end = arr.length - 1;
|
||
|
|
for (; end >= 0; end--) {
|
||
|
|
if (arr[end] !== '') break;
|
||
|
|
}
|
||
|
|
if (start > end) return [];
|
||
|
|
return arr.slice(start, end - start + 1);
|
||
|
|
}
|
||
|
|
var fromParts = trim(from.split('/'));
|
||
|
|
var toParts = trim(to.split('/'));
|
||
|
|
var length = Math.min(fromParts.length, toParts.length);
|
||
|
|
var samePartsLength = length;
|
||
|
|
for (var i = 0; i < length; i++) {
|
||
|
|
if (fromParts[i] !== toParts[i]) {
|
||
|
|
samePartsLength = i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var outputParts = [];
|
||
|
|
for (var i = samePartsLength; i < fromParts.length; i++) {
|
||
|
|
outputParts.push('..');
|
||
|
|
}
|
||
|
|
outputParts = outputParts.concat(toParts.slice(samePartsLength));
|
||
|
|
return outputParts.join('/');
|
||
|
|
}};var Browser={mainLoop:{scheduler:null,shouldPause:false,paused:false,queue:[],pause:function () {
|
||
|
|
Browser.mainLoop.shouldPause = true;
|
||
|
|
},resume:function () {
|
||
|
|
if (Browser.mainLoop.paused) {
|
||
|
|
Browser.mainLoop.paused = false;
|
||
|
|
Browser.mainLoop.scheduler();
|
||
|
|
}
|
||
|
|
Browser.mainLoop.shouldPause = false;
|
||
|
|
},updateStatus:function () {
|
||
|
|
if (Module['setStatus']) {
|
||
|
|
var message = Module['statusMessage'] || 'Please wait...';
|
||
|
|
var remaining = Browser.mainLoop.remainingBlockers;
|
||
|
|
var expected = Browser.mainLoop.expectedBlockers;
|
||
|
|
if (remaining) {
|
||
|
|
if (remaining < expected) {
|
||
|
|
Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
|
||
|
|
} else {
|
||
|
|
Module['setStatus'](message);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
Module['setStatus']('');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}},isFullScreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],init:function () {
|
||
|
|
if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
|
||
|
|
|
||
|
|
if (Browser.initted || ENVIRONMENT_IS_WORKER) return;
|
||
|
|
Browser.initted = true;
|
||
|
|
|
||
|
|
try {
|
||
|
|
new Blob();
|
||
|
|
Browser.hasBlobConstructor = true;
|
||
|
|
} catch(e) {
|
||
|
|
Browser.hasBlobConstructor = false;
|
||
|
|
console.log("warning: no blob constructor, cannot create blobs with mimetypes");
|
||
|
|
}
|
||
|
|
Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
|
||
|
|
Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
|
||
|
|
if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
|
||
|
|
console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
|
||
|
|
Module.noImageDecoding = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Support for plugins that can process preloaded files. You can add more of these to
|
||
|
|
// your app by creating and appending to Module.preloadPlugins.
|
||
|
|
//
|
||
|
|
// Each plugin is asked if it can handle a file based on the file's name. If it can,
|
||
|
|
// it is given the file's raw data. When it is done, it calls a callback with the file's
|
||
|
|
// (possibly modified) data. For example, a plugin might decompress a file, or it
|
||
|
|
// might create some side data structure for use later (like an Image element, etc.).
|
||
|
|
|
||
|
|
var imagePlugin = {};
|
||
|
|
imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
|
||
|
|
return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
|
||
|
|
};
|
||
|
|
imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
|
||
|
|
var b = null;
|
||
|
|
if (Browser.hasBlobConstructor) {
|
||
|
|
try {
|
||
|
|
b = new Blob([byteArray], { type: Browser.getMimetype(name) });
|
||
|
|
if (b.size !== byteArray.length) { // Safari bug #118630
|
||
|
|
// Safari's Blob can only take an ArrayBuffer
|
||
|
|
b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
|
||
|
|
}
|
||
|
|
} catch(e) {
|
||
|
|
Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!b) {
|
||
|
|
var bb = new Browser.BlobBuilder();
|
||
|
|
bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
|
||
|
|
b = bb.getBlob();
|
||
|
|
}
|
||
|
|
var url = Browser.URLObject.createObjectURL(b);
|
||
|
|
assert(typeof url == 'string', 'createObjectURL must return a url as a string');
|
||
|
|
var img = new Image();
|
||
|
|
img.onload = function img_onload() {
|
||
|
|
assert(img.complete, 'Image ' + name + ' could not be decoded');
|
||
|
|
var canvas = document.createElement('canvas');
|
||
|
|
canvas.width = img.width;
|
||
|
|
canvas.height = img.height;
|
||
|
|
var ctx = canvas.getContext('2d');
|
||
|
|
ctx.drawImage(img, 0, 0);
|
||
|
|
Module["preloadedImages"][name] = canvas;
|
||
|
|
Browser.URLObject.revokeObjectURL(url);
|
||
|
|
if (onload) onload(byteArray);
|
||
|
|
};
|
||
|
|
img.onerror = function img_onerror(event) {
|
||
|
|
console.log('Image ' + url + ' could not be decoded');
|
||
|
|
if (onerror) onerror();
|
||
|
|
};
|
||
|
|
img.src = url;
|
||
|
|
};
|
||
|
|
Module['preloadPlugins'].push(imagePlugin);
|
||
|
|
|
||
|
|
var audioPlugin = {};
|
||
|
|
audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
|
||
|
|
return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
|
||
|
|
};
|
||
|
|
audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
|
||
|
|
var done = false;
|
||
|
|
function finish(audio) {
|
||
|
|
if (done) return;
|
||
|
|
done = true;
|
||
|
|
Module["preloadedAudios"][name] = audio;
|
||
|
|
if (onload) onload(byteArray);
|
||
|
|
}
|
||
|
|
function fail() {
|
||
|
|
if (done) return;
|
||
|
|
done = true;
|
||
|
|
Module["preloadedAudios"][name] = new Audio(); // empty shim
|
||
|
|
if (onerror) onerror();
|
||
|
|
}
|
||
|
|
if (Browser.hasBlobConstructor) {
|
||
|
|
try {
|
||
|
|
var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
|
||
|
|
} catch(e) {
|
||
|
|
return fail();
|
||
|
|
}
|
||
|
|
var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
|
||
|
|
assert(typeof url == 'string', 'createObjectURL must return a url as a string');
|
||
|
|
var audio = new Audio();
|
||
|
|
audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
|
||
|
|
audio.onerror = function audio_onerror(event) {
|
||
|
|
if (done) return;
|
||
|
|
console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
|
||
|
|
function encode64(data) {
|
||
|
|
var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
||
|
|
var PAD = '=';
|
||
|
|
var ret = '';
|
||
|
|
var leftchar = 0;
|
||
|
|
var leftbits = 0;
|
||
|
|
for (var i = 0; i < data.length; i++) {
|
||
|
|
leftchar = (leftchar << 8) | data[i];
|
||
|
|
leftbits += 8;
|
||
|
|
while (leftbits >= 6) {
|
||
|
|
var curr = (leftchar >> (leftbits-6)) & 0x3f;
|
||
|
|
leftbits -= 6;
|
||
|
|
ret += BASE[curr];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (leftbits == 2) {
|
||
|
|
ret += BASE[(leftchar&3) << 4];
|
||
|
|
ret += PAD + PAD;
|
||
|
|
} else if (leftbits == 4) {
|
||
|
|
ret += BASE[(leftchar&0xf) << 2];
|
||
|
|
ret += PAD;
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
|
||
|
|
finish(audio); // we don't wait for confirmation this worked - but it's worth trying
|
||
|
|
};
|
||
|
|
audio.src = url;
|
||
|
|
// workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
|
||
|
|
Browser.safeSetTimeout(function() {
|
||
|
|
finish(audio); // try to use it even though it is not necessarily ready to play
|
||
|
|
}, 10000);
|
||
|
|
} else {
|
||
|
|
return fail();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Module['preloadPlugins'].push(audioPlugin);
|
||
|
|
|
||
|
|
// Canvas event setup
|
||
|
|
|
||
|
|
var canvas = Module['canvas'];
|
||
|
|
canvas.requestPointerLock = canvas['requestPointerLock'] ||
|
||
|
|
canvas['mozRequestPointerLock'] ||
|
||
|
|
canvas['webkitRequestPointerLock'];
|
||
|
|
canvas.exitPointerLock = document['exitPointerLock'] ||
|
||
|
|
document['mozExitPointerLock'] ||
|
||
|
|
document['webkitExitPointerLock'] ||
|
||
|
|
function(){}; // no-op if function does not exist
|
||
|
|
canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
|
||
|
|
|
||
|
|
function pointerLockChange() {
|
||
|
|
Browser.pointerLock = document['pointerLockElement'] === canvas ||
|
||
|
|
document['mozPointerLockElement'] === canvas ||
|
||
|
|
document['webkitPointerLockElement'] === canvas;
|
||
|
|
}
|
||
|
|
|
||
|
|
document.addEventListener('pointerlockchange', pointerLockChange, false);
|
||
|
|
document.addEventListener('mozpointerlockchange', pointerLockChange, false);
|
||
|
|
document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
|
||
|
|
|
||
|
|
if (Module['elementPointerLock']) {
|
||
|
|
canvas.addEventListener("click", function(ev) {
|
||
|
|
if (!Browser.pointerLock && canvas.requestPointerLock) {
|
||
|
|
canvas.requestPointerLock();
|
||
|
|
ev.preventDefault();
|
||
|
|
}
|
||
|
|
}, false);
|
||
|
|
}
|
||
|
|
},createContext:function (canvas, useWebGL, setInModule, webGLContextAttributes) {
|
||
|
|
var ctx;
|
||
|
|
try {
|
||
|
|
if (useWebGL) {
|
||
|
|
var contextAttributes = {
|
||
|
|
antialias: false,
|
||
|
|
alpha: false
|
||
|
|
};
|
||
|
|
|
||
|
|
if (webGLContextAttributes) {
|
||
|
|
for (var attribute in webGLContextAttributes) {
|
||
|
|
contextAttributes[attribute] = webGLContextAttributes[attribute];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
var errorInfo = '?';
|
||
|
|
function onContextCreationError(event) {
|
||
|
|
errorInfo = event.statusMessage || errorInfo;
|
||
|
|
}
|
||
|
|
canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
|
||
|
|
try {
|
||
|
|
['experimental-webgl', 'webgl'].some(function(webglId) {
|
||
|
|
return ctx = canvas.getContext(webglId, contextAttributes);
|
||
|
|
});
|
||
|
|
} finally {
|
||
|
|
canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
ctx = canvas.getContext('2d');
|
||
|
|
}
|
||
|
|
if (!ctx) throw ':(';
|
||
|
|
} catch (e) {
|
||
|
|
Module.print('Could not create canvas: ' + [errorInfo, e]);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
if (useWebGL) {
|
||
|
|
// Set the background of the WebGL canvas to black
|
||
|
|
canvas.style.backgroundColor = "black";
|
||
|
|
|
||
|
|
// Warn on context loss
|
||
|
|
canvas.addEventListener('webglcontextlost', function(event) {
|
||
|
|
alert('WebGL context lost. You will need to reload the page.');
|
||
|
|
}, false);
|
||
|
|
}
|
||
|
|
if (setInModule) {
|
||
|
|
GLctx = Module.ctx = ctx;
|
||
|
|
Module.useWebGL = useWebGL;
|
||
|
|
Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
|
||
|
|
Browser.init();
|
||
|
|
}
|
||
|
|
return ctx;
|
||
|
|
},destroyContext:function (canvas, useWebGL, setInModule) {},fullScreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullScreen:function (lockPointer, resizeCanvas) {
|
||
|
|
Browser.lockPointer = lockPointer;
|
||
|
|
Browser.resizeCanvas = resizeCanvas;
|
||
|
|
if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
|
||
|
|
if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
|
||
|
|
|
||
|
|
var canvas = Module['canvas'];
|
||
|
|
function fullScreenChange() {
|
||
|
|
Browser.isFullScreen = false;
|
||
|
|
if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
|
||
|
|
document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
|
||
|
|
document['fullScreenElement'] || document['fullscreenElement']) === canvas) {
|
||
|
|
canvas.cancelFullScreen = document['cancelFullScreen'] ||
|
||
|
|
document['mozCancelFullScreen'] ||
|
||
|
|
document['webkitCancelFullScreen'];
|
||
|
|
canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document);
|
||
|
|
if (Browser.lockPointer) canvas.requestPointerLock();
|
||
|
|
Browser.isFullScreen = true;
|
||
|
|
if (Browser.resizeCanvas) Browser.setFullScreenCanvasSize();
|
||
|
|
} else if (Browser.resizeCanvas){
|
||
|
|
Browser.setWindowedCanvasSize();
|
||
|
|
}
|
||
|
|
if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!Browser.fullScreenHandlersInstalled) {
|
||
|
|
Browser.fullScreenHandlersInstalled = true;
|
||
|
|
document.addEventListener('fullscreenchange', fullScreenChange, false);
|
||
|
|
document.addEventListener('mozfullscreenchange', fullScreenChange, false);
|
||
|
|
document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
canvas.requestFullScreen = canvas['requestFullScreen'] ||
|
||
|
|
canvas['mozRequestFullScreen'] ||
|
||
|
|
(canvas['webkitRequestFullScreen'] ? function() { canvas['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
|
||
|
|
canvas.requestFullScreen();
|
||
|
|
},requestAnimationFrame:function requestAnimationFrame(func) {
|
||
|
|
if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
|
||
|
|
setTimeout(func, 1000/60);
|
||
|
|
} else {
|
||
|
|
if (!window.requestAnimationFrame) {
|
||
|
|
window.requestAnimationFrame = window['requestAnimationFrame'] ||
|
||
|
|
window['mozRequestAnimationFrame'] ||
|
||
|
|
window['webkitRequestAnimationFrame'] ||
|
||
|
|
window['msRequestAnimationFrame'] ||
|
||
|
|
window['oRequestAnimationFrame'] ||
|
||
|
|
window['setTimeout'];
|
||
|
|
}
|
||
|
|
window.requestAnimationFrame(func);
|
||
|
|
}
|
||
|
|
},safeCallback:function (func) {
|
||
|
|
return function() {
|
||
|
|
if (!ABORT) return func.apply(null, arguments);
|
||
|
|
};
|
||
|
|
},safeRequestAnimationFrame:function (func) {
|
||
|
|
return Browser.requestAnimationFrame(function() {
|
||
|
|
if (!ABORT) func();
|
||
|
|
});
|
||
|
|
},safeSetTimeout:function (func, timeout) {
|
||
|
|
return setTimeout(function() {
|
||
|
|
if (!ABORT) func();
|
||
|
|
}, timeout);
|
||
|
|
},safeSetInterval:function (func, timeout) {
|
||
|
|
return setInterval(function() {
|
||
|
|
if (!ABORT) func();
|
||
|
|
}, timeout);
|
||
|
|
},getMimetype:function (name) {
|
||
|
|
return {
|
||
|
|
'jpg': 'image/jpeg',
|
||
|
|
'jpeg': 'image/jpeg',
|
||
|
|
'png': 'image/png',
|
||
|
|
'bmp': 'image/bmp',
|
||
|
|
'ogg': 'audio/ogg',
|
||
|
|
'wav': 'audio/wav',
|
||
|
|
'mp3': 'audio/mpeg'
|
||
|
|
}[name.substr(name.lastIndexOf('.')+1)];
|
||
|
|
},getUserMedia:function (func) {
|
||
|
|
if(!window.getUserMedia) {
|
||
|
|
window.getUserMedia = navigator['getUserMedia'] ||
|
||
|
|
navigator['mozGetUserMedia'];
|
||
|
|
}
|
||
|
|
window.getUserMedia(func);
|
||
|
|
},getMovementX:function (event) {
|
||
|
|
return event['movementX'] ||
|
||
|
|
event['mozMovementX'] ||
|
||
|
|
event['webkitMovementX'] ||
|
||
|
|
0;
|
||
|
|
},getMovementY:function (event) {
|
||
|
|
return event['movementY'] ||
|
||
|
|
event['mozMovementY'] ||
|
||
|
|
event['webkitMovementY'] ||
|
||
|
|
0;
|
||
|
|
},mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,calculateMouseEvent:function (event) { // event should be mousemove, mousedown or mouseup
|
||
|
|
if (Browser.pointerLock) {
|
||
|
|
// When the pointer is locked, calculate the coordinates
|
||
|
|
// based on the movement of the mouse.
|
||
|
|
// Workaround for Firefox bug 764498
|
||
|
|
if (event.type != 'mousemove' &&
|
||
|
|
('mozMovementX' in event)) {
|
||
|
|
Browser.mouseMovementX = Browser.mouseMovementY = 0;
|
||
|
|
} else {
|
||
|
|
Browser.mouseMovementX = Browser.getMovementX(event);
|
||
|
|
Browser.mouseMovementY = Browser.getMovementY(event);
|
||
|
|
}
|
||
|
|
|
||
|
|
// check if SDL is available
|
||
|
|
if (typeof SDL != "undefined") {
|
||
|
|
Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
|
||
|
|
Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
|
||
|
|
} else {
|
||
|
|
// just add the mouse delta to the current absolut mouse position
|
||
|
|
// FIXME: ideally this should be clamped against the canvas size and zero
|
||
|
|
Browser.mouseX += Browser.mouseMovementX;
|
||
|
|
Browser.mouseY += Browser.mouseMovementY;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// Otherwise, calculate the movement based on the changes
|
||
|
|
// in the coordinates.
|
||
|
|
var rect = Module["canvas"].getBoundingClientRect();
|
||
|
|
var x, y;
|
||
|
|
|
||
|
|
// Neither .scrollX or .pageXOffset are defined in a spec, but
|
||
|
|
// we prefer .scrollX because it is currently in a spec draft.
|
||
|
|
// (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
|
||
|
|
var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset);
|
||
|
|
var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset);
|
||
|
|
// If this assert lands, it's likely because the browser doesn't support scrollX or pageXOffset
|
||
|
|
// and we have no viable fallback.
|
||
|
|
assert((typeof scrollX !== 'undefined') && (typeof scrollY !== 'undefined'), 'Unable to retrieve scroll position, mouse positions likely broken.');
|
||
|
|
if (event.type == 'touchstart' ||
|
||
|
|
event.type == 'touchend' ||
|
||
|
|
event.type == 'touchmove') {
|
||
|
|
var t = event.touches.item(0);
|
||
|
|
if (t) {
|
||
|
|
x = t.pageX - (scrollX + rect.left);
|
||
|
|
y = t.pageY - (scrollY + rect.top);
|
||
|
|
} else {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
x = event.pageX - (scrollX + rect.left);
|
||
|
|
y = event.pageY - (scrollY + rect.top);
|
||
|
|
}
|
||
|
|
|
||
|
|
// the canvas might be CSS-scaled compared to its backbuffer;
|
||
|
|
// SDL-using content will want mouse coordinates in terms
|
||
|
|
// of backbuffer units.
|
||
|
|
var cw = Module["canvas"].width;
|
||
|
|
var ch = Module["canvas"].height;
|
||
|
|
x = x * (cw / rect.width);
|
||
|
|
y = y * (ch / rect.height);
|
||
|
|
|
||
|
|
Browser.mouseMovementX = x - Browser.mouseX;
|
||
|
|
Browser.mouseMovementY = y - Browser.mouseY;
|
||
|
|
Browser.mouseX = x;
|
||
|
|
Browser.mouseY = y;
|
||
|
|
}
|
||
|
|
},xhrLoad:function (url, onload, onerror) {
|
||
|
|
var xhr = new XMLHttpRequest();
|
||
|
|
xhr.open('GET', url, true);
|
||
|
|
xhr.responseType = 'arraybuffer';
|
||
|
|
xhr.onload = function xhr_onload() {
|
||
|
|
if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
|
||
|
|
onload(xhr.response);
|
||
|
|
} else {
|
||
|
|
onerror();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
xhr.onerror = onerror;
|
||
|
|
xhr.send(null);
|
||
|
|
},asyncLoad:function (url, onload, onerror, noRunDep) {
|
||
|
|
Browser.xhrLoad(url, function(arrayBuffer) {
|
||
|
|
assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
|
||
|
|
onload(new Uint8Array(arrayBuffer));
|
||
|
|
if (!noRunDep) removeRunDependency('al ' + url);
|
||
|
|
}, function(event) {
|
||
|
|
if (onerror) {
|
||
|
|
onerror();
|
||
|
|
} else {
|
||
|
|
throw 'Loading data file "' + url + '" failed.';
|
||
|
|
}
|
||
|
|
});
|
||
|
|
if (!noRunDep) addRunDependency('al ' + url);
|
||
|
|
},resizeListeners:[],updateResizeListeners:function () {
|
||
|
|
var canvas = Module['canvas'];
|
||
|
|
Browser.resizeListeners.forEach(function(listener) {
|
||
|
|
listener(canvas.width, canvas.height);
|
||
|
|
});
|
||
|
|
},setCanvasSize:function (width, height, noUpdates) {
|
||
|
|
var canvas = Module['canvas'];
|
||
|
|
canvas.width = width;
|
||
|
|
canvas.height = height;
|
||
|
|
if (!noUpdates) Browser.updateResizeListeners();
|
||
|
|
},windowedWidth:0,windowedHeight:0,setFullScreenCanvasSize:function () {
|
||
|
|
var canvas = Module['canvas'];
|
||
|
|
this.windowedWidth = canvas.width;
|
||
|
|
this.windowedHeight = canvas.height;
|
||
|
|
canvas.width = screen.width;
|
||
|
|
canvas.height = screen.height;
|
||
|
|
// check if SDL is available
|
||
|
|
if (typeof SDL != "undefined") {
|
||
|
|
var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
|
||
|
|
flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
|
||
|
|
HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
|
||
|
|
}
|
||
|
|
Browser.updateResizeListeners();
|
||
|
|
},setWindowedCanvasSize:function () {
|
||
|
|
var canvas = Module['canvas'];
|
||
|
|
canvas.width = this.windowedWidth;
|
||
|
|
canvas.height = this.windowedHeight;
|
||
|
|
// check if SDL is available
|
||
|
|
if (typeof SDL != "undefined") {
|
||
|
|
var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
|
||
|
|
flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
|
||
|
|
HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
|
||
|
|
}
|
||
|
|
Browser.updateResizeListeners();
|
||
|
|
}};
|
||
|
|
___errno_state = Runtime.staticAlloc(4); HEAP32[((___errno_state)>>2)]=0;
|
||
|
|
Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };
|
||
|
|
Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };
|
||
|
|
Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };
|
||
|
|
Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };
|
||
|
|
Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };
|
||
|
|
Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }
|
||
|
|
FS.staticInit();__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });__ATEXIT__.push({ func: function() { FS.quit() } });Module["FS_createFolder"] = FS.createFolder;Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createLink"] = FS.createLink;Module["FS_createDevice"] = FS.createDevice;
|
||
|
|
__ATINIT__.unshift({ func: function() { TTY.init() } });__ATEXIT__.push({ func: function() { TTY.shutdown() } });TTY.utf8 = new Runtime.UTF8Processor();
|
||
|
|
if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
|
||
|
|
STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
|
||
|
|
|
||
|
|
staticSealed = true; // seal the static portion of memory
|
||
|
|
|
||
|
|
STACK_MAX = STACK_BASE + 5242880;
|
||
|
|
|
||
|
|
DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);
|
||
|
|
|
||
|
|
assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack");
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
var FUNCTION_TABLE = [0, 0];
|
||
|
|
|
||
|
|
// EMSCRIPTEN_START_FUNCS
|
||
|
|
|
||
|
|
function _bitmap_decompress_15($output,$output_width,$output_height,$input_width,$input_height,$input,$size){
|
||
|
|
var label=0;
|
||
|
|
var sp=STACKTOP; (assert((STACKTOP|0) < (STACK_MAX|0))|0);
|
||
|
|
label = 1;
|
||
|
|
while(1)switch(label){
|
||
|
|
case 1:
|
||
|
|
var $1;
|
||
|
|
var $2;
|
||
|
|
var $3;
|
||
|
|
var $4;
|
||
|
|
var $5;
|
||
|
|
var $6;
|
||
|
|
var $7;
|
||
|
|
var $temp;
|
||
|
|
var $rv;
|
||
|
|
var $y;
|
||
|
|
var $x;
|
||
|
|
var $a;
|
||
|
|
var $r;
|
||
|
|
var $g;
|
||
|
|
var $b;
|
||
|
|
$1=$output;
|
||
|
|
$2=$output_width;
|
||
|
|
$3=$output_height;
|
||
|
|
$4=$input_width;
|
||
|
|
$5=$input_height;
|
||
|
|
$6=$input;
|
||
|
|
$7=$size;
|
||
|
|
var $8=$4;
|
||
|
|
var $9=$5;
|
||
|
|
var $10=(Math_imul($8,$9)|0);
|
||
|
|
var $11=($10<<1);
|
||
|
|
var $12=_malloc($11);
|
||
|
|
$temp=$12;
|
||
|
|
var $13=$temp;
|
||
|
|
var $14=$4;
|
||
|
|
var $15=$5;
|
||
|
|
var $16=$6;
|
||
|
|
var $17=$7;
|
||
|
|
var $18=_bitmap_decompress2($13,$14,$15,$16,$17);
|
||
|
|
$rv=$18;
|
||
|
|
$y=0;
|
||
|
|
label=2;break;
|
||
|
|
case 2:
|
||
|
|
var $20=$y;
|
||
|
|
var $21=$3;
|
||
|
|
var $22=($20|0)<($21|0);
|
||
|
|
if($22){label=3;break;}else{label=9;break;}
|
||
|
|
case 3:
|
||
|
|
$x=0;
|
||
|
|
label=4;break;
|
||
|
|
case 4:
|
||
|
|
var $25=$x;
|
||
|
|
var $26=$2;
|
||
|
|
var $27=($25|0)<($26|0);
|
||
|
|
if($27){label=5;break;}else{label=7;break;}
|
||
|
|
case 5:
|
||
|
|
var $29=$y;
|
||
|
|
var $30=$4;
|
||
|
|
var $31=(Math_imul($29,$30)|0);
|
||
|
|
var $32=$x;
|
||
|
|
var $33=((($31)+($32))|0);
|
||
|
|
var $34=$temp;
|
||
|
|
var $35=$34;
|
||
|
|
var $36=(($35+($33<<1))|0);
|
||
|
|
var $37=HEAP16[(($36)>>1)];
|
||
|
|
$a=$37;
|
||
|
|
var $38=$a;
|
||
|
|
var $39=($38&65535);
|
||
|
|
var $40=$39&31744;
|
||
|
|
var $41=$40>>10;
|
||
|
|
var $42=(($41)&255);
|
||
|
|
$r=$42;
|
||
|
|
var $43=$a;
|
||
|
|
var $44=($43&65535);
|
||
|
|
var $45=$44&992;
|
||
|
|
var $46=$45>>5;
|
||
|
|
var $47=(($46)&255);
|
||
|
|
$g=$47;
|
||
|
|
var $48=$a;
|
||
|
|
var $49=($48&65535);
|
||
|
|
var $50=$49&31;
|
||
|
|
var $51=(($50)&255);
|
||
|
|
$b=$51;
|
||
|
|
var $52=$r;
|
||
|
|
var $53=($52&255);
|
||
|
|
var $54=((($53)*(255))&-1);
|
||
|
|
var $55=(((($54|0))/(31))&-1);
|
||
|
|
var $56=(($55)&255);
|
||
|
|
$r=$56;
|
||
|
|
var $57=$g;
|
||
|
|
var $58=($57&255);
|
||
|
|
var $59=((($58)*(255))&-1);
|
||
|
|
var $60=(((($59|0))/(31))&-1);
|
||
|
|
var $61=(($60)&255);
|
||
|
|
$g=$61;
|
||
|
|
var $62=$b;
|
||
|
|
var $63=($62&255);
|
||
|
|
var $64=((($63)*(255))&-1);
|
||
|
|
var $65=(((($64|0))/(31))&-1);
|
||
|
|
var $66=(($65)&255);
|
||
|
|
$b=$66;
|
||
|
|
var $67=$b;
|
||
|
|
var $68=($67&255);
|
||
|
|
var $69=$68<<16;
|
||
|
|
var $70=-16777216|$69;
|
||
|
|
var $71=$g;
|
||
|
|
var $72=($71&255);
|
||
|
|
var $73=$72<<8;
|
||
|
|
var $74=$70|$73;
|
||
|
|
var $75=$r;
|
||
|
|
var $76=($75&255);
|
||
|
|
var $77=$74|$76;
|
||
|
|
var $78=$y;
|
||
|
|
var $79=$2;
|
||
|
|
var $80=(Math_imul($78,$79)|0);
|
||
|
|
var $81=$x;
|
||
|
|
var $82=((($80)+($81))|0);
|
||
|
|
var $83=$1;
|
||
|
|
var $84=$83;
|
||
|
|
var $85=(($84+($82<<2))|0);
|
||
|
|
HEAP32[(($85)>>2)]=$77;
|
||
|
|
label=6;break;
|
||
|
|
case 6:
|
||
|
|
var $87=$x;
|
||
|
|
var $88=((($87)+(1))|0);
|
||
|
|
$x=$88;
|
||
|
|
label=4;break;
|
||
|
|
case 7:
|
||
|
|
label=8;break;
|
||
|
|
case 8:
|
||
|
|
var $91=$y;
|
||
|
|
var $92=((($91)+(1))|0);
|
||
|
|
$y=$92;
|
||
|
|
label=2;break;
|
||
|
|
case 9:
|
||
|
|
var $94=$temp;
|
||
|
|
_free($94);
|
||
|
|
var $95=$rv;
|
||
|
|
STACKTOP=sp;return $95;
|
||
|
|
default: assert(0, "bad label: " + label);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
Module["_bitmap_decompress_15"] = _bitmap_decompress_15;
|
||
|
|
|
||
|
|
function _bitmap_decompress2($output,$width,$height,$input,$size){
|
||
|
|
var label=0;
|
||
|
|
var sp=STACKTOP; (assert((STACKTOP|0) < (STACK_MAX|0))|0);
|
||
|
|
label = 1;
|
||
|
|
while(1)switch(label){
|
||
|
|
case 1:
|
||
|
|
var $1;
|
||
|
|
var $2;
|
||
|
|
var $3;
|
||
|
|
var $4;
|
||
|
|
var $5;
|
||
|
|
var $6;
|
||
|
|
var $end;
|
||
|
|
var $prevline;
|
||
|
|
var $line;
|
||
|
|
var $opcode;
|
||
|
|
var $count;
|
||
|
|
var $offset;
|
||
|
|
var $isfillormix;
|
||
|
|
var $x;
|
||
|
|
var $lastopcode;
|
||
|
|
var $insertmix;
|
||
|
|
var $bicolour;
|
||
|
|
var $code;
|
||
|
|
var $colour1;
|
||
|
|
var $colour2;
|
||
|
|
var $mixmask;
|
||
|
|
var $mask;
|
||
|
|
var $mix;
|
||
|
|
var $fom_mask;
|
||
|
|
$2=$output;
|
||
|
|
$3=$width;
|
||
|
|
$4=$height;
|
||
|
|
$5=$input;
|
||
|
|
$6=$size;
|
||
|
|
var $7=$5;
|
||
|
|
var $8=$6;
|
||
|
|
var $9=(($7+$8)|0);
|
||
|
|
$end=$9;
|
||
|
|
$prevline=0;
|
||
|
|
$line=0;
|
||
|
|
var $10=$3;
|
||
|
|
$x=$10;
|
||
|
|
$lastopcode=-1;
|
||
|
|
$insertmix=0;
|
||
|
|
$bicolour=0;
|
||
|
|
$colour1=0;
|
||
|
|
$colour2=0;
|
||
|
|
$mask=0;
|
||
|
|
$mix=-1;
|
||
|
|
$fom_mask=0;
|
||
|
|
label=2;break;
|
||
|
|
case 2:
|
||
|
|
var $12=$5;
|
||
|
|
var $13=$end;
|
||
|
|
var $14=($12>>>0)<($13>>>0);
|
||
|
|
if($14){label=3;break;}else{label=346;break;}
|
||
|
|
case 3:
|
||
|
|
$fom_mask=0;
|
||
|
|
var $16=$5;
|
||
|
|
var $17=(($16+1)|0);
|
||
|
|
$5=$17;
|
||
|
|
var $18=HEAP8[($16)];
|
||
|
|
$code=$18;
|
||
|
|
var $19=$code;
|
||
|
|
var $20=($19&255);
|
||
|
|
var $21=$20>>4;
|
||
|
|
$opcode=$21;
|
||
|
|
var $22=$opcode;
|
||
|
|
if(($22|0)==12|($22|0)==13|($22|0)==14){ label=4;break;}else if(($22|0)==15){ label=5;break;}else{label=9;break;}
|
||
|
|
case 4:
|
||
|
|
var $24=$opcode;
|
||
|
|
var $25=((($24)-(6))|0);
|
||
|
|
$opcode=$25;
|
||
|
|
var $26=$code;
|
||
|
|
var $27=($26&255);
|
||
|
|
var $28=$27&15;
|
||
|
|
$count=$28;
|
||
|
|
$offset=16;
|
||
|
|
label=10;break;
|
||
|
|
case 5:
|
||
|
|
var $30=$code;
|
||
|
|
var $31=($30&255);
|
||
|
|
var $32=$31&15;
|
||
|
|
$opcode=$32;
|
||
|
|
var $33=$opcode;
|
||
|
|
var $34=($33|0)<9;
|
||
|
|
if($34){label=6;break;}else{label=7;break;}
|
||
|
|
case 6:
|
||
|
|
var $36=$5;
|
||
|
|
var $37=(($36+1)|0);
|
||
|
|
$5=$37;
|
||
|
|
var $38=HEAP8[($36)];
|
||
|
|
var $39=($38&255);
|
||
|
|
$count=$39;
|
||
|
|
var $40=$5;
|
||
|
|
var $41=(($40+1)|0);
|
||
|
|
$5=$41;
|
||
|
|
var $42=HEAP8[($40)];
|
||
|
|
var $43=($42&255);
|
||
|
|
var $44=$43<<8;
|
||
|
|
var $45=$count;
|
||
|
|
var $46=$45|$44;
|
||
|
|
$count=$46;
|
||
|
|
label=8;break;
|
||
|
|
case 7:
|
||
|
|
var $48=$opcode;
|
||
|
|
var $49=($48|0)<11;
|
||
|
|
var $50=($49?8:1);
|
||
|
|
$count=$50;
|
||
|
|
label=8;break;
|
||
|
|
case 8:
|
||
|
|
$offset=0;
|
||
|
|
label=10;break;
|
||
|
|
case 9:
|
||
|
|
var $53=$opcode;
|
||
|
|
var $54=$53>>1;
|
||
|
|
$opcode=$54;
|
||
|
|
var $55=$code;
|
||
|
|
var $56=($55&255);
|
||
|
|
var $57=$56&31;
|
||
|
|
$count=$57;
|
||
|
|
$offset=32;
|
||
|
|
label=10;break;
|
||
|
|
case 10:
|
||
|
|
var $59=$offset;
|
||
|
|
var $60=($59|0)!=0;
|
||
|
|
if($60){label=11;break;}else{label=22;break;}
|
||
|
|
case 11:
|
||
|
|
var $62=$opcode;
|
||
|
|
var $63=($62|0)==2;
|
||
|
|
if($63){var $68=1;label=13;break;}else{label=12;break;}
|
||
|
|
case 12:
|
||
|
|
var $65=$opcode;
|
||
|
|
var $66=($65|0)==7;
|
||
|
|
var $68=$66;label=13;break;
|
||
|
|
case 13:
|
||
|
|
var $68;
|
||
|
|
var $69=($68&1);
|
||
|
|
$isfillormix=$69;
|
||
|
|
var $70=$count;
|
||
|
|
var $71=($70|0)==0;
|
||
|
|
if($71){label=14;break;}else{label=18;break;}
|
||
|
|
case 14:
|
||
|
|
var $73=$isfillormix;
|
||
|
|
var $74=($73|0)!=0;
|
||
|
|
if($74){label=15;break;}else{label=16;break;}
|
||
|
|
case 15:
|
||
|
|
var $76=$5;
|
||
|
|
var $77=(($76+1)|0);
|
||
|
|
$5=$77;
|
||
|
|
var $78=HEAP8[($76)];
|
||
|
|
var $79=($78&255);
|
||
|
|
var $80=((($79)+(1))|0);
|
||
|
|
$count=$80;
|
||
|
|
label=17;break;
|
||
|
|
case 16:
|
||
|
|
var $82=$5;
|
||
|
|
var $83=(($82+1)|0);
|
||
|
|
$5=$83;
|
||
|
|
var $84=HEAP8[($82)];
|
||
|
|
var $85=($84&255);
|
||
|
|
var $86=$offset;
|
||
|
|
var $87=((($85)+($86))|0);
|
||
|
|
$count=$87;
|
||
|
|
label=17;break;
|
||
|
|
case 17:
|
||
|
|
label=21;break;
|
||
|
|
case 18:
|
||
|
|
var $90=$isfillormix;
|
||
|
|
var $91=($90|0)!=0;
|
||
|
|
if($91){label=19;break;}else{label=20;break;}
|
||
|
|
case 19:
|
||
|
|
var $93=$count;
|
||
|
|
var $94=$93<<3;
|
||
|
|
$count=$94;
|
||
|
|
label=20;break;
|
||
|
|
case 20:
|
||
|
|
label=21;break;
|
||
|
|
case 21:
|
||
|
|
label=22;break;
|
||
|
|
case 22:
|
||
|
|
var $98=$opcode;
|
||
|
|
switch(($98|0)){case 0:{ label=23;break;}case 8:{ label=28;break;}case 3:{ label=29;break;}case 6:case 7:{ label=30;break;}case 9:{ label=31;break;}case 10:{ label=32;break;}default:{label=33;break;}}break;
|
||
|
|
case 23:
|
||
|
|
var $100=$lastopcode;
|
||
|
|
var $101=$opcode;
|
||
|
|
var $102=($100|0)==($101|0);
|
||
|
|
if($102){label=24;break;}else{label=27;break;}
|
||
|
|
case 24:
|
||
|
|
var $104=$x;
|
||
|
|
var $105=$3;
|
||
|
|
var $106=($104|0)==($105|0);
|
||
|
|
if($106){label=25;break;}else{label=26;break;}
|
||
|
|
case 25:
|
||
|
|
var $108=$prevline;
|
||
|
|
var $109=($108|0)==0;
|
||
|
|
if($109){label=27;break;}else{label=26;break;}
|
||
|
|
case 26:
|
||
|
|
$insertmix=1;
|
||
|
|
label=27;break;
|
||
|
|
case 27:
|
||
|
|
label=33;break;
|
||
|
|
case 28:
|
||
|
|
var $113=$5;
|
||
|
|
var $114=(($113+1)|0);
|
||
|
|
$5=$114;
|
||
|
|
var $115=HEAP8[($113)];
|
||
|
|
var $116=($115&255);
|
||
|
|
$colour1=$116;
|
||
|
|
var $117=$5;
|
||
|
|
var $118=(($117+1)|0);
|
||
|
|
$5=$118;
|
||
|
|
var $119=HEAP8[($117)];
|
||
|
|
var $120=($119&255);
|
||
|
|
var $121=$120<<8;
|
||
|
|
var $122=$colour1;
|
||
|
|
var $123=($122&65535);
|
||
|
|
var $124=$123|$121;
|
||
|
|
var $125=(($124)&65535);
|
||
|
|
$colour1=$125;
|
||
|
|
label=29;break;
|
||
|
|
case 29:
|
||
|
|
var $127=$5;
|
||
|
|
var $128=(($127+1)|0);
|
||
|
|
$5=$128;
|
||
|
|
var $129=HEAP8[($127)];
|
||
|
|
var $130=($129&255);
|
||
|
|
$colour2=$130;
|
||
|
|
var $131=$5;
|
||
|
|
var $132=(($131+1)|0);
|
||
|
|
$5=$132;
|
||
|
|
var $133=HEAP8[($131)];
|
||
|
|
var $134=($133&255);
|
||
|
|
var $135=$134<<8;
|
||
|
|
var $136=$colour2;
|
||
|
|
var $137=($136&65535);
|
||
|
|
var $138=$137|$135;
|
||
|
|
var $139=(($138)&65535);
|
||
|
|
$colour2=$139;
|
||
|
|
label=33;break;
|
||
|
|
case 30:
|
||
|
|
var $141=$5;
|
||
|
|
var $142=(($141+1)|0);
|
||
|
|
$5=$142;
|
||
|
|
var $143=HEAP8[($141)];
|
||
|
|
var $144=($143&255);
|
||
|
|
$mix=$144;
|
||
|
|
var $145=$5;
|
||
|
|
var $146=(($145+1)|0);
|
||
|
|
$5=$146;
|
||
|
|
var $147=HEAP8[($145)];
|
||
|
|
var $148=($147&255);
|
||
|
|
var $149=$148<<8;
|
||
|
|
var $150=$mix;
|
||
|
|
var $151=($150&65535);
|
||
|
|
var $152=$151|$149;
|
||
|
|
var $153=(($152)&65535);
|
||
|
|
$mix=$153;
|
||
|
|
var $154=$opcode;
|
||
|
|
var $155=((($154)-(5))|0);
|
||
|
|
$opcode=$155;
|
||
|
|
label=33;break;
|
||
|
|
case 31:
|
||
|
|
$mask=3;
|
||
|
|
$opcode=2;
|
||
|
|
$fom_mask=3;
|
||
|
|
label=33;break;
|
||
|
|
case 32:
|
||
|
|
$mask=5;
|
||
|
|
$opcode=2;
|
||
|
|
$fom_mask=5;
|
||
|
|
label=33;break;
|
||
|
|
case 33:
|
||
|
|
var $159=$opcode;
|
||
|
|
$lastopcode=$159;
|
||
|
|
$mixmask=0;
|
||
|
|
label=34;break;
|
||
|
|
case 34:
|
||
|
|
var $161=$count;
|
||
|
|
var $162=($161|0)>0;
|
||
|
|
if($162){label=35;break;}else{label=345;break;}
|
||
|
|
case 35:
|
||
|
|
var $164=$x;
|
||
|
|
var $165=$3;
|
||
|
|
var $166=($164|0)>=($165|0);
|
||
|
|
if($166){label=36;break;}else{label=39;break;}
|
||
|
|
case 36:
|
||
|
|
var $168=$4;
|
||
|
|
var $169=($168|0)<=0;
|
||
|
|
if($169){label=37;break;}else{label=38;break;}
|
||
|
|
case 37:
|
||
|
|
$1=0;
|
||
|
|
label=347;break;
|
||
|
|
case 38:
|
||
|
|
$x=0;
|
||
|
|
var $172=$4;
|
||
|
|
var $173=((($172)-(1))|0);
|
||
|
|
$4=$173;
|
||
|
|
var $174=$line;
|
||
|
|
$prevline=$174;
|
||
|
|
var $175=$2;
|
||
|
|
var $176=$175;
|
||
|
|
var $177=$4;
|
||
|
|
var $178=$3;
|
||
|
|
var $179=(Math_imul($177,$178)|0);
|
||
|
|
var $180=(($176+($179<<1))|0);
|
||
|
|
$line=$180;
|
||
|
|
label=39;break;
|
||
|
|
case 39:
|
||
|
|
var $182=$opcode;
|
||
|
|
switch(($182|0)){case 3:{ label=261;break;}case 4:{ label=272;break;}case 8:{ label=283;break;}case 13:{ label=321;break;}case 14:{ label=332;break;}case 0:{ label=40;break;}case 1:{ label=69;break;}case 2:{ label=93;break;}default:{label=343;break;}}break;
|
||
|
|
case 40:
|
||
|
|
var $184=$insertmix;
|
||
|
|
var $185=($184|0)!=0;
|
||
|
|
if($185){label=41;break;}else{label=45;break;}
|
||
|
|
case 41:
|
||
|
|
var $187=$prevline;
|
||
|
|
var $188=($187|0)==0;
|
||
|
|
if($188){label=42;break;}else{label=43;break;}
|
||
|
|
case 42:
|
||
|
|
var $190=$mix;
|
||
|
|
var $191=$x;
|
||
|
|
var $192=$line;
|
||
|
|
var $193=(($192+($191<<1))|0);
|
||
|
|
HEAP16[(($193)>>1)]=$190;
|
||
|
|
label=44;break;
|
||
|
|
case 43:
|
||
|
|
var $195=$x;
|
||
|
|
var $196=$prevline;
|
||
|
|
var $197=(($196+($195<<1))|0);
|
||
|
|
var $198=HEAP16[(($197)>>1)];
|
||
|
|
var $199=($198&65535);
|
||
|
|
var $200=$mix;
|
||
|
|
var $201=($200&65535);
|
||
|
|
var $202=$199^$201;
|
||
|
|
var $203=(($202)&65535);
|
||
|
|
var $204=$x;
|
||
|
|
var $205=$line;
|
||
|
|
var $206=(($205+($204<<1))|0);
|
||
|
|
HEAP16[(($206)>>1)]=$203;
|
||
|
|
label=44;break;
|
||
|
|
case 44:
|
||
|
|
$insertmix=0;
|
||
|
|
var $208=$count;
|
||
|
|
var $209=((($208)-(1))|0);
|
||
|
|
$count=$209;
|
||
|
|
var $210=$x;
|
||
|
|
var $211=((($210)+(1))|0);
|
||
|
|
$x=$211;
|
||
|
|
label=45;break;
|
||
|
|
case 45:
|
||
|
|
var $213=$prevline;
|
||
|
|
var $214=($213|0)==0;
|
||
|
|
if($214){label=46;break;}else{label=57;break;}
|
||
|
|
case 46:
|
||
|
|
label=47;break;
|
||
|
|
case 47:
|
||
|
|
var $217=$count;
|
||
|
|
var $218=$217&-8;
|
||
|
|
var $219=($218|0)!=0;
|
||
|
|
if($219){label=48;break;}else{var $226=0;label=49;break;}
|
||
|
|
case 48:
|
||
|
|
var $221=$x;
|
||
|
|
var $222=((($221)+(8))|0);
|
||
|
|
var $223=$3;
|
||
|
|
var $224=($222|0)<($223|0);
|
||
|
|
var $226=$224;label=49;break;
|
||
|
|
case 49:
|
||
|
|
var $226;
|
||
|
|
if($226){label=50;break;}else{label=51;break;}
|
||
|
|
case 50:
|
||
|
|
var $228=$x;
|
||
|
|
var $229=$line;
|
||
|
|
var $230=(($229+($228<<1))|0);
|
||
|
|
HEAP16[(($230)>>1)]=0;
|
||
|
|
var $231=$count;
|
||
|
|
var $232=((($231)-(1))|0);
|
||
|
|
$count=$232;
|
||
|
|
var $233=$x;
|
||
|
|
var $234=((($233)+(1))|0);
|
||
|
|
$x=$234;
|
||
|
|
var $235=$x;
|
||
|
|
var $236=$line;
|
||
|
|
var $237=(($236+($235<<1))|0);
|
||
|
|
HEAP16[(($237)>>1)]=0;
|
||
|
|
var $238=$count;
|
||
|
|
var $239=((($238)-(1))|0);
|
||
|
|
$count=$239;
|
||
|
|
var $240=$x;
|
||
|
|
var $241=((($240)+(1))|0);
|
||
|
|
$x=$241;
|
||
|
|
var $242=$x;
|
||
|
|
var $243=$line;
|
||
|
|
var $244=(($243+($242<<1))|0);
|
||
|
|
HEAP16[(($244)>>1)]=0;
|
||
|
|
var $245=$count;
|
||
|
|
var $246=((($245)-(1))|0);
|
||
|
|
$count=$246;
|
||
|
|
var $247=$x;
|
||
|
|
var $248=((($247)+(1))|0);
|
||
|
|
$x=$248;
|
||
|
|
var $249=$x;
|
||
|
|
var $250=$line;
|
||
|
|
var $251=(($250+($249<<1))|0);
|
||
|
|
HEAP16[(($251)>>1)]=0;
|
||
|
|
var $252=$count;
|
||
|
|
var $253=((($252)-(1))|0);
|
||
|
|
$count=$253;
|
||
|
|
var $254=$x;
|
||
|
|
var $255=((($254)+(1))|0);
|
||
|
|
$x=$255;
|
||
|
|
var $256=$x;
|
||
|
|
var $257=$line;
|
||
|
|
var $258=(($257+($256<<1))|0);
|
||
|
|
HEAP16[(($258)>>1)]=0;
|
||
|
|
var $259=$count;
|
||
|
|
var $260=((($259)-(1))|0);
|
||
|
|
$count=$260;
|
||
|
|
var $261=$x;
|
||
|
|
var $262=((($261)+(1))|0);
|
||
|
|
$x=$262;
|
||
|
|
var $263=$x;
|
||
|
|
var $264=$line;
|
||
|
|
var $265=(($264+($263<<1))|0);
|
||
|
|
HEAP16[(($265)>>1)]=0;
|
||
|
|
var $266=$count;
|
||
|
|
var $267=((($266)-(1))|0);
|
||
|
|
$count=$267;
|
||
|
|
var $268=$x;
|
||
|
|
var $269=((($268)+(1))|0);
|
||
|
|
$x=$269;
|
||
|
|
var $270=$x;
|
||
|
|
var $271=$line;
|
||
|
|
var $272=(($271+($270<<1))|0);
|
||
|
|
HEAP16[(($272)>>1)]=0;
|
||
|
|
var $273=$count;
|
||
|
|
var $274=((($273)-(1))|0);
|
||
|
|
$count=$274;
|
||
|
|
var $275=$x;
|
||
|
|
var $276=((($275)+(1))|0);
|
||
|
|
$x=$276;
|
||
|
|
var $277=$x;
|
||
|
|
var $278=$line;
|
||
|
|
var $279=(($278+($277<<1))|0);
|
||
|
|
HEAP16[(($279)>>1)]=0;
|
||
|
|
var $280=$count;
|
||
|
|
var $281=((($280)-(1))|0);
|
||
|
|
$count=$281;
|
||
|
|
var $282=$x;
|
||
|
|
var $283=((($282)+(1))|0);
|
||
|
|
$x=$283;
|
||
|
|
label=47;break;
|
||
|
|
case 51:
|
||
|
|
label=52;break;
|
||
|
|
case 52:
|
||
|
|
var $286=$count;
|
||
|
|
var $287=($286|0)>0;
|
||
|
|
if($287){label=53;break;}else{var $293=0;label=54;break;}
|
||
|
|
case 53:
|
||
|
|
var $289=$x;
|
||
|
|
var $290=$3;
|
||
|
|
var $291=($289|0)<($290|0);
|
||
|
|
var $293=$291;label=54;break;
|
||
|
|
case 54:
|
||
|
|
var $293;
|
||
|
|
if($293){label=55;break;}else{label=56;break;}
|
||
|
|
case 55:
|
||
|
|
var $295=$x;
|
||
|
|
var $296=$line;
|
||
|
|
var $297=(($296+($295<<1))|0);
|
||
|
|
HEAP16[(($297)>>1)]=0;
|
||
|
|
var $298=$count;
|
||
|
|
var $299=((($298)-(1))|0);
|
||
|
|
$count=$299;
|
||
|
|
var $300=$x;
|
||
|
|
var $301=((($300)+(1))|0);
|
||
|
|
$x=$301;
|
||
|
|
label=52;break;
|
||
|
|
case 56:
|
||
|
|
label=68;break;
|
||
|
|
case 57:
|
||
|
|
label=58;break;
|
||
|
|
case 58:
|
||
|
|
var $305=$count;
|
||
|
|
var $306=$305&-8;
|
||
|
|
var $307=($306|0)!=0;
|
||
|
|
if($307){label=59;break;}else{var $314=0;label=60;break;}
|
||
|
|
case 59:
|
||
|
|
var $309=$x;
|
||
|
|
var $310=((($309)+(8))|0);
|
||
|
|
var $311=$3;
|
||
|
|
var $312=($310|0)<($311|0);
|
||
|
|
var $314=$312;label=60;break;
|
||
|
|
case 60:
|
||
|
|
var $314;
|
||
|
|
if($314){label=61;break;}else{label=62;break;}
|
||
|
|
case 61:
|
||
|
|
var $316=$x;
|
||
|
|
var $317=$prevline;
|
||
|
|
var $318=(($317+($316<<1))|0);
|
||
|
|
var $319=HEAP16[(($318)>>1)];
|
||
|
|
var $320=$x;
|
||
|
|
var $321=$line;
|
||
|
|
var $322=(($321+($320<<1))|0);
|
||
|
|
HEAP16[(($322)>>1)]=$319;
|
||
|
|
var $323=$count;
|
||
|
|
var $324=((($323)-(1))|0);
|
||
|
|
$count=$324;
|
||
|
|
var $325=$x;
|
||
|
|
var $326=((($325)+(1))|0);
|
||
|
|
$x=$326;
|
||
|
|
var $327=$x;
|
||
|
|
var $328=$prevline;
|
||
|
|
var $329=(($328+($327<<1))|0);
|
||
|
|
var $330=HEAP16[(($329)>>1)];
|
||
|
|
var $331=$x;
|
||
|
|
var $332=$line;
|
||
|
|
var $333=(($332+($331<<1))|0);
|
||
|
|
HEAP16[(($333)>>1)]=$330;
|
||
|
|
var $334=$count;
|
||
|
|
var $335=((($334)-(1))|0);
|
||
|
|
$count=$335;
|
||
|
|
var $336=$x;
|
||
|
|
var $337=((($336)+(1))|0);
|
||
|
|
$x=$337;
|
||
|
|
var $338=$x;
|
||
|
|
var $339=$prevline;
|
||
|
|
var $340=(($339+($338<<1))|0);
|
||
|
|
var $341=HEAP16[(($340)>>1)];
|
||
|
|
var $342=$x;
|
||
|
|
var $343=$line;
|
||
|
|
var $344=(($343+($342<<1))|0);
|
||
|
|
HEAP16[(($344)>>1)]=$341;
|
||
|
|
var $345=$count;
|
||
|
|
var $346=((($345)-(1))|0);
|
||
|
|
$count=$346;
|
||
|
|
var $347=$x;
|
||
|
|
var $348=((($347)+(1))|0);
|
||
|
|
$x=$348;
|
||
|
|
var $349=$x;
|
||
|
|
var $350=$prevline;
|
||
|
|
var $351=(($350+($349<<1))|0);
|
||
|
|
var $352=HEAP16[(($351)>>1)];
|
||
|
|
var $353=$x;
|
||
|
|
var $354=$line;
|
||
|
|
var $355=(($354+($353<<1))|0);
|
||
|
|
HEAP16[(($355)>>1)]=$352;
|
||
|
|
var $356=$count;
|
||
|
|
var $357=((($356)-(1))|0);
|
||
|
|
$count=$357;
|
||
|
|
var $358=$x;
|
||
|
|
var $359=((($358)+(1))|0);
|
||
|
|
$x=$359;
|
||
|
|
var $360=$x;
|
||
|
|
var $361=$prevline;
|
||
|
|
var $362=(($361+($360<<1))|0);
|
||
|
|
var $363=HEAP16[(($362)>>1)];
|
||
|
|
var $364=$x;
|
||
|
|
var $365=$line;
|
||
|
|
var $366=(($365+($364<<1))|0);
|
||
|
|
HEAP16[(($366)>>1)]=$363;
|
||
|
|
var $367=$count;
|
||
|
|
var $368=((($367)-(1))|0);
|
||
|
|
$count=$368;
|
||
|
|
var $369=$x;
|
||
|
|
var $370=((($369)+(1))|0);
|
||
|
|
$x=$370;
|
||
|
|
var $371=$x;
|
||
|
|
var $372=$prevline;
|
||
|
|
var $373=(($372+($371<<1))|0);
|
||
|
|
var $374=HEAP16[(($373)>>1)];
|
||
|
|
var $375=$x;
|
||
|
|
var $376=$line;
|
||
|
|
var $377=(($376+($375<<1))|0);
|
||
|
|
HEAP16[(($377)>>1)]=$374;
|
||
|
|
var $378=$count;
|
||
|
|
var $379=((($378)-(1))|0);
|
||
|
|
$count=$379;
|
||
|
|
var $380=$x;
|
||
|
|
var $381=((($380)+(1))|0);
|
||
|
|
$x=$381;
|
||
|
|
var $382=$x;
|
||
|
|
var $383=$prevline;
|
||
|
|
var $384=(($383+($382<<1))|0);
|
||
|
|
var $385=HEAP16[(($384)>>1)];
|
||
|
|
var $386=$x;
|
||
|
|
var $387=$line;
|
||
|
|
var $388=(($387+($386<<1))|0);
|
||
|
|
HEAP16[(($388)>>1)]=$385;
|
||
|
|
var $389=$count;
|
||
|
|
var $390=((($389)-(1))|0);
|
||
|
|
$count=$390;
|
||
|
|
var $391=$x;
|
||
|
|
var $392=((($391)+(1))|0);
|
||
|
|
$x=$392;
|
||
|
|
var $393=$x;
|
||
|
|
var $394=$prevline;
|
||
|
|
var $395=(($394+($393<<1))|0);
|
||
|
|
var $396=HEAP16[(($395)>>1)];
|
||
|
|
var $397=$x;
|
||
|
|
var $398=$line;
|
||
|
|
var $399=(($398+($397<<1))|0);
|
||
|
|
HEAP16[(($399)>>1)]=$396;
|
||
|
|
var $400=$count;
|
||
|
|
var $401=((($400)-(1))|0);
|
||
|
|
$count=$401;
|
||
|
|
var $402=$x;
|
||
|
|
var $403=((($402)+(1))|0);
|
||
|
|
$x=$403;
|
||
|
|
label=58;break;
|
||
|
|
case 62:
|
||
|
|
label=63;break;
|
||
|
|
case 63:
|
||
|
|
var $406=$count;
|
||
|
|
var $407=($406|0)>0;
|
||
|
|
if($407){label=64;break;}else{var $413=0;label=65;break;}
|
||
|
|
case 64:
|
||
|
|
var $409=$x;
|
||
|
|
var $410=$3;
|
||
|
|
var $411=($409|0)<($410|0);
|
||
|
|
var $413=$411;label=65;break;
|
||
|
|
case 65:
|
||
|
|
var $413;
|
||
|
|
if($413){label=66;break;}else{label=67;break;}
|
||
|
|
case 66:
|
||
|
|
var $415=$x;
|
||
|
|
var $416=$prevline;
|
||
|
|
var $417=(($416+($415<<1))|0);
|
||
|
|
var $418=HEAP16[(($417)>>1)];
|
||
|
|
var $419=$x;
|
||
|
|
var $420=$line;
|
||
|
|
var $421=(($420+($419<<1))|0);
|
||
|
|
HEAP16[(($421)>>1)]=$418;
|
||
|
|
var $422=$count;
|
||
|
|
var $423=((($422)-(1))|0);
|
||
|
|
$count=$423;
|
||
|
|
var $424=$x;
|
||
|
|
var $425=((($424)+(1))|0);
|
||
|
|
$x=$425;
|
||
|
|
label=63;break;
|
||
|
|
case 67:
|
||
|
|
label=68;break;
|
||
|
|
case 68:
|
||
|
|
label=344;break;
|
||
|
|
case 69:
|
||
|
|
var $429=$prevline;
|
||
|
|
var $430=($429|0)==0;
|
||
|
|
if($430){label=70;break;}else{label=81;break;}
|
||
|
|
case 70:
|
||
|
|
label=71;break;
|
||
|
|
case 71:
|
||
|
|
var $433=$count;
|
||
|
|
var $434=$433&-8;
|
||
|
|
var $435=($434|0)!=0;
|
||
|
|
if($435){label=72;break;}else{var $442=0;label=73;break;}
|
||
|
|
case 72:
|
||
|
|
var $437=$x;
|
||
|
|
var $438=((($437)+(8))|0);
|
||
|
|
var $439=$3;
|
||
|
|
var $440=($438|0)<($439|0);
|
||
|
|
var $442=$440;label=73;break;
|
||
|
|
case 73:
|
||
|
|
var $442;
|
||
|
|
if($442){label=74;break;}else{label=75;break;}
|
||
|
|
case 74:
|
||
|
|
var $444=$mix;
|
||
|
|
var $445=$x;
|
||
|
|
var $446=$line;
|
||
|
|
var $447=(($446+($445<<1))|0);
|
||
|
|
HEAP16[(($447)>>1)]=$444;
|
||
|
|
var $448=$count;
|
||
|
|
var $449=((($448)-(1))|0);
|
||
|
|
$count=$449;
|
||
|
|
var $450=$x;
|
||
|
|
var $451=((($450)+(1))|0);
|
||
|
|
$x=$451;
|
||
|
|
var $452=$mix;
|
||
|
|
var $453=$x;
|
||
|
|
var $454=$line;
|
||
|
|
var $455=(($454+($453<<1))|0);
|
||
|
|
HEAP16[(($455)>>1)]=$452;
|
||
|
|
var $456=$count;
|
||
|
|
var $457=((($456)-(1))|0);
|
||
|
|
$count=$457;
|
||
|
|
var $458=$x;
|
||
|
|
var $459=((($458)+(1))|0);
|
||
|
|
$x=$459;
|
||
|
|
var $460=$mix;
|
||
|
|
var $461=$x;
|
||
|
|
var $462=$line;
|
||
|
|
var $463=(($462+($461<<1))|0);
|
||
|
|
HEAP16[(($463)>>1)]=$460;
|
||
|
|
var $464=$count;
|
||
|
|
var $465=((($464)-(1))|0);
|
||
|
|
$count=$465;
|
||
|
|
var $466=$x;
|
||
|
|
var $467=((($466)+(1))|0);
|
||
|
|
$x=$467;
|
||
|
|
var $468=$mix;
|
||
|
|
var $469=$x;
|
||
|
|
var $470=$line;
|
||
|
|
var $471=(($470+($469<<1))|0);
|
||
|
|
HEAP16[(($471)>>1)]=$468;
|
||
|
|
var $472=$count;
|
||
|
|
var $473=((($472)-(1))|0);
|
||
|
|
$count=$473;
|
||
|
|
var $474=$x;
|
||
|
|
var $475=((($474)+(1))|0);
|
||
|
|
$x=$475;
|
||
|
|
var $476=$mix;
|
||
|
|
var $477=$x;
|
||
|
|
var $478=$line;
|
||
|
|
var $479=(($478+($477<<1))|0);
|
||
|
|
HEAP16[(($479)>>1)]=$476;
|
||
|
|
var $480=$count;
|
||
|
|
var $481=((($480)-(1))|0);
|
||
|
|
$count=$481;
|
||
|
|
var $482=$x;
|
||
|
|
var $483=((($482)+(1))|0);
|
||
|
|
$x=$483;
|
||
|
|
var $484=$mix;
|
||
|
|
var $485=$x;
|
||
|
|
var $486=$line;
|
||
|
|
var $487=(($486+($485<<1))|0);
|
||
|
|
HEAP16[(($487)>>1)]=$484;
|
||
|
|
var $488=$count;
|
||
|
|
var $489=((($488)-(1))|0);
|
||
|
|
$count=$489;
|
||
|
|
var $490=$x;
|
||
|
|
var $491=((($490)+(1))|0);
|
||
|
|
$x=$491;
|
||
|
|
var $492=$mix;
|
||
|
|
var $493=$x;
|
||
|
|
var $494=$line;
|
||
|
|
var $495=(($494+($493<<1))|0);
|
||
|
|
HEAP16[(($495)>>1)]=$492;
|
||
|
|
var $496=$count;
|
||
|
|
var $497=((($496)-(1))|0);
|
||
|
|
$count=$497;
|
||
|
|
var $498=$x;
|
||
|
|
var $499=((($498)+(1))|0);
|
||
|
|
$x=$499;
|
||
|
|
var $500=$mix;
|
||
|
|
var $501=$x;
|
||
|
|
var $502=$line;
|
||
|
|
var $503=(($502+($501<<1))|0);
|
||
|
|
HEAP16[(($503)>>1)]=$500;
|
||
|
|
var $504=$count;
|
||
|
|
var $505=((($504)-(1))|0);
|
||
|
|
$count=$505;
|
||
|
|
var $506=$x;
|
||
|
|
var $507=((($506)+(1))|0);
|
||
|
|
$x=$507;
|
||
|
|
label=71;break;
|
||
|
|
case 75:
|
||
|
|
label=76;break;
|
||
|
|
case 76:
|
||
|
|
var $510=$count;
|
||
|
|
var $511=($510|0)>0;
|
||
|
|
if($511){label=77;break;}else{var $517=0;label=78;break;}
|
||
|
|
case 77:
|
||
|
|
var $513=$x;
|
||
|
|
var $514=$3;
|
||
|
|
var $515=($513|0)<($514|0);
|
||
|
|
var $517=$515;label=78;break;
|
||
|
|
case 78:
|
||
|
|
var $517;
|
||
|
|
if($517){label=79;break;}else{label=80;break;}
|
||
|
|
case 79:
|
||
|
|
var $519=$mix;
|
||
|
|
var $520=$x;
|
||
|
|
var $521=$line;
|
||
|
|
var $522=(($521+($520<<1))|0);
|
||
|
|
HEAP16[(($522)>>1)]=$519;
|
||
|
|
var $523=$count;
|
||
|
|
var $524=((($523)-(1))|0);
|
||
|
|
$count=$524;
|
||
|
|
var $525=$x;
|
||
|
|
var $526=((($525)+(1))|0);
|
||
|
|
$x=$526;
|
||
|
|
label=76;break;
|
||
|
|
case 80:
|
||
|
|
label=92;break;
|
||
|
|
case 81:
|
||
|
|
label=82;break;
|
||
|
|
case 82:
|
||
|
|
var $530=$count;
|
||
|
|
var $531=$530&-8;
|
||
|
|
var $532=($531|0)!=0;
|
||
|
|
if($532){label=83;break;}else{var $539=0;label=84;break;}
|
||
|
|
case 83:
|
||
|
|
var $534=$x;
|
||
|
|
var $535=((($534)+(8))|0);
|
||
|
|
var $536=$3;
|
||
|
|
var $537=($535|0)<($536|0);
|
||
|
|
var $539=$537;label=84;break;
|
||
|
|
case 84:
|
||
|
|
var $539;
|
||
|
|
if($539){label=85;break;}else{label=86;break;}
|
||
|
|
case 85:
|
||
|
|
var $541=$x;
|
||
|
|
var $542=$prevline;
|
||
|
|
var $543=(($542+($541<<1))|0);
|
||
|
|
var $544=HEAP16[(($543)>>1)];
|
||
|
|
var $545=($544&65535);
|
||
|
|
var $546=$mix;
|
||
|
|
var $547=($546&65535);
|
||
|
|
var $548=$545^$547;
|
||
|
|
var $549=(($548)&65535);
|
||
|
|
var $550=$x;
|
||
|
|
var $551=$line;
|
||
|
|
var $552=(($551+($550<<1))|0);
|
||
|
|
HEAP16[(($552)>>1)]=$549;
|
||
|
|
var $553=$count;
|
||
|
|
var $554=((($553)-(1))|0);
|
||
|
|
$count=$554;
|
||
|
|
var $555=$x;
|
||
|
|
var $556=((($555)+(1))|0);
|
||
|
|
$x=$556;
|
||
|
|
var $557=$x;
|
||
|
|
var $558=$prevline;
|
||
|
|
var $559=(($558+($557<<1))|0);
|
||
|
|
var $560=HEAP16[(($559)>>1)];
|
||
|
|
var $561=($560&65535);
|
||
|
|
var $562=$mix;
|
||
|
|
var $563=($562&65535);
|
||
|
|
var $564=$561^$563;
|
||
|
|
var $565=(($564)&65535);
|
||
|
|
var $566=$x;
|
||
|
|
var $567=$line;
|
||
|
|
var $568=(($567+($566<<1))|0);
|
||
|
|
HEAP16[(($568)>>1)]=$565;
|
||
|
|
var $569=$count;
|
||
|
|
var $570=((($569)-(1))|0);
|
||
|
|
$count=$570;
|
||
|
|
var $571=$x;
|
||
|
|
var $572=((($571)+(1))|0);
|
||
|
|
$x=$572;
|
||
|
|
var $573=$x;
|
||
|
|
var $574=$prevline;
|
||
|
|
var $575=(($574+($573<<1))|0);
|
||
|
|
var $576=HEAP16[(($575)>>1)];
|
||
|
|
var $577=($576&65535);
|
||
|
|
var $578=$mix;
|
||
|
|
var $579=($578&65535);
|
||
|
|
var $580=$577^$579;
|
||
|
|
var $581=(($580)&65535);
|
||
|
|
var $582=$x;
|
||
|
|
var $583=$line;
|
||
|
|
var $584=(($583+($582<<1))|0);
|
||
|
|
HEAP16[(($584)>>1)]=$581;
|
||
|
|
var $585=$count;
|
||
|
|
var $586=((($585)-(1))|0);
|
||
|
|
$count=$586;
|
||
|
|
var $587=$x;
|
||
|
|
var $588=((($587)+(1))|0);
|
||
|
|
$x=$588;
|
||
|
|
var $589=$x;
|
||
|
|
var $590=$prevline;
|
||
|
|
var $591=(($590+($589<<1))|0);
|
||
|
|
var $592=HEAP16[(($591)>>1)];
|
||
|
|
var $593=($592&65535);
|
||
|
|
var $594=$mix;
|
||
|
|
var $595=($594&65535);
|
||
|
|
var $596=$593^$595;
|
||
|
|
var $597=(($596)&65535);
|
||
|
|
var $598=$x;
|
||
|
|
var $599=$line;
|
||
|
|
var $600=(($599+($598<<1))|0);
|
||
|
|
HEAP16[(($600)>>1)]=$597;
|
||
|
|
var $601=$count;
|
||
|
|
var $602=((($601)-(1))|0);
|
||
|
|
$count=$602;
|
||
|
|
var $603=$x;
|
||
|
|
var $604=((($603)+(1))|0);
|
||
|
|
$x=$604;
|
||
|
|
var $605=$x;
|
||
|
|
var $606=$prevline;
|
||
|
|
var $607=(($606+($605<<1))|0);
|
||
|
|
var $608=HEAP16[(($607)>>1)];
|
||
|
|
var $609=($608&65535);
|
||
|
|
var $610=$mix;
|
||
|
|
var $611=($610&65535);
|
||
|
|
var $612=$609^$611;
|
||
|
|
var $613=(($612)&65535);
|
||
|
|
var $614=$x;
|
||
|
|
var $615=$line;
|
||
|
|
var $616=(($615+($614<<1))|0);
|
||
|
|
HEAP16[(($616)>>1)]=$613;
|
||
|
|
var $617=$count;
|
||
|
|
var $618=((($617)-(1))|0);
|
||
|
|
$count=$618;
|
||
|
|
var $619=$x;
|
||
|
|
var $620=((($619)+(1))|0);
|
||
|
|
$x=$620;
|
||
|
|
var $621=$x;
|
||
|
|
var $622=$prevline;
|
||
|
|
var $623=(($622+($621<<1))|0);
|
||
|
|
var $624=HEAP16[(($623)>>1)];
|
||
|
|
var $625=($624&65535);
|
||
|
|
var $626=$mix;
|
||
|
|
var $627=($626&65535);
|
||
|
|
var $628=$625^$627;
|
||
|
|
var $629=(($628)&65535);
|
||
|
|
var $630=$x;
|
||
|
|
var $631=$line;
|
||
|
|
var $632=(($631+($630<<1))|0);
|
||
|
|
HEAP16[(($632)>>1)]=$629;
|
||
|
|
var $633=$count;
|
||
|
|
var $634=((($633)-(1))|0);
|
||
|
|
$count=$634;
|
||
|
|
var $635=$x;
|
||
|
|
var $636=((($635)+(1))|0);
|
||
|
|
$x=$636;
|
||
|
|
var $637=$x;
|
||
|
|
var $638=$prevline;
|
||
|
|
var $639=(($638+($637<<1))|0);
|
||
|
|
var $640=HEAP16[(($639)>>1)];
|
||
|
|
var $641=($640&65535);
|
||
|
|
var $642=$mix;
|
||
|
|
var $643=($642&65535);
|
||
|
|
var $644=$641^$643;
|
||
|
|
var $645=(($644)&65535);
|
||
|
|
var $646=$x;
|
||
|
|
var $647=$line;
|
||
|
|
var $648=(($647+($646<<1))|0);
|
||
|
|
HEAP16[(($648)>>1)]=$645;
|
||
|
|
var $649=$count;
|
||
|
|
var $650=((($649)-(1))|0);
|
||
|
|
$count=$650;
|
||
|
|
var $651=$x;
|
||
|
|
var $652=((($651)+(1))|0);
|
||
|
|
$x=$652;
|
||
|
|
var $653=$x;
|
||
|
|
var $654=$prevline;
|
||
|
|
var $655=(($654+($653<<1))|0);
|
||
|
|
var $656=HEAP16[(($655)>>1)];
|
||
|
|
var $657=($656&65535);
|
||
|
|
var $658=$mix;
|
||
|
|
var $659=($658&65535);
|
||
|
|
var $660=$657^$659;
|
||
|
|
var $661=(($660)&65535);
|
||
|
|
var $662=$x;
|
||
|
|
var $663=$line;
|
||
|
|
var $664=(($663+($662<<1))|0);
|
||
|
|
HEAP16[(($664)>>1)]=$661;
|
||
|
|
var $665=$count;
|
||
|
|
var $666=((($665)-(1))|0);
|
||
|
|
$count=$666;
|
||
|
|
var $667=$x;
|
||
|
|
var $668=((($667)+(1))|0);
|
||
|
|
$x=$668;
|
||
|
|
label=82;break;
|
||
|
|
case 86:
|
||
|
|
label=87;break;
|
||
|
|
case 87:
|
||
|
|
var $671=$count;
|
||
|
|
var $672=($671|0)>0;
|
||
|
|
if($672){label=88;break;}else{var $678=0;label=89;break;}
|
||
|
|
case 88:
|
||
|
|
var $674=$x;
|
||
|
|
var $675=$3;
|
||
|
|
var $676=($674|0)<($675|0);
|
||
|
|
var $678=$676;label=89;break;
|
||
|
|
case 89:
|
||
|
|
var $678;
|
||
|
|
if($678){label=90;break;}else{label=91;break;}
|
||
|
|
case 90:
|
||
|
|
var $680=$x;
|
||
|
|
var $681=$prevline;
|
||
|
|
var $682=(($681+($680<<1))|0);
|
||
|
|
var $683=HEAP16[(($682)>>1)];
|
||
|
|
var $684=($683&65535);
|
||
|
|
var $685=$mix;
|
||
|
|
var $686=($685&65535);
|
||
|
|
var $687=$684^$686;
|
||
|
|
var $688=(($687)&65535);
|
||
|
|
var $689=$x;
|
||
|
|
var $690=$line;
|
||
|
|
var $691=(($690+($689<<1))|0);
|
||
|
|
HEAP16[(($691)>>1)]=$688;
|
||
|
|
var $692=$count;
|
||
|
|
var $693=((($692)-(1))|0);
|
||
|
|
$count=$693;
|
||
|
|
var $694=$x;
|
||
|
|
var $695=((($694)+(1))|0);
|
||
|
|
$x=$695;
|
||
|
|
label=87;break;
|
||
|
|
case 91:
|
||
|
|
label=92;break;
|
||
|
|
case 92:
|
||
|
|
label=344;break;
|
||
|
|
case 93:
|
||
|
|
var $699=$prevline;
|
||
|
|
var $700=($699|0)==0;
|
||
|
|
if($700){label=94;break;}else{label=177;break;}
|
||
|
|
case 94:
|
||
|
|
label=95;break;
|
||
|
|
case 95:
|
||
|
|
var $703=$count;
|
||
|
|
var $704=$703&-8;
|
||
|
|
var $705=($704|0)!=0;
|
||
|
|
if($705){label=96;break;}else{var $712=0;label=97;break;}
|
||
|
|
case 96:
|
||
|
|
var $707=$x;
|
||
|
|
var $708=((($707)+(8))|0);
|
||
|
|
var $709=$3;
|
||
|
|
var $710=($708|0)<($709|0);
|
||
|
|
var $712=$710;label=97;break;
|
||
|
|
case 97:
|
||
|
|
var $712;
|
||
|
|
if($712){label=98;break;}else{label=163;break;}
|
||
|
|
case 98:
|
||
|
|
var $714=$mixmask;
|
||
|
|
var $715=($714&255);
|
||
|
|
var $716=$715<<1;
|
||
|
|
var $717=(($716)&255);
|
||
|
|
$mixmask=$717;
|
||
|
|
var $718=$mixmask;
|
||
|
|
var $719=($718&255);
|
||
|
|
var $720=($719|0)==0;
|
||
|
|
if($720){label=99;break;}else{label=103;break;}
|
||
|
|
case 99:
|
||
|
|
var $722=$fom_mask;
|
||
|
|
var $723=($722|0)!=0;
|
||
|
|
if($723){label=100;break;}else{label=101;break;}
|
||
|
|
case 100:
|
||
|
|
var $725=$fom_mask;
|
||
|
|
var $732=$725;label=102;break;
|
||
|
|
case 101:
|
||
|
|
var $727=$5;
|
||
|
|
var $728=(($727+1)|0);
|
||
|
|
$5=$728;
|
||
|
|
var $729=HEAP8[($727)];
|
||
|
|
var $730=($729&255);
|
||
|
|
var $732=$730;label=102;break;
|
||
|
|
case 102:
|
||
|
|
var $732;
|
||
|
|
var $733=(($732)&255);
|
||
|
|
$mask=$733;
|
||
|
|
$mixmask=1;
|
||
|
|
label=103;break;
|
||
|
|
case 103:
|
||
|
|
var $735=$mask;
|
||
|
|
var $736=($735&255);
|
||
|
|
var $737=$mixmask;
|
||
|
|
var $738=($737&255);
|
||
|
|
var $739=$736&$738;
|
||
|
|
var $740=($739|0)!=0;
|
||
|
|
if($740){label=104;break;}else{label=105;break;}
|
||
|
|
case 104:
|
||
|
|
var $742=$mix;
|
||
|
|
var $743=$x;
|
||
|
|
var $744=$line;
|
||
|
|
var $745=(($744+($743<<1))|0);
|
||
|
|
HEAP16[(($745)>>1)]=$742;
|
||
|
|
label=106;break;
|
||
|
|
case 105:
|
||
|
|
var $747=$x;
|
||
|
|
var $748=$line;
|
||
|
|
var $749=(($748+($747<<1))|0);
|
||
|
|
HEAP16[(($749)>>1)]=0;
|
||
|
|
label=106;break;
|
||
|
|
case 106:
|
||
|
|
var $751=$count;
|
||
|
|
var $752=((($751)-(1))|0);
|
||
|
|
$count=$752;
|
||
|
|
var $753=$x;
|
||
|
|
var $754=((($753)+(1))|0);
|
||
|
|
$x=$754;
|
||
|
|
var $755=$mixmask;
|
||
|
|
var $756=($755&255);
|
||
|
|
var $757=$756<<1;
|
||
|
|
var $758=(($757)&255);
|
||
|
|
$mixmask=$758;
|
||
|
|
var $759=$mixmask;
|
||
|
|
var $760=($759&255);
|
||
|
|
var $761=($760|0)==0;
|
||
|
|
if($761){label=107;break;}else{label=111;break;}
|
||
|
|
case 107:
|
||
|
|
var $763=$fom_mask;
|
||
|
|
var $764=($763|0)!=0;
|
||
|
|
if($764){label=108;break;}else{label=109;break;}
|
||
|
|
case 108:
|
||
|
|
var $766=$fom_mask;
|
||
|
|
var $773=$766;label=110;break;
|
||
|
|
case 109:
|
||
|
|
var $768=$5;
|
||
|
|
var $769=(($768+1)|0);
|
||
|
|
$5=$769;
|
||
|
|
var $770=HEAP8[($768)];
|
||
|
|
var $771=($770&255);
|
||
|
|
var $773=$771;label=110;break;
|
||
|
|
case 110:
|
||
|
|
var $773;
|
||
|
|
var $774=(($773)&255);
|
||
|
|
$mask=$774;
|
||
|
|
$mixmask=1;
|
||
|
|
label=111;break;
|
||
|
|
case 111:
|
||
|
|
var $776=$mask;
|
||
|
|
var $777=($776&255);
|
||
|
|
var $778=$mixmask;
|
||
|
|
var $779=($778&255);
|
||
|
|
var $780=$777&$779;
|
||
|
|
var $781=($780|0)!=0;
|
||
|
|
if($781){label=112;break;}else{label=113;break;}
|
||
|
|
case 112:
|
||
|
|
var $783=$mix;
|
||
|
|
var $784=$x;
|
||
|
|
var $785=$line;
|
||
|
|
var $786=(($785+($784<<1))|0);
|
||
|
|
HEAP16[(($786)>>1)]=$783;
|
||
|
|
label=114;break;
|
||
|
|
case 113:
|
||
|
|
var $788=$x;
|
||
|
|
var $789=$line;
|
||
|
|
var $790=(($789+($788<<1))|0);
|
||
|
|
HEAP16[(($790)>>1)]=0;
|
||
|
|
label=114;break;
|
||
|
|
case 114:
|
||
|
|
var $792=$count;
|
||
|
|
var $793=((($792)-(1))|0);
|
||
|
|
$count=$793;
|
||
|
|
var $794=$x;
|
||
|
|
var $795=((($794)+(1))|0);
|
||
|
|
$x=$795;
|
||
|
|
var $796=$mixmask;
|
||
|
|
var $797=($796&255);
|
||
|
|
var $798=$797<<1;
|
||
|
|
var $799=(($798)&255);
|
||
|
|
$mixmask=$799;
|
||
|
|
var $800=$mixmask;
|
||
|
|
var $801=($800&255);
|
||
|
|
var $802=($801|0)==0;
|
||
|
|
if($802){label=115;break;}else{label=119;break;}
|
||
|
|
case 115:
|
||
|
|
var $804=$fom_mask;
|
||
|
|
var $805=($804|0)!=0;
|
||
|
|
if($805){label=116;break;}else{label=117;break;}
|
||
|
|
case 116:
|
||
|
|
var $807=$fom_mask;
|
||
|
|
var $814=$807;label=118;break;
|
||
|
|
case 117:
|
||
|
|
var $809=$5;
|
||
|
|
var $810=(($809+1)|0);
|
||
|
|
$5=$810;
|
||
|
|
var $811=HEAP8[($809)];
|
||
|
|
var $812=($811&255);
|
||
|
|
var $814=$812;label=118;break;
|
||
|
|
case 118:
|
||
|
|
var $814;
|
||
|
|
var $815=(($814)&255);
|
||
|
|
$mask=$815;
|
||
|
|
$mixmask=1;
|
||
|
|
label=119;break;
|
||
|
|
case 119:
|
||
|
|
var $817=$mask;
|
||
|
|
var $818=($817&255);
|
||
|
|
var $819=$mixmask;
|
||
|
|
var $820=($819&255);
|
||
|
|
var $821=$818&$820;
|
||
|
|
var $822=($821|0)!=0;
|
||
|
|
if($822){label=120;break;}else{label=121;break;}
|
||
|
|
case 120:
|
||
|
|
var $824=$mix;
|
||
|
|
var $825=$x;
|
||
|
|
var $826=$line;
|
||
|
|
var $827=(($826+($825<<1))|0);
|
||
|
|
HEAP16[(($827)>>1)]=$824;
|
||
|
|
label=122;break;
|
||
|
|
case 121:
|
||
|
|
var $829=$x;
|
||
|
|
var $830=$line;
|
||
|
|
var $831=(($830+($829<<1))|0);
|
||
|
|
HEAP16[(($831)>>1)]=0;
|
||
|
|
label=122;break;
|
||
|
|
case 122:
|
||
|
|
var $833=$count;
|
||
|
|
var $834=((($833)-(1))|0);
|
||
|
|
$count=$834;
|
||
|
|
var $835=$x;
|
||
|
|
var $836=((($835)+(1))|0);
|
||
|
|
$x=$836;
|
||
|
|
var $837=$mixmask;
|
||
|
|
var $838=($837&255);
|
||
|
|
var $839=$838<<1;
|
||
|
|
var $840=(($839)&255);
|
||
|
|
$mixmask=$840;
|
||
|
|
var $841=$mixmask;
|
||
|
|
var $842=($841&255);
|
||
|
|
var $843=($842|0)==0;
|
||
|
|
if($843){label=123;break;}else{label=127;break;}
|
||
|
|
case 123:
|
||
|
|
var $845=$fom_mask;
|
||
|
|
var $846=($845|0)!=0;
|
||
|
|
if($846){label=124;break;}else{label=125;break;}
|
||
|
|
case 124:
|
||
|
|
var $848=$fom_mask;
|
||
|
|
var $855=$848;label=126;break;
|
||
|
|
case 125:
|
||
|
|
var $850=$5;
|
||
|
|
var $851=(($850+1)|0);
|
||
|
|
$5=$851;
|
||
|
|
var $852=HEAP8[($850)];
|
||
|
|
var $853=($852&255);
|
||
|
|
var $855=$853;label=126;break;
|
||
|
|
case 126:
|
||
|
|
var $855;
|
||
|
|
var $856=(($855)&255);
|
||
|
|
$mask=$856;
|
||
|
|
$mixmask=1;
|
||
|
|
label=127;break;
|
||
|
|
case 127:
|
||
|
|
var $858=$mask;
|
||
|
|
var $859=($858&255);
|
||
|
|
var $860=$mixmask;
|
||
|
|
var $861=($860&255);
|
||
|
|
var $862=$859&$861;
|
||
|
|
var $863=($862|0)!=0;
|
||
|
|
if($863){label=128;break;}else{label=129;break;}
|
||
|
|
case 128:
|
||
|
|
var $865=$mix;
|
||
|
|
var $866=$x;
|
||
|
|
var $867=$line;
|
||
|
|
var $868=(($867+($866<<1))|0);
|
||
|
|
HEAP16[(($868)>>1)]=$865;
|
||
|
|
label=130;break;
|
||
|
|
case 129:
|
||
|
|
var $870=$x;
|
||
|
|
var $871=$line;
|
||
|
|
var $872=(($871+($870<<1))|0);
|
||
|
|
HEAP16[(($872)>>1)]=0;
|
||
|
|
label=130;break;
|
||
|
|
case 130:
|
||
|
|
var $874=$count;
|
||
|
|
var $875=((($874)-(1))|0);
|
||
|
|
$count=$875;
|
||
|
|
var $876=$x;
|
||
|
|
var $877=((($876)+(1))|0);
|
||
|
|
$x=$877;
|
||
|
|
var $878=$mixmask;
|
||
|
|
var $879=($878&255);
|
||
|
|
var $880=$879<<1;
|
||
|
|
var $881=(($880)&255);
|
||
|
|
$mixmask=$881;
|
||
|
|
var $882=$mixmask;
|
||
|
|
var $883=($882&255);
|
||
|
|
var $884=($883|0)==0;
|
||
|
|
if($884){label=131;break;}else{label=135;break;}
|
||
|
|
case 131:
|
||
|
|
var $886=$fom_mask;
|
||
|
|
var $887=($886|0)!=0;
|
||
|
|
if($887){label=132;break;}else{label=133;break;}
|
||
|
|
case 132:
|
||
|
|
var $889=$fom_mask;
|
||
|
|
var $896=$889;label=134;break;
|
||
|
|
case 133:
|
||
|
|
var $891=$5;
|
||
|
|
var $892=(($891+1)|0);
|
||
|
|
$5=$892;
|
||
|
|
var $893=HEAP8[($891)];
|
||
|
|
var $894=($893&255);
|
||
|
|
var $896=$894;label=134;break;
|
||
|
|
case 134:
|
||
|
|
var $896;
|
||
|
|
var $897=(($896)&255);
|
||
|
|
$mask=$897;
|
||
|
|
$mixmask=1;
|
||
|
|
label=135;break;
|
||
|
|
case 135:
|
||
|
|
var $899=$mask;
|
||
|
|
var $900=($899&255);
|
||
|
|
var $901=$mixmask;
|
||
|
|
var $902=($901&255);
|
||
|
|
var $903=$900&$902;
|
||
|
|
var $904=($903|0)!=0;
|
||
|
|
if($904){label=136;break;}else{label=137;break;}
|
||
|
|
case 136:
|
||
|
|
var $906=$mix;
|
||
|
|
var $907=$x;
|
||
|
|
var $908=$line;
|
||
|
|
var $909=(($908+($907<<1))|0);
|
||
|
|
HEAP16[(($909)>>1)]=$906;
|
||
|
|
label=138;break;
|
||
|
|
case 137:
|
||
|
|
var $911=$x;
|
||
|
|
var $912=$line;
|
||
|
|
var $913=(($912+($911<<1))|0);
|
||
|
|
HEAP16[(($913)>>1)]=0;
|
||
|
|
label=138;break;
|
||
|
|
case 138:
|
||
|
|
var $915=$count;
|
||
|
|
var $916=((($915)-(1))|0);
|
||
|
|
$count=$916;
|
||
|
|
var $917=$x;
|
||
|
|
var $918=((($917)+(1))|0);
|
||
|
|
$x=$918;
|
||
|
|
var $919=$mixmask;
|
||
|
|
var $920=($919&255);
|
||
|
|
var $921=$920<<1;
|
||
|
|
var $922=(($921)&255);
|
||
|
|
$mixmask=$922;
|
||
|
|
var $923=$mixmask;
|
||
|
|
var $924=($923&255);
|
||
|
|
var $925=($924|0)==0;
|
||
|
|
if($925){label=139;break;}else{label=143;break;}
|
||
|
|
case 139:
|
||
|
|
var $927=$fom_mask;
|
||
|
|
var $928=($927|0)!=0;
|
||
|
|
if($928){label=140;break;}else{label=141;break;}
|
||
|
|
case 140:
|
||
|
|
var $930=$fom_mask;
|
||
|
|
var $937=$930;label=142;break;
|
||
|
|
case 141:
|
||
|
|
var $932=$5;
|
||
|
|
var $933=(($932+1)|0);
|
||
|
|
$5=$933;
|
||
|
|
var $934=HEAP8[($932)];
|
||
|
|
var $935=($934&255);
|
||
|
|
var $937=$935;label=142;break;
|
||
|
|
case 142:
|
||
|
|
var $937;
|
||
|
|
var $938=(($937)&255);
|
||
|
|
$mask=$938;
|
||
|
|
$mixmask=1;
|
||
|
|
label=143;break;
|
||
|
|
case 143:
|
||
|
|
var $940=$mask;
|
||
|
|
var $941=($940&255);
|
||
|
|
var $942=$mixmask;
|
||
|
|
var $943=($942&255);
|
||
|
|
var $944=$941&$943;
|
||
|
|
var $945=($944|0)!=0;
|
||
|
|
if($945){label=144;break;}else{label=145;break;}
|
||
|
|
case 144:
|
||
|
|
var $947=$mix;
|
||
|
|
var $948=$x;
|
||
|
|
var $949=$line;
|
||
|
|
var $950=(($949+($948<<1))|0);
|
||
|
|
HEAP16[(($950)>>1)]=$947;
|
||
|
|
label=146;break;
|
||
|
|
case 145:
|
||
|
|
var $952=$x;
|
||
|
|
var $953=$line;
|
||
|
|
var $954=(($953+($952<<1))|0);
|
||
|
|
HEAP16[(($954)>>1)]=0;
|
||
|
|
label=146;break;
|
||
|
|
case 146:
|
||
|
|
var $956=$count;
|
||
|
|
var $957=((($956)-(1))|0);
|
||
|
|
$count=$957;
|
||
|
|
var $958=$x;
|
||
|
|
var $959=((($958)+(1))|0);
|
||
|
|
$x=$959;
|
||
|
|
var $960=$mixmask;
|
||
|
|
var $961=($960&255);
|
||
|
|
var $962=$961<<1;
|
||
|
|
var $963=(($962)&255);
|
||
|
|
$mixmask=$963;
|
||
|
|
var $964=$mixmask;
|
||
|
|
var $965=($964&255);
|
||
|
|
var $966=($965|0)==0;
|
||
|
|
if($966){label=147;break;}else{label=151;break;}
|
||
|
|
case 147:
|
||
|
|
var $968=$fom_mask;
|
||
|
|
var $969=($968|0)!=0;
|
||
|
|
if($969){label=148;break;}else{label=149;break;}
|
||
|
|
case 148:
|
||
|
|
var $971=$fom_mask;
|
||
|
|
var $978=$971;label=150;break;
|
||
|
|
case 149:
|
||
|
|
var $973=$5;
|
||
|
|
var $974=(($973+1)|0);
|
||
|
|
$5=$974;
|
||
|
|
var $975=HEAP8[($973)];
|
||
|
|
var $976=($975&255);
|
||
|
|
var $978=$976;label=150;break;
|
||
|
|
case 150:
|
||
|
|
var $978;
|
||
|
|
var $979=(($978)&255);
|
||
|
|
$mask=$979;
|
||
|
|
$mixmask=1;
|
||
|
|
label=151;break;
|
||
|
|
case 151:
|
||
|
|
var $981=$mask;
|
||
|
|
var $982=($981&255);
|
||
|
|
var $983=$mixmask;
|
||
|
|
var $984=($983&255);
|
||
|
|
var $985=$982&$984;
|
||
|
|
var $986=($985|0)!=0;
|
||
|
|
if($986){label=152;break;}else{label=153;break;}
|
||
|
|
case 152:
|
||
|
|
var $988=$mix;
|
||
|
|
var $989=$x;
|
||
|
|
var $990=$line;
|
||
|
|
var $991=(($990+($989<<1))|0);
|
||
|
|
HEAP16[(($991)>>1)]=$988;
|
||
|
|
label=154;break;
|
||
|
|
case 153:
|
||
|
|
var $993=$x;
|
||
|
|
var $994=$line;
|
||
|
|
var $995=(($994+($993<<1))|0);
|
||
|
|
HEAP16[(($995)>>1)]=0;
|
||
|
|
label=154;break;
|
||
|
|
case 154:
|
||
|
|
var $997=$count;
|
||
|
|
var $998=((($997)-(1))|0);
|
||
|
|
$count=$998;
|
||
|
|
var $999=$x;
|
||
|
|
var $1000=((($999)+(1))|0);
|
||
|
|
$x=$1000;
|
||
|
|
var $1001=$mixmask;
|
||
|
|
var $1002=($1001&255);
|
||
|
|
var $1003=$1002<<1;
|
||
|
|
var $1004=(($1003)&255);
|
||
|
|
$mixmask=$1004;
|
||
|
|
var $1005=$mixmask;
|
||
|
|
var $1006=($1005&255);
|
||
|
|
var $1007=($1006|0)==0;
|
||
|
|
if($1007){label=155;break;}else{label=159;break;}
|
||
|
|
case 155:
|
||
|
|
var $1009=$fom_mask;
|
||
|
|
var $1010=($1009|0)!=0;
|
||
|
|
if($1010){label=156;break;}else{label=157;break;}
|
||
|
|
case 156:
|
||
|
|
var $1012=$fom_mask;
|
||
|
|
var $1019=$1012;label=158;break;
|
||
|
|
case 157:
|
||
|
|
var $1014=$5;
|
||
|
|
var $1015=(($1014+1)|0);
|
||
|
|
$5=$1015;
|
||
|
|
var $1016=HEAP8[($1014)];
|
||
|
|
var $1017=($1016&255);
|
||
|
|
var $1019=$1017;label=158;break;
|
||
|
|
case 158:
|
||
|
|
var $1019;
|
||
|
|
var $1020=(($1019)&255);
|
||
|
|
$mask=$1020;
|
||
|
|
$mixmask=1;
|
||
|
|
label=159;break;
|
||
|
|
case 159:
|
||
|
|
var $1022=$mask;
|
||
|
|
var $1023=($1022&255);
|
||
|
|
var $1024=$mixmask;
|
||
|
|
var $1025=($1024&255);
|
||
|
|
var $1026=$1023&$1025;
|
||
|
|
var $1027=($1026|0)!=0;
|
||
|
|
if($1027){label=160;break;}else{label=161;break;}
|
||
|
|
case 160:
|
||
|
|
var $1029=$mix;
|
||
|
|
var $1030=$x;
|
||
|
|
var $1031=$line;
|
||
|
|
var $1032=(($1031+($1030<<1))|0);
|
||
|
|
HEAP16[(($1032)>>1)]=$1029;
|
||
|
|
label=162;break;
|
||
|
|
case 161:
|
||
|
|
var $1034=$x;
|
||
|
|
var $1035=$line;
|
||
|
|
var $1036=(($1035+($1034<<1))|0);
|
||
|
|
HEAP16[(($1036)>>1)]=0;
|
||
|
|
label=162;break;
|
||
|
|
case 162:
|
||
|
|
var $1038=$count;
|
||
|
|
var $1039=((($1038)-(1))|0);
|
||
|
|
$count=$1039;
|
||
|
|
var $1040=$x;
|
||
|
|
var $1041=((($1040)+(1))|0);
|
||
|
|
$x=$1041;
|
||
|
|
label=95;break;
|
||
|
|
case 163:
|
||
|
|
label=164;break;
|
||
|
|
case 164:
|
||
|
|
var $1044=$count;
|
||
|
|
var $1045=($1044|0)>0;
|
||
|
|
if($1045){label=165;break;}else{var $1051=0;label=166;break;}
|
||
|
|
case 165:
|
||
|
|
var $1047=$x;
|
||
|
|
var $1048=$3;
|
||
|
|
var $1049=($1047|0)<($1048|0);
|
||
|
|
var $1051=$1049;label=166;break;
|
||
|
|
case 166:
|
||
|
|
var $1051;
|
||
|
|
if($1051){label=167;break;}else{label=176;break;}
|
||
|
|
case 167:
|
||
|
|
var $1053=$mixmask;
|
||
|
|
var $1054=($1053&255);
|
||
|
|
var $1055=$1054<<1;
|
||
|
|
var $1056=(($1055)&255);
|
||
|
|
$mixmask=$1056;
|
||
|
|
var $1057=$mixmask;
|
||
|
|
var $1058=($1057&255);
|
||
|
|
var $1059=($1058|0)==0;
|
||
|
|
if($1059){label=168;break;}else{label=172;break;}
|
||
|
|
case 168:
|
||
|
|
var $1061=$fom_mask;
|
||
|
|
var $1062=($1061|0)!=0;
|
||
|
|
if($1062){label=169;break;}else{label=170;break;}
|
||
|
|
case 169:
|
||
|
|
var $1064=$fom_mask;
|
||
|
|
var $1071=$1064;label=171;break;
|
||
|
|
case 170:
|
||
|
|
var $1066=$5;
|
||
|
|
var $1067=(($1066+1)|0);
|
||
|
|
$5=$1067;
|
||
|
|
var $1068=HEAP8[($1066)];
|
||
|
|
var $1069=($1068&255);
|
||
|
|
var $1071=$1069;label=171;break;
|
||
|
|
case 171:
|
||
|
|
var $1071;
|
||
|
|
var $1072=(($1071)&255);
|
||
|
|
$mask=$1072;
|
||
|
|
$mixmask=1;
|
||
|
|
label=172;break;
|
||
|
|
case 172:
|
||
|
|
var $1074=$mask;
|
||
|
|
var $1075=($1074&255);
|
||
|
|
var $1076=$mixmask;
|
||
|
|
var $1077=($1076&255);
|
||
|
|
var $1078=$1075&$1077;
|
||
|
|
var $1079=($1078|0)!=0;
|
||
|
|
if($1079){label=173;break;}else{label=174;break;}
|
||
|
|
case 173:
|
||
|
|
var $1081=$mix;
|
||
|
|
var $1082=$x;
|
||
|
|
var $1083=$line;
|
||
|
|
var $1084=(($1083+($1082<<1))|0);
|
||
|
|
HEAP16[(($1084)>>1)]=$1081;
|
||
|
|
label=175;break;
|
||
|
|
case 174:
|
||
|
|
var $1086=$x;
|
||
|
|
var $1087=$line;
|
||
|
|
var $1088=(($1087+($1086<<1))|0);
|
||
|
|
HEAP16[(($1088)>>1)]=0;
|
||
|
|
label=175;break;
|
||
|
|
case 175:
|
||
|
|
var $1090=$count;
|
||
|
|
var $1091=((($1090)-(1))|0);
|
||
|
|
$count=$1091;
|
||
|
|
var $1092=$x;
|
||
|
|
var $1093=((($1092)+(1))|0);
|
||
|
|
$x=$1093;
|
||
|
|
label=164;break;
|
||
|
|
case 176:
|
||
|
|
label=260;break;
|
||
|
|
case 177:
|
||
|
|
label=178;break;
|
||
|
|
case 178:
|
||
|
|
var $1097=$count;
|
||
|
|
var $1098=$1097&-8;
|
||
|
|
var $1099=($1098|0)!=0;
|
||
|
|
if($1099){label=179;break;}else{var $1106=0;label=180;break;}
|
||
|
|
case 179:
|
||
|
|
var $1101=$x;
|
||
|
|
var $1102=((($1101)+(8))|0);
|
||
|
|
var $1103=$3;
|
||
|
|
var $1104=($1102|0)<($1103|0);
|
||
|
|
var $1106=$1104;label=180;break;
|
||
|
|
case 180:
|
||
|
|
var $1106;
|
||
|
|
if($1106){label=181;break;}else{label=246;break;}
|
||
|
|
case 181:
|
||
|
|
var $1108=$mixmask;
|
||
|
|
var $1109=($1108&255);
|
||
|
|
var $1110=$1109<<1;
|
||
|
|
var $1111=(($1110)&255);
|
||
|
|
$mixmask=$1111;
|
||
|
|
var $1112=$mixmask;
|
||
|
|
var $1113=($1112&255);
|
||
|
|
var $1114=($1113|0)==0;
|
||
|
|
if($1114){label=182;break;}else{label=186;break;}
|
||
|
|
case 182:
|
||
|
|
var $1116=$fom_mask;
|
||
|
|
var $1117=($1116|0)!=0;
|
||
|
|
if($1117){label=183;break;}else{label=184;break;}
|
||
|
|
case 183:
|
||
|
|
var $1119=$fom_mask;
|
||
|
|
var $1126=$1119;label=185;break;
|
||
|
|
case 184:
|
||
|
|
var $1121=$5;
|
||
|
|
var $1122=(($1121+1)|0);
|
||
|
|
$5=$1122;
|
||
|
|
var $1123=HEAP8[($1121)];
|
||
|
|
var $1124=($1123&255);
|
||
|
|
var $1126=$1124;label=185;break;
|
||
|
|
case 185:
|
||
|
|
var $1126;
|
||
|
|
var $1127=(($1126)&255);
|
||
|
|
$mask=$1127;
|
||
|
|
$mixmask=1;
|
||
|
|
label=186;break;
|
||
|
|
case 186:
|
||
|
|
var $1129=$mask;
|
||
|
|
var $1130=($1129&255);
|
||
|
|
var $1131=$mixmask;
|
||
|
|
var $1132=($1131&255);
|
||
|
|
var $1133=$1130&$1132;
|
||
|
|
var $1134=($1133|0)!=0;
|
||
|
|
if($1134){label=187;break;}else{label=188;break;}
|
||
|
|
case 187:
|
||
|
|
var $1136=$x;
|
||
|
|
var $1137=$prevline;
|
||
|
|
var $1138=(($1137+($1136<<1))|0);
|
||
|
|
var $1139=HEAP16[(($1138)>>1)];
|
||
|
|
var $1140=($1139&65535);
|
||
|
|
var $1141=$mix;
|
||
|
|
var $1142=($1141&65535);
|
||
|
|
var $1143=$1140^$1142;
|
||
|
|
var $1144=(($1143)&65535);
|
||
|
|
var $1145=$x;
|
||
|
|
var $1146=$line;
|
||
|
|
var $1147=(($1146+($1145<<1))|0);
|
||
|
|
HEAP16[(($1147)>>1)]=$1144;
|
||
|
|
label=189;break;
|
||
|
|
case 188:
|
||
|
|
var $1149=$x;
|
||
|
|
var $1150=$prevline;
|
||
|
|
var $1151=(($1150+($1149<<1))|0);
|
||
|
|
var $1152=HEAP16[(($1151)>>1)];
|
||
|
|
var $1153=$x;
|
||
|
|
var $1154=$line;
|
||
|
|
var $1155=(($1154+($1153<<1))|0);
|
||
|
|
HEAP16[(($1155)>>1)]=$1152;
|
||
|
|
label=189;break;
|
||
|
|
case 189:
|
||
|
|
var $1157=$count;
|
||
|
|
var $1158=((($1157)-(1))|0);
|
||
|
|
$count=$1158;
|
||
|
|
var $1159=$x;
|
||
|
|
var $1160=((($1159)+(1))|0);
|
||
|
|
$x=$1160;
|
||
|
|
var $1161=$mixmask;
|
||
|
|
var $1162=($1161&255);
|
||
|
|
var $1163=$1162<<1;
|
||
|
|
var $1164=(($1163)&255);
|
||
|
|
$mixmask=$1164;
|
||
|
|
var $1165=$mixmask;
|
||
|
|
var $1166=($1165&255);
|
||
|
|
var $1167=($1166|0)==0;
|
||
|
|
if($1167){label=190;break;}else{label=194;break;}
|
||
|
|
case 190:
|
||
|
|
var $1169=$fom_mask;
|
||
|
|
var $1170=($1169|0)!=0;
|
||
|
|
if($1170){label=191;break;}else{label=192;break;}
|
||
|
|
case 191:
|
||
|
|
var $1172=$fom_mask;
|
||
|
|
var $1179=$1172;label=193;break;
|
||
|
|
case 192:
|
||
|
|
var $1174=$5;
|
||
|
|
var $1175=(($1174+1)|0);
|
||
|
|
$5=$1175;
|
||
|
|
var $1176=HEAP8[($1174)];
|
||
|
|
var $1177=($1176&255);
|
||
|
|
var $1179=$1177;label=193;break;
|
||
|
|
case 193:
|
||
|
|
var $1179;
|
||
|
|
var $1180=(($1179)&255);
|
||
|
|
$mask=$1180;
|
||
|
|
$mixmask=1;
|
||
|
|
label=194;break;
|
||
|
|
case 194:
|
||
|
|
var $1182=$mask;
|
||
|
|
var $1183=($1182&255);
|
||
|
|
var $1184=$mixmask;
|
||
|
|
var $1185=($1184&255);
|
||
|
|
var $1186=$1183&$1185;
|
||
|
|
var $1187=($1186|0)!=0;
|
||
|
|
if($1187){label=195;break;}else{label=196;break;}
|
||
|
|
case 195:
|
||
|
|
var $1189=$x;
|
||
|
|
var $1190=$prevline;
|
||
|
|
var $1191=(($1190+($1189<<1))|0);
|
||
|
|
var $1192=HEAP16[(($1191)>>1)];
|
||
|
|
var $1193=($1192&65535);
|
||
|
|
var $1194=$mix;
|
||
|
|
var $1195=($1194&65535);
|
||
|
|
var $1196=$1193^$1195;
|
||
|
|
var $1197=(($1196)&65535);
|
||
|
|
var $1198=$x;
|
||
|
|
var $1199=$line;
|
||
|
|
var $1200=(($1199+($1198<<1))|0);
|
||
|
|
HEAP16[(($1200)>>1)]=$1197;
|
||
|
|
label=197;break;
|
||
|
|
case 196:
|
||
|
|
var $1202=$x;
|
||
|
|
var $1203=$prevline;
|
||
|
|
var $1204=(($1203+($1202<<1))|0);
|
||
|
|
var $1205=HEAP16[(($1204)>>1)];
|
||
|
|
var $1206=$x;
|
||
|
|
var $1207=$line;
|
||
|
|
var $1208=(($1207+($1206<<1))|0);
|
||
|
|
HEAP16[(($1208)>>1)]=$1205;
|
||
|
|
label=197;break;
|
||
|
|
case 197:
|
||
|
|
var $1210=$count;
|
||
|
|
var $1211=((($1210)-(1))|0);
|
||
|
|
$count=$1211;
|
||
|
|
var $1212=$x;
|
||
|
|
var $1213=((($1212)+(1))|0);
|
||
|
|
$x=$1213;
|
||
|
|
var $1214=$mixmask;
|
||
|
|
var $1215=($1214&255);
|
||
|
|
var $1216=$1215<<1;
|
||
|
|
var $1217=(($1216)&255);
|
||
|
|
$mixmask=$1217;
|
||
|
|
var $1218=$mixmask;
|
||
|
|
var $1219=($1218&255);
|
||
|
|
var $1220=($1219|0)==0;
|
||
|
|
if($1220){label=198;break;}else{label=202;break;}
|
||
|
|
case 198:
|
||
|
|
var $1222=$fom_mask;
|
||
|
|
var $1223=($1222|0)!=0;
|
||
|
|
if($1223){label=199;break;}else{label=200;break;}
|
||
|
|
case 199:
|
||
|
|
var $1225=$fom_mask;
|
||
|
|
var $1232=$1225;label=201;break;
|
||
|
|
case 200:
|
||
|
|
var $1227=$5;
|
||
|
|
var $1228=(($1227+1)|0);
|
||
|
|
$5=$1228;
|
||
|
|
var $1229=HEAP8[($1227)];
|
||
|
|
var $1230=($1229&255);
|
||
|
|
var $1232=$1230;label=201;break;
|
||
|
|
case 201:
|
||
|
|
var $1232;
|
||
|
|
var $1233=(($1232)&255);
|
||
|
|
$mask=$1233;
|
||
|
|
$mixmask=1;
|
||
|
|
label=202;break;
|
||
|
|
case 202:
|
||
|
|
var $1235=$mask;
|
||
|
|
var $1236=($1235&255);
|
||
|
|
var $1237=$mixmask;
|
||
|
|
var $1238=($1237&255);
|
||
|
|
var $1239=$1236&$1238;
|
||
|
|
var $1240=($1239|0)!=0;
|
||
|
|
if($1240){label=203;break;}else{label=204;break;}
|
||
|
|
case 203:
|
||
|
|
var $1242=$x;
|
||
|
|
var $1243=$prevline;
|
||
|
|
var $1244=(($1243+($1242<<1))|0);
|
||
|
|
var $1245=HEAP16[(($1244)>>1)];
|
||
|
|
var $1246=($1245&65535);
|
||
|
|
var $1247=$mix;
|
||
|
|
var $1248=($1247&65535);
|
||
|
|
var $1249=$1246^$1248;
|
||
|
|
var $1250=(($1249)&65535);
|
||
|
|
var $1251=$x;
|
||
|
|
var $1252=$line;
|
||
|
|
var $1253=(($1252+($1251<<1))|0);
|
||
|
|
HEAP16[(($1253)>>1)]=$1250;
|
||
|
|
label=205;break;
|
||
|
|
case 204:
|
||
|
|
var $1255=$x;
|
||
|
|
var $1256=$prevline;
|
||
|
|
var $1257=(($1256+($1255<<1))|0);
|
||
|
|
var $1258=HEAP16[(($1257)>>1)];
|
||
|
|
var $1259=$x;
|
||
|
|
var $1260=$line;
|
||
|
|
var $1261=(($1260+($1259<<1))|0);
|
||
|
|
HEAP16[(($1261)>>1)]=$1258;
|
||
|
|
label=205;break;
|
||
|
|
case 205:
|
||
|
|
var $1263=$count;
|
||
|
|
var $1264=((($1263)-(1))|0);
|
||
|
|
$count=$1264;
|
||
|
|
var $1265=$x;
|
||
|
|
var $1266=((($1265)+(1))|0);
|
||
|
|
$x=$1266;
|
||
|
|
var $1267=$mixmask;
|
||
|
|
var $1268=($1267&255);
|
||
|
|
var $1269=$1268<<1;
|
||
|
|
var $1270=(($1269)&255);
|
||
|
|
$mixmask=$1270;
|
||
|
|
var $1271=$mixmask;
|
||
|
|
var $1272=($1271&255);
|
||
|
|
var $1273=($1272|0)==0;
|
||
|
|
if($1273){label=206;break;}else{label=210;break;}
|
||
|
|
case 206:
|
||
|
|
var $1275=$fom_mask;
|
||
|
|
var $1276=($1275|0)!=0;
|
||
|
|
if($1276){label=207;break;}else{label=208;break;}
|
||
|
|
case 207:
|
||
|
|
var $1278=$fom_mask;
|
||
|
|
var $1285=$1278;label=209;break;
|
||
|
|
case 208:
|
||
|
|
var $1280=$5;
|
||
|
|
var $1281=(($1280+1)|0);
|
||
|
|
$5=$1281;
|
||
|
|
var $1282=HEAP8[($1280)];
|
||
|
|
var $1283=($1282&255);
|
||
|
|
var $1285=$1283;label=209;break;
|
||
|
|
case 209:
|
||
|
|
var $1285;
|
||
|
|
var $1286=(($1285)&255);
|
||
|
|
$mask=$1286;
|
||
|
|
$mixmask=1;
|
||
|
|
label=210;break;
|
||
|
|
case 210:
|
||
|
|
var $1288=$mask;
|
||
|
|
var $1289=($1288&255);
|
||
|
|
var $1290=$mixmask;
|
||
|
|
var $1291=($1290&255);
|
||
|
|
var $1292=$1289&$1291;
|
||
|
|
var $1293=($1292|0)!=0;
|
||
|
|
if($1293){label=211;break;}else{label=212;break;}
|
||
|
|
case 211:
|
||
|
|
var $1295=$x;
|
||
|
|
var $1296=$prevline;
|
||
|
|
var $1297=(($1296+($1295<<1))|0);
|
||
|
|
var $1298=HEAP16[(($1297)>>1)];
|
||
|
|
var $1299=($1298&65535);
|
||
|
|
var $1300=$mix;
|
||
|
|
var $1301=($1300&65535);
|
||
|
|
var $1302=$1299^$1301;
|
||
|
|
var $1303=(($1302)&65535);
|
||
|
|
var $1304=$x;
|
||
|
|
var $1305=$line;
|
||
|
|
var $1306=(($1305+($1304<<1))|0);
|
||
|
|
HEAP16[(($1306)>>1)]=$1303;
|
||
|
|
label=213;break;
|
||
|
|
case 212:
|
||
|
|
var $1308=$x;
|
||
|
|
var $1309=$prevline;
|
||
|
|
var $1310=(($1309+($1308<<1))|0);
|
||
|
|
var $1311=HEAP16[(($1310)>>1)];
|
||
|
|
var $1312=$x;
|
||
|
|
var $1313=$line;
|
||
|
|
var $1314=(($1313+($1312<<1))|0);
|
||
|
|
HEAP16[(($1314)>>1)]=$1311;
|
||
|
|
label=213;break;
|
||
|
|
case 213:
|
||
|
|
var $1316=$count;
|
||
|
|
var $1317=((($1316)-(1))|0);
|
||
|
|
$count=$1317;
|
||
|
|
var $1318=$x;
|
||
|
|
var $1319=((($1318)+(1))|0);
|
||
|
|
$x=$1319;
|
||
|
|
var $1320=$mixmask;
|
||
|
|
var $1321=($1320&255);
|
||
|
|
var $1322=$1321<<1;
|
||
|
|
var $1323=(($1322)&255);
|
||
|
|
$mixmask=$1323;
|
||
|
|
var $1324=$mixmask;
|
||
|
|
var $1325=($1324&255);
|
||
|
|
var $1326=($1325|0)==0;
|
||
|
|
if($1326){label=214;break;}else{label=218;break;}
|
||
|
|
case 214:
|
||
|
|
var $1328=$fom_mask;
|
||
|
|
var $1329=($1328|0)!=0;
|
||
|
|
if($1329){label=215;break;}else{label=216;break;}
|
||
|
|
case 215:
|
||
|
|
var $1331=$fom_mask;
|
||
|
|
var $1338=$1331;label=217;break;
|
||
|
|
case 216:
|
||
|
|
var $1333=$5;
|
||
|
|
var $1334=(($1333+1)|0);
|
||
|
|
$5=$1334;
|
||
|
|
var $1335=HEAP8[($1333)];
|
||
|
|
var $1336=($1335&255);
|
||
|
|
var $1338=$1336;label=217;break;
|
||
|
|
case 217:
|
||
|
|
var $1338;
|
||
|
|
var $1339=(($1338)&255);
|
||
|
|
$mask=$1339;
|
||
|
|
$mixmask=1;
|
||
|
|
label=218;break;
|
||
|
|
case 218:
|
||
|
|
var $1341=$mask;
|
||
|
|
var $1342=($1341&255);
|
||
|
|
var $1343=$mixmask;
|
||
|
|
var $1344=($1343&255);
|
||
|
|
var $1345=$1342&$1344;
|
||
|
|
var $1346=($1345|0)!=0;
|
||
|
|
if($1346){label=219;break;}else{label=220;break;}
|
||
|
|
case 219:
|
||
|
|
var $1348=$x;
|
||
|
|
var $1349=$prevline;
|
||
|
|
var $1350=(($1349+($1348<<1))|0);
|
||
|
|
var $1351=HEAP16[(($1350)>>1)];
|
||
|
|
var $1352=($1351&65535);
|
||
|
|
var $1353=$mix;
|
||
|
|
var $1354=($1353&65535);
|
||
|
|
var $1355=$1352^$1354;
|
||
|
|
var $1356=(($1355)&65535);
|
||
|
|
var $1357=$x;
|
||
|
|
var $1358=$line;
|
||
|
|
var $1359=(($1358+($1357<<1))|0);
|
||
|
|
HEAP16[(($1359)>>1)]=$1356;
|
||
|
|
label=221;break;
|
||
|
|
case 220:
|
||
|
|
var $1361=$x;
|
||
|
|
var $1362=$prevline;
|
||
|
|
var $1363=(($1362+($1361<<1))|0);
|
||
|
|
var $1364=HEAP16[(($1363)>>1)];
|
||
|
|
var $1365=$x;
|
||
|
|
var $1366=$line;
|
||
|
|
var $1367=(($1366+($1365<<1))|0);
|
||
|
|
HEAP16[(($1367)>>1)]=$1364;
|
||
|
|
label=221;break;
|
||
|
|
case 221:
|
||
|
|
var $1369=$count;
|
||
|
|
var $1370=((($1369)-(1))|0);
|
||
|
|
$count=$1370;
|
||
|
|
var $1371=$x;
|
||
|
|
var $1372=((($1371)+(1))|0);
|
||
|
|
$x=$1372;
|
||
|
|
var $1373=$mixmask;
|
||
|
|
var $1374=($1373&255);
|
||
|
|
var $1375=$1374<<1;
|
||
|
|
var $1376=(($1375)&255);
|
||
|
|
$mixmask=$1376;
|
||
|
|
var $1377=$mixmask;
|
||
|
|
var $1378=($1377&255);
|
||
|
|
var $1379=($1378|0)==0;
|
||
|
|
if($1379){label=222;break;}else{label=226;break;}
|
||
|
|
case 222:
|
||
|
|
var $1381=$fom_mask;
|
||
|
|
var $1382=($1381|0)!=0;
|
||
|
|
if($1382){label=223;break;}else{label=224;break;}
|
||
|
|
case 223:
|
||
|
|
var $1384=$fom_mask;
|
||
|
|
var $1391=$1384;label=225;break;
|
||
|
|
case 224:
|
||
|
|
var $1386=$5;
|
||
|
|
var $1387=(($1386+1)|0);
|
||
|
|
$5=$1387;
|
||
|
|
var $1388=HEAP8[($1386)];
|
||
|
|
var $1389=($1388&255);
|
||
|
|
var $1391=$1389;label=225;break;
|
||
|
|
case 225:
|
||
|
|
var $1391;
|
||
|
|
var $1392=(($1391)&255);
|
||
|
|
$mask=$1392;
|
||
|
|
$mixmask=1;
|
||
|
|
label=226;break;
|
||
|
|
case 226:
|
||
|
|
var $1394=$mask;
|
||
|
|
var $1395=($1394&255);
|
||
|
|
var $1396=$mixmask;
|
||
|
|
var $1397=($1396&255);
|
||
|
|
var $1398=$1395&$1397;
|
||
|
|
var $1399=($1398|0)!=0;
|
||
|
|
if($1399){label=227;break;}else{label=228;break;}
|
||
|
|
case 227:
|
||
|
|
var $1401=$x;
|
||
|
|
var $1402=$prevline;
|
||
|
|
var $1403=(($1402+($1401<<1))|0);
|
||
|
|
var $1404=HEAP16[(($1403)>>1)];
|
||
|
|
var $1405=($1404&65535);
|
||
|
|
var $1406=$mix;
|
||
|
|
var $1407=($1406&65535);
|
||
|
|
var $1408=$1405^$1407;
|
||
|
|
var $1409=(($1408)&65535);
|
||
|
|
var $1410=$x;
|
||
|
|
var $1411=$line;
|
||
|
|
var $1412=(($1411+($1410<<1))|0);
|
||
|
|
HEAP16[(($1412)>>1)]=$1409;
|
||
|
|
label=229;break;
|
||
|
|
case 228:
|
||
|
|
var $1414=$x;
|
||
|
|
var $1415=$prevline;
|
||
|
|
var $1416=(($1415+($1414<<1))|0);
|
||
|
|
var $1417=HEAP16[(($1416)>>1)];
|
||
|
|
var $1418=$x;
|
||
|
|
var $1419=$line;
|
||
|
|
var $1420=(($1419+($1418<<1))|0);
|
||
|
|
HEAP16[(($1420)>>1)]=$1417;
|
||
|
|
label=229;break;
|
||
|
|
case 229:
|
||
|
|
var $1422=$count;
|
||
|
|
var $1423=((($1422)-(1))|0);
|
||
|
|
$count=$1423;
|
||
|
|
var $1424=$x;
|
||
|
|
var $1425=((($1424)+(1))|0);
|
||
|
|
$x=$1425;
|
||
|
|
var $1426=$mixmask;
|
||
|
|
var $1427=($1426&255);
|
||
|
|
var $1428=$1427<<1;
|
||
|
|
var $1429=(($1428)&255);
|
||
|
|
$mixmask=$1429;
|
||
|
|
var $1430=$mixmask;
|
||
|
|
var $1431=($1430&255);
|
||
|
|
var $1432=($1431|0)==0;
|
||
|
|
if($1432){label=230;break;}else{label=234;break;}
|
||
|
|
case 230:
|
||
|
|
var $1434=$fom_mask;
|
||
|
|
var $1435=($1434|0)!=0;
|
||
|
|
if($1435){label=231;break;}else{label=232;break;}
|
||
|
|
case 231:
|
||
|
|
var $1437=$fom_mask;
|
||
|
|
var $1444=$1437;label=233;break;
|
||
|
|
case 232:
|
||
|
|
var $1439=$5;
|
||
|
|
var $1440=(($1439+1)|0);
|
||
|
|
$5=$1440;
|
||
|
|
var $1441=HEAP8[($1439)];
|
||
|
|
var $1442=($1441&255);
|
||
|
|
var $1444=$1442;label=233;break;
|
||
|
|
case 233:
|
||
|
|
var $1444;
|
||
|
|
var $1445=(($1444)&255);
|
||
|
|
$mask=$1445;
|
||
|
|
$mixmask=1;
|
||
|
|
label=234;break;
|
||
|
|
case 234:
|
||
|
|
var $1447=$mask;
|
||
|
|
var $1448=($1447&255);
|
||
|
|
var $1449=$mixmask;
|
||
|
|
var $1450=($1449&255);
|
||
|
|
var $1451=$1448&$1450;
|
||
|
|
var $1452=($1451|0)!=0;
|
||
|
|
if($1452){label=235;break;}else{label=236;break;}
|
||
|
|
case 235:
|
||
|
|
var $1454=$x;
|
||
|
|
var $1455=$prevline;
|
||
|
|
var $1456=(($1455+($1454<<1))|0);
|
||
|
|
var $1457=HEAP16[(($1456)>>1)];
|
||
|
|
var $1458=($1457&65535);
|
||
|
|
var $1459=$mix;
|
||
|
|
var $1460=($1459&65535);
|
||
|
|
var $1461=$1458^$1460;
|
||
|
|
var $1462=(($1461)&65535);
|
||
|
|
var $1463=$x;
|
||
|
|
var $1464=$line;
|
||
|
|
var $1465=(($1464+($1463<<1))|0);
|
||
|
|
HEAP16[(($1465)>>1)]=$1462;
|
||
|
|
label=237;break;
|
||
|
|
case 236:
|
||
|
|
var $1467=$x;
|
||
|
|
var $1468=$prevline;
|
||
|
|
var $1469=(($1468+($1467<<1))|0);
|
||
|
|
var $1470=HEAP16[(($1469)>>1)];
|
||
|
|
var $1471=$x;
|
||
|
|
var $1472=$line;
|
||
|
|
var $1473=(($1472+($1471<<1))|0);
|
||
|
|
HEAP16[(($1473)>>1)]=$1470;
|
||
|
|
label=237;break;
|
||
|
|
case 237:
|
||
|
|
var $1475=$count;
|
||
|
|
var $1476=((($1475)-(1))|0);
|
||
|
|
$count=$1476;
|
||
|
|
var $1477=$x;
|
||
|
|
var $1478=((($1477)+(1))|0);
|
||
|
|
$x=$1478;
|
||
|
|
var $1479=$mixmask;
|
||
|
|
var $1480=($1479&255);
|
||
|
|
var $1481=$1480<<1;
|
||
|
|
var $1482=(($1481)&255);
|
||
|
|
$mixmask=$1482;
|
||
|
|
var $1483=$mixmask;
|
||
|
|
var $1484=($1483&255);
|
||
|
|
var $1485=($1484|0)==0;
|
||
|
|
if($1485){label=238;break;}else{label=242;break;}
|
||
|
|
case 238:
|
||
|
|
var $1487=$fom_mask;
|
||
|
|
var $1488=($1487|0)!=0;
|
||
|
|
if($1488){label=239;break;}else{label=240;break;}
|
||
|
|
case 239:
|
||
|
|
var $1490=$fom_mask;
|
||
|
|
var $1497=$1490;label=241;break;
|
||
|
|
case 240:
|
||
|
|
var $1492=$5;
|
||
|
|
var $1493=(($1492+1)|0);
|
||
|
|
$5=$1493;
|
||
|
|
var $1494=HEAP8[($1492)];
|
||
|
|
var $1495=($1494&255);
|
||
|
|
var $1497=$1495;label=241;break;
|
||
|
|
case 241:
|
||
|
|
var $1497;
|
||
|
|
var $1498=(($1497)&255);
|
||
|
|
$mask=$1498;
|
||
|
|
$mixmask=1;
|
||
|
|
label=242;break;
|
||
|
|
case 242:
|
||
|
|
var $1500=$mask;
|
||
|
|
var $1501=($1500&255);
|
||
|
|
var $1502=$mixmask;
|
||
|
|
var $1503=($1502&255);
|
||
|
|
var $1504=$1501&$1503;
|
||
|
|
var $1505=($1504|0)!=0;
|
||
|
|
if($1505){label=243;break;}else{label=244;break;}
|
||
|
|
case 243:
|
||
|
|
var $1507=$x;
|
||
|
|
var $1508=$prevline;
|
||
|
|
var $1509=(($1508+($1507<<1))|0);
|
||
|
|
var $1510=HEAP16[(($1509)>>1)];
|
||
|
|
var $1511=($1510&65535);
|
||
|
|
var $1512=$mix;
|
||
|
|
var $1513=($1512&65535);
|
||
|
|
var $1514=$1511^$1513;
|
||
|
|
var $1515=(($1514)&65535);
|
||
|
|
var $1516=$x;
|
||
|
|
var $1517=$line;
|
||
|
|
var $1518=(($1517+($1516<<1))|0);
|
||
|
|
HEAP16[(($1518)>>1)]=$1515;
|
||
|
|
label=245;break;
|
||
|
|
case 244:
|
||
|
|
var $1520=$x;
|
||
|
|
var $1521=$prevline;
|
||
|
|
var $1522=(($1521+($1520<<1))|0);
|
||
|
|
var $1523=HEAP16[(($1522)>>1)];
|
||
|
|
var $1524=$x;
|
||
|
|
var $1525=$line;
|
||
|
|
var $1526=(($1525+($1524<<1))|0);
|
||
|
|
HEAP16[(($1526)>>1)]=$1523;
|
||
|
|
label=245;break;
|
||
|
|
case 245:
|
||
|
|
var $1528=$count;
|
||
|
|
var $1529=((($1528)-(1))|0);
|
||
|
|
$count=$1529;
|
||
|
|
var $1530=$x;
|
||
|
|
var $1531=((($1530)+(1))|0);
|
||
|
|
$x=$1531;
|
||
|
|
label=178;break;
|
||
|
|
case 246:
|
||
|
|
label=247;break;
|
||
|
|
case 247:
|
||
|
|
var $1534=$count;
|
||
|
|
var $1535=($1534|0)>0;
|
||
|
|
if($1535){label=248;break;}else{var $1541=0;label=249;break;}
|
||
|
|
case 248:
|
||
|
|
var $1537=$x;
|
||
|
|
var $1538=$3;
|
||
|
|
var $1539=($1537|0)<($1538|0);
|
||
|
|
var $1541=$1539;label=249;break;
|
||
|
|
case 249:
|
||
|
|
var $1541;
|
||
|
|
if($1541){label=250;break;}else{label=259;break;}
|
||
|
|
case 250:
|
||
|
|
var $1543=$mixmask;
|
||
|
|
var $1544=($1543&255);
|
||
|
|
var $1545=$1544<<1;
|
||
|
|
var $1546=(($1545)&255);
|
||
|
|
$mixmask=$1546;
|
||
|
|
var $1547=$mixmask;
|
||
|
|
var $1548=($1547&255);
|
||
|
|
var $1549=($1548|0)==0;
|
||
|
|
if($1549){label=251;break;}else{label=255;break;}
|
||
|
|
case 251:
|
||
|
|
var $1551=$fom_mask;
|
||
|
|
var $1552=($1551|0)!=0;
|
||
|
|
if($1552){label=252;break;}else{label=253;break;}
|
||
|
|
case 252:
|
||
|
|
var $1554=$fom_mask;
|
||
|
|
var $1561=$1554;label=254;break;
|
||
|
|
case 253:
|
||
|
|
var $1556=$5;
|
||
|
|
var $1557=(($1556+1)|0);
|
||
|
|
$5=$1557;
|
||
|
|
var $1558=HEAP8[($1556)];
|
||
|
|
var $1559=($1558&255);
|
||
|
|
var $1561=$1559;label=254;break;
|
||
|
|
case 254:
|
||
|
|
var $1561;
|
||
|
|
var $1562=(($1561)&255);
|
||
|
|
$mask=$1562;
|
||
|
|
$mixmask=1;
|
||
|
|
label=255;break;
|
||
|
|
case 255:
|
||
|
|
var $1564=$mask;
|
||
|
|
var $1565=($1564&255);
|
||
|
|
var $1566=$mixmask;
|
||
|
|
var $1567=($1566&255);
|
||
|
|
var $1568=$1565&$1567;
|
||
|
|
var $1569=($1568|0)!=0;
|
||
|
|
if($1569){label=256;break;}else{label=257;break;}
|
||
|
|
case 256:
|
||
|
|
var $1571=$x;
|
||
|
|
var $1572=$prevline;
|
||
|
|
var $1573=(($1572+($1571<<1))|0);
|
||
|
|
var $1574=HEAP16[(($1573)>>1)];
|
||
|
|
var $1575=($1574&65535);
|
||
|
|
var $1576=$mix;
|
||
|
|
var $1577=($1576&65535);
|
||
|
|
var $1578=$1575^$1577;
|
||
|
|
var $1579=(($1578)&65535);
|
||
|
|
var $1580=$x;
|
||
|
|
var $1581=$line;
|
||
|
|
var $1582=(($1581+($1580<<1))|0);
|
||
|
|
HEAP16[(($1582)>>1)]=$1579;
|
||
|
|
label=258;break;
|
||
|
|
case 257:
|
||
|
|
var $1584=$x;
|
||
|
|
var $1585=$prevline;
|
||
|
|
var $1586=(($1585+($1584<<1))|0);
|
||
|
|
var $1587=HEAP16[(($1586)>>1)];
|
||
|
|
var $1588=$x;
|
||
|
|
var $1589=$line;
|
||
|
|
var $1590=(($1589+($1588<<1))|0);
|
||
|
|
HEAP16[(($1590)>>1)]=$1587;
|
||
|
|
label=258;break;
|
||
|
|
case 258:
|
||
|
|
var $1592=$count;
|
||
|
|
var $1593=((($1592)-(1))|0);
|
||
|
|
$count=$1593;
|
||
|
|
var $1594=$x;
|
||
|
|
var $1595=((($1594)+(1))|0);
|
||
|
|
$x=$1595;
|
||
|
|
label=247;break;
|
||
|
|
case 259:
|
||
|
|
label=260;break;
|
||
|
|
case 260:
|
||
|
|
label=344;break;
|
||
|
|
case 261:
|
||
|
|
label=262;break;
|
||
|
|
case 262:
|
||
|
|
var $1600=$count;
|
||
|
|
var $1601=$1600&-8;
|
||
|
|
var $1602=($1601|0)!=0;
|
||
|
|
if($1602){label=263;break;}else{var $1609=0;label=264;break;}
|
||
|
|
case 263:
|
||
|
|
var $1604=$x;
|
||
|
|
var $1605=((($1604)+(8))|0);
|
||
|
|
var $1606=$3;
|
||
|
|
var $1607=($1605|0)<($1606|0);
|
||
|
|
var $1609=$1607;label=264;break;
|
||
|
|
case 264:
|
||
|
|
var $1609;
|
||
|
|
if($1609){label=265;break;}else{label=266;break;}
|
||
|
|
case 265:
|
||
|
|
var $1611=$colour2;
|
||
|
|
var $1612=$x;
|
||
|
|
var $1613=$line;
|
||
|
|
var $1614=(($1613+($1612<<1))|0);
|
||
|
|
HEAP16[(($1614)>>1)]=$1611;
|
||
|
|
var $1615=$count;
|
||
|
|
var $1616=((($1615)-(1))|0);
|
||
|
|
$count=$1616;
|
||
|
|
var $1617=$x;
|
||
|
|
var $1618=((($1617)+(1))|0);
|
||
|
|
$x=$1618;
|
||
|
|
var $1619=$colour2;
|
||
|
|
var $1620=$x;
|
||
|
|
var $1621=$line;
|
||
|
|
var $1622=(($1621+($1620<<1))|0);
|
||
|
|
HEAP16[(($1622)>>1)]=$1619;
|
||
|
|
var $1623=$count;
|
||
|
|
var $1624=((($1623)-(1))|0);
|
||
|
|
$count=$1624;
|
||
|
|
var $1625=$x;
|
||
|
|
var $1626=((($1625)+(1))|0);
|
||
|
|
$x=$1626;
|
||
|
|
var $1627=$colour2;
|
||
|
|
var $1628=$x;
|
||
|
|
var $1629=$line;
|
||
|
|
var $1630=(($1629+($1628<<1))|0);
|
||
|
|
HEAP16[(($1630)>>1)]=$1627;
|
||
|
|
var $1631=$count;
|
||
|
|
var $1632=((($1631)-(1))|0);
|
||
|
|
$count=$1632;
|
||
|
|
var $1633=$x;
|
||
|
|
var $1634=((($1633)+(1))|0);
|
||
|
|
$x=$1634;
|
||
|
|
var $1635=$colour2;
|
||
|
|
var $1636=$x;
|
||
|
|
var $1637=$line;
|
||
|
|
var $1638=(($1637+($1636<<1))|0);
|
||
|
|
HEAP16[(($1638)>>1)]=$1635;
|
||
|
|
var $1639=$count;
|
||
|
|
var $1640=((($1639)-(1))|0);
|
||
|
|
$count=$1640;
|
||
|
|
var $1641=$x;
|
||
|
|
var $1642=((($1641)+(1))|0);
|
||
|
|
$x=$1642;
|
||
|
|
var $1643=$colour2;
|
||
|
|
var $1644=$x;
|
||
|
|
var $1645=$line;
|
||
|
|
var $1646=(($1645+($1644<<1))|0);
|
||
|
|
HEAP16[(($1646)>>1)]=$1643;
|
||
|
|
var $1647=$count;
|
||
|
|
var $1648=((($1647)-(1))|0);
|
||
|
|
$count=$1648;
|
||
|
|
var $1649=$x;
|
||
|
|
var $1650=((($1649)+(1))|0);
|
||
|
|
$x=$1650;
|
||
|
|
var $1651=$colour2;
|
||
|
|
var $1652=$x;
|
||
|
|
var $1653=$line;
|
||
|
|
var $1654=(($1653+($1652<<1))|0);
|
||
|
|
HEAP16[(($1654)>>1)]=$1651;
|
||
|
|
var $1655=$count;
|
||
|
|
var $1656=((($1655)-(1))|0);
|
||
|
|
$count=$1656;
|
||
|
|
var $1657=$x;
|
||
|
|
var $1658=((($1657)+(1))|0);
|
||
|
|
$x=$1658;
|
||
|
|
var $1659=$colour2;
|
||
|
|
var $1660=$x;
|
||
|
|
var $1661=$line;
|
||
|
|
var $1662=(($1661+($1660<<1))|0);
|
||
|
|
HEAP16[(($1662)>>1)]=$1659;
|
||
|
|
var $1663=$count;
|
||
|
|
var $1664=((($1663)-(1))|0);
|
||
|
|
$count=$1664;
|
||
|
|
var $1665=$x;
|
||
|
|
var $1666=((($1665)+(1))|0);
|
||
|
|
$x=$1666;
|
||
|
|
var $1667=$colour2;
|
||
|
|
var $1668=$x;
|
||
|
|
var $1669=$line;
|
||
|
|
var $1670=(($1669+($1668<<1))|0);
|
||
|
|
HEAP16[(($1670)>>1)]=$1667;
|
||
|
|
var $1671=$count;
|
||
|
|
var $1672=((($1671)-(1))|0);
|
||
|
|
$count=$1672;
|
||
|
|
var $1673=$x;
|
||
|
|
var $1674=((($1673)+(1))|0);
|
||
|
|
$x=$1674;
|
||
|
|
label=262;break;
|
||
|
|
case 266:
|
||
|
|
label=267;break;
|
||
|
|
case 267:
|
||
|
|
var $1677=$count;
|
||
|
|
var $1678=($1677|0)>0;
|
||
|
|
if($1678){label=268;break;}else{var $1684=0;label=269;break;}
|
||
|
|
case 268:
|
||
|
|
var $1680=$x;
|
||
|
|
var $1681=$3;
|
||
|
|
var $1682=($1680|0)<($1681|0);
|
||
|
|
var $1684=$1682;label=269;break;
|
||
|
|
case 269:
|
||
|
|
var $1684;
|
||
|
|
if($1684){label=270;break;}else{label=271;break;}
|
||
|
|
case 270:
|
||
|
|
var $1686=$colour2;
|
||
|
|
var $1687=$x;
|
||
|
|
var $1688=$line;
|
||
|
|
var $1689=(($1688+($1687<<1))|0);
|
||
|
|
HEAP16[(($1689)>>1)]=$1686;
|
||
|
|
var $1690=$count;
|
||
|
|
var $1691=((($1690)-(1))|0);
|
||
|
|
$count=$1691;
|
||
|
|
var $1692=$x;
|
||
|
|
var $1693=((($1692)+(1))|0);
|
||
|
|
$x=$1693;
|
||
|
|
label=267;break;
|
||
|
|
case 271:
|
||
|
|
label=344;break;
|
||
|
|
case 272:
|
||
|
|
label=273;break;
|
||
|
|
case 273:
|
||
|
|
var $1697=$count;
|
||
|
|
var $1698=$1697&-8;
|
||
|
|
var $1699=($1698|0)!=0;
|
||
|
|
if($1699){label=274;break;}else{var $1706=0;label=275;break;}
|
||
|
|
case 274:
|
||
|
|
var $1701=$x;
|
||
|
|
var $1702=((($1701)+(8))|0);
|
||
|
|
var $1703=$3;
|
||
|
|
var $1704=($1702|0)<($1703|0);
|
||
|
|
var $1706=$1704;label=275;break;
|
||
|
|
case 275:
|
||
|
|
var $1706;
|
||
|
|
if($1706){label=276;break;}else{label=277;break;}
|
||
|
|
case 276:
|
||
|
|
var $1708=$5;
|
||
|
|
var $1709=(($1708+1)|0);
|
||
|
|
$5=$1709;
|
||
|
|
var $1710=HEAP8[($1708)];
|
||
|
|
var $1711=($1710&255);
|
||
|
|
var $1712=$x;
|
||
|
|
var $1713=$line;
|
||
|
|
var $1714=(($1713+($1712<<1))|0);
|
||
|
|
HEAP16[(($1714)>>1)]=$1711;
|
||
|
|
var $1715=$5;
|
||
|
|
var $1716=(($1715+1)|0);
|
||
|
|
$5=$1716;
|
||
|
|
var $1717=HEAP8[($1715)];
|
||
|
|
var $1718=($1717&255);
|
||
|
|
var $1719=$1718<<8;
|
||
|
|
var $1720=$x;
|
||
|
|
var $1721=$line;
|
||
|
|
var $1722=(($1721+($1720<<1))|0);
|
||
|
|
var $1723=HEAP16[(($1722)>>1)];
|
||
|
|
var $1724=($1723&65535);
|
||
|
|
var $1725=$1724|$1719;
|
||
|
|
var $1726=(($1725)&65535);
|
||
|
|
HEAP16[(($1722)>>1)]=$1726;
|
||
|
|
var $1727=$count;
|
||
|
|
var $1728=((($1727)-(1))|0);
|
||
|
|
$count=$1728;
|
||
|
|
var $1729=$x;
|
||
|
|
var $1730=((($1729)+(1))|0);
|
||
|
|
$x=$1730;
|
||
|
|
var $1731=$5;
|
||
|
|
var $1732=(($1731+1)|0);
|
||
|
|
$5=$1732;
|
||
|
|
var $1733=HEAP8[($1731)];
|
||
|
|
var $1734=($1733&255);
|
||
|
|
var $1735=$x;
|
||
|
|
var $1736=$line;
|
||
|
|
var $1737=(($1736+($1735<<1))|0);
|
||
|
|
HEAP16[(($1737)>>1)]=$1734;
|
||
|
|
var $1738=$5;
|
||
|
|
var $1739=(($1738+1)|0);
|
||
|
|
$5=$1739;
|
||
|
|
var $1740=HEAP8[($1738)];
|
||
|
|
var $1741=($1740&255);
|
||
|
|
var $1742=$1741<<8;
|
||
|
|
var $1743=$x;
|
||
|
|
var $1744=$line;
|
||
|
|
var $1745=(($1744+($1743<<1))|0);
|
||
|
|
var $1746=HEAP16[(($1745)>>1)];
|
||
|
|
var $1747=($1746&65535);
|
||
|
|
var $1748=$1747|$1742;
|
||
|
|
var $1749=(($1748)&65535);
|
||
|
|
HEAP16[(($1745)>>1)]=$1749;
|
||
|
|
var $1750=$count;
|
||
|
|
var $1751=((($1750)-(1))|0);
|
||
|
|
$count=$1751;
|
||
|
|
var $1752=$x;
|
||
|
|
var $1753=((($1752)+(1))|0);
|
||
|
|
$x=$1753;
|
||
|
|
var $1754=$5;
|
||
|
|
var $1755=(($1754+1)|0);
|
||
|
|
$5=$1755;
|
||
|
|
var $1756=HEAP8[($1754)];
|
||
|
|
var $1757=($1756&255);
|
||
|
|
var $1758=$x;
|
||
|
|
var $1759=$line;
|
||
|
|
var $1760=(($1759+($1758<<1))|0);
|
||
|
|
HEAP16[(($1760)>>1)]=$1757;
|
||
|
|
var $1761=$5;
|
||
|
|
var $1762=(($1761+1)|0);
|
||
|
|
$5=$1762;
|
||
|
|
var $1763=HEAP8[($1761)];
|
||
|
|
var $1764=($1763&255);
|
||
|
|
var $1765=$1764<<8;
|
||
|
|
var $1766=$x;
|
||
|
|
var $1767=$line;
|
||
|
|
var $1768=(($1767+($1766<<1))|0);
|
||
|
|
var $1769=HEAP16[(($1768)>>1)];
|
||
|
|
var $1770=($1769&65535);
|
||
|
|
var $1771=$1770|$1765;
|
||
|
|
var $1772=(($1771)&65535);
|
||
|
|
HEAP16[(($1768)>>1)]=$1772;
|
||
|
|
var $1773=$count;
|
||
|
|
var $1774=((($1773)-(1))|0);
|
||
|
|
$count=$1774;
|
||
|
|
var $1775=$x;
|
||
|
|
var $1776=((($1775)+(1))|0);
|
||
|
|
$x=$1776;
|
||
|
|
var $1777=$5;
|
||
|
|
var $1778=(($1777+1)|0);
|
||
|
|
$5=$1778;
|
||
|
|
var $1779=HEAP8[($1777)];
|
||
|
|
var $1780=($1779&255);
|
||
|
|
var $1781=$x;
|
||
|
|
var $1782=$line;
|
||
|
|
var $1783=(($1782+($1781<<1))|0);
|
||
|
|
HEAP16[(($1783)>>1)]=$1780;
|
||
|
|
var $1784=$5;
|
||
|
|
var $1785=(($1784+1)|0);
|
||
|
|
$5=$1785;
|
||
|
|
var $1786=HEAP8[($1784)];
|
||
|
|
var $1787=($1786&255);
|
||
|
|
var $1788=$1787<<8;
|
||
|
|
var $1789=$x;
|
||
|
|
var $1790=$line;
|
||
|
|
var $1791=(($1790+($1789<<1))|0);
|
||
|
|
var $1792=HEAP16[(($1791)>>1)];
|
||
|
|
var $1793=($1792&65535);
|
||
|
|
var $1794=$1793|$1788;
|
||
|
|
var $1795=(($1794)&65535);
|
||
|
|
HEAP16[(($1791)>>1)]=$1795;
|
||
|
|
var $1796=$count;
|
||
|
|
var $1797=((($1796)-(1))|0);
|
||
|
|
$count=$1797;
|
||
|
|
var $1798=$x;
|
||
|
|
var $1799=((($1798)+(1))|0);
|
||
|
|
$x=$1799;
|
||
|
|
var $1800=$5;
|
||
|
|
var $1801=(($1800+1)|0);
|
||
|
|
$5=$1801;
|
||
|
|
var $1802=HEAP8[($1800)];
|
||
|
|
var $1803=($1802&255);
|
||
|
|
var $1804=$x;
|
||
|
|
var $1805=$line;
|
||
|
|
var $1806=(($1805+($1804<<1))|0);
|
||
|
|
HEAP16[(($1806)>>1)]=$1803;
|
||
|
|
var $1807=$5;
|
||
|
|
var $1808=(($1807+1)|0);
|
||
|
|
$5=$1808;
|
||
|
|
var $1809=HEAP8[($1807)];
|
||
|
|
var $1810=($1809&255);
|
||
|
|
var $1811=$1810<<8;
|
||
|
|
var $1812=$x;
|
||
|
|
var $1813=$line;
|
||
|
|
var $1814=(($1813+($1812<<1))|0);
|
||
|
|
var $1815=HEAP16[(($1814)>>1)];
|
||
|
|
var $1816=($1815&65535);
|
||
|
|
var $1817=$1816|$1811;
|
||
|
|
var $1818=(($1817)&65535);
|
||
|
|
HEAP16[(($1814)>>1)]=$1818;
|
||
|
|
var $1819=$count;
|
||
|
|
var $1820=((($1819)-(1))|0);
|
||
|
|
$count=$1820;
|
||
|
|
var $1821=$x;
|
||
|
|
var $1822=((($1821)+(1))|0);
|
||
|
|
$x=$1822;
|
||
|
|
var $1823=$5;
|
||
|
|
var $1824=(($1823+1)|0);
|
||
|
|
$5=$1824;
|
||
|
|
var $1825=HEAP8[($1823)];
|
||
|
|
var $1826=($1825&255);
|
||
|
|
var $1827=$x;
|
||
|
|
var $1828=$line;
|
||
|
|
var $1829=(($1828+($1827<<1))|0);
|
||
|
|
HEAP16[(($1829)>>1)]=$1826;
|
||
|
|
var $1830=$5;
|
||
|
|
var $1831=(($1830+1)|0);
|
||
|
|
$5=$1831;
|
||
|
|
var $1832=HEAP8[($1830)];
|
||
|
|
var $1833=($1832&255);
|
||
|
|
var $1834=$1833<<8;
|
||
|
|
var $1835=$x;
|
||
|
|
var $1836=$line;
|
||
|
|
var $1837=(($1836+($1835<<1))|0);
|
||
|
|
var $1838=HEAP16[(($1837)>>1)];
|
||
|
|
var $1839=($1838&65535);
|
||
|
|
var $1840=$1839|$1834;
|
||
|
|
var $1841=(($1840)&65535);
|
||
|
|
HEAP16[(($1837)>>1)]=$1841;
|
||
|
|
var $1842=$count;
|
||
|
|
var $1843=((($1842)-(1))|0);
|
||
|
|
$count=$1843;
|
||
|
|
var $1844=$x;
|
||
|
|
var $1845=((($1844)+(1))|0);
|
||
|
|
$x=$1845;
|
||
|
|
var $1846=$5;
|
||
|
|
var $1847=(($1846+1)|0);
|
||
|
|
$5=$1847;
|
||
|
|
var $1848=HEAP8[($1846)];
|
||
|
|
var $1849=($1848&255);
|
||
|
|
var $1850=$x;
|
||
|
|
var $1851=$line;
|
||
|
|
var $1852=(($1851+($1850<<1))|0);
|
||
|
|
HEAP16[(($1852)>>1)]=$1849;
|
||
|
|
var $1853=$5;
|
||
|
|
var $1854=(($1853+1)|0);
|
||
|
|
$5=$1854;
|
||
|
|
var $1855=HEAP8[($1853)];
|
||
|
|
var $1856=($1855&255);
|
||
|
|
var $1857=$1856<<8;
|
||
|
|
var $1858=$x;
|
||
|
|
var $1859=$line;
|
||
|
|
var $1860=(($1859+($1858<<1))|0);
|
||
|
|
var $1861=HEAP16[(($1860)>>1)];
|
||
|
|
var $1862=($1861&65535);
|
||
|
|
var $1863=$1862|$1857;
|
||
|
|
var $1864=(($1863)&65535);
|
||
|
|
HEAP16[(($1860)>>1)]=$1864;
|
||
|
|
var $1865=$count;
|
||
|
|
var $1866=((($1865)-(1))|0);
|
||
|
|
$count=$1866;
|
||
|
|
var $1867=$x;
|
||
|
|
var $1868=((($1867)+(1))|0);
|
||
|
|
$x=$1868;
|
||
|
|
var $1869=$5;
|
||
|
|
var $1870=(($1869+1)|0);
|
||
|
|
$5=$1870;
|
||
|
|
var $1871=HEAP8[($1869)];
|
||
|
|
var $1872=($1871&255);
|
||
|
|
var $1873=$x;
|
||
|
|
var $1874=$line;
|
||
|
|
var $1875=(($1874+($1873<<1))|0);
|
||
|
|
HEAP16[(($1875)>>1)]=$1872;
|
||
|
|
var $1876=$5;
|
||
|
|
var $1877=(($1876+1)|0);
|
||
|
|
$5=$1877;
|
||
|
|
var $1878=HEAP8[($1876)];
|
||
|
|
var $1879=($1878&255);
|
||
|
|
var $1880=$1879<<8;
|
||
|
|
var $1881=$x;
|
||
|
|
var $1882=$line;
|
||
|
|
var $1883=(($1882+($1881<<1))|0);
|
||
|
|
var $1884=HEAP16[(($1883)>>1)];
|
||
|
|
var $1885=($1884&65535);
|
||
|
|
var $1886=$1885|$1880;
|
||
|
|
var $1887=(($1886)&65535);
|
||
|
|
HEAP16[(($1883)>>1)]=$1887;
|
||
|
|
var $1888=$count;
|
||
|
|
var $1889=((($1888)-(1))|0);
|
||
|
|
$count=$1889;
|
||
|
|
var $1890=$x;
|
||
|
|
var $1891=((($1890)+(1))|0);
|
||
|
|
$x=$1891;
|
||
|
|
label=273;break;
|
||
|
|
case 277:
|
||
|
|
label=278;break;
|
||
|
|
case 278:
|
||
|
|
var $1894=$count;
|
||
|
|
var $1895=($1894|0)>0;
|
||
|
|
if($1895){label=279;break;}else{var $1901=0;label=280;break;}
|
||
|
|
case 279:
|
||
|
|
var $1897=$x;
|
||
|
|
var $1898=$3;
|
||
|
|
var $1899=($1897|0)<($1898|0);
|
||
|
|
var $1901=$1899;label=280;break;
|
||
|
|
case 280:
|
||
|
|
var $1901;
|
||
|
|
if($1901){label=281;break;}else{label=282;break;}
|
||
|
|
case 281:
|
||
|
|
var $1903=$5;
|
||
|
|
var $1904=(($1903+1)|0);
|
||
|
|
$5=$1904;
|
||
|
|
var $1905=HEAP8[($1903)];
|
||
|
|
var $1906=($1905&255);
|
||
|
|
var $1907=$x;
|
||
|
|
var $1908=$line;
|
||
|
|
var $1909=(($1908+($1907<<1))|0);
|
||
|
|
HEAP16[(($1909)>>1)]=$1906;
|
||
|
|
var $1910=$5;
|
||
|
|
var $1911=(($1910+1)|0);
|
||
|
|
$5=$1911;
|
||
|
|
var $1912=HEAP8[($1910)];
|
||
|
|
var $1913=($1912&255);
|
||
|
|
var $1914=$1913<<8;
|
||
|
|
var $1915=$x;
|
||
|
|
var $1916=$line;
|
||
|
|
var $1917=(($1916+($1915<<1))|0);
|
||
|
|
var $1918=HEAP16[(($1917)>>1)];
|
||
|
|
var $1919=($1918&65535);
|
||
|
|
var $1920=$1919|$1914;
|
||
|
|
var $1921=(($1920)&65535);
|
||
|
|
HEAP16[(($1917)>>1)]=$1921;
|
||
|
|
var $1922=$count;
|
||
|
|
var $1923=((($1922)-(1))|0);
|
||
|
|
$count=$1923;
|
||
|
|
var $1924=$x;
|
||
|
|
var $1925=((($1924)+(1))|0);
|
||
|
|
$x=$1925;
|
||
|
|
label=278;break;
|
||
|
|
case 282:
|
||
|
|
label=344;break;
|
||
|
|
case 283:
|
||
|
|
label=284;break;
|
||
|
|
case 284:
|
||
|
|
var $1929=$count;
|
||
|
|
var $1930=$1929&-8;
|
||
|
|
var $1931=($1930|0)!=0;
|
||
|
|
if($1931){label=285;break;}else{var $1938=0;label=286;break;}
|
||
|
|
case 285:
|
||
|
|
var $1933=$x;
|
||
|
|
var $1934=((($1933)+(8))|0);
|
||
|
|
var $1935=$3;
|
||
|
|
var $1936=($1934|0)<($1935|0);
|
||
|
|
var $1938=$1936;label=286;break;
|
||
|
|
case 286:
|
||
|
|
var $1938;
|
||
|
|
if($1938){label=287;break;}else{label=312;break;}
|
||
|
|
case 287:
|
||
|
|
var $1940=$bicolour;
|
||
|
|
var $1941=($1940|0)!=0;
|
||
|
|
if($1941){label=288;break;}else{label=289;break;}
|
||
|
|
case 288:
|
||
|
|
var $1943=$colour2;
|
||
|
|
var $1944=$x;
|
||
|
|
var $1945=$line;
|
||
|
|
var $1946=(($1945+($1944<<1))|0);
|
||
|
|
HEAP16[(($1946)>>1)]=$1943;
|
||
|
|
$bicolour=0;
|
||
|
|
label=290;break;
|
||
|
|
case 289:
|
||
|
|
var $1948=$colour1;
|
||
|
|
var $1949=$x;
|
||
|
|
var $1950=$line;
|
||
|
|
var $1951=(($1950+($1949<<1))|0);
|
||
|
|
HEAP16[(($1951)>>1)]=$1948;
|
||
|
|
$bicolour=1;
|
||
|
|
var $1952=$count;
|
||
|
|
var $1953=((($1952)+(1))|0);
|
||
|
|
$count=$1953;
|
||
|
|
label=290;break;
|
||
|
|
case 290:
|
||
|
|
var $1955=$count;
|
||
|
|
var $1956=((($1955)-(1))|0);
|
||
|
|
$count=$1956;
|
||
|
|
var $1957=$x;
|
||
|
|
var $1958=((($1957)+(1))|0);
|
||
|
|
$x=$1958;
|
||
|
|
var $1959=$bicolour;
|
||
|
|
var $1960=($1959|0)!=0;
|
||
|
|
if($1960){label=291;break;}else{label=292;break;}
|
||
|
|
case 291:
|
||
|
|
var $1962=$colour2;
|
||
|
|
var $1963=$x;
|
||
|
|
var $1964=$line;
|
||
|
|
var $1965=(($1964+($1963<<1))|0);
|
||
|
|
HEAP16[(($1965)>>1)]=$1962;
|
||
|
|
$bicolour=0;
|
||
|
|
label=293;break;
|
||
|
|
case 292:
|
||
|
|
var $1967=$colour1;
|
||
|
|
var $1968=$x;
|
||
|
|
var $1969=$line;
|
||
|
|
var $1970=(($1969+($1968<<1))|0);
|
||
|
|
HEAP16[(($1970)>>1)]=$1967;
|
||
|
|
$bicolour=1;
|
||
|
|
var $1971=$count;
|
||
|
|
var $1972=((($1971)+(1))|0);
|
||
|
|
$count=$1972;
|
||
|
|
label=293;break;
|
||
|
|
case 293:
|
||
|
|
var $1974=$count;
|
||
|
|
var $1975=((($1974)-(1))|0);
|
||
|
|
$count=$1975;
|
||
|
|
var $1976=$x;
|
||
|
|
var $1977=((($1976)+(1))|0);
|
||
|
|
$x=$1977;
|
||
|
|
var $1978=$bicolour;
|
||
|
|
var $1979=($1978|0)!=0;
|
||
|
|
if($1979){label=294;break;}else{label=295;break;}
|
||
|
|
case 294:
|
||
|
|
var $1981=$colour2;
|
||
|
|
var $1982=$x;
|
||
|
|
var $1983=$line;
|
||
|
|
var $1984=(($1983+($1982<<1))|0);
|
||
|
|
HEAP16[(($1984)>>1)]=$1981;
|
||
|
|
$bicolour=0;
|
||
|
|
label=296;break;
|
||
|
|
case 295:
|
||
|
|
var $1986=$colour1;
|
||
|
|
var $1987=$x;
|
||
|
|
var $1988=$line;
|
||
|
|
var $1989=(($1988+($1987<<1))|0);
|
||
|
|
HEAP16[(($1989)>>1)]=$1986;
|
||
|
|
$bicolour=1;
|
||
|
|
var $1990=$count;
|
||
|
|
var $1991=((($1990)+(1))|0);
|
||
|
|
$count=$1991;
|
||
|
|
label=296;break;
|
||
|
|
case 296:
|
||
|
|
var $1993=$count;
|
||
|
|
var $1994=((($1993)-(1))|0);
|
||
|
|
$count=$1994;
|
||
|
|
var $1995=$x;
|
||
|
|
var $1996=((($1995)+(1))|0);
|
||
|
|
$x=$1996;
|
||
|
|
var $1997=$bicolour;
|
||
|
|
var $1998=($1997|0)!=0;
|
||
|
|
if($1998){label=297;break;}else{label=298;break;}
|
||
|
|
case 297:
|
||
|
|
var $2000=$colour2;
|
||
|
|
var $2001=$x;
|
||
|
|
var $2002=$line;
|
||
|
|
var $2003=(($2002+($2001<<1))|0);
|
||
|
|
HEAP16[(($2003)>>1)]=$2000;
|
||
|
|
$bicolour=0;
|
||
|
|
label=299;break;
|
||
|
|
case 298:
|
||
|
|
var $2005=$colour1;
|
||
|
|
var $2006=$x;
|
||
|
|
var $2007=$line;
|
||
|
|
var $2008=(($2007+($2006<<1))|0);
|
||
|
|
HEAP16[(($2008)>>1)]=$2005;
|
||
|
|
$bicolour=1;
|
||
|
|
var $2009=$count;
|
||
|
|
var $2010=((($2009)+(1))|0);
|
||
|
|
$count=$2010;
|
||
|
|
label=299;break;
|
||
|
|
case 299:
|
||
|
|
var $2012=$count;
|
||
|
|
var $2013=((($2012)-(1))|0);
|
||
|
|
$count=$2013;
|
||
|
|
var $2014=$x;
|
||
|
|
var $2015=((($2014)+(1))|0);
|
||
|
|
$x=$2015;
|
||
|
|
var $2016=$bicolour;
|
||
|
|
var $2017=($2016|0)!=0;
|
||
|
|
if($2017){label=300;break;}else{label=301;break;}
|
||
|
|
case 300:
|
||
|
|
var $2019=$colour2;
|
||
|
|
var $2020=$x;
|
||
|
|
var $2021=$line;
|
||
|
|
var $2022=(($2021+($2020<<1))|0);
|
||
|
|
HEAP16[(($2022)>>1)]=$2019;
|
||
|
|
$bicolour=0;
|
||
|
|
label=302;break;
|
||
|
|
case 301:
|
||
|
|
var $2024=$colour1;
|
||
|
|
var $2025=$x;
|
||
|
|
var $2026=$line;
|
||
|
|
var $2027=(($2026+($2025<<1))|0);
|
||
|
|
HEAP16[(($2027)>>1)]=$2024;
|
||
|
|
$bicolour=1;
|
||
|
|
var $2028=$count;
|
||
|
|
var $2029=((($2028)+(1))|0);
|
||
|
|
$count=$2029;
|
||
|
|
label=302;break;
|
||
|
|
case 302:
|
||
|
|
var $2031=$count;
|
||
|
|
var $2032=((($2031)-(1))|0);
|
||
|
|
$count=$2032;
|
||
|
|
var $2033=$x;
|
||
|
|
var $2034=((($2033)+(1))|0);
|
||
|
|
$x=$2034;
|
||
|
|
var $2035=$bicolour;
|
||
|
|
var $2036=($2035|0)!=0;
|
||
|
|
if($2036){label=303;break;}else{label=304;break;}
|
||
|
|
case 303:
|
||
|
|
var $2038=$colour2;
|
||
|
|
var $2039=$x;
|
||
|
|
var $2040=$line;
|
||
|
|
var $2041=(($2040+($2039<<1))|0);
|
||
|
|
HEAP16[(($2041)>>1)]=$2038;
|
||
|
|
$bicolour=0;
|
||
|
|
label=305;break;
|
||
|
|
case 304:
|
||
|
|
var $2043=$colour1;
|
||
|
|
var $2044=$x;
|
||
|
|
var $2045=$line;
|
||
|
|
var $2046=(($2045+($2044<<1))|0);
|
||
|
|
HEAP16[(($2046)>>1)]=$2043;
|
||
|
|
$bicolour=1;
|
||
|
|
var $2047=$count;
|
||
|
|
var $2048=((($2047)+(1))|0);
|
||
|
|
$count=$2048;
|
||
|
|
label=305;break;
|
||
|
|
case 305:
|
||
|
|
var $2050=$count;
|
||
|
|
var $2051=((($2050)-(1))|0);
|
||
|
|
$count=$2051;
|
||
|
|
var $2052=$x;
|
||
|
|
var $2053=((($2052)+(1))|0);
|
||
|
|
$x=$2053;
|
||
|
|
var $2054=$bicolour;
|
||
|
|
var $2055=($2054|0)!=0;
|
||
|
|
if($2055){label=306;break;}else{label=307;break;}
|
||
|
|
case 306:
|
||
|
|
var $2057=$colour2;
|
||
|
|
var $2058=$x;
|
||
|
|
var $2059=$line;
|
||
|
|
var $2060=(($2059+($2058<<1))|0);
|
||
|
|
HEAP16[(($2060)>>1)]=$2057;
|
||
|
|
$bicolour=0;
|
||
|
|
label=308;break;
|
||
|
|
case 307:
|
||
|
|
var $2062=$colour1;
|
||
|
|
var $2063=$x;
|
||
|
|
var $2064=$line;
|
||
|
|
var $2065=(($2064+($2063<<1))|0);
|
||
|
|
HEAP16[(($2065)>>1)]=$2062;
|
||
|
|
$bicolour=1;
|
||
|
|
var $2066=$count;
|
||
|
|
var $2067=((($2066)+(1))|0);
|
||
|
|
$count=$2067;
|
||
|
|
label=308;break;
|
||
|
|
case 308:
|
||
|
|
var $2069=$count;
|
||
|
|
var $2070=((($2069)-(1))|0);
|
||
|
|
$count=$2070;
|
||
|
|
var $2071=$x;
|
||
|
|
var $2072=((($2071)+(1))|0);
|
||
|
|
$x=$2072;
|
||
|
|
var $2073=$bicolour;
|
||
|
|
var $2074=($2073|0)!=0;
|
||
|
|
if($2074){label=309;break;}else{label=310;break;}
|
||
|
|
case 309:
|
||
|
|
var $2076=$colour2;
|
||
|
|
var $2077=$x;
|
||
|
|
var $2078=$line;
|
||
|
|
var $2079=(($2078+($2077<<1))|0);
|
||
|
|
HEAP16[(($2079)>>1)]=$2076;
|
||
|
|
$bicolour=0;
|
||
|
|
label=311;break;
|
||
|
|
case 310:
|
||
|
|
var $2081=$colour1;
|
||
|
|
var $2082=$x;
|
||
|
|
var $2083=$line;
|
||
|
|
var $2084=(($2083+($2082<<1))|0);
|
||
|
|
HEAP16[(($2084)>>1)]=$2081;
|
||
|
|
$bicolour=1;
|
||
|
|
var $2085=$count;
|
||
|
|
var $2086=((($2085)+(1))|0);
|
||
|
|
$count=$2086;
|
||
|
|
label=311;break;
|
||
|
|
case 311:
|
||
|
|
var $2088=$count;
|
||
|
|
var $2089=((($2088)-(1))|0);
|
||
|
|
$count=$2089;
|
||
|
|
var $2090=$x;
|
||
|
|
var $2091=((($2090)+(1))|0);
|
||
|
|
$x=$2091;
|
||
|
|
label=284;break;
|
||
|
|
case 312:
|
||
|
|
label=313;break;
|
||
|
|
case 313:
|
||
|
|
var $2094=$count;
|
||
|
|
var $2095=($2094|0)>0;
|
||
|
|
if($2095){label=314;break;}else{var $2101=0;label=315;break;}
|
||
|
|
case 314:
|
||
|
|
var $2097=$x;
|
||
|
|
var $2098=$3;
|
||
|
|
var $2099=($2097|0)<($2098|0);
|
||
|
|
var $2101=$2099;label=315;break;
|
||
|
|
case 315:
|
||
|
|
var $2101;
|
||
|
|
if($2101){label=316;break;}else{label=320;break;}
|
||
|
|
case 316:
|
||
|
|
var $2103=$bicolour;
|
||
|
|
var $2104=($2103|0)!=0;
|
||
|
|
if($2104){label=317;break;}else{label=318;break;}
|
||
|
|
case 317:
|
||
|
|
var $2106=$colour2;
|
||
|
|
var $2107=$x;
|
||
|
|
var $2108=$line;
|
||
|
|
var $2109=(($2108+($2107<<1))|0);
|
||
|
|
HEAP16[(($2109)>>1)]=$2106;
|
||
|
|
$bicolour=0;
|
||
|
|
label=319;break;
|
||
|
|
case 318:
|
||
|
|
var $2111=$colour1;
|
||
|
|
var $2112=$x;
|
||
|
|
var $2113=$line;
|
||
|
|
var $2114=(($2113+($2112<<1))|0);
|
||
|
|
HEAP16[(($2114)>>1)]=$2111;
|
||
|
|
$bicolour=1;
|
||
|
|
var $2115=$count;
|
||
|
|
var $2116=((($2115)+(1))|0);
|
||
|
|
$count=$2116;
|
||
|
|
label=319;break;
|
||
|
|
case 319:
|
||
|
|
var $2118=$count;
|
||
|
|
var $2119=((($2118)-(1))|0);
|
||
|
|
$count=$2119;
|
||
|
|
var $2120=$x;
|
||
|
|
var $2121=((($2120)+(1))|0);
|
||
|
|
$x=$2121;
|
||
|
|
label=313;break;
|
||
|
|
case 320:
|
||
|
|
label=344;break;
|
||
|
|
case 321:
|
||
|
|
label=322;break;
|
||
|
|
case 322:
|
||
|
|
var $2125=$count;
|
||
|
|
var $2126=$2125&-8;
|
||
|
|
var $2127=($2126|0)!=0;
|
||
|
|
if($2127){label=323;break;}else{var $2134=0;label=324;break;}
|
||
|
|
case 323:
|
||
|
|
var $2129=$x;
|
||
|
|
var $2130=((($2129)+(8))|0);
|
||
|
|
var $2131=$3;
|
||
|
|
var $2132=($2130|0)<($2131|0);
|
||
|
|
var $2134=$2132;label=324;break;
|
||
|
|
case 324:
|
||
|
|
var $2134;
|
||
|
|
if($2134){label=325;break;}else{label=326;break;}
|
||
|
|
case 325:
|
||
|
|
var $2136=$x;
|
||
|
|
var $2137=$line;
|
||
|
|
var $2138=(($2137+($2136<<1))|0);
|
||
|
|
HEAP16[(($2138)>>1)]=-1;
|
||
|
|
var $2139=$count;
|
||
|
|
var $2140=((($2139)-(1))|0);
|
||
|
|
$count=$2140;
|
||
|
|
var $2141=$x;
|
||
|
|
var $2142=((($2141)+(1))|0);
|
||
|
|
$x=$2142;
|
||
|
|
var $2143=$x;
|
||
|
|
var $2144=$line;
|
||
|
|
var $2145=(($2144+($2143<<1))|0);
|
||
|
|
HEAP16[(($2145)>>1)]=-1;
|
||
|
|
var $2146=$count;
|
||
|
|
var $2147=((($2146)-(1))|0);
|
||
|
|
$count=$2147;
|
||
|
|
var $2148=$x;
|
||
|
|
var $2149=((($2148)+(1))|0);
|
||
|
|
$x=$2149;
|
||
|
|
var $2150=$x;
|
||
|
|
var $2151=$line;
|
||
|
|
var $2152=(($2151+($2150<<1))|0);
|
||
|
|
HEAP16[(($2152)>>1)]=-1;
|
||
|
|
var $2153=$count;
|
||
|
|
var $2154=((($2153)-(1))|0);
|
||
|
|
$count=$2154;
|
||
|
|
var $2155=$x;
|
||
|
|
var $2156=((($2155)+(1))|0);
|
||
|
|
$x=$2156;
|
||
|
|
var $2157=$x;
|
||
|
|
var $2158=$line;
|
||
|
|
var $2159=(($2158+($2157<<1))|0);
|
||
|
|
HEAP16[(($2159)>>1)]=-1;
|
||
|
|
var $2160=$count;
|
||
|
|
var $2161=((($2160)-(1))|0);
|
||
|
|
$count=$2161;
|
||
|
|
var $2162=$x;
|
||
|
|
var $2163=((($2162)+(1))|0);
|
||
|
|
$x=$2163;
|
||
|
|
var $2164=$x;
|
||
|
|
var $2165=$line;
|
||
|
|
var $2166=(($2165+($2164<<1))|0);
|
||
|
|
HEAP16[(($2166)>>1)]=-1;
|
||
|
|
var $2167=$count;
|
||
|
|
var $2168=((($2167)-(1))|0);
|
||
|
|
$count=$2168;
|
||
|
|
var $2169=$x;
|
||
|
|
var $2170=((($2169)+(1))|0);
|
||
|
|
$x=$2170;
|
||
|
|
var $2171=$x;
|
||
|
|
var $2172=$line;
|
||
|
|
var $2173=(($2172+($2171<<1))|0);
|
||
|
|
HEAP16[(($2173)>>1)]=-1;
|
||
|
|
var $2174=$count;
|
||
|
|
var $2175=((($2174)-(1))|0);
|
||
|
|
$count=$2175;
|
||
|
|
var $2176=$x;
|
||
|
|
var $2177=((($2176)+(1))|0);
|
||
|
|
$x=$2177;
|
||
|
|
var $2178=$x;
|
||
|
|
var $2179=$line;
|
||
|
|
var $2180=(($2179+($2178<<1))|0);
|
||
|
|
HEAP16[(($2180)>>1)]=-1;
|
||
|
|
var $2181=$count;
|
||
|
|
var $2182=((($2181)-(1))|0);
|
||
|
|
$count=$2182;
|
||
|
|
var $2183=$x;
|
||
|
|
var $2184=((($2183)+(1))|0);
|
||
|
|
$x=$2184;
|
||
|
|
var $2185=$x;
|
||
|
|
var $2186=$line;
|
||
|
|
var $2187=(($2186+($2185<<1))|0);
|
||
|
|
HEAP16[(($2187)>>1)]=-1;
|
||
|
|
var $2188=$count;
|
||
|
|
var $2189=((($2188)-(1))|0);
|
||
|
|
$count=$2189;
|
||
|
|
var $2190=$x;
|
||
|
|
var $2191=((($2190)+(1))|0);
|
||
|
|
$x=$2191;
|
||
|
|
label=322;break;
|
||
|
|
case 326:
|
||
|
|
label=327;break;
|
||
|
|
case 327:
|
||
|
|
var $2194=$count;
|
||
|
|
var $2195=($2194|0)>0;
|
||
|
|
if($2195){label=328;break;}else{var $2201=0;label=329;break;}
|
||
|
|
case 328:
|
||
|
|
var $2197=$x;
|
||
|
|
var $2198=$3;
|
||
|
|
var $2199=($2197|0)<($2198|0);
|
||
|
|
var $2201=$2199;label=329;break;
|
||
|
|
case 329:
|
||
|
|
var $2201;
|
||
|
|
if($2201){label=330;break;}else{label=331;break;}
|
||
|
|
case 330:
|
||
|
|
var $2203=$x;
|
||
|
|
var $2204=$line;
|
||
|
|
var $2205=(($2204+($2203<<1))|0);
|
||
|
|
HEAP16[(($2205)>>1)]=-1;
|
||
|
|
var $2206=$count;
|
||
|
|
var $2207=((($2206)-(1))|0);
|
||
|
|
$count=$2207;
|
||
|
|
var $2208=$x;
|
||
|
|
var $2209=((($2208)+(1))|0);
|
||
|
|
$x=$2209;
|
||
|
|
label=327;break;
|
||
|
|
case 331:
|
||
|
|
label=344;break;
|
||
|
|
case 332:
|
||
|
|
label=333;break;
|
||
|
|
case 333:
|
||
|
|
var $2213=$count;
|
||
|
|
var $2214=$2213&-8;
|
||
|
|
var $2215=($2214|0)!=0;
|
||
|
|
if($2215){label=334;break;}else{var $2222=0;label=335;break;}
|
||
|
|
case 334:
|
||
|
|
var $2217=$x;
|
||
|
|
var $2218=((($2217)+(8))|0);
|
||
|
|
var $2219=$3;
|
||
|
|
var $2220=($2218|0)<($2219|0);
|
||
|
|
var $2222=$2220;label=335;break;
|
||
|
|
case 335:
|
||
|
|
var $2222;
|
||
|
|
if($2222){label=336;break;}else{label=337;break;}
|
||
|
|
case 336:
|
||
|
|
var $2224=$x;
|
||
|
|
var $2225=$line;
|
||
|
|
var $2226=(($2225+($2224<<1))|0);
|
||
|
|
HEAP16[(($2226)>>1)]=0;
|
||
|
|
var $2227=$count;
|
||
|
|
var $2228=((($2227)-(1))|0);
|
||
|
|
$count=$2228;
|
||
|
|
var $2229=$x;
|
||
|
|
var $2230=((($2229)+(1))|0);
|
||
|
|
$x=$2230;
|
||
|
|
var $2231=$x;
|
||
|
|
var $2232=$line;
|
||
|
|
var $2233=(($2232+($2231<<1))|0);
|
||
|
|
HEAP16[(($2233)>>1)]=0;
|
||
|
|
var $2234=$count;
|
||
|
|
var $2235=((($2234)-(1))|0);
|
||
|
|
$count=$2235;
|
||
|
|
var $2236=$x;
|
||
|
|
var $2237=((($2236)+(1))|0);
|
||
|
|
$x=$2237;
|
||
|
|
var $2238=$x;
|
||
|
|
var $2239=$line;
|
||
|
|
var $2240=(($2239+($2238<<1))|0);
|
||
|
|
HEAP16[(($2240)>>1)]=0;
|
||
|
|
var $2241=$count;
|
||
|
|
var $2242=((($2241)-(1))|0);
|
||
|
|
$count=$2242;
|
||
|
|
var $2243=$x;
|
||
|
|
var $2244=((($2243)+(1))|0);
|
||
|
|
$x=$2244;
|
||
|
|
var $2245=$x;
|
||
|
|
var $2246=$line;
|
||
|
|
var $2247=(($2246+($2245<<1))|0);
|
||
|
|
HEAP16[(($2247)>>1)]=0;
|
||
|
|
var $2248=$count;
|
||
|
|
var $2249=((($2248)-(1))|0);
|
||
|
|
$count=$2249;
|
||
|
|
var $2250=$x;
|
||
|
|
var $2251=((($2250)+(1))|0);
|
||
|
|
$x=$2251;
|
||
|
|
var $2252=$x;
|
||
|
|
var $2253=$line;
|
||
|
|
var $2254=(($2253+($2252<<1))|0);
|
||
|
|
HEAP16[(($2254)>>1)]=0;
|
||
|
|
var $2255=$count;
|
||
|
|
var $2256=((($2255)-(1))|0);
|
||
|
|
$count=$2256;
|
||
|
|
var $2257=$x;
|
||
|
|
var $2258=((($2257)+(1))|0);
|
||
|
|
$x=$2258;
|
||
|
|
var $2259=$x;
|
||
|
|
var $2260=$line;
|
||
|
|
var $2261=(($2260+($2259<<1))|0);
|
||
|
|
HEAP16[(($2261)>>1)]=0;
|
||
|
|
var $2262=$count;
|
||
|
|
var $2263=((($2262)-(1))|0);
|
||
|
|
$count=$2263;
|
||
|
|
var $2264=$x;
|
||
|
|
var $2265=((($2264)+(1))|0);
|
||
|
|
$x=$2265;
|
||
|
|
var $2266=$x;
|
||
|
|
var $2267=$line;
|
||
|
|
var $2268=(($2267+($2266<<1))|0);
|
||
|
|
HEAP16[(($2268)>>1)]=0;
|
||
|
|
var $2269=$count;
|
||
|
|
var $2270=((($2269)-(1))|0);
|
||
|
|
$count=$2270;
|
||
|
|
var $2271=$x;
|
||
|
|
var $2272=((($2271)+(1))|0);
|
||
|
|
$x=$2272;
|
||
|
|
var $2273=$x;
|
||
|
|
var $2274=$line;
|
||
|
|
var $2275=(($2274+($2273<<1))|0);
|
||
|
|
HEAP16[(($2275)>>1)]=0;
|
||
|
|
var $2276=$count;
|
||
|
|
var $2277=((($2276)-(1))|0);
|
||
|
|
$count=$2277;
|
||
|
|
var $2278=$x;
|
||
|
|
var $2279=((($2278)+(1))|0);
|
||
|
|
$x=$2279;
|
||
|
|
label=333;break;
|
||
|
|
case 337:
|
||
|
|
label=338;break;
|
||
|
|
case 338:
|
||
|
|
var $2282=$count;
|
||
|
|
var $2283=($2282|0)>0;
|
||
|
|
if($2283){label=339;break;}else{var $2289=0;label=340;break;}
|
||
|
|
case 339:
|
||
|
|
var $2285=$x;
|
||
|
|
var $2286=$3;
|
||
|
|
var $2287=($2285|0)<($2286|0);
|
||
|
|
var $2289=$2287;label=340;break;
|
||
|
|
case 340:
|
||
|
|
var $2289;
|
||
|
|
if($2289){label=341;break;}else{label=342;break;}
|
||
|
|
case 341:
|
||
|
|
var $2291=$x;
|
||
|
|
var $2292=$line;
|
||
|
|
var $2293=(($2292+($2291<<1))|0);
|
||
|
|
HEAP16[(($2293)>>1)]=0;
|
||
|
|
var $2294=$count;
|
||
|
|
var $2295=((($2294)-(1))|0);
|
||
|
|
$count=$2295;
|
||
|
|
var $2296=$x;
|
||
|
|
var $2297=((($2296)+(1))|0);
|
||
|
|
$x=$2297;
|
||
|
|
label=338;break;
|
||
|
|
case 342:
|
||
|
|
label=344;break;
|
||
|
|
case 343:
|
||
|
|
$1=0;
|
||
|
|
label=347;break;
|
||
|
|
case 344:
|
||
|
|
label=34;break;
|
||
|
|
case 345:
|
||
|
|
label=2;break;
|
||
|
|
case 346:
|
||
|
|
$1=1;
|
||
|
|
label=347;break;
|
||
|
|
case 347:
|
||
|
|
var $2304=$1;
|
||
|
|
STACKTOP=sp;return $2304;
|
||
|
|
default: assert(0, "bad label: " + label);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
function _bitmap_decompress_16($output,$output_width,$output_height,$input_width,$input_height,$input,$size){
|
||
|
|
var label=0;
|
||
|
|
var sp=STACKTOP; (assert((STACKTOP|0) < (STACK_MAX|0))|0);
|
||
|
|
label = 1;
|
||
|
|
while(1)switch(label){
|
||
|
|
case 1:
|
||
|
|
var $1;
|
||
|
|
var $2;
|
||
|
|
var $3;
|
||
|
|
var $4;
|
||
|
|
var $5;
|
||
|
|
var $6;
|
||
|
|
var $7;
|
||
|
|
var $temp;
|
||
|
|
var $rv;
|
||
|
|
var $y;
|
||
|
|
var $x;
|
||
|
|
var $a;
|
||
|
|
var $r;
|
||
|
|
var $g;
|
||
|
|
var $b;
|
||
|
|
$1=$output;
|
||
|
|
$2=$output_width;
|
||
|
|
$3=$output_height;
|
||
|
|
$4=$input_width;
|
||
|
|
$5=$input_height;
|
||
|
|
$6=$input;
|
||
|
|
$7=$size;
|
||
|
|
var $8=$4;
|
||
|
|
var $9=$5;
|
||
|
|
var $10=(Math_imul($8,$9)|0);
|
||
|
|
var $11=($10<<1);
|
||
|
|
var $12=_malloc($11);
|
||
|
|
$temp=$12;
|
||
|
|
var $13=$temp;
|
||
|
|
var $14=$4;
|
||
|
|
var $15=$5;
|
||
|
|
var $16=$6;
|
||
|
|
var $17=$7;
|
||
|
|
var $18=_bitmap_decompress2($13,$14,$15,$16,$17);
|
||
|
|
$rv=$18;
|
||
|
|
$y=0;
|
||
|
|
label=2;break;
|
||
|
|
case 2:
|
||
|
|
var $20=$y;
|
||
|
|
var $21=$3;
|
||
|
|
var $22=($20|0)<($21|0);
|
||
|
|
if($22){label=3;break;}else{label=9;break;}
|
||
|
|
case 3:
|
||
|
|
$x=0;
|
||
|
|
label=4;break;
|
||
|
|
case 4:
|
||
|
|
var $25=$x;
|
||
|
|
var $26=$2;
|
||
|
|
var $27=($25|0)<($26|0);
|
||
|
|
if($27){label=5;break;}else{label=7;break;}
|
||
|
|
case 5:
|
||
|
|
var $29=$y;
|
||
|
|
var $30=$4;
|
||
|
|
var $31=(Math_imul($29,$30)|0);
|
||
|
|
var $32=$x;
|
||
|
|
var $33=((($31)+($32))|0);
|
||
|
|
var $34=$temp;
|
||
|
|
var $35=$34;
|
||
|
|
var $36=(($35+($33<<1))|0);
|
||
|
|
var $37=HEAP16[(($36)>>1)];
|
||
|
|
$a=$37;
|
||
|
|
var $38=$a;
|
||
|
|
var $39=($38&65535);
|
||
|
|
var $40=$39&63488;
|
||
|
|
var $41=$40>>11;
|
||
|
|
var $42=(($41)&255);
|
||
|
|
$r=$42;
|
||
|
|
var $43=$a;
|
||
|
|
var $44=($43&65535);
|
||
|
|
var $45=$44&2016;
|
||
|
|
var $46=$45>>5;
|
||
|
|
var $47=(($46)&255);
|
||
|
|
$g=$47;
|
||
|
|
var $48=$a;
|
||
|
|
var $49=($48&65535);
|
||
|
|
var $50=$49&31;
|
||
|
|
var $51=(($50)&255);
|
||
|
|
$b=$51;
|
||
|
|
var $52=$r;
|
||
|
|
var $53=($52&255);
|
||
|
|
var $54=((($53)*(255))&-1);
|
||
|
|
var $55=(((($54|0))/(31))&-1);
|
||
|
|
var $56=(($55)&255);
|
||
|
|
$r=$56;
|
||
|
|
var $57=$g;
|
||
|
|
var $58=($57&255);
|
||
|
|
var $59=((($58)*(255))&-1);
|
||
|
|
var $60=(((($59|0))/(63))&-1);
|
||
|
|
var $61=(($60)&255);
|
||
|
|
$g=$61;
|
||
|
|
var $62=$b;
|
||
|
|
var $63=($62&255);
|
||
|
|
var $64=((($63)*(255))&-1);
|
||
|
|
var $65=(((($64|0))/(31))&-1);
|
||
|
|
var $66=(($65)&255);
|
||
|
|
$b=$66;
|
||
|
|
var $67=$b;
|
||
|
|
var $68=($67&255);
|
||
|
|
var $69=$68<<16;
|
||
|
|
var $70=-16777216|$69;
|
||
|
|
var $71=$g;
|
||
|
|
var $72=($71&255);
|
||
|
|
var $73=$72<<8;
|
||
|
|
var $74=$70|$73;
|
||
|
|
var $75=$r;
|
||
|
|
var $76=($75&255);
|
||
|
|
var $77=$74|$76;
|
||
|
|
var $78=$y;
|
||
|
|
var $79=$2;
|
||
|
|
var $80=(Math_imul($78,$79)|0);
|
||
|
|
var $81=$x;
|
||
|
|
var $82=((($80)+($81))|0);
|
||
|
|
var $83=$1;
|
||
|
|
var $84=$83;
|
||
|
|
var $85=(($84+($82<<2))|0);
|
||
|
|
HEAP32[(($85)>>2)]=$77;
|
||
|
|
label=6;break;
|
||
|
|
case 6:
|
||
|
|
var $87=$x;
|
||
|
|
var $88=((($87)+(1))|0);
|
||
|
|
$x=$88;
|
||
|
|
label=4;break;
|
||
|
|
case 7:
|
||
|
|
label=8;break;
|
||
|
|
case 8:
|
||
|
|
var $91=$y;
|
||
|
|
var $92=((($91)+(1))|0);
|
||
|
|
$y=$92;
|
||
|
|
label=2;break;
|
||
|
|
case 9:
|
||
|
|
var $94=$temp;
|
||
|
|
_free($94);
|
||
|
|
var $95=$rv;
|
||
|
|
STACKTOP=sp;return $95;
|
||
|
|
default: assert(0, "bad label: " + label);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
Module["_bitmap_decompress_16"] = _bitmap_decompress_16;
|
||
|
|
|
||
|
|
function _bitmap_decompress_24($output,$output_width,$output_height,$input_width,$input_height,$input,$size){
|
||
|
|
var label=0;
|
||
|
|
var sp=STACKTOP; (assert((STACKTOP|0) < (STACK_MAX|0))|0);
|
||
|
|
label = 1;
|
||
|
|
while(1)switch(label){
|
||
|
|
case 1:
|
||
|
|
var $1;
|
||
|
|
var $2;
|
||
|
|
var $3;
|
||
|
|
var $4;
|
||
|
|
var $5;
|
||
|
|
var $6;
|
||
|
|
var $7;
|
||
|
|
var $temp;
|
||
|
|
var $rv;
|
||
|
|
var $y;
|
||
|
|
var $x;
|
||
|
|
var $r;
|
||
|
|
var $g;
|
||
|
|
var $b;
|
||
|
|
$1=$output;
|
||
|
|
$2=$output_width;
|
||
|
|
$3=$output_height;
|
||
|
|
$4=$input_width;
|
||
|
|
$5=$input_height;
|
||
|
|
$6=$input;
|
||
|
|
$7=$size;
|
||
|
|
var $8=$4;
|
||
|
|
var $9=$5;
|
||
|
|
var $10=(Math_imul($8,$9)|0);
|
||
|
|
var $11=((($10)*(3))&-1);
|
||
|
|
var $12=_malloc($11);
|
||
|
|
$temp=$12;
|
||
|
|
var $13=$temp;
|
||
|
|
var $14=$4;
|
||
|
|
var $15=$5;
|
||
|
|
var $16=$6;
|
||
|
|
var $17=$7;
|
||
|
|
var $18=_bitmap_decompress3($13,$14,$15,$16,$17);
|
||
|
|
$rv=$18;
|
||
|
|
$y=0;
|
||
|
|
label=2;break;
|
||
|
|
case 2:
|
||
|
|
var $20=$y;
|
||
|
|
var $21=$3;
|
||
|
|
var $22=($20|0)<($21|0);
|
||
|
|
if($22){label=3;break;}else{label=9;break;}
|
||
|
|
case 3:
|
||
|
|
$x=0;
|
||
|
|
label=4;break;
|
||
|
|
case 4:
|
||
|
|
var $25=$x;
|
||
|
|
var $26=$2;
|
||
|
|
var $27=($25|0)<($26|0);
|
||
|
|
if($27){label=5;break;}else{label=7;break;}
|
||
|
|
case 5:
|
||
|
|
var $29=$y;
|
||
|
|
var $30=$4;
|
||
|
|
var $31=(Math_imul($29,$30)|0);
|
||
|
|
var $32=$x;
|
||
|
|
var $33=((($31)+($32))|0);
|
||
|
|
var $34=((($33)*(3))&-1);
|
||
|
|
var $35=$temp;
|
||
|
|
var $36=(($35+$34)|0);
|
||
|
|
var $37=HEAP8[($36)];
|
||
|
|
$r=$37;
|
||
|
|
var $38=$y;
|
||
|
|
var $39=$4;
|
||
|
|
var $40=(Math_imul($38,$39)|0);
|
||
|
|
var $41=$x;
|
||
|
|
var $42=((($40)+($41))|0);
|
||
|
|
var $43=((($42)*(3))&-1);
|
||
|
|
var $44=((($43)+(1))|0);
|
||
|
|
var $45=$temp;
|
||
|
|
var $46=(($45+$44)|0);
|
||
|
|
var $47=HEAP8[($46)];
|
||
|
|
$g=$47;
|
||
|
|
var $48=$y;
|
||
|
|
var $49=$4;
|
||
|
|
var $50=(Math_imul($48,$49)|0);
|
||
|
|
var $51=$x;
|
||
|
|
var $52=((($50)+($51))|0);
|
||
|
|
var $53=((($52)*(3))&-1);
|
||
|
|
var $54=((($53)+(2))|0);
|
||
|
|
var $55=$temp;
|
||
|
|
var $56=(($55+$54)|0);
|
||
|
|
var $57=HEAP8[($56)];
|
||
|
|
$b=$57;
|
||
|
|
var $58=$b;
|
||
|
|
var $59=($58&255);
|
||
|
|
var $60=$59<<16;
|
||
|
|
var $61=-16777216|$60;
|
||
|
|
var $62=$g;
|
||
|
|
var $63=($62&255);
|
||
|
|
var $64=$63<<8;
|
||
|
|
var $65=$61|$64;
|
||
|
|
var $66=$r;
|
||
|
|
var $67=($66&255);
|
||
|
|
var $68=$65|$67;
|
||
|
|
var $69=$y;
|
||
|
|
var $70=$2;
|
||
|
|
var $71=(Math_imul($69,$70)|0);
|
||
|
|
var $72=$x;
|
||
|
|
var $73=((($71)+($72))|0);
|
||
|
|
var $74=$1;
|
||
|
|
var $75=$74;
|
||
|
|
var $76=(($75+($73<<2))|0);
|
||
|
|
HEAP32[(($76)>>2)]=$68;
|
||
|
|
label=6;break;
|
||
|
|
case 6:
|
||
|
|
var $78=$x;
|
||
|
|
var $79=((($78)+(1))|0);
|
||
|
|
$x=$79;
|
||
|
|
label=4;break;
|
||
|
|
case 7:
|
||
|
|
label=8;break;
|
||
|
|
case 8:
|
||
|
|
var $82=$y;
|
||
|
|
var $83=((($82)+(1))|0);
|
||
|
|
$y=$83;
|
||
|
|
label=2;break;
|
||
|
|
case 9:
|
||
|
|
var $85=$temp;
|
||
|
|
_free($85);
|
||
|
|
var $86=$rv;
|
||
|
|
STACKTOP=sp;return $86;
|
||
|
|
default: assert(0, "bad label: " + label);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
Module["_bitmap_decompress_24"] = _bitmap_decompress_24;
|
||
|
|
|
||
|
|
function _bitmap_decompress3($output,$width,$height,$input,$size){
|
||
|
|
var label=0;
|
||
|
|
var sp=STACKTOP;STACKTOP=(STACKTOP+24)|0; (assert((STACKTOP|0) < (STACK_MAX|0))|0);
|
||
|
|
label = 1;
|
||
|
|
while(1)switch(label){
|
||
|
|
case 1:
|
||
|
|
var $1;
|
||
|
|
var $2;
|
||
|
|
var $3;
|
||
|
|
var $4;
|
||
|
|
var $5;
|
||
|
|
var $6;
|
||
|
|
var $end;
|
||
|
|
var $prevline;
|
||
|
|
var $line;
|
||
|
|
var $opcode;
|
||
|
|
var $count;
|
||
|
|
var $offset;
|
||
|
|
var $isfillormix;
|
||
|
|
var $x;
|
||
|
|
var $lastopcode;
|
||
|
|
var $insertmix;
|
||
|
|
var $bicolour;
|
||
|
|
var $code;
|
||
|
|
var $colour1=sp;
|
||
|
|
var $colour2=(sp)+(8);
|
||
|
|
var $mixmask;
|
||
|
|
var $mask;
|
||
|
|
var $mix=(sp)+(16);
|
||
|
|
var $fom_mask;
|
||
|
|
$2=$output;
|
||
|
|
$3=$width;
|
||
|
|
$4=$height;
|
||
|
|
$5=$input;
|
||
|
|
$6=$size;
|
||
|
|
var $7=$5;
|
||
|
|
var $8=$6;
|
||
|
|
var $9=(($7+$8)|0);
|
||
|
|
$end=$9;
|
||
|
|
$prevline=0;
|
||
|
|
$line=0;
|
||
|
|
var $10=$3;
|
||
|
|
$x=$10;
|
||
|
|
$lastopcode=-1;
|
||
|
|
$insertmix=0;
|
||
|
|
$bicolour=0;
|
||
|
|
var $11=$colour1;
|
||
|
|
HEAP8[($11)]=0; HEAP8[((($11)+(1))|0)]=0; HEAP8[((($11)+(2))|0)]=0;
|
||
|
|
var $12=$colour2;
|
||
|
|
HEAP8[($12)]=0; HEAP8[((($12)+(1))|0)]=0; HEAP8[((($12)+(2))|0)]=0;
|
||
|
|
$mask=0;
|
||
|
|
var $13=$mix;
|
||
|
|
assert(3 % 1 === 0);HEAP8[($13)]=HEAP8[(8)];HEAP8[((($13)+(1))|0)]=HEAP8[(9)];HEAP8[((($13)+(2))|0)]=HEAP8[(10)];
|
||
|
|
$fom_mask=0;
|
||
|
|
label=2;break;
|
||
|
|
case 2:
|
||
|
|
var $15=$5;
|
||
|
|
var $16=$end;
|
||
|
|
var $17=($15>>>0)<($16>>>0);
|
||
|
|
if($17){label=3;break;}else{label=346;break;}
|
||
|
|
case 3:
|
||
|
|
$fom_mask=0;
|
||
|
|
var $19=$5;
|
||
|
|
var $20=(($19+1)|0);
|
||
|
|
$5=$20;
|
||
|
|
var $21=HEAP8[($19)];
|
||
|
|
$code=$21;
|
||
|
|
var $22=$code;
|
||
|
|
var $23=($22&255);
|
||
|
|
var $24=$23>>4;
|
||
|
|
$opcode=$24;
|
||
|
|
var $25=$opcode;
|
||
|
|
if(($25|0)==12|($25|0)==13|($25|0)==14){ label=4;break;}else if(($25|0)==15){ label=5;break;}else{label=9;break;}
|
||
|
|
case 4:
|
||
|
|
var $27=$opcode;
|
||
|
|
var $28=((($27)-(6))|0);
|
||
|
|
$opcode=$28;
|
||
|
|
var $29=$code;
|
||
|
|
var $30=($29&255);
|
||
|
|
var $31=$30&15;
|
||
|
|
$count=$31;
|
||
|
|
$offset=16;
|
||
|
|
label=10;break;
|
||
|
|
case 5:
|
||
|
|
var $33=$code;
|
||
|
|
var $34=($33&255);
|
||
|
|
var $35=$34&15;
|
||
|
|
$opcode=$35;
|
||
|
|
var $36=$opcode;
|
||
|
|
var $37=($36|0)<9;
|
||
|
|
if($37){label=6;break;}else{label=7;break;}
|
||
|
|
case 6:
|
||
|
|
var $39=$5;
|
||
|
|
var $40=(($39+1)|0);
|
||
|
|
$5=$40;
|
||
|
|
var $41=HEAP8[($39)];
|
||
|
|
var $42=($41&255);
|
||
|
|
$count=$42;
|
||
|
|
var $43=$5;
|
||
|
|
var $44=(($43+1)|0);
|
||
|
|
$5=$44;
|
||
|
|
var $45=HEAP8[($43)];
|
||
|
|
var $46=($45&255);
|
||
|
|
var $47=$46<<8;
|
||
|
|
var $48=$count;
|
||
|
|
var $49=$48|$47;
|
||
|
|
$count=$49;
|
||
|
|
label=8;break;
|
||
|
|
case 7:
|
||
|
|
var $51=$opcode;
|
||
|
|
var $52=($51|0)<11;
|
||
|
|
var $53=($52?8:1);
|
||
|
|
$count=$53;
|
||
|
|
label=8;break;
|
||
|
|
case 8:
|
||
|
|
$offset=0;
|
||
|
|
label=10;break;
|
||
|
|
case 9:
|
||
|
|
var $56=$opcode;
|
||
|
|
var $57=$56>>1;
|
||
|
|
$opcode=$57;
|
||
|
|
var $58=$code;
|
||
|
|
var $59=($58&255);
|
||
|
|
var $60=$59&31;
|
||
|
|
$count=$60;
|
||
|
|
$offset=32;
|
||
|
|
label=10;break;
|
||
|
|
case 10:
|
||
|
|
var $62=$offset;
|
||
|
|
var $63=($62|0)!=0;
|
||
|
|
if($63){label=11;break;}else{label=22;break;}
|
||
|
|
case 11:
|
||
|
|
var $65=$opcode;
|
||
|
|
var $66=($65|0)==2;
|
||
|
|
if($66){var $71=1;label=13;break;}else{label=12;break;}
|
||
|
|
case 12:
|
||
|
|
var $68=$opcode;
|
||
|
|
var $69=($68|0)==7;
|
||
|
|
var $71=$69;label=13;break;
|
||
|
|
case 13:
|
||
|
|
var $71;
|
||
|
|
var $72=($71&1);
|
||
|
|
$isfillormix=$72;
|
||
|
|
var $73=$count;
|
||
|
|
var $74=($73|0)==0;
|
||
|
|
if($74){label=14;break;}else{label=18;break;}
|
||
|
|
case 14:
|
||
|
|
var $76=$isfillormix;
|
||
|
|
var $77=($76|0)!=0;
|
||
|
|
if($77){label=15;break;}else{label=16;break;}
|
||
|
|
case 15:
|
||
|
|
var $79=$5;
|
||
|
|
var $80=(($79+1)|0);
|
||
|
|
$5=$80;
|
||
|
|
var $81=HEAP8[($79)];
|
||
|
|
var $82=($81&255);
|
||
|
|
var $83=((($82)+(1))|0);
|
||
|
|
$count=$83;
|
||
|
|
label=17;break;
|
||
|
|
case 16:
|
||
|
|
var $85=$5;
|
||
|
|
var $86=(($85+1)|0);
|
||
|
|
$5=$86;
|
||
|
|
var $87=HEAP8[($85)];
|
||
|
|
var $88=($87&255);
|
||
|
|
var $89=$offset;
|
||
|
|
var $90=((($88)+($89))|0);
|
||
|
|
$count=$90;
|
||
|
|
label=17;break;
|
||
|
|
case 17:
|
||
|
|
label=21;break;
|
||
|
|
case 18:
|
||
|
|
var $93=$isfillormix;
|
||
|
|
var $94=($93|0)!=0;
|
||
|
|
if($94){label=19;break;}else{label=20;break;}
|
||
|
|
case 19:
|
||
|
|
var $96=$count;
|
||
|
|
var $97=$96<<3;
|
||
|
|
$count=$97;
|
||
|
|
label=20;break;
|
||
|
|
case 20:
|
||
|
|
label=21;break;
|
||
|
|
case 21:
|
||
|
|
label=22;break;
|
||
|
|
case 22:
|
||
|
|
var $101=$opcode;
|
||
|
|
switch(($101|0)){case 0:{ label=23;break;}case 8:{ label=28;break;}case 3:{ label=29;break;}case 6:case 7:{ label=30;break;}case 9:{ label=31;break;}case 10:{ label=32;break;}default:{label=33;break;}}break;
|
||
|
|
case 23:
|
||
|
|
var $103=$lastopcode;
|
||
|
|
var $104=$opcode;
|
||
|
|
var $105=($103|0)==($104|0);
|
||
|
|
if($105){label=24;break;}else{label=27;break;}
|
||
|
|
case 24:
|
||
|
|
var $107=$x;
|
||
|
|
var $108=$3;
|
||
|
|
var $109=($107|0)==($108|0);
|
||
|
|
if($109){label=25;break;}else{label=26;break;}
|
||
|
|
case 25:
|
||
|
|
var $111=$prevline;
|
||
|
|
var $112=($111|0)==0;
|
||
|
|
if($112){label=27;break;}else{label=26;break;}
|
||
|
|
case 26:
|
||
|
|
$insertmix=1;
|
||
|
|
label=27;break;
|
||
|
|
case 27:
|
||
|
|
label=33;break;
|
||
|
|
case 28:
|
||
|
|
var $116=$5;
|
||
|
|
var $117=(($116+1)|0);
|
||
|
|
$5=$117;
|
||
|
|
var $118=HEAP8[($116)];
|
||
|
|
var $119=(($colour1)|0);
|
||
|
|
HEAP8[($119)]=$118;
|
||
|
|
var $120=$5;
|
||
|
|
var $121=(($120+1)|0);
|
||
|
|
$5=$121;
|
||
|
|
var $122=HEAP8[($120)];
|
||
|
|
var $123=(($colour1+1)|0);
|
||
|
|
HEAP8[($123)]=$122;
|
||
|
|
var $124=$5;
|
||
|
|
var $125=(($124+1)|0);
|
||
|
|
$5=$125;
|
||
|
|
var $126=HEAP8[($124)];
|
||
|
|
var $127=(($colour1+2)|0);
|
||
|
|
HEAP8[($127)]=$126;
|
||
|
|
label=29;break;
|
||
|
|
case 29:
|
||
|
|
var $129=$5;
|
||
|
|
var $130=(($129+1)|0);
|
||
|
|
$5=$130;
|
||
|
|
var $131=HEAP8[($129)];
|
||
|
|
var $132=(($colour2)|0);
|
||
|
|
HEAP8[($132)]=$131;
|
||
|
|
var $133=$5;
|
||
|
|
var $134=(($133+1)|0);
|
||
|
|
$5=$134;
|
||
|
|
var $135=HEAP8[($133)];
|
||
|
|
var $136=(($colour2+1)|0);
|
||
|
|
HEAP8[($136)]=$135;
|
||
|
|
var $137=$5;
|
||
|
|
var $138=(($137+1)|0);
|
||
|
|
$5=$138;
|
||
|
|
var $139=HEAP8[($137)];
|
||
|
|
var $140=(($colour2+2)|0);
|
||
|
|
HEAP8[($140)]=$139;
|
||
|
|
label=33;break;
|
||
|
|
case 30:
|
||
|
|
var $142=$5;
|
||
|
|
var $143=(($142+1)|0);
|
||
|
|
$5=$143;
|
||
|
|
var $144=HEAP8[($142)];
|
||
|
|
var $145=(($mix)|0);
|
||
|
|
HEAP8[($145)]=$144;
|
||
|
|
var $146=$5;
|
||
|
|
var $147=(($146+1)|0);
|
||
|
|
$5=$147;
|
||
|
|
var $148=HEAP8[($146)];
|
||
|
|
var $149=(($mix+1)|0);
|
||
|
|
HEAP8[($149)]=$148;
|
||
|
|
var $150=$5;
|
||
|
|
var $151=(($150+1)|0);
|
||
|
|
$5=$151;
|
||
|
|
var $152=HEAP8[($150)];
|
||
|
|
var $153=(($mix+2)|0);
|
||
|
|
HEAP8[($153)]=$152;
|
||
|
|
var $154=$opcode;
|
||
|
|
var $155=((($154)-(5))|0);
|
||
|
|
$opcode=$155;
|
||
|
|
label=33;break;
|
||
|
|
case 31:
|
||
|
|
$mask=3;
|
||
|
|
$opcode=2;
|
||
|
|
$fom_mask=3;
|
||
|
|
label=33;break;
|
||
|
|
case 32:
|
||
|
|
$mask=5;
|
||
|
|
$opcode=2;
|
||
|
|
$fom_mask=5;
|
||
|
|
label=33;break;
|
||
|
|
case 33:
|
||
|
|
var $159=$opcode;
|
||
|
|
$lastopcode=$159;
|
||
|
|
$mixmask=0;
|
||
|
|
label=34;break;
|
||
|
|
case 34:
|
||
|
|
var $161=$count;
|
||
|
|
var $162=($161|0)>0;
|
||
|
|
if($162){label=35;break;}else{label=345;break;}
|
||
|
|
case 35:
|
||
|
|
var $164=$x;
|
||
|
|
var $165=$3;
|
||
|
|
var $166=($164|0)>=($165|0);
|
||
|
|
if($166){label=36;break;}else{label=39;break;}
|
||
|
|
case 36:
|
||
|
|
var $168=$4;
|
||
|
|
var $169=($168|0)<=0;
|
||
|
|
if($169){label=37;break;}else{label=38;break;}
|
||
|
|
case 37:
|
||
|
|
$1=0;
|
||
|
|
label=347;break;
|
||
|
|
case 38:
|
||
|
|
$x=0;
|
||
|
|
var $172=$4;
|
||
|
|
var $173=((($172)-(1))|0);
|
||
|
|
$4=$173;
|
||
|
|
var $174=$line;
|
||
|
|
$prevline=$174;
|
||
|
|
var $175=$2;
|
||
|
|
var $176=$4;
|
||
|
|
var $177=$3;
|
||
|
|
var $178=((($177)*(3))&-1);
|
||
|
|
var $179=(Math_imul($176,$178)|0);
|
||
|
|
var $180=(($175+$179)|0);
|
||
|
|
$line=$180;
|
||
|
|
label=39;break;
|
||
|
|
case 39:
|
||
|
|
var $182=$opcode;
|
||
|
|
switch(($182|0)){case 3:{ label=261;break;}case 4:{ label=272;break;}case 8:{ label=283;break;}case 13:{ label=321;break;}case 14:{ label=332;break;}case 0:{ label=40;break;}case 1:{ label=69;break;}case 2:{ label=93;break;}default:{label=343;break;}}break;
|
||
|
|
case 40:
|
||
|
|
var $184=$insertmix;
|
||
|
|
var $185=($184|0)!=0;
|
||
|
|
if($185){label=41;break;}else{label=45;break;}
|
||
|
|
case 41:
|
||
|
|
var $187=$prevline;
|
||
|
|
var $188=($187|0)==0;
|
||
|
|
if($188){label=42;break;}else{label=43;break;}
|
||
|
|
case 42:
|
||
|
|
var $190=(($mix)|0);
|
||
|
|
var $191=HEAP8[($190)];
|
||
|
|
var $192=$x;
|
||
|
|
var $193=((($192)*(3))&-1);
|
||
|
|
var $194=$line;
|
||
|
|
var $195=(($194+$193)|0);
|
||
|
|
HEAP8[($195)]=$191;
|
||
|
|
var $196=(($mix+1)|0);
|
||
|
|
var $197=HEAP8[($196)];
|
||
|
|
var $198=$x;
|
||
|
|
var $199=((($198)*(3))&-1);
|
||
|
|
var $200=((($199)+(1))|0);
|
||
|
|
var $201=$line;
|
||
|
|
var $202=(($201+$200)|0);
|
||
|
|
HEAP8[($202)]=$197;
|
||
|
|
var $203=(($mix+2)|0);
|
||
|
|
var $204=HEAP8[($203)];
|
||
|
|
var $205=$x;
|
||
|
|
var $206=((($205)*(3))&-1);
|
||
|
|
var $207=((($206)+(2))|0);
|
||
|
|
var $208=$line;
|
||
|
|
var $209=(($208+$207)|0);
|
||
|
|
HEAP8[($209)]=$204;
|
||
|
|
label=44;break;
|
||
|
|
case 43:
|
||
|
|
var $211=$x;
|
||
|
|
var $212=((($211)*(3))&-1);
|
||
|
|
var $213=$prevline;
|
||
|
|
var $214=(($213+$212)|0);
|
||
|
|
var $215=HEAP8[($214)];
|
||
|
|
var $216=($215&255);
|
||
|
|
var $217=(($mix)|0);
|
||
|
|
var $218=HEAP8[($217)];
|
||
|
|
var $219=($218&255);
|
||
|
|
var $220=$216^$219;
|
||
|
|
var $221=(($220)&255);
|
||
|
|
var $222=$x;
|
||
|
|
var $223=((($222)*(3))&-1);
|
||
|
|
var $224=$line;
|
||
|
|
var $225=(($224+$223)|0);
|
||
|
|
HEAP8[($225)]=$221;
|
||
|
|
var $226=$x;
|
||
|
|
var $227=((($226)*(3))&-1);
|
||
|
|
var $228=((($227)+(1))|0);
|
||
|
|
var $229=$prevline;
|
||
|
|
var $230=(($229+$228)|0);
|
||
|
|
var $231=HEAP8[($230)];
|
||
|
|
var $232=($231&255);
|
||
|
|
var $233=(($mix+1)|0);
|
||
|
|
var $234=HEAP8[($233)];
|
||
|
|
var $235=($234&255);
|
||
|
|
var $236=$232^$235;
|
||
|
|
var $237=(($236)&255);
|
||
|
|
var $238=$x;
|
||
|
|
var $239=((($238)*(3))&-1);
|
||
|
|
var $240=((($239)+(1))|0);
|
||
|
|
var $241=$line;
|
||
|
|
var $242=(($241+$240)|0);
|
||
|
|
HEAP8[($242)]=$237;
|
||
|
|
var $243=$x;
|
||
|
|
var $244=((($243)*(3))&-1);
|
||
|
|
var $245=((($244)+(2))|0);
|
||
|
|
var $246=$prevline;
|
||
|
|
var $247=(($246+$245)|0);
|
||
|
|
var $248=HEAP8[($247)];
|
||
|
|
var $249=($248&255);
|
||
|
|
var $250=(($mix+2)|0);
|
||
|
|
var $251=HEAP8[($250)];
|
||
|
|
var $252=($251&255);
|
||
|
|
var $253=$249^$252;
|
||
|
|
var $254=(($253)&255);
|
||
|
|
var $255=$x;
|
||
|
|
var $256=((($255)*(3))&-1);
|
||
|
|
var $257=((($256)+(2))|0);
|
||
|
|
var $258=$line;
|
||
|
|
var $259=(($258+$257)|0);
|
||
|
|
HEAP8[($259)]=$254;
|
||
|
|
label=44;break;
|
||
|
|
case 44:
|
||
|
|
$insertmix=0;
|
||
|
|
var $261=$count;
|
||
|
|
var $262=((($261)-(1))|0);
|
||
|
|
$count=$262;
|
||
|
|
var $263=$x;
|
||
|
|
var $264=((($263)+(1))|0);
|
||
|
|
$x=$264;
|
||
|
|
label=45;break;
|
||
|
|
case 45:
|
||
|
|
var $266=$prevline;
|
||
|
|
var $267=($266|0)==0;
|
||
|
|
if($267){label=46;break;}else{label=57;break;}
|
||
|
|
case 46:
|
||
|
|
label=47;break;
|
||
|
|
case 47:
|
||
|
|
var $270=$count;
|
||
|
|
var $271=$270&-8;
|
||
|
|
var $272=($271|0)!=0;
|
||
|
|
if($272){label=48;break;}else{var $279=0;label=49;break;}
|
||
|
|
case 48:
|
||
|
|
var $274=$x;
|
||
|
|
var $275=((($274)+(8))|0);
|
||
|
|
var $276=$3;
|
||
|
|
var $277=($275|0)<($276|0);
|
||
|
|
var $279=$277;label=49;break;
|
||
|
|
case 49:
|
||
|
|
var $279;
|
||
|
|
if($279){label=50;break;}else{label=51;break;}
|
||
|
|
case 50:
|
||
|
|
var $281=$x;
|
||
|
|
var $282=((($281)*(3))&-1);
|
||
|
|
var $283=$line;
|
||
|
|
var $284=(($283+$282)|0);
|
||
|
|
HEAP8[($284)]=0;
|
||
|
|
var $285=$x;
|
||
|
|
var $286=((($285)*(3))&-1);
|
||
|
|
var $287=((($286)+(1))|0);
|
||
|
|
var $288=$line;
|
||
|
|
var $289=(($288+$287)|0);
|
||
|
|
HEAP8[($289)]=0;
|
||
|
|
var $290=$x;
|
||
|
|
var $291=((($290)*(3))&-1);
|
||
|
|
var $292=((($291)+(2))|0);
|
||
|
|
var $293=$line;
|
||
|
|
var $294=(($293+$292)|0);
|
||
|
|
HEAP8[($294)]=0;
|
||
|
|
var $295=$count;
|
||
|
|
var $296=((($295)-(1))|0);
|
||
|
|
$count=$296;
|
||
|
|
var $297=$x;
|
||
|
|
var $298=((($297)+(1))|0);
|
||
|
|
$x=$298;
|
||
|
|
var $299=$x;
|
||
|
|
var $300=((($299)*(3))&-1);
|
||
|
|
var $301=$line;
|
||
|
|
var $302=(($301+$300)|0);
|
||
|
|
HEAP8[($302)]=0;
|
||
|
|
var $303=$x;
|
||
|
|
var $304=((($303)*(3))&-1);
|
||
|
|
var $305=((($304)+(1))|0);
|
||
|
|
var $306=$line;
|
||
|
|
var $307=(($306+$305)|0);
|
||
|
|
HEAP8[($307)]=0;
|
||
|
|
var $308=$x;
|
||
|
|
var $309=((($308)*(3))&-1);
|
||
|
|
var $310=((($309)+(2))|0);
|
||
|
|
var $311=$line;
|
||
|
|
var $312=(($311+$310)|0);
|
||
|
|
HEAP8[($312)]=0;
|
||
|
|
var $313=$count;
|
||
|
|
var $314=((($313)-(1))|0);
|
||
|
|
$count=$314;
|
||
|
|
var $315=$x;
|
||
|
|
var $316=((($315)+(1))|0);
|
||
|
|
$x=$316;
|
||
|
|
var $317=$x;
|
||
|
|
var $318=((($317)*(3))&-1);
|
||
|
|
var $319=$line;
|
||
|
|
var $320=(($319+$318)|0);
|
||
|
|
HEAP8[($320)]=0;
|
||
|
|
var $321=$x;
|
||
|
|
var $322=((($321)*(3))&-1);
|
||
|
|
var $323=((($322)+(1))|0);
|
||
|
|
var $324=$line;
|
||
|
|
var $325=(($324+$323)|0);
|
||
|
|
HEAP8[($325)]=0;
|
||
|
|
var $326=$x;
|
||
|
|
var $327=((($326)*(3))&-1);
|
||
|
|
var $328=((($327)+(2))|0);
|
||
|
|
var $329=$line;
|
||
|
|
var $330=(($329+$328)|0);
|
||
|
|
HEAP8[($330)]=0;
|
||
|
|
var $331=$count;
|
||
|
|
var $332=((($331)-(1))|0);
|
||
|
|
$count=$332;
|
||
|
|
var $333=$x;
|
||
|
|
var $334=((($333)+(1))|0);
|
||
|
|
$x=$334;
|
||
|
|
var $335=$x;
|
||
|
|
var $336=((($335)*(3))&-1);
|
||
|
|
var $337=$line;
|
||
|
|
var $338=(($337+$336)|0);
|
||
|
|
HEAP8[($338)]=0;
|
||
|
|
var $339=$x;
|
||
|
|
var $340=((($339)*(3))&-1);
|
||
|
|
var $341=((($340)+(1))|0);
|
||
|
|
var $342=$line;
|
||
|
|
var $343=(($342+$341)|0);
|
||
|
|
HEAP8[($343)]=0;
|
||
|
|
var $344=$x;
|
||
|
|
var $345=((($344)*(3))&-1);
|
||
|
|
var $346=((($345)+(2))|0);
|
||
|
|
var $347=$line;
|
||
|
|
var $348=(($347+$346)|0);
|
||
|
|
HEAP8[($348)]=0;
|
||
|
|
var $349=$count;
|
||
|
|
var $350=((($349)-(1))|0);
|
||
|
|
$count=$350;
|
||
|
|
var $351=$x;
|
||
|
|
var $352=((($351)+(1))|0);
|
||
|
|
$x=$352;
|
||
|
|
var $353=$x;
|
||
|
|
var $354=((($353)*(3))&-1);
|
||
|
|
var $355=$line;
|
||
|
|
var $356=(($355+$354)|0);
|
||
|
|
HEAP8[($356)]=0;
|
||
|
|
var $357=$x;
|
||
|
|
var $358=((($357)*(3))&-1);
|
||
|
|
var $359=((($358)+(1))|0);
|
||
|
|
var $360=$line;
|
||
|
|
var $361=(($360+$359)|0);
|
||
|
|
HEAP8[($361)]=0;
|
||
|
|
var $362=$x;
|
||
|
|
var $363=((($362)*(3))&-1);
|
||
|
|
var $364=((($363)+(2))|0);
|
||
|
|
var $365=$line;
|
||
|
|
var $366=(($365+$364)|0);
|
||
|
|
HEAP8[($366)]=0;
|
||
|
|
var $367=$count;
|
||
|
|
var $368=((($367)-(1))|0);
|
||
|
|
$count=$368;
|
||
|
|
var $369=$x;
|
||
|
|
var $370=((($369)+(1))|0);
|
||
|
|
$x=$370;
|
||
|
|
var $371=$x;
|
||
|
|
var $372=((($371)*(3))&-1);
|
||
|
|
var $373=$line;
|
||
|
|
var $374=(($373+$372)|0);
|
||
|
|
HEAP8[($374)]=0;
|
||
|
|
var $375=$x;
|
||
|
|
var $376=((($375)*(3))&-1);
|
||
|
|
var $377=((($376)+(1))|0);
|
||
|
|
var $378=$line;
|
||
|
|
var $379=(($378+$377)|0);
|
||
|
|
HEAP8[($379)]=0;
|
||
|
|
var $380=$x;
|
||
|
|
var $381=((($380)*(3))&-1);
|
||
|
|
var $382=((($381)+(2))|0);
|
||
|
|
var $383=$line;
|
||
|
|
var $384=(($383+$382)|0);
|
||
|
|
HEAP8[($384)]=0;
|
||
|
|
var $385=$count;
|
||
|
|
var $386=((($385)-(1))|0);
|
||
|
|
$count=$386;
|
||
|
|
var $387=$x;
|
||
|
|
var $388=((($387)+(1))|0);
|
||
|
|
$x=$388;
|
||
|
|
var $389=$x;
|
||
|
|
var $390=((($389)*(3))&-1);
|
||
|
|
var $391=$line;
|
||
|
|
var $392=(($391+$390)|0);
|
||
|
|
HEAP8[($392)]=0;
|
||
|
|
var $393=$x;
|
||
|
|
var $394=((($393)*(3))&-1);
|
||
|
|
var $395=((($394)+(1))|0);
|
||
|
|
var $396=$line;
|
||
|
|
var $397=(($396+$395)|0);
|
||
|
|
HEAP8[($397)]=0;
|
||
|
|
var $398=$x;
|
||
|
|
var $399=((($398)*(3))&-1);
|
||
|
|
var $400=((($399)+(2))|0);
|
||
|
|
var $401=$line;
|
||
|
|
var $402=(($401+$400)|0);
|
||
|
|
HEAP8[($402)]=0;
|
||
|
|
var $403=$count;
|
||
|
|
var $404=((($403)-(1))|0);
|
||
|
|
$count=$404;
|
||
|
|
var $405=$x;
|
||
|
|
var $406=((($405)+(1))|0);
|
||
|
|
$x=$406;
|
||
|
|
var $407=$x;
|
||
|
|
var $408=((($407)*(3))&-1);
|
||
|
|
var $409=$line;
|
||
|
|
var $410=(($409+$408)|0);
|
||
|
|
HEAP8[($410)]=0;
|
||
|
|
var $411=$x;
|
||
|
|
var $412=((($411)*(3))&-1);
|
||
|
|
var $413=((($412)+(1))|0);
|
||
|
|
var $414=$line;
|
||
|
|
var $415=(($414+$413)|0);
|
||
|
|
HEAP8[($415)]=0;
|
||
|
|
var $416=$x;
|
||
|
|
var $417=((($416)*(3))&-1);
|
||
|
|
var $418=((($417)+(2))|0);
|
||
|
|
var $419=$line;
|
||
|
|
var $420=(($419+$418)|0);
|
||
|
|
HEAP8[($420)]=0;
|
||
|
|
var $421=$count;
|
||
|
|
var $422=((($421)-(1))|0);
|
||
|
|
$count=$422;
|
||
|
|
var $423=$x;
|
||
|
|
var $424=((($423)+(1))|0);
|
||
|
|
$x=$424;
|
||
|
|
label=47;break;
|
||
|
|
case 51:
|
||
|
|
label=52;break;
|
||
|
|
case 52:
|
||
|
|
var $427=$count;
|
||
|
|
var $428=($427|0)>0;
|
||
|
|
if($428){label=53;break;}else{var $434=0;label=54;break;}
|
||
|
|
case 53:
|
||
|
|
var $430=$x;
|
||
|
|
var $431=$3;
|
||
|
|
var $432=($430|0)<($431|0);
|
||
|
|
var $434=$432;label=54;break;
|
||
|
|
case 54:
|
||
|
|
var $434;
|
||
|
|
if($434){label=55;break;}else{label=56;break;}
|
||
|
|
case 55:
|
||
|
|
var $436=$x;
|
||
|
|
var $437=((($436)*(3))&-1);
|
||
|
|
var $438=$line;
|
||
|
|
var $439=(($438+$437)|0);
|
||
|
|
HEAP8[($439)]=0;
|
||
|
|
var $440=$x;
|
||
|
|
var $441=((($440)*(3))&-1);
|
||
|
|
var $442=((($441)+(1))|0);
|
||
|
|
var $443=$line;
|
||
|
|
var $444=(($443+$442)|0);
|
||
|
|
HEAP8[($444)]=0;
|
||
|
|
var $445=$x;
|
||
|
|
var $446=((($445)*(3))&-1);
|
||
|
|
var $447=((($446)+(2))|0);
|
||
|
|
var $448=$line;
|
||
|
|
var $449=(($448+$447)|0);
|
||
|
|
HEAP8[($449)]=0;
|
||
|
|
var $450=$count;
|
||
|
|
var $451=((($450)-(1))|0);
|
||
|
|
$count=$451;
|
||
|
|
var $452=$x;
|
||
|
|
var $453=((($452)+(1))|0);
|
||
|
|
$x=$453;
|
||
|
|
label=52;break;
|
||
|
|
case 56:
|
||
|
|
label=68;break;
|
||
|
|
case 57:
|
||
|
|
label=58;break;
|
||
|
|
case 58:
|
||
|
|
var $457=$count;
|
||
|
|
var $458=$457&-8;
|
||
|
|
var $459=($458|0)!=0;
|
||
|
|
if($459){label=59;break;}else{var $466=0;label=60;break;}
|
||
|
|
case 59:
|
||
|
|
var $461=$x;
|
||
|
|
var $462=((($461)+(8))|0);
|
||
|
|
var $463=$3;
|
||
|
|
var $464=($462|0)<($463|0);
|
||
|
|
var $466=$464;label=60;break;
|
||
|
|
case 60:
|
||
|
|
var $466;
|
||
|
|
if($466){label=61;break;}else{label=62;break;}
|
||
|
|
case 61:
|
||
|
|
var $468=$x;
|
||
|
|
var $469=((($468)*(3))&-1);
|
||
|
|
var $470=$prevline;
|
||
|
|
var $471=(($470+$469)|0);
|
||
|
|
var $472=HEAP8[($471)];
|
||
|
|
var $473=$x;
|
||
|
|
var $474=((($473)*(3))&-1);
|
||
|
|
var $475=$line;
|
||
|
|
var $476=(($475+$474)|0);
|
||
|
|
HEAP8[($476)]=$472;
|
||
|
|
var $477=$x;
|
||
|
|
var $478=((($477)*(3))&-1);
|
||
|
|
var $479=((($478)+(1))|0);
|
||
|
|
var $480=$prevline;
|
||
|
|
var $481=(($480+$479)|0);
|
||
|
|
var $482=HEAP8[($481)];
|
||
|
|
var $483=$x;
|
||
|
|
var $484=((($483)*(3))&-1);
|
||
|
|
var $485=((($484)+(1))|0);
|
||
|
|
var $486=$line;
|
||
|
|
var $487=(($486+$485)|0);
|
||
|
|
HEAP8[($487)]=$482;
|
||
|
|
var $488=$x;
|
||
|
|
var $489=((($488)*(3))&-1);
|
||
|
|
var $490=((($489)+(2))|0);
|
||
|
|
var $491=$prevline;
|
||
|
|
var $492=(($491+$490)|0);
|
||
|
|
var $493=HEAP8[($492)];
|
||
|
|
var $494=$x;
|
||
|
|
var $495=((($494)*(3))&-1);
|
||
|
|
var $496=((($495)+(2))|0);
|
||
|
|
var $497=$line;
|
||
|
|
var $498=(($497+$496)|0);
|
||
|
|
HEAP8[($498)]=$493;
|
||
|
|
var $499=$count;
|
||
|
|
var $500=((($499)-(1))|0);
|
||
|
|
$count=$500;
|
||
|
|
var $501=$x;
|
||
|
|
var $502=((($501)+(1))|0);
|
||
|
|
$x=$502;
|
||
|
|
var $503=$x;
|
||
|
|
var $504=((($503)*(3))&-1);
|
||
|
|
var $505=$prevline;
|
||
|
|
var $506=(($505+$504)|0);
|
||
|
|
var $507=HEAP8[($506)];
|
||
|
|
var $508=$x;
|
||
|
|
var $509=((($508)*(3))&-1);
|
||
|
|
var $510=$line;
|
||
|
|
var $511=(($510+$509)|0);
|
||
|
|
HEAP8[($511)]=$507;
|
||
|
|
var $512=$x;
|
||
|
|
var $513=((($512)*(3))&-1);
|
||
|
|
var $514=((($513)+(1))|0);
|
||
|
|
var $515=$prevline;
|
||
|
|
var $516=(($515+$514)|0);
|
||
|
|
var $517=HEAP8[($516)];
|
||
|
|
var $518=$x;
|
||
|
|
var $519=((($518)*(3))&-1);
|
||
|
|
var $520=((($519)+(1))|0);
|
||
|
|
var $521=$line;
|
||
|
|
var $522=(($521+$520)|0);
|
||
|
|
HEAP8[($522)]=$517;
|
||
|
|
var $523=$x;
|
||
|
|
var $524=((($523)*(3))&-1);
|
||
|
|
var $525=((($524)+(2))|0);
|
||
|
|
var $526=$prevline;
|
||
|
|
var $527=(($526+$525)|0);
|
||
|
|
var $528=HEAP8[($527)];
|
||
|
|
var $529=$x;
|
||
|
|
var $530=((($529)*(3))&-1);
|
||
|
|
var $531=((($530)+(2))|0);
|
||
|
|
var $532=$line;
|
||
|
|
var $533=(($532+$531)|0);
|
||
|
|
HEAP8[($533)]=$528;
|
||
|
|
var $534=$count;
|
||
|
|
var $535=((($534)-(1))|0);
|
||
|
|
$count=$535;
|
||
|
|
var $536=$x;
|
||
|
|
var $537=((($536)+(1))|0);
|
||
|
|
$x=$537;
|
||
|
|
var $538=$x;
|
||
|
|
var $539=((($538)*(3))&-1);
|
||
|
|
var $540=$prevline;
|
||
|
|
var $541=(($540+$539)|0);
|
||
|
|
var $542=HEAP8[($541)];
|
||
|
|
var $543=$x;
|
||
|
|
var $544=((($543)*(3))&-1);
|
||
|
|
var $545=$line;
|
||
|
|
var $546=(($545+$544)|0);
|
||
|
|
HEAP8[($546)]=$542;
|
||
|
|
var $547=$x;
|
||
|
|
var $548=((($547)*(3))&-1);
|
||
|
|
var $549=((($548)+(1))|0);
|
||
|
|
var $550=$prevline;
|
||
|
|
var $551=(($550+$549)|0);
|
||
|
|
var $552=HEAP8[($551)];
|
||
|
|
var $553=$x;
|
||
|
|
var $554=((($553)*(3))&-1);
|
||
|
|
var $555=((($554)+(1))|0);
|
||
|
|
var $556=$line;
|
||
|
|
var $557=(($556+$555)|0);
|
||
|
|
HEAP8[($557)]=$552;
|
||
|
|
var $558=$x;
|
||
|
|
var $559=((($558)*(3))&-1);
|
||
|
|
var $560=((($559)+(2))|0);
|
||
|
|
var $561=$prevline;
|
||
|
|
var $562=(($561+$560)|0);
|
||
|
|
var $563=HEAP8[($562)];
|
||
|
|
var $564=$x;
|
||
|
|
var $565=((($564)*(3))&-1);
|
||
|
|
var $566=((($565)+(2))|0);
|
||
|
|
var $567=$line;
|
||
|
|
var $568=(($567+$566)|0);
|
||
|
|
HEAP8[($568)]=$563;
|
||
|
|
var $569=$count;
|
||
|
|
var $570=((($569)-(1))|0);
|
||
|
|
$count=$570;
|
||
|
|
var $571=$x;
|
||
|
|
var $572=((($571)+(1))|0);
|
||
|
|
$x=$572;
|
||
|
|
var $573=$x;
|
||
|
|
var $574=((($573)*(3))&-1);
|
||
|
|
var $575=$prevline;
|
||
|
|
var $576=(($575+$574)|0);
|
||
|
|
var $577=HEAP8[($576)];
|
||
|
|
var $578=$x;
|
||
|
|
var $579=((($578)*(3))&-1);
|
||
|
|
var $580=$line;
|
||
|
|
var $581=(($580+$579)|0);
|
||
|
|
HEAP8[($581)]=$577;
|
||
|
|
var $582=$x;
|
||
|
|
var $583=((($582)*(3))&-1);
|
||
|
|
var $584=((($583)+(1))|0);
|
||
|
|
var $585=$prevline;
|
||
|
|
var $586=(($585+$584)|0);
|
||
|
|
var $587=HEAP8[($586)];
|
||
|
|
var $588=$x;
|
||
|
|
var $589=((($588)*(3))&-1);
|
||
|
|
var $590=((($589)+(1))|0);
|
||
|
|
var $591=$line;
|
||
|
|
var $592=(($591+$590)|0);
|
||
|
|
HEAP8[($592)]=$587;
|
||
|
|
var $593=$x;
|
||
|
|
var $594=((($593)*(3))&-1);
|
||
|
|
var $595=((($594)+(2))|0);
|
||
|
|
var $596=$prevline;
|
||
|
|
var $597=(($596+$595)|0);
|
||
|
|
var $598=HEAP8[($597)];
|
||
|
|
var $599=$x;
|
||
|
|
var $600=((($599)*(3))&-1);
|
||
|
|
var $601=((($600)+(2))|0);
|
||
|
|
var $602=$line;
|
||
|
|
var $603=(($602+$601)|0);
|
||
|
|
HEAP8[($603)]=$598;
|
||
|
|
var $604=$count;
|
||
|
|
var $605=((($604)-(1))|0);
|
||
|
|
$count=$605;
|
||
|
|
var $606=$x;
|
||
|
|
var $607=((($606)+(1))|0);
|
||
|
|
$x=$607;
|
||
|
|
var $608=$x;
|
||
|
|
var $609=((($608)*(3))&-1);
|
||
|
|
var $610=$prevline;
|
||
|
|
var $611=(($610+$609)|0);
|
||
|
|
var $612=HEAP8[($611)];
|
||
|
|
var $613=$x;
|
||
|
|
var $614=((($613)*(3))&-1);
|
||
|
|
var $615=$line;
|
||
|
|
var $616=(($615+$614)|0);
|
||
|
|
HEAP8[($616)]=$612;
|
||
|
|
var $617=$x;
|
||
|
|
var $618=((($617)*(3))&-1);
|
||
|
|
var $619=((($618)+(1))|0);
|
||
|
|
var $620=$prevline;
|
||
|
|
var $621=(($620+$619)|0);
|
||
|
|
var $622=HEAP8[($621)];
|
||
|
|
var $623=$x;
|
||
|
|
var $624=((($623)*(3))&-1);
|
||
|
|
var $625=((($624)+(1))|0);
|
||
|
|
var $626=$line;
|
||
|
|
var $627=(($626+$625)|0);
|
||
|
|
HEAP8[($627)]=$622;
|
||
|
|
var $628=$x;
|
||
|
|
var $629=((($628)*(3))&-1);
|
||
|
|
var $630=((($629)+(2))|0);
|
||
|
|
var $631=$prevline;
|
||
|
|
var $632=(($631+$630)|0);
|
||
|
|
var $633=HEAP8[($632)];
|
||
|
|
var $634=$x;
|
||
|
|
var $635=((($634)*(3))&-1);
|
||
|
|
var $636=((($635)+(2))|0);
|
||
|
|
var $637=$line;
|
||
|
|
var $638=(($637+$636)|0);
|
||
|
|
HEAP8[($638)]=$633;
|
||
|
|
var $639=$count;
|
||
|
|
var $640=((($639)-(1))|0);
|
||
|
|
$count=$640;
|
||
|
|
var $641=$x;
|
||
|
|
var $642=((($641)+(1))|0);
|
||
|
|
$x=$642;
|
||
|
|
var $643=$x;
|
||
|
|
var $644=((($643)*(3))&-1);
|
||
|
|
var $645=$prevline;
|
||
|
|
var $646=(($645+$644)|0);
|
||
|
|
var $647=HEAP8[($646)];
|
||
|
|
var $648=$x;
|
||
|
|
var $649=((($648)*(3))&-1);
|
||
|
|
var $650=$line;
|
||
|
|
var $651=(($650+$649)|0);
|
||
|
|
HEAP8[($651)]=$647;
|
||
|
|
var $652=$x;
|
||
|
|
var $653=((($652)*(3))&-1);
|
||
|
|
var $654=((($653)+(1))|0);
|
||
|
|
var $655=$prevline;
|
||
|
|
var $656=(($655+$654)|0);
|
||
|
|
var $657=HEAP8[($656)];
|
||
|
|
var $658=$x;
|
||
|
|
var $659=((($658)*(3))&-1);
|
||
|
|
var $660=((($659)+(1))|0);
|
||
|
|
var $661=$line;
|
||
|
|
var $662=(($661+$660)|0);
|
||
|
|
HEAP8[($662)]=$657;
|
||
|
|
var $663=$x;
|
||
|
|
var $664=((($663)*(3))&-1);
|
||
|
|
var $665=((($664)+(2))|0);
|
||
|
|
var $666=$prevline;
|
||
|
|
var $667=(($666+$665)|0);
|
||
|
|
var $668=HEAP8[($667)];
|
||
|
|
var $669=$x;
|
||
|
|
var $670=((($669)*(3))&-1);
|
||
|
|
var $671=((($670)+(2))|0);
|
||
|
|
var $672=$line;
|
||
|
|
var $673=(($672+$671)|0);
|
||
|
|
HEAP8[($673)]=$668;
|
||
|
|
var $674=$count;
|
||
|
|
var $675=((($674)-(1))|0);
|
||
|
|
$count=$675;
|
||
|
|
var $676=$x;
|
||
|
|
var $677=((($676)+(1))|0);
|
||
|
|
$x=$677;
|
||
|
|
var $678=$x;
|
||
|
|
var $679=((($678)*(3))&-1);
|
||
|
|
var $680=$prevline;
|
||
|
|
var $681=(($680+$679)|0);
|
||
|
|
var $682=HEAP8[($681)];
|
||
|
|
var $683=$x;
|
||
|
|
var $684=((($683)*(3))&-1);
|
||
|
|
var $685=$line;
|
||
|
|
var $686=(($685+$684)|0);
|
||
|
|
HEAP8[($686)]=$682;
|
||
|
|
var $687=$x;
|
||
|
|
var $688=((($687)*(3))&-1);
|
||
|
|
var $689=((($688)+(1))|0);
|
||
|
|
var $690=$prevline;
|
||
|
|
var $691=(($690+$689)|0);
|
||
|
|
var $692=HEAP8[($691)];
|
||
|
|
var $693=$x;
|
||
|
|
var $694=((($693)*(3))&-1);
|
||
|
|
var $695=((($694)+(1))|0);
|
||
|
|
var $696=$line;
|
||
|
|
var $697=(($696+$695)|0);
|
||
|
|
HEAP8[($697)]=$692;
|
||
|
|
var $698=$x;
|
||
|
|
var $699=((($698)*(3))&-1);
|
||
|
|
var $700=((($699)+(2))|0);
|
||
|
|
var $701=$prevline;
|
||
|
|
var $702=(($701+$700)|0);
|
||
|
|
var $703=HEAP8[($702)];
|
||
|
|
var $704=$x;
|
||
|
|
var $705=((($704)*(3))&-1);
|
||
|
|
var $706=((($705)+(2))|0);
|
||
|
|
var $707=$line;
|
||
|
|
var $708=(($707+$706)|0);
|
||
|
|
HEAP8[($708)]=$703;
|
||
|
|
var $709=$count;
|
||
|
|
var $710=((($709)-(1))|0);
|
||
|
|
$count=$710;
|
||
|
|
var $711=$x;
|
||
|
|
var $712=((($711)+(1))|0);
|
||
|
|
$x=$712;
|
||
|
|
var $713=$x;
|
||
|
|
var $714=((($713)*(3))&-1);
|
||
|
|
var $715=$prevline;
|
||
|
|
var $716=(($715+$714)|0);
|
||
|
|
var $717=HEAP8[($716)];
|
||
|
|
var $718=$x;
|
||
|
|
var $719=((($718)*(3))&-1);
|
||
|
|
var $720=$line;
|
||
|
|
var $721=(($720+$719)|0);
|
||
|
|
HEAP8[($721)]=$717;
|
||
|
|
var $722=$x;
|
||
|
|
var $723=((($722)*(3))&-1);
|
||
|
|
var $724=((($723)+(1))|0);
|
||
|
|
var $725=$prevline;
|
||
|
|
var $726=(($725+$724)|0);
|
||
|
|
var $727=HEAP8[($726)];
|
||
|
|
var $728=$x;
|
||
|
|
var $729=((($728)*(3))&-1);
|
||
|
|
var $730=((($729)+(1))|0);
|
||
|
|
var $731=$line;
|
||
|
|
var $732=(($731+$730)|0);
|
||
|
|
HEAP8[($732)]=$727;
|
||
|
|
var $733=$x;
|
||
|
|
var $734=((($733)*(3))&-1);
|
||
|
|
var $735=((($734)+(2))|0);
|
||
|
|
var $736=$prevline;
|
||
|
|
var $737=(($736+$735)|0);
|
||
|
|
var $738=HEAP8[($737)];
|
||
|
|
var $739=$x;
|
||
|
|
var $740=((($739)*(3))&-1);
|
||
|
|
var $741=((($740)+(2))|0);
|
||
|
|
var $742=$line;
|
||
|
|
var $743=(($742+$741)|0);
|
||
|
|
HEAP8[($743)]=$738;
|
||
|
|
var $744=$count;
|
||
|
|
var $745=((($744)-(1))|0);
|
||
|
|
$count=$745;
|
||
|
|
var $746=$x;
|
||
|
|
var $747=((($746)+(1))|0);
|
||
|
|
$x=$747;
|
||
|
|
label=58;break;
|
||
|
|
case 62:
|
||
|
|
label=63;break;
|
||
|
|
case 63:
|
||
|
|
var $750=$count;
|
||
|
|
var $751=($750|0)>0;
|
||
|
|
if($751){label=64;break;}else{var $757=0;label=65;break;}
|
||
|
|
case 64:
|
||
|
|
var $753=$x;
|
||
|
|
var $754=$3;
|
||
|
|
var $755=($753|0)<($754|0);
|
||
|
|
var $757=$755;label=65;break;
|
||
|
|
case 65:
|
||
|
|
var $757;
|
||
|
|
if($757){label=66;break;}else{label=67;break;}
|
||
|
|
case 66:
|
||
|
|
var $759=$x;
|
||
|
|
var $760=((($759)*(3))&-1);
|
||
|
|
var $761=$prevline;
|
||
|
|
var $762=(($761+$760)|0);
|
||
|
|
var $763=HEAP8[($762)];
|
||
|
|
var $764=$x;
|
||
|
|
var $765=((($764)*(3))&-1);
|
||
|
|
var $766=$line;
|
||
|
|
var $767=(($766+$765)|0);
|
||
|
|
HEAP8[($767)]=$763;
|
||
|
|
var $768=$x;
|
||
|
|
var $769=((($768)*(3))&-1);
|
||
|
|
var $770=((($769)+(1))|0);
|
||
|
|
var $771=$prevline;
|
||
|
|
var $772=(($771+$770)|0);
|
||
|
|
var $773=HEAP8[($772)];
|
||
|
|
var $774=$x;
|
||
|
|
var $775=((($774)*(3))&-1);
|
||
|
|
var $776=((($775)+(1))|0);
|
||
|
|
var $777=$line;
|
||
|
|
var $778=(($777+$776)|0);
|
||
|
|
HEAP8[($778)]=$773;
|
||
|
|
var $779=$x;
|
||
|
|
var $780=((($779)*(3))&-1);
|
||
|
|
var $781=((($780)+(2))|0);
|
||
|
|
var $782=$prevline;
|
||
|
|
var $783=(($782+$781)|0);
|
||
|
|
var $784=HEAP8[($783)];
|
||
|
|
var $785=$x;
|
||
|
|
var $786=((($785)*(3))&-1);
|
||
|
|
var $787=((($786)+(2))|0);
|
||
|
|
var $788=$line;
|
||
|
|
var $789=(($788+$787)|0);
|
||
|
|
HEAP8[($789)]=$784;
|
||
|
|
var $790=$count;
|
||
|
|
var $791=((($790)-(1))|0);
|
||
|
|
$count=$791;
|
||
|
|
var $792=$x;
|
||
|
|
var $793=((($792)+(1))|0);
|
||
|
|
$x=$793;
|
||
|
|
label=63;break;
|
||
|
|
case 67:
|
||
|
|
label=68;break;
|
||
|
|
case 68:
|
||
|
|
label=344;break;
|
||
|
|
case 69:
|
||
|
|
var $797=$prevline;
|
||
|
|
var $798=($797|0)==0;
|
||
|
|
if($798){label=70;break;}else{label=81;break;}
|
||
|
|
case 70:
|
||
|
|
label=71;break;
|
||
|
|
case 71:
|
||
|
|
var $801=$count;
|
||
|
|
var $802=$801&-8;
|
||
|
|
var $803=($802|0)!=0;
|
||
|
|
if($803){label=72;break;}else{var $810=0;label=73;break;}
|
||
|
|
case 72:
|
||
|
|
var $805=$x;
|
||
|
|
var $806=((($805)+(8))|0);
|
||
|
|
var $807=$3;
|
||
|
|
var $808=($806|0)<($807|0);
|
||
|
|
var $810=$808;label=73;break;
|
||
|
|
case 73:
|
||
|
|
var $810;
|
||
|
|
if($810){label=74;break;}else{label=75;break;}
|
||
|
|
case 74:
|
||
|
|
var $812=(($mix)|0);
|
||
|
|
var $813=HEAP8[($812)];
|
||
|
|
var $814=$x;
|
||
|
|
var $815=((($814)*(3))&-1);
|
||
|
|
var $816=$line;
|
||
|
|
var $817=(($816+$815)|0);
|
||
|
|
HEAP8[($817)]=$813;
|
||
|
|
var $818=(($mix+1)|0);
|
||
|
|
var $819=HEAP8[($818)];
|
||
|
|
var $820=$x;
|
||
|
|
var $821=((($820)*(3))&-1);
|
||
|
|
var $822=((($821)+(1))|0);
|
||
|
|
var $823=$line;
|
||
|
|
var $824=(($823+$822)|0);
|
||
|
|
HEAP8[($824)]=$819;
|
||
|
|
var $825=(($mix+2)|0);
|
||
|
|
var $826=HEAP8[($825)];
|
||
|
|
var $827=$x;
|
||
|
|
var $828=((($827)*(3))&-1);
|
||
|
|
var $829=((($828)+(2))|0);
|
||
|
|
var $830=$line;
|
||
|
|
var $831=(($830+$829)|0);
|
||
|
|
HEAP8[($831)]=$826;
|
||
|
|
var $832=$count;
|
||
|
|
var $833=((($832)-(1))|0);
|
||
|
|
$count=$833;
|
||
|
|
var $834=$x;
|
||
|
|
var $835=((($834)+(1))|0);
|
||
|
|
$x=$835;
|
||
|
|
var $836=(($mix)|0);
|
||
|
|
var $837=HEAP8[($836)];
|
||
|
|
var $838=$x;
|
||
|
|
var $839=((($838)*(3))&-1);
|
||
|
|
var $840=$line;
|
||
|
|
var $841=(($840+$839)|0);
|
||
|
|
HEAP8[($841)]=$837;
|
||
|
|
var $842=(($mix+1)|0);
|
||
|
|
var $843=HEAP8[($842)];
|
||
|
|
var $844=$x;
|
||
|
|
var $845=((($844)*(3))&-1);
|
||
|
|
var $846=((($845)+(1))|0);
|
||
|
|
var $847=$line;
|
||
|
|
var $848=(($847+$846)|0);
|
||
|
|
HEAP8[($848)]=$843;
|
||
|
|
var $849=(($mix+2)|0);
|
||
|
|
var $850=HEAP8[($849)];
|
||
|
|
var $851=$x;
|
||
|
|
var $852=((($851)*(3))&-1);
|
||
|
|
var $853=((($852)+(2))|0);
|
||
|
|
var $854=$line;
|
||
|
|
var $855=(($854+$853)|0);
|
||
|
|
HEAP8[($855)]=$850;
|
||
|
|
var $856=$count;
|
||
|
|
var $857=((($856)-(1))|0);
|
||
|
|
$count=$857;
|
||
|
|
var $858=$x;
|
||
|
|
var $859=((($858)+(1))|0);
|
||
|
|
$x=$859;
|
||
|
|
var $860=(($mix)|0);
|
||
|
|
var $861=HEAP8[($860)];
|
||
|
|
var $862=$x;
|
||
|
|
var $863=((($862)*(3))&-1);
|
||
|
|
var $864=$line;
|
||
|
|
var $865=(($864+$863)|0);
|
||
|
|
HEAP8[($865)]=$861;
|
||
|
|
var $866=(($mix+1)|0);
|
||
|
|
var $867=HEAP8[($866)];
|
||
|
|
var $868=$x;
|
||
|
|
var $869=((($868)*(3))&-1);
|
||
|
|
var $870=((($869)+(1))|0);
|
||
|
|
var $871=$line;
|
||
|
|
var $872=(($871+$870)|0);
|
||
|
|
HEAP8[($872)]=$867;
|
||
|
|
var $873=(($mix+2)|0);
|
||
|
|
var $874=HEAP8[($873)];
|
||
|
|
var $875=$x;
|
||
|
|
var $876=((($875)*(3))&-1);
|
||
|
|
var $877=((($876)+(2))|0);
|
||
|
|
var $878=$line;
|
||
|
|
var $879=(($878+$877)|0);
|
||
|
|
HEAP8[($879)]=$874;
|
||
|
|
var $880=$count;
|
||
|
|
var $881=((($880)-(1))|0);
|
||
|
|
$count=$881;
|
||
|
|
var $882=$x;
|
||
|
|
var $883=((($882)+(1))|0);
|
||
|
|
$x=$883;
|
||
|
|
var $884=(($mix)|0);
|
||
|
|
var $885=HEAP8[($884)];
|
||
|
|
var $886=$x;
|
||
|
|
var $887=((($886)*(3))&-1);
|
||
|
|
var $888=$line;
|
||
|
|
var $889=(($888+$887)|0);
|
||
|
|
HEAP8[($889)]=$885;
|
||
|
|
var $890=(($mix+1)|0);
|
||
|
|
var $891=HEAP8[($890)];
|
||
|
|
var $892=$x;
|
||
|
|
var $893=((($892)*(3))&-1);
|
||
|
|
var $894=((($893)+(1))|0);
|
||
|
|
var $895=$line;
|
||
|
|
var $896=(($895+$894)|0);
|
||
|
|
HEAP8[($896)]=$891;
|
||
|
|
var $897=(($mix+2)|0);
|
||
|
|
var $898=HEAP8[($897)];
|
||
|
|
var $899=$x;
|
||
|
|
var $900=((($899)*(3))&-1);
|
||
|
|
var $901=((($900)+(2))|0);
|
||
|
|
var $902=$line;
|
||
|
|
var $903=(($902+$901)|0);
|
||
|
|
HEAP8[($903)]=$898;
|
||
|
|
var $904=$count;
|
||
|
|
var $905=((($904)-(1))|0);
|
||
|
|
$count=$905;
|
||
|
|
var $906=$x;
|
||
|
|
var $907=((($906)+(1))|0);
|
||
|
|
$x=$907;
|
||
|
|
var $908=(($mix)|0);
|
||
|
|
var $909=HEAP8[($908)];
|
||
|
|
var $910=$x;
|
||
|
|
var $911=((($910)*(3))&-1);
|
||
|
|
var $912=$line;
|
||
|
|
var $913=(($912+$911)|0);
|
||
|
|
HEAP8[($913)]=$909;
|
||
|
|
var $914=(($mix+1)|0);
|
||
|
|
var $915=HEAP8[($914)];
|
||
|
|
var $916=$x;
|
||
|
|
var $917=((($916)*(3))&-1);
|
||
|
|
var $918=((($917)+(1))|0);
|
||
|
|
var $919=$line;
|
||
|
|
var $920=(($919+$918)|0);
|
||
|
|
HEAP8[($920)]=$915;
|
||
|
|
var $921=(($mix+2)|0);
|
||
|
|
var $922=HEAP8[($921)];
|
||
|
|
var $923=$x;
|
||
|
|
var $924=((($923)*(3))&-1);
|
||
|
|
var $925=((($924)+(2))|0);
|
||
|
|
var $926=$line;
|
||
|
|
var $927=(($926+$925)|0);
|
||
|
|
HEAP8[($927)]=$922;
|
||
|
|
var $928=$count;
|
||
|
|
var $929=((($928)-(1))|0);
|
||
|
|
$count=$929;
|
||
|
|
var $930=$x;
|
||
|
|
var $931=((($930)+(1))|0);
|
||
|
|
$x=$931;
|
||
|
|
var $932=(($mix)|0);
|
||
|
|
var $933=HEAP8[($932)];
|
||
|
|
var $934=$x;
|
||
|
|
var $935=((($934)*(3))&-1);
|
||
|
|
var $936=$line;
|
||
|
|
var $937=(($936+$935)|0);
|
||
|
|
HEAP8[($937)]=$933;
|
||
|
|
var $938=(($mix+1)|0);
|
||
|
|
var $939=HEAP8[($938)];
|
||
|
|
var $940=$x;
|
||
|
|
var $941=((($940)*(3))&-1);
|
||
|
|
var $942=((($941)+(1))|0);
|
||
|
|
var $943=$line;
|
||
|
|
var $944=(($943+$942)|0);
|
||
|
|
HEAP8[($944)]=$939;
|
||
|
|
var $945=(($mix+2)|0);
|
||
|
|
var $946=HEAP8[($945)];
|
||
|
|
var $947=$x;
|
||
|
|
var $948=((($947)*(3))&-1);
|
||
|
|
var $949=((($948)+(2))|0);
|
||
|
|
var $950=$line;
|
||
|
|
var $951=(($950+$949)|0);
|
||
|
|
HEAP8[($951)]=$946;
|
||
|
|
var $952=$count;
|
||
|
|
var $953=((($952)-(1))|0);
|
||
|
|
$count=$953;
|
||
|
|
var $954=$x;
|
||
|
|
var $955=((($954)+(1))|0);
|
||
|
|
$x=$955;
|
||
|
|
var $956=(($mix)|0);
|
||
|
|
var $957=HEAP8[($956)];
|
||
|
|
var $958=$x;
|
||
|
|
var $959=((($958)*(3))&-1);
|
||
|
|
var $960=$line;
|
||
|
|
var $961=(($960+$959)|0);
|
||
|
|
HEAP8[($961)]=$957;
|
||
|
|
var $962=(($mix+1)|0);
|
||
|
|
var $963=HEAP8[($962)];
|
||
|
|
var $964=$x;
|
||
|
|
var $965=((($964)*(3))&-1);
|
||
|
|
var $966=((($965)+(1))|0);
|
||
|
|
var $967=$line;
|
||
|
|
var $968=(($967+$966)|0);
|
||
|
|
HEAP8[($968)]=$963;
|
||
|
|
var $969=(($mix+2)|0);
|
||
|
|
var $970=HEAP8[($969)];
|
||
|
|
var $971=$x;
|
||
|
|
var $972=((($971)*(3))&-1);
|
||
|
|
var $973=((($972)+(2))|0);
|
||
|
|
var $974=$line;
|
||
|
|
var $975=(($974+$973)|0);
|
||
|
|
HEAP8[($975)]=$970;
|
||
|
|
var $976=$count;
|
||
|
|
var $977=((($976)-(1))|0);
|
||
|
|
$count=$977;
|
||
|
|
var $978=$x;
|
||
|
|
var $979=((($978)+(1))|0);
|
||
|
|
$x=$979;
|
||
|
|
var $980=(($mix)|0);
|
||
|
|
var $981=HEAP8[($980)];
|
||
|
|
var $982=$x;
|
||
|
|
var $983=((($982)*(3))&-1);
|
||
|
|
var $984=$line;
|
||
|
|
var $985=(($984+$983)|0);
|
||
|
|
HEAP8[($985)]=$981;
|
||
|
|
var $986=(($mix+1)|0);
|
||
|
|
var $987=HEAP8[($986)];
|
||
|
|
var $988=$x;
|
||
|
|
var $989=((($988)*(3))&-1);
|
||
|
|
var $990=((($989)+(1))|0);
|
||
|
|
var $991=$line;
|
||
|
|
var $992=(($991+$990)|0);
|
||
|
|
HEAP8[($992)]=$987;
|
||
|
|
var $993=(($mix+2)|0);
|
||
|
|
var $994=HEAP8[($993)];
|
||
|
|
var $995=$x;
|
||
|
|
var $996=((($995)*(3))&-1);
|
||
|
|
var $997=((($996)+(2))|0);
|
||
|
|
var $998=$line;
|
||
|
|
var $999=(($998+$997)|0);
|
||
|
|
HEAP8[($999)]=$994;
|
||
|
|
var $1000=$count;
|
||
|
|
var $1001=((($1000)-(1))|0);
|
||
|
|
$count=$1001;
|
||
|
|
var $1002=$x;
|
||
|
|
var $1003=((($1002)+(1))|0);
|
||
|
|
$x=$1003;
|
||
|
|
label=71;break;
|
||
|
|
case 75:
|
||
|
|
label=76;break;
|
||
|
|
case 76:
|
||
|
|
var $1006=$count;
|
||
|
|
var $1007=($1006|0)>0;
|
||
|
|
if($1007){label=77;break;}else{var $1013=0;label=78;break;}
|
||
|
|
case 77:
|
||
|
|
var $1009=$x;
|
||
|
|
var $1010=$3;
|
||
|
|
var $1011=($1009|0)<($1010|0);
|
||
|
|
var $1013=$1011;label=78;break;
|
||
|
|
case 78:
|
||
|
|
var $1013;
|
||
|
|
if($1013){label=79;break;}else{label=80;break;}
|
||
|
|
case 79:
|
||
|
|
var $1015=(($mix)|0);
|
||
|
|
var $1016=HEAP8[($1015)];
|
||
|
|
var $1017=$x;
|
||
|
|
var $1018=((($1017)*(3))&-1);
|
||
|
|
var $1019=$line;
|
||
|
|
var $1020=(($1019+$1018)|0);
|
||
|
|
HEAP8[($1020)]=$1016;
|
||
|
|
var $1021=(($mix+1)|0);
|
||
|
|
var $1022=HEAP8[($1021)];
|
||
|
|
var $1023=$x;
|
||
|
|
var $1024=((($1023)*(3))&-1);
|
||
|
|
var $1025=((($1024)+(1))|0);
|
||
|
|
var $1026=$line;
|
||
|
|
var $1027=(($1026+$1025)|0);
|
||
|
|
HEAP8[($1027)]=$1022;
|
||
|
|
var $1028=(($mix+2)|0);
|
||
|
|
var $1029=HEAP8[($1028)];
|
||
|
|
var $1030=$x;
|
||
|
|
var $1031=((($1030)*(3))&-1);
|
||
|
|
var $1032=((($1031)+(2))|0);
|
||
|
|
var $1033=$line;
|
||
|
|
var $1034=(($1033+$1032)|0);
|
||
|
|
HEAP8[($1034)]=$1029;
|
||
|
|
var $1035=$count;
|
||
|
|
var $1036=((($1035)-(1))|0);
|
||
|
|
$count=$1036;
|
||
|
|
var $1037=$x;
|
||
|
|
var $1038=((($1037)+(1))|0);
|
||
|
|
$x=$1038;
|
||
|
|
label=76;break;
|
||
|
|
case 80:
|
||
|
|
label=92;break;
|
||
|
|
case 81:
|
||
|
|
label=82;break;
|
||
|
|
case 82:
|
||
|
|
var $1042=$count;
|
||
|
|
var $1043=$1042&-8;
|
||
|
|
var $1044=($1043|0)!=0;
|
||
|
|
if($1044){label=83;break;}else{var $1051=0;label=84;break;}
|
||
|
|
case 83:
|
||
|
|
var $1046=$x;
|
||
|
|
var $1047=((($1046)+(8))|0);
|
||
|
|
var $1048=$3;
|
||
|
|
var $1049=($1047|0)<($1048|0);
|
||
|
|
var $1051=$1049;label=84;break;
|
||
|
|
case 84:
|
||
|
|
var $1051;
|
||
|
|
if($1051){label=85;break;}else{label=86;break;}
|
||
|
|
case 85:
|
||
|
|
var $1053=$x;
|
||
|
|
var $1054=((($1053)*(3))&-1);
|
||
|
|
var $1055=$prevline;
|
||
|
|
var $1056=(($1055+$1054)|0);
|
||
|
|
var $1057=HEAP8[($1056)];
|
||
|
|
var $1058=($1057&255);
|
||
|
|
var $1059=(($mix)|0);
|
||
|
|
var $1060=HEAP8[($1059)];
|
||
|
|
var $1061=($1060&255);
|
||
|
|
var $1062=$1058^$1061;
|
||
|
|
var $1063=(($1062)&255);
|
||
|
|
var $1064=$x;
|
||
|
|
var $1065=((($1064)*(3))&-1);
|
||
|
|
var $1066=$line;
|
||
|
|
var $1067=(($1066+$1065)|0);
|
||
|
|
HEAP8[($1067)]=$1063;
|
||
|
|
var $1068=$x;
|
||
|
|
var $1069=((($1068)*(3))&-1);
|
||
|
|
var $1070=((($1069)+(1))|0);
|
||
|
|
var $1071=$prevline;
|
||
|
|
var $1072=(($1071+$1070)|0);
|
||
|
|
var $1073=HEAP8[($1072)];
|
||
|
|
var $1074=($1073&255);
|
||
|
|
var $1075=(($mix+1)|0);
|
||
|
|
var $1076=HEAP8[($1075)];
|
||
|
|
var $1077=($1076&255);
|
||
|
|
var $1078=$1074^$1077;
|
||
|
|
var $1079=(($1078)&255);
|
||
|
|
var $1080=$x;
|
||
|
|
var $1081=((($1080)*(3))&-1);
|
||
|
|
var $1082=((($1081)+(1))|0);
|
||
|
|
var $1083=$line;
|
||
|
|
var $1084=(($1083+$1082)|0);
|
||
|
|
HEAP8[($1084)]=$1079;
|
||
|
|
var $1085=$x;
|
||
|
|
var $1086=((($1085)*(3))&-1);
|
||
|
|
var $1087=((($1086)+(2))|0);
|
||
|
|
var $1088=$prevline;
|
||
|
|
var $1089=(($1088+$1087)|0);
|
||
|
|
var $1090=HEAP8[($1089)];
|
||
|
|
var $1091=($1090&255);
|
||
|
|
var $1092=(($mix+2)|0);
|
||
|
|
var $1093=HEAP8[($1092)];
|
||
|
|
var $1094=($1093&255);
|
||
|
|
var $1095=$1091^$1094;
|
||
|
|
var $1096=(($1095)&255);
|
||
|
|
var $1097=$x;
|
||
|
|
var $1098=((($1097)*(3))&-1);
|
||
|
|
var $1099=((($1098)+(2))|0);
|
||
|
|
var $1100=$line;
|
||
|
|
var $1101=(($1100+$1099)|0);
|
||
|
|
HEAP8[($1101)]=$1096;
|
||
|
|
var $1102=$count;
|
||
|
|
var $1103=((($1102)-(1))|0);
|
||
|
|
$count=$1103;
|
||
|
|
var $1104=$x;
|
||
|
|
var $1105=((($1104)+(1))|0);
|
||
|
|
$x=$1105;
|
||
|
|
var $1106=$x;
|
||
|
|
var $1107=((($1106)*(3))&-1);
|
||
|
|
var $1108=$prevline;
|
||
|
|
var $1109=(($1108+$1107)|0);
|
||
|
|
var $1110=HEAP8[($1109)];
|
||
|
|
var $1111=($1110&255);
|
||
|
|
var $1112=(($mix)|0);
|
||
|
|
var $1113=HEAP8[($1112)];
|
||
|
|
var $1114=($1113&255);
|
||
|
|
var $1115=$1111^$1114;
|
||
|
|
var $1116=(($1115)&255);
|
||
|
|
var $1117=$x;
|
||
|
|
var $1118=((($1117)*(3))&-1);
|
||
|
|
var $1119=$line;
|
||
|
|
var $1120=(($1119+$1118)|0);
|
||
|
|
HEAP8[($1120)]=$1116;
|
||
|
|
var $1121=$x;
|
||
|
|
var $1122=((($1121)*(3))&-1);
|
||
|
|
var $1123=((($1122)+(1))|0);
|
||
|
|
var $1124=$prevline;
|
||
|
|
var $1125=(($1124+$1123)|0);
|
||
|
|
var $1126=HEAP8[($1125)];
|
||
|
|
var $1127=($1126&255);
|
||
|
|
var $1128=(($mix+1)|0);
|
||
|
|
var $1129=HEAP8[($1128)];
|
||
|
|
var $1130=($1129&255);
|
||
|
|
var $1131=$1127^$1130;
|
||
|
|
var $1132=(($1131)&255);
|
||
|
|
var $1133=$x;
|
||
|
|
var $1134=((($1133)*(3))&-1);
|
||
|
|
var $1135=((($1134)+(1))|0);
|
||
|
|
var $1136=$line;
|
||
|
|
var $1137=(($1136+$1135)|0);
|
||
|
|
HEAP8[($1137)]=$1132;
|
||
|
|
var $1138=$x;
|
||
|
|
var $1139=((($1138)*(3))&-1);
|
||
|
|
var $1140=((($1139)+(2))|0);
|
||
|
|
var $1141=$prevline;
|
||
|
|
var $1142=(($1141+$1140)|0);
|
||
|
|
var $1143=HEAP8[($1142)];
|
||
|
|
var $1144=($1143&255);
|
||
|
|
var $1145=(($mix+2)|0);
|
||
|
|
var $1146=HEAP8[($1145)];
|
||
|
|
var $1147=($1146&255);
|
||
|
|
var $1148=$1144^$1147;
|
||
|
|
var $1149=(($1148)&255);
|
||
|
|
var $1150=$x;
|
||
|
|
var $1151=((($1150)*(3))&-1);
|
||
|
|
var $1152=((($1151)+(2))|0);
|
||
|
|
var $1153=$line;
|
||
|
|
var $1154=(($1153+$1152)|0);
|
||
|
|
HEAP8[($1154)]=$1149;
|
||
|
|
var $1155=$count;
|
||
|
|
var $1156=((($1155)-(1))|0);
|
||
|
|
$count=$1156;
|
||
|
|
var $1157=$x;
|
||
|
|
var $1158=((($1157)+(1))|0);
|
||
|
|
$x=$1158;
|
||
|
|
var $1159=$x;
|
||
|
|
var $1160=((($1159)*(3))&-1);
|
||
|
|
var $1161=$prevline;
|
||
|
|
var $1162=(($1161+$1160)|0);
|
||
|
|
var $1163=HEAP8[($1162)];
|
||
|
|
var $1164=($1163&255);
|
||
|
|
var $1165=(($mix)|0);
|
||
|
|
var $1166=HEAP8[($1165)];
|
||
|
|
var $1167=($1166&255);
|
||
|
|
var $1168=$1164^$1167;
|
||
|
|
var $1169=(($1168)&255);
|
||
|
|
var $1170=$x;
|
||
|
|
var $1171=((($1170)*(3))&-1);
|
||
|
|
var $1172=$line;
|
||
|
|
var $1173=(($1172+$1171)|0);
|
||
|
|
HEAP8[($1173)]=$1169;
|
||
|
|
var $1174=$x;
|
||
|
|
var $1175=((($1174)*(3))&-1);
|
||
|
|
var $1176=((($1175)+(1))|0);
|
||
|
|
var $1177=$prevline;
|
||
|
|
var $1178=(($1177+$1176)|0);
|
||
|
|
var $1179=HEAP8[($1178)];
|
||
|
|
var $1180=($1179&255);
|
||
|
|
var $1181=(($mix+1)|0);
|
||
|
|
var $1182=HEAP8[($1181)];
|
||
|
|
var $1183=($1182&255);
|
||
|
|
var $1184=$1180^$1183;
|
||
|
|
var $1185=(($1184)&255);
|
||
|
|
var $1186=$x;
|
||
|
|
var $1187=((($1186)*(3))&-1);
|
||
|
|
var $1188=((($1187)+(1))|0);
|
||
|
|
var $1189=$line;
|
||
|
|
var $1190=(($1189+$1188)|0);
|
||
|
|
HEAP8[($1190)]=$1185;
|
||
|
|
var $1191=$x;
|
||
|
|
var $1192=((($1191)*(3))&-1);
|
||
|
|
var $1193=((($1192)+(2))|0);
|
||
|
|
var $1194=$prevline;
|
||
|
|
var $1195=(($1194+$1193)|0);
|
||
|
|
var $1196=HEAP8[($1195)];
|
||
|
|
var $1197=($1196&255);
|
||
|
|
var $1198=(($mix+2)|0);
|
||
|
|
var $1199=HEAP8[($1198)];
|
||
|
|
var $1200=($1199&255);
|
||
|
|
var $1201=$1197^$1200;
|
||
|
|
var $1202=(($1201)&255);
|
||
|
|
var $1203=$x;
|
||
|
|
var $1204=((($1203)*(3))&-1);
|
||
|
|
var $1205=((($1204)+(2))|0);
|
||
|
|
var $1206=$line;
|
||
|
|
var $1207=(($1206+$1205)|0);
|
||
|
|
HEAP8[($1207)]=$1202;
|
||
|
|
var $1208=$count;
|
||
|
|
var $1209=((($1208)-(1))|0);
|
||
|
|
$count=$1209;
|
||
|
|
var $1210=$x;
|
||
|
|
var $1211=((($1210)+(1))|0);
|
||
|
|
$x=$1211;
|
||
|
|
var $1212=$x;
|
||
|
|
var $1213=((($1212)*(3))&-1);
|
||
|
|
var $1214=$prevline;
|
||
|
|
var $1215=(($1214+$1213)|0);
|
||
|
|
var $1216=HEAP8[($1215)];
|
||
|
|
var $1217=($1216&255);
|
||
|
|
var $1218=(($mix)|0);
|
||
|
|
var $1219=HEAP8[($1218)];
|
||
|
|
var $1220=($1219&255);
|
||
|
|
var $1221=$1217^$1220;
|
||
|
|
var $1222=(($1221)&255);
|
||
|
|
var $1223=$x;
|
||
|
|
var $1224=((($1223)*(3))&-1);
|
||
|
|
var $1225=$line;
|
||
|
|
var $1226=(($1225+$1224)|0);
|
||
|
|
HEAP8[($1226)]=$1222;
|
||
|
|
var $1227=$x;
|
||
|
|
var $1228=((($1227)*(3))&-1);
|
||
|
|
var $1229=((($1228)+(1))|0);
|
||
|
|
var $1230=$prevline;
|
||
|
|
var $1231=(($1230+$1229)|0);
|
||
|
|
var $1232=HEAP8[($1231)];
|
||
|
|
var $1233=($1232&255);
|
||
|
|
var $1234=(($mix+1)|0);
|
||
|
|
var $1235=HEAP8[($1234)];
|
||
|
|
var $1236=($1235&255);
|
||
|
|
var $1237=$1233^$1236;
|
||
|
|
var $1238=(($1237)&255);
|
||
|
|
var $1239=$x;
|
||
|
|
var $1240=((($1239)*(3))&-1);
|
||
|
|
var $1241=((($1240)+(1))|0);
|
||
|
|
var $1242=$line;
|
||
|
|
var $1243=(($1242+$1241)|0);
|
||
|
|
HEAP8[($1243)]=$1238;
|
||
|
|
var $1244=$x;
|
||
|
|
var $1245=((($1244)*(3))&-1);
|
||
|
|
var $1246=((($1245)+(2))|0);
|
||
|
|
var $1247=$prevline;
|
||
|
|
var $1248=(($1247+$1246)|0);
|
||
|
|
var $1249=HEAP8[($1248)];
|
||
|
|
var $1250=($1249&255);
|
||
|
|
var $1251=(($mix+2)|0);
|
||
|
|
var $1252=HEAP8[($1251)];
|
||
|
|
var $1253=($1252&255);
|
||
|
|
var $1254=$1250^$1253;
|
||
|
|
var $1255=(($1254)&255);
|
||
|
|
var $1256=$x;
|
||
|
|
var $1257=((($1256)*(3))&-1);
|
||
|
|
var $1258=((($1257)+(2))|0);
|
||
|
|
var $1259=$line;
|
||
|
|
var $1260=(($1259+$1258)|0);
|
||
|
|
HEAP8[($1260)]=$1255;
|
||
|
|
var $1261=$count;
|
||
|
|
var $1262=((($1261)-(1))|0);
|
||
|
|
$count=$1262;
|
||
|
|
var $1263=$x;
|
||
|
|
var $1264=((($1263)+(1))|0);
|
||
|
|
$x=$1264;
|
||
|
|
var $1265=$x;
|
||
|
|
var $1266=((($1265)*(3))&-1);
|
||
|
|
var $1267=$prevline;
|
||
|
|
var $1268=(($1267+$1266)|0);
|
||
|
|
var $1269=HEAP8[($1268)];
|
||
|
|
var $1270=($1269&255);
|
||
|
|
var $1271=(($mix)|0);
|
||
|
|
var $1272=HEAP8[($1271)];
|
||
|
|
var $1273=($1272&255);
|
||
|
|
var $1274=$1270^$1273;
|
||
|
|
var $1275=(($1274)&255);
|
||
|
|
var $1276=$x;
|
||
|
|
var $1277=((($1276)*(3))&-1);
|
||
|
|
var $1278=$line;
|
||
|
|
var $1279=(($1278+$1277)|0);
|
||
|
|
HEAP8[($1279)]=$1275;
|
||
|
|
var $1280=$x;
|
||
|
|
var $1281=((($1280)*(3))&-1);
|
||
|
|
var $1282=((($1281)+(1))|0);
|
||
|
|
var $1283=$prevline;
|
||
|
|
var $1284=(($1283+$1282)|0);
|
||
|
|
var $1285=HEAP8[($1284)];
|
||
|
|
var $1286=($1285&255);
|
||
|
|
var $1287=(($mix+1)|0);
|
||
|
|
var $1288=HEAP8[($1287)];
|
||
|
|
var $1289=($1288&255);
|
||
|
|
var $1290=$1286^$1289;
|
||
|
|
var $1291=(($1290)&255);
|
||
|
|
var $1292=$x;
|
||
|
|
var $1293=((($1292)*(3))&-1);
|
||
|
|
var $1294=((($1293)+(1))|0);
|
||
|
|
var $1295=$line;
|
||
|
|
var $1296=(($1295+$1294)|0);
|
||
|
|
HEAP8[($1296)]=$1291;
|
||
|
|
var $1297=$x;
|
||
|
|
var $1298=((($1297)*(3))&-1);
|
||
|
|
var $1299=((($1298)+(2))|0);
|
||
|
|
var $1300=$prevline;
|
||
|
|
var $1301=(($1300+$1299)|0);
|
||
|
|
var $1302=HEAP8[($1301)];
|
||
|
|
var $1303=($1302&255);
|
||
|
|
var $1304=(($mix+2)|0);
|
||
|
|
var $1305=HEAP8[($1304)];
|
||
|
|
var $1306=($1305&255);
|
||
|
|
var $1307=$1303^$1306;
|
||
|
|
var $1308=(($1307)&255);
|
||
|
|
var $1309=$x;
|
||
|
|
var $1310=((($1309)*(3))&-1);
|
||
|
|
var $1311=((($1310)+(2))|0);
|
||
|
|
var $1312=$line;
|
||
|
|
var $1313=(($1312+$1311)|0);
|
||
|
|
HEAP8[($1313)]=$1308;
|
||
|
|
var $1314=$count;
|
||
|
|
var $1315=((($1314)-(1))|0);
|
||
|
|
$count=$1315;
|
||
|
|
var $1316=$x;
|
||
|
|
var $1317=((($1316)+(1))|0);
|
||
|
|
$x=$1317;
|
||
|
|
var $1318=$x;
|
||
|
|
var $1319=((($1318)*(3))&-1);
|
||
|
|
var $1320=$prevline;
|
||
|
|
var $1321=(($1320+$1319)|0);
|
||
|
|
var $1322=HEAP8[($1321)];
|
||
|
|
var $1323=($1322&255);
|
||
|
|
var $1324=(($mix)|0);
|
||
|
|
var $1325=HEAP8[($1324)];
|
||
|
|
var $1326=($1325&255);
|
||
|
|
var $1327=$1323^$1326;
|
||
|
|
var $1328=(($1327)&255);
|
||
|
|
var $1329=$x;
|
||
|
|
var $1330=((($1329)*(3))&-1);
|
||
|
|
var $1331=$line;
|
||
|
|
var $1332=(($1331+$1330)|0);
|
||
|
|
HEAP8[($1332)]=$1328;
|
||
|
|
var $1333=$x;
|
||
|
|
var $1334=((($1333)*(3))&-1);
|
||
|
|
var $1335=((($1334)+(1))|0);
|
||
|
|
var $1336=$prevline;
|
||
|
|
var $1337=(($1336+$1335)|0);
|
||
|
|
var $1338=HEAP8[($1337)];
|
||
|
|
var $1339=($1338&255);
|
||
|
|
var $1340=(($mix+1)|0);
|
||
|
|
var $1341=HEAP8[($1340)];
|
||
|
|
var $1342=($1341&255);
|
||
|
|
var $1343=$1339^$1342;
|
||
|
|
var $1344=(($1343)&255);
|
||
|
|
var $1345=$x;
|
||
|
|
var $1346=((($1345)*(3))&-1);
|
||
|
|
var $1347=((($1346)+(1))|0);
|
||
|
|
var $1348=$line;
|
||
|
|
var $1349=(($1348+$1347)|0);
|
||
|
|
HEAP8[($1349)]=$1344;
|
||
|
|
var $1350=$x;
|
||
|
|
var $1351=((($1350)*(3))&-1);
|
||
|
|
var $1352=((($1351)+(2))|0);
|
||
|
|
var $1353=$prevline;
|
||
|
|
var $1354=(($1353+$1352)|0);
|
||
|
|
var $1355=HEAP8[($1354)];
|
||
|
|
var $1356=($1355&255);
|
||
|
|
var $1357=(($mix+2)|0);
|
||
|
|
var $1358=HEAP8[($1357)];
|
||
|
|
var $1359=($1358&255);
|
||
|
|
var $1360=$1356^$1359;
|
||
|
|
var $1361=(($1360)&255);
|
||
|
|
var $1362=$x;
|
||
|
|
var $1363=((($1362)*(3))&-1);
|
||
|
|
var $1364=((($1363)+(2))|0);
|
||
|
|
var $1365=$line;
|
||
|
|
var $1366=(($1365+$1364)|0);
|
||
|
|
HEAP8[($1366)]=$1361;
|
||
|
|
var $1367=$count;
|
||
|
|
var $1368=((($1367)-(1))|0);
|
||
|
|
$count=$1368;
|
||
|
|
var $1369=$x;
|
||
|
|
var $1370=((($1369)+(1))|0);
|
||
|
|
$x=$1370;
|
||
|
|
var $1371=$x;
|
||
|
|
var $1372=((($1371)*(3))&-1);
|
||
|
|
var $1373=$prevline;
|
||
|
|
var $1374=(($1373+$1372)|0);
|
||
|
|
var $1375=HEAP8[($1374)];
|
||
|
|
var $1376=($1375&255);
|
||
|
|
var $1377=(($mix)|0);
|
||
|
|
var $1378=HEAP8[($1377)];
|
||
|
|
var $1379=($1378&255);
|
||
|
|
var $1380=$1376^$1379;
|
||
|
|
var $1381=(($1380)&255);
|
||
|
|
var $1382=$x;
|
||
|
|
var $1383=((($1382)*(3))&-1);
|
||
|
|
var $1384=$line;
|
||
|
|
var $1385=(($1384+$1383)|0);
|
||
|
|
HEAP8[($1385)]=$1381;
|
||
|
|
var $1386=$x;
|
||
|
|
var $1387=((($1386)*(3))&-1);
|
||
|
|
var $1388=((($1387)+(1))|0);
|
||
|
|
var $1389=$prevline;
|
||
|
|
var $1390=(($1389+$1388)|0);
|
||
|
|
var $1391=HEAP8[($1390)];
|
||
|
|
var $1392=($1391&255);
|
||
|
|
var $1393=(($mix+1)|0);
|
||
|
|
var $1394=HEAP8[($1393)];
|
||
|
|
var $1395=($1394&255);
|
||
|
|
var $1396=$1392^$1395;
|
||
|
|
var $1397=(($1396)&255);
|
||
|
|
var $1398=$x;
|
||
|
|
var $1399=((($1398)*(3))&-1);
|
||
|
|
var $1400=((($1399)+(1))|0);
|
||
|
|
var $1401=$line;
|
||
|
|
var $1402=(($1401+$1400)|0);
|
||
|
|
HEAP8[($1402)]=$1397;
|
||
|
|
var $1403=$x;
|
||
|
|
var $1404=((($1403)*(3))&-1);
|
||
|
|
var $1405=((($1404)+(2))|0);
|
||
|
|
var $1406=$prevline;
|
||
|
|
var $1407=(($1406+$1405)|0);
|
||
|
|
var $1408=HEAP8[($1407)];
|
||
|
|
var $1409=($1408&255);
|
||
|
|
var $1410=(($mix+2)|0);
|
||
|
|
var $1411=HEAP8[($1410)];
|
||
|
|
var $1412=($1411&255);
|
||
|
|
var $1413=$1409^$1412;
|
||
|
|
var $1414=(($1413)&255);
|
||
|
|
var $1415=$x;
|
||
|
|
var $1416=((($1415)*(3))&-1);
|
||
|
|
var $1417=((($1416)+(2))|0);
|
||
|
|
var $1418=$line;
|
||
|
|
var $1419=(($1418+$1417)|0);
|
||
|
|
HEAP8[($1419)]=$1414;
|
||
|
|
var $1420=$count;
|
||
|
|
var $1421=((($1420)-(1))|0);
|
||
|
|
$count=$1421;
|
||
|
|
var $1422=$x;
|
||
|
|
var $1423=((($1422)+(1))|0);
|
||
|
|
$x=$1423;
|
||
|
|
var $1424=$x;
|
||
|
|
var $1425=((($1424)*(3))&-1);
|
||
|
|
var $1426=$prevline;
|
||
|
|
var $1427=(($1426+$1425)|0);
|
||
|
|
var $1428=HEAP8[($1427)];
|
||
|
|
var $1429=($1428&255);
|
||
|
|
var $1430=(($mix)|0);
|
||
|
|
var $1431=HEAP8[($1430)];
|
||
|
|
var $1432=($1431&255);
|
||
|
|
var $1433=$1429^$1432;
|
||
|
|
var $1434=(($1433)&255);
|
||
|
|
var $1435=$x;
|
||
|
|
var $1436=((($1435)*(3))&-1);
|
||
|
|
var $1437=$line;
|
||
|
|
var $1438=(($1437+$1436)|0);
|
||
|
|
HEAP8[($1438)]=$1434;
|
||
|
|
var $1439=$x;
|
||
|
|
var $1440=((($1439)*(3))&-1);
|
||
|
|
var $1441=((($1440)+(1))|0);
|
||
|
|
var $1442=$prevline;
|
||
|
|
var $1443=(($1442+$1441)|0);
|
||
|
|
var $1444=HEAP8[($1443)];
|
||
|
|
var $1445=($1444&255);
|
||
|
|
var $1446=(($mix+1)|0);
|
||
|
|
var $1447=HEAP8[($1446)];
|
||
|
|
var $1448=($1447&255);
|
||
|
|
var $1449=$1445^$1448;
|
||
|
|
var $1450=(($1449)&255);
|
||
|
|
var $1451=$x;
|
||
|
|
var $1452=((($1451)*(3))&-1);
|
||
|
|
var $1453=((($1452)+(1))|0);
|
||
|
|
var $1454=$line;
|
||
|
|
var $1455=(($1454+$1453)|0);
|
||
|
|
HEAP8[($1455)]=$1450;
|
||
|
|
var $1456=$x;
|
||
|
|
var $1457=((($1456)*(3))&-1);
|
||
|
|
var $1458=((($1457)+(2))|0);
|
||
|
|
var $1459=$prevline;
|
||
|
|
var $1460=(($1459+$1458)|0);
|
||
|
|
var $1461=HEAP8[($1460)];
|
||
|
|
var $1462=($1461&255);
|
||
|
|
var $1463=(($mix+2)|0);
|
||
|
|
var $1464=HEAP8[($1463)];
|
||
|
|
var $1465=($1464&255);
|
||
|
|
var $1466=$1462^$1465;
|
||
|
|
var $1467=(($1466)&255);
|
||
|
|
var $1468=$x;
|
||
|
|
var $1469=((($1468)*(3))&-1);
|
||
|
|
var $1470=((($1469)+(2))|0);
|
||
|
|
var $1471=$line;
|
||
|
|
var $1472=(($1471+$1470)|0);
|
||
|
|
HEAP8[($1472)]=$1467;
|
||
|
|
var $1473=$count;
|
||
|
|
var $1474=((($1473)-(1))|0);
|
||
|
|
$count=$1474;
|
||
|
|
var $1475=$x;
|
||
|
|
var $1476=((($1475)+(1))|0);
|
||
|
|
$x=$1476;
|
||
|
|
label=82;break;
|
||
|
|
case 86:
|
||
|
|
label=87;break;
|
||
|
|
case 87:
|
||
|
|
var $1479=$count;
|
||
|
|
var $1480=($1479|0)>0;
|
||
|
|
if($1480){label=88;break;}else{var $1486=0;label=89;break;}
|
||
|
|
case 88:
|
||
|
|
var $1482=$x;
|
||
|
|
var $1483=$3;
|
||
|
|
var $1484=($1482|0)<($1483|0);
|
||
|
|
var $1486=$1484;label=89;break;
|
||
|
|
case 89:
|
||
|
|
var $1486;
|
||
|
|
if($1486){label=90;break;}else{label=91;break;}
|
||
|
|
case 90:
|
||
|
|
var $1488=$x;
|
||
|
|
var $1489=((($1488)*(3))&-1);
|
||
|
|
var $1490=$prevline;
|
||
|
|
var $1491=(($1490+$1489)|0);
|
||
|
|
var $1492=HEAP8[($1491)];
|
||
|
|
var $1493=($1492&255);
|
||
|
|
var $1494=(($mix)|0);
|
||
|
|
var $1495=HEAP8[($1494)];
|
||
|
|
var $1496=($1495&255);
|
||
|
|
var $1497=$1493^$1496;
|
||
|
|
var $1498=(($1497)&255);
|
||
|
|
var $1499=$x;
|
||
|
|
var $1500=((($1499)*(3))&-1);
|
||
|
|
var $1501=$line;
|
||
|
|
var $1502=(($1501+$1500)|0);
|
||
|
|
HEAP8[($1502)]=$1498;
|
||
|
|
var $1503=$x;
|
||
|
|
var $1504=((($1503)*(3))&-1);
|
||
|
|
var $1505=((($1504)+(1))|0);
|
||
|
|
var $1506=$prevline;
|
||
|
|
var $1507=(($1506+$1505)|0);
|
||
|
|
var $1508=HEAP8[($1507)];
|
||
|
|
var $1509=($1508&255);
|
||
|
|
var $1510=(($mix+1)|0);
|
||
|
|
var $1511=HEAP8[($1510)];
|
||
|
|
var $1512=($1511&255);
|
||
|
|
var $1513=$1509^$1512;
|
||
|
|
var $1514=(($1513)&255);
|
||
|
|
var $1515=$x;
|
||
|
|
var $1516=((($1515)*(3))&-1);
|
||
|
|
var $1517=((($1516)+(1))|0);
|
||
|
|
var $1518=$line;
|
||
|
|
var $1519=(($1518+$1517)|0);
|
||
|
|
HEAP8[($1519)]=$1514;
|
||
|
|
var $1520=$x;
|
||
|
|
var $1521=((($1520)*(3))&-1);
|
||
|
|
var $1522=((($1521)+(2))|0);
|
||
|
|
var $1523=$prevline;
|
||
|
|
var $1524=(($1523+$1522)|0);
|
||
|
|
var $1525=HEAP8[($1524)];
|
||
|
|
var $1526=($1525&255);
|
||
|
|
var $1527=(($mix+2)|0);
|
||
|
|
var $1528=HEAP8[($1527)];
|
||
|
|
var $1529=($1528&255);
|
||
|
|
var $1530=$1526^$1529;
|
||
|
|
var $1531=(($1530)&255);
|
||
|
|
var $1532=$x;
|
||
|
|
var $1533=((($1532)*(3))&-1);
|
||
|
|
var $1534=((($1533)+(2))|0);
|
||
|
|
var $1535=$line;
|
||
|
|
var $1536=(($1535+$1534)|0);
|
||
|
|
HEAP8[($1536)]=$1531;
|
||
|
|
var $1537=$count;
|
||
|
|
var $1538=((($1537)-(1))|0);
|
||
|
|
$count=$1538;
|
||
|
|
var $1539=$x;
|
||
|
|
var $1540=((($1539)+(1))|0);
|
||
|
|
$x=$1540;
|
||
|
|
label=87;break;
|
||
|
|
case 91:
|
||
|
|
label=92;break;
|
||
|
|
case 92:
|
||
|
|
label=344;break;
|
||
|
|
case 93:
|
||
|
|
var $1544=$prevline;
|
||
|
|
var $1545=($1544|0)==0;
|
||
|
|
if($1545){label=94;break;}else{label=177;break;}
|
||
|
|
case 94:
|
||
|
|
label=95;break;
|
||
|
|
case 95:
|
||
|
|
var $1548=$count;
|
||
|
|
var $1549=$1548&-8;
|
||
|
|
var $1550=($1549|0)!=0;
|
||
|
|
if($1550){label=96;break;}else{var $1557=0;label=97;break;}
|
||
|
|
case 96:
|
||
|
|
var $1552=$x;
|
||
|
|
var $1553=((($1552)+(8))|0);
|
||
|
|
var $1554=$3;
|
||
|
|
var $1555=($1553|0)<($1554|0);
|
||
|
|
var $1557=$1555;label=97;break;
|
||
|
|
case 97:
|
||
|
|
var $1557;
|
||
|
|
if($1557){label=98;break;}else{label=163;break;}
|
||
|
|
case 98:
|
||
|
|
var $1559=$mixmask;
|
||
|
|
var $1560=($1559&255);
|
||
|
|
var $1561=$1560<<1;
|
||
|
|
var $1562=(($1561)&255);
|
||
|
|
$mixmask=$1562;
|
||
|
|
var $1563=$mixmask;
|
||
|
|
var $1564=($1563&255);
|
||
|
|
var $1565=($1564|0)==0;
|
||
|
|
if($1565){label=99;break;}else{label=103;break;}
|
||
|
|
case 99:
|
||
|
|
var $1567=$fom_mask;
|
||
|
|
var $1568=($1567|0)!=0;
|
||
|
|
if($1568){label=100;break;}else{label=101;break;}
|
||
|
|
case 100:
|
||
|
|
var $1570=$fom_mask;
|
||
|
|
var $1577=$1570;label=102;break;
|
||
|
|
case 101:
|
||
|
|
var $1572=$5;
|
||
|
|
var $1573=(($1572+1)|0);
|
||
|
|
$5=$1573;
|
||
|
|
var $1574=HEAP8[($1572)];
|
||
|
|
var $1575=($1574&255);
|
||
|
|
var $1577=$1575;label=102;break;
|
||
|
|
case 102:
|
||
|
|
var $1577;
|
||
|
|
var $1578=(($1577)&255);
|
||
|
|
$mask=$1578;
|
||
|
|
$mixmask=1;
|
||
|
|
label=103;break;
|
||
|
|
case 103:
|
||
|
|
var $1580=$mask;
|
||
|
|
var $1581=($1580&255);
|
||
|
|
var $1582=$mixmask;
|
||
|
|
var $1583=($1582&255);
|
||
|
|
var $1584=$1581&$1583;
|
||
|
|
var $1585=($1584|0)!=0;
|
||
|
|
if($1585){label=104;break;}else{label=105;break;}
|
||
|
|
case 104:
|
||
|
|
var $1587=(($mix)|0);
|
||
|
|
var $1588=HEAP8[($1587)];
|
||
|
|
var $1589=$x;
|
||
|
|
var $1590=((($1589)*(3))&-1);
|
||
|
|
var $1591=$line;
|
||
|
|
var $1592=(($1591+$1590)|0);
|
||
|
|
HEAP8[($1592)]=$1588;
|
||
|
|
var $1593=(($mix+1)|0);
|
||
|
|
var $1594=HEAP8[($1593)];
|
||
|
|
var $1595=$x;
|
||
|
|
var $1596=((($1595)*(3))&-1);
|
||
|
|
var $1597=((($1596)+(1))|0);
|
||
|
|
var $1598=$line;
|
||
|
|
var $1599=(($1598+$1597)|0);
|
||
|
|
HEAP8[($1599)]=$1594;
|
||
|
|
var $1600=(($mix+2)|0);
|
||
|
|
var $1601=HEAP8[($1600)];
|
||
|
|
var $1602=$x;
|
||
|
|
var $1603=((($1602)*(3))&-1);
|
||
|
|
var $1604=((($1603)+(2))|0);
|
||
|
|
var $1605=$line;
|
||
|
|
var $1606=(($1605+$1604)|0);
|
||
|
|
HEAP8[($1606)]=$1601;
|
||
|
|
label=106;break;
|
||
|
|
case 105:
|
||
|
|
var $1608=$x;
|
||
|
|
var $1609=((($1608)*(3))&-1);
|
||
|
|
var $1610=$line;
|
||
|
|
var $1611=(($1610+$1609)|0);
|
||
|
|
HEAP8[($1611)]=0;
|
||
|
|
var $1612=$x;
|
||
|
|
var $1613=((($1612)*(3))&-1);
|
||
|
|
var $1614=((($1613)+(1))|0);
|
||
|
|
var $1615=$line;
|
||
|
|
var $1616=(($1615+$1614)|0);
|
||
|
|
HEAP8[($1616)]=0;
|
||
|
|
var $1617=$x;
|
||
|
|
var $1618=((($1617)*(3))&-1);
|
||
|
|
var $1619=((($1618)+(2))|0);
|
||
|
|
var $1620=$line;
|
||
|
|
var $1621=(($1620+$1619)|0);
|
||
|
|
HEAP8[($1621)]=0;
|
||
|
|
label=106;break;
|
||
|
|
case 106:
|
||
|
|
var $1623=$count;
|
||
|
|
var $1624=((($1623)-(1))|0);
|
||
|
|
$count=$1624;
|
||
|
|
var $1625=$x;
|
||
|
|
var $1626=((($1625)+(1))|0);
|
||
|
|
$x=$1626;
|
||
|
|
var $1627=$mixmask;
|
||
|
|
var $1628=($1627&255);
|
||
|
|
var $1629=$1628<<1;
|
||
|
|
var $1630=(($1629)&255);
|
||
|
|
$mixmask=$1630;
|
||
|
|
var $1631=$mixmask;
|
||
|
|
var $1632=($1631&255);
|
||
|
|
var $1633=($1632|0)==0;
|
||
|
|
if($1633){label=107;break;}else{label=111;break;}
|
||
|
|
case 107:
|
||
|
|
var $1635=$fom_mask;
|
||
|
|
var $1636=($1635|0)!=0;
|
||
|
|
if($1636){label=108;break;}else{label=109;break;}
|
||
|
|
case 108:
|
||
|
|
var $1638=$fom_mask;
|
||
|
|
var $1645=$1638;label=110;break;
|
||
|
|
case 109:
|
||
|
|
var $1640=$5;
|
||
|
|
var $1641=(($1640+1)|0);
|
||
|
|
$5=$1641;
|
||
|
|
var $1642=HEAP8[($1640)];
|
||
|
|
var $1643=($1642&255);
|
||
|
|
var $1645=$1643;label=110;break;
|
||
|
|
case 110:
|
||
|
|
var $1645;
|
||
|
|
var $1646=(($1645)&255);
|
||
|
|
$mask=$1646;
|
||
|
|
$mixmask=1;
|
||
|
|
label=111;break;
|
||
|
|
case 111:
|
||
|
|
var $1648=$mask;
|
||
|
|
var $1649=($1648&255);
|
||
|
|
var $1650=$mixmask;
|
||
|
|
var $1651=($1650&255);
|
||
|
|
var $1652=$1649&$1651;
|
||
|
|
var $1653=($1652|0)!=0;
|
||
|
|
if($1653){label=112;break;}else{label=113;break;}
|
||
|
|
case 112:
|
||
|
|
var $1655=(($mix)|0);
|
||
|
|
var $1656=HEAP8[($1655)];
|
||
|
|
var $1657=$x;
|
||
|
|
var $1658=((($1657)*(3))&-1);
|
||
|
|
var $1659=$line;
|
||
|
|
var $1660=(($1659+$1658)|0);
|
||
|
|
HEAP8[($1660)]=$1656;
|
||
|
|
var $1661=(($mix+1)|0);
|
||
|
|
var $1662=HEAP8[($1661)];
|
||
|
|
var $1663=$x;
|
||
|
|
var $1664=((($1663)*(3))&-1);
|
||
|
|
var $1665=((($1664)+(1))|0);
|
||
|
|
var $1666=$line;
|
||
|
|
var $1667=(($1666+$1665)|0);
|
||
|
|
HEAP8[($1667)]=$1662;
|
||
|
|
var $1668=(($mix+2)|0);
|
||
|
|
var $1669=HEAP8[($1668)];
|
||
|
|
var $1670=$x;
|
||
|
|
var $1671=((($1670)*(3))&-1);
|
||
|
|
var $1672=((($1671)+(2))|0);
|
||
|
|
var $1673=$line;
|
||
|
|
var $1674=(($1673+$1672)|0);
|
||
|
|
HEAP8[($1674)]=$1669;
|
||
|
|
label=114;break;
|
||
|
|
case 113:
|
||
|
|
var $1676=$x;
|
||
|
|
var $1677=((($1676)*(3))&-1);
|
||
|
|
var $1678=$line;
|
||
|
|
var $1679=(($1678+$1677)|0);
|
||
|
|
HEAP8[($1679)]=0;
|
||
|
|
var $1680=$x;
|
||
|
|
var $1681=((($1680)*(3))&-1);
|
||
|
|
var $1682=((($1681)+(1))|0);
|
||
|
|
var $1683=$line;
|
||
|
|
var $1684=(($1683+$1682)|0);
|
||
|
|
HEAP8[($1684)]=0;
|
||
|
|
var $1685=$x;
|
||
|
|
var $1686=((($1685)*(3))&-1);
|
||
|
|
var $1687=((($1686)+(2))|0);
|
||
|
|
var $1688=$line;
|
||
|
|
var $1689=(($1688+$1687)|0);
|
||
|
|
HEAP8[($1689)]=0;
|
||
|
|
label=114;break;
|
||
|
|
case 114:
|
||
|
|
var $1691=$count;
|
||
|
|
var $1692=((($1691)-(1))|0);
|
||
|
|
$count=$1692;
|
||
|
|
var $1693=$x;
|
||
|
|
var $1694=((($1693)+(1))|0);
|
||
|
|
$x=$1694;
|
||
|
|
var $1695=$mixmask;
|
||
|
|
var $1696=($1695&255);
|
||
|
|
var $1697=$1696<<1;
|
||
|
|
var $1698=(($1697)&255);
|
||
|
|
$mixmask=$1698;
|
||
|
|
var $1699=$mixmask;
|
||
|
|
var $1700=($1699&255);
|
||
|
|
var $1701=($1700|0)==0;
|
||
|
|
if($1701){label=115;break;}else{label=119;break;}
|
||
|
|
case 115:
|
||
|
|
var $1703=$fom_mask;
|
||
|
|
var $1704=($1703|0)!=0;
|
||
|
|
if($1704){label=116;break;}else{label=117;break;}
|
||
|
|
case 116:
|
||
|
|
var $1706=$fom_mask;
|
||
|
|
var $1713=$1706;label=118;break;
|
||
|
|
case 117:
|
||
|
|
var $1708=$5;
|
||
|
|
var $1709=(($1708+1)|0);
|
||
|
|
$5=$1709;
|
||
|
|
var $1710=HEAP8[($1708)];
|
||
|
|
var $1711=($1710&255);
|
||
|
|
var $1713=$1711;label=118;break;
|
||
|
|
case 118:
|
||
|
|
var $1713;
|
||
|
|
var $1714=(($1713)&255);
|
||
|
|
$mask=$1714;
|
||
|
|
$mixmask=1;
|
||
|
|
label=119;break;
|
||
|
|
case 119:
|
||
|
|
var $1716=$mask;
|
||
|
|
var $1717=($1716&255);
|
||
|
|
var $1718=$mixmask;
|
||
|
|
var $1719=($1718&255);
|
||
|
|
var $1720=$1717&$1719;
|
||
|
|
var $1721=($1720|0)!=0;
|
||
|
|
if($1721){label=120;break;}else{label=121;break;}
|
||
|
|
case 120:
|
||
|
|
var $1723=(($mix)|0);
|
||
|
|
var $1724=HEAP8[($1723)];
|
||
|
|
var $1725=$x;
|
||
|
|
var $1726=((($1725)*(3))&-1);
|
||
|
|
var $1727=$line;
|
||
|
|
var $1728=(($1727+$1726)|0);
|
||
|
|
HEAP8[($1728)]=$1724;
|
||
|
|
var $1729=(($mix+1)|0);
|
||
|
|
var $1730=HEAP8[($1729)];
|
||
|
|
var $1731=$x;
|
||
|
|
var $1732=((($1731)*(3))&-1);
|
||
|
|
var $1733=((($1732)+(1))|0);
|
||
|
|
var $1734=$line;
|
||
|
|
var $1735=(($1734+$1733)|0);
|
||
|
|
HEAP8[($1735)]=$1730;
|
||
|
|
var $1736=(($mix+2)|0);
|
||
|
|
var $1737=HEAP8[($1736)];
|
||
|
|
var $1738=$x;
|
||
|
|
var $1739=((($1738)*(3))&-1);
|
||
|
|
var $1740=((($1739)+(2))|0);
|
||
|
|
var $1741=$line;
|
||
|
|
var $1742=(($1741+$1740)|0);
|
||
|
|
HEAP8[($1742)]=$1737;
|
||
|
|
label=122;break;
|
||
|
|
case 121:
|
||
|
|
var $1744=$x;
|
||
|
|
var $1745=((($1744)*(3))&-1);
|
||
|
|
var $1746=$line;
|
||
|
|
var $1747=(($1746+$1745)|0);
|
||
|
|
HEAP8[($1747)]=0;
|
||
|
|
var $1748=$x;
|
||
|
|
var $1749=((($1748)*(3))&-1);
|
||
|
|
var $1750=((($1749)+(1))|0);
|
||
|
|
var $1751=$line;
|
||
|
|
var $1752=(($1751+$1750)|0);
|
||
|
|
HEAP8[($1752)]=0;
|
||
|
|
var $1753=$x;
|
||
|
|
var $1754=((($1753)*(3))&-1);
|
||
|
|
var $1755=((($1754)+(2))|0);
|
||
|
|
var $1756=$line;
|
||
|
|
var $1757=(($1756+$1755)|0);
|
||
|
|
HEAP8[($1757)]=0;
|
||
|
|
label=122;break;
|
||
|
|
case 122:
|
||
|
|
var $1759=$count;
|
||
|
|
var $1760=((($1759)-(1))|0);
|
||
|
|
$count=$1760;
|
||
|
|
var $1761=$x;
|
||
|
|
var $1762=((($1761)+(1))|0);
|
||
|
|
$x=$1762;
|
||
|
|
var $1763=$mixmask;
|
||
|
|
var $1764=($1763&255);
|
||
|
|
var $1765=$1764<<1;
|
||
|
|
var $1766=(($1765)&255);
|
||
|
|
$mixmask=$1766;
|
||
|
|
var $1767=$mixmask;
|
||
|
|
var $1768=($1767&255);
|
||
|
|
var $1769=($1768|0)==0;
|
||
|
|
if($1769){label=123;break;}else{label=127;break;}
|
||
|
|
case 123:
|
||
|
|
var $1771=$fom_mask;
|
||
|
|
var $1772=($1771|0)!=0;
|
||
|
|
if($1772){label=124;break;}else{label=125;break;}
|
||
|
|
case 124:
|
||
|
|
var $1774=$fom_mask;
|
||
|
|
var $1781=$1774;label=126;break;
|
||
|
|
case 125:
|
||
|
|
var $1776=$5;
|
||
|
|
var $1777=(($1776+1)|0);
|
||
|
|
$5=$1777;
|
||
|
|
var $1778=HEAP8[($1776)];
|
||
|
|
var $1779=($1778&255);
|
||
|
|
var $1781=$1779;label=126;break;
|
||
|
|
case 126:
|
||
|
|
var $1781;
|
||
|
|
var $1782=(($1781)&255);
|
||
|
|
$mask=$1782;
|
||
|
|
$mixmask=1;
|
||
|
|
label=127;break;
|
||
|
|
case 127:
|
||
|
|
var $1784=$mask;
|
||
|
|
var $1785=($1784&255);
|
||
|
|
var $1786=$mixmask;
|
||
|
|
var $1787=($1786&255);
|
||
|
|
var $1788=$1785&$1787;
|
||
|
|
var $1789=($1788|0)!=0;
|
||
|
|
if($1789){label=128;break;}else{label=129;break;}
|
||
|
|
case 128:
|
||
|
|
var $1791=(($mix)|0);
|
||
|
|
var $1792=HEAP8[($1791)];
|
||
|
|
var $1793=$x;
|
||
|
|
var $1794=((($1793)*(3))&-1);
|
||
|
|
var $1795=$line;
|
||
|
|
var $1796=(($1795+$1794)|0);
|
||
|
|
HEAP8[($1796)]=$1792;
|
||
|
|
var $1797=(($mix+1)|0);
|
||
|
|
var $1798=HEAP8[($1797)];
|
||
|
|
var $1799=$x;
|
||
|
|
var $1800=((($1799)*(3))&-1);
|
||
|
|
var $1801=((($1800)+(1))|0);
|
||
|
|
var $1802=$line;
|
||
|
|
var $1803=(($1802+$1801)|0);
|
||
|
|
HEAP8[($1803)]=$1798;
|
||
|
|
var $1804=(($mix+2)|0);
|
||
|
|
var $1805=HEAP8[($1804)];
|
||
|
|
var $1806=$x;
|
||
|
|
var $1807=((($1806)*(3))&-1);
|
||
|
|
var $1808=((($1807)+(2))|0);
|
||
|
|
var $1809=$line;
|
||
|
|
var $1810=(($1809+$1808)|0);
|
||
|
|
HEAP8[($1810)]=$1805;
|
||
|
|
label=130;break;
|
||
|
|
case 129:
|
||
|
|
var $1812=$x;
|
||
|
|
var $1813=((($1812)*(3))&-1);
|
||
|
|
var $1814=$line;
|
||
|
|
var $1815=(($1814+$1813)|0);
|
||
|
|
HEAP8[($1815)]=0;
|
||
|
|
var $1816=$x;
|
||
|
|
var $1817=((($1816)*(3))&-1);
|
||
|
|
var $1818=((($1817)+(1))|0);
|
||
|
|
var $1819=$line;
|
||
|
|
var $1820=(($1819+$1818)|0);
|
||
|
|
HEAP8[($1820)]=0;
|
||
|
|
var $1821=$x;
|
||
|
|
var $1822=((($1821)*(3))&-1);
|
||
|
|
var $1823=((($1822)+(2))|0);
|
||
|
|
var $1824=$line;
|
||
|
|
var $1825=(($1824+$1823)|0);
|
||
|
|
HEAP8[($1825)]=0;
|
||
|
|
label=130;break;
|
||
|
|
case 130:
|
||
|
|
var $1827=$count;
|
||
|
|
var $1828=((($1827)-(1))|0);
|
||
|
|
$count=$1828;
|
||
|
|
var $1829=$x;
|
||
|
|
var $1830=((($1829)+(1))|0);
|
||
|
|
$x=$1830;
|
||
|
|
var $1831=$mixmask;
|
||
|
|
var $1832=($1831&255);
|
||
|
|
var $1833=$1832<<1;
|
||
|
|
var $1834=(($1833)&255);
|
||
|
|
$mixmask=$1834;
|
||
|
|
var $1835=$mixmask;
|
||
|
|
var $1836=($1835&255);
|
||
|
|
var $1837=($1836|0)==0;
|
||
|
|
if($1837){label=131;break;}else{label=135;break;}
|
||
|
|
case 131:
|
||
|
|
var $1839=$fom_mask;
|
||
|
|
var $1840=($1839|0)!=0;
|
||
|
|
if($1840){label=132;break;}else{label=133;break;}
|
||
|
|
case 132:
|
||
|
|
var $1842=$fom_mask;
|
||
|
|
var $1849=$1842;label=134;break;
|
||
|
|
case 133:
|
||
|
|
var $1844=$5;
|
||
|
|
var $1845=(($1844+1)|0);
|
||
|
|
$5=$1845;
|
||
|
|
var $1846=HEAP8[($1844)];
|
||
|
|
var $1847=($1846&255);
|
||
|
|
var $1849=$1847;label=134;break;
|
||
|
|
case 134:
|
||
|
|
var $1849;
|
||
|
|
var $1850=(($1849)&255);
|
||
|
|
$mask=$1850;
|
||
|
|
$mixmask=1;
|
||
|
|
label=135;break;
|
||
|
|
case 135:
|
||
|
|
var $1852=$mask;
|
||
|
|
var $1853=($1852&255);
|
||
|
|
var $1854=$mixmask;
|
||
|
|
var $1855=($1854&255);
|
||
|
|
var $1856=$1853&$1855;
|
||
|
|
var $1857=($1856|0)!=0;
|
||
|
|
if($1857){label=136;break;}else{label=137;break;}
|
||
|
|
case 136:
|
||
|
|
var $1859=(($mix)|0);
|
||
|
|
var $1860=HEAP8[($1859)];
|
||
|
|
var $1861=$x;
|
||
|
|
var $1862=((($1861)*(3))&-1);
|
||
|
|
var $1863=$line;
|
||
|
|
var $1864=(($1863+$1862)|0);
|
||
|
|
HEAP8[($1864)]=$1860;
|
||
|
|
var $1865=(($mix+1)|0);
|
||
|
|
var $1866=HEAP8[($1865)];
|
||
|
|
var $1867=$x;
|
||
|
|
var $1868=((($1867)*(3))&-1);
|
||
|
|
var $1869=((($1868)+(1))|0);
|
||
|
|
var $1870=$line;
|
||
|
|
var $1871=(($1870+$1869)|0);
|
||
|
|
HEAP8[($1871)]=$1866;
|
||
|
|
var $1872=(($mix+2)|0);
|
||
|
|
var $1873=HEAP8[($1872)];
|
||
|
|
var $1874=$x;
|
||
|
|
var $1875=((($1874)*(3))&-1);
|
||
|
|
var $1876=((($1875)+(2))|0);
|
||
|
|
var $1877=$line;
|
||
|
|
var $1878=(($1877+$1876)|0);
|
||
|
|
HEAP8[($1878)]=$1873;
|
||
|
|
label=138;break;
|
||
|
|
case 137:
|
||
|
|
var $1880=$x;
|
||
|
|
var $1881=((($1880)*(3))&-1);
|
||
|
|
var $1882=$line;
|
||
|
|
var $1883=(($1882+$1881)|0);
|
||
|
|
HEAP8[($1883)]=0;
|
||
|
|
var $1884=$x;
|
||
|
|
var $1885=((($1884)*(3))&-1);
|
||
|
|
var $1886=((($1885)+(1))|0);
|
||
|
|
var $1887=$line;
|
||
|
|
var $1888=(($1887+$1886)|0);
|
||
|
|
HEAP8[($1888)]=0;
|
||
|
|
var $1889=$x;
|
||
|
|
var $1890=((($1889)*(3))&-1);
|
||
|
|
var $1891=((($1890)+(2))|0);
|
||
|
|
var $1892=$line;
|
||
|
|
var $1893=(($1892+$1891)|0);
|
||
|
|
HEAP8[($1893)]=0;
|
||
|
|
label=138;break;
|
||
|
|
case 138:
|
||
|
|
var $1895=$count;
|
||
|
|
var $1896=((($1895)-(1))|0);
|
||
|
|
$count=$1896;
|
||
|
|
var $1897=$x;
|
||
|
|
var $1898=((($1897)+(1))|0);
|
||
|
|
$x=$1898;
|
||
|
|
var $1899=$mixmask;
|
||
|
|
var $1900=($1899&255);
|
||
|
|
var $1901=$1900<<1;
|
||
|
|
var $1902=(($1901)&255);
|
||
|
|
$mixmask=$1902;
|
||
|
|
var $1903=$mixmask;
|
||
|
|
var $1904=($1903&255);
|
||
|
|
var $1905=($1904|0)==0;
|
||
|
|
if($1905){label=139;break;}else{label=143;break;}
|
||
|
|
case 139:
|
||
|
|
var $1907=$fom_mask;
|
||
|
|
var $1908=($1907|0)!=0;
|
||
|
|
if($1908){label=140;break;}else{label=141;break;}
|
||
|
|
case 140:
|
||
|
|
var $1910=$fom_mask;
|
||
|
|
var $1917=$1910;label=142;break;
|
||
|
|
case 141:
|
||
|
|
var $1912=$5;
|
||
|
|
var $1913=(($1912+1)|0);
|
||
|
|
$5=$1913;
|
||
|
|
var $1914=HEAP8[($1912)];
|
||
|
|
var $1915=($1914&255);
|
||
|
|
var $1917=$1915;label=142;break;
|
||
|
|
case 142:
|
||
|
|
var $1917;
|
||
|
|
var $1918=(($1917)&255);
|
||
|
|
$mask=$1918;
|
||
|
|
$mixmask=1;
|
||
|
|
label=143;break;
|
||
|
|
case 143:
|
||
|
|
var $1920=$mask;
|
||
|
|
var $1921=($1920&255);
|
||
|
|
var $1922=$mixmask;
|
||
|
|
var $1923=($1922&255);
|
||
|
|
var $1924=$1921&$1923;
|
||
|
|
var $1925=($1924|0)!=0;
|
||
|
|
if($1925){label=144;break;}else{label=145;break;}
|
||
|
|
case 144:
|
||
|
|
var $1927=(($mix)|0);
|
||
|
|
var $1928=HEAP8[($1927)];
|
||
|
|
var $1929=$x;
|
||
|
|
var $1930=((($1929)*(3))&-1);
|
||
|
|
var $1931=$line;
|
||
|
|
var $1932=(($1931+$1930)|0);
|
||
|
|
HEAP8[($1932)]=$1928;
|
||
|
|
var $1933=(($mix+1)|0);
|
||
|
|
var $1934=HEAP8[($1933)];
|
||
|
|
var $1935=$x;
|
||
|
|
var $1936=((($1935)*(3))&-1);
|
||
|
|
var $1937=((($1936)+(1))|0);
|
||
|
|
var $1938=$line;
|
||
|
|
var $1939=(($1938+$1937)|0);
|
||
|
|
HEAP8[($1939)]=$1934;
|
||
|
|
var $1940=(($mix+2)|0);
|
||
|
|
var $1941=HEAP8[($1940)];
|
||
|
|
var $1942=$x;
|
||
|
|
var $1943=((($1942)*(3))&-1);
|
||
|
|
var $1944=((($1943)+(2))|0);
|
||
|
|
var $1945=$line;
|
||
|
|
var $1946=(($1945+$1944)|0);
|
||
|
|
HEAP8[($1946)]=$1941;
|
||
|
|
label=146;break;
|
||
|
|
case 145:
|
||
|
|
var $1948=$x;
|
||
|
|
var $1949=((($1948)*(3))&-1);
|
||
|
|
var $1950=$line;
|
||
|
|
var $1951=(($1950+$1949)|0);
|
||
|
|
HEAP8[($1951)]=0;
|
||
|
|
var $1952=$x;
|
||
|
|
var $1953=((($1952)*(3))&-1);
|
||
|
|
var $1954=((($1953)+(1))|0);
|
||
|
|
var $1955=$line;
|
||
|
|
var $1956=(($1955+$1954)|0);
|
||
|
|
HEAP8[($1956)]=0;
|
||
|
|
var $1957=$x;
|
||
|
|
var $1958=((($1957)*(3))&-1);
|
||
|
|
var $1959=((($1958)+(2))|0);
|
||
|
|
var $1960=$line;
|
||
|
|
var $1961=(($1960+$1959)|0);
|
||
|
|
HEAP8[($1961)]=0;
|
||
|
|
label=146;break;
|
||
|
|
case 146:
|
||
|
|
var $1963=$count;
|
||
|
|
var $1964=((($1963)-(1))|0);
|
||
|
|
$count=$1964;
|
||
|
|
var $1965=$x;
|
||
|
|
var $1966=((($1965)+(1))|0);
|
||
|
|
$x=$1966;
|
||
|
|
var $1967=$mixmask;
|
||
|
|
var $1968=($1967&255);
|
||
|
|
var $1969=$1968<<1;
|
||
|
|
var $1970=(($1969)&255);
|
||
|
|
$mixmask=$1970;
|
||
|
|
var $1971=$mixmask;
|
||
|
|
var $1972=($1971&255);
|
||
|
|
var $1973=($1972|0)==0;
|
||
|
|
if($1973){label=147;break;}else{label=151;break;}
|
||
|
|
case 147:
|
||
|
|
var $1975=$fom_mask;
|
||
|
|
var $1976=($1975|0)!=0;
|
||
|
|
if($1976){label=148;break;}else{label=149;break;}
|
||
|
|
case 148:
|
||
|
|
var $1978=$fom_mask;
|
||
|
|
var $1985=$1978;label=150;break;
|
||
|
|
case 149:
|
||
|
|
var $1980=$5;
|
||
|
|
var $1981=(($1980+1)|0);
|
||
|
|
$5=$1981;
|
||
|
|
var $1982=HEAP8[($1980)];
|
||
|
|
var $1983=($1982&255);
|
||
|
|
var $1985=$1983;label=150;break;
|
||
|
|
case 150:
|
||
|
|
var $1985;
|
||
|
|
var $1986=(($1985)&255);
|
||
|
|
$mask=$1986;
|
||
|
|
$mixmask=1;
|
||
|
|
label=151;break;
|
||
|
|
case 151:
|
||
|
|
var $1988=$mask;
|
||
|
|
var $1989=($1988&255);
|
||
|
|
var $1990=$mixmask;
|
||
|
|
var $1991=($1990&255);
|
||
|
|
var $1992=$1989&$1991;
|
||
|
|
var $1993=($1992|0)!=0;
|
||
|
|
if($1993){label=152;break;}else{label=153;break;}
|
||
|
|
case 152:
|
||
|
|
var $1995=(($mix)|0);
|
||
|
|
var $1996=HEAP8[($1995)];
|
||
|
|
var $1997=$x;
|
||
|
|
var $1998=((($1997)*(3))&-1);
|
||
|
|
var $1999=$line;
|
||
|
|
var $2000=(($1999+$1998)|0);
|
||
|
|
HEAP8[($2000)]=$1996;
|
||
|
|
var $2001=(($mix+1)|0);
|
||
|
|
var $2002=HEAP8[($2001)];
|
||
|
|
var $2003=$x;
|
||
|
|
var $2004=((($2003)*(3))&-1);
|
||
|
|
var $2005=((($2004)+(1))|0);
|
||
|
|
var $2006=$line;
|
||
|
|
var $2007=(($2006+$2005)|0);
|
||
|
|
HEAP8[($2007)]=$2002;
|
||
|
|
var $2008=(($mix+2)|0);
|
||
|
|
var $2009=HEAP8[($2008)];
|
||
|
|
var $2010=$x;
|
||
|
|
var $2011=((($2010)*(3))&-1);
|
||
|
|
var $2012=((($2011)+(2))|0);
|
||
|
|
var $2013=$line;
|
||
|
|
var $2014=(($2013+$2012)|0);
|
||
|
|
HEAP8[($2014)]=$2009;
|
||
|
|
label=154;break;
|
||
|
|
case 153:
|
||
|
|
var $2016=$x;
|
||
|
|
var $2017=((($2016)*(3))&-1);
|
||
|
|
var $2018=$line;
|
||
|
|
var $2019=(($2018+$2017)|0);
|
||
|
|
HEAP8[($2019)]=0;
|
||
|
|
var $2020=$x;
|
||
|
|
var $2021=((($2020)*(3))&-1);
|
||
|
|
var $2022=((($2021)+(1))|0);
|
||
|
|
var $2023=$line;
|
||
|
|
var $2024=(($2023+$2022)|0);
|
||
|
|
HEAP8[($2024)]=0;
|
||
|
|
var $2025=$x;
|
||
|
|
var $2026=((($2025)*(3))&-1);
|
||
|
|
var $2027=((($2026)+(2))|0);
|
||
|
|
var $2028=$line;
|
||
|
|
var $2029=(($2028+$2027)|0);
|
||
|
|
HEAP8[($2029)]=0;
|
||
|
|
label=154;break;
|
||
|
|
case 154:
|
||
|
|
var $2031=$count;
|
||
|
|
var $2032=((($2031)-(1))|0);
|
||
|
|
$count=$2032;
|
||
|
|
var $2033=$x;
|
||
|
|
var $2034=((($2033)+(1))|0);
|
||
|
|
$x=$2034;
|
||
|
|
var $2035=$mixmask;
|
||
|
|
var $2036=($2035&255);
|
||
|
|
var $2037=$2036<<1;
|
||
|
|
var $2038=(($2037)&255);
|
||
|
|
$mixmask=$2038;
|
||
|
|
var $2039=$mixmask;
|
||
|
|
var $2040=($2039&255);
|
||
|
|
var $2041=($2040|0)==0;
|
||
|
|
if($2041){label=155;break;}else{label=159;break;}
|
||
|
|
case 155:
|
||
|
|
var $2043=$fom_mask;
|
||
|
|
var $2044=($2043|0)!=0;
|
||
|
|
if($2044){label=156;break;}else{label=157;break;}
|
||
|
|
case 156:
|
||
|
|
var $2046=$fom_mask;
|
||
|
|
var $2053=$2046;label=158;break;
|
||
|
|
case 157:
|
||
|
|
var $2048=$5;
|
||
|
|
var $2049=(($2048+1)|0);
|
||
|
|
$5=$2049;
|
||
|
|
var $2050=HEAP8[($2048)];
|
||
|
|
var $2051=($2050&255);
|
||
|
|
var $2053=$2051;label=158;break;
|
||
|
|
case 158:
|
||
|
|
var $2053;
|
||
|
|
var $2054=(($2053)&255);
|
||
|
|
$mask=$2054;
|
||
|
|
$mixmask=1;
|
||
|
|
label=159;break;
|
||
|
|
case 159:
|
||
|
|
var $2056=$mask;
|
||
|
|
var $2057=($2056&255);
|
||
|
|
var $2058=$mixmask;
|
||
|
|
var $2059=($2058&255);
|
||
|
|
var $2060=$2057&$2059;
|
||
|
|
var $2061=($2060|0)!=0;
|
||
|
|
if($2061){label=160;break;}else{label=161;break;}
|
||
|
|
case 160:
|
||
|
|
var $2063=(($mix)|0);
|
||
|
|
var $2064=HEAP8[($2063)];
|
||
|
|
var $2065=$x;
|
||
|
|
var $2066=((($2065)*(3))&-1);
|
||
|
|
var $2067=$line;
|
||
|
|
var $2068=(($2067+$2066)|0);
|
||
|
|
HEAP8[($2068)]=$2064;
|
||
|
|
var $2069=(($mix+1)|0);
|
||
|
|
var $2070=HEAP8[($2069)];
|
||
|
|
var $2071=$x;
|
||
|
|
var $2072=((($2071)*(3))&-1);
|
||
|
|
var $2073=((($2072)+(1))|0);
|
||
|
|
var $2074=$line;
|
||
|
|
var $2075=(($2074+$2073)|0);
|
||
|
|
HEAP8[($2075)]=$2070;
|
||
|
|
var $2076=(($mix+2)|0);
|
||
|
|
var $2077=HEAP8[($2076)];
|
||
|
|
var $2078=$x;
|
||
|
|
var $2079=((($2078)*(3))&-1);
|
||
|
|
var $2080=((($2079)+(2))|0);
|
||
|
|
var $2081=$line;
|
||
|
|
var $2082=(($2081+$2080)|0);
|
||
|
|
HEAP8[($2082)]=$2077;
|
||
|
|
label=162;break;
|
||
|
|
case 161:
|
||
|
|
var $2084=$x;
|
||
|
|
var $2085=((($2084)*(3))&-1);
|
||
|
|
var $2086=$line;
|
||
|
|
var $2087=(($2086+$2085)|0);
|
||
|
|
HEAP8[($2087)]=0;
|
||
|
|
var $2088=$x;
|
||
|
|
var $2089=((($2088)*(3))&-1);
|
||
|
|
var $2090=((($2089)+(1))|0);
|
||
|
|
var $2091=$line;
|
||
|
|
var $2092=(($2091+$2090)|0);
|
||
|
|
HEAP8[($2092)]=0;
|
||
|
|
var $2093=$x;
|
||
|
|
var $2094=((($2093)*(3))&-1);
|
||
|
|
var $2095=((($2094)+(2))|0);
|
||
|
|
var $2096=$line;
|
||
|
|
var $2097=(($2096+$2095)|0);
|
||
|
|
HEAP8[($2097)]=0;
|
||
|
|
label=162;break;
|
||
|
|
case 162:
|
||
|
|
var $2099=$count;
|
||
|
|
var $2100=((($2099)-(1))|0);
|
||
|
|
$count=$2100;
|
||
|
|
var $2101=$x;
|
||
|
|
var $2102=((($2101)+(1))|0);
|
||
|
|
$x=$2102;
|
||
|
|
label=95;break;
|
||
|
|
case 163:
|
||
|
|
label=164;break;
|
||
|
|
case 164:
|
||
|
|
var $2105=$count;
|
||
|
|
var $2106=($2105|0)>0;
|
||
|
|
if($2106){label=165;break;}else{var $2112=0;label=166;break;}
|
||
|
|
case 165:
|
||
|
|
var $2108=$x;
|
||
|
|
var $2109=$3;
|
||
|
|
var $2110=($2108|0)<($2109|0);
|
||
|
|
var $2112=$2110;label=166;break;
|
||
|
|
case 166:
|
||
|
|
var $2112;
|
||
|
|
if($2112){label=167;break;}else{label=176;break;}
|
||
|
|
case 167:
|
||
|
|
var $2114=$mixmask;
|
||
|
|
var $2115=($2114&255);
|
||
|
|
var $2116=$2115<<1;
|
||
|
|
var $2117=(($2116)&255);
|
||
|
|
$mixmask=$2117;
|
||
|
|
var $2118=$mixmask;
|
||
|
|
var $2119=($2118&255);
|
||
|
|
var $2120=($2119|0)==0;
|
||
|
|
if($2120){label=168;break;}else{label=172;break;}
|
||
|
|
case 168:
|
||
|
|
var $2122=$fom_mask;
|
||
|
|
var $2123=($2122|0)!=0;
|
||
|
|
if($2123){label=169;break;}else{label=170;break;}
|
||
|
|
case 169:
|
||
|
|
var $2125=$fom_mask;
|
||
|
|
var $2132=$2125;label=171;break;
|
||
|
|
case 170:
|
||
|
|
var $2127=$5;
|
||
|
|
var $2128=(($2127+1)|0);
|
||
|
|
$5=$2128;
|
||
|
|
var $2129=HEAP8[($2127)];
|
||
|
|
var $2130=($2129&255);
|
||
|
|
var $2132=$2130;label=171;break;
|
||
|
|
case 171:
|
||
|
|
var $2132;
|
||
|
|
var $2133=(($2132)&255);
|
||
|
|
$mask=$2133;
|
||
|
|
$mixmask=1;
|
||
|
|
label=172;break;
|
||
|
|
case 172:
|
||
|
|
var $2135=$mask;
|
||
|
|
var $2136=($2135&255);
|
||
|
|
var $2137=$mixmask;
|
||
|
|
var $2138=($2137&255);
|
||
|
|
var $2139=$2136&$2138;
|
||
|
|
var $2140=($2139|0)!=0;
|
||
|
|
if($2140){label=173;break;}else{label=174;break;}
|
||
|
|
case 173:
|
||
|
|
var $2142=(($mix)|0);
|
||
|
|
var $2143=HEAP8[($2142)];
|
||
|
|
var $2144=$x;
|
||
|
|
var $2145=((($2144)*(3))&-1);
|
||
|
|
var $2146=$line;
|
||
|
|
var $2147=(($2146+$2145)|0);
|
||
|
|
HEAP8[($2147)]=$2143;
|
||
|
|
var $2148=(($mix+1)|0);
|
||
|
|
var $2149=HEAP8[($2148)];
|
||
|
|
var $2150=$x;
|
||
|
|
var $2151=((($2150)*(3))&-1);
|
||
|
|
var $2152=((($2151)+(1))|0);
|
||
|
|
var $2153=$line;
|
||
|
|
var $2154=(($2153+$2152)|0);
|
||
|
|
HEAP8[($2154)]=$2149;
|
||
|
|
var $2155=(($mix+2)|0);
|
||
|
|
var $2156=HEAP8[($2155)];
|
||
|
|
var $2157=$x;
|
||
|
|
var $2158=((($2157)*(3))&-1);
|
||
|
|
var $2159=((($2158)+(2))|0);
|
||
|
|
var $2160=$line;
|
||
|
|
var $2161=(($2160+$2159)|0);
|
||
|
|
HEAP8[($2161)]=$2156;
|
||
|
|
label=175;break;
|
||
|
|
case 174:
|
||
|
|
var $2163=$x;
|
||
|
|
var $2164=((($2163)*(3))&-1);
|
||
|
|
var $2165=$line;
|
||
|
|
var $2166=(($2165+$2164)|0);
|
||
|
|
HEAP8[($2166)]=0;
|
||
|
|
var $2167=$x;
|
||
|
|
var $2168=((($2167)*(3))&-1);
|
||
|
|
var $2169=((($2168)+(1))|0);
|
||
|
|
var $2170=$line;
|
||
|
|
var $2171=(($2170+$2169)|0);
|
||
|
|
HEAP8[($2171)]=0;
|
||
|
|
var $2172=$x;
|
||
|
|
var $2173=((($2172)*(3))&-1);
|
||
|
|
var $2174=((($2173)+(2))|0);
|
||
|
|
var $2175=$line;
|
||
|
|
var $2176=(($2175+$2174)|0);
|
||
|
|
HEAP8[($2176)]=0;
|
||
|
|
label=175;break;
|
||
|
|
case 175:
|
||
|
|
var $2178=$count;
|
||
|
|
var $2179=((($2178)-(1))|0);
|
||
|
|
$count=$2179;
|
||
|
|
var $2180=$x;
|
||
|
|
var $2181=((($2180)+(1))|0);
|
||
|
|
$x=$2181;
|
||
|
|
label=164;break;
|
||
|
|
case 176:
|
||
|
|
label=260;break;
|
||
|
|
case 177:
|
||
|
|
label=178;break;
|
||
|
|
case 178:
|
||
|
|
var $2185=$count;
|
||
|
|
var $2186=$2185&-8;
|
||
|
|
var $2187=($2186|0)!=0;
|
||
|
|
if($2187){label=179;break;}else{var $2194=0;label=180;break;}
|
||
|
|
case 179:
|
||
|
|
var $2189=$x;
|
||
|
|
var $2190=((($2189)+(8))|0);
|
||
|
|
var $2191=$3;
|
||
|
|
var $2192=($2190|0)<($2191|0);
|
||
|
|
var $2194=$2192;label=180;break;
|
||
|
|
case 180:
|
||
|
|
var $2194;
|
||
|
|
if($2194){label=181;break;}else{label=246;break;}
|
||
|
|
case 181:
|
||
|
|
var $2196=$mixmask;
|
||
|
|
var $2197=($2196&255);
|
||
|
|
var $2198=$2197<<1;
|
||
|
|
var $2199=(($2198)&255);
|
||
|
|
$mixmask=$2199;
|
||
|
|
var $2200=$mixmask;
|
||
|
|
var $2201=($2200&255);
|
||
|
|
var $2202=($2201|0)==0;
|
||
|
|
if($2202){label=182;break;}else{label=186;break;}
|
||
|
|
case 182:
|
||
|
|
var $2204=$fom_mask;
|
||
|
|
var $2205=($2204|0)!=0;
|
||
|
|
if($2205){label=183;break;}else{label=184;break;}
|
||
|
|
case 183:
|
||
|
|
var $2207=$fom_mask;
|
||
|
|
var $2214=$2207;label=185;break;
|
||
|
|
case 184:
|
||
|
|
var $2209=$5;
|
||
|
|
var $2210=(($2209+1)|0);
|
||
|
|
$5=$2210;
|
||
|
|
var $2211=HEAP8[($2209)];
|
||
|
|
var $2212=($2211&255);
|
||
|
|
var $2214=$2212;label=185;break;
|
||
|
|
case 185:
|
||
|
|
var $2214;
|
||
|
|
var $2215=(($2214)&255);
|
||
|
|
$mask=$2215;
|
||
|
|
$mixmask=1;
|
||
|
|
label=186;break;
|
||
|
|
case 186:
|
||
|
|
var $2217=$mask;
|
||
|
|
var $2218=($2217&255);
|
||
|
|
var $2219=$mixmask;
|
||
|
|
var $2220=($2219&255);
|
||
|
|
var $2221=$2218&$2220;
|
||
|
|
var $2222=($2221|0)!=0;
|
||
|
|
if($2222){label=187;break;}else{label=188;break;}
|
||
|
|
case 187:
|
||
|
|
var $2224=$x;
|
||
|
|
var $2225=((($2224)*(3))&-1);
|
||
|
|
var $2226=$prevline;
|
||
|
|
var $2227=(($2226+$2225)|0);
|
||
|
|
var $2228=HEAP8[($2227)];
|
||
|
|
var $2229=($2228&255);
|
||
|
|
var $2230=(($mix)|0);
|
||
|
|
var $2231=HEAP8[($2230)];
|
||
|
|
var $2232=($2231&255);
|
||
|
|
var $2233=$2229^$2232;
|
||
|
|
var $2234=(($2233)&255);
|
||
|
|
var $2235=$x;
|
||
|
|
var $2236=((($2235)*(3))&-1);
|
||
|
|
var $2237=$line;
|
||
|
|
var $2238=(($2237+$2236)|0);
|
||
|
|
HEAP8[($2238)]=$2234;
|
||
|
|
var $2239=$x;
|
||
|
|
var $2240=((($2239)*(3))&-1);
|
||
|
|
var $2241=((($2240)+(1))|0);
|
||
|
|
var $2242=$prevline;
|
||
|
|
var $2243=(($2242+$2241)|0);
|
||
|
|
var $2244=HEAP8[($2243)];
|
||
|
|
var $2245=($2244&255);
|
||
|
|
var $2246=(($mix+1)|0);
|
||
|
|
var $2247=HEAP8[($2246)];
|
||
|
|
var $2248=($2247&255);
|
||
|
|
var $2249=$2245^$2248;
|
||
|
|
var $2250=(($2249)&255);
|
||
|
|
var $2251=$x;
|
||
|
|
var $2252=((($2251)*(3))&-1);
|
||
|
|
var $2253=((($2252)+(1))|0);
|
||
|
|
var $2254=$line;
|
||
|
|
var $2255=(($2254+$2253)|0);
|
||
|
|
HEAP8[($2255)]=$2250;
|
||
|
|
var $2256=$x;
|
||
|
|
var $2257=((($2256)*(3))&-1);
|
||
|
|
var $2258=((($2257)+(2))|0);
|
||
|
|
var $2259=$prevline;
|
||
|
|
var $2260=(($2259+$2258)|0);
|
||
|
|
var $2261=HEAP8[($2260)];
|
||
|
|
var $2262=($2261&255);
|
||
|
|
var $2263=(($mix+2)|0);
|
||
|
|
var $2264=HEAP8[($2263)];
|
||
|
|
var $2265=($2264&255);
|
||
|
|
var $2266=$2262^$2265;
|
||
|
|
var $2267=(($2266)&255);
|
||
|
|
var $2268=$x;
|
||
|
|
var $2269=((($2268)*(3))&-1);
|
||
|
|
var $2270=((($2269)+(2))|0);
|
||
|
|
var $2271=$line;
|
||
|
|
var $2272=(($2271+$2270)|0);
|
||
|
|
HEAP8[($2272)]=$2267;
|
||
|
|
label=189;break;
|
||
|
|
case 188:
|
||
|
|
var $2274=$x;
|
||
|
|
var $2275=((($2274)*(3))&-1);
|
||
|
|
var $2276=$prevline;
|
||
|
|
var $2277=(($2276+$2275)|0);
|
||
|
|
var $2278=HEAP8[($2277)];
|
||
|
|
var $2279=$x;
|
||
|
|
var $2280=((($2279)*(3))&-1);
|
||
|
|
var $2281=$line;
|
||
|
|
var $2282=(($2281+$2280)|0);
|
||
|
|
HEAP8[($2282)]=$2278;
|
||
|
|
var $2283=$x;
|
||
|
|
var $2284=((($2283)*(3))&-1);
|
||
|
|
var $2285=((($2284)+(1))|0);
|
||
|
|
var $2286=$prevline;
|
||
|
|
var $2287=(($2286+$2285)|0);
|
||
|
|
var $2288=HEAP8[($2287)];
|
||
|
|
var $2289=$x;
|
||
|
|
var $2290=((($2289)*(3))&-1);
|
||
|
|
var $2291=((($2290)+(1))|0);
|
||
|
|
var $2292=$line;
|
||
|
|
var $2293=(($2292+$2291)|0);
|
||
|
|
HEAP8[($2293)]=$2288;
|
||
|
|
var $2294=$x;
|
||
|
|
var $2295=((($2294)*(3))&-1);
|
||
|
|
var $2296=((($2295)+(2))|0);
|
||
|
|
var $2297=$prevline;
|
||
|
|
var $2298=(($2297+$2296)|0);
|
||
|
|
var $2299=HEAP8[($2298)];
|
||
|
|
var $2300=$x;
|
||
|
|
var $2301=((($2300)*(3))&-1);
|
||
|
|
var $2302=((($2301)+(2))|0);
|
||
|
|
var $2303=$line;
|
||
|
|
var $2304=(($2303+$2302)|0);
|
||
|
|
HEAP8[($2304)]=$2299;
|
||
|
|
label=189;break;
|
||
|
|
case 189:
|
||
|
|
var $2306=$count;
|
||
|
|
var $2307=((($2306)-(1))|0);
|
||
|
|
$count=$2307;
|
||
|
|
var $2308=$x;
|
||
|
|
var $2309=((($2308)+(1))|0);
|
||
|
|
$x=$2309;
|
||
|
|
var $2310=$mixmask;
|
||
|
|
var $2311=($2310&255);
|
||
|
|
var $2312=$2311<<1;
|
||
|
|
var $2313=(($2312)&255);
|
||
|
|
$mixmask=$2313;
|
||
|
|
var $2314=$mixmask;
|
||
|
|
var $2315=($2314&255);
|
||
|
|
var $2316=($2315|0)==0;
|
||
|
|
if($2316){label=190;break;}else{label=194;break;}
|
||
|
|
case 190:
|
||
|
|
var $2318=$fom_mask;
|
||
|
|
var $2319=($2318|0)!=0;
|
||
|
|
if($2319){label=191;break;}else{label=192;break;}
|
||
|
|
case 191:
|
||
|
|
var $2321=$fom_mask;
|
||
|
|
var $2328=$2321;label=193;break;
|
||
|
|
case 192:
|
||
|
|
var $2323=$5;
|
||
|
|
var $2324=(($2323+1)|0);
|
||
|
|
$5=$2324;
|
||
|
|
var $2325=HEAP8[($2323)];
|
||
|
|
var $2326=($2325&255);
|
||
|
|
var $2328=$2326;label=193;break;
|
||
|
|
case 193:
|
||
|
|
var $2328;
|
||
|
|
var $2329=(($2328)&255);
|
||
|
|
$mask=$2329;
|
||
|
|
$mixmask=1;
|
||
|
|
label=194;break;
|
||
|
|
case 194:
|
||
|
|
var $2331=$mask;
|
||
|
|
var $2332=($2331&255);
|
||
|
|
var $2333=$mixmask;
|
||
|
|
var $2334=($2333&255);
|
||
|
|
var $2335=$2332&$2334;
|
||
|
|
var $2336=($2335|0)!=0;
|
||
|
|
if($2336){label=195;break;}else{label=196;break;}
|
||
|
|
case 195:
|
||
|
|
var $2338=$x;
|
||
|
|
var $2339=((($2338)*(3))&-1);
|
||
|
|
var $2340=$prevline;
|
||
|
|
var $2341=(($2340+$2339)|0);
|
||
|
|
var $2342=HEAP8[($2341)];
|
||
|
|
var $2343=($2342&255);
|
||
|
|
var $2344=(($mix)|0);
|
||
|
|
var $2345=HEAP8[($2344)];
|
||
|
|
var $2346=($2345&255);
|
||
|
|
var $2347=$2343^$2346;
|
||
|
|
var $2348=(($2347)&255);
|
||
|
|
var $2349=$x;
|
||
|
|
var $2350=((($2349)*(3))&-1);
|
||
|
|
var $2351=$line;
|
||
|
|
var $2352=(($2351+$2350)|0);
|
||
|
|
HEAP8[($2352)]=$2348;
|
||
|
|
var $2353=$x;
|
||
|
|
var $2354=((($2353)*(3))&-1);
|
||
|
|
var $2355=((($2354)+(1))|0);
|
||
|
|
var $2356=$prevline;
|
||
|
|
var $2357=(($2356+$2355)|0);
|
||
|
|
var $2358=HEAP8[($2357)];
|
||
|
|
var $2359=($2358&255);
|
||
|
|
var $2360=(($mix+1)|0);
|
||
|
|
var $2361=HEAP8[($2360)];
|
||
|
|
var $2362=($2361&255);
|
||
|
|
var $2363=$2359^$2362;
|
||
|
|
var $2364=(($2363)&255);
|
||
|
|
var $2365=$x;
|
||
|
|
var $2366=((($2365)*(3))&-1);
|
||
|
|
var $2367=((($2366)+(1))|0);
|
||
|
|
var $2368=$line;
|
||
|
|
var $2369=(($2368+$2367)|0);
|
||
|
|
HEAP8[($2369)]=$2364;
|
||
|
|
var $2370=$x;
|
||
|
|
var $2371=((($2370)*(3))&-1);
|
||
|
|
var $2372=((($2371)+(2))|0);
|
||
|
|
var $2373=$prevline;
|
||
|
|
var $2374=(($2373+$2372)|0);
|
||
|
|
var $2375=HEAP8[($2374)];
|
||
|
|
var $2376=($2375&255);
|
||
|
|
var $2377=(($mix+2)|0);
|
||
|
|
var $2378=HEAP8[($2377)];
|
||
|
|
var $2379=($2378&255);
|
||
|
|
var $2380=$2376^$2379;
|
||
|
|
var $2381=(($2380)&255);
|
||
|
|
var $2382=$x;
|
||
|
|
var $2383=((($2382)*(3))&-1);
|
||
|
|
var $2384=((($2383)+(2))|0);
|
||
|
|
var $2385=$line;
|
||
|
|
var $2386=(($2385+$2384)|0);
|
||
|
|
HEAP8[($2386)]=$2381;
|
||
|
|
label=197;break;
|
||
|
|
case 196:
|
||
|
|
var $2388=$x;
|
||
|
|
var $2389=((($2388)*(3))&-1);
|
||
|
|
var $2390=$prevline;
|
||
|
|
var $2391=(($2390+$2389)|0);
|
||
|
|
var $2392=HEAP8[($2391)];
|
||
|
|
var $2393=$x;
|
||
|
|
var $2394=((($2393)*(3))&-1);
|
||
|
|
var $2395=$line;
|
||
|
|
var $2396=(($2395+$2394)|0);
|
||
|
|
HEAP8[($2396)]=$2392;
|
||
|
|
var $2397=$x;
|
||
|
|
var $2398=((($2397)*(3))&-1);
|
||
|
|
var $2399=((($2398)+(1))|0);
|
||
|
|
var $2400=$prevline;
|
||
|
|
var $2401=(($2400+$2399)|0);
|
||
|
|
var $2402=HEAP8[($2401)];
|
||
|
|
var $2403=$x;
|
||
|
|
var $2404=((($2403)*(3))&-1);
|
||
|
|
var $2405=((($2404)+(1))|0);
|
||
|
|
var $2406=$line;
|
||
|
|
var $2407=(($2406+$2405)|0);
|
||
|
|
HEAP8[($2407)]=$2402;
|
||
|
|
var $2408=$x;
|
||
|
|
var $2409=((($2408)*(3))&-1);
|
||
|
|
var $2410=((($2409)+(2))|0);
|
||
|
|
var $2411=$prevline;
|
||
|
|
var $2412=(($2411+$2410)|0);
|
||
|
|
var $2413=HEAP8[($2412)];
|
||
|
|
var $2414=$x;
|
||
|
|
var $2415=((($2414)*(3))&-1);
|
||
|
|
var $2416=((($2415)+(2))|0);
|
||
|
|
var $2417=$line;
|
||
|
|
var $2418=(($2417+$2416)|0);
|
||
|
|
HEAP8[($2418)]=$2413;
|
||
|
|
label=197;break;
|
||
|
|
case 197:
|
||
|
|
var $2420=$count;
|
||
|
|
var $2421=((($2420)-(1))|0);
|
||
|
|
$count=$2421;
|
||
|
|
var $2422=$x;
|
||
|
|
var $2423=((($2422)+(1))|0);
|
||
|
|
$x=$2423;
|
||
|
|
var $2424=$mixmask;
|
||
|
|
var $2425=($2424&255);
|
||
|
|
var $2426=$2425<<1;
|
||
|
|
var $2427=(($2426)&255);
|
||
|
|
$mixmask=$2427;
|
||
|
|
var $2428=$mixmask;
|
||
|
|
var $2429=($2428&255);
|
||
|
|
var $2430=($2429|0)==0;
|
||
|
|
if($2430){label=198;break;}else{label=202;break;}
|
||
|
|
case 198:
|
||
|
|
var $2432=$fom_mask;
|
||
|
|
var $2433=($2432|0)!=0;
|
||
|
|
if($2433){label=199;break;}else{label=200;break;}
|
||
|
|
case 199:
|
||
|
|
var $2435=$fom_mask;
|
||
|
|
var $2442=$2435;label=201;break;
|
||
|
|
case 200:
|
||
|
|
var $2437=$5;
|
||
|
|
var $2438=(($2437+1)|0);
|
||
|
|
$5=$2438;
|
||
|
|
var $2439=HEAP8[($2437)];
|
||
|
|
var $2440=($2439&255);
|
||
|
|
var $2442=$2440;label=201;break;
|
||
|
|
case 201:
|
||
|
|
var $2442;
|
||
|
|
var $2443=(($2442)&255);
|
||
|
|
$mask=$2443;
|
||
|
|
$mixmask=1;
|
||
|
|
label=202;break;
|
||
|
|
case 202:
|
||
|
|
var $2445=$mask;
|
||
|
|
var $2446=($2445&255);
|
||
|
|
var $2447=$mixmask;
|
||
|
|
var $2448=($2447&255);
|
||
|
|
var $2449=$2446&$2448;
|
||
|
|
var $2450=($2449|0)!=0;
|
||
|
|
if($2450){label=203;break;}else{label=204;break;}
|
||
|
|
case 203:
|
||
|
|
var $2452=$x;
|
||
|
|
var $2453=((($2452)*(3))&-1);
|
||
|
|
var $2454=$prevline;
|
||
|
|
var $2455=(($2454+$2453)|0);
|
||
|
|
var $2456=HEAP8[($2455)];
|
||
|
|
var $2457=($2456&255);
|
||
|
|
var $2458=(($mix)|0);
|
||
|
|
var $2459=HEAP8[($2458)];
|
||
|
|
var $2460=($2459&255);
|
||
|
|
var $2461=$2457^$2460;
|
||
|
|
var $2462=(($2461)&255);
|
||
|
|
var $2463=$x;
|
||
|
|
var $2464=((($2463)*(3))&-1);
|
||
|
|
var $2465=$line;
|
||
|
|
var $2466=(($2465+$2464)|0);
|
||
|
|
HEAP8[($2466)]=$2462;
|
||
|
|
var $2467=$x;
|
||
|
|
var $2468=((($2467)*(3))&-1);
|
||
|
|
var $2469=((($2468)+(1))|0);
|
||
|
|
var $2470=$prevline;
|
||
|
|
var $2471=(($2470+$2469)|0);
|
||
|
|
var $2472=HEAP8[($2471)];
|
||
|
|
var $2473=($2472&255);
|
||
|
|
var $2474=(($mix+1)|0);
|
||
|
|
var $2475=HEAP8[($2474)];
|
||
|
|
var $2476=($2475&255);
|
||
|
|
var $2477=$2473^$2476;
|
||
|
|
var $2478=(($2477)&255);
|
||
|
|
var $2479=$x;
|
||
|
|
var $2480=((($2479)*(3))&-1);
|
||
|
|
var $2481=((($2480)+(1))|0);
|
||
|
|
var $2482=$line;
|
||
|
|
var $2483=(($2482+$2481)|0);
|
||
|
|
HEAP8[($2483)]=$2478;
|
||
|
|
var $2484=$x;
|
||
|
|
var $2485=((($2484)*(3))&-1);
|
||
|
|
var $2486=((($2485)+(2))|0);
|
||
|
|
var $2487=$prevline;
|
||
|
|
var $2488=(($2487+$2486)|0);
|
||
|
|
var $2489=HEAP8[($2488)];
|
||
|
|
var $2490=($2489&255);
|
||
|
|
var $2491=(($mix+2)|0);
|
||
|
|
var $2492=HEAP8[($2491)];
|
||
|
|
var $2493=($2492&255);
|
||
|
|
var $2494=$2490^$2493;
|
||
|
|
var $2495=(($2494)&255);
|
||
|
|
var $2496=$x;
|
||
|
|
var $2497=((($2496)*(3))&-1);
|
||
|
|
var $2498=((($2497)+(2))|0);
|
||
|
|
var $2499=$line;
|
||
|
|
var $2500=(($2499+$2498)|0);
|
||
|
|
HEAP8[($2500)]=$2495;
|
||
|
|
label=205;break;
|
||
|
|
case 204:
|
||
|
|
var $2502=$x;
|
||
|
|
var $2503=((($2502)*(3))&-1);
|
||
|
|
var $2504=$prevline;
|
||
|
|
var $2505=(($2504+$2503)|0);
|
||
|
|
var $2506=HEAP8[($2505)];
|
||
|
|
var $2507=$x;
|
||
|
|
var $2508=((($2507)*(3))&-1);
|
||
|
|
var $2509=$line;
|
||
|
|
var $2510=(($2509+$2508)|0);
|
||
|
|
HEAP8[($2510)]=$2506;
|
||
|
|
var $2511=$x;
|
||
|
|
var $2512=((($2511)*(3))&-1);
|
||
|
|
var $2513=((($2512)+(1))|0);
|
||
|
|
var $2514=$prevline;
|
||
|
|
var $2515=(($2514+$2513)|0);
|
||
|
|
var $2516=HEAP8[($2515)];
|
||
|
|
var $2517=$x;
|
||
|
|
var $2518=((($2517)*(3))&-1);
|
||
|
|
var $2519=((($2518)+(1))|0);
|
||
|
|
var $2520=$line;
|
||
|
|
var $2521=(($2520+$2519)|0);
|
||
|
|
HEAP8[($2521)]=$2516;
|
||
|
|
var $2522=$x;
|
||
|
|
var $2523=((($2522)*(3))&-1);
|
||
|
|
var $2524=((($2523)+(2))|0);
|
||
|
|
var $2525=$prevline;
|
||
|
|
var $2526=(($2525+$2524)|0);
|
||
|
|
var $2527=HEAP8[($2526)];
|
||
|
|
var $2528=$x;
|
||
|
|
var $2529=((($2528)*(3))&-1);
|
||
|
|
var $2530=((($2529)+(2))|0);
|
||
|
|
var $2531=$line;
|
||
|
|
var $2532=(($2531+$2530)|0);
|
||
|
|
HEAP8[($2532)]=$2527;
|
||
|
|
label=205;break;
|
||
|
|
case 205:
|
||
|
|
var $2534=$count;
|
||
|
|
var $2535=((($2534)-(1))|0);
|
||
|
|
$count=$2535;
|
||
|
|
var $2536=$x;
|
||
|
|
var $2537=((($2536)+(1))|0);
|
||
|
|
$x=$2537;
|
||
|
|
var $2538=$mixmask;
|
||
|
|
var $2539=($2538&255);
|
||
|
|
var $2540=$2539<<1;
|
||
|
|
var $2541=(($2540)&255);
|
||
|
|
$mixmask=$2541;
|
||
|
|
var $2542=$mixmask;
|
||
|
|
var $2543=($2542&255);
|
||
|
|
var $2544=($2543|0)==0;
|
||
|
|
if($2544){label=206;break;}else{label=210;break;}
|
||
|
|
case 206:
|
||
|
|
var $2546=$fom_mask;
|
||
|
|
var $2547=($2546|0)!=0;
|
||
|
|
if($2547){label=207;break;}else{label=208;break;}
|
||
|
|
case 207:
|
||
|
|
var $2549=$fom_mask;
|
||
|
|
var $2556=$2549;label=209;break;
|
||
|
|
case 208:
|
||
|
|
var $2551=$5;
|
||
|
|
var $2552=(($2551+1)|0);
|
||
|
|
$5=$2552;
|
||
|
|
var $2553=HEAP8[($2551)];
|
||
|
|
var $2554=($2553&255);
|
||
|
|
var $2556=$2554;label=209;break;
|
||
|
|
case 209:
|
||
|
|
var $2556;
|
||
|
|
var $2557=(($2556)&255);
|
||
|
|
$mask=$2557;
|
||
|
|
$mixmask=1;
|
||
|
|
label=210;break;
|
||
|
|
case 210:
|
||
|
|
var $2559=$mask;
|
||
|
|
var $2560=($2559&255);
|
||
|
|
var $2561=$mixmask;
|
||
|
|
var $2562=($2561&255);
|
||
|
|
var $2563=$2560&$2562;
|
||
|
|
var $2564=($2563|0)!=0;
|
||
|
|
if($2564){label=211;break;}else{label=212;break;}
|
||
|
|
case 211:
|
||
|
|
var $2566=$x;
|
||
|
|
var $2567=((($2566)*(3))&-1);
|
||
|
|
var $2568=$prevline;
|
||
|
|
var $2569=(($2568+$2567)|0);
|
||
|
|
var $2570=HEAP8[($2569)];
|
||
|
|
var $2571=($2570&255);
|
||
|
|
var $2572=(($mix)|0);
|
||
|
|
var $2573=HEAP8[($2572)];
|
||
|
|
var $2574=($2573&255);
|
||
|
|
var $2575=$2571^$2574;
|
||
|
|
var $2576=(($2575)&255);
|
||
|
|
var $2577=$x;
|
||
|
|
var $2578=((($2577)*(3))&-1);
|
||
|
|
var $2579=$line;
|
||
|
|
var $2580=(($2579+$2578)|0);
|
||
|
|
HEAP8[($2580)]=$2576;
|
||
|
|
var $2581=$x;
|
||
|
|
var $2582=((($2581)*(3))&-1);
|
||
|
|
var $2583=((($2582)+(1))|0);
|
||
|
|
var $2584=$prevline;
|
||
|
|
var $2585=(($2584+$2583)|0);
|
||
|
|
var $2586=HEAP8[($2585)];
|
||
|
|
var $2587=($2586&255);
|
||
|
|
var $2588=(($mix+1)|0);
|
||
|
|
var $2589=HEAP8[($2588)];
|
||
|
|
var $2590=($2589&255);
|
||
|
|
var $2591=$2587^$2590;
|
||
|
|
var $2592=(($2591)&255);
|
||
|
|
var $2593=$x;
|
||
|
|
var $2594=((($2593)*(3))&-1);
|
||
|
|
var $2595=((($2594)+(1))|0);
|
||
|
|
var $2596=$line;
|
||
|
|
var $2597=(($2596+$2595)|0);
|
||
|
|
HEAP8[($2597)]=$2592;
|
||
|
|
var $2598=$x;
|
||
|
|
var $2599=((($2598)*(3))&-1);
|
||
|
|
var $2600=((($2599)+(2))|0);
|
||
|
|
var $2601=$prevline;
|
||
|
|
var $2602=(($2601+$2600)|0);
|
||
|
|
var $2603=HEAP8[($2602)];
|
||
|
|
var $2604=($2603&255);
|
||
|
|
var $2605=(($mix+2)|0);
|
||
|
|
var $2606=HEAP8[($2605)];
|
||
|
|
var $2607=($2606&255);
|
||
|
|
var $2608=$2604^$2607;
|
||
|
|
var $2609=(($2608)&255);
|
||
|
|
var $2610=$x;
|
||
|
|
var $2611=((($2610)*(3))&-1);
|
||
|
|
var $2612=((($2611)+(2))|0);
|
||
|
|
var $2613=$line;
|
||
|
|
var $2614=(($2613+$2612)|0);
|
||
|
|
HEAP8[($2614)]=$2609;
|
||
|
|
label=213;break;
|
||
|
|
case 212:
|
||
|
|
var $2616=$x;
|
||
|
|
var $2617=((($2616)*(3))&-1);
|
||
|
|
var $2618=$prevline;
|
||
|
|
var $2619=(($2618+$2617)|0);
|
||
|
|
var $2620=HEAP8[($2619)];
|
||
|
|
var $2621=$x;
|
||
|
|
var $2622=((($2621)*(3))&-1);
|
||
|
|
var $2623=$line;
|
||
|
|
var $2624=(($2623+$2622)|0);
|
||
|
|
HEAP8[($2624)]=$2620;
|
||
|
|
var $2625=$x;
|
||
|
|
var $2626=((($2625)*(3))&-1);
|
||
|
|
var $2627=((($2626)+(1))|0);
|
||
|
|
var $2628=$prevline;
|
||
|
|
var $2629=(($2628+$2627)|0);
|
||
|
|
var $2630=HEAP8[($2629)];
|
||
|
|
var $2631=$x;
|
||
|
|
var $2632=((($2631)*(3))&-1);
|
||
|
|
var $2633=((($2632)+(1))|0);
|
||
|
|
var $2634=$line;
|
||
|
|
var $2635=(($2634+$2633)|0);
|
||
|
|
HEAP8[($2635)]=$2630;
|
||
|
|
var $2636=$x;
|
||
|
|
var $2637=((($2636)*(3))&-1);
|
||
|
|
var $2638=((($2637)+(2))|0);
|
||
|
|
var $2639=$prevline;
|
||
|
|
var $2640=(($2639+$2638)|0);
|
||
|
|
var $2641=HEAP8[($2640)];
|
||
|
|
var $2642=$x;
|
||
|
|
var $2643=((($2642)*(3))&-1);
|
||
|
|
var $2644=((($2643)+(2))|0);
|
||
|
|
var $2645=$line;
|
||
|
|
var $2646=(($2645+$2644)|0);
|
||
|
|
HEAP8[($2646)]=$2641;
|
||
|
|
label=213;break;
|
||
|
|
case 213:
|
||
|
|
var $2648=$count;
|
||
|
|
var $2649=((($2648)-(1))|0);
|
||
|
|
$count=$2649;
|
||
|
|
var $2650=$x;
|
||
|
|
var $2651=((($2650)+(1))|0);
|
||
|
|
$x=$2651;
|
||
|
|
var $2652=$mixmask;
|
||
|
|
var $2653=($2652&255);
|
||
|
|
var $2654=$2653<<1;
|
||
|
|
var $2655=(($2654)&255);
|
||
|
|
$mixmask=$2655;
|
||
|
|
var $2656=$mixmask;
|
||
|
|
var $2657=($2656&255);
|
||
|
|
var $2658=($2657|0)==0;
|
||
|
|
if($2658){label=214;break;}else{label=218;break;}
|
||
|
|
case 214:
|
||
|
|
var $2660=$fom_mask;
|
||
|
|
var $2661=($2660|0)!=0;
|
||
|
|
if($2661){label=215;break;}else{label=216;break;}
|
||
|
|
case 215:
|
||
|
|
var $2663=$fom_mask;
|
||
|
|
var $2670=$2663;label=217;break;
|
||
|
|
case 216:
|
||
|
|
var $2665=$5;
|
||
|
|
var $2666=(($2665+1)|0);
|
||
|
|
$5=$2666;
|
||
|
|
var $2667=HEAP8[($2665)];
|
||
|
|
var $2668=($2667&255);
|
||
|
|
var $2670=$2668;label=217;break;
|
||
|
|
case 217:
|
||
|
|
var $2670;
|
||
|
|
var $2671=(($2670)&255);
|
||
|
|
$mask=$2671;
|
||
|
|
$mixmask=1;
|
||
|
|
label=218;break;
|
||
|
|
case 218:
|
||
|
|
var $2673=$mask;
|
||
|
|
var $2674=($2673&255);
|
||
|
|
var $2675=$mixmask;
|
||
|
|
var $2676=($2675&255);
|
||
|
|
var $2677=$2674&$2676;
|
||
|
|
var $2678=($2677|0)!=0;
|
||
|
|
if($2678){label=219;break;}else{label=220;break;}
|
||
|
|
case 219:
|
||
|
|
var $2680=$x;
|
||
|
|
var $2681=((($2680)*(3))&-1);
|
||
|
|
var $2682=$prevline;
|
||
|
|
var $2683=(($2682+$2681)|0);
|
||
|
|
var $2684=HEAP8[($2683)];
|
||
|
|
var $2685=($2684&255);
|
||
|
|
var $2686=(($mix)|0);
|
||
|
|
var $2687=HEAP8[($2686)];
|
||
|
|
var $2688=($2687&255);
|
||
|
|
var $2689=$2685^$2688;
|
||
|
|
var $2690=(($2689)&255);
|
||
|
|
var $2691=$x;
|
||
|
|
var $2692=((($2691)*(3))&-1);
|
||
|
|
var $2693=$line;
|
||
|
|
var $2694=(($2693+$2692)|0);
|
||
|
|
HEAP8[($2694)]=$2690;
|
||
|
|
var $2695=$x;
|
||
|
|
var $2696=((($2695)*(3))&-1);
|
||
|
|
var $2697=((($2696)+(1))|0);
|
||
|
|
var $2698=$prevline;
|
||
|
|
var $2699=(($2698+$2697)|0);
|
||
|
|
var $2700=HEAP8[($2699)];
|
||
|
|
var $2701=($2700&255);
|
||
|
|
var $2702=(($mix+1)|0);
|
||
|
|
var $2703=HEAP8[($2702)];
|
||
|
|
var $2704=($2703&255);
|
||
|
|
var $2705=$2701^$2704;
|
||
|
|
var $2706=(($2705)&255);
|
||
|
|
var $2707=$x;
|
||
|
|
var $2708=((($2707)*(3))&-1);
|
||
|
|
var $2709=((($2708)+(1))|0);
|
||
|
|
var $2710=$line;
|
||
|
|
var $2711=(($2710+$2709)|0);
|
||
|
|
HEAP8[($2711)]=$2706;
|
||
|
|
var $2712=$x;
|
||
|
|
var $2713=((($2712)*(3))&-1);
|
||
|
|
var $2714=((($2713)+(2))|0);
|
||
|
|
var $2715=$prevline;
|
||
|
|
var $2716=(($2715+$2714)|0);
|
||
|
|
var $2717=HEAP8[($2716)];
|
||
|
|
var $2718=($2717&255);
|
||
|
|
var $2719=(($mix+2)|0);
|
||
|
|
var $2720=HEAP8[($2719)];
|
||
|
|
var $2721=($2720&255);
|
||
|
|
var $2722=$2718^$2721;
|
||
|
|
var $2723=(($2722)&255);
|
||
|
|
var $2724=$x;
|
||
|
|
var $2725=((($2724)*(3))&-1);
|
||
|
|
var $2726=((($2725)+(2))|0);
|
||
|
|
var $2727=$line;
|
||
|
|
var $2728=(($2727+$2726)|0);
|
||
|
|
HEAP8[($2728)]=$2723;
|
||
|
|
label=221;break;
|
||
|
|
case 220:
|
||
|
|
var $2730=$x;
|
||
|
|
var $2731=((($2730)*(3))&-1);
|
||
|
|
var $2732=$prevline;
|
||
|
|
var $2733=(($2732+$2731)|0);
|
||
|
|
var $2734=HEAP8[($2733)];
|
||
|
|
var $2735=$x;
|
||
|
|
var $2736=((($2735)*(3))&-1);
|
||
|
|
var $2737=$line;
|
||
|
|
var $2738=(($2737+$2736)|0);
|
||
|
|
HEAP8[($2738)]=$2734;
|
||
|
|
var $2739=$x;
|
||
|
|
var $2740=((($2739)*(3))&-1);
|
||
|
|
var $2741=((($2740)+(1))|0);
|
||
|
|
var $2742=$prevline;
|
||
|
|
var $2743=(($2742+$2741)|0);
|
||
|
|
var $2744=HEAP8[($2743)];
|
||
|
|
var $2745=$x;
|
||
|
|
var $2746=((($2745)*(3))&-1);
|
||
|
|
var $2747=((($2746)+(1))|0);
|
||
|
|
var $2748=$line;
|
||
|
|
var $2749=(($2748+$2747)|0);
|
||
|
|
HEAP8[($2749)]=$2744;
|
||
|
|
var $2750=$x;
|
||
|
|
var $2751=((($2750)*(3))&-1);
|
||
|
|
var $2752=((($2751)+(2))|0);
|
||
|
|
var $2753=$prevline;
|
||
|
|
var $2754=(($2753+$2752)|0);
|
||
|
|
var $2755=HEAP8[($2754)];
|
||
|
|
var $2756=$x;
|
||
|
|
var $2757=((($2756)*(3))&-1);
|
||
|
|
var $2758=((($2757)+(2))|0);
|
||
|
|
var $2759=$line;
|
||
|
|
var $2760=(($2759+$2758)|0);
|
||
|
|
HEAP8[($2760)]=$2755;
|
||
|
|
label=221;break;
|
||
|
|
case 221:
|
||
|
|
var $2762=$count;
|
||
|
|
var $2763=((($2762)-(1))|0);
|
||
|
|
$count=$2763;
|
||
|
|
var $2764=$x;
|
||
|
|
var $2765=((($2764)+(1))|0);
|
||
|
|
$x=$2765;
|
||
|
|
var $2766=$mixmask;
|
||
|
|
var $2767=($2766&255);
|
||
|
|
var $2768=$2767<<1;
|
||
|
|
var $2769=(($2768)&255);
|
||
|
|
$mixmask=$2769;
|
||
|
|
var $2770=$mixmask;
|
||
|
|
var $2771=($2770&255);
|
||
|
|
var $2772=($2771|0)==0;
|
||
|
|
if($2772){label=222;break;}else{label=226;break;}
|
||
|
|
case 222:
|
||
|
|
var $2774=$fom_mask;
|
||
|
|
var $2775=($2774|0)!=0;
|
||
|
|
if($2775){label=223;break;}else{label=224;break;}
|
||
|
|
case 223:
|
||
|
|
var $2777=$fom_mask;
|
||
|
|
var $2784=$2777;label=225;break;
|
||
|
|
case 224:
|
||
|
|
var $2779=$5;
|
||
|
|
var $2780=(($2779+1)|0);
|
||
|
|
$5=$2780;
|
||
|
|
var $2781=HEAP8[($2779)];
|
||
|
|
var $2782=($2781&255);
|
||
|
|
var $2784=$2782;label=225;break;
|
||
|
|
case 225:
|
||
|
|
var $2784;
|
||
|
|
var $2785=(($2784)&255);
|
||
|
|
$mask=$2785;
|
||
|
|
$mixmask=1;
|
||
|
|
label=226;break;
|
||
|
|
case 226:
|
||
|
|
var $2787=$mask;
|
||
|
|
var $2788=($2787&255);
|
||
|
|
var $2789=$mixmask;
|
||
|
|
var $2790=($2789&255);
|
||
|
|
var $2791=$2788&$2790;
|
||
|
|
var $2792=($2791|0)!=0;
|
||
|
|
if($2792){label=227;break;}else{label=228;break;}
|
||
|
|
case 227:
|
||
|
|
var $2794=$x;
|
||
|
|
var $2795=((($2794)*(3))&-1);
|
||
|
|
var $2796=$prevline;
|
||
|
|
var $2797=(($2796+$2795)|0);
|
||
|
|
var $2798=HEAP8[($2797)];
|
||
|
|
var $2799=($2798&255);
|
||
|
|
var $2800=(($mix)|0);
|
||
|
|
var $2801=HEAP8[($2800)];
|
||
|
|
var $2802=($2801&255);
|
||
|
|
var $2803=$2799^$2802;
|
||
|
|
var $2804=(($2803)&255);
|
||
|
|
var $2805=$x;
|
||
|
|
var $2806=((($2805)*(3))&-1);
|
||
|
|
var $2807=$line;
|
||
|
|
var $2808=(($2807+$2806)|0);
|
||
|
|
HEAP8[($2808)]=$2804;
|
||
|
|
var $2809=$x;
|
||
|
|
var $2810=((($2809)*(3))&-1);
|
||
|
|
var $2811=((($2810)+(1))|0);
|
||
|
|
var $2812=$prevline;
|
||
|
|
var $2813=(($2812+$2811)|0);
|
||
|
|
var $2814=HEAP8[($2813)];
|
||
|
|
var $2815=($2814&255);
|
||
|
|
var $2816=(($mix+1)|0);
|
||
|
|
var $2817=HEAP8[($2816)];
|
||
|
|
var $2818=($2817&255);
|
||
|
|
var $2819=$2815^$2818;
|
||
|
|
var $2820=(($2819)&255);
|
||
|
|
var $2821=$x;
|
||
|
|
var $2822=((($2821)*(3))&-1);
|
||
|
|
var $2823=((($2822)+(1))|0);
|
||
|
|
var $2824=$line;
|
||
|
|
var $2825=(($2824+$2823)|0);
|
||
|
|
HEAP8[($2825)]=$2820;
|
||
|
|
var $2826=$x;
|
||
|
|
var $2827=((($2826)*(3))&-1);
|
||
|
|
var $2828=((($2827)+(2))|0);
|
||
|
|
var $2829=$prevline;
|
||
|
|
var $2830=(($2829+$2828)|0);
|
||
|
|
var $2831=HEAP8[($2830)];
|
||
|
|
var $2832=($2831&255);
|
||
|
|
var $2833=(($mix+2)|0);
|
||
|
|
var $2834=HEAP8[($2833)];
|
||
|
|
var $2835=($2834&255);
|
||
|
|
var $2836=$2832^$2835;
|
||
|
|
var $2837=(($2836)&255);
|
||
|
|
var $2838=$x;
|
||
|
|
var $2839=((($2838)*(3))&-1);
|
||
|
|
var $2840=((($2839)+(2))|0);
|
||
|
|
var $2841=$line;
|
||
|
|
var $2842=(($2841+$2840)|0);
|
||
|
|
HEAP8[($2842)]=$2837;
|
||
|
|
label=229;break;
|
||
|
|
case 228:
|
||
|
|
var $2844=$x;
|
||
|
|
var $2845=((($2844)*(3))&-1);
|
||
|
|
var $2846=$prevline;
|
||
|
|
var $2847=(($2846+$2845)|0);
|
||
|
|
var $2848=HEAP8[($2847)];
|
||
|
|
var $2849=$x;
|
||
|
|
var $2850=((($2849)*(3))&-1);
|
||
|
|
var $2851=$line;
|
||
|
|
var $2852=(($2851+$2850)|0);
|
||
|
|
HEAP8[($2852)]=$2848;
|
||
|
|
var $2853=$x;
|
||
|
|
var $2854=((($2853)*(3))&-1);
|
||
|
|
var $2855=((($2854)+(1))|0);
|
||
|
|
var $2856=$prevline;
|
||
|
|
var $2857=(($2856+$2855)|0);
|
||
|
|
var $2858=HEAP8[($2857)];
|
||
|
|
var $2859=$x;
|
||
|
|
var $2860=((($2859)*(3))&-1);
|
||
|
|
var $2861=((($2860)+(1))|0);
|
||
|
|
var $2862=$line;
|
||
|
|
var $2863=(($2862+$2861)|0);
|
||
|
|
HEAP8[($2863)]=$2858;
|
||
|
|
var $2864=$x;
|
||
|
|
var $2865=((($2864)*(3))&-1);
|
||
|
|
var $2866=((($2865)+(2))|0);
|
||
|
|
var $2867=$prevline;
|
||
|
|
var $2868=(($2867+$2866)|0);
|
||
|
|
var $2869=HEAP8[($2868)];
|
||
|
|
var $2870=$x;
|
||
|
|
var $2871=((($2870)*(3))&-1);
|
||
|
|
var $2872=((($2871)+(2))|0);
|
||
|
|
var $2873=$line;
|
||
|
|
var $2874=(($2873+$2872)|0);
|
||
|
|
HEAP8[($2874)]=$2869;
|
||
|
|
label=229;break;
|
||
|
|
case 229:
|
||
|
|
var $2876=$count;
|
||
|
|
var $2877=((($2876)-(1))|0);
|
||
|
|
$count=$2877;
|
||
|
|
var $2878=$x;
|
||
|
|
var $2879=((($2878)+(1))|0);
|
||
|
|
$x=$2879;
|
||
|
|
var $2880=$mixmask;
|
||
|
|
var $2881=($2880&255);
|
||
|
|
var $2882=$2881<<1;
|
||
|
|
var $2883=(($2882)&255);
|
||
|
|
$mixmask=$2883;
|
||
|
|
var $2884=$mixmask;
|
||
|
|
var $2885=($2884&255);
|
||
|
|
var $2886=($2885|0)==0;
|
||
|
|
if($2886){label=230;break;}else{label=234;break;}
|
||
|
|
case 230:
|
||
|
|
var $2888=$fom_mask;
|
||
|
|
var $2889=($2888|0)!=0;
|
||
|
|
if($2889){label=231;break;}else{label=232;break;}
|
||
|
|
case 231:
|
||
|
|
var $2891=$fom_mask;
|
||
|
|
var $2898=$2891;label=233;break;
|
||
|
|
case 232:
|
||
|
|
var $2893=$5;
|
||
|
|
var $2894=(($2893+1)|0);
|
||
|
|
$5=$2894;
|
||
|
|
var $2895=HEAP8[($2893)];
|
||
|
|
var $2896=($2895&255);
|
||
|
|
var $2898=$2896;label=233;break;
|
||
|
|
case 233:
|
||
|
|
var $2898;
|
||
|
|
var $2899=(($2898)&255);
|
||
|
|
$mask=$2899;
|
||
|
|
$mixmask=1;
|
||
|
|
label=234;break;
|
||
|
|
case 234:
|
||
|
|
var $2901=$mask;
|
||
|
|
var $2902=($2901&255);
|
||
|
|
var $2903=$mixmask;
|
||
|
|
var $2904=($2903&255);
|
||
|
|
var $2905=$2902&$2904;
|
||
|
|
var $2906=($2905|0)!=0;
|
||
|
|
if($2906){label=235;break;}else{label=236;break;}
|
||
|
|
case 235:
|
||
|
|
var $2908=$x;
|
||
|
|
var $2909=((($2908)*(3))&-1);
|
||
|
|
var $2910=$prevline;
|
||
|
|
var $2911=(($2910+$2909)|0);
|
||
|
|
var $2912=HEAP8[($2911)];
|
||
|
|
var $2913=($2912&255);
|
||
|
|
var $2914=(($mix)|0);
|
||
|
|
var $2915=HEAP8[($2914)];
|
||
|
|
var $2916=($2915&255);
|
||
|
|
var $2917=$2913^$2916;
|
||
|
|
var $2918=(($2917)&255);
|
||
|
|
var $2919=$x;
|
||
|
|
var $2920=((($2919)*(3))&-1);
|
||
|
|
var $2921=$line;
|
||
|
|
var $2922=(($2921+$2920)|0);
|
||
|
|
HEAP8[($2922)]=$2918;
|
||
|
|
var $2923=$x;
|
||
|
|
var $2924=((($2923)*(3))&-1);
|
||
|
|
var $2925=((($2924)+(1))|0);
|
||
|
|
var $2926=$prevline;
|
||
|
|
var $2927=(($2926+$2925)|0);
|
||
|
|
var $2928=HEAP8[($2927)];
|
||
|
|
var $2929=($2928&255);
|
||
|
|
var $2930=(($mix+1)|0);
|
||
|
|
var $2931=HEAP8[($2930)];
|
||
|
|
var $2932=($2931&255);
|
||
|
|
var $2933=$2929^$2932;
|
||
|
|
var $2934=(($2933)&255);
|
||
|
|
var $2935=$x;
|
||
|
|
var $2936=((($2935)*(3))&-1);
|
||
|
|
var $2937=((($2936)+(1))|0);
|
||
|
|
var $2938=$line;
|
||
|
|
var $2939=(($2938+$2937)|0);
|
||
|
|
HEAP8[($2939)]=$2934;
|
||
|
|
var $2940=$x;
|
||
|
|
var $2941=((($2940)*(3))&-1);
|
||
|
|
var $2942=((($2941)+(2))|0);
|
||
|
|
var $2943=$prevline;
|
||
|
|
var $2944=(($2943+$2942)|0);
|
||
|
|
var $2945=HEAP8[($2944)];
|
||
|
|
var $2946=($2945&255);
|
||
|
|
var $2947=(($mix+2)|0);
|
||
|
|
var $2948=HEAP8[($2947)];
|
||
|
|
var $2949=($2948&255);
|
||
|
|
var $2950=$2946^$2949;
|
||
|
|
var $2951=(($2950)&255);
|
||
|
|
var $2952=$x;
|
||
|
|
var $2953=((($2952)*(3))&-1);
|
||
|
|
var $2954=((($2953)+(2))|0);
|
||
|
|
var $2955=$line;
|
||
|
|
var $2956=(($2955+$2954)|0);
|
||
|
|
HEAP8[($2956)]=$2951;
|
||
|
|
label=237;break;
|
||
|
|
case 236:
|
||
|
|
var $2958=$x;
|
||
|
|
var $2959=((($2958)*(3))&-1);
|
||
|
|
var $2960=$prevline;
|
||
|
|
var $2961=(($2960+$2959)|0);
|
||
|
|
var $2962=HEAP8[($2961)];
|
||
|
|
var $2963=$x;
|
||
|
|
var $2964=((($2963)*(3))&-1);
|
||
|
|
var $2965=$line;
|
||
|
|
var $2966=(($2965+$2964)|0);
|
||
|
|
HEAP8[($2966)]=$2962;
|
||
|
|
var $2967=$x;
|
||
|
|
var $2968=((($2967)*(3))&-1);
|
||
|
|
var $2969=((($2968)+(1))|0);
|
||
|
|
var $2970=$prevline;
|
||
|
|
var $2971=(($2970+$2969)|0);
|
||
|
|
var $2972=HEAP8[($2971)];
|
||
|
|
var $2973=$x;
|
||
|
|
var $2974=((($2973)*(3))&-1);
|
||
|
|
var $2975=((($2974)+(1))|0);
|
||
|
|
var $2976=$line;
|
||
|
|
var $2977=(($2976+$2975)|0);
|
||
|
|
HEAP8[($2977)]=$2972;
|
||
|
|
var $2978=$x;
|
||
|
|
var $2979=((($2978)*(3))&-1);
|
||
|
|
var $2980=((($2979)+(2))|0);
|
||
|
|
var $2981=$prevline;
|
||
|
|
var $2982=(($2981+$2980)|0);
|
||
|
|
var $2983=HEAP8[($2982)];
|
||
|
|
var $2984=$x;
|
||
|
|
var $2985=((($2984)*(3))&-1);
|
||
|
|
var $2986=((($2985)+(2))|0);
|
||
|
|
var $2987=$line;
|
||
|
|
var $2988=(($2987+$2986)|0);
|
||
|
|
HEAP8[($2988)]=$2983;
|
||
|
|
label=237;break;
|
||
|
|
case 237:
|
||
|
|
var $2990=$count;
|
||
|
|
var $2991=((($2990)-(1))|0);
|
||
|
|
$count=$2991;
|
||
|
|
var $2992=$x;
|
||
|
|
var $2993=((($2992)+(1))|0);
|
||
|
|
$x=$2993;
|
||
|
|
var $2994=$mixmask;
|
||
|
|
var $2995=($2994&255);
|
||
|
|
var $2996=$2995<<1;
|
||
|
|
var $2997=(($2996)&255);
|
||
|
|
$mixmask=$2997;
|
||
|
|
var $2998=$mixmask;
|
||
|
|
var $2999=($2998&255);
|
||
|
|
var $3000=($2999|0)==0;
|
||
|
|
if($3000){label=238;break;}else{label=242;break;}
|
||
|
|
case 238:
|
||
|
|
var $3002=$fom_mask;
|
||
|
|
var $3003=($3002|0)!=0;
|
||
|
|
if($3003){label=239;break;}else{label=240;break;}
|
||
|
|
case 239:
|
||
|
|
var $3005=$fom_mask;
|
||
|
|
var $3012=$3005;label=241;break;
|
||
|
|
case 240:
|
||
|
|
var $3007=$5;
|
||
|
|
var $3008=(($3007+1)|0);
|
||
|
|
$5=$3008;
|
||
|
|
var $3009=HEAP8[($3007)];
|
||
|
|
var $3010=($3009&255);
|
||
|
|
var $3012=$3010;label=241;break;
|
||
|
|
case 241:
|
||
|
|
var $3012;
|
||
|
|
var $3013=(($3012)&255);
|
||
|
|
$mask=$3013;
|
||
|
|
$mixmask=1;
|
||
|
|
label=242;break;
|
||
|
|
case 242:
|
||
|
|
var $3015=$mask;
|
||
|
|
var $3016=($3015&255);
|
||
|
|
var $3017=$mixmask;
|
||
|
|
var $3018=($3017&255);
|
||
|
|
var $3019=$3016&$3018;
|
||
|
|
var $3020=($3019|0)!=0;
|
||
|
|
if($3020){label=243;break;}else{label=244;break;}
|
||
|
|
case 243:
|
||
|
|
var $3022=$x;
|
||
|
|
var $3023=((($3022)*(3))&-1);
|
||
|
|
var $3024=$prevline;
|
||
|
|
var $3025=(($3024+$3023)|0);
|
||
|
|
var $3026=HEAP8[($3025)];
|
||
|
|
var $3027=($3026&255);
|
||
|
|
var $3028=(($mix)|0);
|
||
|
|
var $3029=HEAP8[($3028)];
|
||
|
|
var $3030=($3029&255);
|
||
|
|
var $3031=$3027^$3030;
|
||
|
|
var $3032=(($3031)&255);
|
||
|
|
var $3033=$x;
|
||
|
|
var $3034=((($3033)*(3))&-1);
|
||
|
|
var $3035=$line;
|
||
|
|
var $3036=(($3035+$3034)|0);
|
||
|
|
HEAP8[($3036)]=$3032;
|
||
|
|
var $3037=$x;
|
||
|
|
var $3038=((($3037)*(3))&-1);
|
||
|
|
var $3039=((($3038)+(1))|0);
|
||
|
|
var $3040=$prevline;
|
||
|
|
var $3041=(($3040+$3039)|0);
|
||
|
|
var $3042=HEAP8[($3041)];
|
||
|
|
var $3043=($3042&255);
|
||
|
|
var $3044=(($mix+1)|0);
|
||
|
|
var $3045=HEAP8[($3044)];
|
||
|
|
var $3046=($3045&255);
|
||
|
|
var $3047=$3043^$3046;
|
||
|
|
var $3048=(($3047)&255);
|
||
|
|
var $3049=$x;
|
||
|
|
var $3050=((($3049)*(3))&-1);
|
||
|
|
var $3051=((($3050)+(1))|0);
|
||
|
|
var $3052=$line;
|
||
|
|
var $3053=(($3052+$3051)|0);
|
||
|
|
HEAP8[($3053)]=$3048;
|
||
|
|
var $3054=$x;
|
||
|
|
var $3055=((($3054)*(3))&-1);
|
||
|
|
var $3056=((($3055)+(2))|0);
|
||
|
|
var $3057=$prevline;
|
||
|
|
var $3058=(($3057+$3056)|0);
|
||
|
|
var $3059=HEAP8[($3058)];
|
||
|
|
var $3060=($3059&255);
|
||
|
|
var $3061=(($mix+2)|0);
|
||
|
|
var $3062=HEAP8[($3061)];
|
||
|
|
var $3063=($3062&255);
|
||
|
|
var $3064=$3060^$3063;
|
||
|
|
var $3065=(($3064)&255);
|
||
|
|
var $3066=$x;
|
||
|
|
var $3067=((($3066)*(3))&-1);
|
||
|
|
var $3068=((($3067)+(2))|0);
|
||
|
|
var $3069=$line;
|
||
|
|
var $3070=(($3069+$3068)|0);
|
||
|
|
HEAP8[($3070)]=$3065;
|
||
|
|
label=245;break;
|
||
|
|
case 244:
|
||
|
|
var $3072=$x;
|
||
|
|
var $3073=((($3072)*(3))&-1);
|
||
|
|
var $3074=$prevline;
|
||
|
|
var $3075=(($3074+$3073)|0);
|
||
|
|
var $3076=HEAP8[($3075)];
|
||
|
|
var $3077=$x;
|
||
|
|
var $3078=((($3077)*(3))&-1);
|
||
|
|
var $3079=$line;
|
||
|
|
var $3080=(($3079+$3078)|0);
|
||
|
|
HEAP8[($3080)]=$3076;
|
||
|
|
var $3081=$x;
|
||
|
|
var $3082=((($3081)*(3))&-1);
|
||
|
|
var $3083=((($3082)+(1))|0);
|
||
|
|
var $3084=$prevline;
|
||
|
|
var $3085=(($3084+$3083)|0);
|
||
|
|
var $3086=HEAP8[($3085)];
|
||
|
|
var $3087=$x;
|
||
|
|
var $3088=((($3087)*(3))&-1);
|
||
|
|
var $3089=((($3088)+(1))|0);
|
||
|
|
var $3090=$line;
|
||
|
|
var $3091=(($3090+$3089)|0);
|
||
|
|
HEAP8[($3091)]=$3086;
|
||
|
|
var $3092=$x;
|
||
|
|
var $3093=((($3092)*(3))&-1);
|
||
|
|
var $3094=((($3093)+(2))|0);
|
||
|
|
var $3095=$prevline;
|
||
|
|
var $3096=(($3095+$3094)|0);
|
||
|
|
var $3097=HEAP8[($3096)];
|
||
|
|
var $3098=$x;
|
||
|
|
var $3099=((($3098)*(3))&-1);
|
||
|
|
var $3100=((($3099)+(2))|0);
|
||
|
|
var $3101=$line;
|
||
|
|
var $3102=(($3101+$3100)|0);
|
||
|
|
HEAP8[($3102)]=$3097;
|
||
|
|
label=245;break;
|
||
|
|
case 245:
|
||
|
|
var $3104=$count;
|
||
|
|
var $3105=((($3104)-(1))|0);
|
||
|
|
$count=$3105;
|
||
|
|
var $3106=$x;
|
||
|
|
var $3107=((($3106)+(1))|0);
|
||
|
|
$x=$3107;
|
||
|
|
label=178;break;
|
||
|
|
case 246:
|
||
|
|
label=247;break;
|
||
|
|
case 247:
|
||
|
|
var $3110=$count;
|
||
|
|
var $3111=($3110|0)>0;
|
||
|
|
if($3111){label=248;break;}else{var $3117=0;label=249;break;}
|
||
|
|
case 248:
|
||
|
|
var $3113=$x;
|
||
|
|
var $3114=$3;
|
||
|
|
var $3115=($3113|0)<($3114|0);
|
||
|
|
var $3117=$3115;label=249;break;
|
||
|
|
case 249:
|
||
|
|
var $3117;
|
||
|
|
if($3117){label=250;break;}else{label=259;break;}
|
||
|
|
case 250:
|
||
|
|
var $3119=$mixmask;
|
||
|
|
var $3120=($3119&255);
|
||
|
|
var $3121=$3120<<1;
|
||
|
|
var $3122=(($3121)&255);
|
||
|
|
$mixmask=$3122;
|
||
|
|
var $3123=$mixmask;
|
||
|
|
var $3124=($3123&255);
|
||
|
|
var $3125=($3124|0)==0;
|
||
|
|
if($3125){label=251;break;}else{label=255;break;}
|
||
|
|
case 251:
|
||
|
|
var $3127=$fom_mask;
|
||
|
|
var $3128=($3127|0)!=0;
|
||
|
|
if($3128){label=252;break;}else{label=253;break;}
|
||
|
|
case 252:
|
||
|
|
var $3130=$fom_mask;
|
||
|
|
var $3137=$3130;label=254;break;
|
||
|
|
case 253:
|
||
|
|
var $3132=$5;
|
||
|
|
var $3133=(($3132+1)|0);
|
||
|
|
$5=$3133;
|
||
|
|
var $3134=HEAP8[($3132)];
|
||
|
|
var $3135=($3134&255);
|
||
|
|
var $3137=$3135;label=254;break;
|
||
|
|
case 254:
|
||
|
|
var $3137;
|
||
|
|
var $3138=(($3137)&255);
|
||
|
|
$mask=$3138;
|
||
|
|
$mixmask=1;
|
||
|
|
label=255;break;
|
||
|
|
case 255:
|
||
|
|
var $3140=$mask;
|
||
|
|
var $3141=($3140&255);
|
||
|
|
var $3142=$mixmask;
|
||
|
|
var $3143=($3142&255);
|
||
|
|
var $3144=$3141&$3143;
|
||
|
|
var $3145=($3144|0)!=0;
|
||
|
|
if($3145){label=256;break;}else{label=257;break;}
|
||
|
|
case 256:
|
||
|
|
var $3147=$x;
|
||
|
|
var $3148=((($3147)*(3))&-1);
|
||
|
|
var $3149=$prevline;
|
||
|
|
var $3150=(($3149+$3148)|0);
|
||
|
|
var $3151=HEAP8[($3150)];
|
||
|
|
var $3152=($3151&255);
|
||
|
|
var $3153=(($mix)|0);
|
||
|
|
var $3154=HEAP8[($3153)];
|
||
|
|
var $3155=($3154&255);
|
||
|
|
var $3156=$3152^$3155;
|
||
|
|
var $3157=(($3156)&255);
|
||
|
|
var $3158=$x;
|
||
|
|
var $3159=((($3158)*(3))&-1);
|
||
|
|
var $3160=$line;
|
||
|
|
var $3161=(($3160+$3159)|0);
|
||
|
|
HEAP8[($3161)]=$3157;
|
||
|
|
var $3162=$x;
|
||
|
|
var $3163=((($3162)*(3))&-1);
|
||
|
|
var $3164=((($3163)+(1))|0);
|
||
|
|
var $3165=$prevline;
|
||
|
|
var $3166=(($3165+$3164)|0);
|
||
|
|
var $3167=HEAP8[($3166)];
|
||
|
|
var $3168=($3167&255);
|
||
|
|
var $3169=(($mix+1)|0);
|
||
|
|
var $3170=HEAP8[($3169)];
|
||
|
|
var $3171=($3170&255);
|
||
|
|
var $3172=$3168^$3171;
|
||
|
|
var $3173=(($3172)&255);
|
||
|
|
var $3174=$x;
|
||
|
|
var $3175=((($3174)*(3))&-1);
|
||
|
|
var $3176=((($3175)+(1))|0);
|
||
|
|
var $3177=$line;
|
||
|
|
var $3178=(($3177+$3176)|0);
|
||
|
|
HEAP8[($3178)]=$3173;
|
||
|
|
var $3179=$x;
|
||
|
|
var $3180=((($3179)*(3))&-1);
|
||
|
|
var $3181=((($3180)+(2))|0);
|
||
|
|
var $3182=$prevline;
|
||
|
|
var $3183=(($3182+$3181)|0);
|
||
|
|
var $3184=HEAP8[($3183)];
|
||
|
|
var $3185=($3184&255);
|
||
|
|
var $3186=(($mix+2)|0);
|
||
|
|
var $3187=HEAP8[($3186)];
|
||
|
|
var $3188=($3187&255);
|
||
|
|
var $3189=$3185^$3188;
|
||
|
|
var $3190=(($3189)&255);
|
||
|
|
var $3191=$x;
|
||
|
|
var $3192=((($3191)*(3))&-1);
|
||
|
|
var $3193=((($3192)+(2))|0);
|
||
|
|
var $3194=$line;
|
||
|
|
var $3195=(($3194+$3193)|0);
|
||
|
|
HEAP8[($3195)]=$3190;
|
||
|
|
label=258;break;
|
||
|
|
case 257:
|
||
|
|
var $3197=$x;
|
||
|
|
var $3198=((($3197)*(3))&-1);
|
||
|
|
var $3199=$prevline;
|
||
|
|
var $3200=(($3199+$3198)|0);
|
||
|
|
var $3201=HEAP8[($3200)];
|
||
|
|
var $3202=$x;
|
||
|
|
var $3203=((($3202)*(3))&-1);
|
||
|
|
var $3204=$line;
|
||
|
|
var $3205=(($3204+$3203)|0);
|
||
|
|
HEAP8[($3205)]=$3201;
|
||
|
|
var $3206=$x;
|
||
|
|
var $3207=((($3206)*(3))&-1);
|
||
|
|
var $3208=((($3207)+(1))|0);
|
||
|
|
var $3209=$prevline;
|
||
|
|
var $3210=(($3209+$3208)|0);
|
||
|
|
var $3211=HEAP8[($3210)];
|
||
|
|
var $3212=$x;
|
||
|
|
var $3213=((($3212)*(3))&-1);
|
||
|
|
var $3214=((($3213)+(1))|0);
|
||
|
|
var $3215=$line;
|
||
|
|
var $3216=(($3215+$3214)|0);
|
||
|
|
HEAP8[($3216)]=$3211;
|
||
|
|
var $3217=$x;
|
||
|
|
var $3218=((($3217)*(3))&-1);
|
||
|
|
var $3219=((($3218)+(2))|0);
|
||
|
|
var $3220=$prevline;
|
||
|
|
var $3221=(($3220+$3219)|0);
|
||
|
|
var $3222=HEAP8[($3221)];
|
||
|
|
var $3223=$x;
|
||
|
|
var $3224=((($3223)*(3))&-1);
|
||
|
|
var $3225=((($3224)+(2))|0);
|
||
|
|
var $3226=$line;
|
||
|
|
var $3227=(($3226+$3225)|0);
|
||
|
|
HEAP8[($3227)]=$3222;
|
||
|
|
label=258;break;
|
||
|
|
case 258:
|
||
|
|
var $3229=$count;
|
||
|
|
var $3230=((($3229)-(1))|0);
|
||
|
|
$count=$3230;
|
||
|
|
var $3231=$x;
|
||
|
|
var $3232=((($3231)+(1))|0);
|
||
|
|
$x=$3232;
|
||
|
|
label=247;break;
|
||
|
|
case 259:
|
||
|
|
label=260;break;
|
||
|
|
case 260:
|
||
|
|
label=344;break;
|
||
|
|
case 261:
|
||
|
|
label=262;break;
|
||
|
|
case 262:
|
||
|
|
var $3237=$count;
|
||
|
|
var $3238=$3237&-8;
|
||
|
|
var $3239=($3238|0)!=0;
|
||
|
|
if($3239){label=263;break;}else{var $3246=0;label=264;break;}
|
||
|
|
case 263:
|
||
|
|
var $3241=$x;
|
||
|
|
var $3242=((($3241)+(8))|0);
|
||
|
|
var $3243=$3;
|
||
|
|
var $3244=($3242|0)<($3243|0);
|
||
|
|
var $3246=$3244;label=264;break;
|
||
|
|
case 264:
|
||
|
|
var $3246;
|
||
|
|
if($3246){label=265;break;}else{label=266;break;}
|
||
|
|
case 265:
|
||
|
|
var $3248=(($colour2)|0);
|
||
|
|
var $3249=HEAP8[($3248)];
|
||
|
|
var $3250=$x;
|
||
|
|
var $3251=((($3250)*(3))&-1);
|
||
|
|
var $3252=$line;
|
||
|
|
var $3253=(($3252+$3251)|0);
|
||
|
|
HEAP8[($3253)]=$3249;
|
||
|
|
var $3254=(($colour2+1)|0);
|
||
|
|
var $3255=HEAP8[($3254)];
|
||
|
|
var $3256=$x;
|
||
|
|
var $3257=((($3256)*(3))&-1);
|
||
|
|
var $3258=((($3257)+(1))|0);
|
||
|
|
var $3259=$line;
|
||
|
|
var $3260=(($3259+$3258)|0);
|
||
|
|
HEAP8[($3260)]=$3255;
|
||
|
|
var $3261=(($colour2+2)|0);
|
||
|
|
var $3262=HEAP8[($3261)];
|
||
|
|
var $3263=$x;
|
||
|
|
var $3264=((($3263)*(3))&-1);
|
||
|
|
var $3265=((($3264)+(2))|0);
|
||
|
|
var $3266=$line;
|
||
|
|
var $3267=(($3266+$3265)|0);
|
||
|
|
HEAP8[($3267)]=$3262;
|
||
|
|
var $3268=$count;
|
||
|
|
var $3269=((($3268)-(1))|0);
|
||
|
|
$count=$3269;
|
||
|
|
var $3270=$x;
|
||
|
|
var $3271=((($3270)+(1))|0);
|
||
|
|
$x=$3271;
|
||
|
|
var $3272=(($colour2)|0);
|
||
|
|
var $3273=HEAP8[($3272)];
|
||
|
|
var $3274=$x;
|
||
|
|
var $3275=((($3274)*(3))&-1);
|
||
|
|
var $3276=$line;
|
||
|
|
var $3277=(($3276+$3275)|0);
|
||
|
|
HEAP8[($3277)]=$3273;
|
||
|
|
var $3278=(($colour2+1)|0);
|
||
|
|
var $3279=HEAP8[($3278)];
|
||
|
|
var $3280=$x;
|
||
|
|
var $3281=((($3280)*(3))&-1);
|
||
|
|
var $3282=((($3281)+(1))|0);
|
||
|
|
var $3283=$line;
|
||
|
|
var $3284=(($3283+$3282)|0);
|
||
|
|
HEAP8[($3284)]=$3279;
|
||
|
|
var $3285=(($colour2+2)|0);
|
||
|
|
var $3286=HEAP8[($3285)];
|
||
|
|
var $3287=$x;
|
||
|
|
var $3288=((($3287)*(3))&-1);
|
||
|
|
var $3289=((($3288)+(2))|0);
|
||
|
|
var $3290=$line;
|
||
|
|
var $3291=(($3290+$3289)|0);
|
||
|
|
HEAP8[($3291)]=$3286;
|
||
|
|
var $3292=$count;
|
||
|
|
var $3293=((($3292)-(1))|0);
|
||
|
|
$count=$3293;
|
||
|
|
var $3294=$x;
|
||
|
|
var $3295=((($3294)+(1))|0);
|
||
|
|
$x=$3295;
|
||
|
|
var $3296=(($colour2)|0);
|
||
|
|
var $3297=HEAP8[($3296)];
|
||
|
|
var $3298=$x;
|
||
|
|
var $3299=((($3298)*(3))&-1);
|
||
|
|
var $3300=$line;
|
||
|
|
var $3301=(($3300+$3299)|0);
|
||
|
|
HEAP8[($3301)]=$3297;
|
||
|
|
var $3302=(($colour2+1)|0);
|
||
|
|
var $3303=HEAP8[($3302)];
|
||
|
|
var $3304=$x;
|
||
|
|
var $3305=((($3304)*(3))&-1);
|
||
|
|
var $3306=((($3305)+(1))|0);
|
||
|
|
var $3307=$line;
|
||
|
|
var $3308=(($3307+$3306)|0);
|
||
|
|
HEAP8[($3308)]=$3303;
|
||
|
|
var $3309=(($colour2+2)|0);
|
||
|
|
var $3310=HEAP8[($3309)];
|
||
|
|
var $3311=$x;
|
||
|
|
var $3312=((($3311)*(3))&-1);
|
||
|
|
var $3313=((($3312)+(2))|0);
|
||
|
|
var $3314=$line;
|
||
|
|
var $3315=(($3314+$3313)|0);
|
||
|
|
HEAP8[($3315)]=$3310;
|
||
|
|
var $3316=$count;
|
||
|
|
var $3317=((($3316)-(1))|0);
|
||
|
|
$count=$3317;
|
||
|
|
var $3318=$x;
|
||
|
|
var $3319=((($3318)+(1))|0);
|
||
|
|
$x=$3319;
|
||
|
|
var $3320=(($colour2)|0);
|
||
|
|
var $3321=HEAP8[($3320)];
|
||
|
|
var $3322=$x;
|
||
|
|
var $3323=((($3322)*(3))&-1);
|
||
|
|
var $3324=$line;
|
||
|
|
var $3325=(($3324+$3323)|0);
|
||
|
|
HEAP8[($3325)]=$3321;
|
||
|
|
var $3326=(($colour2+1)|0);
|
||
|
|
var $3327=HEAP8[($3326)];
|
||
|
|
var $3328=$x;
|
||
|
|
var $3329=((($3328)*(3))&-1);
|
||
|
|
var $3330=((($3329)+(1))|0);
|
||
|
|
var $3331=$line;
|
||
|
|
var $3332=(($3331+$3330)|0);
|
||
|
|
HEAP8[($3332)]=$3327;
|
||
|
|
var $3333=(($colour2+2)|0);
|
||
|
|
var $3334=HEAP8[($3333)];
|
||
|
|
var $3335=$x;
|
||
|
|
var $3336=((($3335)*(3))&-1);
|
||
|
|
var $3337=((($3336)+(2))|0);
|
||
|
|
var $3338=$line;
|
||
|
|
var $3339=(($3338+$3337)|0);
|
||
|
|
HEAP8[($3339)]=$3334;
|
||
|
|
var $3340=$count;
|
||
|
|
var $3341=((($3340)-(1))|0);
|
||
|
|
$count=$3341;
|
||
|
|
var $3342=$x;
|
||
|
|
var $3343=((($3342)+(1))|0);
|
||
|
|
$x=$3343;
|
||
|
|
var $3344=(($colour2)|0);
|
||
|
|
var $3345=HEAP8[($3344)];
|
||
|
|
var $3346=$x;
|
||
|
|
var $3347=((($3346)*(3))&-1);
|
||
|
|
var $3348=$line;
|
||
|
|
var $3349=(($3348+$3347)|0);
|
||
|
|
HEAP8[($3349)]=$3345;
|
||
|
|
var $3350=(($colour2+1)|0);
|
||
|
|
var $3351=HEAP8[($3350)];
|
||
|
|
var $3352=$x;
|
||
|
|
var $3353=((($3352)*(3))&-1);
|
||
|
|
var $3354=((($3353)+(1))|0);
|
||
|
|
var $3355=$line;
|
||
|
|
var $3356=(($3355+$3354)|0);
|
||
|
|
HEAP8[($3356)]=$3351;
|
||
|
|
var $3357=(($colour2+2)|0);
|
||
|
|
var $3358=HEAP8[($3357)];
|
||
|
|
var $3359=$x;
|
||
|
|
var $3360=((($3359)*(3))&-1);
|
||
|
|
var $3361=((($3360)+(2))|0);
|
||
|
|
var $3362=$line;
|
||
|
|
var $3363=(($3362+$3361)|0);
|
||
|
|
HEAP8[($3363)]=$3358;
|
||
|
|
var $3364=$count;
|
||
|
|
var $3365=((($3364)-(1))|0);
|
||
|
|
$count=$3365;
|
||
|
|
var $3366=$x;
|
||
|
|
var $3367=((($3366)+(1))|0);
|
||
|
|
$x=$3367;
|
||
|
|
var $3368=(($colour2)|0);
|
||
|
|
var $3369=HEAP8[($3368)];
|
||
|
|
var $3370=$x;
|
||
|
|
var $3371=((($3370)*(3))&-1);
|
||
|
|
var $3372=$line;
|
||
|
|
var $3373=(($3372+$3371)|0);
|
||
|
|
HEAP8[($3373)]=$3369;
|
||
|
|
var $3374=(($colour2+1)|0);
|
||
|
|
var $3375=HEAP8[($3374)];
|
||
|
|
var $3376=$x;
|
||
|
|
var $3377=((($3376)*(3))&-1);
|
||
|
|
var $3378=((($3377)+(1))|0);
|
||
|
|
var $3379=$line;
|
||
|
|
var $3380=(($3379+$3378)|0);
|
||
|
|
HEAP8[($3380)]=$3375;
|
||
|
|
var $3381=(($colour2+2)|0);
|
||
|
|
var $3382=HEAP8[($3381)];
|
||
|
|
var $3383=$x;
|
||
|
|
var $3384=((($3383)*(3))&-1);
|
||
|
|
var $3385=((($3384)+(2))|0);
|
||
|
|
var $3386=$line;
|
||
|
|
var $3387=(($3386+$3385)|0);
|
||
|
|
HEAP8[($3387)]=$3382;
|
||
|
|
var $3388=$count;
|
||
|
|
var $3389=((($3388)-(1))|0);
|
||
|
|
$count=$3389;
|
||
|
|
var $3390=$x;
|
||
|
|
var $3391=((($3390)+(1))|0);
|
||
|
|
$x=$3391;
|
||
|
|
var $3392=(($colour2)|0);
|
||
|
|
var $3393=HEAP8[($3392)];
|
||
|
|
var $3394=$x;
|
||
|
|
var $3395=((($3394)*(3))&-1);
|
||
|
|
var $3396=$line;
|
||
|
|
var $3397=(($3396+$3395)|0);
|
||
|
|
HEAP8[($3397)]=$3393;
|
||
|
|
var $3398=(($colour2+1)|0);
|
||
|
|
var $3399=HEAP8[($3398)];
|
||
|
|
var $3400=$x;
|
||
|
|
var $3401=((($3400)*(3))&-1);
|
||
|
|
var $3402=((($3401)+(1))|0);
|
||
|
|
var $3403=$line;
|
||
|
|
var $3404=(($3403+$3402)|0);
|
||
|
|
HEAP8[($3404)]=$3399;
|
||
|
|
var $3405=(($colour2+2)|0);
|
||
|
|
var $3406=HEAP8[($3405)];
|
||
|
|
var $3407=$x;
|
||
|
|
var $3408=((($3407)*(3))&-1);
|
||
|
|
var $3409=((($3408)+(2))|0);
|
||
|
|
var $3410=$line;
|
||
|
|
var $3411=(($3410+$3409)|0);
|
||
|
|
HEAP8[($3411)]=$3406;
|
||
|
|
var $3412=$count;
|
||
|
|
var $3413=((($3412)-(1))|0);
|
||
|
|
$count=$3413;
|
||
|
|
var $3414=$x;
|
||
|
|
var $3415=((($3414)+(1))|0);
|
||
|
|
$x=$3415;
|
||
|
|
var $3416=(($colour2)|0);
|
||
|
|
var $3417=HEAP8[($3416)];
|
||
|
|
var $3418=$x;
|
||
|
|
var $3419=((($3418)*(3))&-1);
|
||
|
|
var $3420=$line;
|
||
|
|
var $3421=(($3420+$3419)|0);
|
||
|
|
HEAP8[($3421)]=$3417;
|
||
|
|
var $3422=(($colour2+1)|0);
|
||
|
|
var $3423=HEAP8[($3422)];
|
||
|
|
var $3424=$x;
|
||
|
|
var $3425=((($3424)*(3))&-1);
|
||
|
|
var $3426=((($3425)+(1))|0);
|
||
|
|
var $3427=$line;
|
||
|
|
var $3428=(($3427+$3426)|0);
|
||
|
|
HEAP8[($3428)]=$3423;
|
||
|
|
var $3429=(($colour2+2)|0);
|
||
|
|
var $3430=HEAP8[($3429)];
|
||
|
|
var $3431=$x;
|
||
|
|
var $3432=((($3431)*(3))&-1);
|
||
|
|
var $3433=((($3432)+(2))|0);
|
||
|
|
var $3434=$line;
|
||
|
|
var $3435=(($3434+$3433)|0);
|
||
|
|
HEAP8[($3435)]=$3430;
|
||
|
|
var $3436=$count;
|
||
|
|
var $3437=((($3436)-(1))|0);
|
||
|
|
$count=$3437;
|
||
|
|
var $3438=$x;
|
||
|
|
var $3439=((($3438)+(1))|0);
|
||
|
|
$x=$3439;
|
||
|
|
label=262;break;
|
||
|
|
case 266:
|
||
|
|
label=267;break;
|
||
|
|
case 267:
|
||
|
|
var $3442=$count;
|
||
|
|
var $3443=($3442|0)>0;
|
||
|
|
if($3443){label=268;break;}else{var $3449=0;label=269;break;}
|
||
|
|
case 268:
|
||
|
|
var $3445=$x;
|
||
|
|
var $3446=$3;
|
||
|
|
var $3447=($3445|0)<($3446|0);
|
||
|
|
var $3449=$3447;label=269;break;
|
||
|
|
case 269:
|
||
|
|
var $3449;
|
||
|
|
if($3449){label=270;break;}else{label=271;break;}
|
||
|
|
case 270:
|
||
|
|
var $3451=(($colour2)|0);
|
||
|
|
var $3452=HEAP8[($3451)];
|
||
|
|
var $3453=$x;
|
||
|
|
var $3454=((($3453)*(3))&-1);
|
||
|
|
var $3455=$line;
|
||
|
|
var $3456=(($3455+$3454)|0);
|
||
|
|
HEAP8[($3456)]=$3452;
|
||
|
|
var $3457=(($colour2+1)|0);
|
||
|
|
var $3458=HEAP8[($3457)];
|
||
|
|
var $3459=$x;
|
||
|
|
var $3460=((($3459)*(3))&-1);
|
||
|
|
var $3461=((($3460)+(1))|0);
|
||
|
|
var $3462=$line;
|
||
|
|
var $3463=(($3462+$3461)|0);
|
||
|
|
HEAP8[($3463)]=$3458;
|
||
|
|
var $3464=(($colour2+2)|0);
|
||
|
|
var $3465=HEAP8[($3464)];
|
||
|
|
var $3466=$x;
|
||
|
|
var $3467=((($3466)*(3))&-1);
|
||
|
|
var $3468=((($3467)+(2))|0);
|
||
|
|
var $3469=$line;
|
||
|
|
var $3470=(($3469+$3468)|0);
|
||
|
|
HEAP8[($3470)]=$3465;
|
||
|
|
var $3471=$count;
|
||
|
|
var $3472=((($3471)-(1))|0);
|
||
|
|
$count=$3472;
|
||
|
|
var $3473=$x;
|
||
|
|
var $3474=((($3473)+(1))|0);
|
||
|
|
$x=$3474;
|
||
|
|
label=267;break;
|
||
|
|
case 271:
|
||
|
|
label=344;break;
|
||
|
|
case 272:
|
||
|
|
label=273;break;
|
||
|
|
case 273:
|
||
|
|
var $3478=$count;
|
||
|
|
var $3479=$3478&-8;
|
||
|
|
var $3480=($3479|0)!=0;
|
||
|
|
if($3480){label=274;break;}else{var $3487=0;label=275;break;}
|
||
|
|
case 274:
|
||
|
|
var $3482=$x;
|
||
|
|
var $3483=((($3482)+(8))|0);
|
||
|
|
var $3484=$3;
|
||
|
|
var $3485=($3483|0)<($3484|0);
|
||
|
|
var $3487=$3485;label=275;break;
|
||
|
|
case 275:
|
||
|
|
var $3487;
|
||
|
|
if($3487){label=276;break;}else{label=277;break;}
|
||
|
|
case 276:
|
||
|
|
var $3489=$5;
|
||
|
|
var $3490=(($3489+1)|0);
|
||
|
|
$5=$3490;
|
||
|
|
var $3491=HEAP8[($3489)];
|
||
|
|
var $3492=$x;
|
||
|
|
var $3493=((($3492)*(3))&-1);
|
||
|
|
var $3494=$line;
|
||
|
|
var $3495=(($3494+$3493)|0);
|
||
|
|
HEAP8[($3495)]=$3491;
|
||
|
|
var $3496=$5;
|
||
|
|
var $3497=(($3496+1)|0);
|
||
|
|
$5=$3497;
|
||
|
|
var $3498=HEAP8[($3496)];
|
||
|
|
var $3499=$x;
|
||
|
|
var $3500=((($3499)*(3))&-1);
|
||
|
|
var $3501=((($3500)+(1))|0);
|
||
|
|
var $3502=$line;
|
||
|
|
var $3503=(($3502+$3501)|0);
|
||
|
|
HEAP8[($3503)]=$3498;
|
||
|
|
var $3504=$5;
|
||
|
|
var $3505=(($3504+1)|0);
|
||
|
|
$5=$3505;
|
||
|
|
var $3506=HEAP8[($3504)];
|
||
|
|
var $3507=$x;
|
||
|
|
var $3508=((($3507)*(3))&-1);
|
||
|
|
var $3509=((($3508)+(2))|0);
|
||
|
|
var $3510=$line;
|
||
|
|
var $3511=(($3510+$3509)|0);
|
||
|
|
HEAP8[($3511)]=$3506;
|
||
|
|
var $3512=$count;
|
||
|
|
var $3513=((($3512)-(1))|0);
|
||
|
|
$count=$3513;
|
||
|
|
var $3514=$x;
|
||
|
|
var $3515=((($3514)+(1))|0);
|
||
|
|
$x=$3515;
|
||
|
|
var $3516=$5;
|
||
|
|
var $3517=(($3516+1)|0);
|
||
|
|
$5=$3517;
|
||
|
|
var $3518=HEAP8[($3516)];
|
||
|
|
var $3519=$x;
|
||
|
|
var $3520=((($3519)*(3))&-1);
|
||
|
|
var $3521=$line;
|
||
|
|
var $3522=(($3521+$3520)|0);
|
||
|
|
HEAP8[($3522)]=$3518;
|
||
|
|
var $3523=$5;
|
||
|
|
var $3524=(($3523+1)|0);
|
||
|
|
$5=$3524;
|
||
|
|
var $3525=HEAP8[($3523)];
|
||
|
|
var $3526=$x;
|
||
|
|
var $3527=((($3526)*(3))&-1);
|
||
|
|
var $3528=((($3527)+(1))|0);
|
||
|
|
var $3529=$line;
|
||
|
|
var $3530=(($3529+$3528)|0);
|
||
|
|
HEAP8[($3530)]=$3525;
|
||
|
|
var $3531=$5;
|
||
|
|
var $3532=(($3531+1)|0);
|
||
|
|
$5=$3532;
|
||
|
|
var $3533=HEAP8[($3531)];
|
||
|
|
var $3534=$x;
|
||
|
|
var $3535=((($3534)*(3))&-1);
|
||
|
|
var $3536=((($3535)+(2))|0);
|
||
|
|
var $3537=$line;
|
||
|
|
var $3538=(($3537+$3536)|0);
|
||
|
|
HEAP8[($3538)]=$3533;
|
||
|
|
var $3539=$count;
|
||
|
|
var $3540=((($3539)-(1))|0);
|
||
|
|
$count=$3540;
|
||
|
|
var $3541=$x;
|
||
|
|
var $3542=((($3541)+(1))|0);
|
||
|
|
$x=$3542;
|
||
|
|
var $3543=$5;
|
||
|
|
var $3544=(($3543+1)|0);
|
||
|
|
$5=$3544;
|
||
|
|
var $3545=HEAP8[($3543)];
|
||
|
|
var $3546=$x;
|
||
|
|
var $3547=((($3546)*(3))&-1);
|
||
|
|
var $3548=$line;
|
||
|
|
var $3549=(($3548+$3547)|0);
|
||
|
|
HEAP8[($3549)]=$3545;
|
||
|
|
var $3550=$5;
|
||
|
|
var $3551=(($3550+1)|0);
|
||
|
|
$5=$3551;
|
||
|
|
var $3552=HEAP8[($3550)];
|
||
|
|
var $3553=$x;
|
||
|
|
var $3554=((($3553)*(3))&-1);
|
||
|
|
var $3555=((($3554)+(1))|0);
|
||
|
|
var $3556=$line;
|
||
|
|
var $3557=(($3556+$3555)|0);
|
||
|
|
HEAP8[($3557)]=$3552;
|
||
|
|
var $3558=$5;
|
||
|
|
var $3559=(($3558+1)|0);
|
||
|
|
$5=$3559;
|
||
|
|
var $3560=HEAP8[($3558)];
|
||
|
|
var $3561=$x;
|
||
|
|
var $3562=((($3561)*(3))&-1);
|
||
|
|
var $3563=((($3562)+(2))|0);
|
||
|
|
var $3564=$line;
|
||
|
|
var $3565=(($3564+$3563)|0);
|
||
|
|
HEAP8[($3565)]=$3560;
|
||
|
|
var $3566=$count;
|
||
|
|
var $3567=((($3566)-(1))|0);
|
||
|
|
$count=$3567;
|
||
|
|
var $3568=$x;
|
||
|
|
var $3569=((($3568)+(1))|0);
|
||
|
|
$x=$3569;
|
||
|
|
var $3570=$5;
|
||
|
|
var $3571=(($3570+1)|0);
|
||
|
|
$5=$3571;
|
||
|
|
var $3572=HEAP8[($3570)];
|
||
|
|
var $3573=$x;
|
||
|
|
var $3574=((($3573)*(3))&-1);
|
||
|
|
var $3575=$line;
|
||
|
|
var $3576=(($3575+$3574)|0);
|
||
|
|
HEAP8[($3576)]=$3572;
|
||
|
|
var $3577=$5;
|
||
|
|
var $3578=(($3577+1)|0);
|
||
|
|
$5=$3578;
|
||
|
|
var $3579=HEAP8[($3577)];
|
||
|
|
var $3580=$x;
|
||
|
|
var $3581=((($3580)*(3))&-1);
|
||
|
|
var $3582=((($3581)+(1))|0);
|
||
|
|
var $3583=$line;
|
||
|
|
var $3584=(($3583+$3582)|0);
|
||
|
|
HEAP8[($3584)]=$3579;
|
||
|
|
var $3585=$5;
|
||
|
|
var $3586=(($3585+1)|0);
|
||
|
|
$5=$3586;
|
||
|
|
var $3587=HEAP8[($3585)];
|
||
|
|
var $3588=$x;
|
||
|
|
var $3589=((($3588)*(3))&-1);
|
||
|
|
var $3590=((($3589)+(2))|0);
|
||
|
|
var $3591=$line;
|
||
|
|
var $3592=(($3591+$3590)|0);
|
||
|
|
HEAP8[($3592)]=$3587;
|
||
|
|
var $3593=$count;
|
||
|
|
var $3594=((($3593)-(1))|0);
|
||
|
|
$count=$3594;
|
||
|
|
var $3595=$x;
|
||
|
|
var $3596=((($3595)+(1))|0);
|
||
|
|
$x=$3596;
|
||
|
|
var $3597=$5;
|
||
|
|
var $3598=(($3597+1)|0);
|
||
|
|
$5=$3598;
|
||
|
|
var $3599=HEAP8[($3597)];
|
||
|
|
var $3600=$x;
|
||
|
|
var $3601=((($3600)*(3))&-1);
|
||
|
|
var $3602=$line;
|
||
|
|
var $3603=(($3602+$3601)|0);
|
||
|
|
HEAP8[($3603)]=$3599;
|
||
|
|
var $3604=$5;
|
||
|
|
var $3605=(($3604+1)|0);
|
||
|
|
$5=$3605;
|
||
|
|
var $3606=HEAP8[($3604)];
|
||
|
|
var $3607=$x;
|
||
|
|
var $3608=((($3607)*(3))&-1);
|
||
|
|
var $3609=((($3608)+(1))|0);
|
||
|
|
var $3610=$line;
|
||
|
|
var $3611=(($3610+$3609)|0);
|
||
|
|
HEAP8[($3611)]=$3606;
|
||
|
|
var $3612=$5;
|
||
|
|
var $3613=(($3612+1)|0);
|
||
|
|
$5=$3613;
|
||
|
|
var $3614=HEAP8[($3612)];
|
||
|
|
var $3615=$x;
|
||
|
|
var $3616=((($3615)*(3))&-1);
|
||
|
|
var $3617=((($3616)+(2))|0);
|
||
|
|
var $3618=$line;
|
||
|
|
var $3619=(($3618+$3617)|0);
|
||
|
|
HEAP8[($3619)]=$3614;
|
||
|
|
var $3620=$count;
|
||
|
|
var $3621=((($3620)-(1))|0);
|
||
|
|
$count=$3621;
|
||
|
|
var $3622=$x;
|
||
|
|
var $3623=((($3622)+(1))|0);
|
||
|
|
$x=$3623;
|
||
|
|
var $3624=$5;
|
||
|
|
var $3625=(($3624+1)|0);
|
||
|
|
$5=$3625;
|
||
|
|
var $3626=HEAP8[($3624)];
|
||
|
|
var $3627=$x;
|
||
|
|
var $3628=((($3627)*(3))&-1);
|
||
|
|
var $3629=$line;
|
||
|
|
var $3630=(($3629+$3628)|0);
|
||
|
|
HEAP8[($3630)]=$3626;
|
||
|
|
var $3631=$5;
|
||
|
|
var $3632=(($3631+1)|0);
|
||
|
|
$5=$3632;
|
||
|
|
var $3633=HEAP8[($3631)];
|
||
|
|
var $3634=$x;
|
||
|
|
var $3635=((($3634)*(3))&-1);
|
||
|
|
var $3636=((($3635)+(1))|0);
|
||
|
|
var $3637=$line;
|
||
|
|
var $3638=(($3637+$3636)|0);
|
||
|
|
HEAP8[($3638)]=$3633;
|
||
|
|
var $3639=$5;
|
||
|
|
var $3640=(($3639+1)|0);
|
||
|
|
$5=$3640;
|
||
|
|
var $3641=HEAP8[($3639)];
|
||
|
|
var $3642=$x;
|
||
|
|
var $3643=((($3642)*(3))&-1);
|
||
|
|
var $3644=((($3643)+(2))|0);
|
||
|
|
var $3645=$line;
|
||
|
|
var $3646=(($3645+$3644)|0);
|
||
|
|
HEAP8[($3646)]=$3641;
|
||
|
|
var $3647=$count;
|
||
|
|
var $3648=((($3647)-(1))|0);
|
||
|
|
$count=$3648;
|
||
|
|
var $3649=$x;
|
||
|
|
var $3650=((($3649)+(1))|0);
|
||
|
|
$x=$3650;
|
||
|
|
var $3651=$5;
|
||
|
|
var $3652=(($3651+1)|0);
|
||
|
|
$5=$3652;
|
||
|
|
var $3653=HEAP8[($3651)];
|
||
|
|
var $3654=$x;
|
||
|
|
var $3655=((($3654)*(3))&-1);
|
||
|
|
var $3656=$line;
|
||
|
|
var $3657=(($3656+$3655)|0);
|
||
|
|
HEAP8[($3657)]=$3653;
|
||
|
|
var $3658=$5;
|
||
|
|
var $3659=(($3658+1)|0);
|
||
|
|
$5=$3659;
|
||
|
|
var $3660=HEAP8[($3658)];
|
||
|
|
var $3661=$x;
|
||
|
|
var $3662=((($3661)*(3))&-1);
|
||
|
|
var $3663=((($3662)+(1))|0);
|
||
|
|
var $3664=$line;
|
||
|
|
var $3665=(($3664+$3663)|0);
|
||
|
|
HEAP8[($3665)]=$3660;
|
||
|
|
var $3666=$5;
|
||
|
|
var $3667=(($3666+1)|0);
|
||
|
|
$5=$3667;
|
||
|
|
var $3668=HEAP8[($3666)];
|
||
|
|
var $3669=$x;
|
||
|
|
var $3670=((($3669)*(3))&-1);
|
||
|
|
var $3671=((($3670)+(2))|0);
|
||
|
|
var $3672=$line;
|
||
|
|
var $3673=(($3672+$3671)|0);
|
||
|
|
HEAP8[($3673)]=$3668;
|
||
|
|
var $3674=$count;
|
||
|
|
var $3675=((($3674)-(1))|0);
|
||
|
|
$count=$3675;
|
||
|
|
var $3676=$x;
|
||
|
|
var $3677=((($3676)+(1))|0);
|
||
|
|
$x=$3677;
|
||
|
|
var $3678=$5;
|
||
|
|
var $3679=(($3678+1)|0);
|
||
|
|
$5=$3679;
|
||
|
|
var $3680=HEAP8[($3678)];
|
||
|
|
var $3681=$x;
|
||
|
|
var $3682=((($3681)*(3))&-1);
|
||
|
|
var $3683=$line;
|
||
|
|
var $3684=(($3683+$3682)|0);
|
||
|
|
HEAP8[($3684)]=$3680;
|
||
|
|
var $3685=$5;
|
||
|
|
var $3686=(($3685+1)|0);
|
||
|
|
$5=$3686;
|
||
|
|
var $3687=HEAP8[($3685)];
|
||
|
|
var $3688=$x;
|
||
|
|
var $3689=((($3688)*(3))&-1);
|
||
|
|
var $3690=((($3689)+(1))|0);
|
||
|
|
var $3691=$line;
|
||
|
|
var $3692=(($3691+$3690)|0);
|
||
|
|
HEAP8[($3692)]=$3687;
|
||
|
|
var $3693=$5;
|
||
|
|
var $3694=(($3693+1)|0);
|
||
|
|
$5=$3694;
|
||
|
|
var $3695=HEAP8[($3693)];
|
||
|
|
var $3696=$x;
|
||
|
|
var $3697=((($3696)*(3))&-1);
|
||
|
|
var $3698=((($3697)+(2))|0);
|
||
|
|
var $3699=$line;
|
||
|
|
var $3700=(($3699+$3698)|0);
|
||
|
|
HEAP8[($3700)]=$3695;
|
||
|
|
var $3701=$count;
|
||
|
|
var $3702=((($3701)-(1))|0);
|
||
|
|
$count=$3702;
|
||
|
|
var $3703=$x;
|
||
|
|
var $3704=((($3703)+(1))|0);
|
||
|
|
$x=$3704;
|
||
|
|
label=273;break;
|
||
|
|
case 277:
|
||
|
|
label=278;break;
|
||
|
|
case 278:
|
||
|
|
var $3707=$count;
|
||
|
|
var $3708=($3707|0)>0;
|
||
|
|
if($3708){label=279;break;}else{var $3714=0;label=280;break;}
|
||
|
|
case 279:
|
||
|
|
var $3710=$x;
|
||
|
|
var $3711=$3;
|
||
|
|
var $3712=($3710|0)<($3711|0);
|
||
|
|
var $3714=$3712;label=280;break;
|
||
|
|
case 280:
|
||
|
|
var $3714;
|
||
|
|
if($3714){label=281;break;}else{label=282;break;}
|
||
|
|
case 281:
|
||
|
|
var $3716=$5;
|
||
|
|
var $3717=(($3716+1)|0);
|
||
|
|
$5=$3717;
|
||
|
|
var $3718=HEAP8[($3716)];
|
||
|
|
var $3719=$x;
|
||
|
|
var $3720=((($3719)*(3))&-1);
|
||
|
|
var $3721=$line;
|
||
|
|
var $3722=(($3721+$3720)|0);
|
||
|
|
HEAP8[($3722)]=$3718;
|
||
|
|
var $3723=$5;
|
||
|
|
var $3724=(($3723+1)|0);
|
||
|
|
$5=$3724;
|
||
|
|
var $3725=HEAP8[($3723)];
|
||
|
|
var $3726=$x;
|
||
|
|
var $3727=((($3726)*(3))&-1);
|
||
|
|
var $3728=((($3727)+(1))|0);
|
||
|
|
var $3729=$line;
|
||
|
|
var $3730=(($3729+$3728)|0);
|
||
|
|
HEAP8[($3730)]=$3725;
|
||
|
|
var $3731=$5;
|
||
|
|
var $3732=(($3731+1)|0);
|
||
|
|
$5=$3732;
|
||
|
|
var $3733=HEAP8[($3731)];
|
||
|
|
var $3734=$x;
|
||
|
|
var $3735=((($3734)*(3))&-1);
|
||
|
|
var $3736=((($3735)+(2))|0);
|
||
|
|
var $3737=$line;
|
||
|
|
var $3738=(($3737+$3736)|0);
|
||
|
|
HEAP8[($3738)]=$3733;
|
||
|
|
var $3739=$count;
|
||
|
|
var $3740=((($3739)-(1))|0);
|
||
|
|
$count=$3740;
|
||
|
|
var $3741=$x;
|
||
|
|
var $3742=((($3741)+(1))|0);
|
||
|
|
$x=$3742;
|
||
|
|
label=278;break;
|
||
|
|
case 282:
|
||
|
|
label=344;break;
|
||
|
|
case 283:
|
||
|
|
label=284;break;
|
||
|
|
case 284:
|
||
|
|
var $3746=$count;
|
||
|
|
var $3747=$3746&-8;
|
||
|
|
var $3748=($3747|0)!=0;
|
||
|
|
if($3748){label=285;break;}else{var $3755=0;label=286;break;}
|
||
|
|
case 285:
|
||
|
|
var $3750=$x;
|
||
|
|
var $3751=((($3750)+(8))|0);
|
||
|
|
var $3752=$3;
|
||
|
|
var $3753=($3751|0)<($3752|0);
|
||
|
|
var $3755=$3753;label=286;break;
|
||
|
|
case 286:
|
||
|
|
var $3755;
|
||
|
|
if($3755){label=287;break;}else{label=312;break;}
|
||
|
|
case 287:
|
||
|
|
var $3757=$bicolour;
|
||
|
|
var $3758=($3757|0)!=0;
|
||
|
|
if($3758){label=288;break;}else{label=289;break;}
|
||
|
|
case 288:
|
||
|
|
var $3760=(($colour2)|0);
|
||
|
|
var $3761=HEAP8[($3760)];
|
||
|
|
var $3762=$x;
|
||
|
|
var $3763=((($3762)*(3))&-1);
|
||
|
|
var $3764=$line;
|
||
|
|
var $3765=(($3764+$3763)|0);
|
||
|
|
HEAP8[($3765)]=$3761;
|
||
|
|
var $3766=(($colour2+1)|0);
|
||
|
|
var $3767=HEAP8[($3766)];
|
||
|
|
var $3768=$x;
|
||
|
|
var $3769=((($3768)*(3))&-1);
|
||
|
|
var $3770=((($3769)+(1))|0);
|
||
|
|
var $3771=$line;
|
||
|
|
var $3772=(($3771+$3770)|0);
|
||
|
|
HEAP8[($3772)]=$3767;
|
||
|
|
var $3773=(($colour2+2)|0);
|
||
|
|
var $3774=HEAP8[($3773)];
|
||
|
|
var $3775=$x;
|
||
|
|
var $3776=((($3775)*(3))&-1);
|
||
|
|
var $3777=((($3776)+(2))|0);
|
||
|
|
var $3778=$line;
|
||
|
|
var $3779=(($3778+$3777)|0);
|
||
|
|
HEAP8[($3779)]=$3774;
|
||
|
|
$bicolour=0;
|
||
|
|
label=290;break;
|
||
|
|
case 289:
|
||
|
|
var $3781=(($colour1)|0);
|
||
|
|
var $3782=HEAP8[($3781)];
|
||
|
|
var $3783=$x;
|
||
|
|
var $3784=((($3783)*(3))&-1);
|
||
|
|
var $3785=$line;
|
||
|
|
var $3786=(($3785+$3784)|0);
|
||
|
|
HEAP8[($3786)]=$3782;
|
||
|
|
var $3787=(($colour1+1)|0);
|
||
|
|
var $3788=HEAP8[($3787)];
|
||
|
|
var $3789=$x;
|
||
|
|
var $3790=((($3789)*(3))&-1);
|
||
|
|
var $3791=((($3790)+(1))|0);
|
||
|
|
var $3792=$line;
|
||
|
|
var $3793=(($3792+$3791)|0);
|
||
|
|
HEAP8[($3793)]=$3788;
|
||
|
|
var $3794=(($colour1+2)|0);
|
||
|
|
var $3795=HEAP8[($3794)];
|
||
|
|
var $3796=$x;
|
||
|
|
var $3797=((($3796)*(3))&-1);
|
||
|
|
var $3798=((($3797)+(2))|0);
|
||
|
|
var $3799=$line;
|
||
|
|
var $3800=(($3799+$3798)|0);
|
||
|
|
HEAP8[($3800)]=$3795;
|
||
|
|
$bicolour=1;
|
||
|
|
var $3801=$count;
|
||
|
|
var $3802=((($3801)+(1))|0);
|
||
|
|
$count=$3802;
|
||
|
|
label=290;break;
|
||
|
|
case 290:
|
||
|
|
var $3804=$count;
|
||
|
|
var $3805=((($3804)-(1))|0);
|
||
|
|
$count=$3805;
|
||
|
|
var $3806=$x;
|
||
|
|
var $3807=((($3806)+(1))|0);
|
||
|
|
$x=$3807;
|
||
|
|
var $3808=$bicolour;
|
||
|
|
var $3809=($3808|0)!=0;
|
||
|
|
if($3809){label=291;break;}else{label=292;break;}
|
||
|
|
case 291:
|
||
|
|
var $3811=(($colour2)|0);
|
||
|
|
var $3812=HEAP8[($3811)];
|
||
|
|
var $3813=$x;
|
||
|
|
var $3814=((($3813)*(3))&-1);
|
||
|
|
var $3815=$line;
|
||
|
|
var $3816=(($3815+$3814)|0);
|
||
|
|
HEAP8[($3816)]=$3812;
|
||
|
|
var $3817=(($colour2+1)|0);
|
||
|
|
var $3818=HEAP8[($3817)];
|
||
|
|
var $3819=$x;
|
||
|
|
var $3820=((($3819)*(3))&-1);
|
||
|
|
var $3821=((($3820)+(1))|0);
|
||
|
|
var $3822=$line;
|
||
|
|
var $3823=(($3822+$3821)|0);
|
||
|
|
HEAP8[($3823)]=$3818;
|
||
|
|
var $3824=(($colour2+2)|0);
|
||
|
|
var $3825=HEAP8[($3824)];
|
||
|
|
var $3826=$x;
|
||
|
|
var $3827=((($3826)*(3))&-1);
|
||
|
|
var $3828=((($3827)+(2))|0);
|
||
|
|
var $3829=$line;
|
||
|
|
var $3830=(($3829+$3828)|0);
|
||
|
|
HEAP8[($3830)]=$3825;
|
||
|
|
$bicolour=0;
|
||
|
|
label=293;break;
|
||
|
|
case 292:
|
||
|
|
var $3832=(($colour1)|0);
|
||
|
|
var $3833=HEAP8[($3832)];
|
||
|
|
var $3834=$x;
|
||
|
|
var $3835=((($3834)*(3))&-1);
|
||
|
|
var $3836=$line;
|
||
|
|
var $3837=(($3836+$3835)|0);
|
||
|
|
HEAP8[($3837)]=$3833;
|
||
|
|
var $3838=(($colour1+1)|0);
|
||
|
|
var $3839=HEAP8[($3838)];
|
||
|
|
var $3840=$x;
|
||
|
|
var $3841=((($3840)*(3))&-1);
|
||
|
|
var $3842=((($3841)+(1))|0);
|
||
|
|
var $3843=$line;
|
||
|
|
var $3844=(($3843+$3842)|0);
|
||
|
|
HEAP8[($3844)]=$3839;
|
||
|
|
var $3845=(($colour1+2)|0);
|
||
|
|
var $3846=HEAP8[($3845)];
|
||
|
|
var $3847=$x;
|
||
|
|
var $3848=((($3847)*(3))&-1);
|
||
|
|
var $3849=((($3848)+(2))|0);
|
||
|
|
var $3850=$line;
|
||
|
|
var $3851=(($3850+$3849)|0);
|
||
|
|
HEAP8[($3851)]=$3846;
|
||
|
|
$bicolour=1;
|
||
|
|
var $3852=$count;
|
||
|
|
var $3853=((($3852)+(1))|0);
|
||
|
|
$count=$3853;
|
||
|
|
label=293;break;
|
||
|
|
case 293:
|
||
|
|
var $3855=$count;
|
||
|
|
var $3856=((($3855)-(1))|0);
|
||
|
|
$count=$3856;
|
||
|
|
var $3857=$x;
|
||
|
|
var $3858=((($3857)+(1))|0);
|
||
|
|
$x=$3858;
|
||
|
|
var $3859=$bicolour;
|
||
|
|
var $3860=($3859|0)!=0;
|
||
|
|
if($3860){label=294;break;}else{label=295;break;}
|
||
|
|
case 294:
|
||
|
|
var $3862=(($colour2)|0);
|
||
|
|
var $3863=HEAP8[($3862)];
|
||
|
|
var $3864=$x;
|
||
|
|
var $3865=((($3864)*(3))&-1);
|
||
|
|
var $3866=$line;
|
||
|
|
var $3867=(($3866+$3865)|0);
|
||
|
|
HEAP8[($3867)]=$3863;
|
||
|
|
var $3868=(($colour2+1)|0);
|
||
|
|
var $3869=HEAP8[($3868)];
|
||
|
|
var $3870=$x;
|
||
|
|
var $3871=((($3870)*(3))&-1);
|
||
|
|
var $3872=((($3871)+(1))|0);
|
||
|
|
var $3873=$line;
|
||
|
|
var $3874=(($3873+$3872)|0);
|
||
|
|
HEAP8[($3874)]=$3869;
|
||
|
|
var $3875=(($colour2+2)|0);
|
||
|
|
var $3876=HEAP8[($3875)];
|
||
|
|
var $3877=$x;
|
||
|
|
var $3878=((($3877)*(3))&-1);
|
||
|
|
var $3879=((($3878)+(2))|0);
|
||
|
|
var $3880=$line;
|
||
|
|
var $3881=(($3880+$3879)|0);
|
||
|
|
HEAP8[($3881)]=$3876;
|
||
|
|
$bicolour=0;
|
||
|
|
label=296;break;
|
||
|
|
case 295:
|
||
|
|
var $3883=(($colour1)|0);
|
||
|
|
var $3884=HEAP8[($3883)];
|
||
|
|
var $3885=$x;
|
||
|
|
var $3886=((($3885)*(3))&-1);
|
||
|
|
var $3887=$line;
|
||
|
|
var $3888=(($3887+$3886)|0);
|
||
|
|
HEAP8[($3888)]=$3884;
|
||
|
|
var $3889=(($colour1+1)|0);
|
||
|
|
var $3890=HEAP8[($3889)];
|
||
|
|
var $3891=$x;
|
||
|
|
var $3892=((($3891)*(3))&-1);
|
||
|
|
var $3893=((($3892)+(1))|0);
|
||
|
|
var $3894=$line;
|
||
|
|
var $3895=(($3894+$3893)|0);
|
||
|
|
HEAP8[($3895)]=$3890;
|
||
|
|
var $3896=(($colour1+2)|0);
|
||
|
|
var $3897=HEAP8[($3896)];
|
||
|
|
var $3898=$x;
|
||
|
|
var $3899=((($3898)*(3))&-1);
|
||
|
|
var $3900=((($3899)+(2))|0);
|
||
|
|
var $3901=$line;
|
||
|
|
var $3902=(($3901+$3900)|0);
|
||
|
|
HEAP8[($3902)]=$3897;
|
||
|
|
$bicolour=1;
|
||
|
|
var $3903=$count;
|
||
|
|
var $3904=((($3903)+(1))|0);
|
||
|
|
$count=$3904;
|
||
|
|
label=296;break;
|
||
|
|
case 296:
|
||
|
|
var $3906=$count;
|
||
|
|
var $3907=((($3906)-(1))|0);
|
||
|
|
$count=$3907;
|
||
|
|
var $3908=$x;
|
||
|
|
var $3909=((($3908)+(1))|0);
|
||
|
|
$x=$3909;
|
||
|
|
var $3910=$bicolour;
|
||
|
|
var $3911=($3910|0)!=0;
|
||
|
|
if($3911){label=297;break;}else{label=298;break;}
|
||
|
|
case 297:
|
||
|
|
var $3913=(($colour2)|0);
|
||
|
|
var $3914=HEAP8[($3913)];
|
||
|
|
var $3915=$x;
|
||
|
|
var $3916=((($3915)*(3))&-1);
|
||
|
|
var $3917=$line;
|
||
|
|
var $3918=(($3917+$3916)|0);
|
||
|
|
HEAP8[($3918)]=$3914;
|
||
|
|
var $3919=(($colour2+1)|0);
|
||
|
|
var $3920=HEAP8[($3919)];
|
||
|
|
var $3921=$x;
|
||
|
|
var $3922=((($3921)*(3))&-1);
|
||
|
|
var $3923=((($3922)+(1))|0);
|
||
|
|
var $3924=$line;
|
||
|
|
var $3925=(($3924+$3923)|0);
|
||
|
|
HEAP8[($3925)]=$3920;
|
||
|
|
var $3926=(($colour2+2)|0);
|
||
|
|
var $3927=HEAP8[($3926)];
|
||
|
|
var $3928=$x;
|
||
|
|
var $3929=((($3928)*(3))&-1);
|
||
|
|
var $3930=((($3929)+(2))|0);
|
||
|
|
var $3931=$line;
|
||
|
|
var $3932=(($3931+$3930)|0);
|
||
|
|
HEAP8[($3932)]=$3927;
|
||
|
|
$bicolour=0;
|
||
|
|
label=299;break;
|
||
|
|
case 298:
|
||
|
|
var $3934=(($colour1)|0);
|
||
|
|
var $3935=HEAP8[($3934)];
|
||
|
|
var $3936=$x;
|
||
|
|
var $3937=((($3936)*(3))&-1);
|
||
|
|
var $3938=$line;
|
||
|
|
var $3939=(($3938+$3937)|0);
|
||
|
|
HEAP8[($3939)]=$3935;
|
||
|
|
var $3940=(($colour1+1)|0);
|
||
|
|
var $3941=HEAP8[($3940)];
|
||
|
|
var $3942=$x;
|
||
|
|
var $3943=((($3942)*(3))&-1);
|
||
|
|
var $3944=((($3943)+(1))|0);
|
||
|
|
var $3945=$line;
|
||
|
|
var $3946=(($3945+$3944)|0);
|
||
|
|
HEAP8[($3946)]=$3941;
|
||
|
|
var $3947=(($colour1+2)|0);
|
||
|
|
var $3948=HEAP8[($3947)];
|
||
|
|
var $3949=$x;
|
||
|
|
var $3950=((($3949)*(3))&-1);
|
||
|
|
var $3951=((($3950)+(2))|0);
|
||
|
|
var $3952=$line;
|
||
|
|
var $3953=(($3952+$3951)|0);
|
||
|
|
HEAP8[($3953)]=$3948;
|
||
|
|
$bicolour=1;
|
||
|
|
var $3954=$count;
|
||
|
|
var $3955=((($3954)+(1))|0);
|
||
|
|
$count=$3955;
|
||
|
|
label=299;break;
|
||
|
|
case 299:
|
||
|
|
var $3957=$count;
|
||
|
|
var $3958=((($3957)-(1))|0);
|
||
|
|
$count=$3958;
|
||
|
|
var $3959=$x;
|
||
|
|
var $3960=((($3959)+(1))|0);
|
||
|
|
$x=$3960;
|
||
|
|
var $3961=$bicolour;
|
||
|
|
var $3962=($3961|0)!=0;
|
||
|
|
if($3962){label=300;break;}else{label=301;break;}
|
||
|
|
case 300:
|
||
|
|
var $3964=(($colour2)|0);
|
||
|
|
var $3965=HEAP8[($3964)];
|
||
|
|
var $3966=$x;
|
||
|
|
var $3967=((($3966)*(3))&-1);
|
||
|
|
var $3968=$line;
|
||
|
|
var $3969=(($3968+$3967)|0);
|
||
|
|
HEAP8[($3969)]=$3965;
|
||
|
|
var $3970=(($colour2+1)|0);
|
||
|
|
var $3971=HEAP8[($3970)];
|
||
|
|
var $3972=$x;
|
||
|
|
var $3973=((($3972)*(3))&-1);
|
||
|
|
var $3974=((($3973)+(1))|0);
|
||
|
|
var $3975=$line;
|
||
|
|
var $3976=(($3975+$3974)|0);
|
||
|
|
HEAP8[($3976)]=$3971;
|
||
|
|
var $3977=(($colour2+2)|0);
|
||
|
|
var $3978=HEAP8[($3977)];
|
||
|
|
var $3979=$x;
|
||
|
|
var $3980=((($3979)*(3))&-1);
|
||
|
|
var $3981=((($3980)+(2))|0);
|
||
|
|
var $3982=$line;
|
||
|
|
var $3983=(($3982+$3981)|0);
|
||
|
|
HEAP8[($3983)]=$3978;
|
||
|
|
$bicolour=0;
|
||
|
|
label=302;break;
|
||
|
|
case 301:
|
||
|
|
var $3985=(($colour1)|0);
|
||
|
|
var $3986=HEAP8[($3985)];
|
||
|
|
var $3987=$x;
|
||
|
|
var $3988=((($3987)*(3))&-1);
|
||
|
|
var $3989=$line;
|
||
|
|
var $3990=(($3989+$3988)|0);
|
||
|
|
HEAP8[($3990)]=$3986;
|
||
|
|
var $3991=(($colour1+1)|0);
|
||
|
|
var $3992=HEAP8[($3991)];
|
||
|
|
var $3993=$x;
|
||
|
|
var $3994=((($3993)*(3))&-1);
|
||
|
|
var $3995=((($3994)+(1))|0);
|
||
|
|
var $3996=$line;
|
||
|
|
var $3997=(($3996+$3995)|0);
|
||
|
|
HEAP8[($3997)]=$3992;
|
||
|
|
var $3998=(($colour1+2)|0);
|
||
|
|
var $3999=HEAP8[($3998)];
|
||
|
|
var $4000=$x;
|
||
|
|
var $4001=((($4000)*(3))&-1);
|
||
|
|
var $4002=((($4001)+(2))|0);
|
||
|
|
var $4003=$line;
|
||
|
|
var $4004=(($4003+$4002)|0);
|
||
|
|
HEAP8[($4004)]=$3999;
|
||
|
|
$bicolour=1;
|
||
|
|
var $4005=$count;
|
||
|
|
var $4006=((($4005)+(1))|0);
|
||
|
|
$count=$4006;
|
||
|
|
label=302;break;
|
||
|
|
case 302:
|
||
|
|
var $4008=$count;
|
||
|
|
var $4009=((($4008)-(1))|0);
|
||
|
|
$count=$4009;
|
||
|
|
var $4010=$x;
|
||
|
|
var $4011=((($4010)+(1))|0);
|
||
|
|
$x=$4011;
|
||
|
|
var $4012=$bicolour;
|
||
|
|
var $4013=($4012|0)!=0;
|
||
|
|
if($4013){label=303;break;}else{label=304;break;}
|
||
|
|
case 303:
|
||
|
|
var $4015=(($colour2)|0);
|
||
|
|
var $4016=HEAP8[($4015)];
|
||
|
|
var $4017=$x;
|
||
|
|
var $4018=((($4017)*(3))&-1);
|
||
|
|
var $4019=$line;
|
||
|
|
var $4020=(($4019+$4018)|0);
|
||
|
|
HEAP8[($4020)]=$4016;
|
||
|
|
var $4021=(($colour2+1)|0);
|
||
|
|
var $4022=HEAP8[($4021)];
|
||
|
|
var $4023=$x;
|
||
|
|
var $4024=((($4023)*(3))&-1);
|
||
|
|
var $4025=((($4024)+(1))|0);
|
||
|
|
var $4026=$line;
|
||
|
|
var $4027=(($4026+$4025)|0);
|
||
|
|
HEAP8[($4027)]=$4022;
|
||
|
|
var $4028=(($colour2+2)|0);
|
||
|
|
var $4029=HEAP8[($4028)];
|
||
|
|
var $4030=$x;
|
||
|
|
var $4031=((($4030)*(3))&-1);
|
||
|
|
var $4032=((($4031)+(2))|0);
|
||
|
|
var $4033=$line;
|
||
|
|
var $4034=(($4033+$4032)|0);
|
||
|
|
HEAP8[($4034)]=$4029;
|
||
|
|
$bicolour=0;
|
||
|
|
label=305;break;
|
||
|
|
case 304:
|
||
|
|
var $4036=(($colour1)|0);
|
||
|
|
var $4037=HEAP8[($4036)];
|
||
|
|
var $4038=$x;
|
||
|
|
var $4039=((($4038)*(3))&-1);
|
||
|
|
var $4040=$line;
|
||
|
|
var $4041=(($4040+$4039)|0);
|
||
|
|
HEAP8[($4041)]=$4037;
|
||
|
|
var $4042=(($colour1+1)|0);
|
||
|
|
var $4043=HEAP8[($4042)];
|
||
|
|
var $4044=$x;
|
||
|
|
var $4045=((($4044)*(3))&-1);
|
||
|
|
var $4046=((($4045)+(1))|0);
|
||
|
|
var $4047=$line;
|
||
|
|
var $4048=(($4047+$4046)|0);
|
||
|
|
HEAP8[($4048)]=$4043;
|
||
|
|
var $4049=(($colour1+2)|0);
|
||
|
|
var $4050=HEAP8[($4049)];
|
||
|
|
var $4051=$x;
|
||
|
|
var $4052=((($4051)*(3))&-1);
|
||
|
|
var $4053=((($4052)+(2))|0);
|
||
|
|
var $4054=$line;
|
||
|
|
var $4055=(($4054+$4053)|0);
|
||
|
|
HEAP8[($4055)]=$4050;
|
||
|
|
$bicolour=1;
|
||
|
|
var $4056=$count;
|
||
|
|
var $4057=((($4056)+(1))|0);
|
||
|
|
$count=$4057;
|
||
|
|
label=305;break;
|
||
|
|
case 305:
|
||
|
|
var $4059=$count;
|
||
|
|
var $4060=((($4059)-(1))|0);
|
||
|
|
$count=$4060;
|
||
|
|
var $4061=$x;
|
||
|
|
var $4062=((($4061)+(1))|0);
|
||
|
|
$x=$4062;
|
||
|
|
var $4063=$bicolour;
|
||
|
|
var $4064=($4063|0)!=0;
|
||
|
|
if($4064){label=306;break;}else{label=307;break;}
|
||
|
|
case 306:
|
||
|
|
var $4066=(($colour2)|0);
|
||
|
|
var $4067=HEAP8[($4066)];
|
||
|
|
var $4068=$x;
|
||
|
|
var $4069=((($4068)*(3))&-1);
|
||
|
|
var $4070=$line;
|
||
|
|
var $4071=(($4070+$4069)|0);
|
||
|
|
HEAP8[($4071)]=$4067;
|
||
|
|
var $4072=(($colour2+1)|0);
|
||
|
|
var $4073=HEAP8[($4072)];
|
||
|
|
var $4074=$x;
|
||
|
|
var $4075=((($4074)*(3))&-1);
|
||
|
|
var $4076=((($4075)+(1))|0);
|
||
|
|
var $4077=$line;
|
||
|
|
var $4078=(($4077+$4076)|0);
|
||
|
|
HEAP8[($4078)]=$4073;
|
||
|
|
var $4079=(($colour2+2)|0);
|
||
|
|
var $4080=HEAP8[($4079)];
|
||
|
|
var $4081=$x;
|
||
|
|
var $4082=((($4081)*(3))&-1);
|
||
|
|
var $4083=((($4082)+(2))|0);
|
||
|
|
var $4084=$line;
|
||
|
|
var $4085=(($4084+$4083)|0);
|
||
|
|
HEAP8[($4085)]=$4080;
|
||
|
|
$bicolour=0;
|
||
|
|
label=308;break;
|
||
|
|
case 307:
|
||
|
|
var $4087=(($colour1)|0);
|
||
|
|
var $4088=HEAP8[($4087)];
|
||
|
|
var $4089=$x;
|
||
|
|
var $4090=((($4089)*(3))&-1);
|
||
|
|
var $4091=$line;
|
||
|
|
var $4092=(($4091+$4090)|0);
|
||
|
|
HEAP8[($4092)]=$4088;
|
||
|
|
var $4093=(($colour1+1)|0);
|
||
|
|
var $4094=HEAP8[($4093)];
|
||
|
|
var $4095=$x;
|
||
|
|
var $4096=((($4095)*(3))&-1);
|
||
|
|
var $4097=((($4096)+(1))|0);
|
||
|
|
var $4098=$line;
|
||
|
|
var $4099=(($4098+$4097)|0);
|
||
|
|
HEAP8[($4099)]=$4094;
|
||
|
|
var $4100=(($colour1+2)|0);
|
||
|
|
var $4101=HEAP8[($4100)];
|
||
|
|
var $4102=$x;
|
||
|
|
var $4103=((($4102)*(3))&-1);
|
||
|
|
var $4104=((($4103)+(2))|0);
|
||
|
|
var $4105=$line;
|
||
|
|
var $4106=(($4105+$4104)|0);
|
||
|
|
HEAP8[($4106)]=$4101;
|
||
|
|
$bicolour=1;
|
||
|
|
var $4107=$count;
|
||
|
|
var $4108=((($4107)+(1))|0);
|
||
|
|
$count=$4108;
|
||
|
|
label=308;break;
|
||
|
|
case 308:
|
||
|
|
var $4110=$count;
|
||
|
|
var $4111=((($4110)-(1))|0);
|
||
|
|
$count=$4111;
|
||
|
|
var $4112=$x;
|
||
|
|
var $4113=((($4112)+(1))|0);
|
||
|
|
$x=$4113;
|
||
|
|
var $4114=$bicolour;
|
||
|
|
var $4115=($4114|0)!=0;
|
||
|
|
if($4115){label=309;break;}else{label=310;break;}
|
||
|
|
case 309:
|
||
|
|
var $4117=(($colour2)|0);
|
||
|
|
var $4118=HEAP8[($4117)];
|
||
|
|
var $4119=$x;
|
||
|
|
var $4120=((($4119)*(3))&-1);
|
||
|
|
var $4121=$line;
|
||
|
|
var $4122=(($4121+$4120)|0);
|
||
|
|
HEAP8[($4122)]=$4118;
|
||
|
|
var $4123=(($colour2+1)|0);
|
||
|
|
var $4124=HEAP8[($4123)];
|
||
|
|
var $4125=$x;
|
||
|
|
var $4126=((($4125)*(3))&-1);
|
||
|
|
var $4127=((($4126)+(1))|0);
|
||
|
|
var $4128=$line;
|
||
|
|
var $4129=(($4128+$4127)|0);
|
||
|
|
HEAP8[($4129)]=$4124;
|
||
|
|
var $4130=(($colour2+2)|0);
|
||
|
|
var $4131=HEAP8[($4130)];
|
||
|
|
var $4132=$x;
|
||
|
|
var $4133=((($4132)*(3))&-1);
|
||
|
|
var $4134=((($4133)+(2))|0);
|
||
|
|
var $4135=$line;
|
||
|
|
var $4136=(($4135+$4134)|0);
|
||
|
|
HEAP8[($4136)]=$4131;
|
||
|
|
$bicolour=0;
|
||
|
|
label=311;break;
|
||
|
|
case 310:
|
||
|
|
var $4138=(($colour1)|0);
|
||
|
|
var $4139=HEAP8[($4138)];
|
||
|
|
var $4140=$x;
|
||
|
|
var $4141=((($4140)*(3))&-1);
|
||
|
|
var $4142=$line;
|
||
|
|
var $4143=(($4142+$4141)|0);
|
||
|
|
HEAP8[($4143)]=$4139;
|
||
|
|
var $4144=(($colour1+1)|0);
|
||
|
|
var $4145=HEAP8[($4144)];
|
||
|
|
var $4146=$x;
|
||
|
|
var $4147=((($4146)*(3))&-1);
|
||
|
|
var $4148=((($4147)+(1))|0);
|
||
|
|
var $4149=$line;
|
||
|
|
var $4150=(($4149+$4148)|0);
|
||
|
|
HEAP8[($4150)]=$4145;
|
||
|
|
var $4151=(($colour1+2)|0);
|
||
|
|
var $4152=HEAP8[($4151)];
|
||
|
|
var $4153=$x;
|
||
|
|
var $4154=((($4153)*(3))&-1);
|
||
|
|
var $4155=((($4154)+(2))|0);
|
||
|
|
var $4156=$line;
|
||
|
|
var $4157=(($4156+$4155)|0);
|
||
|
|
HEAP8[($4157)]=$4152;
|
||
|
|
$bicolour=1;
|
||
|
|
var $4158=$count;
|
||
|
|
var $4159=((($4158)+(1))|0);
|
||
|
|
$count=$4159;
|
||
|
|
label=311;break;
|
||
|
|
case 311:
|
||
|
|
var $4161=$count;
|
||
|
|
var $4162=((($4161)-(1))|0);
|
||
|
|
$count=$4162;
|
||
|
|
var $4163=$x;
|
||
|
|
var $4164=((($4163)+(1))|0);
|
||
|
|
$x=$4164;
|
||
|
|
label=284;break;
|
||
|
|
case 312:
|
||
|
|
label=313;break;
|
||
|
|
case 313:
|
||
|
|
var $4167=$count;
|
||
|
|
var $4168=($4167|0)>0;
|
||
|
|
if($4168){label=314;break;}else{var $4174=0;label=315;break;}
|
||
|
|
case 314:
|
||
|
|
var $4170=$x;
|
||
|
|
var $4171=$3;
|
||
|
|
var $4172=($4170|0)<($4171|0);
|
||
|
|
var $4174=$4172;label=315;break;
|
||
|
|
case 315:
|
||
|
|
var $4174;
|
||
|
|
if($4174){label=316;break;}else{label=320;break;}
|
||
|
|
case 316:
|
||
|
|
var $4176=$bicolour;
|
||
|
|
var $4177=($4176|0)!=0;
|
||
|
|
if($4177){label=317;break;}else{label=318;break;}
|
||
|
|
case 317:
|
||
|
|
var $4179=(($colour2)|0);
|
||
|
|
var $4180=HEAP8[($4179)];
|
||
|
|
var $4181=$x;
|
||
|
|
var $4182=((($4181)*(3))&-1);
|
||
|
|
var $4183=$line;
|
||
|
|
var $4184=(($4183+$4182)|0);
|
||
|
|
HEAP8[($4184)]=$4180;
|
||
|
|
var $4185=(($colour2+1)|0);
|
||
|
|
var $4186=HEAP8[($4185)];
|
||
|
|
var $4187=$x;
|
||
|
|
var $4188=((($4187)*(3))&-1);
|
||
|
|
var $4189=((($4188)+(1))|0);
|
||
|
|
var $4190=$line;
|
||
|
|
var $4191=(($4190+$4189)|0);
|
||
|
|
HEAP8[($4191)]=$4186;
|
||
|
|
var $4192=(($colour2+2)|0);
|
||
|
|
var $4193=HEAP8[($4192)];
|
||
|
|
var $4194=$x;
|
||
|
|
var $4195=((($4194)*(3))&-1);
|
||
|
|
var $4196=((($4195)+(2))|0);
|
||
|
|
var $4197=$line;
|
||
|
|
var $4198=(($4197+$4196)|0);
|
||
|
|
HEAP8[($4198)]=$4193;
|
||
|
|
$bicolour=0;
|
||
|
|
label=319;break;
|
||
|
|
case 318:
|
||
|
|
var $4200=(($colour1)|0);
|
||
|
|
var $4201=HEAP8[($4200)];
|
||
|
|
var $4202=$x;
|
||
|
|
var $4203=((($4202)*(3))&-1);
|
||
|
|
var $4204=$line;
|
||
|
|
var $4205=(($4204+$4203)|0);
|
||
|
|
HEAP8[($4205)]=$4201;
|
||
|
|
var $4206=(($colour1+1)|0);
|
||
|
|
var $4207=HEAP8[($4206)];
|
||
|
|
var $4208=$x;
|
||
|
|
var $4209=((($4208)*(3))&-1);
|
||
|
|
var $4210=((($4209)+(1))|0);
|
||
|
|
var $4211=$line;
|
||
|
|
var $4212=(($4211+$4210)|0);
|
||
|
|
HEAP8[($4212)]=$4207;
|
||
|
|
var $4213=(($colour1+2)|0);
|
||
|
|
var $4214=HEAP8[($4213)];
|
||
|
|
var $4215=$x;
|
||
|
|
var $4216=((($4215)*(3))&-1);
|
||
|
|
var $4217=((($4216)+(2))|0);
|
||
|
|
var $4218=$line;
|
||
|
|
var $4219=(($4218+$4217)|0);
|
||
|
|
HEAP8[($4219)]=$4214;
|
||
|
|
$bicolour=1;
|
||
|
|
var $4220=$count;
|
||
|
|
var $4221=((($4220)+(1))|0);
|
||
|
|
$count=$4221;
|
||
|
|
label=319;break;
|
||
|
|
case 319:
|
||
|
|
var $4223=$count;
|
||
|
|
var $4224=((($4223)-(1))|0);
|
||
|
|
$count=$4224;
|
||
|
|
var $4225=$x;
|
||
|
|
var $4226=((($4225)+(1))|0);
|
||
|
|
$x=$4226;
|
||
|
|
label=313;break;
|
||
|
|
case 320:
|
||
|
|
label=344;break;
|
||
|
|
case 321:
|
||
|
|
label=322;break;
|
||
|
|
case 322:
|
||
|
|
var $4230=$count;
|
||
|
|
var $4231=$4230&-8;
|
||
|
|
var $4232=($4231|0)!=0;
|
||
|
|
if($4232){label=323;break;}else{var $4239=0;label=324;break;}
|
||
|
|
case 323:
|
||
|
|
var $4234=$x;
|
||
|
|
var $4235=((($4234)+(8))|0);
|
||
|
|
var $4236=$3;
|
||
|
|
var $4237=($4235|0)<($4236|0);
|
||
|
|
var $4239=$4237;label=324;break;
|
||
|
|
case 324:
|
||
|
|
var $4239;
|
||
|
|
if($4239){label=325;break;}else{label=326;break;}
|
||
|
|
case 325:
|
||
|
|
var $4241=$x;
|
||
|
|
var $4242=((($4241)*(3))&-1);
|
||
|
|
var $4243=$line;
|
||
|
|
var $4244=(($4243+$4242)|0);
|
||
|
|
HEAP8[($4244)]=-1;
|
||
|
|
var $4245=$x;
|
||
|
|
var $4246=((($4245)*(3))&-1);
|
||
|
|
var $4247=((($4246)+(1))|0);
|
||
|
|
var $4248=$line;
|
||
|
|
var $4249=(($4248+$4247)|0);
|
||
|
|
HEAP8[($4249)]=-1;
|
||
|
|
var $4250=$x;
|
||
|
|
var $4251=((($4250)*(3))&-1);
|
||
|
|
var $4252=((($4251)+(2))|0);
|
||
|
|
var $4253=$line;
|
||
|
|
var $4254=(($4253+$4252)|0);
|
||
|
|
HEAP8[($4254)]=-1;
|
||
|
|
var $4255=$count;
|
||
|
|
var $4256=((($4255)-(1))|0);
|
||
|
|
$count=$4256;
|
||
|
|
var $4257=$x;
|
||
|
|
var $4258=((($4257)+(1))|0);
|
||
|
|
$x=$4258;
|
||
|
|
var $4259=$x;
|
||
|
|
var $4260=((($4259)*(3))&-1);
|
||
|
|
var $4261=$line;
|
||
|
|
var $4262=(($4261+$4260)|0);
|
||
|
|
HEAP8[($4262)]=-1;
|
||
|
|
var $4263=$x;
|
||
|
|
var $4264=((($4263)*(3))&-1);
|
||
|
|
var $4265=((($4264)+(1))|0);
|
||
|
|
var $4266=$line;
|
||
|
|
var $4267=(($4266+$4265)|0);
|
||
|
|
HEAP8[($4267)]=-1;
|
||
|
|
var $4268=$x;
|
||
|
|
var $4269=((($4268)*(3))&-1);
|
||
|
|
var $4270=((($4269)+(2))|0);
|
||
|
|
var $4271=$line;
|
||
|
|
var $4272=(($4271+$4270)|0);
|
||
|
|
HEAP8[($4272)]=-1;
|
||
|
|
var $4273=$count;
|
||
|
|
var $4274=((($4273)-(1))|0);
|
||
|
|
$count=$4274;
|
||
|
|
var $4275=$x;
|
||
|
|
var $4276=((($4275)+(1))|0);
|
||
|
|
$x=$4276;
|
||
|
|
var $4277=$x;
|
||
|
|
var $4278=((($4277)*(3))&-1);
|
||
|
|
var $4279=$line;
|
||
|
|
var $4280=(($4279+$4278)|0);
|
||
|
|
HEAP8[($4280)]=-1;
|
||
|
|
var $4281=$x;
|
||
|
|
var $4282=((($4281)*(3))&-1);
|
||
|
|
var $4283=((($4282)+(1))|0);
|
||
|
|
var $4284=$line;
|
||
|
|
var $4285=(($4284+$4283)|0);
|
||
|
|
HEAP8[($4285)]=-1;
|
||
|
|
var $4286=$x;
|
||
|
|
var $4287=((($4286)*(3))&-1);
|
||
|
|
var $4288=((($4287)+(2))|0);
|
||
|
|
var $4289=$line;
|
||
|
|
var $4290=(($4289+$4288)|0);
|
||
|
|
HEAP8[($4290)]=-1;
|
||
|
|
var $4291=$count;
|
||
|
|
var $4292=((($4291)-(1))|0);
|
||
|
|
$count=$4292;
|
||
|
|
var $4293=$x;
|
||
|
|
var $4294=((($4293)+(1))|0);
|
||
|
|
$x=$4294;
|
||
|
|
var $4295=$x;
|
||
|
|
var $4296=((($4295)*(3))&-1);
|
||
|
|
var $4297=$line;
|
||
|
|
var $4298=(($4297+$4296)|0);
|
||
|
|
HEAP8[($4298)]=-1;
|
||
|
|
var $4299=$x;
|
||
|
|
var $4300=((($4299)*(3))&-1);
|
||
|
|
var $4301=((($4300)+(1))|0);
|
||
|
|
var $4302=$line;
|
||
|
|
var $4303=(($4302+$4301)|0);
|
||
|
|
HEAP8[($4303)]=-1;
|
||
|
|
var $4304=$x;
|
||
|
|
var $4305=((($4304)*(3))&-1);
|
||
|
|
var $4306=((($4305)+(2))|0);
|
||
|
|
var $4307=$line;
|
||
|
|
var $4308=(($4307+$4306)|0);
|
||
|
|
HEAP8[($4308)]=-1;
|
||
|
|
var $4309=$count;
|
||
|
|
var $4310=((($4309)-(1))|0);
|
||
|
|
$count=$4310;
|
||
|
|
var $4311=$x;
|
||
|
|
var $4312=((($4311)+(1))|0);
|
||
|
|
$x=$4312;
|
||
|
|
var $4313=$x;
|
||
|
|
var $4314=((($4313)*(3))&-1);
|
||
|
|
var $4315=$line;
|
||
|
|
var $4316=(($4315+$4314)|0);
|
||
|
|
HEAP8[($4316)]=-1;
|
||
|
|
var $4317=$x;
|
||
|
|
var $4318=((($4317)*(3))&-1);
|
||
|
|
var $4319=((($4318)+(1))|0);
|
||
|
|
var $4320=$line;
|
||
|
|
var $4321=(($4320+$4319)|0);
|
||
|
|
HEAP8[($4321)]=-1;
|
||
|
|
var $4322=$x;
|
||
|
|
var $4323=((($4322)*(3))&-1);
|
||
|
|
var $4324=((($4323)+(2))|0);
|
||
|
|
var $4325=$line;
|
||
|
|
var $4326=(($4325+$4324)|0);
|
||
|
|
HEAP8[($4326)]=-1;
|
||
|
|
var $4327=$count;
|
||
|
|
var $4328=((($4327)-(1))|0);
|
||
|
|
$count=$4328;
|
||
|
|
var $4329=$x;
|
||
|
|
var $4330=((($4329)+(1))|0);
|
||
|
|
$x=$4330;
|
||
|
|
var $4331=$x;
|
||
|
|
var $4332=((($4331)*(3))&-1);
|
||
|
|
var $4333=$line;
|
||
|
|
var $4334=(($4333+$4332)|0);
|
||
|
|
HEAP8[($4334)]=-1;
|
||
|
|
var $4335=$x;
|
||
|
|
var $4336=((($4335)*(3))&-1);
|
||
|
|
var $4337=((($4336)+(1))|0);
|
||
|
|
var $4338=$line;
|
||
|
|
var $4339=(($4338+$4337)|0);
|
||
|
|
HEAP8[($4339)]=-1;
|
||
|
|
var $4340=$x;
|
||
|
|
var $4341=((($4340)*(3))&-1);
|
||
|
|
var $4342=((($4341)+(2))|0);
|
||
|
|
var $4343=$line;
|
||
|
|
var $4344=(($4343+$4342)|0);
|
||
|
|
HEAP8[($4344)]=-1;
|
||
|
|
var $4345=$count;
|
||
|
|
var $4346=((($4345)-(1))|0);
|
||
|
|
$count=$4346;
|
||
|
|
var $4347=$x;
|
||
|
|
var $4348=((($4347)+(1))|0);
|
||
|
|
$x=$4348;
|
||
|
|
var $4349=$x;
|
||
|
|
var $4350=((($4349)*(3))&-1);
|
||
|
|
var $4351=$line;
|
||
|
|
var $4352=(($4351+$4350)|0);
|
||
|
|
HEAP8[($4352)]=-1;
|
||
|
|
var $4353=$x;
|
||
|
|
var $4354=((($4353)*(3))&-1);
|
||
|
|
var $4355=((($4354)+(1))|0);
|
||
|
|
var $4356=$line;
|
||
|
|
var $4357=(($4356+$4355)|0);
|
||
|
|
HEAP8[($4357)]=-1;
|
||
|
|
var $4358=$x;
|
||
|
|
var $4359=((($4358)*(3))&-1);
|
||
|
|
var $4360=((($4359)+(2))|0);
|
||
|
|
var $4361=$line;
|
||
|
|
var $4362=(($4361+$4360)|0);
|
||
|
|
HEAP8[($4362)]=-1;
|
||
|
|
var $4363=$count;
|
||
|
|
var $4364=((($4363)-(1))|0);
|
||
|
|
$count=$4364;
|
||
|
|
var $4365=$x;
|
||
|
|
var $4366=((($4365)+(1))|0);
|
||
|
|
$x=$4366;
|
||
|
|
var $4367=$x;
|
||
|
|
var $4368=((($4367)*(3))&-1);
|
||
|
|
var $4369=$line;
|
||
|
|
var $4370=(($4369+$4368)|0);
|
||
|
|
HEAP8[($4370)]=-1;
|
||
|
|
var $4371=$x;
|
||
|
|
var $4372=((($4371)*(3))&-1);
|
||
|
|
var $4373=((($4372)+(1))|0);
|
||
|
|
var $4374=$line;
|
||
|
|
var $4375=(($4374+$4373)|0);
|
||
|
|
HEAP8[($4375)]=-1;
|
||
|
|
var $4376=$x;
|
||
|
|
var $4377=((($4376)*(3))&-1);
|
||
|
|
var $4378=((($4377)+(2))|0);
|
||
|
|
var $4379=$line;
|
||
|
|
var $4380=(($4379+$4378)|0);
|
||
|
|
HEAP8[($4380)]=-1;
|
||
|
|
var $4381=$count;
|
||
|
|
var $4382=((($4381)-(1))|0);
|
||
|
|
$count=$4382;
|
||
|
|
var $4383=$x;
|
||
|
|
var $4384=((($4383)+(1))|0);
|
||
|
|
$x=$4384;
|
||
|
|
label=322;break;
|
||
|
|
case 326:
|
||
|
|
label=327;break;
|
||
|
|
case 327:
|
||
|
|
var $4387=$count;
|
||
|
|
var $4388=($4387|0)>0;
|
||
|
|
if($4388){label=328;break;}else{var $4394=0;label=329;break;}
|
||
|
|
case 328:
|
||
|
|
var $4390=$x;
|
||
|
|
var $4391=$3;
|
||
|
|
var $4392=($4390|0)<($4391|0);
|
||
|
|
var $4394=$4392;label=329;break;
|
||
|
|
case 329:
|
||
|
|
var $4394;
|
||
|
|
if($4394){label=330;break;}else{label=331;break;}
|
||
|
|
case 330:
|
||
|
|
var $4396=$x;
|
||
|
|
var $4397=((($4396)*(3))&-1);
|
||
|
|
var $4398=$line;
|
||
|
|
var $4399=(($4398+$4397)|0);
|
||
|
|
HEAP8[($4399)]=-1;
|
||
|
|
var $4400=$x;
|
||
|
|
var $4401=((($4400)*(3))&-1);
|
||
|
|
var $4402=((($4401)+(1))|0);
|
||
|
|
var $4403=$line;
|
||
|
|
var $4404=(($4403+$4402)|0);
|
||
|
|
HEAP8[($4404)]=-1;
|
||
|
|
var $4405=$x;
|
||
|
|
var $4406=((($4405)*(3))&-1);
|
||
|
|
var $4407=((($4406)+(2))|0);
|
||
|
|
var $4408=$line;
|
||
|
|
var $4409=(($4408+$4407)|0);
|
||
|
|
HEAP8[($4409)]=-1;
|
||
|
|
var $4410=$count;
|
||
|
|
var $4411=((($4410)-(1))|0);
|
||
|
|
$count=$4411;
|
||
|
|
var $4412=$x;
|
||
|
|
var $4413=((($4412)+(1))|0);
|
||
|
|
$x=$4413;
|
||
|
|
label=327;break;
|
||
|
|
case 331:
|
||
|
|
label=344;break;
|
||
|
|
case 332:
|
||
|
|
label=333;break;
|
||
|
|
case 333:
|
||
|
|
var $4417=$count;
|
||
|
|
var $4418=$4417&-8;
|
||
|
|
var $4419=($4418|0)!=0;
|
||
|
|
if($4419){label=334;break;}else{var $4426=0;label=335;break;}
|
||
|
|
case 334:
|
||
|
|
var $4421=$x;
|
||
|
|
var $4422=((($4421)+(8))|0);
|
||
|
|
var $4423=$3;
|
||
|
|
var $4424=($4422|0)<($4423|0);
|
||
|
|
var $4426=$4424;label=335;break;
|
||
|
|
case 335:
|
||
|
|
var $4426;
|
||
|
|
if($4426){label=336;break;}else{label=337;break;}
|
||
|
|
case 336:
|
||
|
|
var $4428=$x;
|
||
|
|
var $4429=((($4428)*(3))&-1);
|
||
|
|
var $4430=$line;
|
||
|
|
var $4431=(($4430+$4429)|0);
|
||
|
|
HEAP8[($4431)]=0;
|
||
|
|
var $4432=$x;
|
||
|
|
var $4433=((($4432)*(3))&-1);
|
||
|
|
var $4434=((($4433)+(1))|0);
|
||
|
|
var $4435=$line;
|
||
|
|
var $4436=(($4435+$4434)|0);
|
||
|
|
HEAP8[($4436)]=0;
|
||
|
|
var $4437=$x;
|
||
|
|
var $4438=((($4437)*(3))&-1);
|
||
|
|
var $4439=((($4438)+(2))|0);
|
||
|
|
var $4440=$line;
|
||
|
|
var $4441=(($4440+$4439)|0);
|
||
|
|
HEAP8[($4441)]=0;
|
||
|
|
var $4442=$count;
|
||
|
|
var $4443=((($4442)-(1))|0);
|
||
|
|
$count=$4443;
|
||
|
|
var $4444=$x;
|
||
|
|
var $4445=((($4444)+(1))|0);
|
||
|
|
$x=$4445;
|
||
|
|
var $4446=$x;
|
||
|
|
var $4447=((($4446)*(3))&-1);
|
||
|
|
var $4448=$line;
|
||
|
|
var $4449=(($4448+$4447)|0);
|
||
|
|
HEAP8[($4449)]=0;
|
||
|
|
var $4450=$x;
|
||
|
|
var $4451=((($4450)*(3))&-1);
|
||
|
|
var $4452=((($4451)+(1))|0);
|
||
|
|
var $4453=$line;
|
||
|
|
var $4454=(($4453+$4452)|0);
|
||
|
|
HEAP8[($4454)]=0;
|
||
|
|
var $4455=$x;
|
||
|
|
var $4456=((($4455)*(3))&-1);
|
||
|
|
var $4457=((($4456)+(2))|0);
|
||
|
|
var $4458=$line;
|
||
|
|
var $4459=(($4458+$4457)|0);
|
||
|
|
HEAP8[($4459)]=0;
|
||
|
|
var $4460=$count;
|
||
|
|
var $4461=((($4460)-(1))|0);
|
||
|
|
$count=$4461;
|
||
|
|
var $4462=$x;
|
||
|
|
var $4463=((($4462)+(1))|0);
|
||
|
|
$x=$4463;
|
||
|
|
var $4464=$x;
|
||
|
|
var $4465=((($4464)*(3))&-1);
|
||
|
|
var $4466=$line;
|
||
|
|
var $4467=(($4466+$4465)|0);
|
||
|
|
HEAP8[($4467)]=0;
|
||
|
|
var $4468=$x;
|
||
|
|
var $4469=((($4468)*(3))&-1);
|
||
|
|
var $4470=((($4469)+(1))|0);
|
||
|
|
var $4471=$line;
|
||
|
|
var $4472=(($4471+$4470)|0);
|
||
|
|
HEAP8[($4472)]=0;
|
||
|
|
var $4473=$x;
|
||
|
|
var $4474=((($4473)*(3))&-1);
|
||
|
|
var $4475=((($4474)+(2))|0);
|
||
|
|
var $4476=$line;
|
||
|
|
var $4477=(($4476+$4475)|0);
|
||
|
|
HEAP8[($4477)]=0;
|
||
|
|
var $4478=$count;
|
||
|
|
var $4479=((($4478)-(1))|0);
|
||
|
|
$count=$4479;
|
||
|
|
var $4480=$x;
|
||
|
|
var $4481=((($4480)+(1))|0);
|
||
|
|
$x=$4481;
|
||
|
|
var $4482=$x;
|
||
|
|
var $4483=((($4482)*(3))&-1);
|
||
|
|
var $4484=$line;
|
||
|
|
var $4485=(($4484+$4483)|0);
|
||
|
|
HEAP8[($4485)]=0;
|
||
|
|
var $4486=$x;
|
||
|
|
var $4487=((($4486)*(3))&-1);
|
||
|
|
var $4488=((($4487)+(1))|0);
|
||
|
|
var $4489=$line;
|
||
|
|
var $4490=(($4489+$4488)|0);
|
||
|
|
HEAP8[($4490)]=0;
|
||
|
|
var $4491=$x;
|
||
|
|
var $4492=((($4491)*(3))&-1);
|
||
|
|
var $4493=((($4492)+(2))|0);
|
||
|
|
var $4494=$line;
|
||
|
|
var $4495=(($4494+$4493)|0);
|
||
|
|
HEAP8[($4495)]=0;
|
||
|
|
var $4496=$count;
|
||
|
|
var $4497=((($4496)-(1))|0);
|
||
|
|
$count=$4497;
|
||
|
|
var $4498=$x;
|
||
|
|
var $4499=((($4498)+(1))|0);
|
||
|
|
$x=$4499;
|
||
|
|
var $4500=$x;
|
||
|
|
var $4501=((($4500)*(3))&-1);
|
||
|
|
var $4502=$line;
|
||
|
|
var $4503=(($4502+$4501)|0);
|
||
|
|
HEAP8[($4503)]=0;
|
||
|
|
var $4504=$x;
|
||
|
|
var $4505=((($4504)*(3))&-1);
|
||
|
|
var $4506=((($4505)+(1))|0);
|
||
|
|
var $4507=$line;
|
||
|
|
var $4508=(($4507+$4506)|0);
|
||
|
|
HEAP8[($4508)]=0;
|
||
|
|
var $4509=$x;
|
||
|
|
var $4510=((($4509)*(3))&-1);
|
||
|
|
var $4511=((($4510)+(2))|0);
|
||
|
|
var $4512=$line;
|
||
|
|
var $4513=(($4512+$4511)|0);
|
||
|
|
HEAP8[($4513)]=0;
|
||
|
|
var $4514=$count;
|
||
|
|
var $4515=((($4514)-(1))|0);
|
||
|
|
$count=$4515;
|
||
|
|
var $4516=$x;
|
||
|
|
var $4517=((($4516)+(1))|0);
|
||
|
|
$x=$4517;
|
||
|
|
var $4518=$x;
|
||
|
|
var $4519=((($4518)*(3))&-1);
|
||
|
|
var $4520=$line;
|
||
|
|
var $4521=(($4520+$4519)|0);
|
||
|
|
HEAP8[($4521)]=0;
|
||
|
|
var $4522=$x;
|
||
|
|
var $4523=((($4522)*(3))&-1);
|
||
|
|
var $4524=((($4523)+(1))|0);
|
||
|
|
var $4525=$line;
|
||
|
|
var $4526=(($4525+$4524)|0);
|
||
|
|
HEAP8[($4526)]=0;
|
||
|
|
var $4527=$x;
|
||
|
|
var $4528=((($4527)*(3))&-1);
|
||
|
|
var $4529=((($4528)+(2))|0);
|
||
|
|
var $4530=$line;
|
||
|
|
var $4531=(($4530+$4529)|0);
|
||
|
|
HEAP8[($4531)]=0;
|
||
|
|
var $4532=$count;
|
||
|
|
var $4533=((($4532)-(1))|0);
|
||
|
|
$count=$4533;
|
||
|
|
var $4534=$x;
|
||
|
|
var $4535=((($4534)+(1))|0);
|
||
|
|
$x=$4535;
|
||
|
|
var $4536=$x;
|
||
|
|
var $4537=((($4536)*(3))&-1);
|
||
|
|
var $4538=$line;
|
||
|
|
var $4539=(($4538+$4537)|0);
|
||
|
|
HEAP8[($4539)]=0;
|
||
|
|
var $4540=$x;
|
||
|
|
var $4541=((($4540)*(3))&-1);
|
||
|
|
var $4542=((($4541)+(1))|0);
|
||
|
|
var $4543=$line;
|
||
|
|
var $4544=(($4543+$4542)|0);
|
||
|
|
HEAP8[($4544)]=0;
|
||
|
|
var $4545=$x;
|
||
|
|
var $4546=((($4545)*(3))&-1);
|
||
|
|
var $4547=((($4546)+(2))|0);
|
||
|
|
var $4548=$line;
|
||
|
|
var $4549=(($4548+$4547)|0);
|
||
|
|
HEAP8[($4549)]=0;
|
||
|
|
var $4550=$count;
|
||
|
|
var $4551=((($4550)-(1))|0);
|
||
|
|
$count=$4551;
|
||
|
|
var $4552=$x;
|
||
|
|
var $4553=((($4552)+(1))|0);
|
||
|
|
$x=$4553;
|
||
|
|
var $4554=$x;
|
||
|
|
var $4555=((($4554)*(3))&-1);
|
||
|
|
var $4556=$line;
|
||
|
|
var $4557=(($4556+$4555)|0);
|
||
|
|
HEAP8[($4557)]=0;
|
||
|
|
var $4558=$x;
|
||
|
|
var $4559=((($4558)*(3))&-1);
|
||
|
|
var $4560=((($4559)+(1))|0);
|
||
|
|
var $4561=$line;
|
||
|
|
var $4562=(($4561+$4560)|0);
|
||
|
|
HEAP8[($4562)]=0;
|
||
|
|
var $4563=$x;
|
||
|
|
var $4564=((($4563)*(3))&-1);
|
||
|
|
var $4565=((($4564)+(2))|0);
|
||
|
|
var $4566=$line;
|
||
|
|
var $4567=(($4566+$4565)|0);
|
||
|
|
HEAP8[($4567)]=0;
|
||
|
|
var $4568=$count;
|
||
|
|
var $4569=((($4568)-(1))|0);
|
||
|
|
$count=$4569;
|
||
|
|
var $4570=$x;
|
||
|
|
var $4571=((($4570)+(1))|0);
|
||
|
|
$x=$4571;
|
||
|
|
label=333;break;
|
||
|
|
case 337:
|
||
|
|
label=338;break;
|
||
|
|
case 338:
|
||
|
|
var $4574=$count;
|
||
|
|
var $4575=($4574|0)>0;
|
||
|
|
if($4575){label=339;break;}else{var $4581=0;label=340;break;}
|
||
|
|
case 339:
|
||
|
|
var $4577=$x;
|
||
|
|
var $4578=$3;
|
||
|
|
var $4579=($4577|0)<($4578|0);
|
||
|
|
var $4581=$4579;label=340;break;
|
||
|
|
case 340:
|
||
|
|
var $4581;
|
||
|
|
if($4581){label=341;break;}else{label=342;break;}
|
||
|
|
case 341:
|
||
|
|
var $4583=$x;
|
||
|
|
var $4584=((($4583)*(3))&-1);
|
||
|
|
var $4585=$line;
|
||
|
|
var $4586=(($4585+$4584)|0);
|
||
|
|
HEAP8[($4586)]=0;
|
||
|
|
var $4587=$x;
|
||
|
|
var $4588=((($4587)*(3))&-1);
|
||
|
|
var $4589=((($4588)+(1))|0);
|
||
|
|
var $4590=$line;
|
||
|
|
var $4591=(($4590+$4589)|0);
|
||
|
|
HEAP8[($4591)]=0;
|
||
|
|
var $4592=$x;
|
||
|
|
var $4593=((($4592)*(3))&-1);
|
||
|
|
var $4594=((($4593)+(2))|0);
|
||
|
|
var $4595=$line;
|
||
|
|
var $4596=(($4595+$4594)|0);
|
||
|
|
HEAP8[($4596)]=0;
|
||
|
|
var $4597=$count;
|
||
|
|
var $4598=((($4597)-(1))|0);
|
||
|
|
$count=$4598;
|
||
|
|
var $4599=$x;
|
||
|
|
var $4600=((($4599)+(1))|0);
|
||
|
|
$x=$4600;
|
||
|
|
label=338;break;
|
||
|
|
case 342:
|
||
|
|
label=344;break;
|
||
|
|
case 343:
|
||
|
|
$1=0;
|
||
|
|
label=347;break;
|
||
|
|
case 344:
|
||
|
|
label=34;break;
|
||
|
|
case 345:
|
||
|
|
label=2;break;
|
||
|
|
case 346:
|
||
|
|
$1=1;
|
||
|
|
label=347;break;
|
||
|
|
case 347:
|
||
|
|
var $4607=$1;
|
||
|
|
STACKTOP=sp;return $4607;
|
||
|
|
default: assert(0, "bad label: " + label);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
function _bitmap_decompress_32($output,$output_width,$output_height,$input_width,$input_height,$input,$size){
|
||
|
|
var label=0;
|
||
|
|
var sp=STACKTOP; (assert((STACKTOP|0) < (STACK_MAX|0))|0);
|
||
|
|
label = 1;
|
||
|
|
while(1)switch(label){
|
||
|
|
case 1:
|
||
|
|
var $1;
|
||
|
|
var $2;
|
||
|
|
var $3;
|
||
|
|
var $4;
|
||
|
|
var $5;
|
||
|
|
var $6;
|
||
|
|
var $7;
|
||
|
|
var $temp;
|
||
|
|
var $rv;
|
||
|
|
var $y;
|
||
|
|
var $x;
|
||
|
|
var $r;
|
||
|
|
var $g;
|
||
|
|
var $b;
|
||
|
|
var $a;
|
||
|
|
$1=$output;
|
||
|
|
$2=$output_width;
|
||
|
|
$3=$output_height;
|
||
|
|
$4=$input_width;
|
||
|
|
$5=$input_height;
|
||
|
|
$6=$input;
|
||
|
|
$7=$size;
|
||
|
|
var $8=$4;
|
||
|
|
var $9=$5;
|
||
|
|
var $10=(Math_imul($8,$9)|0);
|
||
|
|
var $11=($10<<2);
|
||
|
|
var $12=_malloc($11);
|
||
|
|
$temp=$12;
|
||
|
|
var $13=$temp;
|
||
|
|
var $14=$4;
|
||
|
|
var $15=$5;
|
||
|
|
var $16=$6;
|
||
|
|
var $17=$7;
|
||
|
|
var $18=_bitmap_decompress4($13,$14,$15,$16,$17);
|
||
|
|
$rv=$18;
|
||
|
|
$y=0;
|
||
|
|
label=2;break;
|
||
|
|
case 2:
|
||
|
|
var $20=$y;
|
||
|
|
var $21=$3;
|
||
|
|
var $22=($20|0)<($21|0);
|
||
|
|
if($22){label=3;break;}else{label=9;break;}
|
||
|
|
case 3:
|
||
|
|
$x=0;
|
||
|
|
label=4;break;
|
||
|
|
case 4:
|
||
|
|
var $25=$x;
|
||
|
|
var $26=$2;
|
||
|
|
var $27=($25|0)<($26|0);
|
||
|
|
if($27){label=5;break;}else{label=7;break;}
|
||
|
|
case 5:
|
||
|
|
var $29=$y;
|
||
|
|
var $30=$4;
|
||
|
|
var $31=(Math_imul($29,$30)|0);
|
||
|
|
var $32=$x;
|
||
|
|
var $33=((($31)+($32))|0);
|
||
|
|
var $34=($33<<2);
|
||
|
|
var $35=$temp;
|
||
|
|
var $36=(($35+$34)|0);
|
||
|
|
var $37=HEAP8[($36)];
|
||
|
|
$r=$37;
|
||
|
|
var $38=$y;
|
||
|
|
var $39=$4;
|
||
|
|
var $40=(Math_imul($38,$39)|0);
|
||
|
|
var $41=$x;
|
||
|
|
var $42=((($40)+($41))|0);
|
||
|
|
var $43=($42<<2);
|
||
|
|
var $44=((($43)+(1))|0);
|
||
|
|
var $45=$temp;
|
||
|
|
var $46=(($45+$44)|0);
|
||
|
|
var $47=HEAP8[($46)];
|
||
|
|
$g=$47;
|
||
|
|
var $48=$y;
|
||
|
|
var $49=$4;
|
||
|
|
var $50=(Math_imul($48,$49)|0);
|
||
|
|
var $51=$x;
|
||
|
|
var $52=((($50)+($51))|0);
|
||
|
|
var $53=($52<<2);
|
||
|
|
var $54=((($53)+(2))|0);
|
||
|
|
var $55=$temp;
|
||
|
|
var $56=(($55+$54)|0);
|
||
|
|
var $57=HEAP8[($56)];
|
||
|
|
$b=$57;
|
||
|
|
var $58=$y;
|
||
|
|
var $59=$4;
|
||
|
|
var $60=(Math_imul($58,$59)|0);
|
||
|
|
var $61=$x;
|
||
|
|
var $62=((($60)+($61))|0);
|
||
|
|
var $63=($62<<2);
|
||
|
|
var $64=((($63)+(3))|0);
|
||
|
|
var $65=$temp;
|
||
|
|
var $66=(($65+$64)|0);
|
||
|
|
var $67=HEAP8[($66)];
|
||
|
|
$a=$67;
|
||
|
|
var $68=$r;
|
||
|
|
var $69=($68&255);
|
||
|
|
var $70=$69<<16;
|
||
|
|
var $71=-16777216|$70;
|
||
|
|
var $72=$g;
|
||
|
|
var $73=($72&255);
|
||
|
|
var $74=$73<<8;
|
||
|
|
var $75=$71|$74;
|
||
|
|
var $76=$b;
|
||
|
|
var $77=($76&255);
|
||
|
|
var $78=$75|$77;
|
||
|
|
var $79=$y;
|
||
|
|
var $80=$2;
|
||
|
|
var $81=(Math_imul($79,$80)|0);
|
||
|
|
var $82=$x;
|
||
|
|
var $83=((($81)+($82))|0);
|
||
|
|
var $84=$1;
|
||
|
|
var $85=$84;
|
||
|
|
var $86=(($85+($83<<2))|0);
|
||
|
|
HEAP32[(($86)>>2)]=$78;
|
||
|
|
label=6;break;
|
||
|
|
case 6:
|
||
|
|
var $88=$x;
|
||
|
|
var $89=((($88)+(1))|0);
|
||
|
|
$x=$89;
|
||
|
|
label=4;break;
|
||
|
|
case 7:
|
||
|
|
label=8;break;
|
||
|
|
case 8:
|
||
|
|
var $92=$y;
|
||
|
|
var $93=((($92)+(1))|0);
|
||
|
|
$y=$93;
|
||
|
|
label=2;break;
|
||
|
|
case 9:
|
||
|
|
var $95=$temp;
|
||
|
|
_free($95);
|
||
|
|
var $96=$rv;
|
||
|
|
STACKTOP=sp;return $96;
|
||
|
|
default: assert(0, "bad label: " + label);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
Module["_bitmap_decompress_32"] = _bitmap_decompress_32;
|
||
|
|
|
||
|
|
function _bitmap_decompress4($output,$width,$height,$input,$size){
|
||
|
|
var label=0;
|
||
|
|
var sp=STACKTOP; (assert((STACKTOP|0) < (STACK_MAX|0))|0);
|
||
|
|
label = 1;
|
||
|
|
while(1)switch(label){
|
||
|
|
case 1:
|
||
|
|
var $1;
|
||
|
|
var $2;
|
||
|
|
var $3;
|
||
|
|
var $4;
|
||
|
|
var $5;
|
||
|
|
var $6;
|
||
|
|
var $code;
|
||
|
|
var $bytes_pro;
|
||
|
|
var $total_pro;
|
||
|
|
$2=$output;
|
||
|
|
$3=$width;
|
||
|
|
$4=$height;
|
||
|
|
$5=$input;
|
||
|
|
$6=$size;
|
||
|
|
var $7=$5;
|
||
|
|
var $8=(($7+1)|0);
|
||
|
|
$5=$8;
|
||
|
|
var $9=HEAP8[($7)];
|
||
|
|
var $10=($9&255);
|
||
|
|
$code=$10;
|
||
|
|
var $11=$code;
|
||
|
|
var $12=($11|0)!=16;
|
||
|
|
if($12){label=2;break;}else{label=3;break;}
|
||
|
|
case 2:
|
||
|
|
$1=0;
|
||
|
|
label=4;break;
|
||
|
|
case 3:
|
||
|
|
$total_pro=1;
|
||
|
|
var $15=$5;
|
||
|
|
var $16=$3;
|
||
|
|
var $17=$4;
|
||
|
|
var $18=$2;
|
||
|
|
var $19=(($18+3)|0);
|
||
|
|
var $20=$6;
|
||
|
|
var $21=$total_pro;
|
||
|
|
var $22=((($20)-($21))|0);
|
||
|
|
var $23=_process_plane($15,$16,$17,$19,$22);
|
||
|
|
$bytes_pro=$23;
|
||
|
|
var $24=$bytes_pro;
|
||
|
|
var $25=$total_pro;
|
||
|
|
var $26=((($25)+($24))|0);
|
||
|
|
$total_pro=$26;
|
||
|
|
var $27=$bytes_pro;
|
||
|
|
var $28=$5;
|
||
|
|
var $29=(($28+$27)|0);
|
||
|
|
$5=$29;
|
||
|
|
var $30=$5;
|
||
|
|
var $31=$3;
|
||
|
|
var $32=$4;
|
||
|
|
var $33=$2;
|
||
|
|
var $34=(($33+2)|0);
|
||
|
|
var $35=$6;
|
||
|
|
var $36=$total_pro;
|
||
|
|
var $37=((($35)-($36))|0);
|
||
|
|
var $38=_process_plane($30,$31,$32,$34,$37);
|
||
|
|
$bytes_pro=$38;
|
||
|
|
var $39=$bytes_pro;
|
||
|
|
var $40=$total_pro;
|
||
|
|
var $41=((($40)+($39))|0);
|
||
|
|
$total_pro=$41;
|
||
|
|
var $42=$bytes_pro;
|
||
|
|
var $43=$5;
|
||
|
|
var $44=(($43+$42)|0);
|
||
|
|
$5=$44;
|
||
|
|
var $45=$5;
|
||
|
|
var $46=$3;
|
||
|
|
var $47=$4;
|
||
|
|
var $48=$2;
|
||
|
|
var $49=(($48+1)|0);
|
||
|
|
var $50=$6;
|
||
|
|
var $51=$total_pro;
|
||
|
|
var $52=((($50)-($51))|0);
|
||
|
|
var $53=_process_plane($45,$46,$47,$49,$52);
|
||
|
|
$bytes_pro=$53;
|
||
|
|
var $54=$bytes_pro;
|
||
|
|
var $55=$total_pro;
|
||
|
|
var $56=((($55)+($54))|0);
|
||
|
|
$total_pro=$56;
|
||
|
|
var $57=$bytes_pro;
|
||
|
|
var $58=$5;
|
||
|
|
var $59=(($58+$57)|0);
|
||
|
|
$5=$59;
|
||
|
|
var $60=$5;
|
||
|
|
var $61=$3;
|
||
|
|
var $62=$4;
|
||
|
|
var $63=$2;
|
||
|
|
var $64=(($63)|0);
|
||
|
|
var $65=$6;
|
||
|
|
var $66=$total_pro;
|
||
|
|
var $67=((($65)-($66))|0);
|
||
|
|
var $68=_process_plane($60,$61,$62,$64,$67);
|
||
|
|
$bytes_pro=$68;
|
||
|
|
var $69=$bytes_pro;
|
||
|
|
var $70=$total_pro;
|
||
|
|
var $71=((($70)+($69))|0);
|
||
|
|
$total_pro=$71;
|
||
|
|
var $72=$6;
|
||
|
|
var $73=$total_pro;
|
||
|
|
var $74=($72|0)==($73|0);
|
||
|
|
var $75=($74&1);
|
||
|
|
$1=$75;
|
||
|
|
label=4;break;
|
||
|
|
case 4:
|
||
|
|
var $77=$1;
|
||
|
|
STACKTOP=sp;return $77;
|
||
|
|
default: assert(0, "bad label: " + label);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
function _process_plane($in,$width,$height,$out,$size){
|
||
|
|
var label=0;
|
||
|
|
var sp=STACKTOP; (assert((STACKTOP|0) < (STACK_MAX|0))|0);
|
||
|
|
label = 1;
|
||
|
|
while(1)switch(label){
|
||
|
|
case 1:
|
||
|
|
var $1;
|
||
|
|
var $2;
|
||
|
|
var $3;
|
||
|
|
var $4;
|
||
|
|
var $5;
|
||
|
|
var $indexw;
|
||
|
|
var $indexh;
|
||
|
|
var $code;
|
||
|
|
var $collen;
|
||
|
|
var $replen;
|
||
|
|
var $color;
|
||
|
|
var $x;
|
||
|
|
var $revcode;
|
||
|
|
var $last_line;
|
||
|
|
var $this_line;
|
||
|
|
var $org_in;
|
||
|
|
var $org_out;
|
||
|
|
$1=$in;
|
||
|
|
$2=$width;
|
||
|
|
$3=$height;
|
||
|
|
$4=$out;
|
||
|
|
$5=$size;
|
||
|
|
var $6=$1;
|
||
|
|
$org_in=$6;
|
||
|
|
var $7=$4;
|
||
|
|
$org_out=$7;
|
||
|
|
$last_line=0;
|
||
|
|
$indexh=0;
|
||
|
|
label=2;break;
|
||
|
|
case 2:
|
||
|
|
var $9=$indexh;
|
||
|
|
var $10=$3;
|
||
|
|
var $11=($9|0)<($10|0);
|
||
|
|
if($11){label=3;break;}else{label=34;break;}
|
||
|
|
case 3:
|
||
|
|
var $13=$org_out;
|
||
|
|
var $14=$2;
|
||
|
|
var $15=$3;
|
||
|
|
var $16=(Math_imul($14,$15)|0);
|
||
|
|
var $17=($16<<2);
|
||
|
|
var $18=(($13+$17)|0);
|
||
|
|
var $19=$indexh;
|
||
|
|
var $20=((($19)+(1))|0);
|
||
|
|
var $21=$2;
|
||
|
|
var $22=(Math_imul($20,$21)|0);
|
||
|
|
var $23=($22<<2);
|
||
|
|
var $24=(((-$23))|0);
|
||
|
|
var $25=(($18+$24)|0);
|
||
|
|
$4=$25;
|
||
|
|
$color=0;
|
||
|
|
var $26=$4;
|
||
|
|
$this_line=$26;
|
||
|
|
$indexw=0;
|
||
|
|
var $27=$last_line;
|
||
|
|
var $28=($27|0)==0;
|
||
|
|
if($28){label=4;break;}else{label=17;break;}
|
||
|
|
case 4:
|
||
|
|
label=5;break;
|
||
|
|
case 5:
|
||
|
|
var $31=$indexw;
|
||
|
|
var $32=$2;
|
||
|
|
var $33=($31|0)<($32|0);
|
||
|
|
if($33){label=6;break;}else{label=16;break;}
|
||
|
|
case 6:
|
||
|
|
var $35=$1;
|
||
|
|
var $36=(($35+1)|0);
|
||
|
|
$1=$36;
|
||
|
|
var $37=HEAP8[($35)];
|
||
|
|
var $38=($37&255);
|
||
|
|
$code=$38;
|
||
|
|
var $39=$code;
|
||
|
|
var $40=$39&15;
|
||
|
|
$replen=$40;
|
||
|
|
var $41=$code;
|
||
|
|
var $42=$41>>4;
|
||
|
|
var $43=$42&15;
|
||
|
|
$collen=$43;
|
||
|
|
var $44=$replen;
|
||
|
|
var $45=$44<<4;
|
||
|
|
var $46=$collen;
|
||
|
|
var $47=$45|$46;
|
||
|
|
$revcode=$47;
|
||
|
|
var $48=$revcode;
|
||
|
|
var $49=($48|0)<=47;
|
||
|
|
if($49){label=7;break;}else{label=9;break;}
|
||
|
|
case 7:
|
||
|
|
var $51=$revcode;
|
||
|
|
var $52=($51|0)>=16;
|
||
|
|
if($52){label=8;break;}else{label=9;break;}
|
||
|
|
case 8:
|
||
|
|
var $54=$revcode;
|
||
|
|
$replen=$54;
|
||
|
|
$collen=0;
|
||
|
|
label=9;break;
|
||
|
|
case 9:
|
||
|
|
label=10;break;
|
||
|
|
case 10:
|
||
|
|
var $57=$collen;
|
||
|
|
var $58=($57|0)>0;
|
||
|
|
if($58){label=11;break;}else{label=12;break;}
|
||
|
|
case 11:
|
||
|
|
var $60=$1;
|
||
|
|
var $61=(($60+1)|0);
|
||
|
|
$1=$61;
|
||
|
|
var $62=HEAP8[($60)];
|
||
|
|
var $63=($62&255);
|
||
|
|
$color=$63;
|
||
|
|
var $64=$color;
|
||
|
|
var $65=(($64)&255);
|
||
|
|
var $66=$4;
|
||
|
|
HEAP8[($66)]=$65;
|
||
|
|
var $67=$4;
|
||
|
|
var $68=(($67+4)|0);
|
||
|
|
$4=$68;
|
||
|
|
var $69=$indexw;
|
||
|
|
var $70=((($69)+(1))|0);
|
||
|
|
$indexw=$70;
|
||
|
|
var $71=$collen;
|
||
|
|
var $72=((($71)-(1))|0);
|
||
|
|
$collen=$72;
|
||
|
|
label=10;break;
|
||
|
|
case 12:
|
||
|
|
label=13;break;
|
||
|
|
case 13:
|
||
|
|
var $75=$replen;
|
||
|
|
var $76=($75|0)>0;
|
||
|
|
if($76){label=14;break;}else{label=15;break;}
|
||
|
|
case 14:
|
||
|
|
var $78=$color;
|
||
|
|
var $79=(($78)&255);
|
||
|
|
var $80=$4;
|
||
|
|
HEAP8[($80)]=$79;
|
||
|
|
var $81=$4;
|
||
|
|
var $82=(($81+4)|0);
|
||
|
|
$4=$82;
|
||
|
|
var $83=$indexw;
|
||
|
|
var $84=((($83)+(1))|0);
|
||
|
|
$indexw=$84;
|
||
|
|
var $85=$replen;
|
||
|
|
var $86=((($85)-(1))|0);
|
||
|
|
$replen=$86;
|
||
|
|
label=13;break;
|
||
|
|
case 15:
|
||
|
|
label=5;break;
|
||
|
|
case 16:
|
||
|
|
label=33;break;
|
||
|
|
case 17:
|
||
|
|
label=18;break;
|
||
|
|
case 18:
|
||
|
|
var $91=$indexw;
|
||
|
|
var $92=$2;
|
||
|
|
var $93=($91|0)<($92|0);
|
||
|
|
if($93){label=19;break;}else{label=32;break;}
|
||
|
|
case 19:
|
||
|
|
var $95=$1;
|
||
|
|
var $96=(($95+1)|0);
|
||
|
|
$1=$96;
|
||
|
|
var $97=HEAP8[($95)];
|
||
|
|
var $98=($97&255);
|
||
|
|
$code=$98;
|
||
|
|
var $99=$code;
|
||
|
|
var $100=$99&15;
|
||
|
|
$replen=$100;
|
||
|
|
var $101=$code;
|
||
|
|
var $102=$101>>4;
|
||
|
|
var $103=$102&15;
|
||
|
|
$collen=$103;
|
||
|
|
var $104=$replen;
|
||
|
|
var $105=$104<<4;
|
||
|
|
var $106=$collen;
|
||
|
|
var $107=$105|$106;
|
||
|
|
$revcode=$107;
|
||
|
|
var $108=$revcode;
|
||
|
|
var $109=($108|0)<=47;
|
||
|
|
if($109){label=20;break;}else{label=22;break;}
|
||
|
|
case 20:
|
||
|
|
var $111=$revcode;
|
||
|
|
var $112=($111|0)>=16;
|
||
|
|
if($112){label=21;break;}else{label=22;break;}
|
||
|
|
case 21:
|
||
|
|
var $114=$revcode;
|
||
|
|
$replen=$114;
|
||
|
|
$collen=0;
|
||
|
|
label=22;break;
|
||
|
|
case 22:
|
||
|
|
label=23;break;
|
||
|
|
case 23:
|
||
|
|
var $117=$collen;
|
||
|
|
var $118=($117|0)>0;
|
||
|
|
if($118){label=24;break;}else{label=28;break;}
|
||
|
|
case 24:
|
||
|
|
var $120=$1;
|
||
|
|
var $121=(($120+1)|0);
|
||
|
|
$1=$121;
|
||
|
|
var $122=HEAP8[($120)];
|
||
|
|
var $123=($122&255);
|
||
|
|
$x=$123;
|
||
|
|
var $124=$x;
|
||
|
|
var $125=$124&1;
|
||
|
|
var $126=($125|0)!=0;
|
||
|
|
if($126){label=25;break;}else{label=26;break;}
|
||
|
|
case 25:
|
||
|
|
var $128=$x;
|
||
|
|
var $129=$128>>1;
|
||
|
|
$x=$129;
|
||
|
|
var $130=$x;
|
||
|
|
var $131=((($130)+(1))|0);
|
||
|
|
$x=$131;
|
||
|
|
var $132=$x;
|
||
|
|
var $133=(((-$132))|0);
|
||
|
|
$color=$133;
|
||
|
|
label=27;break;
|
||
|
|
case 26:
|
||
|
|
var $135=$x;
|
||
|
|
var $136=$135>>1;
|
||
|
|
$x=$136;
|
||
|
|
var $137=$x;
|
||
|
|
$color=$137;
|
||
|
|
label=27;break;
|
||
|
|
case 27:
|
||
|
|
var $139=$indexw;
|
||
|
|
var $140=($139<<2);
|
||
|
|
var $141=$last_line;
|
||
|
|
var $142=(($141+$140)|0);
|
||
|
|
var $143=HEAP8[($142)];
|
||
|
|
var $144=($143&255);
|
||
|
|
var $145=$color;
|
||
|
|
var $146=((($144)+($145))|0);
|
||
|
|
$x=$146;
|
||
|
|
var $147=$x;
|
||
|
|
var $148=(($147)&255);
|
||
|
|
var $149=$4;
|
||
|
|
HEAP8[($149)]=$148;
|
||
|
|
var $150=$4;
|
||
|
|
var $151=(($150+4)|0);
|
||
|
|
$4=$151;
|
||
|
|
var $152=$indexw;
|
||
|
|
var $153=((($152)+(1))|0);
|
||
|
|
$indexw=$153;
|
||
|
|
var $154=$collen;
|
||
|
|
var $155=((($154)-(1))|0);
|
||
|
|
$collen=$155;
|
||
|
|
label=23;break;
|
||
|
|
case 28:
|
||
|
|
label=29;break;
|
||
|
|
case 29:
|
||
|
|
var $158=$replen;
|
||
|
|
var $159=($158|0)>0;
|
||
|
|
if($159){label=30;break;}else{label=31;break;}
|
||
|
|
case 30:
|
||
|
|
var $161=$indexw;
|
||
|
|
var $162=($161<<2);
|
||
|
|
var $163=$last_line;
|
||
|
|
var $164=(($163+$162)|0);
|
||
|
|
var $165=HEAP8[($164)];
|
||
|
|
var $166=($165&255);
|
||
|
|
var $167=$color;
|
||
|
|
var $168=((($166)+($167))|0);
|
||
|
|
$x=$168;
|
||
|
|
var $169=$x;
|
||
|
|
var $170=(($169)&255);
|
||
|
|
var $171=$4;
|
||
|
|
HEAP8[($171)]=$170;
|
||
|
|
var $172=$4;
|
||
|
|
var $173=(($172+4)|0);
|
||
|
|
$4=$173;
|
||
|
|
var $174=$indexw;
|
||
|
|
var $175=((($174)+(1))|0);
|
||
|
|
$indexw=$175;
|
||
|
|
var $176=$replen;
|
||
|
|
var $177=((($176)-(1))|0);
|
||
|
|
$replen=$177;
|
||
|
|
label=29;break;
|
||
|
|
case 31:
|
||
|
|
label=18;break;
|
||
|
|
case 32:
|
||
|
|
label=33;break;
|
||
|
|
case 33:
|
||
|
|
var $181=$indexh;
|
||
|
|
var $182=((($181)+(1))|0);
|
||
|
|
$indexh=$182;
|
||
|
|
var $183=$this_line;
|
||
|
|
$last_line=$183;
|
||
|
|
label=2;break;
|
||
|
|
case 34:
|
||
|
|
var $185=$1;
|
||
|
|
var $186=$org_in;
|
||
|
|
var $187=$185;
|
||
|
|
var $188=$186;
|
||
|
|
var $189=((($187)-($188))|0);
|
||
|
|
STACKTOP=sp;return $189;
|
||
|
|
default: assert(0, "bad label: " + label);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
function _malloc($bytes){
|
||
|
|
var label=0;
|
||
|
|
|
||
|
|
label = 1;
|
||
|
|
while(1)switch(label){
|
||
|
|
case 1:
|
||
|
|
var $1=($bytes>>>0)<245;
|
||
|
|
if($1){label=2;break;}else{label=78;break;}
|
||
|
|
case 2:
|
||
|
|
var $3=($bytes>>>0)<11;
|
||
|
|
if($3){var $8=16;label=4;break;}else{label=3;break;}
|
||
|
|
case 3:
|
||
|
|
var $5=((($bytes)+(11))|0);
|
||
|
|
var $6=$5&-8;
|
||
|
|
var $8=$6;label=4;break;
|
||
|
|
case 4:
|
||
|
|
var $8;
|
||
|
|
var $9=$8>>>3;
|
||
|
|
var $10=HEAP32[((40)>>2)];
|
||
|
|
var $11=$10>>>($9>>>0);
|
||
|
|
var $12=$11&3;
|
||
|
|
var $13=($12|0)==0;
|
||
|
|
if($13){label=12;break;}else{label=5;break;}
|
||
|
|
case 5:
|
||
|
|
var $15=$11&1;
|
||
|
|
var $16=$15^1;
|
||
|
|
var $17=((($16)+($9))|0);
|
||
|
|
var $18=$17<<1;
|
||
|
|
var $19=((80+($18<<2))|0);
|
||
|
|
var $20=$19;
|
||
|
|
var $_sum11=((($18)+(2))|0);
|
||
|
|
var $21=((80+($_sum11<<2))|0);
|
||
|
|
var $22=HEAP32[(($21)>>2)];
|
||
|
|
var $23=(($22+8)|0);
|
||
|
|
var $24=HEAP32[(($23)>>2)];
|
||
|
|
var $25=($20|0)==($24|0);
|
||
|
|
if($25){label=6;break;}else{label=7;break;}
|
||
|
|
case 6:
|
||
|
|
var $27=1<<$17;
|
||
|
|
var $28=$27^-1;
|
||
|
|
var $29=$10&$28;
|
||
|
|
HEAP32[((40)>>2)]=$29;
|
||
|
|
label=11;break;
|
||
|
|
case 7:
|
||
|
|
var $31=$24;
|
||
|
|
var $32=HEAP32[((56)>>2)];
|
||
|
|
var $33=($31>>>0)<($32>>>0);
|
||
|
|
if($33){label=10;break;}else{label=8;break;}
|
||
|
|
case 8:
|
||
|
|
var $35=(($24+12)|0);
|
||
|
|
var $36=HEAP32[(($35)>>2)];
|
||
|
|
var $37=($36|0)==($22|0);
|
||
|
|
if($37){label=9;break;}else{label=10;break;}
|
||
|
|
case 9:
|
||
|
|
HEAP32[(($35)>>2)]=$20;
|
||
|
|
HEAP32[(($21)>>2)]=$24;
|
||
|
|
label=11;break;
|
||
|
|
case 10:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 11:
|
||
|
|
var $40=$17<<3;
|
||
|
|
var $41=$40|3;
|
||
|
|
var $42=(($22+4)|0);
|
||
|
|
HEAP32[(($42)>>2)]=$41;
|
||
|
|
var $43=$22;
|
||
|
|
var $_sum1314=$40|4;
|
||
|
|
var $44=(($43+$_sum1314)|0);
|
||
|
|
var $45=$44;
|
||
|
|
var $46=HEAP32[(($45)>>2)];
|
||
|
|
var $47=$46|1;
|
||
|
|
HEAP32[(($45)>>2)]=$47;
|
||
|
|
var $48=$23;
|
||
|
|
var $mem_0=$48;label=341;break;
|
||
|
|
case 12:
|
||
|
|
var $50=HEAP32[((48)>>2)];
|
||
|
|
var $51=($8>>>0)>($50>>>0);
|
||
|
|
if($51){label=13;break;}else{var $nb_0=$8;label=160;break;}
|
||
|
|
case 13:
|
||
|
|
var $53=($11|0)==0;
|
||
|
|
if($53){label=27;break;}else{label=14;break;}
|
||
|
|
case 14:
|
||
|
|
var $55=$11<<$9;
|
||
|
|
var $56=2<<$9;
|
||
|
|
var $57=(((-$56))|0);
|
||
|
|
var $58=$56|$57;
|
||
|
|
var $59=$55&$58;
|
||
|
|
var $60=(((-$59))|0);
|
||
|
|
var $61=$59&$60;
|
||
|
|
var $62=((($61)-(1))|0);
|
||
|
|
var $63=$62>>>12;
|
||
|
|
var $64=$63&16;
|
||
|
|
var $65=$62>>>($64>>>0);
|
||
|
|
var $66=$65>>>5;
|
||
|
|
var $67=$66&8;
|
||
|
|
var $68=$67|$64;
|
||
|
|
var $69=$65>>>($67>>>0);
|
||
|
|
var $70=$69>>>2;
|
||
|
|
var $71=$70&4;
|
||
|
|
var $72=$68|$71;
|
||
|
|
var $73=$69>>>($71>>>0);
|
||
|
|
var $74=$73>>>1;
|
||
|
|
var $75=$74&2;
|
||
|
|
var $76=$72|$75;
|
||
|
|
var $77=$73>>>($75>>>0);
|
||
|
|
var $78=$77>>>1;
|
||
|
|
var $79=$78&1;
|
||
|
|
var $80=$76|$79;
|
||
|
|
var $81=$77>>>($79>>>0);
|
||
|
|
var $82=((($80)+($81))|0);
|
||
|
|
var $83=$82<<1;
|
||
|
|
var $84=((80+($83<<2))|0);
|
||
|
|
var $85=$84;
|
||
|
|
var $_sum4=((($83)+(2))|0);
|
||
|
|
var $86=((80+($_sum4<<2))|0);
|
||
|
|
var $87=HEAP32[(($86)>>2)];
|
||
|
|
var $88=(($87+8)|0);
|
||
|
|
var $89=HEAP32[(($88)>>2)];
|
||
|
|
var $90=($85|0)==($89|0);
|
||
|
|
if($90){label=15;break;}else{label=16;break;}
|
||
|
|
case 15:
|
||
|
|
var $92=1<<$82;
|
||
|
|
var $93=$92^-1;
|
||
|
|
var $94=$10&$93;
|
||
|
|
HEAP32[((40)>>2)]=$94;
|
||
|
|
label=20;break;
|
||
|
|
case 16:
|
||
|
|
var $96=$89;
|
||
|
|
var $97=HEAP32[((56)>>2)];
|
||
|
|
var $98=($96>>>0)<($97>>>0);
|
||
|
|
if($98){label=19;break;}else{label=17;break;}
|
||
|
|
case 17:
|
||
|
|
var $100=(($89+12)|0);
|
||
|
|
var $101=HEAP32[(($100)>>2)];
|
||
|
|
var $102=($101|0)==($87|0);
|
||
|
|
if($102){label=18;break;}else{label=19;break;}
|
||
|
|
case 18:
|
||
|
|
HEAP32[(($100)>>2)]=$85;
|
||
|
|
HEAP32[(($86)>>2)]=$89;
|
||
|
|
label=20;break;
|
||
|
|
case 19:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 20:
|
||
|
|
var $105=$82<<3;
|
||
|
|
var $106=((($105)-($8))|0);
|
||
|
|
var $107=$8|3;
|
||
|
|
var $108=(($87+4)|0);
|
||
|
|
HEAP32[(($108)>>2)]=$107;
|
||
|
|
var $109=$87;
|
||
|
|
var $110=(($109+$8)|0);
|
||
|
|
var $111=$110;
|
||
|
|
var $112=$106|1;
|
||
|
|
var $_sum67=$8|4;
|
||
|
|
var $113=(($109+$_sum67)|0);
|
||
|
|
var $114=$113;
|
||
|
|
HEAP32[(($114)>>2)]=$112;
|
||
|
|
var $115=(($109+$105)|0);
|
||
|
|
var $116=$115;
|
||
|
|
HEAP32[(($116)>>2)]=$106;
|
||
|
|
var $117=HEAP32[((48)>>2)];
|
||
|
|
var $118=($117|0)==0;
|
||
|
|
if($118){label=26;break;}else{label=21;break;}
|
||
|
|
case 21:
|
||
|
|
var $120=HEAP32[((60)>>2)];
|
||
|
|
var $121=$117>>>3;
|
||
|
|
var $122=$121<<1;
|
||
|
|
var $123=((80+($122<<2))|0);
|
||
|
|
var $124=$123;
|
||
|
|
var $125=HEAP32[((40)>>2)];
|
||
|
|
var $126=1<<$121;
|
||
|
|
var $127=$125&$126;
|
||
|
|
var $128=($127|0)==0;
|
||
|
|
if($128){label=22;break;}else{label=23;break;}
|
||
|
|
case 22:
|
||
|
|
var $130=$125|$126;
|
||
|
|
HEAP32[((40)>>2)]=$130;
|
||
|
|
var $_sum9_pre=((($122)+(2))|0);
|
||
|
|
var $_pre=((80+($_sum9_pre<<2))|0);
|
||
|
|
var $F4_0=$124;var $_pre_phi=$_pre;label=25;break;
|
||
|
|
case 23:
|
||
|
|
var $_sum10=((($122)+(2))|0);
|
||
|
|
var $132=((80+($_sum10<<2))|0);
|
||
|
|
var $133=HEAP32[(($132)>>2)];
|
||
|
|
var $134=$133;
|
||
|
|
var $135=HEAP32[((56)>>2)];
|
||
|
|
var $136=($134>>>0)<($135>>>0);
|
||
|
|
if($136){label=24;break;}else{var $F4_0=$133;var $_pre_phi=$132;label=25;break;}
|
||
|
|
case 24:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 25:
|
||
|
|
var $_pre_phi;
|
||
|
|
var $F4_0;
|
||
|
|
HEAP32[(($_pre_phi)>>2)]=$120;
|
||
|
|
var $139=(($F4_0+12)|0);
|
||
|
|
HEAP32[(($139)>>2)]=$120;
|
||
|
|
var $140=(($120+8)|0);
|
||
|
|
HEAP32[(($140)>>2)]=$F4_0;
|
||
|
|
var $141=(($120+12)|0);
|
||
|
|
HEAP32[(($141)>>2)]=$124;
|
||
|
|
label=26;break;
|
||
|
|
case 26:
|
||
|
|
HEAP32[((48)>>2)]=$106;
|
||
|
|
HEAP32[((60)>>2)]=$111;
|
||
|
|
var $143=$88;
|
||
|
|
var $mem_0=$143;label=341;break;
|
||
|
|
case 27:
|
||
|
|
var $145=HEAP32[((44)>>2)];
|
||
|
|
var $146=($145|0)==0;
|
||
|
|
if($146){var $nb_0=$8;label=160;break;}else{label=28;break;}
|
||
|
|
case 28:
|
||
|
|
var $148=(((-$145))|0);
|
||
|
|
var $149=$145&$148;
|
||
|
|
var $150=((($149)-(1))|0);
|
||
|
|
var $151=$150>>>12;
|
||
|
|
var $152=$151&16;
|
||
|
|
var $153=$150>>>($152>>>0);
|
||
|
|
var $154=$153>>>5;
|
||
|
|
var $155=$154&8;
|
||
|
|
var $156=$155|$152;
|
||
|
|
var $157=$153>>>($155>>>0);
|
||
|
|
var $158=$157>>>2;
|
||
|
|
var $159=$158&4;
|
||
|
|
var $160=$156|$159;
|
||
|
|
var $161=$157>>>($159>>>0);
|
||
|
|
var $162=$161>>>1;
|
||
|
|
var $163=$162&2;
|
||
|
|
var $164=$160|$163;
|
||
|
|
var $165=$161>>>($163>>>0);
|
||
|
|
var $166=$165>>>1;
|
||
|
|
var $167=$166&1;
|
||
|
|
var $168=$164|$167;
|
||
|
|
var $169=$165>>>($167>>>0);
|
||
|
|
var $170=((($168)+($169))|0);
|
||
|
|
var $171=((344+($170<<2))|0);
|
||
|
|
var $172=HEAP32[(($171)>>2)];
|
||
|
|
var $173=(($172+4)|0);
|
||
|
|
var $174=HEAP32[(($173)>>2)];
|
||
|
|
var $175=$174&-8;
|
||
|
|
var $176=((($175)-($8))|0);
|
||
|
|
var $t_0_i=$172;var $v_0_i=$172;var $rsize_0_i=$176;label=29;break;
|
||
|
|
case 29:
|
||
|
|
var $rsize_0_i;
|
||
|
|
var $v_0_i;
|
||
|
|
var $t_0_i;
|
||
|
|
var $178=(($t_0_i+16)|0);
|
||
|
|
var $179=HEAP32[(($178)>>2)];
|
||
|
|
var $180=($179|0)==0;
|
||
|
|
if($180){label=30;break;}else{var $185=$179;label=31;break;}
|
||
|
|
case 30:
|
||
|
|
var $182=(($t_0_i+20)|0);
|
||
|
|
var $183=HEAP32[(($182)>>2)];
|
||
|
|
var $184=($183|0)==0;
|
||
|
|
if($184){label=32;break;}else{var $185=$183;label=31;break;}
|
||
|
|
case 31:
|
||
|
|
var $185;
|
||
|
|
var $186=(($185+4)|0);
|
||
|
|
var $187=HEAP32[(($186)>>2)];
|
||
|
|
var $188=$187&-8;
|
||
|
|
var $189=((($188)-($8))|0);
|
||
|
|
var $190=($189>>>0)<($rsize_0_i>>>0);
|
||
|
|
var $_rsize_0_i=($190?$189:$rsize_0_i);
|
||
|
|
var $_v_0_i=($190?$185:$v_0_i);
|
||
|
|
var $t_0_i=$185;var $v_0_i=$_v_0_i;var $rsize_0_i=$_rsize_0_i;label=29;break;
|
||
|
|
case 32:
|
||
|
|
var $192=$v_0_i;
|
||
|
|
var $193=HEAP32[((56)>>2)];
|
||
|
|
var $194=($192>>>0)<($193>>>0);
|
||
|
|
if($194){label=76;break;}else{label=33;break;}
|
||
|
|
case 33:
|
||
|
|
var $196=(($192+$8)|0);
|
||
|
|
var $197=$196;
|
||
|
|
var $198=($192>>>0)<($196>>>0);
|
||
|
|
if($198){label=34;break;}else{label=76;break;}
|
||
|
|
case 34:
|
||
|
|
var $200=(($v_0_i+24)|0);
|
||
|
|
var $201=HEAP32[(($200)>>2)];
|
||
|
|
var $202=(($v_0_i+12)|0);
|
||
|
|
var $203=HEAP32[(($202)>>2)];
|
||
|
|
var $204=($203|0)==($v_0_i|0);
|
||
|
|
if($204){label=40;break;}else{label=35;break;}
|
||
|
|
case 35:
|
||
|
|
var $206=(($v_0_i+8)|0);
|
||
|
|
var $207=HEAP32[(($206)>>2)];
|
||
|
|
var $208=$207;
|
||
|
|
var $209=($208>>>0)<($193>>>0);
|
||
|
|
if($209){label=39;break;}else{label=36;break;}
|
||
|
|
case 36:
|
||
|
|
var $211=(($207+12)|0);
|
||
|
|
var $212=HEAP32[(($211)>>2)];
|
||
|
|
var $213=($212|0)==($v_0_i|0);
|
||
|
|
if($213){label=37;break;}else{label=39;break;}
|
||
|
|
case 37:
|
||
|
|
var $215=(($203+8)|0);
|
||
|
|
var $216=HEAP32[(($215)>>2)];
|
||
|
|
var $217=($216|0)==($v_0_i|0);
|
||
|
|
if($217){label=38;break;}else{label=39;break;}
|
||
|
|
case 38:
|
||
|
|
HEAP32[(($211)>>2)]=$203;
|
||
|
|
HEAP32[(($215)>>2)]=$207;
|
||
|
|
var $R_1_i=$203;label=47;break;
|
||
|
|
case 39:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 40:
|
||
|
|
var $220=(($v_0_i+20)|0);
|
||
|
|
var $221=HEAP32[(($220)>>2)];
|
||
|
|
var $222=($221|0)==0;
|
||
|
|
if($222){label=41;break;}else{var $R_0_i=$221;var $RP_0_i=$220;label=42;break;}
|
||
|
|
case 41:
|
||
|
|
var $224=(($v_0_i+16)|0);
|
||
|
|
var $225=HEAP32[(($224)>>2)];
|
||
|
|
var $226=($225|0)==0;
|
||
|
|
if($226){var $R_1_i=0;label=47;break;}else{var $R_0_i=$225;var $RP_0_i=$224;label=42;break;}
|
||
|
|
case 42:
|
||
|
|
var $RP_0_i;
|
||
|
|
var $R_0_i;
|
||
|
|
var $227=(($R_0_i+20)|0);
|
||
|
|
var $228=HEAP32[(($227)>>2)];
|
||
|
|
var $229=($228|0)==0;
|
||
|
|
if($229){label=43;break;}else{var $R_0_i=$228;var $RP_0_i=$227;label=42;break;}
|
||
|
|
case 43:
|
||
|
|
var $231=(($R_0_i+16)|0);
|
||
|
|
var $232=HEAP32[(($231)>>2)];
|
||
|
|
var $233=($232|0)==0;
|
||
|
|
if($233){label=44;break;}else{var $R_0_i=$232;var $RP_0_i=$231;label=42;break;}
|
||
|
|
case 44:
|
||
|
|
var $235=$RP_0_i;
|
||
|
|
var $236=($235>>>0)<($193>>>0);
|
||
|
|
if($236){label=46;break;}else{label=45;break;}
|
||
|
|
case 45:
|
||
|
|
HEAP32[(($RP_0_i)>>2)]=0;
|
||
|
|
var $R_1_i=$R_0_i;label=47;break;
|
||
|
|
case 46:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 47:
|
||
|
|
var $R_1_i;
|
||
|
|
var $240=($201|0)==0;
|
||
|
|
if($240){label=67;break;}else{label=48;break;}
|
||
|
|
case 48:
|
||
|
|
var $242=(($v_0_i+28)|0);
|
||
|
|
var $243=HEAP32[(($242)>>2)];
|
||
|
|
var $244=((344+($243<<2))|0);
|
||
|
|
var $245=HEAP32[(($244)>>2)];
|
||
|
|
var $246=($v_0_i|0)==($245|0);
|
||
|
|
if($246){label=49;break;}else{label=51;break;}
|
||
|
|
case 49:
|
||
|
|
HEAP32[(($244)>>2)]=$R_1_i;
|
||
|
|
var $cond_i=($R_1_i|0)==0;
|
||
|
|
if($cond_i){label=50;break;}else{label=57;break;}
|
||
|
|
case 50:
|
||
|
|
var $248=HEAP32[(($242)>>2)];
|
||
|
|
var $249=1<<$248;
|
||
|
|
var $250=$249^-1;
|
||
|
|
var $251=HEAP32[((44)>>2)];
|
||
|
|
var $252=$251&$250;
|
||
|
|
HEAP32[((44)>>2)]=$252;
|
||
|
|
label=67;break;
|
||
|
|
case 51:
|
||
|
|
var $254=$201;
|
||
|
|
var $255=HEAP32[((56)>>2)];
|
||
|
|
var $256=($254>>>0)<($255>>>0);
|
||
|
|
if($256){label=55;break;}else{label=52;break;}
|
||
|
|
case 52:
|
||
|
|
var $258=(($201+16)|0);
|
||
|
|
var $259=HEAP32[(($258)>>2)];
|
||
|
|
var $260=($259|0)==($v_0_i|0);
|
||
|
|
if($260){label=53;break;}else{label=54;break;}
|
||
|
|
case 53:
|
||
|
|
HEAP32[(($258)>>2)]=$R_1_i;
|
||
|
|
label=56;break;
|
||
|
|
case 54:
|
||
|
|
var $263=(($201+20)|0);
|
||
|
|
HEAP32[(($263)>>2)]=$R_1_i;
|
||
|
|
label=56;break;
|
||
|
|
case 55:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 56:
|
||
|
|
var $266=($R_1_i|0)==0;
|
||
|
|
if($266){label=67;break;}else{label=57;break;}
|
||
|
|
case 57:
|
||
|
|
var $268=$R_1_i;
|
||
|
|
var $269=HEAP32[((56)>>2)];
|
||
|
|
var $270=($268>>>0)<($269>>>0);
|
||
|
|
if($270){label=66;break;}else{label=58;break;}
|
||
|
|
case 58:
|
||
|
|
var $272=(($R_1_i+24)|0);
|
||
|
|
HEAP32[(($272)>>2)]=$201;
|
||
|
|
var $273=(($v_0_i+16)|0);
|
||
|
|
var $274=HEAP32[(($273)>>2)];
|
||
|
|
var $275=($274|0)==0;
|
||
|
|
if($275){label=62;break;}else{label=59;break;}
|
||
|
|
case 59:
|
||
|
|
var $277=$274;
|
||
|
|
var $278=HEAP32[((56)>>2)];
|
||
|
|
var $279=($277>>>0)<($278>>>0);
|
||
|
|
if($279){label=61;break;}else{label=60;break;}
|
||
|
|
case 60:
|
||
|
|
var $281=(($R_1_i+16)|0);
|
||
|
|
HEAP32[(($281)>>2)]=$274;
|
||
|
|
var $282=(($274+24)|0);
|
||
|
|
HEAP32[(($282)>>2)]=$R_1_i;
|
||
|
|
label=62;break;
|
||
|
|
case 61:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 62:
|
||
|
|
var $285=(($v_0_i+20)|0);
|
||
|
|
var $286=HEAP32[(($285)>>2)];
|
||
|
|
var $287=($286|0)==0;
|
||
|
|
if($287){label=67;break;}else{label=63;break;}
|
||
|
|
case 63:
|
||
|
|
var $289=$286;
|
||
|
|
var $290=HEAP32[((56)>>2)];
|
||
|
|
var $291=($289>>>0)<($290>>>0);
|
||
|
|
if($291){label=65;break;}else{label=64;break;}
|
||
|
|
case 64:
|
||
|
|
var $293=(($R_1_i+20)|0);
|
||
|
|
HEAP32[(($293)>>2)]=$286;
|
||
|
|
var $294=(($286+24)|0);
|
||
|
|
HEAP32[(($294)>>2)]=$R_1_i;
|
||
|
|
label=67;break;
|
||
|
|
case 65:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 66:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 67:
|
||
|
|
var $298=($rsize_0_i>>>0)<16;
|
||
|
|
if($298){label=68;break;}else{label=69;break;}
|
||
|
|
case 68:
|
||
|
|
var $300=((($rsize_0_i)+($8))|0);
|
||
|
|
var $301=$300|3;
|
||
|
|
var $302=(($v_0_i+4)|0);
|
||
|
|
HEAP32[(($302)>>2)]=$301;
|
||
|
|
var $_sum4_i=((($300)+(4))|0);
|
||
|
|
var $303=(($192+$_sum4_i)|0);
|
||
|
|
var $304=$303;
|
||
|
|
var $305=HEAP32[(($304)>>2)];
|
||
|
|
var $306=$305|1;
|
||
|
|
HEAP32[(($304)>>2)]=$306;
|
||
|
|
label=77;break;
|
||
|
|
case 69:
|
||
|
|
var $308=$8|3;
|
||
|
|
var $309=(($v_0_i+4)|0);
|
||
|
|
HEAP32[(($309)>>2)]=$308;
|
||
|
|
var $310=$rsize_0_i|1;
|
||
|
|
var $_sum_i41=$8|4;
|
||
|
|
var $311=(($192+$_sum_i41)|0);
|
||
|
|
var $312=$311;
|
||
|
|
HEAP32[(($312)>>2)]=$310;
|
||
|
|
var $_sum1_i=((($rsize_0_i)+($8))|0);
|
||
|
|
var $313=(($192+$_sum1_i)|0);
|
||
|
|
var $314=$313;
|
||
|
|
HEAP32[(($314)>>2)]=$rsize_0_i;
|
||
|
|
var $315=HEAP32[((48)>>2)];
|
||
|
|
var $316=($315|0)==0;
|
||
|
|
if($316){label=75;break;}else{label=70;break;}
|
||
|
|
case 70:
|
||
|
|
var $318=HEAP32[((60)>>2)];
|
||
|
|
var $319=$315>>>3;
|
||
|
|
var $320=$319<<1;
|
||
|
|
var $321=((80+($320<<2))|0);
|
||
|
|
var $322=$321;
|
||
|
|
var $323=HEAP32[((40)>>2)];
|
||
|
|
var $324=1<<$319;
|
||
|
|
var $325=$323&$324;
|
||
|
|
var $326=($325|0)==0;
|
||
|
|
if($326){label=71;break;}else{label=72;break;}
|
||
|
|
case 71:
|
||
|
|
var $328=$323|$324;
|
||
|
|
HEAP32[((40)>>2)]=$328;
|
||
|
|
var $_sum2_pre_i=((($320)+(2))|0);
|
||
|
|
var $_pre_i=((80+($_sum2_pre_i<<2))|0);
|
||
|
|
var $F1_0_i=$322;var $_pre_phi_i=$_pre_i;label=74;break;
|
||
|
|
case 72:
|
||
|
|
var $_sum3_i=((($320)+(2))|0);
|
||
|
|
var $330=((80+($_sum3_i<<2))|0);
|
||
|
|
var $331=HEAP32[(($330)>>2)];
|
||
|
|
var $332=$331;
|
||
|
|
var $333=HEAP32[((56)>>2)];
|
||
|
|
var $334=($332>>>0)<($333>>>0);
|
||
|
|
if($334){label=73;break;}else{var $F1_0_i=$331;var $_pre_phi_i=$330;label=74;break;}
|
||
|
|
case 73:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 74:
|
||
|
|
var $_pre_phi_i;
|
||
|
|
var $F1_0_i;
|
||
|
|
HEAP32[(($_pre_phi_i)>>2)]=$318;
|
||
|
|
var $337=(($F1_0_i+12)|0);
|
||
|
|
HEAP32[(($337)>>2)]=$318;
|
||
|
|
var $338=(($318+8)|0);
|
||
|
|
HEAP32[(($338)>>2)]=$F1_0_i;
|
||
|
|
var $339=(($318+12)|0);
|
||
|
|
HEAP32[(($339)>>2)]=$322;
|
||
|
|
label=75;break;
|
||
|
|
case 75:
|
||
|
|
HEAP32[((48)>>2)]=$rsize_0_i;
|
||
|
|
HEAP32[((60)>>2)]=$197;
|
||
|
|
label=77;break;
|
||
|
|
case 76:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 77:
|
||
|
|
var $342=(($v_0_i+8)|0);
|
||
|
|
var $343=$342;
|
||
|
|
var $mem_0=$343;label=341;break;
|
||
|
|
case 78:
|
||
|
|
var $345=($bytes>>>0)>4294967231;
|
||
|
|
if($345){var $nb_0=-1;label=160;break;}else{label=79;break;}
|
||
|
|
case 79:
|
||
|
|
var $347=((($bytes)+(11))|0);
|
||
|
|
var $348=$347&-8;
|
||
|
|
var $349=HEAP32[((44)>>2)];
|
||
|
|
var $350=($349|0)==0;
|
||
|
|
if($350){var $nb_0=$348;label=160;break;}else{label=80;break;}
|
||
|
|
case 80:
|
||
|
|
var $352=(((-$348))|0);
|
||
|
|
var $353=$347>>>8;
|
||
|
|
var $354=($353|0)==0;
|
||
|
|
if($354){var $idx_0_i=0;label=83;break;}else{label=81;break;}
|
||
|
|
case 81:
|
||
|
|
var $356=($348>>>0)>16777215;
|
||
|
|
if($356){var $idx_0_i=31;label=83;break;}else{label=82;break;}
|
||
|
|
case 82:
|
||
|
|
var $358=((($353)+(1048320))|0);
|
||
|
|
var $359=$358>>>16;
|
||
|
|
var $360=$359&8;
|
||
|
|
var $361=$353<<$360;
|
||
|
|
var $362=((($361)+(520192))|0);
|
||
|
|
var $363=$362>>>16;
|
||
|
|
var $364=$363&4;
|
||
|
|
var $365=$364|$360;
|
||
|
|
var $366=$361<<$364;
|
||
|
|
var $367=((($366)+(245760))|0);
|
||
|
|
var $368=$367>>>16;
|
||
|
|
var $369=$368&2;
|
||
|
|
var $370=$365|$369;
|
||
|
|
var $371=(((14)-($370))|0);
|
||
|
|
var $372=$366<<$369;
|
||
|
|
var $373=$372>>>15;
|
||
|
|
var $374=((($371)+($373))|0);
|
||
|
|
var $375=$374<<1;
|
||
|
|
var $376=((($374)+(7))|0);
|
||
|
|
var $377=$348>>>($376>>>0);
|
||
|
|
var $378=$377&1;
|
||
|
|
var $379=$378|$375;
|
||
|
|
var $idx_0_i=$379;label=83;break;
|
||
|
|
case 83:
|
||
|
|
var $idx_0_i;
|
||
|
|
var $381=((344+($idx_0_i<<2))|0);
|
||
|
|
var $382=HEAP32[(($381)>>2)];
|
||
|
|
var $383=($382|0)==0;
|
||
|
|
if($383){var $v_2_i=0;var $rsize_2_i=$352;var $t_1_i=0;label=90;break;}else{label=84;break;}
|
||
|
|
case 84:
|
||
|
|
var $385=($idx_0_i|0)==31;
|
||
|
|
if($385){var $390=0;label=86;break;}else{label=85;break;}
|
||
|
|
case 85:
|
||
|
|
var $387=$idx_0_i>>>1;
|
||
|
|
var $388=(((25)-($387))|0);
|
||
|
|
var $390=$388;label=86;break;
|
||
|
|
case 86:
|
||
|
|
var $390;
|
||
|
|
var $391=$348<<$390;
|
||
|
|
var $v_0_i18=0;var $rsize_0_i17=$352;var $t_0_i16=$382;var $sizebits_0_i=$391;var $rst_0_i=0;label=87;break;
|
||
|
|
case 87:
|
||
|
|
var $rst_0_i;
|
||
|
|
var $sizebits_0_i;
|
||
|
|
var $t_0_i16;
|
||
|
|
var $rsize_0_i17;
|
||
|
|
var $v_0_i18;
|
||
|
|
var $393=(($t_0_i16+4)|0);
|
||
|
|
var $394=HEAP32[(($393)>>2)];
|
||
|
|
var $395=$394&-8;
|
||
|
|
var $396=((($395)-($348))|0);
|
||
|
|
var $397=($396>>>0)<($rsize_0_i17>>>0);
|
||
|
|
if($397){label=88;break;}else{var $v_1_i=$v_0_i18;var $rsize_1_i=$rsize_0_i17;label=89;break;}
|
||
|
|
case 88:
|
||
|
|
var $399=($395|0)==($348|0);
|
||
|
|
if($399){var $v_2_i=$t_0_i16;var $rsize_2_i=$396;var $t_1_i=$t_0_i16;label=90;break;}else{var $v_1_i=$t_0_i16;var $rsize_1_i=$396;label=89;break;}
|
||
|
|
case 89:
|
||
|
|
var $rsize_1_i;
|
||
|
|
var $v_1_i;
|
||
|
|
var $401=(($t_0_i16+20)|0);
|
||
|
|
var $402=HEAP32[(($401)>>2)];
|
||
|
|
var $403=$sizebits_0_i>>>31;
|
||
|
|
var $404=(($t_0_i16+16+($403<<2))|0);
|
||
|
|
var $405=HEAP32[(($404)>>2)];
|
||
|
|
var $406=($402|0)==0;
|
||
|
|
var $407=($402|0)==($405|0);
|
||
|
|
var $or_cond21_i=$406|$407;
|
||
|
|
var $rst_1_i=($or_cond21_i?$rst_0_i:$402);
|
||
|
|
var $408=($405|0)==0;
|
||
|
|
var $409=$sizebits_0_i<<1;
|
||
|
|
if($408){var $v_2_i=$v_1_i;var $rsize_2_i=$rsize_1_i;var $t_1_i=$rst_1_i;label=90;break;}else{var $v_0_i18=$v_1_i;var $rsize_0_i17=$rsize_1_i;var $t_0_i16=$405;var $sizebits_0_i=$409;var $rst_0_i=$rst_1_i;label=87;break;}
|
||
|
|
case 90:
|
||
|
|
var $t_1_i;
|
||
|
|
var $rsize_2_i;
|
||
|
|
var $v_2_i;
|
||
|
|
var $410=($t_1_i|0)==0;
|
||
|
|
var $411=($v_2_i|0)==0;
|
||
|
|
var $or_cond_i=$410&$411;
|
||
|
|
if($or_cond_i){label=91;break;}else{var $t_2_ph_i=$t_1_i;label=93;break;}
|
||
|
|
case 91:
|
||
|
|
var $413=2<<$idx_0_i;
|
||
|
|
var $414=(((-$413))|0);
|
||
|
|
var $415=$413|$414;
|
||
|
|
var $416=$349&$415;
|
||
|
|
var $417=($416|0)==0;
|
||
|
|
if($417){var $nb_0=$348;label=160;break;}else{label=92;break;}
|
||
|
|
case 92:
|
||
|
|
var $419=(((-$416))|0);
|
||
|
|
var $420=$416&$419;
|
||
|
|
var $421=((($420)-(1))|0);
|
||
|
|
var $422=$421>>>12;
|
||
|
|
var $423=$422&16;
|
||
|
|
var $424=$421>>>($423>>>0);
|
||
|
|
var $425=$424>>>5;
|
||
|
|
var $426=$425&8;
|
||
|
|
var $427=$426|$423;
|
||
|
|
var $428=$424>>>($426>>>0);
|
||
|
|
var $429=$428>>>2;
|
||
|
|
var $430=$429&4;
|
||
|
|
var $431=$427|$430;
|
||
|
|
var $432=$428>>>($430>>>0);
|
||
|
|
var $433=$432>>>1;
|
||
|
|
var $434=$433&2;
|
||
|
|
var $435=$431|$434;
|
||
|
|
var $436=$432>>>($434>>>0);
|
||
|
|
var $437=$436>>>1;
|
||
|
|
var $438=$437&1;
|
||
|
|
var $439=$435|$438;
|
||
|
|
var $440=$436>>>($438>>>0);
|
||
|
|
var $441=((($439)+($440))|0);
|
||
|
|
var $442=((344+($441<<2))|0);
|
||
|
|
var $443=HEAP32[(($442)>>2)];
|
||
|
|
var $t_2_ph_i=$443;label=93;break;
|
||
|
|
case 93:
|
||
|
|
var $t_2_ph_i;
|
||
|
|
var $444=($t_2_ph_i|0)==0;
|
||
|
|
if($444){var $rsize_3_lcssa_i=$rsize_2_i;var $v_3_lcssa_i=$v_2_i;label=96;break;}else{var $t_232_i=$t_2_ph_i;var $rsize_333_i=$rsize_2_i;var $v_334_i=$v_2_i;label=94;break;}
|
||
|
|
case 94:
|
||
|
|
var $v_334_i;
|
||
|
|
var $rsize_333_i;
|
||
|
|
var $t_232_i;
|
||
|
|
var $445=(($t_232_i+4)|0);
|
||
|
|
var $446=HEAP32[(($445)>>2)];
|
||
|
|
var $447=$446&-8;
|
||
|
|
var $448=((($447)-($348))|0);
|
||
|
|
var $449=($448>>>0)<($rsize_333_i>>>0);
|
||
|
|
var $_rsize_3_i=($449?$448:$rsize_333_i);
|
||
|
|
var $t_2_v_3_i=($449?$t_232_i:$v_334_i);
|
||
|
|
var $450=(($t_232_i+16)|0);
|
||
|
|
var $451=HEAP32[(($450)>>2)];
|
||
|
|
var $452=($451|0)==0;
|
||
|
|
if($452){label=95;break;}else{var $t_232_i=$451;var $rsize_333_i=$_rsize_3_i;var $v_334_i=$t_2_v_3_i;label=94;break;}
|
||
|
|
case 95:
|
||
|
|
var $453=(($t_232_i+20)|0);
|
||
|
|
var $454=HEAP32[(($453)>>2)];
|
||
|
|
var $455=($454|0)==0;
|
||
|
|
if($455){var $rsize_3_lcssa_i=$_rsize_3_i;var $v_3_lcssa_i=$t_2_v_3_i;label=96;break;}else{var $t_232_i=$454;var $rsize_333_i=$_rsize_3_i;var $v_334_i=$t_2_v_3_i;label=94;break;}
|
||
|
|
case 96:
|
||
|
|
var $v_3_lcssa_i;
|
||
|
|
var $rsize_3_lcssa_i;
|
||
|
|
var $456=($v_3_lcssa_i|0)==0;
|
||
|
|
if($456){var $nb_0=$348;label=160;break;}else{label=97;break;}
|
||
|
|
case 97:
|
||
|
|
var $458=HEAP32[((48)>>2)];
|
||
|
|
var $459=((($458)-($348))|0);
|
||
|
|
var $460=($rsize_3_lcssa_i>>>0)<($459>>>0);
|
||
|
|
if($460){label=98;break;}else{var $nb_0=$348;label=160;break;}
|
||
|
|
case 98:
|
||
|
|
var $462=$v_3_lcssa_i;
|
||
|
|
var $463=HEAP32[((56)>>2)];
|
||
|
|
var $464=($462>>>0)<($463>>>0);
|
||
|
|
if($464){label=158;break;}else{label=99;break;}
|
||
|
|
case 99:
|
||
|
|
var $466=(($462+$348)|0);
|
||
|
|
var $467=$466;
|
||
|
|
var $468=($462>>>0)<($466>>>0);
|
||
|
|
if($468){label=100;break;}else{label=158;break;}
|
||
|
|
case 100:
|
||
|
|
var $470=(($v_3_lcssa_i+24)|0);
|
||
|
|
var $471=HEAP32[(($470)>>2)];
|
||
|
|
var $472=(($v_3_lcssa_i+12)|0);
|
||
|
|
var $473=HEAP32[(($472)>>2)];
|
||
|
|
var $474=($473|0)==($v_3_lcssa_i|0);
|
||
|
|
if($474){label=106;break;}else{label=101;break;}
|
||
|
|
case 101:
|
||
|
|
var $476=(($v_3_lcssa_i+8)|0);
|
||
|
|
var $477=HEAP32[(($476)>>2)];
|
||
|
|
var $478=$477;
|
||
|
|
var $479=($478>>>0)<($463>>>0);
|
||
|
|
if($479){label=105;break;}else{label=102;break;}
|
||
|
|
case 102:
|
||
|
|
var $481=(($477+12)|0);
|
||
|
|
var $482=HEAP32[(($481)>>2)];
|
||
|
|
var $483=($482|0)==($v_3_lcssa_i|0);
|
||
|
|
if($483){label=103;break;}else{label=105;break;}
|
||
|
|
case 103:
|
||
|
|
var $485=(($473+8)|0);
|
||
|
|
var $486=HEAP32[(($485)>>2)];
|
||
|
|
var $487=($486|0)==($v_3_lcssa_i|0);
|
||
|
|
if($487){label=104;break;}else{label=105;break;}
|
||
|
|
case 104:
|
||
|
|
HEAP32[(($481)>>2)]=$473;
|
||
|
|
HEAP32[(($485)>>2)]=$477;
|
||
|
|
var $R_1_i22=$473;label=113;break;
|
||
|
|
case 105:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 106:
|
||
|
|
var $490=(($v_3_lcssa_i+20)|0);
|
||
|
|
var $491=HEAP32[(($490)>>2)];
|
||
|
|
var $492=($491|0)==0;
|
||
|
|
if($492){label=107;break;}else{var $R_0_i20=$491;var $RP_0_i19=$490;label=108;break;}
|
||
|
|
case 107:
|
||
|
|
var $494=(($v_3_lcssa_i+16)|0);
|
||
|
|
var $495=HEAP32[(($494)>>2)];
|
||
|
|
var $496=($495|0)==0;
|
||
|
|
if($496){var $R_1_i22=0;label=113;break;}else{var $R_0_i20=$495;var $RP_0_i19=$494;label=108;break;}
|
||
|
|
case 108:
|
||
|
|
var $RP_0_i19;
|
||
|
|
var $R_0_i20;
|
||
|
|
var $497=(($R_0_i20+20)|0);
|
||
|
|
var $498=HEAP32[(($497)>>2)];
|
||
|
|
var $499=($498|0)==0;
|
||
|
|
if($499){label=109;break;}else{var $R_0_i20=$498;var $RP_0_i19=$497;label=108;break;}
|
||
|
|
case 109:
|
||
|
|
var $501=(($R_0_i20+16)|0);
|
||
|
|
var $502=HEAP32[(($501)>>2)];
|
||
|
|
var $503=($502|0)==0;
|
||
|
|
if($503){label=110;break;}else{var $R_0_i20=$502;var $RP_0_i19=$501;label=108;break;}
|
||
|
|
case 110:
|
||
|
|
var $505=$RP_0_i19;
|
||
|
|
var $506=($505>>>0)<($463>>>0);
|
||
|
|
if($506){label=112;break;}else{label=111;break;}
|
||
|
|
case 111:
|
||
|
|
HEAP32[(($RP_0_i19)>>2)]=0;
|
||
|
|
var $R_1_i22=$R_0_i20;label=113;break;
|
||
|
|
case 112:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 113:
|
||
|
|
var $R_1_i22;
|
||
|
|
var $510=($471|0)==0;
|
||
|
|
if($510){label=133;break;}else{label=114;break;}
|
||
|
|
case 114:
|
||
|
|
var $512=(($v_3_lcssa_i+28)|0);
|
||
|
|
var $513=HEAP32[(($512)>>2)];
|
||
|
|
var $514=((344+($513<<2))|0);
|
||
|
|
var $515=HEAP32[(($514)>>2)];
|
||
|
|
var $516=($v_3_lcssa_i|0)==($515|0);
|
||
|
|
if($516){label=115;break;}else{label=117;break;}
|
||
|
|
case 115:
|
||
|
|
HEAP32[(($514)>>2)]=$R_1_i22;
|
||
|
|
var $cond_i23=($R_1_i22|0)==0;
|
||
|
|
if($cond_i23){label=116;break;}else{label=123;break;}
|
||
|
|
case 116:
|
||
|
|
var $518=HEAP32[(($512)>>2)];
|
||
|
|
var $519=1<<$518;
|
||
|
|
var $520=$519^-1;
|
||
|
|
var $521=HEAP32[((44)>>2)];
|
||
|
|
var $522=$521&$520;
|
||
|
|
HEAP32[((44)>>2)]=$522;
|
||
|
|
label=133;break;
|
||
|
|
case 117:
|
||
|
|
var $524=$471;
|
||
|
|
var $525=HEAP32[((56)>>2)];
|
||
|
|
var $526=($524>>>0)<($525>>>0);
|
||
|
|
if($526){label=121;break;}else{label=118;break;}
|
||
|
|
case 118:
|
||
|
|
var $528=(($471+16)|0);
|
||
|
|
var $529=HEAP32[(($528)>>2)];
|
||
|
|
var $530=($529|0)==($v_3_lcssa_i|0);
|
||
|
|
if($530){label=119;break;}else{label=120;break;}
|
||
|
|
case 119:
|
||
|
|
HEAP32[(($528)>>2)]=$R_1_i22;
|
||
|
|
label=122;break;
|
||
|
|
case 120:
|
||
|
|
var $533=(($471+20)|0);
|
||
|
|
HEAP32[(($533)>>2)]=$R_1_i22;
|
||
|
|
label=122;break;
|
||
|
|
case 121:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 122:
|
||
|
|
var $536=($R_1_i22|0)==0;
|
||
|
|
if($536){label=133;break;}else{label=123;break;}
|
||
|
|
case 123:
|
||
|
|
var $538=$R_1_i22;
|
||
|
|
var $539=HEAP32[((56)>>2)];
|
||
|
|
var $540=($538>>>0)<($539>>>0);
|
||
|
|
if($540){label=132;break;}else{label=124;break;}
|
||
|
|
case 124:
|
||
|
|
var $542=(($R_1_i22+24)|0);
|
||
|
|
HEAP32[(($542)>>2)]=$471;
|
||
|
|
var $543=(($v_3_lcssa_i+16)|0);
|
||
|
|
var $544=HEAP32[(($543)>>2)];
|
||
|
|
var $545=($544|0)==0;
|
||
|
|
if($545){label=128;break;}else{label=125;break;}
|
||
|
|
case 125:
|
||
|
|
var $547=$544;
|
||
|
|
var $548=HEAP32[((56)>>2)];
|
||
|
|
var $549=($547>>>0)<($548>>>0);
|
||
|
|
if($549){label=127;break;}else{label=126;break;}
|
||
|
|
case 126:
|
||
|
|
var $551=(($R_1_i22+16)|0);
|
||
|
|
HEAP32[(($551)>>2)]=$544;
|
||
|
|
var $552=(($544+24)|0);
|
||
|
|
HEAP32[(($552)>>2)]=$R_1_i22;
|
||
|
|
label=128;break;
|
||
|
|
case 127:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 128:
|
||
|
|
var $555=(($v_3_lcssa_i+20)|0);
|
||
|
|
var $556=HEAP32[(($555)>>2)];
|
||
|
|
var $557=($556|0)==0;
|
||
|
|
if($557){label=133;break;}else{label=129;break;}
|
||
|
|
case 129:
|
||
|
|
var $559=$556;
|
||
|
|
var $560=HEAP32[((56)>>2)];
|
||
|
|
var $561=($559>>>0)<($560>>>0);
|
||
|
|
if($561){label=131;break;}else{label=130;break;}
|
||
|
|
case 130:
|
||
|
|
var $563=(($R_1_i22+20)|0);
|
||
|
|
HEAP32[(($563)>>2)]=$556;
|
||
|
|
var $564=(($556+24)|0);
|
||
|
|
HEAP32[(($564)>>2)]=$R_1_i22;
|
||
|
|
label=133;break;
|
||
|
|
case 131:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 132:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 133:
|
||
|
|
var $568=($rsize_3_lcssa_i>>>0)<16;
|
||
|
|
if($568){label=134;break;}else{label=135;break;}
|
||
|
|
case 134:
|
||
|
|
var $570=((($rsize_3_lcssa_i)+($348))|0);
|
||
|
|
var $571=$570|3;
|
||
|
|
var $572=(($v_3_lcssa_i+4)|0);
|
||
|
|
HEAP32[(($572)>>2)]=$571;
|
||
|
|
var $_sum19_i=((($570)+(4))|0);
|
||
|
|
var $573=(($462+$_sum19_i)|0);
|
||
|
|
var $574=$573;
|
||
|
|
var $575=HEAP32[(($574)>>2)];
|
||
|
|
var $576=$575|1;
|
||
|
|
HEAP32[(($574)>>2)]=$576;
|
||
|
|
label=159;break;
|
||
|
|
case 135:
|
||
|
|
var $578=$348|3;
|
||
|
|
var $579=(($v_3_lcssa_i+4)|0);
|
||
|
|
HEAP32[(($579)>>2)]=$578;
|
||
|
|
var $580=$rsize_3_lcssa_i|1;
|
||
|
|
var $_sum_i2540=$348|4;
|
||
|
|
var $581=(($462+$_sum_i2540)|0);
|
||
|
|
var $582=$581;
|
||
|
|
HEAP32[(($582)>>2)]=$580;
|
||
|
|
var $_sum1_i26=((($rsize_3_lcssa_i)+($348))|0);
|
||
|
|
var $583=(($462+$_sum1_i26)|0);
|
||
|
|
var $584=$583;
|
||
|
|
HEAP32[(($584)>>2)]=$rsize_3_lcssa_i;
|
||
|
|
var $585=$rsize_3_lcssa_i>>>3;
|
||
|
|
var $586=($rsize_3_lcssa_i>>>0)<256;
|
||
|
|
if($586){label=136;break;}else{label=141;break;}
|
||
|
|
case 136:
|
||
|
|
var $588=$585<<1;
|
||
|
|
var $589=((80+($588<<2))|0);
|
||
|
|
var $590=$589;
|
||
|
|
var $591=HEAP32[((40)>>2)];
|
||
|
|
var $592=1<<$585;
|
||
|
|
var $593=$591&$592;
|
||
|
|
var $594=($593|0)==0;
|
||
|
|
if($594){label=137;break;}else{label=138;break;}
|
||
|
|
case 137:
|
||
|
|
var $596=$591|$592;
|
||
|
|
HEAP32[((40)>>2)]=$596;
|
||
|
|
var $_sum15_pre_i=((($588)+(2))|0);
|
||
|
|
var $_pre_i27=((80+($_sum15_pre_i<<2))|0);
|
||
|
|
var $F5_0_i=$590;var $_pre_phi_i28=$_pre_i27;label=140;break;
|
||
|
|
case 138:
|
||
|
|
var $_sum18_i=((($588)+(2))|0);
|
||
|
|
var $598=((80+($_sum18_i<<2))|0);
|
||
|
|
var $599=HEAP32[(($598)>>2)];
|
||
|
|
var $600=$599;
|
||
|
|
var $601=HEAP32[((56)>>2)];
|
||
|
|
var $602=($600>>>0)<($601>>>0);
|
||
|
|
if($602){label=139;break;}else{var $F5_0_i=$599;var $_pre_phi_i28=$598;label=140;break;}
|
||
|
|
case 139:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 140:
|
||
|
|
var $_pre_phi_i28;
|
||
|
|
var $F5_0_i;
|
||
|
|
HEAP32[(($_pre_phi_i28)>>2)]=$467;
|
||
|
|
var $605=(($F5_0_i+12)|0);
|
||
|
|
HEAP32[(($605)>>2)]=$467;
|
||
|
|
var $_sum16_i=((($348)+(8))|0);
|
||
|
|
var $606=(($462+$_sum16_i)|0);
|
||
|
|
var $607=$606;
|
||
|
|
HEAP32[(($607)>>2)]=$F5_0_i;
|
||
|
|
var $_sum17_i=((($348)+(12))|0);
|
||
|
|
var $608=(($462+$_sum17_i)|0);
|
||
|
|
var $609=$608;
|
||
|
|
HEAP32[(($609)>>2)]=$590;
|
||
|
|
label=159;break;
|
||
|
|
case 141:
|
||
|
|
var $611=$466;
|
||
|
|
var $612=$rsize_3_lcssa_i>>>8;
|
||
|
|
var $613=($612|0)==0;
|
||
|
|
if($613){var $I7_0_i=0;label=144;break;}else{label=142;break;}
|
||
|
|
case 142:
|
||
|
|
var $615=($rsize_3_lcssa_i>>>0)>16777215;
|
||
|
|
if($615){var $I7_0_i=31;label=144;break;}else{label=143;break;}
|
||
|
|
case 143:
|
||
|
|
var $617=((($612)+(1048320))|0);
|
||
|
|
var $618=$617>>>16;
|
||
|
|
var $619=$618&8;
|
||
|
|
var $620=$612<<$619;
|
||
|
|
var $621=((($620)+(520192))|0);
|
||
|
|
var $622=$621>>>16;
|
||
|
|
var $623=$622&4;
|
||
|
|
var $624=$623|$619;
|
||
|
|
var $625=$620<<$623;
|
||
|
|
var $626=((($625)+(245760))|0);
|
||
|
|
var $627=$626>>>16;
|
||
|
|
var $628=$627&2;
|
||
|
|
var $629=$624|$628;
|
||
|
|
var $630=(((14)-($629))|0);
|
||
|
|
var $631=$625<<$628;
|
||
|
|
var $632=$631>>>15;
|
||
|
|
var $633=((($630)+($632))|0);
|
||
|
|
var $634=$633<<1;
|
||
|
|
var $635=((($633)+(7))|0);
|
||
|
|
var $636=$rsize_3_lcssa_i>>>($635>>>0);
|
||
|
|
var $637=$636&1;
|
||
|
|
var $638=$637|$634;
|
||
|
|
var $I7_0_i=$638;label=144;break;
|
||
|
|
case 144:
|
||
|
|
var $I7_0_i;
|
||
|
|
var $640=((344+($I7_0_i<<2))|0);
|
||
|
|
var $_sum2_i=((($348)+(28))|0);
|
||
|
|
var $641=(($462+$_sum2_i)|0);
|
||
|
|
var $642=$641;
|
||
|
|
HEAP32[(($642)>>2)]=$I7_0_i;
|
||
|
|
var $_sum3_i29=((($348)+(16))|0);
|
||
|
|
var $643=(($462+$_sum3_i29)|0);
|
||
|
|
var $_sum4_i30=((($348)+(20))|0);
|
||
|
|
var $644=(($462+$_sum4_i30)|0);
|
||
|
|
var $645=$644;
|
||
|
|
HEAP32[(($645)>>2)]=0;
|
||
|
|
var $646=$643;
|
||
|
|
HEAP32[(($646)>>2)]=0;
|
||
|
|
var $647=HEAP32[((44)>>2)];
|
||
|
|
var $648=1<<$I7_0_i;
|
||
|
|
var $649=$647&$648;
|
||
|
|
var $650=($649|0)==0;
|
||
|
|
if($650){label=145;break;}else{label=146;break;}
|
||
|
|
case 145:
|
||
|
|
var $652=$647|$648;
|
||
|
|
HEAP32[((44)>>2)]=$652;
|
||
|
|
HEAP32[(($640)>>2)]=$611;
|
||
|
|
var $653=$640;
|
||
|
|
var $_sum5_i=((($348)+(24))|0);
|
||
|
|
var $654=(($462+$_sum5_i)|0);
|
||
|
|
var $655=$654;
|
||
|
|
HEAP32[(($655)>>2)]=$653;
|
||
|
|
var $_sum6_i=((($348)+(12))|0);
|
||
|
|
var $656=(($462+$_sum6_i)|0);
|
||
|
|
var $657=$656;
|
||
|
|
HEAP32[(($657)>>2)]=$611;
|
||
|
|
var $_sum7_i=((($348)+(8))|0);
|
||
|
|
var $658=(($462+$_sum7_i)|0);
|
||
|
|
var $659=$658;
|
||
|
|
HEAP32[(($659)>>2)]=$611;
|
||
|
|
label=159;break;
|
||
|
|
case 146:
|
||
|
|
var $661=HEAP32[(($640)>>2)];
|
||
|
|
var $662=($I7_0_i|0)==31;
|
||
|
|
if($662){var $667=0;label=148;break;}else{label=147;break;}
|
||
|
|
case 147:
|
||
|
|
var $664=$I7_0_i>>>1;
|
||
|
|
var $665=(((25)-($664))|0);
|
||
|
|
var $667=$665;label=148;break;
|
||
|
|
case 148:
|
||
|
|
var $667;
|
||
|
|
var $668=(($661+4)|0);
|
||
|
|
var $669=HEAP32[(($668)>>2)];
|
||
|
|
var $670=$669&-8;
|
||
|
|
var $671=($670|0)==($rsize_3_lcssa_i|0);
|
||
|
|
if($671){var $T_0_lcssa_i=$661;label=155;break;}else{label=149;break;}
|
||
|
|
case 149:
|
||
|
|
var $672=$rsize_3_lcssa_i<<$667;
|
||
|
|
var $T_028_i=$661;var $K12_029_i=$672;label=151;break;
|
||
|
|
case 150:
|
||
|
|
var $674=$K12_029_i<<1;
|
||
|
|
var $675=(($682+4)|0);
|
||
|
|
var $676=HEAP32[(($675)>>2)];
|
||
|
|
var $677=$676&-8;
|
||
|
|
var $678=($677|0)==($rsize_3_lcssa_i|0);
|
||
|
|
if($678){var $T_0_lcssa_i=$682;label=155;break;}else{var $T_028_i=$682;var $K12_029_i=$674;label=151;break;}
|
||
|
|
case 151:
|
||
|
|
var $K12_029_i;
|
||
|
|
var $T_028_i;
|
||
|
|
var $680=$K12_029_i>>>31;
|
||
|
|
var $681=(($T_028_i+16+($680<<2))|0);
|
||
|
|
var $682=HEAP32[(($681)>>2)];
|
||
|
|
var $683=($682|0)==0;
|
||
|
|
if($683){label=152;break;}else{label=150;break;}
|
||
|
|
case 152:
|
||
|
|
var $685=$681;
|
||
|
|
var $686=HEAP32[((56)>>2)];
|
||
|
|
var $687=($685>>>0)<($686>>>0);
|
||
|
|
if($687){label=154;break;}else{label=153;break;}
|
||
|
|
case 153:
|
||
|
|
HEAP32[(($681)>>2)]=$611;
|
||
|
|
var $_sum12_i=((($348)+(24))|0);
|
||
|
|
var $689=(($462+$_sum12_i)|0);
|
||
|
|
var $690=$689;
|
||
|
|
HEAP32[(($690)>>2)]=$T_028_i;
|
||
|
|
var $_sum13_i=((($348)+(12))|0);
|
||
|
|
var $691=(($462+$_sum13_i)|0);
|
||
|
|
var $692=$691;
|
||
|
|
HEAP32[(($692)>>2)]=$611;
|
||
|
|
var $_sum14_i=((($348)+(8))|0);
|
||
|
|
var $693=(($462+$_sum14_i)|0);
|
||
|
|
var $694=$693;
|
||
|
|
HEAP32[(($694)>>2)]=$611;
|
||
|
|
label=159;break;
|
||
|
|
case 154:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 155:
|
||
|
|
var $T_0_lcssa_i;
|
||
|
|
var $696=(($T_0_lcssa_i+8)|0);
|
||
|
|
var $697=HEAP32[(($696)>>2)];
|
||
|
|
var $698=$T_0_lcssa_i;
|
||
|
|
var $699=HEAP32[((56)>>2)];
|
||
|
|
var $700=($698>>>0)>=($699>>>0);
|
||
|
|
var $701=$697;
|
||
|
|
var $702=($701>>>0)>=($699>>>0);
|
||
|
|
var $or_cond26_i=$700&$702;
|
||
|
|
if($or_cond26_i){label=156;break;}else{label=157;break;}
|
||
|
|
case 156:
|
||
|
|
var $704=(($697+12)|0);
|
||
|
|
HEAP32[(($704)>>2)]=$611;
|
||
|
|
HEAP32[(($696)>>2)]=$611;
|
||
|
|
var $_sum9_i=((($348)+(8))|0);
|
||
|
|
var $705=(($462+$_sum9_i)|0);
|
||
|
|
var $706=$705;
|
||
|
|
HEAP32[(($706)>>2)]=$697;
|
||
|
|
var $_sum10_i=((($348)+(12))|0);
|
||
|
|
var $707=(($462+$_sum10_i)|0);
|
||
|
|
var $708=$707;
|
||
|
|
HEAP32[(($708)>>2)]=$T_0_lcssa_i;
|
||
|
|
var $_sum11_i=((($348)+(24))|0);
|
||
|
|
var $709=(($462+$_sum11_i)|0);
|
||
|
|
var $710=$709;
|
||
|
|
HEAP32[(($710)>>2)]=0;
|
||
|
|
label=159;break;
|
||
|
|
case 157:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 158:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 159:
|
||
|
|
var $712=(($v_3_lcssa_i+8)|0);
|
||
|
|
var $713=$712;
|
||
|
|
var $mem_0=$713;label=341;break;
|
||
|
|
case 160:
|
||
|
|
var $nb_0;
|
||
|
|
var $714=HEAP32[((48)>>2)];
|
||
|
|
var $715=($714>>>0)<($nb_0>>>0);
|
||
|
|
if($715){label=165;break;}else{label=161;break;}
|
||
|
|
case 161:
|
||
|
|
var $717=((($714)-($nb_0))|0);
|
||
|
|
var $718=HEAP32[((60)>>2)];
|
||
|
|
var $719=($717>>>0)>15;
|
||
|
|
if($719){label=162;break;}else{label=163;break;}
|
||
|
|
case 162:
|
||
|
|
var $721=$718;
|
||
|
|
var $722=(($721+$nb_0)|0);
|
||
|
|
var $723=$722;
|
||
|
|
HEAP32[((60)>>2)]=$723;
|
||
|
|
HEAP32[((48)>>2)]=$717;
|
||
|
|
var $724=$717|1;
|
||
|
|
var $_sum2=((($nb_0)+(4))|0);
|
||
|
|
var $725=(($721+$_sum2)|0);
|
||
|
|
var $726=$725;
|
||
|
|
HEAP32[(($726)>>2)]=$724;
|
||
|
|
var $727=(($721+$714)|0);
|
||
|
|
var $728=$727;
|
||
|
|
HEAP32[(($728)>>2)]=$717;
|
||
|
|
var $729=$nb_0|3;
|
||
|
|
var $730=(($718+4)|0);
|
||
|
|
HEAP32[(($730)>>2)]=$729;
|
||
|
|
label=164;break;
|
||
|
|
case 163:
|
||
|
|
HEAP32[((48)>>2)]=0;
|
||
|
|
HEAP32[((60)>>2)]=0;
|
||
|
|
var $732=$714|3;
|
||
|
|
var $733=(($718+4)|0);
|
||
|
|
HEAP32[(($733)>>2)]=$732;
|
||
|
|
var $734=$718;
|
||
|
|
var $_sum1=((($714)+(4))|0);
|
||
|
|
var $735=(($734+$_sum1)|0);
|
||
|
|
var $736=$735;
|
||
|
|
var $737=HEAP32[(($736)>>2)];
|
||
|
|
var $738=$737|1;
|
||
|
|
HEAP32[(($736)>>2)]=$738;
|
||
|
|
label=164;break;
|
||
|
|
case 164:
|
||
|
|
var $740=(($718+8)|0);
|
||
|
|
var $741=$740;
|
||
|
|
var $mem_0=$741;label=341;break;
|
||
|
|
case 165:
|
||
|
|
var $743=HEAP32[((52)>>2)];
|
||
|
|
var $744=($743>>>0)>($nb_0>>>0);
|
||
|
|
if($744){label=166;break;}else{label=167;break;}
|
||
|
|
case 166:
|
||
|
|
var $746=((($743)-($nb_0))|0);
|
||
|
|
HEAP32[((52)>>2)]=$746;
|
||
|
|
var $747=HEAP32[((64)>>2)];
|
||
|
|
var $748=$747;
|
||
|
|
var $749=(($748+$nb_0)|0);
|
||
|
|
var $750=$749;
|
||
|
|
HEAP32[((64)>>2)]=$750;
|
||
|
|
var $751=$746|1;
|
||
|
|
var $_sum=((($nb_0)+(4))|0);
|
||
|
|
var $752=(($748+$_sum)|0);
|
||
|
|
var $753=$752;
|
||
|
|
HEAP32[(($753)>>2)]=$751;
|
||
|
|
var $754=$nb_0|3;
|
||
|
|
var $755=(($747+4)|0);
|
||
|
|
HEAP32[(($755)>>2)]=$754;
|
||
|
|
var $756=(($747+8)|0);
|
||
|
|
var $757=$756;
|
||
|
|
var $mem_0=$757;label=341;break;
|
||
|
|
case 167:
|
||
|
|
var $759=HEAP32[((16)>>2)];
|
||
|
|
var $760=($759|0)==0;
|
||
|
|
if($760){label=168;break;}else{label=171;break;}
|
||
|
|
case 168:
|
||
|
|
var $762=_sysconf(30);
|
||
|
|
var $763=((($762)-(1))|0);
|
||
|
|
var $764=$763&$762;
|
||
|
|
var $765=($764|0)==0;
|
||
|
|
if($765){label=170;break;}else{label=169;break;}
|
||
|
|
case 169:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 170:
|
||
|
|
HEAP32[((24)>>2)]=$762;
|
||
|
|
HEAP32[((20)>>2)]=$762;
|
||
|
|
HEAP32[((28)>>2)]=-1;
|
||
|
|
HEAP32[((32)>>2)]=-1;
|
||
|
|
HEAP32[((36)>>2)]=0;
|
||
|
|
HEAP32[((484)>>2)]=0;
|
||
|
|
var $767=_time(0);
|
||
|
|
var $768=$767&-16;
|
||
|
|
var $769=$768^1431655768;
|
||
|
|
HEAP32[((16)>>2)]=$769;
|
||
|
|
label=171;break;
|
||
|
|
case 171:
|
||
|
|
var $771=((($nb_0)+(48))|0);
|
||
|
|
var $772=HEAP32[((24)>>2)];
|
||
|
|
var $773=((($nb_0)+(47))|0);
|
||
|
|
var $774=((($772)+($773))|0);
|
||
|
|
var $775=(((-$772))|0);
|
||
|
|
var $776=$774&$775;
|
||
|
|
var $777=($776>>>0)>($nb_0>>>0);
|
||
|
|
if($777){label=172;break;}else{var $mem_0=0;label=341;break;}
|
||
|
|
case 172:
|
||
|
|
var $779=HEAP32[((480)>>2)];
|
||
|
|
var $780=($779|0)==0;
|
||
|
|
if($780){label=174;break;}else{label=173;break;}
|
||
|
|
case 173:
|
||
|
|
var $782=HEAP32[((472)>>2)];
|
||
|
|
var $783=((($782)+($776))|0);
|
||
|
|
var $784=($783>>>0)<=($782>>>0);
|
||
|
|
var $785=($783>>>0)>($779>>>0);
|
||
|
|
var $or_cond1_i=$784|$785;
|
||
|
|
if($or_cond1_i){var $mem_0=0;label=341;break;}else{label=174;break;}
|
||
|
|
case 174:
|
||
|
|
var $787=HEAP32[((484)>>2)];
|
||
|
|
var $788=$787&4;
|
||
|
|
var $789=($788|0)==0;
|
||
|
|
if($789){label=175;break;}else{var $tsize_1_i=0;label=198;break;}
|
||
|
|
case 175:
|
||
|
|
var $791=HEAP32[((64)>>2)];
|
||
|
|
var $792=($791|0)==0;
|
||
|
|
if($792){label=181;break;}else{label=176;break;}
|
||
|
|
case 176:
|
||
|
|
var $794=$791;
|
||
|
|
var $sp_0_i_i=488;label=177;break;
|
||
|
|
case 177:
|
||
|
|
var $sp_0_i_i;
|
||
|
|
var $796=(($sp_0_i_i)|0);
|
||
|
|
var $797=HEAP32[(($796)>>2)];
|
||
|
|
var $798=($797>>>0)>($794>>>0);
|
||
|
|
if($798){label=179;break;}else{label=178;break;}
|
||
|
|
case 178:
|
||
|
|
var $800=(($sp_0_i_i+4)|0);
|
||
|
|
var $801=HEAP32[(($800)>>2)];
|
||
|
|
var $802=(($797+$801)|0);
|
||
|
|
var $803=($802>>>0)>($794>>>0);
|
||
|
|
if($803){label=180;break;}else{label=179;break;}
|
||
|
|
case 179:
|
||
|
|
var $805=(($sp_0_i_i+8)|0);
|
||
|
|
var $806=HEAP32[(($805)>>2)];
|
||
|
|
var $807=($806|0)==0;
|
||
|
|
if($807){label=181;break;}else{var $sp_0_i_i=$806;label=177;break;}
|
||
|
|
case 180:
|
||
|
|
var $808=($sp_0_i_i|0)==0;
|
||
|
|
if($808){label=181;break;}else{label=188;break;}
|
||
|
|
case 181:
|
||
|
|
var $809=_sbrk(0);
|
||
|
|
var $810=($809|0)==-1;
|
||
|
|
if($810){var $tsize_03141_i=0;label=197;break;}else{label=182;break;}
|
||
|
|
case 182:
|
||
|
|
var $812=$809;
|
||
|
|
var $813=HEAP32[((20)>>2)];
|
||
|
|
var $814=((($813)-(1))|0);
|
||
|
|
var $815=$814&$812;
|
||
|
|
var $816=($815|0)==0;
|
||
|
|
if($816){var $ssize_0_i=$776;label=184;break;}else{label=183;break;}
|
||
|
|
case 183:
|
||
|
|
var $818=((($814)+($812))|0);
|
||
|
|
var $819=(((-$813))|0);
|
||
|
|
var $820=$818&$819;
|
||
|
|
var $821=((($776)-($812))|0);
|
||
|
|
var $822=((($821)+($820))|0);
|
||
|
|
var $ssize_0_i=$822;label=184;break;
|
||
|
|
case 184:
|
||
|
|
var $ssize_0_i;
|
||
|
|
var $824=HEAP32[((472)>>2)];
|
||
|
|
var $825=((($824)+($ssize_0_i))|0);
|
||
|
|
var $826=($ssize_0_i>>>0)>($nb_0>>>0);
|
||
|
|
var $827=($ssize_0_i>>>0)<2147483647;
|
||
|
|
var $or_cond_i31=$826&$827;
|
||
|
|
if($or_cond_i31){label=185;break;}else{var $tsize_03141_i=0;label=197;break;}
|
||
|
|
case 185:
|
||
|
|
var $829=HEAP32[((480)>>2)];
|
||
|
|
var $830=($829|0)==0;
|
||
|
|
if($830){label=187;break;}else{label=186;break;}
|
||
|
|
case 186:
|
||
|
|
var $832=($825>>>0)<=($824>>>0);
|
||
|
|
var $833=($825>>>0)>($829>>>0);
|
||
|
|
var $or_cond2_i=$832|$833;
|
||
|
|
if($or_cond2_i){var $tsize_03141_i=0;label=197;break;}else{label=187;break;}
|
||
|
|
case 187:
|
||
|
|
var $835=_sbrk($ssize_0_i);
|
||
|
|
var $836=($835|0)==($809|0);
|
||
|
|
if($836){var $br_0_i=$809;var $ssize_1_i=$ssize_0_i;label=190;break;}else{var $ssize_129_i=$ssize_0_i;var $br_030_i=$835;label=191;break;}
|
||
|
|
case 188:
|
||
|
|
var $838=HEAP32[((52)>>2)];
|
||
|
|
var $839=((($774)-($838))|0);
|
||
|
|
var $840=$839&$775;
|
||
|
|
var $841=($840>>>0)<2147483647;
|
||
|
|
if($841){label=189;break;}else{var $tsize_03141_i=0;label=197;break;}
|
||
|
|
case 189:
|
||
|
|
var $843=_sbrk($840);
|
||
|
|
var $844=HEAP32[(($796)>>2)];
|
||
|
|
var $845=HEAP32[(($800)>>2)];
|
||
|
|
var $846=(($844+$845)|0);
|
||
|
|
var $847=($843|0)==($846|0);
|
||
|
|
if($847){var $br_0_i=$843;var $ssize_1_i=$840;label=190;break;}else{var $ssize_129_i=$840;var $br_030_i=$843;label=191;break;}
|
||
|
|
case 190:
|
||
|
|
var $ssize_1_i;
|
||
|
|
var $br_0_i;
|
||
|
|
var $849=($br_0_i|0)==-1;
|
||
|
|
if($849){var $tsize_03141_i=$ssize_1_i;label=197;break;}else{var $tsize_244_i=$ssize_1_i;var $tbase_245_i=$br_0_i;label=201;break;}
|
||
|
|
case 191:
|
||
|
|
var $br_030_i;
|
||
|
|
var $ssize_129_i;
|
||
|
|
var $850=(((-$ssize_129_i))|0);
|
||
|
|
var $851=($br_030_i|0)!=-1;
|
||
|
|
var $852=($ssize_129_i>>>0)<2147483647;
|
||
|
|
var $or_cond5_i=$851&$852;
|
||
|
|
var $853=($771>>>0)>($ssize_129_i>>>0);
|
||
|
|
var $or_cond4_i=$or_cond5_i&$853;
|
||
|
|
if($or_cond4_i){label=192;break;}else{var $ssize_2_i=$ssize_129_i;label=196;break;}
|
||
|
|
case 192:
|
||
|
|
var $855=HEAP32[((24)>>2)];
|
||
|
|
var $856=((($773)-($ssize_129_i))|0);
|
||
|
|
var $857=((($856)+($855))|0);
|
||
|
|
var $858=(((-$855))|0);
|
||
|
|
var $859=$857&$858;
|
||
|
|
var $860=($859>>>0)<2147483647;
|
||
|
|
if($860){label=193;break;}else{var $ssize_2_i=$ssize_129_i;label=196;break;}
|
||
|
|
case 193:
|
||
|
|
var $862=_sbrk($859);
|
||
|
|
var $863=($862|0)==-1;
|
||
|
|
if($863){label=195;break;}else{label=194;break;}
|
||
|
|
case 194:
|
||
|
|
var $865=((($859)+($ssize_129_i))|0);
|
||
|
|
var $ssize_2_i=$865;label=196;break;
|
||
|
|
case 195:
|
||
|
|
var $866=_sbrk($850);
|
||
|
|
var $tsize_03141_i=0;label=197;break;
|
||
|
|
case 196:
|
||
|
|
var $ssize_2_i;
|
||
|
|
var $868=($br_030_i|0)==-1;
|
||
|
|
if($868){var $tsize_03141_i=0;label=197;break;}else{var $tsize_244_i=$ssize_2_i;var $tbase_245_i=$br_030_i;label=201;break;}
|
||
|
|
case 197:
|
||
|
|
var $tsize_03141_i;
|
||
|
|
var $869=HEAP32[((484)>>2)];
|
||
|
|
var $870=$869|4;
|
||
|
|
HEAP32[((484)>>2)]=$870;
|
||
|
|
var $tsize_1_i=$tsize_03141_i;label=198;break;
|
||
|
|
case 198:
|
||
|
|
var $tsize_1_i;
|
||
|
|
var $872=($776>>>0)<2147483647;
|
||
|
|
if($872){label=199;break;}else{label=340;break;}
|
||
|
|
case 199:
|
||
|
|
var $874=_sbrk($776);
|
||
|
|
var $875=_sbrk(0);
|
||
|
|
var $876=($874|0)!=-1;
|
||
|
|
var $877=($875|0)!=-1;
|
||
|
|
var $or_cond3_i=$876&$877;
|
||
|
|
var $878=($874>>>0)<($875>>>0);
|
||
|
|
var $or_cond6_i=$or_cond3_i&$878;
|
||
|
|
if($or_cond6_i){label=200;break;}else{label=340;break;}
|
||
|
|
case 200:
|
||
|
|
var $880=$875;
|
||
|
|
var $881=$874;
|
||
|
|
var $882=((($880)-($881))|0);
|
||
|
|
var $883=((($nb_0)+(40))|0);
|
||
|
|
var $884=($882>>>0)>($883>>>0);
|
||
|
|
var $_tsize_1_i=($884?$882:$tsize_1_i);
|
||
|
|
if($884){var $tsize_244_i=$_tsize_1_i;var $tbase_245_i=$874;label=201;break;}else{label=340;break;}
|
||
|
|
case 201:
|
||
|
|
var $tbase_245_i;
|
||
|
|
var $tsize_244_i;
|
||
|
|
var $885=HEAP32[((472)>>2)];
|
||
|
|
var $886=((($885)+($tsize_244_i))|0);
|
||
|
|
HEAP32[((472)>>2)]=$886;
|
||
|
|
var $887=HEAP32[((476)>>2)];
|
||
|
|
var $888=($886>>>0)>($887>>>0);
|
||
|
|
if($888){label=202;break;}else{label=203;break;}
|
||
|
|
case 202:
|
||
|
|
HEAP32[((476)>>2)]=$886;
|
||
|
|
label=203;break;
|
||
|
|
case 203:
|
||
|
|
var $891=HEAP32[((64)>>2)];
|
||
|
|
var $892=($891|0)==0;
|
||
|
|
if($892){label=204;break;}else{var $sp_073_i=488;label=211;break;}
|
||
|
|
case 204:
|
||
|
|
var $894=HEAP32[((56)>>2)];
|
||
|
|
var $895=($894|0)==0;
|
||
|
|
var $896=($tbase_245_i>>>0)<($894>>>0);
|
||
|
|
var $or_cond8_i=$895|$896;
|
||
|
|
if($or_cond8_i){label=205;break;}else{label=206;break;}
|
||
|
|
case 205:
|
||
|
|
HEAP32[((56)>>2)]=$tbase_245_i;
|
||
|
|
label=206;break;
|
||
|
|
case 206:
|
||
|
|
HEAP32[((488)>>2)]=$tbase_245_i;
|
||
|
|
HEAP32[((492)>>2)]=$tsize_244_i;
|
||
|
|
HEAP32[((500)>>2)]=0;
|
||
|
|
var $899=HEAP32[((16)>>2)];
|
||
|
|
HEAP32[((76)>>2)]=$899;
|
||
|
|
HEAP32[((72)>>2)]=-1;
|
||
|
|
var $i_02_i_i=0;label=207;break;
|
||
|
|
case 207:
|
||
|
|
var $i_02_i_i;
|
||
|
|
var $901=$i_02_i_i<<1;
|
||
|
|
var $902=((80+($901<<2))|0);
|
||
|
|
var $903=$902;
|
||
|
|
var $_sum_i_i=((($901)+(3))|0);
|
||
|
|
var $904=((80+($_sum_i_i<<2))|0);
|
||
|
|
HEAP32[(($904)>>2)]=$903;
|
||
|
|
var $_sum1_i_i=((($901)+(2))|0);
|
||
|
|
var $905=((80+($_sum1_i_i<<2))|0);
|
||
|
|
HEAP32[(($905)>>2)]=$903;
|
||
|
|
var $906=((($i_02_i_i)+(1))|0);
|
||
|
|
var $907=($906>>>0)<32;
|
||
|
|
if($907){var $i_02_i_i=$906;label=207;break;}else{label=208;break;}
|
||
|
|
case 208:
|
||
|
|
var $908=((($tsize_244_i)-(40))|0);
|
||
|
|
var $909=(($tbase_245_i+8)|0);
|
||
|
|
var $910=$909;
|
||
|
|
var $911=$910&7;
|
||
|
|
var $912=($911|0)==0;
|
||
|
|
if($912){var $916=0;label=210;break;}else{label=209;break;}
|
||
|
|
case 209:
|
||
|
|
var $914=(((-$910))|0);
|
||
|
|
var $915=$914&7;
|
||
|
|
var $916=$915;label=210;break;
|
||
|
|
case 210:
|
||
|
|
var $916;
|
||
|
|
var $917=(($tbase_245_i+$916)|0);
|
||
|
|
var $918=$917;
|
||
|
|
var $919=((($908)-($916))|0);
|
||
|
|
HEAP32[((64)>>2)]=$918;
|
||
|
|
HEAP32[((52)>>2)]=$919;
|
||
|
|
var $920=$919|1;
|
||
|
|
var $_sum_i12_i=((($916)+(4))|0);
|
||
|
|
var $921=(($tbase_245_i+$_sum_i12_i)|0);
|
||
|
|
var $922=$921;
|
||
|
|
HEAP32[(($922)>>2)]=$920;
|
||
|
|
var $_sum2_i_i=((($tsize_244_i)-(36))|0);
|
||
|
|
var $923=(($tbase_245_i+$_sum2_i_i)|0);
|
||
|
|
var $924=$923;
|
||
|
|
HEAP32[(($924)>>2)]=40;
|
||
|
|
var $925=HEAP32[((32)>>2)];
|
||
|
|
HEAP32[((68)>>2)]=$925;
|
||
|
|
label=338;break;
|
||
|
|
case 211:
|
||
|
|
var $sp_073_i;
|
||
|
|
var $926=(($sp_073_i)|0);
|
||
|
|
var $927=HEAP32[(($926)>>2)];
|
||
|
|
var $928=(($sp_073_i+4)|0);
|
||
|
|
var $929=HEAP32[(($928)>>2)];
|
||
|
|
var $930=(($927+$929)|0);
|
||
|
|
var $931=($tbase_245_i|0)==($930|0);
|
||
|
|
if($931){label=213;break;}else{label=212;break;}
|
||
|
|
case 212:
|
||
|
|
var $933=(($sp_073_i+8)|0);
|
||
|
|
var $934=HEAP32[(($933)>>2)];
|
||
|
|
var $935=($934|0)==0;
|
||
|
|
if($935){label=218;break;}else{var $sp_073_i=$934;label=211;break;}
|
||
|
|
case 213:
|
||
|
|
var $936=(($sp_073_i+12)|0);
|
||
|
|
var $937=HEAP32[(($936)>>2)];
|
||
|
|
var $938=$937&8;
|
||
|
|
var $939=($938|0)==0;
|
||
|
|
if($939){label=214;break;}else{label=218;break;}
|
||
|
|
case 214:
|
||
|
|
var $941=$891;
|
||
|
|
var $942=($941>>>0)>=($927>>>0);
|
||
|
|
var $943=($941>>>0)<($tbase_245_i>>>0);
|
||
|
|
var $or_cond47_i=$942&$943;
|
||
|
|
if($or_cond47_i){label=215;break;}else{label=218;break;}
|
||
|
|
case 215:
|
||
|
|
var $945=((($929)+($tsize_244_i))|0);
|
||
|
|
HEAP32[(($928)>>2)]=$945;
|
||
|
|
var $946=HEAP32[((64)>>2)];
|
||
|
|
var $947=HEAP32[((52)>>2)];
|
||
|
|
var $948=((($947)+($tsize_244_i))|0);
|
||
|
|
var $949=$946;
|
||
|
|
var $950=(($946+8)|0);
|
||
|
|
var $951=$950;
|
||
|
|
var $952=$951&7;
|
||
|
|
var $953=($952|0)==0;
|
||
|
|
if($953){var $957=0;label=217;break;}else{label=216;break;}
|
||
|
|
case 216:
|
||
|
|
var $955=(((-$951))|0);
|
||
|
|
var $956=$955&7;
|
||
|
|
var $957=$956;label=217;break;
|
||
|
|
case 217:
|
||
|
|
var $957;
|
||
|
|
var $958=(($949+$957)|0);
|
||
|
|
var $959=$958;
|
||
|
|
var $960=((($948)-($957))|0);
|
||
|
|
HEAP32[((64)>>2)]=$959;
|
||
|
|
HEAP32[((52)>>2)]=$960;
|
||
|
|
var $961=$960|1;
|
||
|
|
var $_sum_i16_i=((($957)+(4))|0);
|
||
|
|
var $962=(($949+$_sum_i16_i)|0);
|
||
|
|
var $963=$962;
|
||
|
|
HEAP32[(($963)>>2)]=$961;
|
||
|
|
var $_sum2_i17_i=((($948)+(4))|0);
|
||
|
|
var $964=(($949+$_sum2_i17_i)|0);
|
||
|
|
var $965=$964;
|
||
|
|
HEAP32[(($965)>>2)]=40;
|
||
|
|
var $966=HEAP32[((32)>>2)];
|
||
|
|
HEAP32[((68)>>2)]=$966;
|
||
|
|
label=338;break;
|
||
|
|
case 218:
|
||
|
|
var $967=HEAP32[((56)>>2)];
|
||
|
|
var $968=($tbase_245_i>>>0)<($967>>>0);
|
||
|
|
if($968){label=219;break;}else{label=220;break;}
|
||
|
|
case 219:
|
||
|
|
HEAP32[((56)>>2)]=$tbase_245_i;
|
||
|
|
label=220;break;
|
||
|
|
case 220:
|
||
|
|
var $970=(($tbase_245_i+$tsize_244_i)|0);
|
||
|
|
var $sp_166_i=488;label=221;break;
|
||
|
|
case 221:
|
||
|
|
var $sp_166_i;
|
||
|
|
var $972=(($sp_166_i)|0);
|
||
|
|
var $973=HEAP32[(($972)>>2)];
|
||
|
|
var $974=($973|0)==($970|0);
|
||
|
|
if($974){label=223;break;}else{label=222;break;}
|
||
|
|
case 222:
|
||
|
|
var $976=(($sp_166_i+8)|0);
|
||
|
|
var $977=HEAP32[(($976)>>2)];
|
||
|
|
var $978=($977|0)==0;
|
||
|
|
if($978){label=304;break;}else{var $sp_166_i=$977;label=221;break;}
|
||
|
|
case 223:
|
||
|
|
var $979=(($sp_166_i+12)|0);
|
||
|
|
var $980=HEAP32[(($979)>>2)];
|
||
|
|
var $981=$980&8;
|
||
|
|
var $982=($981|0)==0;
|
||
|
|
if($982){label=224;break;}else{label=304;break;}
|
||
|
|
case 224:
|
||
|
|
HEAP32[(($972)>>2)]=$tbase_245_i;
|
||
|
|
var $984=(($sp_166_i+4)|0);
|
||
|
|
var $985=HEAP32[(($984)>>2)];
|
||
|
|
var $986=((($985)+($tsize_244_i))|0);
|
||
|
|
HEAP32[(($984)>>2)]=$986;
|
||
|
|
var $987=(($tbase_245_i+8)|0);
|
||
|
|
var $988=$987;
|
||
|
|
var $989=$988&7;
|
||
|
|
var $990=($989|0)==0;
|
||
|
|
if($990){var $995=0;label=226;break;}else{label=225;break;}
|
||
|
|
case 225:
|
||
|
|
var $992=(((-$988))|0);
|
||
|
|
var $993=$992&7;
|
||
|
|
var $995=$993;label=226;break;
|
||
|
|
case 226:
|
||
|
|
var $995;
|
||
|
|
var $996=(($tbase_245_i+$995)|0);
|
||
|
|
var $_sum102_i=((($tsize_244_i)+(8))|0);
|
||
|
|
var $997=(($tbase_245_i+$_sum102_i)|0);
|
||
|
|
var $998=$997;
|
||
|
|
var $999=$998&7;
|
||
|
|
var $1000=($999|0)==0;
|
||
|
|
if($1000){var $1005=0;label=228;break;}else{label=227;break;}
|
||
|
|
case 227:
|
||
|
|
var $1002=(((-$998))|0);
|
||
|
|
var $1003=$1002&7;
|
||
|
|
var $1005=$1003;label=228;break;
|
||
|
|
case 228:
|
||
|
|
var $1005;
|
||
|
|
var $_sum103_i=((($1005)+($tsize_244_i))|0);
|
||
|
|
var $1006=(($tbase_245_i+$_sum103_i)|0);
|
||
|
|
var $1007=$1006;
|
||
|
|
var $1008=$1006;
|
||
|
|
var $1009=$996;
|
||
|
|
var $1010=((($1008)-($1009))|0);
|
||
|
|
var $_sum_i19_i=((($995)+($nb_0))|0);
|
||
|
|
var $1011=(($tbase_245_i+$_sum_i19_i)|0);
|
||
|
|
var $1012=$1011;
|
||
|
|
var $1013=((($1010)-($nb_0))|0);
|
||
|
|
var $1014=$nb_0|3;
|
||
|
|
var $_sum1_i20_i=((($995)+(4))|0);
|
||
|
|
var $1015=(($tbase_245_i+$_sum1_i20_i)|0);
|
||
|
|
var $1016=$1015;
|
||
|
|
HEAP32[(($1016)>>2)]=$1014;
|
||
|
|
var $1017=HEAP32[((64)>>2)];
|
||
|
|
var $1018=($1007|0)==($1017|0);
|
||
|
|
if($1018){label=229;break;}else{label=230;break;}
|
||
|
|
case 229:
|
||
|
|
var $1020=HEAP32[((52)>>2)];
|
||
|
|
var $1021=((($1020)+($1013))|0);
|
||
|
|
HEAP32[((52)>>2)]=$1021;
|
||
|
|
HEAP32[((64)>>2)]=$1012;
|
||
|
|
var $1022=$1021|1;
|
||
|
|
var $_sum46_i_i=((($_sum_i19_i)+(4))|0);
|
||
|
|
var $1023=(($tbase_245_i+$_sum46_i_i)|0);
|
||
|
|
var $1024=$1023;
|
||
|
|
HEAP32[(($1024)>>2)]=$1022;
|
||
|
|
label=303;break;
|
||
|
|
case 230:
|
||
|
|
var $1026=HEAP32[((60)>>2)];
|
||
|
|
var $1027=($1007|0)==($1026|0);
|
||
|
|
if($1027){label=231;break;}else{label=232;break;}
|
||
|
|
case 231:
|
||
|
|
var $1029=HEAP32[((48)>>2)];
|
||
|
|
var $1030=((($1029)+($1013))|0);
|
||
|
|
HEAP32[((48)>>2)]=$1030;
|
||
|
|
HEAP32[((60)>>2)]=$1012;
|
||
|
|
var $1031=$1030|1;
|
||
|
|
var $_sum44_i_i=((($_sum_i19_i)+(4))|0);
|
||
|
|
var $1032=(($tbase_245_i+$_sum44_i_i)|0);
|
||
|
|
var $1033=$1032;
|
||
|
|
HEAP32[(($1033)>>2)]=$1031;
|
||
|
|
var $_sum45_i_i=((($1030)+($_sum_i19_i))|0);
|
||
|
|
var $1034=(($tbase_245_i+$_sum45_i_i)|0);
|
||
|
|
var $1035=$1034;
|
||
|
|
HEAP32[(($1035)>>2)]=$1030;
|
||
|
|
label=303;break;
|
||
|
|
case 232:
|
||
|
|
var $_sum2_i21_i=((($tsize_244_i)+(4))|0);
|
||
|
|
var $_sum104_i=((($_sum2_i21_i)+($1005))|0);
|
||
|
|
var $1037=(($tbase_245_i+$_sum104_i)|0);
|
||
|
|
var $1038=$1037;
|
||
|
|
var $1039=HEAP32[(($1038)>>2)];
|
||
|
|
var $1040=$1039&3;
|
||
|
|
var $1041=($1040|0)==1;
|
||
|
|
if($1041){label=233;break;}else{var $oldfirst_0_i_i=$1007;var $qsize_0_i_i=$1013;label=280;break;}
|
||
|
|
case 233:
|
||
|
|
var $1043=$1039&-8;
|
||
|
|
var $1044=$1039>>>3;
|
||
|
|
var $1045=($1039>>>0)<256;
|
||
|
|
if($1045){label=234;break;}else{label=246;break;}
|
||
|
|
case 234:
|
||
|
|
var $_sum3940_i_i=$1005|8;
|
||
|
|
var $_sum114_i=((($_sum3940_i_i)+($tsize_244_i))|0);
|
||
|
|
var $1047=(($tbase_245_i+$_sum114_i)|0);
|
||
|
|
var $1048=$1047;
|
||
|
|
var $1049=HEAP32[(($1048)>>2)];
|
||
|
|
var $_sum41_i_i=((($tsize_244_i)+(12))|0);
|
||
|
|
var $_sum115_i=((($_sum41_i_i)+($1005))|0);
|
||
|
|
var $1050=(($tbase_245_i+$_sum115_i)|0);
|
||
|
|
var $1051=$1050;
|
||
|
|
var $1052=HEAP32[(($1051)>>2)];
|
||
|
|
var $1053=$1044<<1;
|
||
|
|
var $1054=((80+($1053<<2))|0);
|
||
|
|
var $1055=$1054;
|
||
|
|
var $1056=($1049|0)==($1055|0);
|
||
|
|
if($1056){label=237;break;}else{label=235;break;}
|
||
|
|
case 235:
|
||
|
|
var $1058=$1049;
|
||
|
|
var $1059=HEAP32[((56)>>2)];
|
||
|
|
var $1060=($1058>>>0)<($1059>>>0);
|
||
|
|
if($1060){label=245;break;}else{label=236;break;}
|
||
|
|
case 236:
|
||
|
|
var $1062=(($1049+12)|0);
|
||
|
|
var $1063=HEAP32[(($1062)>>2)];
|
||
|
|
var $1064=($1063|0)==($1007|0);
|
||
|
|
if($1064){label=237;break;}else{label=245;break;}
|
||
|
|
case 237:
|
||
|
|
var $1065=($1052|0)==($1049|0);
|
||
|
|
if($1065){label=238;break;}else{label=239;break;}
|
||
|
|
case 238:
|
||
|
|
var $1067=1<<$1044;
|
||
|
|
var $1068=$1067^-1;
|
||
|
|
var $1069=HEAP32[((40)>>2)];
|
||
|
|
var $1070=$1069&$1068;
|
||
|
|
HEAP32[((40)>>2)]=$1070;
|
||
|
|
label=279;break;
|
||
|
|
case 239:
|
||
|
|
var $1072=($1052|0)==($1055|0);
|
||
|
|
if($1072){label=240;break;}else{label=241;break;}
|
||
|
|
case 240:
|
||
|
|
var $_pre62_i_i=(($1052+8)|0);
|
||
|
|
var $_pre_phi63_i_i=$_pre62_i_i;label=243;break;
|
||
|
|
case 241:
|
||
|
|
var $1074=$1052;
|
||
|
|
var $1075=HEAP32[((56)>>2)];
|
||
|
|
var $1076=($1074>>>0)<($1075>>>0);
|
||
|
|
if($1076){label=244;break;}else{label=242;break;}
|
||
|
|
case 242:
|
||
|
|
var $1078=(($1052+8)|0);
|
||
|
|
var $1079=HEAP32[(($1078)>>2)];
|
||
|
|
var $1080=($1079|0)==($1007|0);
|
||
|
|
if($1080){var $_pre_phi63_i_i=$1078;label=243;break;}else{label=244;break;}
|
||
|
|
case 243:
|
||
|
|
var $_pre_phi63_i_i;
|
||
|
|
var $1081=(($1049+12)|0);
|
||
|
|
HEAP32[(($1081)>>2)]=$1052;
|
||
|
|
HEAP32[(($_pre_phi63_i_i)>>2)]=$1049;
|
||
|
|
label=279;break;
|
||
|
|
case 244:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 245:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 246:
|
||
|
|
var $1083=$1006;
|
||
|
|
var $_sum34_i_i=$1005|24;
|
||
|
|
var $_sum105_i=((($_sum34_i_i)+($tsize_244_i))|0);
|
||
|
|
var $1084=(($tbase_245_i+$_sum105_i)|0);
|
||
|
|
var $1085=$1084;
|
||
|
|
var $1086=HEAP32[(($1085)>>2)];
|
||
|
|
var $_sum5_i_i=((($tsize_244_i)+(12))|0);
|
||
|
|
var $_sum106_i=((($_sum5_i_i)+($1005))|0);
|
||
|
|
var $1087=(($tbase_245_i+$_sum106_i)|0);
|
||
|
|
var $1088=$1087;
|
||
|
|
var $1089=HEAP32[(($1088)>>2)];
|
||
|
|
var $1090=($1089|0)==($1083|0);
|
||
|
|
if($1090){label=252;break;}else{label=247;break;}
|
||
|
|
case 247:
|
||
|
|
var $_sum3637_i_i=$1005|8;
|
||
|
|
var $_sum107_i=((($_sum3637_i_i)+($tsize_244_i))|0);
|
||
|
|
var $1092=(($tbase_245_i+$_sum107_i)|0);
|
||
|
|
var $1093=$1092;
|
||
|
|
var $1094=HEAP32[(($1093)>>2)];
|
||
|
|
var $1095=$1094;
|
||
|
|
var $1096=HEAP32[((56)>>2)];
|
||
|
|
var $1097=($1095>>>0)<($1096>>>0);
|
||
|
|
if($1097){label=251;break;}else{label=248;break;}
|
||
|
|
case 248:
|
||
|
|
var $1099=(($1094+12)|0);
|
||
|
|
var $1100=HEAP32[(($1099)>>2)];
|
||
|
|
var $1101=($1100|0)==($1083|0);
|
||
|
|
if($1101){label=249;break;}else{label=251;break;}
|
||
|
|
case 249:
|
||
|
|
var $1103=(($1089+8)|0);
|
||
|
|
var $1104=HEAP32[(($1103)>>2)];
|
||
|
|
var $1105=($1104|0)==($1083|0);
|
||
|
|
if($1105){label=250;break;}else{label=251;break;}
|
||
|
|
case 250:
|
||
|
|
HEAP32[(($1099)>>2)]=$1089;
|
||
|
|
HEAP32[(($1103)>>2)]=$1094;
|
||
|
|
var $R_1_i_i=$1089;label=259;break;
|
||
|
|
case 251:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 252:
|
||
|
|
var $_sum67_i_i=$1005|16;
|
||
|
|
var $_sum112_i=((($_sum2_i21_i)+($_sum67_i_i))|0);
|
||
|
|
var $1108=(($tbase_245_i+$_sum112_i)|0);
|
||
|
|
var $1109=$1108;
|
||
|
|
var $1110=HEAP32[(($1109)>>2)];
|
||
|
|
var $1111=($1110|0)==0;
|
||
|
|
if($1111){label=253;break;}else{var $R_0_i_i=$1110;var $RP_0_i_i=$1109;label=254;break;}
|
||
|
|
case 253:
|
||
|
|
var $_sum113_i=((($_sum67_i_i)+($tsize_244_i))|0);
|
||
|
|
var $1113=(($tbase_245_i+$_sum113_i)|0);
|
||
|
|
var $1114=$1113;
|
||
|
|
var $1115=HEAP32[(($1114)>>2)];
|
||
|
|
var $1116=($1115|0)==0;
|
||
|
|
if($1116){var $R_1_i_i=0;label=259;break;}else{var $R_0_i_i=$1115;var $RP_0_i_i=$1114;label=254;break;}
|
||
|
|
case 254:
|
||
|
|
var $RP_0_i_i;
|
||
|
|
var $R_0_i_i;
|
||
|
|
var $1117=(($R_0_i_i+20)|0);
|
||
|
|
var $1118=HEAP32[(($1117)>>2)];
|
||
|
|
var $1119=($1118|0)==0;
|
||
|
|
if($1119){label=255;break;}else{var $R_0_i_i=$1118;var $RP_0_i_i=$1117;label=254;break;}
|
||
|
|
case 255:
|
||
|
|
var $1121=(($R_0_i_i+16)|0);
|
||
|
|
var $1122=HEAP32[(($1121)>>2)];
|
||
|
|
var $1123=($1122|0)==0;
|
||
|
|
if($1123){label=256;break;}else{var $R_0_i_i=$1122;var $RP_0_i_i=$1121;label=254;break;}
|
||
|
|
case 256:
|
||
|
|
var $1125=$RP_0_i_i;
|
||
|
|
var $1126=HEAP32[((56)>>2)];
|
||
|
|
var $1127=($1125>>>0)<($1126>>>0);
|
||
|
|
if($1127){label=258;break;}else{label=257;break;}
|
||
|
|
case 257:
|
||
|
|
HEAP32[(($RP_0_i_i)>>2)]=0;
|
||
|
|
var $R_1_i_i=$R_0_i_i;label=259;break;
|
||
|
|
case 258:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 259:
|
||
|
|
var $R_1_i_i;
|
||
|
|
var $1131=($1086|0)==0;
|
||
|
|
if($1131){label=279;break;}else{label=260;break;}
|
||
|
|
case 260:
|
||
|
|
var $_sum31_i_i=((($tsize_244_i)+(28))|0);
|
||
|
|
var $_sum108_i=((($_sum31_i_i)+($1005))|0);
|
||
|
|
var $1133=(($tbase_245_i+$_sum108_i)|0);
|
||
|
|
var $1134=$1133;
|
||
|
|
var $1135=HEAP32[(($1134)>>2)];
|
||
|
|
var $1136=((344+($1135<<2))|0);
|
||
|
|
var $1137=HEAP32[(($1136)>>2)];
|
||
|
|
var $1138=($1083|0)==($1137|0);
|
||
|
|
if($1138){label=261;break;}else{label=263;break;}
|
||
|
|
case 261:
|
||
|
|
HEAP32[(($1136)>>2)]=$R_1_i_i;
|
||
|
|
var $cond_i_i=($R_1_i_i|0)==0;
|
||
|
|
if($cond_i_i){label=262;break;}else{label=269;break;}
|
||
|
|
case 262:
|
||
|
|
var $1140=HEAP32[(($1134)>>2)];
|
||
|
|
var $1141=1<<$1140;
|
||
|
|
var $1142=$1141^-1;
|
||
|
|
var $1143=HEAP32[((44)>>2)];
|
||
|
|
var $1144=$1143&$1142;
|
||
|
|
HEAP32[((44)>>2)]=$1144;
|
||
|
|
label=279;break;
|
||
|
|
case 263:
|
||
|
|
var $1146=$1086;
|
||
|
|
var $1147=HEAP32[((56)>>2)];
|
||
|
|
var $1148=($1146>>>0)<($1147>>>0);
|
||
|
|
if($1148){label=267;break;}else{label=264;break;}
|
||
|
|
case 264:
|
||
|
|
var $1150=(($1086+16)|0);
|
||
|
|
var $1151=HEAP32[(($1150)>>2)];
|
||
|
|
var $1152=($1151|0)==($1083|0);
|
||
|
|
if($1152){label=265;break;}else{label=266;break;}
|
||
|
|
case 265:
|
||
|
|
HEAP32[(($1150)>>2)]=$R_1_i_i;
|
||
|
|
label=268;break;
|
||
|
|
case 266:
|
||
|
|
var $1155=(($1086+20)|0);
|
||
|
|
HEAP32[(($1155)>>2)]=$R_1_i_i;
|
||
|
|
label=268;break;
|
||
|
|
case 267:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 268:
|
||
|
|
var $1158=($R_1_i_i|0)==0;
|
||
|
|
if($1158){label=279;break;}else{label=269;break;}
|
||
|
|
case 269:
|
||
|
|
var $1160=$R_1_i_i;
|
||
|
|
var $1161=HEAP32[((56)>>2)];
|
||
|
|
var $1162=($1160>>>0)<($1161>>>0);
|
||
|
|
if($1162){label=278;break;}else{label=270;break;}
|
||
|
|
case 270:
|
||
|
|
var $1164=(($R_1_i_i+24)|0);
|
||
|
|
HEAP32[(($1164)>>2)]=$1086;
|
||
|
|
var $_sum3233_i_i=$1005|16;
|
||
|
|
var $_sum109_i=((($_sum3233_i_i)+($tsize_244_i))|0);
|
||
|
|
var $1165=(($tbase_245_i+$_sum109_i)|0);
|
||
|
|
var $1166=$1165;
|
||
|
|
var $1167=HEAP32[(($1166)>>2)];
|
||
|
|
var $1168=($1167|0)==0;
|
||
|
|
if($1168){label=274;break;}else{label=271;break;}
|
||
|
|
case 271:
|
||
|
|
var $1170=$1167;
|
||
|
|
var $1171=HEAP32[((56)>>2)];
|
||
|
|
var $1172=($1170>>>0)<($1171>>>0);
|
||
|
|
if($1172){label=273;break;}else{label=272;break;}
|
||
|
|
case 272:
|
||
|
|
var $1174=(($R_1_i_i+16)|0);
|
||
|
|
HEAP32[(($1174)>>2)]=$1167;
|
||
|
|
var $1175=(($1167+24)|0);
|
||
|
|
HEAP32[(($1175)>>2)]=$R_1_i_i;
|
||
|
|
label=274;break;
|
||
|
|
case 273:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 274:
|
||
|
|
var $_sum110_i=((($_sum2_i21_i)+($_sum3233_i_i))|0);
|
||
|
|
var $1178=(($tbase_245_i+$_sum110_i)|0);
|
||
|
|
var $1179=$1178;
|
||
|
|
var $1180=HEAP32[(($1179)>>2)];
|
||
|
|
var $1181=($1180|0)==0;
|
||
|
|
if($1181){label=279;break;}else{label=275;break;}
|
||
|
|
case 275:
|
||
|
|
var $1183=$1180;
|
||
|
|
var $1184=HEAP32[((56)>>2)];
|
||
|
|
var $1185=($1183>>>0)<($1184>>>0);
|
||
|
|
if($1185){label=277;break;}else{label=276;break;}
|
||
|
|
case 276:
|
||
|
|
var $1187=(($R_1_i_i+20)|0);
|
||
|
|
HEAP32[(($1187)>>2)]=$1180;
|
||
|
|
var $1188=(($1180+24)|0);
|
||
|
|
HEAP32[(($1188)>>2)]=$R_1_i_i;
|
||
|
|
label=279;break;
|
||
|
|
case 277:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 278:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 279:
|
||
|
|
var $_sum9_i_i=$1043|$1005;
|
||
|
|
var $_sum111_i=((($_sum9_i_i)+($tsize_244_i))|0);
|
||
|
|
var $1192=(($tbase_245_i+$_sum111_i)|0);
|
||
|
|
var $1193=$1192;
|
||
|
|
var $1194=((($1043)+($1013))|0);
|
||
|
|
var $oldfirst_0_i_i=$1193;var $qsize_0_i_i=$1194;label=280;break;
|
||
|
|
case 280:
|
||
|
|
var $qsize_0_i_i;
|
||
|
|
var $oldfirst_0_i_i;
|
||
|
|
var $1196=(($oldfirst_0_i_i+4)|0);
|
||
|
|
var $1197=HEAP32[(($1196)>>2)];
|
||
|
|
var $1198=$1197&-2;
|
||
|
|
HEAP32[(($1196)>>2)]=$1198;
|
||
|
|
var $1199=$qsize_0_i_i|1;
|
||
|
|
var $_sum10_i_i=((($_sum_i19_i)+(4))|0);
|
||
|
|
var $1200=(($tbase_245_i+$_sum10_i_i)|0);
|
||
|
|
var $1201=$1200;
|
||
|
|
HEAP32[(($1201)>>2)]=$1199;
|
||
|
|
var $_sum11_i_i=((($qsize_0_i_i)+($_sum_i19_i))|0);
|
||
|
|
var $1202=(($tbase_245_i+$_sum11_i_i)|0);
|
||
|
|
var $1203=$1202;
|
||
|
|
HEAP32[(($1203)>>2)]=$qsize_0_i_i;
|
||
|
|
var $1204=$qsize_0_i_i>>>3;
|
||
|
|
var $1205=($qsize_0_i_i>>>0)<256;
|
||
|
|
if($1205){label=281;break;}else{label=286;break;}
|
||
|
|
case 281:
|
||
|
|
var $1207=$1204<<1;
|
||
|
|
var $1208=((80+($1207<<2))|0);
|
||
|
|
var $1209=$1208;
|
||
|
|
var $1210=HEAP32[((40)>>2)];
|
||
|
|
var $1211=1<<$1204;
|
||
|
|
var $1212=$1210&$1211;
|
||
|
|
var $1213=($1212|0)==0;
|
||
|
|
if($1213){label=282;break;}else{label=283;break;}
|
||
|
|
case 282:
|
||
|
|
var $1215=$1210|$1211;
|
||
|
|
HEAP32[((40)>>2)]=$1215;
|
||
|
|
var $_sum27_pre_i_i=((($1207)+(2))|0);
|
||
|
|
var $_pre_i22_i=((80+($_sum27_pre_i_i<<2))|0);
|
||
|
|
var $F4_0_i_i=$1209;var $_pre_phi_i23_i=$_pre_i22_i;label=285;break;
|
||
|
|
case 283:
|
||
|
|
var $_sum30_i_i=((($1207)+(2))|0);
|
||
|
|
var $1217=((80+($_sum30_i_i<<2))|0);
|
||
|
|
var $1218=HEAP32[(($1217)>>2)];
|
||
|
|
var $1219=$1218;
|
||
|
|
var $1220=HEAP32[((56)>>2)];
|
||
|
|
var $1221=($1219>>>0)<($1220>>>0);
|
||
|
|
if($1221){label=284;break;}else{var $F4_0_i_i=$1218;var $_pre_phi_i23_i=$1217;label=285;break;}
|
||
|
|
case 284:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 285:
|
||
|
|
var $_pre_phi_i23_i;
|
||
|
|
var $F4_0_i_i;
|
||
|
|
HEAP32[(($_pre_phi_i23_i)>>2)]=$1012;
|
||
|
|
var $1224=(($F4_0_i_i+12)|0);
|
||
|
|
HEAP32[(($1224)>>2)]=$1012;
|
||
|
|
var $_sum28_i_i=((($_sum_i19_i)+(8))|0);
|
||
|
|
var $1225=(($tbase_245_i+$_sum28_i_i)|0);
|
||
|
|
var $1226=$1225;
|
||
|
|
HEAP32[(($1226)>>2)]=$F4_0_i_i;
|
||
|
|
var $_sum29_i_i=((($_sum_i19_i)+(12))|0);
|
||
|
|
var $1227=(($tbase_245_i+$_sum29_i_i)|0);
|
||
|
|
var $1228=$1227;
|
||
|
|
HEAP32[(($1228)>>2)]=$1209;
|
||
|
|
label=303;break;
|
||
|
|
case 286:
|
||
|
|
var $1230=$1011;
|
||
|
|
var $1231=$qsize_0_i_i>>>8;
|
||
|
|
var $1232=($1231|0)==0;
|
||
|
|
if($1232){var $I7_0_i_i=0;label=289;break;}else{label=287;break;}
|
||
|
|
case 287:
|
||
|
|
var $1234=($qsize_0_i_i>>>0)>16777215;
|
||
|
|
if($1234){var $I7_0_i_i=31;label=289;break;}else{label=288;break;}
|
||
|
|
case 288:
|
||
|
|
var $1236=((($1231)+(1048320))|0);
|
||
|
|
var $1237=$1236>>>16;
|
||
|
|
var $1238=$1237&8;
|
||
|
|
var $1239=$1231<<$1238;
|
||
|
|
var $1240=((($1239)+(520192))|0);
|
||
|
|
var $1241=$1240>>>16;
|
||
|
|
var $1242=$1241&4;
|
||
|
|
var $1243=$1242|$1238;
|
||
|
|
var $1244=$1239<<$1242;
|
||
|
|
var $1245=((($1244)+(245760))|0);
|
||
|
|
var $1246=$1245>>>16;
|
||
|
|
var $1247=$1246&2;
|
||
|
|
var $1248=$1243|$1247;
|
||
|
|
var $1249=(((14)-($1248))|0);
|
||
|
|
var $1250=$1244<<$1247;
|
||
|
|
var $1251=$1250>>>15;
|
||
|
|
var $1252=((($1249)+($1251))|0);
|
||
|
|
var $1253=$1252<<1;
|
||
|
|
var $1254=((($1252)+(7))|0);
|
||
|
|
var $1255=$qsize_0_i_i>>>($1254>>>0);
|
||
|
|
var $1256=$1255&1;
|
||
|
|
var $1257=$1256|$1253;
|
||
|
|
var $I7_0_i_i=$1257;label=289;break;
|
||
|
|
case 289:
|
||
|
|
var $I7_0_i_i;
|
||
|
|
var $1259=((344+($I7_0_i_i<<2))|0);
|
||
|
|
var $_sum12_i24_i=((($_sum_i19_i)+(28))|0);
|
||
|
|
var $1260=(($tbase_245_i+$_sum12_i24_i)|0);
|
||
|
|
var $1261=$1260;
|
||
|
|
HEAP32[(($1261)>>2)]=$I7_0_i_i;
|
||
|
|
var $_sum13_i_i=((($_sum_i19_i)+(16))|0);
|
||
|
|
var $1262=(($tbase_245_i+$_sum13_i_i)|0);
|
||
|
|
var $_sum14_i_i=((($_sum_i19_i)+(20))|0);
|
||
|
|
var $1263=(($tbase_245_i+$_sum14_i_i)|0);
|
||
|
|
var $1264=$1263;
|
||
|
|
HEAP32[(($1264)>>2)]=0;
|
||
|
|
var $1265=$1262;
|
||
|
|
HEAP32[(($1265)>>2)]=0;
|
||
|
|
var $1266=HEAP32[((44)>>2)];
|
||
|
|
var $1267=1<<$I7_0_i_i;
|
||
|
|
var $1268=$1266&$1267;
|
||
|
|
var $1269=($1268|0)==0;
|
||
|
|
if($1269){label=290;break;}else{label=291;break;}
|
||
|
|
case 290:
|
||
|
|
var $1271=$1266|$1267;
|
||
|
|
HEAP32[((44)>>2)]=$1271;
|
||
|
|
HEAP32[(($1259)>>2)]=$1230;
|
||
|
|
var $1272=$1259;
|
||
|
|
var $_sum15_i_i=((($_sum_i19_i)+(24))|0);
|
||
|
|
var $1273=(($tbase_245_i+$_sum15_i_i)|0);
|
||
|
|
var $1274=$1273;
|
||
|
|
HEAP32[(($1274)>>2)]=$1272;
|
||
|
|
var $_sum16_i_i=((($_sum_i19_i)+(12))|0);
|
||
|
|
var $1275=(($tbase_245_i+$_sum16_i_i)|0);
|
||
|
|
var $1276=$1275;
|
||
|
|
HEAP32[(($1276)>>2)]=$1230;
|
||
|
|
var $_sum17_i_i=((($_sum_i19_i)+(8))|0);
|
||
|
|
var $1277=(($tbase_245_i+$_sum17_i_i)|0);
|
||
|
|
var $1278=$1277;
|
||
|
|
HEAP32[(($1278)>>2)]=$1230;
|
||
|
|
label=303;break;
|
||
|
|
case 291:
|
||
|
|
var $1280=HEAP32[(($1259)>>2)];
|
||
|
|
var $1281=($I7_0_i_i|0)==31;
|
||
|
|
if($1281){var $1286=0;label=293;break;}else{label=292;break;}
|
||
|
|
case 292:
|
||
|
|
var $1283=$I7_0_i_i>>>1;
|
||
|
|
var $1284=(((25)-($1283))|0);
|
||
|
|
var $1286=$1284;label=293;break;
|
||
|
|
case 293:
|
||
|
|
var $1286;
|
||
|
|
var $1287=(($1280+4)|0);
|
||
|
|
var $1288=HEAP32[(($1287)>>2)];
|
||
|
|
var $1289=$1288&-8;
|
||
|
|
var $1290=($1289|0)==($qsize_0_i_i|0);
|
||
|
|
if($1290){var $T_0_lcssa_i26_i=$1280;label=300;break;}else{label=294;break;}
|
||
|
|
case 294:
|
||
|
|
var $1291=$qsize_0_i_i<<$1286;
|
||
|
|
var $T_056_i_i=$1280;var $K8_057_i_i=$1291;label=296;break;
|
||
|
|
case 295:
|
||
|
|
var $1293=$K8_057_i_i<<1;
|
||
|
|
var $1294=(($1301+4)|0);
|
||
|
|
var $1295=HEAP32[(($1294)>>2)];
|
||
|
|
var $1296=$1295&-8;
|
||
|
|
var $1297=($1296|0)==($qsize_0_i_i|0);
|
||
|
|
if($1297){var $T_0_lcssa_i26_i=$1301;label=300;break;}else{var $T_056_i_i=$1301;var $K8_057_i_i=$1293;label=296;break;}
|
||
|
|
case 296:
|
||
|
|
var $K8_057_i_i;
|
||
|
|
var $T_056_i_i;
|
||
|
|
var $1299=$K8_057_i_i>>>31;
|
||
|
|
var $1300=(($T_056_i_i+16+($1299<<2))|0);
|
||
|
|
var $1301=HEAP32[(($1300)>>2)];
|
||
|
|
var $1302=($1301|0)==0;
|
||
|
|
if($1302){label=297;break;}else{label=295;break;}
|
||
|
|
case 297:
|
||
|
|
var $1304=$1300;
|
||
|
|
var $1305=HEAP32[((56)>>2)];
|
||
|
|
var $1306=($1304>>>0)<($1305>>>0);
|
||
|
|
if($1306){label=299;break;}else{label=298;break;}
|
||
|
|
case 298:
|
||
|
|
HEAP32[(($1300)>>2)]=$1230;
|
||
|
|
var $_sum24_i_i=((($_sum_i19_i)+(24))|0);
|
||
|
|
var $1308=(($tbase_245_i+$_sum24_i_i)|0);
|
||
|
|
var $1309=$1308;
|
||
|
|
HEAP32[(($1309)>>2)]=$T_056_i_i;
|
||
|
|
var $_sum25_i_i=((($_sum_i19_i)+(12))|0);
|
||
|
|
var $1310=(($tbase_245_i+$_sum25_i_i)|0);
|
||
|
|
var $1311=$1310;
|
||
|
|
HEAP32[(($1311)>>2)]=$1230;
|
||
|
|
var $_sum26_i_i=((($_sum_i19_i)+(8))|0);
|
||
|
|
var $1312=(($tbase_245_i+$_sum26_i_i)|0);
|
||
|
|
var $1313=$1312;
|
||
|
|
HEAP32[(($1313)>>2)]=$1230;
|
||
|
|
label=303;break;
|
||
|
|
case 299:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 300:
|
||
|
|
var $T_0_lcssa_i26_i;
|
||
|
|
var $1315=(($T_0_lcssa_i26_i+8)|0);
|
||
|
|
var $1316=HEAP32[(($1315)>>2)];
|
||
|
|
var $1317=$T_0_lcssa_i26_i;
|
||
|
|
var $1318=HEAP32[((56)>>2)];
|
||
|
|
var $1319=($1317>>>0)>=($1318>>>0);
|
||
|
|
var $1320=$1316;
|
||
|
|
var $1321=($1320>>>0)>=($1318>>>0);
|
||
|
|
var $or_cond_i27_i=$1319&$1321;
|
||
|
|
if($or_cond_i27_i){label=301;break;}else{label=302;break;}
|
||
|
|
case 301:
|
||
|
|
var $1323=(($1316+12)|0);
|
||
|
|
HEAP32[(($1323)>>2)]=$1230;
|
||
|
|
HEAP32[(($1315)>>2)]=$1230;
|
||
|
|
var $_sum21_i_i=((($_sum_i19_i)+(8))|0);
|
||
|
|
var $1324=(($tbase_245_i+$_sum21_i_i)|0);
|
||
|
|
var $1325=$1324;
|
||
|
|
HEAP32[(($1325)>>2)]=$1316;
|
||
|
|
var $_sum22_i_i=((($_sum_i19_i)+(12))|0);
|
||
|
|
var $1326=(($tbase_245_i+$_sum22_i_i)|0);
|
||
|
|
var $1327=$1326;
|
||
|
|
HEAP32[(($1327)>>2)]=$T_0_lcssa_i26_i;
|
||
|
|
var $_sum23_i_i=((($_sum_i19_i)+(24))|0);
|
||
|
|
var $1328=(($tbase_245_i+$_sum23_i_i)|0);
|
||
|
|
var $1329=$1328;
|
||
|
|
HEAP32[(($1329)>>2)]=0;
|
||
|
|
label=303;break;
|
||
|
|
case 302:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 303:
|
||
|
|
var $_sum1819_i_i=$995|8;
|
||
|
|
var $1330=(($tbase_245_i+$_sum1819_i_i)|0);
|
||
|
|
var $mem_0=$1330;label=341;break;
|
||
|
|
case 304:
|
||
|
|
var $1331=$891;
|
||
|
|
var $sp_0_i_i_i=488;label=305;break;
|
||
|
|
case 305:
|
||
|
|
var $sp_0_i_i_i;
|
||
|
|
var $1333=(($sp_0_i_i_i)|0);
|
||
|
|
var $1334=HEAP32[(($1333)>>2)];
|
||
|
|
var $1335=($1334>>>0)>($1331>>>0);
|
||
|
|
if($1335){label=307;break;}else{label=306;break;}
|
||
|
|
case 306:
|
||
|
|
var $1337=(($sp_0_i_i_i+4)|0);
|
||
|
|
var $1338=HEAP32[(($1337)>>2)];
|
||
|
|
var $1339=(($1334+$1338)|0);
|
||
|
|
var $1340=($1339>>>0)>($1331>>>0);
|
||
|
|
if($1340){label=308;break;}else{label=307;break;}
|
||
|
|
case 307:
|
||
|
|
var $1342=(($sp_0_i_i_i+8)|0);
|
||
|
|
var $1343=HEAP32[(($1342)>>2)];
|
||
|
|
var $sp_0_i_i_i=$1343;label=305;break;
|
||
|
|
case 308:
|
||
|
|
var $_sum_i13_i=((($1338)-(47))|0);
|
||
|
|
var $_sum1_i14_i=((($1338)-(39))|0);
|
||
|
|
var $1344=(($1334+$_sum1_i14_i)|0);
|
||
|
|
var $1345=$1344;
|
||
|
|
var $1346=$1345&7;
|
||
|
|
var $1347=($1346|0)==0;
|
||
|
|
if($1347){var $1352=0;label=310;break;}else{label=309;break;}
|
||
|
|
case 309:
|
||
|
|
var $1349=(((-$1345))|0);
|
||
|
|
var $1350=$1349&7;
|
||
|
|
var $1352=$1350;label=310;break;
|
||
|
|
case 310:
|
||
|
|
var $1352;
|
||
|
|
var $_sum2_i15_i=((($_sum_i13_i)+($1352))|0);
|
||
|
|
var $1353=(($1334+$_sum2_i15_i)|0);
|
||
|
|
var $1354=(($891+16)|0);
|
||
|
|
var $1355=$1354;
|
||
|
|
var $1356=($1353>>>0)<($1355>>>0);
|
||
|
|
var $1357=($1356?$1331:$1353);
|
||
|
|
var $1358=(($1357+8)|0);
|
||
|
|
var $1359=$1358;
|
||
|
|
var $1360=((($tsize_244_i)-(40))|0);
|
||
|
|
var $1361=(($tbase_245_i+8)|0);
|
||
|
|
var $1362=$1361;
|
||
|
|
var $1363=$1362&7;
|
||
|
|
var $1364=($1363|0)==0;
|
||
|
|
if($1364){var $1368=0;label=312;break;}else{label=311;break;}
|
||
|
|
case 311:
|
||
|
|
var $1366=(((-$1362))|0);
|
||
|
|
var $1367=$1366&7;
|
||
|
|
var $1368=$1367;label=312;break;
|
||
|
|
case 312:
|
||
|
|
var $1368;
|
||
|
|
var $1369=(($tbase_245_i+$1368)|0);
|
||
|
|
var $1370=$1369;
|
||
|
|
var $1371=((($1360)-($1368))|0);
|
||
|
|
HEAP32[((64)>>2)]=$1370;
|
||
|
|
HEAP32[((52)>>2)]=$1371;
|
||
|
|
var $1372=$1371|1;
|
||
|
|
var $_sum_i_i_i=((($1368)+(4))|0);
|
||
|
|
var $1373=(($tbase_245_i+$_sum_i_i_i)|0);
|
||
|
|
var $1374=$1373;
|
||
|
|
HEAP32[(($1374)>>2)]=$1372;
|
||
|
|
var $_sum2_i_i_i=((($tsize_244_i)-(36))|0);
|
||
|
|
var $1375=(($tbase_245_i+$_sum2_i_i_i)|0);
|
||
|
|
var $1376=$1375;
|
||
|
|
HEAP32[(($1376)>>2)]=40;
|
||
|
|
var $1377=HEAP32[((32)>>2)];
|
||
|
|
HEAP32[((68)>>2)]=$1377;
|
||
|
|
var $1378=(($1357+4)|0);
|
||
|
|
var $1379=$1378;
|
||
|
|
HEAP32[(($1379)>>2)]=27;
|
||
|
|
assert(16 % 1 === 0);HEAP32[(($1358)>>2)]=HEAP32[((488)>>2)];HEAP32[((($1358)+(4))>>2)]=HEAP32[((492)>>2)];HEAP32[((($1358)+(8))>>2)]=HEAP32[((496)>>2)];HEAP32[((($1358)+(12))>>2)]=HEAP32[((500)>>2)];
|
||
|
|
HEAP32[((488)>>2)]=$tbase_245_i;
|
||
|
|
HEAP32[((492)>>2)]=$tsize_244_i;
|
||
|
|
HEAP32[((500)>>2)]=0;
|
||
|
|
HEAP32[((496)>>2)]=$1359;
|
||
|
|
var $1380=(($1357+28)|0);
|
||
|
|
var $1381=$1380;
|
||
|
|
HEAP32[(($1381)>>2)]=7;
|
||
|
|
var $1382=(($1357+32)|0);
|
||
|
|
var $1383=($1382>>>0)<($1339>>>0);
|
||
|
|
if($1383){var $1384=$1381;label=313;break;}else{label=314;break;}
|
||
|
|
case 313:
|
||
|
|
var $1384;
|
||
|
|
var $1385=(($1384+4)|0);
|
||
|
|
HEAP32[(($1385)>>2)]=7;
|
||
|
|
var $1386=(($1384+8)|0);
|
||
|
|
var $1387=$1386;
|
||
|
|
var $1388=($1387>>>0)<($1339>>>0);
|
||
|
|
if($1388){var $1384=$1385;label=313;break;}else{label=314;break;}
|
||
|
|
case 314:
|
||
|
|
var $1389=($1357|0)==($1331|0);
|
||
|
|
if($1389){label=338;break;}else{label=315;break;}
|
||
|
|
case 315:
|
||
|
|
var $1391=$1357;
|
||
|
|
var $1392=$891;
|
||
|
|
var $1393=((($1391)-($1392))|0);
|
||
|
|
var $1394=(($1331+$1393)|0);
|
||
|
|
var $_sum3_i_i=((($1393)+(4))|0);
|
||
|
|
var $1395=(($1331+$_sum3_i_i)|0);
|
||
|
|
var $1396=$1395;
|
||
|
|
var $1397=HEAP32[(($1396)>>2)];
|
||
|
|
var $1398=$1397&-2;
|
||
|
|
HEAP32[(($1396)>>2)]=$1398;
|
||
|
|
var $1399=$1393|1;
|
||
|
|
var $1400=(($891+4)|0);
|
||
|
|
HEAP32[(($1400)>>2)]=$1399;
|
||
|
|
var $1401=$1394;
|
||
|
|
HEAP32[(($1401)>>2)]=$1393;
|
||
|
|
var $1402=$1393>>>3;
|
||
|
|
var $1403=($1393>>>0)<256;
|
||
|
|
if($1403){label=316;break;}else{label=321;break;}
|
||
|
|
case 316:
|
||
|
|
var $1405=$1402<<1;
|
||
|
|
var $1406=((80+($1405<<2))|0);
|
||
|
|
var $1407=$1406;
|
||
|
|
var $1408=HEAP32[((40)>>2)];
|
||
|
|
var $1409=1<<$1402;
|
||
|
|
var $1410=$1408&$1409;
|
||
|
|
var $1411=($1410|0)==0;
|
||
|
|
if($1411){label=317;break;}else{label=318;break;}
|
||
|
|
case 317:
|
||
|
|
var $1413=$1408|$1409;
|
||
|
|
HEAP32[((40)>>2)]=$1413;
|
||
|
|
var $_sum11_pre_i_i=((($1405)+(2))|0);
|
||
|
|
var $_pre_i_i=((80+($_sum11_pre_i_i<<2))|0);
|
||
|
|
var $F_0_i_i=$1407;var $_pre_phi_i_i=$_pre_i_i;label=320;break;
|
||
|
|
case 318:
|
||
|
|
var $_sum12_i_i=((($1405)+(2))|0);
|
||
|
|
var $1415=((80+($_sum12_i_i<<2))|0);
|
||
|
|
var $1416=HEAP32[(($1415)>>2)];
|
||
|
|
var $1417=$1416;
|
||
|
|
var $1418=HEAP32[((56)>>2)];
|
||
|
|
var $1419=($1417>>>0)<($1418>>>0);
|
||
|
|
if($1419){label=319;break;}else{var $F_0_i_i=$1416;var $_pre_phi_i_i=$1415;label=320;break;}
|
||
|
|
case 319:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 320:
|
||
|
|
var $_pre_phi_i_i;
|
||
|
|
var $F_0_i_i;
|
||
|
|
HEAP32[(($_pre_phi_i_i)>>2)]=$891;
|
||
|
|
var $1422=(($F_0_i_i+12)|0);
|
||
|
|
HEAP32[(($1422)>>2)]=$891;
|
||
|
|
var $1423=(($891+8)|0);
|
||
|
|
HEAP32[(($1423)>>2)]=$F_0_i_i;
|
||
|
|
var $1424=(($891+12)|0);
|
||
|
|
HEAP32[(($1424)>>2)]=$1407;
|
||
|
|
label=338;break;
|
||
|
|
case 321:
|
||
|
|
var $1426=$891;
|
||
|
|
var $1427=$1393>>>8;
|
||
|
|
var $1428=($1427|0)==0;
|
||
|
|
if($1428){var $I1_0_i_i=0;label=324;break;}else{label=322;break;}
|
||
|
|
case 322:
|
||
|
|
var $1430=($1393>>>0)>16777215;
|
||
|
|
if($1430){var $I1_0_i_i=31;label=324;break;}else{label=323;break;}
|
||
|
|
case 323:
|
||
|
|
var $1432=((($1427)+(1048320))|0);
|
||
|
|
var $1433=$1432>>>16;
|
||
|
|
var $1434=$1433&8;
|
||
|
|
var $1435=$1427<<$1434;
|
||
|
|
var $1436=((($1435)+(520192))|0);
|
||
|
|
var $1437=$1436>>>16;
|
||
|
|
var $1438=$1437&4;
|
||
|
|
var $1439=$1438|$1434;
|
||
|
|
var $1440=$1435<<$1438;
|
||
|
|
var $1441=((($1440)+(245760))|0);
|
||
|
|
var $1442=$1441>>>16;
|
||
|
|
var $1443=$1442&2;
|
||
|
|
var $1444=$1439|$1443;
|
||
|
|
var $1445=(((14)-($1444))|0);
|
||
|
|
var $1446=$1440<<$1443;
|
||
|
|
var $1447=$1446>>>15;
|
||
|
|
var $1448=((($1445)+($1447))|0);
|
||
|
|
var $1449=$1448<<1;
|
||
|
|
var $1450=((($1448)+(7))|0);
|
||
|
|
var $1451=$1393>>>($1450>>>0);
|
||
|
|
var $1452=$1451&1;
|
||
|
|
var $1453=$1452|$1449;
|
||
|
|
var $I1_0_i_i=$1453;label=324;break;
|
||
|
|
case 324:
|
||
|
|
var $I1_0_i_i;
|
||
|
|
var $1455=((344+($I1_0_i_i<<2))|0);
|
||
|
|
var $1456=(($891+28)|0);
|
||
|
|
var $I1_0_c_i_i=$I1_0_i_i;
|
||
|
|
HEAP32[(($1456)>>2)]=$I1_0_c_i_i;
|
||
|
|
var $1457=(($891+20)|0);
|
||
|
|
HEAP32[(($1457)>>2)]=0;
|
||
|
|
var $1458=(($891+16)|0);
|
||
|
|
HEAP32[(($1458)>>2)]=0;
|
||
|
|
var $1459=HEAP32[((44)>>2)];
|
||
|
|
var $1460=1<<$I1_0_i_i;
|
||
|
|
var $1461=$1459&$1460;
|
||
|
|
var $1462=($1461|0)==0;
|
||
|
|
if($1462){label=325;break;}else{label=326;break;}
|
||
|
|
case 325:
|
||
|
|
var $1464=$1459|$1460;
|
||
|
|
HEAP32[((44)>>2)]=$1464;
|
||
|
|
HEAP32[(($1455)>>2)]=$1426;
|
||
|
|
var $1465=(($891+24)|0);
|
||
|
|
var $_c_i_i=$1455;
|
||
|
|
HEAP32[(($1465)>>2)]=$_c_i_i;
|
||
|
|
var $1466=(($891+12)|0);
|
||
|
|
HEAP32[(($1466)>>2)]=$891;
|
||
|
|
var $1467=(($891+8)|0);
|
||
|
|
HEAP32[(($1467)>>2)]=$891;
|
||
|
|
label=338;break;
|
||
|
|
case 326:
|
||
|
|
var $1469=HEAP32[(($1455)>>2)];
|
||
|
|
var $1470=($I1_0_i_i|0)==31;
|
||
|
|
if($1470){var $1475=0;label=328;break;}else{label=327;break;}
|
||
|
|
case 327:
|
||
|
|
var $1472=$I1_0_i_i>>>1;
|
||
|
|
var $1473=(((25)-($1472))|0);
|
||
|
|
var $1475=$1473;label=328;break;
|
||
|
|
case 328:
|
||
|
|
var $1475;
|
||
|
|
var $1476=(($1469+4)|0);
|
||
|
|
var $1477=HEAP32[(($1476)>>2)];
|
||
|
|
var $1478=$1477&-8;
|
||
|
|
var $1479=($1478|0)==($1393|0);
|
||
|
|
if($1479){var $T_0_lcssa_i_i=$1469;label=335;break;}else{label=329;break;}
|
||
|
|
case 329:
|
||
|
|
var $1480=$1393<<$1475;
|
||
|
|
var $T_015_i_i=$1469;var $K2_016_i_i=$1480;label=331;break;
|
||
|
|
case 330:
|
||
|
|
var $1482=$K2_016_i_i<<1;
|
||
|
|
var $1483=(($1490+4)|0);
|
||
|
|
var $1484=HEAP32[(($1483)>>2)];
|
||
|
|
var $1485=$1484&-8;
|
||
|
|
var $1486=($1485|0)==($1393|0);
|
||
|
|
if($1486){var $T_0_lcssa_i_i=$1490;label=335;break;}else{var $T_015_i_i=$1490;var $K2_016_i_i=$1482;label=331;break;}
|
||
|
|
case 331:
|
||
|
|
var $K2_016_i_i;
|
||
|
|
var $T_015_i_i;
|
||
|
|
var $1488=$K2_016_i_i>>>31;
|
||
|
|
var $1489=(($T_015_i_i+16+($1488<<2))|0);
|
||
|
|
var $1490=HEAP32[(($1489)>>2)];
|
||
|
|
var $1491=($1490|0)==0;
|
||
|
|
if($1491){label=332;break;}else{label=330;break;}
|
||
|
|
case 332:
|
||
|
|
var $1493=$1489;
|
||
|
|
var $1494=HEAP32[((56)>>2)];
|
||
|
|
var $1495=($1493>>>0)<($1494>>>0);
|
||
|
|
if($1495){label=334;break;}else{label=333;break;}
|
||
|
|
case 333:
|
||
|
|
HEAP32[(($1489)>>2)]=$1426;
|
||
|
|
var $1497=(($891+24)|0);
|
||
|
|
var $T_0_c8_i_i=$T_015_i_i;
|
||
|
|
HEAP32[(($1497)>>2)]=$T_0_c8_i_i;
|
||
|
|
var $1498=(($891+12)|0);
|
||
|
|
HEAP32[(($1498)>>2)]=$891;
|
||
|
|
var $1499=(($891+8)|0);
|
||
|
|
HEAP32[(($1499)>>2)]=$891;
|
||
|
|
label=338;break;
|
||
|
|
case 334:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 335:
|
||
|
|
var $T_0_lcssa_i_i;
|
||
|
|
var $1501=(($T_0_lcssa_i_i+8)|0);
|
||
|
|
var $1502=HEAP32[(($1501)>>2)];
|
||
|
|
var $1503=$T_0_lcssa_i_i;
|
||
|
|
var $1504=HEAP32[((56)>>2)];
|
||
|
|
var $1505=($1503>>>0)>=($1504>>>0);
|
||
|
|
var $1506=$1502;
|
||
|
|
var $1507=($1506>>>0)>=($1504>>>0);
|
||
|
|
var $or_cond_i_i=$1505&$1507;
|
||
|
|
if($or_cond_i_i){label=336;break;}else{label=337;break;}
|
||
|
|
case 336:
|
||
|
|
var $1509=(($1502+12)|0);
|
||
|
|
HEAP32[(($1509)>>2)]=$1426;
|
||
|
|
HEAP32[(($1501)>>2)]=$1426;
|
||
|
|
var $1510=(($891+8)|0);
|
||
|
|
var $_c7_i_i=$1502;
|
||
|
|
HEAP32[(($1510)>>2)]=$_c7_i_i;
|
||
|
|
var $1511=(($891+12)|0);
|
||
|
|
var $T_0_c_i_i=$T_0_lcssa_i_i;
|
||
|
|
HEAP32[(($1511)>>2)]=$T_0_c_i_i;
|
||
|
|
var $1512=(($891+24)|0);
|
||
|
|
HEAP32[(($1512)>>2)]=0;
|
||
|
|
label=338;break;
|
||
|
|
case 337:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 338:
|
||
|
|
var $1513=HEAP32[((52)>>2)];
|
||
|
|
var $1514=($1513>>>0)>($nb_0>>>0);
|
||
|
|
if($1514){label=339;break;}else{label=340;break;}
|
||
|
|
case 339:
|
||
|
|
var $1516=((($1513)-($nb_0))|0);
|
||
|
|
HEAP32[((52)>>2)]=$1516;
|
||
|
|
var $1517=HEAP32[((64)>>2)];
|
||
|
|
var $1518=$1517;
|
||
|
|
var $1519=(($1518+$nb_0)|0);
|
||
|
|
var $1520=$1519;
|
||
|
|
HEAP32[((64)>>2)]=$1520;
|
||
|
|
var $1521=$1516|1;
|
||
|
|
var $_sum_i34=((($nb_0)+(4))|0);
|
||
|
|
var $1522=(($1518+$_sum_i34)|0);
|
||
|
|
var $1523=$1522;
|
||
|
|
HEAP32[(($1523)>>2)]=$1521;
|
||
|
|
var $1524=$nb_0|3;
|
||
|
|
var $1525=(($1517+4)|0);
|
||
|
|
HEAP32[(($1525)>>2)]=$1524;
|
||
|
|
var $1526=(($1517+8)|0);
|
||
|
|
var $1527=$1526;
|
||
|
|
var $mem_0=$1527;label=341;break;
|
||
|
|
case 340:
|
||
|
|
var $1528=___errno_location();
|
||
|
|
HEAP32[(($1528)>>2)]=12;
|
||
|
|
var $mem_0=0;label=341;break;
|
||
|
|
case 341:
|
||
|
|
var $mem_0;
|
||
|
|
return $mem_0;
|
||
|
|
default: assert(0, "bad label: " + label);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
Module["_malloc"] = _malloc;
|
||
|
|
|
||
|
|
function _free($mem){
|
||
|
|
var label=0;
|
||
|
|
|
||
|
|
label = 1;
|
||
|
|
while(1)switch(label){
|
||
|
|
case 1:
|
||
|
|
var $1=($mem|0)==0;
|
||
|
|
if($1){label=140;break;}else{label=2;break;}
|
||
|
|
case 2:
|
||
|
|
var $3=((($mem)-(8))|0);
|
||
|
|
var $4=$3;
|
||
|
|
var $5=HEAP32[((56)>>2)];
|
||
|
|
var $6=($3>>>0)<($5>>>0);
|
||
|
|
if($6){label=139;break;}else{label=3;break;}
|
||
|
|
case 3:
|
||
|
|
var $8=((($mem)-(4))|0);
|
||
|
|
var $9=$8;
|
||
|
|
var $10=HEAP32[(($9)>>2)];
|
||
|
|
var $11=$10&3;
|
||
|
|
var $12=($11|0)==1;
|
||
|
|
if($12){label=139;break;}else{label=4;break;}
|
||
|
|
case 4:
|
||
|
|
var $14=$10&-8;
|
||
|
|
var $_sum=((($14)-(8))|0);
|
||
|
|
var $15=(($mem+$_sum)|0);
|
||
|
|
var $16=$15;
|
||
|
|
var $17=$10&1;
|
||
|
|
var $18=($17|0)==0;
|
||
|
|
if($18){label=5;break;}else{var $p_0=$4;var $psize_0=$14;label=56;break;}
|
||
|
|
case 5:
|
||
|
|
var $20=$3;
|
||
|
|
var $21=HEAP32[(($20)>>2)];
|
||
|
|
var $22=($11|0)==0;
|
||
|
|
if($22){label=140;break;}else{label=6;break;}
|
||
|
|
case 6:
|
||
|
|
var $_sum3=(((-8)-($21))|0);
|
||
|
|
var $24=(($mem+$_sum3)|0);
|
||
|
|
var $25=$24;
|
||
|
|
var $26=((($21)+($14))|0);
|
||
|
|
var $27=($24>>>0)<($5>>>0);
|
||
|
|
if($27){label=139;break;}else{label=7;break;}
|
||
|
|
case 7:
|
||
|
|
var $29=HEAP32[((60)>>2)];
|
||
|
|
var $30=($25|0)==($29|0);
|
||
|
|
if($30){label=54;break;}else{label=8;break;}
|
||
|
|
case 8:
|
||
|
|
var $32=$21>>>3;
|
||
|
|
var $33=($21>>>0)<256;
|
||
|
|
if($33){label=9;break;}else{label=21;break;}
|
||
|
|
case 9:
|
||
|
|
var $_sum47=((($_sum3)+(8))|0);
|
||
|
|
var $35=(($mem+$_sum47)|0);
|
||
|
|
var $36=$35;
|
||
|
|
var $37=HEAP32[(($36)>>2)];
|
||
|
|
var $_sum48=((($_sum3)+(12))|0);
|
||
|
|
var $38=(($mem+$_sum48)|0);
|
||
|
|
var $39=$38;
|
||
|
|
var $40=HEAP32[(($39)>>2)];
|
||
|
|
var $41=$32<<1;
|
||
|
|
var $42=((80+($41<<2))|0);
|
||
|
|
var $43=$42;
|
||
|
|
var $44=($37|0)==($43|0);
|
||
|
|
if($44){label=12;break;}else{label=10;break;}
|
||
|
|
case 10:
|
||
|
|
var $46=$37;
|
||
|
|
var $47=($46>>>0)<($5>>>0);
|
||
|
|
if($47){label=20;break;}else{label=11;break;}
|
||
|
|
case 11:
|
||
|
|
var $49=(($37+12)|0);
|
||
|
|
var $50=HEAP32[(($49)>>2)];
|
||
|
|
var $51=($50|0)==($25|0);
|
||
|
|
if($51){label=12;break;}else{label=20;break;}
|
||
|
|
case 12:
|
||
|
|
var $52=($40|0)==($37|0);
|
||
|
|
if($52){label=13;break;}else{label=14;break;}
|
||
|
|
case 13:
|
||
|
|
var $54=1<<$32;
|
||
|
|
var $55=$54^-1;
|
||
|
|
var $56=HEAP32[((40)>>2)];
|
||
|
|
var $57=$56&$55;
|
||
|
|
HEAP32[((40)>>2)]=$57;
|
||
|
|
var $p_0=$25;var $psize_0=$26;label=56;break;
|
||
|
|
case 14:
|
||
|
|
var $59=($40|0)==($43|0);
|
||
|
|
if($59){label=15;break;}else{label=16;break;}
|
||
|
|
case 15:
|
||
|
|
var $_pre82=(($40+8)|0);
|
||
|
|
var $_pre_phi83=$_pre82;label=18;break;
|
||
|
|
case 16:
|
||
|
|
var $61=$40;
|
||
|
|
var $62=($61>>>0)<($5>>>0);
|
||
|
|
if($62){label=19;break;}else{label=17;break;}
|
||
|
|
case 17:
|
||
|
|
var $64=(($40+8)|0);
|
||
|
|
var $65=HEAP32[(($64)>>2)];
|
||
|
|
var $66=($65|0)==($25|0);
|
||
|
|
if($66){var $_pre_phi83=$64;label=18;break;}else{label=19;break;}
|
||
|
|
case 18:
|
||
|
|
var $_pre_phi83;
|
||
|
|
var $67=(($37+12)|0);
|
||
|
|
HEAP32[(($67)>>2)]=$40;
|
||
|
|
HEAP32[(($_pre_phi83)>>2)]=$37;
|
||
|
|
var $p_0=$25;var $psize_0=$26;label=56;break;
|
||
|
|
case 19:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 20:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 21:
|
||
|
|
var $69=$24;
|
||
|
|
var $_sum37=((($_sum3)+(24))|0);
|
||
|
|
var $70=(($mem+$_sum37)|0);
|
||
|
|
var $71=$70;
|
||
|
|
var $72=HEAP32[(($71)>>2)];
|
||
|
|
var $_sum38=((($_sum3)+(12))|0);
|
||
|
|
var $73=(($mem+$_sum38)|0);
|
||
|
|
var $74=$73;
|
||
|
|
var $75=HEAP32[(($74)>>2)];
|
||
|
|
var $76=($75|0)==($69|0);
|
||
|
|
if($76){label=27;break;}else{label=22;break;}
|
||
|
|
case 22:
|
||
|
|
var $_sum44=((($_sum3)+(8))|0);
|
||
|
|
var $78=(($mem+$_sum44)|0);
|
||
|
|
var $79=$78;
|
||
|
|
var $80=HEAP32[(($79)>>2)];
|
||
|
|
var $81=$80;
|
||
|
|
var $82=($81>>>0)<($5>>>0);
|
||
|
|
if($82){label=26;break;}else{label=23;break;}
|
||
|
|
case 23:
|
||
|
|
var $84=(($80+12)|0);
|
||
|
|
var $85=HEAP32[(($84)>>2)];
|
||
|
|
var $86=($85|0)==($69|0);
|
||
|
|
if($86){label=24;break;}else{label=26;break;}
|
||
|
|
case 24:
|
||
|
|
var $88=(($75+8)|0);
|
||
|
|
var $89=HEAP32[(($88)>>2)];
|
||
|
|
var $90=($89|0)==($69|0);
|
||
|
|
if($90){label=25;break;}else{label=26;break;}
|
||
|
|
case 25:
|
||
|
|
HEAP32[(($84)>>2)]=$75;
|
||
|
|
HEAP32[(($88)>>2)]=$80;
|
||
|
|
var $R_1=$75;label=34;break;
|
||
|
|
case 26:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 27:
|
||
|
|
var $_sum40=((($_sum3)+(20))|0);
|
||
|
|
var $93=(($mem+$_sum40)|0);
|
||
|
|
var $94=$93;
|
||
|
|
var $95=HEAP32[(($94)>>2)];
|
||
|
|
var $96=($95|0)==0;
|
||
|
|
if($96){label=28;break;}else{var $R_0=$95;var $RP_0=$94;label=29;break;}
|
||
|
|
case 28:
|
||
|
|
var $_sum39=((($_sum3)+(16))|0);
|
||
|
|
var $98=(($mem+$_sum39)|0);
|
||
|
|
var $99=$98;
|
||
|
|
var $100=HEAP32[(($99)>>2)];
|
||
|
|
var $101=($100|0)==0;
|
||
|
|
if($101){var $R_1=0;label=34;break;}else{var $R_0=$100;var $RP_0=$99;label=29;break;}
|
||
|
|
case 29:
|
||
|
|
var $RP_0;
|
||
|
|
var $R_0;
|
||
|
|
var $102=(($R_0+20)|0);
|
||
|
|
var $103=HEAP32[(($102)>>2)];
|
||
|
|
var $104=($103|0)==0;
|
||
|
|
if($104){label=30;break;}else{var $R_0=$103;var $RP_0=$102;label=29;break;}
|
||
|
|
case 30:
|
||
|
|
var $106=(($R_0+16)|0);
|
||
|
|
var $107=HEAP32[(($106)>>2)];
|
||
|
|
var $108=($107|0)==0;
|
||
|
|
if($108){label=31;break;}else{var $R_0=$107;var $RP_0=$106;label=29;break;}
|
||
|
|
case 31:
|
||
|
|
var $110=$RP_0;
|
||
|
|
var $111=($110>>>0)<($5>>>0);
|
||
|
|
if($111){label=33;break;}else{label=32;break;}
|
||
|
|
case 32:
|
||
|
|
HEAP32[(($RP_0)>>2)]=0;
|
||
|
|
var $R_1=$R_0;label=34;break;
|
||
|
|
case 33:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 34:
|
||
|
|
var $R_1;
|
||
|
|
var $115=($72|0)==0;
|
||
|
|
if($115){var $p_0=$25;var $psize_0=$26;label=56;break;}else{label=35;break;}
|
||
|
|
case 35:
|
||
|
|
var $_sum41=((($_sum3)+(28))|0);
|
||
|
|
var $117=(($mem+$_sum41)|0);
|
||
|
|
var $118=$117;
|
||
|
|
var $119=HEAP32[(($118)>>2)];
|
||
|
|
var $120=((344+($119<<2))|0);
|
||
|
|
var $121=HEAP32[(($120)>>2)];
|
||
|
|
var $122=($69|0)==($121|0);
|
||
|
|
if($122){label=36;break;}else{label=38;break;}
|
||
|
|
case 36:
|
||
|
|
HEAP32[(($120)>>2)]=$R_1;
|
||
|
|
var $cond=($R_1|0)==0;
|
||
|
|
if($cond){label=37;break;}else{label=44;break;}
|
||
|
|
case 37:
|
||
|
|
var $124=HEAP32[(($118)>>2)];
|
||
|
|
var $125=1<<$124;
|
||
|
|
var $126=$125^-1;
|
||
|
|
var $127=HEAP32[((44)>>2)];
|
||
|
|
var $128=$127&$126;
|
||
|
|
HEAP32[((44)>>2)]=$128;
|
||
|
|
var $p_0=$25;var $psize_0=$26;label=56;break;
|
||
|
|
case 38:
|
||
|
|
var $130=$72;
|
||
|
|
var $131=HEAP32[((56)>>2)];
|
||
|
|
var $132=($130>>>0)<($131>>>0);
|
||
|
|
if($132){label=42;break;}else{label=39;break;}
|
||
|
|
case 39:
|
||
|
|
var $134=(($72+16)|0);
|
||
|
|
var $135=HEAP32[(($134)>>2)];
|
||
|
|
var $136=($135|0)==($69|0);
|
||
|
|
if($136){label=40;break;}else{label=41;break;}
|
||
|
|
case 40:
|
||
|
|
HEAP32[(($134)>>2)]=$R_1;
|
||
|
|
label=43;break;
|
||
|
|
case 41:
|
||
|
|
var $139=(($72+20)|0);
|
||
|
|
HEAP32[(($139)>>2)]=$R_1;
|
||
|
|
label=43;break;
|
||
|
|
case 42:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 43:
|
||
|
|
var $142=($R_1|0)==0;
|
||
|
|
if($142){var $p_0=$25;var $psize_0=$26;label=56;break;}else{label=44;break;}
|
||
|
|
case 44:
|
||
|
|
var $144=$R_1;
|
||
|
|
var $145=HEAP32[((56)>>2)];
|
||
|
|
var $146=($144>>>0)<($145>>>0);
|
||
|
|
if($146){label=53;break;}else{label=45;break;}
|
||
|
|
case 45:
|
||
|
|
var $148=(($R_1+24)|0);
|
||
|
|
HEAP32[(($148)>>2)]=$72;
|
||
|
|
var $_sum42=((($_sum3)+(16))|0);
|
||
|
|
var $149=(($mem+$_sum42)|0);
|
||
|
|
var $150=$149;
|
||
|
|
var $151=HEAP32[(($150)>>2)];
|
||
|
|
var $152=($151|0)==0;
|
||
|
|
if($152){label=49;break;}else{label=46;break;}
|
||
|
|
case 46:
|
||
|
|
var $154=$151;
|
||
|
|
var $155=HEAP32[((56)>>2)];
|
||
|
|
var $156=($154>>>0)<($155>>>0);
|
||
|
|
if($156){label=48;break;}else{label=47;break;}
|
||
|
|
case 47:
|
||
|
|
var $158=(($R_1+16)|0);
|
||
|
|
HEAP32[(($158)>>2)]=$151;
|
||
|
|
var $159=(($151+24)|0);
|
||
|
|
HEAP32[(($159)>>2)]=$R_1;
|
||
|
|
label=49;break;
|
||
|
|
case 48:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 49:
|
||
|
|
var $_sum43=((($_sum3)+(20))|0);
|
||
|
|
var $162=(($mem+$_sum43)|0);
|
||
|
|
var $163=$162;
|
||
|
|
var $164=HEAP32[(($163)>>2)];
|
||
|
|
var $165=($164|0)==0;
|
||
|
|
if($165){var $p_0=$25;var $psize_0=$26;label=56;break;}else{label=50;break;}
|
||
|
|
case 50:
|
||
|
|
var $167=$164;
|
||
|
|
var $168=HEAP32[((56)>>2)];
|
||
|
|
var $169=($167>>>0)<($168>>>0);
|
||
|
|
if($169){label=52;break;}else{label=51;break;}
|
||
|
|
case 51:
|
||
|
|
var $171=(($R_1+20)|0);
|
||
|
|
HEAP32[(($171)>>2)]=$164;
|
||
|
|
var $172=(($164+24)|0);
|
||
|
|
HEAP32[(($172)>>2)]=$R_1;
|
||
|
|
var $p_0=$25;var $psize_0=$26;label=56;break;
|
||
|
|
case 52:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 53:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 54:
|
||
|
|
var $_sum4=((($14)-(4))|0);
|
||
|
|
var $176=(($mem+$_sum4)|0);
|
||
|
|
var $177=$176;
|
||
|
|
var $178=HEAP32[(($177)>>2)];
|
||
|
|
var $179=$178&3;
|
||
|
|
var $180=($179|0)==3;
|
||
|
|
if($180){label=55;break;}else{var $p_0=$25;var $psize_0=$26;label=56;break;}
|
||
|
|
case 55:
|
||
|
|
HEAP32[((48)>>2)]=$26;
|
||
|
|
var $182=HEAP32[(($177)>>2)];
|
||
|
|
var $183=$182&-2;
|
||
|
|
HEAP32[(($177)>>2)]=$183;
|
||
|
|
var $184=$26|1;
|
||
|
|
var $_sum35=((($_sum3)+(4))|0);
|
||
|
|
var $185=(($mem+$_sum35)|0);
|
||
|
|
var $186=$185;
|
||
|
|
HEAP32[(($186)>>2)]=$184;
|
||
|
|
var $187=$15;
|
||
|
|
HEAP32[(($187)>>2)]=$26;
|
||
|
|
label=140;break;
|
||
|
|
case 56:
|
||
|
|
var $psize_0;
|
||
|
|
var $p_0;
|
||
|
|
var $189=$p_0;
|
||
|
|
var $190=($189>>>0)<($15>>>0);
|
||
|
|
if($190){label=57;break;}else{label=139;break;}
|
||
|
|
case 57:
|
||
|
|
var $_sum34=((($14)-(4))|0);
|
||
|
|
var $192=(($mem+$_sum34)|0);
|
||
|
|
var $193=$192;
|
||
|
|
var $194=HEAP32[(($193)>>2)];
|
||
|
|
var $195=$194&1;
|
||
|
|
var $phitmp=($195|0)==0;
|
||
|
|
if($phitmp){label=139;break;}else{label=58;break;}
|
||
|
|
case 58:
|
||
|
|
var $197=$194&2;
|
||
|
|
var $198=($197|0)==0;
|
||
|
|
if($198){label=59;break;}else{label=112;break;}
|
||
|
|
case 59:
|
||
|
|
var $200=HEAP32[((64)>>2)];
|
||
|
|
var $201=($16|0)==($200|0);
|
||
|
|
if($201){label=60;break;}else{label=62;break;}
|
||
|
|
case 60:
|
||
|
|
var $203=HEAP32[((52)>>2)];
|
||
|
|
var $204=((($203)+($psize_0))|0);
|
||
|
|
HEAP32[((52)>>2)]=$204;
|
||
|
|
HEAP32[((64)>>2)]=$p_0;
|
||
|
|
var $205=$204|1;
|
||
|
|
var $206=(($p_0+4)|0);
|
||
|
|
HEAP32[(($206)>>2)]=$205;
|
||
|
|
var $207=HEAP32[((60)>>2)];
|
||
|
|
var $208=($p_0|0)==($207|0);
|
||
|
|
if($208){label=61;break;}else{label=140;break;}
|
||
|
|
case 61:
|
||
|
|
HEAP32[((60)>>2)]=0;
|
||
|
|
HEAP32[((48)>>2)]=0;
|
||
|
|
label=140;break;
|
||
|
|
case 62:
|
||
|
|
var $211=HEAP32[((60)>>2)];
|
||
|
|
var $212=($16|0)==($211|0);
|
||
|
|
if($212){label=63;break;}else{label=64;break;}
|
||
|
|
case 63:
|
||
|
|
var $214=HEAP32[((48)>>2)];
|
||
|
|
var $215=((($214)+($psize_0))|0);
|
||
|
|
HEAP32[((48)>>2)]=$215;
|
||
|
|
HEAP32[((60)>>2)]=$p_0;
|
||
|
|
var $216=$215|1;
|
||
|
|
var $217=(($p_0+4)|0);
|
||
|
|
HEAP32[(($217)>>2)]=$216;
|
||
|
|
var $218=(($189+$215)|0);
|
||
|
|
var $219=$218;
|
||
|
|
HEAP32[(($219)>>2)]=$215;
|
||
|
|
label=140;break;
|
||
|
|
case 64:
|
||
|
|
var $221=$194&-8;
|
||
|
|
var $222=((($221)+($psize_0))|0);
|
||
|
|
var $223=$194>>>3;
|
||
|
|
var $224=($194>>>0)<256;
|
||
|
|
if($224){label=65;break;}else{label=77;break;}
|
||
|
|
case 65:
|
||
|
|
var $226=(($mem+$14)|0);
|
||
|
|
var $227=$226;
|
||
|
|
var $228=HEAP32[(($227)>>2)];
|
||
|
|
var $_sum2829=$14|4;
|
||
|
|
var $229=(($mem+$_sum2829)|0);
|
||
|
|
var $230=$229;
|
||
|
|
var $231=HEAP32[(($230)>>2)];
|
||
|
|
var $232=$223<<1;
|
||
|
|
var $233=((80+($232<<2))|0);
|
||
|
|
var $234=$233;
|
||
|
|
var $235=($228|0)==($234|0);
|
||
|
|
if($235){label=68;break;}else{label=66;break;}
|
||
|
|
case 66:
|
||
|
|
var $237=$228;
|
||
|
|
var $238=HEAP32[((56)>>2)];
|
||
|
|
var $239=($237>>>0)<($238>>>0);
|
||
|
|
if($239){label=76;break;}else{label=67;break;}
|
||
|
|
case 67:
|
||
|
|
var $241=(($228+12)|0);
|
||
|
|
var $242=HEAP32[(($241)>>2)];
|
||
|
|
var $243=($242|0)==($16|0);
|
||
|
|
if($243){label=68;break;}else{label=76;break;}
|
||
|
|
case 68:
|
||
|
|
var $244=($231|0)==($228|0);
|
||
|
|
if($244){label=69;break;}else{label=70;break;}
|
||
|
|
case 69:
|
||
|
|
var $246=1<<$223;
|
||
|
|
var $247=$246^-1;
|
||
|
|
var $248=HEAP32[((40)>>2)];
|
||
|
|
var $249=$248&$247;
|
||
|
|
HEAP32[((40)>>2)]=$249;
|
||
|
|
label=110;break;
|
||
|
|
case 70:
|
||
|
|
var $251=($231|0)==($234|0);
|
||
|
|
if($251){label=71;break;}else{label=72;break;}
|
||
|
|
case 71:
|
||
|
|
var $_pre80=(($231+8)|0);
|
||
|
|
var $_pre_phi81=$_pre80;label=74;break;
|
||
|
|
case 72:
|
||
|
|
var $253=$231;
|
||
|
|
var $254=HEAP32[((56)>>2)];
|
||
|
|
var $255=($253>>>0)<($254>>>0);
|
||
|
|
if($255){label=75;break;}else{label=73;break;}
|
||
|
|
case 73:
|
||
|
|
var $257=(($231+8)|0);
|
||
|
|
var $258=HEAP32[(($257)>>2)];
|
||
|
|
var $259=($258|0)==($16|0);
|
||
|
|
if($259){var $_pre_phi81=$257;label=74;break;}else{label=75;break;}
|
||
|
|
case 74:
|
||
|
|
var $_pre_phi81;
|
||
|
|
var $260=(($228+12)|0);
|
||
|
|
HEAP32[(($260)>>2)]=$231;
|
||
|
|
HEAP32[(($_pre_phi81)>>2)]=$228;
|
||
|
|
label=110;break;
|
||
|
|
case 75:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 76:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 77:
|
||
|
|
var $262=$15;
|
||
|
|
var $_sum6=((($14)+(16))|0);
|
||
|
|
var $263=(($mem+$_sum6)|0);
|
||
|
|
var $264=$263;
|
||
|
|
var $265=HEAP32[(($264)>>2)];
|
||
|
|
var $_sum78=$14|4;
|
||
|
|
var $266=(($mem+$_sum78)|0);
|
||
|
|
var $267=$266;
|
||
|
|
var $268=HEAP32[(($267)>>2)];
|
||
|
|
var $269=($268|0)==($262|0);
|
||
|
|
if($269){label=83;break;}else{label=78;break;}
|
||
|
|
case 78:
|
||
|
|
var $271=(($mem+$14)|0);
|
||
|
|
var $272=$271;
|
||
|
|
var $273=HEAP32[(($272)>>2)];
|
||
|
|
var $274=$273;
|
||
|
|
var $275=HEAP32[((56)>>2)];
|
||
|
|
var $276=($274>>>0)<($275>>>0);
|
||
|
|
if($276){label=82;break;}else{label=79;break;}
|
||
|
|
case 79:
|
||
|
|
var $278=(($273+12)|0);
|
||
|
|
var $279=HEAP32[(($278)>>2)];
|
||
|
|
var $280=($279|0)==($262|0);
|
||
|
|
if($280){label=80;break;}else{label=82;break;}
|
||
|
|
case 80:
|
||
|
|
var $282=(($268+8)|0);
|
||
|
|
var $283=HEAP32[(($282)>>2)];
|
||
|
|
var $284=($283|0)==($262|0);
|
||
|
|
if($284){label=81;break;}else{label=82;break;}
|
||
|
|
case 81:
|
||
|
|
HEAP32[(($278)>>2)]=$268;
|
||
|
|
HEAP32[(($282)>>2)]=$273;
|
||
|
|
var $R7_1=$268;label=90;break;
|
||
|
|
case 82:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 83:
|
||
|
|
var $_sum10=((($14)+(12))|0);
|
||
|
|
var $287=(($mem+$_sum10)|0);
|
||
|
|
var $288=$287;
|
||
|
|
var $289=HEAP32[(($288)>>2)];
|
||
|
|
var $290=($289|0)==0;
|
||
|
|
if($290){label=84;break;}else{var $R7_0=$289;var $RP9_0=$288;label=85;break;}
|
||
|
|
case 84:
|
||
|
|
var $_sum9=((($14)+(8))|0);
|
||
|
|
var $292=(($mem+$_sum9)|0);
|
||
|
|
var $293=$292;
|
||
|
|
var $294=HEAP32[(($293)>>2)];
|
||
|
|
var $295=($294|0)==0;
|
||
|
|
if($295){var $R7_1=0;label=90;break;}else{var $R7_0=$294;var $RP9_0=$293;label=85;break;}
|
||
|
|
case 85:
|
||
|
|
var $RP9_0;
|
||
|
|
var $R7_0;
|
||
|
|
var $296=(($R7_0+20)|0);
|
||
|
|
var $297=HEAP32[(($296)>>2)];
|
||
|
|
var $298=($297|0)==0;
|
||
|
|
if($298){label=86;break;}else{var $R7_0=$297;var $RP9_0=$296;label=85;break;}
|
||
|
|
case 86:
|
||
|
|
var $300=(($R7_0+16)|0);
|
||
|
|
var $301=HEAP32[(($300)>>2)];
|
||
|
|
var $302=($301|0)==0;
|
||
|
|
if($302){label=87;break;}else{var $R7_0=$301;var $RP9_0=$300;label=85;break;}
|
||
|
|
case 87:
|
||
|
|
var $304=$RP9_0;
|
||
|
|
var $305=HEAP32[((56)>>2)];
|
||
|
|
var $306=($304>>>0)<($305>>>0);
|
||
|
|
if($306){label=89;break;}else{label=88;break;}
|
||
|
|
case 88:
|
||
|
|
HEAP32[(($RP9_0)>>2)]=0;
|
||
|
|
var $R7_1=$R7_0;label=90;break;
|
||
|
|
case 89:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 90:
|
||
|
|
var $R7_1;
|
||
|
|
var $310=($265|0)==0;
|
||
|
|
if($310){label=110;break;}else{label=91;break;}
|
||
|
|
case 91:
|
||
|
|
var $_sum21=((($14)+(20))|0);
|
||
|
|
var $312=(($mem+$_sum21)|0);
|
||
|
|
var $313=$312;
|
||
|
|
var $314=HEAP32[(($313)>>2)];
|
||
|
|
var $315=((344+($314<<2))|0);
|
||
|
|
var $316=HEAP32[(($315)>>2)];
|
||
|
|
var $317=($262|0)==($316|0);
|
||
|
|
if($317){label=92;break;}else{label=94;break;}
|
||
|
|
case 92:
|
||
|
|
HEAP32[(($315)>>2)]=$R7_1;
|
||
|
|
var $cond69=($R7_1|0)==0;
|
||
|
|
if($cond69){label=93;break;}else{label=100;break;}
|
||
|
|
case 93:
|
||
|
|
var $319=HEAP32[(($313)>>2)];
|
||
|
|
var $320=1<<$319;
|
||
|
|
var $321=$320^-1;
|
||
|
|
var $322=HEAP32[((44)>>2)];
|
||
|
|
var $323=$322&$321;
|
||
|
|
HEAP32[((44)>>2)]=$323;
|
||
|
|
label=110;break;
|
||
|
|
case 94:
|
||
|
|
var $325=$265;
|
||
|
|
var $326=HEAP32[((56)>>2)];
|
||
|
|
var $327=($325>>>0)<($326>>>0);
|
||
|
|
if($327){label=98;break;}else{label=95;break;}
|
||
|
|
case 95:
|
||
|
|
var $329=(($265+16)|0);
|
||
|
|
var $330=HEAP32[(($329)>>2)];
|
||
|
|
var $331=($330|0)==($262|0);
|
||
|
|
if($331){label=96;break;}else{label=97;break;}
|
||
|
|
case 96:
|
||
|
|
HEAP32[(($329)>>2)]=$R7_1;
|
||
|
|
label=99;break;
|
||
|
|
case 97:
|
||
|
|
var $334=(($265+20)|0);
|
||
|
|
HEAP32[(($334)>>2)]=$R7_1;
|
||
|
|
label=99;break;
|
||
|
|
case 98:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 99:
|
||
|
|
var $337=($R7_1|0)==0;
|
||
|
|
if($337){label=110;break;}else{label=100;break;}
|
||
|
|
case 100:
|
||
|
|
var $339=$R7_1;
|
||
|
|
var $340=HEAP32[((56)>>2)];
|
||
|
|
var $341=($339>>>0)<($340>>>0);
|
||
|
|
if($341){label=109;break;}else{label=101;break;}
|
||
|
|
case 101:
|
||
|
|
var $343=(($R7_1+24)|0);
|
||
|
|
HEAP32[(($343)>>2)]=$265;
|
||
|
|
var $_sum22=((($14)+(8))|0);
|
||
|
|
var $344=(($mem+$_sum22)|0);
|
||
|
|
var $345=$344;
|
||
|
|
var $346=HEAP32[(($345)>>2)];
|
||
|
|
var $347=($346|0)==0;
|
||
|
|
if($347){label=105;break;}else{label=102;break;}
|
||
|
|
case 102:
|
||
|
|
var $349=$346;
|
||
|
|
var $350=HEAP32[((56)>>2)];
|
||
|
|
var $351=($349>>>0)<($350>>>0);
|
||
|
|
if($351){label=104;break;}else{label=103;break;}
|
||
|
|
case 103:
|
||
|
|
var $353=(($R7_1+16)|0);
|
||
|
|
HEAP32[(($353)>>2)]=$346;
|
||
|
|
var $354=(($346+24)|0);
|
||
|
|
HEAP32[(($354)>>2)]=$R7_1;
|
||
|
|
label=105;break;
|
||
|
|
case 104:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 105:
|
||
|
|
var $_sum23=((($14)+(12))|0);
|
||
|
|
var $357=(($mem+$_sum23)|0);
|
||
|
|
var $358=$357;
|
||
|
|
var $359=HEAP32[(($358)>>2)];
|
||
|
|
var $360=($359|0)==0;
|
||
|
|
if($360){label=110;break;}else{label=106;break;}
|
||
|
|
case 106:
|
||
|
|
var $362=$359;
|
||
|
|
var $363=HEAP32[((56)>>2)];
|
||
|
|
var $364=($362>>>0)<($363>>>0);
|
||
|
|
if($364){label=108;break;}else{label=107;break;}
|
||
|
|
case 107:
|
||
|
|
var $366=(($R7_1+20)|0);
|
||
|
|
HEAP32[(($366)>>2)]=$359;
|
||
|
|
var $367=(($359+24)|0);
|
||
|
|
HEAP32[(($367)>>2)]=$R7_1;
|
||
|
|
label=110;break;
|
||
|
|
case 108:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 109:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 110:
|
||
|
|
var $371=$222|1;
|
||
|
|
var $372=(($p_0+4)|0);
|
||
|
|
HEAP32[(($372)>>2)]=$371;
|
||
|
|
var $373=(($189+$222)|0);
|
||
|
|
var $374=$373;
|
||
|
|
HEAP32[(($374)>>2)]=$222;
|
||
|
|
var $375=HEAP32[((60)>>2)];
|
||
|
|
var $376=($p_0|0)==($375|0);
|
||
|
|
if($376){label=111;break;}else{var $psize_1=$222;label=113;break;}
|
||
|
|
case 111:
|
||
|
|
HEAP32[((48)>>2)]=$222;
|
||
|
|
label=140;break;
|
||
|
|
case 112:
|
||
|
|
var $379=$194&-2;
|
||
|
|
HEAP32[(($193)>>2)]=$379;
|
||
|
|
var $380=$psize_0|1;
|
||
|
|
var $381=(($p_0+4)|0);
|
||
|
|
HEAP32[(($381)>>2)]=$380;
|
||
|
|
var $382=(($189+$psize_0)|0);
|
||
|
|
var $383=$382;
|
||
|
|
HEAP32[(($383)>>2)]=$psize_0;
|
||
|
|
var $psize_1=$psize_0;label=113;break;
|
||
|
|
case 113:
|
||
|
|
var $psize_1;
|
||
|
|
var $385=$psize_1>>>3;
|
||
|
|
var $386=($psize_1>>>0)<256;
|
||
|
|
if($386){label=114;break;}else{label=119;break;}
|
||
|
|
case 114:
|
||
|
|
var $388=$385<<1;
|
||
|
|
var $389=((80+($388<<2))|0);
|
||
|
|
var $390=$389;
|
||
|
|
var $391=HEAP32[((40)>>2)];
|
||
|
|
var $392=1<<$385;
|
||
|
|
var $393=$391&$392;
|
||
|
|
var $394=($393|0)==0;
|
||
|
|
if($394){label=115;break;}else{label=116;break;}
|
||
|
|
case 115:
|
||
|
|
var $396=$391|$392;
|
||
|
|
HEAP32[((40)>>2)]=$396;
|
||
|
|
var $_sum19_pre=((($388)+(2))|0);
|
||
|
|
var $_pre=((80+($_sum19_pre<<2))|0);
|
||
|
|
var $F16_0=$390;var $_pre_phi=$_pre;label=118;break;
|
||
|
|
case 116:
|
||
|
|
var $_sum20=((($388)+(2))|0);
|
||
|
|
var $398=((80+($_sum20<<2))|0);
|
||
|
|
var $399=HEAP32[(($398)>>2)];
|
||
|
|
var $400=$399;
|
||
|
|
var $401=HEAP32[((56)>>2)];
|
||
|
|
var $402=($400>>>0)<($401>>>0);
|
||
|
|
if($402){label=117;break;}else{var $F16_0=$399;var $_pre_phi=$398;label=118;break;}
|
||
|
|
case 117:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 118:
|
||
|
|
var $_pre_phi;
|
||
|
|
var $F16_0;
|
||
|
|
HEAP32[(($_pre_phi)>>2)]=$p_0;
|
||
|
|
var $405=(($F16_0+12)|0);
|
||
|
|
HEAP32[(($405)>>2)]=$p_0;
|
||
|
|
var $406=(($p_0+8)|0);
|
||
|
|
HEAP32[(($406)>>2)]=$F16_0;
|
||
|
|
var $407=(($p_0+12)|0);
|
||
|
|
HEAP32[(($407)>>2)]=$390;
|
||
|
|
label=140;break;
|
||
|
|
case 119:
|
||
|
|
var $409=$p_0;
|
||
|
|
var $410=$psize_1>>>8;
|
||
|
|
var $411=($410|0)==0;
|
||
|
|
if($411){var $I18_0=0;label=122;break;}else{label=120;break;}
|
||
|
|
case 120:
|
||
|
|
var $413=($psize_1>>>0)>16777215;
|
||
|
|
if($413){var $I18_0=31;label=122;break;}else{label=121;break;}
|
||
|
|
case 121:
|
||
|
|
var $415=((($410)+(1048320))|0);
|
||
|
|
var $416=$415>>>16;
|
||
|
|
var $417=$416&8;
|
||
|
|
var $418=$410<<$417;
|
||
|
|
var $419=((($418)+(520192))|0);
|
||
|
|
var $420=$419>>>16;
|
||
|
|
var $421=$420&4;
|
||
|
|
var $422=$421|$417;
|
||
|
|
var $423=$418<<$421;
|
||
|
|
var $424=((($423)+(245760))|0);
|
||
|
|
var $425=$424>>>16;
|
||
|
|
var $426=$425&2;
|
||
|
|
var $427=$422|$426;
|
||
|
|
var $428=(((14)-($427))|0);
|
||
|
|
var $429=$423<<$426;
|
||
|
|
var $430=$429>>>15;
|
||
|
|
var $431=((($428)+($430))|0);
|
||
|
|
var $432=$431<<1;
|
||
|
|
var $433=((($431)+(7))|0);
|
||
|
|
var $434=$psize_1>>>($433>>>0);
|
||
|
|
var $435=$434&1;
|
||
|
|
var $436=$435|$432;
|
||
|
|
var $I18_0=$436;label=122;break;
|
||
|
|
case 122:
|
||
|
|
var $I18_0;
|
||
|
|
var $438=((344+($I18_0<<2))|0);
|
||
|
|
var $439=(($p_0+28)|0);
|
||
|
|
var $I18_0_c=$I18_0;
|
||
|
|
HEAP32[(($439)>>2)]=$I18_0_c;
|
||
|
|
var $440=(($p_0+20)|0);
|
||
|
|
HEAP32[(($440)>>2)]=0;
|
||
|
|
var $441=(($p_0+16)|0);
|
||
|
|
HEAP32[(($441)>>2)]=0;
|
||
|
|
var $442=HEAP32[((44)>>2)];
|
||
|
|
var $443=1<<$I18_0;
|
||
|
|
var $444=$442&$443;
|
||
|
|
var $445=($444|0)==0;
|
||
|
|
if($445){label=123;break;}else{label=124;break;}
|
||
|
|
case 123:
|
||
|
|
var $447=$442|$443;
|
||
|
|
HEAP32[((44)>>2)]=$447;
|
||
|
|
HEAP32[(($438)>>2)]=$409;
|
||
|
|
var $448=(($p_0+24)|0);
|
||
|
|
var $_c=$438;
|
||
|
|
HEAP32[(($448)>>2)]=$_c;
|
||
|
|
var $449=(($p_0+12)|0);
|
||
|
|
HEAP32[(($449)>>2)]=$p_0;
|
||
|
|
var $450=(($p_0+8)|0);
|
||
|
|
HEAP32[(($450)>>2)]=$p_0;
|
||
|
|
label=136;break;
|
||
|
|
case 124:
|
||
|
|
var $452=HEAP32[(($438)>>2)];
|
||
|
|
var $453=($I18_0|0)==31;
|
||
|
|
if($453){var $458=0;label=126;break;}else{label=125;break;}
|
||
|
|
case 125:
|
||
|
|
var $455=$I18_0>>>1;
|
||
|
|
var $456=(((25)-($455))|0);
|
||
|
|
var $458=$456;label=126;break;
|
||
|
|
case 126:
|
||
|
|
var $458;
|
||
|
|
var $459=(($452+4)|0);
|
||
|
|
var $460=HEAP32[(($459)>>2)];
|
||
|
|
var $461=$460&-8;
|
||
|
|
var $462=($461|0)==($psize_1|0);
|
||
|
|
if($462){var $T_0_lcssa=$452;label=133;break;}else{label=127;break;}
|
||
|
|
case 127:
|
||
|
|
var $463=$psize_1<<$458;
|
||
|
|
var $T_072=$452;var $K19_073=$463;label=129;break;
|
||
|
|
case 128:
|
||
|
|
var $465=$K19_073<<1;
|
||
|
|
var $466=(($473+4)|0);
|
||
|
|
var $467=HEAP32[(($466)>>2)];
|
||
|
|
var $468=$467&-8;
|
||
|
|
var $469=($468|0)==($psize_1|0);
|
||
|
|
if($469){var $T_0_lcssa=$473;label=133;break;}else{var $T_072=$473;var $K19_073=$465;label=129;break;}
|
||
|
|
case 129:
|
||
|
|
var $K19_073;
|
||
|
|
var $T_072;
|
||
|
|
var $471=$K19_073>>>31;
|
||
|
|
var $472=(($T_072+16+($471<<2))|0);
|
||
|
|
var $473=HEAP32[(($472)>>2)];
|
||
|
|
var $474=($473|0)==0;
|
||
|
|
if($474){label=130;break;}else{label=128;break;}
|
||
|
|
case 130:
|
||
|
|
var $476=$472;
|
||
|
|
var $477=HEAP32[((56)>>2)];
|
||
|
|
var $478=($476>>>0)<($477>>>0);
|
||
|
|
if($478){label=132;break;}else{label=131;break;}
|
||
|
|
case 131:
|
||
|
|
HEAP32[(($472)>>2)]=$409;
|
||
|
|
var $480=(($p_0+24)|0);
|
||
|
|
var $T_0_c16=$T_072;
|
||
|
|
HEAP32[(($480)>>2)]=$T_0_c16;
|
||
|
|
var $481=(($p_0+12)|0);
|
||
|
|
HEAP32[(($481)>>2)]=$p_0;
|
||
|
|
var $482=(($p_0+8)|0);
|
||
|
|
HEAP32[(($482)>>2)]=$p_0;
|
||
|
|
label=136;break;
|
||
|
|
case 132:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 133:
|
||
|
|
var $T_0_lcssa;
|
||
|
|
var $484=(($T_0_lcssa+8)|0);
|
||
|
|
var $485=HEAP32[(($484)>>2)];
|
||
|
|
var $486=$T_0_lcssa;
|
||
|
|
var $487=HEAP32[((56)>>2)];
|
||
|
|
var $488=($486>>>0)>=($487>>>0);
|
||
|
|
var $489=$485;
|
||
|
|
var $490=($489>>>0)>=($487>>>0);
|
||
|
|
var $or_cond=$488&$490;
|
||
|
|
if($or_cond){label=134;break;}else{label=135;break;}
|
||
|
|
case 134:
|
||
|
|
var $492=(($485+12)|0);
|
||
|
|
HEAP32[(($492)>>2)]=$409;
|
||
|
|
HEAP32[(($484)>>2)]=$409;
|
||
|
|
var $493=(($p_0+8)|0);
|
||
|
|
var $_c15=$485;
|
||
|
|
HEAP32[(($493)>>2)]=$_c15;
|
||
|
|
var $494=(($p_0+12)|0);
|
||
|
|
var $T_0_c=$T_0_lcssa;
|
||
|
|
HEAP32[(($494)>>2)]=$T_0_c;
|
||
|
|
var $495=(($p_0+24)|0);
|
||
|
|
HEAP32[(($495)>>2)]=0;
|
||
|
|
label=136;break;
|
||
|
|
case 135:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 136:
|
||
|
|
var $497=HEAP32[((72)>>2)];
|
||
|
|
var $498=((($497)-(1))|0);
|
||
|
|
HEAP32[((72)>>2)]=$498;
|
||
|
|
var $499=($498|0)==0;
|
||
|
|
if($499){var $sp_0_in_i=496;label=137;break;}else{label=140;break;}
|
||
|
|
case 137:
|
||
|
|
var $sp_0_in_i;
|
||
|
|
var $sp_0_i=HEAP32[(($sp_0_in_i)>>2)];
|
||
|
|
var $500=($sp_0_i|0)==0;
|
||
|
|
var $501=(($sp_0_i+8)|0);
|
||
|
|
if($500){label=138;break;}else{var $sp_0_in_i=$501;label=137;break;}
|
||
|
|
case 138:
|
||
|
|
HEAP32[((72)>>2)]=-1;
|
||
|
|
label=140;break;
|
||
|
|
case 139:
|
||
|
|
_abort();
|
||
|
|
throw "Reached an unreachable!";
|
||
|
|
case 140:
|
||
|
|
return;
|
||
|
|
default: assert(0, "bad label: " + label);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
Module["_free"] = _free;
|
||
|
|
|
||
|
|
|
||
|
|
// EMSCRIPTEN_END_FUNCS
|
||
|
|
// EMSCRIPTEN_END_FUNCS
|
||
|
|
|
||
|
|
// Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
|
||
|
|
var i64Math = null;
|
||
|
|
|
||
|
|
// === Auto-generated postamble setup entry stuff ===
|
||
|
|
|
||
|
|
if (memoryInitializer) {
|
||
|
|
function applyData(data) {
|
||
|
|
HEAPU8.set(data, STATIC_BASE);
|
||
|
|
}
|
||
|
|
if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
|
||
|
|
applyData(Module['readBinary'](memoryInitializer));
|
||
|
|
} else {
|
||
|
|
addRunDependency('memory initializer');
|
||
|
|
Browser.asyncLoad(memoryInitializer, function(data) {
|
||
|
|
applyData(data);
|
||
|
|
removeRunDependency('memory initializer');
|
||
|
|
}, function(data) {
|
||
|
|
throw 'could not load memory initializer ' + memoryInitializer;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function ExitStatus(status) {
|
||
|
|
this.name = "ExitStatus";
|
||
|
|
this.message = "Program terminated with exit(" + status + ")";
|
||
|
|
this.status = status;
|
||
|
|
};
|
||
|
|
ExitStatus.prototype = new Error();
|
||
|
|
ExitStatus.prototype.constructor = ExitStatus;
|
||
|
|
|
||
|
|
var initialStackTop;
|
||
|
|
var preloadStartTime = null;
|
||
|
|
var calledMain = false;
|
||
|
|
|
||
|
|
dependenciesFulfilled = function runCaller() {
|
||
|
|
// If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
|
||
|
|
if (!Module['calledRun'] && shouldRunNow) run();
|
||
|
|
if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
|
||
|
|
}
|
||
|
|
|
||
|
|
Module['callMain'] = Module.callMain = function callMain(args) {
|
||
|
|
assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
|
||
|
|
assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
|
||
|
|
|
||
|
|
args = args || [];
|
||
|
|
|
||
|
|
if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) {
|
||
|
|
Module.printErr('preload time: ' + (Date.now() - preloadStartTime) + ' ms');
|
||
|
|
}
|
||
|
|
|
||
|
|
ensureInitRuntime();
|
||
|
|
|
||
|
|
var argc = args.length+1;
|
||
|
|
function pad() {
|
||
|
|
for (var i = 0; i < 4-1; i++) {
|
||
|
|
argv.push(0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL) ];
|
||
|
|
pad();
|
||
|
|
for (var i = 0; i < argc-1; i = i + 1) {
|
||
|
|
argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
|
||
|
|
pad();
|
||
|
|
}
|
||
|
|
argv.push(0);
|
||
|
|
argv = allocate(argv, 'i32', ALLOC_NORMAL);
|
||
|
|
|
||
|
|
initialStackTop = STACKTOP;
|
||
|
|
|
||
|
|
try {
|
||
|
|
|
||
|
|
var ret = Module['_main'](argc, argv, 0);
|
||
|
|
|
||
|
|
|
||
|
|
// if we're not running an evented main loop, it's time to exit
|
||
|
|
if (!Module['noExitRuntime']) {
|
||
|
|
exit(ret);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch(e) {
|
||
|
|
if (e instanceof ExitStatus) {
|
||
|
|
// exit() throws this once it's done to make sure execution
|
||
|
|
// has been stopped completely
|
||
|
|
return;
|
||
|
|
} else if (e == 'SimulateInfiniteLoop') {
|
||
|
|
// running an evented main loop, don't immediately exit
|
||
|
|
Module['noExitRuntime'] = true;
|
||
|
|
return;
|
||
|
|
} else {
|
||
|
|
if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
} finally {
|
||
|
|
calledMain = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
function run(args) {
|
||
|
|
args = args || Module['arguments'];
|
||
|
|
|
||
|
|
if (preloadStartTime === null) preloadStartTime = Date.now();
|
||
|
|
|
||
|
|
if (runDependencies > 0) {
|
||
|
|
Module.printErr('run() called, but dependencies remain, so not running');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
preRun();
|
||
|
|
|
||
|
|
if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
|
||
|
|
if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
|
||
|
|
|
||
|
|
function doRun() {
|
||
|
|
if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
|
||
|
|
Module['calledRun'] = true;
|
||
|
|
|
||
|
|
ensureInitRuntime();
|
||
|
|
|
||
|
|
preMain();
|
||
|
|
|
||
|
|
if (Module['_main'] && shouldRunNow) {
|
||
|
|
Module['callMain'](args);
|
||
|
|
}
|
||
|
|
|
||
|
|
postRun();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Module['setStatus']) {
|
||
|
|
Module['setStatus']('Running...');
|
||
|
|
setTimeout(function() {
|
||
|
|
setTimeout(function() {
|
||
|
|
Module['setStatus']('');
|
||
|
|
}, 1);
|
||
|
|
if (!ABORT) doRun();
|
||
|
|
}, 1);
|
||
|
|
} else {
|
||
|
|
doRun();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Module['run'] = Module.run = run;
|
||
|
|
|
||
|
|
function exit(status) {
|
||
|
|
ABORT = true;
|
||
|
|
EXITSTATUS = status;
|
||
|
|
STACKTOP = initialStackTop;
|
||
|
|
|
||
|
|
// exit the runtime
|
||
|
|
exitRuntime();
|
||
|
|
|
||
|
|
// TODO We should handle this differently based on environment.
|
||
|
|
// In the browser, the best we can do is throw an exception
|
||
|
|
// to halt execution, but in node we could process.exit and
|
||
|
|
// I'd imagine SM shell would have something equivalent.
|
||
|
|
// This would let us set a proper exit status (which
|
||
|
|
// would be great for checking test exit statuses).
|
||
|
|
// https://github.com/kripken/emscripten/issues/1371
|
||
|
|
|
||
|
|
// throw an exception to halt the current execution
|
||
|
|
throw new ExitStatus(status);
|
||
|
|
}
|
||
|
|
Module['exit'] = Module.exit = exit;
|
||
|
|
|
||
|
|
function abort(text) {
|
||
|
|
if (text) {
|
||
|
|
Module.print(text);
|
||
|
|
Module.printErr(text);
|
||
|
|
}
|
||
|
|
|
||
|
|
ABORT = true;
|
||
|
|
EXITSTATUS = 1;
|
||
|
|
|
||
|
|
throw 'abort() at ' + stackTrace();
|
||
|
|
}
|
||
|
|
Module['abort'] = Module.abort = abort;
|
||
|
|
|
||
|
|
// {{PRE_RUN_ADDITIONS}}
|
||
|
|
|
||
|
|
if (Module['preInit']) {
|
||
|
|
if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
|
||
|
|
while (Module['preInit'].length > 0) {
|
||
|
|
Module['preInit'].pop()();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// shouldRunNow refers to calling main(), not run().
|
||
|
|
var shouldRunNow = true;
|
||
|
|
if (Module['noInitialRun']) {
|
||
|
|
shouldRunNow = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
run();
|
||
|
|
|
||
|
|
// {{POST_RUN_ADDITIONS}}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// {{MODULE_ADDITIONS}}
|