LiquidFun.js
Quick experiment with LiquidFun from google.github.io/liquidfun/
Exports as a 60 FPS GIF of the same duration as the simulation time.
Log in to post a comment.
// LL 2021
// Using LiquidFun.js
const simulate_seconds = 2; // min=0 max=10 step=.01
const volume = 10; // min=0 max=20 step=0.1
const draw_style = 0; // min=0 max=3 step=1 (Circles,Trace,Contour,Filled contour)
const precision = 500; // min=10 max=1500 step=1
if (draw_style==1) Canvas.setpenopacity(.02);
const turtle = new Turtle();
function walk(i, t) {
if (i==0 && (t==0 || t==1)) {
const gravity = new b2Vec2(0, -10);
world = new b2World(gravity);
test = new TestImpulse;
done_iterations = 0;
}
if (i==0) contour_i = 0;
if (done_iterations < simulate_seconds * 60 * t) {
world.Step(timeStep, velocityIterations, positionIterations);
done_iterations++;
if (draw_style==1) draw();
return true;
}
if (draw_style < 2) {
draw();
return false;
}
return contour(contour_i++, getWater);
}
// p: 2D point in -100 to 100 range
function getWater(in_p2) {
for (var j = 0, jcount = world.particleSystems.length; j < jcount; j++) {
var particles = world.particleSystems[j].GetPositionBuffer();
const r = 1.5;
for (var i = 0, icount = particles.length; i < icount; i += 2) {
const x = particles[i] * 48 - 48;
const y = -particles[i+1] * 48 + 48;
const dist = Math.hypot(in_p2[0] - x, in_p2[1] - y);
if (dist < r) return 2 + (draw_style == 3 ? (Math.random() > 0.5) : 0);
}
}
return 0;
}
function draw() {
for (var i = 0, max = world.bodies.length; i < max; i++) {
var body = world.bodies[i];
var maxFixtures = body.fixtures.length;
var transform = body.GetTransform();
for (var j = 0; j < maxFixtures; j++) {
var fixture = body.fixtures[j];
//fixture.shape.draw(transform);
}
}
for (var i = 0, max = world.particleSystems.length; i < max; i++) {
drawParticleSystem(world.particleSystems[i]);
}
};
function drawParticleSystem(system) {
var particles = system.GetPositionBuffer();
var maxParticles = particles.length;
const r = 1;
for (var i = 0; i < maxParticles; i += 2) {
const x = particles[i] * 48 - 48;
const y = -particles[i+1] * 48 + 48;
turtle.jump(x, y-r);
turtle.circle(r, 0, 10);
}
}
var world = null;
var camera;
var timeStep = 1.0 / 60.0;
var velocityIterations = 8;
var positionIterations = 3;
function TestImpulse() {
this.boxLeft = -2;
this.boxRight = 2;
this.boxBottom = -2;
this.boxTop = 40;
var bd = new b2BodyDef;
var ground = world.CreateBody(bd);
var shape = new b2ChainShape;
shape.vertices.push(new b2Vec2(this.boxLeft, this.boxBottom));
shape.vertices.push(new b2Vec2(this.boxRight, this.boxBottom));
shape.vertices.push(new b2Vec2(this.boxRight,this.boxTop));
shape.vertices.push(new b2Vec2(this.boxLeft, this.boxTop));
shape.CreateLoop();
ground.CreateFixtureFromShape(shape, 0.0);
var psd = new b2ParticleSystemDef();
psd.radius = 0.025;
psd.damping = 0.2;
this.particleSystem = world.CreateParticleSystem(psd);
shape = new b2PolygonShape ;
shape.SetAsBoxXYCenterAngle(0.2, volume, new b2Vec2(0.0, volume + .01), 0);
var pd = new b2ParticleGroupDef;
pd.shape = shape;
this.group = this.particleSystem.CreateParticleGroup(pd);
}
//////////////////////////////////////////
// Contour utility by Lionel Lemarie 2021
// https://turtletoy.net/turtle/765d77abf4
function contour(i, zFunc) {
if (i == 0) { cache = {}; }
const r = 100 / precision;
if (i >= precision*precision) return false;
const xx = i % precision;
const yy = (i / precision) | 0;
const ci00 = (xx-1) + (yy-1) * precision;
const ci01 = (xx-0) + (yy-1) * precision;
const ci10 = (xx-1) + (yy-0) * precision;
const ci11 = (xx-0) + (yy-0) * precision;
const x0 = ((xx-1) / precision - 0.5) * 200;
const y0 = ((yy-1) / precision - 0.5) * 200;
const x1 = ((xx-0) / precision - 0.5) * 200;
const y1 = ((yy-0) / precision - 0.5) * 200;
const z00 = cache[ci00], z01 = cache[ci01], z10 = cache[ci10];
const z11 = cache[ci11] = zFunc([x1, y1]);
var lines = [];
// A bit like marching cubes
if (z00 != z01 && z00 != z10 && z00 != z11) lines = [[[1,0],[0,1]],[[0,1],[1,2]],[[1,2],[2,1]],[[2,1],[1,0]]];
if (z00 == z01 && z00 == z10 && z00 != z11) lines = [[[2,1],[1,2]]];
if (z00 == z01 && z00 == z11 && z00 != z10) lines = [[[0,1],[1,2]]];
if (z00 == z01 && z10 == z11 && z00 != z10) lines = [[[0,1],[2,1]]];
if (z00 == z10 && z00 == z11 && z00 != z01) lines = [[[1,0],[2,1]]];
if (z00 == z10 && z01 == z11 && z00 != z01) lines = [[[1,0],[1,2]]];
if (z00 == z11 && z01 == z10 && z00 != z01) lines = [[[1,0],[0,1]],[[2,1],[1,2]]];
if (z01 == z10 && z01 == z11 && z00 != z01) lines = [[[1,0],[0,1]]];
lines.forEach(l => {
turtle.jump(r/2+x0+l[0][0]*r, r/2+y0+l[0][1]*r);
turtle.goto(r/2+x0+l[1][0]*r, r/2+y0+l[1][1]*r);
});
return true;
}
// LiquidFun.js from https://google.github.io/liquidfun/
var Module;
if (!Module)
Module = (typeof Module !== "undefined" ? Module : null) || {};
var moduleOverrides = {};
for (var key in Module)
if (Module.hasOwnProperty(key))
moduleOverrides[key] = Module[key];
var ENVIRONMENT_IS_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) {
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);
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;
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
} 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 {
var TRY_USE_DUMP = false;
if (!Module["print"])
Module["print"] = TRY_USE_DUMP && typeof dump !== "undefined" ? function(x) {
dump(x)
} : function(x) {}
}
if (ENVIRONMENT_IS_WEB)
window["Module"] = Module;
else
Module["load"] = importScripts
} else
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"] = [];
Module.print = Module["print"];
Module.printErr = Module["printErr"];
Module["preRun"] = [];
Module["postRun"] = [];
for (var key in moduleOverrides)
if (moduleOverrides.hasOwnProperty(key))
Module[key] = moduleOverrides[key];
var Runtime = {
setTempRet0: function(value) {
tempRet0 = value
},
getTempRet0: function() {
return tempRet0
},
stackSave: function() {
return STACKTOP
},
stackRestore: function(stackTop) {
STACKTOP = stackTop
},
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;
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;
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) {
if (!vararg && (type == "i64" || type == "double"))
return 8;
if (!type)
return Math.min(size, 8);
return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE)
},
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);
alignSize = Runtime.getAlignSize(field, size)
} else if (Runtime.isStructType(field))
if (field[1] === "0") {
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") {
size = field.substr(1) |
0;
alignSize = 1
} else if (field[0] === "<")
size = alignSize = Types.types[field].flatSize;
else if (field[0] === "i") {
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);
type.flatSize = curr + size;
if (prev >= 0)
diffs.push(curr - prev);
prev = curr;
return curr
});
if (type.name_ && type.name_[0] ===
"[")
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 {
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) {
if (!args.splice)
args = Array.prototype.slice.call(args);
args.splice(0, 0, ptr);
return Module["dynCall_" + sig].apply(null, args)
} else
return Module["dynCall_" + sig].call(null, ptr)
},
functionPointers: [],
addFunction: function(func) {
for (var i = 0; i < Runtime.functionPointers.length; i++)
if (!Runtime.functionPointers[i]) {
Runtime.functionPointers[i] =
func;
return 2 * (1 + i)
}
throw "Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.";
},
removeFunction: function(index) {
Runtime.functionPointers[(index - 2) / 2] = null
},
getAsmConst: function(code, numArgs) {
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);
var source = Pointer_stringify(code);
if (source[0] === '"')
if (source.indexOf('"', 1) === source.length -
1)
source = source.substr(1, source.length - 2);
else
abort("invalid EM_ASM input |" + source + "|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)");
try {
var evalled = eval("(function(" + args.join(",") + "){ " + source + " })")
} catch (e) {
Module.printErr("error in executing inline EM_ASM code: " + e + " on: \n\n" + source + "\n\nwith args |" + args + "| (make sure to use the right one out of EM_ASM, EM_ASM_ARGS, etc.)");
throw e;
}
return Runtime.asmConstCache[code] = evalled
},
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 & 255;
if (buffer.length == 0) {
if ((code & 128) == 0)
return String.fromCharCode(code);
buffer.push(code);
if ((code & 224) == 192)
needed = 1;
else if ((code & 240) == 224)
needed = 2;
else
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 & 31) << 6 | c2 & 63);
else if (buffer.length == 3)
ret = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);
else {
var codePoint = (c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63;
ret = String.fromCharCode(Math.floor((codePoint - 65536) / 1024) + 55296, (codePoint - 65536) %
1024 + 56320)
}
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
}
},
getCompilerSetting: function(name) {
throw "You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work";
},
stackAlloc: function(size) {
var ret = STACKTOP;
STACKTOP = STACKTOP + size | 0;
STACKTOP = STACKTOP + 7 & -8;
return ret
},
staticAlloc: function(size) {
var ret =
STATICTOP;
STATICTOP = STATICTOP + size | 0;
STATICTOP = STATICTOP + 7 & -8;
return ret
},
dynamicAlloc: function(size) {
var ret = DYNAMICTOP;
DYNAMICTOP = DYNAMICTOP + 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;
var __THREW__ = 0;
var ABORT = false;
var EXITSTATUS = 0;
var undef = 0;
var tempValue,
tempInt,
tempBigInt,
tempInt2,
tempBigInt2,
tempPair,
tempBigIntI,
tempBigIntR,
tempBigIntS,
tempBigIntP,
tempBigIntD,
tempDouble,
tempFloat;
var tempI64,
tempI64b;
var tempRet0,
tempRet1,
tempRet2,
tempRet3,
tempRet4,
tempRet5,
tempRet6,
tempRet7,
tempRet8,
tempRet9;
function assert(condition, text) {
if (!condition)
abort("Assertion failed: " + text)
}
var globalScope = this;
function getCFunc(ident) {
var func = Module["_" + ident];
if (!func)
try {
func = eval("_" + ident)
} catch (e) {}
assert(func, "Cannot call unknown function " + ident + " (perhaps LLVM optimizations or closure removed it?)");
return func
}
var cwrap,
ccall;
(function() {
var stack = 0;
var JSfuncs = {
"stackSave": function() {
stack = Runtime.stackSave()
},
"stackRestore": function() {
Runtime.stackRestore(stack)
},
"arrayToC": function(arr) {
var ret = Runtime.stackAlloc(arr.length);
writeArrayToMemory(arr, ret);
return ret
},
"stringToC": function(str) {
var ret = 0;
if (str !== null && str !== undefined && str !== 0) {
ret = Runtime.stackAlloc(str.length + 1);
writeStringToMemory(str, ret)
}
return ret
}
};
var toC = {
"string": JSfuncs["stringToC"],
"array": JSfuncs["arrayToC"]
};
ccall = function ccallFunc(ident,
returnType, argTypes, args) {
var func = getCFunc(ident);
var cArgs = [];
if (args)
for (var i = 0; i < args.length; i++) {
var converter = toC[argTypes[i]];
if (converter) {
if (stack === 0)
stack = Runtime.stackSave();
cArgs[i] = converter(args[i])
} else
cArgs[i] = args[i]
}
var ret = func.apply(null, cArgs);
if (returnType === "string")
ret = Pointer_stringify(ret);
if (stack !== 0)
JSfuncs["stackRestore"]();
return ret
};
var sourceRegex = /^function\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/;
function parseJSFunc(jsfunc) {
var parsed =
jsfunc.toString().match(sourceRegex).slice(1);
return {
arguments: parsed[0],
body: parsed[1],
returnValue: parsed[2]
}
}
var JSsource = {};
for (var fun in JSfuncs)
if (JSfuncs.hasOwnProperty(fun))
JSsource[fun] = parseJSFunc(JSfuncs[fun]);
cwrap = function cwrap(ident, returnType, argTypes) {
var cfunc = getCFunc(ident);
var numericArgs = argTypes.every(function(type) {
return type === "number"
});
var numericRet = returnType !== "string";
if (numericRet && numericArgs)
return cfunc;
var argNames = argTypes.map(function(x, i) {
return "$" + i
});
var funcstr =
"(function(" + argNames.join(",") + ") {";
var nargs = argTypes.length;
if (!numericArgs) {
funcstr += JSsource["stackSave"].body + ";";
for (var i = 0; i < nargs; i++) {
var arg = argNames[i],
type = argTypes[i];
if (type === "number")
continue;
var convertCode = JSsource[type + "ToC"];
funcstr += "var " + convertCode.arguments + " = " + arg + ";";
funcstr += convertCode.body + ";";
funcstr += arg + "=" + convertCode.returnValue + ";"
}
}
var cfuncname = parseJSFunc(function() {
return cfunc
}).returnValue;
funcstr += "var ret = " + cfuncname + "(" + argNames.join(",") + ");";
if (!numericRet) {
var strgfy =
parseJSFunc(function() {
return Pointer_stringify
}).returnValue;
funcstr += "ret = " + strgfy + "(ret);"
}
if (!numericArgs)
funcstr += JSsource["stackRestore"].body + ";";
funcstr += "return ret})";
return eval(funcstr)
}
})();
Module["cwrap"] = cwrap;
Module["ccall"] = ccall;
function setValue(ptr, value, type, noSafe) {
type = type || "i8";
if (type.charAt(type.length - 1) === "*")
type = "i32";
switch (type) {
case "i1":
HEAP8[ptr >> 0] = value;
break;
case "i8":
HEAP8[ptr >> 0] = value;
break;
case "i16":
HEAP16[ptr >> 1] = value;
break;
case "i32":
HEAP32[ptr >> 2] = value;
break;
case "i64":
tempI64 = [value >>> 0, (tempDouble = value, +Math_abs(tempDouble) >= +1 ? tempDouble > +0 ? (Math_min(+Math_floor(tempDouble / +4294967296), +4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / +4294967296) >>> 0 : 0)],
HEAP32[ptr >> 2] =
tempI64[0],
HEAP32[ptr + 4 >> 2] = tempI64[1];
break;
case "float":
HEAPF32[ptr >> 2] = value;
break;
case "double":
HEAPF64[ptr >> 3] = value;
break;
default:
abort("invalid type for setValue: " + type)
}
}
Module["setValue"] = setValue;
function getValue(ptr, type, noSafe) {
type = type || "i8";
if (type.charAt(type.length - 1) === "*")
type = "i32";
switch (type) {
case "i1":
return HEAP8[ptr >> 0];
case "i8":
return HEAP8[ptr >> 0];
case "i16":
return HEAP16[ptr >> 1];
case "i32":
return HEAP32[ptr >> 2];
case "i64":
return HEAP32[ptr >> 2];
case "float":
return HEAPF32[ptr >> 2];
case "double":
return HEAPF64[ptr >> 3];
default:
abort("invalid type for setValue: " + type)
}
return null
}
Module["getValue"] = getValue;
var ALLOC_NORMAL = 0;
var ALLOC_STACK = 1;
var ALLOC_STATIC = 2;
var ALLOC_DYNAMIC = 3;
var ALLOC_NONE = 4;
Module["ALLOC_NORMAL"] = ALLOC_NORMAL;
Module["ALLOC_STACK"] = ALLOC_STACK;
Module["ALLOC_STATIC"] = ALLOC_STATIC;
Module["ALLOC_DYNAMIC"] = ALLOC_DYNAMIC;
Module["ALLOC_NONE"] = ALLOC_NONE;
function allocate(slab, types, allocator, ptr) {
var zeroinit,
size;
if (typeof slab === "number") {
zeroinit = true;
size = slab
} else {
zeroinit = false;
size = slab.length
}
var singleType = typeof types === "string" ? types : null;
var ret;
if (allocator == ALLOC_NONE)
ret = ptr;
else
ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
if (zeroinit) {
var ptr = ret,
stop;
assert((ret & 3) == 0);
stop = ret + (size & ~3);
for (; ptr < stop; ptr += 4)
HEAP32[ptr >>
2] = 0;
stop = ret + size;
while (ptr < stop)
HEAP8[ptr++ >> 0] = 0;
return ret
}
if (singleType === "i8") {
if (slab.subarray || slab.slice)
HEAPU8.set(slab, ret);
else
HEAPU8.set(new Uint8Array(slab), ret);
return ret
}
var i = 0,
type,
typeSize,
previousType;
while (i < size) {
var curr = slab[i];
if (typeof curr === "function")
curr = Runtime.getFunctionIndex(curr);
type = singleType || types[i];
if (type === 0) {
i++;
continue
}
if (type == "i64")
type = "i32";
setValue(ret + i, curr, type);
if (previousType !== type) {
typeSize = Runtime.getNativeTypeSize(type);
previousType = type
}
i +=
typeSize
}
return ret
}
Module["allocate"] = allocate;
function Pointer_stringify(ptr, length) {
var hasUtf = false;
var t;
var i = 0;
while (1) {
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;
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++) {
t = HEAPU8[ptr + i >> 0];
ret +=
utf8.processCChar(t)
}
return ret
}
Module["Pointer_stringify"] = Pointer_stringify;
function UTF16ToString(ptr) {
var i = 0;
var str = "";
while (1) {
var codeUnit = HEAP16[ptr + i * 2 >> 1];
if (codeUnit == 0)
return str;
++i;
str += String.fromCharCode(codeUnit)
}
}
Module["UTF16ToString"] = UTF16ToString;
function stringToUTF16(str, outPtr) {
for (var i = 0; i < str.length; ++i) {
var codeUnit = str.charCodeAt(i);
HEAP16[outPtr + i * 2 >> 1] = codeUnit
}
HEAP16[outPtr + str.length * 2 >> 1] = 0
}
Module["stringToUTF16"] = stringToUTF16;
function UTF32ToString(ptr) {
var i = 0;
var str = "";
while (1) {
var utf32 = HEAP32[ptr + i * 4 >> 2];
if (utf32 == 0)
return str;
++i;
if (utf32 >= 65536) {
var ch = utf32 - 65536;
str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
} else
str += String.fromCharCode(utf32)
}
}
Module["UTF32ToString"] = UTF32ToString;
function stringToUTF32(str, outPtr) {
var iChar = 0;
for (var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
var codeUnit = str.charCodeAt(iCodeUnit);
if (codeUnit >= 55296 && codeUnit <= 57343) {
var trailSurrogate = str.charCodeAt(++iCodeUnit);
codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023
}
HEAP32[outPtr + iChar * 4 >> 2] = codeUnit;
++iChar
}
HEAP32[outPtr + iChar * 4 >> 2] = 0
}
Module["stringToUTF32"] = stringToUTF32;
function demangle(func) {
var i = 3;
var basicTypes = {
"v": "void",
"b": "bool",
"c": "char",
"s": "short",
"i": "int",
"l": "long",
"f": "float",
"d": "double",
"w": "wchar_t",
"a": "signed char",
"h": "unsigned char",
"t": "unsigned short",
"j": "unsigned int",
"m": "unsigned long",
"x": "long long",
"y": "unsigned long long",
"z": "..."
};
var subs = [];
var first = true;
function dump(x) {
if (x)
Module.print(x);
Module.print(func);
var pre = "";
for (var a = 0; a < i; a++)
pre += " ";
Module.print(pre + "^")
}
function parseNested() {
i++;
if (func[i] === "K")
i++;
var parts =
[];
while (func[i] !== "E") {
if (func[i] === "S") {
i++;
var next = func.indexOf("_", i);
var num = func.substring(i, next) || 0;
parts.push(subs[num] || "?");
i = next + 1;
continue
}
if (func[i] === "C") {
parts.push(parts[parts.length - 1]);
i += 2;
continue
}
var size = parseInt(func.substr(i));
var pre = size.toString().length;
if (!size || !pre) {
i--;
break
}
var curr = func.substr(i + pre, size);
parts.push(curr);
subs.push(curr);
i += pre + size
}
i++;
return parts
}
function parse(rawList, limit, allowVoid) {
limit = limit || Infinity;
var ret = "",
list = [];
function flushList() {
return "(" +
list.join(", ") + ")"
}
var name;
if (func[i] === "N") {
name = parseNested().join("::");
limit--;
if (limit === 0)
return rawList ? [name] : name
} else {
if (func[i] === "K" || first && func[i] === "L")
i++;
var size = parseInt(func.substr(i));
if (size) {
var pre = size.toString().length;
name = func.substr(i + pre, size);
i += pre + size
}
}
first = false;
if (func[i] === "I") {
i++;
var iList = parse(true);
var iRet = parse(true, 1, true);
ret += iRet[0] + " " + name + "<" + iList.join(", ") + ">"
} else
ret = name;
paramLoop:
while (i < func.length && limit-- > 0) {
var c = func[i++];
if (c in basicTypes)
list.push(basicTypes[c]);
else
switch (c) {
case "P":
list.push(parse(true, 1, true)[0] + "*");
break;
case "R":
list.push(parse(true, 1, true)[0] + "&");
break;
case "L":
i++;
var end = func.indexOf("E", i);
var size = end - i;
list.push(func.substr(i, size));
i += size + 2;
break;
case "A":
var size = parseInt(func.substr(i));
i += size.toString().length;
if (func[i] !== "_")
throw "?";
i++;
list.push(parse(true, 1, true)[0] + " [" + size + "]");
break;
case "E":
break paramLoop;
default:
ret += "?" + c;
break paramLoop
}
}
if (!allowVoid && list.length === 1 && list[0] === "void")
list = [];
if (rawList) {
if (ret)
list.push(ret +
"?");
return list
} else
return ret + flushList()
}
try {
if (func == "Object._main" || func == "_main")
return "main()";
if (typeof func === "number")
func = Pointer_stringify(func);
if (func[0] !== "_")
return func;
if (func[1] !== "_")
return func;
if (func[2] !== "Z")
return func;
switch (func[3]) {
case "n":
return "operator new()";
case "d":
return "operator delete()"
}
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)"
}
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;
var STACK_BASE = 0,
STACKTOP = 0,
STACK_MAX = 0;
var DYNAMIC_BASE = 0,
DYNAMICTOP = 0;
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"] || 33554432;
var FAST_MEMORY = Module["FAST_MEMORY"] || 2097152;
var totalMemory = 4096;
while (totalMemory < TOTAL_MEMORY || totalMemory < 2 * TOTAL_STACK)
if (totalMemory < 16 * 1024 * 1024)
totalMemory *= 2;
else
totalMemory += 16 * 1024 * 1024;
if (totalMemory !== TOTAL_MEMORY) {
Module.printErr("increasing TOTAL_MEMORY to " + totalMemory + " to be more reasonable");
TOTAL_MEMORY = totalMemory
}
assert(typeof Int32Array !== "undefined" && typeof Float64Array !== "undefined" && !!(new Int32Array(1))["subarray"] && !!(new Int32Array(1))["set"], "JS engine does not provide full typed array support");
var buffer = new ArrayBuffer(TOTAL_MEMORY);
HEAP8 = new Int8Array(buffer);
HEAP16 = new Int16Array(buffer);
HEAP32 = new Int32Array(buffer);
HEAPU8 = new Uint8Array(buffer);
HEAPU16 = new Uint16Array(buffer);
HEAPU32 = new Uint32Array(buffer);
HEAPF32 = new Float32Array(buffer);
HEAPF64 = new Float64Array(buffer);
HEAP32[0] = 255;
assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, "Typed arrays 2 must be run on a little-endian system");
Module["HEAP"] = HEAP;
Module["HEAP8"] = HEAP8;
Module["HEAP16"] = HEAP16;
Module["HEAP32"] = HEAP32;
Module["HEAPU8"] = HEAPU8;
Module["HEAPU16"] = HEAPU16;
Module["HEAPU32"] = HEAPU32;
Module["HEAPF32"] = HEAPF32;
Module["HEAPF64"] = HEAPF64;
function callRuntimeCallbacks(callbacks) {
while (callbacks.length > 0) {
var callback = callbacks.shift();
if (typeof callback == "function") {
callback();
continue
}
var func = callback.func;
if (typeof func === "number")
if (callback.arg === undefined)
Runtime.dynCall("v", func);
else
Runtime.dynCall("vi", func, [callback.arg]);
else
func(callback.arg === undefined ? null : callback.arg)
}
}
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATMAIN__ = [];
var __ATEXIT__ = [];
var __ATPOSTRUN__ = [];
var runtimeInitialized = false;
function preRun() {
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function")
Module["preRun"] = [Module["preRun"]];
while (Module["preRun"].length)
addOnPreRun(Module["preRun"].shift())
}
callRuntimeCallbacks(__ATPRERUN__)
}
function ensureInitRuntime() {
if (runtimeInitialized)
return;
runtimeInitialized = true;
callRuntimeCallbacks(__ATINIT__)
}
function preMain() {
callRuntimeCallbacks(__ATMAIN__)
}
function exitRuntime() {
callRuntimeCallbacks(__ATEXIT__)
}
function postRun() {
if (Module["postRun"]) {
if (typeof Module["postRun"] == "function")
Module["postRun"] = [Module["postRun"]];
while (Module["postRun"].length)
addOnPostRun(Module["postRun"].shift())
}
callRuntimeCallbacks(__ATPOSTRUN__)
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb)
}
Module["addOnPreRun"] = 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;
function intArrayFromString(stringy, dontAddNull, length) {
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 > 255)
chr &= 255;
ret.push(String.fromCharCode(chr))
}
return ret.join("")
}
Module["intArrayToString"] = intArrayToString;
function writeStringToMemory(string, buffer, dontAddNull) {
var array = intArrayFromString(string, dontAddNull);
var i = 0;
while (i < array.length) {
var chr = array[i];
HEAP8[buffer + i >> 0] = chr;
i = i + 1
}
}
Module["writeStringToMemory"] = writeStringToMemory;
function writeArrayToMemory(array, buffer) {
for (var i = 0; i < array.length; i++)
HEAP8[buffer + i >> 0] = array[i]
}
Module["writeArrayToMemory"] = writeArrayToMemory;
function writeAsciiToMemory(str, buffer, dontAddNull) {
for (var i = 0; i < str.length; i++)
HEAP8[buffer + i >> 0] = str.charCodeAt(i);
if (!dontAddNull)
HEAP8[buffer + str.length >> 0] = 0
}
Module["writeAsciiToMemory"] = writeAsciiToMemory;
function unSign(value, bits, ignore) {
if (value >= 0)
return value;
return bits <= 32 ? 2 * Math.abs(1 << bits - 1) + value : Math.pow(2, bits) + value
}
function reSign(value, bits, ignore) {
if (value <= 0)
return value;
var half = bits <= 32 ? Math.abs(1 << bits - 1) : Math.pow(2, bits - 1);
if (value >= half && (bits <= 32 || value > half))
value = -2 * half + value;
return value
}
if (!Math["imul"] || Math["imul"](4294967295, 5) !== -5)
Math["imul"] = function imul(a, b) {
var ah = a >>> 16;
var al = a & 65535;
var bh = b >>> 16;
var bl = b & 65535;
return al * bl + (ah * bl + al * bh << 16) | 0
};
Math.imul = Math["imul"];
var Math_abs = Math.abs;
var Math_cos = Math.cos;
var Math_sin = Math.sin;
var Math_tan = Math.tan;
var Math_acos = Math.acos;
var Math_asin = Math.asin;
var Math_atan = Math.atan;
var Math_atan2 = Math.atan2;
var Math_exp = Math.exp;
var Math_log = Math.log;
var Math_sqrt = Math.sqrt;
var Math_ceil = Math.ceil;
var Math_floor = Math.floor;
var Math_pow = Math.pow;
var Math_imul = Math.imul;
var Math_fround = Math.fround;
var Math_min = Math.min;
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null;
function addRunDependency(id) {
runDependencies++;
if (Module["monitorRunDependencies"])
Module["monitorRunDependencies"](runDependencies)
}
Module["addRunDependency"] = addRunDependency;
function removeRunDependency(id) {
runDependencies--;
if (Module["monitorRunDependencies"])
Module["monitorRunDependencies"](runDependencies);
if (runDependencies == 0) {
if (runDependencyWatcher !== null) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null
}
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback()
}
}
}
Module["removeRunDependency"] = removeRunDependency;
Module["preloadedImages"] = {};
Module["preloadedAudios"] = {};
var memoryInitializer = null;
var __ZTVN10__cxxabiv117__class_type_infoE = 9E3;
var __ZTVN10__cxxabiv120__si_class_type_infoE = 9040;
STATIC_BASE = 8;
STATICTOP = STATIC_BASE + Runtime.alignMemory(9715);
__ATINIT__.push({
func: function() {
__GLOBAL__I_a()
}
});
allocate([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 152, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 49, 53, 82, 97, 121, 67, 97, 115, 116, 67, 97, 108, 108, 98, 97, 99, 107, 0, 0, 0, 0, 0, 0, 0, 49, 55, 98, 50, 82, 97, 121, 67, 97, 115, 116, 67, 97, 108, 108, 98, 97, 99, 107, 0, 0, 0, 0, 0, 48, 35, 0, 0, 120, 0, 0, 0, 88, 35, 0, 0, 96, 0, 0, 0, 144, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 49, 55, 81, 117, 101, 114, 121, 65, 65, 66, 66, 67, 97, 108, 108,
98, 97, 99, 107, 0, 0, 0, 0, 0, 49, 53, 98, 50, 81, 117, 101, 114, 121, 67, 97, 108, 108, 98, 97, 99, 107, 0, 0, 0, 0, 0, 0, 0, 48, 35, 0, 0, 224, 0, 0, 0, 88, 35, 0, 0, 200, 0, 0, 0, 248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 1, 0, 0, 5, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 50, 50, 98, 50, 87, 111, 114, 108, 100, 67, 111, 110, 116, 97, 99, 116, 76, 105, 115, 116, 101, 110, 101, 114, 0, 0, 0, 0, 0, 0, 0, 0, 49, 55, 98, 50, 67, 111, 110, 116, 97, 99, 116, 76, 105, 115, 116, 101, 110, 101, 114, 0, 0, 0, 0, 0, 48, 35, 0, 0, 96, 1, 0, 0, 88, 35, 0, 0, 64, 1, 0, 0, 120, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 2, 0, 0, 7, 0, 0, 0, 8, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 49, 49, 98, 50, 69, 100, 103, 101, 83, 104, 97, 112, 101, 0, 0, 0, 55, 98, 50, 83, 104, 97, 112, 101, 0, 0, 0, 0, 0, 0, 0, 0, 48, 35, 0, 0, 32, 2, 0, 0, 88, 35, 0, 0, 16, 2, 0, 0, 48, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 144, 2, 0, 0, 9, 0, 0, 0, 10, 0, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 49, 52, 98, 50,
80, 111, 108, 121, 103, 111, 110, 83, 104, 97, 112, 101, 0, 0, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 120, 2, 0, 0, 48, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 2, 0, 0, 11, 0, 0, 0, 12, 0, 0, 0, 6, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 49, 51, 98, 50, 67, 105, 114, 99, 108, 101, 83, 104, 97, 112, 101, 0, 88, 35, 0, 0, 208, 2, 0, 0, 48, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 3, 0, 0, 13, 0, 0, 0, 14, 0, 0, 0, 7, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 49, 50, 98, 50, 67, 104, 97, 105, 110, 83, 104, 97, 112, 101, 0, 0, 88, 35, 0, 0, 32, 3, 0, 0, 48, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 120, 3, 0, 0, 15, 0, 0,
0, 16, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 49, 53, 98, 50, 67, 111, 110, 116, 97, 99, 116, 70, 105, 108, 116, 101, 114, 0, 0, 0, 0, 0, 0, 0, 48, 35, 0, 0, 96, 3, 0, 0, 0, 0, 0, 0, 224, 3, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 1, 0, 0, 0, 17, 0, 0, 0, 5, 0, 0, 0, 18, 0, 0, 0, 19, 0, 0, 0, 6, 0, 0, 0, 7, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 49, 50, 98, 50, 77, 111, 117, 115, 101, 74, 111, 105, 110, 116, 0, 0, 55, 98, 50, 74, 111, 105, 110, 116, 0, 0, 0, 0, 0, 0, 0, 0, 48, 35, 0, 0, 200, 3, 0, 0, 88, 35, 0, 0, 184, 3, 0, 0, 216, 3, 0, 0, 0, 0, 0, 0, 77, 111, 117, 115, 101, 32, 106, 111, 105, 110, 116, 32, 100, 117, 109, 112, 105, 110, 103, 32, 105, 115, 32, 110, 111,
116, 32, 115, 117, 112, 112, 111, 114, 116, 101, 100, 46, 10, 0, 0, 0, 0, 0, 0, 200, 5, 0, 0, 8, 0, 0, 0, 9, 0, 0, 0, 6, 0, 0, 0, 2, 0, 0, 0, 20, 0, 0, 0, 10, 0, 0, 0, 21, 0, 0, 0, 22, 0, 0, 0, 11, 0, 0, 0, 12, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 32, 32, 98, 50, 77, 111, 116, 111, 114, 74, 111, 105, 110, 116, 68, 101, 102, 32, 106, 100, 59, 10, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 65, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 66, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 99, 111, 108, 108, 105, 100, 101, 67,
111, 110, 110, 101, 99, 116, 101, 100, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 105, 110, 101, 97, 114, 79, 102, 102, 115, 101, 116, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 97, 110, 103, 117, 108, 97, 114, 79, 102, 102, 115, 101, 116, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 32, 32, 106, 100, 46, 109, 97, 120, 70, 111, 114, 99, 101, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 109, 97, 120, 84, 111, 114, 113, 117, 101,
32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 99, 111, 114, 114, 101, 99, 116, 105, 111, 110, 70, 97, 99, 116, 111, 114, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 111, 105, 110, 116, 115, 91, 37, 100, 93, 32, 61, 32, 109, 95, 119, 111, 114, 108, 100, 45, 62, 67, 114, 101, 97, 116, 101, 74, 111, 105, 110, 116, 40, 38, 106, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 49, 50, 98, 50, 77, 111, 116, 111, 114, 74, 111, 105, 110, 116, 0, 0, 88, 35, 0, 0, 184, 5, 0, 0, 216, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 152, 7, 0, 0, 13, 0, 0, 0, 14, 0, 0, 0, 7, 0, 0, 0, 3, 0, 0, 0, 23, 0, 0, 0, 10, 0, 0,
0, 24, 0, 0, 0, 25, 0, 0, 0, 15, 0, 0, 0, 16, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 98, 50, 68, 105, 115, 116, 97, 110, 99, 101, 74, 111, 105, 110, 116, 68, 101, 102, 32, 106, 100, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 65, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 66, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 99, 111, 108, 108, 105, 100, 101, 67, 111, 110, 110, 101, 99, 116, 101, 100, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100,
46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 65, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 66, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 101, 110, 103, 116, 104, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 32, 32, 106, 100, 46, 102, 114, 101, 113, 117, 101, 110, 99, 121, 72, 122, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 32, 32, 106, 100, 46, 100,
97, 109, 112, 105, 110, 103, 82, 97, 116, 105, 111, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 32, 32, 106, 111, 105, 110, 116, 115, 91, 37, 100, 93, 32, 61, 32, 109, 95, 119, 111, 114, 108, 100, 45, 62, 67, 114, 101, 97, 116, 101, 74, 111, 105, 110, 116, 40, 38, 106, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 49, 53, 98, 50, 68, 105, 115, 116, 97, 110, 99, 101, 74, 111, 105, 110, 116, 0, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 128, 7, 0, 0, 216, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 80, 9, 0, 0, 17, 0, 0, 0, 18, 0, 0, 0, 8, 0, 0, 0, 4, 0, 0, 0, 26, 0, 0, 0, 10, 0, 0, 0, 27, 0, 0, 0, 28, 0, 0, 0, 19, 0, 0, 0, 20, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 32, 32, 98, 50, 70, 114, 105,
99, 116, 105, 111, 110, 74, 111, 105, 110, 116, 68, 101, 102, 32, 106, 100, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 65, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 66, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 99, 111, 108, 108, 105, 100, 101, 67, 111, 110, 110, 101, 99, 116, 101, 100, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 65, 46, 83, 101, 116, 40, 37, 46, 49, 53,
108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 66, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 109, 97, 120, 70, 111, 114, 99, 101, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 109, 97, 120, 84, 111, 114, 113, 117, 101, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 111, 105, 110, 116, 115, 91, 37, 100, 93, 32, 61, 32, 109, 95, 119, 111, 114, 108, 100, 45,
62, 67, 114, 101, 97, 116, 101, 74, 111, 105, 110, 116, 40, 38, 106, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 49, 53, 98, 50, 70, 114, 105, 99, 116, 105, 111, 110, 74, 111, 105, 110, 116, 0, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 56, 9, 0, 0, 216, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 11, 0, 0, 21, 0, 0, 0, 22, 0, 0, 0, 9, 0, 0, 0, 5, 0, 0, 0, 29, 0, 0, 0, 10, 0, 0, 0, 30, 0, 0, 0, 31, 0, 0, 0, 23, 0, 0, 0, 24, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 32, 32, 98, 50, 87, 101, 108, 100, 74, 111, 105, 110, 116, 68, 101, 102, 32, 106, 100, 59, 10, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 65, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106,
100, 46, 98, 111, 100, 121, 66, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 99, 111, 108, 108, 105, 100, 101, 67, 111, 110, 110, 101, 99, 116, 101, 100, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 65, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 66, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101,
102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 114, 101, 102, 101, 114, 101, 110, 99, 101, 65, 110, 103, 108, 101, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 32, 32, 106, 100, 46, 102, 114, 101, 113, 117, 101, 110, 99, 121, 72, 122, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 32, 32, 106, 100, 46, 100, 97, 109, 112, 105, 110, 103, 82, 97, 116, 105, 111, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 32, 32, 106, 111, 105, 110, 116, 115, 91, 37, 100, 93, 32, 61, 32, 109, 95, 119, 111, 114, 108, 100, 45, 62, 67, 114, 101, 97, 116, 101, 74, 111, 105, 110, 116, 40, 38, 106, 100, 41, 59, 10,
0, 0, 0, 0, 0, 0, 49, 49, 98, 50, 87, 101, 108, 100, 74, 111, 105, 110, 116, 0, 0, 0, 88, 35, 0, 0, 8, 11, 0, 0, 216, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 120, 12, 0, 0, 25, 0, 0, 0, 26, 0, 0, 0, 10, 0, 0, 0, 6, 0, 0, 0, 32, 0, 0, 0, 10, 0, 0, 0, 33, 0, 0, 0, 34, 0, 0, 0, 27, 0, 0, 0, 28, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 32, 32, 98, 50, 71, 101, 97, 114, 74, 111, 105, 110, 116, 68, 101, 102, 32, 106, 100, 59, 10, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 65, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 66, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0,
0, 0, 32, 32, 106, 100, 46, 99, 111, 108, 108, 105, 100, 101, 67, 111, 110, 110, 101, 99, 116, 101, 100, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 106, 111, 105, 110, 116, 49, 32, 61, 32, 106, 111, 105, 110, 116, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 106, 111, 105, 110, 116, 50, 32, 61, 32, 106, 111, 105, 110, 116, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 114, 97, 116, 105, 111, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 32, 32, 106, 111, 105, 110, 116, 115, 91, 37, 100, 93, 32, 61, 32, 109, 95, 119, 111, 114, 108, 100,
45, 62, 67, 114, 101, 97, 116, 101, 74, 111, 105, 110, 116, 40, 38, 106, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 49, 49, 98, 50, 71, 101, 97, 114, 74, 111, 105, 110, 116, 0, 0, 0, 88, 35, 0, 0, 104, 12, 0, 0, 216, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 15, 0, 0, 29, 0, 0, 0, 30, 0, 0, 0, 11, 0, 0, 0, 7, 0, 0, 0, 35, 0, 0, 0, 10, 0, 0, 0, 36, 0, 0, 0, 37, 0, 0, 0, 31, 0, 0, 0, 32, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 32, 32, 98, 50, 80, 114, 105, 115, 109, 97, 116, 105, 99, 74, 111, 105, 110, 116, 68, 101, 102, 32, 106, 100, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 65, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32,
32, 106, 100, 46, 98, 111, 100, 121, 66, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 99, 111, 108, 108, 105, 100, 101, 67, 111, 110, 110, 101, 99, 116, 101, 100, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 65, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 66, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53,
108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 120, 105, 115, 65, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 32, 32, 106, 100, 46, 114, 101, 102, 101, 114, 101, 110, 99, 101, 65, 110, 103, 108, 101, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 32, 32, 106, 100, 46, 101, 110, 97, 98, 108, 101, 76, 105, 109, 105, 116, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 119, 101, 114, 84, 114, 97, 110, 115, 108, 97, 116, 105, 111, 110, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59,
10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 117, 112, 112, 101, 114, 84, 114, 97, 110, 115, 108, 97, 116, 105, 111, 110, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 101, 110, 97, 98, 108, 101, 77, 111, 116, 111, 114, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 32, 32, 106, 100, 46, 109, 111, 116, 111, 114, 83, 112, 101, 101, 100, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 109, 97, 120, 77, 111, 116, 111, 114, 70, 111, 114, 99, 101, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 32, 32, 106, 111, 105, 110, 116, 115, 91,
37, 100, 93, 32, 61, 32, 109, 95, 119, 111, 114, 108, 100, 45, 62, 67, 114, 101, 97, 116, 101, 74, 111, 105, 110, 116, 40, 38, 106, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 49, 54, 98, 50, 80, 114, 105, 115, 109, 97, 116, 105, 99, 74, 111, 105, 110, 116, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 240, 14, 0, 0, 216, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 144, 16, 0, 0, 33, 0, 0, 0, 34, 0, 0, 0, 12, 0, 0, 0, 8, 0, 0, 0, 38, 0, 0, 0, 10, 0, 0, 0, 39, 0, 0, 0, 40, 0, 0, 0, 35, 0, 0, 0, 36, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 32, 32, 98, 50, 82, 111, 112, 101, 74, 111, 105, 110, 116, 68, 101, 102, 32, 106, 100, 59, 10, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 65, 32, 61, 32, 98, 111, 100,
105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 66, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 99, 111, 108, 108, 105, 100, 101, 67, 111, 110, 110, 101, 99, 116, 101, 100, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 65, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 66, 46, 83, 101,
116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 109, 97, 120, 76, 101, 110, 103, 116, 104, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 111, 105, 110, 116, 115, 91, 37, 100, 93, 32, 61, 32, 109, 95, 119, 111, 114, 108, 100, 45, 62, 67, 114, 101, 97, 116, 101, 74, 111, 105, 110, 116, 40, 38, 106, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 49, 49, 98, 50, 82, 111, 112, 101, 74, 111, 105, 110, 116, 0, 0, 0, 88, 35, 0, 0, 128, 16, 0, 0, 216, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 216, 3, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 41, 0, 0, 0, 10, 0,
0, 0, 42, 0, 0, 0, 43, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 47, 47, 32, 68, 117, 109, 112, 32, 105, 115, 32, 110, 111, 116, 32, 115, 117, 112, 112, 111, 114, 116, 101, 100, 32, 102, 111, 114, 32, 116, 104, 105, 115, 32, 106, 111, 105, 110, 116, 32, 116, 121, 112, 101, 46, 10, 0, 0, 0, 0, 0, 0, 80, 19, 0, 0, 37, 0, 0, 0, 38, 0, 0, 0, 13, 0, 0, 0, 9, 0, 0, 0, 44, 0, 0, 0, 10, 0, 0, 0, 45, 0, 0, 0, 46, 0, 0, 0, 39, 0, 0, 0, 40, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 32, 32, 98, 50, 82, 101, 118, 111, 108, 117, 116, 101, 74, 111, 105, 110, 116, 68, 101, 102, 32, 106, 100, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 65, 32, 61, 32,
98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 66, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 99, 111, 108, 108, 105, 100, 101, 67, 111, 110, 110, 101, 99, 116, 101, 100, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 65, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 66,
46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 114, 101, 102, 101, 114, 101, 110, 99, 101, 65, 110, 103, 108, 101, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 32, 32, 106, 100, 46, 101, 110, 97, 98, 108, 101, 76, 105, 109, 105, 116, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 119, 101, 114, 65, 110, 103, 108, 101, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 117, 112, 112, 101, 114, 65, 110, 103, 108, 101, 32, 61, 32, 37, 46, 49, 53, 108, 101,
102, 59, 10, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 101, 110, 97, 98, 108, 101, 77, 111, 116, 111, 114, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 32, 32, 106, 100, 46, 109, 111, 116, 111, 114, 83, 112, 101, 101, 100, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 109, 97, 120, 77, 111, 116, 111, 114, 84, 111, 114, 113, 117, 101, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 32, 32, 106, 111, 105, 110, 116, 115, 91, 37, 100, 93, 32, 61, 32, 109, 95, 119, 111, 114, 108, 100, 45, 62, 67, 114, 101, 97, 116, 101, 74, 111, 105, 110, 116, 40, 38, 106, 100, 41, 59, 10, 0, 0, 0, 0, 0,
0, 49, 53, 98, 50, 82, 101, 118, 111, 108, 117, 116, 101, 74, 111, 105, 110, 116, 0, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 56, 19, 0, 0, 216, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 21, 0, 0, 41, 0, 0, 0, 42, 0, 0, 0, 14, 0, 0, 0, 10, 0, 0, 0, 47, 0, 0, 0, 10, 0, 0, 0, 48, 0, 0, 0, 49, 0, 0, 0, 43, 0, 0, 0, 44, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 32, 32, 98, 50, 87, 104, 101, 101, 108, 74, 111, 105, 110, 116, 68, 101, 102, 32, 106, 100, 59, 10, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 65, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 66, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100,
93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 99, 111, 108, 108, 105, 100, 101, 67, 111, 110, 110, 101, 99, 116, 101, 100, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 65, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 66, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65,
120, 105, 115, 65, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 32, 32, 106, 100, 46, 101, 110, 97, 98, 108, 101, 77, 111, 116, 111, 114, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 32, 32, 106, 100, 46, 109, 111, 116, 111, 114, 83, 112, 101, 101, 100, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 109, 97, 120, 77, 111, 116, 111, 114, 84, 111, 114, 113, 117, 101, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 32, 32, 106, 100, 46, 102, 114, 101, 113, 117, 101, 110, 99, 121, 72, 122, 32, 61, 32, 37, 46, 49, 53, 108,
101, 102, 59, 10, 0, 0, 0, 0, 32, 32, 106, 100, 46, 100, 97, 109, 112, 105, 110, 103, 82, 97, 116, 105, 111, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 32, 32, 106, 111, 105, 110, 116, 115, 91, 37, 100, 93, 32, 61, 32, 109, 95, 119, 111, 114, 108, 100, 45, 62, 67, 114, 101, 97, 116, 101, 74, 111, 105, 110, 116, 40, 38, 106, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 49, 50, 98, 50, 87, 104, 101, 101, 108, 74, 111, 105, 110, 116, 0, 0, 88, 35, 0, 0, 112, 21, 0, 0, 216, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 160, 23, 0, 0, 45, 0, 0, 0, 46, 0, 0, 0, 15, 0, 0, 0, 11, 0, 0, 0, 50, 0, 0, 0, 47, 0, 0, 0, 51, 0, 0, 0, 52, 0, 0, 0, 48, 0, 0, 0, 49, 0, 0, 0, 18, 0, 0, 0,
0, 0, 0, 0, 32, 32, 98, 50, 80, 117, 108, 108, 101, 121, 74, 111, 105, 110, 116, 68, 101, 102, 32, 106, 100, 59, 10, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 65, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 98, 111, 100, 121, 66, 32, 61, 32, 98, 111, 100, 105, 101, 115, 91, 37, 100, 93, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 99, 111, 108, 108, 105, 100, 101, 67, 111, 110, 110, 101, 99, 116, 101, 100, 32, 61, 32, 98, 111, 111, 108, 40, 37, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 103, 114, 111, 117, 110, 100, 65, 110, 99, 104, 111, 114, 65, 46, 83, 101,
116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 103, 114, 111, 117, 110, 100, 65, 110, 99, 104, 111, 114, 66, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 65, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32, 37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 111, 99, 97, 108, 65, 110, 99, 104, 111, 114, 66, 46, 83, 101, 116, 40, 37, 46, 49, 53, 108, 101, 102, 44, 32,
37, 46, 49, 53, 108, 101, 102, 41, 59, 10, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 101, 110, 103, 116, 104, 65, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 108, 101, 110, 103, 116, 104, 66, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 0, 0, 0, 0, 0, 0, 32, 32, 106, 100, 46, 114, 97, 116, 105, 111, 32, 61, 32, 37, 46, 49, 53, 108, 101, 102, 59, 10, 0, 0, 32, 32, 106, 111, 105, 110, 116, 115, 91, 37, 100, 93, 32, 61, 32, 109, 95, 119, 111, 114, 108, 100, 45, 62, 67, 114, 101, 97, 116, 101, 74, 111, 105, 110, 116, 40, 38, 106, 100, 41, 59, 10, 0, 0, 0, 0, 0, 0, 49, 51, 98, 50, 80, 117,
108, 108, 101, 121, 74, 111, 105, 110, 116, 0, 88, 35, 0, 0, 144, 23, 0, 0, 216, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 7, 0, 0, 0, 53, 0, 0, 0, 54, 0, 0, 0, 0, 0, 0, 0, 50, 52, 98, 50, 67, 104, 97, 105, 110, 65, 110, 100, 80, 111, 108, 121, 103, 111, 110, 67, 111, 110, 116, 97, 99, 116, 0, 0, 0, 0, 0, 0, 57, 98, 50, 67, 111, 110, 116, 97, 99, 116, 0, 0, 0, 0, 0, 0, 48, 35, 0, 0, 232, 23, 0, 0, 88, 35, 0, 0, 200, 23, 0, 0, 248, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 23, 0, 0, 1, 0, 0, 0, 55, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 25, 0, 0, 8, 0, 0, 0, 57, 0, 0, 0, 58, 0, 0, 0, 0, 0, 0, 0, 50, 53, 98, 50, 80, 111, 108, 121, 103, 111, 110, 65, 110, 100, 67, 105, 114, 99, 108, 101, 67, 111, 110, 116, 97, 99, 116, 0, 0, 0, 0, 0, 88, 35, 0, 0, 8, 25, 0, 0, 248, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 104, 25,
0, 0, 9, 0, 0, 0, 59, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, 0, 49, 53, 98, 50, 67, 105, 114, 99, 108, 101, 67, 111, 110, 116, 97, 99, 116, 0, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 80, 25, 0, 0, 248, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 176, 25, 0, 0, 10, 0, 0, 0, 61, 0, 0, 0, 62, 0, 0, 0, 0, 0, 0, 0, 50, 50, 98, 50, 69, 100, 103, 101, 65, 110, 100, 67, 105, 114, 99, 108, 101, 67, 111, 110, 116, 97, 99, 116, 0, 0, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 144, 25, 0, 0, 248, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 25, 0, 0, 11, 0, 0, 0, 63, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 50, 51, 98, 50, 67, 104, 97, 105, 110, 65, 110, 100, 67, 105, 114, 99, 108, 101, 67, 111, 110, 116, 97, 99, 116, 0, 0, 0, 0, 0, 0, 0,
88, 35, 0, 0, 216, 25, 0, 0, 248, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 26, 0, 0, 12, 0, 0, 0, 65, 0, 0, 0, 66, 0, 0, 0, 0, 0, 0, 0, 50, 51, 98, 50, 69, 100, 103, 101, 65, 110, 100, 80, 111, 108, 121, 103, 111, 110, 67, 111, 110, 116, 97, 99, 116, 0, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 32, 26, 0, 0, 248, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 26, 0, 0, 13, 0, 0, 0, 67, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 49, 54, 98, 50, 80, 111, 108, 121, 103, 111, 110, 67, 111, 110, 116, 97, 99, 116, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 104, 26, 0, 0, 248, 23, 0, 0, 0, 0, 0, 0, 72, 3, 0, 0, 0, 0, 0, 0, 168, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 120, 1, 0, 0, 69, 0, 0, 0, 70, 0, 0, 0, 50, 0, 0, 0, 51, 0, 0, 0, 1, 0, 0,
0, 1, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 120, 27, 0, 0, 71, 0, 0, 0, 72, 0, 0, 0, 19, 0, 0, 0, 1, 0, 0, 0, 20, 0, 0, 0, 14, 0, 0, 0, 90, 78, 49, 54, 98, 50, 80, 97, 114, 116, 105, 99, 108, 101, 83, 121, 115, 116, 101, 109, 49, 52, 83, 111, 108, 118, 101, 67, 111, 108, 108, 105, 115, 105, 111, 110, 69, 82, 75, 49, 48, 98, 50, 84, 105, 109, 101, 83, 116, 101, 112, 69, 50, 50, 83, 111, 108, 118, 101, 67, 111, 108, 108, 105, 115, 105, 111, 110, 67, 97, 108, 108, 98, 97, 99, 107, 0, 0, 0, 0, 51, 48, 98, 50, 70, 105, 120, 116, 117, 114, 101, 80, 97, 114, 116, 105, 99, 108, 101, 81, 117, 101, 114, 121, 67, 97, 108, 108, 98, 97, 99,
107, 0, 0, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 64, 27, 0, 0, 248, 0, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 240, 26, 0, 0, 104, 27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 27, 0, 0, 73, 0, 0, 0, 74, 0, 0, 0, 19, 0, 0, 0, 1, 0, 0, 0, 20, 0, 0, 0, 15, 0, 0, 0, 90, 78, 49, 54, 98, 50, 80, 97, 114, 116, 105, 99, 108, 101, 83, 121, 115, 116, 101, 109, 49, 56, 85, 112, 100, 97, 116, 101, 66, 111, 100, 121, 67, 111, 110, 116, 97, 99, 116, 115, 69, 118, 69, 50, 54, 85, 112, 100, 97, 116, 101, 66, 111, 100, 121, 67, 111, 110, 116, 97, 99, 116, 115, 67, 97, 108, 108, 98, 97, 99, 107, 0, 88, 35, 0, 0, 168, 27, 0, 0, 104, 27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 168, 28, 0, 0, 75, 0, 0, 0, 76, 0, 0, 0, 16,
0, 0, 0, 0, 0, 0, 0, 90, 78, 49, 54, 98, 50, 80, 97, 114, 116, 105, 99, 108, 101, 83, 121, 115, 116, 101, 109, 50, 48, 85, 112, 100, 97, 116, 101, 80, 97, 105, 114, 115, 65, 110, 100, 84, 114, 105, 97, 100, 115, 69, 105, 105, 82, 75, 78, 83, 95, 49, 54, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 70, 105, 108, 116, 101, 114, 69, 69, 50, 48, 85, 112, 100, 97, 116, 101, 84, 114, 105, 97, 100, 115, 67, 97, 108, 108, 98, 97, 99, 107, 0, 0, 0, 0, 78, 49, 54, 98, 50, 86, 111, 114, 111, 110, 111, 105, 68, 105, 97, 103, 114, 97, 109, 49, 50, 78, 111, 100, 101, 67, 97, 108, 108, 98, 97, 99, 107, 69, 0, 0, 0, 0, 0, 0, 48, 35, 0, 0, 120, 28, 0, 0, 88,
35, 0, 0, 24, 28, 0, 0, 160, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 29, 0, 0, 77, 0, 0, 0, 78, 0, 0, 0, 21, 0, 0, 0, 7, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 90, 78, 49, 54, 98, 50, 80, 97, 114, 116, 105, 99, 108, 101, 83, 121, 115, 116, 101, 109, 52, 49, 85, 112, 100, 97, 116, 101, 80, 97, 105, 114, 115, 65, 110, 100, 84, 114, 105, 97, 100, 115, 87, 105, 116, 104, 82, 101, 97, 99, 116, 105, 118, 101, 80, 97, 114, 116, 105, 99, 108, 101, 115, 69, 118, 69, 49, 52, 82, 101, 97, 99, 116, 105, 118, 101, 70, 105, 108, 116, 101, 114, 0, 0, 0, 0, 0, 0, 78, 49, 54, 98, 50, 80, 97, 114, 116, 105, 99, 108, 101, 83, 121, 115, 116, 101, 109, 49, 54, 67, 111, 110, 110, 101,
99, 116, 105, 111, 110, 70, 105, 108, 116, 101, 114, 69, 0, 0, 48, 35, 0, 0, 48, 29, 0, 0, 88, 35, 0, 0, 216, 28, 0, 0, 88, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 29, 0, 0, 79, 0, 0, 0, 80, 0, 0, 0, 22, 0, 0, 0, 7, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 30, 0, 0, 81, 0, 0, 0, 82, 0, 0, 0, 22, 0, 0, 0, 8, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 90, 78, 49, 54, 98, 50, 80, 97, 114, 116, 105, 99, 108, 101, 83, 121, 115, 116, 101, 109, 49, 56, 74, 111, 105, 110, 80, 97, 114, 116, 105, 99, 108, 101, 71, 114, 111, 117, 112, 115, 69, 80, 49, 53, 98, 50, 80, 97, 114, 116, 105, 99, 108, 101, 71, 114, 111, 117, 112, 83, 49, 95, 69, 50, 52, 74, 111, 105, 110, 80, 97, 114, 116,
105, 99, 108, 101, 71, 114, 111, 117, 112, 115, 70, 105, 108, 116, 101, 114, 0, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 176, 29, 0, 0, 88, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 208, 30, 0, 0, 83, 0, 0, 0, 84, 0, 0, 0, 23, 0, 0, 0, 5, 0, 0, 0, 9, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 17, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 90, 78, 49, 54, 98, 50, 80, 97, 114, 116, 105, 99, 108, 101, 83, 121, 115, 116, 101, 109, 51, 51, 67, 114, 101, 97, 116, 101, 80, 97, 114, 116, 105, 99, 108, 101, 115, 87, 105, 116, 104, 83, 104, 97, 112, 101, 115, 70, 111, 114, 71, 114, 111, 117, 112, 69, 80, 75, 80, 75, 55, 98, 50, 83, 104, 97, 112, 101, 105, 82, 75, 49, 56, 98, 50, 80, 97, 114, 116, 105, 99,
108, 101, 71, 114, 111, 117, 112, 68, 101, 102, 82, 75, 49, 49, 98, 50, 84, 114, 97, 110, 115, 102, 111, 114, 109, 69, 49, 52, 67, 111, 109, 112, 111, 115, 105, 116, 101, 83, 104, 97, 112, 101, 0, 0, 0, 0, 0, 88, 35, 0, 0, 80, 30, 0, 0, 48, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 112, 31, 0, 0, 85, 0, 0, 0, 86, 0, 0, 0, 24, 0, 0, 0, 10, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 90, 78, 49, 54, 98, 50, 80, 97, 114, 116, 105, 99, 108, 101, 83, 121, 115, 116, 101, 109, 50, 51, 68, 101, 115, 116, 114, 111, 121, 80, 97, 114, 116, 105, 99, 108, 101, 115, 73, 110, 83, 104, 97, 112, 101, 69, 82, 75, 55, 98, 50, 83, 104, 97, 112, 101, 82, 75, 49, 49, 98, 50, 84, 114, 97, 110, 115,
102, 111, 114, 109, 98, 69, 51, 49, 68, 101, 115, 116, 114, 111, 121, 80, 97, 114, 116, 105, 99, 108, 101, 115, 73, 110, 83, 104, 97, 112, 101, 67, 97, 108, 108, 98, 97, 99, 107, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 0, 31, 0, 0, 248, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 32, 0, 0, 0, 64, 0, 0, 0, 96, 0, 0, 0, 128, 0, 0, 0, 160, 0, 0, 0, 192, 0, 0, 0, 224, 0, 0, 0, 0, 1, 0, 0, 64, 1, 0, 0, 128, 1, 0, 0, 192, 1, 0, 0, 0, 2, 0, 0, 128, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 76, 105, 113, 117, 105, 100, 70, 117, 110, 32, 49, 46, 49, 46, 48, 0, 104, 34, 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 83, 116, 57, 116, 121, 112, 101, 95, 105, 110, 102, 111, 0, 0, 0, 0, 48, 35, 0, 0, 160, 34, 0, 0, 78, 49, 48, 95, 95, 99, 120, 120, 97, 98, 105, 118, 49, 49, 54, 95, 95, 115, 104, 105, 109, 95, 116, 121, 112, 101, 95, 105, 110,
102, 111, 69, 0, 0, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 184, 34, 0, 0, 176, 34, 0, 0, 0, 0, 0, 0, 78, 49, 48, 95, 95, 99, 120, 120, 97, 98, 105, 118, 49, 49, 55, 95, 95, 99, 108, 97, 115, 115, 95, 116, 121, 112, 101, 95, 105, 110, 102, 111, 69, 0, 0, 0, 0, 0, 0, 0, 88, 35, 0, 0, 240, 34, 0, 0, 224, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 35, 0, 0, 87, 0, 0, 0, 88, 0, 0, 0, 89, 0, 0, 0, 90, 0, 0, 0, 11, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 160, 35, 0, 0, 87, 0, 0, 0, 91, 0, 0, 0, 89, 0, 0, 0, 90, 0, 0, 0, 11, 0, 0, 0, 7, 0, 0, 0, 2, 0, 0, 0, 19, 0, 0, 0, 78, 49, 48, 95, 95, 99, 120, 120, 97, 98, 105, 118, 49, 50, 48, 95, 95, 115, 105, 95, 99, 108, 97, 115, 115, 95, 116,
121, 112, 101, 95, 105, 110, 102, 111, 69, 0, 0, 0, 0, 88, 35, 0, 0, 120, 35, 0, 0, 24, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 232, 37, 0, 0, 92, 0, 0, 0, 93, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 115, 116, 100, 58, 58, 98, 97, 100, 95, 97, 108, 108, 111, 99, 0, 0, 83, 116, 57, 98, 97, 100, 95, 97, 108, 108, 111, 99, 0, 0, 0, 0, 88, 35, 0, 0, 216, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);
assert(tempDoublePtr % 8 == 0);
function copyTempFloat(ptr) {
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 _cosf() {
return Math_cos.apply(null, arguments)
}
function ___cxa_pure_virtual() {
ABORT = true;
throw "Pure virtual function called!";
}
function _b2WorldEndContactBody(contactPtr) {
b2World.EndContactBody(contactPtr)
}
function _floorf() {
return Math_floor.apply(null, arguments)
}
function __ZSt18uncaught_exceptionv() {
return !!__ZSt18uncaught_exceptionv.uncaught_exception
}
function ___cxa_is_number_type(type) {
var isNumber = false;
try {
if (type == __ZTIi)
isNumber = true
} catch (e) {}
try {
if (type == __ZTIj)
isNumber = true
} catch (e) {}
try {
if (type == __ZTIl)
isNumber = true
} catch (e) {}
try {
if (type == __ZTIm)
isNumber = true
} catch (e) {}
try {
if (type == __ZTIx)
isNumber = true
} catch (e) {}
try {
if (type == __ZTIy)
isNumber = true
} catch (e) {}
try {
if (type == __ZTIf)
isNumber = true
} catch (e) {}
try {
if (type == __ZTId)
isNumber = true
} catch (e) {}
try {
if (type == __ZTIe)
isNumber = true
} catch (e) {}
try {
if (type == __ZTIc)
isNumber = true
} catch (e) {}
try {
if (type ==
__ZTIa)
isNumber = true
} catch (e) {}
try {
if (type == __ZTIh)
isNumber = true
} catch (e) {}
try {
if (type == __ZTIs)
isNumber = true
} catch (e) {}
try {
if (type == __ZTIt)
isNumber = true
} catch (e) {}
return isNumber
}
function ___cxa_does_inherit(definiteType, possibilityType, possibility) {
if (possibility == 0)
return false;
if (possibilityType == 0 || possibilityType == definiteType)
return true;
var possibility_type_info;
if (___cxa_is_number_type(possibilityType))
possibility_type_info = possibilityType;
else {
var possibility_type_infoAddr = HEAP32[possibilityType >> 2] - 8;
possibility_type_info = HEAP32[possibility_type_infoAddr >> 2]
}
switch (possibility_type_info) {
case 0:
var definite_type_infoAddr = HEAP32[definiteType >> 2] - 8;
var definite_type_info =
HEAP32[definite_type_infoAddr >> 2];
if (definite_type_info == 0) {
var defPointerBaseAddr = definiteType + 8;
var defPointerBaseType = HEAP32[defPointerBaseAddr >> 2];
var possPointerBaseAddr = possibilityType + 8;
var possPointerBaseType = HEAP32[possPointerBaseAddr >> 2];
return ___cxa_does_inherit(defPointerBaseType, possPointerBaseType, possibility)
} else
return false;
case 1:
return false;
case 2:
var parentTypeAddr = possibilityType + 8;
var parentType = HEAP32[parentTypeAddr >> 2];
return ___cxa_does_inherit(definiteType, parentType,
possibility);
default:
return false
}
}
var ___cxa_last_thrown_exception = 0;
function ___resumeException(ptr) {
if (!___cxa_last_thrown_exception)
___cxa_last_thrown_exception = ptr;
throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch.";
}
var ___cxa_exception_header_size = 8;
function ___cxa_find_matching_catch(thrown, throwntype) {
if (thrown == -1)
thrown = ___cxa_last_thrown_exception;
header = thrown - ___cxa_exception_header_size;
if (throwntype == -1)
throwntype = HEAP32[header >> 2];
var typeArray = Array.prototype.slice.call(arguments, 2);
if (throwntype != 0 && !___cxa_is_number_type(throwntype)) {
var throwntypeInfoAddr = HEAP32[throwntype >> 2] - 8;
var throwntypeInfo = HEAP32[throwntypeInfoAddr >> 2];
if (throwntypeInfo == 0)
thrown = HEAP32[thrown >> 2]
}
for (var i = 0; i < typeArray.length; i++)
if (___cxa_does_inherit(typeArray[i],
throwntype, thrown))
return (asm["setTempRet0"](typeArray[i]), thrown) | 0;
return (asm["setTempRet0"](throwntype), thrown) | 0
}
function ___cxa_throw(ptr, type, destructor) {
if (!___cxa_throw.initialized) {
try {
HEAP32[__ZTVN10__cxxabiv119__pointer_type_infoE >> 2] = 0
} catch (e) {}
try {
HEAP32[__ZTVN10__cxxabiv117__class_type_infoE >> 2] = 1
} catch (e) {}
try {
HEAP32[__ZTVN10__cxxabiv120__si_class_type_infoE >> 2] = 2
} catch (e) {}
___cxa_throw.initialized = true
}
var header = ptr - ___cxa_exception_header_size;
HEAP32[header >> 2] = type;
HEAP32[header + 4 >> 2] = destructor;
___cxa_last_thrown_exception = ptr;
if (!("uncaught_exception" in __ZSt18uncaught_exceptionv))
__ZSt18uncaught_exceptionv.uncaught_exception =
1;
else
__ZSt18uncaught_exceptionv.uncaught_exception++;
throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch.";
}
Module["_memset"] = _memset;
function _b2WorldRayCastCallback(fixturePtr, pointX, pointY, normalX, normalY, fraction) {
return b2World.RayCast(fixturePtr, pointX, pointY, normalX, normalY, fraction)
}
var _FtoIHigh = true;
function __exit(status) {
Module["exit"](status)
}
function _exit(status) {
__exit(status)
}
function __ZSt9terminatev() {
_exit(-1234)
}
function _abort() {
Module["abort"]()
}
function _b2WorldBeginContactBody(contactPtr) {
b2World.BeginContactBody(contactPtr)
}
var ___cxa_caught_exceptions = [];
function ___cxa_begin_catch(ptr) {
__ZSt18uncaught_exceptionv.uncaught_exception--;
___cxa_caught_exceptions.push(___cxa_last_thrown_exception);
return ptr
}
function _sinf() {
return Math_sin.apply(null, arguments)
}
function _b2WorldPostSolve(contactPtr, impulsePtr) {
b2World.PostSolve(contactPtr, impulsePtr)
}
Module["_strlen"] = _strlen;
function _sqrtf() {
return Math_sqrt.apply(null, arguments)
}
function _b2WorldQueryAABB(fixturePtr) {
return b2World.QueryAABB(fixturePtr)
}
Module["_i64Add"] = _i64Add;
function _sbrk(bytes) {
var self = _sbrk;
if (!self.called) {
DYNAMICTOP = alignMemoryPage(DYNAMICTOP);
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
}
function _emscripten_memcpy_big(dest, src, num) {
HEAPU8.set(HEAPU8.subarray(src, src + num), dest);
return dest
}
Module["_memcpy"] = _memcpy;
Module["_memmove"] = _memmove;
var ___errno_state = 0;
function ___setErrNo(value) {
HEAP32[___errno_state >> 2] = value;
return value
}
function ___errno_location() {
return ___errno_state
}
var _FtoILow = true;
function __ZNSt9exceptionD2Ev() {}
function _b2WorldPreSolve(contactPtr, oldManifoldPtr) {
b2World.PreSolve(contactPtr, oldManifoldPtr)
}
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
};
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() {},
shutdown: function() {},
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) {
if (stream.tty.output.length)
stream.tty.ops.put_char(stream.tty, 10)
},
read: function(stream, buffer, offset, length, pos) {
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;
return undefined
}
} else if (typeof window != "undefined" && typeof window.prompt ==
"function") {
result = window.prompt("Input: ");
if (result !== null)
result += "\n"
} else if (typeof readline == "function") {
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,
mount: function(mount) {
return MEMFS.createNode(null, "/", 16384 | 511, 0)
},
createNode: function(parent, name, mode, dev) {
if (FS.isBlkdev(mode) || FS.isFIFO(mode))
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,
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.usedBytes = 0;
node.contents = null
} 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();
if (parent)
parent.contents[name] = node;
return node
},
getFileDataAsRegularArray: function(node) {
if (node.contents && node.contents.subarray) {
var arr = [];
for (var i = 0; i < node.usedBytes; ++i)
arr.push(node.contents[i]);
return arr
}
return node.contents
},
getFileDataAsTypedArray: function(node) {
if (node.contents && node.contents.subarray)
return node.contents.subarray(0, node.usedBytes);
return new Uint8Array(node.contents)
},
expandFileStorage: function(node,
newCapacity) {
if (node.contents && node.contents.subarray && newCapacity > node.contents.length) {
node.contents = MEMFS.getFileDataAsRegularArray(node);
node.usedBytes = node.contents.length
}
if (!node.contents || node.contents.subarray) {
var prevCapacity = node.contents ? node.contents.buffer.byteLength : 0;
if (prevCapacity >= newCapacity)
return;
var CAPACITY_DOUBLING_MAX = 1024 * 1024;
newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) | 0);
if (prevCapacity != 0)
newCapacity = Math.max(newCapacity,
256);
var oldContents = node.contents;
node.contents = new Uint8Array(newCapacity);
if (node.usedBytes > 0)
node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
return
}
if (!node.contents && newCapacity > 0)
node.contents = [];
while (node.contents.length < newCapacity)
node.contents.push(0)
},
resizeFileStorage: function(node, newSize) {
if (node.usedBytes == newSize)
return;
if (newSize == 0) {
node.contents = null;
node.usedBytes = 0;
return
}
if (!node.contents || node.contents.subarray) {
var oldContents = node.contents;
node.contents = new Uint8Array(new ArrayBuffer(newSize));
node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
node.usedBytes = newSize;
return
}
if (!node.contents)
node.contents = [];
if (node.contents.length > newSize)
node.contents.length = newSize;
else
while (node.contents.length < newSize)
node.contents.push(0);
node.usedBytes = newSize
},
node_ops: {
getattr: function(node) {
var attr = {};
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.usedBytes;
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);
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.resizeFileStorage(node, attr.size)
},
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 (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);
}
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, 511 | 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 >= stream.node.usedBytes)
return 0;
var size = Math.min(stream.node.usedBytes - position, length);
assert(size >= 0);
if (size > 8 && contents.subarray)
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) {
if (!length)
return 0;
var node = stream.node;
node.timestamp = Date.now();
if (buffer.subarray && (!node.contents || node.contents.subarray))
if (canOwn) {
node.contents = buffer.subarray(offset, offset + length);
node.usedBytes = length;
return length
} else if (node.usedBytes === 0 && position === 0) {
node.contents = new Uint8Array(buffer.subarray(offset, offset + length));
node.usedBytes = length;
return length
} else if (position + length <= node.usedBytes) {
node.contents.set(buffer.subarray(offset,
offset + length), position);
return length
}
MEMFS.expandFileStorage(node, position + length);
if (node.contents.subarray && buffer.subarray)
node.contents.set(buffer.subarray(offset, offset + length), position);
else
for (var i = 0; i < length; i++)
node.contents[position + i] = buffer[offset + i];
node.usedBytes = Math.max(node.usedBytes, position + length);
return length
},
llseek: function(stream, offset, whence) {
var position = offset;
if (whence === 1)
position += stream.position;
else if (whence === 2)
if (FS.isFile(stream.node.mode))
position += stream.node.usedBytes;
if (position < 0)
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
stream.ungotten = [];
stream.position = position;
return position
},
allocate: function(stream, offset, length) {
MEMFS.expandFileStorage(stream.node, offset + length);
stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length)
},
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;
if (!(flags & 2) && (contents.buffer ===
buffer || contents.buffer === buffer.buffer)) {
allocated = false;
ptr = contents.byteOffset
} else {
if (position > 0 || position + length < stream.node.usedBytes)
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: 21,
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)
})
})
},
getDB: function(name, callback) {
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 callback(e)
}
req.onupgradeneeded = function(e) {
var db = e.target.result;
var transaction = e.target.transaction;
var fileStore;
if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME))
fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
else
fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME);
fileStore.createIndex("timestamp", "timestamp",
{
unique: false
})
};
req.onsuccess = function() {
db = req.result;
IDBFS.dbs[name] = db;
callback(null, db)
};
req.onerror = function() {
callback(this.error)
}
},
getLocalSet: function(mount, callback) {
var entries = {};
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;
try {
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)));
entries[path] = {
timestamp: stat.mtime
}
}
return callback(null, {
type: "local",
entries: entries
})
},
getRemoteSet: function(mount, callback) {
var entries = {};
IDBFS.getDB(mount.mountpoint, function(err, db) {
if (err)
return callback(err);
var transaction = db.transaction([IDBFS.DB_STORE_NAME], "readonly");
transaction.onerror = function() {
callback(this.error)
};
var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
var index = store.index("timestamp");
index.openKeyCursor().onsuccess =
function(event) {
var cursor = event.target.result;
if (!cursor)
return callback(null, {
type: "remote",
db: db,
entries: entries
});
entries[cursor.primaryKey] = {
timestamp: cursor.key
};
cursor.continue()
}
})
},
loadLocalEntry: function(path, callback) {
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))
return callback(null, {
timestamp: stat.mtime,
mode: stat.mode
});
else if (FS.isFile(stat.mode)) {
node.contents = MEMFS.getFileDataAsTypedArray(node);
return callback(null, {
timestamp: stat.mtime,
mode: stat.mode,
contents: node.contents
})
} else
return callback(new Error("node type not supported"))
},
storeLocalEntry: function(path, entry, callback) {
try {
if (FS.isDir(entry.mode))
FS.mkdir(path, entry.mode);
else if (FS.isFile(entry.mode))
FS.writeFile(path, entry.contents, {
encoding: "binary",
canOwn: true
});
else
return callback(new Error("node type not supported"));
FS.utime(path, entry.timestamp, entry.timestamp)
} catch (e) {
return callback(e)
}
callback(null)
},
removeLocalEntry: function(path,
callback) {
try {
var lookup = FS.lookupPath(path);
var stat = FS.stat(path);
if (FS.isDir(stat.mode))
FS.rmdir(path);
else if (FS.isFile(stat.mode))
FS.unlink(path)
} catch (e) {
return callback(e)
}
callback(null)
},
loadRemoteEntry: function(store, path, callback) {
var req = store.get(path);
req.onsuccess = function(event) {
callback(null, event.target.result)
};
req.onerror = function() {
callback(this.error)
}
},
storeRemoteEntry: function(store, path, entry, callback) {
var req = store.put(entry, path);
req.onsuccess = function() {
callback(null)
};
req.onerror = function() {
callback(this.error)
}
},
removeRemoteEntry: function(store, path, callback) {
var req = store.delete(path);
req.onsuccess = function() {
callback(null)
};
req.onerror = function() {
callback(this.error)
}
},
reconcile: function(src, dst, callback) {
var total = 0;
var create = [];
Object.keys(src.entries).forEach(function(key) {
var e = src.entries[key];
var e2 = dst.entries[key];
if (!e2 || e.timestamp > e2.timestamp) {
create.push(key);
total++
}
});
var remove = [];
Object.keys(dst.entries).forEach(function(key) {
var e = dst.entries[key];
var e2 = src.entries[key];
if (!e2) {
remove.push(key);
total++
}
});
if (!total)
return callback(null);
var errored = false;
var completed = 0;
var db = src.type === "remote" ? src.db : dst.db;
var transaction = db.transaction([IDBFS.DB_STORE_NAME], "readwrite");
var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
function done(err) {
if (err) {
if (!done.errored) {
done.errored = true;
return callback(err)
}
return
}
if (++completed >= total)
return callback(null)
}
transaction.onerror = function() {
done(this.error)
};
create.sort().forEach(function(path) {
if (dst.type ===
"local")
IDBFS.loadRemoteEntry(store, path, function(err, entry) {
if (err)
return done(err);
IDBFS.storeLocalEntry(path, entry, done)
});
else
IDBFS.loadLocalEntry(path, function(err, entry) {
if (err)
return done(err);
IDBFS.storeRemoteEntry(store, path, entry, done)
})
});
remove.sort().reverse().forEach(function(path) {
if (dst.type === "local")
IDBFS.removeLocalEntry(path, done);
else
IDBFS.removeRemoteEntry(store, path, done)
})
}
};
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)
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]);
}
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);
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);
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) {
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) {
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)
position += stream.position;
else if (whence === 2)
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) {}
var FS = {
root: null,
mounts: [],
devices: [null],
streams: [],
nextInode: 1,
nameTable: null,
currentPath: "/",
initialized: false,
ignorePermissions: true,
trackingDelegate: {},
tracking: {
openFlags: {
READ: 1,
WRITE: 2
}
},
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 || {};
var defaults = {
follow_mount: true,
recurse_count: 0
};
for (var key in defaults)
if (opts[key] === undefined)
opts[key] =
defaults[key];
if (opts.recurse_count > 8)
throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
var parts = PATH.normalizeArray(path.split("/").filter(function(p) {
return !!p
}), false);
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)
break;
current = FS.lookupNode(current, parts[i]);
current_path = PATH.join2(current_path, parts[i]);
if (FS.isMountpoint(current))
if (!islast || islast && opts.follow_mount)
current = current.mounted.root;
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)
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
}
return FS.lookup(parent, name)
},
createNode: function(parent, name, mode, rdev) {
if (!FS.FSNode) {
FS.FSNode =
function(parent, name, mode, rdev) {
if (!parent)
parent = this;
this.parent = parent;
this.mount = parent.mount;
this.mounted = null;
this.id = FS.nextInode++;
this.name = name;
this.mode = mode;
this.node_ops = {};
this.stream_ops = {};
this.rdev = rdev
};
FS.FSNode.prototype = {};
var readMode = 292 | 73;
var writeMode = 146;
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)
}
}
})
}
var node = new FS.FSNode(parent, name, mode, rdev);
FS.hashAddNode(node);
return node
},
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;
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 || 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 || 0;
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 = {};
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
}
}
})
}
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
},
getStreamFromPtr: function(ptr) {
return FS.streams[ptr - 1]
},
getPtrForStream: function(stream) {
return stream ? stream.fd + 1 : 0
},
chrdev_stream_ops: {
open: function(stream) {
var device = FS.getDevice(stream.node.rdev);
stream.stream_ops = device.stream_ops;
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 &
255
},
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]
},
getMounts: function(mount) {
var mounts = [];
var check = [mount];
while (check.length) {
var m = check.pop();
mounts.push(m);
check.push.apply(check, m.mounts)
}
return mounts
},
syncfs: function(populate, callback) {
if (typeof populate === "function") {
callback = populate;
populate = false
}
var mounts = FS.getMounts(FS.root.mount);
var completed = 0;
function done(err) {
if (err) {
if (!done.errored) {
done.errored =
true;
return callback(err)
}
return
}
if (++completed >= mounts.length)
callback(null)
}
mounts.forEach(function(mount) {
if (!mount.type.syncfs)
return done(null);
mount.type.syncfs(mount, populate, done)
})
},
mount: function(type, opts, mountpoint) {
var root = mountpoint === "/";
var pseudo = !mountpoint;
var node;
if (root && FS.root)
throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
else if (!root && !pseudo) {
var lookup = FS.lookupPath(mountpoint, {
follow_mount: false
});
mountpoint = lookup.path;
node = lookup.node;
if (FS.isMountpoint(node))
throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
if (!FS.isDir(node.mode))
throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
}
var mount = {
type: type,
opts: opts,
mountpoint: mountpoint,
mounts: []
};
var mountRoot = type.mount(mount);
mountRoot.mount = mount;
mount.root = mountRoot;
if (root)
FS.root = mountRoot;
else if (node) {
node.mounted = mount;
if (node.mount)
node.mount.mounts.push(mount)
}
return mountRoot
},
unmount: function(mountpoint) {
var lookup = FS.lookupPath(mountpoint, {
follow_mount: false
});
if (!FS.isMountpoint(lookup.node))
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
var node =
lookup.node;
var mount = node.mounted;
var mounts = FS.getMounts(mount);
Object.keys(FS.nameTable).forEach(function(hash) {
var current = FS.nameTable[hash];
while (current) {
var next = current.name_next;
if (mounts.indexOf(current.mount) !== -1)
FS.destroyNode(current);
current = next
}
});
node.mounted = null;
var idx = node.mount.mounts.indexOf(mount);
assert(idx !== -1);
node.mount.mounts.splice(idx, 1)
},
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 : 438;
mode &= 4095;
mode |= 32768;
return FS.mknod(path, mode, 0)
},
mkdir: function(path, mode) {
mode = mode !== undefined ? mode : 511;
mode &= 511 | 512;
mode |= 16384;
return FS.mknod(path, mode, 0)
},
mkdev: function(path,
mode, dev) {
if (typeof dev === "undefined") {
dev = mode;
mode = 438
}
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);
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);
}
if (old_dir.mount !== new_dir.mount)
throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
var old_node = FS.lookupNode(old_dir, old_name);
var relative = PATH.relative(old_path, new_dirname);
if (relative.charAt(0) !==
".")
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
relative = PATH.relative(new_path, old_dirname);
if (relative.charAt(0) !== ".")
throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
var new_node;
try {
new_node = FS.lookupNode(new_dir, new_name)
} catch (e) {}
if (old_node === new_node)
return;
var isdir = FS.isDir(old_node.mode);
var err = FS.mayDelete(old_dir, old_name, isdir);
if (err)
throw new FS.ErrnoError(err);
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 (new_dir !== old_dir) {
err = FS.nodePermissions(old_dir, "w");
if (err)
throw new FS.ErrnoError(err);
}
try {
if (FS.trackingDelegate["willMovePath"])
FS.trackingDelegate["willMovePath"](old_path, new_path)
} catch (e) {
console.log("FS.trackingDelegate['willMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message)
}
FS.hashRemoveNode(old_node);
try {
old_dir.node_ops.rename(old_node, new_dir, new_name)
} catch (e) {
throw e;
} finally {
FS.hashAddNode(old_node)
}
try {
if (FS.trackingDelegate["onMovePath"])
FS.trackingDelegate["onMovePath"](old_path, new_path)
} catch (e) {
console.log("FS.trackingDelegate['onMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message)
}
},
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);
try {
if (FS.trackingDelegate["willDeletePath"])
FS.trackingDelegate["willDeletePath"](path)
} catch (e) {
console.log("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message)
}
parent.node_ops.rmdir(parent, name);
FS.destroyNode(node);
try {
if (FS.trackingDelegate["onDeletePath"])
FS.trackingDelegate["onDeletePath"](path)
} catch (e) {
console.log("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message)
}
},
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) {
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);
try {
if (FS.trackingDelegate["willDeletePath"])
FS.trackingDelegate["willDeletePath"](path)
} catch (e) {
console.log("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message)
}
parent.node_ops.unlink(parent, name);
FS.destroyNode(node);
try {
if (FS.trackingDelegate["onDeletePath"])
FS.trackingDelegate["onDeletePath"](path)
} catch (e) {
console.log("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message)
}
},
readlink: function(path) {
var lookup = FS.lookupPath(path);
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()
})
},
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" ? 438 : 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) {}
}
if (flags & 64)
if (node) {
if (flags & 128)
throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
} else
node = FS.mknod(path, mode, 0);
if (!node)
throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
if (FS.isChrdev(node.mode))
flags &= ~512;
var err = FS.mayOpen(node, flags);
if (err)
throw new FS.ErrnoError(err);
if (flags & 512)
FS.truncate(node, 0);
flags &= ~(128 | 512);
var stream = FS.createStream({
node: node,
path: FS.getPath(node),
flags: flags,
seekable: true,
position: 0,
stream_ops: node.stream_ops,
ungotten: [],
error: false
}, fd_start, fd_end);
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)
}
}
try {
if (FS.trackingDelegate["onOpenFile"]) {
var trackingFlags = 0;
if ((flags & 2097155) !== 1)
trackingFlags |= FS.tracking.openFlags.READ;
if ((flags & 2097155) !== 0)
trackingFlags |= FS.tracking.openFlags.WRITE;
FS.trackingDelegate["onOpenFile"](path, trackingFlags)
}
} catch (e) {
console.log("FS.trackingDelegate['onOpenFile']('" + path + "', flags) threw an exception: " + e.message)
}
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);
if (stream.flags & 1024)
FS.llseek(stream,
0, 2);
var seeking = true;
if (typeof position === "undefined") {
position = stream.position;
seeking = false
} else if (!stream.seekable)
throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
if (!seeking)
stream.position += bytesWritten;
try {
if (stream.path && FS.trackingDelegate["onWriteToFile"])
FS.trackingDelegate["onWriteToFile"](stream.path)
} catch (e) {
console.log("FS.trackingDelegate['onWriteToFile']('" + path + "') threw an exception: " + e.message)
}
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) {
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";
if (opts.encoding !== "utf8" && opts.encoding !== "binary")
throw new Error('Invalid encoding type "' +
opts.encoding + '"');
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;
FS.close(stream);
return ret
},
writeFile: function(path, data, opts) {
opts = opts || {};
opts.flags = opts.flags || "w";
opts.encoding = opts.encoding || "utf8";
if (opts.encoding !== "utf8" &&
opts.encoding !== "binary")
throw new Error('Invalid encoding type "' + opts.encoding + '"');
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, opts.canOwn)
} else if (opts.encoding === "binary")
FS.write(stream, data, 0, data.length, 0, opts.canOwn);
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() {
FS.mkdir("/dev");
FS.registerDevice(FS.makedev(1, 3), {
read: function() {
return 0
},
write: function() {
return 0
}
});
FS.mkdev("/dev/null", FS.makedev(1, 3));
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));
FS.mkdir("/dev/shm");
FS.mkdir("/dev/shm/tmp")
},
createStandardStreams: function() {
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");
var stdin = FS.open("/dev/stdin", "r");
HEAP32[_stdin >> 2] = FS.getPtrForStream(stdin);
assert(stdin.fd === 0, "invalid handle for stdin (" + stdin.fd + ")");
var stdout = FS.open("/dev/stdout", "w");
HEAP32[_stdout >> 2] = FS.getPtrForStream(stdout);
assert(stdout.fd === 1, "invalid handle for stdout (" + stdout.fd + ")");
var stderr = FS.open("/dev/stderr", "w");
HEAP32[_stderr >> 2] = FS.getPtrForStream(stderr);
assert(stderr.fd === 2, "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]
};
FS.ErrnoError.prototype = new Error;
FS.ErrnoError.prototype.constructor = FS.ErrnoError;
[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.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();
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) {
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) {}
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
}
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);
FS.registerDevice(dev, {
open: function(stream) {
stream.seekable = false
},
close: function(stream) {
if (output && output.buffer && output.buffer.length)
output(10)
},
read: function(stream, buffer, offset, length, pos) {
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"])
try {
obj.contents = intArrayFromString(Module["read"](obj.url), true);
obj.usedBytes = obj.contents.length
} 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) {
function LazyUint8Array() {
this.lengthKnown = false;
this.chunks = []
}
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() {
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;
if (!hasByteServing)
chunkSize = datalength;
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!");
var xhr = new XMLHttpRequest;
xhr.open("GET", url, false);
if (datalength !== chunkSize)
xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
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;
end = Math.min(end, datalength - 1);
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
};
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";
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);
if (properties.contents)
node.contents = properties.contents;
else if (properties.url) {
node.contents = null;
node.url = properties.url
}
Object.defineProperty(node, "usedBytes", {
get: function() {
return this.contents.length
}
});
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)
}
});
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)
for (var i =
0; i < size; i++)
buffer[offset + i] = contents[position + i];
else
for (var i = 0; i < size; i++)
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();
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;
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) {
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 (allowAboveRoot)
for (; up--; up)
parts.unshift("..");
return parts
},
normalize: function(path) {
var isAbsolute = path.charAt(0) ===
"/",
trailingSlash = path.substr(-1) === "/";
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)
return ".";
if (dir)
dir = dir.substr(0, dir.length - 1);
return root + dir
},
basename: function(path) {
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();
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) === "/"
}
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,
method: "",
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"] = [];
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
}
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)
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);
b = bb.getBlob()
}
var url = Browser.URLObject.createObjectURL(b);
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;
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);
var audio = new Audio;
audio.addEventListener("canplaythrough", function() {
finish(audio)
}, false);
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 & 63;
leftbits -= 6;
ret += BASE[curr]
}
}
if (leftbits == 2) {
ret += BASE[(leftchar & 3) << 4];
ret += PAD + PAD
} else if (leftbits == 4) {
ret += BASE[(leftchar & 15) << 2];
ret += PAD
}
return ret
}
audio.src = "data:audio/x-" + name.substr(-3) + ";base64," + encode64(byteArray);
finish(audio)
};
audio.src = url;
Browser.safeSetTimeout(function() {
finish(audio)
}, 1E4)
} else
return fail()
};
Module["preloadPlugins"].push(audioPlugin);
var canvas = Module["canvas"];
if (canvas) {
canvas.requestPointerLock = canvas["requestPointerLock"] || canvas["mozRequestPointerLock"] || canvas["webkitRequestPointerLock"] || canvas["msRequestPointerLock"] || function() {};
canvas.exitPointerLock = document["exitPointerLock"] || document["mozExitPointerLock"] || document["webkitExitPointerLock"] || document["msExitPointerLock"] ||
function() {};
canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
function pointerLockChange() {
Browser.pointerLock = document["pointerLockElement"] === canvas || document["mozPointerLockElement"] === canvas || document["webkitPointerLockElement"] === canvas || document["msPointerLockElement"] === canvas
}
document.addEventListener("pointerlockchange", pointerLockChange, false);
document.addEventListener("mozpointerlockchange", pointerLockChange, false);
document.addEventListener("webkitpointerlockchange", pointerLockChange,
false);
document.addEventListener("mspointerlockchange", 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;
var errorInfo = "?";
function onContextCreationError(event) {
errorInfo = event.statusMessage || errorInfo
}
try {
if (useWebGL) {
var contextAttributes = {
antialias: false,
alpha: false
};
if (webGLContextAttributes)
for (var attribute in webGLContextAttributes)
contextAttributes[attribute] = webGLContextAttributes[attribute];
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)
canvas.style.backgroundColor = "black";
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;
var canvasContainer = canvas.parentNode;
if ((document["webkitFullScreenElement"] || document["webkitFullscreenElement"] || document["mozFullScreenElement"] || document["mozFullscreenElement"] || document["fullScreenElement"] || document["fullscreenElement"] || document["msFullScreenElement"] || document["msFullscreenElement"] ||
document["webkitCurrentFullScreenElement"]) === canvasContainer) {
canvas.cancelFullScreen = document["cancelFullScreen"] || document["mozCancelFullScreen"] || document["webkitCancelFullScreen"] || document["msExitFullscreen"] || document["exitFullscreen"] || function() {};
canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document);
if (Browser.lockPointer)
canvas.requestPointerLock();
Browser.isFullScreen = true;
if (Browser.resizeCanvas)
Browser.setFullScreenCanvasSize()
} else {
canvasContainer.parentNode.insertBefore(canvas,
canvasContainer);
canvasContainer.parentNode.removeChild(canvasContainer);
if (Browser.resizeCanvas)
Browser.setWindowedCanvasSize()
}
if (Module["onFullScreen"])
Module["onFullScreen"](Browser.isFullScreen);
Browser.updateCanvasDimensions(canvas)
}
if (!Browser.fullScreenHandlersInstalled) {
Browser.fullScreenHandlersInstalled = true;
document.addEventListener("fullscreenchange", fullScreenChange, false);
document.addEventListener("mozfullscreenchange", fullScreenChange, false);
document.addEventListener("webkitfullscreenchange",
fullScreenChange, false);
document.addEventListener("MSFullscreenChange", fullScreenChange, false)
}
var canvasContainer = document.createElement("div");
canvas.parentNode.insertBefore(canvasContainer, canvas);
canvasContainer.appendChild(canvas);
canvasContainer.requestFullScreen = canvasContainer["requestFullScreen"] || canvasContainer["mozRequestFullScreen"] || canvasContainer["msRequestFullscreen"] || (canvasContainer["webkitRequestFullScreen"] ? function() {
canvasContainer["webkitRequestFullScreen"](Element["ALLOW_KEYBOARD_INPUT"])
} :
null);
canvasContainer.requestFullScreen()
},
requestAnimationFrame: function requestAnimationFrame(func) {
if (typeof window === "undefined")
setTimeout(func, 1E3 / 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) {
Module["noExitRuntime"] = true;
return setTimeout(function() {
if (!ABORT)
func()
}, timeout)
},
safeSetInterval: function(func, timeout) {
Module["noExitRuntime"] = true;
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
},
getMouseWheelDelta: function(event) {
var delta = 0;
switch (event.type) {
case "DOMMouseScroll":
delta =
event.detail;
break;
case "mousewheel":
delta = -event.wheelDelta;
break;
case "wheel":
delta = event.deltaY;
break;
default:
throw "unrecognized mouse wheel event: " + event.type;
}
return Math.max(-1, Math.min(1, delta))
},
mouseX: 0,
mouseY: 0,
mouseMovementX: 0,
mouseMovementY: 0,
touches: {},
lastTouches: {},
calculateMouseEvent: function(event) {
if (Browser.pointerLock) {
if (event.type != "mousemove" && "mozMovementX" in event)
Browser.mouseMovementX = Browser.mouseMovementY = 0;
else {
Browser.mouseMovementX = Browser.getMovementX(event);
Browser.mouseMovementY =
Browser.getMovementY(event)
}
if (typeof SDL != "undefined") {
Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
Browser.mouseY = SDL.mouseY + Browser.mouseMovementY
} else {
Browser.mouseX += Browser.mouseMovementX;
Browser.mouseY += Browser.mouseMovementY
}
} else {
var rect = Module["canvas"].getBoundingClientRect();
var cw = Module["canvas"].width;
var ch = Module["canvas"].height;
var scrollX = typeof window.scrollX !== "undefined" ? window.scrollX : window.pageXOffset;
var scrollY = typeof window.scrollY !== "undefined" ? window.scrollY : window.pageYOffset;
if (event.type === "touchstart" || event.type === "touchend" || event.type === "touchmove") {
var touch = event.touch;
if (touch === undefined)
return;
var adjustedX = touch.pageX - (scrollX + rect.left);
var adjustedY = touch.pageY - (scrollY + rect.top);
adjustedX = adjustedX * (cw / rect.width);
adjustedY = adjustedY * (ch / rect.height);
var coords = {
x: adjustedX,
y: adjustedY
};
if (event.type === "touchstart") {
Browser.lastTouches[touch.identifier] = coords;
Browser.touches[touch.identifier] = coords
} else if (event.type === "touchend" || event.type === "touchmove") {
Browser.lastTouches[touch.identifier] =
Browser.touches[touch.identifier];
Browser.touches[touch.identifier] = {
x: adjustedX,
y: adjustedY
}
}
return
}
var x = event.pageX - (scrollX + rect.left);
var y = event.pageY - (scrollY + rect.top);
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)
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"];
Browser.updateCanvasDimensions(canvas, width, height);
if (!noUpdates)
Browser.updateResizeListeners()
},
windowedWidth: 0,
windowedHeight: 0,
setFullScreenCanvasSize: function() {
if (typeof SDL != "undefined") {
var flags = HEAPU32[SDL.screen + Runtime.QUANTUM_SIZE * 0 >> 2];
flags = flags | 8388608;
HEAP32[SDL.screen +
Runtime.QUANTUM_SIZE * 0 >> 2] = flags
}
Browser.updateResizeListeners()
},
setWindowedCanvasSize: function() {
if (typeof SDL != "undefined") {
var flags = HEAPU32[SDL.screen + Runtime.QUANTUM_SIZE * 0 >> 2];
flags = flags & ~8388608;
HEAP32[SDL.screen + Runtime.QUANTUM_SIZE * 0 >> 2] = flags
}
Browser.updateResizeListeners()
},
updateCanvasDimensions: function(canvas, wNative, hNative) {
if (wNative && hNative) {
canvas.widthNative = wNative;
canvas.heightNative = hNative
} else {
wNative = canvas.widthNative;
hNative = canvas.heightNative
}
var w = wNative;
var h = hNative;
if (Module["forcedAspectRatio"] && Module["forcedAspectRatio"] > 0)
if (w / h < Module["forcedAspectRatio"])
w = Math.round(h * Module["forcedAspectRatio"]);
else
h = Math.round(w / Module["forcedAspectRatio"]);
if ((document["webkitFullScreenElement"] || document["webkitFullscreenElement"] || document["mozFullScreenElement"] || document["mozFullscreenElement"] || document["fullScreenElement"] || document["fullscreenElement"] || document["msFullScreenElement"] || document["msFullscreenElement"] || document["webkitCurrentFullScreenElement"]) ===
canvas.parentNode && typeof screen != "undefined") {
var factor = Math.min(screen.width / w, screen.height / h);
w = Math.round(w * factor);
h = Math.round(h * factor)
}
if (Browser.resizeCanvas) {
if (canvas.width != w)
canvas.width = w;
if (canvas.height != h)
canvas.height = h;
if (typeof canvas.style != "undefined") {
canvas.style.removeProperty("width");
canvas.style.removeProperty("height")
}
} else {
if (canvas.width != wNative)
canvas.width = wNative;
if (canvas.height != hNative)
canvas.height = hNative;
if (typeof canvas.style != "undefined")
if (w != wNative ||
h != hNative) {
canvas.style.setProperty("width", w + "px", "important");
canvas.style.setProperty("height", h + "px", "important")
} else {
canvas.style.removeProperty("width");
canvas.style.removeProperty("height")
}
}
}
};
function _time(ptr) {
var ret = Math.floor(Date.now() / 1E3);
if (ptr)
HEAP32[ptr >> 2] = ret;
return ret
}
function _sysconf(name) {
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 1E3;
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 _malloc(bytes) {
var ptr = Runtime.dynamicAlloc(bytes + 8);
return ptr + 8 & 4294967288
}
Module["_malloc"] = _malloc;
function ___cxa_allocate_exception(size) {
var ptr = _malloc(size + ___cxa_exception_header_size);
return ptr + ___cxa_exception_header_size
}
var __ZTISt9exception = allocate([allocate([1, 0, 0, 0, 0, 0, 0], "i8", ALLOC_STATIC) + 8, 0], "i32", ALLOC_STATIC);
___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;
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 ctlz_i8 = allocate([8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "i8", ALLOC_DYNAMIC);
var cttz_i8 = allocate([8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0], "i8", ALLOC_DYNAMIC);
var Math_min = Math.min;
function invoke_diiiiid(index, a1, a2, a3, a4, a5, a6) {
try {
return Module["dynCall_diiiiid"](index, a1, a2, a3, a4, a5, a6)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_ii(index, a1) {
try {
return Module["dynCall_ii"](index, a1)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_viiiii(index, a1, a2, a3, a4, a5) {
try {
Module["dynCall_viiiii"](index, a1, a2, a3, a4, a5)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_did(index, a1, a2) {
try {
return Module["dynCall_did"](index, a1, a2)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_vi(index, a1) {
try {
Module["dynCall_vi"](index, a1)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_diiiid(index, a1, a2, a3, a4, a5) {
try {
return Module["dynCall_diiiid"](index, a1, a2, a3, a4, a5)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_vii(index, a1, a2) {
try {
Module["dynCall_vii"](index, a1, a2)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_iiii(index, a1, a2, a3) {
try {
return Module["dynCall_iiii"](index, a1, a2, a3)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_viii(index, a1, a2, a3) {
try {
Module["dynCall_viii"](index, a1, a2, a3)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_v(index) {
try {
Module["dynCall_v"](index)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_viid(index, a1, a2, a3) {
try {
Module["dynCall_viid"](index, a1, a2, a3)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_iiiii(index, a1, a2, a3, a4) {
try {
return Module["dynCall_iiiii"](index, a1, a2, a3, a4)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
try {
Module["dynCall_viiiiii"](index, a1, a2, a3, a4, a5, a6)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_iii(index, a1, a2) {
try {
return Module["dynCall_iii"](index, a1, a2)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
try {
return Module["dynCall_iiiiii"](index, a1, a2, a3, a4, a5)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function invoke_viiii(index, a1, a2, a3, a4) {
try {
Module["dynCall_viiii"](index, a1, a2, a3, a4)
} catch (e) {
if (typeof e !== "number" && e !== "longjmp")
throw e;
asm["setThrew"](1, 0)
}
}
function asmPrintInt(x, y) {
Module.print("int " + x + "," + y)
}
function asmPrintFloat(x, y) {
Module.print("float " + x + "," + y)
}
var asm = function(global, env, buffer) {
"use asm";
var a = new global.Int8Array(buffer);
var b = new global.Int16Array(buffer);
var c = new global.Int32Array(buffer);
var d = new global.Uint8Array(buffer);
var e = new global.Uint16Array(buffer);
var f = new global.Uint32Array(buffer);
var g = new global.Float32Array(buffer);
var h = new global.Float64Array(buffer);
var i = env.STACKTOP | 0;
var j = env.STACK_MAX | 0;
var k = env.tempDoublePtr | 0;
var l = env.ABORT | 0;
var m = env.cttz_i8 | 0;
var n = env.ctlz_i8 | 0;
var o = env.__ZTISt9exception | 0;
var p =
0;
var q = 0;
var r = 0;
var s = 0;
var t = +env.NaN,
u = +env.Infinity;
var v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0;
var E = 0;
var F = 0;
var G = 0;
var H = 0;
var I = 0;
var J = 0;
var K = 0;
var L = 0;
var M = 0;
var N = 0;
var O = global.Math.floor;
var P = global.Math.abs;
var Q = global.Math.sqrt;
var R = global.Math.pow;
var S = global.Math.cos;
var T = global.Math.sin;
var U = global.Math.tan;
var V = global.Math.acos;
var W = global.Math.asin;
var X = global.Math.atan;
var Y = global.Math.atan2;
var Z = global.Math.exp;
var _ = global.Math.log;
var $ = global.Math.ceil;
var aa =
global.Math.imul;
var ba = env.abort;
var ca = env.assert;
var da = env.asmPrintInt;
var ea = env.asmPrintFloat;
var fa = env.min;
var ga = env.invoke_diiiiid;
var ha = env.invoke_ii;
var ia = env.invoke_viiiii;
var ja = env.invoke_did;
var ka = env.invoke_vi;
var la = env.invoke_diiiid;
var ma = env.invoke_vii;
var na = env.invoke_iiii;
var oa = env.invoke_viii;
var pa = env.invoke_v;
var qa = env.invoke_viid;
var ra = env.invoke_iiiii;
var sa = env.invoke_viiiiii;
var ta = env.invoke_iii;
var ua = env.invoke_iiiiii;
var va = env.invoke_viiii;
var wa = env._cosf;
var xa = env.__ZSt9terminatev;
var ya = env._b2WorldPreSolve;
var za = env.___cxa_is_number_type;
var Aa = env.___cxa_allocate_exception;
var Ba = env.___cxa_find_matching_catch;
var Ca = env._fflush;
var Da = env._time;
var Ea = env.__exit;
var Fa = env.___setErrNo;
var Ga = env._sbrk;
var Ha = env.___cxa_begin_catch;
var Ia = env._sinf;
var Ja = env.___resumeException;
var Ka = env.__ZSt18uncaught_exceptionv;
var La = env._b2WorldRayCastCallback;
var Ma = env._emscripten_memcpy_big;
var Na = env._floorf;
var Oa = env._sqrtf;
var Pa = env._b2WorldBeginContactBody;
var Qa = env.___errno_location;
var Ra = env.__ZNSt9exceptionD2Ev;
var Sa = env.___cxa_throw;
var Ta = env._sysconf;
var Ua = env._abort;
var Va = env.___cxa_does_inherit;
var Wa = env._b2WorldEndContactBody;
var Xa = env._b2WorldQueryAABB;
var Ya = env._b2WorldPostSolve;
var Za = env._exit;
var _a = env.___cxa_pure_virtual;
var $a = 0;
function $k(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0;
d = i;
i = i + 64 | 0;
e = d;
f = d + 16 | 0;
g[e >> 2] = 3.4028234663852886E38;
g[e + 4 >> 2] = 3.4028234663852886E38;
h = e + 8 | 0;
g[h >> 2] = -3.4028234663852886E38;
g[e + 12 >> 2] = -3.4028234663852886E38;
j = c[a + 44 >> 2] | 0;
if ((j | 0) > 0) {
k = c[a + 104 >> 2] | 0;
l = c[a + 96 >> 2] | 0;
m = +g[b >> 2];
n = 3.4028234663852886E38;
o = 3.4028234663852886E38;
p = -3.4028234663852886E38;
q = -3.4028234663852886E38;
r = 0;
do {
s = k + (r << 3) | 0;
t = +g[s >> 2];
u = +g[s + 4 >> 2];
s = l + (r << 3) | 0;
v = +g[s >> 2];
w = +g[s + 4 >> 2];
x = v + t * m;
t = u * m + w;
u = v < x ? v : x;
y = w < t ? w : t;
n = n < u ? n : u;
o = o < y ? o : y;
y = +n;
u = +o;
s = e;
g[s >> 2] = y;
g[s + 4 >> 2] = u;
u = v > x ? v : x;
x = w > t ? w : t;
p = p > u ? p : u;
q = q > x ? q : x;
x = +p;
u = +q;
s = h;
g[s >> 2] = x;
g[s + 4 >> 2] = u;
r = r + 1 | 0
} while ((r |
0) < (j | 0))
}
c[f + 4 >> 2] = a;
c[f >> 2] = 6872;
j = f + 8 | 0;
c[j + 0 >> 2] = c[b + 0 >> 2];
c[j + 4 >> 2] = c[b + 4 >> 2];
c[j + 8 >> 2] = c[b + 8 >> 2];
c[j + 12 >> 2] = c[b + 12 >> 2];
c[j + 16 >> 2] = c[b + 16 >> 2];
c[j + 20 >> 2] = c[b + 20 >> 2];
c[j + 24 >> 2] = c[b + 24 >> 2];
Dj(c[a + 400 >> 2] | 0, f, e);
i = d;
return
}
function al(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la =
0;
e = i;
i = i + 48 | 0;
f = e;
h = e + 16 | 0;
j = b + 44 | 0;
k = c[j >> 2] | 0;
if ((k | 0) > 0) {
l = c[b + 88 >> 2] | 0;
m = b + 104 | 0;
n = 0;
do {
if ((c[l + (n << 2) >> 2] & 1028 | 0) == 1028) {
o = c[m >> 2] | 0;
g[o + (n << 3) >> 2] = 0;
g[o + (n << 3) + 4 >> 2] = 0
}
n = n + 1 | 0
} while ((n | 0) < (k | 0))
}
p = +g[d >> 2] * 2.5;
k = b + 252 | 0;
if ((c[k >> 2] | 0) <= 0) {
i = e;
return
}
n = b + 248 | 0;
m = b + 96 | 0;
l = f + 8 | 0;
o = b + 144 | 0;
q = b + 104 | 0;
r = h + 16 | 0;
s = h + 20 | 0;
t = h + 4 | 0;
u = b + 32 | 0;
v = b + 320 | 0;
w = d + 4 | 0;
d = b + 88 | 0;
x = b + 21 | 0;
y = b + 112 | 0;
z = 0;
do {
A = c[n >> 2] | 0;
a:
do if ((c[A + (z * 20 | 0) + 8 >> 2] & 1024 | 0) != 0) {
B = c[A + (z * 20 | 0) >> 2] | 0;
C = c[A + (z * 20 | 0) + 4 >> 2] | 0;
D = c[m >> 2] | 0;
E =
D + (B << 3) | 0;
F = +g[E >> 2];
G = +g[E + 4 >> 2];
E = D + (C << 3) | 0;
H = +g[E >> 2];
I = +g[E + 4 >> 2];
J = +(F < H ? F : H);
K = +(G < I ? G : I);
E = f;
g[E >> 2] = J;
g[E + 4 >> 2] = K;
K = +(F > H ? F : H);
J = +(G > I ? G : I);
E = l;
g[E >> 2] = K;
g[E + 4 >> 2] = J;
E = c[o >> 2] | 0;
D = c[E + (B << 2) >> 2] | 0;
L = c[E + (C << 2) >> 2] | 0;
if ((D | 0) != 0 ? (c[D + 12 >> 2] & 2 | 0) != 0 : 0) {
nk(D);
J = +g[D + 56 >> 2];
M = +g[D + 48 >> 2] - J * (G - +g[D + 44 >> 2]);
N = J * (F - +g[D + 40 >> 2]) + +g[D + 52 >> 2]
} else {
E = (c[q >> 2] | 0) + (B << 3) | 0;
J = +g[E >> 2];
M = J;
N = +g[E + 4 >> 2]
}
if ((L | 0) != 0 ? (c[L + 12 >> 2] & 2 | 0) != 0 : 0) {
nk(L);
J = +g[L + 56 >> 2];
O = +g[L + 48 >> 2] - J * (I - +g[L + 44 >> 2]);
P = J * (H - +g[L +
40 >> 2]) + +g[L + 52 >> 2]
} else {
E = (c[q >> 2] | 0) + (C << 3) | 0;
J = +g[E >> 2];
O = J;
P = +g[E + 4 >> 2]
}
J = H - F;
H = I - G;
I = O - M;
K = P - N;
Nk(h, b, f);
E = c[r >> 2] | 0;
C = c[s >> 2] | 0;
if (E >>> 0 < C >>> 0) {
B = c[h >> 2] | 0;
R = c[t >> 2] | 0;
S = E;
while (1) {
E = c[S + 4 >> 2] & 1048575;
T = S;
S = S + 8 | 0;
c[r >> 2] = S;
if (E >>> 0 < B >>> 0 | E >>> 0 > R >>> 0)
if (S >>> 0 < C >>> 0) {
S = S;
continue
} else
break;
E = c[T >> 2] | 0;
if (!((E | 0) > -1))
break a;
T = (c[m >> 2] | 0) + (E << 3) | 0;
U = +g[T >> 2];
V = +g[T + 4 >> 2];
T = c[(c[o >> 2] | 0) + (E << 2) >> 2] | 0;
b:
do if (!((D | 0) == (T | 0) | (L | 0) == (T | 0))) {
W = (T | 0) == 0;
if (!W ? (c[T + 12 >> 2] & 2 | 0) != 0 : 0) {
nk(T);
X = +g[T + 56 >>
2];
Y = +g[T + 48 >> 2] - X * (V - +g[T + 44 >> 2]);
Z = X * (U - +g[T + 40 >> 2]) + +g[T + 52 >> 2]
} else {
_ = (c[q >> 2] | 0) + (E << 3) | 0;
X = +g[_ >> 2];
Y = X;
Z = +g[_ + 4 >> 2]
}
X = U - F;
$ = V - G;
aa = Y - M;
ba = Z - N;
ca = I * ba - K * aa;
da = J * ba - H * aa - (K * X - I * $);
ea = J * $ - H * X;
do if (ca == 0) {
if (da == 0)
break b;
fa = -ea / da;
if (!(fa >= 0 & fa < p))
break b;
ga = J + I * fa;
ha = H + K * fa;
ia = (ga * (X + aa * fa) + ha * ($ + ba * fa)) / (ga * ga + ha * ha);
if (ia >= 0 & ia <= 1)
ja = ia;
else
break b
} else {
ia = da * da - ea * 4 * ca;
if (ia < 0)
break b;
ha = +Q(+ia);
ia = ca * 2;
ga = (-da - ha) / ia;
fa = (ha - da) / ia;
_ = ga > fa;
ia = _ ? fa : ga;
ha = _ ? ga : fa;
fa = J + I * ia;
ga = H + K * ia;
ka = (fa *
(X + aa * ia) + ga * ($ + ba * ia)) / (fa * fa + ga * ga);
if (ia >= 0 & ia < p ? ka >= 0 & ka <= 1 : 0) {
ja = ka;
break
}
if (!(ha >= 0 & ha < p))
break b;
ka = J + I * ha;
ia = H + K * ha;
ga = (ka * (X + aa * ha) + ia * ($ + ba * ha)) / (ka * ka + ia * ia);
if (ga >= 0 & ga <= 1)
ja = ga;
else
break b
}
while (0);
ba = M + I * ja - Y;
$ = N + K * ja - Z;
aa = +g[u >> 2] * .75;
X = aa * +g[v >> 2] * aa;
aa = ba * X;
da = $ * X;
if (!W ? (c[T + 12 >> 2] & 2 | 0) != 0 : 0) {
nk(T);
X = +g[T + 32 >> 2];
nk(T);
ca = +g[T + 36 >> 2];
if (X > 0) {
ea = 1 / X;
_ = T + 48 | 0;
g[_ >> 2] = aa * ea + +g[_ >> 2];
_ = T + 52 | 0;
g[_ >> 2] = da * ea + +g[_ >> 2]
}
if (ca > 0) {
nk(T);
_ = T + 40 | 0;
ea = +g[_ >> 2];
la = T + 56 | 0;
g[la >> 2] = (da * (U - ea) - aa *
(V - +g[_ + 4 >> 2])) / ca + +g[la >> 2]
}
} else {
la = c[q >> 2] | 0;
_ = la + (E << 3) | 0;
g[_ >> 2] = ba + +g[_ >> 2];
_ = la + (E << 3) + 4 | 0;
g[_ >> 2] = $ + +g[_ >> 2]
}
$ = -+g[w >> 2];
ba = aa * $;
aa = da * $;
if (ba != 0 | aa != 0 ? (c[(c[d >> 2] | 0) + (E << 2) >> 2] & 4 | 0) == 0 : 0) {
if ((a[x >> 0] | 0) == 0) {
xn(c[y >> 2] | 0, 0, c[j >> 2] << 3 | 0) | 0;
a[x >> 0] = 1
}
_ = c[y >> 2] | 0;
la = _ + (E << 3) | 0;
g[la >> 2] = ba + +g[la >> 2];
la = _ + (E << 3) + 4 | 0;
g[la >> 2] = aa + +g[la >> 2]
}
}
while (0);
if (!(S >>> 0 < C >>> 0))
break
}
}
}
while (0);
z = z + 1 | 0
} while ((z | 0) < (c[k >> 2] | 0));
i = e;
return
}
function bl(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
ga = 0;
e = i;
i = i + 48 | 0;
f = e + 32 | 0;
h = e + 28 | 0;
j = e;
k = b + 44 | 0;
l = c[k >> 2] | 0;
if ((l | 0) == 0) {
i = e;
return
}
m = c[b + 280 >> 2] | 0;
a:
do if ((m | 0) != 0) {
n = b + 296 | 0;
o = n;
p = +g[d >> 2] / +g[b + 396 >> 2] * 4294967296;
q = zn(~~p >>> 0 | 0, (+P(p) >= 1 ? p > 0 ? (fa(+O(p / 4294967296), 4294967295) | 0) >>> 0 : ~~+$((p - +(~~p >>> 0)) / 4294967296) >>> 0 : 0) | 0, c[o >> 2] | 0, c[o + 4 >> 2] | 0) | 0;
o = E;
r = n;
c[r >> 2] = q;
c[r + 4 >> 2] = o;
r = c[b +
288 >> 2] | 0;
q = b + 304 | 0;
if ((a[q >> 0] | 0) != 0) {
c[h >> 2] = m;
sl(r, r + (l << 2) | 0, h);
a[q >> 0] = 0
}
if ((l | 0) > 0) {
q = b + 88 | 0;
n = l;
do {
n = n + -1 | 0;
s = c[r + (n << 2) >> 2] | 0;
t = c[m + (s << 2) >> 2] | 0;
if ((o | 0) < (t | 0) | (t | 0) < 1)
break a;
Ak(b, s, c[(c[q >> 2] | 0) + (s << 2) >> 2] | 2)
} while ((n | 0) > 0)
}
}
while (0);
m = b + 8 | 0;
if ((c[m >> 2] & 2 | 0) != 0)
xk(b);
l = b + 12 | 0;
if ((a[l >> 0] | 0) != 0) {
c[m >> 2] = 0;
h = c[k >> 2] | 0;
if ((h | 0) > 0) {
n = c[b + 88 >> 2] | 0;
q = 0;
o = 0;
do {
q = c[n + (o << 2) >> 2] | q;
c[m >> 2] = q;
o = o + 1 | 0
} while ((o | 0) != (h | 0))
}
a[l >> 0] = 0
}
l = b + 20 | 0;
if ((a[l >> 0] | 0) != 0) {
h = b + 16 | 0;
c[h >> 2] = 0;
o = c[b + 312 >> 2] | 0;
if ((o |
0) != 0) {
q = 0;
n = o;
do {
q = c[n + 12 >> 2] | q;
c[h >> 2] = q;
n = c[n + 24 >> 2] | 0
} while ((n | 0) != 0)
}
a[l >> 0] = 0
}
if ((a[b >> 0] | 0) != 0) {
i = e;
return
}
l = b + 24 | 0;
c[l >> 2] = 0;
n = d + 20 | 0;
if ((c[n >> 2] | 0) <= 0) {
i = e;
return
}
q = b + 4 | 0;
h = j + 4 | 0;
o = b + 116 | 0;
r = b + 236 | 0;
s = b + 232 | 0;
t = b + 220 | 0;
u = b + 216 | 0;
v = b + 16 | 0;
w = b + 21 | 0;
x = b + 324 | 0;
y = b + 400 | 0;
z = b + 104 | 0;
A = b + 32 | 0;
B = b + 88 | 0;
C = b + 96 | 0;
D = b + 372 | 0;
F = b + 144 | 0;
G = b + 132 | 0;
H = b + 368 | 0;
I = b + 364 | 0;
J = b + 36 | 0;
K = b + 28 | 0;
L = b + 112 | 0;
M = f + 4 | 0;
do {
c[q >> 2] = (c[q >> 2] | 0) + 1;
c[j + 0 >> 2] = c[d + 0 >> 2];
c[j + 4 >> 2] = c[d + 4 >> 2];
c[j + 8 >> 2] = c[d + 8 >> 2];
c[j + 12 >> 2] = c[d + 12 >>
2];
c[j + 16 >> 2] = c[d + 16 >> 2];
c[j + 20 >> 2] = c[d + 20 >> 2];
c[j + 24 >> 2] = c[d + 24 >> 2];
p = +(c[n >> 2] | 0);
N = +g[j >> 2] / p;
g[j >> 2] = N;
R = +g[h >> 2] * p;
g[h >> 2] = R;
Gk(b, 0);
Yk(b);
xn(c[o >> 2] | 0, 0, c[k >> 2] << 2 | 0) | 0;
S = c[r >> 2] | 0;
if ((S | 0) > 0) {
T = c[s >> 2] | 0;
U = c[o >> 2] | 0;
V = 0;
do {
W = U + (c[T + (V * 28 | 0) >> 2] << 2) | 0;
g[W >> 2] = +g[T + (V * 28 | 0) + 12 >> 2] + +g[W >> 2];
V = V + 1 | 0
} while ((V | 0) != (S | 0))
}
S = c[t >> 2] | 0;
if ((S | 0) > 0) {
V = c[u >> 2] | 0;
T = c[o >> 2] | 0;
U = 0;
do {
W = c[V + (U * 24 | 0) + 4 >> 2] | 0;
p = +g[V + (U * 24 | 0) + 8 >> 2];
X = T + (c[V + (U * 24 | 0) >> 2] << 2) | 0;
g[X >> 2] = p + +g[X >> 2];
X = T + (W << 2) | 0;
g[X >> 2] = p + +g[X >>
2];
U = U + 1 | 0
} while ((U | 0) != (S | 0))
}
if ((c[v >> 2] & 16 | 0) != 0)
Mk(b);
S = c[m >> 2] | 0;
if ((S & 4096 | 0) == 0)
Y = S;
else {
S = c[B >> 2] | 0;
c[f >> 2] = 7360;
c[M >> 2] = S;
Hk(b, 0, c[k >> 2] | 0, f);
if ((c[k >> 2] | 0) > 0) {
S = c[B >> 2] | 0;
U = 0;
do {
T = S + (U << 2) | 0;
c[T >> 2] = c[T >> 2] & -4097;
U = U + 1 | 0
} while ((U | 0) < (c[k >> 2] | 0))
}
U = c[m >> 2] & -4097;
c[m >> 2] = U;
Y = U
}
if ((a[w >> 0] | 0) != 0) {
p = +g[J >> 2] * 1.3333333730697632;
Z = N * p * +g[K >> 2] * p;
U = c[k >> 2] | 0;
if ((U | 0) > 0) {
S = c[z >> 2] | 0;
T = c[L >> 2] | 0;
V = 0;
do {
p = Z * +g[T + (V << 3) + 4 >> 2];
X = S + (V << 3) | 0;
g[X >> 2] = Z * +g[T + (V << 3) >> 2] + +g[X >> 2];
X = S + (V << 3) + 4 | 0;
g[X >> 2] =
p + +g[X >> 2];
V = V + 1 | 0
} while ((V | 0) != (U | 0))
}
a[w >> 0] = 0
}
if ((Y & 32 | 0) == 0)
_ = Y;
else {
cl(b);
_ = c[m >> 2] | 0
}
if ((_ & 8192 | 0) != 0 ? (Z = +g[I >> 2] * +g[A >> 2] * R, U = c[t >> 2] | 0, (U | 0) > 0) : 0) {
V = c[u >> 2] | 0;
S = 0;
do {
do if ((c[V + (S * 24 | 0) + 20 >> 2] & 8192 | 0) != 0) {
T = c[V + (S * 24 | 0) >> 2] | 0;
X = c[V + (S * 24 | 0) + 4 >> 2] | 0;
W = c[F >> 2] | 0;
if ((c[W + (T << 2) >> 2] | 0) == (c[W + (X << 2) >> 2] | 0))
break;
W = V + (S * 24 | 0) + 12 | 0;
N = +g[W >> 2];
p = Z * +g[V + (S * 24 | 0) + 8 >> 2];
aa = p * N;
N = p * +g[W + 4 >> 2];
W = c[z >> 2] | 0;
ba = W + (T << 3) | 0;
g[ba >> 2] = +g[ba >> 2] - aa;
ba = W + (T << 3) + 4 | 0;
g[ba >> 2] = +g[ba >> 2] - N;
ba = W + (X << 3) | 0;
g[ba >> 2] =
aa + +g[ba >> 2];
ba = W + (X << 3) + 4 | 0;
g[ba >> 2] = N + +g[ba >> 2]
}
while (0);
S = S + 1 | 0
} while ((S | 0) != (U | 0))
}
if ((_ & 64 | 0) != 0 ? (Z = +g[H >> 2] * +g[A >> 2] * R, U = c[t >> 2] | 0, (U | 0) > 0) : 0) {
S = c[u >> 2] | 0;
V = 0;
do {
do if ((c[S + (V * 24 | 0) + 20 >> 2] & 64 | 0) != 0) {
N = +g[S + (V * 24 | 0) + 8 >> 2];
if (!(N > .25))
break;
ba = c[S + (V * 24 | 0) >> 2] | 0;
X = c[S + (V * 24 | 0) + 4 >> 2] | 0;
W = S + (V * 24 | 0) + 12 | 0;
aa = +g[W >> 2];
p = Z * (N + -.25);
N = p * aa;
aa = p * +g[W + 4 >> 2];
W = c[z >> 2] | 0;
T = W + (ba << 3) | 0;
g[T >> 2] = +g[T >> 2] - N;
T = W + (ba << 3) + 4 | 0;
g[T >> 2] = +g[T >> 2] - aa;
T = W + (X << 3) | 0;
g[T >> 2] = N + +g[T >> 2];
T = W + (X << 3) + 4 | 0;
g[T >> 2] = aa + +g[T >>
2]
}
while (0);
V = V + 1 | 0
} while ((V | 0) != (U | 0))
}
if ((_ & 128 | 0) != 0)
dl(b, j);
if ((c[v >> 2] & 1 | 0) != 0 ? (Z = +g[h >> 2] * +g[D >> 2], U = c[t >> 2] | 0, (U | 0) > 0) : 0) {
V = c[u >> 2] | 0;
S = c[F >> 2] | 0;
T = 0;
do {
X = c[V + (T * 24 | 0) >> 2] | 0;
W = c[V + (T * 24 | 0) + 4 >> 2] | 0;
if ((c[S + (X << 2) >> 2] | 0) != (c[S + (W << 2) >> 2] | 0)) {
ba = V + (T * 24 | 0) + 12 | 0;
R = +g[ba >> 2];
ca = c[G >> 2] | 0;
aa = +g[V + (T * 24 | 0) + 8 >> 2] * Z * (+g[ca + (X << 2) >> 2] + +g[ca + (W << 2) >> 2]);
N = R * aa;
R = +g[ba + 4 >> 2] * aa;
ba = c[z >> 2] | 0;
ca = ba + (X << 3) | 0;
g[ca >> 2] = +g[ca >> 2] - N;
ca = ba + (X << 3) + 4 | 0;
g[ca >> 2] = +g[ca >> 2] - R;
ca = ba + (W << 3) | 0;
g[ca >> 2] = N + +g[ca >> 2];
ca = ba + (W << 3) + 4 | 0;
g[ca >> 2] = R + +g[ca >> 2]
}
T = T + 1 | 0
} while ((T | 0) != (U | 0))
}
if ((c[m >> 2] & 256 | 0) != 0)
el(b);
Z = +g[j >> 2] * +g[x >> 2];
U = (c[y >> 2] | 0) + 102980 | 0;
R = +g[U >> 2];
N = Z * R;
R = Z * +g[U + 4 >> 2];
U = c[k >> 2] | 0;
if ((U | 0) > 0) {
T = c[z >> 2] | 0;
V = 0;
do {
S = T + (V << 3) | 0;
g[S >> 2] = N + +g[S >> 2];
S = T + (V << 3) + 4 | 0;
g[S >> 2] = R + +g[S >> 2];
V = V + 1 | 0
} while ((V | 0) != (U | 0))
}
if ((c[m >> 2] & 2048 | 0) != 0)
fl(b, j);
gl(b, j);
hl(b, j);
U = c[m >> 2] | 0;
if ((U & 2048 | 0) == 0)
da = U;
else {
il(b);
da = c[m >> 2] | 0
}
if ((da & 16 | 0) == 0)
ea = da;
else {
jl(b, j);
ea = c[m >> 2] | 0
}
if ((ea & 8 | 0) != 0)
kl(b, j);
R = +g[A >> 2] * +g[h >>
2];
N = R * R;
U = c[k >> 2] | 0;
if ((U | 0) > 0) {
V = c[z >> 2] | 0;
T = 0;
do {
S = V + (T << 3) | 0;
R = +g[S >> 2];
ca = V + (T << 3) + 4 | 0;
Z = +g[ca >> 2];
aa = R * R + Z * Z;
if (aa > N) {
p = +Q(+(N / aa));
g[S >> 2] = R * p;
g[ca >> 2] = Z * p
}
T = T + 1 | 0
} while ((T | 0) != (U | 0))
}
if ((c[v >> 2] & 2 | 0) != 0)
ll(b);
if ((c[m >> 2] & 1024 | 0) != 0)
al(b, j);
$k(b, j);
if ((c[v >> 2] & 2 | 0) != 0)
ml(b, j);
U = c[k >> 2] | 0;
do if ((c[m >> 2] & 4 | 0) == 0)
ga = 95;
else {
if ((U | 0) <= 0)
break;
T = c[B >> 2] | 0;
V = 0;
do {
if ((c[T + (V << 2) >> 2] & 4 | 0) != 0) {
ca = c[z >> 2] | 0;
g[ca + (V << 3) >> 2] = 0;
g[ca + (V << 3) + 4 >> 2] = 0
}
V = V + 1 | 0
} while ((V | 0) != (U | 0));
ga = 95
}
while (0);
do if ((ga | 0) ==
95) {
ga = 0;
if ((U | 0) <= 0)
break;
V = c[C >> 2] | 0;
N = +g[j >> 2];
T = c[z >> 2] | 0;
ca = 0;
do {
p = N * +g[T + (ca << 3) + 4 >> 2];
S = V + (ca << 3) | 0;
g[S >> 2] = N * +g[T + (ca << 3) >> 2] + +g[S >> 2];
S = V + (ca << 3) + 4 | 0;
g[S >> 2] = p + +g[S >> 2];
ca = ca + 1 | 0
} while ((ca | 0) < (U | 0))
}
while (0);
U = (c[l >> 2] | 0) + 1 | 0;
c[l >> 2] = U
} while ((U | 0) < (c[n >> 2] | 0));
i = e;
return
}
function cl(a) {
a = a | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0;
d = i;
e = +g[a + 352 >> 2];
f = c[a + 236 >> 2] | 0;
if ((f | 0) > 0) {
h = a + 96 | 0;
j = a + 104 | 0;
k = a + 36 | 0;
l =
a + 28 | 0;
m = c[a + 232 >> 2] | 0;
n = c[a + 88 >> 2] | 0;
o = 0;
do {
p = c[m + (o * 28 | 0) >> 2] | 0;
if ((c[n + (p << 2) >> 2] & 32 | 0) != 0 ? (q = c[m + (o * 28 | 0) + 4 >> 2] | 0, r = (c[h >> 2] | 0) + (p << 3) | 0, s = +g[r >> 2], t = +g[r + 4 >> 2], r = q + 88 | 0, u = +g[r >> 2], v = q + 60 | 0, w = q + 64 | 0, x = q + 80 | 0, y = q + 84 | 0, z = c[j >> 2] | 0, A = z + (p << 3) | 0, B = +g[A >> 2], C = z + (p << 3) + 4 | 0, D = +g[C >> 2], E = +g[m + (o * 28 | 0) + 12 >> 2] * e * +g[m + (o * 28 | 0) + 24 >> 2], F = E * (+g[x >> 2] - u * (t - +g[w >> 2]) - B), G = E * (u * (s - +g[v >> 2]) + +g[y >> 2] - D), u = +g[k >> 2] * 1.3333333730697632, E = u * +g[l >> 2] * u, g[A >> 2] = B + F * E, g[C >> 2] = D + G * E, E = -F, F = -G, (c[q >> 2] | 0) == 2) : 0) {
C = q + 4 |
0;
A = b[C >> 1] | 0;
if ((A & 2) == 0 ? (p = A & 65535, (p & 2 | 0) == 0) : 0) {
z = (p | 2) & 65535;
b[C >> 1] = z;
g[q + 160 >> 2] = 0;
H = z
} else
H = A;
if (!((H & 2) == 0)) {
G = +g[q + 136 >> 2];
g[x >> 2] = G * E + +g[x >> 2];
g[y >> 2] = G * F + +g[y >> 2];
g[r >> 2] = +g[r >> 2] + +g[q + 144 >> 2] * ((s - +g[v >> 2]) * F - (t - +g[w >> 2]) * E)
}
}
o = o + 1 | 0
} while ((o | 0) < (f | 0))
}
f = c[a + 220 >> 2] | 0;
if ((f | 0) <= 0) {
i = d;
return
}
o = c[a + 216 >> 2] | 0;
H = a + 104 | 0;
a = 0;
do {
if ((c[o + (a * 24 | 0) + 20 >> 2] & 32 | 0) != 0) {
l = c[o + (a * 24 | 0) >> 2] | 0;
k = c[o + (a * 24 | 0) + 4 >> 2] | 0;
m = c[H >> 2] | 0;
j = m + (k << 3) | 0;
h = m + (l << 3) | 0;
E = +g[h >> 2];
n = m + (k << 3) + 4 | 0;
k = m + (l << 3) + 4 | 0;
t =
+g[k >> 2];
F = e * +g[o + (a * 24 | 0) + 8 >> 2];
s = F * (+g[j >> 2] - E);
G = F * (+g[n >> 2] - t);
g[h >> 2] = E + s;
g[k >> 2] = t + G;
g[j >> 2] = +g[j >> 2] - s;
g[n >> 2] = +g[n >> 2] - G
}
a = a + 1 | 0
} while ((a | 0) < (f | 0));
i = d;
return
}
function dl(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0;
d = i;
e = a + 44 | 0;
if ((c[e >> 2] | 0) > 0) {
f = a + 128 | 0;
h = 0;
do {
j = 8784;
k = c[j + 4 >> 2] | 0;
l = (c[f >> 2] | 0) + (h << 3) | 0;
c[l >> 2] = c[j >> 2];
c[l + 4 >> 2] = k;
h = h + 1 | 0
} while ((h | 0) < (c[e >> 2] | 0))
}
e = a + 216 | 0;
h = c[a + 220 >> 2] | 0;
f = (h | 0) > 0;
if (f) {
k = a + 128 | 0;
l = c[e >> 2] | 0;
j = 0;
do {
if ((c[l +
(j * 24 | 0) + 20 >> 2] & 128 | 0) != 0) {
m = c[l + (j * 24 | 0) >> 2] | 0;
n = c[l + (j * 24 | 0) + 4 >> 2] | 0;
o = +g[l + (j * 24 | 0) + 8 >> 2];
p = l + (j * 24 | 0) + 12 | 0;
q = +g[p >> 2];
r = o * (1 - o);
o = r * q;
q = r * +g[p + 4 >> 2];
p = c[k >> 2] | 0;
s = p + (m << 3) | 0;
g[s >> 2] = +g[s >> 2] - o;
s = p + (m << 3) + 4 | 0;
g[s >> 2] = +g[s >> 2] - q;
s = p + (n << 3) | 0;
g[s >> 2] = o + +g[s >> 2];
s = p + (n << 3) + 4 | 0;
g[s >> 2] = q + +g[s >> 2]
}
j = j + 1 | 0
} while ((j | 0) < (h | 0))
}
q = +g[a + 32 >> 2] * +g[b + 4 >> 2];
o = +g[a + 356 >> 2] * q;
r = q * +g[a + 360 >> 2];
t = q * .5;
if (!f) {
i = d;
return
}
f = a + 116 | 0;
b = a + 128 | 0;
j = a + 104 | 0;
a = c[e >> 2] | 0;
e = 0;
do {
if ((c[a + (e * 24 | 0) + 20 >> 2] & 128 | 0) != 0) {
k = c[a + (e *
24 | 0) >> 2] | 0;
l = c[a + (e * 24 | 0) + 4 >> 2] | 0;
s = a + (e * 24 | 0) + 12 | 0;
q = +g[s >> 2];
u = +g[s + 4 >> 2];
s = c[f >> 2] | 0;
n = c[b >> 2] | 0;
v = o * (+g[s + (k << 2) >> 2] + +g[s + (l << 2) >> 2] + -2) + r * (q * (+g[n + (l << 3) >> 2] - +g[n + (k << 3) >> 2]) + u * (+g[n + (l << 3) + 4 >> 2] - +g[n + (k << 3) + 4 >> 2]));
w = +g[a + (e * 24 | 0) + 8 >> 2] * (v < t ? v : t);
v = q * w;
q = u * w;
n = c[j >> 2] | 0;
s = n + (k << 3) | 0;
g[s >> 2] = +g[s >> 2] - v;
s = n + (k << 3) + 4 | 0;
g[s >> 2] = +g[s >> 2] - q;
s = n + (l << 3) | 0;
g[s >> 2] = +g[s >> 2] + v;
s = n + (l << 3) + 4 | 0;
g[s >> 2] = +g[s >> 2] + q
}
e = e + 1 | 0
} while ((e | 0) < (h | 0));
i = d;
return
}
function el(b) {
b = b | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0;
e = i;
f = ~~(+g[b + 388 >> 2] * 128);
if ((f | 0) == 0) {
i = e;
return
}
h = b + 220 | 0;
j = c[h >> 2] | 0;
if ((j | 0) <= 0) {
i = e;
return
}
k = b + 216 | 0;
l = b + 88 | 0;
m = b + 136 | 0;
b = d[8064] | 0;
n = j;
j = 0;
while (1) {
o = c[k >> 2] | 0;
p = c[o + (j * 24 | 0) >> 2] | 0;
q = c[o + (j * 24 | 0) + 4 >> 2] | 0;
o = c[l >> 2] | 0;
if ((c[o + (p << 2) >> 2] & 256 & c[o + (q << 2) >> 2] | 0) == 0)
r = n;
else {
o = c[m >> 2] | 0;
s = o + (q << 2) | 0;
t = o + (p << 2) | 0;
u = d[t >> 0] | 0;
v = (aa((d[s >> 0] | 0) - u | 0, f) | 0) >> b;
w = o + (q << 2) + 1 | 0;
x = o + (p << 2) + 1 | 0;
y = d[x >> 0] | 0;
z = (aa((d[w >> 0] | 0) - y | 0, f) | 0) >> b;
A = o + (q << 2) + 2 | 0;
B = o + (p << 2) + 2 | 0;
C = d[B >> 0] | 0;
D = (aa((d[A >> 0] | 0) - C | 0, f) | 0) >> b;
E = o + (q << 2) + 3 | 0;
q = o + (p << 2) + 3 | 0;
p = d[q >> 0] | 0;
o = (aa((d[E >> 0] | 0) - p | 0, f) | 0) >> b;
a[t >> 0] = v + u;
a[x >> 0] = z + y;
a[B >> 0] = D + C;
a[q >> 0] = o + p;
a[s >> 0] = (d[s >> 0] | 0) - v;
a[w >> 0] = (d[w >> 0] | 0) - z;
a[A >> 0] = (d[A >> 0] | 0) - D;
a[E >> 0] = (d[E >> 0] | 0) - o;
r = c[h >> 2] | 0
}
j = j + 1 | 0;
if ((j | 0) >= (r | 0))
break;
else
n = r
}
i = e;
return
}
function fl(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0;
d = i;
e = a + 120 | 0;
f = c[e >> 2] | 0;
if ((f | 0) ==
0) {
h = a + 48 | 0;
j = c[h >> 2] | 0;
if ((j | 0) == 0) {
vk(a, 256);
k = c[h >> 2] | 0
} else
k = j;
j = Em(c[a + 400 >> 2] | 0, k << 2) | 0;
xn(j | 0, 0, c[h >> 2] << 2 | 0) | 0;
l = j
} else
l = f;
c[e >> 2] = l;
m = +g[a + 32 >> 2] * +g[b + 4 >> 2];
n = +g[a + 320 >> 2] * m * m;
m = +g[a + 376 >> 2] * n;
o = n * .25;
n = +g[a + 380 >> 2];
b = a + 384 | 0;
if ((c[b >> 2] | 0) <= 0) {
i = d;
return
}
l = a + 124 | 0;
f = a + 44 | 0;
j = a + 220 | 0;
h = a + 116 | 0;
k = a + 88 | 0;
p = a + 216 | 0;
a = c[f >> 2] | 0;
q = 1;
while (1) {
xn(c[l >> 2] | 0, 0, a << 2 | 0) | 0;
r = c[j >> 2] | 0;
if ((r | 0) > 0) {
s = c[p >> 2] | 0;
t = 0;
do {
if ((c[s + (t * 24 | 0) + 20 >> 2] & 2048 | 0) != 0) {
u = c[s + (t * 24 | 0) >> 2] | 0;
v = c[s + (t * 24 | 0) + 4 >> 2] | 0;
w = +g[s +
(t * 24 | 0) + 8 >> 2];
x = c[e >> 2] | 0;
y = c[l >> 2] | 0;
z = y + (u << 2) | 0;
g[z >> 2] = w * +g[x + (v << 2) >> 2] + +g[z >> 2];
z = y + (v << 2) | 0;
g[z >> 2] = w * +g[x + (u << 2) >> 2] + +g[z >> 2]
}
t = t + 1 | 0
} while ((t | 0) < (r | 0))
}
r = c[f >> 2] | 0;
if ((r | 0) > 0) {
t = c[h >> 2] | 0;
s = c[k >> 2] | 0;
z = 0;
do {
w = +g[t + (z << 2) >> 2];
if ((c[s + (z << 2) >> 2] & 2048 | 0) == 0)
g[(c[e >> 2] | 0) + (z << 2) >> 2] = 0;
else {
A = (m * (w + -1) + +g[(c[l >> 2] | 0) + (z << 2) >> 2]) / (n + w);
w = A < o ? A : o;
g[(c[e >> 2] | 0) + (z << 2) >> 2] = w < 0 ? 0 : w
}
z = z + 1 | 0
} while ((z | 0) < (r | 0))
}
if ((q | 0) >= (c[b >> 2] | 0))
break;
a = r;
q = q + 1 | 0
}
i = d;
return
}
function gl(a, d) {
a = a | 0;
d = d | 0;
var e =
0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0;
e = i;
f = a + 320 | 0;
h = a + 32 | 0;
j = +g[h >> 2] * +g[d + 4 >> 2];
k = +g[f >> 2] * j * j;
j = +g[a + 336 >> 2] * k;
l = k * .25;
m = c[a + 44 >> 2] | 0;
n = (m | 0) > 0;
if (n) {
o = c[a + 116 >> 2] | 0;
p = c[a + 124 >> 2] | 0;
q = 0;
do {
k = +g[o + (q << 2) >> 2] + -1;
r = j * (k < 0 ? 0 : k);
g[p + (q << 2) >> 2] = r < l ? r : l;
q = q + 1 | 0
} while ((q | 0) < (m | 0))
}
q = c[a + 8 >> 2] | 0;
if (!((q & 192 | 0) == 0 | n ^ 1)) {
p = c[a + 88 >> 2] | 0;
o = a + 124 | 0;
s = 0;
do {
if ((c[p + (s << 2) >> 2] & 192 | 0) != 0)
g[(c[o >> 2] | 0) + (s << 2) >> 2] = 0;
s = s + 1 | 0
} while ((s | 0) < (m | 0))
}
if (!((q & 2048 | 0) == 0 | n ^ 1)) {
n =
c[a + 88 >> 2] | 0;
q = a + 120 | 0;
s = a + 124 | 0;
o = 0;
do {
if ((c[n + (o << 2) >> 2] & 2048 | 0) != 0) {
p = (c[s >> 2] | 0) + (o << 2) | 0;
g[p >> 2] = +g[(c[q >> 2] | 0) + (o << 2) >> 2] + +g[p >> 2]
}
o = o + 1 | 0
} while ((o | 0) < (m | 0))
}
l = +g[d >> 2] / (+g[f >> 2] * +g[h >> 2]);
h = c[a + 236 >> 2] | 0;
if ((h | 0) > 0) {
f = a + 36 | 0;
d = a + 28 | 0;
m = c[a + 232 >> 2] | 0;
o = c[a + 96 >> 2] | 0;
q = c[a + 124 >> 2] | 0;
s = c[a + 104 >> 2] | 0;
n = 0;
do {
p = c[m + (n * 28 | 0) >> 2] | 0;
t = c[m + (n * 28 | 0) + 4 >> 2] | 0;
r = +g[m + (n * 28 | 0) + 12 >> 2];
u = m + (n * 28 | 0) + 16 | 0;
k = +g[u >> 2];
v = +g[u + 4 >> 2];
u = o + (p << 3) | 0;
w = +g[u >> 2];
x = +g[u + 4 >> 2];
y = l * r * +g[m + (n * 28 | 0) + 24 >> 2] * (j * r + +g[q + (p << 2) >>
2]);
r = k * y;
k = v * y;
y = +g[f >> 2] * 1.3333333730697632;
v = y * +g[d >> 2] * y;
u = s + (p << 3) | 0;
g[u >> 2] = +g[u >> 2] - r * v;
u = s + (p << 3) + 4 | 0;
g[u >> 2] = +g[u >> 2] - k * v;
if ((c[t >> 2] | 0) == 2) {
u = t + 4 | 0;
p = b[u >> 1] | 0;
if ((p & 2) == 0 ? (z = p & 65535, (z & 2 | 0) == 0) : 0) {
A = (z | 2) & 65535;
b[u >> 1] = A;
g[t + 160 >> 2] = 0;
B = A
} else
B = p;
if (!((B & 2) == 0)) {
v = +g[t + 136 >> 2];
p = t + 80 | 0;
g[p >> 2] = r * v + +g[p >> 2];
p = t + 84 | 0;
g[p >> 2] = k * v + +g[p >> 2];
p = t + 88 | 0;
g[p >> 2] = +g[p >> 2] + +g[t + 144 >> 2] * (k * (w - +g[t + 60 >> 2]) - r * (x - +g[t + 64 >> 2]))
}
}
n = n + 1 | 0
} while ((n | 0) < (h | 0))
}
h = c[a + 220 >> 2] | 0;
if ((h | 0) <= 0) {
i = e;
return
}
n = c[a +
216 >> 2] | 0;
B = c[a + 124 >> 2] | 0;
s = c[a + 104 >> 2] | 0;
a = 0;
do {
d = c[n + (a * 24 | 0) >> 2] | 0;
f = c[n + (a * 24 | 0) + 4 >> 2] | 0;
q = n + (a * 24 | 0) + 12 | 0;
j = +g[q >> 2];
x = l * +g[n + (a * 24 | 0) + 8 >> 2] * (+g[B + (d << 2) >> 2] + +g[B + (f << 2) >> 2]);
r = j * x;
j = +g[q + 4 >> 2] * x;
q = s + (d << 3) | 0;
g[q >> 2] = +g[q >> 2] - r;
q = s + (d << 3) + 4 | 0;
g[q >> 2] = +g[q >> 2] - j;
q = s + (f << 3) | 0;
g[q >> 2] = r + +g[q >> 2];
q = s + (f << 3) + 4 | 0;
g[q >> 2] = j + +g[q >> 2];
a = a + 1 | 0
} while ((a | 0) < (h | 0));
i = e;
return
}
function hl(a, d) {
a = a | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D =
0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0;
e = i;
f = +g[a + 340 >> 2];
h = 1 / (+g[a + 32 >> 2] * +g[d + 4 >> 2]);
d = c[a + 236 >> 2] | 0;
if ((d | 0) > 0) {
j = a + 36 | 0;
k = a + 28 | 0;
l = c[a + 232 >> 2] | 0;
m = c[a + 96 >> 2] | 0;
n = c[a + 104 >> 2] | 0;
o = 0;
do {
p = c[l + (o * 28 | 0) >> 2] | 0;
q = c[l + (o * 28 | 0) + 4 >> 2] | 0;
r = l + (o * 28 | 0) + 16 | 0;
s = +g[r >> 2];
t = +g[r + 4 >> 2];
r = m + (p << 3) | 0;
u = +g[r >> 2];
v = +g[r + 4 >> 2];
r = q + 88 | 0;
w = +g[r >> 2];
x = q + 60 | 0;
y = q + 64 | 0;
z = q + 80 | 0;
A = q + 84 | 0;
B = n + (p << 3) | 0;
C = +g[B >> 2];
D = n + (p << 3) + 4 | 0;
E = +g[D >> 2];
F = s * (+g[z >> 2] - w * (v - +g[y >> 2]) - C) + t * (w * (u - +g[x >> 2]) + +g[A >> 2] - E);
if (F < 0 ? (w = f * +g[l + (o * 28 | 0) + 12 >> 2], G =
h * F, H = G > -.5 ? -G : .5, G = F * +g[l + (o * 28 | 0) + 24 >> 2] * (w > H ? w : H), H = s * G, s = t * G, G = +g[j >> 2] * 1.3333333730697632, t = G * +g[k >> 2] * G, g[B >> 2] = C + t * H, g[D >> 2] = E + t * s, t = -H, H = -s, (c[q >> 2] | 0) == 2) : 0) {
D = q + 4 | 0;
B = b[D >> 1] | 0;
if ((B & 2) == 0 ? (p = B & 65535, (p & 2 | 0) == 0) : 0) {
I = (p | 2) & 65535;
b[D >> 1] = I;
g[q + 160 >> 2] = 0;
J = I
} else
J = B;
if (!((J & 2) == 0)) {
s = +g[q + 136 >> 2];
g[z >> 2] = s * t + +g[z >> 2];
g[A >> 2] = s * H + +g[A >> 2];
g[r >> 2] = +g[r >> 2] + +g[q + 144 >> 2] * ((u - +g[x >> 2]) * H - (v - +g[y >> 2]) * t)
}
}
o = o + 1 | 0
} while ((o | 0) < (d | 0))
}
d = c[a + 220 >> 2] | 0;
if ((d | 0) <= 0) {
i = e;
return
}
o = c[a + 216 >> 2] | 0;
J = c[a +
104 >> 2] | 0;
a = 0;
do {
k = c[o + (a * 24 | 0) >> 2] | 0;
j = c[o + (a * 24 | 0) + 4 >> 2] | 0;
l = o + (a * 24 | 0) + 12 | 0;
t = +g[l >> 2];
v = +g[l + 4 >> 2];
l = J + (j << 3) | 0;
n = J + (k << 3) | 0;
H = +g[n >> 2];
m = J + (j << 3) + 4 | 0;
j = J + (k << 3) + 4 | 0;
u = +g[j >> 2];
s = t * (+g[l >> 2] - H) + v * (+g[m >> 2] - u);
if (s < 0) {
E = f * +g[o + (a * 24 | 0) + 8 >> 2];
C = h * s;
G = C > -.5 ? -C : .5;
C = s * (E > G ? E : G);
G = t * C;
t = v * C;
g[n >> 2] = H + G;
g[j >> 2] = u + t;
g[l >> 2] = +g[l >> 2] - G;
g[m >> 2] = +g[m >> 2] - t
}
a = a + 1 | 0
} while ((a | 0) < (d | 0));
i = e;
return
}
function il(a) {
a = a | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A =
0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0;
d = i;
e = c[a + 236 >> 2] | 0;
if ((e | 0) <= 0) {
i = d;
return
}
f = a + 96 | 0;
h = a + 104 | 0;
j = a + 36 | 0;
k = a + 28 | 0;
l = c[a + 232 >> 2] | 0;
m = c[a + 88 >> 2] | 0;
a = 0;
do {
n = c[l + (a * 28 | 0) >> 2] | 0;
if (((c[m + (n << 2) >> 2] & 2048 | 0) != 0 ? (o = c[l + (a * 28 | 0) + 4 >> 2] | 0, p = l + (a * 28 | 0) + 16 | 0, q = +g[p >> 2], r = +g[p + 4 >> 2], p = (c[f >> 2] | 0) + (n << 3) | 0, s = +g[p >> 2], t = +g[p + 4 >> 2], p = o + 88 | 0, u = +g[p >> 2], v = o + 60 | 0, w = o + 64 | 0, x = o + 80 | 0, y = o + 84 | 0, z = c[h >> 2] | 0, A = z + (n << 3) | 0, B = +g[A >> 2], C = z + (n << 3) + 4 | 0, D = +g[C >> 2], E = q * (+g[x >> 2] - u * (t - +g[w >> 2]) - B) + r * (u * (s - +g[v >> 2]) + +g[y >> 2] - D), E < 0) : 0) ? (u = E * +g[l +
(a * 28 | 0) + 24 >> 2] * .5, E = q * u, q = r * u, u = +g[j >> 2] * 1.3333333730697632, r = u * +g[k >> 2] * u, g[A >> 2] = B + E * r, g[C >> 2] = D + q * r, r = -E, E = -q, (c[o >> 2] | 0) == 2) : 0) {
C = o + 4 | 0;
A = b[C >> 1] | 0;
if ((A & 2) == 0 ? (n = A & 65535, (n & 2 | 0) == 0) : 0) {
z = (n | 2) & 65535;
b[C >> 1] = z;
g[o + 160 >> 2] = 0;
F = z
} else
F = A;
if (!((F & 2) == 0)) {
q = +g[o + 136 >> 2];
g[x >> 2] = q * r + +g[x >> 2];
g[y >> 2] = q * E + +g[y >> 2];
g[p >> 2] = +g[p >> 2] + +g[o + 144 >> 2] * ((s - +g[v >> 2]) * E - (t - +g[w >> 2]) * r)
}
}
a = a + 1 | 0
} while ((a | 0) < (e | 0));
i = d;
return
}
function jl(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s =
0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0;
d = i;
e = +g[b + 4 >> 2] * +g[a + 344 >> 2];
f = a + 268 | 0;
h = c[f >> 2] | 0;
if ((h | 0) <= 0) {
i = d;
return
}
j = a + 264 | 0;
l = a + 96 | 0;
m = a + 104 | 0;
a = h;
h = 0;
while (1) {
n = c[j >> 2] | 0;
if ((c[n + (h * 60 | 0) + 12 >> 2] & 16 | 0) == 0)
o = a;
else {
p = c[n + (h * 60 | 0) >> 2] | 0;
q = c[n + (h * 60 | 0) + 4 >> 2] | 0;
r = c[n + (h * 60 | 0) + 8 >> 2] | 0;
s = c[l >> 2] | 0;
t = s + (p << 3) | 0;
u = +g[t >> 2];
v = +g[t + 4 >> 2];
t = s + (q << 3) | 0;
w = +g[t >> 2];
x = +g[t + 4 >> 2];
t = s + (r << 3) | 0;
y = +g[t >> 2];
s = c[m >> 2] | 0;
z = +g[b >> 2];
A = s + (p << 3) | 0;
B = +g[A >> 2];
C = s + (p << 3) +
4 | 0;
D = +g[C >> 2];
E = u + z * B;
u = v + z * D;
p = s + (q << 3) | 0;
F = s + (q << 3) + 4 | 0;
v = w + z * +g[p >> 2];
w = x + z * +g[F >> 2];
q = s + (r << 3) | 0;
G = s + (r << 3) + 4 | 0;
x = y + z * +g[q >> 2];
y = +g[t + 4 >> 2] + z * +g[G >> 2];
z = (E + v + x) * .3333333432674408;
H = (u + w + y) * .3333333432674408;
I = E - z;
E = u - H;
u = v - z;
v = w - H;
w = x - z;
z = y - H;
H = +g[n + (h * 60 | 0) + 20 >> 2];
y = +g[n + (h * 60 | 0) + 24 >> 2];
t = n + (h * 60 | 0) + 28 | 0;
x = +g[t >> 2];
r = n + (h * 60 | 0) + 32 | 0;
J = +g[r >> 2];
s = n + (h * 60 | 0) + 36 | 0;
K = +g[s >> 2];
L = n + (h * 60 | 0) + 40 | 0;
M = +g[L >> 2];
N = H * E - y * I + (x * v - J * u) + (K * z - w * M);
O = H * I + y * E + (x * u + J * v) + (w * K + z * M);
M = N * N + O * O;
K = (c[k >> 2] = 1597463007 -
((g[k >> 2] = M, c[k >> 2] | 0) >> 1), +g[k >> 2]);
J = K * (1.5 - K * M * .5 * K);
K = N * J;
N = O * J;
J = e * +g[n + (h * 60 | 0) + 16 >> 2];
g[A >> 2] = B + J * (H * N - y * K - I);
g[C >> 2] = D + J * (H * K + y * N - E);
E = +g[t >> 2];
y = +g[r >> 2];
g[p >> 2] = +g[p >> 2] + J * (E * N - y * K - u);
g[F >> 2] = +g[F >> 2] + J * (E * K + y * N - v);
v = +g[s >> 2];
y = +g[L >> 2];
g[q >> 2] = +g[q >> 2] + J * (v * N - y * K - w);
g[G >> 2] = +g[G >> 2] + J * (v * K + y * N - z);
o = c[f >> 2] | 0
}
h = h + 1 | 0;
if ((h | 0) >= (o | 0))
break;
else
a = o
}
i = d;
return
}
function kl(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0;
d = i;
e = +g[b + 4 >> 2] *
+g[a + 348 >> 2];
f = c[a + 252 >> 2] | 0;
if ((f | 0) <= 0) {
i = d;
return
}
h = a + 96 | 0;
j = a + 104 | 0;
k = c[a + 248 >> 2] | 0;
a = 0;
do {
if ((c[k + (a * 20 | 0) + 8 >> 2] & 8 | 0) != 0) {
l = c[k + (a * 20 | 0) >> 2] | 0;
m = c[k + (a * 20 | 0) + 4 >> 2] | 0;
n = c[h >> 2] | 0;
o = n + (l << 3) | 0;
p = +g[o >> 2];
q = +g[o + 4 >> 2];
o = n + (m << 3) | 0;
r = +g[o >> 2];
n = c[j >> 2] | 0;
s = +g[b >> 2];
t = n + (l << 3) | 0;
u = +g[t >> 2];
v = n + (l << 3) + 4 | 0;
w = +g[v >> 2];
l = n + (m << 3) | 0;
x = n + (m << 3) + 4 | 0;
y = r + s * +g[l >> 2] - (p + s * u);
p = +g[o + 4 >> 2] + s * +g[x >> 2] - (q + s * w);
s = +Q(+(y * y + p * p));
q = (+g[k + (a * 20 | 0) + 16 >> 2] - s) * e * +g[k + (a * 20 | 0) + 12 >> 2] / s;
s = y * q;
y = p * q;
g[t >> 2] = u - s;
g[v >> 2] =
w - y;
g[l >> 2] = s + +g[l >> 2];
g[x >> 2] = y + +g[x >> 2]
}
a = a + 1 | 0
} while ((a | 0) < (f | 0));
i = d;
return
}
function ll(a) {
a = a | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0;
d = i;
e = +g[a + 340 >> 2];
f = a + 236 | 0;
if ((c[f >> 2] | 0) > 0) {
h = a + 232 | 0;
j = a + 144 | 0;
k = a + 96 | 0;
l = 0;
do {
m = c[h >> 2] | 0;
n = c[m + (l * 28 | 0) >> 2] | 0;
o = c[(c[j >> 2] | 0) + (n << 2) >> 2] | 0;
if (((o | 0) != 0 ? (c[o + 12 >> 2] & 2 | 0) !=
0 : 0) ? (p = c[m + (l * 28 | 0) + 4 >> 2] | 0, q = m + (l * 28 | 0) + 16 | 0, r = +g[q >> 2], s = +g[q + 4 >> 2], t = +g[m + (l * 28 | 0) + 12 >> 2], m = (c[k >> 2] | 0) + (n << 3) | 0, u = +g[m >> 2], v = +g[m + 4 >> 2], m = p + 88 | 0, w = +g[m >> 2], n = p + 60 | 0, q = p + 64 | 0, x = p + 80 | 0, y = +g[x >> 2] - w * (v - +g[q >> 2]), z = p + 84 | 0, A = w * (u - +g[n >> 2]) + +g[z >> 2], nk(o), B = o + 56 | 0, w = +g[B >> 2], C = o + 48 | 0, D = o + 52 | 0, E = r * (y - (+g[C >> 2] - w * (v - +g[o + 44 >> 2]))) + s * (A - (w * (u - +g[o + 40 >> 2]) + +g[D >> 2])), E < 0) : 0) {
nk(o);
w = +g[o + 32 >> 2];
nk(o);
A = +g[o + 36 >> 2];
nk(o);
F = o + 40 | 0;
y = +g[F >> 2];
if (w > 0)
G = 1 / w;
else
G = 0;
if (A > 0)
H = 1 / A;
else
H = 0;
A = s * (u - y) - r * (v - +g[F +
4 >> 2]);
y = +g[p + 132 >> 2];
w = +g[p + 44 >> 2];
I = +g[p + 48 >> 2];
J = y * (w * w + I * I);
I = +g[p + 140 >> 2] + J - J;
if (y > 0)
K = 1 / y;
else
K = 0;
if (I > 0)
L = 1 / I;
else
L = 0;
I = s * (u - +g[n >> 2]) - r * (v - +g[q >> 2]);
y = G + A * A * H + K + I * L * I;
if (y > 0)
M = E / y;
else
M = 0;
y = e * (t < 1 ? t : 1) * M;
t = G * y;
g[C >> 2] = +g[C >> 2] + r * t;
g[D >> 2] = +g[D >> 2] + s * t;
g[B >> 2] = H * A * y + +g[B >> 2];
A = -y;
y = r * A;
r = s * A;
if ((c[p >> 2] | 0) == 2) {
B = p + 4 | 0;
D = b[B >> 1] | 0;
if ((D & 2) == 0 ? (C = D & 65535, (C & 2 | 0) == 0) : 0) {
F = (C | 2) & 65535;
b[B >> 1] = F;
g[p + 160 >> 2] = 0;
N = F
} else
N = D;
if (!((N & 2) == 0)) {
A = +g[p + 136 >> 2];
g[x >> 2] = y * A + +g[x >> 2];
g[z >> 2] = r * A + +g[z >>
2];
g[m >> 2] = +g[m >> 2] + +g[p + 144 >> 2] * (r * (u - +g[n >> 2]) - y * (v - +g[q >> 2]))
}
}
}
l = l + 1 | 0
} while ((l | 0) < (c[f >> 2] | 0))
}
f = a + 220 | 0;
if ((c[f >> 2] | 0) <= 0) {
i = d;
return
}
l = a + 216 | 0;
N = a + 144 | 0;
k = a + 96 | 0;
j = a + 104 | 0;
h = a + 88 | 0;
q = a + 32 | 0;
n = a + 320 | 0;
a = 0;
do {
p = c[l >> 2] | 0;
m = c[p + (a * 24 | 0) >> 2] | 0;
z = c[p + (a * 24 | 0) + 4 >> 2] | 0;
x = p + (a * 24 | 0) + 12 | 0;
H = +g[x >> 2];
G = +g[x + 4 >> 2];
M = +g[p + (a * 24 | 0) + 8 >> 2];
p = c[N >> 2] | 0;
x = c[p + (m << 2) >> 2] | 0;
D = c[p + (z << 2) >> 2] | 0;
p = (x | 0) == 0;
if (p)
O = 0;
else
O = (c[x + 12 >> 2] & 2 | 0) != 0;
F = (D | 0) == 0;
if (F)
P = 0;
else
P = (c[D + 12 >> 2] & 2 | 0) != 0;
do if ((x | 0) != (D | 0) & (O |
P)) {
B = c[k >> 2] | 0;
L = (+g[B + (m << 3) >> 2] + +g[B + (z << 3) >> 2]) * .5;
K = (+g[B + (m << 3) + 4 >> 2] + +g[B + (z << 3) + 4 >> 2]) * .5;
if (!F ? (c[D + 12 >> 2] & 2 | 0) != 0 : 0) {
nk(D);
v = +g[D + 56 >> 2];
Q = +g[D + 48 >> 2] - v * (K - +g[D + 44 >> 2]);
R = v * (L - +g[D + 40 >> 2]) + +g[D + 52 >> 2]
} else {
B = (c[j >> 2] | 0) + (z << 3) | 0;
v = +g[B >> 2];
Q = v;
R = +g[B + 4 >> 2]
}
if (!p ? (c[x + 12 >> 2] & 2 | 0) != 0 : 0) {
nk(x);
v = +g[x + 56 >> 2];
S = +g[x + 48 >> 2] - v * (K - +g[x + 44 >> 2]);
T = v * (L - +g[x + 40 >> 2]) + +g[x + 52 >> 2]
} else {
B = (c[j >> 2] | 0) + (m << 3) | 0;
v = +g[B >> 2];
S = v;
T = +g[B + 4 >> 2]
}
v = G * (R - T) + H * (Q - S);
if (v < 0) {
if (O) {
nk(x);
y = +g[x + 32 >> 2];
nk(x);
u = +g[x +
36 >> 2];
nk(x);
B = x + 40 | 0;
r = +g[B >> 2];
if (y > 0)
U = 1 / y;
else
U = 0;
if (u > 0)
V = 1 / u;
else
V = 0;
W = V;
X = U;
Y = G * (L - r) - H * (K - +g[B + 4 >> 2])
} else {
if ((c[(c[h >> 2] | 0) + (m << 2) >> 2] & 4 | 0) == 0 ? (r = +g[q >> 2] * .75, u = r * +g[n >> 2] * r, u > 0) : 0)
Z = 1 / u;
else
Z = 0;
W = 0;
X = Z;
Y = G * (L - L) - H * (K - K)
}
if (P) {
nk(D);
u = +g[D + 32 >> 2];
nk(D);
r = +g[D + 36 >> 2];
nk(D);
B = D + 40 | 0;
y = +g[B >> 2];
if (u > 0)
_ = 1 / u;
else
_ = 0;
if (r > 0)
$ = 1 / r;
else
$ = 0;
aa = _;
ba = $;
ca = G * (L - y) - H * (K - +g[B + 4 >> 2])
} else {
if ((c[(c[h >> 2] | 0) + (z << 2) >> 2] & 4 | 0) == 0 ? (y = +g[q >> 2] * .75, r = y * +g[n >> 2] * y, r > 0) : 0)
da = 1 / r;
else
da = 0;
aa = da;
ba = 0;
ca = G * (L -
L) - H * (K - K)
}
K = X + Y * W * Y + aa + ca * ba * ca;
if (K > 0)
ea = v / K;
else
ea = 0;
K = e * M * ea;
if (O) {
v = X * K;
B = x + 48 | 0;
g[B >> 2] = H * v + +g[B >> 2];
B = x + 52 | 0;
g[B >> 2] = G * v + +g[B >> 2];
B = x + 56 | 0;
g[B >> 2] = W * Y * K + +g[B >> 2]
} else {
B = c[j >> 2] | 0;
v = X * K;
C = B + (m << 3) | 0;
g[C >> 2] = H * v + +g[C >> 2];
C = B + (m << 3) + 4 | 0;
g[C >> 2] = G * v + +g[C >> 2]
}
v = -K;
if (P) {
K = aa * v;
C = D + 48 | 0;
g[C >> 2] = H * K + +g[C >> 2];
C = D + 52 | 0;
g[C >> 2] = G * K + +g[C >> 2];
C = D + 56 | 0;
g[C >> 2] = ba * ca * v + +g[C >> 2];
break
} else {
C = c[j >> 2] | 0;
K = aa * v;
B = C + (z << 3) | 0;
g[B >> 2] = H * K + +g[B >> 2];
B = C + (z << 3) + 4 | 0;
g[B >> 2] = G * K + +g[B >> 2];
break
}
}
}
while (0);
a = a + 1 | 0
} while ((a | 0) < (c[f >> 2] | 0));
i = d;
return
}
function ml(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0;
d = i;
e = c[a + 312 >> 2] | 0;
if ((e | 0) == 0) {
i = d;
return
}
f = b + 4 | 0;
h = a + 104 | 0;
j = a + 96 | 0;
a = e;
do {
if ((c[a + 12 >> 2] & 2 | 0) != 0 ? (nk(a), k = +g[b >> 2], l = k * +g[a + 56 >> 2], m = +T(+l), n = +S(+l), l = +g[a + 40 >> 2], o = +g[a + 44 >> 2], p = k * +g[a + 48 >> 2] + l - (n * l - m * o), q = k * +g[a + 52 >> 2] + o - (m * l + n * o), e = a + 60 | 0, o = +g[a + 72 >> 2], l = +g[a + 68 >> 2], k = +(m * o + n * l), r = +(n * o - m * l), l = +g[e >> 2], o = +g[a + 64 >> 2], s = +(p + (n * l - m * o)), t = +(q + (m * l + n * o)),
u = e, g[u >> 2] = s, g[u + 4 >> 2] = t, u = a + 68 | 0, g[u >> 2] = k, g[u + 4 >> 2] = r, r = +g[f >> 2], k = p * r, p = q * r, q = m * r, m = (n + -1) * r, u = c[a + 4 >> 2] | 0, e = a + 8 | 0, (u | 0) < (c[e >> 2] | 0)) : 0) {
v = u;
do {
u = c[j >> 2] | 0;
r = +g[u + (v << 3) >> 2];
n = +g[u + (v << 3) + 4 >> 2];
t = +(k + (m * r - q * n));
s = +(p + (q * r + m * n));
u = (c[h >> 2] | 0) + (v << 3) | 0;
g[u >> 2] = t;
g[u + 4 >> 2] = s;
v = v + 1 | 0
} while ((v | 0) < (c[e >> 2] | 0))
}
a = c[a + 24 >> 2] | 0
} while ((a | 0) != 0);
i = d;
return
}
function nl(b, d, e, f) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0;
h = i;
j = +(e - d | 0);
k = +g[f >> 2] / j;
l = +g[f + 4 >> 2] / j;
if (!(k != 0 | l != 0)) {
i = h;
return
}
f = b + 21 | 0;
if ((a[f >>
0] | 0) == 0) {
xn(c[b + 112 >> 2] | 0, 0, c[b + 44 >> 2] << 3 | 0) | 0;
a[f >> 0] = 1
}
if ((d | 0) >= (e | 0)) {
i = h;
return
}
f = c[b + 112 >> 2] | 0;
b = d;
do {
d = f + (b << 3) | 0;
g[d >> 2] = k + +g[d >> 2];
d = f + (b << 3) + 4 | 0;
g[d >> 2] = l + +g[d >> 2];
b = b + 1 | 0
} while ((b | 0) != (e | 0));
i = h;
return
}
function ol(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0;
f = i;
h = +g[a + 32 >> 2] * .75;
j = +(d - b | 0) * h * +g[a + 320 >> 2] * h;
h = +g[e >> 2] / j;
k = +g[e + 4 >> 2] / j;
if ((b | 0) >= (d | 0)) {
i = f;
return
}
e = c[a + 104 >> 2] | 0;
a = b;
do {
b = e + (a << 3) | 0;
g[b >> 2] = h + +g[b >> 2];
b = e + (a << 3) + 4 | 0;
g[b >> 2] = k + +g[b >> 2];
a = a + 1 | 0
} while ((a | 0) != (d |
0));
i = f;
return
}
function pl(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0;
e = i;
f = c[a + 204 >> 2] | 0;
if ((f | 0) == 0) {
i = e;
return
}
h = c[a + 200 >> 2] | 0;
j = +g[a + 36 >> 2];
k = +g[d >> 2];
l = d + 4 | 0;
m = (~~(j * +g[l >> 2] + 2048) >>> 0 << 20) + (~~(j * k * 256 + 524288) >>> 0) | 0;
n = h;
o = f << 3 >> 3;
a:
while (1) {
p = o;
while (1) {
if ((p | 0) == 0)
break a;
q = (p | 0) / 2 | 0;
if ((c[n + (q << 3) + 4 >> 2] | 0) >>> 0 < m >>> 0)
break;
else
p = q
}
n = n + (q + 1 << 3) | 0;
o = p + -1 - q | 0
}
q = d + 8 | 0;
o = d + 12 | 0;
m = (~~(j * +g[o >> 2] + 2048) >>> 0 << 20) + (~~(j * +g[q >> 2] * 256 + 524288) >>> 0) | 0;
r = n;
s =
h + (f << 3) - n >> 3;
b:
while (1) {
f = s;
while (1) {
if ((f | 0) == 0)
break b;
t = (f | 0) / 2 | 0;
if ((c[r + (t << 3) + 4 >> 2] | 0) >>> 0 > m >>> 0)
f = t;
else
break
}
r = r + (t + 1 << 3) | 0;
s = f + -1 - t | 0
}
if (!(n >>> 0 < r >>> 0)) {
i = e;
return
}
t = a + 96 | 0;
j = k;
s = n;
while (1) {
n = c[s >> 2] | 0;
m = c[t >> 2] | 0;
k = +g[m + (n << 3) >> 2];
if ((((j < k ? k < +g[q >> 2] : 0) ? (k = +g[m + (n << 3) + 4 >> 2], +g[l >> 2] < k) : 0) ? k < +g[o >> 2] : 0) ? !(hb[c[(c[b >> 2] | 0) + 12 >> 2] & 15](b, a, n) | 0) : 0) {
u = 21;
break
}
n = s + 8 | 0;
if (!(n >>> 0 < r >>> 0)) {
u = 21;
break
}
j = +g[d >> 2];
s = n
}
if ((u | 0) == 21) {
i = e;
return
}
}
function ql(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f =
0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0;
f = i;
i = i + 64 | 0;
h = f;
j = f + 32 | 0;
k = f + 24 | 0;
l = f + 16 | 0;
if ((c[a + 204 >> 2] | 0) == 0) {
i = f;
return
}
m = +g[d >> 2];
n = +g[e >> 2];
o = d + 4 | 0;
p = +g[o >> 2];
q = +g[e + 4 >> 2];
r = +(m < n ? m : n);
s = +(p < q ? p : q);
e = h;
g[e >> 2] = r;
g[e + 4 >> 2] = s;
s = +(m > n ? m : n);
r = +(p > q ? p : q);
e = h + 8 | 0;
g[e >> 2] = s;
g[e + 4 >> 2] = r;
r = n - m;
m = q - p;
p = r * r + m * m;
Nk(j, a, h);
h = j + 16 | 0;
e = c[j + 20 >> 2] | 0;
t = j + 4 | 0;
u = a + 96 | 0;
v = a + 40 | 0;
w = k + 4 | 0;
x = l + 4 | 0;
y = c[h >> 2] | 0;
q = 1;
a:
while (1) {
if (!(y >>>
0 < e >>> 0)) {
z = 16;
break
}
A = c[j >> 2] | 0;
B = c[t >> 2] | 0;
C = y;
while (1) {
D = c[C + 4 >> 2] & 1048575;
E = C;
C = C + 8 | 0;
c[h >> 2] = C;
if (D >>> 0 < A >>> 0 | D >>> 0 > B >>> 0)
if (C >>> 0 < e >>> 0) {
C = C;
continue
} else {
z = 16;
break a
}
F = c[E >> 2] | 0;
if (!((F | 0) > -1)) {
z = 16;
break a
}
E = c[u >> 2] | 0;
G = +g[d >> 2];
H = G - +g[E + (F << 3) >> 2];
I = +g[o >> 2];
J = I - +g[E + (F << 3) + 4 >> 2];
n = r * H + m * J;
s = n * n - p * (H * H + J * J - +g[v >> 2]);
if (s >= 0 ? (K = +Q(+s), s = (-n - K) / p, !(s > q)) : 0) {
if (!(s < 0)) {
L = s;
break
}
s = (K - n) / p;
if (!(s < 0 | s > q)) {
L = s;
break
}
}
if (!(C >>> 0 < e >>> 0)) {
z = 16;
break a
}
}
s = r * L;
n = m * L;
K = H + s;
M = J + n;
g[k >> 2] = K;
g[w >> 2] = M;
N = +Q(+(K * K + M * M));
if (!(N < 1.1920928955078125E-7)) {
O = 1 / N;
g[k >> 2] = K * O;
g[w >> 2] = M * O
}
B = c[(c[b >> 2] | 0) + 12 >> 2] | 0;
g[l >> 2] = s + G;
g[x >> 2] = n + I;
n = +ab[B & 1](b, a, F, l, k, L);
q = q < n ? q : n;
if (q <= 0) {
z = 16;
break
} else
y = C
}
if ((z | 0) == 16) {
i = f;
return
}
}
function rl(b, c, e) {
b = b | 0;
c = c | 0;
e = e | 0;
var f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0;
f = i;
g = ((e + -4 + (0 - c) | 0) >>> 2) + 1 | 0;
h = b;
j = c;
k = c;
while (1) {
c = d[h >> 0] | d[h + 1 >> 0] << 8 | d[h + 2 >> 0] << 16 | d[h + 3 >> 0] << 24;
l = k + 1 | 0;
m = a[l >> 0] | 0;
n = k + 2 | 0;
o = a[n >> 0] | 0;
p = k + 3 | 0;
q = a[p >> 0] | 0;
a[h >> 0] = a[k >>
0] | 0;
a[h + 1 >> 0] = m;
a[h + 2 >> 0] = o;
a[h + 3 >> 0] = q;
a[k >> 0] = c;
a[l >> 0] = c >>> 8;
a[n >> 0] = c >>> 16;
a[p >> 0] = c >>> 24;
c = h + 4 | 0;
p = k + 4 | 0;
r = (c | 0) == (j | 0);
if ((p | 0) == (e | 0))
break;
h = c;
j = r ? p : j;
k = p
}
k = b + (g << 2) | 0;
if (r) {
i = f;
return k | 0
} else {
s = k;
t = j;
u = j
}
a:
while (1) {
j = s;
r = u;
while (1) {
g = d[j >> 0] | d[j + 1 >> 0] << 8 | d[j + 2 >> 0] << 16 | d[j + 3 >> 0] << 24;
b = r + 1 | 0;
h = a[b >> 0] | 0;
p = r + 2 | 0;
c = a[p >> 0] | 0;
n = r + 3 | 0;
l = a[n >> 0] | 0;
a[j >> 0] = a[r >> 0] | 0;
a[j + 1 >> 0] = h;
a[j + 2 >> 0] = c;
a[j + 3 >> 0] = l;
a[r >> 0] = g;
a[b >> 0] = g >>> 8;
a[p >> 0] = g >>> 16;
a[n >> 0] = g >>> 24;
j = j + 4 | 0;
v = r + 4 | 0;
w = (j | 0) == (t | 0);
if ((v | 0) !=
(e | 0))
break;
if (w)
break a;
else
r = t
}
s = j;
t = w ? v : t;
u = v
}
i = f;
return k | 0
}
function sl(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0;
e = i;
f = a;
a = b;
a:
while (1) {
b = a;
g = a + -4 | 0;
h = f;
b:
while (1) {
j = h;
k = b - j | 0;
l = k >> 2;
switch (l | 0) {
case 2:
m = 4;
break a;
break;
case 3:
m = 6;
break a;
break;
case 5:
m = 8;
break a;
break;
case 4:
m = 7;
break a;
break;
case 1:
case 0:
m = 51;
break a;
break;
default:
}
if ((k |
0) < 124) {
m = 10;
break a
}
n = (l | 0) / 2 | 0;
o = h + (n << 2) | 0;
if ((k | 0) > 3996) {
k = (l | 0) / 4 | 0;
p = vl(h, h + (k << 2) | 0, o, h + (k + n << 2) | 0, g, d) | 0
} else
p = tl(h, o, g, c[d >> 2] | 0) | 0;
n = c[h >> 2] | 0;
k = c[d >> 2] | 0;
l = c[k + (n << 2) >> 2] | 0;
q = c[k + (c[o >> 2] << 2) >> 2] | 0;
r = +(l | 0) <= 0;
s = +(q | 0) <= 0;
do if (r ^ s ? r : (l | 0) > (q | 0)) {
t = g;
u = p
} else {
v = g;
while (1) {
v = v + -4 | 0;
if ((h | 0) == (v | 0))
break;
w = c[v >> 2] | 0;
x = c[k + (w << 2) >> 2] | 0;
y = +(x | 0) <= 0;
if (y ^ s ? y : (x | 0) > (q | 0)) {
m = 34;
break
}
}
if ((m | 0) == 34) {
m = 0;
c[h >> 2] = w;
c[v >> 2] = n;
t = v;
u = p + 1 | 0;
break
}
x = h + 4 | 0;
y = c[g >> 2] | 0;
z = c[k + (y << 2) >> 2] | 0;
if (r ^ +(z | 0) <=
0 ? r : (l | 0) > (z | 0))
A = x;
else {
if ((x | 0) == (g | 0)) {
m = 51;
break a
} else
B = x;
while (1) {
C = c[B >> 2] | 0;
x = c[k + (C << 2) >> 2] | 0;
D = B + 4 | 0;
if (r ^ +(x | 0) <= 0 ? r : (l | 0) > (x | 0))
break;
if ((D | 0) == (g | 0)) {
m = 51;
break a
} else
B = D
}
c[B >> 2] = y;
c[g >> 2] = C;
A = D
}
if ((A | 0) == (g | 0)) {
m = 51;
break a
} else {
E = A;
F = g
}
while (1) {
v = c[k + (c[h >> 2] << 2) >> 2] | 0;
x = +(v | 0) <= 0;
z = E;
while (1) {
G = c[z >> 2] | 0;
H = c[k + (G << 2) >> 2] | 0;
I = z + 4 | 0;
if (x ^ +(H | 0) <= 0 ? x : (v | 0) > (H | 0)) {
J = F;
break
} else
z = I
}
do {
J = J + -4 | 0;
K = c[J >> 2] | 0;
H = c[k + (K << 2) >> 2] | 0
} while (x ^ +(H | 0) <= 0 ? x : (v | 0) > (H | 0));
if (!(z >>> 0 < J >>> 0)) {
h = z;
continue b
}
c[z >>
2] = K;
c[J >> 2] = G;
E = I;
F = J
}
}
while (0);
l = h + 4 | 0;
c:
do if (l >>> 0 < t >>> 0) {
r = l;
n = t;
q = o;
s = u;
while (1) {
y = c[k + (c[q >> 2] << 2) >> 2] | 0;
v = +(y | 0) <= 0;
x = r;
while (1) {
L = c[x >> 2] | 0;
H = c[k + (L << 2) >> 2] | 0;
M = +(H | 0) <= 0;
N = x + 4 | 0;
if (M ^ v ? M : (H | 0) > (y | 0))
x = N;
else {
O = n;
break
}
}
do {
O = O + -4 | 0;
P = c[O >> 2] | 0;
z = c[k + (P << 2) >> 2] | 0;
H = +(z | 0) <= 0
} while (!(H ^ v ? H : (z | 0) > (y | 0)));
if (x >>> 0 > O >>> 0) {
Q = x;
R = q;
S = s;
break c
}
c[x >> 2] = P;
c[O >> 2] = L;
r = N;
n = O;
q = (q | 0) == (x | 0) ? O : q;
s = s + 1 | 0
}
} else {
Q = l;
R = o;
S = u
}
while (0);
if ((Q | 0) != (R | 0) ? (o = c[R >> 2] | 0, l = c[Q >> 2] | 0, s = c[k + (o << 2) >> 2] | 0, q = c[k + (l << 2) >>
2] | 0, n = +(s | 0) <= 0, n ^ +(q | 0) <= 0 ? n : (s | 0) > (q | 0)) : 0) {
c[Q >> 2] = o;
c[R >> 2] = l;
T = S + 1 | 0
} else
T = S;
if ((T | 0) == 0) {
U = wl(h, Q, d) | 0;
l = Q + 4 | 0;
if (wl(l, a, d) | 0) {
m = 46;
break
}
if (U) {
h = l;
continue
}
}
l = Q;
if ((l - j | 0) >= (b - l | 0)) {
m = 50;
break
}
sl(h, Q, d);
h = Q + 4 | 0
}
if ((m | 0) == 46) {
m = 0;
if (U) {
m = 51;
break
} else {
f = h;
a = Q;
continue
}
} else if ((m | 0) == 50) {
m = 0;
sl(Q + 4 | 0, a, d);
f = h;
a = Q;
continue
}
}
if ((m | 0) == 4) {
Q = c[g >> 2] | 0;
f = c[h >> 2] | 0;
U = c[d >> 2] | 0;
T = c[U + (Q << 2) >> 2] | 0;
S = c[U + (f << 2) >> 2] | 0;
U = +(T | 0) <= 0;
if (!(U ^ +(S | 0) <= 0 ? U : (T | 0) > (S | 0))) {
i = e;
return
}
c[h >> 2] = Q;
c[g >> 2] = f;
i = e;
return
} else if ((m |
0) == 6) {
tl(h, h + 4 | 0, g, c[d >> 2] | 0) | 0;
i = e;
return
} else if ((m | 0) == 7) {
ul(h, h + 4 | 0, h + 8 | 0, g, d) | 0;
i = e;
return
} else if ((m | 0) == 8) {
vl(h, h + 4 | 0, h + 8 | 0, h + 12 | 0, g, d) | 0;
i = e;
return
} else if ((m | 0) == 10) {
g = h + 8 | 0;
tl(h, h + 4 | 0, g, c[d >> 2] | 0) | 0;
f = h + 12 | 0;
if ((f | 0) == (a | 0)) {
i = e;
return
}
Q = c[d >> 2] | 0;
d = f;
f = g;
while (1) {
g = c[d >> 2] | 0;
S = c[f >> 2] | 0;
T = Q + (g << 2) | 0;
U = c[T >> 2] | 0;
R = c[Q + (S << 2) >> 2] | 0;
u = +(U | 0) <= 0;
if (u ^ +(R | 0) <= 0 ? u : (U | 0) > (R | 0)) {
R = S;
S = d;
U = f;
while (1) {
c[S >> 2] = R;
if ((U | 0) == (h | 0)) {
V = h;
break
}
u = U + -4 | 0;
R = c[u >> 2] | 0;
O = c[T >> 2] | 0;
N = c[Q + (R << 2) >> 2] | 0;
L = +(O |
0) <= 0;
if (!(L ^ +(N | 0) <= 0 ? L : (O | 0) > (N | 0))) {
V = U;
break
} else {
N = U;
U = u;
S = N
}
}
c[V >> 2] = g
}
S = d + 4 | 0;
if ((S | 0) == (a | 0))
break;
else {
U = d;
d = S;
f = U
}
}
i = e;
return
} else if ((m | 0) == 51) {
i = e;
return
}
}
function tl(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0;
f = i;
g = c[b >> 2] | 0;
h = c[a >> 2] | 0;
j = c[e + (g << 2) >> 2] | 0;
k = e + (h << 2) | 0;
l = c[k >> 2] | 0;
m = +(j | 0) <= 0;
n = c[d >> 2] | 0;
o = c[e + (n << 2) >> 2] | 0;
p = +(o | 0) <= 0;
q = p ^ m ? p : (o | 0) > (j | 0);
if (!(m ^ +(l | 0) <= 0 ? m : (j | 0) > (l | 0))) {
if (!q) {
r = 0;
i = f;
return r | 0
}
c[b >> 2] = n;
c[d >> 2] = g;
l = c[b >> 2] | 0;
j = c[a >> 2] | 0;
m = c[e + (l << 2) >> 2] | 0;
o = c[e + (j << 2) >> 2] | 0;
p = +(m | 0) <= 0;
if (!(p ^ +(o | 0) <= 0 ? p : (m | 0) > (o | 0))) {
r = 1;
i = f;
return r | 0
}
c[a >> 2] = l;
c[b >> 2] = j;
r = 2;
i = f;
return r | 0
}
if (q) {
c[a >> 2] = n;
c[d >> 2] = h;
r = 1;
i = f;
return r | 0
}
c[a >> 2] = g;
c[b >> 2] = h;
g = c[d >> 2] | 0;
a = c[e + (g << 2) >> 2] | 0;
e = c[k >> 2] | 0;
k = +(a | 0) <= 0;
if (!(k ^ +(e | 0) <= 0 ? k : (a | 0) > (e | 0))) {
r = 1;
i = f;
return r | 0
}
c[b >> 2] = g;
c[d >> 2] = h;
r = 2;
i = f;
return r | 0
}
function ul(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0;
g = i;
h = tl(a, b, d, c[f >> 2] | 0) | 0;
j = c[e >> 2] | 0;
k = c[d >> 2] |
0;
l = c[f >> 2] | 0;
f = c[l + (j << 2) >> 2] | 0;
m = c[l + (k << 2) >> 2] | 0;
n = +(f | 0) <= 0;
if (!(n ^ +(m | 0) <= 0 ? n : (f | 0) > (m | 0))) {
o = h;
i = g;
return o | 0
}
c[d >> 2] = j;
c[e >> 2] = k;
k = c[d >> 2] | 0;
e = c[b >> 2] | 0;
j = c[l + (k << 2) >> 2] | 0;
m = c[l + (e << 2) >> 2] | 0;
f = +(j | 0) <= 0;
if (!(f ^ +(m | 0) <= 0 ? f : (j | 0) > (m | 0))) {
o = h + 1 | 0;
i = g;
return o | 0
}
c[b >> 2] = k;
c[d >> 2] = e;
e = c[b >> 2] | 0;
d = c[a >> 2] | 0;
k = c[l + (e << 2) >> 2] | 0;
m = c[l + (d << 2) >> 2] | 0;
l = +(k | 0) <= 0;
if (!(l ^ +(m | 0) <= 0 ? l : (k | 0) > (m | 0))) {
o = h + 2 | 0;
i = g;
return o | 0
}
c[a >> 2] = e;
c[b >> 2] = d;
o = h + 3 | 0;
i = g;
return o | 0
}
function vl(a, b, d, e, f, g) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
h = i;
j = ul(a, b, d, e, g) | 0;
k = c[f >> 2] | 0;
l = c[e >> 2] | 0;
m = c[g >> 2] | 0;
g = c[m + (k << 2) >> 2] | 0;
n = c[m + (l << 2) >> 2] | 0;
o = +(g | 0) <= 0;
if (!(o ^ +(n | 0) <= 0 ? o : (g | 0) > (n | 0))) {
p = j;
i = h;
return p | 0
}
c[e >> 2] = k;
c[f >> 2] = l;
l = c[e >> 2] | 0;
f = c[d >> 2] | 0;
k = c[m + (l << 2) >> 2] | 0;
n = c[m + (f << 2) >> 2] | 0;
g = +(k | 0) <= 0;
if (!(g ^ +(n | 0) <= 0 ? g : (k | 0) > (n | 0))) {
p = j + 1 | 0;
i = h;
return p | 0
}
c[d >> 2] = l;
c[e >> 2] = f;
f = c[d >> 2] | 0;
e = c[b >> 2] | 0;
l = c[m + (f << 2) >> 2] | 0;
n = c[m + (e << 2) >> 2] | 0;
k = +(l | 0) <= 0;
if (!(k ^ +(n | 0) <= 0 ? k : (l | 0) > (n | 0))) {
p = j + 2 | 0;
i =
h;
return p | 0
}
c[b >> 2] = f;
c[d >> 2] = e;
e = c[b >> 2] | 0;
d = c[a >> 2] | 0;
f = c[m + (e << 2) >> 2] | 0;
n = c[m + (d << 2) >> 2] | 0;
m = +(f | 0) <= 0;
if (!(m ^ +(n | 0) <= 0 ? m : (f | 0) > (n | 0))) {
p = j + 3 | 0;
i = h;
return p | 0
}
c[a >> 2] = e;
c[b >> 2] = d;
p = j + 4 | 0;
i = h;
return p | 0
}
function wl(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0;
e = i;
switch (b - a >> 2 | 0) {
case 3:
tl(a, a + 4 | 0, b + -4 | 0, c[d >> 2] | 0) | 0;
f = 1;
i = e;
return f | 0;
case 2:
g = b + -4 | 0;
h = c[g >> 2] | 0;
j = c[a >> 2] | 0;
k = c[d >> 2] | 0;
l = c[k + (h << 2) >> 2] | 0;
m = c[k + (j << 2) >> 2] | 0;
k = +(l | 0) <= 0;
if (!(k ^
+(m | 0) <= 0 ? k : (l | 0) > (m | 0))) {
f = 1;
i = e;
return f | 0
}
c[a >> 2] = h;
c[g >> 2] = j;
f = 1;
i = e;
return f | 0;
case 4:
ul(a, a + 4 | 0, a + 8 | 0, b + -4 | 0, d) | 0;
f = 1;
i = e;
return f | 0;
case 1:
case 0:
f = 1;
i = e;
return f | 0;
case 5:
vl(a, a + 4 | 0, a + 8 | 0, a + 12 | 0, b + -4 | 0, d) | 0;
f = 1;
i = e;
return f | 0;
default:
j = a + 8 | 0;
tl(a, a + 4 | 0, j, c[d >> 2] | 0) | 0;
g = a + 12 | 0;
if ((g | 0) == (b | 0)) {
f = 1;
i = e;
return f | 0
}
h = c[d >> 2] | 0;
d = 0;
m = g;
g = j;
while (1) {
j = c[m >> 2] | 0;
l = c[g >> 2] | 0;
k = h + (j << 2) | 0;
n = c[k >> 2] | 0;
o = c[h + (l << 2) >> 2] | 0;
p = +(n | 0) <= 0;
if (p ^ +(o | 0) <= 0 ? p : (n | 0) > (o | 0)) {
o = l;
l = m;
n = g;
while (1) {
c[l >> 2] = o;
if ((n |
0) == (a | 0)) {
q = a;
break
}
p = n + -4 | 0;
o = c[p >> 2] | 0;
r = c[k >> 2] | 0;
s = c[h + (o << 2) >> 2] | 0;
t = +(r | 0) <= 0;
if (!(t ^ +(s | 0) <= 0 ? t : (r | 0) > (s | 0))) {
q = n;
break
} else {
s = n;
n = p;
l = s
}
}
c[q >> 2] = j;
l = d + 1 | 0;
if ((l | 0) == 8)
break;
else
u = l
} else
u = d;
l = m + 4 | 0;
if ((l | 0) == (b | 0)) {
f = 1;
v = 15;
break
} else {
n = m;
d = u;
m = l;
g = n
}
}
if ((v | 0) == 15) {
i = e;
return f | 0
}
f = (m + 4 | 0) == (b | 0);
i = e;
return f | 0
}
return 0
}
function xl(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0;
d = i;
i = i + 32 | 0;
e = d + 16 | 0;
f = d + 8 | 0;
h = d;
j = a + 4 | 0;
k = a + 8 | 0;
if ((c[b >> 2] | 0) == (c[j >> 2] | 0)) {
l = c[k >> 2] |
0;
c[a + 8 >> 2] = l + 1;
if ((l | 0) > 3) {
l = c[a + 12 >> 2] | 0;
c[l >> 2] = (c[l >> 2] | 0) + 1;
m = 1;
i = d;
return m | 0
}
} else {
c[k >> 2] = 0;
c[j >> 2] = c[b >> 2];
c[a + 8 >> 2] = 1
}
j = b + 16 | 0;
n = +g[j >> 2];
k = c[a >> 2] | 0;
o = +g[k + 32 >> 2] * (1 - +g[b + 12 >> 2]);
l = c[b >> 2] | 0;
p = c[k + 96 >> 2] | 0;
q = +g[j + 4 >> 2] * o + +g[p + (l << 3) + 4 >> 2];
g[e >> 2] = +g[p + (l << 3) >> 2] + n * o;
g[e + 4 >> 2] = q;
l = b + 8 | 0;
b = c[l >> 2] | 0;
p = c[b + 12 >> 2] | 0;
if (hb[c[(c[p >> 2] | 0) + 16 >> 2] & 15](p, (c[b + 8 >> 2] | 0) + 12 | 0, e) | 0) {
m = 0;
i = d;
return m | 0
}
b = c[(c[l >> 2] | 0) + 12 >> 2] | 0;
p = bb[c[(c[b >> 2] | 0) + 12 >> 2] & 7](b) | 0;
a:
do if ((p | 0) > 0) {
b = 0;
while (1) {
j = c[l >> 2] |
0;
k = c[j + 12 >> 2] | 0;
mb[c[(c[k >> 2] | 0) + 20 >> 2] & 7](k, (c[j + 8 >> 2] | 0) + 12 | 0, e, f, h, b);
b = b + 1 | 0;
if (+g[f >> 2] < .004999999888241291) {
m = 0;
break
}
if ((b | 0) >= (p | 0))
break a
}
i = d;
return m | 0
}
while (0);
p = c[a + 12 >> 2] | 0;
c[p >> 2] = (c[p >> 2] | 0) + 1;
m = 1;
i = d;
return m | 0
}
function yl(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0;
e = i;
i = i + 32 | 0;
f = e;
g = a;
a = b;
a:
while (1) {
b = a;
h = a + -28 | 0;
j = g;
b:
while (1) {
k = j;
l = b - k | 0;
switch ((l | 0) / 28 | 0 | 0) {
case 4:
m =
14;
break a;
break;
case 3:
m = 6;
break a;
break;
case 5:
m = 15;
break a;
break;
case 1:
case 0:
m = 67;
break a;
break;
case 2:
m = 4;
break a;
break;
default:
}
if ((l | 0) < 868) {
m = 21;
break a
}
n = (l | 0) / 56 | 0;
o = j + (n * 28 | 0) | 0;
do if ((l | 0) > 27972) {
p = (l | 0) / 112 | 0;
q = j + (p * 28 | 0) | 0;
r = j + ((p + n | 0) * 28 | 0) | 0;
p = zl(j, q, o, r, d) | 0;
if (nb[c[d >> 2] & 31](h, r) | 0) {
c[f + 0 >> 2] = c[r + 0 >> 2];
c[f + 4 >> 2] = c[r + 4 >> 2];
c[f + 8 >> 2] = c[r + 8 >> 2];
c[f + 12 >> 2] = c[r + 12 >> 2];
c[f + 16 >> 2] = c[r + 16 >> 2];
c[f + 20 >> 2] = c[r + 20 >> 2];
c[f + 24 >> 2] = c[r + 24 >> 2];
c[r + 0 >> 2] = c[h + 0 >> 2];
c[r + 4 >> 2] = c[h + 4 >> 2];
c[r + 8 >> 2] =
c[h + 8 >> 2];
c[r + 12 >> 2] = c[h + 12 >> 2];
c[r + 16 >> 2] = c[h + 16 >> 2];
c[r + 20 >> 2] = c[h + 20 >> 2];
c[r + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
s = p + 1 | 0;
if (nb[c[d >> 2] & 31](r, o) | 0) {
c[f + 0 >> 2] = c[o + 0 >> 2];
c[f + 4 >> 2] = c[o + 4 >> 2];
c[f + 8 >> 2] = c[o + 8 >> 2];
c[f + 12 >> 2] = c[o + 12 >> 2];
c[f + 16 >> 2] = c[o + 16 >> 2];
c[f + 20 >> 2] = c[o + 20 >> 2];
c[f + 24 >> 2] = c[o + 24 >> 2];
c[o + 0 >> 2] = c[r + 0 >> 2];
c[o + 4 >> 2] = c[r + 4 >> 2];
c[o + 8 >> 2] = c[r + 8 >> 2];
c[o + 12 >> 2] = c[r +
12 >> 2];
c[o + 16 >> 2] = c[r + 16 >> 2];
c[o + 20 >> 2] = c[r + 20 >> 2];
c[o + 24 >> 2] = c[r + 24 >> 2];
c[r + 0 >> 2] = c[f + 0 >> 2];
c[r + 4 >> 2] = c[f + 4 >> 2];
c[r + 8 >> 2] = c[f + 8 >> 2];
c[r + 12 >> 2] = c[f + 12 >> 2];
c[r + 16 >> 2] = c[f + 16 >> 2];
c[r + 20 >> 2] = c[f + 20 >> 2];
c[r + 24 >> 2] = c[f + 24 >> 2];
r = p + 2 | 0;
if (nb[c[d >> 2] & 31](o, q) | 0) {
c[f + 0 >> 2] = c[q + 0 >> 2];
c[f + 4 >> 2] = c[q + 4 >> 2];
c[f + 8 >> 2] = c[q + 8 >> 2];
c[f + 12 >> 2] = c[q + 12 >> 2];
c[f + 16 >> 2] = c[q + 16 >> 2];
c[f + 20 >> 2] = c[q + 20 >> 2];
c[f + 24 >> 2] = c[q + 24 >> 2];
c[q + 0 >> 2] = c[o + 0 >> 2];
c[q + 4 >> 2] = c[o + 4 >> 2];
c[q + 8 >> 2] = c[o + 8 >> 2];
c[q + 12 >> 2] = c[o + 12 >> 2];
c[q + 16 >> 2] = c[o + 16 >>
2];
c[q + 20 >> 2] = c[o + 20 >> 2];
c[q + 24 >> 2] = c[o + 24 >> 2];
c[o + 0 >> 2] = c[f + 0 >> 2];
c[o + 4 >> 2] = c[f + 4 >> 2];
c[o + 8 >> 2] = c[f + 8 >> 2];
c[o + 12 >> 2] = c[f + 12 >> 2];
c[o + 16 >> 2] = c[f + 16 >> 2];
c[o + 20 >> 2] = c[f + 20 >> 2];
c[o + 24 >> 2] = c[f + 24 >> 2];
if (nb[c[d >> 2] & 31](q, j) | 0) {
c[f + 0 >> 2] = c[j + 0 >> 2];
c[f + 4 >> 2] = c[j + 4 >> 2];
c[f + 8 >> 2] = c[j + 8 >> 2];
c[f + 12 >> 2] = c[j + 12 >> 2];
c[f + 16 >> 2] = c[j + 16 >> 2];
c[f + 20 >> 2] = c[j + 20 >> 2];
c[f + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[q + 0 >> 2];
c[j + 4 >> 2] = c[q + 4 >> 2];
c[j + 8 >> 2] = c[q + 8 >> 2];
c[j + 12 >> 2] = c[q + 12 >> 2];
c[j + 16 >> 2] = c[q + 16 >> 2];
c[j + 20 >> 2] = c[q + 20 >> 2];
c[j + 24 >>
2] = c[q + 24 >> 2];
c[q + 0 >> 2] = c[f + 0 >> 2];
c[q + 4 >> 2] = c[f + 4 >> 2];
c[q + 8 >> 2] = c[f + 8 >> 2];
c[q + 12 >> 2] = c[f + 12 >> 2];
c[q + 16 >> 2] = c[f + 16 >> 2];
c[q + 20 >> 2] = c[f + 20 >> 2];
c[q + 24 >> 2] = c[f + 24 >> 2];
t = p + 4 | 0
} else
t = p + 3 | 0
} else
t = r
} else
t = s
} else
t = p
} else {
p = nb[c[d >> 2] & 31](o, j) | 0;
s = nb[c[d >> 2] & 31](h, o) | 0;
if (!p) {
if (!s) {
t = 0;
break
}
c[f + 0 >> 2] = c[o + 0 >> 2];
c[f + 4 >> 2] = c[o + 4 >> 2];
c[f + 8 >> 2] = c[o + 8 >> 2];
c[f + 12 >> 2] = c[o + 12 >> 2];
c[f + 16 >> 2] = c[o + 16 >> 2];
c[f + 20 >> 2] = c[o + 20 >> 2];
c[f + 24 >> 2] = c[o + 24 >> 2];
c[o + 0 >> 2] = c[h + 0 >> 2];
c[o + 4 >> 2] = c[h + 4 >> 2];
c[o + 8 >> 2] = c[h + 8 >> 2];
c[o + 12 >>
2] = c[h + 12 >> 2];
c[o + 16 >> 2] = c[h + 16 >> 2];
c[o + 20 >> 2] = c[h + 20 >> 2];
c[o + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
if (!(nb[c[d >> 2] & 31](o, j) | 0)) {
t = 1;
break
}
c[f + 0 >> 2] = c[j + 0 >> 2];
c[f + 4 >> 2] = c[j + 4 >> 2];
c[f + 8 >> 2] = c[j + 8 >> 2];
c[f + 12 >> 2] = c[j + 12 >> 2];
c[f + 16 >> 2] = c[j + 16 >> 2];
c[f + 20 >> 2] = c[j + 20 >> 2];
c[f + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[o + 0 >> 2];
c[j + 4 >> 2] = c[o + 4 >> 2];
c[j + 8 >> 2] = c[o + 8 >> 2];
c[j + 12 >> 2] = c[o + 12 >> 2];
c[j +
16 >> 2] = c[o + 16 >> 2];
c[j + 20 >> 2] = c[o + 20 >> 2];
c[j + 24 >> 2] = c[o + 24 >> 2];
c[o + 0 >> 2] = c[f + 0 >> 2];
c[o + 4 >> 2] = c[f + 4 >> 2];
c[o + 8 >> 2] = c[f + 8 >> 2];
c[o + 12 >> 2] = c[f + 12 >> 2];
c[o + 16 >> 2] = c[f + 16 >> 2];
c[o + 20 >> 2] = c[f + 20 >> 2];
c[o + 24 >> 2] = c[f + 24 >> 2];
t = 2;
break
}
if (s) {
c[f + 0 >> 2] = c[j + 0 >> 2];
c[f + 4 >> 2] = c[j + 4 >> 2];
c[f + 8 >> 2] = c[j + 8 >> 2];
c[f + 12 >> 2] = c[j + 12 >> 2];
c[f + 16 >> 2] = c[j + 16 >> 2];
c[f + 20 >> 2] = c[j + 20 >> 2];
c[f + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[h + 0 >> 2];
c[j + 4 >> 2] = c[h + 4 >> 2];
c[j + 8 >> 2] = c[h + 8 >> 2];
c[j + 12 >> 2] = c[h + 12 >> 2];
c[j + 16 >> 2] = c[h + 16 >> 2];
c[j + 20 >> 2] = c[h + 20 >> 2];
c[j +
24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
t = 1;
break
}
c[f + 0 >> 2] = c[j + 0 >> 2];
c[f + 4 >> 2] = c[j + 4 >> 2];
c[f + 8 >> 2] = c[j + 8 >> 2];
c[f + 12 >> 2] = c[j + 12 >> 2];
c[f + 16 >> 2] = c[j + 16 >> 2];
c[f + 20 >> 2] = c[j + 20 >> 2];
c[f + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[o + 0 >> 2];
c[j + 4 >> 2] = c[o + 4 >> 2];
c[j + 8 >> 2] = c[o + 8 >> 2];
c[j + 12 >> 2] = c[o + 12 >> 2];
c[j + 16 >> 2] = c[o + 16 >> 2];
c[j + 20 >> 2] = c[o + 20 >> 2];
c[j + 24 >> 2] = c[o + 24 >> 2];
c[o + 0 >> 2] = c[f + 0 >> 2];
c[o + 4 >> 2] =
c[f + 4 >> 2];
c[o + 8 >> 2] = c[f + 8 >> 2];
c[o + 12 >> 2] = c[f + 12 >> 2];
c[o + 16 >> 2] = c[f + 16 >> 2];
c[o + 20 >> 2] = c[f + 20 >> 2];
c[o + 24 >> 2] = c[f + 24 >> 2];
if (nb[c[d >> 2] & 31](h, o) | 0) {
c[f + 0 >> 2] = c[o + 0 >> 2];
c[f + 4 >> 2] = c[o + 4 >> 2];
c[f + 8 >> 2] = c[o + 8 >> 2];
c[f + 12 >> 2] = c[o + 12 >> 2];
c[f + 16 >> 2] = c[o + 16 >> 2];
c[f + 20 >> 2] = c[o + 20 >> 2];
c[f + 24 >> 2] = c[o + 24 >> 2];
c[o + 0 >> 2] = c[h + 0 >> 2];
c[o + 4 >> 2] = c[h + 4 >> 2];
c[o + 8 >> 2] = c[h + 8 >> 2];
c[o + 12 >> 2] = c[h + 12 >> 2];
c[o + 16 >> 2] = c[h + 16 >> 2];
c[o + 20 >> 2] = c[h + 20 >> 2];
c[o + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h +
12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
t = 2
} else
t = 1
}
while (0);
do if (nb[c[d >> 2] & 31](j, o) | 0) {
u = h;
v = t
} else {
n = h;
while (1) {
n = n + -28 | 0;
if ((j | 0) == (n | 0))
break;
if (nb[c[d >> 2] & 31](n, o) | 0) {
m = 50;
break
}
}
if ((m | 0) == 50) {
m = 0;
c[f + 0 >> 2] = c[j + 0 >> 2];
c[f + 4 >> 2] = c[j + 4 >> 2];
c[f + 8 >> 2] = c[j + 8 >> 2];
c[f + 12 >> 2] = c[j + 12 >> 2];
c[f + 16 >> 2] = c[j + 16 >> 2];
c[f + 20 >> 2] = c[j + 20 >> 2];
c[f + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[n + 0 >> 2];
c[j + 4 >> 2] = c[n + 4 >> 2];
c[j + 8 >> 2] = c[n + 8 >> 2];
c[j + 12 >> 2] = c[n + 12 >> 2];
c[j + 16 >> 2] = c[n + 16 >> 2];
c[j + 20 >> 2] = c[n + 20 >> 2];
c[j + 24 >> 2] = c[n + 24 >> 2];
c[n + 0 >> 2] = c[f + 0 >> 2];
c[n + 4 >> 2] = c[f + 4 >> 2];
c[n + 8 >> 2] = c[f + 8 >> 2];
c[n + 12 >> 2] = c[f + 12 >> 2];
c[n + 16 >> 2] = c[f + 16 >> 2];
c[n + 20 >> 2] = c[f + 20 >> 2];
c[n + 24 >> 2] = c[f + 24 >> 2];
u = n;
v = t + 1 | 0;
break
}
l = j + 28 | 0;
if (nb[c[d >> 2] & 31](j, h) | 0)
w = l;
else {
if ((l | 0) == (h | 0)) {
m = 67;
break a
} else
x = l;
while (1) {
y = x + 28 | 0;
if (nb[c[d >> 2] & 31](j, x) | 0)
break;
if ((y | 0) == (h | 0)) {
m = 67;
break a
} else
x = y
}
c[f + 0 >> 2] = c[x + 0 >> 2];
c[f + 4 >> 2] = c[x + 4 >> 2];
c[f + 8 >> 2] = c[x + 8 >> 2];
c[f + 12 >> 2] = c[x + 12 >> 2];
c[f + 16 >> 2] = c[x + 16 >> 2];
c[f + 20 >> 2] = c[x + 20 >>
2];
c[f + 24 >> 2] = c[x + 24 >> 2];
c[x + 0 >> 2] = c[h + 0 >> 2];
c[x + 4 >> 2] = c[h + 4 >> 2];
c[x + 8 >> 2] = c[h + 8 >> 2];
c[x + 12 >> 2] = c[h + 12 >> 2];
c[x + 16 >> 2] = c[h + 16 >> 2];
c[x + 20 >> 2] = c[h + 20 >> 2];
c[x + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
w = y
}
if ((w | 0) == (h | 0)) {
m = 67;
break a
} else {
z = w;
A = h
}
while (1) {
n = z;
while (1) {
B = n + 28 | 0;
if (nb[c[d >> 2] & 31](j, n) | 0) {
C = A;
break
} else
n = B
}
do C = C + -28 | 0;
while (nb[c[d >> 2] & 31](j, C) | 0);
if (!(n >>> 0 < C >>>
0)) {
j = n;
continue b
}
c[f + 0 >> 2] = c[n + 0 >> 2];
c[f + 4 >> 2] = c[n + 4 >> 2];
c[f + 8 >> 2] = c[n + 8 >> 2];
c[f + 12 >> 2] = c[n + 12 >> 2];
c[f + 16 >> 2] = c[n + 16 >> 2];
c[f + 20 >> 2] = c[n + 20 >> 2];
c[f + 24 >> 2] = c[n + 24 >> 2];
c[n + 0 >> 2] = c[C + 0 >> 2];
c[n + 4 >> 2] = c[C + 4 >> 2];
c[n + 8 >> 2] = c[C + 8 >> 2];
c[n + 12 >> 2] = c[C + 12 >> 2];
c[n + 16 >> 2] = c[C + 16 >> 2];
c[n + 20 >> 2] = c[C + 20 >> 2];
c[n + 24 >> 2] = c[C + 24 >> 2];
c[C + 0 >> 2] = c[f + 0 >> 2];
c[C + 4 >> 2] = c[f + 4 >> 2];
c[C + 8 >> 2] = c[f + 8 >> 2];
c[C + 12 >> 2] = c[f + 12 >> 2];
c[C + 16 >> 2] = c[f + 16 >> 2];
c[C + 20 >> 2] = c[f + 20 >> 2];
c[C + 24 >> 2] = c[f + 24 >> 2];
z = B;
A = C
}
}
while (0);
l = j + 28 | 0;
c:
do if (l >>>
0 < u >>> 0) {
s = l;
p = u;
r = o;
q = v;
while (1) {
D = s;
while (1) {
E = D + 28 | 0;
if (nb[c[d >> 2] & 31](D, r) | 0)
D = E;
else {
F = p;
break
}
}
do F = F + -28 | 0;
while (!(nb[c[d >> 2] & 31](F, r) | 0));
if (D >>> 0 > F >>> 0) {
G = D;
H = r;
I = q;
break c
}
c[f + 0 >> 2] = c[D + 0 >> 2];
c[f + 4 >> 2] = c[D + 4 >> 2];
c[f + 8 >> 2] = c[D + 8 >> 2];
c[f + 12 >> 2] = c[D + 12 >> 2];
c[f + 16 >> 2] = c[D + 16 >> 2];
c[f + 20 >> 2] = c[D + 20 >> 2];
c[f + 24 >> 2] = c[D + 24 >> 2];
c[D + 0 >> 2] = c[F + 0 >> 2];
c[D + 4 >> 2] = c[F + 4 >> 2];
c[D + 8 >> 2] = c[F + 8 >> 2];
c[D + 12 >> 2] = c[F + 12 >> 2];
c[D + 16 >> 2] = c[F + 16 >> 2];
c[D + 20 >> 2] = c[F + 20 >> 2];
c[D + 24 >> 2] = c[F + 24 >> 2];
c[F + 0 >> 2] = c[f + 0 >> 2];
c[F +
4 >> 2] = c[f + 4 >> 2];
c[F + 8 >> 2] = c[f + 8 >> 2];
c[F + 12 >> 2] = c[f + 12 >> 2];
c[F + 16 >> 2] = c[f + 16 >> 2];
c[F + 20 >> 2] = c[f + 20 >> 2];
c[F + 24 >> 2] = c[f + 24 >> 2];
s = E;
p = F;
r = (r | 0) == (D | 0) ? F : r;
q = q + 1 | 0
}
} else {
G = l;
H = o;
I = v
}
while (0);
if ((G | 0) != (H | 0) ? nb[c[d >> 2] & 31](H, G) | 0 : 0) {
c[f + 0 >> 2] = c[G + 0 >> 2];
c[f + 4 >> 2] = c[G + 4 >> 2];
c[f + 8 >> 2] = c[G + 8 >> 2];
c[f + 12 >> 2] = c[G + 12 >> 2];
c[f + 16 >> 2] = c[G + 16 >> 2];
c[f + 20 >> 2] = c[G + 20 >> 2];
c[f + 24 >> 2] = c[G + 24 >> 2];
c[G + 0 >> 2] = c[H + 0 >> 2];
c[G + 4 >> 2] = c[H + 4 >> 2];
c[G + 8 >> 2] = c[H + 8 >> 2];
c[G + 12 >> 2] = c[H + 12 >> 2];
c[G + 16 >> 2] = c[H + 16 >> 2];
c[G + 20 >> 2] = c[H + 20 >> 2];
c[G + 24 >> 2] = c[H + 24 >> 2];
c[H + 0 >> 2] = c[f + 0 >> 2];
c[H + 4 >> 2] = c[f + 4 >> 2];
c[H + 8 >> 2] = c[f + 8 >> 2];
c[H + 12 >> 2] = c[f + 12 >> 2];
c[H + 16 >> 2] = c[f + 16 >> 2];
c[H + 20 >> 2] = c[f + 20 >> 2];
c[H + 24 >> 2] = c[f + 24 >> 2];
J = I + 1 | 0
} else
J = I;
if ((J | 0) == 0) {
K = Bl(j, G, d) | 0;
o = G + 28 | 0;
if (Bl(o, a, d) | 0) {
m = 62;
break
}
if (K) {
j = o;
continue
}
}
o = G;
if ((o - k | 0) >= (b - o | 0)) {
m = 66;
break
}
yl(j, G, d);
j = G + 28 | 0
}
if ((m | 0) == 62) {
m = 0;
if (K) {
m = 67;
break
} else {
g = j;
a = G;
continue
}
} else if ((m | 0) == 66) {
m = 0;
yl(G + 28 | 0, a, d);
g = j;
a = G;
continue
}
}
if ((m | 0) == 4) {
if (!(nb[c[d >> 2] & 31](h, j) | 0)) {
i = e;
return
}
c[f + 0 >> 2] =
c[j + 0 >> 2];
c[f + 4 >> 2] = c[j + 4 >> 2];
c[f + 8 >> 2] = c[j + 8 >> 2];
c[f + 12 >> 2] = c[j + 12 >> 2];
c[f + 16 >> 2] = c[j + 16 >> 2];
c[f + 20 >> 2] = c[j + 20 >> 2];
c[f + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[h + 0 >> 2];
c[j + 4 >> 2] = c[h + 4 >> 2];
c[j + 8 >> 2] = c[h + 8 >> 2];
c[j + 12 >> 2] = c[h + 12 >> 2];
c[j + 16 >> 2] = c[h + 16 >> 2];
c[j + 20 >> 2] = c[h + 20 >> 2];
c[j + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
i = e;
return
} else if ((m | 0) == 6) {
G = j + 28 | 0;
g = nb[c[d >> 2] & 31](G, j) | 0;
K = nb[c[d >>
2] & 31](h, G) | 0;
if (!g) {
if (!K) {
i = e;
return
}
c[f + 0 >> 2] = c[G + 0 >> 2];
c[f + 4 >> 2] = c[G + 4 >> 2];
c[f + 8 >> 2] = c[G + 8 >> 2];
c[f + 12 >> 2] = c[G + 12 >> 2];
c[f + 16 >> 2] = c[G + 16 >> 2];
c[f + 20 >> 2] = c[G + 20 >> 2];
c[f + 24 >> 2] = c[G + 24 >> 2];
c[G + 0 >> 2] = c[h + 0 >> 2];
c[G + 4 >> 2] = c[h + 4 >> 2];
c[G + 8 >> 2] = c[h + 8 >> 2];
c[G + 12 >> 2] = c[h + 12 >> 2];
c[G + 16 >> 2] = c[h + 16 >> 2];
c[G + 20 >> 2] = c[h + 20 >> 2];
c[G + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
if (!(nb[c[d >> 2] & 31](G,
j) | 0)) {
i = e;
return
}
c[f + 0 >> 2] = c[j + 0 >> 2];
c[f + 4 >> 2] = c[j + 4 >> 2];
c[f + 8 >> 2] = c[j + 8 >> 2];
c[f + 12 >> 2] = c[j + 12 >> 2];
c[f + 16 >> 2] = c[j + 16 >> 2];
c[f + 20 >> 2] = c[j + 20 >> 2];
c[f + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[G + 0 >> 2];
c[j + 4 >> 2] = c[G + 4 >> 2];
c[j + 8 >> 2] = c[G + 8 >> 2];
c[j + 12 >> 2] = c[G + 12 >> 2];
c[j + 16 >> 2] = c[G + 16 >> 2];
c[j + 20 >> 2] = c[G + 20 >> 2];
c[j + 24 >> 2] = c[G + 24 >> 2];
c[G + 0 >> 2] = c[f + 0 >> 2];
c[G + 4 >> 2] = c[f + 4 >> 2];
c[G + 8 >> 2] = c[f + 8 >> 2];
c[G + 12 >> 2] = c[f + 12 >> 2];
c[G + 16 >> 2] = c[f + 16 >> 2];
c[G + 20 >> 2] = c[f + 20 >> 2];
c[G + 24 >> 2] = c[f + 24 >> 2];
i = e;
return
}
if (K) {
c[f + 0 >> 2] = c[j + 0 >> 2];
c[f +
4 >> 2] = c[j + 4 >> 2];
c[f + 8 >> 2] = c[j + 8 >> 2];
c[f + 12 >> 2] = c[j + 12 >> 2];
c[f + 16 >> 2] = c[j + 16 >> 2];
c[f + 20 >> 2] = c[j + 20 >> 2];
c[f + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[h + 0 >> 2];
c[j + 4 >> 2] = c[h + 4 >> 2];
c[j + 8 >> 2] = c[h + 8 >> 2];
c[j + 12 >> 2] = c[h + 12 >> 2];
c[j + 16 >> 2] = c[h + 16 >> 2];
c[j + 20 >> 2] = c[h + 20 >> 2];
c[j + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
i = e;
return
}
c[f + 0 >> 2] = c[j + 0 >> 2];
c[f + 4 >> 2] = c[j + 4 >> 2];
c[f + 8 >> 2] = c[j + 8 >> 2];
c[f + 12 >> 2] =
c[j + 12 >> 2];
c[f + 16 >> 2] = c[j + 16 >> 2];
c[f + 20 >> 2] = c[j + 20 >> 2];
c[f + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[G + 0 >> 2];
c[j + 4 >> 2] = c[G + 4 >> 2];
c[j + 8 >> 2] = c[G + 8 >> 2];
c[j + 12 >> 2] = c[G + 12 >> 2];
c[j + 16 >> 2] = c[G + 16 >> 2];
c[j + 20 >> 2] = c[G + 20 >> 2];
c[j + 24 >> 2] = c[G + 24 >> 2];
c[G + 0 >> 2] = c[f + 0 >> 2];
c[G + 4 >> 2] = c[f + 4 >> 2];
c[G + 8 >> 2] = c[f + 8 >> 2];
c[G + 12 >> 2] = c[f + 12 >> 2];
c[G + 16 >> 2] = c[f + 16 >> 2];
c[G + 20 >> 2] = c[f + 20 >> 2];
c[G + 24 >> 2] = c[f + 24 >> 2];
if (!(nb[c[d >> 2] & 31](h, G) | 0)) {
i = e;
return
}
c[f + 0 >> 2] = c[G + 0 >> 2];
c[f + 4 >> 2] = c[G + 4 >> 2];
c[f + 8 >> 2] = c[G + 8 >> 2];
c[f + 12 >> 2] = c[G + 12 >> 2];
c[f + 16 >>
2] = c[G + 16 >> 2];
c[f + 20 >> 2] = c[G + 20 >> 2];
c[f + 24 >> 2] = c[G + 24 >> 2];
c[G + 0 >> 2] = c[h + 0 >> 2];
c[G + 4 >> 2] = c[h + 4 >> 2];
c[G + 8 >> 2] = c[h + 8 >> 2];
c[G + 12 >> 2] = c[h + 12 >> 2];
c[G + 16 >> 2] = c[h + 16 >> 2];
c[G + 20 >> 2] = c[h + 20 >> 2];
c[G + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
i = e;
return
} else if ((m | 0) == 14) {
zl(j, j + 28 | 0, j + 56 | 0, h, d) | 0;
i = e;
return
} else if ((m | 0) == 15) {
G = j + 28 | 0;
K = j + 56 | 0;
g = j + 84 | 0;
zl(j, G, K, g, d) | 0;
if (!(nb[c[d >> 2] & 31](h,
g) | 0)) {
i = e;
return
}
c[f + 0 >> 2] = c[g + 0 >> 2];
c[f + 4 >> 2] = c[g + 4 >> 2];
c[f + 8 >> 2] = c[g + 8 >> 2];
c[f + 12 >> 2] = c[g + 12 >> 2];
c[f + 16 >> 2] = c[g + 16 >> 2];
c[f + 20 >> 2] = c[g + 20 >> 2];
c[f + 24 >> 2] = c[g + 24 >> 2];
c[g + 0 >> 2] = c[h + 0 >> 2];
c[g + 4 >> 2] = c[h + 4 >> 2];
c[g + 8 >> 2] = c[h + 8 >> 2];
c[g + 12 >> 2] = c[h + 12 >> 2];
c[g + 16 >> 2] = c[h + 16 >> 2];
c[g + 20 >> 2] = c[h + 20 >> 2];
c[g + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
if (!(nb[c[d >> 2] & 31](g, K) | 0)) {
i = e;
return
}
c[f +
0 >> 2] = c[K + 0 >> 2];
c[f + 4 >> 2] = c[K + 4 >> 2];
c[f + 8 >> 2] = c[K + 8 >> 2];
c[f + 12 >> 2] = c[K + 12 >> 2];
c[f + 16 >> 2] = c[K + 16 >> 2];
c[f + 20 >> 2] = c[K + 20 >> 2];
c[f + 24 >> 2] = c[K + 24 >> 2];
c[K + 0 >> 2] = c[g + 0 >> 2];
c[K + 4 >> 2] = c[g + 4 >> 2];
c[K + 8 >> 2] = c[g + 8 >> 2];
c[K + 12 >> 2] = c[g + 12 >> 2];
c[K + 16 >> 2] = c[g + 16 >> 2];
c[K + 20 >> 2] = c[g + 20 >> 2];
c[K + 24 >> 2] = c[g + 24 >> 2];
c[g + 0 >> 2] = c[f + 0 >> 2];
c[g + 4 >> 2] = c[f + 4 >> 2];
c[g + 8 >> 2] = c[f + 8 >> 2];
c[g + 12 >> 2] = c[f + 12 >> 2];
c[g + 16 >> 2] = c[f + 16 >> 2];
c[g + 20 >> 2] = c[f + 20 >> 2];
c[g + 24 >> 2] = c[f + 24 >> 2];
if (!(nb[c[d >> 2] & 31](K, G) | 0)) {
i = e;
return
}
c[f + 0 >> 2] = c[G + 0 >> 2];
c[f +
4 >> 2] = c[G + 4 >> 2];
c[f + 8 >> 2] = c[G + 8 >> 2];
c[f + 12 >> 2] = c[G + 12 >> 2];
c[f + 16 >> 2] = c[G + 16 >> 2];
c[f + 20 >> 2] = c[G + 20 >> 2];
c[f + 24 >> 2] = c[G + 24 >> 2];
c[G + 0 >> 2] = c[K + 0 >> 2];
c[G + 4 >> 2] = c[K + 4 >> 2];
c[G + 8 >> 2] = c[K + 8 >> 2];
c[G + 12 >> 2] = c[K + 12 >> 2];
c[G + 16 >> 2] = c[K + 16 >> 2];
c[G + 20 >> 2] = c[K + 20 >> 2];
c[G + 24 >> 2] = c[K + 24 >> 2];
c[K + 0 >> 2] = c[f + 0 >> 2];
c[K + 4 >> 2] = c[f + 4 >> 2];
c[K + 8 >> 2] = c[f + 8 >> 2];
c[K + 12 >> 2] = c[f + 12 >> 2];
c[K + 16 >> 2] = c[f + 16 >> 2];
c[K + 20 >> 2] = c[f + 20 >> 2];
c[K + 24 >> 2] = c[f + 24 >> 2];
if (!(nb[c[d >> 2] & 31](G, j) | 0)) {
i = e;
return
}
c[f + 0 >> 2] = c[j + 0 >> 2];
c[f + 4 >> 2] = c[j + 4 >> 2];
c[f +
8 >> 2] = c[j + 8 >> 2];
c[f + 12 >> 2] = c[j + 12 >> 2];
c[f + 16 >> 2] = c[j + 16 >> 2];
c[f + 20 >> 2] = c[j + 20 >> 2];
c[f + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[G + 0 >> 2];
c[j + 4 >> 2] = c[G + 4 >> 2];
c[j + 8 >> 2] = c[G + 8 >> 2];
c[j + 12 >> 2] = c[G + 12 >> 2];
c[j + 16 >> 2] = c[G + 16 >> 2];
c[j + 20 >> 2] = c[G + 20 >> 2];
c[j + 24 >> 2] = c[G + 24 >> 2];
c[G + 0 >> 2] = c[f + 0 >> 2];
c[G + 4 >> 2] = c[f + 4 >> 2];
c[G + 8 >> 2] = c[f + 8 >> 2];
c[G + 12 >> 2] = c[f + 12 >> 2];
c[G + 16 >> 2] = c[f + 16 >> 2];
c[G + 20 >> 2] = c[f + 20 >> 2];
c[G + 24 >> 2] = c[f + 24 >> 2];
i = e;
return
} else if ((m | 0) == 21) {
Al(j, a, d);
i = e;
return
} else if ((m | 0) == 67) {
i = e;
return
}
}
function zl(a, b, d, e,
f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0;
g = i;
i = i + 32 | 0;
h = g;
j = nb[c[f >> 2] & 31](b, a) | 0;
k = nb[c[f >> 2] & 31](d, b) | 0;
do if (j) {
if (k) {
c[h + 0 >> 2] = c[a + 0 >> 2];
c[h + 4 >> 2] = c[a + 4 >> 2];
c[h + 8 >> 2] = c[a + 8 >> 2];
c[h + 12 >> 2] = c[a + 12 >> 2];
c[h + 16 >> 2] = c[a + 16 >> 2];
c[h + 20 >> 2] = c[a + 20 >> 2];
c[h + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[d + 0 >> 2];
c[a + 4 >> 2] = c[d + 4 >> 2];
c[a + 8 >> 2] = c[d + 8 >> 2];
c[a + 12 >> 2] = c[d + 12 >> 2];
c[a + 16 >> 2] = c[d + 16 >> 2];
c[a + 20 >> 2] = c[d + 20 >> 2];
c[a + 24 >> 2] = c[d + 24 >> 2];
c[d + 0 >> 2] = c[h + 0 >> 2];
c[d + 4 >> 2] = c[h + 4 >> 2];
c[d + 8 >> 2] = c[h + 8 >> 2];
c[d +
12 >> 2] = c[h + 12 >> 2];
c[d + 16 >> 2] = c[h + 16 >> 2];
c[d + 20 >> 2] = c[h + 20 >> 2];
c[d + 24 >> 2] = c[h + 24 >> 2];
l = 1;
break
}
c[h + 0 >> 2] = c[a + 0 >> 2];
c[h + 4 >> 2] = c[a + 4 >> 2];
c[h + 8 >> 2] = c[a + 8 >> 2];
c[h + 12 >> 2] = c[a + 12 >> 2];
c[h + 16 >> 2] = c[a + 16 >> 2];
c[h + 20 >> 2] = c[a + 20 >> 2];
c[h + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[b + 0 >> 2];
c[a + 4 >> 2] = c[b + 4 >> 2];
c[a + 8 >> 2] = c[b + 8 >> 2];
c[a + 12 >> 2] = c[b + 12 >> 2];
c[a + 16 >> 2] = c[b + 16 >> 2];
c[a + 20 >> 2] = c[b + 20 >> 2];
c[a + 24 >> 2] = c[b + 24 >> 2];
c[b + 0 >> 2] = c[h + 0 >> 2];
c[b + 4 >> 2] = c[h + 4 >> 2];
c[b + 8 >> 2] = c[h + 8 >> 2];
c[b + 12 >> 2] = c[h + 12 >> 2];
c[b + 16 >> 2] = c[h + 16 >> 2];
c[b + 20 >>
2] = c[h + 20 >> 2];
c[b + 24 >> 2] = c[h + 24 >> 2];
if (nb[c[f >> 2] & 31](d, b) | 0) {
c[h + 0 >> 2] = c[b + 0 >> 2];
c[h + 4 >> 2] = c[b + 4 >> 2];
c[h + 8 >> 2] = c[b + 8 >> 2];
c[h + 12 >> 2] = c[b + 12 >> 2];
c[h + 16 >> 2] = c[b + 16 >> 2];
c[h + 20 >> 2] = c[b + 20 >> 2];
c[h + 24 >> 2] = c[b + 24 >> 2];
c[b + 0 >> 2] = c[d + 0 >> 2];
c[b + 4 >> 2] = c[d + 4 >> 2];
c[b + 8 >> 2] = c[d + 8 >> 2];
c[b + 12 >> 2] = c[d + 12 >> 2];
c[b + 16 >> 2] = c[d + 16 >> 2];
c[b + 20 >> 2] = c[d + 20 >> 2];
c[b + 24 >> 2] = c[d + 24 >> 2];
c[d + 0 >> 2] = c[h + 0 >> 2];
c[d + 4 >> 2] = c[h + 4 >> 2];
c[d + 8 >> 2] = c[h + 8 >> 2];
c[d + 12 >> 2] = c[h + 12 >> 2];
c[d + 16 >> 2] = c[h + 16 >> 2];
c[d + 20 >> 2] = c[h + 20 >> 2];
c[d + 24 >> 2] = c[h + 24 >>
2];
l = 2
} else
l = 1
} else if (k) {
c[h + 0 >> 2] = c[b + 0 >> 2];
c[h + 4 >> 2] = c[b + 4 >> 2];
c[h + 8 >> 2] = c[b + 8 >> 2];
c[h + 12 >> 2] = c[b + 12 >> 2];
c[h + 16 >> 2] = c[b + 16 >> 2];
c[h + 20 >> 2] = c[b + 20 >> 2];
c[h + 24 >> 2] = c[b + 24 >> 2];
c[b + 0 >> 2] = c[d + 0 >> 2];
c[b + 4 >> 2] = c[d + 4 >> 2];
c[b + 8 >> 2] = c[d + 8 >> 2];
c[b + 12 >> 2] = c[d + 12 >> 2];
c[b + 16 >> 2] = c[d + 16 >> 2];
c[b + 20 >> 2] = c[d + 20 >> 2];
c[b + 24 >> 2] = c[d + 24 >> 2];
c[d + 0 >> 2] = c[h + 0 >> 2];
c[d + 4 >> 2] = c[h + 4 >> 2];
c[d + 8 >> 2] = c[h + 8 >> 2];
c[d + 12 >> 2] = c[h + 12 >> 2];
c[d + 16 >> 2] = c[h + 16 >> 2];
c[d + 20 >> 2] = c[h + 20 >> 2];
c[d + 24 >> 2] = c[h + 24 >> 2];
if (nb[c[f >> 2] & 31](b, a) | 0) {
c[h +
0 >> 2] = c[a + 0 >> 2];
c[h + 4 >> 2] = c[a + 4 >> 2];
c[h + 8 >> 2] = c[a + 8 >> 2];
c[h + 12 >> 2] = c[a + 12 >> 2];
c[h + 16 >> 2] = c[a + 16 >> 2];
c[h + 20 >> 2] = c[a + 20 >> 2];
c[h + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[b + 0 >> 2];
c[a + 4 >> 2] = c[b + 4 >> 2];
c[a + 8 >> 2] = c[b + 8 >> 2];
c[a + 12 >> 2] = c[b + 12 >> 2];
c[a + 16 >> 2] = c[b + 16 >> 2];
c[a + 20 >> 2] = c[b + 20 >> 2];
c[a + 24 >> 2] = c[b + 24 >> 2];
c[b + 0 >> 2] = c[h + 0 >> 2];
c[b + 4 >> 2] = c[h + 4 >> 2];
c[b + 8 >> 2] = c[h + 8 >> 2];
c[b + 12 >> 2] = c[h + 12 >> 2];
c[b + 16 >> 2] = c[h + 16 >> 2];
c[b + 20 >> 2] = c[h + 20 >> 2];
c[b + 24 >> 2] = c[h + 24 >> 2];
l = 2
} else
l = 1
} else
l = 0;
while (0);
if (!(nb[c[f >> 2] & 31](e, d) | 0)) {
m =
l;
i = g;
return m | 0
}
c[h + 0 >> 2] = c[d + 0 >> 2];
c[h + 4 >> 2] = c[d + 4 >> 2];
c[h + 8 >> 2] = c[d + 8 >> 2];
c[h + 12 >> 2] = c[d + 12 >> 2];
c[h + 16 >> 2] = c[d + 16 >> 2];
c[h + 20 >> 2] = c[d + 20 >> 2];
c[h + 24 >> 2] = c[d + 24 >> 2];
c[d + 0 >> 2] = c[e + 0 >> 2];
c[d + 4 >> 2] = c[e + 4 >> 2];
c[d + 8 >> 2] = c[e + 8 >> 2];
c[d + 12 >> 2] = c[e + 12 >> 2];
c[d + 16 >> 2] = c[e + 16 >> 2];
c[d + 20 >> 2] = c[e + 20 >> 2];
c[d + 24 >> 2] = c[e + 24 >> 2];
c[e + 0 >> 2] = c[h + 0 >> 2];
c[e + 4 >> 2] = c[h + 4 >> 2];
c[e + 8 >> 2] = c[h + 8 >> 2];
c[e + 12 >> 2] = c[h + 12 >> 2];
c[e + 16 >> 2] = c[h + 16 >> 2];
c[e + 20 >> 2] = c[h + 20 >> 2];
c[e + 24 >> 2] = c[h + 24 >> 2];
if (!(nb[c[f >> 2] & 31](d, b) | 0)) {
m = l + 1 | 0;
i = g;
return m | 0
}
c[h + 0 >> 2] = c[b + 0 >> 2];
c[h + 4 >> 2] = c[b + 4 >> 2];
c[h + 8 >> 2] = c[b + 8 >> 2];
c[h + 12 >> 2] = c[b + 12 >> 2];
c[h + 16 >> 2] = c[b + 16 >> 2];
c[h + 20 >> 2] = c[b + 20 >> 2];
c[h + 24 >> 2] = c[b + 24 >> 2];
c[b + 0 >> 2] = c[d + 0 >> 2];
c[b + 4 >> 2] = c[d + 4 >> 2];
c[b + 8 >> 2] = c[d + 8 >> 2];
c[b + 12 >> 2] = c[d + 12 >> 2];
c[b + 16 >> 2] = c[d + 16 >> 2];
c[b + 20 >> 2] = c[d + 20 >> 2];
c[b + 24 >> 2] = c[d + 24 >> 2];
c[d + 0 >> 2] = c[h + 0 >> 2];
c[d + 4 >> 2] = c[h + 4 >> 2];
c[d + 8 >> 2] = c[h + 8 >> 2];
c[d + 12 >> 2] = c[h + 12 >> 2];
c[d + 16 >> 2] = c[h + 16 >> 2];
c[d + 20 >> 2] = c[h + 20 >> 2];
c[d + 24 >> 2] = c[h + 24 >> 2];
if (!(nb[c[f >> 2] & 31](b, a) | 0)) {
m = l + 2 | 0;
i = g;
return m |
0
}
c[h + 0 >> 2] = c[a + 0 >> 2];
c[h + 4 >> 2] = c[a + 4 >> 2];
c[h + 8 >> 2] = c[a + 8 >> 2];
c[h + 12 >> 2] = c[a + 12 >> 2];
c[h + 16 >> 2] = c[a + 16 >> 2];
c[h + 20 >> 2] = c[a + 20 >> 2];
c[h + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[b + 0 >> 2];
c[a + 4 >> 2] = c[b + 4 >> 2];
c[a + 8 >> 2] = c[b + 8 >> 2];
c[a + 12 >> 2] = c[b + 12 >> 2];
c[a + 16 >> 2] = c[b + 16 >> 2];
c[a + 20 >> 2] = c[b + 20 >> 2];
c[a + 24 >> 2] = c[b + 24 >> 2];
c[b + 0 >> 2] = c[h + 0 >> 2];
c[b + 4 >> 2] = c[h + 4 >> 2];
c[b + 8 >> 2] = c[h + 8 >> 2];
c[b + 12 >> 2] = c[h + 12 >> 2];
c[b + 16 >> 2] = c[h + 16 >> 2];
c[b + 20 >> 2] = c[h + 20 >> 2];
c[b + 24 >> 2] = c[h + 24 >> 2];
m = l + 3 | 0;
i = g;
return m | 0
}
function Al(a, b, d) {
a = a | 0;
b = b | 0;
d =
d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0;
e = i;
i = i + 64 | 0;
f = e + 28 | 0;
g = e;
h = a + 56 | 0;
j = a + 28 | 0;
k = nb[c[d >> 2] & 31](j, a) | 0;
l = nb[c[d >> 2] & 31](h, j) | 0;
do if (k) {
if (l) {
c[f + 0 >> 2] = c[a + 0 >> 2];
c[f + 4 >> 2] = c[a + 4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f + 16 >> 2] = c[a + 16 >> 2];
c[f + 20 >> 2] = c[a + 20 >> 2];
c[f + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[h + 0 >> 2];
c[a + 4 >> 2] = c[h + 4 >> 2];
c[a + 8 >> 2] = c[h + 8 >> 2];
c[a + 12 >> 2] = c[h + 12 >> 2];
c[a + 16 >> 2] = c[h + 16 >> 2];
c[a + 20 >> 2] = c[h + 20 >> 2];
c[a + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
break
}
c[f + 0 >> 2] = c[a + 0 >> 2];
c[f + 4 >> 2] = c[a + 4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f + 16 >> 2] = c[a + 16 >> 2];
c[f + 20 >> 2] = c[a + 20 >> 2];
c[f + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[j + 0 >> 2];
c[a + 4 >> 2] = c[j + 4 >> 2];
c[a + 8 >> 2] = c[j + 8 >> 2];
c[a + 12 >> 2] = c[j + 12 >> 2];
c[a + 16 >> 2] = c[j + 16 >> 2];
c[a + 20 >> 2] = c[j + 20 >> 2];
c[a + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[f + 0 >> 2];
c[j + 4 >> 2] = c[f + 4 >> 2];
c[j + 8 >> 2] = c[f + 8 >> 2];
c[j + 12 >> 2] = c[f + 12 >> 2];
c[j + 16 >> 2] = c[f + 16 >> 2];
c[j + 20 >>
2] = c[f + 20 >> 2];
c[j + 24 >> 2] = c[f + 24 >> 2];
if (nb[c[d >> 2] & 31](h, j) | 0) {
c[f + 0 >> 2] = c[j + 0 >> 2];
c[f + 4 >> 2] = c[j + 4 >> 2];
c[f + 8 >> 2] = c[j + 8 >> 2];
c[f + 12 >> 2] = c[j + 12 >> 2];
c[f + 16 >> 2] = c[j + 16 >> 2];
c[f + 20 >> 2] = c[j + 20 >> 2];
c[f + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[h + 0 >> 2];
c[j + 4 >> 2] = c[h + 4 >> 2];
c[j + 8 >> 2] = c[h + 8 >> 2];
c[j + 12 >> 2] = c[h + 12 >> 2];
c[j + 16 >> 2] = c[h + 16 >> 2];
c[j + 20 >> 2] = c[h + 20 >> 2];
c[j + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >>
2]
}
} else if (l) {
c[f + 0 >> 2] = c[j + 0 >> 2];
c[f + 4 >> 2] = c[j + 4 >> 2];
c[f + 8 >> 2] = c[j + 8 >> 2];
c[f + 12 >> 2] = c[j + 12 >> 2];
c[f + 16 >> 2] = c[j + 16 >> 2];
c[f + 20 >> 2] = c[j + 20 >> 2];
c[f + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[h + 0 >> 2];
c[j + 4 >> 2] = c[h + 4 >> 2];
c[j + 8 >> 2] = c[h + 8 >> 2];
c[j + 12 >> 2] = c[h + 12 >> 2];
c[j + 16 >> 2] = c[h + 16 >> 2];
c[j + 20 >> 2] = c[h + 20 >> 2];
c[j + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
if (nb[c[d >> 2] & 31](j, a) | 0) {
c[f + 0 >> 2] = c[a + 0 >>
2];
c[f + 4 >> 2] = c[a + 4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f + 16 >> 2] = c[a + 16 >> 2];
c[f + 20 >> 2] = c[a + 20 >> 2];
c[f + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[j + 0 >> 2];
c[a + 4 >> 2] = c[j + 4 >> 2];
c[a + 8 >> 2] = c[j + 8 >> 2];
c[a + 12 >> 2] = c[j + 12 >> 2];
c[a + 16 >> 2] = c[j + 16 >> 2];
c[a + 20 >> 2] = c[j + 20 >> 2];
c[a + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[f + 0 >> 2];
c[j + 4 >> 2] = c[f + 4 >> 2];
c[j + 8 >> 2] = c[f + 8 >> 2];
c[j + 12 >> 2] = c[f + 12 >> 2];
c[j + 16 >> 2] = c[f + 16 >> 2];
c[j + 20 >> 2] = c[f + 20 >> 2];
c[j + 24 >> 2] = c[f + 24 >> 2]
}
}
while (0);
f = a + 84 | 0;
if ((f | 0) == (b | 0)) {
i = e;
return
}
j = f;
f = h;
while (1) {
if (nb[c[d >>
2] & 31](j, f) | 0) {
c[g + 0 >> 2] = c[j + 0 >> 2];
c[g + 4 >> 2] = c[j + 4 >> 2];
c[g + 8 >> 2] = c[j + 8 >> 2];
c[g + 12 >> 2] = c[j + 12 >> 2];
c[g + 16 >> 2] = c[j + 16 >> 2];
c[g + 20 >> 2] = c[j + 20 >> 2];
c[g + 24 >> 2] = c[j + 24 >> 2];
h = j;
l = f;
while (1) {
c[h + 0 >> 2] = c[l + 0 >> 2];
c[h + 4 >> 2] = c[l + 4 >> 2];
c[h + 8 >> 2] = c[l + 8 >> 2];
c[h + 12 >> 2] = c[l + 12 >> 2];
c[h + 16 >> 2] = c[l + 16 >> 2];
c[h + 20 >> 2] = c[l + 20 >> 2];
c[h + 24 >> 2] = c[l + 24 >> 2];
if ((l | 0) == (a | 0))
break;
k = l + -28 | 0;
if (nb[c[d >> 2] & 31](g, k) | 0) {
m = l;
l = k;
h = m
} else
break
}
c[l + 0 >> 2] = c[g + 0 >> 2];
c[l + 4 >> 2] = c[g + 4 >> 2];
c[l + 8 >> 2] = c[g + 8 >> 2];
c[l + 12 >> 2] = c[g + 12 >> 2];
c[l + 16 >> 2] =
c[g + 16 >> 2];
c[l + 20 >> 2] = c[g + 20 >> 2];
c[l + 24 >> 2] = c[g + 24 >> 2]
}
h = j + 28 | 0;
if ((h | 0) == (b | 0))
break;
else {
m = j;
j = h;
f = m
}
}
i = e;
return
}
function Bl(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0;
e = i;
i = i + 64 | 0;
f = e + 28 | 0;
g = e;
switch ((b - a | 0) / 28 | 0 | 0) {
case 5:
h = a + 28 | 0;
j = a + 56 | 0;
k = a + 84 | 0;
l = b + -28 | 0;
zl(a, h, j, k, d) | 0;
if (!(nb[c[d >> 2] & 31](l, k) | 0)) {
m = 1;
i = e;
return m | 0
}
c[f + 0 >> 2] = c[k + 0 >> 2];
c[f + 4 >> 2] = c[k + 4 >> 2];
c[f + 8 >> 2] = c[k + 8 >> 2];
c[f + 12 >> 2] = c[k + 12 >> 2];
c[f + 16 >> 2] = c[k + 16 >> 2];
c[f + 20 >> 2] = c[k + 20 >> 2];
c[f + 24 >> 2] = c[k +
24 >> 2];
c[k + 0 >> 2] = c[l + 0 >> 2];
c[k + 4 >> 2] = c[l + 4 >> 2];
c[k + 8 >> 2] = c[l + 8 >> 2];
c[k + 12 >> 2] = c[l + 12 >> 2];
c[k + 16 >> 2] = c[l + 16 >> 2];
c[k + 20 >> 2] = c[l + 20 >> 2];
c[k + 24 >> 2] = c[l + 24 >> 2];
c[l + 0 >> 2] = c[f + 0 >> 2];
c[l + 4 >> 2] = c[f + 4 >> 2];
c[l + 8 >> 2] = c[f + 8 >> 2];
c[l + 12 >> 2] = c[f + 12 >> 2];
c[l + 16 >> 2] = c[f + 16 >> 2];
c[l + 20 >> 2] = c[f + 20 >> 2];
c[l + 24 >> 2] = c[f + 24 >> 2];
if (!(nb[c[d >> 2] & 31](k, j) | 0)) {
m = 1;
i = e;
return m | 0
}
c[f + 0 >> 2] = c[j + 0 >> 2];
c[f + 4 >> 2] = c[j + 4 >> 2];
c[f + 8 >> 2] = c[j + 8 >> 2];
c[f + 12 >> 2] = c[j + 12 >> 2];
c[f + 16 >> 2] = c[j + 16 >> 2];
c[f + 20 >> 2] = c[j + 20 >> 2];
c[f + 24 >> 2] = c[j + 24 >> 2];
c[j +
0 >> 2] = c[k + 0 >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
c[j + 8 >> 2] = c[k + 8 >> 2];
c[j + 12 >> 2] = c[k + 12 >> 2];
c[j + 16 >> 2] = c[k + 16 >> 2];
c[j + 20 >> 2] = c[k + 20 >> 2];
c[j + 24 >> 2] = c[k + 24 >> 2];
c[k + 0 >> 2] = c[f + 0 >> 2];
c[k + 4 >> 2] = c[f + 4 >> 2];
c[k + 8 >> 2] = c[f + 8 >> 2];
c[k + 12 >> 2] = c[f + 12 >> 2];
c[k + 16 >> 2] = c[f + 16 >> 2];
c[k + 20 >> 2] = c[f + 20 >> 2];
c[k + 24 >> 2] = c[f + 24 >> 2];
if (!(nb[c[d >> 2] & 31](j, h) | 0)) {
m = 1;
i = e;
return m | 0
}
c[f + 0 >> 2] = c[h + 0 >> 2];
c[f + 4 >> 2] = c[h + 4 >> 2];
c[f + 8 >> 2] = c[h + 8 >> 2];
c[f + 12 >> 2] = c[h + 12 >> 2];
c[f + 16 >> 2] = c[h + 16 >> 2];
c[f + 20 >> 2] = c[h + 20 >> 2];
c[f + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[j +
0 >> 2];
c[h + 4 >> 2] = c[j + 4 >> 2];
c[h + 8 >> 2] = c[j + 8 >> 2];
c[h + 12 >> 2] = c[j + 12 >> 2];
c[h + 16 >> 2] = c[j + 16 >> 2];
c[h + 20 >> 2] = c[j + 20 >> 2];
c[h + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[f + 0 >> 2];
c[j + 4 >> 2] = c[f + 4 >> 2];
c[j + 8 >> 2] = c[f + 8 >> 2];
c[j + 12 >> 2] = c[f + 12 >> 2];
c[j + 16 >> 2] = c[f + 16 >> 2];
c[j + 20 >> 2] = c[f + 20 >> 2];
c[j + 24 >> 2] = c[f + 24 >> 2];
if (!(nb[c[d >> 2] & 31](h, a) | 0)) {
m = 1;
i = e;
return m | 0
}
c[f + 0 >> 2] = c[a + 0 >> 2];
c[f + 4 >> 2] = c[a + 4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f + 16 >> 2] = c[a + 16 >> 2];
c[f + 20 >> 2] = c[a + 20 >> 2];
c[f + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[h + 0 >> 2];
c[a +
4 >> 2] = c[h + 4 >> 2];
c[a + 8 >> 2] = c[h + 8 >> 2];
c[a + 12 >> 2] = c[h + 12 >> 2];
c[a + 16 >> 2] = c[h + 16 >> 2];
c[a + 20 >> 2] = c[h + 20 >> 2];
c[a + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
m = 1;
i = e;
return m | 0;
case 3:
h = a + 28 | 0;
j = b + -28 | 0;
k = nb[c[d >> 2] & 31](h, a) | 0;
l = nb[c[d >> 2] & 31](j, h) | 0;
if (!k) {
if (!l) {
m = 1;
i = e;
return m | 0
}
c[f + 0 >> 2] = c[h + 0 >> 2];
c[f + 4 >> 2] = c[h + 4 >> 2];
c[f + 8 >> 2] = c[h + 8 >> 2];
c[f + 12 >> 2] = c[h + 12 >> 2];
c[f + 16 >> 2] = c[h + 16 >> 2];
c[f + 20 >> 2] = c[h + 20 >> 2];
c[f + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[j + 0 >> 2];
c[h + 4 >> 2] = c[j + 4 >> 2];
c[h + 8 >> 2] = c[j + 8 >> 2];
c[h + 12 >> 2] = c[j + 12 >> 2];
c[h + 16 >> 2] = c[j + 16 >> 2];
c[h + 20 >> 2] = c[j + 20 >> 2];
c[h + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[f + 0 >> 2];
c[j + 4 >> 2] = c[f + 4 >> 2];
c[j + 8 >> 2] = c[f + 8 >> 2];
c[j + 12 >> 2] = c[f + 12 >> 2];
c[j + 16 >> 2] = c[f + 16 >> 2];
c[j + 20 >> 2] = c[f + 20 >> 2];
c[j + 24 >> 2] = c[f + 24 >> 2];
if (!(nb[c[d >> 2] & 31](h, a) | 0)) {
m = 1;
i = e;
return m | 0
}
c[f + 0 >> 2] = c[a + 0 >> 2];
c[f + 4 >> 2] = c[a + 4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f + 16 >> 2] = c[a + 16 >> 2];
c[f + 20 >> 2] =
c[a + 20 >> 2];
c[f + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[h + 0 >> 2];
c[a + 4 >> 2] = c[h + 4 >> 2];
c[a + 8 >> 2] = c[h + 8 >> 2];
c[a + 12 >> 2] = c[h + 12 >> 2];
c[a + 16 >> 2] = c[h + 16 >> 2];
c[a + 20 >> 2] = c[h + 20 >> 2];
c[a + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
m = 1;
i = e;
return m | 0
}
if (l) {
c[f + 0 >> 2] = c[a + 0 >> 2];
c[f + 4 >> 2] = c[a + 4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f + 16 >> 2] = c[a + 16 >> 2];
c[f + 20 >> 2] = c[a + 20 >> 2];
c[f + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[j + 0 >> 2];
c[a + 4 >> 2] = c[j + 4 >> 2];
c[a + 8 >> 2] = c[j + 8 >> 2];
c[a + 12 >> 2] = c[j + 12 >> 2];
c[a + 16 >> 2] = c[j + 16 >> 2];
c[a + 20 >> 2] = c[j + 20 >> 2];
c[a + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[f + 0 >> 2];
c[j + 4 >> 2] = c[f + 4 >> 2];
c[j + 8 >> 2] = c[f + 8 >> 2];
c[j + 12 >> 2] = c[f + 12 >> 2];
c[j + 16 >> 2] = c[f + 16 >> 2];
c[j + 20 >> 2] = c[f + 20 >> 2];
c[j + 24 >> 2] = c[f + 24 >> 2];
m = 1;
i = e;
return m | 0
}
c[f + 0 >> 2] = c[a + 0 >> 2];
c[f + 4 >> 2] = c[a + 4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f + 16 >> 2] = c[a + 16 >> 2];
c[f + 20 >> 2] = c[a + 20 >> 2];
c[f + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[h + 0 >> 2];
c[a + 4 >> 2] = c[h + 4 >> 2];
c[a + 8 >> 2] = c[h + 8 >> 2];
c[a + 12 >> 2] = c[h + 12 >> 2];
c[a + 16 >> 2] = c[h + 16 >> 2];
c[a + 20 >> 2] = c[h + 20 >> 2];
c[a + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
if (!(nb[c[d >> 2] & 31](j, h) | 0)) {
m = 1;
i = e;
return m | 0
}
c[f + 0 >> 2] = c[h + 0 >> 2];
c[f + 4 >> 2] = c[h + 4 >> 2];
c[f + 8 >> 2] = c[h + 8 >> 2];
c[f + 12 >> 2] = c[h + 12 >> 2];
c[f + 16 >> 2] = c[h + 16 >> 2];
c[f + 20 >> 2] = c[h + 20 >> 2];
c[f + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[j + 0 >> 2];
c[h + 4 >> 2] = c[j + 4 >> 2];
c[h + 8 >> 2] =
c[j + 8 >> 2];
c[h + 12 >> 2] = c[j + 12 >> 2];
c[h + 16 >> 2] = c[j + 16 >> 2];
c[h + 20 >> 2] = c[j + 20 >> 2];
c[h + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[f + 0 >> 2];
c[j + 4 >> 2] = c[f + 4 >> 2];
c[j + 8 >> 2] = c[f + 8 >> 2];
c[j + 12 >> 2] = c[f + 12 >> 2];
c[j + 16 >> 2] = c[f + 16 >> 2];
c[j + 20 >> 2] = c[f + 20 >> 2];
c[j + 24 >> 2] = c[f + 24 >> 2];
m = 1;
i = e;
return m | 0;
case 1:
case 0:
m = 1;
i = e;
return m | 0;
case 4:
zl(a, a + 28 | 0, a + 56 | 0, b + -28 | 0, d) | 0;
m = 1;
i = e;
return m | 0;
case 2:
j = b + -28 | 0;
if (!(nb[c[d >> 2] & 31](j, a) | 0)) {
m = 1;
i = e;
return m | 0
}
c[f + 0 >> 2] = c[a + 0 >> 2];
c[f + 4 >> 2] = c[a + 4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f + 16 >> 2] = c[a + 16 >> 2];
c[f + 20 >> 2] = c[a + 20 >> 2];
c[f + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[j + 0 >> 2];
c[a + 4 >> 2] = c[j + 4 >> 2];
c[a + 8 >> 2] = c[j + 8 >> 2];
c[a + 12 >> 2] = c[j + 12 >> 2];
c[a + 16 >> 2] = c[j + 16 >> 2];
c[a + 20 >> 2] = c[j + 20 >> 2];
c[a + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[f + 0 >> 2];
c[j + 4 >> 2] = c[f + 4 >> 2];
c[j + 8 >> 2] = c[f + 8 >> 2];
c[j + 12 >> 2] = c[f + 12 >> 2];
c[j + 16 >> 2] = c[f + 16 >> 2];
c[j + 20 >> 2] = c[f + 20 >> 2];
c[j + 24 >> 2] = c[f + 24 >> 2];
m = 1;
i = e;
return m | 0;
default:
j = a + 56 | 0;
h = a + 28 | 0;
l = nb[c[d >> 2] & 31](h, a) | 0;
k = nb[c[d >> 2] & 31](j, h) | 0;
do if (l) {
if (k) {
c[f + 0 >> 2] = c[a + 0 >> 2];
c[f + 4 >> 2] = c[a +
4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f + 16 >> 2] = c[a + 16 >> 2];
c[f + 20 >> 2] = c[a + 20 >> 2];
c[f + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[j + 0 >> 2];
c[a + 4 >> 2] = c[j + 4 >> 2];
c[a + 8 >> 2] = c[j + 8 >> 2];
c[a + 12 >> 2] = c[j + 12 >> 2];
c[a + 16 >> 2] = c[j + 16 >> 2];
c[a + 20 >> 2] = c[j + 20 >> 2];
c[a + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[f + 0 >> 2];
c[j + 4 >> 2] = c[f + 4 >> 2];
c[j + 8 >> 2] = c[f + 8 >> 2];
c[j + 12 >> 2] = c[f + 12 >> 2];
c[j + 16 >> 2] = c[f + 16 >> 2];
c[j + 20 >> 2] = c[f + 20 >> 2];
c[j + 24 >> 2] = c[f + 24 >> 2];
break
}
c[f + 0 >> 2] = c[a + 0 >> 2];
c[f + 4 >> 2] = c[a + 4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f +
16 >> 2] = c[a + 16 >> 2];
c[f + 20 >> 2] = c[a + 20 >> 2];
c[f + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[h + 0 >> 2];
c[a + 4 >> 2] = c[h + 4 >> 2];
c[a + 8 >> 2] = c[h + 8 >> 2];
c[a + 12 >> 2] = c[h + 12 >> 2];
c[a + 16 >> 2] = c[h + 16 >> 2];
c[a + 20 >> 2] = c[h + 20 >> 2];
c[a + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2];
if (nb[c[d >> 2] & 31](j, h) | 0) {
c[f + 0 >> 2] = c[h + 0 >> 2];
c[f + 4 >> 2] = c[h + 4 >> 2];
c[f + 8 >> 2] = c[h + 8 >> 2];
c[f + 12 >> 2] = c[h + 12 >> 2];
c[f + 16 >> 2] = c[h + 16 >> 2];
c[f + 20 >> 2] = c[h +
20 >> 2];
c[f + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[j + 0 >> 2];
c[h + 4 >> 2] = c[j + 4 >> 2];
c[h + 8 >> 2] = c[j + 8 >> 2];
c[h + 12 >> 2] = c[j + 12 >> 2];
c[h + 16 >> 2] = c[j + 16 >> 2];
c[h + 20 >> 2] = c[j + 20 >> 2];
c[h + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[f + 0 >> 2];
c[j + 4 >> 2] = c[f + 4 >> 2];
c[j + 8 >> 2] = c[f + 8 >> 2];
c[j + 12 >> 2] = c[f + 12 >> 2];
c[j + 16 >> 2] = c[f + 16 >> 2];
c[j + 20 >> 2] = c[f + 20 >> 2];
c[j + 24 >> 2] = c[f + 24 >> 2]
}
} else if (k) {
c[f + 0 >> 2] = c[h + 0 >> 2];
c[f + 4 >> 2] = c[h + 4 >> 2];
c[f + 8 >> 2] = c[h + 8 >> 2];
c[f + 12 >> 2] = c[h + 12 >> 2];
c[f + 16 >> 2] = c[h + 16 >> 2];
c[f + 20 >> 2] = c[h + 20 >> 2];
c[f + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[j + 0 >>
2];
c[h + 4 >> 2] = c[j + 4 >> 2];
c[h + 8 >> 2] = c[j + 8 >> 2];
c[h + 12 >> 2] = c[j + 12 >> 2];
c[h + 16 >> 2] = c[j + 16 >> 2];
c[h + 20 >> 2] = c[j + 20 >> 2];
c[h + 24 >> 2] = c[j + 24 >> 2];
c[j + 0 >> 2] = c[f + 0 >> 2];
c[j + 4 >> 2] = c[f + 4 >> 2];
c[j + 8 >> 2] = c[f + 8 >> 2];
c[j + 12 >> 2] = c[f + 12 >> 2];
c[j + 16 >> 2] = c[f + 16 >> 2];
c[j + 20 >> 2] = c[f + 20 >> 2];
c[j + 24 >> 2] = c[f + 24 >> 2];
if (nb[c[d >> 2] & 31](h, a) | 0) {
c[f + 0 >> 2] = c[a + 0 >> 2];
c[f + 4 >> 2] = c[a + 4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f + 16 >> 2] = c[a + 16 >> 2];
c[f + 20 >> 2] = c[a + 20 >> 2];
c[f + 24 >> 2] = c[a + 24 >> 2];
c[a + 0 >> 2] = c[h + 0 >> 2];
c[a + 4 >> 2] = c[h + 4 >> 2];
c[a + 8 >> 2] =
c[h + 8 >> 2];
c[a + 12 >> 2] = c[h + 12 >> 2];
c[a + 16 >> 2] = c[h + 16 >> 2];
c[a + 20 >> 2] = c[h + 20 >> 2];
c[a + 24 >> 2] = c[h + 24 >> 2];
c[h + 0 >> 2] = c[f + 0 >> 2];
c[h + 4 >> 2] = c[f + 4 >> 2];
c[h + 8 >> 2] = c[f + 8 >> 2];
c[h + 12 >> 2] = c[f + 12 >> 2];
c[h + 16 >> 2] = c[f + 16 >> 2];
c[h + 20 >> 2] = c[f + 20 >> 2];
c[h + 24 >> 2] = c[f + 24 >> 2]
}
}
while (0);
f = a + 84 | 0;
if ((f | 0) == (b | 0)) {
m = 1;
i = e;
return m | 0
}
h = 0;
k = f;
f = j;
while (1) {
if (nb[c[d >> 2] & 31](k, f) | 0) {
c[g + 0 >> 2] = c[k + 0 >> 2];
c[g + 4 >> 2] = c[k + 4 >> 2];
c[g + 8 >> 2] = c[k + 8 >> 2];
c[g + 12 >> 2] = c[k + 12 >> 2];
c[g + 16 >> 2] = c[k + 16 >> 2];
c[g + 20 >> 2] = c[k + 20 >> 2];
c[g + 24 >> 2] = c[k + 24 >> 2];
j = k;
l =
f;
while (1) {
c[j + 0 >> 2] = c[l + 0 >> 2];
c[j + 4 >> 2] = c[l + 4 >> 2];
c[j + 8 >> 2] = c[l + 8 >> 2];
c[j + 12 >> 2] = c[l + 12 >> 2];
c[j + 16 >> 2] = c[l + 16 >> 2];
c[j + 20 >> 2] = c[l + 20 >> 2];
c[j + 24 >> 2] = c[l + 24 >> 2];
if ((l | 0) == (a | 0))
break;
n = l + -28 | 0;
if (nb[c[d >> 2] & 31](g, n) | 0) {
o = l;
l = n;
j = o
} else
break
}
c[l + 0 >> 2] = c[g + 0 >> 2];
c[l + 4 >> 2] = c[g + 4 >> 2];
c[l + 8 >> 2] = c[g + 8 >> 2];
c[l + 12 >> 2] = c[g + 12 >> 2];
c[l + 16 >> 2] = c[g + 16 >> 2];
c[l + 20 >> 2] = c[g + 20 >> 2];
c[l + 24 >> 2] = c[g + 24 >> 2];
j = h + 1 | 0;
if ((j | 0) == 8)
break;
else
p = j
} else
p = h;
j = k + 28 | 0;
if ((j | 0) == (b | 0)) {
m = 1;
q = 35;
break
} else {
o = k;
h = p;
k = j;
f = o
}
}
if ((q |
0) == 35) {
i = e;
return m | 0
}
m = (k + 28 | 0) == (b | 0);
i = e;
return m | 0
}
return 0
}
function Cl(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0;
e = i;
i = i + 16 | 0;
f = e;
g = a;
a = b;
a:
while (1) {
b = a;
h = a + -8 | 0;
j = g;
b:
while (1) {
k = j;
l = b - k | 0;
m = l >> 3;
switch (m | 0) {
case 2:
n = 4;
break a;
break;
case 3:
n = 6;
break a;
break;
case 4:
n = 14;
break a;
break;
case 5:
n = 26;
break a;
break;
case 1:
case 0:
n = 84;
break a;
break;
default:
}
if ((l |
0) < 248) {
n = 28;
break a
}
o = (m | 0) / 2 | 0;
p = j + (o << 3) | 0;
do if ((l | 0) <= 7992) {
q = nb[c[d >> 2] & 31](p, j) | 0;
r = nb[c[d >> 2] & 31](h, p) | 0;
if (!q) {
if (!r) {
s = 0;
break
}
q = p;
t = c[q >> 2] | 0;
u = c[q + 4 >> 2] | 0;
q = h;
v = c[q + 4 >> 2] | 0;
w = p;
c[w >> 2] = c[q >> 2];
c[w + 4 >> 2] = v;
v = h;
c[v >> 2] = t;
c[v + 4 >> 2] = u;
if (!(nb[c[d >> 2] & 31](p, j) | 0)) {
s = 1;
break
}
u = j;
v = c[u >> 2] | 0;
t = c[u + 4 >> 2] | 0;
u = p;
w = c[u + 4 >> 2] | 0;
q = j;
c[q >> 2] = c[u >> 2];
c[q + 4 >> 2] = w;
w = p;
c[w >> 2] = v;
c[w + 4 >> 2] = t;
s = 2;
break
}
t = j;
w = c[t >> 2] | 0;
v = c[t + 4 >> 2] | 0;
if (r) {
r = h;
t = c[r + 4 >> 2] | 0;
q = j;
c[q >> 2] = c[r >> 2];
c[q + 4 >> 2] = t;
t = h;
c[t >> 2] = w;
c[t +
4 >> 2] = v;
s = 1;
break
}
t = p;
q = c[t + 4 >> 2] | 0;
r = j;
c[r >> 2] = c[t >> 2];
c[r + 4 >> 2] = q;
q = p;
c[q >> 2] = w;
c[q + 4 >> 2] = v;
if (nb[c[d >> 2] & 31](h, p) | 0) {
v = p;
q = c[v >> 2] | 0;
w = c[v + 4 >> 2] | 0;
v = h;
r = c[v + 4 >> 2] | 0;
t = p;
c[t >> 2] = c[v >> 2];
c[t + 4 >> 2] = r;
r = h;
c[r >> 2] = q;
c[r + 4 >> 2] = w;
s = 2
} else
s = 1
} else {
w = (m | 0) / 4 | 0;
s = Dl(j, j + (w << 3) | 0, p, j + (w + o << 3) | 0, h, d) | 0
}
while (0);
do if (nb[c[d >> 2] & 31](j, p) | 0) {
x = h;
y = s
} else {
o = h;
while (1) {
o = o + -8 | 0;
if ((j | 0) == (o | 0))
break;
if (nb[c[d >> 2] & 31](o, p) | 0) {
n = 67;
break
}
}
if ((n | 0) == 67) {
n = 0;
m = j;
l = c[m >> 2] | 0;
w = c[m + 4 >> 2] | 0;
m = o;
r = c[m + 4 >> 2] | 0;
q = j;
c[q >>
2] = c[m >> 2];
c[q + 4 >> 2] = r;
r = o;
c[r >> 2] = l;
c[r + 4 >> 2] = w;
x = o;
y = s + 1 | 0;
break
}
w = j + 8 | 0;
if (nb[c[d >> 2] & 31](j, h) | 0)
z = w;
else {
if ((w | 0) == (h | 0)) {
n = 84;
break a
} else
A = w;
while (1) {
B = A + 8 | 0;
if (nb[c[d >> 2] & 31](j, A) | 0)
break;
if ((B | 0) == (h | 0)) {
n = 84;
break a
} else
A = B
}
o = A;
w = c[o >> 2] | 0;
r = c[o + 4 >> 2] | 0;
o = h;
l = c[o + 4 >> 2] | 0;
q = A;
c[q >> 2] = c[o >> 2];
c[q + 4 >> 2] = l;
l = h;
c[l >> 2] = w;
c[l + 4 >> 2] = r;
z = B
}
if ((z | 0) == (h | 0)) {
n = 84;
break a
} else {
C = z;
D = h
}
while (1) {
r = C;
while (1) {
E = r + 8 | 0;
if (nb[c[d >> 2] & 31](j, r) | 0) {
F = D;
break
} else
r = E
}
do F = F + -8 | 0;
while (nb[c[d >> 2] & 31](j, F) |
0);
if (!(r >>> 0 < F >>> 0)) {
j = r;
continue b
}
l = r;
w = c[l >> 2] | 0;
q = c[l + 4 >> 2] | 0;
l = F;
o = c[l + 4 >> 2] | 0;
m = r;
c[m >> 2] = c[l >> 2];
c[m + 4 >> 2] = o;
o = F;
c[o >> 2] = w;
c[o + 4 >> 2] = q;
C = E;
D = F
}
}
while (0);
q = j + 8 | 0;
c:
do if (q >>> 0 < x >>> 0) {
o = q;
w = x;
m = p;
l = y;
while (1) {
t = o;
while (1) {
G = t + 8 | 0;
if (nb[c[d >> 2] & 31](t, m) | 0)
t = G;
else {
H = w;
break
}
}
do H = H + -8 | 0;
while (!(nb[c[d >> 2] & 31](H, m) | 0));
if (t >>> 0 > H >>> 0) {
I = t;
J = m;
K = l;
break c
}
r = t;
v = c[r >> 2] | 0;
u = c[r + 4 >> 2] | 0;
r = H;
L = c[r + 4 >> 2] | 0;
M = t;
c[M >> 2] = c[r >> 2];
c[M + 4 >> 2] = L;
L = H;
c[L >> 2] = v;
c[L + 4 >> 2] = u;
o = G;
w = H;
m = (m | 0) == (t | 0) ? H : m;
l = l + 1 | 0
}
} else {
I =
q;
J = p;
K = y
}
while (0);
if ((I | 0) != (J | 0) ? nb[c[d >> 2] & 31](J, I) | 0 : 0) {
p = I;
q = c[p >> 2] | 0;
l = c[p + 4 >> 2] | 0;
p = J;
m = c[p + 4 >> 2] | 0;
w = I;
c[w >> 2] = c[p >> 2];
c[w + 4 >> 2] = m;
m = J;
c[m >> 2] = q;
c[m + 4 >> 2] = l;
N = K + 1 | 0
} else
N = K;
if ((N | 0) == 0) {
O = El(j, I, d) | 0;
l = I + 8 | 0;
if (El(l, a, d) | 0) {
n = 79;
break
}
if (O) {
j = l;
continue
}
}
l = I;
if ((l - k | 0) >= (b - l | 0)) {
n = 83;
break
}
Cl(j, I, d);
j = I + 8 | 0
}
if ((n | 0) == 79) {
n = 0;
if (O) {
n = 84;
break
} else {
g = j;
a = I;
continue
}
} else if ((n | 0) == 83) {
n = 0;
Cl(I + 8 | 0, a, d);
g = j;
a = I;
continue
}
}
if ((n | 0) == 4) {
if (!(nb[c[d >> 2] & 31](h, j) | 0)) {
i = e;
return
}
I = j;
g = c[I >> 2] | 0;
O = c[I + 4 >> 2] | 0;
I = h;
N = c[I + 4 >> 2] | 0;
K = j;
c[K >> 2] = c[I >> 2];
c[K + 4 >> 2] = N;
N = h;
c[N >> 2] = g;
c[N + 4 >> 2] = O;
i = e;
return
} else if ((n | 0) == 6) {
O = j + 8 | 0;
N = nb[c[d >> 2] & 31](O, j) | 0;
g = nb[c[d >> 2] & 31](h, O) | 0;
if (!N) {
if (!g) {
i = e;
return
}
N = O;
K = c[N >> 2] | 0;
I = c[N + 4 >> 2] | 0;
N = h;
J = c[N + 4 >> 2] | 0;
y = O;
c[y >> 2] = c[N >> 2];
c[y + 4 >> 2] = J;
J = h;
c[J >> 2] = K;
c[J + 4 >> 2] = I;
if (!(nb[c[d >> 2] & 31](O, j) | 0)) {
i = e;
return
}
I = j;
J = c[I >> 2] | 0;
K = c[I + 4 >> 2] | 0;
I = O;
y = c[I + 4 >> 2] | 0;
N = j;
c[N >> 2] = c[I >> 2];
c[N + 4 >> 2] = y;
y = O;
c[y >> 2] = J;
c[y + 4 >> 2] = K;
i = e;
return
}
K = j;
y = c[K >> 2] | 0;
J = c[K + 4 >> 2] | 0;
if (g) {
g =
h;
K = c[g + 4 >> 2] | 0;
N = j;
c[N >> 2] = c[g >> 2];
c[N + 4 >> 2] = K;
K = h;
c[K >> 2] = y;
c[K + 4 >> 2] = J;
i = e;
return
}
K = O;
N = c[K + 4 >> 2] | 0;
g = j;
c[g >> 2] = c[K >> 2];
c[g + 4 >> 2] = N;
N = O;
c[N >> 2] = y;
c[N + 4 >> 2] = J;
if (!(nb[c[d >> 2] & 31](h, O) | 0)) {
i = e;
return
}
J = O;
N = c[J >> 2] | 0;
y = c[J + 4 >> 2] | 0;
J = h;
g = c[J + 4 >> 2] | 0;
K = O;
c[K >> 2] = c[J >> 2];
c[K + 4 >> 2] = g;
g = h;
c[g >> 2] = N;
c[g + 4 >> 2] = y;
i = e;
return
} else if ((n | 0) == 14) {
y = j + 8 | 0;
g = j + 16 | 0;
N = nb[c[d >> 2] & 31](y, j) | 0;
K = nb[c[d >> 2] & 31](g, y) | 0;
do if (N) {
J = j;
O = c[J >> 2] | 0;
I = c[J + 4 >> 2] | 0;
if (K) {
J = g;
H = c[J + 4 >> 2] | 0;
G = j;
c[G >> 2] = c[J >> 2];
c[G + 4 >> 2] = H;
H = g;
c[H >> 2] = O;
c[H + 4 >> 2] = I;
break
}
H = y;
G = c[H + 4 >> 2] | 0;
J = j;
c[J >> 2] = c[H >> 2];
c[J + 4 >> 2] = G;
G = y;
c[G >> 2] = O;
c[G + 4 >> 2] = I;
if (nb[c[d >> 2] & 31](g, y) | 0) {
I = y;
G = c[I >> 2] | 0;
O = c[I + 4 >> 2] | 0;
I = g;
J = c[I + 4 >> 2] | 0;
H = y;
c[H >> 2] = c[I >> 2];
c[H + 4 >> 2] = J;
J = g;
c[J >> 2] = G;
c[J + 4 >> 2] = O
}
} else if (K ? (O = y, J = c[O >> 2] | 0, G = c[O + 4 >> 2] | 0, O = g, H = c[O + 4 >> 2] | 0, I = y, c[I >> 2] = c[O >> 2], c[I + 4 >> 2] = H, H = g, c[H >> 2] = J, c[H + 4 >> 2] = G, nb[c[d >> 2] & 31](y, j) | 0) : 0) {
G = j;
H = c[G >> 2] | 0;
J = c[G + 4 >> 2] | 0;
G = y;
I = c[G + 4 >> 2] | 0;
O = j;
c[O >> 2] = c[G >> 2];
c[O + 4 >> 2] = I;
I = y;
c[I >> 2] = H;
c[I + 4 >> 2] = J
}
while (0);
if (!(nb[c[d >>
2] & 31](h, g) | 0)) {
i = e;
return
}
K = g;
N = c[K >> 2] | 0;
J = c[K + 4 >> 2] | 0;
K = h;
I = c[K + 4 >> 2] | 0;
H = g;
c[H >> 2] = c[K >> 2];
c[H + 4 >> 2] = I;
I = h;
c[I >> 2] = N;
c[I + 4 >> 2] = J;
if (!(nb[c[d >> 2] & 31](g, y) | 0)) {
i = e;
return
}
J = y;
I = c[J >> 2] | 0;
N = c[J + 4 >> 2] | 0;
J = g;
H = c[J + 4 >> 2] | 0;
K = y;
c[K >> 2] = c[J >> 2];
c[K + 4 >> 2] = H;
H = g;
c[H >> 2] = I;
c[H + 4 >> 2] = N;
if (!(nb[c[d >> 2] & 31](y, j) | 0)) {
i = e;
return
}
N = j;
H = c[N >> 2] | 0;
I = c[N + 4 >> 2] | 0;
N = y;
g = c[N + 4 >> 2] | 0;
K = j;
c[K >> 2] = c[N >> 2];
c[K + 4 >> 2] = g;
g = y;
c[g >> 2] = H;
c[g + 4 >> 2] = I;
i = e;
return
} else if ((n | 0) == 26) {
Dl(j, j + 8 | 0, j + 16 | 0, j + 24 | 0, h, d) | 0;
i = e;
return
} else if ((n |
0) == 28) {
h = j + 16 | 0;
I = j + 8 | 0;
g = nb[c[d >> 2] & 31](I, j) | 0;
H = nb[c[d >> 2] & 31](h, I) | 0;
do if (g) {
y = j;
K = c[y >> 2] | 0;
N = c[y + 4 >> 2] | 0;
if (H) {
y = h;
J = c[y + 4 >> 2] | 0;
O = j;
c[O >> 2] = c[y >> 2];
c[O + 4 >> 2] = J;
J = h;
c[J >> 2] = K;
c[J + 4 >> 2] = N;
break
}
J = I;
O = c[J + 4 >> 2] | 0;
y = j;
c[y >> 2] = c[J >> 2];
c[y + 4 >> 2] = O;
O = I;
c[O >> 2] = K;
c[O + 4 >> 2] = N;
if (nb[c[d >> 2] & 31](h, I) | 0) {
N = I;
O = c[N >> 2] | 0;
K = c[N + 4 >> 2] | 0;
N = h;
y = c[N + 4 >> 2] | 0;
J = I;
c[J >> 2] = c[N >> 2];
c[J + 4 >> 2] = y;
y = h;
c[y >> 2] = O;
c[y + 4 >> 2] = K
}
} else if (H ? (K = I, y = c[K >> 2] | 0, O = c[K + 4 >> 2] | 0, K = h, J = c[K + 4 >> 2] | 0, N = I, c[N >> 2] = c[K >> 2], c[N + 4 >> 2] = J, J =
h, c[J >> 2] = y, c[J + 4 >> 2] = O, nb[c[d >> 2] & 31](I, j) | 0) : 0) {
O = j;
J = c[O >> 2] | 0;
y = c[O + 4 >> 2] | 0;
O = I;
N = c[O + 4 >> 2] | 0;
K = j;
c[K >> 2] = c[O >> 2];
c[K + 4 >> 2] = N;
N = I;
c[N >> 2] = J;
c[N + 4 >> 2] = y
}
while (0);
I = j + 24 | 0;
if ((I | 0) == (a | 0)) {
i = e;
return
} else {
P = I;
Q = h
}
while (1) {
if (nb[c[d >> 2] & 31](P, Q) | 0) {
h = P;
I = c[h + 4 >> 2] | 0;
H = f;
c[H >> 2] = c[h >> 2];
c[H + 4 >> 2] = I;
I = P;
H = Q;
while (1) {
h = H;
g = c[h + 4 >> 2] | 0;
y = I;
c[y >> 2] = c[h >> 2];
c[y + 4 >> 2] = g;
if ((H | 0) == (j | 0))
break;
g = H + -8 | 0;
if (nb[c[d >> 2] & 31](f, g) | 0) {
y = H;
H = g;
I = y
} else
break
}
I = f;
y = c[I + 4 >> 2] | 0;
g = H;
c[g >> 2] = c[I >> 2];
c[g + 4 >> 2] = y
}
y = P +
8 | 0;
if ((y | 0) == (a | 0))
break;
else {
g = P;
P = y;
Q = g
}
}
i = e;
return
} else if ((n | 0) == 84) {
i = e;
return
}
}
function Dl(a, b, d, e, f, g) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0;
h = i;
j = nb[c[g >> 2] & 31](b, a) | 0;
k = nb[c[g >> 2] & 31](d, b) | 0;
do if (j) {
l = a;
m = c[l >> 2] | 0;
n = c[l + 4 >> 2] | 0;
if (k) {
l = d;
o = c[l + 4 >> 2] | 0;
p = a;
c[p >> 2] = c[l >> 2];
c[p + 4 >> 2] = o;
o = d;
c[o >> 2] = m;
c[o + 4 >> 2] = n;
q = 1;
break
}
o = b;
p = c[o + 4 >> 2] | 0;
l = a;
c[l >> 2] = c[o >> 2];
c[l + 4 >> 2] = p;
p = b;
c[p >> 2] = m;
c[p + 4 >> 2] = n;
if (nb[c[g >> 2] & 31](d, b) | 0) {
n = b;
p = c[n >> 2] | 0;
m = c[n +
4 >> 2] | 0;
n = d;
l = c[n + 4 >> 2] | 0;
o = b;
c[o >> 2] = c[n >> 2];
c[o + 4 >> 2] = l;
l = d;
c[l >> 2] = p;
c[l + 4 >> 2] = m;
q = 2
} else
q = 1
} else if (k) {
m = b;
l = c[m >> 2] | 0;
p = c[m + 4 >> 2] | 0;
m = d;
o = c[m + 4 >> 2] | 0;
n = b;
c[n >> 2] = c[m >> 2];
c[n + 4 >> 2] = o;
o = d;
c[o >> 2] = l;
c[o + 4 >> 2] = p;
if (nb[c[g >> 2] & 31](b, a) | 0) {
p = a;
o = c[p >> 2] | 0;
l = c[p + 4 >> 2] | 0;
p = b;
n = c[p + 4 >> 2] | 0;
m = a;
c[m >> 2] = c[p >> 2];
c[m + 4 >> 2] = n;
n = b;
c[n >> 2] = o;
c[n + 4 >> 2] = l;
q = 2
} else
q = 1
} else
q = 0;
while (0);
if (nb[c[g >> 2] & 31](e, d) | 0) {
k = d;
j = c[k >> 2] | 0;
l = c[k + 4 >> 2] | 0;
k = e;
n = c[k + 4 >> 2] | 0;
o = d;
c[o >> 2] = c[k >> 2];
c[o + 4 >> 2] = n;
n = e;
c[n >> 2] = j;
c[n +
4 >> 2] = l;
l = q + 1 | 0;
if (nb[c[g >> 2] & 31](d, b) | 0) {
n = b;
j = c[n >> 2] | 0;
o = c[n + 4 >> 2] | 0;
n = d;
k = c[n + 4 >> 2] | 0;
m = b;
c[m >> 2] = c[n >> 2];
c[m + 4 >> 2] = k;
k = d;
c[k >> 2] = j;
c[k + 4 >> 2] = o;
if (nb[c[g >> 2] & 31](b, a) | 0) {
o = a;
k = c[o >> 2] | 0;
j = c[o + 4 >> 2] | 0;
o = b;
m = c[o + 4 >> 2] | 0;
n = a;
c[n >> 2] = c[o >> 2];
c[n + 4 >> 2] = m;
m = b;
c[m >> 2] = k;
c[m + 4 >> 2] = j;
r = q + 3 | 0
} else
r = q + 2 | 0
} else
r = l
} else
r = q;
if (!(nb[c[g >> 2] & 31](f, e) | 0)) {
s = r;
i = h;
return s | 0
}
q = e;
l = c[q >> 2] | 0;
j = c[q + 4 >> 2] | 0;
q = f;
m = c[q + 4 >> 2] | 0;
k = e;
c[k >> 2] = c[q >> 2];
c[k + 4 >> 2] = m;
m = f;
c[m >> 2] = l;
c[m + 4 >> 2] = j;
if (!(nb[c[g >> 2] & 31](e, d) | 0)) {
s =
r + 1 | 0;
i = h;
return s | 0
}
j = d;
m = c[j >> 2] | 0;
l = c[j + 4 >> 2] | 0;
j = e;
f = c[j + 4 >> 2] | 0;
k = d;
c[k >> 2] = c[j >> 2];
c[k + 4 >> 2] = f;
f = e;
c[f >> 2] = m;
c[f + 4 >> 2] = l;
if (!(nb[c[g >> 2] & 31](d, b) | 0)) {
s = r + 2 | 0;
i = h;
return s | 0
}
l = b;
f = c[l >> 2] | 0;
m = c[l + 4 >> 2] | 0;
l = d;
e = c[l + 4 >> 2] | 0;
k = b;
c[k >> 2] = c[l >> 2];
c[k + 4 >> 2] = e;
e = d;
c[e >> 2] = f;
c[e + 4 >> 2] = m;
if (!(nb[c[g >> 2] & 31](b, a) | 0)) {
s = r + 3 | 0;
i = h;
return s | 0
}
g = a;
m = c[g >> 2] | 0;
e = c[g + 4 >> 2] | 0;
g = b;
f = c[g + 4 >> 2] | 0;
d = a;
c[d >> 2] = c[g >> 2];
c[d + 4 >> 2] = f;
f = b;
c[f >> 2] = m;
c[f + 4 >> 2] = e;
s = r + 4 | 0;
i = h;
return s | 0
}
function El(a, b, d) {
a = a | 0;
b = b | 0;
d = d |
0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0;
e = i;
i = i + 16 | 0;
f = e;
switch (b - a >> 3 | 0) {
case 2:
g = b + -8 | 0;
if (!(nb[c[d >> 2] & 31](g, a) | 0)) {
h = 1;
i = e;
return h | 0
}
j = a;
k = c[j >> 2] | 0;
l = c[j + 4 >> 2] | 0;
j = g;
m = c[j + 4 >> 2] | 0;
n = a;
c[n >> 2] = c[j >> 2];
c[n + 4 >> 2] = m;
m = g;
c[m >> 2] = k;
c[m + 4 >> 2] = l;
h = 1;
i = e;
return h | 0;
case 5:
Dl(a, a + 8 | 0, a + 16 | 0, a + 24 | 0, b + -8 | 0, d) | 0;
h = 1;
i = e;
return h | 0;
case 1:
case 0:
h = 1;
i = e;
return h | 0;
case 4:
l = a + 8 | 0;
m = a + 16 | 0;
k = b + -8 | 0;
g = nb[c[d >> 2] & 31](l, a) | 0;
n = nb[c[d >> 2] & 31](m, l) | 0;
do if (g) {
j = a;
o = c[j >> 2] |
0;
p = c[j + 4 >> 2] | 0;
if (n) {
j = m;
q = c[j + 4 >> 2] | 0;
r = a;
c[r >> 2] = c[j >> 2];
c[r + 4 >> 2] = q;
q = m;
c[q >> 2] = o;
c[q + 4 >> 2] = p;
break
}
q = l;
r = c[q + 4 >> 2] | 0;
j = a;
c[j >> 2] = c[q >> 2];
c[j + 4 >> 2] = r;
r = l;
c[r >> 2] = o;
c[r + 4 >> 2] = p;
if (nb[c[d >> 2] & 31](m, l) | 0) {
p = l;
r = c[p >> 2] | 0;
o = c[p + 4 >> 2] | 0;
p = m;
j = c[p + 4 >> 2] | 0;
q = l;
c[q >> 2] = c[p >> 2];
c[q + 4 >> 2] = j;
j = m;
c[j >> 2] = r;
c[j + 4 >> 2] = o
}
} else if (n ? (o = l, j = c[o >> 2] | 0, r = c[o + 4 >> 2] | 0, o = m, q = c[o + 4 >> 2] | 0, p = l, c[p >> 2] = c[o >> 2], c[p + 4 >> 2] = q, q = m, c[q >> 2] = j, c[q + 4 >> 2] = r, nb[c[d >> 2] & 31](l, a) | 0) : 0) {
r = a;
q = c[r >> 2] | 0;
j = c[r + 4 >> 2] | 0;
r = l;
p = c[r + 4 >> 2] |
0;
o = a;
c[o >> 2] = c[r >> 2];
c[o + 4 >> 2] = p;
p = l;
c[p >> 2] = q;
c[p + 4 >> 2] = j
}
while (0);
if (!(nb[c[d >> 2] & 31](k, m) | 0)) {
h = 1;
i = e;
return h | 0
}
n = m;
g = c[n >> 2] | 0;
j = c[n + 4 >> 2] | 0;
n = k;
p = c[n + 4 >> 2] | 0;
q = m;
c[q >> 2] = c[n >> 2];
c[q + 4 >> 2] = p;
p = k;
c[p >> 2] = g;
c[p + 4 >> 2] = j;
if (!(nb[c[d >> 2] & 31](m, l) | 0)) {
h = 1;
i = e;
return h | 0
}
j = l;
p = c[j >> 2] | 0;
g = c[j + 4 >> 2] | 0;
j = m;
k = c[j + 4 >> 2] | 0;
q = l;
c[q >> 2] = c[j >> 2];
c[q + 4 >> 2] = k;
k = m;
c[k >> 2] = p;
c[k + 4 >> 2] = g;
if (!(nb[c[d >> 2] & 31](l, a) | 0)) {
h = 1;
i = e;
return h | 0
}
g = a;
k = c[g >> 2] | 0;
p = c[g + 4 >> 2] | 0;
g = l;
m = c[g + 4 >> 2] | 0;
q = a;
c[q >> 2] = c[g >> 2];
c[q + 4 >> 2] =
m;
m = l;
c[m >> 2] = k;
c[m + 4 >> 2] = p;
h = 1;
i = e;
return h | 0;
case 3:
p = a + 8 | 0;
m = b + -8 | 0;
k = nb[c[d >> 2] & 31](p, a) | 0;
l = nb[c[d >> 2] & 31](m, p) | 0;
if (!k) {
if (!l) {
h = 1;
i = e;
return h | 0
}
k = p;
q = c[k >> 2] | 0;
g = c[k + 4 >> 2] | 0;
k = m;
j = c[k + 4 >> 2] | 0;
n = p;
c[n >> 2] = c[k >> 2];
c[n + 4 >> 2] = j;
j = m;
c[j >> 2] = q;
c[j + 4 >> 2] = g;
if (!(nb[c[d >> 2] & 31](p, a) | 0)) {
h = 1;
i = e;
return h | 0
}
g = a;
j = c[g >> 2] | 0;
q = c[g + 4 >> 2] | 0;
g = p;
n = c[g + 4 >> 2] | 0;
k = a;
c[k >> 2] = c[g >> 2];
c[k + 4 >> 2] = n;
n = p;
c[n >> 2] = j;
c[n + 4 >> 2] = q;
h = 1;
i = e;
return h | 0
}
q = a;
n = c[q >> 2] | 0;
j = c[q + 4 >> 2] | 0;
if (l) {
l = m;
q = c[l + 4 >> 2] | 0;
k = a;
c[k >> 2] = c[l >>
2];
c[k + 4 >> 2] = q;
q = m;
c[q >> 2] = n;
c[q + 4 >> 2] = j;
h = 1;
i = e;
return h | 0
}
q = p;
k = c[q + 4 >> 2] | 0;
l = a;
c[l >> 2] = c[q >> 2];
c[l + 4 >> 2] = k;
k = p;
c[k >> 2] = n;
c[k + 4 >> 2] = j;
if (!(nb[c[d >> 2] & 31](m, p) | 0)) {
h = 1;
i = e;
return h | 0
}
j = p;
k = c[j >> 2] | 0;
n = c[j + 4 >> 2] | 0;
j = m;
l = c[j + 4 >> 2] | 0;
q = p;
c[q >> 2] = c[j >> 2];
c[q + 4 >> 2] = l;
l = m;
c[l >> 2] = k;
c[l + 4 >> 2] = n;
h = 1;
i = e;
return h | 0;
default:
n = a + 16 | 0;
l = a + 8 | 0;
k = nb[c[d >> 2] & 31](l, a) | 0;
m = nb[c[d >> 2] & 31](n, l) | 0;
do if (k) {
q = a;
j = c[q >> 2] | 0;
p = c[q + 4 >> 2] | 0;
if (m) {
q = n;
g = c[q + 4 >> 2] | 0;
o = a;
c[o >> 2] = c[q >> 2];
c[o + 4 >> 2] = g;
g = n;
c[g >> 2] = j;
c[g + 4 >> 2] =
p;
break
}
g = l;
o = c[g + 4 >> 2] | 0;
q = a;
c[q >> 2] = c[g >> 2];
c[q + 4 >> 2] = o;
o = l;
c[o >> 2] = j;
c[o + 4 >> 2] = p;
if (nb[c[d >> 2] & 31](n, l) | 0) {
p = l;
o = c[p >> 2] | 0;
j = c[p + 4 >> 2] | 0;
p = n;
q = c[p + 4 >> 2] | 0;
g = l;
c[g >> 2] = c[p >> 2];
c[g + 4 >> 2] = q;
q = n;
c[q >> 2] = o;
c[q + 4 >> 2] = j
}
} else if (m ? (j = l, q = c[j >> 2] | 0, o = c[j + 4 >> 2] | 0, j = n, g = c[j + 4 >> 2] | 0, p = l, c[p >> 2] = c[j >> 2], c[p + 4 >> 2] = g, g = n, c[g >> 2] = q, c[g + 4 >> 2] = o, nb[c[d >> 2] & 31](l, a) | 0) : 0) {
o = a;
g = c[o >> 2] | 0;
q = c[o + 4 >> 2] | 0;
o = l;
p = c[o + 4 >> 2] | 0;
j = a;
c[j >> 2] = c[o >> 2];
c[j + 4 >> 2] = p;
p = l;
c[p >> 2] = g;
c[p + 4 >> 2] = q
}
while (0);
l = a + 24 | 0;
if ((l | 0) == (b | 0)) {
h =
1;
i = e;
return h | 0
} else {
s = 0;
t = l;
u = n
}
while (1) {
if (nb[c[d >> 2] & 31](t, u) | 0) {
n = t;
l = c[n + 4 >> 2] | 0;
m = f;
c[m >> 2] = c[n >> 2];
c[m + 4 >> 2] = l;
l = t;
m = u;
while (1) {
n = m;
k = c[n + 4 >> 2] | 0;
q = l;
c[q >> 2] = c[n >> 2];
c[q + 4 >> 2] = k;
if ((m | 0) == (a | 0))
break;
k = m + -8 | 0;
if (nb[c[d >> 2] & 31](f, k) | 0) {
q = m;
m = k;
l = q
} else
break
}
l = f;
q = c[l + 4 >> 2] | 0;
k = m;
c[k >> 2] = c[l >> 2];
c[k + 4 >> 2] = q;
q = s + 1 | 0;
if ((q | 0) == 8)
break;
else
v = q
} else
v = s;
q = t + 8 | 0;
if ((q | 0) == (b | 0)) {
h = 1;
w = 41;
break
} else {
k = t;
s = v;
t = q;
u = k
}
}
if ((w | 0) == 41) {
i = e;
return h | 0
}
h = (t + 8 | 0) == (b | 0);
i = e;
return h | 0
}
return 0
}
function Fl(a,
b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0;
e = i;
i = i + 16 | 0;
f = e;
g = a;
a = b;
a:
while (1) {
b = a;
h = a + -8 | 0;
j = g;
b:
while (1) {
k = j;
l = b - k | 0;
m = l >> 3;
switch (m | 0) {
case 2:
n = 4;
break a;
break;
case 4:
n = 14;
break a;
break;
case 5:
n = 26;
break a;
break;
case 3:
n = 6;
break a;
break;
case 1:
case 0:
n = 84;
break a;
break;
default:
}
if ((l | 0) < 248) {
n = 28;
break a
}
o = (m | 0) / 2 | 0;
p = j + (o << 3) | 0;
do if ((l | 0) <= 7992) {
q = nb[c[d >> 2] &
31](p, j) | 0;
r = nb[c[d >> 2] & 31](h, p) | 0;
if (!q) {
if (!r) {
s = 0;
break
}
q = p;
t = c[q >> 2] | 0;
u = c[q + 4 >> 2] | 0;
q = h;
v = c[q + 4 >> 2] | 0;
w = p;
c[w >> 2] = c[q >> 2];
c[w + 4 >> 2] = v;
v = h;
c[v >> 2] = t;
c[v + 4 >> 2] = u;
if (!(nb[c[d >> 2] & 31](p, j) | 0)) {
s = 1;
break
}
u = j;
v = c[u >> 2] | 0;
t = c[u + 4 >> 2] | 0;
u = p;
w = c[u + 4 >> 2] | 0;
q = j;
c[q >> 2] = c[u >> 2];
c[q + 4 >> 2] = w;
w = p;
c[w >> 2] = v;
c[w + 4 >> 2] = t;
s = 2;
break
}
t = j;
w = c[t >> 2] | 0;
v = c[t + 4 >> 2] | 0;
if (r) {
r = h;
t = c[r + 4 >> 2] | 0;
q = j;
c[q >> 2] = c[r >> 2];
c[q + 4 >> 2] = t;
t = h;
c[t >> 2] = w;
c[t + 4 >> 2] = v;
s = 1;
break
}
t = p;
q = c[t + 4 >> 2] | 0;
r = j;
c[r >> 2] = c[t >> 2];
c[r + 4 >> 2] = q;
q = p;
c[q >>
2] = w;
c[q + 4 >> 2] = v;
if (nb[c[d >> 2] & 31](h, p) | 0) {
v = p;
q = c[v >> 2] | 0;
w = c[v + 4 >> 2] | 0;
v = h;
r = c[v + 4 >> 2] | 0;
t = p;
c[t >> 2] = c[v >> 2];
c[t + 4 >> 2] = r;
r = h;
c[r >> 2] = q;
c[r + 4 >> 2] = w;
s = 2
} else
s = 1
} else {
w = (m | 0) / 4 | 0;
s = Gl(j, j + (w << 3) | 0, p, j + (w + o << 3) | 0, h, d) | 0
}
while (0);
do if (nb[c[d >> 2] & 31](j, p) | 0) {
x = h;
y = s
} else {
o = h;
while (1) {
o = o + -8 | 0;
if ((j | 0) == (o | 0))
break;
if (nb[c[d >> 2] & 31](o, p) | 0) {
n = 67;
break
}
}
if ((n | 0) == 67) {
n = 0;
m = j;
l = c[m >> 2] | 0;
w = c[m + 4 >> 2] | 0;
m = o;
r = c[m + 4 >> 2] | 0;
q = j;
c[q >> 2] = c[m >> 2];
c[q + 4 >> 2] = r;
r = o;
c[r >> 2] = l;
c[r + 4 >> 2] = w;
x = o;
y = s + 1 | 0;
break
}
w = j + 8 | 0;
if (nb[c[d >> 2] & 31](j, h) | 0)
z = w;
else {
if ((w | 0) == (h | 0)) {
n = 84;
break a
} else
A = w;
while (1) {
B = A + 8 | 0;
if (nb[c[d >> 2] & 31](j, A) | 0)
break;
if ((B | 0) == (h | 0)) {
n = 84;
break a
} else
A = B
}
o = A;
w = c[o >> 2] | 0;
r = c[o + 4 >> 2] | 0;
o = h;
l = c[o + 4 >> 2] | 0;
q = A;
c[q >> 2] = c[o >> 2];
c[q + 4 >> 2] = l;
l = h;
c[l >> 2] = w;
c[l + 4 >> 2] = r;
z = B
}
if ((z | 0) == (h | 0)) {
n = 84;
break a
} else {
C = z;
D = h
}
while (1) {
r = C;
while (1) {
E = r + 8 | 0;
if (nb[c[d >> 2] & 31](j, r) | 0) {
F = D;
break
} else
r = E
}
do F = F + -8 | 0;
while (nb[c[d >> 2] & 31](j, F) | 0);
if (!(r >>> 0 < F >>> 0)) {
j = r;
continue b
}
l = r;
w = c[l >> 2] | 0;
q = c[l + 4 >> 2] | 0;
l = F;
o = c[l +
4 >> 2] | 0;
m = r;
c[m >> 2] = c[l >> 2];
c[m + 4 >> 2] = o;
o = F;
c[o >> 2] = w;
c[o + 4 >> 2] = q;
C = E;
D = F
}
}
while (0);
q = j + 8 | 0;
c:
do if (q >>> 0 < x >>> 0) {
o = q;
w = x;
m = p;
l = y;
while (1) {
t = o;
while (1) {
G = t + 8 | 0;
if (nb[c[d >> 2] & 31](t, m) | 0)
t = G;
else {
H = w;
break
}
}
do H = H + -8 | 0;
while (!(nb[c[d >> 2] & 31](H, m) | 0));
if (t >>> 0 > H >>> 0) {
I = t;
J = m;
K = l;
break c
}
r = t;
v = c[r >> 2] | 0;
u = c[r + 4 >> 2] | 0;
r = H;
L = c[r + 4 >> 2] | 0;
M = t;
c[M >> 2] = c[r >> 2];
c[M + 4 >> 2] = L;
L = H;
c[L >> 2] = v;
c[L + 4 >> 2] = u;
o = G;
w = H;
m = (m | 0) == (t | 0) ? H : m;
l = l + 1 | 0
}
} else {
I = q;
J = p;
K = y
}
while (0);
if ((I | 0) != (J | 0) ? nb[c[d >> 2] & 31](J, I) | 0 : 0) {
p = I;
q = c[p >>
2] | 0;
l = c[p + 4 >> 2] | 0;
p = J;
m = c[p + 4 >> 2] | 0;
w = I;
c[w >> 2] = c[p >> 2];
c[w + 4 >> 2] = m;
m = J;
c[m >> 2] = q;
c[m + 4 >> 2] = l;
N = K + 1 | 0
} else
N = K;
if ((N | 0) == 0) {
O = Hl(j, I, d) | 0;
l = I + 8 | 0;
if (Hl(l, a, d) | 0) {
n = 79;
break
}
if (O) {
j = l;
continue
}
}
l = I;
if ((l - k | 0) >= (b - l | 0)) {
n = 83;
break
}
Fl(j, I, d);
j = I + 8 | 0
}
if ((n | 0) == 79) {
n = 0;
if (O) {
n = 84;
break
} else {
g = j;
a = I;
continue
}
} else if ((n | 0) == 83) {
n = 0;
Fl(I + 8 | 0, a, d);
g = j;
a = I;
continue
}
}
if ((n | 0) == 4) {
if (!(nb[c[d >> 2] & 31](h, j) | 0)) {
i = e;
return
}
I = j;
g = c[I >> 2] | 0;
O = c[I + 4 >> 2] | 0;
I = h;
N = c[I + 4 >> 2] | 0;
K = j;
c[K >> 2] = c[I >> 2];
c[K + 4 >> 2] = N;
N = h;
c[N >>
2] = g;
c[N + 4 >> 2] = O;
i = e;
return
} else if ((n | 0) == 6) {
O = j + 8 | 0;
N = nb[c[d >> 2] & 31](O, j) | 0;
g = nb[c[d >> 2] & 31](h, O) | 0;
if (!N) {
if (!g) {
i = e;
return
}
N = O;
K = c[N >> 2] | 0;
I = c[N + 4 >> 2] | 0;
N = h;
J = c[N + 4 >> 2] | 0;
y = O;
c[y >> 2] = c[N >> 2];
c[y + 4 >> 2] = J;
J = h;
c[J >> 2] = K;
c[J + 4 >> 2] = I;
if (!(nb[c[d >> 2] & 31](O, j) | 0)) {
i = e;
return
}
I = j;
J = c[I >> 2] | 0;
K = c[I + 4 >> 2] | 0;
I = O;
y = c[I + 4 >> 2] | 0;
N = j;
c[N >> 2] = c[I >> 2];
c[N + 4 >> 2] = y;
y = O;
c[y >> 2] = J;
c[y + 4 >> 2] = K;
i = e;
return
}
K = j;
y = c[K >> 2] | 0;
J = c[K + 4 >> 2] | 0;
if (g) {
g = h;
K = c[g + 4 >> 2] | 0;
N = j;
c[N >> 2] = c[g >> 2];
c[N + 4 >> 2] = K;
K = h;
c[K >> 2] = y;
c[K + 4 >> 2] = J;
i = e;
return
}
K = O;
N = c[K + 4 >> 2] | 0;
g = j;
c[g >> 2] = c[K >> 2];
c[g + 4 >> 2] = N;
N = O;
c[N >> 2] = y;
c[N + 4 >> 2] = J;
if (!(nb[c[d >> 2] & 31](h, O) | 0)) {
i = e;
return
}
J = O;
N = c[J >> 2] | 0;
y = c[J + 4 >> 2] | 0;
J = h;
g = c[J + 4 >> 2] | 0;
K = O;
c[K >> 2] = c[J >> 2];
c[K + 4 >> 2] = g;
g = h;
c[g >> 2] = N;
c[g + 4 >> 2] = y;
i = e;
return
} else if ((n | 0) == 14) {
y = j + 8 | 0;
g = j + 16 | 0;
N = nb[c[d >> 2] & 31](y, j) | 0;
K = nb[c[d >> 2] & 31](g, y) | 0;
do if (N) {
J = j;
O = c[J >> 2] | 0;
I = c[J + 4 >> 2] | 0;
if (K) {
J = g;
H = c[J + 4 >> 2] | 0;
G = j;
c[G >> 2] = c[J >> 2];
c[G + 4 >> 2] = H;
H = g;
c[H >> 2] = O;
c[H + 4 >> 2] = I;
break
}
H = y;
G = c[H + 4 >> 2] | 0;
J = j;
c[J >> 2] = c[H >> 2];
c[J + 4 >> 2] =
G;
G = y;
c[G >> 2] = O;
c[G + 4 >> 2] = I;
if (nb[c[d >> 2] & 31](g, y) | 0) {
I = y;
G = c[I >> 2] | 0;
O = c[I + 4 >> 2] | 0;
I = g;
J = c[I + 4 >> 2] | 0;
H = y;
c[H >> 2] = c[I >> 2];
c[H + 4 >> 2] = J;
J = g;
c[J >> 2] = G;
c[J + 4 >> 2] = O
}
} else if (K ? (O = y, J = c[O >> 2] | 0, G = c[O + 4 >> 2] | 0, O = g, H = c[O + 4 >> 2] | 0, I = y, c[I >> 2] = c[O >> 2], c[I + 4 >> 2] = H, H = g, c[H >> 2] = J, c[H + 4 >> 2] = G, nb[c[d >> 2] & 31](y, j) | 0) : 0) {
G = j;
H = c[G >> 2] | 0;
J = c[G + 4 >> 2] | 0;
G = y;
I = c[G + 4 >> 2] | 0;
O = j;
c[O >> 2] = c[G >> 2];
c[O + 4 >> 2] = I;
I = y;
c[I >> 2] = H;
c[I + 4 >> 2] = J
}
while (0);
if (!(nb[c[d >> 2] & 31](h, g) | 0)) {
i = e;
return
}
K = g;
N = c[K >> 2] | 0;
J = c[K + 4 >> 2] | 0;
K = h;
I = c[K + 4 >>
2] | 0;
H = g;
c[H >> 2] = c[K >> 2];
c[H + 4 >> 2] = I;
I = h;
c[I >> 2] = N;
c[I + 4 >> 2] = J;
if (!(nb[c[d >> 2] & 31](g, y) | 0)) {
i = e;
return
}
J = y;
I = c[J >> 2] | 0;
N = c[J + 4 >> 2] | 0;
J = g;
H = c[J + 4 >> 2] | 0;
K = y;
c[K >> 2] = c[J >> 2];
c[K + 4 >> 2] = H;
H = g;
c[H >> 2] = I;
c[H + 4 >> 2] = N;
if (!(nb[c[d >> 2] & 31](y, j) | 0)) {
i = e;
return
}
N = j;
H = c[N >> 2] | 0;
I = c[N + 4 >> 2] | 0;
N = y;
g = c[N + 4 >> 2] | 0;
K = j;
c[K >> 2] = c[N >> 2];
c[K + 4 >> 2] = g;
g = y;
c[g >> 2] = H;
c[g + 4 >> 2] = I;
i = e;
return
} else if ((n | 0) == 26) {
Gl(j, j + 8 | 0, j + 16 | 0, j + 24 | 0, h, d) | 0;
i = e;
return
} else if ((n | 0) == 28) {
h = j + 16 | 0;
I = j + 8 | 0;
g = nb[c[d >> 2] & 31](I, j) | 0;
H = nb[c[d >> 2] &
31](h, I) | 0;
do if (g) {
y = j;
K = c[y >> 2] | 0;
N = c[y + 4 >> 2] | 0;
if (H) {
y = h;
J = c[y + 4 >> 2] | 0;
O = j;
c[O >> 2] = c[y >> 2];
c[O + 4 >> 2] = J;
J = h;
c[J >> 2] = K;
c[J + 4 >> 2] = N;
break
}
J = I;
O = c[J + 4 >> 2] | 0;
y = j;
c[y >> 2] = c[J >> 2];
c[y + 4 >> 2] = O;
O = I;
c[O >> 2] = K;
c[O + 4 >> 2] = N;
if (nb[c[d >> 2] & 31](h, I) | 0) {
N = I;
O = c[N >> 2] | 0;
K = c[N + 4 >> 2] | 0;
N = h;
y = c[N + 4 >> 2] | 0;
J = I;
c[J >> 2] = c[N >> 2];
c[J + 4 >> 2] = y;
y = h;
c[y >> 2] = O;
c[y + 4 >> 2] = K
}
} else if (H ? (K = I, y = c[K >> 2] | 0, O = c[K + 4 >> 2] | 0, K = h, J = c[K + 4 >> 2] | 0, N = I, c[N >> 2] = c[K >> 2], c[N + 4 >> 2] = J, J = h, c[J >> 2] = y, c[J + 4 >> 2] = O, nb[c[d >> 2] & 31](I, j) | 0) : 0) {
O = j;
J = c[O >>
2] | 0;
y = c[O + 4 >> 2] | 0;
O = I;
N = c[O + 4 >> 2] | 0;
K = j;
c[K >> 2] = c[O >> 2];
c[K + 4 >> 2] = N;
N = I;
c[N >> 2] = J;
c[N + 4 >> 2] = y
}
while (0);
I = j + 24 | 0;
if ((I | 0) == (a | 0)) {
i = e;
return
} else {
P = I;
Q = h
}
while (1) {
if (nb[c[d >> 2] & 31](P, Q) | 0) {
h = P;
I = c[h + 4 >> 2] | 0;
H = f;
c[H >> 2] = c[h >> 2];
c[H + 4 >> 2] = I;
I = P;
H = Q;
while (1) {
h = H;
g = c[h + 4 >> 2] | 0;
y = I;
c[y >> 2] = c[h >> 2];
c[y + 4 >> 2] = g;
if ((H | 0) == (j | 0))
break;
g = H + -8 | 0;
if (nb[c[d >> 2] & 31](f, g) | 0) {
y = H;
H = g;
I = y
} else
break
}
I = f;
y = c[I + 4 >> 2] | 0;
g = H;
c[g >> 2] = c[I >> 2];
c[g + 4 >> 2] = y
}
y = P + 8 | 0;
if ((y | 0) == (a | 0))
break;
else {
g = P;
P = y;
Q = g
}
}
i = e;
return
} else if ((n |
0) == 84) {
i = e;
return
}
}
function Gl(a, b, d, e, f, g) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0;
h = i;
j = nb[c[g >> 2] & 31](b, a) | 0;
k = nb[c[g >> 2] & 31](d, b) | 0;
do if (j) {
l = a;
m = c[l >> 2] | 0;
n = c[l + 4 >> 2] | 0;
if (k) {
l = d;
o = c[l + 4 >> 2] | 0;
p = a;
c[p >> 2] = c[l >> 2];
c[p + 4 >> 2] = o;
o = d;
c[o >> 2] = m;
c[o + 4 >> 2] = n;
q = 1;
break
}
o = b;
p = c[o + 4 >> 2] | 0;
l = a;
c[l >> 2] = c[o >> 2];
c[l + 4 >> 2] = p;
p = b;
c[p >> 2] = m;
c[p + 4 >> 2] = n;
if (nb[c[g >> 2] & 31](d, b) | 0) {
n = b;
p = c[n >> 2] | 0;
m = c[n + 4 >> 2] | 0;
n = d;
l = c[n + 4 >> 2] | 0;
o = b;
c[o >> 2] = c[n >> 2];
c[o + 4 >> 2] = l;
l = d;
c[l >>
2] = p;
c[l + 4 >> 2] = m;
q = 2
} else
q = 1
} else if (k) {
m = b;
l = c[m >> 2] | 0;
p = c[m + 4 >> 2] | 0;
m = d;
o = c[m + 4 >> 2] | 0;
n = b;
c[n >> 2] = c[m >> 2];
c[n + 4 >> 2] = o;
o = d;
c[o >> 2] = l;
c[o + 4 >> 2] = p;
if (nb[c[g >> 2] & 31](b, a) | 0) {
p = a;
o = c[p >> 2] | 0;
l = c[p + 4 >> 2] | 0;
p = b;
n = c[p + 4 >> 2] | 0;
m = a;
c[m >> 2] = c[p >> 2];
c[m + 4 >> 2] = n;
n = b;
c[n >> 2] = o;
c[n + 4 >> 2] = l;
q = 2
} else
q = 1
} else
q = 0;
while (0);
if (nb[c[g >> 2] & 31](e, d) | 0) {
k = d;
j = c[k >> 2] | 0;
l = c[k + 4 >> 2] | 0;
k = e;
n = c[k + 4 >> 2] | 0;
o = d;
c[o >> 2] = c[k >> 2];
c[o + 4 >> 2] = n;
n = e;
c[n >> 2] = j;
c[n + 4 >> 2] = l;
l = q + 1 | 0;
if (nb[c[g >> 2] & 31](d, b) | 0) {
n = b;
j = c[n >> 2] | 0;
o = c[n + 4 >>
2] | 0;
n = d;
k = c[n + 4 >> 2] | 0;
m = b;
c[m >> 2] = c[n >> 2];
c[m + 4 >> 2] = k;
k = d;
c[k >> 2] = j;
c[k + 4 >> 2] = o;
if (nb[c[g >> 2] & 31](b, a) | 0) {
o = a;
k = c[o >> 2] | 0;
j = c[o + 4 >> 2] | 0;
o = b;
m = c[o + 4 >> 2] | 0;
n = a;
c[n >> 2] = c[o >> 2];
c[n + 4 >> 2] = m;
m = b;
c[m >> 2] = k;
c[m + 4 >> 2] = j;
r = q + 3 | 0
} else
r = q + 2 | 0
} else
r = l
} else
r = q;
if (!(nb[c[g >> 2] & 31](f, e) | 0)) {
s = r;
i = h;
return s | 0
}
q = e;
l = c[q >> 2] | 0;
j = c[q + 4 >> 2] | 0;
q = f;
m = c[q + 4 >> 2] | 0;
k = e;
c[k >> 2] = c[q >> 2];
c[k + 4 >> 2] = m;
m = f;
c[m >> 2] = l;
c[m + 4 >> 2] = j;
if (!(nb[c[g >> 2] & 31](e, d) | 0)) {
s = r + 1 | 0;
i = h;
return s | 0
}
j = d;
m = c[j >> 2] | 0;
l = c[j + 4 >> 2] | 0;
j = e;
f = c[j + 4 >>
2] | 0;
k = d;
c[k >> 2] = c[j >> 2];
c[k + 4 >> 2] = f;
f = e;
c[f >> 2] = m;
c[f + 4 >> 2] = l;
if (!(nb[c[g >> 2] & 31](d, b) | 0)) {
s = r + 2 | 0;
i = h;
return s | 0
}
l = b;
f = c[l >> 2] | 0;
m = c[l + 4 >> 2] | 0;
l = d;
e = c[l + 4 >> 2] | 0;
k = b;
c[k >> 2] = c[l >> 2];
c[k + 4 >> 2] = e;
e = d;
c[e >> 2] = f;
c[e + 4 >> 2] = m;
if (!(nb[c[g >> 2] & 31](b, a) | 0)) {
s = r + 3 | 0;
i = h;
return s | 0
}
g = a;
m = c[g >> 2] | 0;
e = c[g + 4 >> 2] | 0;
g = b;
f = c[g + 4 >> 2] | 0;
d = a;
c[d >> 2] = c[g >> 2];
c[d + 4 >> 2] = f;
f = b;
c[f >> 2] = m;
c[f + 4 >> 2] = e;
s = r + 4 | 0;
i = h;
return s | 0
}
function Hl(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t =
0,
u = 0,
v = 0,
w = 0;
e = i;
i = i + 16 | 0;
f = e;
switch (b - a >> 3 | 0) {
case 3:
g = a + 8 | 0;
h = b + -8 | 0;
j = nb[c[d >> 2] & 31](g, a) | 0;
k = nb[c[d >> 2] & 31](h, g) | 0;
if (!j) {
if (!k) {
l = 1;
i = e;
return l | 0
}
j = g;
m = c[j >> 2] | 0;
n = c[j + 4 >> 2] | 0;
j = h;
o = c[j + 4 >> 2] | 0;
p = g;
c[p >> 2] = c[j >> 2];
c[p + 4 >> 2] = o;
o = h;
c[o >> 2] = m;
c[o + 4 >> 2] = n;
if (!(nb[c[d >> 2] & 31](g, a) | 0)) {
l = 1;
i = e;
return l | 0
}
n = a;
o = c[n >> 2] | 0;
m = c[n + 4 >> 2] | 0;
n = g;
p = c[n + 4 >> 2] | 0;
j = a;
c[j >> 2] = c[n >> 2];
c[j + 4 >> 2] = p;
p = g;
c[p >> 2] = o;
c[p + 4 >> 2] = m;
l = 1;
i = e;
return l | 0
}
m = a;
p = c[m >> 2] | 0;
o = c[m + 4 >> 2] | 0;
if (k) {
k = h;
m = c[k + 4 >> 2] | 0;
j = a;
c[j >> 2] = c[k >>
2];
c[j + 4 >> 2] = m;
m = h;
c[m >> 2] = p;
c[m + 4 >> 2] = o;
l = 1;
i = e;
return l | 0
}
m = g;
j = c[m + 4 >> 2] | 0;
k = a;
c[k >> 2] = c[m >> 2];
c[k + 4 >> 2] = j;
j = g;
c[j >> 2] = p;
c[j + 4 >> 2] = o;
if (!(nb[c[d >> 2] & 31](h, g) | 0)) {
l = 1;
i = e;
return l | 0
}
o = g;
j = c[o >> 2] | 0;
p = c[o + 4 >> 2] | 0;
o = h;
k = c[o + 4 >> 2] | 0;
m = g;
c[m >> 2] = c[o >> 2];
c[m + 4 >> 2] = k;
k = h;
c[k >> 2] = j;
c[k + 4 >> 2] = p;
l = 1;
i = e;
return l | 0;
case 4:
p = a + 8 | 0;
k = a + 16 | 0;
j = b + -8 | 0;
h = nb[c[d >> 2] & 31](p, a) | 0;
m = nb[c[d >> 2] & 31](k, p) | 0;
do if (h) {
o = a;
g = c[o >> 2] | 0;
n = c[o + 4 >> 2] | 0;
if (m) {
o = k;
q = c[o + 4 >> 2] | 0;
r = a;
c[r >> 2] = c[o >> 2];
c[r + 4 >> 2] = q;
q = k;
c[q >> 2] = g;
c[q +
4 >> 2] = n;
break
}
q = p;
r = c[q + 4 >> 2] | 0;
o = a;
c[o >> 2] = c[q >> 2];
c[o + 4 >> 2] = r;
r = p;
c[r >> 2] = g;
c[r + 4 >> 2] = n;
if (nb[c[d >> 2] & 31](k, p) | 0) {
n = p;
r = c[n >> 2] | 0;
g = c[n + 4 >> 2] | 0;
n = k;
o = c[n + 4 >> 2] | 0;
q = p;
c[q >> 2] = c[n >> 2];
c[q + 4 >> 2] = o;
o = k;
c[o >> 2] = r;
c[o + 4 >> 2] = g
}
} else if (m ? (g = p, o = c[g >> 2] | 0, r = c[g + 4 >> 2] | 0, g = k, q = c[g + 4 >> 2] | 0, n = p, c[n >> 2] = c[g >> 2], c[n + 4 >> 2] = q, q = k, c[q >> 2] = o, c[q + 4 >> 2] = r, nb[c[d >> 2] & 31](p, a) | 0) : 0) {
r = a;
q = c[r >> 2] | 0;
o = c[r + 4 >> 2] | 0;
r = p;
n = c[r + 4 >> 2] | 0;
g = a;
c[g >> 2] = c[r >> 2];
c[g + 4 >> 2] = n;
n = p;
c[n >> 2] = q;
c[n + 4 >> 2] = o
}
while (0);
if (!(nb[c[d >> 2] & 31](j,
k) | 0)) {
l = 1;
i = e;
return l | 0
}
m = k;
h = c[m >> 2] | 0;
o = c[m + 4 >> 2] | 0;
m = j;
n = c[m + 4 >> 2] | 0;
q = k;
c[q >> 2] = c[m >> 2];
c[q + 4 >> 2] = n;
n = j;
c[n >> 2] = h;
c[n + 4 >> 2] = o;
if (!(nb[c[d >> 2] & 31](k, p) | 0)) {
l = 1;
i = e;
return l | 0
}
o = p;
n = c[o >> 2] | 0;
h = c[o + 4 >> 2] | 0;
o = k;
j = c[o + 4 >> 2] | 0;
q = p;
c[q >> 2] = c[o >> 2];
c[q + 4 >> 2] = j;
j = k;
c[j >> 2] = n;
c[j + 4 >> 2] = h;
if (!(nb[c[d >> 2] & 31](p, a) | 0)) {
l = 1;
i = e;
return l | 0
}
h = a;
j = c[h >> 2] | 0;
n = c[h + 4 >> 2] | 0;
h = p;
k = c[h + 4 >> 2] | 0;
q = a;
c[q >> 2] = c[h >> 2];
c[q + 4 >> 2] = k;
k = p;
c[k >> 2] = j;
c[k + 4 >> 2] = n;
l = 1;
i = e;
return l | 0;
case 1:
case 0:
l = 1;
i = e;
return l | 0;
case 5:
Gl(a,
a + 8 | 0, a + 16 | 0, a + 24 | 0, b + -8 | 0, d) | 0;
l = 1;
i = e;
return l | 0;
case 2:
n = b + -8 | 0;
if (!(nb[c[d >> 2] & 31](n, a) | 0)) {
l = 1;
i = e;
return l | 0
}
k = a;
j = c[k >> 2] | 0;
p = c[k + 4 >> 2] | 0;
k = n;
q = c[k + 4 >> 2] | 0;
h = a;
c[h >> 2] = c[k >> 2];
c[h + 4 >> 2] = q;
q = n;
c[q >> 2] = j;
c[q + 4 >> 2] = p;
l = 1;
i = e;
return l | 0;
default:
p = a + 16 | 0;
q = a + 8 | 0;
j = nb[c[d >> 2] & 31](q, a) | 0;
n = nb[c[d >> 2] & 31](p, q) | 0;
do if (j) {
h = a;
k = c[h >> 2] | 0;
o = c[h + 4 >> 2] | 0;
if (n) {
h = p;
m = c[h + 4 >> 2] | 0;
g = a;
c[g >> 2] = c[h >> 2];
c[g + 4 >> 2] = m;
m = p;
c[m >> 2] = k;
c[m + 4 >> 2] = o;
break
}
m = q;
g = c[m + 4 >> 2] | 0;
h = a;
c[h >> 2] = c[m >> 2];
c[h + 4 >> 2] = g;
g = q;
c[g >> 2] =
k;
c[g + 4 >> 2] = o;
if (nb[c[d >> 2] & 31](p, q) | 0) {
o = q;
g = c[o >> 2] | 0;
k = c[o + 4 >> 2] | 0;
o = p;
h = c[o + 4 >> 2] | 0;
m = q;
c[m >> 2] = c[o >> 2];
c[m + 4 >> 2] = h;
h = p;
c[h >> 2] = g;
c[h + 4 >> 2] = k
}
} else if (n ? (k = q, h = c[k >> 2] | 0, g = c[k + 4 >> 2] | 0, k = p, m = c[k + 4 >> 2] | 0, o = q, c[o >> 2] = c[k >> 2], c[o + 4 >> 2] = m, m = p, c[m >> 2] = h, c[m + 4 >> 2] = g, nb[c[d >> 2] & 31](q, a) | 0) : 0) {
g = a;
m = c[g >> 2] | 0;
h = c[g + 4 >> 2] | 0;
g = q;
o = c[g + 4 >> 2] | 0;
k = a;
c[k >> 2] = c[g >> 2];
c[k + 4 >> 2] = o;
o = q;
c[o >> 2] = m;
c[o + 4 >> 2] = h
}
while (0);
q = a + 24 | 0;
if ((q | 0) == (b | 0)) {
l = 1;
i = e;
return l | 0
} else {
s = 0;
t = q;
u = p
}
while (1) {
if (nb[c[d >> 2] & 31](t, u) | 0) {
p =
t;
q = c[p + 4 >> 2] | 0;
n = f;
c[n >> 2] = c[p >> 2];
c[n + 4 >> 2] = q;
q = t;
n = u;
while (1) {
p = n;
j = c[p + 4 >> 2] | 0;
h = q;
c[h >> 2] = c[p >> 2];
c[h + 4 >> 2] = j;
if ((n | 0) == (a | 0))
break;
j = n + -8 | 0;
if (nb[c[d >> 2] & 31](f, j) | 0) {
h = n;
n = j;
q = h
} else
break
}
q = f;
h = c[q + 4 >> 2] | 0;
j = n;
c[j >> 2] = c[q >> 2];
c[j + 4 >> 2] = h;
h = s + 1 | 0;
if ((h | 0) == 8)
break;
else
v = h
} else
v = s;
h = t + 8 | 0;
if ((h | 0) == (b | 0)) {
l = 1;
w = 41;
break
} else {
j = t;
s = v;
t = h;
u = j
}
}
if ((w | 0) == 41) {
i = e;
return l | 0
}
l = (t + 8 | 0) == (b | 0);
i = e;
return l | 0
}
return 0
}
function Il(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0;
e = i;
f = a;
a = b;
a:
while (1) {
b = a;
g = a + -8 | 0;
h = a + -4 | 0;
j = f;
b:
while (1) {
k = j;
l = b - k | 0;
m = l >> 3;
switch (m | 0) {
case 2:
n = 4;
break a;
break;
case 4:
n = 14;
break a;
break;
case 3:
n = 6;
break a;
break;
case 5:
n = 15;
break a;
break;
case 1:
case 0:
n = 85;
break a;
break;
default:
}
if ((l | 0) < 248) {
n = 21;
break a
}
o = (m | 0) / 2 | 0;
p = j + (o << 3) | 0;
do if ((l | 0) > 7992) {
q = (m | 0) / 4 | 0;
r = j + (q << 3) | 0;
s = q + o | 0;
t = j + (s << 3) | 0;
u = Jl(j, r, p, t, 0) | 0;
v = j + (s <<
3) + 4 | 0;
if (!((c[h >> 2] | 0) >>> 0 < (c[v >> 2] | 0) >>> 0)) {
w = j + (o << 3) + 4 | 0;
x = u;
break
}
s = t;
y = c[s >> 2] | 0;
z = c[s + 4 >> 2] | 0;
s = g;
A = c[s + 4 >> 2] | 0;
B = t;
c[B >> 2] = c[s >> 2];
c[B + 4 >> 2] = A;
A = g;
c[A >> 2] = y;
c[A + 4 >> 2] = z;
z = j + (o << 3) + 4 | 0;
if (!((c[v >> 2] | 0) >>> 0 < (c[z >> 2] | 0) >>> 0)) {
w = z;
x = u + 1 | 0;
break
}
v = p;
A = c[v >> 2] | 0;
y = c[v + 4 >> 2] | 0;
v = t;
B = c[v + 4 >> 2] | 0;
s = p;
c[s >> 2] = c[v >> 2];
c[s + 4 >> 2] = B;
B = t;
c[B >> 2] = A;
c[B + 4 >> 2] = y;
y = j + (q << 3) + 4 | 0;
if (!((c[z >> 2] | 0) >>> 0 < (c[y >> 2] | 0) >>> 0)) {
w = z;
x = u + 2 | 0;
break
}
q = r;
B = c[q >> 2] | 0;
A = c[q + 4 >> 2] | 0;
q = p;
t = c[q + 4 >> 2] | 0;
s = r;
c[s >> 2] = c[q >> 2];
c[s + 4 >>
2] = t;
t = p;
c[t >> 2] = B;
c[t + 4 >> 2] = A;
if ((c[y >> 2] | 0) >>> 0 < (c[j + 4 >> 2] | 0) >>> 0) {
y = j;
A = c[y >> 2] | 0;
t = c[y + 4 >> 2] | 0;
y = r;
B = c[y + 4 >> 2] | 0;
s = j;
c[s >> 2] = c[y >> 2];
c[s + 4 >> 2] = B;
B = r;
c[B >> 2] = A;
c[B + 4 >> 2] = t;
w = z;
x = u + 4 | 0;
break
} else {
w = z;
x = u + 3 | 0;
break
}
} else {
u = j + (o << 3) + 4 | 0;
z = c[u >> 2] | 0;
t = j + 4 | 0;
B = (c[h >> 2] | 0) >>> 0 < z >>> 0;
if (!(z >>> 0 < (c[t >> 2] | 0) >>> 0)) {
if (!B) {
w = u;
x = 0;
break
}
z = p;
A = c[z >> 2] | 0;
r = c[z + 4 >> 2] | 0;
z = g;
s = c[z + 4 >> 2] | 0;
y = p;
c[y >> 2] = c[z >> 2];
c[y + 4 >> 2] = s;
s = g;
c[s >> 2] = A;
c[s + 4 >> 2] = r;
if (!((c[u >> 2] | 0) >>> 0 < (c[t >> 2] | 0) >>> 0)) {
w = u;
x = 1;
break
}
t = j;
r = c[t >>
2] | 0;
s = c[t + 4 >> 2] | 0;
t = p;
A = c[t + 4 >> 2] | 0;
y = j;
c[y >> 2] = c[t >> 2];
c[y + 4 >> 2] = A;
A = p;
c[A >> 2] = r;
c[A + 4 >> 2] = s;
w = u;
x = 2;
break
}
s = j;
A = c[s >> 2] | 0;
r = c[s + 4 >> 2] | 0;
if (B) {
B = g;
s = c[B + 4 >> 2] | 0;
y = j;
c[y >> 2] = c[B >> 2];
c[y + 4 >> 2] = s;
s = g;
c[s >> 2] = A;
c[s + 4 >> 2] = r;
w = u;
x = 1;
break
}
s = p;
y = c[s + 4 >> 2] | 0;
B = j;
c[B >> 2] = c[s >> 2];
c[B + 4 >> 2] = y;
y = p;
c[y >> 2] = A;
c[y + 4 >> 2] = r;
if ((c[h >> 2] | 0) >>> 0 < r >>> 0) {
y = g;
B = c[y + 4 >> 2] | 0;
s = p;
c[s >> 2] = c[y >> 2];
c[s + 4 >> 2] = B;
B = g;
c[B >> 2] = A;
c[B + 4 >> 2] = r;
w = u;
x = 2
} else {
w = u;
x = 1
}
}
while (0);
o = j + 4 | 0;
m = c[o >> 2] | 0;
l = c[w >> 2] | 0;
do if (m >>> 0 < l >>> 0) {
C = g;
D =
x
} else {
u = g;
while (1) {
r = u;
u = u + -8 | 0;
if ((j | 0) == (u | 0))
break;
if ((c[r + -4 >> 2] | 0) >>> 0 < l >>> 0) {
n = 68;
break
}
}
if ((n | 0) == 68) {
n = 0;
r = j;
B = c[r >> 2] | 0;
A = c[r + 4 >> 2] | 0;
r = u;
s = c[r + 4 >> 2] | 0;
y = j;
c[y >> 2] = c[r >> 2];
c[y + 4 >> 2] = s;
s = u;
c[s >> 2] = B;
c[s + 4 >> 2] = A;
C = u;
D = x + 1 | 0;
break
}
A = j + 8 | 0;
if (m >>> 0 < (c[h >> 2] | 0) >>> 0)
E = A;
else {
if ((A | 0) == (g | 0)) {
n = 85;
break a
} else
F = A;
while (1) {
G = F + 8 | 0;
if (m >>> 0 < (c[F + 4 >> 2] | 0) >>> 0)
break;
if ((G | 0) == (g | 0)) {
n = 85;
break a
} else
F = G
}
u = F;
A = c[u >> 2] | 0;
s = c[u + 4 >> 2] | 0;
u = g;
B = c[u + 4 >> 2] | 0;
y = F;
c[y >> 2] = c[u >> 2];
c[y + 4 >> 2] = B;
B = g;
c[B >> 2] = A;
c[B + 4 >> 2] = s;
E = G
}
if ((E | 0) == (g | 0)) {
n = 85;
break a
} else {
H = E;
I = g
}
while (1) {
s = c[o >> 2] | 0;
B = H;
while (1) {
J = B + 8 | 0;
if (s >>> 0 < (c[B + 4 >> 2] | 0) >>> 0) {
K = I;
break
} else
B = J
}
do {
A = K;
K = K + -8 | 0
} while (s >>> 0 < (c[A + -4 >> 2] | 0) >>> 0);
if (!(B >>> 0 < K >>> 0)) {
j = B;
continue b
}
s = B;
A = c[s >> 2] | 0;
y = c[s + 4 >> 2] | 0;
s = K;
u = c[s + 4 >> 2] | 0;
r = B;
c[r >> 2] = c[s >> 2];
c[r + 4 >> 2] = u;
u = K;
c[u >> 2] = A;
c[u + 4 >> 2] = y;
H = J;
I = K
}
}
while (0);
o = j + 8 | 0;
c:
do if (o >>> 0 < C >>> 0) {
m = o;
l = C;
y = p;
u = D;
while (1) {
A = c[y + 4 >> 2] | 0;
r = m;
while (1) {
L = r + 8 | 0;
if ((c[r + 4 >> 2] | 0) >>> 0 < A >>> 0)
r = L;
else {
M = l;
break
}
}
do {
B = M;
M = M +
-8 | 0
} while (!((c[B + -4 >> 2] | 0) >>> 0 < A >>> 0));
if (r >>> 0 > M >>> 0) {
N = r;
O = y;
P = u;
break c
}
A = r;
B = c[A >> 2] | 0;
s = c[A + 4 >> 2] | 0;
A = M;
t = c[A + 4 >> 2] | 0;
z = r;
c[z >> 2] = c[A >> 2];
c[z + 4 >> 2] = t;
t = M;
c[t >> 2] = B;
c[t + 4 >> 2] = s;
m = L;
l = M;
y = (y | 0) == (r | 0) ? M : y;
u = u + 1 | 0
}
} else {
N = o;
O = p;
P = D
}
while (0);
if ((N | 0) != (O | 0) ? (c[O + 4 >> 2] | 0) >>> 0 < (c[N + 4 >> 2] | 0) >>> 0 : 0) {
p = N;
o = c[p >> 2] | 0;
u = c[p + 4 >> 2] | 0;
p = O;
y = c[p + 4 >> 2] | 0;
l = N;
c[l >> 2] = c[p >> 2];
c[l + 4 >> 2] = y;
y = O;
c[y >> 2] = o;
c[y + 4 >> 2] = u;
Q = P + 1 | 0
} else
Q = P;
if ((Q | 0) == 0) {
R = Kl(j, N, 0) | 0;
u = N + 8 | 0;
if (Kl(u, a, 0) | 0) {
n = 80;
break
}
if (R) {
j = u;
continue
}
}
u =
N;
if ((u - k | 0) >= (b - u | 0)) {
n = 84;
break
}
Il(j, N, d);
j = N + 8 | 0
}
if ((n | 0) == 80) {
n = 0;
if (R) {
n = 85;
break
} else {
f = j;
a = N;
continue
}
} else if ((n | 0) == 84) {
n = 0;
Il(N + 8 | 0, a, d);
f = j;
a = N;
continue
}
}
if ((n | 0) == 4) {
if (!((c[h >> 2] | 0) >>> 0 < (c[j + 4 >> 2] | 0) >>> 0)) {
i = e;
return
}
N = j;
f = c[N >> 2] | 0;
d = c[N + 4 >> 2] | 0;
N = g;
R = c[N + 4 >> 2] | 0;
Q = j;
c[Q >> 2] = c[N >> 2];
c[Q + 4 >> 2] = R;
R = g;
c[R >> 2] = f;
c[R + 4 >> 2] = d;
i = e;
return
} else if ((n | 0) == 6) {
d = j + 8 | 0;
R = j + 12 | 0;
f = c[R >> 2] | 0;
Q = j + 4 | 0;
N = (c[h >> 2] | 0) >>> 0 < f >>> 0;
if (!(f >>> 0 < (c[Q >> 2] | 0) >>> 0)) {
if (!N) {
i = e;
return
}
f = d;
P = c[f >> 2] | 0;
O = c[f + 4 >> 2] |
0;
f = g;
D = c[f + 4 >> 2] | 0;
M = d;
c[M >> 2] = c[f >> 2];
c[M + 4 >> 2] = D;
D = g;
c[D >> 2] = P;
c[D + 4 >> 2] = O;
if (!((c[R >> 2] | 0) >>> 0 < (c[Q >> 2] | 0) >>> 0)) {
i = e;
return
}
Q = j;
R = c[Q >> 2] | 0;
O = c[Q + 4 >> 2] | 0;
Q = d;
D = c[Q + 4 >> 2] | 0;
P = j;
c[P >> 2] = c[Q >> 2];
c[P + 4 >> 2] = D;
D = d;
c[D >> 2] = R;
c[D + 4 >> 2] = O;
i = e;
return
}
O = j;
D = c[O >> 2] | 0;
R = c[O + 4 >> 2] | 0;
if (N) {
N = g;
O = c[N + 4 >> 2] | 0;
P = j;
c[P >> 2] = c[N >> 2];
c[P + 4 >> 2] = O;
O = g;
c[O >> 2] = D;
c[O + 4 >> 2] = R;
i = e;
return
}
O = d;
P = c[O + 4 >> 2] | 0;
N = j;
c[N >> 2] = c[O >> 2];
c[N + 4 >> 2] = P;
P = d;
c[P >> 2] = D;
c[P + 4 >> 2] = R;
if (!((c[h >> 2] | 0) >>> 0 < R >>> 0)) {
i = e;
return
}
P = g;
N = c[P + 4 >> 2] | 0;
O = d;
c[O >> 2] = c[P >> 2];
c[O + 4 >> 2] = N;
N = g;
c[N >> 2] = D;
c[N + 4 >> 2] = R;
i = e;
return
} else if ((n | 0) == 14) {
Jl(j, j + 8 | 0, j + 16 | 0, g, 0) | 0;
i = e;
return
} else if ((n | 0) == 15) {
R = j + 8 | 0;
N = j + 16 | 0;
D = j + 24 | 0;
Jl(j, R, N, D, 0) | 0;
O = j + 28 | 0;
if (!((c[h >> 2] | 0) >>> 0 < (c[O >> 2] | 0) >>> 0)) {
i = e;
return
}
h = D;
P = c[h >> 2] | 0;
d = c[h + 4 >> 2] | 0;
h = g;
Q = c[h + 4 >> 2] | 0;
M = D;
c[M >> 2] = c[h >> 2];
c[M + 4 >> 2] = Q;
Q = g;
c[Q >> 2] = P;
c[Q + 4 >> 2] = d;
if (!((c[O >> 2] | 0) >>> 0 < (c[j + 20 >> 2] | 0) >>> 0)) {
i = e;
return
}
O = N;
d = c[O >> 2] | 0;
Q = c[O + 4 >> 2] | 0;
O = D;
P = c[O >> 2] | 0;
g = c[O + 4 >> 2] | 0;
O = N;
c[O >> 2] = P;
c[O + 4 >> 2] = g;
O = D;
c[O >> 2] =
d;
c[O + 4 >> 2] = Q;
if (!(g >>> 0 < (c[j + 12 >> 2] | 0) >>> 0)) {
i = e;
return
}
Q = R;
O = c[Q >> 2] | 0;
d = c[Q + 4 >> 2] | 0;
Q = R;
c[Q >> 2] = P;
c[Q + 4 >> 2] = g;
Q = N;
c[Q >> 2] = O;
c[Q + 4 >> 2] = d;
if (!(g >>> 0 < (c[j + 4 >> 2] | 0) >>> 0)) {
i = e;
return
}
d = j;
Q = c[d >> 2] | 0;
O = c[d + 4 >> 2] | 0;
d = j;
c[d >> 2] = P;
c[d + 4 >> 2] = g;
g = R;
c[g >> 2] = Q;
c[g + 4 >> 2] = O;
i = e;
return
} else if ((n | 0) == 21) {
O = j + 16 | 0;
g = j + 8 | 0;
Q = c[j + 12 >> 2] | 0;
R = c[j + 4 >> 2] | 0;
d = c[j + 20 >> 2] | 0;
P = d >>> 0 < Q >>> 0;
do if (Q >>> 0 < R >>> 0) {
N = j;
D = c[N >> 2] | 0;
M = c[N + 4 >> 2] | 0;
if (P) {
N = O;
h = c[N + 4 >> 2] | 0;
f = j;
c[f >> 2] = c[N >> 2];
c[f + 4 >> 2] = h;
h = O;
c[h >> 2] = D;
c[h + 4 >> 2] = M;
break
}
h =
g;
f = c[h + 4 >> 2] | 0;
N = j;
c[N >> 2] = c[h >> 2];
c[N + 4 >> 2] = f;
f = g;
c[f >> 2] = D;
c[f + 4 >> 2] = M;
if (d >>> 0 < M >>> 0) {
f = O;
N = c[f + 4 >> 2] | 0;
h = g;
c[h >> 2] = c[f >> 2];
c[h + 4 >> 2] = N;
N = O;
c[N >> 2] = D;
c[N + 4 >> 2] = M
}
} else if (P ? (M = g, N = c[M >> 2] | 0, D = c[M + 4 >> 2] | 0, M = O, h = c[M >> 2] | 0, f = c[M + 4 >> 2] | 0, M = g, c[M >> 2] = h, c[M + 4 >> 2] = f, M = O, c[M >> 2] = N, c[M + 4 >> 2] = D, f >>> 0 < R >>> 0) : 0) {
D = j;
M = c[D >> 2] | 0;
N = c[D + 4 >> 2] | 0;
D = j;
c[D >> 2] = h;
c[D + 4 >> 2] = f;
f = g;
c[f >> 2] = M;
c[f + 4 >> 2] = N
}
while (0);
g = j + 24 | 0;
if ((g | 0) == (a | 0)) {
i = e;
return
} else {
S = g;
T = O
}
while (1) {
if ((c[S + 4 >> 2] | 0) >>> 0 < (c[T + 4 >> 2] | 0) >>> 0) {
O = S;
g =
c[O >> 2] | 0;
R = c[O + 4 >> 2] | 0;
O = S;
P = T;
while (1) {
d = P;
Q = c[d + 4 >> 2] | 0;
N = O;
c[N >> 2] = c[d >> 2];
c[N + 4 >> 2] = Q;
if ((P | 0) == (j | 0))
break;
if (R >>> 0 < (c[P + -4 >> 2] | 0) >>> 0) {
Q = P;
P = P + -8 | 0;
O = Q
} else
break
}
O = P;
c[O >> 2] = g;
c[O + 4 >> 2] = R
}
O = S + 8 | 0;
if ((O | 0) == (a | 0))
break;
else {
Q = S;
S = O;
T = Q
}
}
i = e;
return
} else if ((n | 0) == 85) {
i = e;
return
}
}
function Jl(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0;
f = i;
g = b + 4 | 0;
h = c[g >> 2] | 0;
j = a + 4 | 0;
k = d + 4 | 0;
l = c[k >> 2] | 0;
m = l >>> 0 < h >>> 0;
do if (h >>> 0 < (c[j >> 2] | 0) >>> 0) {
n = a;
o = c[n >> 2] | 0;
p = c[n + 4 >> 2] | 0;
if (m) {
n = d;
q = c[n + 4 >> 2] | 0;
r = a;
c[r >> 2] = c[n >> 2];
c[r + 4 >> 2] = q;
q = d;
c[q >> 2] = o;
c[q + 4 >> 2] = p;
s = 1;
t = p;
break
}
q = b;
r = c[q + 4 >> 2] | 0;
n = a;
c[n >> 2] = c[q >> 2];
c[n + 4 >> 2] = r;
r = b;
c[r >> 2] = o;
c[r + 4 >> 2] = p;
r = c[k >> 2] | 0;
if (r >>> 0 < p >>> 0) {
n = d;
q = c[n + 4 >> 2] | 0;
u = b;
c[u >> 2] = c[n >> 2];
c[u + 4 >> 2] = q;
q = d;
c[q >> 2] = o;
c[q + 4 >> 2] = p;
s = 2;
t = p
} else {
s = 1;
t = r
}
} else if (m) {
r = b;
p = c[r >> 2] | 0;
q = c[r + 4 >> 2] | 0;
r = d;
o = c[r + 4 >> 2] | 0;
u = b;
c[u >> 2] = c[r >> 2];
c[u + 4 >> 2] = o;
o = d;
c[o >> 2] = p;
c[o + 4 >> 2] = q;
if ((c[g >> 2] | 0) >>> 0 < (c[j >> 2] | 0) >>> 0) {
o = a;
p = c[o >> 2] | 0;
u = c[o + 4 >>
2] | 0;
o = b;
r = c[o + 4 >> 2] | 0;
n = a;
c[n >> 2] = c[o >> 2];
c[n + 4 >> 2] = r;
r = b;
c[r >> 2] = p;
c[r + 4 >> 2] = u;
s = 2;
t = c[k >> 2] | 0
} else {
s = 1;
t = q
}
} else {
s = 0;
t = l
}
while (0);
if (!((c[e + 4 >> 2] | 0) >>> 0 < t >>> 0)) {
v = s;
i = f;
return v | 0
}
t = d;
l = c[t >> 2] | 0;
m = c[t + 4 >> 2] | 0;
t = e;
h = c[t + 4 >> 2] | 0;
q = d;
c[q >> 2] = c[t >> 2];
c[q + 4 >> 2] = h;
h = e;
c[h >> 2] = l;
c[h + 4 >> 2] = m;
if (!((c[k >> 2] | 0) >>> 0 < (c[g >> 2] | 0) >>> 0)) {
v = s + 1 | 0;
i = f;
return v | 0
}
k = b;
m = c[k >> 2] | 0;
h = c[k + 4 >> 2] | 0;
k = d;
l = c[k + 4 >> 2] | 0;
e = b;
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = l;
l = d;
c[l >> 2] = m;
c[l + 4 >> 2] = h;
if (!((c[g >> 2] | 0) >>> 0 < (c[j >> 2] | 0) >>> 0)) {
v = s + 2 |
0;
i = f;
return v | 0
}
j = a;
g = c[j >> 2] | 0;
h = c[j + 4 >> 2] | 0;
j = b;
l = c[j + 4 >> 2] | 0;
m = a;
c[m >> 2] = c[j >> 2];
c[m + 4 >> 2] = l;
l = b;
c[l >> 2] = g;
c[l + 4 >> 2] = h;
v = s + 3 | 0;
i = f;
return v | 0
}
function Kl(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0;
d = i;
switch (b - a >> 3 | 0) {
case 5:
e = a + 8 | 0;
f = a + 16 | 0;
g = a + 24 | 0;
Jl(a, e, f, g, 0) | 0;
h = a + 28 | 0;
if (!((c[b + -4 >> 2] | 0) >>> 0 < (c[h >> 2] | 0) >>> 0)) {
j = 1;
i = d;
return j | 0
}
k = b + -8 | 0;
l = g;
m = c[l >> 2] | 0;
n = c[l + 4 >> 2] | 0;
l = k;
o = c[l + 4 >> 2] | 0;
p = g;
c[p >> 2] = c[l >> 2];
c[p + 4 >> 2] = o;
o = k;
c[o >> 2] = m;
c[o +
4 >> 2] = n;
if (!((c[h >> 2] | 0) >>> 0 < (c[a + 20 >> 2] | 0) >>> 0)) {
j = 1;
i = d;
return j | 0
}
h = f;
n = c[h >> 2] | 0;
o = c[h + 4 >> 2] | 0;
h = g;
m = c[h >> 2] | 0;
k = c[h + 4 >> 2] | 0;
h = f;
c[h >> 2] = m;
c[h + 4 >> 2] = k;
h = g;
c[h >> 2] = n;
c[h + 4 >> 2] = o;
if (!(k >>> 0 < (c[a + 12 >> 2] | 0) >>> 0)) {
j = 1;
i = d;
return j | 0
}
o = e;
h = c[o >> 2] | 0;
n = c[o + 4 >> 2] | 0;
o = e;
c[o >> 2] = m;
c[o + 4 >> 2] = k;
o = f;
c[o >> 2] = h;
c[o + 4 >> 2] = n;
if (!(k >>> 0 < (c[a + 4 >> 2] | 0) >>> 0)) {
j = 1;
i = d;
return j | 0
}
n = a;
o = c[n >> 2] | 0;
h = c[n + 4 >> 2] | 0;
n = a;
c[n >> 2] = m;
c[n + 4 >> 2] = k;
k = e;
c[k >> 2] = o;
c[k + 4 >> 2] = h;
j = 1;
i = d;
return j | 0;
case 4:
Jl(a, a + 8 | 0, a + 16 | 0, b + -8 | 0, 0) | 0;
j = 1;
i = d;
return j | 0;
case 1:
case 0:
j = 1;
i = d;
return j | 0;
case 3:
h = a + 8 | 0;
k = b + -8 | 0;
o = a + 12 | 0;
e = c[o >> 2] | 0;
n = a + 4 | 0;
m = b + -4 | 0;
f = (c[m >> 2] | 0) >>> 0 < e >>> 0;
if (!(e >>> 0 < (c[n >> 2] | 0) >>> 0)) {
if (!f) {
j = 1;
i = d;
return j | 0
}
e = h;
g = c[e >> 2] | 0;
p = c[e + 4 >> 2] | 0;
e = k;
l = c[e + 4 >> 2] | 0;
q = h;
c[q >> 2] = c[e >> 2];
c[q + 4 >> 2] = l;
l = k;
c[l >> 2] = g;
c[l + 4 >> 2] = p;
if (!((c[o >> 2] | 0) >>> 0 < (c[n >> 2] | 0) >>> 0)) {
j = 1;
i = d;
return j | 0
}
n = a;
o = c[n >> 2] | 0;
p = c[n + 4 >> 2] | 0;
n = h;
l = c[n + 4 >> 2] | 0;
g = a;
c[g >> 2] = c[n >> 2];
c[g + 4 >> 2] = l;
l = h;
c[l >> 2] = o;
c[l + 4 >> 2] = p;
j = 1;
i = d;
return j | 0
}
p = a;
l = c[p >> 2] | 0;
o = c[p +
4 >> 2] | 0;
if (f) {
f = k;
p = c[f + 4 >> 2] | 0;
g = a;
c[g >> 2] = c[f >> 2];
c[g + 4 >> 2] = p;
p = k;
c[p >> 2] = l;
c[p + 4 >> 2] = o;
j = 1;
i = d;
return j | 0
}
p = h;
g = c[p + 4 >> 2] | 0;
f = a;
c[f >> 2] = c[p >> 2];
c[f + 4 >> 2] = g;
g = h;
c[g >> 2] = l;
c[g + 4 >> 2] = o;
if (!((c[m >> 2] | 0) >>> 0 < o >>> 0)) {
j = 1;
i = d;
return j | 0
}
m = k;
g = c[m + 4 >> 2] | 0;
f = h;
c[f >> 2] = c[m >> 2];
c[f + 4 >> 2] = g;
g = k;
c[g >> 2] = l;
c[g + 4 >> 2] = o;
j = 1;
i = d;
return j | 0;
case 2:
if (!((c[b + -4 >> 2] | 0) >>> 0 < (c[a + 4 >> 2] | 0) >>> 0)) {
j = 1;
i = d;
return j | 0
}
o = b + -8 | 0;
g = a;
l = c[g >> 2] | 0;
k = c[g + 4 >> 2] | 0;
g = o;
f = c[g + 4 >> 2] | 0;
m = a;
c[m >> 2] = c[g >> 2];
c[m + 4 >> 2] = f;
f = o;
c[f >> 2] = l;
c[f + 4 >> 2] = k;
j = 1;
i = d;
return j | 0;
default:
k = a + 16 | 0;
f = a + 8 | 0;
l = c[a + 12 >> 2] | 0;
o = c[a + 4 >> 2] | 0;
m = c[a + 20 >> 2] | 0;
g = m >>> 0 < l >>> 0;
do if (l >>> 0 < o >>> 0) {
h = a;
p = c[h >> 2] | 0;
n = c[h + 4 >> 2] | 0;
if (g) {
h = k;
q = c[h + 4 >> 2] | 0;
e = a;
c[e >> 2] = c[h >> 2];
c[e + 4 >> 2] = q;
q = k;
c[q >> 2] = p;
c[q + 4 >> 2] = n;
break
}
q = f;
e = c[q + 4 >> 2] | 0;
h = a;
c[h >> 2] = c[q >> 2];
c[h + 4 >> 2] = e;
e = f;
c[e >> 2] = p;
c[e + 4 >> 2] = n;
if (m >>> 0 < n >>> 0) {
e = k;
h = c[e + 4 >> 2] | 0;
q = f;
c[q >> 2] = c[e >> 2];
c[q + 4 >> 2] = h;
h = k;
c[h >> 2] = p;
c[h + 4 >> 2] = n
}
} else if (g ? (n = f, h = c[n >> 2] | 0, p = c[n + 4 >> 2] | 0, n = k, q = c[n >> 2] | 0, e = c[n + 4 >> 2] | 0, n = f, c[n >> 2] =
q, c[n + 4 >> 2] = e, n = k, c[n >> 2] = h, c[n + 4 >> 2] = p, e >>> 0 < o >>> 0) : 0) {
p = a;
n = c[p >> 2] | 0;
h = c[p + 4 >> 2] | 0;
p = a;
c[p >> 2] = q;
c[p + 4 >> 2] = e;
e = f;
c[e >> 2] = n;
c[e + 4 >> 2] = h
}
while (0);
f = a + 24 | 0;
if ((f | 0) == (b | 0)) {
j = 1;
i = d;
return j | 0
} else {
r = 0;
s = f;
t = k
}
while (1) {
if ((c[s + 4 >> 2] | 0) >>> 0 < (c[t + 4 >> 2] | 0) >>> 0) {
k = s;
f = c[k >> 2] | 0;
o = c[k + 4 >> 2] | 0;
k = s;
g = t;
while (1) {
m = g;
l = c[m + 4 >> 2] | 0;
h = k;
c[h >> 2] = c[m >> 2];
c[h + 4 >> 2] = l;
if ((g | 0) == (a | 0))
break;
if (o >>> 0 < (c[g + -4 >> 2] | 0) >>> 0) {
l = g;
g = g + -8 | 0;
k = l
} else
break
}
k = g;
c[k >> 2] = f;
c[k + 4 >> 2] = o;
k = r + 1 | 0;
if ((k | 0) == 8)
break;
else
u = k
} else
u =
r;
k = s + 8 | 0;
if ((k | 0) == (b | 0)) {
j = 1;
v = 34;
break
} else {
l = s;
r = u;
s = k;
t = l
}
}
if ((v | 0) == 34) {
i = d;
return j | 0
}
j = (s + 8 | 0) == (b | 0);
i = d;
return j | 0
}
return 0
}
function Ll(a, b, d, e, f, g) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0;
h = i;
i = i + 64 | 0;
j = h;
if ((e | 0) == 2) {
k = b + -60 | 0;
if (!(nb[c[d >> 2] & 31](k, a) | 0)) {
i = h;
return
}
l = j + 0 | 0;
m = a + 0 | 0;
n = l + 60 | 0;
do {
c[l >> 2] = c[m >> 2];
l = l + 4 | 0;
m = m + 4 | 0
} while ((l | 0) < (n | 0));
l = a + 0 | 0;
m = k + 0 | 0;
n = l + 60 | 0;
do {
c[l >> 2] = c[m >> 2];
l = l + 4 | 0;
m = m + 4 | 0
} while ((l | 0) < (n |
0));
l = k + 0 | 0;
m = j + 0 | 0;
n = l + 60 | 0;
do {
c[l >> 2] = c[m >> 2];
l = l + 4 | 0;
m = m + 4 | 0
} while ((l | 0) < (n | 0));
i = h;
return
} else if ((e | 0) == 1 | (e | 0) == 0) {
i = h;
return
} else {
if ((e | 0) < 129) {
if ((a | 0) == (b | 0)) {
i = h;
return
}
k = a + 60 | 0;
if ((k | 0) == (b | 0)) {
i = h;
return
}
o = k;
do {
l = j + 0 | 0;
m = o + 0 | 0;
n = l + 60 | 0;
do {
c[l >> 2] = c[m >> 2];
l = l + 4 | 0;
m = m + 4 | 0
} while ((l | 0) < (n | 0));
a:
do if ((o | 0) == (a | 0))
p = a;
else {
k = o;
while (1) {
q = k;
k = k + -60 | 0;
if (!(nb[c[d >> 2] & 31](j, k) | 0)) {
p = q;
break a
}
l = q + 0 | 0;
m = k + 0 | 0;
n = l + 60 | 0;
do {
c[l >> 2] = c[m >> 2];
l = l + 4 | 0;
m = m + 4 | 0
} while ((l | 0) < (n | 0));
if ((k | 0) == (a | 0)) {
p = a;
break
}
}
}
while (0);
l = p + 0 | 0;
m = j + 0 | 0;
n = l + 60 | 0;
do {
c[l >> 2] = c[m >> 2];
l = l + 4 | 0;
m = m + 4 | 0
} while ((l | 0) < (n | 0));
o = o + 60 | 0
} while ((o | 0) != (b | 0));
i = h;
return
}
o = (e | 0) / 2 | 0;
j = a + (o * 60 | 0) | 0;
if ((e | 0) > (g | 0)) {
Ll(a, j, d, o, f, g);
p = e - o | 0;
Ll(j, b, d, p, f, g);
Nl(a, j, b, d, o, p, f, g);
i = h;
return
}
Ml(a, j, d, o, f);
g = f + (o * 60 | 0) | 0;
Ml(j, b, d, e - o | 0, g);
o = f + (e * 60 | 0) | 0;
b:
do if ((e + 1 | 0) >>> 0 < 3) {
r = a;
s = g
} else {
b = a;
j = f;
p = g;
while (1) {
if ((p | 0) == (o | 0))
break;
if (nb[c[d >> 2] & 31](p, j) | 0) {
l = b + 0 | 0;
m = p + 0 | 0;
n = l + 60 | 0;
do {
c[l >> 2] = c[m >> 2];
l = l + 4 | 0;
m = m + 4 | 0
} while ((l | 0) < (n | 0));
t = p + 60 | 0;
u = j
} else {
l = b +
0 | 0;
m = j + 0 | 0;
n = l + 60 | 0;
do {
c[l >> 2] = c[m >> 2];
l = l + 4 | 0;
m = m + 4 | 0
} while ((l | 0) < (n | 0));
t = p;
u = j + 60 | 0
}
k = b + 60 | 0;
if ((u | 0) == (g | 0)) {
r = k;
s = t;
break b
} else {
b = k;
j = u;
p = t
}
}
if ((j | 0) == (g | 0)) {
i = h;
return
} else {
v = j;
w = b
}
while (1) {
l = w + 0 | 0;
m = v + 0 | 0;
n = l + 60 | 0;
do {
c[l >> 2] = c[m >> 2];
l = l + 4 | 0;
m = m + 4 | 0
} while ((l | 0) < (n | 0));
v = v + 60 | 0;
if ((v | 0) == (g | 0))
break;
else
w = w + 60 | 0
}
i = h;
return
}
while (0);
if ((s | 0) == (o | 0)) {
i = h;
return
} else {
x = r;
y = s
}
while (1) {
l = x + 0 | 0;
m = y + 0 | 0;
n = l + 60 | 0;
do {
c[l >> 2] = c[m >> 2];
l = l + 4 | 0;
m = m + 4 | 0
} while ((l | 0) < (n | 0));
y = y + 60 | 0;
if ((y | 0) == (o | 0))
break;
else
x = x + 60 | 0
}
i = h;
return
}
}
function Ml(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0;
g = i;
if ((e | 0) == 1) {
if ((f | 0) == 0) {
i = g;
return
}
h = f + 0 | 0;
j = a + 0 | 0;
k = h + 60 | 0;
do {
c[h >> 2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h | 0) < (k | 0));
i = g;
return
} else if ((e | 0) == 2) {
l = b + -60 | 0;
m = (f | 0) == 0;
if (nb[c[d >> 2] & 31](l, a) | 0) {
if (!m) {
h = f + 0 | 0;
j = l + 0 | 0;
k = h + 60 | 0;
do {
c[h >> 2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h | 0) < (k | 0))
}
h = f + 60 | 0;
j = a + 0 | 0;
k = h + 60 | 0;
do {
c[h >> 2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h |
0) < (k | 0));
i = g;
return
} else {
if (!m) {
h = f + 0 | 0;
j = a + 0 | 0;
k = h + 60 | 0;
do {
c[h >> 2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h | 0) < (k | 0))
}
h = f + 60 | 0;
j = l + 0 | 0;
k = h + 60 | 0;
do {
c[h >> 2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h | 0) < (k | 0));
i = g;
return
}
} else if ((e | 0) == 0) {
i = g;
return
} else {
if ((e | 0) < 9) {
if ((a | 0) == (b | 0)) {
i = g;
return
}
if ((f | 0) == 0)
n = 0;
else {
h = f + 0 | 0;
j = a + 0 | 0;
k = h + 60 | 0;
do {
c[h >> 2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h | 0) < (k | 0));
n = f
}
l = a + 60 | 0;
if ((l | 0) == (b | 0)) {
i = g;
return
} else {
o = l;
p = n
}
do {
n = p;
p = p + 60 | 0;
if (nb[c[d >> 2] & 31](o, n) | 0) {
h = p + 0 | 0;
j = n + 0 | 0;
k = h + 60 | 0;
do {
c[h >>
2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h | 0) < (k | 0));
a:
do if ((n | 0) == (f | 0))
q = f;
else {
l = n;
while (1) {
m = l;
l = l + -60 | 0;
if (!(nb[c[d >> 2] & 31](o, l) | 0)) {
q = m;
break a
}
h = m + 0 | 0;
j = l + 0 | 0;
k = h + 60 | 0;
do {
c[h >> 2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h | 0) < (k | 0));
if ((l | 0) == (f | 0)) {
q = f;
break
}
}
}
while (0);
h = q + 0 | 0;
j = o + 0 | 0;
k = h + 60 | 0;
do {
c[h >> 2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h | 0) < (k | 0))
} else {
h = p + 0 | 0;
j = o + 0 | 0;
k = h + 60 | 0;
do {
c[h >> 2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h | 0) < (k | 0))
}
o = o + 60 | 0
} while ((o | 0) != (b | 0));
i = g;
return
}
o = (e | 0) / 2 | 0;
p = a + (o * 60 | 0) | 0;
Ll(a, p, d, o,
f, o);
q = e - o | 0;
Ll(p, b, d, q, f + (o * 60 | 0) | 0, q);
b:
do if ((e + 1 | 0) >>> 0 < 3) {
r = p;
s = f
} else {
q = p;
o = a;
n = f;
while (1) {
if ((q | 0) == (b | 0))
break;
l = (n | 0) == 0;
if (nb[c[d >> 2] & 31](q, o) | 0) {
if (!l) {
h = n + 0 | 0;
j = q + 0 | 0;
k = h + 60 | 0;
do {
c[h >> 2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h | 0) < (k | 0))
}
t = o;
u = q + 60 | 0
} else {
if (!l) {
h = n + 0 | 0;
j = o + 0 | 0;
k = h + 60 | 0;
do {
c[h >> 2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h | 0) < (k | 0))
}
t = o + 60 | 0;
u = q
}
l = n + 60 | 0;
if ((t | 0) == (p | 0)) {
r = u;
s = l;
break b
} else {
q = u;
o = t;
n = l
}
}
if ((o | 0) == (p | 0)) {
i = g;
return
} else {
v = o;
w = n
}
while (1) {
if ((w | 0) != 0) {
h = w + 0 | 0;
j = v + 0 | 0;
k = h +
60 | 0;
do {
c[h >> 2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h | 0) < (k | 0))
}
v = v + 60 | 0;
if ((v | 0) == (p | 0))
break;
else
w = w + 60 | 0
}
i = g;
return
}
while (0);
if ((r | 0) == (b | 0)) {
i = g;
return
} else {
x = r;
y = s
}
while (1) {
if ((y | 0) != 0) {
h = y + 0 | 0;
j = x + 0 | 0;
k = h + 60 | 0;
do {
c[h >> 2] = c[j >> 2];
h = h + 4 | 0;
j = j + 4 | 0
} while ((h | 0) < (k | 0))
}
x = x + 60 | 0;
if ((x | 0) == (b | 0))
break;
else
y = y + 60 | 0
}
i = g;
return
}
}
function Nl(a, b, d, e, f, g, h, j) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
h = h | 0;
j = j | 0;
var k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I =
0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0;
k = i;
i = i + 64 | 0;
l = k;
if ((g | 0) == 0) {
i = k;
return
}
m = a;
a = b;
b = d;
d = f;
f = g;
a:
while (1) {
g = b;
n = a;
o = d;
p = m;
q = f;
while (1) {
if ((o | 0) == 0) {
r = 45;
break a
} else {
s = p;
t = o
}
while (1) {
if (nb[c[e >> 2] & 31](n, s) | 0)
break;
u = t + -1 | 0;
if ((u | 0) == 0) {
r = 45;
break a
} else {
s = s + 60 | 0;
t = u
}
}
if (!((t | 0) > (j | 0) & (q | 0) > (j | 0))) {
r = 8;
break a
}
if ((t | 0) < (q | 0)) {
u = (q | 0) / 2 | 0;
v = n + (u * 60 | 0) | 0;
w = s;
x = s;
y = (n - w | 0) / 60 | 0;
b:
while (1) {
z = y;
while (1) {
if ((z | 0) == 0)
break b;
A = (z | 0) / 2 | 0;
if (nb[c[e >> 2] & 31](v, x + (A * 60 | 0) | 0) | 0)
z = A;
else
break
}
x =
x + ((A + 1 | 0) * 60 | 0) | 0;
y = z + -1 - A | 0
}
B = x;
C = v;
D = (x - w | 0) / 60 | 0;
E = u
} else {
if ((t | 0) == 1) {
r = 17;
break a
}
y = (t | 0) / 2 | 0;
F = s + (y * 60 | 0) | 0;
G = n;
H = n;
I = (g - G | 0) / 60 | 0;
c:
while (1) {
J = I;
while (1) {
if ((J | 0) == 0)
break c;
K = (J | 0) / 2 | 0;
if (nb[c[e >> 2] & 31](H + (K * 60 | 0) | 0, F) | 0)
break;
else
J = K
}
H = H + ((K + 1 | 0) * 60 | 0) | 0;
I = J + -1 - K | 0
}
B = F;
C = H;
D = y;
E = (H - G | 0) / 60 | 0
}
o = t - D | 0;
L = q - E | 0;
d:
do if ((B | 0) != (n | 0))
if ((n | 0) == (C | 0))
M = B;
else {
if ((B + 60 | 0) == (n | 0)) {
N = l + 0 | 0;
O = B + 0 | 0;
P = N + 60 | 0;
do {
c[N >> 2] = c[O >> 2];
N = N + 4 | 0;
O = O + 4 | 0
} while ((N | 0) < (P | 0));
J = C - n | 0;
Bn(B | 0, n | 0, J | 0) | 0;
I = B + (((J | 0) /
60 | 0) * 60 | 0) | 0;
N = I + 0 | 0;
O = l + 0 | 0;
P = N + 60 | 0;
do {
c[N >> 2] = c[O >> 2];
N = N + 4 | 0;
O = O + 4 | 0
} while ((N | 0) < (P | 0));
M = I;
break
}
if ((n + 60 | 0) == (C | 0)) {
J = C + -60 | 0;
N = l + 0 | 0;
O = J + 0 | 0;
P = N + 60 | 0;
do {
c[N >> 2] = c[O >> 2];
N = N + 4 | 0;
O = O + 4 | 0
} while ((N | 0) < (P | 0));
I = J - B | 0;
u = C + (((I | 0) / -60 | 0) * 60 | 0) | 0;
Bn(u | 0, B | 0, I | 0) | 0;
N = B + 0 | 0;
O = l + 0 | 0;
P = N + 60 | 0;
do {
c[N >> 2] = c[O >> 2];
N = N + 4 | 0;
O = O + 4 | 0
} while ((N | 0) < (P | 0));
M = u;
break
}
J = n;
I = (J - B | 0) / 60 | 0;
w = C;
x = (w - J | 0) / 60 | 0;
if ((I | 0) == (x | 0)) {
J = B;
v = n;
while (1) {
N = l + 0 | 0;
O = J + 0 | 0;
P = N + 60 | 0;
do {
c[N >> 2] = c[O >> 2];
N = N + 4 | 0;
O = O + 4 | 0
} while ((N | 0) < (P |
0));
N = J + 0 | 0;
O = v + 0 | 0;
P = N + 60 | 0;
do {
c[N >> 2] = c[O >> 2];
N = N + 4 | 0;
O = O + 4 | 0
} while ((N | 0) < (P | 0));
N = v + 0 | 0;
O = l + 0 | 0;
P = N + 60 | 0;
do {
c[N >> 2] = c[O >> 2];
N = N + 4 | 0;
O = O + 4 | 0
} while ((N | 0) < (P | 0));
J = J + 60 | 0;
if ((J | 0) == (n | 0)) {
M = n;
break d
} else
v = v + 60 | 0
}
} else {
Q = I;
R = x
}
while (1) {
v = (Q | 0) % (R | 0) | 0;
if ((v | 0) == 0)
break;
else {
J = R;
R = v;
Q = J
}
}
if ((R | 0) != 0) {
J = I + -1 | 0;
v = B + (R * 60 | 0) | 0;
do {
u = v;
v = v + -60 | 0;
N = l + 0 | 0;
O = v + 0 | 0;
P = N + 60 | 0;
do {
c[N >> 2] = c[O >> 2];
N = N + 4 | 0;
O = O + 4 | 0
} while ((N | 0) < (P | 0));
z = v;
S = u + (J * 60 | 0) | 0;
while (1) {
N = z + 0 | 0;
O = S + 0 | 0;
P = N + 60 | 0;
do {
c[N >> 2] = c[O >> 2];
N = N + 4 | 0;
O = O + 4 | 0
} while ((N | 0) < (P | 0));
T = (w - S | 0) / 60 | 0;
if ((I | 0) < (T | 0))
U = S + (I * 60 | 0) | 0;
else
U = B + ((I - T | 0) * 60 | 0) | 0;
if ((U | 0) == (v | 0))
break;
else {
T = S;
S = U;
z = T
}
}
N = S + 0 | 0;
O = l + 0 | 0;
P = N + 60 | 0;
do {
c[N >> 2] = c[O >> 2];
N = N + 4 | 0;
O = O + 4 | 0
} while ((N | 0) < (P | 0))
} while ((v | 0) != (B | 0))
}
M = B + (x * 60 | 0) | 0
}
else
M = C;
while (0);
if ((E + D | 0) >= (L + o | 0))
break;
Nl(s, B, M, e, D, E, h, j);
if ((q | 0) == (E | 0)) {
r = 45;
break a
} else {
n = C;
p = M;
q = L
}
}
Nl(M, C, b, e, o, L, h, j);
if ((E | 0) == 0) {
r = 45;
break
} else {
m = s;
a = B;
b = M;
d = D;
f = E
}
}
if ((r | 0) == 8) {
Ol(s, n, b, e, t, q, h);
i = k;
return
} else if ((r | 0) == 17) {
N = l + 0 |
0;
O = s + 0 | 0;
P = N + 60 | 0;
do {
c[N >> 2] = c[O >> 2];
N = N + 4 | 0;
O = O + 4 | 0
} while ((N | 0) < (P | 0));
N = s + 0 | 0;
O = n + 0 | 0;
P = N + 60 | 0;
do {
c[N >> 2] = c[O >> 2];
N = N + 4 | 0;
O = O + 4 | 0
} while ((N | 0) < (P | 0));
N = n + 0 | 0;
O = l + 0 | 0;
P = N + 60 | 0;
do {
c[N >> 2] = c[O >> 2];
N = N + 4 | 0;
O = O + 4 | 0
} while ((N | 0) < (P | 0));
i = k;
return
} else if ((r | 0) == 45) {
i = k;
return
}
}
function Ol(a, b, d, e, f, g, h) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
h = h | 0;
var j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0;
j = i;
k = a;
l = b;
if ((f | 0) <= (g | 0)) {
a:
do if ((a | 0) != (b | 0)) {
g = (((b + -60 + (0 -
k) | 0) >>> 0) / 60 | 0) + 1 | 0;
f = a;
m = h;
while (1) {
if ((m | 0) != 0) {
n = m + 0 | 0;
o = f + 0 | 0;
p = n + 60 | 0;
do {
c[n >> 2] = c[o >> 2];
n = n + 4 | 0;
o = o + 4 | 0
} while ((n | 0) < (p | 0))
}
f = f + 60 | 0;
if ((f | 0) == (b | 0))
break;
else
m = m + 60 | 0
}
m = h + (g * 60 | 0) | 0;
if ((m | 0) != (h | 0)) {
f = a;
q = b;
r = h;
while (1) {
if ((q | 0) == (d | 0))
break;
if (nb[c[e >> 2] & 31](q, r) | 0) {
n = f + 0 | 0;
o = q + 0 | 0;
p = n + 60 | 0;
do {
c[n >> 2] = c[o >> 2];
n = n + 4 | 0;
o = o + 4 | 0
} while ((n | 0) < (p | 0));
s = r;
t = q + 60 | 0
} else {
n = f + 0 | 0;
o = r + 0 | 0;
p = n + 60 | 0;
do {
c[n >> 2] = c[o >> 2];
n = n + 4 | 0;
o = o + 4 | 0
} while ((n | 0) < (p | 0));
s = r + 60 | 0;
t = q
}
u = f + 60 | 0;
if ((s | 0) == (m | 0)) {
v = u;
w = t;
break a
} else {
f =
u;
q = t;
r = s
}
}
Bn(f | 0, r | 0, m - r | 0) | 0;
i = j;
return
} else {
v = a;
w = b
}
} else {
v = a;
w = b
}
while (0);
Bn(v | 0, w | 0, d - w | 0) | 0;
i = j;
return
}
if ((b | 0) == (d | 0))
x = h;
else {
w = (((d + -60 + (0 - l) | 0) >>> 0) / 60 | 0) + 1 | 0;
l = b;
v = h;
while (1) {
if ((v | 0) != 0) {
n = v + 0 | 0;
o = l + 0 | 0;
p = n + 60 | 0;
do {
c[n >> 2] = c[o >> 2];
n = n + 4 | 0;
o = o + 4 | 0
} while ((n | 0) < (p | 0))
}
l = l + 60 | 0;
if ((l | 0) == (d | 0))
break;
else
v = v + 60 | 0
}
x = h + (w * 60 | 0) | 0
}
w = x;
b:
do if ((b | 0) == (a | 0)) {
y = w;
z = d
} else {
v = w;
l = b;
r = x;
m = d;
while (1) {
if ((v | 0) == (h | 0))
break;
f = r + -60 | 0;
s = l + -60 | 0;
t = m + -60 | 0;
if (nb[c[e >> 2] & 31](f, s) | 0) {
n = t + 0 | 0;
o = s + 0 | 0;
p = n + 60 |
0;
do {
c[n >> 2] = c[o >> 2];
n = n + 4 | 0;
o = o + 4 | 0
} while ((n | 0) < (p | 0));
A = s;
B = r
} else {
n = t + 0 | 0;
o = f + 0 | 0;
p = n + 60 | 0;
do {
c[n >> 2] = c[o >> 2];
n = n + 4 | 0;
o = o + 4 | 0
} while ((n | 0) < (p | 0));
A = l;
B = f
}
s = B;
if ((A | 0) == (a | 0)) {
y = s;
z = t;
break b
} else {
v = s;
l = A;
r = B;
m = t
}
}
if ((l | 0) == (a | 0)) {
i = j;
return
} else {
C = m;
D = l
}
do {
C = C + -60 | 0;
D = D + -60 | 0;
n = C + 0 | 0;
o = D + 0 | 0;
p = n + 60 | 0;
do {
c[n >> 2] = c[o >> 2];
n = n + 4 | 0;
o = o + 4 | 0
} while ((n | 0) < (p | 0))
} while ((D | 0) != (a | 0));
i = j;
return
}
while (0);
a = y;
if ((a | 0) == (h | 0)) {
i = j;
return
} else {
E = z;
F = a
}
do {
E = E + -60 | 0;
F = F + -60 | 0;
n = E + 0 | 0;
o = F + 0 | 0;
p = n + 60 | 0;
do {
c[n >> 2] =
c[o >> 2];
n = n + 4 | 0;
o = o + 4 | 0
} while ((n | 0) < (p | 0))
} while ((F | 0) != (h | 0));
i = j;
return
}
function Pl(a, b, d, e, f, g) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0;
h = i;
i = i + 32 | 0;
j = h;
if ((e | 0) == 2) {
k = b + -20 | 0;
if (!(nb[c[d >> 2] & 31](k, a) | 0)) {
i = h;
return
}
c[j + 0 >> 2] = c[a + 0 >> 2];
c[j + 4 >> 2] = c[a + 4 >> 2];
c[j + 8 >> 2] = c[a + 8 >> 2];
c[j + 12 >> 2] = c[a + 12 >> 2];
c[j + 16 >> 2] = c[a + 16 >> 2];
c[a + 0 >> 2] = c[k + 0 >> 2];
c[a + 4 >> 2] = c[k + 4 >> 2];
c[a + 8 >> 2] = c[k + 8 >> 2];
c[a + 12 >> 2] = c[k + 12 >> 2];
c[a + 16 >> 2] = c[k + 16 >> 2];
c[k + 0 >> 2] = c[j + 0 >> 2];
c[k + 4 >> 2] = c[j + 4 >> 2];
c[k + 8 >> 2] = c[j + 8 >> 2];
c[k + 12 >> 2] = c[j + 12 >> 2];
c[k + 16 >> 2] = c[j + 16 >> 2];
i = h;
return
} else if ((e | 0) == 1 | (e | 0) == 0) {
i = h;
return
} else {
if ((e | 0) < 129) {
if ((a | 0) == (b | 0)) {
i = h;
return
}
k = a + 20 | 0;
if ((k | 0) == (b | 0)) {
i = h;
return
} else
l = k;
do {
c[j + 0 >> 2] = c[l + 0 >> 2];
c[j + 4 >> 2] = c[l + 4 >> 2];
c[j + 8 >> 2] = c[l + 8 >> 2];
c[j + 12 >> 2] = c[l + 12 >> 2];
c[j + 16 >> 2] = c[l + 16 >> 2];
a:
do if ((l | 0) == (a | 0))
m = a;
else {
k = l;
while (1) {
n = k;
k = k + -20 | 0;
if (!(nb[c[d >> 2] & 31](j, k) | 0)) {
m = n;
break a
}
c[n + 0 >> 2] = c[k + 0 >> 2];
c[n + 4 >> 2] = c[k + 4 >> 2];
c[n + 8 >> 2] = c[k + 8 >> 2];
c[n + 12 >> 2] =
c[k + 12 >> 2];
c[n + 16 >> 2] = c[k + 16 >> 2];
if ((k | 0) == (a | 0)) {
m = a;
break
}
}
}
while (0);
c[m + 0 >> 2] = c[j + 0 >> 2];
c[m + 4 >> 2] = c[j + 4 >> 2];
c[m + 8 >> 2] = c[j + 8 >> 2];
c[m + 12 >> 2] = c[j + 12 >> 2];
c[m + 16 >> 2] = c[j + 16 >> 2];
l = l + 20 | 0
} while ((l | 0) != (b | 0));
i = h;
return
}
l = (e | 0) / 2 | 0;
j = a + (l * 20 | 0) | 0;
if ((e | 0) > (g | 0)) {
Pl(a, j, d, l, f, g);
m = e - l | 0;
Pl(j, b, d, m, f, g);
Rl(a, j, b, d, l, m, f, g);
i = h;
return
}
Ql(a, j, d, l, f);
g = f + (l * 20 | 0) | 0;
Ql(j, b, d, e - l | 0, g);
l = f + (e * 20 | 0) | 0;
b:
do if ((e + 1 | 0) >>> 0 < 3) {
o = a;
p = g
} else {
b = a;
j = f;
m = g;
while (1) {
if ((m | 0) == (l | 0))
break;
if (nb[c[d >> 2] & 31](m, j) | 0) {
c[b + 0 >>
2] = c[m + 0 >> 2];
c[b + 4 >> 2] = c[m + 4 >> 2];
c[b + 8 >> 2] = c[m + 8 >> 2];
c[b + 12 >> 2] = c[m + 12 >> 2];
c[b + 16 >> 2] = c[m + 16 >> 2];
q = m + 20 | 0;
r = j
} else {
c[b + 0 >> 2] = c[j + 0 >> 2];
c[b + 4 >> 2] = c[j + 4 >> 2];
c[b + 8 >> 2] = c[j + 8 >> 2];
c[b + 12 >> 2] = c[j + 12 >> 2];
c[b + 16 >> 2] = c[j + 16 >> 2];
q = m;
r = j + 20 | 0
}
k = b + 20 | 0;
if ((r | 0) == (g | 0)) {
o = k;
p = q;
break b
} else {
b = k;
j = r;
m = q
}
}
if ((j | 0) == (g | 0)) {
i = h;
return
} else {
s = j;
t = b
}
while (1) {
c[t + 0 >> 2] = c[s + 0 >> 2];
c[t + 4 >> 2] = c[s + 4 >> 2];
c[t + 8 >> 2] = c[s + 8 >> 2];
c[t + 12 >> 2] = c[s + 12 >> 2];
c[t + 16 >> 2] = c[s + 16 >> 2];
s = s + 20 | 0;
if ((s | 0) == (g | 0))
break;
else
t = t + 20 | 0
}
i = h;
return
}
while (0);
if ((p | 0) == (l | 0)) {
i = h;
return
} else {
u = o;
v = p
}
while (1) {
c[u + 0 >> 2] = c[v + 0 >> 2];
c[u + 4 >> 2] = c[v + 4 >> 2];
c[u + 8 >> 2] = c[v + 8 >> 2];
c[u + 12 >> 2] = c[v + 12 >> 2];
c[u + 16 >> 2] = c[v + 16 >> 2];
v = v + 20 | 0;
if ((v | 0) == (l | 0))
break;
else
u = u + 20 | 0
}
i = h;
return
}
}
function Ql(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0;
g = i;
if ((e | 0) == 1) {
if ((f | 0) == 0) {
i = g;
return
}
c[f + 0 >> 2] = c[a + 0 >> 2];
c[f + 4 >> 2] = c[a + 4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f + 16 >> 2] = c[a + 16 >> 2];
i = g;
return
} else if ((e | 0) ==
0) {
i = g;
return
} else if ((e | 0) == 2) {
h = b + -20 | 0;
j = (f | 0) == 0;
if (nb[c[d >> 2] & 31](h, a) | 0) {
if (!j) {
c[f + 0 >> 2] = c[h + 0 >> 2];
c[f + 4 >> 2] = c[h + 4 >> 2];
c[f + 8 >> 2] = c[h + 8 >> 2];
c[f + 12 >> 2] = c[h + 12 >> 2];
c[f + 16 >> 2] = c[h + 16 >> 2]
}
k = f + 20 | 0;
c[k + 0 >> 2] = c[a + 0 >> 2];
c[k + 4 >> 2] = c[a + 4 >> 2];
c[k + 8 >> 2] = c[a + 8 >> 2];
c[k + 12 >> 2] = c[a + 12 >> 2];
c[k + 16 >> 2] = c[a + 16 >> 2];
i = g;
return
} else {
if (!j) {
c[f + 0 >> 2] = c[a + 0 >> 2];
c[f + 4 >> 2] = c[a + 4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f + 16 >> 2] = c[a + 16 >> 2]
}
j = f + 20 | 0;
c[j + 0 >> 2] = c[h + 0 >> 2];
c[j + 4 >> 2] = c[h + 4 >> 2];
c[j + 8 >> 2] = c[h + 8 >> 2];
c[j +
12 >> 2] = c[h + 12 >> 2];
c[j + 16 >> 2] = c[h + 16 >> 2];
i = g;
return
}
} else {
if ((e | 0) < 9) {
if ((a | 0) == (b | 0)) {
i = g;
return
}
if ((f | 0) == 0)
l = 0;
else {
c[f + 0 >> 2] = c[a + 0 >> 2];
c[f + 4 >> 2] = c[a + 4 >> 2];
c[f + 8 >> 2] = c[a + 8 >> 2];
c[f + 12 >> 2] = c[a + 12 >> 2];
c[f + 16 >> 2] = c[a + 16 >> 2];
l = f
}
h = a + 20 | 0;
if ((h | 0) == (b | 0)) {
i = g;
return
} else {
m = h;
n = l
}
do {
l = n;
n = n + 20 | 0;
if (nb[c[d >> 2] & 31](m, l) | 0) {
c[n + 0 >> 2] = c[l + 0 >> 2];
c[n + 4 >> 2] = c[l + 4 >> 2];
c[n + 8 >> 2] = c[l + 8 >> 2];
c[n + 12 >> 2] = c[l + 12 >> 2];
c[n + 16 >> 2] = c[l + 16 >> 2];
a:
do if ((l | 0) == (f | 0))
o = f;
else {
h = l;
while (1) {
j = h;
h = h + -20 | 0;
if (!(nb[c[d >> 2] & 31](m,
h) | 0)) {
o = j;
break a
}
c[j + 0 >> 2] = c[h + 0 >> 2];
c[j + 4 >> 2] = c[h + 4 >> 2];
c[j + 8 >> 2] = c[h + 8 >> 2];
c[j + 12 >> 2] = c[h + 12 >> 2];
c[j + 16 >> 2] = c[h + 16 >> 2];
if ((h | 0) == (f | 0)) {
o = f;
break
}
}
}
while (0);
c[o + 0 >> 2] = c[m + 0 >> 2];
c[o + 4 >> 2] = c[m + 4 >> 2];
c[o + 8 >> 2] = c[m + 8 >> 2];
c[o + 12 >> 2] = c[m + 12 >> 2];
c[o + 16 >> 2] = c[m + 16 >> 2]
} else {
c[n + 0 >> 2] = c[m + 0 >> 2];
c[n + 4 >> 2] = c[m + 4 >> 2];
c[n + 8 >> 2] = c[m + 8 >> 2];
c[n + 12 >> 2] = c[m + 12 >> 2];
c[n + 16 >> 2] = c[m + 16 >> 2]
}
m = m + 20 | 0
} while ((m | 0) != (b | 0));
i = g;
return
}
m = (e | 0) / 2 | 0;
n = a + (m * 20 | 0) | 0;
Pl(a, n, d, m, f, m);
o = e - m | 0;
Pl(n, b, d, o, f + (m * 20 | 0) | 0, o);
b:
do if ((e +
1 | 0) >>> 0 < 3) {
p = n;
q = f
} else {
o = n;
m = a;
l = f;
while (1) {
if ((o | 0) == (b | 0))
break;
h = (l | 0) == 0;
if (nb[c[d >> 2] & 31](o, m) | 0) {
if (!h) {
c[l + 0 >> 2] = c[o + 0 >> 2];
c[l + 4 >> 2] = c[o + 4 >> 2];
c[l + 8 >> 2] = c[o + 8 >> 2];
c[l + 12 >> 2] = c[o + 12 >> 2];
c[l + 16 >> 2] = c[o + 16 >> 2]
}
r = m;
s = o + 20 | 0
} else {
if (!h) {
c[l + 0 >> 2] = c[m + 0 >> 2];
c[l + 4 >> 2] = c[m + 4 >> 2];
c[l + 8 >> 2] = c[m + 8 >> 2];
c[l + 12 >> 2] = c[m + 12 >> 2];
c[l + 16 >> 2] = c[m + 16 >> 2]
}
r = m + 20 | 0;
s = o
}
h = l + 20 | 0;
if ((r | 0) == (n | 0)) {
p = s;
q = h;
break b
} else {
o = s;
m = r;
l = h
}
}
if ((m | 0) == (n | 0)) {
i = g;
return
} else {
t = m;
u = l
}
while (1) {
if ((u | 0) != 0) {
c[u + 0 >> 2] = c[t + 0 >> 2];
c[u + 4 >> 2] = c[t + 4 >> 2];
c[u + 8 >> 2] = c[t + 8 >> 2];
c[u + 12 >> 2] = c[t + 12 >> 2];
c[u + 16 >> 2] = c[t + 16 >> 2]
}
t = t + 20 | 0;
if ((t | 0) == (n | 0))
break;
else
u = u + 20 | 0
}
i = g;
return
}
while (0);
if ((p | 0) == (b | 0)) {
i = g;
return
} else {
v = p;
w = q
}
while (1) {
if ((w | 0) != 0) {
c[w + 0 >> 2] = c[v + 0 >> 2];
c[w + 4 >> 2] = c[v + 4 >> 2];
c[w + 8 >> 2] = c[v + 8 >> 2];
c[w + 12 >> 2] = c[v + 12 >> 2];
c[w + 16 >> 2] = c[v + 16 >> 2]
}
v = v + 20 | 0;
if ((v | 0) == (b | 0))
break;
else
w = w + 20 | 0
}
i = g;
return
}
}
function Rl(a, b, d, e, f, g, h, j) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
h = h | 0;
j = j | 0;
var k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0;
k = i;
i = i + 48 | 0;
l = k + 20 | 0;
m = k;
if ((g | 0) == 0) {
i = k;
return
}
n = a;
a = b;
b = d;
d = f;
f = g;
a:
while (1) {
g = b;
o = a;
p = d;
q = n;
r = f;
while (1) {
if ((p | 0) == 0) {
s = 45;
break a
} else {
t = q;
u = p
}
while (1) {
if (nb[c[e >> 2] & 31](o, t) | 0)
break;
v = u + -1 | 0;
if ((v | 0) == 0) {
s = 45;
break a
} else {
t = t + 20 | 0;
u = v
}
}
if (!((u | 0) > (j | 0) & (r | 0) > (j | 0))) {
s = 8;
break a
}
if ((u | 0) < (r | 0)) {
v = (r | 0) / 2 | 0;
w = o + (v * 20 | 0) | 0;
x = t;
y = t;
z = (o - x | 0) / 20 | 0;
b:
while (1) {
A = z;
while (1) {
if ((A | 0) == 0)
break b;
B = (A | 0) / 2 | 0;
if (nb[c[e >>
2] & 31](w, y + (B * 20 | 0) | 0) | 0)
A = B;
else
break
}
y = y + ((B + 1 | 0) * 20 | 0) | 0;
z = A + -1 - B | 0
}
C = y;
D = w;
E = (y - x | 0) / 20 | 0;
F = v
} else {
if ((u | 0) == 1) {
s = 17;
break a
}
z = (u | 0) / 2 | 0;
G = t + (z * 20 | 0) | 0;
H = o;
I = o;
J = (g - H | 0) / 20 | 0;
c:
while (1) {
K = J;
while (1) {
if ((K | 0) == 0)
break c;
L = (K | 0) / 2 | 0;
if (nb[c[e >> 2] & 31](I + (L * 20 | 0) | 0, G) | 0)
break;
else
K = L
}
I = I + ((L + 1 | 0) * 20 | 0) | 0;
J = K + -1 - L | 0
}
C = G;
D = I;
E = z;
F = (I - H | 0) / 20 | 0
}
p = u - E | 0;
M = r - F | 0;
d:
do if ((C | 0) != (o | 0))
if ((o | 0) == (D | 0))
N = C;
else {
if ((C + 20 | 0) == (o | 0)) {
c[l + 0 >> 2] = c[C + 0 >> 2];
c[l + 4 >> 2] = c[C + 4 >> 2];
c[l + 8 >> 2] = c[C + 8 >> 2];
c[l + 12 >> 2] = c[C +
12 >> 2];
c[l + 16 >> 2] = c[C + 16 >> 2];
J = D - o | 0;
Bn(C | 0, o | 0, J | 0) | 0;
v = C + (((J | 0) / 20 | 0) * 20 | 0) | 0;
c[v + 0 >> 2] = c[l + 0 >> 2];
c[v + 4 >> 2] = c[l + 4 >> 2];
c[v + 8 >> 2] = c[l + 8 >> 2];
c[v + 12 >> 2] = c[l + 12 >> 2];
c[v + 16 >> 2] = c[l + 16 >> 2];
N = v;
break
}
if ((o + 20 | 0) == (D | 0)) {
v = D + -20 | 0;
c[l + 0 >> 2] = c[v + 0 >> 2];
c[l + 4 >> 2] = c[v + 4 >> 2];
c[l + 8 >> 2] = c[v + 8 >> 2];
c[l + 12 >> 2] = c[v + 12 >> 2];
c[l + 16 >> 2] = c[v + 16 >> 2];
J = v - C | 0;
v = D + (((J | 0) / -20 | 0) * 20 | 0) | 0;
Bn(v | 0, C | 0, J | 0) | 0;
c[C + 0 >> 2] = c[l + 0 >> 2];
c[C + 4 >> 2] = c[l + 4 >> 2];
c[C + 8 >> 2] = c[l + 8 >> 2];
c[C + 12 >> 2] = c[l + 12 >> 2];
c[C + 16 >> 2] = c[l + 16 >> 2];
N = v;
break
}
v = o;
J =
(v - C | 0) / 20 | 0;
x = D;
y = (x - v | 0) / 20 | 0;
if ((J | 0) == (y | 0)) {
v = C;
w = o;
while (1) {
c[l + 0 >> 2] = c[v + 0 >> 2];
c[l + 4 >> 2] = c[v + 4 >> 2];
c[l + 8 >> 2] = c[v + 8 >> 2];
c[l + 12 >> 2] = c[v + 12 >> 2];
c[l + 16 >> 2] = c[v + 16 >> 2];
c[v + 0 >> 2] = c[w + 0 >> 2];
c[v + 4 >> 2] = c[w + 4 >> 2];
c[v + 8 >> 2] = c[w + 8 >> 2];
c[v + 12 >> 2] = c[w + 12 >> 2];
c[v + 16 >> 2] = c[w + 16 >> 2];
c[w + 0 >> 2] = c[l + 0 >> 2];
c[w + 4 >> 2] = c[l + 4 >> 2];
c[w + 8 >> 2] = c[l + 8 >> 2];
c[w + 12 >> 2] = c[l + 12 >> 2];
c[w + 16 >> 2] = c[l + 16 >> 2];
v = v + 20 | 0;
if ((v | 0) == (o | 0)) {
N = o;
break d
} else
w = w + 20 | 0
}
} else {
O = J;
P = y
}
while (1) {
w = (O | 0) % (P | 0) | 0;
if ((w | 0) == 0)
break;
else {
v = P;
P = w;
O =
v
}
}
if ((P | 0) != 0) {
v = J + -1 | 0;
w = C + (P * 20 | 0) | 0;
do {
K = w;
w = w + -20 | 0;
c[m + 0 >> 2] = c[w + 0 >> 2];
c[m + 4 >> 2] = c[w + 4 >> 2];
c[m + 8 >> 2] = c[w + 8 >> 2];
c[m + 12 >> 2] = c[w + 12 >> 2];
c[m + 16 >> 2] = c[w + 16 >> 2];
A = w;
Q = K + (v * 20 | 0) | 0;
while (1) {
c[A + 0 >> 2] = c[Q + 0 >> 2];
c[A + 4 >> 2] = c[Q + 4 >> 2];
c[A + 8 >> 2] = c[Q + 8 >> 2];
c[A + 12 >> 2] = c[Q + 12 >> 2];
c[A + 16 >> 2] = c[Q + 16 >> 2];
K = (x - Q | 0) / 20 | 0;
if ((J | 0) < (K | 0))
R = Q + (J * 20 | 0) | 0;
else
R = C + ((J - K | 0) * 20 | 0) | 0;
if ((R | 0) == (w | 0))
break;
else {
K = Q;
Q = R;
A = K
}
}
c[Q + 0 >> 2] = c[m + 0 >> 2];
c[Q + 4 >> 2] = c[m + 4 >> 2];
c[Q + 8 >> 2] = c[m + 8 >> 2];
c[Q + 12 >> 2] = c[m + 12 >> 2];
c[Q + 16 >> 2] = c[m +
16 >> 2]
} while ((w | 0) != (C | 0))
}
N = C + (y * 20 | 0) | 0
}
else
N = D;
while (0);
if ((F + E | 0) >= (M + p | 0))
break;
Rl(t, C, N, e, E, F, h, j);
if ((r | 0) == (F | 0)) {
s = 45;
break a
} else {
o = D;
q = N;
r = M
}
}
Rl(N, D, b, e, p, M, h, j);
if ((F | 0) == 0) {
s = 45;
break
} else {
n = t;
a = C;
b = N;
d = E;
f = F
}
}
if ((s | 0) == 8) {
Sl(t, o, b, e, u, r, h);
i = k;
return
} else if ((s | 0) == 17) {
c[l + 0 >> 2] = c[t + 0 >> 2];
c[l + 4 >> 2] = c[t + 4 >> 2];
c[l + 8 >> 2] = c[t + 8 >> 2];
c[l + 12 >> 2] = c[t + 12 >> 2];
c[l + 16 >> 2] = c[t + 16 >> 2];
c[t + 0 >> 2] = c[o + 0 >> 2];
c[t + 4 >> 2] = c[o + 4 >> 2];
c[t + 8 >> 2] = c[o + 8 >> 2];
c[t + 12 >> 2] = c[o + 12 >> 2];
c[t + 16 >> 2] = c[o + 16 >> 2];
c[o + 0 >> 2] =
c[l + 0 >> 2];
c[o + 4 >> 2] = c[l + 4 >> 2];
c[o + 8 >> 2] = c[l + 8 >> 2];
c[o + 12 >> 2] = c[l + 12 >> 2];
c[o + 16 >> 2] = c[l + 16 >> 2];
i = k;
return
} else if ((s | 0) == 45) {
i = k;
return
}
}
function Sl(a, b, d, e, f, g, h) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
h = h | 0;
var j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0;
j = i;
k = a;
l = b;
if ((f | 0) <= (g | 0)) {
a:
do if ((a | 0) != (b | 0)) {
g = (((b + -20 + (0 - k) | 0) >>> 0) / 20 | 0) + 1 | 0;
f = a;
m = h;
while (1) {
if ((m | 0) != 0) {
c[m + 0 >> 2] = c[f + 0 >> 2];
c[m + 4 >> 2] = c[f + 4 >> 2];
c[m + 8 >> 2] = c[f + 8 >> 2];
c[m + 12 >> 2] = c[f + 12 >> 2];
c[m + 16 >> 2] = c[f +
16 >> 2]
}
f = f + 20 | 0;
if ((f | 0) == (b | 0))
break;
else
m = m + 20 | 0
}
m = h + (g * 20 | 0) | 0;
if ((m | 0) != (h | 0)) {
f = a;
n = b;
o = h;
while (1) {
if ((n | 0) == (d | 0))
break;
if (nb[c[e >> 2] & 31](n, o) | 0) {
c[f + 0 >> 2] = c[n + 0 >> 2];
c[f + 4 >> 2] = c[n + 4 >> 2];
c[f + 8 >> 2] = c[n + 8 >> 2];
c[f + 12 >> 2] = c[n + 12 >> 2];
c[f + 16 >> 2] = c[n + 16 >> 2];
p = o;
q = n + 20 | 0
} else {
c[f + 0 >> 2] = c[o + 0 >> 2];
c[f + 4 >> 2] = c[o + 4 >> 2];
c[f + 8 >> 2] = c[o + 8 >> 2];
c[f + 12 >> 2] = c[o + 12 >> 2];
c[f + 16 >> 2] = c[o + 16 >> 2];
p = o + 20 | 0;
q = n
}
r = f + 20 | 0;
if ((p | 0) == (m | 0)) {
s = r;
t = q;
break a
} else {
f = r;
n = q;
o = p
}
}
Bn(f | 0, o | 0, m - o | 0) | 0;
i = j;
return
} else {
s = a;
t = b
}
} else {
s =
a;
t = b
}
while (0);
Bn(s | 0, t | 0, d - t | 0) | 0;
i = j;
return
}
if ((b | 0) == (d | 0))
u = h;
else {
t = (((d + -20 + (0 - l) | 0) >>> 0) / 20 | 0) + 1 | 0;
l = b;
s = h;
while (1) {
if ((s | 0) != 0) {
c[s + 0 >> 2] = c[l + 0 >> 2];
c[s + 4 >> 2] = c[l + 4 >> 2];
c[s + 8 >> 2] = c[l + 8 >> 2];
c[s + 12 >> 2] = c[l + 12 >> 2];
c[s + 16 >> 2] = c[l + 16 >> 2]
}
l = l + 20 | 0;
if ((l | 0) == (d | 0))
break;
else
s = s + 20 | 0
}
u = h + (t * 20 | 0) | 0
}
t = u;
b:
do if ((b | 0) == (a | 0)) {
v = t;
w = d
} else {
s = t;
l = b;
p = u;
q = d;
while (1) {
if ((s | 0) == (h | 0))
break;
k = p + -20 | 0;
n = l + -20 | 0;
g = q + -20 | 0;
if (nb[c[e >> 2] & 31](k, n) | 0) {
c[g + 0 >> 2] = c[n + 0 >> 2];
c[g + 4 >> 2] = c[n + 4 >> 2];
c[g + 8 >> 2] = c[n + 8 >> 2];
c[g + 12 >> 2] = c[n + 12 >> 2];
c[g + 16 >> 2] = c[n + 16 >> 2];
x = n;
y = p
} else {
c[g + 0 >> 2] = c[k + 0 >> 2];
c[g + 4 >> 2] = c[k + 4 >> 2];
c[g + 8 >> 2] = c[k + 8 >> 2];
c[g + 12 >> 2] = c[k + 12 >> 2];
c[g + 16 >> 2] = c[k + 16 >> 2];
x = l;
y = k
}
k = y;
if ((x | 0) == (a | 0)) {
v = k;
w = g;
break b
} else {
s = k;
l = x;
p = y;
q = g
}
}
if ((l | 0) == (a | 0)) {
i = j;
return
} else {
z = q;
A = l
}
do {
z = z + -20 | 0;
A = A + -20 | 0;
c[z + 0 >> 2] = c[A + 0 >> 2];
c[z + 4 >> 2] = c[A + 4 >> 2];
c[z + 8 >> 2] = c[A + 8 >> 2];
c[z + 12 >> 2] = c[A + 12 >> 2];
c[z + 16 >> 2] = c[A + 16 >> 2]
} while ((A | 0) != (a | 0));
i = j;
return
}
while (0);
a = v;
if ((a | 0) == (h | 0)) {
i = j;
return
} else {
B = w;
C = a
}
do {
B = B + -20 | 0;
C = C + -20 |
0;
c[B + 0 >> 2] = c[C + 0 >> 2];
c[B + 4 >> 2] = c[C + 4 >> 2];
c[B + 8 >> 2] = c[C + 8 >> 2];
c[B + 12 >> 2] = c[C + 12 >> 2];
c[B + 16 >> 2] = c[C + 16 >> 2]
} while ((C | 0) != (h | 0));
i = j;
return
}
function Tl(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0;
b = i;
d = a + 4 | 0;
e = c[d >> 2] | 0;
if ((e | 0) != (a | 0)) {
f = e;
do {
e = Sm(f) | 0;
g = c[e >> 2] | 0;
if ((g | 0) != 0) {
h = 0;
j = e + 32 | 0;
while (1) {
k = j + 4 | 0;
c[(c[j >> 2] | 0) + 4 >> 2] = c[k >> 2];
c[c[k >> 2] >> 2] = c[j >> 2];
c[k >> 2] = j;
c[j >> 2] = j;
h = h + 1 | 0;
if ((h | 0) == (g | 0))
break;
else
j = j + 12 | 0
}
}
Um(a, e);
f = c[d >> 2] | 0
} while ((f | 0) != (a | 0))
}
f = a + 12 | 0;
j = a + 20 | 0;
g = a + 24 | 0;
c[(c[j >> 2] | 0) +
4 >> 2] = c[g >> 2];
c[c[g >> 2] >> 2] = c[j >> 2];
c[g >> 2] = j;
c[j >> 2] = j;
j = a + 16 | 0;
c[(c[f >> 2] | 0) + 4 >> 2] = c[j >> 2];
c[c[j >> 2] >> 2] = c[f >> 2];
c[j >> 2] = f;
c[f >> 2] = f;
Vm(a);
c[(c[a >> 2] | 0) + 4 >> 2] = c[d >> 2];
c[c[d >> 2] >> 2] = c[a >> 2];
c[d >> 2] = a;
c[a >> 2] = a;
i = b;
return
}
function Ul(a) {
a = a | 0;
return
}
function Vl(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Wl(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0;
e = i;
i = i + 48 | 0;
f = e + 24 | 0;
g = e;
if ((a[d + 38 >> 0] | 0) != 0) {
i = e;
return 1
}
h = c[d + 12 >> 2] | 0;
j = bb[c[(c[h >> 2] | 0) + 12 >> 2] &
7](h) | 0;
if ((j | 0) <= 0) {
i = e;
return 1
}
h = d + 24 | 0;
k = b + 4 | 0;
l = g + 16 | 0;
m = g + 20 | 0;
n = g + 4 | 0;
o = 0;
do {
p = (c[h >> 2] | 0) + (o * 28 | 0) | 0;
c[f + 0 >> 2] = c[p + 0 >> 2];
c[f + 4 >> 2] = c[p + 4 >> 2];
c[f + 8 >> 2] = c[p + 8 >> 2];
c[f + 12 >> 2] = c[p + 12 >> 2];
Nk(g, c[k >> 2] | 0, f);
p = c[l >> 2] | 0;
q = c[m >> 2] | 0;
a:
do if (p >>> 0 < q >>> 0) {
r = c[g >> 2] | 0;
s = c[n >> 2] | 0;
t = p;
while (1) {
u = c[t + 4 >> 2] & 1048575;
v = t;
t = t + 8 | 0;
c[l >> 2] = t;
if (u >>> 0 < r >>> 0 | u >>> 0 > s >>> 0)
if (t >>> 0 < q >>> 0) {
t = t;
continue
} else
break;
u = c[v >> 2] | 0;
if (!((u | 0) > -1))
break a;
pb[c[(c[b >> 2] | 0) + 20 >> 2] & 31](b, d, o, u);
if (!(t >>> 0 < q >>> 0))
break
}
}
while (0);
o = o + 1 | 0
} while ((o | 0) != (j | 0));
i = e;
return 1
}
function Xl(a, b) {
a = a | 0;
b = b | 0;
return 0
}
function Yl(b, d, e, f) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0;
h = i;
i = i + 48 | 0;
j = h + 24 | 0;
l = h;
m = c[d + 8 >> 2] | 0;
n = b + 4 | 0;
o = c[n >> 2] | 0;
p = (c[o + 96 >> 2] | 0) + (f << 3) | 0;
q = c[p >> 2] | 0;
r = c[p + 4 >> 2] | 0;
s = (c[k >> 2] = q, +g[k >> 2]);
t = (c[k >> 2] = r, +g[k >> 2]);
p = (c[o + 104 >> 2] | 0) + (f << 3) | 0;
u = +g[p >> 2];
v = +g[p + 4 >> 2];
if ((c[o + 24 >> 2] | 0) == 0) {
w = s - +g[m + 28 >> 2];
x = t - +g[m + 32 >> 2];
y = +g[m + 40 >> 2];
z = +g[m + 36 >> 2];
A = w * y + x * z;
B = y * x - w * z;
o = c[d + 12 >> 2] | 0;
if ((c[o + 4 >> 2] | 0) == 0) {
w = +g[m + 44 >> 2];
x = A - w;
C = +g[m + 48 >> 2];
D = B - C;
E = x * y - D * z;
F = y * D + x * z;
z = +g[m + 24 >> 2];
x = +g[m + 20 >> 2];
G = z;
H = w + (z * E + x * F);
I = x;
J = C + (z * F - E * x)
} else {
G = +g[m + 24 >> 2];
H = A;
I = +g[m + 20 >> 2];
J = B
}
B = +(+g[m + 12 >> 2] + (H * G - J * I));
A = +(J * G + H * I + +g[m + 16 >> 2]);
p = l;
g[p >> 2] = B;
g[p + 4 >> 2] = A;
K = o
} else {
o = l;
c[o >> 2] = q;
c[o + 4 >> 2] = r;
K = c[d + 12 >> 2] | 0
}
d = l + 8 | 0;
A = +g[b + 8 >> 2];
B = +(s + u * A);
I = +(t + v * A);
r = d;
g[r >> 2] = B;
g[r + 4 >> 2] = I;
g[l + 16 >> 2] = 1;
if (!(ob[c[(c[K >> 2] | 0) + 24 >> 2] & 15](K, j, l, m +
12 | 0, e) | 0)) {
i = h;
return
}
e = j;
I = +g[e >> 2];
B = +g[j + 8 >> 2];
A = 1 - B;
j = b + 12 | 0;
H = +g[j >> 2];
G = H * (I * .004999999888241291 + (+g[l >> 2] * A + B * +g[d >> 2]) - s);
s = H * (+g[e + 4 >> 2] * .004999999888241291 + (A * +g[l + 4 >> 2] + B * +g[l + 12 >> 2]) - t);
t = +G;
B = +s;
l = (c[(c[n >> 2] | 0) + 104 >> 2] | 0) + (f << 3) | 0;
g[l >> 2] = t;
g[l + 4 >> 2] = B;
l = c[n >> 2] | 0;
B = +g[l + 32 >> 2] * .75;
t = +g[j >> 2] * B * +g[l + 320 >> 2] * B;
B = (u - G) * t;
G = (v - s) * t;
if (!(B != 0 | G != 0)) {
i = h;
return
}
if ((c[(c[l + 88 >> 2] | 0) + (f << 2) >> 2] & 4 | 0) != 0) {
i = h;
return
}
j = l + 21 | 0;
n = l + 112 | 0;
if ((a[j >> 0] | 0) == 0) {
xn(c[n >> 2] | 0, 0, c[l + 44 >> 2] << 3 | 0) | 0;
a[j >>
0] = 1
}
j = c[n >> 2] | 0;
n = j + (f << 3) | 0;
g[n >> 2] = B + +g[n >> 2];
n = j + (f << 3) + 4 | 0;
g[n >> 2] = G + +g[n >> 2];
i = h;
return
}
function Zl(a) {
a = a | 0;
return
}
function _l(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function $l(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0;
f = i;
i = i + 32 | 0;
h = f;
j = f + 16 | 0;
k = f + 8 | 0;
l = a + 4 | 0;
m = (c[(c[l >> 2] | 0) + 96 >> 2] | 0) + (e << 3) | 0;
n = c[m + 4 >> 2] | 0;
o = h;
c[o >> 2] = c[m >> 2];
c[o + 4 >> 2] = n;
n = c[b + 12 >> 2] | 0;
o = b + 8 | 0;
mb[c[(c[n >> 2] | 0) + 20 >> 2] & 7](n, (c[o >> 2] | 0) + 12 |
0, h, j, k, d);
d = c[l >> 2] | 0;
if (!(+g[j >> 2] < +g[d + 32 >> 2])) {
i = f;
return
}
n = c[a + 8 >> 2] | 0;
if (((n | 0) != 0 ? (c[(c[d + 88 >> 2] | 0) + (e << 2) >> 2] & 65536 | 0) != 0 : 0) ? !(lb[c[(c[n >> 2] | 0) + 12 >> 2] & 7](n, b, d, e) | 0) : 0) {
i = f;
return
}
d = c[o >> 2] | 0;
o = d + 60 | 0;
p = +g[o >> 2];
q = +g[d + 132 >> 2];
r = +g[d + 44 >> 2];
s = +g[d + 48 >> 2];
t = q * (r * r + s * s);
s = +g[d + 140 >> 2] + t - t;
if (q > 0)
u = 1 / q;
else
u = 0;
if (s > 0)
v = 1 / s;
else
v = 0;
n = c[l >> 2] | 0;
if ((c[(c[n + 88 >> 2] | 0) + (e << 2) >> 2] & 4 | 0) == 0) {
s = +g[n + 36 >> 2] * 1.3333333730697632;
w = s * +g[n + 28 >> 2] * s
} else
w = 0;
a = k + 4 | 0;
s = (+g[h >> 2] - p) * +g[a >> 2] - (+g[h + 4 >> 2] - +g[o +
4 >> 2]) * +g[k >> 2];
p = u + w + s * v * s;
o = n + 232 | 0;
h = n + 236 | 0;
m = c[h >> 2] | 0;
x = n + 240 | 0;
y = c[x >> 2] | 0;
if ((m | 0) >= (y | 0) ? (z = (y | 0) == 0 ? 256 : y << 1, (y | 0) < (z | 0)) : 0) {
y = n + 244 | 0;
n = Em(c[y >> 2] | 0, z * 28 | 0) | 0;
A = c[o >> 2] | 0;
if ((A | 0) != 0) {
An(n | 0, A | 0, (c[h >> 2] | 0) * 28 | 0) | 0;
Fm(c[y >> 2] | 0, c[o >> 2] | 0, (c[x >> 2] | 0) * 28 | 0)
}
c[x >> 2] = z;
c[o >> 2] = n;
B = c[h >> 2] | 0
} else
B = m;
c[h >> 2] = B + 1;
h = c[o >> 2] | 0;
c[h + (B * 28 | 0) >> 2] = e;
c[h + (B * 28 | 0) + 4 >> 2] = d;
c[h + (B * 28 | 0) + 8 >> 2] = b;
g[h + (B * 28 | 0) + 12 >> 2] = 1 - +g[j >> 2] * +g[(c[l >> 2] | 0) + 36 >> 2];
s = +-+g[k >> 2];
v = +-+g[a >> 2];
a = h + (B * 28 | 0) + 16 | 0;
g[a >> 2] = s;
g[a +
4 >> 2] = v;
if (p > 0)
C = 1 / p;
else
C = 0;
g[h + (B * 28 | 0) + 24 >> 2] = C;
Tk(c[l >> 2] | 0, e);
i = f;
return
}
function am(a) {
a = a | 0;
return
}
function bm(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function sj(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0;
b = i;
d = c[a + 102960 >> 2] | 0;
if ((d | 0) != 0) {
e = d;
do {
d = e;
e = c[e + 112 >> 2] | 0;
f = c[d + 116 >> 2] | 0;
while (1) {
if ((f | 0) == 0)
break;
d = c[f + 4 >> 2] | 0;
c[f + 28 >> 2] = 0;
nj(f, a);
f = d
}
} while ((e | 0) != 0)
}
e = a + 102968 | 0;
f = c[e >> 2] | 0;
if ((f | 0) == 0) {
g = a + 102880 | 0;
Ne(g);
h = a + 76 | 0;
Xm(h);
Dm(a);
i = b;
return
}
d = a + 102876 | 0;
j = f;
while (1) {
if ((c[d >>
2] & 2 | 0) == 0) {
f = j + 404 | 0;
k = c[f >> 2] | 0;
l = j + 408 | 0;
if ((k | 0) != 0)
c[k + 408 >> 2] = c[l >> 2];
k = c[l >> 2] | 0;
if ((k | 0) != 0)
c[k + 404 >> 2] = c[f >> 2];
if ((c[e >> 2] | 0) == (j | 0))
c[e >> 2] = c[l >> 2];
sk(j);
Fm(a, j, 416);
m = c[e >> 2] | 0
} else
m = j;
if ((m | 0) == 0)
break;
else
j = m
}
g = a + 102880 | 0;
Ne(g);
h = a + 76 | 0;
Xm(h);
Dm(a);
i = b;
return
}
function tj(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0;
d = i;
if ((c[a + 102876 >> 2] & 2 | 0) != 0) {
i = d;
return
}
e = b + 404 | 0;
f = c[e >> 2] | 0;
g = b + 408 | 0;
if ((f | 0) != 0)
c[f + 408 >> 2] = c[g >> 2];
f = c[g >> 2] | 0;
if ((f | 0) != 0)
c[f + 404 >> 2] = c[e >> 2];
e = a + 102968 | 0;
if ((c[e >> 2] | 0) ==
(b | 0))
c[e >> 2] = c[g >> 2];
sk(b);
Fm(a, b, 416);
i = d;
return
}
function uj(a, b) {
a = a | 0;
b = b | 0;
c[a + 102952 >> 2] = b;
return
}
function vj(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0;
d = i;
if ((c[a + 102876 >> 2] & 2 | 0) != 0) {
e = 0;
i = d;
return e | 0
}
f = Em(a, 168) | 0;
if ((f | 0) == 0)
g = 0;
else {
Hj(f, b, a);
g = f
}
c[g + 108 >> 2] = 0;
f = a + 102960 | 0;
c[g + 112 >> 2] = c[f >> 2];
b = c[f >> 2] | 0;
if ((b | 0) != 0)
c[b + 108 >> 2] = g;
c[f >> 2] = g;
f = a + 102972 | 0;
c[f >> 2] = (c[f >> 2] | 0) + 1;
e = g;
i = d;
return e | 0
}
function wj(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0;
d = i;
if ((c[a + 102876 >> 2] & 2 | 0) != 0) {
i =
d;
return
}
e = b + 124 | 0;
f = c[e >> 2] | 0;
if ((f | 0) != 0) {
g = a + 102992 | 0;
h = f;
do {
f = h;
h = c[h + 12 >> 2] | 0;
j = c[g >> 2] | 0;
if ((j | 0) == 0)
k = f + 4 | 0;
else {
l = f + 4 | 0;
gb[c[(c[j >> 2] | 0) + 8 >> 2] & 63](j, c[l >> 2] | 0);
k = l
}
xj(a, c[k >> 2] | 0);
c[e >> 2] = h
} while ((h | 0) != 0)
}
c[e >> 2] = 0;
e = b + 128 | 0;
h = c[e >> 2] | 0;
if ((h | 0) != 0) {
k = a + 102880 | 0;
g = h;
do {
h = g;
g = c[g + 12 >> 2] | 0;
Tj(k, c[h + 4 >> 2] | 0)
} while ((g | 0) != 0)
}
c[e >> 2] = 0;
e = b + 116 | 0;
g = c[e >> 2] | 0;
if ((g | 0) == 0)
m = b + 120 | 0;
else {
k = a + 102992 | 0;
h = a + 102880 | 0;
l = b + 120 | 0;
j = g;
do {
g = j;
j = c[j + 4 >> 2] | 0;
f = c[k >> 2] | 0;
if ((f | 0) != 0)
gb[c[(c[f >> 2] | 0) + 12 >> 2] & 63](f,
g);
pj(g, h);
nj(g, a);
Fm(a, g, 44);
c[e >> 2] = j;
c[l >> 2] = (c[l >> 2] | 0) + -1
} while ((j | 0) != 0);
m = l
}
c[e >> 2] = 0;
c[m >> 2] = 0;
m = b + 108 | 0;
e = c[m >> 2] | 0;
l = b + 112 | 0;
if ((e | 0) != 0)
c[e + 112 >> 2] = c[l >> 2];
e = c[l >> 2] | 0;
if ((e | 0) != 0)
c[e + 108 >> 2] = c[m >> 2];
m = a + 102960 | 0;
if ((c[m >> 2] | 0) == (b | 0))
c[m >> 2] = c[l >> 2];
l = a + 102972 | 0;
c[l >> 2] = (c[l >> 2] | 0) + -1;
Ij(b);
Fm(a, b, 168);
i = d;
return
}
function xj(d, f) {
d = d | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
h = i;
if ((c[d + 102876 >> 2] & 2 | 0) != 0) {
i = h;
return
}
j = a[f + 61 >> 0] | 0;
k = f + 8 | 0;
l = c[k >> 2] | 0;
m = f + 12 | 0;
if ((l | 0) != 0)
c[l + 12 >> 2] =
c[m >> 2];
l = c[m >> 2] | 0;
if ((l | 0) != 0)
c[l + 8 >> 2] = c[k >> 2];
k = d + 102964 | 0;
if ((c[k >> 2] | 0) == (f | 0))
c[k >> 2] = c[m >> 2];
m = c[f + 48 >> 2] | 0;
k = c[f + 52 >> 2] | 0;
l = m + 4 | 0;
n = e[l >> 1] | 0;
if ((n & 2 | 0) == 0) {
b[l >> 1] = n | 2;
g[m + 160 >> 2] = 0
}
n = k + 4 | 0;
l = e[n >> 1] | 0;
if ((l & 2 | 0) == 0) {
b[n >> 1] = l | 2;
g[k + 160 >> 2] = 0
}
l = f + 24 | 0;
n = c[l >> 2] | 0;
o = f + 28 | 0;
if ((n | 0) != 0)
c[n + 12 >> 2] = c[o >> 2];
n = c[o >> 2] | 0;
if ((n | 0) != 0)
c[n + 8 >> 2] = c[l >> 2];
n = m + 124 | 0;
if ((f + 16 | 0) == (c[n >> 2] | 0))
c[n >> 2] = c[o >> 2];
c[l >> 2] = 0;
c[o >> 2] = 0;
o = f + 40 | 0;
l = c[o >> 2] | 0;
n = f + 44 | 0;
if ((l | 0) != 0)
c[l + 12 >> 2] = c[n >> 2];
l = c[n >> 2] | 0;
if ((l |
0) != 0)
c[l + 8 >> 2] = c[o >> 2];
l = k + 124 | 0;
if ((f + 32 | 0) == (c[l >> 2] | 0))
c[l >> 2] = c[n >> 2];
c[o >> 2] = 0;
c[n >> 2] = 0;
uh(f, d);
f = d + 102976 | 0;
c[f >> 2] = (c[f >> 2] | 0) + -1;
if (!(j << 24 >> 24 == 0)) {
i = h;
return
}
j = c[k + 128 >> 2] | 0;
if ((j | 0) == 0) {
i = h;
return
} else
p = j;
do {
if ((c[p >> 2] | 0) == (m | 0)) {
j = (c[p + 4 >> 2] | 0) + 4 | 0;
c[j >> 2] = c[j >> 2] | 8
}
p = c[p + 12 >> 2] | 0
} while ((p | 0) != 0);
i = h;
return
}
function yj(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
e = i;
if ((c[b + 102876 >> 2] & 2 | 0) != 0) {
f = 0;
i = e;
return f | 0
}
g = th(d, b) | 0;
c[g + 8 >> 2] = 0;
h = b + 102964 | 0;
c[g + 12 >> 2] =
c[h >> 2];
j = c[h >> 2] | 0;
if ((j | 0) != 0)
c[j + 8 >> 2] = g;
c[h >> 2] = g;
h = b + 102976 | 0;
c[h >> 2] = (c[h >> 2] | 0) + 1;
h = g + 16 | 0;
c[g + 20 >> 2] = g;
b = g + 52 | 0;
c[h >> 2] = c[b >> 2];
c[g + 24 >> 2] = 0;
j = g + 48 | 0;
k = c[j >> 2] | 0;
l = k + 124 | 0;
c[g + 28 >> 2] = c[l >> 2];
m = c[l >> 2] | 0;
if ((m | 0) == 0)
n = k;
else {
c[m + 8 >> 2] = h;
n = c[j >> 2] | 0
}
c[n + 124 >> 2] = h;
h = g + 32 | 0;
c[g + 36 >> 2] = g;
c[h >> 2] = c[j >> 2];
c[g + 40 >> 2] = 0;
j = c[b >> 2] | 0;
n = j + 124 | 0;
c[g + 44 >> 2] = c[n >> 2];
m = c[n >> 2] | 0;
if ((m | 0) == 0)
o = j;
else {
c[m + 8 >> 2] = h;
o = c[b >> 2] | 0
}
c[o + 124 >> 2] = h;
h = c[d + 8 >> 2] | 0;
if ((a[d + 16 >> 0] | 0) != 0) {
f = g;
i = e;
return f | 0
}
o = c[(c[d + 12 >>
2] | 0) + 128 >> 2] | 0;
if ((o | 0) == 0) {
f = g;
i = e;
return f | 0
} else
p = o;
do {
if ((c[p >> 2] | 0) == (h | 0)) {
o = (c[p + 4 >> 2] | 0) + 4 | 0;
c[o >> 2] = c[o >> 2] | 8
}
p = c[p + 12 >> 2] | 0
} while ((p | 0) != 0);
f = g;
i = e;
return f | 0
}
function zj(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0;
d = i;
if ((c[a + 102876 >> 2] & 2 | 0) != 0) {
e = 0;
i = d;
return e | 0
}
f = Em(a, 416) | 0;
if ((f | 0) == 0)
g = 0;
else {
rk(f, b, a);
g = f
}
c[g + 404 >> 2] = 0;
f = a + 102968 | 0;
c[g + 408 >> 2] = c[f >> 2];
a = c[f >> 2] | 0;
if ((a | 0) != 0)
c[a + 404 >> 2] = g;
c[f >> 2] = g;
e = g;
i = d;
return e | 0
}
function Aj(d, f) {
d = d | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q =
0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0;
h = i;
i = i + 96 | 0;
j = h + 40 | 0;
k = h + 8 | 0;
l = h;
m = d + 102960 | 0;
n = c[m >> 2] | 0;
if ((n | 0) != 0) {
o = n;
do {
n = o + 28 | 0;
p = o + 12 | 0;
c[n + 0 >> 2] = c[p + 0 >> 2];
c[n + 4 >> 2] = c[p + 4 >> 2];
c[n + 8 >> 2] = c[p + 8 >> 2];
c[n + 12 >> 2] = c[p + 12 >> 2];
o = c[o + 112 >> 2] | 0
} while ((o | 0) != 0)
}
o = d + 103020 | 0;
g[o >> 2] = 0;
p = d + 103024 | 0;
g[p >> 2] = 0;
n = d + 103028 | 0;
g[n >> 2] = 0;
q = d + 102972 | 0;
r = d + 102880 | 0;
s = d + 76 | 0;
mf(j, c[q >> 2] | 0, c[d + 102944 >> 2] | 0, c[d + 102976 >> 2] | 0, s, c[d +
102952 >> 2] | 0);
t = c[m >> 2] | 0;
if ((t | 0) != 0) {
u = t;
do {
t = u + 4 | 0;
b[t >> 1] = b[t >> 1] & 65534;
u = c[u + 112 >> 2] | 0
} while ((u | 0) != 0)
}
u = c[d + 102940 >> 2] | 0;
if ((u | 0) != 0) {
t = u;
do {
u = t + 4 | 0;
c[u >> 2] = c[u >> 2] & -2;
t = c[t + 12 >> 2] | 0
} while ((t | 0) != 0)
}
t = c[d + 102964 >> 2] | 0;
if ((t | 0) != 0) {
u = t;
do {
a[u + 60 >> 0] = 0;
u = c[u + 12 >> 2] | 0
} while ((u | 0) != 0)
}
u = Ym(s, c[q >> 2] << 2) | 0;
q = c[m >> 2] | 0;
if ((q | 0) != 0) {
t = j + 28 | 0;
v = j + 36 | 0;
w = j + 32 | 0;
x = j + 8 | 0;
y = j + 16 | 0;
z = j + 12 | 0;
A = d + 102980 | 0;
B = d + 102988 | 0;
C = k + 12 | 0;
D = k + 16 | 0;
E = k + 20 | 0;
F = q;
do {
q = F + 4 | 0;
G = b[q >> 1] | 0;
if ((G & 35) == 34 ? (c[F >> 2] | 0) != 0 : 0) {
c[t >>
2] = 0;
c[v >> 2] = 0;
c[w >> 2] = 0;
c[u >> 2] = F;
b[q >> 1] = G & 65535 | 1;
G = 0;
q = 1;
while (1) {
H = q + -1 | 0;
I = c[u + (H << 2) >> 2] | 0;
c[I + 8 >> 2] = G;
J = c[t >> 2] | 0;
c[(c[x >> 2] | 0) + (J << 2) >> 2] = I;
c[t >> 2] = J + 1;
J = I + 4 | 0;
K = e[J >> 1] | 0;
if ((K & 2 | 0) == 0) {
b[J >> 1] = K | 2;
g[I + 160 >> 2] = 0
}
if ((c[I >> 2] | 0) != 0) {
K = c[I + 128 >> 2] | 0;
if ((K | 0) == 0)
L = H;
else {
J = K;
K = H;
while (1) {
M = c[J + 4 >> 2] | 0;
N = M + 4 | 0;
do if ((c[N >> 2] & 7 | 0) == 6 ? (a[(c[M + 48 >> 2] | 0) + 38 >> 0] | 0) == 0 : 0) {
if ((a[(c[M + 52 >> 2] | 0) + 38 >> 0] | 0) != 0) {
O = K;
break
}
P = c[v >> 2] | 0;
c[v >> 2] = P + 1;
c[(c[z >> 2] | 0) + (P << 2) >> 2] = M;
c[N >> 2] = c[N >> 2] | 1;
P = c[J >> 2] | 0;
Q =
P + 4 | 0;
R = b[Q >> 1] | 0;
if (!((R & 1) == 0)) {
O = K;
break
}
c[u + (K << 2) >> 2] = P;
b[Q >> 1] = R & 65535 | 1;
O = K + 1 | 0
} else
O = K;
while (0);
J = c[J + 12 >> 2] | 0;
if ((J | 0) == 0) {
L = O;
break
} else
K = O
}
}
K = c[I + 124 >> 2] | 0;
if ((K | 0) == 0)
S = L;
else {
J = K;
K = L;
while (1) {
N = J + 4 | 0;
M = c[N >> 2] | 0;
do if ((a[M + 60 >> 0] | 0) == 0 ? (R = c[J >> 2] | 0, Q = R + 4 | 0, P = b[Q >> 1] | 0, !((P & 32) == 0)) : 0) {
T = c[w >> 2] | 0;
c[w >> 2] = T + 1;
c[(c[y >> 2] | 0) + (T << 2) >> 2] = M;
a[(c[N >> 2] | 0) + 60 >> 0] = 1;
if (!((P & 1) == 0)) {
U = K;
break
}
c[u + (K << 2) >> 2] = R;
b[Q >> 1] = P & 65535 | 1;
U = K + 1 | 0
} else
U = K;
while (0);
J = c[J + 12 >> 2] | 0;
if ((J | 0) == 0) {
S = U;
break
} else
K =
U
}
}
} else
S = H;
if ((S | 0) <= 0)
break;
G = c[t >> 2] | 0;
q = S
}
of(j, k, f, A, (a[B >> 0] | 0) != 0);
g[o >> 2] = +g[C >> 2] + +g[o >> 2];
g[p >> 2] = +g[D >> 2] + +g[p >> 2];
g[n >> 2] = +g[E >> 2] + +g[n >> 2];
q = c[t >> 2] | 0;
if ((q | 0) > 0) {
G = c[x >> 2] | 0;
K = 0;
do {
J = c[G + (K << 2) >> 2] | 0;
if ((c[J >> 2] | 0) == 0) {
I = J + 4 | 0;
b[I >> 1] = b[I >> 1] & 65534
}
K = K + 1 | 0
} while ((K | 0) < (q | 0))
}
}
F = c[F + 112 >> 2] | 0
} while ((F | 0) != 0)
}
_m(s, u);
Km(l);
u = c[m >> 2] | 0;
if ((u | 0) == 0) {
Vj(r);
V = +Mm(l);
W = d + 103032 | 0;
g[W >> 2] = V;
nf(j);
i = h;
return
} else
X = u;
do {
if (!((b[X + 4 >> 1] & 1) == 0) ? (c[X >> 2] | 0) != 0 : 0)
Lj(X);
X = c[X + 112 >> 2] | 0
} while ((X |
0) != 0);
Vj(r);
V = +Mm(l);
W = d + 103032 | 0;
g[W >> 2] = V;
nf(j);
i = h;
return
}
function Bj(d, f) {
d = d | 0;
f = f | 0;
var h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0,
ya = 0,
za = 0,
Aa = 0,
Ba = 0,
Ca = 0,
Da = 0,
Ea = 0,
Fa = 0,
Ga = 0,
Ha = 0,
Ia = 0,
Ja = 0,
Ka = 0,
La = 0,
Ma = 0,
Na = 0,
Oa = 0,
Pa = 0,
Qa = 0,
Ra = 0,
Sa = 0,
Ta = 0,
Ua = 0,
Va = 0,
Wa = 0,
Xa = 0,
Ya = 0,
Za = 0;
h = i;
i = i + 336 | 0;
j = h + 284 | 0;
l = h + 152 | 0;
m = h + 144 | 0;
n = h + 108 | 0;
o = h + 72 | 0;
p = h + 64 | 0;
q = h + 28 | 0;
r = h;
s = d + 102880 | 0;
t = d + 102952 | 0;
mf(j, 64, 32, 0, d + 76 | 0, c[t >> 2] | 0);
u = d + 103007 | 0;
if ((a[u >> 0] | 0) != 0) {
v = c[d + 102960 >> 2] | 0;
if ((v | 0) != 0) {
w = v;
do {
v = w + 4 | 0;
b[v >> 1] = b[v >> 1] & 65534;
g[w + 76 >> 2] = 0;
w = c[w + 112 >> 2] | 0
} while ((w | 0) != 0)
}
w = d + 102940 | 0;
v = c[w >> 2] | 0;
if ((v | 0) == 0)
x = w;
else {
y = v;
do {
v = y + 4 | 0;
c[v >> 2] = c[v >> 2] & -34;
c[y + 128 >> 2] = 0;
g[y + 132 >> 2] = 1;
y = c[y + 12 >> 2] | 0
} while ((y | 0) != 0);
x = w
}
} else
x = d + 102940 | 0;
w = j + 28 | 0;
y = j + 36 | 0;
v = j + 32 |
0;
z = j + 8 | 0;
A = j + 12 | 0;
B = p + 4 | 0;
C = j + 40 | 0;
D = j + 44 | 0;
E = r + 4 | 0;
F = r + 8 | 0;
G = r + 16 | 0;
H = f + 12 | 0;
I = r + 12 | 0;
J = f + 20 | 0;
K = r + 20 | 0;
L = r + 24 | 0;
M = d + 103006 | 0;
d = l + 16 | 0;
N = l + 20 | 0;
O = l + 24 | 0;
P = l + 44 | 0;
Q = l + 48 | 0;
R = l + 52 | 0;
U = l + 28 | 0;
V = l + 56 | 0;
W = l + 92 | 0;
X = l + 128 | 0;
Y = m + 4 | 0;
while (1) {
Z = c[x >> 2] | 0;
if ((Z | 0) == 0) {
_ = 28;
break
} else {
$ = Z;
aa = 1;
ba = 0
}
while (1) {
Z = $ + 4 | 0;
ca = c[Z >> 2] | 0;
do if ((ca & 4 | 0) != 0 ? (c[$ + 128 >> 2] | 0) <= 8 : 0) {
if ((ca & 32 | 0) == 0) {
da = c[$ + 48 >> 2] | 0;
ea = c[$ + 52 >> 2] | 0;
if ((a[da + 38 >> 0] | 0) != 0) {
fa = aa;
ga = ba;
break
}
if ((a[ea + 38 >> 0] | 0) != 0) {
fa = aa;
ga = ba;
break
}
ha = c[da + 8 >>
2] | 0;
ia = c[ea + 8 >> 2] | 0;
ja = c[ha >> 2] | 0;
ka = c[ia >> 2] | 0;
la = b[ha + 4 >> 1] | 0;
ma = b[ia + 4 >> 1] | 0;
if (!((la & 2) != 0 & (ja | 0) != 0 | (ma & 2) != 0 & (ka | 0) != 0)) {
fa = aa;
ga = ba;
break
}
if (!((la & 8) != 0 | (ja | 0) != 2 | ((ma & 8) != 0 | (ka | 0) != 2))) {
fa = aa;
ga = ba;
break
}
ka = ha + 44 | 0;
ma = ha + 76 | 0;
na = +g[ma >> 2];
ja = ia + 44 | 0;
la = ia + 76 | 0;
oa = +g[la >> 2];
if (!(na < oa))
if (oa < na) {
pa = (na - oa) / (1 - oa);
qa = ia + 52 | 0;
ra = +g[qa >> 2];
sa = ia + 56 | 0;
ta = +g[sa >> 2];
ua = pa * (+g[ia + 64 >> 2] - ta);
g[qa >> 2] = ra + pa * (+g[ia + 60 >> 2] - ra);
g[sa >> 2] = ta + ua;
sa = ia + 68 | 0;
ua = +g[sa >> 2];
g[sa >> 2] = ua + pa * (+g[ia + 72 >> 2] - ua);
g[la >>
2] = na;
va = na
} else
va = na;
else {
ua = (oa - na) / (1 - na);
la = ha + 52 | 0;
na = +g[la >> 2];
ia = ha + 56 | 0;
pa = +g[ia >> 2];
ta = ua * (+g[ha + 64 >> 2] - pa);
g[la >> 2] = na + ua * (+g[ha + 60 >> 2] - na);
g[ia >> 2] = pa + ta;
ia = ha + 68 | 0;
ta = +g[ia >> 2];
g[ia >> 2] = ta + ua * (+g[ha + 72 >> 2] - ta);
g[ma >> 2] = oa;
va = oa
}
ma = c[$ + 56 >> 2] | 0;
ha = c[$ + 60 >> 2] | 0;
c[d >> 2] = 0;
c[N >> 2] = 0;
g[O >> 2] = 0;
c[P >> 2] = 0;
c[Q >> 2] = 0;
g[R >> 2] = 0;
be(l, c[da + 12 >> 2] | 0, ma);
be(U, c[ea + 12 >> 2] | 0, ha);
wa = V + 0 | 0;
xa = ka + 0 | 0;
ya = wa + 36 | 0;
do {
c[wa >> 2] = c[xa >> 2];
wa = wa + 4 | 0;
xa = xa + 4 | 0
} while ((wa | 0) < (ya | 0));
wa = W + 0 | 0;
xa = ja + 0 | 0;
ya = wa + 36 | 0;
do {
c[wa >> 2] = c[xa >> 2];
wa = wa + 4 | 0;
xa = xa + 4 | 0
} while ((wa | 0) < (ya | 0));
g[X >> 2] = 1;
Zd(m, l);
if ((c[m >> 2] | 0) == 3) {
oa = va + (1 - va) * +g[Y >> 2];
za = oa < 1 ? oa : 1
} else
za = 1;
g[$ + 132 >> 2] = za;
c[Z >> 2] = c[Z >> 2] | 32;
Aa = za
} else
Aa = +g[$ + 132 >> 2];
if (Aa < aa) {
fa = Aa;
ga = $
} else {
fa = aa;
ga = ba
}
} else {
fa = aa;
ga = ba
}
while (0);
$ = c[$ + 12 >> 2] | 0;
if (($ | 0) == 0)
break;
else {
aa = fa;
ba = ga
}
}
if ((ga | 0) == 0 | fa > .9999988079071045) {
_ = 28;
break
}
Z = c[(c[ga + 48 >> 2] | 0) + 8 >> 2] | 0;
ca = c[(c[ga + 52 >> 2] | 0) + 8 >> 2] | 0;
ja = Z + 44 | 0;
wa = n + 0 | 0;
xa = ja + 0 | 0;
ya = wa + 36 | 0;
do {
c[wa >> 2] = c[xa >> 2];
wa = wa + 4 | 0;
xa = xa +
4 | 0
} while ((wa | 0) < (ya | 0));
ka = ca + 44 | 0;
wa = o + 0 | 0;
xa = ka + 0 | 0;
ya = wa + 36 | 0;
do {
c[wa >> 2] = c[xa >> 2];
wa = wa + 4 | 0;
xa = xa + 4 | 0
} while ((wa | 0) < (ya | 0));
ha = Z + 76 | 0;
oa = +g[ha >> 2];
ta = (fa - oa) / (1 - oa);
ea = Z + 60 | 0;
ma = Z + 52 | 0;
oa = +g[ma >> 2];
da = Z + 64 | 0;
ia = Z + 56 | 0;
ua = +g[ia >> 2];
pa = ta * (+g[da >> 2] - ua);
g[ma >> 2] = oa + ta * (+g[ea >> 2] - oa);
g[ia >> 2] = ua + pa;
ia = Z + 72 | 0;
ma = Z + 68 | 0;
pa = +g[ma >> 2];
ua = pa + ta * (+g[ia >> 2] - pa);
g[ma >> 2] = ua;
g[ha >> 2] = fa;
ha = Z + 52 | 0;
ma = c[ha >> 2] | 0;
la = c[ha + 4 >> 2] | 0;
ha = Z + 60 | 0;
c[ha >> 2] = ma;
c[ha + 4 >> 2] = la;
g[ia >> 2] = ua;
pa = +T(+ua);
ha = Z + 20 | 0;
g[ha >> 2] = pa;
ta = +S(+ua);
sa = Z + 24 | 0;
g[sa >> 2] = ta;
qa = Z + 12 | 0;
Ba = Z + 44 | 0;
ua = +g[Ba >> 2];
Ca = Z + 48 | 0;
oa = +g[Ca >> 2];
na = (c[k >> 2] = ma, +g[k >> 2]) - (ta * ua - pa * oa);
ra = (c[k >> 2] = la, +g[k >> 2]) - (pa * ua + ta * oa);
oa = +na;
na = +ra;
la = qa;
g[la >> 2] = oa;
g[la + 4 >> 2] = na;
la = ca + 76 | 0;
na = +g[la >> 2];
oa = (fa - na) / (1 - na);
ma = ca + 60 | 0;
Da = ca + 52 | 0;
na = +g[Da >> 2];
Ea = ca + 64 | 0;
Fa = ca + 56 | 0;
ra = +g[Fa >> 2];
ta = oa * (+g[Ea >> 2] - ra);
g[Da >> 2] = na + oa * (+g[ma >> 2] - na);
g[Fa >> 2] = ra + ta;
Fa = ca + 72 | 0;
Da = ca + 68 | 0;
ta = +g[Da >> 2];
ra = ta + oa * (+g[Fa >> 2] - ta);
g[Da >> 2] = ra;
g[la >> 2] = fa;
la = ca + 52 | 0;
Da = c[la >> 2] | 0;
Ga =
c[la + 4 >> 2] | 0;
la = ca + 60 | 0;
c[la >> 2] = Da;
c[la + 4 >> 2] = Ga;
g[Fa >> 2] = ra;
ta = +T(+ra);
la = ca + 20 | 0;
g[la >> 2] = ta;
oa = +S(+ra);
Ha = ca + 24 | 0;
g[Ha >> 2] = oa;
Ia = ca + 12 | 0;
Ja = ca + 44 | 0;
ra = +g[Ja >> 2];
Ka = ca + 48 | 0;
na = +g[Ka >> 2];
ua = (c[k >> 2] = Da, +g[k >> 2]) - (oa * ra - ta * na);
pa = (c[k >> 2] = Ga, +g[k >> 2]) - (ta * ra + oa * na);
na = +ua;
ua = +pa;
Ga = Ia;
g[Ga >> 2] = na;
g[Ga + 4 >> 2] = ua;
xi(ga, c[t >> 2] | 0);
Ga = ga + 4 | 0;
Da = c[Ga >> 2] | 0;
c[Ga >> 2] = Da & -33;
La = ga + 128 | 0;
c[La >> 2] = (c[La >> 2] | 0) + 1;
if ((Da & 6 | 0) != 6) {
c[Ga >> 2] = Da & -37;
wa = ja + 0 | 0;
xa = n + 0 | 0;
ya = wa + 36 | 0;
do {
c[wa >> 2] = c[xa >> 2];
wa = wa + 4 | 0;
xa =
xa + 4 | 0
} while ((wa | 0) < (ya | 0));
wa = ka + 0 | 0;
xa = o + 0 | 0;
ya = wa + 36 | 0;
do {
c[wa >> 2] = c[xa >> 2];
wa = wa + 4 | 0;
xa = xa + 4 | 0
} while ((wa | 0) < (ya | 0));
ua = +g[ia >> 2];
na = +T(+ua);
g[ha >> 2] = na;
pa = +S(+ua);
g[sa >> 2] = pa;
ua = +g[Ba >> 2];
oa = +g[Ca >> 2];
ra = +(+g[ea >> 2] - (pa * ua - na * oa));
ta = +(+g[da >> 2] - (na * ua + pa * oa));
ka = qa;
g[ka >> 2] = ra;
g[ka + 4 >> 2] = ta;
ta = +g[Fa >> 2];
ra = +T(+ta);
g[la >> 2] = ra;
oa = +S(+ta);
g[Ha >> 2] = oa;
ta = +g[Ja >> 2];
pa = +g[Ka >> 2];
ua = +(+g[ma >> 2] - (oa * ta - ra * pa));
na = +(+g[Ea >> 2] - (ra * ta + oa * pa));
ka = Ia;
g[ka >> 2] = ua;
g[ka + 4 >> 2] = na;
continue
}
ka = Z + 4 | 0;
ja = b[ka >>
1] | 0;
Da = ja & 65535;
if ((Da & 2 | 0) == 0) {
La = (Da | 2) & 65535;
b[ka >> 1] = La;
g[Z + 160 >> 2] = 0;
Ma = La
} else
Ma = ja;
ja = ca + 4 | 0;
La = e[ja >> 1] | 0;
if ((La & 2 | 0) == 0) {
b[ja >> 1] = La | 2;
g[ca + 160 >> 2] = 0;
Na = b[ka >> 1] | 0
} else
Na = Ma;
c[w >> 2] = 0;
c[y >> 2] = 0;
c[v >> 2] = 0;
La = Z + 8 | 0;
c[La >> 2] = 0;
Da = c[w >> 2] | 0;
c[(c[z >> 2] | 0) + (Da << 2) >> 2] = Z;
Oa = Da + 1 | 0;
c[w >> 2] = Oa;
Da = ca + 8 | 0;
c[Da >> 2] = Oa;
Oa = c[w >> 2] | 0;
c[(c[z >> 2] | 0) + (Oa << 2) >> 2] = ca;
c[w >> 2] = Oa + 1;
Oa = c[y >> 2] | 0;
c[y >> 2] = Oa + 1;
c[(c[A >> 2] | 0) + (Oa << 2) >> 2] = ga;
b[ka >> 1] = Na & 65535 | 1;
b[ja >> 1] = e[ja >> 1] | 1;
c[Ga >> 2] = c[Ga >> 2] | 1;
c[p >> 2] = Z;
c[B >>
2] = ca;
ja = Z;
ka = 1;
while (1) {
a:
do if ((c[ja >> 2] | 0) == 2 ? (Oa = c[ja + 128 >> 2] | 0, (Oa | 0) != 0) : 0) {
Pa = ja + 4 | 0;
Qa = Oa;
do {
if ((c[w >> 2] | 0) == (c[C >> 2] | 0))
break a;
if ((c[y >> 2] | 0) == (c[D >> 2] | 0))
break a;
Oa = c[Qa + 4 >> 2] | 0;
Ra = Oa + 4 | 0;
do if ((c[Ra >> 2] & 1 | 0) == 0) {
Sa = c[Qa >> 2] | 0;
if (((c[Sa >> 2] | 0) == 2 ? (b[Pa >> 1] & 8) == 0 : 0) ? (b[Sa + 4 >> 1] & 8) == 0 : 0)
break;
if ((a[(c[Oa + 48 >> 2] | 0) + 38 >> 0] | 0) == 0 ? (a[(c[Oa + 52 >> 2] | 0) + 38 >> 0] | 0) == 0 : 0) {
Ta = Sa + 44 | 0;
wa = q + 0 | 0;
xa = Ta + 0 | 0;
ya = wa + 36 | 0;
do {
c[wa >> 2] = c[xa >> 2];
wa = wa + 4 | 0;
xa = xa + 4 | 0
} while ((wa | 0) < (ya | 0));
Ua = Sa + 4 | 0;
if ((b[Ua >> 1] & 1) ==
0) {
Va = Sa + 76 | 0;
na = +g[Va >> 2];
ua = (fa - na) / (1 - na);
Wa = Sa + 52 | 0;
na = +g[Wa >> 2];
Xa = Sa + 56 | 0;
pa = +g[Xa >> 2];
oa = ua * (+g[Sa + 64 >> 2] - pa);
g[Wa >> 2] = na + ua * (+g[Sa + 60 >> 2] - na);
g[Xa >> 2] = pa + oa;
Xa = Sa + 72 | 0;
Wa = Sa + 68 | 0;
oa = +g[Wa >> 2];
pa = oa + ua * (+g[Xa >> 2] - oa);
g[Wa >> 2] = pa;
g[Va >> 2] = fa;
Va = Sa + 52 | 0;
Wa = c[Va >> 2] | 0;
Ya = c[Va + 4 >> 2] | 0;
Va = Sa + 60 | 0;
c[Va >> 2] = Wa;
c[Va + 4 >> 2] = Ya;
g[Xa >> 2] = pa;
oa = +T(+pa);
g[Sa + 20 >> 2] = oa;
ua = +S(+pa);
g[Sa + 24 >> 2] = ua;
pa = +g[Sa + 44 >> 2];
na = +g[Sa + 48 >> 2];
ta = (c[k >> 2] = Wa, +g[k >> 2]) - (ua * pa - oa * na);
ra = (c[k >> 2] = Ya, +g[k >> 2]) - (oa * pa + ua * na);
na =
+ta;
ta = +ra;
Ya = Sa + 12 | 0;
g[Ya >> 2] = na;
g[Ya + 4 >> 2] = ta
}
xi(Oa, c[t >> 2] | 0);
Ya = c[Ra >> 2] | 0;
if ((Ya & 4 | 0) == 0) {
wa = Ta + 0 | 0;
xa = q + 0 | 0;
ya = wa + 36 | 0;
do {
c[wa >> 2] = c[xa >> 2];
wa = wa + 4 | 0;
xa = xa + 4 | 0
} while ((wa | 0) < (ya | 0));
ta = +g[Sa + 72 >> 2];
na = +T(+ta);
g[Sa + 20 >> 2] = na;
ra = +S(+ta);
g[Sa + 24 >> 2] = ra;
ta = +g[Sa + 44 >> 2];
ua = +g[Sa + 48 >> 2];
pa = +(+g[Sa + 60 >> 2] - (ra * ta - na * ua));
oa = +(+g[Sa + 64 >> 2] - (na * ta + ra * ua));
Wa = Sa + 12 | 0;
g[Wa >> 2] = pa;
g[Wa + 4 >> 2] = oa;
break
}
if ((Ya & 2 | 0) == 0) {
wa = Ta + 0 | 0;
xa = q + 0 | 0;
ya = wa + 36 | 0;
do {
c[wa >> 2] = c[xa >> 2];
wa = wa + 4 | 0;
xa = xa + 4 | 0
} while ((wa | 0) < (ya | 0));
oa = +g[Sa + 72 >> 2];
pa = +T(+oa);
g[Sa + 20 >> 2] = pa;
ua = +S(+oa);
g[Sa + 24 >> 2] = ua;
oa = +g[Sa + 44 >> 2];
ra = +g[Sa + 48 >> 2];
ta = +(+g[Sa + 60 >> 2] - (ua * oa - pa * ra));
na = +(+g[Sa + 64 >> 2] - (pa * oa + ua * ra));
Ta = Sa + 12 | 0;
g[Ta >> 2] = ta;
g[Ta + 4 >> 2] = na;
break
}
c[Ra >> 2] = Ya | 1;
Ta = c[y >> 2] | 0;
c[y >> 2] = Ta + 1;
c[(c[A >> 2] | 0) + (Ta << 2) >> 2] = Oa;
Ta = e[Ua >> 1] | 0;
if ((Ta & 1 | 0) != 0)
break;
b[Ua >> 1] = Ta | 1;
do if ((c[Sa >> 2] | 0) != 0) {
if ((Ta & 2 | 0) != 0)
break;
b[Ua >> 1] = Ta | 3;
g[Sa + 160 >> 2] = 0
}
while (0);
c[Sa + 8 >> 2] = c[w >> 2];
Ta = c[w >> 2] | 0;
c[(c[z >> 2] | 0) + (Ta << 2) >> 2] = Sa;
c[w >> 2] = Ta + 1
}
}
while (0);
Qa = c[Qa +
12 >> 2] | 0
} while ((Qa | 0) != 0)
}
while (0);
if ((ka | 0) >= 2)
break;
ja = c[p + (ka << 2) >> 2] | 0;
ka = ka + 1 | 0
}
na = (1 - fa) * +g[f >> 2];
g[r >> 2] = na;
g[E >> 2] = 1 / na;
g[F >> 2] = 1;
c[G >> 2] = 20;
c[I >> 2] = c[H >> 2];
c[K >> 2] = c[J >> 2];
a[L >> 0] = 0;
pf(j, r, c[La >> 2] | 0, c[Da >> 2] | 0);
ka = c[w >> 2] | 0;
if ((ka | 0) > 0) {
ja = ka;
ka = 0;
while (1) {
Z = c[(c[z >> 2] | 0) + (ka << 2) >> 2] | 0;
ca = Z + 4 | 0;
b[ca >> 1] = b[ca >> 1] & 65534;
if ((c[Z >> 2] | 0) == 2) {
Lj(Z);
ca = c[Z + 128 >> 2] | 0;
if ((ca | 0) != 0) {
Z = ca;
do {
ca = (c[Z + 4 >> 2] | 0) + 4 | 0;
c[ca >> 2] = c[ca >> 2] & -34;
Z = c[Z + 12 >> 2] | 0
} while ((Z | 0) != 0)
}
Za = c[w >> 2] | 0
} else
Za = ja;
ka = ka + 1 | 0;
if ((ka | 0) >= (Za | 0))
break;
else
ja = Za
}
}
Vj(s);
if ((a[M >> 0] | 0) != 0) {
_ = 68;
break
}
}
if ((_ | 0) == 28) {
a[u >> 0] = 1;
nf(j);
i = h;
return
} else if ((_ | 0) == 68) {
a[u >> 0] = 0;
nf(j);
i = h;
return
}
}
function Cj(b, d, e, f, h) {
b = b | 0;
d = +d;
e = e | 0;
f = f | 0;
h = h | 0;
var j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0;
j = i;
i = i + 64 | 0;
k = j + 24 | 0;
l = j + 32 | 0;
m = j + 16 | 0;
n = j + 8 | 0;
o = j;
Km(k);
p = b + 102876 | 0;
q = c[p >> 2] | 0;
if ((q & 1 | 0) == 0)
r = q;
else {
Vj(b + 102880 | 0);
q = c[p >> 2] & -2;
c[p >> 2] = q;
r = q
}
c[p >> 2] = r | 2;
g[l >> 2] = d;
c[l + 12 >> 2] = e;
c[l + 16 >> 2] = f;
c[l + 20 >> 2] = h;
if (d > 0)
g[l + 4 >> 2] =
1 / d;
else
g[l + 4 >> 2] = 0;
h = b + 103E3 | 0;
g[l + 8 >> 2] = +g[h >> 2] * d;
a[l + 24 >> 0] = a[b + 103004 >> 0] | 0;
Km(m);
Uj(b + 102880 | 0);
g[b + 103012 >> 2] = +Mm(m);
if ((a[b + 103007 >> 0] | 0) != 0 ? +g[l >> 2] > 0 : 0) {
Km(n);
m = c[b + 102968 >> 2] | 0;
if ((m | 0) != 0) {
f = m;
do {
bl(f, l);
f = c[f + 408 >> 2] | 0
} while ((f | 0) != 0)
}
Aj(b, l);
g[b + 103016 >> 2] = +Mm(n)
}
if ((a[b + 103005 >> 0] | 0) != 0) {
d = +g[l >> 2];
if (d > 0) {
Km(o);
Bj(b, l);
g[b + 103036 >> 2] = +Mm(o);
s = 14
} else
t = d
} else
s = 14;
if ((s | 0) == 14)
t = +g[l >> 2];
if (t > 0)
g[h >> 2] = +g[l + 4 >> 2];
l = c[p >> 2] | 0;
if ((l & 4 | 0) == 0) {
u = l & -3;
c[p >> 2] = u;
v = +Mm(k);
w = b + 103008 | 0;
g[w >>
2] = v;
i = j;
return
}
h = c[b + 102960 >> 2] | 0;
if ((h | 0) == 0) {
u = l & -3;
c[p >> 2] = u;
v = +Mm(k);
w = b + 103008 | 0;
g[w >> 2] = v;
i = j;
return
} else
x = h;
do {
g[x + 92 >> 2] = 0;
g[x + 96 >> 2] = 0;
g[x + 100 >> 2] = 0;
x = c[x + 112 >> 2] | 0
} while ((x | 0) != 0);
u = l & -3;
c[p >> 2] = u;
v = +Mm(k);
w = b + 103008 | 0;
g[w >> 2] = v;
i = j;
return
}
function Dj(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0;
e = i;
i = i + 16 | 0;
f = e;
g = a + 102880 | 0;
c[f >> 2] = g;
c[f + 4 >> 2] = b;
Gj(g, f, d);
f = c[a + 102968 >> 2] | 0;
if ((f | 0) == 0) {
i = e;
return
}
a = f;
do {
if (nb[c[(c[b >> 2] | 0) + 16 >> 2] & 31](b, a) | 0)
pl(a, b, d);
a = c[a + 408 >> 2] | 0
} while ((a | 0) != 0);
i = e;
return
}
function Ej(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0;
f = i;
i = i + 32 | 0;
h = f + 24 | 0;
j = f;
k = a + 102880 | 0;
c[h >> 2] = k;
c[h + 4 >> 2] = b;
g[j + 16 >> 2] = 1;
l = d;
m = c[l + 4 >> 2] | 0;
n = j;
c[n >> 2] = c[l >> 2];
c[n + 4 >> 2] = m;
m = e;
n = c[m + 4 >> 2] | 0;
l = j + 8 | 0;
c[l >> 2] = c[m >> 2];
c[l + 4 >> 2] = n;
Fj(k, h, j);
j = c[a + 102968 >> 2] | 0;
if ((j | 0) == 0) {
i = f;
return
}
a = j;
do {
if (nb[c[(c[b >> 2] | 0) + 16 >> 2] & 31](b, a) | 0)
ql(a, b, d, e);
a = c[a + 408 >> 2] | 0
} while ((a | 0) != 0);
i = f;
return
}
function Fj(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r =
0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0;
e = i;
i = i + 1088 | 0;
f = e + 1064 | 0;
h = e + 1056 | 0;
j = e + 20 | 0;
k = e;
l = d;
m = +g[l >> 2];
n = +g[l + 4 >> 2];
l = d + 8 | 0;
o = l;
p = +g[o >> 2];
q = p - m;
p = +g[o + 4 >> 2] - n;
r = +Q(+(q * q + p * p));
if (r < 1.1920928955078125E-7) {
s = p;
t = q
} else {
u = 1 / r;
s = p * u;
t = q * u
}
u = -s;
r = s < -0 ? u : s;
if (t > 0)
v = t;
else
v = -t;
s = +g[d + 16 >> 2];
w = m + q * s;
x = n + p * s;
o = j + 4 | 0;
c[j >> 2] = o;
y = j + 1028 |
0;
c[y >> 2] = 0;
z = j + 1032 | 0;
c[z >> 2] = 256;
A = c[j >> 2] | 0;
c[A + (c[y >> 2] << 2) >> 2] = c[a >> 2];
B = c[y >> 2] | 0;
C = B + 1 | 0;
c[y >> 2] = C;
a:
do if ((B | 0) > -1) {
D = a + 4 | 0;
E = k + 8 | 0;
F = k + 16 | 0;
G = f + 8 | 0;
H = k + 4 | 0;
I = k + 8 | 0;
J = k + 12 | 0;
K = h + 4 | 0;
L = b + 4 | 0;
M = C;
N = n < x ? n : x;
O = m < w ? m : w;
P = n > x ? n : x;
R = m > w ? m : w;
S = A;
T = s;
while (1) {
U = M;
V = S;
while (1) {
W = U + -1 | 0;
c[y >> 2] = W;
X = c[V + (W << 2) >> 2] | 0;
if ((X | 0) == -1) {
Y = W;
Z = V
} else {
_ = c[D >> 2] | 0;
$ = +g[_ + (X * 36 | 0) + 8 >> 2];
aa = +g[_ + (X * 36 | 0) + 12 >> 2];
ba = +g[_ + (X * 36 | 0) >> 2];
ca = +g[_ + (X * 36 | 0) + 4 >> 2];
if (O - $ > 0 | N - aa > 0 | ba - R > 0 | ca - P > 0) {
da = N;
ea = O;
fa = P;
ga = R;
ha = T;
break
}
ia =
(m - ($ + ba) * .5) * u + t * (n - (aa + ca) * .5);
if (ia > 0)
ja = ia;
else
ja = -ia;
if (ja - (r * ($ - ba) * .5 + v * (aa - ca) * .5) > 0) {
da = N;
ea = O;
fa = P;
ga = R;
ha = T;
break
}
ka = _ + (X * 36 | 0) + 24 | 0;
if ((c[ka >> 2] | 0) == -1) {
la = 17;
break
}
if ((W | 0) == (c[z >> 2] | 0) ? (c[z >> 2] = W << 1, ma = Pm(W << 3) | 0, c[j >> 2] = ma, An(ma | 0, V | 0, c[y >> 2] << 2 | 0) | 0, (V | 0) != (o | 0)) : 0)
Qm(V);
ma = c[j >> 2] | 0;
c[ma + (c[y >> 2] << 2) >> 2] = c[ka >> 2];
ka = (c[y >> 2] | 0) + 1 | 0;
c[y >> 2] = ka;
W = _ + (X * 36 | 0) + 28 | 0;
if ((ka | 0) == (c[z >> 2] | 0) ? (c[z >> 2] = ka << 1, _ = Pm(ka << 3) | 0, c[j >> 2] = _, An(_ | 0, ma | 0, c[y >> 2] << 2 | 0) | 0, (ma | 0) != (o | 0)) : 0)
Qm(ma);
ma = c[j >>
2] | 0;
c[ma + (c[y >> 2] << 2) >> 2] = c[W >> 2];
W = (c[y >> 2] | 0) + 1 | 0;
c[y >> 2] = W;
Y = W;
Z = ma
}
if ((Y | 0) > 0) {
U = Y;
V = Z
} else
break a
}
if ((la | 0) == 17) {
la = 0;
c[k + 0 >> 2] = 0;
c[k + 4 >> 2] = 0;
c[k + 8 >> 2] = 0;
c[k + 12 >> 2] = 0;
V = d;
U = c[V + 4 >> 2] | 0;
ma = k;
c[ma >> 2] = c[V >> 2];
c[ma + 4 >> 2] = U;
U = l;
ma = c[U + 4 >> 2] | 0;
V = E;
c[V >> 2] = c[U >> 2];
c[V + 4 >> 2] = ma;
g[F >> 2] = T;
ma = c[(c[(c[b >> 2] | 0) + 4 >> 2] | 0) + (X * 36 | 0) + 16 >> 2] | 0;
V = c[ma + 16 >> 2] | 0;
U = c[V + 12 >> 2] | 0;
if (ob[c[(c[U >> 2] | 0) + 24 >> 2] & 15](U, f, k, (c[V + 8 >> 2] | 0) + 12 | 0, c[ma + 20 >> 2] | 0) | 0) {
ca = +g[G >> 2];
aa = 1 - ca;
ba = aa * +g[H >> 2] + ca * +g[J >> 2];
g[h >> 2] = +g[k >>
2] * aa + ca * +g[I >> 2];
g[K >> 2] = ba;
ma = c[L >> 2] | 0;
na = +fb[c[(c[ma >> 2] | 0) + 8 >> 2] & 1](ma, V, h, f, ca)
} else
na = +g[F >> 2];
if (na == 0)
break a;
if (na > 0) {
ca = m + q * na;
ba = n + p * na;
da = n < ba ? n : ba;
ea = m < ca ? m : ca;
fa = n > ba ? n : ba;
ga = m > ca ? m : ca;
ha = na
} else {
da = N;
ea = O;
fa = P;
ga = R;
ha = T
}
}
V = c[y >> 2] | 0;
if ((V | 0) <= 0)
break a;
M = V;
N = da;
O = ea;
P = fa;
R = ga;
S = c[j >> 2] | 0;
T = ha
}
}
while (0);
y = c[j >> 2] | 0;
if ((y | 0) == (o | 0)) {
i = e;
return
}
Qm(y);
c[j >> 2] = 0;
i = e;
return
}
function Gj(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0;
e = i;
i = i + 1040 | 0;
f = e;
h = f + 4 | 0;
c[f >> 2] = h;
j = f + 1028 | 0;
c[j >> 2] = 0;
k = f + 1032 | 0;
c[k >> 2] = 256;
l = c[f >> 2] | 0;
c[l + (c[j >> 2] << 2) >> 2] = c[a >> 2];
m = c[j >> 2] | 0;
n = m + 1 | 0;
c[j >> 2] = n;
a:
do if ((m | 0) > -1) {
o = a + 4 | 0;
p = d + 4 | 0;
q = d + 8 | 0;
r = d + 12 | 0;
s = b + 4 | 0;
t = n;
u = l;
while (1) {
v = t + -1 | 0;
c[j >> 2] = v;
w = c[u + (v << 2) >> 2] | 0;
do if (!((w | 0) == -1) ? (x = c[o >> 2] | 0, !((+g[d >> 2] - +g[x + (w * 36 | 0) + 8 >> 2] > 0 ? 1 : +g[p >> 2] - +g[x + (w * 36 | 0) + 12 >> 2] > 0) | +g[x + (w * 36 | 0) >> 2] - +g[q >> 2] > 0 | +g[x + (w * 36 | 0) + 4 >> 2] - +g[r >> 2] > 0)) : 0) {
y = x + (w * 36 | 0) + 24 | 0;
if ((c[y >> 2] | 0) == -1) {
z = c[s >> 2] | 0;
if (!(nb[c[(c[z >>
2] | 0) + 8 >> 2] & 31](z, c[(c[(c[(c[b >> 2] | 0) + 4 >> 2] | 0) + (w * 36 | 0) + 16 >> 2] | 0) + 16 >> 2] | 0) | 0))
break a;
A = c[j >> 2] | 0;
break
}
if ((v | 0) == (c[k >> 2] | 0) ? (c[k >> 2] = v << 1, z = Pm(v << 3) | 0, c[f >> 2] = z, An(z | 0, u | 0, c[j >> 2] << 2 | 0) | 0, (u | 0) != (h | 0)) : 0)
Qm(u);
z = c[f >> 2] | 0;
c[z + (c[j >> 2] << 2) >> 2] = c[y >> 2];
y = (c[j >> 2] | 0) + 1 | 0;
c[j >> 2] = y;
B = x + (w * 36 | 0) + 28 | 0;
if ((y | 0) == (c[k >> 2] | 0) ? (c[k >> 2] = y << 1, x = Pm(y << 3) | 0, c[f >> 2] = x, An(x | 0, z | 0, c[j >> 2] << 2 | 0) | 0, (z | 0) != (h | 0)) : 0)
Qm(z);
c[(c[f >> 2] | 0) + (c[j >> 2] << 2) >> 2] = c[B >> 2];
B = (c[j >> 2] | 0) + 1 | 0;
c[j >> 2] = B;
A = B
} else
A = v;
while (0);
if ((A |
0) <= 0)
break a;
t = A;
u = c[f >> 2] | 0
}
}
while (0);
A = c[f >> 2] | 0;
if ((A | 0) == (h | 0)) {
i = e;
return
}
Qm(A);
c[f >> 2] = 0;
i = e;
return
}
function Hj(d, e, f) {
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0;
h = i;
j = d + 12 | 0;
k = d + 28 | 0;
l = d + 80 | 0;
m = d + 4 | 0;
n = (a[e + 39 >> 0] | 0) == 0 ? 0 : 8;
b[m >> 1] = n;
if ((a[e + 38 >> 0] | 0) == 0)
o = n;
else {
p = (n & 65535 | 16) & 65535;
b[m >> 1] = p;
o = p
}
if ((a[e + 36 >> 0] | 0) == 0)
q = o;
else {
p = (o & 65535 | 4) & 65535;
b[m >> 1] = p;
q = p
}
if ((a[e + 37 >> 0] | 0) == 0)
r = q;
else {
p = (q & 65535 | 2) & 65535;
b[m >> 1] = p;
r = p
}
if ((a[e + 40 >> 0] |
0) != 0)
b[m >> 1] = r & 65535 | 32;
c[d + 104 >> 2] = f;
f = e + 4 | 0;
r = c[f >> 2] | 0;
m = c[f + 4 >> 2] | 0;
f = j;
c[f >> 2] = r;
c[f + 4 >> 2] = m;
f = e + 12 | 0;
s = +g[f >> 2];
g[d + 20 >> 2] = +T(+s);
g[d + 24 >> 2] = +S(+s);
c[k + 0 >> 2] = c[j + 0 >> 2];
c[k + 4 >> 2] = c[j + 4 >> 2];
c[k + 8 >> 2] = c[j + 8 >> 2];
c[k + 12 >> 2] = c[j + 12 >> 2];
g[d + 44 >> 2] = 0;
g[d + 48 >> 2] = 0;
j = d + 52 | 0;
c[j >> 2] = r;
c[j + 4 >> 2] = m;
j = d + 60 | 0;
c[j >> 2] = r;
c[j + 4 >> 2] = m;
g[d + 68 >> 2] = +g[f >> 2];
g[d + 72 >> 2] = +g[f >> 2];
g[d + 76 >> 2] = 0;
c[d + 124 >> 2] = 0;
c[d + 128 >> 2] = 0;
c[d + 108 >> 2] = 0;
c[d + 112 >> 2] = 0;
f = e + 16 | 0;
m = c[f + 4 >> 2] | 0;
j = l;
c[j >> 2] = c[f >> 2];
c[j + 4 >> 2] = m;
g[d + 88 >> 2] = +g[e +
24 >> 2];
g[d + 148 >> 2] = +g[e + 28 >> 2];
g[d + 152 >> 2] = +g[e + 32 >> 2];
g[d + 156 >> 2] = +g[e + 48 >> 2];
g[d + 92 >> 2] = 0;
g[d + 96 >> 2] = 0;
g[d + 100 >> 2] = 0;
g[d + 160 >> 2] = 0;
m = c[e >> 2] | 0;
c[d >> 2] = m;
j = d + 132 | 0;
if ((m | 0) == 2) {
g[j >> 2] = 1;
g[d + 136 >> 2] = 1;
t = d + 140 | 0;
g[t >> 2] = 0;
u = d + 144 | 0;
g[u >> 2] = 0;
v = e + 44 | 0;
w = c[v >> 2] | 0;
x = d + 164 | 0;
c[x >> 2] = w;
y = d + 116 | 0;
c[y >> 2] = 0;
z = d + 120 | 0;
c[z >> 2] = 0;
i = h;
return
} else {
g[j >> 2] = 0;
g[d + 136 >> 2] = 0;
t = d + 140 | 0;
g[t >> 2] = 0;
u = d + 144 | 0;
g[u >> 2] = 0;
v = e + 44 | 0;
w = c[v >> 2] | 0;
x = d + 164 | 0;
c[x >> 2] = w;
y = d + 116 | 0;
c[y >> 2] = 0;
z = d + 120 | 0;
c[z >> 2] = 0;
i = h;
return
}
}
function Ij(a) {
a =
a | 0;
return
}
function Jj(a, d) {
a = a | 0;
d = d | 0;
var f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0;
f = i;
i = i + 16 | 0;
h = f;
j = a + 104 | 0;
if ((c[(c[j >> 2] | 0) + 102876 >> 2] & 2 | 0) != 0) {
i = f;
return
}
if ((c[a >> 2] | 0) == (d | 0)) {
i = f;
return
}
c[a >> 2] = d;
Kj(a);
if ((c[a >> 2] | 0) == 0 ? (g[a + 80 >> 2] = 0, g[a + 84 >> 2] = 0, g[a + 88 >> 2] = 0, l = +g[a + 72 >> 2], g[a + 68 >> 2] = l, d = a + 60 | 0, m = c[d >> 2] | 0, n = c[d + 4 >> 2] | 0, d = a + 52 | 0, c[d >> 2] = m, c[d + 4 >> 2] = n, o = +T(+l), g[h + 8 >> 2] = o, p = +S(+l), g[h + 12 >> 2] = p, l = +g[a + 44 >> 2], q = +g[a + 48 >> 2], r = (c[k >> 2] = m, +g[k >> 2]) - (p * l - o * q), s = (c[k >> 2] = n, +g[k >> 2]) - (o *
l + p * q), q = +r, r = +s, n = h, g[n >> 2] = q, g[n + 4 >> 2] = r, n = (c[j >> 2] | 0) + 102880 | 0, m = c[a + 116 >> 2] | 0, (m | 0) != 0) : 0) {
d = a + 12 | 0;
t = m;
do {
qj(t, n, h, d);
t = c[t + 4 >> 2] | 0
} while ((t | 0) != 0)
}
t = a + 4 | 0;
d = e[t >> 1] | 0;
if ((d & 2 | 0) == 0) {
b[t >> 1] = d | 2;
g[a + 160 >> 2] = 0
}
g[a + 92 >> 2] = 0;
g[a + 96 >> 2] = 0;
g[a + 100 >> 2] = 0;
d = a + 128 | 0;
t = c[d >> 2] | 0;
if ((t | 0) != 0) {
h = t;
do {
t = h;
h = c[h + 12 >> 2] | 0;
Tj((c[j >> 2] | 0) + 102880 | 0, c[t + 4 >> 2] | 0)
} while ((h | 0) != 0)
}
c[d >> 2] = 0;
d = (c[j >> 2] | 0) + 102880 | 0;
j = c[a + 116 >> 2] | 0;
if ((j | 0) == 0) {
i = f;
return
} else
u = j;
do {
j = c[u + 28 >> 2] | 0;
if ((j | 0) > 0) {
a = u + 24 | 0;
h = 0;
do {
Re(d,
c[(c[a >> 2] | 0) + (h * 28 | 0) + 24 >> 2] | 0);
h = h + 1 | 0
} while ((h | 0) != (j | 0))
}
u = c[u + 4 >> 2] | 0
} while ((u | 0) != 0);
i = f;
return
}
function Kj(a) {
a = a | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0;
d = i;
i = i + 16 | 0;
e = d;
f = a + 132 | 0;
h = a + 136 | 0;
j = a + 140 | 0;
k = a + 144 | 0;
l = a + 44 | 0;
g[l >> 2] = 0;
g[a + 48 >> 2] = 0;
c[f + 0 >> 2] = 0;
c[f + 4 >> 2] = 0;
c[f + 8 >> 2] = 0;
c[f + 12 >> 2] = 0;
if ((c[a >> 2] | 0) >>> 0 < 2) {
m = a + 12 | 0;
n = c[m >> 2] | 0;
o = c[m + 4 >> 2] | 0;
m = a + 52 | 0;
c[m >> 2] = n;
c[m + 4 >> 2] = o;
m = a + 60 | 0;
c[m >> 2] = n;
c[m + 4 >> 2] = o;
g[a + 68 >> 2] = +g[a + 72 >> 2];
i = d;
return
}
o = 8784;
p = +g[o >> 2];
q = +g[o + 4 >> 2];
o = c[a + 116 >> 2] | 0;
if ((o | 0) != 0) {
m = e + 4 | 0;
n = e + 8 | 0;
r = e + 12 | 0;
s = 0;
t = 0;
u = p;
v = q;
w = o;
while (1) {
x = +g[w >> 2];
if (x == 0) {
y = s;
z = t;
A = u;
B = v
} else {
o = c[w + 12 >> 2] | 0;
kb[c[(c[o >> 2] | 0) + 32 >> 2] & 31](o, e, x);
x = +g[e >> 2];
C = x + +g[f >> 2];
g[f >> 2] = C;
D = u + x * +g[m >> 2];
E = v + x * +g[n >> 2];
x = +g[r >> 2] + +g[j >> 2];
g[j >> 2] = x;
y = x;
z = C;
A = D;
B = E
}
w = c[w + 4 >> 2] | 0;
if ((w | 0) == 0)
break;
else {
s = y;
t = z;
u = A;
v = B
}
}
if (z > 0) {
v = 1 / z;
g[h >> 2] = v;
F = y;
G = A * v;
H = B * v;
I = z
} else {
J = B;
K = A;
L = y;
M = 10
}
} else {
J =
q;
K = p;
L = 0;
M = 10
}
if ((M | 0) == 10) {
g[f >> 2] = 1;
g[h >> 2] = 1;
F = L;
G = K;
H = J;
I = 1
}
if (F > 0 ? (b[a + 4 >> 1] & 16) == 0 : 0) {
J = F - (H * H + G * G) * I;
g[j >> 2] = J;
N = 1 / J
} else {
g[j >> 2] = 0;
N = 0
}
g[k >> 2] = N;
k = a + 60 | 0;
j = k;
N = +g[j >> 2];
J = +g[j + 4 >> 2];
I = +G;
F = +H;
j = l;
g[j >> 2] = I;
g[j + 4 >> 2] = F;
F = +g[a + 24 >> 2];
I = +g[a + 20 >> 2];
K = +g[a + 12 >> 2] + (F * G - I * H);
L = G * I + F * H + +g[a + 16 >> 2];
H = +K;
F = +L;
j = k;
g[j >> 2] = H;
g[j + 4 >> 2] = F;
j = a + 52 | 0;
g[j >> 2] = H;
g[j + 4 >> 2] = F;
F = +g[a + 88 >> 2];
j = a + 80 | 0;
g[j >> 2] = +g[j >> 2] - F * (L - J);
j = a + 84 | 0;
g[j >> 2] = F * (K - N) + +g[j >> 2];
i = d;
return
}
function Lj(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f =
0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0;
b = i;
i = i + 16 | 0;
d = b;
e = +g[a + 68 >> 2];
f = +T(+e);
g[d + 8 >> 2] = f;
h = +S(+e);
g[d + 12 >> 2] = h;
e = +g[a + 44 >> 2];
j = +g[a + 48 >> 2];
k = +(+g[a + 52 >> 2] - (h * e - f * j));
l = +(+g[a + 56 >> 2] - (e * f + h * j));
m = d;
g[m >> 2] = k;
g[m + 4 >> 2] = l;
m = (c[a + 104 >> 2] | 0) + 102880 | 0;
n = c[a + 116 >> 2] | 0;
if ((n | 0) == 0) {
i = b;
return
}
o = a + 12 | 0;
a = n;
do {
qj(a, m, d, o);
a = c[a + 4 >> 2] | 0
} while ((a | 0) != 0);
i = b;
return
}
function Mj(a, d) {
a = a | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0;
e = i;
f = a + 104 | 0;
h = c[f >> 2] | 0;
if ((c[h + 102876 >> 2] & 2 | 0) != 0) {
j = 0;
i = e;
return j | 0
}
k = Em(h, 44) | 0;
if ((k | 0) ==
0)
l = 0;
else {
lj(k);
l = k
}
mj(l, h, a, d);
if (!((b[a + 4 >> 1] & 32) == 0))
oj(l, (c[f >> 2] | 0) + 102880 | 0, a + 12 | 0);
d = a + 116 | 0;
c[l + 4 >> 2] = c[d >> 2];
c[d >> 2] = l;
d = a + 120 | 0;
c[d >> 2] = (c[d >> 2] | 0) + 1;
c[l + 8 >> 2] = a;
if (+g[l >> 2] > 0)
Kj(a);
a = (c[f >> 2] | 0) + 102876 | 0;
c[a >> 2] = c[a >> 2] | 1;
j = l;
i = e;
return j | 0
}
function Nj(a, d) {
a = a | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0;
e = i;
f = a + 104 | 0;
if ((c[(c[f >> 2] | 0) + 102876 >> 2] & 2 | 0) != 0) {
i = e;
return
}
g = a + 116 | 0;
h = c[g >> 2] | 0;
a:
do if ((h | 0) != 0) {
j = h;
k = g;
while (1) {
l = j + 4 | 0;
if ((j | 0) == (d | 0))
break;
j = c[l >> 2] | 0;
if ((j | 0) == 0)
break a;
else
k =
l
}
c[k >> 2] = c[d + 4 >> 2]
}
while (0);
g = c[a + 128 >> 2] | 0;
if ((g | 0) != 0) {
h = g;
do {
g = c[h + 4 >> 2] | 0;
h = c[h + 12 >> 2] | 0;
if ((c[g + 48 >> 2] | 0) == (d | 0) ? 1 : (c[g + 52 >> 2] | 0) == (d | 0))
Tj((c[f >> 2] | 0) + 102880 | 0, g)
} while ((h | 0) != 0)
}
h = c[f >> 2] | 0;
if (!((b[a + 4 >> 1] & 32) == 0))
pj(d, h + 102880 | 0);
nj(d, h);
c[d + 8 >> 2] = 0;
c[d + 4 >> 2] = 0;
Fm(h, d, 44);
d = a + 120 | 0;
c[d >> 2] = (c[d >> 2] | 0) + -1;
Kj(a);
i = e;
return
}
function Oj(a, d) {
a = a | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0;
e = i;
if ((c[(c[a + 104 >> 2] | 0) + 102876 >> 2] & 2 | 0) != 0) {
i = e;
return
}
if ((c[a >> 2] | 0) != 2) {
i = e;
return
}
f =
a + 136 | 0;
g[f >> 2] = 0;
h = a + 140 | 0;
g[h >> 2] = 0;
j = a + 144 | 0;
g[j >> 2] = 0;
l = +g[d >> 2];
m = !(l <= 0) ? l : 1;
g[a + 132 >> 2] = m;
g[f >> 2] = 1 / m;
l = +g[d + 12 >> 2];
if (l > 0 ? (b[a + 4 >> 1] & 16) == 0 : 0) {
n = +g[d + 4 >> 2];
o = +g[d + 8 >> 2];
p = l - m * (n * n + o * o);
g[h >> 2] = p;
g[j >> 2] = 1 / p
}
j = a + 60 | 0;
h = j;
p = +g[h >> 2];
o = +g[h + 4 >> 2];
h = d + 4 | 0;
d = c[h >> 2] | 0;
f = c[h + 4 >> 2] | 0;
h = a + 44 | 0;
c[h >> 2] = d;
c[h + 4 >> 2] = f;
n = +g[a + 24 >> 2];
m = (c[k >> 2] = d, +g[k >> 2]);
l = +g[a + 20 >> 2];
q = (c[k >> 2] = f, +g[k >> 2]);
r = +g[a + 12 >> 2] + (n * m - l * q);
s = m * l + n * q + +g[a + 16 >> 2];
q = +r;
n = +s;
f = j;
g[f >> 2] = q;
g[f + 4 >> 2] = n;
f = a + 52 | 0;
g[f >> 2] = q;
g[f + 4 >> 2] =
n;
n = +g[a + 88 >> 2];
f = a + 80 | 0;
g[f >> 2] = +g[f >> 2] - n * (s - o);
f = a + 84 | 0;
g[f >> 2] = n * (r - p) + +g[f >> 2];
i = e;
return
}
function Pj(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0;
e = i;
if ((c[b >> 2] | 0) != 2 ? (c[d >> 2] | 0) != 2 : 0)
f = 0;
else
g = 3;
a:
do if ((g | 0) == 3) {
h = c[b + 124 >> 2] | 0;
if ((h | 0) == 0)
f = 1;
else {
j = h;
while (1) {
if ((c[j >> 2] | 0) == (d | 0) ? (a[(c[j + 4 >> 2] | 0) + 61 >> 0] | 0) == 0 : 0) {
f = 0;
break a
}
j = c[j + 12 >> 2] | 0;
if ((j | 0) == 0) {
f = 1;
break
}
}
}
}
while (0);
i = e;
return f | 0
}
function Qj(a, b, d) {
a = a | 0;
b = b | 0;
d = +d;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0;
e = i;
f = c[a + 104 >>
2] | 0;
if ((c[f + 102876 >> 2] & 2 | 0) != 0) {
i = e;
return
}
h = a + 12 | 0;
j = +T(+d);
g[a + 20 >> 2] = j;
l = +S(+d);
g[a + 24 >> 2] = l;
m = b;
b = c[m >> 2] | 0;
n = c[m + 4 >> 2] | 0;
m = h;
c[m >> 2] = b;
c[m + 4 >> 2] = n;
m = a + 28 | 0;
c[m + 0 >> 2] = c[h + 0 >> 2];
c[m + 4 >> 2] = c[h + 4 >> 2];
c[m + 8 >> 2] = c[h + 8 >> 2];
c[m + 12 >> 2] = c[h + 12 >> 2];
o = +g[a + 44 >> 2];
p = +g[a + 48 >> 2];
q = (c[k >> 2] = b, +g[k >> 2]) + (l * o - j * p);
r = o * j + l * p + (c[k >> 2] = n, +g[k >> 2]);
p = +q;
q = +r;
n = a + 60 | 0;
g[n >> 2] = p;
g[n + 4 >> 2] = q;
g[a + 72 >> 2] = d;
n = a + 52 | 0;
g[n >> 2] = p;
g[n + 4 >> 2] = q;
g[a + 68 >> 2] = d;
n = f + 102880 | 0;
f = c[a + 116 >> 2] | 0;
if ((f | 0) == 0) {
i = e;
return
} else
s = f;
do {
qj(s,
n, h, h);
s = c[s + 4 >> 2] | 0
} while ((s | 0) != 0);
i = e;
return
}
function Rj(a) {
a = a | 0;
return
}
function Sj(a) {
a = a | 0;
var b = 0;
b = i;
Me(a);
c[a + 60 >> 2] = 0;
c[a + 64 >> 2] = 0;
c[a + 68 >> 2] = 6800;
c[a + 72 >> 2] = 6808;
c[a + 76 >> 2] = 0;
i = b;
return
}
function Tj(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0;
d = i;
e = c[(c[b + 48 >> 2] | 0) + 8 >> 2] | 0;
f = c[(c[b + 52 >> 2] | 0) + 8 >> 2] | 0;
g = c[a + 72 >> 2] | 0;
if ((g | 0) != 0 ? (c[b + 4 >> 2] & 2 | 0) != 0 : 0)
gb[c[(c[g >> 2] | 0) + 12 >> 2] & 63](g, b);
g = b + 8 | 0;
h = c[g >> 2] | 0;
j = b + 12 | 0;
if ((h | 0) != 0)
c[h + 12 >> 2] = c[j >> 2];
h = c[j >> 2] | 0;
if ((h | 0) != 0)
c[h +
8 >> 2] = c[g >> 2];
g = a + 60 | 0;
if ((c[g >> 2] | 0) == (b | 0))
c[g >> 2] = c[j >> 2];
j = b + 24 | 0;
g = c[j >> 2] | 0;
h = b + 28 | 0;
if ((g | 0) != 0)
c[g + 12 >> 2] = c[h >> 2];
g = c[h >> 2] | 0;
if ((g | 0) != 0)
c[g + 8 >> 2] = c[j >> 2];
j = e + 128 | 0;
if ((b + 16 | 0) == (c[j >> 2] | 0))
c[j >> 2] = c[h >> 2];
h = b + 40 | 0;
j = c[h >> 2] | 0;
e = b + 44 | 0;
if ((j | 0) != 0)
c[j + 12 >> 2] = c[e >> 2];
j = c[e >> 2] | 0;
if ((j | 0) != 0)
c[j + 8 >> 2] = c[h >> 2];
h = f + 128 | 0;
if ((b + 32 | 0) != (c[h >> 2] | 0)) {
k = a + 76 | 0;
l = c[k >> 2] | 0;
vi(b, l);
m = a + 64 | 0;
n = c[m >> 2] | 0;
o = n + -1 | 0;
c[m >> 2] = o;
i = d;
return
}
c[h >> 2] = c[e >> 2];
k = a + 76 | 0;
l = c[k >> 2] | 0;
vi(b, l);
m = a + 64 | 0;
n = c[m >> 2] | 0;
o =
n + -1 | 0;
c[m >> 2] = o;
i = d;
return
}
function Uj(a) {
a = a | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0;
d = i;
e = c[a + 60 >> 2] | 0;
if ((e | 0) == 0) {
i = d;
return
}
f = a + 4 | 0;
h = a + 72 | 0;
j = a + 68 | 0;
k = e;
while (1) {
e = c[k + 48 >> 2] | 0;
l = c[k + 52 >> 2] | 0;
m = c[k + 56 >> 2] | 0;
n = c[k + 60 >> 2] | 0;
o = c[e + 8 >> 2] | 0;
p = c[l + 8 >> 2] | 0;
q = k + 4 | 0;
do if ((c[q >> 2] & 8 | 0) == 0)
r = 11;
else {
if (!(Pj(p, o) | 0)) {
s = c[k + 12 >> 2] | 0;
Tj(a, k);
t = s;
break
}
s = c[j >> 2] | 0;
if ((s | 0) != 0 ? !(hb[c[(c[s >> 2] | 0) + 8 >> 2] & 15](s, e, l) | 0) : 0) {
s = c[k + 12 >> 2] | 0;
Tj(a, k);
t = s;
break
}
c[q >> 2] = c[q >> 2] &
-9;
r = 11
}
while (0);
do if ((r | 0) == 11) {
r = 0;
if ((b[o + 4 >> 1] & 2) == 0)
u = 0;
else
u = (c[o >> 2] | 0) != 0;
if ((b[p + 4 >> 1] & 2) == 0)
v = 0;
else
v = (c[p >> 2] | 0) != 0;
if (!(u | v)) {
t = c[k + 12 >> 2] | 0;
break
}
q = c[(c[e + 24 >> 2] | 0) + (m * 28 | 0) + 24 >> 2] | 0;
s = c[(c[l + 24 >> 2] | 0) + (n * 28 | 0) + 24 >> 2] | 0;
w = c[f >> 2] | 0;
if ((+g[w + (s * 36 | 0) >> 2] - +g[w + (q * 36 | 0) + 8 >> 2] > 0 ? 1 : +g[w + (s * 36 | 0) + 4 >> 2] - +g[w + (q * 36 | 0) + 12 >> 2] > 0) | +g[w + (q * 36 | 0) >> 2] - +g[w + (s * 36 | 0) + 8 >> 2] > 0 | +g[w + (q * 36 | 0) + 4 >> 2] - +g[w + (s * 36 | 0) + 12 >> 2] > 0) {
s = c[k + 12 >> 2] | 0;
Tj(a, k);
t = s;
break
} else {
xi(k, c[h >> 2] | 0);
t = c[k + 12 >> 2] | 0;
break
}
}
while (0);
if ((t | 0) == 0)
break;
else
k = t
}
i = d;
return
}
function Vj(a) {
a = a | 0;
var b = 0;
b = i;
Wj(a, a);
i = b;
return
}
function Wj(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
d = i;
i = i + 16 | 0;
e = d;
f = a + 52 | 0;
c[f >> 2] = 0;
g = a + 40 | 0;
h = c[g >> 2] | 0;
if ((h | 0) > 0) {
j = a + 32 | 0;
k = a + 56 | 0;
l = a + 4 | 0;
m = h;
h = 0;
while (1) {
n = c[(c[j >> 2] | 0) + (h << 2) >> 2] | 0;
c[k >> 2] = n;
if ((n | 0) == -1)
o = m;
else {
Yj(a, a, (c[l >> 2] | 0) + (n * 36 | 0) | 0);
o = c[g >> 2] | 0
}
h = h + 1 | 0;
if ((h | 0) >= (o | 0))
break;
else
m = o
}
p = c[f >> 2] | 0
} else
p = 0;
c[g >> 2] = 0;
g = a + 44 | 0;
o = c[g >> 2] | 0;
c[e >> 2] = 26;
_j(o, o + (p << 3) |
0, e);
if ((c[f >> 2] | 0) <= 0) {
i = d;
return
}
e = a + 4 | 0;
a = 0;
a:
while (1) {
p = c[g >> 2] | 0;
o = p + (a << 3) | 0;
m = c[e >> 2] | 0;
h = p + (a << 3) + 4 | 0;
Xj(b, c[m + ((c[o >> 2] | 0) * 36 | 0) + 16 >> 2] | 0, c[m + ((c[h >> 2] | 0) * 36 | 0) + 16 >> 2] | 0);
m = c[f >> 2] | 0;
p = a;
while (1) {
l = p + 1 | 0;
if ((l | 0) >= (m | 0))
break a;
k = c[g >> 2] | 0;
if ((c[k + (l << 3) >> 2] | 0) != (c[o >> 2] | 0)) {
a = l;
continue a
}
if ((c[k + (l << 3) + 4 >> 2] | 0) == (c[h >> 2] | 0))
p = l;
else {
a = l;
continue a
}
}
}
i = d;
return
}
function Xj(d, f, h) {
d = d | 0;
f = f | 0;
h = h | 0;
var j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0;
j = i;
k = c[f + 16 >> 2] | 0;
l = c[h + 16 >> 2] | 0;
m = c[f + 20 >> 2] | 0;
f = c[h + 20 >> 2] | 0;
h = c[k + 8 >> 2] | 0;
n = c[l + 8 >> 2] | 0;
if ((h | 0) == (n | 0)) {
i = j;
return
}
o = c[n + 128 >> 2] | 0;
a:
do if ((o | 0) != 0) {
p = o;
while (1) {
if ((c[p >> 2] | 0) == (h | 0)) {
q = c[p + 4 >> 2] | 0;
r = c[q + 48 >> 2] | 0;
s = c[q + 52 >> 2] | 0;
t = c[q + 56 >> 2] | 0;
u = c[q + 60 >> 2] | 0;
if ((r | 0) == (k | 0) & (s | 0) == (l | 0) & (t | 0) == (m | 0) & (u | 0) == (f | 0)) {
v = 24;
break
}
if ((r | 0) == (l | 0) & (s | 0) == (k | 0) & (t | 0) == (f | 0) & (u | 0) == (m | 0)) {
v = 24;
break
}
}
p = c[p + 12 >> 2] | 0;
if ((p | 0) == 0)
break a
}
if ((v | 0) == 24) {
i = j;
return
}
}
while (0);
if (!(Pj(n, h) | 0)) {
i = j;
return
}
h = c[d + 68 >> 2] | 0;
if ((h | 0) != 0 ? !(hb[c[(c[h >>
2] | 0) + 8 >> 2] & 15](h, k, l) | 0) : 0) {
i = j;
return
}
h = ui(k, m, l, f, c[d + 76 >> 2] | 0) | 0;
if ((h | 0) == 0) {
i = j;
return
}
f = c[h + 48 >> 2] | 0;
l = c[h + 52 >> 2] | 0;
m = c[f + 8 >> 2] | 0;
k = c[l + 8 >> 2] | 0;
c[h + 8 >> 2] = 0;
n = d + 60 | 0;
c[h + 12 >> 2] = c[n >> 2];
v = c[n >> 2] | 0;
if ((v | 0) != 0)
c[v + 8 >> 2] = h;
c[n >> 2] = h;
n = h + 16 | 0;
c[h + 20 >> 2] = h;
c[n >> 2] = k;
c[h + 24 >> 2] = 0;
v = m + 128 | 0;
c[h + 28 >> 2] = c[v >> 2];
o = c[v >> 2] | 0;
if ((o | 0) != 0)
c[o + 8 >> 2] = n;
c[v >> 2] = n;
n = h + 32 | 0;
c[h + 36 >> 2] = h;
c[n >> 2] = m;
c[h + 40 >> 2] = 0;
v = k + 128 | 0;
c[h + 44 >> 2] = c[v >> 2];
h = c[v >> 2] | 0;
if ((h | 0) != 0)
c[h + 8 >> 2] = n;
c[v >> 2] = n;
if ((a[f + 38 >> 0] | 0) == 0 ? (a[l +
38 >> 0] | 0) == 0 : 0) {
l = m + 4 | 0;
f = e[l >> 1] | 0;
if ((f & 2 | 0) == 0) {
b[l >> 1] = f | 2;
g[m + 160 >> 2] = 0
}
m = k + 4 | 0;
f = e[m >> 1] | 0;
if ((f & 2 | 0) == 0) {
b[m >> 1] = f | 2;
g[k + 160 >> 2] = 0
}
}
k = d + 64 | 0;
c[k >> 2] = (c[k >> 2] | 0) + 1;
i = j;
return
}
function Yj(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0;
e = i;
i = i + 1040 | 0;
f = e;
h = f + 4 | 0;
c[f >> 2] = h;
j = f + 1028 | 0;
c[j >> 2] = 0;
k = f + 1032 | 0;
c[k >> 2] = 256;
l = c[f >> 2] | 0;
c[l + (c[j >> 2] << 2) >> 2] = c[a >> 2];
m = c[j >> 2] | 0;
n = m + 1 | 0;
c[j >> 2] = n;
a:
do if ((m | 0) > -1) {
o = a + 4 | 0;
p = d + 4 | 0;
q = d + 8 | 0;
r =
d + 12 | 0;
s = n;
t = l;
while (1) {
u = s + -1 | 0;
c[j >> 2] = u;
v = c[t + (u << 2) >> 2] | 0;
do if (!((v | 0) == -1) ? (w = c[o >> 2] | 0, !((+g[d >> 2] - +g[w + (v * 36 | 0) + 8 >> 2] > 0 ? 1 : +g[p >> 2] - +g[w + (v * 36 | 0) + 12 >> 2] > 0) | +g[w + (v * 36 | 0) >> 2] - +g[q >> 2] > 0 | +g[w + (v * 36 | 0) + 4 >> 2] - +g[r >> 2] > 0)) : 0) {
x = w + (v * 36 | 0) + 24 | 0;
if ((c[x >> 2] | 0) == -1) {
if (!(Se(b, v) | 0))
break a;
y = c[j >> 2] | 0;
break
}
if ((u | 0) == (c[k >> 2] | 0) ? (c[k >> 2] = u << 1, z = Pm(u << 3) | 0, c[f >> 2] = z, An(z | 0, t | 0, c[j >> 2] << 2 | 0) | 0, (t | 0) != (h | 0)) : 0)
Qm(t);
z = c[f >> 2] | 0;
c[z + (c[j >> 2] << 2) >> 2] = c[x >> 2];
x = (c[j >> 2] | 0) + 1 | 0;
c[j >> 2] = x;
A = w + (v * 36 | 0) + 28 |
0;
if ((x | 0) == (c[k >> 2] | 0) ? (c[k >> 2] = x << 1, w = Pm(x << 3) | 0, c[f >> 2] = w, An(w | 0, z | 0, c[j >> 2] << 2 | 0) | 0, (z | 0) != (h | 0)) : 0)
Qm(z);
c[(c[f >> 2] | 0) + (c[j >> 2] << 2) >> 2] = c[A >> 2];
A = (c[j >> 2] | 0) + 1 | 0;
c[j >> 2] = A;
y = A
} else
y = u;
while (0);
if ((y | 0) <= 0)
break a;
s = y;
t = c[f >> 2] | 0
}
}
while (0);
y = c[f >> 2] | 0;
if ((y | 0) == (h | 0)) {
i = e;
return
}
Qm(y);
c[f >> 2] = 0;
i = e;
return
}
function Zj(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0;
d = i;
e = c[a >> 2] | 0;
f = c[b >> 2] | 0;
if ((e | 0) >= (f | 0))
if ((e | 0) == (f | 0))
g = (c[a + 4 >> 2] | 0) < (c[b + 4 >> 2] | 0);
else
g = 0;
else
g = 1;
i = d;
return g | 0
}
function _j(a, b, d) {
a =
a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0;
e = i;
f = a;
a = b;
a:
while (1) {
b = a;
g = a + -8 | 0;
h = f;
b:
while (1) {
j = h;
k = b - j | 0;
l = k >> 3;
switch (l | 0) {
case 5:
m = 15;
break a;
break;
case 2:
m = 4;
break a;
break;
case 4:
m = 14;
break a;
break;
case 1:
case 0:
m = 67;
break a;
break;
case 3:
m = 6;
break a;
break;
default:
}
if ((k | 0) < 248) {
m = 21;
break a
}
n = (l | 0) / 2 | 0;
o = h + (n << 3) | 0;
do if ((k | 0) > 7992) {
p = (l | 0) / 4 | 0;
q = h + (p << 3) | 0;
r = h + (p + n << 3) | 0;
p =
$j(h, q, o, r, d) | 0;
if (nb[c[d >> 2] & 31](g, r) | 0) {
s = r;
t = c[s >> 2] | 0;
u = c[s + 4 >> 2] | 0;
s = g;
v = c[s + 4 >> 2] | 0;
w = r;
c[w >> 2] = c[s >> 2];
c[w + 4 >> 2] = v;
v = g;
c[v >> 2] = t;
c[v + 4 >> 2] = u;
u = p + 1 | 0;
if (nb[c[d >> 2] & 31](r, o) | 0) {
v = o;
t = c[v >> 2] | 0;
w = c[v + 4 >> 2] | 0;
v = r;
s = c[v + 4 >> 2] | 0;
x = o;
c[x >> 2] = c[v >> 2];
c[x + 4 >> 2] = s;
s = r;
c[s >> 2] = t;
c[s + 4 >> 2] = w;
w = p + 2 | 0;
if (nb[c[d >> 2] & 31](o, q) | 0) {
s = q;
t = c[s >> 2] | 0;
r = c[s + 4 >> 2] | 0;
s = o;
x = c[s + 4 >> 2] | 0;
v = q;
c[v >> 2] = c[s >> 2];
c[v + 4 >> 2] = x;
x = o;
c[x >> 2] = t;
c[x + 4 >> 2] = r;
if (nb[c[d >> 2] & 31](q, h) | 0) {
r = h;
x = c[r >> 2] | 0;
t = c[r + 4 >> 2] | 0;
r = q;
v = c[r + 4 >> 2] | 0;
s = h;
c[s >> 2] = c[r >> 2];
c[s + 4 >> 2] = v;
v = q;
c[v >> 2] = x;
c[v + 4 >> 2] = t;
y = p + 4 | 0
} else
y = p + 3 | 0
} else
y = w
} else
y = u
} else
y = p
} else {
p = nb[c[d >> 2] & 31](o, h) | 0;
u = nb[c[d >> 2] & 31](g, o) | 0;
if (!p) {
if (!u) {
y = 0;
break
}
p = o;
w = c[p >> 2] | 0;
t = c[p + 4 >> 2] | 0;
p = g;
v = c[p + 4 >> 2] | 0;
x = o;
c[x >> 2] = c[p >> 2];
c[x + 4 >> 2] = v;
v = g;
c[v >> 2] = w;
c[v + 4 >> 2] = t;
if (!(nb[c[d >> 2] & 31](o, h) | 0)) {
y = 1;
break
}
t = h;
v = c[t >> 2] | 0;
w = c[t + 4 >> 2] | 0;
t = o;
x = c[t + 4 >> 2] | 0;
p = h;
c[p >> 2] = c[t >> 2];
c[p + 4 >> 2] = x;
x = o;
c[x >> 2] = v;
c[x + 4 >> 2] = w;
y = 2;
break
}
w = h;
x = c[w >> 2] | 0;
v = c[w + 4 >> 2] | 0;
if (u) {
u = g;
w = c[u + 4 >> 2] | 0;
p = h;
c[p >> 2] = c[u >> 2];
c[p + 4 >> 2] = w;
w = g;
c[w >> 2] = x;
c[w + 4 >> 2] = v;
y = 1;
break
}
w = o;
p = c[w + 4 >> 2] | 0;
u = h;
c[u >> 2] = c[w >> 2];
c[u + 4 >> 2] = p;
p = o;
c[p >> 2] = x;
c[p + 4 >> 2] = v;
if (nb[c[d >> 2] & 31](g, o) | 0) {
v = o;
p = c[v >> 2] | 0;
x = c[v + 4 >> 2] | 0;
v = g;
u = c[v + 4 >> 2] | 0;
w = o;
c[w >> 2] = c[v >> 2];
c[w + 4 >> 2] = u;
u = g;
c[u >> 2] = p;
c[u + 4 >> 2] = x;
y = 2
} else
y = 1
}
while (0);
do if (nb[c[d >> 2] & 31](h, o) | 0) {
z = g;
A = y
} else {
n = g;
while (1) {
n = n + -8 | 0;
if ((h | 0) == (n | 0))
break;
if (nb[c[d >> 2] & 31](n, o) | 0) {
m = 50;
break
}
}
if ((m | 0) == 50) {
m = 0;
l = h;
k = c[l >> 2] | 0;
x = c[l + 4 >> 2] | 0;
l = n;
u = c[l + 4 >> 2] | 0;
p = h;
c[p >> 2] = c[l >>
2];
c[p + 4 >> 2] = u;
u = n;
c[u >> 2] = k;
c[u + 4 >> 2] = x;
z = n;
A = y + 1 | 0;
break
}
x = h + 8 | 0;
if (nb[c[d >> 2] & 31](h, g) | 0)
B = x;
else {
if ((x | 0) == (g | 0)) {
m = 67;
break a
} else
C = x;
while (1) {
D = C + 8 | 0;
if (nb[c[d >> 2] & 31](h, C) | 0)
break;
if ((D | 0) == (g | 0)) {
m = 67;
break a
} else
C = D
}
n = C;
x = c[n >> 2] | 0;
u = c[n + 4 >> 2] | 0;
n = g;
k = c[n + 4 >> 2] | 0;
p = C;
c[p >> 2] = c[n >> 2];
c[p + 4 >> 2] = k;
k = g;
c[k >> 2] = x;
c[k + 4 >> 2] = u;
B = D
}
if ((B | 0) == (g | 0)) {
m = 67;
break a
} else {
E = B;
F = g
}
while (1) {
u = E;
while (1) {
G = u + 8 | 0;
if (nb[c[d >> 2] & 31](h, u) | 0) {
H = F;
break
} else
u = G
}
do H = H + -8 | 0;
while (nb[c[d >> 2] & 31](h, H) | 0);
if (!(u >>>
0 < H >>> 0)) {
h = u;
continue b
}
k = u;
x = c[k >> 2] | 0;
p = c[k + 4 >> 2] | 0;
k = H;
n = c[k + 4 >> 2] | 0;
l = u;
c[l >> 2] = c[k >> 2];
c[l + 4 >> 2] = n;
n = H;
c[n >> 2] = x;
c[n + 4 >> 2] = p;
E = G;
F = H
}
}
while (0);
p = h + 8 | 0;
c:
do if (p >>> 0 < z >>> 0) {
n = p;
x = z;
l = o;
k = A;
while (1) {
w = n;
while (1) {
I = w + 8 | 0;
if (nb[c[d >> 2] & 31](w, l) | 0)
w = I;
else {
J = x;
break
}
}
do J = J + -8 | 0;
while (!(nb[c[d >> 2] & 31](J, l) | 0));
if (w >>> 0 > J >>> 0) {
K = w;
L = l;
M = k;
break c
}
u = w;
v = c[u >> 2] | 0;
t = c[u + 4 >> 2] | 0;
u = J;
q = c[u + 4 >> 2] | 0;
s = w;
c[s >> 2] = c[u >> 2];
c[s + 4 >> 2] = q;
q = J;
c[q >> 2] = v;
c[q + 4 >> 2] = t;
n = I;
x = J;
l = (l | 0) == (w | 0) ? J : l;
k = k + 1 | 0
}
} else {
K = p;
L =
o;
M = A
}
while (0);
if ((K | 0) != (L | 0) ? nb[c[d >> 2] & 31](L, K) | 0 : 0) {
o = K;
p = c[o >> 2] | 0;
k = c[o + 4 >> 2] | 0;
o = L;
l = c[o + 4 >> 2] | 0;
x = K;
c[x >> 2] = c[o >> 2];
c[x + 4 >> 2] = l;
l = L;
c[l >> 2] = p;
c[l + 4 >> 2] = k;
N = M + 1 | 0
} else
N = M;
if ((N | 0) == 0) {
O = bk(h, K, d) | 0;
k = K + 8 | 0;
if (bk(k, a, d) | 0) {
m = 62;
break
}
if (O) {
h = k;
continue
}
}
k = K;
if ((k - j | 0) >= (b - k | 0)) {
m = 66;
break
}
_j(h, K, d);
h = K + 8 | 0
}
if ((m | 0) == 62) {
m = 0;
if (O) {
m = 67;
break
} else {
f = h;
a = K;
continue
}
} else if ((m | 0) == 66) {
m = 0;
_j(K + 8 | 0, a, d);
f = h;
a = K;
continue
}
}
if ((m | 0) == 4) {
if (!(nb[c[d >> 2] & 31](g, h) | 0)) {
i = e;
return
}
K = h;
f = c[K >> 2] | 0;
O = c[K +
4 >> 2] | 0;
K = g;
N = c[K + 4 >> 2] | 0;
M = h;
c[M >> 2] = c[K >> 2];
c[M + 4 >> 2] = N;
N = g;
c[N >> 2] = f;
c[N + 4 >> 2] = O;
i = e;
return
} else if ((m | 0) == 6) {
O = h + 8 | 0;
N = nb[c[d >> 2] & 31](O, h) | 0;
f = nb[c[d >> 2] & 31](g, O) | 0;
if (!N) {
if (!f) {
i = e;
return
}
N = O;
M = c[N >> 2] | 0;
K = c[N + 4 >> 2] | 0;
N = g;
L = c[N + 4 >> 2] | 0;
A = O;
c[A >> 2] = c[N >> 2];
c[A + 4 >> 2] = L;
L = g;
c[L >> 2] = M;
c[L + 4 >> 2] = K;
if (!(nb[c[d >> 2] & 31](O, h) | 0)) {
i = e;
return
}
K = h;
L = c[K >> 2] | 0;
M = c[K + 4 >> 2] | 0;
K = O;
A = c[K + 4 >> 2] | 0;
N = h;
c[N >> 2] = c[K >> 2];
c[N + 4 >> 2] = A;
A = O;
c[A >> 2] = L;
c[A + 4 >> 2] = M;
i = e;
return
}
M = h;
A = c[M >> 2] | 0;
L = c[M + 4 >> 2] | 0;
if (f) {
f = g;
M = c[f +
4 >> 2] | 0;
N = h;
c[N >> 2] = c[f >> 2];
c[N + 4 >> 2] = M;
M = g;
c[M >> 2] = A;
c[M + 4 >> 2] = L;
i = e;
return
}
M = O;
N = c[M + 4 >> 2] | 0;
f = h;
c[f >> 2] = c[M >> 2];
c[f + 4 >> 2] = N;
N = O;
c[N >> 2] = A;
c[N + 4 >> 2] = L;
if (!(nb[c[d >> 2] & 31](g, O) | 0)) {
i = e;
return
}
L = O;
N = c[L >> 2] | 0;
A = c[L + 4 >> 2] | 0;
L = g;
f = c[L + 4 >> 2] | 0;
M = O;
c[M >> 2] = c[L >> 2];
c[M + 4 >> 2] = f;
f = g;
c[f >> 2] = N;
c[f + 4 >> 2] = A;
i = e;
return
} else if ((m | 0) == 14) {
$j(h, h + 8 | 0, h + 16 | 0, g, d) | 0;
i = e;
return
} else if ((m | 0) == 15) {
A = h + 8 | 0;
f = h + 16 | 0;
N = h + 24 | 0;
$j(h, A, f, N, d) | 0;
if (!(nb[c[d >> 2] & 31](g, N) | 0)) {
i = e;
return
}
M = N;
L = c[M >> 2] | 0;
O = c[M + 4 >> 2] | 0;
M = g;
K =
c[M + 4 >> 2] | 0;
J = N;
c[J >> 2] = c[M >> 2];
c[J + 4 >> 2] = K;
K = g;
c[K >> 2] = L;
c[K + 4 >> 2] = O;
if (!(nb[c[d >> 2] & 31](N, f) | 0)) {
i = e;
return
}
O = f;
K = c[O >> 2] | 0;
L = c[O + 4 >> 2] | 0;
O = N;
g = c[O + 4 >> 2] | 0;
J = f;
c[J >> 2] = c[O >> 2];
c[J + 4 >> 2] = g;
g = N;
c[g >> 2] = K;
c[g + 4 >> 2] = L;
if (!(nb[c[d >> 2] & 31](f, A) | 0)) {
i = e;
return
}
L = A;
g = c[L >> 2] | 0;
K = c[L + 4 >> 2] | 0;
L = f;
N = c[L + 4 >> 2] | 0;
J = A;
c[J >> 2] = c[L >> 2];
c[J + 4 >> 2] = N;
N = f;
c[N >> 2] = g;
c[N + 4 >> 2] = K;
if (!(nb[c[d >> 2] & 31](A, h) | 0)) {
i = e;
return
}
K = h;
N = c[K >> 2] | 0;
g = c[K + 4 >> 2] | 0;
K = A;
f = c[K + 4 >> 2] | 0;
J = h;
c[J >> 2] = c[K >> 2];
c[J + 4 >> 2] = f;
f = A;
c[f >> 2] = N;
c[f + 4 >>
2] = g;
i = e;
return
} else if ((m | 0) == 21) {
ak(h, a, d);
i = e;
return
} else if ((m | 0) == 67) {
i = e;
return
}
}
function $j(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0;
g = i;
h = nb[c[f >> 2] & 31](b, a) | 0;
j = nb[c[f >> 2] & 31](d, b) | 0;
do if (h) {
k = a;
l = c[k >> 2] | 0;
m = c[k + 4 >> 2] | 0;
if (j) {
k = d;
n = c[k + 4 >> 2] | 0;
o = a;
c[o >> 2] = c[k >> 2];
c[o + 4 >> 2] = n;
n = d;
c[n >> 2] = l;
c[n + 4 >> 2] = m;
p = 1;
break
}
n = b;
o = c[n + 4 >> 2] | 0;
k = a;
c[k >> 2] = c[n >> 2];
c[k + 4 >> 2] = o;
o = b;
c[o >> 2] = l;
c[o + 4 >> 2] = m;
if (nb[c[f >> 2] & 31](d, b) | 0) {
m = b;
o = c[m >> 2] | 0;
l = c[m + 4 >> 2] | 0;
m =
d;
k = c[m + 4 >> 2] | 0;
n = b;
c[n >> 2] = c[m >> 2];
c[n + 4 >> 2] = k;
k = d;
c[k >> 2] = o;
c[k + 4 >> 2] = l;
p = 2
} else
p = 1
} else if (j) {
l = b;
k = c[l >> 2] | 0;
o = c[l + 4 >> 2] | 0;
l = d;
n = c[l + 4 >> 2] | 0;
m = b;
c[m >> 2] = c[l >> 2];
c[m + 4 >> 2] = n;
n = d;
c[n >> 2] = k;
c[n + 4 >> 2] = o;
if (nb[c[f >> 2] & 31](b, a) | 0) {
o = a;
n = c[o >> 2] | 0;
k = c[o + 4 >> 2] | 0;
o = b;
m = c[o + 4 >> 2] | 0;
l = a;
c[l >> 2] = c[o >> 2];
c[l + 4 >> 2] = m;
m = b;
c[m >> 2] = n;
c[m + 4 >> 2] = k;
p = 2
} else
p = 1
} else
p = 0;
while (0);
if (!(nb[c[f >> 2] & 31](e, d) | 0)) {
q = p;
i = g;
return q | 0
}
j = d;
h = c[j >> 2] | 0;
k = c[j + 4 >> 2] | 0;
j = e;
m = c[j + 4 >> 2] | 0;
n = d;
c[n >> 2] = c[j >> 2];
c[n + 4 >> 2] = m;
m = e;
c[m >>
2] = h;
c[m + 4 >> 2] = k;
if (!(nb[c[f >> 2] & 31](d, b) | 0)) {
q = p + 1 | 0;
i = g;
return q | 0
}
k = b;
m = c[k >> 2] | 0;
h = c[k + 4 >> 2] | 0;
k = d;
e = c[k + 4 >> 2] | 0;
n = b;
c[n >> 2] = c[k >> 2];
c[n + 4 >> 2] = e;
e = d;
c[e >> 2] = m;
c[e + 4 >> 2] = h;
if (!(nb[c[f >> 2] & 31](b, a) | 0)) {
q = p + 2 | 0;
i = g;
return q | 0
}
f = a;
h = c[f >> 2] | 0;
e = c[f + 4 >> 2] | 0;
f = b;
m = c[f + 4 >> 2] | 0;
d = a;
c[d >> 2] = c[f >> 2];
c[d + 4 >> 2] = m;
m = b;
c[m >> 2] = h;
c[m + 4 >> 2] = e;
q = p + 3 | 0;
i = g;
return q | 0
}
function ak(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0;
e = i;
i = i + 16 | 0;
f = e;
g = a + 16 | 0;
h = a + 8 | 0;
j = nb[c[d >> 2] & 31](h,
a) | 0;
k = nb[c[d >> 2] & 31](g, h) | 0;
do if (j) {
l = a;
m = c[l >> 2] | 0;
n = c[l + 4 >> 2] | 0;
if (k) {
l = g;
o = c[l + 4 >> 2] | 0;
p = a;
c[p >> 2] = c[l >> 2];
c[p + 4 >> 2] = o;
o = g;
c[o >> 2] = m;
c[o + 4 >> 2] = n;
break
}
o = h;
p = c[o + 4 >> 2] | 0;
l = a;
c[l >> 2] = c[o >> 2];
c[l + 4 >> 2] = p;
p = h;
c[p >> 2] = m;
c[p + 4 >> 2] = n;
if (nb[c[d >> 2] & 31](g, h) | 0) {
n = h;
p = c[n >> 2] | 0;
m = c[n + 4 >> 2] | 0;
n = g;
l = c[n + 4 >> 2] | 0;
o = h;
c[o >> 2] = c[n >> 2];
c[o + 4 >> 2] = l;
l = g;
c[l >> 2] = p;
c[l + 4 >> 2] = m
}
} else if (k ? (m = h, l = c[m >> 2] | 0, p = c[m + 4 >> 2] | 0, m = g, o = c[m + 4 >> 2] | 0, n = h, c[n >> 2] = c[m >> 2], c[n + 4 >> 2] = o, o = g, c[o >> 2] = l, c[o + 4 >> 2] = p, nb[c[d >> 2] & 31](h, a) |
0) : 0) {
p = a;
o = c[p >> 2] | 0;
l = c[p + 4 >> 2] | 0;
p = h;
n = c[p + 4 >> 2] | 0;
m = a;
c[m >> 2] = c[p >> 2];
c[m + 4 >> 2] = n;
n = h;
c[n >> 2] = o;
c[n + 4 >> 2] = l
}
while (0);
h = a + 24 | 0;
if ((h | 0) == (b | 0)) {
i = e;
return
} else {
q = h;
r = g
}
while (1) {
if (nb[c[d >> 2] & 31](q, r) | 0) {
g = q;
h = c[g + 4 >> 2] | 0;
k = f;
c[k >> 2] = c[g >> 2];
c[k + 4 >> 2] = h;
h = q;
k = r;
while (1) {
g = k;
j = c[g + 4 >> 2] | 0;
l = h;
c[l >> 2] = c[g >> 2];
c[l + 4 >> 2] = j;
if ((k | 0) == (a | 0))
break;
j = k + -8 | 0;
if (nb[c[d >> 2] & 31](f, j) | 0) {
l = k;
k = j;
h = l
} else
break
}
h = f;
l = c[h + 4 >> 2] | 0;
j = k;
c[j >> 2] = c[h >> 2];
c[j + 4 >> 2] = l
}
l = q + 8 | 0;
if ((l | 0) == (b | 0))
break;
else {
j = q;
q = l;
r = j
}
}
i =
e;
return
}
function bk(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0;
e = i;
i = i + 16 | 0;
f = e;
switch (b - a >> 3 | 0) {
case 2:
g = b + -8 | 0;
if (!(nb[c[d >> 2] & 31](g, a) | 0)) {
h = 1;
i = e;
return h | 0
}
j = a;
k = c[j >> 2] | 0;
l = c[j + 4 >> 2] | 0;
j = g;
m = c[j + 4 >> 2] | 0;
n = a;
c[n >> 2] = c[j >> 2];
c[n + 4 >> 2] = m;
m = g;
c[m >> 2] = k;
c[m + 4 >> 2] = l;
h = 1;
i = e;
return h | 0;
case 4:
$j(a, a + 8 | 0, a + 16 | 0, b + -8 | 0, d) | 0;
h = 1;
i = e;
return h | 0;
case 5:
l = a + 8 | 0;
m = a + 16 | 0;
k = a + 24 | 0;
g = b + -8 | 0;
$j(a, l, m, k, d) | 0;
if (!(nb[c[d >> 2] & 31](g, k) | 0)) {
h = 1;
i = e;
return h |
0
}
n = k;
j = c[n >> 2] | 0;
o = c[n + 4 >> 2] | 0;
n = g;
p = c[n + 4 >> 2] | 0;
q = k;
c[q >> 2] = c[n >> 2];
c[q + 4 >> 2] = p;
p = g;
c[p >> 2] = j;
c[p + 4 >> 2] = o;
if (!(nb[c[d >> 2] & 31](k, m) | 0)) {
h = 1;
i = e;
return h | 0
}
o = m;
p = c[o >> 2] | 0;
j = c[o + 4 >> 2] | 0;
o = k;
g = c[o + 4 >> 2] | 0;
q = m;
c[q >> 2] = c[o >> 2];
c[q + 4 >> 2] = g;
g = k;
c[g >> 2] = p;
c[g + 4 >> 2] = j;
if (!(nb[c[d >> 2] & 31](m, l) | 0)) {
h = 1;
i = e;
return h | 0
}
j = l;
g = c[j >> 2] | 0;
p = c[j + 4 >> 2] | 0;
j = m;
k = c[j + 4 >> 2] | 0;
q = l;
c[q >> 2] = c[j >> 2];
c[q + 4 >> 2] = k;
k = m;
c[k >> 2] = g;
c[k + 4 >> 2] = p;
if (!(nb[c[d >> 2] & 31](l, a) | 0)) {
h = 1;
i = e;
return h | 0
}
p = a;
k = c[p >> 2] | 0;
g = c[p + 4 >> 2] | 0;
p = l;
m = c[p +
4 >> 2] | 0;
q = a;
c[q >> 2] = c[p >> 2];
c[q + 4 >> 2] = m;
m = l;
c[m >> 2] = k;
c[m + 4 >> 2] = g;
h = 1;
i = e;
return h | 0;
case 3:
g = a + 8 | 0;
m = b + -8 | 0;
k = nb[c[d >> 2] & 31](g, a) | 0;
l = nb[c[d >> 2] & 31](m, g) | 0;
if (!k) {
if (!l) {
h = 1;
i = e;
return h | 0
}
k = g;
q = c[k >> 2] | 0;
p = c[k + 4 >> 2] | 0;
k = m;
j = c[k + 4 >> 2] | 0;
o = g;
c[o >> 2] = c[k >> 2];
c[o + 4 >> 2] = j;
j = m;
c[j >> 2] = q;
c[j + 4 >> 2] = p;
if (!(nb[c[d >> 2] & 31](g, a) | 0)) {
h = 1;
i = e;
return h | 0
}
p = a;
j = c[p >> 2] | 0;
q = c[p + 4 >> 2] | 0;
p = g;
o = c[p + 4 >> 2] | 0;
k = a;
c[k >> 2] = c[p >> 2];
c[k + 4 >> 2] = o;
o = g;
c[o >> 2] = j;
c[o + 4 >> 2] = q;
h = 1;
i = e;
return h | 0
}
q = a;
o = c[q >> 2] | 0;
j = c[q + 4 >> 2] | 0;
if (l) {
l =
m;
q = c[l + 4 >> 2] | 0;
k = a;
c[k >> 2] = c[l >> 2];
c[k + 4 >> 2] = q;
q = m;
c[q >> 2] = o;
c[q + 4 >> 2] = j;
h = 1;
i = e;
return h | 0
}
q = g;
k = c[q + 4 >> 2] | 0;
l = a;
c[l >> 2] = c[q >> 2];
c[l + 4 >> 2] = k;
k = g;
c[k >> 2] = o;
c[k + 4 >> 2] = j;
if (!(nb[c[d >> 2] & 31](m, g) | 0)) {
h = 1;
i = e;
return h | 0
}
j = g;
k = c[j >> 2] | 0;
o = c[j + 4 >> 2] | 0;
j = m;
l = c[j + 4 >> 2] | 0;
q = g;
c[q >> 2] = c[j >> 2];
c[q + 4 >> 2] = l;
l = m;
c[l >> 2] = k;
c[l + 4 >> 2] = o;
h = 1;
i = e;
return h | 0;
case 1:
case 0:
h = 1;
i = e;
return h | 0;
default:
o = a + 16 | 0;
l = a + 8 | 0;
k = nb[c[d >> 2] & 31](l, a) | 0;
m = nb[c[d >> 2] & 31](o, l) | 0;
do if (k) {
q = a;
j = c[q >> 2] | 0;
g = c[q + 4 >> 2] | 0;
if (m) {
q = o;
p = c[q +
4 >> 2] | 0;
n = a;
c[n >> 2] = c[q >> 2];
c[n + 4 >> 2] = p;
p = o;
c[p >> 2] = j;
c[p + 4 >> 2] = g;
break
}
p = l;
n = c[p + 4 >> 2] | 0;
q = a;
c[q >> 2] = c[p >> 2];
c[q + 4 >> 2] = n;
n = l;
c[n >> 2] = j;
c[n + 4 >> 2] = g;
if (nb[c[d >> 2] & 31](o, l) | 0) {
g = l;
n = c[g >> 2] | 0;
j = c[g + 4 >> 2] | 0;
g = o;
q = c[g + 4 >> 2] | 0;
p = l;
c[p >> 2] = c[g >> 2];
c[p + 4 >> 2] = q;
q = o;
c[q >> 2] = n;
c[q + 4 >> 2] = j
}
} else if (m ? (j = l, q = c[j >> 2] | 0, n = c[j + 4 >> 2] | 0, j = o, p = c[j + 4 >> 2] | 0, g = l, c[g >> 2] = c[j >> 2], c[g + 4 >> 2] = p, p = o, c[p >> 2] = q, c[p + 4 >> 2] = n, nb[c[d >> 2] & 31](l, a) | 0) : 0) {
n = a;
p = c[n >> 2] | 0;
q = c[n + 4 >> 2] | 0;
n = l;
g = c[n + 4 >> 2] | 0;
j = a;
c[j >> 2] = c[n >> 2];
c[j + 4 >> 2] =
g;
g = l;
c[g >> 2] = p;
c[g + 4 >> 2] = q
}
while (0);
l = a + 24 | 0;
if ((l | 0) == (b | 0)) {
h = 1;
i = e;
return h | 0
} else {
r = 0;
s = l;
t = o
}
while (1) {
if (nb[c[d >> 2] & 31](s, t) | 0) {
o = s;
l = c[o + 4 >> 2] | 0;
m = f;
c[m >> 2] = c[o >> 2];
c[m + 4 >> 2] = l;
l = s;
m = t;
while (1) {
o = m;
k = c[o + 4 >> 2] | 0;
q = l;
c[q >> 2] = c[o >> 2];
c[q + 4 >> 2] = k;
if ((m | 0) == (a | 0))
break;
k = m + -8 | 0;
if (nb[c[d >> 2] & 31](f, k) | 0) {
q = m;
m = k;
l = q
} else
break
}
l = f;
q = c[l + 4 >> 2] | 0;
k = m;
c[k >> 2] = c[l >> 2];
c[k + 4 >> 2] = q;
q = r + 1 | 0;
if ((q | 0) == 8)
break;
else
u = q
} else
u = r;
q = s + 8 | 0;
if ((q | 0) == (b | 0)) {
h = 1;
v = 34;
break
} else {
k = s;
r = u;
s = q;
t = k
}
}
if ((v | 0) == 34) {
i =
e;
return h | 0
}
h = (s + 8 | 0) == (b | 0);
i = e;
return h | 0
}
return 0
}
function ck(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function dk(a, b) {
a = a | 0;
b = b | 0;
return
}
function ek(a, b) {
a = a | 0;
b = b | 0;
return
}
function fk(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
return
}
function gk(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
return
}
function hk(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0;
e = i;
c[a >> 2] = b;
c[a + 4 >> 2] = Ym(b, d << 4) | 0;
c[a + 8 >> 2] = d;
d = a + 12 | 0;
c[d + 0 >> 2] = 0;
c[d + 4 >> 2] = 0;
c[d + 8 >> 2] = 0;
c[d + 12 >> 2] = 0;
i = e;
return
}
function ik(a) {
a = a | 0;
var b = 0,
d = 0;
b = i;
d = c[a + 24 >> 2] | 0;
if ((d | 0) != 0)
_m(c[a >> 2] |
0, d);
_m(c[a >> 2] | 0, c[a + 4 >> 2] | 0);
i = b;
return
}
function jk(b, d, e, f) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0,
h = 0,
i = 0;
g = b + 12 | 0;
h = c[g >> 2] | 0;
c[g >> 2] = h + 1;
g = c[b + 4 >> 2] | 0;
b = d;
d = c[b + 4 >> 2] | 0;
i = g + (h << 4) | 0;
c[i >> 2] = c[b >> 2];
c[i + 4 >> 2] = d;
c[g + (h << 4) + 8 >> 2] = e;
a[g + (h << 4) + 12 >> 0] = f & 1;
return
}
function kk(b, d, e) {
b = b | 0;
d = +d;
e = +e;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
ba = 0,
ca = 0,
da = 0,
ea =
0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0,
ya = 0,
za = 0,
Aa = 0,
Ba = 0,
Ca = 0,
Da = 0,
Ea = 0,
Fa = 0,
Ga = 0,
Ha = 0,
Ia = 0,
Ja = 0,
Ka = 0,
La = 0,
Ma = 0,
Na = 0,
Oa = 0,
Pa = 0,
Qa = 0,
Ra = 0,
Sa = 0,
Ta = 0,
Ua = 0,
Va = 0,
Wa = 0,
Xa = 0,
Ya = 0,
Za = 0,
_a = 0,
$a = 0,
ab = 0,
bb = 0,
cb = 0,
db = 0,
eb = 0,
fb = 0,
gb = 0,
hb = 0,
ib = 0,
jb = 0,
kb = 0,
lb = 0,
mb = 0,
nb = 0,
ob = 0,
pb = 0,
qb = 0,
rb = 0,
sb = 0,
tb = 0,
ub = 0,
vb = 0,
wb = 0,
xb = 0,
yb = 0,
zb = 0,
Ab = 0,
Bb = 0,
Cb = 0,
Db = 0,
Eb = 0,
Fb = 0,
Gb = 0,
Hb = 0,
Ib = 0,
Jb = 0,
Kb = 0,
Lb = 0,
Mb = 0,
Nb = 0,
Ob = 0,
Pb = 0,
Qb = 0,
Rb = 0,
Sb = 0,
Tb = 0,
Ub = 0,
Vb = 0,
Wb = 0,
Xb = 0,
Yb = 0,
Zb = 0,
_b = 0,
$b = 0,
ac = 0,
bc = 0,
cc = 0,
dc = 0,
ec = 0,
fc = 0,
gc = 0,
hc = 0,
ic = 0,
jc = 0;
f = i;
h = 1 / d;
j = b + 12 | 0;
k = c[j >> 2] | 0;
if ((k | 0) > 0) {
l = c[b + 4 >> 2] | 0;
d = 3.4028234663852886E38;
m = 3.4028234663852886E38;
n = -3.4028234663852886E38;
o = -3.4028234663852886E38;
p = 0;
while (1) {
if ((a[l + (p << 4) + 12 >> 0] | 0) == 0) {
q = m;
r = d;
s = o;
t = n
} else {
u = +g[l + (p << 4) >> 2];
v = +g[l + (p << 4) + 4 >> 2];
q = m < v ? m : v;
r = d < u ? d : u;
s = o > v ? o : v;
t = n > u ? n : u
}
p = p + 1 | 0;
if ((p | 0) >= (k | 0)) {
w = q;
x = r;
y = s;
z = t;
break
} else {
d = r;
m = q;
n = t;
o = s
}
}
} else {
w = 3.4028234663852886E38;
x = 3.4028234663852886E38;
y = -3.4028234663852886E38;
z = -3.4028234663852886E38
}
s = x - e;
x = w - e;
k = ~~(h * (z + e - s)) + 1 | 0;
p = b + 16 | 0;
c[p >> 2] = k;
l = ~~(h * (y + e - x)) + 1 | 0;
A = b + 20 | 0;
c[A >> 2] = l;
B = Ym(c[b >> 2] | 0, aa(l << 2, k) | 0) | 0;
k = b + 24 | 0;
c[k >> 2] = B;
l = c[p >> 2] | 0;
C = c[A >> 2] | 0;
D = aa(C, l) | 0;
a:
do if ((D | 0) > 0) {
E = B;
F = 0;
while (1) {
c[E + (F << 2) >> 2] = 0;
G = F + 1 | 0;
if ((G | 0) >= (D | 0))
break a;
E = c[k >> 2] | 0;
F = G
}
}
while (0);
D = c[b >> 2] | 0;
B = aa(l << 2, C) | 0;
C = Ym(D, B << 4) | 0;
if ((c[j >> 2] | 0) > 0) {
l = b + 4 | 0;
b = 0;
F = B;
E = C;
G = 0;
while (1) {
H = c[l >> 2] | 0;
I = H + (G << 4) | 0;
J = H + (G << 4) + 4 | 0;
e = h * (+g[I >> 2] - s);
y = +e;
z = +(h * (+g[J >> 2] - x));
H = I;
g[H >> 2] = y;
g[H +
4 >> 2] = z;
H = ~~e;
K = ~~+g[J >> 2];
if (((K | H | 0) > -1 ? (J = c[p >> 2] | 0, (H | 0) < (J | 0)) : 0) ? (K | 0) < (c[A >> 2] | 0) : 0) {
L = (aa(J, K) | 0) + H | 0;
if ((b | 0) < (F | 0)) {
M = F;
N = E
} else {
if ((b | 0) > 0) {
J = 0;
do J = J + 1 | 0;
while ((J | 0) != (b | 0))
}
J = (F | 0) > 0 ? F << 1 : 1;
M = J;
N = Zm(D, E, J << 4) | 0
}
c[N + (b << 4) >> 2] = H;
c[N + (b << 4) + 4 >> 2] = K;
c[N + (b << 4) + 8 >> 2] = L;
c[N + (b << 4) + 12 >> 2] = I;
O = M;
P = b + 1 | 0;
Q = N
} else {
O = F;
P = b;
Q = E
}
G = G + 1 | 0;
if ((G | 0) >= (c[j >> 2] | 0)) {
R = O;
S = P;
T = 0;
U = Q;
break
} else {
b = P;
F = O;
E = Q
}
}
} else {
R = B;
S = 0;
T = 0;
U = C
}
b:
while (1) {
C = T;
do {
if ((C | 0) == (S | 0))
break b;
V = c[U + (C << 4) >> 2] | 0;
W = c[U + (C << 4) + 4 >>
2] | 0;
X = c[U + (C << 4) + 8 >> 2] | 0;
Y = c[U + (C << 4) + 12 >> 2] | 0;
C = C + 1 | 0;
Z = (c[k >> 2] | 0) + (X << 2) | 0
} while ((c[Z >> 2] | 0) != 0);
c[Z >> 2] = Y;
if ((V | 0) > 0) {
I = V + -1 | 0;
L = X + -1 | 0;
if ((S | 0) >= (R | 0)) {
if ((C | 0) < (S | 0)) {
K = C;
do {
H = U + (K - C << 4) | 0;
B = U + (K << 4) | 0;
c[H + 0 >> 2] = c[B + 0 >> 2];
c[H + 4 >> 2] = c[B + 4 >> 2];
c[H + 8 >> 2] = c[B + 8 >> 2];
c[H + 12 >> 2] = c[B + 12 >> 2];
K = K + 1 | 0
} while ((K | 0) != (S | 0))
}
K = S - C | 0;
if ((K | 0) < (R | 0)) {
_ = U;
$ = K;
ba = R;
ca = 0
} else {
B = (R | 0) > 0 ? R << 1 : 1;
_ = Zm(D, U, B << 4) | 0;
$ = K;
ba = B;
ca = 0
}
} else {
_ = U;
$ = S;
ba = R;
ca = C
}
c[_ + ($ << 4) >> 2] = I;
c[_ + ($ << 4) + 4 >> 2] = W;
c[_ + ($ << 4) + 8 >> 2] = L;
c[_ + ($ <<
4) + 12 >> 2] = Y;
da = $ + 1 | 0;
ea = ba;
fa = ca;
ga = _
} else {
da = S;
ea = R;
fa = C;
ga = U
}
if ((W | 0) > 0) {
B = W + -1 | 0;
K = X - (c[p >> 2] | 0) | 0;
if ((da | 0) >= (ea | 0)) {
if ((fa | 0) < (da | 0)) {
H = fa;
do {
Q = ga + (H - fa << 4) | 0;
E = ga + (H << 4) | 0;
c[Q + 0 >> 2] = c[E + 0 >> 2];
c[Q + 4 >> 2] = c[E + 4 >> 2];
c[Q + 8 >> 2] = c[E + 8 >> 2];
c[Q + 12 >> 2] = c[E + 12 >> 2];
H = H + 1 | 0
} while ((H | 0) != (da | 0))
}
H = da - fa | 0;
if ((H | 0) < (ea | 0)) {
ha = ga;
ia = H;
ja = ea;
ka = 0
} else {
C = (ea | 0) > 0 ? ea << 1 : 1;
ha = Zm(D, ga, C << 4) | 0;
ia = H;
ja = C;
ka = 0
}
} else {
ha = ga;
ia = da;
ja = ea;
ka = fa
}
c[ha + (ia << 4) >> 2] = V;
c[ha + (ia << 4) + 4 >> 2] = B;
c[ha + (ia << 4) + 8 >> 2] = K;
c[ha + (ia << 4) + 12 >>
2] = Y;
la = ia + 1 | 0;
ma = ja;
na = ka;
oa = ha
} else {
la = da;
ma = ea;
na = fa;
oa = ga
}
if ((V | 0) < ((c[p >> 2] | 0) + -1 | 0)) {
C = V + 1 | 0;
H = X + 1 | 0;
if ((la | 0) >= (ma | 0)) {
if ((na | 0) < (la | 0)) {
L = na;
do {
I = oa + (L - na << 4) | 0;
E = oa + (L << 4) | 0;
c[I + 0 >> 2] = c[E + 0 >> 2];
c[I + 4 >> 2] = c[E + 4 >> 2];
c[I + 8 >> 2] = c[E + 8 >> 2];
c[I + 12 >> 2] = c[E + 12 >> 2];
L = L + 1 | 0
} while ((L | 0) != (la | 0))
}
L = la - na | 0;
if ((L | 0) < (ma | 0)) {
pa = oa;
qa = L;
ra = ma;
sa = 0
} else {
K = (ma | 0) > 0 ? ma << 1 : 1;
pa = Zm(D, oa, K << 4) | 0;
qa = L;
ra = K;
sa = 0
}
} else {
pa = oa;
qa = la;
ra = ma;
sa = na
}
c[pa + (qa << 4) >> 2] = C;
c[pa + (qa << 4) + 4 >> 2] = W;
c[pa + (qa << 4) + 8 >> 2] = H;
c[pa + (qa <<
4) + 12 >> 2] = Y;
ta = qa + 1 | 0;
ua = ra;
va = sa;
wa = pa
} else {
ta = la;
ua = ma;
va = na;
wa = oa
}
if ((W | 0) >= ((c[A >> 2] | 0) + -1 | 0)) {
R = ua;
S = ta;
T = va;
U = wa;
continue
}
K = W + 1 | 0;
L = (c[p >> 2] | 0) + X | 0;
if ((ta | 0) >= (ua | 0)) {
if ((va | 0) < (ta | 0)) {
B = va;
do {
E = wa + (B - va << 4) | 0;
I = wa + (B << 4) | 0;
c[E + 0 >> 2] = c[I + 0 >> 2];
c[E + 4 >> 2] = c[I + 4 >> 2];
c[E + 8 >> 2] = c[I + 8 >> 2];
c[E + 12 >> 2] = c[I + 12 >> 2];
B = B + 1 | 0
} while ((B | 0) != (ta | 0))
}
B = ta - va | 0;
if ((B | 0) < (ua | 0)) {
xa = wa;
ya = B;
za = ua;
Aa = 0
} else {
H = (ua | 0) > 0 ? ua << 1 : 1;
xa = Zm(D, wa, H << 4) | 0;
ya = B;
za = H;
Aa = 0
}
} else {
xa = wa;
ya = ta;
za = ua;
Aa = va
}
c[xa + (ya << 4) >> 2] = V;
c[xa +
(ya << 4) + 4 >> 2] = K;
c[xa + (ya << 4) + 8 >> 2] = L;
c[xa + (ya << 4) + 12 >> 2] = Y;
R = za;
S = ya + 1 | 0;
T = Aa;
U = xa
}
xa = c[A >> 2] | 0;
if ((xa | 0) > 0) {
Aa = c[p >> 2] | 0;
T = xa;
ya = U;
za = S;
Y = S;
V = R;
va = 0;
while (1) {
if ((Aa + -1 | 0) > 0) {
ua = Aa;
ta = Y;
wa = V;
X = za;
W = ya;
oa = 0;
while (1) {
na = (aa(ua, va) | 0) + oa | 0;
ma = c[k >> 2] | 0;
la = c[ma + (na << 2) >> 2] | 0;
pa = na + 1 | 0;
sa = c[ma + (pa << 2) >> 2] | 0;
if ((la | 0) == (sa | 0)) {
Ba = oa + 1 | 0;
Ca = ua;
Da = wa;
Ea = ta;
Fa = X;
Ga = W
} else {
if ((ta | 0) >= (wa | 0)) {
if ((X | 0) < (ta | 0)) {
ma = X;
do {
ra = W + (ma - X << 4) | 0;
qa = W + (ma << 4) | 0;
c[ra + 0 >> 2] = c[qa + 0 >> 2];
c[ra + 4 >> 2] = c[qa + 4 >> 2];
c[ra + 8 >> 2] = c[qa +
8 >> 2];
c[ra + 12 >> 2] = c[qa + 12 >> 2];
ma = ma + 1 | 0
} while ((ma | 0) != (ta | 0))
}
ma = ta - X | 0;
if ((ma | 0) < (wa | 0)) {
Ha = W;
Ia = ma;
Ja = wa;
Ka = 0
} else {
qa = (wa | 0) > 0 ? wa << 1 : 1;
Ha = Zm(D, W, qa << 4) | 0;
Ia = ma;
Ja = qa;
Ka = 0
}
} else {
Ha = W;
Ia = ta;
Ja = wa;
Ka = X
}
c[Ha + (Ia << 4) >> 2] = oa;
c[Ha + (Ia << 4) + 4 >> 2] = va;
c[Ha + (Ia << 4) + 8 >> 2] = na;
c[Ha + (Ia << 4) + 12 >> 2] = sa;
qa = Ia + 1 | 0;
ma = oa + 1 | 0;
if ((qa | 0) >= (Ja | 0)) {
if ((Ka | 0) < (qa | 0)) {
ra = Ka;
do {
ga = Ha + (ra - Ka << 4) | 0;
fa = Ha + (ra << 4) | 0;
c[ga + 0 >> 2] = c[fa + 0 >> 2];
c[ga + 4 >> 2] = c[fa + 4 >> 2];
c[ga + 8 >> 2] = c[fa + 8 >> 2];
c[ga + 12 >> 2] = c[fa + 12 >> 2];
ra = ra + 1 | 0
} while ((ra | 0) !=
(qa | 0))
}
ra = qa - Ka | 0;
if ((ra | 0) < (Ja | 0)) {
La = Ha;
Ma = ra;
Na = Ja;
Oa = 0
} else {
sa = (Ja | 0) > 0 ? Ja << 1 : 1;
La = Zm(D, Ha, sa << 4) | 0;
Ma = ra;
Na = sa;
Oa = 0
}
} else {
La = Ha;
Ma = qa;
Na = Ja;
Oa = Ka
}
c[La + (Ma << 4) >> 2] = ma;
c[La + (Ma << 4) + 4 >> 2] = va;
c[La + (Ma << 4) + 8 >> 2] = pa;
c[La + (Ma << 4) + 12 >> 2] = la;
Ba = ma;
Ca = c[p >> 2] | 0;
Da = Na;
Ea = Ma + 1 | 0;
Fa = Oa;
Ga = La
}
if ((Ba | 0) < (Ca + -1 | 0)) {
ua = Ca;
ta = Ea;
wa = Da;
X = Fa;
W = Ga;
oa = Ba
} else
break
}
Pa = Da;
Qa = Ea;
Ra = Fa;
Sa = Ga;
Ta = c[A >> 2] | 0;
Ua = Ca
} else {
Pa = V;
Qa = Y;
Ra = za;
Sa = ya;
Ta = T;
Ua = Aa
}
va = va + 1 | 0;
if ((va | 0) >= (Ta | 0)) {
Va = Pa;
Wa = Qa;
Xa = Ra;
Ya = Sa;
Za = Ta;
break
} else {
Aa =
Ua;
T = Ta;
ya = Sa;
za = Ra;
Y = Qa;
V = Pa
}
}
} else {
Va = R;
Wa = S;
Xa = S;
Ya = U;
Za = xa
}
if ((Za + -1 | 0) > 0) {
xa = c[p >> 2] | 0;
U = Za;
Za = Ya;
S = Xa;
R = Wa;
Pa = Va;
V = 0;
while (1) {
Qa = V;
V = V + 1 | 0;
if ((xa | 0) > 0) {
Y = xa;
Ra = R;
za = Pa;
Sa = S;
ya = Za;
Ta = 0;
while (1) {
T = (aa(Y, Qa) | 0) + Ta | 0;
Ua = c[k >> 2] | 0;
Aa = c[Ua + (T << 2) >> 2] | 0;
va = c[Ua + (T + Y << 2) >> 2] | 0;
if ((Aa | 0) == (va | 0)) {
_a = Y;
$a = za;
ab = Ra;
bb = Sa;
cb = ya
} else {
if ((Ra | 0) >= (za | 0)) {
if ((Sa | 0) < (Ra | 0)) {
Ua = Sa;
do {
Ca = ya + (Ua - Sa << 4) | 0;
Ga = ya + (Ua << 4) | 0;
c[Ca + 0 >> 2] = c[Ga + 0 >> 2];
c[Ca + 4 >> 2] = c[Ga + 4 >> 2];
c[Ca + 8 >> 2] = c[Ga + 8 >> 2];
c[Ca + 12 >> 2] = c[Ga + 12 >> 2];
Ua =
Ua + 1 | 0
} while ((Ua | 0) != (Ra | 0))
}
Ua = Ra - Sa | 0;
if ((Ua | 0) < (za | 0)) {
db = ya;
eb = Ua;
fb = za;
gb = 0
} else {
ma = (za | 0) > 0 ? za << 1 : 1;
db = Zm(D, ya, ma << 4) | 0;
eb = Ua;
fb = ma;
gb = 0
}
} else {
db = ya;
eb = Ra;
fb = za;
gb = Sa
}
c[db + (eb << 4) >> 2] = Ta;
c[db + (eb << 4) + 4 >> 2] = Qa;
c[db + (eb << 4) + 8 >> 2] = T;
c[db + (eb << 4) + 12 >> 2] = va;
ma = eb + 1 | 0;
Ua = (c[p >> 2] | 0) + T | 0;
if ((ma | 0) >= (fb | 0)) {
if ((gb | 0) < (ma | 0)) {
la = gb;
do {
pa = db + (la - gb << 4) | 0;
qa = db + (la << 4) | 0;
c[pa + 0 >> 2] = c[qa + 0 >> 2];
c[pa + 4 >> 2] = c[qa + 4 >> 2];
c[pa + 8 >> 2] = c[qa + 8 >> 2];
c[pa + 12 >> 2] = c[qa + 12 >> 2];
la = la + 1 | 0
} while ((la | 0) != (ma | 0))
}
la = ma - gb | 0;
if ((la | 0) < (fb | 0)) {
hb = db;
ib = la;
jb = fb;
kb = 0
} else {
T = (fb | 0) > 0 ? fb << 1 : 1;
hb = Zm(D, db, T << 4) | 0;
ib = la;
jb = T;
kb = 0
}
} else {
hb = db;
ib = ma;
jb = fb;
kb = gb
}
c[hb + (ib << 4) >> 2] = Ta;
c[hb + (ib << 4) + 4 >> 2] = V;
c[hb + (ib << 4) + 8 >> 2] = Ua;
c[hb + (ib << 4) + 12 >> 2] = Aa;
_a = c[p >> 2] | 0;
$a = jb;
ab = ib + 1 | 0;
bb = kb;
cb = hb
}
Ta = Ta + 1 | 0;
if ((Ta | 0) >= (_a | 0))
break;
else {
Y = _a;
Ra = ab;
za = $a;
Sa = bb;
ya = cb
}
}
lb = $a;
mb = ab;
nb = bb;
ob = cb;
pb = c[A >> 2] | 0;
qb = _a
} else {
lb = Pa;
mb = R;
nb = S;
ob = Za;
pb = U;
qb = xa
}
if ((V | 0) >= (pb + -1 | 0)) {
rb = lb;
sb = mb;
tb = nb;
ub = ob;
break
} else {
xa = qb;
U = pb;
Za = ob;
S = nb;
R = mb;
Pa = lb
}
}
} else {
rb =
Va;
sb = Wa;
tb = Xa;
ub = Ya
}
if ((tb | 0) == (sb | 0)) {
vb = ub;
_m(D, vb);
i = f;
return
} else {
wb = rb;
xb = sb;
yb = tb;
zb = ub
}
c:
while (1) {
ub = c[k >> 2] | 0;
tb = yb;
while (1) {
Ab = c[zb + (tb << 4) >> 2] | 0;
Bb = c[zb + (tb << 4) + 4 >> 2] | 0;
Cb = c[zb + (tb << 4) + 8 >> 2] | 0;
Db = c[zb + (tb << 4) + 12 >> 2] | 0;
tb = tb + 1 | 0;
Eb = ub + (Cb << 2) | 0;
sb = c[Eb >> 2] | 0;
if ((sb | 0) != (Db | 0) ? (x = +(Ab | 0), h = +g[sb >> 2] - x, s = +(Bb | 0), e = +g[sb + 4 >> 2] - s, z = +g[Db >> 2] - x, x = +g[Db + 4 >> 2] - s, h * h + e * e > z * z + x * x) : 0)
break;
if ((tb | 0) == (xb | 0)) {
vb = zb;
Fb = 122;
break c
}
}
c[Eb >> 2] = Db;
if ((Ab | 0) > 0) {
ub = Ab + -1 | 0;
sb = Cb + -1 | 0;
if ((xb | 0) >= (wb | 0)) {
if ((tb |
0) < (xb | 0)) {
rb = tb;
do {
Ya = zb + (rb - tb << 4) | 0;
Xa = zb + (rb << 4) | 0;
c[Ya + 0 >> 2] = c[Xa + 0 >> 2];
c[Ya + 4 >> 2] = c[Xa + 4 >> 2];
c[Ya + 8 >> 2] = c[Xa + 8 >> 2];
c[Ya + 12 >> 2] = c[Xa + 12 >> 2];
rb = rb + 1 | 0
} while ((rb | 0) != (xb | 0))
}
rb = xb - tb | 0;
if ((rb | 0) < (wb | 0)) {
Gb = zb;
Hb = rb;
Ib = wb;
Jb = 0
} else {
Xa = (wb | 0) > 0 ? wb << 1 : 1;
Gb = Zm(D, zb, Xa << 4) | 0;
Hb = rb;
Ib = Xa;
Jb = 0
}
} else {
Gb = zb;
Hb = xb;
Ib = wb;
Jb = tb
}
c[Gb + (Hb << 4) >> 2] = ub;
c[Gb + (Hb << 4) + 4 >> 2] = Bb;
c[Gb + (Hb << 4) + 8 >> 2] = sb;
c[Gb + (Hb << 4) + 12 >> 2] = Db;
Kb = Hb + 1 | 0;
Lb = Ib;
Mb = Jb;
Nb = Gb
} else {
Kb = xb;
Lb = wb;
Mb = tb;
Nb = zb
}
if ((Bb | 0) > 0) {
Xa = Bb + -1 | 0;
rb = Cb - (c[p >>
2] | 0) | 0;
if ((Kb | 0) >= (Lb | 0)) {
if ((Mb | 0) < (Kb | 0)) {
Ya = Mb;
do {
Wa = Nb + (Ya - Mb << 4) | 0;
Va = Nb + (Ya << 4) | 0;
c[Wa + 0 >> 2] = c[Va + 0 >> 2];
c[Wa + 4 >> 2] = c[Va + 4 >> 2];
c[Wa + 8 >> 2] = c[Va + 8 >> 2];
c[Wa + 12 >> 2] = c[Va + 12 >> 2];
Ya = Ya + 1 | 0
} while ((Ya | 0) != (Kb | 0))
}
Ya = Kb - Mb | 0;
if ((Ya | 0) < (Lb | 0)) {
Ob = Nb;
Pb = Ya;
Qb = Lb;
Rb = 0
} else {
tb = (Lb | 0) > 0 ? Lb << 1 : 1;
Ob = Zm(D, Nb, tb << 4) | 0;
Pb = Ya;
Qb = tb;
Rb = 0
}
} else {
Ob = Nb;
Pb = Kb;
Qb = Lb;
Rb = Mb
}
c[Ob + (Pb << 4) >> 2] = Ab;
c[Ob + (Pb << 4) + 4 >> 2] = Xa;
c[Ob + (Pb << 4) + 8 >> 2] = rb;
c[Ob + (Pb << 4) + 12 >> 2] = Db;
Sb = Pb + 1 | 0;
Tb = Qb;
Ub = Rb;
Vb = Ob
} else {
Sb = Kb;
Tb = Lb;
Ub = Mb;
Vb = Nb
}
if ((Ab |
0) < ((c[p >> 2] | 0) + -1 | 0)) {
tb = Ab + 1 | 0;
Ya = Cb + 1 | 0;
if ((Sb | 0) >= (Tb | 0)) {
if ((Ub | 0) < (Sb | 0)) {
sb = Ub;
do {
ub = Vb + (sb - Ub << 4) | 0;
Va = Vb + (sb << 4) | 0;
c[ub + 0 >> 2] = c[Va + 0 >> 2];
c[ub + 4 >> 2] = c[Va + 4 >> 2];
c[ub + 8 >> 2] = c[Va + 8 >> 2];
c[ub + 12 >> 2] = c[Va + 12 >> 2];
sb = sb + 1 | 0
} while ((sb | 0) != (Sb | 0))
}
sb = Sb - Ub | 0;
if ((sb | 0) < (Tb | 0)) {
Wb = Vb;
Xb = sb;
Yb = Tb;
Zb = 0
} else {
rb = (Tb | 0) > 0 ? Tb << 1 : 1;
Wb = Zm(D, Vb, rb << 4) | 0;
Xb = sb;
Yb = rb;
Zb = 0
}
} else {
Wb = Vb;
Xb = Sb;
Yb = Tb;
Zb = Ub
}
c[Wb + (Xb << 4) >> 2] = tb;
c[Wb + (Xb << 4) + 4 >> 2] = Bb;
c[Wb + (Xb << 4) + 8 >> 2] = Ya;
c[Wb + (Xb << 4) + 12 >> 2] = Db;
_b = Xb + 1 | 0;
$b = Yb;
ac = Zb;
bc =
Wb
} else {
_b = Sb;
$b = Tb;
ac = Ub;
bc = Vb
}
if ((Bb | 0) < ((c[A >> 2] | 0) + -1 | 0)) {
rb = Bb + 1 | 0;
sb = (c[p >> 2] | 0) + Cb | 0;
if ((_b | 0) >= ($b | 0)) {
if ((ac | 0) < (_b | 0)) {
Xa = ac;
do {
Va = bc + (Xa - ac << 4) | 0;
ub = bc + (Xa << 4) | 0;
c[Va + 0 >> 2] = c[ub + 0 >> 2];
c[Va + 4 >> 2] = c[ub + 4 >> 2];
c[Va + 8 >> 2] = c[ub + 8 >> 2];
c[Va + 12 >> 2] = c[ub + 12 >> 2];
Xa = Xa + 1 | 0
} while ((Xa | 0) != (_b | 0))
}
Xa = _b - ac | 0;
if ((Xa | 0) < ($b | 0)) {
cc = bc;
dc = Xa;
ec = $b;
fc = 0
} else {
Ya = ($b | 0) > 0 ? $b << 1 : 1;
cc = Zm(D, bc, Ya << 4) | 0;
dc = Xa;
ec = Ya;
fc = 0
}
} else {
cc = bc;
dc = _b;
ec = $b;
fc = ac
}
c[cc + (dc << 4) >> 2] = Ab;
c[cc + (dc << 4) + 4 >> 2] = rb;
c[cc + (dc << 4) + 8 >> 2] = sb;
c[cc + (dc << 4) + 12 >> 2] = Db;
gc = ec;
hc = dc + 1 | 0;
ic = fc;
jc = cc
} else {
gc = $b;
hc = _b;
ic = ac;
jc = bc
}
if ((ic | 0) == (hc | 0)) {
vb = jc;
Fb = 122;
break
} else {
wb = gc;
xb = hc;
yb = ic;
zb = jc
}
}
if ((Fb | 0) == 122) {
_m(D, vb);
i = f;
return
}
}
function lk(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0;
e = i;
f = b + 20 | 0;
g = c[f >> 2] | 0;
if ((g + -1 | 0) <= 0) {
i = e;
return
}
h = b + 16 | 0;
j = b + 24 | 0;
b = c[h >> 2] | 0;
k = g;
g = 0;
while (1) {
if ((b + -1 | 0) > 0) {
l = b;
m = 0;
do {
n = (aa(l, g) | 0) + m | 0;
o = c[j >> 2] | 0;
p = c[o + (n << 2) >> 2] | 0;
q = n + 1 | 0;
r = c[o + (q << 2) >> 2] | 0;
s = c[o + (n + l << 2) >> 2] |
0;
n = c[o + (q + l << 2) >> 2] | 0;
do if ((r | 0) != (s | 0)) {
do if (!((p | 0) == (r | 0) | (p | 0) == (s | 0))) {
if (((a[p + 12 >> 0] | 0) == 0 ? (a[r + 12 >> 0] | 0) == 0 : 0) ? (a[s + 12 >> 0] | 0) == 0 : 0)
break;
pb[c[(c[d >> 2] | 0) + 8 >> 2] & 31](d, c[p + 8 >> 2] | 0, c[r + 8 >> 2] | 0, c[s + 8 >> 2] | 0)
}
while (0);
if (!((n | 0) == (r | 0) | (n | 0) == (s | 0))) {
if (((a[r + 12 >> 0] | 0) == 0 ? (a[n + 12 >> 0] | 0) == 0 : 0) ? (a[s + 12 >> 0] | 0) == 0 : 0)
break;
pb[c[(c[d >> 2] | 0) + 8 >> 2] & 31](d, c[r + 8 >> 2] | 0, c[n + 8 >> 2] | 0, c[s + 8 >> 2] | 0)
}
}
while (0);
m = m + 1 | 0;
l = c[h >> 2] | 0
} while ((m | 0) < (l + -1 | 0));
t = c[f >> 2] | 0;
u = l
} else {
t = k;
u = b
}
g = g + 1 | 0;
if ((g | 0) >= (t + -1 | 0))
break;
else {
b = u;
k = t
}
}
i = e;
return
}
function mk(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
h = 0,
j = 0;
b = i;
d = a + 40 | 0;
e = a + 48 | 0;
f = a + 16 | 0;
c[a + 0 >> 2] = 0;
c[a + 4 >> 2] = 0;
c[a + 8 >> 2] = 0;
c[a + 12 >> 2] = 0;
g[f >> 2] = 1;
c[a + 20 >> 2] = 0;
c[a + 24 >> 2] = 0;
c[a + 28 >> 2] = -1;
g[a + 32 >> 2] = 0;
g[a + 36 >> 2] = 0;
f = 8784;
h = c[f + 4 >> 2] | 0;
j = d;
c[j >> 2] = c[f >> 2];
c[j + 4 >> 2] = h;
h = 8784;
j = c[h + 4 >> 2] | 0;
f = e;
c[f >> 2] = c[h >> 2];
c[f + 4 >> 2] = j;
j = a + 56 | 0;
f = a + 72 | 0;
c[j + 0 >> 2] = 0;
c[j + 4 >> 2] = 0;
c[j + 8 >> 2] = 0;
c[j + 12 >> 2] = 0;
g[f >> 2] = 1;
c[a + 76 >> 2] = 0;
i = b;
return
}
function nk(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0;
b = i;
d = a + 28 | 0;
e = c[a >> 2] | 0;
f = c[e + 4 >> 2] | 0;
if ((c[d >> 2] | 0) == (f | 0)) {
i = b;
return
}
h = +g[e + 32 >> 2] * .75;
j = h * +g[e + 320 >> 2] * h;
k = a + 32 | 0;
g[k >> 2] = 0;
l = a + 40 | 0;
m = a + 44 | 0;
n = a + 48 | 0;
o = a + 52 | 0;
p = a + 4 | 0;
c[l + 0 >> 2] = 0;
c[l + 4 >> 2] = 0;
c[l + 8 >> 2] = 0;
c[l + 12 >> 2] = 0;
q = c[p >> 2] | 0;
p = c[a + 8 >> 2] | 0;
r = (q | 0) < (p | 0);
if (r) {
s = c[e + 96 >> 2] | 0;
t = c[e + 104 >> 2] | 0;
h = 0;
u = 0;
v = 0;
w = 0;
x = 0;
y = q;
do {
h = j + h;
g[k >> 2] = h;
z = j * +g[s + (y << 3) + 4 >> 2];
u = j * +g[s + (y << 3) >> 2] + u;
g[l >> 2] = u;
v = z + v;
g[m >> 2] = v;
z = j * +g[t + (y <<
3) + 4 >> 2];
w = j * +g[t + (y << 3) >> 2] + w;
g[n >> 2] = w;
x = z + x;
g[o >> 2] = x;
y = y + 1 | 0
} while ((y | 0) < (p | 0));
if (h > 0) {
z = 1 / h;
A = z * u;
g[l >> 2] = A;
B = z * v;
g[m >> 2] = B;
z = 1 / h;
h = z * w;
g[n >> 2] = h;
C = z * x;
g[o >> 2] = C;
D = A;
E = B;
F = h;
G = C
} else {
D = u;
E = v;
F = w;
G = x
}
o = a + 36 | 0;
g[o >> 2] = 0;
n = a + 56 | 0;
g[n >> 2] = 0;
if (r) {
r = c[e + 96 >> 2] | 0;
m = c[e + 104 >> 2] | 0;
x = 0;
w = 0;
e = q;
do {
v = +g[r + (e << 3) >> 2] - D;
u = +g[r + (e << 3) + 4 >> 2] - E;
C = +g[m + (e << 3) >> 2] - F;
h = +g[m + (e << 3) + 4 >> 2] - G;
x = j * (v * v + u * u) + x;
g[o >> 2] = x;
w = w + j * (v * h - u * C);
g[n >> 2] = w;
e = e + 1 | 0
} while ((e | 0) < (p | 0));
if (x > 0)
g[n >> 2] = 1 / x * w
}
} else {
g[a + 36 >> 2] = 0;
g[a +
56 >> 2] = 0
}
c[d >> 2] = f;
i = b;
return
}
function ok(a, b) {
a = a | 0;
b = b | 0;
var d = 0;
d = i;
nl(c[a >> 2] | 0, c[a + 4 >> 2] | 0, c[a + 8 >> 2] | 0, b);
i = d;
return
}
function pk(a, b) {
a = a | 0;
b = b | 0;
var d = 0;
d = i;
ol(c[a >> 2] | 0, c[a + 4 >> 2] | 0, c[a + 8 >> 2] | 0, b);
i = d;
return
}
function qk(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0;
d = i;
e = c[a >> 2] | 0;
if ((c[(c[e + 400 >> 2] | 0) + 102876 >> 2] & 2 | 0) != 0) {
i = d;
return
}
f = c[a + 4 >> 2] | 0;
g = a + 8 | 0;
if ((f | 0) < (c[g >> 2] | 0)) {
h = e;
j = f
} else {
i = d;
return
}
while (1) {
Bk(h, j, b);
f = j + 1 | 0;
if ((f | 0) >= (c[g >> 2] | 0))
break;
h = c[a >> 2] | 0;
j = f
}
i = d;
return
}
function rk(b,
d, e) {
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0;
f = i;
h = b + 52 | 0;
c[b + 56 >> 2] = h;
c[h >> 2] = h;
c[b + 60 >> 2] = 256;
h = b + 64 | 0;
c[b + 68 >> 2] = h;
c[h >> 2] = h;
h = b + 72 | 0;
c[b + 76 >> 2] = h;
c[h >> 2] = h;
h = b + 80 | 0;
c[b + 136 >> 2] = 0;
c[b + 140 >> 2] = 0;
c[b + 148 >> 2] = 0;
c[b + 152 >> 2] = 0;
j = b + 160 | 0;
k = b + 196 | 0;
c[h + 0 >> 2] = 0;
c[h + 4 >> 2] = 0;
c[h + 8 >> 2] = 0;
c[h + 12 >> 2] = 0;
c[h + 16 >> 2] = 0;
c[h + 20 >> 2] = 0;
c[h + 24 >> 2] = 0;
c[h + 28 >> 2] = 0;
h = j + 0 | 0;
j = h + 36 | 0;
do {
c[h >> 2] = 0;
h = h + 4 | 0
} while ((h | 0) < (j | 0));
c[k >> 2] = e;
c[b + 200 >> 2] = 0;
c[b + 204 >> 2] = 0;
c[b + 208 >> 2] = 0;
c[b + 212 >> 2] = e;
c[b + 216 >>
2] = 0;
c[b + 220 >> 2] = 0;
c[b + 224 >> 2] = 0;
c[b + 228 >> 2] = e;
c[b + 232 >> 2] = 0;
c[b + 236 >> 2] = 0;
c[b + 240 >> 2] = 0;
c[b + 244 >> 2] = e;
c[b + 248 >> 2] = 0;
c[b + 252 >> 2] = 0;
c[b + 256 >> 2] = 0;
c[b + 260 >> 2] = e;
c[b + 264 >> 2] = 0;
c[b + 268 >> 2] = 0;
c[b + 272 >> 2] = 0;
c[b + 276 >> 2] = e;
k = b + 280 | 0;
l = b + 316 | 0;
a[l >> 0] = 0;
m = b + 320 | 0;
c[k + 0 >> 2] = 0;
c[k + 4 >> 2] = 0;
c[k + 8 >> 2] = 0;
c[k + 12 >> 2] = 0;
g[m >> 2] = 1;
n = b + 324 | 0;
g[n >> 2] = 1;
g[b + 328 >> 2] = 1;
o = b + 332 | 0;
c[o >> 2] = 0;
g[b + 336 >> 2] = .05000000074505806;
g[b + 340 >> 2] = 1;
g[b + 344 >> 2] = .25;
g[b + 348 >> 2] = .25;
g[b + 352 >> 2] = .25;
g[b + 356 >> 2] = .20000000298023224;
g[b + 360 >>
2] = .20000000298023224;
g[b + 364 >> 2] = 1;
g[b + 368 >> 2] = .5;
g[b + 372 >> 2] = .5;
g[b + 376 >> 2] = .20000000298023224;
g[b + 380 >> 2] = .20000000298023224;
c[b + 384 >> 2] = 8;
g[b + 388 >> 2] = .5;
p = b + 392 | 0;
a[p >> 0] = 1;
g[b + 396 >> 2] = .01666666753590107;
a[b >> 0] = 0;
c[b + 4 >> 2] = 0;
c[b + 8 >> 2] = 0;
a[b + 12 >> 0] = 0;
c[b + 16 >> 2] = 0;
a[b + 20 >> 0] = 0;
a[b + 21 >> 0] = 0;
c[b + 24 >> 2] = 0;
a[l >> 0] = a[d >> 0] | 0;
q = +g[d + 4 >> 2];
g[m >> 2] = q;
g[b + 28 >> 2] = 1 / q;
g[n >> 2] = +g[d + 8 >> 2];
q = +g[d + 12 >> 2] * 2;
g[b + 32 >> 2] = q;
g[b + 40 >> 2] = q * q;
g[b + 36 >> 2] = 1 / q;
c[o >> 2] = c[d + 16 >> 2];
c[b + 44 >> 2] = 0;
o = b + 48 | 0;
c[o >> 2] = 0;
n = b + 112 | 0;
c[b + 144 >> 2] = 0;
c[b + 308 >> 2] = 0;
c[b + 312 >> 2] = 0;
c[n + 0 >> 2] = 0;
c[n + 4 >> 2] = 0;
c[n + 8 >> 2] = 0;
c[n + 12 >> 2] = 0;
c[n + 16 >> 2] = 0;
c[n + 20 >> 2] = 0;
h = l + 0 | 0;
l = d + 0 | 0;
j = h + 84 | 0;
do {
c[h >> 2] = c[l >> 2];
h = h + 4 | 0;
l = l + 4 | 0
} while ((h | 0) < (j | 0));
l = b + 400 | 0;
c[l >> 2] = e;
c[b + 156 >> 2] = 0;
e = b + 296 | 0;
c[e >> 2] = 0;
c[e + 4 >> 2] = 0;
a[b + 304 >> 0] = 0;
e = a[p >> 0] | 0;
if (e << 24 >> 24 == 0) {
a[p >> 0] = e;
i = f;
return
}
h = c[k >> 2] | 0;
if ((h | 0) == 0) {
vk(b, 256);
b = Em(c[l >> 2] | 0, c[o >> 2] << 2) | 0;
xn(b | 0, 0, c[o >> 2] << 2 | 0) | 0;
r = b
} else
r = h;
c[k >> 2] = r;
a[p >> 0] = e;
i = f;
return
}
function sk(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
g =
0;
b = i;
d = a + 312 | 0;
while (1) {
e = c[d >> 2] | 0;
if ((e | 0) == 0)
break;
tk(a, e)
}
if ((c[a + 84 >> 2] | 0) == 0 ? (d = a + 80 | 0, e = c[d >> 2] | 0, (e | 0) != 0) : 0) {
Fm(c[a + 400 >> 2] | 0, e, c[a + 48 >> 2] << 2);
c[d >> 2] = 0
}
if ((c[a + 92 >> 2] | 0) == 0 ? (d = a + 88 | 0, e = c[d >> 2] | 0, (e | 0) != 0) : 0) {
Fm(c[a + 400 >> 2] | 0, e, c[a + 48 >> 2] << 2);
c[d >> 2] = 0
}
if ((c[a + 164 >> 2] | 0) == 0 ? (d = a + 160 | 0, e = c[d >> 2] | 0, (e | 0) != 0) : 0) {
Fm(c[a + 400 >> 2] | 0, e, c[a + 48 >> 2] << 2);
c[d >> 2] = 0
}
if ((c[a + 172 >> 2] | 0) == 0 ? (d = a + 168 | 0, e = c[d >> 2] | 0, (e | 0) != 0) : 0) {
Fm(c[a + 400 >> 2] | 0, e, c[a + 48 >> 2] << 2);
c[d >> 2] = 0
}
if ((c[a + 180 >> 2] | 0) == 0 ? (d = a + 176 | 0, e =
c[d >> 2] | 0, (e | 0) != 0) : 0) {
Fm(c[a + 400 >> 2] | 0, e, c[a + 48 >> 2] << 2);
c[d >> 2] = 0
}
if ((c[a + 100 >> 2] | 0) == 0 ? (d = a + 96 | 0, e = c[d >> 2] | 0, (e | 0) != 0) : 0) {
Fm(c[a + 400 >> 2] | 0, e, c[a + 48 >> 2] << 3);
c[d >> 2] = 0
}
if ((c[a + 108 >> 2] | 0) == 0 ? (d = a + 104 | 0, e = c[d >> 2] | 0, (e | 0) != 0) : 0) {
Fm(c[a + 400 >> 2] | 0, e, c[a + 48 >> 2] << 3);
c[d >> 2] = 0
}
if ((c[a + 140 >> 2] | 0) == 0 ? (d = a + 136 | 0, e = c[d >> 2] | 0, (e | 0) != 0) : 0) {
Fm(c[a + 400 >> 2] | 0, e, c[a + 48 >> 2] << 2);
c[d >> 2] = 0
}
if ((c[a + 152 >> 2] | 0) == 0 ? (d = a + 148 | 0, e = c[d >> 2] | 0, (e | 0) != 0) : 0) {
Fm(c[a + 400 >> 2] | 0, e, c[a + 48 >> 2] << 2);
c[d >> 2] = 0
}
if ((c[a + 284 >> 2] | 0) == 0 ? (d = a +
280 | 0, e = c[d >> 2] | 0, (e | 0) != 0) : 0) {
Fm(c[a + 400 >> 2] | 0, e, c[a + 48 >> 2] << 2);
c[d >> 2] = 0
}
if ((c[a + 292 >> 2] | 0) == 0 ? (d = a + 288 | 0, e = c[d >> 2] | 0, (e | 0) != 0) : 0) {
Fm(c[a + 400 >> 2] | 0, e, c[a + 48 >> 2] << 2);
c[d >> 2] = 0
}
d = a + 112 | 0;
e = a + 48 | 0;
f = c[d >> 2] | 0;
if ((f | 0) != 0) {
Fm(c[a + 400 >> 2] | 0, f, c[e >> 2] << 3);
c[d >> 2] = 0
}
d = a + 116 | 0;
f = c[d >> 2] | 0;
if ((f | 0) != 0) {
Fm(c[a + 400 >> 2] | 0, f, c[e >> 2] << 2);
c[d >> 2] = 0
}
d = a + 120 | 0;
f = c[d >> 2] | 0;
if ((f | 0) != 0) {
Fm(c[a + 400 >> 2] | 0, f, c[e >> 2] << 2);
c[d >> 2] = 0
}
d = a + 124 | 0;
f = c[d >> 2] | 0;
if ((f | 0) != 0) {
Fm(c[a + 400 >> 2] | 0, f, c[e >> 2] << 2);
c[d >> 2] = 0
}
d = a + 128 | 0;
f =
c[d >> 2] | 0;
if ((f | 0) != 0) {
Fm(c[a + 400 >> 2] | 0, f, c[e >> 2] << 3);
c[d >> 2] = 0
}
d = a + 132 | 0;
f = c[d >> 2] | 0;
if ((f | 0) != 0) {
Fm(c[a + 400 >> 2] | 0, f, c[e >> 2] << 2);
c[d >> 2] = 0
}
d = a + 144 | 0;
f = c[d >> 2] | 0;
if ((f | 0) != 0) {
Fm(c[a + 400 >> 2] | 0, f, c[e >> 2] << 2);
c[d >> 2] = 0
}
d = a + 264 | 0;
e = c[d >> 2] | 0;
if ((e | 0) != 0) {
f = a + 272 | 0;
Fm(c[a + 276 >> 2] | 0, e, (c[f >> 2] | 0) * 60 | 0);
c[d >> 2] = 0;
c[f >> 2] = 0;
c[a + 268 >> 2] = 0
}
f = a + 248 | 0;
d = c[f >> 2] | 0;
if ((d | 0) != 0) {
e = a + 256 | 0;
Fm(c[a + 260 >> 2] | 0, d, (c[e >> 2] | 0) * 20 | 0);
c[f >> 2] = 0;
c[e >> 2] = 0;
c[a + 252 >> 2] = 0
}
e = a + 232 | 0;
f = c[e >> 2] | 0;
if ((f | 0) != 0) {
d = a + 240 | 0;
Fm(c[a + 244 >>
2] | 0, f, (c[d >> 2] | 0) * 28 | 0);
c[e >> 2] = 0;
c[d >> 2] = 0;
c[a + 236 >> 2] = 0
}
d = a + 216 | 0;
e = c[d >> 2] | 0;
if ((e | 0) != 0) {
f = a + 224 | 0;
Fm(c[a + 228 >> 2] | 0, e, (c[f >> 2] | 0) * 24 | 0);
c[d >> 2] = 0;
c[f >> 2] = 0;
c[a + 220 >> 2] = 0
}
f = a + 200 | 0;
d = c[f >> 2] | 0;
if ((d | 0) != 0) {
e = a + 208 | 0;
Fm(c[a + 212 >> 2] | 0, d, c[e >> 2] << 3);
c[f >> 2] = 0;
c[e >> 2] = 0;
c[a + 204 >> 2] = 0
}
e = a + 184 | 0;
f = c[e >> 2] | 0;
if ((f | 0) == 0) {
g = a + 52 | 0;
Tl(g);
i = b;
return
}
d = a + 192 | 0;
Fm(c[a + 196 >> 2] | 0, f, c[d >> 2] << 2);
c[e >> 2] = 0;
c[d >> 2] = 0;
c[a + 188 >> 2] = 0;
g = a + 52 | 0;
Tl(g);
i = b;
return
}
function tk(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k =
0,
l = 0,
m = 0,
n = 0,
o = 0;
e = i;
f = b + 400 | 0;
g = c[(c[f >> 2] | 0) + 102992 >> 2] | 0;
if ((g | 0) != 0)
gb[c[(c[g >> 2] | 0) + 16 >> 2] & 63](g, d);
g = d + 12 | 0;
h = c[g >> 2] | 0;
j = h << 4;
k = j & 16;
if ((((j | -17) ^ 16) & h | 0) != 0)
a[b + 20 >> 0] = 1;
h = b + 16 | 0;
j = c[h >> 2] | 0;
if ((k & ~j | 0) != 0)
c[h >> 2] = j | k;
c[g >> 2] = k;
k = c[d + 4 >> 2] | 0;
g = c[d + 8 >> 2] | 0;
if ((k | 0) < (g | 0)) {
j = b + 144 | 0;
h = k;
do {
c[(c[j >> 2] | 0) + (h << 2) >> 2] = 0;
h = h + 1 | 0
} while ((h | 0) < (g | 0))
}
g = d + 20 | 0;
h = c[g >> 2] | 0;
j = d + 24 | 0;
if ((h | 0) != 0)
c[h + 24 >> 2] = c[j >> 2];
h = c[j >> 2] | 0;
if ((h | 0) != 0)
c[h + 20 >> 2] = c[g >> 2];
g = b + 312 | 0;
if ((c[g >> 2] | 0) != (d | 0)) {
l = b + 308 | 0;
m =
c[l >> 2] | 0;
n = m + -1 | 0;
c[l >> 2] = n;
o = c[f >> 2] | 0;
Fm(o, d, 80);
i = e;
return
}
c[g >> 2] = c[j >> 2];
l = b + 308 | 0;
m = c[l >> 2] | 0;
n = m + -1 | 0;
c[l >> 2] = n;
o = c[f >> 2] | 0;
Fm(o, d, 80);
i = e;
return
}
function uk(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
g = 0,
h = 0;
b = i;
d = a + 136 | 0;
e = c[d >> 2] | 0;
if ((e | 0) != 0) {
f = e;
c[d >> 2] = f;
i = b;
return f | 0
}
e = a + 48 | 0;
g = c[e >> 2] | 0;
if ((g | 0) == 0) {
vk(a, 256);
h = c[e >> 2] | 0
} else
h = g;
g = Em(c[a + 400 >> 2] | 0, h << 2) | 0;
xn(g | 0, 0, c[e >> 2] << 2 | 0) | 0;
f = g;
c[d >> 2] = f;
i = b;
return f | 0
}
function vk(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0;
d = i;
e = c[a + 332 >> 2] | 0;
if ((e | 0) == 0)
f = b;
else
f = (e | 0) < (b | 0) ? e : b;
b = a + 92 | 0;
e = c[b >> 2] | 0;
if ((e | 0) == 0)
g = f;
else
g = (f | 0) > (e | 0) ? e : f;
f = a + 100 | 0;
e = c[f >> 2] | 0;
if ((e | 0) == 0)
h = g;
else
h = (g | 0) > (e | 0) ? e : g;
g = a + 108 | 0;
e = c[g >> 2] | 0;
if ((e | 0) == 0)
j = h;
else
j = (h | 0) > (e | 0) ? e : h;
h = a + 140 | 0;
e = c[h >> 2] | 0;
if ((e | 0) == 0)
k = j;
else
k = (j | 0) > (e | 0) ? e : j;
j = a + 152 | 0;
e = c[j >> 2] | 0;
if ((e | 0) == 0)
l = k;
else
l = (k | 0) > (e | 0) ? e : k;
k = a + 48 | 0;
e = c[k >> 2] | 0;
if ((e | 0) >= (l | 0)) {
i = d;
return
}
m = a + 80 | 0;
n = c[m >> 2] | 0;
o = (n |
0) == 0;
if ((c[a + 84 >> 2] | 0) == 0 & (o ^ 1)) {
p = a + 400 | 0;
q = Em(c[p >> 2] | 0, l << 2) | 0;
if (o)
r = q;
else {
o = e << 2;
An(q | 0, n | 0, o | 0) | 0;
Fm(c[p >> 2] | 0, n, o);
r = q
}
} else
r = n;
c[m >> 2] = r;
r = c[k >> 2] | 0;
c[a + 60 >> 2] = l - r;
m = a + 88 | 0;
n = c[m >> 2] | 0;
if ((c[b >> 2] | 0) == 0) {
b = a + 400 | 0;
q = Em(c[b >> 2] | 0, l << 2) | 0;
if ((n | 0) == 0)
s = q;
else {
o = r << 2;
An(q | 0, n | 0, o | 0) | 0;
Fm(c[b >> 2] | 0, n, o);
s = q
}
} else
s = n;
c[m >> 2] = s;
s = (c[a + 156 >> 2] | 0) > 0;
m = c[k >> 2] | 0;
n = a + 160 | 0;
q = c[n >> 2] | 0;
o = (q | 0) == 0;
if ((c[a + 164 >> 2] | 0) == 0 & (o & s ^ 1)) {
b = a + 400 | 0;
r = Em(c[b >> 2] | 0, l << 2) | 0;
if (o)
t = r;
else {
o = m << 2;
An(r | 0, q | 0, o | 0) |
0;
Fm(c[b >> 2] | 0, q, o);
t = r
}
} else
t = q;
c[n >> 2] = t;
t = c[k >> 2] | 0;
n = a + 168 | 0;
q = c[n >> 2] | 0;
r = (q | 0) == 0;
if ((c[a + 172 >> 2] | 0) == 0 & (r & s ^ 1)) {
o = a + 400 | 0;
b = Em(c[o >> 2] | 0, l << 2) | 0;
if (r)
u = b;
else {
r = t << 2;
An(b | 0, q | 0, r | 0) | 0;
Fm(c[o >> 2] | 0, q, r);
u = b
}
} else
u = q;
c[n >> 2] = u;
u = c[k >> 2] | 0;
n = a + 176 | 0;
q = c[n >> 2] | 0;
b = (q | 0) == 0;
if ((c[a + 180 >> 2] | 0) == 0 & (b & s ^ 1)) {
s = a + 400 | 0;
r = Em(c[s >> 2] | 0, l << 2) | 0;
if (b)
v = r;
else {
b = u << 2;
An(r | 0, q | 0, b | 0) | 0;
Fm(c[s >> 2] | 0, q, b);
v = r
}
} else
v = q;
c[n >> 2] = v;
v = c[k >> 2] | 0;
n = a + 96 | 0;
q = c[n >> 2] | 0;
if ((c[f >> 2] | 0) == 0) {
f = a + 400 | 0;
r = Em(c[f >> 2] | 0,
l << 3) | 0;
if ((q | 0) == 0)
w = r;
else {
b = v << 3;
An(r | 0, q | 0, b | 0) | 0;
Fm(c[f >> 2] | 0, q, b);
w = r
}
} else
w = q;
c[n >> 2] = w;
w = c[k >> 2] | 0;
n = a + 104 | 0;
q = c[n >> 2] | 0;
if ((c[g >> 2] | 0) == 0) {
g = a + 400 | 0;
r = l << 3;
b = Em(c[g >> 2] | 0, r) | 0;
if ((q | 0) == 0) {
x = b;
y = r;
z = g
} else {
f = w << 3;
An(b | 0, q | 0, f | 0) | 0;
Fm(c[g >> 2] | 0, q, f);
x = b;
y = r;
z = g
}
} else {
x = q;
y = l << 3;
z = a + 400 | 0
}
c[n >> 2] = x;
x = a + 112 | 0;
n = c[x >> 2] | 0;
q = c[k >> 2] | 0;
g = Em(c[z >> 2] | 0, y) | 0;
if ((n | 0) != 0) {
r = q << 3;
An(g | 0, n | 0, r | 0) | 0;
Fm(c[z >> 2] | 0, n, r)
}
c[x >> 2] = g;
g = a + 116 | 0;
x = c[g >> 2] | 0;
r = c[k >> 2] | 0;
n = l << 2;
q = Em(c[z >> 2] | 0, n) | 0;
if ((x | 0) != 0) {
b =
r << 2;
An(q | 0, x | 0, b | 0) | 0;
Fm(c[z >> 2] | 0, x, b)
}
c[g >> 2] = q;
q = a + 120 | 0;
g = c[q >> 2] | 0;
if ((g | 0) == 0)
A = 0;
else {
b = c[k >> 2] | 0;
x = Em(c[z >> 2] | 0, n) | 0;
r = b << 2;
An(x | 0, g | 0, r | 0) | 0;
Fm(c[z >> 2] | 0, g, r);
A = x
}
c[q >> 2] = A;
A = a + 124 | 0;
q = c[A >> 2] | 0;
x = c[k >> 2] | 0;
r = Em(c[z >> 2] | 0, n) | 0;
if ((q | 0) != 0) {
g = x << 2;
An(r | 0, q | 0, g | 0) | 0;
Fm(c[z >> 2] | 0, q, g)
}
c[A >> 2] = r;
r = a + 128 | 0;
A = c[r >> 2] | 0;
if ((A | 0) == 0)
B = 0;
else {
g = c[k >> 2] | 0;
q = Em(c[z >> 2] | 0, y) | 0;
y = g << 3;
An(q | 0, A | 0, y | 0) | 0;
Fm(c[z >> 2] | 0, A, y);
B = q
}
c[r >> 2] = B;
B = a + 132 | 0;
r = c[B >> 2] | 0;
if ((r | 0) == 0)
C = 0;
else {
q = c[k >> 2] | 0;
y = Em(c[z >> 2] |
0, n) | 0;
A = q << 2;
An(y | 0, r | 0, A | 0) | 0;
Fm(c[z >> 2] | 0, r, A);
C = y
}
c[B >> 2] = C;
C = c[k >> 2] | 0;
B = a + 136 | 0;
y = c[B >> 2] | 0;
A = (y | 0) == 0;
do if ((c[h >> 2] | 0) == 0 & (A ^ 1)) {
r = Em(c[z >> 2] | 0, n) | 0;
if (A) {
D = r;
break
}
q = C << 2;
An(r | 0, y | 0, q | 0) | 0;
Fm(c[z >> 2] | 0, y, q);
D = r
} else
D = y;
while (0);
c[B >> 2] = D;
D = a + 144 | 0;
B = c[D >> 2] | 0;
y = c[k >> 2] | 0;
C = Em(c[z >> 2] | 0, n) | 0;
if ((B | 0) != 0) {
A = y << 2;
An(C | 0, B | 0, A | 0) | 0;
Fm(c[z >> 2] | 0, B, A)
}
c[D >> 2] = C;
C = c[k >> 2] | 0;
D = a + 148 | 0;
A = c[D >> 2] | 0;
B = (A | 0) == 0;
do if ((c[j >> 2] | 0) == 0 & (B ^ 1)) {
y = Em(c[z >> 2] | 0, n) | 0;
if (B) {
E = y;
break
}
h = C << 2;
An(y | 0, A | 0, h | 0) | 0;
Fm(c[z >> 2] | 0, A, h);
E = y
} else
E = A;
while (0);
c[D >> 2] = E;
E = c[k >> 2] | 0;
D = a + 280 | 0;
A = c[D >> 2] | 0;
C = (A | 0) == 0;
do if ((c[a + 284 >> 2] | 0) == 0 & (C ^ 1)) {
B = Em(c[z >> 2] | 0, n) | 0;
if (C) {
F = B;
break
}
j = E << 2;
An(B | 0, A | 0, j | 0) | 0;
Fm(c[z >> 2] | 0, A, j);
F = B
} else
F = A;
while (0);
c[D >> 2] = F;
F = c[k >> 2] | 0;
D = a + 288 | 0;
A = c[D >> 2] | 0;
E = (A | 0) == 0;
do if ((c[a + 292 >> 2] | 0) == 0 & (E ^ 1)) {
C = Em(c[z >> 2] | 0, n) | 0;
if (E) {
G = C;
break
}
B = F << 2;
An(C | 0, A | 0, B | 0) | 0;
Fm(c[z >> 2] | 0, A, B);
G = C
} else
G = A;
while (0);
c[D >> 2] = G;
c[k >> 2] = l;
i = d;
return
}
function wk(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l =
0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0;
e = i;
f = b + 400 | 0;
if ((c[(c[f >> 2] | 0) + 102876 >> 2] & 2 | 0) != 0) {
h = 0;
i = e;
return h | 0
}
j = b + 44 | 0;
k = c[j >> 2] | 0;
l = b + 48 | 0;
m = c[l >> 2] | 0;
if ((k | 0) < (m | 0)) {
n = k;
o = m
} else {
vk(b, (k | 0) == 0 ? 256 : k << 1);
n = c[j >> 2] | 0;
o = c[l >> 2] | 0
}
do if ((n | 0) >= (o | 0))
if ((a[b + 392 >> 0] | 0) == 0) {
h = -1;
i = e;
return h | 0
} else {
k = c[b + 288 >> 2] | 0;
m = c[k + (n + -1 << 2) >> 2] | 0;
p = +(c[(c[b + 280 >> 2] | 0) + (m << 2) >> 2] | 0) > 0 ? m : c[k >> 2] | 0;
k = b + 88 | 0;
Ak(b, p, c[(c[k >> 2] | 0) + (p << 2) >> 2] | 2);
xk(b);
q = k;
r = c[j >> 2] | 0;
break
}
else {
q = b + 88 | 0;
r = n
}
while (0);
n = r + 1 | 0;
c[j >> 2] = n;
c[(c[q >> 2] | 0) + (r << 2) >> 2] = 0;
q = c[b + 160 >> 2] | 0;
if ((q | 0) != 0)
c[q + (r << 2) >> 2] = 0;
q = c[b + 168 >> 2] | 0;
if ((q | 0) != 0)
c[q + (r << 2) >> 2] = 0;
q = c[b + 176 >> 2] | 0;
if ((q | 0) != 0)
c[q + (r << 2) >> 2] = 0;
q = d + 4 | 0;
j = c[q + 4 >> 2] | 0;
o = (c[b + 96 >> 2] | 0) + (r << 3) | 0;
c[o >> 2] = c[q >> 2];
c[o + 4 >> 2] = j;
j = d + 12 | 0;
o = c[j + 4 >> 2] | 0;
q = (c[b + 104 >> 2] | 0) + (r << 3) | 0;
c[q >> 2] = c[j >> 2];
c[q + 4 >> 2] = o;
g[(c[b + 116 >> 2] | 0) + (r << 2) >> 2] = 0;
o = 8784;
q = c[o + 4 >> 2] | 0;
j = (c[b + 112 >> 2] | 0) + (r << 3) | 0;
c[j >> 2] = c[o >> 2];
c[j + 4 >> 2] = q;
q = c[b + 120 >> 2] | 0;
if ((q | 0) != 0)
g[q + (r << 2) >> 2] = 0;
q = c[b + 132 >> 2] | 0;
if ((q | 0) != 0)
g[q + (r << 2) >> 2] = 0;
q = b + 136 | 0;
j = c[q >> 2] | 0;
o = d + 20 | 0;
do if ((j | 0) == 0) {
if ((((a[o >> 0] | 0) == 0 ? (a[d + 21 >> 0] | 0) == 0 : 0) ? (a[d + 22 >> 0] | 0) == 0 : 0) ? (a[d + 23 >> 0] | 0) == 0 : 0)
break;
k = c[l >> 2] | 0;
if ((k | 0) == 0) {
vk(b, 256);
s = c[l >> 2] | 0
} else
s = k;
k = Em(c[f >> 2] | 0, s << 2) | 0;
xn(k | 0, 0, c[l >> 2] << 2 | 0) | 0;
t = k;
u = 26
} else {
t = j;
u = 26
}
while (0);
if ((u | 0) == 26) {
c[q >> 2] = t;
q = a[d + 21 >> 0] | 0;
j = a[d + 22 >> 0] | 0;
s = a[d + 23 >> 0] | 0;
a[t + (r << 2) >> 0] = a[o >> 0] | 0;
a[t + (r << 2) + 1 >> 0] = q;
a[t + (r << 2) + 2 >> 0] = j;
a[t + (r << 2) + 3 >> 0] = s
}
s = b + 148 | 0;
t = c[s >> 2] | 0;
j = d + 28 | 0;
if ((t | 0) == 0) {
if ((c[j >>
2] | 0) != 0) {
q = c[l >> 2] | 0;
if ((q | 0) == 0) {
vk(b, 256);
v = c[l >> 2] | 0
} else
v = q;
q = Em(c[f >> 2] | 0, v << 2) | 0;
xn(q | 0, 0, c[l >> 2] << 2 | 0) | 0;
w = q;
u = 32
}
} else {
w = t;
u = 32
}
if ((u | 0) == 32) {
c[s >> 2] = w;
c[w + (r << 2) >> 2] = c[j >> 2]
}
j = c[b + 80 >> 2] | 0;
if ((j | 0) != 0)
c[j + (r << 2) >> 2] = 0;
j = b + 200 | 0;
w = b + 204 | 0;
s = c[w >> 2] | 0;
u = b + 208 | 0;
t = c[u >> 2] | 0;
if ((s | 0) >= (t | 0) ? (q = (t | 0) == 0 ? 256 : t << 1, (t | 0) < (q | 0)) : 0) {
t = b + 212 | 0;
l = Em(c[t >> 2] | 0, q << 3) | 0;
v = c[j >> 2] | 0;
if ((v | 0) != 0) {
An(l | 0, v | 0, c[w >> 2] << 3 | 0) | 0;
Fm(c[t >> 2] | 0, c[j >> 2] | 0, c[u >> 2] << 3)
}
c[u >> 2] = q;
c[j >> 2] = l;
x = c[w >> 2] | 0
} else
x = s;
c[w >>
2] = x + 1;
w = c[j >> 2] | 0;
y = +g[d + 24 >> 2];
j = y > 0;
if ((c[b + 280 >> 2] | 0) != 0 | j) {
if (j)
z = y;
else {
j = c[b + 300 >> 2] | 0;
z = +g[b + 396 >> 2] * +(((j | 0) < 0 ? 0 - j | 0 : 0) - j | 0)
}
yk(b, r, z);
c[(c[b + 288 >> 2] | 0) + (r << 2) >> 2] = r
}
c[w + (x << 3) >> 2] = r;
x = c[d + 32 >> 2] | 0;
c[(c[b + 144 >> 2] | 0) + (r << 2) >> 2] = x;
do if ((x | 0) != 0) {
w = x + 4 | 0;
j = c[w >> 2] | 0;
s = x + 8 | 0;
l = c[s >> 2] | 0;
if ((j | 0) < (l | 0)) {
zk(b, j, l, r);
c[s >> 2] = n;
break
} else {
c[w >> 2] = r;
c[s >> 2] = n;
break
}
}
while (0);
Ak(b, r, c[d >> 2] | 0);
h = r;
i = e;
return h | 0
}
function xk(b) {
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0;
d = i;
e = b + 400 | 0;
f = b + 44 | 0;
h = Ym((c[e >> 2] | 0) + 76 | 0, c[f >> 2] << 2) | 0;
if ((c[f >> 2] | 0) > 0) {
j = b + 88 | 0;
k = b + 80 | 0;
l = b + 160 | 0;
m = b + 168 | 0;
n = b + 176 | 0;
o = b + 96 | 0;
p = b + 104 | 0;
q = b + 144 | 0;
r = b + 21 | 0;
s = b + 120 | 0;
t = b + 132 | 0;
u = b + 136 | 0;
v = b + 148 | 0;
w = b + 280 | 0;
x = b + 112 | 0;
y = b + 64 | 0;
z = 0;
A = 0;
B = 0;
while (1) {
C =
c[j >> 2] | 0;
D = c[C + (A << 2) >> 2] | 0;
if ((D & 2 | 0) == 0) {
c[h + (A << 2) >> 2] = B;
if ((A | 0) != (B | 0)) {
E = c[k >> 2] | 0;
if ((E | 0) == 0)
F = C;
else {
C = c[E + (A << 2) >> 2] | 0;
if ((C | 0) != 0)
c[C + 8 >> 2] = B;
c[E + (B << 2) >> 2] = C;
F = c[j >> 2] | 0
}
c[F + (B << 2) >> 2] = c[F + (A << 2) >> 2];
C = c[l >> 2] | 0;
if ((C | 0) != 0)
c[C + (B << 2) >> 2] = c[C + (A << 2) >> 2];
C = c[m >> 2] | 0;
if ((C | 0) != 0)
c[C + (B << 2) >> 2] = c[C + (A << 2) >> 2];
C = c[n >> 2] | 0;
if ((C | 0) != 0)
c[C + (B << 2) >> 2] = c[C + (A << 2) >> 2];
C = c[o >> 2] | 0;
E = C + (A << 3) | 0;
G = c[E + 4 >> 2] | 0;
H = C + (B << 3) | 0;
c[H >> 2] = c[E >> 2];
c[H + 4 >> 2] = G;
G = c[p >> 2] | 0;
H = G + (A << 3) | 0;
E = c[H + 4 >> 2] | 0;
C = G + (B <<
3) | 0;
c[C >> 2] = c[H >> 2];
c[C + 4 >> 2] = E;
E = c[q >> 2] | 0;
c[E + (B << 2) >> 2] = c[E + (A << 2) >> 2];
if ((a[r >> 0] | 0) != 0) {
E = c[x >> 2] | 0;
C = E + (A << 3) | 0;
H = c[C + 4 >> 2] | 0;
G = E + (B << 3) | 0;
c[G >> 2] = c[C >> 2];
c[G + 4 >> 2] = H
}
H = c[s >> 2] | 0;
if ((H | 0) != 0)
g[H + (B << 2) >> 2] = +g[H + (A << 2) >> 2];
H = c[t >> 2] | 0;
if ((H | 0) != 0)
g[H + (B << 2) >> 2] = +g[H + (A << 2) >> 2];
H = c[u >> 2] | 0;
if ((H | 0) != 0) {
G = a[H + (A << 2) + 1 >> 0] | 0;
C = a[H + (A << 2) + 2 >> 0] | 0;
E = a[H + (A << 2) + 3 >> 0] | 0;
a[H + (B << 2) >> 0] = a[H + (A << 2) >> 0] | 0;
a[H + (B << 2) + 1 >> 0] = G;
a[H + (B << 2) + 2 >> 0] = C;
a[H + (B << 2) + 3 >> 0] = E
}
E = c[v >> 2] | 0;
if ((E | 0) != 0)
c[E + (B << 2) >> 2] = c[E +
(A << 2) >> 2];
E = c[w >> 2] | 0;
if ((E | 0) != 0)
c[E + (B << 2) >> 2] = c[E + (A << 2) >> 2]
}
I = D | z;
J = B + 1 | 0
} else {
E = c[(c[e >> 2] | 0) + 102992 >> 2] | 0;
if (!((D & 512 | 0) == 0 | (E | 0) == 0))
ib[c[(c[E >> 2] | 0) + 20 >> 2] & 7](E, b, A);
E = c[k >> 2] | 0;
if ((E | 0) != 0 ? (D = E + (A << 2) | 0, E = c[D >> 2] | 0, (E | 0) != 0) : 0) {
c[E + 8 >> 2] = -1;
c[D >> 2] = 0;
Bm(y, E)
}
c[h + (A << 2) >> 2] = -1;
I = z;
J = B
}
A = A + 1 | 0;
if ((A | 0) >= (c[f >> 2] | 0)) {
K = I;
L = J;
break
} else {
z = I;
B = J
}
}
} else {
K = 0;
L = 0
}
J = b + 204 | 0;
B = c[J >> 2] | 0;
I = b + 200 | 0;
z = c[I >> 2] | 0;
if ((B | 0) > 0) {
A = 0;
do {
y = z + (A << 3) | 0;
c[y >> 2] = c[h + (c[y >> 2] << 2) >> 2];
A = A + 1 | 0;
y = c[J >> 2] | 0
} while ((A |
0) < (y | 0));
M = y
} else
M = B;
B = z + (M << 3) | 0;
a:
do if ((M | 0) == 0) {
N = z;
O = 40
} else {
A = z;
while (1) {
if ((c[A >> 2] | 0) < 0) {
N = A;
O = 40;
break a
}
A = A + 8 | 0;
if ((A | 0) == (B | 0)) {
P = B;
Q = z;
break
}
}
}
while (0);
if ((O | 0) == 40)
if ((N | 0) == (B | 0)) {
P = B;
Q = z
} else {
z = N;
M = N;
b:
while (1) {
N = M;
do {
N = N + 8 | 0;
if ((N | 0) == (B | 0))
break b
} while ((c[N >> 2] | 0) < 0);
A = N;
y = c[A + 4 >> 2] | 0;
k = z;
c[k >> 2] = c[A >> 2];
c[k + 4 >> 2] = y;
z = z + 8 | 0;
M = N
}
P = z;
Q = c[I >> 2] | 0
}
c[J >> 2] = P - Q >> 3;
Q = b + 220 | 0;
P = c[Q >> 2] | 0;
J = b + 216 | 0;
I = c[J >> 2] | 0;
if ((P | 0) > 0) {
z = 0;
do {
M = I + (z * 24 | 0) | 0;
B = I + (z * 24 | 0) + 4 | 0;
y = c[h + (c[B >> 2] << 2) >> 2] | 0;
c[M >> 2] = c[h + (c[M >> 2] << 2) >> 2];
c[B >> 2] = y;
z = z + 1 | 0;
y = c[Q >> 2] | 0
} while ((z | 0) < (y | 0));
R = y
} else
R = P;
P = I + (R * 24 | 0) | 0;
c:
do if ((R | 0) == 0) {
S = I;
O = 52
} else {
z = I;
while (1) {
if ((c[z >> 2] | 0) < 0) {
S = z;
O = 52;
break c
}
if ((c[z + 4 >> 2] | 0) < 0) {
S = z;
O = 52;
break c
}
z = z + 24 | 0;
if ((z | 0) == (P | 0)) {
T = P;
U = I;
break
}
}
}
while (0);
if ((O | 0) == 52)
if ((S | 0) == (P | 0)) {
T = P;
U = I
} else {
I = S + 24 | 0;
d:
do if ((I | 0) == (P | 0))
V = S;
else {
R = S;
z = I;
N = S;
while (1) {
y = z;
B = N;
while (1) {
if ((c[y >> 2] | 0) >= 0 ? (c[B + 28 >> 2] | 0) >= 0 : 0)
break;
M = y + 24 | 0;
if ((M | 0) == (P | 0)) {
V = R;
break d
} else {
k = y;
y = M;
B = k
}
}
c[R + 0 >>
2] = c[y + 0 >> 2];
c[R + 4 >> 2] = c[y + 4 >> 2];
c[R + 8 >> 2] = c[y + 8 >> 2];
c[R + 12 >> 2] = c[y + 12 >> 2];
c[R + 16 >> 2] = c[y + 16 >> 2];
c[R + 20 >> 2] = c[y + 20 >> 2];
B = R + 24 | 0;
z = y + 24 | 0;
if ((z | 0) == (P | 0)) {
V = B;
break
} else {
R = B;
N = y
}
}
}
while (0);
T = V;
U = c[J >> 2] | 0
}
c[Q >> 2] = (T - U | 0) / 24 | 0;
U = b + 236 | 0;
T = c[U >> 2] | 0;
Q = b + 232 | 0;
J = c[Q >> 2] | 0;
if ((T | 0) > 0) {
V = 0;
do {
P = J + (V * 28 | 0) | 0;
c[P >> 2] = c[h + (c[P >> 2] << 2) >> 2];
V = V + 1 | 0;
P = c[U >> 2] | 0
} while ((V | 0) < (P | 0));
W = P
} else
W = T;
T = J + (W * 28 | 0) | 0;
e:
do if ((W | 0) == 0) {
X = J;
O = 65
} else {
V = J;
while (1) {
if ((c[V >> 2] | 0) < 0) {
X = V;
O = 65;
break e
}
V = V + 28 | 0;
if ((V | 0) == (T |
0)) {
Y = T;
Z = J;
break
}
}
}
while (0);
if ((O | 0) == 65)
if ((X | 0) == (T | 0)) {
Y = T;
Z = J
} else {
J = X;
W = X;
f:
while (1) {
X = W;
do {
X = X + 28 | 0;
if ((X | 0) == (T | 0))
break f
} while ((c[X >> 2] | 0) < 0);
c[J + 0 >> 2] = c[X + 0 >> 2];
c[J + 4 >> 2] = c[X + 4 >> 2];
c[J + 8 >> 2] = c[X + 8 >> 2];
c[J + 12 >> 2] = c[X + 12 >> 2];
c[J + 16 >> 2] = c[X + 16 >> 2];
c[J + 20 >> 2] = c[X + 20 >> 2];
c[J + 24 >> 2] = c[X + 24 >> 2];
J = J + 28 | 0;
W = X
}
Y = J;
Z = c[Q >> 2] | 0
}
c[U >> 2] = (Y - Z | 0) / 28 | 0;
Z = b + 252 | 0;
Y = c[Z >> 2] | 0;
U = b + 248 | 0;
Q = c[U >> 2] | 0;
if ((Y | 0) > 0) {
J = 0;
do {
W = Q + (J * 20 | 0) | 0;
c[W >> 2] = c[h + (c[W >> 2] << 2) >> 2];
W = Q + (J * 20 | 0) + 4 | 0;
c[W >> 2] = c[h + (c[W >> 2] << 2) >> 2];
J = J + 1 | 0;
W = c[Z >> 2] | 0
} while ((J | 0) < (W | 0));
_ = W
} else
_ = Y;
Y = Q + (_ * 20 | 0) | 0;
g:
do if ((_ | 0) == 0) {
$ = Q;
O = 77
} else {
J = Q;
while (1) {
if ((c[J >> 2] | 0) < 0) {
$ = J;
O = 77;
break g
}
if ((c[J + 4 >> 2] | 0) < 0) {
$ = J;
O = 77;
break g
}
J = J + 20 | 0;
if ((J | 0) == (Y | 0)) {
aa = Y;
ba = Q;
break
}
}
}
while (0);
if ((O | 0) == 77)
if (($ | 0) == (Y | 0)) {
aa = Y;
ba = Q
} else {
Q = $ + 20 | 0;
h:
do if ((Q | 0) == (Y | 0))
ca = $;
else {
_ = $;
J = Q;
X = $;
while (1) {
W = J;
T = X;
while (1) {
if ((c[W >> 2] | 0) >= 0 ? (c[T + 24 >> 2] | 0) >= 0 : 0)
break;
V = W + 20 | 0;
if ((V | 0) == (Y | 0)) {
ca = _;
break h
} else {
P = W;
W = V;
T = P
}
}
c[_ + 0 >> 2] = c[W + 0 >> 2];
c[_ + 4 >> 2] = c[W + 4 >> 2];
c[_ + 8 >> 2] = c[W + 8 >> 2];
c[_ + 12 >> 2] = c[W + 12 >> 2];
c[_ + 16 >> 2] = c[W + 16 >> 2];
T = _ + 20 | 0;
J = W + 20 | 0;
if ((J | 0) == (Y | 0)) {
ca = T;
break
} else {
_ = T;
X = W
}
}
}
while (0);
aa = ca;
ba = c[U >> 2] | 0
}
c[Z >> 2] = (aa - ba | 0) / 20 | 0;
ba = b + 268 | 0;
aa = c[ba >> 2] | 0;
Z = b + 264 | 0;
U = c[Z >> 2] | 0;
if ((aa | 0) > 0) {
ca = 0;
do {
Y = U + (ca * 60 | 0) | 0;
c[Y >> 2] = c[h + (c[Y >> 2] << 2) >> 2];
Y = U + (ca * 60 | 0) + 4 | 0;
c[Y >> 2] = c[h + (c[Y >> 2] << 2) >> 2];
Y = U + (ca * 60 | 0) + 8 | 0;
c[Y >> 2] = c[h + (c[Y >> 2] << 2) >> 2];
ca = ca + 1 | 0;
Y = c[ba >> 2] | 0
} while ((ca | 0) < (Y | 0));
da = Y
} else
da = aa;
aa = U + (da * 60 | 0) | 0;
i:
do if ((da | 0) == 0) {
ea = U;
O = 92
} else {
ca = U;
while (1) {
if ((c[ca >>
2] | 0) < 0) {
ea = ca;
O = 92;
break i
}
if ((c[ca + 4 >> 2] | 0) < 0) {
ea = ca;
O = 92;
break i
}
if ((c[ca + 8 >> 2] | 0) < 0) {
ea = ca;
O = 92;
break i
}
ca = ca + 60 | 0;
if ((ca | 0) == (aa | 0)) {
fa = aa;
ga = U;
break
}
}
}
while (0);
if ((O | 0) == 92)
if ((ea | 0) == (aa | 0)) {
fa = aa;
ga = U
} else {
U = ea + 60 | 0;
j:
do if ((U | 0) == (aa | 0))
ha = ea;
else {
O = ea;
da = U;
ca = ea;
while (1) {
Y = da;
$ = ca;
while (1) {
if (((c[Y >> 2] | 0) >= 0 ? (c[$ + 64 >> 2] | 0) >= 0 : 0) ? (c[$ + 68 >> 2] | 0) >= 0 : 0)
break;
Q = Y + 60 | 0;
if ((Q | 0) == (aa | 0)) {
ha = O;
break j
} else {
X = Y;
Y = Q;
$ = X
}
}
$ = O + 0 | 0;
W = Y + 0 | 0;
X = $ + 60 | 0;
do {
c[$ >> 2] = c[W >> 2];
$ = $ + 4 | 0;
W = W + 4 | 0
} while (($ | 0) < (X | 0));
W = O + 60 | 0;
da = Y + 60 | 0;
if ((da | 0) == (aa | 0)) {
ha = W;
break
} else {
O = W;
ca = Y
}
}
}
while (0);
fa = ha;
ga = c[Z >> 2] | 0
}
c[ba >> 2] = (fa - ga | 0) / 60 | 0;
ga = c[b + 288 >> 2] | 0;
if ((ga | 0) != 0 ? (fa = c[f >> 2] | 0, (fa | 0) > 0) : 0) {
ba = fa;
fa = 0;
Z = 0;
while (1) {
ha = c[h + (c[ga + (fa << 2) >> 2] << 2) >> 2] | 0;
if ((ha | 0) == -1) {
ia = ba;
ja = Z
} else {
c[ga + (Z << 2) >> 2] = ha;
ia = c[f >> 2] | 0;
ja = Z + 1 | 0
}
fa = fa + 1 | 0;
if ((fa | 0) >= (ia | 0))
break;
else {
ba = ia;
Z = ja
}
}
}
ja = b + 312 | 0;
Z = c[ja >> 2] | 0;
if ((Z | 0) != 0) {
ia = b + 16 | 0;
ba = b + 132 | 0;
fa = b + 48 | 0;
ga = b + 20 | 0;
ha = Z;
do {
Z = ha + 4 | 0;
aa = c[Z >> 2] | 0;
ea = ha + 8 | 0;
U = c[ea >> 2] | 0;
if ((aa | 0) < (U |
0)) {
ca = L;
O = aa;
aa = 0;
da = 0;
while (1) {
W = c[h + (O << 2) >> 2] | 0;
if ((W | 0) > -1) {
$ = W + 1 | 0;
ka = (ca | 0) < (W | 0) ? ca : W;
la = (aa | 0) > ($ | 0) ? aa : $;
ma = da
} else {
ka = ca;
la = aa;
ma = 1
}
O = O + 1 | 0;
if ((O | 0) >= (U | 0)) {
na = ka;
oa = la;
pa = ma;
break
} else {
ca = ka;
aa = la;
da = ma
}
}
} else {
na = L;
oa = 0;
pa = 0
}
if ((na | 0) < (oa | 0)) {
c[Z >> 2] = na;
c[ea >> 2] = oa;
if (pa ? (da = ha + 12 | 0, aa = c[da >> 2] | 0, (aa & 1 | 0) != 0) : 0) {
ca = aa | 16;
aa = c[ia >> 2] | 0;
if ((ca & ~aa | 0) != 0) {
U = c[ba >> 2] | 0;
if ((U | 0) == 0) {
O = c[fa >> 2] | 0;
if ((O | 0) == 0) {
vk(b, 256);
qa = c[fa >> 2] | 0
} else
qa = O;
O = Em(c[e >> 2] | 0, qa << 2) | 0;
xn(O | 0, 0, c[fa >> 2] << 2 | 0) |
0;
ra = O;
sa = c[ia >> 2] | 0
} else {
ra = U;
sa = aa
}
c[ba >> 2] = ra;
c[ia >> 2] = sa | ca
}
c[da >> 2] = ca
}
} else {
c[Z >> 2] = 0;
c[ea >> 2] = 0;
ca = ha + 12 | 0;
da = c[ca >> 2] | 0;
if ((da & 4 | 0) == 0) {
aa = da | 8;
if (((da & -9 ^ -9) & da | 0) != 0)
a[ga >> 0] = 1;
U = c[ia >> 2] | 0;
if ((aa & ~U | 0) != 0) {
if ((da & 1 | 0) == 0)
ta = U;
else {
da = c[ba >> 2] | 0;
if ((da | 0) == 0) {
O = c[fa >> 2] | 0;
if ((O | 0) == 0) {
vk(b, 256);
ua = c[fa >> 2] | 0
} else
ua = O;
O = Em(c[e >> 2] | 0, ua << 2) | 0;
xn(O | 0, 0, c[fa >> 2] << 2 | 0) | 0;
va = O;
wa = c[ia >> 2] | 0
} else {
va = da;
wa = U
}
c[ba >> 2] = va;
ta = wa
}
c[ia >> 2] = ta | aa
}
c[ca >> 2] = aa
}
}
ha = c[ha + 24 >> 2] | 0
} while ((ha | 0) != 0)
}
c[f >> 2] =
L;
_m((c[e >> 2] | 0) + 76 | 0, h);
c[b + 8 >> 2] = K;
a[b + 12 >> 0] = 0;
K = c[ja >> 2] | 0;
if ((K | 0) == 0) {
i = d;
return
} else
xa = K;
do {
K = xa;
xa = c[xa + 24 >> 2] | 0;
if ((c[K + 12 >> 2] & 8 | 0) != 0)
tk(b, K)
} while ((xa | 0) != 0);
i = d;
return
}
function yk(b, d, e) {
b = b | 0;
d = d | 0;
e = +e;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0;
f = i;
h = b + 288 | 0;
j = c[h >> 2] | 0;
k = (j | 0) == 0;
l = b + 280 | 0;
m = c[l >> 2] | 0;
if ((m | 0) == 0) {
n = b + 48 | 0;
o = c[n >> 2] | 0;
if ((o | 0) == 0) {
vk(b, 256);
p = c[n >> 2] | 0
} else
p = o;
o = Em(c[b + 400 >> 2] | 0, p << 2) | 0;
xn(o | 0, 0, c[n >> 2] << 2 | 0) | 0;
q = o;
r = c[h >> 2] | 0
} else {
q = m;
r = j
}
c[l >> 2] =
q;
if ((r | 0) == 0) {
q = b + 48 | 0;
j = c[q >> 2] | 0;
if ((j | 0) == 0) {
vk(b, 256);
s = c[q >> 2] | 0
} else
s = j;
j = Em(c[b + 400 >> 2] | 0, s << 2) | 0;
xn(j | 0, 0, c[q >> 2] << 2 | 0) | 0;
t = j
} else
t = r;
c[h >> 2] = t;
if (k ? (k = c[b + 44 >> 2] | 0, (k | 0) > 0) : 0) {
h = 0;
do {
c[t + (h << 2) >> 2] = h;
h = h + 1 | 0
} while ((h | 0) != (k | 0))
}
k = ~~(e / +g[b + 396 >> 2]);
if ((k | 0) > 0)
u = (c[b + 300 >> 2] | 0) + k | 0;
else
u = k;
k = (c[l >> 2] | 0) + (d << 2) | 0;
if ((u | 0) == (c[k >> 2] | 0)) {
i = f;
return
}
c[k >> 2] = u;
a[b + 304 >> 0] = 1;
i = f;
return
}
function zk(b, d, e, f) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w =
0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0;
h = i;
if ((d | 0) == (e | 0) | (e | 0) == (f | 0)) {
i = h;
return
}
j = c[b + 88 >> 2] | 0;
k = j + (d << 2) | 0;
l = j + (e << 2) | 0;
m = j + (f << 2) | 0;
a:
do if ((d + 1 | 0) != (e | 0)) {
if ((e + 1 | 0) == (f | 0)) {
n = j + (f + -1 << 2) | 0;
o = c[n >> 2] | 0;
p = n - k | 0;
Bn(j + (f - (p >> 2) << 2) | 0, k | 0, p | 0) | 0;
c[k >> 2] = o;
break
}
o = l;
p = o - k >> 2;
n = m;
q = n - o >> 2;
if ((p | 0) == (q |
0)) {
o = k;
r = l;
while (1) {
s = c[o >> 2] | 0;
c[o >> 2] = c[r >> 2];
c[r >> 2] = s;
o = o + 4 | 0;
if ((o | 0) == (l | 0))
break a;
else
r = r + 4 | 0
}
} else {
t = p;
u = q
}
while (1) {
r = (t | 0) % (u | 0) | 0;
if ((r | 0) == 0)
break;
else {
o = u;
u = r;
t = o
}
}
if ((u | 0) != 0) {
q = p + -1 | 0;
o = p + d | 0;
r = j + (u + d << 2) | 0;
do {
s = r;
r = r + -4 | 0;
v = c[r >> 2] | 0;
w = r;
x = s + (q << 2) | 0;
while (1) {
c[w >> 2] = c[x >> 2];
s = n - x >> 2;
if ((p | 0) < (s | 0))
y = x + (p << 2) | 0;
else
y = j + (o - s << 2) | 0;
if ((y | 0) == (r | 0))
break;
else {
s = x;
x = y;
w = s
}
}
c[x >> 2] = v
} while ((r | 0) != (k | 0))
}
} else {
r = c[k >> 2] | 0;
o = m - l | 0;
Bn(k | 0, l | 0, o | 0) | 0;
c[j + ((o >> 2) + d << 2) >> 2] = r
}
while (0);
j = c[b +
160 >> 2] | 0;
b:
do if ((j | 0) != 0) {
l = j + (d << 2) | 0;
k = j + (e << 2) | 0;
m = j + (f << 2) | 0;
if ((d + 1 | 0) == (e | 0)) {
y = c[l >> 2] | 0;
u = m - k | 0;
Bn(l | 0, k | 0, u | 0) | 0;
c[j + ((u >> 2) + d << 2) >> 2] = y;
break
}
if ((e + 1 | 0) == (f | 0)) {
y = j + (f + -1 << 2) | 0;
u = c[y >> 2] | 0;
t = y - l | 0;
Bn(j + (f - (t >> 2) << 2) | 0, l | 0, t | 0) | 0;
c[l >> 2] = u;
break
}
u = k;
t = u - l >> 2;
y = m;
m = y - u >> 2;
if ((t | 0) == (m | 0)) {
u = l;
r = k;
while (1) {
o = c[u >> 2] | 0;
c[u >> 2] = c[r >> 2];
c[r >> 2] = o;
u = u + 4 | 0;
if ((u | 0) == (k | 0))
break b;
else
r = r + 4 | 0
}
} else {
z = t;
A = m
}
while (1) {
r = (z | 0) % (A | 0) | 0;
if ((r | 0) == 0)
break;
else {
k = A;
A = r;
z = k
}
}
if ((A | 0) != 0) {
m = t + -1 | 0;
k = t +
d | 0;
r = j + (A + d << 2) | 0;
do {
u = r;
r = r + -4 | 0;
o = c[r >> 2] | 0;
p = r;
n = u + (m << 2) | 0;
while (1) {
c[p >> 2] = c[n >> 2];
u = y - n >> 2;
if ((t | 0) < (u | 0))
B = n + (t << 2) | 0;
else
B = j + (k - u << 2) | 0;
if ((B | 0) == (r | 0))
break;
else {
u = n;
n = B;
p = u
}
}
c[n >> 2] = o
} while ((r | 0) != (l | 0))
}
}
while (0);
B = c[b + 168 >> 2] | 0;
c:
do if ((B | 0) != 0) {
j = B + (d << 2) | 0;
A = B + (e << 2) | 0;
z = B + (f << 2) | 0;
if ((d + 1 | 0) == (e | 0)) {
l = c[j >> 2] | 0;
r = z - A | 0;
Bn(j | 0, A | 0, r | 0) | 0;
c[B + ((r >> 2) + d << 2) >> 2] = l;
break
}
if ((e + 1 | 0) == (f | 0)) {
l = B + (f + -1 << 2) | 0;
r = c[l >> 2] | 0;
k = l - j | 0;
Bn(B + (f - (k >> 2) << 2) | 0, j | 0, k | 0) | 0;
c[j >> 2] = r;
break
}
r = A;
k = r - j >> 2;
l = z;
z = l - r >> 2;
if ((k | 0) == (z | 0)) {
r = j;
t = A;
while (1) {
y = c[r >> 2] | 0;
c[r >> 2] = c[t >> 2];
c[t >> 2] = y;
r = r + 4 | 0;
if ((r | 0) == (A | 0))
break c;
else
t = t + 4 | 0
}
} else {
C = k;
D = z
}
while (1) {
t = (C | 0) % (D | 0) | 0;
if ((t | 0) == 0)
break;
else {
A = D;
D = t;
C = A
}
}
if ((D | 0) != 0) {
z = k + -1 | 0;
A = k + d | 0;
t = B + (D + d << 2) | 0;
do {
r = t;
t = t + -4 | 0;
y = c[t >> 2] | 0;
m = t;
p = r + (z << 2) | 0;
while (1) {
c[m >> 2] = c[p >> 2];
r = l - p >> 2;
if ((k | 0) < (r | 0))
E = p + (k << 2) | 0;
else
E = B + (A - r << 2) | 0;
if ((E | 0) == (t | 0))
break;
else {
r = p;
p = E;
m = r
}
}
c[p >> 2] = y
} while ((t | 0) != (j | 0))
}
}
while (0);
E = c[b + 176 >> 2] | 0;
d:
do if ((E | 0) != 0) {
B = E + (d << 2) |
0;
D = E + (e << 2) | 0;
C = E + (f << 2) | 0;
if ((d + 1 | 0) == (e | 0)) {
j = c[B >> 2] | 0;
t = C - D | 0;
Bn(B | 0, D | 0, t | 0) | 0;
c[E + ((t >> 2) + d << 2) >> 2] = j;
break
}
if ((e + 1 | 0) == (f | 0)) {
j = E + (f + -1 << 2) | 0;
t = c[j >> 2] | 0;
A = j - B | 0;
Bn(E + (f - (A >> 2) << 2) | 0, B | 0, A | 0) | 0;
c[B >> 2] = t;
break
}
t = D;
A = t - B >> 2;
j = C;
C = j - t >> 2;
if ((A | 0) == (C | 0)) {
t = B;
k = D;
while (1) {
l = c[t >> 2] | 0;
c[t >> 2] = c[k >> 2];
c[k >> 2] = l;
t = t + 4 | 0;
if ((t | 0) == (D | 0))
break d;
else
k = k + 4 | 0
}
} else {
F = A;
G = C
}
while (1) {
k = (F | 0) % (G | 0) | 0;
if ((k | 0) == 0)
break;
else {
D = G;
G = k;
F = D
}
}
if ((G | 0) != 0) {
C = A + -1 | 0;
D = A + d | 0;
k = E + (G + d << 2) | 0;
do {
t = k;
k = k + -4 | 0;
l = c[k >>
2] | 0;
z = k;
m = t + (C << 2) | 0;
while (1) {
c[z >> 2] = c[m >> 2];
t = j - m >> 2;
if ((A | 0) < (t | 0))
H = m + (A << 2) | 0;
else
H = E + (D - t << 2) | 0;
if ((H | 0) == (k | 0))
break;
else {
t = m;
m = H;
z = t
}
}
c[m >> 2] = l
} while ((k | 0) != (B | 0))
}
}
while (0);
H = c[b + 96 >> 2] | 0;
E = H + (d << 3) | 0;
G = H + (e << 3) | 0;
F = H + (f << 3) | 0;
e:
do if ((d + 1 | 0) != (e | 0)) {
if ((e + 1 | 0) == (f | 0)) {
B = H + (f + -1 << 3) | 0;
k = B;
D = c[k >> 2] | 0;
A = c[k + 4 >> 2] | 0;
k = B - E | 0;
Bn(H + (f - (k >> 3) << 3) | 0, E | 0, k | 0) | 0;
k = E;
c[k >> 2] = D;
c[k + 4 >> 2] = A;
break
}
A = G;
k = A - E >> 3;
D = F;
B = D - A >> 3;
if ((k | 0) == (B | 0)) {
A = E;
j = G;
while (1) {
C = A;
z = c[C >> 2] | 0;
y = c[C + 4 >> 2] | 0;
C = j;
p = c[C + 4 >>
2] | 0;
t = A;
c[t >> 2] = c[C >> 2];
c[t + 4 >> 2] = p;
p = j;
c[p >> 2] = z;
c[p + 4 >> 2] = y;
A = A + 8 | 0;
if ((A | 0) == (G | 0))
break e;
else
j = j + 8 | 0
}
} else {
I = k;
J = B
}
while (1) {
j = (I | 0) % (J | 0) | 0;
if ((j | 0) == 0)
break;
else {
A = J;
J = j;
I = A
}
}
if ((J | 0) != 0) {
B = k + -1 | 0;
A = k + d | 0;
j = H + (J + d << 3) | 0;
do {
y = j;
j = j + -8 | 0;
p = j;
z = c[p >> 2] | 0;
t = c[p + 4 >> 2] | 0;
p = j;
C = y + (B << 3) | 0;
while (1) {
y = C;
o = c[y + 4 >> 2] | 0;
n = p;
c[n >> 2] = c[y >> 2];
c[n + 4 >> 2] = o;
o = D - C >> 3;
if ((k | 0) < (o | 0))
K = C + (k << 3) | 0;
else
K = H + (A - o << 3) | 0;
if ((K | 0) == (j | 0))
break;
else {
o = C;
C = K;
p = o
}
}
p = C;
c[p >> 2] = z;
c[p + 4 >> 2] = t
} while ((j | 0) != (E | 0))
}
} else {
j =
E;
A = c[j >> 2] | 0;
k = c[j + 4 >> 2] | 0;
j = F - G | 0;
Bn(E | 0, G | 0, j | 0) | 0;
D = H + ((j >> 3) + d << 3) | 0;
c[D >> 2] = A;
c[D + 4 >> 2] = k
}
while (0);
H = c[b + 104 >> 2] | 0;
G = H + (d << 3) | 0;
E = H + (e << 3) | 0;
F = H + (f << 3) | 0;
f:
do if ((d + 1 | 0) != (e | 0)) {
if ((e + 1 | 0) == (f | 0)) {
K = H + (f + -1 << 3) | 0;
J = K;
I = c[J >> 2] | 0;
k = c[J + 4 >> 2] | 0;
J = K - G | 0;
Bn(H + (f - (J >> 3) << 3) | 0, G | 0, J | 0) | 0;
J = G;
c[J >> 2] = I;
c[J + 4 >> 2] = k;
break
}
k = E;
J = k - G >> 3;
I = F;
K = I - k >> 3;
if ((J | 0) == (K | 0)) {
k = G;
D = E;
while (1) {
A = k;
j = c[A >> 2] | 0;
B = c[A + 4 >> 2] | 0;
A = D;
p = c[A + 4 >> 2] | 0;
l = k;
c[l >> 2] = c[A >> 2];
c[l + 4 >> 2] = p;
p = D;
c[p >> 2] = j;
c[p + 4 >> 2] = B;
k = k + 8 | 0;
if ((k |
0) == (E | 0))
break f;
else
D = D + 8 | 0
}
} else {
L = J;
M = K
}
while (1) {
D = (L | 0) % (M | 0) | 0;
if ((D | 0) == 0)
break;
else {
k = M;
M = D;
L = k
}
}
if ((M | 0) != 0) {
K = J + -1 | 0;
k = J + d | 0;
D = H + (M + d << 3) | 0;
do {
B = D;
D = D + -8 | 0;
p = D;
j = c[p >> 2] | 0;
l = c[p + 4 >> 2] | 0;
p = D;
A = B + (K << 3) | 0;
while (1) {
B = A;
m = c[B + 4 >> 2] | 0;
o = p;
c[o >> 2] = c[B >> 2];
c[o + 4 >> 2] = m;
m = I - A >> 3;
if ((J | 0) < (m | 0))
N = A + (J << 3) | 0;
else
N = H + (k - m << 3) | 0;
if ((N | 0) == (D | 0))
break;
else {
m = A;
A = N;
p = m
}
}
p = A;
c[p >> 2] = j;
c[p + 4 >> 2] = l
} while ((D | 0) != (G | 0))
}
} else {
D = G;
k = c[D >> 2] | 0;
J = c[D + 4 >> 2] | 0;
D = F - E | 0;
Bn(G | 0, E | 0, D | 0) | 0;
I = H + ((D >> 3) + d << 3) | 0;
c[I >>
2] = k;
c[I + 4 >> 2] = J
}
while (0);
H = c[b + 144 >> 2] | 0;
E = H + (d << 2) | 0;
G = H + (e << 2) | 0;
F = H + (f << 2) | 0;
g:
do if ((d + 1 | 0) != (e | 0)) {
if ((e + 1 | 0) == (f | 0)) {
N = H + (f + -1 << 2) | 0;
M = c[N >> 2] | 0;
L = N - E | 0;
Bn(H + (f - (L >> 2) << 2) | 0, E | 0, L | 0) | 0;
c[E >> 2] = M;
break
}
M = G;
L = M - E >> 2;
N = F;
J = N - M >> 2;
if ((L | 0) == (J | 0)) {
M = E;
I = G;
while (1) {
k = c[M >> 2] | 0;
c[M >> 2] = c[I >> 2];
c[I >> 2] = k;
M = M + 4 | 0;
if ((M | 0) == (G | 0))
break g;
else
I = I + 4 | 0
}
} else {
O = L;
P = J
}
while (1) {
I = (O | 0) % (P | 0) | 0;
if ((I | 0) == 0)
break;
else {
M = P;
P = I;
O = M
}
}
if ((P | 0) != 0) {
J = L + -1 | 0;
M = L + d | 0;
I = H + (P + d << 2) | 0;
do {
k = I;
I = I + -4 | 0;
D = c[I >> 2] | 0;
K =
I;
p = k + (J << 2) | 0;
while (1) {
c[K >> 2] = c[p >> 2];
k = N - p >> 2;
if ((L | 0) < (k | 0))
Q = p + (L << 2) | 0;
else
Q = H + (M - k << 2) | 0;
if ((Q | 0) == (I | 0))
break;
else {
k = p;
p = Q;
K = k
}
}
c[p >> 2] = D
} while ((I | 0) != (E | 0))
}
} else {
I = c[E >> 2] | 0;
M = F - G | 0;
Bn(E | 0, G | 0, M | 0) | 0;
c[H + ((M >> 2) + d << 2) >> 2] = I
}
while (0);
h:
do if ((a[b + 21 >> 0] | 0) != 0) {
H = c[b + 112 >> 2] | 0;
G = H + (d << 3) | 0;
E = H + (e << 3) | 0;
F = H + (f << 3) | 0;
if ((d + 1 | 0) == (e | 0)) {
Q = G;
P = c[Q >> 2] | 0;
O = c[Q + 4 >> 2] | 0;
Q = F - E | 0;
Bn(G | 0, E | 0, Q | 0) | 0;
I = H + ((Q >> 3) + d << 3) | 0;
c[I >> 2] = P;
c[I + 4 >> 2] = O;
break
}
if ((e + 1 | 0) == (f | 0)) {
O = H + (f + -1 << 3) | 0;
I = O;
P = c[I >> 2] | 0;
Q =
c[I + 4 >> 2] | 0;
I = O - G | 0;
Bn(H + (f - (I >> 3) << 3) | 0, G | 0, I | 0) | 0;
I = G;
c[I >> 2] = P;
c[I + 4 >> 2] = Q;
break
}
Q = E;
I = Q - G >> 3;
P = F;
F = P - Q >> 3;
if ((I | 0) == (F | 0)) {
Q = G;
O = E;
while (1) {
M = Q;
L = c[M >> 2] | 0;
N = c[M + 4 >> 2] | 0;
M = O;
J = c[M + 4 >> 2] | 0;
K = Q;
c[K >> 2] = c[M >> 2];
c[K + 4 >> 2] = J;
J = O;
c[J >> 2] = L;
c[J + 4 >> 2] = N;
Q = Q + 8 | 0;
if ((Q | 0) == (E | 0))
break h;
else
O = O + 8 | 0
}
} else {
R = I;
S = F
}
while (1) {
O = (R | 0) % (S | 0) | 0;
if ((O | 0) == 0)
break;
else {
E = S;
S = O;
R = E
}
}
if ((S | 0) != 0) {
F = I + -1 | 0;
E = I + d | 0;
O = H + (S + d << 3) | 0;
do {
Q = O;
O = O + -8 | 0;
N = O;
J = c[N >> 2] | 0;
L = c[N + 4 >> 2] | 0;
N = O;
K = Q + (F << 3) | 0;
while (1) {
Q = K;
M = c[Q + 4 >> 2] |
0;
l = N;
c[l >> 2] = c[Q >> 2];
c[l + 4 >> 2] = M;
M = P - K >> 3;
if ((I | 0) < (M | 0))
T = K + (I << 3) | 0;
else
T = H + (E - M << 3) | 0;
if ((T | 0) == (O | 0))
break;
else {
M = K;
K = T;
N = M
}
}
N = K;
c[N >> 2] = J;
c[N + 4 >> 2] = L
} while ((O | 0) != (G | 0))
}
}
while (0);
T = c[b + 120 >> 2] | 0;
i:
do if ((T | 0) != 0) {
S = T + (d << 2) | 0;
R = T + (e << 2) | 0;
G = T + (f << 2) | 0;
if ((d + 1 | 0) == (e | 0)) {
U = +g[S >> 2];
O = G - R | 0;
Bn(S | 0, R | 0, O | 0) | 0;
g[T + ((O >> 2) + d << 2) >> 2] = U;
break
}
if ((e + 1 | 0) == (f | 0)) {
O = T + (f + -1 << 2) | 0;
U = +g[O >> 2];
E = O - S | 0;
Bn(T + (f - (E >> 2) << 2) | 0, S | 0, E | 0) | 0;
g[S >> 2] = U;
break
}
E = R;
O = E - S >> 2;
H = G;
G = H - E >> 2;
if ((O | 0) == (G | 0)) {
E = S;
I = R;
while (1) {
U =
+g[E >> 2];
g[E >> 2] = +g[I >> 2];
g[I >> 2] = U;
E = E + 4 | 0;
if ((E | 0) == (R | 0))
break i;
else
I = I + 4 | 0
}
} else {
V = O;
W = G
}
while (1) {
I = (V | 0) % (W | 0) | 0;
if ((I | 0) == 0)
break;
else {
R = W;
W = I;
V = R
}
}
if ((W | 0) != 0) {
G = O + -1 | 0;
R = O + d | 0;
I = T + (W + d << 2) | 0;
do {
E = I;
I = I + -4 | 0;
U = +g[I >> 2];
P = I;
F = E + (G << 2) | 0;
while (1) {
g[P >> 2] = +g[F >> 2];
E = H - F >> 2;
if ((O | 0) < (E | 0))
X = F + (O << 2) | 0;
else
X = T + (R - E << 2) | 0;
if ((X | 0) == (I | 0))
break;
else {
E = F;
F = X;
P = E
}
}
g[F >> 2] = U
} while ((I | 0) != (S | 0))
}
}
while (0);
X = c[b + 132 >> 2] | 0;
j:
do if ((X | 0) != 0) {
T = X + (d << 2) | 0;
W = X + (e << 2) | 0;
V = X + (f << 2) | 0;
if ((d + 1 | 0) == (e | 0)) {
Y =
+g[T >> 2];
S = V - W | 0;
Bn(T | 0, W | 0, S | 0) | 0;
g[X + ((S >> 2) + d << 2) >> 2] = Y;
break
}
if ((e + 1 | 0) == (f | 0)) {
S = X + (f + -1 << 2) | 0;
Y = +g[S >> 2];
I = S - T | 0;
Bn(X + (f - (I >> 2) << 2) | 0, T | 0, I | 0) | 0;
g[T >> 2] = Y;
break
}
I = W;
S = I - T >> 2;
R = V;
V = R - I >> 2;
if ((S | 0) == (V | 0)) {
I = T;
O = W;
while (1) {
Y = +g[I >> 2];
g[I >> 2] = +g[O >> 2];
g[O >> 2] = Y;
I = I + 4 | 0;
if ((I | 0) == (W | 0))
break j;
else
O = O + 4 | 0
}
} else {
Z = S;
_ = V
}
while (1) {
O = (Z | 0) % (_ | 0) | 0;
if ((O | 0) == 0)
break;
else {
W = _;
_ = O;
Z = W
}
}
if ((_ | 0) != 0) {
V = S + -1 | 0;
W = S + d | 0;
O = X + (_ + d << 2) | 0;
do {
I = O;
O = O + -4 | 0;
Y = +g[O >> 2];
H = O;
G = I + (V << 2) | 0;
while (1) {
g[H >> 2] = +g[G >> 2];
I =
R - G >> 2;
if ((S | 0) < (I | 0))
$ = G + (S << 2) | 0;
else
$ = X + (W - I << 2) | 0;
if (($ | 0) == (O | 0))
break;
else {
I = G;
G = $;
H = I
}
}
g[G >> 2] = Y
} while ((O | 0) != (T | 0))
}
}
while (0);
$ = c[b + 136 >> 2] | 0;
if (($ | 0) != 0)
rl($ + (d << 2) | 0, $ + (e << 2) | 0, $ + (f << 2) | 0) | 0;
$ = c[b + 148 >> 2] | 0;
k:
do if (($ | 0) != 0) {
X = $ + (d << 2) | 0;
_ = $ + (e << 2) | 0;
Z = $ + (f << 2) | 0;
if ((d + 1 | 0) == (e | 0)) {
T = c[X >> 2] | 0;
O = Z - _ | 0;
Bn(X | 0, _ | 0, O | 0) | 0;
c[$ + ((O >> 2) + d << 2) >> 2] = T;
break
}
if ((e + 1 | 0) == (f | 0)) {
T = $ + (f + -1 << 2) | 0;
O = c[T >> 2] | 0;
W = T - X | 0;
Bn($ + (f - (W >> 2) << 2) | 0, X | 0, W | 0) | 0;
c[X >> 2] = O;
break
}
O = _;
W = O - X >> 2;
T = Z;
Z = T - O >> 2;
if ((W | 0) ==
(Z | 0)) {
O = X;
S = _;
while (1) {
R = c[O >> 2] | 0;
c[O >> 2] = c[S >> 2];
c[S >> 2] = R;
O = O + 4 | 0;
if ((O | 0) == (_ | 0))
break k;
else
S = S + 4 | 0
}
} else {
aa = W;
ba = Z
}
while (1) {
S = (aa | 0) % (ba | 0) | 0;
if ((S | 0) == 0)
break;
else {
_ = ba;
ba = S;
aa = _
}
}
if ((ba | 0) != 0) {
Z = W + -1 | 0;
_ = W + d | 0;
S = $ + (ba + d << 2) | 0;
do {
O = S;
S = S + -4 | 0;
R = c[S >> 2] | 0;
V = S;
H = O + (Z << 2) | 0;
while (1) {
c[V >> 2] = c[H >> 2];
O = T - H >> 2;
if ((W | 0) < (O | 0))
ca = H + (W << 2) | 0;
else
ca = $ + (_ - O << 2) | 0;
if ((ca | 0) == (S | 0))
break;
else {
O = H;
H = ca;
V = O
}
}
c[H >> 2] = R
} while ((S | 0) != (X | 0))
}
}
while (0);
ca = b + 80 | 0;
$ = c[ca >> 2] | 0;
if (($ | 0) != 0) {
ba = $ + (d << 2) | 0;
aa = $ +
(e << 2) | 0;
X = $ + (f << 2) | 0;
l:
do if ((d + 1 | 0) != (e | 0)) {
if ((e + 1 | 0) == (f | 0)) {
S = $ + (f + -1 << 2) | 0;
_ = c[S >> 2] | 0;
W = S - ba | 0;
Bn($ + (f - (W >> 2) << 2) | 0, ba | 0, W | 0) | 0;
c[ba >> 2] = _;
break
}
_ = aa;
W = _ - ba >> 2;
S = X;
T = S - _ >> 2;
if ((W | 0) == (T | 0)) {
_ = ba;
Z = aa;
while (1) {
V = c[_ >> 2] | 0;
c[_ >> 2] = c[Z >> 2];
c[Z >> 2] = V;
_ = _ + 4 | 0;
if ((_ | 0) == (aa | 0))
break l;
else
Z = Z + 4 | 0
}
} else {
da = W;
ea = T
}
while (1) {
Z = (da | 0) % (ea | 0) | 0;
if ((Z | 0) == 0)
break;
else {
_ = ea;
ea = Z;
da = _
}
}
if ((ea | 0) != 0) {
T = W + -1 | 0;
_ = W + d | 0;
Z = $ + (ea + d << 2) | 0;
do {
V = Z;
Z = Z + -4 | 0;
G = c[Z >> 2] | 0;
O = Z;
F = V + (T << 2) | 0;
while (1) {
c[O >> 2] = c[F >> 2];
V =
S - F >> 2;
if ((W | 0) < (V | 0))
fa = F + (W << 2) | 0;
else
fa = $ + (_ - V << 2) | 0;
if ((fa | 0) == (Z | 0))
break;
else {
V = F;
F = fa;
O = V
}
}
c[F >> 2] = G
} while ((Z | 0) != (ba | 0))
}
} else {
Z = c[ba >> 2] | 0;
_ = X - aa | 0;
Bn(ba | 0, aa | 0, _ | 0) | 0;
c[$ + ((_ >> 2) + d << 2) >> 2] = Z
}
while (0);
if ((d | 0) < (f | 0)) {
$ = c[ca >> 2] | 0;
ca = f - e | 0;
aa = d - e | 0;
ba = d;
do {
X = c[$ + (ba << 2) >> 2] | 0;
if ((X | 0) != 0) {
fa = X + 8 | 0;
X = c[fa >> 2] | 0;
do if ((X | 0) >= (d | 0))
if ((X | 0) < (e | 0)) {
ga = ca + X | 0;
break
} else {
ga = X + ((X | 0) < (f | 0) ? aa : 0) | 0;
break
}
else
ga = X;
while (0);
c[fa >> 2] = ga
}
ba = ba + 1 | 0
} while ((ba | 0) != (f | 0))
}
}
ba = c[b + 280 >> 2] | 0;
if ((ba | 0) != 0) {
ga =
ba + (d << 2) | 0;
aa = ba + (e << 2) | 0;
ca = ba + (f << 2) | 0;
m:
do if ((d + 1 | 0) == (e | 0)) {
$ = c[ga >> 2] | 0;
X = ca - aa | 0;
Bn(ga | 0, aa | 0, X | 0) | 0;
c[ba + ((X >> 2) + d << 2) >> 2] = $
} else {
if ((e + 1 | 0) == (f | 0)) {
$ = ba + (f + -1 << 2) | 0;
X = c[$ >> 2] | 0;
ea = $ - ga | 0;
Bn(ba + (f - (ea >> 2) << 2) | 0, ga | 0, ea | 0) | 0;
c[ga >> 2] = X;
break
}
X = aa;
ea = X - ga >> 2;
$ = ca;
da = $ - X >> 2;
if ((ea | 0) == (da | 0)) {
X = ga;
Z = aa;
while (1) {
_ = c[X >> 2] | 0;
c[X >> 2] = c[Z >> 2];
c[Z >> 2] = _;
X = X + 4 | 0;
if ((X | 0) == (aa | 0))
break m;
else
Z = Z + 4 | 0
}
} else {
ha = ea;
ia = da
}
while (1) {
Z = (ha | 0) % (ia | 0) | 0;
if ((Z | 0) == 0)
break;
else {
X = ia;
ia = Z;
ha = X
}
}
if ((ia | 0) == 0)
break;
da = ea + -1 | 0;
X = ea + d | 0;
Z = ba + (ia + d << 2) | 0;
do {
fa = Z;
Z = Z + -4 | 0;
_ = c[Z >> 2] | 0;
W = Z;
S = fa + (da << 2) | 0;
while (1) {
c[W >> 2] = c[S >> 2];
fa = $ - S >> 2;
if ((ea | 0) < (fa | 0))
ja = S + (ea << 2) | 0;
else
ja = ba + (X - fa << 2) | 0;
if ((ja | 0) == (Z | 0))
break;
else {
fa = S;
S = ja;
W = fa
}
}
c[S >> 2] = _
} while ((Z | 0) != (ga | 0))
}
while (0);
ga = c[b + 44 >> 2] | 0;
ja = c[b + 288 >> 2] | 0;
if ((ga | 0) > 0) {
ba = f - e | 0;
ia = d - e | 0;
ha = 0;
do {
aa = ja + (ha << 2) | 0;
ca = c[aa >> 2] | 0;
do if ((ca | 0) >= (d | 0))
if ((ca | 0) < (e | 0)) {
ka = ba + ca | 0;
break
} else {
ka = ca + ((ca | 0) < (f | 0) ? ia : 0) | 0;
break
}
else
ka = ca;
while (0);
c[aa >> 2] = ka;
ha = ha + 1 | 0
} while ((ha |
0) != (ga | 0))
}
}
ga = b + 204 | 0;
if ((c[ga >> 2] | 0) > 0) {
ha = c[b + 200 >> 2] | 0;
ka = f - e | 0;
ia = d - e | 0;
ba = 0;
do {
ja = ha + (ba << 3) | 0;
ca = c[ja >> 2] | 0;
do if ((ca | 0) >= (d | 0))
if ((ca | 0) < (e | 0)) {
la = ka + ca | 0;
break
} else {
la = ca + ((ca | 0) < (f | 0) ? ia : 0) | 0;
break
}
else
la = ca;
while (0);
c[ja >> 2] = la;
ba = ba + 1 | 0
} while ((ba | 0) < (c[ga >> 2] | 0))
}
ga = b + 220 | 0;
if ((c[ga >> 2] | 0) > 0) {
ba = c[b + 216 >> 2] | 0;
la = f - e | 0;
ia = d - e | 0;
ka = 0;
do {
ha = ba + (ka * 24 | 0) | 0;
ca = c[ha >> 2] | 0;
do if ((ca | 0) >= (d | 0))
if ((ca | 0) < (e | 0)) {
ma = la + ca | 0;
break
} else {
ma = ca + ((ca | 0) < (f | 0) ? ia : 0) | 0;
break
}
else
ma = ca;
while (0);
ca = ba +
(ka * 24 | 0) + 4 | 0;
ja = c[ca >> 2] | 0;
do if ((ja | 0) >= (d | 0))
if ((ja | 0) < (e | 0)) {
na = la + ja | 0;
break
} else {
na = ja + ((ja | 0) < (f | 0) ? ia : 0) | 0;
break
}
else
na = ja;
while (0);
c[ha >> 2] = ma;
c[ca >> 2] = na;
ka = ka + 1 | 0
} while ((ka | 0) < (c[ga >> 2] | 0))
}
ga = b + 236 | 0;
if ((c[ga >> 2] | 0) > 0) {
ka = c[b + 232 >> 2] | 0;
na = f - e | 0;
ma = d - e | 0;
ia = 0;
do {
la = ka + (ia * 28 | 0) | 0;
ba = c[la >> 2] | 0;
do if ((ba | 0) >= (d | 0))
if ((ba | 0) < (e | 0)) {
oa = na + ba | 0;
break
} else {
oa = ba + ((ba | 0) < (f | 0) ? ma : 0) | 0;
break
}
else
oa = ba;
while (0);
c[la >> 2] = oa;
ia = ia + 1 | 0
} while ((ia | 0) < (c[ga >> 2] | 0))
}
ga = b + 252 | 0;
if ((c[ga >> 2] | 0) > 0) {
ia =
c[b + 248 >> 2] | 0;
oa = f - e | 0;
ma = d - e | 0;
na = 0;
do {
ka = ia + (na * 20 | 0) | 0;
ba = c[ka >> 2] | 0;
do if ((ba | 0) >= (d | 0))
if ((ba | 0) < (e | 0)) {
pa = oa + ba | 0;
break
} else {
pa = ba + ((ba | 0) < (f | 0) ? ma : 0) | 0;
break
}
else
pa = ba;
while (0);
c[ka >> 2] = pa;
ba = ia + (na * 20 | 0) + 4 | 0;
la = c[ba >> 2] | 0;
do if ((la | 0) >= (d | 0))
if ((la | 0) < (e | 0)) {
qa = oa + la | 0;
break
} else {
qa = la + ((la | 0) < (f | 0) ? ma : 0) | 0;
break
}
else
qa = la;
while (0);
c[ba >> 2] = qa;
na = na + 1 | 0
} while ((na | 0) < (c[ga >> 2] | 0))
}
ga = b + 268 | 0;
if ((c[ga >> 2] | 0) > 0) {
na = c[b + 264 >> 2] | 0;
qa = f - e | 0;
ma = d - e | 0;
oa = 0;
do {
ia = na + (oa * 60 | 0) | 0;
pa = c[ia >> 2] | 0;
do if ((pa |
0) >= (d | 0))
if ((pa | 0) < (e | 0)) {
ra = qa + pa | 0;
break
} else {
ra = pa + ((pa | 0) < (f | 0) ? ma : 0) | 0;
break
}
else
ra = pa;
while (0);
c[ia >> 2] = ra;
pa = na + (oa * 60 | 0) + 4 | 0;
ba = c[pa >> 2] | 0;
do if ((ba | 0) >= (d | 0))
if ((ba | 0) < (e | 0)) {
sa = qa + ba | 0;
break
} else {
sa = ba + ((ba | 0) < (f | 0) ? ma : 0) | 0;
break
}
else
sa = ba;
while (0);
c[pa >> 2] = sa;
ba = na + (oa * 60 | 0) + 8 | 0;
ia = c[ba >> 2] | 0;
do if ((ia | 0) >= (d | 0))
if ((ia | 0) < (e | 0)) {
ta = qa + ia | 0;
break
} else {
ta = ia + ((ia | 0) < (f | 0) ? ma : 0) | 0;
break
}
else
ta = ia;
while (0);
c[ba >> 2] = ta;
oa = oa + 1 | 0
} while ((oa | 0) < (c[ga >> 2] | 0))
}
ga = c[b + 312 >> 2] | 0;
if ((ga | 0) == 0) {
i =
h;
return
}
b = d - e | 0;
oa = f - e | 0;
ta = ga;
do {
ga = ta + 4 | 0;
ma = c[ga >> 2] | 0;
do if ((ma | 0) >= (d | 0))
if ((ma | 0) < (e | 0)) {
ua = oa + ma | 0;
break
} else {
ua = ma + ((ma | 0) < (f | 0) ? b : 0) | 0;
break
}
else
ua = ma;
while (0);
c[ga >> 2] = ua;
ma = ta + 8 | 0;
ba = c[ma >> 2] | 0;
qa = ba + -1 | 0;
do if ((ba | 0) > (d | 0))
if ((ba | 0) > (e | 0)) {
va = qa + ((ba | 0) > (f | 0) ? 0 : b) | 0;
break
} else {
va = oa + qa | 0;
break
}
else
va = qa;
while (0);
c[ma >> 2] = va + 1;
ta = c[ta + 24 >> 2] | 0
} while ((ta | 0) != 0);
i = h;
return
}
function Ak(b, d, e) {
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
f = i;
g = (c[b + 88 >> 2] | 0) + (d << 2) | 0;
if ((c[g >>
2] & ~e | 0) != 0)
a[b + 12 >> 0] = 1;
d = b + 8 | 0;
if ((~c[d >> 2] & e | 0) == 0) {
c[g >> 2] = e;
i = f;
return
}
if ((e & 128 | 0) != 0) {
h = b + 128 | 0;
j = c[h >> 2] | 0;
if ((j | 0) == 0) {
k = b + 48 | 0;
l = c[k >> 2] | 0;
if ((l | 0) == 0) {
vk(b, 256);
m = c[k >> 2] | 0
} else
m = l;
l = Em(c[b + 400 >> 2] | 0, m << 3) | 0;
xn(l | 0, 0, c[k >> 2] << 3 | 0) | 0;
n = l
} else
n = j;
c[h >> 2] = n
}
if ((e & 256 | 0) != 0) {
n = b + 136 | 0;
h = c[n >> 2] | 0;
if ((h | 0) == 0) {
j = b + 48 | 0;
l = c[j >> 2] | 0;
if ((l | 0) == 0) {
vk(b, 256);
o = c[j >> 2] | 0
} else
o = l;
l = Em(c[b + 400 >> 2] | 0, o << 2) | 0;
xn(l | 0, 0, c[j >> 2] << 2 | 0) | 0;
p = l
} else
p = h;
c[n >> 2] = p
}
c[d >> 2] = c[d >> 2] | e;
c[g >> 2] = e;
i = f;
return
}
function Bk(a,
b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0;
e = i;
Ak(a, b, c[(c[a + 88 >> 2] | 0) + (b << 2) >> 2] | (d ? 514 : 2));
i = e;
return
}
function Ck(b, d, e, f) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0;
g = i;
i = i + 64 | 0;
h = g + 16 | 0;
j = g;
k = b + 400 | 0;
if ((c[(c[k >> 2] | 0) + 102876 >> 2] & 2 | 0) != 0) {
l = 0;
i = g;
return l | 0
}
c[h >> 2] = 7912;
m = h + 12 | 0;
c[h + 4 >> 2] = b;
c[h + 8 >> 2] = d;
c[m + 0 >> 2] = c[e + 0 >> 2];
c[m + 4 >> 2] = c[e + 4 >> 2];
c[m + 8 >> 2] = c[e + 8 >> 2];
c[m + 12 >> 2] = c[e + 12 >> 2];
a[h + 28 >> 0] = f & 1;
f = h + 32 | 0;
c[f >> 2] = 0;
pb[c[(c[d >> 2] | 0) + 28 >> 2] & 31](d, j, e, 0);
Dj(c[k >> 2] | 0, h, j);
l = c[f >> 2] | 0;
i = g;
return l | 0
}
function Dk(d, e, f, h) {
d = d | 0;
e = e | 0;
f = f | 0;
h = h | 0;
var j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0;
j = i;
i = i + 96 | 0;
k = j + 48 | 0;
l = j;
m = +g[f + 52 >> 2];
if (m == 0)
n = +g[d + 32 >> 2] * .75;
else
n = m;
o = bb[c[(c[e >> 2] | 0) + 12 >> 2] & 7](e) | 0;
if ((o | 0) <= 0) {
i = j;
return
}
p = l + 4 | 0;
q = l + 8 | 0;
r = l + 28 | 0;
s = e + 4 | 0;
t = l + 12 | 0;
u = e + 12 | 0;
v = l + 20 | 0;
w = l + 12 | 0;
x = l +
24 | 0;
y = l + 16 | 0;
z = k + 4 | 0;
A = k + 12 | 0;
B = k + 20 | 0;
C = k + 21 | 0;
D = k + 22 | 0;
E = k + 23 | 0;
F = k + 24 | 0;
G = k + 28 | 0;
H = k + 32 | 0;
I = h + 12 | 0;
J = h + 8 | 0;
K = h + 4 | 0;
L = f + 28 | 0;
M = f + 8 | 0;
N = f + 12 | 0;
O = f + 20 | 0;
P = f + 24 | 0;
R = f + 32 | 0;
S = f + 33 | 0;
T = f + 34 | 0;
U = f + 35 | 0;
V = f + 64 | 0;
W = f + 68 | 0;
X = 0;
m = 0;
while (1) {
c[l >> 2] = 488;
c[p >> 2] = 1;
g[q >> 2] = .009999999776482582;
c[r + 0 >> 2] = 0;
c[r + 4 >> 2] = 0;
c[r + 8 >> 2] = 0;
c[r + 12 >> 2] = 0;
b[r + 16 >> 1] = 0;
if ((c[s >> 2] | 0) == 1) {
Y = s;
Z = c[Y + 4 >> 2] | 0;
_ = p;
c[_ >> 2] = c[Y >> 2];
c[_ + 4 >> 2] = Z;
c[t + 0 >> 2] = c[u + 0 >> 2];
c[t + 4 >> 2] = c[u + 4 >> 2];
c[t + 8 >> 2] = c[u + 8 >> 2];
c[t + 12 >> 2] = c[u + 12 >> 2];
c[t +
16 >> 2] = c[u + 16 >> 2];
c[t + 20 >> 2] = c[u + 20 >> 2];
c[t + 24 >> 2] = c[u + 24 >> 2];
c[t + 28 >> 2] = c[u + 28 >> 2];
b[t + 32 >> 1] = b[u + 32 >> 1] | 0
} else
Ge(e, l, X);
$ = +g[w >> 2];
aa = +g[v >> 2] - $;
ba = +g[y >> 2];
ca = +g[x >> 2] - ba;
da = +Q(+(aa * aa + ca * ca));
a:
do if (m < da) {
ea = $;
fa = ba;
ga = m;
while (1) {
ha = ga / da;
ia = ea + aa * ha;
ja = ca * ha + fa;
c[H >> 2] = 0;
c[k >> 2] = c[f >> 2];
ha = +g[I >> 2];
ka = +g[J >> 2];
la = +g[h >> 2] + (ia * ha - ja * ka);
ma = ja * ha + ia * ka + +g[K >> 2];
ka = +la;
ia = +ma;
Z = z;
g[Z >> 2] = ka;
g[Z + 4 >> 2] = ia;
ia = +g[L >> 2];
ka = +(+g[O >> 2] - ia * (ma - +g[N >> 2]));
ma = +(ia * (la - +g[M >> 2]) + +g[P >> 2]);
Z = A;
g[Z >> 2] =
ka;
g[Z + 4 >> 2] = ma;
Z = a[S >> 0] | 0;
_ = a[T >> 0] | 0;
Y = a[U >> 0] | 0;
a[B >> 0] = a[R >> 0] | 0;
a[C >> 0] = Z;
a[D >> 0] = _;
a[E >> 0] = Y;
g[F >> 2] = +g[V >> 2];
c[G >> 2] = c[W >> 2];
wk(d, k) | 0;
ma = n + ga;
if (!(ma < da)) {
na = ma;
break a
}
ea = +g[w >> 2];
fa = +g[y >> 2];
ga = ma
}
} else
na = m;
while (0);
Y = X + 1 | 0;
if ((Y | 0) == (o | 0))
break;
X = Y;
m = na - da
}
i = j;
return
}
function Ek(b, d, e, f) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0;
h = i;
i = i + 80 | 0;
j = h + 40 | 0;
k = h + 24 | 0;
l = h + 8 | 0;
m = h;
n = +g[e + 52 >> 2];
if (n == 0)
o = +g[b + 32 >> 2] * .75;
else
o = n;
g[k >> 2] = 0;
g[k + 4 >> 2] = 0;
g[k + 8 >> 2] = 0;
g[k + 12 >> 2] = 1;
pb[c[(c[d >> 2] | 0) + 28 >> 2] & 31](d, l, k, 0);
n = o * +O(+(+g[l + 4 >> 2] / o));
p = l + 12 | 0;
q = +g[p >> 2];
if (!(n < q)) {
i = h;
return
}
r = l + 8 | 0;
s = m + 4 | 0;
t = j + 4 | 0;
u = j + 12 | 0;
v = j + 20 | 0;
w = j + 21 | 0;
x = j + 22 | 0;
y = j + 23 | 0;
z = j + 24 | 0;
A = j + 28 | 0;
B = j + 32 | 0;
C = f + 12 | 0;
D = f + 8 | 0;
E = f + 4 | 0;
F = e + 28 | 0;
G = e + 8 | 0;
H = e + 12 | 0;
I = e + 20 | 0;
J = e + 24 | 0;
K = e + 32 | 0;
L = e + 33 | 0;
M = e + 34 | 0;
N = e + 35 | 0;
P = e + 64 | 0;
Q = e + 68 | 0;
R = q;
q = +g[r >> 2];
S =
n;
while (1) {
n = o * +O(+(+g[l >> 2] / o));
if (n < q) {
T = n;
do {
g[m >> 2] = T;
g[s >> 2] = S;
if (hb[c[(c[d >> 2] | 0) + 16 >> 2] & 15](d, k, m) | 0) {
c[B >> 2] = 0;
c[j >> 2] = c[e >> 2];
n = +g[C >> 2];
U = +g[m >> 2];
V = +g[D >> 2];
W = +g[s >> 2];
X = +g[f >> 2] + (n * U - V * W);
Y = U * V + n * W + +g[E >> 2];
W = +X;
n = +Y;
Z = t;
g[Z >> 2] = W;
g[Z + 4 >> 2] = n;
n = +g[F >> 2];
W = +(+g[I >> 2] - n * (Y - +g[H >> 2]));
Y = +(n * (X - +g[G >> 2]) + +g[J >> 2]);
Z = u;
g[Z >> 2] = W;
g[Z + 4 >> 2] = Y;
Z = a[L >> 0] | 0;
_ = a[M >> 0] | 0;
$ = a[N >> 0] | 0;
a[v >> 0] = a[K >> 0] | 0;
a[w >> 0] = Z;
a[x >> 0] = _;
a[y >> 0] = $;
g[z >> 2] = +g[P >> 2];
c[A >> 2] = c[Q >> 2];
wk(b, j) | 0
}
T = o + T;
aa = +g[r >> 2]
} while (T <
aa);
ba = +g[p >> 2];
ca = aa
} else {
ba = R;
ca = q
}
S = o + S;
if (!(S < ba))
break;
else {
R = ba;
q = ca
}
}
i = h;
return
}
function Fk(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0;
e = i;
i = i + 64 | 0;
f = e + 20 | 0;
h = e;
j = e + 16 | 0;
k = b + 400 | 0;
if ((c[(c[k >> 2] | 0) + 102876 >> 2] & 2 | 0) != 0) {
l = 0;
i = e;
return l | 0
}
m = +g[d + 16 >> 2];
n = d + 8 | 0;
o = c[n + 4 >> 2] | 0;
p = h;
c[p >> 2] = c[n >> 2];
c[p + 4 >> 2] = o;
o = h + 8 | 0;
g[o >> 2] = +T(+m);
p = h + 12 | 0;
g[p >> 2] = +S(+m);
n = b + 44 | 0;
q = c[n >> 2] | 0;
r = c[d + 40 >> 2] | 0;
do if ((r | 0) != 0) {
s = c[r + 4 >> 2] | 0;
if ((s | 0) == 3 | (s | 0) == 1) {
Dk(b, r, d, h);
break
} else if ((s | 0) == 0 | (s | 0) == 2) {
Ek(b, r, d, h);
break
} else
break
}
while (0);
r = c[d + 44 >> 2] | 0;
if ((r | 0) != 0) {
s = c[d + 48 >> 2] | 0;
c[f >> 2] = 7720;
c[f + 12 >> 2] = r;
c[f + 16 >> 2] = s;
Ek(b, f, d, h)
}
s = d + 56 | 0;
if ((c[s >> 2] | 0) > 0) {
r = d + 60 | 0;
t = f + 4 | 0;
u = f + 12 | 0;
v = f + 20 | 0;
w = f + 21 | 0;
x = f + 22 | 0;
y = f + 23 | 0;
z = f + 24 | 0;
A = f + 28 | 0;
B = f + 32 | 0;
m = +g[p >> 2];
C = +g[o >> 2];
D = +g[h >> 2];
E = +g[h + 4 >> 2];
o = d + 28 | 0;
p = d + 8 | 0;
F = d + 12 | 0;
G = d + 20 | 0;
H = d + 24 | 0;
I = d + 32 |
0;
J = d + 33 | 0;
K = d + 34 | 0;
L = d + 35 | 0;
M = d + 64 | 0;
N = d + 68 | 0;
O = 0;
do {
P = (c[r >> 2] | 0) + (O << 3) | 0;
Q = +g[P >> 2];
R = +g[P + 4 >> 2];
c[B >> 2] = 0;
c[f >> 2] = c[d >> 2];
U = D + (Q * m - R * C);
V = m * R + Q * C + E;
Q = +U;
R = +V;
P = t;
g[P >> 2] = Q;
g[P + 4 >> 2] = R;
R = +g[o >> 2];
Q = +(+g[G >> 2] - R * (V - +g[F >> 2]));
V = +(R * (U - +g[p >> 2]) + +g[H >> 2]);
P = u;
g[P >> 2] = Q;
g[P + 4 >> 2] = V;
P = a[J >> 0] | 0;
W = a[K >> 0] | 0;
X = a[L >> 0] | 0;
a[v >> 0] = a[I >> 0] | 0;
a[w >> 0] = P;
a[x >> 0] = W;
a[y >> 0] = X;
g[z >> 2] = +g[M >> 2];
c[A >> 2] = c[N >> 2];
wk(b, f) | 0;
O = O + 1 | 0
} while ((O | 0) < (c[s >> 2] | 0))
}
s = c[n >> 2] | 0;
n = Em(c[k >> 2] | 0, 80) | 0;
if ((n | 0) == 0)
Y = 0;
else {
mk(n);
Y = n
}
c[Y >> 2] = b;
c[Y + 4 >> 2] = q;
c[Y + 8 >> 2] = s;
g[Y + 16 >> 2] = +g[d + 36 >> 2];
c[Y + 76 >> 2] = c[d + 68 >> 2];
n = Y + 60 | 0;
c[n + 0 >> 2] = c[h + 0 >> 2];
c[n + 4 >> 2] = c[h + 4 >> 2];
c[n + 8 >> 2] = c[h + 8 >> 2];
c[n + 12 >> 2] = c[h + 12 >> 2];
c[Y + 20 >> 2] = 0;
h = b + 312 | 0;
c[Y + 24 >> 2] = c[h >> 2];
n = c[h >> 2] | 0;
if ((n | 0) != 0)
c[n + 20 >> 2] = Y;
c[h >> 2] = Y;
h = b + 308 | 0;
c[h >> 2] = (c[h >> 2] | 0) + 1;
if ((q | 0) < (s | 0)) {
h = b + 144 | 0;
n = q;
do {
c[(c[h >> 2] | 0) + (n << 2) >> 2] = Y;
n = n + 1 | 0
} while ((n | 0) != (s | 0))
}
n = c[d + 4 >> 2] | 0;
h = Y + 12 | 0;
O = c[h >> 2] | 0;
f = (O ^ n) << 4 & 16 | n;
if ((O & ~f | 0) != 0)
a[b + 20 >> 0] = 1;
O = b + 16 | 0;
N = c[O >> 2] | 0;
if ((f & ~N | 0) != 0) {
if ((n &
1 | 0) == 0)
Z = N;
else {
n = b + 132 | 0;
A = c[n >> 2] | 0;
if ((A | 0) == 0) {
M = b + 48 | 0;
z = c[M >> 2] | 0;
if ((z | 0) == 0) {
vk(b, 256);
_ = c[M >> 2] | 0
} else
_ = z;
z = Em(c[k >> 2] | 0, _ << 2) | 0;
xn(z | 0, 0, c[M >> 2] << 2 | 0) | 0;
$ = z;
aa = c[O >> 2] | 0
} else {
$ = A;
aa = N
}
c[n >> 2] = $;
Z = aa
}
c[O >> 2] = Z | f
}
c[h >> 2] = f;
c[j >> 2] = 7544;
Gk(b, 1);
Hk(b, q, s, j);
j = d + 72 | 0;
d = c[j >> 2] | 0;
if ((d | 0) == 0) {
l = Y;
i = e;
return l | 0
}
Ik(b, d, Y);
l = c[j >> 2] | 0;
i = e;
return l | 0
}
function Gk(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0;
d = i;
i = i + 32 | 0;
e = d;
f = d + 8 | 0;
h = a + 204 | 0;
j = c[h >> 2] | 0;
k =
c[a + 200 >> 2] | 0;
l = k + (j << 3) | 0;
if ((j | 0) > 0) {
m = c[a + 96 >> 2] | 0;
n = +g[a + 36 >> 2];
o = k;
do {
p = c[o >> 2] | 0;
c[o + 4 >> 2] = (~~(n * +g[m + (p << 3) + 4 >> 2] + 2048) >>> 0 << 20) + (~~(n * +g[m + (p << 3) >> 2] * 256 + 524288) >>> 0);
o = o + 8 | 0
} while (o >>> 0 < l >>> 0);
q = c[h >> 2] | 0
} else
q = j;
Il(k, k + (q << 3) | 0, e);
e = c[a + 400 >> 2] | 0;
c[f >> 2] = 0;
c[f + 4 >> 2] = 0;
q = f + 8 | 0;
c[q >> 2] = 0;
k = f + 12 | 0;
c[k >> 2] = e + 76;
if ((c[a + 8 >> 2] & 32768 | 0) != 0 ? (c[e + 102952 >> 2] | 0) != 0 : 0)
Rk(f, c[a + 216 >> 2] | 0, c[a + 220 >> 2] | 0, c[a + 88 >> 2] | 0);
e = a + 216 | 0;
Ok(a, e);
Qk(a, e);
Sk(a, f);
if (b) {
b = c[e >> 2] | 0;
j = a + 220 | 0;
a = c[j >> 2] | 0;
h = b + (a * 24 |
0) | 0;
a:
do if ((a | 0) == 0) {
r = b;
s = 12
} else {
l = b;
while (1) {
if ((c[l + 20 >> 2] & 2 | 0) != 0) {
r = l;
s = 12;
break a
}
l = l + 24 | 0;
if ((l | 0) == (h | 0)) {
t = h;
u = b;
break
}
}
}
while (0);
if ((s | 0) == 12)
if ((r | 0) == (h | 0)) {
t = h;
u = b
} else {
b = r;
s = r;
b:
while (1) {
r = s;
do {
a = r;
r = r + 24 | 0;
if ((r | 0) == (h | 0))
break b
} while ((c[a + 44 >> 2] & 2 | 0) != 0);
c[b + 0 >> 2] = c[r + 0 >> 2];
c[b + 4 >> 2] = c[r + 4 >> 2];
c[b + 8 >> 2] = c[r + 8 >> 2];
c[b + 12 >> 2] = c[r + 12 >> 2];
c[b + 16 >> 2] = c[r + 16 >> 2];
c[b + 20 >> 2] = c[r + 20 >> 2];
b = b + 24 | 0;
s = r
}
t = b;
u = c[e >> 2] | 0
}
c[j >> 2] = (t - u | 0) / 24 | 0
}
u = c[f >> 2] | 0;
if ((u | 0) == 0) {
i = d;
return
}
_m(c[k >> 2] | 0, u);
c[f >> 2] = 0;
c[q >> 2] = 0;
i = d;
return
}
function Hk(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0;
f = i;
i = i + 48 | 0;
h = f + 40 | 0;
j = f + 12 | 0;
k = f;
l = (b | 0) < (d | 0);
if (!l) {
i = f;
return
}
m = c[a + 88 >> 2] | 0;
n = b;
o = 0;
do {
o = c[m + (n << 2) >> 2] | o;
n = n + 1 | 0
} while ((n | 0) != (d | 0));
if ((o & 1032 | 0) != 0) {
n = a + 220 | 0;
if ((c[n >> 2] | 0) > 0) {
m = a + 216 | 0;
p = a + 88 | 0;
q = a + 144 | 0;
r = a + 252 | 0;
s = a + 256 | 0;
t = a + 248 | 0;
u = a + 96 | 0;
v = a + 260 | 0;
w = 0;
do {
x = c[m >> 2] | 0;
y = c[x + (w * 24 | 0) >> 2] | 0;
z = c[x + (w * 24 | 0) + 4 >> 2] | 0;
A = c[p >> 2] | 0;
B = c[A + (y << 2) >> 2] | 0;
C = c[A + (z << 2) >> 2] | 0;
A = c[q >> 2] | 0;
D = c[A + (y << 2) >> 2] | 0;
E = c[A + (z << 2) >> 2] | 0;
do if ((z | 0) < (d | 0) & (((y | 0) >= (d | 0) | (y | 0) < (b | 0) | (z | 0) < (b | 0)) ^ 1) ? (A = C | B, !((A & 2 | 0) != 0 | (A & 1032 | 0) == 0)) : 0) {
if (!(nb[c[(c[e >> 2] | 0) + 8 >> 2] & 31](e, y) | 0) ? !(nb[c[(c[e >> 2] | 0) + 8 >> 2] & 31](e, z) | 0) : 0)
break;
if ((B & 28 | 0) == 0) {
if ((D | 0) == 0)
break;
if ((c[D + 12 >> 2] & 2 | 0) == 0)
break
}
if ((C & 28 | 0) == 0) {
if ((E | 0) == 0)
break;
if ((c[E + 12 >> 2] & 2 | 0) == 0)
break
}
if (hb[c[(c[e >>
2] | 0) + 12 >> 2] & 15](e, y, z) | 0) {
A = c[r >> 2] | 0;
F = c[s >> 2] | 0;
if ((A | 0) >= (F | 0) ? (G = (F | 0) == 0 ? 256 : F << 1, (F | 0) < (G | 0)) : 0) {
F = Em(c[v >> 2] | 0, G * 20 | 0) | 0;
H = c[t >> 2] | 0;
if ((H | 0) != 0) {
An(F | 0, H | 0, (c[r >> 2] | 0) * 20 | 0) | 0;
Fm(c[v >> 2] | 0, c[t >> 2] | 0, (c[s >> 2] | 0) * 20 | 0)
}
c[s >> 2] = G;
c[t >> 2] = F;
I = c[r >> 2] | 0
} else
I = A;
c[r >> 2] = I + 1;
A = c[t >> 2] | 0;
c[A + (I * 20 | 0) >> 2] = y;
c[A + (I * 20 | 0) + 4 >> 2] = z;
c[A + (I * 20 | 0) + 8 >> 2] = c[x + (w * 24 | 0) + 20 >> 2];
if ((D | 0) == 0)
J = 1;
else
J = +g[D + 16 >> 2];
if ((E | 0) == 0)
K = 1;
else
K = +g[E + 16 >> 2];
g[A + (I * 20 | 0) + 12 >> 2] = J < K ? J : K;
F = c[u >> 2] | 0;
L = +g[F + (y << 3) >> 2] - +g[F +
(z << 3) >> 2];
M = +g[F + (y << 3) + 4 >> 2] - +g[F + (z << 3) + 4 >> 2];
g[A + (I * 20 | 0) + 16 >> 2] = +Q(+(L * L + M * M))
}
}
while (0);
w = w + 1 | 0
} while ((w | 0) < (c[n >> 2] | 0));
N = r
} else
N = a + 252 | 0;
r = a + 248 | 0;
n = c[r >> 2] | 0;
w = c[N >> 2] | 0;
I = n + (w * 20 | 0) | 0;
c[h >> 2] = 27;
u = w * 20 | 0;
w = (u | 0) / 20 | 0;
a:
do if ((u | 0) > 2560) {
t = w;
while (1) {
s = rn(t * 20 | 0, 9632) | 0;
if ((s | 0) != 0) {
O = s;
P = t;
break a
}
if ((t | 0) > 1)
t = (t | 0) / 2 | 0;
else {
O = s;
P = 0;
break
}
}
} else {
O = 0;
P = 0
}
while (0);
Pl(n, I, h, w, O, P);
if ((O | 0) != 0)
sn(O);
O = c[r >> 2] | 0;
P = c[N >> 2] | 0;
w = O + (P * 20 | 0) | 0;
b:
do if ((P | 0) == 0) {
R = O;
S = 40
} else if ((P | 0) == 1) {
T = w;
U = O
} else {
I =
O;
n = O + 20 | 0;
u = c[O >> 2] | 0;
while (1) {
t = u;
u = c[n >> 2] | 0;
if ((t | 0) == (u | 0) ? (c[I + 4 >> 2] | 0) == (c[I + 24 >> 2] | 0) : 0) {
R = I;
S = 40;
break b
}
t = n + 20 | 0;
if ((t | 0) == (w | 0)) {
T = w;
U = O;
break
} else {
s = n;
n = t;
I = s
}
}
}
while (0);
if ((S | 0) == 40)
if ((R | 0) == (w | 0)) {
T = w;
U = O
} else {
O = R;
P = R + 20 | 0;
c:
while (1) {
R = O + 4 | 0;
I = P;
do {
n = I;
I = I + 20 | 0;
if ((I | 0) == (w | 0))
break c;
if ((c[O >> 2] | 0) != (c[I >> 2] | 0))
break
} while ((c[R >> 2] | 0) == (c[n + 24 >> 2] | 0));
R = O + 20 | 0;
c[R + 0 >> 2] = c[I + 0 >> 2];
c[R + 4 >> 2] = c[I + 4 >> 2];
c[R + 8 >> 2] = c[I + 8 >> 2];
c[R + 12 >> 2] = c[I + 12 >> 2];
c[R + 16 >> 2] = c[I + 16 >> 2];
O = R;
P = I
}
T = O + 20 | 0;
U =
c[r >> 2] | 0
}
c[N >> 2] = (T - U | 0) / 20 | 0
}
if ((o & 16 | 0) == 0) {
i = f;
return
}
hk(j, (c[a + 400 >> 2] | 0) + 76 | 0, d - b | 0);
if (l) {
l = a + 88 | 0;
o = a + 144 | 0;
U = a + 96 | 0;
T = b;
do {
b = c[(c[l >> 2] | 0) + (T << 2) >> 2] | 0;
do if ((b & 2 | 0) == 0) {
N = c[(c[o >> 2] | 0) + (T << 2) >> 2] | 0;
if ((b & 28 | 0) == 0) {
if ((N | 0) == 0)
break;
if ((c[N + 12 >> 2] & 2 | 0) == 0)
break
}
N = c[U >> 2] | 0;
jk(j, N + (T << 3) | 0, T, nb[c[(c[e >> 2] | 0) + 8 >> 2] & 31](e, T) | 0)
}
while (0);
T = T + 1 | 0
} while ((T | 0) < (d | 0))
}
K = +g[a + 32 >> 2] * .75;
kk(j, K * .5, K * 2);
c[k >> 2] = 7176;
c[k + 4 >> 2] = a;
c[k + 8 >> 2] = e;
lk(j, k);
k = a + 264 | 0;
e = c[k >> 2] | 0;
d = a + 268 | 0;
a = c[d >> 2] | 0;
T = e + (a *
60 | 0) | 0;
c[h >> 2] = 28;
U = a * 60 | 0;
a = (U | 0) / 60 | 0;
d:
do if ((U | 0) > 7680) {
o = a;
while (1) {
l = rn(o * 60 | 0, 9632) | 0;
if ((l | 0) != 0) {
V = l;
W = o;
break d
}
if ((o | 0) > 1)
o = (o | 0) / 2 | 0;
else {
V = l;
W = 0;
break
}
}
} else {
V = 0;
W = 0
}
while (0);
Ll(e, T, h, a, V, W);
if ((V | 0) != 0)
sn(V);
V = c[k >> 2] | 0;
W = c[d >> 2] | 0;
a = V + (W * 60 | 0) | 0;
e:
do if ((W | 0) == 0) {
X = V;
S = 69
} else if ((W | 0) == 1) {
Y = a;
Z = V
} else {
h = V;
T = V + 60 | 0;
e = c[V >> 2] | 0;
while (1) {
U = e;
e = c[T >> 2] | 0;
if (((U | 0) == (e | 0) ? (c[h + 4 >> 2] | 0) == (c[h + 64 >> 2] | 0) : 0) ? (c[h + 8 >> 2] | 0) == (c[h + 68 >> 2] | 0) : 0) {
X = h;
S = 69;
break e
}
U = T + 60 | 0;
if ((U | 0) == (a | 0)) {
Y = a;
Z =
V;
break
} else {
o = T;
T = U;
h = o
}
}
}
while (0);
if ((S | 0) == 69)
if ((X | 0) == (a | 0)) {
Y = a;
Z = V
} else {
V = X;
S = X + 60 | 0;
f:
while (1) {
X = V + 4 | 0;
W = V + 8 | 0;
h = S;
do {
T = h;
h = h + 60 | 0;
if ((h | 0) == (a | 0))
break f;
if ((c[V >> 2] | 0) != (c[h >> 2] | 0))
break;
if ((c[X >> 2] | 0) != (c[T + 64 >> 2] | 0))
break
} while ((c[W >> 2] | 0) == (c[T + 68 >> 2] | 0));
W = V + 60 | 0;
X = W + 0 | 0;
T = h + 0 | 0;
e = X + 60 | 0;
do {
c[X >> 2] = c[T >> 2];
X = X + 4 | 0;
T = T + 4 | 0
} while ((X | 0) < (e | 0));
V = W;
S = h
}
Y = V + 60 | 0;
Z = c[k >> 2] | 0
}
c[d >> 2] = (Y - Z | 0) / 60 | 0;
ik(j);
i = f;
return
}
function Ik(b, d, e) {
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0;
f = i;
i = i + 16 | 0;
g = f;
h = b + 400 | 0;
if ((c[(c[h >> 2] | 0) + 102876 >> 2] & 2 | 0) != 0) {
i = f;
return
}
j = e + 4 | 0;
k = e + 8 | 0;
zk(b, c[j >> 2] | 0, c[k >> 2] | 0, c[b + 44 >> 2] | 0);
l = d + 4 | 0;
m = d + 8 | 0;
zk(b, c[l >> 2] | 0, c[m >> 2] | 0, c[j >> 2] | 0);
n = c[j >> 2] | 0;
c[g >> 2] = 7576;
c[g + 4 >> 2] = n;
Gk(b, 1);
Hk(b, c[l >> 2] | 0, c[k >> 2] | 0, g);
g = c[j >> 2] | 0;
l = c[k >> 2] | 0;
if ((g | 0) < (l | 0)) {
n = b + 144 | 0;
o = g;
do {
c[(c[n >> 2] | 0) + (o << 2) >> 2] = d;
o = o + 1 | 0
} while ((o | 0) < (l | 0))
}
l = d + 12 | 0;
d = c[l >> 2] | 0;
o = c[e + 12 >> 2] | d;
n = (o ^ d) << 4 & 16 | o;
if ((d & ~n | 0) != 0)
a[b + 20 >> 0] = 1;
d = b + 16 | 0;
g = c[d >> 2] | 0;
if ((n &
~g | 0) != 0) {
if ((o & 1 | 0) == 0)
p = g;
else {
o = b + 132 | 0;
q = c[o >> 2] | 0;
if ((q | 0) == 0) {
r = b + 48 | 0;
s = c[r >> 2] | 0;
if ((s | 0) == 0) {
vk(b, 256);
t = c[r >> 2] | 0
} else
t = s;
s = Em(c[h >> 2] | 0, t << 2) | 0;
xn(s | 0, 0, c[r >> 2] << 2 | 0) | 0;
u = s;
v = c[d >> 2] | 0
} else {
u = q;
v = g
}
c[o >> 2] = u;
p = v
}
c[d >> 2] = p | n
}
c[l >> 2] = n;
c[m >> 2] = c[k >> 2];
c[j >> 2] = c[k >> 2];
tk(b, e);
i = f;
return
}
function Jk(a) {
a = a | 0;
return
}
function Kk(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0;
d = i;
e = c[a >> 2] | 0;
f = c[b >> 2] | 0;
if ((e | 0) == (f | 0)) {
g = (c[a + 4 >> 2] | 0) < (c[b + 4 >> 2] | 0);
i = d;
return g | 0
} else {
g = (e - f | 0) < 0;
i = d;
return g | 0
}
return 0
}
function Lk(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0;
d = i;
e = c[a >> 2] | 0;
f = c[b >> 2] | 0;
if ((e | 0) != (f | 0)) {
g = (e - f | 0) < 0;
i = d;
return g | 0
}
f = c[a + 4 >> 2] | 0;
e = c[b + 4 >> 2] | 0;
if ((f | 0) == (e | 0)) {
g = (c[a + 8 >> 2] | 0) < (c[b + 8 >> 2] | 0);
i = d;
return g | 0
} else {
g = (f - e | 0) < 0;
i = d;
return g | 0
}
return 0
}
function Mk(b) {
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0;
d = i;
e = b + 400 | 0;
f = b + 220 | 0;
h = Ym((c[e >> 2] | 0) + 76 | 0, (c[f >> 2] | 0) * 24 | 0) | 0;
j = c[f >> 2] |
0;
if ((j | 0) > 0) {
k = b + 216 | 0;
l = b + 144 | 0;
m = j;
j = 0;
n = 0;
while (1) {
o = c[k >> 2] | 0;
p = o + (n * 24 | 0) | 0;
q = c[l >> 2] | 0;
r = c[q + (c[p >> 2] << 2) >> 2] | 0;
if (((r | 0) != 0 ? (r | 0) == (c[q + (c[o + (n * 24 | 0) + 4 >> 2] << 2) >> 2] | 0) : 0) ? (c[r + 12 >> 2] & 16 | 0) != 0 : 0) {
r = j + 1 | 0;
o = h + (j * 24 | 0) | 0;
c[o + 0 >> 2] = c[p + 0 >> 2];
c[o + 4 >> 2] = c[p + 4 >> 2];
c[o + 8 >> 2] = c[p + 8 >> 2];
c[o + 12 >> 2] = c[p + 12 >> 2];
c[o + 16 >> 2] = c[p + 16 >> 2];
c[o + 20 >> 2] = c[p + 20 >> 2];
s = c[f >> 2] | 0;
t = r
} else {
s = m;
t = j
}
n = n + 1 | 0;
if ((n | 0) >= (s | 0)) {
u = t;
break
} else {
m = s;
j = t
}
}
} else
u = 0;
t = Ym((c[e >> 2] | 0) + 76 | 0, c[b + 308 >> 2] << 2) | 0;
j = c[b + 312 >> 2] | 0;
if ((j |
0) == 0)
v = 0;
else {
s = b + 16 | 0;
m = b + 124 | 0;
n = b + 132 | 0;
f = b + 48 | 0;
l = b + 20 | 0;
k = j;
j = 0;
while (1) {
r = k + 12 | 0;
p = c[r >> 2] | 0;
if ((p & 16 | 0) != 0) {
o = j + 1 | 0;
c[t + (j << 2) >> 2] = k;
q = p & -17;
if ((((p | 16) ^ -17) & p | 0) != 0)
a[l >> 0] = 1;
w = c[s >> 2] | 0;
if ((q & ~w | 0) != 0) {
if ((p & 1 | 0) == 0)
x = w;
else {
p = c[n >> 2] | 0;
if ((p | 0) == 0) {
y = c[f >> 2] | 0;
if ((y | 0) == 0) {
vk(b, 256);
z = c[f >> 2] | 0
} else
z = y;
y = Em(c[e >> 2] | 0, z << 2) | 0;
xn(y | 0, 0, c[f >> 2] << 2 | 0) | 0;
A = y;
B = c[s >> 2] | 0
} else {
A = p;
B = w
}
c[n >> 2] = A;
x = B
}
c[s >> 2] = x | q
}
c[r >> 2] = q;
q = c[k + 4 >> 2] | 0;
r = c[k + 8 >> 2] | 0;
if ((q | 0) < (r | 0)) {
w = q + 1 | 0;
xn((c[m >> 2] | 0) + (q << 2) |
0, 0, ((r | 0) > (w | 0) ? r : w) - q << 2 | 0) | 0;
C = o
} else
C = o
} else
C = j;
k = c[k + 24 >> 2] | 0;
if ((k | 0) == 0) {
v = C;
break
} else
j = C
}
}
C = (u | 0) > 0;
if (C) {
j = c[b + 124 >> 2] | 0;
k = 0;
do {
m = c[h + (k * 24 | 0) + 4 >> 2] | 0;
D = +g[h + (k * 24 | 0) + 8 >> 2];
x = j + (c[h + (k * 24 | 0) >> 2] << 2) | 0;
g[x >> 2] = D + +g[x >> 2];
x = j + (m << 2) | 0;
g[x >> 2] = D + +g[x >> 2];
k = k + 1 | 0
} while ((k | 0) != (u | 0))
}
k = (v | 0) > 0;
if (k) {
j = b + 124 | 0;
x = b + 132 | 0;
m = 0;
do {
s = c[t + (m << 2) >> 2] | 0;
B = c[s + 4 >> 2] | 0;
A = c[s + 8 >> 2] | 0;
if ((B | 0) < (A | 0)) {
s = c[j >> 2] | 0;
n = c[x >> 2] | 0;
f = B;
do {
g[n + (f << 2) >> 2] = +g[s + (f << 2) >> 2] < .800000011920929 ? 0 : 3.4028234663852886E38;
f = f + 1 | 0
} while ((f | 0) < (A | 0))
}
m = m + 1 | 0
} while ((m | 0) != (v | 0))
}
m = ~~+Q(1+(c[b + 44 >> 2] | 0));
if ((m | 0) > 0 ? (x = b + 132 | 0, C) : 0) {
C = 0;
do {
j = c[x >> 2] | 0;
A = 0;
f = 0;
while (1) {
D = 1 - +g[h + (A * 24 | 0) + 8 >> 2];
s = j + (c[h + (A * 24 | 0) >> 2] << 2) | 0;
n = j + (c[h + (A * 24 | 0) + 4 >> 2] << 2) | 0;
E = +g[n >> 2];
F = D + E;
G = +g[s >> 2];
H = D + G;
if (G > F) {
g[s >> 2] = F;
I = +g[n >> 2];
J = 1
} else {
I = E;
J = f
}
if (I > H) {
g[n >> 2] = H;
K = 1
} else
K = J;
A = A + 1 | 0;
if ((A | 0) == (u | 0))
break;
else
f = K
}
C = C + 1 | 0
} while (K & (C | 0) < (m | 0))
}
if (!k) {
L = c[e >> 2] | 0;
M = L + 76 | 0;
_m(M, t);
N = c[e >> 2] | 0;
O = N + 76 | 0;
_m(O, h);
i = d;
return
}
k = b + 132 | 0;
m = b + 32 | 0;
b = 0;
do {
C = c[t + (b << 2) >> 2] | 0;
K = c[C + 4 >> 2] | 0;
u = c[C + 8 >> 2] | 0;
if ((K | 0) < (u | 0)) {
C = c[k >> 2] | 0;
J = K;
do {
K = C + (J << 2) | 0;
I = +g[K >> 2];
if (I < 3.4028234663852886E38)
P = I * +g[m >> 2];
else
P = 0;
g[K >> 2] = P;
J = J + 1 | 0
} while ((J | 0) < (u | 0))
}
b = b + 1 | 0
} while ((b | 0) != (v | 0));
L = c[e >> 2] | 0;
M = L + 76 | 0;
_m(M, t);
N = c[e >> 2] | 0;
O = N + 76 | 0;
_m(O, h);
i = d;
return
}
function Nk(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0;
e = i;
f = +g[b + 36 >> 2];
h = (~~(f * +g[d + 4 >> 2] + -1 + 2048) >>> 0 << 20) + (~~((f * +g[d >> 2] + -1) * 256 + 524288) >>> 0) | 0;
j = ~~(f * +g[d + 12 >> 2] + 1 + 2048) >>> 0;
k = ~~((f *
+g[d + 8 >> 2] + 1) * 256 + 524288) >>> 0;
d = c[b + 200 >> 2] | 0;
l = c[b + 204 >> 2] | 0;
b = d + (l << 3) | 0;
m = d;
d = l << 3 >> 3;
a:
while (1) {
l = d;
while (1) {
if ((l | 0) == 0)
break a;
n = (l | 0) / 2 | 0;
if ((c[m + (n << 3) + 4 >> 2] | 0) >>> 0 < h >>> 0)
break;
else
l = n
}
m = m + (n + 1 << 3) | 0;
d = l + -1 - n | 0
}
n = (j << 20) + k | 0;
k = m;
j = b - m >> 3;
b:
while (1) {
b = j;
while (1) {
if ((b | 0) == 0)
break b;
o = (b | 0) / 2 | 0;
if ((c[k + (o << 3) + 4 >> 2] | 0) >>> 0 > n >>> 0)
b = o;
else
break
}
k = k + (o + 1 << 3) | 0;
j = b + -1 - o | 0
}
c[a >> 2] = h & 1048575;
c[a + 4 >> 2] = n & 1048575;
c[a + 8 >> 2] = h & -1048576;
c[a + 12 >> 2] = n & -1048576;
c[a + 16 >> 2] = m;
c[a + 20 >> 2] = k;
i = e;
return
}
function Ok(a,
b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
d = i;
e = c[a + 200 >> 2] | 0;
f = c[a + 204 >> 2] | 0;
g = e + (f << 3) | 0;
c[b + 4 >> 2] = 0;
if ((f | 0) > 0) {
h = e;
j = e
} else {
i = d;
return
}
while (1) {
e = h + 4 | 0;
f = (c[e >> 2] | 0) + 256 | 0;
k = h;
h = h + 8 | 0;
l = h >>> 0 < g >>> 0;
a:
do if (l) {
m = h;
do {
if (f >>> 0 < (c[m + 4 >> 2] | 0) >>> 0)
break a;
Pk(a, c[k >> 2] | 0, c[m >> 2] | 0, b);
m = m + 8 | 0
} while (m >>> 0 < g >>> 0)
}
while (0);
f = c[e >> 2] | 0;
m = f + 1048320 | 0;
b:
do if (j >>> 0 < g >>> 0) {
n = j;
while (1) {
o = n + 8 | 0;
if (!(m >>> 0 > (c[n + 4 >> 2] | 0) >>> 0)) {
p = n;
break b
}
if (o >>> 0 < g >>> 0)
n = o;
else {
p = o;
break
}
}
} else
p = j;
while (0);
m = f + 1048832 | 0;
c:
do if (p >>> 0 < g >>> 0) {
e = p;
do {
if (m >>> 0 < (c[e + 4 >> 2] | 0) >>> 0)
break c;
Pk(a, c[k >> 2] | 0, c[e >> 2] | 0, b);
e = e + 8 | 0
} while (e >>> 0 < g >>> 0)
}
while (0);
if (!l)
break;
else
j = p
}
i = d;
return
}
function Pk(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0;
f = i;
h = c[a + 96 >> 2] | 0;
j = +g[h + (d << 3) >> 2] - +g[h + (b << 3) >> 2];
l = +g[h + (d << 3) + 4 >> 2] - +g[h + (b << 3) + 4 >> 2];
m = j * j + l * l;
if (!(m < +g[a + 40 >> 2])) {
i = f;
return
}
n = (c[k >> 2] = 1597463007 - ((g[k >> 2] = m, c[k >> 2] | 0) >> 1), +g[k >> 2]);
o = n * (1.5 - n * m * .5 * n);
h = e + 4 | 0;
p = c[h >>
2] | 0;
q = e + 8 | 0;
r = c[q >> 2] | 0;
if ((p | 0) >= (r | 0) ? (s = (r | 0) == 0 ? 256 : r << 1, (r | 0) < (s | 0)) : 0) {
r = e + 12 | 0;
t = Em(c[r >> 2] | 0, s * 24 | 0) | 0;
u = c[e >> 2] | 0;
if ((u | 0) != 0) {
An(t | 0, u | 0, (c[h >> 2] | 0) * 24 | 0) | 0;
Fm(c[r >> 2] | 0, c[e >> 2] | 0, (c[q >> 2] | 0) * 24 | 0)
}
c[q >> 2] = s;
c[e >> 2] = t;
v = c[h >> 2] | 0
} else
v = p;
c[h >> 2] = v + 1;
h = c[e >> 2] | 0;
c[h + (v * 24 | 0) >> 2] = b;
c[h + (v * 24 | 0) + 4 >> 2] = d;
e = c[a + 88 >> 2] | 0;
c[h + (v * 24 | 0) + 20 >> 2] = c[e + (d << 2) >> 2] | c[e + (b << 2) >> 2];
g[h + (v * 24 | 0) + 8 >> 2] = 1 - m * o * +g[a + 36 >> 2];
m = +(j * o);
j = +(l * o);
a = h + (v * 24 | 0) + 12 | 0;
g[a >> 2] = m;
g[a + 4 >> 2] = j;
i = f;
return
}
function Qk(a, b) {
a =
a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0;
d = i;
if ((c[a + 8 >> 2] & 131072 | 0) == 0) {
i = d;
return
}
e = c[(c[a + 400 >> 2] | 0) + 102948 >> 2] | 0;
if ((e | 0) == 0) {
i = d;
return
}
f = c[b >> 2] | 0;
g = b + 4 | 0;
h = c[g >> 2] | 0;
j = f + (h * 24 | 0) | 0;
a:
do if ((h | 0) == 0) {
k = f;
l = 8
} else {
m = f;
while (1) {
if ((c[m + 20 >> 2] & 131072 | 0) != 0 ? !(lb[c[(c[e >> 2] | 0) + 16 >> 2] & 7](e, a, c[m >> 2] | 0, c[m + 4 >> 2] | 0) | 0) : 0) {
k = m;
l = 8;
break a
}
m = m + 24 | 0;
if ((m | 0) == (j | 0)) {
n = j;
break
}
}
}
while (0);
b:
do if ((l | 0) == 8)
if ((k | 0) == (j | 0))
n = j;
else {
f = k;
h = k;
while (1) {
m = h;
do {
o = m;
m = m + 24 | 0;
if ((m | 0) == (j | 0)) {
n = f;
break b
}
if ((c[o + 44 >> 2] & 131072 | 0) == 0)
break
} while (!(lb[c[(c[e >> 2] | 0) + 16 >> 2] & 7](e, a, c[m >> 2] | 0, c[o + 28 >> 2] | 0) | 0));
c[f + 0 >> 2] = c[m + 0 >> 2];
c[f + 4 >> 2] = c[m + 4 >> 2];
c[f + 8 >> 2] = c[m + 8 >> 2];
c[f + 12 >> 2] = c[m + 12 >> 2];
c[f + 16 >> 2] = c[m + 16 >> 2];
c[f + 20 >> 2] = c[m + 20 >> 2];
f = f + 24 | 0;
h = m
}
}
while (0);
c[g >> 2] = (n - (c[b >> 2] | 0) | 0) / 24 | 0;
i = d;
return
}
function Rk(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
f = i;
i = i + 16 | 0;
g = f;
h = c[a >> 2] | 0;
if ((h | 0) != 0) {
_m(c[a + 12 >> 2] | 0, h);
c[a >> 2] = 0;
c[a + 8 >> 2] = 0
}
if ((d | 0) == 0)
j = c[a + 8 >> 2] | 0;
else {
h =
Ym(c[a + 12 >> 2] | 0, d * 9 | 0) | 0;
c[a >> 2] = h;
k = h + (d << 3) | 0;
c[a + 4 >> 2] = k;
xn(k | 0, 1, d | 0) | 0;
c[a + 8 >> 2] = d;
j = d
}
if ((j | 0) == 0) {
i = f;
return
}
j = c[a >> 2] | 0;
if ((d | 0) > 0) {
k = 0;
h = 0;
while (1) {
l = c[b + (k * 24 | 0) >> 2] | 0;
if ((!((l | 0) == -1) ? (m = b + (k * 24 | 0) + 4 | 0, n = c[m >> 2] | 0, !((n | 0) == -1)) : 0) ? ((c[e + (n << 2) >> 2] | c[e + (l << 2) >> 2]) & 32768 | 0) != 0 : 0) {
c[j + (k << 3) >> 2] = l;
c[j + (k << 3) + 4 >> 2] = c[m >> 2];
o = h + 1 | 0
} else
o = h;
k = k + 1 | 0;
if ((k | 0) == (d | 0)) {
p = o;
break
} else
h = o
}
} else
p = 0;
c[a + 8 >> 2] = p;
c[g >> 2] = 29;
Cl(j, j + (p << 3) | 0, g);
i = f;
return
}
function Sk(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0;
e = i;
if ((c[b + 8 >> 2] & 32768 | 0) == 0) {
i = e;
return
}
f = c[(c[b + 400 >> 2] | 0) + 102952 >> 2] | 0;
if ((f | 0) == 0) {
i = e;
return
}
g = c[b + 220 >> 2] | 0;
h = c[b + 216 >> 2] | 0;
j = h + (g * 24 | 0) | 0;
k = d + 8 | 0;
if ((g | 0) > 0) {
g = d + 4 | 0;
l = h;
while (1) {
h = c[l >> 2] | 0;
m = c[l + 4 >> 2] | 0;
n = c[k >> 2] | 0;
do if ((n | 0) == 0)
o = 24;
else {
p = c[d >> 2] | 0;
q = p;
r = p + (n << 3) - q >> 3;
s = (r | 0) == 0;
a:
do if (s)
t = p;
else {
u = p;
v = r;
while (1) {
w = v;
while (1) {
x = (w | 0) / 2 | 0;
if ((c[u + (x << 3) >> 2] | 0) < (h | 0) ? (c[u + (x << 3) + 4 >> 2] | 0) < (m |
0) : 0)
break;
if ((w + 1 | 0) >>> 0 < 3) {
t = u;
break a
} else
w = x
}
y = u + (x + 1 << 3) | 0;
z = w + -1 | 0;
if ((z | 0) == (x | 0)) {
t = y;
break
} else {
u = y;
v = z - x | 0
}
}
}
while (0);
if ((t | 0) != 0 ? (v = (t - q | 0) >>> 3, u = c[g >> 2] | 0, (a[u + v >> 0] | 0) != 0) : 0) {
A = u;
B = v
} else {
b:
do if (s)
C = p;
else {
v = p;
u = r;
while (1) {
z = u;
while (1) {
D = (z | 0) / 2 | 0;
if ((c[v + (D << 3) >> 2] | 0) < (m | 0) ? (c[v + (D << 3) + 4 >> 2] | 0) < (h | 0) : 0)
break;
if ((z + 1 | 0) >>> 0 < 3) {
C = v;
break b
} else
z = D
}
w = v + (D + 1 << 3) | 0;
y = z + -1 | 0;
if ((y | 0) == (D | 0)) {
C = w;
break
} else {
v = w;
u = y - D | 0
}
}
}
while (0);
if ((C | 0) == 0) {
o = 24;
break
}
r = (C - q | 0) >>> 3;
p = c[g >> 2] | 0;
if ((a[p +
r >> 0] | 0) == 0) {
o = 24;
break
} else {
A = p;
B = r
}
}
a[A + B >> 0] = 0
}
while (0);
if ((o | 0) == 24) {
o = 0;
ib[c[(c[f >> 2] | 0) + 24 >> 2] & 7](f, b, l)
}
l = l + 24 | 0;
if (!(l >>> 0 < j >>> 0)) {
E = d;
F = g;
break
}
}
} else {
E = d;
F = d + 4 | 0
}
d = c[k >> 2] | 0;
k = c[E >> 2] | 0;
E = c[F >> 2] | 0;
if ((d | 0) <= 0) {
i = e;
return
}
F = 0;
do {
if ((a[E + F >> 0] | 0) != 0)
pb[c[(c[f >> 2] | 0) + 28 >> 2] & 31](f, b, c[k + (F << 3) >> 2] | 0, c[k + (F << 3) + 4 >> 2] | 0);
F = F + 1 | 0
} while ((F | 0) != (d | 0));
i = e;
return
}
function Tk(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0;
d = i;
e = a + 156 | 0;
if ((c[e >> 2] | 0) < 1) {
i = d;
return
}
f = (c[a + 176 >> 2] |
0) + (b << 2) | 0;
g = (c[a + 160 >> 2] | 0) + (b << 2) | 0;
h = (c[a + 168 >> 2] | 0) + (b << 2) | 0;
j = (c[h >> 2] | 0) + 1 | 0;
c[h >> 2] = j;
if ((j | 0) == 2 ? (j = c[f >> 2] | 0, c[f >> 2] = j + 1, (j | 0) >= (c[e >> 2] | 0)) : 0) {
e = a + 184 | 0;
j = a + 188 | 0;
f = c[j >> 2] | 0;
h = a + 192 | 0;
k = c[h >> 2] | 0;
if ((f | 0) >= (k | 0) ? (l = (k | 0) == 0 ? 256 : k << 1, (k | 0) < (l | 0)) : 0) {
k = a + 196 | 0;
m = Em(c[k >> 2] | 0, l << 2) | 0;
n = c[e >> 2] | 0;
if ((n | 0) != 0) {
An(m | 0, n | 0, c[j >> 2] << 2 | 0) | 0;
Fm(c[k >> 2] | 0, c[e >> 2] | 0, c[h >> 2] << 2)
}
c[h >> 2] = l;
c[e >> 2] = m;
o = c[j >> 2] | 0
} else
o = f;
c[j >> 2] = o + 1;
c[(c[e >> 2] | 0) + (o << 2) >> 2] = b
}
c[g >> 2] = c[a + 4 >> 2];
i = d;
return
}
function Uk(a,
b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0;
f = i;
i = i + 16 | 0;
g = f;
h = c[a >> 2] | 0;
if ((h | 0) != 0) {
_m(c[a + 12 >> 2] | 0, h);
c[a >> 2] = 0;
c[a + 8 >> 2] = 0
}
if ((d | 0) == 0)
j = c[a + 8 >> 2] | 0;
else {
h = Ym(c[a + 12 >> 2] | 0, d * 9 | 0) | 0;
c[a >> 2] = h;
k = h + (d << 3) | 0;
c[a + 4 >> 2] = k;
xn(k | 0, 1, d | 0) | 0;
c[a + 8 >> 2] = d;
j = d
}
if ((j | 0) == 0) {
i = f;
return
}
j = c[a >> 2] | 0;
if ((d | 0) > 0) {
k = 0;
h = 0;
while (1) {
l = c[b + (k * 28 | 0) >> 2] | 0;
if (!((l | 0) == -1) ? (c[e + (l << 2) >> 2] & 16384 | 0) != 0 : 0) {
c[j + (k << 3) >> 2] = c[b + (k * 28 | 0) + 8 >> 2];
c[j + (k << 3) + 4 >> 2] = l;
m = h + 1 | 0
} else
m = h;
k = k + 1 | 0;
if ((k | 0) == (d | 0)) {
n =
m;
break
} else
h = m
}
} else
n = 0;
c[a + 8 >> 2] = n;
c[g >> 2] = 30;
Fl(j, j + (n << 3) | 0, g);
i = f;
return
}
function Vk(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0;
d = i;
if (!((c[a >> 2] | 0) >>> 0 < (c[b >> 2] | 0) >>> 0)) {
e = 0;
i = d;
return e | 0
}
e = (c[a + 4 >> 2] | 0) < (c[b + 4 >> 2] | 0);
i = d;
return e | 0
}
function Wk(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0;
d = i;
if ((c[a >> 2] | 0) >= (c[b >> 2] | 0)) {
e = 0;
i = d;
return e | 0
}
e = (c[a + 4 >> 2] | 0) < (c[b + 4 >> 2] | 0);
i = d;
return e | 0
}
function Xk(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0;
e = i;
if ((c[b +
8 >> 2] & 16384 | 0) == 0) {
i = e;
return
}
f = c[(c[b + 400 >> 2] | 0) + 102952 >> 2] | 0;
if ((f | 0) == 0) {
i = e;
return
}
g = b + 232 | 0;
h = b + 236 | 0;
if ((c[h >> 2] | 0) == 0) {
j = d;
k = d + 8 | 0;
l = d + 4 | 0
} else {
m = d + 8 | 0;
n = d + 4 | 0;
o = c[g >> 2] | 0;
while (1) {
p = c[o + 8 >> 2] | 0;
q = c[o >> 2] | 0;
r = c[m >> 2] | 0;
if ((r | 0) != 0) {
s = c[d >> 2] | 0;
t = s;
u = s + (r << 3) - t >> 3;
a:
do if ((u | 0) == 0)
v = s;
else {
r = s;
w = u;
while (1) {
x = w;
while (1) {
y = (x | 0) / 2 | 0;
if ((c[r + (y << 3) >> 2] | 0) >>> 0 < p >>> 0 ? (c[r + (y << 3) + 4 >> 2] | 0) < (q | 0) : 0)
break;
if ((x + 1 | 0) >>> 0 < 3) {
v = r;
break a
} else
x = y
}
z = r + (y + 1 << 3) | 0;
A = x + -1 | 0;
if ((A | 0) == (y | 0)) {
v = z;
break
} else {
r =
z;
w = A - y | 0
}
}
}
while (0);
if ((v | 0) != 0 ? (q = (c[n >> 2] | 0) + ((v - t | 0) >>> 3) | 0, (a[q >> 0] | 0) != 0) : 0)
a[q >> 0] = 0;
else
B = 16
} else
B = 16;
if ((B | 0) == 16) {
B = 0;
ib[c[(c[f >> 2] | 0) + 16 >> 2] & 7](f, b, o)
}
o = o + 28 | 0;
if ((o | 0) == ((c[g >> 2] | 0) + ((c[h >> 2] | 0) * 28 | 0) | 0)) {
j = d;
k = m;
l = n;
break
}
}
}
n = c[j >> 2] | 0;
j = c[l >> 2] | 0;
l = c[k >> 2] | 0;
if ((l | 0) <= 0) {
i = e;
return
}
k = 0;
do {
if ((a[j + k >> 0] | 0) != 0)
pb[c[(c[f >> 2] | 0) + 20 >> 2] & 31](f, c[n + (k << 3) >> 2] | 0, b, c[n + (k << 3) + 4 >> 2] | 0);
k = k + 1 | 0
} while ((k | 0) != (l | 0));
i = e;
return
}
function Yk(b) {
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p =
0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0;
d = i;
i = i + 48 | 0;
e = d + 32 | 0;
f = d + 16 | 0;
h = d;
j = b + 400 | 0;
k = c[j >> 2] | 0;
c[e >> 2] = 0;
c[e + 4 >> 2] = 0;
l = e + 8 | 0;
c[l >> 2] = 0;
m = e + 12 | 0;
c[m >> 2] = k + 76;
n = b + 8 | 0;
if ((c[n >> 2] & 16384 | 0) != 0 ? (c[k + 102952 >> 2] | 0) != 0 : 0)
Uk(e, c[b + 232 >> 2] | 0, c[b + 236 >> 2] | 0, c[b + 88 >> 2] | 0);
if ((c[b + 156 >> 2] | 0) > 0 ? (k = c[b + 44 >> 2] | 0, (k | 0) > 0) : 0) {
o = c[b + 168 >> 2] | 0;
p = b + 4 | 0;
q = c[b + 160 >> 2] | 0;
r = b + 176 | 0;
s = 0;
do {
c[o + (s << 2) >> 2] = 0;
if ((c[p >> 2] | 0) > ((c[q + (s << 2) >> 2] | 0) + 1 | 0))
c[(c[r >> 2] | 0) + (s << 2) >> 2] = 0;
s = s + 1 | 0
} while ((s |
0) != (k | 0))
}
c[b + 236 >> 2] = 0;
c[b + 188 >> 2] = 0;
if ((c[n >> 2] & 65536 | 0) == 0)
t = 0;
else
t = c[(c[j >> 2] | 0) + 102948 >> 2] | 0;
c[f + 4 >> 2] = b;
c[f >> 2] = 7056;
c[f + 8 >> 2] = t;
t = c[b + 44 >> 2] | 0;
g[h >> 2] = 3.4028234663852886E38;
n = h + 4 | 0;
g[n >> 2] = 3.4028234663852886E38;
k = h + 8 | 0;
g[k >> 2] = -3.4028234663852886E38;
s = h + 12 | 0;
g[s >> 2] = -3.4028234663852886E38;
if ((t | 0) > 0) {
r = c[b + 96 >> 2] | 0;
u = 3.4028234663852886E38;
v = 3.4028234663852886E38;
w = -3.4028234663852886E38;
x = -3.4028234663852886E38;
q = 0;
while (1) {
p = r + (q << 3) | 0;
y = +g[p >> 2];
z = +g[p + 4 >> 2];
A = u < y ? u : y;
B = v < z ? v : z;
C = +A;
D =
+B;
p = h;
g[p >> 2] = C;
g[p + 4 >> 2] = D;
D = w > y ? w : y;
y = x > z ? x : z;
z = +D;
C = +y;
p = k;
g[p >> 2] = z;
g[p + 4 >> 2] = C;
q = q + 1 | 0;
if ((q | 0) == (t | 0)) {
E = y;
F = A;
G = B;
H = D;
break
} else {
u = A;
v = B;
w = D;
x = y
}
}
} else {
E = -3.4028234663852886E38;
F = 3.4028234663852886E38;
G = 3.4028234663852886E38;
H = -3.4028234663852886E38
}
x = +g[b + 32 >> 2];
g[h >> 2] = F - x;
g[n >> 2] = G - x;
g[k >> 2] = H + x;
g[s >> 2] = E + x;
Dj(c[j >> 2] | 0, f, h);
if ((a[b + 316 >> 0] | 0) != 0)
Zk(b);
Xk(b, e);
b = c[e >> 2] | 0;
if ((b | 0) == 0) {
i = d;
return
}
_m(c[m >> 2] | 0, b);
c[e >> 2] = 0;
c[l >> 2] = 0;
i = d;
return
}
function Zk(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0;
b = i;
i = i + 32 | 0;
d = b + 20 | 0;
e = b;
f = b + 16 | 0;
g = a + 232 | 0;
h = c[g >> 2] | 0;
j = a + 236 | 0;
k = h + ((c[j >> 2] | 0) * 28 | 0) | 0;
c[d >> 2] = 31;
yl(h, k, d);
c[f >> 2] = 0;
d = c[g >> 2] | 0;
g = c[j >> 2] | 0;
k = d + (g * 28 | 0) | 0;
c[e >> 2] = a;
c[e + 4 >> 2] = -1;
c[e + 8 >> 2] = 0;
c[e + 12 >> 2] = f;
a:
do if ((g | 0) == 0)
l = d;
else {
a = d;
do {
if (xl(e, a) | 0) {
l = a;
break a
}
a = a + 28 | 0
} while ((a | 0) != (k | 0));
m = c[j >> 2] | 0;
n = c[f >> 2] | 0;
o = m - n | 0;
c[j >> 2] = o;
i = b;
return
}
while (0);
if ((l | 0) == (k | 0)) {
m = c[j >> 2] | 0;
n = c[f >> 2] | 0;
o = m - n | 0;
c[j >> 2] = o;
i = b;
return
} else {
p = l;
q = l
}
b:
while (1) {
l = q;
do {
l = l +
28 | 0;
if ((l | 0) == (k | 0))
break b
} while (xl(e, l) | 0);
c[p + 0 >> 2] = c[l + 0 >> 2];
c[p + 4 >> 2] = c[l + 4 >> 2];
c[p + 8 >> 2] = c[l + 8 >> 2];
c[p + 12 >> 2] = c[l + 12 >> 2];
c[p + 16 >> 2] = c[l + 16 >> 2];
c[p + 20 >> 2] = c[l + 20 >> 2];
c[p + 24 >> 2] = c[l + 24 >> 2];
p = p + 28 | 0;
q = l
}
m = c[j >> 2] | 0;
n = c[f >> 2] | 0;
o = m - n | 0;
c[j >> 2] = o;
i = b;
return
}
function _k(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0;
d = i;
e = c[a >> 2] | 0;
f = c[b >> 2] | 0;
if ((e | 0) == (f | 0)) {
h = +g[a + 12 >> 2] > +g[b + 12 >> 2];
i = d;
return h | 0
} else {
h = (e | 0) < (f | 0);
i = d;
return h | 0
}
return 0
}
function Jf(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0;
d = i;
vh(a, b);
c[a >>
2] = 1056;
e = b + 20 | 0;
f = c[e + 4 >> 2] | 0;
h = a + 68 | 0;
c[h >> 2] = c[e >> 2];
c[h + 4 >> 2] = f;
g[a + 76 >> 2] = +g[b + 28 >> 2];
g[a + 80 >> 2] = 0;
g[a + 84 >> 2] = 0;
g[a + 88 >> 2] = 0;
g[a + 92 >> 2] = +g[b + 32 >> 2];
g[a + 96 >> 2] = +g[b + 36 >> 2];
g[a + 100 >> 2] = +g[b + 40 >> 2];
i = d;
return
}
function Kf(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa =
0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0,
ya = 0,
za = 0,
Aa = 0,
Ba = 0,
Ca = 0,
Da = 0,
Ea = 0;
e = i;
f = c[b + 48 >> 2] | 0;
h = c[f + 8 >> 2] | 0;
j = b + 104 | 0;
c[j >> 2] = h;
l = c[b + 52 >> 2] | 0;
m = c[l + 8 >> 2] | 0;
n = b + 108 | 0;
c[n >> 2] = m;
o = f + 44 | 0;
p = c[o >> 2] | 0;
q = c[o + 4 >> 2] | 0;
o = b + 128 | 0;
c[o >> 2] = p;
c[o + 4 >> 2] = q;
o = l + 44 | 0;
r = c[o >> 2] | 0;
s = c[o + 4 >> 2] | 0;
o = b + 136 | 0;
c[o >> 2] = r;
c[o + 4 >> 2] = s;
o = b + 156 | 0;
g[o >> 2] = +g[f + 136 >> 2];
t = b + 160 | 0;
g[t >> 2] = +g[l + 136 >> 2];
u = b + 164 | 0;
g[u >> 2] = +g[f + 144 >> 2];
f = b + 168 | 0;
g[f >> 2] = +g[l + 144 >> 2];
l = c[d + 28 >> 2] | 0;
v = l + (h * 12 | 0) | 0;
w = +g[v >> 2];
x = +g[v + 4 >> 2];
y = +g[l + (h *
12 | 0) + 8 >> 2];
v = d + 32 | 0;
z = c[v >> 2] | 0;
A = z + (h * 12 | 0) | 0;
B = +g[A >> 2];
C = +g[A + 4 >> 2];
D = +g[z + (h * 12 | 0) + 8 >> 2];
h = l + (m * 12 | 0) | 0;
E = +g[h >> 2];
F = +g[h + 4 >> 2];
G = +g[l + (m * 12 | 0) + 8 >> 2];
l = z + (m * 12 | 0) | 0;
H = +g[l >> 2];
I = +g[l + 4 >> 2];
J = +g[z + (m * 12 | 0) + 8 >> 2];
K = +T(+y);
L = +S(+y);
M = +T(+G);
N = +S(+G);
O = -(c[k >> 2] = p, +g[k >> 2]);
P = -(c[k >> 2] = q, +g[k >> 2]);
Q = L * O - K * P;
R = K * O + L * P;
P = +Q;
O = +R;
q = b + 112 | 0;
g[q >> 2] = P;
g[q + 4 >> 2] = O;
O = -(c[k >> 2] = r, +g[k >> 2]);
P = -(c[k >> 2] = s, +g[k >> 2]);
U = N * O - M * P;
V = M * O + N * P;
P = +U;
N = +V;
s = b + 120 | 0;
g[s >> 2] = P;
g[s + 4 >> 2] = N;
N = +g[o >> 2];
P = +g[t >> 2];
O = +g[u >>
2];
M = +g[f >> 2];
W = N + P;
X = W + R * O * R + V * M * V;
Y = O * Q;
Z = M * U;
_ = -(R * Y) - V * Z;
$ = W + Q * Y + U * Z;
Z = X * $ - _ * _;
if (Z != 0)
aa = 1 / Z;
else
aa = Z;
Z = -(_ * aa);
g[b + 172 >> 2] = $ * aa;
g[b + 176 >> 2] = Z;
g[b + 180 >> 2] = Z;
g[b + 184 >> 2] = X * aa;
aa = O + M;
if (aa > 0)
ba = 1 / aa;
else
ba = aa;
g[b + 188 >> 2] = ba;
ba = +g[b + 68 >> 2];
aa = +g[b + 72 >> 2];
X = +(E + U - w - Q - (L * ba - K * aa));
w = +(F + V - x - R - (K * ba + L * aa));
f = b + 144 | 0;
g[f >> 2] = X;
g[f + 4 >> 2] = w;
g[b + 152 >> 2] = G - y - +g[b + 76 >> 2];
f = b + 80 | 0;
if ((a[d + 24 >> 0] | 0) == 0) {
g[f >> 2] = 0;
g[b + 84 >> 2] = 0;
g[b + 88 >> 2] = 0;
ca = B;
da = C;
ea = H;
fa = I;
ga = D;
ha = J;
ia = c[j >> 2] | 0;
ja = c[v >> 2] | 0;
ka = ja + (ia *
12 | 0) | 0;
la = +ca;
ma = +da;
na = ka;
oa = na;
g[oa >> 2] = la;
pa = na + 4 | 0;
qa = pa;
g[qa >> 2] = ma;
ra = c[j >> 2] | 0;
sa = c[v >> 2] | 0;
ta = sa + (ra * 12 | 0) + 8 | 0;
g[ta >> 2] = ga;
ua = c[n >> 2] | 0;
va = sa + (ua * 12 | 0) | 0;
wa = +ea;
xa = +fa;
ya = va;
za = ya;
g[za >> 2] = wa;
Aa = ya + 4 | 0;
Ba = Aa;
g[Ba >> 2] = xa;
Ca = c[n >> 2] | 0;
Da = c[v >> 2] | 0;
Ea = Da + (Ca * 12 | 0) + 8 | 0;
g[Ea >> 2] = ha;
i = e;
return
} else {
u = d + 8 | 0;
y = +g[u >> 2];
G = y * +g[f >> 2];
g[f >> 2] = G;
f = b + 84 | 0;
w = y * +g[f >> 2];
g[f >> 2] = w;
f = b + 88 | 0;
y = +g[u >> 2] * +g[f >> 2];
g[f >> 2] = y;
ca = B - N * G;
da = C - N * w;
ea = H + P * G;
fa = I + P * w;
ga = D - O * (y + (w * Q - G * R));
ha = J + M * (y + (w * U - G * V));
ia = c[j >>
2] | 0;
ja = c[v >> 2] | 0;
ka = ja + (ia * 12 | 0) | 0;
la = +ca;
ma = +da;
na = ka;
oa = na;
g[oa >> 2] = la;
pa = na + 4 | 0;
qa = pa;
g[qa >> 2] = ma;
ra = c[j >> 2] | 0;
sa = c[v >> 2] | 0;
ta = sa + (ra * 12 | 0) + 8 | 0;
g[ta >> 2] = ga;
ua = c[n >> 2] | 0;
va = sa + (ua * 12 | 0) | 0;
wa = +ea;
xa = +fa;
ya = va;
za = ya;
g[za >> 2] = wa;
Aa = ya + 4 | 0;
Ba = Aa;
g[Ba >> 2] = xa;
Ca = c[n >> 2] | 0;
Da = c[v >> 2] | 0;
Ea = Da + (Ca * 12 | 0) + 8 | 0;
g[Ea >> 2] = ha;
i = e;
return
}
}
function Lf(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0;
d = i;
e = a + 104 |
0;
f = c[e >> 2] | 0;
h = b + 32 | 0;
j = c[h >> 2] | 0;
k = j + (f * 12 | 0) | 0;
l = +g[k >> 2];
m = +g[k + 4 >> 2];
n = +g[j + (f * 12 | 0) + 8 >> 2];
f = a + 108 | 0;
k = c[f >> 2] | 0;
o = j + (k * 12 | 0) | 0;
p = +g[o >> 2];
q = +g[o + 4 >> 2];
r = +g[j + (k * 12 | 0) + 8 >> 2];
s = +g[a + 156 >> 2];
t = +g[a + 160 >> 2];
u = +g[a + 164 >> 2];
v = +g[a + 168 >> 2];
w = +g[b >> 2];
x = +g[b + 4 >> 2] * +g[a + 100 >> 2];
b = a + 88 | 0;
y = +g[b >> 2];
z = w * +g[a + 96 >> 2];
A = y - +g[a + 188 >> 2] * (r - n + x * +g[a + 152 >> 2]);
B = -z;
C = A < z ? A : z;
z = C < B ? B : C;
g[b >> 2] = z;
C = z - y;
y = n - u * C;
n = r + v * C;
C = +g[a + 124 >> 2];
r = +g[a + 120 >> 2];
z = +g[a + 116 >> 2];
B = +g[a + 112 >> 2];
A = +g[a + 144 >> 2] * x + (z * y + (p - C * n - l));
D =
x * +g[a + 148 >> 2] + (q + r * n - m - B * y);
x = +g[a + 176 >> 2] * A + +g[a + 184 >> 2] * D;
b = a + 80 | 0;
k = b;
E = +g[k >> 2];
F = +g[k + 4 >> 2];
G = E - (+g[a + 172 >> 2] * A + +g[a + 180 >> 2] * D);
g[b >> 2] = G;
k = a + 84 | 0;
D = +g[k >> 2] - x;
g[k >> 2] = D;
x = w * +g[a + 92 >> 2];
w = G * G + D * D;
if (w > x * x) {
A = +Q(+w);
if (A < 1.1920928955078125E-7) {
H = G;
I = D
} else {
w = 1 / A;
A = G * w;
g[b >> 2] = A;
J = D * w;
g[k >> 2] = J;
H = A;
I = J
}
J = x * H;
g[b >> 2] = J;
H = x * I;
g[k >> 2] = H;
K = J;
L = H
} else {
K = G;
L = D
}
D = K - E;
E = L - F;
F = +(l - s * D);
l = +(m - s * E);
k = (c[h >> 2] | 0) + ((c[e >> 2] | 0) * 12 | 0) | 0;
g[k >> 2] = F;
g[k + 4 >> 2] = l;
k = c[h >> 2] | 0;
g[k + ((c[e >> 2] | 0) * 12 | 0) + 8 >> 2] = y - u * (B *
E - D * z);
z = +(p + t * D);
p = +(q + t * E);
e = k + ((c[f >> 2] | 0) * 12 | 0) | 0;
g[e >> 2] = z;
g[e + 4 >> 2] = p;
g[(c[h >> 2] | 0) + ((c[f >> 2] | 0) * 12 | 0) + 8 >> 2] = n + v * (E * r - D * C);
i = d;
return
}
function Mf(a, b) {
a = a | 0;
b = b | 0;
return 1
}
function Nf(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0;
d = (c[b + 48 >> 2] | 0) + 12 | 0;
b = c[d + 4 >> 2] | 0;
e = a;
c[e >> 2] = c[d >> 2];
c[e + 4 >> 2] = b;
return
}
function Of(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0;
d = (c[b + 52 >> 2] | 0) + 12 | 0;
b = c[d + 4 >> 2] | 0;
e = a;
c[e >> 2] = c[d >> 2];
c[e + 4 >> 2] = b;
return
}
function Pf(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
var d = 0;
d = +g[b + 84 >> 2] * c;
g[a >> 2] = +g[b + 80 >> 2] * c;
g[a + 4 >> 2] =
d;
return
}
function Qf(a, b) {
a = a | 0;
b = +b;
return +(+g[a + 88 >> 2] * b)
}
function Rf(a, d) {
a = a | 0;
d = d | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0;
f = i;
h = a + 68 | 0;
if (!(+g[d >> 2] != +g[h >> 2]) ? !(+g[d + 4 >> 2] != +g[a + 72 >> 2]) : 0) {
i = f;
return
}
j = c[a + 48 >> 2] | 0;
k = j + 4 | 0;
l = e[k >> 1] | 0;
if ((l & 2 | 0) == 0) {
b[k >> 1] = l | 2;
g[j + 160 >> 2] = 0
}
j = c[a + 52 >> 2] | 0;
a = j + 4 | 0;
l = e[a >> 1] | 0;
if ((l & 2 | 0) == 0) {
b[a >> 1] = l | 2;
g[j + 160 >> 2] = 0
}
j = d;
d = c[j + 4 >> 2] | 0;
l = h;
c[l >> 2] = c[j >> 2];
c[l + 4 >> 2] = d;
i = f;
return
}
function Sf(a, d) {
a = a | 0;
d = +d;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0;
f = i;
h = a + 76 | 0;
if (!(+g[h >> 2] != d)) {
i = f;
return
}
j =
c[a + 48 >> 2] | 0;
k = j + 4 | 0;
l = e[k >> 1] | 0;
if ((l & 2 | 0) == 0) {
b[k >> 1] = l | 2;
g[j + 160 >> 2] = 0
}
j = c[a + 52 >> 2] | 0;
a = j + 4 | 0;
l = e[a >> 1] | 0;
if ((l & 2 | 0) == 0) {
b[a >> 1] = l | 2;
g[j + 160 >> 2] = 0
}
g[h >> 2] = d;
i = f;
return
}
function Tf(a) {
a = a | 0;
var b = 0,
e = 0,
f = 0,
j = 0,
l = 0;
b = i;
i = i + 16 | 0;
e = b;
f = c[(c[a + 48 >> 2] | 0) + 8 >> 2] | 0;
j = c[(c[a + 52 >> 2] | 0) + 8 >> 2] | 0;
Rm(1104, e);
c[e >> 2] = f;
Rm(1128, e);
c[e >> 2] = j;
Rm(1160, e);
c[e >> 2] = d[a + 61 >> 0] | 0;
Rm(1192, e);
l = +g[a + 72 >> 2];
h[k >> 3] = +g[a + 68 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(1232,
e);
h[k >> 3] = +g[a + 76 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(1280, e);
h[k >> 3] = +g[a + 92 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(1312, e);
h[k >> 3] = +g[a + 96 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(1344, e);
h[k >> 3] = +g[a + 100 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(1376, e);
c[e >> 2] = c[a + 56 >> 2];
Rm(1416, e);
i = b;
return
}
function Uf(a, b) {
a = a | 0;
b = b | 0;
return
}
function Vf(a) {
a = a | 0;
return
}
function Wf(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Xf(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m =
0,
n = 0,
o = 0,
p = 0;
h = i;
c[a + 8 >> 2] = b;
c[a + 12 >> 2] = d;
j = +g[e >> 2] - +g[b + 12 >> 2];
k = e + 4 | 0;
l = +g[k >> 2] - +g[b + 16 >> 2];
m = +g[b + 24 >> 2];
n = +g[b + 20 >> 2];
o = +(j * m + l * n);
p = +(m * l - j * n);
b = a + 20 | 0;
g[b >> 2] = o;
g[b + 4 >> 2] = p;
p = +g[f >> 2] - +g[d + 12 >> 2];
b = f + 4 | 0;
o = +g[b >> 2] - +g[d + 16 >> 2];
n = +g[d + 24 >> 2];
j = +g[d + 20 >> 2];
l = +(p * n + o * j);
m = +(n * o - p * j);
d = a + 28 | 0;
g[d >> 2] = l;
g[d + 4 >> 2] = m;
m = +g[f >> 2] - +g[e >> 2];
l = +g[b >> 2] - +g[k >> 2];
g[a + 36 >> 2] = +Q(+(m * m + l * l));
i = h;
return
}
function Yf(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0;
d = i;
vh(a, b);
c[a >> 2] = 1504;
e = b + 20 | 0;
f = c[e + 4 >> 2] | 0;
h = a + 80 |
0;
c[h >> 2] = c[e >> 2];
c[h + 4 >> 2] = f;
f = b + 28 | 0;
h = c[f + 4 >> 2] | 0;
e = a + 88 | 0;
c[e >> 2] = c[f >> 2];
c[e + 4 >> 2] = h;
g[a + 104 >> 2] = +g[b + 36 >> 2];
g[a + 68 >> 2] = +g[b + 40 >> 2];
g[a + 72 >> 2] = +g[b + 44 >> 2];
g[a + 100 >> 2] = 0;
g[a + 96 >> 2] = 0;
g[a + 76 >> 2] = 0;
i = d;
return
}
function Zf(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa =
0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0,
ya = 0,
za = 0;
e = i;
f = c[b + 48 >> 2] | 0;
h = c[f + 8 >> 2] | 0;
j = b + 108 | 0;
c[j >> 2] = h;
l = c[b + 52 >> 2] | 0;
m = c[l + 8 >> 2] | 0;
n = b + 112 | 0;
c[n >> 2] = m;
o = f + 44 | 0;
p = c[o >> 2] | 0;
q = c[o + 4 >> 2] | 0;
o = b + 140 | 0;
c[o >> 2] = p;
c[o + 4 >> 2] = q;
o = l + 44 | 0;
r = c[o >> 2] | 0;
s = c[o + 4 >> 2] | 0;
o = b + 148 | 0;
c[o >> 2] = r;
c[o + 4 >> 2] = s;
s = b + 156 | 0;
g[s >> 2] = +g[f + 136 >> 2];
o = b + 160 | 0;
g[o >> 2] = +g[l + 136 >> 2];
t = b + 164 | 0;
g[t >> 2] = +g[f + 144 >> 2];
f = b + 168 | 0;
g[f >> 2] = +g[l + 144 >> 2];
l = c[d + 28 >> 2] | 0;
u = l + (h * 12 | 0) | 0;
v = +g[u >> 2];
w = +g[u + 4 >> 2];
x = +g[l + (h * 12 | 0) + 8 >> 2];
u = d + 32 | 0;
y = c[u >> 2] |
0;
z = y + (h * 12 | 0) | 0;
A = +g[z >> 2];
B = +g[z + 4 >> 2];
C = +g[y + (h * 12 | 0) + 8 >> 2];
h = l + (m * 12 | 0) | 0;
D = +g[h >> 2];
E = +g[h + 4 >> 2];
F = +g[l + (m * 12 | 0) + 8 >> 2];
l = y + (m * 12 | 0) | 0;
G = +g[l >> 2];
H = +g[l + 4 >> 2];
I = +g[y + (m * 12 | 0) + 8 >> 2];
J = +T(+x);
K = +S(+x);
x = +T(+F);
L = +S(+F);
F = +g[b + 80 >> 2] - (c[k >> 2] = p, +g[k >> 2]);
M = +g[b + 84 >> 2] - (c[k >> 2] = q, +g[k >> 2]);
N = K * F - J * M;
O = J * F + K * M;
M = +N;
K = +O;
q = b + 124 | 0;
g[q >> 2] = M;
g[q + 4 >> 2] = K;
K = +g[b + 88 >> 2] - (c[k >> 2] = r, +g[k >> 2]);
M = +g[b + 92 >> 2] - +g[b + 152 >> 2];
F = L * K - x * M;
J = x * K + L * M;
M = +F;
L = +J;
r = b + 132 | 0;
g[r >> 2] = M;
g[r + 4 >> 2] = L;
r = b + 116 | 0;
L = D + F - v - N;
v = E +
J - w - O;
w = +L;
E = +v;
q = r;
g[q >> 2] = w;
g[q + 4 >> 2] = E;
E = +Q(+(L * L + v * v));
if (E > .004999999888241291) {
w = 1 / E;
D = L * w;
g[r >> 2] = D;
P = w * v;
R = D
} else {
g[r >> 2] = 0;
P = 0;
R = 0
}
g[b + 120 >> 2] = P;
D = P * N - O * R;
v = P * F - R * J;
w = +g[s >> 2];
L = +g[t >> 2];
M = +g[o >> 2];
K = +g[f >> 2];
x = M + (w + D * D * L) + v * v * K;
if (x != 0)
U = 1 / x;
else
U = 0;
f = b + 172 | 0;
g[f >> 2] = U;
v = +g[b + 68 >> 2];
if (v > 0) {
D = E - +g[b + 104 >> 2];
E = v * 6.2831854820251465;
v = E * U * E;
V = +g[d >> 2];
W = V * (E * U * 2 * +g[b + 72 >> 2] + v * V);
o = b + 96 | 0;
g[o >> 2] = W;
if (W != 0)
X = 1 / W;
else
X = 0;
g[o >> 2] = X;
g[b + 76 >> 2] = v * D * V * X;
V = x + X;
if (V != 0)
Y = 1 / V;
else
Y = 0;
g[f >> 2] = Y
} else {
g[b +
96 >> 2] = 0;
g[b + 76 >> 2] = 0
}
if ((a[d + 24 >> 0] | 0) == 0) {
g[b + 100 >> 2] = 0;
Z = A;
_ = B;
$ = G;
aa = H;
ba = C;
ca = I;
da = c[j >> 2] | 0;
ea = c[u >> 2] | 0;
fa = ea + (da * 12 | 0) | 0;
ga = +Z;
ha = +_;
ia = fa;
ja = ia;
g[ja >> 2] = ga;
ka = ia + 4 | 0;
la = ka;
g[la >> 2] = ha;
ma = c[j >> 2] | 0;
na = c[u >> 2] | 0;
oa = na + (ma * 12 | 0) + 8 | 0;
g[oa >> 2] = ba;
pa = c[n >> 2] | 0;
qa = na + (pa * 12 | 0) | 0;
ra = +$;
sa = +aa;
ta = qa;
ua = ta;
g[ua >> 2] = ra;
va = ta + 4 | 0;
wa = va;
g[wa >> 2] = sa;
xa = c[n >> 2] | 0;
ya = c[u >> 2] | 0;
za = ya + (xa * 12 | 0) + 8 | 0;
g[za >> 2] = ca;
i = e;
return
} else {
f = b + 100 | 0;
Y = +g[d + 8 >> 2] * +g[f >> 2];
g[f >> 2] = Y;
V = R * Y;
R = Y * P;
Z = A - V * w;
_ = B - R * w;
$ = G + V * M;
aa =
H + R * M;
ba = C - L * (R * N - V * O);
ca = I + K * (R * F - V * J);
da = c[j >> 2] | 0;
ea = c[u >> 2] | 0;
fa = ea + (da * 12 | 0) | 0;
ga = +Z;
ha = +_;
ia = fa;
ja = ia;
g[ja >> 2] = ga;
ka = ia + 4 | 0;
la = ka;
g[la >> 2] = ha;
ma = c[j >> 2] | 0;
na = c[u >> 2] | 0;
oa = na + (ma * 12 | 0) + 8 | 0;
g[oa >> 2] = ba;
pa = c[n >> 2] | 0;
qa = na + (pa * 12 | 0) | 0;
ra = +$;
sa = +aa;
ta = qa;
ua = ta;
g[ua >> 2] = ra;
va = ta + 4 | 0;
wa = va;
g[wa >> 2] = sa;
xa = c[n >> 2] | 0;
ya = c[u >> 2] | 0;
za = ya + (xa * 12 | 0) + 8 | 0;
g[za >> 2] = ca;
i = e;
return
}
}
function _f(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0;
d = i;
e = a +
108 | 0;
f = c[e >> 2] | 0;
h = b + 32 | 0;
b = c[h >> 2] | 0;
j = b + (f * 12 | 0) | 0;
k = j;
l = +g[k >> 2];
m = +g[k + 4 >> 2];
n = +g[b + (f * 12 | 0) + 8 >> 2];
f = a + 112 | 0;
k = c[f >> 2] | 0;
o = b + (k * 12 | 0) | 0;
p = +g[o >> 2];
q = +g[o + 4 >> 2];
r = +g[b + (k * 12 | 0) + 8 >> 2];
s = +g[a + 128 >> 2];
t = +g[a + 124 >> 2];
u = +g[a + 136 >> 2];
v = +g[a + 132 >> 2];
w = +g[a + 116 >> 2];
x = +g[a + 120 >> 2];
k = a + 100 | 0;
y = +g[k >> 2];
z = +g[a + 172 >> 2] * (+g[a + 76 >> 2] + (w * (p - r * u - (l - n * s)) + x * (q + r * v - (m + n * t))) + +g[a + 96 >> 2] * y);
A = -z;
g[k >> 2] = y - z;
z = w * A;
w = x * A;
A = +g[a + 156 >> 2];
x = n - +g[a + 164 >> 2] * (t * w - z * s);
s = +g[a + 160 >> 2];
t = r + +g[a + 168 >> 2] * (w * v - z * u);
u = +(l - A *
z);
l = +(m - A * w);
a = j;
g[a >> 2] = u;
g[a + 4 >> 2] = l;
a = c[h >> 2] | 0;
g[a + ((c[e >> 2] | 0) * 12 | 0) + 8 >> 2] = x;
x = +(p + z * s);
z = +(q + w * s);
e = a + ((c[f >> 2] | 0) * 12 | 0) | 0;
g[e >> 2] = x;
g[e + 4 >> 2] = z;
g[(c[h >> 2] | 0) + ((c[f >> 2] | 0) * 12 | 0) + 8 >> 2] = t;
i = d;
return
}
function $f(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0;
d = i;
if (+g[a + 68 >> 2] > 0) {
e = 1;
i = d;
return e | 0
}
f = a + 108 | 0;
h = c[f >> 2] | 0;
j = b + 28 | 0;
b = c[j >> 2] | 0;
k = b + (h * 12 | 0) | 0;
l = k;
m = +g[l >> 2];
n = +g[l + 4 >> 2];
o = +g[b + (h * 12 | 0) + 8 >> 2];
h = a + 112 | 0;
l =
c[h >> 2] | 0;
p = b + (l * 12 | 0) | 0;
q = +g[p >> 2];
r = +g[p + 4 >> 2];
s = +g[b + (l * 12 | 0) + 8 >> 2];
t = +T(+o);
u = +S(+o);
v = +T(+s);
w = +S(+s);
x = +g[a + 80 >> 2] - +g[a + 140 >> 2];
y = +g[a + 84 >> 2] - +g[a + 144 >> 2];
z = u * x - t * y;
A = t * x + u * y;
y = +g[a + 88 >> 2] - +g[a + 148 >> 2];
u = +g[a + 92 >> 2] - +g[a + 152 >> 2];
x = w * y - v * u;
t = v * y + w * u;
u = q + x - m - z;
w = r + t - n - A;
y = +Q(+(u * u + w * w));
if (y < 1.1920928955078125E-7) {
B = 0;
C = u;
D = w
} else {
v = 1 / y;
B = y;
C = u * v;
D = w * v
}
v = B - +g[a + 104 >> 2];
B = v < .20000000298023224 ? v : .20000000298023224;
v = B < -.20000000298023224 ? -.20000000298023224 : B;
B = -(+g[a + 172 >> 2] * v);
w = C * B;
C = D * B;
B = +g[a +
156 >> 2];
D = o - +g[a + 164 >> 2] * (z * C - A * w);
A = +g[a + 160 >> 2];
z = s + +g[a + 168 >> 2] * (x * C - t * w);
t = +(m - B * w);
m = +(n - B * C);
a = k;
g[a >> 2] = t;
g[a + 4 >> 2] = m;
a = c[j >> 2] | 0;
g[a + ((c[f >> 2] | 0) * 12 | 0) + 8 >> 2] = D;
D = +(q + A * w);
w = +(r + A * C);
f = a + ((c[h >> 2] | 0) * 12 | 0) | 0;
g[f >> 2] = D;
g[f + 4 >> 2] = w;
g[(c[j >> 2] | 0) + ((c[h >> 2] | 0) * 12 | 0) + 8 >> 2] = z;
if (v > 0)
E = v;
else
E = -v;
e = E < .004999999888241291;
i = d;
return e | 0
}
function ag(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 48 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 80 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 84 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d +
12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function bg(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 52 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 88 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 92 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function cg(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
var d = 0;
d = +g[b + 100 >> 2] * c;
c = d * +g[b + 120 >> 2];
g[a >> 2] = +g[b + 116 >> 2] * d;
g[a + 4 >> 2] = c;
return
}
function dg(a, b) {
a = a | 0;
b = +b;
return 0
}
function eg(a) {
a = a | 0;
var b = 0,
e = 0,
f = 0,
j = 0,
l = 0;
b = i;
i = i + 16 | 0;
e = b;
f = c[(c[a + 48 >> 2] | 0) + 8 >> 2] | 0;
j = c[(c[a + 52 >> 2] | 0) +
8 >> 2] | 0;
Rm(1552, e);
c[e >> 2] = f;
Rm(1584, e);
c[e >> 2] = j;
Rm(1616, e);
c[e >> 2] = d[a + 61 >> 0] | 0;
Rm(1648, e);
l = +g[a + 84 >> 2];
h[k >> 3] = +g[a + 80 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(1688, e);
l = +g[a + 92 >> 2];
h[k >> 3] = +g[a + 88 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(1736, e);
h[k >> 3] = +g[a + 104 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(1784, e);
h[k >> 3] = +g[a + 68 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(1808, e);
h[k >>
3] = +g[a + 72 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(1840, e);
c[e >> 2] = c[a + 56 >> 2];
Rm(1872, e);
i = b;
return
}
function fg(a) {
a = a | 0;
return
}
function gg(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function hg(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0;
f = i;
c[a + 8 >> 2] = b;
c[a + 12 >> 2] = d;
h = +g[e >> 2] - +g[b + 12 >> 2];
j = e + 4 | 0;
k = +g[j >> 2] - +g[b + 16 >> 2];
l = +g[b + 24 >> 2];
m = +g[b + 20 >> 2];
n = +(h * l + k * m);
o = +(l * k - h * m);
b = a + 20 | 0;
g[b >> 2] = n;
g[b + 4 >> 2] = o;
o = +g[e >> 2] - +g[d + 12 >> 2];
n = +g[j >> 2] - +g[d + 16 >> 2];
m = +g[d + 24 >> 2];
h = +g[d + 20 >>
2];
k = +(o * m + n * h);
l = +(m * n - o * h);
d = a + 28 | 0;
g[d >> 2] = k;
g[d + 4 >> 2] = l;
i = f;
return
}
function ig(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0;
d = i;
vh(a, b);
c[a >> 2] = 1968;
e = b + 20 | 0;
f = c[e + 4 >> 2] | 0;
h = a + 68 | 0;
c[h >> 2] = c[e >> 2];
c[h + 4 >> 2] = f;
f = b + 28 | 0;
h = c[f + 4 >> 2] | 0;
e = a + 76 | 0;
c[e >> 2] = c[f >> 2];
c[e + 4 >> 2] = h;
g[a + 84 >> 2] = 0;
g[a + 88 >> 2] = 0;
g[a + 92 >> 2] = 0;
g[a + 96 >> 2] = +g[b + 36 >> 2];
g[a + 100 >> 2] = +g[b + 40 >> 2];
i = d;
return
}
function jg(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H =
0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0;
e = i;
f = c[b + 48 >> 2] | 0;
h = c[f + 8 >> 2] | 0;
j = b + 104 | 0;
c[j >> 2] = h;
l = c[b + 52 >> 2] | 0;
m = c[l + 8 >> 2] | 0;
n = b + 108 | 0;
c[n >> 2] = m;
o = f + 44 | 0;
p = c[o >> 2] | 0;
q = c[o + 4 >> 2] | 0;
o = b + 128 | 0;
c[o >> 2] = p;
c[o + 4 >> 2] = q;
o = l + 44 | 0;
r = c[o >> 2] | 0;
s = c[o + 4 >> 2] | 0;
o = b + 136 | 0;
c[o >> 2] = r;
c[o + 4 >> 2] = s;
o = b + 144 | 0;
g[o >> 2] = +g[f + 136 >> 2];
t = +g[l + 136 >> 2];
g[b + 148 >> 2] = t;
u = +g[f + 144 >> 2];
g[b + 152 >> 2] = u;
v =
+g[l + 144 >> 2];
g[b + 156 >> 2] = v;
l = c[d + 28 >> 2] | 0;
w = +g[l + (h * 12 | 0) + 8 >> 2];
f = d + 32 | 0;
x = c[f >> 2] | 0;
y = x + (h * 12 | 0) | 0;
z = +g[y >> 2];
A = +g[y + 4 >> 2];
B = +g[x + (h * 12 | 0) + 8 >> 2];
C = +g[l + (m * 12 | 0) + 8 >> 2];
l = x + (m * 12 | 0) | 0;
D = +g[l >> 2];
E = +g[l + 4 >> 2];
F = +g[x + (m * 12 | 0) + 8 >> 2];
G = +T(+w);
H = +S(+w);
w = +T(+C);
I = +S(+C);
C = +g[b + 68 >> 2] - (c[k >> 2] = p, +g[k >> 2]);
J = +g[b + 72 >> 2] - (c[k >> 2] = q, +g[k >> 2]);
K = H * C - G * J;
L = G * C + H * J;
J = +K;
H = +L;
q = b + 112 | 0;
g[q >> 2] = J;
g[q + 4 >> 2] = H;
H = +g[b + 76 >> 2] - (c[k >> 2] = r, +g[k >> 2]);
J = +g[b + 80 >> 2] - (c[k >> 2] = s, +g[k >> 2]);
C = I * H - w * J;
G = w * H + I * J;
J = +C;
I = +G;
s = b +
120 | 0;
g[s >> 2] = J;
g[s + 4 >> 2] = I;
I = +g[o >> 2];
J = I + t;
H = J + L * u * L + G * v * G;
w = u * K;
M = v * C;
N = -(L * w) - G * M;
O = J + K * w + C * M;
M = H * O - N * N;
if (M != 0)
P = 1 / M;
else
P = M;
M = -(N * P);
g[b + 160 >> 2] = O * P;
g[b + 164 >> 2] = M;
g[b + 168 >> 2] = M;
g[b + 172 >> 2] = H * P;
P = u + v;
if (P > 0)
Q = 1 / P;
else
Q = P;
g[b + 176 >> 2] = Q;
o = b + 84 | 0;
if ((a[d + 24 >> 0] | 0) == 0) {
g[o >> 2] = 0;
g[b + 88 >> 2] = 0;
g[b + 92 >> 2] = 0;
R = z;
U = A;
V = D;
W = E;
X = B;
Y = F;
Z = c[j >> 2] | 0;
_ = c[f >> 2] | 0;
$ = _ + (Z * 12 | 0) | 0;
aa = +R;
ba = +U;
ca = $;
da = ca;
g[da >> 2] = aa;
ea = ca + 4 | 0;
fa = ea;
g[fa >> 2] = ba;
ga = c[j >> 2] | 0;
ha = c[f >> 2] | 0;
ia = ha + (ga * 12 | 0) + 8 | 0;
g[ia >> 2] = X;
ja = c[n >> 2] |
0;
ka = ha + (ja * 12 | 0) | 0;
la = +V;
ma = +W;
na = ka;
oa = na;
g[oa >> 2] = la;
pa = na + 4 | 0;
qa = pa;
g[qa >> 2] = ma;
ra = c[n >> 2] | 0;
sa = c[f >> 2] | 0;
ta = sa + (ra * 12 | 0) + 8 | 0;
g[ta >> 2] = Y;
i = e;
return
} else {
s = d + 8 | 0;
Q = +g[s >> 2];
P = Q * +g[o >> 2];
g[o >> 2] = P;
o = b + 88 | 0;
H = Q * +g[o >> 2];
g[o >> 2] = H;
o = b + 92 | 0;
Q = +g[s >> 2] * +g[o >> 2];
g[o >> 2] = Q;
R = z - I * P;
U = A - I * H;
V = D + t * P;
W = E + t * H;
X = B - u * (Q + (H * K - P * L));
Y = F + v * (Q + (H * C - P * G));
Z = c[j >> 2] | 0;
_ = c[f >> 2] | 0;
$ = _ + (Z * 12 | 0) | 0;
aa = +R;
ba = +U;
ca = $;
da = ca;
g[da >> 2] = aa;
ea = ca + 4 | 0;
fa = ea;
g[fa >> 2] = ba;
ga = c[j >> 2] | 0;
ha = c[f >> 2] | 0;
ia = ha + (ga * 12 | 0) + 8 | 0;
g[ia >> 2] = X;
ja = c[n >> 2] | 0;
ka = ha + (ja * 12 | 0) | 0;
la = +V;
ma = +W;
na = ka;
oa = na;
g[oa >> 2] = la;
pa = na + 4 | 0;
qa = pa;
g[qa >> 2] = ma;
ra = c[n >> 2] | 0;
sa = c[f >> 2] | 0;
ta = sa + (ra * 12 | 0) + 8 | 0;
g[ta >> 2] = Y;
i = e;
return
}
}
function kg(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0;
d = i;
e = a + 104 | 0;
f = c[e >> 2] | 0;
h = b + 32 | 0;
j = c[h >> 2] | 0;
k = j + (f * 12 | 0) | 0;
l = +g[k >> 2];
m = +g[k + 4 >> 2];
n = +g[j + (f * 12 | 0) + 8 >> 2];
f = a + 108 | 0;
k = c[f >> 2] | 0;
o = j + (k * 12 | 0) | 0;
p = +g[o >> 2];
q = +g[o + 4 >> 2];
r = +g[j +
(k * 12 | 0) + 8 >> 2];
s = +g[a + 144 >> 2];
t = +g[a + 148 >> 2];
u = +g[a + 152 >> 2];
v = +g[a + 156 >> 2];
w = +g[b >> 2];
b = a + 92 | 0;
x = +g[b >> 2];
y = w * +g[a + 100 >> 2];
z = x - (r - n) * +g[a + 176 >> 2];
A = -y;
B = z < y ? z : y;
y = B < A ? A : B;
g[b >> 2] = y;
B = y - x;
x = n - u * B;
n = r + v * B;
B = +g[a + 124 >> 2];
r = +g[a + 120 >> 2];
y = +g[a + 116 >> 2];
A = +g[a + 112 >> 2];
z = y * x + (p - B * n - l);
C = q + r * n - m - A * x;
D = +g[a + 164 >> 2] * z + +g[a + 172 >> 2] * C;
b = a + 84 | 0;
k = b;
E = +g[k >> 2];
F = +g[k + 4 >> 2];
G = E - (+g[a + 160 >> 2] * z + +g[a + 168 >> 2] * C);
g[b >> 2] = G;
k = a + 88 | 0;
C = +g[k >> 2] - D;
g[k >> 2] = C;
D = w * +g[a + 96 >> 2];
w = G * G + C * C;
if (w > D * D) {
z = +Q(+w);
if (z < 1.1920928955078125E-7) {
H =
G;
I = C
} else {
w = 1 / z;
z = G * w;
g[b >> 2] = z;
J = C * w;
g[k >> 2] = J;
H = z;
I = J
}
J = D * H;
g[b >> 2] = J;
H = D * I;
g[k >> 2] = H;
K = J;
L = H
} else {
K = G;
L = C
}
C = K - E;
E = L - F;
F = +(l - s * C);
l = +(m - s * E);
k = (c[h >> 2] | 0) + ((c[e >> 2] | 0) * 12 | 0) | 0;
g[k >> 2] = F;
g[k + 4 >> 2] = l;
k = c[h >> 2] | 0;
g[k + ((c[e >> 2] | 0) * 12 | 0) + 8 >> 2] = x - u * (A * E - C * y);
y = +(p + t * C);
p = +(q + t * E);
e = k + ((c[f >> 2] | 0) * 12 | 0) | 0;
g[e >> 2] = y;
g[e + 4 >> 2] = p;
g[(c[h >> 2] | 0) + ((c[f >> 2] | 0) * 12 | 0) + 8 >> 2] = n + v * (E * r - C * B);
i = d;
return
}
function lg(a, b) {
a = a | 0;
b = b | 0;
return 1
}
function mg(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 48 >> 2] | 0;
e =
+g[d + 24 >> 2];
f = +g[b + 68 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 72 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function ng(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 52 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 76 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 80 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function og(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
var d = 0;
d = +g[b + 88 >> 2] * c;
g[a >> 2] = +g[b + 84 >> 2] * c;
g[a + 4 >> 2] = d;
return
}
function pg(a, b) {
a = a | 0;
b = +b;
return +(+g[a + 92 >> 2] * b)
}
function qg(a) {
a = a | 0;
var b =
0,
e = 0,
f = 0,
j = 0,
l = 0;
b = i;
i = i + 16 | 0;
e = b;
f = c[(c[a + 48 >> 2] | 0) + 8 >> 2] | 0;
j = c[(c[a + 52 >> 2] | 0) + 8 >> 2] | 0;
Rm(2016, e);
c[e >> 2] = f;
Rm(2048, e);
c[e >> 2] = j;
Rm(2080, e);
c[e >> 2] = d[a + 61 >> 0] | 0;
Rm(2112, e);
l = +g[a + 72 >> 2];
h[k >> 3] = +g[a + 68 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(2152, e);
l = +g[a + 80 >> 2];
h[k >> 3] = +g[a + 76 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(2200, e);
h[k >> 3] = +g[a + 96 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(2248,
e);
h[k >> 3] = +g[a + 100 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(2280, e);
c[e >> 2] = c[a + 56 >> 2];
Rm(2312, e);
i = b;
return
}
function rg(a) {
a = a | 0;
return
}
function sg(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function tg(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
f = i;
c[a + 8 >> 2] = b;
c[a + 12 >> 2] = d;
h = +g[e >> 2] - +g[b + 12 >> 2];
j = e + 4 | 0;
k = +g[j >> 2] - +g[b + 16 >> 2];
l = +g[b + 24 >> 2];
m = +g[b + 20 >> 2];
n = +(h * l + k * m);
o = +(l * k - h * m);
p = a + 20 | 0;
g[p >> 2] = n;
g[p + 4 >> 2] = o;
o = +g[e >> 2] - +g[d + 12 >> 2];
n = +g[j >> 2] - +g[d + 16 >> 2];
m = +g[d + 24 >> 2];
h = +g[d + 20 >> 2];
k = +(o * m + n * h);
l = +(m * n - o * h);
j = a + 28 | 0;
g[j >> 2] = k;
g[j + 4 >> 2] = l;
g[a + 36 >> 2] = +g[d + 72 >> 2] - +g[b + 72 >> 2];
i = f;
return
}
function ug(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0;
d = i;
vh(a, b);
c[a >> 2] = 2408;
e = b + 20 | 0;
f = c[e + 4 >> 2] | 0;
h = a + 80 | 0;
c[h >> 2] = c[e >> 2];
c[h + 4 >> 2] = f;
f = b + 28 | 0;
h = c[f + 4 >> 2] | 0;
e = a + 88 | 0;
c[e >> 2] = c[f >> 2];
c[e + 4 >> 2] = h;
g[a + 96 >> 2] = +g[b + 36 >> 2];
g[a + 68 >> 2] = +g[b + 40 >> 2];
g[a + 72 >> 2] = +g[b + 44 >> 2];
g[a + 104 >> 2] = 0;
g[a + 108 >> 2] = 0;
g[a + 112 >> 2] = 0;
i = d;
return
}
function vg(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0;
e = i;
i = i + 48 | 0;
f = e;
h = c[b + 48 >> 2] | 0;
j = c[h + 8 >> 2] | 0;
l = b + 116 | 0;
c[l >> 2] = j;
m = c[b + 52 >> 2] | 0;
n = c[m + 8 >> 2] | 0;
o = b + 120 | 0;
c[o >> 2] = n;
p = h + 44 | 0;
q = c[p >> 2] | 0;
r = c[p + 4 >> 2] | 0;
p = b + 140 | 0;
c[p >> 2] = q;
c[p + 4 >> 2] = r;
p = m + 44 | 0;
s = c[p >> 2] | 0;
t = c[p + 4 >> 2] | 0;
p = b + 148 | 0;
c[p >> 2] = s;
c[p + 4 >> 2] = t;
p = b +
156 | 0;
g[p >> 2] = +g[h + 136 >> 2];
u = +g[m + 136 >> 2];
g[b + 160 >> 2] = u;
v = +g[h + 144 >> 2];
g[b + 164 >> 2] = v;
w = +g[m + 144 >> 2];
g[b + 168 >> 2] = w;
m = c[d + 28 >> 2] | 0;
x = +g[m + (j * 12 | 0) + 8 >> 2];
h = d + 32 | 0;
y = c[h >> 2] | 0;
z = y + (j * 12 | 0) | 0;
A = +g[z >> 2];
B = +g[z + 4 >> 2];
C = +g[y + (j * 12 | 0) + 8 >> 2];
D = +g[m + (n * 12 | 0) + 8 >> 2];
m = y + (n * 12 | 0) | 0;
E = +g[m >> 2];
F = +g[m + 4 >> 2];
G = +g[y + (n * 12 | 0) + 8 >> 2];
H = +T(+x);
I = +S(+x);
J = +T(+D);
K = +S(+D);
n = b + 124 | 0;
L = +g[b + 80 >> 2] - (c[k >> 2] = q, +g[k >> 2]);
M = +g[b + 84 >> 2] - (c[k >> 2] = r, +g[k >> 2]);
N = I * L - H * M;
O = H * L + I * M;
M = +N;
I = +O;
r = n;
g[r >> 2] = M;
g[r + 4 >> 2] = I;
r = b + 132 | 0;
I = +g[b +
88 >> 2] - (c[k >> 2] = s, +g[k >> 2]);
M = +g[b + 92 >> 2] - (c[k >> 2] = t, +g[k >> 2]);
L = K * I - J * M;
H = J * I + K * M;
M = +L;
K = +H;
t = r;
g[t >> 2] = M;
g[t + 4 >> 2] = K;
K = +g[p >> 2];
M = K + u;
p = b + 128 | 0;
t = b + 136 | 0;
g[f >> 2] = M + v * O * O + w * H * H;
I = -(v * O * N) - w * H * L;
g[f + 12 >> 2] = I;
J = -(v * O) - w * H;
g[f + 24 >> 2] = J;
g[f + 4 >> 2] = I;
g[f + 16 >> 2] = M + v * N * N + w * L * L;
M = v * N + w * L;
g[f + 28 >> 2] = M;
g[f + 8 >> 2] = J;
g[f + 20 >> 2] = M;
M = v + w;
g[f + 32 >> 2] = M;
s = b + 68 | 0;
q = b + 172 | 0;
if (+g[s >> 2] > 0) {
Im(f, q);
if (M > 0)
P = 1 / M;
else
P = 0;
J = D - x - +g[b + 96 >> 2];
x = +g[s >> 2] * 6.2831854820251465;
D = x * P * x;
L = +g[d >> 2];
N = L * (x * P * 2 * +g[b + 72 >> 2] + L * D);
s = b +
100 | 0;
g[s >> 2] = N;
if (N != 0)
Q = 1 / N;
else
Q = 0;
g[s >> 2] = Q;
g[b + 76 >> 2] = J * L * D * Q;
D = M + Q;
if (D != 0)
R = 1 / D;
else
R = 0;
g[b + 204 >> 2] = R
} else {
Jm(f, q);
g[b + 100 >> 2] = 0;
g[b + 76 >> 2] = 0
}
q = b + 104 | 0;
if ((a[d + 24 >> 0] | 0) == 0) {
g[q >> 2] = 0;
g[b + 108 >> 2] = 0;
g[b + 112 >> 2] = 0;
U = A;
V = B;
W = E;
X = F;
Y = C;
Z = G;
_ = c[l >> 2] | 0;
$ = c[h >> 2] | 0;
aa = $ + (_ * 12 | 0) | 0;
ba = +U;
ca = +V;
da = aa;
ea = da;
g[ea >> 2] = ba;
fa = da + 4 | 0;
ga = fa;
g[ga >> 2] = ca;
ha = c[l >> 2] | 0;
ia = c[h >> 2] | 0;
ja = ia + (ha * 12 | 0) + 8 | 0;
g[ja >> 2] = Y;
ka = c[o >> 2] | 0;
la = ia + (ka * 12 | 0) | 0;
ma = +W;
na = +X;
oa = la;
pa = oa;
g[pa >> 2] = ma;
qa = oa + 4 | 0;
ra = qa;
g[ra >> 2] = na;
sa = c[o >> 2] | 0;
ta = c[h >> 2] | 0;
ua = ta + (sa * 12 | 0) + 8 | 0;
g[ua >> 2] = Z;
i = e;
return
} else {
R = +g[d + 8 >> 2];
D = R * +g[q >> 2];
g[q >> 2] = D;
q = b + 108 | 0;
Q = R * +g[q >> 2];
g[q >> 2] = Q;
q = b + 112 | 0;
M = R * +g[q >> 2];
g[q >> 2] = M;
U = A - K * D;
V = B - K * Q;
W = E + u * D;
X = F + u * Q;
Y = C - v * (M + (Q * +g[n >> 2] - D * +g[p >> 2]));
Z = G + w * (M + (Q * +g[r >> 2] - D * +g[t >> 2]));
_ = c[l >> 2] | 0;
$ = c[h >> 2] | 0;
aa = $ + (_ * 12 | 0) | 0;
ba = +U;
ca = +V;
da = aa;
ea = da;
g[ea >> 2] = ba;
fa = da + 4 | 0;
ga = fa;
g[ga >> 2] = ca;
ha = c[l >> 2] | 0;
ia = c[h >> 2] | 0;
ja = ia + (ha * 12 | 0) + 8 | 0;
g[ja >> 2] = Y;
ka = c[o >> 2] | 0;
la = ia + (ka * 12 | 0) | 0;
ma = +W;
na = +X;
oa = la;
pa = oa;
g[pa >> 2] = ma;
qa = oa + 4 | 0;
ra = qa;
g[ra >> 2] = na;
sa = c[o >> 2] | 0;
ta = c[h >> 2] | 0;
ua = ta + (sa * 12 | 0) + 8 | 0;
g[ua >> 2] = Z;
i = e;
return
}
}
function wg(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0;
d = i;
e = a + 116 | 0;
f = c[e >> 2] | 0;
h = b + 32 | 0;
b = c[h >> 2] | 0;
j = b + (f * 12 | 0) | 0;
k = j;
l = +g[k >> 2];
m = +g[k + 4 >> 2];
n = +g[b + (f * 12 | 0) + 8 >> 2];
f = a + 120 | 0;
k = c[f >>
2] | 0;
o = b + (k * 12 | 0) | 0;
p = +g[o >> 2];
q = +g[o + 4 >> 2];
r = +g[b + (k * 12 | 0) + 8 >> 2];
s = +g[a + 156 >> 2];
t = +g[a + 160 >> 2];
u = +g[a + 164 >> 2];
v = +g[a + 168 >> 2];
if (+g[a + 68 >> 2] > 0) {
k = a + 112 | 0;
w = +g[k >> 2];
x = +g[a + 204 >> 2] * (r - n + +g[a + 76 >> 2] + +g[a + 100 >> 2] * w);
y = -x;
g[k >> 2] = w - x;
x = n - u * y;
w = r + v * y;
y = +g[a + 136 >> 2];
z = +g[a + 132 >> 2];
A = +g[a + 128 >> 2];
B = +g[a + 124 >> 2];
C = A * x + (p - y * w - l);
D = q + z * w - m - B * x;
E = +g[a + 172 >> 2] * C + +g[a + 184 >> 2] * D;
F = +g[a + 176 >> 2] * C + +g[a + 188 >> 2] * D;
D = -E;
C = -F;
k = a + 104 | 0;
g[k >> 2] = +g[k >> 2] - E;
k = a + 108 | 0;
g[k >> 2] = +g[k >> 2] - F;
G = C;
H = D;
I = x - u * (B * C - A * D);
J = w + v *
(z * C - y * D);
K = t * H;
L = t * G;
M = s * H;
N = s * G;
O = p + K;
P = q + L;
Q = l - M;
R = m - N;
S = +Q;
T = +R;
U = j;
V = U;
g[V >> 2] = S;
W = U + 4 | 0;
X = W;
g[X >> 2] = T;
Y = c[e >> 2] | 0;
Z = c[h >> 2] | 0;
_ = Z + (Y * 12 | 0) + 8 | 0;
g[_ >> 2] = I;
$ = c[f >> 2] | 0;
aa = Z + ($ * 12 | 0) | 0;
ba = +O;
ca = +P;
da = aa;
ea = da;
g[ea >> 2] = ba;
fa = da + 4 | 0;
ga = fa;
g[ga >> 2] = ca;
ha = c[f >> 2] | 0;
ia = c[h >> 2] | 0;
ja = ia + (ha * 12 | 0) + 8 | 0;
g[ja >> 2] = J;
i = d;
return
} else {
D = +g[a + 136 >> 2];
y = +g[a + 132 >> 2];
C = +g[a + 128 >> 2];
z = +g[a + 124 >> 2];
w = p - r * D - l + n * C;
A = q + r * y - m - n * z;
B = r - n;
x = w * +g[a + 172 >> 2] + A * +g[a + 184 >> 2] + B * +g[a + 196 >> 2];
F = w * +g[a + 176 >> 2] + A * +g[a + 188 >> 2] + B * +g[a +
200 >> 2];
E = w * +g[a + 180 >> 2] + A * +g[a + 192 >> 2] + B * +g[a + 204 >> 2];
B = -x;
A = -F;
k = a + 104 | 0;
g[k >> 2] = +g[k >> 2] - x;
k = a + 108 | 0;
g[k >> 2] = +g[k >> 2] - F;
k = a + 112 | 0;
g[k >> 2] = +g[k >> 2] - E;
G = A;
H = B;
I = n - u * (z * A - C * B - E);
J = r + v * (y * A - D * B - E);
K = t * H;
L = t * G;
M = s * H;
N = s * G;
O = p + K;
P = q + L;
Q = l - M;
R = m - N;
S = +Q;
T = +R;
U = j;
V = U;
g[V >> 2] = S;
W = U + 4 | 0;
X = W;
g[X >> 2] = T;
Y = c[e >> 2] | 0;
Z = c[h >> 2] | 0;
_ = Z + (Y * 12 | 0) + 8 | 0;
g[_ >> 2] = I;
$ = c[f >> 2] | 0;
aa = Z + ($ * 12 | 0) | 0;
ba = +O;
ca = +P;
da = aa;
ea = da;
g[ea >> 2] = ba;
fa = da + 4 | 0;
ga = fa;
g[ga >> 2] = ca;
ha = c[f >> 2] | 0;
ia = c[h >> 2] | 0;
ja = ia + (ha * 12 | 0) + 8 | 0;
g[ja >> 2] = J;
i = d;
return
}
}
function xg(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
R = 0;
d = i;
i = i + 80 | 0;
e = d + 40 | 0;
f = d + 32 | 0;
h = d + 24 | 0;
j = d + 12 | 0;
k = d;
l = a + 116 | 0;
m = c[l >> 2] | 0;
n = b + 28 | 0;
b = c[n >> 2] | 0;
o = b + (m * 12 | 0) | 0;
p = +g[o >> 2];
q = +g[o + 4 >> 2];
r = +g[b + (m * 12 | 0) + 8 >> 2];
m = a + 120 | 0;
o = c[m >> 2] | 0;
s = b + (o * 12 | 0) | 0;
t = +g[s >> 2];
u = +g[s + 4 >> 2];
v = +g[b + (o * 12 | 0) + 8 >> 2];
w = +T(+r);
x = +S(+r);
y = +T(+v);
z = +S(+v);
A = +g[a + 156 >> 2];
B = +g[a + 160 >> 2];
C = +g[a + 164 >>
2];
D = +g[a + 168 >> 2];
E = +g[a + 80 >> 2] - +g[a + 140 >> 2];
F = +g[a + 84 >> 2] - +g[a + 144 >> 2];
G = x * E - w * F;
H = w * E + x * F;
F = +g[a + 88 >> 2] - +g[a + 148 >> 2];
x = +g[a + 92 >> 2] - +g[a + 152 >> 2];
E = z * F - y * x;
w = y * F + z * x;
x = A + B;
g[e >> 2] = x + C * H * H + D * w * w;
z = -(C * H * G) - D * w * E;
g[e + 12 >> 2] = z;
F = -(C * H) - D * w;
g[e + 24 >> 2] = F;
g[e + 4 >> 2] = z;
g[e + 16 >> 2] = x + C * G * G + D * E * E;
x = C * G + D * E;
g[e + 28 >> 2] = x;
g[e + 8 >> 2] = F;
g[e + 20 >> 2] = x;
g[e + 32 >> 2] = C + D;
x = t + E - p - G;
F = u + w - q - H;
if (+g[a + 68 >> 2] > 0) {
g[f >> 2] = x;
g[f + 4 >> 2] = F;
z = +Q(+(F * F + x * x));
Hm(h, e, f);
y = -+g[h >> 2];
I = -+g[h + 4 >> 2];
J = I;
K = y;
L = E * I - w * y;
M = G * I - H * y;
N = 0;
O = z
} else {
z =
v - r - +g[a + 96 >> 2];
y = +Q(+(x * x + F * F));
if (z > 0)
P = z;
else
P = -z;
g[j >> 2] = x;
g[j + 4 >> 2] = F;
g[j + 8 >> 2] = z;
Gm(k, e, j);
z = -+g[k >> 2];
F = -+g[k + 4 >> 2];
x = +g[k + 8 >> 2];
J = F;
K = z;
L = E * F - w * z - x;
M = G * F - H * z - x;
N = P;
O = y
}
y = +(p - A * K);
p = +(q - A * J);
k = (c[n >> 2] | 0) + ((c[l >> 2] | 0) * 12 | 0) | 0;
g[k >> 2] = y;
g[k + 4 >> 2] = p;
k = c[n >> 2] | 0;
g[k + ((c[l >> 2] | 0) * 12 | 0) + 8 >> 2] = r - C * M;
M = +(t + B * K);
K = +(u + B * J);
l = k + ((c[m >> 2] | 0) * 12 | 0) | 0;
g[l >> 2] = M;
g[l + 4 >> 2] = K;
g[(c[n >> 2] | 0) + ((c[m >> 2] | 0) * 12 | 0) + 8 >> 2] = v + D * L;
if (!(O <= .004999999888241291)) {
R = 0;
i = d;
return R | 0
}
R = N <= .03490658849477768;
i = d;
return R |
0
}
function yg(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 48 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 80 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 84 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function zg(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 52 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 88 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 92 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function Ag(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
var d = 0;
d = +g[b + 108 >> 2] * c;
g[a >> 2] = +g[b + 104 >> 2] * c;
g[a + 4 >> 2] = d;
return
}
function Bg(a, b) {
a = a | 0;
b = +b;
return +(+g[a + 112 >> 2] * b)
}
function Cg(a) {
a = a | 0;
var b = 0,
e = 0,
f = 0,
j = 0,
l = 0;
b = i;
i = i + 16 | 0;
e = b;
f = c[(c[a + 48 >> 2] | 0) + 8 >> 2] | 0;
j = c[(c[a + 52 >> 2] | 0) + 8 >> 2] | 0;
Rm(2456, e);
c[e >> 2] = f;
Rm(2480, e);
c[e >> 2] = j;
Rm(2512, e);
c[e >> 2] = d[a + 61 >> 0] | 0;
Rm(2544, e);
l = +g[a + 84 >> 2];
h[k >> 3] = +g[a + 80 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(2584, e);
l = +g[a + 92 >> 2];
h[k >> 3] = +g[a + 88 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] =
c[k + 4 >> 2];
Rm(2632, e);
h[k >> 3] = +g[a + 96 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(2680, e);
h[k >> 3] = +g[a + 68 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(2712, e);
h[k >> 3] = +g[a + 72 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(2744, e);
c[e >> 2] = c[a + 56 >> 2];
Rm(2776, e);
i = b;
return
}
function Dg(a) {
a = a | 0;
return
}
function Eg(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Fg(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0;
d = i;
vh(a, b);
c[a >> 2] = 2864;
e = a + 92 | 0;
f = a + 100 | 0;
h = a + 108 | 0;
j = a + 116 | 0;
l = a + 124 | 0;
m = a + 132 | 0;
n = b + 20 | 0;
o = c[n >> 2] | 0;
c[a + 68 >> 2] = o;
p = b + 24 | 0;
q = c[p >> 2] | 0;
c[a + 72 >> 2] = q;
r = c[o + 4 >> 2] | 0;
c[a + 76 >> 2] = r;
s = c[q + 4 >> 2] | 0;
c[a + 80 >> 2] = s;
t = c[o + 48 >> 2] | 0;
c[a + 84 >> 2] = t;
u = c[o + 52 >> 2] | 0;
c[a + 48 >> 2] = u;
v = +g[u + 20 >> 2];
w = +g[u + 24 >> 2];
x = +g[t + 20 >> 2];
y = +g[t + 24 >> 2];
o = c[n >> 2] | 0;
if ((r | 0) == 1) {
z = +g[u + 72 >> 2];
A = +g[t + 72 >> 2];
r = o + 68 | 0;
n = c[r + 4 >> 2] | 0;
B = h;
c[B >> 2] = c[r >> 2];
c[B + 4 >> 2] = n;
n = o + 76 | 0;
B = c[n + 4 >> 2] | 0;
r = e;
c[r >> 2] = c[n >> 2];
c[r + 4 >> 2] =
B;
C = +g[o + 116 >> 2];
g[a + 140 >> 2] = C;
g[l >> 2] = 0;
g[a + 128 >> 2] = 0;
D = z - A - C
} else {
C = +g[t + 16 >> 2];
A = +g[t + 12 >> 2];
z = +g[u + 16 >> 2];
E = +g[u + 12 >> 2];
u = o + 68 | 0;
t = c[u >> 2] | 0;
B = c[u + 4 >> 2] | 0;
u = h;
c[u >> 2] = t;
c[u + 4 >> 2] = B;
u = o + 76 | 0;
h = c[u >> 2] | 0;
r = c[u + 4 >> 2] | 0;
u = e;
c[u >> 2] = h;
c[u + 4 >> 2] = r;
g[a + 140 >> 2] = +g[o + 100 >> 2];
u = o + 84 | 0;
o = c[u >> 2] | 0;
e = c[u + 4 >> 2] | 0;
u = l;
c[u >> 2] = o;
c[u + 4 >> 2] = e;
F = (c[k >> 2] = t, +g[k >> 2]);
G = (c[k >> 2] = B, +g[k >> 2]);
H = (c[k >> 2] = h, +g[k >> 2]);
I = (c[k >> 2] = r, +g[k >> 2]);
J = E - A + (w * H - v * I);
A = z - C + (v * H + w * I);
I = (c[k >> 2] = o, +g[k >> 2]) * (y * J + x * A - F);
D = I + (c[k >>
2] = e, +g[k >> 2]) * (y * A - x * J - G)
}
e = c[q + 48 >> 2] | 0;
c[a + 88 >> 2] = e;
o = c[q + 52 >> 2] | 0;
c[a + 52 >> 2] = o;
G = +g[o + 20 >> 2];
J = +g[o + 24 >> 2];
x = +g[e + 20 >> 2];
A = +g[e + 24 >> 2];
q = c[p >> 2] | 0;
if ((s | 0) == 1) {
y = +g[o + 72 >> 2];
I = +g[e + 72 >> 2];
s = q + 68 | 0;
p = c[s + 4 >> 2] | 0;
r = j;
c[r >> 2] = c[s >> 2];
c[r + 4 >> 2] = p;
p = q + 76 | 0;
r = c[p + 4 >> 2] | 0;
s = f;
c[s >> 2] = c[p >> 2];
c[s + 4 >> 2] = r;
F = +g[q + 116 >> 2];
g[a + 144 >> 2] = F;
g[m >> 2] = 0;
g[a + 136 >> 2] = 0;
K = y - I - F;
L = b + 28 | 0;
M = +g[L >> 2];
N = a + 152 | 0;
g[N >> 2] = M;
O = K * M;
P = D + O;
Q = a + 148 | 0;
g[Q >> 2] = P;
R = a + 156 | 0;
g[R >> 2] = 0;
i = d;
return
} else {
F = +g[e + 16 >> 2];
I = +g[e + 12 >> 2];
y =
+g[o + 16 >> 2];
w = +g[o + 12 >> 2];
o = q + 68 | 0;
e = c[o >> 2] | 0;
r = c[o + 4 >> 2] | 0;
o = j;
c[o >> 2] = e;
c[o + 4 >> 2] = r;
o = q + 76 | 0;
j = c[o >> 2] | 0;
s = c[o + 4 >> 2] | 0;
o = f;
c[o >> 2] = j;
c[o + 4 >> 2] = s;
g[a + 144 >> 2] = +g[q + 100 >> 2];
o = q + 84 | 0;
q = c[o >> 2] | 0;
f = c[o + 4 >> 2] | 0;
o = m;
c[o >> 2] = q;
c[o + 4 >> 2] = f;
H = (c[k >> 2] = e, +g[k >> 2]);
v = (c[k >> 2] = r, +g[k >> 2]);
C = (c[k >> 2] = j, +g[k >> 2]);
z = (c[k >> 2] = s, +g[k >> 2]);
E = w - I + (J * C - G * z);
I = y - F + (G * C + J * z);
z = (c[k >> 2] = q, +g[k >> 2]) * (A * E + x * I - H);
K = z + (c[k >> 2] = f, +g[k >> 2]) * (A * I - x * E - v);
L = b + 28 | 0;
M = +g[L >> 2];
N = a + 152 | 0;
g[N >> 2] = M;
O = K * M;
P = D + O;
Q = a + 148 | 0;
g[Q >> 2] = P;
R = a + 156 | 0;
g[R >> 2] = 0;
i = d;
return
}
}
function Gg(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0,
ya = 0,
za = 0,
Aa = 0,
Ba = 0,
Ca = 0,
Da = 0,
Ea = 0,
Fa = 0,
Ga = 0,
Ha = 0,
Ia = 0,
Ja = 0,
Ka = 0,
La = 0,
Ma = 0,
Na = 0,
Oa = 0,
Pa = 0,
Qa = 0,
Ra = 0,
Sa = 0,
Ta = 0,
Ua = 0,
Va = 0,
Wa = 0,
Xa = 0,
Ya = 0,
Za =
0,
_a = 0,
$a = 0,
ab = 0,
bb = 0,
cb = 0,
db = 0,
eb = 0,
fb = 0,
gb = 0,
hb = 0,
ib = 0,
jb = 0,
kb = 0,
lb = 0,
mb = 0,
nb = 0,
ob = 0,
pb = 0,
qb = 0,
rb = 0,
sb = 0,
tb = 0,
ub = 0,
vb = 0,
wb = 0,
xb = 0,
yb = 0;
e = i;
f = c[b + 48 >> 2] | 0;
h = c[f + 8 >> 2] | 0;
j = b + 160 | 0;
c[j >> 2] = h;
l = c[b + 52 >> 2] | 0;
m = c[l + 8 >> 2] | 0;
n = b + 164 | 0;
c[n >> 2] = m;
o = c[b + 84 >> 2] | 0;
p = c[o + 8 >> 2] | 0;
q = b + 168 | 0;
c[q >> 2] = p;
r = c[b + 88 >> 2] | 0;
s = c[r + 8 >> 2] | 0;
t = b + 172 | 0;
c[t >> 2] = s;
u = b + 176 | 0;
v = f + 44 | 0;
w = c[v + 4 >> 2] | 0;
x = u;
c[x >> 2] = c[v >> 2];
c[x + 4 >> 2] = w;
w = b + 184 | 0;
x = l + 44 | 0;
v = c[x + 4 >> 2] | 0;
y = w;
c[y >> 2] = c[x >> 2];
c[y + 4 >> 2] = v;
v = b + 192 | 0;
y = o + 44 | 0;
x = c[y + 4 >> 2] | 0;
z =
v;
c[z >> 2] = c[y >> 2];
c[z + 4 >> 2] = x;
x = r + 44 | 0;
z = c[x >> 2] | 0;
y = c[x + 4 >> 2] | 0;
x = b + 200 | 0;
c[x >> 2] = z;
c[x + 4 >> 2] = y;
A = +g[f + 136 >> 2];
g[b + 208 >> 2] = A;
B = +g[l + 136 >> 2];
g[b + 212 >> 2] = B;
C = +g[o + 136 >> 2];
g[b + 216 >> 2] = C;
D = +g[r + 136 >> 2];
g[b + 220 >> 2] = D;
E = +g[f + 144 >> 2];
g[b + 224 >> 2] = E;
F = +g[l + 144 >> 2];
g[b + 228 >> 2] = F;
G = +g[o + 144 >> 2];
g[b + 232 >> 2] = G;
H = +g[r + 144 >> 2];
g[b + 236 >> 2] = H;
r = c[d + 28 >> 2] | 0;
I = +g[r + (h * 12 | 0) + 8 >> 2];
o = d + 32 | 0;
l = c[o >> 2] | 0;
f = l + (h * 12 | 0) | 0;
J = +g[f >> 2];
K = +g[f + 4 >> 2];
L = +g[l + (h * 12 | 0) + 8 >> 2];
M = +g[r + (m * 12 | 0) + 8 >> 2];
h = l + (m * 12 | 0) | 0;
N = +g[h >> 2];
O = +g[h +
4 >> 2];
P = +g[l + (m * 12 | 0) + 8 >> 2];
Q = +g[r + (p * 12 | 0) + 8 >> 2];
m = l + (p * 12 | 0) | 0;
R = +g[m >> 2];
U = +g[m + 4 >> 2];
V = +g[l + (p * 12 | 0) + 8 >> 2];
W = +g[r + (s * 12 | 0) + 8 >> 2];
r = l + (s * 12 | 0) | 0;
X = +g[r >> 2];
Y = +g[r + 4 >> 2];
Z = +g[l + (s * 12 | 0) + 8 >> 2];
_ = +T(+I);
$ = +S(+I);
I = +T(+M);
aa = +S(+M);
M = +T(+Q);
ba = +S(+Q);
Q = +T(+W);
ca = +S(+W);
s = b + 272 | 0;
g[s >> 2] = 0;
W = (c[k >> 2] = z, +g[k >> 2]);
if ((c[b + 76 >> 2] | 0) == 1) {
g[b + 240 >> 2] = 0;
g[b + 244 >> 2] = 0;
g[b + 256 >> 2] = 1;
g[b + 264 >> 2] = 1;
da = E + G;
ea = 0;
fa = 0;
ga = 1;
ha = 1
} else {
ia = +g[b + 124 >> 2];
ja = +g[b + 128 >> 2];
ka = ba * ia - M * ja;
la = M * ia + ba * ja;
ja = +g[b + 108 >> 2] - +g[v >>
2];
ia = +g[b + 112 >> 2] - +g[b + 196 >> 2];
ma = +g[b + 92 >> 2] - +g[u >> 2];
na = +g[b + 96 >> 2] - +g[b + 180 >> 2];
oa = +ka;
pa = +la;
u = b + 240 | 0;
g[u >> 2] = oa;
g[u + 4 >> 2] = pa;
pa = la * (ba * ja - M * ia) - ka * (M * ja + ba * ia);
g[b + 264 >> 2] = pa;
ia = la * ($ * ma - _ * na) - ka * (_ * ma + $ * na);
g[b + 256 >> 2] = ia;
da = C + A + pa * G * pa + ia * E * ia;
ea = ka;
fa = la;
ga = ia;
ha = pa
}
pa = da + 0;
g[s >> 2] = pa;
if ((c[b + 80 >> 2] | 0) == 1) {
g[b + 248 >> 2] = 0;
g[b + 252 >> 2] = 0;
da = +g[b + 152 >> 2];
g[b + 260 >> 2] = da;
g[b + 268 >> 2] = da;
qa = da * da * (F + H);
ra = 0;
sa = 0;
ta = da;
ua = da
} else {
da = +g[b + 132 >> 2];
ia = +g[b + 136 >> 2];
la = ca * da - Q * ia;
ka = Q * da + ca * ia;
ia = +g[b +
116 >> 2] - W;
W = +g[b + 120 >> 2] - +g[b + 204 >> 2];
da = +g[b + 100 >> 2] - +g[w >> 2];
na = +g[b + 104 >> 2] - +g[b + 188 >> 2];
$ = +g[b + 152 >> 2];
ma = la * $;
_ = ka * $;
ba = +ma;
ja = +_;
w = b + 248 | 0;
g[w >> 2] = ba;
g[w + 4 >> 2] = ja;
ja = (ka * (ca * ia - Q * W) - la * (Q * ia + ca * W)) * $;
g[b + 268 >> 2] = ja;
W = $ * (ka * (aa * da - I * na) - la * (I * da + aa * na));
g[b + 260 >> 2] = W;
qa = $ * $ * (D + B) + ja * H * ja + W * W * F;
ra = ma;
sa = _;
ta = W;
ua = ja
}
ja = pa + qa;
g[s >> 2] = ja;
if (ja > 0)
va = 1 / ja;
else
va = 0;
g[s >> 2] = va;
s = b + 156 | 0;
if ((a[d + 24 >> 0] | 0) == 0) {
g[s >> 2] = 0;
wa = J;
xa = K;
ya = N;
za = O;
Aa = R;
Ba = U;
Ca = X;
Da = Y;
Ea = L;
Fa = P;
Ga = V;
Ha = Z;
Ia = c[j >> 2] | 0;
Ja = c[o >>
2] | 0;
Ka = Ja + (Ia * 12 | 0) | 0;
La = +wa;
Ma = +xa;
Na = Ka;
Oa = Na;
g[Oa >> 2] = La;
Pa = Na + 4 | 0;
Qa = Pa;
g[Qa >> 2] = Ma;
Ra = c[j >> 2] | 0;
Sa = c[o >> 2] | 0;
Ta = Sa + (Ra * 12 | 0) + 8 | 0;
g[Ta >> 2] = Ea;
Ua = c[n >> 2] | 0;
Va = Sa + (Ua * 12 | 0) | 0;
Wa = +ya;
Xa = +za;
Ya = Va;
Za = Ya;
g[Za >> 2] = Wa;
_a = Ya + 4 | 0;
$a = _a;
g[$a >> 2] = Xa;
ab = c[n >> 2] | 0;
bb = c[o >> 2] | 0;
cb = bb + (ab * 12 | 0) + 8 | 0;
g[cb >> 2] = Fa;
db = c[q >> 2] | 0;
eb = bb + (db * 12 | 0) | 0;
fb = +Aa;
gb = +Ba;
hb = eb;
ib = hb;
g[ib >> 2] = fb;
jb = hb + 4 | 0;
kb = jb;
g[kb >> 2] = gb;
lb = c[q >> 2] | 0;
mb = c[o >> 2] | 0;
nb = mb + (lb * 12 | 0) + 8 | 0;
g[nb >> 2] = Ga;
ob = c[t >> 2] | 0;
pb = mb + (ob * 12 | 0) | 0;
qb = +Ca;
rb = +Da;
sb = pb;
tb = sb;
g[tb >> 2] = qb;
ub = sb + 4 | 0;
vb = ub;
g[vb >> 2] = rb;
wb = c[t >> 2] | 0;
xb = c[o >> 2] | 0;
yb = xb + (wb * 12 | 0) + 8 | 0;
g[yb >> 2] = Ha;
i = e;
return
} else {
va = +g[s >> 2];
ja = A * va;
A = va * B;
B = va * C;
C = va * D;
wa = J + ea * ja;
xa = K + ja * fa;
ya = N + ra * A;
za = O + A * sa;
Aa = R - ea * B;
Ba = U - fa * B;
Ca = X - ra * C;
Da = Y - sa * C;
Ea = L + va * E * ga;
Fa = P + va * F * ta;
Ga = V - va * G * ha;
Ha = Z - va * H * ua;
Ia = c[j >> 2] | 0;
Ja = c[o >> 2] | 0;
Ka = Ja + (Ia * 12 | 0) | 0;
La = +wa;
Ma = +xa;
Na = Ka;
Oa = Na;
g[Oa >> 2] = La;
Pa = Na + 4 | 0;
Qa = Pa;
g[Qa >> 2] = Ma;
Ra = c[j >> 2] | 0;
Sa = c[o >> 2] | 0;
Ta = Sa + (Ra * 12 | 0) + 8 | 0;
g[Ta >> 2] = Ea;
Ua = c[n >> 2] | 0;
Va = Sa + (Ua * 12 | 0) | 0;
Wa =
+ya;
Xa = +za;
Ya = Va;
Za = Ya;
g[Za >> 2] = Wa;
_a = Ya + 4 | 0;
$a = _a;
g[$a >> 2] = Xa;
ab = c[n >> 2] | 0;
bb = c[o >> 2] | 0;
cb = bb + (ab * 12 | 0) + 8 | 0;
g[cb >> 2] = Fa;
db = c[q >> 2] | 0;
eb = bb + (db * 12 | 0) | 0;
fb = +Aa;
gb = +Ba;
hb = eb;
ib = hb;
g[ib >> 2] = fb;
jb = hb + 4 | 0;
kb = jb;
g[kb >> 2] = gb;
lb = c[q >> 2] | 0;
mb = c[o >> 2] | 0;
nb = mb + (lb * 12 | 0) + 8 | 0;
g[nb >> 2] = Ga;
ob = c[t >> 2] | 0;
pb = mb + (ob * 12 | 0) | 0;
qb = +Ca;
rb = +Da;
sb = pb;
tb = sb;
g[tb >> 2] = qb;
ub = sb + 4 | 0;
vb = ub;
g[vb >> 2] = rb;
wb = c[t >> 2] | 0;
xb = c[o >> 2] | 0;
yb = xb + (wb * 12 | 0) + 8 | 0;
g[yb >> 2] = Ha;
i = e;
return
}
}
function Hg(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l =
0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0;
d = i;
e = a + 160 | 0;
f = c[e >> 2] | 0;
h = b + 32 | 0;
b = c[h >> 2] | 0;
j = b + (f * 12 | 0) | 0;
k = +g[j >> 2];
l = +g[j + 4 >> 2];
m = +g[b + (f * 12 | 0) + 8 >> 2];
f = a + 164 | 0;
j = c[f >> 2] | 0;
n = b + (j * 12 | 0) | 0;
o = +g[n >> 2];
p = +g[n + 4 >> 2];
q = +g[b + (j * 12 | 0) + 8 >> 2];
j = a + 168 | 0;
n = c[j >> 2] | 0;
r = b + (n * 12 | 0) | 0;
s = +g[r >> 2];
t = +g[r + 4 >> 2];
u = +g[b + (n * 12 | 0) + 8 >> 2];
n = a + 172 | 0;
r = c[n >> 2] | 0;
v = b + (r * 12 | 0) | 0;
w = +g[v >> 2];
x = +g[v + 4 >> 2];
y = +g[b + (r * 12 | 0) + 8 >> 2];
z = +g[a + 240 >> 2];
A = +g[a + 244 >> 2];
B = +g[a + 248 >> 2];
C =
+g[a + 252 >> 2];
D = +g[a + 256 >> 2];
E = +g[a + 264 >> 2];
F = +g[a + 260 >> 2];
G = +g[a + 268 >> 2];
H = +g[a + 272 >> 2] * ((k - s) * z + (l - t) * A + ((o - w) * B + (p - x) * C) + (m * D - u * E + (q * F - y * G)));
I = -H;
r = a + 156 | 0;
g[r >> 2] = +g[r >> 2] - H;
H = +g[a + 208 >> 2] * I;
J = m + +g[a + 224 >> 2] * I * D;
D = +g[a + 212 >> 2] * I;
m = q + +g[a + 228 >> 2] * I * F;
F = +g[a + 216 >> 2] * I;
q = u - +g[a + 232 >> 2] * I * E;
E = +g[a + 220 >> 2] * I;
u = y - +g[a + 236 >> 2] * I * G;
G = +(k + z * H);
k = +(l + A * H);
a = (c[h >> 2] | 0) + ((c[e >> 2] | 0) * 12 | 0) | 0;
g[a >> 2] = G;
g[a + 4 >> 2] = k;
a = c[h >> 2] | 0;
g[a + ((c[e >> 2] | 0) * 12 | 0) + 8 >> 2] = J;
J = +(o + B * D);
o = +(p + D * C);
e = a + ((c[f >> 2] | 0) * 12 | 0) | 0;
g[e >> 2] = J;
g[e + 4 >> 2] = o;
e = c[h >> 2] | 0;
g[e + ((c[f >> 2] | 0) * 12 | 0) + 8 >> 2] = m;
m = +(s - z * F);
z = +(t - A * F);
f = e + ((c[j >> 2] | 0) * 12 | 0) | 0;
g[f >> 2] = m;
g[f + 4 >> 2] = z;
f = c[h >> 2] | 0;
g[f + ((c[j >> 2] | 0) * 12 | 0) + 8 >> 2] = q;
q = +(w - B * E);
B = +(x - C * E);
j = f + ((c[n >> 2] | 0) * 12 | 0) | 0;
g[j >> 2] = q;
g[j + 4 >> 2] = B;
g[(c[h >> 2] | 0) + ((c[n >> 2] | 0) * 12 | 0) + 8 >> 2] = u;
i = d;
return
}
function Ig(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X =
0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0;
d = i;
e = a + 160 | 0;
f = c[e >> 2] | 0;
h = b + 28 | 0;
b = c[h >> 2] | 0;
j = b + (f * 12 | 0) | 0;
k = j;
l = +g[k >> 2];
m = +g[k + 4 >> 2];
n = +g[b + (f * 12 | 0) + 8 >> 2];
f = a + 164 | 0;
k = c[f >> 2] | 0;
o = b + (k * 12 | 0) | 0;
p = +g[o >> 2];
q = +g[o + 4 >> 2];
r = +g[b + (k * 12 | 0) + 8 >> 2];
k = a + 168 | 0;
o = c[k >> 2] | 0;
s = b + (o * 12 | 0) | 0;
t = +g[s >> 2];
u = +g[s + 4 >> 2];
v = +g[b + (o * 12 | 0) + 8 >> 2];
o = a + 172 | 0;
s = c[o >> 2] | 0;
w = b + (s * 12 | 0) | 0;
x = +g[w >> 2];
y = +g[w + 4 >> 2];
z = +g[b + (s * 12 | 0) + 8 >> 2];
A = +T(+n);
B = +S(+n);
C = +T(+r);
D = +S(+r);
E = +T(+v);
F = +S(+v);
G = +T(+z);
H = +S(+z);
if ((c[a + 76 >> 2] | 0) == 1) {
I = +g[a + 224 >> 2];
J = +g[a + 232 >> 2];
K = 0;
L = 0;
M = I;
N = J;
O = 1;
P = 1;
Q = n - v - +g[a + 140 >> 2];
R = I + J
} else {
J = +g[a + 124 >> 2];
I = +g[a + 128 >> 2];
U = F * J - E * I;
V = E * J + F * I;
W = +g[a + 108 >> 2] - +g[a + 192 >> 2];
X = +g[a + 112 >> 2] - +g[a + 196 >> 2];
Y = +g[a + 92 >> 2] - +g[a + 176 >> 2];
Z = +g[a + 96 >> 2] - +g[a + 180 >> 2];
_ = B * Y - A * Z;
$ = A * Y + B * Z;
Z = V * (F * W - E * X) - U * (E * W + F * X);
B = V * _ - U * $;
Y = +g[a + 232 >> 2];
A = +g[a + 224 >> 2];
aa = l - t + _;
_ = m - u + $;
K = U;
L = V;
M = A;
N = Y;
O = B;
P = Z;
Q = J * (F * aa + E * _ - W) + I * (F * _ - E * aa - X);
R = +g[a + 216 >> 2] + +g[a + 208 >> 2] + Z * Z * Y + B * A * B
}
if ((c[a + 80 >> 2] | 0) == 1) {
B = +g[a + 152 >> 2];
A = +g[a + 228 >> 2];
Y = +g[a + 236 >> 2];
ba = B * B * (A + Y);
ca = B;
da = 0;
ea = 0;
fa = A;
ga = Y;
ha = B;
ia = B;
ja = r - z - +g[a + 144 >> 2]
} else {
B = +g[a + 132 >> 2];
Y = +g[a + 136 >> 2];
A = H * B - G * Y;
Z = G * B + H * Y;
X = +g[a + 116 >> 2] - +g[a + 200 >> 2];
aa = +g[a + 120 >> 2] - +g[a + 204 >> 2];
E = +g[a + 100 >> 2] - +g[a + 184 >> 2];
_ = +g[a + 104 >> 2] - +g[a + 188 >> 2];
F = D * E - C * _;
I = C * E + D * _;
_ = +g[a + 152 >> 2];
D = _ * (Z * (H * X - G * aa) - A * (G * X + H * aa));
E = _ * (Z * F - A * I);
C = +g[a + 236 >> 2];
W = +g[a + 228 >> 2];
J = p - x + F;
F = q - y + I;
ba = _ * _ * (+g[a + 220 >> 2] + +g[a + 212 >> 2]) + D * D * C + E * W * E;
ca = _;
da = A * _;
ea = Z * _;
fa = W;
ga = C;
ha = E;
ia = D;
ja = B * (H * J + G * F - X) + Y * (H *
F - G * J - aa)
}
aa = R + 0 + ba;
if (aa > 0)
ka = -(Q + ja * ca - +g[a + 148 >> 2]) / aa;
else
ka = 0;
aa = ka * +g[a + 208 >> 2];
ca = ka * +g[a + 212 >> 2];
ja = ka * +g[a + 216 >> 2];
Q = ka * +g[a + 220 >> 2];
ba = +(l + K * aa);
l = +(m + L * aa);
a = j;
g[a >> 2] = ba;
g[a + 4 >> 2] = l;
a = c[h >> 2] | 0;
g[a + ((c[e >> 2] | 0) * 12 | 0) + 8 >> 2] = n + O * ka * M;
M = +(p + da * ca);
p = +(q + ea * ca);
e = a + ((c[f >> 2] | 0) * 12 | 0) | 0;
g[e >> 2] = M;
g[e + 4 >> 2] = p;
e = c[h >> 2] | 0;
g[e + ((c[f >> 2] | 0) * 12 | 0) + 8 >> 2] = r + ha * ka * fa;
fa = +(t - K * ja);
K = +(u - L * ja);
f = e + ((c[k >> 2] | 0) * 12 | 0) | 0;
g[f >> 2] = fa;
g[f + 4 >> 2] = K;
f = c[h >> 2] | 0;
g[f + ((c[k >> 2] | 0) * 12 | 0) + 8 >> 2] = v - P * ka * N;
N = +(x - da *
Q);
da = +(y - ea * Q);
k = f + ((c[o >> 2] | 0) * 12 | 0) | 0;
g[k >> 2] = N;
g[k + 4 >> 2] = da;
g[(c[h >> 2] | 0) + ((c[o >> 2] | 0) * 12 | 0) + 8 >> 2] = z - ia * ka * ga;
i = d;
return 1
}
function Jg(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 48 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 92 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 96 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function Kg(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 52 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 100 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 104 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e *
f - h * i);
g[a + 4 >> 2] = j;
return
}
function Lg(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
var d = 0,
e = 0;
d = +g[b + 156 >> 2];
e = d * +g[b + 244 >> 2] * c;
g[a >> 2] = d * +g[b + 240 >> 2] * c;
g[a + 4 >> 2] = e;
return
}
function Mg(a, b) {
a = a | 0;
b = +b;
return +(+g[a + 156 >> 2] * +g[a + 256 >> 2] * b)
}
function Ng(a) {
a = a | 0;
return ++g[a + 152 >> 2]
}
function Og(a) {
a = a | 0;
var b = 0,
e = 0,
f = 0,
j = 0,
l = 0,
m = 0;
b = i;
i = i + 16 | 0;
e = b;
f = c[(c[a + 48 >> 2] | 0) + 8 >> 2] | 0;
j = c[(c[a + 52 >> 2] | 0) + 8 >> 2] | 0;
l = c[(c[a + 68 >> 2] | 0) + 56 >> 2] | 0;
m = c[(c[a + 72 >> 2] | 0) + 56 >> 2] | 0;
Rm(2912, e);
c[e >> 2] = f;
Rm(2936, e);
c[e >> 2] = j;
Rm(2968, e);
c[e >> 2] = d[a + 61 >>
0] | 0;
Rm(3E3, e);
c[e >> 2] = l;
Rm(3040, e);
c[e >> 2] = m;
Rm(3072, e);
h[k >> 3] = +g[a + 152 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(3104, e);
c[e >> 2] = c[a + 56 >> 2];
Rm(3128, e);
i = b;
return
}
function Pg(a) {
a = a | 0;
return
}
function Qg(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Rg(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0;
h = i;
c[a + 8 >> 2] = b;
c[a + 12 >> 2] = d;
j = +g[e >> 2] - +g[b + 12 >> 2];
k = e + 4 | 0;
l = +g[k >> 2] - +g[b + 16 >> 2];
m = b + 24 | 0;
n = +g[m >> 2];
o = b + 20 | 0;
p = +g[o >> 2];
q = +(j * n + l * p);
r = +(n * l - j * p);
s = a + 20 |
0;
g[s >> 2] = q;
g[s + 4 >> 2] = r;
r = +g[e >> 2] - +g[d + 12 >> 2];
q = +g[k >> 2] - +g[d + 16 >> 2];
p = +g[d + 24 >> 2];
j = +g[d + 20 >> 2];
l = +(r * p + q * j);
n = +(p * q - r * j);
k = a + 28 | 0;
g[k >> 2] = l;
g[k + 4 >> 2] = n;
n = +g[m >> 2];
l = +g[f >> 2];
j = +g[o >> 2];
r = +g[f + 4 >> 2];
q = +(n * l + j * r);
p = +(n * r - l * j);
f = a + 36 | 0;
g[f >> 2] = q;
g[f + 4 >> 2] = p;
g[a + 44 >> 2] = +g[d + 72 >> 2] - +g[b + 72 >> 2];
i = h;
return
}
function Sg(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0;
e = i;
vh(b, d);
c[b >> 2] = 3216;
f = b + 84 | 0;
h = d + 20 | 0;
j = c[h + 4 >> 2] | 0;
l = b + 68 | 0;
c[l >> 2] = c[h >> 2];
c[l + 4 >> 2] = j;
j = d + 28 | 0;
l = c[j + 4 >> 2] | 0;
h = b +
76 | 0;
c[h >> 2] = c[j >> 2];
c[h + 4 >> 2] = l;
l = d + 36 | 0;
h = c[l >> 2] | 0;
j = c[l + 4 >> 2] | 0;
l = f;
c[l >> 2] = h;
c[l + 4 >> 2] = j;
m = (c[k >> 2] = h, +g[k >> 2]);
n = (c[k >> 2] = j, +g[k >> 2]);
o = +Q(+(m * m + n * n));
if (o < 1.1920928955078125E-7) {
p = n;
q = m
} else {
r = 1 / o;
o = m * r;
g[f >> 2] = o;
m = n * r;
g[b + 88 >> 2] = m;
p = m;
q = o
}
o = +-p;
p = +q;
f = b + 92 | 0;
g[f >> 2] = o;
g[f + 4 >> 2] = p;
g[b + 100 >> 2] = +g[d + 44 >> 2];
f = b + 104 | 0;
g[b + 252 >> 2] = 0;
j = d + 52 | 0;
c[f + 0 >> 2] = 0;
c[f + 4 >> 2] = 0;
c[f + 8 >> 2] = 0;
c[f + 12 >> 2] = 0;
g[b + 120 >> 2] = +g[j >> 2];
g[b + 124 >> 2] = +g[d + 56 >> 2];
g[b + 128 >> 2] = +g[d + 64 >> 2];
g[b + 132 >> 2] = +g[d + 68 >> 2];
a[b + 136 >> 0] = a[d +
48 >> 0] | 0;
a[b + 137 >> 0] = a[d + 60 >> 0] | 0;
c[b + 140 >> 2] = 0;
d = b + 184 | 0;
c[d + 0 >> 2] = 0;
c[d + 4 >> 2] = 0;
c[d + 8 >> 2] = 0;
c[d + 12 >> 2] = 0;
i = e;
return
}
function Tg(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0,
ya = 0,
za = 0,
Aa = 0,
Ba = 0,
Ca = 0,
Da = 0;
e = i;
f = c[b + 48 >> 2] | 0;
h =
c[f + 8 >> 2] | 0;
j = b + 144 | 0;
c[j >> 2] = h;
l = c[b + 52 >> 2] | 0;
m = c[l + 8 >> 2] | 0;
n = b + 148 | 0;
c[n >> 2] = m;
o = f + 44 | 0;
p = c[o >> 2] | 0;
q = c[o + 4 >> 2] | 0;
o = b + 152 | 0;
c[o >> 2] = p;
c[o + 4 >> 2] = q;
o = l + 44 | 0;
r = c[o >> 2] | 0;
s = c[o + 4 >> 2] | 0;
o = b + 160 | 0;
c[o >> 2] = r;
c[o + 4 >> 2] = s;
o = b + 168 | 0;
g[o >> 2] = +g[f + 136 >> 2];
t = b + 172 | 0;
g[t >> 2] = +g[l + 136 >> 2];
u = +g[f + 144 >> 2];
g[b + 176 >> 2] = u;
v = +g[l + 144 >> 2];
g[b + 180 >> 2] = v;
l = c[d + 28 >> 2] | 0;
f = l + (h * 12 | 0) | 0;
w = +g[f >> 2];
x = +g[f + 4 >> 2];
y = +g[l + (h * 12 | 0) + 8 >> 2];
f = d + 32 | 0;
z = c[f >> 2] | 0;
A = z + (h * 12 | 0) | 0;
B = +g[A >> 2];
C = +g[A + 4 >> 2];
D = +g[z + (h * 12 | 0) + 8 >> 2];
h = l + (m * 12 |
0) | 0;
E = +g[h >> 2];
F = +g[h + 4 >> 2];
G = +g[l + (m * 12 | 0) + 8 >> 2];
l = z + (m * 12 | 0) | 0;
H = +g[l >> 2];
I = +g[l + 4 >> 2];
J = +g[z + (m * 12 | 0) + 8 >> 2];
K = +T(+y);
L = +S(+y);
y = +T(+G);
M = +S(+G);
G = +g[b + 68 >> 2] - (c[k >> 2] = p, +g[k >> 2]);
N = +g[b + 72 >> 2] - (c[k >> 2] = q, +g[k >> 2]);
O = L * G - K * N;
P = K * G + L * N;
N = +g[b + 76 >> 2] - (c[k >> 2] = r, +g[k >> 2]);
G = +g[b + 80 >> 2] - (c[k >> 2] = s, +g[k >> 2]);
Q = M * N - y * G;
R = y * N + M * G;
G = E - w + Q - O;
w = F - x + R - P;
x = +g[o >> 2];
F = +g[t >> 2];
E = +g[b + 84 >> 2];
M = +g[b + 88 >> 2];
N = L * E - K * M;
y = K * E + L * M;
M = +N;
E = +y;
t = b + 184 | 0;
g[t >> 2] = M;
g[t + 4 >> 2] = E;
E = O + G;
O = P + w;
P = E * y - O * N;
g[b + 208 >> 2] = P;
M = Q * y -
R * N;
g[b + 212 >> 2] = M;
U = x + F;
V = u * P;
W = v * M;
X = U + P * V + M * W;
if (X > 0)
Y = 1 / X;
else
Y = X;
g[b + 252 >> 2] = Y;
Y = +g[b + 92 >> 2];
Z = +g[b + 96 >> 2];
_ = L * Y - K * Z;
$ = K * Y + L * Z;
Z = +_;
L = +$;
t = b + 192 | 0;
g[t >> 2] = Z;
g[t + 4 >> 2] = L;
L = E * $ - O * _;
g[b + 200 >> 2] = L;
O = Q * $ - R * _;
g[b + 204 >> 2] = O;
R = u * L;
Q = v * O;
E = R + Q;
Z = R * P + Q * M;
Y = v + u;
K = V + W;
g[b + 216 >> 2] = U + L * R + O * Q;
g[b + 220 >> 2] = E;
g[b + 224 >> 2] = Z;
g[b + 228 >> 2] = E;
g[b + 232 >> 2] = Y == 0 ? 1 : Y;
g[b + 236 >> 2] = K;
g[b + 240 >> 2] = Z;
g[b + 244 >> 2] = K;
g[b + 248 >> 2] = X;
do if ((a[b + 136 >> 0] | 0) != 0) {
X = G * N + w * y;
K = +g[b + 124 >> 2];
Z = +g[b + 120 >> 2];
Y = K - Z;
if (Y > 0)
aa = Y;
else
aa = -Y;
if (aa <
.009999999776482582) {
c[b + 140 >> 2] = 3;
break
}
if (X <= Z) {
t = b + 140 | 0;
if ((c[t >> 2] | 0) == 1)
break;
c[t >> 2] = 1;
g[b + 112 >> 2] = 0;
break
}
t = b + 140 | 0;
if (!(X >= K)) {
c[t >> 2] = 0;
g[b + 112 >> 2] = 0;
break
}
if ((c[t >> 2] | 0) != 2) {
c[t >> 2] = 2;
g[b + 112 >> 2] = 0
}
} else {
c[b + 140 >> 2] = 0;
g[b + 112 >> 2] = 0
}
while (0);
if ((a[b + 137 >> 0] | 0) == 0)
g[b + 116 >> 2] = 0;
t = b + 104 | 0;
if ((a[d + 24 >> 0] | 0) == 0) {
c[t + 0 >> 2] = 0;
c[t + 4 >> 2] = 0;
c[t + 8 >> 2] = 0;
c[t + 12 >> 2] = 0;
ba = B;
ca = C;
da = H;
ea = I;
fa = D;
ga = J;
ha = c[j >> 2] | 0;
ia = c[f >> 2] | 0;
ja = ia + (ha * 12 | 0) | 0;
ka = +ba;
la = +ca;
ma = ja;
na = ma;
g[na >> 2] = ka;
oa = ma + 4 | 0;
pa = oa;
g[pa >>
2] = la;
qa = c[j >> 2] | 0;
ra = c[f >> 2] | 0;
sa = ra + (qa * 12 | 0) + 8 | 0;
g[sa >> 2] = fa;
ta = c[n >> 2] | 0;
ua = ra + (ta * 12 | 0) | 0;
va = +da;
wa = +ea;
xa = ua;
ya = xa;
g[ya >> 2] = va;
za = xa + 4 | 0;
Aa = za;
g[Aa >> 2] = wa;
Ba = c[n >> 2] | 0;
Ca = c[f >> 2] | 0;
Da = Ca + (Ba * 12 | 0) + 8 | 0;
g[Da >> 2] = ga;
i = e;
return
} else {
o = d + 8 | 0;
aa = +g[o >> 2];
w = aa * +g[t >> 2];
g[t >> 2] = w;
t = b + 108 | 0;
G = aa * +g[t >> 2];
g[t >> 2] = G;
t = b + 112 | 0;
K = aa * +g[t >> 2];
g[t >> 2] = K;
t = b + 116 | 0;
aa = +g[o >> 2] * +g[t >> 2];
g[t >> 2] = aa;
X = aa + K;
K = w * _ + N * X;
N = w * $ + X * y;
ba = B - x * K;
ca = C - x * N;
da = H + F * K;
ea = I + F * N;
fa = D - u * (w * L + G + X * P);
ga = J + v * (G + w * O + X * M);
ha = c[j >> 2] |
0;
ia = c[f >> 2] | 0;
ja = ia + (ha * 12 | 0) | 0;
ka = +ba;
la = +ca;
ma = ja;
na = ma;
g[na >> 2] = ka;
oa = ma + 4 | 0;
pa = oa;
g[pa >> 2] = la;
qa = c[j >> 2] | 0;
ra = c[f >> 2] | 0;
sa = ra + (qa * 12 | 0) + 8 | 0;
g[sa >> 2] = fa;
ta = c[n >> 2] | 0;
ua = ra + (ta * 12 | 0) | 0;
va = +da;
wa = +ea;
xa = ua;
ya = xa;
g[ya >> 2] = va;
za = xa + 4 | 0;
Aa = za;
g[Aa >> 2] = wa;
Ba = c[n >> 2] | 0;
Ca = c[f >> 2] | 0;
Da = Ca + (Ba * 12 | 0) + 8 | 0;
g[Da >> 2] = ga;
i = e;
return
}
}
function Ug(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0,
ya = 0,
za = 0,
Aa = 0,
Ba = 0,
Ca = 0,
Da = 0,
Ea = 0,
Fa = 0,
Ga = 0,
Ha = 0,
Ia = 0,
Ja = 0,
Ka = 0,
La = 0,
Ma = 0,
Na = 0,
Oa = 0;
e = i;
i = i + 64 | 0;
f = e + 44 | 0;
h = e + 32 | 0;
j = e + 24 | 0;
k = e + 16 | 0;
l = e + 8 | 0;
m = e;
n = b + 144 | 0;
o = c[n >> 2] | 0;
p = d + 32 | 0;
q = c[p >> 2] | 0;
r = q + (o * 12 | 0) | 0;
s = +g[r >> 2];
t = +g[r + 4 >> 2];
u = +g[q + (o * 12 | 0) + 8 >> 2];
o = b + 148 | 0;
r = c[o >> 2] | 0;
v = q + (r * 12 | 0) | 0;
w = +g[v >> 2];
x = +g[v + 4 >> 2];
y = +g[q + (r * 12 | 0) + 8 >> 2];
z = +g[b + 168 >> 2];
A = +g[b + 172 >> 2];
B = +g[b + 176 >> 2];
C = +g[b + 180 >> 2];
if ((a[b + 137 >> 0] | 0) != 0 ? (c[b + 140 >> 2] | 0) != 3 : 0) {
D = +g[b + 184 >> 2];
E = +g[b + 188 >> 2];
F = +g[b + 212 >> 2];
G = +g[b + 208 >> 2];
r = b + 116 | 0;
H = +g[r >> 2];
I = +g[d >> 2] * +g[b + 128 >> 2];
J = H + +g[b + 252 >> 2] * (+g[b + 132 >> 2] - ((w - s) * D + (x - t) * E + y * F - u * G));
K = -I;
L = J < I ? J : I;
I = L < K ? K : L;
g[r >> 2] = I;
L = I - H;
H = D * L;
D = E * L;
M = t - z * D;
N = x + A * D;
O = s - z * H;
P = w + A * H;
Q = u - B * G * L;
R = y + C * F * L
} else {
M = t;
N = x;
O = s;
P = w;
Q = u;
R = y
}
y = P - O;
u = N - M;
r = b + 192 | 0;
d = b + 196 | 0;
q = b + 204 | 0;
v = b + 200 | 0;
w = y * +g[r >> 2] + u * +g[d >> 2] + R * +g[q >> 2] - Q * +g[v >> 2];
s =
R - Q;
if ((a[b + 136 >> 0] | 0) != 0 ? (S = b + 140 | 0, (c[S >> 2] | 0) != 0) : 0) {
T = b + 184 | 0;
U = b + 188 | 0;
V = b + 212 | 0;
W = b + 208 | 0;
X = b + 104 | 0;
x = +g[X >> 2];
Y = b + 108 | 0;
t = +g[Y >> 2];
Z = b + 112 | 0;
L = +g[Z >> 2];
_ = b + 216 | 0;
F = -w;
G = -s;
H = -(y * +g[T >> 2] + u * +g[U >> 2] + R * +g[V >> 2] - Q * +g[W >> 2]);
g[h >> 2] = F;
g[h + 4 >> 2] = G;
g[h + 8 >> 2] = H;
Gm(f, _, h);
g[X >> 2] = +g[f >> 2] + +g[X >> 2];
h = f + 4 | 0;
g[Y >> 2] = +g[h >> 2] + +g[Y >> 2];
$ = f + 8 | 0;
H = +g[$ >> 2] + +g[Z >> 2];
g[Z >> 2] = H;
aa = c[S >> 2] | 0;
if ((aa | 0) == 2) {
u = H < 0 ? H : 0;
g[Z >> 2] = u;
ba = u
} else if ((aa | 0) == 1) {
u = H > 0 ? H : 0;
g[Z >> 2] = u;
ba = u
} else
ba = H;
H = ba - L;
ba = G - H * +g[b + 244 >>
2];
g[j >> 2] = F - +g[b + 240 >> 2] * H;
g[j + 4 >> 2] = ba;
Hm(k, _, j);
ba = x + +g[k >> 2];
H = t + +g[k + 4 >> 2];
g[X >> 2] = ba;
g[Y >> 2] = H;
F = ba - x;
x = H - t;
t = +g[Z >> 2] - L;
g[f >> 2] = F;
g[h >> 2] = x;
g[$ >> 2] = t;
ca = x + F * +g[q >> 2] + t * +g[V >> 2];
da = F * +g[r >> 2] + t * +g[T >> 2];
ea = F * +g[v >> 2] + x + t * +g[W >> 2];
fa = F * +g[d >> 2] + t * +g[U >> 2];
ga = z * fa;
ha = z * da;
ia = O - ha;
ja = M - ga;
ka = A * da;
la = A * fa;
ma = P + ka;
na = N + la;
oa = B * ea;
pa = C * ca;
qa = Q - oa;
ra = R + pa;
sa = c[n >> 2] | 0;
ta = c[p >> 2] | 0;
ua = ta + (sa * 12 | 0) | 0;
va = +ia;
wa = +ja;
xa = ua;
ya = xa;
g[ya >> 2] = va;
za = xa + 4 | 0;
Aa = za;
g[Aa >> 2] = wa;
Ba = c[n >> 2] | 0;
Ca = c[p >> 2] | 0;
Da = Ca +
(Ba * 12 | 0) + 8 | 0;
g[Da >> 2] = qa;
Ea = c[o >> 2] | 0;
Fa = Ca + (Ea * 12 | 0) | 0;
Ga = +ma;
Ha = +na;
Ia = Fa;
Ja = Ia;
g[Ja >> 2] = Ga;
Ka = Ia + 4 | 0;
La = Ka;
g[La >> 2] = Ha;
Ma = c[o >> 2] | 0;
Na = c[p >> 2] | 0;
Oa = Na + (Ma * 12 | 0) + 8 | 0;
g[Oa >> 2] = ra;
i = e;
return
}
g[m >> 2] = -w;
g[m + 4 >> 2] = -s;
Hm(l, b + 216 | 0, m);
s = +g[l >> 2];
m = b + 104 | 0;
g[m >> 2] = s + +g[m >> 2];
w = +g[l + 4 >> 2];
l = b + 108 | 0;
g[l >> 2] = w + +g[l >> 2];
ca = w + s * +g[q >> 2];
da = s * +g[r >> 2];
ea = s * +g[v >> 2] + w;
fa = s * +g[d >> 2];
ga = z * fa;
ha = z * da;
ia = O - ha;
ja = M - ga;
ka = A * da;
la = A * fa;
ma = P + ka;
na = N + la;
oa = B * ea;
pa = C * ca;
qa = Q - oa;
ra = R + pa;
sa = c[n >> 2] | 0;
ta = c[p >> 2] | 0;
ua =
ta + (sa * 12 | 0) | 0;
va = +ia;
wa = +ja;
xa = ua;
ya = xa;
g[ya >> 2] = va;
za = xa + 4 | 0;
Aa = za;
g[Aa >> 2] = wa;
Ba = c[n >> 2] | 0;
Ca = c[p >> 2] | 0;
Da = Ca + (Ba * 12 | 0) + 8 | 0;
g[Da >> 2] = qa;
Ea = c[o >> 2] | 0;
Fa = Ca + (Ea * 12 | 0) | 0;
Ga = +ma;
Ha = +na;
Ia = Fa;
Ja = Ia;
g[Ja >> 2] = Ga;
Ka = Ia + 4 | 0;
La = Ka;
g[La >> 2] = Ha;
Ma = c[o >> 2] | 0;
Na = c[p >> 2] | 0;
Oa = Na + (Ma * 12 | 0) + 8 | 0;
g[Oa >> 2] = ra;
i = e;
return
}
function Vg(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0;
e = i;
i = i + 64 | 0;
f = e + 24 | 0;
h = e + 12 | 0;
j = e;
k = b + 144 | 0;
l = c[k >> 2] | 0;
m = d + 28 | 0;
d = c[m >> 2] | 0;
n = d + (l * 12 | 0) | 0;
o = +g[n >> 2];
p = +g[n + 4 >> 2];
q = +g[d + (l * 12 | 0) + 8 >> 2];
l = b + 148 | 0;
n = c[l >> 2] | 0;
r = d + (n * 12 | 0) | 0;
s = +g[r >> 2];
t = +g[r + 4 >> 2];
u = +g[d + (n * 12 | 0) + 8 >> 2];
v = +T(+q);
w = +S(+q);
x = +T(+u);
y = +S(+u);
z = +g[b + 168 >> 2];
A = +g[b + 172 >> 2];
B = +g[b + 176 >> 2];
C = +g[b + 180 >> 2];
D = +g[b + 68 >> 2] - +g[b + 152 >> 2];
E = +g[b + 72 >> 2] - +g[b + 156 >> 2];
F = w * D - v * E;
G = v * D + w * E;
E = +g[b + 76 >> 2] - +g[b + 160 >> 2];
D = +g[b + 80 >> 2] - +g[b + 164 >> 2];
H = y * E - x * D;
I = x * E + y * D;
D = s + H -
o - F;
y = t + I - p - G;
E = +g[b + 84 >> 2];
x = +g[b + 88 >> 2];
J = w * E - v * x;
K = v * E + w * x;
x = F + D;
F = G + y;
G = K * x - J * F;
E = H * K - I * J;
L = +g[b + 92 >> 2];
M = +g[b + 96 >> 2];
N = w * L - v * M;
O = v * L + w * M;
M = O * x - N * F;
F = H * O - I * N;
I = N * D + O * y;
H = u - q - +g[b + 100 >> 2];
if (I > 0)
P = I;
else
P = -I;
if (H > 0)
Q = H;
else
Q = -H;
do if ((a[b + 136 >> 0] | 0) != 0) {
x = J * D + K * y;
w = +g[b + 124 >> 2];
L = +g[b + 120 >> 2];
v = w - L;
if (v > 0)
R = v;
else
R = -v;
if (R < .009999999776482582) {
v = x < .20000000298023224 ? x : .20000000298023224;
if (x > 0)
U = x;
else
U = -x;
V = v < -.20000000298023224 ? -.20000000298023224 : v;
W = 1;
X = P > U ? P : U;
break
}
if (x <= L) {
v = x - L + .004999999888241291;
Y = v < 0 ? v : 0;
v = L - x;
V = Y < -.20000000298023224 ? -.20000000298023224 : Y;
W = 1;
X = P > v ? P : v;
break
}
if (x >= w) {
v = x - w;
w = v + -.004999999888241291;
x = w < .20000000298023224 ? w : .20000000298023224;
V = x < 0 ? 0 : x;
W = 1;
X = P > v ? P : v
} else {
V = 0;
W = 0;
X = P
}
} else {
V = 0;
W = 0;
X = P
}
while (0);
P = z + A;
U = B * M;
R = C * F;
y = F * R + (P + M * U);
D = R + U;
if (W) {
v = E * R + G * U;
U = B + C;
R = B * G;
x = C * E;
w = x + R;
g[f >> 2] = y;
g[f + 4 >> 2] = D;
g[f + 8 >> 2] = v;
g[f + 12 >> 2] = D;
g[f + 16 >> 2] = U == 0 ? 1 : U;
g[f + 20 >> 2] = w;
g[f + 24 >> 2] = v;
g[f + 28 >> 2] = w;
g[f + 32 >> 2] = E * x + (P + G * R);
g[j >> 2] = -I;
g[j + 4 >> 2] = -H;
g[j + 8 >> 2] = -V;
Gm(h, f, j);
Z = +g[h >> 2];
_ =
+g[h + 8 >> 2];
$ = +g[h + 4 >> 2]
} else {
V = B + C;
R = V == 0 ? 1 : V;
V = -I;
I = -H;
H = R * y - D * D;
if (H != 0)
aa = 1 / H;
else
aa = H;
Z = (R * V - D * I) * aa;
_ = 0;
$ = (y * I - D * V) * aa
}
aa = J * _ + N * Z;
N = K * _ + O * Z;
O = +(o - z * aa);
o = +(p - z * N);
h = (c[m >> 2] | 0) + ((c[k >> 2] | 0) * 12 | 0) | 0;
g[h >> 2] = O;
g[h + 4 >> 2] = o;
h = c[m >> 2] | 0;
g[h + ((c[k >> 2] | 0) * 12 | 0) + 8 >> 2] = q - B * (G * _ + ($ + M * Z));
M = +(s + A * aa);
aa = +(t + A * N);
k = h + ((c[l >> 2] | 0) * 12 | 0) | 0;
g[k >> 2] = M;
g[k + 4 >> 2] = aa;
g[(c[m >> 2] | 0) + ((c[l >> 2] | 0) * 12 | 0) + 8 >> 2] = u + C * (E * _ + ($ + F * Z));
if (!(X <= .004999999888241291)) {
ba = 0;
i = e;
return ba | 0
}
ba = Q <= .03490658849477768;
i = e;
return ba |
0
}
function Wg(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 48 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 68 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 72 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function Xg(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 52 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 76 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 80 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function Yg(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
var d = 0,
e = 0,
f = 0;
d = +g[b + 104 >> 2];
e = +g[b + 116 >> 2] + +g[b + 112 >> 2];
f = (d *
+g[b + 196 >> 2] + e * +g[b + 188 >> 2]) * c;
g[a >> 2] = (d * +g[b + 192 >> 2] + +g[b + 184 >> 2] * e) * c;
g[a + 4 >> 2] = f;
return
}
function Zg(a, b) {
a = a | 0;
b = +b;
return +(+g[a + 108 >> 2] * b)
}
function _g(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0;
b = c[a + 48 >> 2] | 0;
d = +g[b + 24 >> 2];
e = +g[a + 68 >> 2];
f = +g[b + 20 >> 2];
h = +g[a + 72 >> 2];
i = c[a + 52 >> 2] | 0;
j = +g[i + 24 >> 2];
k = +g[a + 76 >> 2];
l = +g[i + 20 >> 2];
m = +g[a + 80 >> 2];
n = +g[a + 84 >> 2];
o = +g[a + 88 >> 2];
return +((+g[i + 12 >> 2] + (j * k - l * m) - (+g[b + 12 >> 2] + (d * e - f * h))) * (d * n - f * o) + (k * l + j * m + +g[i + 16 >> 2] - (e * f + d * h + +g[b + 16 >> 2])) * (f *
n + d * o))
}
function $g(b) {
b = b | 0;
return (a[b + 136 >> 0] | 0) != 0 | 0
}
function ah(f, h) {
f = f | 0;
h = h | 0;
var j = 0,
k = 0,
l = 0,
m = 0,
n = 0;
j = i;
k = f + 136 | 0;
if ((h & 1 | 0) == (d[k >> 0] | 0 | 0)) {
i = j;
return
}
l = c[f + 48 >> 2] | 0;
m = l + 4 | 0;
n = e[m >> 1] | 0;
if ((n & 2 | 0) == 0) {
b[m >> 1] = n | 2;
g[l + 160 >> 2] = 0
}
l = c[f + 52 >> 2] | 0;
n = l + 4 | 0;
m = e[n >> 1] | 0;
if ((m & 2 | 0) == 0) {
b[n >> 1] = m | 2;
g[l + 160 >> 2] = 0
}
a[k >> 0] = h & 1;
g[f + 112 >> 2] = 0;
i = j;
return
}
function bh(b) {
b = b | 0;
return (a[b + 137 >> 0] | 0) != 0 | 0
}
function ch(d, f) {
d = d | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0;
h = i;
j = c[d + 48 >> 2] | 0;
k = j + 4 | 0;
l = e[k >> 1] | 0;
if ((l & 2 |
0) == 0) {
b[k >> 1] = l | 2;
g[j + 160 >> 2] = 0
}
j = c[d + 52 >> 2] | 0;
l = j + 4 | 0;
k = e[l >> 1] | 0;
if ((k & 2 | 0) != 0) {
m = d + 137 | 0;
n = f & 1;
a[m >> 0] = n;
i = h;
return
}
b[l >> 1] = k | 2;
g[j + 160 >> 2] = 0;
m = d + 137 | 0;
n = f & 1;
a[m >> 0] = n;
i = h;
return
}
function dh(a, d) {
a = a | 0;
d = +d;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0;
f = i;
h = c[a + 48 >> 2] | 0;
j = h + 4 | 0;
k = e[j >> 1] | 0;
if ((k & 2 | 0) == 0) {
b[j >> 1] = k | 2;
g[h + 160 >> 2] = 0
}
h = c[a + 52 >> 2] | 0;
k = h + 4 | 0;
j = e[k >> 1] | 0;
if ((j & 2 | 0) != 0) {
l = a + 132 | 0;
g[l >> 2] = d;
i = f;
return
}
b[k >> 1] = j | 2;
g[h + 160 >> 2] = 0;
l = a + 132 | 0;
g[l >> 2] = d;
i = f;
return
}
function eh(a, b) {
a = a | 0;
b = +b;
return +(+g[a + 116 >> 2] *
b)
}
function fh(a) {
a = a | 0;
var b = 0,
e = 0,
f = 0,
j = 0,
l = 0;
b = i;
i = i + 16 | 0;
e = b;
f = c[(c[a + 48 >> 2] | 0) + 8 >> 2] | 0;
j = c[(c[a + 52 >> 2] | 0) + 8 >> 2] | 0;
Rm(3264, e);
c[e >> 2] = f;
Rm(3296, e);
c[e >> 2] = j;
Rm(3328, e);
c[e >> 2] = d[a + 61 >> 0] | 0;
Rm(3360, e);
l = +g[a + 72 >> 2];
h[k >> 3] = +g[a + 68 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(3400, e);
l = +g[a + 80 >> 2];
h[k >> 3] = +g[a + 76 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(3448, e);
l = +g[a + 88 >> 2];
h[k >> 3] = +g[a +
84 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(3496, e);
h[k >> 3] = +g[a + 100 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(3536, e);
c[e >> 2] = d[a + 136 >> 0] | 0;
Rm(3568, e);
h[k >> 3] = +g[a + 120 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(3600, e);
h[k >> 3] = +g[a + 124 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(3640, e);
c[e >> 2] = d[a + 137 >> 0] | 0;
Rm(3680, e);
h[k >> 3] = +g[a + 132 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(3712, e);
h[k >> 3] = +g[a + 128 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(3744, e);
c[e >> 2] = c[a + 56 >> 2];
Rm(3776, e);
i = b;
return
}
function gh(a) {
a = a | 0;
return
}
function hh(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function ih(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0;
d = i;
vh(a, b);
c[a >> 2] = 3872;
e = b + 20 | 0;
f = c[e + 4 >> 2] | 0;
h = a + 68 | 0;
c[h >> 2] = c[e >> 2];
c[h + 4 >> 2] = f;
f = b + 28 | 0;
h = c[f + 4 >> 2] | 0;
e = a + 76 | 0;
c[e >> 2] = c[f >> 2];
c[e + 4 >> 2] = h;
g[a + 84 >> 2] = +g[b + 36 >> 2];
g[a + 160 >> 2] = 0;
g[a + 92 >> 2] = 0;
c[a + 164 >> 2] = 0;
g[a + 88 >> 2] = 0;
i = d;
return
}
function jh(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0;
e = i;
f = c[b + 48 >> 2] | 0;
h = c[f + 8 >> 2] | 0;
j = b + 96 | 0;
c[j >> 2] = h;
l = c[b + 52 >> 2] | 0;
m = c[l + 8 >> 2] | 0;
n = b + 100 | 0;
c[n >> 2] = m;
o = f + 44 | 0;
p = c[o >> 2] | 0;
q = c[o + 4 >> 2] | 0;
o = b + 128 | 0;
c[o >> 2] = p;
c[o + 4 >> 2] = q;
o = l + 44 | 0;
r = c[o >> 2] | 0;
s = c[o + 4 >> 2] | 0;
o = b + 136 | 0;
c[o >> 2] = r;
c[o + 4 >> 2] = s;
s = b + 144 | 0;
g[s >> 2] = +g[f + 136 >> 2];
o = b + 148 | 0;
g[o >> 2] = +g[l + 136 >> 2];
t = b + 152 | 0;
g[t >> 2] = +g[f + 144 >> 2];
f = b + 156 | 0;
g[f >> 2] = +g[l + 144 >> 2];
l = c[d + 28 >> 2] | 0;
u = l + (h * 12 | 0) | 0;
v = +g[u >> 2];
w = +g[u + 4 >> 2];
x = +g[l + (h * 12 | 0) + 8 >> 2];
u = d + 32 | 0;
y = c[u >> 2] | 0;
z = y + (h * 12 | 0) | 0;
A = +g[z >> 2];
B = +g[z + 4 >> 2];
C = +g[y + (h * 12 | 0) + 8 >> 2];
h = l + (m * 12 | 0) | 0;
D = +g[h >> 2];
E = +g[h + 4 >> 2];
F = +g[l + (m * 12 | 0) + 8 >> 2];
l = y + (m * 12 | 0) | 0;
G = +g[l >> 2];
H = +g[l + 4 >> 2];
I = +g[y + (m * 12 | 0) + 8 >> 2];
J = +T(+x);
K = +S(+x);
x = +T(+F);
L = +S(+F);
F = +g[b + 68 >> 2] - (c[k >> 2] = p, +g[k >> 2]);
M = +g[b + 72 >> 2] - (c[k >> 2] = q, +g[k >> 2]);
N = K * F - J * M;
O = J * F + K * M;
M = +N;
K = +O;
q = b + 112 | 0;
g[q >> 2] = M;
g[q + 4 >> 2] = K;
K = +g[b + 76 >> 2] - (c[k >> 2] = r, +g[k >> 2]);
M = +g[b + 80 >> 2] - +g[b + 140 >> 2];
F = L * K - x * M;
J = x * K + L * M;
M =
+F;
L = +J;
r = b + 120 | 0;
g[r >> 2] = M;
g[r + 4 >> 2] = L;
r = b + 104 | 0;
L = D + F - v - N;
v = E + J - w - O;
w = +L;
E = +v;
q = r;
g[q >> 2] = w;
g[q + 4 >> 2] = E;
q = b + 108 | 0;
E = +Q(+(L * L + v * v));
g[b + 88 >> 2] = E;
c[b + 164 >> 2] = E - +g[b + 84 >> 2] > 0 ? 2 : 0;
if (!(E > .004999999888241291)) {
g[r >> 2] = 0;
g[q >> 2] = 0;
g[b + 160 >> 2] = 0;
g[b + 92 >> 2] = 0;
i = e;
return
}
w = 1 / E;
E = w * L;
g[r >> 2] = E;
L = w * v;
g[q >> 2] = L;
v = N * L - O * E;
w = L * F - E * J;
D = +g[s >> 2];
M = +g[t >> 2];
K = +g[o >> 2];
x = +g[f >> 2];
P = K + (D + v * v * M) + w * w * x;
if (P != 0)
R = 1 / P;
else
R = 0;
g[b + 160 >> 2] = R;
if ((a[d + 24 >> 0] | 0) == 0) {
g[b + 92 >> 2] = 0;
U = A;
V = B;
W = G;
X = H;
Y = C;
Z = I
} else {
f = b + 92 | 0;
R = +g[d +
8 >> 2] * +g[f >> 2];
g[f >> 2] = R;
P = E * R;
E = R * L;
U = A - P * D;
V = B - E * D;
W = G + P * K;
X = H + E * K;
Y = C - M * (E * N - P * O);
Z = I + x * (E * F - P * J)
}
J = +U;
U = +V;
f = (c[u >> 2] | 0) + ((c[j >> 2] | 0) * 12 | 0) | 0;
g[f >> 2] = J;
g[f + 4 >> 2] = U;
f = c[u >> 2] | 0;
g[f + ((c[j >> 2] | 0) * 12 | 0) + 8 >> 2] = Y;
Y = +W;
W = +X;
j = f + ((c[n >> 2] | 0) * 12 | 0) | 0;
g[j >> 2] = Y;
g[j + 4 >> 2] = W;
g[(c[u >> 2] | 0) + ((c[n >> 2] | 0) * 12 | 0) + 8 >> 2] = Z;
i = e;
return
}
function kh(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0;
d = i;
e = a + 96 | 0;
f = c[e >> 2] | 0;
h = b + 32 | 0;
j = c[h >> 2] | 0;
k = j + (f * 12 |
0) | 0;
l = k;
m = +g[l >> 2];
n = +g[l + 4 >> 2];
o = +g[j + (f * 12 | 0) + 8 >> 2];
f = a + 100 | 0;
l = c[f >> 2] | 0;
p = j + (l * 12 | 0) | 0;
q = +g[p >> 2];
r = +g[p + 4 >> 2];
s = +g[j + (l * 12 | 0) + 8 >> 2];
t = +g[a + 116 >> 2];
u = +g[a + 112 >> 2];
v = +g[a + 124 >> 2];
w = +g[a + 120 >> 2];
x = +g[a + 88 >> 2] - +g[a + 84 >> 2];
y = +g[a + 104 >> 2];
z = +g[a + 108 >> 2];
A = (q - s * v - (m - o * t)) * y + (r + s * w - (n + o * u)) * z;
if (x < 0)
B = A + x * +g[b + 4 >> 2];
else
B = A;
b = a + 92 | 0;
A = +g[b >> 2];
x = A - B * +g[a + 160 >> 2];
B = x > 0 ? 0 : x;
g[b >> 2] = B;
x = B - A;
A = y * x;
y = z * x;
x = +g[a + 144 >> 2];
z = o - +g[a + 152 >> 2] * (u * y - A * t);
t = +g[a + 148 >> 2];
u = s + +g[a + 156 >> 2] * (y * w - A * v);
v = +(m - x * A);
m = +(n -
x * y);
a = k;
g[a >> 2] = v;
g[a + 4 >> 2] = m;
a = c[h >> 2] | 0;
g[a + ((c[e >> 2] | 0) * 12 | 0) + 8 >> 2] = z;
z = +(q + A * t);
A = +(r + y * t);
e = a + ((c[f >> 2] | 0) * 12 | 0) | 0;
g[e >> 2] = z;
g[e + 4 >> 2] = A;
g[(c[h >> 2] | 0) + ((c[f >> 2] | 0) * 12 | 0) + 8 >> 2] = u;
i = d;
return
}
function lh(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0;
d = i;
e = a + 96 | 0;
f = c[e >> 2] | 0;
h = b + 28 | 0;
b = c[h >> 2] | 0;
j = b + (f * 12 | 0) | 0;
k = j;
l = +g[k >> 2];
m = +g[k + 4 >> 2];
n = +g[b + (f * 12 | 0) + 8 >> 2];
f = a + 100 | 0;
k = c[f >> 2] | 0;
o = b + (k * 12 | 0) | 0;
p = +g[o >> 2];
q = +g[o + 4 >> 2];
r = +g[b +
(k * 12 | 0) + 8 >> 2];
s = +T(+n);
t = +S(+n);
u = +T(+r);
v = +S(+r);
w = +g[a + 68 >> 2] - +g[a + 128 >> 2];
x = +g[a + 72 >> 2] - +g[a + 132 >> 2];
y = t * w - s * x;
z = s * w + t * x;
x = +g[a + 76 >> 2] - +g[a + 136 >> 2];
t = +g[a + 80 >> 2] - +g[a + 140 >> 2];
w = v * x - u * t;
s = u * x + v * t;
t = p + w - l - y;
v = q + s - m - z;
x = +Q(+(t * t + v * v));
if (x < 1.1920928955078125E-7) {
A = 0;
B = t;
C = v
} else {
u = 1 / x;
A = x;
B = t * u;
C = v * u
}
k = a + 84 | 0;
u = A - +g[k >> 2];
v = u < .20000000298023224 ? u : .20000000298023224;
u = -(+g[a + 160 >> 2] * (v < 0 ? 0 : v));
v = B * u;
B = C * u;
u = +g[a + 144 >> 2];
C = n - +g[a + 152 >> 2] * (y * B - z * v);
z = +g[a + 148 >> 2];
y = r + +g[a + 156 >> 2] * (w * B - s * v);
s = +(l - u *
v);
l = +(m - u * B);
a = j;
g[a >> 2] = s;
g[a + 4 >> 2] = l;
a = c[h >> 2] | 0;
g[a + ((c[e >> 2] | 0) * 12 | 0) + 8 >> 2] = C;
C = +(p + z * v);
v = +(q + z * B);
e = a + ((c[f >> 2] | 0) * 12 | 0) | 0;
g[e >> 2] = C;
g[e + 4 >> 2] = v;
g[(c[h >> 2] | 0) + ((c[f >> 2] | 0) * 12 | 0) + 8 >> 2] = y;
i = d;
return A - +g[k >> 2] < .004999999888241291 | 0
}
function mh(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 48 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 68 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 72 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function nh(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 52 >>
2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 76 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 80 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function oh(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
var d = 0;
d = +g[b + 92 >> 2] * c;
c = d * +g[b + 108 >> 2];
g[a >> 2] = +g[b + 104 >> 2] * d;
g[a + 4 >> 2] = c;
return
}
function ph(a, b) {
a = a | 0;
b = +b;
return 0
}
function qh(a) {
a = a | 0;
var b = 0,
e = 0,
f = 0,
j = 0,
l = 0;
b = i;
i = i + 16 | 0;
e = b;
f = c[(c[a + 48 >> 2] | 0) + 8 >> 2] | 0;
j = c[(c[a + 52 >> 2] | 0) + 8 >> 2] | 0;
Rm(3920, e);
c[e >> 2] = f;
Rm(3944, e);
c[e >> 2] = j;
Rm(3976, e);
c[e >> 2] = d[a + 61 >> 0] | 0;
Rm(4008, e);
l = +g[a + 72 >>
2];
h[k >> 3] = +g[a + 68 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(4048, e);
l = +g[a + 80 >> 2];
h[k >> 3] = +g[a + 76 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(4096, e);
h[k >> 3] = +g[a + 84 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(4144, e);
c[e >> 2] = c[a + 56 >> 2];
Rm(4176, e);
i = b;
return
}
function rh(a) {
a = a | 0;
return
}
function sh(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function th(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0;
d = i;
do switch (c[a >> 2] | 0) {
case 5:
e = Em(b, 168) | 0;
if ((e | 0) == 0)
f = 0;
else {
vf(e, a);
f = e
}
g = f;
break;
case 2:
e = Em(b, 256) | 0;
if ((e | 0) == 0)
h = 0;
else {
Sg(e, a);
h = e
}
g = h;
break;
case 7:
e = Em(b, 224) | 0;
if ((e | 0) == 0)
j = 0;
else {
Sh(e, a);
j = e
}
g = j;
break;
case 4:
e = Em(b, 196) | 0;
if ((e | 0) == 0)
k = 0;
else {
di(e, a);
k = e
}
g = k;
break;
case 3:
e = Em(b, 176) | 0;
if ((e | 0) == 0)
l = 0;
else {
Yf(e, a);
l = e
}
g = l;
break;
case 9:
e = Em(b, 180) | 0;
if ((e | 0) == 0)
m = 0;
else {
ig(e, a);
m = e
}
g = m;
break;
case 11:
e = Em(b, 192) | 0;
if ((e | 0) == 0)
n = 0;
else {
Jf(e, a);
n = e
}
g = n;
break;
case 1:
e = Em(b, 228) | 0;
if ((e | 0) == 0)
o = 0;
else {
Ah(e, a);
o = e
}
g = o;
break;
case 8:
e = Em(b, 208) | 0;
if ((e | 0) == 0)
p = 0;
else {
ug(e, a);
p = e
}
g = p;
break;
case 6:
e = Em(b, 276) | 0;
if ((e | 0) == 0)
q = 0;
else {
Fg(e, a);
q = e
}
g = q;
break;
case 10:
e = Em(b, 168) | 0;
if ((e | 0) == 0)
r = 0;
else {
ih(e, a);
r = e
}
g = r;
break;
default:
g = 0
}
while (0);
i = d;
return g | 0
}
function uh(a, b) {
a = a | 0;
b = b | 0;
var d = 0;
d = i;
eb[c[(c[a >> 2] | 0) + 24 >> 2] & 127](a);
do switch (c[a + 4 >> 2] | 0) {
case 9:
Fm(b, a, 180);
break;
case 2:
Fm(b, a, 256);
break;
case 1:
Fm(b, a, 228);
break;
case 7:
Fm(b, a, 224);
break;
case 8:
Fm(b,
a, 208);
break;
case 5:
Fm(b, a, 168);
break;
case 3:
Fm(b, a, 176);
break;
case 11:
Fm(b, a, 192);
break;
case 4:
Fm(b, a, 196);
break;
case 10:
Fm(b, a, 168);
break;
case 6:
Fm(b, a, 276);
break;
default:
}
while (0);
i = d;
return
}
function vh(b, d) {
b = b | 0;
d = d | 0;
var e = 0;
e = i;
c[b >> 2] = 4264;
c[b + 4 >> 2] = c[d >> 2];
c[b + 8 >> 2] = 0;
c[b + 12 >> 2] = 0;
c[b + 48 >> 2] = c[d + 8 >> 2];
c[b + 52 >> 2] = c[d + 12 >> 2];
c[b + 56 >> 2] = 0;
a[b + 61 >> 0] = a[d + 16 >> 0] | 0;
a[b + 60 >> 0] = 0;
c[b + 64 >> 2] = c[d + 4 >> 2];
d = b + 16 | 0;
c[d + 0 >> 2] = 0;
c[d + 4 >> 2] = 0;
c[d + 8 >> 2] = 0;
c[d + 12 >> 2] = 0;
c[d + 16 >> 2] = 0;
c[d + 20 >> 2] = 0;
c[d + 24 >> 2] = 0;
c[d + 28 >> 2] = 0;
i = e;
return
}
function wh(a) {
a = a | 0;
a = i;
i = i + 16 | 0;
Rm(4312, a);
i = a;
return
}
function xh(a) {
a = a | 0;
return
}
function yh(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function zh(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
f = i;
c[a + 8 >> 2] = b;
c[a + 12 >> 2] = d;
h = +g[e >> 2] - +g[b + 12 >> 2];
j = e + 4 | 0;
k = +g[j >> 2] - +g[b + 16 >> 2];
l = +g[b + 24 >> 2];
m = +g[b + 20 >> 2];
n = +(h * l + k * m);
o = +(l * k - h * m);
p = a + 20 | 0;
g[p >> 2] = n;
g[p + 4 >> 2] = o;
o = +g[e >> 2] - +g[d + 12 >> 2];
n = +g[j >> 2] - +g[d + 16 >> 2];
m = +g[d + 24 >> 2];
h = +g[d + 20 >> 2];
k = +(o * m + n * h);
l = +(m *
n - o * h);
j = a + 28 | 0;
g[j >> 2] = k;
g[j + 4 >> 2] = l;
g[a + 36 >> 2] = +g[d + 72 >> 2] - +g[b + 72 >> 2];
i = f;
return
}
function Ah(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0;
e = i;
vh(b, d);
c[b >> 2] = 4368;
f = d + 20 | 0;
h = c[f + 4 >> 2] | 0;
j = b + 68 | 0;
c[j >> 2] = c[f >> 2];
c[j + 4 >> 2] = h;
h = d + 28 | 0;
j = c[h + 4 >> 2] | 0;
f = b + 76 | 0;
c[f >> 2] = c[h >> 2];
c[f + 4 >> 2] = j;
g[b + 116 >> 2] = +g[d + 36 >> 2];
j = b + 84 | 0;
f = d + 44 | 0;
c[j + 0 >> 2] = 0;
c[j + 4 >> 2] = 0;
c[j + 8 >> 2] = 0;
c[j + 12 >> 2] = 0;
g[b + 120 >> 2] = +g[f >> 2];
g[b + 124 >> 2] = +g[d + 48 >> 2];
g[b + 104 >> 2] = +g[d + 60 >> 2];
g[b + 108 >> 2] = +g[d + 56 >> 2];
a[b + 112 >> 0] = a[d + 40 >> 0] | 0;
a[b + 100 >> 0] = a[d +
52 >> 0] | 0;
c[b + 224 >> 2] = 0;
i = e;
return
}
function Bh(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0;
e = i;
f = c[b + 48 >> 2] | 0;
h = c[f + 8 >> 2] | 0;
j = b + 128 | 0;
c[j >> 2] = h;
l = c[b + 52 >> 2] | 0;
m = c[l + 8 >> 2] | 0;
n = b + 132 | 0;
c[n >> 2] = m;
o = f + 44 | 0;
p = c[o >> 2] | 0;
q = c[o + 4 >> 2] | 0;
o = b + 152 | 0;
c[o >> 2] =
p;
c[o + 4 >> 2] = q;
o = l + 44 | 0;
r = c[o >> 2] | 0;
s = c[o + 4 >> 2] | 0;
o = b + 160 | 0;
c[o >> 2] = r;
c[o + 4 >> 2] = s;
o = b + 168 | 0;
g[o >> 2] = +g[f + 136 >> 2];
t = +g[l + 136 >> 2];
g[b + 172 >> 2] = t;
u = +g[f + 144 >> 2];
g[b + 176 >> 2] = u;
v = +g[l + 144 >> 2];
g[b + 180 >> 2] = v;
l = c[d + 28 >> 2] | 0;
w = +g[l + (h * 12 | 0) + 8 >> 2];
f = d + 32 | 0;
x = c[f >> 2] | 0;
y = x + (h * 12 | 0) | 0;
z = +g[y >> 2];
A = +g[y + 4 >> 2];
B = +g[x + (h * 12 | 0) + 8 >> 2];
C = +g[l + (m * 12 | 0) + 8 >> 2];
l = x + (m * 12 | 0) | 0;
D = +g[l >> 2];
E = +g[l + 4 >> 2];
F = +g[x + (m * 12 | 0) + 8 >> 2];
G = +T(+w);
H = +S(+w);
I = +T(+C);
J = +S(+C);
m = b + 136 | 0;
K = +g[b + 68 >> 2] - (c[k >> 2] = p, +g[k >> 2]);
L = +g[b + 72 >> 2] - (c[k >>
2] = q, +g[k >> 2]);
M = H * K - G * L;
N = G * K + H * L;
L = +M;
H = +N;
q = m;
g[q >> 2] = L;
g[q + 4 >> 2] = H;
H = +g[b + 76 >> 2] - (c[k >> 2] = r, +g[k >> 2]);
L = +g[b + 80 >> 2] - (c[k >> 2] = s, +g[k >> 2]);
K = J * H - I * L;
G = I * H + J * L;
L = +K;
J = +G;
s = b + 144 | 0;
g[s >> 2] = L;
g[s + 4 >> 2] = J;
J = +g[o >> 2];
L = u + v;
o = L == 0;
H = J + t;
s = b + 140 | 0;
g[b + 184 >> 2] = H + u * N * N + v * G * G;
I = -(u * N * M) - v * G * K;
g[b + 196 >> 2] = I;
O = -(u * N) - v * G;
g[b + 208 >> 2] = O;
g[b + 188 >> 2] = I;
g[b + 200 >> 2] = H + u * M * M + v * K * K;
H = u * M + v * K;
g[b + 212 >> 2] = H;
g[b + 192 >> 2] = O;
g[b + 204 >> 2] = H;
g[b + 216 >> 2] = L;
if (L > 0)
P = 1 / L;
else
P = L;
g[b + 220 >> 2] = P;
if ((a[b + 100 >> 0] | 0) == 0 | o)
g[b + 96 >>
2] = 0;
do if ((a[b + 112 >> 0] | 0) == 0 | o)
c[b + 224 >> 2] = 0;
else {
P = C - w - +g[b + 116 >> 2];
L = +g[b + 124 >> 2];
H = +g[b + 120 >> 2];
O = L - H;
if (O > 0)
Q = O;
else
Q = -O;
if (Q < .06981317698955536) {
c[b + 224 >> 2] = 3;
break
}
if (P <= H) {
r = b + 224 | 0;
if ((c[r >> 2] | 0) != 1)
g[b + 92 >> 2] = 0;
c[r >> 2] = 1;
break
}
r = b + 224 | 0;
if (!(P >= L)) {
c[r >> 2] = 0;
g[b + 92 >> 2] = 0;
break
}
if ((c[r >> 2] | 0) != 2)
g[b + 92 >> 2] = 0;
c[r >> 2] = 2
}
while (0);
o = b + 84 | 0;
if ((a[d + 24 >> 0] | 0) == 0) {
c[o + 0 >> 2] = 0;
c[o + 4 >> 2] = 0;
c[o + 8 >> 2] = 0;
c[o + 12 >> 2] = 0;
R = z;
U = A;
V = D;
W = E;
X = B;
Y = F;
Z = c[j >> 2] | 0;
_ = c[f >> 2] | 0;
$ = _ + (Z * 12 | 0) | 0;
aa = +R;
ba = +U;
ca = $;
da =
ca;
g[da >> 2] = aa;
ea = ca + 4 | 0;
fa = ea;
g[fa >> 2] = ba;
ga = c[j >> 2] | 0;
ha = c[f >> 2] | 0;
ia = ha + (ga * 12 | 0) + 8 | 0;
g[ia >> 2] = X;
ja = c[n >> 2] | 0;
ka = ha + (ja * 12 | 0) | 0;
la = +V;
ma = +W;
na = ka;
oa = na;
g[oa >> 2] = la;
pa = na + 4 | 0;
qa = pa;
g[qa >> 2] = ma;
ra = c[n >> 2] | 0;
sa = c[f >> 2] | 0;
ta = sa + (ra * 12 | 0) + 8 | 0;
g[ta >> 2] = Y;
i = e;
return
} else {
r = d + 8 | 0;
Q = +g[r >> 2];
w = Q * +g[o >> 2];
g[o >> 2] = w;
o = b + 88 | 0;
C = Q * +g[o >> 2];
g[o >> 2] = C;
o = b + 92 | 0;
L = Q * +g[o >> 2];
g[o >> 2] = L;
o = b + 96 | 0;
Q = +g[r >> 2] * +g[o >> 2];
g[o >> 2] = Q;
R = z - J * w;
U = A - J * C;
V = D + t * w;
W = E + t * C;
X = B - u * (L + (Q + (C * +g[m >> 2] - w * +g[s >> 2])));
Y = F + v * (L + (Q + (C * K - w *
G)));
Z = c[j >> 2] | 0;
_ = c[f >> 2] | 0;
$ = _ + (Z * 12 | 0) | 0;
aa = +R;
ba = +U;
ca = $;
da = ca;
g[da >> 2] = aa;
ea = ca + 4 | 0;
fa = ea;
g[fa >> 2] = ba;
ga = c[j >> 2] | 0;
ha = c[f >> 2] | 0;
ia = ha + (ga * 12 | 0) + 8 | 0;
g[ia >> 2] = X;
ja = c[n >> 2] | 0;
ka = ha + (ja * 12 | 0) | 0;
la = +V;
ma = +W;
na = ka;
oa = na;
g[oa >> 2] = la;
pa = na + 4 | 0;
qa = pa;
g[qa >> 2] = ma;
ra = c[n >> 2] | 0;
sa = c[f >> 2] | 0;
ta = sa + (ra * 12 | 0) + 8 | 0;
g[ta >> 2] = Y;
i = e;
return
}
}
function Ch(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0,
ya = 0,
za = 0,
Aa = 0,
Ba = 0,
Ca = 0,
Da = 0,
Ea = 0,
Fa = 0,
Ga = 0,
Ha = 0;
e = i;
i = i + 80 | 0;
f = e + 60 | 0;
h = e + 48 | 0;
j = e + 40 | 0;
k = e + 32 | 0;
l = e + 24 | 0;
m = e + 16 | 0;
n = e + 8 | 0;
o = e;
p = b + 128 | 0;
q = c[p >> 2] | 0;
r = d + 32 | 0;
s = c[r >> 2] | 0;
t = s + (q * 12 | 0) | 0;
u = +g[t >> 2];
v = +g[t + 4 >> 2];
w = +g[s + (q * 12 | 0) + 8 >> 2];
q = b + 132 | 0;
t = c[q >> 2] | 0;
x = s + (t * 12 | 0) | 0;
y = +g[x >> 2];
z = +g[x + 4 >> 2];
A = +g[s + (t * 12 | 0) + 8 >> 2];
B = +g[b + 168 >> 2];
C = +g[b + 172 >> 2];
D = +g[b + 176 >> 2];
E = +g[b + 180 >> 2];
t = D + E == 0;
if ((a[b + 100 >> 0] | 0) != 0 ? !((c[b + 224 >> 2] | 0) == 3 | t) : 0) {
s = b + 96 | 0;
F = +g[s >> 2];
G = +g[d >> 2] * +g[b + 104 >> 2];
H = F - +g[b + 220 >> 2] * (A - w - +g[b + 108 >> 2]);
I = -G;
J = H < G ? H : G;
G = J < I ? I : J;
g[s >> 2] = G;
J = G - F;
K = w - D * J;
L = A + E * J
} else {
K = w;
L = A
}
if ((a[b + 112 >> 0] | 0) != 0 ? (s = b + 224 | 0, !((c[s >> 2] | 0) == 0 | t)) : 0) {
t = b + 148 | 0;
d = b + 144 | 0;
x = b + 140 | 0;
M = b + 136 | 0;
A = y - L * +g[t >> 2] - u + K * +g[x >> 2];
w = z + L * +g[d >> 2] - v - K * +g[M >> 2];
g[f >> 2] = A;
g[f + 4 >> 2] = w;
g[f + 8 >> 2] = L - K;
N = b + 184 | 0;
Gm(h, N, f);
J = +g[h >> 2];
F = -J;
G = +g[h + 4 >> 2];
I = -G;
H = +g[h +
8 >> 2];
O = -H;
h = c[s >> 2] | 0;
do if ((h | 0) == 2) {
s = b + 84 | 0;
f = b + 92 | 0;
P = +g[f >> 2];
Q = P - H;
if (Q > 0) {
R = P * +g[b + 212 >> 2] - w;
g[l >> 2] = P * +g[b + 208 >> 2] - A;
g[l + 4 >> 2] = R;
Hm(m, N, l);
R = +g[m >> 2];
P = +g[m + 4 >> 2];
S = -+g[f >> 2];
g[s >> 2] = R + +g[s >> 2];
T = b + 88 | 0;
g[T >> 2] = P + +g[T >> 2];
g[f >> 2] = 0;
U = P;
V = R;
W = S;
break
} else {
g[s >> 2] = +g[s >> 2] - J;
s = b + 88 | 0;
g[s >> 2] = +g[s >> 2] - G;
g[f >> 2] = Q;
U = I;
V = F;
W = O;
break
}
} else if ((h | 0) == 3) {
f = b + 84 | 0;
g[f >> 2] = +g[f >> 2] - J;
f = b + 88 | 0;
g[f >> 2] = +g[f >> 2] - G;
f = b + 92 | 0;
g[f >> 2] = +g[f >> 2] - H;
U = I;
V = F;
W = O
} else if ((h | 0) == 1) {
f = b + 84 | 0;
s = b + 92 | 0;
Q = +g[s >> 2];
S = Q - H;
if (S < 0) {
R = Q * +g[b + 212 >> 2] - w;
g[j >> 2] = Q * +g[b + 208 >> 2] - A;
g[j + 4 >> 2] = R;
Hm(k, N, j);
R = +g[k >> 2];
Q = +g[k + 4 >> 2];
P = -+g[s >> 2];
g[f >> 2] = R + +g[f >> 2];
T = b + 88 | 0;
g[T >> 2] = Q + +g[T >> 2];
g[s >> 2] = 0;
U = Q;
V = R;
W = P;
break
} else {
g[f >> 2] = +g[f >> 2] - J;
f = b + 88 | 0;
g[f >> 2] = +g[f >> 2] - G;
g[s >> 2] = S;
U = I;
V = F;
W = O;
break
}
} else {
U = I;
V = F;
W = O
}
while (0);
X = W + (U * +g[d >> 2] - V * +g[t >> 2]);
Y = W + (U * +g[M >> 2] - V * +g[x >> 2]);
Z = U;
_ = V;
$ = C * _;
aa = C * Z;
ba = B * _;
ca = B * Z;
da = y + $;
ea = z + aa;
fa = u - ba;
ga = v - ca;
ha = D * Y;
ia = E * X;
ja = K - ha;
ka = L + ia;
la = c[p >> 2] | 0;
ma = c[r >> 2] | 0;
na = ma + (la * 12 | 0) | 0;
oa = +fa;
pa = +ga;
qa = na;
ra = qa;
g[ra >> 2] = oa;
sa = qa + 4 | 0;
ta = sa;
g[ta >> 2] = pa;
ua = c[p >> 2] | 0;
va = c[r >> 2] | 0;
wa = va + (ua * 12 | 0) + 8 | 0;
g[wa >> 2] = ja;
xa = c[q >> 2] | 0;
ya = va + (xa * 12 | 0) | 0;
za = +da;
Aa = +ea;
Ba = ya;
Ca = Ba;
g[Ca >> 2] = za;
Da = Ba + 4 | 0;
Ea = Da;
g[Ea >> 2] = Aa;
Fa = c[q >> 2] | 0;
Ga = c[r >> 2] | 0;
Ha = Ga + (Fa * 12 | 0) + 8 | 0;
g[Ha >> 2] = ka;
i = e;
return
}
x = b + 148 | 0;
M = b + 144 | 0;
t = b + 140 | 0;
d = b + 136 | 0;
V = -(z + L * +g[M >> 2] - v - K * +g[d >> 2]);
g[o >> 2] = -(y - L * +g[x >> 2] - u + K * +g[t >> 2]);
g[o + 4 >> 2] = V;
Hm(n, b + 184 | 0, o);
V = +g[n >> 2];
o = b + 84 | 0;
g[o >> 2] = V + +g[o >> 2];
U = +g[n + 4 >> 2];
n = b + 88 | 0;
g[n >> 2] = U + +g[n >> 2];
X = U * +g[M >> 2] - V * +g[x >> 2];
Y = U * +g[d >> 2] - V * +g[t >> 2];
Z = U;
_ = V;
$ = C * _;
aa = C * Z;
ba = B * _;
ca = B * Z;
da = y + $;
ea = z + aa;
fa = u - ba;
ga = v - ca;
ha = D * Y;
ia = E * X;
ja = K - ha;
ka = L + ia;
la = c[p >> 2] | 0;
ma = c[r >> 2] | 0;
na = ma + (la * 12 | 0) | 0;
oa = +fa;
pa = +ga;
qa = na;
ra = qa;
g[ra >> 2] = oa;
sa = qa + 4 | 0;
ta = sa;
g[ta >> 2] = pa;
ua = c[p >> 2] | 0;
va = c[r >> 2] | 0;
wa = va + (ua * 12 | 0) + 8 | 0;
g[wa >> 2] = ja;
xa = c[q >> 2] | 0;
ya = va + (xa * 12 | 0) | 0;
za = +da;
Aa = +ea;
Ba = ya;
Ca = Ba;
g[Ca >> 2] = za;
Da = Ba + 4 | 0;
Ea = Da;
g[Ea >> 2] = Aa;
Fa = c[q >> 2] | 0;
Ga = c[r >> 2] | 0;
Ha = Ga + (Fa * 12 | 0) + 8 | 0;
g[Ha >> 2] = ka;
i = e;
return
}
function Dh(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0;
e = i;
f = b + 128 | 0;
h = c[f >> 2] | 0;
j = d + 28 | 0;
d = c[j >> 2] | 0;
k = d + (h * 12 | 0) | 0;
l = k;
m = +g[l >> 2];
n = +g[l + 4 >> 2];
o = +g[d + (h * 12 | 0) + 8 >> 2];
h = b + 132 | 0;
l = c[h >> 2] | 0;
p = d + (l * 12 | 0) | 0;
q = +g[p >> 2];
r = +g[p + 4 >> 2];
s = +g[d + (l * 12 | 0) + 8 >> 2];
l = b + 176 | 0;
d = b + 180 | 0;
if ((a[b + 112 >> 0] | 0) != 0) {
t = +g[d >> 2];
u = +g[l >> 2];
p = c[b + 224 >> 2] | 0;
if ((p | 0) == 0 | t + u == 0) {
v = u;
w = t;
x = o;
y = s;
z = 0
} else {
A = s - o - +g[b + 116 >> 2];
if ((p | 0) == 1) {
B = A - +g[b +
120 >> 2];
C = B + .03490658849477768;
D = C < 0 ? C : 0;
E = -B;
F = -(+g[b + 220 >> 2] * (D < -.13962635397911072 ? -.13962635397911072 : D))
} else if ((p | 0) == 3) {
D = A - +g[b + 120 >> 2];
B = D < .13962635397911072 ? D : .13962635397911072;
D = B < -.13962635397911072 ? -.13962635397911072 : B;
B = -(+g[b + 220 >> 2] * D);
if (D > 0) {
E = D;
F = B
} else {
E = -D;
F = B
}
} else if ((p | 0) == 2) {
B = A - +g[b + 124 >> 2];
A = B + -.03490658849477768;
D = A < .13962635397911072 ? A : .13962635397911072;
E = B;
F = -(+g[b + 220 >> 2] * (D < 0 ? 0 : D))
} else {
E = 0;
F = 0
}
v = u;
w = t;
x = o - F * u;
y = s + F * t;
z = E
}
} else {
v = +g[l >> 2];
w = +g[d >> 2];
x = o;
y = s;
z = 0
}
s =
+T(+x);
o = +S(+x);
E = +T(+y);
t = +S(+y);
F = +g[b + 68 >> 2] - +g[b + 152 >> 2];
u = +g[b + 72 >> 2] - +g[b + 156 >> 2];
D = o * F - s * u;
B = s * F + o * u;
u = +g[b + 76 >> 2] - +g[b + 160 >> 2];
o = +g[b + 80 >> 2] - +g[b + 164 >> 2];
F = t * u - E * o;
s = E * u + t * o;
o = q + F - m - D;
t = r + s - n - B;
u = +Q(+(o * o + t * t));
E = +g[b + 168 >> 2];
A = +g[b + 172 >> 2];
C = E + A;
G = C + B * B * v + s * s * w;
H = D * v;
I = F * w;
J = -(B * H) - s * I;
K = C + D * H + F * I;
I = G * K - J * J;
if (I != 0)
L = 1 / I;
else
L = I;
I = -((o * K - t * J) * L);
K = -((t * G - o * J) * L);
L = +(m - E * I);
m = +(n - E * K);
b = k;
g[b >> 2] = L;
g[b + 4 >> 2] = m;
b = c[j >> 2] | 0;
g[b + ((c[f >> 2] | 0) * 12 | 0) + 8 >> 2] = x - v * (D * K - B * I);
B = +(q + A * I);
q = +(r + A * K);
f =
b + ((c[h >> 2] | 0) * 12 | 0) | 0;
g[f >> 2] = B;
g[f + 4 >> 2] = q;
g[(c[j >> 2] | 0) + ((c[h >> 2] | 0) * 12 | 0) + 8 >> 2] = y + w * (F * K - s * I);
if (!(u <= .004999999888241291)) {
M = 0;
i = e;
return M | 0
}
M = z <= .03490658849477768;
i = e;
return M | 0
}
function Eh(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 48 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 68 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 72 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function Fh(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 52 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 76 >> 2];
h = +g[d + 20 >> 2];
i =
+g[b + 80 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function Gh(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
var d = 0;
d = +g[b + 88 >> 2] * c;
g[a >> 2] = +g[b + 84 >> 2] * c;
g[a + 4 >> 2] = d;
return
}
function Hh(a, b) {
a = a | 0;
b = +b;
return +(+g[a + 92 >> 2] * b)
}
function Ih(a) {
a = a | 0;
return +(+g[(c[a + 52 >> 2] | 0) + 72 >> 2] - +g[(c[a + 48 >> 2] | 0) + 72 >> 2] - +g[a + 116 >> 2])
}
function Jh(b) {
b = b | 0;
return (a[b + 100 >> 0] | 0) != 0 | 0
}
function Kh(d, f) {
d = d | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0;
h = i;
j = c[d + 48 >> 2] | 0;
k = j + 4 | 0;
l = e[k >> 1] | 0;
if ((l & 2 | 0) == 0) {
b[k >> 1] = l | 2;
g[j +
160 >> 2] = 0
}
j = c[d + 52 >> 2] | 0;
l = j + 4 | 0;
k = e[l >> 1] | 0;
if ((k & 2 | 0) != 0) {
m = d + 100 | 0;
n = f & 1;
a[m >> 0] = n;
i = h;
return
}
b[l >> 1] = k | 2;
g[j + 160 >> 2] = 0;
m = d + 100 | 0;
n = f & 1;
a[m >> 0] = n;
i = h;
return
}
function Lh(a, d) {
a = a | 0;
d = +d;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0;
f = i;
h = c[a + 48 >> 2] | 0;
j = h + 4 | 0;
k = e[j >> 1] | 0;
if ((k & 2 | 0) == 0) {
b[j >> 1] = k | 2;
g[h + 160 >> 2] = 0
}
h = c[a + 52 >> 2] | 0;
k = h + 4 | 0;
j = e[k >> 1] | 0;
if ((j & 2 | 0) != 0) {
l = a + 108 | 0;
g[l >> 2] = d;
i = f;
return
}
b[k >> 1] = j | 2;
g[h + 160 >> 2] = 0;
l = a + 108 | 0;
g[l >> 2] = d;
i = f;
return
}
function Mh(b) {
b = b | 0;
return (a[b + 112 >> 0] | 0) != 0 | 0
}
function Nh(f, h) {
f = f | 0;
h = h | 0;
var j = 0,
k = 0,
l = 0,
m = 0,
n = 0;
j = i;
k = f + 112 | 0;
if ((h & 1 | 0) == (d[k >> 0] | 0 | 0)) {
i = j;
return
}
l = c[f + 48 >> 2] | 0;
m = l + 4 | 0;
n = e[m >> 1] | 0;
if ((n & 2 | 0) == 0) {
b[m >> 1] = n | 2;
g[l + 160 >> 2] = 0
}
l = c[f + 52 >> 2] | 0;
n = l + 4 | 0;
m = e[n >> 1] | 0;
if ((m & 2 | 0) == 0) {
b[n >> 1] = m | 2;
g[l + 160 >> 2] = 0
}
a[k >> 0] = h & 1;
g[f + 92 >> 2] = 0;
i = j;
return
}
function Oh(a) {
a = a | 0;
var b = 0,
e = 0,
f = 0,
j = 0,
l = 0;
b = i;
i = i + 16 | 0;
e = b;
f = c[(c[a + 48 >> 2] | 0) + 8 >> 2] | 0;
j = c[(c[a + 52 >> 2] | 0) + 8 >> 2] | 0;
Rm(4416, e);
c[e >> 2] = f;
Rm(4448, e);
c[e >> 2] = j;
Rm(4480, e);
c[e >> 2] = d[a + 61 >> 0] | 0;
Rm(4512, e);
l = +g[a + 72 >> 2];
h[k >> 3] = +g[a + 68 >>
2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(4552, e);
l = +g[a + 80 >> 2];
h[k >> 3] = +g[a + 76 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(4600, e);
h[k >> 3] = +g[a + 116 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(4648, e);
c[e >> 2] = d[a + 112 >> 0] | 0;
Rm(4680, e);
h[k >> 3] = +g[a + 120 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(4712, e);
h[k >> 3] = +g[a + 124 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(4744, e);
c[e >> 2] = d[a + 100 >> 0] | 0;
Rm(4776,
e);
h[k >> 3] = +g[a + 108 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(4808, e);
h[k >> 3] = +g[a + 104 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(4840, e);
c[e >> 2] = c[a + 56 >> 2];
Rm(4872, e);
i = b;
return
}
function Ph(a) {
a = a | 0;
return
}
function Qh(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Rh(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0;
h = i;
c[a + 8 >> 2] = b;
c[a + 12 >> 2] = d;
j = +g[e >> 2] - +g[b + 12 >> 2];
k = e + 4 | 0;
l = +g[k >> 2] - +g[b + 16 >> 2];
m = b + 24 | 0;
n = +g[m >> 2];
o = b + 20 | 0;
p = +g[o >> 2];
q = +(j * n + l * p);
r = +(n * l - j *
p);
b = a + 20 | 0;
g[b >> 2] = q;
g[b + 4 >> 2] = r;
r = +g[e >> 2] - +g[d + 12 >> 2];
q = +g[k >> 2] - +g[d + 16 >> 2];
p = +g[d + 24 >> 2];
j = +g[d + 20 >> 2];
l = +(r * p + q * j);
n = +(p * q - r * j);
d = a + 28 | 0;
g[d >> 2] = l;
g[d + 4 >> 2] = n;
n = +g[m >> 2];
l = +g[f >> 2];
j = +g[o >> 2];
r = +g[f + 4 >> 2];
q = +(n * l + j * r);
p = +(n * r - l * j);
f = a + 36 | 0;
g[f >> 2] = q;
g[f + 4 >> 2] = p;
i = h;
return
}
function Sh(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0;
e = i;
vh(b, d);
c[b >> 2] = 4968;
f = d + 20 | 0;
h = c[f + 4 >> 2] | 0;
j = b + 76 | 0;
c[j >> 2] = c[f >> 2];
c[j + 4 >> 2] = h;
h = d + 28 | 0;
j = c[h + 4 >> 2] | 0;
f = b + 84 | 0;
c[f >> 2] = c[h >> 2];
c[f + 4 >> 2] = j;
j = d + 36 | 0;
f = c[j >> 2] | 0;
h = c[j + 4 >>
2] | 0;
j = b + 92 | 0;
c[j >> 2] = f;
c[j + 4 >> 2] = h;
j = b + 100 | 0;
g[j >> 2] = -(c[k >> 2] = h, +g[k >> 2]);
c[j + 4 >> 2] = f;
g[b + 204 >> 2] = 0;
g[b + 108 >> 2] = 0;
g[b + 208 >> 2] = 0;
g[b + 112 >> 2] = 0;
g[b + 212 >> 2] = 0;
g[b + 116 >> 2] = 0;
g[b + 120 >> 2] = +g[d + 48 >> 2];
g[b + 124 >> 2] = +g[d + 52 >> 2];
a[b + 128 >> 0] = a[d + 44 >> 0] | 0;
g[b + 68 >> 2] = +g[d + 56 >> 2];
g[b + 72 >> 2] = +g[d + 60 >> 2];
g[b + 216 >> 2] = 0;
g[b + 220 >> 2] = 0;
d = b + 172 | 0;
c[d + 0 >> 2] = 0;
c[d + 4 >> 2] = 0;
c[d + 8 >> 2] = 0;
c[d + 12 >> 2] = 0;
i = e;
return
}
function Th(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0,
ya = 0,
za = 0,
Aa = 0,
Ba = 0;
e = i;
f = c[b + 48 >> 2] | 0;
h = c[f + 8 >> 2] | 0;
j = b + 132 | 0;
c[j >> 2] = h;
l = c[b + 52 >> 2] | 0;
m = c[l + 8 >> 2] | 0;
n = b + 136 | 0;
c[n >> 2] = m;
o = f + 44 | 0;
p = c[o >> 2] | 0;
q = c[o + 4 >> 2] | 0;
o = b + 140 | 0;
c[o >> 2] = p;
c[o + 4 >> 2] = q;
o = l + 44 | 0;
r = c[o >> 2] | 0;
s = c[o + 4 >> 2] | 0;
o = b + 148 | 0;
c[o >> 2] = r;
c[o + 4 >> 2] = s;
t = +g[f + 136 >> 2];
o = b + 156 | 0;
g[o >> 2] = t;
u = +g[l + 136 >> 2];
v = b + 160 | 0;
g[v >> 2] = u;
w = +g[f + 144 >> 2];
f = b + 164 | 0;
g[f >> 2] = w;
x = +g[l + 144 >> 2];
l = b + 168 | 0;
g[l >> 2] = x;
y = c[d + 28 >> 2] | 0;
z = y + (h * 12 | 0) | 0;
A = +g[z >> 2];
B = +g[z + 4 >> 2];
C = +g[y + (h * 12 | 0) + 8 >> 2];
z = d + 32 | 0;
D = c[z >> 2] | 0;
E = D + (h * 12 | 0) | 0;
F = +g[E >> 2];
G = +g[E + 4 >> 2];
H = +g[D + (h * 12 | 0) + 8 >> 2];
h = y + (m * 12 | 0) | 0;
I = +g[h >> 2];
J = +g[h + 4 >> 2];
K = +g[y + (m * 12 | 0) + 8 >> 2];
y = D + (m * 12 | 0) | 0;
L = +g[y >> 2];
M = +g[y + 4 >> 2];
N = +g[D + (m * 12 | 0) + 8 >> 2];
O = +T(+C);
P = +S(+C);
C = +T(+K);
Q = +S(+K);
K = +g[b + 76 >> 2] - (c[k >> 2] = p, +g[k >> 2]);
R = +g[b + 80 >> 2] - (c[k >> 2] = q, +g[k >> 2]);
U = P * K - O * R;
V = O * K + P * R;
R = +g[b + 84 >> 2] - (c[k >> 2] = r, +g[k >> 2]);
K = +g[b + 88 >> 2] - (c[k >> 2] = s, +g[k >> 2]);
W = Q * R - C * K;
X = C * R + Q * K;
K = I + W - A - U;
A = J + X - B - V;
B = +g[b + 100 >> 2];
J = +g[b + 104 >> 2];
I = P * B - O * J;
Q = O * B + P * J;
J = +I;
B = +Q;
s = b + 180 | 0;
g[s >> 2] = J;
g[s + 4 >> 2] = B;
B = U + K;
U = V + A;
V = Q * B - I * U;
g[b + 196 >> 2] = V;
J = W * Q - X * I;
g[b + 200 >> 2] = J;
R = t + u;
u = R + V * w * V + J * x * J;
if (u > 0)
Y = 1 / u;
else
Y = u;
g[b + 204 >> 2] = Y;
s = b + 212 | 0;
g[s >> 2] = 0;
r = b + 216 | 0;
g[r >> 2] = 0;
q = b + 220 | 0;
g[q >> 2] = 0;
Y = +g[b + 68 >> 2];
if (Y > 0) {
u = +g[b + 92 >> 2];
t = +g[b + 96 >> 2];
C = P * u - O * t;
Z = O * u + P * t;
t = +C;
P = +Z;
p = b + 172 | 0;
g[p >> 2] = t;
g[p +
4 >> 2] = P;
P = B * Z - U * C;
g[b + 188 >> 2] = P;
U = W * Z - X * C;
g[b + 192 >> 2] = U;
X = R + P * w * P + U * x * U;
if (X > 0) {
U = 1 / X;
g[s >> 2] = U;
P = Y * 6.2831854820251465;
Y = P * U * P;
R = +g[d >> 2];
W = R * (P * U * 2 * +g[b + 72 >> 2] + R * Y);
if (W > 0)
_ = 1 / W;
else
_ = W;
g[q >> 2] = _;
g[r >> 2] = (K * C + A * Z) * R * Y * _;
Y = X + _;
g[s >> 2] = Y;
if (Y > 0)
g[s >> 2] = 1 / Y
}
} else
g[b + 116 >> 2] = 0;
if ((a[b + 128 >> 0] | 0) != 0) {
Y = x + w;
s = b + 208 | 0;
g[s >> 2] = Y;
if (Y > 0)
g[s >> 2] = 1 / Y
} else {
g[b + 208 >> 2] = 0;
g[b + 112 >> 2] = 0
}
if ((a[d + 24 >> 0] | 0) == 0) {
g[b + 108 >> 2] = 0;
g[b + 116 >> 2] = 0;
g[b + 112 >> 2] = 0;
$ = F;
aa = G;
ba = L;
ca = M;
da = H;
ea = N;
fa = c[j >> 2] | 0;
ga = c[z >> 2] | 0;
ha = ga +
(fa * 12 | 0) | 0;
ia = +$;
ja = +aa;
ka = ha;
la = ka;
g[la >> 2] = ia;
ma = ka + 4 | 0;
na = ma;
g[na >> 2] = ja;
oa = c[j >> 2] | 0;
pa = c[z >> 2] | 0;
qa = pa + (oa * 12 | 0) + 8 | 0;
g[qa >> 2] = da;
ra = c[n >> 2] | 0;
sa = pa + (ra * 12 | 0) | 0;
ta = +ba;
ua = +ca;
va = sa;
wa = va;
g[wa >> 2] = ta;
xa = va + 4 | 0;
ya = xa;
g[ya >> 2] = ua;
za = c[n >> 2] | 0;
Aa = c[z >> 2] | 0;
Ba = Aa + (za * 12 | 0) + 8 | 0;
g[Ba >> 2] = ea;
i = e;
return
} else {
s = d + 8 | 0;
d = b + 108 | 0;
Y = +g[s >> 2] * +g[d >> 2];
g[d >> 2] = Y;
d = b + 116 | 0;
w = +g[s >> 2] * +g[d >> 2];
g[d >> 2] = w;
d = b + 112 | 0;
x = +g[s >> 2] * +g[d >> 2];
g[d >> 2] = x;
_ = Y * I + w * +g[b + 172 >> 2];
I = Y * Q + w * +g[b + 176 >> 2];
Q = +g[o >> 2];
X = +g[v >> 2];
$ = F -
_ * Q;
aa = G - I * Q;
ba = L + _ * X;
ca = M + I * X;
da = H - (x + (Y * V + w * +g[b + 188 >> 2])) * +g[f >> 2];
ea = N + (x + (Y * J + w * +g[b + 192 >> 2])) * +g[l >> 2];
fa = c[j >> 2] | 0;
ga = c[z >> 2] | 0;
ha = ga + (fa * 12 | 0) | 0;
ia = +$;
ja = +aa;
ka = ha;
la = ka;
g[la >> 2] = ia;
ma = ka + 4 | 0;
na = ma;
g[na >> 2] = ja;
oa = c[j >> 2] | 0;
pa = c[z >> 2] | 0;
qa = pa + (oa * 12 | 0) + 8 | 0;
g[qa >> 2] = da;
ra = c[n >> 2] | 0;
sa = pa + (ra * 12 | 0) | 0;
ta = +ba;
ua = +ca;
va = sa;
wa = va;
g[wa >> 2] = ta;
xa = va + 4 | 0;
ya = xa;
g[ya >> 2] = ua;
za = c[n >> 2] | 0;
Aa = c[z >> 2] | 0;
Ba = Aa + (za * 12 | 0) + 8 | 0;
g[Ba >> 2] = ea;
i = e;
return
}
}
function Uh(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l =
0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0;
d = i;
e = +g[a + 156 >> 2];
f = +g[a + 160 >> 2];
h = +g[a + 164 >> 2];
j = +g[a + 168 >> 2];
k = a + 132 | 0;
l = c[k >> 2] | 0;
m = b + 32 | 0;
n = c[m >> 2] | 0;
o = n + (l * 12 | 0) | 0;
p = +g[o >> 2];
q = +g[o + 4 >> 2];
r = +g[n + (l * 12 | 0) + 8 >> 2];
l = a + 136 | 0;
o = c[l >> 2] | 0;
s = n + (o * 12 | 0) | 0;
t = +g[s >> 2];
u = +g[s + 4 >> 2];
v = +g[n + (o * 12 | 0) + 8 >> 2];
w = +g[a + 172 >> 2];
x = +g[a + 176 >> 2];
y = +g[a + 192 >> 2];
z = +g[a + 188 >> 2];
o = a + 116 | 0;
A = +g[o >> 2];
B = +g[a + 212 >> 2] * (+g[a + 216 >> 2] + (v * y + (w * (t - p) + x * (u - q)) - r * z) + +g[a + 220 >> 2] * A);
C = -B;
g[o >> 2] = A - B;
B = w * C;
w =
x * C;
x = p - e * B;
p = q - e * w;
q = r - h * z * C;
z = t + f * B;
B = u + f * w;
w = v + j * y * C;
o = a + 112 | 0;
C = +g[o >> 2];
y = +g[b >> 2] * +g[a + 120 >> 2];
v = C - +g[a + 208 >> 2] * (w - q - +g[a + 124 >> 2]);
u = -y;
t = v < y ? v : y;
y = t < u ? u : t;
g[o >> 2] = y;
t = y - C;
C = q - h * t;
q = w + j * t;
t = +g[a + 180 >> 2];
w = +g[a + 184 >> 2];
y = +g[a + 200 >> 2];
u = +g[a + 196 >> 2];
v = +g[a + 204 >> 2] * ((z - x) * t + (B - p) * w + y * q - u * C);
r = -v;
o = a + 108 | 0;
g[o >> 2] = +g[o >> 2] - v;
v = t * r;
t = w * r;
w = +(x - e * v);
x = +(p - e * t);
o = (c[m >> 2] | 0) + ((c[k >> 2] | 0) * 12 | 0) | 0;
g[o >> 2] = w;
g[o + 4 >> 2] = x;
o = c[m >> 2] | 0;
g[o + ((c[k >> 2] | 0) * 12 | 0) + 8 >> 2] = C - h * u * r;
u = +(z + f * v);
v = +(B + f * t);
k = o + ((c[l >>
2] | 0) * 12 | 0) | 0;
g[k >> 2] = u;
g[k + 4 >> 2] = v;
g[(c[m >> 2] | 0) + ((c[l >> 2] | 0) * 12 | 0) + 8 >> 2] = q + j * y * r;
i = d;
return
}
function Vh(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0;
d = i;
e = a + 132 | 0;
f = c[e >> 2] | 0;
h = b + 28 | 0;
b = c[h >> 2] | 0;
j = b + (f * 12 | 0) | 0;
k = +g[j >> 2];
l = +g[j + 4 >> 2];
m = +g[b + (f * 12 | 0) + 8 >> 2];
f = a + 136 | 0;
j = c[f >> 2] | 0;
n = b + (j * 12 | 0) | 0;
o = +g[n >> 2];
p = +g[n + 4 >> 2];
q = +g[b + (j * 12 | 0) + 8 >> 2];
r = +T(+m);
s = +S(+m);
t = +T(+q);
u = +S(+q);
v = +g[a + 76 >> 2] - +g[a + 140 >>
2];
w = +g[a + 80 >> 2] - +g[a + 144 >> 2];
x = s * v - r * w;
y = r * v + s * w;
w = +g[a + 84 >> 2] - +g[a + 148 >> 2];
v = +g[a + 88 >> 2] - +g[a + 152 >> 2];
z = u * w - t * v;
A = t * w + u * v;
v = o - k + z - x;
u = p - l + A - y;
w = +g[a + 100 >> 2];
t = +g[a + 104 >> 2];
B = s * w - r * t;
C = r * w + s * t;
t = B * v + C * u;
s = +g[a + 156 >> 2];
w = +g[a + 160 >> 2];
r = +g[a + 164 >> 2];
D = +g[a + 196 >> 2];
E = +g[a + 168 >> 2];
F = +g[a + 200 >> 2];
G = s + w + D * r * D + F * E * F;
if (G != 0)
H = -t / G;
else
H = 0;
G = B * H;
F = C * H;
D = +(k - G * s);
k = +(l - F * s);
a = (c[h >> 2] | 0) + ((c[e >> 2] | 0) * 12 | 0) | 0;
g[a >> 2] = D;
g[a + 4 >> 2] = k;
a = c[h >> 2] | 0;
g[a + ((c[e >> 2] | 0) * 12 | 0) + 8 >> 2] = m - (C * (x + v) - B * (y + u)) * H * r;
r = +(o + G * w);
G = +(p + F * w);
e = a + ((c[f >> 2] | 0) * 12 | 0) | 0;
g[e >> 2] = r;
g[e + 4 >> 2] = G;
g[(c[h >> 2] | 0) + ((c[f >> 2] | 0) * 12 | 0) + 8 >> 2] = q + (z * C - A * B) * H * E;
if (t > 0) {
I = t;
J = I <= .004999999888241291;
i = d;
return J | 0
}
I = -t;
J = I <= .004999999888241291;
i = d;
return J | 0
}
function Wh(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 48 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 76 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 80 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function Xh(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 52 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b +
84 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 88 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function Yh(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
var d = 0,
e = 0,
f = 0;
d = +g[b + 108 >> 2];
e = +g[b + 116 >> 2];
f = (d * +g[b + 184 >> 2] + e * +g[b + 176 >> 2]) * c;
g[a >> 2] = (d * +g[b + 180 >> 2] + e * +g[b + 172 >> 2]) * c;
g[a + 4 >> 2] = f;
return
}
function Zh(a, b) {
a = a | 0;
b = +b;
return +(+g[a + 112 >> 2] * b)
}
function _h(a, d) {
a = a | 0;
d = +d;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0;
f = i;
h = c[a + 48 >> 2] | 0;
j = h + 4 | 0;
k = e[j >> 1] | 0;
if ((k & 2 | 0) == 0) {
b[j >> 1] = k | 2;
g[h + 160 >> 2] = 0
}
h = c[a + 52 >> 2] | 0;
k = h + 4 | 0;
j = e[k >> 1] |
0;
if ((j & 2 | 0) != 0) {
l = a + 124 | 0;
g[l >> 2] = d;
i = f;
return
}
b[k >> 1] = j | 2;
g[h + 160 >> 2] = 0;
l = a + 124 | 0;
g[l >> 2] = d;
i = f;
return
}
function $h(a) {
a = a | 0;
var b = 0,
e = 0,
f = 0,
j = 0,
l = 0;
b = i;
i = i + 16 | 0;
e = b;
f = c[(c[a + 48 >> 2] | 0) + 8 >> 2] | 0;
j = c[(c[a + 52 >> 2] | 0) + 8 >> 2] | 0;
Rm(5016, e);
c[e >> 2] = f;
Rm(5040, e);
c[e >> 2] = j;
Rm(5072, e);
c[e >> 2] = d[a + 61 >> 0] | 0;
Rm(5104, e);
l = +g[a + 80 >> 2];
h[k >> 3] = +g[a + 76 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(5144, e);
l = +g[a + 88 >> 2];
h[k >> 3] = +g[a + 84 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] =
c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(5192, e);
l = +g[a + 96 >> 2];
h[k >> 3] = +g[a + 92 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(5240, e);
c[e >> 2] = d[a + 128 >> 0] | 0;
Rm(5280, e);
h[k >> 3] = +g[a + 124 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(5312, e);
h[k >> 3] = +g[a + 120 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(5344, e);
h[k >> 3] = +g[a + 68 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(5376, e);
h[k >> 3] = +g[a + 72 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(5408, e);
c[e >> 2] = c[a + 56 >> 2];
Rm(5440, e);
i = b;
return
}
function ai(a) {
a = a | 0;
return
}
function bi(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function ci(a, b, d, e, f, h, j, k) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
h = h | 0;
j = j | 0;
k = +k;
var l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0;
l = i;
c[a + 8 >> 2] = b;
c[a + 12 >> 2] = d;
m = e;
n = c[m + 4 >> 2] | 0;
o = a + 20 | 0;
c[o >> 2] = c[m >> 2];
c[o + 4 >> 2] = n;
n = f;
o = c[n + 4 >> 2] | 0;
m = a + 28 | 0;
c[m >> 2] = c[n >> 2];
c[m + 4 >> 2] = o;
p = +g[h >> 2] - +g[b + 12 >> 2];
o = h + 4 | 0;
q = +g[o >> 2] - +g[b + 16 >> 2];
r = +g[b + 24 >> 2];
s = +g[b + 20 >> 2];
t = +(p * r + q * s);
u = +(r * q - p * s);
b = a +
36 | 0;
g[b >> 2] = t;
g[b + 4 >> 2] = u;
u = +g[j >> 2] - +g[d + 12 >> 2];
b = j + 4 | 0;
t = +g[b >> 2] - +g[d + 16 >> 2];
s = +g[d + 24 >> 2];
p = +g[d + 20 >> 2];
q = +(u * s + t * p);
r = +(s * t - u * p);
d = a + 44 | 0;
g[d >> 2] = q;
g[d + 4 >> 2] = r;
r = +g[h >> 2] - +g[e >> 2];
q = +g[o >> 2] - +g[e + 4 >> 2];
g[a + 52 >> 2] = +Q(+(r * r + q * q));
q = +g[j >> 2] - +g[f >> 2];
r = +g[b >> 2] - +g[f + 4 >> 2];
g[a + 56 >> 2] = +Q(+(q * q + r * r));
g[a + 60 >> 2] = k;
i = l;
return
}
function di(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0;
d = i;
vh(a, b);
c[a >> 2] = 5528;
e = b + 20 | 0;
f = c[e + 4 >> 2] | 0;
h = a + 68 | 0;
c[h >> 2] = c[e >> 2];
c[h + 4 >> 2] = f;
f = b + 28 | 0;
h = c[f + 4 >> 2] | 0;
e = a + 76 | 0;
c[e >>
2] = c[f >> 2];
c[e + 4 >> 2] = h;
h = b + 36 | 0;
e = c[h + 4 >> 2] | 0;
f = a + 92 | 0;
c[f >> 2] = c[h >> 2];
c[f + 4 >> 2] = e;
e = b + 44 | 0;
f = c[e + 4 >> 2] | 0;
h = a + 100 | 0;
c[h >> 2] = c[e >> 2];
c[h + 4 >> 2] = f;
f = b + 52 | 0;
g[a + 84 >> 2] = +g[f >> 2];
h = b + 56 | 0;
g[a + 88 >> 2] = +g[h >> 2];
j = +g[b + 60 >> 2];
g[a + 112 >> 2] = j;
g[a + 108 >> 2] = +g[f >> 2] + j * +g[h >> 2];
g[a + 116 >> 2] = 0;
i = d;
return
}
function ei(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0;
e = i;
f = c[b + 48 >> 2] | 0;
h = c[f + 8 >> 2] | 0;
j = b + 120 | 0;
c[j >> 2] = h;
l = c[b + 52 >> 2] | 0;
m = c[l + 8 >> 2] | 0;
n = b + 124 | 0;
c[n >> 2] = m;
o = f + 44 | 0;
p = c[o >> 2] | 0;
q = c[o + 4 >> 2] | 0;
o = b + 160 | 0;
c[o >> 2] = p;
c[o + 4 >> 2] = q;
o = l + 44 | 0;
r = c[o >> 2] | 0;
s = c[o + 4 >> 2] | 0;
o = b + 168 | 0;
c[o >> 2] = r;
c[o + 4 >> 2] = s;
s = b + 176 | 0;
g[s >> 2] = +g[f + 136 >> 2];
o = b + 180 | 0;
g[o >> 2] = +g[l + 136 >> 2];
t = b + 184 | 0;
g[t >> 2] = +g[f + 144 >> 2];
f = b + 188 | 0;
g[f >> 2] = +g[l + 144 >> 2];
l = c[d + 28 >> 2] | 0;
u = l + (h * 12 | 0) |
0;
v = +g[u >> 2];
w = +g[u + 4 >> 2];
x = +g[l + (h * 12 | 0) + 8 >> 2];
u = d + 32 | 0;
y = c[u >> 2] | 0;
z = y + (h * 12 | 0) | 0;
A = +g[z >> 2];
B = +g[z + 4 >> 2];
C = +g[y + (h * 12 | 0) + 8 >> 2];
h = l + (m * 12 | 0) | 0;
D = +g[h >> 2];
E = +g[h + 4 >> 2];
F = +g[l + (m * 12 | 0) + 8 >> 2];
l = y + (m * 12 | 0) | 0;
G = +g[l >> 2];
H = +g[l + 4 >> 2];
I = +g[y + (m * 12 | 0) + 8 >> 2];
J = +T(+x);
K = +S(+x);
x = +T(+F);
L = +S(+F);
m = b + 144 | 0;
F = +g[b + 92 >> 2] - (c[k >> 2] = p, +g[k >> 2]);
M = +g[b + 96 >> 2] - (c[k >> 2] = q, +g[k >> 2]);
N = K * F - J * M;
O = J * F + K * M;
M = +N;
K = +O;
q = m;
g[q >> 2] = M;
g[q + 4 >> 2] = K;
K = +g[b + 100 >> 2] - (c[k >> 2] = r, +g[k >> 2]);
M = +g[b + 104 >> 2] - +g[b + 172 >> 2];
F = L * K - x * M;
J = x *
K + L * M;
M = +F;
L = +J;
r = b + 152 | 0;
g[r >> 2] = M;
g[r + 4 >> 2] = L;
r = b + 128 | 0;
L = v + N - +g[b + 68 >> 2];
N = w + O - +g[b + 72 >> 2];
O = +L;
w = +N;
q = r;
g[q >> 2] = O;
g[q + 4 >> 2] = w;
q = b + 136 | 0;
w = D + F - +g[b + 76 >> 2];
D = E + J - +g[b + 80 >> 2];
E = +w;
O = +D;
p = q;
g[p >> 2] = E;
g[p + 4 >> 2] = O;
O = +Q(+(L * L + N * N));
E = +Q(+(w * w + D * D));
if (O > .04999999701976776) {
v = 1 / O;
O = L * v;
g[r >> 2] = O;
P = v * N;
R = O
} else {
g[r >> 2] = 0;
P = 0;
R = 0
}
g[b + 132 >> 2] = P;
if (E > .04999999701976776) {
O = 1 / E;
E = O * w;
g[q >> 2] = E;
U = O * D;
V = E
} else {
g[q >> 2] = 0;
U = 0;
V = 0
}
g[b + 140 >> 2] = U;
E = +g[m >> 2];
D = +g[b + 148 >> 2];
O = E * P - D * R;
w = F * U - J * V;
N = +g[s >> 2];
v = +g[t >> 2];
L = +g[o >> 2];
M = +g[f >> 2];
K = +g[b + 112 >> 2];
x = N + O * O * v + K * K * (L + w * w * M);
if (x > 0)
W = 1 / x;
else
W = x;
g[b + 192 >> 2] = W;
if ((a[d + 24 >> 0] | 0) == 0) {
g[b + 116 >> 2] = 0;
X = A;
Y = B;
Z = G;
_ = H;
$ = C;
aa = I;
ba = c[j >> 2] | 0;
ca = c[u >> 2] | 0;
da = ca + (ba * 12 | 0) | 0;
ea = +X;
fa = +Y;
ga = da;
ha = ga;
g[ha >> 2] = ea;
ia = ga + 4 | 0;
ja = ia;
g[ja >> 2] = fa;
ka = c[j >> 2] | 0;
la = c[u >> 2] | 0;
ma = la + (ka * 12 | 0) + 8 | 0;
g[ma >> 2] = $;
na = c[n >> 2] | 0;
oa = la + (na * 12 | 0) | 0;
pa = +Z;
qa = +_;
ra = oa;
sa = ra;
g[sa >> 2] = pa;
ta = ra + 4 | 0;
ua = ta;
g[ua >> 2] = qa;
va = c[n >> 2] | 0;
wa = c[u >> 2] | 0;
xa = wa + (va * 12 | 0) + 8 | 0;
g[xa >> 2] = aa;
i = e;
return
} else {
f = b + 116 | 0;
W = +g[d + 8 >> 2] * +g[f >> 2];
g[f >> 2] = W;
x = -W;
w = R * x;
R = P * x;
x = -(W * K);
K = V * x;
V = U * x;
X = A + w * N;
Y = B + R * N;
Z = G + K * L;
_ = H + V * L;
$ = C + v * (R * E - w * D);
aa = I + M * (V * F - K * J);
ba = c[j >> 2] | 0;
ca = c[u >> 2] | 0;
da = ca + (ba * 12 | 0) | 0;
ea = +X;
fa = +Y;
ga = da;
ha = ga;
g[ha >> 2] = ea;
ia = ga + 4 | 0;
ja = ia;
g[ja >> 2] = fa;
ka = c[j >> 2] | 0;
la = c[u >> 2] | 0;
ma = la + (ka * 12 | 0) + 8 | 0;
g[ma >> 2] = $;
na = c[n >> 2] | 0;
oa = la + (na * 12 | 0) | 0;
pa = +Z;
qa = +_;
ra = oa;
sa = ra;
g[sa >> 2] = pa;
ta = ra + 4 | 0;
ua = ta;
g[ua >> 2] = qa;
va = c[n >> 2] | 0;
wa = c[u >> 2] | 0;
xa = wa + (va * 12 | 0) + 8 | 0;
g[xa >> 2] = aa;
i = e;
return
}
}
function fi(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0;
d = i;
e = a + 120 | 0;
f = c[e >> 2] | 0;
h = b + 32 | 0;
b = c[h >> 2] | 0;
j = b + (f * 12 | 0) | 0;
k = j;
l = +g[k >> 2];
m = +g[k + 4 >> 2];
n = +g[b + (f * 12 | 0) + 8 >> 2];
f = a + 124 | 0;
k = c[f >> 2] | 0;
o = b + (k * 12 | 0) | 0;
p = +g[o >> 2];
q = +g[o + 4 >> 2];
r = +g[b + (k * 12 | 0) + 8 >> 2];
s = +g[a + 148 >> 2];
t = +g[a + 144 >> 2];
u = +g[a + 156 >> 2];
v = +g[a + 152 >> 2];
w = +g[a + 128 >> 2];
x = +g[a + 132 >> 2];
y = +g[a + 112 >> 2];
z = +g[a + 136 >> 2];
A = +g[a + 140 >> 2];
B = +g[a + 192 >> 2] * (-((l - n * s) * w + (m + n * t) * x) - y * ((p - r * u) * z + (q + r * v) * A));
k = a + 116 | 0;
g[k >>
2] = +g[k >> 2] - B;
C = w * B;
w = x * B;
x = y * B;
B = z * x;
z = x * A;
A = +g[a + 176 >> 2];
x = n + +g[a + 184 >> 2] * (w * t - C * s);
s = +g[a + 180 >> 2];
t = r + +g[a + 188 >> 2] * (z * v - B * u);
u = +(l + C * A);
C = +(m + w * A);
a = j;
g[a >> 2] = u;
g[a + 4 >> 2] = C;
a = c[h >> 2] | 0;
g[a + ((c[e >> 2] | 0) * 12 | 0) + 8 >> 2] = x;
x = +(p + B * s);
B = +(q + z * s);
e = a + ((c[f >> 2] | 0) * 12 | 0) | 0;
g[e >> 2] = x;
g[e + 4 >> 2] = B;
g[(c[h >> 2] | 0) + ((c[f >> 2] | 0) * 12 | 0) + 8 >> 2] = t;
i = d;
return
}
function gi(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K =
0,
L = 0;
d = i;
e = a + 120 | 0;
f = c[e >> 2] | 0;
h = b + 28 | 0;
b = c[h >> 2] | 0;
j = b + (f * 12 | 0) | 0;
k = j;
l = +g[k >> 2];
m = +g[k + 4 >> 2];
n = +g[b + (f * 12 | 0) + 8 >> 2];
f = a + 124 | 0;
k = c[f >> 2] | 0;
o = b + (k * 12 | 0) | 0;
p = +g[o >> 2];
q = +g[o + 4 >> 2];
r = +g[b + (k * 12 | 0) + 8 >> 2];
s = +T(+n);
t = +S(+n);
u = +T(+r);
v = +S(+r);
w = +g[a + 92 >> 2] - +g[a + 160 >> 2];
x = +g[a + 96 >> 2] - +g[a + 164 >> 2];
y = t * w - s * x;
z = s * w + t * x;
x = +g[a + 100 >> 2] - +g[a + 168 >> 2];
t = +g[a + 104 >> 2] - +g[a + 172 >> 2];
w = v * x - u * t;
s = u * x + v * t;
t = l + y - +g[a + 68 >> 2];
v = m + z - +g[a + 72 >> 2];
x = p + w - +g[a + 76 >> 2];
u = q + s - +g[a + 80 >> 2];
A = +Q(+(t * t + v * v));
B = +Q(+(x * x + u * u));
if (A > .04999999701976776) {
C =
1 / A;
D = v * C;
E = t * C
} else {
D = 0;
E = 0
}
if (B > .04999999701976776) {
C = 1 / B;
F = u * C;
G = x * C
} else {
F = 0;
G = 0
}
C = y * D - z * E;
x = w * F - s * G;
u = +g[a + 176 >> 2];
t = +g[a + 184 >> 2];
v = +g[a + 180 >> 2];
H = +g[a + 188 >> 2];
I = +g[a + 112 >> 2];
J = u + C * C * t + I * I * (v + x * x * H);
if (J > 0)
K = 1 / J;
else
K = J;
J = +g[a + 108 >> 2] - A - B * I;
if (J > 0)
L = J;
else
L = -J;
B = K * J;
J = E * B;
E = D * B;
D = B * I;
I = G * D;
G = F * D;
D = +(l + J * u);
l = +(m + E * u);
a = j;
g[a >> 2] = D;
g[a + 4 >> 2] = l;
a = c[h >> 2] | 0;
g[a + ((c[e >> 2] | 0) * 12 | 0) + 8 >> 2] = n + (y * E - z * J) * t;
t = +(p + I * v);
p = +(q + G * v);
e = a + ((c[f >> 2] | 0) * 12 | 0) | 0;
g[e >> 2] = t;
g[e + 4 >> 2] = p;
g[(c[h >> 2] | 0) + ((c[f >> 2] | 0) *
12 | 0) + 8 >> 2] = r + H * (w * G - s * I);
i = d;
return L < .004999999888241291 | 0
}
function hi(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 48 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 92 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 96 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function ii(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 52 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 100 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 104 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function ji(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
var d =
0,
e = 0;
d = +g[b + 116 >> 2];
e = d * +g[b + 140 >> 2] * c;
g[a >> 2] = d * +g[b + 136 >> 2] * c;
g[a + 4 >> 2] = e;
return
}
function ki(a, b) {
a = a | 0;
b = +b;
return 0
}
function li(a) {
a = a | 0;
var b = 0,
e = 0,
f = 0,
j = 0,
l = 0;
b = i;
i = i + 16 | 0;
e = b;
f = c[(c[a + 48 >> 2] | 0) + 8 >> 2] | 0;
j = c[(c[a + 52 >> 2] | 0) + 8 >> 2] | 0;
Rm(5576, e);
c[e >> 2] = f;
Rm(5600, e);
c[e >> 2] = j;
Rm(5632, e);
c[e >> 2] = d[a + 61 >> 0] | 0;
Rm(5664, e);
l = +g[a + 72 >> 2];
h[k >> 3] = +g[a + 68 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(5704, e);
l = +g[a + 80 >> 2];
h[k >> 3] = +g[a + 76 >> 2];
c[e >> 2] = c[k >>
2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(5752, e);
l = +g[a + 96 >> 2];
h[k >> 3] = +g[a + 92 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(5800, e);
l = +g[a + 104 >> 2];
h[k >> 3] = +g[a + 100 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
j = e + 8 | 0;
h[k >> 3] = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
Rm(5848, e);
h[k >> 3] = +g[a + 84 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(5896, e);
h[k >> 3] = +g[a + 88 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(5928, e);
h[k >> 3] =
+g[a + 112 >> 2];
c[e >> 2] = c[k >> 2];
c[e + 4 >> 2] = c[k + 4 >> 2];
Rm(5960, e);
c[e >> 2] = c[a + 56 >> 2];
Rm(5984, e);
i = b;
return
}
function mi(a, b) {
a = a | 0;
b = b | 0;
var c = 0,
d = 0;
c = a + 68 | 0;
g[c >> 2] = +g[c >> 2] - +g[b >> 2];
c = b + 4 | 0;
d = a + 72 | 0;
g[d >> 2] = +g[d >> 2] - +g[c >> 2];
d = a + 76 | 0;
g[d >> 2] = +g[d >> 2] - +g[b >> 2];
b = a + 80 | 0;
g[b >> 2] = +g[b >> 2] - +g[c >> 2];
return
}
function ni(a) {
a = a | 0;
return
}
function oi(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function pi(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0,
h = 0,
j = 0;
g = i;
h = Em(f, 148) | 0;
if ((h | 0) == 0) {
j = 0;
i = g;
return j | 0
}
wi(h, a,
b, d, e);
c[h >> 2] = 6072;
j = h;
i = g;
return j | 0
}
function qi(a, b) {
a = a | 0;
b = b | 0;
var d = 0;
d = i;
eb[c[(c[a >> 2] | 0) + 4 >> 2] & 127](a);
Fm(b, a, 148);
i = d;
return
}
function ri(a, d, e, f) {
a = a | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0;
h = i;
i = i + 48 | 0;
j = h;
k = c[(c[a + 48 >> 2] | 0) + 12 >> 2] | 0;
c[j >> 2] = 488;
c[j + 4 >> 2] = 1;
g[j + 8 >> 2] = .009999999776482582;
l = j + 28 | 0;
c[l + 0 >> 2] = 0;
c[l + 4 >> 2] = 0;
c[l + 8 >> 2] = 0;
c[l + 12 >> 2] = 0;
b[l + 16 >> 1] = 0;
Ge(k, j, c[a + 56 >> 2] | 0);
ff(d, j, e, c[(c[a + 52 >> 2] | 0) + 12 >> 2] | 0, f);
i = h;
return
}
function si(a) {
a = a | 0;
return
}
function ti(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function ui(b, d, e, f, g) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0;
h = i;
if ((a[6352] | 0) == 0) {
c[1540] = 6;
c[6164 >> 2] = 53;
a[6168 >> 0] = 1;
c[6256 >> 2] = 7;
c[6260 >> 2] = 54;
a[6264 >> 0] = 1;
c[6184 >> 2] = 7;
c[6188 >> 2] = 54;
a[6192 >> 0] = 0;
c[6280 >> 2] = 8;
c[6284 >> 2] = 55;
a[6288 >> 0] = 1;
c[6208 >> 2] = 9;
c[6212 >> 2] = 56;
a[6216 >> 0] = 1;
c[6172 >> 2] = 9;
c[6176 >> 2] = 56;
a[6180 >> 0] = 0;
c[6232 >> 2] = 10;
c[6236 >> 2] = 57;
a[6240 >> 0] = 1;
c[6268 >> 2] = 10;
c[6272 >> 2] = 57;
a[6276 >> 0] = 0;
c[6304 >> 2] = 11;
c[6308 >> 2] = 58;
a[6312 >> 0] = 1;
c[6196 >> 2] = 11;
c[6200 >> 2] = 58;
a[6204 >>
0] = 0;
c[6328 >> 2] = 12;
c[6332 >> 2] = 59;
a[6336 >> 0] = 1;
c[6292 >> 2] = 12;
c[6296 >> 2] = 59;
a[6300 >> 0] = 0;
a[6352] = 1
}
j = c[(c[b + 12 >> 2] | 0) + 4 >> 2] | 0;
k = c[(c[e + 12 >> 2] | 0) + 4 >> 2] | 0;
l = c[6160 + (j * 48 | 0) + (k * 12 | 0) >> 2] | 0;
if ((l | 0) == 0) {
m = 0;
i = h;
return m | 0
}
if ((a[6160 + (j * 48 | 0) + (k * 12 | 0) + 8 >> 0] | 0) == 0) {
m = ob[l & 15](e, f, b, d, g) | 0;
i = h;
return m | 0
} else {
m = ob[l & 15](b, d, e, f, g) | 0;
i = h;
return m | 0
}
return 0
}
function vi(d, f) {
d = d | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0;
h = i;
j = c[d + 48 >> 2] | 0;
k = c[d + 52 >> 2] | 0;
if (((c[d + 124 >> 2] | 0) > 0 ? (a[j + 38 >> 0] | 0) == 0 : 0) ? (a[k + 38 >> 0] | 0) == 0 :
0) {
l = c[j + 8 >> 2] | 0;
m = l + 4 | 0;
n = e[m >> 1] | 0;
if ((n & 2 | 0) == 0) {
b[m >> 1] = n | 2;
g[l + 160 >> 2] = 0
}
l = c[k + 8 >> 2] | 0;
n = l + 4 | 0;
m = e[n >> 1] | 0;
if ((m & 2 | 0) == 0) {
b[n >> 1] = m | 2;
g[l + 160 >> 2] = 0
}
}
gb[c[6160 + ((c[(c[j + 12 >> 2] | 0) + 4 >> 2] | 0) * 48 | 0) + ((c[(c[k + 12 >> 2] | 0) + 4 >> 2] | 0) * 12 | 0) + 4 >> 2] & 63](d, f);
i = h;
return
}
function wi(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0;
h = i;
c[a >> 2] = 6368;
c[a + 4 >> 2] = 4;
c[a + 48 >> 2] = b;
c[a + 52 >> 2] = e;
c[a + 56 >> 2] = d;
c[a + 60 >> 2] = f;
c[a + 124 >> 2] = 0;
c[a + 128 >> 2] = 0;
f = b + 16 | 0;
d = a + 8 | 0;
j = d + 40 | 0;
do {
c[d >> 2] = 0;
d = d + 4 | 0
} while ((d | 0) < (j |
0));
g[a + 136 >> 2] = +Q(+(+g[f >> 2] * +g[e + 16 >> 2]));
k = +g[b + 20 >> 2];
l = +g[e + 20 >> 2];
g[a + 140 >> 2] = k > l ? k : l;
g[a + 144 >> 2] = 0;
i = h;
return
}
function xi(d, f) {
d = d | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0;
h = i;
i = i + 64 | 0;
j = h;
k = d + 64 | 0;
l = j + 0 | 0;
m = k + 0 | 0;
n = l + 64 | 0;
do {
c[l >> 2] = c[m >> 2];
l = l + 4 | 0;
m = m + 4 | 0
} while ((l | 0) < (n | 0));
m = d + 4 | 0;
l = c[m >> 2] | 0;
c[m >> 2] = l | 4;
n = l >>> 1;
l = c[d + 48 >> 2] | 0;
o = c[d + 52 >> 2] | 0;
p = (a[o + 38 >> 0] | a[l + 38 >> 0]) << 24 >> 24 != 0;
q = c[l + 8 >> 2] | 0;
r = c[o + 8 >> 2] | 0;
s = q + 12 | 0;
t = r + 12 | 0;
if (!p) {
pb[c[c[d >>
2] >> 2] & 31](d, k, s, t);
k = d + 124 | 0;
u = (c[k >> 2] | 0) > 0;
a:
do if (u) {
v = c[j + 60 >> 2] | 0;
if ((v | 0) > 0)
w = 0;
else {
x = 0;
while (1) {
g[d + (x * 20 | 0) + 72 >> 2] = 0;
g[d + (x * 20 | 0) + 76 >> 2] = 0;
x = x + 1 | 0;
if ((x | 0) >= (c[k >> 2] | 0))
break a
}
}
do {
x = d + (w * 20 | 0) + 72 | 0;
g[x >> 2] = 0;
y = d + (w * 20 | 0) + 76 | 0;
g[y >> 2] = 0;
z = c[d + (w * 20 | 0) + 80 >> 2] | 0;
A = 0;
while (1) {
B = A + 1 | 0;
if ((c[j + (A * 20 | 0) + 16 >> 2] | 0) == (z | 0)) {
C = 7;
break
}
if ((B | 0) < (v | 0))
A = B;
else
break
}
if ((C | 0) == 7) {
C = 0;
g[x >> 2] = +g[j + (A * 20 | 0) + 8 >> 2];
g[y >> 2] = +g[j + (A * 20 | 0) + 12 >> 2]
}
w = w + 1 | 0
} while ((w | 0) < (c[k >> 2] | 0))
}
while (0);
k = n & 1;
if (u ^ (k | 0) !=
0) {
w = q + 4 | 0;
C = e[w >> 1] | 0;
if ((C & 2 | 0) == 0) {
b[w >> 1] = C | 2;
g[q + 160 >> 2] = 0
}
q = r + 4 | 0;
C = e[q >> 1] | 0;
if ((C & 2 | 0) == 0) {
b[q >> 1] = C | 2;
g[r + 160 >> 2] = 0;
D = k;
E = u
} else {
D = k;
E = u
}
} else {
D = k;
E = u
}
} else {
u = lf(c[l + 12 >> 2] | 0, c[d + 56 >> 2] | 0, c[o + 12 >> 2] | 0, c[d + 60 >> 2] | 0, s, t) | 0;
c[d + 124 >> 2] = 0;
D = n & 1;
E = u
}
u = c[m >> 2] | 0;
c[m >> 2] = E ? u | 2 : u & -3;
u = (D | 0) == 0;
D = E ^ 1;
m = (f | 0) == 0;
if (!(u ^ 1 | D | m))
gb[c[(c[f >> 2] | 0) + 8 >> 2] & 63](f, d);
if (!(u | E | m))
gb[c[(c[f >> 2] | 0) + 12 >> 2] & 63](f, d);
if (p | D | m) {
i = h;
return
}
ib[c[(c[f >> 2] | 0) + 32 >> 2] & 7](f, d, j);
i = h;
return
}
function yi(a) {
a = a | 0;
return
}
function zi(a) {
a =
a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Ai(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0;
e = i;
b = Em(f, 148) | 0;
if ((b | 0) == 0) {
g = 0;
i = e;
return g | 0
}
wi(b, a, 0, d, 0);
c[b >> 2] = 6392;
g = b;
i = e;
return g | 0
}
function Bi(a, b) {
a = a | 0;
b = b | 0;
var d = 0;
d = i;
eb[c[(c[a >> 2] | 0) + 4 >> 2] & 127](a);
Fm(b, a, 148);
i = d;
return
}
function Ci(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0;
f = i;
Ue(b, c[(c[a + 48 >> 2] | 0) + 12 >> 2] | 0, d, c[(c[a + 52 >> 2] | 0) + 12 >> 2] | 0, e);
i = f;
return
}
function Di(a) {
a = a | 0;
return
}
function Ei(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Fi(a,
b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0;
e = i;
b = Em(f, 148) | 0;
if ((b | 0) == 0) {
g = 0;
i = e;
return g | 0
}
wi(b, a, 0, d, 0);
c[b >> 2] = 6464;
g = b;
i = e;
return g | 0
}
function Gi(a, b) {
a = a | 0;
b = b | 0;
var d = 0;
d = i;
eb[c[(c[a >> 2] | 0) + 4 >> 2] & 127](a);
Fm(b, a, 148);
i = d;
return
}
function Hi(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0;
f = i;
Te(b, c[(c[a + 48 >> 2] | 0) + 12 >> 2] | 0, d, c[(c[a + 52 >> 2] | 0) + 12 >> 2] | 0, e);
i = f;
return
}
function Ii(a) {
a = a | 0;
return
}
function Ji(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Ki(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l =
0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0;
e = i;
c[b + 0 >> 2] = c[d + 0 >> 2];
c[b + 4 >> 2] = c[d + 4 >> 2];
c[b + 8 >> 2] = c[d + 8 >> 2];
c[b + 12 >> 2] = c[d + 12 >> 2];
c[b + 16 >> 2] = c[d + 16 >> 2];
c[b + 20 >> 2] = c[d + 20 >> 2];
c[b + 24 >> 2] = c[d + 24 >> 2];
f = c[d + 44 >> 2] | 0;
h = b + 36 | 0;
c[h >> 2] = f;
j = c[d + 32 >> 2] | 0;
k = b + 52 | 0;
c[k >> 2] = j;
l = b + 40 | 0;
c[l >> 2] = Ym(f, j * 88 | 0) | 0;
j = Ym(c[h >> 2] | 0, (c[k >> 2] | 0) * 156 | 0) | 0;
h = b + 44 | 0;
c[h >> 2] = j;
c[b + 28 >> 2] = c[d + 36 >> 2];
c[b + 32 >> 2] = c[d + 40 >> 2];
f = c[d + 28 >> 2] | 0;
d = b + 48 | 0;
c[d >> 2] = f;
if ((c[k >> 2] | 0) <= 0) {
i = e;
return
}
m = b + 24 | 0;
n = b + 8 | 0;
b = f;
f = j;
j = 0;
while (1) {
o = c[b + (j << 2) >> 2] | 0;
p = c[o + 48 >> 2] | 0;
q = c[o + 52 >> 2] | 0;
r = +g[(c[p + 12 >> 2] | 0) + 8 >> 2];
s = +g[(c[q + 12 >> 2] | 0) + 8 >> 2];
t = c[p + 8 >> 2] | 0;
p = c[q + 8 >> 2] | 0;
q = c[o + 124 >> 2] | 0;
g[f + (j * 156 | 0) + 136 >> 2] = +g[o + 136 >> 2];
g[f + (j * 156 | 0) + 140 >> 2] = +g[o + 140 >> 2];
g[f + (j * 156 | 0) + 144 >> 2] = +g[o + 144 >> 2];
u = t + 8 | 0;
c[f + (j * 156 | 0) + 112 >> 2] = c[u >> 2];
v = p + 8 | 0;
c[f + (j * 156 | 0) + 116 >> 2] = c[v >> 2];
w = t + 136 | 0;
g[f + (j * 156 | 0) + 120 >> 2] = +g[w >> 2];
x = p + 136 | 0;
g[f + (j * 156 | 0) + 124 >> 2] = +g[x >> 2];
y = t + 144 | 0;
g[f + (j * 156 | 0) + 128 >> 2] = +g[y >> 2];
z = p + 144 | 0;
g[f + (j * 156 | 0) + 132 >> 2] = +g[z >> 2];
c[f + (j * 156 | 0) + 152 >> 2] = j;
c[f + (j * 156 | 0) + 148 >> 2] = q;
A = f + (j * 156 | 0) + 80 | 0;
c[A + 0 >> 2] = 0;
c[A + 4 >> 2] = 0;
c[A + 8 >> 2] = 0;
c[A + 12 >> 2] = 0;
c[A + 16 >> 2] = 0;
c[A + 20 >> 2] = 0;
c[A + 24 >> 2] = 0;
c[A + 28 >> 2] = 0;
A = c[l >> 2] | 0;
c[A + (j * 88 | 0) + 32 >> 2] = c[u >> 2];
c[A + (j * 88 | 0) + 36 >> 2] = c[v >> 2];
g[A + (j * 88 | 0) + 40 >> 2] = +g[w >> 2];
g[A + (j * 88 | 0) + 44 >> 2] = +g[x >> 2];
x = t + 44 | 0;
t = c[x + 4 >> 2] | 0;
w = A + (j * 88 | 0) + 48 | 0;
c[w >> 2] = c[x >> 2];
c[w + 4 >> 2] = t;
t = p + 44 | 0;
p = c[t + 4 >> 2] | 0;
w = A + (j * 88 | 0) + 56 | 0;
c[w >> 2] = c[t >> 2];
c[w + 4 >> 2] = p;
g[A + (j * 88 | 0) + 64 >> 2] = +g[y >> 2];
g[A + (j * 88 | 0) + 68 >> 2] = +g[z >> 2];
z = o + 104 | 0;
y =
c[z + 4 >> 2] | 0;
p = A + (j * 88 | 0) + 16 | 0;
c[p >> 2] = c[z >> 2];
c[p + 4 >> 2] = y;
y = o + 112 | 0;
p = c[y + 4 >> 2] | 0;
z = A + (j * 88 | 0) + 24 | 0;
c[z >> 2] = c[y >> 2];
c[z + 4 >> 2] = p;
c[A + (j * 88 | 0) + 84 >> 2] = q;
g[A + (j * 88 | 0) + 76 >> 2] = r;
g[A + (j * 88 | 0) + 80 >> 2] = s;
c[A + (j * 88 | 0) + 72 >> 2] = c[o + 120 >> 2];
if ((q | 0) > 0) {
p = 0;
do {
z = o + (p * 20 | 0) + 64 | 0;
if ((a[m >> 0] | 0) == 0) {
g[f + (j * 156 | 0) + (p * 36 | 0) + 16 >> 2] = 0;
g[f + (j * 156 | 0) + (p * 36 | 0) + 20 >> 2] = 0
} else {
g[f + (j * 156 | 0) + (p * 36 | 0) + 16 >> 2] = +g[n >> 2] * +g[o + (p * 20 | 0) + 72 >> 2];
g[f + (j * 156 | 0) + (p * 36 | 0) + 20 >> 2] = +g[n >> 2] * +g[o + (p * 20 | 0) + 76 >> 2]
}
y = f + (j * 156 | 0) + (p * 36 | 0) | 0;
g[f + (j *
156 | 0) + (p * 36 | 0) + 24 >> 2] = 0;
g[f + (j * 156 | 0) + (p * 36 | 0) + 28 >> 2] = 0;
g[f + (j * 156 | 0) + (p * 36 | 0) + 32 >> 2] = 0;
w = A + (j * 88 | 0) + (p << 3) | 0;
c[y + 0 >> 2] = 0;
c[y + 4 >> 2] = 0;
c[y + 8 >> 2] = 0;
c[y + 12 >> 2] = 0;
y = z;
z = c[y + 4 >> 2] | 0;
t = w;
c[t >> 2] = c[y >> 2];
c[t + 4 >> 2] = z;
p = p + 1 | 0
} while ((p | 0) != (q | 0))
}
q = j + 1 | 0;
if ((q | 0) >= (c[k >> 2] | 0))
break;
b = c[d >> 2] | 0;
f = c[h >> 2] | 0;
j = q
}
i = e;
return
}
function Li(a) {
a = a | 0;
var b = 0,
d = 0;
b = i;
d = a + 36 | 0;
_m(c[d >> 2] | 0, c[a + 44 >> 2] | 0);
_m(c[d >> 2] | 0, c[a + 40 >> 2] | 0);
i = b;
return
}
function Mi(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0;
b = i;
i = i + 64 | 0;
d = b + 48 | 0;
e = b + 32 | 0;
f = b;
h = a + 52 | 0;
if ((c[h >> 2] | 0) <= 0) {
i = b;
return
}
j = a + 44 | 0;
k = a + 40 | 0;
l = a + 48 | 0;
m = a + 28 | 0;
n = a + 32 | 0;
a = d + 8 | 0;
o = d + 12 | 0;
p = e + 8 | 0;
q = e + 12 | 0;
r = 0;
do {
s = c[j >> 2] | 0;
t = c[k >> 2] | 0;
u = +g[t + (r * 88 | 0) + 76 >> 2];
v = +g[t + (r * 88 | 0) + 80 >> 2];
w = (c[(c[l >> 2] | 0) + (c[s + (r * 156 | 0) + 152 >> 2] << 2) >> 2] | 0) + 64 | 0;
x = c[s + (r * 156 | 0) + 112 >> 2] | 0;
y = c[s + (r * 156 | 0) + 116 >> 2] |
0;
z = +g[s + (r * 156 | 0) + 120 >> 2];
A = +g[s + (r * 156 | 0) + 124 >> 2];
B = +g[s + (r * 156 | 0) + 128 >> 2];
C = +g[s + (r * 156 | 0) + 132 >> 2];
D = t + (r * 88 | 0) + 48 | 0;
E = +g[D >> 2];
F = +g[D + 4 >> 2];
D = t + (r * 88 | 0) + 56 | 0;
G = +g[D >> 2];
H = +g[D + 4 >> 2];
D = c[m >> 2] | 0;
t = D + (x * 12 | 0) | 0;
I = +g[t >> 2];
J = +g[t + 4 >> 2];
K = +g[D + (x * 12 | 0) + 8 >> 2];
t = c[n >> 2] | 0;
L = t + (x * 12 | 0) | 0;
M = +g[L >> 2];
N = +g[L + 4 >> 2];
O = +g[t + (x * 12 | 0) + 8 >> 2];
x = D + (y * 12 | 0) | 0;
P = +g[x >> 2];
Q = +g[x + 4 >> 2];
R = +g[D + (y * 12 | 0) + 8 >> 2];
D = t + (y * 12 | 0) | 0;
U = +g[D >> 2];
V = +g[D + 4 >> 2];
W = +g[t + (y * 12 | 0) + 8 >> 2];
X = +T(+K);
g[a >> 2] = X;
Y = +S(+K);
g[o >> 2] = Y;
K = +T(+R);
g[p >> 2] = K;
Z = +S(+R);
g[q >> 2] = Z;
R = +(I - (E * Y - F * X));
_ = +(J - (F * Y + E * X));
y = d;
g[y >> 2] = R;
g[y + 4 >> 2] = _;
_ = +(P - (G * Z - H * K));
R = +(Q - (H * Z + G * K));
y = e;
g[y >> 2] = _;
g[y + 4 >> 2] = R;
jf(f, w, d, u, e, v);
w = s + (r * 156 | 0) + 72 | 0;
y = f;
t = c[y + 4 >> 2] | 0;
D = w;
c[D >> 2] = c[y >> 2];
c[D + 4 >> 2] = t;
t = s + (r * 156 | 0) + 148 | 0;
D = c[t >> 2] | 0;
do if ((D | 0) > 0) {
y = s + (r * 156 | 0) + 76 | 0;
v = z + A;
x = s + (r * 156 | 0) + 140 | 0;
L = 0;
do {
$ = f + (L << 3) + 8 | 0;
u = +g[$ >> 2] - I;
aa = f + (L << 3) + 12 | 0;
R = +u;
_ = +(+g[aa >> 2] - J);
ba = s + (r * 156 | 0) + (L * 36 | 0) | 0;
g[ba >> 2] = R;
g[ba + 4 >> 2] = _;
_ = +g[$ >> 2] - P;
R = +_;
K = +(+g[aa >> 2] - Q);
aa = s + (r * 156 | 0) + (L *
36 | 0) + 8 | 0;
g[aa >> 2] = R;
g[aa + 4 >> 2] = K;
K = +g[y >> 2];
R = +g[s + (r * 156 | 0) + (L * 36 | 0) + 4 >> 2];
G = +g[w >> 2];
Z = u * K - R * G;
H = +g[s + (r * 156 | 0) + (L * 36 | 0) + 12 >> 2];
X = K * _ - G * H;
G = v + Z * B * Z + X * C * X;
if (G > 0)
ca = 1 / G;
else
ca = 0;
g[s + (r * 156 | 0) + (L * 36 | 0) + 24 >> 2] = ca;
G = +g[y >> 2];
X = -+g[w >> 2];
Z = u * X - G * R;
K = _ * X - G * H;
G = v + Z * B * Z + K * C * K;
if (G > 0)
da = 1 / G;
else
da = 0;
g[s + (r * 156 | 0) + (L * 36 | 0) + 28 >> 2] = da;
aa = s + (r * 156 | 0) + (L * 36 | 0) + 32 | 0;
g[aa >> 2] = 0;
G = +g[w >> 2] * (U - W * H - M + O * R) + +g[y >> 2] * (V + W * _ - N - O * u);
if (G < -1)
g[aa >> 2] = -(G * +g[x >> 2]);
L = L + 1 | 0
} while ((L | 0) != (D | 0));
if ((c[t >> 2] | 0) == 2) {
v = +g[s +
(r * 156 | 0) + 76 >> 2];
G = +g[w >> 2];
u = +g[s + (r * 156 | 0) >> 2] * v - +g[s + (r * 156 | 0) + 4 >> 2] * G;
_ = v * +g[s + (r * 156 | 0) + 8 >> 2] - G * +g[s + (r * 156 | 0) + 12 >> 2];
R = v * +g[s + (r * 156 | 0) + 36 >> 2] - G * +g[s + (r * 156 | 0) + 40 >> 2];
H = v * +g[s + (r * 156 | 0) + 44 >> 2] - G * +g[s + (r * 156 | 0) + 48 >> 2];
G = z + A;
v = B * u;
K = C * _;
Z = G + u * v + _ * K;
_ = G + R * B * R + H * C * H;
u = G + v * R + K * H;
H = Z * _ - u * u;
if (!(Z * Z < H * 1E3)) {
c[t >> 2] = 1;
break
}
g[s + (r * 156 | 0) + 96 >> 2] = Z;
g[s + (r * 156 | 0) + 100 >> 2] = u;
g[s + (r * 156 | 0) + 104 >> 2] = u;
g[s + (r * 156 | 0) + 108 >> 2] = _;
if (H != 0)
ea = 1 / H;
else
ea = H;
H = -(ea * u);
g[s + (r * 156 | 0) + 80 >> 2] = _ * ea;
g[s + (r * 156 | 0) + 84 >> 2] =
H;
g[s + (r * 156 | 0) + 88 >> 2] = H;
g[s + (r * 156 | 0) + 92 >> 2] = Z * ea
}
}
while (0);
r = r + 1 | 0
} while ((r | 0) < (c[h >> 2] | 0));
i = b;
return
}
function Ni(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0;
b = i;
d = a + 52 | 0;
if ((c[d >> 2] | 0) <= 0) {
i = b;
return
}
e = a + 44 | 0;
f = a + 32 | 0;
a = c[f >> 2] | 0;
h = 0;
do {
j = c[e >> 2] | 0;
k = c[j + (h * 156 | 0) + 112 >> 2] | 0;
l = c[j + (h * 156 | 0) + 116 >> 2] | 0;
m = +g[j + (h * 156 | 0) + 120 >> 2];
n = +g[j + (h * 156 | 0) + 128 >> 2];
o = +g[j + (h *
156 | 0) + 124 >> 2];
p = +g[j + (h * 156 | 0) + 132 >> 2];
q = c[j + (h * 156 | 0) + 148 >> 2] | 0;
r = a + (k * 12 | 0) | 0;
s = r;
t = +g[s >> 2];
u = +g[s + 4 >> 2];
v = +g[a + (k * 12 | 0) + 8 >> 2];
s = a + (l * 12 | 0) | 0;
w = +g[s >> 2];
x = +g[s + 4 >> 2];
y = +g[a + (l * 12 | 0) + 8 >> 2];
s = j + (h * 156 | 0) + 72 | 0;
z = +g[s >> 2];
A = +g[s + 4 >> 2];
if ((q | 0) > 0) {
B = t;
C = u;
D = w;
E = x;
s = 0;
F = v;
G = y;
while (1) {
H = +g[j + (h * 156 | 0) + (s * 36 | 0) + 16 >> 2];
I = +g[j + (h * 156 | 0) + (s * 36 | 0) + 20 >> 2];
J = z * H + A * I;
K = A * H - z * I;
I = F - n * (+g[j + (h * 156 | 0) + (s * 36 | 0) >> 2] * K - +g[j + (h * 156 | 0) + (s * 36 | 0) + 4 >> 2] * J);
H = B - m * J;
L = C - m * K;
M = G + p * (K * +g[j + (h * 156 | 0) + (s * 36 | 0) + 8 >> 2] - J * +g[j +
(h * 156 | 0) + (s * 36 | 0) + 12 >> 2]);
N = D + o * J;
J = E + o * K;
s = s + 1 | 0;
if ((s | 0) == (q | 0)) {
O = L;
P = J;
Q = N;
R = H;
S = I;
T = M;
break
} else {
B = H;
C = L;
D = N;
E = J;
F = I;
G = M
}
}
} else {
O = u;
P = x;
Q = w;
R = t;
S = v;
T = y
}
G = +R;
F = +O;
q = r;
g[q >> 2] = G;
g[q + 4 >> 2] = F;
q = c[f >> 2] | 0;
g[q + (k * 12 | 0) + 8 >> 2] = S;
F = +Q;
G = +P;
s = q + (l * 12 | 0) | 0;
g[s >> 2] = F;
g[s + 4 >> 2] = G;
a = c[f >> 2] | 0;
g[a + (l * 12 | 0) + 8 >> 2] = T;
h = h + 1 | 0
} while ((h | 0) < (c[d >> 2] | 0));
i = b;
return
}
function Oi(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J =
0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0;
b = i;
d = a + 52 | 0;
if ((c[d >> 2] | 0) <= 0) {
i = b;
return
}
e = a + 44 | 0;
f = a + 32 | 0;
a = c[f >> 2] | 0;
h = 0;
do {
j = c[e >> 2] | 0;
k = j + (h * 156 | 0) | 0;
l = c[j + (h * 156 | 0) + 112 >> 2] | 0;
m = c[j + (h * 156 | 0) + 116 >> 2] | 0;
n = +g[j + (h * 156 | 0) + 120 >> 2];
o = +g[j + (h * 156 | 0) + 128 >> 2];
p = +g[j + (h * 156 | 0) + 124 >> 2];
q = +g[j + (h * 156 | 0) + 132 >> 2];
r = j + (h * 156 | 0) + 148 | 0;
s = c[r >> 2] | 0;
t = a + (l * 12 | 0) | 0;
u = t;
v = +g[u >> 2];
w = +g[u + 4 >> 2];
x =
+g[a + (l * 12 | 0) + 8 >> 2];
u = a + (m * 12 | 0) | 0;
y = +g[u >> 2];
z = +g[u + 4 >> 2];
A = +g[a + (m * 12 | 0) + 8 >> 2];
u = j + (h * 156 | 0) + 72 | 0;
B = +g[u >> 2];
C = +g[u + 4 >> 2];
D = -B;
E = +g[j + (h * 156 | 0) + 136 >> 2];
if ((s | 0) > 0) {
u = j + (h * 156 | 0) + 144 | 0;
F = y;
G = z;
H = v;
I = w;
J = 0;
K = x;
L = A;
do {
M = +g[j + (h * 156 | 0) + (J * 36 | 0) + 12 >> 2];
N = +g[j + (h * 156 | 0) + (J * 36 | 0) + 8 >> 2];
O = +g[j + (h * 156 | 0) + (J * 36 | 0) + 4 >> 2];
P = +g[j + (h * 156 | 0) + (J * 36 | 0) >> 2];
Q = E * +g[j + (h * 156 | 0) + (J * 36 | 0) + 16 >> 2];
R = j + (h * 156 | 0) + (J * 36 | 0) + 20 | 0;
S = +g[R >> 2];
T = S - +g[j + (h * 156 | 0) + (J * 36 | 0) + 28 >> 2] * (C * (F - L * M - H + K * O) + (G + L * N - I - K * P) * D - +g[u >> 2]);
U = -Q;
V = T < Q ? T : Q;
Q = V < U ? U : V;
V = Q - S;
g[R >> 2] = Q;
Q = C * V;
S = V * D;
H = H - n * Q;
I = I - n * S;
K = K - o * (P * S - O * Q);
F = F + p * Q;
G = G + p * S;
L = L + q * (N * S - M * Q);
J = J + 1 | 0
} while ((J | 0) != (s | 0));
if ((c[r >> 2] | 0) == 1) {
D = +g[j + (h * 156 | 0) + 12 >> 2];
E = +g[j + (h * 156 | 0) + 8 >> 2];
Q = +g[j + (h * 156 | 0) + 4 >> 2];
M = +g[k >> 2];
s = j + (h * 156 | 0) + 16 | 0;
S = +g[s >> 2];
N = S - +g[j + (h * 156 | 0) + 24 >> 2] * (B * (F - L * D - H + K * Q) + C * (G + L * E - I - K * M) - +g[j + (h * 156 | 0) + 32 >> 2]);
O = N > 0 ? N : 0;
N = O - S;
g[s >> 2] = O;
O = B * N;
S = C * N;
W = H - n * O;
X = I - n * S;
Y = F + p * O;
Z = G + p * S;
_ = K - o * (M * S - Q * O);
$ = L + q * (E * S - D * O)
} else {
aa = I;
ba = H;
ca = G;
da = F;
ea = K;
fa = L;
ga = 8
}
} else {
aa =
w;
ba = v;
ca = z;
da = y;
ea = x;
fa = A;
ga = 8
}
do if ((ga | 0) == 8) {
ga = 0;
s = j + (h * 156 | 0) + 16 | 0;
O = +g[s >> 2];
J = j + (h * 156 | 0) + 52 | 0;
D = +g[J >> 2];
S = +g[j + (h * 156 | 0) + 12 >> 2];
E = +g[j + (h * 156 | 0) + 8 >> 2];
Q = +g[j + (h * 156 | 0) + 4 >> 2];
M = +g[k >> 2];
N = +g[j + (h * 156 | 0) + 48 >> 2];
P = +g[j + (h * 156 | 0) + 44 >> 2];
V = +g[j + (h * 156 | 0) + 40 >> 2];
U = +g[j + (h * 156 | 0) + 36 >> 2];
T = +g[j + (h * 156 | 0) + 104 >> 2];
ha = +g[j + (h * 156 | 0) + 100 >> 2];
ia = B * (da - fa * S - ba + ea * Q) + C * (ca + fa * E - aa - ea * M) - +g[j + (h * 156 | 0) + 32 >> 2] - (O * +g[j + (h * 156 | 0) + 96 >> 2] + D * T);
ja = B * (da - fa * N - ba + ea * V) + C * (ca + fa * P - aa - ea * U) - +g[j + (h * 156 | 0) + 68 >> 2] -
(O * ha + D * +g[j + (h * 156 | 0) + 108 >> 2]);
ka = +g[j + (h * 156 | 0) + 80 >> 2] * ia + +g[j + (h * 156 | 0) + 88 >> 2] * ja;
la = ia * +g[j + (h * 156 | 0) + 84 >> 2] + ja * +g[j + (h * 156 | 0) + 92 >> 2];
ma = -ka;
na = -la;
if (!(!(ka <= -0) | !(la <= -0))) {
la = ma - O;
ka = na - D;
oa = B * la;
pa = C * la;
la = B * ka;
qa = C * ka;
ka = oa + la;
ra = pa + qa;
g[s >> 2] = ma;
g[J >> 2] = na;
W = ba - n * ka;
X = aa - n * ra;
Y = da + p * ka;
Z = ca + p * ra;
_ = ea - o * (M * pa - Q * oa + (U * qa - V * la));
$ = fa + q * (E * pa - S * oa + (P * qa - N * la));
break
}
la = ia * +g[j + (h * 156 | 0) + 24 >> 2];
qa = -la;
if (la <= -0 ? ja + ha * qa >= 0 : 0) {
ha = qa - O;
la = 0 - D;
oa = B * ha;
pa = C * ha;
ha = B * la;
ra = C * la;
la = ha + oa;
ka = ra + pa;
g[s >> 2] = qa;
g[J >> 2] = 0;
W = ba - n * la;
X = aa - n * ka;
Y = da + p * la;
Z = ca + p * ka;
_ = ea - o * (pa * M - oa * Q + (ra * U - ha * V));
$ = fa + q * (pa * E - oa * S + (ra * P - ha * N));
break
}
ha = ja * +g[j + (h * 156 | 0) + 60 >> 2];
ra = -ha;
if (ha <= -0 ? ia + T * ra >= 0 : 0) {
T = 0 - O;
ha = ra - D;
oa = B * T;
pa = C * T;
T = B * ha;
ka = C * ha;
ha = oa + T;
la = pa + ka;
g[s >> 2] = 0;
g[J >> 2] = ra;
W = ba - n * ha;
X = aa - n * la;
Y = da + p * ha;
Z = ca + p * la;
_ = ea - o * (pa * M - oa * Q + (ka * U - T * V));
$ = fa + q * (pa * E - oa * S + (ka * P - T * N));
break
}
if (!(ia >= 0) | !(ja >= 0)) {
W = ba;
X = aa;
Y = da;
Z = ca;
_ = ea;
$ = fa
} else {
ja = 0 - O;
O = 0 - D;
D = B * ja;
ia = C * ja;
ja = B * O;
T = C * O;
O = D + ja;
ka = ia + T;
g[s >> 2] = 0;
g[J >>
2] = 0;
W = ba - n * O;
X = aa - n * ka;
Y = da + p * O;
Z = ca + p * ka;
_ = ea - o * (ia * M - D * Q + (T * U - ja * V));
$ = fa + q * (ia * E - D * S + (T * P - ja * N))
}
}
while (0);
q = +W;
o = +X;
j = t;
g[j >> 2] = q;
g[j + 4 >> 2] = o;
j = c[f >> 2] | 0;
g[j + (l * 12 | 0) + 8 >> 2] = _;
o = +Y;
q = +Z;
k = j + (m * 12 | 0) | 0;
g[k >> 2] = o;
g[k + 4 >> 2] = q;
a = c[f >> 2] | 0;
g[a + (m * 12 | 0) + 8 >> 2] = $;
h = h + 1 | 0
} while ((h | 0) < (c[d >> 2] | 0));
i = b;
return
}
function Pi(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0;
b = i;
d = c[a + 52 >> 2] | 0;
if ((d | 0) <= 0) {
i = b;
return
}
e = c[a + 44 >> 2] | 0;
f = c[a + 48 >> 2] | 0;
a = 0;
do {
h = c[f + (c[e + (a * 156 | 0) + 152 >> 2] << 2) >> 2] | 0;
j = c[e + (a * 156 | 0) + 148 >> 2] | 0;
if ((j | 0) > 0) {
k = 0;
do {
g[h + (k * 20 | 0) + 72 >> 2] = +g[e + (a * 156 | 0) + (k * 36 | 0) + 16 >> 2];
g[h + (k * 20 | 0) + 76 >> 2] = +g[e + (a * 156 | 0) + (k * 36 | 0) + 20 >> 2];
k = k + 1 | 0
} while ((k | 0) < (j | 0))
}
a = a + 1 | 0
} while ((a | 0) < (d | 0));
i = b;
return
}
function Qi(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0;
b = i;
i = i + 64 | 0;
d = b + 40 |
0;
e = b + 24 | 0;
f = b;
h = a + 52 | 0;
if ((c[h >> 2] | 0) <= 0) {
j = 0;
k = j >= -.014999999664723873;
i = b;
return k | 0
}
l = a + 40 | 0;
m = a + 28 | 0;
a = d + 8 | 0;
n = d + 12 | 0;
o = e + 8 | 0;
p = e + 12 | 0;
q = f + 8 | 0;
r = f + 16 | 0;
s = c[m >> 2] | 0;
t = 0;
u = 0;
while (1) {
v = c[l >> 2] | 0;
w = v + (t * 88 | 0) | 0;
x = c[v + (t * 88 | 0) + 32 >> 2] | 0;
y = c[v + (t * 88 | 0) + 36 >> 2] | 0;
z = v + (t * 88 | 0) + 48 | 0;
A = +g[z >> 2];
B = +g[z + 4 >> 2];
C = +g[v + (t * 88 | 0) + 40 >> 2];
D = +g[v + (t * 88 | 0) + 64 >> 2];
z = v + (t * 88 | 0) + 56 | 0;
E = +g[z >> 2];
F = +g[z + 4 >> 2];
G = +g[v + (t * 88 | 0) + 44 >> 2];
H = +g[v + (t * 88 | 0) + 68 >> 2];
z = c[v + (t * 88 | 0) + 84 >> 2] | 0;
v = s + (x * 12 | 0) | 0;
I = +g[v >> 2];
J = +g[v + 4 >> 2];
K =
+g[s + (x * 12 | 0) + 8 >> 2];
v = s + (y * 12 | 0) | 0;
L = +g[v >> 2];
M = +g[v + 4 >> 2];
N = +g[s + (y * 12 | 0) + 8 >> 2];
if ((z | 0) > 0) {
O = C + G;
P = I;
Q = J;
R = L;
U = M;
V = K;
W = N;
v = 0;
X = u;
do {
Y = +T(+V);
g[a >> 2] = Y;
Z = +S(+V);
g[n >> 2] = Z;
_ = +T(+W);
g[o >> 2] = _;
$ = +S(+W);
g[p >> 2] = $;
aa = +(P - (A * Z - B * Y));
ba = +(Q - (B * Z + A * Y));
ca = d;
g[ca >> 2] = aa;
g[ca + 4 >> 2] = ba;
ba = +(R - (E * $ - F * _));
aa = +(U - (F * $ + E * _));
ca = e;
g[ca >> 2] = ba;
g[ca + 4 >> 2] = aa;
Ri(f, w, d, e, v);
ca = f;
aa = +g[ca >> 2];
ba = +g[ca + 4 >> 2];
ca = q;
_ = +g[ca >> 2];
$ = +g[ca + 4 >> 2];
Y = +g[r >> 2];
Z = _ - P;
da = $ - Q;
ea = _ - R;
_ = $ - U;
X = X < Y ? X : Y;
$ = (Y + .004999999888241291) * .20000000298023224;
Y = $ < 0 ? $ : 0;
$ = ba * Z - aa * da;
fa = ba * ea - aa * _;
ga = fa * H * fa + (O + $ * D * $);
if (ga > 0)
ha = -(Y < -.20000000298023224 ? -.20000000298023224 : Y) / ga;
else
ha = 0;
ga = aa * ha;
aa = ba * ha;
P = P - C * ga;
Q = Q - C * aa;
V = V - D * (Z * aa - da * ga);
R = R + G * ga;
U = U + G * aa;
W = W + H * (ea * aa - _ * ga);
v = v + 1 | 0
} while ((v | 0) != (z | 0));
ia = Q;
ja = P;
ka = U;
la = R;
ma = c[m >> 2] | 0;
na = V;
oa = W;
pa = X
} else {
ia = J;
ja = I;
ka = M;
la = L;
ma = s;
na = K;
oa = N;
pa = u
}
H = +ja;
G = +ia;
z = ma + (x * 12 | 0) | 0;
g[z >> 2] = H;
g[z + 4 >> 2] = G;
z = c[m >> 2] | 0;
g[z + (x * 12 | 0) + 8 >> 2] = na;
G = +la;
H = +ka;
v = z + (y * 12 | 0) | 0;
g[v >> 2] = G;
g[v + 4 >> 2] = H;
s = c[m >> 2] | 0;
g[s + (y * 12 | 0) + 8 >>
2] = oa;
t = t + 1 | 0;
if ((t | 0) >= (c[h >> 2] | 0)) {
j = pa;
break
} else
u = pa
}
k = j >= -.014999999664723873;
i = b;
return k | 0
}
function Ri(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0;
h = i;
j = c[b + 72 >> 2] | 0;
if ((j | 0) == 2) {
k = e + 12 | 0;
l = +g[k >> 2];
m = +g[b + 16 >> 2];
n = e + 8 | 0;
o = +g[n >> 2];
p = +g[b + 20 >> 2];
q = l * m - o * p;
r = m * o + l * p;
p = +q;
l = +r;
s = a;
g[s >> 2] = p;
g[s + 4 >> 2] = l;
l = +g[k >> 2];
p = +g[b + 24 >> 2];
o = +g[n >> 2];
m = +g[b + 28 >> 2];
t = +g[d + 12 >> 2];
u = +g[b + (f << 3) >> 2];
v = +g[d + 8 >> 2];
w = +g[b + (f << 3) + 4 >> 2];
x = +g[d >> 2] + (t * u - v * w);
y = u * v + t * w + +g[d + 4 >> 2];
g[a + 16 >> 2] = q * (x - (+g[e >> 2] + (l * p - o * m))) + (y - (p * o + l * m + +g[e + 4 >> 2])) * r - +g[b + 76 >> 2] - +g[b + 80 >> 2];
m = +x;
x = +y;
n = a + 8 | 0;
g[n >> 2] = m;
g[n + 4 >> 2] = x;
x = +-q;
q = +-r;
n = a;
g[n >> 2] = x;
g[n + 4 >> 2] = q;
i = h;
return
} else if ((j | 0) == 1) {
n = d + 12 | 0;
q = +g[n >> 2];
x = +g[b + 16 >> 2];
k = d + 8 | 0;
r = +g[k >> 2];
m = +g[b + 20 >> 2];
y = q * x - r * m;
l = x * r + q * m;
m = +y;
q = +l;
s = a;
g[s >> 2] = m;
g[s + 4 >> 2] = q;
q = +g[n >> 2];
m = +g[b + 24 >> 2];
r = +g[k >> 2];
x = +g[b + 28 >> 2];
o = +g[e + 12 >> 2];
p = +g[b + (f << 3) >> 2];
w = +g[e + 8 >> 2];
t = +g[b + (f << 3) + 4 >> 2];
v = +g[e >> 2] + (o * p - w * t);
u =
p * w + o * t + +g[e + 4 >> 2];
g[a + 16 >> 2] = y * (v - (+g[d >> 2] + (q * m - r * x))) + (u - (m * r + q * x + +g[d + 4 >> 2])) * l - +g[b + 76 >> 2] - +g[b + 80 >> 2];
l = +v;
v = +u;
f = a + 8 | 0;
g[f >> 2] = l;
g[f + 4 >> 2] = v;
i = h;
return
} else if ((j | 0) == 0) {
v = +g[d + 12 >> 2];
l = +g[b + 24 >> 2];
u = +g[d + 8 >> 2];
x = +g[b + 28 >> 2];
q = +g[d >> 2] + (v * l - u * x);
r = l * u + v * x + +g[d + 4 >> 2];
x = +g[e + 12 >> 2];
v = +g[b >> 2];
u = +g[e + 8 >> 2];
l = +g[b + 4 >> 2];
m = +g[e >> 2] + (x * v - u * l);
y = v * u + x * l + +g[e + 4 >> 2];
l = m - q;
x = y - r;
u = +l;
v = +x;
e = a;
g[e >> 2] = u;
g[e + 4 >> 2] = v;
v = +Q(+(l * l + x * x));
if (v < 1.1920928955078125E-7) {
z = l;
A = x
} else {
u = 1 / v;
v = l * u;
g[a >> 2] = v;
t =
x * u;
g[a + 4 >> 2] = t;
z = v;
A = t
}
t = +((q + m) * .5);
m = +((r + y) * .5);
e = a + 8 | 0;
g[e >> 2] = t;
g[e + 4 >> 2] = m;
g[a + 16 >> 2] = l * z + x * A - +g[b + 76 >> 2] - +g[b + 80 >> 2];
i = h;
return
} else {
g[a + 16 >> 2] = 0;
b = 8784;
e = c[b + 4 >> 2] | 0;
d = a;
c[d >> 2] = c[b >> 2];
c[d + 4 >> 2] = e;
e = 8784;
d = c[e + 4 >> 2] | 0;
b = a + 8 | 0;
c[b >> 2] = c[e >> 2];
c[b + 4 >> 2] = d;
i = h;
return
}
}
function Si(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0;
e = i;
i = i + 64 | 0;
f = e + 40 | 0;
h = e + 24 | 0;
j = e;
k = a + 52 | 0;
if ((c[k >> 2] | 0) <= 0) {
l = 0;
m = l >= -.007499999832361937;
i = e;
return m | 0
}
n = a + 40 | 0;
o = a + 28 | 0;
a = f + 8 | 0;
p = f + 12 | 0;
q = h + 8 | 0;
r = h + 12 | 0;
s = j + 8 | 0;
t = j + 16 | 0;
u = 0;
v = 0;
while (1) {
w = c[n >> 2] | 0;
x = w + (u * 88 | 0) | 0;
y = c[w + (u * 88 | 0) + 32 >> 2] | 0;
z = c[w + (u * 88 | 0) + 36 >> 2] | 0;
A = w + (u * 88 | 0) + 48 | 0;
B = +g[A >> 2];
C = +g[A + 4 >> 2];
A = w + (u * 88 | 0) + 56 | 0;
D = +g[A >> 2];
E = +g[A + 4 >> 2];
A = c[w + (u * 88 | 0) + 84 >> 2] | 0;
if ((y | 0) == (b | 0) | (y | 0) == (d | 0)) {
F = +g[w +
(u * 88 | 0) + 64 >> 2];
G = +g[w + (u * 88 | 0) + 40 >> 2]
} else {
F = 0;
G = 0
}
if ((z | 0) == (b | 0) | (z | 0) == (d | 0)) {
H = +g[w + (u * 88 | 0) + 68 >> 2];
I = +g[w + (u * 88 | 0) + 44 >> 2]
} else {
H = 0;
I = 0
}
w = c[o >> 2] | 0;
J = w + (y * 12 | 0) | 0;
K = +g[J >> 2];
L = +g[J + 4 >> 2];
M = +g[w + (y * 12 | 0) + 8 >> 2];
J = w + (z * 12 | 0) | 0;
N = +g[J >> 2];
O = +g[J + 4 >> 2];
P = +g[w + (z * 12 | 0) + 8 >> 2];
if ((A | 0) > 0) {
Q = G + I;
R = N;
U = O;
V = K;
W = L;
X = M;
Y = P;
J = 0;
Z = v;
do {
_ = +T(+X);
g[a >> 2] = _;
$ = +S(+X);
g[p >> 2] = $;
aa = +T(+Y);
g[q >> 2] = aa;
ba = +S(+Y);
g[r >> 2] = ba;
ca = +(V - (B * $ - C * _));
da = +(W - (C * $ + B * _));
ea = f;
g[ea >> 2] = ca;
g[ea + 4 >> 2] = da;
da = +(R - (D * ba - E * aa));
ca = +(U -
(E * ba + D * aa));
ea = h;
g[ea >> 2] = da;
g[ea + 4 >> 2] = ca;
Ri(j, x, f, h, J);
ea = j;
ca = +g[ea >> 2];
da = +g[ea + 4 >> 2];
ea = s;
aa = +g[ea >> 2];
ba = +g[ea + 4 >> 2];
_ = +g[t >> 2];
$ = aa - V;
fa = ba - W;
ga = aa - R;
aa = ba - U;
Z = Z < _ ? Z : _;
ba = (_ + .004999999888241291) * .75;
_ = ba < 0 ? ba : 0;
ba = da * $ - ca * fa;
ha = da * ga - ca * aa;
ia = ha * H * ha + (Q + ba * F * ba);
if (ia > 0)
ja = -(_ < -.20000000298023224 ? -.20000000298023224 : _) / ia;
else
ja = 0;
ia = ca * ja;
ca = da * ja;
V = V - G * ia;
W = W - G * ca;
X = X - F * ($ * ca - fa * ia);
R = R + I * ia;
U = U + I * ca;
Y = Y + H * (ga * ca - aa * ia);
J = J + 1 | 0
} while ((J | 0) != (A | 0));
ka = W;
la = V;
ma = U;
na = R;
oa = c[o >> 2] | 0;
pa = X;
qa = Y;
ra = Z
} else {
ka = L;
la = K;
ma = O;
na = N;
oa = w;
pa = M;
qa = P;
ra = v
}
Q = +la;
D = +ka;
A = oa + (y * 12 | 0) | 0;
g[A >> 2] = Q;
g[A + 4 >> 2] = D;
A = c[o >> 2] | 0;
g[A + (y * 12 | 0) + 8 >> 2] = pa;
D = +na;
Q = +ma;
J = A + (z * 12 | 0) | 0;
g[J >> 2] = D;
g[J + 4 >> 2] = Q;
g[(c[o >> 2] | 0) + (z * 12 | 0) + 8 >> 2] = qa;
u = u + 1 | 0;
if ((u | 0) >= (c[k >> 2] | 0)) {
l = ra;
break
} else
v = ra
}
m = l >= -.007499999832361937;
i = e;
return m | 0
}
function Ti(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0;
e = i;
b = Em(f, 148) | 0;
if ((b | 0) == 0) {
g = 0;
i = e;
return g | 0
}
wi(b, a, 0, d, 0);
c[b >> 2] = 6528;
g = b;
i = e;
return g | 0
}
function Ui(a, b) {
a = a | 0;
b = b | 0;
var d =
0;
d = i;
eb[c[(c[a >> 2] | 0) + 4 >> 2] & 127](a);
Fm(b, a, 148);
i = d;
return
}
function Vi(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0;
f = i;
cf(b, c[(c[a + 48 >> 2] | 0) + 12 >> 2] | 0, d, c[(c[a + 52 >> 2] | 0) + 12 >> 2] | 0, e);
i = f;
return
}
function Wi(a) {
a = a | 0;
return
}
function Xi(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Yi(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0,
h = 0,
j = 0;
g = i;
h = Em(f, 148) | 0;
if ((h | 0) == 0) {
j = 0;
i = g;
return j | 0
}
wi(h, a, b, d, e);
c[h >> 2] = 6600;
j = h;
i = g;
return j | 0
}
function Zi(a, b) {
a = a | 0;
b = b | 0;
var d = 0;
d = i;
eb[c[(c[a >> 2] | 0) + 4 >> 2] & 127](a);
Fm(b, a, 148);
i = d;
return
}
function _i(a, d, e, f) {
a = a | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0;
h = i;
i = i + 48 | 0;
j = h;
k = c[(c[a + 48 >> 2] | 0) + 12 >> 2] | 0;
c[j >> 2] = 488;
c[j + 4 >> 2] = 1;
g[j + 8 >> 2] = .009999999776482582;
l = j + 28 | 0;
c[l + 0 >> 2] = 0;
c[l + 4 >> 2] = 0;
c[l + 8 >> 2] = 0;
c[l + 12 >> 2] = 0;
b[l + 16 >> 1] = 0;
Ge(k, j, c[a + 56 >> 2] | 0);
cf(d, j, e, c[(c[a + 52 >> 2] | 0) + 12 >> 2] | 0, f);
i = h;
return
}
function $i(a) {
a = a | 0;
return
}
function aj(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function bj(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0;
e = i;
b = Em(f, 148) | 0;
if ((b | 0) == 0) {
g = 0;
i = e;
return g | 0
}
wi(b, a, 0, d, 0);
c[b >> 2] = 6672;
g = b;
i = e;
return g | 0
}
function cj(a, b) {
a = a | 0;
b = b | 0;
var d = 0;
d = i;
eb[c[(c[a >> 2] | 0) + 4 >> 2] & 127](a);
Fm(b, a, 148);
i = d;
return
}
function dj(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0;
f = i;
ff(b, c[(c[a + 48 >> 2] | 0) + 12 >> 2] | 0, d, c[(c[a + 52 >> 2] | 0) + 12 >> 2] | 0, e);
i = f;
return
}
function ej(a) {
a = a | 0;
return
}
function fj(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function gj(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0;
e = i;
b = Em(f, 148) | 0;
if ((b | 0) == 0) {
g = 0;
i = e;
return g | 0
}
wi(b, a, 0, d, 0);
c[b >> 2] = 6744;
g = b;
i = e;
return g | 0
}
function hj(a, b) {
a = a | 0;
b = b | 0;
var d = 0;
d = i;
eb[c[(c[a >> 2] | 0) + 4 >> 2] & 127](a);
Fm(b, a, 148);
i = d;
return
}
function ij(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0;
f = i;
gf(b, c[(c[a + 48 >> 2] | 0) + 12 >> 2] | 0, d, c[(c[a + 52 >> 2] | 0) + 12 >> 2] | 0, e);
i = f;
return
}
function jj(a) {
a = a | 0;
return
}
function kj(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function lj(a) {
a = a | 0;
var d = 0;
d = i;
b[a + 32 >> 1] = 1;
b[a + 34 >> 1] = -1;
b[a + 36 >> 1] = 0;
c[a + 40 >> 2] = 0;
c[a + 24 >> 2] = 0;
c[a + 28 >> 2] = 0;
c[a + 0 >> 2] = 0;
c[a + 4 >> 2] = 0;
c[a + 8 >> 2] = 0;
c[a + 12 >> 2] = 0;
i = d;
return
}
function mj(d,
e, f, h) {
d = d | 0;
e = e | 0;
f = f | 0;
h = h | 0;
var j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
j = i;
c[d + 40 >> 2] = c[h + 4 >> 2];
g[d + 16 >> 2] = +g[h + 8 >> 2];
g[d + 20 >> 2] = +g[h + 12 >> 2];
c[d + 8 >> 2] = f;
c[d + 4 >> 2] = 0;
f = d + 32 | 0;
k = h + 22 | 0;
b[f + 0 >> 1] = b[k + 0 >> 1] | 0;
b[f + 2 >> 1] = b[k + 2 >> 1] | 0;
b[f + 4 >> 1] = b[k + 4 >> 1] | 0;
a[d + 38 >> 0] = a[h + 20 >> 0] | 0;
k = c[h >> 2] | 0;
f = nb[c[(c[k >> 2] | 0) + 8 >> 2] & 31](k, e) | 0;
c[d + 12 >> 2] = f;
k = bb[c[(c[f >> 2] | 0) + 12 >> 2] & 7](f) | 0;
f = Em(e, k * 28 | 0) | 0;
e = d + 24 | 0;
c[e >> 2] = f;
if ((k | 0) > 0) {
l = f;
m = 0
} else {
n = d + 28 | 0;
c[n >> 2] = 0;
o = h + 16 | 0;
p = +g[o >> 2];
g[d >> 2] = p;
i = j;
return
}
do {
c[l + (m * 28 | 0) + 16 >>
2] = 0;
l = c[e >> 2] | 0;
c[l + (m * 28 | 0) + 24 >> 2] = -1;
m = m + 1 | 0
} while ((m | 0) != (k | 0));
n = d + 28 | 0;
c[n >> 2] = 0;
o = h + 16 | 0;
p = +g[o >> 2];
g[d >> 2] = p;
i = j;
return
}
function nj(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0;
d = i;
e = a + 12 | 0;
f = c[e >> 2] | 0;
g = bb[c[(c[f >> 2] | 0) + 12 >> 2] & 7](f) | 0;
f = a + 24 | 0;
Fm(b, c[f >> 2] | 0, g * 28 | 0);
c[f >> 2] = 0;
f = c[e >> 2] | 0;
g = c[f + 4 >> 2] | 0;
if ((g | 0) == 1) {
eb[c[c[f >> 2] >> 2] & 127](f);
Fm(b, f, 48);
c[e >> 2] = 0;
i = d;
return
} else if ((g | 0) == 3) {
eb[c[c[f >> 2] >> 2] & 127](f);
Fm(b, f, 40);
c[e >> 2] = 0;
i = d;
return
} else if ((g | 0) == 0) {
eb[c[c[f >> 2] >> 2] & 127](f);
Fm(b, f, 20);
c[e >> 2] = 0;
i = d;
return
} else if ((g | 0) == 2) {
eb[c[c[f >> 2] >> 2] & 127](f);
Fm(b, f, 152);
c[e >> 2] = 0;
i = d;
return
} else {
c[e >> 2] = 0;
i = d;
return
}
}
function oj(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0;
e = i;
f = a + 12 | 0;
g = c[f >> 2] | 0;
h = bb[c[(c[g >> 2] | 0) + 12 >> 2] & 7](g) | 0;
g = a + 28 | 0;
c[g >> 2] = h;
if ((h | 0) <= 0) {
i = e;
return
}
h = a + 24 | 0;
j = 0;
do {
k = c[h >> 2] | 0;
l = k + (j * 28 | 0) | 0;
m = c[f >> 2] | 0;
pb[c[(c[m >> 2] | 0) + 28 >> 2] & 31](m, l, d, j);
c[k + (j * 28 | 0) + 24 >> 2] = Oe(b, l, l) | 0;
c[k + (j * 28 | 0) + 16 >> 2] = a;
c[k + (j * 28 | 0) + 20 >> 2] = j;
j = j + 1 | 0
} while ((j | 0) < (c[g >> 2] | 0));
i =
e;
return
}
function pj(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0;
d = i;
e = a + 28 | 0;
if ((c[e >> 2] | 0) <= 0) {
c[e >> 2] = 0;
i = d;
return
}
f = a + 24 | 0;
a = 0;
do {
g = (c[f >> 2] | 0) + (a * 28 | 0) + 24 | 0;
Pe(b, c[g >> 2] | 0);
c[g >> 2] = -1;
a = a + 1 | 0
} while ((a | 0) < (c[e >> 2] | 0));
c[e >> 2] = 0;
i = d;
return
}
function qj(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0;
f = i;
i = i + 48 | 0;
h = f + 24 | 0;
j = f + 8 | 0;
k = f;
l = a + 28 | 0;
if ((c[l >> 2] | 0) <= 0) {
i = f;
return
}
m = a + 24 | 0;
n = a + 12 | 0;
a = h + 4 | 0;
o = j + 4 | 0;
p = h + 8 | 0;
q = j + 8 |
0;
r = h + 12 | 0;
s = j + 12 | 0;
t = e + 4 | 0;
u = d + 4 | 0;
v = k + 4 | 0;
w = 0;
do {
x = c[m >> 2] | 0;
y = c[n >> 2] | 0;
z = x + (w * 28 | 0) + 20 | 0;
pb[c[(c[y >> 2] | 0) + 28 >> 2] & 31](y, h, d, c[z >> 2] | 0);
y = c[n >> 2] | 0;
pb[c[(c[y >> 2] | 0) + 28 >> 2] & 31](y, j, e, c[z >> 2] | 0);
z = x + (w * 28 | 0) | 0;
A = +g[h >> 2];
B = +g[j >> 2];
C = +g[a >> 2];
D = +g[o >> 2];
E = +(A < B ? A : B);
B = +(C < D ? C : D);
y = z;
g[y >> 2] = E;
g[y + 4 >> 2] = B;
B = +g[p >> 2];
E = +g[q >> 2];
D = +g[r >> 2];
C = +g[s >> 2];
A = +(B > E ? B : E);
E = +(D > C ? D : C);
y = x + (w * 28 | 0) + 8 | 0;
g[y >> 2] = A;
g[y + 4 >> 2] = E;
E = +g[t >> 2] - +g[u >> 2];
g[k >> 2] = +g[e >> 2] - +g[d >> 2];
g[v >> 2] = E;
Qe(b, c[x + (w * 28 | 0) + 24 >> 2] | 0, z, k);
w = w + 1 | 0
} while ((w | 0) < (c[l >> 2] | 0));
i = f;
return
}
function rj(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0;
e = i;
Cm(b);
Wm(b + 76 | 0);
Sj(b + 102880 | 0);
c[b + 102992 >> 2] = 0;
c[b + 102996 >> 2] = 0;
f = b + 102960 | 0;
h = b + 103004 | 0;
c[f + 0 >> 2] = 0;
c[f + 4 >> 2] = 0;
c[f + 8 >> 2] = 0;
c[f + 12 >> 2] = 0;
c[f + 16 >> 2] = 0;
a[h >> 0] = 1;
a[b + 103005 >> 0] = 1;
a[b + 103006 >> 0] = 0;
a[b + 103007 >> 0] = 1;
a[b + 102988 >> 0] = 1;
h = d;
d = c[h + 4 >> 2] | 0;
f = b + 102980 | 0;
c[f >> 2] = c[h >> 2];
c[f + 4 >> 2] = d;
c[b + 102876 >> 2] = 4;
g[b + 103E3 >> 2] = 0;
c[b + 102956 >> 2] = b;
c[b + 103040 >> 2] = 8792;
c[b + 103044 >> 2] = c[2206];
d = b + 103008 | 0;
c[d + 0 >> 2] = 0;
c[d + 4 >> 2] = 0;
c[d + 8 >> 2] = 0;
c[d + 12 >> 2] = 0;
c[d + 16 >> 2] = 0;
c[d + 20 >> 2] = 0;
c[d + 24 >> 2] = 0;
c[d + 28 >> 2] = 0;
i = e;
return
}
function qb(a) {
a = a | 0;
var b = 0;
b = i;
i = i + a | 0;
i = i + 7 & -8;
return b | 0
}
function rb() {
return i | 0
}
function sb(a) {
a = a | 0;
i = a
}
function tb(a, b) {
a = a | 0;
b = b | 0;
if ((p | 0) == 0) {
p = a;
q = b
}
}
function ub(b) {
b = b | 0;
a[k >> 0] = a[b >> 0];
a[k + 1 >> 0] = a[b + 1 >> 0];
a[k + 2 >> 0] = a[b + 2 >> 0];
a[k + 3 >> 0] = a[b + 3 >> 0]
}
function vb(b) {
b = b | 0;
a[k >> 0] = a[b >> 0];
a[k + 1 >> 0] = a[b + 1 >> 0];
a[k + 2 >> 0] = a[b + 2 >> 0];
a[k + 3 >> 0] = a[b + 3 >> 0];
a[k + 4 >> 0] = a[b + 4 >> 0];
a[k + 5 >> 0] = a[b + 5 >> 0];
a[k + 6 >>
0] = a[b + 6 >> 0];
a[k + 7 >> 0] = a[b + 7 >> 0]
}
function wb(a) {
a = a | 0;
E = a
}
function xb() {
return E | 0
}
function yb(a) {
a = a | 0;
return 1+(c[a + 60 >> 2] | 0)
}
function zb(d, e, f, j, k, l, m, n, o, p, q) {
d = d | 0;
e = +e;
f = +f;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = p | 0;
q = +q;
var r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0;
r = i;
i = i + 1104 | 0;
s = r;
t = r + 1072 | 0;
u = r + 1032 | 0;
v = r + 8 | 0;
h[s >> 3] = l;
c[t >> 2] = 0;
g[t + 16 >> 2] = e;
g[t + 8 >> 2] = f;
a[t + 20 >> 0] = j != 0 & 1;
g[t + 12 >> 2] = k;
c[t + 4 >> 2] = s;
b[t + 22 >> 1] = ~~m;
b[t + 26 >> 1] = ~~n;
b[t + 24 >> 1] = ~~o;
c[u >> 2] = 760;
c[u + 4 >> 2] = 3;
g[u + 8 >> 2] = .009999999776482582;
c[u + 12 >>
2] = 0;
c[u + 16 >> 2] = 0;
a[u + 36 >> 0] = 0;
a[u + 37 >> 0] = 0;
s = ~~(q * .5);
if (q > 0) {
w = 0;
x = 0
} else {
De(u, v, s);
c[t >> 2] = u;
y = Mj(d, t) | 0;
Ce(u);
i = r;
return y | 0
}
while (1) {
o = ++g[p + (w << 2) >> 2];
n = ++g[p + ((w | 1) << 2) >> 2];
z = v + (x << 3) | 0;
g[z >> 2] = o;
g[z + 4 >> 2] = n;
w = w + 2 | 0;
if (!(+(w | 0) < q))
break;
else
x = x + 1 | 0
}
De(u, v, s);
c[t >> 2] = u;
y = Mj(d, t) | 0;
Ce(u);
i = r;
return y | 0
}
function Ab(a) {
a = a | 0;
Ha(a | 0) | 0;
xa()
}
function Bb(d, e, f, j, k, l, m, n, o, p, q, r) {
d = d | 0;
e = +e;
f = +f;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
var s = 0,
t = 0,
u = 0,
v = 0;
s = i;
i = i + 64 | 0;
t = s;
u = s + 28 | 0;
v = s + 8 | 0;
h[t >>
3] = l;
g[u + 16 >> 2] = e;
g[u + 8 >> 2] = f;
a[u + 20 >> 0] = j != 0 & 1;
g[u + 12 >> 2] = k;
c[u + 4 >> 2] = t;
b[u + 22 >> 1] = ~~m;
b[u + 26 >> 1] = ~~n;
b[u + 24 >> 1] = ~~o;
c[v >> 2] = 680;
t = v + 4 | 0;
c[t + 0 >> 2] = 0;
c[t + 4 >> 2] = 0;
c[t + 8 >> 2] = 0;
g[v + 12 >> 2] = p;
g[v + 16 >> 2] = q;
g[v + 8 >> 2] = r;
c[u >> 2] = v;
v = Mj(d, u) | 0;
i = s;
return v | 0
}
function Cb(a) {
a = a | 0;
return
}
function Db(b, d, e, f, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B) {
b = b | 0;
d = +d;
e = +e;
f = +f;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
t = +t;
u = +u;
v = +v;
w = +w;
x = +x;
y = +y;
z = +z;
A = +A;
B = +B;
var C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N =
0,
O = 0,
P = 0,
Q = 0;
C = i;
i = i + 112 | 0;
D = C;
E = C + 28 | 0;
F = C + 8 | 0;
h[D >> 3] = y;
G = E + 8 | 0;
H = E + 20 | 0;
I = E + 4 | 0;
J = E + 16 | 0;
K = E + 28 | 0;
L = E + 32 | 0;
M = E + 33 | 0;
N = E + 34 | 0;
O = E + 35 | 0;
P = E + 36 | 0;
Q = E + 40 | 0;
c[Q + 0 >> 2] = 0;
c[Q + 4 >> 2] = 0;
c[Q + 8 >> 2] = 0;
c[Q + 12 >> 2] = 0;
c[Q + 16 >> 2] = 0;
c[Q + 20 >> 2] = 0;
c[Q + 24 >> 2] = 0;
g[J >> 2] = d;
g[K >> 2] = e;
a[L >> 0] = ~~f;
a[M >> 0] = ~~j;
a[N >> 0] = ~~k;
a[O >> 0] = ~~l;
c[E >> 2] = ~~m >>> 0;
c[E + 72 >> 2] = 0;
c[I >> 2] = ~~o >>> 0;
g[E + 64 >> 2] = p;
p = +q;
q = +r;
I = H;
g[I >> 2] = p;
g[I + 4 >> 2] = q;
q = +s;
s = +t;
I = G;
g[I >> 2] = q;
g[I + 4 >> 2] = s;
c[E + 60 >> 2] = 0;
c[E + 56 >> 2] = ~~v;
c[E + 48 >> 2] = 0;
c[E + 44 >> 2] = 0;
g[P >>
2] = w;
g[E + 52 >> 2] = x;
c[E + 68 >> 2] = D;
c[F >> 2] = 680;
c[F + 4 >> 2] = 0;
x = +z;
z = +A;
D = F + 12 | 0;
g[D >> 2] = x;
g[D + 4 >> 2] = z;
g[F + 8 >> 2] = B;
c[Q >> 2] = F;
F = Fk(b, E) | 0;
i = C;
return F | 0
}
function Eb(a, b, d, e, f, h, j, k) {
a = a | 0;
b = +b;
d = +d;
e = +e;
f = +f;
h = +h;
j = +j;
k = +k;
var l = 0,
m = 0,
n = 0,
o = 0;
l = i;
i = i + 48 | 0;
m = l + 16 | 0;
n = l;
c[m >> 2] = 680;
o = m + 4 | 0;
c[o + 0 >> 2] = 0;
c[o + 4 >> 2] = 0;
c[o + 8 >> 2] = 0;
g[m + 12 >> 2] = b;
g[m + 16 >> 2] = d;
g[m + 8 >> 2] = e;
g[n >> 2] = f;
g[n + 4 >> 2] = h;
g[n + 8 >> 2] = j;
g[n + 12 >> 2] = k;
k = +(Ck(a, m, n, 0) | 0);
i = l;
return +k
}
function Fb(d, e, f, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) {
d = d | 0;
e = +e;
f = +f;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
t = +t;
u = +u;
v = +v;
w = +w;
x = +x;
y = +y;
var z = 0,
A = 0,
B = 0,
C = 0;
z = i;
i = i + 96 | 0;
A = z;
B = z + 56 | 0;
C = z + 8 | 0;
h[A >> 3] = l;
g[B + 16 >> 2] = e;
g[B + 8 >> 2] = f;
a[B + 20 >> 0] = j != 0 & 1;
g[B + 12 >> 2] = k;
c[B + 4 >> 2] = A;
b[B + 22 >> 1] = ~~m;
b[B + 26 >> 1] = ~~n;
b[B + 24 >> 1] = ~~o;
c[C >> 2] = 488;
c[C + 4 >> 2] = 1;
g[C + 8 >> 2] = .009999999776482582;
A = C + 28 | 0;
c[A + 0 >> 2] = 0;
c[A + 4 >> 2] = 0;
c[A + 8 >> 2] = 0;
c[A + 12 >> 2] = 0;
b[A + 16 >> 1] = 0;
o = +r;
r = +s;
A = C + 28 | 0;
g[A >> 2] = o;
g[A + 4 >> 2] = r;
r = +t;
t = +u;
A = C + 12 | 0;
g[A >> 2] = r;
g[A + 4 >> 2] = t;
t = +v;
v = +w;
A = C + 20 | 0;
g[A >> 2] = t;
g[A + 4 >> 2] =
v;
v = +x;
x = +y;
A = C + 36 | 0;
g[A >> 2] = v;
g[A + 4 >> 2] = x;
a[C + 44 >> 0] = p != 0 & 1;
a[C + 45 >> 0] = q != 0 & 1;
c[B >> 2] = C;
C = Mj(d, B) | 0;
i = z;
return C | 0
}
function Gb(a) {
a = a | 0;
return
}
function Hb(d, e, f, j, k, l, m, n, o, p, q, r, s, t, u) {
d = d | 0;
e = +e;
f = +f;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
t = +t;
u = +u;
var v = 0,
w = 0,
x = 0,
y = 0,
z = 0;
v = i;
i = i + 224 | 0;
w = v;
x = v + 184 | 0;
y = v + 160 | 0;
z = v + 8 | 0;
h[w >> 3] = l;
g[x + 16 >> 2] = e;
g[x + 8 >> 2] = f;
a[x + 20 >> 0] = j != 0 & 1;
g[x + 12 >> 2] = k;
c[x + 4 >> 2] = w;
b[x + 22 >> 1] = ~~m;
b[x + 26 >> 1] = ~~n;
b[x + 24 >> 1] = ~~o;
g[y >> 2] = p;
g[y + 4 >> 2] = q;
g[y + 8 >> 2] = r;
g[y + 12 >> 2] =
s;
g[y + 16 >> 2] = t;
g[y + 20 >> 2] = u;
c[z >> 2] = 592;
c[z + 4 >> 2] = 2;
g[z + 8 >> 2] = .009999999776482582;
c[z + 148 >> 2] = 0;
g[z + 12 >> 2] = 0;
g[z + 16 >> 2] = 0;
oe(z, y, 3);
c[x >> 2] = z;
z = Mj(d, x) | 0;
i = v;
return z | 0
}
function Ib(a) {
a = a | 0;
return
}
function Jb(d, e, f, j, k, l, m, n, o, p, q, r, s, t, u, v, w) {
d = d | 0;
e = +e;
f = +f;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
t = +t;
u = +u;
v = +v;
w = +w;
var x = 0,
y = 0,
z = 0,
A = 0,
B = 0;
x = i;
i = i + 224 | 0;
y = x;
z = x + 192 | 0;
A = x + 160 | 0;
B = x + 8 | 0;
h[y >> 3] = l;
g[z + 16 >> 2] = e;
g[z + 8 >> 2] = f;
a[z + 20 >> 0] = j != 0 & 1;
g[z + 12 >> 2] = k;
c[z + 4 >> 2] = y;
b[z + 22 >> 1] = ~~m;
b[z + 26 >>
1] = ~~n;
b[z + 24 >> 1] = ~~o;
g[A >> 2] = p;
g[A + 4 >> 2] = q;
g[A + 8 >> 2] = r;
g[A + 12 >> 2] = s;
g[A + 16 >> 2] = t;
g[A + 20 >> 2] = u;
g[A + 24 >> 2] = v;
g[A + 28 >> 2] = w;
c[B >> 2] = 592;
c[B + 4 >> 2] = 2;
g[B + 8 >> 2] = .009999999776482582;
c[B + 148 >> 2] = 0;
g[B + 12 >> 2] = 0;
g[B + 16 >> 2] = 0;
oe(B, A, 4);
c[z >> 2] = B;
B = Mj(d, z) | 0;
i = x;
return B | 0
}
function Kb(d, e, f, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) {
d = d | 0;
e = +e;
f = +f;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
t = +t;
u = +u;
v = +v;
w = +w;
x = +x;
y = +y;
var z = 0,
A = 0,
B = 0,
C = 0,
D = 0;
z = i;
i = i + 240 | 0;
A = z;
B = z + 200 | 0;
C = z + 160 | 0;
D = z + 8 | 0;
h[A >> 3] = l;
g[B + 16 >> 2] = e;
g[B + 8 >> 2] = f;
a[B + 20 >> 0] = j != 0 & 1;
g[B + 12 >> 2] = k;
c[B + 4 >> 2] = A;
b[B + 22 >> 1] = ~~m;
b[B + 26 >> 1] = ~~n;
b[B + 24 >> 1] = ~~o;
g[C >> 2] = p;
g[C + 4 >> 2] = q;
g[C + 8 >> 2] = r;
g[C + 12 >> 2] = s;
g[C + 16 >> 2] = t;
g[C + 20 >> 2] = u;
g[C + 24 >> 2] = v;
g[C + 28 >> 2] = w;
g[C + 32 >> 2] = x;
g[C + 36 >> 2] = y;
c[D >> 2] = 592;
c[D + 4 >> 2] = 2;
g[D + 8 >> 2] = .009999999776482582;
c[D + 148 >> 2] = 0;
g[D + 12 >> 2] = 0;
g[D + 16 >> 2] = 0;
oe(D, C, 5);
c[B >> 2] = D;
D = Mj(d, B) | 0;
i = z;
return D | 0
}
function Lb(d, e, f, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A) {
d = d | 0;
e = +e;
f = +f;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
t = +t;
u = +u;
v = +v;
w = +w;
x = +x;
y = +y;
z = +z;
A = +A;
var B = 0,
C = 0,
D = 0,
E = 0,
F = 0;
B = i;
i = i + 240 | 0;
C = B;
D = B + 208 | 0;
E = B + 160 | 0;
F = B + 8 | 0;
h[C >> 3] = l;
g[D + 16 >> 2] = e;
g[D + 8 >> 2] = f;
a[D + 20 >> 0] = j != 0 & 1;
g[D + 12 >> 2] = k;
c[D + 4 >> 2] = C;
b[D + 22 >> 1] = ~~m;
b[D + 26 >> 1] = ~~n;
b[D + 24 >> 1] = ~~o;
g[E >> 2] = p;
g[E + 4 >> 2] = q;
g[E + 8 >> 2] = r;
g[E + 12 >> 2] = s;
g[E + 16 >> 2] = t;
g[E + 20 >> 2] = u;
g[E + 24 >> 2] = v;
g[E + 28 >> 2] = w;
g[E + 32 >> 2] = x;
g[E + 36 >> 2] = y;
g[E + 40 >> 2] = z;
g[E + 44 >> 2] = A;
c[F >> 2] = 592;
c[F + 4 >> 2] = 2;
g[F + 8 >> 2] = .009999999776482582;
c[F + 148 >> 2] = 0;
g[F + 12 >> 2] = 0;
g[F + 16 >> 2] = 0;
oe(F, E, 6);
c[D >> 2] = F;
F = Mj(d, D) | 0;
i = B;
return F |
0
}
function Mb(d, e, f, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B, C) {
d = d | 0;
e = +e;
f = +f;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
t = +t;
u = +u;
v = +v;
w = +w;
x = +x;
y = +y;
z = +z;
A = +A;
B = +B;
C = +C;
var D = 0,
E = 0,
F = 0,
G = 0,
H = 0;
D = i;
i = i + 256 | 0;
E = D;
F = D + 216 | 0;
G = D + 160 | 0;
H = D + 8 | 0;
h[E >> 3] = l;
g[F + 16 >> 2] = e;
g[F + 8 >> 2] = f;
a[F + 20 >> 0] = j != 0 & 1;
g[F + 12 >> 2] = k;
c[F + 4 >> 2] = E;
b[F + 22 >> 1] = ~~m;
b[F + 26 >> 1] = ~~n;
b[F + 24 >> 1] = ~~o;
g[G >> 2] = p;
g[G + 4 >> 2] = q;
g[G + 8 >> 2] = r;
g[G + 12 >> 2] = s;
g[G + 16 >> 2] = t;
g[G + 20 >> 2] = u;
g[G + 24 >> 2] = v;
g[G + 28 >> 2] = w;
g[G + 32 >> 2] = x;
g[G + 36 >> 2] = y;
g[G + 40 >>
2] = z;
g[G + 44 >> 2] = A;
g[G + 48 >> 2] = B;
g[G + 52 >> 2] = C;
c[H >> 2] = 592;
c[H + 4 >> 2] = 2;
g[H + 8 >> 2] = .009999999776482582;
c[H + 148 >> 2] = 0;
g[H + 12 >> 2] = 0;
g[H + 16 >> 2] = 0;
oe(H, G, 7);
c[F >> 2] = H;
H = Mj(d, F) | 0;
i = D;
return H | 0
}
function Nb(d, e, f, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B, C, D, E) {
d = d | 0;
e = +e;
f = +f;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
t = +t;
u = +u;
v = +v;
w = +w;
x = +x;
y = +y;
z = +z;
A = +A;
B = +B;
C = +C;
D = +D;
E = +E;
var F = 0,
G = 0,
H = 0,
I = 0,
J = 0;
F = i;
i = i + 256 | 0;
G = F;
H = F + 224 | 0;
I = F + 160 | 0;
J = F + 8 | 0;
h[G >> 3] = l;
g[H + 16 >> 2] = e;
g[H + 8 >> 2] = f;
a[H + 20 >> 0] = j != 0 & 1;
g[H +
12 >> 2] = k;
c[H + 4 >> 2] = G;
b[H + 22 >> 1] = ~~m;
b[H + 26 >> 1] = ~~n;
b[H + 24 >> 1] = ~~o;
g[I >> 2] = p;
g[I + 4 >> 2] = q;
g[I + 8 >> 2] = r;
g[I + 12 >> 2] = s;
g[I + 16 >> 2] = t;
g[I + 20 >> 2] = u;
g[I + 24 >> 2] = v;
g[I + 28 >> 2] = w;
g[I + 32 >> 2] = x;
g[I + 36 >> 2] = y;
g[I + 40 >> 2] = z;
g[I + 44 >> 2] = A;
g[I + 48 >> 2] = B;
g[I + 52 >> 2] = C;
g[I + 56 >> 2] = D;
g[I + 60 >> 2] = E;
c[J >> 2] = 592;
c[J + 4 >> 2] = 2;
g[J + 8 >> 2] = .009999999776482582;
c[J + 148 >> 2] = 0;
g[J + 12 >> 2] = 0;
g[J + 16 >> 2] = 0;
oe(J, I, 8);
c[H >> 2] = J;
J = Mj(d, H) | 0;
i = F;
return J | 0
}
function Ob(b, d, e, f, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B, C, D, E, F, G) {
b = b | 0;
d = +d;
e = +e;
f = +f;
j =
+j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
t = +t;
u = +u;
v = +v;
w = +w;
x = +x;
y = +y;
z = +z;
A = +A;
B = +B;
C = +C;
D = +D;
E = +E;
F = +F;
G = +G;
var H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0;
H = i;
i = i + 272 | 0;
I = H;
J = H + 192 | 0;
K = H + 160 | 0;
L = H + 8 | 0;
h[I >> 3] = y;
M = J + 8 | 0;
N = J + 20 | 0;
O = J + 4 | 0;
P = J + 16 | 0;
Q = J + 28 | 0;
R = J + 32 | 0;
S = J + 33 | 0;
T = J + 34 | 0;
U = J + 35 | 0;
V = J + 36 | 0;
W = J + 40 | 0;
c[W + 0 >> 2] = 0;
c[W + 4 >> 2] = 0;
c[W + 8 >> 2] = 0;
c[W + 12 >> 2] = 0;
c[W + 16 >> 2] = 0;
c[W + 20 >> 2] = 0;
c[W + 24 >> 2] = 0;
g[P >> 2] = d;
g[Q >> 2] = e;
a[R >> 0] = ~~f;
a[S >> 0] = ~~j;
a[T >> 0] = ~~k;
a[U >> 0] = ~~l;
c[J >> 2] =
~~m >>> 0;
c[J + 72 >> 2] = 0;
c[O >> 2] = ~~o >>> 0;
g[J + 64 >> 2] = p;
p = +q;
q = +r;
O = N;
g[O >> 2] = p;
g[O + 4 >> 2] = q;
q = +s;
s = +t;
O = M;
g[O >> 2] = q;
g[O + 4 >> 2] = s;
c[J + 60 >> 2] = 0;
c[J + 56 >> 2] = ~~v;
c[J + 48 >> 2] = 0;
c[J + 44 >> 2] = 0;
g[V >> 2] = w;
g[J + 52 >> 2] = x;
c[J + 68 >> 2] = I;
g[K >> 2] = z;
g[K + 4 >> 2] = A;
g[K + 8 >> 2] = B;
g[K + 12 >> 2] = C;
g[K + 16 >> 2] = D;
g[K + 20 >> 2] = E;
g[K + 24 >> 2] = F;
g[K + 28 >> 2] = G;
c[L >> 2] = 592;
c[L + 4 >> 2] = 2;
g[L + 8 >> 2] = .009999999776482582;
c[L + 148 >> 2] = 0;
g[L + 12 >> 2] = 0;
g[L + 16 >> 2] = 0;
oe(L, K, 4);
c[W >> 2] = L;
L = Fk(b, J) | 0;
i = H;
return L | 0
}
function Pb(a, b, d, e, f, h, j, k, l, m, n, o, p) {
a = a | 0;
b = +b;
d = +d;
e = +e;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
var q = 0,
r = 0,
s = 0,
t = 0;
q = i;
i = i + 208 | 0;
r = q + 168 | 0;
s = q + 16 | 0;
t = q;
g[r >> 2] = b;
g[r + 4 >> 2] = d;
g[r + 8 >> 2] = e;
g[r + 12 >> 2] = f;
g[r + 16 >> 2] = h;
g[r + 20 >> 2] = j;
g[r + 24 >> 2] = k;
g[r + 28 >> 2] = l;
c[s >> 2] = 592;
c[s + 4 >> 2] = 2;
g[s + 8 >> 2] = .009999999776482582;
c[s + 148 >> 2] = 0;
g[s + 12 >> 2] = 0;
g[s + 16 >> 2] = 0;
oe(s, r, 4);
g[t >> 2] = m;
g[t + 4 >> 2] = n;
g[t + 8 >> 2] = o;
g[t + 12 >> 2] = p;
p = +(Ck(a, s, t, 0) | 0);
i = q;
return +p
}
function Qb(a, d, e) {
a = a | 0;
d = +d;
e = +e;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0;
f = i;
h = d;
if ((c[a >> 2] | 0) != 2) {
i = f;
return
}
j =
a + 4 | 0;
k = b[j >> 1] | 0;
if ((e != 0 ? (k & 2) == 0 : 0) ? (l = k & 65535, (l & 2 | 0) == 0) : 0) {
m = (l | 2) & 65535;
b[j >> 1] = m;
g[a + 160 >> 2] = 0;
n = m
} else
n = k;
if ((n & 2) == 0) {
i = f;
return
}
n = a + 88 | 0;
g[n >> 2] = +g[n >> 2] + h * +g[a + 144 >> 2];
i = f;
return
}
function Rb(a, d, e, f, h, j) {
a = a | 0;
d = +d;
e = +e;
f = +f;
h = +h;
j = +j;
var k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0;
k = i;
l = d;
d = e;
e = f;
f = h;
if ((c[a >> 2] | 0) != 2) {
i = k;
return
}
m = a + 4 | 0;
n = b[m >> 1] | 0;
if ((j != 0 ? (n & 2) == 0 : 0) ? (o = n & 65535, (o & 2 | 0) == 0) : 0) {
p = (o | 2) & 65535;
b[m >> 1] = p;
g[a + 160 >> 2] = 0;
q = p
} else
q = n;
if ((q & 2) == 0) {
i = k;
return
}
q = a + 92 | 0;
g[q >> 2] = l + +g[q >> 2];
q = a + 96 | 0;
g[q >> 2] = d + +g[q >> 2];
q = a + 100 | 0;
g[q >> 2] = +g[q >> 2] + (d * (e - +g[a + 60 >> 2]) - l * (f - +g[a + 64 >> 2]));
i = k;
return
}
function Sb(a, d, e, f) {
a = a | 0;
d = +d;
e = +e;
f = +f;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0;
h = i;
j = d;
d = e;
if ((c[a >> 2] | 0) != 2) {
i = h;
return
}
k = a + 4 | 0;
l = b[k >> 1] | 0;
if ((f != 0 ? (l & 2) == 0 : 0) ? (m = l & 65535, (m & 2 | 0) == 0) : 0) {
n = (m | 2) & 65535;
b[k >> 1] = n;
g[a + 160 >> 2] = 0;
o = n
} else
o = l;
if ((o & 2) == 0) {
i = h;
return
}
o = a + 92 | 0;
g[o >> 2] = j + +g[o >> 2];
o = a + 96 | 0;
g[o >> 2] = d + +g[o >> 2];
i = h;
return
}
function Tb(a, d, e) {
a = a | 0;
d = +d;
e = +e;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0;
f =
i;
h = d;
if ((c[a >> 2] | 0) != 2) {
i = f;
return
}
j = a + 4 | 0;
k = b[j >> 1] | 0;
if ((e != 0 ? (k & 2) == 0 : 0) ? (l = k & 65535, (l & 2 | 0) == 0) : 0) {
m = (l | 2) & 65535;
b[j >> 1] = m;
g[a + 160 >> 2] = 0;
n = m
} else
n = k;
if ((n & 2) == 0) {
i = f;
return
}
n = a + 100 | 0;
g[n >> 2] = h + +g[n >> 2];
i = f;
return
}
function Ub(a, b) {
a = a | 0;
b = b | 0;
var c = 0;
c = i;
Nj(a, b);
i = c;
return
}
function Vb(a) {
a = a | 0;
return ++g[a + 72 >> 2]
}
function Wb(a) {
a = a | 0;
return ++g[a + 88 >> 2]
}
function Xb(a) {
a = a | 0;
var b = 0,
c = 0;
b = +g[a + 44 >> 2];
c = +g[a + 48 >> 2];
return +(+g[a + 140 >> 2] + +g[a + 132 >> 2] * (b * b + c * c))
}
function Yb(a, b) {
a = a | 0;
b = b | 0;
var c =
0;
c = +g[a + 84 >> 2];
g[b >> 2] = +g[a + 80 >> 2];
g[b + 4 >> 2] = c;
return
}
function Zb(a, b, c, d) {
a = a | 0;
b = +b;
c = +c;
d = d | 0;
var e = 0,
f = 0;
e = b - +g[a + 12 >> 2];
b = c - +g[a + 16 >> 2];
c = +g[a + 24 >> 2];
f = +g[a + 20 >> 2];
g[d >> 2] = e * c + b * f;
g[d + 4 >> 2] = c * b - e * f;
return
}
function _b(a, b, c, d) {
a = a | 0;
b = +b;
c = +c;
d = d | 0;
var e = 0,
f = 0;
e = b - +g[a + 12 >> 2];
b = c - +g[a + 16 >> 2];
c = +g[a + 24 >> 2];
f = +g[a + 20 >> 2];
g[d >> 2] = e * c + b * f;
g[d + 4 >> 2] = c * b - e * f;
return
}
function $b(a) {
a = a | 0;
return ++g[a + 132 >> 2]
}
function ac(a, b) {
a = a | 0;
b = b | 0;
var c = 0;
c = +g[a + 16 >> 2];
g[b >> 2] = +g[a + 12 >> 2];
g[b + 4 >> 2] = c;
return
}
function bc(a,
b) {
a = a | 0;
b = b | 0;
g[b >> 2] = +g[a + 12 >> 2];
g[b + 4 >> 2] = +g[a + 16 >> 2];
g[b + 8 >> 2] = +g[a + 20 >> 2];
g[b + 12 >> 2] = +g[a + 24 >> 2];
return
}
function cc(a) {
a = a | 0;
return 1+((c[a >> 2] | 0) >>> 0)
}
function dc(a, b) {
a = a | 0;
b = b | 0;
var c = 0;
c = +g[a + 64 >> 2];
g[b >> 2] = +g[a + 60 >> 2];
g[b + 4 >> 2] = c;
return
}
function ec(a, b, c, d) {
a = a | 0;
b = +b;
c = +c;
d = d | 0;
var e = 0,
f = 0,
h = 0;
e = b;
b = c;
c = +g[a + 24 >> 2];
f = +g[a + 20 >> 2];
h = b * c + e * f + +g[a + 16 >> 2];
g[d >> 2] = +g[a + 12 >> 2] + (e * c - b * f);
g[d + 4 >> 2] = h;
return
}
function fc(a, b, c, d) {
a = a | 0;
b = +b;
c = +c;
d = d | 0;
var e = 0,
f = 0,
h = 0;
e = b;
b = c;
c = +g[a + 24 >> 2];
f = +g[a +
20 >> 2];
h = b * c + e * f + +g[a + 16 >> 2];
g[d >> 2] = +g[a + 12 >> 2] + (e * c - b * f);
g[d + 4 >> 2] = h;
return
}
function gc(a, d) {
a = a | 0;
d = +d;
var f = 0,
h = 0,
j = 0,
k = 0;
f = i;
h = a + 4 | 0;
j = e[h >> 1] | 0;
if (!(d != 0)) {
b[h >> 1] = j & 65533;
g[a + 160 >> 2] = 0;
k = a + 80 | 0;
c[k + 0 >> 2] = 0;
c[k + 4 >> 2] = 0;
c[k + 8 >> 2] = 0;
c[k + 12 >> 2] = 0;
c[k + 16 >> 2] = 0;
c[k + 20 >> 2] = 0;
i = f;
return
}
if ((j & 2 | 0) != 0) {
i = f;
return
}
b[h >> 1] = j | 2;
g[a + 160 >> 2] = 0;
i = f;
return
}
function hc(a, d) {
a = a | 0;
d = +d;
var f = 0,
h = 0,
j = 0,
k = 0;
f = i;
h = d;
if ((c[a >> 2] | 0) == 0) {
i = f;
return
}
if (h * h > 0 ? (j = a + 4 | 0, k = e[j >> 1] | 0, (k & 2 | 0) == 0) : 0) {
b[j >> 1] = k | 2;
g[a + 160 >>
2] = 0
}
g[a + 88 >> 2] = h;
i = f;
return
}
function ic(a, d, f) {
a = a | 0;
d = +d;
f = +f;
var h = 0,
j = 0,
k = 0,
l = 0;
h = i;
j = d;
d = f;
if ((c[a >> 2] | 0) == 0) {
i = h;
return
}
if (j * j + d * d > 0 ? (k = a + 4 | 0, l = e[k >> 1] | 0, (l & 2 | 0) == 0) : 0) {
b[k >> 1] = l | 2;
g[a + 160 >> 2] = 0
}
f = +j;
j = +d;
l = a + 80 | 0;
g[l >> 2] = f;
g[l + 4 >> 2] = j;
i = h;
return
}
function jc(a, b, c, d, e) {
a = a | 0;
b = +b;
c = +c;
d = +d;
e = +e;
var f = 0,
h = 0;
f = i;
i = i + 16 | 0;
h = f;
g[h >> 2] = b;
g[h + 4 >> 2] = c;
g[h + 8 >> 2] = d;
g[h + 12 >> 2] = e;
Oj(a, h);
i = f;
return
}
function kc(a, b, c, d) {
a = a | 0;
b = +b;
c = +c;
d = +d;
var e = 0,
f = 0;
e = i;
i = i + 16 | 0;
f = e;
g[f >> 2] = b;
g[f + 4 >> 2] = c;
Qj(a, f, d);
i =
e;
return
}
function lc(a, b) {
a = a | 0;
b = +b;
var c = 0;
c = i;
Jj(a, ~~b >>> 0);
i = c;
return
}
function mc(a, b, d) {
a = a | 0;
b = +b;
d = +d;
var e = 0,
f = 0,
h = 0;
e = i;
i = i + 16 | 0;
f = e;
g[f >> 2] = b;
g[f + 4 >> 2] = d;
h = c[a + 12 >> 2] | 0;
d = +((hb[c[(c[h >> 2] | 0) + 16 >> 2] & 15](h, (c[a + 8 >> 2] | 0) + 12 | 0, f) | 0) & 1);
i = e;
return +d
}
function nc(a) {
a = a | 0;
return
}
function oc(a) {
a = a | 0;
return
}
function pc(a) {
a = a | 0;
return
}
function qc(a, b) {
a = +a;
b = +b;
var c = 0,
d = 0,
e = 0;
c = i;
i = i + 16 | 0;
d = c;
e = qn(103048) | 0;
g[d >> 2] = a;
g[d + 4 >> 2] = b;
rj(e, d);
i = c;
return e | 0
}
function rc(b, d, e, f, h, j, k, l, m, n, o, p, q, r, s,
t, u) {
b = b | 0;
d = +d;
e = +e;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
t = +t;
u = u | 0;
var v = 0,
w = 0,
x = 0,
y = 0,
z = 0;
v = i;
i = i + 64 | 0;
w = v;
x = w + 44 | 0;
y = w + 4 | 0;
z = w + 36 | 0;
c[y + 0 >> 2] = 0;
c[y + 4 >> 2] = 0;
c[y + 8 >> 2] = 0;
c[y + 12 >> 2] = 0;
c[y + 16 >> 2] = 0;
c[y + 20 >> 2] = 0;
a[w + 40 >> 0] = d != 0 & 1;
a[z >> 0] = e != 0 & 1;
g[w + 12 >> 2] = f;
g[w + 24 >> 2] = h;
g[w + 32 >> 2] = j;
a[w + 37 >> 0] = k != 0 & 1;
a[w + 39 >> 0] = l != 0 & 1;
a[w + 38 >> 0] = m != 0 & 1;
g[w + 48 >> 2] = n;
g[w + 28 >> 2] = o;
g[w + 16 >> 2] = p;
g[w + 20 >> 2] = q;
g[y >> 2] = r;
g[w + 8 >> 2] = s;
c[w >> 2] = ~~t >>> 0;
c[x >> 2] = u;
u = vj(b, w) | 0;
i = v;
return u | 0
}
function sc(b,
d, e, f, h, j, k, l, m, n, o, p, q, r, s, t, u, v) {
b = b | 0;
d = +d;
e = +e;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
t = +t;
u = +u;
v = +v;
var w = 0,
x = 0,
y = 0;
w = i;
i = i + 96 | 0;
x = w;
a[x >> 0] = 0;
g[x + 4 >> 2] = 1;
g[x + 8 >> 2] = 1;
c[x + 16 >> 2] = 0;
g[x + 72 >> 2] = d;
g[x + 24 >> 2] = e;
a[x + 76 >> 0] = f != 0 & 1;
g[x + 56 >> 2] = h;
g[x + 28 >> 2] = j;
g[x + 80 >> 2] = k;
g[x + 52 >> 2] = l;
g[x + 20 >> 2] = m;
g[x + 12 >> 2] = n;
g[x + 48 >> 2] = o;
g[x + 32 >> 2] = p;
c[x + 68 >> 2] = ~~q;
g[x + 64 >> 2] = r;
g[x + 60 >> 2] = s;
g[x + 44 >> 2] = t;
g[x + 40 >> 2] = u;
g[x + 36 >> 2] = v;
y = zj(b, x) | 0;
i = w;
return y | 0
}
function tc(a) {
a = a | 0;
var b = 0;
b = i;
if ((a | 0) !=
0) {
sj(a);
sn(a)
}
i = b;
return
}
function uc(a, b) {
a = a | 0;
b = b | 0;
var c = 0;
c = i;
wj(a, b);
i = c;
return
}
function vc(a, b) {
a = a | 0;
b = b | 0;
var c = 0;
c = i;
xj(a, b);
i = c;
return
}
function wc(a, b) {
a = a | 0;
b = b | 0;
var c = 0;
c = i;
tj(a, b);
i = c;
return
}
function xc(a, b, c, d, e) {
a = a | 0;
b = +b;
c = +c;
d = +d;
e = +e;
var f = 0,
h = 0,
j = 0,
k = 0;
f = i;
i = i + 16 | 0;
h = f;
j = +b;
b = +c;
k = h;
g[k >> 2] = j;
g[k + 4 >> 2] = b;
b = +d;
d = +e;
k = h + 8 | 0;
g[k >> 2] = b;
g[k + 4 >> 2] = d;
Dj(a, 16, h);
i = f;
return
}
function yc(a, b, c, d, e) {
a = a | 0;
b = +b;
c = +c;
d = +d;
e = +e;
var f = 0,
h = 0,
j = 0;
f = i;
i = i + 16 | 0;
h = f + 8 | 0;
j = f;
g[h >> 2] = b;
g[h + 4 >> 2] = c;
g[j >> 2] = d;
g[j + 4 >> 2] = e;
Ej(a, 24, h, j);
i = f;
return
}
function zc(a) {
a = a | 0;
var b = 0;
b = i;
uj(a, 8);
i = b;
return
}
function Ac(a, b, c) {
a = a | 0;
b = +b;
c = +c;
var d = 0,
e = 0,
f = 0;
d = i;
e = +b;
b = +c;
f = a + 102980 | 0;
g[f >> 2] = e;
g[f + 4 >> 2] = b;
i = d;
return
}
function Bc(a, b, c, d) {
a = a | 0;
b = +b;
c = +c;
d = +d;
var e = 0;
e = i;
Cj(a, b, ~~c, ~~d, 3);
i = e;
return
}
function Cc(a) {
a = a | 0;
return a + 64 | 0
}
function Dc(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0;
b = i;
d = c[a + 48 >> 2] | 0;
e = c[a + 52 >> 2] | 0;
jf(32, a + 64 | 0, (c[d + 8 >> 2] | 0) + 12 | 0, +g[(c[d + 12 >> 2] | 0) + 8 >> 2], (c[e + 8 >> 2] | 0) + 12 | 0, +g[(c[e + 12 >> 2] | 0) + 8 >> 2]);
i = b;
return 32
}
function Ec(b, d, e, f, h, j, k, l, m, n, o) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
var p = 0,
q = 0,
r = 0;
p = i;
i = i + 48 | 0;
q = p;
c[q + 0 >> 2] = 0;
c[q + 4 >> 2] = 0;
c[q + 8 >> 2] = 0;
c[q + 12 >> 2] = 0;
c[q >> 2] = 3;
r = q + 20 | 0;
c[r >> 2] = 0;
c[r + 4 >> 2] = 0;
c[q + 8 >> 2] = d;
c[q + 12 >> 2] = e;
a[q + 16 >> 0] = f != 0 & 1;
g[q + 44 >> 2] = h;
g[q + 40 >> 2] = j;
g[q + 36 >> 2] = k;
k = +l;
l = +m;
e = q + 20 | 0;
g[e >> 2] = k;
g[e + 4 >> 2] = l;
l = +n;
n = +o;
e = q + 28 | 0;
g[e >> 2] = l;
g[e + 4 >> 2] = n;
e = yj(b, q) | 0;
i = p;
return e | 0
}
function Fc(b, d, e, f, h, j, k, l, m, n) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
var o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0;
o = i;
i = i + 64 | 0;
p = o + 16 | 0;
q = o + 8 | 0;
r = o;
c[p + 0 >> 2] = 0;
c[p + 4 >> 2] = 0;
c[p + 8 >> 2] = 0;
c[p + 12 >> 2] = 0;
c[p >> 2] = 3;
s = p + 20 | 0;
t = p + 36 | 0;
c[s + 0 >> 2] = 0;
c[s + 4 >> 2] = 0;
c[s + 8 >> 2] = 0;
c[s + 12 >> 2] = 0;
g[t >> 2] = 1;
a[p + 16 >> 0] = l != 0 & 1;
g[p + 44 >> 2] = m;
g[p + 40 >> 2] = n;
g[q >> 2] = f;
g[q + 4 >> 2] = h;
g[r >> 2] = j;
g[r + 4 >> 2] = k;
Xf(p, d, e, q, r);
r = yj(b, p) | 0;
i = o;
return r | 0
}
function Gc(b, d, e, f, h, j, k, l, m, n) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
var o = 0,
p = 0,
q = 0;
o = i;
i = i + 48 | 0;
p = o;
c[p + 0 >> 2] = 0;
c[p + 4 >> 2] = 0;
c[p + 8 >> 2] = 0;
c[p + 12 >> 2] = 0;
c[p >> 2] =
9;
q = p + 20 | 0;
c[q + 0 >> 2] = 0;
c[q + 4 >> 2] = 0;
c[q + 8 >> 2] = 0;
c[q + 12 >> 2] = 0;
c[q + 16 >> 2] = 0;
c[p + 8 >> 2] = d;
c[p + 12 >> 2] = e;
a[p + 16 >> 0] = f != 0 & 1;
f = +h;
h = +j;
e = p + 20 | 0;
g[e >> 2] = f;
g[e + 4 >> 2] = h;
h = +k;
k = +l;
e = p + 28 | 0;
g[e >> 2] = h;
g[e + 4 >> 2] = k;
g[p + 36 >> 2] = m;
g[p + 40 >> 2] = n;
e = yj(b, p) | 0;
i = o;
return e | 0
}
function Hc(b, d, e, f, h, j, k, l) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
var m = 0,
n = 0,
o = 0,
p = 0;
m = i;
i = i + 64 | 0;
n = m + 8 | 0;
o = m;
c[n + 0 >> 2] = 0;
c[n + 4 >> 2] = 0;
c[n + 8 >> 2] = 0;
c[n + 12 >> 2] = 0;
c[n >> 2] = 9;
p = n + 20 | 0;
c[p + 0 >> 2] = 0;
c[p + 4 >> 2] = 0;
c[p + 8 >> 2] = 0;
c[p + 12 >> 2] = 0;
c[p + 16 >> 2] = 0;
a[n +
16 >> 0] = j != 0 & 1;
g[n + 36 >> 2] = k;
g[n + 40 >> 2] = l;
g[o >> 2] = f;
g[o + 4 >> 2] = h;
hg(n, d, e, o);
o = yj(b, n) | 0;
i = m;
return o | 0
}
function Ic(a) {
a = a | 0;
var b = 0,
c = 0;
b = i;
c = +Ng(a);
i = b;
return +c
}
function Jc(b, d, e, f, h, j, k) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = h | 0;
j = j | 0;
k = +k;
var l = 0,
m = 0;
l = i;
i = i + 32 | 0;
m = l;
c[m + 0 >> 2] = 0;
c[m + 4 >> 2] = 0;
c[m + 8 >> 2] = 0;
c[m + 12 >> 2] = 0;
c[m >> 2] = 6;
c[m + 8 >> 2] = d;
c[m + 12 >> 2] = e;
a[m + 16 >> 0] = f != 0 & 1;
c[m + 20 >> 2] = h;
c[m + 24 >> 2] = j;
g[m + 28 >> 2] = k;
j = yj(b, m) | 0;
i = l;
return j | 0
}
function Kc(a) {
a = a | 0;
return c[a + 48 >> 2] | 0
}
function Lc(a) {
a = a | 0;
return c[a + 52 >>
2] | 0
}
function Mc(a, b) {
a = a | 0;
b = +b;
var c = 0;
c = i;
Sf(a, b);
i = c;
return
}
function Nc(a, b, c) {
a = a | 0;
b = +b;
c = +c;
var d = 0,
e = 0;
d = i;
i = i + 16 | 0;
e = d;
g[e >> 2] = b;
g[e + 4 >> 2] = c;
Rf(a, e);
i = d;
return
}
function Oc(b, d, e, f, h, j, k, l, m, n) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
var o = 0,
p = 0;
o = i;
i = i + 48 | 0;
p = o;
c[p + 0 >> 2] = 0;
c[p + 4 >> 2] = 0;
c[p + 8 >> 2] = 0;
c[p + 12 >> 2] = 0;
c[p >> 2] = 11;
c[p + 8 >> 2] = d;
c[p + 12 >> 2] = e;
a[p + 16 >> 0] = f != 0 & 1;
g[p + 28 >> 2] = h;
g[p + 40 >> 2] = j;
j = +k;
k = +l;
e = p + 20 | 0;
g[e >> 2] = j;
g[e + 4 >> 2] = k;
g[p + 32 >> 2] = m;
g[p + 36 >> 2] = n;
e = yj(b, p) | 0;
i = o;
return e |
0
}
function Pc(b, d, e, f, h, j, k) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
var l = 0,
m = 0;
l = i;
i = i + 48 | 0;
m = l;
c[m + 0 >> 2] = 0;
c[m + 4 >> 2] = 0;
c[m + 8 >> 2] = 0;
c[m + 12 >> 2] = 0;
c[m >> 2] = 11;
g[m + 20 >> 2] = 0;
g[m + 24 >> 2] = 0;
g[m + 28 >> 2] = 0;
a[m + 16 >> 0] = f != 0 & 1;
g[m + 40 >> 2] = h;
g[m + 32 >> 2] = j;
g[m + 36 >> 2] = k;
If(m, d, e);
e = yj(b, m) | 0;
i = l;
return e | 0
}
function Qc(a, b, c) {
a = a | 0;
b = +b;
c = +c;
var d = 0,
e = 0;
d = i;
i = i + 16 | 0;
e = d;
g[e >> 2] = b;
g[e + 4 >> 2] = c;
wf(a, e);
i = d;
return
}
function Rc(b, d, e, f, h, j, k, l, m) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
var n = 0,
o = 0;
n = i;
i = i + 48 | 0;
o = n;
c[o + 0 >> 2] = 0;
c[o + 4 >> 2] = 0;
c[o + 8 >> 2] = 0;
c[o + 12 >> 2] = 0;
c[o >> 2] = 5;
c[o + 8 >> 2] = d;
c[o + 12 >> 2] = e;
a[o + 16 >> 0] = f != 0 & 1;
g[o + 36 >> 2] = h;
g[o + 32 >> 2] = j;
g[o + 28 >> 2] = k;
k = +l;
l = +m;
e = o + 20 | 0;
g[e >> 2] = k;
g[e + 4 >> 2] = l;
e = yj(b, o) | 0;
i = n;
return e | 0
}
function Sc(a, b) {
a = a | 0;
b = +b;
var c = 0;
c = i;
ah(a, b != 0);
i = c;
return
}
function Tc(a, b) {
a = a | 0;
b = +b;
var c = 0;
c = i;
ch(a, b != 0);
i = c;
return
}
function Uc(a) {
a = a | 0;
var b = 0,
c = 0;
b = i;
c = +_g(a);
i = b;
return +c
}
function Vc(a) {
a = a | 0;
return ++g[a + 132 >> 2]
}
function Wc(a, b) {
a = a | 0;
b = +b;
var c = 0,
d = 0;
c = i;
d = +eh(a, b);
i = c;
return +d
}
function Xc(a) {
a = a | 0;
var b = 0,
c = 0;
b = i;
c = +(($g(a) | 0) & 1);
i = b;
return +c
}
function Yc(a) {
a = a | 0;
var b = 0,
c = 0;
b = i;
c = +((bh(a) | 0) & 1);
i = b;
return +c
}
function Zc(a, b) {
a = a | 0;
b = +b;
var c = 0;
c = i;
dh(a, b);
i = c;
return
}
function _c(b, d, e, f, h, j, k, l, m, n, o, p, q, r, s, t, u) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
t = +t;
u = +u;
var v = 0,
w = 0,
x = 0;
v = i;
i = i + 80 | 0;
w = v;
c[w + 0 >> 2] = 0;
c[w + 4 >> 2] = 0;
c[w + 8 >> 2] = 0;
c[w + 12 >> 2] = 0;
c[w >> 2] = 2;
x = w + 20 | 0;
c[x >> 2] = 0;
c[x + 4 >> 2] = 0;
c[w + 8 >> 2] = d;
c[w + 12 >> 2] = e;
a[w + 16 >> 0] = f != 0 & 1;
a[w + 48 >>
0] = h != 0 & 1;
a[w + 60 >> 0] = j != 0 & 1;
j = +k;
k = +l;
e = w + 20 | 0;
g[e >> 2] = j;
g[e + 4 >> 2] = k;
k = +m;
m = +n;
e = w + 28 | 0;
g[e >> 2] = k;
g[e + 4 >> 2] = m;
m = +o;
o = +p;
e = w + 36 | 0;
g[e >> 2] = m;
g[e + 4 >> 2] = o;
g[w + 52 >> 2] = q;
g[w + 64 >> 2] = r;
g[w + 68 >> 2] = s;
g[w + 44 >> 2] = t;
g[w + 56 >> 2] = u;
e = yj(b, w) | 0;
i = v;
return e | 0
}
function $c(b, d, e, f, h, j, k, l, m, n, o, p, q, r) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
var s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0;
s = i;
i = i + 96 | 0;
t = s + 16 | 0;
u = s + 8 | 0;
v = s;
c[t + 0 >> 2] = 0;
c[t + 4 >> 2] = 0;
c[t + 8 >> 2] = 0;
c[t + 12 >> 2] = 0;
c[t >> 2] = 2;
w = t + 20 | 0;
x = t + 36 | 0;
c[w + 0 >>
2] = 0;
c[w + 4 >> 2] = 0;
c[w + 8 >> 2] = 0;
c[w + 12 >> 2] = 0;
g[x >> 2] = 1;
g[t + 40 >> 2] = 0;
g[t + 44 >> 2] = 0;
a[t + 16 >> 0] = l != 0 & 1;
a[t + 48 >> 0] = m != 0 & 1;
a[t + 60 >> 0] = n != 0 & 1;
g[t + 52 >> 2] = o;
g[t + 64 >> 2] = p;
g[t + 68 >> 2] = q;
g[t + 56 >> 2] = r;
g[u >> 2] = f;
g[u + 4 >> 2] = h;
g[v >> 2] = j;
g[v + 4 >> 2] = k;
Rg(t, d, e, u, v);
v = yj(b, t) | 0;
i = s;
return v | 0
}
function ad(b, d, e, f, h, j, k, l, m, n, o, p, q, r, s) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
var t = 0,
u = 0;
t = i;
i = i + 64 | 0;
u = t;
c[u + 0 >> 2] = 0;
c[u + 4 >> 2] = 0;
c[u + 8 >> 2] = 0;
c[u >> 2] = 4;
c[u + 8 >> 2] = d;
c[u + 12 >> 2] = e;
a[u + 16 >> 0] =
f != 0 & 1;
f = +h;
h = +j;
e = u + 20 | 0;
g[e >> 2] = f;
g[e + 4 >> 2] = h;
h = +k;
k = +l;
e = u + 28 | 0;
g[e >> 2] = h;
g[e + 4 >> 2] = k;
g[u + 52 >> 2] = m;
g[u + 56 >> 2] = n;
n = +o;
o = +p;
e = u + 36 | 0;
g[e >> 2] = n;
g[e + 4 >> 2] = o;
o = +q;
q = +r;
e = u + 44 | 0;
g[e >> 2] = o;
g[e + 4 >> 2] = q;
g[u + 60 >> 2] = s;
e = yj(b, u) | 0;
i = t;
return e | 0
}
function bd(b, d, e, f, h, j, k, l, m, n, o, p, q) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
var r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0;
r = i;
i = i + 96 | 0;
s = r + 32 | 0;
t = r + 24 | 0;
u = r + 16 | 0;
v = r + 8 | 0;
w = r;
c[s + 0 >> 2] = 0;
c[s + 4 >> 2] = 0;
c[s + 8 >> 2] = 0;
c[s + 12 >> 2] = 0;
c[s >> 2] = 4;
g[s + 20 >> 2] = -1;
g[s +
24 >> 2] = 1;
g[s + 28 >> 2] = 1;
g[s + 32 >> 2] = 1;
g[s + 36 >> 2] = -1;
g[s + 40 >> 2] = 0;
g[s + 44 >> 2] = 1;
g[s + 48 >> 2] = 0;
g[s + 52 >> 2] = 0;
g[s + 56 >> 2] = 0;
g[s + 60 >> 2] = 1;
a[s + 16 >> 0] = q != 0 & 1;
g[t >> 2] = l;
g[t + 4 >> 2] = m;
g[u >> 2] = n;
g[u + 4 >> 2] = o;
g[v >> 2] = f;
g[v + 4 >> 2] = h;
g[w >> 2] = j;
g[w + 4 >> 2] = k;
ci(s, d, e, t, u, v, w, p);
w = yj(b, s) | 0;
i = r;
return w | 0
}
function cd(a, b) {
a = a | 0;
b = +b;
var c = 0;
c = i;
Nh(a, b != 0);
i = c;
return
}
function dd(a, b) {
a = a | 0;
b = +b;
var c = 0;
c = i;
Kh(a, b != 0);
i = c;
return
}
function ed(a) {
a = a | 0;
var b = 0,
c = 0;
b = i;
c = +Ih(a);
i = b;
return +c
}
function fd(a) {
a = a | 0;
var b = 0,
c = 0;
b = i;
c =
+((Mh(a) | 0) & 1);
i = b;
return +c
}
function gd(a) {
a = a | 0;
var b = 0,
c = 0;
b = i;
c = +((Jh(a) | 0) & 1);
i = b;
return +c
}
function hd(b, d, e, f, h, j, k, l, m, n, o, p, q, r, s) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
var t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0;
t = i;
i = i + 64 | 0;
u = t;
c[u + 0 >> 2] = 0;
c[u + 4 >> 2] = 0;
c[u + 8 >> 2] = 0;
c[u + 12 >> 2] = 0;
c[u >> 2] = 1;
v = u + 20 | 0;
w = u + 44 | 0;
x = u + 48 | 0;
y = u + 60 | 0;
z = u + 56 | 0;
A = u + 52 | 0;
c[v + 0 >> 2] = 0;
c[v + 4 >> 2] = 0;
c[v + 8 >> 2] = 0;
c[v + 12 >> 2] = 0;
c[u + 8 >> 2] = d;
c[u + 12 >> 2] = e;
a[u + 16 >> 0] = f != 0 & 1;
a[u + 40 >> 0] = h != 0 & 1;
a[A >> 0] = j !=
0 & 1;
j = +l;
l = +m;
A = u + 20 | 0;
g[A >> 2] = j;
g[A + 4 >> 2] = l;
l = +n;
n = +o;
A = u + 28 | 0;
g[A >> 2] = l;
g[A + 4 >> 2] = n;
g[w >> 2] = k;
g[y >> 2] = p;
g[z >> 2] = q;
g[u + 36 >> 2] = r;
g[x >> 2] = s;
x = yj(b, u) | 0;
i = t;
return x | 0
}
function id(b, d, e, f, h, j, k, l, m, n, o, p) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
var q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0;
q = i;
i = i + 80 | 0;
r = q + 8 | 0;
s = q;
c[r + 0 >> 2] = 0;
c[r + 4 >> 2] = 0;
c[r + 8 >> 2] = 0;
c[r + 12 >> 2] = 0;
c[r >> 2] = 1;
t = r + 20 | 0;
u = r + 44 | 0;
v = r + 48 | 0;
w = r + 60 | 0;
x = r + 56 | 0;
y = r + 52 | 0;
c[t + 0 >> 2] = 0;
c[t + 4 >> 2] = 0;
c[t + 8 >> 2] = 0;
c[t + 12 >> 2] = 0;
c[t + 16 >>
2] = 0;
a[r + 16 >> 0] = j != 0 & 1;
a[r + 40 >> 0] = k != 0 & 1;
a[y >> 0] = l != 0 & 1;
g[u >> 2] = m;
g[w >> 2] = n;
g[x >> 2] = o;
g[v >> 2] = p;
g[s >> 2] = f;
g[s + 4 >> 2] = h;
zh(r, d, e, s);
s = yj(b, r) | 0;
i = q;
return s | 0
}
function jd(a, b) {
a = a | 0;
b = +b;
var c = 0;
c = i;
Lh(a, b);
i = c;
return
}
function kd(b, d, e, f, h, j, k, l, m) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
var n = 0,
o = 0;
n = i;
i = i + 48 | 0;
o = n;
c[o + 0 >> 2] = 0;
c[o + 4 >> 2] = 0;
c[o + 8 >> 2] = 0;
c[o + 12 >> 2] = 0;
c[o >> 2] = 10;
c[o + 8 >> 2] = d;
c[o + 12 >> 2] = e;
a[o + 16 >> 0] = f != 0 & 1;
f = +h;
h = +j;
e = o + 20 | 0;
g[e >> 2] = f;
g[e + 4 >> 2] = h;
h = +k;
k = +l;
e = o + 28 | 0;
g[e >> 2] = h;
g[e +
4 >> 2] = k;
g[o + 36 >> 2] = m;
e = yj(b, o) | 0;
i = n;
return e | 0
}
function ld(b, d, e, f, h, j, k, l, m, n, o) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
var p = 0,
q = 0,
r = 0;
p = i;
i = i + 48 | 0;
q = p;
c[q + 0 >> 2] = 0;
c[q + 4 >> 2] = 0;
c[q + 8 >> 2] = 0;
c[q + 12 >> 2] = 0;
c[q >> 2] = 8;
r = q + 20 | 0;
c[r + 0 >> 2] = 0;
c[r + 4 >> 2] = 0;
c[r + 8 >> 2] = 0;
c[r + 12 >> 2] = 0;
c[q + 8 >> 2] = d;
c[q + 12 >> 2] = e;
a[q + 16 >> 0] = f != 0 & 1;
g[q + 44 >> 2] = h;
g[q + 40 >> 2] = j;
j = +k;
k = +l;
e = q + 20 | 0;
g[e >> 2] = j;
g[e + 4 >> 2] = k;
k = +m;
m = +n;
e = q + 28 | 0;
g[e >> 2] = k;
g[e + 4 >> 2] = m;
g[q + 36 >> 2] = o;
e = yj(b, q) | 0;
i = p;
return e | 0
}
function md(b, d, e, f,
h, j, k, l) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
var m = 0,
n = 0,
o = 0,
p = 0;
m = i;
i = i + 64 | 0;
n = m + 8 | 0;
o = m;
c[n + 0 >> 2] = 0;
c[n + 4 >> 2] = 0;
c[n + 8 >> 2] = 0;
c[n + 12 >> 2] = 0;
c[n >> 2] = 8;
p = n + 20 | 0;
c[p + 0 >> 2] = 0;
c[p + 4 >> 2] = 0;
c[p + 8 >> 2] = 0;
c[p + 12 >> 2] = 0;
c[p + 16 >> 2] = 0;
a[n + 16 >> 0] = j != 0 & 1;
g[n + 44 >> 2] = k;
g[n + 40 >> 2] = l;
g[o >> 2] = f;
g[o + 4 >> 2] = h;
tg(n, d, e, o);
o = yj(b, n) | 0;
i = m;
return o | 0
}
function nd(a, b) {
a = a | 0;
b = +b;
var c = 0;
c = i;
_h(a, b);
i = c;
return
}
function od(a, b) {
a = a | 0;
b = +b;
g[a + 68 >> 2] = b;
return
}
function pd(b, d, e, f, h, j, k, l, m, n, o, p, q, r, s) {
b = b | 0;
d = d | 0;
e = e | 0;
f =
+f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
s = +s;
var t = 0,
u = 0,
v = 0;
t = i;
i = i + 64 | 0;
u = t;
c[u + 0 >> 2] = 0;
c[u + 4 >> 2] = 0;
c[u + 8 >> 2] = 0;
c[u + 12 >> 2] = 0;
c[u >> 2] = 7;
v = u + 20 | 0;
c[v >> 2] = 0;
c[v + 4 >> 2] = 0;
c[u + 8 >> 2] = d;
c[u + 12 >> 2] = e;
a[u + 16 >> 0] = f != 0 & 1;
g[u + 60 >> 2] = h;
a[u + 44 >> 0] = j != 0 & 1;
g[u + 56 >> 2] = k;
k = +l;
l = +m;
e = u + 20 | 0;
g[e >> 2] = k;
g[e + 4 >> 2] = l;
l = +n;
n = +o;
e = u + 28 | 0;
g[e >> 2] = l;
g[e + 4 >> 2] = n;
n = +p;
p = +q;
e = u + 36 | 0;
g[e >> 2] = n;
g[e + 4 >> 2] = p;
g[u + 48 >> 2] = r;
g[u + 52 >> 2] = s;
e = yj(b, u) | 0;
i = t;
return e | 0
}
function qd(b, d, e, f, h, j, k, l, m, n, o, p, q) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = +h;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
var r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0;
r = i;
i = i + 80 | 0;
s = r + 16 | 0;
t = r + 8 | 0;
u = r;
c[s + 0 >> 2] = 0;
c[s + 4 >> 2] = 0;
c[s + 8 >> 2] = 0;
c[s + 12 >> 2] = 0;
c[s >> 2] = 7;
v = s + 20 | 0;
w = s + 36 | 0;
c[v + 0 >> 2] = 0;
c[v + 4 >> 2] = 0;
c[v + 8 >> 2] = 0;
c[v + 12 >> 2] = 0;
g[w >> 2] = 1;
g[s + 40 >> 2] = 0;
a[s + 16 >> 0] = l != 0 & 1;
g[s + 60 >> 2] = m;
a[s + 44 >> 0] = n != 0 & 1;
g[s + 56 >> 2] = o;
g[s + 48 >> 2] = p;
g[s + 52 >> 2] = q;
g[t >> 2] = f;
g[t + 4 >> 2] = h;
g[u >> 2] = j;
g[u + 4 >> 2] = k;
Rh(s, d, e, t, u);
u = yj(b, s) | 0;
i = r;
return u | 0
}
function rd(a, b, c) {
a = a | 0;
b = +b;
c = +c;
var d = 0,
e = 0;
d = i;
i = i + 16 | 0;
e = d;
g[e >>
2] = b;
g[e + 4 >> 2] = c;
ok(a, e);
i = d;
return
}
function sd(a, b, c) {
a = a | 0;
b = +b;
c = +c;
var d = 0,
e = 0;
d = i;
i = i + 16 | 0;
e = d;
g[e >> 2] = b;
g[e + 4 >> 2] = c;
pk(a, e);
i = d;
return
}
function td(a, b) {
a = a | 0;
b = +b;
var c = 0;
c = i;
qk(a, b != 0);
i = c;
return
}
function ud(a) {
a = a | 0;
return 1+(c[a + 4 >> 2] | 0)
}
function vd(a) {
a = a | 0;
return 1+((c[a + 8 >> 2] | 0) - (c[a + 4 >> 2] | 0) | 0)
}
function wd(b, d, e, f, j, k, l, m, n, o, p, q, r) {
b = b | 0;
d = +d;
e = +e;
f = +f;
j = +j;
k = +k;
l = +l;
m = +m;
n = +n;
o = +o;
p = +p;
q = +q;
r = +r;
var s = 0,
t = 0,
u = 0,
v = 0;
s = i;
i = i + 64 | 0;
t = s + 8 | 0;
u = s;
v = s + 16 | 0;
h[t >> 3] = l;
h[u >> 3] = p;
a[v + 20 >> 0] = ~~d;
a[v + 21 >> 0] = ~~f;
a[v + 22 >> 0] = ~~e;
a[v + 23 >> 0] = ~~j;
c[v >> 2] = ~~k >>> 0;
c[v + 32 >> 2] = t;
g[v + 24 >> 2] = m;
m = +n;
n = +o;
t = v + 4 | 0;
g[t >> 2] = m;
g[t + 4 >> 2] = n;
c[v + 28 >> 2] = u;
n = +q;
q = +r;
u = v + 12 | 0;
g[u >> 2] = n;
g[u + 4 >> 2] = q;
q = +(wk(b, v) | 0);
i = s;
return +q
}
function xd(a) {
a = a | 0;
var b = 0,
c = 0;
b = i;
c = uk(a) | 0;
i = b;
return c | 0
}
function yd(a) {
a = a | 0;
return 1+(c[a + 44 >> 2] | 0)
}
function zd(a) {
a = a | 0;
return c[a + 96 >> 2] | 0
}
function Ad(a) {
a = a | 0;
return c[a + 104 >> 2] | 0
}
function Bd(a, b) {
a = a | 0;
b = +b;
g[a + 340 >> 2] = b;
return
}
function Cd(a, b) {
a = a | 0;
b = +b;
var c = 0;
c = b;
g[a + 320 >> 2] = c;
g[a + 28 >> 2] = 1 / c;
return
}
function Dd(a, b) {
a = a | 0;
b = +b;
var c = 0;
c = b * 2;
g[a + 32 >> 2] = c;
g[a + 40 >> 2] = c * c;
g[a + 36 >> 2] = 1 / c;
return
}
function Ed(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Fd(a, b, c, d, e) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = +e;
var f = 0;
a = i;
f = +La(b | 0, ++g[c >> 2], ++g[c + 4 >> 2], ++g[d >> 2], ++g[d + 4 >> 2], +e);
i = a;
return +f
}
function Gd(a, b, c, d, e, f) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
f = +f;
return 0
}
function Hd(a, b) {
a = a | 0;
b = b | 0;
return 1
}
function Id(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Jd(a, b) {
a = a | 0;
b = b | 0;
var c = 0;
a = i;
c = Xa(b | 0) | 0;
i = a;
return c | 0
}
function Kd(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
return 0
}
function Ld(a, b) {
a = a | 0;
b = b | 0;
return 1
}
function Md(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Nd(a, b) {
a = a | 0;
b = b | 0;
a = i;
Pa(b | 0);
i = a;
return
}
function Od(a, b) {
a = a | 0;
b = b | 0;
a = i;
Wa(b | 0);
i = a;
return
}
function Pd(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
return
}
function Qd(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
return
}
function Rd(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
return
}
function Sd(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
return
}
function Td(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
a = i;
ya(b |
0, c | 0);
i = a;
return
}
function Ud(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
a = i;
Ya(b | 0, c | 0);
i = a;
return
}
function Vd(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Wd(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Xd(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function Yd() {
c[2] = 280;
c[4] = 176;
c[6] = 72;
return
}
function Zd(d, e) {
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca =
0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0,
ya = 0,
za = 0,
Aa = 0,
Ba = 0,
Ca = 0,
Da = 0,
Ea = 0,
Fa = 0,
Ga = 0,
Ha = 0;
f = i;
i = i + 320 | 0;
h = f;
j = f + 284 | 0;
k = f + 248 | 0;
l = f + 236 | 0;
m = f + 144 | 0;
n = f + 120 | 0;
o = f + 16 | 0;
p = f + 12 | 0;
q = f + 8 | 0;
Km(h);
c[104] = (c[104] | 0) + 1;
c[d >> 2] = 0;
r = e + 128 | 0;
s = d + 4 | 0;
g[s >> 2] = +g[r >> 2];
t = e + 28 | 0;
u = j + 0 | 0;
v = e + 56 | 0;
w = u + 36 | 0;
do {
c[u >> 2] = c[v >> 2];
u = u + 4 | 0;
v = v + 4 | 0
} while ((u | 0) < (w | 0));
u = k + 0 | 0;
v = e + 92 | 0;
w = u + 36 | 0;
do {
c[u >> 2] = c[v >> 2];
u = u + 4 | 0;
v = v + 4 | 0
} while ((u | 0) < (w | 0));
v = j + 24 | 0;
x =
+g[v >> 2];
y = +O(+(x / 6.2831854820251465)) * 6.2831854820251465;
z = x - y;
g[v >> 2] = z;
u = j + 28 | 0;
x = +g[u >> 2] - y;
g[u >> 2] = x;
w = k + 24 | 0;
y = +g[w >> 2];
A = +O(+(y / 6.2831854820251465)) * 6.2831854820251465;
B = y - A;
g[w >> 2] = B;
C = k + 28 | 0;
y = +g[C >> 2] - A;
g[C >> 2] = y;
A = +g[r >> 2];
D = +g[e + 24 >> 2] + +g[e + 52 >> 2] + -.014999999664723873;
E = D < .004999999888241291 ? .004999999888241291 : D;
b[l + 4 >> 1] = 0;
c[m + 0 >> 2] = c[e + 0 >> 2];
c[m + 4 >> 2] = c[e + 4 >> 2];
c[m + 8 >> 2] = c[e + 8 >> 2];
c[m + 12 >> 2] = c[e + 12 >> 2];
c[m + 16 >> 2] = c[e + 16 >> 2];
c[m + 20 >> 2] = c[e + 20 >> 2];
c[m + 24 >> 2] = c[e + 24 >> 2];
r = m + 28 | 0;
c[r +
0 >> 2] = c[t + 0 >> 2];
c[r + 4 >> 2] = c[t + 4 >> 2];
c[r + 8 >> 2] = c[t + 8 >> 2];
c[r + 12 >> 2] = c[t + 12 >> 2];
c[r + 16 >> 2] = c[t + 16 >> 2];
c[r + 20 >> 2] = c[t + 20 >> 2];
c[r + 24 >> 2] = c[t + 24 >> 2];
a[m + 88 >> 0] = 0;
r = j + 8 | 0;
F = j + 12 | 0;
G = j + 16 | 0;
H = j + 20 | 0;
I = j + 4 | 0;
J = k + 8 | 0;
K = k + 12 | 0;
L = k + 16 | 0;
M = k + 20 | 0;
N = k + 4 | 0;
P = m + 56 | 0;
Q = m + 64 | 0;
R = m + 68 | 0;
U = m + 72 | 0;
V = m + 80 | 0;
W = m + 84 | 0;
X = n + 16 | 0;
D = E + .0012499999720603228;
Y = E + -.0012499999720603228;
Z = z;
z = x;
x = B;
B = y;
_ = 0;
y = 0;
a:
while (1) {
$ = 1 - y;
aa = $ * Z + y * z;
ba = +T(+aa);
ca = +S(+aa);
aa = +g[j >> 2];
da = +g[I >> 2];
ea = $ * x + y * B;
fa = +T(+ea);
ga = +S(+ea);
ea = +g[k >> 2];
ha =
+g[N >> 2];
ia = $ * +g[J >> 2] + y * +g[L >> 2] - (ga * ea - fa * ha);
ja = $ * +g[K >> 2] + y * +g[M >> 2] - (fa * ea + ga * ha);
ha = +($ * +g[r >> 2] + y * +g[G >> 2] - (ca * aa - ba * da));
ea = +($ * +g[F >> 2] + y * +g[H >> 2] - (ba * aa + ca * da));
ka = P;
g[ka >> 2] = ha;
g[ka + 4 >> 2] = ea;
g[Q >> 2] = ba;
g[R >> 2] = ca;
ca = +ia;
ia = +ja;
ka = U;
g[ka >> 2] = ca;
g[ka + 4 >> 2] = ia;
g[V >> 2] = fa;
g[W >> 2] = ga;
de(n, l, m);
ga = +g[X >> 2];
if (ga <= 0) {
la = 3;
break
}
if (ga < D) {
la = 5;
break
}
+_d(o, l, e, j, t, k, y);
ka = 0;
ga = A;
while (1) {
fa = +$d(o, p, q, ga);
if (fa > D) {
la = 8;
break a
}
if (fa > Y) {
ma = ga;
break
}
na = c[p >> 2] | 0;
oa = c[q >> 2] | 0;
ia = +ae(o, na, oa, y);
if (ia <
Y) {
la = 11;
break a
}
if (!(ia <= D)) {
pa = y;
qa = ga;
ra = 0;
sa = ia;
ta = fa
} else {
la = 13;
break a
}
while (1) {
if ((ra & 1 | 0) == 0)
ua = (pa + qa) * .5;
else
ua = pa + (E - sa) * (qa - pa) / (ta - sa);
ra = ra + 1 | 0;
c[110] = (c[110] | 0) + 1;
fa = +ae(o, na, oa, ua);
ia = fa - E;
if (ia > 0)
va = ia;
else
va = -ia;
if (va < .0012499999720603228) {
wa = ua;
break
}
xa = fa > E;
if ((ra | 0) == 50) {
wa = ga;
break
} else {
pa = xa ? ua : pa;
qa = xa ? qa : ua;
sa = xa ? fa : sa;
ta = xa ? ta : fa
}
}
oa = c[112] | 0;
c[112] = (oa | 0) > (ra | 0) ? oa : ra;
ka = ka + 1 | 0;
if ((ka | 0) == 8) {
ma = y;
break
} else
ga = wa
}
ka = _ + 1 | 0;
c[106] = (c[106] | 0) + 1;
if ((ka | 0) == 20) {
la = 25;
break
}
Z =
+g[v >> 2];
z = +g[u >> 2];
x = +g[w >> 2];
B = +g[C >> 2];
_ = ka;
y = ma
}
if ((la | 0) == 3) {
c[d >> 2] = 2;
g[s >> 2] = 0;
ya = _;
za = c[108] | 0;
Aa = (za | 0) > (ya | 0);
Ba = Aa ? za : ya;
c[108] = Ba;
Ca = +Mm(h);
Da = +g[102];
Ea = Da > Ca;
Fa = Ea ? Da : Ca;
g[102] = Fa;
Ga = +g[100];
Ha = Ca + Ga;
g[100] = Ha;
i = f;
return
} else if ((la | 0) == 5) {
c[d >> 2] = 3;
g[s >> 2] = y;
ya = _;
za = c[108] | 0;
Aa = (za | 0) > (ya | 0);
Ba = Aa ? za : ya;
c[108] = Ba;
Ca = +Mm(h);
Da = +g[102];
Ea = Da > Ca;
Fa = Ea ? Da : Ca;
g[102] = Fa;
Ga = +g[100];
Ha = Ca + Ga;
g[100] = Ha;
i = f;
return
} else if ((la | 0) == 8) {
c[d >> 2] = 4;
g[s >> 2] = A
} else if ((la | 0) == 11) {
c[d >> 2] = 1;
g[s >> 2] = y
} else if ((la |
0) == 13) {
c[d >> 2] = 3;
g[s >> 2] = y
} else if ((la | 0) == 25) {
c[d >> 2] = 1;
g[s >> 2] = ma;
ya = 20;
za = c[108] | 0;
Aa = (za | 0) > (ya | 0);
Ba = Aa ? za : ya;
c[108] = Ba;
Ca = +Mm(h);
Da = +g[102];
Ea = Da > Ca;
Fa = Ea ? Da : Ca;
g[102] = Fa;
Ga = +g[100];
Ha = Ca + Ga;
g[100] = Ha;
i = f;
return
}
c[106] = (c[106] | 0) + 1;
ya = _ + 1 | 0;
za = c[108] | 0;
Aa = (za | 0) > (ya | 0);
Ba = Aa ? za : ya;
c[108] = Ba;
Ca = +Mm(h);
Da = +g[102];
Ea = Da > Ca;
Fa = Ea ? Da : Ca;
g[102] = Fa;
Ga = +g[100];
Ha = Ca + Ga;
g[100] = Ha;
i = f;
return
}
function _d(e, f, h, j, k, l, m) {
e = e | 0;
f = f | 0;
h = h | 0;
j = j | 0;
k = k | 0;
l = l | 0;
m = +m;
var n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w =
0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0;
n = i;
c[e >> 2] = h;
c[e + 4 >> 2] = k;
o = b[f + 4 >> 1] | 0;
p = e + 8 | 0;
q = p + 0 | 0;
r = j + 0 | 0;
j = q + 36 | 0;
do {
c[q >> 2] = c[r >> 2];
q = q + 4 | 0;
r = r + 4 | 0
} while ((q | 0) < (j | 0));
s = e + 44 | 0;
q = s + 0 | 0;
r = l + 0 | 0;
j = q + 36 | 0;
do {
c[q >> 2] = c[r >> 2];
q = q + 4 | 0;
r = r + 4 | 0
} while ((q | 0) < (j | 0));
t = 1 - m;
u = t * +g[e + 32 >> 2] + +g[e + 36 >> 2] * m;
v = +T(+u);
w = +S(+u);
u = +g[p >> 2];
x = +g[e + 12 >> 2];
y = t * +g[e + 16 >> 2] + +g[e + 24 >> 2] * m - (w * u - v * x);
z = t * +g[e + 20 >> 2] + +g[e + 28 >> 2] * m - (v * u + w * x);
x = t * +g[e + 68 >> 2] + +g[e + 72 >> 2] * m;
u = +T(+x);
A = +S(+x);
x = +g[s >>
2];
B = +g[e + 48 >> 2];
C = t * +g[e + 52 >> 2] + +g[e + 60 >> 2] * m - (A * x - u * B);
D = t * +g[e + 56 >> 2] + +g[e + 64 >> 2] * m - (u * x + A * B);
if (o << 16 >> 16 == 1) {
c[e + 80 >> 2] = 0;
o = (c[h + 16 >> 2] | 0) + (d[f + 6 >> 0] << 3) | 0;
B = +g[o >> 2];
x = +g[o + 4 >> 2];
o = (c[k + 16 >> 2] | 0) + (d[f + 9 >> 0] << 3) | 0;
m = +g[o >> 2];
t = +g[o + 4 >> 2];
o = e + 92 | 0;
E = C + (A * m - u * t) - (y + (w * B - v * x));
F = D + (u * m + A * t) - (z + (v * B + w * x));
x = +E;
B = +F;
s = o;
g[s >> 2] = x;
g[s + 4 >> 2] = B;
B = +Q(+(E * E + F * F));
if (B < 1.1920928955078125E-7)
G = 0;
else {
x = 1 / B;
g[o >> 2] = E * x;
g[e + 96 >> 2] = F * x;
G = B
}
o = 8784;
s = c[o + 4 >> 2] | 0;
p = e + 84 | 0;
c[p >> 2] = c[o >> 2];
c[p + 4 >> 2] = s;
H = G;
i = n;
return +H
}
s = f + 6 | 0;
p = f + 7 | 0;
o = e + 80 | 0;
if ((a[s >> 0] | 0) == (a[p >> 0] | 0)) {
c[o >> 2] = 2;
r = c[k + 16 >> 2] | 0;
q = r + (d[f + 9 >> 0] << 3) | 0;
G = +g[q >> 2];
B = +g[q + 4 >> 2];
q = r + (d[f + 10 >> 0] << 3) | 0;
x = +g[q >> 2];
F = +g[q + 4 >> 2];
q = e + 92 | 0;
E = x - G;
t = F - B;
m = -E;
I = +t;
J = +m;
r = q;
g[r >> 2] = I;
g[r + 4 >> 2] = J;
J = +Q(+(t * t + E * E));
if (J < 1.1920928955078125E-7) {
K = t;
L = m
} else {
E = 1 / J;
J = t * E;
g[q >> 2] = J;
t = E * m;
g[e + 96 >> 2] = t;
K = J;
L = t
}
t = (G + x) * .5;
x = (B + F) * .5;
F = +t;
B = +x;
r = e + 84 | 0;
g[r >> 2] = F;
g[r + 4 >> 2] = B;
r = (c[h + 16 >> 2] | 0) + (d[s >> 0] << 3) | 0;
B = +g[r >> 2];
F = +g[r + 4 >> 2];
G = (A * K - u * L) * (y + (w * B - v * F) - (C + (A * t - u *
x))) + (u * K + A * L) * (z + (v * B + w * F) - (D + (u * t + A * x)));
if (!(G < 0)) {
H = G;
i = n;
return +H
}
x = +-K;
K = +-L;
r = q;
g[r >> 2] = x;
g[r + 4 >> 2] = K;
H = -G;
i = n;
return +H
} else {
c[o >> 2] = 1;
o = c[h + 16 >> 2] | 0;
h = o + (d[s >> 0] << 3) | 0;
G = +g[h >> 2];
K = +g[h + 4 >> 2];
h = o + (d[p >> 0] << 3) | 0;
x = +g[h >> 2];
L = +g[h + 4 >> 2];
h = e + 92 | 0;
t = x - G;
F = L - K;
B = -t;
J = +F;
m = +B;
p = h;
g[p >> 2] = J;
g[p + 4 >> 2] = m;
m = +Q(+(F * F + t * t));
if (m < 1.1920928955078125E-7) {
M = F;
N = B
} else {
t = 1 / m;
m = F * t;
g[h >> 2] = m;
F = t * B;
g[e + 96 >> 2] = F;
M = m;
N = F
}
F = (G + x) * .5;
x = (K + L) * .5;
L = +F;
K = +x;
p = e + 84 | 0;
g[p >> 2] = L;
g[p + 4 >> 2] = K;
p = (c[k + 16 >> 2] | 0) + (d[f + 9 >> 0] <<
3) | 0;
K = +g[p >> 2];
L = +g[p + 4 >> 2];
G = (w * M - v * N) * (C + (A * K - u * L) - (y + (w * F - v * x))) + (v * M + w * N) * (D + (u * K + A * L) - (z + (v * F + w * x)));
if (!(G < 0)) {
H = G;
i = n;
return +H
}
x = +-M;
M = +-N;
p = h;
g[p >> 2] = x;
g[p + 4 >> 2] = M;
H = -G;
i = n;
return +H
}
return 0
}
function $d(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = +e;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0;
f = i;
h = 1 - e;
j = h * +g[a + 32 >> 2] + +g[a + 36 >> 2] * e;
k = +T(+j);
l = +S(+j);
j = +g[a + 8 >> 2];
m = +g[a + 12 >> 2];
n = h * +g[a + 16 >> 2] + +g[a + 24 >> 2] * e - (l * j - k * m);
o = h * +g[a + 20 >> 2] +
+g[a + 28 >> 2] * e - (k * j + l * m);
m = h * +g[a + 68 >> 2] + +g[a + 72 >> 2] * e;
j = +T(+m);
p = +S(+m);
m = +g[a + 44 >> 2];
q = +g[a + 48 >> 2];
r = h * +g[a + 52 >> 2] + +g[a + 60 >> 2] * e - (p * m - j * q);
s = h * +g[a + 56 >> 2] + +g[a + 64 >> 2] * e - (j * m + p * q);
t = c[a + 80 >> 2] | 0;
if ((t | 0) == 0) {
q = +g[a + 92 >> 2];
m = +g[a + 96 >> 2];
e = l * q + k * m;
h = l * m - k * q;
u = -q;
v = -m;
w = p * u + j * v;
x = p * v - j * u;
y = c[a >> 2] | 0;
z = c[y + 16 >> 2] | 0;
A = c[y + 20 >> 2] | 0;
if ((A | 0) > 1) {
y = 0;
u = h * +g[z + 4 >> 2] + e * +g[z >> 2];
B = 1;
while (1) {
v = e * +g[z + (B << 3) >> 2] + h * +g[z + (B << 3) + 4 >> 2];
C = v > u;
D = C ? B : y;
B = B + 1 | 0;
if ((B | 0) == (A | 0)) {
E = D;
break
} else {
y = D;
u = C ? v : u
}
}
} else
E =
0;
c[b >> 2] = E;
E = c[a + 4 >> 2] | 0;
y = c[E + 16 >> 2] | 0;
A = c[E + 20 >> 2] | 0;
if ((A | 0) > 1) {
E = 0;
u = x * +g[y + 4 >> 2] + w * +g[y >> 2];
B = 1;
while (1) {
h = w * +g[y + (B << 3) >> 2] + x * +g[y + (B << 3) + 4 >> 2];
C = h > u;
D = C ? B : E;
B = B + 1 | 0;
if ((B | 0) == (A | 0)) {
F = D;
break
} else {
E = D;
u = C ? h : u
}
}
} else
F = 0;
c[d >> 2] = F;
E = z + (c[b >> 2] << 3) | 0;
u = +g[E >> 2];
x = +g[E + 4 >> 2];
E = y + (F << 3) | 0;
w = +g[E >> 2];
h = +g[E + 4 >> 2];
G = q * (r + (p * w - j * h) - (n + (l * u - k * x))) + m * (s + (j * w + p * h) - (o + (k * u + l * x)));
i = f;
return +G
} else if ((t | 0) == 1) {
x = +g[a + 92 >> 2];
u = +g[a + 96 >> 2];
h = l * x - k * u;
w = k * x + l * u;
u = +g[a + 84 >> 2];
x = +g[a + 88 >> 2];
m = n + (l * u - k * x);
q = o + (k * u + l * x);
x = -h;
u = -w;
e = p * x + j * u;
v = p * u - j * x;
c[b >> 2] = -1;
E = c[a + 4 >> 2] | 0;
F = c[E + 16 >> 2] | 0;
y = c[E + 20 >> 2] | 0;
if ((y | 0) > 1) {
E = 0;
x = v * +g[F + 4 >> 2] + e * +g[F >> 2];
z = 1;
while (1) {
u = e * +g[F + (z << 3) >> 2] + v * +g[F + (z << 3) + 4 >> 2];
A = u > x;
B = A ? z : E;
z = z + 1 | 0;
if ((z | 0) == (y | 0)) {
H = B;
break
} else {
E = B;
x = A ? u : x
}
}
} else
H = 0;
c[d >> 2] = H;
E = F + (H << 3) | 0;
x = +g[E >> 2];
v = +g[E + 4 >> 2];
G = h * (r + (p * x - j * v) - m) + w * (s + (j * x + p * v) - q);
i = f;
return +G
} else if ((t | 0) == 2) {
q = +g[a + 92 >> 2];
v = +g[a + 96 >> 2];
x = p * q - j * v;
w = j * q + p * v;
v = +g[a + 84 >> 2];
q = +g[a + 88 >> 2];
m = r + (p * v - j * q);
r = s + (j * v + p * q);
q = -x;
p = -w;
v = l * q + k * p;
j = l * p - k * q;
c[d >> 2] = -1;
t = c[a >> 2] | 0;
a = c[t + 16 >> 2] | 0;
E = c[t + 20 >> 2] | 0;
if ((E | 0) > 1) {
t = 0;
q = j * +g[a + 4 >> 2] + v * +g[a >> 2];
H = 1;
while (1) {
p = v * +g[a + (H << 3) >> 2] + j * +g[a + (H << 3) + 4 >> 2];
F = p > q;
y = F ? H : t;
H = H + 1 | 0;
if ((H | 0) == (E | 0)) {
I = y;
break
} else {
t = y;
q = F ? p : q
}
}
} else
I = 0;
c[b >> 2] = I;
t = a + (I << 3) | 0;
q = +g[t >> 2];
j = +g[t + 4 >> 2];
G = x * (n + (l * q - k * j) - m) + w * (o + (k * q + l * j) - r);
i = f;
return +G
} else {
c[b >> 2] = -1;
c[d >> 2] = -1;
G = 0;
i = f;
return +G
}
return 0
}
function ae(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = +e;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v =
0,
w = 0,
x = 0;
f = i;
h = 1 - e;
j = h * +g[a + 32 >> 2] + +g[a + 36 >> 2] * e;
k = +T(+j);
l = +S(+j);
j = +g[a + 8 >> 2];
m = +g[a + 12 >> 2];
n = h * +g[a + 16 >> 2] + +g[a + 24 >> 2] * e - (l * j - k * m);
o = h * +g[a + 20 >> 2] + +g[a + 28 >> 2] * e - (k * j + l * m);
m = h * +g[a + 68 >> 2] + +g[a + 72 >> 2] * e;
j = +T(+m);
p = +S(+m);
m = +g[a + 44 >> 2];
q = +g[a + 48 >> 2];
r = h * +g[a + 52 >> 2] + +g[a + 60 >> 2] * e - (p * m - j * q);
s = h * +g[a + 56 >> 2] + +g[a + 64 >> 2] * e - (j * m + p * q);
t = c[a + 80 >> 2] | 0;
if ((t | 0) == 0) {
u = (c[(c[a >> 2] | 0) + 16 >> 2] | 0) + (b << 3) | 0;
q = +g[u >> 2];
m = +g[u + 4 >> 2];
u = (c[(c[a + 4 >> 2] | 0) + 16 >> 2] | 0) + (d << 3) | 0;
e = +g[u >> 2];
h = +g[u + 4 >> 2];
v = +g[a + 92 >> 2] *
(r + (p * e - j * h) - (n + (l * q - k * m))) + +g[a + 96 >> 2] * (s + (j * e + p * h) - (o + (k * q + l * m)));
i = f;
return +v
} else if ((t | 0) == 1) {
m = +g[a + 92 >> 2];
q = +g[a + 96 >> 2];
h = +g[a + 84 >> 2];
e = +g[a + 88 >> 2];
u = (c[(c[a + 4 >> 2] | 0) + 16 >> 2] | 0) + (d << 3) | 0;
w = +g[u >> 2];
x = +g[u + 4 >> 2];
v = (l * m - k * q) * (r + (p * w - j * x) - (n + (l * h - k * e))) + (k * m + l * q) * (s + (j * w + p * x) - (o + (k * h + l * e)));
i = f;
return +v
} else if ((t | 0) == 2) {
e = +g[a + 92 >> 2];
h = +g[a + 96 >> 2];
x = +g[a + 84 >> 2];
w = +g[a + 88 >> 2];
t = (c[(c[a >> 2] | 0) + 16 >> 2] | 0) + (b << 3) | 0;
q = +g[t >> 2];
m = +g[t + 4 >> 2];
v = (p * e - j * h) * (n + (l * q - k * m) - (r + (p * x - j * w))) + (j * e + p * h) * (o + (k * q +
l * m) - (s + (j * x + p * w)));
i = f;
return +v
} else {
v = 0;
i = f;
return +v
}
return 0
}
function be(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0;
e = i;
f = c[b + 4 >> 2] | 0;
if ((f | 0) == 0) {
c[a + 16 >> 2] = b + 12;
c[a + 20 >> 2] = 1;
g[a + 24 >> 2] = +g[b + 8 >> 2];
i = e;
return
} else if ((f | 0) == 2) {
c[a + 16 >> 2] = b + 20;
c[a + 20 >> 2] = c[b + 148 >> 2];
g[a + 24 >> 2] = +g[b + 8 >> 2];
i = e;
return
} else if ((f | 0) == 1) {
c[a + 16 >> 2] = b + 12;
c[a + 20 >> 2] = 2;
g[a + 24 >> 2] = +g[b + 8 >> 2];
i = e;
return
} else if ((f | 0) == 3) {
f = b + 12 | 0;
h = (c[f >> 2] | 0) + (d << 3) | 0;
j = c[h + 4 >> 2] | 0;
k = a;
c[k >> 2] = c[h >> 2];
c[k + 4 >> 2] = j;
j = d + 1 | 0;
d = a + 8 | 0;
k =
c[f >> 2] | 0;
if ((j | 0) < (c[b + 16 >> 2] | 0)) {
f = k + (j << 3) | 0;
j = c[f + 4 >> 2] | 0;
h = d;
c[h >> 2] = c[f >> 2];
c[h + 4 >> 2] = j
} else {
j = k;
k = c[j + 4 >> 2] | 0;
h = d;
c[h >> 2] = c[j >> 2];
c[h + 4 >> 2] = k
}
c[a + 16 >> 2] = a;
c[a + 20 >> 2] = 2;
g[a + 24 >> 2] = +g[b + 8 >> 2];
i = e;
return
} else {
i = e;
return
}
}
function ce(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0;
b = i;
d = a + 16 | 0;
e = +g[d >> 2];
f = +g[d + 4 >> 2];
d = a + 36 | 0;
h = a + 52 | 0;
j = +g[h >> 2];
k = +g[h + 4 >> 2];
h = a + 72 | 0;
l = a + 88 | 0;
m = +g[l >> 2];
n = +g[l + 4 >> 2];
o = j - e;
p = k - f;
q = e * o + f * p;
r = j * o + k *
p;
s = m - e;
t = n - f;
u = e * s + f * t;
v = m * s + n * t;
w = m - j;
x = n - k;
y = j * w + k * x;
z = m * w + n * x;
x = o * t - p * s;
s = (j * n - k * m) * x;
p = (f * m - e * n) * x;
n = (e * k - f * j) * x;
if (!(!(q >= -0) | !(u >= -0))) {
g[a + 24 >> 2] = 1;
c[a + 108 >> 2] = 1;
i = b;
return
}
if (!(!(q < -0) | !(r > 0) | !(n <= 0))) {
x = 1 / (r - q);
g[a + 24 >> 2] = r * x;
g[a + 60 >> 2] = -(q * x);
c[a + 108 >> 2] = 2;
i = b;
return
}
if (!(!(u < -0) | !(v > 0) | !(p <= 0))) {
x = 1 / (v - u);
g[a + 24 >> 2] = v * x;
g[a + 96 >> 2] = -(u * x);
c[a + 108 >> 2] = 2;
A = d + 0 | 0;
B = h + 0 | 0;
C = A + 36 | 0;
do {
c[A >> 2] = c[B >> 2];
A = A + 4 | 0;
B = B + 4 | 0
} while ((A | 0) < (C | 0));
i = b;
return
}
if (!(!(r <= 0) | !(y >= -0))) {
g[a + 60 >> 2] = 1;
c[a + 108 >>
2] = 1;
A = a + 0 | 0;
B = d + 0 | 0;
C = A + 36 | 0;
do {
c[A >> 2] = c[B >> 2];
A = A + 4 | 0;
B = B + 4 | 0
} while ((A | 0) < (C | 0));
i = b;
return
}
if (!(!(v <= 0) | !(z <= 0))) {
g[a + 96 >> 2] = 1;
c[a + 108 >> 2] = 1;
A = a + 0 | 0;
B = h + 0 | 0;
C = A + 36 | 0;
do {
c[A >> 2] = c[B >> 2];
A = A + 4 | 0;
B = B + 4 | 0
} while ((A | 0) < (C | 0));
i = b;
return
}
if (!(y < -0) | !(z > 0) | !(s <= 0)) {
v = 1 / (n + (s + p));
g[a + 24 >> 2] = s * v;
g[a + 60 >> 2] = p * v;
g[a + 96 >> 2] = n * v;
c[a + 108 >> 2] = 3;
i = b;
return
} else {
v = 1 / (z - y);
g[a + 60 >> 2] = z * v;
g[a + 96 >> 2] = -(y * v);
c[a + 108 >> 2] = 2;
A = a + 0 | 0;
B = h + 0 | 0;
C = A + 36 | 0;
do {
c[A >> 2] = c[B >> 2];
A = A + 4 | 0;
B = B + 4 | 0
} while ((A | 0) < (C | 0));
i = b;
return
}
}
function de(d,
e, f) {
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0;
h = i;
i = i + 176 | 0;
j = h + 152 | 0;
l = h + 136 | 0;
m = h;
n = h + 124 | 0;
o = h + 112 | 0;
c[114] = (c[114] | 0) + 1;
p = f + 28 | 0;
q = f + 56 | 0;
c[j + 0 >> 2] = c[q + 0 >> 2];
c[j + 4 >> 2] = c[q + 4 >> 2];
c[j + 8 >> 2] = c[q + 8 >> 2];
c[j + 12 >> 2] = c[q + 12 >> 2];
q = f + 72 |
0;
c[l + 0 >> 2] = c[q + 0 >> 2];
c[l + 4 >> 2] = c[q + 4 >> 2];
c[l + 8 >> 2] = c[q + 8 >> 2];
c[l + 12 >> 2] = c[q + 12 >> 2];
ee(m, e, f, j, p, l);
c[n + 0 >> 2] = 0;
c[n + 4 >> 2] = 0;
c[n + 8 >> 2] = 0;
c[o + 0 >> 2] = 0;
c[o + 4 >> 2] = 0;
c[o + 8 >> 2] = 0;
p = m + 108 | 0;
r = +g[j + 12 >> 2];
s = +g[j + 8 >> 2];
q = f + 16 | 0;
t = f + 20 | 0;
u = +g[j >> 2];
v = +g[j + 4 >> 2];
w = +g[l + 12 >> 2];
x = +g[l + 8 >> 2];
j = f + 44 | 0;
y = f + 48 | 0;
z = +g[l >> 2];
A = +g[l + 4 >> 2];
l = m + 16 | 0;
B = m + 20 | 0;
C = m + 52 | 0;
D = m + 56 | 0;
E = m + 16 | 0;
F = m + 36 | 0;
G = m + 52 | 0;
H = m + 24 | 0;
I = m + 60 | 0;
J = c[p >> 2] | 0;
K = 0;
a:
while (1) {
L = (J | 0) > 0;
if (L) {
M = 0;
do {
c[n + (M << 2) >> 2] = c[m + (M * 36 | 0) + 28 >> 2];
c[o + (M << 2) >> 2] =
c[m + (M * 36 | 0) + 32 >> 2];
M = M + 1 | 0
} while ((M | 0) != (J | 0))
}
do if ((J | 0) == 2) {
M = E;
N = +g[M >> 2];
O = +g[M + 4 >> 2];
M = G;
P = +g[M >> 2];
R = +g[M + 4 >> 2];
S = P - N;
T = R - O;
U = N * S + O * T;
if (U >= -0) {
g[H >> 2] = 1;
c[p >> 2] = 1;
V = 13;
break
}
O = P * S + R * T;
if (!(O <= 0)) {
T = 1 / (O - U);
g[H >> 2] = O * T;
g[I >> 2] = -(U * T);
c[p >> 2] = 2;
V = 14;
break
} else {
g[I >> 2] = 1;
c[p >> 2] = 1;
M = m + 0 | 0;
W = F + 0 | 0;
X = M + 36 | 0;
do {
c[M >> 2] = c[W >> 2];
M = M + 4 | 0;
W = W + 4 | 0
} while ((M | 0) < (X | 0));
V = 13;
break
}
} else if ((J | 0) == 3) {
ce(m);
W = c[p >> 2] | 0;
if ((W | 0) == 3) {
V = 11;
break a
} else {
Y = W;
V = 12
}
} else {
Y = J;
V = 12
}
while (0);
do if ((V | 0) == 12) {
V = 0;
if ((Y |
0) == 1) {
V = 13;
break
} else if ((Y | 0) == 2) {
V = 14;
break
}
W = 8784;
T = +g[W >> 2];
Z = T;
_ = +g[W + 4 >> 2];
$ = Y
}
while (0);
do if ((V | 0) == 13) {
V = 0;
Z = -+g[l >> 2];
_ = -+g[B >> 2];
$ = 1
} else if ((V | 0) == 14) {
V = 0;
T = +g[l >> 2];
U = +g[C >> 2] - T;
O = +g[B >> 2];
R = +g[D >> 2] - O;
if (T * R - U * O > 0) {
Z = -R;
_ = U;
$ = 2;
break
} else {
Z = R;
_ = -U;
$ = 2;
break
}
}
while (0);
if (_ * _ + Z * Z < 1.4210854715202004E-14) {
aa = $;
ba = K;
V = 31;
break
}
W = m + ($ * 36 | 0) | 0;
U = -Z;
R = -_;
O = r * U + s * R;
T = r * R - s * U;
M = c[q >> 2] | 0;
X = c[t >> 2] | 0;
if ((X | 0) > 1) {
ca = 0;
U = T * +g[M + 4 >> 2] + O * +g[M >> 2];
da = 1;
while (1) {
R = O * +g[M + (da << 3) >> 2] + T * +g[M + (da << 3) + 4 >>
2];
ea = R > U;
fa = ea ? da : ca;
da = da + 1 | 0;
if ((da | 0) == (X | 0)) {
ga = fa;
break
} else {
ca = fa;
U = ea ? R : U
}
}
} else
ga = 0;
c[m + ($ * 36 | 0) + 28 >> 2] = ga;
U = +g[M + (ga << 3) >> 2];
T = +g[M + (ga << 3) + 4 >> 2];
O = u + (r * U - s * T);
R = +O;
S = +(U * s + r * T + v);
ca = W;
g[ca >> 2] = R;
g[ca + 4 >> 2] = S;
S = Z * w + _ * x;
R = _ * w - Z * x;
ca = c[j >> 2] | 0;
X = c[y >> 2] | 0;
if ((X | 0) > 1) {
da = 0;
T = R * +g[ca + 4 >> 2] + S * +g[ca >> 2];
ea = 1;
while (1) {
U = S * +g[ca + (ea << 3) >> 2] + R * +g[ca + (ea << 3) + 4 >> 2];
fa = U > T;
ha = fa ? ea : da;
ea = ea + 1 | 0;
if ((ea | 0) == (X | 0)) {
ia = ha;
break
} else {
da = ha;
T = fa ? U : T
}
}
} else
ia = 0;
c[m + ($ * 36 | 0) + 32 >> 2] = ia;
T = +g[ca + (ia << 3) >> 2];
R = +g[ca + (ia << 3) + 4 >> 2];
S = z + (w * T - x * R);
U = +S;
P = +(T * x + w * R + A);
da = m + ($ * 36 | 0) + 8 | 0;
g[da >> 2] = U;
g[da + 4 >> 2] = P;
P = +(S - O);
S = +(+g[m + ($ * 36 | 0) + 12 >> 2] - +g[m + ($ * 36 | 0) + 4 >> 2]);
da = m + ($ * 36 | 0) + 16 | 0;
g[da >> 2] = P;
g[da + 4 >> 2] = S;
ja = K + 1 | 0;
c[116] = (c[116] | 0) + 1;
if (L) {
da = 0;
do {
if ((ga | 0) == (c[n + (da << 2) >> 2] | 0) ? (ia | 0) == (c[o + (da << 2) >> 2] | 0) : 0) {
V = 30;
break a
}
da = da + 1 | 0
} while ((da | 0) < (J | 0))
}
da = (c[p >> 2] | 0) + 1 | 0;
c[p >> 2] = da;
if ((ja | 0) < 20) {
J = da;
K = ja
} else {
aa = da;
ba = ja;
V = 31;
break
}
}
if ((V | 0) == 11) {
J = c[118] | 0;
c[118] = (J | 0) > (K | 0) ? J : K;
ka = d + 8 | 0;
la = K;
V = 35
} else if ((V |
0) == 30) {
aa = c[p >> 2] | 0;
ba = ja;
V = 31
}
do if ((V | 0) == 31) {
ja = c[118] | 0;
c[118] = (ja | 0) > (ba | 0) ? ja : ba;
ja = d + 8 | 0;
if ((aa | 0) == 1) {
p = m;
K = c[p >> 2] | 0;
J = c[p + 4 >> 2] | 0;
p = d;
c[p >> 2] = K;
c[p + 4 >> 2] = J;
p = m + 8 | 0;
o = c[p >> 2] | 0;
ia = c[p + 4 >> 2] | 0;
p = ja;
c[p >> 2] = o;
c[p + 4 >> 2] = ia;
A = (c[k >> 2] = K, +g[k >> 2]);
w = (c[k >> 2] = o, +g[k >> 2]);
x = (c[k >> 2] = J, +g[k >> 2]);
ma = w;
na = A;
oa = (c[k >> 2] = ia, +g[k >> 2]);
pa = x;
qa = 1;
ra = ja;
sa = ba;
break
} else if ((aa | 0) == 2) {
x = +g[H >> 2];
A = +g[I >> 2];
w = x * +g[m >> 2] + A * +g[m + 36 >> 2];
z = x * +g[m + 4 >> 2] + A * +g[m + 40 >> 2];
Z = +w;
_ = +z;
ia = d;
g[ia >> 2] = Z;
g[ia + 4 >> 2] = _;
_ = x *
+g[m + 8 >> 2] + A * +g[m + 44 >> 2];
Z = x * +g[m + 12 >> 2] + A * +g[m + 48 >> 2];
A = +_;
x = +Z;
ia = ja;
g[ia >> 2] = A;
g[ia + 4 >> 2] = x;
ma = _;
na = w;
oa = Z;
pa = z;
qa = 2;
ra = ja;
sa = ba;
break
} else if ((aa | 0) == 3) {
ka = ja;
la = ba;
V = 35;
break
} else {
ma = +g[ja >> 2];
na = +g[d >> 2];
oa = +g[d + 12 >> 2];
pa = +g[d + 4 >> 2];
qa = aa;
ra = ja;
sa = ba;
break
}
}
while (0);
if ((V | 0) == 35) {
z = +g[H >> 2];
Z = +g[I >> 2];
w = +g[m + 96 >> 2];
_ = z * +g[m >> 2] + Z * +g[m + 36 >> 2] + w * +g[m + 72 >> 2];
x = z * +g[m + 4 >> 2] + Z * +g[m + 40 >> 2] + w * +g[m + 76 >> 2];
w = +_;
Z = +x;
I = d;
g[I >> 2] = w;
g[I + 4 >> 2] = Z;
I = ka;
g[I >> 2] = w;
g[I + 4 >> 2] = Z;
ma = _;
na = _;
oa = x;
pa = x;
qa = 3;
ra = ka;
sa = la
}
x = na - ma;
la = d + 4 | 0;
ka = d + 12 | 0;
ma = pa - oa;
I = d + 16 | 0;
g[I >> 2] = +Q(+(x * x + ma * ma));
c[d + 20 >> 2] = sa;
if ((qa | 0) == 2) {
ma = +g[l >> 2] - +g[C >> 2];
x = +g[B >> 2] - +g[D >> 2];
ta = +Q(+(ma * ma + x * x));
V = 39
} else if ((qa | 0) != 3) {
g[e >> 2] = 0;
b[e + 4 >> 1] = qa;
if ((qa | 0) > 0) {
ua = 0;
V = 41
}
} else {
x = +g[l >> 2];
ma = +g[B >> 2];
ta = (+g[C >> 2] - x) * (+g[m + 92 >> 2] - ma) - (+g[D >> 2] - ma) * (+g[m + 88 >> 2] - x);
V = 39
}
if ((V | 0) == 39) {
g[e >> 2] = ta;
b[e + 4 >> 1] = qa;
ua = 0;
V = 41
}
if ((V | 0) == 41)
while (1) {
V = 0;
a[e + ua + 6 >> 0] = c[m + (ua * 36 | 0) + 28 >> 2];
a[e + ua + 9 >> 0] = c[m + (ua * 36 | 0) + 32 >> 2];
ua = ua + 1 | 0;
if ((ua | 0) >= (qa | 0))
break;
else
V = 41
}
if ((a[f + 88 >> 0] | 0) == 0) {
i = h;
return
}
ta = +g[f + 24 >> 2];
x = +g[f + 52 >> 2];
ma = +g[I >> 2];
oa = ta + x;
if (!(ma > oa & ma > 1.1920928955078125E-7)) {
pa = +((+g[d >> 2] + +g[ra >> 2]) * .5);
na = +((+g[la >> 2] + +g[ka >> 2]) * .5);
f = d;
g[f >> 2] = pa;
g[f + 4 >> 2] = na;
f = ra;
g[f >> 2] = pa;
g[f + 4 >> 2] = na;
g[I >> 2] = 0;
i = h;
return
}
g[I >> 2] = ma - oa;
oa = +g[ra >> 2];
ma = +g[d >> 2];
na = oa - ma;
pa = +g[ka >> 2];
_ = +g[la >> 2];
Z = pa - _;
w = +Q(+(na * na + Z * Z));
if (w < 1.1920928955078125E-7) {
va = na;
wa = Z
} else {
z = 1 / w;
va = na * z;
wa = Z * z
}
g[d >> 2] = ta * va + ma;
g[la >> 2] = ta * wa + _;
g[ra >> 2] = oa - x * va;
g[ka >> 2] = pa - x * wa;
i = h;
return
}
function ee(a, e, f, h, j, k) {
a = a | 0;
e = e | 0;
f = f | 0;
h = h | 0;
j = j | 0;
k = k | 0;
var l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0;
l = i;
m = b[e + 4 >> 1] | 0;
n = m & 65535;
o = a + 108 | 0;
c[o >> 2] = n;
if (m << 16 >> 16 == 0)
p = n;
else {
n = f + 16 | 0;
m = j + 16 | 0;
q = h + 12 | 0;
r = h + 8 | 0;
s = h + 4 | 0;
t = k + 12 | 0;
u = k + 8 | 0;
v = k + 4 | 0;
w = 0;
do {
x = d[e + w + 6 >> 0] | 0;
c[a + (w * 36 | 0) + 28 >> 2] = x;
y = d[e + w + 9 >> 0] | 0;
c[a + (w * 36 | 0) + 32 >> 2] = y;
z = (c[n >> 2] | 0) + (x << 3) | 0;
A = +g[z >> 2];
B = +g[z + 4 >> 2];
z = (c[m >> 2] | 0) + (y << 3) | 0;
C = +g[z >> 2];
D = +g[z + 4 >> 2];
E = +g[q >>
2];
F = +g[r >> 2];
G = +g[h >> 2] + (A * E - B * F);
H = +G;
I = +(E * B + A * F + +g[s >> 2]);
z = a + (w * 36 | 0) | 0;
g[z >> 2] = H;
g[z + 4 >> 2] = I;
I = +g[t >> 2];
H = +g[u >> 2];
F = +g[k >> 2] + (C * I - D * H);
A = +F;
B = +(D * I + C * H + +g[v >> 2]);
z = a + (w * 36 | 0) + 8 | 0;
g[z >> 2] = A;
g[z + 4 >> 2] = B;
B = +(F - G);
G = +(+g[a + (w * 36 | 0) + 12 >> 2] - +g[a + (w * 36 | 0) + 4 >> 2]);
z = a + (w * 36 | 0) + 16 | 0;
g[z >> 2] = B;
g[z + 4 >> 2] = G;
g[a + (w * 36 | 0) + 24 >> 2] = 0;
w = w + 1 | 0;
z = c[o >> 2] | 0
} while ((w | 0) < (z | 0));
p = z
}
do if ((p | 0) > 1) {
G = +g[e >> 2];
if ((p | 0) == 2) {
B = +g[a + 16 >> 2] - +g[a + 52 >> 2];
F = +g[a + 20 >> 2] - +g[a + 56 >> 2];
J = +Q(+(B * B + F * F))
} else if ((p | 0) == 3) {
F = +g[a +
16 >> 2];
B = +g[a + 20 >> 2];
J = (+g[a + 52 >> 2] - F) * (+g[a + 92 >> 2] - B) - (+g[a + 56 >> 2] - B) * (+g[a + 88 >> 2] - F)
} else
J = 0;
if (!(J < G * .5) ? !(G * 2 < J | J < 1.1920928955078125E-7) : 0) {
K = 11;
break
}
c[o >> 2] = 0
} else
K = 11;
while (0);
if ((K | 0) == 11 ? (p | 0) != 0 : 0) {
i = l;
return
}
c[a + 28 >> 2] = 0;
c[a + 32 >> 2] = 0;
p = c[f + 16 >> 2] | 0;
J = +g[p >> 2];
G = +g[p + 4 >> 2];
p = c[j + 16 >> 2] | 0;
F = +g[p >> 2];
B = +g[p + 4 >> 2];
A = +g[h + 12 >> 2];
H = +g[h + 8 >> 2];
C = +g[h >> 2] + (J * A - G * H);
I = A * G + J * H + +g[h + 4 >> 2];
H = +C;
J = +I;
h = a;
g[h >> 2] = H;
g[h + 4 >> 2] = J;
J = +g[k + 12 >> 2];
H = +g[k + 8 >> 2];
G = +g[k >> 2] + (F * J - B * H);
A = B * J + F * H + +g[k + 4 >> 2];
H = +G;
F = +A;
k = a + 8 | 0;
g[k >> 2] = H;
g[k + 4 >> 2] = F;
F = +(G - C);
C = +(A - I);
k = a + 16 | 0;
g[k >> 2] = F;
g[k + 4 >> 2] = C;
g[a + 24 >> 2] = 1;
c[o >> 2] = 1;
i = l;
return
}
function fe(a, d) {
a = a | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0;
e = i;
f = Em(d, 48) | 0;
if ((f | 0) == 0)
h = 0;
else {
c[f >> 2] = 488;
c[f + 4 >> 2] = 1;
g[f + 8 >> 2] = .009999999776482582;
d = f + 28 | 0;
c[d + 0 >> 2] = 0;
c[d + 4 >> 2] = 0;
c[d + 8 >> 2] = 0;
c[d + 12 >> 2] = 0;
b[d + 16 >> 1] = 0;
h = f
}
f = a + 4 | 0;
d = c[f + 4 >> 2] | 0;
j = h + 4 | 0;
c[j >> 2] = c[f >> 2];
c[j + 4 >> 2] = d;
d = h + 12 | 0;
j = a + 12 | 0;
c[d + 0 >> 2] = c[j + 0 >> 2];
c[d + 4 >> 2] = c[j + 4 >> 2];
c[d + 8 >> 2] = c[j + 8 >> 2];
c[d + 12 >> 2] = c[j + 12 >> 2];
c[d +
16 >> 2] = c[j + 16 >> 2];
c[d + 20 >> 2] = c[j + 20 >> 2];
c[d + 24 >> 2] = c[j + 24 >> 2];
c[d + 28 >> 2] = c[j + 28 >> 2];
b[d + 32 >> 1] = b[j + 32 >> 1] | 0;
i = e;
return h | 0
}
function ge(a) {
a = a | 0;
return 1
}
function he(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
return 0
}
function ie(a, b, c, d, e, f) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0;
f = i;
h = +g[b + 12 >> 2];
j = +g[a + 12 >> 2];
k = +g[b + 8 >> 2];
l = +g[a + 16 >> 2];
m = +g[b >> 2];
n = m + (h * j - k * l);
o = +g[b + 4 >> 2];
p = j * k + h * l + o;
l = +g[a + 20 >> 2];
j = +g[a + 24 >> 2];
q = m + (h * l - k * j);
m =
o + (k * l + h * j);
j = +g[c >> 2];
h = j - n;
l = +g[c + 4 >> 2];
k = l - p;
o = q - n;
n = m - p;
p = h * o + k * n;
do if (p > 0) {
r = o * o + n * n;
if (p > r) {
s = j - q;
t = l - m;
break
} else {
u = p / r;
s = h - o * u;
t = k - n * u;
break
}
} else {
s = h;
t = k
}
while (0);
k = +Q(+(t * t + s * s));
g[d >> 2] = k;
if (k > 0) {
h = 1 / k;
v = s * h;
w = t * h;
x = +v;
y = +w;
z = e;
A = z;
g[A >> 2] = x;
B = z + 4 | 0;
C = B;
g[C >> 2] = y;
i = f;
return
} else {
d = 8784;
h = +g[d >> 2];
v = h;
w = +g[d + 4 >> 2];
x = +v;
y = +w;
z = e;
A = z;
g[A >> 2] = x;
B = z + 4 | 0;
C = B;
g[C >> 2] = y;
i = f;
return
}
}
function je(a, b, c, d, e) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0;
e = i;
f = +g[d >> 2];
h = +g[c >> 2] - f;
j = +g[d + 4 >> 2];
k = +g[c + 4 >> 2] - j;
l = d + 12 | 0;
m = +g[l >> 2];
n = d + 8 | 0;
o = +g[n >> 2];
p = h * m + k * o;
q = m * k - h * o;
h = +g[c + 8 >> 2] - f;
f = +g[c + 12 >> 2] - j;
j = m * h + o * f - p;
k = m * f - o * h - q;
d = a + 12 | 0;
h = +g[d >> 2];
o = +g[d + 4 >> 2];
d = a + 20 | 0;
f = +g[d >> 2];
m = f - h;
f = +g[d + 4 >> 2] - o;
r = -m;
s = m * m + f * f;
t = +Q(+s);
if (t < 1.1920928955078125E-7) {
u = f;
v = r
} else {
w = 1 / t;
u = f * w;
v = w * r
}
r = (o - q) * v + (h - p) * u;
w = k * v + j * u;
if (w == 0) {
x = 0;
i = e;
return x | 0
}
t = r / w;
if (t < 0) {
x = 0;
i = e;
return x | 0
}
if (s == 0 ? 1 : +g[c + 16 >> 2] < t) {
x = 0;
i = e;
return x | 0
}
w = (m * (p + j * t - h) + f * (q + k * t - o)) / s;
if (w < 0 | w > 1) {
x = 0;
i = e;
return x | 0
}
g[b + 8 >> 2] = t;
t = +g[l >> 2];
w = +g[n >> 2];
s = u * t - v * w;
o = v * t + u * w;
if (r > 0) {
r = +-s;
w = +-o;
n = b;
g[n >> 2] = r;
g[n + 4 >> 2] = w;
x = 1;
i = e;
return x | 0
} else {
w = +s;
s = +o;
n = b;
g[n >> 2] = w;
g[n + 4 >> 2] = s;
x = 1;
i = e;
return x | 0
}
return 0
}
function ke(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0;
d = i;
e = +g[c + 12 >> 2];
f = +g[a + 12 >> 2];
h = +g[c + 8 >> 2];
j = +g[a + 16 >> 2];
k = +g[c >> 2];
l = k + (e * f - h * j);
m = +g[c + 4 >> 2];
n = f * h + e * j + m;
j = +g[a + 20 >> 2];
f = +g[a + 24 >> 2];
o = k + (e * j - h * f);
k = m + (h * j + e * f);
f = +g[a + 8 >> 2];
e = +((l < o ? l : o) - f);
j =
+((n < k ? n : k) - f);
a = b;
g[a >> 2] = e;
g[a + 4 >> 2] = j;
j = +(f + (l > o ? l : o));
o = +(f + (n > k ? n : k));
a = b + 8 | 0;
g[a >> 2] = j;
g[a + 4 >> 2] = o;
i = d;
return
}
function le(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
var d = 0,
e = 0;
d = i;
g[b >> 2] = 0;
c = +((+g[a + 12 >> 2] + +g[a + 20 >> 2]) * .5);
e = +((+g[a + 16 >> 2] + +g[a + 24 >> 2]) * .5);
a = b + 4 | 0;
g[a >> 2] = c;
g[a + 4 >> 2] = e;
g[b + 12 >> 2] = 0;
i = d;
return
}
function me(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0;
d = i;
e = Em(b, 152) | 0;
if ((e | 0) == 0)
f = 0;
else {
c[e >> 2] = 592;
c[e + 4 >> 2] = 2;
g[e + 8 >> 2] = .009999999776482582;
c[e + 148 >> 2] = 0;
g[e + 12 >> 2] = 0;
g[e + 16 >> 2] = 0;
f = e
}
e = a + 4 | 0;
b = c[e +
4 >> 2] | 0;
h = f + 4 | 0;
c[h >> 2] = c[e >> 2];
c[h + 4 >> 2] = b;
An(f + 12 | 0, a + 12 | 0, 140) | 0;
i = d;
return f | 0
}
function ne(a) {
a = a | 0;
return 1
}
function oe(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0;
e = i;
i = i + 96 | 0;
f = e + 32 | 0;
h = e;
if ((d | 0) < 3) {
c[a + 148 >> 2] = 4;
g[a + 20 >> 2] = -1;
g[a + 24 >> 2] = -1;
g[a + 28 >> 2] = 1;
g[a + 32 >> 2] = -1;
g[a + 36 >> 2] = 1;
g[a + 40 >> 2] = 1;
g[a + 44 >> 2] = -1;
g[a + 48 >> 2] = 1;
g[a + 84 >> 2] = 0;
g[a + 88 >> 2] = -1;
g[a + 92 >> 2] = 1;
g[a + 96 >> 2] = 0;
g[a + 100 >> 2] = 0;
g[a +
104 >> 2] = 1;
g[a + 108 >> 2] = -1;
g[a + 112 >> 2] = 0;
g[a + 12 >> 2] = 0;
g[a + 16 >> 2] = 0;
i = e;
return
}
j = (d | 0) < 8 ? d : 8;
d = 0;
l = 0;
while (1) {
m = b + (d << 3) | 0;
n = c[m >> 2] | 0;
o = c[m + 4 >> 2] | 0;
p = (c[k >> 2] = n, +g[k >> 2]);
q = (c[k >> 2] = o, +g[k >> 2]);
a:
do if ((l | 0) > 0) {
m = 0;
while (1) {
r = p - +g[f + (m << 3) >> 2];
s = q - +g[f + (m << 3) + 4 >> 2];
m = m + 1 | 0;
if (r * r + s * s < .0024999999441206455) {
t = l;
break a
}
if ((m | 0) >= (l | 0)) {
u = 7;
break
}
}
} else
u = 7;
while (0);
if ((u | 0) == 7) {
u = 0;
m = f + (l << 3) | 0;
c[m >> 2] = n;
c[m + 4 >> 2] = o;
t = l + 1 | 0
}
d = d + 1 | 0;
if ((d | 0) == (j | 0))
break;
else
l = t
}
if ((t | 0) < 3) {
c[a + 148 >> 2] = 4;
g[a + 20 >> 2] = -1;
g[a + 24 >> 2] = -1;
g[a + 28 >> 2] = 1;
g[a + 32 >> 2] = -1;
g[a + 36 >> 2] = 1;
g[a + 40 >> 2] = 1;
g[a + 44 >> 2] = -1;
g[a + 48 >> 2] = 1;
g[a + 84 >> 2] = 0;
g[a + 88 >> 2] = -1;
g[a + 92 >> 2] = 1;
g[a + 96 >> 2] = 0;
g[a + 100 >> 2] = 0;
g[a + 104 >> 2] = 1;
g[a + 108 >> 2] = -1;
g[a + 112 >> 2] = 0;
g[a + 12 >> 2] = 0;
g[a + 16 >> 2] = 0;
i = e;
return
}
l = 0;
j = 1;
q = +g[f >> 2];
while (1) {
p = +g[f + (j << 3) >> 2];
if (!(p > q))
if (p == q ? +g[f + (j << 3) + 4 >> 2] < +g[f + (l << 3) + 4 >> 2] : 0)
u = 22;
else {
v = l;
w = q
}
else
u = 22;
if ((u | 0) == 22) {
u = 0;
v = j;
w = p
}
j = j + 1 | 0;
if ((j | 0) == (t | 0)) {
x = v;
y = 0;
break
} else {
l = v;
q = w
}
}
while (1) {
c[h + (y << 2) >> 2] = x;
l = 0;
j = 1;
while (1) {
if ((l | 0) !=
(x | 0)) {
w = +g[f + (x << 3) >> 2];
q = +g[f + (l << 3) >> 2] - w;
p = +g[f + (x << 3) + 4 >> 2];
s = +g[f + (l << 3) + 4 >> 2] - p;
r = +g[f + (j << 3) >> 2] - w;
w = +g[f + (j << 3) + 4 >> 2] - p;
p = q * w - s * r;
u = p < 0 ? j : l;
if (p == 0 ? r * r + w * w > q * q + s * s : 0)
z = j;
else
z = u
} else
z = j;
j = j + 1 | 0;
if ((j | 0) == (t | 0))
break;
else
l = z
}
A = y + 1 | 0;
if ((z | 0) == (v | 0))
break;
else {
x = z;
y = A
}
}
c[a + 148 >> 2] = A;
z = (y | 0) > -1;
if (z) {
x = 0;
do {
v = f + (c[h + (x << 2) >> 2] << 3) | 0;
t = c[v + 4 >> 2] | 0;
l = a + (x << 3) + 20 | 0;
c[l >> 2] = c[v >> 2];
c[l + 4 >> 2] = t;
x = x + 1 | 0
} while ((x | 0) != (A | 0));
if (z) {
z = 0;
do {
x = z;
z = z + 1 | 0;
h = (z | 0) < (A | 0) ? z : 0;
s = +g[a + (h << 3) + 24 >> 2] - +g[a + (x <<
3) + 24 >> 2];
f = a + (x << 3) + 84 | 0;
q = +s;
w = +-(+g[a + (h << 3) + 20 >> 2] - +g[a + (x << 3) + 20 >> 2]);
h = f;
g[h >> 2] = q;
g[h + 4 >> 2] = w;
h = a + (x << 3) + 88 | 0;
w = +g[h >> 2];
q = +Q(+(s * s + w * w));
if (!(q < 1.1920928955078125E-7)) {
r = 1 / q;
g[f >> 2] = s * r;
g[h >> 2] = w * r
}
} while ((z | 0) != (A | 0))
}
}
z = a + 12 | 0;
h = a + 20 | 0;
if ((y | 0) > -1) {
r = 0;
w = 0;
s = 0;
y = 0;
while (1) {
f = a + (y << 3) + 20 | 0;
q = +g[f >> 2];
p = +g[f + 4 >> 2];
y = y + 1 | 0;
if ((y | 0) < (A | 0))
B = a + (y << 3) + 20 | 0;
else
B = h;
f = B;
C = +g[f >> 2];
D = +g[f + 4 >> 2];
E = (q * D - p * C) * .5;
F = s + E;
G = E * .3333333432674408;
E = r + (q + 0 + C) * G;
C = w + (p + 0 + D) * G;
if ((y | 0) == (A | 0)) {
H = E;
I = C;
J = F;
break
} else {
r =
E;
w = C;
s = F
}
}
} else {
H = 0;
I = 0;
J = 0
}
s = 1 / J;
J = +(H * s);
H = +(I * s);
A = z;
g[A >> 2] = J;
g[A + 4 >> 2] = H;
i = e;
return
}
function pe(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
e = i;
f = +g[d >> 2] - +g[b >> 2];
h = +g[d + 4 >> 2] - +g[b + 4 >> 2];
j = +g[b + 12 >> 2];
k = +g[b + 8 >> 2];
l = f * j + h * k;
m = j * h - f * k;
b = c[a + 148 >> 2] | 0;
if ((b | 0) > 0)
n = 0;
else {
o = 1;
i = e;
return o | 0
}
while (1) {
if ((l - +g[a + (n << 3) + 20 >> 2]) * +g[a + (n << 3) + 84 >> 2] + (m - +g[a + (n << 3) + 24 >> 2]) * +g[a + (n << 3) + 88 >> 2] > 0) {
o = 0;
p = 4;
break
}
n = n + 1 | 0;
if ((n | 0) >= (b | 0)) {
o = 1;
p = 4;
break
}
}
if ((p | 0) == 4) {
i = e;
return o | 0
}
return 0
}
function qe(a, b, d, e, f, h) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
h = h | 0;
var j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0;
h = i;
j = +g[d >> 2] - +g[b >> 2];
k = +g[d + 4 >> 2] - +g[b + 4 >> 2];
d = b + 12 | 0;
l = +g[d >> 2];
m = b + 8 | 0;
n = +g[m >> 2];
o = j * l + k * n;
p = l * k - j * n;
b = c[a + 148 >> 2] | 0;
q = (b | 0) > 0;
if (q) {
n = o;
j = p;
r = 0;
k = -3.4028234663852886E38;
while (1) {
s = a + (r << 3) + 84 | 0;
l = (o - +g[a + (r << 3) + 20 >> 2]) * +g[s >> 2] + (p - +g[a + (r << 3) + 24 >> 2]) * +g[a + (r << 3) + 88 >> 2];
if (l > k) {
t = s;
u = +g[t >> 2];
v = +g[t + 4 >> 2];
w = u;
x = l
} else {
v = j;
w = n;
x = k
}
r =
r + 1 | 0;
if ((r | 0) >= (b | 0))
break;
else {
n = w;
j = v;
k = x
}
}
if (x > 0) {
k = x * x;
if (q) {
j = v;
n = w;
q = 0;
l = k;
while (1) {
u = o - +g[a + (q << 3) + 20 >> 2];
y = p - +g[a + (q << 3) + 24 >> 2];
z = u * u + y * y;
r = l > z;
A = r ? y : j;
y = r ? u : n;
u = r ? z : l;
q = q + 1 | 0;
if ((q | 0) >= (b | 0)) {
B = A;
C = y;
D = u;
break
} else {
j = A;
n = y;
l = u
}
}
} else {
B = v;
C = w;
D = k
}
g[e >> 2] = +Q(+D);
D = +g[d >> 2];
k = +g[m >> 2];
l = C * D - B * k;
n = B * D + C * k;
k = +l;
C = +n;
b = f;
g[b >> 2] = k;
g[b + 4 >> 2] = C;
C = +Q(+(l * l + n * n));
if (C < 1.1920928955078125E-7) {
i = h;
return
}
k = 1 / C;
g[f >> 2] = l * k;
g[f + 4 >> 2] = n * k;
i = h;
return
} else {
E = v;
F = w;
G = x
}
} else {
E = p;
F = o;
G = -3.4028234663852886E38
}
g[e >>
2] = G;
G = +g[d >> 2];
o = +g[m >> 2];
p = +(F * G - E * o);
x = +(E * G + F * o);
m = f;
g[m >> 2] = p;
g[m + 4 >> 2] = x;
i = h;
return
}
function re(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0;
f = i;
h = +g[e >> 2];
j = +g[d >> 2] - h;
k = +g[e + 4 >> 2];
l = +g[d + 4 >> 2] - k;
m = e + 12 | 0;
n = +g[m >> 2];
o = e + 8 | 0;
p = +g[o >> 2];
q = j * n + l * p;
r = n * l - j * p;
j = +g[d + 8 >> 2] - h;
h = +g[d + 12 >> 2] - k;
k = n * j + p * h - q;
l = n * h - p * j - r;
e = c[a + 148 >> 2] | 0;
if ((e | 0) <= 0) {
s = 0;
i = f;
return s | 0
}
t = 0;
u = -1;
j = 0;
p = +g[d + 16 >> 2];
a:
while (1) {
h = +g[a + (t << 3) + 84 >> 2];
n =
+g[a + (t << 3) + 88 >> 2];
v = (+g[a + (t << 3) + 20 >> 2] - q) * h + (+g[a + (t << 3) + 24 >> 2] - r) * n;
w = k * h + l * n;
do if (w == 0)
if (v < 0) {
s = 0;
x = 15;
break a
} else {
y = u;
z = j;
A = p
}
else {
if (w < 0 ? v < j * w : 0) {
y = t;
z = v / w;
A = p;
break
}
if (w > 0 ? v < p * w : 0) {
y = u;
z = j;
A = v / w
} else {
y = u;
z = j;
A = p
}
}
while (0);
t = t + 1 | 0;
if (A < z) {
s = 0;
x = 15;
break
}
if ((t | 0) >= (e | 0)) {
x = 13;
break
} else {
u = y;
j = z;
p = A
}
}
if ((x | 0) == 13) {
if (!((y | 0) > -1)) {
s = 0;
i = f;
return s | 0
}
g[b + 8 >> 2] = z;
z = +g[m >> 2];
A = +g[a + (y << 3) + 84 >> 2];
p = +g[o >> 2];
j = +g[a + (y << 3) + 88 >> 2];
l = +(z * A - p * j);
k = +(A * p + z * j);
y = b;
g[y >> 2] = l;
g[y + 4 >> 2] = k;
s = 1;
i = f;
return s |
0
} else if ((x | 0) == 15) {
i = f;
return s | 0
}
return 0
}
function se(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0;
e = i;
f = +g[d + 12 >> 2];
h = +g[a + 20 >> 2];
j = +g[d + 8 >> 2];
k = +g[a + 24 >> 2];
l = +g[d >> 2];
m = l + (f * h - j * k);
n = +g[d + 4 >> 2];
o = h * j + f * k + n;
d = c[a + 148 >> 2] | 0;
if ((d | 0) > 1) {
k = m;
h = o;
p = m;
q = o;
r = 1;
while (1) {
s = +g[a + (r << 3) + 20 >> 2];
t = +g[a + (r << 3) + 24 >> 2];
u = l + (f * s - j * t);
v = s * j + f * t + n;
t = k < u ? k : u;
s = h < v ? h : v;
w = p > u ? p : u;
u = q > v ? q : v;
r = r + 1 | 0;
if ((r | 0) >= (d | 0)) {
x = s;
y = t;
z = u;
A = w;
break
} else {
k =
t;
h = s;
p = w;
q = u
}
}
} else {
x = o;
y = m;
z = o;
A = m
}
m = +g[a + 8 >> 2];
o = +(y - m);
y = +(x - m);
a = b;
g[a >> 2] = o;
g[a + 4 >> 2] = y;
y = +(A + m);
A = +(z + m);
a = b + 8 | 0;
g[a >> 2] = y;
g[a + 4 >> 2] = A;
i = e;
return
}
function te(a, b, d) {
a = a | 0;
b = b | 0;
d = +d;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0;
e = i;
f = c[a + 148 >> 2] | 0;
h = (f | 0) > 0;
if (h) {
j = 0;
k = 0;
l = 0;
do {
j = j + +g[a + (l << 3) + 20 >> 2];
k = k + +g[a + (l << 3) + 24 >> 2];
l = l + 1 | 0
} while ((l | 0) < (f | 0));
m = 1 / +(f | 0);
n = j * m;
j = k * m;
if (h) {
h = a + 20 | 0;
l = a + 24 | 0;
m = 0;
k = 0;
o = 0;
p = 0;
q = 0;
while (1) {
r = +g[a + (q << 3) + 20 >> 2] - n;
s = +g[a + (q << 3) + 24 >> 2] - j;
q = q + 1 | 0;
t = (q | 0) < (f | 0);
if (t) {
u = a + (q << 3) + 20 | 0;
v = a + (q << 3) + 24 | 0
} else {
u = h;
v = l
}
w = +g[u >> 2] - n;
x = +g[v >> 2] - j;
y = r * x - s * w;
z = y * .5;
A = p + z;
B = z * .3333333432674408;
z = m + (r + w) * B;
C = k + (s + x) * B;
B = o + y * .0833333358168602 * (w * w + (r * r + r * w) + (x * x + (s * s + s * x)));
if (!t) {
D = C;
E = z;
F = n;
G = j;
H = B;
I = A;
break
} else {
m = z;
k = C;
o = B;
p = A
}
}
} else {
D = 0;
E = 0;
F = n;
G = j;
H = 0;
I = 0
}
} else {
j = 1 / +(f | 0);
D = 0;
E = 0;
F = j * 0;
G = j * 0;
H = 0;
I = 0
}
j = I * d;
g[b >> 2] = j;
n = 1 / I;
I = E * n;
E = D * n;
n = F + I;
F = G + E;
G = +n;
D = +F;
f = b + 4 | 0;
g[f >> 2] = G;
g[f + 4 >> 2] = D;
g[b +
12 >> 2] = H * d + j * (n * n + F * F - (I * I + E * E));
i = e;
return
}
function ue(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0;
d = i;
e = Em(b, 20) | 0;
if ((e | 0) == 0)
f = 0;
else {
c[e >> 2] = 680;
b = e + 4 | 0;
c[b + 0 >> 2] = 0;
c[b + 4 >> 2] = 0;
c[b + 8 >> 2] = 0;
c[b + 12 >> 2] = 0;
f = e
}
e = a + 4 | 0;
b = c[e + 4 >> 2] | 0;
g = f + 4 | 0;
c[g >> 2] = c[e >> 2];
c[g + 4 >> 2] = b;
b = a + 12 | 0;
a = c[b + 4 >> 2] | 0;
g = f + 12 | 0;
c[g >> 2] = c[b >> 2];
c[g + 4 >> 2] = a;
i = d;
return f | 0
}
function ve(a) {
a = a | 0;
return 1
}
function we(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = +g[b + 12 >> 2];
e = +g[a + 12 >> 2];
f = +g[b + 8 >> 2];
h = +g[a + 16 >> 2];
i = +g[c >> 2] - (+g[b >>
2] + (d * e - f * h));
j = +g[c + 4 >> 2] - (+g[b + 4 >> 2] + (e * f + d * h));
h = +g[a + 8 >> 2];
return i * i + j * j <= h * h | 0
}
function xe(a, b, c, d, e, f) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0;
f = i;
h = +g[b + 12 >> 2];
j = +g[a + 12 >> 2];
k = +g[b + 8 >> 2];
l = +g[a + 16 >> 2];
m = +g[c >> 2] - (+g[b >> 2] + (h * j - k * l));
n = +g[c + 4 >> 2] - (+g[b + 4 >> 2] + (j * k + h * l));
l = +Q(+(m * m + n * n));
g[d >> 2] = l - +g[a + 8 >> 2];
h = 1 / l;
l = +(m * h);
m = +(n * h);
a = e;
g[a >> 2] = l;
g[a + 4 >> 2] = m;
i = f;
return
}
function ye(a, b, c, d, e) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
e = i;
f = +g[d +
12 >> 2];
h = +g[a + 12 >> 2];
j = +g[d + 8 >> 2];
k = +g[a + 16 >> 2];
l = +g[c >> 2];
m = l - (+g[d >> 2] + (f * h - j * k));
n = +g[c + 4 >> 2];
o = n - (+g[d + 4 >> 2] + (h * j + f * k));
k = +g[a + 8 >> 2];
f = +g[c + 8 >> 2] - l;
l = +g[c + 12 >> 2] - n;
n = m * f + o * l;
j = f * f + l * l;
h = n * n - (m * m + o * o - k * k) * j;
if (h < 0 | j < 1.1920928955078125E-7) {
p = 0;
i = e;
return p | 0
}
k = n + +Q(+h);
h = -k;
if (!(k <= -0)) {
p = 0;
i = e;
return p | 0
}
if (!(j * +g[c + 16 >> 2] >= h)) {
p = 0;
i = e;
return p | 0
}
k = h / j;
g[b + 8 >> 2] = k;
j = m + f * k;
f = o + l * k;
k = +j;
l = +f;
c = b;
g[c >> 2] = k;
g[c + 4 >> 2] = l;
l = +Q(+(j * j + f * f));
if (l < 1.1920928955078125E-7) {
p = 1;
i = e;
return p | 0
}
k = 1 / l;
g[b >> 2] =
j * k;
g[b + 4 >> 2] = f * k;
p = 1;
i = e;
return p | 0
}
function ze(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
i = 0,
j = 0,
k = 0;
e = +g[c + 12 >> 2];
f = +g[a + 12 >> 2];
h = +g[c + 8 >> 2];
i = +g[a + 16 >> 2];
j = +g[c >> 2] + (e * f - h * i);
k = +g[c + 4 >> 2] + (f * h + e * i);
c = a + 8 | 0;
i = +g[c >> 2];
g[b >> 2] = j - i;
g[b + 4 >> 2] = k - i;
i = +g[c >> 2];
g[b + 8 >> 2] = j + i;
g[b + 12 >> 2] = k + i;
return
}
function Ae(a, b, d) {
a = a | 0;
b = b | 0;
d = +d;
var e = 0,
f = 0,
h = 0,
i = 0,
j = 0,
k = 0,
l = 0,
m = 0;
e = a + 8 | 0;
f = +g[e >> 2];
h = f * d * 3.1415927410125732 * f;
g[b >> 2] = h;
i = a + 12 | 0;
j = i;
k = c[j + 4 >> 2] | 0;
l = b + 4 | 0;
c[l >> 2] = c[j >> 2];
c[l + 4 >> 2] = k;
f = +g[e >> 2];
d = +g[i >> 2];
m = +g[a + 16 >> 2];
g[b + 12 >> 2] = h * (f * f * .5 + (d * d + m * m));
return
}
function Be(a) {
a = a | 0;
var b = 0;
b = i;
c[a >> 2] = 760;
Qm(c[a + 12 >> 2] | 0);
sn(a);
i = b;
return
}
function Ce(a) {
a = a | 0;
var b = 0,
d = 0;
b = i;
c[a >> 2] = 760;
d = a + 12 | 0;
Qm(c[d >> 2] | 0);
c[d >> 2] = 0;
c[a + 16 >> 2] = 0;
i = b;
return
}
function De(a, d, e) {
a = a | 0;
d = d | 0;
e = e | 0;
var f = 0,
g = 0,
h = 0;
f = i;
g = a + 16 | 0;
c[g >> 2] = e;
h = Pm(e << 3) | 0;
c[a + 12 >> 2] = h;
An(h | 0, d | 0, c[g >> 2] << 3 | 0) | 0;
g = a + 20 | 0;
c[g + 0 >> 2] = 0;
c[g + 4 >> 2] = 0;
c[g + 8 >> 2] = 0;
c[g + 12 >> 2] = 0;
b[g + 16 >> 1] = 0;
i = f;
return
}
function Ee(d, e) {
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0;
f = i;
h = Em(e, 40) | 0;
if ((h | 0) == 0)
j = 0;
else {
c[h >> 2] = 760;
c[h + 4 >> 2] = 3;
g[h + 8 >> 2] = .009999999776482582;
c[h + 12 >> 2] = 0;
c[h + 16 >> 2] = 0;
a[h + 36 >> 0] = 0;
a[h + 37 >> 0] = 0;
j = h
}
h = c[d + 12 >> 2] | 0;
e = c[d + 16 >> 2] | 0;
k = j + 16 | 0;
c[k >> 2] = e;
l = Pm(e << 3) | 0;
c[j + 12 >> 2] = l;
An(l | 0, h | 0, c[k >> 2] << 3 | 0) | 0;
k = j + 20 | 0;
c[k + 0 >> 2] = 0;
c[k + 4 >> 2] = 0;
c[k + 8 >> 2] = 0;
c[k + 12 >> 2] = 0;
b[k + 16 >> 1] = 0;
k = d + 20 | 0;
h = c[k + 4 >> 2] | 0;
l = j + 20 | 0;
c[l >> 2] = c[k >> 2];
c[l + 4 >> 2] = h;
h = d + 28 | 0;
l = c[h + 4 >> 2] | 0;
k = j + 28 | 0;
c[k >> 2] = c[h >> 2];
c[k + 4 >> 2] = l;
a[j + 36 >> 0] = a[d + 36 >> 0] | 0;
a[j + 37 >> 0] = a[d + 37 >> 0] | 0;
i = f;
return j | 0
}
function Fe(a) {
a = a | 0;
return (c[a + 16 >> 2] | 0) + -1 | 0
}
function Ge(b, d, e) {
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0;
f = i;
c[d + 4 >> 2] = 1;
g[d + 8 >> 2] = +g[b + 8 >> 2];
h = b + 12 | 0;
j = (c[h >> 2] | 0) + (e << 3) | 0;
k = c[j + 4 >> 2] | 0;
l = d + 12 | 0;
c[l >> 2] = c[j >> 2];
c[l + 4 >> 2] = k;
k = (c[h >> 2] | 0) + (e + 1 << 3) | 0;
l = c[k + 4 >> 2] | 0;
j = d + 20 | 0;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = l;
l = d + 28 | 0;
if ((e | 0) > 0) {
j = (c[h >> 2] | 0) + (e + -1 << 3) | 0;
k = c[j + 4 >> 2] | 0;
m = l;
c[m >> 2] = c[j >> 2];
c[m + 4 >> 2] = k;
a[d + 44 >> 0] = 1
} else {
k = b + 20 | 0;
m = c[k + 4 >> 2] | 0;
j = l;
c[j >> 2] = c[k >> 2];
c[j + 4 >> 2] = m;
a[d + 44 >> 0] = a[b +
36 >> 0] | 0
}
m = d + 36 | 0;
if (((c[b + 16 >> 2] | 0) + -2 | 0) > (e | 0)) {
j = (c[h >> 2] | 0) + (e + 2 << 3) | 0;
e = c[j + 4 >> 2] | 0;
h = m;
c[h >> 2] = c[j >> 2];
c[h + 4 >> 2] = e;
a[d + 45 >> 0] = 1;
i = f;
return
} else {
e = b + 28 | 0;
h = c[e + 4 >> 2] | 0;
j = m;
c[j >> 2] = c[e >> 2];
c[j + 4 >> 2] = h;
a[d + 45 >> 0] = a[b + 37 >> 0] | 0;
i = f;
return
}
}
function He(d, e, f, h, j, k) {
d = d | 0;
e = e | 0;
f = f | 0;
h = h | 0;
j = j | 0;
k = k | 0;
var l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0;
l = i;
i = i + 48 | 0;
m = l;
c[m >> 2] = 488;
n = m + 4 | 0;
o = m + 8 | 0;
p = m + 28 | 0;
c[p + 0 >> 2] = 0;
c[p + 4 >> 2] = 0;
c[p + 8 >> 2] = 0;
c[p + 12 >> 2] = 0;
b[p + 16 >> 1] = 0;
c[n >> 2] = 1;
g[o >> 2] = +g[d + 8 >> 2];
o = c[d + 12 >> 2] | 0;
n = o + (k <<
3) | 0;
p = c[n + 4 >> 2] | 0;
q = m + 12 | 0;
c[q >> 2] = c[n >> 2];
c[q + 4 >> 2] = p;
p = o + (k + 1 << 3) | 0;
q = c[p + 4 >> 2] | 0;
n = m + 20 | 0;
c[n >> 2] = c[p >> 2];
c[n + 4 >> 2] = q;
q = m + 28 | 0;
if ((k | 0) > 0) {
n = o + (k + -1 << 3) | 0;
p = c[n + 4 >> 2] | 0;
r = q;
c[r >> 2] = c[n >> 2];
c[r + 4 >> 2] = p;
a[m + 44 >> 0] = 1
} else {
p = d + 20 | 0;
r = c[p + 4 >> 2] | 0;
n = q;
c[n >> 2] = c[p >> 2];
c[n + 4 >> 2] = r;
a[m + 44 >> 0] = a[d + 36 >> 0] | 0
}
r = m + 36 | 0;
if (((c[d + 16 >> 2] | 0) + -2 | 0) > (k | 0)) {
n = o + (k + 2 << 3) | 0;
k = c[n + 4 >> 2] | 0;
o = r;
c[o >> 2] = c[n >> 2];
c[o + 4 >> 2] = k;
a[m + 45 >> 0] = 1;
ie(m, e, f, h, j, 0);
i = l;
return
} else {
k = d + 28 | 0;
o = c[k + 4 >> 2] | 0;
n = r;
c[n >> 2] = c[k >> 2];
c[n + 4 >> 2] =
o;
a[m + 45 >> 0] = a[d + 37 >> 0] | 0;
ie(m, e, f, h, j, 0);
i = l;
return
}
}
function Ie(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
return 0
}
function Je(a, d, e, f, h) {
a = a | 0;
d = d | 0;
e = e | 0;
f = f | 0;
h = h | 0;
var j = 0,
k = 0,
l = 0,
m = 0,
n = 0;
j = i;
i = i + 48 | 0;
k = j;
c[k >> 2] = 488;
c[k + 4 >> 2] = 1;
g[k + 8 >> 2] = .009999999776482582;
l = k + 28 | 0;
c[l + 0 >> 2] = 0;
c[l + 4 >> 2] = 0;
c[l + 8 >> 2] = 0;
c[l + 12 >> 2] = 0;
b[l + 16 >> 1] = 0;
l = h + 1 | 0;
m = (l | 0) == (c[a + 16 >> 2] | 0) ? 0 : l;
l = c[a + 12 >> 2] | 0;
a = l + (h << 3) | 0;
h = c[a + 4 >> 2] | 0;
n = k + 12 | 0;
c[n >> 2] = c[a >> 2];
c[n + 4 >> 2] = h;
h = l + (m << 3) | 0;
m = c[h + 4 >> 2] | 0;
l = k + 20 | 0;
c[l >> 2] = c[h >> 2];
c[l + 4 >> 2] = m;
m = je(k,
d, e, f, 0) | 0;
i = j;
return m | 0
}
function Ke(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0;
f = i;
h = e + 1 | 0;
j = (h | 0) == (c[a + 16 >> 2] | 0) ? 0 : h;
h = c[a + 12 >> 2] | 0;
k = +g[d + 12 >> 2];
l = +g[h + (e << 3) >> 2];
m = +g[d + 8 >> 2];
n = +g[h + (e << 3) + 4 >> 2];
o = +g[d >> 2];
p = o + (k * l - m * n);
q = +g[d + 4 >> 2];
r = l * m + k * n + q;
n = +g[h + (j << 3) >> 2];
l = +g[h + (j << 3) + 4 >> 2];
s = o + (k * n - m * l);
o = q + (m * n + k * l);
l = +(p < s ? p : s);
k = +(r < o ? r : o);
j = b;
g[j >> 2] = l;
g[j + 4 >> 2] = k;
k = +(p > s ? p : s);
s = +(r > o ? r : o);
j = b + 8 | 0;
g[j >> 2] = k;
g[j + 4 >> 2] = s;
i = f;
return
}
function Le(a, b, d) {
a = a |
0;
b = b | 0;
d = +d;
a = i;
c[b + 0 >> 2] = 0;
c[b + 4 >> 2] = 0;
c[b + 8 >> 2] = 0;
c[b + 12 >> 2] = 0;
i = a;
return
}
function Me(a) {
a = a | 0;
var b = 0;
b = i;
Ve(a);
c[a + 28 >> 2] = 0;
c[a + 48 >> 2] = 16;
c[a + 52 >> 2] = 0;
c[a + 44 >> 2] = Pm(128) | 0;
c[a + 36 >> 2] = 16;
c[a + 40 >> 2] = 0;
c[a + 32 >> 2] = Pm(64) | 0;
i = b;
return
}
function Ne(a) {
a = a | 0;
var b = 0;
b = i;
Qm(c[a + 32 >> 2] | 0);
Qm(c[a + 44 >> 2] | 0);
We(a);
i = b;
return
}
function Oe(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0;
e = i;
f = Ye(a, b, d) | 0;
d = a + 28 | 0;
c[d >> 2] = (c[d >> 2] | 0) + 1;
d = a + 40 | 0;
b = c[d >> 2] | 0;
g = a + 36 | 0;
h = a + 32 | 0;
if ((b | 0) == (c[g >> 2] | 0)) {
a = c[h >> 2] |
0;
c[g >> 2] = b << 1;
g = Pm(b << 3) | 0;
c[h >> 2] = g;
An(g | 0, a | 0, c[d >> 2] << 2 | 0) | 0;
Qm(a);
j = c[d >> 2] | 0
} else
j = b;
c[(c[h >> 2] | 0) + (j << 2) >> 2] = f;
c[d >> 2] = (c[d >> 2] | 0) + 1;
i = e;
return f | 0
}
function Pe(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0;
d = i;
e = a + 40 | 0;
f = c[e >> 2] | 0;
if ((f | 0) > 0) {
g = c[a + 32 >> 2] | 0;
h = f;
f = 0;
while (1) {
j = g + (f << 2) | 0;
if ((c[j >> 2] | 0) == (b | 0)) {
c[j >> 2] = -1;
k = c[e >> 2] | 0
} else
k = h;
f = f + 1 | 0;
if ((f | 0) >= (k | 0))
break;
else
h = k
}
}
k = a + 28 | 0;
c[k >> 2] = (c[k >> 2] | 0) + -1;
_e(a, b);
i = d;
return
}
function Qe(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
g = 0,
h = 0,
j = 0;
f = i;
if (!(af(a, b, d, e) | 0)) {
i = f;
return
}
e = a + 40 | 0;
d = c[e >> 2] | 0;
g = a + 36 | 0;
h = a + 32 | 0;
if ((d | 0) == (c[g >> 2] | 0)) {
a = c[h >> 2] | 0;
c[g >> 2] = d << 1;
g = Pm(d << 3) | 0;
c[h >> 2] = g;
An(g | 0, a | 0, c[e >> 2] << 2 | 0) | 0;
Qm(a);
j = c[e >> 2] | 0
} else
j = d;
c[(c[h >> 2] | 0) + (j << 2) >> 2] = b;
c[e >> 2] = (c[e >> 2] | 0) + 1;
i = f;
return
}
function Re(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0;
d = i;
e = a + 40 | 0;
f = c[e >> 2] | 0;
g = a + 36 | 0;
h = a + 32 | 0;
if ((f | 0) == (c[g >> 2] | 0)) {
a = c[h >> 2] | 0;
c[g >> 2] = f << 1;
g = Pm(f << 3) | 0;
c[h >> 2] = g;
An(g | 0, a | 0, c[e >> 2] << 2 | 0) | 0;
Qm(a);
j = c[e >> 2] | 0
} else
j = f;
c[(c[h >>
2] | 0) + (j << 2) >> 2] = b;
c[e >> 2] = (c[e >> 2] | 0) + 1;
i = d;
return
}
function Se(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0;
d = i;
e = a + 56 | 0;
f = c[e >> 2] | 0;
if ((f | 0) == (b | 0)) {
i = d;
return 1
}
g = a + 52 | 0;
h = c[g >> 2] | 0;
j = a + 48 | 0;
k = a + 44 | 0;
if ((h | 0) == (c[j >> 2] | 0)) {
a = c[k >> 2] | 0;
c[j >> 2] = h << 1;
j = Pm(h << 4) | 0;
c[k >> 2] = j;
An(j | 0, a | 0, c[g >> 2] << 3 | 0) | 0;
Qm(a);
l = c[e >> 2] | 0;
m = c[g >> 2] | 0
} else {
l = f;
m = h
}
h = c[k >> 2] | 0;
c[h + (m << 3) >> 2] = (l | 0) > (b | 0) ? b : l;
l = c[e >> 2] | 0;
c[h + (c[g >> 2] << 3) + 4 >> 2] = (l | 0) < (b | 0) ? b : l;
c[g >> 2] = (c[g >> 2] | 0) + 1;
i = d;
return 1
}
function Te(a, b,
d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0;
h = i;
j = a + 60 | 0;
c[j >> 2] = 0;
k = b + 12 | 0;
l = +g[d + 12 >> 2];
m = +g[k >> 2];
n = +g[d + 8 >> 2];
o = +g[b + 16 >> 2];
p = e + 12 | 0;
q = +g[f + 12 >> 2];
r = +g[p >> 2];
s = +g[f + 8 >> 2];
t = +g[e + 16 >> 2];
u = +g[f >> 2] + (q * r - s * t) - (+g[d >> 2] + (l * m - n * o));
v = r * s + q * t + +g[f + 4 >> 2] - (m * n + l * o + +g[d + 4 >> 2]);
o = +g[b + 8 >> 2] + +g[e + 8 >> 2];
if (u * u + v * v > o * o) {
i = h;
return
}
c[a + 56 >> 2] = 0;
e = k;
k = c[e + 4 >> 2] | 0;
b = a + 48 | 0;
c[b >> 2] = c[e >> 2];
c[b + 4 >> 2] = k;
g[a + 40 >> 2] = 0;
g[a + 44 >> 2] = 0;
c[j >> 2] = 1;
j = p;
p = c[j + 4 >> 2] | 0;
k = a;
c[k >> 2] = c[j >> 2];
c[k + 4 >> 2] = p;
c[a + 16 >> 2] = 0;
i = h;
return
}
function Ue(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0;
h = i;
j = a + 60 | 0;
c[j >> 2] = 0;
l = e + 12 | 0;
m = +g[f + 12 >> 2];
n = +g[l >> 2];
o = +g[f + 8 >> 2];
p = +g[e + 16 >> 2];
q = +g[f >> 2] + (m * n - o * p) - +g[d >> 2];
r = n * o + m * p + +g[f + 4 >> 2] - +g[d + 4 >> 2];
p = +g[d + 12 >> 2];
m = +g[d + 8 >> 2];
o = q * p + r * m;
n = p * r - q * m;
m = +g[b + 8 >> 2] + +g[e + 8 >> 2];
e = c[b + 148 >> 2] | 0;
do if ((e | 0) > 0) {
d = 0;
f = 0;
q = -3.4028234663852886E38;
while (1) {
r = (o -
+g[b + (d << 3) + 20 >> 2]) * +g[b + (d << 3) + 84 >> 2] + (n - +g[b + (d << 3) + 24 >> 2]) * +g[b + (d << 3) + 88 >> 2];
if (r > m) {
s = 19;
break
}
t = r > q;
q = t ? r : q;
f = t ? d : f;
d = d + 1 | 0;
if ((d | 0) >= (e | 0)) {
s = 4;
break
}
}
if ((s | 0) == 4) {
u = f;
v = q < 1.1920928955078125E-7;
break
} else if ((s | 0) == 19) {
i = h;
return
}
} else {
u = 0;
v = 1
}
while (0);
s = u + 1 | 0;
d = b + (u << 3) + 20 | 0;
t = c[d >> 2] | 0;
w = c[d + 4 >> 2] | 0;
r = (c[k >> 2] = t, +g[k >> 2]);
p = (c[k >> 2] = w, +g[k >> 2]);
d = b + (((s | 0) < (e | 0) ? s : 0) << 3) + 20 | 0;
s = c[d >> 2] | 0;
e = c[d + 4 >> 2] | 0;
x = (c[k >> 2] = s, +g[k >> 2]);
y = (c[k >> 2] = e, +g[k >> 2]);
if (v) {
c[j >> 2] = 1;
c[a + 56 >> 2] = 1;
v = b + (u << 3) + 84 |
0;
d = c[v + 4 >> 2] | 0;
z = a + 40 | 0;
c[z >> 2] = c[v >> 2];
c[z + 4 >> 2] = d;
A = +((r + x) * .5);
B = +((p + y) * .5);
d = a + 48 | 0;
g[d >> 2] = A;
g[d + 4 >> 2] = B;
d = l;
z = c[d + 4 >> 2] | 0;
v = a;
c[v >> 2] = c[d >> 2];
c[v + 4 >> 2] = z;
c[a + 16 >> 2] = 0;
i = h;
return
}
B = o - r;
A = n - p;
C = o - x;
D = n - y;
if (B * (x - r) + A * (y - p) <= 0) {
if (B * B + A * A > m * m) {
i = h;
return
}
c[j >> 2] = 1;
c[a + 56 >> 2] = 1;
z = a + 40 | 0;
E = +B;
F = +A;
v = z;
g[v >> 2] = E;
g[v + 4 >> 2] = F;
F = +Q(+(B * B + A * A));
if (!(F < 1.1920928955078125E-7)) {
E = 1 / F;
g[z >> 2] = B * E;
g[a + 44 >> 2] = A * E
}
z = a + 48 | 0;
c[z >> 2] = t;
c[z + 4 >> 2] = w;
w = l;
z = c[w + 4 >> 2] | 0;
t = a;
c[t >> 2] = c[w >> 2];
c[t + 4 >> 2] = z;
c[a + 16 >> 2] =
0;
i = h;
return
}
if (!(C * (r - x) + D * (p - y) <= 0)) {
E = (r + x) * .5;
x = (p + y) * .5;
z = b + (u << 3) + 84 | 0;
if ((o - E) * +g[z >> 2] + (n - x) * +g[b + (u << 3) + 88 >> 2] > m) {
i = h;
return
}
c[j >> 2] = 1;
c[a + 56 >> 2] = 1;
u = z;
z = c[u + 4 >> 2] | 0;
b = a + 40 | 0;
c[b >> 2] = c[u >> 2];
c[b + 4 >> 2] = z;
n = +E;
E = +x;
z = a + 48 | 0;
g[z >> 2] = n;
g[z + 4 >> 2] = E;
z = l;
b = c[z + 4 >> 2] | 0;
u = a;
c[u >> 2] = c[z >> 2];
c[u + 4 >> 2] = b;
c[a + 16 >> 2] = 0;
i = h;
return
}
if (C * C + D * D > m * m) {
i = h;
return
}
c[j >> 2] = 1;
c[a + 56 >> 2] = 1;
j = a + 40 | 0;
m = +C;
E = +D;
b = j;
g[b >> 2] = m;
g[b + 4 >> 2] = E;
E = +Q(+(C * C + D * D));
if (!(E < 1.1920928955078125E-7)) {
m = 1 / E;
g[j >> 2] = C * m;
g[a + 44 >> 2] = D *
m
}
j = a + 48 | 0;
c[j >> 2] = s;
c[j + 4 >> 2] = e;
e = l;
l = c[e + 4 >> 2] | 0;
j = a;
c[j >> 2] = c[e >> 2];
c[j + 4 >> 2] = l;
c[a + 16 >> 2] = 0;
i = h;
return
}
function Ve(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0;
b = i;
c[a >> 2] = -1;
d = a + 12 | 0;
c[d >> 2] = 16;
c[a + 8 >> 2] = 0;
e = Pm(576) | 0;
f = a + 4 | 0;
c[f >> 2] = e;
xn(e | 0, 0, (c[d >> 2] | 0) * 36 | 0) | 0;
e = (c[d >> 2] | 0) + -1 | 0;
g = c[f >> 2] | 0;
if ((e | 0) > 0) {
f = 0;
do {
h = f;
f = f + 1 | 0;
c[g + (h * 36 | 0) + 20 >> 2] = f;
c[g + (h * 36 | 0) + 32 >> 2] = -1;
h = (c[d >> 2] | 0) + -1 | 0
} while ((f | 0) < (h | 0));
j = h
} else
j = e;
c[g + (j * 36 | 0) + 20 >> 2] = -1;
c[g + (((c[d >> 2] | 0) + -1 | 0) * 36 | 0) + 32 >> 2] = -1;
c[a + 16 >> 2] = 0;
c[a +
20 >> 2] = 0;
c[a + 24 >> 2] = 0;
i = b;
return
}
function We(a) {
a = a | 0;
var b = 0;
b = i;
Qm(c[a + 4 >> 2] | 0);
i = b;
return
}
function Xe(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0;
b = i;
d = a + 16 | 0;
e = c[d >> 2] | 0;
f = a + 4 | 0;
g = c[f >> 2] | 0;
if ((e | 0) == -1) {
h = a + 12 | 0;
j = c[h >> 2] | 0;
c[h >> 2] = j << 1;
k = Pm(j * 72 | 0) | 0;
c[f >> 2] = k;
j = a + 8 | 0;
An(k | 0, g | 0, (c[j >> 2] | 0) * 36 | 0) | 0;
Qm(g);
k = c[j >> 2] | 0;
l = (c[h >> 2] | 0) + -1 | 0;
m = c[f >> 2] | 0;
if ((k | 0) < (l | 0)) {
f = k;
do {
k = f;
f = f + 1 | 0;
c[m + (k * 36 | 0) + 20 >> 2] = f;
c[m + (k * 36 | 0) + 32 >> 2] = -1;
k = (c[h >> 2] | 0) + -1 | 0
} while ((f | 0) < (k | 0));
n = k
} else
n =
l;
c[m + (n * 36 | 0) + 20 >> 2] = -1;
c[m + (((c[h >> 2] | 0) + -1 | 0) * 36 | 0) + 32 >> 2] = -1;
h = c[j >> 2] | 0;
c[d >> 2] = h;
o = j;
p = m;
q = h
} else {
o = a + 8 | 0;
p = g;
q = e
}
e = p + (q * 36 | 0) + 20 | 0;
c[d >> 2] = c[e >> 2];
c[e >> 2] = -1;
c[p + (q * 36 | 0) + 24 >> 2] = -1;
c[p + (q * 36 | 0) + 28 >> 2] = -1;
c[p + (q * 36 | 0) + 32 >> 2] = 0;
c[p + (q * 36 | 0) + 16 >> 2] = 0;
c[o >> 2] = (c[o >> 2] | 0) + 1;
i = b;
return q | 0
}
function Ye(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0;
e = i;
f = Xe(a) | 0;
h = a + 4 | 0;
j = +(+g[b >> 2] + -.10000000149011612);
k = +(+g[b + 4 >> 2] + -.10000000149011612);
l = (c[h >> 2] | 0) + (f * 36 | 0) | 0;
g[l >> 2] = j;
g[l + 4 >> 2] = k;
k = +(+g[b +
8 >> 2] + .10000000149011612);
j = +(+g[b + 12 >> 2] + .10000000149011612);
b = (c[h >> 2] | 0) + (f * 36 | 0) + 8 | 0;
g[b >> 2] = k;
g[b + 4 >> 2] = j;
c[(c[h >> 2] | 0) + (f * 36 | 0) + 16 >> 2] = d;
c[(c[h >> 2] | 0) + (f * 36 | 0) + 32 >> 2] = 0;
Ze(a, f);
i = e;
return f | 0
}
function Ze(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0;
d = i;
e = a + 24 | 0;
c[e >> 2] = (c[e >> 2] | 0) + 1;
e = c[a >> 2] | 0;
if ((e | 0) == -1) {
c[a >> 2] = b;
c[(c[a + 4 >> 2] | 0) + (b * 36 | 0) + 20 >> 2] = -1;
i = d;
return
}
f = a + 4 | 0;
h = c[f >> 2] | 0;
j = +g[h + (b * 36 | 0) >>
2];
k = +g[h + (b * 36 | 0) + 4 >> 2];
l = +g[h + (b * 36 | 0) + 8 >> 2];
m = +g[h + (b * 36 | 0) + 12 >> 2];
n = c[h + (e * 36 | 0) + 24 >> 2] | 0;
a:
do if ((n | 0) == -1)
o = e;
else {
p = n;
q = e;
while (1) {
r = c[h + (q * 36 | 0) + 28 >> 2] | 0;
s = +g[h + (q * 36 | 0) + 8 >> 2];
t = +g[h + (q * 36 | 0) >> 2];
u = +g[h + (q * 36 | 0) + 12 >> 2];
v = +g[h + (q * 36 | 0) + 4 >> 2];
w = ((s > l ? s : l) - (t < j ? t : j) + ((u > m ? u : m) - (v < k ? v : k))) * 2;
x = w * 2;
y = (w - (s - t + (u - v)) * 2) * 2;
v = +g[h + (p * 36 | 0) >> 2];
u = j < v ? j : v;
t = +g[h + (p * 36 | 0) + 4 >> 2];
s = k < t ? k : t;
w = +g[h + (p * 36 | 0) + 8 >> 2];
z = l > w ? l : w;
A = +g[h + (p * 36 | 0) + 12 >> 2];
B = m > A ? m : A;
if ((c[h + (p * 36 | 0) + 24 >> 2] | 0) == -1)
C = (z - u + (B - s)) * 2;
else
C =
(z - u + (B - s)) * 2 - (w - v + (A - t)) * 2;
t = y + C;
A = +g[h + (r * 36 | 0) >> 2];
v = j < A ? j : A;
w = +g[h + (r * 36 | 0) + 4 >> 2];
s = k < w ? k : w;
B = +g[h + (r * 36 | 0) + 8 >> 2];
u = l > B ? l : B;
z = +g[h + (r * 36 | 0) + 12 >> 2];
D = m > z ? m : z;
if ((c[h + (r * 36 | 0) + 24 >> 2] | 0) == -1)
E = (u - v + (D - s)) * 2;
else
E = (u - v + (D - s)) * 2 - (B - A + (z - w)) * 2;
w = y + E;
if (x < t & x < w) {
o = q;
break a
}
F = t < w ? p : r;
p = c[h + (F * 36 | 0) + 24 >> 2] | 0;
if ((p | 0) == -1) {
o = F;
break
} else
q = F
}
}
while (0);
e = c[h + (o * 36 | 0) + 20 >> 2] | 0;
h = Xe(a) | 0;
n = c[f >> 2] | 0;
c[n + (h * 36 | 0) + 20 >> 2] = e;
c[n + (h * 36 | 0) + 16 >> 2] = 0;
n = c[f >> 2] | 0;
E = +g[n + (o * 36 | 0) >> 2];
C = +g[n + (o * 36 | 0) + 4 >> 2];
w = +(j < E ?
j : E);
E = +(k < C ? k : C);
q = n + (h * 36 | 0) | 0;
g[q >> 2] = w;
g[q + 4 >> 2] = E;
E = +g[n + (o * 36 | 0) + 8 >> 2];
w = +g[n + (o * 36 | 0) + 12 >> 2];
C = +(l > E ? l : E);
E = +(m > w ? m : w);
q = n + (h * 36 | 0) + 8 | 0;
g[q >> 2] = C;
g[q + 4 >> 2] = E;
q = c[f >> 2] | 0;
c[q + (h * 36 | 0) + 32 >> 2] = (c[q + (o * 36 | 0) + 32 >> 2] | 0) + 1;
if ((e | 0) == -1) {
c[q + (h * 36 | 0) + 24 >> 2] = o;
c[q + (h * 36 | 0) + 28 >> 2] = b;
c[q + (o * 36 | 0) + 20 >> 2] = h;
n = q + (b * 36 | 0) + 20 | 0;
c[n >> 2] = h;
c[a >> 2] = h;
G = c[n >> 2] | 0
} else {
n = q + (e * 36 | 0) + 24 | 0;
if ((c[n >> 2] | 0) == (o | 0))
c[n >> 2] = h;
else
c[q + (e * 36 | 0) + 28 >> 2] = h;
c[q + (h * 36 | 0) + 24 >> 2] = o;
c[q + (h * 36 | 0) + 28 >> 2] = b;
c[q + (o * 36 | 0) + 20 >> 2] = h;
c[q + (b * 36 | 0) + 20 >> 2] = h;
G = h
}
if ((G | 0) == -1) {
i = d;
return
} else
H = G;
do {
G = bf(a, H) | 0;
h = c[f >> 2] | 0;
b = c[h + (G * 36 | 0) + 24 >> 2] | 0;
q = c[h + (G * 36 | 0) + 28 >> 2] | 0;
o = c[h + (b * 36 | 0) + 32 >> 2] | 0;
e = c[h + (q * 36 | 0) + 32 >> 2] | 0;
c[h + (G * 36 | 0) + 32 >> 2] = ((o | 0) > (e | 0) ? o : e) + 1;
E = +g[h + (b * 36 | 0) >> 2];
C = +g[h + (q * 36 | 0) >> 2];
w = +g[h + (b * 36 | 0) + 4 >> 2];
m = +g[h + (q * 36 | 0) + 4 >> 2];
l = +(E < C ? E : C);
C = +(w < m ? w : m);
e = h + (G * 36 | 0) | 0;
g[e >> 2] = l;
g[e + 4 >> 2] = C;
C = +g[h + (b * 36 | 0) + 8 >> 2];
l = +g[h + (q * 36 | 0) + 8 >> 2];
m = +g[h + (b * 36 | 0) + 12 >> 2];
w = +g[h + (q * 36 | 0) + 12 >> 2];
E = +(C > l ? C : l);
l = +(m > w ? m : w);
q = h + (G * 36 | 0) + 8 |
0;
g[q >> 2] = E;
g[q + 4 >> 2] = l;
H = c[(c[f >> 2] | 0) + (G * 36 | 0) + 20 >> 2] | 0
} while (!((H | 0) == -1));
i = d;
return
}
function _e(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0;
d = i;
$e(a, b);
e = a + 16 | 0;
f = c[a + 4 >> 2] | 0;
c[f + (b * 36 | 0) + 20 >> 2] = c[e >> 2];
c[f + (b * 36 | 0) + 32 >> 2] = -1;
c[e >> 2] = b;
b = a + 8 | 0;
c[b >> 2] = (c[b >> 2] | 0) + -1;
i = d;
return
}
function $e(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0;
d = i;
if ((c[a >> 2] | 0) == (b | 0)) {
c[a >> 2] = -1;
i = d;
return
}
e = a + 4 | 0;
f = c[e >> 2] | 0;
h = c[f + (b * 36 | 0) + 20 >> 2] | 0;
j = f + (h * 36 | 0) + 20 | 0;
k = c[j >> 2] | 0;
l = c[f + (h * 36 | 0) + 24 >> 2] |
0;
if ((l | 0) == (b | 0))
m = c[f + (h * 36 | 0) + 28 >> 2] | 0;
else
m = l;
if ((k | 0) == -1) {
c[a >> 2] = m;
c[f + (m * 36 | 0) + 20 >> 2] = -1;
l = a + 16 | 0;
c[j >> 2] = c[l >> 2];
c[f + (h * 36 | 0) + 32 >> 2] = -1;
c[l >> 2] = h;
l = a + 8 | 0;
c[l >> 2] = (c[l >> 2] | 0) + -1;
i = d;
return
}
l = f + (k * 36 | 0) + 24 | 0;
if ((c[l >> 2] | 0) == (h | 0))
c[l >> 2] = m;
else
c[f + (k * 36 | 0) + 28 >> 2] = m;
c[f + (m * 36 | 0) + 20 >> 2] = k;
m = a + 16 | 0;
c[j >> 2] = c[m >> 2];
c[f + (h * 36 | 0) + 32 >> 2] = -1;
c[m >> 2] = h;
h = a + 8 | 0;
c[h >> 2] = (c[h >> 2] | 0) + -1;
h = k;
do {
k = bf(a, h) | 0;
m = c[e >> 2] | 0;
f = c[m + (k * 36 | 0) + 24 >> 2] | 0;
j = c[m + (k * 36 | 0) + 28 >> 2] | 0;
n = +g[m + (f * 36 | 0) >> 2];
o = +g[m + (j * 36 | 0) >>
2];
p = +g[m + (f * 36 | 0) + 4 >> 2];
q = +g[m + (j * 36 | 0) + 4 >> 2];
r = +(n < o ? n : o);
o = +(p < q ? p : q);
l = m + (k * 36 | 0) | 0;
g[l >> 2] = r;
g[l + 4 >> 2] = o;
o = +g[m + (f * 36 | 0) + 8 >> 2];
r = +g[m + (j * 36 | 0) + 8 >> 2];
q = +g[m + (f * 36 | 0) + 12 >> 2];
p = +g[m + (j * 36 | 0) + 12 >> 2];
n = +(o > r ? o : r);
r = +(q > p ? q : p);
l = m + (k * 36 | 0) + 8 | 0;
g[l >> 2] = n;
g[l + 4 >> 2] = r;
l = c[e >> 2] | 0;
m = c[l + (f * 36 | 0) + 32 >> 2] | 0;
f = c[l + (j * 36 | 0) + 32 >> 2] | 0;
c[l + (k * 36 | 0) + 32 >> 2] = ((m | 0) > (f | 0) ? m : f) + 1;
h = c[l + (k * 36 | 0) + 20 >> 2] | 0
} while (!((h | 0) == -1));
i = d;
return
}
function af(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0;
f = i;
h = a + 4 | 0;
j = c[h >> 2] | 0;
if (((+g[j + (b * 36 | 0) >> 2] <= +g[d >> 2] ? +g[j + (b * 36 | 0) + 4 >> 2] <= +g[d + 4 >> 2] : 0) ? +g[d + 8 >> 2] <= +g[j + (b * 36 | 0) + 8 >> 2] : 0) ? +g[d + 12 >> 2] <= +g[j + (b * 36 | 0) + 12 >> 2] : 0) {
k = 0;
i = f;
return k | 0
}
$e(a, b);
j = d;
l = +g[j >> 2];
m = +g[j + 4 >> 2];
j = d + 8 | 0;
n = +g[j >> 2];
o = l + -.10000000149011612;
l = m + -.10000000149011612;
m = n + .10000000149011612;
n = +g[j + 4 >> 2] + .10000000149011612;
p = +g[e >> 2] * 2;
q = +g[e + 4 >> 2] * 2;
if (p < 0) {
r = o + p;
s = m
} else {
r = o;
s = p + m
}
if (q < 0) {
t = l + q;
u = n
} else {
t = l;
u = q + n
}
e = c[h >> 2] | 0;
n = +r;
r = +t;
h = e + (b * 36 | 0) | 0;
g[h >>
2] = n;
g[h + 4 >> 2] = r;
r = +s;
s = +u;
h = e + (b * 36 | 0) + 8 | 0;
g[h >> 2] = r;
g[h + 4 >> 2] = s;
Ze(a, b);
k = 1;
i = f;
return k | 0
}
function bf(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0;
d = i;
e = c[a + 4 >> 2] | 0;
f = e + (b * 36 | 0) | 0;
h = e + (b * 36 | 0) + 24 | 0;
j = c[h >> 2] | 0;
if ((j | 0) == -1) {
k = b;
i = d;
return k | 0
}
l = e + (b * 36 | 0) + 32 | 0;
if ((c[l >> 2] | 0) < 2) {
k = b;
i = d;
return k | 0
}
m = e + (b * 36 | 0) + 28 | 0;
n = c[m >> 2] | 0;
o = e + (j * 36 | 0) | 0;
p = e + (n * 36 | 0) | 0;
q = e + (n * 36 | 0) + 32 | 0;
r = e + (j * 36 | 0) + 32 | 0;
s = (c[q >> 2] | 0) - (c[r >> 2] | 0) | 0;
if ((s | 0) > 1) {
t = e + (n * 36 | 0) + 24 | 0;
u = c[t >> 2] | 0;
v = e + (n * 36 | 0) + 28 | 0;
w = c[v >> 2] | 0;
x = e + (u * 36 | 0) | 0;
y = e + (w * 36 | 0) | 0;
c[t >> 2] = b;
t = e + (b * 36 | 0) + 20 | 0;
z = e + (n * 36 | 0) + 20 | 0;
c[z >> 2] = c[t >> 2];
c[t >> 2] = n;
t = c[z >> 2] | 0;
do if (!((t | 0) == -1)) {
z = e + (t * 36 | 0) + 24 | 0;
if ((c[z >> 2] | 0) == (b | 0)) {
c[z >> 2] = n;
break
} else {
c[e + (t * 36 | 0) + 28 >> 2] = n;
break
}
} else
c[a >> 2] = n;
while (0);
t = e + (u * 36 | 0) + 32 | 0;
z = e + (w * 36 | 0) + 32 | 0;
if ((c[t >> 2] | 0) > (c[z >> 2] | 0)) {
c[v >> 2] = u;
c[m >> 2] = w;
c[e + (w * 36 | 0) + 20 >> 2] = b;
A = +g[o >> 2];
B = +g[y >> 2];
C = A < B ? A : B;
B = +g[e + (j * 36 | 0) +
4 >> 2];
A = +g[e + (w * 36 | 0) + 4 >> 2];
D = +C;
E = +(B < A ? B : A);
F = f;
g[F >> 2] = D;
g[F + 4 >> 2] = E;
E = +g[e + (j * 36 | 0) + 8 >> 2];
D = +g[e + (w * 36 | 0) + 8 >> 2];
A = +g[e + (j * 36 | 0) + 12 >> 2];
B = +g[e + (w * 36 | 0) + 12 >> 2];
G = +(E > D ? E : D);
D = +(A > B ? A : B);
F = e + (b * 36 | 0) + 8 | 0;
g[F >> 2] = G;
g[F + 4 >> 2] = D;
D = +g[x >> 2];
G = +g[e + (b * 36 | 0) + 4 >> 2];
B = +g[e + (u * 36 | 0) + 4 >> 2];
A = +(C < D ? C : D);
D = +(G < B ? G : B);
F = p;
g[F >> 2] = A;
g[F + 4 >> 2] = D;
D = +g[e + (b * 36 | 0) + 8 >> 2];
A = +g[e + (u * 36 | 0) + 8 >> 2];
B = +g[e + (b * 36 | 0) + 12 >> 2];
G = +g[e + (u * 36 | 0) + 12 >> 2];
C = +(D > A ? D : A);
A = +(B > G ? B : G);
F = e + (n * 36 | 0) + 8 | 0;
g[F >> 2] = C;
g[F + 4 >> 2] = A;
F = c[r >> 2] | 0;
H = c[z >> 2] | 0;
I = ((F | 0) > (H | 0) ? F : H) + 1 | 0;
c[l >> 2] = I;
H = c[t >> 2] | 0;
J = (I | 0) > (H | 0) ? I : H
} else {
c[v >> 2] = w;
c[m >> 2] = u;
c[e + (u * 36 | 0) + 20 >> 2] = b;
A = +g[o >> 2];
C = +g[x >> 2];
G = A < C ? A : C;
C = +g[e + (j * 36 | 0) + 4 >> 2];
A = +g[e + (u * 36 | 0) + 4 >> 2];
B = +G;
D = +(C < A ? C : A);
x = f;
g[x >> 2] = B;
g[x + 4 >> 2] = D;
D = +g[e + (j * 36 | 0) + 8 >> 2];
B = +g[e + (u * 36 | 0) + 8 >> 2];
A = +g[e + (j * 36 | 0) + 12 >> 2];
C = +g[e + (u * 36 | 0) + 12 >> 2];
E = +(D > B ? D : B);
B = +(A > C ? A : C);
u = e + (b * 36 | 0) + 8 | 0;
g[u >> 2] = E;
g[u + 4 >> 2] = B;
B = +g[y >> 2];
E = +g[e + (b * 36 | 0) + 4 >> 2];
C = +g[e + (w * 36 | 0) + 4 >> 2];
A = +(G < B ? G : B);
B = +(E < C ? E : C);
y = p;
g[y >> 2] = A;
g[y + 4 >> 2] =
B;
B = +g[e + (b * 36 | 0) + 8 >> 2];
A = +g[e + (w * 36 | 0) + 8 >> 2];
C = +g[e + (b * 36 | 0) + 12 >> 2];
E = +g[e + (w * 36 | 0) + 12 >> 2];
G = +(B > A ? B : A);
A = +(C > E ? C : E);
w = e + (n * 36 | 0) + 8 | 0;
g[w >> 2] = G;
g[w + 4 >> 2] = A;
w = c[r >> 2] | 0;
y = c[t >> 2] | 0;
t = ((w | 0) > (y | 0) ? w : y) + 1 | 0;
c[l >> 2] = t;
y = c[z >> 2] | 0;
J = (t | 0) > (y | 0) ? t : y
}
c[q >> 2] = J + 1;
k = n;
i = d;
return k | 0
}
if (!((s | 0) < -1)) {
k = b;
i = d;
return k | 0
}
s = e + (j * 36 | 0) + 24 | 0;
J = c[s >> 2] | 0;
y = e + (j * 36 | 0) + 28 | 0;
t = c[y >> 2] | 0;
z = e + (J * 36 | 0) | 0;
w = e + (t * 36 | 0) | 0;
c[s >> 2] = b;
s = e + (b * 36 | 0) + 20 | 0;
u = e + (j * 36 | 0) + 20 | 0;
c[u >> 2] = c[s >> 2];
c[s >> 2] = j;
s = c[u >> 2] | 0;
do if (!((s | 0) == -1)) {
u =
e + (s * 36 | 0) + 24 | 0;
if ((c[u >> 2] | 0) == (b | 0)) {
c[u >> 2] = j;
break
} else {
c[e + (s * 36 | 0) + 28 >> 2] = j;
break
}
} else
c[a >> 2] = j;
while (0);
a = e + (J * 36 | 0) + 32 | 0;
s = e + (t * 36 | 0) + 32 | 0;
if ((c[a >> 2] | 0) > (c[s >> 2] | 0)) {
c[y >> 2] = J;
c[h >> 2] = t;
c[e + (t * 36 | 0) + 20 >> 2] = b;
A = +g[p >> 2];
G = +g[w >> 2];
E = A < G ? A : G;
G = +g[e + (n * 36 | 0) + 4 >> 2];
A = +g[e + (t * 36 | 0) + 4 >> 2];
C = +E;
B = +(G < A ? G : A);
u = f;
g[u >> 2] = C;
g[u + 4 >> 2] = B;
B = +g[e + (n * 36 | 0) + 8 >> 2];
C = +g[e + (t * 36 | 0) + 8 >> 2];
A = +g[e + (n * 36 | 0) + 12 >> 2];
G = +g[e + (t * 36 | 0) + 12 >> 2];
D = +(B > C ? B : C);
C = +(A > G ? A : G);
u = e + (b * 36 | 0) + 8 | 0;
g[u >> 2] = D;
g[u + 4 >> 2] = C;
C = +g[z >>
2];
D = +g[e + (b * 36 | 0) + 4 >> 2];
G = +g[e + (J * 36 | 0) + 4 >> 2];
A = +(E < C ? E : C);
C = +(D < G ? D : G);
u = o;
g[u >> 2] = A;
g[u + 4 >> 2] = C;
C = +g[e + (b * 36 | 0) + 8 >> 2];
A = +g[e + (J * 36 | 0) + 8 >> 2];
G = +g[e + (b * 36 | 0) + 12 >> 2];
D = +g[e + (J * 36 | 0) + 12 >> 2];
E = +(C > A ? C : A);
A = +(G > D ? G : D);
u = e + (j * 36 | 0) + 8 | 0;
g[u >> 2] = E;
g[u + 4 >> 2] = A;
u = c[q >> 2] | 0;
x = c[s >> 2] | 0;
m = ((u | 0) > (x | 0) ? u : x) + 1 | 0;
c[l >> 2] = m;
x = c[a >> 2] | 0;
K = (m | 0) > (x | 0) ? m : x
} else {
c[y >> 2] = t;
c[h >> 2] = J;
c[e + (J * 36 | 0) + 20 >> 2] = b;
A = +g[p >> 2];
E = +g[z >> 2];
D = A < E ? A : E;
E = +g[e + (n * 36 | 0) + 4 >> 2];
A = +g[e + (J * 36 | 0) + 4 >> 2];
G = +D;
C = +(E < A ? E : A);
z = f;
g[z >> 2] = G;
g[z +
4 >> 2] = C;
C = +g[e + (n * 36 | 0) + 8 >> 2];
G = +g[e + (J * 36 | 0) + 8 >> 2];
A = +g[e + (n * 36 | 0) + 12 >> 2];
E = +g[e + (J * 36 | 0) + 12 >> 2];
B = +(C > G ? C : G);
G = +(A > E ? A : E);
J = e + (b * 36 | 0) + 8 | 0;
g[J >> 2] = B;
g[J + 4 >> 2] = G;
G = +g[w >> 2];
B = +g[e + (b * 36 | 0) + 4 >> 2];
E = +g[e + (t * 36 | 0) + 4 >> 2];
A = +(D < G ? D : G);
G = +(B < E ? B : E);
w = o;
g[w >> 2] = A;
g[w + 4 >> 2] = G;
G = +g[e + (b * 36 | 0) + 8 >> 2];
A = +g[e + (t * 36 | 0) + 8 >> 2];
E = +g[e + (b * 36 | 0) + 12 >> 2];
B = +g[e + (t * 36 | 0) + 12 >> 2];
D = +(G > A ? G : A);
A = +(E > B ? E : B);
t = e + (j * 36 | 0) + 8 | 0;
g[t >> 2] = D;
g[t + 4 >> 2] = A;
t = c[q >> 2] | 0;
q = c[a >> 2] | 0;
a = ((t | 0) > (q | 0) ? t : q) + 1 | 0;
c[l >> 2] = a;
l = c[s >> 2] | 0;
K = (a | 0) >
(l | 0) ? a : l
}
c[r >> 2] = K + 1;
k = j;
i = d;
return k | 0
}
function cf(b, d, e, f, h) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
h = h | 0;
var j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0;
j = i;
l = b + 60 | 0;
c[l >> 2] = 0;
m = f + 12 | 0;
n = +g[h + 12 >> 2];
o = +g[m >> 2];
p = +g[h + 8 >> 2];
q = +g[f + 16 >> 2];
r = +g[h >> 2] + (n * o - p * q) - +g[e >> 2];
s = o * p + n * q + +g[h + 4 >> 2] - +g[e + 4 >> 2];
q = +g[e + 12 >> 2];
n = +g[e + 8 >> 2];
p = r * q + s * n;
o = q * s - r * n;
e = d + 12 | 0;
h = c[e >> 2] | 0;
t = c[e + 4 >> 2] | 0;
n = (c[k >> 2] = h, +g[k >> 2]);
r = (c[k >> 2] = t, +g[k >> 2]);
e = d + 20 | 0;
u = c[e >> 2] | 0;
v = c[e + 4 >> 2] | 0;
s = (c[k >> 2] = u, +g[k >> 2]);
q = (c[k >> 2] = v, +g[k >> 2]);
w = s - n;
x = q - r;
y = w * (s - p) + x * (q - o);
z = p - n;
A = o - r;
B = z * w + A * x;
C = +g[d + 8 >> 2] + +g[f + 8 >> 2];
if (B <= 0) {
if (z * z + A * A > C * C) {
i = j;
return
}
if ((a[d + 44 >> 0] | 0) != 0 ? (f = d + 28 | 0, D = +g[f >> 2], (n - p) * (n - D) + (r - o) * (r - +g[f + 4 >> 2]) > 0) : 0) {
i = j;
return
}
c[l >> 2] = 1;
c[b + 56 >> 2] = 0;
g[b + 40 >> 2] = 0;
g[b + 44 >> 2] = 0;
f = b + 48 | 0;
c[f >> 2] = h;
c[f + 4 >> 2] = t;
f = b + 16 | 0;
c[f >> 2] = 0;
a[f >> 0] = 0;
a[f + 1 >> 0] = 0;
a[f + 2 >> 0] = 0;
a[f + 3 >> 0] = 0;
f = m;
e = c[f + 4 >> 2] | 0;
E = b;
c[E >> 2] = c[f >> 2];
c[E + 4 >> 2] = e;
i = j;
return
}
if (y <= 0) {
D = p - s;
F = o - q;
if (D * D + F *
F > C * C) {
i = j;
return
}
if ((a[d + 45 >> 0] | 0) != 0 ? (e = d + 36 | 0, G = +g[e >> 2], D * (G - s) + F * (+g[e + 4 >> 2] - q) > 0) : 0) {
i = j;
return
}
c[l >> 2] = 1;
c[b + 56 >> 2] = 0;
g[b + 40 >> 2] = 0;
g[b + 44 >> 2] = 0;
e = b + 48 | 0;
c[e >> 2] = u;
c[e + 4 >> 2] = v;
v = b + 16 | 0;
c[v >> 2] = 0;
a[v >> 0] = 1;
a[v + 1 >> 0] = 0;
a[v + 2 >> 0] = 0;
a[v + 3 >> 0] = 0;
v = m;
e = c[v + 4 >> 2] | 0;
u = b;
c[u >> 2] = c[v >> 2];
c[u + 4 >> 2] = e;
i = j;
return
}
F = 1 / (w * w + x * x);
G = p - (n * y + s * B) * F;
s = o - (r * y + q * B) * F;
if (G * G + s * s > C * C) {
i = j;
return
}
C = -x;
if (w * A + z * C < 0) {
H = x;
I = -w
} else {
H = C;
I = w
}
w = +Q(+(I * I + H * H));
if (w < 1.1920928955078125E-7) {
J = H;
K = I
} else {
C = 1 / w;
J = H * C;
K = I * C
}
c[l >>
2] = 1;
c[b + 56 >> 2] = 1;
C = +J;
J = +K;
l = b + 40 | 0;
g[l >> 2] = C;
g[l + 4 >> 2] = J;
l = b + 48 | 0;
c[l >> 2] = h;
c[l + 4 >> 2] = t;
t = b + 16 | 0;
c[t >> 2] = 0;
a[t >> 0] = 0;
a[t + 1 >> 0] = 0;
a[t + 2 >> 0] = 1;
a[t + 3 >> 0] = 0;
t = m;
m = c[t + 4 >> 2] | 0;
l = b;
c[l >> 2] = c[t >> 2];
c[l + 4 >> 2] = m;
i = j;
return
}
function df(b, d, e, f, h, j) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
h = h | 0;
j = j | 0;
var l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka =
0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0,
ya = 0,
za = 0,
Aa = 0,
Ba = 0,
Ca = 0,
Da = 0,
Ea = 0;
l = i;
i = i + 144 | 0;
m = l + 128 | 0;
n = l + 24 | 0;
o = l + 72 | 0;
p = l + 48 | 0;
q = l;
r = b + 132 | 0;
s = +g[f + 12 >> 2];
t = +g[j + 8 >> 2];
u = +g[f + 8 >> 2];
v = +g[j + 12 >> 2];
w = s * t - u * v;
x = t * u + s * v;
v = +w;
t = +x;
y = +g[j >> 2] - +g[f >> 2];
z = +g[j + 4 >> 2] - +g[f + 4 >> 2];
A = s * y + u * z;
B = s * z - u * y;
y = +A;
u = +B;
f = r;
g[f >> 2] = y;
g[f + 4 >> 2] = u;
f = b + 140 | 0;
g[f >> 2] = v;
g[f + 4 >> 2] = t;
f = b + 144 | 0;
t = +g[h + 12 >> 2];
j = b + 140 | 0;
v = +g[h + 16 >> 2];
u = A + (x * t - w * v);
C = b + 136 | 0;
A = t * w + x * v + B;
B = +u;
v = +A;
D = b + 148 | 0;
g[D >> 2] = B;
g[D +
4 >> 2] = v;
D = e + 28 | 0;
E = c[D >> 2] | 0;
F = c[D + 4 >> 2] | 0;
D = b + 156 | 0;
c[D >> 2] = E;
c[D + 4 >> 2] = F;
D = b + 164 | 0;
G = e + 12 | 0;
H = c[G >> 2] | 0;
I = c[G + 4 >> 2] | 0;
G = D;
c[G >> 2] = H;
c[G + 4 >> 2] = I;
G = b + 172 | 0;
J = e + 20 | 0;
K = c[J >> 2] | 0;
L = c[J + 4 >> 2] | 0;
J = G;
c[J >> 2] = K;
c[J + 4 >> 2] = L;
J = e + 36 | 0;
M = c[J >> 2] | 0;
N = c[J + 4 >> 2] | 0;
J = b + 180 | 0;
c[J >> 2] = M;
c[J + 4 >> 2] = N;
J = (a[e + 44 >> 0] | 0) != 0;
O = (a[e + 45 >> 0] | 0) != 0;
v = (c[k >> 2] = K, +g[k >> 2]);
B = (c[k >> 2] = H, +g[k >> 2]);
x = v - B;
w = (c[k >> 2] = L, +g[k >> 2]);
L = b + 168 | 0;
t = (c[k >> 2] = I, +g[k >> 2]);
y = w - t;
z = +Q(+(x * x + y * y));
s = (c[k >> 2] = E, +g[k >> 2]);
P = (c[k >> 2] = F, +g[k >> 2]);
R = (c[k >> 2] = M, +g[k >> 2]);
S = (c[k >> 2] = N, +g[k >> 2]);
if (z < 1.1920928955078125E-7) {
T = x;
U = y
} else {
V = 1 / z;
T = x * V;
U = y * V
}
N = b + 196 | 0;
V = -T;
g[N >> 2] = U;
M = b + 200 | 0;
g[M >> 2] = V;
y = (u - B) * U + (A - t) * V;
if (J) {
V = B - s;
B = t - P;
t = +Q(+(V * V + B * B));
if (t < 1.1920928955078125E-7) {
W = V;
X = B
} else {
x = 1 / t;
W = V * x;
X = B * x
}
x = -W;
g[b + 188 >> 2] = X;
g[b + 192 >> 2] = x;
Y = U * W - T * X >= 0;
Z = (u - s) * X + (A - P) * x
} else {
Y = 0;
Z = 0
}
a:
do if (!O) {
if (!J) {
F = y >= 0;
a[b + 248 >> 0] = F & 1;
E = b + 212 | 0;
if (F) {
_ = E;
$ = 64;
break
} else {
aa = E;
$ = 65;
break
}
}
E = Z >= 0;
if (Y) {
if (!E) {
F = y >= 0;
a[b + 248 >> 0] = F & 1;
I = b + 212 | 0;
if (F)
ba = I;
else {
x =
+-U;
P = +T;
F = I;
g[F >> 2] = x;
g[F + 4 >> 2] = P;
F = N;
I = c[F >> 2] | 0;
H = c[F + 4 >> 2] | 0;
F = b + 228 | 0;
c[F >> 2] = I;
c[F + 4 >> 2] = H;
H = b + 236 | 0;
g[H >> 2] = -(c[k >> 2] = I, +g[k >> 2]);
g[H + 4 >> 2] = P;
break
}
} else {
a[b + 248 >> 0] = 1;
ba = b + 212 | 0
}
H = N;
I = c[H + 4 >> 2] | 0;
F = ba;
c[F >> 2] = c[H >> 2];
c[F + 4 >> 2] = I;
I = b + 188 | 0;
F = c[I + 4 >> 2] | 0;
H = b + 228 | 0;
c[H >> 2] = c[I >> 2];
c[H + 4 >> 2] = F;
P = +-+g[N >> 2];
x = +-+g[M >> 2];
F = b + 236 | 0;
g[F >> 2] = P;
g[F + 4 >> 2] = x;
break
} else {
if (E) {
E = y >= 0;
a[b + 248 >> 0] = E & 1;
F = b + 212 | 0;
if (E) {
E = N;
H = c[E >> 2] | 0;
I = c[E + 4 >> 2] | 0;
E = F;
c[E >> 2] = H;
c[E + 4 >> 2] = I;
E = b + 228 | 0;
c[E >> 2] = H;
c[E + 4 >> 2] = I;
x = +-(c[k >> 2] = H, +g[k >> 2]);
P = +T;
H = b + 236 | 0;
g[H >> 2] = x;
g[H + 4 >> 2] = P;
break
} else
ca = F
} else {
a[b + 248 >> 0] = 0;
ca = b + 212 | 0
}
P = +-U;
x = +T;
F = ca;
g[F >> 2] = P;
g[F + 4 >> 2] = x;
F = N;
H = c[F + 4 >> 2] | 0;
I = b + 228 | 0;
c[I >> 2] = c[F >> 2];
c[I + 4 >> 2] = H;
x = +-+g[b + 188 >> 2];
P = +-+g[b + 192 >> 2];
H = b + 236 | 0;
g[H >> 2] = x;
g[H + 4 >> 2] = P;
break
}
} else {
P = R - v;
x = S - w;
X = +Q(+(P * P + x * x));
if (X < 1.1920928955078125E-7) {
da = P;
ea = x
} else {
s = 1 / X;
da = P * s;
ea = x * s
}
s = -da;
H = b + 204 | 0;
g[H >> 2] = ea;
I = b + 208 | 0;
g[I >> 2] = s;
F = T * ea - U * da > 0;
x = (u - v) * ea + (A - w) * s;
if (!J) {
E = y >= 0;
if (!O) {
a[b + 248 >> 0] = E & 1;
K = b + 212 | 0;
if (E) {
_ =
K;
$ = 64;
break
} else {
aa = K;
$ = 65;
break
}
}
if (F) {
if (!E) {
K = x >= 0;
a[b + 248 >> 0] = K & 1;
e = b + 212 | 0;
if (K)
fa = e;
else {
s = +-U;
P = +T;
K = e;
g[K >> 2] = s;
g[K + 4 >> 2] = P;
K = b + 228 | 0;
g[K >> 2] = s;
g[K + 4 >> 2] = P;
K = N;
e = c[K + 4 >> 2] | 0;
ga = b + 236 | 0;
c[ga >> 2] = c[K >> 2];
c[ga + 4 >> 2] = e;
break
}
} else {
a[b + 248 >> 0] = 1;
fa = b + 212 | 0
}
e = N;
ga = c[e + 4 >> 2] | 0;
K = fa;
c[K >> 2] = c[e >> 2];
c[K + 4 >> 2] = ga;
P = +-+g[N >> 2];
s = +-+g[M >> 2];
ga = b + 228 | 0;
g[ga >> 2] = P;
g[ga + 4 >> 2] = s;
ga = b + 204 | 0;
K = c[ga + 4 >> 2] | 0;
e = b + 236 | 0;
c[e >> 2] = c[ga >> 2];
c[e + 4 >> 2] = K;
break
} else {
if (E) {
E = x >= 0;
a[b + 248 >> 0] = E & 1;
K = b + 212 | 0;
if (E) {
E = N;
e =
c[E >> 2] | 0;
ga = c[E + 4 >> 2] | 0;
E = K;
c[E >> 2] = e;
c[E + 4 >> 2] = ga;
s = +-(c[k >> 2] = e, +g[k >> 2]);
P = +T;
E = b + 228 | 0;
g[E >> 2] = s;
g[E + 4 >> 2] = P;
E = b + 236 | 0;
c[E >> 2] = e;
c[E + 4 >> 2] = ga;
break
} else
ha = K
} else {
a[b + 248 >> 0] = 0;
ha = b + 212 | 0
}
P = +-U;
s = +T;
K = ha;
g[K >> 2] = P;
g[K + 4 >> 2] = s;
s = +-+g[b + 204 >> 2];
P = +-+g[b + 208 >> 2];
K = b + 228 | 0;
g[K >> 2] = s;
g[K + 4 >> 2] = P;
K = N;
ga = c[K + 4 >> 2] | 0;
E = b + 236 | 0;
c[E >> 2] = c[K >> 2];
c[E + 4 >> 2] = ga;
break
}
}
if (Y & F) {
if (!(Z >= 0) & !(y >= 0)) {
ga = x >= 0;
a[b + 248 >> 0] = ga & 1;
E = b + 212 | 0;
if (ga)
ia = E;
else {
P = +-U;
s = +T;
ga = E;
g[ga >> 2] = P;
g[ga + 4 >> 2] = s;
ga = b + 228 | 0;
g[ga >> 2] =
P;
g[ga + 4 >> 2] = s;
ga = b + 236 | 0;
g[ga >> 2] = P;
g[ga + 4 >> 2] = s;
break
}
} else {
a[b + 248 >> 0] = 1;
ia = b + 212 | 0
}
ga = N;
E = c[ga + 4 >> 2] | 0;
K = ia;
c[K >> 2] = c[ga >> 2];
c[K + 4 >> 2] = E;
E = b + 188 | 0;
K = c[E + 4 >> 2] | 0;
ga = b + 228 | 0;
c[ga >> 2] = c[E >> 2];
c[ga + 4 >> 2] = K;
K = b + 204 | 0;
ga = c[K + 4 >> 2] | 0;
E = b + 236 | 0;
c[E >> 2] = c[K >> 2];
c[E + 4 >> 2] = ga;
break
}
if (Y) {
do if (!(Z >= 0)) {
if (y >= 0) {
ga = x >= 0;
a[b + 248 >> 0] = ga & 1;
E = b + 212 | 0;
if (ga) {
ja = E;
break
} else
ka = E
} else {
a[b + 248 >> 0] = 0;
ka = b + 212 | 0
}
s = +-U;
P = +T;
E = ka;
g[E >> 2] = s;
g[E + 4 >> 2] = P;
P = +-+g[H >> 2];
s = +-+g[I >> 2];
E = b + 228 | 0;
g[E >> 2] = P;
g[E + 4 >> 2] = s;
s = +-+g[N >>
2];
P = +-+g[M >> 2];
E = b + 236 | 0;
g[E >> 2] = s;
g[E + 4 >> 2] = P;
break a
} else {
a[b + 248 >> 0] = 1;
ja = b + 212 | 0
}
while (0);
E = N;
ga = c[E + 4 >> 2] | 0;
K = ja;
c[K >> 2] = c[E >> 2];
c[K + 4 >> 2] = ga;
ga = b + 188 | 0;
K = c[ga + 4 >> 2] | 0;
E = b + 228 | 0;
c[E >> 2] = c[ga >> 2];
c[E + 4 >> 2] = K;
K = N;
E = c[K + 4 >> 2] | 0;
ga = b + 236 | 0;
c[ga >> 2] = c[K >> 2];
c[ga + 4 >> 2] = E;
break
}
if (!F) {
if (!(!(Z >= 0) | !(y >= 0))) {
E = x >= 0;
a[b + 248 >> 0] = E & 1;
ga = b + 212 | 0;
if (E) {
E = N;
K = c[E >> 2] | 0;
e = c[E + 4 >> 2] | 0;
E = ga;
c[E >> 2] = K;
c[E + 4 >> 2] = e;
E = b + 228 | 0;
c[E >> 2] = K;
c[E + 4 >> 2] = e;
E = b + 236 | 0;
c[E >> 2] = K;
c[E + 4 >> 2] = e;
break
} else
la = ga
} else {
a[b + 248 >> 0] =
0;
la = b + 212 | 0
}
P = +-U;
s = +T;
ga = la;
g[ga >> 2] = P;
g[ga + 4 >> 2] = s;
s = +-+g[H >> 2];
P = +-+g[I >> 2];
ga = b + 228 | 0;
g[ga >> 2] = s;
g[ga + 4 >> 2] = P;
P = +-+g[b + 188 >> 2];
s = +-+g[b + 192 >> 2];
ga = b + 236 | 0;
g[ga >> 2] = P;
g[ga + 4 >> 2] = s;
break
}
do if (!(x >= 0)) {
if (Z >= 0) {
ga = y >= 0;
a[b + 248 >> 0] = ga & 1;
e = b + 212 | 0;
if (ga) {
ma = e;
break
} else
na = e
} else {
a[b + 248 >> 0] = 0;
na = b + 212 | 0
}
s = +-U;
P = +T;
e = na;
g[e >> 2] = s;
g[e + 4 >> 2] = P;
P = +-+g[N >> 2];
s = +-+g[M >> 2];
e = b + 228 | 0;
g[e >> 2] = P;
g[e + 4 >> 2] = s;
s = +-+g[b + 188 >> 2];
P = +-+g[b + 192 >> 2];
e = b + 236 | 0;
g[e >> 2] = s;
g[e + 4 >> 2] = P;
break a
} else {
a[b + 248 >> 0] = 1;
ma = b +
212 | 0
}
while (0);
I = N;
H = c[I + 4 >> 2] | 0;
F = ma;
c[F >> 2] = c[I >> 2];
c[F + 4 >> 2] = H;
H = N;
F = c[H + 4 >> 2] | 0;
I = b + 228 | 0;
c[I >> 2] = c[H >> 2];
c[I + 4 >> 2] = F;
F = b + 204 | 0;
I = c[F + 4 >> 2] | 0;
H = b + 236 | 0;
c[H >> 2] = c[F >> 2];
c[H + 4 >> 2] = I
}
while (0);
if (($ | 0) == 64) {
ma = N;
na = c[ma >> 2] | 0;
la = c[ma + 4 >> 2] | 0;
ma = _;
c[ma >> 2] = na;
c[ma + 4 >> 2] = la;
y = +-(c[k >> 2] = na, +g[k >> 2]);
Z = +T;
na = b + 228 | 0;
g[na >> 2] = y;
g[na + 4 >> 2] = Z;
na = b + 236 | 0;
g[na >> 2] = y;
g[na + 4 >> 2] = Z
} else if (($ | 0) == 65) {
Z = +-U;
U = +T;
na = aa;
g[na >> 2] = Z;
g[na + 4 >> 2] = U;
na = N;
aa = c[na >> 2] | 0;
la = c[na + 4 >> 2] | 0;
na = b + 228 | 0;
c[na >> 2] = aa;
c[na + 4 >> 2] =
la;
na = b + 236 | 0;
c[na >> 2] = aa;
c[na + 4 >> 2] = la
}
la = h + 148 | 0;
na = b + 128 | 0;
c[na >> 2] = c[la >> 2];
if ((c[la >> 2] | 0) > 0) {
aa = 0;
do {
U = +g[f >> 2];
Z = +g[h + (aa << 3) + 20 >> 2];
T = +g[j >> 2];
y = +g[h + (aa << 3) + 24 >> 2];
w = +(+g[r >> 2] + (U * Z - T * y));
A = +(Z * T + U * y + +g[C >> 2]);
ma = b + (aa << 3) | 0;
g[ma >> 2] = w;
g[ma + 4 >> 2] = A;
A = +g[f >> 2];
w = +g[h + (aa << 3) + 84 >> 2];
y = +g[j >> 2];
U = +g[h + (aa << 3) + 88 >> 2];
T = +(A * w - y * U);
Z = +(w * y + A * U);
ma = b + (aa << 3) + 64 | 0;
g[ma >> 2] = T;
g[ma + 4 >> 2] = Z;
aa = aa + 1 | 0
} while ((aa | 0) < (c[la >> 2] | 0))
}
la = b + 244 | 0;
g[la >> 2] = .019999999552965164;
aa = d + 60 | 0;
c[aa >> 2] = 0;
ma = b + 248 | 0;
_ = c[na >> 2] | 0;
if ((_ | 0) <= 0) {
i = l;
return
}
Z = +g[b + 164 >> 2];
T = +g[L >> 2];
U = +g[b + 212 >> 2];
A = +g[b + 216 >> 2];
y = 3.4028234663852886E38;
L = 0;
do {
w = U * (+g[b + (L << 3) >> 2] - Z) + A * (+g[b + (L << 3) + 4 >> 2] - T);
y = w < y ? w : y;
L = L + 1 | 0
} while ((L | 0) != (_ | 0));
if (y > .019999999552965164) {
i = l;
return
}
ef(m, b);
_ = c[m >> 2] | 0;
if ((_ | 0) != 0) {
T = +g[m + 8 >> 2];
if (T > +g[la >> 2]) {
i = l;
return
}
if (T > y * .9800000190734863 + .0010000000474974513) {
L = c[m + 4 >> 2] | 0;
m = d + 56 | 0;
if ((_ | 0) == 1) {
oa = n;
pa = m;
$ = 77
} else {
c[m >> 2] = 2;
m = D;
_ = c[m + 4 >> 2] | 0;
ja = n;
c[ja >> 2] = c[m >> 2];
c[ja + 4 >> 2] = _;
_ = n + 8 | 0;
a[_ >> 0] =
0;
ja = L & 255;
a[_ + 1 >> 0] = ja;
a[_ + 2 >> 0] = 0;
a[_ + 3 >> 0] = 1;
_ = G;
m = c[_ + 4 >> 2] | 0;
ka = n + 12 | 0;
c[ka >> 2] = c[_ >> 2];
c[ka + 4 >> 2] = m;
m = n + 20 | 0;
a[m >> 0] = 0;
a[m + 1 >> 0] = ja;
a[m + 2 >> 0] = 0;
a[m + 3 >> 0] = 1;
c[o >> 2] = L;
m = L + 1 | 0;
ja = (m | 0) < (c[na >> 2] | 0) ? m : 0;
c[o + 4 >> 2] = ja;
m = b + (L << 3) | 0;
ka = c[m >> 2] | 0;
_ = c[m + 4 >> 2] | 0;
m = o + 8 | 0;
c[m >> 2] = ka;
c[m + 4 >> 2] = _;
m = b + (ja << 3) | 0;
ja = c[m >> 2] | 0;
Y = c[m + 4 >> 2] | 0;
m = o + 16 | 0;
c[m >> 2] = ja;
c[m + 4 >> 2] = Y;
m = b + (L << 3) + 64 | 0;
ia = c[m >> 2] | 0;
ha = c[m + 4 >> 2] | 0;
m = o + 24 | 0;
c[m >> 2] = ia;
c[m + 4 >> 2] = ha;
qa = Y;
ra = ja;
sa = _;
ta = ka;
ua = ia;
va = ha;
wa = n;
xa = L;
ya = 0
}
} else
$ = 75
} else
$ =
75;
if (($ | 0) == 75) {
oa = n;
pa = d + 56 | 0;
$ = 77
}
do if (($ | 0) == 77) {
c[pa >> 2] = 1;
L = c[na >> 2] | 0;
if ((L | 0) > 1) {
y = +g[b + 216 >> 2];
T = +g[b + 212 >> 2];
ha = 0;
A = T * +g[b + 64 >> 2] + y * +g[b + 68 >> 2];
ia = 1;
while (1) {
Z = T * +g[b + (ia << 3) + 64 >> 2] + y * +g[b + (ia << 3) + 68 >> 2];
ka = Z < A;
_ = ka ? ia : ha;
ia = ia + 1 | 0;
if ((ia | 0) >= (L | 0)) {
za = _;
break
} else {
ha = _;
A = ka ? Z : A
}
}
} else
za = 0;
ha = za + 1 | 0;
ia = (ha | 0) < (L | 0) ? ha : 0;
ha = b + (za << 3) | 0;
ka = c[ha + 4 >> 2] | 0;
_ = n;
c[_ >> 2] = c[ha >> 2];
c[_ + 4 >> 2] = ka;
ka = n + 8 | 0;
a[ka >> 0] = 0;
a[ka + 1 >> 0] = za;
a[ka + 2 >> 0] = 1;
a[ka + 3 >> 0] = 0;
ka = b + (ia << 3) | 0;
_ = c[ka + 4 >> 2] | 0;
ha = n + 12 | 0;
c[ha >>
2] = c[ka >> 2];
c[ha + 4 >> 2] = _;
_ = n + 20 | 0;
a[_ >> 0] = 0;
a[_ + 1 >> 0] = ia;
a[_ + 2 >> 0] = 1;
a[_ + 3 >> 0] = 0;
if ((a[ma >> 0] | 0) == 0) {
c[o >> 2] = 1;
c[o + 4 >> 2] = 0;
_ = G;
ia = c[_ >> 2] | 0;
ha = c[_ + 4 >> 2] | 0;
_ = o + 8 | 0;
c[_ >> 2] = ia;
c[_ + 4 >> 2] = ha;
_ = D;
ka = c[_ >> 2] | 0;
ja = c[_ + 4 >> 2] | 0;
_ = o + 16 | 0;
c[_ >> 2] = ka;
c[_ + 4 >> 2] = ja;
_ = (g[k >> 2] = -+g[N >> 2], c[k >> 2] | 0);
Y = (g[k >> 2] = -+g[M >> 2], c[k >> 2] | 0);
m = o + 24 | 0;
c[m >> 2] = _;
c[m + 4 >> 2] = Y;
qa = ja;
ra = ka;
sa = ha;
ta = ia;
ua = _;
va = Y;
wa = oa;
xa = 1;
ya = 1;
break
} else {
c[o >> 2] = 0;
c[o + 4 >> 2] = 1;
Y = D;
_ = c[Y >> 2] | 0;
ia = c[Y + 4 >> 2] | 0;
Y = o + 8 | 0;
c[Y >> 2] = _;
c[Y + 4 >> 2] = ia;
Y = G;
ha = c[Y >>
2] | 0;
ka = c[Y + 4 >> 2] | 0;
Y = o + 16 | 0;
c[Y >> 2] = ha;
c[Y + 4 >> 2] = ka;
Y = N;
ja = c[Y >> 2] | 0;
m = c[Y + 4 >> 2] | 0;
Y = o + 24 | 0;
c[Y >> 2] = ja;
c[Y + 4 >> 2] = m;
qa = ka;
ra = ha;
sa = ia;
ta = _;
ua = ja;
va = m;
wa = oa;
xa = 0;
ya = 1;
break
}
}
while (0);
A = (c[k >> 2] = va, +g[k >> 2]);
y = (c[k >> 2] = ua, +g[k >> 2]);
T = (c[k >> 2] = ta, +g[k >> 2]);
Z = (c[k >> 2] = sa, +g[k >> 2]);
U = (c[k >> 2] = ra, +g[k >> 2]);
w = (c[k >> 2] = qa, +g[k >> 2]);
qa = o + 32 | 0;
ra = o + 24 | 0;
sa = o + 28 | 0;
ea = -y;
g[qa >> 2] = A;
g[o + 36 >> 2] = ea;
ta = o + 44 | 0;
y = -A;
va = ta;
g[va >> 2] = y;
c[va + 4 >> 2] = ua;
va = o + 8 | 0;
oa = o + 12 | 0;
v = A * T + Z * ea;
g[o + 40 >> 2] = v;
N = o + 52 | 0;
g[N >> 2] = U * y + (c[k >>
2] = ua, +g[k >> 2]) * w;
if ((kf(p, wa, qa, v, xa) | 0) < 2) {
i = l;
return
}
if ((kf(q, p, ta, +g[N >> 2], c[o + 4 >> 2] | 0) | 0) < 2) {
i = l;
return
}
N = d + 40 | 0;
if (ya) {
ya = ra;
ta = c[ya >> 2] | 0;
p = c[ya + 4 >> 2] | 0;
ya = N;
c[ya >> 2] = ta;
c[ya + 4 >> 2] = p;
p = va;
ya = c[p >> 2] | 0;
xa = c[p + 4 >> 2] | 0;
p = d + 48 | 0;
c[p >> 2] = ya;
c[p + 4 >> 2] = xa;
v = (c[k >> 2] = ya, +g[k >> 2]);
w = (c[k >> 2] = ta, +g[k >> 2]);
y = +g[oa >> 2];
U = +g[sa >> 2];
ea = +g[q >> 2];
Z = +g[q + 4 >> 2];
T = +g[la >> 2];
if (!((ea - v) * w + (Z - y) * U <= T)) {
Aa = T;
Ba = 0
} else {
T = ea - +g[r >> 2];
ea = Z - +g[C >> 2];
Z = +g[f >> 2];
A = +g[j >> 2];
u = +(T * Z + ea * A);
da = +(Z * ea - T * A);
ta = d;
g[ta >> 2] = u;
g[ta + 4 >> 2] = da;
c[d + 16 >> 2] = c[q + 8 >> 2];
Aa = +g[la >> 2];
Ba = 1
}
da = +g[q + 12 >> 2];
u = +g[q + 16 >> 2];
if (!((da - v) * w + (u - y) * U <= Aa))
Ca = Ba;
else {
Aa = da - +g[r >> 2];
da = u - +g[C >> 2];
u = +g[f >> 2];
U = +g[j >> 2];
y = +(Aa * u + da * U);
w = +(u * da - Aa * U);
j = d + (Ba * 20 | 0) | 0;
g[j >> 2] = y;
g[j + 4 >> 2] = w;
c[d + (Ba * 20 | 0) + 16 >> 2] = c[q + 20 >> 2];
Ca = Ba + 1 | 0
}
} else {
Ba = c[o >> 2] | 0;
o = h + (Ba << 3) + 84 | 0;
j = c[o + 4 >> 2] | 0;
f = N;
c[f >> 2] = c[o >> 2];
c[f + 4 >> 2] = j;
j = h + (Ba << 3) + 20 | 0;
Ba = c[j + 4 >> 2] | 0;
h = d + 48 | 0;
c[h >> 2] = c[j >> 2];
c[h + 4 >> 2] = Ba;
w = +g[va >> 2];
y = +g[ra >> 2];
U = +g[oa >> 2];
Aa = +g[sa >> 2];
da = +g[la >> 2];
if (!((+g[q >>
2] - w) * y + (+g[q + 4 >> 2] - U) * Aa <= da)) {
Da = da;
Ea = 0
} else {
sa = q;
oa = c[sa + 4 >> 2] | 0;
ra = d;
c[ra >> 2] = c[sa >> 2];
c[ra + 4 >> 2] = oa;
oa = q + 8 | 0;
ra = d + 16 | 0;
a[ra + 2 >> 0] = a[oa + 3 >> 0] | 0;
a[ra + 3 >> 0] = a[oa + 2 >> 0] | 0;
a[ra >> 0] = a[oa + 1 >> 0] | 0;
a[ra + 1 >> 0] = a[oa >> 0] | 0;
Da = +g[la >> 2];
Ea = 1
}
la = q + 12 | 0;
if (!((+g[la >> 2] - w) * y + (+g[q + 16 >> 2] - U) * Aa <= Da))
Ca = Ea;
else {
oa = la;
la = c[oa + 4 >> 2] | 0;
ra = d + (Ea * 20 | 0) | 0;
c[ra >> 2] = c[oa >> 2];
c[ra + 4 >> 2] = la;
la = q + 20 | 0;
q = d + (Ea * 20 | 0) + 16 | 0;
a[q + 2 >> 0] = a[la + 3 >> 0] | 0;
a[q + 3 >> 0] = a[la + 2 >> 0] | 0;
a[q >> 0] = a[la + 1 >> 0] | 0;
a[q + 1 >> 0] = a[la >> 0] | 0;
Ca = Ea + 1 | 0
}
}
c[aa >>
2] = Ca;
i = l;
return
}
function ef(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0;
d = i;
c[a >> 2] = 0;
e = a + 4 | 0;
c[e >> 2] = -1;
f = a + 8 | 0;
g[f >> 2] = -3.4028234663852886E38;
h = +g[b + 216 >> 2];
j = +g[b + 212 >> 2];
k = c[b + 128 >> 2] | 0;
if ((k | 0) <= 0) {
i = d;
return
}
l = +g[b + 164 >> 2];
m = +g[b + 168 >> 2];
n = +g[b + 172 >> 2];
o = +g[b + 176 >> 2];
p = +g[b + 244 >> 2];
q = b + 228 | 0;
r = b + 232 | 0;
s = b + 236 | 0;
t = b + 240 | 0;
u = -3.4028234663852886E38;
v = 0;
while (1) {
w = +g[b + (v << 3) + 64 >> 2];
x = -w;
y = -+g[b + (v << 3) + 68 >>
2];
z = +g[b + (v << 3) >> 2];
A = +g[b + (v << 3) + 4 >> 2];
B = (z - l) * x + (A - m) * y;
C = (z - n) * x + (A - o) * y;
D = B < C ? B : C;
if (D > p)
break;
if (!(h * w + j * y >= 0))
if (D > u ? !((x - +g[q >> 2]) * j + (y - +g[r >> 2]) * h < -.03490658849477768) : 0)
E = 8;
else
F = u;
else if (D > u ? !((x - +g[s >> 2]) * j + (y - +g[t >> 2]) * h < -.03490658849477768) : 0)
E = 8;
else
F = u;
if ((E | 0) == 8) {
E = 0;
c[a >> 2] = 2;
c[e >> 2] = v;
g[f >> 2] = D;
F = D
}
G = v + 1 | 0;
if ((G | 0) < (k | 0)) {
u = F;
v = G
} else {
E = 10;
break
}
}
if ((E | 0) == 10) {
i = d;
return
}
c[a >> 2] = 2;
c[e >> 2] = v;
g[f >> 2] = D;
i = d;
return
}
function ff(a, b, c, d, e) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
var f = 0;
f =
i;
i = i + 256 | 0;
df(f, a, b, c, d, e);
i = f;
return
}
function gf(b, d, e, f, h) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
h = h | 0;
var j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0;
j = i;
i = i + 96 | 0;
k = j + 92 | 0;
l = j + 88 | 0;
m = j;
n = j + 80 | 0;
o = j + 56 | 0;
p = j + 32 | 0;
q = j + 24 | 0;
r = b + 60 | 0;
c[r >> 2] = 0;
s = +g[d + 8 >> 2] + +g[f + 8 >> 2];
c[k >> 2] = 0;
t = +hf(k, d, e, f, h);
if (t > s) {
i = j;
return
}
c[l >> 2] = 0;
u = +hf(l, f, h, d, e);
if (u > s) {
i = j;
return
}
if (u > t + 5.000000237487257E-4) {
t = +g[h >> 2];
u =
+g[h + 4 >> 2];
v = +g[h + 8 >> 2];
w = +g[h + 12 >> 2];
x = +g[e >> 2];
y = +g[e + 4 >> 2];
z = +g[e + 8 >> 2];
A = +g[e + 12 >> 2];
B = c[l >> 2] | 0;
c[b + 56 >> 2] = 2;
C = t;
D = u;
E = w;
F = v;
G = A;
H = z;
I = x;
J = y;
K = B;
L = 1;
M = f;
N = d
} else {
y = +g[e >> 2];
x = +g[e + 4 >> 2];
z = +g[e + 8 >> 2];
A = +g[e + 12 >> 2];
v = +g[h >> 2];
w = +g[h + 4 >> 2];
u = +g[h + 8 >> 2];
t = +g[h + 12 >> 2];
h = c[k >> 2] | 0;
c[b + 56 >> 2] = 1;
C = y;
D = x;
E = A;
F = z;
G = t;
H = u;
I = v;
J = w;
K = h;
L = 0;
M = d;
N = f
}
f = c[N + 148 >> 2] | 0;
w = +g[M + (K << 3) + 84 >> 2];
v = +g[M + (K << 3) + 88 >> 2];
u = E * w - F * v;
t = F * w + E * v;
v = G * u + H * t;
w = G * t - H * u;
if ((f | 0) > 0) {
d = 0;
h = 0;
u = 3.4028234663852886E38;
while (1) {
t = v * +g[N +
(d << 3) + 84 >> 2] + w * +g[N + (d << 3) + 88 >> 2];
k = t < u;
e = k ? d : h;
d = d + 1 | 0;
if ((d | 0) == (f | 0)) {
O = e;
break
} else {
h = e;
u = k ? t : u
}
}
} else
O = 0;
h = O + 1 | 0;
d = (h | 0) < (f | 0) ? h : 0;
u = +g[N + (O << 3) + 20 >> 2];
w = +g[N + (O << 3) + 24 >> 2];
v = +(I + (G * u - H * w));
t = +(J + (H * u + G * w));
h = m;
g[h >> 2] = v;
g[h + 4 >> 2] = t;
h = K & 255;
f = m + 8 | 0;
a[f >> 0] = h;
a[f + 1 >> 0] = O;
a[f + 2 >> 0] = 1;
a[f + 3 >> 0] = 0;
t = +g[N + (d << 3) + 20 >> 2];
v = +g[N + (d << 3) + 24 >> 2];
w = +(I + (G * t - H * v));
u = +(J + (H * t + G * v));
N = m + 12 | 0;
g[N >> 2] = w;
g[N + 4 >> 2] = u;
N = m + 20 | 0;
a[N >> 0] = h;
a[N + 1 >> 0] = d;
a[N + 2 >> 0] = 1;
a[N + 3 >> 0] = 0;
N = K + 1 | 0;
d = (N | 0) < (c[M + 148 >> 2] | 0) ? N : 0;
N =
M + (K << 3) + 20 | 0;
u = +g[N >> 2];
w = +g[N + 4 >> 2];
N = M + (d << 3) + 20 | 0;
v = +g[N >> 2];
t = +g[N + 4 >> 2];
z = v - u;
A = t - w;
x = +Q(+(z * z + A * A));
if (x < 1.1920928955078125E-7) {
P = z;
R = A
} else {
y = 1 / x;
P = z * y;
R = A * y
}
y = E * P - F * R;
A = E * R + F * P;
g[n >> 2] = y;
g[n + 4 >> 2] = A;
z = -y;
x = C + (E * u - F * w);
S = D + (F * u + E * w);
T = x * A + S * z;
g[q >> 2] = z;
g[q + 4 >> 2] = -A;
if ((kf(o, m, q, s - (x * y + S * A), K) | 0) < 2) {
i = j;
return
}
if ((kf(p, o, n, s + ((C + (E * v - F * t)) * y + (D + (F * v + E * t)) * A), d) | 0) < 2) {
i = j;
return
}
E = +R;
R = +-P;
d = b + 40 | 0;
g[d >> 2] = E;
g[d + 4 >> 2] = R;
R = +((u + v) * .5);
v = +((w + t) * .5);
d = b + 48 | 0;
g[d >> 2] = R;
g[d + 4 >> 2] = v;
v = +g[p >> 2];
R =
+g[p + 4 >> 2];
d = !(A * v + R * z - T <= s);
if (L << 24 >> 24 == 0) {
if (d)
U = 0;
else {
t = v - I;
w = R - J;
u = +(G * t + H * w);
E = +(G * w - H * t);
L = b;
g[L >> 2] = u;
g[L + 4 >> 2] = E;
c[b + 16 >> 2] = c[p + 8 >> 2];
U = 1
}
E = +g[p + 12 >> 2];
u = +g[p + 16 >> 2];
if (!(A * E + u * z - T <= s))
V = U;
else {
t = E - I;
E = u - J;
u = +(G * t + H * E);
w = +(G * E - H * t);
L = b + (U * 20 | 0) | 0;
g[L >> 2] = u;
g[L + 4 >> 2] = w;
c[b + (U * 20 | 0) + 16 >> 2] = c[p + 20 >> 2];
V = U + 1 | 0
}
} else {
if (d)
W = 0;
else {
w = v - I;
v = R - J;
R = +(G * w + H * v);
u = +(G * v - H * w);
d = b;
g[d >> 2] = R;
g[d + 4 >> 2] = u;
d = b + 16 | 0;
U = c[p + 8 >> 2] | 0;
c[d >> 2] = U;
a[d >> 0] = U >>> 8;
a[d + 1 >> 0] = U;
a[d + 2 >> 0] = U >>> 24;
a[d + 3 >> 0] = U >>> 16;
W = 1
}
u =
+g[p + 12 >> 2];
R = +g[p + 16 >> 2];
if (!(A * u + R * z - T <= s))
V = W;
else {
s = u - I;
I = R - J;
J = +(G * s + H * I);
R = +(G * I - H * s);
U = b + (W * 20 | 0) | 0;
g[U >> 2] = J;
g[U + 4 >> 2] = R;
U = b + (W * 20 | 0) + 16 | 0;
b = c[p + 20 >> 2] | 0;
c[U >> 2] = b;
a[U >> 0] = b >>> 8;
a[U + 1 >> 0] = b;
a[U + 2 >> 0] = b >>> 24;
a[U + 3 >> 0] = b >>> 16;
V = W + 1 | 0
}
}
c[r >> 2] = V;
i = j;
return
}
function hf(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0;
h = i;
j = c[b + 148 >> 2] | 0;
k = c[e + 148 >> 2] | 0;
l = +g[f + 12 >> 2];
m = +g[d + 8 >> 2];
n = +g[f + 8 >> 2];
o = +g[d + 12 >> 2];
p = l * m - n * o;
q =
m * n + l * o;
o = +g[d >> 2] - +g[f >> 2];
m = +g[d + 4 >> 2] - +g[f + 4 >> 2];
r = l * o + n * m;
s = l * m - n * o;
if ((j | 0) <= 0) {
t = 0;
u = -3.4028234663852886E38;
c[a >> 2] = t;
i = h;
return +u
}
if ((k | 0) > 0) {
v = 0;
w = 0;
x = -3.4028234663852886E38
} else {
f = 0;
d = 0;
o = -3.4028234663852886E38;
while (1) {
y = o < 3.4028234663852886E38;
n = y ? 3.4028234663852886E38 : o;
z = y ? d : f;
d = d + 1 | 0;
if ((d | 0) == (j | 0)) {
t = z;
u = n;
break
} else {
f = z;
o = n
}
}
c[a >> 2] = t;
i = h;
return +u
}
while (1) {
o = +g[b + (w << 3) + 84 >> 2];
n = +g[b + (w << 3) + 88 >> 2];
m = q * o - p * n;
l = p * o + q * n;
n = +g[b + (w << 3) + 20 >> 2];
o = +g[b + (w << 3) + 24 >> 2];
A = r + (q * n - p * o);
B = s + (p *
n + q * o);
f = 0;
o = 3.4028234663852886E38;
do {
n = m * (+g[e + (f << 3) + 20 >> 2] - A) + l * (+g[e + (f << 3) + 24 >> 2] - B);
o = n < o ? n : o;
f = f + 1 | 0
} while ((f | 0) != (k | 0));
f = o > x;
B = f ? o : x;
d = f ? w : v;
w = w + 1 | 0;
if ((w | 0) == (j | 0)) {
t = d;
u = B;
break
} else {
v = d;
x = B
}
}
c[a >> 2] = t;
i = h;
return +u
}
function jf(a, b, d, e, f, h) {
a = a | 0;
b = b | 0;
d = d | 0;
e = +e;
f = f | 0;
h = +h;
var j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0;
j = i;
k = b + 60 | 0;
if ((c[k >> 2] | 0) == 0) {
i = j;
return
}
l = c[b + 56 >> 2] | 0;
if ((l | 0) == 2) {
m = f + 12 | 0;
n = +g[m >> 2];
o = +g[b + 40 >> 2];
p = f + 8 | 0;
q = +g[p >> 2];
r = +g[b + 44 >> 2];
s = n * o - q * r;
t = o * q + n * r;
r = +s;
n = +t;
u = a;
g[u >> 2] = r;
g[u + 4 >> 2] = n;
n = +g[m >> 2];
r = +g[b + 48 >> 2];
q = +g[p >> 2];
o = +g[b + 52 >> 2];
v = +g[f >> 2] + (n * r - q * o);
w = r * q + n * o + +g[f + 4 >> 2];
if ((c[k >> 2] | 0) > 0) {
p = d + 12 | 0;
m = d + 8 | 0;
u = d + 4 | 0;
x = a + 4 | 0;
o = s;
n = t;
y = 0;
while (1) {
q = +g[p >> 2];
r = +g[b + (y * 20 | 0) >> 2];
z = +g[m >> 2];
A = +g[b + (y * 20 | 0) + 4 >> 2];
B = +g[d >> 2] + (q * r - z * A);
C = r * z + q * A + +g[u >> 2];
A = h - (o * (B - v) + (C - w) * n);
q = B + o * A;
z = C + n * A;
A = B - o * e;
B = C - n * e;
C = +((A + q) * .5);
r = +((B + z) * .5);
D = a + (y << 3) + 8 | 0;
g[D >> 2] = C;
g[D + 4 >> 2] = r;
g[a + (y << 2) + 24 >> 2] = +g[a >> 2] * (A - q) +
+g[x >> 2] * (B - z);
y = y + 1 | 0;
z = +g[a >> 2];
B = +g[x >> 2];
if ((y | 0) >= (c[k >> 2] | 0)) {
E = z;
F = B;
break
} else {
o = z;
n = B
}
}
} else {
E = s;
F = t
}
t = +-E;
E = +-F;
y = a;
g[y >> 2] = t;
g[y + 4 >> 2] = E;
i = j;
return
} else if ((l | 0) == 0) {
g[a >> 2] = 1;
y = a + 4 | 0;
g[y >> 2] = 0;
E = +g[d + 12 >> 2];
t = +g[b + 48 >> 2];
F = +g[d + 8 >> 2];
s = +g[b + 52 >> 2];
n = +g[d >> 2] + (E * t - F * s);
o = t * F + E * s + +g[d + 4 >> 2];
s = +g[f + 12 >> 2];
E = +g[b >> 2];
F = +g[f + 8 >> 2];
t = +g[b + 4 >> 2];
w = +g[f >> 2] + (s * E - F * t);
v = E * F + s * t + +g[f + 4 >> 2];
t = n - w;
s = o - v;
if (t * t + s * s > 1.4210854715202004E-14) {
s = w - n;
t = v - o;
F = +s;
E = +t;
x = a;
g[x >> 2] = F;
g[x + 4 >> 2] = E;
E = +Q(+(s *
s + t * t));
if (E < 1.1920928955078125E-7) {
G = s;
H = t
} else {
F = 1 / E;
E = s * F;
g[a >> 2] = E;
s = t * F;
g[y >> 2] = s;
G = E;
H = s
}
} else {
G = 1;
H = 0
}
s = n + G * e;
n = o + H * e;
o = w - G * h;
w = v - H * h;
v = +((s + o) * .5);
E = +((n + w) * .5);
y = a + 8 | 0;
g[y >> 2] = v;
g[y + 4 >> 2] = E;
g[a + 24 >> 2] = G * (o - s) + H * (w - n);
i = j;
return
} else if ((l | 0) == 1) {
l = d + 12 | 0;
n = +g[l >> 2];
w = +g[b + 40 >> 2];
y = d + 8 | 0;
H = +g[y >> 2];
s = +g[b + 44 >> 2];
o = n * w - H * s;
G = w * H + n * s;
s = +o;
n = +G;
x = a;
g[x >> 2] = s;
g[x + 4 >> 2] = n;
n = +g[l >> 2];
s = +g[b + 48 >> 2];
H = +g[y >> 2];
w = +g[b + 52 >> 2];
E = +g[d >> 2] + (n * s - H * w);
v = s * H + n * w + +g[d + 4 >> 2];
if ((c[k >> 2] | 0) <= 0) {
i = j;
return
}
d =
f + 12 | 0;
y = f + 8 | 0;
l = f + 4 | 0;
x = a + 4 | 0;
w = o;
o = G;
u = 0;
while (1) {
G = +g[d >> 2];
n = +g[b + (u * 20 | 0) >> 2];
H = +g[y >> 2];
s = +g[b + (u * 20 | 0) + 4 >> 2];
F = +g[f >> 2] + (G * n - H * s);
t = n * H + G * s + +g[l >> 2];
s = e - (w * (F - E) + (t - v) * o);
G = F + w * s;
H = t + o * s;
s = F - w * h;
F = t - o * h;
t = +((s + G) * .5);
n = +((F + H) * .5);
m = a + (u << 3) + 8 | 0;
g[m >> 2] = t;
g[m + 4 >> 2] = n;
g[a + (u << 2) + 24 >> 2] = +g[a >> 2] * (s - G) + +g[x >> 2] * (F - H);
m = u + 1 | 0;
if ((m | 0) >= (c[k >> 2] | 0))
break;
w = +g[a >> 2];
o = +g[x >> 2];
u = m
}
i = j;
return
} else {
i = j;
return
}
}
function kf(b, d, e, f, h) {
b = b | 0;
d = d | 0;
e = e | 0;
f = +f;
h = h | 0;
var j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q =
0,
r = 0,
s = 0,
t = 0,
u = 0;
j = i;
k = +g[e >> 2];
l = +g[e + 4 >> 2];
e = d + 4 | 0;
m = k * +g[d >> 2] + l * +g[e >> 2] - f;
n = d + 12 | 0;
o = d + 16 | 0;
p = k * +g[n >> 2] + l * +g[o >> 2] - f;
if (!(m <= 0))
q = 0;
else {
c[b + 0 >> 2] = c[d + 0 >> 2];
c[b + 4 >> 2] = c[d + 4 >> 2];
c[b + 8 >> 2] = c[d + 8 >> 2];
q = 1
}
if (!(p <= 0))
r = q;
else {
s = q + 1 | 0;
t = b + (q * 12 | 0) | 0;
c[t + 0 >> 2] = c[n + 0 >> 2];
c[t + 4 >> 2] = c[n + 4 >> 2];
c[t + 8 >> 2] = c[n + 8 >> 2];
r = s
}
if (!(m * p < 0)) {
u = r;
i = j;
return u | 0
}
f = m / (m - p);
p = +g[d >> 2];
m = +g[e >> 2];
l = +(p + f * (+g[n >> 2] - p));
p = +(m + f * (+g[o >> 2] - m));
o = b + (r * 12 | 0) | 0;
g[o >> 2] = l;
g[o + 4 >> 2] = p;
o = b + (r * 12 | 0) + 8 | 0;
a[o >> 0] = h;
a[o + 1 >> 0] = a[d +
9 >> 0] | 0;
a[o + 2 >> 0] = 0;
a[o + 3 >> 0] = 1;
u = r + 1 | 0;
i = j;
return u | 0
}
function lf(d, e, f, h, j, k) {
d = d | 0;
e = e | 0;
f = f | 0;
h = h | 0;
j = j | 0;
k = k | 0;
var l = 0,
m = 0,
n = 0,
o = 0;
l = i;
i = i + 128 | 0;
m = l + 36 | 0;
n = l + 24 | 0;
o = l;
c[m + 16 >> 2] = 0;
c[m + 20 >> 2] = 0;
g[m + 24 >> 2] = 0;
c[m + 44 >> 2] = 0;
c[m + 48 >> 2] = 0;
g[m + 52 >> 2] = 0;
be(m, d, e);
be(m + 28 | 0, f, h);
h = m + 56 | 0;
c[h + 0 >> 2] = c[j + 0 >> 2];
c[h + 4 >> 2] = c[j + 4 >> 2];
c[h + 8 >> 2] = c[j + 8 >> 2];
c[h + 12 >> 2] = c[j + 12 >> 2];
j = m + 72 | 0;
c[j + 0 >> 2] = c[k + 0 >> 2];
c[j + 4 >> 2] = c[k + 4 >> 2];
c[j + 8 >> 2] = c[k + 8 >> 2];
c[j + 12 >> 2] = c[k + 12 >> 2];
a[m + 88 >> 0] = 1;
b[n + 4 >> 1] = 0;
de(o, n, m);
i = l;
return +g[o +
16 >> 2] < 1.1920928955078125E-6 | 0
}
function mf(a, b, d, e, f, g) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
var h = 0,
j = 0;
h = i;
j = a + 40 | 0;
c[j >> 2] = b;
c[a + 44 >> 2] = d;
c[a + 48 >> 2] = e;
c[a + 28 >> 2] = 0;
c[a + 36 >> 2] = 0;
c[a + 32 >> 2] = 0;
c[a >> 2] = f;
c[a + 4 >> 2] = g;
c[a + 8 >> 2] = Ym(f, b << 2) | 0;
c[a + 12 >> 2] = Ym(c[a >> 2] | 0, d << 2) | 0;
c[a + 16 >> 2] = Ym(c[a >> 2] | 0, e << 2) | 0;
c[a + 24 >> 2] = Ym(c[a >> 2] | 0, (c[j >> 2] | 0) * 12 | 0) | 0;
c[a + 20 >> 2] = Ym(c[a >> 2] | 0, (c[j >> 2] | 0) * 12 | 0) | 0;
i = h;
return
}
function nf(a) {
a = a | 0;
var b = 0;
b = i;
_m(c[a >> 2] | 0, c[a + 20 >> 2] | 0);
_m(c[a >> 2] | 0, c[a + 24 >> 2] | 0);
_m(c[a >> 2] | 0, c[a +
16 >> 2] | 0);
_m(c[a >> 2] | 0, c[a + 12 >> 2] | 0);
_m(c[a >> 2] | 0, c[a + 8 >> 2] | 0);
i = b;
return
}
function of(d, e, f, h, j) {
d = d | 0;
e = e | 0;
f = f | 0;
h = h | 0;
j = j | 0;
var l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
R = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0;
l = i;
i = i + 176 | 0;
m = l + 148 | 0;
n = l;
o = l + 112 | 0;
p = l + 64 | 0;
q = l + 8 | 0;
Km(n);
r = +g[f >> 2];
s = d + 28 | 0;
if ((c[s >> 2] | 0) > 0) {
t = d + 8 | 0;
u = h + 4 | 0;
v = d + 20 | 0;
w = d + 24 | 0;
x = 0;
do {
y = c[(c[t >> 2] | 0) + (x << 2) >> 2] | 0;
z = y + 60 | 0;
A = c[z >> 2] | 0;
B = c[z + 4 >> 2] | 0;
C = +g[y + 72 >> 2];
z = y +
80 | 0;
D = +g[z >> 2];
E = +g[z + 4 >> 2];
F = +g[y + 88 >> 2];
z = y + 52 | 0;
c[z >> 2] = A;
c[z + 4 >> 2] = B;
g[y + 68 >> 2] = C;
if ((c[y >> 2] | 0) == 2) {
G = +g[y + 156 >> 2];
H = +g[y + 136 >> 2];
I = 1 / (r * +g[y + 148 >> 2] + 1);
J = (D + r * (G * +g[h >> 2] + H * +g[y + 92 >> 2])) * I;
K = (E + r * (G * +g[u >> 2] + H * +g[y + 96 >> 2])) * I;
L = (F + r * +g[y + 144 >> 2] * +g[y + 100 >> 2]) * (1 / (r * +g[y + 152 >> 2] + 1))
} else {
J = D;
K = E;
L = F
}
y = (c[v >> 2] | 0) + (x * 12 | 0) | 0;
c[y >> 2] = A;
c[y + 4 >> 2] = B;
g[(c[v >> 2] | 0) + (x * 12 | 0) + 8 >> 2] = C;
C = +J;
F = +K;
B = (c[w >> 2] | 0) + (x * 12 | 0) | 0;
g[B >> 2] = C;
g[B + 4 >> 2] = F;
g[(c[w >> 2] | 0) + (x * 12 | 0) + 8 >> 2] = L;
x = x + 1 | 0
} while ((x | 0) < (c[s >> 2] |
0));
M = w;
N = v
} else {
M = d + 24 | 0;
N = d + 20 | 0
}
c[o + 0 >> 2] = c[f + 0 >> 2];
c[o + 4 >> 2] = c[f + 4 >> 2];
c[o + 8 >> 2] = c[f + 8 >> 2];
c[o + 12 >> 2] = c[f + 12 >> 2];
c[o + 16 >> 2] = c[f + 16 >> 2];
c[o + 20 >> 2] = c[f + 20 >> 2];
c[o + 24 >> 2] = c[f + 24 >> 2];
v = c[N >> 2] | 0;
c[o + 28 >> 2] = v;
w = c[M >> 2] | 0;
c[o + 32 >> 2] = w;
c[p + 0 >> 2] = c[f + 0 >> 2];
c[p + 4 >> 2] = c[f + 4 >> 2];
c[p + 8 >> 2] = c[f + 8 >> 2];
c[p + 12 >> 2] = c[f + 12 >> 2];
c[p + 16 >> 2] = c[f + 16 >> 2];
c[p + 20 >> 2] = c[f + 20 >> 2];
c[p + 24 >> 2] = c[f + 24 >> 2];
x = d + 12 | 0;
c[p + 28 >> 2] = c[x >> 2];
u = d + 36 | 0;
c[p + 32 >> 2] = c[u >> 2];
c[p + 36 >> 2] = v;
c[p + 40 >> 2] = w;
c[p + 44 >> 2] = c[d >> 2];
Ki(q, p);
Mi(q);
if ((a[f +
24 >> 0] | 0) != 0)
Ni(q);
p = d + 32 | 0;
if ((c[p >> 2] | 0) > 0) {
w = d + 16 | 0;
v = 0;
do {
h = c[(c[w >> 2] | 0) + (v << 2) >> 2] | 0;
gb[c[(c[h >> 2] | 0) + 32 >> 2] & 63](h, o);
v = v + 1 | 0
} while ((v | 0) < (c[p >> 2] | 0))
}
g[e + 12 >> 2] = +Mm(n);
v = f + 12 | 0;
if ((c[v >> 2] | 0) > 0) {
w = d + 16 | 0;
h = 0;
do {
if ((c[p >> 2] | 0) > 0) {
t = 0;
do {
B = c[(c[w >> 2] | 0) + (t << 2) >> 2] | 0;
gb[c[(c[B >> 2] | 0) + 36 >> 2] & 63](B, o);
t = t + 1 | 0
} while ((t | 0) < (c[p >> 2] | 0))
}
Oi(q);
h = h + 1 | 0
} while ((h | 0) < (c[v >> 2] | 0))
}
Pi(q);
g[e + 16 >> 2] = +Mm(n);
if ((c[s >> 2] | 0) > 0) {
v = c[M >> 2] | 0;
h = 0;
do {
w = c[N >> 2] | 0;
t = w + (h * 12 | 0) | 0;
B = t;
L = +g[B >> 2];
K = +g[B + 4 >> 2];
J = +g[w + (h *
12 | 0) + 8 >> 2];
w = v + (h * 12 | 0) | 0;
F = +g[w >> 2];
C = +g[w + 4 >> 2];
E = +g[v + (h * 12 | 0) + 8 >> 2];
D = r * F;
I = r * C;
H = D * D + I * I;
if (H > 4) {
I = 2 / +Q(+H);
O = F * I;
P = C * I
} else {
O = F;
P = C
}
C = r * E;
if (C * C > 2.4674012660980225) {
if (C > 0)
R = C;
else
R = -C;
U = E * (1.5707963705062866 / R)
} else
U = E;
E = +(L + r * O);
L = +(K + r * P);
w = t;
g[w >> 2] = E;
g[w + 4 >> 2] = L;
g[(c[N >> 2] | 0) + (h * 12 | 0) + 8 >> 2] = J + r * U;
J = +O;
L = +P;
w = (c[M >> 2] | 0) + (h * 12 | 0) | 0;
g[w >> 2] = J;
g[w + 4 >> 2] = L;
v = c[M >> 2] | 0;
g[v + (h * 12 | 0) + 8 >> 2] = U;
h = h + 1 | 0
} while ((h | 0) < (c[s >> 2] | 0))
}
h = f + 16 | 0;
a:
do if ((c[h >> 2] | 0) > 0) {
f = d + 16 | 0;
v = 0;
while (1) {
w = Qi(q) | 0;
if ((c[p >>
2] | 0) > 0) {
t = 0;
B = 1;
while (1) {
y = c[(c[f >> 2] | 0) + (t << 2) >> 2] | 0;
A = B & (nb[c[(c[y >> 2] | 0) + 40 >> 2] & 31](y, o) | 0);
t = t + 1 | 0;
if ((t | 0) >= (c[p >> 2] | 0)) {
V = A;
break
} else
B = A
}
} else
V = 1;
v = v + 1 | 0;
if (w & V) {
W = 0;
break a
}
if ((v | 0) >= (c[h >> 2] | 0)) {
W = 1;
break
}
}
} else
W = 1;
while (0);
if ((c[s >> 2] | 0) > 0) {
h = d + 8 | 0;
V = 0;
do {
p = c[(c[h >> 2] | 0) + (V << 2) >> 2] | 0;
o = (c[N >> 2] | 0) + (V * 12 | 0) | 0;
v = c[o >> 2] | 0;
f = c[o + 4 >> 2] | 0;
o = p + 60 | 0;
c[o >> 2] = v;
c[o + 4 >> 2] = f;
U = +g[(c[N >> 2] | 0) + (V * 12 | 0) + 8 >> 2];
g[p + 72 >> 2] = U;
o = (c[M >> 2] | 0) + (V * 12 | 0) | 0;
B = c[o + 4 >> 2] | 0;
t = p + 80 | 0;
c[t >> 2] = c[o >> 2];
c[t + 4 >> 2] = B;
g[p + 88 >> 2] = +g[(c[M >> 2] | 0) + (V * 12 | 0) + 8 >> 2];
P = +T(+U);
g[p + 20 >> 2] = P;
O = +S(+U);
g[p + 24 >> 2] = O;
U = +g[p + 44 >> 2];
R = +g[p + 48 >> 2];
L = (c[k >> 2] = v, +g[k >> 2]) - (O * U - P * R);
J = (c[k >> 2] = f, +g[k >> 2]) - (P * U + O * R);
R = +L;
L = +J;
f = p + 12 | 0;
g[f >> 2] = R;
g[f + 4 >> 2] = L;
V = V + 1 | 0
} while ((V | 0) < (c[s >> 2] | 0))
}
g[e + 20 >> 2] = +Mm(n);
n = c[q + 44 >> 2] | 0;
e = d + 4 | 0;
if ((c[e >> 2] | 0) != 0 ? (c[u >> 2] | 0) > 0 : 0) {
V = m + 16 | 0;
M = 0;
do {
N = c[(c[x >> 2] | 0) + (M << 2) >> 2] | 0;
h = c[n + (M * 156 | 0) + 148 >> 2] | 0;
c[V >> 2] = h;
if ((h | 0) > 0) {
f = 0;
do {
g[m + (f << 2) >> 2] = +g[n + (M * 156 | 0) + (f * 36 | 0) + 16 >> 2];
g[m + (f << 2) + 8 >> 2] = +g[n + (M * 156 |
0) + (f * 36 | 0) + 20 >> 2];
f = f + 1 | 0
} while ((f | 0) != (h | 0))
}
h = c[e >> 2] | 0;
ib[c[(c[h >> 2] | 0) + 36 >> 2] & 7](h, N, m);
M = M + 1 | 0
} while ((M | 0) < (c[u >> 2] | 0))
}
if (!j) {
Li(q);
i = l;
return
}
j = c[s >> 2] | 0;
u = (j | 0) > 0;
if (u) {
M = c[d + 8 >> 2] | 0;
m = 0;
L = 3.4028234663852886E38;
while (1) {
e = c[M + (m << 2) >> 2] | 0;
do if ((c[e >> 2] | 0) == 0)
X = L;
else {
if ((!((b[e + 4 >> 1] & 4) == 0) ? (R = +g[e + 88 >> 2], !(R * R > .001218469929881394)) : 0) ? (R = +g[e + 80 >> 2], J = +g[e + 84 >> 2], !(R * R + J * J > 9.999999747378752E-5)) : 0) {
n = e + 160 | 0;
J = r + +g[n >> 2];
g[n >> 2] = J;
X = L < J ? L : J;
break
}
g[e + 160 >> 2] = 0;
X = 0
}
while (0);
m = m + 1 | 0;
if ((m |
0) >= (j | 0)) {
Y = X;
break
} else
L = X
}
} else
Y = 3.4028234663852886E38;
if (!(Y >= .5) | W | u ^ 1) {
Li(q);
i = l;
return
}
u = d + 8 | 0;
d = 0;
do {
W = c[(c[u >> 2] | 0) + (d << 2) >> 2] | 0;
j = W + 4 | 0;
b[j >> 1] = b[j >> 1] & 65533;
g[W + 160 >> 2] = 0;
j = W + 80 | 0;
c[j + 0 >> 2] = 0;
c[j + 4 >> 2] = 0;
c[j + 8 >> 2] = 0;
c[j + 12 >> 2] = 0;
c[j + 16 >> 2] = 0;
c[j + 20 >> 2] = 0;
d = d + 1 | 0
} while ((d | 0) < (c[s >> 2] | 0));
Li(q);
i = l;
return
}
function pf(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0;
f = i;
i = i + 128 | 0;
h = f +
104 | 0;
j = f + 56 | 0;
k = f;
l = a + 28 | 0;
if ((c[l >> 2] | 0) > 0) {
m = a + 8 | 0;
n = a + 20 | 0;
o = a + 24 | 0;
p = 0;
do {
q = c[(c[m >> 2] | 0) + (p << 2) >> 2] | 0;
r = q + 60 | 0;
s = c[r + 4 >> 2] | 0;
t = (c[n >> 2] | 0) + (p * 12 | 0) | 0;
c[t >> 2] = c[r >> 2];
c[t + 4 >> 2] = s;
g[(c[n >> 2] | 0) + (p * 12 | 0) + 8 >> 2] = +g[q + 72 >> 2];
s = q + 80 | 0;
t = c[s + 4 >> 2] | 0;
r = (c[o >> 2] | 0) + (p * 12 | 0) | 0;
c[r >> 2] = c[s >> 2];
c[r + 4 >> 2] = t;
t = c[o >> 2] | 0;
g[t + (p * 12 | 0) + 8 >> 2] = +g[q + 88 >> 2];
p = p + 1 | 0
} while ((p | 0) < (c[l >> 2] | 0));
u = n;
v = t
} else {
u = a + 20 | 0;
v = c[a + 24 >> 2] | 0
}
n = a + 12 | 0;
c[j + 28 >> 2] = c[n >> 2];
p = a + 36 | 0;
c[j + 32 >> 2] = c[p >> 2];
c[j + 44 >> 2] = c[a >> 2];
c[j + 0 >> 2] = c[b +
0 >> 2];
c[j + 4 >> 2] = c[b + 4 >> 2];
c[j + 8 >> 2] = c[b + 8 >> 2];
c[j + 12 >> 2] = c[b + 12 >> 2];
c[j + 16 >> 2] = c[b + 16 >> 2];
c[j + 20 >> 2] = c[b + 20 >> 2];
c[j + 24 >> 2] = c[b + 24 >> 2];
c[j + 36 >> 2] = c[u >> 2];
o = a + 24 | 0;
c[j + 40 >> 2] = v;
Ki(k, j);
j = b + 16 | 0;
a:
do if ((c[j >> 2] | 0) > 0) {
v = 0;
do {
v = v + 1 | 0;
if (Si(k, d, e) | 0)
break a
} while ((v | 0) < (c[j >> 2] | 0))
}
while (0);
j = a + 8 | 0;
v = (c[u >> 2] | 0) + (d * 12 | 0) | 0;
m = c[v + 4 >> 2] | 0;
t = (c[(c[j >> 2] | 0) + (d << 2) >> 2] | 0) + 52 | 0;
c[t >> 2] = c[v >> 2];
c[t + 4 >> 2] = m;
m = c[u >> 2] | 0;
t = c[j >> 2] | 0;
g[(c[t + (d << 2) >> 2] | 0) + 68 >> 2] = +g[m + (d * 12 | 0) + 8 >> 2];
d = m + (e * 12 | 0) | 0;
m = c[d + 4 >> 2] | 0;
v =
(c[t + (e << 2) >> 2] | 0) + 52 | 0;
c[v >> 2] = c[d >> 2];
c[v + 4 >> 2] = m;
g[(c[(c[j >> 2] | 0) + (e << 2) >> 2] | 0) + 68 >> 2] = +g[(c[u >> 2] | 0) + (e * 12 | 0) + 8 >> 2];
Mi(k);
e = b + 12 | 0;
if ((c[e >> 2] | 0) > 0) {
m = 0;
do {
Oi(k);
m = m + 1 | 0
} while ((m | 0) < (c[e >> 2] | 0))
}
w = +g[b >> 2];
if ((c[l >> 2] | 0) > 0) {
b = 0;
do {
e = c[u >> 2] | 0;
m = e + (b * 12 | 0) | 0;
v = m;
x = +g[v >> 2];
y = +g[v + 4 >> 2];
z = +g[e + (b * 12 | 0) + 8 >> 2];
e = c[o >> 2] | 0;
v = e + (b * 12 | 0) | 0;
A = +g[v >> 2];
B = +g[v + 4 >> 2];
C = +g[e + (b * 12 | 0) + 8 >> 2];
D = w * A;
E = w * B;
F = D * D + E * E;
if (F > 4) {
E = 2 / +Q(+F);
G = A * E;
H = B * E
} else {
G = A;
H = B
}
B = w * C;
if (B * B > 2.4674012660980225) {
if (B > 0)
I = B;
else
I =
-B;
J = C * (1.5707963705062866 / I)
} else
J = C;
C = x + w * G;
x = y + w * H;
y = z + w * J;
z = +C;
B = +x;
e = m;
g[e >> 2] = z;
g[e + 4 >> 2] = B;
g[(c[u >> 2] | 0) + (b * 12 | 0) + 8 >> 2] = y;
A = +G;
E = +H;
e = (c[o >> 2] | 0) + (b * 12 | 0) | 0;
g[e >> 2] = A;
g[e + 4 >> 2] = E;
g[(c[o >> 2] | 0) + (b * 12 | 0) + 8 >> 2] = J;
e = c[(c[j >> 2] | 0) + (b << 2) >> 2] | 0;
m = e + 60 | 0;
g[m >> 2] = z;
g[m + 4 >> 2] = B;
g[e + 72 >> 2] = y;
m = e + 80 | 0;
g[m >> 2] = A;
g[m + 4 >> 2] = E;
g[e + 88 >> 2] = J;
E = +T(+y);
g[e + 20 >> 2] = E;
A = +S(+y);
g[e + 24 >> 2] = A;
y = +g[e + 44 >> 2];
B = +g[e + 48 >> 2];
z = +(C - (A * y - E * B));
C = +(x - (E * y + A * B));
m = e + 12 | 0;
g[m >> 2] = z;
g[m + 4 >> 2] = C;
b = b + 1 | 0
} while ((b | 0) < (c[l >> 2] |
0))
}
l = c[k + 44 >> 2] | 0;
b = a + 4 | 0;
if ((c[b >> 2] | 0) == 0) {
Li(k);
i = f;
return
}
if ((c[p >> 2] | 0) <= 0) {
Li(k);
i = f;
return
}
a = h + 16 | 0;
j = 0;
do {
o = c[(c[n >> 2] | 0) + (j << 2) >> 2] | 0;
u = c[l + (j * 156 | 0) + 148 >> 2] | 0;
c[a >> 2] = u;
if ((u | 0) > 0) {
m = 0;
do {
g[h + (m << 2) >> 2] = +g[l + (j * 156 | 0) + (m * 36 | 0) + 16 >> 2];
g[h + (m << 2) + 8 >> 2] = +g[l + (j * 156 | 0) + (m * 36 | 0) + 20 >> 2];
m = m + 1 | 0
} while ((m | 0) != (u | 0))
}
u = c[b >> 2] | 0;
ib[c[(c[u >> 2] | 0) + 36 >> 2] & 7](u, o, h);
j = j + 1 | 0
} while ((j | 0) < (c[p >> 2] | 0));
Li(k);
i = f;
return
}
function qf(a, c, d) {
a = a | 0;
c = c | 0;
d = d | 0;
var e = 0,
f = 0;
a = i;
e = b[c + 36 >> 1] | 0;
if (!(e << 16 >> 16 ==
0 ? 1 : e << 16 >> 16 != (b[d + 36 >> 1] | 0))) {
f = e << 16 >> 16 > 0;
i = a;
return f | 0
}
if ((b[d + 32 >> 1] & b[c + 34 >> 1]) << 16 >> 16 == 0) {
f = 0;
i = a;
return f | 0
}
f = (b[d + 34 >> 1] & b[c + 32 >> 1]) << 16 >> 16 != 0;
i = a;
return f | 0
}
function rf(a) {
a = a | 0;
return
}
function sf(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function tf(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
return 1
}
function uf(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
return 1
}
function vf(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
d = i;
vh(a, b);
c[a >> 2] = 904;
e = b + 20 | 0;
f = c[e >> 2] | 0;
h = c[e + 4 >> 2] | 0;
e = a + 76 | 0;
c[e >>
2] = f;
c[e + 4 >> 2] = h;
e = c[a + 52 >> 2] | 0;
j = (c[k >> 2] = f, +g[k >> 2]) - +g[e + 12 >> 2];
l = (c[k >> 2] = h, +g[k >> 2]) - +g[e + 16 >> 2];
m = +g[e + 24 >> 2];
n = +g[e + 20 >> 2];
o = +(j * m + l * n);
p = +(m * l - j * n);
e = a + 68 | 0;
g[e >> 2] = o;
g[e + 4 >> 2] = p;
g[a + 104 >> 2] = +g[b + 28 >> 2];
g[a + 96 >> 2] = 0;
g[a + 100 >> 2] = 0;
g[a + 84 >> 2] = +g[b + 32 >> 2];
g[a + 88 >> 2] = +g[b + 36 >> 2];
g[a + 92 >> 2] = 0;
g[a + 108 >> 2] = 0;
i = d;
return
}
function wf(a, d) {
a = a | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0;
e = i;
f = c[a + 52 >> 2] | 0;
h = f + 4 | 0;
j = b[h >> 1] | 0;
if ((j & 2) == 0 ? (k = j & 65535, (k & 2 | 0) == 0) : 0) {
b[h >> 1] = k | 2;
g[f + 160 >> 2] = 0
}
f = d;
d = c[f + 4 >> 2] | 0;
k = a + 76 |
0;
c[k >> 2] = c[f >> 2];
c[k + 4 >> 2] = d;
i = e;
return
}
function xf(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
U = 0,
V = 0;
e = i;
f = c[b + 52 >> 2] | 0;
h = c[f + 8 >> 2] | 0;
j = b + 116 | 0;
c[j >> 2] = h;
l = f + 44 | 0;
m = c[l >> 2] | 0;
n = c[l + 4 >> 2] | 0;
l = b + 128 | 0;
c[l >> 2] = m;
c[l + 4 >> 2] = n;
o = +g[f + 136 >> 2];
g[b + 136 >> 2] = o;
p = +g[f + 144 >> 2];
g[b + 140 >> 2] = p;
l = c[d + 28 >> 2] | 0;
q = l + (h * 12 | 0) | 0;
r = +g[q >> 2];
s = +g[q + 4 >> 2];
t = +g[l + (h * 12 | 0) + 8 >> 2];
l = d + 32 | 0;
q = c[l >> 2] |
0;
u = q + (h * 12 | 0) | 0;
v = +g[u >> 2];
w = +g[u + 4 >> 2];
x = +g[q + (h * 12 | 0) + 8 >> 2];
y = +T(+t);
z = +S(+t);
t = +g[f + 132 >> 2];
A = +g[b + 84 >> 2] * 6.2831854820251465;
B = +g[d >> 2];
C = B * t * A * A;
D = B * (A * t * 2 * +g[b + 88 >> 2] + C);
t = (c[k >> 2] = m, +g[k >> 2]);
A = (c[k >> 2] = n, +g[k >> 2]);
if (D != 0)
E = 1 / D;
else
E = D;
g[b + 108 >> 2] = E;
D = C * E;
g[b + 92 >> 2] = D;
C = +g[b + 68 >> 2] - t;
t = +g[b + 72 >> 2] - A;
A = z * C - y * t;
B = y * C + z * t;
t = +A;
z = +B;
n = b + 120 | 0;
g[n >> 2] = t;
g[n + 4 >> 2] = z;
z = E + (o + B * p * B);
t = p * A;
C = B * t;
y = E + (o + A * t);
t = z * y - C * C;
if (t != 0)
F = 1 / t;
else
F = t;
t = C * F;
g[b + 144 >> 2] = y * F;
g[b + 148 >> 2] = t;
g[b + 152 >> 2] = t;
g[b + 156 >>
2] = z * F;
n = b + 160 | 0;
F = r + A - +g[b + 76 >> 2];
r = s + B - +g[b + 80 >> 2];
s = +F;
z = +r;
m = n;
g[m >> 2] = s;
g[m + 4 >> 2] = z;
g[n >> 2] = D * F;
g[b + 164 >> 2] = D * r;
r = x * .9800000190734863;
n = b + 96 | 0;
if ((a[d + 24 >> 0] | 0) == 0) {
g[n >> 2] = 0;
g[b + 100 >> 2] = 0;
G = v;
H = w;
I = r;
J = c[l >> 2] | 0;
K = J + (h * 12 | 0) | 0;
L = +G;
M = +H;
N = K;
O = N;
g[O >> 2] = L;
P = N + 4 | 0;
Q = P;
g[Q >> 2] = M;
R = c[j >> 2] | 0;
U = c[l >> 2] | 0;
V = U + (R * 12 | 0) + 8 | 0;
g[V >> 2] = I;
i = e;
return
} else {
x = +g[d + 8 >> 2];
D = x * +g[n >> 2];
g[n >> 2] = D;
n = b + 100 | 0;
F = x * +g[n >> 2];
g[n >> 2] = F;
G = v + o * D;
H = w + F * o;
I = r + p * (F * A - D * B);
J = c[l >> 2] | 0;
K = J + (h * 12 | 0) | 0;
L = +G;
M = +H;
N = K;
O = N;
g[O >>
2] = L;
P = N + 4 | 0;
Q = P;
g[Q >> 2] = M;
R = c[j >> 2] | 0;
U = c[l >> 2] | 0;
V = U + (R * 12 | 0) + 8 | 0;
g[V >> 2] = I;
i = e;
return
}
}
function yf(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0;
d = i;
e = a + 116 | 0;
f = c[e >> 2] | 0;
h = b + 32 | 0;
j = c[h >> 2] | 0;
k = j + (f * 12 | 0) | 0;
l = k;
m = +g[l >> 2];
n = +g[l + 4 >> 2];
o = +g[j + (f * 12 | 0) + 8 >> 2];
p = +g[a + 124 >> 2];
q = +g[a + 120 >> 2];
r = +g[a + 108 >> 2];
f = a + 96 | 0;
s = +g[f >> 2];
j = a + 100 | 0;
t = +g[j >> 2];
u = -(m - o * p + +g[a + 160 >> 2] + r * s);
v = -(n + o * q + +g[a + 164 >> 2] + r * t);
r = +g[a + 148 >> 2] * u + +g[a + 156 >> 2] * v;
l =
f;
w = +g[l >> 2];
x = +g[l + 4 >> 2];
y = s + (+g[a + 144 >> 2] * u + +g[a + 152 >> 2] * v);
g[f >> 2] = y;
v = r + t;
g[j >> 2] = v;
t = +g[b >> 2] * +g[a + 104 >> 2];
r = v * v + y * y;
if (r > t * t) {
u = t / +Q(+r);
r = y * u;
g[f >> 2] = r;
t = u * v;
g[j >> 2] = t;
z = r;
A = t
} else {
z = y;
A = v
}
v = z - w;
w = A - x;
x = +g[a + 136 >> 2];
A = o + +g[a + 140 >> 2] * (w * q - v * p);
p = +(m + v * x);
v = +(n + w * x);
a = k;
g[a >> 2] = p;
g[a + 4 >> 2] = v;
g[(c[h >> 2] | 0) + ((c[e >> 2] | 0) * 12 | 0) + 8 >> 2] = A;
i = d;
return
}
function zf(a, b) {
a = a | 0;
b = b | 0;
return 1
}
function Af(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0;
d = b + 76 | 0;
b = c[d + 4 >> 2] | 0;
e = a;
c[e >> 2] = c[d >> 2];
c[e + 4 >> 2] = b;
return
}
function Bf(a,
b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0;
d = c[b + 52 >> 2] | 0;
e = +g[d + 24 >> 2];
f = +g[b + 68 >> 2];
h = +g[d + 20 >> 2];
i = +g[b + 72 >> 2];
j = f * h + e * i + +g[d + 16 >> 2];
g[a >> 2] = +g[d + 12 >> 2] + (e * f - h * i);
g[a + 4 >> 2] = j;
return
}
function Cf(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
var d = 0;
d = +g[b + 100 >> 2] * c;
g[a >> 2] = +g[b + 96 >> 2] * c;
g[a + 4 >> 2] = d;
return
}
function Df(a, b) {
a = a | 0;
b = +b;
return +(b * 0)
}
function Ef(a, b) {
a = a | 0;
b = b | 0;
var c = 0;
c = a + 76 | 0;
g[c >> 2] = +g[c >> 2] - +g[b >> 2];
c = a + 80 | 0;
g[c >> 2] = +g[c >> 2] - +g[b + 4 >> 2];
return
}
function Ff(a) {
a = a | 0;
a = i;
i = i + 16 | 0;
Rm(1008, a);
i = a;
return
}
function Gf(a) {
a = a | 0;
return
}
function Hf(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function If(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0;
e = i;
c[a + 8 >> 2] = b;
c[a + 12 >> 2] = d;
f = d + 12 | 0;
h = +g[f >> 2];
j = h - +g[b + 12 >> 2];
h = +g[f + 4 >> 2] - +g[b + 16 >> 2];
k = +g[b + 24 >> 2];
l = +g[b + 20 >> 2];
m = +(j * k + h * l);
n = +(k * h - j * l);
f = a + 20 | 0;
g[f >> 2] = m;
g[f + 4 >> 2] = n;
g[a + 28 >> 2] = +g[d + 72 >> 2] - +g[b + 72 >> 2];
i = e;
return
}
function cm(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0;
f = i;
h = a + 4 | 0;
j = c[(c[h >> 2] | 0) + 88 >> 2] | 0;
k = c[j + (d << 2) >> 2] | c[j + (b << 2) >> 2] | c[j + (e << 2) >> 2];
if ((k & 16 | 0) == 0) {
i = f;
return
}
j = c[a + 8 >> 2] | 0;
if (!(lb[c[(c[j >> 2] | 0) + 16 >> 2] & 7](j, b, d, e) | 0)) {
i = f;
return
}
j = c[h >> 2] | 0;
h = c[j + 96 >> 2] | 0;
a = h + (b << 3) | 0;
l = +g[a >> 2];
m = h + (d << 3) | 0;
n = +g[m >> 2];
o = l - n;
p = h + (b << 3) + 4 | 0;
q = +g[p >> 2];
r = h + (d << 3) + 4 | 0;
s = +g[r >> 2];
t = q - s;
u = h + (e << 3) | 0;
v = +g[u >> 2];
w = n - v;
x = h + (e << 3) + 4 | 0;
n = +g[x >> 2];
y = s - n;
s = v - l;
l = n - q;
q = +g[j + 40 >> 2] * 4;
if (o * o + t * t > q) {
i = f;
return
}
if (w * w + y * y > q) {
i = f;
return
}
if (s *
s + l * l > q) {
i = f;
return
}
h = c[j + 144 >> 2] | 0;
z = c[h + (b << 2) >> 2] | 0;
A = c[h + (d << 2) >> 2] | 0;
B = c[h + (e << 2) >> 2] | 0;
h = j + 264 | 0;
C = j + 268 | 0;
D = c[C >> 2] | 0;
E = j + 272 | 0;
F = c[E >> 2] | 0;
if ((D | 0) >= (F | 0) ? (G = (F | 0) == 0 ? 256 : F << 1, (F | 0) < (G | 0)) : 0) {
F = j + 276 | 0;
j = Em(c[F >> 2] | 0, G * 60 | 0) | 0;
H = c[h >> 2] | 0;
if ((H | 0) != 0) {
An(j | 0, H | 0, (c[C >> 2] | 0) * 60 | 0) | 0;
Fm(c[F >> 2] | 0, c[h >> 2] | 0, (c[E >> 2] | 0) * 60 | 0)
}
c[E >> 2] = G;
c[h >> 2] = j;
I = c[C >> 2] | 0
} else
I = D;
c[C >> 2] = I + 1;
C = c[h >> 2] | 0;
c[C + (I * 60 | 0) >> 2] = b;
c[C + (I * 60 | 0) + 4 >> 2] = d;
c[C + (I * 60 | 0) + 8 >> 2] = e;
c[C + (I * 60 | 0) + 12 >> 2] = k;
if ((z | 0) == 0)
J = 1;
else
J =
+g[z + 16 >> 2];
if ((A | 0) == 0)
K = 1;
else
K = +g[A + 16 >> 2];
q = J < K ? J : K;
if ((B | 0) == 0)
L = 1;
else
L = +g[B + 16 >> 2];
g[C + (I * 60 | 0) + 16 >> 2] = q < L ? q : L;
L = +g[a >> 2];
q = +g[p >> 2];
K = (L + +g[m >> 2] + +g[u >> 2]) * .3333333432674408;
J = (q + +g[r >> 2] + +g[x >> 2]) * .3333333432674408;
n = +(L - K);
L = +(q - J);
B = C + (I * 60 | 0) + 20 | 0;
g[B >> 2] = n;
g[B + 4 >> 2] = L;
L = +(+g[m >> 2] - K);
n = +(+g[r >> 2] - J);
B = C + (I * 60 | 0) + 28 | 0;
g[B >> 2] = L;
g[B + 4 >> 2] = n;
n = +(+g[u >> 2] - K);
K = +(+g[x >> 2] - J);
B = C + (I * 60 | 0) + 36 | 0;
g[B >> 2] = n;
g[B + 4 >> 2] = K;
g[C + (I * 60 | 0) + 44 >> 2] = -(o * s + t * l);
g[C + (I * 60 | 0) + 48 >> 2] = -(o * w + t * y);
g[C + (I *
60 | 0) + 52 >> 2] = -(w * s + y * l);
l = +g[a >> 2];
y = +g[r >> 2];
s = +g[p >> 2];
w = +g[m >> 2];
t = +g[x >> 2];
o = +g[u >> 2];
g[C + (I * 60 | 0) + 56 >> 2] = s * o - l * t + (l * y - s * w + (w * t - y * o));
i = f;
return
}
function dm(a) {
a = a | 0;
return
}
function em(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function fm(a, b) {
a = a | 0;
b = b | 0;
return (c[(c[a + 4 >> 2] | 0) + (b << 2) >> 2] & 4096 | 0) != 0 | 0
}
function gm(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
return 1
}
function hm(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
return 1
}
function im(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function jm(a, b) {
a = a | 0;
b = b | 0;
return 1
}
function km(a) {
a =
a | 0;
return
}
function lm(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function mm(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0;
e = i;
f = c[a + 4 >> 2] | 0;
a = (f | 0) <= (b | 0);
b = (f | 0) > (d | 0);
if (a | b) {
i = e;
return b & a | 0
} else {
i = e;
return 1
}
return 0
}
function nm(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
g = 0;
f = i;
g = c[a + 4 >> 2] | 0;
a = (g | 0) > (b | 0);
b = (g | 0) > (d | 0);
if (a | b | (g | 0) > (e | 0)) {
i = f;
return (g | 0) <= (e | 0) | a & b ^ 1 | 0
} else {
i = f;
return 0
}
return 0
}
function om(a) {
a = a | 0;
return
}
function pm(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function qm(a, b) {
a = a | 0;
b = b | 0;
return 0
}
function rm(a) {
a = a | 0;
return 1
}
function sm(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0;
e = i;
f = a + 16 | 0;
if ((c[f >> 2] | 0) <= 0) {
g = 0;
i = e;
return g | 0
}
h = a + 12 | 0;
a = 0;
while (1) {
j = c[(c[h >> 2] | 0) + (a << 2) >> 2] | 0;
a = a + 1 | 0;
if (hb[c[(c[j >> 2] | 0) + 16 >> 2] & 15](j, b, d) | 0) {
g = 1;
k = 5;
break
}
if ((a | 0) >= (c[f >> 2] | 0)) {
g = 0;
k = 5;
break
}
}
if ((k | 0) == 5) {
i = e;
return g | 0
}
return 0
}
function tm(a, b, c, d, e, f) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
f = f | 0;
return
}
function um(a, b, c, d, e) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
return 0
}
function vm(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d |
0;
e = e | 0;
var f = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0;
e = i;
i = i + 16 | 0;
f = e;
g[b >> 2] = 3.4028234663852886E38;
h = b + 4 | 0;
g[h >> 2] = 3.4028234663852886E38;
g[b + 8 >> 2] = -3.4028234663852886E38;
j = b + 12 | 0;
g[j >> 2] = -3.4028234663852886E38;
k = a + 16 | 0;
if ((c[k >> 2] | 0) <= 0) {
i = e;
return
}
l = a + 12 | 0;
a = f + 4 | 0;
m = b + 8 | 0;
n = f + 8 | 0;
o = f + 12 | 0;
p = 0;
do {
q = c[(c[l >> 2] | 0) + (p << 2) >> 2] | 0;
r = bb[c[(c[q >> 2] | 0) + 12 >> 2] & 7](q) | 0;
if ((r | 0) > 0) {
q = 0;
do {
s = c[(c[l >> 2] | 0) + (p << 2) >> 2] | 0;
pb[c[(c[s >> 2] | 0) + 28 >> 2] & 31](s, f, d, q);
t = +g[b >> 2];
u = +g[f >> 2];
v = +g[h >>
2];
w = +g[a >> 2];
x = +(t < u ? t : u);
u = +(v < w ? v : w);
s = b;
g[s >> 2] = x;
g[s + 4 >> 2] = u;
u = +g[m >> 2];
x = +g[n >> 2];
w = +g[j >> 2];
v = +g[o >> 2];
t = +(u > x ? u : x);
x = +(w > v ? w : v);
s = m;
g[s >> 2] = t;
g[s + 4 >> 2] = x;
q = q + 1 | 0
} while ((q | 0) != (r | 0))
}
p = p + 1 | 0
} while ((p | 0) < (c[k >> 2] | 0));
i = e;
return
}
function wm(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
return
}
function xm(a) {
a = a | 0;
return
}
function ym(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function zm(a, b) {
a = a | 0;
b = b | 0;
return 0
}
function Am(b, d, e) {
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
g = 0,
h = 0,
j = 0;
f = i;
g = b + 4 | 0;
if ((c[g >> 2] | 0) != (d | 0)) {
h = 0;
i = f;
return h |
0
}
j = c[b + 8 >> 2] | 0;
if (!(hb[c[(c[j >> 2] | 0) + 16 >> 2] & 15](j, b + 12 | 0, (c[d + 96 >> 2] | 0) + (e << 3) | 0) | 0)) {
h = 1;
i = f;
return h | 0
}
d = c[g >> 2] | 0;
Ak(d, e, c[(c[d + 88 >> 2] | 0) + (e << 2) >> 2] | ((a[b + 28 >> 0] | 0) != 0 ? 514 : 2));
e = b + 32 | 0;
c[e >> 2] = (c[e >> 2] | 0) + 1;
h = 1;
i = f;
return h | 0
}
function Bm(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0;
d = b + 4 | 0;
c[(c[b >> 2] | 0) + 4 >> 2] = c[d >> 2];
c[c[d >> 2] >> 2] = c[b >> 2];
c[d >> 2] = b;
c[b >> 2] = b;
e = a + 12 | 0;
c[d >> 2] = c[e >> 2];
c[b >> 2] = a + 8;
c[c[e >> 2] >> 2] = b;
c[e >> 2] = b;
return
}
function Cm(b) {
b = b | 0;
var d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0;
d = i;
e = b + 68 | 0;
c[b + 72 >> 2] = e;
c[e >> 2] =
e;
e = b + 8 | 0;
c[e >> 2] = 128;
c[b + 4 >> 2] = 0;
f = Pm(1024) | 0;
c[b >> 2] = f;
xn(f | 0, 0, c[e >> 2] << 3 | 0) | 0;
e = b + 12 | 0;
b = e + 56 | 0;
do {
c[e >> 2] = 0;
e = e + 4 | 0
} while ((e | 0) < (b | 0));
if ((a[8776] | 0) == 0) {
g = 1;
h = 0
} else {
i = d;
return
}
while (1) {
if ((g | 0) > (c[8072 + (h << 2) >> 2] | 0)) {
e = h + 1 | 0;
a[8128 + g >> 0] = e;
j = e
} else {
a[8128 + g >> 0] = h;
j = h
}
g = g + 1 | 0;
if ((g | 0) == 641)
break;
else
h = j
}
a[8776] = 1;
i = d;
return
}
function Dm(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0;
b = i;
d = a + 4 | 0;
e = c[a >> 2] | 0;
if ((c[d >> 2] | 0) > 0) {
f = e;
g = 0;
while (1) {
Qm(c[f + (g << 3) + 4 >> 2] | 0);
g = g + 1 | 0;
h = c[a >> 2] | 0;
if ((g | 0) >= (c[d >>
2] | 0)) {
j = h;
break
} else
f = h
}
} else
j = e;
Qm(j);
j = a + 68 | 0;
Vm(j);
e = a + 72 | 0;
c[(c[j >> 2] | 0) + 4 >> 2] = c[e >> 2];
c[c[e >> 2] >> 2] = c[j >> 2];
c[e >> 2] = j;
c[j >> 2] = j;
i = b;
return
}
function Em(a, b) {
a = a | 0;
b = b | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0;
e = i;
if ((b | 0) == 0) {
f = 0;
i = e;
return f | 0
}
if ((b | 0) > 640) {
f = Tm(a + 68 | 0, b) | 0;
i = e;
return f | 0
}
g = d[8128 + b >> 0] | 0;
b = a + (g << 2) + 12 | 0;
h = c[b >> 2] | 0;
if ((h | 0) != 0) {
c[b >> 2] = c[h >> 2];
f = h;
i = e;
return f | 0
}
h = a + 4 | 0;
j = c[h >> 2] | 0;
k = a + 8 | 0;
if ((j | 0) == (c[k >> 2] | 0)) {
l = c[a >> 2] | 0;
m = j + 128 | 0;
c[k >> 2] = m;
k = Pm(m << 3) | 0;
c[a >> 2] = k;
An(k | 0, l | 0, c[h >> 2] << 3 | 0) | 0;
xn((c[a >> 2] | 0) + (c[h >> 2] << 3) | 0, 0, 1024) | 0;
Qm(l);
n = c[h >> 2] | 0
} else
n = j;
j = c[a >> 2] | 0;
a = Pm(16384) | 0;
l = j + (n << 3) + 4 | 0;
c[l >> 2] = a;
k = c[8072 + (g << 2) >> 2] | 0;
c[j + (n << 3) >> 2] = k;
n = (16384 / (k | 0) | 0) + -1 | 0;
if ((n | 0) > 0) {
j = a;
g = 0;
while (1) {
m = g;
g = g + 1 | 0;
c[j + (aa(m, k) | 0) >> 2] = j + (aa(g, k) | 0);
m = c[l >> 2] | 0;
if ((g | 0) == (n | 0)) {
o = m;
break
} else
j = m
}
} else
o = a;
c[o + (aa(n, k) | 0) >> 2] = 0;
c[b >> 2] = c[c[l >> 2] >> 2];
c[h >> 2] = (c[h >> 2] | 0) + 1;
f = c[l >> 2] | 0;
i = e;
return f | 0
}
function Fm(a, b, e) {
a = a | 0;
b = b | 0;
e = e | 0;
var f = 0,
g = 0;
f = i;
if ((e | 0) == 0) {
i =
f;
return
}
if ((e | 0) > 640) {
Um(a + 68 | 0, b);
i = f;
return
} else {
g = a + ((d[8128 + e >> 0] | 0) << 2) + 12 | 0;
c[b >> 2] = c[g >> 2];
c[g >> 2] = b;
i = f;
return
}
}
function Gm(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0;
d = +g[b + 16 >> 2];
e = +g[b + 32 >> 2];
f = +g[b + 20 >> 2];
h = +g[b + 28 >> 2];
i = d * e - f * h;
j = +g[b + 24 >> 2];
k = +g[b + 12 >> 2];
l = f * j - e * k;
m = h * k - d * j;
n = +g[b >> 2];
o = +g[b + 4 >> 2];
p = +g[b + 8 >> 2];
q = i * n + o * l + m * p;
if (q != 0)
r = 1 / q;
else
r = q;
q = +g[c >> 2];
s = +g[c + 4 >> 2];
t = +g[c + 8 >> 2];
g[a >> 2] = r * (i * q + s * l + m * t);
g[a + 4 >> 2] = r * ((s * e - t * h) * n + o *
(t * j - e * q) + (h * q - s * j) * p);
g[a + 8 >> 2] = r * ((d * t - f * s) * n + o * (f * q - t * k) + (s * k - d * q) * p);
return
}
function Hm(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0,
k = 0;
d = +g[b >> 2];
e = +g[b + 12 >> 2];
f = +g[b + 4 >> 2];
h = +g[b + 16 >> 2];
i = d * h - e * f;
if (i != 0)
j = 1 / i;
else
j = i;
i = +g[c >> 2];
k = +g[c + 4 >> 2];
g[a >> 2] = j * (h * i - e * k);
g[a + 4 >> 2] = j * (d * k - f * i);
return
}
function Im(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0,
f = 0,
h = 0,
j = 0,
k = 0,
l = 0;
d = i;
e = +g[a >> 2];
f = +g[a + 12 >> 2];
h = +g[a + 4 >> 2];
j = +g[a + 16 >> 2];
k = e * j - f * h;
if (k != 0)
l = 1 / k;
else
l = k;
g[b >> 2] = j * l;
j = -l;
g[b + 12 >> 2] = f * j;
g[b + 8 >> 2] = 0;
g[b + 4 >> 2] = h * j;
g[b + 16 >> 2] = e * l;
a = b + 20 | 0;
c[a + 0 >> 2] = 0;
c[a + 4 >> 2] = 0;
c[a + 8 >> 2] = 0;
c[a + 12 >> 2] = 0;
i = d;
return
}
function Jm(a, b) {
a = a | 0;
b = b | 0;
var c = 0,
d = 0,
e = 0,
f = 0,
h = 0,
i = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0;
c = +g[a + 16 >> 2];
d = +g[a + 32 >> 2];
e = c * d;
f = +g[a + 20 >> 2];
h = +g[a + 28 >> 2];
i = +g[a + 24 >> 2];
j = +g[a + 12 >> 2];
k = d * j;
l = h * j - c * i;
m = +g[a >> 2];
n = (e - f * h) * m + +g[a + 4 >> 2] * (f * i - k) + l * +g[a + 8 >> 2];
if (n != 0)
o = 1 / n;
else
o = n;
g[b >> 2] = o * (e - h * h);
e = o * (i * h - k);
g[b + 4 >> 2] = e;
k = o * l;
g[b + 8 >> 2] = k;
g[b + 12 >> 2] = e;
g[b + 16 >> 2] = o * (m * d - i * i);
d = o * (j * i - m * h);
g[b + 20 >> 2] = d;
g[b + 24 >> 2] = k;
g[b +
28 >> 2] = d;
g[b + 32 >> 2] = o * (m * c - j * j);
return
}
function Km(a) {
a = a | 0;
return
}
function Lm(a) {
a = a | 0;
return
}
function Mm(a) {
a = a | 0;
return 0
}
function Nm(a, b) {
a = a | 0;
b = b | 0;
var c = 0;
b = i;
c = on(a) | 0;
i = b;
return c | 0
}
function Om(a, b) {
a = a | 0;
b = b | 0;
b = i;
pn(a);
i = b;
return
}
function Pm(a) {
a = a | 0;
var b = 0,
d = 0;
b = i;
c[2214] = (c[2214] | 0) + 1;
d = nb[c[2208] & 31](a, c[2212] | 0) | 0;
i = b;
return d | 0
}
function Qm(a) {
a = a | 0;
var b = 0;
b = i;
c[2214] = (c[2214] | 0) + -1;
gb[c[2210] & 63](a, c[2212] | 0);
i = b;
return
}
function Rm(a, b) {
a = a | 0;
b = b | 0;
return
}
function Sm(a) {
a = a | 0;
return a +
43 & -32 | 0
}
function Tm(a, b) {
a = a | 0;
b = b | 0;
var d = 0,
e = 0;
d = i;
e = Pm(b + 44 | 0) | 0;
c[e >> 2] = e;
b = e + 43 & -32;
c[b + -4 >> 2] = e;
c[e + 4 >> 2] = a;
c[e >> 2] = c[a >> 2];
c[(c[a >> 2] | 0) + 4 >> 2] = e;
c[a >> 2] = e;
i = d;
return b | 0
}
function Um(a, b) {
a = a | 0;
b = b | 0;
var d = 0;
a = i;
d = c[b + -4 >> 2] | 0;
b = d + 4 | 0;
c[(c[d >> 2] | 0) + 4 >> 2] = c[b >> 2];
c[c[b >> 2] >> 2] = c[d >> 2];
c[b >> 2] = d;
c[d >> 2] = d;
Qm(d);
i = a;
return
}
function Vm(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0;
b = i;
d = a + 4 | 0;
e = c[d >> 2] | 0;
if ((e | 0) == (a | 0)) {
i = b;
return
} else
f = e;
do {
e = f + 4 | 0;
c[(c[f >> 2] | 0) + 4 >> 2] = c[e >> 2];
c[c[e >> 2] >> 2] = c[f >> 2];
c[e >> 2] = f;
c[f >> 2] = f;
Qm(f);
f = c[d >> 2] | 0
} while ((f | 0) != (a | 0));
i = b;
return
}
function Wm(a) {
a = a | 0;
c[a + 102400 >> 2] = 0;
c[a + 102404 >> 2] = 0;
c[a + 102408 >> 2] = 0;
c[a + 102796 >> 2] = 0;
return
}
function Xm(a) {
a = a | 0;
return
}
function Ym(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0;
e = i;
f = d + 3 & -4;
d = b + 102796 | 0;
g = c[d >> 2] | 0;
h = b + (g * 12 | 0) + 102412 | 0;
c[b + (g * 12 | 0) + 102416 >> 2] = f;
j = b + 102400 | 0;
k = c[j >> 2] | 0;
if ((k + f | 0) > 102400) {
c[h >> 2] = Pm(f) | 0;
a[b + (g * 12 | 0) + 102420 >> 0] = 1
} else {
c[h >> 2] = b + k;
a[b + (g * 12 | 0) + 102420 >> 0] = 0;
c[j >> 2] = (c[j >> 2] | 0) + f
}
j = b + 102404 | 0;
g = (c[j >> 2] |
0) + f | 0;
c[j >> 2] = g;
j = b + 102408 | 0;
b = c[j >> 2] | 0;
c[j >> 2] = (b | 0) > (g | 0) ? b : g;
c[d >> 2] = (c[d >> 2] | 0) + 1;
i = e;
return c[h >> 2] | 0
}
function Zm(b, d, e) {
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0;
d = i;
f = (c[b + 102796 >> 2] | 0) + -1 | 0;
g = b + (f * 12 | 0) + 102412 | 0;
h = b + (f * 12 | 0) + 102416 | 0;
j = e - (c[h >> 2] | 0) | 0;
if ((j | 0) <= 0) {
k = c[g >> 2] | 0;
i = d;
return k | 0
}
l = b + (f * 12 | 0) + 102420 | 0;
do if ((a[l >> 0] | 0) == 0) {
f = b + 102400 | 0;
m = (c[f >> 2] | 0) + j | 0;
if ((m | 0) > 102400) {
n = Pm(e) | 0;
An(n | 0, c[g >> 2] | 0, c[h >> 2] | 0) | 0;
c[f >> 2] = (c[f >> 2] | 0) - (c[h >> 2] | 0);
c[g >> 2] = n;
a[l >> 0] = 1;
break
} else {
c[f >>
2] = m;
m = b + 102404 | 0;
f = (c[m >> 2] | 0) + j | 0;
c[m >> 2] = f;
m = b + 102408 | 0;
n = c[m >> 2] | 0;
c[m >> 2] = (n | 0) > (f | 0) ? n : f;
break
}
} else {
f = Pm(e) | 0;
An(f | 0, c[g >> 2] | 0, c[h >> 2] | 0) | 0;
Qm(c[g >> 2] | 0);
c[g >> 2] = f
}
while (0);
c[h >> 2] = e;
k = c[g >> 2] | 0;
i = d;
return k | 0
}
function _m(b, d) {
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0;
e = i;
f = b + 102796 | 0;
g = c[f >> 2] | 0;
h = g + -1 | 0;
if ((a[b + (h * 12 | 0) + 102420 >> 0] | 0) == 0) {
j = b + (h * 12 | 0) + 102416 | 0;
k = b + 102400 | 0;
c[k >> 2] = (c[k >> 2] | 0) - (c[j >> 2] | 0);
l = j;
m = g
} else {
Qm(d);
l = b + (h * 12 | 0) + 102416 | 0;
m = c[f >> 2] | 0
}
h = b + 102404 | 0;
c[h >> 2] = (c[h >>
2] | 0) - (c[l >> 2] | 0);
c[f >> 2] = m + -1;
i = e;
return
}
function $m(a) {
a = a | 0;
return
}
function an(a) {
a = a | 0;
return
}
function bn(a) {
a = a | 0;
return
}
function cn(a) {
a = a | 0;
return
}
function dn(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function en(a) {
a = a | 0;
var b = 0;
b = i;
sn(a);
i = b;
return
}
function fn(a, b, d) {
a = a | 0;
b = b | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
j = 0;
e = i;
i = i + 64 | 0;
f = e;
if ((a | 0) == (b | 0)) {
g = 1;
i = e;
return g | 0
}
if ((b | 0) == 0) {
g = 0;
i = e;
return g | 0
}
h = jn(b, 8928, 8984, 0) | 0;
if ((h | 0) == 0) {
g = 0;
i = e;
return g | 0
}
b = f + 0 | 0;
j = b + 56 | 0;
do {
c[b >> 2] = 0;
b = b + 4 | 0
} while ((b |
0) < (j | 0));
c[f >> 2] = h;
c[f + 8 >> 2] = a;
c[f + 12 >> 2] = -1;
c[f + 48 >> 2] = 1;
pb[c[(c[h >> 2] | 0) + 28 >> 2] & 31](h, f, c[d >> 2] | 0, 1);
if ((c[f + 24 >> 2] | 0) != 1) {
g = 0;
i = e;
return g | 0
}
c[d >> 2] = c[f + 16 >> 2];
g = 1;
i = e;
return g | 0
}
function gn(b, d, e, f) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0,
h = 0;
g = i;
if ((c[d + 8 >> 2] | 0) != (b | 0)) {
i = g;
return
}
b = d + 16 | 0;
h = c[b >> 2] | 0;
if ((h | 0) == 0) {
c[b >> 2] = e;
c[d + 24 >> 2] = f;
c[d + 36 >> 2] = 1;
i = g;
return
}
if ((h | 0) != (e | 0)) {
e = d + 36 | 0;
c[e >> 2] = (c[e >> 2] | 0) + 1;
c[d + 24 >> 2] = 2;
a[d + 54 >> 0] = 1;
i = g;
return
}
e = d + 24 | 0;
if ((c[e >> 2] | 0) != 2) {
i = g;
return
}
c[e >> 2] = f;
i = g;
return
}
function hn(b, d, e, f) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g = 0,
h = 0;
g = i;
if ((b | 0) != (c[d + 8 >> 2] | 0)) {
h = c[b + 8 >> 2] | 0;
pb[c[(c[h >> 2] | 0) + 28 >> 2] & 31](h, d, e, f);
i = g;
return
}
h = d + 16 | 0;
b = c[h >> 2] | 0;
if ((b | 0) == 0) {
c[h >> 2] = e;
c[d + 24 >> 2] = f;
c[d + 36 >> 2] = 1;
i = g;
return
}
if ((b | 0) != (e | 0)) {
e = d + 36 | 0;
c[e >> 2] = (c[e >> 2] | 0) + 1;
c[d + 24 >> 2] = 2;
a[d + 54 >> 0] = 1;
i = g;
return
}
e = d + 24 | 0;
if ((c[e >> 2] | 0) != 2) {
i = g;
return
}
c[e >> 2] = f;
i = g;
return
}
function jn(d, e, f, g) {
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0;
h = i;
i = i + 64 | 0;
j = h;
k = c[d >> 2] | 0;
l = d + (c[k +
-8 >> 2] | 0) | 0;
m = c[k + -4 >> 2] | 0;
c[j >> 2] = f;
c[j + 4 >> 2] = d;
c[j + 8 >> 2] = e;
c[j + 12 >> 2] = g;
g = j + 16 | 0;
e = j + 20 | 0;
d = j + 24 | 0;
k = j + 28 | 0;
n = j + 32 | 0;
o = j + 40 | 0;
p = (m | 0) == (f | 0);
f = g + 0 | 0;
q = f + 36 | 0;
do {
c[f >> 2] = 0;
f = f + 4 | 0
} while ((f | 0) < (q | 0));
b[g + 36 >> 1] = 0;
a[g + 38 >> 0] = 0;
if (p) {
c[j + 48 >> 2] = 1;
mb[c[(c[m >> 2] | 0) + 20 >> 2] & 7](m, j, l, l, 1, 0);
r = (c[d >> 2] | 0) == 1 ? l : 0;
i = h;
return r | 0
}
cb[c[(c[m >> 2] | 0) + 24 >> 2] & 3](m, j, l, 1, 0);
l = c[j + 36 >> 2] | 0;
if ((l | 0) == 1) {
if ((c[d >> 2] | 0) != 1) {
if ((c[o >> 2] | 0) != 0) {
r = 0;
i = h;
return r | 0
}
if ((c[k >> 2] | 0) != 1) {
r = 0;
i = h;
return r | 0
}
if ((c[n >> 2] | 0) != 1) {
r =
0;
i = h;
return r | 0
}
}
r = c[g >> 2] | 0;
i = h;
return r | 0
} else if ((l | 0) == 0) {
if ((c[o >> 2] | 0) != 1) {
r = 0;
i = h;
return r | 0
}
if ((c[k >> 2] | 0) != 1) {
r = 0;
i = h;
return r | 0
}
r = (c[n >> 2] | 0) == 1 ? c[e >> 2] | 0 : 0;
i = h;
return r | 0
} else {
r = 0;
i = h;
return r | 0
}
return 0
}
function kn(b, d, e, f, g) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
var h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0;
h = i;
if ((b | 0) == (c[d + 8 >> 2] | 0)) {
if ((c[d + 4 >> 2] | 0) != (e | 0)) {
i = h;
return
}
j = d + 28 | 0;
if ((c[j >> 2] | 0) == 1) {
i = h;
return
}
c[j >> 2] = f;
i = h;
return
}
if ((b | 0) != (c[d >> 2] | 0)) {
j = c[b + 8 >> 2] | 0;
cb[c[(c[j >> 2] | 0) + 24 >> 2] & 3](j, d, e, f,
g);
i = h;
return
}
if ((c[d + 16 >> 2] | 0) != (e | 0) ? (j = d + 20 | 0, (c[j >> 2] | 0) != (e | 0)) : 0) {
c[d + 32 >> 2] = f;
k = d + 44 | 0;
if ((c[k >> 2] | 0) == 4) {
i = h;
return
}
l = d + 52 | 0;
a[l >> 0] = 0;
m = d + 53 | 0;
a[m >> 0] = 0;
n = c[b + 8 >> 2] | 0;
mb[c[(c[n >> 2] | 0) + 20 >> 2] & 7](n, d, e, e, 1, g);
if ((a[m >> 0] | 0) != 0) {
if ((a[l >> 0] | 0) == 0) {
o = 1;
p = 13
}
} else {
o = 0;
p = 13
}
do if ((p | 0) == 13) {
c[j >> 2] = e;
l = d + 40 | 0;
c[l >> 2] = (c[l >> 2] | 0) + 1;
if ((c[d + 36 >> 2] | 0) == 1 ? (c[d + 24 >> 2] | 0) == 2 : 0) {
a[d + 54 >> 0] = 1;
if (o)
break
} else
p = 16;
if ((p | 0) == 16 ? o : 0)
break;
c[k >> 2] = 4;
i = h;
return
}
while (0);
c[k >> 2] = 3;
i = h;
return
}
if ((f | 0) != 1) {
i =
h;
return
}
c[d + 32 >> 2] = 1;
i = h;
return
}
function ln(b, d, e, f, g) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
var h = 0;
g = i;
if ((c[d + 8 >> 2] | 0) == (b | 0)) {
if ((c[d + 4 >> 2] | 0) != (e | 0)) {
i = g;
return
}
h = d + 28 | 0;
if ((c[h >> 2] | 0) == 1) {
i = g;
return
}
c[h >> 2] = f;
i = g;
return
}
if ((c[d >> 2] | 0) != (b | 0)) {
i = g;
return
}
if ((c[d + 16 >> 2] | 0) != (e | 0) ? (b = d + 20 | 0, (c[b >> 2] | 0) != (e | 0)) : 0) {
c[d + 32 >> 2] = f;
c[b >> 2] = e;
e = d + 40 | 0;
c[e >> 2] = (c[e >> 2] | 0) + 1;
if ((c[d + 36 >> 2] | 0) == 1 ? (c[d + 24 >> 2] | 0) == 2 : 0)
a[d + 54 >> 0] = 1;
c[d + 44 >> 2] = 4;
i = g;
return
}
if ((f | 0) != 1) {
i = g;
return
}
c[d + 32 >> 2] = 1;
i = g;
return
}
function mn(b,
d, e, f, g, h) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
h = h | 0;
var j = 0,
k = 0,
l = 0;
j = i;
if ((b | 0) != (c[d + 8 >> 2] | 0)) {
k = c[b + 8 >> 2] | 0;
mb[c[(c[k >> 2] | 0) + 20 >> 2] & 7](k, d, e, f, g, h);
i = j;
return
}
a[d + 53 >> 0] = 1;
if ((c[d + 4 >> 2] | 0) != (f | 0)) {
i = j;
return
}
a[d + 52 >> 0] = 1;
f = d + 16 | 0;
h = c[f >> 2] | 0;
if ((h | 0) == 0) {
c[f >> 2] = e;
c[d + 24 >> 2] = g;
c[d + 36 >> 2] = 1;
if (!((g | 0) == 1 ? (c[d + 48 >> 2] | 0) == 1 : 0)) {
i = j;
return
}
a[d + 54 >> 0] = 1;
i = j;
return
}
if ((h | 0) != (e | 0)) {
e = d + 36 | 0;
c[e >> 2] = (c[e >> 2] | 0) + 1;
a[d + 54 >> 0] = 1;
i = j;
return
}
e = d + 24 | 0;
h = c[e >> 2] | 0;
if ((h | 0) == 2) {
c[e >> 2] = g;
l = g
} else
l = h;
if (!((l | 0) ==
1 ? (c[d + 48 >> 2] | 0) == 1 : 0)) {
i = j;
return
}
a[d + 54 >> 0] = 1;
i = j;
return
}
function nn(b, d, e, f, g, h) {
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
h = h | 0;
var j = 0;
h = i;
if ((c[d + 8 >> 2] | 0) != (b | 0)) {
i = h;
return
}
a[d + 53 >> 0] = 1;
if ((c[d + 4 >> 2] | 0) != (f | 0)) {
i = h;
return
}
a[d + 52 >> 0] = 1;
f = d + 16 | 0;
b = c[f >> 2] | 0;
if ((b | 0) == 0) {
c[f >> 2] = e;
c[d + 24 >> 2] = g;
c[d + 36 >> 2] = 1;
if (!((g | 0) == 1 ? (c[d + 48 >> 2] | 0) == 1 : 0)) {
i = h;
return
}
a[d + 54 >> 0] = 1;
i = h;
return
}
if ((b | 0) != (e | 0)) {
e = d + 36 | 0;
c[e >> 2] = (c[e >> 2] | 0) + 1;
a[d + 54 >> 0] = 1;
i = h;
return
}
e = d + 24 | 0;
b = c[e >> 2] | 0;
if ((b | 0) == 2) {
c[e >> 2] = g;
j = g
} else
j = b;
if (!((j |
0) == 1 ? (c[d + 48 >> 2] | 0) == 1 : 0)) {
i = h;
return
}
a[d + 54 >> 0] = 1;
i = h;
return
}
function on(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0,
L = 0,
M = 0,
N = 0,
O = 0,
P = 0,
Q = 0,
R = 0,
S = 0,
T = 0,
U = 0,
V = 0,
W = 0,
X = 0,
Y = 0,
Z = 0,
_ = 0,
$ = 0,
aa = 0,
ba = 0,
ca = 0,
da = 0,
ea = 0,
fa = 0,
ga = 0,
ha = 0,
ia = 0,
ja = 0,
ka = 0,
la = 0,
ma = 0,
na = 0,
oa = 0,
pa = 0,
qa = 0,
ra = 0,
sa = 0,
ta = 0,
ua = 0,
va = 0,
wa = 0,
xa = 0,
ya = 0,
za = 0,
Aa = 0,
Ba = 0,
Ca = 0,
Ea = 0,
Fa = 0,
Ha = 0,
Ia = 0,
Ja = 0,
Ka = 0,
La = 0;
b = i;
do if (a >>> 0 < 245) {
if (a >>> 0 <
11)
d = 16;
else
d = a + 11 & -8;
e = d >>> 3;
f = c[2284] | 0;
g = f >>> e;
if ((g & 3 | 0) != 0) {
h = (g & 1 ^ 1) + e | 0;
j = h << 1;
k = 9176 + (j << 2) | 0;
l = 9176 + (j + 2 << 2) | 0;
j = c[l >> 2] | 0;
m = j + 8 | 0;
n = c[m >> 2] | 0;
do if ((k | 0) != (n | 0)) {
if (n >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
o = n + 12 | 0;
if ((c[o >> 2] | 0) == (j | 0)) {
c[o >> 2] = k;
c[l >> 2] = n;
break
} else
Ua()
} else
c[2284] = f & ~(1 << h);
while (0);
n = h << 3;
c[j + 4 >> 2] = n | 3;
l = j + (n | 4) | 0;
c[l >> 2] = c[l >> 2] | 1;
p = m;
i = b;
return p | 0
}
if (d >>> 0 > (c[9144 >> 2] | 0) >>> 0) {
if ((g | 0) != 0) {
l = 2 << e;
n = g << e & (l | 0 - l);
l = (n & 0 - n) + -1 | 0;
n = l >>> 12 & 16;
k = l >>> n;
l = k >>> 5 & 8;
o = k >>> l;
k = o >>> 2 &
4;
q = o >>> k;
o = q >>> 1 & 2;
r = q >>> o;
q = r >>> 1 & 1;
s = (l | n | k | o | q) + (r >>> q) | 0;
q = s << 1;
r = 9176 + (q << 2) | 0;
o = 9176 + (q + 2 << 2) | 0;
q = c[o >> 2] | 0;
k = q + 8 | 0;
n = c[k >> 2] | 0;
do if ((r | 0) != (n | 0)) {
if (n >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
l = n + 12 | 0;
if ((c[l >> 2] | 0) == (q | 0)) {
c[l >> 2] = r;
c[o >> 2] = n;
break
} else
Ua()
} else
c[2284] = f & ~(1 << s);
while (0);
f = s << 3;
n = f - d | 0;
c[q + 4 >> 2] = d | 3;
o = q + d | 0;
c[q + (d | 4) >> 2] = n | 1;
c[q + f >> 2] = n;
f = c[9144 >> 2] | 0;
if ((f | 0) != 0) {
r = c[9156 >> 2] | 0;
e = f >>> 3;
f = e << 1;
g = 9176 + (f << 2) | 0;
m = c[2284] | 0;
j = 1 << e;
if ((m & j | 0) != 0) {
e = 9176 + (f + 2 << 2) | 0;
h = c[e >> 2] | 0;
if (h >>> 0 <
(c[9152 >> 2] | 0) >>> 0)
Ua();
else {
t = e;
u = h
}
} else {
c[2284] = m | j;
t = 9176 + (f + 2 << 2) | 0;
u = g
}
c[t >> 2] = r;
c[u + 12 >> 2] = r;
c[r + 8 >> 2] = u;
c[r + 12 >> 2] = g
}
c[9144 >> 2] = n;
c[9156 >> 2] = o;
p = k;
i = b;
return p | 0
}
o = c[9140 >> 2] | 0;
if ((o | 0) != 0) {
n = (o & 0 - o) + -1 | 0;
o = n >>> 12 & 16;
g = n >>> o;
n = g >>> 5 & 8;
r = g >>> n;
g = r >>> 2 & 4;
f = r >>> g;
r = f >>> 1 & 2;
j = f >>> r;
f = j >>> 1 & 1;
m = c[9440 + ((n | o | g | r | f) + (j >>> f) << 2) >> 2] | 0;
f = (c[m + 4 >> 2] & -8) - d | 0;
j = m;
r = m;
while (1) {
m = c[j + 16 >> 2] | 0;
if ((m | 0) == 0) {
g = c[j + 20 >> 2] | 0;
if ((g | 0) == 0)
break;
else
v = g
} else
v = m;
m = (c[v + 4 >> 2] & -8) - d | 0;
g = m >>> 0 < f >>> 0;
f = g ? m : f;
j = v;
r = g ? v : r
}
j = c[9152 >> 2] | 0;
if (r >>> 0 < j >>> 0)
Ua();
k = r + d | 0;
if (!(r >>> 0 < k >>> 0))
Ua();
q = c[r + 24 >> 2] | 0;
s = c[r + 12 >> 2] | 0;
do if ((s | 0) == (r | 0)) {
g = r + 20 | 0;
m = c[g >> 2] | 0;
if ((m | 0) == 0) {
o = r + 16 | 0;
n = c[o >> 2] | 0;
if ((n | 0) == 0) {
w = 0;
break
} else {
x = n;
y = o
}
} else {
x = m;
y = g
}
while (1) {
g = x + 20 | 0;
m = c[g >> 2] | 0;
if ((m | 0) != 0) {
x = m;
y = g;
continue
}
g = x + 16 | 0;
m = c[g >> 2] | 0;
if ((m | 0) == 0)
break;
else {
x = m;
y = g
}
}
if (y >>> 0 < j >>> 0)
Ua();
else {
c[y >> 2] = 0;
w = x;
break
}
} else {
g = c[r + 8 >> 2] | 0;
if (g >>> 0 < j >>> 0)
Ua();
m = g + 12 | 0;
if ((c[m >> 2] | 0) != (r | 0))
Ua();
o = s + 8 | 0;
if ((c[o >> 2] | 0) == (r | 0)) {
c[m >> 2] =
s;
c[o >> 2] = g;
w = s;
break
} else
Ua()
}
while (0);
do if ((q | 0) != 0) {
s = c[r + 28 >> 2] | 0;
j = 9440 + (s << 2) | 0;
if ((r | 0) == (c[j >> 2] | 0)) {
c[j >> 2] = w;
if ((w | 0) == 0) {
c[9140 >> 2] = c[9140 >> 2] & ~(1 << s);
break
}
} else {
if (q >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
s = q + 16 | 0;
if ((c[s >> 2] | 0) == (r | 0))
c[s >> 2] = w;
else
c[q + 20 >> 2] = w;
if ((w | 0) == 0)
break
}
if (w >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
c[w + 24 >> 2] = q;
s = c[r + 16 >> 2] | 0;
do if ((s | 0) != 0)
if (s >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[w + 16 >> 2] = s;
c[s + 24 >> 2] = w;
break
}
while (0);
s = c[r + 20 >> 2] | 0;
if ((s | 0) != 0)
if (s >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[w + 20 >> 2] = s;
c[s + 24 >> 2] = w;
break
}
}
while (0);
if (f >>> 0 < 16) {
q = f + d | 0;
c[r + 4 >> 2] = q | 3;
s = r + (q + 4) | 0;
c[s >> 2] = c[s >> 2] | 1
} else {
c[r + 4 >> 2] = d | 3;
c[r + (d | 4) >> 2] = f | 1;
c[r + (f + d) >> 2] = f;
s = c[9144 >> 2] | 0;
if ((s | 0) != 0) {
q = c[9156 >> 2] | 0;
j = s >>> 3;
s = j << 1;
g = 9176 + (s << 2) | 0;
o = c[2284] | 0;
m = 1 << j;
if ((o & m | 0) != 0) {
j = 9176 + (s + 2 << 2) | 0;
n = c[j >> 2] | 0;
if (n >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
z = j;
A = n
}
} else {
c[2284] = o | m;
z = 9176 + (s + 2 << 2) | 0;
A = g
}
c[z >> 2] = q;
c[A + 12 >> 2] = q;
c[q + 8 >> 2] = A;
c[q + 12 >> 2] = g
}
c[9144 >> 2] = f;
c[9156 >> 2] = k
}
p = r + 8 | 0;
i = b;
return p | 0
} else
B = d
} else
B =
d
} else if (!(a >>> 0 > 4294967231)) {
g = a + 11 | 0;
q = g & -8;
s = c[9140 >> 2] | 0;
if ((s | 0) != 0) {
m = 0 - q | 0;
o = g >>> 8;
if ((o | 0) != 0)
if (q >>> 0 > 16777215)
C = 31;
else {
g = (o + 1048320 | 0) >>> 16 & 8;
n = o << g;
o = (n + 520192 | 0) >>> 16 & 4;
j = n << o;
n = (j + 245760 | 0) >>> 16 & 2;
h = 14 - (o | g | n) + (j << n >>> 15) | 0;
C = q >>> (h + 7 | 0) & 1 | h << 1
}
else
C = 0;
h = c[9440 + (C << 2) >> 2] | 0;
a:
do if ((h | 0) == 0) {
D = m;
E = 0;
F = 0
} else {
if ((C | 0) == 31)
G = 0;
else
G = 25 - (C >>> 1) | 0;
n = m;
j = 0;
g = q << G;
o = h;
e = 0;
while (1) {
l = c[o + 4 >> 2] & -8;
H = l - q | 0;
if (H >>> 0 < n >>> 0)
if ((l | 0) == (q | 0)) {
D = H;
E = o;
F = o;
break a
} else {
I = H;
J = o
}
else {
I = n;
J = e
}
H = c[o +
20 >> 2] | 0;
o = c[o + (g >>> 31 << 2) + 16 >> 2] | 0;
l = (H | 0) == 0 | (H | 0) == (o | 0) ? j : H;
if ((o | 0) == 0) {
D = I;
E = l;
F = J;
break
} else {
n = I;
j = l;
g = g << 1;
e = J
}
}
}
while (0);
if ((E | 0) == 0 & (F | 0) == 0) {
h = 2 << C;
m = s & (h | 0 - h);
if ((m | 0) == 0) {
B = q;
break
}
h = (m & 0 - m) + -1 | 0;
m = h >>> 12 & 16;
r = h >>> m;
h = r >>> 5 & 8;
k = r >>> h;
r = k >>> 2 & 4;
f = k >>> r;
k = f >>> 1 & 2;
e = f >>> k;
f = e >>> 1 & 1;
K = c[9440 + ((h | m | r | k | f) + (e >>> f) << 2) >> 2] | 0
} else
K = E;
if ((K | 0) == 0) {
L = D;
M = F
} else {
f = D;
e = K;
k = F;
while (1) {
r = (c[e + 4 >> 2] & -8) - q | 0;
m = r >>> 0 < f >>> 0;
h = m ? r : f;
r = m ? e : k;
m = c[e + 16 >> 2] | 0;
if ((m | 0) != 0) {
f = h;
e = m;
k = r;
continue
}
e = c[e + 20 >> 2] |
0;
if ((e | 0) == 0) {
L = h;
M = r;
break
} else {
f = h;
k = r
}
}
}
if ((M | 0) != 0 ? L >>> 0 < ((c[9144 >> 2] | 0) - q | 0) >>> 0 : 0) {
k = c[9152 >> 2] | 0;
if (M >>> 0 < k >>> 0)
Ua();
f = M + q | 0;
if (!(M >>> 0 < f >>> 0))
Ua();
e = c[M + 24 >> 2] | 0;
s = c[M + 12 >> 2] | 0;
do if ((s | 0) == (M | 0)) {
r = M + 20 | 0;
h = c[r >> 2] | 0;
if ((h | 0) == 0) {
m = M + 16 | 0;
g = c[m >> 2] | 0;
if ((g | 0) == 0) {
N = 0;
break
} else {
O = g;
P = m
}
} else {
O = h;
P = r
}
while (1) {
r = O + 20 | 0;
h = c[r >> 2] | 0;
if ((h | 0) != 0) {
O = h;
P = r;
continue
}
r = O + 16 | 0;
h = c[r >> 2] | 0;
if ((h | 0) == 0)
break;
else {
O = h;
P = r
}
}
if (P >>> 0 < k >>> 0)
Ua();
else {
c[P >> 2] = 0;
N = O;
break
}
} else {
r = c[M + 8 >> 2] | 0;
if (r >>> 0 < k >>>
0)
Ua();
h = r + 12 | 0;
if ((c[h >> 2] | 0) != (M | 0))
Ua();
m = s + 8 | 0;
if ((c[m >> 2] | 0) == (M | 0)) {
c[h >> 2] = s;
c[m >> 2] = r;
N = s;
break
} else
Ua()
}
while (0);
do if ((e | 0) != 0) {
s = c[M + 28 >> 2] | 0;
k = 9440 + (s << 2) | 0;
if ((M | 0) == (c[k >> 2] | 0)) {
c[k >> 2] = N;
if ((N | 0) == 0) {
c[9140 >> 2] = c[9140 >> 2] & ~(1 << s);
break
}
} else {
if (e >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
s = e + 16 | 0;
if ((c[s >> 2] | 0) == (M | 0))
c[s >> 2] = N;
else
c[e + 20 >> 2] = N;
if ((N | 0) == 0)
break
}
if (N >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
c[N + 24 >> 2] = e;
s = c[M + 16 >> 2] | 0;
do if ((s | 0) != 0)
if (s >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[N + 16 >> 2] = s;
c[s + 24 >>
2] = N;
break
}
while (0);
s = c[M + 20 >> 2] | 0;
if ((s | 0) != 0)
if (s >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[N + 20 >> 2] = s;
c[s + 24 >> 2] = N;
break
}
}
while (0);
b:
do if (!(L >>> 0 < 16)) {
c[M + 4 >> 2] = q | 3;
c[M + (q | 4) >> 2] = L | 1;
c[M + (L + q) >> 2] = L;
e = L >>> 3;
if (L >>> 0 < 256) {
s = e << 1;
k = 9176 + (s << 2) | 0;
r = c[2284] | 0;
m = 1 << e;
do if ((r & m | 0) == 0) {
c[2284] = r | m;
Q = 9176 + (s + 2 << 2) | 0;
R = k
} else {
e = 9176 + (s + 2 << 2) | 0;
h = c[e >> 2] | 0;
if (!(h >>> 0 < (c[9152 >> 2] | 0) >>> 0)) {
Q = e;
R = h;
break
}
Ua()
}
while (0);
c[Q >> 2] = f;
c[R + 12 >> 2] = f;
c[M + (q + 8) >> 2] = R;
c[M + (q + 12) >> 2] = k;
break
}
s = L >>> 8;
if ((s | 0) != 0)
if (L >>> 0 > 16777215)
S =
31;
else {
m = (s + 1048320 | 0) >>> 16 & 8;
r = s << m;
s = (r + 520192 | 0) >>> 16 & 4;
h = r << s;
r = (h + 245760 | 0) >>> 16 & 2;
e = 14 - (s | m | r) + (h << r >>> 15) | 0;
S = L >>> (e + 7 | 0) & 1 | e << 1
}
else
S = 0;
e = 9440 + (S << 2) | 0;
c[M + (q + 28) >> 2] = S;
c[M + (q + 20) >> 2] = 0;
c[M + (q + 16) >> 2] = 0;
r = c[9140 >> 2] | 0;
h = 1 << S;
if ((r & h | 0) == 0) {
c[9140 >> 2] = r | h;
c[e >> 2] = f;
c[M + (q + 24) >> 2] = e;
c[M + (q + 12) >> 2] = f;
c[M + (q + 8) >> 2] = f;
break
}
h = c[e >> 2] | 0;
if ((S | 0) == 31)
T = 0;
else
T = 25 - (S >>> 1) | 0;
c:
do if ((c[h + 4 >> 2] & -8 | 0) != (L | 0)) {
e = L << T;
r = h;
while (1) {
U = r + (e >>> 31 << 2) + 16 | 0;
m = c[U >> 2] | 0;
if ((m | 0) == 0)
break;
if ((c[m + 4 >> 2] & -8 |
0) == (L | 0)) {
V = m;
break c
} else {
e = e << 1;
r = m
}
}
if (U >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[U >> 2] = f;
c[M + (q + 24) >> 2] = r;
c[M + (q + 12) >> 2] = f;
c[M + (q + 8) >> 2] = f;
break b
}
} else
V = h;
while (0);
h = V + 8 | 0;
k = c[h >> 2] | 0;
e = c[9152 >> 2] | 0;
if (V >>> 0 < e >>> 0)
Ua();
if (k >>> 0 < e >>> 0)
Ua();
else {
c[k + 12 >> 2] = f;
c[h >> 2] = f;
c[M + (q + 8) >> 2] = k;
c[M + (q + 12) >> 2] = V;
c[M + (q + 24) >> 2] = 0;
break
}
} else {
k = L + q | 0;
c[M + 4 >> 2] = k | 3;
h = M + (k + 4) | 0;
c[h >> 2] = c[h >> 2] | 1
}
while (0);
p = M + 8 | 0;
i = b;
return p | 0
} else
B = q
} else
B = q
} else
B = -1;
while (0);
M = c[9144 >> 2] | 0;
if (!(B >>> 0 > M >>> 0)) {
L = M - B | 0;
V = c[9156 >>
2] | 0;
if (L >>> 0 > 15) {
c[9156 >> 2] = V + B;
c[9144 >> 2] = L;
c[V + (B + 4) >> 2] = L | 1;
c[V + M >> 2] = L;
c[V + 4 >> 2] = B | 3
} else {
c[9144 >> 2] = 0;
c[9156 >> 2] = 0;
c[V + 4 >> 2] = M | 3;
L = V + (M + 4) | 0;
c[L >> 2] = c[L >> 2] | 1
}
p = V + 8 | 0;
i = b;
return p | 0
}
V = c[9148 >> 2] | 0;
if (B >>> 0 < V >>> 0) {
L = V - B | 0;
c[9148 >> 2] = L;
V = c[9160 >> 2] | 0;
c[9160 >> 2] = V + B;
c[V + (B + 4) >> 2] = L | 1;
c[V + 4 >> 2] = B | 3;
p = V + 8 | 0;
i = b;
return p | 0
}
do if ((c[2402] | 0) == 0) {
V = Ta(30) | 0;
if ((V + -1 & V | 0) == 0) {
c[9616 >> 2] = V;
c[9612 >> 2] = V;
c[9620 >> 2] = -1;
c[9624 >> 2] = -1;
c[9628 >> 2] = 0;
c[9580 >> 2] = 0;
c[2402] = (Da(0) | 0) & -16 ^ 1431655768;
break
} else
Ua()
}
while (0);
V = B + 48 | 0;
L = c[9616 >> 2] | 0;
M = B + 47 | 0;
U = L + M | 0;
T = 0 - L | 0;
L = U & T;
if (!(L >>> 0 > B >>> 0)) {
p = 0;
i = b;
return p | 0
}
S = c[9576 >> 2] | 0;
if ((S | 0) != 0 ? (R = c[9568 >> 2] | 0, Q = R + L | 0, Q >>> 0 <= R >>> 0 | Q >>> 0 > S >>> 0) : 0) {
p = 0;
i = b;
return p | 0
}
d:
do if ((c[9580 >> 2] & 4 | 0) == 0) {
S = c[9160 >> 2] | 0;
e:
do if ((S | 0) != 0) {
Q = 9584 | 0;
while (1) {
R = c[Q >> 2] | 0;
if (!(R >>> 0 > S >>> 0) ? (W = Q + 4 | 0, (R + (c[W >> 2] | 0) | 0) >>> 0 > S >>> 0) : 0)
break;
R = c[Q + 8 >> 2] | 0;
if ((R | 0) == 0) {
X = 182;
break e
} else
Q = R
}
if ((Q | 0) != 0) {
R = U - (c[9148 >> 2] | 0) & T;
if (R >>> 0 < 2147483647) {
N = Ga(R | 0) | 0;
O = (N | 0) == ((c[Q >> 2] | 0) + (c[W >> 2] | 0) | 0);
Y = N;
Z = R;
_ = O ? N : -1;
$ = O ? R : 0;
X = 191
} else
aa = 0
} else
X = 182
} else
X = 182;
while (0);
do if ((X | 0) == 182) {
S = Ga(0) | 0;
if ((S | 0) != (-1 | 0)) {
q = S;
R = c[9612 >> 2] | 0;
O = R + -1 | 0;
if ((O & q | 0) == 0)
ba = L;
else
ba = L - q + (O + q & 0 - R) | 0;
R = c[9568 >> 2] | 0;
q = R + ba | 0;
if (ba >>> 0 > B >>> 0 & ba >>> 0 < 2147483647) {
O = c[9576 >> 2] | 0;
if ((O | 0) != 0 ? q >>> 0 <= R >>> 0 | q >>> 0 > O >>> 0 : 0) {
aa = 0;
break
}
O = Ga(ba | 0) | 0;
q = (O | 0) == (S | 0);
Y = O;
Z = ba;
_ = q ? S : -1;
$ = q ? ba : 0;
X = 191
} else
aa = 0
} else
aa = 0
}
while (0);
f:
do if ((X | 0) == 191) {
q = 0 - Z | 0;
if ((_ | 0) != (-1 | 0)) {
ca = _;
da = $;
X = 202;
break d
}
do if ((Y | 0) != (-1 | 0) & Z >>> 0 < 2147483647 &
Z >>> 0 < V >>> 0 ? (S = c[9616 >> 2] | 0, O = M - Z + S & 0 - S, O >>> 0 < 2147483647) : 0)
if ((Ga(O | 0) | 0) == (-1 | 0)) {
Ga(q | 0) | 0;
aa = $;
break f
} else {
ea = O + Z | 0;
break
}
else
ea = Z;
while (0);
if ((Y | 0) == (-1 | 0))
aa = $;
else {
ca = Y;
da = ea;
X = 202;
break d
}
}
while (0);
c[9580 >> 2] = c[9580 >> 2] | 4;
fa = aa;
X = 199
} else {
fa = 0;
X = 199
}
while (0);
if ((((X | 0) == 199 ? L >>> 0 < 2147483647 : 0) ? (aa = Ga(L | 0) | 0, L = Ga(0) | 0, (L | 0) != (-1 | 0) & (aa | 0) != (-1 | 0) & aa >>> 0 < L >>> 0) : 0) ? (ea = L - aa | 0, L = ea >>> 0 > (B + 40 | 0) >>> 0, L) : 0) {
ca = aa;
da = L ? ea : fa;
X = 202
}
if ((X | 0) == 202) {
fa = (c[9568 >> 2] | 0) + da | 0;
c[9568 >> 2] = fa;
if (fa >>> 0 > (c[9572 >>
2] | 0) >>> 0)
c[9572 >> 2] = fa;
fa = c[9160 >> 2] | 0;
g:
do if ((fa | 0) != 0) {
ea = 9584 | 0;
while (1) {
ga = c[ea >> 2] | 0;
ha = ea + 4 | 0;
ia = c[ha >> 2] | 0;
if ((ca | 0) == (ga + ia | 0)) {
X = 214;
break
}
L = c[ea + 8 >> 2] | 0;
if ((L | 0) == 0)
break;
else
ea = L
}
if (((X | 0) == 214 ? (c[ea + 12 >> 2] & 8 | 0) == 0 : 0) ? fa >>> 0 >= ga >>> 0 & fa >>> 0 < ca >>> 0 : 0) {
c[ha >> 2] = ia + da;
L = (c[9148 >> 2] | 0) + da | 0;
aa = fa + 8 | 0;
if ((aa & 7 | 0) == 0)
ja = 0;
else
ja = 0 - aa & 7;
aa = L - ja | 0;
c[9160 >> 2] = fa + ja;
c[9148 >> 2] = aa;
c[fa + (ja + 4) >> 2] = aa | 1;
c[fa + (L + 4) >> 2] = 40;
c[9164 >> 2] = c[9624 >> 2];
break
}
if (ca >>> 0 < (c[9152 >> 2] | 0) >>> 0)
c[9152 >> 2] = ca;
L = ca +
da | 0;
aa = 9584 | 0;
while (1) {
if ((c[aa >> 2] | 0) == (L | 0)) {
X = 224;
break
}
Y = c[aa + 8 >> 2] | 0;
if ((Y | 0) == 0)
break;
else
aa = Y
}
if ((X | 0) == 224 ? (c[aa + 12 >> 2] & 8 | 0) == 0 : 0) {
c[aa >> 2] = ca;
L = aa + 4 | 0;
c[L >> 2] = (c[L >> 2] | 0) + da;
L = ca + 8 | 0;
if ((L & 7 | 0) == 0)
ka = 0;
else
ka = 0 - L & 7;
L = ca + (da + 8) | 0;
if ((L & 7 | 0) == 0)
la = 0;
else
la = 0 - L & 7;
L = ca + (la + da) | 0;
ea = ka + B | 0;
Y = ca + ea | 0;
$ = L - (ca + ka) - B | 0;
c[ca + (ka + 4) >> 2] = B | 3;
h:
do if ((L | 0) != (c[9160 >> 2] | 0)) {
if ((L | 0) == (c[9156 >> 2] | 0)) {
Z = (c[9144 >> 2] | 0) + $ | 0;
c[9144 >> 2] = Z;
c[9156 >> 2] = Y;
c[ca + (ea + 4) >> 2] = Z | 1;
c[ca + (Z + ea) >> 2] = Z;
break
}
Z = da + 4 | 0;
M = c[ca + (Z + la) >> 2] | 0;
if ((M & 3 | 0) == 1) {
V = M & -8;
_ = M >>> 3;
i:
do if (!(M >>> 0 < 256)) {
ba = c[ca + ((la | 24) + da) >> 2] | 0;
W = c[ca + (da + 12 + la) >> 2] | 0;
do if ((W | 0) == (L | 0)) {
T = la | 16;
U = ca + (Z + T) | 0;
q = c[U >> 2] | 0;
if ((q | 0) == 0) {
Q = ca + (T + da) | 0;
T = c[Q >> 2] | 0;
if ((T | 0) == 0) {
ma = 0;
break
} else {
na = T;
oa = Q
}
} else {
na = q;
oa = U
}
while (1) {
U = na + 20 | 0;
q = c[U >> 2] | 0;
if ((q | 0) != 0) {
na = q;
oa = U;
continue
}
U = na + 16 | 0;
q = c[U >> 2] | 0;
if ((q | 0) == 0)
break;
else {
na = q;
oa = U
}
}
if (oa >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[oa >> 2] = 0;
ma = na;
break
}
} else {
U = c[ca + ((la | 8) + da) >> 2] | 0;
if (U >>> 0 < (c[9152 >> 2] |
0) >>> 0)
Ua();
q = U + 12 | 0;
if ((c[q >> 2] | 0) != (L | 0))
Ua();
Q = W + 8 | 0;
if ((c[Q >> 2] | 0) == (L | 0)) {
c[q >> 2] = W;
c[Q >> 2] = U;
ma = W;
break
} else
Ua()
}
while (0);
if ((ba | 0) == 0)
break;
W = c[ca + (da + 28 + la) >> 2] | 0;
r = 9440 + (W << 2) | 0;
do if ((L | 0) != (c[r >> 2] | 0)) {
if (ba >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
U = ba + 16 | 0;
if ((c[U >> 2] | 0) == (L | 0))
c[U >> 2] = ma;
else
c[ba + 20 >> 2] = ma;
if ((ma | 0) == 0)
break i
} else {
c[r >> 2] = ma;
if ((ma | 0) != 0)
break;
c[9140 >> 2] = c[9140 >> 2] & ~(1 << W);
break i
}
while (0);
if (ma >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
c[ma + 24 >> 2] = ba;
W = la | 16;
r = c[ca + (W + da) >> 2] | 0;
do if ((r | 0) !=
0)
if (r >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[ma + 16 >> 2] = r;
c[r + 24 >> 2] = ma;
break
}
while (0);
r = c[ca + (Z + W) >> 2] | 0;
if ((r | 0) == 0)
break;
if (r >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[ma + 20 >> 2] = r;
c[r + 24 >> 2] = ma;
break
}
} else {
r = c[ca + ((la | 8) + da) >> 2] | 0;
ba = c[ca + (da + 12 + la) >> 2] | 0;
U = 9176 + (_ << 1 << 2) | 0;
do if ((r | 0) != (U | 0)) {
if (r >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
if ((c[r + 12 >> 2] | 0) == (L | 0))
break;
Ua()
}
while (0);
if ((ba | 0) == (r | 0)) {
c[2284] = c[2284] & ~(1 << _);
break
}
do if ((ba | 0) == (U | 0))
pa = ba + 8 | 0;
else {
if (ba >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
W = ba + 8 | 0;
if ((c[W >> 2] |
0) == (L | 0)) {
pa = W;
break
}
Ua()
}
while (0);
c[r + 12 >> 2] = ba;
c[pa >> 2] = r
}
while (0);
qa = ca + ((V | la) + da) | 0;
ra = V + $ | 0
} else {
qa = L;
ra = $
}
_ = qa + 4 | 0;
c[_ >> 2] = c[_ >> 2] & -2;
c[ca + (ea + 4) >> 2] = ra | 1;
c[ca + (ra + ea) >> 2] = ra;
_ = ra >>> 3;
if (ra >>> 0 < 256) {
Z = _ << 1;
M = 9176 + (Z << 2) | 0;
U = c[2284] | 0;
W = 1 << _;
do if ((U & W | 0) == 0) {
c[2284] = U | W;
sa = 9176 + (Z + 2 << 2) | 0;
ta = M
} else {
_ = 9176 + (Z + 2 << 2) | 0;
Q = c[_ >> 2] | 0;
if (!(Q >>> 0 < (c[9152 >> 2] | 0) >>> 0)) {
sa = _;
ta = Q;
break
}
Ua()
}
while (0);
c[sa >> 2] = Y;
c[ta + 12 >> 2] = Y;
c[ca + (ea + 8) >> 2] = ta;
c[ca + (ea + 12) >> 2] = M;
break
}
Z = ra >>> 8;
do if ((Z | 0) == 0)
ua = 0;
else {
if (ra >>>
0 > 16777215) {
ua = 31;
break
}
W = (Z + 1048320 | 0) >>> 16 & 8;
U = Z << W;
V = (U + 520192 | 0) >>> 16 & 4;
Q = U << V;
U = (Q + 245760 | 0) >>> 16 & 2;
_ = 14 - (V | W | U) + (Q << U >>> 15) | 0;
ua = ra >>> (_ + 7 | 0) & 1 | _ << 1
}
while (0);
Z = 9440 + (ua << 2) | 0;
c[ca + (ea + 28) >> 2] = ua;
c[ca + (ea + 20) >> 2] = 0;
c[ca + (ea + 16) >> 2] = 0;
M = c[9140 >> 2] | 0;
_ = 1 << ua;
if ((M & _ | 0) == 0) {
c[9140 >> 2] = M | _;
c[Z >> 2] = Y;
c[ca + (ea + 24) >> 2] = Z;
c[ca + (ea + 12) >> 2] = Y;
c[ca + (ea + 8) >> 2] = Y;
break
}
_ = c[Z >> 2] | 0;
if ((ua | 0) == 31)
va = 0;
else
va = 25 - (ua >>> 1) | 0;
j:
do if ((c[_ + 4 >> 2] & -8 | 0) != (ra | 0)) {
Z = ra << va;
M = _;
while (1) {
wa = M + (Z >>> 31 << 2) + 16 | 0;
U = c[wa >>
2] | 0;
if ((U | 0) == 0)
break;
if ((c[U + 4 >> 2] & -8 | 0) == (ra | 0)) {
xa = U;
break j
} else {
Z = Z << 1;
M = U
}
}
if (wa >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[wa >> 2] = Y;
c[ca + (ea + 24) >> 2] = M;
c[ca + (ea + 12) >> 2] = Y;
c[ca + (ea + 8) >> 2] = Y;
break h
}
} else
xa = _;
while (0);
_ = xa + 8 | 0;
Z = c[_ >> 2] | 0;
r = c[9152 >> 2] | 0;
if (xa >>> 0 < r >>> 0)
Ua();
if (Z >>> 0 < r >>> 0)
Ua();
else {
c[Z + 12 >> 2] = Y;
c[_ >> 2] = Y;
c[ca + (ea + 8) >> 2] = Z;
c[ca + (ea + 12) >> 2] = xa;
c[ca + (ea + 24) >> 2] = 0;
break
}
} else {
Z = (c[9148 >> 2] | 0) + $ | 0;
c[9148 >> 2] = Z;
c[9160 >> 2] = Y;
c[ca + (ea + 4) >> 2] = Z | 1
}
while (0);
p = ca + (ka | 8) | 0;
i = b;
return p | 0
}
ea = 9584 |
0;
while (1) {
ya = c[ea >> 2] | 0;
if (!(ya >>> 0 > fa >>> 0) ? (za = c[ea + 4 >> 2] | 0, Aa = ya + za | 0, Aa >>> 0 > fa >>> 0) : 0)
break;
ea = c[ea + 8 >> 2] | 0
}
ea = ya + (za + -39) | 0;
if ((ea & 7 | 0) == 0)
Ba = 0;
else
Ba = 0 - ea & 7;
ea = ya + (za + -47 + Ba) | 0;
Y = ea >>> 0 < (fa + 16 | 0) >>> 0 ? fa : ea;
ea = Y + 8 | 0;
$ = ca + 8 | 0;
if (($ & 7 | 0) == 0)
Ca = 0;
else
Ca = 0 - $ & 7;
$ = da + -40 - Ca | 0;
c[9160 >> 2] = ca + Ca;
c[9148 >> 2] = $;
c[ca + (Ca + 4) >> 2] = $ | 1;
c[ca + (da + -36) >> 2] = 40;
c[9164 >> 2] = c[9624 >> 2];
c[Y + 4 >> 2] = 27;
c[ea + 0 >> 2] = c[9584 >> 2];
c[ea + 4 >> 2] = c[9588 >> 2];
c[ea + 8 >> 2] = c[9592 >> 2];
c[ea + 12 >> 2] = c[9596 >> 2];
c[9584 >> 2] = ca;
c[9588 >> 2] = da;
c[9596 >> 2] = 0;
c[9592 >> 2] = ea;
ea = Y + 28 | 0;
c[ea >> 2] = 7;
if ((Y + 32 | 0) >>> 0 < Aa >>> 0) {
$ = ea;
do {
ea = $;
$ = $ + 4 | 0;
c[$ >> 2] = 7
} while ((ea + 8 | 0) >>> 0 < Aa >>> 0)
}
if ((Y | 0) != (fa | 0)) {
$ = Y - fa | 0;
ea = fa + ($ + 4) | 0;
c[ea >> 2] = c[ea >> 2] & -2;
c[fa + 4 >> 2] = $ | 1;
c[fa + $ >> 2] = $;
ea = $ >>> 3;
if ($ >>> 0 < 256) {
L = ea << 1;
aa = 9176 + (L << 2) | 0;
Z = c[2284] | 0;
_ = 1 << ea;
do if ((Z & _ | 0) == 0) {
c[2284] = Z | _;
Ea = 9176 + (L + 2 << 2) | 0;
Fa = aa
} else {
ea = 9176 + (L + 2 << 2) | 0;
r = c[ea >> 2] | 0;
if (!(r >>> 0 < (c[9152 >> 2] | 0) >>> 0)) {
Ea = ea;
Fa = r;
break
}
Ua()
}
while (0);
c[Ea >> 2] = fa;
c[Fa + 12 >> 2] = fa;
c[fa + 8 >> 2] = Fa;
c[fa + 12 >> 2] = aa;
break
}
L =
$ >>> 8;
if ((L | 0) != 0)
if ($ >>> 0 > 16777215)
Ha = 31;
else {
_ = (L + 1048320 | 0) >>> 16 & 8;
Z = L << _;
L = (Z + 520192 | 0) >>> 16 & 4;
Y = Z << L;
Z = (Y + 245760 | 0) >>> 16 & 2;
r = 14 - (L | _ | Z) + (Y << Z >>> 15) | 0;
Ha = $ >>> (r + 7 | 0) & 1 | r << 1
}
else
Ha = 0;
r = 9440 + (Ha << 2) | 0;
c[fa + 28 >> 2] = Ha;
c[fa + 20 >> 2] = 0;
c[fa + 16 >> 2] = 0;
Z = c[9140 >> 2] | 0;
Y = 1 << Ha;
if ((Z & Y | 0) == 0) {
c[9140 >> 2] = Z | Y;
c[r >> 2] = fa;
c[fa + 24 >> 2] = r;
c[fa + 12 >> 2] = fa;
c[fa + 8 >> 2] = fa;
break
}
Y = c[r >> 2] | 0;
if ((Ha | 0) == 31)
Ia = 0;
else
Ia = 25 - (Ha >>> 1) | 0;
k:
do if ((c[Y + 4 >> 2] & -8 | 0) != ($ | 0)) {
r = $ << Ia;
Z = Y;
while (1) {
Ja = Z + (r >>> 31 << 2) + 16 | 0;
_ = c[Ja >> 2] | 0;
if ((_ | 0) == 0)
break;
if ((c[_ + 4 >> 2] & -8 | 0) == ($ | 0)) {
Ka = _;
break k
} else {
r = r << 1;
Z = _
}
}
if (Ja >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[Ja >> 2] = fa;
c[fa + 24 >> 2] = Z;
c[fa + 12 >> 2] = fa;
c[fa + 8 >> 2] = fa;
break g
}
} else
Ka = Y;
while (0);
Y = Ka + 8 | 0;
$ = c[Y >> 2] | 0;
aa = c[9152 >> 2] | 0;
if (Ka >>> 0 < aa >>> 0)
Ua();
if ($ >>> 0 < aa >>> 0)
Ua();
else {
c[$ + 12 >> 2] = fa;
c[Y >> 2] = fa;
c[fa + 8 >> 2] = $;
c[fa + 12 >> 2] = Ka;
c[fa + 24 >> 2] = 0;
break
}
}
} else {
$ = c[9152 >> 2] | 0;
if (($ | 0) == 0 | ca >>> 0 < $ >>> 0)
c[9152 >> 2] = ca;
c[9584 >> 2] = ca;
c[9588 >> 2] = da;
c[9596 >> 2] = 0;
c[9172 >> 2] = c[2402];
c[9168 >> 2] = -1;
$ = 0;
do {
Y = $ <<
1;
aa = 9176 + (Y << 2) | 0;
c[9176 + (Y + 3 << 2) >> 2] = aa;
c[9176 + (Y + 2 << 2) >> 2] = aa;
$ = $ + 1 | 0
} while (($ | 0) != 32);
$ = ca + 8 | 0;
if (($ & 7 | 0) == 0)
La = 0;
else
La = 0 - $ & 7;
$ = da + -40 - La | 0;
c[9160 >> 2] = ca + La;
c[9148 >> 2] = $;
c[ca + (La + 4) >> 2] = $ | 1;
c[ca + (da + -36) >> 2] = 40;
c[9164 >> 2] = c[9624 >> 2]
}
while (0);
da = c[9148 >> 2] | 0;
if (da >>> 0 > B >>> 0) {
ca = da - B | 0;
c[9148 >> 2] = ca;
da = c[9160 >> 2] | 0;
c[9160 >> 2] = da + B;
c[da + (B + 4) >> 2] = ca | 1;
c[da + 4 >> 2] = B | 3;
p = da + 8 | 0;
i = b;
return p | 0
}
}
c[(Qa() | 0) >> 2] = 12;
p = 0;
i = b;
return p | 0
}
function pn(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n =
0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
E = 0,
F = 0,
G = 0,
H = 0,
I = 0,
J = 0,
K = 0;
b = i;
if ((a | 0) == 0) {
i = b;
return
}
d = a + -8 | 0;
e = c[9152 >> 2] | 0;
if (d >>> 0 < e >>> 0)
Ua();
f = c[a + -4 >> 2] | 0;
g = f & 3;
if ((g | 0) == 1)
Ua();
h = f & -8;
j = a + (h + -8) | 0;
do if ((f & 1 | 0) == 0) {
k = c[d >> 2] | 0;
if ((g | 0) == 0) {
i = b;
return
}
l = -8 - k | 0;
m = a + l | 0;
n = k + h | 0;
if (m >>> 0 < e >>> 0)
Ua();
if ((m | 0) == (c[9156 >> 2] | 0)) {
o = a + (h + -4) | 0;
if ((c[o >> 2] & 3 | 0) != 3) {
p = m;
q = n;
break
}
c[9144 >> 2] = n;
c[o >> 2] = c[o >> 2] & -2;
c[a + (l + 4) >> 2] = n | 1;
c[j >> 2] = n;
i = b;
return
}
o = k >>> 3;
if (k >>> 0 < 256) {
k = c[a + (l + 8) >>
2] | 0;
r = c[a + (l + 12) >> 2] | 0;
s = 9176 + (o << 1 << 2) | 0;
if ((k | 0) != (s | 0)) {
if (k >>> 0 < e >>> 0)
Ua();
if ((c[k + 12 >> 2] | 0) != (m | 0))
Ua()
}
if ((r | 0) == (k | 0)) {
c[2284] = c[2284] & ~(1 << o);
p = m;
q = n;
break
}
if ((r | 0) != (s | 0)) {
if (r >>> 0 < e >>> 0)
Ua();
s = r + 8 | 0;
if ((c[s >> 2] | 0) == (m | 0))
t = s;
else
Ua()
} else
t = r + 8 | 0;
c[k + 12 >> 2] = r;
c[t >> 2] = k;
p = m;
q = n;
break
}
k = c[a + (l + 24) >> 2] | 0;
r = c[a + (l + 12) >> 2] | 0;
do if ((r | 0) == (m | 0)) {
s = a + (l + 20) | 0;
o = c[s >> 2] | 0;
if ((o | 0) == 0) {
u = a + (l + 16) | 0;
v = c[u >> 2] | 0;
if ((v | 0) == 0) {
w = 0;
break
} else {
x = v;
y = u
}
} else {
x = o;
y = s
}
while (1) {
s = x + 20 | 0;
o = c[s >> 2] | 0;
if ((o |
0) != 0) {
x = o;
y = s;
continue
}
s = x + 16 | 0;
o = c[s >> 2] | 0;
if ((o | 0) == 0)
break;
else {
x = o;
y = s
}
}
if (y >>> 0 < e >>> 0)
Ua();
else {
c[y >> 2] = 0;
w = x;
break
}
} else {
s = c[a + (l + 8) >> 2] | 0;
if (s >>> 0 < e >>> 0)
Ua();
o = s + 12 | 0;
if ((c[o >> 2] | 0) != (m | 0))
Ua();
u = r + 8 | 0;
if ((c[u >> 2] | 0) == (m | 0)) {
c[o >> 2] = r;
c[u >> 2] = s;
w = r;
break
} else
Ua()
}
while (0);
if ((k | 0) != 0) {
r = c[a + (l + 28) >> 2] | 0;
s = 9440 + (r << 2) | 0;
if ((m | 0) == (c[s >> 2] | 0)) {
c[s >> 2] = w;
if ((w | 0) == 0) {
c[9140 >> 2] = c[9140 >> 2] & ~(1 << r);
p = m;
q = n;
break
}
} else {
if (k >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
r = k + 16 | 0;
if ((c[r >> 2] | 0) == (m | 0))
c[r >> 2] = w;
else
c[k +
20 >> 2] = w;
if ((w | 0) == 0) {
p = m;
q = n;
break
}
}
if (w >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
c[w + 24 >> 2] = k;
r = c[a + (l + 16) >> 2] | 0;
do if ((r | 0) != 0)
if (r >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[w + 16 >> 2] = r;
c[r + 24 >> 2] = w;
break
}
while (0);
r = c[a + (l + 20) >> 2] | 0;
if ((r | 0) != 0)
if (r >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[w + 20 >> 2] = r;
c[r + 24 >> 2] = w;
p = m;
q = n;
break
}
else {
p = m;
q = n
}
} else {
p = m;
q = n
}
} else {
p = d;
q = h
}
while (0);
if (!(p >>> 0 < j >>> 0))
Ua();
d = a + (h + -4) | 0;
w = c[d >> 2] | 0;
if ((w & 1 | 0) == 0)
Ua();
if ((w & 2 | 0) == 0) {
if ((j | 0) == (c[9160 >> 2] | 0)) {
e = (c[9148 >> 2] | 0) + q | 0;
c[9148 >> 2] = e;
c[9160 >>
2] = p;
c[p + 4 >> 2] = e | 1;
if ((p | 0) != (c[9156 >> 2] | 0)) {
i = b;
return
}
c[9156 >> 2] = 0;
c[9144 >> 2] = 0;
i = b;
return
}
if ((j | 0) == (c[9156 >> 2] | 0)) {
e = (c[9144 >> 2] | 0) + q | 0;
c[9144 >> 2] = e;
c[9156 >> 2] = p;
c[p + 4 >> 2] = e | 1;
c[p + e >> 2] = e;
i = b;
return
}
e = (w & -8) + q | 0;
x = w >>> 3;
do if (!(w >>> 0 < 256)) {
y = c[a + (h + 16) >> 2] | 0;
t = c[a + (h | 4) >> 2] | 0;
do if ((t | 0) == (j | 0)) {
g = a + (h + 12) | 0;
f = c[g >> 2] | 0;
if ((f | 0) == 0) {
r = a + (h + 8) | 0;
k = c[r >> 2] | 0;
if ((k | 0) == 0) {
z = 0;
break
} else {
A = k;
B = r
}
} else {
A = f;
B = g
}
while (1) {
g = A + 20 | 0;
f = c[g >> 2] | 0;
if ((f | 0) != 0) {
A = f;
B = g;
continue
}
g = A + 16 | 0;
f = c[g >> 2] | 0;
if ((f | 0) ==
0)
break;
else {
A = f;
B = g
}
}
if (B >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[B >> 2] = 0;
z = A;
break
}
} else {
g = c[a + h >> 2] | 0;
if (g >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
f = g + 12 | 0;
if ((c[f >> 2] | 0) != (j | 0))
Ua();
r = t + 8 | 0;
if ((c[r >> 2] | 0) == (j | 0)) {
c[f >> 2] = t;
c[r >> 2] = g;
z = t;
break
} else
Ua()
}
while (0);
if ((y | 0) != 0) {
t = c[a + (h + 20) >> 2] | 0;
n = 9440 + (t << 2) | 0;
if ((j | 0) == (c[n >> 2] | 0)) {
c[n >> 2] = z;
if ((z | 0) == 0) {
c[9140 >> 2] = c[9140 >> 2] & ~(1 << t);
break
}
} else {
if (y >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
t = y + 16 | 0;
if ((c[t >> 2] | 0) == (j | 0))
c[t >> 2] = z;
else
c[y + 20 >> 2] = z;
if ((z | 0) == 0)
break
}
if (z >>>
0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
c[z + 24 >> 2] = y;
t = c[a + (h + 8) >> 2] | 0;
do if ((t | 0) != 0)
if (t >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[z + 16 >> 2] = t;
c[t + 24 >> 2] = z;
break
}
while (0);
t = c[a + (h + 12) >> 2] | 0;
if ((t | 0) != 0)
if (t >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[z + 20 >> 2] = t;
c[t + 24 >> 2] = z;
break
}
}
} else {
t = c[a + h >> 2] | 0;
y = c[a + (h | 4) >> 2] | 0;
n = 9176 + (x << 1 << 2) | 0;
if ((t | 0) != (n | 0)) {
if (t >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
if ((c[t + 12 >> 2] | 0) != (j | 0))
Ua()
}
if ((y | 0) == (t | 0)) {
c[2284] = c[2284] & ~(1 << x);
break
}
if ((y | 0) != (n | 0)) {
if (y >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
n = y + 8 | 0;
if ((c[n >>
2] | 0) == (j | 0))
C = n;
else
Ua()
} else
C = y + 8 | 0;
c[t + 12 >> 2] = y;
c[C >> 2] = t
}
while (0);
c[p + 4 >> 2] = e | 1;
c[p + e >> 2] = e;
if ((p | 0) == (c[9156 >> 2] | 0)) {
c[9144 >> 2] = e;
i = b;
return
} else
D = e
} else {
c[d >> 2] = w & -2;
c[p + 4 >> 2] = q | 1;
c[p + q >> 2] = q;
D = q
}
q = D >>> 3;
if (D >>> 0 < 256) {
w = q << 1;
d = 9176 + (w << 2) | 0;
e = c[2284] | 0;
C = 1 << q;
if ((e & C | 0) != 0) {
q = 9176 + (w + 2 << 2) | 0;
j = c[q >> 2] | 0;
if (j >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
E = q;
F = j
}
} else {
c[2284] = e | C;
E = 9176 + (w + 2 << 2) | 0;
F = d
}
c[E >> 2] = p;
c[F + 12 >> 2] = p;
c[p + 8 >> 2] = F;
c[p + 12 >> 2] = d;
i = b;
return
}
d = D >>> 8;
if ((d | 0) != 0)
if (D >>> 0 > 16777215)
G = 31;
else {
F = (d + 1048320 | 0) >>> 16 & 8;
E = d << F;
d = (E + 520192 | 0) >>> 16 & 4;
w = E << d;
E = (w + 245760 | 0) >>> 16 & 2;
C = 14 - (d | F | E) + (w << E >>> 15) | 0;
G = D >>> (C + 7 | 0) & 1 | C << 1
}
else
G = 0;
C = 9440 + (G << 2) | 0;
c[p + 28 >> 2] = G;
c[p + 20 >> 2] = 0;
c[p + 16 >> 2] = 0;
E = c[9140 >> 2] | 0;
w = 1 << G;
a:
do if ((E & w | 0) != 0) {
F = c[C >> 2] | 0;
if ((G | 0) == 31)
H = 0;
else
H = 25 - (G >>> 1) | 0;
b:
do if ((c[F + 4 >> 2] & -8 | 0) != (D | 0)) {
d = D << H;
e = F;
while (1) {
I = e + (d >>> 31 << 2) + 16 | 0;
j = c[I >> 2] | 0;
if ((j | 0) == 0)
break;
if ((c[j + 4 >> 2] & -8 | 0) == (D | 0)) {
J = j;
break b
} else {
d = d << 1;
e = j
}
}
if (I >>> 0 < (c[9152 >> 2] | 0) >>> 0)
Ua();
else {
c[I >> 2] = p;
c[p +
24 >> 2] = e;
c[p + 12 >> 2] = p;
c[p + 8 >> 2] = p;
break a
}
} else
J = F;
while (0);
F = J + 8 | 0;
d = c[F >> 2] | 0;
j = c[9152 >> 2] | 0;
if (J >>> 0 < j >>> 0)
Ua();
if (d >>> 0 < j >>> 0)
Ua();
else {
c[d + 12 >> 2] = p;
c[F >> 2] = p;
c[p + 8 >> 2] = d;
c[p + 12 >> 2] = J;
c[p + 24 >> 2] = 0;
break
}
} else {
c[9140 >> 2] = E | w;
c[C >> 2] = p;
c[p + 24 >> 2] = C;
c[p + 12 >> 2] = p;
c[p + 8 >> 2] = p
}
while (0);
p = (c[9168 >> 2] | 0) + -1 | 0;
c[9168 >> 2] = p;
if ((p | 0) == 0)
K = 9592 | 0;
else {
i = b;
return
}
while (1) {
p = c[K >> 2] | 0;
if ((p | 0) == 0)
break;
else
K = p + 8 | 0
}
c[9168 >> 2] = -1;
i = b;
return
}
function qn(a) {
a = a | 0;
var b = 0,
d = 0,
e = 0,
f = 0;
b = i;
d = (a | 0) == 0 ? 1 : a;
while (1) {
e =
on(d) | 0;
if ((e | 0) != 0) {
f = 6;
break
}
a = c[2410] | 0;
c[2410] = a + 0;
if ((a | 0) == 0) {
f = 5;
break
}
jb[a & 1]()
}
if ((f | 0) == 5) {
d = Aa(4) | 0;
c[d >> 2] = 9656;
Sa(d | 0, 9704, 92)
} else if ((f | 0) == 6) {
i = b;
return e | 0
}
return 0
}
function rn(a, b) {
a = a | 0;
b = b | 0;
var c = 0;
b = i;
c = qn(a) | 0;
i = b;
return c | 0
}
function sn(a) {
a = a | 0;
var b = 0;
b = i;
if ((a | 0) != 0)
pn(a);
i = b;
return
}
function tn(a) {
a = a | 0;
var b = 0;
b = i;
Ra(a | 0);
sn(a);
i = b;
return
}
function un(a) {
a = a | 0;
var b = 0;
b = i;
Ra(a | 0);
i = b;
return
}
function vn(a) {
a = a | 0;
return 9672
}
function wn() {
c[2428] = o
}
function xn(b, d, e) {
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
g = 0,
h = 0,
i = 0;
f = b + e | 0;
if ((e | 0) >= 20) {
d = d & 255;
g = b & 3;
h = d | d << 8 | d << 16 | d << 24;
i = f & ~3;
if (g) {
g = b + 4 - g | 0;
while ((b | 0) < (g | 0)) {
a[b >> 0] = d;
b = b + 1 | 0
}
}
while ((b | 0) < (i | 0)) {
c[b >> 2] = h;
b = b + 4 | 0
}
}
while ((b | 0) < (f | 0)) {
a[b >> 0] = d;
b = b + 1 | 0
}
return b - e | 0
}
function yn(b) {
b = b | 0;
var c = 0;
c = b;
while (a[c >> 0] | 0)
c = c + 1 | 0;
return c - b | 0
}
function zn(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
var e = 0;
e = a + c >>> 0;
return (E = b + d + (e >>> 0 < a >>> 0 | 0) >>> 0, e | 0) | 0
}
function An(b, d, e) {
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0;
if ((e | 0) >= 4096)
return Ma(b | 0, d | 0, e | 0) | 0;
f = b | 0;
if ((b & 3) == (d & 3)) {
while (b & 3) {
if ((e | 0) == 0)
return f | 0;
a[b >> 0] = a[d >> 0] | 0;
b = b + 1 | 0;
d = d + 1 | 0;
e = e - 1 | 0
}
while ((e | 0) >= 4) {
c[b >> 2] = c[d >> 2];
b = b + 4 | 0;
d = d + 4 | 0;
e = e - 4 | 0
}
}
while ((e | 0) > 0) {
a[b >> 0] = a[d >> 0] | 0;
b = b + 1 | 0;
d = d + 1 | 0;
e = e - 1 | 0
}
return f | 0
}
function Bn(b, c, d) {
b = b | 0;
c = c | 0;
d = d | 0;
var e = 0;
if ((c | 0) < (b | 0) & (b | 0) < (c + d | 0)) {
e = b;
c = c + d | 0;
b = b + d | 0;
while ((d | 0) > 0) {
b = b - 1 | 0;
c = c - 1 | 0;
d = d - 1 | 0;
a[b >> 0] = a[c >> 0] | 0
}
b = e
} else
An(b, c, d) | 0;
return b | 0
}
function Cn(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
var e = 0;
e = b - d >>> 0;
e = b - d - (c >>> 0 > a >>> 0 | 0) >>> 0;
return (E = e,
a - c >>> 0 | 0) | 0
}
function Dn(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
if ((c | 0) < 32) {
E = b << c | (a & (1 << c) - 1 << 32 - c) >>> 32 - c;
return a << c
}
E = a << c - 32;
return 0
}
function En(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
if ((c | 0) < 32) {
E = b >>> c;
return a >>> c | (b & (1 << c) - 1) << 32 - c
}
E = 0;
return b >>> c - 32 | 0
}
function Fn(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
if ((c | 0) < 32) {
E = b >> c;
return a >>> c | (b & (1 << c) - 1) << 32 - c
}
E = (b | 0) < 0 ? -1 : 0;
return b >> c - 32 | 0
}
function Gn(b) {
b = b | 0;
var c = 0;
c = a[n + (b >>> 24) >> 0] | 0;
if ((c | 0) < 8)
return c | 0;
c = a[n + (b >> 16 & 255) >> 0] | 0;
if ((c | 0) < 8)
return c + 8 | 0;
c = a[n + (b >> 8 & 255) >> 0] |
0;
if ((c | 0) < 8)
return c + 16 | 0;
return (a[n + (b & 255) >> 0] | 0) + 24 | 0
}
function Hn(b) {
b = b | 0;
var c = 0;
c = a[m + (b & 255) >> 0] | 0;
if ((c | 0) < 8)
return c | 0;
c = a[m + (b >> 8 & 255) >> 0] | 0;
if ((c | 0) < 8)
return c + 8 | 0;
c = a[m + (b >> 16 & 255) >> 0] | 0;
if ((c | 0) < 8)
return c + 16 | 0;
return (a[m + (b >>> 24) >> 0] | 0) + 24 | 0
}
function In(a, b) {
a = a | 0;
b = b | 0;
var c = 0,
d = 0,
e = 0,
f = 0;
c = a & 65535;
d = b & 65535;
e = aa(d, c) | 0;
f = a >>> 16;
a = (e >>> 16) + (aa(d, f) | 0) | 0;
d = b >>> 16;
b = aa(d, c) | 0;
return (E = (a >>> 16) + (aa(d, f) | 0) + (((a & 65535) + b | 0) >>> 16) | 0, a + b << 16 | e & 65535 | 0) | 0
}
function Jn(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
var e = 0,
f = 0,
g = 0,
h = 0,
i = 0;
e = b >> 31 | ((b | 0) < 0 ? -1 : 0) << 1;
f = ((b | 0) < 0 ? -1 : 0) >> 31 | ((b | 0) < 0 ? -1 : 0) << 1;
g = d >> 31 | ((d | 0) < 0 ? -1 : 0) << 1;
h = ((d | 0) < 0 ? -1 : 0) >> 31 | ((d | 0) < 0 ? -1 : 0) << 1;
i = Cn(e ^ a, f ^ b, e, f) | 0;
b = E;
a = g ^ e;
e = h ^ f;
f = Cn((On(i, b, Cn(g ^ c, h ^ d, g, h) | 0, E, 0) | 0) ^ a, E ^ e, a, e) | 0;
return f | 0
}
function Kn(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
g = 0,
h = 0,
j = 0,
k = 0,
l = 0,
m = 0;
f = i;
i = i + 8 | 0;
g = f | 0;
h = b >> 31 | ((b | 0) < 0 ? -1 : 0) << 1;
j = ((b | 0) < 0 ? -1 : 0) >> 31 | ((b | 0) < 0 ? -1 : 0) << 1;
k = e >> 31 | ((e | 0) < 0 ? -1 : 0) << 1;
l = ((e | 0) < 0 ? -1 : 0) >> 31 | ((e | 0) < 0 ? -1 : 0) << 1;
m = Cn(h ^ a, j ^
b, h, j) | 0;
b = E;
On(m, b, Cn(k ^ d, l ^ e, k, l) | 0, E, g) | 0;
l = Cn(c[g >> 2] ^ h, c[g + 4 >> 2] ^ j, h, j) | 0;
j = E;
i = f;
return (E = j, l) | 0
}
function Ln(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
var e = 0,
f = 0;
e = a;
a = c;
c = In(e, a) | 0;
f = E;
return (E = (aa(b, a) | 0) + (aa(d, e) | 0) + f | f & 0, c | 0 | 0) | 0
}
function Mn(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
var e = 0;
e = On(a, b, c, d, 0) | 0;
return e | 0
}
function Nn(a, b, d, e) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
var f = 0,
g = 0;
f = i;
i = i + 8 | 0;
g = f | 0;
On(a, b, d, e, g) | 0;
i = f;
return (E = c[g + 4 >> 2] | 0, c[g >> 2] | 0) | 0
}
function On(a, b, d, e, f) {
a = a | 0;
b = b | 0;
d = d | 0;
e = e | 0;
f = f | 0;
var g =
0,
h = 0,
i = 0,
j = 0,
k = 0,
l = 0,
m = 0,
n = 0,
o = 0,
p = 0,
q = 0,
r = 0,
s = 0,
t = 0,
u = 0,
v = 0,
w = 0,
x = 0,
y = 0,
z = 0,
A = 0,
B = 0,
C = 0,
D = 0,
F = 0,
G = 0,
H = 0;
g = a;
h = b;
i = h;
j = d;
k = e;
l = k;
if ((i | 0) == 0) {
m = (f | 0) != 0;
if ((l | 0) == 0) {
if (m) {
c[f >> 2] = (g >>> 0) % (j >>> 0);
c[f + 4 >> 2] = 0
}
n = 0;
o = (g >>> 0) / (j >>> 0) >>> 0;
return (E = n, o) | 0
} else {
if (!m) {
n = 0;
o = 0;
return (E = n, o) | 0
}
c[f >> 2] = a | 0;
c[f + 4 >> 2] = b & 0;
n = 0;
o = 0;
return (E = n, o) | 0
}
}
m = (l | 0) == 0;
do if ((j | 0) != 0) {
if (!m) {
p = (Gn(l | 0) | 0) - (Gn(i | 0) | 0) | 0;
if (p >>> 0 <= 31) {
q = p + 1 | 0;
r = 31 - p | 0;
s = p - 31 >> 31;
t = q;
u = g >>> (q >>> 0) & s | i << r;
v = i >>> (q >>> 0) & s;
w = 0;
x = g << r;
break
}
if ((f |
0) == 0) {
n = 0;
o = 0;
return (E = n, o) | 0
}
c[f >> 2] = a | 0;
c[f + 4 >> 2] = h | b & 0;
n = 0;
o = 0;
return (E = n, o) | 0
}
r = j - 1 | 0;
if ((r & j | 0) != 0) {
s = (Gn(j | 0) | 0) + 33 - (Gn(i | 0) | 0) | 0;
q = 64 - s | 0;
p = 32 - s | 0;
y = p >> 31;
z = s - 32 | 0;
A = z >> 31;
t = s;
u = p - 1 >> 31 & i >>> (z >>> 0) | (i << p | g >>> (s >>> 0)) & A;
v = A & i >>> (s >>> 0);
w = g << q & y;
x = (i << q | g >>> (z >>> 0)) & y | g << p & s - 33 >> 31;
break
}
if ((f | 0) != 0) {
c[f >> 2] = r & g;
c[f + 4 >> 2] = 0
}
if ((j | 0) == 1) {
n = h | b & 0;
o = a | 0 | 0;
return (E = n, o) | 0
} else {
r = Hn(j | 0) | 0;
n = i >>> (r >>> 0) | 0;
o = i << 32 - r | g >>> (r >>> 0) | 0;
return (E = n, o) | 0
}
} else {
if (m) {
if ((f | 0) != 0) {
c[f >> 2] = (i >>> 0) % (j >>> 0);
c[f +
4 >> 2] = 0
}
n = 0;
o = (i >>> 0) / (j >>> 0) >>> 0;
return (E = n, o) | 0
}
if ((g | 0) == 0) {
if ((f | 0) != 0) {
c[f >> 2] = 0;
c[f + 4 >> 2] = (i >>> 0) % (l >>> 0)
}
n = 0;
o = (i >>> 0) / (l >>> 0) >>> 0;
return (E = n, o) | 0
}
r = l - 1 | 0;
if ((r & l | 0) == 0) {
if ((f | 0) != 0) {
c[f >> 2] = a | 0;
c[f + 4 >> 2] = r & i | b & 0
}
n = 0;
o = i >>> ((Hn(l | 0) | 0) >>> 0);
return (E = n, o) | 0
}
r = (Gn(l | 0) | 0) - (Gn(i | 0) | 0) | 0;
if (r >>> 0 <= 30) {
s = r + 1 | 0;
p = 31 - r | 0;
t = s;
u = i << p | g >>> (s >>> 0);
v = i >>> (s >>> 0);
w = 0;
x = g << p;
break
}
if ((f | 0) == 0) {
n = 0;
o = 0;
return (E = n, o) | 0
}
c[f >> 2] = a | 0;
c[f + 4 >> 2] = h | b & 0;
n = 0;
o = 0;
return (E = n, o) | 0
}
while (0);
if ((t | 0) == 0) {
B = x;
C = w;
D = v;
F =
u;
G = 0;
H = 0
} else {
b = d | 0 | 0;
d = k | e & 0;
e = zn(b, d, -1, -1) | 0;
k = E;
h = x;
x = w;
w = v;
v = u;
u = t;
t = 0;
do {
a = h;
h = x >>> 31 | h << 1;
x = t | x << 1;
g = v << 1 | a >>> 31 | 0;
a = v >>> 31 | w << 1 | 0;
Cn(e, k, g, a) | 0;
i = E;
l = i >> 31 | ((i | 0) < 0 ? -1 : 0) << 1;
t = l & 1;
v = Cn(g, a, l & b, (((i | 0) < 0 ? -1 : 0) >> 31 | ((i | 0) < 0 ? -1 : 0) << 1) & d) | 0;
w = E;
u = u - 1 | 0
} while ((u | 0) != 0);
B = h;
C = x;
D = w;
F = v;
G = 0;
H = t
}
t = C;
C = 0;
if ((f | 0) != 0) {
c[f >> 2] = F;
c[f + 4 >> 2] = D
}
n = (t | 0) >>> 31 | (B | C) << 1 | (C << 1 | t >>> 31) & 0 | G;
o = (t << 1 | 0 >>> 31) & -2 | H;
return (E = n, o) | 0
}
function Pn(a, b, c, d, e, f, g) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = +g;
return +ab[a & 1](b |
0, c | 0, d | 0, e | 0, f | 0, +g)
}
function Qn(a, b) {
a = a | 0;
b = b | 0;
return bb[a & 7](b | 0) | 0
}
function Rn(a, b, c, d, e, f) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
f = f | 0;
cb[a & 3](b | 0, c | 0, d | 0, e | 0, f | 0)
}
function Sn(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
return +db[a & 15](b | 0, +c)
}
function Tn(a, b) {
a = a | 0;
b = b | 0;
eb[a & 127](b | 0)
}
function Un(a, b, c, d, e, f) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
f = +f;
return +fb[a & 1](b | 0, c | 0, d | 0, e | 0, +f)
}
function Vn(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
gb[a & 63](b | 0, c | 0)
}
function Wn(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
return hb[a & 15](b | 0, c | 0, d | 0) | 0
}
function Xn(a,
b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
ib[a & 7](b | 0, c | 0, d | 0)
}
function Yn(a) {
a = a | 0;
jb[a & 1]()
}
function Zn(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = +d;
kb[a & 31](b | 0, c | 0, +d)
}
function _n(a, b, c, d, e) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
return lb[a & 7](b | 0, c | 0, d | 0, e | 0) | 0
}
function $n(a, b, c, d, e, f, g) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
f = f | 0;
g = g | 0;
mb[a & 7](b | 0, c | 0, d | 0, e | 0, f | 0, g | 0)
}
function ao(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
return nb[a & 31](b | 0, c | 0) | 0
}
function bo(a, b, c, d, e, f) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
f = f | 0;
return ob[a & 15](b | 0, c | 0, d | 0, e | 0, f | 0) | 0
}
function co(a, b, c, d, e) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
pb[a & 31](b | 0, c | 0, d | 0, e | 0)
}
function eo(a, b, c, d, e, f) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
f = +f;
ba(0);
return 0
}
function fo(a) {
a = a | 0;
ba(1);
return 0
}
function go(a, b, c, d, e) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
ba(2)
}
function ho(a, b) {
a = a | 0;
b = +b;
ba(3);
return 0
}
function io(a) {
a = a | 0;
ba(4)
}
function jo(a, b, c, d, e) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = +e;
ba(5);
return 0
}
function ko(a, b) {
a = a | 0;
b = b | 0;
ba(6)
}
function lo(a, b, c) {
a = a | 0;
b = b | 0;
c = c | 0;
ba(7);
return 0
}
function mo(a, b, c) {
a = a | 0;
b = b |
0;
c = c | 0;
ba(8)
}
function no() {
ba(9)
}
function oo() {
_a()
}
function po(a, b, c) {
a = a | 0;
b = b | 0;
c = +c;
ba(10)
}
function qo(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
ba(11);
return 0
}
function ro(a, b, c, d, e, f) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
f = f | 0;
ba(12)
}
function so(a, b) {
a = a | 0;
b = b | 0;
ba(13);
return 0
}
function to(a, b, c, d, e) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
e = e | 0;
ba(14);
return 0
}
function uo(a, b, c, d) {
a = a | 0;
b = b | 0;
c = c | 0;
d = d | 0;
ba(15)
}
var ab = [eo, Gd];
var bb = [fo, ge, ne, ve, Fe, rm, vn, fo];
var cb = [go, ln, kn, go];
var db = [ho, Df, Qf, dg, pg, Bg, Mg, Zg, ph, Hh, Zh,
ki, ho, ho, ho, ho];
var eb = [io, pc, Ed, oc, Id, nc, Md, Gb, Wd, Ib, Vd, Cb, Xd, Ce, Be, rf, sf, Ff, Gf, Hf, Tf, Vf, Wf, eg, fg, gg, qg, rg, sg, Cg, Dg, Eg, Og, Pg, Qg, fh, gh, hh, qh, rh, sh, wh, xh, yh, Oh, Ph, Qh, $h, ai, bi, li, ni, oi, si, ti, yi, zi, Di, Ei, Ii, Ji, Wi, Xi, $i, aj, ej, fj, jj, kj, Rj, ck, Ul, Vl, Zl, _l, am, bm, dm, em, Jk, im, km, lm, om, pm, xm, ym, an, dn, bn, cn, en, un, tn, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io, io];
var fb = [jo, Fd];
var gb = [ko, Nd, Od, Af, Bf, Ef, xf, yf, Nf, Of, Uf, Kf, Lf, ag, bg, Zf, _f, mg, ng, jg, kg, yg, zg,
vg, wg, Jg, Kg, Gg, Hg, Wg, Xg, Tg, Ug, mh, nh, jh, kh, Eh, Fh, Bh, Ch, Wh, Xh, Th, Uh, hi, ii, mi, ei, fi, dk, ek, Om, Gi, Bi, hj, Ui, cj, Zi, qi, ko, ko, ko, ko];
var hb = [lo, Kd, he, pe, we, Ie, qf, gm, mm, sm, Am, fn, lo, lo, lo, lo];
var ib = [mo, Pd, Rd, Td, Ud, fk, gk, mo];
var jb = [no, oo];
var kb = [po, le, te, Ae, Le, Cf, Pf, cg, og, Ag, Lg, Yg, oh, Gh, Yh, ji, wm, po, po, po, po, po, po, po, po, po, po, po, po, po, po, po];
var lb = [qo, tf, uf, hm, nm, qo, qo, qo];
var mb = [ro, ie, qe, xe, He, tm, nn, mn];
var nb = [so, Hd, Jd, Ld, fe, me, ue, Ee, zf, Mf, $f, lg, xg, Ig, Vg, lh, Dh, Vh, gi, Wl, Xl, fm, jm, qm, zm, Nm, Zj, Kk, Lk, Wk, Vk,
_k];
var ob = [to, je, re, ye, Je, um, Fi, Ai, gj, Ti, bj, Yi, pi, to, to, to];
var pb = [uo, Qd, Sd, ke, se, ze, Ke, ri, Ci, Hi, Vi, _i, dj, ij, Yl, $l, cm, vm, gn, hn, uo, uo, uo, uo, uo, uo, uo, uo, uo, uo, uo, uo];
return {
_b2PrismaticJoint_IsMotorEnabled: Yc,
_b2Body_GetWorldVector: fc,
_strlen: yn,
_b2Body_GetLocalVector: _b,
_b2PrismaticJoint_GetMotorSpeed: Vc,
_b2RopeJointDef_Create: kd,
_b2World_CreateParticleSystem: sc,
_b2ParticleSystem_SetRadius: Dd,
_b2FrictionJointDef_Create: Gc,
_b2World_RayCast: yc,
_b2MotorJointDef_InitializeAndCreate: Pc,
_b2GearJoint_GetRatio: Ic,
_b2Body_GetLocalPoint: Zb,
_memcpy: An,
_b2RevoluteJoint_EnableLimit: cd,
_b2Body_DestroyFixture: Ub,
_b2World_Create: qc,
_b2PolygonShape_CreateFixture_3: Hb,
_b2PolygonShape_CreateFixture_6: Lb,
_b2PolygonShape_CreateFixture_7: Mb,
_b2PolygonShape_CreateFixture_4: Jb,
_b2PolygonShape_CreateFixture_5: Kb,
_b2Body_SetAwake: gc,
_b2Body_GetWorldCenter: dc,
_b2ParticleGroup_DestroyParticles: td,
_b2PrismaticJoint_EnableLimit: Sc,
_b2Fixture_TestPoint: mc,
_b2MotorJoint_SetLinearOffset: Nc,
_free: pn,
_b2ParticleSystem_CreateParticle: wd,
_b2Body_SetLinearVelocity: ic,
_b2CircleShape_CreateParticleGroup: Db,
_b2WeldJointDef_Create: ld,
_b2Body_GetAngularVelocity: Wb,
_b2Body_ApplyForceToCenter: Sb,
_b2DistanceJointDef_InitializeAndCreate: Fc,
_b2Body_ApplyForce: Rb,
_b2RevoluteJoint_SetMotorSpeed: jd,
_b2Body_GetPosition: ac,
_b2World_CreateBody: rc,
_b2Body_GetLinearVelocity: Yb,
_b2Body_SetMassData: jc,
_b2MouseJointDef_Create: Rc,
_b2ParticleSystem_GetColorBuffer: xd,
_b2DistanceJointDef_Create: Ec,
_b2ParticleSystem_GetPositionBuffer: zd,
_b2CircleShape_DestroyParticlesInShape: Eb,
_b2World_QueryAABB: xc,
_b2PolygonShape_DestroyParticlesInShape_4: Pb,
_b2RevoluteJointDef_InitializeAndCreate: id,
_b2GearJointDef_Create: Jc,
_b2PrismaticJoint_IsLimitEnabled: Xc,
_b2Contact_GetWorldManifold: Dc,
_b2WheelJoint_SetSpringFrequencyHz: od,
_b2Body_ApplyTorque: Tb,
_b2ParticleGroup_ApplyLinearImpulse: sd,
_b2PrismaticJointDef_InitializeAndCreate: $c,
_memset: xn,
_b2MotorJointDef_Create: Oc,
_b2World_DestroyBody: uc,
_b2RevoluteJointDef_Create: hd,
_b2ParticleGroup_GetParticleCount: vd,
_b2World_SetGravity: Ac,
_b2PrismaticJoint_EnableMotor: Tc,
_b2PolygonShape_CreateParticleGroup_4: Ob,
_b2PolygonShape_CreateFixture_8: Nb,
_b2Body_SetAngularVelocity: hc,
_b2Body_GetWorldPoint: ec,
_b2WheelJoint_SetMotorSpeed: nd,
_b2FrictionJointDef_InitializeAndCreate: Hc,
_b2World_SetContactListener: zc,
_b2ParticleSystem_SetDamping: Bd,
_b2Body_SetType: lc,
_b2Body_SetTransform: kc,
_b2CircleShape_CreateFixture: Bb,
_b2RevoluteJoint_GetJointAngle: ed,
_b2ParticleGroup_ApplyForce: rd,
_malloc: on,
_b2Contact_GetManifold: Cc,
_b2RevoluteJoint_IsMotorEnabled: gd,
_b2ParticleSystem_GetVelocityBuffer: Ad,
_b2RevoluteJoint_IsLimitEnabled: fd,
_b2World_DestroyParticleSystem: wc,
_b2RevoluteJoint_EnableMotor: dd,
_b2Body_GetTransform: bc,
_b2WeldJointDef_InitializeAndCreate: md,
_b2EdgeShape_CreateFixture: Fb,
_b2Body_GetType: cc,
_b2Manifold_GetPointCount: yb,
_b2ParticleSystem_SetDensity: Cd,
_b2PrismaticJoint_GetMotorForce: Wc,
_b2Joint_GetBodyA: Kc,
_b2PulleyJointDef_InitializeAndCreate: bd,
_b2Joint_GetBodyB: Lc,
_b2ParticleSystem_GetParticleCount: yd,
_b2MouseJoint_SetTarget: Qc,
_b2Body_ApplyAngularImpulse: Qb,
_b2ChainShape_CreateFixture: zb,
_b2World_DestroyJoint: vc,
_b2MotorJoint_SetAngularOffset: Mc,
_b2World_Delete: tc,
_b2PrismaticJoint_GetJointTranslation: Uc,
_i64Add: zn,
_b2Body_GetMass: $b,
_b2Body_GetAngle: Vb,
_b2ParticleGroup_GetBufferIndex: ud,
_b2WheelJointDef_InitializeAndCreate: qd,
_b2World_Step: Bc,
_b2PrismaticJointDef_Create: _c,
_b2WheelJointDef_Create: pd,
_b2PulleyJointDef_Create: ad,
_b2Body_GetInertia: Xb,
_memmove: Bn,
_b2PrismaticJoint_SetMotorSpeed: Zc,
__GLOBAL__I_a: Yd,
runPostSets: wn,
stackAlloc: qb,
stackSave: rb,
stackRestore: sb,
setThrew: tb,
setTempRet0: wb,
getTempRet0: xb,
dynCall_diiiiid: Pn,
dynCall_ii: Qn,
dynCall_viiiii: Rn,
dynCall_did: Sn,
dynCall_vi: Tn,
dynCall_diiiid: Un,
dynCall_vii: Vn,
dynCall_iiii: Wn,
dynCall_viii: Xn,
dynCall_v: Yn,
dynCall_viid: Zn,
dynCall_iiiii: _n,
dynCall_viiiiii: $n,
dynCall_iii: ao,
dynCall_iiiiii: bo,
dynCall_viiii: co
}
}({
"Math": Math,
"Int8Array": Int8Array,
"Int16Array": Int16Array,
"Int32Array": Int32Array,
"Uint8Array": Uint8Array,
"Uint16Array": Uint16Array,
"Uint32Array": Uint32Array,
"Float32Array": Float32Array,
"Float64Array": Float64Array
},
{
"abort": abort,
"assert": assert,
"asmPrintInt": asmPrintInt,
"asmPrintFloat": asmPrintFloat,
"min": Math_min,
"invoke_diiiiid": invoke_diiiiid,
"invoke_ii": invoke_ii,
"invoke_viiiii": invoke_viiiii,
"invoke_did": invoke_did,
"invoke_vi": invoke_vi,
"invoke_diiiid": invoke_diiiid,
"invoke_vii": invoke_vii,
"invoke_iiii": invoke_iiii,
"invoke_viii": invoke_viii,
"invoke_v": invoke_v,
"invoke_viid": invoke_viid,
"invoke_iiiii": invoke_iiiii,
"invoke_viiiiii": invoke_viiiiii,
"invoke_iii": invoke_iii,
"invoke_iiiiii": invoke_iiiiii,
"invoke_viiii": invoke_viiii,
"_cosf": _cosf,
"__ZSt9terminatev": __ZSt9terminatev,
"_b2WorldPreSolve": _b2WorldPreSolve,
"___cxa_is_number_type": ___cxa_is_number_type,
"___cxa_allocate_exception": ___cxa_allocate_exception,
"___cxa_find_matching_catch": ___cxa_find_matching_catch,
"_fflush": _fflush,
"_time": _time,
"__exit": __exit,
"___setErrNo": ___setErrNo,
"_sbrk": _sbrk,
"___cxa_begin_catch": ___cxa_begin_catch,
"_sinf": _sinf,
"___resumeException": ___resumeException,
"__ZSt18uncaught_exceptionv": __ZSt18uncaught_exceptionv,
"_b2WorldRayCastCallback": _b2WorldRayCastCallback,
"_emscripten_memcpy_big": _emscripten_memcpy_big,
"_floorf": _floorf,
"_sqrtf": _sqrtf,
"_b2WorldBeginContactBody": _b2WorldBeginContactBody,
"___errno_location": ___errno_location,
"__ZNSt9exceptionD2Ev": __ZNSt9exceptionD2Ev,
"___cxa_throw": ___cxa_throw,
"_sysconf": _sysconf,
"_abort": _abort,
"___cxa_does_inherit": ___cxa_does_inherit,
"_b2WorldEndContactBody": _b2WorldEndContactBody,
"_b2WorldQueryAABB": _b2WorldQueryAABB,
"_b2WorldPostSolve": _b2WorldPostSolve,
"_exit": _exit,
"___cxa_pure_virtual": ___cxa_pure_virtual,
"STACKTOP": STACKTOP,
"STACK_MAX": STACK_MAX,
"tempDoublePtr": tempDoublePtr,
"ABORT": ABORT,
"cttz_i8": cttz_i8,
"ctlz_i8": ctlz_i8,
"NaN": NaN,
"Infinity": Infinity,
"__ZTISt9exception": __ZTISt9exception
}, buffer);
var _b2PrismaticJoint_IsMotorEnabled = Module["_b2PrismaticJoint_IsMotorEnabled"] = asm["_b2PrismaticJoint_IsMotorEnabled"];
var _b2Body_GetWorldVector = Module["_b2Body_GetWorldVector"] = asm["_b2Body_GetWorldVector"];
var _strlen = Module["_strlen"] = asm["_strlen"];
var _b2Body_GetLocalVector = Module["_b2Body_GetLocalVector"] = asm["_b2Body_GetLocalVector"];
var _b2PrismaticJoint_GetMotorSpeed = Module["_b2PrismaticJoint_GetMotorSpeed"] = asm["_b2PrismaticJoint_GetMotorSpeed"];
var _b2RopeJointDef_Create = Module["_b2RopeJointDef_Create"] = asm["_b2RopeJointDef_Create"];
var _b2World_CreateParticleSystem = Module["_b2World_CreateParticleSystem"] = asm["_b2World_CreateParticleSystem"];
var _b2ParticleSystem_SetRadius = Module["_b2ParticleSystem_SetRadius"] = asm["_b2ParticleSystem_SetRadius"];
var _b2FrictionJointDef_Create = Module["_b2FrictionJointDef_Create"] = asm["_b2FrictionJointDef_Create"];
var _b2World_RayCast = Module["_b2World_RayCast"] = asm["_b2World_RayCast"];
var _b2MotorJointDef_InitializeAndCreate = Module["_b2MotorJointDef_InitializeAndCreate"] = asm["_b2MotorJointDef_InitializeAndCreate"];
var _b2GearJoint_GetRatio = Module["_b2GearJoint_GetRatio"] = asm["_b2GearJoint_GetRatio"];
var _b2Body_GetLocalPoint = Module["_b2Body_GetLocalPoint"] = asm["_b2Body_GetLocalPoint"];
var _memcpy = Module["_memcpy"] = asm["_memcpy"];
var _b2RevoluteJoint_EnableLimit = Module["_b2RevoluteJoint_EnableLimit"] = asm["_b2RevoluteJoint_EnableLimit"];
var _b2Body_DestroyFixture = Module["_b2Body_DestroyFixture"] = asm["_b2Body_DestroyFixture"];
var _b2World_Create = Module["_b2World_Create"] = asm["_b2World_Create"];
var _b2PolygonShape_CreateFixture_3 = Module["_b2PolygonShape_CreateFixture_3"] = asm["_b2PolygonShape_CreateFixture_3"];
var _b2PolygonShape_CreateFixture_6 = Module["_b2PolygonShape_CreateFixture_6"] = asm["_b2PolygonShape_CreateFixture_6"];
var _b2PolygonShape_CreateFixture_7 = Module["_b2PolygonShape_CreateFixture_7"] = asm["_b2PolygonShape_CreateFixture_7"];
var _b2PolygonShape_CreateFixture_4 = Module["_b2PolygonShape_CreateFixture_4"] = asm["_b2PolygonShape_CreateFixture_4"];
var _b2PolygonShape_CreateFixture_5 = Module["_b2PolygonShape_CreateFixture_5"] = asm["_b2PolygonShape_CreateFixture_5"];
var _b2Body_SetAwake = Module["_b2Body_SetAwake"] = asm["_b2Body_SetAwake"];
var _b2Body_GetWorldCenter = Module["_b2Body_GetWorldCenter"] = asm["_b2Body_GetWorldCenter"];
var _b2ParticleGroup_DestroyParticles = Module["_b2ParticleGroup_DestroyParticles"] = asm["_b2ParticleGroup_DestroyParticles"];
var _b2PrismaticJoint_EnableLimit = Module["_b2PrismaticJoint_EnableLimit"] = asm["_b2PrismaticJoint_EnableLimit"];
var _b2Fixture_TestPoint = Module["_b2Fixture_TestPoint"] = asm["_b2Fixture_TestPoint"];
var _b2MotorJoint_SetLinearOffset = Module["_b2MotorJoint_SetLinearOffset"] = asm["_b2MotorJoint_SetLinearOffset"];
var _free = Module["_free"] = asm["_free"];
var _b2ParticleSystem_CreateParticle = Module["_b2ParticleSystem_CreateParticle"] = asm["_b2ParticleSystem_CreateParticle"];
var _b2Body_SetLinearVelocity = Module["_b2Body_SetLinearVelocity"] = asm["_b2Body_SetLinearVelocity"];
var _b2CircleShape_CreateParticleGroup = Module["_b2CircleShape_CreateParticleGroup"] = asm["_b2CircleShape_CreateParticleGroup"];
var _b2WeldJointDef_Create = Module["_b2WeldJointDef_Create"] = asm["_b2WeldJointDef_Create"];
var _b2Body_GetAngularVelocity = Module["_b2Body_GetAngularVelocity"] = asm["_b2Body_GetAngularVelocity"];
var _b2Body_ApplyForceToCenter = Module["_b2Body_ApplyForceToCenter"] = asm["_b2Body_ApplyForceToCenter"];
var _b2DistanceJointDef_InitializeAndCreate = Module["_b2DistanceJointDef_InitializeAndCreate"] = asm["_b2DistanceJointDef_InitializeAndCreate"];
var _b2Body_ApplyForce = Module["_b2Body_ApplyForce"] = asm["_b2Body_ApplyForce"];
var _b2RevoluteJoint_SetMotorSpeed = Module["_b2RevoluteJoint_SetMotorSpeed"] = asm["_b2RevoluteJoint_SetMotorSpeed"];
var _b2Body_GetPosition = Module["_b2Body_GetPosition"] = asm["_b2Body_GetPosition"];
var _b2World_CreateBody = Module["_b2World_CreateBody"] = asm["_b2World_CreateBody"];
var _b2Body_GetLinearVelocity = Module["_b2Body_GetLinearVelocity"] = asm["_b2Body_GetLinearVelocity"];
var _b2Body_SetMassData = Module["_b2Body_SetMassData"] = asm["_b2Body_SetMassData"];
var _b2MouseJointDef_Create = Module["_b2MouseJointDef_Create"] = asm["_b2MouseJointDef_Create"];
var _b2ParticleSystem_GetColorBuffer = Module["_b2ParticleSystem_GetColorBuffer"] = asm["_b2ParticleSystem_GetColorBuffer"];
var _b2DistanceJointDef_Create = Module["_b2DistanceJointDef_Create"] = asm["_b2DistanceJointDef_Create"];
var _b2ParticleSystem_GetPositionBuffer = Module["_b2ParticleSystem_GetPositionBuffer"] = asm["_b2ParticleSystem_GetPositionBuffer"];
var _b2CircleShape_DestroyParticlesInShape = Module["_b2CircleShape_DestroyParticlesInShape"] = asm["_b2CircleShape_DestroyParticlesInShape"];
var _b2World_QueryAABB = Module["_b2World_QueryAABB"] = asm["_b2World_QueryAABB"];
var _b2PolygonShape_DestroyParticlesInShape_4 = Module["_b2PolygonShape_DestroyParticlesInShape_4"] = asm["_b2PolygonShape_DestroyParticlesInShape_4"];
var _b2RevoluteJointDef_InitializeAndCreate = Module["_b2RevoluteJointDef_InitializeAndCreate"] = asm["_b2RevoluteJointDef_InitializeAndCreate"];
var _b2GearJointDef_Create = Module["_b2GearJointDef_Create"] = asm["_b2GearJointDef_Create"];
var _b2PrismaticJoint_IsLimitEnabled = Module["_b2PrismaticJoint_IsLimitEnabled"] = asm["_b2PrismaticJoint_IsLimitEnabled"];
var _b2Contact_GetWorldManifold = Module["_b2Contact_GetWorldManifold"] = asm["_b2Contact_GetWorldManifold"];
var _b2WheelJoint_SetSpringFrequencyHz = Module["_b2WheelJoint_SetSpringFrequencyHz"] = asm["_b2WheelJoint_SetSpringFrequencyHz"];
var _b2Body_ApplyTorque = Module["_b2Body_ApplyTorque"] = asm["_b2Body_ApplyTorque"];
var _b2ParticleGroup_ApplyLinearImpulse = Module["_b2ParticleGroup_ApplyLinearImpulse"] = asm["_b2ParticleGroup_ApplyLinearImpulse"];
var _b2PrismaticJointDef_InitializeAndCreate = Module["_b2PrismaticJointDef_InitializeAndCreate"] = asm["_b2PrismaticJointDef_InitializeAndCreate"];
var _memset = Module["_memset"] = asm["_memset"];
var _b2MotorJointDef_Create = Module["_b2MotorJointDef_Create"] = asm["_b2MotorJointDef_Create"];
var _b2World_DestroyBody = Module["_b2World_DestroyBody"] = asm["_b2World_DestroyBody"];
var _b2RevoluteJointDef_Create = Module["_b2RevoluteJointDef_Create"] = asm["_b2RevoluteJointDef_Create"];
var _b2ParticleGroup_GetParticleCount = Module["_b2ParticleGroup_GetParticleCount"] = asm["_b2ParticleGroup_GetParticleCount"];
var _b2World_SetGravity = Module["_b2World_SetGravity"] = asm["_b2World_SetGravity"];
var _b2PrismaticJoint_EnableMotor = Module["_b2PrismaticJoint_EnableMotor"] = asm["_b2PrismaticJoint_EnableMotor"];
var _b2PolygonShape_CreateParticleGroup_4 = Module["_b2PolygonShape_CreateParticleGroup_4"] = asm["_b2PolygonShape_CreateParticleGroup_4"];
var _b2PolygonShape_CreateFixture_8 = Module["_b2PolygonShape_CreateFixture_8"] = asm["_b2PolygonShape_CreateFixture_8"];
var _b2Body_SetAngularVelocity = Module["_b2Body_SetAngularVelocity"] = asm["_b2Body_SetAngularVelocity"];
var _b2Body_GetWorldPoint = Module["_b2Body_GetWorldPoint"] = asm["_b2Body_GetWorldPoint"];
var _b2WheelJoint_SetMotorSpeed = Module["_b2WheelJoint_SetMotorSpeed"] = asm["_b2WheelJoint_SetMotorSpeed"];
var _b2FrictionJointDef_InitializeAndCreate = Module["_b2FrictionJointDef_InitializeAndCreate"] = asm["_b2FrictionJointDef_InitializeAndCreate"];
var _b2World_SetContactListener = Module["_b2World_SetContactListener"] = asm["_b2World_SetContactListener"];
var _b2ParticleSystem_SetDamping = Module["_b2ParticleSystem_SetDamping"] = asm["_b2ParticleSystem_SetDamping"];
var _b2Body_SetType = Module["_b2Body_SetType"] = asm["_b2Body_SetType"];
var _b2Body_SetTransform = Module["_b2Body_SetTransform"] = asm["_b2Body_SetTransform"];
var _b2CircleShape_CreateFixture = Module["_b2CircleShape_CreateFixture"] = asm["_b2CircleShape_CreateFixture"];
var _b2RevoluteJoint_GetJointAngle = Module["_b2RevoluteJoint_GetJointAngle"] = asm["_b2RevoluteJoint_GetJointAngle"];
var _b2ParticleGroup_ApplyForce = Module["_b2ParticleGroup_ApplyForce"] = asm["_b2ParticleGroup_ApplyForce"];
var _malloc = Module["_malloc"] = asm["_malloc"];
var _b2Contact_GetManifold = Module["_b2Contact_GetManifold"] = asm["_b2Contact_GetManifold"];
var _b2RevoluteJoint_IsMotorEnabled = Module["_b2RevoluteJoint_IsMotorEnabled"] = asm["_b2RevoluteJoint_IsMotorEnabled"];
var _b2ParticleSystem_GetVelocityBuffer = Module["_b2ParticleSystem_GetVelocityBuffer"] = asm["_b2ParticleSystem_GetVelocityBuffer"];
var _b2RevoluteJoint_IsLimitEnabled = Module["_b2RevoluteJoint_IsLimitEnabled"] = asm["_b2RevoluteJoint_IsLimitEnabled"];
var _b2World_DestroyParticleSystem = Module["_b2World_DestroyParticleSystem"] = asm["_b2World_DestroyParticleSystem"];
var _b2RevoluteJoint_EnableMotor = Module["_b2RevoluteJoint_EnableMotor"] = asm["_b2RevoluteJoint_EnableMotor"];
var _b2Body_GetTransform = Module["_b2Body_GetTransform"] = asm["_b2Body_GetTransform"];
var _b2WeldJointDef_InitializeAndCreate = Module["_b2WeldJointDef_InitializeAndCreate"] = asm["_b2WeldJointDef_InitializeAndCreate"];
var _b2EdgeShape_CreateFixture = Module["_b2EdgeShape_CreateFixture"] = asm["_b2EdgeShape_CreateFixture"];
var _b2Body_GetType = Module["_b2Body_GetType"] = asm["_b2Body_GetType"];
var _b2Manifold_GetPointCount = Module["_b2Manifold_GetPointCount"] = asm["_b2Manifold_GetPointCount"];
var _b2ParticleSystem_SetDensity = Module["_b2ParticleSystem_SetDensity"] = asm["_b2ParticleSystem_SetDensity"];
var _b2PrismaticJoint_GetMotorForce = Module["_b2PrismaticJoint_GetMotorForce"] = asm["_b2PrismaticJoint_GetMotorForce"];
var _b2Joint_GetBodyA = Module["_b2Joint_GetBodyA"] = asm["_b2Joint_GetBodyA"];
var _b2PulleyJointDef_InitializeAndCreate = Module["_b2PulleyJointDef_InitializeAndCreate"] = asm["_b2PulleyJointDef_InitializeAndCreate"];
var _b2Joint_GetBodyB = Module["_b2Joint_GetBodyB"] = asm["_b2Joint_GetBodyB"];
var _b2ParticleSystem_GetParticleCount = Module["_b2ParticleSystem_GetParticleCount"] = asm["_b2ParticleSystem_GetParticleCount"];
var _b2MouseJoint_SetTarget = Module["_b2MouseJoint_SetTarget"] = asm["_b2MouseJoint_SetTarget"];
var _b2Body_ApplyAngularImpulse = Module["_b2Body_ApplyAngularImpulse"] = asm["_b2Body_ApplyAngularImpulse"];
var _b2ChainShape_CreateFixture = Module["_b2ChainShape_CreateFixture"] = asm["_b2ChainShape_CreateFixture"];
var _b2World_DestroyJoint = Module["_b2World_DestroyJoint"] = asm["_b2World_DestroyJoint"];
var _b2MotorJoint_SetAngularOffset = Module["_b2MotorJoint_SetAngularOffset"] = asm["_b2MotorJoint_SetAngularOffset"];
var _b2World_Delete = Module["_b2World_Delete"] = asm["_b2World_Delete"];
var _b2PrismaticJoint_GetJointTranslation = Module["_b2PrismaticJoint_GetJointTranslation"] = asm["_b2PrismaticJoint_GetJointTranslation"];
var _i64Add = Module["_i64Add"] = asm["_i64Add"];
var _b2Body_GetMass = Module["_b2Body_GetMass"] = asm["_b2Body_GetMass"];
var _b2Body_GetAngle = Module["_b2Body_GetAngle"] = asm["_b2Body_GetAngle"];
var _b2ParticleGroup_GetBufferIndex = Module["_b2ParticleGroup_GetBufferIndex"] = asm["_b2ParticleGroup_GetBufferIndex"];
var _b2WheelJointDef_InitializeAndCreate = Module["_b2WheelJointDef_InitializeAndCreate"] = asm["_b2WheelJointDef_InitializeAndCreate"];
var _b2World_Step = Module["_b2World_Step"] = asm["_b2World_Step"];
var _b2PrismaticJointDef_Create = Module["_b2PrismaticJointDef_Create"] = asm["_b2PrismaticJointDef_Create"];
var _b2WheelJointDef_Create = Module["_b2WheelJointDef_Create"] = asm["_b2WheelJointDef_Create"];
var _b2PulleyJointDef_Create = Module["_b2PulleyJointDef_Create"] = asm["_b2PulleyJointDef_Create"];
var _b2Body_GetInertia = Module["_b2Body_GetInertia"] = asm["_b2Body_GetInertia"];
var _memmove = Module["_memmove"] = asm["_memmove"];
var _b2PrismaticJoint_SetMotorSpeed = Module["_b2PrismaticJoint_SetMotorSpeed"] = asm["_b2PrismaticJoint_SetMotorSpeed"];
var __GLOBAL__I_a = Module["__GLOBAL__I_a"] = asm["__GLOBAL__I_a"];
var runPostSets = Module["runPostSets"] = asm["runPostSets"];
var dynCall_diiiiid = Module["dynCall_diiiiid"] = asm["dynCall_diiiiid"];
var dynCall_ii = Module["dynCall_ii"] = asm["dynCall_ii"];
var dynCall_viiiii = Module["dynCall_viiiii"] = asm["dynCall_viiiii"];
var dynCall_did = Module["dynCall_did"] = asm["dynCall_did"];
var dynCall_vi = Module["dynCall_vi"] = asm["dynCall_vi"];
var dynCall_diiiid = Module["dynCall_diiiid"] = asm["dynCall_diiiid"];
var dynCall_vii = Module["dynCall_vii"] = asm["dynCall_vii"];
var dynCall_iiii = Module["dynCall_iiii"] = asm["dynCall_iiii"];
var dynCall_viii = Module["dynCall_viii"] = asm["dynCall_viii"];
var dynCall_v = Module["dynCall_v"] = asm["dynCall_v"];
var dynCall_viid = Module["dynCall_viid"] = asm["dynCall_viid"];
var dynCall_iiiii = Module["dynCall_iiiii"] = asm["dynCall_iiiii"];
var dynCall_viiiiii = Module["dynCall_viiiiii"] = asm["dynCall_viiiiii"];
var dynCall_iii = Module["dynCall_iii"] = asm["dynCall_iii"];
var dynCall_iiiiii = Module["dynCall_iiiiii"] = asm["dynCall_iiiiii"];
var dynCall_viiii = Module["dynCall_viiii"] = asm["dynCall_viiii"];
Runtime.stackAlloc = asm["stackAlloc"];
Runtime.stackSave = asm["stackSave"];
Runtime.stackRestore = asm["stackRestore"];
Runtime.setTempRet0 = asm["setTempRet0"];
Runtime.getTempRet0 = asm["getTempRet0"];
var i64Math = function() {
var goog = {
math: {}
};
goog.math.Long = function(low, high) {
this.low_ = low | 0;
this.high_ = high | 0
};
goog.math.Long.IntCache_ = {};
goog.math.Long.fromInt = function(value) {
if (-128 <= value && value < 128) {
var cachedObj = goog.math.Long.IntCache_[value];
if (cachedObj)
return cachedObj
}
var obj = new goog.math.Long(value | 0, value < 0 ? -1 : 0);
if (-128 <= value && value < 128)
goog.math.Long.IntCache_[value] = obj;
return obj
};
goog.math.Long.fromNumber = function(value) {
if (isNaN(value) || !isFinite(value))
return goog.math.Long.ZERO;
else if (value <= -goog.math.Long.TWO_PWR_63_DBL_)
return goog.math.Long.MIN_VALUE;
else if (value + 1 >= goog.math.Long.TWO_PWR_63_DBL_)
return goog.math.Long.MAX_VALUE;
else if (value < 0)
return goog.math.Long.fromNumber(-value).negate();
else
return new goog.math.Long(value % goog.math.Long.TWO_PWR_32_DBL_ | 0, value / goog.math.Long.TWO_PWR_32_DBL_ | 0)
};
goog.math.Long.fromBits = function(lowBits, highBits) {
return new goog.math.Long(lowBits, highBits)
};
goog.math.Long.fromString = function(str, opt_radix) {
if (str.length == 0)
throw Error("number format error: empty string");
var radix = opt_radix || 10;
if (radix < 2 || 36 < radix)
throw Error("radix out of range: " + radix);
if (str.charAt(0) == "-")
return goog.math.Long.fromString(str.substring(1), radix).negate();
else if (str.indexOf("-") >= 0)
throw Error('number format error: interior "-" character: ' + str);
var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 8));
var result = goog.math.Long.ZERO;
for (var i = 0; i < str.length; i += 8) {
var size = Math.min(8, str.length - i);
var value = parseInt(str.substring(i, i + size), radix);
if (size < 8) {
var power = goog.math.Long.fromNumber(Math.pow(radix,
size));
result = result.multiply(power).add(goog.math.Long.fromNumber(value))
} else {
result = result.multiply(radixToPower);
result = result.add(goog.math.Long.fromNumber(value))
}
}
return result
};
goog.math.Long.TWO_PWR_16_DBL_ = 1 << 16;
goog.math.Long.TWO_PWR_24_DBL_ = 1 << 24;
goog.math.Long.TWO_PWR_32_DBL_ = goog.math.Long.TWO_PWR_16_DBL_ * goog.math.Long.TWO_PWR_16_DBL_;
goog.math.Long.TWO_PWR_31_DBL_ = goog.math.Long.TWO_PWR_32_DBL_ / 2;
goog.math.Long.TWO_PWR_48_DBL_ = goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_16_DBL_;
goog.math.Long.TWO_PWR_64_DBL_ = goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_32_DBL_;
goog.math.Long.TWO_PWR_63_DBL_ = goog.math.Long.TWO_PWR_64_DBL_ / 2;
goog.math.Long.ZERO = goog.math.Long.fromInt(0);
goog.math.Long.ONE = goog.math.Long.fromInt(1);
goog.math.Long.NEG_ONE = goog.math.Long.fromInt(-1);
goog.math.Long.MAX_VALUE = goog.math.Long.fromBits(4294967295 | 0, 2147483647 | 0);
goog.math.Long.MIN_VALUE = goog.math.Long.fromBits(0, 2147483648 | 0);
goog.math.Long.TWO_PWR_24_ = goog.math.Long.fromInt(1 << 24);
goog.math.Long.prototype.toInt =
function() {
return this.low_
};
goog.math.Long.prototype.toNumber = function() {
return this.high_ * goog.math.Long.TWO_PWR_32_DBL_ + this.getLowBitsUnsigned()
};
goog.math.Long.prototype.toString = function(opt_radix) {
var radix = opt_radix || 10;
if (radix < 2 || 36 < radix)
throw Error("radix out of range: " + radix);
if (this.isZero())
return "0";
if (this.isNegative())
if (this.equals(goog.math.Long.MIN_VALUE)) {
var radixLong = goog.math.Long.fromNumber(radix);
var div = this.div(radixLong);
var rem = div.multiply(radixLong).subtract(this);
return div.toString(radix) + rem.toInt().toString(radix)
} else
return "-" + this.negate().toString(radix);
var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 6));
var rem = this;
var result = "";
while (true) {
var remDiv = rem.div(radixToPower);
var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt();
var digits = intval.toString(radix);
rem = remDiv;
if (rem.isZero())
return digits + result;
else {
while (digits.length < 6)
digits = "0" + digits;
result = "" + digits + result
}
}
};
goog.math.Long.prototype.getHighBits = function() {
return this.high_
};
goog.math.Long.prototype.getLowBits = function() {
return this.low_
};
goog.math.Long.prototype.getLowBitsUnsigned = function() {
return this.low_ >= 0 ? this.low_ : goog.math.Long.TWO_PWR_32_DBL_ + this.low_
};
goog.math.Long.prototype.getNumBitsAbs = function() {
if (this.isNegative())
if (this.equals(goog.math.Long.MIN_VALUE))
return 64;
else
return this.negate().getNumBitsAbs();
else {
var val = this.high_ != 0 ? this.high_ : this.low_;
for (var bit = 31; bit > 0; bit--)
if ((val & 1 << bit) != 0)
break;
return this.high_ != 0 ? bit + 33 : bit + 1
}
};
goog.math.Long.prototype.isZero =
function() {
return this.high_ == 0 && this.low_ == 0
};
goog.math.Long.prototype.isNegative = function() {
return this.high_ < 0
};
goog.math.Long.prototype.isOdd = function() {
return (this.low_ & 1) == 1
};
goog.math.Long.prototype.equals = function(other) {
return this.high_ == other.high_ && this.low_ == other.low_
};
goog.math.Long.prototype.notEquals = function(other) {
return this.high_ != other.high_ || this.low_ != other.low_
};
goog.math.Long.prototype.lessThan = function(other) {
return this.compare(other) < 0
};
goog.math.Long.prototype.lessThanOrEqual =
function(other) {
return this.compare(other) <= 0
};
goog.math.Long.prototype.greaterThan = function(other) {
return this.compare(other) > 0
};
goog.math.Long.prototype.greaterThanOrEqual = function(other) {
return this.compare(other) >= 0
};
goog.math.Long.prototype.compare = function(other) {
if (this.equals(other))
return 0;
var thisNeg = this.isNegative();
var otherNeg = other.isNegative();
if (thisNeg && !otherNeg)
return -1;
if (!thisNeg && otherNeg)
return 1;
if (this.subtract(other).isNegative())
return -1;
else
return 1
};
goog.math.Long.prototype.negate =
function() {
if (this.equals(goog.math.Long.MIN_VALUE))
return goog.math.Long.MIN_VALUE;
else
return this.not().add(goog.math.Long.ONE)
};
goog.math.Long.prototype.add = function(other) {
var a48 = this.high_ >>> 16;
var a32 = this.high_ & 65535;
var a16 = this.low_ >>> 16;
var a00 = this.low_ & 65535;
var b48 = other.high_ >>> 16;
var b32 = other.high_ & 65535;
var b16 = other.low_ >>> 16;
var b00 = other.low_ & 65535;
var c48 = 0,
c32 = 0,
c16 = 0,
c00 = 0;
c00 += a00 + b00;
c16 += c00 >>> 16;
c00 &= 65535;
c16 += a16 + b16;
c32 += c16 >>> 16;
c16 &= 65535;
c32 += a32 + b32;
c48 += c32 >>>
16;
c32 &= 65535;
c48 += a48 + b48;
c48 &= 65535;
return goog.math.Long.fromBits(c16 << 16 | c00, c48 << 16 | c32)
};
goog.math.Long.prototype.subtract = function(other) {
return this.add(other.negate())
};
goog.math.Long.prototype.multiply = function(other) {
if (this.isZero())
return goog.math.Long.ZERO;
else if (other.isZero())
return goog.math.Long.ZERO;
if (this.equals(goog.math.Long.MIN_VALUE))
return other.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO;
else if (other.equals(goog.math.Long.MIN_VALUE))
return this.isOdd() ? goog.math.Long.MIN_VALUE :
goog.math.Long.ZERO;
if (this.isNegative())
if (other.isNegative())
return this.negate().multiply(other.negate());
else
return this.negate().multiply(other).negate();
else if (other.isNegative())
return this.multiply(other.negate()).negate();
if (this.lessThan(goog.math.Long.TWO_PWR_24_) && other.lessThan(goog.math.Long.TWO_PWR_24_))
return goog.math.Long.fromNumber(this.toNumber() * other.toNumber());
var a48 = this.high_ >>> 16;
var a32 = this.high_ & 65535;
var a16 = this.low_ >>> 16;
var a00 = this.low_ & 65535;
var b48 = other.high_ >>>
16;
var b32 = other.high_ & 65535;
var b16 = other.low_ >>> 16;
var b00 = other.low_ & 65535;
var c48 = 0,
c32 = 0,
c16 = 0,
c00 = 0;
c00 += a00 * b00;
c16 += c00 >>> 16;
c00 &= 65535;
c16 += a16 * b00;
c32 += c16 >>> 16;
c16 &= 65535;
c16 += a00 * b16;
c32 += c16 >>> 16;
c16 &= 65535;
c32 += a32 * b00;
c48 += c32 >>> 16;
c32 &= 65535;
c32 += a16 * b16;
c48 += c32 >>> 16;
c32 &= 65535;
c32 += a00 * b32;
c48 += c32 >>> 16;
c32 &= 65535;
c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
c48 &= 65535;
return goog.math.Long.fromBits(c16 << 16 | c00, c48 << 16 | c32)
};
goog.math.Long.prototype.div = function(other) {
if (other.isZero())
throw Error("division by zero");
else if (this.isZero())
return goog.math.Long.ZERO;
if (this.equals(goog.math.Long.MIN_VALUE))
if (other.equals(goog.math.Long.ONE) || other.equals(goog.math.Long.NEG_ONE))
return goog.math.Long.MIN_VALUE;
else if (other.equals(goog.math.Long.MIN_VALUE))
return goog.math.Long.ONE;
else {
var halfThis = this.shiftRight(1);
var approx = halfThis.div(other).shiftLeft(1);
if (approx.equals(goog.math.Long.ZERO))
return other.isNegative() ? goog.math.Long.ONE : goog.math.Long.NEG_ONE;
else {
var rem = this.subtract(other.multiply(approx));
var result = approx.add(rem.div(other));
return result
}
}
else if (other.equals(goog.math.Long.MIN_VALUE))
return goog.math.Long.ZERO;
if (this.isNegative())
if (other.isNegative())
return this.negate().div(other.negate());
else
return this.negate().div(other).negate();
else if (other.isNegative())
return this.div(other.negate()).negate();
var res = goog.math.Long.ZERO;
var rem = this;
while (rem.greaterThanOrEqual(other)) {
var approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));
var log2 = Math.ceil(Math.log(approx) /
Math.LN2);
var delta = log2 <= 48 ? 1 : Math.pow(2, log2 - 48);
var approxRes = goog.math.Long.fromNumber(approx);
var approxRem = approxRes.multiply(other);
while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
approx -= delta;
approxRes = goog.math.Long.fromNumber(approx);
approxRem = approxRes.multiply(other)
}
if (approxRes.isZero())
approxRes = goog.math.Long.ONE;
res = res.add(approxRes);
rem = rem.subtract(approxRem)
}
return res
};
goog.math.Long.prototype.modulo = function(other) {
return this.subtract(this.div(other).multiply(other))
};
goog.math.Long.prototype.not = function() {
return goog.math.Long.fromBits(~this.low_, ~this.high_)
};
goog.math.Long.prototype.and = function(other) {
return goog.math.Long.fromBits(this.low_ & other.low_, this.high_ & other.high_)
};
goog.math.Long.prototype.or = function(other) {
return goog.math.Long.fromBits(this.low_ | other.low_, this.high_ | other.high_)
};
goog.math.Long.prototype.xor = function(other) {
return goog.math.Long.fromBits(this.low_ ^ other.low_, this.high_ ^ other.high_)
};
goog.math.Long.prototype.shiftLeft = function(numBits) {
numBits &=
63;
if (numBits == 0)
return this;
else {
var low = this.low_;
if (numBits < 32) {
var high = this.high_;
return goog.math.Long.fromBits(low << numBits, high << numBits | low >>> 32 - numBits)
} else
return goog.math.Long.fromBits(0, low << numBits - 32)
}
};
goog.math.Long.prototype.shiftRight = function(numBits) {
numBits &= 63;
if (numBits == 0)
return this;
else {
var high = this.high_;
if (numBits < 32) {
var low = this.low_;
return goog.math.Long.fromBits(low >>> numBits | high << 32 - numBits, high >> numBits)
} else
return goog.math.Long.fromBits(high >> numBits - 32, high >=
0 ? 0 : -1)
}
};
goog.math.Long.prototype.shiftRightUnsigned = function(numBits) {
numBits &= 63;
if (numBits == 0)
return this;
else {
var high = this.high_;
if (numBits < 32) {
var low = this.low_;
return goog.math.Long.fromBits(low >>> numBits | high << 32 - numBits, high >>> numBits)
} else if (numBits == 32)
return goog.math.Long.fromBits(high, 0);
else
return goog.math.Long.fromBits(high >>> numBits - 32, 0)
}
};
var navigator = {
appName: "Modern Browser"
};
var dbits;
var canary = 0xdeadbeefcafe;
var j_lm = (canary & 16777215) == 15715070;
function BigInteger(a, b,
c) {
if (a != null)
if ("number" == typeof a)
this.fromNumber(a, b, c);
else if (b == null && "string" != typeof a)
this.fromString(a, 256);
else
this.fromString(a, b)
}
function nbi() {
return new BigInteger(null)
}
function am1(i, x, w, j, c, n) {
while (--n >= 0) {
var v = x * this[i++] + w[j] + c;
c = Math.floor(v / 67108864);
w[j++] = v & 67108863
}
return c
}
function am2(i, x, w, j, c, n) {
var xl = x & 32767,
xh = x >> 15;
while (--n >= 0) {
var l = this[i] & 32767;
var h = this[i++] >> 15;
var m = xh * l + h * xl;
l = xl * l + ((m & 32767) << 15) + w[j] + (c & 1073741823);
c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30);
w[j++] = l & 1073741823
}
return c
}
function am3(i, x, w, j, c, n) {
var xl = x & 16383,
xh = x >> 14;
while (--n >= 0) {
var l = this[i] & 16383;
var h = this[i++] >> 14;
var m = xh * l + h * xl;
l = xl * l + ((m & 16383) << 14) + w[j] + c;
c = (l >> 28) + (m >> 14) + xh * h;
w[j++] = l & 268435455
}
return c
}
if (j_lm && navigator.appName == "Microsoft Internet Explorer") {
BigInteger.prototype.am = am2;
dbits = 30
} else if (j_lm && navigator.appName != "Netscape") {
BigInteger.prototype.am = am1;
dbits = 26
} else {
BigInteger.prototype.am = am3;
dbits = 28
}
BigInteger.prototype.DB = dbits;
BigInteger.prototype.DM =
(1 << dbits) - 1;
BigInteger.prototype.DV = 1 << dbits;
var BI_FP = 52;
BigInteger.prototype.FV = Math.pow(2, BI_FP);
BigInteger.prototype.F1 = BI_FP - dbits;
BigInteger.prototype.F2 = 2 * dbits - BI_FP;
var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
var BI_RC = new Array;
var rr,
vv;
rr = "0".charCodeAt(0);
for (vv = 0; vv <= 9; ++vv)
BI_RC[rr++] = vv;
rr = "a".charCodeAt(0);
for (vv = 10; vv < 36; ++vv)
BI_RC[rr++] = vv;
rr = "A".charCodeAt(0);
for (vv = 10; vv < 36; ++vv)
BI_RC[rr++] = vv;
function int2char(n) {
return BI_RM.charAt(n)
}
function intAt(s, i) {
var c = BI_RC[s.charCodeAt(i)];
return c == null ? -1 : c
}
function bnpCopyTo(r) {
for (var i = this.t - 1; i >= 0; --i)
r[i] = this[i];
r.t = this.t;
r.s = this.s
}
function bnpFromInt(x) {
this.t = 1;
this.s = x < 0 ? -1 : 0;
if (x > 0)
this[0] = x;
else if (x < -1)
this[0] = x + DV;
else
this.t = 0
}
function nbv(i) {
var r = nbi();
r.fromInt(i);
return r
}
function bnpFromString(s, b) {
var k;
if (b == 16)
k = 4;
else if (b == 8)
k = 3;
else if (b == 256)
k = 8;
else if (b == 2)
k = 1;
else if (b == 32)
k = 5;
else if (b == 4)
k = 2;
else {
this.fromRadix(s, b);
return
}
this.t = 0;
this.s = 0;
var i = s.length,
mi = false,
sh = 0;
while (--i >= 0) {
var x = k == 8 ? s[i] &
255 : intAt(s, i);
if (x < 0) {
if (s.charAt(i) == "-")
mi = true;
continue
}
mi = false;
if (sh == 0)
this[this.t++] = x;
else if (sh + k > this.DB) {
this[this.t - 1] |= (x & (1 << this.DB - sh) - 1) << sh;
this[this.t++] = x >> this.DB - sh
} else
this[this.t - 1] |= x << sh;
sh += k;
if (sh >= this.DB)
sh -= this.DB
}
if (k == 8 && (s[0] & 128) != 0) {
this.s = -1;
if (sh > 0)
this[this.t - 1] |= (1 << this.DB - sh) - 1 << sh
}
this.clamp();
if (mi)
BigInteger.ZERO.subTo(this, this)
}
function bnpClamp() {
var c = this.s & this.DM;
while (this.t > 0 && this[this.t - 1] == c)
--this.t
}
function bnToString(b) {
if (this.s < 0)
return "-" +
this.negate().toString(b);
var k;
if (b == 16)
k = 4;
else if (b == 8)
k = 3;
else if (b == 2)
k = 1;
else if (b == 32)
k = 5;
else if (b == 4)
k = 2;
else
return this.toRadix(b);
var km = (1 << k) - 1,
d,
m = false,
r = "",
i = this.t;
var p = this.DB - i * this.DB % k;
if (i-- > 0) {
if (p < this.DB && (d = this[i] >> p) > 0) {
m = true;
r = int2char(d)
}
while (i >= 0) {
if (p < k) {
d = (this[i] & (1 << p) - 1) << k - p;
d |= this[--i] >> (p += this.DB - k)
} else {
d = this[i] >> (p -= k) & km;
if (p <= 0) {
p += this.DB;
--i
}
}
if (d > 0)
m = true;
if (m)
r += int2char(d)
}
}
return m ? r : "0"
}
function bnNegate() {
var r = nbi();
BigInteger.ZERO.subTo(this,
r);
return r
}
function bnAbs() {
return this.s < 0 ? this.negate() : this
}
function bnCompareTo(a) {
var r = this.s - a.s;
if (r != 0)
return r;
var i = this.t;
r = i - a.t;
if (r != 0)
return this.s < 0 ? -r : r;
while (--i >= 0)
if ((r = this[i] - a[i]) != 0)
return r;
return 0
}
function nbits(x) {
var r = 1,
t;
if ((t = x >>> 16) != 0) {
x = t;
r += 16
}
if ((t = x >> 8) != 0) {
x = t;
r += 8
}
if ((t = x >> 4) != 0) {
x = t;
r += 4
}
if ((t = x >> 2) != 0) {
x = t;
r += 2
}
if ((t = x >> 1) != 0) {
x = t;
r += 1
}
return r
}
function bnBitLength() {
if (this.t <= 0)
return 0;
return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ this.s & this.DM)
}
function bnpDLShiftTo(n,
r) {
var i;
for (i = this.t - 1; i >= 0; --i)
r[i + n] = this[i];
for (i = n - 1; i >= 0; --i)
r[i] = 0;
r.t = this.t + n;
r.s = this.s
}
function bnpDRShiftTo(n, r) {
for (var i = n; i < this.t; ++i)
r[i - n] = this[i];
r.t = Math.max(this.t - n, 0);
r.s = this.s
}
function bnpLShiftTo(n, r) {
var bs = n % this.DB;
var cbs = this.DB - bs;
var bm = (1 << cbs) - 1;
var ds = Math.floor(n / this.DB),
c = this.s << bs & this.DM,
i;
for (i = this.t - 1; i >= 0; --i) {
r[i + ds + 1] = this[i] >> cbs | c;
c = (this[i] & bm) << bs
}
for (i = ds - 1; i >= 0; --i)
r[i] = 0;
r[ds] = c;
r.t = this.t + ds + 1;
r.s = this.s;
r.clamp()
}
function bnpRShiftTo(n, r) {
r.s =
this.s;
var ds = Math.floor(n / this.DB);
if (ds >= this.t) {
r.t = 0;
return
}
var bs = n % this.DB;
var cbs = this.DB - bs;
var bm = (1 << bs) - 1;
r[0] = this[ds] >> bs;
for (var i = ds + 1; i < this.t; ++i) {
r[i - ds - 1] |= (this[i] & bm) << cbs;
r[i - ds] = this[i] >> bs
}
if (bs > 0)
r[this.t - ds - 1] |= (this.s & bm) << cbs;
r.t = this.t - ds;
r.clamp()
}
function bnpSubTo(a, r) {
var i = 0,
c = 0,
m = Math.min(a.t, this.t);
while (i < m) {
c += this[i] - a[i];
r[i++] = c & this.DM;
c >>= this.DB
}
if (a.t < this.t) {
c -= a.s;
while (i < this.t) {
c += this[i];
r[i++] = c & this.DM;
c >>= this.DB
}
c += this.s
} else {
c += this.s;
while (i <
a.t) {
c -= a[i];
r[i++] = c & this.DM;
c >>= this.DB
}
c -= a.s
}
r.s = c < 0 ? -1 : 0;
if (c < -1)
r[i++] = this.DV + c;
else if (c > 0)
r[i++] = c;
r.t = i;
r.clamp()
}
function bnpMultiplyTo(a, r) {
var x = this.abs(),
y = a.abs();
var i = x.t;
r.t = i + y.t;
while (--i >= 0)
r[i] = 0;
for (i = 0; i < y.t; ++i)
r[i + x.t] = x.am(0, y[i], r, i, 0, x.t);
r.s = 0;
r.clamp();
if (this.s != a.s)
BigInteger.ZERO.subTo(r, r)
}
function bnpSquareTo(r) {
var x = this.abs();
var i = r.t = 2 * x.t;
while (--i >= 0)
r[i] = 0;
for (i = 0; i < x.t - 1; ++i) {
var c = x.am(i, x[i], r, 2 * i, 0, 1);
if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >=
x.DV) {
r[i + x.t] -= x.DV;
r[i + x.t + 1] = 1
}
}
if (r.t > 0)
r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1);
r.s = 0;
r.clamp()
}
function bnpDivRemTo(m, q, r) {
var pm = m.abs();
if (pm.t <= 0)
return;
var pt = this.abs();
if (pt.t < pm.t) {
if (q != null)
q.fromInt(0);
if (r != null)
this.copyTo(r);
return
}
if (r == null)
r = nbi();
var y = nbi(),
ts = this.s,
ms = m.s;
var nsh = this.DB - nbits(pm[pm.t - 1]);
if (nsh > 0) {
pm.lShiftTo(nsh, y);
pt.lShiftTo(nsh, r)
} else {
pm.copyTo(y);
pt.copyTo(r)
}
var ys = y.t;
var y0 = y[ys - 1];
if (y0 == 0)
return;
var yt = y0 * (1 << this.F1) + (ys > 1 ? y[ys - 2] >> this.F2 : 0);
var d1 =
this.FV / yt,
d2 = (1 << this.F1) / yt,
e = 1 << this.F2;
var i = r.t,
j = i - ys,
t = q == null ? nbi() : q;
y.dlShiftTo(j, t);
if (r.compareTo(t) >= 0) {
r[r.t++] = 1;
r.subTo(t, r)
}
BigInteger.ONE.dlShiftTo(ys, t);
t.subTo(y, y);
while (y.t < ys)
y[y.t++] = 0;
while (--j >= 0) {
var qd = r[--i] == y0 ? this.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2);
if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) {
y.dlShiftTo(j, t);
r.subTo(t, r);
while (r[i] < --qd)
r.subTo(t, r)
}
}
if (q != null) {
r.drShiftTo(ys, q);
if (ts != ms)
BigInteger.ZERO.subTo(q, q)
}
r.t = ys;
r.clamp();
if (nsh > 0)
r.rShiftTo(nsh, r);
if (ts < 0)
BigInteger.ZERO.subTo(r,
r)
}
function bnMod(a) {
var r = nbi();
this.abs().divRemTo(a, null, r);
if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0)
a.subTo(r, r);
return r
}
function Classic(m) {
this.m = m
}
function cConvert(x) {
if (x.s < 0 || x.compareTo(this.m) >= 0)
return x.mod(this.m);
else
return x
}
function cRevert(x) {
return x
}
function cReduce(x) {
x.divRemTo(this.m, null, x)
}
function cMulTo(x, y, r) {
x.multiplyTo(y, r);
this.reduce(r)
}
function cSqrTo(x, r) {
x.squareTo(r);
this.reduce(r)
}
Classic.prototype.convert = cConvert;
Classic.prototype.revert = cRevert;
Classic.prototype.reduce =
cReduce;
Classic.prototype.mulTo = cMulTo;
Classic.prototype.sqrTo = cSqrTo;
function bnpInvDigit() {
if (this.t < 1)
return 0;
var x = this[0];
if ((x & 1) == 0)
return 0;
var y = x & 3;
y = y * (2 - (x & 15) * y) & 15;
y = y * (2 - (x & 255) * y) & 255;
y = y * (2 - ((x & 65535) * y & 65535)) & 65535;
y = y * (2 - x * y % this.DV) % this.DV;
return y > 0 ? this.DV - y : -y
}
function Montgomery(m) {
this.m = m;
this.mp = m.invDigit();
this.mpl = this.mp & 32767;
this.mph = this.mp >> 15;
this.um = (1 << m.DB - 15) - 1;
this.mt2 = 2 * m.t
}
function montConvert(x) {
var r = nbi();
x.abs().dlShiftTo(this.m.t, r);
r.divRemTo(this.m,
null, r);
if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0)
this.m.subTo(r, r);
return r
}
function montRevert(x) {
var r = nbi();
x.copyTo(r);
this.reduce(r);
return r
}
function montReduce(x) {
while (x.t <= this.mt2)
x[x.t++] = 0;
for (var i = 0; i < this.m.t; ++i) {
var j = x[i] & 32767;
var u0 = j * this.mpl + ((j * this.mph + (x[i] >> 15) * this.mpl & this.um) << 15) & x.DM;
j = i + this.m.t;
x[j] += this.m.am(0, u0, x, i, 0, this.m.t);
while (x[j] >= x.DV) {
x[j] -= x.DV;
x[++j]++
}
}
x.clamp();
x.drShiftTo(this.m.t, x);
if (x.compareTo(this.m) >= 0)
x.subTo(this.m, x)
}
function montSqrTo(x,
r) {
x.squareTo(r);
this.reduce(r)
}
function montMulTo(x, y, r) {
x.multiplyTo(y, r);
this.reduce(r)
}
Montgomery.prototype.convert = montConvert;
Montgomery.prototype.revert = montRevert;
Montgomery.prototype.reduce = montReduce;
Montgomery.prototype.mulTo = montMulTo;
Montgomery.prototype.sqrTo = montSqrTo;
function bnpIsEven() {
return (this.t > 0 ? this[0] & 1 : this.s) == 0
}
function bnpExp(e, z) {
if (e > 4294967295 || e < 1)
return BigInteger.ONE;
var r = nbi(),
r2 = nbi(),
g = z.convert(this),
i = nbits(e) - 1;
g.copyTo(r);
while (--i >= 0) {
z.sqrTo(r, r2);
if ((e &
1 << i) > 0)
z.mulTo(r2, g, r);
else {
var t = r;
r = r2;
r2 = t
}
}
return z.revert(r)
}
function bnModPowInt(e, m) {
var z;
if (e < 256 || m.isEven())
z = new Classic(m);
else
z = new Montgomery(m);
return this.exp(e, z)
}
BigInteger.prototype.copyTo = bnpCopyTo;
BigInteger.prototype.fromInt = bnpFromInt;
BigInteger.prototype.fromString = bnpFromString;
BigInteger.prototype.clamp = bnpClamp;
BigInteger.prototype.dlShiftTo = bnpDLShiftTo;
BigInteger.prototype.drShiftTo = bnpDRShiftTo;
BigInteger.prototype.lShiftTo = bnpLShiftTo;
BigInteger.prototype.rShiftTo =
bnpRShiftTo;
BigInteger.prototype.subTo = bnpSubTo;
BigInteger.prototype.multiplyTo = bnpMultiplyTo;
BigInteger.prototype.squareTo = bnpSquareTo;
BigInteger.prototype.divRemTo = bnpDivRemTo;
BigInteger.prototype.invDigit = bnpInvDigit;
BigInteger.prototype.isEven = bnpIsEven;
BigInteger.prototype.exp = bnpExp;
BigInteger.prototype.toString = bnToString;
BigInteger.prototype.negate = bnNegate;
BigInteger.prototype.abs = bnAbs;
BigInteger.prototype.compareTo = bnCompareTo;
BigInteger.prototype.bitLength = bnBitLength;
BigInteger.prototype.mod =
bnMod;
BigInteger.prototype.modPowInt = bnModPowInt;
BigInteger.ZERO = nbv(0);
BigInteger.ONE = nbv(1);
function bnpFromRadix(s, b) {
this.fromInt(0);
if (b == null)
b = 10;
var cs = this.chunkSize(b);
var d = Math.pow(b, cs),
mi = false,
j = 0,
w = 0;
for (var i = 0; i < s.length; ++i) {
var x = intAt(s, i);
if (x < 0) {
if (s.charAt(i) == "-" && this.signum() == 0)
mi = true;
continue
}
w = b * w + x;
if (++j >= cs) {
this.dMultiply(d);
this.dAddOffset(w, 0);
j = 0;
w = 0
}
}
if (j > 0) {
this.dMultiply(Math.pow(b, j));
this.dAddOffset(w, 0)
}
if (mi)
BigInteger.ZERO.subTo(this, this)
}
function bnpChunkSize(r) {
return Math.floor(Math.LN2 *
this.DB / Math.log(r))
}
function bnSigNum() {
if (this.s < 0)
return -1;
else if (this.t <= 0 || this.t == 1 && this[0] <= 0)
return 0;
else
return 1
}
function bnpDMultiply(n) {
this[this.t] = this.am(0, n - 1, this, 0, 0, this.t);
++this.t;
this.clamp()
}
function bnpDAddOffset(n, w) {
if (n == 0)
return;
while (this.t <= w)
this[this.t++] = 0;
this[w] += n;
while (this[w] >= this.DV) {
this[w] -= this.DV;
if (++w >= this.t)
this[this.t++] = 0;
++this[w]
}
}
function bnpToRadix(b) {
if (b == null)
b = 10;
if (this.signum() == 0 || b < 2 || b > 36)
return "0";
var cs = this.chunkSize(b);
var a = Math.pow(b,
cs);
var d = nbv(a),
y = nbi(),
z = nbi(),
r = "";
this.divRemTo(d, y, z);
while (y.signum() > 0) {
r = (a + z.intValue()).toString(b).substr(1) + r;
y.divRemTo(d, y, z)
}
return z.intValue().toString(b) + r
}
function bnIntValue() {
if (this.s < 0)
if (this.t == 1)
return this[0] - this.DV;
else {
if (this.t == 0)
return -1
}
else if (this.t == 1)
return this[0];
else if (this.t == 0)
return 0;
return (this[1] & (1 << 32 - this.DB) - 1) << this.DB | this[0]
}
function bnpAddTo(a, r) {
var i = 0,
c = 0,
m = Math.min(a.t, this.t);
while (i < m) {
c += this[i] + a[i];
r[i++] = c & this.DM;
c >>= this.DB
}
if (a.t <
this.t) {
c += a.s;
while (i < this.t) {
c += this[i];
r[i++] = c & this.DM;
c >>= this.DB
}
c += this.s
} else {
c += this.s;
while (i < a.t) {
c += a[i];
r[i++] = c & this.DM;
c >>= this.DB
}
c += a.s
}
r.s = c < 0 ? -1 : 0;
if (c > 0)
r[i++] = c;
else if (c < -1)
r[i++] = this.DV + c;
r.t = i;
r.clamp()
}
BigInteger.prototype.fromRadix = bnpFromRadix;
BigInteger.prototype.chunkSize = bnpChunkSize;
BigInteger.prototype.signum = bnSigNum;
BigInteger.prototype.dMultiply = bnpDMultiply;
BigInteger.prototype.dAddOffset = bnpDAddOffset;
BigInteger.prototype.toRadix = bnpToRadix;
BigInteger.prototype.intValue =
bnIntValue;
BigInteger.prototype.addTo = bnpAddTo;
var Wrapper = {
abs: function(l, h) {
var x = new goog.math.Long(l, h);
var ret;
if (x.isNegative())
ret = x.negate();
else
ret = x;
HEAP32[tempDoublePtr >> 2] = ret.low_;
HEAP32[tempDoublePtr + 4 >> 2] = ret.high_
},
ensureTemps: function() {
if (Wrapper.ensuredTemps)
return;
Wrapper.ensuredTemps = true;
Wrapper.two32 = new BigInteger;
Wrapper.two32.fromString("4294967296", 10);
Wrapper.two64 = new BigInteger;
Wrapper.two64.fromString("18446744073709551616", 10);
Wrapper.temp1 = new BigInteger;
Wrapper.temp2 =
new BigInteger
},
lh2bignum: function(l, h) {
var a = new BigInteger;
a.fromString(h.toString(), 10);
var b = new BigInteger;
a.multiplyTo(Wrapper.two32, b);
var c = new BigInteger;
c.fromString(l.toString(), 10);
var d = new BigInteger;
c.addTo(b, d);
return d
},
stringify: function(l, h, unsigned) {
var ret = (new goog.math.Long(l, h)).toString();
if (unsigned && ret[0] == "-") {
Wrapper.ensureTemps();
var bignum = new BigInteger;
bignum.fromString(ret, 10);
ret = new BigInteger;
Wrapper.two64.addTo(bignum, ret);
ret = ret.toString(10)
}
return ret
},
fromString: function(str,
base, min, max, unsigned) {
Wrapper.ensureTemps();
var bignum = new BigInteger;
bignum.fromString(str, base);
var bigmin = new BigInteger;
bigmin.fromString(min, 10);
var bigmax = new BigInteger;
bigmax.fromString(max, 10);
if (unsigned && bignum.compareTo(BigInteger.ZERO) < 0) {
var temp = new BigInteger;
bignum.addTo(Wrapper.two64, temp);
bignum = temp
}
var error = false;
if (bignum.compareTo(bigmin) < 0) {
bignum = bigmin;
error = true
} else if (bignum.compareTo(bigmax) > 0) {
bignum = bigmax;
error = true
}
var ret = goog.math.Long.fromString(bignum.toString());
HEAP32[tempDoublePtr >> 2] = ret.low_;
HEAP32[tempDoublePtr + 4 >> 2] = ret.high_;
if (error)
throw "range error";
}
};
return Wrapper
}();
if (memoryInitializer)
if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
var data = Module["readBinary"](memoryInitializer);
HEAPU8.set(data, STATIC_BASE)
} else {
addRunDependency("memory initializer");
Browser.asyncLoad(memoryInitializer, function(data) {
HEAPU8.set(data, STATIC_BASE);
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 (!Module["calledRun"] && shouldRunNow)
run();
if (!Module["calledRun"])
dependenciesFulfilled = runCaller
};
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 || [];
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 (!Module["noExitRuntime"])
exit(ret)
} catch (e) {
if (e instanceof ExitStatus)
return;
else if (e == "SimulateInfiniteLoop") {
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;
if (Module["calledRun"])
return;
function doRun() {
if (Module["calledRun"])
return;
Module["calledRun"] = true;
ensureInitRuntime();
preMain();
if (ENVIRONMENT_IS_WEB && preloadStartTime !== null)
Module.printErr("pre-main prep time: " + (Date.now() - preloadStartTime) + " ms");
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;
exitRuntime();
throw new ExitStatus(status);
}
Module["exit"] = Module.exit = exit;
function abort(text) {
if (text) {
Module.print(text);
Module.printErr(text)
}
ABORT = true;
EXITSTATUS = 1;
var extra = "\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.";
throw "abort() at " + stackTrace() + extra;
}
Module["abort"] = Module.abort = abort;
if (Module["preInit"]) {
if (typeof Module["preInit"] == "function")
Module["preInit"] = [Module["preInit"]];
while (Module["preInit"].length > 0)
Module["preInit"].pop()()
}
var shouldRunNow = true;
if (Module["noInitialRun"])
shouldRunNow = false;
run();
var Offsets = {
b2Body: {
type: 0,
islandIndex: 8,
xf: 12,
xf0: 28,
sweep: 44,
linearVelocity: 80,
angularVelocity: 88,
force: 92,
torque: 100,
world: 104,
prev: 108,
next: 112,
fixtureList: 116,
fixtureCount: 120,
jointList: 124,
contactList: 128,
mass: 132,
invMass: 136,
I: 140,
invI: 144,
linearDamping: 148,
angularDamping: 152,
gravityScale: 156,
sleepTime: 160,
userData: 164
},
b2Contact: {
flags: 4,
prev: 8,
next: 12,
nodeA: 16,
nodeB: 32,
fixtureA: 48,
fixtureB: 52,
indexA: 56,
indexB: 60,
manifold: 64,
toiCount: 128,
toi: 132,
friction: 136,
restitution: 140,
tangentSpeed: 144
},
b2Fixture: {
density: 0,
next: 4,
body: 8,
shape: 12,
friction: 16,
restitution: 20,
proxies: 24,
proxyCount: 28,
filter: 32,
isSensor: 38,
userData: 40
},
b2ParticleGroup: {
system: 0,
firstIndex: 4,
lastIndex: 8,
groupFlags: 12,
strength: 16,
prev: 20,
next: 24,
timestamp: 28,
mass: 32,
inertia: 36,
center: 40,
linearVelocity: 48,
angularVelocity: 56,
transform: 60,
userData: 76
},
b2WorldManifold: {
normal: 0,
points: 8,
separations: 24
},
b2World: {
bodyList: 102960
}
};
var FLT_EPSILON = 1.1920929E-7;
function b2Max(a, b) {
return new b2Vec2(Math.max(a.x, b.x), Math.max(a.y, b.y))
}
function b2Min(a, b) {
return new b2Vec2(Math.min(a.x, b.x), Math.min(a.y, b.y))
}
function b2Clamp(a, low, high) {
return b2Max(low, b2Min(a, high))
}
function b2Vec2(x, y) {
if (x === undefined)
x = 0;
if (y === undefined)
y = 0;
this.x = x;
this.y = y
}
b2Vec2.Add = function(out, a, b) {
out.x = a.x + b.x;
out.y = a.y + b.y
};
b2Vec2.CrossScalar = function(output, input, scalar) {
output.x = -scalar * input.y;
output.y = scalar * input.x
};
b2Vec2.Cross = function(a, b) {
return a.x * b.y - a.y * b.x
};
b2Vec2.MulScalar = function(out, input, scalar) {
out.x = input.x * scalar;
out.y = input.y * scalar
};
b2Vec2.Mul = function(out, T, v) {
var Tp = T.p;
var Tqc = T.q.c;
var Tqs = T.q.s;
var x = v.x;
var y = v.y;
out.x = Tqc * x - Tqs * y + Tp.x;
out.y = Tqs * x + Tqc * y + Tp.y
};
b2Vec2.Normalize = function(out, input) {
var length = input.Length();
if (length < FLT_EPSILON) {
out.x = 0;
out.y = 0;
return
}
var invLength = 1 / length;
out.x = input.x * invLength;
out.y = input.y * invLength
};
b2Vec2.Sub = function(out, input, subtract) {
out.x = input.x - subtract.x;
out.y = input.y - subtract.y
};
b2Vec2.prototype.Clone = function() {
return new b2Vec2(this.x, this.y)
};
b2Vec2.prototype.Set = function(x, y) {
this.x = x;
this.y = y
};
b2Vec2.prototype.Length = function() {
var x = this.x;
var y = this.y;
return Math.sqrt(x * x + y * y)
};
b2Vec2.prototype.LengthSquared = function() {
var x = this.x;
var y = this.y;
return x * x + y * y
};
function b2Rot(radians) {
if (radians === undefined)
radians = 0;
this.s = Math.sin(radians);
this.c = Math.cos(radians)
}
b2Rot.prototype.Set = function(radians) {
this.s = Math.sin(radians);
this.c = Math.cos(radians)
};
b2Rot.prototype.SetIdentity = function() {
this.s = 0;
this.c = 1
};
b2Rot.prototype.GetXAxis = function() {
return new b2Vec2(this.c, this.s)
};
function b2Transform(position, rotation) {
if (position === undefined)
position = new b2Vec2;
if (rotation === undefined)
rotation = new b2Rot;
this.p = position;
this.q = rotation
}
b2Transform.prototype.FromFloat64Array = function(arr) {
var p = this.p;
var q = this.q;
p.x = arr[0];
p.y = arr[1];
q.s = arr[2];
q.c = arr[3]
};
b2Transform.prototype.SetIdentity = function() {
this.p.Set(0, 0);
this.q.SetIdentity()
};
function b2AABB() {
this.lowerBound = new b2Vec2;
this.upperBound = new b2Vec2
}
b2AABB.prototype.GetCenter = function() {
var sum = new b2Vec2;
b2Vec2.Add(sum, this.lowerBound, this.upperBound);
b2Vec2.MulScalar(sum, sum, .5)
};
var b2Manifold_GetPointCount = Module.cwrap("b2Manifold_GetPointCount", "number", ["number"]);
function b2Manifold(ptr) {
this.ptr = ptr
}
b2Manifold.prototype.GetPointCount = function() {
return b2Manifold_GetPointCount(this.ptr)
};
var b2WorldManifold_points_offset = Offsets.b2WorldManifold.points;
function b2WorldManifold(ptr) {
this.buffer = new DataView(Module.HEAPU8.buffer, ptr);
this.ptr = ptr
}
b2WorldManifold.prototype.GetPoint = function(i) {
var point = new b2Vec2;
point.x = this.buffer.getFloat32(i * 2 + b2WorldManifold_points_offset, true);
point.y = this.buffer.getFloat32(i * 2 + 4 + b2WorldManifold_points_offset, true);
return point
};
var b2EdgeShape_CreateFixture = Module.cwrap("b2EdgeShape_CreateFixture", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
function b2EdgeShape() {
this.hasVertex0 = false;
this.hasVertex3 = false;
this.vertex0 = new b2Vec2;
this.vertex1 = new b2Vec2;
this.vertex2 = new b2Vec2;
this.vertex3 = new b2Vec2;
this.type = b2Shape_Type_e_edge
}
b2EdgeShape.prototype.Set = function(v1, v2) {
this.vertex1 = v1;
this.vertex2 = v2;
this.hasVertex0 = false;
this.hasVertex3 = false
};
b2EdgeShape.prototype._CreateFixture = function(body, fixtureDef) {
return b2EdgeShape_CreateFixture(body.ptr, fixtureDef.density, fixtureDef.friction, fixtureDef.isSensor, fixtureDef.restitution, fixtureDef.userData, fixtureDef.filter.categoryBits, fixtureDef.filter.groupIndex, fixtureDef.filter.maskBits, this.hasVertex0, this.hasVertex3, this.vertex0.x, this.vertex0.y, this.vertex1.x, this.vertex1.y, this.vertex2.x, this.vertex2.y, this.vertex3.x, this.vertex3.y)
};
var b2PolygonShape_CreateFixture_3 = Module.cwrap("b2PolygonShape_CreateFixture_3", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2PolygonShape_CreateFixture_4 = Module.cwrap("b2PolygonShape_CreateFixture_4", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2PolygonShape_CreateFixture_5 = Module.cwrap("b2PolygonShape_CreateFixture_5", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2PolygonShape_CreateFixture_6 = Module.cwrap("b2PolygonShape_CreateFixture_6", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2PolygonShape_CreateFixture_7 = Module.cwrap("b2PolygonShape_CreateFixture_7", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2PolygonShape_CreateFixture_8 = Module.cwrap("b2PolygonShape_CreateFixture_8", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2PolygonShape_CreateParticleGroup_4 = Module.cwrap("b2PolygonShape_CreateParticleGroup_4", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2PolygonShape_DestroyParticlesInShape_4 = Module.cwrap("b2PolygonShape_DestroyParticlesInShape_4", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
function b2PolygonShape() {
this.position = new b2Vec2;
this.vertices = [];
this.type = b2Shape_Type_e_polygon
}
b2PolygonShape.prototype.SetAsBoxXY = function(hx, hy) {
this.vertices[0] = new b2Vec2(-hx, -hy);
this.vertices[1] = new b2Vec2(hx, -hy);
this.vertices[2] = new b2Vec2(hx, hy);
this.vertices[3] = new b2Vec2(-hx, hy)
};
b2PolygonShape.prototype.SetAsBoxXYCenterAngle = function(hx, hy, center, angle) {
this.vertices[0] = new b2Vec2(-hx, -hy);
this.vertices[1] = new b2Vec2(hx, -hy);
this.vertices[2] = new b2Vec2(hx, hy);
this.vertices[3] = new b2Vec2(-hx, hy);
var xf = new b2Transform;
xf.p = center;
xf.q.Set(angle);
for (var i = 0; i < 4; i++)
b2Vec2.Mul(this.vertices[i], xf, this.vertices[i])
};
b2PolygonShape.prototype._CreateFixture = function(body, fixtureDef) {
var vertices = this.vertices;
switch (vertices.length) {
case 3:
var v0 = vertices[0];
var v1 = vertices[1];
var v2 = vertices[2];
return b2PolygonShape_CreateFixture_3(body.ptr, fixtureDef.density, fixtureDef.friction, fixtureDef.isSensor, fixtureDef.restitution, fixtureDef.userData, fixtureDef.filter.categoryBits, fixtureDef.filter.groupIndex, fixtureDef.filter.maskBits, v0.x, v0.y, v1.x, v1.y, v2.x, v2.y);
break;
case 4:
var v0 = vertices[0];
var v1 = vertices[1];
var v2 =
vertices[2];
var v3 = vertices[3];
return b2PolygonShape_CreateFixture_4(body.ptr, fixtureDef.density, fixtureDef.friction, fixtureDef.isSensor, fixtureDef.restitution, fixtureDef.userData, fixtureDef.filter.categoryBits, fixtureDef.filter.groupIndex, fixtureDef.filter.maskBits, v0.x, v0.y, v1.x, v1.y, v2.x, v2.y, v3.x, v3.y);
break;
case 5:
var v0 = vertices[0];
var v1 = vertices[1];
var v2 = vertices[2];
var v3 = vertices[3];
var v4 = vertices[4];
return b2PolygonShape_CreateFixture_5(body.ptr, fixtureDef.density, fixtureDef.friction,
fixtureDef.isSensor, fixtureDef.restitution, fixtureDef.userData, fixtureDef.filter.categoryBits, fixtureDef.filter.groupIndex, fixtureDef.filter.maskBits, v0.x, v0.y, v1.x, v1.y, v2.x, v2.y, v3.x, v3.y, v4.x, v4.y);
break;
case 6:
var v0 = vertices[0];
var v1 = vertices[1];
var v2 = vertices[2];
var v3 = vertices[3];
var v4 = vertices[4];
var v5 = vertices[5];
return b2PolygonShape_CreateFixture_6(body.ptr, fixtureDef.density, fixtureDef.friction, fixtureDef.isSensor, fixtureDef.restitution, fixtureDef.userData, fixtureDef.filter.categoryBits,
fixtureDef.filter.groupIndex, fixtureDef.filter.maskBits, v0.x, v0.y, v1.x, v1.y, v2.x, v2.y, v3.x, v3.y, v4.x, v4.y, v5.x, v5.y);
break;
case 7:
var v0 = vertices[0];
var v1 = vertices[1];
var v2 = vertices[2];
var v3 = vertices[3];
var v4 = vertices[4];
var v5 = vertices[5];
var v6 = vertices[6];
return b2PolygonShape_CreateFixture_7(body.ptr, fixtureDef.density, fixtureDef.friction, fixtureDef.isSensor, fixtureDef.restitution, fixtureDef.userData, fixtureDef.filter.categoryBits, fixtureDef.filter.groupIndex, fixtureDef.filter.maskBits, v0.x,
v0.y, v1.x, v1.y, v2.x, v2.y, v3.x, v3.y, v4.x, v4.y, v5.x, v5.y, v6.x, v6.y);
break;
case 8:
var v0 = vertices[0];
var v1 = vertices[1];
var v2 = vertices[2];
var v3 = vertices[3];
var v4 = vertices[4];
var v5 = vertices[5];
var v6 = vertices[6];
var v7 = vertices[7];
return b2PolygonShape_CreateFixture_8(body.ptr, fixtureDef.density, fixtureDef.friction, fixtureDef.isSensor, fixtureDef.restitution, fixtureDef.userData, fixtureDef.filter.categoryBits, fixtureDef.filter.groupIndex, fixtureDef.filter.maskBits, v0.x, v0.y, v1.x, v1.y, v2.x, v2.y, v3.x,
v3.y, v4.x, v4.y, v5.x, v5.y, v6.x, v6.y, v6.x, v7.y);
break
}
};
b2PolygonShape.prototype._CreateParticleGroup = function(particleSystem, pgd) {
var v = this.vertices;
switch (v.length) {
case 3:
break;
case 4:
return b2PolygonShape_CreateParticleGroup_4(particleSystem.ptr, pgd.angle, pgd.angularVelocity, pgd.color.r, pgd.color.g, pgd.color.b, pgd.color.a, pgd.flags, pgd.group.ptr, pgd.groupFlags, pgd.lifetime, pgd.linearVelocity.x, pgd.linearVelocity.y, pgd.position.x, pgd.position.y, pgd.positionData, pgd.particleCount, pgd.strength, pgd.stride, pgd.userData, v[0].x, v[0].y, v[1].x, v[1].y, v[2].x,
v[2].y, v[3].x, v[3].y);
break
}
};
b2PolygonShape.prototype._DestroyParticlesInShape = function(ps, xf) {
var v = this.vertices;
switch (v.length) {
case 3:
break;
case 4:
return b2PolygonShape_DestroyParticlesInShape_4(ps.ptr, v[0].x, v[0].y, v[1].x, v[1].y, v[2].x, v[2].y, v[3].x, v[3].y, xf.p.x, xf.p.y, xf.q.s, xf.q.c);
break
}
};
b2PolygonShape.prototype.Validate = function() {
for (var i = 0, max = this.vertices.length; i < max; ++i) {
var i1 = i;
var i2 = i < max - 1 ? i1 + 1 : 0;
var p = this.vertices[i1];
var e = this.vertices[i2];
var eSubP = new b2Vec2;
b2Vec2.Sub(eSubP, e, p);
for (var j = 0; j < max; ++j) {
if (j == i1 || j == i2)
continue;
var v = new b2Vec2;
b2Vec2.Sub(v, this.vertices[j], p);
var c = b2Vec2.Cross(eSubP, v);
if (c < 0)
return false
}
}
return true
};
var b2Shape_Type_e_circle = 0;
var b2Shape_Type_e_edge = 1;
var b2Shape_Type_e_polygon = 2;
var b2Shape_Type_e_chain = 3;
var b2Shape_Type_e_typeCount = 4;
var b2_linearSlop = .005;
var b2_polygonRadius = 2 * b2_linearSlop;
var b2_maxPolygonVertices = 8;
function b2MassData(mass, center, I) {
this.mass = mass;
this.center = center;
this.I = I
}
;
var b2ChainShape_CreateFixture = Module.cwrap("b2ChainShape_CreateFixture", "number", ["number", "number", "number", "number", "number", "number", "number", "number"]);
function b2ChainShape() {
this.radius = b2_polygonRadius;
this.vertices = [];
this.type = b2Shape_Type_e_chain
}
b2ChainShape.prototype.CreateLoop = function() {
this.vertices.push(this.vertices[0])
};
b2ChainShape.prototype._CreateFixture = function(body, fixtureDef) {
var vertices = this.vertices;
var chainLength = vertices.length;
var dataLength = chainLength * 2;
var data = new Float32Array(dataLength);
for (var i = 0, j = 0; i < dataLength; i += 2, j++) {
data[i] = vertices[j].x;
data[i + 1] = vertices[j].y
}
var nDataBytes = data.length * data.BYTES_PER_ELEMENT;
var dataPtr = Module._malloc(nDataBytes);
var dataHeap = new Uint8Array(Module.HEAPU8.buffer, dataPtr, nDataBytes);
dataHeap.set(new Uint8Array(data.buffer));
var fixture = b2ChainShape_CreateFixture(body.ptr,
fixtureDef.density, fixtureDef.friction, fixtureDef.isSensor, fixtureDef.restitution, fixtureDef.userData, fixtureDef.filter.categoryBits, fixtureDef.filter.groupIndex, fixtureDef.filter.maskBits, dataHeap.byteOffset, data.length);
Module._free(dataHeap.byteOffset);
return fixture
};
var b2CircleShape_CreateFixture = Module.cwrap("b2CircleShape_CreateFixture", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2CircleShape_CreateParticleGroup = Module.cwrap("b2CircleShape_CreateParticleGroup", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2CircleShape_DestroyParticlesInShape = Module.cwrap("b2CircleShape_DestroyParticlesInShape", "number", ["number", "number", "number", "number", "number", "number", "number", "number"]);
function b2CircleShape() {
this.position = new b2Vec2;
this.radius = 0;
this.type = b2Shape_Type_e_circle
}
b2CircleShape.prototype._CreateFixture = function(body, fixtureDef) {
return b2CircleShape_CreateFixture(body.ptr, fixtureDef.density, fixtureDef.friction, fixtureDef.isSensor, fixtureDef.restitution, fixtureDef.userData, fixtureDef.filter.categoryBits, fixtureDef.filter.groupIndex, fixtureDef.filter.maskBits, this.position.x, this.position.y, this.radius)
};
b2CircleShape.prototype._CreateParticleGroup = function(particleSystem, pgd) {
return b2CircleShape_CreateParticleGroup(particleSystem.ptr, pgd.angle, pgd.angularVelocity, pgd.color.r, pgd.color.g, pgd.color.b, pgd.color.a, pgd.flags, pgd.group.ptr, pgd.groupFlags, pgd.lifetime, pgd.linearVelocity.x, pgd.linearVelocity.y, pgd.position.x, pgd.position.y, pgd.positionData, pgd.particleCount, pgd.strength, pgd.stride, pgd.userData, this.position.x, this.position.y, this.radius)
};
b2CircleShape.prototype._DestroyParticlesInShape = function(ps, xf) {
return b2CircleShape_DestroyParticlesInShape(ps.ptr, this.position.x, this.position.y, this.radius, xf.p.x, xf.p.y, xf.q.s, xf.q.c)
};
var b2Body_ApplyAngularImpulse = Module.cwrap("b2Body_ApplyAngularImpulse", "null", ["number", "number", "number"]);
var b2Body_ApplyForce = Module.cwrap("b2Body_ApplyForce", "number", ["number", "number", "number", "number", "number", "number"]);
var b2Body_ApplyForceToCenter = Module.cwrap("b2Body_ApplyForceToCenter", "number", ["number", "number", "number", "number"]);
var b2Body_ApplyTorque = Module.cwrap("b2Body_ApplyTorque", "number", ["number", "number", "number"]);
var b2Body_DestroyFixture = Module.cwrap("b2Body_DestroyFixture", "null", ["number", "number"]);
var b2Body_GetAngle = Module.cwrap("b2Body_GetAngle", "number", ["number"]);
var b2Body_GetAngularVelocity = Module.cwrap("b2Body_GetAngularVelocity", "number", ["number"]);
var b2Body_GetInertia = Module.cwrap("b2Body_GetInertia", "number", ["number"]);
var b2Body_GetLinearVelocity = Module.cwrap("b2Body_GetLinearVelocity", "null", ["number", "number"]);
var b2Body_GetLocalPoint = Module.cwrap("b2Body_GetLocalPoint", "null", ["number", "number", "number", "number"]);
var b2Body_GetLocalVector = Module.cwrap("b2Body_GetLocalVector", "null", ["number", "number", "number", "number"]);
var b2Body_GetMass = Module.cwrap("b2Body_GetMass", "number", ["number"]);
var b2Body_GetPosition = Module.cwrap("b2Body_GetPosition", "null", ["number", "number"]);
var b2Body_GetTransform = Module.cwrap("b2Body_GetTransform", "null", ["number", "number"]);
var b2Body_GetType = Module.cwrap("b2Body_GetType", "number", ["number"]);
var b2Body_GetWorldCenter = Module.cwrap("b2Body_GetWorldCenter", "null", ["number", "number"]);
var b2Body_GetWorldPoint = Module.cwrap("b2Body_GetWorldPoint", "null", ["number", "number", "number", "number"]);
var b2Body_GetWorldVector = Module.cwrap("b2Body_GetWorldVector", "null", ["number", "number", "number", "number"]);
var b2Body_SetAngularVelocity = Module.cwrap("b2Body_SetAngularVelocity", "null", ["number", "number"]);
var b2Body_SetAwake = Module.cwrap("b2Body_SetAwake", "number", ["number", "number"]);
var b2Body_SetLinearVelocity = Module.cwrap("b2Body_SetLinearVelocity", "null", ["number", "number", "number"]);
var b2Body_SetMassData = Module.cwrap("b2Body_SetMassData", "null", ["number", "number", "number", "number", "number"]);
var b2Body_SetTransform = Module.cwrap("b2Body_SetTransform", "null", ["number", "number", "number"]);
var b2Body_SetType = Module.cwrap("b2Body_SetType", "null", ["number", "number"]);
var b2Body_xf_offset = Offsets.b2Body.xf;
var b2Body_userData_offset = Offsets.b2Body.userData;
function b2Body(ptr) {
this.buffer = new DataView(Module.HEAPU8.buffer, ptr);
this.ptr = ptr;
this.fixtures = []
}
b2Body.prototype.ApplyAngularImpulse = function(force, wake) {
b2Body_ApplyAngularImpulse(this.ptr, force, wake)
};
b2Body.prototype.ApplyForce = function(force, point, wake) {
b2Body_ApplyForce(this.ptr, force.x, force.y, point.x, point.y, wake)
};
b2Body.prototype.ApplyForceToCenter = function(force, wake) {
b2Body_ApplyForceToCenter(this.ptr, force.x, force.y, wake)
};
b2Body.prototype.ApplyTorque = function(force, wake) {
b2Body_ApplyTorque(this.ptr, force, wake)
};
b2Body.prototype.CreateFixtureFromDef = function(fixtureDef) {
var fixture = new b2Fixture;
fixture.FromFixtureDef(fixtureDef);
fixture._SetPtr(fixtureDef.shape._CreateFixture(this, fixtureDef));
fixture.body = this;
b2World._Push(fixture, this.fixtures);
world.fixturesLookup[fixture.ptr] = fixture;
return fixture
};
b2Body.prototype.CreateFixtureFromShape = function(shape, density) {
var fixtureDef = new b2FixtureDef;
fixtureDef.shape = shape;
fixtureDef.density = density;
return this.CreateFixtureFromDef(fixtureDef)
};
b2Body.prototype.DestroyFixture = function(fixture) {
b2Body_DestroyFixture(this.ptr, fixture.ptr);
b2World._RemoveItem(fixture, this.fixtures)
};
b2Body.prototype.GetAngle = function() {
return b2Body_GetAngle(this.ptr)
};
b2Body.prototype.GetAngularVelocity = function() {
return b2Body_GetAngularVelocity(this.ptr)
};
b2Body.prototype.GetInertia = function() {
return b2Body_GetInertia(this.ptr)
};
b2Body.prototype.GetMass = function() {
return b2Body_GetMass(this.ptr)
};
b2Body.prototype.GetLinearVelocity = function() {
b2Body_GetLinearVelocity(this.ptr, _vec2Buf.byteOffset);
var result = new Float32Array(_vec2Buf.buffer, _vec2Buf.byteOffset, _vec2Buf.length);
return new b2Vec2(result[0], result[1])
};
b2Body.prototype.GetLocalPoint = function(vec) {
b2Body_GetLocalPoint(this.ptr, vec.x, vec.y, _vec2Buf.byteOffset);
var result = new Float32Array(_vec2Buf.buffer, _vec2Buf.byteOffset, _vec2Buf.length);
return new b2Vec2(result[0], result[1])
};
b2Body.prototype.GetLocalVector = function(vec) {
b2Body_GetLocalVector(this.ptr, vec.x, vec.y, _vec2Buf.byteOffset);
var result = new Float32Array(_vec2Buf.buffer, _vec2Buf.byteOffset, _vec2Buf.length);
return new b2Vec2(result[0], result[1])
};
b2Body.prototype.GetPosition = function() {
b2Body_GetPosition(this.ptr, _vec2Buf.byteOffset);
var result = new Float32Array(_vec2Buf.buffer, _vec2Buf.byteOffset, _vec2Buf.length);
return new b2Vec2(result[0], result[1])
};
b2Body.prototype.GetTransform = function() {
var transform = new b2Transform;
transform.p.x = this.buffer.getFloat32(b2Body_xf_offset, true);
transform.p.y = this.buffer.getFloat32(b2Body_xf_offset + 4, true);
transform.q.s = this.buffer.getFloat32(b2Body_xf_offset + 8, true);
transform.q.c = this.buffer.getFloat32(b2Body_xf_offset + 12, true);
return transform
};
b2Body.prototype.GetType = function() {
return b2Body_GetType(this.ptr)
};
b2Body.prototype.GetUserData = function() {
return this.buffer.getUint32(b2Body_userData_offset, true)
};
b2Body.prototype.GetWorldCenter = function() {
b2Body_GetWorldCenter(this.ptr, _vec2Buf.byteOffset);
var result = new Float32Array(_vec2Buf.buffer, _vec2Buf.byteOffset, _vec2Buf.length);
return new b2Vec2(result[0], result[1])
};
b2Body.prototype.GetWorldPoint = function(vec) {
b2Body_GetWorldPoint(this.ptr, vec.x, vec.y, _vec2Buf.byteOffset);
var result = new Float32Array(_vec2Buf.buffer, _vec2Buf.byteOffset, _vec2Buf.length);
return new b2Vec2(result[0], result[1])
};
b2Body.prototype.GetWorldVector = function(vec) {
b2Body_GetWorldVector(this.ptr, vec.x, vec.y, _vec2Buf.byteOffset);
var result = new Float32Array(_vec2Buf.buffer, _vec2Buf.byteOffset, _vec2Buf.length);
return new b2Vec2(result[0], result[1])
};
b2Body.prototype.SetAngularVelocity = function(angle) {
b2Body_SetAngularVelocity(this.ptr, angle)
};
b2Body.prototype.SetAwake = function(flag) {
b2Body_SetAwake(this.ptr, flag)
};
b2Body.prototype.SetLinearVelocity = function(v) {
b2Body_SetLinearVelocity(this.ptr, v.x, v.y)
};
b2Body.prototype.SetMassData = function(massData) {
b2Body_SetMassData(this.ptr, massData.mass, massData.center.x, massData.center.y, massData.I)
};
b2Body.prototype.SetTransform = function(v, angle) {
b2Body_SetTransform(this.ptr, v.x, v.y, angle)
};
b2Body.prototype.SetType = function(type) {
b2Body_SetType(this.ptr, type)
};
var b2_staticBody = 0;
var b2_kinematicBody = 1;
var b2_dynamicBody = 2;
function b2BodyDef() {
this.active = true;
this.allowSleep = true;
this.angle = 0;
this.angularVelocity = 0;
this.angularDamping = 0;
this.awake = true;
this.bullet = false;
this.fixedRotation = false;
this.gravityScale = 1;
this.linearDamping = 0;
this.linearVelocity = new b2Vec2;
this.position = new b2Vec2;
this.type = b2_staticBody;
this.userData = null
}
;
b2World.BeginContactBody = function(contactPtr) {
if (world.listener.BeginContactBody === undefined)
return;
var contact = new b2Contact(contactPtr);
world.listener.BeginContactBody(contact)
};
b2World.EndContactBody = function(contactPtr) {
if (world.listener.EndContactBody === undefined)
return;
var contact = new b2Contact(contactPtr);
world.listener.EndContactBody(contact)
};
b2World.PreSolve = function(contactPtr, oldManifoldPtr) {
if (world.listener.PreSolve === undefined)
return;
world.listener.PreSolve(new b2Contact(contactPtr), new b2Manifold(oldManifoldPtr))
};
b2World.PostSolve = function(contactPtr, impulsePtr) {
if (world.listener.PostSolve === undefined)
return;
world.listener.PostSolve(new b2Contact(contactPtr), new b2ContactImpulse(impulsePtr))
};
b2World.QueryAABB = function(fixturePtr) {
return world.queryAABBCallback.ReportFixture(world.fixturesLookup[fixturePtr])
};
b2World.RayCast = function(fixturePtr, pointX, pointY, normalX, normalY, fraction) {
return world.rayCastCallback.ReportFixture(world.fixturesLookup[fixturePtr], new b2Vec2(pointX, pointY), new b2Vec2(normalX, normalY), fraction)
};
var b2World_Create = Module.cwrap("b2World_Create", "number", ["number", "number"]);
var b2World_CreateBody = Module.cwrap("b2World_CreateBody", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2World_CreateParticleSystem = Module.cwrap("b2World_CreateParticleSystem", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2World_DestroyBody = Module.cwrap("b2World_DestroyBody", "null", ["number", "number"]);
var b2World_DestroyJoint = Module.cwrap("b2World_DestroyJoint", "null", ["number", "number"]);
var b2World_DestroyParticleSystem = Module.cwrap("b2World_DestroyParticleSystem", "null", ["number", "number"]);
var b2World_QueryAABB = Module.cwrap("b2World_QueryAABB", "null", ["number", "number", "number", "number", "number"]);
var b2World_RayCast = Module.cwrap("b2World_RayCast", "null", ["number", "number", "number", "number", "number"]);
var b2World_SetContactListener = Module.cwrap("b2World_SetContactListener", "null", ["number"]);
var b2World_SetGravity = Module.cwrap("b2World_SetGravity", "null", ["number", "number", "number"]);
var b2World_Step = Module.cwrap("b2World_Step", "null", ["number", "number", "number"]);
var _transBuf = null;
var _vec2Buf = null;
function b2World(gravity) {
this.bodies = [];
this.bodiesLookup = {};
this.fixturesLookup = {};
this.joints = [];
this.listener = null;
this.particleSystems = [];
this.ptr = b2World_Create(gravity.x, gravity.y);
this.queryAABBCallback = null;
this.rayCastCallback = null;
this.buffer = new DataView(Module.HEAPU8.buffer, this.ptr);
var nDataBytes = 4 * Float32Array.BYTES_PER_ELEMENT;
var dataPtr = Module._malloc(nDataBytes);
_transBuf = new Uint8Array(Module.HEAPU8.buffer, dataPtr, nDataBytes);
nDataBytes = 2 * Float32Array.BYTES_PER_ELEMENT;
dataPtr =
Module._malloc(nDataBytes);
_vec2Buf = new Uint8Array(Module.HEAPU8.buffer, dataPtr, nDataBytes)
}
b2World._Push = function(item, list) {
item.lindex = list.length;
list.push(item)
};
b2World._RemoveItem = function(item, list) {
var length = list.length;
var lindex = item.lindex;
if (length > 1) {
list[lindex] = list[length - 1];
list[lindex].lindex = lindex
}
list.pop()
};
b2World.prototype.CreateBody = function(bodyDef) {
var body = new b2Body(b2World_CreateBody(this.ptr, bodyDef.active, bodyDef.allowSleep, bodyDef.angle, bodyDef.angularVelocity, bodyDef.angularDamping, bodyDef.awake, bodyDef.bullet, bodyDef.fixedRotation, bodyDef.gravityScale, bodyDef.linearDamping, bodyDef.linearVelocity.x, bodyDef.linearVelocity.y, bodyDef.position.x, bodyDef.position.y, bodyDef.type, bodyDef.userData));
b2World._Push(body, this.bodies);
this.bodiesLookup[body.ptr] = body;
return body
};
b2World.prototype.CreateJoint = function(jointDef) {
var joint = jointDef.Create(this);
b2World._Push(joint, this.joints);
return joint
};
b2World.prototype.CreateParticleSystem = function(psd) {
var ps = new b2ParticleSystem(b2World_CreateParticleSystem(this.ptr, psd.colorMixingStrength, psd.dampingStrength, psd.destroyByAge, psd.ejectionStrength, psd.elasticStrength, psd.lifetimeGranularity, psd.powderStrength, psd.pressureStrength, psd.radius, psd.repulsiveStrength, psd.springStrength, psd.staticPressureIterations, psd.staticPressureRelaxation, psd.staticPressureStrength, psd.surfaceTensionNormalStrength, psd.surfaceTensionPressureStrength, psd.viscousStrength));
b2World._Push(ps, this.particleSystems);
ps.dampingStrength = psd.dampingStrength;
ps.radius = psd.radius;
return ps
};
b2World.prototype.DestroyBody = function(body) {
b2World_DestroyBody(this.ptr, body.ptr);
b2World._RemoveItem(body, this.bodies)
};
b2World.prototype.DestroyJoint = function(joint) {
b2World_DestroyJoint(this.ptr, joint.ptr);
b2World._RemoveItem(joint, this.joints)
};
b2World.prototype.DestroyParticleSystem = function(particleSystem) {
b2World_DestroyParticleSystem(this.ptr, particleSystem.ptr);
b2World._RemoveItem(particleSystem, this.particleSystems)
};
b2World.prototype.QueryAABB = function(callback, aabb) {
this.queryAABBCallback = callback;
b2World_QueryAABB(this.ptr, aabb.lowerBound.x, aabb.lowerBound.y, aabb.upperBound.x, aabb.upperBound.y)
};
b2World.prototype.RayCast = function(callback, point1, point2) {
this.rayCastCallback = callback;
b2World_RayCast(this.ptr, point1.x, point1.y, point2.x, point2.y)
};
b2World.prototype.SetContactListener = function(listener) {
this.listener = listener;
b2World_SetContactListener(this.ptr)
};
b2World.prototype.SetGravity = function(gravity) {
b2World_SetGravity(this.ptr, gravity.x, gravity.y)
};
b2World.prototype.Step = function(steps, vIterations, pIterations) {
b2World_Step(this.ptr, steps, vIterations, pIterations)
};
var b2WheelJoint_SetMotorSpeed = Module.cwrap("b2WheelJoint_SetMotorSpeed", "null", ["number", "number"]);
var b2WheelJoint_SetSpringFrequencyHz = Module.cwrap("b2WheelJoint_SetSpringFrequencyHz", "null", ["number", "number"]);
function b2WheelJoint(def) {
this.next = null;
this.ptr = null
}
b2WheelJoint.prototype.SetMotorSpeed = function(speed) {
b2WheelJoint_SetMotorSpeed(this.ptr, speed)
};
b2WheelJoint.prototype.SetSpringFrequencyHz = function(hz) {
b2WheelJoint_SetSpringFrequencyHz(this.ptr, hz)
};
var b2WheelJointDef_Create = Module.cwrap("b2WheelJointDef_Create", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2WheelJointDef_InitializeAndCreate = Module.cwrap("b2WheelJointDef_InitializeAndCreate", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
function b2WheelJointDef() {
this.bodyA = null;
this.bodyB = null;
this.collideConnected = false;
this.dampingRatio = .7;
this.enableMotor = false;
this.frequencyHz = 2;
this.localAnchorA = new b2Vec2;
this.localAnchorB = new b2Vec2;
this.localAxisA = new b2Vec2(1, 0);
this.maxMotorTorque = 0;
this.motorSpeed = 0
}
b2WheelJointDef.prototype.Create = function(world) {
var wheelJoint = new b2WheelJoint(this);
wheelJoint.ptr = b2WheelJointDef_Create(world.ptr, this.bodyA.ptr, this.bodyB.ptr, this.collideConnected, this.dampingRatio, this.enableMotor, this.frequencyHz, this.localAnchorA.x, this.localAnchorA.y, this.localAnchorB.x, this.localAnchorB.y, this.localAxisA.x, this.localAxisA.y, this.maxMotorTorque, this.motorSpeed);
return wheelJoint
};
b2WheelJointDef.prototype.InitializeAndCreate = function(bodyA, bodyB, anchor, axis) {
this.bodyA = bodyA;
this.bodyB = bodyB;
var wheelJoint = new b2WheelJoint(this);
wheelJoint.ptr = b2WheelJointDef_InitializeAndCreate(world.ptr, this.bodyA.ptr, this.bodyB.ptr, anchor.x, anchor.y, axis.x, axis.y, this.collideConnected, this.dampingRatio, this.enableMotor, this.frequencyHz, this.maxMotorTorque, this.motorSpeed);
b2World._Push(wheelJoint, world.joints);
return wheelJoint
};
var b2WeldJointDef_Create = Module.cwrap("b2WeldJointDef_Create", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2WeldJointDef_InitializeAndCreate = Module.cwrap("b2WeldJointDef_InitializeAndCreate", "number", ["number", "number", "number", "number", "number", "number", "number", "number"]);
function b2WeldJointDef() {
this.bodyA = null;
this.bodyB = null;
this.collideConnected = false;
this.dampingRatio = 0;
this.frequencyHz = 0;
this.localAnchorA = new b2Vec2;
this.localAnchorB = new b2Vec2;
this.referenceAngle = 0
}
b2WeldJointDef.prototype.Create = function(world) {
var weldJoint = new b2WeldJoint(this);
weldJoint.ptr = b2WeldJointDef_Create(world.ptr, this.bodyA.ptr, this.bodyB.ptr, this.collideConnected, this.dampingRatio, this.frequencyHz, this.localAnchorA.x, this.localAnchorA.y, this.localAnchorB.x, this.localAnchorB.y, this.referenceAngle);
return weldJoint
};
b2WeldJointDef.prototype.InitializeAndCreate = function(bodyA, bodyB, anchor) {
this.bodyA = bodyA;
this.bodyB = bodyB;
var weldJoint = new b2WeldJoint(this);
weldJoint.ptr = b2WeldJointDef_InitializeAndCreate(world.ptr, this.bodyA.ptr, this.bodyB.ptr, anchor.x, anchor.y, this.collideConnected, this.dampingRatio, this.frequencyHz);
b2World._Push(weldJoint, world.joints);
return weldJoint
};
function b2WeldJoint(def) {
this.bodyA = def.bodyA;
this.bodyB = def.bodyB;
this.next = null;
this.ptr = null
}
;
var b2GearJoint_GetRatio = Module.cwrap("b2GearJoint_GetRatio", "number", ["number"]);
function b2GearJoint(def) {
this.ptr = null;
this.next = null
}
b2GearJoint.prototype.GetRatio = function() {
return b2GearJoint_GetRatio(this.ptr)
};
var b2GearJointDef_Create = Module.cwrap("b2GearJointDef_Create", "number", ["number", "number", "number", "number", "number", "number", "number"]);
function b2GearJointDef() {
this.bodyA = null;
this.bodyB = null;
this.collideConnected = false;
this.joint1 = null;
this.joint2 = null;
this.ratio = 0
}
b2GearJointDef.prototype.Create = function(world) {
var gearJoint = new b2GearJoint(this);
gearJoint.ptr = b2GearJointDef_Create(world.ptr, this.bodyA.ptr, this.bodyB.ptr, this.collideConnected, this.joint1.ptr, this.joint2.ptr, this.ratio);
return gearJoint
};
var e_unknownJoint = 0;
var e_revoluteJoint = 1;
var e_prismaticJoint = 2;
var e_distanceJoint = 3;
var e_pulleyJoint = 4;
var e_mouseJoint = 5;
var e_gearJoint = 6;
var e_wheelJoint = 7;
var e_weldJoint = 8;
var e_frictionJoint = 9;
var e_ropeJoint = 10;
var e_motorJoint = 11;
var b2Joint_GetBodyA = Module.cwrap("b2Joint_GetBodyA", "number", ["number"]);
var b2Joint_GetBodyB = Module.cwrap("b2Joint_GetBodyB", "number", ["number"]);
function b2Joint() {}
b2Joint.prototype.GetBodyA = function() {
return world.bodiesLookup[b2Joint_GetBodyA(this.ptr)]
};
b2Joint.prototype.GetBodyB = function() {
return world.bodiesLookup[b2Joint_GetBodyB(this.ptr)]
};
var b2FrictionJointDef_Create = Module.cwrap("b2FrictionJointDef_Create", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2FrictionJointDef_InitializeAndCreate = Module.cwrap("b2FrictionJointDef_InitializeAndCreate", "number", ["number", "number", "number", "number", "number", "number", "number", "number"]);
function b2FrictionJointDef() {
this.bodyA = null;
this.bodyB = null;
this.collideConnected = false;
this.localAnchorA = new b2Vec2;
this.localAnchorB = new b2Vec2;
this.maxForce = 0;
this.maxTorque = 0;
this.userData = null
}
b2FrictionJointDef.prototype.Create = function(world) {
var frictionJoint = new b2FrictionJoint(this);
frictionJoint.ptr = b2FrictionJointDef_Create(world.ptr, this.bodyA.ptr, this.bodyB.ptr, this.collideConnected, this.localAnchorA.x, this.localAnchorA.y, this.localAnchorB.x, this.localAnchorB.y, this.maxForce, this.maxTorque);
return frictionJoint
};
b2FrictionJointDef.prototype.InitializeAndCreate = function(bodyA, bodyB, anchor) {
this.bodyA = bodyA;
this.bodyB = bodyB;
var frictionJoint = new b2FrictionJoint(this);
frictionJoint.ptr = b2FrictionJointDef_InitializeAndCreate(world.ptr, this.bodyA.ptr, this.bodyB.ptr, anchor.x, anchor.y, this.collideConnected, this.maxForce, this.maxTorque);
b2World._Push(frictionJoint, world.joints);
return frictionJoint
};
function b2FrictionJoint(def) {
this.bodyA = def.bodyA;
this.bodyB = def.bodyB;
this.ptr = null;
this.next = null
}
;
var b2RevoluteJoint_EnableLimit = Module.cwrap("b2RevoluteJoint_EnableLimit", "number", ["number", "number"]);
var b2RevoluteJoint_EnableMotor = Module.cwrap("b2RevoluteJoint_EnableMotor", "number", ["number", "number"]);
var b2RevoluteJoint_GetJointAngle = Module.cwrap("b2RevoluteJoint_GetJointAngle", "number", ["number"]);
var b2RevoluteJoint_IsLimitEnabled = Module.cwrap("b2RevoluteJoint_IsLimitEnabled", "number", ["number"]);
var b2RevoluteJoint_IsMotorEnabled = Module.cwrap("b2RevoluteJoint_IsMotorEnabled", "number", ["number"]);
var b2RevoluteJoint_SetMotorSpeed = Module.cwrap("b2RevoluteJoint_SetMotorSpeed", "number", ["number", "number"]);
function b2RevoluteJoint(revoluteJointDef) {
this.collideConnected = revoluteJointDef.collideConnected;
this.enableLimit = revoluteJointDef.enableLimit;
this.enableMotor = revoluteJointDef.enableMotor;
this.lowerAngle = revoluteJointDef.lowerAngle;
this.maxMotorTorque = revoluteJointDef.maxMotorTorque;
this.motorSpeed = revoluteJointDef.motorSpeed;
this.next = null;
this.ptr = null;
this.upperAngle = revoluteJointDef.upperAngle;
this.userData = revoluteJointDef.userData
}
b2RevoluteJoint.prototype = new b2Joint;
b2RevoluteJoint.prototype.EnableLimit = function(flag) {
b2RevoluteJoint_EnableLimit(this.ptr, flag)
};
b2RevoluteJoint.prototype.EnableMotor = function(flag) {
b2RevoluteJoint_EnableMotor(this.ptr, flag)
};
b2RevoluteJoint.prototype.GetJointAngle = function(flag) {
return b2RevoluteJoint_GetJointAngle(this.ptr)
};
b2RevoluteJoint.prototype.IsLimitEnabled = function() {
return b2RevoluteJoint_IsLimitEnabled(this.ptr)
};
b2RevoluteJoint.prototype.IsMotorEnabled = function() {
return b2RevoluteJoint_IsMotorEnabled(this.ptr)
};
b2RevoluteJoint.prototype.SetMotorSpeed = function(speed) {
b2RevoluteJoint_SetMotorSpeed(this.ptr, speed);
this.motorSpeed = speed
};
var b2RevoluteJointDef_Create = Module.cwrap("b2RevoluteJointDef_Create", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2RevoluteJointDef_InitializeAndCreate = Module.cwrap("b2RevoluteJointDef_InitializeAndCreate", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
function b2RevoluteJointDef() {
this.collideConnected = false;
this.enableLimit = false;
this.enableMotor = false;
this.localAnchorA = new b2Vec2;
this.localAnchorB = new b2Vec2;
this.lowerAngle = 0;
this.maxMotorTorque = 0;
this.motorSpeed = 0;
this.referenceAngle = 0;
this.upperAngle = 0;
this.userData = null
}
b2RevoluteJointDef.prototype.Create = function(world) {
var revoluteJoint = new b2RevoluteJoint(this);
revoluteJoint.ptr = b2RevoluteJointDef_Create(world.ptr, this.bodyA.ptr, this.bodyB.ptr, this.collideConnected, this.enableLimit, this.enableMotor, this.lowerAngle, this.localAnchorA.x, this.localAnchorA.y, this.localAnchorB.x, this.localAnchorB.y, this.maxMotorTorque, this.motorSpeed, this.referenceAngle, this.upperAngle);
return revoluteJoint
};
b2RevoluteJointDef.prototype.InitializeAndCreate = function(bodyA, bodyB, anchor) {
this.bodyA = bodyA;
this.bodyB = bodyB;
var revoluteJoint = new b2RevoluteJoint(this);
revoluteJoint.ptr = b2RevoluteJointDef_InitializeAndCreate(world.ptr, bodyA.ptr, bodyB.ptr, anchor.x, anchor.y, this.collideConnected, this.enableLimit, this.enableMotor, this.lowerAngle, this.maxMotorTorque, this.motorSpeed, this.upperAngle);
b2World._Push(revoluteJoint, world.joints);
return revoluteJoint
};
var b2MotorJoint_SetAngularOffset = Module.cwrap("b2MotorJoint_SetAngularOffset", "null", ["number", "number"]);
var b2MotorJoint_SetLinearOffset = Module.cwrap("b2MotorJoint_SetLinearOffset", "null", ["number", "number", "number"]);
function b2MotorJoint(def) {
this.bodyA = def.bodyA;
this.bodyB = def.bodyB;
this.ptr = null;
this.next = null
}
b2MotorJoint.prototype.SetAngularOffset = function(angle) {
b2MotorJoint_SetAngularOffset(this.ptr, angle)
};
b2MotorJoint.prototype.SetLinearOffset = function(v) {
b2MotorJoint_SetLinearOffset(this.ptr, v.x, v.y)
};
var b2MotorJointDef_Create = Module.cwrap("b2MotorJointDef_Create", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2MotorJointDef_InitializeAndCreate = Module.cwrap("b2MotorJointDef_InitializeAndCreate", "number", ["number", "number", "number", "number", "number", "number", "number", "number"]);
function b2MotorJointDef() {
this.bodyA = null;
this.bodyB = null;
this.collideConnected = false;
this.angularOffset = 0;
this.correctionFactor = .3;
this.linearOffset = new b2Vec2;
this.maxForce = 0;
this.maxTorque = 0
}
b2MotorJointDef.prototype.Create = function(world) {
var motorJoint = new b2MotorJoint(this);
motorJoint.ptr = b2MotorJointDef_Create(world.ptr, this.bodyA.ptr, this.bodyB.ptr, this.collideConnected, this.angularOffset, this.correctionFactor, this.linearOffset.x, this.linearOffset.y, this.maxForce, this.maxTorque);
return motorJoint
};
b2MotorJointDef.prototype.InitializeAndCreate = function(bodyA, bodyB) {
this.bodyA = bodyA;
this.bodyB = bodyB;
var motorJoint = new b2MotorJoint(this);
motorJoint.ptr = b2MotorJointDef_InitializeAndCreate(world.ptr, this.bodyA.ptr, this.bodyB.ptr, this.collideConnected, this.correctionFactor, this.maxForce, this.maxTorque);
b2World._Push(motorJoint, world.joints);
return motorJoint
};
function b2PulleyJoint(def) {
this.ptr = null;
this.next = null
}
var b2PulleyJointDef_Create = Module.cwrap("b2PulleyJointDef_Create", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2PulleyJointDef_InitializeAndCreate = Module.cwrap("b2PulleyJointDef_InitializeAndCreate", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
function b2PulleyJointDef() {
this.bodyA = null;
this.bodyB = null;
this.collideConnected = true;
this.groundAnchorA = new b2Vec2;
this.groundAnchorB = new b2Vec2;
this.localAnchorA = new b2Vec2;
this.localAnchorB = new b2Vec2;
this.lengthA = 0;
this.lengthB = 0;
this.ratio = 1
}
b2PulleyJointDef.prototype.Create = function(world) {
var pulleyJoint = new b2PulleyJoint(this);
pulleyJoint.ptr = b2PulleyJointDef_Create(world.ptr, this.bodyA.ptr, this.bodyB.ptr, this.collideConnected, this.groundAnchorA.x, this.groundAnchorA.y, this.groundAnchorB.x, this.groundAnchorB.y, this.lengthA, this.lengthB, this.localAnchorA.x, this.localAnchorA.y, this.localAnchorB.x, this.localAnchorB.y, this.ratio);
return pulleyJoint
};
b2PulleyJointDef.prototype.InitializeAndCreate = function(bodyA, bodyB, groundAnchorA, groundAnchorB, anchorA, anchorB, ratio) {
this.bodyA = bodyA;
this.bodyB = bodyB;
var pulleyJoint = new b2PulleyJoint(this);
pulleyJoint.ptr = b2PulleyJointDef_InitializeAndCreate(world.ptr, this.bodyA.ptr, this.bodyB.ptr, anchorA.x, anchorA.y, anchorB.x, anchorB.y, groundAnchorA.x, groundAnchorA.y, groundAnchorB.x, groundAnchorB.y, ratio, this.collideConnected);
b2World._Push(pulleyJoint, world.joints);
return pulleyJoint
};
function b2DistanceJoint(def) {
this.bodyA = def.bodyA;
this.bodyB = def.bodyB;
this.ptr = null;
this.next = null
}
var b2DistanceJointDef_Create = Module.cwrap("b2DistanceJointDef_Create", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2DistanceJointDef_InitializeAndCreate = Module.cwrap("b2DistanceJointDef_InitializeAndCreate", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
function b2DistanceJointDef() {
this.bodyA = null;
this.bodyB = null;
this.collideConnected = false;
this.dampingRatio = 0;
this.length = 1;
this.localAnchorA = new b2Vec2;
this.localAnchorB = new b2Vec2;
this.frequencyHz = 0
}
b2DistanceJointDef.prototype.Create = function(world) {
var distanceJoint = new b2DistanceJoint(this);
distanceJoint.ptr = b2DistanceJointDef_Create(world.ptr, this.bodyA.ptr, this.bodyB.ptr, this.collideConnected, this.dampingRatio, this.frequencyHz, this.length, this.localAnchorA.x, this.localAnchorA.y, this.localAnchorB.x, this.localAnchorB.y);
return distanceJoint
};
b2DistanceJointDef.prototype.InitializeAndCreate = function(bodyA, bodyB, anchorA, anchorB) {
this.bodyA = bodyA;
this.bodyB = bodyB;
var distanceJoint = new b2DistanceJoint(this);
distanceJoint.ptr = b2DistanceJointDef_InitializeAndCreate(world.ptr, this.bodyA.ptr, this.bodyB.ptr, anchorA.x, anchorA.y, anchorB.x, anchorB.y, this.collideConnected, this.dampingRatio, this.frequencyHz);
b2World._Push(distanceJoint, world.joints);
return distanceJoint
};
var b2PrismaticJoint_EnableLimit = Module.cwrap("b2PrismaticJoint_EnableLimit", "number", ["number", "number"]);
var b2PrismaticJoint_EnableMotor = Module.cwrap("b2PrismaticJoint_EnableMotor", "number", ["number", "number"]);
var b2PrismaticJoint_GetJointTranslation = Module.cwrap("b2PrismaticJoint_GetJointTranslation", "number", ["number"]);
var b2PrismaticJoint_GetMotorSpeed = Module.cwrap("b2PrismaticJoint_GetMotorSpeed", "number", ["number"]);
var b2PrismaticJoint_GetMotorForce = Module.cwrap("b2PrismaticJoint_GetMotorForce", "number", ["number", "number"]);
var b2PrismaticJoint_IsLimitEnabled = Module.cwrap("b2PrismaticJoint_IsLimitEnabled", "number", ["number"]);
var b2PrismaticJoint_IsMotorEnabled = Module.cwrap("b2PrismaticJoint_IsMotorEnabled", "number", ["number"]);
var b2PrismaticJoint_SetMotorSpeed = Module.cwrap("b2PrismaticJoint_SetMotorSpeed", "number", ["number", "number"]);
function b2PrismaticJoint(def) {
this.ptr = null;
this.next = null
}
b2PrismaticJoint.prototype = new b2Joint;
b2PrismaticJoint.prototype.EnableLimit = function(flag) {
return b2PrismaticJoint_EnableLimit(this.ptr, flag)
};
b2PrismaticJoint.prototype.EnableMotor = function(flag) {
return b2PrismaticJoint_EnableMotor(this.ptr, flag)
};
b2PrismaticJoint.prototype.GetJointTranslation = function() {
return b2PrismaticJoint_GetJointTranslation(this.ptr)
};
b2PrismaticJoint.prototype.GetMotorSpeed = function() {
return b2PrismaticJoint_GetMotorSpeed(this.ptr)
};
b2PrismaticJoint.prototype.GetMotorForce = function(hz) {
return b2PrismaticJoint_GetMotorForce(this.ptr, hz)
};
b2PrismaticJoint.prototype.IsLimitEnabled = function() {
return b2PrismaticJoint_IsLimitEnabled(this.ptr)
};
b2PrismaticJoint.prototype.IsMotorEnabled = function() {
return b2PrismaticJoint_IsMotorEnabled(this.ptr)
};
b2PrismaticJoint.prototype.GetMotorEnabled = function() {
return b2PrismaticJoint_IsMotorEnabled(this.ptr)
};
b2PrismaticJoint.prototype.SetMotorSpeed = function(speed) {
return b2PrismaticJoint_SetMotorSpeed(this.ptr, speed)
};
var b2PrismaticJointDef_Create = Module.cwrap("b2PrismaticJointDef_Create", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2PrismaticJointDef_InitializeAndCreate = Module.cwrap("b2PrismaticJointDef_InitializeAndCreate", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
function b2PrismaticJointDef() {
this.bodyA = null;
this.bodyB = null;
this.collideConnected = false;
this.enableLimit = false;
this.enableMotor = false;
this.localAnchorA = new b2Vec2;
this.localAnchorB = new b2Vec2;
this.localAxisA = new b2Vec2(1, 0);
this.lowerTranslation = 0;
this.maxMotorForce = 0;
this.motorSpeed = 0;
this.referenceAngle = 0;
this.upperTranslation = 0
}
b2PrismaticJointDef.prototype.Create = function(world) {
var prismaticJoint = new b2PrismaticJoint(this);
prismaticJoint.ptr = b2PrismaticJointDef_Create(world.ptr, this.bodyA.ptr, this.bodyB.ptr, this.collideConnected, this.enableLimit, this.enableMotor, this.localAnchorA.x, this.localAnchorA.y, this.localAnchorB.x, this.localAnchorB.y, this.localAxisA.x, this.localAxisA.y, this.lowerTranslation, this.maxMotorForce, this.motorSpeed, this.referenceAngle, this.upperTranslation);
return prismaticJoint
};
b2PrismaticJointDef.prototype.InitializeAndCreate = function(bodyA, bodyB, anchor, axis) {
this.bodyA = bodyA;
this.bodyB = bodyB;
var prismaticJoint = new b2PrismaticJoint(this);
prismaticJoint.ptr = b2PrismaticJointDef_InitializeAndCreate(world.ptr, this.bodyA.ptr, this.bodyB.ptr, anchor.x, anchor.y, axis.x, axis.y, this.collideConnected, this.enableLimit, this.enableMotor, this.lowerTranslation, this.maxMotorForce, this.motorSpeed, this.upperTranslation);
b2World._Push(prismaticJoint, world.joints);
return prismaticJoint
};
function b2RopeJoint(def) {
this.next = null;
this.ptr = null
}
var b2RopeJointDef_Create = Module.cwrap("b2RopeJointDef_Create", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number"]);
function b2RopeJointDef() {
this.bodyA = null;
this.bodyB = null;
this.collideConnected = false;
this.localAnchorA = new b2Vec2;
this.localAnchorB = new b2Vec2;
this.maxLength = 0
}
b2RopeJointDef.prototype.Create = function(world) {
var ropeJoint = new b2RopeJoint(this);
ropeJoint.ptr = b2RopeJointDef_Create(world.ptr, this.bodyA.ptr, this.bodyB.ptr, this.collideConnected, this.localAnchorA.x, this.localAnchorA.y, this.localAnchorB.x, this.localAnchorB.y, this.maxLength);
return ropeJoint
};
var b2MouseJoint_SetTarget = Module.cwrap("b2MouseJoint_SetTarget", "null", ["number", "number", "number"]);
function b2MouseJoint(def) {
this.ptr = null;
this.next = null
}
b2MouseJoint.prototype.SetTarget = function(p) {
b2MouseJoint_SetTarget(this.ptr, p.x, p.y)
};
var b2MouseJointDef_Create = Module.cwrap("b2MouseJointDef_Create", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number"]);
function b2MouseJointDef() {
this.bodyA = null;
this.bodyB = null;
this.collideConnected = false;
this.dampingRatio = .7;
this.frequencyHz = 5;
this.maxForce = 0;
this.target = new b2Vec2
}
b2MouseJointDef.prototype.Create = function(world) {
var mouseJoint = new b2MouseJoint(this);
mouseJoint.ptr = b2MouseJointDef_Create(world.ptr, this.bodyA.ptr, this.bodyB.ptr, this.collideConnected, this.dampingRatio, this.frequencyHz, this.maxForce, this.target.x, this.target.y);
return mouseJoint
};
var b2Contact_fixtureA_offset = Offsets.b2Contact.fixtureA;
var b2Contact_fixtureB_offset = Offsets.b2Contact.fixtureB;
var b2Contact_tangentSpeed_offset = Offsets.b2Contact.tangentSpeed;
var b2Contact_GetManifold = Module.cwrap("b2Contact_GetManifold", "number", ["number"]);
var b2Contact_GetWorldManifold = Module.cwrap("b2Contact_GetWorldManifold", "number", ["number"]);
function b2Contact(ptr) {
this.buffer = new DataView(Module.HEAPU8.buffer, ptr);
this.ptr = ptr
}
b2Contact.prototype.GetFixtureA = function() {
var fixAPtr = this.buffer.getUint32(b2Contact_fixtureA_offset, true);
return world.fixturesLookup[fixAPtr]
};
b2Contact.prototype.GetFixtureB = function() {
var fixBPtr = this.buffer.getUint32(b2Contact_fixtureB_offset, true);
return world.fixturesLookup[fixBPtr]
};
b2Contact.prototype.GetManifold = function() {
return new b2Manifold(b2Contact_GetManifold(this.ptr))
};
b2Contact.prototype.GetWorldManifold = function() {
return new b2WorldManifold(b2Contact_GetWorldManifold(this.ptr))
};
b2Contact.prototype.SetTangentSpeed = function(speed) {
this.buffer.setFloat32(b2Contact_tangentSpeed_offset, speed, true)
};
function b2Filter() {
this.categoryBits = 1;
this.groupIndex = 0;
this.maskBits = 65535
}
var b2Fixture_isSensor_offset = Offsets.b2Fixture.isSensor;
var b2Fixture_userData_offset = Offsets.b2Fixture.userData;
function b2Fixture() {
this.body = null;
this.buffer = null;
this.ptr = null;
this.shape = null
}
var b2Fixture_TestPoint = Module.cwrap("b2Fixture_TestPoint", "number", ["number", "number", "number"]);
b2Fixture.prototype._SetPtr = function(ptr) {
this.ptr = ptr;
this.buffer = new DataView(Module.HEAPU8.buffer, ptr)
};
b2Fixture.prototype.FromFixtureDef = function(fixtureDef) {
this.density = fixtureDef.density;
this.friction = fixtureDef.friction;
this.isSensor = fixtureDef.isSensor;
this.restitution = fixtureDef.restitution;
this.shape = fixtureDef.shape;
this.userData = fixtureDef.userData;
this.vertices = []
};
b2Fixture.prototype.GetUserData = function() {
return this.buffer.getUint32(b2Fixture_userData_offset, true)
};
b2Fixture.prototype.SetSensor = function(flag) {
this.buffer.setUint32(b2Fixture_isSensor_offset, flag, true)
};
b2Fixture.prototype.TestPoint = function(p) {
return b2Fixture_TestPoint(this.ptr, p.x, p.y)
};
function b2FixtureDef() {
this.density = 0;
this.friction = .2;
this.isSensor = false;
this.restitution = 0;
this.shape = null;
this.userData = null;
this.filter = new b2Filter
}
;
function b2ContactImpulse(ptr) {
this.ptr = ptr;
this.buffer = new DataView(Module.HEAPU8.buffer, ptr)
}
b2ContactImpulse.prototype.GetNormalImpulse = function(i) {
return this.buffer.getFloat32(i * 4, true)
};
b2ContactImpulse.prototype.GetTangentImpulse = function(i) {
return this.buffer.getFloat32(i * 4 + 8, true)
};
b2ContactImpulse.prototype.GetCount = function(i) {
console.log(this.buffer.getInt32(16, true))
};
function b2ParticleSystemDef() {
this.colorMixingStrength = .5;
this.dampingStrength = 1;
this.destroyByAge = true;
this.ejectionStrength = .5;
this.elasticStrength = .25;
this.lifetimeGranularity = 1 / 60;
this.powderStrength = .5;
this.pressureStrength = .05;
this.radius = 1;
this.repulsiveStrength = 1;
this.springStrength = .25;
this.staticPressureIterations = 8;
this.staticPressureRelaxation = .2;
this.staticPressureStrength = .2;
this.surfaceTensionNormalStrength = .2;
this.surfaceTensionPressureStrength = .2;
this.viscousStrength = .25
}
var b2ParticleSystem_CreateParticle = Module.cwrap("b2ParticleSystem_CreateParticle", "number", ["number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number", "number"]);
var b2ParticleSystem_GetColorBuffer = Module.cwrap("b2ParticleSystem_GetColorBuffer", "number", ["number"]);
var b2ParticleSystem_GetParticleCount = Module.cwrap("b2ParticleSystem_GetParticleCount", "number", ["number"]);
var b2ParticleSystem_GetPositionBuffer = Module.cwrap("b2ParticleSystem_GetPositionBuffer", "number", ["number"]);
var b2ParticleSystem_GetVelocityBuffer = Module.cwrap("b2ParticleSystem_GetVelocityBuffer", "number", ["number"]);
var b2ParticleSystem_SetDamping = Module.cwrap("b2ParticleSystem_SetDamping", "null", ["number", "number"]);
var b2ParticleSystem_SetDensity = Module.cwrap("b2ParticleSystem_SetDensity", "null", ["number", "number"]);
var b2ParticleSystem_SetRadius = Module.cwrap("b2ParticleSystem_SetRadius", "null", ["number", "number"]);
function b2ParticleSystem(ptr) {
this.dampingStrength = 1;
this.density = 1;
this.ptr = ptr;
this.particleGroups = [];
this.radius = 1
}
b2ParticleSystem.prototype.CreateParticle = function(pd) {
return b2ParticleSystem_CreateParticle(this.ptr, pd.color.r, pd.color.g, pd.color.b, pd.color.a, pd.flags, pd.group, pd.lifetime, pd.position.x, pd.position.y, pd.userData, pd.velocity.x, pd.velocity.y)
};
b2ParticleSystem.prototype.CreateParticleGroup = function(pgd) {
var particleGroup = new b2ParticleGroup(pgd.shape._CreateParticleGroup(this, pgd));
this.particleGroups.push(particleGroup);
return particleGroup
};
b2ParticleSystem.prototype.DestroyParticlesInShape = function(shape, xf) {
return shape._DestroyParticlesInShape(this, xf)
};
b2ParticleSystem.prototype.GetColorBuffer = function() {
var count = b2ParticleSystem_GetParticleCount(this.ptr) * 4;
var offset = b2ParticleSystem_GetColorBuffer(this.ptr);
return new Uint8Array(Module.HEAPU8.buffer, offset, count)
};
b2ParticleSystem.prototype.GetParticleCount = function() {
return b2ParticleSystem_GetParticleCount(this.ptr) * 2
};
b2ParticleSystem.prototype.GetPositionBuffer = function() {
var count = b2ParticleSystem_GetParticleCount(this.ptr) * 2;
var offset = b2ParticleSystem_GetPositionBuffer(this.ptr);
return new Float32Array(Module.HEAPU8.buffer, offset, count)
};
b2ParticleSystem.prototype.GetVelocityBuffer = function() {
var count = b2ParticleSystem_GetParticleCount(this.ptr) * 2;
var offset = b2ParticleSystem_GetVelocityBuffer(this.ptr);
return new Float32Array(Module.HEAPU8.buffer, offset, count)
};
b2ParticleSystem.prototype.SetDamping = function(damping) {
this.dampingStrength = damping;
b2ParticleSystem_SetDamping(this.ptr, damping)
};
b2ParticleSystem.prototype.SetDensity = function(density) {
this.density = density;
b2ParticleSystem_SetDensity(this.ptr, density)
};
b2ParticleSystem.prototype.SetRadius = function(radius) {
this.radius = radius;
b2ParticleSystem_SetRadius(this.ptr, radius)
};
var b2_solidParticleGroup = 1 << 0;
var b2_rigidParticleGroup = 1 << 1;
var b2_particleGroupCanBeEmpty = 1 << 2;
var b2_particleGroupWillBeDestroyed = 1 << 3;
var b2_particleGroupNeedsUpdateDepth = 1 << 4;
var b2_particleGroupInternalMask = b2_particleGroupWillBeDestroyed | b2_particleGroupNeedsUpdateDepth;
var b2ParticleGroup_ApplyForce = Module.cwrap("b2ParticleGroup_ApplyForce", "null", ["number", "number", "number"]);
var b2ParticleGroup_ApplyLinearImpulse = Module.cwrap("b2ParticleGroup_ApplyLinearImpulse", "null", ["number", "number", "number"]);
var b2ParticleGroup_DestroyParticles = Module.cwrap("b2ParticleGroup_DestroyParticles", "null", ["number", "number"]);
var b2ParticleGroup_GetBufferIndex = Module.cwrap("b2ParticleGroup_GetBufferIndex", "number", ["number"]);
var b2ParticleGroup_GetParticleCount = Module.cwrap("b2ParticleGroup_GetParticleCount", "number", ["number"]);
var b2ParticleGroup_groupFlags_offset = Offsets.b2ParticleGroup.groupFlags;
function b2ParticleGroup(ptr) {
this.buffer = new DataView(Module.HEAPU8.buffer, ptr);
this.ptr = ptr
}
b2ParticleGroup.prototype.ApplyForce = function(force) {
b2ParticleGroup_ApplyForce(this.ptr, force.x, force.y)
};
b2ParticleGroup.prototype.ApplyLinearImpulse = function(impulse) {
b2ParticleGroup_ApplyLinearImpulse(this.ptr, impulse.x, impulse.y)
};
b2ParticleGroup.prototype.DestroyParticles = function(flag) {
b2ParticleGroup_DestroyParticles(this.ptr, flag)
};
b2ParticleGroup.prototype.GetBufferIndex = function() {
return b2ParticleGroup_GetBufferIndex(this.ptr)
};
b2ParticleGroup.prototype.GetGroupFlags = function() {
return this.buffer.getUint32(b2ParticleGroup_groupFlags_offset, true)
};
b2ParticleGroup.prototype.GetParticleCount = function() {
return b2ParticleGroup_GetParticleCount(this.ptr)
};
b2ParticleGroup.prototype.SetGroupFlags = function(flags) {
this.buffer.setUint32(b2ParticleGroup_groupFlags_offset, flags, true)
};
function b2ParticleGroupDef() {
this.angle = 0;
this.angularVelocity = 0;
this.color = new b2ParticleColor(0, 0, 0, 0);
this.flags = 0;
this.group = new b2ParticleGroup(null);
this.groupFlags = 0;
this.lifetime = 0;
this.linearVelocity = new b2Vec2;
this.position = new b2Vec2;
this.positionData = null;
this.particleCount = 0;
this.shape = null;
this.strength = 1;
this.stride = 0;
this.userData = null
}
;
var b2_waterParticle = 0;
var b2_zombieParticle = 1 << 1;
var b2_wallParticle = 1 << 2;
var b2_springParticle = 1 << 3;
var b2_elasticParticle = 1 << 4;
var b2_viscousParticle = 1 << 5;
var b2_powderParticle = 1 << 6;
var b2_tensileParticle = 1 << 7;
var b2_colorMixingParticle = 1 << 8;
var b2_destructionListenerParticle = 1 << 9;
var b2_barrierParticle = 1 << 10;
var b2_staticPressureParticle = 1 << 11;
var b2_reactiveParticle = 1 << 12;
var b2_repulsiveParticle = 1 << 13;
var b2_fixtureContactListenerParticle = 1 << 14;
var b2_particleContactListenerParticle = 1 << 15;
var b2_fixtureContactFilterParticle = 1 << 16;
var b2_particleContactFilterParticle = 1 << 17;
function b2ParticleColor(r, g, b, a) {
if (r === undefined)
r = 0;
if (g === undefined)
g = 0;
if (b === undefined)
b = 0;
if (a === undefined)
a = 0;
this.r = r;
this.g = g;
this.b = b;
this.a = a
}
b2ParticleColor.prototype.Set = function(r, g, b, a) {
this.r = r;
this.g = g;
this.b = b;
this.a = a
};
function b2ParticleDef() {
this.color = new b2Vec2;
this.flags = 0;
this.group = 0;
this.lifetime = 0;
this.position = new b2Vec2;
this.userData = 0;
this.velocity = new b2Vec2
}
;