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 >