From b47943dd2d55615087baa366efc4bd7714b40bb2 Mon Sep 17 00:00:00 2001 From: Ling Zhan Date: Thu, 17 Aug 2023 14:18:11 +0800 Subject: [PATCH] add box2d-wasm (#397) --- emscripten/box2d/b2.d.ts | 575 + emscripten/box2d/box2d.d.ts | 13 + emscripten/box2d/box2d.debug.asm.js | 71407 +++++++++++++++++++++ emscripten/box2d/box2d.debug.wasm.js | 4297 ++ emscripten/box2d/box2d.debug.wasm.wasm | Bin 0 -> 4124286 bytes emscripten/box2d/box2d.release.asm.js | 33 + emscripten/box2d/box2d.release.wasm.js | 21 + emscripten/box2d/box2d.release.wasm.wasm | Bin 0 -> 183227 bytes 8 files changed, 76346 insertions(+) create mode 100644 emscripten/box2d/b2.d.ts create mode 100644 emscripten/box2d/box2d.d.ts create mode 100644 emscripten/box2d/box2d.debug.asm.js create mode 100644 emscripten/box2d/box2d.debug.wasm.js create mode 100644 emscripten/box2d/box2d.debug.wasm.wasm create mode 100644 emscripten/box2d/box2d.release.asm.js create mode 100644 emscripten/box2d/box2d.release.wasm.js create mode 100644 emscripten/box2d/box2d.release.wasm.wasm diff --git a/emscripten/box2d/b2.d.ts b/emscripten/box2d/b2.d.ts new file mode 100644 index 000000000..62b628c6c --- /dev/null +++ b/emscripten/box2d/b2.d.ts @@ -0,0 +1,575 @@ +declare namespace B2 { + const maxPolygonVertices: number; + + interface Vec2 { + x: number, y: number + } + + interface Vec2Vector { + push_back(v: Vec2): void; + get(i: number): Vec2; + size(): number; + } + + interface Int32Vector { + push_back(v: number): void; + get(i: number): number; + size(): number; + } + + interface Transform { + p: Vec2, q: Vec2 + } + + interface Color { + r: number, g: number, b: number, a: number + } + + interface MassData { + mass: number; + center: Vec2; + I: number; + } + + class AABB { + constructor(); + lowerBound: Vec2; + upperBound: Vec2; + IsValid(): boolean; + GetCenter(): Vec2; + GetExtents(): Vec2; + GetPerimeter(): number; + Combine(aabb: AABB): void; + CombineTwo(aabb1: AABB, aabb2: AABB): void; + Contains(aabb: AABB): boolean; + RayCast(output: RayCastOutput, input: RayCastInput): boolean; + TestOverlap(other: AABB): boolean; + } + + class RayCastCallback { + constructor(); + ReportFixture(fixture: Fixture, point: Vec2, normal: Vec2, fraction: number): number; + } + + class QueryCallback { + constructor(); + ReportFixture(fixture: Fixture): boolean; + } + + interface RayCastInput { + p1: Vec2; + p2: Vec2; + maxFraction: number; + } + + interface RayCastOutput { + normal: Vec2; + fraction: number; + } + + interface Filter { + categoryBits: number; + maskBits: number; + groupIndex: number; + } + + class ContactListener { + constructor(); + BeginContact(contact: number): void; + EndContact(contact: number): void; + PreSolve(contact: number, oldManifold: number): void; + PostSolve(contact: number, impulse: number): void; + registerContactFixture(fixture: number): void; + unregisterContactFixture(fixture: number): void; + isIndexOf(fixture: number): void; + } + + class Draw { + constructor(); + SetFlags(flags: number): void; + GetFlags(): number; + AppendFlags(flags: number): void; + ClearFlags(flags: number): void; + DrawPolygon(vertices: Vec2[], vertexCount: number, color: Color): void; + DrawSolidPolygon(vertices: Vec2[], vertexCount: number, color: Color): void; + DrawCircle(center: Vec2, radius: number, color: Color): void; + DrawSolidCircle(center: Vec2, radius: number, axis: Vec2, color: Color): void; + } + + class World { + constructor(gravity: Vec2); + SetContactListener(listener: ContactListener): void; + SetDebugDraw(debugDraw: Draw): void; + CreateBody(def: BodyDef): Body; + DestroyBody(body: Body): void; + CreateJoint(def: JointDef): Joint; + DestroyJoint(joint: Joint): void; + Step(timeStep: number, velocityIterations: number, positionIterations: number): void; + DebugDraw(): void; + QueryAABB(callback: QueryCallback, aabb: AABB): void; + RayCast(callback: RayCastCallback, point1: Vec2, point2: Vec2): void; + SetAllowSleeping(flag: boolean): void; + GetAllowSleeping(): boolean; + SetGravity(gravity: Vec2): void; + GetGravity(): Vec2; + Dump(): void; + } + + class Shape { + m_type: number; + m_radius: number; + GetType(): number; + GetChildCount(): number; + TestPoint(xf: Transform, p: Vec2): boolean; + RayCast(output: RayCastOutput, input: RayCastInput, transform: Transform, childIndex: number): boolean; + ComputeAABB(aabb: AABB, xf: Transform, childIndex: number): void; + ComputeMass(massData: MassData, density: number): void; + SetRadius(radius: number): void; + GetRadius(): number; + } + + class CircleShape extends Shape { + constructor(); + m_p: Vec2; + Clone(): CircleShape; + GetChildCount(): number; + TestPoint(transform: Transform, p: Vec2): boolean; + RayCast(output: RayCastOutput, input: RayCastInput, transform: Transform, childIndex: number): boolean; + ComputeAABB(aabb: AABB, transform: Transform, childIndex: number): void; + ComputeMass(massData: MassData, density: number): void; + } + + class EdgeShape extends Shape { + constructor(); + Set(v1: Vec2, v2: Vec2): void; + Clone(): EdgeShape; + GetChildCount(): number; + TestPoint(transform: Transform, p: Vec2): boolean; + RayCast(output: RayCastOutput, input: RayCastInput, transform: Transform, childIndex: number): boolean; + ComputeAABB(aabb: AABB, transform: Transform, childIndex: number): void; + ComputeMass(massData: MassData, density: number): void; + } + + class PolygonShape extends Shape { + constructor(); + Clone(): PolygonShape; + Set(vertices: any, count: number): void; + SetAsBox(hx: number, hy: number): void; + SetAsBoxWithCenterAndAngle(hx: number, hy: number, center: Vec2, angle: number): void; + GetChildCount(): number; + TestPoint(transform: Transform, p: Vec2): boolean; + RayCast(output: RayCastOutput, input: RayCastInput, transform: Transform, childIndex: number): boolean; + ComputeAABB(aabb: AABB, transform: Transform, childIndex: number): void; + ComputeMass(massData: MassData, density: number): void; + Validate(): boolean; + } + + class FixtureDef { + shape: Shape; + userData: any; + friction: number; + restitution: number; + density: number; + isSensor: boolean; + filter: Filter; + SetShape(shape: Shape): void; + GetShape(): Shape; + } + + class Fixture { + GetType(): number; + GetShape(): Shape; + SetSensor(sensor: boolean): void; + IsSensor(): boolean; + SetFilterData(filter: Filter): void; + GetFilterData(): Filter; + Refilter(): void; + GetBody(): Body; + TestPoint(p: Vec2): boolean; + RayCast(output: RayCastOutput, input: RayCastInput, childIndex: number): boolean; + GetMassData(massData: MassData): void; + SetDensity(density: number): void; + GetDensity(): number; + GetFriction(): number; + SetFriction(friction: number): void; + GetRestitution(): number; + SetRestitution(restitution: number): void; + GetAABB(childIndex: number): AABB; + Dump(bodyIndex: number): void; + } + + enum BodyType{ + b2_staticBody = 0, + b2_kinematicBody, + b2_dynamicBody, + cc_animatedBody, + } + + class BodyDef { + constructor(); + type: BodyType; + position: Vec2; + angle: number; + linearVelocity: Vec2; + angularVelocity: number; + linearDamping: number; + angularDamping: number; + allowSleep: boolean; + awake: boolean; + fixedRotation: boolean; + bullet: boolean; + gravityScale: number; + } + + class Body { + CreateFixture (fixtureDef: FixtureDef): Fixture; + CreateFixtureWithShape (shape: Shape, density: number): Fixture; + DestroyFixture(fixture: Fixture): void; + SetTransform(position: Vec2, angle: number): void; + GetTransform(): Transform; + GetPosition(): Vec2; + SetPosition(pos: Vec2): void; + GetAngle(): number; + SetAngle(angle: number): void; + GetWorldCenter(): Vec2; + GetLocalCenter(): Vec2; + SetLinearVelocity(v: Vec2): void; + GetLinearVelocity(): Vec2; + SetAngularVelocity(omega: number): void; + GetAngularVelocity(): number; + ApplyForce(force: Vec2, point: Vec2, wake: boolean): void; + ApplyForceToCenter(force: Vec2, wake: boolean): void; + ApplyTorque(torque: number, wake: boolean): void; + ApplyLinearImpulse(impulse: Vec2, point: Vec2, wake: boolean): void; + ApplyLinearImpulseToCenter(impulse: Vec2, wake: boolean): void; + ApplyAngularImpulse(impulse: number, wake: boolean): void; + GetMass(): number; + GetInertia(): number; + GetMassData(data: MassData): void; + SetMassData(data: MassData): void; + ResetMassData(): void; + GetWorldPoint(localPoint: Vec2): Vec2; + GetWorldVector(localVector: Vec2): Vec2; + GetLocalPoint(worldPoint: Vec2): Vec2; + GetLocalVector(worldVector: Vec2): Vec2; + GetLinearVelocityFromWorldPoint(worldPoint: Vec2): Vec2; + GetLinearVelocityFromLocalPoint(localPoint: Vec2): Vec2; + GetLinearDamping(): number; + SetLinearDamping(linearDamping: number): void; + GetAngularDamping(): number; + SetAngularDamping(angularDamping: number): void; + GetGravityScale(): number; + SetGravityScale(scale: number): void; + SetType(type: BodyType): void; + GetType(): BodyType; + SetBullet(flag: boolean): void; + IsBullet(): boolean; + SetSleepingAllowed(flag: boolean): void; + IsSleepingAllowed(): boolean; + SetAwake(flag: boolean): void; + IsAwake(): boolean; + SetEnabled(flag: boolean): void; + IsEnabled(): boolean; + SetFixedRotation(flag: boolean): void; + IsFixedRotation(): boolean; + GetWorld(): World; + Dump(): void; + } + + enum JointType { + e_unknownJoint, + e_revoluteJoint, + e_prismaticJoint, + e_distanceJoint, + e_pulleyJoint, + e_mouseJoint, + e_gearJoint, + e_wheelJoint, + e_weldJoint, + e_frictionJoint, + e_ropeJoint, + e_motorJoint + } + + class JointDef { + constructor(type: JointType); + type: JointType; + collideConnected: boolean; + SetBodyA(bodyA: Body): void; + SetBodyB(bodyB: Body): void; + GetBodyA(): Body; + GetBodyB(): Body; + SetCollideConnected(flag: boolean): void; + } + + class Joint { + GetType(): JointType; + GetBodyA(): Body; + GetBodyB(): Body; + GetAnchorA(): Vec2; + GetAnchorB(): Vec2; + GetReactionForce(inv_dt: number): Vec2; + GetReactionTorque(inv_dt: number): number; + IsActive(): boolean; + GetCollideConnected(): boolean; + Dump(): void; + } + + class DistanceJointDef extends JointDef { + constructor(); + localAnchorA: Vec2; + localAnchorB: Vec2; + length: number; + stiffness: number; + damping: number; + } + + class DistanceJoint extends Joint { + GetLocalAnchorA(): Vec2; + GetLocalAnchorB(): Vec2; + SetLength(length: number): void; + GetLength(): number; + SetStiffness(stiffness: number): void; + GetStiffness(): number; + SetDamping(damping: number): void; + GetDamping(): number; + Dump(): void; + } + + class MotorJointDef extends JointDef { + constructor(); + linearOffset: Vec2; + angularOffset: number; + maxForce: number; + maxTorque: number; + correctionFactor: number; + } + + class MotorJoint extends Joint { + SetLinearOffset(linearOffset: Vec2): void; + GetLinearOffset(): Vec2; + SetAngularOffset(angularOffset: number): void; + GetAngularOffset(): number; + SetMaxForce(force: number): void; + GetMaxForce(): number; + SetMaxTorque(torque: number): void; + GetMaxTorque(): number; + SetCorrectionFactor(factor: number): void; + GetCorrectionFactor(): number; + Dump(): void; + } + + class MouseJointDef extends JointDef { + constructor(); + target: Vec2; + maxForce: number; + frequencyHz: number; + dampingRatio: number; + } + + class MouseJoint extends Joint { + SetTarget(target: Vec2): void; + GetTarget(): Vec2; + SetMaxForce(force: number): void; + GetMaxForce(): number; + SetFrequency(hz: number): void; + GetFrequency(): number; + SetDampingRatio(ratio: number): void; + GetDampingRatio(): number; + Dump(): void; + } + + class PrismaticJointDef extends JointDef { + constructor(); + localAnchorA: Vec2; + localAnchorB: Vec2; + localAxisA: Vec2; + referenceAngle: number; + enableLimit: boolean; + lowerTranslation: number; + upperTranslation: number; + enableMotor: boolean; + maxMotorForce: number; + motorSpeed: number; + } + + class PrismaticJoint extends Joint { + GetLocalAnchorA(): Vec2; + GetLocalAnchorB(): Vec2; + GetLocalAxisA(): Vec2; + GetReferenceAngle(): number; + GetJointTranslation(): number; + GetJointSpeed(): number; + IsLimitEnabled(): boolean; + EnableLimit(flag: boolean): void; + GetLowerLimit(): number; + GetUpperLimit(): number; + SetLimits(lower: number, upper: number): void; + IsMotorEnabled(): boolean; + EnableMotor(flag: boolean): void; + SetMotorSpeed(speed: number): void; + GetMotorSpeed(): number; + SetMaxMotorForce(force: number): void; + GetMaxMotorForce(): number; + GetMotorForce(inv_dt: number): number; + Dump(): void; + } + + class RevoluteJointDef extends JointDef { + constructor(); + localAnchorA: Vec2; + localAnchorB: Vec2; + referenceAngle: number; + enableLimit: boolean; + lowerAngle: number; + upperAngle: number; + enableMotor: boolean; + motorSpeed: number; + maxMotorTorque: number; + } + + class RevoluteJoint extends Joint { + GetLocalAnchorA(): Vec2; + GetLocalAnchorB(): Vec2; + GetReferenceAngle(): number; + GetJointAngle(): number; + GetJointSpeed(): number; + IsLimitEnabled(): boolean; + EnableLimit(flag: boolean): void; + GetLowerLimit(): number; + GetUpperLimit(): number; + SetLimits(lower: number, upper: number): void; + IsMotorEnabled(): boolean; + EnableMotor(flag: boolean): void; + SetMotorSpeed(speed: number): void; + GetMotorSpeed(): number; + SetMaxMotorTorque(torque: number): void; + GetMaxMotorTorque(): number; + GetMotorTorque(inv_dt: number): number; + Dump(): void; + } + + class RopeJointDef extends JointDef { + constructor(); + localAnchorA: Vec2; + localAnchorB: Vec2; + maxLength: number; + } + + class RopeJoint extends Joint { + GetLocalAnchorA(): Vec2; + GetLocalAnchorB(): Vec2; + GetReactionForce(inv_dt: number): Vec2; + GetReactionTorque(inv_dt: number): number; + SetMaxLength(length: number): void; + GetMaxLength(): number; + GetLength(): number; + Dump(): void; + } + + class WeldJointDef extends JointDef { + constructor(); + localAnchorA: Vec2; + localAnchorB: Vec2; + referenceAngle: number; + stiffness: number; + damping: number; + } + + class WeldJoint extends Joint { + GetLocalAnchorA(): Vec2; + GetLocalAnchorB(): Vec2; + GetReferenceAngle(): number; + SetStiffness(stiffness: number): void; + GetStiffness(): number; + SetDamping(damping: number): void; + GetDamping(): number; + Dump(): void; + } + + class WheelJointDef extends JointDef { + constructor(); + localAnchorA: Vec2; + localAnchorB: Vec2; + localAxisA: Vec2; + enableLimit: boolean; + lowerTranslation: number; + upperTranslation: number; + enableMotor: boolean; + maxMotorTorque: number; + motorSpeed: number; + stiffness: number; + damping: number; + } + + class WheelJoint extends Joint { + GetLocalAnchorA(): Vec2; + GetLocalAnchorB(): Vec2; + GetLocalAxisA(): Vec2; + GetJointTranslation(): number; + IsMotorEnabled(): boolean; + EnableMotor(flag: boolean): void; + SetMotorSpeed(speed: number): void; + GetMotorSpeed(): number; + SetMaxMotorTorque(torque: number): void; + GetMaxMotorTorque(): number; + GetMotorTorque(inv_dt: number): number; + SetStiffness(stiffness: number): void; + GetStiffness(): number; + SetDamping(damping: number): void; + GetDamping(): number; + Dump(): void; + } + + // + // functions + // + function ConvexPartition(verticesIn: Vec2Vector, trianglesIn: Int32Vector, verticesOut: Vec2Vector, trianglesOut: Int32Vector): void; + function GetFloat32(memory: number, offset: number): number; + function SetLinearFrequencyAndDampingRatio(body: Joint, frequencyHertz: number, dampingRatio: number): void; + + //Contact + function ContactSetEnabled(contactPtr: number, flag: boolean): void; + function ContactIsTouching(contactPtr: number): boolean; + function ContactSetTangentSpeed(contactPtr: number, speed: number): void; + function ContactGetTangentSpeed(contactPtr: number): number; + function ContactSetFriction(contactPtr: number, friction: number): void; + function ContactGetFriction(contactPtr: number): number; + function ContactResetFriction(contactPtr: number): void; + function ContactSetRestitution(contactPtr: number, restitution: number): void; + function ContactGetRestitution(contactPtr: number): number; + function ContactResetRestitution(contactPtr: number): void; + function ContactGetFixtureA(contactPtr: number): number; + function ContactGetFixtureB(contactPtr: number): number; + function ContactGetWorldManifold(contactPtr: number, worldManifoldPtr: number): number; + function ContactGetManifold(contactPtr: number): number; + + //Manifold + function ManifoldGetType(manifoldPtr: number): number; + function ManifoldGetPointCount(manifoldPtr: number): number; + function ManifoldGetManifoldPointPtr(manifoldPtr: number, index: number): number; + function ManifoldGetLocalPointValueX(manifoldPtr: number): number; + function ManifoldGetLocalPointValueY(manifoldPtr: number): number; + function ManifoldGetLocalNormalValueX(manifoldPtr: number): number; + function ManifoldGetLocalNormalValueY(manifoldPtr: number): number; + + //ManifoldPoint + function ManifoldPointGetLocalPointX(manifoldPointPtr: number): number; + function ManifoldPointGetLocalPointY(manifoldPointPtr: number): number; + function ManifoldPointGetNormalImpulse(manifoldPointPtr: number): number; + function ManifoldPointGetTangentImpulse(manifoldPointPtr: number): number; + + //WorldManifold + function WorldManifoldNew(): number; + function WorldManifoldGetPointValueX(worldManifoldPtr: number, index: number): number; + function WorldManifoldGetPointValueY(worldManifoldPtr: number, index: number): number; + function WorldManifoldGetSeparationValue(worldManifoldPtr: number, index: number): number; + function WorldManifoldGetNormalValueX(worldManifoldPtr: number): number; + function WorldManifoldGetNormalValueY(worldManifoldPtr: number): number; + function WorldManifoldDelete(worldManifoldPtr: number): void; + + //ContactImpulse + function ContactImpulseGetNormalImpulse(contactImpulsePtr: number, index: number): number; + function ContactImpulseGetTangentImpulse(contactImpulsePtr: number, index: number): number; + function ContactImpulseGetCount(contactImpulsePtr: number): number; +} diff --git a/emscripten/box2d/box2d.d.ts b/emscripten/box2d/box2d.d.ts new file mode 100644 index 000000000..c765878ac --- /dev/null +++ b/emscripten/box2d/box2d.d.ts @@ -0,0 +1,13 @@ +// eslint-disable-next-line @typescript-eslint/triple-slash-reference +/// + +declare module 'external:emscripten/box2d/box2d.release.asm.js' { + export default BOX2D; +} + +declare module 'external:emscripten/box2d/box2d.release.wasm.js' { + export default BOX2D; +} + +// tslint:disable +declare function BOX2D (moduleOptions?: any): Promise; diff --git a/emscripten/box2d/box2d.debug.asm.js b/emscripten/box2d/box2d.debug.asm.js new file mode 100644 index 000000000..2e160c8ab --- /dev/null +++ b/emscripten/box2d/box2d.debug.asm.js @@ -0,0 +1,71407 @@ + +var BOX2D = (() => { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + + return ( +function(BOX2D = {}) { + +// include: shell.js +// The Module object: Our interface to the outside world. We import +// and export values on it. There are various ways Module can be used: +// 1. Not defined. We create it here +// 2. A function parameter, function(Module) { ..generated code.. } +// 3. pre-run appended it, var Module = {}; ..generated code.. +// 4. External script tag defines var Module. +// We need to check if Module already exists (e.g. case 3 above). +// Substitution will be replaced with actual code on later stage of the build, +// this way Closure Compiler will not mangle it (e.g. case 4. above). +// Note that if you want to run closure, and also to use Module +// after the generated code, you will need to define var Module = {}; +// before the code. Then that object will be used in the code, and you +// can continue to use Module afterwards as well. +var Module = typeof BOX2D != 'undefined' ? BOX2D : {}; + +// Set up the promise that indicates the Module is initialized +var readyPromiseResolve, readyPromiseReject; +Module['ready'] = new Promise((resolve, reject) => { + readyPromiseResolve = resolve; + readyPromiseReject = reject; +}); + +// --pre-jses are emitted after the Module integration code, so that they can +// refer to Module (if they choose; they can also define Module) + + +// Sometimes an existing Module object exists with properties +// meant to overwrite the default module functionality. Here +// we collect those properties and reapply _after_ we configure +// the current environment's defaults to avoid having to be so +// defensive during initialization. +var moduleOverrides = Object.assign({}, Module); + +var arguments_ = []; +var thisProgram = './this.program'; +var quit_ = (status, toThrow) => { + throw toThrow; +}; + +// Determine the runtime environment we are in. You can customize this by +// setting the ENVIRONMENT setting at compile time (see settings.js). + +var ENVIRONMENT_IS_WEB = true; +var ENVIRONMENT_IS_WORKER = false; +var ENVIRONMENT_IS_NODE = false; +var ENVIRONMENT_IS_SHELL = false; + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ''; +function locateFile(path) { + if (Module['locateFile']) { + return Module['locateFile'](path, scriptDirectory); + } + return scriptDirectory + path; +} + +// Hooks that are implemented differently in different runtime environments. +var read_, + readAsync, + readBinary, + setWindowTitle; + +// Note that this includes Node.js workers when relevant (pthreads is enabled). +// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and +// ENVIRONMENT_IS_NODE. +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled + scriptDirectory = self.location.href; + } else if (typeof document != 'undefined' && document.currentScript) { // web + scriptDirectory = document.currentScript.src; + } + // When MODULARIZE, this JS may be executed later, after document.currentScript + // is gone, so we saved it, and we use it here instead of any other info. + if (_scriptDir) { + scriptDirectory = _scriptDir; + } + // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. + // otherwise, slice off the final part of the url to find the script directory. + // if scriptDirectory does not contain a slash, lastIndexOf will return -1, + // and scriptDirectory will correctly be replaced with an empty string. + // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #), + // they are removed because they could contain a slash. + if (scriptDirectory.indexOf('blob:') !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf('/')+1); + } else { + scriptDirectory = ''; + } + + // Differentiate the Web Worker from the Node Worker case, as reading must + // be done differently. + { +// include: web_or_worker_shell_read.js +read_ = (url) => { + try { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + } catch (err) { + var data = tryParseAsDataURI(url); + if (data) { + return intArrayToString(data); + } + throw err; + } + } + + if (ENVIRONMENT_IS_WORKER) { + readBinary = (url) => { + try { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.responseType = 'arraybuffer'; + xhr.send(null); + return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response)); + } catch (err) { + var data = tryParseAsDataURI(url); + if (data) { + return data; + } + throw err; + } + }; + } + + readAsync = (url, onload, onerror) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = () => { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 + onload(xhr.response); + return; + } + var data = tryParseAsDataURI(url); + if (data) { + onload(data.buffer); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + } + +// end include: web_or_worker_shell_read.js + } + + setWindowTitle = (title) => document.title = title; +} else +{ +} + +var out = Module['print'] || console.log.bind(console); +var err = Module['printErr'] || console.error.bind(console); + +// Merge back in the overrides +Object.assign(Module, moduleOverrides); +// Free the object hierarchy contained in the overrides, this lets the GC +// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array. +moduleOverrides = null; + +// Emit code to handle expected values on the Module object. This applies Module.x +// to the proper local x. This has two benefits: first, we only emit it if it is +// expected to arrive, and second, by using a local everywhere else that can be +// minified. + +if (Module['arguments']) arguments_ = Module['arguments']; + +if (Module['thisProgram']) thisProgram = Module['thisProgram']; + +if (Module['quit']) quit_ = Module['quit']; + +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message + + +// end include: shell.js +// include: preamble.js +// === Preamble library stuff === + +// Documentation for the public APIs defined in this file must be updated in: +// site/source/docs/api_reference/preamble.js.rst +// A prebuilt local version of the documentation is available at: +// site/build/text/docs/api_reference/preamble.js.txt +// You can also build docs locally as HTML or other formats in site/ +// An online HTML version (which may be of a different version of Emscripten) +// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html + +var wasmBinary; +if (Module['wasmBinary']) wasmBinary = Module['wasmBinary']; +var noExitRuntime = Module['noExitRuntime'] || true; + +// include: wasm2js.js +// wasm2js.js - enough of a polyfill for the WebAssembly object so that we can load +// wasm2js code that way. + +// Emit "var WebAssembly" if definitely using wasm2js. Otherwise, in MAYBE_WASM2JS +// mode, we can't use a "var" since it would prevent normal wasm from working. +/** @suppress{duplicate, const} */ +var +WebAssembly = { + // Note that we do not use closure quoting (this['buffer'], etc.) on these + // functions, as they are just meant for internal use. In other words, this is + // not a fully general polyfill. + /** @constructor */ + Memory: function(opts) { + this.buffer = new ArrayBuffer(opts['initial'] * 65536); + }, + + Module: function(binary) { + // TODO: use the binary and info somehow - right now the wasm2js output is embedded in + // the main JS + }, + + /** @constructor */ + Instance: function(module, info) { + // TODO: use the module somehow - right now the wasm2js output is embedded in + // the main JS + // This will be replaced by the actual wasm2js code. + this.exports = ( +// EMSCRIPTEN_START_ASM +function instantiate(info) { +function Table(ret) { + // grow method not included; table is not growable + ret.set = function(i, func) { + this[i] = func; + }; + ret.get = function(i) { + return this[i]; + }; + return ret; +} + + var bufferView; + var base64ReverseLookup = new Uint8Array(123/*'z'+1*/); + for (var i = 25; i >= 0; --i) { + base64ReverseLookup[48+i] = 52+i; // '0-9' + base64ReverseLookup[65+i] = i; // 'A-Z' + base64ReverseLookup[97+i] = 26+i; // 'a-z' + } + base64ReverseLookup[43] = 62; // '+' + base64ReverseLookup[47] = 63; // '/' + /** @noinline Inlining this function would mean expanding the base64 string 4x times in the source code, which Closure seems to be happy to do. */ + function base64DecodeToExistingUint8Array(uint8Array, offset, b64) { + var b1, b2, i = 0, j = offset, bLength = b64.length, end = offset + (bLength*3>>2) - (b64[bLength-2] == '=') - (b64[bLength-1] == '='); + for (; i < bLength; i += 4) { + b1 = base64ReverseLookup[b64.charCodeAt(i+1)]; + b2 = base64ReverseLookup[b64.charCodeAt(i+2)]; + uint8Array[j++] = base64ReverseLookup[b64.charCodeAt(i)] << 2 | b1 >> 4; + if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; + if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; + } + } +function initActiveSegments(imports) { + base64DecodeToExistingUint8Array(bufferView, 1024, "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"); + base64DecodeToExistingUint8Array(bufferView, 20560, "AwAAAAQAAAAEAAAABgAAAIP5ogBETm4A/CkVANFXJwDdNPUAYtvAADyZlQBBkEMAY1H+ALveqwC3YcUAOm4kANJNQgBJBuAACeouAByS0QDrHf4AKbEcAOg+pwD1NYIARLsuAJzphAC0JnAAQX5fANaROQBTgzkAnPQ5AItfhAAo+b0A+B87AN7/lwAPmAUAES/vAApaiwBtH20Az342AAnLJwBGT7cAnmY/AC3qXwC6J3UA5evHAD178QD3OQcAklKKAPtr6gAfsV8ACF2NADADVgB7/EYA8KtrACC8zwA29JoA46kdAF5hkQAIG+YAhZllAKAUXwCNQGgAgNj/ACdzTQAGBjEAylYVAMmocwB74mAAa4zAABnERwDNZ8MACejcAFmDKgCLdsQAphyWAESv3QAZV9EApT4FAAUH/wAzfj8AwjLoAJhP3gC7fTIAJj3DAB5r7wCf+F4ANR86AH/yygDxhx0AfJAhAGokfADVbvoAMC13ABU7QwC1FMYAwxmdAK3EwgAsTUEADABdAIZ9RgDjcS0Am8aaADNiAAC00nwAtKeXADdV1QDXPvYAoxAYAE12/ABknSoAcNerAGN8+AB6sFcAFxXnAMBJVgA71tkAp4Q4ACQjywDWincAWlQjAAAfuQDxChsAGc7fAJ8x/wBmHmoAmVdhAKz7RwB+f9gAImW3ADLoiQDmv2AA78TNAGw2CQBdP9QAFt7XAFg73gDem5IA0iIoACiG6ADiWE0AxsoyAAjjFgDgfcsAF8BQAPMdpwAY4FsALhM0AIMSYgCDSAEA9Y5bAK2wfwAe6fIASEpDABBn0wCq3dgArl9CAGphzgAKKKQA05m0AAam8gBcd38Ao8KDAGE8iACKc3gAr4xaAG/XvQAtpmMA9L/LAI2B7wAmwWcAVcpFAMrZNgAoqNIAwmGNABLJdwAEJhQAEkabAMRZxADIxUQATbKRAAAX8wDUQ60AKUnlAP3VEAAAvvwAHpTMAHDO7gATPvUA7PGAALPnwwDH+CgAkwWUAMFxPgAuCbMAC0XzAIgSnACrIHsALrWfAEeSwgB7Mi8ADFVtAHKnkABr5x8AMcuWAHkWSgBBeeIA9N+JAOiUlwDi5oQAmTGXAIjtawBfXzYAu/0OAEiatABnpGwAcXJCAI1dMgCfFbgAvOUJAI0xJQD3dDkAMAUcAA0MAQBLCGgALO5YAEeqkAB05wIAvdYkAPd9pgBuSHIAnxbvAI6UpgC0kfYA0VNRAM8K8gAgmDMA9Ut+ALJjaADdPl8AQF0DAIWJfwBVUikAN2TAAG3YEAAySDIAW0x1AE5x1ABFVG4ACwnBACr1aQAUZtUAJwedAF0EUAC0O9sA6nbFAIf5FwBJa30AHSe6AJZpKQDGzKwArRRUAJDiagCI2YkALHJQAASkvgB3B5QA8zBwAAD8JwDqcagAZsJJAGTgPQCX3YMAoz+XAEOU/QANhowAMUHeAJI5nQDdcIwAF7fnAAjfOwAVNysAXICgAFqAkwAQEZIAD+jYAGyArwDb/0sAOJAPAFkYdgBipRUAYcu7AMeJuQAQQL0A0vIEAEl1JwDrtvYA2yK7AAoUqgCJJi8AZIN2AAk7MwAOlBoAUTqqAB2jwgCv7a4AXCYSAG3CTQAtepwAwFaXAAM/gwAJ8PYAK0CMAG0xmQA5tAcADCAVANjDWwD1ksQAxq1LAE7KpQCnN80A5qk2AKuSlADdQmgAGWPeAHaM7wBoi1IA/Ns3AK6hqwDfFTEAAK6hAAz72gBkTWYA7QW3ACllMABXVr8AR/86AGr5uQB1vvMAKJPfAKuAMABmjPYABMsVAPoiBgDZ5B0APbOkAFcbjwA2zQkATkLpABO+pAAzI7UA8KoaAE9lqADSwaUACz8PAFt4zQAj+XYAe4sEAIkXcgDGplMAb27iAO/rAACbSlgAxNq3AKpmugB2z88A0QIdALHxLQCMmcEAw613AIZI2gD3XaAAxoD0AKzwLwDd7JoAP1y8ANDebQCQxx8AKtu2AKMlOgAAr5oArVOTALZXBAApLbQAS4B+ANoHpwB2qg4Ae1mhABYSKgDcty0A+uX9AInb/gCJvv0A5HZsAAap/AA+gHAAhW4VAP2H/wAoPgcAYWczACoYhgBNveoAs+evAI9tbgCVZzkAMb9bAITXSAAw3xYAxy1DACVhNQDJcM4AMMu4AL9s/QCkAKIABWzkAFrdoAAhb0cAYhLSALlchABwYUkAa1bgAJlSAQBQVTcAHtW3ADPxxAATbl8AXTDkAIUuqQAdssMAoTI2AAi3pADqsdQAFvchAI9p5AAn/3cADAOAAI1ALQBPzaAAIKWZALOi0wAvXQoAtPlCABHaywB9vtAAm9vBAKsXvQDKooEACGpcAC5VFwAnAFUAfxTwAOEHhgAUC2QAlkGNAIe+3gDa/SoAayW2AHuJNAAF8/4Aub+eAGhqTwBKKqgAT8RaAC34vADXWpgA9MeVAA1NjQAgOqYApFdfABQ/sQCAOJUAzCABAHHdhgDJ3rYAv2D1AE1lEQABB2sAjLCsALLA0ABRVUgAHvsOAJVywwCjBjsAwEA1AAbcewDgRcwATin6ANbKyADo80EAfGTeAJtk2ADZvjEApJfDAHdY1ABp48UA8NoTALo6PABGGEYAVXVfANK99QBuksYArC5dAA5E7QAcPkIAYcSHACn96QDn1vMAInzKAG+RNQAI4MUA/9eNAG5q4gCw/cYAkwjBAHxddABrrbIAzW6dAD5yewDGEWoA98+pAClz3wC1yboAtwBRAOKyDQB0uiQA5X1gAHTYigANFSwAgRgMAH5mlAABKRYAn3p2AP39vgBWRe8A2X42AOzZEwCLurkAxJf8ADGoJwDxbsMAlMU2ANioVgC0qLUAz8wOABKJLQBvVzQALFaJAJnO4wDWILkAa16qAD4qnAARX8wA/QtKAOH0+wCOO20A4oYsAOnUhAD8tKkA7+7RAC41yQAvOWEAOCFEABvZyACB/AoA+0pqAC8c2ABTtIQATpmMAFQizAAqVdwAwMbWAAsZlgAacLgAaZVkACZaYAA/Uu4AfxEPAPS1EQD8y/UANLwtADS87gDoXcwA3V5gAGeOmwCSM+8AyRe4AGFYmwDhV7wAUYPGANg+EADdcUgALRzdAK8YoQAhLEYAWfPXANl6mACeVMAAT4b6AFYG/ADlea4AiSI2ADitIgBnk9wAVeiqAIImOADK55sAUQ2kAJkzsQCp1w4AaQVIAGWy8AB/iKcAiEyXAPnRNgAhkrMAe4JKAJjPIQBAn9wA3EdVAOF0OgBn60IA/p3fAF7UXwB7Z6QAuqx6AFX2ogAriCMAQbpVAFluCAAhKoYAOUeDAInj5gDlntQASftAAP9W6QAcD8oAxVmKAJT6KwDTwcUAD8XPANtargBHxYYAhUNiACGGOwAseZQAEGGHACpMewCALBoAQ78SAIgmkAB4PIkAqMTkAOXbewDEOsIAJvTqAPdnigANkr8AZaMrAD2TsQC9fAsApFHcACfdYwBp4d0AmpQZAKgplQBozigACe20AESfIABOmMoAcIJjAH58IwAPuTIAp/WOABRW5wAh8QgAtZ0qAG9+TQClGVEAtfmrAILf1gCW3WEAFjYCAMQ6nwCDoqEAcu1tADmNegCCuKkAazJcAEYnWwAANO0A0gB3APz0VQABWU0A4HGA"); + base64DecodeToExistingUint8Array(bufferView, 23347, "QPsh+T8AAAAALUR0PgAAAICYRvg8AAAAYFHMeDsAAACAgxvwOQAAAEAgJXo4AAAAgCKC4zYAAAAAHfNpNRkACgAZGRkAAAAABQAAAAAAAAkAAAAACwAAAAAAAAAAGQARChkZGQMKBwABAAkLGAAACQYLAAALAAYZAAAAGRkZ"); + base64DecodeToExistingUint8Array(bufferView, 23489, "DgAAAAAAAAAAGQAKDRkZGQANAAACAAkOAAAACQAOAAAO"); + base64DecodeToExistingUint8Array(bufferView, 23547, "DA=="); + base64DecodeToExistingUint8Array(bufferView, 23559, "EwAAAAATAAAAAAkMAAAAAAAMAAAM"); + base64DecodeToExistingUint8Array(bufferView, 23605, "EA=="); + base64DecodeToExistingUint8Array(bufferView, 23617, "DwAAAAQPAAAAAAkQAAAAAAAQAAAQ"); + base64DecodeToExistingUint8Array(bufferView, 23663, "Eg=="); + base64DecodeToExistingUint8Array(bufferView, 23675, "EQAAAAARAAAAAAkSAAAAAAASAAASAAAaAAAAGhoa"); + base64DecodeToExistingUint8Array(bufferView, 23730, "GgAAABoaGgAAAAAAAAk="); + base64DecodeToExistingUint8Array(bufferView, 23779, "FA=="); + base64DecodeToExistingUint8Array(bufferView, 23791, "FwAAAAAXAAAAAAkUAAAAAAAUAAAU"); + base64DecodeToExistingUint8Array(bufferView, 23837, "Fg=="); + base64DecodeToExistingUint8Array(bufferView, 23849, "FQAAAAAVAAAAAAkWAAAAAAAWAAAWAAAwMTIzNDU2Nzg5QUJDREVGTjEwX19jeHhhYml2MTE2X19zaGltX3R5cGVfaW5mb0UAAAAADGAAAFBdAADoYAAATjEwX19jeHhhYml2MTE3X19jbGFzc190eXBlX2luZm9FAAAADGAAAIBdAAB0XQAATjEwX19jeHhhYml2MTE3X19wYmFzZV90eXBlX2luZm9FAAAADGAAALBdAAB0XQAATjEwX19jeHhhYml2MTE5X19wb2ludGVyX3R5cGVfaW5mb0UADGAAAOBdAADUXQAATjEwX19jeHhhYml2MTIwX19mdW5jdGlvbl90eXBlX2luZm9FAAAAAAxgAAAQXgAAdF0AAE4xMF9fY3h4YWJpdjEyOV9fcG9pbnRlcl90b19tZW1iZXJfdHlwZV9pbmZvRQAAAAxgAABEXgAA1F0AAAAAAADEXgAAxgMAAMcDAADIAwAAyQMAAMoDAABOMTBfX2N4eGFiaXYxMjNfX2Z1bmRhbWVudGFsX3R5cGVfaW5mb0UADGAAAJxeAAB0XQAAdgAAAIheAADQXgAARG4AAIheAADcXgAAYgAAAIheAADoXgAAYwAAAIheAAD0XgAAaAAAAIheAAAAXwAAYQAAAIheAAAMXwAAcwAAAIheAAAYXwAAdAAAAIheAAAkXwAAaQAAAIheAAAwXwAAagAAAIheAAA8XwAAbAAAAIheAABIXwAAbQAAAIheAABUXwAAeAAAAIheAABgXwAAeQAAAIheAABsXwAAZgAAAIheAAB4XwAAZAAAAIheAACEXwAAAAAAANBfAADGAwAAywMAAMgDAADJAwAAzAMAAE4xMF9fY3h4YWJpdjExNl9fZW51bV90eXBlX2luZm9FAAAAAAxgAACsXwAAdF0AAAAAAACkXQAAxgMAAM0DAADIAwAAyQMAAM4DAADPAwAA0AMAANEDAAAAAAAAVGAAAMYDAADSAwAAyAMAAMkDAADOAwAA0wMAANQDAADVAwAATjEwX19jeHhhYml2MTIwX19zaV9jbGFzc190eXBlX2luZm9FAAAAAAxgAAAsYAAApF0AAAAAAACwYAAAxgMAANYDAADIAwAAyQMAAM4DAADXAwAA2AMAANkDAABOMTBfX2N4eGFiaXYxMjFfX3ZtaV9jbGFzc190eXBlX2luZm9FAAAADGAAAIhgAACkXQAAAAAAAAReAADGAwAA2gMAAMgDAADJAwAA2wMAAFN0OXR5cGVfaW5mbwAAAADkXwAA2GA="); + base64DecodeToExistingUint8Array(bufferView, 24816, "fF8AAEBfAAA0XwAAAAAAANReAAAQYQAAfF8AAHxfAADEYAAADDwAAAAAAADISQAALGEAADRhAAAsYQAA5F8AABw8AADkXwAAJDwAANReAABAXwAA7F4AAOxeAABAXwAA1F4AAEBfAAB8XwAAfF8AAEBfAADUXgAAQF8AAEBfAABAXwAA1F4AAEBfAABAXwAAQF8AAEBfAAA0XwAAQF8AADRfAABAXwAAmF8AAFA8AACYXwAAYDwAAORfAABtPAAAxGAAAJE8AAAAAAAAqGEAAMRgAAC2PAAAAQAAAKhhAACwYQAA1F4AALBhAAA0XwAA1F4AALBhAABYXwAANF8AAFhfAADAYQAABGIAAKhhAABYXwAA5F8AAOc8AAAAAAAA7F4AAKhhAABYXwAANF8AAORfAAACPQAAxGAAAC49AAAAAAAAIGIAAMRgAABbPQAAAQAAACBiAAAoYgAA1F4AAChiAAAsYQ=="); + base64DecodeToExistingUint8Array(bufferView, 25184, "1F4AAChiAABYXwAALGEAAFhfAAA4YgAABGIAACBiAABYXw=="); + base64DecodeToExistingUint8Array(bufferView, 25232, "7F4AACBiAABYXwAALGEAAORfAACJPQAA5F8AAJA9AADkXwAAmT0AAORfAACqPQAA5F8AALw9AADkXwAAyT0AAORfAADTPQAAxGAAAOU9AAAAAAAA0GIAAMRgAAD4PQAAAQAAANBiAADsXgAA2GIAAEBfAADkXwAATz4AAGhgAAAlPgAAAAAAAAIAAADQYgAAAgAAAARjAAACBAAADGAAAAw+AAAMYwAAxGAAAHQ+AAAAAAAALGMAAMRgAACOPgAAAQAAACxjAADUXgAALGMAADhjAAAEYgAAAAAAACxjAADQAgAA0QIAANICAAAAAAAADGMAANMCAADUAgAA1QIAAAAAAADQYgAA1gIAANcCAADVAgAA1F4AAOxeAABAXwAABGIAALxjAAAEYgAA5F8AAKk+AADkXwAA6D4AAMRgAAD8PgAAAAAAAMRjAADEYAAAET8AAAEAAADEYwAAAAAAAHxfAADMYwAAQF8AACxhAAAsYQAAfF8AAGhgAABKPwAAAAAAAAIAAADEYwAAAgAAAARjAAACBAAADGAAAC8/AAAIZAAAxGAAAHY/AAAAAAAAKGQAAMRgAACSPwAAAQAAAChkAADUXgAAKGQAADRkAAAEYgAAAAAAAChkAADYAgAA2QIAANoCAAAAAAAACGQAANsCAADcAgAA1QIAAAAAAADEYwAA3QIAAN4CAADVAgAAfF8AAEBfAAAsYQAALGEAAHxfAADkXwAArz8AAMRgAADDPwAAAAAAALRkAADEYAAA2D8AAAEAAAC0ZAAA1F4AALxkAABAXw=="); + base64DecodeToExistingUint8Array(bufferView, 25840, "1F4AALxkAABAXwAAQF8AAGhgAAAJQAAAAAAAAAIAAAC0ZAAAAgAAAARjAAACBAAADGAAAO4/AAAAZQAA1F4AADhlAABAXwAAxGAAADVAAAAAAAAAIGUAAOxeAAA4ZQAAQF8AAMRgAABRQAAAAQAAACBlAADUXgAAIGUAADhlAAAEYgAAAAAAACBlAADfAgAA4AIAAOECAADiAgAA4wIAAOQCAAAAAAAAAGUAAOUCAADmAgAA5wIAAOgCAADpAgAA6gIAAAAAAAC0ZAAA6wIAAOwCAADnAgAA6AIAAOkCAADqAgAA1F4AAEBfAADUXgAAQF8AAEBfAADkXwAAbkAAAMRgAAB2QAAAAAAAAOhlAADEYAAAf0AAAAEAAADoZQAA1F4AAPBlAABAXwAAQF8AAABm"); + base64DecodeToExistingUint8Array(bufferView, 26160, "1F4AAPBlAABAXwAANF8AAKhi"); + base64DecodeToExistingUint8Array(bufferView, 26192, "1F4AAPBlAAAsYQAAfF8AAKhi"); + base64DecodeToExistingUint8Array(bufferView, 26224, "1F4AAPBlAAAsYQAAfF8AACxhAACoYg=="); + base64DecodeToExistingUint8Array(bufferView, 26256, "1F4AAPBlAAAsYQAALGEAAKhiAADUXgAA8GUAADRhAABoYAAAr0AAAAAAAAACAAAA6GUAAAIAAAAEYwAAAggAAAxgAACfQAAAsGYAAMRgAADPQAAAAAAAANBmAADEYAAA4EAAAAEAAADQZgAA1F4AANBmAADcZgAABGIAAAAAAADQZgAA7QIAAO4CAADvAgAA8AIAAPECAADyAgAA8wIAAPQCAAD1AgAAAAAAALBmAAD2AgAA9wIAANUCAADVAgAA1QIAANUCAADVAgAA1QIAANUC"); + base64DecodeToExistingUint8Array(bufferView, 26480, "1F4AAEBfAAA0XwAAqGIAANReAAAsYQAAfF8AAKhiAADUXgAALGEAAHxfAAAsYQAAqGI="); + base64DecodeToExistingUint8Array(bufferView, 26544, "1F4AACxhAAAsYQAAqGIAANReAAA0YQAA5F8AAPJAAADEYAAA+kAAAAAAAADIZwAAxGAAAANBAAABAAAAyGcAANBnAADsXgAA4GcAACxhAADgZwAAfF8AAOBnAADUXgAA0GcAANBn"); + base64DecodeToExistingUint8Array(bufferView, 26656, "1F4AANBnAADQZwAA0GcAAOxeAADgZwAAyGcAAAAAAADsXgAA4GcAAFBoAACwYgAAxGAAAA1BAAAAAAAAuGIAAORfAAAgQQAAxGAAAClBAAAAAAAAYGgAAMRgAAAzQQAAAQAAAGBoAABoaAAALGEAANReAABoaAAAvGQAANReAABoaAAA8GUAANReAABoaAAAxGgAAGhoAADcaAAA5F8AAEdBAADEYAAAPkEAAAAAAAC8aAAA5F8AAFxBAADEYAAAT0EAAAEAAADUaAAA1F4AAGhoAADEaAAAEGEAAGhoAAAMaQAA5F8AAHZBAADEYAAAZ0EAAAEAAAAEaQAA1F4AAGhoAAAQYQ=="); + base64DecodeToExistingUint8Array(bufferView, 26928, "1F4AAGhoAAB8XwAANF8AADRf"); + base64DecodeToExistingUint8Array(bufferView, 26960, "1F4AAHhoAADYYgAAyGcAANReAAB4aAAAzGMAACxhAAAsYQAA1F4AAGhoAADsXgAA7F4AAHhoAADUXgAAaGgAACxhAAAsYQAAeGgAAORfAACKQQAAxGAAAJNBAAAAAAAAnGkAAMRgAACdQQAAAQAAAJxpAACYYQAAtGkAADRfAAC0aQ=="); + base64DecodeToExistingUint8Array(bufferView, 27104, "7F4AALRpAAA0YQAALGEAAOxeAAC0aQAAUGgAALBiAAA0YQAANF8="); + base64DecodeToExistingUint8Array(bufferView, 27152, "1F4AALRpAADQZwAANGEAADRf"); + base64DecodeToExistingUint8Array(bufferView, 27184, "1F4AALRpAABAagAAfF8AAMRgAACwQQAAAAAAAMBiAADUXgAApGkAAHxfAAB8XwAApGkAAMRgAADEQQAAAAAAADhGAADEYAAA1UEAAAEAAAA4RgAAZGoAAAAAAACcaQAA+AIAAPkCAADVAgAA1QIAANUCAADVAgAA1QIAANUCAACkaQAAdGoAAMRqAADkXwAA+0EAAMRgAADnQQAAAAAAALxqAAA0XwAAdGoAAAAAAADsXgAAdGoAADRhAAAsYQAA7F4AAHRqAABQaAAAsGIAADRhAAA0Xw=="); + base64DecodeToExistingUint8Array(bufferView, 27408, "1F4AAHRqAADQZwAANGEAADRf"); + base64DecodeToExistingUint8Array(bufferView, 27440, "1F4AAHRqAABAagAAfF8AAMRgAAAOQgAAAAAAAHxGAADEYAAAHUIAAAEAAAB8RgAApGkAAFBrAADEagAANF8AAFBr"); + base64DecodeToExistingUint8Array(bufferView, 27520, "7F4AAFBrAAA0YQAALGEAAOxeAABQawAAUGgAALBiAAA0YQAANF8="); + base64DecodeToExistingUint8Array(bufferView, 27568, "1F4AAFBrAADQZwAANGEAADRf"); + base64DecodeToExistingUint8Array(bufferView, 27600, "1F4AAFBrAABAagAAfF8AAMRgAAAtQgAAAAAAAMRGAADEYAAAP0IAAAEAAADERgAA4GsAAKRpAADwawAAxGoAADRfAADwaw=="); + base64DecodeToExistingUint8Array(bufferView, 27680, "1F4AAOBrAAAgYgAANF8AAOxeAADwawAANGEAACxhAADsXgAA8GsAAFBoAACwYgAANGEAADRf"); + base64DecodeToExistingUint8Array(bufferView, 27744, "1F4AAPBrAADQZwAANGEAADRf"); + base64DecodeToExistingUint8Array(bufferView, 27776, "1F4AAPBrAABAagAAfF8AAOxeAADwaw=="); + base64DecodeToExistingUint8Array(bufferView, 27808, "1F4AAOBrAAB8XwAAfF8AANReAADgawAAfF8AAHxfAAAsYQAAfF8AAORfAABaQgAAxGAAAGlCAAAAAAAAyGwAAMRgAAB5QgAAAQAAAMhsAADQbAAA1F4AANBsAAC0aQAAtGkAANBsAADkXwAAikIAAMRgAACVQgAAAAAAAAhtAADEYAAAoUIAAAEAAAAIbQAAmGEAACBtAACkaQAAEG0AANReAAAQbQAA7F4AAOxeAAAgbQAA1F4AABBtAADIYgAAyGIAACBtAADUXgAAEG0AAMRoAAAQbQAA7F4AACBtAAAsYQ=="); + base64DecodeToExistingUint8Array(bufferView, 28048, "7F4AACBtAABQaAAAsGIAADRfAADUXgAAIG0AAEBqAADUXgAAEG0AAHxfAAB8XwAAIG0AAMhnAAAgbQAANF8AANReAAAQbQAANF8AAMRgAAC1QgAAAAAAANRoAADcbQAAxGAAAMFCAAABAAAAvGgAABBtAADEaAAA4GwAAAAAAAAQbQAAxGgAALRpAAB8XwAA1F4AAMRoAAAQbQAAAAAAANReAADEaAAALGEAAHxfAAA0YQAA8G0AACxhAADwbQAAfF8AAPBtAADUXgAAxGgAACxhAADUXgAAxGgAAHxfAADUXgAAxGgAACxhAAAsYQAA7F4="); + base64DecodeToExistingUint8Array(bufferView, 28304, "1F4AAMRoAAAsYQAA7F4AANReAADEaAAAfF8AAOxeAADUXgAA8G0AAEBqAADUXgAAxGgAAMBiAADUXgAAxGgAACxhAADwbQAALGEAANReAADEaAAAoGEAAKBhAADwbQAA1F4AAMRoAADsXgAA7F4AAPBtAAAQbQAAxGgAAGhoAADEaAAAxGAAANdCAAAAAAAABGkAABRvAACYXwAA5UIAANReAAAUbwAAxGgAAMRoAAAUbwAAxGAAAPNCAAABAAAAyEkAAChvAABEbwAAxGgAABBhAAAsYQAARG8AACxhAABEbwAAfF8AAHxfAABEbwAAfF8AAOxeAABEbwAA1F4AABBhAAAMYAAACEMAAARpAADEYAAAHUMAAAAAAACUbwAAxGAAADNDAAABAAAAlG8AAKBvAADEYAAASkMAAAAAAABUSAAAxGAAAF1DAAABAAAAVEgAACxhAADUbwAA1F4AAMRvAAB8XwAAfF8AANRvAADUXgAAxG8AAAxgAABxQwAABGkAAMRgAACDQwAAAAAAAAhwAADEYAAAlkMAAAEAAAAIcAAAFHAAAMRgAACqQwAAAAAAABhKAADEYAAAukMAAAEAAAAYSgAA1F4AADhwAAAsYQAALGEAAEhwAADUXgAAOHAAAHxfAAB8XwAASHAAANReAAA4cAAADGAAAMtDAAAEaQAAxGAAAN1DAAAAAAAAiHAAAMRgAADwQwAAAQAAAIhwAACUcAAAxGAAAAREAAAAAAAAbEoAAMRgAAAURAAAAQAAAGxKAADUXgAAuHAAACxhAAAsYQAAyHAAANReAAC4cAAAfF8AAHxfAADIcAAA1F4AALhwAAAMYAAAJUQAAARpAADEYAAAO0QAAAAAAAAIcQAAxGAAAFJEAAABAAAACHEAABRxAADEYAAAakQAAAAAAAA0SwAAxGAAAH5EAAABAAAANEsAACxhAABIcQAAfF8AAEhxAADsXgAASHEAANReAAA4cQAA7F4AAAAAAADUXgAAOHEAAHxfAAB8XwAA1F4AADhxAAB8XwAAfF8AAEhxAAB8XwAA1F4AADhxAAAMYAAAk0QAAARpAADEYAAAqEQAAAAAAACwcQAAxGAAAL5EAAABAAAAsHEAALxxAADEYAAA1UQAAAAAAADgSwAAxGAAAOhEAAABAAAA4EsAACxhAADwcQAAfF8AAPBxAADsXgAA8HEAANReAADgcQAA7F4="); + base64DecodeToExistingUint8Array(bufferView, 29232, "1F4AAOBxAAB8XwAAfF8AANReAADgcQAAfF8AAHxfAADwcQAAfF8AANReAADgcQAADGAAAPxEAAAEaQAAxGAAAA1FAAAAAAAAYHIAAMRgAAAfRQAAAQAAAGByAABscgAAxGAAADJFAAAAAAAANEwAAMRgAABBRQAAAQAAADRMAAAsYQAAoHIAACxhAACgcgAAfF8AAHxfAACgcgAAfF8AANReAACQcgAAfF8AAHxfAACgcgAA1F4AAJByAAAMYAAAUUUAAARpAADEYAAAYkUAAAAAAADscgAAxGAAAHRFAAABAAAA7HIAAPhyAADEYAAAh0UAAAAAAACITAAAxGAAAJZFAAABAAAAiEwAACxhAAAscwAAfF8AACxzAADUXgAAHHMAAHxfAADUXgAAHHMAAAxgAACmRQAABGkAAMRgAAC4RQAAAAAAAGBzAADEYAAAy0UAAAEAAABgcwAAbHMAAMRgAADfRQAAAAAAANxMAADEYAAA70UAAAEAAADcTAAALGEAAKBzAAB8XwAAoHMAAOxeAACgcwAA1F4AAJBzAADsXgAA1F4AAJBzAAB8XwAAfF8AAKBzAAB8XwAA1F4AAJBzAAACAAAABAAAAAAAAADwTAAAvGUAAAEAAAAAAAAABQ=="); + base64DecodeToExistingUint8Array(bufferView, 29724, "xAM="); + base64DecodeToExistingUint8Array(bufferView, 29748, "vwMAAMUDAAB4eQAAAAQ="); + base64DecodeToExistingUint8Array(bufferView, 29772, "AQ=="); + base64DecodeToExistingUint8Array(bufferView, 29788, "/////wo="); + base64DecodeToExistingUint8Array(bufferView, 29856, "EHQAAACAAQAF"); + base64DecodeToExistingUint8Array(bufferView, 29876, "wQM="); + base64DecodeToExistingUint8Array(bufferView, 29900, "vwMAAL4DAAD0fw=="); + base64DecodeToExistingUint8Array(bufferView, 29924, "Ag=="); + base64DecodeToExistingUint8Array(bufferView, 29940, "//////////8="); + base64DecodeToExistingUint8Array(bufferView, 30008, "qHQ="); +} + + var scratchBuffer = new ArrayBuffer(16); + var i32ScratchView = new Int32Array(scratchBuffer); + var f32ScratchView = new Float32Array(scratchBuffer); + var f64ScratchView = new Float64Array(scratchBuffer); + + function wasm2js_scratch_load_i32(index) { + return i32ScratchView[index]; + } + + function wasm2js_scratch_store_i32(index, value) { + i32ScratchView[index] = value; + } + + function wasm2js_scratch_load_f64() { + return f64ScratchView[0]; + } + + function wasm2js_scratch_store_f64(value) { + f64ScratchView[0] = value; + } + function wasm2js_trap() { throw new Error('abort'); } + + function wasm2js_scratch_store_f32(value) { + f32ScratchView[2] = value; + } + + function wasm2js_scratch_load_f32() { + return f32ScratchView[2]; + } + +function asmFunc(imports) { + var env = imports.env; + var memory = env.memory; + var buffer = memory.buffer; + memory.grow = __wasm_memory_grow; + var HEAP8 = new Int8Array(buffer); + var HEAP16 = new Int16Array(buffer); + var HEAP32 = new Int32Array(buffer); + var HEAPU8 = new Uint8Array(buffer); + var HEAPU16 = new Uint16Array(buffer); + var HEAPU32 = new Uint32Array(buffer); + var HEAPF32 = new Float32Array(buffer); + var HEAPF64 = new Float64Array(buffer); + var Math_imul = Math.imul; + var Math_fround = Math.fround; + var Math_abs = Math.abs; + var Math_clz32 = Math.clz32; + var Math_min = Math.min; + var Math_max = Math.max; + var Math_floor = Math.floor; + var Math_ceil = Math.ceil; + var Math_trunc = Math.trunc; + var Math_sqrt = Math.sqrt; + var _embind_register_class = env._embind_register_class; + var _embind_register_class_class_function = env._embind_register_class_class_function; + var _embind_register_class_property = env._embind_register_class_property; + var _embind_register_constant = env._embind_register_constant; + var _embind_register_function = env._embind_register_function; + var _embind_register_enum = env._embind_register_enum; + var _embind_register_enum_value = env._embind_register_enum_value; + var _embind_register_value_object = env._embind_register_value_object; + var _embind_register_value_object_field = env._embind_register_value_object_field; + var _embind_finalize_value_object = env._embind_finalize_value_object; + var __assert_fail = env.__assert_fail; + var abort = env.abort; + var _embind_register_class_constructor = env._embind_register_class_constructor; + var _embind_register_class_function = env._embind_register_class_function; + var _emval_incref = env._emval_incref; + var _emval_decref = env._emval_decref; + var _emval_take_value = env._emval_take_value; + var _embind_create_inheriting_constructor = env._embind_create_inheriting_constructor; + var _emval_call_void_method = env._emval_call_void_method; + var _emval_get_method_caller = env._emval_get_method_caller; + var _emval_call_method = env._emval_call_method; + var _emval_run_destructors = env._emval_run_destructors; + var _embind_register_void = env._embind_register_void; + var _embind_register_bool = env._embind_register_bool; + var _embind_register_integer = env._embind_register_integer; + var _embind_register_float = env._embind_register_float; + var _embind_register_std_string = env._embind_register_std_string; + var _embind_register_std_wstring = env._embind_register_std_wstring; + var _embind_register_emval = env._embind_register_emval; + var _embind_register_memory_view = env._embind_register_memory_view; + var emscripten_memcpy_big = env.emscripten_memcpy_big; + var __syscall_openat = env.__syscall_openat; + var __syscall_fcntl64 = env.__syscall_fcntl64; + var __syscall_ioctl = env.__syscall_ioctl; + var wasi_snapshot_preview1 = imports.wasi_snapshot_preview1; + var __wasi_fd_write = wasi_snapshot_preview1.fd_write; + var __wasi_fd_read = wasi_snapshot_preview1.fd_read; + var __wasi_fd_close = wasi_snapshot_preview1.fd_close; + var emscripten_resize_heap = env.emscripten_resize_heap; + var legalimport$_embind_register_bigint = env._embind_register_bigint; + var legalimport$__wasi_fd_seek = wasi_snapshot_preview1.fd_seek; + var __stack_pointer = 98304; + var i64toi32_i32$HIGH_BITS = 0; + // EMSCRIPTEN_START_FUNCS +function embind_init_b2_28_29() { + var $0 = 0, $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $0 = __stack_pointer - 16352 | 0; + __stack_pointer = $0; + void_20emscripten__constant_int__28char_20const__2c_20int_20const__29(10836, 29684); + void_20emscripten__constant_int__28char_20const__2c_20int_20const__29(10822, 29688); + void_20emscripten__constant_int__28char_20const__2c_20int_20const__29(10850, 29692); + HEAP32[$0 + 4316 >> 2] = 8; + void_20emscripten__constant_int__28char_20const__2c_20int_20const__29(3570, $0 + 4316 | 0); + void_20emscripten__function_float_2c_20unsigned_20int_2c_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_2c_20int_29_29(12072, 2); + void_20emscripten__function_void_2c_20b2Joint__2c_20float_2c_20float_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2Joint__2c_20float_2c_20float_29_2c_20emscripten__allow_raw_pointers_29(6323, 3); + void_20emscripten__function_b2Vec2_2c_20b2Transform_20const__2c_20b2Vec2_20const__2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Vec2_20_28__29_28b2Transform_20const__2c_20b2Vec2_20const__29_2c_20emscripten__allow_raw_pointers_29(12047, 4); + void_20emscripten__function_void_2c_20unsigned_20int_2c_20bool__28char_20const__2c_20void_20_28__29_28unsigned_20int_2c_20bool_29_29(10246, 5); + void_20emscripten__function_bool_2c_20unsigned_20int__28char_20const__2c_20bool_20_28__29_28unsigned_20int_29_29(7857, 6); + void_20emscripten__function_void_2c_20unsigned_20int_2c_20float__28char_20const__2c_20void_20_28__29_28unsigned_20int_2c_20float_29_29(10303, 7); + void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29(10326, 8); + void_20emscripten__function_void_2c_20unsigned_20int_2c_20float__28char_20const__2c_20void_20_28__29_28unsigned_20int_2c_20float_29_29(6508, 9); + void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29(6527, 10); + void_20emscripten__function_void_2c_20unsigned_20int__28char_20const__2c_20void_20_28__29_28unsigned_20int_29_29(6487, 11); + void_20emscripten__function_void_2c_20unsigned_20int_2c_20float__28char_20const__2c_20void_20_28__29_28unsigned_20int_2c_20float_29_29(6393, 12); + void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29(6415, 13); + void_20emscripten__function_void_2c_20unsigned_20int__28char_20const__2c_20void_20_28__29_28unsigned_20int_29_29(6369, 14); + void_20emscripten__function_unsigned_20int_2c_20unsigned_20int__28char_20const__2c_20unsigned_20int_20_28__29_28unsigned_20int_29_29(11251, 15); + void_20emscripten__function_unsigned_20int_2c_20unsigned_20int__28char_20const__2c_20unsigned_20int_20_28__29_28unsigned_20int_29_29(11044, 16); + void_20emscripten__function_void_2c_20unsigned_20int_2c_20unsigned_20int__28char_20const__2c_20void_20_28__29_28unsigned_20int_2c_20unsigned_20int_29_29(10084, 17); + void_20emscripten__function_unsigned_20int_2c_20unsigned_20int__28char_20const__2c_20unsigned_20int_20_28__29_28unsigned_20int_29_29(10065, 18); + void_20emscripten__function_unsigned_20int_2c_20unsigned_20int__28char_20const__2c_20unsigned_20int_20_28__29_28unsigned_20int_29_29(9245, 19); + void_20emscripten__function_unsigned_20int_2c_20unsigned_20int__28char_20const__2c_20unsigned_20int_20_28__29_28unsigned_20int_29_29(2090, 20); + void_20emscripten__function_unsigned_20int_2c_20unsigned_20int_2c_20int__28char_20const__2c_20unsigned_20int_20_28__29_28unsigned_20int_2c_20int_29_29(3612, 21); + void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29(10712, 22); + void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29(10570, 23); + void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29(10769, 24); + void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29(10627, 25); + void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29(10656, 26); + void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29(10514, 27); + void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29(9063, 28); + void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29(8961, 29); + void_20emscripten__function_unsigned_20int_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20unsigned_20int_20_28__29_28_29_2c_20emscripten__allow_raw_pointers_29(1794, 30); + void_20emscripten__function_float_2c_20unsigned_20int_2c_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_2c_20int_29_29(10684, 31); + void_20emscripten__function_float_2c_20unsigned_20int_2c_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_2c_20int_29_29(10542, 32); + void_20emscripten__function_float_2c_20unsigned_20int_2c_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_2c_20int_29_29(8875, 33); + void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29(10740, 34); + void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29(10598, 35); + void_20emscripten__function_void_2c_20unsigned_20int__28char_20const__2c_20void_20_28__29_28unsigned_20int_29_29(8907, 36); + void_20emscripten__function_float_2c_20unsigned_20int_2c_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_2c_20int_29_29(9093, 37); + void_20emscripten__function_float_2c_20unsigned_20int_2c_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_2c_20int_29_29(8992, 38); + void_20emscripten__function_int_2c_20unsigned_20int__28char_20const__2c_20int_20_28__29_28unsigned_20int_29_29(2112, 39); + emscripten__enum__b2Shape__Type___enum__28char_20const__29($0 + 4312 | 0, 9282); + emscripten__enum__b2Shape__Type___value_28char_20const__2c_20b2Shape__Type_29(emscripten__enum__b2Shape__Type___value_28char_20const__2c_20b2Shape__Type_29(emscripten__enum__b2Shape__Type___value_28char_20const__2c_20b2Shape__Type_29(emscripten__enum__b2Shape__Type___value_28char_20const__2c_20b2Shape__Type_29(emscripten__enum__b2Shape__Type___value_28char_20const__2c_20b2Shape__Type_29($0 + 4312 | 0, 9608, 0), 9786, 1), 6839, 2), 6912, 3), 2357, 4); + emscripten__enum__b2BodyType___enum__28char_20const__29($0 + 4311 | 0, 9228); + emscripten__enum__b2BodyType___value_28char_20const__2c_20b2BodyType_29(emscripten__enum__b2BodyType___value_28char_20const__2c_20b2BodyType_29(emscripten__enum__b2BodyType___value_28char_20const__2c_20b2BodyType_29($0 + 4311 | 0, 1646, 0), 1660, 1), 1687, 2); + emscripten__class__std____2__vector_int_2c_20std____2__allocator_int___2c_20emscripten__internal__NoBaseClass__20emscripten__register_vector_int__28char_20const__29(3712); + emscripten__value_object_b2Vec2___value_object_28char_20const__29($0 + 4309 | 0, 12067); + emscripten__value_object_b2Vec2___20emscripten__value_object_b2Vec2___field_b2Vec2_2c_20float__28char_20const__2c_20float_20b2Vec2____29(emscripten__value_object_b2Vec2___20emscripten__value_object_b2Vec2___field_b2Vec2_2c_20float__28char_20const__2c_20float_20b2Vec2____29($0 + 4309 | 0, 1792, 0), 1733, 4); + emscripten__value_object_b2Vec2____value_object_28_29($0 + 4309 | 0); + emscripten__class__std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___2c_20emscripten__internal__NoBaseClass__20emscripten__register_vector_b2Vec2__28char_20const__29(3701); + emscripten__value_object_b2Rot___value_object_28char_20const__29($0 + 4307 | 0, 1889); + emscripten__value_object_b2Rot___20emscripten__value_object_b2Rot___field_b2Rot_2c_20float__28char_20const__2c_20float_20b2Rot____29(emscripten__value_object_b2Rot___20emscripten__value_object_b2Rot___field_b2Rot_2c_20float__28char_20const__2c_20float_20b2Rot____29($0 + 4307 | 0, 3587, 0), 10400, 4); + emscripten__value_object_b2Rot____value_object_28_29($0 + 4307 | 0); + emscripten__value_object_b2Transform___value_object_28char_20const__29($0 + 4306 | 0, 6954); + emscripten__value_object_b2Transform___20emscripten__value_object_b2Transform___field_b2Transform_2c_20b2Rot__28char_20const__2c_20b2Rot_20b2Transform____29(emscripten__value_object_b2Transform___20emscripten__value_object_b2Transform___field_b2Transform_2c_20b2Vec2__28char_20const__2c_20b2Vec2_20b2Transform____29($0 + 4306 | 0, 6265, 0), 4098, 8); + emscripten__value_object_b2Transform____value_object_28_29($0 + 4306 | 0); + emscripten__value_object_b2Color___value_object_28char_20const__29($0 + 4305 | 0, 3827); + emscripten__value_object_b2Color___20emscripten__value_object_b2Color___field_b2Color_2c_20float__28char_20const__2c_20float_20b2Color____29(emscripten__value_object_b2Color___20emscripten__value_object_b2Color___field_b2Color_2c_20float__28char_20const__2c_20float_20b2Color____29(emscripten__value_object_b2Color___20emscripten__value_object_b2Color___field_b2Color_2c_20float__28char_20const__2c_20float_20b2Color____29(emscripten__value_object_b2Color___20emscripten__value_object_b2Color___field_b2Color_2c_20float__28char_20const__2c_20float_20b2Color____29($0 + 4305 | 0, 4096, 0), 7873, 4), 10402, 8), 10512, 12); + emscripten__value_object_b2Color____value_object_28_29($0 + 4305 | 0); + emscripten__value_object_b2RayCastInput___value_object_28char_20const__29($0 + 4304 | 0, 1838); + emscripten__value_object_b2RayCastInput___20emscripten__value_object_b2RayCastInput___field_b2RayCastInput_2c_20float__28char_20const__2c_20float_20b2RayCastInput____29(emscripten__value_object_b2RayCastInput___20emscripten__value_object_b2RayCastInput___field_b2RayCastInput_2c_20b2Vec2__28char_20const__2c_20b2Vec2_20b2RayCastInput____29(emscripten__value_object_b2RayCastInput___20emscripten__value_object_b2RayCastInput___field_b2RayCastInput_2c_20b2Vec2__28char_20const__2c_20b2Vec2_20b2RayCastInput____29($0 + 4304 | 0, 12129, 0), 12064, 8), 6606, 16); + emscripten__value_object_b2RayCastInput____value_object_28_29($0 + 4304 | 0); + emscripten__value_object_b2RayCastOutput___value_object_28char_20const__29($0 + 4303 | 0, 1824); + emscripten__value_object_b2RayCastOutput___20emscripten__value_object_b2RayCastOutput___field_b2RayCastOutput_2c_20float__28char_20const__2c_20float_20b2RayCastOutput____29(emscripten__value_object_b2RayCastOutput___20emscripten__value_object_b2RayCastOutput___field_b2RayCastOutput_2c_20b2Vec2__28char_20const__2c_20b2Vec2_20b2RayCastOutput____29($0 + 4303 | 0, 7e3, 0), 6565, 8); + emscripten__value_object_b2RayCastOutput____value_object_28_29($0 + 4303 | 0); + emscripten__value_object_b2MassData___value_object_28char_20const__29($0 + 4302 | 0, 10454); + emscripten__value_object_b2MassData___20emscripten__value_object_b2MassData___field_b2MassData_2c_20float__28char_20const__2c_20float_20b2MassData____29(emscripten__value_object_b2MassData___20emscripten__value_object_b2MassData___field_b2MassData_2c_20b2Vec2__28char_20const__2c_20b2Vec2_20b2MassData____29(emscripten__value_object_b2MassData___20emscripten__value_object_b2MassData___field_b2MassData_2c_20float__28char_20const__2c_20float_20b2MassData____29($0 + 4302 | 0, 3423, 0), 3849, 4), 10878, 12); + emscripten__value_object_b2MassData____value_object_28_29($0 + 4302 | 0); + emscripten__value_object_b2Filter___value_object_28char_20const__29($0 + 4301 | 0, 3951); + emscripten__value_object_b2Filter___20emscripten__value_object_b2Filter___field_b2Filter_2c_20short__28char_20const__2c_20short_20b2Filter____29(emscripten__value_object_b2Filter___20emscripten__value_object_b2Filter___field_b2Filter_2c_20unsigned_20short__28char_20const__2c_20unsigned_20short_20b2Filter____29(emscripten__value_object_b2Filter___20emscripten__value_object_b2Filter___field_b2Filter_2c_20unsigned_20short__28char_20const__2c_20unsigned_20short_20b2Filter____29($0 + 4301 | 0, 3365, 0), 3378, 2), 1754, 4); + emscripten__value_object_b2Filter____value_object_28_29($0 + 4301 | 0); + HEAP32[$0 + 4340 >> 2] = $0 + 4300; + HEAP32[$0 + 4336 >> 2] = 7007; + void_20emscripten__internal__NoBaseClass__verify_b2QueryCallback__28_29(); + HEAP32[$0 + 4332 >> 2] = 40; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2QueryCallback__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 4328 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2QueryCallback__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 4324 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 4320 >> 2] = 41; + $1 = emscripten__internal__TypeID_b2QueryCallback_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2QueryCallback__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2QueryCallback_20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$0 + 14816 >> 2] = HEAP32[$0 + 4332 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 4332 >> 2]; + HEAP32[$0 + 14812 >> 2] = HEAP32[$0 + 4328 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$0 + 4328 >> 2]; + HEAP32[$0 + 14808 >> 2] = HEAP32[$0 + 4324 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$0 + 4324 >> 2]; + $11 = HEAP32[$0 + 4336 >> 2]; + HEAP32[$0 + 14820 >> 2] = HEAP32[$0 + 4320 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 4320 >> 2]); + HEAP32[$0 + 4292 >> 2] = 1; + HEAP32[$0 + 4288 >> 2] = 8; + $1 = HEAP32[$0 + 4292 >> 2]; + $2 = HEAP32[$0 + 4288 >> 2]; + HEAP32[$0 + 4344 >> 2] = $2; + HEAP32[$0 + 4348 >> 2] = $1; + $1 = HEAP32[$0 + 4344 >> 2]; + $2 = HEAP32[$0 + 4348 >> 2]; + HEAP32[$0 + 4376 >> 2] = $0 + 4300; + HEAP32[$0 + 4372 >> 2] = 9168; + HEAP32[$0 + 4368 >> 2] = $2; + HEAP32[$0 + 4364 >> 2] = $1; + $3 = HEAP32[$0 + 4376 >> 2]; + $4 = HEAP32[$0 + 4372 >> 2]; + $1 = HEAP32[$0 + 4364 >> 2]; + HEAP32[$0 + 4360 >> 2] = HEAP32[$0 + 4368 >> 2]; + HEAP32[$0 + 4356 >> 2] = $1; + $2 = HEAP32[$0 + 4360 >> 2]; + $1 = HEAP32[$0 + 4356 >> 2]; + HEAP32[$0 + 1976 >> 2] = $1; + HEAP32[$0 + 1980 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2QueryCallback____29_28unsigned_20int_29___invoke_b2QueryCallback_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2QueryCallback____29_28unsigned_20int_29_29($4, $0 + 1976 | 0); + HEAP32[$0 + 4388 >> 2] = $3; + HEAP32[$0 + 4384 >> 2] = 4021; + $1 = HEAP32[$0 + 4388 >> 2]; + $2 = HEAP32[$0 + 4384 >> 2]; + HEAP32[$0 + 14844 >> 2] = $0 + 4383; + HEAP32[$0 + 14840 >> 2] = $2; + void_20emscripten__base_b2QueryCallback___verify_b2QueryCallbackWrapper__28_29(); + HEAP32[$0 + 14836 >> 2] = 42; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2QueryCallback__20_28_emscripten__base_b2QueryCallback___getUpcaster_b2QueryCallbackWrapper__28_29_29_28b2QueryCallbackWrapper__29(), + HEAP32[wasm2js_i32$0 + 14832 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2QueryCallbackWrapper__20_28_emscripten__base_b2QueryCallback___getDowncaster_b2QueryCallbackWrapper__28_29_29_28b2QueryCallback__29(), + HEAP32[wasm2js_i32$0 + 14828 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 14824 >> 2] = 43; + $2 = emscripten__internal__TypeID_b2QueryCallbackWrapper_2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2QueryCallbackWrapper__2c_20void___get_28_29(); + $4 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2QueryCallbackWrapper_20const__2c_20void___get_28_29(); + $5 = emscripten__base_b2QueryCallback___get_28_29(); + HEAP32[$0 + 14900 >> 2] = HEAP32[$0 + 14836 >> 2]; + $6 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $7 = HEAP32[$0 + 14836 >> 2]; + HEAP32[$0 + 14904 >> 2] = HEAP32[$0 + 14832 >> 2]; + $8 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $9 = HEAP32[$0 + 14832 >> 2]; + HEAP32[$0 + 14908 >> 2] = HEAP32[$0 + 14828 >> 2]; + $10 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $11 = HEAP32[$0 + 14828 >> 2]; + $12 = HEAP32[$0 + 14840 >> 2]; + HEAP32[$0 + 14912 >> 2] = HEAP32[$0 + 14824 >> 2]; + _embind_register_class($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, $12 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 14824 >> 2]); + $2 = void_20_28_emscripten__select_overload_void_20_28b2QueryCallbackWrapper__29__28void_20_28__29_28b2QueryCallbackWrapper__29_29_29_28b2QueryCallbackWrapper__29(emscripten__class__b2QueryCallback_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2QueryCallback_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2QueryCallbackWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2QueryCallbackWrapper__29__operator_20void_20_28__29_28b2QueryCallbackWrapper__29_28_29_20const($0 + 4382 | 0)); + HEAP32[$0 + 14856 >> 2] = $0 + 4383; + HEAP32[$0 + 14852 >> 2] = 6458; + HEAP32[$0 + 14848 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2QueryCallbackWrapper__29___invoke_b2QueryCallbackWrapper__28char_20const__2c_20void_20_28__29_28b2QueryCallbackWrapper__29_29(HEAP32[$0 + 14852 >> 2], HEAP32[$0 + 14848 >> 2]); + HEAP32[$0 + 14876 >> 2] = $1; + HEAP32[$0 + 14872 >> 2] = 2811; + HEAP32[$0 + 14868 >> 2] = 44; + $1 = HEAP32[$0 + 14876 >> 2]; + HEAP32[$0 + 14860 >> 2] = 45; + $2 = emscripten__internal__TypeID_b2QueryCallback_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 14872 >> 2]; + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2QueryCallbackWrapper__2c_20emscripten__val_____getCount_28_29_20const($0 + 14867 | 0); + $5 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2QueryCallbackWrapper__2c_20emscripten__val_____getTypes_28_29_20const($0 + 14867 | 0); + HEAP32[$0 + 14916 >> 2] = HEAP32[$0 + 14860 >> 2]; + _embind_register_class_class_function($2 | 0, $3 | 0, $4 | 0, $5 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 14860 >> 2], HEAP32[$0 + 14868 >> 2], 0); + HEAP32[$0 + 14896 >> 2] = $1; + HEAP32[$0 + 14892 >> 2] = 10049; + HEAP32[$0 + 14888 >> 2] = 46; + HEAP32[$0 + 14880 >> 2] = 47; + $1 = emscripten__internal__TypeID_b2QueryCallback_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 14892 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const____getCount_28_29_20const($0 + 14887 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const____getTypes_28_29_20const($0 + 14887 | 0); + HEAP32[$0 + 14920 >> 2] = HEAP32[$0 + 14880 >> 2]; + _embind_register_class_class_function($1 | 0, $2 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 14880 >> 2], HEAP32[$0 + 14888 >> 2], 0); + HEAP32[$0 + 4412 >> 2] = $0 + 4286; + HEAP32[$0 + 4408 >> 2] = 7021; + void_20emscripten__internal__NoBaseClass__verify_b2RayCastCallback__28_29(); + HEAP32[$0 + 4404 >> 2] = 48; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2RayCastCallback__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 4400 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2RayCastCallback__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 4396 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 4392 >> 2] = 49; + $1 = emscripten__internal__TypeID_b2RayCastCallback_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RayCastCallback__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RayCastCallback_20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$0 + 14924 >> 2] = HEAP32[$0 + 4404 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 4404 >> 2]; + HEAP32[$0 + 14804 >> 2] = HEAP32[$0 + 4400 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$0 + 4400 >> 2]; + HEAP32[$0 + 14800 >> 2] = HEAP32[$0 + 4396 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$0 + 4396 >> 2]; + $11 = HEAP32[$0 + 4408 >> 2]; + HEAP32[$0 + 14928 >> 2] = HEAP32[$0 + 4392 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 4392 >> 2]); + HEAP32[$0 + 4280 >> 2] = 1; + HEAP32[$0 + 4276 >> 2] = 8; + $1 = HEAP32[$0 + 4280 >> 2]; + $2 = HEAP32[$0 + 4276 >> 2]; + HEAP32[$0 + 4416 >> 2] = $2; + HEAP32[$0 + 4420 >> 2] = $1; + $1 = HEAP32[$0 + 4416 >> 2]; + $2 = HEAP32[$0 + 4420 >> 2]; + HEAP32[$0 + 4448 >> 2] = $0 + 4286; + HEAP32[$0 + 4444 >> 2] = 9168; + HEAP32[$0 + 4440 >> 2] = $2; + HEAP32[$0 + 4436 >> 2] = $1; + $3 = HEAP32[$0 + 4448 >> 2]; + $4 = HEAP32[$0 + 4444 >> 2]; + $1 = HEAP32[$0 + 4436 >> 2]; + HEAP32[$0 + 4432 >> 2] = HEAP32[$0 + 4440 >> 2]; + HEAP32[$0 + 4428 >> 2] = $1; + $2 = HEAP32[$0 + 4432 >> 2]; + $1 = HEAP32[$0 + 4428 >> 2]; + HEAP32[$0 + 1968 >> 2] = $1; + HEAP32[$0 + 1972 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2RayCastCallback____29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29___invoke_b2RayCastCallback_2c_20emscripten__pure_virtual_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20float_20_28b2RayCastCallback____29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29_29($4, $0 + 1968 | 0); + HEAP32[$0 + 4460 >> 2] = $3; + HEAP32[$0 + 4456 >> 2] = 4042; + $1 = HEAP32[$0 + 4460 >> 2]; + $2 = HEAP32[$0 + 4456 >> 2]; + HEAP32[$0 + 14952 >> 2] = $0 + 4455; + HEAP32[$0 + 14948 >> 2] = $2; + void_20emscripten__base_b2RayCastCallback___verify_b2RayCastCallbackWrapper__28_29(); + HEAP32[$0 + 14944 >> 2] = 50; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2RayCastCallback__20_28_emscripten__base_b2RayCastCallback___getUpcaster_b2RayCastCallbackWrapper__28_29_29_28b2RayCastCallbackWrapper__29(), + HEAP32[wasm2js_i32$0 + 14940 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2RayCastCallbackWrapper__20_28_emscripten__base_b2RayCastCallback___getDowncaster_b2RayCastCallbackWrapper__28_29_29_28b2RayCastCallback__29(), + HEAP32[wasm2js_i32$0 + 14936 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 14932 >> 2] = 51; + $2 = emscripten__internal__TypeID_b2RayCastCallbackWrapper_2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RayCastCallbackWrapper__2c_20void___get_28_29(); + $4 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RayCastCallbackWrapper_20const__2c_20void___get_28_29(); + $5 = emscripten__base_b2RayCastCallback___get_28_29(); + HEAP32[$0 + 15012 >> 2] = HEAP32[$0 + 14944 >> 2]; + $6 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $7 = HEAP32[$0 + 14944 >> 2]; + HEAP32[$0 + 15016 >> 2] = HEAP32[$0 + 14940 >> 2]; + $8 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $9 = HEAP32[$0 + 14940 >> 2]; + HEAP32[$0 + 15020 >> 2] = HEAP32[$0 + 14936 >> 2]; + $10 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $11 = HEAP32[$0 + 14936 >> 2]; + $12 = HEAP32[$0 + 14948 >> 2]; + HEAP32[$0 + 15024 >> 2] = HEAP32[$0 + 14932 >> 2]; + _embind_register_class($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, $12 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 14932 >> 2]); + $2 = void_20_28_emscripten__select_overload_void_20_28b2RayCastCallbackWrapper__29__28void_20_28__29_28b2RayCastCallbackWrapper__29_29_29_28b2RayCastCallbackWrapper__29(emscripten__class__b2RayCastCallback_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2RayCastCallback_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2RayCastCallbackWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2RayCastCallbackWrapper__29__operator_20void_20_28__29_28b2RayCastCallbackWrapper__29_28_29_20const($0 + 4454 | 0)); + HEAP32[$0 + 14964 >> 2] = $0 + 4455; + HEAP32[$0 + 14960 >> 2] = 6458; + HEAP32[$0 + 14956 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2RayCastCallbackWrapper__29___invoke_b2RayCastCallbackWrapper__28char_20const__2c_20void_20_28__29_28b2RayCastCallbackWrapper__29_29(HEAP32[$0 + 14960 >> 2], HEAP32[$0 + 14956 >> 2]); + HEAP32[$0 + 14984 >> 2] = $1; + HEAP32[$0 + 14980 >> 2] = 2811; + HEAP32[$0 + 14976 >> 2] = 52; + $1 = HEAP32[$0 + 14984 >> 2]; + HEAP32[$0 + 14968 >> 2] = 53; + $2 = emscripten__internal__TypeID_b2RayCastCallback_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 14980 >> 2]; + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2RayCastCallbackWrapper__2c_20emscripten__val_____getCount_28_29_20const($0 + 14975 | 0); + $5 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2RayCastCallbackWrapper__2c_20emscripten__val_____getTypes_28_29_20const($0 + 14975 | 0); + HEAP32[$0 + 15028 >> 2] = HEAP32[$0 + 14968 >> 2]; + _embind_register_class_class_function($2 | 0, $3 | 0, $4 | 0, $5 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 14968 >> 2], HEAP32[$0 + 14976 >> 2], 0); + HEAP32[$0 + 15004 >> 2] = $1; + HEAP32[$0 + 15e3 >> 2] = 10049; + HEAP32[$0 + 14996 >> 2] = 54; + HEAP32[$0 + 14988 >> 2] = 47; + $1 = emscripten__internal__TypeID_b2RayCastCallback_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 15e3 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const____getCount_28_29_20const($0 + 14995 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const____getTypes_28_29_20const($0 + 14995 | 0); + HEAP32[$0 + 15008 >> 2] = HEAP32[$0 + 14988 >> 2]; + _embind_register_class_class_function($1 | 0, $2 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 14988 >> 2], HEAP32[$0 + 14996 >> 2], 0); + HEAP32[$0 + 4484 >> 2] = $0 + 4274; + HEAP32[$0 + 4480 >> 2] = 4068; + void_20emscripten__internal__NoBaseClass__verify_b2ContactListener__28_29(); + HEAP32[$0 + 4476 >> 2] = 55; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2ContactListener__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 4472 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2ContactListener__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 4468 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 4464 >> 2] = 56; + $1 = emscripten__internal__TypeID_b2ContactListener_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2ContactListener_20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$0 + 15032 >> 2] = HEAP32[$0 + 4476 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 4476 >> 2]; + HEAP32[$0 + 14796 >> 2] = HEAP32[$0 + 4472 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$0 + 4472 >> 2]; + HEAP32[$0 + 14792 >> 2] = HEAP32[$0 + 4468 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$0 + 4468 >> 2]; + $11 = HEAP32[$0 + 4480 >> 2]; + HEAP32[$0 + 15036 >> 2] = HEAP32[$0 + 4464 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 4464 >> 2]); + HEAP32[$0 + 4268 >> 2] = 1; + HEAP32[$0 + 4264 >> 2] = 8; + $1 = HEAP32[$0 + 4268 >> 2]; + $2 = HEAP32[$0 + 4264 >> 2]; + HEAP32[$0 + 4520 >> 2] = $2; + HEAP32[$0 + 4524 >> 2] = $1; + $1 = HEAP32[$0 + 4520 >> 2]; + $2 = HEAP32[$0 + 4524 >> 2]; + HEAP32[$0 + 4548 >> 2] = $0 + 4274; + HEAP32[$0 + 4544 >> 2] = 3100; + HEAP32[$0 + 4540 >> 2] = $2; + HEAP32[$0 + 4536 >> 2] = $1; + $3 = HEAP32[$0 + 4548 >> 2]; + $4 = HEAP32[$0 + 4544 >> 2]; + $1 = HEAP32[$0 + 4536 >> 2]; + HEAP32[$0 + 4532 >> 2] = HEAP32[$0 + 4540 >> 2]; + HEAP32[$0 + 4528 >> 2] = $1; + $2 = HEAP32[$0 + 4532 >> 2]; + $1 = HEAP32[$0 + 4528 >> 2]; + HEAP32[$0 + 1960 >> 2] = $1; + HEAP32[$0 + 1964 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2ContactListener____29_28unsigned_20int_29___invoke_b2ContactListener_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2ContactListener____29_28unsigned_20int_29_29($4, $0 + 1960 | 0); + HEAP32[$0 + 4256 >> 2] = 1; + HEAP32[$0 + 4252 >> 2] = 12; + $1 = HEAP32[$0 + 4256 >> 2]; + $2 = HEAP32[$0 + 4252 >> 2]; + HEAP32[$0 + 4488 >> 2] = $2; + HEAP32[$0 + 4492 >> 2] = $1; + $1 = HEAP32[$0 + 4488 >> 2]; + $2 = HEAP32[$0 + 4492 >> 2]; + HEAP32[$0 + 4516 >> 2] = $3; + HEAP32[$0 + 4512 >> 2] = 3202; + HEAP32[$0 + 4508 >> 2] = $2; + HEAP32[$0 + 4504 >> 2] = $1; + $3 = HEAP32[$0 + 4516 >> 2]; + $4 = HEAP32[$0 + 4512 >> 2]; + $1 = HEAP32[$0 + 4504 >> 2]; + HEAP32[$0 + 4500 >> 2] = HEAP32[$0 + 4508 >> 2]; + HEAP32[$0 + 4496 >> 2] = $1; + $2 = HEAP32[$0 + 4500 >> 2]; + $1 = HEAP32[$0 + 4496 >> 2]; + HEAP32[$0 + 1952 >> 2] = $1; + HEAP32[$0 + 1956 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2ContactListener____29_28unsigned_20int_29___invoke_b2ContactListener_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2ContactListener____29_28unsigned_20int_29_29($4, $0 + 1952 | 0); + HEAP32[$0 + 4244 >> 2] = 1; + HEAP32[$0 + 4240 >> 2] = 16; + $1 = HEAP32[$0 + 4244 >> 2]; + $2 = HEAP32[$0 + 4240 >> 2]; + HEAP32[$0 + 4584 >> 2] = $2; + HEAP32[$0 + 4588 >> 2] = $1; + $1 = HEAP32[$0 + 4584 >> 2]; + $2 = HEAP32[$0 + 4588 >> 2]; + HEAP32[$0 + 4612 >> 2] = $3; + HEAP32[$0 + 4608 >> 2] = 8689; + HEAP32[$0 + 4604 >> 2] = $2; + HEAP32[$0 + 4600 >> 2] = $1; + $3 = HEAP32[$0 + 4612 >> 2]; + $4 = HEAP32[$0 + 4608 >> 2]; + $1 = HEAP32[$0 + 4600 >> 2]; + HEAP32[$0 + 4596 >> 2] = HEAP32[$0 + 4604 >> 2]; + HEAP32[$0 + 4592 >> 2] = $1; + $2 = HEAP32[$0 + 4596 >> 2]; + $1 = HEAP32[$0 + 4592 >> 2]; + HEAP32[$0 + 1944 >> 2] = $1; + HEAP32[$0 + 1948 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2ContactListener____29_28unsigned_20int_2c_20unsigned_20int_29___invoke_b2ContactListener_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2ContactListener____29_28unsigned_20int_2c_20unsigned_20int_29_29($4, $0 + 1944 | 0); + HEAP32[$0 + 4232 >> 2] = 1; + HEAP32[$0 + 4228 >> 2] = 20; + $1 = HEAP32[$0 + 4232 >> 2]; + $2 = HEAP32[$0 + 4228 >> 2]; + HEAP32[$0 + 4552 >> 2] = $2; + HEAP32[$0 + 4556 >> 2] = $1; + $1 = HEAP32[$0 + 4552 >> 2]; + $2 = HEAP32[$0 + 4556 >> 2]; + HEAP32[$0 + 4580 >> 2] = $3; + HEAP32[$0 + 4576 >> 2] = 8679; + HEAP32[$0 + 4572 >> 2] = $2; + HEAP32[$0 + 4568 >> 2] = $1; + $3 = HEAP32[$0 + 4580 >> 2]; + $4 = HEAP32[$0 + 4576 >> 2]; + $1 = HEAP32[$0 + 4568 >> 2]; + HEAP32[$0 + 4564 >> 2] = HEAP32[$0 + 4572 >> 2]; + HEAP32[$0 + 4560 >> 2] = $1; + $2 = HEAP32[$0 + 4564 >> 2]; + $1 = HEAP32[$0 + 4560 >> 2]; + HEAP32[$0 + 1936 >> 2] = $1; + HEAP32[$0 + 1940 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2ContactListener____29_28unsigned_20int_2c_20unsigned_20int_29___invoke_b2ContactListener_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2ContactListener____29_28unsigned_20int_2c_20unsigned_20int_29_29($4, $0 + 1936 | 0); + HEAP32[$0 + 4224 >> 2] = 0; + HEAP32[$0 + 4220 >> 2] = 57; + $1 = HEAP32[$0 + 4224 >> 2]; + $2 = HEAP32[$0 + 4220 >> 2]; + HEAP32[$0 + 4648 >> 2] = $2; + HEAP32[$0 + 4652 >> 2] = $1; + $1 = HEAP32[$0 + 4648 >> 2]; + $2 = HEAP32[$0 + 4652 >> 2]; + HEAP32[$0 + 4676 >> 2] = $3; + HEAP32[$0 + 4672 >> 2] = 9184; + HEAP32[$0 + 4668 >> 2] = $2; + HEAP32[$0 + 4664 >> 2] = $1; + $3 = HEAP32[$0 + 4676 >> 2]; + $4 = HEAP32[$0 + 4672 >> 2]; + $1 = HEAP32[$0 + 4664 >> 2]; + HEAP32[$0 + 4660 >> 2] = HEAP32[$0 + 4668 >> 2]; + HEAP32[$0 + 4656 >> 2] = $1; + $2 = HEAP32[$0 + 4660 >> 2]; + $1 = HEAP32[$0 + 4656 >> 2]; + HEAP32[$0 + 1928 >> 2] = $1; + HEAP32[$0 + 1932 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2ContactListenerWrapper____29_28unsigned_20int_29___invoke_b2ContactListener__28char_20const__2c_20void_20_28b2ContactListenerWrapper____29_28unsigned_20int_29_29($4, $0 + 1928 | 0); + HEAP32[$0 + 4216 >> 2] = 0; + HEAP32[$0 + 4212 >> 2] = 58; + $1 = HEAP32[$0 + 4216 >> 2]; + $2 = HEAP32[$0 + 4212 >> 2]; + HEAP32[$0 + 4616 >> 2] = $2; + HEAP32[$0 + 4620 >> 2] = $1; + $1 = HEAP32[$0 + 4616 >> 2]; + $2 = HEAP32[$0 + 4620 >> 2]; + HEAP32[$0 + 4644 >> 2] = $3; + HEAP32[$0 + 4640 >> 2] = 9182; + HEAP32[$0 + 4636 >> 2] = $2; + HEAP32[$0 + 4632 >> 2] = $1; + $3 = HEAP32[$0 + 4644 >> 2]; + $4 = HEAP32[$0 + 4640 >> 2]; + $1 = HEAP32[$0 + 4632 >> 2]; + HEAP32[$0 + 4628 >> 2] = HEAP32[$0 + 4636 >> 2]; + HEAP32[$0 + 4624 >> 2] = $1; + $2 = HEAP32[$0 + 4628 >> 2]; + $1 = HEAP32[$0 + 4624 >> 2]; + HEAP32[$0 + 1920 >> 2] = $1; + HEAP32[$0 + 1924 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2ContactListenerWrapper____29_28unsigned_20int_29___invoke_b2ContactListener__28char_20const__2c_20void_20_28b2ContactListenerWrapper____29_28unsigned_20int_29_29($4, $0 + 1920 | 0); + HEAP32[$0 + 4208 >> 2] = 0; + HEAP32[$0 + 4204 >> 2] = 59; + $1 = HEAP32[$0 + 4208 >> 2]; + $2 = HEAP32[$0 + 4204 >> 2]; + HEAP32[$0 + 4680 >> 2] = $2; + HEAP32[$0 + 4684 >> 2] = $1; + $1 = HEAP32[$0 + 4680 >> 2]; + $2 = HEAP32[$0 + 4684 >> 2]; + HEAP32[$0 + 4712 >> 2] = $3; + HEAP32[$0 + 4708 >> 2] = 8029; + HEAP32[$0 + 4704 >> 2] = $2; + HEAP32[$0 + 4700 >> 2] = $1; + $3 = HEAP32[$0 + 4712 >> 2]; + $4 = HEAP32[$0 + 4708 >> 2]; + $1 = HEAP32[$0 + 4700 >> 2]; + HEAP32[$0 + 4696 >> 2] = HEAP32[$0 + 4704 >> 2]; + HEAP32[$0 + 4692 >> 2] = $1; + $2 = HEAP32[$0 + 4696 >> 2]; + $1 = HEAP32[$0 + 4692 >> 2]; + HEAP32[$0 + 1912 >> 2] = $1; + HEAP32[$0 + 1916 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2ContactListenerWrapper____29_28unsigned_20int_29___invoke_b2ContactListener__28char_20const__2c_20bool_20_28b2ContactListenerWrapper____29_28unsigned_20int_29_29($4, $0 + 1912 | 0); + HEAP32[$0 + 4724 >> 2] = $3; + HEAP32[$0 + 4720 >> 2] = 3998; + $1 = HEAP32[$0 + 4724 >> 2]; + $2 = HEAP32[$0 + 4720 >> 2]; + HEAP32[$0 + 15060 >> 2] = $0 + 4719; + HEAP32[$0 + 15056 >> 2] = $2; + void_20emscripten__base_b2ContactListener___verify_b2ContactListenerWrapper__28_29(); + HEAP32[$0 + 15052 >> 2] = 60; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2ContactListener__20_28_emscripten__base_b2ContactListener___getUpcaster_b2ContactListenerWrapper__28_29_29_28b2ContactListenerWrapper__29(), + HEAP32[wasm2js_i32$0 + 15048 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2ContactListenerWrapper__20_28_emscripten__base_b2ContactListener___getDowncaster_b2ContactListenerWrapper__28_29_29_28b2ContactListener__29(), + HEAP32[wasm2js_i32$0 + 15044 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 15040 >> 2] = 61; + $2 = emscripten__internal__TypeID_b2ContactListenerWrapper_2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20void___get_28_29(); + $4 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper_20const__2c_20void___get_28_29(); + $5 = emscripten__base_b2ContactListener___get_28_29(); + HEAP32[$0 + 15120 >> 2] = HEAP32[$0 + 15052 >> 2]; + $6 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $7 = HEAP32[$0 + 15052 >> 2]; + HEAP32[$0 + 15124 >> 2] = HEAP32[$0 + 15048 >> 2]; + $8 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $9 = HEAP32[$0 + 15048 >> 2]; + HEAP32[$0 + 15128 >> 2] = HEAP32[$0 + 15044 >> 2]; + $10 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $11 = HEAP32[$0 + 15044 >> 2]; + $12 = HEAP32[$0 + 15056 >> 2]; + HEAP32[$0 + 15132 >> 2] = HEAP32[$0 + 15040 >> 2]; + _embind_register_class($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, $12 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 15040 >> 2]); + $2 = void_20_28_emscripten__select_overload_void_20_28b2ContactListenerWrapper__29__28void_20_28__29_28b2ContactListenerWrapper__29_29_29_28b2ContactListenerWrapper__29(emscripten__class__b2ContactListener_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2ContactListener_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2ContactListenerWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2ContactListenerWrapper__29__operator_20void_20_28__29_28b2ContactListenerWrapper__29_28_29_20const($0 + 4718 | 0)); + HEAP32[$0 + 15072 >> 2] = $0 + 4719; + HEAP32[$0 + 15068 >> 2] = 6458; + HEAP32[$0 + 15064 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2ContactListenerWrapper__29___invoke_b2ContactListenerWrapper__28char_20const__2c_20void_20_28__29_28b2ContactListenerWrapper__29_29(HEAP32[$0 + 15068 >> 2], HEAP32[$0 + 15064 >> 2]); + HEAP32[$0 + 15092 >> 2] = $1; + HEAP32[$0 + 15088 >> 2] = 2811; + HEAP32[$0 + 15084 >> 2] = 62; + $1 = HEAP32[$0 + 15092 >> 2]; + HEAP32[$0 + 15076 >> 2] = 63; + $2 = emscripten__internal__TypeID_b2ContactListener_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 15088 >> 2]; + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2ContactListenerWrapper__2c_20emscripten__val_____getCount_28_29_20const($0 + 15083 | 0); + $5 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2ContactListenerWrapper__2c_20emscripten__val_____getTypes_28_29_20const($0 + 15083 | 0); + HEAP32[$0 + 15136 >> 2] = HEAP32[$0 + 15076 >> 2]; + _embind_register_class_class_function($2 | 0, $3 | 0, $4 | 0, $5 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 15076 >> 2], HEAP32[$0 + 15084 >> 2], 0); + HEAP32[$0 + 15112 >> 2] = $1; + HEAP32[$0 + 15108 >> 2] = 10049; + HEAP32[$0 + 15104 >> 2] = 64; + HEAP32[$0 + 15096 >> 2] = 47; + $1 = emscripten__internal__TypeID_b2ContactListener_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 15108 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const____getCount_28_29_20const($0 + 15103 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const____getTypes_28_29_20const($0 + 15103 | 0); + HEAP32[$0 + 15116 >> 2] = HEAP32[$0 + 15096 >> 2]; + _embind_register_class_class_function($1 | 0, $2 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 15096 >> 2], HEAP32[$0 + 15104 >> 2], 0); + HEAP32[$0 + 4748 >> 2] = $0 + 4202; + HEAP32[$0 + 4744 >> 2] = 1819; + void_20emscripten__internal__NoBaseClass__verify_b2Draw__28_29(); + HEAP32[$0 + 4740 >> 2] = 65; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2Draw__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 4736 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2Draw__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 4732 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 4728 >> 2] = 66; + $1 = emscripten__internal__TypeID_b2Draw_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Draw__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Draw_20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$0 + 15140 >> 2] = HEAP32[$0 + 4740 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 4740 >> 2]; + HEAP32[$0 + 14788 >> 2] = HEAP32[$0 + 4736 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$0 + 4736 >> 2]; + HEAP32[$0 + 14784 >> 2] = HEAP32[$0 + 4732 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$0 + 4732 >> 2]; + $11 = HEAP32[$0 + 4744 >> 2]; + HEAP32[$0 + 15144 >> 2] = HEAP32[$0 + 4728 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 4728 >> 2]); + HEAP32[$0 + 4196 >> 2] = 0; + HEAP32[$0 + 4192 >> 2] = 67; + $1 = HEAP32[$0 + 4196 >> 2]; + $2 = HEAP32[$0 + 4192 >> 2]; + HEAP32[$0 + 4816 >> 2] = $2; + HEAP32[$0 + 4820 >> 2] = $1; + $1 = HEAP32[$0 + 4816 >> 2]; + $2 = HEAP32[$0 + 4820 >> 2]; + HEAP32[$0 + 4844 >> 2] = $0 + 4202; + HEAP32[$0 + 4840 >> 2] = 3481; + HEAP32[$0 + 4836 >> 2] = $2; + HEAP32[$0 + 4832 >> 2] = $1; + $3 = HEAP32[$0 + 4844 >> 2]; + $4 = HEAP32[$0 + 4840 >> 2]; + $1 = HEAP32[$0 + 4832 >> 2]; + HEAP32[$0 + 4828 >> 2] = HEAP32[$0 + 4836 >> 2]; + HEAP32[$0 + 4824 >> 2] = $1; + $2 = HEAP32[$0 + 4828 >> 2]; + $1 = HEAP32[$0 + 4824 >> 2]; + HEAP32[$0 + 1904 >> 2] = $1; + HEAP32[$0 + 1908 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28unsigned_20int_29___invoke_b2Draw__28char_20const__2c_20void_20_28b2Draw____29_28unsigned_20int_29_29($4, $0 + 1904 | 0); + HEAP32[$0 + 4188 >> 2] = 0; + HEAP32[$0 + 4184 >> 2] = 68; + $1 = HEAP32[$0 + 4188 >> 2]; + $2 = HEAP32[$0 + 4184 >> 2]; + HEAP32[$0 + 4848 >> 2] = $2; + HEAP32[$0 + 4852 >> 2] = $1; + $1 = HEAP32[$0 + 4848 >> 2]; + $2 = HEAP32[$0 + 4852 >> 2]; + HEAP32[$0 + 4876 >> 2] = $3; + HEAP32[$0 + 4872 >> 2] = 3490; + HEAP32[$0 + 4868 >> 2] = $2; + HEAP32[$0 + 4864 >> 2] = $1; + $3 = HEAP32[$0 + 4876 >> 2]; + $4 = HEAP32[$0 + 4872 >> 2]; + $1 = HEAP32[$0 + 4864 >> 2]; + HEAP32[$0 + 4860 >> 2] = HEAP32[$0 + 4868 >> 2]; + HEAP32[$0 + 4856 >> 2] = $1; + $2 = HEAP32[$0 + 4860 >> 2]; + $1 = HEAP32[$0 + 4856 >> 2]; + HEAP32[$0 + 1896 >> 2] = $1; + HEAP32[$0 + 1900 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_unsigned_20int_20_28b2Draw____29_28_29_20const___invoke_b2Draw__28char_20const__2c_20unsigned_20int_20_28b2Draw____29_28_29_20const_29($4, $0 + 1896 | 0); + HEAP32[$0 + 4180 >> 2] = 0; + HEAP32[$0 + 4176 >> 2] = 69; + $1 = HEAP32[$0 + 4180 >> 2]; + $2 = HEAP32[$0 + 4176 >> 2]; + HEAP32[$0 + 4784 >> 2] = $2; + HEAP32[$0 + 4788 >> 2] = $1; + $1 = HEAP32[$0 + 4784 >> 2]; + $2 = HEAP32[$0 + 4788 >> 2]; + HEAP32[$0 + 4812 >> 2] = $3; + HEAP32[$0 + 4808 >> 2] = 3510; + HEAP32[$0 + 4804 >> 2] = $2; + HEAP32[$0 + 4800 >> 2] = $1; + $3 = HEAP32[$0 + 4812 >> 2]; + $4 = HEAP32[$0 + 4808 >> 2]; + $1 = HEAP32[$0 + 4800 >> 2]; + HEAP32[$0 + 4796 >> 2] = HEAP32[$0 + 4804 >> 2]; + HEAP32[$0 + 4792 >> 2] = $1; + $2 = HEAP32[$0 + 4796 >> 2]; + $1 = HEAP32[$0 + 4792 >> 2]; + HEAP32[$0 + 1888 >> 2] = $1; + HEAP32[$0 + 1892 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28unsigned_20int_29___invoke_b2Draw__28char_20const__2c_20void_20_28b2Draw____29_28unsigned_20int_29_29($4, $0 + 1888 | 0); + HEAP32[$0 + 4172 >> 2] = 0; + HEAP32[$0 + 4168 >> 2] = 70; + $1 = HEAP32[$0 + 4172 >> 2]; + $2 = HEAP32[$0 + 4168 >> 2]; + HEAP32[$0 + 4752 >> 2] = $2; + HEAP32[$0 + 4756 >> 2] = $1; + $1 = HEAP32[$0 + 4752 >> 2]; + $2 = HEAP32[$0 + 4756 >> 2]; + HEAP32[$0 + 4780 >> 2] = $3; + HEAP32[$0 + 4776 >> 2] = 3499; + HEAP32[$0 + 4772 >> 2] = $2; + HEAP32[$0 + 4768 >> 2] = $1; + $3 = HEAP32[$0 + 4780 >> 2]; + $4 = HEAP32[$0 + 4776 >> 2]; + $1 = HEAP32[$0 + 4768 >> 2]; + HEAP32[$0 + 4764 >> 2] = HEAP32[$0 + 4772 >> 2]; + HEAP32[$0 + 4760 >> 2] = $1; + $2 = HEAP32[$0 + 4764 >> 2]; + $1 = HEAP32[$0 + 4760 >> 2]; + HEAP32[$0 + 1880 >> 2] = $1; + HEAP32[$0 + 1884 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28unsigned_20int_29___invoke_b2Draw__28char_20const__2c_20void_20_28b2Draw____29_28unsigned_20int_29_29($4, $0 + 1880 | 0); + HEAP32[$0 + 4160 >> 2] = 1; + HEAP32[$0 + 4156 >> 2] = 8; + $1 = HEAP32[$0 + 4160 >> 2]; + $2 = HEAP32[$0 + 4156 >> 2]; + HEAP32[$0 + 4912 >> 2] = $2; + HEAP32[$0 + 4916 >> 2] = $1; + $1 = HEAP32[$0 + 4912 >> 2]; + $2 = HEAP32[$0 + 4916 >> 2]; + HEAP32[$0 + 4940 >> 2] = $3; + HEAP32[$0 + 4936 >> 2] = 6849; + HEAP32[$0 + 4932 >> 2] = $2; + HEAP32[$0 + 4928 >> 2] = $1; + $3 = HEAP32[$0 + 4940 >> 2]; + $4 = HEAP32[$0 + 4936 >> 2]; + $1 = HEAP32[$0 + 4928 >> 2]; + HEAP32[$0 + 4924 >> 2] = HEAP32[$0 + 4932 >> 2]; + HEAP32[$0 + 4920 >> 2] = $1; + $2 = HEAP32[$0 + 4924 >> 2]; + $1 = HEAP32[$0 + 4920 >> 2]; + HEAP32[$0 + 1872 >> 2] = $1; + HEAP32[$0 + 1876 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29___invoke_b2Draw_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Draw____29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29_29($4, $0 + 1872 | 0); + HEAP32[$0 + 4148 >> 2] = 1; + HEAP32[$0 + 4144 >> 2] = 12; + $1 = HEAP32[$0 + 4148 >> 2]; + $2 = HEAP32[$0 + 4144 >> 2]; + HEAP32[$0 + 4880 >> 2] = $2; + HEAP32[$0 + 4884 >> 2] = $1; + $1 = HEAP32[$0 + 4880 >> 2]; + $2 = HEAP32[$0 + 4884 >> 2]; + HEAP32[$0 + 4908 >> 2] = $3; + HEAP32[$0 + 4904 >> 2] = 6861; + HEAP32[$0 + 4900 >> 2] = $2; + HEAP32[$0 + 4896 >> 2] = $1; + $3 = HEAP32[$0 + 4908 >> 2]; + $4 = HEAP32[$0 + 4904 >> 2]; + $1 = HEAP32[$0 + 4896 >> 2]; + HEAP32[$0 + 4892 >> 2] = HEAP32[$0 + 4900 >> 2]; + HEAP32[$0 + 4888 >> 2] = $1; + $2 = HEAP32[$0 + 4892 >> 2]; + $1 = HEAP32[$0 + 4888 >> 2]; + HEAP32[$0 + 1864 >> 2] = $1; + HEAP32[$0 + 1868 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29___invoke_b2Draw_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Draw____29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29_29($4, $0 + 1864 | 0); + HEAP32[$0 + 4136 >> 2] = 1; + HEAP32[$0 + 4132 >> 2] = 16; + $1 = HEAP32[$0 + 4136 >> 2]; + $2 = HEAP32[$0 + 4132 >> 2]; + HEAP32[$0 + 4976 >> 2] = $2; + HEAP32[$0 + 4980 >> 2] = $1; + $1 = HEAP32[$0 + 4976 >> 2]; + $2 = HEAP32[$0 + 4980 >> 2]; + HEAP32[$0 + 5004 >> 2] = $3; + HEAP32[$0 + 5e3 >> 2] = 9617; + HEAP32[$0 + 4996 >> 2] = $2; + HEAP32[$0 + 4992 >> 2] = $1; + $3 = HEAP32[$0 + 5004 >> 2]; + $4 = HEAP32[$0 + 5e3 >> 2]; + $1 = HEAP32[$0 + 4992 >> 2]; + HEAP32[$0 + 4988 >> 2] = HEAP32[$0 + 4996 >> 2]; + HEAP32[$0 + 4984 >> 2] = $1; + $2 = HEAP32[$0 + 4988 >> 2]; + $1 = HEAP32[$0 + 4984 >> 2]; + HEAP32[$0 + 1856 >> 2] = $1; + HEAP32[$0 + 1860 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29___invoke_b2Draw_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29_29($4, $0 + 1856 | 0); + HEAP32[$0 + 4124 >> 2] = 1; + HEAP32[$0 + 4120 >> 2] = 20; + $1 = HEAP32[$0 + 4124 >> 2]; + $2 = HEAP32[$0 + 4120 >> 2]; + HEAP32[$0 + 5008 >> 2] = $2; + HEAP32[$0 + 5012 >> 2] = $1; + $1 = HEAP32[$0 + 5008 >> 2]; + $2 = HEAP32[$0 + 5012 >> 2]; + HEAP32[$0 + 5036 >> 2] = $3; + HEAP32[$0 + 5032 >> 2] = 9651; + HEAP32[$0 + 5028 >> 2] = $2; + HEAP32[$0 + 5024 >> 2] = $1; + $3 = HEAP32[$0 + 5036 >> 2]; + $4 = HEAP32[$0 + 5032 >> 2]; + $1 = HEAP32[$0 + 5024 >> 2]; + HEAP32[$0 + 5020 >> 2] = HEAP32[$0 + 5028 >> 2]; + HEAP32[$0 + 5016 >> 2] = $1; + $2 = HEAP32[$0 + 5020 >> 2]; + $1 = HEAP32[$0 + 5016 >> 2]; + HEAP32[$0 + 1848 >> 2] = $1; + HEAP32[$0 + 1852 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29___invoke_b2Draw_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29_29($4, $0 + 1848 | 0); + HEAP32[$0 + 4112 >> 2] = 1; + HEAP32[$0 + 4108 >> 2] = 24; + $1 = HEAP32[$0 + 4112 >> 2]; + $2 = HEAP32[$0 + 4108 >> 2]; + HEAP32[$0 + 5040 >> 2] = $2; + HEAP32[$0 + 5044 >> 2] = $1; + $1 = HEAP32[$0 + 5040 >> 2]; + $2 = HEAP32[$0 + 5044 >> 2]; + HEAP32[$0 + 5068 >> 2] = $3; + HEAP32[$0 + 5064 >> 2] = 2799; + HEAP32[$0 + 5060 >> 2] = $2; + HEAP32[$0 + 5056 >> 2] = $1; + $3 = HEAP32[$0 + 5068 >> 2]; + $4 = HEAP32[$0 + 5064 >> 2]; + $1 = HEAP32[$0 + 5056 >> 2]; + HEAP32[$0 + 5052 >> 2] = HEAP32[$0 + 5060 >> 2]; + HEAP32[$0 + 5048 >> 2] = $1; + $2 = HEAP32[$0 + 5052 >> 2]; + $1 = HEAP32[$0 + 5048 >> 2]; + HEAP32[$0 + 1840 >> 2] = $1; + HEAP32[$0 + 1844 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29___invoke_b2Draw_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Draw____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29_29($4, $0 + 1840 | 0); + HEAP32[$0 + 4100 >> 2] = 1; + HEAP32[$0 + 4096 >> 2] = 28; + $1 = HEAP32[$0 + 4100 >> 2]; + $2 = HEAP32[$0 + 4096 >> 2]; + HEAP32[$0 + 5072 >> 2] = $2; + HEAP32[$0 + 5076 >> 2] = $1; + $1 = HEAP32[$0 + 5072 >> 2]; + $2 = HEAP32[$0 + 5076 >> 2]; + HEAP32[$0 + 5100 >> 2] = $3; + HEAP32[$0 + 5096 >> 2] = 6924; + HEAP32[$0 + 5092 >> 2] = $2; + HEAP32[$0 + 5088 >> 2] = $1; + $3 = HEAP32[$0 + 5100 >> 2]; + $4 = HEAP32[$0 + 5096 >> 2]; + $1 = HEAP32[$0 + 5088 >> 2]; + HEAP32[$0 + 5084 >> 2] = HEAP32[$0 + 5092 >> 2]; + HEAP32[$0 + 5080 >> 2] = $1; + $2 = HEAP32[$0 + 5084 >> 2]; + $1 = HEAP32[$0 + 5080 >> 2]; + HEAP32[$0 + 1832 >> 2] = $1; + HEAP32[$0 + 1836 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28b2Transform_20const__29___invoke_b2Draw_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Draw____29_28b2Transform_20const__29_29($4, $0 + 1832 | 0); + HEAP32[$0 + 4088 >> 2] = 1; + HEAP32[$0 + 4084 >> 2] = 32; + $1 = HEAP32[$0 + 4088 >> 2]; + $2 = HEAP32[$0 + 4084 >> 2]; + HEAP32[$0 + 4944 >> 2] = $2; + HEAP32[$0 + 4948 >> 2] = $1; + $1 = HEAP32[$0 + 4944 >> 2]; + $2 = HEAP32[$0 + 4948 >> 2]; + HEAP32[$0 + 4972 >> 2] = $3; + HEAP32[$0 + 4968 >> 2] = 2399; + HEAP32[$0 + 4964 >> 2] = $2; + HEAP32[$0 + 4960 >> 2] = $1; + $3 = HEAP32[$0 + 4972 >> 2]; + $4 = HEAP32[$0 + 4968 >> 2]; + $1 = HEAP32[$0 + 4960 >> 2]; + HEAP32[$0 + 4956 >> 2] = HEAP32[$0 + 4964 >> 2]; + HEAP32[$0 + 4952 >> 2] = $1; + $2 = HEAP32[$0 + 4956 >> 2]; + $1 = HEAP32[$0 + 4952 >> 2]; + HEAP32[$0 + 1824 >> 2] = $1; + HEAP32[$0 + 1828 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29___invoke_b2Draw_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29_29($4, $0 + 1824 | 0); + HEAP32[$0 + 5112 >> 2] = $3; + HEAP32[$0 + 5108 >> 2] = 3986; + $1 = HEAP32[$0 + 5112 >> 2]; + $2 = HEAP32[$0 + 5108 >> 2]; + HEAP32[$0 + 15168 >> 2] = $0 + 5107; + HEAP32[$0 + 15164 >> 2] = $2; + void_20emscripten__base_b2Draw___verify_b2DrawWrapper__28_29(); + HEAP32[$0 + 15160 >> 2] = 71; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Draw__20_28_emscripten__base_b2Draw___getUpcaster_b2DrawWrapper__28_29_29_28b2DrawWrapper__29(), + HEAP32[wasm2js_i32$0 + 15156 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2DrawWrapper__20_28_emscripten__base_b2Draw___getDowncaster_b2DrawWrapper__28_29_29_28b2Draw__29(), + HEAP32[wasm2js_i32$0 + 15152 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 15148 >> 2] = 72; + $2 = emscripten__internal__TypeID_b2DrawWrapper_2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2DrawWrapper__2c_20void___get_28_29(); + $4 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2DrawWrapper_20const__2c_20void___get_28_29(); + $5 = emscripten__base_b2Draw___get_28_29(); + HEAP32[$0 + 15228 >> 2] = HEAP32[$0 + 15160 >> 2]; + $6 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $7 = HEAP32[$0 + 15160 >> 2]; + HEAP32[$0 + 15232 >> 2] = HEAP32[$0 + 15156 >> 2]; + $8 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $9 = HEAP32[$0 + 15156 >> 2]; + HEAP32[$0 + 15236 >> 2] = HEAP32[$0 + 15152 >> 2]; + $10 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $11 = HEAP32[$0 + 15152 >> 2]; + $12 = HEAP32[$0 + 15164 >> 2]; + HEAP32[$0 + 15240 >> 2] = HEAP32[$0 + 15148 >> 2]; + _embind_register_class($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, $12 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 15148 >> 2]); + $2 = void_20_28_emscripten__select_overload_void_20_28b2DrawWrapper__29__28void_20_28__29_28b2DrawWrapper__29_29_29_28b2DrawWrapper__29(emscripten__class__b2Draw_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2Draw_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2DrawWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2DrawWrapper__29__operator_20void_20_28__29_28b2DrawWrapper__29_28_29_20const($0 + 5106 | 0)); + HEAP32[$0 + 15180 >> 2] = $0 + 5107; + HEAP32[$0 + 15176 >> 2] = 6458; + HEAP32[$0 + 15172 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2DrawWrapper__29___invoke_b2DrawWrapper__28char_20const__2c_20void_20_28__29_28b2DrawWrapper__29_29(HEAP32[$0 + 15176 >> 2], HEAP32[$0 + 15172 >> 2]); + HEAP32[$0 + 15200 >> 2] = $1; + HEAP32[$0 + 15196 >> 2] = 2811; + HEAP32[$0 + 15192 >> 2] = 73; + $1 = HEAP32[$0 + 15200 >> 2]; + HEAP32[$0 + 15184 >> 2] = 74; + $2 = emscripten__internal__TypeID_b2Draw_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 15196 >> 2]; + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2DrawWrapper__2c_20emscripten__val_____getCount_28_29_20const($0 + 15191 | 0); + $5 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2DrawWrapper__2c_20emscripten__val_____getTypes_28_29_20const($0 + 15191 | 0); + HEAP32[$0 + 15244 >> 2] = HEAP32[$0 + 15184 >> 2]; + _embind_register_class_class_function($2 | 0, $3 | 0, $4 | 0, $5 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 15184 >> 2], HEAP32[$0 + 15192 >> 2], 0); + HEAP32[$0 + 15220 >> 2] = $1; + HEAP32[$0 + 15216 >> 2] = 10049; + HEAP32[$0 + 15212 >> 2] = 75; + HEAP32[$0 + 15204 >> 2] = 47; + $1 = emscripten__internal__TypeID_b2Draw_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 15216 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const____getCount_28_29_20const($0 + 15211 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const____getTypes_28_29_20const($0 + 15211 | 0); + HEAP32[$0 + 15224 >> 2] = HEAP32[$0 + 15204 >> 2]; + _embind_register_class_class_function($1 | 0, $2 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 15204 >> 2], HEAP32[$0 + 15212 >> 2], 0); + HEAP32[$0 + 5136 >> 2] = $0 + 4082; + HEAP32[$0 + 5132 >> 2] = 11099; + void_20emscripten__internal__NoBaseClass__verify_b2AABB__28_29(); + HEAP32[$0 + 5128 >> 2] = 76; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2AABB__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 5124 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2AABB__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 5120 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 5116 >> 2] = 77; + $1 = emscripten__internal__TypeID_b2AABB_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2AABB__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$0 + 15248 >> 2] = HEAP32[$0 + 5128 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 5128 >> 2]; + HEAP32[$0 + 14780 >> 2] = HEAP32[$0 + 5124 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$0 + 5124 >> 2]; + HEAP32[$0 + 14776 >> 2] = HEAP32[$0 + 5120 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$0 + 5120 >> 2]; + $11 = HEAP32[$0 + 5132 >> 2]; + HEAP32[$0 + 15252 >> 2] = HEAP32[$0 + 5116 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 5116 >> 2]); + HEAP32[$0 + 5140 >> 2] = $0 + 4082; + HEAP32[$0 + 15260 >> 2] = HEAP32[$0 + 5140 >> 2]; + HEAP32[$0 + 15256 >> 2] = 78; + $3 = HEAP32[$0 + 15260 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2AABB__20_28__29_28_29___invoke_b2AABB__28b2AABB__20_28__29_28_29_29(HEAP32[$0 + 15256 >> 2]); + HEAP32[$0 + 4076 >> 2] = 0; + HEAP32[$0 + 4072 >> 2] = 79; + $1 = HEAP32[$0 + 4076 >> 2]; + $2 = HEAP32[$0 + 4072 >> 2]; + HEAP32[$0 + 5144 >> 2] = $2; + HEAP32[$0 + 5148 >> 2] = $1; + $1 = HEAP32[$0 + 5144 >> 2]; + $2 = HEAP32[$0 + 5148 >> 2]; + HEAP32[$0 + 5172 >> 2] = $3; + HEAP32[$0 + 5168 >> 2] = 10129; + HEAP32[$0 + 5164 >> 2] = $2; + HEAP32[$0 + 5160 >> 2] = $1; + $3 = HEAP32[$0 + 5172 >> 2]; + $4 = HEAP32[$0 + 5168 >> 2]; + $1 = HEAP32[$0 + 5160 >> 2]; + HEAP32[$0 + 5156 >> 2] = HEAP32[$0 + 5164 >> 2]; + HEAP32[$0 + 5152 >> 2] = $1; + $2 = HEAP32[$0 + 5156 >> 2]; + $1 = HEAP32[$0 + 5152 >> 2]; + HEAP32[$0 + 1816 >> 2] = $1; + HEAP32[$0 + 1820 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2AABB____29_28_29_20const___invoke_b2AABB__28char_20const__2c_20bool_20_28b2AABB____29_28_29_20const_29($4, $0 + 1816 | 0); + HEAP32[$0 + 4068 >> 2] = 0; + HEAP32[$0 + 4064 >> 2] = 80; + $1 = HEAP32[$0 + 4068 >> 2]; + $2 = HEAP32[$0 + 4064 >> 2]; + HEAP32[$0 + 5208 >> 2] = $2; + HEAP32[$0 + 5212 >> 2] = $1; + $1 = HEAP32[$0 + 5208 >> 2]; + $2 = HEAP32[$0 + 5212 >> 2]; + HEAP32[$0 + 5236 >> 2] = $3; + HEAP32[$0 + 5232 >> 2] = 3856; + HEAP32[$0 + 5228 >> 2] = $2; + HEAP32[$0 + 5224 >> 2] = $1; + $3 = HEAP32[$0 + 5236 >> 2]; + $4 = HEAP32[$0 + 5232 >> 2]; + $1 = HEAP32[$0 + 5224 >> 2]; + HEAP32[$0 + 5220 >> 2] = HEAP32[$0 + 5228 >> 2]; + HEAP32[$0 + 5216 >> 2] = $1; + $2 = HEAP32[$0 + 5220 >> 2]; + $1 = HEAP32[$0 + 5216 >> 2]; + HEAP32[$0 + 1808 >> 2] = $1; + HEAP32[$0 + 1812 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2AABB____29_28_29_20const___invoke_b2AABB__28char_20const__2c_20b2Vec2_20_28b2AABB____29_28_29_20const_29($4, $0 + 1808 | 0); + HEAP32[$0 + 4060 >> 2] = 0; + HEAP32[$0 + 4056 >> 2] = 81; + $1 = HEAP32[$0 + 4060 >> 2]; + $2 = HEAP32[$0 + 4056 >> 2]; + HEAP32[$0 + 5176 >> 2] = $2; + HEAP32[$0 + 5180 >> 2] = $1; + $1 = HEAP32[$0 + 5176 >> 2]; + $2 = HEAP32[$0 + 5180 >> 2]; + HEAP32[$0 + 5204 >> 2] = $3; + HEAP32[$0 + 5200 >> 2] = 3344; + HEAP32[$0 + 5196 >> 2] = $2; + HEAP32[$0 + 5192 >> 2] = $1; + $3 = HEAP32[$0 + 5204 >> 2]; + $4 = HEAP32[$0 + 5200 >> 2]; + $1 = HEAP32[$0 + 5192 >> 2]; + HEAP32[$0 + 5188 >> 2] = HEAP32[$0 + 5196 >> 2]; + HEAP32[$0 + 5184 >> 2] = $1; + $2 = HEAP32[$0 + 5188 >> 2]; + $1 = HEAP32[$0 + 5184 >> 2]; + HEAP32[$0 + 1800 >> 2] = $1; + HEAP32[$0 + 1804 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2AABB____29_28_29_20const___invoke_b2AABB__28char_20const__2c_20b2Vec2_20_28b2AABB____29_28_29_20const_29($4, $0 + 1800 | 0); + HEAP32[$0 + 4052 >> 2] = 0; + HEAP32[$0 + 4048 >> 2] = 82; + $1 = HEAP32[$0 + 4052 >> 2]; + $2 = HEAP32[$0 + 4048 >> 2]; + HEAP32[$0 + 5240 >> 2] = $2; + HEAP32[$0 + 5244 >> 2] = $1; + $1 = HEAP32[$0 + 5240 >> 2]; + $2 = HEAP32[$0 + 5244 >> 2]; + HEAP32[$0 + 5268 >> 2] = $3; + HEAP32[$0 + 5264 >> 2] = 3958; + HEAP32[$0 + 5260 >> 2] = $2; + HEAP32[$0 + 5256 >> 2] = $1; + $3 = HEAP32[$0 + 5268 >> 2]; + $4 = HEAP32[$0 + 5264 >> 2]; + $1 = HEAP32[$0 + 5256 >> 2]; + HEAP32[$0 + 5252 >> 2] = HEAP32[$0 + 5260 >> 2]; + HEAP32[$0 + 5248 >> 2] = $1; + $2 = HEAP32[$0 + 5252 >> 2]; + $1 = HEAP32[$0 + 5248 >> 2]; + HEAP32[$0 + 1792 >> 2] = $1; + HEAP32[$0 + 1796 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2AABB____29_28_29_20const___invoke_b2AABB__28char_20const__2c_20float_20_28b2AABB____29_28_29_20const_29($4, $0 + 1792 | 0); + $1 = emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_0__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_0__28embind_init_b2_28_29__$_0_20const__29($0 + 4047 | 0); + HEAP32[$0 + 5280 >> 2] = $3; + HEAP32[$0 + 5276 >> 2] = 9392; + HEAP32[$0 + 5272 >> 2] = $1; + $1 = HEAP32[$0 + 5280 >> 2]; + void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2AABB__2c_20b2AABB__29___invoke_b2AABB_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2AABB__2c_20b2AABB__29_29(HEAP32[$0 + 5276 >> 2], HEAP32[$0 + 5272 >> 2]); + $2 = emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_1__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_1__28embind_init_b2_28_29__$_1_20const__29($0 + 4045 | 0); + HEAP32[$0 + 5292 >> 2] = $1; + HEAP32[$0 + 5288 >> 2] = 6267; + HEAP32[$0 + 5284 >> 2] = $2; + $3 = HEAP32[$0 + 5292 >> 2]; + void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29___invoke_b2AABB_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29_29(HEAP32[$0 + 5288 >> 2], HEAP32[$0 + 5284 >> 2]); + HEAP32[$0 + 4040 >> 2] = 0; + HEAP32[$0 + 4036 >> 2] = 83; + $1 = HEAP32[$0 + 4040 >> 2]; + $2 = HEAP32[$0 + 4036 >> 2]; + HEAP32[$0 + 5296 >> 2] = $2; + HEAP32[$0 + 5300 >> 2] = $1; + $1 = HEAP32[$0 + 5296 >> 2]; + $2 = HEAP32[$0 + 5300 >> 2]; + HEAP32[$0 + 5324 >> 2] = $3; + HEAP32[$0 + 5320 >> 2] = 3448; + HEAP32[$0 + 5316 >> 2] = $2; + HEAP32[$0 + 5312 >> 2] = $1; + $3 = HEAP32[$0 + 5324 >> 2]; + $4 = HEAP32[$0 + 5320 >> 2]; + $1 = HEAP32[$0 + 5312 >> 2]; + HEAP32[$0 + 5308 >> 2] = HEAP32[$0 + 5316 >> 2]; + HEAP32[$0 + 5304 >> 2] = $1; + $2 = HEAP32[$0 + 5308 >> 2]; + $1 = HEAP32[$0 + 5304 >> 2]; + HEAP32[$0 + 1784 >> 2] = $1; + HEAP32[$0 + 1788 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2AABB____29_28b2AABB_20const__29_20const___invoke_b2AABB__28char_20const__2c_20bool_20_28b2AABB____29_28b2AABB_20const__29_20const_29($4, $0 + 1784 | 0); + HEAP32[$0 + 4028 >> 2] = 0; + HEAP32[$0 + 4024 >> 2] = 84; + $1 = HEAP32[$0 + 4028 >> 2]; + $2 = HEAP32[$0 + 4024 >> 2]; + HEAP32[$0 + 5328 >> 2] = $2; + HEAP32[$0 + 5332 >> 2] = $1; + $1 = HEAP32[$0 + 5328 >> 2]; + $2 = HEAP32[$0 + 5332 >> 2]; + HEAP32[$0 + 5360 >> 2] = $3; + HEAP32[$0 + 5356 >> 2] = 1866; + HEAP32[$0 + 5352 >> 2] = $2; + HEAP32[$0 + 5348 >> 2] = $1; + $3 = HEAP32[$0 + 5360 >> 2]; + $4 = HEAP32[$0 + 5356 >> 2]; + $1 = HEAP32[$0 + 5348 >> 2]; + HEAP32[$0 + 5344 >> 2] = HEAP32[$0 + 5352 >> 2]; + HEAP32[$0 + 5340 >> 2] = $1; + $2 = HEAP32[$0 + 5344 >> 2]; + $1 = HEAP32[$0 + 5340 >> 2]; + HEAP32[$0 + 1776 >> 2] = $1; + HEAP32[$0 + 1780 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2AABB____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const___invoke_b2AABB_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2AABB____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const_29($4, $0 + 1776 | 0); + HEAP32[$0 + 5400 >> 2] = $3; + HEAP32[$0 + 5396 >> 2] = 10027; + HEAP32[$0 + 5392 >> 2] = 0; + $1 = HEAP32[$0 + 5400 >> 2]; + HEAP32[$0 + 5388 >> 2] = 85; + HEAP32[$0 + 5384 >> 2] = 86; + $2 = emscripten__internal__TypeID_b2AABB_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 5396 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15264 >> 2] = HEAP32[$0 + 5388 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 5388 >> 2]; + $7 = b2Vec2_20b2AABB_____20emscripten__internal__getContext_b2Vec2_20b2AABB_____28b2Vec2_20b2AABB____20const__29($0 + 5392 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15272 >> 2] = HEAP32[$0 + 5384 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 5384 >> 2], b2Vec2_20b2AABB_____20emscripten__internal__getContext_b2Vec2_20b2AABB_____28b2Vec2_20b2AABB____20const__29($0 + 5392 | 0) | 0); + HEAP32[$0 + 5380 >> 2] = $1; + HEAP32[$0 + 5376 >> 2] = 10038; + HEAP32[$0 + 5372 >> 2] = 8; + HEAP32[$0 + 5368 >> 2] = 85; + HEAP32[$0 + 5364 >> 2] = 86; + $1 = emscripten__internal__TypeID_b2AABB_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 5376 >> 2]; + $3 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15268 >> 2] = HEAP32[$0 + 5368 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $5 = HEAP32[$0 + 5368 >> 2]; + $6 = b2Vec2_20b2AABB_____20emscripten__internal__getContext_b2Vec2_20b2AABB_____28b2Vec2_20b2AABB____20const__29($0 + 5372 | 0); + $7 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15276 >> 2] = HEAP32[$0 + 5364 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 5364 >> 2], b2Vec2_20b2AABB_____20emscripten__internal__getContext_b2Vec2_20b2AABB_____28b2Vec2_20b2AABB____20const__29($0 + 5372 | 0) | 0); + HEAP32[$0 + 5424 >> 2] = $0 + 4023; + HEAP32[$0 + 5420 >> 2] = 10059; + void_20emscripten__internal__NoBaseClass__verify_b2World__28_29(); + HEAP32[$0 + 5416 >> 2] = 87; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2World__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 5412 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2World__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 5408 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 5404 >> 2] = 88; + $1 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2World__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2World_20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$0 + 15280 >> 2] = HEAP32[$0 + 5416 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 5416 >> 2]; + HEAP32[$0 + 14772 >> 2] = HEAP32[$0 + 5412 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$0 + 5412 >> 2]; + HEAP32[$0 + 14768 >> 2] = HEAP32[$0 + 5408 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$0 + 5408 >> 2]; + $11 = HEAP32[$0 + 5420 >> 2]; + HEAP32[$0 + 15284 >> 2] = HEAP32[$0 + 5404 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 5404 >> 2]); + HEAP32[$0 + 5428 >> 2] = $0 + 4023; + HEAP32[$0 + 15292 >> 2] = HEAP32[$0 + 5428 >> 2]; + HEAP32[$0 + 15288 >> 2] = 89; + $3 = HEAP32[$0 + 15292 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2World__20_28__29_28b2Vec2___29___invoke_b2World__28b2World__20_28__29_28b2Vec2___29_29(HEAP32[$0 + 15288 >> 2]); + HEAP32[$0 + 4016 >> 2] = 0; + HEAP32[$0 + 4012 >> 2] = 90; + $1 = HEAP32[$0 + 4016 >> 2]; + $2 = HEAP32[$0 + 4012 >> 2]; + HEAP32[$0 + 5432 >> 2] = $2; + HEAP32[$0 + 5436 >> 2] = $1; + $1 = HEAP32[$0 + 5432 >> 2]; + $2 = HEAP32[$0 + 5436 >> 2]; + HEAP32[$0 + 5460 >> 2] = $3; + HEAP32[$0 + 5456 >> 2] = 4065; + HEAP32[$0 + 5452 >> 2] = $2; + HEAP32[$0 + 5448 >> 2] = $1; + $3 = HEAP32[$0 + 5460 >> 2]; + $4 = HEAP32[$0 + 5456 >> 2]; + $1 = HEAP32[$0 + 5448 >> 2]; + HEAP32[$0 + 5444 >> 2] = HEAP32[$0 + 5452 >> 2]; + HEAP32[$0 + 5440 >> 2] = $1; + $2 = HEAP32[$0 + 5444 >> 2]; + $1 = HEAP32[$0 + 5440 >> 2]; + HEAP32[$0 + 1768 >> 2] = $1; + HEAP32[$0 + 1772 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2ContactListener__29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28b2ContactListener__29_29($4, $0 + 1768 | 0); + HEAP32[$0 + 4004 >> 2] = 0; + HEAP32[$0 + 4e3 >> 2] = 91; + $1 = HEAP32[$0 + 4004 >> 2]; + $2 = HEAP32[$0 + 4e3 >> 2]; + HEAP32[$0 + 5464 >> 2] = $2; + HEAP32[$0 + 5468 >> 2] = $1; + $1 = HEAP32[$0 + 5464 >> 2]; + $2 = HEAP32[$0 + 5468 >> 2]; + HEAP32[$0 + 5492 >> 2] = $3; + HEAP32[$0 + 5488 >> 2] = 1811; + HEAP32[$0 + 5484 >> 2] = $2; + HEAP32[$0 + 5480 >> 2] = $1; + $3 = HEAP32[$0 + 5492 >> 2]; + $4 = HEAP32[$0 + 5488 >> 2]; + $1 = HEAP32[$0 + 5480 >> 2]; + HEAP32[$0 + 5476 >> 2] = HEAP32[$0 + 5484 >> 2]; + HEAP32[$0 + 5472 >> 2] = $1; + $2 = HEAP32[$0 + 5476 >> 2]; + $1 = HEAP32[$0 + 5472 >> 2]; + HEAP32[$0 + 1760 >> 2] = $1; + HEAP32[$0 + 1764 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2Draw__29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28b2Draw__29_29($4, $0 + 1760 | 0); + HEAP32[$0 + 3992 >> 2] = 0; + HEAP32[$0 + 3988 >> 2] = 92; + $1 = HEAP32[$0 + 3992 >> 2]; + $2 = HEAP32[$0 + 3988 >> 2]; + HEAP32[$0 + 5496 >> 2] = $2; + HEAP32[$0 + 5500 >> 2] = $1; + $1 = HEAP32[$0 + 5496 >> 2]; + $2 = HEAP32[$0 + 5500 >> 2]; + HEAP32[$0 + 5524 >> 2] = $3; + HEAP32[$0 + 5520 >> 2] = 1814; + HEAP32[$0 + 5516 >> 2] = $2; + HEAP32[$0 + 5512 >> 2] = $1; + $3 = HEAP32[$0 + 5524 >> 2]; + $4 = HEAP32[$0 + 5520 >> 2]; + $1 = HEAP32[$0 + 5512 >> 2]; + HEAP32[$0 + 5508 >> 2] = HEAP32[$0 + 5516 >> 2]; + HEAP32[$0 + 5504 >> 2] = $1; + $2 = HEAP32[$0 + 5508 >> 2]; + $1 = HEAP32[$0 + 5504 >> 2]; + HEAP32[$0 + 1752 >> 2] = $1; + HEAP32[$0 + 1756 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28_29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28_29_29($4, $0 + 1752 | 0); + HEAP32[$0 + 3980 >> 2] = 0; + HEAP32[$0 + 3976 >> 2] = 93; + $1 = HEAP32[$0 + 3980 >> 2]; + $2 = HEAP32[$0 + 3976 >> 2]; + HEAP32[$0 + 5528 >> 2] = $2; + HEAP32[$0 + 5532 >> 2] = $1; + $1 = HEAP32[$0 + 5528 >> 2]; + $2 = HEAP32[$0 + 5532 >> 2]; + HEAP32[$0 + 5556 >> 2] = $3; + HEAP32[$0 + 5552 >> 2] = 1635; + HEAP32[$0 + 5548 >> 2] = $2; + HEAP32[$0 + 5544 >> 2] = $1; + $3 = HEAP32[$0 + 5556 >> 2]; + $4 = HEAP32[$0 + 5552 >> 2]; + $1 = HEAP32[$0 + 5544 >> 2]; + HEAP32[$0 + 5540 >> 2] = HEAP32[$0 + 5548 >> 2]; + HEAP32[$0 + 5536 >> 2] = $1; + $2 = HEAP32[$0 + 5540 >> 2]; + $1 = HEAP32[$0 + 5536 >> 2]; + HEAP32[$0 + 1744 >> 2] = $1; + HEAP32[$0 + 1748 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Body__20_28b2World____29_28b2BodyDef_20const__29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Body__20_28b2World____29_28b2BodyDef_20const__29_29($4, $0 + 1744 | 0); + HEAP32[$0 + 3968 >> 2] = 0; + HEAP32[$0 + 3964 >> 2] = 94; + $1 = HEAP32[$0 + 3968 >> 2]; + $2 = HEAP32[$0 + 3964 >> 2]; + HEAP32[$0 + 5560 >> 2] = $2; + HEAP32[$0 + 5564 >> 2] = $1; + $1 = HEAP32[$0 + 5560 >> 2]; + $2 = HEAP32[$0 + 5564 >> 2]; + HEAP32[$0 + 5588 >> 2] = $3; + HEAP32[$0 + 5584 >> 2] = 1615; + HEAP32[$0 + 5580 >> 2] = $2; + HEAP32[$0 + 5576 >> 2] = $1; + $3 = HEAP32[$0 + 5588 >> 2]; + $4 = HEAP32[$0 + 5584 >> 2]; + $1 = HEAP32[$0 + 5576 >> 2]; + HEAP32[$0 + 5572 >> 2] = HEAP32[$0 + 5580 >> 2]; + HEAP32[$0 + 5568 >> 2] = $1; + $2 = HEAP32[$0 + 5572 >> 2]; + $1 = HEAP32[$0 + 5568 >> 2]; + HEAP32[$0 + 1736 >> 2] = $1; + HEAP32[$0 + 1740 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2Body__29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28b2Body__29_29($4, $0 + 1736 | 0); + HEAP32[$0 + 3956 >> 2] = 0; + HEAP32[$0 + 3952 >> 2] = 95; + $1 = HEAP32[$0 + 3956 >> 2]; + $2 = HEAP32[$0 + 3952 >> 2]; + HEAP32[$0 + 5592 >> 2] = $2; + HEAP32[$0 + 5596 >> 2] = $1; + $1 = HEAP32[$0 + 5592 >> 2]; + $2 = HEAP32[$0 + 5596 >> 2]; + HEAP32[$0 + 5620 >> 2] = $3; + HEAP32[$0 + 5616 >> 2] = 2586; + HEAP32[$0 + 5612 >> 2] = $2; + HEAP32[$0 + 5608 >> 2] = $1; + $3 = HEAP32[$0 + 5620 >> 2]; + $4 = HEAP32[$0 + 5616 >> 2]; + $1 = HEAP32[$0 + 5608 >> 2]; + HEAP32[$0 + 5604 >> 2] = HEAP32[$0 + 5612 >> 2]; + HEAP32[$0 + 5600 >> 2] = $1; + $2 = HEAP32[$0 + 5604 >> 2]; + $1 = HEAP32[$0 + 5600 >> 2]; + HEAP32[$0 + 1728 >> 2] = $1; + HEAP32[$0 + 1732 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Joint__20_28b2World____29_28b2JointDef_20const__29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Joint__20_28b2World____29_28b2JointDef_20const__29_29($4, $0 + 1728 | 0); + HEAP32[$0 + 3944 >> 2] = 0; + HEAP32[$0 + 3940 >> 2] = 96; + $1 = HEAP32[$0 + 3944 >> 2]; + $2 = HEAP32[$0 + 3940 >> 2]; + HEAP32[$0 + 5624 >> 2] = $2; + HEAP32[$0 + 5628 >> 2] = $1; + $1 = HEAP32[$0 + 5624 >> 2]; + $2 = HEAP32[$0 + 5628 >> 2]; + HEAP32[$0 + 5652 >> 2] = $3; + HEAP32[$0 + 5648 >> 2] = 2511; + HEAP32[$0 + 5644 >> 2] = $2; + HEAP32[$0 + 5640 >> 2] = $1; + $3 = HEAP32[$0 + 5652 >> 2]; + $4 = HEAP32[$0 + 5648 >> 2]; + $1 = HEAP32[$0 + 5640 >> 2]; + HEAP32[$0 + 5636 >> 2] = HEAP32[$0 + 5644 >> 2]; + HEAP32[$0 + 5632 >> 2] = $1; + $2 = HEAP32[$0 + 5636 >> 2]; + $1 = HEAP32[$0 + 5632 >> 2]; + HEAP32[$0 + 1720 >> 2] = $1; + HEAP32[$0 + 1724 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2Joint__29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28b2Joint__29_29($4, $0 + 1720 | 0); + HEAP32[$0 + 3936 >> 2] = 0; + HEAP32[$0 + 3932 >> 2] = 97; + $1 = HEAP32[$0 + 3936 >> 2]; + $2 = HEAP32[$0 + 3932 >> 2]; + HEAP32[$0 + 5656 >> 2] = $2; + HEAP32[$0 + 5660 >> 2] = $1; + $1 = HEAP32[$0 + 5656 >> 2]; + $2 = HEAP32[$0 + 5660 >> 2]; + HEAP32[$0 + 5684 >> 2] = $3; + HEAP32[$0 + 5680 >> 2] = 6237; + HEAP32[$0 + 5676 >> 2] = $2; + HEAP32[$0 + 5672 >> 2] = $1; + $3 = HEAP32[$0 + 5684 >> 2]; + $4 = HEAP32[$0 + 5680 >> 2]; + $1 = HEAP32[$0 + 5672 >> 2]; + HEAP32[$0 + 5668 >> 2] = HEAP32[$0 + 5676 >> 2]; + HEAP32[$0 + 5664 >> 2] = $1; + $2 = HEAP32[$0 + 5668 >> 2]; + $1 = HEAP32[$0 + 5664 >> 2]; + HEAP32[$0 + 1712 >> 2] = $1; + HEAP32[$0 + 1716 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28float_2c_20int_2c_20int_29___invoke_b2World__28char_20const__2c_20void_20_28b2World____29_28float_2c_20int_2c_20int_29_29($4, $0 + 1712 | 0); + HEAP32[$0 + 3924 >> 2] = 0; + HEAP32[$0 + 3920 >> 2] = 98; + $1 = HEAP32[$0 + 3924 >> 2]; + $2 = HEAP32[$0 + 3920 >> 2]; + HEAP32[$0 + 5688 >> 2] = $2; + HEAP32[$0 + 5692 >> 2] = $1; + $1 = HEAP32[$0 + 5688 >> 2]; + $2 = HEAP32[$0 + 5692 >> 2]; + HEAP32[$0 + 5716 >> 2] = $3; + HEAP32[$0 + 5712 >> 2] = 11063; + HEAP32[$0 + 5708 >> 2] = $2; + HEAP32[$0 + 5704 >> 2] = $1; + $3 = HEAP32[$0 + 5716 >> 2]; + $4 = HEAP32[$0 + 5712 >> 2]; + $1 = HEAP32[$0 + 5704 >> 2]; + HEAP32[$0 + 5700 >> 2] = HEAP32[$0 + 5708 >> 2]; + HEAP32[$0 + 5696 >> 2] = $1; + $2 = HEAP32[$0 + 5700 >> 2]; + $1 = HEAP32[$0 + 5696 >> 2]; + HEAP32[$0 + 1704 >> 2] = $1; + HEAP32[$0 + 1708 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2QueryCallback__2c_20b2AABB_20const__29_20const___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28b2QueryCallback__2c_20b2AABB_20const__29_20const_29($4, $0 + 1704 | 0); + HEAP32[$0 + 3912 >> 2] = 0; + HEAP32[$0 + 3908 >> 2] = 99; + $1 = HEAP32[$0 + 3912 >> 2]; + $2 = HEAP32[$0 + 3908 >> 2]; + HEAP32[$0 + 5720 >> 2] = $2; + HEAP32[$0 + 5724 >> 2] = $1; + $1 = HEAP32[$0 + 5720 >> 2]; + $2 = HEAP32[$0 + 5724 >> 2]; + HEAP32[$0 + 5748 >> 2] = $3; + HEAP32[$0 + 5744 >> 2] = 1866; + HEAP32[$0 + 5740 >> 2] = $2; + HEAP32[$0 + 5736 >> 2] = $1; + $3 = HEAP32[$0 + 5748 >> 2]; + $4 = HEAP32[$0 + 5744 >> 2]; + $1 = HEAP32[$0 + 5736 >> 2]; + HEAP32[$0 + 5732 >> 2] = HEAP32[$0 + 5740 >> 2]; + HEAP32[$0 + 5728 >> 2] = $1; + $2 = HEAP32[$0 + 5732 >> 2]; + $1 = HEAP32[$0 + 5728 >> 2]; + HEAP32[$0 + 1696 >> 2] = $1; + HEAP32[$0 + 1700 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const_29($4, $0 + 1696 | 0); + HEAP32[$0 + 3904 >> 2] = 0; + HEAP32[$0 + 3900 >> 2] = 100; + $1 = HEAP32[$0 + 3904 >> 2]; + $2 = HEAP32[$0 + 3900 >> 2]; + HEAP32[$0 + 5752 >> 2] = $2; + HEAP32[$0 + 5756 >> 2] = $1; + $1 = HEAP32[$0 + 5752 >> 2]; + $2 = HEAP32[$0 + 5756 >> 2]; + HEAP32[$0 + 5780 >> 2] = $3; + HEAP32[$0 + 5776 >> 2] = 7823; + HEAP32[$0 + 5772 >> 2] = $2; + HEAP32[$0 + 5768 >> 2] = $1; + $3 = HEAP32[$0 + 5780 >> 2]; + $4 = HEAP32[$0 + 5776 >> 2]; + $1 = HEAP32[$0 + 5768 >> 2]; + HEAP32[$0 + 5764 >> 2] = HEAP32[$0 + 5772 >> 2]; + HEAP32[$0 + 5760 >> 2] = $1; + $2 = HEAP32[$0 + 5764 >> 2]; + $1 = HEAP32[$0 + 5760 >> 2]; + HEAP32[$0 + 1688 >> 2] = $1; + HEAP32[$0 + 1692 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28bool_29___invoke_b2World__28char_20const__2c_20void_20_28b2World____29_28bool_29_29($4, $0 + 1688 | 0); + HEAP32[$0 + 3896 >> 2] = 0; + HEAP32[$0 + 3892 >> 2] = 101; + $1 = HEAP32[$0 + 3896 >> 2]; + $2 = HEAP32[$0 + 3892 >> 2]; + HEAP32[$0 + 5784 >> 2] = $2; + HEAP32[$0 + 5788 >> 2] = $1; + $1 = HEAP32[$0 + 5784 >> 2]; + $2 = HEAP32[$0 + 5788 >> 2]; + HEAP32[$0 + 5812 >> 2] = $3; + HEAP32[$0 + 5808 >> 2] = 7840; + HEAP32[$0 + 5804 >> 2] = $2; + HEAP32[$0 + 5800 >> 2] = $1; + $3 = HEAP32[$0 + 5812 >> 2]; + $4 = HEAP32[$0 + 5808 >> 2]; + $1 = HEAP32[$0 + 5800 >> 2]; + HEAP32[$0 + 5796 >> 2] = HEAP32[$0 + 5804 >> 2]; + HEAP32[$0 + 5792 >> 2] = $1; + $2 = HEAP32[$0 + 5796 >> 2]; + $1 = HEAP32[$0 + 5792 >> 2]; + HEAP32[$0 + 1680 >> 2] = $1; + HEAP32[$0 + 1684 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2World____29_28_29_20const___invoke_b2World__28char_20const__2c_20bool_20_28b2World____29_28_29_20const_29($4, $0 + 1680 | 0); + HEAP32[$0 + 3888 >> 2] = 0; + HEAP32[$0 + 3884 >> 2] = 102; + $1 = HEAP32[$0 + 3888 >> 2]; + $2 = HEAP32[$0 + 3884 >> 2]; + HEAP32[$0 + 5816 >> 2] = $2; + HEAP32[$0 + 5820 >> 2] = $1; + $1 = HEAP32[$0 + 5816 >> 2]; + $2 = HEAP32[$0 + 5820 >> 2]; + HEAP32[$0 + 5844 >> 2] = $3; + HEAP32[$0 + 5840 >> 2] = 1059; + HEAP32[$0 + 5836 >> 2] = $2; + HEAP32[$0 + 5832 >> 2] = $1; + $3 = HEAP32[$0 + 5844 >> 2]; + $4 = HEAP32[$0 + 5840 >> 2]; + $1 = HEAP32[$0 + 5832 >> 2]; + HEAP32[$0 + 5828 >> 2] = HEAP32[$0 + 5836 >> 2]; + HEAP32[$0 + 5824 >> 2] = $1; + $2 = HEAP32[$0 + 5828 >> 2]; + $1 = HEAP32[$0 + 5824 >> 2]; + HEAP32[$0 + 1672 >> 2] = $1; + HEAP32[$0 + 1676 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2Vec2_20const__29___invoke_b2World__28char_20const__2c_20void_20_28b2World____29_28b2Vec2_20const__29_29($4, $0 + 1672 | 0); + HEAP32[$0 + 3880 >> 2] = 0; + HEAP32[$0 + 3876 >> 2] = 103; + $1 = HEAP32[$0 + 3880 >> 2]; + $2 = HEAP32[$0 + 3876 >> 2]; + HEAP32[$0 + 5848 >> 2] = $2; + HEAP32[$0 + 5852 >> 2] = $1; + $1 = HEAP32[$0 + 5848 >> 2]; + $2 = HEAP32[$0 + 5852 >> 2]; + HEAP32[$0 + 5876 >> 2] = $3; + HEAP32[$0 + 5872 >> 2] = 1070; + HEAP32[$0 + 5868 >> 2] = $2; + HEAP32[$0 + 5864 >> 2] = $1; + $3 = HEAP32[$0 + 5876 >> 2]; + $4 = HEAP32[$0 + 5872 >> 2]; + $1 = HEAP32[$0 + 5864 >> 2]; + HEAP32[$0 + 5860 >> 2] = HEAP32[$0 + 5868 >> 2]; + HEAP32[$0 + 5856 >> 2] = $1; + $2 = HEAP32[$0 + 5860 >> 2]; + $1 = HEAP32[$0 + 5856 >> 2]; + HEAP32[$0 + 1664 >> 2] = $1; + HEAP32[$0 + 1668 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2World____29_28_29_20const___invoke_b2World__28char_20const__2c_20b2Vec2_20_28b2World____29_28_29_20const_29($4, $0 + 1664 | 0); + HEAP32[$0 + 3872 >> 2] = 0; + HEAP32[$0 + 3868 >> 2] = 104; + $1 = HEAP32[$0 + 3872 >> 2]; + $2 = HEAP32[$0 + 3868 >> 2]; + HEAP32[$0 + 5880 >> 2] = $2; + HEAP32[$0 + 5884 >> 2] = $1; + $1 = HEAP32[$0 + 5880 >> 2]; + $2 = HEAP32[$0 + 5884 >> 2]; + HEAP32[$0 + 5908 >> 2] = $3; + HEAP32[$0 + 5904 >> 2] = 6232; + HEAP32[$0 + 5900 >> 2] = $2; + HEAP32[$0 + 5896 >> 2] = $1; + $3 = HEAP32[$0 + 5904 >> 2]; + $1 = HEAP32[$0 + 5896 >> 2]; + HEAP32[$0 + 5892 >> 2] = HEAP32[$0 + 5900 >> 2]; + HEAP32[$0 + 5888 >> 2] = $1; + $2 = HEAP32[$0 + 5892 >> 2]; + $1 = HEAP32[$0 + 5888 >> 2]; + HEAP32[$0 + 1656 >> 2] = $1; + HEAP32[$0 + 1660 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28_29___invoke_b2World__28char_20const__2c_20void_20_28b2World____29_28_29_29($3, $0 + 1656 | 0); + HEAP32[$0 + 5932 >> 2] = $0 + 3867; + HEAP32[$0 + 5928 >> 2] = 9380; + void_20emscripten__internal__NoBaseClass__verify_b2Shape__28_29(); + HEAP32[$0 + 5924 >> 2] = 105; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2Shape__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 5920 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2Shape__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 5916 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 5912 >> 2] = 106; + $1 = emscripten__internal__TypeID_b2Shape_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Shape__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$0 + 15296 >> 2] = HEAP32[$0 + 5924 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 5924 >> 2]; + HEAP32[$0 + 14764 >> 2] = HEAP32[$0 + 5920 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$0 + 5920 >> 2]; + HEAP32[$0 + 14760 >> 2] = HEAP32[$0 + 5916 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$0 + 5916 >> 2]; + $11 = HEAP32[$0 + 5928 >> 2]; + HEAP32[$0 + 15300 >> 2] = HEAP32[$0 + 5912 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 5912 >> 2]); + HEAP32[$0 + 5952 >> 2] = $0 + 3867; + HEAP32[$0 + 5948 >> 2] = 9221; + HEAP32[$0 + 5944 >> 2] = 4; + $1 = HEAP32[$0 + 5952 >> 2]; + HEAP32[$0 + 5940 >> 2] = 107; + HEAP32[$0 + 5936 >> 2] = 108; + $2 = emscripten__internal__TypeID_b2Shape_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 5948 >> 2]; + $4 = emscripten__internal__TypeID_b2Shape__Type_2c_20void___get_28_29(); + HEAP32[$0 + 15304 >> 2] = HEAP32[$0 + 5940 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 5940 >> 2]; + $7 = b2Shape__Type_20b2Shape_____20emscripten__internal__getContext_b2Shape__Type_20b2Shape_____28b2Shape__Type_20b2Shape____20const__29($0 + 5944 | 0); + $8 = emscripten__internal__TypeID_b2Shape__Type_2c_20void___get_28_29(); + HEAP32[$0 + 15308 >> 2] = HEAP32[$0 + 5936 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 5936 >> 2], b2Shape__Type_20b2Shape_____20emscripten__internal__getContext_b2Shape__Type_20b2Shape_____28b2Shape__Type_20b2Shape____20const__29($0 + 5944 | 0) | 0); + HEAP32[$0 + 5972 >> 2] = $1; + HEAP32[$0 + 5968 >> 2] = 3243; + HEAP32[$0 + 5964 >> 2] = 8; + $3 = HEAP32[$0 + 5972 >> 2]; + HEAP32[$0 + 5960 >> 2] = 109; + HEAP32[$0 + 5956 >> 2] = 110; + $1 = emscripten__internal__TypeID_b2Shape_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 5968 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15312 >> 2] = HEAP32[$0 + 5960 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 5960 >> 2]; + $7 = float_20b2Shape_____20emscripten__internal__getContext_float_20b2Shape_____28float_20b2Shape____20const__29($0 + 5964 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15316 >> 2] = HEAP32[$0 + 5956 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 5956 >> 2], float_20b2Shape_____20emscripten__internal__getContext_float_20b2Shape_____28float_20b2Shape____20const__29($0 + 5964 | 0) | 0); + HEAP32[$0 + 3860 >> 2] = 0; + HEAP32[$0 + 3856 >> 2] = 111; + $1 = HEAP32[$0 + 3860 >> 2]; + $2 = HEAP32[$0 + 3856 >> 2]; + HEAP32[$0 + 5976 >> 2] = $2; + HEAP32[$0 + 5980 >> 2] = $1; + $1 = HEAP32[$0 + 5976 >> 2]; + $2 = HEAP32[$0 + 5980 >> 2]; + HEAP32[$0 + 6004 >> 2] = $3; + HEAP32[$0 + 6e3 >> 2] = 9253; + HEAP32[$0 + 5996 >> 2] = $2; + HEAP32[$0 + 5992 >> 2] = $1; + $3 = HEAP32[$0 + 6004 >> 2]; + $4 = HEAP32[$0 + 6e3 >> 2]; + $1 = HEAP32[$0 + 5992 >> 2]; + HEAP32[$0 + 5988 >> 2] = HEAP32[$0 + 5996 >> 2]; + HEAP32[$0 + 5984 >> 2] = $1; + $2 = HEAP32[$0 + 5988 >> 2]; + $1 = HEAP32[$0 + 5984 >> 2]; + HEAP32[$0 + 1648 >> 2] = $1; + HEAP32[$0 + 1652 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Shape__Type_20_28b2Shape____29_28_29_20const___invoke_b2Shape__28char_20const__2c_20b2Shape__Type_20_28b2Shape____29_28_29_20const_29($4, $0 + 1648 | 0); + HEAP32[$0 + 3852 >> 2] = 1; + HEAP32[$0 + 3848 >> 2] = 12; + $1 = HEAP32[$0 + 3852 >> 2]; + $2 = HEAP32[$0 + 3848 >> 2]; + HEAP32[$0 + 6008 >> 2] = $2; + HEAP32[$0 + 6012 >> 2] = $1; + $1 = HEAP32[$0 + 6008 >> 2]; + $2 = HEAP32[$0 + 6012 >> 2]; + HEAP32[$0 + 6036 >> 2] = $3; + HEAP32[$0 + 6032 >> 2] = 2385; + HEAP32[$0 + 6028 >> 2] = $2; + HEAP32[$0 + 6024 >> 2] = $1; + $3 = HEAP32[$0 + 6036 >> 2]; + $4 = HEAP32[$0 + 6032 >> 2]; + $1 = HEAP32[$0 + 6024 >> 2]; + HEAP32[$0 + 6020 >> 2] = HEAP32[$0 + 6028 >> 2]; + HEAP32[$0 + 6016 >> 2] = $1; + $2 = HEAP32[$0 + 6020 >> 2]; + $1 = HEAP32[$0 + 6016 >> 2]; + HEAP32[$0 + 1640 >> 2] = $1; + HEAP32[$0 + 1644 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_int_20_28b2Shape____29_28_29_20const___invoke_b2Shape__28char_20const__2c_20int_20_28b2Shape____29_28_29_20const_29($4, $0 + 1640 | 0); + HEAP32[$0 + 3844 >> 2] = 1; + HEAP32[$0 + 3840 >> 2] = 16; + $1 = HEAP32[$0 + 3844 >> 2]; + $2 = HEAP32[$0 + 3840 >> 2]; + HEAP32[$0 + 6040 >> 2] = $2; + HEAP32[$0 + 6044 >> 2] = $1; + $1 = HEAP32[$0 + 6040 >> 2]; + $2 = HEAP32[$0 + 6044 >> 2]; + HEAP32[$0 + 6068 >> 2] = $3; + HEAP32[$0 + 6064 >> 2] = 2409; + HEAP32[$0 + 6060 >> 2] = $2; + HEAP32[$0 + 6056 >> 2] = $1; + $3 = HEAP32[$0 + 6068 >> 2]; + $4 = HEAP32[$0 + 6064 >> 2]; + $1 = HEAP32[$0 + 6056 >> 2]; + HEAP32[$0 + 6052 >> 2] = HEAP32[$0 + 6060 >> 2]; + HEAP32[$0 + 6048 >> 2] = $1; + $2 = HEAP32[$0 + 6052 >> 2]; + $1 = HEAP32[$0 + 6048 >> 2]; + HEAP32[$0 + 1632 >> 2] = $1; + HEAP32[$0 + 1636 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Shape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const___invoke_b2Shape__28char_20const__2c_20bool_20_28b2Shape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29($4, $0 + 1632 | 0); + HEAP32[$0 + 3832 >> 2] = 1; + HEAP32[$0 + 3828 >> 2] = 20; + $1 = HEAP32[$0 + 3832 >> 2]; + $2 = HEAP32[$0 + 3828 >> 2]; + HEAP32[$0 + 6072 >> 2] = $2; + HEAP32[$0 + 6076 >> 2] = $1; + $1 = HEAP32[$0 + 6072 >> 2]; + $2 = HEAP32[$0 + 6076 >> 2]; + HEAP32[$0 + 6100 >> 2] = $3; + HEAP32[$0 + 6096 >> 2] = 1866; + HEAP32[$0 + 6092 >> 2] = $2; + HEAP32[$0 + 6088 >> 2] = $1; + $3 = HEAP32[$0 + 6100 >> 2]; + $4 = HEAP32[$0 + 6096 >> 2]; + $1 = HEAP32[$0 + 6088 >> 2]; + HEAP32[$0 + 6084 >> 2] = HEAP32[$0 + 6092 >> 2]; + HEAP32[$0 + 6080 >> 2] = $1; + $2 = HEAP32[$0 + 6084 >> 2]; + $1 = HEAP32[$0 + 6080 >> 2]; + HEAP32[$0 + 1624 >> 2] = $1; + HEAP32[$0 + 1628 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Shape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2Shape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2Shape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29($4, $0 + 1624 | 0); + HEAP32[$0 + 3820 >> 2] = 1; + HEAP32[$0 + 3816 >> 2] = 24; + $1 = HEAP32[$0 + 3820 >> 2]; + $2 = HEAP32[$0 + 3816 >> 2]; + HEAP32[$0 + 6104 >> 2] = $2; + HEAP32[$0 + 6108 >> 2] = $1; + $1 = HEAP32[$0 + 6104 >> 2]; + $2 = HEAP32[$0 + 6108 >> 2]; + HEAP32[$0 + 6132 >> 2] = $3; + HEAP32[$0 + 6128 >> 2] = 11092; + HEAP32[$0 + 6124 >> 2] = $2; + HEAP32[$0 + 6120 >> 2] = $1; + $3 = HEAP32[$0 + 6132 >> 2]; + $4 = HEAP32[$0 + 6128 >> 2]; + $1 = HEAP32[$0 + 6120 >> 2]; + HEAP32[$0 + 6116 >> 2] = HEAP32[$0 + 6124 >> 2]; + HEAP32[$0 + 6112 >> 2] = $1; + $2 = HEAP32[$0 + 6116 >> 2]; + $1 = HEAP32[$0 + 6112 >> 2]; + HEAP32[$0 + 1616 >> 2] = $1; + HEAP32[$0 + 1620 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Shape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2Shape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Shape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29($4, $0 + 1616 | 0); + HEAP32[$0 + 3808 >> 2] = 1; + HEAP32[$0 + 3804 >> 2] = 28; + $1 = HEAP32[$0 + 3808 >> 2]; + $2 = HEAP32[$0 + 3804 >> 2]; + HEAP32[$0 + 6136 >> 2] = $2; + HEAP32[$0 + 6140 >> 2] = $1; + $1 = HEAP32[$0 + 6136 >> 2]; + $2 = HEAP32[$0 + 6140 >> 2]; + HEAP32[$0 + 6164 >> 2] = $3; + HEAP32[$0 + 6160 >> 2] = 3436; + HEAP32[$0 + 6156 >> 2] = $2; + HEAP32[$0 + 6152 >> 2] = $1; + $3 = HEAP32[$0 + 6164 >> 2]; + $4 = HEAP32[$0 + 6160 >> 2]; + $1 = HEAP32[$0 + 6152 >> 2]; + HEAP32[$0 + 6148 >> 2] = HEAP32[$0 + 6156 >> 2]; + HEAP32[$0 + 6144 >> 2] = $1; + $2 = HEAP32[$0 + 6148 >> 2]; + $1 = HEAP32[$0 + 6144 >> 2]; + HEAP32[$0 + 1608 >> 2] = $1; + HEAP32[$0 + 1612 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Shape____29_28b2MassData__2c_20float_29_20const___invoke_b2Shape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Shape____29_28b2MassData__2c_20float_29_20const_29($4, $0 + 1608 | 0); + $1 = emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_2__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_2__28embind_init_b2_28_29__$_2_20const__29($0 + 3803 | 0); + HEAP32[$0 + 6176 >> 2] = $3; + HEAP32[$0 + 6172 >> 2] = 3252; + HEAP32[$0 + 6168 >> 2] = $1; + $1 = HEAP32[$0 + 6176 >> 2]; + void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2Shape__2c_20float_29___invoke_b2Shape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2Shape__2c_20float_29_29(HEAP32[$0 + 6172 >> 2], HEAP32[$0 + 6168 >> 2]); + $2 = emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_3__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_3__28embind_init_b2_28_29__$_3_20const__29($0 + 3801 | 0); + HEAP32[$0 + 6188 >> 2] = $1; + HEAP32[$0 + 6184 >> 2] = 3262; + HEAP32[$0 + 6180 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28__29_28b2Shape__29___invoke_b2Shape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20float_20_28__29_28b2Shape__29_29(HEAP32[$0 + 6184 >> 2], HEAP32[$0 + 6180 >> 2]); + HEAP32[$0 + 6212 >> 2] = $0 + 3799; + HEAP32[$0 + 6208 >> 2] = 9364; + void_20emscripten__base_b2Shape___verify_b2CircleShape__28_29(); + HEAP32[$0 + 6204 >> 2] = 112; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Shape__20_28_emscripten__base_b2Shape___getUpcaster_b2CircleShape__28_29_29_28b2CircleShape__29(), + HEAP32[wasm2js_i32$0 + 6200 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2CircleShape__20_28_emscripten__base_b2Shape___getDowncaster_b2CircleShape__28_29_29_28b2Shape__29(), + HEAP32[wasm2js_i32$0 + 6196 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 6192 >> 2] = 113; + $1 = emscripten__internal__TypeID_b2CircleShape_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2CircleShape__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2Shape___get_28_29(); + HEAP32[$0 + 15320 >> 2] = HEAP32[$0 + 6204 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 6204 >> 2]; + HEAP32[$0 + 15324 >> 2] = HEAP32[$0 + 6200 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 6200 >> 2]; + HEAP32[$0 + 15328 >> 2] = HEAP32[$0 + 6196 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 6196 >> 2]; + $11 = HEAP32[$0 + 6208 >> 2]; + HEAP32[$0 + 15332 >> 2] = HEAP32[$0 + 6192 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 6192 >> 2]); + HEAP32[$0 + 6216 >> 2] = $0 + 3799; + HEAP32[$0 + 15340 >> 2] = HEAP32[$0 + 6216 >> 2]; + HEAP32[$0 + 15336 >> 2] = 114; + $1 = HEAP32[$0 + 15340 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2CircleShape__20_28__29_28_29___invoke_b2CircleShape__28b2CircleShape__20_28__29_28_29_29(HEAP32[$0 + 15336 >> 2]); + HEAP32[$0 + 6236 >> 2] = $1; + HEAP32[$0 + 6232 >> 2] = 6263; + HEAP32[$0 + 6228 >> 2] = 12; + $3 = HEAP32[$0 + 6236 >> 2]; + HEAP32[$0 + 6224 >> 2] = 115; + HEAP32[$0 + 6220 >> 2] = 116; + $1 = emscripten__internal__TypeID_b2CircleShape_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 6232 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15344 >> 2] = HEAP32[$0 + 6224 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 6224 >> 2]; + $7 = b2Vec2_20b2CircleShape_____20emscripten__internal__getContext_b2Vec2_20b2CircleShape_____28b2Vec2_20b2CircleShape____20const__29($0 + 6228 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15348 >> 2] = HEAP32[$0 + 6220 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 6220 >> 2], b2Vec2_20b2CircleShape_____20emscripten__internal__getContext_b2Vec2_20b2CircleShape_____28b2Vec2_20b2CircleShape____20const__29($0 + 6228 | 0) | 0); + HEAP32[$0 + 3792 >> 2] = 1; + HEAP32[$0 + 3788 >> 2] = 8; + $1 = HEAP32[$0 + 3792 >> 2]; + $2 = HEAP32[$0 + 3788 >> 2]; + HEAP32[$0 + 6240 >> 2] = $2; + HEAP32[$0 + 6244 >> 2] = $1; + $1 = HEAP32[$0 + 6240 >> 2]; + $2 = HEAP32[$0 + 6244 >> 2]; + HEAP32[$0 + 6268 >> 2] = $3; + HEAP32[$0 + 6264 >> 2] = 9386; + HEAP32[$0 + 6260 >> 2] = $2; + HEAP32[$0 + 6256 >> 2] = $1; + $3 = HEAP32[$0 + 6268 >> 2]; + $4 = HEAP32[$0 + 6264 >> 2]; + $1 = HEAP32[$0 + 6256 >> 2]; + HEAP32[$0 + 6252 >> 2] = HEAP32[$0 + 6260 >> 2]; + HEAP32[$0 + 6248 >> 2] = $1; + $2 = HEAP32[$0 + 6252 >> 2]; + $1 = HEAP32[$0 + 6248 >> 2]; + HEAP32[$0 + 1600 >> 2] = $1; + HEAP32[$0 + 1604 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Shape__20_28b2CircleShape____29_28b2BlockAllocator__29_20const___invoke_b2CircleShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Shape__20_28b2CircleShape____29_28b2BlockAllocator__29_20const_29($4, $0 + 1600 | 0); + HEAP32[$0 + 3784 >> 2] = 1; + HEAP32[$0 + 3780 >> 2] = 12; + $1 = HEAP32[$0 + 3784 >> 2]; + $2 = HEAP32[$0 + 3780 >> 2]; + HEAP32[$0 + 6272 >> 2] = $2; + HEAP32[$0 + 6276 >> 2] = $1; + $1 = HEAP32[$0 + 6272 >> 2]; + $2 = HEAP32[$0 + 6276 >> 2]; + HEAP32[$0 + 6300 >> 2] = $3; + HEAP32[$0 + 6296 >> 2] = 2385; + HEAP32[$0 + 6292 >> 2] = $2; + HEAP32[$0 + 6288 >> 2] = $1; + $3 = HEAP32[$0 + 6300 >> 2]; + $4 = HEAP32[$0 + 6296 >> 2]; + $1 = HEAP32[$0 + 6288 >> 2]; + HEAP32[$0 + 6284 >> 2] = HEAP32[$0 + 6292 >> 2]; + HEAP32[$0 + 6280 >> 2] = $1; + $2 = HEAP32[$0 + 6284 >> 2]; + $1 = HEAP32[$0 + 6280 >> 2]; + HEAP32[$0 + 1592 >> 2] = $1; + HEAP32[$0 + 1596 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_int_20_28b2CircleShape____29_28_29_20const___invoke_b2CircleShape__28char_20const__2c_20int_20_28b2CircleShape____29_28_29_20const_29($4, $0 + 1592 | 0); + HEAP32[$0 + 3776 >> 2] = 1; + HEAP32[$0 + 3772 >> 2] = 16; + $1 = HEAP32[$0 + 3776 >> 2]; + $2 = HEAP32[$0 + 3772 >> 2]; + HEAP32[$0 + 6304 >> 2] = $2; + HEAP32[$0 + 6308 >> 2] = $1; + $1 = HEAP32[$0 + 6304 >> 2]; + $2 = HEAP32[$0 + 6308 >> 2]; + HEAP32[$0 + 6332 >> 2] = $3; + HEAP32[$0 + 6328 >> 2] = 2409; + HEAP32[$0 + 6324 >> 2] = $2; + HEAP32[$0 + 6320 >> 2] = $1; + $3 = HEAP32[$0 + 6332 >> 2]; + $4 = HEAP32[$0 + 6328 >> 2]; + $1 = HEAP32[$0 + 6320 >> 2]; + HEAP32[$0 + 6316 >> 2] = HEAP32[$0 + 6324 >> 2]; + HEAP32[$0 + 6312 >> 2] = $1; + $2 = HEAP32[$0 + 6316 >> 2]; + $1 = HEAP32[$0 + 6312 >> 2]; + HEAP32[$0 + 1584 >> 2] = $1; + HEAP32[$0 + 1588 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2CircleShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const___invoke_b2CircleShape__28char_20const__2c_20bool_20_28b2CircleShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29($4, $0 + 1584 | 0); + HEAP32[$0 + 3764 >> 2] = 1; + HEAP32[$0 + 3760 >> 2] = 20; + $1 = HEAP32[$0 + 3764 >> 2]; + $2 = HEAP32[$0 + 3760 >> 2]; + HEAP32[$0 + 6336 >> 2] = $2; + HEAP32[$0 + 6340 >> 2] = $1; + $1 = HEAP32[$0 + 6336 >> 2]; + $2 = HEAP32[$0 + 6340 >> 2]; + HEAP32[$0 + 6364 >> 2] = $3; + HEAP32[$0 + 6360 >> 2] = 1866; + HEAP32[$0 + 6356 >> 2] = $2; + HEAP32[$0 + 6352 >> 2] = $1; + $3 = HEAP32[$0 + 6364 >> 2]; + $4 = HEAP32[$0 + 6360 >> 2]; + $1 = HEAP32[$0 + 6352 >> 2]; + HEAP32[$0 + 6348 >> 2] = HEAP32[$0 + 6356 >> 2]; + HEAP32[$0 + 6344 >> 2] = $1; + $2 = HEAP32[$0 + 6348 >> 2]; + $1 = HEAP32[$0 + 6344 >> 2]; + HEAP32[$0 + 1576 >> 2] = $1; + HEAP32[$0 + 1580 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2CircleShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2CircleShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2CircleShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29($4, $0 + 1576 | 0); + HEAP32[$0 + 3752 >> 2] = 1; + HEAP32[$0 + 3748 >> 2] = 24; + $1 = HEAP32[$0 + 3752 >> 2]; + $2 = HEAP32[$0 + 3748 >> 2]; + HEAP32[$0 + 6368 >> 2] = $2; + HEAP32[$0 + 6372 >> 2] = $1; + $1 = HEAP32[$0 + 6368 >> 2]; + $2 = HEAP32[$0 + 6372 >> 2]; + HEAP32[$0 + 6396 >> 2] = $3; + HEAP32[$0 + 6392 >> 2] = 11092; + HEAP32[$0 + 6388 >> 2] = $2; + HEAP32[$0 + 6384 >> 2] = $1; + $3 = HEAP32[$0 + 6396 >> 2]; + $4 = HEAP32[$0 + 6392 >> 2]; + $1 = HEAP32[$0 + 6384 >> 2]; + HEAP32[$0 + 6380 >> 2] = HEAP32[$0 + 6388 >> 2]; + HEAP32[$0 + 6376 >> 2] = $1; + $2 = HEAP32[$0 + 6380 >> 2]; + $1 = HEAP32[$0 + 6376 >> 2]; + HEAP32[$0 + 1568 >> 2] = $1; + HEAP32[$0 + 1572 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2CircleShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2CircleShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2CircleShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29($4, $0 + 1568 | 0); + HEAP32[$0 + 3740 >> 2] = 1; + HEAP32[$0 + 3736 >> 2] = 28; + $1 = HEAP32[$0 + 3740 >> 2]; + $2 = HEAP32[$0 + 3736 >> 2]; + HEAP32[$0 + 6400 >> 2] = $2; + HEAP32[$0 + 6404 >> 2] = $1; + $1 = HEAP32[$0 + 6400 >> 2]; + $2 = HEAP32[$0 + 6404 >> 2]; + HEAP32[$0 + 6428 >> 2] = $3; + HEAP32[$0 + 6424 >> 2] = 3436; + HEAP32[$0 + 6420 >> 2] = $2; + HEAP32[$0 + 6416 >> 2] = $1; + $3 = HEAP32[$0 + 6424 >> 2]; + $1 = HEAP32[$0 + 6416 >> 2]; + HEAP32[$0 + 6412 >> 2] = HEAP32[$0 + 6420 >> 2]; + HEAP32[$0 + 6408 >> 2] = $1; + $2 = HEAP32[$0 + 6412 >> 2]; + $1 = HEAP32[$0 + 6408 >> 2]; + HEAP32[$0 + 1560 >> 2] = $1; + HEAP32[$0 + 1564 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2CircleShape____29_28b2MassData__2c_20float_29_20const___invoke_b2CircleShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2CircleShape____29_28b2MassData__2c_20float_29_20const_29($3, $0 + 1560 | 0); + HEAP32[$0 + 6452 >> 2] = $0 + 3735; + HEAP32[$0 + 6448 >> 2] = 9376; + void_20emscripten__base_b2Shape___verify_b2EdgeShape__28_29(); + HEAP32[$0 + 6444 >> 2] = 117; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Shape__20_28_emscripten__base_b2Shape___getUpcaster_b2EdgeShape__28_29_29_28b2EdgeShape__29(), + HEAP32[wasm2js_i32$0 + 6440 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2EdgeShape__20_28_emscripten__base_b2Shape___getDowncaster_b2EdgeShape__28_29_29_28b2Shape__29(), + HEAP32[wasm2js_i32$0 + 6436 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 6432 >> 2] = 118; + $1 = emscripten__internal__TypeID_b2EdgeShape_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2EdgeShape__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2Shape___get_28_29(); + HEAP32[$0 + 15352 >> 2] = HEAP32[$0 + 6444 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 6444 >> 2]; + HEAP32[$0 + 15356 >> 2] = HEAP32[$0 + 6440 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 6440 >> 2]; + HEAP32[$0 + 15360 >> 2] = HEAP32[$0 + 6436 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 6436 >> 2]; + $11 = HEAP32[$0 + 6448 >> 2]; + HEAP32[$0 + 15364 >> 2] = HEAP32[$0 + 6432 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 6432 >> 2]); + HEAP32[$0 + 3728 >> 2] = 1; + HEAP32[$0 + 3724 >> 2] = 8; + $1 = HEAP32[$0 + 3728 >> 2]; + $2 = HEAP32[$0 + 3724 >> 2]; + HEAP32[$0 + 6456 >> 2] = $2; + HEAP32[$0 + 6460 >> 2] = $1; + $1 = HEAP32[$0 + 6456 >> 2]; + $2 = HEAP32[$0 + 6460 >> 2]; + HEAP32[$0 + 6484 >> 2] = $0 + 3735; + HEAP32[$0 + 6480 >> 2] = 9386; + HEAP32[$0 + 6476 >> 2] = $2; + HEAP32[$0 + 6472 >> 2] = $1; + $3 = HEAP32[$0 + 6484 >> 2]; + $4 = HEAP32[$0 + 6480 >> 2]; + $1 = HEAP32[$0 + 6472 >> 2]; + HEAP32[$0 + 6468 >> 2] = HEAP32[$0 + 6476 >> 2]; + HEAP32[$0 + 6464 >> 2] = $1; + $2 = HEAP32[$0 + 6468 >> 2]; + $1 = HEAP32[$0 + 6464 >> 2]; + HEAP32[$0 + 1552 >> 2] = $1; + HEAP32[$0 + 1556 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Shape__20_28b2EdgeShape____29_28b2BlockAllocator__29_20const___invoke_b2EdgeShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Shape__20_28b2EdgeShape____29_28b2BlockAllocator__29_20const_29($4, $0 + 1552 | 0); + HEAP32[$0 + 3720 >> 2] = 1; + HEAP32[$0 + 3716 >> 2] = 12; + $1 = HEAP32[$0 + 3720 >> 2]; + $2 = HEAP32[$0 + 3716 >> 2]; + HEAP32[$0 + 6488 >> 2] = $2; + HEAP32[$0 + 6492 >> 2] = $1; + $1 = HEAP32[$0 + 6488 >> 2]; + $2 = HEAP32[$0 + 6492 >> 2]; + HEAP32[$0 + 6516 >> 2] = $3; + HEAP32[$0 + 6512 >> 2] = 2385; + HEAP32[$0 + 6508 >> 2] = $2; + HEAP32[$0 + 6504 >> 2] = $1; + $3 = HEAP32[$0 + 6516 >> 2]; + $4 = HEAP32[$0 + 6512 >> 2]; + $1 = HEAP32[$0 + 6504 >> 2]; + HEAP32[$0 + 6500 >> 2] = HEAP32[$0 + 6508 >> 2]; + HEAP32[$0 + 6496 >> 2] = $1; + $2 = HEAP32[$0 + 6500 >> 2]; + $1 = HEAP32[$0 + 6496 >> 2]; + HEAP32[$0 + 1544 >> 2] = $1; + HEAP32[$0 + 1548 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_int_20_28b2EdgeShape____29_28_29_20const___invoke_b2EdgeShape__28char_20const__2c_20int_20_28b2EdgeShape____29_28_29_20const_29($4, $0 + 1544 | 0); + HEAP32[$0 + 3712 >> 2] = 1; + HEAP32[$0 + 3708 >> 2] = 16; + $1 = HEAP32[$0 + 3712 >> 2]; + $2 = HEAP32[$0 + 3708 >> 2]; + HEAP32[$0 + 6520 >> 2] = $2; + HEAP32[$0 + 6524 >> 2] = $1; + $1 = HEAP32[$0 + 6520 >> 2]; + $2 = HEAP32[$0 + 6524 >> 2]; + HEAP32[$0 + 6548 >> 2] = $3; + HEAP32[$0 + 6544 >> 2] = 2409; + HEAP32[$0 + 6540 >> 2] = $2; + HEAP32[$0 + 6536 >> 2] = $1; + $3 = HEAP32[$0 + 6548 >> 2]; + $4 = HEAP32[$0 + 6544 >> 2]; + $1 = HEAP32[$0 + 6536 >> 2]; + HEAP32[$0 + 6532 >> 2] = HEAP32[$0 + 6540 >> 2]; + HEAP32[$0 + 6528 >> 2] = $1; + $2 = HEAP32[$0 + 6532 >> 2]; + $1 = HEAP32[$0 + 6528 >> 2]; + HEAP32[$0 + 1536 >> 2] = $1; + HEAP32[$0 + 1540 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2EdgeShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const___invoke_b2EdgeShape__28char_20const__2c_20bool_20_28b2EdgeShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29($4, $0 + 1536 | 0); + HEAP32[$0 + 3700 >> 2] = 1; + HEAP32[$0 + 3696 >> 2] = 20; + $1 = HEAP32[$0 + 3700 >> 2]; + $2 = HEAP32[$0 + 3696 >> 2]; + HEAP32[$0 + 6552 >> 2] = $2; + HEAP32[$0 + 6556 >> 2] = $1; + $1 = HEAP32[$0 + 6552 >> 2]; + $2 = HEAP32[$0 + 6556 >> 2]; + HEAP32[$0 + 6580 >> 2] = $3; + HEAP32[$0 + 6576 >> 2] = 1866; + HEAP32[$0 + 6572 >> 2] = $2; + HEAP32[$0 + 6568 >> 2] = $1; + $3 = HEAP32[$0 + 6580 >> 2]; + $4 = HEAP32[$0 + 6576 >> 2]; + $1 = HEAP32[$0 + 6568 >> 2]; + HEAP32[$0 + 6564 >> 2] = HEAP32[$0 + 6572 >> 2]; + HEAP32[$0 + 6560 >> 2] = $1; + $2 = HEAP32[$0 + 6564 >> 2]; + $1 = HEAP32[$0 + 6560 >> 2]; + HEAP32[$0 + 1528 >> 2] = $1; + HEAP32[$0 + 1532 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2EdgeShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2EdgeShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2EdgeShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29($4, $0 + 1528 | 0); + HEAP32[$0 + 3688 >> 2] = 1; + HEAP32[$0 + 3684 >> 2] = 24; + $1 = HEAP32[$0 + 3688 >> 2]; + $2 = HEAP32[$0 + 3684 >> 2]; + HEAP32[$0 + 6584 >> 2] = $2; + HEAP32[$0 + 6588 >> 2] = $1; + $1 = HEAP32[$0 + 6584 >> 2]; + $2 = HEAP32[$0 + 6588 >> 2]; + HEAP32[$0 + 6612 >> 2] = $3; + HEAP32[$0 + 6608 >> 2] = 11092; + HEAP32[$0 + 6604 >> 2] = $2; + HEAP32[$0 + 6600 >> 2] = $1; + $3 = HEAP32[$0 + 6612 >> 2]; + $4 = HEAP32[$0 + 6608 >> 2]; + $1 = HEAP32[$0 + 6600 >> 2]; + HEAP32[$0 + 6596 >> 2] = HEAP32[$0 + 6604 >> 2]; + HEAP32[$0 + 6592 >> 2] = $1; + $2 = HEAP32[$0 + 6596 >> 2]; + $1 = HEAP32[$0 + 6592 >> 2]; + HEAP32[$0 + 1520 >> 2] = $1; + HEAP32[$0 + 1524 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2EdgeShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2EdgeShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2EdgeShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29($4, $0 + 1520 | 0); + HEAP32[$0 + 3676 >> 2] = 1; + HEAP32[$0 + 3672 >> 2] = 28; + $1 = HEAP32[$0 + 3676 >> 2]; + $2 = HEAP32[$0 + 3672 >> 2]; + HEAP32[$0 + 6616 >> 2] = $2; + HEAP32[$0 + 6620 >> 2] = $1; + $1 = HEAP32[$0 + 6616 >> 2]; + $2 = HEAP32[$0 + 6620 >> 2]; + HEAP32[$0 + 6648 >> 2] = $3; + HEAP32[$0 + 6644 >> 2] = 3436; + HEAP32[$0 + 6640 >> 2] = $2; + HEAP32[$0 + 6636 >> 2] = $1; + $3 = HEAP32[$0 + 6644 >> 2]; + $1 = HEAP32[$0 + 6636 >> 2]; + HEAP32[$0 + 6632 >> 2] = HEAP32[$0 + 6640 >> 2]; + HEAP32[$0 + 6628 >> 2] = $1; + $2 = HEAP32[$0 + 6632 >> 2]; + $1 = HEAP32[$0 + 6628 >> 2]; + HEAP32[$0 + 1512 >> 2] = $1; + HEAP32[$0 + 1516 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2EdgeShape____29_28b2MassData__2c_20float_29_20const___invoke_b2EdgeShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2EdgeShape____29_28b2MassData__2c_20float_29_20const_29($3, $0 + 1512 | 0); + HEAP32[$0 + 6672 >> 2] = $0 + 3671; + HEAP32[$0 + 6668 >> 2] = 9328; + void_20emscripten__base_b2Shape___verify_b2PolygonShape__28_29(); + HEAP32[$0 + 6664 >> 2] = 119; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Shape__20_28_emscripten__base_b2Shape___getUpcaster_b2PolygonShape__28_29_29_28b2PolygonShape__29(), + HEAP32[wasm2js_i32$0 + 6660 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2PolygonShape__20_28_emscripten__base_b2Shape___getDowncaster_b2PolygonShape__28_29_29_28b2Shape__29(), + HEAP32[wasm2js_i32$0 + 6656 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 6652 >> 2] = 120; + $1 = emscripten__internal__TypeID_b2PolygonShape_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2Shape___get_28_29(); + HEAP32[$0 + 15368 >> 2] = HEAP32[$0 + 6664 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 6664 >> 2]; + HEAP32[$0 + 15372 >> 2] = HEAP32[$0 + 6660 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 6660 >> 2]; + HEAP32[$0 + 15376 >> 2] = HEAP32[$0 + 6656 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 6656 >> 2]; + $11 = HEAP32[$0 + 6668 >> 2]; + HEAP32[$0 + 15380 >> 2] = HEAP32[$0 + 6652 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 6652 >> 2]); + HEAP32[$0 + 6676 >> 2] = $0 + 3671; + HEAP32[$0 + 15388 >> 2] = HEAP32[$0 + 6676 >> 2]; + HEAP32[$0 + 15384 >> 2] = 121; + $3 = HEAP32[$0 + 15388 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2PolygonShape__20_28__29_28_29___invoke_b2PolygonShape__28b2PolygonShape__20_28__29_28_29_29(HEAP32[$0 + 15384 >> 2]); + HEAP32[$0 + 3664 >> 2] = 1; + HEAP32[$0 + 3660 >> 2] = 8; + $1 = HEAP32[$0 + 3664 >> 2]; + $2 = HEAP32[$0 + 3660 >> 2]; + HEAP32[$0 + 6680 >> 2] = $2; + HEAP32[$0 + 6684 >> 2] = $1; + $1 = HEAP32[$0 + 6680 >> 2]; + $2 = HEAP32[$0 + 6684 >> 2]; + HEAP32[$0 + 6708 >> 2] = $3; + HEAP32[$0 + 6704 >> 2] = 9386; + HEAP32[$0 + 6700 >> 2] = $2; + HEAP32[$0 + 6696 >> 2] = $1; + $3 = HEAP32[$0 + 6708 >> 2]; + $4 = HEAP32[$0 + 6704 >> 2]; + $1 = HEAP32[$0 + 6696 >> 2]; + HEAP32[$0 + 6692 >> 2] = HEAP32[$0 + 6700 >> 2]; + HEAP32[$0 + 6688 >> 2] = $1; + $2 = HEAP32[$0 + 6692 >> 2]; + $1 = HEAP32[$0 + 6688 >> 2]; + HEAP32[$0 + 1504 >> 2] = $1; + HEAP32[$0 + 1508 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Shape__20_28b2PolygonShape____29_28b2BlockAllocator__29_20const___invoke_b2PolygonShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Shape__20_28b2PolygonShape____29_28b2BlockAllocator__29_20const_29($4, $0 + 1504 | 0); + HEAP32[$0 + 3656 >> 2] = 1; + HEAP32[$0 + 3652 >> 2] = 12; + $1 = HEAP32[$0 + 3656 >> 2]; + $2 = HEAP32[$0 + 3652 >> 2]; + HEAP32[$0 + 6712 >> 2] = $2; + HEAP32[$0 + 6716 >> 2] = $1; + $1 = HEAP32[$0 + 6712 >> 2]; + $2 = HEAP32[$0 + 6716 >> 2]; + HEAP32[$0 + 6744 >> 2] = $3; + HEAP32[$0 + 6740 >> 2] = 2385; + HEAP32[$0 + 6736 >> 2] = $2; + HEAP32[$0 + 6732 >> 2] = $1; + $3 = HEAP32[$0 + 6744 >> 2]; + $4 = HEAP32[$0 + 6740 >> 2]; + $1 = HEAP32[$0 + 6732 >> 2]; + HEAP32[$0 + 6728 >> 2] = HEAP32[$0 + 6736 >> 2]; + HEAP32[$0 + 6724 >> 2] = $1; + $2 = HEAP32[$0 + 6728 >> 2]; + $1 = HEAP32[$0 + 6724 >> 2]; + HEAP32[$0 + 1496 >> 2] = $1; + HEAP32[$0 + 1500 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_int_20_28b2PolygonShape____29_28_29_20const___invoke_b2PolygonShape__28char_20const__2c_20int_20_28b2PolygonShape____29_28_29_20const_29($4, $0 + 1496 | 0); + $1 = emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_4__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_4__28embind_init_b2_28_29__$_4_20const__29($0 + 3651 | 0); + HEAP32[$0 + 6756 >> 2] = $3; + HEAP32[$0 + 6752 >> 2] = 3019; + HEAP32[$0 + 6748 >> 2] = $1; + $3 = HEAP32[$0 + 6756 >> 2]; + void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29___invoke_b2PolygonShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29_29(HEAP32[$0 + 6752 >> 2], HEAP32[$0 + 6748 >> 2]); + HEAP32[$0 + 3644 >> 2] = 1; + HEAP32[$0 + 3640 >> 2] = 16; + $1 = HEAP32[$0 + 3644 >> 2]; + $2 = HEAP32[$0 + 3640 >> 2]; + HEAP32[$0 + 6760 >> 2] = $2; + HEAP32[$0 + 6764 >> 2] = $1; + $1 = HEAP32[$0 + 6760 >> 2]; + $2 = HEAP32[$0 + 6764 >> 2]; + HEAP32[$0 + 6788 >> 2] = $3; + HEAP32[$0 + 6784 >> 2] = 2409; + HEAP32[$0 + 6780 >> 2] = $2; + HEAP32[$0 + 6776 >> 2] = $1; + $3 = HEAP32[$0 + 6788 >> 2]; + $4 = HEAP32[$0 + 6784 >> 2]; + $1 = HEAP32[$0 + 6776 >> 2]; + HEAP32[$0 + 6772 >> 2] = HEAP32[$0 + 6780 >> 2]; + HEAP32[$0 + 6768 >> 2] = $1; + $2 = HEAP32[$0 + 6772 >> 2]; + $1 = HEAP32[$0 + 6768 >> 2]; + HEAP32[$0 + 1488 >> 2] = $1; + HEAP32[$0 + 1492 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2PolygonShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const___invoke_b2PolygonShape__28char_20const__2c_20bool_20_28b2PolygonShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29($4, $0 + 1488 | 0); + HEAP32[$0 + 3632 >> 2] = 1; + HEAP32[$0 + 3628 >> 2] = 20; + $1 = HEAP32[$0 + 3632 >> 2]; + $2 = HEAP32[$0 + 3628 >> 2]; + HEAP32[$0 + 6792 >> 2] = $2; + HEAP32[$0 + 6796 >> 2] = $1; + $1 = HEAP32[$0 + 6792 >> 2]; + $2 = HEAP32[$0 + 6796 >> 2]; + HEAP32[$0 + 6820 >> 2] = $3; + HEAP32[$0 + 6816 >> 2] = 1866; + HEAP32[$0 + 6812 >> 2] = $2; + HEAP32[$0 + 6808 >> 2] = $1; + $3 = HEAP32[$0 + 6820 >> 2]; + $4 = HEAP32[$0 + 6816 >> 2]; + $1 = HEAP32[$0 + 6808 >> 2]; + HEAP32[$0 + 6804 >> 2] = HEAP32[$0 + 6812 >> 2]; + HEAP32[$0 + 6800 >> 2] = $1; + $2 = HEAP32[$0 + 6804 >> 2]; + $1 = HEAP32[$0 + 6800 >> 2]; + HEAP32[$0 + 1480 >> 2] = $1; + HEAP32[$0 + 1484 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2PolygonShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2PolygonShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2PolygonShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29($4, $0 + 1480 | 0); + HEAP32[$0 + 3620 >> 2] = 1; + HEAP32[$0 + 3616 >> 2] = 24; + $1 = HEAP32[$0 + 3620 >> 2]; + $2 = HEAP32[$0 + 3616 >> 2]; + HEAP32[$0 + 6824 >> 2] = $2; + HEAP32[$0 + 6828 >> 2] = $1; + $1 = HEAP32[$0 + 6824 >> 2]; + $2 = HEAP32[$0 + 6828 >> 2]; + HEAP32[$0 + 6852 >> 2] = $3; + HEAP32[$0 + 6848 >> 2] = 11092; + HEAP32[$0 + 6844 >> 2] = $2; + HEAP32[$0 + 6840 >> 2] = $1; + $3 = HEAP32[$0 + 6852 >> 2]; + $4 = HEAP32[$0 + 6848 >> 2]; + $1 = HEAP32[$0 + 6840 >> 2]; + HEAP32[$0 + 6836 >> 2] = HEAP32[$0 + 6844 >> 2]; + HEAP32[$0 + 6832 >> 2] = $1; + $2 = HEAP32[$0 + 6836 >> 2]; + $1 = HEAP32[$0 + 6832 >> 2]; + HEAP32[$0 + 1472 >> 2] = $1; + HEAP32[$0 + 1476 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2PolygonShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2PolygonShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2PolygonShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29($4, $0 + 1472 | 0); + HEAP32[$0 + 3608 >> 2] = 1; + HEAP32[$0 + 3604 >> 2] = 28; + $1 = HEAP32[$0 + 3608 >> 2]; + $2 = HEAP32[$0 + 3604 >> 2]; + HEAP32[$0 + 6856 >> 2] = $2; + HEAP32[$0 + 6860 >> 2] = $1; + $1 = HEAP32[$0 + 6856 >> 2]; + $2 = HEAP32[$0 + 6860 >> 2]; + HEAP32[$0 + 6884 >> 2] = $3; + HEAP32[$0 + 6880 >> 2] = 3436; + HEAP32[$0 + 6876 >> 2] = $2; + HEAP32[$0 + 6872 >> 2] = $1; + $3 = HEAP32[$0 + 6884 >> 2]; + $4 = HEAP32[$0 + 6880 >> 2]; + $1 = HEAP32[$0 + 6872 >> 2]; + HEAP32[$0 + 6868 >> 2] = HEAP32[$0 + 6876 >> 2]; + HEAP32[$0 + 6864 >> 2] = $1; + $2 = HEAP32[$0 + 6868 >> 2]; + $1 = HEAP32[$0 + 6864 >> 2]; + HEAP32[$0 + 1464 >> 2] = $1; + HEAP32[$0 + 1468 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2PolygonShape____29_28b2MassData__2c_20float_29_20const___invoke_b2PolygonShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2PolygonShape____29_28b2MassData__2c_20float_29_20const_29($4, $0 + 1464 | 0); + HEAP32[$0 + 3600 >> 2] = 0; + HEAP32[$0 + 3596 >> 2] = 122; + $1 = HEAP32[$0 + 3600 >> 2]; + $2 = HEAP32[$0 + 3596 >> 2]; + HEAP32[$0 + 6888 >> 2] = $2; + HEAP32[$0 + 6892 >> 2] = $1; + $1 = HEAP32[$0 + 6888 >> 2]; + $2 = HEAP32[$0 + 6892 >> 2]; + HEAP32[$0 + 6916 >> 2] = $3; + HEAP32[$0 + 6912 >> 2] = 8943; + HEAP32[$0 + 6908 >> 2] = $2; + HEAP32[$0 + 6904 >> 2] = $1; + $3 = HEAP32[$0 + 6916 >> 2]; + $4 = HEAP32[$0 + 6912 >> 2]; + $1 = HEAP32[$0 + 6904 >> 2]; + HEAP32[$0 + 6900 >> 2] = HEAP32[$0 + 6908 >> 2]; + HEAP32[$0 + 6896 >> 2] = $1; + $2 = HEAP32[$0 + 6900 >> 2]; + $1 = HEAP32[$0 + 6896 >> 2]; + HEAP32[$0 + 1456 >> 2] = $1; + HEAP32[$0 + 1460 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2PolygonShape____29_28_29_20const___invoke_b2PolygonShape__28char_20const__2c_20bool_20_28b2PolygonShape____29_28_29_20const_29($4, $0 + 1456 | 0); + HEAP32[$0 + 3584 >> 2] = 0; + HEAP32[$0 + 3580 >> 2] = 123; + $1 = HEAP32[$0 + 3584 >> 2]; + $2 = HEAP32[$0 + 3580 >> 2]; + HEAP32[$0 + 1448 >> 2] = $2; + HEAP32[$0 + 1452 >> 2] = $1; + decltype_28fp_29_20emscripten__select_overload_void_20_28float_2c_20float_29_2c_20b2PolygonShape__28void_20_28b2PolygonShape____29_28float_2c_20float_29_29($0 + 3588 | 0, $0 + 1448 | 0); + $1 = HEAP32[$0 + 3588 >> 2]; + HEAP32[$0 + 3576 >> 2] = HEAP32[$0 + 3592 >> 2]; + HEAP32[$0 + 3572 >> 2] = $1; + $2 = HEAP32[$0 + 3576 >> 2]; + $1 = HEAP32[$0 + 3572 >> 2]; + HEAP32[$0 + 6920 >> 2] = $1; + HEAP32[$0 + 6924 >> 2] = $2; + $1 = HEAP32[$0 + 6920 >> 2]; + $2 = HEAP32[$0 + 6924 >> 2]; + HEAP32[$0 + 6948 >> 2] = $3; + HEAP32[$0 + 6944 >> 2] = 1735; + HEAP32[$0 + 6940 >> 2] = $2; + HEAP32[$0 + 6936 >> 2] = $1; + $3 = HEAP32[$0 + 6948 >> 2]; + $4 = HEAP32[$0 + 6944 >> 2]; + $1 = HEAP32[$0 + 6936 >> 2]; + HEAP32[$0 + 6932 >> 2] = HEAP32[$0 + 6940 >> 2]; + HEAP32[$0 + 6928 >> 2] = $1; + $1 = HEAP32[$0 + 6932 >> 2]; + $2 = HEAP32[$0 + 6928 >> 2]; + HEAP32[$0 + 1440 >> 2] = $2; + HEAP32[$0 + 1444 >> 2] = $1; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2PolygonShape____29_28float_2c_20float_29___invoke_b2PolygonShape__28char_20const__2c_20void_20_28b2PolygonShape____29_28float_2c_20float_29_29($4, $0 + 1440 | 0); + HEAP32[$0 + 3560 >> 2] = 0; + HEAP32[$0 + 3556 >> 2] = 124; + $2 = HEAP32[$0 + 3560 >> 2]; + $1 = HEAP32[$0 + 3556 >> 2]; + HEAP32[$0 + 1432 >> 2] = $1; + HEAP32[$0 + 1436 >> 2] = $2; + decltype_28fp_29_20emscripten__select_overload_void_20_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29_2c_20b2PolygonShape__28void_20_28b2PolygonShape____29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29_29($0 + 3564 | 0, $0 + 1432 | 0); + $1 = HEAP32[$0 + 3564 >> 2]; + HEAP32[$0 + 3552 >> 2] = HEAP32[$0 + 3568 >> 2]; + HEAP32[$0 + 3548 >> 2] = $1; + $1 = HEAP32[$0 + 3552 >> 2]; + $2 = HEAP32[$0 + 3548 >> 2]; + HEAP32[$0 + 6952 >> 2] = $2; + HEAP32[$0 + 6956 >> 2] = $1; + $1 = HEAP32[$0 + 6952 >> 2]; + $2 = HEAP32[$0 + 6956 >> 2]; + HEAP32[$0 + 6980 >> 2] = $3; + HEAP32[$0 + 6976 >> 2] = 9504; + HEAP32[$0 + 6972 >> 2] = $2; + HEAP32[$0 + 6968 >> 2] = $1; + $3 = HEAP32[$0 + 6976 >> 2]; + $1 = HEAP32[$0 + 6968 >> 2]; + HEAP32[$0 + 6964 >> 2] = HEAP32[$0 + 6972 >> 2]; + HEAP32[$0 + 6960 >> 2] = $1; + $2 = HEAP32[$0 + 6964 >> 2]; + $1 = HEAP32[$0 + 6960 >> 2]; + HEAP32[$0 + 1424 >> 2] = $1; + HEAP32[$0 + 1428 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2PolygonShape____29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29___invoke_b2PolygonShape__28char_20const__2c_20void_20_28b2PolygonShape____29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29_29($3, $0 + 1424 | 0); + HEAP32[$0 + 7004 >> 2] = $0 + 3547; + HEAP32[$0 + 7e3 >> 2] = 8007; + void_20emscripten__internal__NoBaseClass__verify_b2FixtureDef__28_29(); + HEAP32[$0 + 6996 >> 2] = 125; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2FixtureDef__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 6992 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2FixtureDef__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 6988 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 6984 >> 2] = 126; + $1 = emscripten__internal__TypeID_b2FixtureDef_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2FixtureDef__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2FixtureDef_20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$0 + 15392 >> 2] = HEAP32[$0 + 6996 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 6996 >> 2]; + HEAP32[$0 + 14756 >> 2] = HEAP32[$0 + 6992 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$0 + 6992 >> 2]; + HEAP32[$0 + 14752 >> 2] = HEAP32[$0 + 6988 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$0 + 6988 >> 2]; + $11 = HEAP32[$0 + 7e3 >> 2]; + HEAP32[$0 + 15396 >> 2] = HEAP32[$0 + 6984 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 6984 >> 2]); + HEAP32[$0 + 7008 >> 2] = $0 + 3547; + HEAP32[$0 + 15404 >> 2] = HEAP32[$0 + 7008 >> 2]; + HEAP32[$0 + 15400 >> 2] = 127; + $1 = HEAP32[$0 + 15404 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2FixtureDef__20_28__29_28_29___invoke_b2FixtureDef__28b2FixtureDef__20_28__29_28_29_29(HEAP32[$0 + 15400 >> 2]); + $2 = emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_5__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_5__28embind_init_b2_28_29__$_5_20const__29($0 + 3546 | 0); + HEAP32[$0 + 7020 >> 2] = $1; + HEAP32[$0 + 7016 >> 2] = 9310; + HEAP32[$0 + 7012 >> 2] = $2; + $1 = HEAP32[$0 + 7020 >> 2]; + void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2FixtureDef__2c_20b2Shape_20const__29___invoke_b2FixtureDef_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2FixtureDef__2c_20b2Shape_20const__29_29(HEAP32[$0 + 7016 >> 2], HEAP32[$0 + 7012 >> 2]); + $2 = emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_6__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_6__28embind_init_b2_28_29__$_6_20const__29($0 + 3544 | 0); + HEAP32[$0 + 7032 >> 2] = $1; + HEAP32[$0 + 7028 >> 2] = 9319; + HEAP32[$0 + 7024 >> 2] = $2; + $1 = HEAP32[$0 + 7032 >> 2]; + void_20emscripten__internal__RegisterClassMethod_b2Shape_20const__20_28__29_28b2FixtureDef__29___invoke_b2FixtureDef_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Shape_20const__20_28__29_28b2FixtureDef__29_29(HEAP32[$0 + 7028 >> 2], HEAP32[$0 + 7024 >> 2]); + HEAP32[$0 + 7092 >> 2] = $1; + HEAP32[$0 + 7088 >> 2] = 6478; + HEAP32[$0 + 7084 >> 2] = 8; + $1 = HEAP32[$0 + 7092 >> 2]; + HEAP32[$0 + 7080 >> 2] = 128; + HEAP32[$0 + 7076 >> 2] = 129; + $2 = emscripten__internal__TypeID_b2FixtureDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 7088 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15408 >> 2] = HEAP32[$0 + 7080 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7080 >> 2]; + $7 = float_20b2FixtureDef_____20emscripten__internal__getContext_float_20b2FixtureDef_____28float_20b2FixtureDef____20const__29($0 + 7084 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15420 >> 2] = HEAP32[$0 + 7076 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 7076 >> 2], float_20b2FixtureDef_____20emscripten__internal__getContext_float_20b2FixtureDef_____28float_20b2FixtureDef____20const__29($0 + 7084 | 0) | 0); + HEAP32[$0 + 7072 >> 2] = $1; + HEAP32[$0 + 7068 >> 2] = 6357; + HEAP32[$0 + 7064 >> 2] = 12; + $1 = HEAP32[$0 + 7072 >> 2]; + HEAP32[$0 + 7060 >> 2] = 128; + HEAP32[$0 + 7056 >> 2] = 129; + $2 = emscripten__internal__TypeID_b2FixtureDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 7068 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15412 >> 2] = HEAP32[$0 + 7060 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7060 >> 2]; + $7 = float_20b2FixtureDef_____20emscripten__internal__getContext_float_20b2FixtureDef_____28float_20b2FixtureDef____20const__29($0 + 7064 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15424 >> 2] = HEAP32[$0 + 7056 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 7056 >> 2], float_20b2FixtureDef_____20emscripten__internal__getContext_float_20b2FixtureDef_____28float_20b2FixtureDef____20const__29($0 + 7064 | 0) | 0); + HEAP32[$0 + 7052 >> 2] = $1; + HEAP32[$0 + 7048 >> 2] = 1081; + HEAP32[$0 + 7044 >> 2] = 16; + $1 = HEAP32[$0 + 7052 >> 2]; + HEAP32[$0 + 7040 >> 2] = 128; + HEAP32[$0 + 7036 >> 2] = 129; + $2 = emscripten__internal__TypeID_b2FixtureDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 7048 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15416 >> 2] = HEAP32[$0 + 7040 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7040 >> 2]; + $7 = float_20b2FixtureDef_____20emscripten__internal__getContext_float_20b2FixtureDef_____28float_20b2FixtureDef____20const__29($0 + 7044 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15428 >> 2] = HEAP32[$0 + 7036 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 7036 >> 2], float_20b2FixtureDef_____20emscripten__internal__getContext_float_20b2FixtureDef_____28float_20b2FixtureDef____20const__29($0 + 7044 | 0) | 0); + HEAP32[$0 + 7112 >> 2] = $1; + HEAP32[$0 + 7108 >> 2] = 3809; + HEAP32[$0 + 7104 >> 2] = 20; + $1 = HEAP32[$0 + 7112 >> 2]; + HEAP32[$0 + 7100 >> 2] = 130; + HEAP32[$0 + 7096 >> 2] = 131; + $2 = emscripten__internal__TypeID_b2FixtureDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 7108 >> 2]; + $4 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15432 >> 2] = HEAP32[$0 + 7100 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7100 >> 2]; + $7 = bool_20b2FixtureDef_____20emscripten__internal__getContext_bool_20b2FixtureDef_____28bool_20b2FixtureDef____20const__29($0 + 7104 | 0); + $8 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15436 >> 2] = HEAP32[$0 + 7096 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 7096 >> 2], bool_20b2FixtureDef_____20emscripten__internal__getContext_bool_20b2FixtureDef_____28bool_20b2FixtureDef____20const__29($0 + 7104 | 0) | 0); + HEAP32[$0 + 7132 >> 2] = $1; + HEAP32[$0 + 7128 >> 2] = 3944; + HEAP32[$0 + 7124 >> 2] = 22; + HEAP32[$0 + 7120 >> 2] = 132; + HEAP32[$0 + 7116 >> 2] = 133; + $1 = emscripten__internal__TypeID_b2FixtureDef_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 7128 >> 2]; + $3 = emscripten__internal__TypeID_b2Filter_2c_20void___get_28_29(); + HEAP32[$0 + 15440 >> 2] = HEAP32[$0 + 7120 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $5 = HEAP32[$0 + 7120 >> 2]; + $6 = b2Filter_20b2FixtureDef_____20emscripten__internal__getContext_b2Filter_20b2FixtureDef_____28b2Filter_20b2FixtureDef____20const__29($0 + 7124 | 0); + $7 = emscripten__internal__TypeID_b2Filter_2c_20void___get_28_29(); + HEAP32[$0 + 15444 >> 2] = HEAP32[$0 + 7116 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 7116 >> 2], b2Filter_20b2FixtureDef_____20emscripten__internal__getContext_b2Filter_20b2FixtureDef_____28b2Filter_20b2FixtureDef____20const__29($0 + 7124 | 0) | 0); + HEAP32[$0 + 7156 >> 2] = $0 + 3542; + HEAP32[$0 + 7152 >> 2] = 9213; + void_20emscripten__internal__NoBaseClass__verify_b2Fixture__28_29(); + HEAP32[$0 + 7148 >> 2] = 134; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2Fixture__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 7144 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2Fixture__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 7140 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 7136 >> 2] = 135; + $1 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Fixture__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$0 + 15448 >> 2] = HEAP32[$0 + 7148 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7148 >> 2]; + HEAP32[$0 + 14748 >> 2] = HEAP32[$0 + 7144 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$0 + 7144 >> 2]; + HEAP32[$0 + 14744 >> 2] = HEAP32[$0 + 7140 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$0 + 7140 >> 2]; + $11 = HEAP32[$0 + 7152 >> 2]; + HEAP32[$0 + 15452 >> 2] = HEAP32[$0 + 7136 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 7136 >> 2]); + HEAP32[$0 + 3536 >> 2] = 0; + HEAP32[$0 + 3532 >> 2] = 136; + $1 = HEAP32[$0 + 3536 >> 2]; + $2 = HEAP32[$0 + 3532 >> 2]; + HEAP32[$0 + 7160 >> 2] = $2; + HEAP32[$0 + 7164 >> 2] = $1; + $1 = HEAP32[$0 + 7160 >> 2]; + $2 = HEAP32[$0 + 7164 >> 2]; + HEAP32[$0 + 7188 >> 2] = $0 + 3542; + HEAP32[$0 + 7184 >> 2] = 9253; + HEAP32[$0 + 7180 >> 2] = $2; + HEAP32[$0 + 7176 >> 2] = $1; + $3 = HEAP32[$0 + 7188 >> 2]; + $4 = HEAP32[$0 + 7184 >> 2]; + $1 = HEAP32[$0 + 7176 >> 2]; + HEAP32[$0 + 7172 >> 2] = HEAP32[$0 + 7180 >> 2]; + HEAP32[$0 + 7168 >> 2] = $1; + $2 = HEAP32[$0 + 7172 >> 2]; + $1 = HEAP32[$0 + 7168 >> 2]; + HEAP32[$0 + 1416 >> 2] = $1; + HEAP32[$0 + 1420 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Shape__Type_20_28b2Fixture____29_28_29_20const___invoke_b2Fixture__28char_20const__2c_20b2Shape__Type_20_28b2Fixture____29_28_29_20const_29($4, $0 + 1416 | 0); + HEAP32[$0 + 3524 >> 2] = 0; + HEAP32[$0 + 3520 >> 2] = 137; + $1 = HEAP32[$0 + 3524 >> 2]; + $2 = HEAP32[$0 + 3520 >> 2]; + HEAP32[$0 + 7192 >> 2] = $2; + HEAP32[$0 + 7196 >> 2] = $1; + $1 = HEAP32[$0 + 7192 >> 2]; + $2 = HEAP32[$0 + 7196 >> 2]; + HEAP32[$0 + 7220 >> 2] = $3; + HEAP32[$0 + 7216 >> 2] = 9319; + HEAP32[$0 + 7212 >> 2] = $2; + HEAP32[$0 + 7208 >> 2] = $1; + $3 = HEAP32[$0 + 7220 >> 2]; + $4 = HEAP32[$0 + 7216 >> 2]; + $1 = HEAP32[$0 + 7208 >> 2]; + HEAP32[$0 + 7204 >> 2] = HEAP32[$0 + 7212 >> 2]; + HEAP32[$0 + 7200 >> 2] = $1; + $2 = HEAP32[$0 + 7204 >> 2]; + $1 = HEAP32[$0 + 7200 >> 2]; + HEAP32[$0 + 1408 >> 2] = $1; + HEAP32[$0 + 1412 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Shape__20_28b2Fixture____29_28_29___invoke_b2Fixture_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Shape__20_28b2Fixture____29_28_29_29($4, $0 + 1408 | 0); + HEAP32[$0 + 3516 >> 2] = 0; + HEAP32[$0 + 3512 >> 2] = 138; + $1 = HEAP32[$0 + 3516 >> 2]; + $2 = HEAP32[$0 + 3512 >> 2]; + HEAP32[$0 + 7224 >> 2] = $2; + HEAP32[$0 + 7228 >> 2] = $1; + $1 = HEAP32[$0 + 7224 >> 2]; + $2 = HEAP32[$0 + 7228 >> 2]; + HEAP32[$0 + 7252 >> 2] = $3; + HEAP32[$0 + 7248 >> 2] = 3799; + HEAP32[$0 + 7244 >> 2] = $2; + HEAP32[$0 + 7240 >> 2] = $1; + $3 = HEAP32[$0 + 7252 >> 2]; + $4 = HEAP32[$0 + 7248 >> 2]; + $1 = HEAP32[$0 + 7240 >> 2]; + HEAP32[$0 + 7236 >> 2] = HEAP32[$0 + 7244 >> 2]; + HEAP32[$0 + 7232 >> 2] = $1; + $2 = HEAP32[$0 + 7236 >> 2]; + $1 = HEAP32[$0 + 7232 >> 2]; + HEAP32[$0 + 1400 >> 2] = $1; + HEAP32[$0 + 1404 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28bool_29___invoke_b2Fixture__28char_20const__2c_20void_20_28b2Fixture____29_28bool_29_29($4, $0 + 1400 | 0); + HEAP32[$0 + 3508 >> 2] = 0; + HEAP32[$0 + 3504 >> 2] = 139; + $1 = HEAP32[$0 + 3508 >> 2]; + $2 = HEAP32[$0 + 3504 >> 2]; + HEAP32[$0 + 7256 >> 2] = $2; + HEAP32[$0 + 7260 >> 2] = $1; + $1 = HEAP32[$0 + 7256 >> 2]; + $2 = HEAP32[$0 + 7260 >> 2]; + HEAP32[$0 + 7284 >> 2] = $3; + HEAP32[$0 + 7280 >> 2] = 3818; + HEAP32[$0 + 7276 >> 2] = $2; + HEAP32[$0 + 7272 >> 2] = $1; + $3 = HEAP32[$0 + 7284 >> 2]; + $4 = HEAP32[$0 + 7280 >> 2]; + $1 = HEAP32[$0 + 7272 >> 2]; + HEAP32[$0 + 7268 >> 2] = HEAP32[$0 + 7276 >> 2]; + HEAP32[$0 + 7264 >> 2] = $1; + $2 = HEAP32[$0 + 7268 >> 2]; + $1 = HEAP32[$0 + 7264 >> 2]; + HEAP32[$0 + 1392 >> 2] = $1; + HEAP32[$0 + 1396 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Fixture____29_28_29_20const___invoke_b2Fixture__28char_20const__2c_20bool_20_28b2Fixture____29_28_29_20const_29($4, $0 + 1392 | 0); + HEAP32[$0 + 3500 >> 2] = 0; + HEAP32[$0 + 3496 >> 2] = 140; + $1 = HEAP32[$0 + 3500 >> 2]; + $2 = HEAP32[$0 + 3496 >> 2]; + HEAP32[$0 + 7288 >> 2] = $2; + HEAP32[$0 + 7292 >> 2] = $1; + $1 = HEAP32[$0 + 7288 >> 2]; + $2 = HEAP32[$0 + 7292 >> 2]; + HEAP32[$0 + 7316 >> 2] = $3; + HEAP32[$0 + 7312 >> 2] = 10463; + HEAP32[$0 + 7308 >> 2] = $2; + HEAP32[$0 + 7304 >> 2] = $1; + $3 = HEAP32[$0 + 7316 >> 2]; + $4 = HEAP32[$0 + 7312 >> 2]; + $1 = HEAP32[$0 + 7304 >> 2]; + HEAP32[$0 + 7300 >> 2] = HEAP32[$0 + 7308 >> 2]; + HEAP32[$0 + 7296 >> 2] = $1; + $2 = HEAP32[$0 + 7300 >> 2]; + $1 = HEAP32[$0 + 7296 >> 2]; + HEAP32[$0 + 1384 >> 2] = $1; + HEAP32[$0 + 1388 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28b2Filter_20const__29___invoke_b2Fixture__28char_20const__2c_20void_20_28b2Fixture____29_28b2Filter_20const__29_29($4, $0 + 1384 | 0); + HEAP32[$0 + 3492 >> 2] = 0; + HEAP32[$0 + 3488 >> 2] = 141; + $1 = HEAP32[$0 + 3492 >> 2]; + $2 = HEAP32[$0 + 3488 >> 2]; + HEAP32[$0 + 7320 >> 2] = $2; + HEAP32[$0 + 7324 >> 2] = $1; + $1 = HEAP32[$0 + 7320 >> 2]; + $2 = HEAP32[$0 + 7324 >> 2]; + HEAP32[$0 + 7348 >> 2] = $3; + HEAP32[$0 + 7344 >> 2] = 10477; + HEAP32[$0 + 7340 >> 2] = $2; + HEAP32[$0 + 7336 >> 2] = $1; + $3 = HEAP32[$0 + 7348 >> 2]; + $4 = HEAP32[$0 + 7344 >> 2]; + $1 = HEAP32[$0 + 7336 >> 2]; + HEAP32[$0 + 7332 >> 2] = HEAP32[$0 + 7340 >> 2]; + HEAP32[$0 + 7328 >> 2] = $1; + $2 = HEAP32[$0 + 7332 >> 2]; + $1 = HEAP32[$0 + 7328 >> 2]; + HEAP32[$0 + 1376 >> 2] = $1; + HEAP32[$0 + 1380 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Filter_20const__20_28b2Fixture____29_28_29_20const___invoke_b2Fixture__28char_20const__2c_20b2Filter_20const__20_28b2Fixture____29_28_29_20const_29($4, $0 + 1376 | 0); + HEAP32[$0 + 3484 >> 2] = 0; + HEAP32[$0 + 3480 >> 2] = 142; + $1 = HEAP32[$0 + 3484 >> 2]; + $2 = HEAP32[$0 + 3480 >> 2]; + HEAP32[$0 + 7352 >> 2] = $2; + HEAP32[$0 + 7356 >> 2] = $1; + $1 = HEAP32[$0 + 7352 >> 2]; + $2 = HEAP32[$0 + 7356 >> 2]; + HEAP32[$0 + 7380 >> 2] = $3; + HEAP32[$0 + 7376 >> 2] = 3942; + HEAP32[$0 + 7372 >> 2] = $2; + HEAP32[$0 + 7368 >> 2] = $1; + $3 = HEAP32[$0 + 7380 >> 2]; + $4 = HEAP32[$0 + 7376 >> 2]; + $1 = HEAP32[$0 + 7368 >> 2]; + HEAP32[$0 + 7364 >> 2] = HEAP32[$0 + 7372 >> 2]; + HEAP32[$0 + 7360 >> 2] = $1; + $2 = HEAP32[$0 + 7364 >> 2]; + $1 = HEAP32[$0 + 7360 >> 2]; + HEAP32[$0 + 1368 >> 2] = $1; + HEAP32[$0 + 1372 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28_29___invoke_b2Fixture__28char_20const__2c_20void_20_28b2Fixture____29_28_29_29($4, $0 + 1368 | 0); + HEAP32[$0 + 3472 >> 2] = 0; + HEAP32[$0 + 3468 >> 2] = 143; + $1 = HEAP32[$0 + 3472 >> 2]; + $2 = HEAP32[$0 + 3468 >> 2]; + HEAP32[$0 + 7384 >> 2] = $2; + HEAP32[$0 + 7388 >> 2] = $1; + $1 = HEAP32[$0 + 7384 >> 2]; + $2 = HEAP32[$0 + 7388 >> 2]; + HEAP32[$0 + 7412 >> 2] = $3; + HEAP32[$0 + 7408 >> 2] = 1627; + HEAP32[$0 + 7404 >> 2] = $2; + HEAP32[$0 + 7400 >> 2] = $1; + $3 = HEAP32[$0 + 7412 >> 2]; + $4 = HEAP32[$0 + 7408 >> 2]; + $1 = HEAP32[$0 + 7400 >> 2]; + HEAP32[$0 + 7396 >> 2] = HEAP32[$0 + 7404 >> 2]; + HEAP32[$0 + 7392 >> 2] = $1; + $2 = HEAP32[$0 + 7396 >> 2]; + $1 = HEAP32[$0 + 7392 >> 2]; + HEAP32[$0 + 1360 >> 2] = $1; + HEAP32[$0 + 1364 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Body__20_28b2Fixture____29_28_29___invoke_b2Fixture_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Body__20_28b2Fixture____29_28_29_29($4, $0 + 1360 | 0); + HEAP32[$0 + 3464 >> 2] = 0; + HEAP32[$0 + 3460 >> 2] = 144; + $1 = HEAP32[$0 + 3464 >> 2]; + $2 = HEAP32[$0 + 3460 >> 2]; + HEAP32[$0 + 7416 >> 2] = $2; + HEAP32[$0 + 7420 >> 2] = $1; + $1 = HEAP32[$0 + 7416 >> 2]; + $2 = HEAP32[$0 + 7420 >> 2]; + HEAP32[$0 + 7444 >> 2] = $3; + HEAP32[$0 + 7440 >> 2] = 2409; + HEAP32[$0 + 7436 >> 2] = $2; + HEAP32[$0 + 7432 >> 2] = $1; + $3 = HEAP32[$0 + 7444 >> 2]; + $4 = HEAP32[$0 + 7440 >> 2]; + $1 = HEAP32[$0 + 7432 >> 2]; + HEAP32[$0 + 7428 >> 2] = HEAP32[$0 + 7436 >> 2]; + HEAP32[$0 + 7424 >> 2] = $1; + $2 = HEAP32[$0 + 7428 >> 2]; + $1 = HEAP32[$0 + 7424 >> 2]; + HEAP32[$0 + 1352 >> 2] = $1; + HEAP32[$0 + 1356 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Fixture____29_28b2Vec2_20const__29_20const___invoke_b2Fixture__28char_20const__2c_20bool_20_28b2Fixture____29_28b2Vec2_20const__29_20const_29($4, $0 + 1352 | 0); + HEAP32[$0 + 3452 >> 2] = 0; + HEAP32[$0 + 3448 >> 2] = 145; + $1 = HEAP32[$0 + 3452 >> 2]; + $2 = HEAP32[$0 + 3448 >> 2]; + HEAP32[$0 + 7448 >> 2] = $2; + HEAP32[$0 + 7452 >> 2] = $1; + $1 = HEAP32[$0 + 7448 >> 2]; + $2 = HEAP32[$0 + 7452 >> 2]; + HEAP32[$0 + 7476 >> 2] = $3; + HEAP32[$0 + 7472 >> 2] = 1866; + HEAP32[$0 + 7468 >> 2] = $2; + HEAP32[$0 + 7464 >> 2] = $1; + $3 = HEAP32[$0 + 7476 >> 2]; + $4 = HEAP32[$0 + 7472 >> 2]; + $1 = HEAP32[$0 + 7464 >> 2]; + HEAP32[$0 + 7460 >> 2] = HEAP32[$0 + 7468 >> 2]; + HEAP32[$0 + 7456 >> 2] = $1; + $2 = HEAP32[$0 + 7460 >> 2]; + $1 = HEAP32[$0 + 7456 >> 2]; + HEAP32[$0 + 1344 >> 2] = $1; + HEAP32[$0 + 1348 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Fixture____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const___invoke_b2Fixture_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2Fixture____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const_29($4, $0 + 1344 | 0); + HEAP32[$0 + 3440 >> 2] = 0; + HEAP32[$0 + 3436 >> 2] = 146; + $1 = HEAP32[$0 + 3440 >> 2]; + $2 = HEAP32[$0 + 3436 >> 2]; + HEAP32[$0 + 7480 >> 2] = $2; + HEAP32[$0 + 7484 >> 2] = $1; + $1 = HEAP32[$0 + 7480 >> 2]; + $2 = HEAP32[$0 + 7484 >> 2]; + HEAP32[$0 + 7508 >> 2] = $3; + HEAP32[$0 + 7504 >> 2] = 10451; + HEAP32[$0 + 7500 >> 2] = $2; + HEAP32[$0 + 7496 >> 2] = $1; + $3 = HEAP32[$0 + 7508 >> 2]; + $4 = HEAP32[$0 + 7504 >> 2]; + $1 = HEAP32[$0 + 7496 >> 2]; + HEAP32[$0 + 7492 >> 2] = HEAP32[$0 + 7500 >> 2]; + HEAP32[$0 + 7488 >> 2] = $1; + $2 = HEAP32[$0 + 7492 >> 2]; + $1 = HEAP32[$0 + 7488 >> 2]; + HEAP32[$0 + 1336 >> 2] = $1; + HEAP32[$0 + 1340 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28b2MassData__29_20const___invoke_b2Fixture_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Fixture____29_28b2MassData__29_20const_29($4, $0 + 1336 | 0); + HEAP32[$0 + 3432 >> 2] = 0; + HEAP32[$0 + 3428 >> 2] = 147; + $1 = HEAP32[$0 + 3432 >> 2]; + $2 = HEAP32[$0 + 3428 >> 2]; + HEAP32[$0 + 7576 >> 2] = $2; + HEAP32[$0 + 7580 >> 2] = $1; + $1 = HEAP32[$0 + 7576 >> 2]; + $2 = HEAP32[$0 + 7580 >> 2]; + HEAP32[$0 + 7604 >> 2] = $3; + HEAP32[$0 + 7600 >> 2] = 1089; + HEAP32[$0 + 7596 >> 2] = $2; + HEAP32[$0 + 7592 >> 2] = $1; + $3 = HEAP32[$0 + 7604 >> 2]; + $4 = HEAP32[$0 + 7600 >> 2]; + $1 = HEAP32[$0 + 7592 >> 2]; + HEAP32[$0 + 7588 >> 2] = HEAP32[$0 + 7596 >> 2]; + HEAP32[$0 + 7584 >> 2] = $1; + $2 = HEAP32[$0 + 7588 >> 2]; + $1 = HEAP32[$0 + 7584 >> 2]; + HEAP32[$0 + 1328 >> 2] = $1; + HEAP32[$0 + 1332 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28float_29___invoke_b2Fixture__28char_20const__2c_20void_20_28b2Fixture____29_28float_29_29($4, $0 + 1328 | 0); + HEAP32[$0 + 3424 >> 2] = 0; + HEAP32[$0 + 3420 >> 2] = 148; + $1 = HEAP32[$0 + 3424 >> 2]; + $2 = HEAP32[$0 + 3420 >> 2]; + HEAP32[$0 + 7672 >> 2] = $2; + HEAP32[$0 + 7676 >> 2] = $1; + $1 = HEAP32[$0 + 7672 >> 2]; + $2 = HEAP32[$0 + 7676 >> 2]; + HEAP32[$0 + 7700 >> 2] = $3; + HEAP32[$0 + 7696 >> 2] = 1100; + HEAP32[$0 + 7692 >> 2] = $2; + HEAP32[$0 + 7688 >> 2] = $1; + $3 = HEAP32[$0 + 7700 >> 2]; + $4 = HEAP32[$0 + 7696 >> 2]; + $1 = HEAP32[$0 + 7688 >> 2]; + HEAP32[$0 + 7684 >> 2] = HEAP32[$0 + 7692 >> 2]; + HEAP32[$0 + 7680 >> 2] = $1; + $2 = HEAP32[$0 + 7684 >> 2]; + $1 = HEAP32[$0 + 7680 >> 2]; + HEAP32[$0 + 1320 >> 2] = $1; + HEAP32[$0 + 1324 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2Fixture____29_28_29_20const___invoke_b2Fixture__28char_20const__2c_20float_20_28b2Fixture____29_28_29_20const_29($4, $0 + 1320 | 0); + HEAP32[$0 + 3416 >> 2] = 0; + HEAP32[$0 + 3412 >> 2] = 149; + $1 = HEAP32[$0 + 3416 >> 2]; + $2 = HEAP32[$0 + 3412 >> 2]; + HEAP32[$0 + 7640 >> 2] = $2; + HEAP32[$0 + 7644 >> 2] = $1; + $1 = HEAP32[$0 + 7640 >> 2]; + $2 = HEAP32[$0 + 7644 >> 2]; + HEAP32[$0 + 7668 >> 2] = $3; + HEAP32[$0 + 7664 >> 2] = 6534; + HEAP32[$0 + 7660 >> 2] = $2; + HEAP32[$0 + 7656 >> 2] = $1; + $3 = HEAP32[$0 + 7668 >> 2]; + $4 = HEAP32[$0 + 7664 >> 2]; + $1 = HEAP32[$0 + 7656 >> 2]; + HEAP32[$0 + 7652 >> 2] = HEAP32[$0 + 7660 >> 2]; + HEAP32[$0 + 7648 >> 2] = $1; + $2 = HEAP32[$0 + 7652 >> 2]; + $1 = HEAP32[$0 + 7648 >> 2]; + HEAP32[$0 + 1312 >> 2] = $1; + HEAP32[$0 + 1316 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2Fixture____29_28_29_20const___invoke_b2Fixture__28char_20const__2c_20float_20_28b2Fixture____29_28_29_20const_29($4, $0 + 1312 | 0); + HEAP32[$0 + 3408 >> 2] = 0; + HEAP32[$0 + 3404 >> 2] = 150; + $1 = HEAP32[$0 + 3408 >> 2]; + $2 = HEAP32[$0 + 3404 >> 2]; + HEAP32[$0 + 7544 >> 2] = $2; + HEAP32[$0 + 7548 >> 2] = $1; + $1 = HEAP32[$0 + 7544 >> 2]; + $2 = HEAP32[$0 + 7548 >> 2]; + HEAP32[$0 + 7572 >> 2] = $3; + HEAP32[$0 + 7568 >> 2] = 6515; + HEAP32[$0 + 7564 >> 2] = $2; + HEAP32[$0 + 7560 >> 2] = $1; + $3 = HEAP32[$0 + 7572 >> 2]; + $4 = HEAP32[$0 + 7568 >> 2]; + $1 = HEAP32[$0 + 7560 >> 2]; + HEAP32[$0 + 7556 >> 2] = HEAP32[$0 + 7564 >> 2]; + HEAP32[$0 + 7552 >> 2] = $1; + $2 = HEAP32[$0 + 7556 >> 2]; + $1 = HEAP32[$0 + 7552 >> 2]; + HEAP32[$0 + 1304 >> 2] = $1; + HEAP32[$0 + 1308 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28float_29___invoke_b2Fixture__28char_20const__2c_20void_20_28b2Fixture____29_28float_29_29($4, $0 + 1304 | 0); + HEAP32[$0 + 3400 >> 2] = 0; + HEAP32[$0 + 3396 >> 2] = 151; + $1 = HEAP32[$0 + 3400 >> 2]; + $2 = HEAP32[$0 + 3396 >> 2]; + HEAP32[$0 + 7608 >> 2] = $2; + HEAP32[$0 + 7612 >> 2] = $1; + $1 = HEAP32[$0 + 7608 >> 2]; + $2 = HEAP32[$0 + 7612 >> 2]; + HEAP32[$0 + 7636 >> 2] = $3; + HEAP32[$0 + 7632 >> 2] = 6422; + HEAP32[$0 + 7628 >> 2] = $2; + HEAP32[$0 + 7624 >> 2] = $1; + $3 = HEAP32[$0 + 7636 >> 2]; + $4 = HEAP32[$0 + 7632 >> 2]; + $1 = HEAP32[$0 + 7624 >> 2]; + HEAP32[$0 + 7620 >> 2] = HEAP32[$0 + 7628 >> 2]; + HEAP32[$0 + 7616 >> 2] = $1; + $2 = HEAP32[$0 + 7620 >> 2]; + $1 = HEAP32[$0 + 7616 >> 2]; + HEAP32[$0 + 1296 >> 2] = $1; + HEAP32[$0 + 1300 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2Fixture____29_28_29_20const___invoke_b2Fixture__28char_20const__2c_20float_20_28b2Fixture____29_28_29_20const_29($4, $0 + 1296 | 0); + HEAP32[$0 + 3392 >> 2] = 0; + HEAP32[$0 + 3388 >> 2] = 152; + $1 = HEAP32[$0 + 3392 >> 2]; + $2 = HEAP32[$0 + 3388 >> 2]; + HEAP32[$0 + 7512 >> 2] = $2; + HEAP32[$0 + 7516 >> 2] = $1; + $1 = HEAP32[$0 + 7512 >> 2]; + $2 = HEAP32[$0 + 7516 >> 2]; + HEAP32[$0 + 7540 >> 2] = $3; + HEAP32[$0 + 7536 >> 2] = 6400; + HEAP32[$0 + 7532 >> 2] = $2; + HEAP32[$0 + 7528 >> 2] = $1; + $3 = HEAP32[$0 + 7540 >> 2]; + $4 = HEAP32[$0 + 7536 >> 2]; + $1 = HEAP32[$0 + 7528 >> 2]; + HEAP32[$0 + 7524 >> 2] = HEAP32[$0 + 7532 >> 2]; + HEAP32[$0 + 7520 >> 2] = $1; + $2 = HEAP32[$0 + 7524 >> 2]; + $1 = HEAP32[$0 + 7520 >> 2]; + HEAP32[$0 + 1288 >> 2] = $1; + HEAP32[$0 + 1292 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28float_29___invoke_b2Fixture__28char_20const__2c_20void_20_28b2Fixture____29_28float_29_29($4, $0 + 1288 | 0); + HEAP32[$0 + 3384 >> 2] = 0; + HEAP32[$0 + 3380 >> 2] = 153; + $1 = HEAP32[$0 + 3384 >> 2]; + $2 = HEAP32[$0 + 3380 >> 2]; + HEAP32[$0 + 7704 >> 2] = $2; + HEAP32[$0 + 7708 >> 2] = $1; + $1 = HEAP32[$0 + 7704 >> 2]; + $2 = HEAP32[$0 + 7708 >> 2]; + HEAP32[$0 + 7732 >> 2] = $3; + HEAP32[$0 + 7728 >> 2] = 11073; + HEAP32[$0 + 7724 >> 2] = $2; + HEAP32[$0 + 7720 >> 2] = $1; + $3 = HEAP32[$0 + 7732 >> 2]; + $4 = HEAP32[$0 + 7728 >> 2]; + $1 = HEAP32[$0 + 7720 >> 2]; + HEAP32[$0 + 7716 >> 2] = HEAP32[$0 + 7724 >> 2]; + HEAP32[$0 + 7712 >> 2] = $1; + $2 = HEAP32[$0 + 7716 >> 2]; + $1 = HEAP32[$0 + 7712 >> 2]; + HEAP32[$0 + 1280 >> 2] = $1; + HEAP32[$0 + 1284 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2AABB_20const__20_28b2Fixture____29_28int_29_20const___invoke_b2Fixture__28char_20const__2c_20b2AABB_20const__20_28b2Fixture____29_28int_29_20const_29($4, $0 + 1280 | 0); + HEAP32[$0 + 3376 >> 2] = 0; + HEAP32[$0 + 3372 >> 2] = 154; + $1 = HEAP32[$0 + 3376 >> 2]; + $2 = HEAP32[$0 + 3372 >> 2]; + HEAP32[$0 + 7736 >> 2] = $2; + HEAP32[$0 + 7740 >> 2] = $1; + $1 = HEAP32[$0 + 7736 >> 2]; + $2 = HEAP32[$0 + 7740 >> 2]; + HEAP32[$0 + 7768 >> 2] = $3; + HEAP32[$0 + 7764 >> 2] = 6232; + HEAP32[$0 + 7760 >> 2] = $2; + HEAP32[$0 + 7756 >> 2] = $1; + $3 = HEAP32[$0 + 7764 >> 2]; + $1 = HEAP32[$0 + 7756 >> 2]; + HEAP32[$0 + 7752 >> 2] = HEAP32[$0 + 7760 >> 2]; + HEAP32[$0 + 7748 >> 2] = $1; + $2 = HEAP32[$0 + 7752 >> 2]; + $1 = HEAP32[$0 + 7748 >> 2]; + HEAP32[$0 + 1272 >> 2] = $1; + HEAP32[$0 + 1276 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28int_29___invoke_b2Fixture__28char_20const__2c_20void_20_28b2Fixture____29_28int_29_29($3, $0 + 1272 | 0); + HEAP32[$0 + 7792 >> 2] = $0 + 3371; + HEAP32[$0 + 7788 >> 2] = 7879; + void_20emscripten__internal__NoBaseClass__verify_b2BodyDef__28_29(); + HEAP32[$0 + 7784 >> 2] = 155; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2BodyDef__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 7780 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2BodyDef__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 7776 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 7772 >> 2] = 156; + $1 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2BodyDef__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2BodyDef_20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$0 + 15456 >> 2] = HEAP32[$0 + 7784 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7784 >> 2]; + HEAP32[$0 + 14740 >> 2] = HEAP32[$0 + 7780 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$0 + 7780 >> 2]; + HEAP32[$0 + 14736 >> 2] = HEAP32[$0 + 7776 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$0 + 7776 >> 2]; + $11 = HEAP32[$0 + 7788 >> 2]; + HEAP32[$0 + 15460 >> 2] = HEAP32[$0 + 7772 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 7772 >> 2]); + HEAP32[$0 + 7796 >> 2] = $0 + 3371; + HEAP32[$0 + 15468 >> 2] = HEAP32[$0 + 7796 >> 2]; + HEAP32[$0 + 15464 >> 2] = 157; + $1 = HEAP32[$0 + 15468 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2BodyDef__20_28__29_28_29___invoke_b2BodyDef__28b2BodyDef__20_28__29_28_29_29(HEAP32[$0 + 15464 >> 2]); + HEAP32[$0 + 7816 >> 2] = $1; + HEAP32[$0 + 7812 >> 2] = 9223; + HEAP32[$0 + 7808 >> 2] = 0; + $1 = HEAP32[$0 + 7816 >> 2]; + HEAP32[$0 + 7804 >> 2] = 158; + HEAP32[$0 + 7800 >> 2] = 159; + $2 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 7812 >> 2]; + $4 = emscripten__internal__TypeID_b2BodyType_2c_20void___get_28_29(); + HEAP32[$0 + 15472 >> 2] = HEAP32[$0 + 7804 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7804 >> 2]; + $7 = b2BodyType_20b2BodyDef_____20emscripten__internal__getContext_b2BodyType_20b2BodyDef_____28b2BodyType_20b2BodyDef____20const__29($0 + 7808 | 0); + $8 = emscripten__internal__TypeID_b2BodyType_2c_20void___get_28_29(); + HEAP32[$0 + 15476 >> 2] = HEAP32[$0 + 7800 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 7800 >> 2], b2BodyType_20b2BodyDef_____20emscripten__internal__getContext_b2BodyType_20b2BodyDef_____28b2BodyType_20b2BodyDef____20const__29($0 + 7808 | 0) | 0); + HEAP32[$0 + 7856 >> 2] = $1; + HEAP32[$0 + 7852 >> 2] = 6437; + HEAP32[$0 + 7848 >> 2] = 4; + $1 = HEAP32[$0 + 7856 >> 2]; + HEAP32[$0 + 7844 >> 2] = 160; + HEAP32[$0 + 7840 >> 2] = 161; + $2 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 7852 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15480 >> 2] = HEAP32[$0 + 7844 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7844 >> 2]; + $7 = b2Vec2_20b2BodyDef_____20emscripten__internal__getContext_b2Vec2_20b2BodyDef_____28b2Vec2_20b2BodyDef____20const__29($0 + 7848 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15488 >> 2] = HEAP32[$0 + 7840 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 7840 >> 2], b2Vec2_20b2BodyDef_____20emscripten__internal__getContext_b2Vec2_20b2BodyDef_____28b2Vec2_20b2BodyDef____20const__29($0 + 7848 | 0) | 0); + HEAP32[$0 + 7956 >> 2] = $1; + HEAP32[$0 + 7952 >> 2] = 9420; + HEAP32[$0 + 7948 >> 2] = 12; + $1 = HEAP32[$0 + 7956 >> 2]; + HEAP32[$0 + 7944 >> 2] = 162; + HEAP32[$0 + 7940 >> 2] = 163; + $2 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 7952 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15496 >> 2] = HEAP32[$0 + 7944 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7944 >> 2]; + $7 = float_20b2BodyDef_____20emscripten__internal__getContext_float_20b2BodyDef_____28float_20b2BodyDef____20const__29($0 + 7948 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15516 >> 2] = HEAP32[$0 + 7940 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 7940 >> 2], float_20b2BodyDef_____20emscripten__internal__getContext_float_20b2BodyDef_____28float_20b2BodyDef____20const__29($0 + 7948 | 0) | 0); + HEAP32[$0 + 7836 >> 2] = $1; + HEAP32[$0 + 7832 >> 2] = 1165; + HEAP32[$0 + 7828 >> 2] = 16; + $1 = HEAP32[$0 + 7836 >> 2]; + HEAP32[$0 + 7824 >> 2] = 160; + HEAP32[$0 + 7820 >> 2] = 161; + $2 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 7832 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15484 >> 2] = HEAP32[$0 + 7824 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7824 >> 2]; + $7 = b2Vec2_20b2BodyDef_____20emscripten__internal__getContext_b2Vec2_20b2BodyDef_____28b2Vec2_20b2BodyDef____20const__29($0 + 7828 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15492 >> 2] = HEAP32[$0 + 7820 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 7820 >> 2], b2Vec2_20b2BodyDef_____20emscripten__internal__getContext_b2Vec2_20b2BodyDef_____28b2Vec2_20b2BodyDef____20const__29($0 + 7828 | 0) | 0); + HEAP32[$0 + 7936 >> 2] = $1; + HEAP32[$0 + 7932 >> 2] = 1111; + HEAP32[$0 + 7928 >> 2] = 24; + $1 = HEAP32[$0 + 7936 >> 2]; + HEAP32[$0 + 7924 >> 2] = 162; + HEAP32[$0 + 7920 >> 2] = 163; + $2 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 7932 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15500 >> 2] = HEAP32[$0 + 7924 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7924 >> 2]; + $7 = float_20b2BodyDef_____20emscripten__internal__getContext_float_20b2BodyDef_____28float_20b2BodyDef____20const__29($0 + 7928 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15520 >> 2] = HEAP32[$0 + 7920 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 7920 >> 2], float_20b2BodyDef_____20emscripten__internal__getContext_float_20b2BodyDef_____28float_20b2BodyDef____20const__29($0 + 7928 | 0) | 0); + HEAP32[$0 + 7916 >> 2] = $1; + HEAP32[$0 + 7912 >> 2] = 7775; + HEAP32[$0 + 7908 >> 2] = 28; + $1 = HEAP32[$0 + 7916 >> 2]; + HEAP32[$0 + 7904 >> 2] = 162; + HEAP32[$0 + 7900 >> 2] = 163; + $2 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 7912 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15504 >> 2] = HEAP32[$0 + 7904 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7904 >> 2]; + $7 = float_20b2BodyDef_____20emscripten__internal__getContext_float_20b2BodyDef_____28float_20b2BodyDef____20const__29($0 + 7908 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15524 >> 2] = HEAP32[$0 + 7900 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 7900 >> 2], float_20b2BodyDef_____20emscripten__internal__getContext_float_20b2BodyDef_____28float_20b2BodyDef____20const__29($0 + 7908 | 0) | 0); + HEAP32[$0 + 7896 >> 2] = $1; + HEAP32[$0 + 7892 >> 2] = 7724; + HEAP32[$0 + 7888 >> 2] = 32; + $1 = HEAP32[$0 + 7896 >> 2]; + HEAP32[$0 + 7884 >> 2] = 162; + HEAP32[$0 + 7880 >> 2] = 163; + $2 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 7892 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15508 >> 2] = HEAP32[$0 + 7884 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7884 >> 2]; + $7 = float_20b2BodyDef_____20emscripten__internal__getContext_float_20b2BodyDef_____28float_20b2BodyDef____20const__29($0 + 7888 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15528 >> 2] = HEAP32[$0 + 7880 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 7880 >> 2], float_20b2BodyDef_____20emscripten__internal__getContext_float_20b2BodyDef_____28float_20b2BodyDef____20const__29($0 + 7888 | 0) | 0); + HEAP32[$0 + 8036 >> 2] = $1; + HEAP32[$0 + 8032 >> 2] = 6242; + HEAP32[$0 + 8028 >> 2] = 36; + $1 = HEAP32[$0 + 8036 >> 2]; + HEAP32[$0 + 8024 >> 2] = 164; + HEAP32[$0 + 8020 >> 2] = 165; + $2 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 8032 >> 2]; + $4 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15536 >> 2] = HEAP32[$0 + 8024 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 8024 >> 2]; + $7 = bool_20b2BodyDef_____20emscripten__internal__getContext_bool_20b2BodyDef_____28bool_20b2BodyDef____20const__29($0 + 8028 | 0); + $8 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15552 >> 2] = HEAP32[$0 + 8020 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 8020 >> 2], bool_20b2BodyDef_____20emscripten__internal__getContext_bool_20b2BodyDef_____28bool_20b2BodyDef____20const__29($0 + 8028 | 0) | 0); + HEAP32[$0 + 8016 >> 2] = $1; + HEAP32[$0 + 8012 >> 2] = 9719; + HEAP32[$0 + 8008 >> 2] = 37; + $1 = HEAP32[$0 + 8016 >> 2]; + HEAP32[$0 + 8004 >> 2] = 164; + HEAP32[$0 + 8e3 >> 2] = 165; + $2 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 8012 >> 2]; + $4 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15540 >> 2] = HEAP32[$0 + 8004 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 8004 >> 2]; + $7 = bool_20b2BodyDef_____20emscripten__internal__getContext_bool_20b2BodyDef_____28bool_20b2BodyDef____20const__29($0 + 8008 | 0); + $8 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15556 >> 2] = HEAP32[$0 + 8e3 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 8e3 >> 2], bool_20b2BodyDef_____20emscripten__internal__getContext_bool_20b2BodyDef_____28bool_20b2BodyDef____20const__29($0 + 8008 | 0) | 0); + HEAP32[$0 + 7996 >> 2] = $1; + HEAP32[$0 + 7992 >> 2] = 6618; + HEAP32[$0 + 7988 >> 2] = 38; + $1 = HEAP32[$0 + 7996 >> 2]; + HEAP32[$0 + 7984 >> 2] = 164; + HEAP32[$0 + 7980 >> 2] = 165; + $2 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 7992 >> 2]; + $4 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15544 >> 2] = HEAP32[$0 + 7984 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7984 >> 2]; + $7 = bool_20b2BodyDef_____20emscripten__internal__getContext_bool_20b2BodyDef_____28bool_20b2BodyDef____20const__29($0 + 7988 | 0); + $8 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15560 >> 2] = HEAP32[$0 + 7980 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 7980 >> 2], bool_20b2BodyDef_____20emscripten__internal__getContext_bool_20b2BodyDef_____28bool_20b2BodyDef____20const__29($0 + 7988 | 0) | 0); + HEAP32[$0 + 7976 >> 2] = $1; + HEAP32[$0 + 7972 >> 2] = 2966; + HEAP32[$0 + 7968 >> 2] = 39; + $1 = HEAP32[$0 + 7976 >> 2]; + HEAP32[$0 + 7964 >> 2] = 164; + HEAP32[$0 + 7960 >> 2] = 165; + $2 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 7972 >> 2]; + $4 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15548 >> 2] = HEAP32[$0 + 7964 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 7964 >> 2]; + $7 = bool_20b2BodyDef_____20emscripten__internal__getContext_bool_20b2BodyDef_____28bool_20b2BodyDef____20const__29($0 + 7968 | 0); + $8 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15564 >> 2] = HEAP32[$0 + 7960 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 7960 >> 2], bool_20b2BodyDef_____20emscripten__internal__getContext_bool_20b2BodyDef_____28bool_20b2BodyDef____20const__29($0 + 7968 | 0) | 0); + HEAP32[$0 + 7876 >> 2] = $1; + HEAP32[$0 + 7872 >> 2] = 9674; + HEAP32[$0 + 7868 >> 2] = 48; + HEAP32[$0 + 7864 >> 2] = 162; + HEAP32[$0 + 7860 >> 2] = 163; + $1 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 7872 >> 2]; + $3 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15512 >> 2] = HEAP32[$0 + 7864 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $5 = HEAP32[$0 + 7864 >> 2]; + $6 = float_20b2BodyDef_____20emscripten__internal__getContext_float_20b2BodyDef_____28float_20b2BodyDef____20const__29($0 + 7868 | 0); + $7 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15532 >> 2] = HEAP32[$0 + 7860 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 7860 >> 2], float_20b2BodyDef_____20emscripten__internal__getContext_float_20b2BodyDef_____28float_20b2BodyDef____20const__29($0 + 7868 | 0) | 0); + HEAP32[$0 + 8060 >> 2] = $0 + 3370; + HEAP32[$0 + 8056 >> 2] = 1704; + void_20emscripten__internal__NoBaseClass__verify_b2Body__28_29(); + HEAP32[$0 + 8052 >> 2] = 166; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2Body__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 8048 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2Body__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 8044 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 8040 >> 2] = 167; + $1 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Body__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$0 + 15568 >> 2] = HEAP32[$0 + 8052 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 8052 >> 2]; + HEAP32[$0 + 14732 >> 2] = HEAP32[$0 + 8048 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$0 + 8048 >> 2]; + HEAP32[$0 + 14728 >> 2] = HEAP32[$0 + 8044 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$0 + 8044 >> 2]; + $11 = HEAP32[$0 + 8056 >> 2]; + HEAP32[$0 + 15572 >> 2] = HEAP32[$0 + 8040 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 8040 >> 2]); + HEAP32[$0 + 3356 >> 2] = 0; + HEAP32[$0 + 3352 >> 2] = 168; + $1 = HEAP32[$0 + 3356 >> 2]; + $2 = HEAP32[$0 + 3352 >> 2]; + HEAP32[$0 + 1264 >> 2] = $2; + HEAP32[$0 + 1268 >> 2] = $1; + decltype_28fp_29_20emscripten__select_overload_b2Fixture__20_28b2FixtureDef_20const__29_2c_20b2Body__28b2Fixture__20_28b2Body____29_28b2FixtureDef_20const__29_29($0 + 3360 | 0, $0 + 1264 | 0); + $1 = HEAP32[$0 + 3360 >> 2]; + HEAP32[$0 + 3344 >> 2] = HEAP32[$0 + 3364 >> 2]; + HEAP32[$0 + 3340 >> 2] = $1; + $2 = HEAP32[$0 + 3344 >> 2]; + $1 = HEAP32[$0 + 3340 >> 2]; + HEAP32[$0 + 8064 >> 2] = $1; + HEAP32[$0 + 8068 >> 2] = $2; + $1 = HEAP32[$0 + 8064 >> 2]; + $2 = HEAP32[$0 + 8068 >> 2]; + HEAP32[$0 + 8092 >> 2] = $0 + 3370; + HEAP32[$0 + 8088 >> 2] = 9207; + HEAP32[$0 + 8084 >> 2] = $2; + HEAP32[$0 + 8080 >> 2] = $1; + $3 = HEAP32[$0 + 8092 >> 2]; + $4 = HEAP32[$0 + 8088 >> 2]; + $1 = HEAP32[$0 + 8080 >> 2]; + HEAP32[$0 + 8076 >> 2] = HEAP32[$0 + 8084 >> 2]; + HEAP32[$0 + 8072 >> 2] = $1; + $1 = HEAP32[$0 + 8076 >> 2]; + $2 = HEAP32[$0 + 8072 >> 2]; + HEAP32[$0 + 1256 >> 2] = $2; + HEAP32[$0 + 1260 >> 2] = $1; + void_20emscripten__internal__RegisterClassMethod_b2Fixture__20_28b2Body____29_28b2FixtureDef_20const__29___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Fixture__20_28b2Body____29_28b2FixtureDef_20const__29_29($4, $0 + 1256 | 0); + HEAP32[$0 + 3328 >> 2] = 0; + HEAP32[$0 + 3324 >> 2] = 169; + $2 = HEAP32[$0 + 3328 >> 2]; + $1 = HEAP32[$0 + 3324 >> 2]; + HEAP32[$0 + 1248 >> 2] = $1; + HEAP32[$0 + 1252 >> 2] = $2; + decltype_28fp_29_20emscripten__select_overload_b2Fixture__20_28b2Shape_20const__2c_20float_29_2c_20b2Body__28b2Fixture__20_28b2Body____29_28b2Shape_20const__2c_20float_29_29($0 + 3332 | 0, $0 + 1248 | 0); + $1 = HEAP32[$0 + 3332 >> 2]; + HEAP32[$0 + 3316 >> 2] = HEAP32[$0 + 3336 >> 2]; + HEAP32[$0 + 3312 >> 2] = $1; + $1 = HEAP32[$0 + 3316 >> 2]; + $2 = HEAP32[$0 + 3312 >> 2]; + HEAP32[$0 + 8096 >> 2] = $2; + HEAP32[$0 + 8100 >> 2] = $1; + $1 = HEAP32[$0 + 8096 >> 2]; + $2 = HEAP32[$0 + 8100 >> 2]; + HEAP32[$0 + 8124 >> 2] = $3; + HEAP32[$0 + 8120 >> 2] = 9341; + HEAP32[$0 + 8116 >> 2] = $2; + HEAP32[$0 + 8112 >> 2] = $1; + $3 = HEAP32[$0 + 8124 >> 2]; + $4 = HEAP32[$0 + 8120 >> 2]; + $1 = HEAP32[$0 + 8112 >> 2]; + HEAP32[$0 + 8108 >> 2] = HEAP32[$0 + 8116 >> 2]; + HEAP32[$0 + 8104 >> 2] = $1; + $2 = HEAP32[$0 + 8108 >> 2]; + $1 = HEAP32[$0 + 8104 >> 2]; + HEAP32[$0 + 1240 >> 2] = $1; + HEAP32[$0 + 1244 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Fixture__20_28b2Body____29_28b2Shape_20const__2c_20float_29___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Fixture__20_28b2Body____29_28b2Shape_20const__2c_20float_29_29($4, $0 + 1240 | 0); + HEAP32[$0 + 3304 >> 2] = 0; + HEAP32[$0 + 3300 >> 2] = 170; + $1 = HEAP32[$0 + 3304 >> 2]; + $2 = HEAP32[$0 + 3300 >> 2]; + HEAP32[$0 + 8128 >> 2] = $2; + HEAP32[$0 + 8132 >> 2] = $1; + $1 = HEAP32[$0 + 8128 >> 2]; + $2 = HEAP32[$0 + 8132 >> 2]; + HEAP32[$0 + 8156 >> 2] = $3; + HEAP32[$0 + 8152 >> 2] = 9153; + HEAP32[$0 + 8148 >> 2] = $2; + HEAP32[$0 + 8144 >> 2] = $1; + $3 = HEAP32[$0 + 8156 >> 2]; + $4 = HEAP32[$0 + 8152 >> 2]; + $1 = HEAP32[$0 + 8144 >> 2]; + HEAP32[$0 + 8140 >> 2] = HEAP32[$0 + 8148 >> 2]; + HEAP32[$0 + 8136 >> 2] = $1; + $2 = HEAP32[$0 + 8140 >> 2]; + $1 = HEAP32[$0 + 8136 >> 2]; + HEAP32[$0 + 1232 >> 2] = $1; + HEAP32[$0 + 1236 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2Fixture__29___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Body____29_28b2Fixture__29_29($4, $0 + 1232 | 0); + HEAP32[$0 + 3296 >> 2] = 0; + HEAP32[$0 + 3292 >> 2] = 171; + $1 = HEAP32[$0 + 3296 >> 2]; + $2 = HEAP32[$0 + 3292 >> 2]; + HEAP32[$0 + 8160 >> 2] = $2; + HEAP32[$0 + 8164 >> 2] = $1; + $1 = HEAP32[$0 + 8160 >> 2]; + $2 = HEAP32[$0 + 8164 >> 2]; + HEAP32[$0 + 8188 >> 2] = $3; + HEAP32[$0 + 8184 >> 2] = 6938; + HEAP32[$0 + 8180 >> 2] = $2; + HEAP32[$0 + 8176 >> 2] = $1; + $3 = HEAP32[$0 + 8188 >> 2]; + $4 = HEAP32[$0 + 8184 >> 2]; + $1 = HEAP32[$0 + 8176 >> 2]; + HEAP32[$0 + 8172 >> 2] = HEAP32[$0 + 8180 >> 2]; + HEAP32[$0 + 8168 >> 2] = $1; + $2 = HEAP32[$0 + 8172 >> 2]; + $1 = HEAP32[$0 + 8168 >> 2]; + HEAP32[$0 + 1224 >> 2] = $1; + HEAP32[$0 + 1228 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2Vec2_20const__2c_20float_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28b2Vec2_20const__2c_20float_29_29($4, $0 + 1224 | 0); + HEAP32[$0 + 3288 >> 2] = 0; + HEAP32[$0 + 3284 >> 2] = 172; + $1 = HEAP32[$0 + 3288 >> 2]; + $2 = HEAP32[$0 + 3284 >> 2]; + HEAP32[$0 + 8192 >> 2] = $2; + HEAP32[$0 + 8196 >> 2] = $1; + $1 = HEAP32[$0 + 8192 >> 2]; + $2 = HEAP32[$0 + 8196 >> 2]; + HEAP32[$0 + 8220 >> 2] = $3; + HEAP32[$0 + 8216 >> 2] = 6951; + HEAP32[$0 + 8212 >> 2] = $2; + HEAP32[$0 + 8208 >> 2] = $1; + $3 = HEAP32[$0 + 8220 >> 2]; + $4 = HEAP32[$0 + 8216 >> 2]; + $1 = HEAP32[$0 + 8208 >> 2]; + HEAP32[$0 + 8204 >> 2] = HEAP32[$0 + 8212 >> 2]; + HEAP32[$0 + 8200 >> 2] = $1; + $2 = HEAP32[$0 + 8204 >> 2]; + $1 = HEAP32[$0 + 8200 >> 2]; + HEAP32[$0 + 1216 >> 2] = $1; + HEAP32[$0 + 1220 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Transform_20const__20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20b2Transform_20const__20_28b2Body____29_28_29_20const_29($4, $0 + 1216 | 0); + HEAP32[$0 + 3280 >> 2] = 0; + HEAP32[$0 + 3276 >> 2] = 173; + $1 = HEAP32[$0 + 3280 >> 2]; + $2 = HEAP32[$0 + 3276 >> 2]; + HEAP32[$0 + 8320 >> 2] = $2; + HEAP32[$0 + 8324 >> 2] = $1; + $1 = HEAP32[$0 + 8320 >> 2]; + $2 = HEAP32[$0 + 8324 >> 2]; + HEAP32[$0 + 8348 >> 2] = $3; + HEAP32[$0 + 8344 >> 2] = 6446; + HEAP32[$0 + 8340 >> 2] = $2; + HEAP32[$0 + 8336 >> 2] = $1; + $3 = HEAP32[$0 + 8348 >> 2]; + $4 = HEAP32[$0 + 8344 >> 2]; + $1 = HEAP32[$0 + 8336 >> 2]; + HEAP32[$0 + 8332 >> 2] = HEAP32[$0 + 8340 >> 2]; + HEAP32[$0 + 8328 >> 2] = $1; + $2 = HEAP32[$0 + 8332 >> 2]; + $1 = HEAP32[$0 + 8328 >> 2]; + HEAP32[$0 + 1208 >> 2] = $1; + HEAP32[$0 + 1212 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20b2Vec2_20const__20_28b2Body____29_28_29_20const_29($4, $0 + 1208 | 0); + HEAP32[$0 + 3272 >> 2] = 0; + HEAP32[$0 + 3268 >> 2] = 174; + $1 = HEAP32[$0 + 3272 >> 2]; + $2 = HEAP32[$0 + 3268 >> 2]; + HEAP32[$0 + 8544 >> 2] = $2; + HEAP32[$0 + 8548 >> 2] = $1; + $1 = HEAP32[$0 + 8544 >> 2]; + $2 = HEAP32[$0 + 8548 >> 2]; + HEAP32[$0 + 8572 >> 2] = $3; + HEAP32[$0 + 8568 >> 2] = 9440; + HEAP32[$0 + 8564 >> 2] = $2; + HEAP32[$0 + 8560 >> 2] = $1; + $3 = HEAP32[$0 + 8572 >> 2]; + $4 = HEAP32[$0 + 8568 >> 2]; + $1 = HEAP32[$0 + 8560 >> 2]; + HEAP32[$0 + 8556 >> 2] = HEAP32[$0 + 8564 >> 2]; + HEAP32[$0 + 8552 >> 2] = $1; + $2 = HEAP32[$0 + 8556 >> 2]; + $1 = HEAP32[$0 + 8552 >> 2]; + HEAP32[$0 + 1200 >> 2] = $1; + HEAP32[$0 + 1204 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20float_20_28b2Body____29_28_29_20const_29($4, $0 + 1200 | 0); + HEAP32[$0 + 3264 >> 2] = 0; + HEAP32[$0 + 3260 >> 2] = 175; + $1 = HEAP32[$0 + 3264 >> 2]; + $2 = HEAP32[$0 + 3260 >> 2]; + HEAP32[$0 + 8288 >> 2] = $2; + HEAP32[$0 + 8292 >> 2] = $1; + $1 = HEAP32[$0 + 8288 >> 2]; + $2 = HEAP32[$0 + 8292 >> 2]; + HEAP32[$0 + 8316 >> 2] = $3; + HEAP32[$0 + 8312 >> 2] = 3927; + HEAP32[$0 + 8308 >> 2] = $2; + HEAP32[$0 + 8304 >> 2] = $1; + $3 = HEAP32[$0 + 8316 >> 2]; + $4 = HEAP32[$0 + 8312 >> 2]; + $1 = HEAP32[$0 + 8304 >> 2]; + HEAP32[$0 + 8300 >> 2] = HEAP32[$0 + 8308 >> 2]; + HEAP32[$0 + 8296 >> 2] = $1; + $2 = HEAP32[$0 + 8300 >> 2]; + $1 = HEAP32[$0 + 8296 >> 2]; + HEAP32[$0 + 1192 >> 2] = $1; + HEAP32[$0 + 1196 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20b2Vec2_20const__20_28b2Body____29_28_29_20const_29($4, $0 + 1192 | 0); + HEAP32[$0 + 3256 >> 2] = 0; + HEAP32[$0 + 3252 >> 2] = 176; + $1 = HEAP32[$0 + 3256 >> 2]; + $2 = HEAP32[$0 + 3252 >> 2]; + HEAP32[$0 + 8256 >> 2] = $2; + HEAP32[$0 + 8260 >> 2] = $1; + $1 = HEAP32[$0 + 8256 >> 2]; + $2 = HEAP32[$0 + 8260 >> 2]; + HEAP32[$0 + 8284 >> 2] = $3; + HEAP32[$0 + 8280 >> 2] = 3912; + HEAP32[$0 + 8276 >> 2] = $2; + HEAP32[$0 + 8272 >> 2] = $1; + $3 = HEAP32[$0 + 8284 >> 2]; + $4 = HEAP32[$0 + 8280 >> 2]; + $1 = HEAP32[$0 + 8272 >> 2]; + HEAP32[$0 + 8268 >> 2] = HEAP32[$0 + 8276 >> 2]; + HEAP32[$0 + 8264 >> 2] = $1; + $2 = HEAP32[$0 + 8268 >> 2]; + $1 = HEAP32[$0 + 8264 >> 2]; + HEAP32[$0 + 1184 >> 2] = $1; + HEAP32[$0 + 1188 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20b2Vec2_20const__20_28b2Body____29_28_29_20const_29($4, $0 + 1184 | 0); + HEAP32[$0 + 3248 >> 2] = 0; + HEAP32[$0 + 3244 >> 2] = 177; + $1 = HEAP32[$0 + 3248 >> 2]; + $2 = HEAP32[$0 + 3244 >> 2]; + HEAP32[$0 + 8576 >> 2] = $2; + HEAP32[$0 + 8580 >> 2] = $1; + $1 = HEAP32[$0 + 8576 >> 2]; + $2 = HEAP32[$0 + 8580 >> 2]; + HEAP32[$0 + 8604 >> 2] = $3; + HEAP32[$0 + 8600 >> 2] = 1180; + HEAP32[$0 + 8596 >> 2] = $2; + HEAP32[$0 + 8592 >> 2] = $1; + $3 = HEAP32[$0 + 8604 >> 2]; + $4 = HEAP32[$0 + 8600 >> 2]; + $1 = HEAP32[$0 + 8592 >> 2]; + HEAP32[$0 + 8588 >> 2] = HEAP32[$0 + 8596 >> 2]; + HEAP32[$0 + 8584 >> 2] = $1; + $2 = HEAP32[$0 + 8588 >> 2]; + $1 = HEAP32[$0 + 8584 >> 2]; + HEAP32[$0 + 1176 >> 2] = $1; + HEAP32[$0 + 1180 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2Vec2_20const__29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28b2Vec2_20const__29_29($4, $0 + 1176 | 0); + HEAP32[$0 + 3240 >> 2] = 0; + HEAP32[$0 + 3236 >> 2] = 178; + $1 = HEAP32[$0 + 3240 >> 2]; + $2 = HEAP32[$0 + 3236 >> 2]; + HEAP32[$0 + 8224 >> 2] = $2; + HEAP32[$0 + 8228 >> 2] = $1; + $1 = HEAP32[$0 + 8224 >> 2]; + $2 = HEAP32[$0 + 8228 >> 2]; + HEAP32[$0 + 8252 >> 2] = $3; + HEAP32[$0 + 8248 >> 2] = 1198; + HEAP32[$0 + 8244 >> 2] = $2; + HEAP32[$0 + 8240 >> 2] = $1; + $3 = HEAP32[$0 + 8252 >> 2]; + $4 = HEAP32[$0 + 8248 >> 2]; + $1 = HEAP32[$0 + 8240 >> 2]; + HEAP32[$0 + 8236 >> 2] = HEAP32[$0 + 8244 >> 2]; + HEAP32[$0 + 8232 >> 2] = $1; + $2 = HEAP32[$0 + 8236 >> 2]; + $1 = HEAP32[$0 + 8232 >> 2]; + HEAP32[$0 + 1168 >> 2] = $1; + HEAP32[$0 + 1172 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20b2Vec2_20const__20_28b2Body____29_28_29_20const_29($4, $0 + 1168 | 0); + HEAP32[$0 + 3232 >> 2] = 0; + HEAP32[$0 + 3228 >> 2] = 179; + $1 = HEAP32[$0 + 3232 >> 2]; + $2 = HEAP32[$0 + 3228 >> 2]; + HEAP32[$0 + 8704 >> 2] = $2; + HEAP32[$0 + 8708 >> 2] = $1; + $1 = HEAP32[$0 + 8704 >> 2]; + $2 = HEAP32[$0 + 8708 >> 2]; + HEAP32[$0 + 8732 >> 2] = $3; + HEAP32[$0 + 8728 >> 2] = 1127; + HEAP32[$0 + 8724 >> 2] = $2; + HEAP32[$0 + 8720 >> 2] = $1; + $3 = HEAP32[$0 + 8732 >> 2]; + $4 = HEAP32[$0 + 8728 >> 2]; + $1 = HEAP32[$0 + 8720 >> 2]; + HEAP32[$0 + 8716 >> 2] = HEAP32[$0 + 8724 >> 2]; + HEAP32[$0 + 8712 >> 2] = $1; + $2 = HEAP32[$0 + 8716 >> 2]; + $1 = HEAP32[$0 + 8712 >> 2]; + HEAP32[$0 + 1160 >> 2] = $1; + HEAP32[$0 + 1164 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28float_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28float_29_29($4, $0 + 1160 | 0); + HEAP32[$0 + 3224 >> 2] = 0; + HEAP32[$0 + 3220 >> 2] = 180; + $1 = HEAP32[$0 + 3224 >> 2]; + $2 = HEAP32[$0 + 3220 >> 2]; + HEAP32[$0 + 8512 >> 2] = $2; + HEAP32[$0 + 8516 >> 2] = $1; + $1 = HEAP32[$0 + 8512 >> 2]; + $2 = HEAP32[$0 + 8516 >> 2]; + HEAP32[$0 + 8540 >> 2] = $3; + HEAP32[$0 + 8536 >> 2] = 1146; + HEAP32[$0 + 8532 >> 2] = $2; + HEAP32[$0 + 8528 >> 2] = $1; + $3 = HEAP32[$0 + 8540 >> 2]; + $4 = HEAP32[$0 + 8536 >> 2]; + $1 = HEAP32[$0 + 8528 >> 2]; + HEAP32[$0 + 8524 >> 2] = HEAP32[$0 + 8532 >> 2]; + HEAP32[$0 + 8520 >> 2] = $1; + $2 = HEAP32[$0 + 8524 >> 2]; + $1 = HEAP32[$0 + 8520 >> 2]; + HEAP32[$0 + 1152 >> 2] = $1; + HEAP32[$0 + 1156 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20float_20_28b2Body____29_28_29_20const_29($4, $0 + 1152 | 0); + HEAP32[$0 + 3216 >> 2] = 0; + HEAP32[$0 + 3212 >> 2] = 181; + $1 = HEAP32[$0 + 3216 >> 2]; + $2 = HEAP32[$0 + 3212 >> 2]; + HEAP32[$0 + 8768 >> 2] = $2; + HEAP32[$0 + 8772 >> 2] = $1; + $1 = HEAP32[$0 + 8768 >> 2]; + $2 = HEAP32[$0 + 8772 >> 2]; + HEAP32[$0 + 8796 >> 2] = $3; + HEAP32[$0 + 8792 >> 2] = 9852; + HEAP32[$0 + 8788 >> 2] = $2; + HEAP32[$0 + 8784 >> 2] = $1; + $3 = HEAP32[$0 + 8796 >> 2]; + $4 = HEAP32[$0 + 8792 >> 2]; + $1 = HEAP32[$0 + 8784 >> 2]; + HEAP32[$0 + 8780 >> 2] = HEAP32[$0 + 8788 >> 2]; + HEAP32[$0 + 8776 >> 2] = $1; + $2 = HEAP32[$0 + 8780 >> 2]; + $1 = HEAP32[$0 + 8776 >> 2]; + HEAP32[$0 + 1144 >> 2] = $1; + HEAP32[$0 + 1148 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29_29($4, $0 + 1144 | 0); + HEAP32[$0 + 3208 >> 2] = 0; + HEAP32[$0 + 3204 >> 2] = 182; + $1 = HEAP32[$0 + 3208 >> 2]; + $2 = HEAP32[$0 + 3204 >> 2]; + HEAP32[$0 + 8832 >> 2] = $2; + HEAP32[$0 + 8836 >> 2] = $1; + $1 = HEAP32[$0 + 8832 >> 2]; + $2 = HEAP32[$0 + 8836 >> 2]; + HEAP32[$0 + 8860 >> 2] = $3; + HEAP32[$0 + 8856 >> 2] = 3893; + HEAP32[$0 + 8852 >> 2] = $2; + HEAP32[$0 + 8848 >> 2] = $1; + $3 = HEAP32[$0 + 8860 >> 2]; + $4 = HEAP32[$0 + 8856 >> 2]; + $1 = HEAP32[$0 + 8848 >> 2]; + HEAP32[$0 + 8844 >> 2] = HEAP32[$0 + 8852 >> 2]; + HEAP32[$0 + 8840 >> 2] = $1; + $2 = HEAP32[$0 + 8844 >> 2]; + $1 = HEAP32[$0 + 8840 >> 2]; + HEAP32[$0 + 1136 >> 2] = $1; + HEAP32[$0 + 1140 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2Vec2_20const__2c_20bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28b2Vec2_20const__2c_20bool_29_29($4, $0 + 1136 | 0); + HEAP32[$0 + 3200 >> 2] = 0; + HEAP32[$0 + 3196 >> 2] = 183; + $1 = HEAP32[$0 + 3200 >> 2]; + $2 = HEAP32[$0 + 3196 >> 2]; + HEAP32[$0 + 8896 >> 2] = $2; + HEAP32[$0 + 8900 >> 2] = $1; + $1 = HEAP32[$0 + 8896 >> 2]; + $2 = HEAP32[$0 + 8900 >> 2]; + HEAP32[$0 + 8924 >> 2] = $3; + HEAP32[$0 + 8920 >> 2] = 8743; + HEAP32[$0 + 8916 >> 2] = $2; + HEAP32[$0 + 8912 >> 2] = $1; + $3 = HEAP32[$0 + 8924 >> 2]; + $4 = HEAP32[$0 + 8920 >> 2]; + $1 = HEAP32[$0 + 8912 >> 2]; + HEAP32[$0 + 8908 >> 2] = HEAP32[$0 + 8916 >> 2]; + HEAP32[$0 + 8904 >> 2] = $1; + $2 = HEAP32[$0 + 8908 >> 2]; + $1 = HEAP32[$0 + 8904 >> 2]; + HEAP32[$0 + 1128 >> 2] = $1; + HEAP32[$0 + 1132 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28float_2c_20bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28float_2c_20bool_29_29($4, $0 + 1128 | 0); + HEAP32[$0 + 3192 >> 2] = 0; + HEAP32[$0 + 3188 >> 2] = 184; + $1 = HEAP32[$0 + 3192 >> 2]; + $2 = HEAP32[$0 + 3188 >> 2]; + HEAP32[$0 + 8736 >> 2] = $2; + HEAP32[$0 + 8740 >> 2] = $1; + $1 = HEAP32[$0 + 8736 >> 2]; + $2 = HEAP32[$0 + 8740 >> 2]; + HEAP32[$0 + 8764 >> 2] = $3; + HEAP32[$0 + 8760 >> 2] = 9044; + HEAP32[$0 + 8756 >> 2] = $2; + HEAP32[$0 + 8752 >> 2] = $1; + $3 = HEAP32[$0 + 8764 >> 2]; + $4 = HEAP32[$0 + 8760 >> 2]; + $1 = HEAP32[$0 + 8752 >> 2]; + HEAP32[$0 + 8748 >> 2] = HEAP32[$0 + 8756 >> 2]; + HEAP32[$0 + 8744 >> 2] = $1; + $2 = HEAP32[$0 + 8748 >> 2]; + $1 = HEAP32[$0 + 8744 >> 2]; + HEAP32[$0 + 1120 >> 2] = $1; + HEAP32[$0 + 1124 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29_29($4, $0 + 1120 | 0); + HEAP32[$0 + 3184 >> 2] = 0; + HEAP32[$0 + 3180 >> 2] = 185; + $1 = HEAP32[$0 + 3184 >> 2]; + $2 = HEAP32[$0 + 3180 >> 2]; + HEAP32[$0 + 8800 >> 2] = $2; + HEAP32[$0 + 8804 >> 2] = $1; + $1 = HEAP32[$0 + 8800 >> 2]; + $2 = HEAP32[$0 + 8804 >> 2]; + HEAP32[$0 + 8828 >> 2] = $3; + HEAP32[$0 + 8824 >> 2] = 3866; + HEAP32[$0 + 8820 >> 2] = $2; + HEAP32[$0 + 8816 >> 2] = $1; + $3 = HEAP32[$0 + 8828 >> 2]; + $4 = HEAP32[$0 + 8824 >> 2]; + $1 = HEAP32[$0 + 8816 >> 2]; + HEAP32[$0 + 8812 >> 2] = HEAP32[$0 + 8820 >> 2]; + HEAP32[$0 + 8808 >> 2] = $1; + $2 = HEAP32[$0 + 8812 >> 2]; + $1 = HEAP32[$0 + 8808 >> 2]; + HEAP32[$0 + 1112 >> 2] = $1; + HEAP32[$0 + 1116 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2Vec2_20const__2c_20bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28b2Vec2_20const__2c_20bool_29_29($4, $0 + 1112 | 0); + HEAP32[$0 + 3176 >> 2] = 0; + HEAP32[$0 + 3172 >> 2] = 186; + $1 = HEAP32[$0 + 3176 >> 2]; + $2 = HEAP32[$0 + 3172 >> 2]; + HEAP32[$0 + 8864 >> 2] = $2; + HEAP32[$0 + 8868 >> 2] = $1; + $1 = HEAP32[$0 + 8864 >> 2]; + $2 = HEAP32[$0 + 8868 >> 2]; + HEAP32[$0 + 8892 >> 2] = $3; + HEAP32[$0 + 8888 >> 2] = 9024; + HEAP32[$0 + 8884 >> 2] = $2; + HEAP32[$0 + 8880 >> 2] = $1; + $3 = HEAP32[$0 + 8892 >> 2]; + $4 = HEAP32[$0 + 8888 >> 2]; + $1 = HEAP32[$0 + 8880 >> 2]; + HEAP32[$0 + 8876 >> 2] = HEAP32[$0 + 8884 >> 2]; + HEAP32[$0 + 8872 >> 2] = $1; + $2 = HEAP32[$0 + 8876 >> 2]; + $1 = HEAP32[$0 + 8872 >> 2]; + HEAP32[$0 + 1104 >> 2] = $1; + HEAP32[$0 + 1108 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28float_2c_20bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28float_2c_20bool_29_29($4, $0 + 1104 | 0); + HEAP32[$0 + 3168 >> 2] = 0; + HEAP32[$0 + 3164 >> 2] = 187; + $1 = HEAP32[$0 + 3168 >> 2]; + $2 = HEAP32[$0 + 3164 >> 2]; + HEAP32[$0 + 8480 >> 2] = $2; + HEAP32[$0 + 8484 >> 2] = $1; + $1 = HEAP32[$0 + 8480 >> 2]; + $2 = HEAP32[$0 + 8484 >> 2]; + HEAP32[$0 + 8508 >> 2] = $3; + HEAP32[$0 + 8504 >> 2] = 3428; + HEAP32[$0 + 8500 >> 2] = $2; + HEAP32[$0 + 8496 >> 2] = $1; + $3 = HEAP32[$0 + 8508 >> 2]; + $4 = HEAP32[$0 + 8504 >> 2]; + $1 = HEAP32[$0 + 8496 >> 2]; + HEAP32[$0 + 8492 >> 2] = HEAP32[$0 + 8500 >> 2]; + HEAP32[$0 + 8488 >> 2] = $1; + $2 = HEAP32[$0 + 8492 >> 2]; + $1 = HEAP32[$0 + 8488 >> 2]; + HEAP32[$0 + 1096 >> 2] = $1; + HEAP32[$0 + 1100 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20float_20_28b2Body____29_28_29_20const_29($4, $0 + 1096 | 0); + HEAP32[$0 + 3160 >> 2] = 0; + HEAP32[$0 + 3156 >> 2] = 188; + $1 = HEAP32[$0 + 3160 >> 2]; + $2 = HEAP32[$0 + 3156 >> 2]; + HEAP32[$0 + 8448 >> 2] = $2; + HEAP32[$0 + 8452 >> 2] = $1; + $1 = HEAP32[$0 + 8448 >> 2]; + $2 = HEAP32[$0 + 8452 >> 2]; + HEAP32[$0 + 8476 >> 2] = $3; + HEAP32[$0 + 8472 >> 2] = 10503; + HEAP32[$0 + 8468 >> 2] = $2; + HEAP32[$0 + 8464 >> 2] = $1; + $3 = HEAP32[$0 + 8476 >> 2]; + $4 = HEAP32[$0 + 8472 >> 2]; + $1 = HEAP32[$0 + 8464 >> 2]; + HEAP32[$0 + 8460 >> 2] = HEAP32[$0 + 8468 >> 2]; + HEAP32[$0 + 8456 >> 2] = $1; + $2 = HEAP32[$0 + 8460 >> 2]; + $1 = HEAP32[$0 + 8456 >> 2]; + HEAP32[$0 + 1088 >> 2] = $1; + HEAP32[$0 + 1092 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20float_20_28b2Body____29_28_29_20const_29($4, $0 + 1088 | 0); + HEAP32[$0 + 3148 >> 2] = 0; + HEAP32[$0 + 3144 >> 2] = 189; + $1 = HEAP32[$0 + 3148 >> 2]; + $2 = HEAP32[$0 + 3144 >> 2]; + HEAP32[$0 + 8928 >> 2] = $2; + HEAP32[$0 + 8932 >> 2] = $1; + $1 = HEAP32[$0 + 8928 >> 2]; + $2 = HEAP32[$0 + 8932 >> 2]; + HEAP32[$0 + 8960 >> 2] = $3; + HEAP32[$0 + 8956 >> 2] = 10451; + HEAP32[$0 + 8952 >> 2] = $2; + HEAP32[$0 + 8948 >> 2] = $1; + $3 = HEAP32[$0 + 8960 >> 2]; + $4 = HEAP32[$0 + 8956 >> 2]; + $1 = HEAP32[$0 + 8948 >> 2]; + HEAP32[$0 + 8944 >> 2] = HEAP32[$0 + 8952 >> 2]; + HEAP32[$0 + 8940 >> 2] = $1; + $2 = HEAP32[$0 + 8944 >> 2]; + $1 = HEAP32[$0 + 8940 >> 2]; + HEAP32[$0 + 1080 >> 2] = $1; + HEAP32[$0 + 1084 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2MassData__29_20const___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Body____29_28b2MassData__29_20const_29($4, $0 + 1080 | 0); + $1 = emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_7__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_7__28embind_init_b2_28_29__$_7_20const__29($0 + 3143 | 0); + HEAP32[$0 + 8972 >> 2] = $3; + HEAP32[$0 + 8968 >> 2] = 10439; + HEAP32[$0 + 8964 >> 2] = $1; + $3 = HEAP32[$0 + 8972 >> 2]; + void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2Body__2c_20b2MassData_20const__29___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2Body__2c_20b2MassData_20const__29_29(HEAP32[$0 + 8968 >> 2], HEAP32[$0 + 8964 >> 2]); + HEAP32[$0 + 3136 >> 2] = 0; + HEAP32[$0 + 3132 >> 2] = 190; + $1 = HEAP32[$0 + 3136 >> 2]; + $2 = HEAP32[$0 + 3132 >> 2]; + HEAP32[$0 + 9008 >> 2] = $2; + HEAP32[$0 + 9012 >> 2] = $1; + $1 = HEAP32[$0 + 9008 >> 2]; + $2 = HEAP32[$0 + 9012 >> 2]; + HEAP32[$0 + 9036 >> 2] = $3; + HEAP32[$0 + 9032 >> 2] = 10425; + HEAP32[$0 + 9028 >> 2] = $2; + HEAP32[$0 + 9024 >> 2] = $1; + $3 = HEAP32[$0 + 9036 >> 2]; + $4 = HEAP32[$0 + 9032 >> 2]; + $1 = HEAP32[$0 + 9024 >> 2]; + HEAP32[$0 + 9020 >> 2] = HEAP32[$0 + 9028 >> 2]; + HEAP32[$0 + 9016 >> 2] = $1; + $2 = HEAP32[$0 + 9020 >> 2]; + $1 = HEAP32[$0 + 9016 >> 2]; + HEAP32[$0 + 1072 >> 2] = $1; + HEAP32[$0 + 1076 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28_29_29($4, $0 + 1072 | 0); + HEAP32[$0 + 3128 >> 2] = 0; + HEAP32[$0 + 3124 >> 2] = 191; + $1 = HEAP32[$0 + 3128 >> 2]; + $2 = HEAP32[$0 + 3124 >> 2]; + HEAP32[$0 + 9200 >> 2] = $2; + HEAP32[$0 + 9204 >> 2] = $1; + $1 = HEAP32[$0 + 9200 >> 2]; + $2 = HEAP32[$0 + 9204 >> 2]; + HEAP32[$0 + 9228 >> 2] = $3; + HEAP32[$0 + 9224 >> 2] = 2465; + HEAP32[$0 + 9220 >> 2] = $2; + HEAP32[$0 + 9216 >> 2] = $1; + $3 = HEAP32[$0 + 9228 >> 2]; + $4 = HEAP32[$0 + 9224 >> 2]; + $1 = HEAP32[$0 + 9216 >> 2]; + HEAP32[$0 + 9212 >> 2] = HEAP32[$0 + 9220 >> 2]; + HEAP32[$0 + 9208 >> 2] = $1; + $2 = HEAP32[$0 + 9212 >> 2]; + $1 = HEAP32[$0 + 9208 >> 2]; + HEAP32[$0 + 1064 >> 2] = $1; + HEAP32[$0 + 1068 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const___invoke_b2Body__28char_20const__2c_20b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const_29($4, $0 + 1064 | 0); + HEAP32[$0 + 3120 >> 2] = 0; + HEAP32[$0 + 3116 >> 2] = 192; + $1 = HEAP32[$0 + 3120 >> 2]; + $2 = HEAP32[$0 + 3116 >> 2]; + HEAP32[$0 + 9168 >> 2] = $2; + HEAP32[$0 + 9172 >> 2] = $1; + $1 = HEAP32[$0 + 9168 >> 2]; + $2 = HEAP32[$0 + 9172 >> 2]; + HEAP32[$0 + 9196 >> 2] = $3; + HEAP32[$0 + 9192 >> 2] = 3686; + HEAP32[$0 + 9188 >> 2] = $2; + HEAP32[$0 + 9184 >> 2] = $1; + $3 = HEAP32[$0 + 9196 >> 2]; + $4 = HEAP32[$0 + 9192 >> 2]; + $1 = HEAP32[$0 + 9184 >> 2]; + HEAP32[$0 + 9180 >> 2] = HEAP32[$0 + 9188 >> 2]; + HEAP32[$0 + 9176 >> 2] = $1; + $2 = HEAP32[$0 + 9180 >> 2]; + $1 = HEAP32[$0 + 9176 >> 2]; + HEAP32[$0 + 1056 >> 2] = $1; + HEAP32[$0 + 1060 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const___invoke_b2Body__28char_20const__2c_20b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const_29($4, $0 + 1056 | 0); + HEAP32[$0 + 3112 >> 2] = 0; + HEAP32[$0 + 3108 >> 2] = 193; + $1 = HEAP32[$0 + 3112 >> 2]; + $2 = HEAP32[$0 + 3108 >> 2]; + HEAP32[$0 + 9136 >> 2] = $2; + HEAP32[$0 + 9140 >> 2] = $1; + $1 = HEAP32[$0 + 9136 >> 2]; + $2 = HEAP32[$0 + 9140 >> 2]; + HEAP32[$0 + 9164 >> 2] = $3; + HEAP32[$0 + 9160 >> 2] = 2419; + HEAP32[$0 + 9156 >> 2] = $2; + HEAP32[$0 + 9152 >> 2] = $1; + $3 = HEAP32[$0 + 9164 >> 2]; + $4 = HEAP32[$0 + 9160 >> 2]; + $1 = HEAP32[$0 + 9152 >> 2]; + HEAP32[$0 + 9148 >> 2] = HEAP32[$0 + 9156 >> 2]; + HEAP32[$0 + 9144 >> 2] = $1; + $2 = HEAP32[$0 + 9148 >> 2]; + $1 = HEAP32[$0 + 9144 >> 2]; + HEAP32[$0 + 1048 >> 2] = $1; + HEAP32[$0 + 1052 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const___invoke_b2Body__28char_20const__2c_20b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const_29($4, $0 + 1048 | 0); + HEAP32[$0 + 3104 >> 2] = 0; + HEAP32[$0 + 3100 >> 2] = 194; + $1 = HEAP32[$0 + 3104 >> 2]; + $2 = HEAP32[$0 + 3100 >> 2]; + HEAP32[$0 + 9104 >> 2] = $2; + HEAP32[$0 + 9108 >> 2] = $1; + $1 = HEAP32[$0 + 9104 >> 2]; + $2 = HEAP32[$0 + 9108 >> 2]; + HEAP32[$0 + 9132 >> 2] = $3; + HEAP32[$0 + 9128 >> 2] = 3671; + HEAP32[$0 + 9124 >> 2] = $2; + HEAP32[$0 + 9120 >> 2] = $1; + $3 = HEAP32[$0 + 9132 >> 2]; + $4 = HEAP32[$0 + 9128 >> 2]; + $1 = HEAP32[$0 + 9120 >> 2]; + HEAP32[$0 + 9116 >> 2] = HEAP32[$0 + 9124 >> 2]; + HEAP32[$0 + 9112 >> 2] = $1; + $2 = HEAP32[$0 + 9116 >> 2]; + $1 = HEAP32[$0 + 9112 >> 2]; + HEAP32[$0 + 1040 >> 2] = $1; + HEAP32[$0 + 1044 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const___invoke_b2Body__28char_20const__2c_20b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const_29($4, $0 + 1040 | 0); + HEAP32[$0 + 3096 >> 2] = 0; + HEAP32[$0 + 3092 >> 2] = 195; + $1 = HEAP32[$0 + 3096 >> 2]; + $2 = HEAP32[$0 + 3092 >> 2]; + HEAP32[$0 + 9072 >> 2] = $2; + HEAP32[$0 + 9076 >> 2] = $1; + $1 = HEAP32[$0 + 9072 >> 2]; + $2 = HEAP32[$0 + 9076 >> 2]; + HEAP32[$0 + 9100 >> 2] = $3; + HEAP32[$0 + 9096 >> 2] = 2479; + HEAP32[$0 + 9092 >> 2] = $2; + HEAP32[$0 + 9088 >> 2] = $1; + $3 = HEAP32[$0 + 9100 >> 2]; + $4 = HEAP32[$0 + 9096 >> 2]; + $1 = HEAP32[$0 + 9088 >> 2]; + HEAP32[$0 + 9084 >> 2] = HEAP32[$0 + 9092 >> 2]; + HEAP32[$0 + 9080 >> 2] = $1; + $2 = HEAP32[$0 + 9084 >> 2]; + $1 = HEAP32[$0 + 9080 >> 2]; + HEAP32[$0 + 1032 >> 2] = $1; + HEAP32[$0 + 1036 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const___invoke_b2Body__28char_20const__2c_20b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const_29($4, $0 + 1032 | 0); + HEAP32[$0 + 3088 >> 2] = 0; + HEAP32[$0 + 3084 >> 2] = 196; + $1 = HEAP32[$0 + 3088 >> 2]; + $2 = HEAP32[$0 + 3084 >> 2]; + HEAP32[$0 + 9040 >> 2] = $2; + HEAP32[$0 + 9044 >> 2] = $1; + $1 = HEAP32[$0 + 9040 >> 2]; + $2 = HEAP32[$0 + 9044 >> 2]; + HEAP32[$0 + 9068 >> 2] = $3; + HEAP32[$0 + 9064 >> 2] = 2433; + HEAP32[$0 + 9060 >> 2] = $2; + HEAP32[$0 + 9056 >> 2] = $1; + $3 = HEAP32[$0 + 9068 >> 2]; + $4 = HEAP32[$0 + 9064 >> 2]; + $1 = HEAP32[$0 + 9056 >> 2]; + HEAP32[$0 + 9052 >> 2] = HEAP32[$0 + 9060 >> 2]; + HEAP32[$0 + 9048 >> 2] = $1; + $2 = HEAP32[$0 + 9052 >> 2]; + $1 = HEAP32[$0 + 9048 >> 2]; + HEAP32[$0 + 1024 >> 2] = $1; + HEAP32[$0 + 1028 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const___invoke_b2Body__28char_20const__2c_20b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const_29($4, $0 + 1024 | 0); + HEAP32[$0 + 3080 >> 2] = 0; + HEAP32[$0 + 3076 >> 2] = 197; + $1 = HEAP32[$0 + 3080 >> 2]; + $2 = HEAP32[$0 + 3076 >> 2]; + HEAP32[$0 + 8416 >> 2] = $2; + HEAP32[$0 + 8420 >> 2] = $1; + $1 = HEAP32[$0 + 8416 >> 2]; + $2 = HEAP32[$0 + 8420 >> 2]; + HEAP32[$0 + 8444 >> 2] = $3; + HEAP32[$0 + 8440 >> 2] = 7806; + HEAP32[$0 + 8436 >> 2] = $2; + HEAP32[$0 + 8432 >> 2] = $1; + $3 = HEAP32[$0 + 8444 >> 2]; + $4 = HEAP32[$0 + 8440 >> 2]; + $1 = HEAP32[$0 + 8432 >> 2]; + HEAP32[$0 + 8428 >> 2] = HEAP32[$0 + 8436 >> 2]; + HEAP32[$0 + 8424 >> 2] = $1; + $2 = HEAP32[$0 + 8428 >> 2]; + $1 = HEAP32[$0 + 8424 >> 2]; + HEAP32[$0 + 1016 >> 2] = $1; + HEAP32[$0 + 1020 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20float_20_28b2Body____29_28_29_20const_29($4, $0 + 1016 | 0); + HEAP32[$0 + 3072 >> 2] = 0; + HEAP32[$0 + 3068 >> 2] = 198; + $1 = HEAP32[$0 + 3072 >> 2]; + $2 = HEAP32[$0 + 3068 >> 2]; + HEAP32[$0 + 8672 >> 2] = $2; + HEAP32[$0 + 8676 >> 2] = $1; + $1 = HEAP32[$0 + 8672 >> 2]; + $2 = HEAP32[$0 + 8676 >> 2]; + HEAP32[$0 + 8700 >> 2] = $3; + HEAP32[$0 + 8696 >> 2] = 7789; + HEAP32[$0 + 8692 >> 2] = $2; + HEAP32[$0 + 8688 >> 2] = $1; + $3 = HEAP32[$0 + 8700 >> 2]; + $4 = HEAP32[$0 + 8696 >> 2]; + $1 = HEAP32[$0 + 8688 >> 2]; + HEAP32[$0 + 8684 >> 2] = HEAP32[$0 + 8692 >> 2]; + HEAP32[$0 + 8680 >> 2] = $1; + $2 = HEAP32[$0 + 8684 >> 2]; + $1 = HEAP32[$0 + 8680 >> 2]; + HEAP32[$0 + 1008 >> 2] = $1; + HEAP32[$0 + 1012 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28float_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28float_29_29($4, $0 + 1008 | 0); + HEAP32[$0 + 3064 >> 2] = 0; + HEAP32[$0 + 3060 >> 2] = 199; + $1 = HEAP32[$0 + 3064 >> 2]; + $2 = HEAP32[$0 + 3060 >> 2]; + HEAP32[$0 + 8384 >> 2] = $2; + HEAP32[$0 + 8388 >> 2] = $1; + $1 = HEAP32[$0 + 8384 >> 2]; + $2 = HEAP32[$0 + 8388 >> 2]; + HEAP32[$0 + 8412 >> 2] = $3; + HEAP32[$0 + 8408 >> 2] = 7757; + HEAP32[$0 + 8404 >> 2] = $2; + HEAP32[$0 + 8400 >> 2] = $1; + $3 = HEAP32[$0 + 8412 >> 2]; + $4 = HEAP32[$0 + 8408 >> 2]; + $1 = HEAP32[$0 + 8400 >> 2]; + HEAP32[$0 + 8396 >> 2] = HEAP32[$0 + 8404 >> 2]; + HEAP32[$0 + 8392 >> 2] = $1; + $2 = HEAP32[$0 + 8396 >> 2]; + $1 = HEAP32[$0 + 8392 >> 2]; + HEAP32[$0 + 1e3 >> 2] = $1; + HEAP32[$0 + 1004 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20float_20_28b2Body____29_28_29_20const_29($4, $0 + 1e3 | 0); + HEAP32[$0 + 3056 >> 2] = 0; + HEAP32[$0 + 3052 >> 2] = 200; + $1 = HEAP32[$0 + 3056 >> 2]; + $2 = HEAP32[$0 + 3052 >> 2]; + HEAP32[$0 + 8640 >> 2] = $2; + HEAP32[$0 + 8644 >> 2] = $1; + $1 = HEAP32[$0 + 8640 >> 2]; + $2 = HEAP32[$0 + 8644 >> 2]; + HEAP32[$0 + 8668 >> 2] = $3; + HEAP32[$0 + 8664 >> 2] = 7739; + HEAP32[$0 + 8660 >> 2] = $2; + HEAP32[$0 + 8656 >> 2] = $1; + $3 = HEAP32[$0 + 8668 >> 2]; + $4 = HEAP32[$0 + 8664 >> 2]; + $1 = HEAP32[$0 + 8656 >> 2]; + HEAP32[$0 + 8652 >> 2] = HEAP32[$0 + 8660 >> 2]; + HEAP32[$0 + 8648 >> 2] = $1; + $2 = HEAP32[$0 + 8652 >> 2]; + $1 = HEAP32[$0 + 8648 >> 2]; + HEAP32[$0 + 992 >> 2] = $1; + HEAP32[$0 + 996 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28float_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28float_29_29($4, $0 + 992 | 0); + HEAP32[$0 + 3048 >> 2] = 0; + HEAP32[$0 + 3044 >> 2] = 201; + $1 = HEAP32[$0 + 3048 >> 2]; + $2 = HEAP32[$0 + 3044 >> 2]; + HEAP32[$0 + 8352 >> 2] = $2; + HEAP32[$0 + 8356 >> 2] = $1; + $1 = HEAP32[$0 + 8352 >> 2]; + $2 = HEAP32[$0 + 8356 >> 2]; + HEAP32[$0 + 8380 >> 2] = $3; + HEAP32[$0 + 8376 >> 2] = 9703; + HEAP32[$0 + 8372 >> 2] = $2; + HEAP32[$0 + 8368 >> 2] = $1; + $3 = HEAP32[$0 + 8380 >> 2]; + $4 = HEAP32[$0 + 8376 >> 2]; + $1 = HEAP32[$0 + 8368 >> 2]; + HEAP32[$0 + 8364 >> 2] = HEAP32[$0 + 8372 >> 2]; + HEAP32[$0 + 8360 >> 2] = $1; + $2 = HEAP32[$0 + 8364 >> 2]; + $1 = HEAP32[$0 + 8360 >> 2]; + HEAP32[$0 + 984 >> 2] = $1; + HEAP32[$0 + 988 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20float_20_28b2Body____29_28_29_20const_29($4, $0 + 984 | 0); + HEAP32[$0 + 3040 >> 2] = 0; + HEAP32[$0 + 3036 >> 2] = 202; + $1 = HEAP32[$0 + 3040 >> 2]; + $2 = HEAP32[$0 + 3036 >> 2]; + HEAP32[$0 + 8608 >> 2] = $2; + HEAP32[$0 + 8612 >> 2] = $1; + $1 = HEAP32[$0 + 8608 >> 2]; + $2 = HEAP32[$0 + 8612 >> 2]; + HEAP32[$0 + 8636 >> 2] = $3; + HEAP32[$0 + 8632 >> 2] = 9687; + HEAP32[$0 + 8628 >> 2] = $2; + HEAP32[$0 + 8624 >> 2] = $1; + $3 = HEAP32[$0 + 8636 >> 2]; + $4 = HEAP32[$0 + 8632 >> 2]; + $1 = HEAP32[$0 + 8624 >> 2]; + HEAP32[$0 + 8620 >> 2] = HEAP32[$0 + 8628 >> 2]; + HEAP32[$0 + 8616 >> 2] = $1; + $2 = HEAP32[$0 + 8620 >> 2]; + $1 = HEAP32[$0 + 8616 >> 2]; + HEAP32[$0 + 976 >> 2] = $1; + HEAP32[$0 + 980 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28float_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28float_29_29($4, $0 + 976 | 0); + HEAP32[$0 + 3032 >> 2] = 0; + HEAP32[$0 + 3028 >> 2] = 203; + $1 = HEAP32[$0 + 3032 >> 2]; + $2 = HEAP32[$0 + 3028 >> 2]; + HEAP32[$0 + 9232 >> 2] = $2; + HEAP32[$0 + 9236 >> 2] = $1; + $1 = HEAP32[$0 + 9232 >> 2]; + $2 = HEAP32[$0 + 9236 >> 2]; + HEAP32[$0 + 9260 >> 2] = $3; + HEAP32[$0 + 9256 >> 2] = 9237; + HEAP32[$0 + 9252 >> 2] = $2; + HEAP32[$0 + 9248 >> 2] = $1; + $3 = HEAP32[$0 + 9260 >> 2]; + $4 = HEAP32[$0 + 9256 >> 2]; + $1 = HEAP32[$0 + 9248 >> 2]; + HEAP32[$0 + 9244 >> 2] = HEAP32[$0 + 9252 >> 2]; + HEAP32[$0 + 9240 >> 2] = $1; + $2 = HEAP32[$0 + 9244 >> 2]; + $1 = HEAP32[$0 + 9240 >> 2]; + HEAP32[$0 + 968 >> 2] = $1; + HEAP32[$0 + 972 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2BodyType_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28b2BodyType_29_29($4, $0 + 968 | 0); + HEAP32[$0 + 3024 >> 2] = 0; + HEAP32[$0 + 3020 >> 2] = 204; + $1 = HEAP32[$0 + 3024 >> 2]; + $2 = HEAP32[$0 + 3020 >> 2]; + HEAP32[$0 + 9264 >> 2] = $2; + HEAP32[$0 + 9268 >> 2] = $1; + $1 = HEAP32[$0 + 9264 >> 2]; + $2 = HEAP32[$0 + 9268 >> 2]; + HEAP32[$0 + 9292 >> 2] = $3; + HEAP32[$0 + 9288 >> 2] = 9253; + HEAP32[$0 + 9284 >> 2] = $2; + HEAP32[$0 + 9280 >> 2] = $1; + $3 = HEAP32[$0 + 9292 >> 2]; + $4 = HEAP32[$0 + 9288 >> 2]; + $1 = HEAP32[$0 + 9280 >> 2]; + HEAP32[$0 + 9276 >> 2] = HEAP32[$0 + 9284 >> 2]; + HEAP32[$0 + 9272 >> 2] = $1; + $2 = HEAP32[$0 + 9276 >> 2]; + $1 = HEAP32[$0 + 9272 >> 2]; + HEAP32[$0 + 960 >> 2] = $1; + HEAP32[$0 + 964 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2BodyType_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20b2BodyType_20_28b2Body____29_28_29_20const_29($4, $0 + 960 | 0); + HEAP32[$0 + 3016 >> 2] = 0; + HEAP32[$0 + 3012 >> 2] = 205; + $1 = HEAP32[$0 + 3016 >> 2]; + $2 = HEAP32[$0 + 3012 >> 2]; + HEAP32[$0 + 9424 >> 2] = $2; + HEAP32[$0 + 9428 >> 2] = $1; + $1 = HEAP32[$0 + 9424 >> 2]; + $2 = HEAP32[$0 + 9428 >> 2]; + HEAP32[$0 + 9452 >> 2] = $3; + HEAP32[$0 + 9448 >> 2] = 2973; + HEAP32[$0 + 9444 >> 2] = $2; + HEAP32[$0 + 9440 >> 2] = $1; + $3 = HEAP32[$0 + 9452 >> 2]; + $4 = HEAP32[$0 + 9448 >> 2]; + $1 = HEAP32[$0 + 9440 >> 2]; + HEAP32[$0 + 9436 >> 2] = HEAP32[$0 + 9444 >> 2]; + HEAP32[$0 + 9432 >> 2] = $1; + $2 = HEAP32[$0 + 9436 >> 2]; + $1 = HEAP32[$0 + 9432 >> 2]; + HEAP32[$0 + 952 >> 2] = $1; + HEAP32[$0 + 956 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28bool_29_29($4, $0 + 952 | 0); + HEAP32[$0 + 3008 >> 2] = 0; + HEAP32[$0 + 3004 >> 2] = 206; + $1 = HEAP32[$0 + 3008 >> 2]; + $2 = HEAP32[$0 + 3004 >> 2]; + HEAP32[$0 + 9584 >> 2] = $2; + HEAP32[$0 + 9588 >> 2] = $1; + $1 = HEAP32[$0 + 9584 >> 2]; + $2 = HEAP32[$0 + 9588 >> 2]; + HEAP32[$0 + 9612 >> 2] = $3; + HEAP32[$0 + 9608 >> 2] = 2983; + HEAP32[$0 + 9604 >> 2] = $2; + HEAP32[$0 + 9600 >> 2] = $1; + $3 = HEAP32[$0 + 9612 >> 2]; + $4 = HEAP32[$0 + 9608 >> 2]; + $1 = HEAP32[$0 + 9600 >> 2]; + HEAP32[$0 + 9596 >> 2] = HEAP32[$0 + 9604 >> 2]; + HEAP32[$0 + 9592 >> 2] = $1; + $2 = HEAP32[$0 + 9596 >> 2]; + $1 = HEAP32[$0 + 9592 >> 2]; + HEAP32[$0 + 944 >> 2] = $1; + HEAP32[$0 + 948 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20bool_20_28b2Body____29_28_29_20const_29($4, $0 + 944 | 0); + HEAP32[$0 + 3e3 >> 2] = 0; + HEAP32[$0 + 2996 >> 2] = 207; + $1 = HEAP32[$0 + 3e3 >> 2]; + $2 = HEAP32[$0 + 2996 >> 2]; + HEAP32[$0 + 9392 >> 2] = $2; + HEAP32[$0 + 9396 >> 2] = $1; + $1 = HEAP32[$0 + 9392 >> 2]; + $2 = HEAP32[$0 + 9396 >> 2]; + HEAP32[$0 + 9420 >> 2] = $3; + HEAP32[$0 + 9416 >> 2] = 10137; + HEAP32[$0 + 9412 >> 2] = $2; + HEAP32[$0 + 9408 >> 2] = $1; + $3 = HEAP32[$0 + 9420 >> 2]; + $4 = HEAP32[$0 + 9416 >> 2]; + $1 = HEAP32[$0 + 9408 >> 2]; + HEAP32[$0 + 9404 >> 2] = HEAP32[$0 + 9412 >> 2]; + HEAP32[$0 + 9400 >> 2] = $1; + $2 = HEAP32[$0 + 9404 >> 2]; + $1 = HEAP32[$0 + 9400 >> 2]; + HEAP32[$0 + 936 >> 2] = $1; + HEAP32[$0 + 940 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28bool_29_29($4, $0 + 936 | 0); + HEAP32[$0 + 2992 >> 2] = 0; + HEAP32[$0 + 2988 >> 2] = 208; + $1 = HEAP32[$0 + 2992 >> 2]; + $2 = HEAP32[$0 + 2988 >> 2]; + HEAP32[$0 + 9552 >> 2] = $2; + HEAP32[$0 + 9556 >> 2] = $1; + $1 = HEAP32[$0 + 9552 >> 2]; + $2 = HEAP32[$0 + 9556 >> 2]; + HEAP32[$0 + 9580 >> 2] = $3; + HEAP32[$0 + 9576 >> 2] = 10156; + HEAP32[$0 + 9572 >> 2] = $2; + HEAP32[$0 + 9568 >> 2] = $1; + $3 = HEAP32[$0 + 9580 >> 2]; + $4 = HEAP32[$0 + 9576 >> 2]; + $1 = HEAP32[$0 + 9568 >> 2]; + HEAP32[$0 + 9564 >> 2] = HEAP32[$0 + 9572 >> 2]; + HEAP32[$0 + 9560 >> 2] = $1; + $2 = HEAP32[$0 + 9564 >> 2]; + $1 = HEAP32[$0 + 9560 >> 2]; + HEAP32[$0 + 928 >> 2] = $1; + HEAP32[$0 + 932 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20bool_20_28b2Body____29_28_29_20const_29($4, $0 + 928 | 0); + HEAP32[$0 + 2984 >> 2] = 0; + HEAP32[$0 + 2980 >> 2] = 209; + $1 = HEAP32[$0 + 2984 >> 2]; + $2 = HEAP32[$0 + 2980 >> 2]; + HEAP32[$0 + 9360 >> 2] = $2; + HEAP32[$0 + 9364 >> 2] = $1; + $1 = HEAP32[$0 + 9360 >> 2]; + $2 = HEAP32[$0 + 9364 >> 2]; + HEAP32[$0 + 9388 >> 2] = $3; + HEAP32[$0 + 9384 >> 2] = 9725; + HEAP32[$0 + 9380 >> 2] = $2; + HEAP32[$0 + 9376 >> 2] = $1; + $3 = HEAP32[$0 + 9388 >> 2]; + $4 = HEAP32[$0 + 9384 >> 2]; + $1 = HEAP32[$0 + 9376 >> 2]; + HEAP32[$0 + 9372 >> 2] = HEAP32[$0 + 9380 >> 2]; + HEAP32[$0 + 9368 >> 2] = $1; + $2 = HEAP32[$0 + 9372 >> 2]; + $1 = HEAP32[$0 + 9368 >> 2]; + HEAP32[$0 + 920 >> 2] = $1; + HEAP32[$0 + 924 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28bool_29_29($4, $0 + 920 | 0); + HEAP32[$0 + 2976 >> 2] = 0; + HEAP32[$0 + 2972 >> 2] = 210; + $1 = HEAP32[$0 + 2976 >> 2]; + $2 = HEAP32[$0 + 2972 >> 2]; + HEAP32[$0 + 9520 >> 2] = $2; + HEAP32[$0 + 9524 >> 2] = $1; + $1 = HEAP32[$0 + 9520 >> 2]; + $2 = HEAP32[$0 + 9524 >> 2]; + HEAP32[$0 + 9548 >> 2] = $3; + HEAP32[$0 + 9544 >> 2] = 9734; + HEAP32[$0 + 9540 >> 2] = $2; + HEAP32[$0 + 9536 >> 2] = $1; + $3 = HEAP32[$0 + 9548 >> 2]; + $4 = HEAP32[$0 + 9544 >> 2]; + $1 = HEAP32[$0 + 9536 >> 2]; + HEAP32[$0 + 9532 >> 2] = HEAP32[$0 + 9540 >> 2]; + HEAP32[$0 + 9528 >> 2] = $1; + $2 = HEAP32[$0 + 9532 >> 2]; + $1 = HEAP32[$0 + 9528 >> 2]; + HEAP32[$0 + 912 >> 2] = $1; + HEAP32[$0 + 916 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20bool_20_28b2Body____29_28_29_20const_29($4, $0 + 912 | 0); + HEAP32[$0 + 2968 >> 2] = 0; + HEAP32[$0 + 2964 >> 2] = 211; + $1 = HEAP32[$0 + 2968 >> 2]; + $2 = HEAP32[$0 + 2964 >> 2]; + HEAP32[$0 + 9328 >> 2] = $2; + HEAP32[$0 + 9332 >> 2] = $1; + $1 = HEAP32[$0 + 9328 >> 2]; + $2 = HEAP32[$0 + 9332 >> 2]; + HEAP32[$0 + 9356 >> 2] = $3; + HEAP32[$0 + 9352 >> 2] = 10253; + HEAP32[$0 + 9348 >> 2] = $2; + HEAP32[$0 + 9344 >> 2] = $1; + $3 = HEAP32[$0 + 9356 >> 2]; + $4 = HEAP32[$0 + 9352 >> 2]; + $1 = HEAP32[$0 + 9344 >> 2]; + HEAP32[$0 + 9340 >> 2] = HEAP32[$0 + 9348 >> 2]; + HEAP32[$0 + 9336 >> 2] = $1; + $2 = HEAP32[$0 + 9340 >> 2]; + $1 = HEAP32[$0 + 9336 >> 2]; + HEAP32[$0 + 904 >> 2] = $1; + HEAP32[$0 + 908 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28bool_29_29($4, $0 + 904 | 0); + HEAP32[$0 + 2960 >> 2] = 0; + HEAP32[$0 + 2956 >> 2] = 212; + $1 = HEAP32[$0 + 2960 >> 2]; + $2 = HEAP32[$0 + 2956 >> 2]; + HEAP32[$0 + 9488 >> 2] = $2; + HEAP32[$0 + 9492 >> 2] = $1; + $1 = HEAP32[$0 + 9488 >> 2]; + $2 = HEAP32[$0 + 9492 >> 2]; + HEAP32[$0 + 9516 >> 2] = $3; + HEAP32[$0 + 9512 >> 2] = 10264; + HEAP32[$0 + 9508 >> 2] = $2; + HEAP32[$0 + 9504 >> 2] = $1; + $3 = HEAP32[$0 + 9516 >> 2]; + $4 = HEAP32[$0 + 9512 >> 2]; + $1 = HEAP32[$0 + 9504 >> 2]; + HEAP32[$0 + 9500 >> 2] = HEAP32[$0 + 9508 >> 2]; + HEAP32[$0 + 9496 >> 2] = $1; + $2 = HEAP32[$0 + 9500 >> 2]; + $1 = HEAP32[$0 + 9496 >> 2]; + HEAP32[$0 + 896 >> 2] = $1; + HEAP32[$0 + 900 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20bool_20_28b2Body____29_28_29_20const_29($4, $0 + 896 | 0); + HEAP32[$0 + 2952 >> 2] = 0; + HEAP32[$0 + 2948 >> 2] = 213; + $1 = HEAP32[$0 + 2952 >> 2]; + $2 = HEAP32[$0 + 2948 >> 2]; + HEAP32[$0 + 9296 >> 2] = $2; + HEAP32[$0 + 9300 >> 2] = $1; + $1 = HEAP32[$0 + 9296 >> 2]; + $2 = HEAP32[$0 + 9300 >> 2]; + HEAP32[$0 + 9324 >> 2] = $3; + HEAP32[$0 + 9320 >> 2] = 6632; + HEAP32[$0 + 9316 >> 2] = $2; + HEAP32[$0 + 9312 >> 2] = $1; + $3 = HEAP32[$0 + 9324 >> 2]; + $4 = HEAP32[$0 + 9320 >> 2]; + $1 = HEAP32[$0 + 9312 >> 2]; + HEAP32[$0 + 9308 >> 2] = HEAP32[$0 + 9316 >> 2]; + HEAP32[$0 + 9304 >> 2] = $1; + $2 = HEAP32[$0 + 9308 >> 2]; + $1 = HEAP32[$0 + 9304 >> 2]; + HEAP32[$0 + 888 >> 2] = $1; + HEAP32[$0 + 892 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28bool_29_29($4, $0 + 888 | 0); + HEAP32[$0 + 2944 >> 2] = 0; + HEAP32[$0 + 2940 >> 2] = 214; + $1 = HEAP32[$0 + 2944 >> 2]; + $2 = HEAP32[$0 + 2940 >> 2]; + HEAP32[$0 + 9456 >> 2] = $2; + HEAP32[$0 + 9460 >> 2] = $1; + $1 = HEAP32[$0 + 9456 >> 2]; + $2 = HEAP32[$0 + 9460 >> 2]; + HEAP32[$0 + 9484 >> 2] = $3; + HEAP32[$0 + 9480 >> 2] = 6649; + HEAP32[$0 + 9476 >> 2] = $2; + HEAP32[$0 + 9472 >> 2] = $1; + $3 = HEAP32[$0 + 9484 >> 2]; + $4 = HEAP32[$0 + 9480 >> 2]; + $1 = HEAP32[$0 + 9472 >> 2]; + HEAP32[$0 + 9468 >> 2] = HEAP32[$0 + 9476 >> 2]; + HEAP32[$0 + 9464 >> 2] = $1; + $2 = HEAP32[$0 + 9468 >> 2]; + $1 = HEAP32[$0 + 9464 >> 2]; + HEAP32[$0 + 880 >> 2] = $1; + HEAP32[$0 + 884 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20bool_20_28b2Body____29_28_29_20const_29($4, $0 + 880 | 0); + HEAP32[$0 + 2932 >> 2] = 0; + HEAP32[$0 + 2928 >> 2] = 215; + $1 = HEAP32[$0 + 2932 >> 2]; + $2 = HEAP32[$0 + 2928 >> 2]; + HEAP32[$0 + 9616 >> 2] = $2; + HEAP32[$0 + 9620 >> 2] = $1; + $1 = HEAP32[$0 + 9616 >> 2]; + $2 = HEAP32[$0 + 9620 >> 2]; + HEAP32[$0 + 9644 >> 2] = $3; + HEAP32[$0 + 9640 >> 2] = 1851; + HEAP32[$0 + 9636 >> 2] = $2; + HEAP32[$0 + 9632 >> 2] = $1; + $3 = HEAP32[$0 + 9644 >> 2]; + $4 = HEAP32[$0 + 9640 >> 2]; + $1 = HEAP32[$0 + 9632 >> 2]; + HEAP32[$0 + 9628 >> 2] = HEAP32[$0 + 9636 >> 2]; + HEAP32[$0 + 9624 >> 2] = $1; + $2 = HEAP32[$0 + 9628 >> 2]; + $1 = HEAP32[$0 + 9624 >> 2]; + HEAP32[$0 + 872 >> 2] = $1; + HEAP32[$0 + 876 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Fixture__20_28b2Body____29_28_29___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Fixture__20_28b2Body____29_28_29_29($4, $0 + 872 | 0); + HEAP32[$0 + 2920 >> 2] = 0; + HEAP32[$0 + 2916 >> 2] = 216; + $1 = HEAP32[$0 + 2920 >> 2]; + $2 = HEAP32[$0 + 2916 >> 2]; + HEAP32[$0 + 9648 >> 2] = $2; + HEAP32[$0 + 9652 >> 2] = $1; + $1 = HEAP32[$0 + 9648 >> 2]; + $2 = HEAP32[$0 + 9652 >> 2]; + HEAP32[$0 + 9680 >> 2] = $3; + HEAP32[$0 + 9676 >> 2] = 10056; + HEAP32[$0 + 9672 >> 2] = $2; + HEAP32[$0 + 9668 >> 2] = $1; + $3 = HEAP32[$0 + 9680 >> 2]; + $4 = HEAP32[$0 + 9676 >> 2]; + $1 = HEAP32[$0 + 9668 >> 2]; + HEAP32[$0 + 9664 >> 2] = HEAP32[$0 + 9672 >> 2]; + HEAP32[$0 + 9660 >> 2] = $1; + $2 = HEAP32[$0 + 9664 >> 2]; + $1 = HEAP32[$0 + 9660 >> 2]; + HEAP32[$0 + 864 >> 2] = $1; + HEAP32[$0 + 868 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2World__20_28b2Body____29_28_29___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2World__20_28b2Body____29_28_29_29($4, $0 + 864 | 0); + HEAP32[$0 + 2912 >> 2] = 0; + HEAP32[$0 + 2908 >> 2] = 217; + $1 = HEAP32[$0 + 2912 >> 2]; + $2 = HEAP32[$0 + 2908 >> 2]; + HEAP32[$0 + 8976 >> 2] = $2; + HEAP32[$0 + 8980 >> 2] = $1; + $1 = HEAP32[$0 + 8976 >> 2]; + $2 = HEAP32[$0 + 8980 >> 2]; + HEAP32[$0 + 9004 >> 2] = $3; + HEAP32[$0 + 9e3 >> 2] = 6232; + HEAP32[$0 + 8996 >> 2] = $2; + HEAP32[$0 + 8992 >> 2] = $1; + $3 = HEAP32[$0 + 9e3 >> 2]; + $1 = HEAP32[$0 + 8992 >> 2]; + HEAP32[$0 + 8988 >> 2] = HEAP32[$0 + 8996 >> 2]; + HEAP32[$0 + 8984 >> 2] = $1; + $2 = HEAP32[$0 + 8988 >> 2]; + $1 = HEAP32[$0 + 8984 >> 2]; + HEAP32[$0 + 856 >> 2] = $1; + HEAP32[$0 + 860 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28_29_29($3, $0 + 856 | 0); + HEAP32[$0 + 9704 >> 2] = $0 + 2907; + HEAP32[$0 + 9700 >> 2] = 7998; + void_20emscripten__internal__NoBaseClass__verify_b2JointDef__28_29(); + HEAP32[$0 + 9696 >> 2] = 218; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2JointDef__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 9692 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2JointDef__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 9688 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 9684 >> 2] = 219; + $1 = emscripten__internal__TypeID_b2JointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2JointDef__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2JointDef_20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$0 + 15576 >> 2] = HEAP32[$0 + 9696 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 9696 >> 2]; + HEAP32[$0 + 14724 >> 2] = HEAP32[$0 + 9692 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$0 + 9692 >> 2]; + HEAP32[$0 + 14720 >> 2] = HEAP32[$0 + 9688 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$0 + 9688 >> 2]; + $11 = HEAP32[$0 + 9700 >> 2]; + HEAP32[$0 + 15580 >> 2] = HEAP32[$0 + 9684 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 9684 >> 2]); + HEAP32[$0 + 9708 >> 2] = $0 + 2907; + HEAP32[$0 + 15588 >> 2] = HEAP32[$0 + 9708 >> 2]; + HEAP32[$0 + 15584 >> 2] = 220; + $1 = HEAP32[$0 + 15588 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2JointDef__20_28__29_28_29___invoke_b2JointDef__28b2JointDef__20_28__29_28_29_29(HEAP32[$0 + 15584 >> 2]); + HEAP32[$0 + 9728 >> 2] = $1; + HEAP32[$0 + 9724 >> 2] = 9223; + HEAP32[$0 + 9720 >> 2] = 0; + $1 = HEAP32[$0 + 9728 >> 2]; + HEAP32[$0 + 9716 >> 2] = 221; + HEAP32[$0 + 9712 >> 2] = 222; + $2 = emscripten__internal__TypeID_b2JointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 9724 >> 2]; + $4 = emscripten__internal__TypeID_b2JointType_2c_20void___get_28_29(); + HEAP32[$0 + 15592 >> 2] = HEAP32[$0 + 9716 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 9716 >> 2]; + $7 = b2JointType_20b2JointDef_____20emscripten__internal__getContext_b2JointType_20b2JointDef_____28b2JointType_20b2JointDef____20const__29($0 + 9720 | 0); + $8 = emscripten__internal__TypeID_b2JointType_2c_20void___get_28_29(); + HEAP32[$0 + 15596 >> 2] = HEAP32[$0 + 9712 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 9712 >> 2], b2JointType_20b2JointDef_____20emscripten__internal__getContext_b2JointType_20b2JointDef_____28b2JointType_20b2JointDef____20const__29($0 + 9720 | 0) | 0); + $2 = emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_8__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_8__28embind_init_b2_28_29__$_8_20const__29($0 + 2906 | 0); + HEAP32[$0 + 9752 >> 2] = $1; + HEAP32[$0 + 9748 >> 2] = 11104; + HEAP32[$0 + 9744 >> 2] = $2; + $1 = HEAP32[$0 + 9752 >> 2]; + void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2JointDef__2c_20b2Body__29___invoke_b2JointDef_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2JointDef__2c_20b2Body__29_29(HEAP32[$0 + 9748 >> 2], HEAP32[$0 + 9744 >> 2]); + $2 = emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_9__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_9__28embind_init_b2_28_29__$_9_20const__29($0 + 2904 | 0); + HEAP32[$0 + 9776 >> 2] = $1; + HEAP32[$0 + 9772 >> 2] = 11113; + HEAP32[$0 + 9768 >> 2] = $2; + $1 = HEAP32[$0 + 9776 >> 2]; + void_20emscripten__internal__RegisterClassMethod_b2Body__20_28__29_28b2JointDef__29___invoke_b2JointDef_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Body__20_28__29_28b2JointDef__29_29(HEAP32[$0 + 9772 >> 2], HEAP32[$0 + 9768 >> 2]); + $2 = emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_10__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_10__28embind_init_b2_28_29__$_10_20const__29($0 + 2902 | 0); + HEAP32[$0 + 9740 >> 2] = $1; + HEAP32[$0 + 9736 >> 2] = 10986; + HEAP32[$0 + 9732 >> 2] = $2; + $1 = HEAP32[$0 + 9740 >> 2]; + void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2JointDef__2c_20b2Body__29___invoke_b2JointDef_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2JointDef__2c_20b2Body__29_29(HEAP32[$0 + 9736 >> 2], HEAP32[$0 + 9732 >> 2]); + $2 = emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_11__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_11__28embind_init_b2_28_29__$_11_20const__29($0 + 2900 | 0); + HEAP32[$0 + 9764 >> 2] = $1; + HEAP32[$0 + 9760 >> 2] = 10995; + HEAP32[$0 + 9756 >> 2] = $2; + $1 = HEAP32[$0 + 9764 >> 2]; + void_20emscripten__internal__RegisterClassMethod_b2Body__20_28__29_28b2JointDef__29___invoke_b2JointDef_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Body__20_28__29_28b2JointDef__29_29(HEAP32[$0 + 9760 >> 2], HEAP32[$0 + 9756 >> 2]); + HEAP32[$0 + 9796 >> 2] = $1; + HEAP32[$0 + 9792 >> 2] = 10194; + HEAP32[$0 + 9788 >> 2] = 16; + HEAP32[$0 + 9784 >> 2] = 223; + HEAP32[$0 + 9780 >> 2] = 224; + $1 = emscripten__internal__TypeID_b2JointDef_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 9792 >> 2]; + $3 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15600 >> 2] = HEAP32[$0 + 9784 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $5 = HEAP32[$0 + 9784 >> 2]; + $6 = bool_20b2JointDef_____20emscripten__internal__getContext_bool_20b2JointDef_____28bool_20b2JointDef____20const__29($0 + 9788 | 0); + $7 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15604 >> 2] = HEAP32[$0 + 9780 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 9780 >> 2], bool_20b2JointDef_____20emscripten__internal__getContext_bool_20b2JointDef_____28bool_20b2JointDef____20const__29($0 + 9788 | 0) | 0); + HEAP32[$0 + 9820 >> 2] = $0 + 2898; + HEAP32[$0 + 9816 >> 2] = 2780; + void_20emscripten__internal__NoBaseClass__verify_b2Joint__28_29(); + HEAP32[$0 + 9812 >> 2] = 225; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2Joint__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 9808 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2Joint__28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 9804 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 9800 >> 2] = 226; + $1 = emscripten__internal__TypeID_b2Joint_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Joint__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$0 + 15608 >> 2] = HEAP32[$0 + 9812 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 9812 >> 2]; + HEAP32[$0 + 14716 >> 2] = HEAP32[$0 + 9808 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$0 + 9808 >> 2]; + HEAP32[$0 + 14712 >> 2] = HEAP32[$0 + 9804 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$0 + 9804 >> 2]; + $11 = HEAP32[$0 + 9816 >> 2]; + HEAP32[$0 + 15612 >> 2] = HEAP32[$0 + 9800 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 9800 >> 2]); + HEAP32[$0 + 2892 >> 2] = 0; + HEAP32[$0 + 2888 >> 2] = 227; + $1 = HEAP32[$0 + 2892 >> 2]; + $2 = HEAP32[$0 + 2888 >> 2]; + HEAP32[$0 + 9824 >> 2] = $2; + HEAP32[$0 + 9828 >> 2] = $1; + $1 = HEAP32[$0 + 9824 >> 2]; + $2 = HEAP32[$0 + 9828 >> 2]; + HEAP32[$0 + 9852 >> 2] = $0 + 2898; + HEAP32[$0 + 9848 >> 2] = 9253; + HEAP32[$0 + 9844 >> 2] = $2; + HEAP32[$0 + 9840 >> 2] = $1; + $3 = HEAP32[$0 + 9852 >> 2]; + $4 = HEAP32[$0 + 9848 >> 2]; + $1 = HEAP32[$0 + 9840 >> 2]; + HEAP32[$0 + 9836 >> 2] = HEAP32[$0 + 9844 >> 2]; + HEAP32[$0 + 9832 >> 2] = $1; + $2 = HEAP32[$0 + 9836 >> 2]; + $1 = HEAP32[$0 + 9832 >> 2]; + HEAP32[$0 + 848 >> 2] = $1; + HEAP32[$0 + 852 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2JointType_20_28b2Joint____29_28_29_20const___invoke_b2Joint__28char_20const__2c_20b2JointType_20_28b2Joint____29_28_29_20const_29($4, $0 + 848 | 0); + HEAP32[$0 + 2880 >> 2] = 0; + HEAP32[$0 + 2876 >> 2] = 228; + $1 = HEAP32[$0 + 2880 >> 2]; + $2 = HEAP32[$0 + 2876 >> 2]; + HEAP32[$0 + 9888 >> 2] = $2; + HEAP32[$0 + 9892 >> 2] = $1; + $1 = HEAP32[$0 + 9888 >> 2]; + $2 = HEAP32[$0 + 9892 >> 2]; + HEAP32[$0 + 9916 >> 2] = $3; + HEAP32[$0 + 9912 >> 2] = 11113; + HEAP32[$0 + 9908 >> 2] = $2; + HEAP32[$0 + 9904 >> 2] = $1; + $3 = HEAP32[$0 + 9916 >> 2]; + $4 = HEAP32[$0 + 9912 >> 2]; + $1 = HEAP32[$0 + 9904 >> 2]; + HEAP32[$0 + 9900 >> 2] = HEAP32[$0 + 9908 >> 2]; + HEAP32[$0 + 9896 >> 2] = $1; + $2 = HEAP32[$0 + 9900 >> 2]; + $1 = HEAP32[$0 + 9896 >> 2]; + HEAP32[$0 + 840 >> 2] = $1; + HEAP32[$0 + 844 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Body__20_28b2Joint____29_28_29___invoke_b2Joint_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Body__20_28b2Joint____29_28_29_29($4, $0 + 840 | 0); + HEAP32[$0 + 2868 >> 2] = 0; + HEAP32[$0 + 2864 >> 2] = 229; + $1 = HEAP32[$0 + 2868 >> 2]; + $2 = HEAP32[$0 + 2864 >> 2]; + HEAP32[$0 + 9856 >> 2] = $2; + HEAP32[$0 + 9860 >> 2] = $1; + $1 = HEAP32[$0 + 9856 >> 2]; + $2 = HEAP32[$0 + 9860 >> 2]; + HEAP32[$0 + 9884 >> 2] = $3; + HEAP32[$0 + 9880 >> 2] = 10995; + HEAP32[$0 + 9876 >> 2] = $2; + HEAP32[$0 + 9872 >> 2] = $1; + $3 = HEAP32[$0 + 9884 >> 2]; + $4 = HEAP32[$0 + 9880 >> 2]; + $1 = HEAP32[$0 + 9872 >> 2]; + HEAP32[$0 + 9868 >> 2] = HEAP32[$0 + 9876 >> 2]; + HEAP32[$0 + 9864 >> 2] = $1; + $2 = HEAP32[$0 + 9868 >> 2]; + $1 = HEAP32[$0 + 9864 >> 2]; + HEAP32[$0 + 832 >> 2] = $1; + HEAP32[$0 + 836 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Body__20_28b2Joint____29_28_29___invoke_b2Joint_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Body__20_28b2Joint____29_28_29_29($4, $0 + 832 | 0); + HEAP32[$0 + 2856 >> 2] = 1; + HEAP32[$0 + 2852 >> 2] = 0; + $1 = HEAP32[$0 + 2856 >> 2]; + $2 = HEAP32[$0 + 2852 >> 2]; + HEAP32[$0 + 9952 >> 2] = $2; + HEAP32[$0 + 9956 >> 2] = $1; + $1 = HEAP32[$0 + 9952 >> 2]; + $2 = HEAP32[$0 + 9956 >> 2]; + HEAP32[$0 + 9980 >> 2] = $3; + HEAP32[$0 + 9976 >> 2] = 11147; + HEAP32[$0 + 9972 >> 2] = $2; + HEAP32[$0 + 9968 >> 2] = $1; + $3 = HEAP32[$0 + 9980 >> 2]; + $4 = HEAP32[$0 + 9976 >> 2]; + $1 = HEAP32[$0 + 9968 >> 2]; + HEAP32[$0 + 9964 >> 2] = HEAP32[$0 + 9972 >> 2]; + HEAP32[$0 + 9960 >> 2] = $1; + $2 = HEAP32[$0 + 9964 >> 2]; + $1 = HEAP32[$0 + 9960 >> 2]; + HEAP32[$0 + 824 >> 2] = $1; + HEAP32[$0 + 828 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2Joint____29_28_29_20const___invoke_b2Joint_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Vec2_20_28b2Joint____29_28_29_20const_29($4, $0 + 824 | 0); + HEAP32[$0 + 2844 >> 2] = 1; + HEAP32[$0 + 2840 >> 2] = 4; + $1 = HEAP32[$0 + 2844 >> 2]; + $2 = HEAP32[$0 + 2840 >> 2]; + HEAP32[$0 + 9920 >> 2] = $2; + HEAP32[$0 + 9924 >> 2] = $1; + $1 = HEAP32[$0 + 9920 >> 2]; + $2 = HEAP32[$0 + 9924 >> 2]; + HEAP32[$0 + 9948 >> 2] = $3; + HEAP32[$0 + 9944 >> 2] = 11004; + HEAP32[$0 + 9940 >> 2] = $2; + HEAP32[$0 + 9936 >> 2] = $1; + $3 = HEAP32[$0 + 9948 >> 2]; + $4 = HEAP32[$0 + 9944 >> 2]; + $1 = HEAP32[$0 + 9936 >> 2]; + HEAP32[$0 + 9932 >> 2] = HEAP32[$0 + 9940 >> 2]; + HEAP32[$0 + 9928 >> 2] = $1; + $2 = HEAP32[$0 + 9932 >> 2]; + $1 = HEAP32[$0 + 9928 >> 2]; + HEAP32[$0 + 816 >> 2] = $1; + HEAP32[$0 + 820 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2Joint____29_28_29_20const___invoke_b2Joint_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Vec2_20_28b2Joint____29_28_29_20const_29($4, $0 + 816 | 0); + HEAP32[$0 + 2836 >> 2] = 1; + HEAP32[$0 + 2832 >> 2] = 8; + $1 = HEAP32[$0 + 2836 >> 2]; + $2 = HEAP32[$0 + 2832 >> 2]; + HEAP32[$0 + 9984 >> 2] = $2; + HEAP32[$0 + 9988 >> 2] = $1; + $1 = HEAP32[$0 + 9984 >> 2]; + $2 = HEAP32[$0 + 9988 >> 2]; + HEAP32[$0 + 10012 >> 2] = $3; + HEAP32[$0 + 10008 >> 2] = 9958; + HEAP32[$0 + 10004 >> 2] = $2; + HEAP32[$0 + 1e4 >> 2] = $1; + $3 = HEAP32[$0 + 10012 >> 2]; + $4 = HEAP32[$0 + 10008 >> 2]; + $1 = HEAP32[$0 + 1e4 >> 2]; + HEAP32[$0 + 9996 >> 2] = HEAP32[$0 + 10004 >> 2]; + HEAP32[$0 + 9992 >> 2] = $1; + $2 = HEAP32[$0 + 9996 >> 2]; + $1 = HEAP32[$0 + 9992 >> 2]; + HEAP32[$0 + 808 >> 2] = $1; + HEAP32[$0 + 812 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2Joint____29_28float_29_20const___invoke_b2Joint__28char_20const__2c_20b2Vec2_20_28b2Joint____29_28float_29_20const_29($4, $0 + 808 | 0); + HEAP32[$0 + 2828 >> 2] = 1; + HEAP32[$0 + 2824 >> 2] = 12; + $1 = HEAP32[$0 + 2828 >> 2]; + $2 = HEAP32[$0 + 2824 >> 2]; + HEAP32[$0 + 10016 >> 2] = $2; + HEAP32[$0 + 10020 >> 2] = $1; + $1 = HEAP32[$0 + 10016 >> 2]; + $2 = HEAP32[$0 + 10020 >> 2]; + HEAP32[$0 + 10044 >> 2] = $3; + HEAP32[$0 + 10040 >> 2] = 8857; + HEAP32[$0 + 10036 >> 2] = $2; + HEAP32[$0 + 10032 >> 2] = $1; + $3 = HEAP32[$0 + 10044 >> 2]; + $4 = HEAP32[$0 + 10040 >> 2]; + $1 = HEAP32[$0 + 10032 >> 2]; + HEAP32[$0 + 10028 >> 2] = HEAP32[$0 + 10036 >> 2]; + HEAP32[$0 + 10024 >> 2] = $1; + $2 = HEAP32[$0 + 10028 >> 2]; + $1 = HEAP32[$0 + 10024 >> 2]; + HEAP32[$0 + 800 >> 2] = $1; + HEAP32[$0 + 804 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2Joint____29_28float_29_20const___invoke_b2Joint__28char_20const__2c_20float_20_28b2Joint____29_28float_29_20const_29($4, $0 + 800 | 0); + HEAP32[$0 + 2820 >> 2] = 0; + HEAP32[$0 + 2816 >> 2] = 230; + $1 = HEAP32[$0 + 2820 >> 2]; + $2 = HEAP32[$0 + 2816 >> 2]; + HEAP32[$0 + 10048 >> 2] = $2; + HEAP32[$0 + 10052 >> 2] = $1; + $1 = HEAP32[$0 + 10048 >> 2]; + $2 = HEAP32[$0 + 10052 >> 2]; + HEAP32[$0 + 10076 >> 2] = $3; + HEAP32[$0 + 10072 >> 2] = 10211; + HEAP32[$0 + 10068 >> 2] = $2; + HEAP32[$0 + 10064 >> 2] = $1; + $3 = HEAP32[$0 + 10076 >> 2]; + $4 = HEAP32[$0 + 10072 >> 2]; + $1 = HEAP32[$0 + 10064 >> 2]; + HEAP32[$0 + 10060 >> 2] = HEAP32[$0 + 10068 >> 2]; + HEAP32[$0 + 10056 >> 2] = $1; + $2 = HEAP32[$0 + 10060 >> 2]; + $1 = HEAP32[$0 + 10056 >> 2]; + HEAP32[$0 + 792 >> 2] = $1; + HEAP32[$0 + 796 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Joint____29_28_29_20const___invoke_b2Joint__28char_20const__2c_20bool_20_28b2Joint____29_28_29_20const_29($4, $0 + 792 | 0); + HEAP32[$0 + 2812 >> 2] = 1; + HEAP32[$0 + 2808 >> 2] = 16; + $1 = HEAP32[$0 + 2812 >> 2]; + $2 = HEAP32[$0 + 2808 >> 2]; + HEAP32[$0 + 10080 >> 2] = $2; + HEAP32[$0 + 10084 >> 2] = $1; + $1 = HEAP32[$0 + 10080 >> 2]; + $2 = HEAP32[$0 + 10084 >> 2]; + HEAP32[$0 + 10108 >> 2] = $3; + HEAP32[$0 + 10104 >> 2] = 6232; + HEAP32[$0 + 10100 >> 2] = $2; + HEAP32[$0 + 10096 >> 2] = $1; + $3 = HEAP32[$0 + 10104 >> 2]; + $1 = HEAP32[$0 + 10096 >> 2]; + HEAP32[$0 + 10092 >> 2] = HEAP32[$0 + 10100 >> 2]; + HEAP32[$0 + 10088 >> 2] = $1; + $2 = HEAP32[$0 + 10092 >> 2]; + $1 = HEAP32[$0 + 10088 >> 2]; + HEAP32[$0 + 784 >> 2] = $1; + HEAP32[$0 + 788 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2Joint____29_28_29___invoke_b2Joint__28char_20const__2c_20void_20_28b2Joint____29_28_29_29($3, $0 + 784 | 0); + HEAP32[$0 + 10132 >> 2] = $0 + 2807; + HEAP32[$0 + 10128 >> 2] = 7959; + void_20emscripten__base_b2JointDef___verify_b2DistanceJointDef__28_29(); + HEAP32[$0 + 10124 >> 2] = 231; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2DistanceJointDef__28_29_29_28b2DistanceJointDef__29(), + HEAP32[wasm2js_i32$0 + 10120 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2DistanceJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2DistanceJointDef__28_29_29_28b2JointDef__29(), + HEAP32[wasm2js_i32$0 + 10116 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 10112 >> 2] = 232; + $1 = emscripten__internal__TypeID_b2DistanceJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2DistanceJointDef__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2DistanceJointDef_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2JointDef___get_28_29(); + HEAP32[$0 + 15616 >> 2] = HEAP32[$0 + 10124 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 10124 >> 2]; + HEAP32[$0 + 15620 >> 2] = HEAP32[$0 + 10120 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 10120 >> 2]; + HEAP32[$0 + 15624 >> 2] = HEAP32[$0 + 10116 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 10116 >> 2]; + $11 = HEAP32[$0 + 10128 >> 2]; + HEAP32[$0 + 15628 >> 2] = HEAP32[$0 + 10112 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 10112 >> 2]); + HEAP32[$0 + 10136 >> 2] = $0 + 2807; + HEAP32[$0 + 15636 >> 2] = HEAP32[$0 + 10136 >> 2]; + HEAP32[$0 + 15632 >> 2] = 233; + $1 = HEAP32[$0 + 15636 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2DistanceJointDef__20_28__29_28_29___invoke_b2DistanceJointDef__28b2DistanceJointDef__20_28__29_28_29_29(HEAP32[$0 + 15632 >> 2]); + HEAP32[$0 + 10176 >> 2] = $1; + HEAP32[$0 + 10172 >> 2] = 11158; + HEAP32[$0 + 10168 >> 2] = 20; + $1 = HEAP32[$0 + 10176 >> 2]; + HEAP32[$0 + 10164 >> 2] = 234; + HEAP32[$0 + 10160 >> 2] = 235; + $2 = emscripten__internal__TypeID_b2DistanceJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 10172 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15640 >> 2] = HEAP32[$0 + 10164 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 10164 >> 2]; + $7 = b2Vec2_20b2DistanceJointDef_____20emscripten__internal__getContext_b2Vec2_20b2DistanceJointDef_____28b2Vec2_20b2DistanceJointDef____20const__29($0 + 10168 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15648 >> 2] = HEAP32[$0 + 10160 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 10160 >> 2], b2Vec2_20b2DistanceJointDef_____20emscripten__internal__getContext_b2Vec2_20b2DistanceJointDef_____28b2Vec2_20b2DistanceJointDef____20const__29($0 + 10168 | 0) | 0); + HEAP32[$0 + 10156 >> 2] = $1; + HEAP32[$0 + 10152 >> 2] = 11015; + HEAP32[$0 + 10148 >> 2] = 28; + $1 = HEAP32[$0 + 10156 >> 2]; + HEAP32[$0 + 10144 >> 2] = 234; + HEAP32[$0 + 10140 >> 2] = 235; + $2 = emscripten__internal__TypeID_b2DistanceJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 10152 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15644 >> 2] = HEAP32[$0 + 10144 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 10144 >> 2]; + $7 = b2Vec2_20b2DistanceJointDef_____20emscripten__internal__getContext_b2Vec2_20b2DistanceJointDef_____28b2Vec2_20b2DistanceJointDef____20const__29($0 + 10148 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15652 >> 2] = HEAP32[$0 + 10140 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 10140 >> 2], b2Vec2_20b2DistanceJointDef_____20emscripten__internal__getContext_b2Vec2_20b2DistanceJointDef_____28b2Vec2_20b2DistanceJointDef____20const__29($0 + 10148 | 0) | 0); + HEAP32[$0 + 10236 >> 2] = $1; + HEAP32[$0 + 10232 >> 2] = 7047; + HEAP32[$0 + 10228 >> 2] = 36; + $1 = HEAP32[$0 + 10236 >> 2]; + HEAP32[$0 + 10224 >> 2] = 236; + HEAP32[$0 + 10220 >> 2] = 237; + $2 = emscripten__internal__TypeID_b2DistanceJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 10232 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15656 >> 2] = HEAP32[$0 + 10224 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 10224 >> 2]; + $7 = float_20b2DistanceJointDef_____20emscripten__internal__getContext_float_20b2DistanceJointDef_____28float_20b2DistanceJointDef____20const__29($0 + 10228 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15668 >> 2] = HEAP32[$0 + 10220 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 10220 >> 2], float_20b2DistanceJointDef_____20emscripten__internal__getContext_float_20b2DistanceJointDef_____28float_20b2DistanceJointDef____20const__29($0 + 10228 | 0) | 0); + HEAP32[$0 + 10216 >> 2] = $1; + HEAP32[$0 + 10212 >> 2] = 3387; + HEAP32[$0 + 10208 >> 2] = 40; + $1 = HEAP32[$0 + 10216 >> 2]; + HEAP32[$0 + 10204 >> 2] = 236; + HEAP32[$0 + 10200 >> 2] = 237; + $2 = emscripten__internal__TypeID_b2DistanceJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 10212 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15660 >> 2] = HEAP32[$0 + 10204 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 10204 >> 2]; + $7 = float_20b2DistanceJointDef_____20emscripten__internal__getContext_float_20b2DistanceJointDef_____28float_20b2DistanceJointDef____20const__29($0 + 10208 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15672 >> 2] = HEAP32[$0 + 10200 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 10200 >> 2], float_20b2DistanceJointDef_____20emscripten__internal__getContext_float_20b2DistanceJointDef_____28float_20b2DistanceJointDef____20const__29($0 + 10208 | 0) | 0); + HEAP32[$0 + 10196 >> 2] = $1; + HEAP32[$0 + 10192 >> 2] = 7694; + HEAP32[$0 + 10188 >> 2] = 44; + HEAP32[$0 + 10184 >> 2] = 236; + HEAP32[$0 + 10180 >> 2] = 237; + $1 = emscripten__internal__TypeID_b2DistanceJointDef_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 10192 >> 2]; + $3 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15664 >> 2] = HEAP32[$0 + 10184 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $5 = HEAP32[$0 + 10184 >> 2]; + $6 = float_20b2DistanceJointDef_____20emscripten__internal__getContext_float_20b2DistanceJointDef_____28float_20b2DistanceJointDef____20const__29($0 + 10188 | 0); + $7 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15676 >> 2] = HEAP32[$0 + 10180 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 10180 >> 2], float_20b2DistanceJointDef_____20emscripten__internal__getContext_float_20b2DistanceJointDef_____28float_20b2DistanceJointDef____20const__29($0 + 10188 | 0) | 0); + HEAP32[$0 + 10260 >> 2] = $0 + 2806; + HEAP32[$0 + 10256 >> 2] = 2621; + void_20emscripten__base_b2Joint___verify_b2DistanceJoint__28_29(); + HEAP32[$0 + 10252 >> 2] = 238; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2DistanceJoint__28_29_29_28b2DistanceJoint__29(), + HEAP32[wasm2js_i32$0 + 10248 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2DistanceJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2DistanceJoint__28_29_29_28b2Joint__29(), + HEAP32[wasm2js_i32$0 + 10244 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 10240 >> 2] = 239; + $1 = emscripten__internal__TypeID_b2DistanceJoint_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2DistanceJoint__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2Joint___get_28_29(); + HEAP32[$0 + 15680 >> 2] = HEAP32[$0 + 10252 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 10252 >> 2]; + HEAP32[$0 + 15684 >> 2] = HEAP32[$0 + 10248 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 10248 >> 2]; + HEAP32[$0 + 15688 >> 2] = HEAP32[$0 + 10244 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 10244 >> 2]; + $11 = HEAP32[$0 + 10256 >> 2]; + HEAP32[$0 + 15692 >> 2] = HEAP32[$0 + 10240 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 10240 >> 2]); + HEAP32[$0 + 2800 >> 2] = 0; + HEAP32[$0 + 2796 >> 2] = 240; + $1 = HEAP32[$0 + 2800 >> 2]; + $2 = HEAP32[$0 + 2796 >> 2]; + HEAP32[$0 + 10296 >> 2] = $2; + HEAP32[$0 + 10300 >> 2] = $1; + $1 = HEAP32[$0 + 10296 >> 2]; + $2 = HEAP32[$0 + 10300 >> 2]; + HEAP32[$0 + 10324 >> 2] = $0 + 2806; + HEAP32[$0 + 10320 >> 2] = 11171; + HEAP32[$0 + 10316 >> 2] = $2; + HEAP32[$0 + 10312 >> 2] = $1; + $3 = HEAP32[$0 + 10324 >> 2]; + $4 = HEAP32[$0 + 10320 >> 2]; + $1 = HEAP32[$0 + 10312 >> 2]; + HEAP32[$0 + 10308 >> 2] = HEAP32[$0 + 10316 >> 2]; + HEAP32[$0 + 10304 >> 2] = $1; + $2 = HEAP32[$0 + 10308 >> 2]; + $1 = HEAP32[$0 + 10304 >> 2]; + HEAP32[$0 + 776 >> 2] = $1; + HEAP32[$0 + 780 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2DistanceJoint____29_28_29_20const___invoke_b2DistanceJoint__28char_20const__2c_20b2Vec2_20const__20_28b2DistanceJoint____29_28_29_20const_29($4, $0 + 776 | 0); + HEAP32[$0 + 2792 >> 2] = 0; + HEAP32[$0 + 2788 >> 2] = 241; + $1 = HEAP32[$0 + 2792 >> 2]; + $2 = HEAP32[$0 + 2788 >> 2]; + HEAP32[$0 + 10264 >> 2] = $2; + HEAP32[$0 + 10268 >> 2] = $1; + $1 = HEAP32[$0 + 10264 >> 2]; + $2 = HEAP32[$0 + 10268 >> 2]; + HEAP32[$0 + 10292 >> 2] = $3; + HEAP32[$0 + 10288 >> 2] = 11028; + HEAP32[$0 + 10284 >> 2] = $2; + HEAP32[$0 + 10280 >> 2] = $1; + $3 = HEAP32[$0 + 10292 >> 2]; + $4 = HEAP32[$0 + 10288 >> 2]; + $1 = HEAP32[$0 + 10280 >> 2]; + HEAP32[$0 + 10276 >> 2] = HEAP32[$0 + 10284 >> 2]; + HEAP32[$0 + 10272 >> 2] = $1; + $2 = HEAP32[$0 + 10276 >> 2]; + $1 = HEAP32[$0 + 10272 >> 2]; + HEAP32[$0 + 768 >> 2] = $1; + HEAP32[$0 + 772 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2DistanceJoint____29_28_29_20const___invoke_b2DistanceJoint__28char_20const__2c_20b2Vec2_20const__20_28b2DistanceJoint____29_28_29_20const_29($4, $0 + 768 | 0); + HEAP32[$0 + 2784 >> 2] = 0; + HEAP32[$0 + 2780 >> 2] = 242; + $1 = HEAP32[$0 + 2784 >> 2]; + $2 = HEAP32[$0 + 2780 >> 2]; + HEAP32[$0 + 10392 >> 2] = $2; + HEAP32[$0 + 10396 >> 2] = $1; + $1 = HEAP32[$0 + 10392 >> 2]; + $2 = HEAP32[$0 + 10396 >> 2]; + HEAP32[$0 + 10420 >> 2] = $3; + HEAP32[$0 + 10416 >> 2] = 7090; + HEAP32[$0 + 10412 >> 2] = $2; + HEAP32[$0 + 10408 >> 2] = $1; + $3 = HEAP32[$0 + 10420 >> 2]; + $4 = HEAP32[$0 + 10416 >> 2]; + $1 = HEAP32[$0 + 10408 >> 2]; + HEAP32[$0 + 10404 >> 2] = HEAP32[$0 + 10412 >> 2]; + HEAP32[$0 + 10400 >> 2] = $1; + $2 = HEAP32[$0 + 10404 >> 2]; + $1 = HEAP32[$0 + 10400 >> 2]; + HEAP32[$0 + 760 >> 2] = $1; + HEAP32[$0 + 764 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2DistanceJoint____29_28float_29___invoke_b2DistanceJoint__28char_20const__2c_20void_20_28b2DistanceJoint____29_28float_29_29($4, $0 + 760 | 0); + HEAP32[$0 + 2776 >> 2] = 0; + HEAP32[$0 + 2772 >> 2] = 243; + $1 = HEAP32[$0 + 2776 >> 2]; + $2 = HEAP32[$0 + 2772 >> 2]; + HEAP32[$0 + 10488 >> 2] = $2; + HEAP32[$0 + 10492 >> 2] = $1; + $1 = HEAP32[$0 + 10488 >> 2]; + $2 = HEAP32[$0 + 10492 >> 2]; + HEAP32[$0 + 10516 >> 2] = $3; + HEAP32[$0 + 10512 >> 2] = 7100; + HEAP32[$0 + 10508 >> 2] = $2; + HEAP32[$0 + 10504 >> 2] = $1; + $3 = HEAP32[$0 + 10516 >> 2]; + $4 = HEAP32[$0 + 10512 >> 2]; + $1 = HEAP32[$0 + 10504 >> 2]; + HEAP32[$0 + 10500 >> 2] = HEAP32[$0 + 10508 >> 2]; + HEAP32[$0 + 10496 >> 2] = $1; + $2 = HEAP32[$0 + 10500 >> 2]; + $1 = HEAP32[$0 + 10496 >> 2]; + HEAP32[$0 + 752 >> 2] = $1; + HEAP32[$0 + 756 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2DistanceJoint____29_28_29_20const___invoke_b2DistanceJoint__28char_20const__2c_20float_20_28b2DistanceJoint____29_28_29_20const_29($4, $0 + 752 | 0); + HEAP32[$0 + 2768 >> 2] = 0; + HEAP32[$0 + 2764 >> 2] = 244; + $1 = HEAP32[$0 + 2768 >> 2]; + $2 = HEAP32[$0 + 2764 >> 2]; + HEAP32[$0 + 10360 >> 2] = $2; + HEAP32[$0 + 10364 >> 2] = $1; + $1 = HEAP32[$0 + 10360 >> 2]; + $2 = HEAP32[$0 + 10364 >> 2]; + HEAP32[$0 + 10388 >> 2] = $3; + HEAP32[$0 + 10384 >> 2] = 3397; + HEAP32[$0 + 10380 >> 2] = $2; + HEAP32[$0 + 10376 >> 2] = $1; + $3 = HEAP32[$0 + 10388 >> 2]; + $4 = HEAP32[$0 + 10384 >> 2]; + $1 = HEAP32[$0 + 10376 >> 2]; + HEAP32[$0 + 10372 >> 2] = HEAP32[$0 + 10380 >> 2]; + HEAP32[$0 + 10368 >> 2] = $1; + $2 = HEAP32[$0 + 10372 >> 2]; + $1 = HEAP32[$0 + 10368 >> 2]; + HEAP32[$0 + 744 >> 2] = $1; + HEAP32[$0 + 748 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2DistanceJoint____29_28float_29___invoke_b2DistanceJoint__28char_20const__2c_20void_20_28b2DistanceJoint____29_28float_29_29($4, $0 + 744 | 0); + HEAP32[$0 + 2760 >> 2] = 0; + HEAP32[$0 + 2756 >> 2] = 245; + $1 = HEAP32[$0 + 2760 >> 2]; + $2 = HEAP32[$0 + 2756 >> 2]; + HEAP32[$0 + 10456 >> 2] = $2; + HEAP32[$0 + 10460 >> 2] = $1; + $1 = HEAP32[$0 + 10456 >> 2]; + $2 = HEAP32[$0 + 10460 >> 2]; + HEAP32[$0 + 10484 >> 2] = $3; + HEAP32[$0 + 10480 >> 2] = 3410; + HEAP32[$0 + 10476 >> 2] = $2; + HEAP32[$0 + 10472 >> 2] = $1; + $3 = HEAP32[$0 + 10484 >> 2]; + $4 = HEAP32[$0 + 10480 >> 2]; + $1 = HEAP32[$0 + 10472 >> 2]; + HEAP32[$0 + 10468 >> 2] = HEAP32[$0 + 10476 >> 2]; + HEAP32[$0 + 10464 >> 2] = $1; + $2 = HEAP32[$0 + 10468 >> 2]; + $1 = HEAP32[$0 + 10464 >> 2]; + HEAP32[$0 + 736 >> 2] = $1; + HEAP32[$0 + 740 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2DistanceJoint____29_28_29_20const___invoke_b2DistanceJoint__28char_20const__2c_20float_20_28b2DistanceJoint____29_28_29_20const_29($4, $0 + 736 | 0); + HEAP32[$0 + 2752 >> 2] = 0; + HEAP32[$0 + 2748 >> 2] = 246; + $1 = HEAP32[$0 + 2752 >> 2]; + $2 = HEAP32[$0 + 2748 >> 2]; + HEAP32[$0 + 10328 >> 2] = $2; + HEAP32[$0 + 10332 >> 2] = $1; + $1 = HEAP32[$0 + 10328 >> 2]; + $2 = HEAP32[$0 + 10332 >> 2]; + HEAP32[$0 + 10356 >> 2] = $3; + HEAP32[$0 + 10352 >> 2] = 7702; + HEAP32[$0 + 10348 >> 2] = $2; + HEAP32[$0 + 10344 >> 2] = $1; + $3 = HEAP32[$0 + 10356 >> 2]; + $4 = HEAP32[$0 + 10352 >> 2]; + $1 = HEAP32[$0 + 10344 >> 2]; + HEAP32[$0 + 10340 >> 2] = HEAP32[$0 + 10348 >> 2]; + HEAP32[$0 + 10336 >> 2] = $1; + $2 = HEAP32[$0 + 10340 >> 2]; + $1 = HEAP32[$0 + 10336 >> 2]; + HEAP32[$0 + 728 >> 2] = $1; + HEAP32[$0 + 732 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2DistanceJoint____29_28float_29___invoke_b2DistanceJoint__28char_20const__2c_20void_20_28b2DistanceJoint____29_28float_29_29($4, $0 + 728 | 0); + HEAP32[$0 + 2744 >> 2] = 0; + HEAP32[$0 + 2740 >> 2] = 247; + $1 = HEAP32[$0 + 2744 >> 2]; + $2 = HEAP32[$0 + 2740 >> 2]; + HEAP32[$0 + 10424 >> 2] = $2; + HEAP32[$0 + 10428 >> 2] = $1; + $1 = HEAP32[$0 + 10424 >> 2]; + $2 = HEAP32[$0 + 10428 >> 2]; + HEAP32[$0 + 10452 >> 2] = $3; + HEAP32[$0 + 10448 >> 2] = 7713; + HEAP32[$0 + 10444 >> 2] = $2; + HEAP32[$0 + 10440 >> 2] = $1; + $3 = HEAP32[$0 + 10452 >> 2]; + $4 = HEAP32[$0 + 10448 >> 2]; + $1 = HEAP32[$0 + 10440 >> 2]; + HEAP32[$0 + 10436 >> 2] = HEAP32[$0 + 10444 >> 2]; + HEAP32[$0 + 10432 >> 2] = $1; + $2 = HEAP32[$0 + 10436 >> 2]; + $1 = HEAP32[$0 + 10432 >> 2]; + HEAP32[$0 + 720 >> 2] = $1; + HEAP32[$0 + 724 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2DistanceJoint____29_28_29_20const___invoke_b2DistanceJoint__28char_20const__2c_20float_20_28b2DistanceJoint____29_28_29_20const_29($4, $0 + 720 | 0); + HEAP32[$0 + 2736 >> 2] = 1; + HEAP32[$0 + 2732 >> 2] = 16; + $1 = HEAP32[$0 + 2736 >> 2]; + $2 = HEAP32[$0 + 2732 >> 2]; + HEAP32[$0 + 10520 >> 2] = $2; + HEAP32[$0 + 10524 >> 2] = $1; + $1 = HEAP32[$0 + 10520 >> 2]; + $2 = HEAP32[$0 + 10524 >> 2]; + HEAP32[$0 + 10548 >> 2] = $3; + HEAP32[$0 + 10544 >> 2] = 6232; + HEAP32[$0 + 10540 >> 2] = $2; + HEAP32[$0 + 10536 >> 2] = $1; + $3 = HEAP32[$0 + 10544 >> 2]; + $1 = HEAP32[$0 + 10536 >> 2]; + HEAP32[$0 + 10532 >> 2] = HEAP32[$0 + 10540 >> 2]; + HEAP32[$0 + 10528 >> 2] = $1; + $2 = HEAP32[$0 + 10532 >> 2]; + $1 = HEAP32[$0 + 10528 >> 2]; + HEAP32[$0 + 712 >> 2] = $1; + HEAP32[$0 + 716 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2DistanceJoint____29_28_29___invoke_b2DistanceJoint__28char_20const__2c_20void_20_28b2DistanceJoint____29_28_29_29($3, $0 + 712 | 0); + HEAP32[$0 + 10572 >> 2] = $0 + 2731; + HEAP32[$0 + 10568 >> 2] = 7887; + void_20emscripten__base_b2JointDef___verify_b2MotorJointDef__28_29(); + HEAP32[$0 + 10564 >> 2] = 248; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2MotorJointDef__28_29_29_28b2MotorJointDef__29(), + HEAP32[wasm2js_i32$0 + 10560 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2MotorJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2MotorJointDef__28_29_29_28b2JointDef__29(), + HEAP32[wasm2js_i32$0 + 10556 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 10552 >> 2] = 249; + $1 = emscripten__internal__TypeID_b2MotorJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MotorJointDef__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MotorJointDef_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2JointDef___get_28_29(); + HEAP32[$0 + 15696 >> 2] = HEAP32[$0 + 10564 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 10564 >> 2]; + HEAP32[$0 + 15700 >> 2] = HEAP32[$0 + 10560 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 10560 >> 2]; + HEAP32[$0 + 15704 >> 2] = HEAP32[$0 + 10556 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 10556 >> 2]; + $11 = HEAP32[$0 + 10568 >> 2]; + HEAP32[$0 + 15708 >> 2] = HEAP32[$0 + 10552 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 10552 >> 2]); + HEAP32[$0 + 10576 >> 2] = $0 + 2731; + HEAP32[$0 + 15716 >> 2] = HEAP32[$0 + 10576 >> 2]; + HEAP32[$0 + 15712 >> 2] = 250; + $1 = HEAP32[$0 + 15716 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2MotorJointDef__20_28__29_28_29___invoke_b2MotorJointDef__28b2MotorJointDef__20_28__29_28_29_29(HEAP32[$0 + 15712 >> 2]); + HEAP32[$0 + 10596 >> 2] = $1; + HEAP32[$0 + 10592 >> 2] = 2921; + HEAP32[$0 + 10588 >> 2] = 20; + $1 = HEAP32[$0 + 10596 >> 2]; + HEAP32[$0 + 10584 >> 2] = 251; + HEAP32[$0 + 10580 >> 2] = 252; + $2 = emscripten__internal__TypeID_b2MotorJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 10592 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15720 >> 2] = HEAP32[$0 + 10584 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 10584 >> 2]; + $7 = b2Vec2_20b2MotorJointDef_____20emscripten__internal__getContext_b2Vec2_20b2MotorJointDef_____28b2Vec2_20b2MotorJointDef____20const__29($0 + 10588 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15724 >> 2] = HEAP32[$0 + 10580 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 10580 >> 2], b2Vec2_20b2MotorJointDef_____20emscripten__internal__getContext_b2Vec2_20b2MotorJointDef_____28b2Vec2_20b2MotorJointDef____20const__29($0 + 10588 | 0) | 0); + HEAP32[$0 + 10676 >> 2] = $1; + HEAP32[$0 + 10672 >> 2] = 2873; + HEAP32[$0 + 10668 >> 2] = 28; + $1 = HEAP32[$0 + 10676 >> 2]; + HEAP32[$0 + 10664 >> 2] = 253; + HEAP32[$0 + 10660 >> 2] = 254; + $2 = emscripten__internal__TypeID_b2MotorJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 10672 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15728 >> 2] = HEAP32[$0 + 10664 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 10664 >> 2]; + $7 = float_20b2MotorJointDef_____20emscripten__internal__getContext_float_20b2MotorJointDef_____28float_20b2MotorJointDef____20const__29($0 + 10668 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15744 >> 2] = HEAP32[$0 + 10660 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 10660 >> 2], float_20b2MotorJointDef_____20emscripten__internal__getContext_float_20b2MotorJointDef_____28float_20b2MotorJointDef____20const__29($0 + 10668 | 0) | 0); + HEAP32[$0 + 10656 >> 2] = $1; + HEAP32[$0 + 10652 >> 2] = 9863; + HEAP32[$0 + 10648 >> 2] = 32; + $1 = HEAP32[$0 + 10656 >> 2]; + HEAP32[$0 + 10644 >> 2] = 253; + HEAP32[$0 + 10640 >> 2] = 254; + $2 = emscripten__internal__TypeID_b2MotorJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 10652 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15732 >> 2] = HEAP32[$0 + 10644 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 10644 >> 2]; + $7 = float_20b2MotorJointDef_____20emscripten__internal__getContext_float_20b2MotorJointDef_____28float_20b2MotorJointDef____20const__29($0 + 10648 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15748 >> 2] = HEAP32[$0 + 10640 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 10640 >> 2], float_20b2MotorJointDef_____20emscripten__internal__getContext_float_20b2MotorJointDef_____28float_20b2MotorJointDef____20const__29($0 + 10648 | 0) | 0); + HEAP32[$0 + 10636 >> 2] = $1; + HEAP32[$0 + 10632 >> 2] = 8755; + HEAP32[$0 + 10628 >> 2] = 36; + $1 = HEAP32[$0 + 10636 >> 2]; + HEAP32[$0 + 10624 >> 2] = 253; + HEAP32[$0 + 10620 >> 2] = 254; + $2 = emscripten__internal__TypeID_b2MotorJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 10632 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15736 >> 2] = HEAP32[$0 + 10624 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 10624 >> 2]; + $7 = float_20b2MotorJointDef_____20emscripten__internal__getContext_float_20b2MotorJointDef_____28float_20b2MotorJointDef____20const__29($0 + 10628 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15752 >> 2] = HEAP32[$0 + 10620 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 10620 >> 2], float_20b2MotorJointDef_____20emscripten__internal__getContext_float_20b2MotorJointDef_____28float_20b2MotorJointDef____20const__29($0 + 10628 | 0) | 0); + HEAP32[$0 + 10616 >> 2] = $1; + HEAP32[$0 + 10612 >> 2] = 3724; + HEAP32[$0 + 10608 >> 2] = 40; + HEAP32[$0 + 10604 >> 2] = 253; + HEAP32[$0 + 10600 >> 2] = 254; + $1 = emscripten__internal__TypeID_b2MotorJointDef_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 10612 >> 2]; + $3 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15740 >> 2] = HEAP32[$0 + 10604 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $5 = HEAP32[$0 + 10604 >> 2]; + $6 = float_20b2MotorJointDef_____20emscripten__internal__getContext_float_20b2MotorJointDef_____28float_20b2MotorJointDef____20const__29($0 + 10608 | 0); + $7 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15756 >> 2] = HEAP32[$0 + 10600 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 10600 >> 2], float_20b2MotorJointDef_____20emscripten__internal__getContext_float_20b2MotorJointDef_____28float_20b2MotorJointDef____20const__29($0 + 10608 | 0) | 0); + HEAP32[$0 + 10700 >> 2] = $0 + 2730; + HEAP32[$0 + 10696 >> 2] = 2538; + void_20emscripten__base_b2Joint___verify_b2MotorJoint__28_29(); + HEAP32[$0 + 10692 >> 2] = 255; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2MotorJoint__28_29_29_28b2MotorJoint__29(), + HEAP32[wasm2js_i32$0 + 10688 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2MotorJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2MotorJoint__28_29_29_28b2Joint__29(), + HEAP32[wasm2js_i32$0 + 10684 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 10680 >> 2] = 256; + $1 = emscripten__internal__TypeID_b2MotorJoint_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MotorJoint_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2Joint___get_28_29(); + HEAP32[$0 + 15760 >> 2] = HEAP32[$0 + 10692 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 10692 >> 2]; + HEAP32[$0 + 15764 >> 2] = HEAP32[$0 + 10688 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 10688 >> 2]; + HEAP32[$0 + 15768 >> 2] = HEAP32[$0 + 10684 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 10684 >> 2]; + $11 = HEAP32[$0 + 10696 >> 2]; + HEAP32[$0 + 15772 >> 2] = HEAP32[$0 + 10680 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 10680 >> 2]); + HEAP32[$0 + 2724 >> 2] = 0; + HEAP32[$0 + 2720 >> 2] = 257; + $1 = HEAP32[$0 + 2724 >> 2]; + $2 = HEAP32[$0 + 2720 >> 2]; + HEAP32[$0 + 10704 >> 2] = $2; + HEAP32[$0 + 10708 >> 2] = $1; + $1 = HEAP32[$0 + 10704 >> 2]; + $2 = HEAP32[$0 + 10708 >> 2]; + HEAP32[$0 + 10732 >> 2] = $0 + 2730; + HEAP32[$0 + 10728 >> 2] = 2934; + HEAP32[$0 + 10724 >> 2] = $2; + HEAP32[$0 + 10720 >> 2] = $1; + $3 = HEAP32[$0 + 10732 >> 2]; + $4 = HEAP32[$0 + 10728 >> 2]; + $1 = HEAP32[$0 + 10720 >> 2]; + HEAP32[$0 + 10716 >> 2] = HEAP32[$0 + 10724 >> 2]; + HEAP32[$0 + 10712 >> 2] = $1; + $2 = HEAP32[$0 + 10716 >> 2]; + $1 = HEAP32[$0 + 10712 >> 2]; + HEAP32[$0 + 704 >> 2] = $1; + HEAP32[$0 + 708 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2MotorJoint____29_28b2Vec2_20const__29___invoke_b2MotorJoint__28char_20const__2c_20void_20_28b2MotorJoint____29_28b2Vec2_20const__29_29($4, $0 + 704 | 0); + HEAP32[$0 + 2716 >> 2] = 0; + HEAP32[$0 + 2712 >> 2] = 258; + $1 = HEAP32[$0 + 2716 >> 2]; + $2 = HEAP32[$0 + 2712 >> 2]; + HEAP32[$0 + 10736 >> 2] = $2; + HEAP32[$0 + 10740 >> 2] = $1; + $1 = HEAP32[$0 + 10736 >> 2]; + $2 = HEAP32[$0 + 10740 >> 2]; + HEAP32[$0 + 10764 >> 2] = $3; + HEAP32[$0 + 10760 >> 2] = 2950; + HEAP32[$0 + 10756 >> 2] = $2; + HEAP32[$0 + 10752 >> 2] = $1; + $3 = HEAP32[$0 + 10764 >> 2]; + $4 = HEAP32[$0 + 10760 >> 2]; + $1 = HEAP32[$0 + 10752 >> 2]; + HEAP32[$0 + 10748 >> 2] = HEAP32[$0 + 10756 >> 2]; + HEAP32[$0 + 10744 >> 2] = $1; + $2 = HEAP32[$0 + 10748 >> 2]; + $1 = HEAP32[$0 + 10744 >> 2]; + HEAP32[$0 + 696 >> 2] = $1; + HEAP32[$0 + 700 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2MotorJoint____29_28_29_20const___invoke_b2MotorJoint__28char_20const__2c_20b2Vec2_20const__20_28b2MotorJoint____29_28_29_20const_29($4, $0 + 696 | 0); + HEAP32[$0 + 2708 >> 2] = 0; + HEAP32[$0 + 2704 >> 2] = 259; + $1 = HEAP32[$0 + 2708 >> 2]; + $2 = HEAP32[$0 + 2704 >> 2]; + HEAP32[$0 + 10864 >> 2] = $2; + HEAP32[$0 + 10868 >> 2] = $1; + $1 = HEAP32[$0 + 10864 >> 2]; + $2 = HEAP32[$0 + 10868 >> 2]; + HEAP32[$0 + 10892 >> 2] = $3; + HEAP32[$0 + 10888 >> 2] = 2887; + HEAP32[$0 + 10884 >> 2] = $2; + HEAP32[$0 + 10880 >> 2] = $1; + $3 = HEAP32[$0 + 10892 >> 2]; + $4 = HEAP32[$0 + 10888 >> 2]; + $1 = HEAP32[$0 + 10880 >> 2]; + HEAP32[$0 + 10876 >> 2] = HEAP32[$0 + 10884 >> 2]; + HEAP32[$0 + 10872 >> 2] = $1; + $2 = HEAP32[$0 + 10876 >> 2]; + $1 = HEAP32[$0 + 10872 >> 2]; + HEAP32[$0 + 688 >> 2] = $1; + HEAP32[$0 + 692 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2MotorJoint____29_28float_29___invoke_b2MotorJoint__28char_20const__2c_20void_20_28b2MotorJoint____29_28float_29_29($4, $0 + 688 | 0); + HEAP32[$0 + 2700 >> 2] = 0; + HEAP32[$0 + 2696 >> 2] = 260; + $1 = HEAP32[$0 + 2700 >> 2]; + $2 = HEAP32[$0 + 2696 >> 2]; + HEAP32[$0 + 10992 >> 2] = $2; + HEAP32[$0 + 10996 >> 2] = $1; + $1 = HEAP32[$0 + 10992 >> 2]; + $2 = HEAP32[$0 + 10996 >> 2]; + HEAP32[$0 + 11020 >> 2] = $3; + HEAP32[$0 + 11016 >> 2] = 2904; + HEAP32[$0 + 11012 >> 2] = $2; + HEAP32[$0 + 11008 >> 2] = $1; + $3 = HEAP32[$0 + 11020 >> 2]; + $4 = HEAP32[$0 + 11016 >> 2]; + $1 = HEAP32[$0 + 11008 >> 2]; + HEAP32[$0 + 11004 >> 2] = HEAP32[$0 + 11012 >> 2]; + HEAP32[$0 + 11e3 >> 2] = $1; + $2 = HEAP32[$0 + 11004 >> 2]; + $1 = HEAP32[$0 + 11e3 >> 2]; + HEAP32[$0 + 680 >> 2] = $1; + HEAP32[$0 + 684 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2MotorJoint____29_28_29_20const___invoke_b2MotorJoint__28char_20const__2c_20float_20_28b2MotorJoint____29_28_29_20const_29($4, $0 + 680 | 0); + HEAP32[$0 + 2692 >> 2] = 0; + HEAP32[$0 + 2688 >> 2] = 261; + $1 = HEAP32[$0 + 2692 >> 2]; + $2 = HEAP32[$0 + 2688 >> 2]; + HEAP32[$0 + 10832 >> 2] = $2; + HEAP32[$0 + 10836 >> 2] = $1; + $1 = HEAP32[$0 + 10832 >> 2]; + $2 = HEAP32[$0 + 10836 >> 2]; + HEAP32[$0 + 10860 >> 2] = $3; + HEAP32[$0 + 10856 >> 2] = 9872; + HEAP32[$0 + 10852 >> 2] = $2; + HEAP32[$0 + 10848 >> 2] = $1; + $3 = HEAP32[$0 + 10860 >> 2]; + $4 = HEAP32[$0 + 10856 >> 2]; + $1 = HEAP32[$0 + 10848 >> 2]; + HEAP32[$0 + 10844 >> 2] = HEAP32[$0 + 10852 >> 2]; + HEAP32[$0 + 10840 >> 2] = $1; + $2 = HEAP32[$0 + 10844 >> 2]; + $1 = HEAP32[$0 + 10840 >> 2]; + HEAP32[$0 + 672 >> 2] = $1; + HEAP32[$0 + 676 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2MotorJoint____29_28float_29___invoke_b2MotorJoint__28char_20const__2c_20void_20_28b2MotorJoint____29_28float_29_29($4, $0 + 672 | 0); + HEAP32[$0 + 2684 >> 2] = 0; + HEAP32[$0 + 2680 >> 2] = 262; + $1 = HEAP32[$0 + 2684 >> 2]; + $2 = HEAP32[$0 + 2680 >> 2]; + HEAP32[$0 + 10960 >> 2] = $2; + HEAP32[$0 + 10964 >> 2] = $1; + $1 = HEAP32[$0 + 10960 >> 2]; + $2 = HEAP32[$0 + 10964 >> 2]; + HEAP32[$0 + 10988 >> 2] = $3; + HEAP32[$0 + 10984 >> 2] = 9884; + HEAP32[$0 + 10980 >> 2] = $2; + HEAP32[$0 + 10976 >> 2] = $1; + $3 = HEAP32[$0 + 10988 >> 2]; + $4 = HEAP32[$0 + 10984 >> 2]; + $1 = HEAP32[$0 + 10976 >> 2]; + HEAP32[$0 + 10972 >> 2] = HEAP32[$0 + 10980 >> 2]; + HEAP32[$0 + 10968 >> 2] = $1; + $2 = HEAP32[$0 + 10972 >> 2]; + $1 = HEAP32[$0 + 10968 >> 2]; + HEAP32[$0 + 664 >> 2] = $1; + HEAP32[$0 + 668 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2MotorJoint____29_28_29_20const___invoke_b2MotorJoint__28char_20const__2c_20float_20_28b2MotorJoint____29_28_29_20const_29($4, $0 + 664 | 0); + HEAP32[$0 + 2676 >> 2] = 0; + HEAP32[$0 + 2672 >> 2] = 263; + $1 = HEAP32[$0 + 2676 >> 2]; + $2 = HEAP32[$0 + 2672 >> 2]; + HEAP32[$0 + 10800 >> 2] = $2; + HEAP32[$0 + 10804 >> 2] = $1; + $1 = HEAP32[$0 + 10800 >> 2]; + $2 = HEAP32[$0 + 10804 >> 2]; + HEAP32[$0 + 10828 >> 2] = $3; + HEAP32[$0 + 10824 >> 2] = 8765; + HEAP32[$0 + 10820 >> 2] = $2; + HEAP32[$0 + 10816 >> 2] = $1; + $3 = HEAP32[$0 + 10828 >> 2]; + $4 = HEAP32[$0 + 10824 >> 2]; + $1 = HEAP32[$0 + 10816 >> 2]; + HEAP32[$0 + 10812 >> 2] = HEAP32[$0 + 10820 >> 2]; + HEAP32[$0 + 10808 >> 2] = $1; + $2 = HEAP32[$0 + 10812 >> 2]; + $1 = HEAP32[$0 + 10808 >> 2]; + HEAP32[$0 + 656 >> 2] = $1; + HEAP32[$0 + 660 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2MotorJoint____29_28float_29___invoke_b2MotorJoint__28char_20const__2c_20void_20_28b2MotorJoint____29_28float_29_29($4, $0 + 656 | 0); + HEAP32[$0 + 2668 >> 2] = 0; + HEAP32[$0 + 2664 >> 2] = 264; + $1 = HEAP32[$0 + 2668 >> 2]; + $2 = HEAP32[$0 + 2664 >> 2]; + HEAP32[$0 + 10928 >> 2] = $2; + HEAP32[$0 + 10932 >> 2] = $1; + $1 = HEAP32[$0 + 10928 >> 2]; + $2 = HEAP32[$0 + 10932 >> 2]; + HEAP32[$0 + 10956 >> 2] = $3; + HEAP32[$0 + 10952 >> 2] = 8778; + HEAP32[$0 + 10948 >> 2] = $2; + HEAP32[$0 + 10944 >> 2] = $1; + $3 = HEAP32[$0 + 10956 >> 2]; + $4 = HEAP32[$0 + 10952 >> 2]; + $1 = HEAP32[$0 + 10944 >> 2]; + HEAP32[$0 + 10940 >> 2] = HEAP32[$0 + 10948 >> 2]; + HEAP32[$0 + 10936 >> 2] = $1; + $2 = HEAP32[$0 + 10940 >> 2]; + $1 = HEAP32[$0 + 10936 >> 2]; + HEAP32[$0 + 648 >> 2] = $1; + HEAP32[$0 + 652 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2MotorJoint____29_28_29_20const___invoke_b2MotorJoint__28char_20const__2c_20float_20_28b2MotorJoint____29_28_29_20const_29($4, $0 + 648 | 0); + HEAP32[$0 + 2660 >> 2] = 0; + HEAP32[$0 + 2656 >> 2] = 265; + $1 = HEAP32[$0 + 2660 >> 2]; + $2 = HEAP32[$0 + 2656 >> 2]; + HEAP32[$0 + 10768 >> 2] = $2; + HEAP32[$0 + 10772 >> 2] = $1; + $1 = HEAP32[$0 + 10768 >> 2]; + $2 = HEAP32[$0 + 10772 >> 2]; + HEAP32[$0 + 10796 >> 2] = $3; + HEAP32[$0 + 10792 >> 2] = 3741; + HEAP32[$0 + 10788 >> 2] = $2; + HEAP32[$0 + 10784 >> 2] = $1; + $3 = HEAP32[$0 + 10796 >> 2]; + $4 = HEAP32[$0 + 10792 >> 2]; + $1 = HEAP32[$0 + 10784 >> 2]; + HEAP32[$0 + 10780 >> 2] = HEAP32[$0 + 10788 >> 2]; + HEAP32[$0 + 10776 >> 2] = $1; + $2 = HEAP32[$0 + 10780 >> 2]; + $1 = HEAP32[$0 + 10776 >> 2]; + HEAP32[$0 + 640 >> 2] = $1; + HEAP32[$0 + 644 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2MotorJoint____29_28float_29___invoke_b2MotorJoint__28char_20const__2c_20void_20_28b2MotorJoint____29_28float_29_29($4, $0 + 640 | 0); + HEAP32[$0 + 2652 >> 2] = 0; + HEAP32[$0 + 2648 >> 2] = 266; + $1 = HEAP32[$0 + 2652 >> 2]; + $2 = HEAP32[$0 + 2648 >> 2]; + HEAP32[$0 + 10896 >> 2] = $2; + HEAP32[$0 + 10900 >> 2] = $1; + $1 = HEAP32[$0 + 10896 >> 2]; + $2 = HEAP32[$0 + 10900 >> 2]; + HEAP32[$0 + 10924 >> 2] = $3; + HEAP32[$0 + 10920 >> 2] = 3761; + HEAP32[$0 + 10916 >> 2] = $2; + HEAP32[$0 + 10912 >> 2] = $1; + $3 = HEAP32[$0 + 10924 >> 2]; + $4 = HEAP32[$0 + 10920 >> 2]; + $1 = HEAP32[$0 + 10912 >> 2]; + HEAP32[$0 + 10908 >> 2] = HEAP32[$0 + 10916 >> 2]; + HEAP32[$0 + 10904 >> 2] = $1; + $2 = HEAP32[$0 + 10908 >> 2]; + $1 = HEAP32[$0 + 10904 >> 2]; + HEAP32[$0 + 632 >> 2] = $1; + HEAP32[$0 + 636 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2MotorJoint____29_28_29_20const___invoke_b2MotorJoint__28char_20const__2c_20float_20_28b2MotorJoint____29_28_29_20const_29($4, $0 + 632 | 0); + HEAP32[$0 + 2644 >> 2] = 1; + HEAP32[$0 + 2640 >> 2] = 16; + $1 = HEAP32[$0 + 2644 >> 2]; + $2 = HEAP32[$0 + 2640 >> 2]; + HEAP32[$0 + 11024 >> 2] = $2; + HEAP32[$0 + 11028 >> 2] = $1; + $1 = HEAP32[$0 + 11024 >> 2]; + $2 = HEAP32[$0 + 11028 >> 2]; + HEAP32[$0 + 11056 >> 2] = $3; + HEAP32[$0 + 11052 >> 2] = 6232; + HEAP32[$0 + 11048 >> 2] = $2; + HEAP32[$0 + 11044 >> 2] = $1; + $3 = HEAP32[$0 + 11052 >> 2]; + $1 = HEAP32[$0 + 11044 >> 2]; + HEAP32[$0 + 11040 >> 2] = HEAP32[$0 + 11048 >> 2]; + HEAP32[$0 + 11036 >> 2] = $1; + $2 = HEAP32[$0 + 11040 >> 2]; + $1 = HEAP32[$0 + 11036 >> 2]; + HEAP32[$0 + 624 >> 2] = $1; + HEAP32[$0 + 628 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2MotorJoint____29_28_29___invoke_b2MotorJoint__28char_20const__2c_20void_20_28b2MotorJoint____29_28_29_29($3, $0 + 624 | 0); + HEAP32[$0 + 11080 >> 2] = $0 + 2639; + HEAP32[$0 + 11076 >> 2] = 7932; + void_20emscripten__base_b2JointDef___verify_b2MouseJointDef__28_29(); + HEAP32[$0 + 11072 >> 2] = 267; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2MouseJointDef__28_29_29_28b2MouseJointDef__29(), + HEAP32[wasm2js_i32$0 + 11068 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2MouseJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2MouseJointDef__28_29_29_28b2JointDef__29(), + HEAP32[wasm2js_i32$0 + 11064 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 11060 >> 2] = 268; + $1 = emscripten__internal__TypeID_b2MouseJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MouseJointDef__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MouseJointDef_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2JointDef___get_28_29(); + HEAP32[$0 + 15776 >> 2] = HEAP32[$0 + 11072 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11072 >> 2]; + HEAP32[$0 + 15780 >> 2] = HEAP32[$0 + 11068 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 11068 >> 2]; + HEAP32[$0 + 15784 >> 2] = HEAP32[$0 + 11064 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 11064 >> 2]; + $11 = HEAP32[$0 + 11076 >> 2]; + HEAP32[$0 + 15788 >> 2] = HEAP32[$0 + 11060 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 11060 >> 2]); + HEAP32[$0 + 11084 >> 2] = $0 + 2639; + HEAP32[$0 + 15796 >> 2] = HEAP32[$0 + 11084 >> 2]; + HEAP32[$0 + 15792 >> 2] = 269; + $1 = HEAP32[$0 + 15796 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2MouseJointDef__20_28__29_28_29___invoke_b2MouseJointDef__28b2MouseJointDef__20_28__29_28_29_29(HEAP32[$0 + 15792 >> 2]); + HEAP32[$0 + 11104 >> 2] = $1; + HEAP32[$0 + 11100 >> 2] = 2992; + HEAP32[$0 + 11096 >> 2] = 20; + $1 = HEAP32[$0 + 11104 >> 2]; + HEAP32[$0 + 11092 >> 2] = 270; + HEAP32[$0 + 11088 >> 2] = 271; + $2 = emscripten__internal__TypeID_b2MouseJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 11100 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15800 >> 2] = HEAP32[$0 + 11092 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11092 >> 2]; + $7 = b2Vec2_20b2MouseJointDef_____20emscripten__internal__getContext_b2Vec2_20b2MouseJointDef_____28b2Vec2_20b2MouseJointDef____20const__29($0 + 11096 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15804 >> 2] = HEAP32[$0 + 11088 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 11088 >> 2], b2Vec2_20b2MouseJointDef_____20emscripten__internal__getContext_b2Vec2_20b2MouseJointDef_____28b2Vec2_20b2MouseJointDef____20const__29($0 + 11096 | 0) | 0); + HEAP32[$0 + 11164 >> 2] = $1; + HEAP32[$0 + 11160 >> 2] = 9863; + HEAP32[$0 + 11156 >> 2] = 28; + $1 = HEAP32[$0 + 11164 >> 2]; + HEAP32[$0 + 11152 >> 2] = 272; + HEAP32[$0 + 11148 >> 2] = 273; + $2 = emscripten__internal__TypeID_b2MouseJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 11160 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15808 >> 2] = HEAP32[$0 + 11152 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11152 >> 2]; + $7 = float_20b2MouseJointDef_____20emscripten__internal__getContext_float_20b2MouseJointDef_____28float_20b2MouseJointDef____20const__29($0 + 11156 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15820 >> 2] = HEAP32[$0 + 11148 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 11148 >> 2], float_20b2MouseJointDef_____20emscripten__internal__getContext_float_20b2MouseJointDef_____28float_20b2MouseJointDef____20const__29($0 + 11156 | 0) | 0); + HEAP32[$0 + 11144 >> 2] = $1; + HEAP32[$0 + 11140 >> 2] = 1024; + HEAP32[$0 + 11136 >> 2] = 32; + $1 = HEAP32[$0 + 11144 >> 2]; + HEAP32[$0 + 11132 >> 2] = 272; + HEAP32[$0 + 11128 >> 2] = 273; + $2 = emscripten__internal__TypeID_b2MouseJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 11140 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15812 >> 2] = HEAP32[$0 + 11132 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11132 >> 2]; + $7 = float_20b2MouseJointDef_____20emscripten__internal__getContext_float_20b2MouseJointDef_____28float_20b2MouseJointDef____20const__29($0 + 11136 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15824 >> 2] = HEAP32[$0 + 11128 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 11128 >> 2], float_20b2MouseJointDef_____20emscripten__internal__getContext_float_20b2MouseJointDef_____28float_20b2MouseJointDef____20const__29($0 + 11136 | 0) | 0); + HEAP32[$0 + 11124 >> 2] = $1; + HEAP32[$0 + 11120 >> 2] = 6278; + HEAP32[$0 + 11116 >> 2] = 36; + HEAP32[$0 + 11112 >> 2] = 272; + HEAP32[$0 + 11108 >> 2] = 273; + $1 = emscripten__internal__TypeID_b2MouseJointDef_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 11120 >> 2]; + $3 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15816 >> 2] = HEAP32[$0 + 11112 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $5 = HEAP32[$0 + 11112 >> 2]; + $6 = float_20b2MouseJointDef_____20emscripten__internal__getContext_float_20b2MouseJointDef_____28float_20b2MouseJointDef____20const__29($0 + 11116 | 0); + $7 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15828 >> 2] = HEAP32[$0 + 11108 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 11108 >> 2], float_20b2MouseJointDef_____20emscripten__internal__getContext_float_20b2MouseJointDef_____28float_20b2MouseJointDef____20const__29($0 + 11116 | 0) | 0); + HEAP32[$0 + 11188 >> 2] = $0 + 2638; + HEAP32[$0 + 11184 >> 2] = 2600; + void_20emscripten__base_b2Joint___verify_b2MouseJoint__28_29(); + HEAP32[$0 + 11180 >> 2] = 274; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2MouseJoint__28_29_29_28b2MouseJoint__29(), + HEAP32[wasm2js_i32$0 + 11176 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2MouseJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2MouseJoint__28_29_29_28b2Joint__29(), + HEAP32[wasm2js_i32$0 + 11172 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 11168 >> 2] = 275; + $1 = emscripten__internal__TypeID_b2MouseJoint_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MouseJoint_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2Joint___get_28_29(); + HEAP32[$0 + 15832 >> 2] = HEAP32[$0 + 11180 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11180 >> 2]; + HEAP32[$0 + 15836 >> 2] = HEAP32[$0 + 11176 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 11176 >> 2]; + HEAP32[$0 + 15840 >> 2] = HEAP32[$0 + 11172 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 11172 >> 2]; + $11 = HEAP32[$0 + 11184 >> 2]; + HEAP32[$0 + 15844 >> 2] = HEAP32[$0 + 11168 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 11168 >> 2]); + HEAP32[$0 + 2632 >> 2] = 0; + HEAP32[$0 + 2628 >> 2] = 276; + $1 = HEAP32[$0 + 2632 >> 2]; + $2 = HEAP32[$0 + 2628 >> 2]; + HEAP32[$0 + 11192 >> 2] = $2; + HEAP32[$0 + 11196 >> 2] = $1; + $1 = HEAP32[$0 + 11192 >> 2]; + $2 = HEAP32[$0 + 11196 >> 2]; + HEAP32[$0 + 11220 >> 2] = $0 + 2638; + HEAP32[$0 + 11216 >> 2] = 2999; + HEAP32[$0 + 11212 >> 2] = $2; + HEAP32[$0 + 11208 >> 2] = $1; + $3 = HEAP32[$0 + 11220 >> 2]; + $4 = HEAP32[$0 + 11216 >> 2]; + $1 = HEAP32[$0 + 11208 >> 2]; + HEAP32[$0 + 11204 >> 2] = HEAP32[$0 + 11212 >> 2]; + HEAP32[$0 + 11200 >> 2] = $1; + $2 = HEAP32[$0 + 11204 >> 2]; + $1 = HEAP32[$0 + 11200 >> 2]; + HEAP32[$0 + 616 >> 2] = $1; + HEAP32[$0 + 620 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2MouseJoint____29_28b2Vec2_20const__29___invoke_b2MouseJoint__28char_20const__2c_20void_20_28b2MouseJoint____29_28b2Vec2_20const__29_29($4, $0 + 616 | 0); + HEAP32[$0 + 2624 >> 2] = 0; + HEAP32[$0 + 2620 >> 2] = 277; + $1 = HEAP32[$0 + 2624 >> 2]; + $2 = HEAP32[$0 + 2620 >> 2]; + HEAP32[$0 + 11224 >> 2] = $2; + HEAP32[$0 + 11228 >> 2] = $1; + $1 = HEAP32[$0 + 11224 >> 2]; + $2 = HEAP32[$0 + 11228 >> 2]; + HEAP32[$0 + 11252 >> 2] = $3; + HEAP32[$0 + 11248 >> 2] = 3009; + HEAP32[$0 + 11244 >> 2] = $2; + HEAP32[$0 + 11240 >> 2] = $1; + $3 = HEAP32[$0 + 11252 >> 2]; + $4 = HEAP32[$0 + 11248 >> 2]; + $1 = HEAP32[$0 + 11240 >> 2]; + HEAP32[$0 + 11236 >> 2] = HEAP32[$0 + 11244 >> 2]; + HEAP32[$0 + 11232 >> 2] = $1; + $2 = HEAP32[$0 + 11236 >> 2]; + $1 = HEAP32[$0 + 11232 >> 2]; + HEAP32[$0 + 608 >> 2] = $1; + HEAP32[$0 + 612 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2MouseJoint____29_28_29_20const___invoke_b2MouseJoint__28char_20const__2c_20b2Vec2_20const__20_28b2MouseJoint____29_28_29_20const_29($4, $0 + 608 | 0); + HEAP32[$0 + 2616 >> 2] = 0; + HEAP32[$0 + 2612 >> 2] = 278; + $1 = HEAP32[$0 + 2616 >> 2]; + $2 = HEAP32[$0 + 2612 >> 2]; + HEAP32[$0 + 11320 >> 2] = $2; + HEAP32[$0 + 11324 >> 2] = $1; + $1 = HEAP32[$0 + 11320 >> 2]; + $2 = HEAP32[$0 + 11324 >> 2]; + HEAP32[$0 + 11348 >> 2] = $3; + HEAP32[$0 + 11344 >> 2] = 9872; + HEAP32[$0 + 11340 >> 2] = $2; + HEAP32[$0 + 11336 >> 2] = $1; + $3 = HEAP32[$0 + 11348 >> 2]; + $4 = HEAP32[$0 + 11344 >> 2]; + $1 = HEAP32[$0 + 11336 >> 2]; + HEAP32[$0 + 11332 >> 2] = HEAP32[$0 + 11340 >> 2]; + HEAP32[$0 + 11328 >> 2] = $1; + $2 = HEAP32[$0 + 11332 >> 2]; + $1 = HEAP32[$0 + 11328 >> 2]; + HEAP32[$0 + 600 >> 2] = $1; + HEAP32[$0 + 604 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2MouseJoint____29_28float_29___invoke_b2MouseJoint__28char_20const__2c_20void_20_28b2MouseJoint____29_28float_29_29($4, $0 + 600 | 0); + HEAP32[$0 + 2608 >> 2] = 0; + HEAP32[$0 + 2604 >> 2] = 279; + $1 = HEAP32[$0 + 2608 >> 2]; + $2 = HEAP32[$0 + 2604 >> 2]; + HEAP32[$0 + 11416 >> 2] = $2; + HEAP32[$0 + 11420 >> 2] = $1; + $1 = HEAP32[$0 + 11416 >> 2]; + $2 = HEAP32[$0 + 11420 >> 2]; + HEAP32[$0 + 11444 >> 2] = $3; + HEAP32[$0 + 11440 >> 2] = 9884; + HEAP32[$0 + 11436 >> 2] = $2; + HEAP32[$0 + 11432 >> 2] = $1; + $3 = HEAP32[$0 + 11444 >> 2]; + $4 = HEAP32[$0 + 11440 >> 2]; + $1 = HEAP32[$0 + 11432 >> 2]; + HEAP32[$0 + 11428 >> 2] = HEAP32[$0 + 11436 >> 2]; + HEAP32[$0 + 11424 >> 2] = $1; + $2 = HEAP32[$0 + 11428 >> 2]; + $1 = HEAP32[$0 + 11424 >> 2]; + HEAP32[$0 + 592 >> 2] = $1; + HEAP32[$0 + 596 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2MouseJoint____29_28_29_20const___invoke_b2MouseJoint__28char_20const__2c_20float_20_28b2MouseJoint____29_28_29_20const_29($4, $0 + 592 | 0); + HEAP32[$0 + 2600 >> 2] = 0; + HEAP32[$0 + 2596 >> 2] = 280; + $1 = HEAP32[$0 + 2600 >> 2]; + $2 = HEAP32[$0 + 2596 >> 2]; + HEAP32[$0 + 11288 >> 2] = $2; + HEAP32[$0 + 11292 >> 2] = $1; + $1 = HEAP32[$0 + 11288 >> 2]; + $2 = HEAP32[$0 + 11292 >> 2]; + HEAP32[$0 + 11316 >> 2] = $3; + HEAP32[$0 + 11312 >> 2] = 1709; + HEAP32[$0 + 11308 >> 2] = $2; + HEAP32[$0 + 11304 >> 2] = $1; + $3 = HEAP32[$0 + 11316 >> 2]; + $4 = HEAP32[$0 + 11312 >> 2]; + $1 = HEAP32[$0 + 11304 >> 2]; + HEAP32[$0 + 11300 >> 2] = HEAP32[$0 + 11308 >> 2]; + HEAP32[$0 + 11296 >> 2] = $1; + $2 = HEAP32[$0 + 11300 >> 2]; + $1 = HEAP32[$0 + 11296 >> 2]; + HEAP32[$0 + 584 >> 2] = $1; + HEAP32[$0 + 588 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2MouseJoint____29_28float_29___invoke_b2MouseJoint__28char_20const__2c_20void_20_28b2MouseJoint____29_28float_29_29($4, $0 + 584 | 0); + HEAP32[$0 + 2592 >> 2] = 0; + HEAP32[$0 + 2588 >> 2] = 281; + $1 = HEAP32[$0 + 2592 >> 2]; + $2 = HEAP32[$0 + 2588 >> 2]; + HEAP32[$0 + 11384 >> 2] = $2; + HEAP32[$0 + 11388 >> 2] = $1; + $1 = HEAP32[$0 + 11384 >> 2]; + $2 = HEAP32[$0 + 11388 >> 2]; + HEAP32[$0 + 11412 >> 2] = $3; + HEAP32[$0 + 11408 >> 2] = 1722; + HEAP32[$0 + 11404 >> 2] = $2; + HEAP32[$0 + 11400 >> 2] = $1; + $3 = HEAP32[$0 + 11412 >> 2]; + $4 = HEAP32[$0 + 11408 >> 2]; + $1 = HEAP32[$0 + 11400 >> 2]; + HEAP32[$0 + 11396 >> 2] = HEAP32[$0 + 11404 >> 2]; + HEAP32[$0 + 11392 >> 2] = $1; + $2 = HEAP32[$0 + 11396 >> 2]; + $1 = HEAP32[$0 + 11392 >> 2]; + HEAP32[$0 + 576 >> 2] = $1; + HEAP32[$0 + 580 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2MouseJoint____29_28_29_20const___invoke_b2MouseJoint__28char_20const__2c_20float_20_28b2MouseJoint____29_28_29_20const_29($4, $0 + 576 | 0); + HEAP32[$0 + 2584 >> 2] = 0; + HEAP32[$0 + 2580 >> 2] = 282; + $1 = HEAP32[$0 + 2584 >> 2]; + $2 = HEAP32[$0 + 2580 >> 2]; + HEAP32[$0 + 11256 >> 2] = $2; + HEAP32[$0 + 11260 >> 2] = $1; + $1 = HEAP32[$0 + 11256 >> 2]; + $2 = HEAP32[$0 + 11260 >> 2]; + HEAP32[$0 + 11284 >> 2] = $3; + HEAP32[$0 + 11280 >> 2] = 6291; + HEAP32[$0 + 11276 >> 2] = $2; + HEAP32[$0 + 11272 >> 2] = $1; + $3 = HEAP32[$0 + 11284 >> 2]; + $4 = HEAP32[$0 + 11280 >> 2]; + $1 = HEAP32[$0 + 11272 >> 2]; + HEAP32[$0 + 11268 >> 2] = HEAP32[$0 + 11276 >> 2]; + HEAP32[$0 + 11264 >> 2] = $1; + $2 = HEAP32[$0 + 11268 >> 2]; + $1 = HEAP32[$0 + 11264 >> 2]; + HEAP32[$0 + 568 >> 2] = $1; + HEAP32[$0 + 572 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2MouseJoint____29_28float_29___invoke_b2MouseJoint__28char_20const__2c_20void_20_28b2MouseJoint____29_28float_29_29($4, $0 + 568 | 0); + HEAP32[$0 + 2576 >> 2] = 0; + HEAP32[$0 + 2572 >> 2] = 283; + $1 = HEAP32[$0 + 2576 >> 2]; + $2 = HEAP32[$0 + 2572 >> 2]; + HEAP32[$0 + 11352 >> 2] = $2; + HEAP32[$0 + 11356 >> 2] = $1; + $1 = HEAP32[$0 + 11352 >> 2]; + $2 = HEAP32[$0 + 11356 >> 2]; + HEAP32[$0 + 11380 >> 2] = $3; + HEAP32[$0 + 11376 >> 2] = 6307; + HEAP32[$0 + 11372 >> 2] = $2; + HEAP32[$0 + 11368 >> 2] = $1; + $3 = HEAP32[$0 + 11380 >> 2]; + $4 = HEAP32[$0 + 11376 >> 2]; + $1 = HEAP32[$0 + 11368 >> 2]; + HEAP32[$0 + 11364 >> 2] = HEAP32[$0 + 11372 >> 2]; + HEAP32[$0 + 11360 >> 2] = $1; + $2 = HEAP32[$0 + 11364 >> 2]; + $1 = HEAP32[$0 + 11360 >> 2]; + HEAP32[$0 + 560 >> 2] = $1; + HEAP32[$0 + 564 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2MouseJoint____29_28_29_20const___invoke_b2MouseJoint__28char_20const__2c_20float_20_28b2MouseJoint____29_28_29_20const_29($4, $0 + 560 | 0); + HEAP32[$0 + 2568 >> 2] = 1; + HEAP32[$0 + 2564 >> 2] = 16; + $1 = HEAP32[$0 + 2568 >> 2]; + $2 = HEAP32[$0 + 2564 >> 2]; + HEAP32[$0 + 11448 >> 2] = $2; + HEAP32[$0 + 11452 >> 2] = $1; + $1 = HEAP32[$0 + 11448 >> 2]; + $2 = HEAP32[$0 + 11452 >> 2]; + HEAP32[$0 + 11480 >> 2] = $3; + HEAP32[$0 + 11476 >> 2] = 6232; + HEAP32[$0 + 11472 >> 2] = $2; + HEAP32[$0 + 11468 >> 2] = $1; + $3 = HEAP32[$0 + 11476 >> 2]; + $1 = HEAP32[$0 + 11468 >> 2]; + HEAP32[$0 + 11464 >> 2] = HEAP32[$0 + 11472 >> 2]; + HEAP32[$0 + 11460 >> 2] = $1; + $2 = HEAP32[$0 + 11464 >> 2]; + $1 = HEAP32[$0 + 11460 >> 2]; + HEAP32[$0 + 552 >> 2] = $1; + HEAP32[$0 + 556 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2MouseJoint____29_28_29___invoke_b2MouseJoint__28char_20const__2c_20void_20_28b2MouseJoint____29_28_29_29($3, $0 + 552 | 0); + HEAP32[$0 + 11504 >> 2] = $0 + 2563; + HEAP32[$0 + 11500 >> 2] = 7989; + void_20emscripten__base_b2JointDef___verify_b2PrismaticJointDef__28_29(); + HEAP32[$0 + 11496 >> 2] = 284; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2PrismaticJointDef__28_29_29_28b2PrismaticJointDef__29(), + HEAP32[wasm2js_i32$0 + 11492 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2PrismaticJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2PrismaticJointDef__28_29_29_28b2JointDef__29(), + HEAP32[wasm2js_i32$0 + 11488 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 11484 >> 2] = 285; + $1 = emscripten__internal__TypeID_b2PrismaticJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2PrismaticJointDef__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2PrismaticJointDef_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2JointDef___get_28_29(); + HEAP32[$0 + 15848 >> 2] = HEAP32[$0 + 11496 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11496 >> 2]; + HEAP32[$0 + 15852 >> 2] = HEAP32[$0 + 11492 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 11492 >> 2]; + HEAP32[$0 + 15856 >> 2] = HEAP32[$0 + 11488 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 11488 >> 2]; + $11 = HEAP32[$0 + 11500 >> 2]; + HEAP32[$0 + 15860 >> 2] = HEAP32[$0 + 11484 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 11484 >> 2]); + HEAP32[$0 + 11508 >> 2] = $0 + 2563; + HEAP32[$0 + 15868 >> 2] = HEAP32[$0 + 11508 >> 2]; + HEAP32[$0 + 15864 >> 2] = 286; + $1 = HEAP32[$0 + 15868 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2PrismaticJointDef__20_28__29_28_29___invoke_b2PrismaticJointDef__28b2PrismaticJointDef__20_28__29_28_29_29(HEAP32[$0 + 15864 >> 2]); + HEAP32[$0 + 11568 >> 2] = $1; + HEAP32[$0 + 11564 >> 2] = 11158; + HEAP32[$0 + 11560 >> 2] = 20; + $1 = HEAP32[$0 + 11568 >> 2]; + HEAP32[$0 + 11556 >> 2] = 287; + HEAP32[$0 + 11552 >> 2] = 288; + $2 = emscripten__internal__TypeID_b2PrismaticJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 11564 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15872 >> 2] = HEAP32[$0 + 11556 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11556 >> 2]; + $7 = b2Vec2_20b2PrismaticJointDef_____20emscripten__internal__getContext_b2Vec2_20b2PrismaticJointDef_____28b2Vec2_20b2PrismaticJointDef____20const__29($0 + 11560 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15884 >> 2] = HEAP32[$0 + 11552 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 11552 >> 2], b2Vec2_20b2PrismaticJointDef_____20emscripten__internal__getContext_b2Vec2_20b2PrismaticJointDef_____28b2Vec2_20b2PrismaticJointDef____20const__29($0 + 11560 | 0) | 0); + HEAP32[$0 + 11548 >> 2] = $1; + HEAP32[$0 + 11544 >> 2] = 11015; + HEAP32[$0 + 11540 >> 2] = 28; + $1 = HEAP32[$0 + 11548 >> 2]; + HEAP32[$0 + 11536 >> 2] = 287; + HEAP32[$0 + 11532 >> 2] = 288; + $2 = emscripten__internal__TypeID_b2PrismaticJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 11544 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15876 >> 2] = HEAP32[$0 + 11536 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11536 >> 2]; + $7 = b2Vec2_20b2PrismaticJointDef_____20emscripten__internal__getContext_b2Vec2_20b2PrismaticJointDef_____28b2Vec2_20b2PrismaticJointDef____20const__29($0 + 11540 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15888 >> 2] = HEAP32[$0 + 11532 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 11532 >> 2], b2Vec2_20b2PrismaticJointDef_____20emscripten__internal__getContext_b2Vec2_20b2PrismaticJointDef_____28b2Vec2_20b2PrismaticJointDef____20const__29($0 + 11540 | 0) | 0); + HEAP32[$0 + 11528 >> 2] = $1; + HEAP32[$0 + 11524 >> 2] = 11122; + HEAP32[$0 + 11520 >> 2] = 36; + $1 = HEAP32[$0 + 11528 >> 2]; + HEAP32[$0 + 11516 >> 2] = 287; + HEAP32[$0 + 11512 >> 2] = 288; + $2 = emscripten__internal__TypeID_b2PrismaticJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 11524 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15880 >> 2] = HEAP32[$0 + 11516 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11516 >> 2]; + $7 = b2Vec2_20b2PrismaticJointDef_____20emscripten__internal__getContext_b2Vec2_20b2PrismaticJointDef_____28b2Vec2_20b2PrismaticJointDef____20const__29($0 + 11520 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15892 >> 2] = HEAP32[$0 + 11512 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 11512 >> 2], b2Vec2_20b2PrismaticJointDef_____20emscripten__internal__getContext_b2Vec2_20b2PrismaticJointDef_____28b2Vec2_20b2PrismaticJointDef____20const__29($0 + 11520 | 0) | 0); + HEAP32[$0 + 11668 >> 2] = $1; + HEAP32[$0 + 11664 >> 2] = 9471; + HEAP32[$0 + 11660 >> 2] = 44; + $1 = HEAP32[$0 + 11668 >> 2]; + HEAP32[$0 + 11656 >> 2] = 289; + HEAP32[$0 + 11652 >> 2] = 290; + $2 = emscripten__internal__TypeID_b2PrismaticJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 11664 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15896 >> 2] = HEAP32[$0 + 11656 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11656 >> 2]; + $7 = float_20b2PrismaticJointDef_____20emscripten__internal__getContext_float_20b2PrismaticJointDef_____28float_20b2PrismaticJointDef____20const__29($0 + 11660 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15916 >> 2] = HEAP32[$0 + 11652 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 11652 >> 2], float_20b2PrismaticJointDef_____20emscripten__internal__getContext_float_20b2PrismaticJointDef_____28float_20b2PrismaticJointDef____20const__29($0 + 11660 | 0) | 0); + HEAP32[$0 + 11708 >> 2] = $1; + HEAP32[$0 + 11704 >> 2] = 2849; + HEAP32[$0 + 11700 >> 2] = 48; + $1 = HEAP32[$0 + 11708 >> 2]; + HEAP32[$0 + 11696 >> 2] = 291; + HEAP32[$0 + 11692 >> 2] = 292; + $2 = emscripten__internal__TypeID_b2PrismaticJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 11704 >> 2]; + $4 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15936 >> 2] = HEAP32[$0 + 11696 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11696 >> 2]; + $7 = bool_20b2PrismaticJointDef_____20emscripten__internal__getContext_bool_20b2PrismaticJointDef_____28bool_20b2PrismaticJointDef____20const__29($0 + 11700 | 0); + $8 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15944 >> 2] = HEAP32[$0 + 11692 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 11692 >> 2], bool_20b2PrismaticJointDef_____20emscripten__internal__getContext_bool_20b2PrismaticJointDef_____28bool_20b2PrismaticJointDef____20const__29($0 + 11700 | 0) | 0); + HEAP32[$0 + 11648 >> 2] = $1; + HEAP32[$0 + 11644 >> 2] = 6703; + HEAP32[$0 + 11640 >> 2] = 52; + $1 = HEAP32[$0 + 11648 >> 2]; + HEAP32[$0 + 11636 >> 2] = 289; + HEAP32[$0 + 11632 >> 2] = 290; + $2 = emscripten__internal__TypeID_b2PrismaticJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 11644 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15900 >> 2] = HEAP32[$0 + 11636 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11636 >> 2]; + $7 = float_20b2PrismaticJointDef_____20emscripten__internal__getContext_float_20b2PrismaticJointDef_____28float_20b2PrismaticJointDef____20const__29($0 + 11640 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15920 >> 2] = HEAP32[$0 + 11632 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 11632 >> 2], float_20b2PrismaticJointDef_____20emscripten__internal__getContext_float_20b2PrismaticJointDef_____28float_20b2PrismaticJointDef____20const__29($0 + 11640 | 0) | 0); + HEAP32[$0 + 11628 >> 2] = $1; + HEAP32[$0 + 11624 >> 2] = 6744; + HEAP32[$0 + 11620 >> 2] = 56; + $1 = HEAP32[$0 + 11628 >> 2]; + HEAP32[$0 + 11616 >> 2] = 289; + HEAP32[$0 + 11612 >> 2] = 290; + $2 = emscripten__internal__TypeID_b2PrismaticJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 11624 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15904 >> 2] = HEAP32[$0 + 11616 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11616 >> 2]; + $7 = float_20b2PrismaticJointDef_____20emscripten__internal__getContext_float_20b2PrismaticJointDef_____28float_20b2PrismaticJointDef____20const__29($0 + 11620 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15924 >> 2] = HEAP32[$0 + 11612 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 11612 >> 2], float_20b2PrismaticJointDef_____20emscripten__internal__getContext_float_20b2PrismaticJointDef_____28float_20b2PrismaticJointDef____20const__29($0 + 11620 | 0) | 0); + HEAP32[$0 + 11688 >> 2] = $1; + HEAP32[$0 + 11684 >> 2] = 3640; + HEAP32[$0 + 11680 >> 2] = 60; + $1 = HEAP32[$0 + 11688 >> 2]; + HEAP32[$0 + 11676 >> 2] = 291; + HEAP32[$0 + 11672 >> 2] = 292; + $2 = emscripten__internal__TypeID_b2PrismaticJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 11684 >> 2]; + $4 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15940 >> 2] = HEAP32[$0 + 11676 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11676 >> 2]; + $7 = bool_20b2PrismaticJointDef_____20emscripten__internal__getContext_bool_20b2PrismaticJointDef_____28bool_20b2PrismaticJointDef____20const__29($0 + 11680 | 0); + $8 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 15948 >> 2] = HEAP32[$0 + 11672 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 11672 >> 2], bool_20b2PrismaticJointDef_____20emscripten__internal__getContext_bool_20b2PrismaticJointDef_____28bool_20b2PrismaticJointDef____20const__29($0 + 11680 | 0) | 0); + HEAP32[$0 + 11608 >> 2] = $1; + HEAP32[$0 + 11604 >> 2] = 10349; + HEAP32[$0 + 11600 >> 2] = 68; + $1 = HEAP32[$0 + 11608 >> 2]; + HEAP32[$0 + 11596 >> 2] = 289; + HEAP32[$0 + 11592 >> 2] = 290; + $2 = emscripten__internal__TypeID_b2PrismaticJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 11604 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15908 >> 2] = HEAP32[$0 + 11596 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11596 >> 2]; + $7 = float_20b2PrismaticJointDef_____20emscripten__internal__getContext_float_20b2PrismaticJointDef_____28float_20b2PrismaticJointDef____20const__29($0 + 11600 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15928 >> 2] = HEAP32[$0 + 11592 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 11592 >> 2], float_20b2PrismaticJointDef_____20emscripten__internal__getContext_float_20b2PrismaticJointDef_____28float_20b2PrismaticJointDef____20const__29($0 + 11600 | 0) | 0); + HEAP32[$0 + 11588 >> 2] = $1; + HEAP32[$0 + 11584 >> 2] = 9896; + HEAP32[$0 + 11580 >> 2] = 64; + HEAP32[$0 + 11576 >> 2] = 289; + HEAP32[$0 + 11572 >> 2] = 290; + $1 = emscripten__internal__TypeID_b2PrismaticJointDef_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 11584 >> 2]; + $3 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15912 >> 2] = HEAP32[$0 + 11576 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $5 = HEAP32[$0 + 11576 >> 2]; + $6 = float_20b2PrismaticJointDef_____20emscripten__internal__getContext_float_20b2PrismaticJointDef_____28float_20b2PrismaticJointDef____20const__29($0 + 11580 | 0); + $7 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 15932 >> 2] = HEAP32[$0 + 11572 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 11572 >> 2], float_20b2PrismaticJointDef_____20emscripten__internal__getContext_float_20b2PrismaticJointDef_____28float_20b2PrismaticJointDef____20const__29($0 + 11580 | 0) | 0); + HEAP32[$0 + 11732 >> 2] = $0 + 2562; + HEAP32[$0 + 11728 >> 2] = 2763; + void_20emscripten__base_b2Joint___verify_b2PrismaticJoint__28_29(); + HEAP32[$0 + 11724 >> 2] = 293; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2PrismaticJoint__28_29_29_28b2PrismaticJoint__29(), + HEAP32[wasm2js_i32$0 + 11720 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2PrismaticJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2PrismaticJoint__28_29_29_28b2Joint__29(), + HEAP32[wasm2js_i32$0 + 11716 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 11712 >> 2] = 294; + $1 = emscripten__internal__TypeID_b2PrismaticJoint_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2Joint___get_28_29(); + HEAP32[$0 + 15952 >> 2] = HEAP32[$0 + 11724 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 11724 >> 2]; + HEAP32[$0 + 15956 >> 2] = HEAP32[$0 + 11720 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 11720 >> 2]; + HEAP32[$0 + 15960 >> 2] = HEAP32[$0 + 11716 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 11716 >> 2]; + $11 = HEAP32[$0 + 11728 >> 2]; + HEAP32[$0 + 15964 >> 2] = HEAP32[$0 + 11712 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 11712 >> 2]); + HEAP32[$0 + 2556 >> 2] = 0; + HEAP32[$0 + 2552 >> 2] = 295; + $1 = HEAP32[$0 + 2556 >> 2]; + $2 = HEAP32[$0 + 2552 >> 2]; + HEAP32[$0 + 11800 >> 2] = $2; + HEAP32[$0 + 11804 >> 2] = $1; + $1 = HEAP32[$0 + 11800 >> 2]; + $2 = HEAP32[$0 + 11804 >> 2]; + HEAP32[$0 + 11828 >> 2] = $0 + 2562; + HEAP32[$0 + 11824 >> 2] = 11171; + HEAP32[$0 + 11820 >> 2] = $2; + HEAP32[$0 + 11816 >> 2] = $1; + $3 = HEAP32[$0 + 11828 >> 2]; + $4 = HEAP32[$0 + 11824 >> 2]; + $1 = HEAP32[$0 + 11816 >> 2]; + HEAP32[$0 + 11812 >> 2] = HEAP32[$0 + 11820 >> 2]; + HEAP32[$0 + 11808 >> 2] = $1; + $2 = HEAP32[$0 + 11812 >> 2]; + $1 = HEAP32[$0 + 11808 >> 2]; + HEAP32[$0 + 544 >> 2] = $1; + HEAP32[$0 + 548 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20b2Vec2_20const__20_28b2PrismaticJoint____29_28_29_20const_29($4, $0 + 544 | 0); + HEAP32[$0 + 2548 >> 2] = 0; + HEAP32[$0 + 2544 >> 2] = 296; + $1 = HEAP32[$0 + 2548 >> 2]; + $2 = HEAP32[$0 + 2544 >> 2]; + HEAP32[$0 + 11768 >> 2] = $2; + HEAP32[$0 + 11772 >> 2] = $1; + $1 = HEAP32[$0 + 11768 >> 2]; + $2 = HEAP32[$0 + 11772 >> 2]; + HEAP32[$0 + 11796 >> 2] = $3; + HEAP32[$0 + 11792 >> 2] = 11028; + HEAP32[$0 + 11788 >> 2] = $2; + HEAP32[$0 + 11784 >> 2] = $1; + $3 = HEAP32[$0 + 11796 >> 2]; + $4 = HEAP32[$0 + 11792 >> 2]; + $1 = HEAP32[$0 + 11784 >> 2]; + HEAP32[$0 + 11780 >> 2] = HEAP32[$0 + 11788 >> 2]; + HEAP32[$0 + 11776 >> 2] = $1; + $2 = HEAP32[$0 + 11780 >> 2]; + $1 = HEAP32[$0 + 11776 >> 2]; + HEAP32[$0 + 536 >> 2] = $1; + HEAP32[$0 + 540 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20b2Vec2_20const__20_28b2PrismaticJoint____29_28_29_20const_29($4, $0 + 536 | 0); + HEAP32[$0 + 2540 >> 2] = 0; + HEAP32[$0 + 2536 >> 2] = 297; + $1 = HEAP32[$0 + 2540 >> 2]; + $2 = HEAP32[$0 + 2536 >> 2]; + HEAP32[$0 + 11736 >> 2] = $2; + HEAP32[$0 + 11740 >> 2] = $1; + $1 = HEAP32[$0 + 11736 >> 2]; + $2 = HEAP32[$0 + 11740 >> 2]; + HEAP32[$0 + 11764 >> 2] = $3; + HEAP32[$0 + 11760 >> 2] = 11133; + HEAP32[$0 + 11756 >> 2] = $2; + HEAP32[$0 + 11752 >> 2] = $1; + $3 = HEAP32[$0 + 11764 >> 2]; + $4 = HEAP32[$0 + 11760 >> 2]; + $1 = HEAP32[$0 + 11752 >> 2]; + HEAP32[$0 + 11748 >> 2] = HEAP32[$0 + 11756 >> 2]; + HEAP32[$0 + 11744 >> 2] = $1; + $2 = HEAP32[$0 + 11748 >> 2]; + $1 = HEAP32[$0 + 11744 >> 2]; + HEAP32[$0 + 528 >> 2] = $1; + HEAP32[$0 + 532 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20b2Vec2_20const__20_28b2PrismaticJoint____29_28_29_20const_29($4, $0 + 528 | 0); + HEAP32[$0 + 2532 >> 2] = 0; + HEAP32[$0 + 2528 >> 2] = 298; + $1 = HEAP32[$0 + 2532 >> 2]; + $2 = HEAP32[$0 + 2528 >> 2]; + HEAP32[$0 + 12024 >> 2] = $2; + HEAP32[$0 + 12028 >> 2] = $1; + $1 = HEAP32[$0 + 12024 >> 2]; + $2 = HEAP32[$0 + 12028 >> 2]; + HEAP32[$0 + 12052 >> 2] = $3; + HEAP32[$0 + 12048 >> 2] = 9486; + HEAP32[$0 + 12044 >> 2] = $2; + HEAP32[$0 + 12040 >> 2] = $1; + $3 = HEAP32[$0 + 12052 >> 2]; + $4 = HEAP32[$0 + 12048 >> 2]; + $1 = HEAP32[$0 + 12040 >> 2]; + HEAP32[$0 + 12036 >> 2] = HEAP32[$0 + 12044 >> 2]; + HEAP32[$0 + 12032 >> 2] = $1; + $2 = HEAP32[$0 + 12036 >> 2]; + $1 = HEAP32[$0 + 12032 >> 2]; + HEAP32[$0 + 520 >> 2] = $1; + HEAP32[$0 + 524 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20float_20_28b2PrismaticJoint____29_28_29_20const_29($4, $0 + 520 | 0); + HEAP32[$0 + 2524 >> 2] = 0; + HEAP32[$0 + 2520 >> 2] = 299; + $1 = HEAP32[$0 + 2524 >> 2]; + $2 = HEAP32[$0 + 2520 >> 2]; + HEAP32[$0 + 11992 >> 2] = $2; + HEAP32[$0 + 11996 >> 2] = $1; + $1 = HEAP32[$0 + 11992 >> 2]; + $2 = HEAP32[$0 + 11996 >> 2]; + HEAP32[$0 + 12020 >> 2] = $3; + HEAP32[$0 + 12016 >> 2] = 6683; + HEAP32[$0 + 12012 >> 2] = $2; + HEAP32[$0 + 12008 >> 2] = $1; + $3 = HEAP32[$0 + 12020 >> 2]; + $4 = HEAP32[$0 + 12016 >> 2]; + $1 = HEAP32[$0 + 12008 >> 2]; + HEAP32[$0 + 12004 >> 2] = HEAP32[$0 + 12012 >> 2]; + HEAP32[$0 + 12e3 >> 2] = $1; + $2 = HEAP32[$0 + 12004 >> 2]; + $1 = HEAP32[$0 + 12e3 >> 2]; + HEAP32[$0 + 512 >> 2] = $1; + HEAP32[$0 + 516 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20float_20_28b2PrismaticJoint____29_28_29_20const_29($4, $0 + 512 | 0); + HEAP32[$0 + 2516 >> 2] = 0; + HEAP32[$0 + 2512 >> 2] = 300; + $1 = HEAP32[$0 + 2516 >> 2]; + $2 = HEAP32[$0 + 2512 >> 2]; + HEAP32[$0 + 11960 >> 2] = $2; + HEAP32[$0 + 11964 >> 2] = $1; + $1 = HEAP32[$0 + 11960 >> 2]; + $2 = HEAP32[$0 + 11964 >> 2]; + HEAP32[$0 + 11988 >> 2] = $3; + HEAP32[$0 + 11984 >> 2] = 10289; + HEAP32[$0 + 11980 >> 2] = $2; + HEAP32[$0 + 11976 >> 2] = $1; + $3 = HEAP32[$0 + 11988 >> 2]; + $4 = HEAP32[$0 + 11984 >> 2]; + $1 = HEAP32[$0 + 11976 >> 2]; + HEAP32[$0 + 11972 >> 2] = HEAP32[$0 + 11980 >> 2]; + HEAP32[$0 + 11968 >> 2] = $1; + $2 = HEAP32[$0 + 11972 >> 2]; + $1 = HEAP32[$0 + 11968 >> 2]; + HEAP32[$0 + 504 >> 2] = $1; + HEAP32[$0 + 508 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20float_20_28b2PrismaticJoint____29_28_29_20const_29($4, $0 + 504 | 0); + HEAP32[$0 + 2508 >> 2] = 0; + HEAP32[$0 + 2504 >> 2] = 301; + $1 = HEAP32[$0 + 2508 >> 2]; + $2 = HEAP32[$0 + 2504 >> 2]; + HEAP32[$0 + 12088 >> 2] = $2; + HEAP32[$0 + 12092 >> 2] = $1; + $1 = HEAP32[$0 + 12088 >> 2]; + $2 = HEAP32[$0 + 12092 >> 2]; + HEAP32[$0 + 12116 >> 2] = $3; + HEAP32[$0 + 12112 >> 2] = 10231; + HEAP32[$0 + 12108 >> 2] = $2; + HEAP32[$0 + 12104 >> 2] = $1; + $3 = HEAP32[$0 + 12116 >> 2]; + $4 = HEAP32[$0 + 12112 >> 2]; + $1 = HEAP32[$0 + 12104 >> 2]; + HEAP32[$0 + 12100 >> 2] = HEAP32[$0 + 12108 >> 2]; + HEAP32[$0 + 12096 >> 2] = $1; + $2 = HEAP32[$0 + 12100 >> 2]; + $1 = HEAP32[$0 + 12096 >> 2]; + HEAP32[$0 + 496 >> 2] = $1; + HEAP32[$0 + 500 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20bool_20_28b2PrismaticJoint____29_28_29_20const_29($4, $0 + 496 | 0); + HEAP32[$0 + 2500 >> 2] = 0; + HEAP32[$0 + 2496 >> 2] = 302; + $1 = HEAP32[$0 + 2500 >> 2]; + $2 = HEAP32[$0 + 2496 >> 2]; + HEAP32[$0 + 12152 >> 2] = $2; + HEAP32[$0 + 12156 >> 2] = $1; + $1 = HEAP32[$0 + 12152 >> 2]; + $2 = HEAP32[$0 + 12156 >> 2]; + HEAP32[$0 + 12180 >> 2] = $3; + HEAP32[$0 + 12176 >> 2] = 2861; + HEAP32[$0 + 12172 >> 2] = $2; + HEAP32[$0 + 12168 >> 2] = $1; + $3 = HEAP32[$0 + 12180 >> 2]; + $4 = HEAP32[$0 + 12176 >> 2]; + $1 = HEAP32[$0 + 12168 >> 2]; + HEAP32[$0 + 12164 >> 2] = HEAP32[$0 + 12172 >> 2]; + HEAP32[$0 + 12160 >> 2] = $1; + $2 = HEAP32[$0 + 12164 >> 2]; + $1 = HEAP32[$0 + 12160 >> 2]; + HEAP32[$0 + 488 >> 2] = $1; + HEAP32[$0 + 492 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2PrismaticJoint____29_28bool_29___invoke_b2PrismaticJoint__28char_20const__2c_20void_20_28b2PrismaticJoint____29_28bool_29_29($4, $0 + 488 | 0); + HEAP32[$0 + 2492 >> 2] = 0; + HEAP32[$0 + 2488 >> 2] = 303; + $1 = HEAP32[$0 + 2492 >> 2]; + $2 = HEAP32[$0 + 2488 >> 2]; + HEAP32[$0 + 11928 >> 2] = $2; + HEAP32[$0 + 11932 >> 2] = $1; + $1 = HEAP32[$0 + 11928 >> 2]; + $2 = HEAP32[$0 + 11932 >> 2]; + HEAP32[$0 + 11956 >> 2] = $3; + HEAP32[$0 + 11952 >> 2] = 2821; + HEAP32[$0 + 11948 >> 2] = $2; + HEAP32[$0 + 11944 >> 2] = $1; + $3 = HEAP32[$0 + 11956 >> 2]; + $4 = HEAP32[$0 + 11952 >> 2]; + $1 = HEAP32[$0 + 11944 >> 2]; + HEAP32[$0 + 11940 >> 2] = HEAP32[$0 + 11948 >> 2]; + HEAP32[$0 + 11936 >> 2] = $1; + $2 = HEAP32[$0 + 11940 >> 2]; + $1 = HEAP32[$0 + 11936 >> 2]; + HEAP32[$0 + 480 >> 2] = $1; + HEAP32[$0 + 484 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20float_20_28b2PrismaticJoint____29_28_29_20const_29($4, $0 + 480 | 0); + HEAP32[$0 + 2484 >> 2] = 0; + HEAP32[$0 + 2480 >> 2] = 304; + $1 = HEAP32[$0 + 2484 >> 2]; + $2 = HEAP32[$0 + 2480 >> 2]; + HEAP32[$0 + 11896 >> 2] = $2; + HEAP32[$0 + 11900 >> 2] = $1; + $1 = HEAP32[$0 + 11896 >> 2]; + $2 = HEAP32[$0 + 11900 >> 2]; + HEAP32[$0 + 11924 >> 2] = $3; + HEAP32[$0 + 11920 >> 2] = 2835; + HEAP32[$0 + 11916 >> 2] = $2; + HEAP32[$0 + 11912 >> 2] = $1; + $3 = HEAP32[$0 + 11924 >> 2]; + $4 = HEAP32[$0 + 11920 >> 2]; + $1 = HEAP32[$0 + 11912 >> 2]; + HEAP32[$0 + 11908 >> 2] = HEAP32[$0 + 11916 >> 2]; + HEAP32[$0 + 11904 >> 2] = $1; + $2 = HEAP32[$0 + 11908 >> 2]; + $1 = HEAP32[$0 + 11904 >> 2]; + HEAP32[$0 + 472 >> 2] = $1; + HEAP32[$0 + 476 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20float_20_28b2PrismaticJoint____29_28_29_20const_29($4, $0 + 472 | 0); + HEAP32[$0 + 2476 >> 2] = 0; + HEAP32[$0 + 2472 >> 2] = 305; + $1 = HEAP32[$0 + 2476 >> 2]; + $2 = HEAP32[$0 + 2472 >> 2]; + HEAP32[$0 + 12184 >> 2] = $2; + HEAP32[$0 + 12188 >> 2] = $1; + $1 = HEAP32[$0 + 12184 >> 2]; + $2 = HEAP32[$0 + 12188 >> 2]; + HEAP32[$0 + 12212 >> 2] = $3; + HEAP32[$0 + 12208 >> 2] = 3355; + HEAP32[$0 + 12204 >> 2] = $2; + HEAP32[$0 + 12200 >> 2] = $1; + $3 = HEAP32[$0 + 12212 >> 2]; + $4 = HEAP32[$0 + 12208 >> 2]; + $1 = HEAP32[$0 + 12200 >> 2]; + HEAP32[$0 + 12196 >> 2] = HEAP32[$0 + 12204 >> 2]; + HEAP32[$0 + 12192 >> 2] = $1; + $2 = HEAP32[$0 + 12196 >> 2]; + $1 = HEAP32[$0 + 12192 >> 2]; + HEAP32[$0 + 464 >> 2] = $1; + HEAP32[$0 + 468 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2PrismaticJoint____29_28float_2c_20float_29___invoke_b2PrismaticJoint__28char_20const__2c_20void_20_28b2PrismaticJoint____29_28float_2c_20float_29_29($4, $0 + 464 | 0); + HEAP32[$0 + 2468 >> 2] = 0; + HEAP32[$0 + 2464 >> 2] = 306; + $1 = HEAP32[$0 + 2468 >> 2]; + $2 = HEAP32[$0 + 2464 >> 2]; + HEAP32[$0 + 12056 >> 2] = $2; + HEAP32[$0 + 12060 >> 2] = $1; + $1 = HEAP32[$0 + 12056 >> 2]; + $2 = HEAP32[$0 + 12060 >> 2]; + HEAP32[$0 + 12084 >> 2] = $3; + HEAP32[$0 + 12080 >> 2] = 10274; + HEAP32[$0 + 12076 >> 2] = $2; + HEAP32[$0 + 12072 >> 2] = $1; + $3 = HEAP32[$0 + 12084 >> 2]; + $4 = HEAP32[$0 + 12080 >> 2]; + $1 = HEAP32[$0 + 12072 >> 2]; + HEAP32[$0 + 12068 >> 2] = HEAP32[$0 + 12076 >> 2]; + HEAP32[$0 + 12064 >> 2] = $1; + $2 = HEAP32[$0 + 12068 >> 2]; + $1 = HEAP32[$0 + 12064 >> 2]; + HEAP32[$0 + 456 >> 2] = $1; + HEAP32[$0 + 460 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20bool_20_28b2PrismaticJoint____29_28_29_20const_29($4, $0 + 456 | 0); + HEAP32[$0 + 2460 >> 2] = 0; + HEAP32[$0 + 2456 >> 2] = 307; + $1 = HEAP32[$0 + 2460 >> 2]; + $2 = HEAP32[$0 + 2456 >> 2]; + HEAP32[$0 + 12120 >> 2] = $2; + HEAP32[$0 + 12124 >> 2] = $1; + $1 = HEAP32[$0 + 12120 >> 2]; + $2 = HEAP32[$0 + 12124 >> 2]; + HEAP32[$0 + 12148 >> 2] = $3; + HEAP32[$0 + 12144 >> 2] = 3652; + HEAP32[$0 + 12140 >> 2] = $2; + HEAP32[$0 + 12136 >> 2] = $1; + $3 = HEAP32[$0 + 12148 >> 2]; + $4 = HEAP32[$0 + 12144 >> 2]; + $1 = HEAP32[$0 + 12136 >> 2]; + HEAP32[$0 + 12132 >> 2] = HEAP32[$0 + 12140 >> 2]; + HEAP32[$0 + 12128 >> 2] = $1; + $2 = HEAP32[$0 + 12132 >> 2]; + $1 = HEAP32[$0 + 12128 >> 2]; + HEAP32[$0 + 448 >> 2] = $1; + HEAP32[$0 + 452 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2PrismaticJoint____29_28bool_29___invoke_b2PrismaticJoint__28char_20const__2c_20void_20_28b2PrismaticJoint____29_28bool_29_29($4, $0 + 448 | 0); + HEAP32[$0 + 2452 >> 2] = 0; + HEAP32[$0 + 2448 >> 2] = 308; + $1 = HEAP32[$0 + 2452 >> 2]; + $2 = HEAP32[$0 + 2448 >> 2]; + HEAP32[$0 + 12248 >> 2] = $2; + HEAP32[$0 + 12252 >> 2] = $1; + $1 = HEAP32[$0 + 12248 >> 2]; + $2 = HEAP32[$0 + 12252 >> 2]; + HEAP32[$0 + 12276 >> 2] = $3; + HEAP32[$0 + 12272 >> 2] = 10360; + HEAP32[$0 + 12268 >> 2] = $2; + HEAP32[$0 + 12264 >> 2] = $1; + $3 = HEAP32[$0 + 12276 >> 2]; + $4 = HEAP32[$0 + 12272 >> 2]; + $1 = HEAP32[$0 + 12264 >> 2]; + HEAP32[$0 + 12260 >> 2] = HEAP32[$0 + 12268 >> 2]; + HEAP32[$0 + 12256 >> 2] = $1; + $2 = HEAP32[$0 + 12260 >> 2]; + $1 = HEAP32[$0 + 12256 >> 2]; + HEAP32[$0 + 440 >> 2] = $1; + HEAP32[$0 + 444 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2PrismaticJoint____29_28float_29___invoke_b2PrismaticJoint__28char_20const__2c_20void_20_28b2PrismaticJoint____29_28float_29_29($4, $0 + 440 | 0); + HEAP32[$0 + 2444 >> 2] = 0; + HEAP32[$0 + 2440 >> 2] = 309; + $1 = HEAP32[$0 + 2444 >> 2]; + $2 = HEAP32[$0 + 2440 >> 2]; + HEAP32[$0 + 11864 >> 2] = $2; + HEAP32[$0 + 11868 >> 2] = $1; + $1 = HEAP32[$0 + 11864 >> 2]; + $2 = HEAP32[$0 + 11868 >> 2]; + HEAP32[$0 + 11892 >> 2] = $3; + HEAP32[$0 + 11888 >> 2] = 10374; + HEAP32[$0 + 11884 >> 2] = $2; + HEAP32[$0 + 11880 >> 2] = $1; + $3 = HEAP32[$0 + 11892 >> 2]; + $4 = HEAP32[$0 + 11888 >> 2]; + $1 = HEAP32[$0 + 11880 >> 2]; + HEAP32[$0 + 11876 >> 2] = HEAP32[$0 + 11884 >> 2]; + HEAP32[$0 + 11872 >> 2] = $1; + $2 = HEAP32[$0 + 11876 >> 2]; + $1 = HEAP32[$0 + 11872 >> 2]; + HEAP32[$0 + 432 >> 2] = $1; + HEAP32[$0 + 436 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20float_20_28b2PrismaticJoint____29_28_29_20const_29($4, $0 + 432 | 0); + HEAP32[$0 + 2436 >> 2] = 0; + HEAP32[$0 + 2432 >> 2] = 310; + $1 = HEAP32[$0 + 2436 >> 2]; + $2 = HEAP32[$0 + 2432 >> 2]; + HEAP32[$0 + 12216 >> 2] = $2; + HEAP32[$0 + 12220 >> 2] = $1; + $1 = HEAP32[$0 + 12216 >> 2]; + $2 = HEAP32[$0 + 12220 >> 2]; + HEAP32[$0 + 12244 >> 2] = $3; + HEAP32[$0 + 12240 >> 2] = 9910; + HEAP32[$0 + 12236 >> 2] = $2; + HEAP32[$0 + 12232 >> 2] = $1; + $3 = HEAP32[$0 + 12244 >> 2]; + $4 = HEAP32[$0 + 12240 >> 2]; + $1 = HEAP32[$0 + 12232 >> 2]; + HEAP32[$0 + 12228 >> 2] = HEAP32[$0 + 12236 >> 2]; + HEAP32[$0 + 12224 >> 2] = $1; + $2 = HEAP32[$0 + 12228 >> 2]; + $1 = HEAP32[$0 + 12224 >> 2]; + HEAP32[$0 + 424 >> 2] = $1; + HEAP32[$0 + 428 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2PrismaticJoint____29_28float_29___invoke_b2PrismaticJoint__28char_20const__2c_20void_20_28b2PrismaticJoint____29_28float_29_29($4, $0 + 424 | 0); + HEAP32[$0 + 2428 >> 2] = 0; + HEAP32[$0 + 2424 >> 2] = 311; + $1 = HEAP32[$0 + 2428 >> 2]; + $2 = HEAP32[$0 + 2424 >> 2]; + HEAP32[$0 + 11832 >> 2] = $2; + HEAP32[$0 + 11836 >> 2] = $1; + $1 = HEAP32[$0 + 11832 >> 2]; + $2 = HEAP32[$0 + 11836 >> 2]; + HEAP32[$0 + 11860 >> 2] = $3; + HEAP32[$0 + 11856 >> 2] = 9927; + HEAP32[$0 + 11852 >> 2] = $2; + HEAP32[$0 + 11848 >> 2] = $1; + $3 = HEAP32[$0 + 11860 >> 2]; + $4 = HEAP32[$0 + 11856 >> 2]; + $1 = HEAP32[$0 + 11848 >> 2]; + HEAP32[$0 + 11844 >> 2] = HEAP32[$0 + 11852 >> 2]; + HEAP32[$0 + 11840 >> 2] = $1; + $2 = HEAP32[$0 + 11844 >> 2]; + $1 = HEAP32[$0 + 11840 >> 2]; + HEAP32[$0 + 416 >> 2] = $1; + HEAP32[$0 + 420 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20float_20_28b2PrismaticJoint____29_28_29_20const_29($4, $0 + 416 | 0); + HEAP32[$0 + 2420 >> 2] = 0; + HEAP32[$0 + 2416 >> 2] = 312; + $1 = HEAP32[$0 + 2420 >> 2]; + $2 = HEAP32[$0 + 2416 >> 2]; + HEAP32[$0 + 12280 >> 2] = $2; + HEAP32[$0 + 12284 >> 2] = $1; + $1 = HEAP32[$0 + 12280 >> 2]; + $2 = HEAP32[$0 + 12284 >> 2]; + HEAP32[$0 + 12308 >> 2] = $3; + HEAP32[$0 + 12304 >> 2] = 9944; + HEAP32[$0 + 12300 >> 2] = $2; + HEAP32[$0 + 12296 >> 2] = $1; + $3 = HEAP32[$0 + 12308 >> 2]; + $4 = HEAP32[$0 + 12304 >> 2]; + $1 = HEAP32[$0 + 12296 >> 2]; + HEAP32[$0 + 12292 >> 2] = HEAP32[$0 + 12300 >> 2]; + HEAP32[$0 + 12288 >> 2] = $1; + $2 = HEAP32[$0 + 12292 >> 2]; + $1 = HEAP32[$0 + 12288 >> 2]; + HEAP32[$0 + 408 >> 2] = $1; + HEAP32[$0 + 412 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2PrismaticJoint____29_28float_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20float_20_28b2PrismaticJoint____29_28float_29_20const_29($4, $0 + 408 | 0); + HEAP32[$0 + 2412 >> 2] = 1; + HEAP32[$0 + 2408 >> 2] = 16; + $1 = HEAP32[$0 + 2412 >> 2]; + $2 = HEAP32[$0 + 2408 >> 2]; + HEAP32[$0 + 12312 >> 2] = $2; + HEAP32[$0 + 12316 >> 2] = $1; + $1 = HEAP32[$0 + 12312 >> 2]; + $2 = HEAP32[$0 + 12316 >> 2]; + HEAP32[$0 + 12340 >> 2] = $3; + HEAP32[$0 + 12336 >> 2] = 6232; + HEAP32[$0 + 12332 >> 2] = $2; + HEAP32[$0 + 12328 >> 2] = $1; + $3 = HEAP32[$0 + 12336 >> 2]; + $1 = HEAP32[$0 + 12328 >> 2]; + HEAP32[$0 + 12324 >> 2] = HEAP32[$0 + 12332 >> 2]; + HEAP32[$0 + 12320 >> 2] = $1; + $2 = HEAP32[$0 + 12324 >> 2]; + $1 = HEAP32[$0 + 12320 >> 2]; + HEAP32[$0 + 400 >> 2] = $1; + HEAP32[$0 + 404 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2PrismaticJoint____29_28_29___invoke_b2PrismaticJoint__28char_20const__2c_20void_20_28b2PrismaticJoint____29_28_29_29($3, $0 + 400 | 0); + HEAP32[$0 + 12364 >> 2] = $0 + 2407; + HEAP32[$0 + 12360 >> 2] = 7915; + void_20emscripten__base_b2JointDef___verify_b2RevoluteJointDef__28_29(); + HEAP32[$0 + 12356 >> 2] = 313; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2RevoluteJointDef__28_29_29_28b2RevoluteJointDef__29(), + HEAP32[wasm2js_i32$0 + 12352 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2RevoluteJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2RevoluteJointDef__28_29_29_28b2JointDef__29(), + HEAP32[wasm2js_i32$0 + 12348 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 12344 >> 2] = 314; + $1 = emscripten__internal__TypeID_b2RevoluteJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RevoluteJointDef__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RevoluteJointDef_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2JointDef___get_28_29(); + HEAP32[$0 + 15968 >> 2] = HEAP32[$0 + 12356 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 12356 >> 2]; + HEAP32[$0 + 15972 >> 2] = HEAP32[$0 + 12352 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 12352 >> 2]; + HEAP32[$0 + 15976 >> 2] = HEAP32[$0 + 12348 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 12348 >> 2]; + $11 = HEAP32[$0 + 12360 >> 2]; + HEAP32[$0 + 15980 >> 2] = HEAP32[$0 + 12344 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 12344 >> 2]); + HEAP32[$0 + 12368 >> 2] = $0 + 2407; + HEAP32[$0 + 15988 >> 2] = HEAP32[$0 + 12368 >> 2]; + HEAP32[$0 + 15984 >> 2] = 315; + $1 = HEAP32[$0 + 15988 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2RevoluteJointDef__20_28__29_28_29___invoke_b2RevoluteJointDef__28b2RevoluteJointDef__20_28__29_28_29_29(HEAP32[$0 + 15984 >> 2]); + HEAP32[$0 + 12408 >> 2] = $1; + HEAP32[$0 + 12404 >> 2] = 11158; + HEAP32[$0 + 12400 >> 2] = 20; + $1 = HEAP32[$0 + 12408 >> 2]; + HEAP32[$0 + 12396 >> 2] = 316; + HEAP32[$0 + 12392 >> 2] = 317; + $2 = emscripten__internal__TypeID_b2RevoluteJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 12404 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15992 >> 2] = HEAP32[$0 + 12396 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 12396 >> 2]; + $7 = b2Vec2_20b2RevoluteJointDef_____20emscripten__internal__getContext_b2Vec2_20b2RevoluteJointDef_____28b2Vec2_20b2RevoluteJointDef____20const__29($0 + 12400 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16e3 >> 2] = HEAP32[$0 + 12392 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 12392 >> 2], b2Vec2_20b2RevoluteJointDef_____20emscripten__internal__getContext_b2Vec2_20b2RevoluteJointDef_____28b2Vec2_20b2RevoluteJointDef____20const__29($0 + 12400 | 0) | 0); + HEAP32[$0 + 12388 >> 2] = $1; + HEAP32[$0 + 12384 >> 2] = 11015; + HEAP32[$0 + 12380 >> 2] = 28; + $1 = HEAP32[$0 + 12388 >> 2]; + HEAP32[$0 + 12376 >> 2] = 316; + HEAP32[$0 + 12372 >> 2] = 317; + $2 = emscripten__internal__TypeID_b2RevoluteJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 12384 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 15996 >> 2] = HEAP32[$0 + 12376 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 12376 >> 2]; + $7 = b2Vec2_20b2RevoluteJointDef_____20emscripten__internal__getContext_b2Vec2_20b2RevoluteJointDef_____28b2Vec2_20b2RevoluteJointDef____20const__29($0 + 12380 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16004 >> 2] = HEAP32[$0 + 12372 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 12372 >> 2], b2Vec2_20b2RevoluteJointDef_____20emscripten__internal__getContext_b2Vec2_20b2RevoluteJointDef_____28b2Vec2_20b2RevoluteJointDef____20const__29($0 + 12380 | 0) | 0); + HEAP32[$0 + 12508 >> 2] = $1; + HEAP32[$0 + 12504 >> 2] = 9471; + HEAP32[$0 + 12500 >> 2] = 36; + $1 = HEAP32[$0 + 12508 >> 2]; + HEAP32[$0 + 12496 >> 2] = 318; + HEAP32[$0 + 12492 >> 2] = 319; + $2 = emscripten__internal__TypeID_b2RevoluteJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 12504 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16008 >> 2] = HEAP32[$0 + 12496 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 12496 >> 2]; + $7 = float_20b2RevoluteJointDef_____20emscripten__internal__getContext_float_20b2RevoluteJointDef_____28float_20b2RevoluteJointDef____20const__29($0 + 12500 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16028 >> 2] = HEAP32[$0 + 12492 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 12492 >> 2], float_20b2RevoluteJointDef_____20emscripten__internal__getContext_float_20b2RevoluteJointDef_____28float_20b2RevoluteJointDef____20const__29($0 + 12500 | 0) | 0); + HEAP32[$0 + 12548 >> 2] = $1; + HEAP32[$0 + 12544 >> 2] = 2849; + HEAP32[$0 + 12540 >> 2] = 40; + $1 = HEAP32[$0 + 12548 >> 2]; + HEAP32[$0 + 12536 >> 2] = 320; + HEAP32[$0 + 12532 >> 2] = 321; + $2 = emscripten__internal__TypeID_b2RevoluteJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 12544 >> 2]; + $4 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 16048 >> 2] = HEAP32[$0 + 12536 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 12536 >> 2]; + $7 = bool_20b2RevoluteJointDef_____20emscripten__internal__getContext_bool_20b2RevoluteJointDef_____28bool_20b2RevoluteJointDef____20const__29($0 + 12540 | 0); + $8 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 16056 >> 2] = HEAP32[$0 + 12532 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 12532 >> 2], bool_20b2RevoluteJointDef_____20emscripten__internal__getContext_bool_20b2RevoluteJointDef_____28bool_20b2RevoluteJointDef____20const__29($0 + 12540 | 0) | 0); + HEAP32[$0 + 12488 >> 2] = $1; + HEAP32[$0 + 12484 >> 2] = 9449; + HEAP32[$0 + 12480 >> 2] = 44; + $1 = HEAP32[$0 + 12488 >> 2]; + HEAP32[$0 + 12476 >> 2] = 318; + HEAP32[$0 + 12472 >> 2] = 319; + $2 = emscripten__internal__TypeID_b2RevoluteJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 12484 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16012 >> 2] = HEAP32[$0 + 12476 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 12476 >> 2]; + $7 = float_20b2RevoluteJointDef_____20emscripten__internal__getContext_float_20b2RevoluteJointDef_____28float_20b2RevoluteJointDef____20const__29($0 + 12480 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16032 >> 2] = HEAP32[$0 + 12472 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 12472 >> 2], float_20b2RevoluteJointDef_____20emscripten__internal__getContext_float_20b2RevoluteJointDef_____28float_20b2RevoluteJointDef____20const__29($0 + 12480 | 0) | 0); + HEAP32[$0 + 12468 >> 2] = $1; + HEAP32[$0 + 12464 >> 2] = 9460; + HEAP32[$0 + 12460 >> 2] = 48; + $1 = HEAP32[$0 + 12468 >> 2]; + HEAP32[$0 + 12456 >> 2] = 318; + HEAP32[$0 + 12452 >> 2] = 319; + $2 = emscripten__internal__TypeID_b2RevoluteJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 12464 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16016 >> 2] = HEAP32[$0 + 12456 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 12456 >> 2]; + $7 = float_20b2RevoluteJointDef_____20emscripten__internal__getContext_float_20b2RevoluteJointDef_____28float_20b2RevoluteJointDef____20const__29($0 + 12460 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16036 >> 2] = HEAP32[$0 + 12452 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 12452 >> 2], float_20b2RevoluteJointDef_____20emscripten__internal__getContext_float_20b2RevoluteJointDef_____28float_20b2RevoluteJointDef____20const__29($0 + 12460 | 0) | 0); + HEAP32[$0 + 12528 >> 2] = $1; + HEAP32[$0 + 12524 >> 2] = 3640; + HEAP32[$0 + 12520 >> 2] = 52; + $1 = HEAP32[$0 + 12528 >> 2]; + HEAP32[$0 + 12516 >> 2] = 320; + HEAP32[$0 + 12512 >> 2] = 321; + $2 = emscripten__internal__TypeID_b2RevoluteJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 12524 >> 2]; + $4 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 16052 >> 2] = HEAP32[$0 + 12516 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 12516 >> 2]; + $7 = bool_20b2RevoluteJointDef_____20emscripten__internal__getContext_bool_20b2RevoluteJointDef_____28bool_20b2RevoluteJointDef____20const__29($0 + 12520 | 0); + $8 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 16060 >> 2] = HEAP32[$0 + 12512 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 12512 >> 2], bool_20b2RevoluteJointDef_____20emscripten__internal__getContext_bool_20b2RevoluteJointDef_____28bool_20b2RevoluteJointDef____20const__29($0 + 12520 | 0) | 0); + HEAP32[$0 + 12448 >> 2] = $1; + HEAP32[$0 + 12444 >> 2] = 10349; + HEAP32[$0 + 12440 >> 2] = 56; + $1 = HEAP32[$0 + 12448 >> 2]; + HEAP32[$0 + 12436 >> 2] = 318; + HEAP32[$0 + 12432 >> 2] = 319; + $2 = emscripten__internal__TypeID_b2RevoluteJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 12444 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16020 >> 2] = HEAP32[$0 + 12436 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 12436 >> 2]; + $7 = float_20b2RevoluteJointDef_____20emscripten__internal__getContext_float_20b2RevoluteJointDef_____28float_20b2RevoluteJointDef____20const__29($0 + 12440 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16040 >> 2] = HEAP32[$0 + 12432 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 12432 >> 2], float_20b2RevoluteJointDef_____20emscripten__internal__getContext_float_20b2RevoluteJointDef_____28float_20b2RevoluteJointDef____20const__29($0 + 12440 | 0) | 0); + HEAP32[$0 + 12428 >> 2] = $1; + HEAP32[$0 + 12424 >> 2] = 8791; + HEAP32[$0 + 12420 >> 2] = 60; + HEAP32[$0 + 12416 >> 2] = 318; + HEAP32[$0 + 12412 >> 2] = 319; + $1 = emscripten__internal__TypeID_b2RevoluteJointDef_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 12424 >> 2]; + $3 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16024 >> 2] = HEAP32[$0 + 12416 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $5 = HEAP32[$0 + 12416 >> 2]; + $6 = float_20b2RevoluteJointDef_____20emscripten__internal__getContext_float_20b2RevoluteJointDef_____28float_20b2RevoluteJointDef____20const__29($0 + 12420 | 0); + $7 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16044 >> 2] = HEAP32[$0 + 12412 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 12412 >> 2], float_20b2RevoluteJointDef_____20emscripten__internal__getContext_float_20b2RevoluteJointDef_____28float_20b2RevoluteJointDef____20const__29($0 + 12420 | 0) | 0); + HEAP32[$0 + 12572 >> 2] = $0 + 2406; + HEAP32[$0 + 12568 >> 2] = 2572; + void_20emscripten__base_b2Joint___verify_b2RevoluteJoint__28_29(); + HEAP32[$0 + 12564 >> 2] = 322; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2RevoluteJoint__28_29_29_28b2RevoluteJoint__29(), + HEAP32[wasm2js_i32$0 + 12560 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2RevoluteJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2RevoluteJoint__28_29_29_28b2Joint__29(), + HEAP32[wasm2js_i32$0 + 12556 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 12552 >> 2] = 323; + $1 = emscripten__internal__TypeID_b2RevoluteJoint_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2Joint___get_28_29(); + HEAP32[$0 + 16064 >> 2] = HEAP32[$0 + 12564 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 12564 >> 2]; + HEAP32[$0 + 16068 >> 2] = HEAP32[$0 + 12560 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 12560 >> 2]; + HEAP32[$0 + 16072 >> 2] = HEAP32[$0 + 12556 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 12556 >> 2]; + $11 = HEAP32[$0 + 12568 >> 2]; + HEAP32[$0 + 16076 >> 2] = HEAP32[$0 + 12552 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 12552 >> 2]); + HEAP32[$0 + 2400 >> 2] = 0; + HEAP32[$0 + 2396 >> 2] = 324; + $1 = HEAP32[$0 + 2400 >> 2]; + $2 = HEAP32[$0 + 2396 >> 2]; + HEAP32[$0 + 12608 >> 2] = $2; + HEAP32[$0 + 12612 >> 2] = $1; + $1 = HEAP32[$0 + 12608 >> 2]; + $2 = HEAP32[$0 + 12612 >> 2]; + HEAP32[$0 + 12636 >> 2] = $0 + 2406; + HEAP32[$0 + 12632 >> 2] = 11171; + HEAP32[$0 + 12628 >> 2] = $2; + HEAP32[$0 + 12624 >> 2] = $1; + $3 = HEAP32[$0 + 12636 >> 2]; + $4 = HEAP32[$0 + 12632 >> 2]; + $1 = HEAP32[$0 + 12624 >> 2]; + HEAP32[$0 + 12620 >> 2] = HEAP32[$0 + 12628 >> 2]; + HEAP32[$0 + 12616 >> 2] = $1; + $2 = HEAP32[$0 + 12620 >> 2]; + $1 = HEAP32[$0 + 12616 >> 2]; + HEAP32[$0 + 392 >> 2] = $1; + HEAP32[$0 + 396 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20b2Vec2_20const__20_28b2RevoluteJoint____29_28_29_20const_29($4, $0 + 392 | 0); + HEAP32[$0 + 2392 >> 2] = 0; + HEAP32[$0 + 2388 >> 2] = 325; + $1 = HEAP32[$0 + 2392 >> 2]; + $2 = HEAP32[$0 + 2388 >> 2]; + HEAP32[$0 + 12576 >> 2] = $2; + HEAP32[$0 + 12580 >> 2] = $1; + $1 = HEAP32[$0 + 12576 >> 2]; + $2 = HEAP32[$0 + 12580 >> 2]; + HEAP32[$0 + 12604 >> 2] = $3; + HEAP32[$0 + 12600 >> 2] = 11028; + HEAP32[$0 + 12596 >> 2] = $2; + HEAP32[$0 + 12592 >> 2] = $1; + $3 = HEAP32[$0 + 12604 >> 2]; + $4 = HEAP32[$0 + 12600 >> 2]; + $1 = HEAP32[$0 + 12592 >> 2]; + HEAP32[$0 + 12588 >> 2] = HEAP32[$0 + 12596 >> 2]; + HEAP32[$0 + 12584 >> 2] = $1; + $2 = HEAP32[$0 + 12588 >> 2]; + $1 = HEAP32[$0 + 12584 >> 2]; + HEAP32[$0 + 384 >> 2] = $1; + HEAP32[$0 + 388 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20b2Vec2_20const__20_28b2RevoluteJoint____29_28_29_20const_29($4, $0 + 384 | 0); + HEAP32[$0 + 2384 >> 2] = 0; + HEAP32[$0 + 2380 >> 2] = 326; + $1 = HEAP32[$0 + 2384 >> 2]; + $2 = HEAP32[$0 + 2380 >> 2]; + HEAP32[$0 + 12832 >> 2] = $2; + HEAP32[$0 + 12836 >> 2] = $1; + $1 = HEAP32[$0 + 12832 >> 2]; + $2 = HEAP32[$0 + 12836 >> 2]; + HEAP32[$0 + 12860 >> 2] = $3; + HEAP32[$0 + 12856 >> 2] = 9486; + HEAP32[$0 + 12852 >> 2] = $2; + HEAP32[$0 + 12848 >> 2] = $1; + $3 = HEAP32[$0 + 12860 >> 2]; + $4 = HEAP32[$0 + 12856 >> 2]; + $1 = HEAP32[$0 + 12848 >> 2]; + HEAP32[$0 + 12844 >> 2] = HEAP32[$0 + 12852 >> 2]; + HEAP32[$0 + 12840 >> 2] = $1; + $2 = HEAP32[$0 + 12844 >> 2]; + $1 = HEAP32[$0 + 12840 >> 2]; + HEAP32[$0 + 376 >> 2] = $1; + HEAP32[$0 + 380 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20float_20_28b2RevoluteJoint____29_28_29_20const_29($4, $0 + 376 | 0); + HEAP32[$0 + 2376 >> 2] = 0; + HEAP32[$0 + 2372 >> 2] = 327; + $1 = HEAP32[$0 + 2376 >> 2]; + $2 = HEAP32[$0 + 2372 >> 2]; + HEAP32[$0 + 12800 >> 2] = $2; + HEAP32[$0 + 12804 >> 2] = $1; + $1 = HEAP32[$0 + 12800 >> 2]; + $2 = HEAP32[$0 + 12804 >> 2]; + HEAP32[$0 + 12828 >> 2] = $3; + HEAP32[$0 + 12824 >> 2] = 9426; + HEAP32[$0 + 12820 >> 2] = $2; + HEAP32[$0 + 12816 >> 2] = $1; + $3 = HEAP32[$0 + 12828 >> 2]; + $4 = HEAP32[$0 + 12824 >> 2]; + $1 = HEAP32[$0 + 12816 >> 2]; + HEAP32[$0 + 12812 >> 2] = HEAP32[$0 + 12820 >> 2]; + HEAP32[$0 + 12808 >> 2] = $1; + $2 = HEAP32[$0 + 12812 >> 2]; + $1 = HEAP32[$0 + 12808 >> 2]; + HEAP32[$0 + 368 >> 2] = $1; + HEAP32[$0 + 372 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20float_20_28b2RevoluteJoint____29_28_29_20const_29($4, $0 + 368 | 0); + HEAP32[$0 + 2368 >> 2] = 0; + HEAP32[$0 + 2364 >> 2] = 328; + $1 = HEAP32[$0 + 2368 >> 2]; + $2 = HEAP32[$0 + 2364 >> 2]; + HEAP32[$0 + 12768 >> 2] = $2; + HEAP32[$0 + 12772 >> 2] = $1; + $1 = HEAP32[$0 + 12768 >> 2]; + $2 = HEAP32[$0 + 12772 >> 2]; + HEAP32[$0 + 12796 >> 2] = $3; + HEAP32[$0 + 12792 >> 2] = 10289; + HEAP32[$0 + 12788 >> 2] = $2; + HEAP32[$0 + 12784 >> 2] = $1; + $3 = HEAP32[$0 + 12796 >> 2]; + $4 = HEAP32[$0 + 12792 >> 2]; + $1 = HEAP32[$0 + 12784 >> 2]; + HEAP32[$0 + 12780 >> 2] = HEAP32[$0 + 12788 >> 2]; + HEAP32[$0 + 12776 >> 2] = $1; + $2 = HEAP32[$0 + 12780 >> 2]; + $1 = HEAP32[$0 + 12776 >> 2]; + HEAP32[$0 + 360 >> 2] = $1; + HEAP32[$0 + 364 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20float_20_28b2RevoluteJoint____29_28_29_20const_29($4, $0 + 360 | 0); + HEAP32[$0 + 2360 >> 2] = 0; + HEAP32[$0 + 2356 >> 2] = 329; + $1 = HEAP32[$0 + 2360 >> 2]; + $2 = HEAP32[$0 + 2356 >> 2]; + HEAP32[$0 + 12896 >> 2] = $2; + HEAP32[$0 + 12900 >> 2] = $1; + $1 = HEAP32[$0 + 12896 >> 2]; + $2 = HEAP32[$0 + 12900 >> 2]; + HEAP32[$0 + 12924 >> 2] = $3; + HEAP32[$0 + 12920 >> 2] = 10231; + HEAP32[$0 + 12916 >> 2] = $2; + HEAP32[$0 + 12912 >> 2] = $1; + $3 = HEAP32[$0 + 12924 >> 2]; + $4 = HEAP32[$0 + 12920 >> 2]; + $1 = HEAP32[$0 + 12912 >> 2]; + HEAP32[$0 + 12908 >> 2] = HEAP32[$0 + 12916 >> 2]; + HEAP32[$0 + 12904 >> 2] = $1; + $2 = HEAP32[$0 + 12908 >> 2]; + $1 = HEAP32[$0 + 12904 >> 2]; + HEAP32[$0 + 352 >> 2] = $1; + HEAP32[$0 + 356 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20bool_20_28b2RevoluteJoint____29_28_29_20const_29($4, $0 + 352 | 0); + HEAP32[$0 + 2352 >> 2] = 0; + HEAP32[$0 + 2348 >> 2] = 330; + $1 = HEAP32[$0 + 2352 >> 2]; + $2 = HEAP32[$0 + 2348 >> 2]; + HEAP32[$0 + 12960 >> 2] = $2; + HEAP32[$0 + 12964 >> 2] = $1; + $1 = HEAP32[$0 + 12960 >> 2]; + $2 = HEAP32[$0 + 12964 >> 2]; + HEAP32[$0 + 12988 >> 2] = $3; + HEAP32[$0 + 12984 >> 2] = 2861; + HEAP32[$0 + 12980 >> 2] = $2; + HEAP32[$0 + 12976 >> 2] = $1; + $3 = HEAP32[$0 + 12988 >> 2]; + $4 = HEAP32[$0 + 12984 >> 2]; + $1 = HEAP32[$0 + 12976 >> 2]; + HEAP32[$0 + 12972 >> 2] = HEAP32[$0 + 12980 >> 2]; + HEAP32[$0 + 12968 >> 2] = $1; + $2 = HEAP32[$0 + 12972 >> 2]; + $1 = HEAP32[$0 + 12968 >> 2]; + HEAP32[$0 + 344 >> 2] = $1; + HEAP32[$0 + 348 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2RevoluteJoint____29_28bool_29___invoke_b2RevoluteJoint__28char_20const__2c_20void_20_28b2RevoluteJoint____29_28bool_29_29($4, $0 + 344 | 0); + HEAP32[$0 + 2344 >> 2] = 0; + HEAP32[$0 + 2340 >> 2] = 331; + $1 = HEAP32[$0 + 2344 >> 2]; + $2 = HEAP32[$0 + 2340 >> 2]; + HEAP32[$0 + 12736 >> 2] = $2; + HEAP32[$0 + 12740 >> 2] = $1; + $1 = HEAP32[$0 + 12736 >> 2]; + $2 = HEAP32[$0 + 12740 >> 2]; + HEAP32[$0 + 12764 >> 2] = $3; + HEAP32[$0 + 12760 >> 2] = 2821; + HEAP32[$0 + 12756 >> 2] = $2; + HEAP32[$0 + 12752 >> 2] = $1; + $3 = HEAP32[$0 + 12764 >> 2]; + $4 = HEAP32[$0 + 12760 >> 2]; + $1 = HEAP32[$0 + 12752 >> 2]; + HEAP32[$0 + 12748 >> 2] = HEAP32[$0 + 12756 >> 2]; + HEAP32[$0 + 12744 >> 2] = $1; + $2 = HEAP32[$0 + 12748 >> 2]; + $1 = HEAP32[$0 + 12744 >> 2]; + HEAP32[$0 + 336 >> 2] = $1; + HEAP32[$0 + 340 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20float_20_28b2RevoluteJoint____29_28_29_20const_29($4, $0 + 336 | 0); + HEAP32[$0 + 2336 >> 2] = 0; + HEAP32[$0 + 2332 >> 2] = 332; + $1 = HEAP32[$0 + 2336 >> 2]; + $2 = HEAP32[$0 + 2332 >> 2]; + HEAP32[$0 + 12704 >> 2] = $2; + HEAP32[$0 + 12708 >> 2] = $1; + $1 = HEAP32[$0 + 12704 >> 2]; + $2 = HEAP32[$0 + 12708 >> 2]; + HEAP32[$0 + 12732 >> 2] = $3; + HEAP32[$0 + 12728 >> 2] = 2835; + HEAP32[$0 + 12724 >> 2] = $2; + HEAP32[$0 + 12720 >> 2] = $1; + $3 = HEAP32[$0 + 12732 >> 2]; + $4 = HEAP32[$0 + 12728 >> 2]; + $1 = HEAP32[$0 + 12720 >> 2]; + HEAP32[$0 + 12716 >> 2] = HEAP32[$0 + 12724 >> 2]; + HEAP32[$0 + 12712 >> 2] = $1; + $2 = HEAP32[$0 + 12716 >> 2]; + $1 = HEAP32[$0 + 12712 >> 2]; + HEAP32[$0 + 328 >> 2] = $1; + HEAP32[$0 + 332 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20float_20_28b2RevoluteJoint____29_28_29_20const_29($4, $0 + 328 | 0); + HEAP32[$0 + 2328 >> 2] = 0; + HEAP32[$0 + 2324 >> 2] = 333; + $1 = HEAP32[$0 + 2328 >> 2]; + $2 = HEAP32[$0 + 2324 >> 2]; + HEAP32[$0 + 12992 >> 2] = $2; + HEAP32[$0 + 12996 >> 2] = $1; + $1 = HEAP32[$0 + 12992 >> 2]; + $2 = HEAP32[$0 + 12996 >> 2]; + HEAP32[$0 + 13020 >> 2] = $3; + HEAP32[$0 + 13016 >> 2] = 3355; + HEAP32[$0 + 13012 >> 2] = $2; + HEAP32[$0 + 13008 >> 2] = $1; + $3 = HEAP32[$0 + 13020 >> 2]; + $4 = HEAP32[$0 + 13016 >> 2]; + $1 = HEAP32[$0 + 13008 >> 2]; + HEAP32[$0 + 13004 >> 2] = HEAP32[$0 + 13012 >> 2]; + HEAP32[$0 + 13e3 >> 2] = $1; + $2 = HEAP32[$0 + 13004 >> 2]; + $1 = HEAP32[$0 + 13e3 >> 2]; + HEAP32[$0 + 320 >> 2] = $1; + HEAP32[$0 + 324 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2RevoluteJoint____29_28float_2c_20float_29___invoke_b2RevoluteJoint__28char_20const__2c_20void_20_28b2RevoluteJoint____29_28float_2c_20float_29_29($4, $0 + 320 | 0); + HEAP32[$0 + 2320 >> 2] = 0; + HEAP32[$0 + 2316 >> 2] = 334; + $1 = HEAP32[$0 + 2320 >> 2]; + $2 = HEAP32[$0 + 2316 >> 2]; + HEAP32[$0 + 12864 >> 2] = $2; + HEAP32[$0 + 12868 >> 2] = $1; + $1 = HEAP32[$0 + 12864 >> 2]; + $2 = HEAP32[$0 + 12868 >> 2]; + HEAP32[$0 + 12892 >> 2] = $3; + HEAP32[$0 + 12888 >> 2] = 10274; + HEAP32[$0 + 12884 >> 2] = $2; + HEAP32[$0 + 12880 >> 2] = $1; + $3 = HEAP32[$0 + 12892 >> 2]; + $4 = HEAP32[$0 + 12888 >> 2]; + $1 = HEAP32[$0 + 12880 >> 2]; + HEAP32[$0 + 12876 >> 2] = HEAP32[$0 + 12884 >> 2]; + HEAP32[$0 + 12872 >> 2] = $1; + $2 = HEAP32[$0 + 12876 >> 2]; + $1 = HEAP32[$0 + 12872 >> 2]; + HEAP32[$0 + 312 >> 2] = $1; + HEAP32[$0 + 316 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20bool_20_28b2RevoluteJoint____29_28_29_20const_29($4, $0 + 312 | 0); + HEAP32[$0 + 2312 >> 2] = 0; + HEAP32[$0 + 2308 >> 2] = 335; + $1 = HEAP32[$0 + 2312 >> 2]; + $2 = HEAP32[$0 + 2308 >> 2]; + HEAP32[$0 + 12928 >> 2] = $2; + HEAP32[$0 + 12932 >> 2] = $1; + $1 = HEAP32[$0 + 12928 >> 2]; + $2 = HEAP32[$0 + 12932 >> 2]; + HEAP32[$0 + 12956 >> 2] = $3; + HEAP32[$0 + 12952 >> 2] = 3652; + HEAP32[$0 + 12948 >> 2] = $2; + HEAP32[$0 + 12944 >> 2] = $1; + $3 = HEAP32[$0 + 12956 >> 2]; + $4 = HEAP32[$0 + 12952 >> 2]; + $1 = HEAP32[$0 + 12944 >> 2]; + HEAP32[$0 + 12940 >> 2] = HEAP32[$0 + 12948 >> 2]; + HEAP32[$0 + 12936 >> 2] = $1; + $2 = HEAP32[$0 + 12940 >> 2]; + $1 = HEAP32[$0 + 12936 >> 2]; + HEAP32[$0 + 304 >> 2] = $1; + HEAP32[$0 + 308 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2RevoluteJoint____29_28bool_29___invoke_b2RevoluteJoint__28char_20const__2c_20void_20_28b2RevoluteJoint____29_28bool_29_29($4, $0 + 304 | 0); + HEAP32[$0 + 2304 >> 2] = 0; + HEAP32[$0 + 2300 >> 2] = 336; + $1 = HEAP32[$0 + 2304 >> 2]; + $2 = HEAP32[$0 + 2300 >> 2]; + HEAP32[$0 + 13056 >> 2] = $2; + HEAP32[$0 + 13060 >> 2] = $1; + $1 = HEAP32[$0 + 13056 >> 2]; + $2 = HEAP32[$0 + 13060 >> 2]; + HEAP32[$0 + 13084 >> 2] = $3; + HEAP32[$0 + 13080 >> 2] = 10360; + HEAP32[$0 + 13076 >> 2] = $2; + HEAP32[$0 + 13072 >> 2] = $1; + $3 = HEAP32[$0 + 13084 >> 2]; + $4 = HEAP32[$0 + 13080 >> 2]; + $1 = HEAP32[$0 + 13072 >> 2]; + HEAP32[$0 + 13068 >> 2] = HEAP32[$0 + 13076 >> 2]; + HEAP32[$0 + 13064 >> 2] = $1; + $2 = HEAP32[$0 + 13068 >> 2]; + $1 = HEAP32[$0 + 13064 >> 2]; + HEAP32[$0 + 296 >> 2] = $1; + HEAP32[$0 + 300 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2RevoluteJoint____29_28float_29___invoke_b2RevoluteJoint__28char_20const__2c_20void_20_28b2RevoluteJoint____29_28float_29_29($4, $0 + 296 | 0); + HEAP32[$0 + 2296 >> 2] = 0; + HEAP32[$0 + 2292 >> 2] = 337; + $1 = HEAP32[$0 + 2296 >> 2]; + $2 = HEAP32[$0 + 2292 >> 2]; + HEAP32[$0 + 12672 >> 2] = $2; + HEAP32[$0 + 12676 >> 2] = $1; + $1 = HEAP32[$0 + 12672 >> 2]; + $2 = HEAP32[$0 + 12676 >> 2]; + HEAP32[$0 + 12700 >> 2] = $3; + HEAP32[$0 + 12696 >> 2] = 10374; + HEAP32[$0 + 12692 >> 2] = $2; + HEAP32[$0 + 12688 >> 2] = $1; + $3 = HEAP32[$0 + 12700 >> 2]; + $4 = HEAP32[$0 + 12696 >> 2]; + $1 = HEAP32[$0 + 12688 >> 2]; + HEAP32[$0 + 12684 >> 2] = HEAP32[$0 + 12692 >> 2]; + HEAP32[$0 + 12680 >> 2] = $1; + $2 = HEAP32[$0 + 12684 >> 2]; + $1 = HEAP32[$0 + 12680 >> 2]; + HEAP32[$0 + 288 >> 2] = $1; + HEAP32[$0 + 292 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20float_20_28b2RevoluteJoint____29_28_29_20const_29($4, $0 + 288 | 0); + HEAP32[$0 + 2288 >> 2] = 0; + HEAP32[$0 + 2284 >> 2] = 338; + $1 = HEAP32[$0 + 2288 >> 2]; + $2 = HEAP32[$0 + 2284 >> 2]; + HEAP32[$0 + 13024 >> 2] = $2; + HEAP32[$0 + 13028 >> 2] = $1; + $1 = HEAP32[$0 + 13024 >> 2]; + $2 = HEAP32[$0 + 13028 >> 2]; + HEAP32[$0 + 13052 >> 2] = $3; + HEAP32[$0 + 13048 >> 2] = 8806; + HEAP32[$0 + 13044 >> 2] = $2; + HEAP32[$0 + 13040 >> 2] = $1; + $3 = HEAP32[$0 + 13052 >> 2]; + $4 = HEAP32[$0 + 13048 >> 2]; + $1 = HEAP32[$0 + 13040 >> 2]; + HEAP32[$0 + 13036 >> 2] = HEAP32[$0 + 13044 >> 2]; + HEAP32[$0 + 13032 >> 2] = $1; + $2 = HEAP32[$0 + 13036 >> 2]; + $1 = HEAP32[$0 + 13032 >> 2]; + HEAP32[$0 + 280 >> 2] = $1; + HEAP32[$0 + 284 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2RevoluteJoint____29_28float_29___invoke_b2RevoluteJoint__28char_20const__2c_20void_20_28b2RevoluteJoint____29_28float_29_29($4, $0 + 280 | 0); + HEAP32[$0 + 2280 >> 2] = 0; + HEAP32[$0 + 2276 >> 2] = 339; + $1 = HEAP32[$0 + 2280 >> 2]; + $2 = HEAP32[$0 + 2276 >> 2]; + HEAP32[$0 + 12640 >> 2] = $2; + HEAP32[$0 + 12644 >> 2] = $1; + $1 = HEAP32[$0 + 12640 >> 2]; + $2 = HEAP32[$0 + 12644 >> 2]; + HEAP32[$0 + 12668 >> 2] = $3; + HEAP32[$0 + 12664 >> 2] = 8824; + HEAP32[$0 + 12660 >> 2] = $2; + HEAP32[$0 + 12656 >> 2] = $1; + $3 = HEAP32[$0 + 12668 >> 2]; + $4 = HEAP32[$0 + 12664 >> 2]; + $1 = HEAP32[$0 + 12656 >> 2]; + HEAP32[$0 + 12652 >> 2] = HEAP32[$0 + 12660 >> 2]; + HEAP32[$0 + 12648 >> 2] = $1; + $2 = HEAP32[$0 + 12652 >> 2]; + $1 = HEAP32[$0 + 12648 >> 2]; + HEAP32[$0 + 272 >> 2] = $1; + HEAP32[$0 + 276 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20float_20_28b2RevoluteJoint____29_28_29_20const_29($4, $0 + 272 | 0); + HEAP32[$0 + 2272 >> 2] = 0; + HEAP32[$0 + 2268 >> 2] = 340; + $1 = HEAP32[$0 + 2272 >> 2]; + $2 = HEAP32[$0 + 2268 >> 2]; + HEAP32[$0 + 13088 >> 2] = $2; + HEAP32[$0 + 13092 >> 2] = $1; + $1 = HEAP32[$0 + 13088 >> 2]; + $2 = HEAP32[$0 + 13092 >> 2]; + HEAP32[$0 + 13116 >> 2] = $3; + HEAP32[$0 + 13112 >> 2] = 8842; + HEAP32[$0 + 13108 >> 2] = $2; + HEAP32[$0 + 13104 >> 2] = $1; + $3 = HEAP32[$0 + 13116 >> 2]; + $4 = HEAP32[$0 + 13112 >> 2]; + $1 = HEAP32[$0 + 13104 >> 2]; + HEAP32[$0 + 13100 >> 2] = HEAP32[$0 + 13108 >> 2]; + HEAP32[$0 + 13096 >> 2] = $1; + $2 = HEAP32[$0 + 13100 >> 2]; + $1 = HEAP32[$0 + 13096 >> 2]; + HEAP32[$0 + 264 >> 2] = $1; + HEAP32[$0 + 268 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2RevoluteJoint____29_28float_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20float_20_28b2RevoluteJoint____29_28float_29_20const_29($4, $0 + 264 | 0); + HEAP32[$0 + 2264 >> 2] = 1; + HEAP32[$0 + 2260 >> 2] = 16; + $1 = HEAP32[$0 + 2264 >> 2]; + $2 = HEAP32[$0 + 2260 >> 2]; + HEAP32[$0 + 13120 >> 2] = $2; + HEAP32[$0 + 13124 >> 2] = $1; + $1 = HEAP32[$0 + 13120 >> 2]; + $2 = HEAP32[$0 + 13124 >> 2]; + HEAP32[$0 + 13148 >> 2] = $3; + HEAP32[$0 + 13144 >> 2] = 6232; + HEAP32[$0 + 13140 >> 2] = $2; + HEAP32[$0 + 13136 >> 2] = $1; + $3 = HEAP32[$0 + 13144 >> 2]; + $1 = HEAP32[$0 + 13136 >> 2]; + HEAP32[$0 + 13132 >> 2] = HEAP32[$0 + 13140 >> 2]; + HEAP32[$0 + 13128 >> 2] = $1; + $2 = HEAP32[$0 + 13132 >> 2]; + $1 = HEAP32[$0 + 13128 >> 2]; + HEAP32[$0 + 256 >> 2] = $1; + HEAP32[$0 + 260 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2RevoluteJoint____29_28_29___invoke_b2RevoluteJoint__28char_20const__2c_20void_20_28b2RevoluteJoint____29_28_29_29($3, $0 + 256 | 0); + HEAP32[$0 + 13172 >> 2] = $0 + 2259; + HEAP32[$0 + 13168 >> 2] = 7946; + void_20emscripten__base_b2JointDef___verify_b2RopeJointDef__28_29(); + HEAP32[$0 + 13164 >> 2] = 341; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2RopeJointDef__28_29_29_28b2RopeJointDef__29(), + HEAP32[wasm2js_i32$0 + 13160 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2RopeJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2RopeJointDef__28_29_29_28b2JointDef__29(), + HEAP32[wasm2js_i32$0 + 13156 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 13152 >> 2] = 342; + $1 = emscripten__internal__TypeID_b2RopeJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RopeJointDef__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RopeJointDef_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2JointDef___get_28_29(); + HEAP32[$0 + 16080 >> 2] = HEAP32[$0 + 13164 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 13164 >> 2]; + HEAP32[$0 + 16084 >> 2] = HEAP32[$0 + 13160 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 13160 >> 2]; + HEAP32[$0 + 16088 >> 2] = HEAP32[$0 + 13156 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 13156 >> 2]; + $11 = HEAP32[$0 + 13168 >> 2]; + HEAP32[$0 + 16092 >> 2] = HEAP32[$0 + 13152 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 13152 >> 2]); + HEAP32[$0 + 13176 >> 2] = $0 + 2259; + HEAP32[$0 + 16100 >> 2] = HEAP32[$0 + 13176 >> 2]; + HEAP32[$0 + 16096 >> 2] = 343; + $1 = HEAP32[$0 + 16100 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2RopeJointDef__20_28__29_28_29___invoke_b2RopeJointDef__28b2RopeJointDef__20_28__29_28_29_29(HEAP32[$0 + 16096 >> 2]); + HEAP32[$0 + 13216 >> 2] = $1; + HEAP32[$0 + 13212 >> 2] = 11158; + HEAP32[$0 + 13208 >> 2] = 20; + $1 = HEAP32[$0 + 13216 >> 2]; + HEAP32[$0 + 13204 >> 2] = 344; + HEAP32[$0 + 13200 >> 2] = 345; + $2 = emscripten__internal__TypeID_b2RopeJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 13212 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16104 >> 2] = HEAP32[$0 + 13204 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 13204 >> 2]; + $7 = b2Vec2_20b2RopeJointDef_____20emscripten__internal__getContext_b2Vec2_20b2RopeJointDef_____28b2Vec2_20b2RopeJointDef____20const__29($0 + 13208 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16112 >> 2] = HEAP32[$0 + 13200 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 13200 >> 2], b2Vec2_20b2RopeJointDef_____20emscripten__internal__getContext_b2Vec2_20b2RopeJointDef_____28b2Vec2_20b2RopeJointDef____20const__29($0 + 13208 | 0) | 0); + HEAP32[$0 + 13196 >> 2] = $1; + HEAP32[$0 + 13192 >> 2] = 11015; + HEAP32[$0 + 13188 >> 2] = 28; + $1 = HEAP32[$0 + 13196 >> 2]; + HEAP32[$0 + 13184 >> 2] = 344; + HEAP32[$0 + 13180 >> 2] = 345; + $2 = emscripten__internal__TypeID_b2RopeJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 13192 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16108 >> 2] = HEAP32[$0 + 13184 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 13184 >> 2]; + $7 = b2Vec2_20b2RopeJointDef_____20emscripten__internal__getContext_b2Vec2_20b2RopeJointDef_____28b2Vec2_20b2RopeJointDef____20const__29($0 + 13188 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16116 >> 2] = HEAP32[$0 + 13180 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 13180 >> 2], b2Vec2_20b2RopeJointDef_____20emscripten__internal__getContext_b2Vec2_20b2RopeJointDef_____28b2Vec2_20b2RopeJointDef____20const__29($0 + 13188 | 0) | 0); + HEAP32[$0 + 13236 >> 2] = $1; + HEAP32[$0 + 13232 >> 2] = 7054; + HEAP32[$0 + 13228 >> 2] = 36; + HEAP32[$0 + 13224 >> 2] = 346; + HEAP32[$0 + 13220 >> 2] = 347; + $1 = emscripten__internal__TypeID_b2RopeJointDef_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 13232 >> 2]; + $3 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16120 >> 2] = HEAP32[$0 + 13224 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $5 = HEAP32[$0 + 13224 >> 2]; + $6 = float_20b2RopeJointDef_____20emscripten__internal__getContext_float_20b2RopeJointDef_____28float_20b2RopeJointDef____20const__29($0 + 13228 | 0); + $7 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16124 >> 2] = HEAP32[$0 + 13220 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 13220 >> 2], float_20b2RopeJointDef_____20emscripten__internal__getContext_float_20b2RopeJointDef_____28float_20b2RopeJointDef____20const__29($0 + 13228 | 0) | 0); + HEAP32[$0 + 13260 >> 2] = $0 + 2258; + HEAP32[$0 + 13256 >> 2] = 2611; + void_20emscripten__base_b2Joint___verify_b2RopeJoint__28_29(); + HEAP32[$0 + 13252 >> 2] = 348; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2RopeJoint__28_29_29_28b2RopeJoint__29(), + HEAP32[wasm2js_i32$0 + 13248 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2RopeJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2RopeJoint__28_29_29_28b2Joint__29(), + HEAP32[wasm2js_i32$0 + 13244 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 13240 >> 2] = 349; + $1 = emscripten__internal__TypeID_b2RopeJoint_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RopeJoint__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2Joint___get_28_29(); + HEAP32[$0 + 16128 >> 2] = HEAP32[$0 + 13252 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 13252 >> 2]; + HEAP32[$0 + 16132 >> 2] = HEAP32[$0 + 13248 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 13248 >> 2]; + HEAP32[$0 + 16136 >> 2] = HEAP32[$0 + 13244 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 13244 >> 2]; + $11 = HEAP32[$0 + 13256 >> 2]; + HEAP32[$0 + 16140 >> 2] = HEAP32[$0 + 13240 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 13240 >> 2]); + HEAP32[$0 + 2252 >> 2] = 0; + HEAP32[$0 + 2248 >> 2] = 350; + $1 = HEAP32[$0 + 2252 >> 2]; + $2 = HEAP32[$0 + 2248 >> 2]; + HEAP32[$0 + 13296 >> 2] = $2; + HEAP32[$0 + 13300 >> 2] = $1; + $1 = HEAP32[$0 + 13296 >> 2]; + $2 = HEAP32[$0 + 13300 >> 2]; + HEAP32[$0 + 13324 >> 2] = $0 + 2258; + HEAP32[$0 + 13320 >> 2] = 11171; + HEAP32[$0 + 13316 >> 2] = $2; + HEAP32[$0 + 13312 >> 2] = $1; + $3 = HEAP32[$0 + 13324 >> 2]; + $4 = HEAP32[$0 + 13320 >> 2]; + $1 = HEAP32[$0 + 13312 >> 2]; + HEAP32[$0 + 13308 >> 2] = HEAP32[$0 + 13316 >> 2]; + HEAP32[$0 + 13304 >> 2] = $1; + $2 = HEAP32[$0 + 13308 >> 2]; + $1 = HEAP32[$0 + 13304 >> 2]; + HEAP32[$0 + 248 >> 2] = $1; + HEAP32[$0 + 252 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2RopeJoint____29_28_29_20const___invoke_b2RopeJoint__28char_20const__2c_20b2Vec2_20const__20_28b2RopeJoint____29_28_29_20const_29($4, $0 + 248 | 0); + HEAP32[$0 + 2244 >> 2] = 0; + HEAP32[$0 + 2240 >> 2] = 351; + $1 = HEAP32[$0 + 2244 >> 2]; + $2 = HEAP32[$0 + 2240 >> 2]; + HEAP32[$0 + 13264 >> 2] = $2; + HEAP32[$0 + 13268 >> 2] = $1; + $1 = HEAP32[$0 + 13264 >> 2]; + $2 = HEAP32[$0 + 13268 >> 2]; + HEAP32[$0 + 13292 >> 2] = $3; + HEAP32[$0 + 13288 >> 2] = 11028; + HEAP32[$0 + 13284 >> 2] = $2; + HEAP32[$0 + 13280 >> 2] = $1; + $3 = HEAP32[$0 + 13292 >> 2]; + $4 = HEAP32[$0 + 13288 >> 2]; + $1 = HEAP32[$0 + 13280 >> 2]; + HEAP32[$0 + 13276 >> 2] = HEAP32[$0 + 13284 >> 2]; + HEAP32[$0 + 13272 >> 2] = $1; + $2 = HEAP32[$0 + 13276 >> 2]; + $1 = HEAP32[$0 + 13272 >> 2]; + HEAP32[$0 + 240 >> 2] = $1; + HEAP32[$0 + 244 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2RopeJoint____29_28_29_20const___invoke_b2RopeJoint__28char_20const__2c_20b2Vec2_20const__20_28b2RopeJoint____29_28_29_20const_29($4, $0 + 240 | 0); + HEAP32[$0 + 2236 >> 2] = 1; + HEAP32[$0 + 2232 >> 2] = 8; + $1 = HEAP32[$0 + 2236 >> 2]; + $2 = HEAP32[$0 + 2232 >> 2]; + HEAP32[$0 + 13328 >> 2] = $2; + HEAP32[$0 + 13332 >> 2] = $1; + $1 = HEAP32[$0 + 13328 >> 2]; + $2 = HEAP32[$0 + 13332 >> 2]; + HEAP32[$0 + 13356 >> 2] = $3; + HEAP32[$0 + 13352 >> 2] = 9958; + HEAP32[$0 + 13348 >> 2] = $2; + HEAP32[$0 + 13344 >> 2] = $1; + $3 = HEAP32[$0 + 13356 >> 2]; + $4 = HEAP32[$0 + 13352 >> 2]; + $1 = HEAP32[$0 + 13344 >> 2]; + HEAP32[$0 + 13340 >> 2] = HEAP32[$0 + 13348 >> 2]; + HEAP32[$0 + 13336 >> 2] = $1; + $2 = HEAP32[$0 + 13340 >> 2]; + $1 = HEAP32[$0 + 13336 >> 2]; + HEAP32[$0 + 232 >> 2] = $1; + HEAP32[$0 + 236 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2RopeJoint____29_28float_29_20const___invoke_b2RopeJoint__28char_20const__2c_20b2Vec2_20_28b2RopeJoint____29_28float_29_20const_29($4, $0 + 232 | 0); + HEAP32[$0 + 2228 >> 2] = 1; + HEAP32[$0 + 2224 >> 2] = 12; + $1 = HEAP32[$0 + 2228 >> 2]; + $2 = HEAP32[$0 + 2224 >> 2]; + HEAP32[$0 + 13360 >> 2] = $2; + HEAP32[$0 + 13364 >> 2] = $1; + $1 = HEAP32[$0 + 13360 >> 2]; + $2 = HEAP32[$0 + 13364 >> 2]; + HEAP32[$0 + 13388 >> 2] = $3; + HEAP32[$0 + 13384 >> 2] = 8857; + HEAP32[$0 + 13380 >> 2] = $2; + HEAP32[$0 + 13376 >> 2] = $1; + $3 = HEAP32[$0 + 13388 >> 2]; + $4 = HEAP32[$0 + 13384 >> 2]; + $1 = HEAP32[$0 + 13376 >> 2]; + HEAP32[$0 + 13372 >> 2] = HEAP32[$0 + 13380 >> 2]; + HEAP32[$0 + 13368 >> 2] = $1; + $2 = HEAP32[$0 + 13372 >> 2]; + $1 = HEAP32[$0 + 13368 >> 2]; + HEAP32[$0 + 224 >> 2] = $1; + HEAP32[$0 + 228 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2RopeJoint____29_28float_29_20const___invoke_b2RopeJoint__28char_20const__2c_20float_20_28b2RopeJoint____29_28float_29_20const_29($4, $0 + 224 | 0); + HEAP32[$0 + 2220 >> 2] = 0; + HEAP32[$0 + 2216 >> 2] = 352; + $1 = HEAP32[$0 + 2220 >> 2]; + $2 = HEAP32[$0 + 2216 >> 2]; + HEAP32[$0 + 13392 >> 2] = $2; + HEAP32[$0 + 13396 >> 2] = $1; + $1 = HEAP32[$0 + 13392 >> 2]; + $2 = HEAP32[$0 + 13396 >> 2]; + HEAP32[$0 + 13420 >> 2] = $3; + HEAP32[$0 + 13416 >> 2] = 7064; + HEAP32[$0 + 13412 >> 2] = $2; + HEAP32[$0 + 13408 >> 2] = $1; + $3 = HEAP32[$0 + 13420 >> 2]; + $4 = HEAP32[$0 + 13416 >> 2]; + $1 = HEAP32[$0 + 13408 >> 2]; + HEAP32[$0 + 13404 >> 2] = HEAP32[$0 + 13412 >> 2]; + HEAP32[$0 + 13400 >> 2] = $1; + $2 = HEAP32[$0 + 13404 >> 2]; + $1 = HEAP32[$0 + 13400 >> 2]; + HEAP32[$0 + 216 >> 2] = $1; + HEAP32[$0 + 220 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2RopeJoint____29_28float_29___invoke_b2RopeJoint__28char_20const__2c_20void_20_28b2RopeJoint____29_28float_29_29($4, $0 + 216 | 0); + HEAP32[$0 + 2212 >> 2] = 0; + HEAP32[$0 + 2208 >> 2] = 353; + $1 = HEAP32[$0 + 2212 >> 2]; + $2 = HEAP32[$0 + 2208 >> 2]; + HEAP32[$0 + 13456 >> 2] = $2; + HEAP32[$0 + 13460 >> 2] = $1; + $1 = HEAP32[$0 + 13456 >> 2]; + $2 = HEAP32[$0 + 13460 >> 2]; + HEAP32[$0 + 13484 >> 2] = $3; + HEAP32[$0 + 13480 >> 2] = 7077; + HEAP32[$0 + 13476 >> 2] = $2; + HEAP32[$0 + 13472 >> 2] = $1; + $3 = HEAP32[$0 + 13484 >> 2]; + $4 = HEAP32[$0 + 13480 >> 2]; + $1 = HEAP32[$0 + 13472 >> 2]; + HEAP32[$0 + 13468 >> 2] = HEAP32[$0 + 13476 >> 2]; + HEAP32[$0 + 13464 >> 2] = $1; + $2 = HEAP32[$0 + 13468 >> 2]; + $1 = HEAP32[$0 + 13464 >> 2]; + HEAP32[$0 + 208 >> 2] = $1; + HEAP32[$0 + 212 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2RopeJoint____29_28_29_20const___invoke_b2RopeJoint__28char_20const__2c_20float_20_28b2RopeJoint____29_28_29_20const_29($4, $0 + 208 | 0); + HEAP32[$0 + 2204 >> 2] = 0; + HEAP32[$0 + 2200 >> 2] = 354; + $1 = HEAP32[$0 + 2204 >> 2]; + $2 = HEAP32[$0 + 2200 >> 2]; + HEAP32[$0 + 13424 >> 2] = $2; + HEAP32[$0 + 13428 >> 2] = $1; + $1 = HEAP32[$0 + 13424 >> 2]; + $2 = HEAP32[$0 + 13428 >> 2]; + HEAP32[$0 + 13452 >> 2] = $3; + HEAP32[$0 + 13448 >> 2] = 7100; + HEAP32[$0 + 13444 >> 2] = $2; + HEAP32[$0 + 13440 >> 2] = $1; + $3 = HEAP32[$0 + 13452 >> 2]; + $4 = HEAP32[$0 + 13448 >> 2]; + $1 = HEAP32[$0 + 13440 >> 2]; + HEAP32[$0 + 13436 >> 2] = HEAP32[$0 + 13444 >> 2]; + HEAP32[$0 + 13432 >> 2] = $1; + $2 = HEAP32[$0 + 13436 >> 2]; + $1 = HEAP32[$0 + 13432 >> 2]; + HEAP32[$0 + 200 >> 2] = $1; + HEAP32[$0 + 204 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2RopeJoint____29_28_29_20const___invoke_b2RopeJoint__28char_20const__2c_20float_20_28b2RopeJoint____29_28_29_20const_29($4, $0 + 200 | 0); + HEAP32[$0 + 2196 >> 2] = 1; + HEAP32[$0 + 2192 >> 2] = 16; + $1 = HEAP32[$0 + 2196 >> 2]; + $2 = HEAP32[$0 + 2192 >> 2]; + HEAP32[$0 + 13488 >> 2] = $2; + HEAP32[$0 + 13492 >> 2] = $1; + $1 = HEAP32[$0 + 13488 >> 2]; + $2 = HEAP32[$0 + 13492 >> 2]; + HEAP32[$0 + 13516 >> 2] = $3; + HEAP32[$0 + 13512 >> 2] = 6232; + HEAP32[$0 + 13508 >> 2] = $2; + HEAP32[$0 + 13504 >> 2] = $1; + $3 = HEAP32[$0 + 13512 >> 2]; + $1 = HEAP32[$0 + 13504 >> 2]; + HEAP32[$0 + 13500 >> 2] = HEAP32[$0 + 13508 >> 2]; + HEAP32[$0 + 13496 >> 2] = $1; + $2 = HEAP32[$0 + 13500 >> 2]; + $1 = HEAP32[$0 + 13496 >> 2]; + HEAP32[$0 + 192 >> 2] = $1; + HEAP32[$0 + 196 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2RopeJoint____29_28_29___invoke_b2RopeJoint__28char_20const__2c_20void_20_28b2RopeJoint____29_28_29_29($3, $0 + 192 | 0); + HEAP32[$0 + 13540 >> 2] = $0 + 2191; + HEAP32[$0 + 13536 >> 2] = 7976; + void_20emscripten__base_b2JointDef___verify_b2WeldJointDef__28_29(); + HEAP32[$0 + 13532 >> 2] = 355; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2WeldJointDef__28_29_29_28b2WeldJointDef__29(), + HEAP32[wasm2js_i32$0 + 13528 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2WeldJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2WeldJointDef__28_29_29_28b2JointDef__29(), + HEAP32[wasm2js_i32$0 + 13524 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 13520 >> 2] = 356; + $1 = emscripten__internal__TypeID_b2WeldJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WeldJointDef__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WeldJointDef_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2JointDef___get_28_29(); + HEAP32[$0 + 16144 >> 2] = HEAP32[$0 + 13532 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 13532 >> 2]; + HEAP32[$0 + 16148 >> 2] = HEAP32[$0 + 13528 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 13528 >> 2]; + HEAP32[$0 + 16152 >> 2] = HEAP32[$0 + 13524 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 13524 >> 2]; + $11 = HEAP32[$0 + 13536 >> 2]; + HEAP32[$0 + 16156 >> 2] = HEAP32[$0 + 13520 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 13520 >> 2]); + HEAP32[$0 + 13544 >> 2] = $0 + 2191; + HEAP32[$0 + 16164 >> 2] = HEAP32[$0 + 13544 >> 2]; + HEAP32[$0 + 16160 >> 2] = 357; + $1 = HEAP32[$0 + 16164 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2WeldJointDef__20_28__29_28_29___invoke_b2WeldJointDef__28b2WeldJointDef__20_28__29_28_29_29(HEAP32[$0 + 16160 >> 2]); + HEAP32[$0 + 13584 >> 2] = $1; + HEAP32[$0 + 13580 >> 2] = 11158; + HEAP32[$0 + 13576 >> 2] = 20; + $1 = HEAP32[$0 + 13584 >> 2]; + HEAP32[$0 + 13572 >> 2] = 358; + HEAP32[$0 + 13568 >> 2] = 359; + $2 = emscripten__internal__TypeID_b2WeldJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 13580 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16168 >> 2] = HEAP32[$0 + 13572 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 13572 >> 2]; + $7 = b2Vec2_20b2WeldJointDef_____20emscripten__internal__getContext_b2Vec2_20b2WeldJointDef_____28b2Vec2_20b2WeldJointDef____20const__29($0 + 13576 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16176 >> 2] = HEAP32[$0 + 13568 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 13568 >> 2], b2Vec2_20b2WeldJointDef_____20emscripten__internal__getContext_b2Vec2_20b2WeldJointDef_____28b2Vec2_20b2WeldJointDef____20const__29($0 + 13576 | 0) | 0); + HEAP32[$0 + 13564 >> 2] = $1; + HEAP32[$0 + 13560 >> 2] = 11015; + HEAP32[$0 + 13556 >> 2] = 28; + $1 = HEAP32[$0 + 13564 >> 2]; + HEAP32[$0 + 13552 >> 2] = 358; + HEAP32[$0 + 13548 >> 2] = 359; + $2 = emscripten__internal__TypeID_b2WeldJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 13560 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16172 >> 2] = HEAP32[$0 + 13552 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 13552 >> 2]; + $7 = b2Vec2_20b2WeldJointDef_____20emscripten__internal__getContext_b2Vec2_20b2WeldJointDef_____28b2Vec2_20b2WeldJointDef____20const__29($0 + 13556 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16180 >> 2] = HEAP32[$0 + 13548 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 13548 >> 2], b2Vec2_20b2WeldJointDef_____20emscripten__internal__getContext_b2Vec2_20b2WeldJointDef_____28b2Vec2_20b2WeldJointDef____20const__29($0 + 13556 | 0) | 0); + HEAP32[$0 + 13644 >> 2] = $1; + HEAP32[$0 + 13640 >> 2] = 9471; + HEAP32[$0 + 13636 >> 2] = 36; + $1 = HEAP32[$0 + 13644 >> 2]; + HEAP32[$0 + 13632 >> 2] = 360; + HEAP32[$0 + 13628 >> 2] = 361; + $2 = emscripten__internal__TypeID_b2WeldJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 13640 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16184 >> 2] = HEAP32[$0 + 13632 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 13632 >> 2]; + $7 = float_20b2WeldJointDef_____20emscripten__internal__getContext_float_20b2WeldJointDef_____28float_20b2WeldJointDef____20const__29($0 + 13636 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16196 >> 2] = HEAP32[$0 + 13628 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 13628 >> 2], float_20b2WeldJointDef_____20emscripten__internal__getContext_float_20b2WeldJointDef_____28float_20b2WeldJointDef____20const__29($0 + 13636 | 0) | 0); + HEAP32[$0 + 13624 >> 2] = $1; + HEAP32[$0 + 13620 >> 2] = 3387; + HEAP32[$0 + 13616 >> 2] = 40; + $1 = HEAP32[$0 + 13624 >> 2]; + HEAP32[$0 + 13612 >> 2] = 360; + HEAP32[$0 + 13608 >> 2] = 361; + $2 = emscripten__internal__TypeID_b2WeldJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 13620 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16188 >> 2] = HEAP32[$0 + 13612 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 13612 >> 2]; + $7 = float_20b2WeldJointDef_____20emscripten__internal__getContext_float_20b2WeldJointDef_____28float_20b2WeldJointDef____20const__29($0 + 13616 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16200 >> 2] = HEAP32[$0 + 13608 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 13608 >> 2], float_20b2WeldJointDef_____20emscripten__internal__getContext_float_20b2WeldJointDef_____28float_20b2WeldJointDef____20const__29($0 + 13616 | 0) | 0); + HEAP32[$0 + 13604 >> 2] = $1; + HEAP32[$0 + 13600 >> 2] = 7694; + HEAP32[$0 + 13596 >> 2] = 44; + HEAP32[$0 + 13592 >> 2] = 360; + HEAP32[$0 + 13588 >> 2] = 361; + $1 = emscripten__internal__TypeID_b2WeldJointDef_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 13600 >> 2]; + $3 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16192 >> 2] = HEAP32[$0 + 13592 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $5 = HEAP32[$0 + 13592 >> 2]; + $6 = float_20b2WeldJointDef_____20emscripten__internal__getContext_float_20b2WeldJointDef_____28float_20b2WeldJointDef____20const__29($0 + 13596 | 0); + $7 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16204 >> 2] = HEAP32[$0 + 13588 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 13588 >> 2], float_20b2WeldJointDef_____20emscripten__internal__getContext_float_20b2WeldJointDef_____28float_20b2WeldJointDef____20const__29($0 + 13596 | 0) | 0); + HEAP32[$0 + 13668 >> 2] = $0 + 2190; + HEAP32[$0 + 13664 >> 2] = 2635; + void_20emscripten__base_b2Joint___verify_b2WeldJoint__28_29(); + HEAP32[$0 + 13660 >> 2] = 362; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2WeldJoint__28_29_29_28b2WeldJoint__29(), + HEAP32[wasm2js_i32$0 + 13656 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2WeldJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2WeldJoint__28_29_29_28b2Joint__29(), + HEAP32[wasm2js_i32$0 + 13652 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 13648 >> 2] = 363; + $1 = emscripten__internal__TypeID_b2WeldJoint_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WeldJoint__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WeldJoint_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2Joint___get_28_29(); + HEAP32[$0 + 16208 >> 2] = HEAP32[$0 + 13660 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 13660 >> 2]; + HEAP32[$0 + 16212 >> 2] = HEAP32[$0 + 13656 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 13656 >> 2]; + HEAP32[$0 + 16216 >> 2] = HEAP32[$0 + 13652 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 13652 >> 2]; + $11 = HEAP32[$0 + 13664 >> 2]; + HEAP32[$0 + 16220 >> 2] = HEAP32[$0 + 13648 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 13648 >> 2]); + HEAP32[$0 + 2184 >> 2] = 0; + HEAP32[$0 + 2180 >> 2] = 364; + $1 = HEAP32[$0 + 2184 >> 2]; + $2 = HEAP32[$0 + 2180 >> 2]; + HEAP32[$0 + 13704 >> 2] = $2; + HEAP32[$0 + 13708 >> 2] = $1; + $1 = HEAP32[$0 + 13704 >> 2]; + $2 = HEAP32[$0 + 13708 >> 2]; + HEAP32[$0 + 13732 >> 2] = $0 + 2190; + HEAP32[$0 + 13728 >> 2] = 11171; + HEAP32[$0 + 13724 >> 2] = $2; + HEAP32[$0 + 13720 >> 2] = $1; + $3 = HEAP32[$0 + 13732 >> 2]; + $4 = HEAP32[$0 + 13728 >> 2]; + $1 = HEAP32[$0 + 13720 >> 2]; + HEAP32[$0 + 13716 >> 2] = HEAP32[$0 + 13724 >> 2]; + HEAP32[$0 + 13712 >> 2] = $1; + $2 = HEAP32[$0 + 13716 >> 2]; + $1 = HEAP32[$0 + 13712 >> 2]; + HEAP32[$0 + 184 >> 2] = $1; + HEAP32[$0 + 188 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2WeldJoint____29_28_29_20const___invoke_b2WeldJoint__28char_20const__2c_20b2Vec2_20const__20_28b2WeldJoint____29_28_29_20const_29($4, $0 + 184 | 0); + HEAP32[$0 + 2176 >> 2] = 0; + HEAP32[$0 + 2172 >> 2] = 365; + $1 = HEAP32[$0 + 2176 >> 2]; + $2 = HEAP32[$0 + 2172 >> 2]; + HEAP32[$0 + 13672 >> 2] = $2; + HEAP32[$0 + 13676 >> 2] = $1; + $1 = HEAP32[$0 + 13672 >> 2]; + $2 = HEAP32[$0 + 13676 >> 2]; + HEAP32[$0 + 13700 >> 2] = $3; + HEAP32[$0 + 13696 >> 2] = 11028; + HEAP32[$0 + 13692 >> 2] = $2; + HEAP32[$0 + 13688 >> 2] = $1; + $3 = HEAP32[$0 + 13700 >> 2]; + $4 = HEAP32[$0 + 13696 >> 2]; + $1 = HEAP32[$0 + 13688 >> 2]; + HEAP32[$0 + 13684 >> 2] = HEAP32[$0 + 13692 >> 2]; + HEAP32[$0 + 13680 >> 2] = $1; + $2 = HEAP32[$0 + 13684 >> 2]; + $1 = HEAP32[$0 + 13680 >> 2]; + HEAP32[$0 + 176 >> 2] = $1; + HEAP32[$0 + 180 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2WeldJoint____29_28_29_20const___invoke_b2WeldJoint__28char_20const__2c_20b2Vec2_20const__20_28b2WeldJoint____29_28_29_20const_29($4, $0 + 176 | 0); + HEAP32[$0 + 2168 >> 2] = 0; + HEAP32[$0 + 2164 >> 2] = 366; + $1 = HEAP32[$0 + 2168 >> 2]; + $2 = HEAP32[$0 + 2164 >> 2]; + HEAP32[$0 + 13800 >> 2] = $2; + HEAP32[$0 + 13804 >> 2] = $1; + $1 = HEAP32[$0 + 13800 >> 2]; + $2 = HEAP32[$0 + 13804 >> 2]; + HEAP32[$0 + 13828 >> 2] = $3; + HEAP32[$0 + 13824 >> 2] = 9486; + HEAP32[$0 + 13820 >> 2] = $2; + HEAP32[$0 + 13816 >> 2] = $1; + $3 = HEAP32[$0 + 13828 >> 2]; + $4 = HEAP32[$0 + 13824 >> 2]; + $1 = HEAP32[$0 + 13816 >> 2]; + HEAP32[$0 + 13812 >> 2] = HEAP32[$0 + 13820 >> 2]; + HEAP32[$0 + 13808 >> 2] = $1; + $2 = HEAP32[$0 + 13812 >> 2]; + $1 = HEAP32[$0 + 13808 >> 2]; + HEAP32[$0 + 168 >> 2] = $1; + HEAP32[$0 + 172 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2WeldJoint____29_28_29_20const___invoke_b2WeldJoint__28char_20const__2c_20float_20_28b2WeldJoint____29_28_29_20const_29($4, $0 + 168 | 0); + HEAP32[$0 + 2160 >> 2] = 0; + HEAP32[$0 + 2156 >> 2] = 367; + $1 = HEAP32[$0 + 2160 >> 2]; + $2 = HEAP32[$0 + 2156 >> 2]; + HEAP32[$0 + 13864 >> 2] = $2; + HEAP32[$0 + 13868 >> 2] = $1; + $1 = HEAP32[$0 + 13864 >> 2]; + $2 = HEAP32[$0 + 13868 >> 2]; + HEAP32[$0 + 13892 >> 2] = $3; + HEAP32[$0 + 13888 >> 2] = 3397; + HEAP32[$0 + 13884 >> 2] = $2; + HEAP32[$0 + 13880 >> 2] = $1; + $3 = HEAP32[$0 + 13892 >> 2]; + $4 = HEAP32[$0 + 13888 >> 2]; + $1 = HEAP32[$0 + 13880 >> 2]; + HEAP32[$0 + 13876 >> 2] = HEAP32[$0 + 13884 >> 2]; + HEAP32[$0 + 13872 >> 2] = $1; + $2 = HEAP32[$0 + 13876 >> 2]; + $1 = HEAP32[$0 + 13872 >> 2]; + HEAP32[$0 + 160 >> 2] = $1; + HEAP32[$0 + 164 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2WeldJoint____29_28float_29___invoke_b2WeldJoint__28char_20const__2c_20void_20_28b2WeldJoint____29_28float_29_29($4, $0 + 160 | 0); + HEAP32[$0 + 2152 >> 2] = 0; + HEAP32[$0 + 2148 >> 2] = 368; + $1 = HEAP32[$0 + 2152 >> 2]; + $2 = HEAP32[$0 + 2148 >> 2]; + HEAP32[$0 + 13768 >> 2] = $2; + HEAP32[$0 + 13772 >> 2] = $1; + $1 = HEAP32[$0 + 13768 >> 2]; + $2 = HEAP32[$0 + 13772 >> 2]; + HEAP32[$0 + 13796 >> 2] = $3; + HEAP32[$0 + 13792 >> 2] = 3410; + HEAP32[$0 + 13788 >> 2] = $2; + HEAP32[$0 + 13784 >> 2] = $1; + $3 = HEAP32[$0 + 13796 >> 2]; + $4 = HEAP32[$0 + 13792 >> 2]; + $1 = HEAP32[$0 + 13784 >> 2]; + HEAP32[$0 + 13780 >> 2] = HEAP32[$0 + 13788 >> 2]; + HEAP32[$0 + 13776 >> 2] = $1; + $2 = HEAP32[$0 + 13780 >> 2]; + $1 = HEAP32[$0 + 13776 >> 2]; + HEAP32[$0 + 152 >> 2] = $1; + HEAP32[$0 + 156 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2WeldJoint____29_28_29_20const___invoke_b2WeldJoint__28char_20const__2c_20float_20_28b2WeldJoint____29_28_29_20const_29($4, $0 + 152 | 0); + HEAP32[$0 + 2144 >> 2] = 0; + HEAP32[$0 + 2140 >> 2] = 369; + $1 = HEAP32[$0 + 2144 >> 2]; + $2 = HEAP32[$0 + 2140 >> 2]; + HEAP32[$0 + 13832 >> 2] = $2; + HEAP32[$0 + 13836 >> 2] = $1; + $1 = HEAP32[$0 + 13832 >> 2]; + $2 = HEAP32[$0 + 13836 >> 2]; + HEAP32[$0 + 13860 >> 2] = $3; + HEAP32[$0 + 13856 >> 2] = 7702; + HEAP32[$0 + 13852 >> 2] = $2; + HEAP32[$0 + 13848 >> 2] = $1; + $3 = HEAP32[$0 + 13860 >> 2]; + $4 = HEAP32[$0 + 13856 >> 2]; + $1 = HEAP32[$0 + 13848 >> 2]; + HEAP32[$0 + 13844 >> 2] = HEAP32[$0 + 13852 >> 2]; + HEAP32[$0 + 13840 >> 2] = $1; + $2 = HEAP32[$0 + 13844 >> 2]; + $1 = HEAP32[$0 + 13840 >> 2]; + HEAP32[$0 + 144 >> 2] = $1; + HEAP32[$0 + 148 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2WeldJoint____29_28float_29___invoke_b2WeldJoint__28char_20const__2c_20void_20_28b2WeldJoint____29_28float_29_29($4, $0 + 144 | 0); + HEAP32[$0 + 2136 >> 2] = 0; + HEAP32[$0 + 2132 >> 2] = 370; + $1 = HEAP32[$0 + 2136 >> 2]; + $2 = HEAP32[$0 + 2132 >> 2]; + HEAP32[$0 + 13736 >> 2] = $2; + HEAP32[$0 + 13740 >> 2] = $1; + $1 = HEAP32[$0 + 13736 >> 2]; + $2 = HEAP32[$0 + 13740 >> 2]; + HEAP32[$0 + 13764 >> 2] = $3; + HEAP32[$0 + 13760 >> 2] = 7713; + HEAP32[$0 + 13756 >> 2] = $2; + HEAP32[$0 + 13752 >> 2] = $1; + $3 = HEAP32[$0 + 13764 >> 2]; + $4 = HEAP32[$0 + 13760 >> 2]; + $1 = HEAP32[$0 + 13752 >> 2]; + HEAP32[$0 + 13748 >> 2] = HEAP32[$0 + 13756 >> 2]; + HEAP32[$0 + 13744 >> 2] = $1; + $2 = HEAP32[$0 + 13748 >> 2]; + $1 = HEAP32[$0 + 13744 >> 2]; + HEAP32[$0 + 136 >> 2] = $1; + HEAP32[$0 + 140 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2WeldJoint____29_28_29_20const___invoke_b2WeldJoint__28char_20const__2c_20float_20_28b2WeldJoint____29_28_29_20const_29($4, $0 + 136 | 0); + HEAP32[$0 + 2128 >> 2] = 1; + HEAP32[$0 + 2124 >> 2] = 16; + $1 = HEAP32[$0 + 2128 >> 2]; + $2 = HEAP32[$0 + 2124 >> 2]; + HEAP32[$0 + 13896 >> 2] = $2; + HEAP32[$0 + 13900 >> 2] = $1; + $1 = HEAP32[$0 + 13896 >> 2]; + $2 = HEAP32[$0 + 13900 >> 2]; + HEAP32[$0 + 13924 >> 2] = $3; + HEAP32[$0 + 13920 >> 2] = 6232; + HEAP32[$0 + 13916 >> 2] = $2; + HEAP32[$0 + 13912 >> 2] = $1; + $3 = HEAP32[$0 + 13920 >> 2]; + $1 = HEAP32[$0 + 13912 >> 2]; + HEAP32[$0 + 13908 >> 2] = HEAP32[$0 + 13916 >> 2]; + HEAP32[$0 + 13904 >> 2] = $1; + $2 = HEAP32[$0 + 13908 >> 2]; + $1 = HEAP32[$0 + 13904 >> 2]; + HEAP32[$0 + 128 >> 2] = $1; + HEAP32[$0 + 132 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2WeldJoint____29_28_29___invoke_b2WeldJoint__28char_20const__2c_20void_20_28b2WeldJoint____29_28_29_29($3, $0 + 128 | 0); + HEAP32[$0 + 13948 >> 2] = $0 + 2123; + HEAP32[$0 + 13944 >> 2] = 7901; + void_20emscripten__base_b2JointDef___verify_b2WheelJointDef__28_29(); + HEAP32[$0 + 13940 >> 2] = 371; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2WheelJointDef__28_29_29_28b2WheelJointDef__29(), + HEAP32[wasm2js_i32$0 + 13936 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2WheelJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2WheelJointDef__28_29_29_28b2JointDef__29(), + HEAP32[wasm2js_i32$0 + 13932 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 13928 >> 2] = 372; + $1 = emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WheelJointDef__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WheelJointDef_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2JointDef___get_28_29(); + HEAP32[$0 + 16224 >> 2] = HEAP32[$0 + 13940 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 13940 >> 2]; + HEAP32[$0 + 16228 >> 2] = HEAP32[$0 + 13936 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 13936 >> 2]; + HEAP32[$0 + 16232 >> 2] = HEAP32[$0 + 13932 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 13932 >> 2]; + $11 = HEAP32[$0 + 13944 >> 2]; + HEAP32[$0 + 16236 >> 2] = HEAP32[$0 + 13928 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 13928 >> 2]); + HEAP32[$0 + 13952 >> 2] = $0 + 2123; + HEAP32[$0 + 16244 >> 2] = HEAP32[$0 + 13952 >> 2]; + HEAP32[$0 + 16240 >> 2] = 373; + $1 = HEAP32[$0 + 16244 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_b2WheelJointDef__20_28__29_28_29___invoke_b2WheelJointDef__28b2WheelJointDef__20_28__29_28_29_29(HEAP32[$0 + 16240 >> 2]); + HEAP32[$0 + 14012 >> 2] = $1; + HEAP32[$0 + 14008 >> 2] = 11158; + HEAP32[$0 + 14004 >> 2] = 20; + $1 = HEAP32[$0 + 14012 >> 2]; + HEAP32[$0 + 14e3 >> 2] = 374; + HEAP32[$0 + 13996 >> 2] = 375; + $2 = emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 14008 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16248 >> 2] = HEAP32[$0 + 14e3 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 14e3 >> 2]; + $7 = b2Vec2_20b2WheelJointDef_____20emscripten__internal__getContext_b2Vec2_20b2WheelJointDef_____28b2Vec2_20b2WheelJointDef____20const__29($0 + 14004 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16260 >> 2] = HEAP32[$0 + 13996 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 13996 >> 2], b2Vec2_20b2WheelJointDef_____20emscripten__internal__getContext_b2Vec2_20b2WheelJointDef_____28b2Vec2_20b2WheelJointDef____20const__29($0 + 14004 | 0) | 0); + HEAP32[$0 + 13992 >> 2] = $1; + HEAP32[$0 + 13988 >> 2] = 11015; + HEAP32[$0 + 13984 >> 2] = 28; + $1 = HEAP32[$0 + 13992 >> 2]; + HEAP32[$0 + 13980 >> 2] = 374; + HEAP32[$0 + 13976 >> 2] = 375; + $2 = emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 13988 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16252 >> 2] = HEAP32[$0 + 13980 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 13980 >> 2]; + $7 = b2Vec2_20b2WheelJointDef_____20emscripten__internal__getContext_b2Vec2_20b2WheelJointDef_____28b2Vec2_20b2WheelJointDef____20const__29($0 + 13984 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16264 >> 2] = HEAP32[$0 + 13976 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 13976 >> 2], b2Vec2_20b2WheelJointDef_____20emscripten__internal__getContext_b2Vec2_20b2WheelJointDef_____28b2Vec2_20b2WheelJointDef____20const__29($0 + 13984 | 0) | 0); + HEAP32[$0 + 13972 >> 2] = $1; + HEAP32[$0 + 13968 >> 2] = 11122; + HEAP32[$0 + 13964 >> 2] = 36; + $1 = HEAP32[$0 + 13972 >> 2]; + HEAP32[$0 + 13960 >> 2] = 374; + HEAP32[$0 + 13956 >> 2] = 375; + $2 = emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 13968 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16256 >> 2] = HEAP32[$0 + 13960 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 13960 >> 2]; + $7 = b2Vec2_20b2WheelJointDef_____20emscripten__internal__getContext_b2Vec2_20b2WheelJointDef_____28b2Vec2_20b2WheelJointDef____20const__29($0 + 13964 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$0 + 16268 >> 2] = HEAP32[$0 + 13956 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 13956 >> 2], b2Vec2_20b2WheelJointDef_____20emscripten__internal__getContext_b2Vec2_20b2WheelJointDef_____28b2Vec2_20b2WheelJointDef____20const__29($0 + 13964 | 0) | 0); + HEAP32[$0 + 14052 >> 2] = $1; + HEAP32[$0 + 14048 >> 2] = 2849; + HEAP32[$0 + 14044 >> 2] = 44; + $1 = HEAP32[$0 + 14052 >> 2]; + HEAP32[$0 + 14040 >> 2] = 376; + HEAP32[$0 + 14036 >> 2] = 377; + $2 = emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 14048 >> 2]; + $4 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 16272 >> 2] = HEAP32[$0 + 14040 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 14040 >> 2]; + $7 = bool_20b2WheelJointDef_____20emscripten__internal__getContext_bool_20b2WheelJointDef_____28bool_20b2WheelJointDef____20const__29($0 + 14044 | 0); + $8 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 16280 >> 2] = HEAP32[$0 + 14036 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 14036 >> 2], bool_20b2WheelJointDef_____20emscripten__internal__getContext_bool_20b2WheelJointDef_____28bool_20b2WheelJointDef____20const__29($0 + 14044 | 0) | 0); + HEAP32[$0 + 14172 >> 2] = $1; + HEAP32[$0 + 14168 >> 2] = 6703; + HEAP32[$0 + 14164 >> 2] = 48; + $1 = HEAP32[$0 + 14172 >> 2]; + HEAP32[$0 + 14160 >> 2] = 378; + HEAP32[$0 + 14156 >> 2] = 379; + $2 = emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 14168 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16288 >> 2] = HEAP32[$0 + 14160 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 14160 >> 2]; + $7 = float_20b2WheelJointDef_____20emscripten__internal__getContext_float_20b2WheelJointDef_____28float_20b2WheelJointDef____20const__29($0 + 14164 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16312 >> 2] = HEAP32[$0 + 14156 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 14156 >> 2], float_20b2WheelJointDef_____20emscripten__internal__getContext_float_20b2WheelJointDef_____28float_20b2WheelJointDef____20const__29($0 + 14164 | 0) | 0); + HEAP32[$0 + 14152 >> 2] = $1; + HEAP32[$0 + 14148 >> 2] = 6744; + HEAP32[$0 + 14144 >> 2] = 52; + $1 = HEAP32[$0 + 14152 >> 2]; + HEAP32[$0 + 14140 >> 2] = 378; + HEAP32[$0 + 14136 >> 2] = 379; + $2 = emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 14148 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16292 >> 2] = HEAP32[$0 + 14140 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 14140 >> 2]; + $7 = float_20b2WheelJointDef_____20emscripten__internal__getContext_float_20b2WheelJointDef_____28float_20b2WheelJointDef____20const__29($0 + 14144 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16316 >> 2] = HEAP32[$0 + 14136 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 14136 >> 2], float_20b2WheelJointDef_____20emscripten__internal__getContext_float_20b2WheelJointDef_____28float_20b2WheelJointDef____20const__29($0 + 14144 | 0) | 0); + HEAP32[$0 + 14032 >> 2] = $1; + HEAP32[$0 + 14028 >> 2] = 3640; + HEAP32[$0 + 14024 >> 2] = 56; + $1 = HEAP32[$0 + 14032 >> 2]; + HEAP32[$0 + 14020 >> 2] = 376; + HEAP32[$0 + 14016 >> 2] = 377; + $2 = emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 14028 >> 2]; + $4 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 16276 >> 2] = HEAP32[$0 + 14020 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 14020 >> 2]; + $7 = bool_20b2WheelJointDef_____20emscripten__internal__getContext_bool_20b2WheelJointDef_____28bool_20b2WheelJointDef____20const__29($0 + 14024 | 0); + $8 = emscripten__internal__TypeID_bool_2c_20void___get_28_29(); + HEAP32[$0 + 16284 >> 2] = HEAP32[$0 + 14016 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$0 + 14016 >> 2], bool_20b2WheelJointDef_____20emscripten__internal__getContext_bool_20b2WheelJointDef_____28bool_20b2WheelJointDef____20const__29($0 + 14024 | 0) | 0); + HEAP32[$0 + 14132 >> 2] = $1; + HEAP32[$0 + 14128 >> 2] = 8791; + HEAP32[$0 + 14124 >> 2] = 60; + $1 = HEAP32[$0 + 14132 >> 2]; + HEAP32[$0 + 14120 >> 2] = 378; + HEAP32[$0 + 14116 >> 2] = 379; + $2 = emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 14128 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16296 >> 2] = HEAP32[$0 + 14120 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 14120 >> 2]; + $7 = float_20b2WheelJointDef_____20emscripten__internal__getContext_float_20b2WheelJointDef_____28float_20b2WheelJointDef____20const__29($0 + 14124 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16320 >> 2] = HEAP32[$0 + 14116 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 14116 >> 2], float_20b2WheelJointDef_____20emscripten__internal__getContext_float_20b2WheelJointDef_____28float_20b2WheelJointDef____20const__29($0 + 14124 | 0) | 0); + HEAP32[$0 + 14112 >> 2] = $1; + HEAP32[$0 + 14108 >> 2] = 10349; + HEAP32[$0 + 14104 >> 2] = 64; + $1 = HEAP32[$0 + 14112 >> 2]; + HEAP32[$0 + 14100 >> 2] = 378; + HEAP32[$0 + 14096 >> 2] = 379; + $2 = emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 14108 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16300 >> 2] = HEAP32[$0 + 14100 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 14100 >> 2]; + $7 = float_20b2WheelJointDef_____20emscripten__internal__getContext_float_20b2WheelJointDef_____28float_20b2WheelJointDef____20const__29($0 + 14104 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16324 >> 2] = HEAP32[$0 + 14096 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 14096 >> 2], float_20b2WheelJointDef_____20emscripten__internal__getContext_float_20b2WheelJointDef_____28float_20b2WheelJointDef____20const__29($0 + 14104 | 0) | 0); + HEAP32[$0 + 14092 >> 2] = $1; + HEAP32[$0 + 14088 >> 2] = 3387; + HEAP32[$0 + 14084 >> 2] = 68; + $1 = HEAP32[$0 + 14092 >> 2]; + HEAP32[$0 + 14080 >> 2] = 378; + HEAP32[$0 + 14076 >> 2] = 379; + $2 = emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29(); + $3 = HEAP32[$0 + 14088 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16304 >> 2] = HEAP32[$0 + 14080 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$0 + 14080 >> 2]; + $7 = float_20b2WheelJointDef_____20emscripten__internal__getContext_float_20b2WheelJointDef_____28float_20b2WheelJointDef____20const__29($0 + 14084 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16328 >> 2] = HEAP32[$0 + 14076 >> 2]; + _embind_register_class_property($2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 14076 >> 2], float_20b2WheelJointDef_____20emscripten__internal__getContext_float_20b2WheelJointDef_____28float_20b2WheelJointDef____20const__29($0 + 14084 | 0) | 0); + HEAP32[$0 + 14072 >> 2] = $1; + HEAP32[$0 + 14068 >> 2] = 7694; + HEAP32[$0 + 14064 >> 2] = 72; + HEAP32[$0 + 14060 >> 2] = 378; + HEAP32[$0 + 14056 >> 2] = 379; + $1 = emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29(); + $2 = HEAP32[$0 + 14068 >> 2]; + $3 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16308 >> 2] = HEAP32[$0 + 14060 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $5 = HEAP32[$0 + 14060 >> 2]; + $6 = float_20b2WheelJointDef_____20emscripten__internal__getContext_float_20b2WheelJointDef_____28float_20b2WheelJointDef____20const__29($0 + 14064 | 0); + $7 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$0 + 16332 >> 2] = HEAP32[$0 + 14056 >> 2]; + _embind_register_class_property($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$0 + 14056 >> 2], float_20b2WheelJointDef_____20emscripten__internal__getContext_float_20b2WheelJointDef_____28float_20b2WheelJointDef____20const__29($0 + 14064 | 0) | 0); + HEAP32[$0 + 14196 >> 2] = $0 + 2122; + HEAP32[$0 + 14192 >> 2] = 2561; + void_20emscripten__base_b2Joint___verify_b2WheelJoint__28_29(); + HEAP32[$0 + 14188 >> 2] = 380; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2WheelJoint__28_29_29_28b2WheelJoint__29(), + HEAP32[wasm2js_i32$0 + 14184 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2WheelJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2WheelJoint__28_29_29_28b2Joint__29(), + HEAP32[wasm2js_i32$0 + 14180 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 14176 >> 2] = 381; + $1 = emscripten__internal__TypeID_b2WheelJoint_2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WheelJoint_20const__2c_20void___get_28_29(); + $4 = emscripten__base_b2Joint___get_28_29(); + HEAP32[$0 + 16336 >> 2] = HEAP32[$0 + 14188 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$0 + 14188 >> 2]; + HEAP32[$0 + 16340 >> 2] = HEAP32[$0 + 14184 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $8 = HEAP32[$0 + 14184 >> 2]; + HEAP32[$0 + 16344 >> 2] = HEAP32[$0 + 14180 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $10 = HEAP32[$0 + 14180 >> 2]; + $11 = HEAP32[$0 + 14192 >> 2]; + HEAP32[$0 + 16348 >> 2] = HEAP32[$0 + 14176 >> 2]; + _embind_register_class($1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$0 + 14176 >> 2]); + HEAP32[$0 + 2116 >> 2] = 0; + HEAP32[$0 + 2112 >> 2] = 382; + $1 = HEAP32[$0 + 2116 >> 2]; + $2 = HEAP32[$0 + 2112 >> 2]; + HEAP32[$0 + 14264 >> 2] = $2; + HEAP32[$0 + 14268 >> 2] = $1; + $1 = HEAP32[$0 + 14264 >> 2]; + $2 = HEAP32[$0 + 14268 >> 2]; + HEAP32[$0 + 14292 >> 2] = $0 + 2122; + HEAP32[$0 + 14288 >> 2] = 11171; + HEAP32[$0 + 14284 >> 2] = $2; + HEAP32[$0 + 14280 >> 2] = $1; + $3 = HEAP32[$0 + 14292 >> 2]; + $4 = HEAP32[$0 + 14288 >> 2]; + $1 = HEAP32[$0 + 14280 >> 2]; + HEAP32[$0 + 14276 >> 2] = HEAP32[$0 + 14284 >> 2]; + HEAP32[$0 + 14272 >> 2] = $1; + $2 = HEAP32[$0 + 14276 >> 2]; + $1 = HEAP32[$0 + 14272 >> 2]; + HEAP32[$0 + 120 >> 2] = $1; + HEAP32[$0 + 124 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2WheelJoint____29_28_29_20const___invoke_b2WheelJoint__28char_20const__2c_20b2Vec2_20const__20_28b2WheelJoint____29_28_29_20const_29($4, $0 + 120 | 0); + HEAP32[$0 + 2108 >> 2] = 0; + HEAP32[$0 + 2104 >> 2] = 383; + $1 = HEAP32[$0 + 2108 >> 2]; + $2 = HEAP32[$0 + 2104 >> 2]; + HEAP32[$0 + 14232 >> 2] = $2; + HEAP32[$0 + 14236 >> 2] = $1; + $1 = HEAP32[$0 + 14232 >> 2]; + $2 = HEAP32[$0 + 14236 >> 2]; + HEAP32[$0 + 14260 >> 2] = $3; + HEAP32[$0 + 14256 >> 2] = 11028; + HEAP32[$0 + 14252 >> 2] = $2; + HEAP32[$0 + 14248 >> 2] = $1; + $3 = HEAP32[$0 + 14260 >> 2]; + $4 = HEAP32[$0 + 14256 >> 2]; + $1 = HEAP32[$0 + 14248 >> 2]; + HEAP32[$0 + 14244 >> 2] = HEAP32[$0 + 14252 >> 2]; + HEAP32[$0 + 14240 >> 2] = $1; + $2 = HEAP32[$0 + 14244 >> 2]; + $1 = HEAP32[$0 + 14240 >> 2]; + HEAP32[$0 + 112 >> 2] = $1; + HEAP32[$0 + 116 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2WheelJoint____29_28_29_20const___invoke_b2WheelJoint__28char_20const__2c_20b2Vec2_20const__20_28b2WheelJoint____29_28_29_20const_29($4, $0 + 112 | 0); + HEAP32[$0 + 2100 >> 2] = 0; + HEAP32[$0 + 2096 >> 2] = 384; + $1 = HEAP32[$0 + 2100 >> 2]; + $2 = HEAP32[$0 + 2096 >> 2]; + HEAP32[$0 + 14200 >> 2] = $2; + HEAP32[$0 + 14204 >> 2] = $1; + $1 = HEAP32[$0 + 14200 >> 2]; + $2 = HEAP32[$0 + 14204 >> 2]; + HEAP32[$0 + 14228 >> 2] = $3; + HEAP32[$0 + 14224 >> 2] = 11133; + HEAP32[$0 + 14220 >> 2] = $2; + HEAP32[$0 + 14216 >> 2] = $1; + $3 = HEAP32[$0 + 14228 >> 2]; + $4 = HEAP32[$0 + 14224 >> 2]; + $1 = HEAP32[$0 + 14216 >> 2]; + HEAP32[$0 + 14212 >> 2] = HEAP32[$0 + 14220 >> 2]; + HEAP32[$0 + 14208 >> 2] = $1; + $2 = HEAP32[$0 + 14212 >> 2]; + $1 = HEAP32[$0 + 14208 >> 2]; + HEAP32[$0 + 104 >> 2] = $1; + HEAP32[$0 + 108 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2WheelJoint____29_28_29_20const___invoke_b2WheelJoint__28char_20const__2c_20b2Vec2_20const__20_28b2WheelJoint____29_28_29_20const_29($4, $0 + 104 | 0); + HEAP32[$0 + 2092 >> 2] = 0; + HEAP32[$0 + 2088 >> 2] = 385; + $1 = HEAP32[$0 + 2092 >> 2]; + $2 = HEAP32[$0 + 2088 >> 2]; + HEAP32[$0 + 14424 >> 2] = $2; + HEAP32[$0 + 14428 >> 2] = $1; + $1 = HEAP32[$0 + 14424 >> 2]; + $2 = HEAP32[$0 + 14428 >> 2]; + HEAP32[$0 + 14452 >> 2] = $3; + HEAP32[$0 + 14448 >> 2] = 6683; + HEAP32[$0 + 14444 >> 2] = $2; + HEAP32[$0 + 14440 >> 2] = $1; + $3 = HEAP32[$0 + 14452 >> 2]; + $4 = HEAP32[$0 + 14448 >> 2]; + $1 = HEAP32[$0 + 14440 >> 2]; + HEAP32[$0 + 14436 >> 2] = HEAP32[$0 + 14444 >> 2]; + HEAP32[$0 + 14432 >> 2] = $1; + $2 = HEAP32[$0 + 14436 >> 2]; + $1 = HEAP32[$0 + 14432 >> 2]; + HEAP32[$0 + 96 >> 2] = $1; + HEAP32[$0 + 100 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2WheelJoint____29_28_29_20const___invoke_b2WheelJoint__28char_20const__2c_20float_20_28b2WheelJoint____29_28_29_20const_29($4, $0 + 96 | 0); + HEAP32[$0 + 2084 >> 2] = 0; + HEAP32[$0 + 2080 >> 2] = 386; + $1 = HEAP32[$0 + 2084 >> 2]; + $2 = HEAP32[$0 + 2080 >> 2]; + HEAP32[$0 + 14456 >> 2] = $2; + HEAP32[$0 + 14460 >> 2] = $1; + $1 = HEAP32[$0 + 14456 >> 2]; + $2 = HEAP32[$0 + 14460 >> 2]; + HEAP32[$0 + 14484 >> 2] = $3; + HEAP32[$0 + 14480 >> 2] = 10274; + HEAP32[$0 + 14476 >> 2] = $2; + HEAP32[$0 + 14472 >> 2] = $1; + $3 = HEAP32[$0 + 14484 >> 2]; + $4 = HEAP32[$0 + 14480 >> 2]; + $1 = HEAP32[$0 + 14472 >> 2]; + HEAP32[$0 + 14468 >> 2] = HEAP32[$0 + 14476 >> 2]; + HEAP32[$0 + 14464 >> 2] = $1; + $2 = HEAP32[$0 + 14468 >> 2]; + $1 = HEAP32[$0 + 14464 >> 2]; + HEAP32[$0 + 88 >> 2] = $1; + HEAP32[$0 + 92 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_bool_20_28b2WheelJoint____29_28_29_20const___invoke_b2WheelJoint__28char_20const__2c_20bool_20_28b2WheelJoint____29_28_29_20const_29($4, $0 + 88 | 0); + HEAP32[$0 + 2076 >> 2] = 0; + HEAP32[$0 + 2072 >> 2] = 387; + $1 = HEAP32[$0 + 2076 >> 2]; + $2 = HEAP32[$0 + 2072 >> 2]; + HEAP32[$0 + 14488 >> 2] = $2; + HEAP32[$0 + 14492 >> 2] = $1; + $1 = HEAP32[$0 + 14488 >> 2]; + $2 = HEAP32[$0 + 14492 >> 2]; + HEAP32[$0 + 14516 >> 2] = $3; + HEAP32[$0 + 14512 >> 2] = 3652; + HEAP32[$0 + 14508 >> 2] = $2; + HEAP32[$0 + 14504 >> 2] = $1; + $3 = HEAP32[$0 + 14516 >> 2]; + $4 = HEAP32[$0 + 14512 >> 2]; + $1 = HEAP32[$0 + 14504 >> 2]; + HEAP32[$0 + 14500 >> 2] = HEAP32[$0 + 14508 >> 2]; + HEAP32[$0 + 14496 >> 2] = $1; + $2 = HEAP32[$0 + 14500 >> 2]; + $1 = HEAP32[$0 + 14496 >> 2]; + HEAP32[$0 + 80 >> 2] = $1; + HEAP32[$0 + 84 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2WheelJoint____29_28bool_29___invoke_b2WheelJoint__28char_20const__2c_20void_20_28b2WheelJoint____29_28bool_29_29($4, $0 + 80 | 0); + HEAP32[$0 + 2068 >> 2] = 0; + HEAP32[$0 + 2064 >> 2] = 388; + $1 = HEAP32[$0 + 2068 >> 2]; + $2 = HEAP32[$0 + 2064 >> 2]; + HEAP32[$0 + 14616 >> 2] = $2; + HEAP32[$0 + 14620 >> 2] = $1; + $1 = HEAP32[$0 + 14616 >> 2]; + $2 = HEAP32[$0 + 14620 >> 2]; + HEAP32[$0 + 14644 >> 2] = $3; + HEAP32[$0 + 14640 >> 2] = 10360; + HEAP32[$0 + 14636 >> 2] = $2; + HEAP32[$0 + 14632 >> 2] = $1; + $3 = HEAP32[$0 + 14644 >> 2]; + $4 = HEAP32[$0 + 14640 >> 2]; + $1 = HEAP32[$0 + 14632 >> 2]; + HEAP32[$0 + 14628 >> 2] = HEAP32[$0 + 14636 >> 2]; + HEAP32[$0 + 14624 >> 2] = $1; + $2 = HEAP32[$0 + 14628 >> 2]; + $1 = HEAP32[$0 + 14624 >> 2]; + HEAP32[$0 + 72 >> 2] = $1; + HEAP32[$0 + 76 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2WheelJoint____29_28float_29___invoke_b2WheelJoint__28char_20const__2c_20void_20_28b2WheelJoint____29_28float_29_29($4, $0 + 72 | 0); + HEAP32[$0 + 2060 >> 2] = 0; + HEAP32[$0 + 2056 >> 2] = 389; + $1 = HEAP32[$0 + 2060 >> 2]; + $2 = HEAP32[$0 + 2056 >> 2]; + HEAP32[$0 + 14392 >> 2] = $2; + HEAP32[$0 + 14396 >> 2] = $1; + $1 = HEAP32[$0 + 14392 >> 2]; + $2 = HEAP32[$0 + 14396 >> 2]; + HEAP32[$0 + 14420 >> 2] = $3; + HEAP32[$0 + 14416 >> 2] = 10374; + HEAP32[$0 + 14412 >> 2] = $2; + HEAP32[$0 + 14408 >> 2] = $1; + $3 = HEAP32[$0 + 14420 >> 2]; + $4 = HEAP32[$0 + 14416 >> 2]; + $1 = HEAP32[$0 + 14408 >> 2]; + HEAP32[$0 + 14404 >> 2] = HEAP32[$0 + 14412 >> 2]; + HEAP32[$0 + 14400 >> 2] = $1; + $2 = HEAP32[$0 + 14404 >> 2]; + $1 = HEAP32[$0 + 14400 >> 2]; + HEAP32[$0 + 64 >> 2] = $1; + HEAP32[$0 + 68 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2WheelJoint____29_28_29_20const___invoke_b2WheelJoint__28char_20const__2c_20float_20_28b2WheelJoint____29_28_29_20const_29($4, $0 - -64 | 0); + HEAP32[$0 + 2052 >> 2] = 0; + HEAP32[$0 + 2048 >> 2] = 390; + $1 = HEAP32[$0 + 2052 >> 2]; + $2 = HEAP32[$0 + 2048 >> 2]; + HEAP32[$0 + 14584 >> 2] = $2; + HEAP32[$0 + 14588 >> 2] = $1; + $1 = HEAP32[$0 + 14584 >> 2]; + $2 = HEAP32[$0 + 14588 >> 2]; + HEAP32[$0 + 14612 >> 2] = $3; + HEAP32[$0 + 14608 >> 2] = 8806; + HEAP32[$0 + 14604 >> 2] = $2; + HEAP32[$0 + 14600 >> 2] = $1; + $3 = HEAP32[$0 + 14612 >> 2]; + $4 = HEAP32[$0 + 14608 >> 2]; + $1 = HEAP32[$0 + 14600 >> 2]; + HEAP32[$0 + 14596 >> 2] = HEAP32[$0 + 14604 >> 2]; + HEAP32[$0 + 14592 >> 2] = $1; + $2 = HEAP32[$0 + 14596 >> 2]; + $1 = HEAP32[$0 + 14592 >> 2]; + HEAP32[$0 + 56 >> 2] = $1; + HEAP32[$0 + 60 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2WheelJoint____29_28float_29___invoke_b2WheelJoint__28char_20const__2c_20void_20_28b2WheelJoint____29_28float_29_29($4, $0 + 56 | 0); + HEAP32[$0 + 2044 >> 2] = 0; + HEAP32[$0 + 2040 >> 2] = 391; + $1 = HEAP32[$0 + 2044 >> 2]; + $2 = HEAP32[$0 + 2040 >> 2]; + HEAP32[$0 + 14360 >> 2] = $2; + HEAP32[$0 + 14364 >> 2] = $1; + $1 = HEAP32[$0 + 14360 >> 2]; + $2 = HEAP32[$0 + 14364 >> 2]; + HEAP32[$0 + 14388 >> 2] = $3; + HEAP32[$0 + 14384 >> 2] = 8824; + HEAP32[$0 + 14380 >> 2] = $2; + HEAP32[$0 + 14376 >> 2] = $1; + $3 = HEAP32[$0 + 14388 >> 2]; + $4 = HEAP32[$0 + 14384 >> 2]; + $1 = HEAP32[$0 + 14376 >> 2]; + HEAP32[$0 + 14372 >> 2] = HEAP32[$0 + 14380 >> 2]; + HEAP32[$0 + 14368 >> 2] = $1; + $2 = HEAP32[$0 + 14372 >> 2]; + $1 = HEAP32[$0 + 14368 >> 2]; + HEAP32[$0 + 48 >> 2] = $1; + HEAP32[$0 + 52 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2WheelJoint____29_28_29_20const___invoke_b2WheelJoint__28char_20const__2c_20float_20_28b2WheelJoint____29_28_29_20const_29($4, $0 + 48 | 0); + HEAP32[$0 + 2036 >> 2] = 0; + HEAP32[$0 + 2032 >> 2] = 392; + $1 = HEAP32[$0 + 2036 >> 2]; + $2 = HEAP32[$0 + 2032 >> 2]; + HEAP32[$0 + 14648 >> 2] = $2; + HEAP32[$0 + 14652 >> 2] = $1; + $1 = HEAP32[$0 + 14648 >> 2]; + $2 = HEAP32[$0 + 14652 >> 2]; + HEAP32[$0 + 14676 >> 2] = $3; + HEAP32[$0 + 14672 >> 2] = 8842; + HEAP32[$0 + 14668 >> 2] = $2; + HEAP32[$0 + 14664 >> 2] = $1; + $3 = HEAP32[$0 + 14676 >> 2]; + $4 = HEAP32[$0 + 14672 >> 2]; + $1 = HEAP32[$0 + 14664 >> 2]; + HEAP32[$0 + 14660 >> 2] = HEAP32[$0 + 14668 >> 2]; + HEAP32[$0 + 14656 >> 2] = $1; + $2 = HEAP32[$0 + 14660 >> 2]; + $1 = HEAP32[$0 + 14656 >> 2]; + HEAP32[$0 + 40 >> 2] = $1; + HEAP32[$0 + 44 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2WheelJoint____29_28float_29_20const___invoke_b2WheelJoint__28char_20const__2c_20float_20_28b2WheelJoint____29_28float_29_20const_29($4, $0 + 40 | 0); + HEAP32[$0 + 2028 >> 2] = 0; + HEAP32[$0 + 2024 >> 2] = 393; + $1 = HEAP32[$0 + 2028 >> 2]; + $2 = HEAP32[$0 + 2024 >> 2]; + HEAP32[$0 + 14552 >> 2] = $2; + HEAP32[$0 + 14556 >> 2] = $1; + $1 = HEAP32[$0 + 14552 >> 2]; + $2 = HEAP32[$0 + 14556 >> 2]; + HEAP32[$0 + 14580 >> 2] = $3; + HEAP32[$0 + 14576 >> 2] = 3397; + HEAP32[$0 + 14572 >> 2] = $2; + HEAP32[$0 + 14568 >> 2] = $1; + $3 = HEAP32[$0 + 14580 >> 2]; + $4 = HEAP32[$0 + 14576 >> 2]; + $1 = HEAP32[$0 + 14568 >> 2]; + HEAP32[$0 + 14564 >> 2] = HEAP32[$0 + 14572 >> 2]; + HEAP32[$0 + 14560 >> 2] = $1; + $2 = HEAP32[$0 + 14564 >> 2]; + $1 = HEAP32[$0 + 14560 >> 2]; + HEAP32[$0 + 32 >> 2] = $1; + HEAP32[$0 + 36 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2WheelJoint____29_28float_29___invoke_b2WheelJoint__28char_20const__2c_20void_20_28b2WheelJoint____29_28float_29_29($4, $0 + 32 | 0); + HEAP32[$0 + 2020 >> 2] = 0; + HEAP32[$0 + 2016 >> 2] = 394; + $1 = HEAP32[$0 + 2020 >> 2]; + $2 = HEAP32[$0 + 2016 >> 2]; + HEAP32[$0 + 14328 >> 2] = $2; + HEAP32[$0 + 14332 >> 2] = $1; + $1 = HEAP32[$0 + 14328 >> 2]; + $2 = HEAP32[$0 + 14332 >> 2]; + HEAP32[$0 + 14356 >> 2] = $3; + HEAP32[$0 + 14352 >> 2] = 3410; + HEAP32[$0 + 14348 >> 2] = $2; + HEAP32[$0 + 14344 >> 2] = $1; + $3 = HEAP32[$0 + 14356 >> 2]; + $4 = HEAP32[$0 + 14352 >> 2]; + $1 = HEAP32[$0 + 14344 >> 2]; + HEAP32[$0 + 14340 >> 2] = HEAP32[$0 + 14348 >> 2]; + HEAP32[$0 + 14336 >> 2] = $1; + $2 = HEAP32[$0 + 14340 >> 2]; + $1 = HEAP32[$0 + 14336 >> 2]; + HEAP32[$0 + 24 >> 2] = $1; + HEAP32[$0 + 28 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2WheelJoint____29_28_29_20const___invoke_b2WheelJoint__28char_20const__2c_20float_20_28b2WheelJoint____29_28_29_20const_29($4, $0 + 24 | 0); + HEAP32[$0 + 2012 >> 2] = 0; + HEAP32[$0 + 2008 >> 2] = 395; + $1 = HEAP32[$0 + 2012 >> 2]; + $2 = HEAP32[$0 + 2008 >> 2]; + HEAP32[$0 + 14520 >> 2] = $2; + HEAP32[$0 + 14524 >> 2] = $1; + $1 = HEAP32[$0 + 14520 >> 2]; + $2 = HEAP32[$0 + 14524 >> 2]; + HEAP32[$0 + 14548 >> 2] = $3; + HEAP32[$0 + 14544 >> 2] = 7702; + HEAP32[$0 + 14540 >> 2] = $2; + HEAP32[$0 + 14536 >> 2] = $1; + $3 = HEAP32[$0 + 14548 >> 2]; + $4 = HEAP32[$0 + 14544 >> 2]; + $1 = HEAP32[$0 + 14536 >> 2]; + HEAP32[$0 + 14532 >> 2] = HEAP32[$0 + 14540 >> 2]; + HEAP32[$0 + 14528 >> 2] = $1; + $2 = HEAP32[$0 + 14532 >> 2]; + $1 = HEAP32[$0 + 14528 >> 2]; + HEAP32[$0 + 16 >> 2] = $1; + HEAP32[$0 + 20 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2WheelJoint____29_28float_29___invoke_b2WheelJoint__28char_20const__2c_20void_20_28b2WheelJoint____29_28float_29_29($4, $0 + 16 | 0); + HEAP32[$0 + 2004 >> 2] = 0; + HEAP32[$0 + 2e3 >> 2] = 396; + $1 = HEAP32[$0 + 2004 >> 2]; + $2 = HEAP32[$0 + 2e3 >> 2]; + HEAP32[$0 + 14296 >> 2] = $2; + HEAP32[$0 + 14300 >> 2] = $1; + $1 = HEAP32[$0 + 14296 >> 2]; + $2 = HEAP32[$0 + 14300 >> 2]; + HEAP32[$0 + 14324 >> 2] = $3; + HEAP32[$0 + 14320 >> 2] = 7713; + HEAP32[$0 + 14316 >> 2] = $2; + HEAP32[$0 + 14312 >> 2] = $1; + $3 = HEAP32[$0 + 14324 >> 2]; + $4 = HEAP32[$0 + 14320 >> 2]; + $1 = HEAP32[$0 + 14312 >> 2]; + HEAP32[$0 + 14308 >> 2] = HEAP32[$0 + 14316 >> 2]; + HEAP32[$0 + 14304 >> 2] = $1; + $2 = HEAP32[$0 + 14308 >> 2]; + $1 = HEAP32[$0 + 14304 >> 2]; + HEAP32[$0 + 8 >> 2] = $1; + HEAP32[$0 + 12 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_float_20_28b2WheelJoint____29_28_29_20const___invoke_b2WheelJoint__28char_20const__2c_20float_20_28b2WheelJoint____29_28_29_20const_29($4, $0 + 8 | 0); + HEAP32[$0 + 1996 >> 2] = 1; + HEAP32[$0 + 1992 >> 2] = 16; + $1 = HEAP32[$0 + 1996 >> 2]; + $2 = HEAP32[$0 + 1992 >> 2]; + HEAP32[$0 + 14680 >> 2] = $2; + HEAP32[$0 + 14684 >> 2] = $1; + $1 = HEAP32[$0 + 14680 >> 2]; + $2 = HEAP32[$0 + 14684 >> 2]; + HEAP32[$0 + 14708 >> 2] = $3; + HEAP32[$0 + 14704 >> 2] = 6232; + HEAP32[$0 + 14700 >> 2] = $2; + HEAP32[$0 + 14696 >> 2] = $1; + $3 = HEAP32[$0 + 14704 >> 2]; + $1 = HEAP32[$0 + 14696 >> 2]; + HEAP32[$0 + 14692 >> 2] = HEAP32[$0 + 14700 >> 2]; + HEAP32[$0 + 14688 >> 2] = $1; + $2 = HEAP32[$0 + 14692 >> 2]; + $1 = HEAP32[$0 + 14688 >> 2]; + HEAP32[$0 + 1984 >> 2] = $1; + HEAP32[$0 + 1988 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28b2WheelJoint____29_28_29___invoke_b2WheelJoint__28char_20const__2c_20void_20_28b2WheelJoint____29_28_29_29($3, $0 + 1984 | 0); + __stack_pointer = $0 + 16352 | 0; +} + +function dlmalloc($0) { + $0 = $0 | 0; + var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $11 = __stack_pointer - 16 | 0; + __stack_pointer = $11; + label$1: { + label$2: { + label$3: { + label$4: { + label$5: { + label$6: { + label$7: { + label$8: { + label$9: { + label$10: { + label$11: { + label$12: { + label$13: { + label$14: { + if ($0 >>> 0 <= 244) { + $6 = HEAP32[8063]; + $5 = $0 >>> 0 < 11 ? 16 : $0 + 11 & -8; + $1 = $5 >>> 3 | 0; + $0 = $6 >>> $1 | 0; + if ($0 & 3) { + $2 = (($0 ^ -1) & 1) + $1 | 0; + $1 = $2 << 3; + $0 = $1 + 32292 | 0; + $1 = HEAP32[$1 + 32300 >> 2]; + $5 = HEAP32[$1 + 8 >> 2]; + label$17: { + if (($0 | 0) == ($5 | 0)) { + wasm2js_i32$0 = 32252, wasm2js_i32$1 = __wasm_rotl_i32(-2, $2) & $6, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + break label$17; + } + HEAP32[$5 + 12 >> 2] = $0; + HEAP32[$0 + 8 >> 2] = $5; + } + $0 = $1 + 8 | 0; + $2 = $2 << 3; + HEAP32[$1 + 4 >> 2] = $2 | 3; + $1 = $1 + $2 | 0; + HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] | 1; + break label$1; + } + $8 = HEAP32[8065]; + if ($8 >>> 0 >= $5 >>> 0) { + break label$14; + } + if ($0) { + $2 = $0 << $1; + $0 = 2 << $1; + $0 = $2 & ($0 | 0 - $0); + $1 = __wasm_ctz_i32($0 & 0 - $0); + $0 = $1 << 3; + $2 = $0 + 32292 | 0; + $0 = HEAP32[$0 + 32300 >> 2]; + $3 = HEAP32[$0 + 8 >> 2]; + label$20: { + if (($2 | 0) == ($3 | 0)) { + $6 = __wasm_rotl_i32(-2, $1) & $6; + HEAP32[8063] = $6; + break label$20; + } + HEAP32[$3 + 12 >> 2] = $2; + HEAP32[$2 + 8 >> 2] = $3; + } + HEAP32[$0 + 4 >> 2] = $5 | 3; + $3 = $0 + $5 | 0; + $1 = $1 << 3; + $2 = $1 - $5 | 0; + HEAP32[$3 + 4 >> 2] = $2 | 1; + HEAP32[$0 + $1 >> 2] = $2; + if ($8) { + $5 = ($8 & -8) + 32292 | 0; + $1 = HEAP32[8068]; + $4 = 1 << ($8 >>> 3); + label$23: { + if (!($6 & $4)) { + HEAP32[8063] = $4 | $6; + $4 = $5; + break label$23; + } + $4 = HEAP32[$5 + 8 >> 2]; + } + HEAP32[$5 + 8 >> 2] = $1; + HEAP32[$4 + 12 >> 2] = $1; + HEAP32[$1 + 12 >> 2] = $5; + HEAP32[$1 + 8 >> 2] = $4; + } + $0 = $0 + 8 | 0; + HEAP32[8068] = $3; + HEAP32[8065] = $2; + break label$1; + } + $9 = HEAP32[8064]; + if (!$9) { + break label$14; + } + $3 = HEAP32[(__wasm_ctz_i32(0 - $9 & $9) << 2) + 32556 >> 2]; + $1 = (HEAP32[$3 + 4 >> 2] & -8) - $5 | 0; + $2 = $3; + while (1) { + label$26: { + $0 = HEAP32[$2 + 16 >> 2]; + if (!$0) { + $0 = HEAP32[$2 + 20 >> 2]; + if (!$0) { + break label$26; + } + } + $2 = (HEAP32[$0 + 4 >> 2] & -8) - $5 | 0; + $4 = $2; + $2 = $1 >>> 0 > $2 >>> 0; + $1 = $2 ? $4 : $1; + $3 = $2 ? $0 : $3; + $2 = $0; + continue; + } + break; + } + $10 = HEAP32[$3 + 24 >> 2]; + $4 = HEAP32[$3 + 12 >> 2]; + if (($4 | 0) != ($3 | 0)) { + $0 = HEAP32[$3 + 8 >> 2]; + HEAP32[$0 + 12 >> 2] = $4; + HEAP32[$4 + 8 >> 2] = $0; + break label$2; + } + $2 = $3 + 20 | 0; + $0 = HEAP32[$2 >> 2]; + if (!$0) { + $0 = HEAP32[$3 + 16 >> 2]; + if (!$0) { + break label$13; + } + $2 = $3 + 16 | 0; + } + while (1) { + $7 = $2; + $4 = $0; + $2 = $0 + 20 | 0; + $0 = HEAP32[$2 >> 2]; + if ($0) { + continue; + } + $2 = $4 + 16 | 0; + $0 = HEAP32[$4 + 16 >> 2]; + if ($0) { + continue; + } + break; + } + HEAP32[$7 >> 2] = 0; + break label$2; + } + $5 = -1; + if ($0 >>> 0 > 4294967231) { + break label$14; + } + $0 = $0 + 11 | 0; + $5 = $0 & -8; + $8 = HEAP32[8064]; + if (!$8) { + break label$14; + } + $1 = 0 - $5 | 0; + $7 = 0; + label$34: { + if ($5 >>> 0 < 256) { + break label$34; + } + $7 = 31; + if ($5 >>> 0 > 16777215) { + break label$34; + } + $0 = Math_clz32($0 >>> 8 | 0); + $7 = (($5 >>> 38 - $0 & 1) - ($0 << 1) | 0) + 62 | 0; + } + $2 = HEAP32[($7 << 2) + 32556 >> 2]; + label$31: { + label$32: { + label$33: { + if (!$2) { + $0 = 0; + break label$33; + } + $0 = 0; + $3 = $5 << (($7 | 0) != 31 ? 25 - ($7 >>> 1 | 0) | 0 : 0); + while (1) { + label$37: { + $6 = (HEAP32[$2 + 4 >> 2] & -8) - $5 | 0; + if ($6 >>> 0 >= $1 >>> 0) { + break label$37; + } + $4 = $2; + $1 = $6; + if ($1) { + break label$37; + } + $1 = 0; + $0 = $2; + break label$32; + } + $6 = HEAP32[$2 + 20 >> 2]; + $2 = HEAP32[(($3 >>> 29 & 4) + $2 | 0) + 16 >> 2]; + $0 = $6 ? ($6 | 0) == ($2 | 0) ? $0 : $6 : $0; + $3 = $3 << 1; + if ($2) { + continue; + } + break; + } + } + if (!($0 | $4)) { + $4 = 0; + $0 = 2 << $7; + $0 = ($0 | 0 - $0) & $8; + if (!$0) { + break label$14; + } + $0 = HEAP32[(__wasm_ctz_i32(0 - $0 & $0) << 2) + 32556 >> 2]; + } + if (!$0) { + break label$31; + } + } + while (1) { + $6 = (HEAP32[$0 + 4 >> 2] & -8) - $5 | 0; + $3 = $6 >>> 0 < $1 >>> 0; + $1 = $3 ? $6 : $1; + $4 = $3 ? $0 : $4; + $2 = HEAP32[$0 + 16 >> 2]; + if (!$2) { + $2 = HEAP32[$0 + 20 >> 2]; + } + $0 = $2; + if ($0) { + continue; + } + break; + } + } + if (!$4 | HEAP32[8065] - $5 >>> 0 <= $1 >>> 0) { + break label$14; + } + $7 = HEAP32[$4 + 24 >> 2]; + $3 = HEAP32[$4 + 12 >> 2]; + if (($4 | 0) != ($3 | 0)) { + $0 = HEAP32[$4 + 8 >> 2]; + HEAP32[$0 + 12 >> 2] = $3; + HEAP32[$3 + 8 >> 2] = $0; + break label$3; + } + $2 = $4 + 20 | 0; + $0 = HEAP32[$2 >> 2]; + if (!$0) { + $0 = HEAP32[$4 + 16 >> 2]; + if (!$0) { + break label$12; + } + $2 = $4 + 16 | 0; + } + while (1) { + $6 = $2; + $3 = $0; + $2 = $0 + 20 | 0; + $0 = HEAP32[$2 >> 2]; + if ($0) { + continue; + } + $2 = $3 + 16 | 0; + $0 = HEAP32[$3 + 16 >> 2]; + if ($0) { + continue; + } + break; + } + HEAP32[$6 >> 2] = 0; + break label$3; + } + $0 = HEAP32[8065]; + if ($5 >>> 0 <= $0 >>> 0) { + $1 = HEAP32[8068]; + $2 = $0 - $5 | 0; + label$45: { + if ($2 >>> 0 >= 16) { + $3 = $1 + $5 | 0; + HEAP32[$3 + 4 >> 2] = $2 | 1; + HEAP32[$0 + $1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $5 | 3; + break label$45; + } + HEAP32[$1 + 4 >> 2] = $0 | 3; + $0 = $0 + $1 | 0; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] | 1; + $3 = 0; + $2 = 0; + } + HEAP32[8065] = $2; + HEAP32[8068] = $3; + $0 = $1 + 8 | 0; + break label$1; + } + $3 = HEAP32[8066]; + if ($5 >>> 0 < $3 >>> 0) { + $1 = $3 - $5 | 0; + HEAP32[8066] = $1; + $0 = HEAP32[8069]; + $2 = $5 + $0 | 0; + HEAP32[8069] = $2; + HEAP32[$2 + 4 >> 2] = $1 | 1; + HEAP32[$0 + 4 >> 2] = $5 | 3; + $0 = $0 + 8 | 0; + break label$1; + } + $0 = 0; + $8 = $5 + 47 | 0; + if (HEAP32[8181]) { + $1 = HEAP32[8183]; + } else { + HEAP32[8184] = -1; + HEAP32[8185] = -1; + HEAP32[8182] = 4096; + HEAP32[8183] = 4096; + HEAP32[8181] = $11 + 12 & -16 ^ 1431655768; + HEAP32[8186] = 0; + HEAP32[8174] = 0; + $1 = 4096; + } + $6 = $8 + $1 | 0; + $7 = 0 - $1 | 0; + $4 = $6 & $7; + if ($5 >>> 0 >= $4 >>> 0) { + break label$1; + } + $1 = HEAP32[8173]; + if ($1) { + $2 = HEAP32[8171]; + $9 = $4 + $2 | 0; + if ($1 >>> 0 < $9 >>> 0 | $2 >>> 0 >= $9 >>> 0) { + break label$1; + } + } + label$51: { + if (!(HEAPU8[32696] & 4)) { + label$53: { + label$54: { + label$55: { + label$56: { + $1 = HEAP32[8069]; + if ($1) { + $0 = 32700; + while (1) { + $2 = HEAP32[$0 >> 2]; + if ($2 >>> 0 <= $1 >>> 0 & HEAP32[$0 + 4 >> 2] + $2 >>> 0 > $1 >>> 0) { + break label$56; + } + $0 = HEAP32[$0 + 8 >> 2]; + if ($0) { + continue; + } + break; + } + } + $3 = sbrk(0); + if (($3 | 0) == -1) { + break label$53; + } + $6 = $4; + $0 = HEAP32[8182]; + $1 = $0 - 1 | 0; + if ($3 & $1) { + $6 = ($4 - $3 | 0) + ($1 + $3 & 0 - $0) | 0; + } + if ($5 >>> 0 >= $6 >>> 0) { + break label$53; + } + $0 = HEAP32[8173]; + if ($0) { + $1 = HEAP32[8171]; + $2 = $6 + $1 | 0; + if ($0 >>> 0 < $2 >>> 0 | $1 >>> 0 >= $2 >>> 0) { + break label$53; + } + } + $0 = sbrk($6); + if (($3 | 0) != ($0 | 0)) { + break label$55; + } + break label$51; + } + $6 = $6 - $3 & $7; + $3 = sbrk($6); + if (($3 | 0) == (HEAP32[$0 >> 2] + HEAP32[$0 + 4 >> 2] | 0)) { + break label$54; + } + $0 = $3; + } + if (($0 | 0) == -1) { + break label$53; + } + if ($5 + 48 >>> 0 <= $6 >>> 0) { + $3 = $0; + break label$51; + } + $1 = HEAP32[8183]; + $1 = $1 + ($8 - $6 | 0) & 0 - $1; + if ((sbrk($1) | 0) == -1) { + break label$53; + } + $6 = $1 + $6 | 0; + $3 = $0; + break label$51; + } + if (($3 | 0) != -1) { + break label$51; + } + } + HEAP32[8174] = HEAP32[8174] | 4; + } + $3 = sbrk($4); + $0 = sbrk(0); + if (($3 | 0) == -1 | ($0 | 0) == -1 | $0 >>> 0 <= $3 >>> 0) { + break label$9; + } + $6 = $0 - $3 | 0; + if ($6 >>> 0 <= $5 + 40 >>> 0) { + break label$9; + } + } + $0 = HEAP32[8171] + $6 | 0; + HEAP32[8171] = $0; + if (HEAPU32[8172] < $0 >>> 0) { + HEAP32[8172] = $0; + } + label$64: { + $1 = HEAP32[8069]; + if ($1) { + $0 = 32700; + while (1) { + $2 = HEAP32[$0 >> 2]; + $4 = HEAP32[$0 + 4 >> 2]; + if (($2 + $4 | 0) == ($3 | 0)) { + break label$64; + } + $0 = HEAP32[$0 + 8 >> 2]; + if ($0) { + continue; + } + break; + } + break label$11; + } + $0 = HEAP32[8067]; + if (!($0 >>> 0 <= $3 >>> 0 ? $0 : 0)) { + HEAP32[8067] = $3; + } + $0 = 0; + HEAP32[8176] = $6; + HEAP32[8175] = $3; + HEAP32[8071] = -1; + HEAP32[8072] = HEAP32[8181]; + HEAP32[8178] = 0; + while (1) { + $1 = $0 << 3; + $2 = $1 + 32292 | 0; + HEAP32[$1 + 32300 >> 2] = $2; + HEAP32[$1 + 32304 >> 2] = $2; + $0 = $0 + 1 | 0; + if (($0 | 0) != 32) { + continue; + } + break; + } + $0 = $6 - 40 | 0; + $1 = $3 + 8 & 7 ? -8 - $3 & 7 : 0; + $2 = $0 - $1 | 0; + HEAP32[8066] = $2; + $1 = $1 + $3 | 0; + HEAP32[8069] = $1; + HEAP32[$1 + 4 >> 2] = $2 | 1; + HEAP32[($0 + $3 | 0) + 4 >> 2] = 40; + HEAP32[8070] = HEAP32[8185]; + break label$10; + } + if (HEAP32[$0 + 12 >> 2] & 8 | ($1 >>> 0 < $2 >>> 0 | $1 >>> 0 >= $3 >>> 0)) { + break label$11; + } + HEAP32[$0 + 4 >> 2] = $4 + $6; + $0 = $1 + 8 & 7 ? -8 - $1 & 7 : 0; + $2 = $1 + $0 | 0; + HEAP32[8069] = $2; + $3 = HEAP32[8066] + $6 | 0; + $0 = $3 - $0 | 0; + HEAP32[8066] = $0; + HEAP32[$2 + 4 >> 2] = $0 | 1; + HEAP32[($1 + $3 | 0) + 4 >> 2] = 40; + HEAP32[8070] = HEAP32[8185]; + break label$10; + } + $4 = 0; + break label$2; + } + $3 = 0; + break label$3; + } + $4 = HEAP32[8067]; + if ($4 >>> 0 > $3 >>> 0) { + HEAP32[8067] = $3; + } + $2 = $3 + $6 | 0; + $0 = 32700; + label$70: { + label$71: { + label$72: { + while (1) { + if (HEAP32[$0 >> 2] != ($2 | 0)) { + $0 = HEAP32[$0 + 8 >> 2]; + if ($0) { + continue; + } + break label$72; + } + break; + } + if (!(HEAPU8[$0 + 12 | 0] & 8)) { + break label$71; + } + } + $0 = 32700; + while (1) { + $2 = HEAP32[$0 >> 2]; + if ($2 >>> 0 <= $1 >>> 0) { + $2 = HEAP32[$0 + 4 >> 2] + $2 | 0; + if ($2 >>> 0 > $1 >>> 0) { + break label$70; + } + } + $0 = HEAP32[$0 + 8 >> 2]; + continue; + } + } + HEAP32[$0 >> 2] = $3; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] + $6; + $7 = ($3 + 8 & 7 ? -8 - $3 & 7 : 0) + $3 | 0; + HEAP32[$7 + 4 >> 2] = $5 | 3; + $6 = ($2 + 8 & 7 ? -8 - $2 & 7 : 0) + $2 | 0; + $5 = $5 + $7 | 0; + $0 = $6 - $5 | 0; + if (($1 | 0) == ($6 | 0)) { + HEAP32[8069] = $5; + $0 = HEAP32[8066] + $0 | 0; + HEAP32[8066] = $0; + HEAP32[$5 + 4 >> 2] = $0 | 1; + break label$4; + } + if (HEAP32[8068] == ($6 | 0)) { + HEAP32[8068] = $5; + $0 = HEAP32[8065] + $0 | 0; + HEAP32[8065] = $0; + HEAP32[$5 + 4 >> 2] = $0 | 1; + HEAP32[$0 + $5 >> 2] = $0; + break label$4; + } + $1 = HEAP32[$6 + 4 >> 2]; + if (($1 & 3) != 1) { + break label$5; + } + $8 = $1 & -8; + if ($1 >>> 0 <= 255) { + $4 = $1 >>> 3 | 0; + $1 = HEAP32[$6 + 12 >> 2]; + $2 = HEAP32[$6 + 8 >> 2]; + if (($1 | 0) == ($2 | 0)) { + wasm2js_i32$0 = 32252, wasm2js_i32$1 = HEAP32[8063] & __wasm_rotl_i32(-2, $4), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + break label$6; + } + HEAP32[$2 + 12 >> 2] = $1; + HEAP32[$1 + 8 >> 2] = $2; + break label$6; + } + $9 = HEAP32[$6 + 24 >> 2]; + $3 = HEAP32[$6 + 12 >> 2]; + if (($6 | 0) != ($3 | 0)) { + $1 = HEAP32[$6 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $3; + HEAP32[$3 + 8 >> 2] = $1; + break label$7; + } + $2 = $6 + 20 | 0; + $1 = HEAP32[$2 >> 2]; + if (!$1) { + $1 = HEAP32[$6 + 16 >> 2]; + if (!$1) { + break label$8; + } + $2 = $6 + 16 | 0; + } + while (1) { + $4 = $2; + $3 = $1; + $2 = $1 + 20 | 0; + $1 = HEAP32[$2 >> 2]; + if ($1) { + continue; + } + $2 = $3 + 16 | 0; + $1 = HEAP32[$3 + 16 >> 2]; + if ($1) { + continue; + } + break; + } + HEAP32[$4 >> 2] = 0; + break label$7; + } + $0 = $6 - 40 | 0; + $4 = $3 + 8 & 7 ? -8 - $3 & 7 : 0; + $7 = $0 - $4 | 0; + HEAP32[8066] = $7; + $4 = $3 + $4 | 0; + HEAP32[8069] = $4; + HEAP32[$4 + 4 >> 2] = $7 | 1; + HEAP32[($0 + $3 | 0) + 4 >> 2] = 40; + HEAP32[8070] = HEAP32[8185]; + $0 = (($2 - 39 & 7 ? 39 - $2 & 7 : 0) + $2 | 0) - 47 | 0; + $4 = $1 + 16 >>> 0 > $0 >>> 0 ? $1 : $0; + HEAP32[$4 + 4 >> 2] = 27; + $0 = HEAP32[8178]; + $7 = HEAP32[8177]; + HEAP32[$4 + 16 >> 2] = $7; + HEAP32[$4 + 20 >> 2] = $0; + $7 = HEAP32[8176]; + $0 = HEAP32[8175]; + HEAP32[$4 + 8 >> 2] = $0; + HEAP32[$4 + 12 >> 2] = $7; + HEAP32[8177] = $4 + 8; + HEAP32[8176] = $6; + HEAP32[8175] = $3; + HEAP32[8178] = 0; + $0 = $4 + 24 | 0; + while (1) { + HEAP32[$0 + 4 >> 2] = 7; + $3 = $0 + 8 | 0; + $0 = $0 + 4 | 0; + if ($3 >>> 0 < $2 >>> 0) { + continue; + } + break; + } + if (($1 | 0) == ($4 | 0)) { + break label$10; + } + HEAP32[$4 + 4 >> 2] = HEAP32[$4 + 4 >> 2] & -2; + $3 = $4 - $1 | 0; + HEAP32[$1 + 4 >> 2] = $3 | 1; + HEAP32[$4 >> 2] = $3; + if ($3 >>> 0 <= 255) { + $0 = ($3 & -8) + 32292 | 0; + $3 = 1 << ($3 >>> 3); + $2 = HEAP32[8063]; + label$86: { + if (!($3 & $2)) { + HEAP32[8063] = $3 | $2; + $2 = $0; + break label$86; + } + $2 = HEAP32[$0 + 8 >> 2]; + } + HEAP32[$0 + 8 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = $1; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$1 + 8 >> 2] = $2; + break label$10; + } + $0 = 31; + if ($3 >>> 0 <= 16777215) { + $0 = Math_clz32($3 >>> 8 | 0); + $0 = (($3 >>> 38 - $0 & 1) - ($0 << 1) | 0) + 62 | 0; + } + HEAP32[$1 + 28 >> 2] = $0; + HEAP32[$1 + 16 >> 2] = 0; + HEAP32[$1 + 20 >> 2] = 0; + $2 = ($0 << 2) + 32556 | 0; + label$89: { + $4 = HEAP32[8064]; + $6 = 1 << $0; + label$90: { + if (!($4 & $6)) { + HEAP32[8064] = $4 | $6; + HEAP32[$2 >> 2] = $1; + break label$90; + } + $0 = $3 << (($0 | 0) != 31 ? 25 - ($0 >>> 1 | 0) | 0 : 0); + $4 = HEAP32[$2 >> 2]; + while (1) { + $2 = $4; + if ((HEAP32[$2 + 4 >> 2] & -8) == ($3 | 0)) { + break label$89; + } + $4 = $0 >>> 29 | 0; + $0 = $0 << 1; + $7 = ($4 & 4) + $2 | 0; + $6 = $7 + 16 | 0; + $4 = HEAP32[$6 >> 2]; + if ($4) { + continue; + } + break; + } + HEAP32[$7 + 16 >> 2] = $1; + } + HEAP32[$1 + 24 >> 2] = $2; + HEAP32[$1 + 12 >> 2] = $1; + HEAP32[$1 + 8 >> 2] = $1; + break label$10; + } + $0 = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 12 >> 2] = $1; + HEAP32[$2 + 8 >> 2] = $1; + HEAP32[$1 + 24 >> 2] = 0; + HEAP32[$1 + 12 >> 2] = $2; + HEAP32[$1 + 8 >> 2] = $0; + } + $0 = HEAP32[8066]; + if ($5 >>> 0 >= $0 >>> 0) { + break label$9; + } + $1 = $0 - $5 | 0; + HEAP32[8066] = $1; + $0 = HEAP32[8069]; + $2 = $5 + $0 | 0; + HEAP32[8069] = $2; + HEAP32[$2 + 4 >> 2] = $1 | 1; + HEAP32[$0 + 4 >> 2] = $5 | 3; + $0 = $0 + 8 | 0; + break label$1; + } + wasm2js_i32$0 = __errno_location(), wasm2js_i32$1 = 48, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + $0 = 0; + break label$1; + } + $3 = 0; + } + if (!$9) { + break label$6; + } + $2 = HEAP32[$6 + 28 >> 2]; + $1 = ($2 << 2) + 32556 | 0; + label$93: { + if (HEAP32[$1 >> 2] == ($6 | 0)) { + HEAP32[$1 >> 2] = $3; + if ($3) { + break label$93; + } + wasm2js_i32$0 = 32256, wasm2js_i32$1 = HEAP32[8064] & __wasm_rotl_i32(-2, $2), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + break label$6; + } + HEAP32[(HEAP32[$9 + 16 >> 2] == ($6 | 0) ? 16 : 20) + $9 >> 2] = $3; + if (!$3) { + break label$6; + } + } + HEAP32[$3 + 24 >> 2] = $9; + $1 = HEAP32[$6 + 16 >> 2]; + if ($1) { + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$1 + 24 >> 2] = $3; + } + $1 = HEAP32[$6 + 20 >> 2]; + if (!$1) { + break label$6; + } + HEAP32[$3 + 20 >> 2] = $1; + HEAP32[$1 + 24 >> 2] = $3; + } + $0 = $0 + $8 | 0; + $6 = $6 + $8 | 0; + $1 = HEAP32[$6 + 4 >> 2]; + } + HEAP32[$6 + 4 >> 2] = $1 & -2; + HEAP32[$5 + 4 >> 2] = $0 | 1; + HEAP32[$0 + $5 >> 2] = $0; + if ($0 >>> 0 <= 255) { + $1 = ($0 & -8) + 32292 | 0; + $0 = 1 << ($0 >>> 3); + $2 = HEAP32[8063]; + label$97: { + if (!($0 & $2)) { + HEAP32[8063] = $0 | $2; + $0 = $1; + break label$97; + } + $0 = HEAP32[$1 + 8 >> 2]; + } + HEAP32[$1 + 8 >> 2] = $5; + HEAP32[$0 + 12 >> 2] = $5; + HEAP32[$5 + 12 >> 2] = $1; + HEAP32[$5 + 8 >> 2] = $0; + break label$4; + } + $1 = 31; + if ($0 >>> 0 <= 16777215) { + $1 = Math_clz32($0 >>> 8 | 0); + $1 = (($0 >>> 38 - $1 & 1) - ($1 << 1) | 0) + 62 | 0; + } + HEAP32[$5 + 28 >> 2] = $1; + HEAP32[$5 + 16 >> 2] = 0; + HEAP32[$5 + 20 >> 2] = 0; + $2 = ($1 << 2) + 32556 | 0; + label$100: { + $3 = HEAP32[8064]; + $4 = 1 << $1; + label$101: { + if (!($3 & $4)) { + HEAP32[8064] = $3 | $4; + HEAP32[$2 >> 2] = $5; + break label$101; + } + $1 = $0 << (($1 | 0) != 31 ? 25 - ($1 >>> 1 | 0) | 0 : 0); + $3 = HEAP32[$2 >> 2]; + while (1) { + $2 = $3; + if ((HEAP32[$3 + 4 >> 2] & -8) == ($0 | 0)) { + break label$100; + } + $3 = $1 >>> 29 | 0; + $1 = $1 << 1; + $6 = ($3 & 4) + $2 | 0; + $4 = $6 + 16 | 0; + $3 = HEAP32[$4 >> 2]; + if ($3) { + continue; + } + break; + } + HEAP32[$6 + 16 >> 2] = $5; + } + HEAP32[$5 + 24 >> 2] = $2; + HEAP32[$5 + 12 >> 2] = $5; + HEAP32[$5 + 8 >> 2] = $5; + break label$4; + } + $0 = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 12 >> 2] = $5; + HEAP32[$2 + 8 >> 2] = $5; + HEAP32[$5 + 24 >> 2] = 0; + HEAP32[$5 + 12 >> 2] = $2; + HEAP32[$5 + 8 >> 2] = $0; + } + $0 = $7 + 8 | 0; + break label$1; + } + label$104: { + if (!$7) { + break label$104; + } + $2 = HEAP32[$4 + 28 >> 2]; + $0 = ($2 << 2) + 32556 | 0; + label$105: { + if (HEAP32[$0 >> 2] == ($4 | 0)) { + HEAP32[$0 >> 2] = $3; + if ($3) { + break label$105; + } + $8 = __wasm_rotl_i32(-2, $2) & $8; + HEAP32[8064] = $8; + break label$104; + } + HEAP32[(HEAP32[$7 + 16 >> 2] == ($4 | 0) ? 16 : 20) + $7 >> 2] = $3; + if (!$3) { + break label$104; + } + } + HEAP32[$3 + 24 >> 2] = $7; + $0 = HEAP32[$4 + 16 >> 2]; + if ($0) { + HEAP32[$3 + 16 >> 2] = $0; + HEAP32[$0 + 24 >> 2] = $3; + } + $0 = HEAP32[$4 + 20 >> 2]; + if (!$0) { + break label$104; + } + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$0 + 24 >> 2] = $3; + } + label$108: { + if ($1 >>> 0 <= 15) { + $0 = $1 + $5 | 0; + HEAP32[$4 + 4 >> 2] = $0 | 3; + $0 = $0 + $4 | 0; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] | 1; + break label$108; + } + HEAP32[$4 + 4 >> 2] = $5 | 3; + $3 = $5 + $4 | 0; + HEAP32[$3 + 4 >> 2] = $1 | 1; + HEAP32[$1 + $3 >> 2] = $1; + if ($1 >>> 0 <= 255) { + $0 = ($1 & -8) + 32292 | 0; + $1 = 1 << ($1 >>> 3); + $2 = HEAP32[8063]; + label$111: { + if (!($1 & $2)) { + HEAP32[8063] = $1 | $2; + $1 = $0; + break label$111; + } + $1 = HEAP32[$0 + 8 >> 2]; + } + HEAP32[$0 + 8 >> 2] = $3; + HEAP32[$1 + 12 >> 2] = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + break label$108; + } + $0 = 31; + if ($1 >>> 0 <= 16777215) { + $0 = Math_clz32($1 >>> 8 | 0); + $0 = (($1 >>> 38 - $0 & 1) - ($0 << 1) | 0) + 62 | 0; + } + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = 0; + HEAP32[$3 + 20 >> 2] = 0; + $2 = ($0 << 2) + 32556 | 0; + label$114: { + $5 = 1 << $0; + label$115: { + if (!($8 & $5)) { + HEAP32[8064] = $5 | $8; + HEAP32[$2 >> 2] = $3; + break label$115; + } + $0 = $1 << (($0 | 0) != 31 ? 25 - ($0 >>> 1 | 0) | 0 : 0); + $5 = HEAP32[$2 >> 2]; + while (1) { + $2 = $5; + if ((HEAP32[$2 + 4 >> 2] & -8) == ($1 | 0)) { + break label$114; + } + $5 = $0 >>> 29 | 0; + $0 = $0 << 1; + $7 = ($5 & 4) + $2 | 0; + $6 = $7 + 16 | 0; + $5 = HEAP32[$6 >> 2]; + if ($5) { + continue; + } + break; + } + HEAP32[$7 + 16 >> 2] = $3; + } + HEAP32[$3 + 24 >> 2] = $2; + HEAP32[$3 + 12 >> 2] = $3; + HEAP32[$3 + 8 >> 2] = $3; + break label$108; + } + $0 = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 12 >> 2] = $3; + HEAP32[$2 + 8 >> 2] = $3; + HEAP32[$3 + 24 >> 2] = 0; + HEAP32[$3 + 12 >> 2] = $2; + HEAP32[$3 + 8 >> 2] = $0; + } + $0 = $4 + 8 | 0; + break label$1; + } + label$118: { + if (!$10) { + break label$118; + } + $2 = HEAP32[$3 + 28 >> 2]; + $0 = ($2 << 2) + 32556 | 0; + label$119: { + if (HEAP32[$0 >> 2] == ($3 | 0)) { + HEAP32[$0 >> 2] = $4; + if ($4) { + break label$119; + } + wasm2js_i32$0 = 32256, wasm2js_i32$1 = __wasm_rotl_i32(-2, $2) & $9, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + break label$118; + } + HEAP32[(HEAP32[$10 + 16 >> 2] == ($3 | 0) ? 16 : 20) + $10 >> 2] = $4; + if (!$4) { + break label$118; + } + } + HEAP32[$4 + 24 >> 2] = $10; + $0 = HEAP32[$3 + 16 >> 2]; + if ($0) { + HEAP32[$4 + 16 >> 2] = $0; + HEAP32[$0 + 24 >> 2] = $4; + } + $0 = HEAP32[$3 + 20 >> 2]; + if (!$0) { + break label$118; + } + HEAP32[$4 + 20 >> 2] = $0; + HEAP32[$0 + 24 >> 2] = $4; + } + label$122: { + if ($1 >>> 0 <= 15) { + $0 = $1 + $5 | 0; + HEAP32[$3 + 4 >> 2] = $0 | 3; + $0 = $0 + $3 | 0; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] | 1; + break label$122; + } + HEAP32[$3 + 4 >> 2] = $5 | 3; + $2 = $3 + $5 | 0; + HEAP32[$2 + 4 >> 2] = $1 | 1; + HEAP32[$1 + $2 >> 2] = $1; + if ($8) { + $5 = ($8 & -8) + 32292 | 0; + $0 = HEAP32[8068]; + $4 = 1 << ($8 >>> 3); + label$125: { + if (!($6 & $4)) { + HEAP32[8063] = $4 | $6; + $4 = $5; + break label$125; + } + $4 = HEAP32[$5 + 8 >> 2]; + } + HEAP32[$5 + 8 >> 2] = $0; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$0 + 12 >> 2] = $5; + HEAP32[$0 + 8 >> 2] = $4; + } + HEAP32[8068] = $2; + HEAP32[8065] = $1; + } + $0 = $3 + 8 | 0; + } + __stack_pointer = $11 + 16 | 0; + return $0 | 0; +} + +function printf_core($0, $1, $2, $3, $4, $5, $6) { + var $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $8 = __stack_pointer - 80 | 0; + __stack_pointer = $8; + HEAP32[$8 + 76 >> 2] = $1; + $25 = $8 + 55 | 0; + $21 = $8 + 56 | 0; + label$1: { + label$2: { + label$3: { + label$4: { + label$5: while (1) { + $15 = $1; + if (($16 ^ 2147483647) < ($7 | 0)) { + break label$4; + } + $16 = $7 + $16 | 0; + label$6: { + label$8: { + label$9: { + $7 = $15; + $12 = HEAPU8[$7 | 0]; + if ($12) { + while (1) { + label$12: { + $12 = $12 & 255; + label$13: { + if (!$12) { + $1 = $7; + break label$13; + } + if (($12 | 0) != 37) { + break label$12; + } + $12 = $7; + while (1) { + if (HEAPU8[$12 + 1 | 0] != 37) { + $1 = $12; + break label$13; + } + $7 = $7 + 1 | 0; + $9 = HEAPU8[$12 + 2 | 0]; + $1 = $12 + 2 | 0; + $12 = $1; + if (($9 | 0) == 37) { + continue; + } + break; + } + } + $7 = $7 - $15 | 0; + $12 = $16 ^ 2147483647; + if (($7 | 0) > ($12 | 0)) { + break label$4; + } + if ($0) { + out($0, $15, $7); + } + if ($7) { + continue label$5; + } + HEAP32[$8 + 76 >> 2] = $1; + $7 = $1 + 1 | 0; + $19 = -1; + if (!(!isdigit(HEAP8[$1 + 1 | 0]) | HEAPU8[$1 + 2 | 0] != 36)) { + $19 = HEAP8[$1 + 1 | 0] - 48 | 0; + $22 = 1; + $7 = $1 + 3 | 0; + } + HEAP32[$8 + 76 >> 2] = $7; + $14 = 0; + $13 = HEAP8[$7 | 0]; + $1 = $13 - 32 | 0; + label$19: { + if ($1 >>> 0 > 31) { + $9 = $7; + break label$19; + } + $9 = $7; + $1 = 1 << $1; + if (!($1 & 75913)) { + break label$19; + } + while (1) { + $9 = $7 + 1 | 0; + HEAP32[$8 + 76 >> 2] = $9; + $14 = $1 | $14; + $13 = HEAP8[$7 + 1 | 0]; + $1 = $13 - 32 | 0; + if ($1 >>> 0 >= 32) { + break label$19; + } + $7 = $9; + $1 = 1 << $1; + if ($1 & 75913) { + continue; + } + break; + } + } + label$22: { + if (($13 | 0) == 42) { + label$24: { + if (!(!isdigit(HEAP8[$9 + 1 | 0]) | HEAPU8[$9 + 2 | 0] != 36)) { + HEAP32[((HEAP8[$9 + 1 | 0] << 2) + $4 | 0) - 192 >> 2] = 10; + $13 = $9 + 3 | 0; + $18 = HEAP32[((HEAP8[$9 + 1 | 0] << 3) + $3 | 0) - 384 >> 2]; + $22 = 1; + break label$24; + } + if ($22) { + break label$9; + } + $13 = $9 + 1 | 0; + if (!$0) { + HEAP32[$8 + 76 >> 2] = $13; + $22 = 0; + $18 = 0; + break label$22; + } + $7 = HEAP32[$2 >> 2]; + HEAP32[$2 >> 2] = $7 + 4; + $18 = HEAP32[$7 >> 2]; + $22 = 0; + } + HEAP32[$8 + 76 >> 2] = $13; + if (($18 | 0) >= 0) { + break label$22; + } + $18 = 0 - $18 | 0; + $14 = $14 | 8192; + break label$22; + } + $18 = getint($8 + 76 | 0); + if (($18 | 0) < 0) { + break label$4; + } + $13 = HEAP32[$8 + 76 >> 2]; + } + $7 = 0; + $11 = -1; + label$27: { + if (HEAPU8[$13 | 0] != 46) { + $1 = $13; + $10 = 0; + break label$27; + } + if (HEAPU8[$13 + 1 | 0] == 42) { + label$30: { + if (!(!isdigit(HEAP8[$13 + 2 | 0]) | HEAPU8[$13 + 3 | 0] != 36)) { + HEAP32[((HEAP8[$13 + 2 | 0] << 2) + $4 | 0) - 192 >> 2] = 10; + $1 = $13 + 4 | 0; + $11 = HEAP32[((HEAP8[$13 + 2 | 0] << 3) + $3 | 0) - 384 >> 2]; + break label$30; + } + if ($22) { + break label$9; + } + $1 = $13 + 2 | 0; + $11 = 0; + if (!$0) { + break label$30; + } + $9 = HEAP32[$2 >> 2]; + HEAP32[$2 >> 2] = $9 + 4; + $11 = HEAP32[$9 >> 2]; + } + HEAP32[$8 + 76 >> 2] = $1; + $10 = ($11 ^ -1) >>> 31 | 0; + break label$27; + } + HEAP32[$8 + 76 >> 2] = $13 + 1; + $11 = getint($8 + 76 | 0); + $1 = HEAP32[$8 + 76 >> 2]; + $10 = 1; + } + $23 = $10; + while (1) { + $9 = $7; + $20 = 28; + $13 = $1; + $7 = HEAP8[$13 | 0]; + if ($7 - 123 >>> 0 < 4294967238) { + break label$3; + } + $1 = $13 + 1 | 0; + $7 = HEAPU8[(Math_imul($9, 58) + $7 | 0) + 23343 | 0]; + if ($7 - 1 >>> 0 < 8) { + continue; + } + break; + } + HEAP32[$8 + 76 >> 2] = $1; + label$33: { + label$34: { + if (($7 | 0) != 27) { + if (!$7) { + break label$3; + } + if (($19 | 0) >= 0) { + HEAP32[($19 << 2) + $4 >> 2] = $7; + $10 = ($19 << 3) + $3 | 0; + $17 = HEAP32[$10 >> 2]; + $10 = HEAP32[$10 + 4 >> 2]; + HEAP32[$8 + 64 >> 2] = $17; + HEAP32[$8 + 68 >> 2] = $10; + break label$34; + } + if (!$0) { + break label$6; + } + pop_arg($8 - -64 | 0, $7, $2, $6); + break label$33; + } + if (($19 | 0) >= 0) { + break label$3; + } + } + $7 = 0; + if (!$0) { + continue label$5; + } + } + $10 = $14 & -65537; + $14 = $14 & 8192 ? $10 : $14; + $19 = 0; + $24 = 1765; + $20 = $21; + label$37: { + label$38: { + label$39: { + label$40: { + label$41: { + label$42: { + label$43: { + label$44: { + label$45: { + label$46: { + label$47: { + label$48: { + label$49: { + label$50: { + label$51: { + label$52: { + $7 = HEAP8[$13 | 0]; + $7 = $9 ? ($7 & 15) == 3 ? $7 & -33 : $7 : $7; + switch ($7 - 88 | 0) { + case 11: + break label$37; + + case 9: + case 13: + case 14: + case 15: + break label$38; + + case 27: + break label$43; + + case 12: + case 17: + break label$46; + + case 23: + break label$47; + + case 0: + case 32: + break label$48; + + case 24: + break label$49; + + case 22: + break label$50; + + case 29: + break label$51; + + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 10: + case 16: + case 18: + case 19: + case 20: + case 21: + case 25: + case 26: + case 28: + case 30: + case 31: + break label$8; + + default: + break label$52; + } + } + label$53: { + switch ($7 - 65 | 0) { + case 0: + case 4: + case 5: + case 6: + break label$38; + + case 2: + break label$41; + + case 1: + case 3: + break label$8; + + default: + break label$53; + } + } + if (($7 | 0) == 83) { + break label$42; + } + break label$8; + } + $10 = HEAP32[$8 + 64 >> 2]; + $17 = HEAP32[$8 + 68 >> 2]; + $7 = $17; + $9 = 1765; + break label$45; + } + $7 = 0; + label$54: { + switch ($9 & 255) { + case 0: + HEAP32[HEAP32[$8 + 64 >> 2] >> 2] = $16; + continue label$5; + + case 1: + HEAP32[HEAP32[$8 + 64 >> 2] >> 2] = $16; + continue label$5; + + case 2: + $10 = $16; + $17 = $10 >> 31; + $10 = HEAP32[$8 + 64 >> 2]; + HEAP32[$10 >> 2] = $16; + HEAP32[$10 + 4 >> 2] = $17; + continue label$5; + + case 3: + HEAP16[HEAP32[$8 + 64 >> 2] >> 1] = $16; + continue label$5; + + case 4: + HEAP8[HEAP32[$8 + 64 >> 2]] = $16; + continue label$5; + + case 6: + HEAP32[HEAP32[$8 + 64 >> 2] >> 2] = $16; + continue label$5; + + case 7: + break label$54; + + default: + continue label$5; + } + } + $10 = $16; + $17 = $10 >> 31; + $10 = HEAP32[$8 + 64 >> 2]; + HEAP32[$10 >> 2] = $16; + HEAP32[$10 + 4 >> 2] = $17; + continue label$5; + } + $11 = $11 >>> 0 <= 8 ? 8 : $11; + $14 = $14 | 8; + $7 = 120; + } + $17 = HEAP32[$8 + 64 >> 2]; + $10 = HEAP32[$8 + 68 >> 2]; + $15 = fmt_x($17, $10, $21, $7 & 32); + $10 = HEAP32[$8 + 64 >> 2]; + $17 = HEAP32[$8 + 68 >> 2]; + if (!($17 | $10) | !($14 & 8)) { + break label$44; + } + $24 = ($7 >>> 4 | 0) + 1765 | 0; + $19 = 2; + break label$44; + } + $17 = HEAP32[$8 + 64 >> 2]; + $10 = HEAP32[$8 + 68 >> 2]; + $15 = fmt_o($17, $10, $21); + if (!($14 & 8)) { + break label$44; + } + $7 = $21 - $15 | 0; + $11 = ($7 | 0) < ($11 | 0) ? $11 : $7 + 1 | 0; + break label$44; + } + $10 = HEAP32[$8 + 64 >> 2]; + $17 = HEAP32[$8 + 68 >> 2]; + $7 = $17; + if (($17 | 0) < 0) { + $9 = $7 + (($10 | 0) != 0) | 0; + $9 = 0 - $9 | 0; + $7 = $9; + $10 = 0 - $10 | 0; + HEAP32[$8 + 64 >> 2] = $10; + HEAP32[$8 + 68 >> 2] = $7; + $19 = 1; + $9 = 1765; + break label$45; + } + if ($14 & 2048) { + $19 = 1; + $9 = 1766; + break label$45; + } + $19 = $14 & 1; + $9 = $19 ? 1767 : 1765; + } + $24 = $9; + $15 = fmt_u($10, $7, $21); + } + if (($11 | 0) < 0 ? $23 : 0) { + break label$4; + } + $14 = $23 ? $14 & -65537 : $14; + $7 = HEAP32[$8 + 68 >> 2]; + $9 = HEAP32[$8 + 64 >> 2]; + $10 = $9; + if (!($11 | ($10 | $7) != 0)) { + $15 = $21; + $11 = 0; + break label$8; + } + $7 = !($7 | $10) + ($21 - $15 | 0) | 0; + $11 = ($7 | 0) < ($11 | 0) ? $11 : $7; + break label$8; + } + $7 = HEAP32[$8 + 64 >> 2]; + $15 = $7 ? $7 : 12373; + $7 = strnlen($15, $11 >>> 0 >= 2147483647 ? 2147483647 : $11); + $20 = $7 + $15 | 0; + if (($11 | 0) >= 0) { + $14 = $10; + $11 = $7; + break label$8; + } + $14 = $10; + $11 = $7; + if (HEAPU8[$20 | 0]) { + break label$4; + } + break label$8; + } + $12 = HEAP32[$8 + 64 >> 2]; + if ($11) { + break label$40; + } + $7 = 0; + pad($0, 32, $18, 0, $14); + break label$39; + } + HEAP32[$8 + 12 >> 2] = 0; + $10 = HEAP32[$8 + 64 >> 2]; + HEAP32[$8 + 8 >> 2] = $10; + HEAP32[$8 + 64 >> 2] = $8 + 8; + $11 = -1; + $12 = $8 + 8 | 0; + } + $7 = 0; + label$66: { + while (1) { + $9 = HEAP32[$12 >> 2]; + if (!$9) { + break label$66; + } + $9 = wctomb($8 + 4 | 0, $9); + $15 = ($9 | 0) < 0; + if (!($15 | $11 - $7 >>> 0 < $9 >>> 0)) { + $12 = $12 + 4 | 0; + $7 = $7 + $9 | 0; + if ($11 >>> 0 > $7 >>> 0) { + continue; + } + break label$66; + } + break; + } + if ($15) { + break label$2; + } + } + $20 = 61; + if (($7 | 0) < 0) { + break label$3; + } + pad($0, 32, $18, $7, $14); + if (!$7) { + $7 = 0; + break label$39; + } + $9 = 0; + $12 = HEAP32[$8 + 64 >> 2]; + while (1) { + $15 = HEAP32[$12 >> 2]; + if (!$15) { + break label$39; + } + $15 = wctomb($8 + 4 | 0, $15); + $9 = $15 + $9 | 0; + if ($9 >>> 0 > $7 >>> 0) { + break label$39; + } + out($0, $8 + 4 | 0, $15); + $12 = $12 + 4 | 0; + if ($7 >>> 0 > $9 >>> 0) { + continue; + } + break; + } + } + pad($0, 32, $18, $7, $14 ^ 8192); + $7 = ($7 | 0) < ($18 | 0) ? $18 : $7; + continue label$5; + } + if (($11 | 0) < 0 ? $23 : 0) { + break label$4; + } + $20 = 61; + $7 = FUNCTION_TABLE[$5 | 0]($0, HEAPF64[$8 + 64 >> 3], $18, $11, $14, $7) | 0; + if (($7 | 0) >= 0) { + continue label$5; + } + break label$3; + } + $7 = HEAP32[$8 + 64 >> 2]; + HEAP8[$8 + 55 | 0] = $7; + $11 = 1; + $15 = $25; + $14 = $10; + break label$8; + } + $12 = HEAPU8[$7 + 1 | 0]; + $7 = $7 + 1 | 0; + continue; + } + } + if ($0) { + break label$1; + } + if (!$22) { + break label$6; + } + $7 = 1; + while (1) { + $12 = HEAP32[($7 << 2) + $4 >> 2]; + if ($12) { + pop_arg(($7 << 3) + $3 | 0, $12, $2, $6); + $16 = 1; + $7 = $7 + 1 | 0; + if (($7 | 0) != 10) { + continue; + } + break label$1; + } + break; + } + $16 = 1; + if ($7 >>> 0 >= 10) { + break label$1; + } + while (1) { + if (HEAP32[($7 << 2) + $4 >> 2]) { + break label$9; + } + $7 = $7 + 1 | 0; + if (($7 | 0) != 10) { + continue; + } + break; + } + break label$1; + } + $20 = 28; + break label$3; + } + $13 = $20 - $15 | 0; + $11 = ($11 | 0) > ($13 | 0) ? $11 : $13; + if (($11 | 0) > ($19 ^ 2147483647)) { + break label$4; + } + $20 = 61; + $9 = $11 + $19 | 0; + $7 = ($9 | 0) < ($18 | 0) ? $18 : $9; + if (($12 | 0) < ($7 | 0)) { + break label$3; + } + pad($0, 32, $7, $9, $14); + out($0, $24, $19); + pad($0, 48, $7, $9, $14 ^ 65536); + pad($0, 48, $11, $13, 0); + out($0, $15, $13); + pad($0, 32, $7, $9, $14 ^ 8192); + continue; + } + break; + } + $16 = 0; + break label$1; + } + $20 = 61; + } + wasm2js_i32$0 = __errno_location(), wasm2js_i32$1 = $20, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + } + $16 = -1; + } + __stack_pointer = $8 + 80 | 0; + return $16; +} + +function b2World__SolveTOI_28b2TimeStep_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 480 | 0; + __stack_pointer = $2; + HEAP32[$2 + 476 >> 2] = $0; + HEAP32[$2 + 472 >> 2] = $1; + $5 = HEAP32[$2 + 476 >> 2]; + b2Island__b2Island_28int_2c_20int_2c_20int_2c_20b2StackAllocator__2c_20b2ContactListener__29($2 + 420 | 0, 64, 32, 0, $5 + 68 | 0, HEAP32[$5 + 102940 >> 2]); + if (HEAP8[$5 + 102994 | 0] & 1) { + HEAP32[$2 + 416 >> 2] = HEAP32[$5 + 102948 >> 2]; + while (1) { + if (HEAP32[$2 + 416 >> 2]) { + $0 = HEAP32[$2 + 416 >> 2]; + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] & -2; + HEAPF32[HEAP32[$2 + 416 >> 2] + 60 >> 2] = 0; + HEAP32[$2 + 416 >> 2] = HEAP32[HEAP32[$2 + 416 >> 2] + 96 >> 2]; + continue; + } + break; + } + HEAP32[$2 + 412 >> 2] = HEAP32[$5 + 102928 >> 2]; + while (1) { + if (HEAP32[$2 + 412 >> 2]) { + $0 = HEAP32[$2 + 412 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] & -34; + HEAP32[HEAP32[$2 + 412 >> 2] + 128 >> 2] = 0; + HEAPF32[HEAP32[$2 + 412 >> 2] + 132 >> 2] = 1; + HEAP32[$2 + 412 >> 2] = HEAP32[HEAP32[$2 + 412 >> 2] + 12 >> 2]; + continue; + } + break; + } + } + while (1) { + HEAP32[$2 + 408 >> 2] = 0; + HEAPF32[$2 + 404 >> 2] = 1; + HEAP32[$2 + 400 >> 2] = HEAP32[$5 + 102928 >> 2]; + while (1) { + if (HEAP32[$2 + 400 >> 2]) { + label$9: { + if (!(b2Contact__IsEnabled_28_29_20const(HEAP32[$2 + 400 >> 2]) & 1) | HEAP32[HEAP32[$2 + 400 >> 2] + 128 >> 2] > 8) { + break label$9; + } + HEAPF32[$2 + 396 >> 2] = 1; + label$10: { + if (HEAP32[HEAP32[$2 + 400 >> 2] + 4 >> 2] & 32) { + HEAPF32[$2 + 396 >> 2] = HEAPF32[HEAP32[$2 + 400 >> 2] + 132 >> 2]; + break label$10; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Contact__GetFixtureA_28_29(HEAP32[$2 + 400 >> 2]), + HEAP32[wasm2js_i32$0 + 392 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Contact__GetFixtureB_28_29(HEAP32[$2 + 400 >> 2]), + HEAP32[wasm2js_i32$0 + 388 >> 2] = wasm2js_i32$1; + if (b2Fixture__IsSensor_28_29_20const(HEAP32[$2 + 392 >> 2]) & 1) { + break label$9; + } + if (b2Fixture__IsSensor_28_29_20const(HEAP32[$2 + 388 >> 2]) & 1) { + break label$9; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$2 + 392 >> 2]), + HEAP32[wasm2js_i32$0 + 384 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$2 + 388 >> 2]), + HEAP32[wasm2js_i32$0 + 380 >> 2] = wasm2js_i32$1; + HEAP32[$2 + 376 >> 2] = HEAP32[HEAP32[$2 + 384 >> 2] >> 2]; + HEAP32[$2 + 372 >> 2] = HEAP32[HEAP32[$2 + 380 >> 2] >> 2]; + $0 = 0; + if (b2Body__IsAwake_28_29_20const(HEAP32[$2 + 384 >> 2]) & 1) { + $0 = HEAP32[$2 + 376 >> 2] != 0; + } + HEAP8[$2 + 371 | 0] = $0; + $0 = 0; + if (b2Body__IsAwake_28_29_20const(HEAP32[$2 + 380 >> 2]) & 1) { + $0 = HEAP32[$2 + 372 >> 2] != 0; + } + HEAP8[$2 + 370 | 0] = $0; + if (!(HEAP8[$2 + 371 | 0] & 1 | HEAP8[$2 + 370 | 0] & 1)) { + break label$9; + } + $0 = 1; + if (!(b2Body__IsBullet_28_29_20const(HEAP32[$2 + 384 >> 2]) & 1)) { + $0 = HEAP32[$2 + 376 >> 2] != 2; + } + HEAP8[$2 + 369 | 0] = $0; + $0 = 1; + if (!(b2Body__IsBullet_28_29_20const(HEAP32[$2 + 380 >> 2]) & 1)) { + $0 = HEAP32[$2 + 372 >> 2] != 2; + } + HEAP8[$2 + 368 | 0] = $0; + if (!(HEAP8[$2 + 369 | 0] & 1 | HEAP8[$2 + 368 | 0] & 1)) { + break label$9; + } + HEAPF32[$2 + 364 >> 2] = HEAPF32[HEAP32[$2 + 384 >> 2] + 60 >> 2]; + label$19: { + if (HEAPF32[HEAP32[$2 + 384 >> 2] + 60 >> 2] < HEAPF32[HEAP32[$2 + 380 >> 2] + 60 >> 2]) { + HEAPF32[$2 + 364 >> 2] = HEAPF32[HEAP32[$2 + 380 >> 2] + 60 >> 2]; + b2Sweep__Advance_28float_29(HEAP32[$2 + 384 >> 2] + 28 | 0, HEAPF32[$2 + 364 >> 2]); + break label$19; + } + if (HEAPF32[HEAP32[$2 + 380 >> 2] + 60 >> 2] < HEAPF32[HEAP32[$2 + 384 >> 2] + 60 >> 2]) { + HEAPF32[$2 + 364 >> 2] = HEAPF32[HEAP32[$2 + 384 >> 2] + 60 >> 2]; + b2Sweep__Advance_28float_29(HEAP32[$2 + 380 >> 2] + 28 | 0, HEAPF32[$2 + 364 >> 2]); + } + } + if (!(HEAPF32[$2 + 364 >> 2] < Math_fround(1))) { + __assert_fail(8093, 6161, 684, 10871); + wasm2js_trap(); + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Contact__GetChildIndexA_28_29_20const(HEAP32[$2 + 400 >> 2]), + HEAP32[wasm2js_i32$0 + 360 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Contact__GetChildIndexB_28_29_20const(HEAP32[$2 + 400 >> 2]), + HEAP32[wasm2js_i32$0 + 356 >> 2] = wasm2js_i32$1; + b2TOIInput__b2TOIInput_28_29($2 + 224 | 0); + b2DistanceProxy__Set_28b2Shape_20const__2c_20int_29($2 + 224 | 0, b2Fixture__GetShape_28_29(HEAP32[$2 + 392 >> 2]), HEAP32[$2 + 360 >> 2]); + b2DistanceProxy__Set_28b2Shape_20const__2c_20int_29($2 + 252 | 0, b2Fixture__GetShape_28_29(HEAP32[$2 + 388 >> 2]), HEAP32[$2 + 356 >> 2]); + $3 = HEAP32[$2 + 384 >> 2]; + $1 = HEAP32[$3 + 28 >> 2]; + $0 = HEAP32[$3 + 32 >> 2]; + $6 = $1; + $4 = $2 + 224 | 0; + $1 = $4; + HEAP32[$1 + 56 >> 2] = $6; + HEAP32[$1 + 60 >> 2] = $0; + HEAP32[$1 + 88 >> 2] = HEAP32[$3 + 60 >> 2]; + $1 = HEAP32[$3 + 56 >> 2]; + $0 = HEAP32[$3 + 52 >> 2]; + $6 = $0; + $0 = $4; + HEAP32[$0 + 80 >> 2] = $6; + HEAP32[$0 + 84 >> 2] = $1; + $0 = HEAP32[$3 + 48 >> 2]; + $1 = HEAP32[$3 + 44 >> 2]; + $6 = $1; + $1 = $4; + HEAP32[$1 + 72 >> 2] = $6; + HEAP32[$1 + 76 >> 2] = $0; + $1 = HEAP32[$3 + 40 >> 2]; + $0 = HEAP32[$3 + 36 >> 2]; + $3 = $0; + $0 = $4; + HEAP32[$0 + 64 >> 2] = $3; + HEAP32[$0 + 68 >> 2] = $1; + $3 = HEAP32[$2 + 380 >> 2]; + $1 = HEAP32[$3 + 28 >> 2]; + $0 = HEAP32[$3 + 32 >> 2]; + $6 = $1; + $4 = $2 + 224 | 0; + $1 = $4; + HEAP32[$1 + 92 >> 2] = $6; + HEAP32[$1 + 96 >> 2] = $0; + HEAP32[$1 + 124 >> 2] = HEAP32[$3 + 60 >> 2]; + $1 = HEAP32[$3 + 56 >> 2]; + $0 = HEAP32[$3 + 52 >> 2]; + $6 = $0; + $0 = $4; + HEAP32[$0 + 116 >> 2] = $6; + HEAP32[$0 + 120 >> 2] = $1; + $0 = HEAP32[$3 + 48 >> 2]; + $1 = HEAP32[$3 + 44 >> 2]; + $6 = $1; + $1 = $4; + HEAP32[$1 + 108 >> 2] = $6; + HEAP32[$1 + 112 >> 2] = $0; + $1 = HEAP32[$3 + 40 >> 2]; + $0 = HEAP32[$3 + 36 >> 2]; + $3 = $0; + $0 = $4; + HEAP32[$0 + 100 >> 2] = $3; + HEAP32[$0 + 104 >> 2] = $1; + HEAPF32[$2 + 352 >> 2] = 1; + b2TimeOfImpact_28b2TOIOutput__2c_20b2TOIInput_20const__29($2 + 216 | 0, $2 + 224 | 0); + HEAPF32[$2 + 212 >> 2] = HEAPF32[$2 + 220 >> 2]; + label$23: { + if (HEAP32[$2 + 216 >> 2] == 3) { + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Min_float__28float_2c_20float_29(Math_fround(Math_fround(Math_fround(Math_fround(1) - HEAPF32[$2 + 364 >> 2]) * HEAPF32[$2 + 212 >> 2]) + HEAPF32[$2 + 364 >> 2]), Math_fround(1)), + HEAPF32[wasm2js_i32$0 + 396 >> 2] = wasm2js_f32$0; + break label$23; + } + HEAPF32[$2 + 396 >> 2] = 1; + } + HEAPF32[HEAP32[$2 + 400 >> 2] + 132 >> 2] = HEAPF32[$2 + 396 >> 2]; + $0 = HEAP32[$2 + 400 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] | 32; + } + if (HEAPF32[$2 + 396 >> 2] < HEAPF32[$2 + 404 >> 2]) { + HEAP32[$2 + 408 >> 2] = HEAP32[$2 + 400 >> 2]; + HEAPF32[$2 + 404 >> 2] = HEAPF32[$2 + 396 >> 2]; + } + } + HEAP32[$2 + 400 >> 2] = HEAP32[HEAP32[$2 + 400 >> 2] + 12 >> 2]; + continue; + } + break; + } + label$26: { + if (!(HEAPF32[$2 + 404 >> 2] > Math_fround(.9999988079071045) ? 0 : HEAP32[$2 + 408 >> 2])) { + HEAP8[$5 + 102994 | 0] = 1; + break label$26; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Contact__GetFixtureA_28_29(HEAP32[$2 + 408 >> 2]), + HEAP32[wasm2js_i32$0 + 208 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Contact__GetFixtureB_28_29(HEAP32[$2 + 408 >> 2]), + HEAP32[wasm2js_i32$0 + 204 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$2 + 208 >> 2]), + HEAP32[wasm2js_i32$0 + 200 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$2 + 204 >> 2]), + HEAP32[wasm2js_i32$0 + 196 >> 2] = wasm2js_i32$1; + $3 = HEAP32[$2 + 200 >> 2]; + HEAP32[$2 + 192 >> 2] = HEAP32[$3 + 60 >> 2]; + $1 = HEAP32[$3 + 52 >> 2]; + $0 = HEAP32[$3 + 56 >> 2]; + HEAP32[$2 + 184 >> 2] = $1; + HEAP32[$2 + 188 >> 2] = $0; + $1 = HEAP32[$3 + 48 >> 2]; + $0 = HEAP32[$3 + 44 >> 2]; + HEAP32[$2 + 176 >> 2] = $0; + HEAP32[$2 + 180 >> 2] = $1; + $0 = HEAP32[$3 + 40 >> 2]; + $1 = HEAP32[$3 + 36 >> 2]; + HEAP32[$2 + 168 >> 2] = $1; + HEAP32[$2 + 172 >> 2] = $0; + $1 = HEAP32[$3 + 32 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + HEAP32[$2 + 160 >> 2] = $0; + HEAP32[$2 + 164 >> 2] = $1; + $3 = HEAP32[$2 + 196 >> 2]; + HEAP32[$2 + 152 >> 2] = HEAP32[$3 + 60 >> 2]; + $1 = HEAP32[$3 + 52 >> 2]; + $0 = HEAP32[$3 + 56 >> 2]; + HEAP32[$2 + 144 >> 2] = $1; + HEAP32[$2 + 148 >> 2] = $0; + $1 = HEAP32[$3 + 48 >> 2]; + $0 = HEAP32[$3 + 44 >> 2]; + HEAP32[$2 + 136 >> 2] = $0; + HEAP32[$2 + 140 >> 2] = $1; + $0 = HEAP32[$3 + 40 >> 2]; + $1 = HEAP32[$3 + 36 >> 2]; + HEAP32[$2 + 128 >> 2] = $1; + HEAP32[$2 + 132 >> 2] = $0; + $1 = HEAP32[$3 + 32 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + HEAP32[$2 + 120 >> 2] = $0; + HEAP32[$2 + 124 >> 2] = $1; + b2Body__Advance_28float_29(HEAP32[$2 + 200 >> 2], HEAPF32[$2 + 404 >> 2]); + b2Body__Advance_28float_29(HEAP32[$2 + 196 >> 2], HEAPF32[$2 + 404 >> 2]); + b2Contact__Update_28b2ContactListener__29(HEAP32[$2 + 408 >> 2], HEAP32[$5 + 102940 >> 2]); + $0 = HEAP32[$2 + 408 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] & -33; + $0 = HEAP32[$2 + 408 >> 2]; + HEAP32[$0 + 128 >> 2] = HEAP32[$0 + 128 >> 2] + 1; + label$29: { + if (b2Contact__IsEnabled_28_29_20const(HEAP32[$2 + 408 >> 2]) & 1) { + if (b2Contact__IsTouching_28_29_20const(HEAP32[$2 + 408 >> 2]) & 1) { + break label$29; + } + } + b2Contact__SetEnabled_28bool_29(HEAP32[$2 + 408 >> 2], 0); + $0 = HEAP32[$2 + 164 >> 2]; + $1 = HEAP32[$2 + 160 >> 2]; + $4 = $1; + $3 = HEAP32[$2 + 200 >> 2]; + $1 = $3; + HEAP32[$1 + 28 >> 2] = $4; + HEAP32[$1 + 32 >> 2] = $0; + HEAP32[$1 + 60 >> 2] = HEAP32[$2 + 192 >> 2]; + $1 = HEAP32[$2 + 188 >> 2]; + $0 = HEAP32[$2 + 184 >> 2]; + $4 = $0; + $0 = $3; + HEAP32[$0 + 52 >> 2] = $4; + HEAP32[$0 + 56 >> 2] = $1; + $0 = HEAP32[$2 + 180 >> 2]; + $1 = HEAP32[$2 + 176 >> 2]; + $4 = $1; + $1 = $3; + HEAP32[$1 + 44 >> 2] = $4; + HEAP32[$1 + 48 >> 2] = $0; + $1 = HEAP32[$2 + 172 >> 2]; + $0 = HEAP32[$2 + 168 >> 2]; + $4 = $0; + $0 = $3; + HEAP32[$0 + 36 >> 2] = $4; + HEAP32[$0 + 40 >> 2] = $1; + $0 = HEAP32[$2 + 124 >> 2]; + $1 = HEAP32[$2 + 120 >> 2]; + $4 = $1; + $3 = HEAP32[$2 + 196 >> 2]; + $1 = $3; + HEAP32[$1 + 28 >> 2] = $4; + HEAP32[$1 + 32 >> 2] = $0; + HEAP32[$1 + 60 >> 2] = HEAP32[$2 + 152 >> 2]; + $1 = HEAP32[$2 + 148 >> 2]; + $0 = HEAP32[$2 + 144 >> 2]; + $4 = $0; + $0 = $3; + HEAP32[$0 + 52 >> 2] = $4; + HEAP32[$0 + 56 >> 2] = $1; + $0 = HEAP32[$2 + 140 >> 2]; + $1 = HEAP32[$2 + 136 >> 2]; + $4 = $1; + $1 = $3; + HEAP32[$1 + 44 >> 2] = $4; + HEAP32[$1 + 48 >> 2] = $0; + $1 = HEAP32[$2 + 132 >> 2]; + $0 = HEAP32[$2 + 128 >> 2]; + $4 = $0; + $0 = $3; + HEAP32[$0 + 36 >> 2] = $4; + HEAP32[$0 + 40 >> 2] = $1; + b2Body__SynchronizeTransform_28_29(HEAP32[$2 + 200 >> 2]); + b2Body__SynchronizeTransform_28_29(HEAP32[$2 + 196 >> 2]); + continue; + } + b2Body__SetAwake_28bool_29(HEAP32[$2 + 200 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$2 + 196 >> 2], 1); + b2Island__Clear_28_29($2 + 420 | 0); + b2Island__Add_28b2Body__29($2 + 420 | 0, HEAP32[$2 + 200 >> 2]); + b2Island__Add_28b2Body__29($2 + 420 | 0, HEAP32[$2 + 196 >> 2]); + b2Island__Add_28b2Contact__29($2 + 420 | 0, HEAP32[$2 + 408 >> 2]); + $0 = HEAP32[$2 + 200 >> 2]; + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] | 1; + $0 = HEAP32[$2 + 196 >> 2]; + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] | 1; + $0 = HEAP32[$2 + 408 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] | 1; + HEAP32[$2 + 112 >> 2] = HEAP32[$2 + 200 >> 2]; + HEAP32[$2 + 116 >> 2] = HEAP32[$2 + 196 >> 2]; + HEAP32[$2 + 108 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 108 >> 2] < 2) { + HEAP32[$2 + 104 >> 2] = HEAP32[($2 + 112 | 0) + (HEAP32[$2 + 108 >> 2] << 2) >> 2]; + if (HEAP32[HEAP32[$2 + 104 >> 2] >> 2] == 2) { + HEAP32[$2 + 100 >> 2] = HEAP32[HEAP32[$2 + 104 >> 2] + 112 >> 2]; + while (1) { + if (!(!HEAP32[$2 + 100 >> 2] | HEAP32[$2 + 448 >> 2] == HEAP32[$2 + 460 >> 2] | HEAP32[$2 + 456 >> 2] == HEAP32[$2 + 464 >> 2])) { + HEAP32[$2 + 96 >> 2] = HEAP32[HEAP32[$2 + 100 >> 2] + 4 >> 2]; + label$36: { + if (HEAP32[HEAP32[$2 + 96 >> 2] + 4 >> 2] & 1) { + break label$36; + } + HEAP32[$2 + 92 >> 2] = HEAP32[HEAP32[$2 + 100 >> 2] >> 2]; + label$37: { + if (HEAP32[HEAP32[$2 + 92 >> 2] >> 2] != 2) { + break label$37; + } + if (b2Body__IsBullet_28_29_20const(HEAP32[$2 + 104 >> 2]) & 1) { + break label$37; + } + if (b2Body__IsBullet_28_29_20const(HEAP32[$2 + 92 >> 2]) & 1) { + break label$37; + } + break label$36; + } + HEAP8[$2 + 91 | 0] = HEAP8[HEAP32[HEAP32[$2 + 96 >> 2] + 48 >> 2] + 38 | 0] & 1; + HEAP8[$2 + 90 | 0] = HEAP8[HEAP32[HEAP32[$2 + 96 >> 2] + 52 >> 2] + 38 | 0] & 1; + if (HEAP8[$2 + 91 | 0] & 1 | HEAP8[$2 + 90 | 0] & 1) { + break label$36; + } + $3 = HEAP32[$2 + 92 >> 2]; + HEAP32[$2 + 80 >> 2] = HEAP32[$3 + 60 >> 2]; + $1 = HEAP32[$3 + 52 >> 2]; + $0 = HEAP32[$3 + 56 >> 2]; + HEAP32[$2 + 72 >> 2] = $1; + HEAP32[$2 + 76 >> 2] = $0; + $1 = HEAP32[$3 + 48 >> 2]; + $0 = HEAP32[$3 + 44 >> 2]; + HEAP32[$2 + 64 >> 2] = $0; + HEAP32[$2 + 68 >> 2] = $1; + $0 = HEAP32[$3 + 40 >> 2]; + $1 = HEAP32[$3 + 36 >> 2]; + HEAP32[$2 + 56 >> 2] = $1; + HEAP32[$2 + 60 >> 2] = $0; + $1 = HEAP32[$3 + 32 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + HEAP32[$2 + 48 >> 2] = $0; + HEAP32[$2 + 52 >> 2] = $1; + if (!(HEAP16[HEAP32[$2 + 92 >> 2] + 4 >> 1] & 1)) { + b2Body__Advance_28float_29(HEAP32[$2 + 92 >> 2], HEAPF32[$2 + 404 >> 2]); + } + b2Contact__Update_28b2ContactListener__29(HEAP32[$2 + 96 >> 2], HEAP32[$5 + 102940 >> 2]); + if (!(b2Contact__IsEnabled_28_29_20const(HEAP32[$2 + 96 >> 2]) & 1)) { + $0 = HEAP32[$2 + 52 >> 2]; + $1 = HEAP32[$2 + 48 >> 2]; + $4 = $1; + $3 = HEAP32[$2 + 92 >> 2]; + $1 = $3; + HEAP32[$1 + 28 >> 2] = $4; + HEAP32[$1 + 32 >> 2] = $0; + HEAP32[$1 + 60 >> 2] = HEAP32[$2 + 80 >> 2]; + $1 = HEAP32[$2 + 76 >> 2]; + $0 = HEAP32[$2 + 72 >> 2]; + $4 = $0; + $0 = $3; + HEAP32[$0 + 52 >> 2] = $4; + HEAP32[$0 + 56 >> 2] = $1; + $0 = HEAP32[$2 + 68 >> 2]; + $1 = HEAP32[$2 + 64 >> 2]; + $4 = $1; + $1 = $3; + HEAP32[$1 + 44 >> 2] = $4; + HEAP32[$1 + 48 >> 2] = $0; + $1 = HEAP32[$2 + 60 >> 2]; + $0 = HEAP32[$2 + 56 >> 2]; + $4 = $0; + $0 = $3; + HEAP32[$0 + 36 >> 2] = $4; + HEAP32[$0 + 40 >> 2] = $1; + b2Body__SynchronizeTransform_28_29(HEAP32[$2 + 92 >> 2]); + break label$36; + } + if (!(b2Contact__IsTouching_28_29_20const(HEAP32[$2 + 96 >> 2]) & 1)) { + $0 = HEAP32[$2 + 52 >> 2]; + $1 = HEAP32[$2 + 48 >> 2]; + $4 = $1; + $3 = HEAP32[$2 + 92 >> 2]; + $1 = $3; + HEAP32[$1 + 28 >> 2] = $4; + HEAP32[$1 + 32 >> 2] = $0; + HEAP32[$1 + 60 >> 2] = HEAP32[$2 + 80 >> 2]; + $1 = HEAP32[$2 + 76 >> 2]; + $0 = HEAP32[$2 + 72 >> 2]; + $4 = $0; + $0 = $3; + HEAP32[$0 + 52 >> 2] = $4; + HEAP32[$0 + 56 >> 2] = $1; + $0 = HEAP32[$2 + 68 >> 2]; + $1 = HEAP32[$2 + 64 >> 2]; + $4 = $1; + $1 = $3; + HEAP32[$1 + 44 >> 2] = $4; + HEAP32[$1 + 48 >> 2] = $0; + $1 = HEAP32[$2 + 60 >> 2]; + $0 = HEAP32[$2 + 56 >> 2]; + $4 = $0; + $0 = $3; + HEAP32[$0 + 36 >> 2] = $4; + HEAP32[$0 + 40 >> 2] = $1; + b2Body__SynchronizeTransform_28_29(HEAP32[$2 + 92 >> 2]); + break label$36; + } + $0 = HEAP32[$2 + 96 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] | 1; + b2Island__Add_28b2Contact__29($2 + 420 | 0, HEAP32[$2 + 96 >> 2]); + if (HEAP16[HEAP32[$2 + 92 >> 2] + 4 >> 1] & 1) { + break label$36; + } + $0 = HEAP32[$2 + 92 >> 2]; + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] | 1; + if (HEAP32[HEAP32[$2 + 92 >> 2] >> 2]) { + b2Body__SetAwake_28bool_29(HEAP32[$2 + 92 >> 2], 1); + } + b2Island__Add_28b2Body__29($2 + 420 | 0, HEAP32[$2 + 92 >> 2]); + } + HEAP32[$2 + 100 >> 2] = HEAP32[HEAP32[$2 + 100 >> 2] + 12 >> 2]; + continue; + } + break; + } + } + HEAP32[$2 + 108 >> 2] = HEAP32[$2 + 108 >> 2] + 1; + continue; + } + break; + } + HEAPF32[$2 + 24 >> 2] = Math_fround(Math_fround(1) - HEAPF32[$2 + 404 >> 2]) * HEAPF32[HEAP32[$2 + 472 >> 2] >> 2]; + HEAPF32[$2 + 28 >> 2] = Math_fround(1) / HEAPF32[$2 + 24 >> 2]; + HEAPF32[$2 + 32 >> 2] = 1; + HEAP32[$2 + 40 >> 2] = 20; + HEAP32[$2 + 36 >> 2] = HEAP32[HEAP32[$2 + 472 >> 2] + 12 >> 2]; + HEAP8[$2 + 44 | 0] = 0; + b2Island__SolveTOI_28b2TimeStep_20const__2c_20int_2c_20int_29($2 + 420 | 0, $2 + 24 | 0, HEAP32[HEAP32[$2 + 200 >> 2] + 8 >> 2], HEAP32[HEAP32[$2 + 196 >> 2] + 8 >> 2]); + HEAP32[$2 + 20 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 20 >> 2] < HEAP32[$2 + 448 >> 2]) { + HEAP32[$2 + 16 >> 2] = HEAP32[HEAP32[$2 + 428 >> 2] + (HEAP32[$2 + 20 >> 2] << 2) >> 2]; + $0 = HEAP32[$2 + 16 >> 2]; + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] & -2; + if (HEAP32[HEAP32[$2 + 16 >> 2] >> 2] == 2) { + b2Body__SynchronizeFixtures_28_29(HEAP32[$2 + 16 >> 2]); + HEAP32[$2 + 12 >> 2] = HEAP32[HEAP32[$2 + 16 >> 2] + 112 >> 2]; + while (1) { + if (HEAP32[$2 + 12 >> 2]) { + $0 = HEAP32[HEAP32[$2 + 12 >> 2] + 4 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] & -34; + HEAP32[$2 + 12 >> 2] = HEAP32[HEAP32[$2 + 12 >> 2] + 12 >> 2]; + continue; + } + break; + } + } + HEAP32[$2 + 20 >> 2] = HEAP32[$2 + 20 >> 2] + 1; + continue; + } + break; + } + b2ContactManager__FindNewContacts_28_29($5 + 102868 | 0); + if (HEAP8[$5 + 102993 | 0] & 1) { + HEAP8[$5 + 102994 | 0] = 0; + break label$26; + } + continue; + } + break; + } + b2Island___b2Island_28_29($2 + 420 | 0); + __stack_pointer = $2 + 480 | 0; +} + +function b2ContactSolver__SolveVelocityConstraints_28_29($0) { + var $1 = 0, $2 = Math_fround(0), $3 = 0, $4 = 0, $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer - 640 | 0; + __stack_pointer = $1; + HEAP32[$1 + 636 >> 2] = $0; + $5 = HEAP32[$1 + 636 >> 2]; + HEAP32[$1 + 632 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 632 >> 2] < HEAP32[$5 + 48 >> 2]) { + HEAP32[$1 + 628 >> 2] = HEAP32[$5 + 40 >> 2] + Math_imul(HEAP32[$1 + 632 >> 2], 156); + HEAP32[$1 + 624 >> 2] = HEAP32[HEAP32[$1 + 628 >> 2] + 112 >> 2]; + HEAP32[$1 + 620 >> 2] = HEAP32[HEAP32[$1 + 628 >> 2] + 116 >> 2]; + HEAPF32[$1 + 616 >> 2] = HEAPF32[HEAP32[$1 + 628 >> 2] + 120 >> 2]; + HEAPF32[$1 + 612 >> 2] = HEAPF32[HEAP32[$1 + 628 >> 2] + 128 >> 2]; + HEAPF32[$1 + 608 >> 2] = HEAPF32[HEAP32[$1 + 628 >> 2] + 124 >> 2]; + HEAPF32[$1 + 604 >> 2] = HEAPF32[HEAP32[$1 + 628 >> 2] + 132 >> 2]; + HEAP32[$1 + 600 >> 2] = HEAP32[HEAP32[$1 + 628 >> 2] + 148 >> 2]; + $3 = HEAP32[$5 + 28 >> 2] + Math_imul(HEAP32[$1 + 624 >> 2], 12) | 0; + $0 = HEAP32[$3 >> 2]; + $4 = HEAP32[$3 + 4 >> 2]; + HEAP32[$1 + 592 >> 2] = $0; + HEAP32[$1 + 596 >> 2] = $4; + HEAPF32[$1 + 588 >> 2] = HEAPF32[(HEAP32[$5 + 28 >> 2] + Math_imul(HEAP32[$1 + 624 >> 2], 12) | 0) + 8 >> 2]; + $3 = HEAP32[$5 + 28 >> 2] + Math_imul(HEAP32[$1 + 620 >> 2], 12) | 0; + $4 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + HEAP32[$1 + 576 >> 2] = $4; + HEAP32[$1 + 580 >> 2] = $0; + HEAPF32[$1 + 572 >> 2] = HEAPF32[(HEAP32[$5 + 28 >> 2] + Math_imul(HEAP32[$1 + 620 >> 2], 12) | 0) + 8 >> 2]; + $3 = HEAP32[$1 + 628 >> 2]; + $0 = HEAP32[$3 + 72 >> 2]; + $4 = HEAP32[$3 + 76 >> 2]; + HEAP32[$1 + 560 >> 2] = $0; + HEAP32[$1 + 564 >> 2] = $4; + b2Cross_28b2Vec2_20const__2c_20float_29($1 + 552 | 0, $1 + 560 | 0, Math_fround(1)); + HEAPF32[$1 + 548 >> 2] = HEAPF32[HEAP32[$1 + 628 >> 2] + 136 >> 2]; + if (!(HEAP32[$1 + 600 >> 2] == 1 | HEAP32[$1 + 600 >> 2] == 2)) { + __assert_fail(12094, 5487, 319, 3319); + wasm2js_trap(); + } + HEAP32[$1 + 544 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 544 >> 2] < HEAP32[$1 + 600 >> 2]) { + HEAP32[$1 + 540 >> 2] = HEAP32[$1 + 628 >> 2] + Math_imul(HEAP32[$1 + 544 >> 2], 36); + b2Cross_28float_2c_20b2Vec2_20const__29($1 + 508 | 0, HEAPF32[$1 + 572 >> 2], HEAP32[$1 + 540 >> 2] + 8 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 516 | 0, $1 + 576 | 0, $1 + 508 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 524 | 0, $1 + 516 | 0, $1 + 592 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($1 + 500 | 0, HEAPF32[$1 + 588 >> 2], HEAP32[$1 + 540 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 532 | 0, $1 + 524 | 0, $1 + 500 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 532 | 0, $1 + 552 | 0) - HEAPF32[HEAP32[$1 + 628 >> 2] + 144 >> 2]), + HEAPF32[wasm2js_i32$0 + 496 >> 2] = wasm2js_f32$0; + HEAPF32[$1 + 492 >> 2] = HEAPF32[HEAP32[$1 + 540 >> 2] + 28 >> 2] * Math_fround(-HEAPF32[$1 + 496 >> 2]); + HEAPF32[$1 + 488 >> 2] = HEAPF32[$1 + 548 >> 2] * HEAPF32[HEAP32[$1 + 540 >> 2] + 16 >> 2]; + wasm2js_i32$0 = $1, wasm2js_f32$0 = float_20b2Clamp_float__28float_2c_20float_2c_20float_29(Math_fround(HEAPF32[HEAP32[$1 + 540 >> 2] + 20 >> 2] + HEAPF32[$1 + 492 >> 2]), Math_fround(-HEAPF32[$1 + 488 >> 2]), HEAPF32[$1 + 488 >> 2]), + HEAPF32[wasm2js_i32$0 + 484 >> 2] = wasm2js_f32$0; + HEAPF32[$1 + 492 >> 2] = HEAPF32[$1 + 484 >> 2] - HEAPF32[HEAP32[$1 + 540 >> 2] + 20 >> 2]; + HEAPF32[HEAP32[$1 + 540 >> 2] + 20 >> 2] = HEAPF32[$1 + 484 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($1 + 476 | 0, HEAPF32[$1 + 492 >> 2], $1 + 552 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 468 | 0, HEAPF32[$1 + 616 >> 2], $1 + 476 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($1 + 592 | 0, $1 + 468 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$1 + 612 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 540 >> 2], $1 + 476 | 0)) + HEAPF32[$1 + 588 >> 2]), + HEAPF32[wasm2js_i32$0 + 588 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($1 + 460 | 0, HEAPF32[$1 + 608 >> 2], $1 + 476 | 0); + b2Vec2__operator___28b2Vec2_20const__29($1 + 576 | 0, $1 + 460 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$1 + 604 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 540 >> 2] + 8 | 0, $1 + 476 | 0)) + HEAPF32[$1 + 572 >> 2]), + HEAPF32[wasm2js_i32$0 + 572 >> 2] = wasm2js_f32$0; + HEAP32[$1 + 544 >> 2] = HEAP32[$1 + 544 >> 2] + 1; + continue; + } + break; + } + label$6: { + if (!(HEAP8[29704] & 1 & HEAP32[$1 + 600 >> 2] != 1)) { + HEAP32[$1 + 456 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 456 >> 2] < HEAP32[$1 + 600 >> 2]) { + HEAP32[$1 + 452 >> 2] = HEAP32[$1 + 628 >> 2] + Math_imul(HEAP32[$1 + 456 >> 2], 36); + b2Cross_28float_2c_20b2Vec2_20const__29($1 + 420 | 0, HEAPF32[$1 + 572 >> 2], HEAP32[$1 + 452 >> 2] + 8 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 428 | 0, $1 + 576 | 0, $1 + 420 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 436 | 0, $1 + 428 | 0, $1 + 592 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($1 + 412 | 0, HEAPF32[$1 + 588 >> 2], HEAP32[$1 + 452 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 444 | 0, $1 + 436 | 0, $1 + 412 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 444 | 0, $1 + 560 | 0), + HEAPF32[wasm2js_i32$0 + 408 >> 2] = wasm2js_f32$0; + HEAPF32[$1 + 404 >> 2] = Math_fround(-HEAPF32[HEAP32[$1 + 452 >> 2] + 24 >> 2]) * Math_fround(HEAPF32[$1 + 408 >> 2] - HEAPF32[HEAP32[$1 + 452 >> 2] + 32 >> 2]); + wasm2js_i32$0 = $1, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(Math_fround(HEAPF32[HEAP32[$1 + 452 >> 2] + 16 >> 2] + HEAPF32[$1 + 404 >> 2]), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 400 >> 2] = wasm2js_f32$0; + HEAPF32[$1 + 404 >> 2] = HEAPF32[$1 + 400 >> 2] - HEAPF32[HEAP32[$1 + 452 >> 2] + 16 >> 2]; + HEAPF32[HEAP32[$1 + 452 >> 2] + 16 >> 2] = HEAPF32[$1 + 400 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($1 + 392 | 0, HEAPF32[$1 + 404 >> 2], $1 + 560 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 384 | 0, HEAPF32[$1 + 616 >> 2], $1 + 392 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($1 + 592 | 0, $1 + 384 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$1 + 612 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 452 >> 2], $1 + 392 | 0)) + HEAPF32[$1 + 588 >> 2]), + HEAPF32[wasm2js_i32$0 + 588 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($1 + 376 | 0, HEAPF32[$1 + 608 >> 2], $1 + 392 | 0); + b2Vec2__operator___28b2Vec2_20const__29($1 + 576 | 0, $1 + 376 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$1 + 604 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 452 >> 2] + 8 | 0, $1 + 392 | 0)) + HEAPF32[$1 + 572 >> 2]), + HEAPF32[wasm2js_i32$0 + 572 >> 2] = wasm2js_f32$0; + HEAP32[$1 + 456 >> 2] = HEAP32[$1 + 456 >> 2] + 1; + continue; + } + break; + } + break label$6; + } + HEAP32[$1 + 372 >> 2] = HEAP32[$1 + 628 >> 2]; + HEAP32[$1 + 368 >> 2] = HEAP32[$1 + 628 >> 2] + 36; + b2Vec2__b2Vec2_28float_2c_20float_29($1 + 360 | 0, HEAPF32[HEAP32[$1 + 372 >> 2] + 16 >> 2], HEAPF32[HEAP32[$1 + 368 >> 2] + 16 >> 2]); + if (!(HEAPF32[$1 + 360 >> 2] >= Math_fround(0) & HEAPF32[$1 + 364 >> 2] >= Math_fround(0))) { + __assert_fail(8248, 5487, 417, 3319); + wasm2js_trap(); + } + b2Cross_28float_2c_20b2Vec2_20const__29($1 + 328 | 0, HEAPF32[$1 + 572 >> 2], HEAP32[$1 + 372 >> 2] + 8 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 336 | 0, $1 + 576 | 0, $1 + 328 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 344 | 0, $1 + 336 | 0, $1 + 592 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($1 + 320 | 0, HEAPF32[$1 + 588 >> 2], HEAP32[$1 + 372 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 352 | 0, $1 + 344 | 0, $1 + 320 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($1 + 288 | 0, HEAPF32[$1 + 572 >> 2], HEAP32[$1 + 368 >> 2] + 8 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 296 | 0, $1 + 576 | 0, $1 + 288 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 304 | 0, $1 + 296 | 0, $1 + 592 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($1 + 280 | 0, HEAPF32[$1 + 588 >> 2], HEAP32[$1 + 368 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 312 | 0, $1 + 304 | 0, $1 + 280 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 352 | 0, $1 + 560 | 0), + HEAPF32[wasm2js_i32$0 + 276 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 312 | 0, $1 + 560 | 0), + HEAPF32[wasm2js_i32$0 + 272 >> 2] = wasm2js_f32$0; + b2Vec2__b2Vec2_28_29($1 + 264 | 0); + HEAPF32[$1 + 264 >> 2] = HEAPF32[$1 + 276 >> 2] - HEAPF32[HEAP32[$1 + 372 >> 2] + 32 >> 2]; + HEAPF32[$1 + 268 >> 2] = HEAPF32[$1 + 272 >> 2] - HEAPF32[HEAP32[$1 + 368 >> 2] + 32 >> 2]; + b2Mul_28b2Mat22_20const__2c_20b2Vec2_20const__29($1 + 256 | 0, HEAP32[$1 + 628 >> 2] + 96 | 0, $1 + 360 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($1 + 264 | 0, $1 + 256 | 0); + HEAPF32[$1 + 252 >> 2] = .0010000000474974513; + b2Mul_28b2Mat22_20const__2c_20b2Vec2_20const__29($1 + 236 | 0, HEAP32[$1 + 628 >> 2] + 80 | 0, $1 + 264 | 0); + b2Vec2__operator__28_29_20const($1 + 244 | 0, $1 + 236 | 0); + label$13: { + if (!(!(HEAPF32[$1 + 244 >> 2] >= Math_fround(0)) | !(HEAPF32[$1 + 248 >> 2] >= Math_fround(0)))) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 228 | 0, $1 + 244 | 0, $1 + 360 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 220 | 0, HEAPF32[$1 + 228 >> 2], $1 + 560 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 212 | 0, HEAPF32[$1 + 232 >> 2], $1 + 560 | 0); + $2 = HEAPF32[$1 + 616 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 196 | 0, $1 + 220 | 0, $1 + 212 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 204 | 0, $2, $1 + 196 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($1 + 592 | 0, $1 + 204 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$1 + 612 >> 2]) * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 372 >> 2], $1 + 220 | 0) + b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 368 >> 2], $1 + 212 | 0))) + HEAPF32[$1 + 588 >> 2]), + HEAPF32[wasm2js_i32$0 + 588 >> 2] = wasm2js_f32$0; + $2 = HEAPF32[$1 + 608 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 180 | 0, $1 + 220 | 0, $1 + 212 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 188 | 0, $2, $1 + 180 | 0); + b2Vec2__operator___28b2Vec2_20const__29($1 + 576 | 0, $1 + 188 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$1 + 604 >> 2] * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 372 >> 2] + 8 | 0, $1 + 220 | 0) + b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 368 >> 2] + 8 | 0, $1 + 212 | 0))) + HEAPF32[$1 + 572 >> 2]), + HEAPF32[wasm2js_i32$0 + 572 >> 2] = wasm2js_f32$0; + HEAPF32[HEAP32[$1 + 372 >> 2] + 16 >> 2] = HEAPF32[$1 + 244 >> 2]; + HEAPF32[HEAP32[$1 + 368 >> 2] + 16 >> 2] = HEAPF32[$1 + 248 >> 2]; + break label$13; + } + HEAPF32[$1 + 244 >> 2] = Math_fround(-HEAPF32[HEAP32[$1 + 372 >> 2] + 24 >> 2]) * HEAPF32[$1 + 264 >> 2]; + HEAPF32[$1 + 248 >> 2] = 0; + HEAPF32[$1 + 276 >> 2] = 0; + HEAPF32[$1 + 272 >> 2] = Math_fround(HEAPF32[HEAP32[$1 + 628 >> 2] + 100 >> 2] * HEAPF32[$1 + 244 >> 2]) + HEAPF32[$1 + 268 >> 2]; + if (!(!(HEAPF32[$1 + 244 >> 2] >= Math_fround(0)) | !(HEAPF32[$1 + 272 >> 2] >= Math_fround(0)))) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 172 | 0, $1 + 244 | 0, $1 + 360 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 164 | 0, HEAPF32[$1 + 172 >> 2], $1 + 560 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 156 | 0, HEAPF32[$1 + 176 >> 2], $1 + 560 | 0); + $2 = HEAPF32[$1 + 616 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 140 | 0, $1 + 164 | 0, $1 + 156 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 148 | 0, $2, $1 + 140 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($1 + 592 | 0, $1 + 148 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$1 + 612 >> 2]) * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 372 >> 2], $1 + 164 | 0) + b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 368 >> 2], $1 + 156 | 0))) + HEAPF32[$1 + 588 >> 2]), + HEAPF32[wasm2js_i32$0 + 588 >> 2] = wasm2js_f32$0; + $2 = HEAPF32[$1 + 608 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 124 | 0, $1 + 164 | 0, $1 + 156 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 132 | 0, $2, $1 + 124 | 0); + b2Vec2__operator___28b2Vec2_20const__29($1 + 576 | 0, $1 + 132 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$1 + 604 >> 2] * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 372 >> 2] + 8 | 0, $1 + 164 | 0) + b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 368 >> 2] + 8 | 0, $1 + 156 | 0))) + HEAPF32[$1 + 572 >> 2]), + HEAPF32[wasm2js_i32$0 + 572 >> 2] = wasm2js_f32$0; + HEAPF32[HEAP32[$1 + 372 >> 2] + 16 >> 2] = HEAPF32[$1 + 244 >> 2]; + HEAPF32[HEAP32[$1 + 368 >> 2] + 16 >> 2] = HEAPF32[$1 + 248 >> 2]; + break label$13; + } + HEAPF32[$1 + 244 >> 2] = 0; + HEAPF32[$1 + 248 >> 2] = Math_fround(-HEAPF32[HEAP32[$1 + 368 >> 2] + 24 >> 2]) * HEAPF32[$1 + 268 >> 2]; + HEAPF32[$1 + 276 >> 2] = Math_fround(HEAPF32[HEAP32[$1 + 628 >> 2] + 104 >> 2] * HEAPF32[$1 + 248 >> 2]) + HEAPF32[$1 + 264 >> 2]; + HEAPF32[$1 + 272 >> 2] = 0; + if (!(!(HEAPF32[$1 + 248 >> 2] >= Math_fround(0)) | !(HEAPF32[$1 + 276 >> 2] >= Math_fround(0)))) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 116 | 0, $1 + 244 | 0, $1 + 360 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 108 | 0, HEAPF32[$1 + 116 >> 2], $1 + 560 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 100 | 0, HEAPF32[$1 + 120 >> 2], $1 + 560 | 0); + $2 = HEAPF32[$1 + 616 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 84 | 0, $1 + 108 | 0, $1 + 100 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 92 | 0, $2, $1 + 84 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($1 + 592 | 0, $1 + 92 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$1 + 612 >> 2]) * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 372 >> 2], $1 + 108 | 0) + b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 368 >> 2], $1 + 100 | 0))) + HEAPF32[$1 + 588 >> 2]), + HEAPF32[wasm2js_i32$0 + 588 >> 2] = wasm2js_f32$0; + $2 = HEAPF32[$1 + 608 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 68 | 0, $1 + 108 | 0, $1 + 100 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 76 | 0, $2, $1 + 68 | 0); + b2Vec2__operator___28b2Vec2_20const__29($1 + 576 | 0, $1 + 76 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$1 + 604 >> 2] * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 372 >> 2] + 8 | 0, $1 + 108 | 0) + b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 368 >> 2] + 8 | 0, $1 + 100 | 0))) + HEAPF32[$1 + 572 >> 2]), + HEAPF32[wasm2js_i32$0 + 572 >> 2] = wasm2js_f32$0; + HEAPF32[HEAP32[$1 + 372 >> 2] + 16 >> 2] = HEAPF32[$1 + 244 >> 2]; + HEAPF32[HEAP32[$1 + 368 >> 2] + 16 >> 2] = HEAPF32[$1 + 248 >> 2]; + break label$13; + } + HEAPF32[$1 + 244 >> 2] = 0; + HEAPF32[$1 + 248 >> 2] = 0; + HEAPF32[$1 + 276 >> 2] = HEAPF32[$1 + 264 >> 2]; + HEAPF32[$1 + 272 >> 2] = HEAPF32[$1 + 268 >> 2]; + if (!(!(HEAPF32[$1 + 276 >> 2] >= Math_fround(0)) | !(HEAPF32[$1 + 272 >> 2] >= Math_fround(0)))) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 60 | 0, $1 + 244 | 0, $1 + 360 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 52 | 0, HEAPF32[$1 + 60 >> 2], $1 + 560 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 44 | 0, HEAPF32[$1 + 64 >> 2], $1 + 560 | 0); + $2 = HEAPF32[$1 + 616 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 28 | 0, $1 + 52 | 0, $1 + 44 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 36 | 0, $2, $1 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($1 + 592 | 0, $1 + 36 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$1 + 612 >> 2]) * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 372 >> 2], $1 + 52 | 0) + b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 368 >> 2], $1 + 44 | 0))) + HEAPF32[$1 + 588 >> 2]), + HEAPF32[wasm2js_i32$0 + 588 >> 2] = wasm2js_f32$0; + $2 = HEAPF32[$1 + 608 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 12 | 0, $1 + 52 | 0, $1 + 44 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 20 | 0, $2, $1 + 12 | 0); + b2Vec2__operator___28b2Vec2_20const__29($1 + 576 | 0, $1 + 20 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$1 + 604 >> 2] * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 372 >> 2] + 8 | 0, $1 + 52 | 0) + b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 368 >> 2] + 8 | 0, $1 + 44 | 0))) + HEAPF32[$1 + 572 >> 2]), + HEAPF32[wasm2js_i32$0 + 572 >> 2] = wasm2js_f32$0; + HEAPF32[HEAP32[$1 + 372 >> 2] + 16 >> 2] = HEAPF32[$1 + 244 >> 2]; + HEAPF32[HEAP32[$1 + 368 >> 2] + 16 >> 2] = HEAPF32[$1 + 248 >> 2]; + } + } + } + $0 = HEAP32[$1 + 596 >> 2]; + $4 = HEAP32[$1 + 592 >> 2]; + $3 = $4; + $4 = HEAP32[$5 + 28 >> 2] + Math_imul(HEAP32[$1 + 624 >> 2], 12) | 0; + HEAP32[$4 >> 2] = $3; + HEAP32[$4 + 4 >> 2] = $0; + HEAPF32[(HEAP32[$5 + 28 >> 2] + Math_imul(HEAP32[$1 + 624 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$1 + 588 >> 2]; + $4 = HEAP32[$1 + 580 >> 2]; + $0 = HEAP32[$1 + 576 >> 2]; + $3 = $0; + $0 = HEAP32[$5 + 28 >> 2] + Math_imul(HEAP32[$1 + 620 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $3; + HEAP32[$0 + 4 >> 2] = $4; + HEAPF32[(HEAP32[$5 + 28 >> 2] + Math_imul(HEAP32[$1 + 620 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$1 + 572 >> 2]; + HEAP32[$1 + 632 >> 2] = HEAP32[$1 + 632 >> 2] + 1; + continue; + } + break; + } + __stack_pointer = $1 + 640 | 0; +} + +function b2CollideEdgeAndPolygon_28b2Manifold__2c_20b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__29($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0), wasm2js_i32$1 = 0; + $5 = __stack_pointer - 608 | 0; + __stack_pointer = $5; + HEAP32[$5 + 604 >> 2] = $0; + HEAP32[$5 + 600 >> 2] = $1; + HEAP32[$5 + 596 >> 2] = $2; + HEAP32[$5 + 592 >> 2] = $3; + HEAP32[$5 + 588 >> 2] = $4; + HEAP32[HEAP32[$5 + 604 >> 2] + 60 >> 2] = 0; + b2MulT_28b2Transform_20const__2c_20b2Transform_20const__29($5 + 572 | 0, HEAP32[$5 + 596 >> 2], HEAP32[$5 + 588 >> 2]); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 564 | 0, $5 + 572 | 0, HEAP32[$5 + 592 >> 2] + 12 | 0); + $2 = HEAP32[$5 + 600 >> 2]; + $1 = HEAP32[$2 + 12 >> 2]; + $0 = HEAP32[$2 + 16 >> 2]; + HEAP32[$5 + 552 >> 2] = $1; + HEAP32[$5 + 556 >> 2] = $0; + $2 = HEAP32[$5 + 600 >> 2]; + $0 = HEAP32[$2 + 20 >> 2]; + $1 = HEAP32[$2 + 24 >> 2]; + HEAP32[$5 + 544 >> 2] = $0; + HEAP32[$5 + 548 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 536 | 0, $5 + 544 | 0, $5 + 552 | 0); + b2Vec2__Normalize_28_29($5 + 536 | 0); + b2Vec2__b2Vec2_28float_2c_20float_29($5 + 528 | 0, HEAPF32[$5 + 540 >> 2], Math_fround(-HEAPF32[$5 + 536 >> 2])); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 516 | 0, $5 + 564 | 0, $5 + 552 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 528 | 0, $5 + 516 | 0), + HEAPF32[wasm2js_i32$0 + 524 >> 2] = wasm2js_f32$0; + HEAP8[$5 + 515 | 0] = HEAP8[HEAP32[$5 + 600 >> 2] + 44 | 0] & 1; + label$1: { + if (!(!(HEAP8[$5 + 515 | 0] & 1) | !(HEAPF32[$5 + 524 >> 2] < Math_fround(0)))) { + break label$1; + } + b2TempPolygon__b2TempPolygon_28_29($5 + 380 | 0); + HEAP32[$5 + 508 >> 2] = HEAP32[HEAP32[$5 + 592 >> 2] + 148 >> 2]; + HEAP32[$5 + 376 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 376 >> 2] < HEAP32[HEAP32[$5 + 592 >> 2] + 148 >> 2]) { + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 368 | 0, $5 + 572 | 0, (HEAP32[$5 + 592 >> 2] + 20 | 0) + (HEAP32[$5 + 376 >> 2] << 3) | 0); + $0 = HEAP32[$5 + 372 >> 2]; + $1 = HEAP32[$5 + 368 >> 2]; + $2 = $1; + $1 = ($5 + 380 | 0) + (HEAP32[$5 + 376 >> 2] << 3) | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($5 + 360 | 0, $5 + 580 | 0, (HEAP32[$5 + 592 >> 2] + 84 | 0) + (HEAP32[$5 + 376 >> 2] << 3) | 0); + $1 = HEAP32[$5 + 364 >> 2]; + $0 = HEAP32[$5 + 360 >> 2]; + $2 = $0; + $0 = ($5 + 444 | 0) + (HEAP32[$5 + 376 >> 2] << 3) | 0; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + HEAP32[$5 + 376 >> 2] = HEAP32[$5 + 376 >> 2] + 1; + continue; + } + break; + } + HEAPF32[$5 + 356 >> 2] = HEAPF32[HEAP32[$5 + 592 >> 2] + 8 >> 2] + HEAPF32[HEAP32[$5 + 600 >> 2] + 8 >> 2]; + b2ComputeEdgeSeparation_28b2TempPolygon_20const__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 336 | 0, $5 + 380 | 0, $5 + 552 | 0, $5 + 528 | 0); + if (HEAPF32[$5 + 352 >> 2] > HEAPF32[$5 + 356 >> 2]) { + break label$1; + } + b2ComputePolygonSeparation_28b2TempPolygon_20const__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 316 | 0, $5 + 380 | 0, $5 + 552 | 0, $5 + 544 | 0); + if (HEAPF32[$5 + 332 >> 2] > HEAPF32[$5 + 356 >> 2]) { + break label$1; + } + HEAPF32[$5 + 312 >> 2] = .9800000190734863; + HEAPF32[$5 + 308 >> 2] = .0010000000474974513; + b2EPAxis__b2EPAxis_28_29($5 + 288 | 0); + label$5: { + if (Math_fround(Math_fround(Math_fround(HEAPF32[$5 + 352 >> 2] - HEAPF32[$5 + 356 >> 2]) * Math_fround(.9800000190734863)) + Math_fround(.0010000000474974513)) < Math_fround(HEAPF32[$5 + 332 >> 2] - HEAPF32[$5 + 356 >> 2])) { + HEAP32[$5 + 304 >> 2] = HEAP32[$5 + 332 >> 2]; + $0 = HEAP32[$5 + 328 >> 2]; + $1 = HEAP32[$5 + 324 >> 2]; + HEAP32[$5 + 296 >> 2] = $1; + HEAP32[$5 + 300 >> 2] = $0; + $1 = HEAP32[$5 + 320 >> 2]; + $0 = HEAP32[$5 + 316 >> 2]; + HEAP32[$5 + 288 >> 2] = $0; + HEAP32[$5 + 292 >> 2] = $1; + break label$5; + } + HEAP32[$5 + 304 >> 2] = HEAP32[$5 + 352 >> 2]; + $0 = HEAP32[$5 + 348 >> 2]; + $1 = HEAP32[$5 + 344 >> 2]; + HEAP32[$5 + 296 >> 2] = $1; + HEAP32[$5 + 300 >> 2] = $0; + $1 = HEAP32[$5 + 340 >> 2]; + $0 = HEAP32[$5 + 336 >> 2]; + HEAP32[$5 + 288 >> 2] = $0; + HEAP32[$5 + 292 >> 2] = $1; + } + if (HEAP8[$5 + 515 | 0] & 1) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 280 | 0, $5 + 552 | 0, HEAP32[$5 + 600 >> 2] + 28 | 0); + b2Vec2__Normalize_28_29($5 + 280 | 0); + b2Vec2__b2Vec2_28float_2c_20float_29($5 + 272 | 0, HEAPF32[$5 + 284 >> 2], Math_fround(-HEAPF32[$5 + 280 >> 2])); + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 280 | 0, $5 + 536 | 0) >= Math_fround(0), + HEAP8[wasm2js_i32$0 + 271 | 0] = wasm2js_i32$1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 260 | 0, HEAP32[$5 + 600 >> 2] + 36 | 0, $5 + 544 | 0); + b2Vec2__Normalize_28_29($5 + 260 | 0); + b2Vec2__b2Vec2_28float_2c_20float_29($5 + 252 | 0, HEAPF32[$5 + 264 >> 2], Math_fround(-HEAPF32[$5 + 260 >> 2])); + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 536 | 0, $5 + 260 | 0) >= Math_fround(0), + HEAP8[wasm2js_i32$0 + 251 | 0] = wasm2js_i32$1; + HEAPF32[$5 + 244 >> 2] = .10000000149011612; + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 288 | 0, $5 + 536 | 0) <= Math_fround(0), + HEAP8[wasm2js_i32$0 + 243 | 0] = wasm2js_i32$1; + label$8: { + if (HEAP8[$5 + 243 | 0] & 1) { + if (HEAP8[$5 + 271 | 0] & 1) { + if (b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 288 | 0, $5 + 272 | 0) > Math_fround(.10000000149011612)) { + break label$1; + } + break label$8; + } + HEAP32[$5 + 304 >> 2] = HEAP32[$5 + 352 >> 2]; + $0 = HEAP32[$5 + 348 >> 2]; + $1 = HEAP32[$5 + 344 >> 2]; + HEAP32[$5 + 296 >> 2] = $1; + HEAP32[$5 + 300 >> 2] = $0; + $1 = HEAP32[$5 + 340 >> 2]; + $0 = HEAP32[$5 + 336 >> 2]; + HEAP32[$5 + 288 >> 2] = $0; + HEAP32[$5 + 292 >> 2] = $1; + break label$8; + } + label$11: { + if (HEAP8[$5 + 251 | 0] & 1) { + if (b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 252 | 0, $5 + 288 | 0) > Math_fround(.10000000149011612)) { + break label$1; + } + break label$11; + } + HEAP32[$5 + 304 >> 2] = HEAP32[$5 + 352 >> 2]; + $0 = HEAP32[$5 + 348 >> 2]; + $1 = HEAP32[$5 + 344 >> 2]; + HEAP32[$5 + 296 >> 2] = $1; + HEAP32[$5 + 300 >> 2] = $0; + $1 = HEAP32[$5 + 340 >> 2]; + $0 = HEAP32[$5 + 336 >> 2]; + HEAP32[$5 + 288 >> 2] = $0; + HEAP32[$5 + 292 >> 2] = $1; + } + } + } + $0 = $5 + 208 | 0; + $1 = $0 + 24 | 0; + while (1) { + b2ClipVertex__b2ClipVertex_28_29($0); + $0 = $0 + 12 | 0; + if (($1 | 0) != ($0 | 0)) { + continue; + } + break; + } + b2ReferenceFace__b2ReferenceFace_28_29($5 + 152 | 0); + label$14: { + if (HEAP32[$5 + 296 >> 2] == 1) { + HEAP32[HEAP32[$5 + 604 >> 2] + 56 >> 2] = 1; + HEAP32[$5 + 148 >> 2] = 0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 288 | 0, $5 + 444 | 0), + HEAPF32[wasm2js_i32$0 + 144 >> 2] = wasm2js_f32$0; + HEAP32[$5 + 140 >> 2] = 1; + while (1) { + if (HEAP32[$5 + 140 >> 2] < HEAP32[$5 + 508 >> 2]) { + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 288 | 0, ($5 + 444 | 0) + (HEAP32[$5 + 140 >> 2] << 3) | 0), + HEAPF32[wasm2js_i32$0 + 136 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 136 >> 2] < HEAPF32[$5 + 144 >> 2]) { + HEAPF32[$5 + 144 >> 2] = HEAPF32[$5 + 136 >> 2]; + HEAP32[$5 + 148 >> 2] = HEAP32[$5 + 140 >> 2]; + } + HEAP32[$5 + 140 >> 2] = HEAP32[$5 + 140 >> 2] + 1; + continue; + } + break; + } + HEAP32[$5 + 132 >> 2] = HEAP32[$5 + 148 >> 2]; + if (HEAP32[$5 + 508 >> 2] > (HEAP32[$5 + 132 >> 2] + 1 | 0)) { + $0 = HEAP32[$5 + 132 >> 2] + 1 | 0; + } else { + $0 = 0; + } + HEAP32[$5 + 128 >> 2] = $0; + $2 = ($5 + 380 | 0) + (HEAP32[$5 + 132 >> 2] << 3) | 0; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + $2 = $1; + $1 = $5 + 208 | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAP8[$5 + 216 | 0] = 0; + HEAP8[$5 + 217 | 0] = HEAP32[$5 + 132 >> 2]; + HEAP8[$5 + 218 | 0] = 1; + HEAP8[$5 + 219 | 0] = 0; + $2 = ($5 + 380 | 0) + (HEAP32[$5 + 128 >> 2] << 3) | 0; + $0 = HEAP32[$2 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + $2 = $0; + $0 = $5 + 208 | 0; + HEAP32[$0 + 12 >> 2] = $2; + HEAP32[$0 + 16 >> 2] = $1; + HEAP8[$5 + 228 | 0] = 0; + HEAP8[$5 + 229 | 0] = HEAP32[$5 + 128 >> 2]; + HEAP8[$5 + 230 | 0] = 1; + HEAP8[$5 + 231 | 0] = 0; + HEAP32[$5 + 152 >> 2] = 0; + HEAP32[$5 + 156 >> 2] = 1; + $0 = HEAP32[$5 + 556 >> 2]; + $1 = HEAP32[$5 + 552 >> 2]; + $2 = $1; + $1 = $5 + 152 | 0; + HEAP32[$1 + 8 >> 2] = $2; + HEAP32[$1 + 12 >> 2] = $0; + $1 = HEAP32[$5 + 548 >> 2]; + $0 = HEAP32[$5 + 544 >> 2]; + $2 = $0; + $0 = $5 + 152 | 0; + HEAP32[$0 + 16 >> 2] = $2; + HEAP32[$0 + 20 >> 2] = $1; + $2 = $5 + 288 | 0; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + $2 = $1; + $1 = $5 + 152 | 0; + HEAP32[$1 + 24 >> 2] = $2; + HEAP32[$1 + 28 >> 2] = $0; + b2Vec2__operator__28_29_20const($5 + 120 | 0, $5 + 536 | 0); + $1 = HEAP32[$5 + 124 >> 2]; + $0 = HEAP32[$5 + 120 >> 2]; + $2 = $0; + $0 = $5 + 152 | 0; + HEAP32[$0 + 32 >> 2] = $2; + HEAP32[$0 + 36 >> 2] = $1; + $0 = HEAP32[$5 + 540 >> 2]; + $1 = HEAP32[$5 + 536 >> 2]; + $2 = $1; + $1 = $5 + 152 | 0; + HEAP32[$1 + 44 >> 2] = $2; + HEAP32[$1 + 48 >> 2] = $0; + break label$14; + } + HEAP32[HEAP32[$5 + 604 >> 2] + 56 >> 2] = 2; + $1 = HEAP32[$5 + 548 >> 2]; + $0 = HEAP32[$5 + 544 >> 2]; + $2 = $0; + $0 = $5 + 208 | 0; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + HEAP8[$5 + 216 | 0] = 1; + HEAP8[$5 + 217 | 0] = HEAP32[$5 + 300 >> 2]; + HEAP8[$5 + 218 | 0] = 0; + HEAP8[$5 + 219 | 0] = 1; + $0 = HEAP32[$5 + 556 >> 2]; + $1 = HEAP32[$5 + 552 >> 2]; + $2 = $1; + $1 = $5 + 208 | 0; + HEAP32[$1 + 12 >> 2] = $2; + HEAP32[$1 + 16 >> 2] = $0; + HEAP8[$5 + 228 | 0] = 0; + HEAP8[$5 + 229 | 0] = HEAP32[$5 + 300 >> 2]; + HEAP8[$5 + 230 | 0] = 0; + HEAP8[$5 + 231 | 0] = 1; + HEAP32[$5 + 152 >> 2] = HEAP32[$5 + 300 >> 2]; + if (HEAP32[$5 + 508 >> 2] > (HEAP32[$5 + 152 >> 2] + 1 | 0)) { + $0 = HEAP32[$5 + 152 >> 2] + 1 | 0; + } else { + $0 = 0; + } + HEAP32[$5 + 156 >> 2] = $0; + $2 = ($5 + 380 | 0) + (HEAP32[$5 + 152 >> 2] << 3) | 0; + $0 = HEAP32[$2 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + $2 = $0; + $0 = $5 + 152 | 0; + HEAP32[$0 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $1; + $2 = ($5 + 380 | 0) + (HEAP32[$5 + 156 >> 2] << 3) | 0; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + $2 = $1; + $1 = $5 + 152 | 0; + HEAP32[$1 + 16 >> 2] = $2; + HEAP32[$1 + 20 >> 2] = $0; + $2 = ($5 + 444 | 0) + (HEAP32[$5 + 152 >> 2] << 3) | 0; + $0 = HEAP32[$2 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + $2 = $0; + $0 = $5 + 152 | 0; + HEAP32[$0 + 24 >> 2] = $2; + HEAP32[$0 + 28 >> 2] = $1; + b2Vec2__Set_28float_2c_20float_29($5 + 184 | 0, HEAPF32[$5 + 180 >> 2], Math_fround(-HEAPF32[$5 + 176 >> 2])); + b2Vec2__operator__28_29_20const($5 + 112 | 0, $5 + 184 | 0); + $0 = HEAP32[$5 + 116 >> 2]; + $1 = HEAP32[$5 + 112 >> 2]; + $2 = $1; + $1 = $5 + 152 | 0; + HEAP32[$1 + 44 >> 2] = $2; + HEAP32[$1 + 48 >> 2] = $0; + } + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 184 | 0, $5 + 160 | 0), + HEAPF32[wasm2js_i32$0 + 192 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 196 | 0, $5 + 168 | 0), + HEAPF32[wasm2js_i32$0 + 204 >> 2] = wasm2js_f32$0; + $0 = $5 + 80 | 0; + $1 = $0 + 24 | 0; + while (1) { + b2ClipVertex__b2ClipVertex_28_29($0); + $0 = $0 + 12 | 0; + if (($1 | 0) != ($0 | 0)) { + continue; + } + break; + } + $0 = $5 + 48 | 0; + $1 = $0 + 24 | 0; + while (1) { + b2ClipVertex__b2ClipVertex_28_29($0); + $0 = $0 + 12 | 0; + if (($1 | 0) != ($0 | 0)) { + continue; + } + break; + } + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2ClipSegmentToLine_28b2ClipVertex__2c_20b2ClipVertex_20const__2c_20b2Vec2_20const__2c_20float_2c_20int_29($5 + 80 | 0, $5 + 208 | 0, $5 + 184 | 0, HEAPF32[$5 + 192 >> 2], HEAP32[$5 + 152 >> 2]), + HEAP32[wasm2js_i32$0 + 44 >> 2] = wasm2js_i32$1; + if (HEAP32[$5 + 44 >> 2] < 2) { + break label$1; + } + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2ClipSegmentToLine_28b2ClipVertex__2c_20b2ClipVertex_20const__2c_20b2Vec2_20const__2c_20float_2c_20int_29($5 + 48 | 0, $5 + 80 | 0, $5 + 196 | 0, HEAPF32[$5 + 204 >> 2], HEAP32[$5 + 156 >> 2]), + HEAP32[wasm2js_i32$0 + 44 >> 2] = wasm2js_i32$1; + if (HEAP32[$5 + 44 >> 2] < 2) { + break label$1; + } + label$25: { + if (HEAP32[$5 + 296 >> 2] == 1) { + $2 = $5 + 152 | 0; + $0 = HEAP32[$2 + 24 >> 2]; + $1 = HEAP32[$2 + 28 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 604 >> 2]; + HEAP32[$0 + 40 >> 2] = $2; + HEAP32[$0 + 44 >> 2] = $1; + $2 = $5 + 152 | 0; + $1 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 604 >> 2]; + HEAP32[$1 + 48 >> 2] = $2; + HEAP32[$1 + 52 >> 2] = $0; + break label$25; + } + $2 = (HEAP32[$5 + 592 >> 2] + 84 | 0) + (HEAP32[$5 + 152 >> 2] << 3) | 0; + $0 = HEAP32[$2 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 604 >> 2]; + HEAP32[$0 + 40 >> 2] = $2; + HEAP32[$0 + 44 >> 2] = $1; + $2 = (HEAP32[$5 + 592 >> 2] + 20 | 0) + (HEAP32[$5 + 152 >> 2] << 3) | 0; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 604 >> 2]; + HEAP32[$1 + 48 >> 2] = $2; + HEAP32[$1 + 52 >> 2] = $0; + } + HEAP32[$5 + 40 >> 2] = 0; + HEAP32[$5 + 36 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 36 >> 2] < 2) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 24 | 0, ($5 + 48 | 0) + Math_imul(HEAP32[$5 + 36 >> 2], 12) | 0, $5 + 160 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 176 | 0, $5 + 24 | 0), + HEAPF32[wasm2js_i32$0 + 32 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 32 >> 2] <= HEAPF32[$5 + 356 >> 2]) { + HEAP32[$5 + 20 >> 2] = HEAP32[$5 + 604 >> 2] + Math_imul(HEAP32[$5 + 40 >> 2], 20); + label$30: { + if (HEAP32[$5 + 296 >> 2] == 1) { + b2MulT_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 12 | 0, $5 + 572 | 0, ($5 + 48 | 0) + Math_imul(HEAP32[$5 + 36 >> 2], 12) | 0); + $1 = HEAP32[$5 + 16 >> 2]; + $0 = HEAP32[$5 + 12 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 20 >> 2]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + HEAP32[HEAP32[$5 + 20 >> 2] + 16 >> 2] = HEAP32[(($5 + 48 | 0) + Math_imul(HEAP32[$5 + 36 >> 2], 12) | 0) + 8 >> 2]; + break label$30; + } + $2 = ($5 + 48 | 0) + Math_imul(HEAP32[$5 + 36 >> 2], 12) | 0; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 20 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAP8[HEAP32[$5 + 20 >> 2] + 18 | 0] = HEAPU8[(($5 + 48 | 0) + Math_imul(HEAP32[$5 + 36 >> 2], 12) | 0) + 11 | 0]; + HEAP8[HEAP32[$5 + 20 >> 2] + 19 | 0] = HEAPU8[(($5 + 48 | 0) + Math_imul(HEAP32[$5 + 36 >> 2], 12) | 0) + 10 | 0]; + HEAP8[HEAP32[$5 + 20 >> 2] + 16 | 0] = HEAPU8[(($5 + 48 | 0) + Math_imul(HEAP32[$5 + 36 >> 2], 12) | 0) + 9 | 0]; + HEAP8[HEAP32[$5 + 20 >> 2] + 17 | 0] = HEAPU8[(($5 + 48 | 0) + Math_imul(HEAP32[$5 + 36 >> 2], 12) | 0) + 8 | 0]; + } + HEAP32[$5 + 40 >> 2] = HEAP32[$5 + 40 >> 2] + 1; + } + HEAP32[$5 + 36 >> 2] = HEAP32[$5 + 36 >> 2] + 1; + continue; + } + break; + } + HEAP32[HEAP32[$5 + 604 >> 2] + 60 >> 2] = HEAP32[$5 + 40 >> 2]; + } + __stack_pointer = $5 + 608 | 0; +} + +function fmt_fp($0, $1, $2, $3, $4, $5) { + $0 = $0 | 0; + $1 = +$1; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + $5 = $5 | 0; + var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0; + $12 = __stack_pointer - 560 | 0; + __stack_pointer = $12; + HEAP32[$12 + 44 >> 2] = 0; + $9 = __DOUBLE_BITS($1); + $11 = i64toi32_i32$HIGH_BITS; + $14 = $11; + label$1: { + if (($11 | 0) < 0) { + $19 = 1; + $25 = 1775; + $1 = -$1; + $8 = __DOUBLE_BITS($1); + $11 = i64toi32_i32$HIGH_BITS; + $14 = $11; + break label$1; + } + if ($4 & 2048) { + $19 = 1; + $25 = 1778; + break label$1; + } + $19 = $4 & 1; + $25 = $19 ? 1781 : 1776; + $26 = !$19; + } + $11 = $14; + $8 = $11 & 2146435072; + $11 = 0; + label$4: { + if (!$11 & ($8 | 0) == 2146435072) { + $6 = $19 + 3 | 0; + pad($0, 32, $2, $6, $4 & -65537); + out($0, $25, $19); + $7 = $5 & 32; + out($0, $1 != $1 ? $7 ? 6920 : 10867 : $7 ? 7875 : 10880, 3); + pad($0, 32, $2, $6, $4 ^ 8192); + $9 = ($2 | 0) < ($6 | 0) ? $6 : $2; + break label$4; + } + $20 = $12 + 16 | 0; + label$6: { + label$7: { + label$8: { + $1 = frexp($1, $12 + 44 | 0); + $1 = $1 + $1; + if ($1 != 0) { + $6 = HEAP32[$12 + 44 >> 2]; + HEAP32[$12 + 44 >> 2] = $6 - 1; + $23 = $5 | 32; + if (($23 | 0) != 97) { + break label$8; + } + break label$6; + } + $23 = $5 | 32; + if (($23 | 0) == 97) { + break label$6; + } + $24 = HEAP32[$12 + 44 >> 2]; + $13 = ($3 | 0) < 0 ? 6 : $3; + break label$7; + } + $24 = $6 - 29 | 0; + HEAP32[$12 + 44 >> 2] = $24; + $1 = $1 * 268435456; + $13 = ($3 | 0) < 0 ? 6 : $3; + } + $17 = ($12 + 48 | 0) + (($24 | 0) >= 0 ? 288 : 0) | 0; + $7 = $17; + while (1) { + if ($1 < 4294967296 & $1 >= 0) { + $6 = ~~$1 >>> 0; + } else { + $6 = 0; + } + HEAP32[$7 >> 2] = $6; + $7 = $7 + 4 | 0; + $1 = ($1 - +($6 >>> 0)) * 1e9; + if ($1 != 0) { + continue; + } + break; + } + label$13: { + if (($24 | 0) <= 0) { + $3 = $24; + $6 = $7; + $10 = $17; + break label$13; + } + $10 = $17; + $3 = $24; + while (1) { + $3 = ($3 | 0) >= 29 ? 29 : $3; + $6 = $7 - 4 | 0; + label$16: { + if ($10 >>> 0 > $6 >>> 0) { + break label$16; + } + $21 = 0; + while (1) { + $9 = $21; + $8 = HEAP32[$6 >> 2]; + $11 = $8; + $22 = $3; + $15 = $22 & 31; + if (($22 & 63) >>> 0 >= 32) { + $8 = $11 << $15; + $22 = 0; + } else { + $8 = (1 << $15) - 1 & $11 >>> 32 - $15; + $22 = $11 << $15; + } + $15 = $9 + $22 | 0; + $11 = $8; + $8 = $16; + $8 = $11 + $8 | 0; + $8 = $15 >>> 0 < $22 >>> 0 ? $8 + 1 | 0 : $8; + $27 = $8; + $9 = __wasm_i64_udiv($15, $8, 1e9, 0); + $8 = i64toi32_i32$HIGH_BITS; + $14 = $8; + $21 = $9; + $9 = __wasm_i64_mul($9, $8, 1e9, 0); + $8 = i64toi32_i32$HIGH_BITS; + $28 = $8; + $22 = $9; + $11 = $15 - $9 | 0; + $8 = $27; + $9 = $28; + $15 = $9 + ($15 >>> 0 < $22 >>> 0) | 0; + HEAP32[$6 >> 2] = $11; + $6 = $6 - 4 | 0; + if ($10 >>> 0 <= $6 >>> 0) { + continue; + } + break; + } + $6 = $21; + if (!$6) { + break label$16; + } + $10 = $10 - 4 | 0; + HEAP32[$10 >> 2] = $6; + } + while (1) { + $6 = $7; + if ($10 >>> 0 < $6 >>> 0) { + $7 = $6 - 4 | 0; + if (!HEAP32[$7 >> 2]) { + continue; + } + } + break; + } + $3 = HEAP32[$12 + 44 >> 2] - $3 | 0; + HEAP32[$12 + 44 >> 2] = $3; + $7 = $6; + if (($3 | 0) > 0) { + continue; + } + break; + } + } + if (($3 | 0) < 0) { + $16 = (($13 + 25 >>> 0) / 9 | 0) + 1 | 0; + $21 = ($23 | 0) == 102; + while (1) { + $7 = 0 - $3 | 0; + $8 = ($7 | 0) >= 9 ? 9 : $7; + label$22: { + if ($6 >>> 0 <= $10 >>> 0) { + $7 = HEAP32[$10 >> 2]; + break label$22; + } + $14 = 1e9 >>> $8 | 0; + $11 = -1 << $8 ^ -1; + $3 = 0; + $7 = $10; + while (1) { + $9 = HEAP32[$7 >> 2]; + HEAP32[$7 >> 2] = ($9 >>> $8 | 0) + $3; + $3 = Math_imul($9 & $11, $14); + $7 = $7 + 4 | 0; + if ($7 >>> 0 < $6 >>> 0) { + continue; + } + break; + } + $7 = HEAP32[$10 >> 2]; + if (!$3) { + break label$22; + } + HEAP32[$6 >> 2] = $3; + $6 = $6 + 4 | 0; + } + $3 = HEAP32[$12 + 44 >> 2] + $8 | 0; + HEAP32[$12 + 44 >> 2] = $3; + $10 = (!$7 << 2) + $10 | 0; + $7 = $21 ? $17 : $10; + $6 = $6 - $7 >> 2 > ($16 | 0) ? $7 + ($16 << 2) | 0 : $6; + if (($3 | 0) < 0) { + continue; + } + break; + } + } + $3 = 0; + label$25: { + if ($6 >>> 0 <= $10 >>> 0) { + break label$25; + } + $3 = Math_imul($17 - $10 >> 2, 9); + $7 = 10; + $9 = HEAP32[$10 >> 2]; + if ($9 >>> 0 < 10) { + break label$25; + } + while (1) { + $3 = $3 + 1 | 0; + $7 = Math_imul($7, 10); + if ($9 >>> 0 >= $7 >>> 0) { + continue; + } + break; + } + } + $7 = ($13 - (($23 | 0) != 102 ? $3 : 0) | 0) - (($23 | 0) == 103 & ($13 | 0) != 0) | 0; + if (($7 | 0) < (Math_imul($6 - $17 >> 2, 9) - 9 | 0)) { + $9 = $7 + 9216 | 0; + $14 = ($9 | 0) / 9 | 0; + $8 = (((($24 | 0) < 0 ? 4 : 292) + $12 | 0) + ($14 << 2) | 0) - 4048 | 0; + $7 = 10; + $9 = $9 - Math_imul($14, 9) | 0; + if (($9 | 0) <= 7) { + while (1) { + $7 = Math_imul($7, 10); + $9 = $9 + 1 | 0; + if (($9 | 0) != 8) { + continue; + } + break; + } + } + $9 = HEAP32[$8 >> 2]; + $16 = ($9 >>> 0) / ($7 >>> 0) | 0; + $14 = $9 - Math_imul($7, $16) | 0; + $11 = $8 + 4 | 0; + label$30: { + if (!$14 & ($11 | 0) == ($6 | 0)) { + break label$30; + } + label$31: { + if (!($16 & 1)) { + $1 = 9007199254740992; + if (!(HEAP8[$8 - 4 | 0] & 1) | (($7 | 0) != 1e9 | $10 >>> 0 >= $8 >>> 0)) { + break label$31; + } + } + $1 = 9007199254740994; + } + $18 = ($6 | 0) == ($11 | 0) ? 1 : 1.5; + $11 = $7 >>> 1 | 0; + $18 = $14 >>> 0 < $11 >>> 0 ? .5 : ($11 | 0) == ($14 | 0) ? $18 : 1.5; + if (!(HEAPU8[$25 | 0] != 45 | $26)) { + $18 = -$18; + $1 = -$1; + } + $9 = $9 - $14 | 0; + HEAP32[$8 >> 2] = $9; + if ($1 + $18 == $1) { + break label$30; + } + $7 = $7 + $9 | 0; + HEAP32[$8 >> 2] = $7; + if ($7 >>> 0 >= 1e9) { + while (1) { + HEAP32[$8 >> 2] = 0; + $8 = $8 - 4 | 0; + if ($8 >>> 0 < $10 >>> 0) { + $10 = $10 - 4 | 0; + HEAP32[$10 >> 2] = 0; + } + $7 = HEAP32[$8 >> 2] + 1 | 0; + HEAP32[$8 >> 2] = $7; + if ($7 >>> 0 > 999999999) { + continue; + } + break; + } + } + $3 = Math_imul($17 - $10 >> 2, 9); + $7 = 10; + $9 = HEAP32[$10 >> 2]; + if ($9 >>> 0 < 10) { + break label$30; + } + while (1) { + $3 = $3 + 1 | 0; + $7 = Math_imul($7, 10); + if ($9 >>> 0 >= $7 >>> 0) { + continue; + } + break; + } + } + $7 = $8 + 4 | 0; + $6 = $6 >>> 0 > $7 >>> 0 ? $7 : $6; + } + while (1) { + $7 = $6; + $9 = $6 >>> 0 <= $10 >>> 0; + if (!$9) { + $6 = $7 - 4 | 0; + if (!HEAP32[$6 >> 2]) { + continue; + } + } + break; + } + label$40: { + if (($23 | 0) != 103) { + $8 = $4 & 8; + break label$40; + } + $6 = $13 ? $13 : 1; + $8 = ($6 | 0) > ($3 | 0) & ($3 | 0) > -5; + $13 = ($8 ? $3 ^ -1 : -1) + $6 | 0; + $5 = ($8 ? -1 : -2) + $5 | 0; + $8 = $4 & 8; + if ($8) { + break label$40; + } + $6 = -9; + label$42: { + if ($9) { + break label$42; + } + $8 = HEAP32[$7 - 4 >> 2]; + if (!$8) { + break label$42; + } + $9 = 10; + $6 = 0; + if (($8 >>> 0) % 10 | 0) { + break label$42; + } + while (1) { + $14 = $6; + $6 = $6 + 1 | 0; + $9 = Math_imul($9, 10); + if (!(($8 >>> 0) % ($9 >>> 0) | 0)) { + continue; + } + break; + } + $6 = $14 ^ -1; + } + $9 = Math_imul($7 - $17 >> 2, 9); + if (($5 & -33) == 70) { + $8 = 0; + $6 = ($6 + $9 | 0) - 9 | 0; + $6 = ($6 | 0) > 0 ? $6 : 0; + $13 = ($6 | 0) > ($13 | 0) ? $13 : $6; + break label$40; + } + $8 = 0; + $6 = (($3 + $9 | 0) + $6 | 0) - 9 | 0; + $6 = ($6 | 0) > 0 ? $6 : 0; + $13 = ($6 | 0) > ($13 | 0) ? $13 : $6; + } + $9 = -1; + $14 = $8 | $13; + if ((($14 ? 2147483645 : 2147483646) | 0) < ($13 | 0)) { + break label$4; + } + $11 = ((($14 | 0) != 0) + $13 | 0) + 1 | 0; + $21 = $5 & -33; + label$45: { + if (($21 | 0) == 70) { + if (($11 ^ 2147483647) < ($3 | 0)) { + break label$4; + } + $6 = ($3 | 0) > 0 ? $3 : 0; + break label$45; + } + $6 = $3 >> 31; + $6 = fmt_u(($6 ^ $3) - $6 | 0, 0, $20); + if (($20 - $6 | 0) <= 1) { + while (1) { + $6 = $6 - 1 | 0; + HEAP8[$6 | 0] = 48; + if (($20 - $6 | 0) < 2) { + continue; + } + break; + } + } + $16 = $6 - 2 | 0; + HEAP8[$16 | 0] = $5; + HEAP8[$6 - 1 | 0] = ($3 | 0) < 0 ? 45 : 43; + $6 = $20 - $16 | 0; + if (($6 | 0) > ($11 ^ 2147483647)) { + break label$4; + } + } + $6 = $6 + $11 | 0; + if (($6 | 0) > ($19 ^ 2147483647)) { + break label$4; + } + $11 = $6 + $19 | 0; + pad($0, 32, $2, $11, $4); + out($0, $25, $19); + pad($0, 48, $2, $11, $4 ^ 65536); + label$49: { + label$50: { + label$51: { + if (($21 | 0) == 70) { + $8 = $12 + 16 | 8; + $3 = $12 + 16 | 9; + $9 = $10 >>> 0 > $17 >>> 0 ? $17 : $10; + $10 = $9; + while (1) { + $15 = HEAP32[$10 >> 2]; + $6 = fmt_u($15, 0, $3); + label$54: { + if (($10 | 0) != ($9 | 0)) { + if ($12 + 16 >>> 0 >= $6 >>> 0) { + break label$54; + } + while (1) { + $6 = $6 - 1 | 0; + HEAP8[$6 | 0] = 48; + if ($12 + 16 >>> 0 < $6 >>> 0) { + continue; + } + break; + } + break label$54; + } + if (($3 | 0) != ($6 | 0)) { + break label$54; + } + HEAP8[$12 + 24 | 0] = 48; + $6 = $8; + } + out($0, $6, $3 - $6 | 0); + $10 = $10 + 4 | 0; + if ($17 >>> 0 >= $10 >>> 0) { + continue; + } + break; + } + if ($14) { + out($0, 12340, 1); + } + if (($13 | 0) <= 0 | $7 >>> 0 <= $10 >>> 0) { + break label$51; + } + while (1) { + $8 = HEAP32[$10 >> 2]; + $6 = fmt_u($8, 0, $3); + if ($6 >>> 0 > $12 + 16 >>> 0) { + while (1) { + $6 = $6 - 1 | 0; + HEAP8[$6 | 0] = 48; + if ($12 + 16 >>> 0 < $6 >>> 0) { + continue; + } + break; + } + } + out($0, $6, ($13 | 0) >= 9 ? 9 : $13); + $6 = $13 - 9 | 0; + $10 = $10 + 4 | 0; + if ($10 >>> 0 >= $7 >>> 0) { + break label$50; + } + $9 = ($13 | 0) > 9; + $13 = $6; + if ($9) { + continue; + } + break; + } + break label$50; + } + label$61: { + if (($13 | 0) < 0) { + break label$61; + } + $14 = $7 >>> 0 > $10 >>> 0 ? $7 : $10 + 4 | 0; + $17 = $12 + 16 | 8; + $3 = $12 + 16 | 9; + $7 = $10; + while (1) { + $15 = HEAP32[$7 >> 2]; + $6 = fmt_u($15, 0, $3); + if (($6 | 0) == ($3 | 0)) { + HEAP8[$12 + 24 | 0] = 48; + $6 = $17; + } + label$64: { + if (($7 | 0) != ($10 | 0)) { + if ($12 + 16 >>> 0 >= $6 >>> 0) { + break label$64; + } + while (1) { + $6 = $6 - 1 | 0; + HEAP8[$6 | 0] = 48; + if ($12 + 16 >>> 0 < $6 >>> 0) { + continue; + } + break; + } + break label$64; + } + out($0, $6, 1); + $6 = $6 + 1 | 0; + if (!($8 | $13)) { + break label$64; + } + out($0, 12340, 1); + } + $9 = $3 - $6 | 0; + out($0, $6, ($9 | 0) > ($13 | 0) ? $13 : $9); + $13 = $13 - $9 | 0; + $7 = $7 + 4 | 0; + if ($14 >>> 0 <= $7 >>> 0) { + break label$61; + } + if (($13 | 0) >= 0) { + continue; + } + break; + } + } + pad($0, 48, $13 + 18 | 0, 18, 0); + out($0, $16, $20 - $16 | 0); + break label$49; + } + $6 = $13; + } + pad($0, 48, $6 + 9 | 0, 9, 0); + } + pad($0, 32, $2, $11, $4 ^ 8192); + $9 = ($2 | 0) < ($11 | 0) ? $11 : $2; + break label$4; + } + $11 = ($5 << 26 >> 31 & 9) + $25 | 0; + label$67: { + if ($3 >>> 0 > 11) { + break label$67; + } + $6 = 12 - $3 | 0; + $18 = 16; + while (1) { + $18 = $18 * 16; + $6 = $6 - 1 | 0; + if ($6) { + continue; + } + break; + } + if (HEAPU8[$11 | 0] == 45) { + $1 = -($18 + (-$1 - $18)); + break label$67; + } + $1 = $1 + $18 - $18; + } + $6 = HEAP32[$12 + 44 >> 2]; + $7 = $6; + $6 = $6 >> 31; + $6 = fmt_u(($7 ^ $6) - $6 | 0, 0, $20); + if (($20 | 0) == ($6 | 0)) { + HEAP8[$12 + 15 | 0] = 48; + $6 = $12 + 15 | 0; + } + $8 = $19 | 2; + $10 = $5 & 32; + $7 = HEAP32[$12 + 44 >> 2]; + $14 = $6 - 2 | 0; + HEAP8[$14 | 0] = $5 + 15; + HEAP8[$6 - 1 | 0] = ($7 | 0) < 0 ? 45 : 43; + $9 = $4 & 8; + $7 = $12 + 16 | 0; + while (1) { + $6 = $7; + if (Math_abs($1) < 2147483648) { + $7 = ~~$1; + } else { + $7 = -2147483648; + } + HEAP8[$6 | 0] = HEAPU8[$7 + 23872 | 0] | $10; + $1 = ($1 - +($7 | 0)) * 16; + $7 = $6 + 1 | 0; + if (!(!(($3 | 0) > 0 | $9) & $1 == 0 | ($7 - ($12 + 16 | 0) | 0) != 1)) { + HEAP8[$6 + 1 | 0] = 46; + $7 = $6 + 2 | 0; + } + if ($1 != 0) { + continue; + } + break; + } + $9 = -1; + $10 = $20 - $14 | 0; + $16 = $8 + $10 | 0; + if ((2147483645 - $16 | 0) < ($3 | 0)) { + break label$4; + } + $6 = $7 - ($12 + 16 | 0) | 0; + $3 = $3 ? ($6 - 2 | 0) < ($3 | 0) ? $3 + 2 | 0 : $6 : $6; + $7 = $16 + $3 | 0; + pad($0, 32, $2, $7, $4); + out($0, $11, $8); + pad($0, 48, $2, $7, $4 ^ 65536); + out($0, $12 + 16 | 0, $6); + pad($0, 48, $3 - $6 | 0, 0, 0); + out($0, $14, $10); + pad($0, 32, $2, $7, $4 ^ 8192); + $9 = ($2 | 0) < ($7 | 0) ? $7 : $2; + } + __stack_pointer = $12 + 560 | 0; + return $9 | 0; +} + +function b2Island__Solve_28b2Profile__2c_20b2TimeStep_20const__2c_20b2Vec2_20const__2c_20bool_29($0, $1, $2, $3, $4) { + var $5 = 0, $6 = 0, $7 = Math_fround(0), $8 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0), wasm2js_i32$1 = 0; + $5 = __stack_pointer - 352 | 0; + __stack_pointer = $5; + HEAP32[$5 + 348 >> 2] = $0; + HEAP32[$5 + 344 >> 2] = $1; + HEAP32[$5 + 340 >> 2] = $2; + HEAP32[$5 + 336 >> 2] = $3; + HEAP8[$5 + 335 | 0] = $4; + $6 = HEAP32[$5 + 348 >> 2]; + b2Timer__b2Timer_28_29($5 + 334 | 0); + HEAPF32[$5 + 328 >> 2] = HEAPF32[HEAP32[$5 + 340 >> 2] >> 2]; + HEAP32[$5 + 324 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 324 >> 2] < HEAP32[$6 + 28 >> 2]) { + HEAP32[$5 + 320 >> 2] = HEAP32[HEAP32[$6 + 8 >> 2] + (HEAP32[$5 + 324 >> 2] << 2) >> 2]; + $2 = HEAP32[$5 + 320 >> 2]; + $0 = HEAP32[$2 + 44 >> 2]; + $1 = HEAP32[$2 + 48 >> 2]; + HEAP32[$5 + 312 >> 2] = $0; + HEAP32[$5 + 316 >> 2] = $1; + HEAPF32[$5 + 308 >> 2] = HEAPF32[HEAP32[$5 + 320 >> 2] + 56 >> 2]; + $2 = HEAP32[$5 + 320 >> 2]; + $1 = HEAP32[$2 + 64 >> 2]; + $0 = HEAP32[$2 + 68 >> 2]; + HEAP32[$5 + 296 >> 2] = $1; + HEAP32[$5 + 300 >> 2] = $0; + HEAPF32[$5 + 292 >> 2] = HEAPF32[HEAP32[$5 + 320 >> 2] + 72 >> 2]; + $2 = HEAP32[$5 + 320 >> 2]; + $0 = HEAP32[$2 + 44 >> 2]; + $1 = HEAP32[$2 + 48 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 320 >> 2]; + HEAP32[$0 + 36 >> 2] = $2; + HEAP32[$0 + 40 >> 2] = $1; + HEAPF32[HEAP32[$5 + 320 >> 2] + 52 >> 2] = HEAPF32[HEAP32[$5 + 320 >> 2] + 56 >> 2]; + if (HEAP32[HEAP32[$5 + 320 >> 2] >> 2] == 2) { + $7 = HEAPF32[$5 + 328 >> 2]; + $8 = HEAPF32[HEAP32[$5 + 320 >> 2] + 120 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($5 + 268 | 0, Math_fround(HEAPF32[HEAP32[$5 + 320 >> 2] + 140 >> 2] * HEAPF32[HEAP32[$5 + 320 >> 2] + 116 >> 2]), HEAP32[$5 + 336 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($5 + 276 | 0, $5 + 268 | 0, HEAP32[$5 + 320 >> 2] + 76 | 0); + operator__28float_2c_20b2Vec2_20const__29($5 + 284 | 0, Math_fround($7 * $8), $5 + 276 | 0); + b2Vec2__operator___28b2Vec2_20const__29($5 + 296 | 0, $5 + 284 | 0); + HEAPF32[$5 + 292 >> 2] = Math_fround(Math_fround(HEAPF32[$5 + 328 >> 2] * HEAPF32[HEAP32[$5 + 320 >> 2] + 128 >> 2]) * HEAPF32[HEAP32[$5 + 320 >> 2] + 84 >> 2]) + HEAPF32[$5 + 292 >> 2]; + b2Vec2__operator___28float_29($5 + 296 | 0, Math_fround(Math_fround(1) / Math_fround(Math_fround(HEAPF32[$5 + 328 >> 2] * HEAPF32[HEAP32[$5 + 320 >> 2] + 132 >> 2]) + Math_fround(1)))); + HEAPF32[$5 + 292 >> 2] = HEAPF32[$5 + 292 >> 2] * Math_fround(Math_fround(1) / Math_fround(Math_fround(HEAPF32[$5 + 328 >> 2] * HEAPF32[HEAP32[$5 + 320 >> 2] + 136 >> 2]) + Math_fround(1))); + } + $0 = HEAP32[$5 + 316 >> 2]; + $1 = HEAP32[$5 + 312 >> 2]; + $2 = $1; + $1 = HEAP32[$6 + 20 >> 2] + Math_imul(HEAP32[$5 + 324 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[$6 + 20 >> 2] + Math_imul(HEAP32[$5 + 324 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$5 + 308 >> 2]; + $1 = HEAP32[$5 + 300 >> 2]; + $0 = HEAP32[$5 + 296 >> 2]; + $2 = $0; + $0 = HEAP32[$6 + 24 >> 2] + Math_imul(HEAP32[$5 + 324 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[$6 + 24 >> 2] + Math_imul(HEAP32[$5 + 324 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$5 + 292 >> 2]; + HEAP32[$5 + 324 >> 2] = HEAP32[$5 + 324 >> 2] + 1; + continue; + } + break; + } + b2Timer__Reset_28_29($5 + 334 | 0); + $2 = HEAP32[$5 + 340 >> 2]; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + $4 = $1; + $3 = $5 + 236 | 0; + $1 = $3; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + $1 = HEAP32[$2 + 20 >> 2]; + $0 = HEAP32[$2 + 16 >> 2]; + $4 = $0; + $0 = $3; + HEAP32[$0 + 16 >> 2] = $4; + HEAP32[$0 + 20 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$2 + 8 >> 2]; + $2 = $1; + $1 = $3; + HEAP32[$1 + 8 >> 2] = $2; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$5 + 260 >> 2] = HEAP32[$6 + 20 >> 2]; + HEAP32[$5 + 264 >> 2] = HEAP32[$6 + 24 >> 2]; + $2 = HEAP32[$5 + 340 >> 2]; + $0 = HEAP32[$2 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + $4 = $0; + $3 = $5 + 192 | 0; + $0 = $3; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + $0 = HEAP32[$2 + 20 >> 2]; + $1 = HEAP32[$2 + 16 >> 2]; + $4 = $1; + $1 = $3; + HEAP32[$1 + 16 >> 2] = $4; + HEAP32[$1 + 20 >> 2] = $0; + $1 = HEAP32[$2 + 12 >> 2]; + $0 = HEAP32[$2 + 8 >> 2]; + $2 = $0; + $0 = $3; + HEAP32[$0 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $1; + HEAP32[$5 + 216 >> 2] = HEAP32[$6 + 12 >> 2]; + HEAP32[$5 + 220 >> 2] = HEAP32[$6 + 36 >> 2]; + HEAP32[$5 + 224 >> 2] = HEAP32[$6 + 20 >> 2]; + HEAP32[$5 + 228 >> 2] = HEAP32[$6 + 24 >> 2]; + HEAP32[$5 + 232 >> 2] = HEAP32[$6 >> 2]; + b2ContactSolver__b2ContactSolver_28b2ContactSolverDef__29($5 + 140 | 0, $5 + 192 | 0); + b2ContactSolver__InitializeVelocityConstraints_28_29($5 + 140 | 0); + if (HEAP8[HEAP32[$5 + 340 >> 2] + 20 | 0] & 1) { + b2ContactSolver__WarmStart_28_29($5 + 140 | 0); + } + HEAP32[$5 + 136 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 136 >> 2] < HEAP32[$6 + 32 >> 2]) { + $0 = HEAP32[HEAP32[$6 + 16 >> 2] + (HEAP32[$5 + 136 >> 2] << 2) >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 36 >> 2]]($0, $5 + 236 | 0); + HEAP32[$5 + 136 >> 2] = HEAP32[$5 + 136 >> 2] + 1; + continue; + } + break; + } + $7 = b2Timer__GetMilliseconds_28_29_20const($5 + 334 | 0); + HEAPF32[HEAP32[$5 + 344 >> 2] + 12 >> 2] = $7; + b2Timer__Reset_28_29($5 + 334 | 0); + HEAP32[$5 + 132 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 132 >> 2] < HEAP32[HEAP32[$5 + 340 >> 2] + 12 >> 2]) { + HEAP32[$5 + 128 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 128 >> 2] < HEAP32[$6 + 32 >> 2]) { + $0 = HEAP32[HEAP32[$6 + 16 >> 2] + (HEAP32[$5 + 128 >> 2] << 2) >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 40 >> 2]]($0, $5 + 236 | 0); + HEAP32[$5 + 128 >> 2] = HEAP32[$5 + 128 >> 2] + 1; + continue; + } + break; + } + b2ContactSolver__SolveVelocityConstraints_28_29($5 + 140 | 0); + HEAP32[$5 + 132 >> 2] = HEAP32[$5 + 132 >> 2] + 1; + continue; + } + break; + } + b2ContactSolver__StoreImpulses_28_29($5 + 140 | 0); + $7 = b2Timer__GetMilliseconds_28_29_20const($5 + 334 | 0); + HEAPF32[HEAP32[$5 + 344 >> 2] + 16 >> 2] = $7; + HEAP32[$5 + 124 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 124 >> 2] < HEAP32[$6 + 28 >> 2]) { + $2 = HEAP32[$6 + 20 >> 2] + Math_imul(HEAP32[$5 + 124 >> 2], 12) | 0; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + HEAP32[$5 + 112 >> 2] = $1; + HEAP32[$5 + 116 >> 2] = $0; + HEAPF32[$5 + 108 >> 2] = HEAPF32[(HEAP32[$6 + 20 >> 2] + Math_imul(HEAP32[$5 + 124 >> 2], 12) | 0) + 8 >> 2]; + $2 = HEAP32[$6 + 24 >> 2] + Math_imul(HEAP32[$5 + 124 >> 2], 12) | 0; + $0 = HEAP32[$2 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + HEAP32[$5 + 96 >> 2] = $0; + HEAP32[$5 + 100 >> 2] = $1; + HEAPF32[$5 + 92 >> 2] = HEAPF32[(HEAP32[$6 + 24 >> 2] + Math_imul(HEAP32[$5 + 124 >> 2], 12) | 0) + 8 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($5 + 84 | 0, HEAPF32[$5 + 328 >> 2], $5 + 96 | 0); + $0 = $5 + 84 | 0; + if (b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $0) > Math_fround(4)) { + wasm2js_i32$0 = $5, wasm2js_f32$0 = Math_fround(Math_fround(2) / b2Vec2__Length_28_29_20const($5 + 84 | 0)), + HEAPF32[wasm2js_i32$0 + 80 >> 2] = wasm2js_f32$0; + b2Vec2__operator___28float_29($5 + 96 | 0, HEAPF32[$5 + 80 >> 2]); + } + HEAPF32[$5 + 76 >> 2] = HEAPF32[$5 + 328 >> 2] * HEAPF32[$5 + 92 >> 2]; + if (Math_fround(HEAPF32[$5 + 76 >> 2] * HEAPF32[$5 + 76 >> 2]) > Math_fround(2.4674012660980225)) { + wasm2js_i32$0 = $5, wasm2js_f32$0 = Math_fround(Math_fround(1.5707963705062866) / float_20b2Abs_float__28float_29(HEAPF32[$5 + 76 >> 2])), + HEAPF32[wasm2js_i32$0 + 72 >> 2] = wasm2js_f32$0; + HEAPF32[$5 + 92 >> 2] = HEAPF32[$5 + 92 >> 2] * HEAPF32[$5 + 72 >> 2]; + } + operator__28float_2c_20b2Vec2_20const__29($5 - -64 | 0, HEAPF32[$5 + 328 >> 2], $5 + 96 | 0); + b2Vec2__operator___28b2Vec2_20const__29($5 + 112 | 0, $5 - -64 | 0); + HEAPF32[$5 + 108 >> 2] = Math_fround(HEAPF32[$5 + 328 >> 2] * HEAPF32[$5 + 92 >> 2]) + HEAPF32[$5 + 108 >> 2]; + $0 = HEAP32[$5 + 116 >> 2]; + $1 = HEAP32[$5 + 112 >> 2]; + $2 = $1; + $1 = HEAP32[$6 + 20 >> 2] + Math_imul(HEAP32[$5 + 124 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[$6 + 20 >> 2] + Math_imul(HEAP32[$5 + 124 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$5 + 108 >> 2]; + $1 = HEAP32[$5 + 100 >> 2]; + $0 = HEAP32[$5 + 96 >> 2]; + $2 = $0; + $0 = HEAP32[$6 + 24 >> 2] + Math_imul(HEAP32[$5 + 124 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[$6 + 24 >> 2] + Math_imul(HEAP32[$5 + 124 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$5 + 92 >> 2]; + HEAP32[$5 + 124 >> 2] = HEAP32[$5 + 124 >> 2] + 1; + continue; + } + break; + } + b2Timer__Reset_28_29($5 + 334 | 0); + HEAP8[$5 + 63 | 0] = 0; + HEAP32[$5 + 56 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 56 >> 2] < HEAP32[HEAP32[$5 + 340 >> 2] + 16 >> 2]) { + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2ContactSolver__SolvePositionConstraints_28_29($5 + 140 | 0) & 1, + HEAP8[wasm2js_i32$0 + 55 | 0] = wasm2js_i32$1; + HEAP8[$5 + 54 | 0] = 1; + HEAP32[$5 + 48 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 48 >> 2] < HEAP32[$6 + 32 >> 2]) { + $0 = HEAP32[HEAP32[$6 + 16 >> 2] + (HEAP32[$5 + 48 >> 2] << 2) >> 2]; + wasm2js_i32$0 = $5, wasm2js_i32$1 = FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 44 >> 2]]($0, $5 + 236 | 0) & 1, + HEAP8[wasm2js_i32$0 + 47 | 0] = wasm2js_i32$1; + $0 = 0; + $0 = HEAP8[$5 + 54 | 0] & 1 ? HEAPU8[$5 + 47 | 0] : $0; + HEAP8[$5 + 54 | 0] = $0 & 1; + HEAP32[$5 + 48 >> 2] = HEAP32[$5 + 48 >> 2] + 1; + continue; + } + break; + } + if (!(HEAP8[$5 + 55 | 0] & 1) | !(HEAP8[$5 + 54 | 0] & 1)) { + HEAP32[$5 + 56 >> 2] = HEAP32[$5 + 56 >> 2] + 1; + continue; + } else { + HEAP8[$5 + 63 | 0] = 1; + } + } + break; + } + HEAP32[$5 + 40 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 40 >> 2] < HEAP32[$6 + 28 >> 2]) { + HEAP32[$5 + 36 >> 2] = HEAP32[HEAP32[$6 + 8 >> 2] + (HEAP32[$5 + 40 >> 2] << 2) >> 2]; + $2 = HEAP32[$6 + 20 >> 2] + Math_imul(HEAP32[$5 + 40 >> 2], 12) | 0; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 36 >> 2]; + HEAP32[$1 + 44 >> 2] = $2; + HEAP32[$1 + 48 >> 2] = $0; + HEAPF32[HEAP32[$5 + 36 >> 2] + 56 >> 2] = HEAPF32[(HEAP32[$6 + 20 >> 2] + Math_imul(HEAP32[$5 + 40 >> 2], 12) | 0) + 8 >> 2]; + $2 = HEAP32[$6 + 24 >> 2] + Math_imul(HEAP32[$5 + 40 >> 2], 12) | 0; + $0 = HEAP32[$2 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 36 >> 2]; + HEAP32[$0 + 64 >> 2] = $2; + HEAP32[$0 + 68 >> 2] = $1; + HEAPF32[HEAP32[$5 + 36 >> 2] + 72 >> 2] = HEAPF32[(HEAP32[$6 + 24 >> 2] + Math_imul(HEAP32[$5 + 40 >> 2], 12) | 0) + 8 >> 2]; + b2Body__SynchronizeTransform_28_29(HEAP32[$5 + 36 >> 2]); + HEAP32[$5 + 40 >> 2] = HEAP32[$5 + 40 >> 2] + 1; + continue; + } + break; + } + $7 = b2Timer__GetMilliseconds_28_29_20const($5 + 334 | 0); + HEAPF32[HEAP32[$5 + 344 >> 2] + 20 >> 2] = $7; + b2Island__Report_28b2ContactVelocityConstraint_20const__29($6, HEAP32[$5 + 180 >> 2]); + if (HEAP8[$5 + 335 | 0] & 1) { + HEAPF32[$5 + 32 >> 2] = 34028234663852886e22; + HEAPF32[$5 + 28 >> 2] = 9999999747378752e-20; + HEAPF32[$5 + 24 >> 2] = .001218469929881394; + HEAP32[$5 + 20 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 20 >> 2] < HEAP32[$6 + 28 >> 2]) { + HEAP32[$5 + 16 >> 2] = HEAP32[HEAP32[$6 + 8 >> 2] + (HEAP32[$5 + 20 >> 2] << 2) >> 2]; + if (b2Body__GetType_28_29_20const(HEAP32[$5 + 16 >> 2])) { + label$27: { + label$28: { + if (!(!(HEAPU16[HEAP32[$5 + 16 >> 2] + 4 >> 1] & 4) | Math_fround(HEAPF32[HEAP32[$5 + 16 >> 2] + 72 >> 2] * HEAPF32[HEAP32[$5 + 16 >> 2] + 72 >> 2]) > Math_fround(.001218469929881394))) { + if (!(b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$5 + 16 >> 2] - -64 | 0, HEAP32[$5 + 16 >> 2] - -64 | 0) > Math_fround(9999999747378752e-20))) { + break label$28; + } + } + HEAPF32[HEAP32[$5 + 16 >> 2] + 144 >> 2] = 0; + HEAPF32[$5 + 32 >> 2] = 0; + break label$27; + } + $0 = HEAP32[$5 + 16 >> 2]; + HEAPF32[$0 + 144 >> 2] = HEAPF32[$0 + 144 >> 2] + HEAPF32[$5 + 328 >> 2]; + wasm2js_i32$0 = $5, wasm2js_f32$0 = float_20b2Min_float__28float_2c_20float_29(HEAPF32[$5 + 32 >> 2], HEAPF32[HEAP32[$5 + 16 >> 2] + 144 >> 2]), + HEAPF32[wasm2js_i32$0 + 32 >> 2] = wasm2js_f32$0; + } + } + HEAP32[$5 + 20 >> 2] = HEAP32[$5 + 20 >> 2] + 1; + continue; + } + break; + } + if (!(!(HEAPF32[$5 + 32 >> 2] >= Math_fround(.5)) | !(HEAP8[$5 + 63 | 0] & 1))) { + HEAP32[$5 + 12 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 12 >> 2] < HEAP32[$6 + 28 >> 2]) { + HEAP32[$5 + 8 >> 2] = HEAP32[HEAP32[$6 + 8 >> 2] + (HEAP32[$5 + 12 >> 2] << 2) >> 2]; + b2Body__SetAwake_28bool_29(HEAP32[$5 + 8 >> 2], 0); + HEAP32[$5 + 12 >> 2] = HEAP32[$5 + 12 >> 2] + 1; + continue; + } + break; + } + } + } + b2ContactSolver___b2ContactSolver_28_29($5 + 140 | 0); + __stack_pointer = $5 + 352 | 0; +} + +function b2ContactSolver__InitializeVelocityConstraints_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = Math_fround(0), $6 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer - 400 | 0; + __stack_pointer = $1; + HEAP32[$1 + 396 >> 2] = $0; + $4 = HEAP32[$1 + 396 >> 2]; + HEAP32[$1 + 392 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 392 >> 2] < HEAP32[$4 + 48 >> 2]) { + HEAP32[$1 + 388 >> 2] = HEAP32[$4 + 40 >> 2] + Math_imul(HEAP32[$1 + 392 >> 2], 156); + HEAP32[$1 + 384 >> 2] = HEAP32[$4 + 36 >> 2] + Math_imul(HEAP32[$1 + 392 >> 2], 88); + HEAPF32[$1 + 380 >> 2] = HEAPF32[HEAP32[$1 + 384 >> 2] + 76 >> 2]; + HEAPF32[$1 + 376 >> 2] = HEAPF32[HEAP32[$1 + 384 >> 2] + 80 >> 2]; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetManifold_28_29(HEAP32[HEAP32[$4 + 44 >> 2] + (HEAP32[HEAP32[$1 + 388 >> 2] + 152 >> 2] << 2) >> 2]), + HEAP32[wasm2js_i32$0 + 372 >> 2] = wasm2js_i32$1; + HEAP32[$1 + 368 >> 2] = HEAP32[HEAP32[$1 + 388 >> 2] + 112 >> 2]; + HEAP32[$1 + 364 >> 2] = HEAP32[HEAP32[$1 + 388 >> 2] + 116 >> 2]; + HEAPF32[$1 + 360 >> 2] = HEAPF32[HEAP32[$1 + 388 >> 2] + 120 >> 2]; + HEAPF32[$1 + 356 >> 2] = HEAPF32[HEAP32[$1 + 388 >> 2] + 124 >> 2]; + HEAPF32[$1 + 352 >> 2] = HEAPF32[HEAP32[$1 + 388 >> 2] + 128 >> 2]; + HEAPF32[$1 + 348 >> 2] = HEAPF32[HEAP32[$1 + 388 >> 2] + 132 >> 2]; + $3 = HEAP32[$1 + 384 >> 2]; + $2 = HEAP32[$3 + 48 >> 2]; + $0 = HEAP32[$3 + 52 >> 2]; + HEAP32[$1 + 336 >> 2] = $2; + HEAP32[$1 + 340 >> 2] = $0; + $3 = HEAP32[$1 + 384 >> 2]; + $0 = HEAP32[$3 + 56 >> 2]; + $2 = HEAP32[$3 + 60 >> 2]; + HEAP32[$1 + 328 >> 2] = $0; + HEAP32[$1 + 332 >> 2] = $2; + $3 = HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$1 + 368 >> 2], 12) | 0; + $2 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + HEAP32[$1 + 320 >> 2] = $2; + HEAP32[$1 + 324 >> 2] = $0; + HEAPF32[$1 + 316 >> 2] = HEAPF32[(HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$1 + 368 >> 2], 12) | 0) + 8 >> 2]; + $3 = HEAP32[$4 + 28 >> 2] + Math_imul(HEAP32[$1 + 368 >> 2], 12) | 0; + $0 = HEAP32[$3 >> 2]; + $2 = HEAP32[$3 + 4 >> 2]; + HEAP32[$1 + 304 >> 2] = $0; + HEAP32[$1 + 308 >> 2] = $2; + HEAPF32[$1 + 300 >> 2] = HEAPF32[(HEAP32[$4 + 28 >> 2] + Math_imul(HEAP32[$1 + 368 >> 2], 12) | 0) + 8 >> 2]; + $3 = HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$1 + 364 >> 2], 12) | 0; + $2 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + HEAP32[$1 + 288 >> 2] = $2; + HEAP32[$1 + 292 >> 2] = $0; + HEAPF32[$1 + 284 >> 2] = HEAPF32[(HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$1 + 364 >> 2], 12) | 0) + 8 >> 2]; + $3 = HEAP32[$4 + 28 >> 2] + Math_imul(HEAP32[$1 + 364 >> 2], 12) | 0; + $0 = HEAP32[$3 >> 2]; + $2 = HEAP32[$3 + 4 >> 2]; + HEAP32[$1 + 272 >> 2] = $0; + HEAP32[$1 + 276 >> 2] = $2; + HEAPF32[$1 + 268 >> 2] = HEAPF32[(HEAP32[$4 + 28 >> 2] + Math_imul(HEAP32[$1 + 364 >> 2], 12) | 0) + 8 >> 2]; + if (HEAP32[HEAP32[$1 + 372 >> 2] + 60 >> 2] <= 0) { + __assert_fail(12211, 5487, 176, 3289); + wasm2js_trap(); + } else { + b2Transform__b2Transform_28_29($1 + 252 | 0); + b2Transform__b2Transform_28_29($1 + 236 | 0); + b2Rot__Set_28float_29($1 + 260 | 0, HEAPF32[$1 + 316 >> 2]); + b2Rot__Set_28float_29($1 + 244 | 0, HEAPF32[$1 + 284 >> 2]); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($1 + 220 | 0, $1 + 260 | 0, $1 + 336 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 228 | 0, $1 + 320 | 0, $1 + 220 | 0); + $0 = HEAP32[$1 + 232 >> 2]; + $2 = HEAP32[$1 + 228 >> 2]; + $3 = $2; + $2 = $1 + 252 | 0; + HEAP32[$2 >> 2] = $3; + HEAP32[$2 + 4 >> 2] = $0; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($1 + 204 | 0, $1 + 244 | 0, $1 + 328 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 212 | 0, $1 + 288 | 0, $1 + 204 | 0); + $2 = HEAP32[$1 + 216 >> 2]; + $0 = HEAP32[$1 + 212 >> 2]; + $3 = $0; + $0 = $1 + 236 | 0; + HEAP32[$0 >> 2] = $3; + HEAP32[$0 + 4 >> 2] = $2; + b2WorldManifold__b2WorldManifold_28_29($1 + 172 | 0); + b2WorldManifold__Initialize_28b2Manifold_20const__2c_20b2Transform_20const__2c_20float_2c_20b2Transform_20const__2c_20float_29($1 + 172 | 0, HEAP32[$1 + 372 >> 2], $1 + 252 | 0, HEAPF32[$1 + 380 >> 2], $1 + 236 | 0, HEAPF32[$1 + 376 >> 2]); + $3 = $1 + 172 | 0; + $2 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + $3 = $2; + $2 = HEAP32[$1 + 388 >> 2]; + HEAP32[$2 + 72 >> 2] = $3; + HEAP32[$2 + 76 >> 2] = $0; + HEAP32[$1 + 168 >> 2] = HEAP32[HEAP32[$1 + 388 >> 2] + 148 >> 2]; + HEAP32[$1 + 164 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 164 >> 2] < HEAP32[$1 + 168 >> 2]) { + HEAP32[$1 + 160 >> 2] = HEAP32[$1 + 388 >> 2] + Math_imul(HEAP32[$1 + 164 >> 2], 36); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 152 | 0, ($1 + 180 | 0) + (HEAP32[$1 + 164 >> 2] << 3) | 0, $1 + 320 | 0); + $2 = HEAP32[$1 + 156 >> 2]; + $0 = HEAP32[$1 + 152 >> 2]; + $3 = $0; + $0 = HEAP32[$1 + 160 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$0 + 4 >> 2] = $2; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 144 | 0, ($1 + 180 | 0) + (HEAP32[$1 + 164 >> 2] << 3) | 0, $1 + 288 | 0); + $0 = HEAP32[$1 + 148 >> 2]; + $2 = HEAP32[$1 + 144 >> 2]; + $3 = $2; + $2 = HEAP32[$1 + 160 >> 2]; + HEAP32[$2 + 8 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = $0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 160 >> 2], HEAP32[$1 + 388 >> 2] + 72 | 0), + HEAPF32[wasm2js_i32$0 + 140 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 160 >> 2] + 8 | 0, HEAP32[$1 + 388 >> 2] + 72 | 0), + HEAPF32[wasm2js_i32$0 + 136 >> 2] = wasm2js_f32$0; + HEAPF32[$1 + 132 >> 2] = Math_fround(Math_fround(HEAPF32[$1 + 348 >> 2] * HEAPF32[$1 + 136 >> 2]) * HEAPF32[$1 + 136 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$1 + 352 >> 2] * HEAPF32[$1 + 140 >> 2]) * HEAPF32[$1 + 140 >> 2]) + Math_fround(HEAPF32[$1 + 360 >> 2] + HEAPF32[$1 + 356 >> 2])); + $0 = HEAP32[$1 + 160 >> 2]; + if (HEAPF32[$1 + 132 >> 2] > Math_fround(0)) { + $5 = Math_fround(Math_fround(1) / HEAPF32[$1 + 132 >> 2]); + } else { + $5 = Math_fround(0); + } + HEAPF32[$0 + 24 >> 2] = $5; + b2Cross_28b2Vec2_20const__2c_20float_29($1 + 124 | 0, HEAP32[$1 + 388 >> 2] + 72 | 0, Math_fround(1)); + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 160 >> 2], $1 + 124 | 0), + HEAPF32[wasm2js_i32$0 + 120 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 160 >> 2] + 8 | 0, $1 + 124 | 0), + HEAPF32[wasm2js_i32$0 + 116 >> 2] = wasm2js_f32$0; + HEAPF32[$1 + 112 >> 2] = Math_fround(Math_fround(HEAPF32[$1 + 348 >> 2] * HEAPF32[$1 + 116 >> 2]) * HEAPF32[$1 + 116 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$1 + 352 >> 2] * HEAPF32[$1 + 120 >> 2]) * HEAPF32[$1 + 120 >> 2]) + Math_fround(HEAPF32[$1 + 360 >> 2] + HEAPF32[$1 + 356 >> 2])); + $0 = HEAP32[$1 + 160 >> 2]; + if (HEAPF32[$1 + 112 >> 2] > Math_fround(0)) { + $5 = Math_fround(Math_fround(1) / HEAPF32[$1 + 112 >> 2]); + } else { + $5 = Math_fround(0); + } + HEAPF32[$0 + 28 >> 2] = $5; + HEAPF32[HEAP32[$1 + 160 >> 2] + 32 >> 2] = 0; + $0 = HEAP32[$1 + 388 >> 2]; + b2Cross_28float_2c_20b2Vec2_20const__29($1 + 76 | 0, HEAPF32[$1 + 268 >> 2], HEAP32[$1 + 160 >> 2] + 8 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 84 | 0, $1 + 272 | 0, $1 + 76 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 92 | 0, $1 + 84 | 0, $1 + 304 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($1 + 68 | 0, HEAPF32[$1 + 300 >> 2], HEAP32[$1 + 160 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 100 | 0, $1 + 92 | 0, $1 + 68 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0 + 72 | 0, $1 + 100 | 0), + HEAPF32[wasm2js_i32$0 + 108 >> 2] = wasm2js_f32$0; + if (HEAPF32[$1 + 108 >> 2] < Math_fround(-1)) { + HEAPF32[HEAP32[$1 + 160 >> 2] + 32 >> 2] = Math_fround(-HEAPF32[HEAP32[$1 + 388 >> 2] + 140 >> 2]) * HEAPF32[$1 + 108 >> 2]; + } + HEAP32[$1 + 164 >> 2] = HEAP32[$1 + 164 >> 2] + 1; + continue; + } + break; + } + if (!(!(HEAP8[29704] & 1) | HEAP32[HEAP32[$1 + 388 >> 2] + 148 >> 2] != 2)) { + HEAP32[$1 + 64 >> 2] = HEAP32[$1 + 388 >> 2]; + HEAP32[$1 + 60 >> 2] = HEAP32[$1 + 388 >> 2] + 36; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 64 >> 2], HEAP32[$1 + 388 >> 2] + 72 | 0), + HEAPF32[wasm2js_i32$0 + 56 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 64 >> 2] + 8 | 0, HEAP32[$1 + 388 >> 2] + 72 | 0), + HEAPF32[wasm2js_i32$0 + 52 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 60 >> 2], HEAP32[$1 + 388 >> 2] + 72 | 0), + HEAPF32[wasm2js_i32$0 + 48 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 60 >> 2] + 8 | 0, HEAP32[$1 + 388 >> 2] + 72 | 0), + HEAPF32[wasm2js_i32$0 + 44 >> 2] = wasm2js_f32$0; + HEAPF32[$1 + 40 >> 2] = Math_fround(Math_fround(HEAPF32[$1 + 348 >> 2] * HEAPF32[$1 + 52 >> 2]) * HEAPF32[$1 + 52 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$1 + 352 >> 2] * HEAPF32[$1 + 56 >> 2]) * HEAPF32[$1 + 56 >> 2]) + Math_fround(HEAPF32[$1 + 360 >> 2] + HEAPF32[$1 + 356 >> 2])); + HEAPF32[$1 + 36 >> 2] = Math_fround(Math_fround(HEAPF32[$1 + 348 >> 2] * HEAPF32[$1 + 44 >> 2]) * HEAPF32[$1 + 44 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$1 + 352 >> 2] * HEAPF32[$1 + 48 >> 2]) * HEAPF32[$1 + 48 >> 2]) + Math_fround(HEAPF32[$1 + 360 >> 2] + HEAPF32[$1 + 356 >> 2])); + HEAPF32[$1 + 32 >> 2] = Math_fround(Math_fround(HEAPF32[$1 + 348 >> 2] * HEAPF32[$1 + 52 >> 2]) * HEAPF32[$1 + 44 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$1 + 352 >> 2] * HEAPF32[$1 + 56 >> 2]) * HEAPF32[$1 + 48 >> 2]) + Math_fround(HEAPF32[$1 + 360 >> 2] + HEAPF32[$1 + 356 >> 2])); + HEAPF32[$1 + 28 >> 2] = 1e3; + label$13: { + if (Math_fround(HEAPF32[$1 + 40 >> 2] * HEAPF32[$1 + 40 >> 2]) < Math_fround(Math_fround(Math_fround(HEAPF32[$1 + 40 >> 2] * HEAPF32[$1 + 36 >> 2]) - Math_fround(HEAPF32[$1 + 32 >> 2] * HEAPF32[$1 + 32 >> 2])) * Math_fround(1e3))) { + b2Vec2__Set_28float_2c_20float_29(HEAP32[$1 + 388 >> 2] + 96 | 0, HEAPF32[$1 + 40 >> 2], HEAPF32[$1 + 32 >> 2]); + b2Vec2__Set_28float_2c_20float_29(HEAP32[$1 + 388 >> 2] + 104 | 0, HEAPF32[$1 + 32 >> 2], HEAPF32[$1 + 36 >> 2]); + b2Mat22__GetInverse_28_29_20const($1 + 12 | 0, HEAP32[$1 + 388 >> 2] + 96 | 0); + $2 = HEAP32[$1 + 16 >> 2]; + $0 = HEAP32[$1 + 12 >> 2]; + $6 = $0; + $3 = HEAP32[$1 + 388 >> 2]; + $0 = $3; + HEAP32[$0 + 80 >> 2] = $6; + HEAP32[$0 + 84 >> 2] = $2; + $0 = HEAP32[$1 + 24 >> 2]; + $2 = HEAP32[$1 + 20 >> 2]; + $6 = $2; + $2 = $3; + HEAP32[$2 + 88 >> 2] = $6; + HEAP32[$2 + 92 >> 2] = $0; + break label$13; + } + HEAP32[HEAP32[$1 + 388 >> 2] + 148 >> 2] = 1; + } + } + HEAP32[$1 + 392 >> 2] = HEAP32[$1 + 392 >> 2] + 1; + continue; + } + } + break; + } + __stack_pointer = $1 + 400 | 0; +} + +function b2PrismaticJoint__SolvePositionConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 400 | 0; + __stack_pointer = $2; + HEAP32[$2 + 396 >> 2] = $0; + HEAP32[$2 + 392 >> 2] = $1; + $3 = HEAP32[$2 + 396 >> 2]; + $4 = HEAP32[HEAP32[$2 + 392 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 384 >> 2] = $0; + HEAP32[$2 + 388 >> 2] = $1; + HEAPF32[$2 + 380 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 392 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 392 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 368 >> 2] = $1; + HEAP32[$2 + 372 >> 2] = $0; + HEAPF32[$2 + 364 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 392 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 356 | 0, HEAPF32[$2 + 380 >> 2]); + b2Rot__b2Rot_28float_29($2 + 348 | 0, HEAPF32[$2 + 364 >> 2]); + HEAPF32[$2 + 344 >> 2] = HEAPF32[$3 + 168 >> 2]; + HEAPF32[$2 + 340 >> 2] = HEAPF32[$3 + 172 >> 2]; + HEAPF32[$2 + 336 >> 2] = HEAPF32[$3 + 176 >> 2]; + HEAPF32[$2 + 332 >> 2] = HEAPF32[$3 + 180 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 316 | 0, $3 + 68 | 0, $3 + 152 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 324 | 0, $2 + 356 | 0, $2 + 316 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 300 | 0, $3 + 76 | 0, $3 + 160 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 308 | 0, $2 + 348 | 0, $2 + 300 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 276 | 0, $2 + 368 | 0, $2 + 308 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 284 | 0, $2 + 276 | 0, $2 + 384 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 292 | 0, $2 + 284 | 0, $2 + 324 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 268 | 0, $2 + 356 | 0, $3 + 84 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 256 | 0, $2 + 292 | 0, $2 + 324 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 256 | 0, $2 + 268 | 0), + HEAPF32[wasm2js_i32$0 + 264 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 308 | 0, $2 + 268 | 0), + HEAPF32[wasm2js_i32$0 + 252 >> 2] = wasm2js_f32$0; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 244 | 0, $2 + 356 | 0, $3 + 92 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 232 | 0, $2 + 292 | 0, $2 + 324 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 232 | 0, $2 + 244 | 0), + HEAPF32[wasm2js_i32$0 + 240 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 308 | 0, $2 + 244 | 0), + HEAPF32[wasm2js_i32$0 + 228 >> 2] = wasm2js_f32$0; + b2Vec3__b2Vec3_28_29($2 + 216 | 0); + b2Vec2__b2Vec2_28_29($2 + 208 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 244 | 0, $2 + 292 | 0), + HEAPF32[wasm2js_i32$0 + 208 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 212 >> 2] = Math_fround(HEAPF32[$2 + 364 >> 2] - HEAPF32[$2 + 380 >> 2]) - HEAPF32[$3 + 100 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Abs_float__28float_29(HEAPF32[$2 + 208 >> 2]), + HEAPF32[wasm2js_i32$0 + 204 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Abs_float__28float_29(HEAPF32[$2 + 212 >> 2]), + HEAPF32[wasm2js_i32$0 + 200 >> 2] = wasm2js_f32$0; + HEAP8[$2 + 199 | 0] = 0; + HEAPF32[$2 + 192 >> 2] = 0; + if (HEAP8[$3 + 140 | 0] & 1) { + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 268 | 0, $2 + 292 | 0), + HEAPF32[wasm2js_i32$0 + 188 >> 2] = wasm2js_f32$0; + label$2: { + if (float_20b2Abs_float__28float_29(Math_fround(HEAPF32[$3 + 128 >> 2] - HEAPF32[$3 + 124 >> 2])) < Math_fround(.009999999776482582)) { + HEAPF32[$2 + 192 >> 2] = HEAPF32[$2 + 188 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(HEAPF32[$2 + 204 >> 2], float_20b2Abs_float__28float_29(HEAPF32[$2 + 188 >> 2])), + HEAPF32[wasm2js_i32$0 + 204 >> 2] = wasm2js_f32$0; + HEAP8[$2 + 199 | 0] = 1; + break label$2; + } + label$4: { + if (HEAPF32[$2 + 188 >> 2] <= HEAPF32[$3 + 124 >> 2]) { + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Min_float__28float_2c_20float_29(Math_fround(HEAPF32[$2 + 188 >> 2] - HEAPF32[$3 + 124 >> 2]), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 192 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(HEAPF32[$2 + 204 >> 2], Math_fround(HEAPF32[$3 + 124 >> 2] - HEAPF32[$2 + 188 >> 2])), + HEAPF32[wasm2js_i32$0 + 204 >> 2] = wasm2js_f32$0; + HEAP8[$2 + 199 | 0] = 1; + break label$4; + } + if (HEAPF32[$2 + 188 >> 2] >= HEAPF32[$3 + 128 >> 2]) { + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(Math_fround(HEAPF32[$2 + 188 >> 2] - HEAPF32[$3 + 128 >> 2]), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 192 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(HEAPF32[$2 + 204 >> 2], Math_fround(HEAPF32[$2 + 188 >> 2] - HEAPF32[$3 + 128 >> 2])), + HEAPF32[wasm2js_i32$0 + 204 >> 2] = wasm2js_f32$0; + HEAP8[$2 + 199 | 0] = 1; + } + } + } + } + label$7: { + if (HEAP8[$2 + 199 | 0] & 1) { + HEAPF32[$2 + 184 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 332 >> 2] * HEAPF32[$2 + 228 >> 2]) * HEAPF32[$2 + 228 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 336 >> 2] * HEAPF32[$2 + 240 >> 2]) * HEAPF32[$2 + 240 >> 2]) + Math_fround(HEAPF32[$2 + 344 >> 2] + HEAPF32[$2 + 340 >> 2])); + HEAPF32[$2 + 180 >> 2] = Math_fround(HEAPF32[$2 + 336 >> 2] * HEAPF32[$2 + 240 >> 2]) + Math_fround(HEAPF32[$2 + 332 >> 2] * HEAPF32[$2 + 228 >> 2]); + HEAPF32[$2 + 176 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 336 >> 2] * HEAPF32[$2 + 240 >> 2]) * HEAPF32[$2 + 264 >> 2]) + Math_fround(Math_fround(HEAPF32[$2 + 332 >> 2] * HEAPF32[$2 + 228 >> 2]) * HEAPF32[$2 + 252 >> 2]); + HEAPF32[$2 + 172 >> 2] = HEAPF32[$2 + 336 >> 2] + HEAPF32[$2 + 332 >> 2]; + if (HEAPF32[$2 + 172 >> 2] == Math_fround(0)) { + HEAPF32[$2 + 172 >> 2] = 1; + } + HEAPF32[$2 + 168 >> 2] = Math_fround(HEAPF32[$2 + 336 >> 2] * HEAPF32[$2 + 264 >> 2]) + Math_fround(HEAPF32[$2 + 332 >> 2] * HEAPF32[$2 + 252 >> 2]); + HEAPF32[$2 + 164 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 332 >> 2] * HEAPF32[$2 + 252 >> 2]) * HEAPF32[$2 + 252 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 336 >> 2] * HEAPF32[$2 + 264 >> 2]) * HEAPF32[$2 + 264 >> 2]) + Math_fround(HEAPF32[$2 + 344 >> 2] + HEAPF32[$2 + 340 >> 2])); + b2Mat33__b2Mat33_28_29($2 + 128 | 0); + b2Vec3__Set_28float_2c_20float_2c_20float_29($2 + 128 | 0, HEAPF32[$2 + 184 >> 2], HEAPF32[$2 + 180 >> 2], HEAPF32[$2 + 176 >> 2]); + b2Vec3__Set_28float_2c_20float_2c_20float_29($2 + 140 | 0, HEAPF32[$2 + 180 >> 2], HEAPF32[$2 + 172 >> 2], HEAPF32[$2 + 168 >> 2]); + b2Vec3__Set_28float_2c_20float_2c_20float_29($2 + 152 | 0, HEAPF32[$2 + 176 >> 2], HEAPF32[$2 + 168 >> 2], HEAPF32[$2 + 164 >> 2]); + b2Vec3__b2Vec3_28_29($2 + 116 | 0); + HEAPF32[$2 + 116 >> 2] = HEAPF32[$2 + 208 >> 2]; + HEAPF32[$2 + 120 >> 2] = HEAPF32[$2 + 212 >> 2]; + HEAPF32[$2 + 124 >> 2] = HEAPF32[$2 + 192 >> 2]; + b2Vec3__operator__28_29_20const($2 + 92 | 0, $2 + 116 | 0); + b2Mat33__Solve33_28b2Vec3_20const__29_20const($2 + 104 | 0, $2 + 128 | 0, $2 + 92 | 0); + HEAP32[$2 + 224 >> 2] = HEAP32[$2 + 112 >> 2]; + $1 = HEAP32[$2 + 108 >> 2]; + $0 = HEAP32[$2 + 104 >> 2]; + HEAP32[$2 + 216 >> 2] = $0; + HEAP32[$2 + 220 >> 2] = $1; + break label$7; + } + HEAPF32[$2 + 88 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 332 >> 2] * HEAPF32[$2 + 228 >> 2]) * HEAPF32[$2 + 228 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 336 >> 2] * HEAPF32[$2 + 240 >> 2]) * HEAPF32[$2 + 240 >> 2]) + Math_fround(HEAPF32[$2 + 344 >> 2] + HEAPF32[$2 + 340 >> 2])); + HEAPF32[$2 + 84 >> 2] = Math_fround(HEAPF32[$2 + 336 >> 2] * HEAPF32[$2 + 240 >> 2]) + Math_fround(HEAPF32[$2 + 332 >> 2] * HEAPF32[$2 + 228 >> 2]); + HEAPF32[$2 + 80 >> 2] = HEAPF32[$2 + 336 >> 2] + HEAPF32[$2 + 332 >> 2]; + if (HEAPF32[$2 + 80 >> 2] == Math_fround(0)) { + HEAPF32[$2 + 80 >> 2] = 1; + } + b2Mat22__b2Mat22_28_29($2 - -64 | 0); + b2Vec2__Set_28float_2c_20float_29($2 - -64 | 0, HEAPF32[$2 + 88 >> 2], HEAPF32[$2 + 84 >> 2]); + b2Vec2__Set_28float_2c_20float_29($2 + 72 | 0, HEAPF32[$2 + 84 >> 2], HEAPF32[$2 + 80 >> 2]); + b2Vec2__operator__28_29_20const($2 + 48 | 0, $2 + 208 | 0); + b2Mat22__Solve_28b2Vec2_20const__29_20const($2 + 56 | 0, $2 - -64 | 0, $2 + 48 | 0); + HEAPF32[$2 + 216 >> 2] = HEAPF32[$2 + 56 >> 2]; + HEAPF32[$2 + 220 >> 2] = HEAPF32[$2 + 60 >> 2]; + HEAPF32[$2 + 224 >> 2] = 0; + } + operator__28float_2c_20b2Vec2_20const__29($2 + 32 | 0, HEAPF32[$2 + 216 >> 2], $2 + 244 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 24 | 0, HEAPF32[$2 + 224 >> 2], $2 + 268 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 40 | 0, $2 + 32 | 0, $2 + 24 | 0); + HEAPF32[$2 + 20 >> 2] = Math_fround(HEAPF32[$2 + 224 >> 2] * HEAPF32[$2 + 264 >> 2]) + Math_fround(Math_fround(HEAPF32[$2 + 216 >> 2] * HEAPF32[$2 + 240 >> 2]) + HEAPF32[$2 + 220 >> 2]); + HEAPF32[$2 + 16 >> 2] = Math_fround(HEAPF32[$2 + 224 >> 2] * HEAPF32[$2 + 252 >> 2]) + Math_fround(Math_fround(HEAPF32[$2 + 216 >> 2] * HEAPF32[$2 + 228 >> 2]) + HEAPF32[$2 + 220 >> 2]); + operator__28float_2c_20b2Vec2_20const__29($2 + 8 | 0, HEAPF32[$2 + 344 >> 2], $2 + 40 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 384 | 0, $2 + 8 | 0); + HEAPF32[$2 + 380 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 336 >> 2]) * HEAPF32[$2 + 20 >> 2]) + HEAPF32[$2 + 380 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2, HEAPF32[$2 + 340 >> 2], $2 + 40 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 368 | 0, $2); + HEAPF32[$2 + 364 >> 2] = Math_fround(HEAPF32[$2 + 332 >> 2] * HEAPF32[$2 + 16 >> 2]) + HEAPF32[$2 + 364 >> 2]; + $0 = HEAP32[$2 + 388 >> 2]; + $1 = HEAP32[$2 + 384 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 392 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 392 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 380 >> 2]; + $1 = HEAP32[$2 + 372 >> 2]; + $0 = HEAP32[$2 + 368 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 392 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 392 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 364 >> 2]; + __stack_pointer = $2 + 400 | 0; + $5 = HEAPF32[$2 + 204 >> 2] <= Math_fround(.004999999888241291) ? HEAPF32[$2 + 200 >> 2] <= Math_fround(.03490658849477768) : $5; + return $5 | 0; +} + +function b2GearJoint__InitVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, $5 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 240 | 0; + __stack_pointer = $3; + HEAP32[$3 + 236 >> 2] = $0; + HEAP32[$3 + 232 >> 2] = $1; + $2 = HEAP32[$3 + 236 >> 2]; + HEAP32[$2 + 160 >> 2] = HEAP32[HEAP32[$2 + 48 >> 2] + 8 >> 2]; + HEAP32[$2 + 164 >> 2] = HEAP32[HEAP32[$2 + 52 >> 2] + 8 >> 2]; + HEAP32[$2 + 168 >> 2] = HEAP32[HEAP32[$2 + 84 >> 2] + 8 >> 2]; + HEAP32[$2 + 172 >> 2] = HEAP32[HEAP32[$2 + 88 >> 2] + 8 >> 2]; + $4 = HEAP32[$2 + 48 >> 2]; + $1 = HEAP32[$4 + 28 >> 2]; + $0 = HEAP32[$4 + 32 >> 2]; + HEAP32[$2 + 176 >> 2] = $1; + HEAP32[$2 + 180 >> 2] = $0; + $4 = HEAP32[$2 + 52 >> 2]; + $0 = HEAP32[$4 + 28 >> 2]; + $1 = HEAP32[$4 + 32 >> 2]; + HEAP32[$2 + 184 >> 2] = $0; + HEAP32[$2 + 188 >> 2] = $1; + $4 = HEAP32[$2 + 84 >> 2]; + $1 = HEAP32[$4 + 28 >> 2]; + $0 = HEAP32[$4 + 32 >> 2]; + HEAP32[$2 + 192 >> 2] = $1; + HEAP32[$2 + 196 >> 2] = $0; + $4 = HEAP32[$2 + 88 >> 2]; + $0 = HEAP32[$4 + 28 >> 2]; + $1 = HEAP32[$4 + 32 >> 2]; + HEAP32[$2 + 200 >> 2] = $0; + HEAP32[$2 + 204 >> 2] = $1; + HEAPF32[$2 + 208 >> 2] = HEAPF32[HEAP32[$2 + 48 >> 2] + 120 >> 2]; + HEAPF32[$2 + 212 >> 2] = HEAPF32[HEAP32[$2 + 52 >> 2] + 120 >> 2]; + HEAPF32[$2 + 216 >> 2] = HEAPF32[HEAP32[$2 + 84 >> 2] + 120 >> 2]; + HEAPF32[$2 + 220 >> 2] = HEAPF32[HEAP32[$2 + 88 >> 2] + 120 >> 2]; + HEAPF32[$2 + 224 >> 2] = HEAPF32[HEAP32[$2 + 48 >> 2] + 128 >> 2]; + HEAPF32[$2 + 228 >> 2] = HEAPF32[HEAP32[$2 + 52 >> 2] + 128 >> 2]; + HEAPF32[$2 + 232 >> 2] = HEAPF32[HEAP32[$2 + 84 >> 2] + 128 >> 2]; + HEAPF32[$2 + 236 >> 2] = HEAPF32[HEAP32[$2 + 88 >> 2] + 128 >> 2]; + HEAPF32[$3 + 228 >> 2] = HEAPF32[(HEAP32[HEAP32[$3 + 232 >> 2] + 24 >> 2] + Math_imul(HEAP32[$2 + 160 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 160 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$3 + 216 >> 2] = $1; + HEAP32[$3 + 220 >> 2] = $0; + HEAPF32[$3 + 212 >> 2] = HEAPF32[(HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 160 >> 2], 12) | 0) + 8 >> 2]; + HEAPF32[$3 + 208 >> 2] = HEAPF32[(HEAP32[HEAP32[$3 + 232 >> 2] + 24 >> 2] + Math_imul(HEAP32[$2 + 164 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 164 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$3 + 200 >> 2] = $0; + HEAP32[$3 + 204 >> 2] = $1; + HEAPF32[$3 + 196 >> 2] = HEAPF32[(HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 164 >> 2], 12) | 0) + 8 >> 2]; + HEAPF32[$3 + 192 >> 2] = HEAPF32[(HEAP32[HEAP32[$3 + 232 >> 2] + 24 >> 2] + Math_imul(HEAP32[$2 + 168 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 168 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$3 + 184 >> 2] = $1; + HEAP32[$3 + 188 >> 2] = $0; + HEAPF32[$3 + 180 >> 2] = HEAPF32[(HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 168 >> 2], 12) | 0) + 8 >> 2]; + HEAPF32[$3 + 176 >> 2] = HEAPF32[(HEAP32[HEAP32[$3 + 232 >> 2] + 24 >> 2] + Math_imul(HEAP32[$2 + 172 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 172 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$3 + 168 >> 2] = $0; + HEAP32[$3 + 172 >> 2] = $1; + HEAPF32[$3 + 164 >> 2] = HEAPF32[(HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 172 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($3 + 156 | 0, HEAPF32[$3 + 228 >> 2]); + b2Rot__b2Rot_28float_29($3 + 148 | 0, HEAPF32[$3 + 208 >> 2]); + b2Rot__b2Rot_28float_29($3 + 140 | 0, HEAPF32[$3 + 192 >> 2]); + b2Rot__b2Rot_28float_29($3 + 132 | 0, HEAPF32[$3 + 176 >> 2]); + HEAPF32[$2 + 272 >> 2] = 0; + label$1: { + if (HEAP32[$2 + 76 >> 2] == 1) { + b2Vec2__SetZero_28_29($2 + 240 | 0); + HEAPF32[$2 + 256 >> 2] = 1; + HEAPF32[$2 + 264 >> 2] = 1; + HEAPF32[$2 + 272 >> 2] = HEAPF32[$2 + 272 >> 2] + Math_fround(HEAPF32[$2 + 224 >> 2] + HEAPF32[$2 + 232 >> 2]); + break label$1; + } + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 124 | 0, $3 + 140 | 0, $2 + 124 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 108 | 0, $2 + 108 | 0, $2 + 192 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 116 | 0, $3 + 140 | 0, $3 + 108 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 92 | 0, $2 + 92 | 0, $2 + 176 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 100 | 0, $3 + 156 | 0, $3 + 92 | 0); + $0 = HEAP32[$3 + 128 >> 2]; + $1 = HEAP32[$3 + 124 >> 2]; + HEAP32[$2 + 240 >> 2] = $1; + HEAP32[$2 + 244 >> 2] = $0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 116 | 0, $3 + 124 | 0), + HEAPF32[wasm2js_i32$0 + 264 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 100 | 0, $3 + 124 | 0), + HEAPF32[wasm2js_i32$0 + 256 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 272 >> 2] = HEAPF32[$2 + 272 >> 2] + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 224 >> 2] * HEAPF32[$2 + 256 >> 2]) * HEAPF32[$2 + 256 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 232 >> 2] * HEAPF32[$2 + 264 >> 2]) * HEAPF32[$2 + 264 >> 2]) + Math_fround(HEAPF32[$2 + 216 >> 2] + HEAPF32[$2 + 208 >> 2]))); + } + label$3: { + if (HEAP32[$2 + 80 >> 2] == 1) { + b2Vec2__SetZero_28_29($2 + 248 | 0); + HEAPF32[$2 + 260 >> 2] = HEAPF32[$2 + 152 >> 2]; + HEAPF32[$2 + 268 >> 2] = HEAPF32[$2 + 152 >> 2]; + HEAPF32[$2 + 272 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 152 >> 2] * HEAPF32[$2 + 152 >> 2]) * Math_fround(HEAPF32[$2 + 228 >> 2] + HEAPF32[$2 + 236 >> 2])) + HEAPF32[$2 + 272 >> 2]; + break label$3; + } + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 84 | 0, $3 + 132 | 0, $2 + 132 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 68 | 0, $2 + 116 | 0, $2 + 200 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 76 | 0, $3 + 132 | 0, $3 + 68 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 52 | 0, $2 + 100 | 0, $2 + 184 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 60 | 0, $3 + 148 | 0, $3 + 52 | 0); + operator__28float_2c_20b2Vec2_20const__29($3 + 44 | 0, HEAPF32[$2 + 152 >> 2], $3 + 84 | 0); + $1 = HEAP32[$3 + 48 >> 2]; + $0 = HEAP32[$3 + 44 >> 2]; + HEAP32[$2 + 248 >> 2] = $0; + HEAP32[$2 + 252 >> 2] = $1; + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(HEAPF32[$2 + 152 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 76 | 0, $3 + 84 | 0)), + HEAPF32[wasm2js_i32$0 + 268 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(HEAPF32[$2 + 152 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 60 | 0, $3 + 84 | 0)), + HEAPF32[wasm2js_i32$0 + 260 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 272 >> 2] = HEAPF32[$2 + 272 >> 2] + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 228 >> 2] * HEAPF32[$2 + 260 >> 2]) * HEAPF32[$2 + 260 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 152 >> 2] * HEAPF32[$2 + 152 >> 2]) * Math_fround(HEAPF32[$2 + 220 >> 2] + HEAPF32[$2 + 212 >> 2])) + Math_fround(Math_fround(HEAPF32[$2 + 236 >> 2] * HEAPF32[$2 + 268 >> 2]) * HEAPF32[$2 + 268 >> 2]))); + } + if (HEAPF32[$2 + 272 >> 2] > Math_fround(0)) { + $5 = Math_fround(Math_fround(1) / HEAPF32[$2 + 272 >> 2]); + } else { + $5 = Math_fround(0); + } + HEAPF32[$2 + 272 >> 2] = $5; + label$7: { + if (HEAP8[HEAP32[$3 + 232 >> 2] + 20 | 0] & 1) { + operator__28float_2c_20b2Vec2_20const__29($3 + 36 | 0, Math_fround(HEAPF32[$2 + 208 >> 2] * HEAPF32[$2 + 156 >> 2]), $2 + 240 | 0); + b2Vec2__operator___28b2Vec2_20const__29($3 + 216 | 0, $3 + 36 | 0); + HEAPF32[$3 + 212 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 224 >> 2] * HEAPF32[$2 + 156 >> 2]) * HEAPF32[$2 + 256 >> 2]) + HEAPF32[$3 + 212 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($3 + 28 | 0, Math_fround(HEAPF32[$2 + 212 >> 2] * HEAPF32[$2 + 156 >> 2]), $2 + 248 | 0); + b2Vec2__operator___28b2Vec2_20const__29($3 + 200 | 0, $3 + 28 | 0); + HEAPF32[$3 + 196 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 228 >> 2] * HEAPF32[$2 + 156 >> 2]) * HEAPF32[$2 + 260 >> 2]) + HEAPF32[$3 + 196 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($3 + 20 | 0, Math_fround(HEAPF32[$2 + 216 >> 2] * HEAPF32[$2 + 156 >> 2]), $2 + 240 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($3 + 184 | 0, $3 + 20 | 0); + HEAPF32[$3 + 180 >> 2] = Math_fround(Math_fround(-Math_fround(HEAPF32[$2 + 232 >> 2] * HEAPF32[$2 + 156 >> 2])) * HEAPF32[$2 + 264 >> 2]) + HEAPF32[$3 + 180 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($3 + 12 | 0, Math_fround(HEAPF32[$2 + 220 >> 2] * HEAPF32[$2 + 156 >> 2]), $2 + 248 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($3 + 168 | 0, $3 + 12 | 0); + HEAPF32[$3 + 164 >> 2] = Math_fround(Math_fround(-Math_fround(HEAPF32[$2 + 236 >> 2] * HEAPF32[$2 + 156 >> 2])) * HEAPF32[$2 + 268 >> 2]) + HEAPF32[$3 + 164 >> 2]; + break label$7; + } + HEAPF32[$2 + 156 >> 2] = 0; + } + $0 = HEAP32[$3 + 220 >> 2]; + $1 = HEAP32[$3 + 216 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 160 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 160 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$3 + 212 >> 2]; + $1 = HEAP32[$3 + 204 >> 2]; + $0 = HEAP32[$3 + 200 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 164 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 164 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$3 + 196 >> 2]; + $0 = HEAP32[$3 + 188 >> 2]; + $1 = HEAP32[$3 + 184 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 168 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 168 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$3 + 180 >> 2]; + $1 = HEAP32[$3 + 172 >> 2]; + $0 = HEAP32[$3 + 168 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 172 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$3 + 232 >> 2] + 28 >> 2] + Math_imul(HEAP32[$2 + 172 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$3 + 164 >> 2]; + __stack_pointer = $3 + 240 | 0; +} + +function void_20std____2____tree_remove_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____2c_20std____2____tree_node_base_void____29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + if (HEAP32[HEAP32[$2 + 24 >> 2] + 4 >> 2] ? HEAP32[HEAP32[$2 + 24 >> 2] >> 2] : 0) { + $0 = std____2____tree_node_base_void____20std____2____tree_next_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 24 >> 2]); + } else { + $0 = HEAP32[$2 + 24 >> 2]; + } + HEAP32[$2 + 20 >> 2] = $0; + if (HEAP32[HEAP32[$2 + 20 >> 2] >> 2]) { + $0 = HEAP32[HEAP32[$2 + 20 >> 2] >> 2]; + } else { + $0 = HEAP32[HEAP32[$2 + 20 >> 2] + 4 >> 2]; + } + HEAP32[$2 + 16 >> 2] = $0; + HEAP32[$2 + 12 >> 2] = 0; + if (HEAP32[$2 + 16 >> 2]) { + HEAP32[HEAP32[$2 + 16 >> 2] + 8 >> 2] = HEAP32[HEAP32[$2 + 20 >> 2] + 8 >> 2]; + } + label$7: { + if (bool_20std____2____tree_is_left_child_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 20 >> 2]) & 1) { + HEAP32[HEAP32[HEAP32[$2 + 20 >> 2] + 8 >> 2] >> 2] = HEAP32[$2 + 16 >> 2]; + label$9: { + if (HEAP32[$2 + 20 >> 2] != HEAP32[$2 + 28 >> 2]) { + wasm2js_i32$0 = $2, wasm2js_i32$1 = HEAP32[std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 20 >> 2]) + 4 >> 2], + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + break label$9; + } + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 16 >> 2]; + } + break label$7; + } + $0 = HEAP32[$2 + 16 >> 2]; + wasm2js_i32$0 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 20 >> 2]), + wasm2js_i32$1 = $0, HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + HEAP32[$2 + 12 >> 2] = HEAP32[HEAP32[HEAP32[$2 + 20 >> 2] + 8 >> 2] >> 2]; + } + HEAP8[$2 + 11 | 0] = HEAP8[HEAP32[$2 + 20 >> 2] + 12 | 0] & 1; + if (HEAP32[$2 + 20 >> 2] != HEAP32[$2 + 24 >> 2]) { + HEAP32[HEAP32[$2 + 20 >> 2] + 8 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 8 >> 2]; + label$12: { + if (bool_20std____2____tree_is_left_child_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 24 >> 2]) & 1) { + HEAP32[HEAP32[HEAP32[$2 + 20 >> 2] + 8 >> 2] >> 2] = HEAP32[$2 + 20 >> 2]; + break label$12; + } + $0 = HEAP32[$2 + 20 >> 2]; + wasm2js_i32$0 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 20 >> 2]), + wasm2js_i32$1 = $0, HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + } + HEAP32[HEAP32[$2 + 20 >> 2] >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] >> 2]; + std____2____tree_node_base_void______set_parent_5babi_v160004_5d_28std____2____tree_node_base_void____29(HEAP32[HEAP32[$2 + 20 >> 2] >> 2], HEAP32[$2 + 20 >> 2]); + HEAP32[HEAP32[$2 + 20 >> 2] + 4 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 4 >> 2]; + if (HEAP32[HEAP32[$2 + 20 >> 2] + 4 >> 2]) { + std____2____tree_node_base_void______set_parent_5babi_v160004_5d_28std____2____tree_node_base_void____29(HEAP32[HEAP32[$2 + 20 >> 2] + 4 >> 2], HEAP32[$2 + 20 >> 2]); + } + HEAP8[HEAP32[$2 + 20 >> 2] + 12 | 0] = HEAP8[HEAP32[$2 + 24 >> 2] + 12 | 0] & 1; + if (HEAP32[$2 + 28 >> 2] == HEAP32[$2 + 24 >> 2]) { + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 20 >> 2]; + } + } + if (!(!(HEAP8[$2 + 11 | 0] & 1) | !HEAP32[$2 + 28 >> 2])) { + label$17: { + if (HEAP32[$2 + 16 >> 2]) { + HEAP8[HEAP32[$2 + 16 >> 2] + 12 | 0] = 1; + break label$17; + } + while (1) { + label$20: { + if (!(bool_20std____2____tree_is_left_child_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 12 >> 2]) & 1)) { + if (!(HEAP8[HEAP32[$2 + 12 >> 2] + 12 | 0] & 1)) { + HEAP8[HEAP32[$2 + 12 >> 2] + 12 | 0] = 1; + wasm2js_i32$0 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2]), + wasm2js_i32$1 = 0, HEAP8[wasm2js_i32$0 + 12 | 0] = wasm2js_i32$1; + void_20std____2____tree_left_rotate_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2])); + if (HEAP32[$2 + 28 >> 2] == HEAP32[HEAP32[$2 + 12 >> 2] >> 2]) { + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + } + HEAP32[$2 + 12 >> 2] = HEAP32[HEAP32[HEAP32[$2 + 12 >> 2] >> 2] + 4 >> 2]; + } + label$24: { + if (!((HEAP8[HEAP32[HEAP32[$2 + 12 >> 2] >> 2] + 12 | 0] & 1 ? 0 : HEAP32[HEAP32[$2 + 12 >> 2] >> 2]) | (HEAP8[HEAP32[HEAP32[$2 + 12 >> 2] + 4 >> 2] + 12 | 0] & 1 ? 0 : HEAP32[HEAP32[$2 + 12 >> 2] + 4 >> 2]))) { + HEAP8[HEAP32[$2 + 12 >> 2] + 12 | 0] = 0; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + if (!(HEAP8[HEAP32[$2 + 16 >> 2] + 12 | 0] & 1 & HEAP32[$2 + 16 >> 2] != HEAP32[$2 + 28 >> 2])) { + HEAP8[HEAP32[$2 + 16 >> 2] + 12 | 0] = 1; + break label$20; + } + label$30: { + if (bool_20std____2____tree_is_left_child_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 16 >> 2]) & 1) { + $0 = HEAP32[std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 16 >> 2]) + 4 >> 2]; + break label$30; + } + $0 = HEAP32[HEAP32[HEAP32[$2 + 16 >> 2] + 8 >> 2] >> 2]; + } + HEAP32[$2 + 12 >> 2] = $0; + break label$24; + } + if (!(HEAP8[HEAP32[HEAP32[$2 + 12 >> 2] + 4 >> 2] + 12 | 0] & 1 ? 0 : HEAP32[HEAP32[$2 + 12 >> 2] + 4 >> 2])) { + HEAP8[HEAP32[HEAP32[$2 + 12 >> 2] >> 2] + 12 | 0] = 1; + HEAP8[HEAP32[$2 + 12 >> 2] + 12 | 0] = 0; + void_20std____2____tree_right_rotate_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 12 >> 2]); + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + } + $0 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2]); + HEAP8[HEAP32[$2 + 12 >> 2] + 12 | 0] = HEAP8[$0 + 12 | 0] & 1; + wasm2js_i32$0 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2]), + wasm2js_i32$1 = 1, HEAP8[wasm2js_i32$0 + 12 | 0] = wasm2js_i32$1; + HEAP8[HEAP32[HEAP32[$2 + 12 >> 2] + 4 >> 2] + 12 | 0] = 1; + void_20std____2____tree_left_rotate_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2])); + break label$20; + } + continue; + } + if (!(HEAP8[HEAP32[$2 + 12 >> 2] + 12 | 0] & 1)) { + HEAP8[HEAP32[$2 + 12 >> 2] + 12 | 0] = 1; + wasm2js_i32$0 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2]), + wasm2js_i32$1 = 0, HEAP8[wasm2js_i32$0 + 12 | 0] = wasm2js_i32$1; + void_20std____2____tree_right_rotate_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2])); + if (HEAP32[$2 + 28 >> 2] == HEAP32[HEAP32[$2 + 12 >> 2] + 4 >> 2]) { + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + } + HEAP32[$2 + 12 >> 2] = HEAP32[HEAP32[HEAP32[$2 + 12 >> 2] + 4 >> 2] >> 2]; + } + label$36: { + if (!((HEAP8[HEAP32[HEAP32[$2 + 12 >> 2] >> 2] + 12 | 0] & 1 ? 0 : HEAP32[HEAP32[$2 + 12 >> 2] >> 2]) | (HEAP8[HEAP32[HEAP32[$2 + 12 >> 2] + 4 >> 2] + 12 | 0] & 1 ? 0 : HEAP32[HEAP32[$2 + 12 >> 2] + 4 >> 2]))) { + HEAP8[HEAP32[$2 + 12 >> 2] + 12 | 0] = 0; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + if (!(HEAP8[HEAP32[$2 + 16 >> 2] + 12 | 0] & 1 & HEAP32[$2 + 16 >> 2] != HEAP32[$2 + 28 >> 2])) { + HEAP8[HEAP32[$2 + 16 >> 2] + 12 | 0] = 1; + break label$20; + } + label$42: { + if (bool_20std____2____tree_is_left_child_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 16 >> 2]) & 1) { + $0 = HEAP32[std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 16 >> 2]) + 4 >> 2]; + break label$42; + } + $0 = HEAP32[HEAP32[HEAP32[$2 + 16 >> 2] + 8 >> 2] >> 2]; + } + HEAP32[$2 + 12 >> 2] = $0; + break label$36; + } + if (!(HEAP8[HEAP32[HEAP32[$2 + 12 >> 2] >> 2] + 12 | 0] & 1 ? 0 : HEAP32[HEAP32[$2 + 12 >> 2] >> 2])) { + HEAP8[HEAP32[HEAP32[$2 + 12 >> 2] + 4 >> 2] + 12 | 0] = 1; + HEAP8[HEAP32[$2 + 12 >> 2] + 12 | 0] = 0; + void_20std____2____tree_left_rotate_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 12 >> 2]); + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + } + $0 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2]); + HEAP8[HEAP32[$2 + 12 >> 2] + 12 | 0] = HEAP8[$0 + 12 | 0] & 1; + wasm2js_i32$0 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2]), + wasm2js_i32$1 = 1, HEAP8[wasm2js_i32$0 + 12 | 0] = wasm2js_i32$1; + HEAP8[HEAP32[HEAP32[$2 + 12 >> 2] >> 2] + 12 | 0] = 1; + void_20std____2____tree_right_rotate_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2])); + break label$20; + } + continue; + } + break; + } + } + } + __stack_pointer = $2 + 32 | 0; +} + +function b2GearJoint__SolvePositionConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 368 | 0; + __stack_pointer = $2; + HEAP32[$2 + 364 >> 2] = $0; + HEAP32[$2 + 360 >> 2] = $1; + $3 = HEAP32[$2 + 364 >> 2]; + $4 = HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 160 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 352 >> 2] = $1; + HEAP32[$2 + 356 >> 2] = $0; + HEAPF32[$2 + 348 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 160 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 164 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 336 >> 2] = $0; + HEAP32[$2 + 340 >> 2] = $1; + HEAPF32[$2 + 332 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 164 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 168 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 320 >> 2] = $1; + HEAP32[$2 + 324 >> 2] = $0; + HEAPF32[$2 + 316 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 168 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 172 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 304 >> 2] = $0; + HEAP32[$2 + 308 >> 2] = $1; + HEAPF32[$2 + 300 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 172 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 292 | 0, HEAPF32[$2 + 348 >> 2]); + b2Rot__b2Rot_28float_29($2 + 284 | 0, HEAPF32[$2 + 332 >> 2]); + b2Rot__b2Rot_28float_29($2 + 276 | 0, HEAPF32[$2 + 316 >> 2]); + b2Rot__b2Rot_28float_29($2 + 268 | 0, HEAPF32[$2 + 300 >> 2]); + HEAPF32[$2 + 264 >> 2] = 0; + b2Vec2__b2Vec2_28_29($2 + 248 | 0); + b2Vec2__b2Vec2_28_29($2 + 240 | 0); + HEAPF32[$2 + 220 >> 2] = 0; + label$1: { + if (HEAP32[$3 + 76 >> 2] == 1) { + b2Vec2__SetZero_28_29($2 + 248 | 0); + HEAPF32[$2 + 236 >> 2] = 1; + HEAPF32[$2 + 228 >> 2] = 1; + HEAPF32[$2 + 220 >> 2] = HEAPF32[$2 + 220 >> 2] + Math_fround(HEAPF32[$3 + 224 >> 2] + HEAPF32[$3 + 232 >> 2]); + HEAPF32[$2 + 260 >> 2] = Math_fround(HEAPF32[$2 + 348 >> 2] - HEAPF32[$2 + 316 >> 2]) - HEAPF32[$3 + 140 >> 2]; + break label$1; + } + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 212 | 0, $2 + 276 | 0, $3 + 124 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 196 | 0, $3 + 108 | 0, $3 + 192 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 204 | 0, $2 + 276 | 0, $2 + 196 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 180 | 0, $3 + 92 | 0, $3 + 176 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 188 | 0, $2 + 292 | 0, $2 + 180 | 0); + $0 = HEAP32[$2 + 216 >> 2]; + $1 = HEAP32[$2 + 212 >> 2]; + HEAP32[$2 + 248 >> 2] = $1; + HEAP32[$2 + 252 >> 2] = $0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 204 | 0, $2 + 212 | 0), + HEAPF32[wasm2js_i32$0 + 228 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 188 | 0, $2 + 212 | 0), + HEAPF32[wasm2js_i32$0 + 236 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 220 >> 2] = HEAPF32[$2 + 220 >> 2] + Math_fround(Math_fround(Math_fround(HEAPF32[$3 + 224 >> 2] * HEAPF32[$2 + 236 >> 2]) * HEAPF32[$2 + 236 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$3 + 232 >> 2] * HEAPF32[$2 + 228 >> 2]) * HEAPF32[$2 + 228 >> 2]) + Math_fround(HEAPF32[$3 + 216 >> 2] + HEAPF32[$3 + 208 >> 2]))); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 172 | 0, $3 + 108 | 0, $3 + 192 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 148 | 0, $2 + 352 | 0, $2 + 320 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 156 | 0, $2 + 188 | 0, $2 + 148 | 0); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 164 | 0, $2 + 276 | 0, $2 + 156 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 140 | 0, $2 + 164 | 0, $2 + 172 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 140 | 0, $3 + 124 | 0), + HEAPF32[wasm2js_i32$0 + 260 >> 2] = wasm2js_f32$0; + } + label$3: { + if (HEAP32[$3 + 80 >> 2] == 1) { + b2Vec2__SetZero_28_29($2 + 240 | 0); + HEAPF32[$2 + 232 >> 2] = HEAPF32[$3 + 152 >> 2]; + HEAPF32[$2 + 224 >> 2] = HEAPF32[$3 + 152 >> 2]; + HEAPF32[$2 + 220 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 152 >> 2] * HEAPF32[$3 + 152 >> 2]) * Math_fround(HEAPF32[$3 + 228 >> 2] + HEAPF32[$3 + 236 >> 2])) + HEAPF32[$2 + 220 >> 2]; + HEAPF32[$2 + 256 >> 2] = Math_fround(HEAPF32[$2 + 332 >> 2] - HEAPF32[$2 + 300 >> 2]) - HEAPF32[$3 + 144 >> 2]; + break label$3; + } + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 132 | 0, $2 + 268 | 0, $3 + 132 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 116 | 0, $3 + 116 | 0, $3 + 200 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 124 | 0, $2 + 268 | 0, $2 + 116 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 100 | 0, $3 + 100 | 0, $3 + 184 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 108 | 0, $2 + 284 | 0, $2 + 100 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 92 | 0, HEAPF32[$3 + 152 >> 2], $2 + 132 | 0); + $1 = HEAP32[$2 + 96 >> 2]; + $0 = HEAP32[$2 + 92 >> 2]; + HEAP32[$2 + 240 >> 2] = $0; + HEAP32[$2 + 244 >> 2] = $1; + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(HEAPF32[$3 + 152 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 124 | 0, $2 + 132 | 0)), + HEAPF32[wasm2js_i32$0 + 224 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(HEAPF32[$3 + 152 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 108 | 0, $2 + 132 | 0)), + HEAPF32[wasm2js_i32$0 + 232 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 220 >> 2] = HEAPF32[$2 + 220 >> 2] + Math_fround(Math_fround(Math_fround(HEAPF32[$3 + 228 >> 2] * HEAPF32[$2 + 232 >> 2]) * HEAPF32[$2 + 232 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$3 + 152 >> 2] * HEAPF32[$3 + 152 >> 2]) * Math_fround(HEAPF32[$3 + 220 >> 2] + HEAPF32[$3 + 212 >> 2])) + Math_fround(Math_fround(HEAPF32[$3 + 236 >> 2] * HEAPF32[$2 + 224 >> 2]) * HEAPF32[$2 + 224 >> 2]))); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 84 | 0, $3 + 116 | 0, $3 + 200 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 60 | 0, $2 + 336 | 0, $2 + 304 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 68 | 0, $2 + 108 | 0, $2 + 60 | 0); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 76 | 0, $2 + 268 | 0, $2 + 68 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 52 | 0, $2 + 76 | 0, $2 + 84 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 52 | 0, $3 + 132 | 0), + HEAPF32[wasm2js_i32$0 + 256 >> 2] = wasm2js_f32$0; + } + HEAPF32[$2 + 48 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 152 >> 2] * HEAPF32[$2 + 256 >> 2]) + HEAPF32[$2 + 260 >> 2]) - HEAPF32[$3 + 148 >> 2]; + HEAPF32[$2 + 44 >> 2] = 0; + if (HEAPF32[$2 + 220 >> 2] > Math_fround(0)) { + HEAPF32[$2 + 44 >> 2] = Math_fround(-HEAPF32[$2 + 48 >> 2]) / HEAPF32[$2 + 220 >> 2]; + } + operator__28float_2c_20b2Vec2_20const__29($2 + 36 | 0, Math_fround(HEAPF32[$3 + 208 >> 2] * HEAPF32[$2 + 44 >> 2]), $2 + 248 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 352 | 0, $2 + 36 | 0); + HEAPF32[$2 + 348 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 224 >> 2] * HEAPF32[$2 + 44 >> 2]) * HEAPF32[$2 + 236 >> 2]) + HEAPF32[$2 + 348 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 28 | 0, Math_fround(HEAPF32[$3 + 212 >> 2] * HEAPF32[$2 + 44 >> 2]), $2 + 240 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 336 | 0, $2 + 28 | 0); + HEAPF32[$2 + 332 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 228 >> 2] * HEAPF32[$2 + 44 >> 2]) * HEAPF32[$2 + 232 >> 2]) + HEAPF32[$2 + 332 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, Math_fround(HEAPF32[$3 + 216 >> 2] * HEAPF32[$2 + 44 >> 2]), $2 + 248 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 320 | 0, $2 + 20 | 0); + HEAPF32[$2 + 316 >> 2] = Math_fround(Math_fround(-Math_fround(HEAPF32[$3 + 232 >> 2] * HEAPF32[$2 + 44 >> 2])) * HEAPF32[$2 + 228 >> 2]) + HEAPF32[$2 + 316 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, Math_fround(HEAPF32[$3 + 220 >> 2] * HEAPF32[$2 + 44 >> 2]), $2 + 240 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 304 | 0, $2 + 12 | 0); + HEAPF32[$2 + 300 >> 2] = Math_fround(Math_fround(-Math_fround(HEAPF32[$3 + 236 >> 2] * HEAPF32[$2 + 44 >> 2])) * HEAPF32[$2 + 224 >> 2]) + HEAPF32[$2 + 300 >> 2]; + $0 = HEAP32[$2 + 356 >> 2]; + $1 = HEAP32[$2 + 352 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 160 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 160 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 348 >> 2]; + $1 = HEAP32[$2 + 340 >> 2]; + $0 = HEAP32[$2 + 336 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 164 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 164 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 332 >> 2]; + $0 = HEAP32[$2 + 324 >> 2]; + $1 = HEAP32[$2 + 320 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 168 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 168 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 316 >> 2]; + $1 = HEAP32[$2 + 308 >> 2]; + $0 = HEAP32[$2 + 304 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 172 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 360 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 172 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 300 >> 2]; + __stack_pointer = $2 + 368 | 0; + return HEAPF32[$2 + 264 >> 2] < Math_fround(.004999999888241291) | 0; +} + +function b2World__DebugDraw_28_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 288 | 0; + __stack_pointer = $1; + HEAP32[$1 + 284 >> 2] = $0; + $3 = HEAP32[$1 + 284 >> 2]; + label$1: { + if (!HEAP32[$3 + 102980 >> 2]) { + break label$1; + } + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Draw__GetFlags_28_29_20const(HEAP32[$3 + 102980 >> 2]), + HEAP32[wasm2js_i32$0 + 280 >> 2] = wasm2js_i32$1; + if (HEAP32[$1 + 280 >> 2] & 1) { + HEAP32[$1 + 276 >> 2] = HEAP32[$3 + 102948 >> 2]; + while (1) { + if (HEAP32[$1 + 276 >> 2]) { + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Body__GetTransform_28_29_20const(HEAP32[$1 + 276 >> 2]), + HEAP32[wasm2js_i32$0 + 272 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Body__GetFixtureList_28_29(HEAP32[$1 + 276 >> 2]), + HEAP32[wasm2js_i32$0 + 268 >> 2] = wasm2js_i32$1; + while (1) { + if (HEAP32[$1 + 268 >> 2]) { + label$7: { + if (!((b2Body__GetType_28_29_20const(HEAP32[$1 + 276 >> 2]) | 0) != 2 | HEAPF32[HEAP32[$1 + 276 >> 2] + 116 >> 2] != Math_fround(0))) { + $0 = HEAP32[$1 + 268 >> 2]; + $2 = HEAP32[$1 + 272 >> 2]; + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($1 + 252 | 0, Math_fround(1), Math_fround(0), Math_fround(0), Math_fround(1)); + b2World__DrawShape_28b2Fixture__2c_20b2Transform_20const__2c_20b2Color_20const__29($3, $0, $2, $1 + 252 | 0); + break label$7; + } + label$9: { + if (!(b2Body__IsEnabled_28_29_20const(HEAP32[$1 + 276 >> 2]) & 1)) { + $0 = HEAP32[$1 + 268 >> 2]; + $2 = HEAP32[$1 + 272 >> 2]; + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($1 + 236 | 0, Math_fround(.5), Math_fround(.5), Math_fround(.30000001192092896), Math_fround(1)); + b2World__DrawShape_28b2Fixture__2c_20b2Transform_20const__2c_20b2Color_20const__29($3, $0, $2, $1 + 236 | 0); + break label$9; + } + label$11: { + if (!b2Body__GetType_28_29_20const(HEAP32[$1 + 276 >> 2])) { + $0 = HEAP32[$1 + 268 >> 2]; + $2 = HEAP32[$1 + 272 >> 2]; + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($1 + 220 | 0, Math_fround(.5), Math_fround(.8999999761581421), Math_fround(.5), Math_fround(1)); + b2World__DrawShape_28b2Fixture__2c_20b2Transform_20const__2c_20b2Color_20const__29($3, $0, $2, $1 + 220 | 0); + break label$11; + } + label$13: { + if ((b2Body__GetType_28_29_20const(HEAP32[$1 + 276 >> 2]) | 0) == 1) { + $0 = HEAP32[$1 + 268 >> 2]; + $2 = HEAP32[$1 + 272 >> 2]; + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($1 + 204 | 0, Math_fround(.5), Math_fround(.5), Math_fround(.8999999761581421), Math_fround(1)); + b2World__DrawShape_28b2Fixture__2c_20b2Transform_20const__2c_20b2Color_20const__29($3, $0, $2, $1 + 204 | 0); + break label$13; + } + label$15: { + if (!(b2Body__IsAwake_28_29_20const(HEAP32[$1 + 276 >> 2]) & 1)) { + $0 = HEAP32[$1 + 268 >> 2]; + $2 = HEAP32[$1 + 272 >> 2]; + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($1 + 188 | 0, Math_fround(.6000000238418579), Math_fround(.6000000238418579), Math_fround(.6000000238418579), Math_fround(1)); + b2World__DrawShape_28b2Fixture__2c_20b2Transform_20const__2c_20b2Color_20const__29($3, $0, $2, $1 + 188 | 0); + break label$15; + } + $0 = HEAP32[$1 + 268 >> 2]; + $2 = HEAP32[$1 + 272 >> 2]; + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($1 + 172 | 0, Math_fround(.8999999761581421), Math_fround(.699999988079071), Math_fround(.699999988079071), Math_fround(1)); + b2World__DrawShape_28b2Fixture__2c_20b2Transform_20const__2c_20b2Color_20const__29($3, $0, $2, $1 + 172 | 0); + } + } + } + } + } + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Fixture__GetNext_28_29(HEAP32[$1 + 268 >> 2]), + HEAP32[wasm2js_i32$0 + 268 >> 2] = wasm2js_i32$1; + continue; + } + break; + } + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Body__GetNext_28_29(HEAP32[$1 + 276 >> 2]), + HEAP32[wasm2js_i32$0 + 276 >> 2] = wasm2js_i32$1; + continue; + } + break; + } + } + if (HEAP32[$1 + 280 >> 2] & 2) { + HEAP32[$1 + 168 >> 2] = HEAP32[$3 + 102952 >> 2]; + while (1) { + if (HEAP32[$1 + 168 >> 2]) { + $0 = HEAP32[$1 + 168 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, HEAP32[$3 + 102980 >> 2]); + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Joint__GetNext_28_29(HEAP32[$1 + 168 >> 2]), + HEAP32[wasm2js_i32$0 + 168 >> 2] = wasm2js_i32$1; + continue; + } + break; + } + } + if (HEAP32[$1 + 280 >> 2] & 8) { + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($1 + 152 | 0, Math_fround(.30000001192092896), Math_fround(.8999999761581421), Math_fround(.8999999761581421), Math_fround(1)); + HEAP32[$1 + 148 >> 2] = HEAP32[$3 + 102928 >> 2]; + while (1) { + if (HEAP32[$1 + 148 >> 2]) { + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetFixtureA_28_29(HEAP32[$1 + 148 >> 2]), + HEAP32[wasm2js_i32$0 + 144 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetFixtureB_28_29(HEAP32[$1 + 148 >> 2]), + HEAP32[wasm2js_i32$0 + 140 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetChildIndexA_28_29_20const(HEAP32[$1 + 148 >> 2]), + HEAP32[wasm2js_i32$0 + 136 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetChildIndexB_28_29_20const(HEAP32[$1 + 148 >> 2]), + HEAP32[wasm2js_i32$0 + 132 >> 2] = wasm2js_i32$1; + b2AABB__GetCenter_28_29_20const($1 + 124 | 0, b2Fixture__GetAABB_28int_29_20const(HEAP32[$1 + 144 >> 2], HEAP32[$1 + 136 >> 2])); + b2AABB__GetCenter_28_29_20const($1 + 116 | 0, b2Fixture__GetAABB_28int_29_20const(HEAP32[$1 + 140 >> 2], HEAP32[$1 + 132 >> 2])); + $0 = HEAP32[$3 + 102980 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $1 + 124 | 0, $1 + 116 | 0, $1 + 152 | 0); + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetNext_28_29(HEAP32[$1 + 148 >> 2]), + HEAP32[wasm2js_i32$0 + 148 >> 2] = wasm2js_i32$1; + continue; + } + break; + } + } + if (HEAP32[$1 + 280 >> 2] & 4) { + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($1 + 100 | 0, Math_fround(.8999999761581421), Math_fround(.30000001192092896), Math_fround(.8999999761581421), Math_fround(1)); + HEAP32[$1 + 96 >> 2] = $3 + 102868; + HEAP32[$1 + 92 >> 2] = HEAP32[$3 + 102948 >> 2]; + while (1) { + if (HEAP32[$1 + 92 >> 2]) { + if (b2Body__IsEnabled_28_29_20const(HEAP32[$1 + 92 >> 2]) & 1) { + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Body__GetFixtureList_28_29(HEAP32[$1 + 92 >> 2]), + HEAP32[wasm2js_i32$0 + 88 >> 2] = wasm2js_i32$1; + while (1) { + if (HEAP32[$1 + 88 >> 2]) { + HEAP32[$1 + 84 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 84 >> 2] < HEAP32[HEAP32[$1 + 88 >> 2] + 28 >> 2]) { + HEAP32[$1 + 80 >> 2] = HEAP32[HEAP32[$1 + 88 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 84 >> 2], 28); + $4 = b2BroadPhase__GetFatAABB_28int_29_20const(HEAP32[$1 + 96 >> 2], HEAP32[HEAP32[$1 + 80 >> 2] + 24 >> 2]); + $2 = HEAP32[$4 + 8 >> 2]; + $0 = HEAP32[$4 + 12 >> 2]; + HEAP32[$1 + 72 >> 2] = $2; + HEAP32[$1 + 76 >> 2] = $0; + $2 = HEAP32[$4 + 4 >> 2]; + $0 = HEAP32[$4 >> 2]; + HEAP32[$1 + 64 >> 2] = $0; + HEAP32[$1 + 68 >> 2] = $2; + $0 = $1 + 32 | 0; + $2 = $0 + 32 | 0; + while (1) { + b2Vec2__b2Vec2_28_29($0); + $0 = $0 + 8 | 0; + if (($2 | 0) != ($0 | 0)) { + continue; + } + break; + } + b2Vec2__Set_28float_2c_20float_29($1 + 32 | 0, HEAPF32[$1 + 64 >> 2], HEAPF32[$1 + 68 >> 2]); + b2Vec2__Set_28float_2c_20float_29($1 + 40 | 0, HEAPF32[$1 + 72 >> 2], HEAPF32[$1 + 68 >> 2]); + b2Vec2__Set_28float_2c_20float_29($1 + 48 | 0, HEAPF32[$1 + 72 >> 2], HEAPF32[$1 + 76 >> 2]); + b2Vec2__Set_28float_2c_20float_29($1 + 56 | 0, HEAPF32[$1 + 64 >> 2], HEAPF32[$1 + 76 >> 2]); + $0 = HEAP32[$3 + 102980 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 8 >> 2]]($0, $1 + 32 | 0, 4, $1 + 100 | 0); + HEAP32[$1 + 84 >> 2] = HEAP32[$1 + 84 >> 2] + 1; + continue; + } + break; + } + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Fixture__GetNext_28_29(HEAP32[$1 + 88 >> 2]), + HEAP32[wasm2js_i32$0 + 88 >> 2] = wasm2js_i32$1; + continue; + } + break; + } + } + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Body__GetNext_28_29(HEAP32[$1 + 92 >> 2]), + HEAP32[wasm2js_i32$0 + 92 >> 2] = wasm2js_i32$1; + continue; + } + break; + } + } + if (!(HEAP32[$1 + 280 >> 2] & 16)) { + break label$1; + } + HEAP32[$1 + 28 >> 2] = HEAP32[$3 + 102948 >> 2]; + while (1) { + if (HEAP32[$1 + 28 >> 2]) { + $4 = b2Body__GetTransform_28_29_20const(HEAP32[$1 + 28 >> 2]); + $2 = HEAP32[$4 + 8 >> 2]; + $0 = HEAP32[$4 + 12 >> 2]; + HEAP32[$1 + 16 >> 2] = $2; + HEAP32[$1 + 20 >> 2] = $0; + $2 = HEAP32[$4 + 4 >> 2]; + $0 = HEAP32[$4 >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 + 12 >> 2] = $2; + $4 = b2Body__GetWorldCenter_28_29_20const(HEAP32[$1 + 28 >> 2]); + $2 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + $4 = $2; + $2 = $1 + 8 | 0; + HEAP32[$2 >> 2] = $4; + HEAP32[$2 + 4 >> 2] = $0; + $0 = HEAP32[$3 + 102980 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 28 >> 2]]($0, $1 + 8 | 0); + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Body__GetNext_28_29(HEAP32[$1 + 28 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + continue; + } + break; + } + } + __stack_pointer = $1 + 288 | 0; +} + +function b2TimeOfImpact_28b2TOIOutput__2c_20b2TOIInput_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0), wasm2js_i32$1 = 0; + $2 = __stack_pointer - 448 | 0; + __stack_pointer = $2; + HEAP32[$2 + 444 >> 2] = $0; + HEAP32[$2 + 440 >> 2] = $1; + b2Timer__b2Timer_28_29($2 + 439 | 0); + HEAP32[7747] = HEAP32[7747] + 1; + HEAP32[HEAP32[$2 + 444 >> 2] >> 2] = 0; + HEAPF32[HEAP32[$2 + 444 >> 2] + 4 >> 2] = HEAPF32[HEAP32[$2 + 440 >> 2] + 128 >> 2]; + HEAP32[$2 + 432 >> 2] = HEAP32[$2 + 440 >> 2]; + HEAP32[$2 + 428 >> 2] = HEAP32[$2 + 440 >> 2] + 28; + $3 = HEAP32[$2 + 440 >> 2]; + HEAP32[$2 + 424 >> 2] = HEAP32[$3 + 88 >> 2]; + $1 = HEAP32[$3 + 80 >> 2]; + $0 = HEAP32[$3 + 84 >> 2]; + HEAP32[$2 + 416 >> 2] = $1; + HEAP32[$2 + 420 >> 2] = $0; + $1 = HEAP32[$3 + 76 >> 2]; + $0 = HEAP32[$3 + 72 >> 2]; + HEAP32[$2 + 408 >> 2] = $0; + HEAP32[$2 + 412 >> 2] = $1; + $0 = HEAP32[$3 + 68 >> 2]; + $1 = HEAP32[$3 + 64 >> 2]; + HEAP32[$2 + 400 >> 2] = $1; + HEAP32[$2 + 404 >> 2] = $0; + $1 = HEAP32[$3 + 60 >> 2]; + $0 = HEAP32[$3 + 56 >> 2]; + HEAP32[$2 + 392 >> 2] = $0; + HEAP32[$2 + 396 >> 2] = $1; + $3 = HEAP32[$2 + 440 >> 2]; + HEAP32[$2 + 384 >> 2] = HEAP32[$3 + 124 >> 2]; + $1 = HEAP32[$3 + 116 >> 2]; + $0 = HEAP32[$3 + 120 >> 2]; + HEAP32[$2 + 376 >> 2] = $1; + HEAP32[$2 + 380 >> 2] = $0; + $1 = HEAP32[$3 + 112 >> 2]; + $0 = HEAP32[$3 + 108 >> 2]; + HEAP32[$2 + 368 >> 2] = $0; + HEAP32[$2 + 372 >> 2] = $1; + $0 = HEAP32[$3 + 104 >> 2]; + $1 = HEAP32[$3 + 100 >> 2]; + HEAP32[$2 + 360 >> 2] = $1; + HEAP32[$2 + 364 >> 2] = $0; + $1 = HEAP32[$3 + 96 >> 2]; + $0 = HEAP32[$3 + 92 >> 2]; + HEAP32[$2 + 352 >> 2] = $0; + HEAP32[$2 + 356 >> 2] = $1; + b2Sweep__Normalize_28_29($2 + 392 | 0); + b2Sweep__Normalize_28_29($2 + 352 | 0); + HEAPF32[$2 + 348 >> 2] = HEAPF32[HEAP32[$2 + 440 >> 2] + 128 >> 2]; + HEAPF32[$2 + 344 >> 2] = HEAPF32[HEAP32[$2 + 432 >> 2] + 24 >> 2] + HEAPF32[HEAP32[$2 + 428 >> 2] + 24 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(Math_fround(.004999999888241291), Math_fround(HEAPF32[$2 + 344 >> 2] + Math_fround(-.014999999664723873))), + HEAPF32[wasm2js_i32$0 + 340 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 336 >> 2] = .0012499999720603228; + if (!(HEAPF32[$2 + 340 >> 2] > HEAPF32[$2 + 336 >> 2])) { + __assert_fail(9994, 5216, 283, 3213); + wasm2js_trap(); + } + HEAPF32[$2 + 332 >> 2] = 0; + HEAP32[$2 + 328 >> 2] = 20; + HEAP32[$2 + 324 >> 2] = 0; + HEAP16[$2 + 316 >> 1] = 0; + b2DistanceInput__b2DistanceInput_28_29($2 + 220 | 0); + $3 = HEAP32[$2 + 440 >> 2]; + $1 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + $5 = $1; + $4 = $2 + 220 | 0; + $1 = $4; + HEAP32[$1 >> 2] = $5; + HEAP32[$1 + 4 >> 2] = $0; + HEAP32[$1 + 24 >> 2] = HEAP32[$3 + 24 >> 2]; + $1 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 16 >> 2]; + $5 = $0; + $0 = $4; + HEAP32[$0 + 16 >> 2] = $5; + HEAP32[$0 + 20 >> 2] = $1; + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$3 + 8 >> 2]; + $3 = $1; + $1 = $4; + HEAP32[$1 + 8 >> 2] = $3; + HEAP32[$1 + 12 >> 2] = $0; + $3 = HEAP32[$2 + 440 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $1 = HEAP32[$3 + 32 >> 2]; + $5 = $0; + $4 = $2 + 220 | 0; + $0 = $4; + HEAP32[$0 + 28 >> 2] = $5; + HEAP32[$0 + 32 >> 2] = $1; + HEAP32[$0 + 52 >> 2] = HEAP32[$3 + 52 >> 2]; + $0 = HEAP32[$3 + 48 >> 2]; + $1 = HEAP32[$3 + 44 >> 2]; + $5 = $1; + $1 = $4; + HEAP32[$1 + 44 >> 2] = $5; + HEAP32[$1 + 48 >> 2] = $0; + $1 = HEAP32[$3 + 40 >> 2]; + $0 = HEAP32[$3 + 36 >> 2]; + $3 = $0; + $0 = $4; + HEAP32[$0 + 36 >> 2] = $3; + HEAP32[$0 + 40 >> 2] = $1; + HEAP8[$2 + 308 | 0] = 0; + while (1) { + label$3: { + b2Transform__b2Transform_28_29($2 + 204 | 0); + b2Transform__b2Transform_28_29($2 + 188 | 0); + b2Sweep__GetTransform_28b2Transform__2c_20float_29_20const($2 + 392 | 0, $2 + 204 | 0, HEAPF32[$2 + 332 >> 2]); + b2Sweep__GetTransform_28b2Transform__2c_20float_29_20const($2 + 352 | 0, $2 + 188 | 0, HEAPF32[$2 + 332 >> 2]); + $0 = HEAP32[$2 + 208 >> 2]; + $1 = HEAP32[$2 + 204 >> 2]; + $4 = $1; + $3 = $2 + 220 | 0; + $1 = $3; + HEAP32[$1 + 56 >> 2] = $4; + HEAP32[$1 + 60 >> 2] = $0; + $1 = HEAP32[$2 + 216 >> 2]; + $0 = HEAP32[$2 + 212 >> 2]; + $4 = $0; + $0 = $3; + HEAP32[$0 + 64 >> 2] = $4; + HEAP32[$0 + 68 >> 2] = $1; + $0 = HEAP32[$2 + 192 >> 2]; + $1 = HEAP32[$2 + 188 >> 2]; + $4 = $1; + $3 = $2 + 220 | 0; + $1 = $3; + HEAP32[$1 + 72 >> 2] = $4; + HEAP32[$1 + 76 >> 2] = $0; + $1 = HEAP32[$2 + 200 >> 2]; + $0 = HEAP32[$2 + 196 >> 2]; + $4 = $0; + $0 = $3; + HEAP32[$0 + 80 >> 2] = $4; + HEAP32[$0 + 84 >> 2] = $1; + b2DistanceOutput__b2DistanceOutput_28_29($2 + 164 | 0); + b2Distance_28b2DistanceOutput__2c_20b2SimplexCache__2c_20b2DistanceInput_20const__29($2 + 164 | 0, $2 + 312 | 0, $2 + 220 | 0); + if (HEAPF32[$2 + 180 >> 2] <= Math_fround(0)) { + HEAP32[HEAP32[$2 + 444 >> 2] >> 2] = 2; + HEAPF32[HEAP32[$2 + 444 >> 2] + 4 >> 2] = 0; + break label$3; + } + if (HEAPF32[$2 + 180 >> 2] < Math_fround(HEAPF32[$2 + 340 >> 2] + HEAPF32[$2 + 336 >> 2])) { + HEAP32[HEAP32[$2 + 444 >> 2] >> 2] = 3; + HEAPF32[HEAP32[$2 + 444 >> 2] + 4 >> 2] = HEAPF32[$2 + 332 >> 2]; + break label$3; + } + b2SeparationFunction__b2SeparationFunction_28_29($2 - -64 | 0); + b2SeparationFunction__Initialize_28b2SimplexCache_20const__2c_20b2DistanceProxy_20const__2c_20b2Sweep_20const__2c_20b2DistanceProxy_20const__2c_20b2Sweep_20const__2c_20float_29($2 - -64 | 0, $2 + 312 | 0, HEAP32[$2 + 432 >> 2], $2 + 392 | 0, HEAP32[$2 + 428 >> 2], $2 + 352 | 0, HEAPF32[$2 + 332 >> 2]); + HEAP8[$2 + 63 | 0] = 0; + HEAPF32[$2 + 56 >> 2] = HEAPF32[$2 + 348 >> 2]; + HEAP32[$2 + 52 >> 2] = 0; + while (1) { + label$7: { + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2SeparationFunction__FindMinSeparation_28int__2c_20int__2c_20float_29_20const($2 - -64 | 0, $2 + 48 | 0, $2 + 44 | 0, HEAPF32[$2 + 56 >> 2]), + HEAPF32[wasm2js_i32$0 + 40 >> 2] = wasm2js_f32$0; + if (HEAPF32[$2 + 40 >> 2] > Math_fround(HEAPF32[$2 + 340 >> 2] + HEAPF32[$2 + 336 >> 2])) { + HEAP32[HEAP32[$2 + 444 >> 2] >> 2] = 4; + HEAPF32[HEAP32[$2 + 444 >> 2] + 4 >> 2] = HEAPF32[$2 + 348 >> 2]; + HEAP8[$2 + 63 | 0] = 1; + break label$7; + } + if (HEAPF32[$2 + 40 >> 2] > Math_fround(HEAPF32[$2 + 340 >> 2] - HEAPF32[$2 + 336 >> 2])) { + HEAPF32[$2 + 332 >> 2] = HEAPF32[$2 + 56 >> 2]; + break label$7; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2SeparationFunction__Evaluate_28int_2c_20int_2c_20float_29_20const($2 - -64 | 0, HEAP32[$2 + 48 >> 2], HEAP32[$2 + 44 >> 2], HEAPF32[$2 + 332 >> 2]), + HEAPF32[wasm2js_i32$0 + 36 >> 2] = wasm2js_f32$0; + if (HEAPF32[$2 + 36 >> 2] < Math_fround(HEAPF32[$2 + 340 >> 2] - HEAPF32[$2 + 336 >> 2])) { + HEAP32[HEAP32[$2 + 444 >> 2] >> 2] = 1; + HEAPF32[HEAP32[$2 + 444 >> 2] + 4 >> 2] = HEAPF32[$2 + 332 >> 2]; + HEAP8[$2 + 63 | 0] = 1; + break label$7; + } + if (HEAPF32[$2 + 36 >> 2] <= Math_fround(HEAPF32[$2 + 340 >> 2] + HEAPF32[$2 + 336 >> 2])) { + HEAP32[HEAP32[$2 + 444 >> 2] >> 2] = 3; + HEAPF32[HEAP32[$2 + 444 >> 2] + 4 >> 2] = HEAPF32[$2 + 332 >> 2]; + HEAP8[$2 + 63 | 0] = 1; + break label$7; + } + HEAP32[$2 + 32 >> 2] = 0; + HEAPF32[$2 + 28 >> 2] = HEAPF32[$2 + 332 >> 2]; + HEAPF32[$2 + 24 >> 2] = HEAPF32[$2 + 56 >> 2]; + while (1) { + label$13: { + if (HEAP32[$2 + 32 >> 2] & 1) { + HEAPF32[$2 + 20 >> 2] = HEAPF32[$2 + 28 >> 2] + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 340 >> 2] - HEAPF32[$2 + 36 >> 2]) * Math_fround(HEAPF32[$2 + 24 >> 2] - HEAPF32[$2 + 28 >> 2])) / Math_fround(HEAPF32[$2 + 40 >> 2] - HEAPF32[$2 + 36 >> 2])); + break label$13; + } + HEAPF32[$2 + 20 >> 2] = Math_fround(HEAPF32[$2 + 28 >> 2] + HEAPF32[$2 + 24 >> 2]) * Math_fround(.5); + } + HEAP32[$2 + 32 >> 2] = HEAP32[$2 + 32 >> 2] + 1; + HEAP32[7750] = HEAP32[7750] + 1; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2SeparationFunction__Evaluate_28int_2c_20int_2c_20float_29_20const($2 - -64 | 0, HEAP32[$2 + 48 >> 2], HEAP32[$2 + 44 >> 2], HEAPF32[$2 + 20 >> 2]), + HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0; + label$15: { + if (float_20b2Abs_float__28float_29(Math_fround(HEAPF32[$2 + 16 >> 2] - HEAPF32[$2 + 340 >> 2])) < HEAPF32[$2 + 336 >> 2]) { + HEAPF32[$2 + 56 >> 2] = HEAPF32[$2 + 20 >> 2]; + break label$15; + } + label$17: { + if (HEAPF32[$2 + 16 >> 2] > HEAPF32[$2 + 340 >> 2]) { + HEAPF32[$2 + 28 >> 2] = HEAPF32[$2 + 20 >> 2]; + HEAPF32[$2 + 36 >> 2] = HEAPF32[$2 + 16 >> 2]; + break label$17; + } + HEAPF32[$2 + 24 >> 2] = HEAPF32[$2 + 20 >> 2]; + HEAPF32[$2 + 40 >> 2] = HEAPF32[$2 + 16 >> 2]; + } + if (HEAP32[$2 + 32 >> 2] == 50) { + break label$15; + } + continue; + } + break; + } + wasm2js_i32$0 = 31004, wasm2js_i32$1 = int_20b2Max_int__28int_2c_20int_29(HEAP32[7751], HEAP32[$2 + 32 >> 2]), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP32[$2 + 52 >> 2] = HEAP32[$2 + 52 >> 2] + 1; + if (HEAP32[$2 + 52 >> 2] != 8) { + continue; + } + } + break; + } + HEAP32[$2 + 324 >> 2] = HEAP32[$2 + 324 >> 2] + 1; + HEAP32[7748] = HEAP32[7748] + 1; + if (HEAP8[$2 + 63 | 0] & 1) { + break label$3; + } + if (HEAP32[$2 + 324 >> 2] != 20) { + continue; + } + HEAP32[HEAP32[$2 + 444 >> 2] >> 2] = 1; + HEAPF32[HEAP32[$2 + 444 >> 2] + 4 >> 2] = HEAPF32[$2 + 332 >> 2]; + } + break; + } + wasm2js_i32$0 = 30996, wasm2js_i32$1 = int_20b2Max_int__28int_2c_20int_29(HEAP32[7749], HEAP32[$2 + 324 >> 2]), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Timer__GetMilliseconds_28_29_20const($2 + 439 | 0), + HEAPF32[wasm2js_i32$0 + 12 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = 30984, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(HEAPF32[7746], HEAPF32[$2 + 12 >> 2]), + HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0; + HEAPF32[7745] = HEAPF32[7745] + HEAPF32[$2 + 12 >> 2]; + __stack_pointer = $2 + 448 | 0; +} + +function b2WheelJoint__InitVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 256 | 0; + __stack_pointer = $2; + HEAP32[$2 + 252 >> 2] = $0; + HEAP32[$2 + 248 >> 2] = $1; + $3 = HEAP32[$2 + 252 >> 2]; + HEAP32[$3 + 152 >> 2] = HEAP32[HEAP32[$3 + 48 >> 2] + 8 >> 2]; + HEAP32[$3 + 156 >> 2] = HEAP32[HEAP32[$3 + 52 >> 2] + 8 >> 2]; + $4 = HEAP32[$3 + 48 >> 2]; + $0 = HEAP32[$4 + 28 >> 2]; + $1 = HEAP32[$4 + 32 >> 2]; + HEAP32[$3 + 160 >> 2] = $0; + HEAP32[$3 + 164 >> 2] = $1; + $4 = HEAP32[$3 + 52 >> 2]; + $1 = HEAP32[$4 + 28 >> 2]; + $0 = HEAP32[$4 + 32 >> 2]; + HEAP32[$3 + 168 >> 2] = $1; + HEAP32[$3 + 172 >> 2] = $0; + HEAPF32[$3 + 176 >> 2] = HEAPF32[HEAP32[$3 + 48 >> 2] + 120 >> 2]; + HEAPF32[$3 + 180 >> 2] = HEAPF32[HEAP32[$3 + 52 >> 2] + 120 >> 2]; + HEAPF32[$3 + 184 >> 2] = HEAPF32[HEAP32[$3 + 48 >> 2] + 128 >> 2]; + HEAPF32[$3 + 188 >> 2] = HEAPF32[HEAP32[$3 + 52 >> 2] + 128 >> 2]; + HEAPF32[$2 + 244 >> 2] = HEAPF32[$3 + 176 >> 2]; + HEAPF32[$2 + 240 >> 2] = HEAPF32[$3 + 180 >> 2]; + HEAPF32[$2 + 236 >> 2] = HEAPF32[$3 + 184 >> 2]; + HEAPF32[$2 + 232 >> 2] = HEAPF32[$3 + 188 >> 2]; + $4 = HEAP32[HEAP32[$2 + 248 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 224 >> 2] = $0; + HEAP32[$2 + 228 >> 2] = $1; + HEAPF32[$2 + 220 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 208 >> 2] = $1; + HEAP32[$2 + 212 >> 2] = $0; + HEAPF32[$2 + 204 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 248 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 192 >> 2] = $0; + HEAP32[$2 + 196 >> 2] = $1; + HEAPF32[$2 + 188 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 176 >> 2] = $1; + HEAP32[$2 + 180 >> 2] = $0; + HEAPF32[$2 + 172 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 164 | 0, HEAPF32[$2 + 220 >> 2]); + b2Rot__b2Rot_28float_29($2 + 156 | 0, HEAPF32[$2 + 188 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 140 | 0, $3 + 68 | 0, $3 + 160 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 148 | 0, $2 + 164 | 0, $2 + 140 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 124 | 0, $3 + 76 | 0, $3 + 168 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 132 | 0, $2 + 156 | 0, $2 + 124 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 100 | 0, $2 + 192 | 0, $2 + 132 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 108 | 0, $2 + 100 | 0, $2 + 224 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 116 | 0, $2 + 108 | 0, $2 + 148 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 92 | 0, $2 + 164 | 0, $3 + 92 | 0); + $1 = HEAP32[$2 + 96 >> 2]; + $0 = HEAP32[$2 + 92 >> 2]; + HEAP32[$3 + 200 >> 2] = $0; + HEAP32[$3 + 204 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 84 | 0, $2 + 116 | 0, $2 + 148 | 0); + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 84 | 0, $3 + 200 | 0), + HEAPF32[wasm2js_i32$0 + 216 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 132 | 0, $3 + 200 | 0), + HEAPF32[wasm2js_i32$0 + 220 >> 2] = wasm2js_f32$0; + HEAPF32[$3 + 224 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 232 >> 2] * HEAPF32[$3 + 220 >> 2]) * HEAPF32[$3 + 220 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 236 >> 2] * HEAPF32[$3 + 216 >> 2]) * HEAPF32[$3 + 216 >> 2]) + Math_fround(HEAPF32[$2 + 244 >> 2] + HEAPF32[$2 + 240 >> 2])); + if (HEAPF32[$3 + 224 >> 2] > Math_fround(0)) { + HEAPF32[$3 + 224 >> 2] = Math_fround(1) / HEAPF32[$3 + 224 >> 2]; + } + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 76 | 0, $2 + 164 | 0, $3 + 84 | 0); + $0 = HEAP32[$2 + 80 >> 2]; + $1 = HEAP32[$2 + 76 >> 2]; + HEAP32[$3 + 192 >> 2] = $1; + HEAP32[$3 + 196 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 68 | 0, $2 + 116 | 0, $2 + 148 | 0); + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 68 | 0, $3 + 192 | 0), + HEAPF32[wasm2js_i32$0 + 208 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 132 | 0, $3 + 192 | 0), + HEAPF32[wasm2js_i32$0 + 212 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 64 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 232 >> 2] * HEAPF32[$3 + 212 >> 2]) * HEAPF32[$3 + 212 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 236 >> 2] * HEAPF32[$3 + 208 >> 2]) * HEAPF32[$3 + 208 >> 2]) + Math_fround(HEAPF32[$2 + 244 >> 2] + HEAPF32[$2 + 240 >> 2])); + label$2: { + if (HEAPF32[$2 + 64 >> 2] > Math_fround(0)) { + HEAPF32[$3 + 232 >> 2] = Math_fround(1) / HEAPF32[$2 + 64 >> 2]; + break label$2; + } + HEAPF32[$3 + 232 >> 2] = 0; + } + HEAPF32[$3 + 236 >> 2] = 0; + HEAPF32[$3 + 240 >> 2] = 0; + HEAPF32[$3 + 244 >> 2] = 0; + label$4: { + if (!(!(HEAPF32[$3 + 144 >> 2] > Math_fround(0)) | !(HEAPF32[$2 + 64 >> 2] > Math_fround(0)))) { + HEAPF32[$3 + 236 >> 2] = Math_fround(1) / HEAPF32[$2 + 64 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 116 | 0, $3 + 192 | 0), + HEAPF32[wasm2js_i32$0 + 60 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 56 >> 2] = HEAPF32[HEAP32[$2 + 248 >> 2] >> 2]; + HEAPF32[$3 + 244 >> 2] = HEAPF32[$2 + 56 >> 2] * Math_fround(Math_fround(HEAPF32[$2 + 56 >> 2] * HEAPF32[$3 + 144 >> 2]) + HEAPF32[$3 + 148 >> 2]); + if (HEAPF32[$3 + 244 >> 2] > Math_fround(0)) { + HEAPF32[$3 + 244 >> 2] = Math_fround(1) / HEAPF32[$3 + 244 >> 2]; + } + HEAPF32[$3 + 240 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 60 >> 2] * HEAPF32[$2 + 56 >> 2]) * HEAPF32[$3 + 144 >> 2]) * HEAPF32[$3 + 244 >> 2]; + HEAPF32[$3 + 236 >> 2] = HEAPF32[$2 + 64 >> 2] + HEAPF32[$3 + 244 >> 2]; + if (HEAPF32[$3 + 236 >> 2] > Math_fround(0)) { + HEAPF32[$3 + 236 >> 2] = Math_fround(1) / HEAPF32[$3 + 236 >> 2]; + } + break label$4; + } + HEAPF32[$3 + 108 >> 2] = 0; + } + label$8: { + if (HEAP8[$3 + 140 | 0] & 1) { + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 192 | 0, $2 + 116 | 0), + HEAPF32[wasm2js_i32$0 + 120 >> 2] = wasm2js_f32$0; + break label$8; + } + HEAPF32[$3 + 112 >> 2] = 0; + HEAPF32[$3 + 116 >> 2] = 0; + } + label$10: { + if (HEAP8[$3 + 141 | 0] & 1) { + HEAPF32[$3 + 228 >> 2] = HEAPF32[$2 + 236 >> 2] + HEAPF32[$2 + 232 >> 2]; + if (HEAPF32[$3 + 228 >> 2] > Math_fround(0)) { + HEAPF32[$3 + 228 >> 2] = Math_fround(1) / HEAPF32[$3 + 228 >> 2]; + } + break label$10; + } + HEAPF32[$3 + 228 >> 2] = 0; + HEAPF32[$3 + 104 >> 2] = 0; + } + label$13: { + if (HEAP8[HEAP32[$2 + 248 >> 2] + 20 | 0] & 1) { + HEAPF32[$3 + 100 >> 2] = HEAPF32[$3 + 100 >> 2] * HEAPF32[HEAP32[$2 + 248 >> 2] + 8 >> 2]; + HEAPF32[$3 + 108 >> 2] = HEAPF32[$3 + 108 >> 2] * HEAPF32[HEAP32[$2 + 248 >> 2] + 8 >> 2]; + HEAPF32[$3 + 104 >> 2] = HEAPF32[$3 + 104 >> 2] * HEAPF32[HEAP32[$2 + 248 >> 2] + 8 >> 2]; + HEAPF32[$2 + 52 >> 2] = Math_fround(HEAPF32[$3 + 108 >> 2] + HEAPF32[$3 + 112 >> 2]) - HEAPF32[$3 + 116 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 36 | 0, HEAPF32[$3 + 100 >> 2], $3 + 200 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 28 | 0, HEAPF32[$2 + 52 >> 2], $3 + 192 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 44 | 0, $2 + 36 | 0, $2 + 28 | 0); + HEAPF32[$2 + 24 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 100 >> 2] * HEAPF32[$3 + 216 >> 2]) + Math_fround(HEAPF32[$2 + 52 >> 2] * HEAPF32[$3 + 208 >> 2])) + HEAPF32[$3 + 104 >> 2]; + HEAPF32[$2 + 20 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 100 >> 2] * HEAPF32[$3 + 220 >> 2]) + Math_fround(HEAPF32[$2 + 52 >> 2] * HEAPF32[$3 + 212 >> 2])) + HEAPF32[$3 + 104 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$3 + 176 >> 2], $2 + 44 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 208 | 0, $2 + 12 | 0); + HEAPF32[$2 + 204 >> 2] = Math_fround(Math_fround(-HEAPF32[$3 + 184 >> 2]) * HEAPF32[$2 + 24 >> 2]) + HEAPF32[$2 + 204 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 4 | 0, HEAPF32[$3 + 180 >> 2], $2 + 44 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 176 | 0, $2 + 4 | 0); + HEAPF32[$2 + 172 >> 2] = Math_fround(HEAPF32[$3 + 188 >> 2] * HEAPF32[$2 + 20 >> 2]) + HEAPF32[$2 + 172 >> 2]; + break label$13; + } + HEAPF32[$3 + 100 >> 2] = 0; + HEAPF32[$3 + 108 >> 2] = 0; + HEAPF32[$3 + 104 >> 2] = 0; + HEAPF32[$3 + 112 >> 2] = 0; + HEAPF32[$3 + 116 >> 2] = 0; + } + $1 = HEAP32[$2 + 212 >> 2]; + $0 = HEAP32[$2 + 208 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 204 >> 2]; + $0 = HEAP32[$2 + 180 >> 2]; + $1 = HEAP32[$2 + 176 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 172 >> 2]; + __stack_pointer = $2 + 256 | 0; +} + +function __rem_pio2_large($0, $1, $2, $3, $4) { + var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0; + $8 = __stack_pointer - 560 | 0; + __stack_pointer = $8; + $6 = ($2 - 3 | 0) / 24 | 0; + $18 = ($6 | 0) > 0 ? $6 : 0; + $12 = Math_imul($18, -24) + $2 | 0; + $13 = HEAP32[($4 << 2) + 20560 >> 2]; + $15 = $3 - 1 | 0; + if (($13 + $15 | 0) >= 0) { + $7 = $3 + $13 | 0; + $2 = $18 - $15 | 0; + $6 = 0; + while (1) { + $5 = ($2 | 0) < 0 ? 0 : +HEAP32[($2 << 2) + 20576 >> 2]; + HEAPF64[($8 + 320 | 0) + ($6 << 3) >> 3] = $5; + $2 = $2 + 1 | 0; + $6 = $6 + 1 | 0; + if (($6 | 0) != ($7 | 0)) { + continue; + } + break; + } + } + $17 = $12 - 24 | 0; + $7 = 0; + $10 = ($13 | 0) > 0 ? $13 : 0; + $11 = ($3 | 0) <= 0; + while (1) { + label$6: { + if ($11) { + $5 = 0; + break label$6; + } + $6 = $7 + $15 | 0; + $2 = 0; + $5 = 0; + while (1) { + $5 = HEAPF64[($2 << 3) + $0 >> 3] * HEAPF64[($8 + 320 | 0) + ($6 - $2 << 3) >> 3] + $5; + $2 = $2 + 1 | 0; + if (($3 | 0) != ($2 | 0)) { + continue; + } + break; + } + } + HEAPF64[($7 << 3) + $8 >> 3] = $5; + $2 = ($7 | 0) == ($10 | 0); + $7 = $7 + 1 | 0; + if (!$2) { + continue; + } + break; + } + $23 = 47 - $12 | 0; + $21 = 48 - $12 | 0; + $24 = $12 - 25 | 0; + $7 = $13; + label$9: { + while (1) { + $5 = HEAPF64[($7 << 3) + $8 >> 3]; + $2 = 0; + $6 = $7; + $15 = ($7 | 0) <= 0; + if (!$15) { + while (1) { + $10 = ($8 + 480 | 0) + ($2 << 2) | 0; + $9 = $5 * 5.960464477539063e-8; + label$14: { + if (Math_abs($9) < 2147483648) { + $11 = ~~$9; + break label$14; + } + $11 = -2147483648; + } + $9 = +($11 | 0); + $5 = $9 * -16777216 + $5; + label$13: { + if (Math_abs($5) < 2147483648) { + $11 = ~~$5; + break label$13; + } + $11 = -2147483648; + } + HEAP32[$10 >> 2] = $11; + $6 = $6 - 1 | 0; + $5 = HEAPF64[($6 << 3) + $8 >> 3] + $9; + $2 = $2 + 1 | 0; + if (($7 | 0) != ($2 | 0)) { + continue; + } + break; + } + } + $5 = scalbn($5, $17); + $5 = $5 + floor($5 * .125) * -8; + label$17: { + if (Math_abs($5) < 2147483648) { + $16 = ~~$5; + break label$17; + } + $16 = -2147483648; + } + $5 = $5 - +($16 | 0); + label$19: { + label$20: { + label$21: { + $22 = ($17 | 0) <= 0; + label$22: { + if (!$22) { + $6 = ($7 << 2) + $8 | 0; + $2 = $6 + 476 | 0; + $11 = $2; + $2 = HEAP32[$6 + 476 >> 2]; + $6 = $2; + $2 = $2 >> $21; + $6 = $6 - ($2 << $21) | 0; + HEAP32[$11 >> 2] = $6; + $16 = $2 + $16 | 0; + $14 = $6 >> $23; + break label$22; + } + if ($17) { + break label$21; + } + $14 = HEAP32[(($7 << 2) + $8 | 0) + 476 >> 2] >> 23; + } + if (($14 | 0) <= 0) { + break label$19; + } + break label$20; + } + $14 = 2; + if ($5 >= .5) { + break label$20; + } + $14 = 0; + break label$19; + } + $2 = 0; + $11 = 0; + if (!$15) { + while (1) { + $15 = ($8 + 480 | 0) + ($2 << 2) | 0; + $6 = HEAP32[$15 >> 2]; + $10 = 16777215; + label$26: { + label$27: { + if ($11) { + break label$27; + } + $10 = 16777216; + if ($6) { + break label$27; + } + $11 = 0; + break label$26; + } + HEAP32[$15 >> 2] = $10 - $6; + $11 = 1; + } + $2 = $2 + 1 | 0; + if (($7 | 0) != ($2 | 0)) { + continue; + } + break; + } + } + label$28: { + if ($22) { + break label$28; + } + $2 = 8388607; + label$29: { + switch ($24 | 0) { + case 1: + $2 = 4194303; + break; + + case 0: + break label$29; + + default: + break label$28; + } + } + $10 = ($7 << 2) + $8 | 0; + $6 = $10 + 476 | 0; + HEAP32[$6 >> 2] = HEAP32[$10 + 476 >> 2] & $2; + } + $16 = $16 + 1 | 0; + if (($14 | 0) != 2) { + break label$19; + } + $5 = 1 - $5; + $14 = 2; + if (!$11) { + break label$19; + } + $5 = $5 - scalbn(1, $17); + } + if ($5 == 0) { + $6 = 0; + label$32: { + $2 = $7; + if (($13 | 0) >= ($2 | 0)) { + break label$32; + } + while (1) { + $2 = $2 - 1 | 0; + $6 = HEAP32[($8 + 480 | 0) + ($2 << 2) >> 2] | $6; + if (($2 | 0) > ($13 | 0)) { + continue; + } + break; + } + if (!$6) { + break label$32; + } + $12 = $17; + while (1) { + $12 = $12 - 24 | 0; + $7 = $7 - 1 | 0; + if (!HEAP32[($8 + 480 | 0) + ($7 << 2) >> 2]) { + continue; + } + break; + } + break label$9; + } + $2 = 1; + while (1) { + $6 = $2; + $2 = $2 + 1 | 0; + if (!HEAP32[($8 + 480 | 0) + ($13 - $6 << 2) >> 2]) { + continue; + } + break; + } + $10 = $7 + $6 | 0; + while (1) { + $6 = $3 + $7 | 0; + $7 = $7 + 1 | 0; + HEAPF64[($8 + 320 | 0) + ($6 << 3) >> 3] = HEAP32[($18 + $7 << 2) + 20576 >> 2]; + $2 = 0; + $5 = 0; + if (($3 | 0) > 0) { + while (1) { + $5 = HEAPF64[($2 << 3) + $0 >> 3] * HEAPF64[($8 + 320 | 0) + ($6 - $2 << 3) >> 3] + $5; + $2 = $2 + 1 | 0; + if (($3 | 0) != ($2 | 0)) { + continue; + } + break; + } + } + HEAPF64[($7 << 3) + $8 >> 3] = $5; + if (($7 | 0) < ($10 | 0)) { + continue; + } + break; + } + $7 = $10; + continue; + } + break; + } + $5 = scalbn($5, 24 - $12 | 0); + label$39: { + if ($5 >= 16777216) { + $3 = $7 << 2; + $3 = $3 + ($8 + 480 | 0) | 0; + $9 = $5 * 5.960464477539063e-8; + label$42: { + if (Math_abs($9) < 2147483648) { + $2 = ~~$9; + break label$42; + } + $2 = -2147483648; + } + $5 = +($2 | 0) * -16777216 + $5; + label$41: { + if (Math_abs($5) < 2147483648) { + $6 = ~~$5; + break label$41; + } + $6 = -2147483648; + } + HEAP32[$3 >> 2] = $6; + $7 = $7 + 1 | 0; + break label$39; + } + if (Math_abs($5) < 2147483648) { + $2 = ~~$5; + } else { + $2 = -2147483648; + } + $12 = $17; + } + HEAP32[($8 + 480 | 0) + ($7 << 2) >> 2] = $2; + } + $5 = scalbn(1, $12); + label$47: { + if (($7 | 0) < 0) { + break label$47; + } + $3 = $7; + while (1) { + $2 = $3; + HEAPF64[($2 << 3) + $8 >> 3] = $5 * +HEAP32[($8 + 480 | 0) + ($2 << 2) >> 2]; + $3 = $2 - 1 | 0; + $5 = $5 * 5.960464477539063e-8; + if ($2) { + continue; + } + break; + } + if (($7 | 0) < 0) { + break label$47; + } + $6 = $7; + while (1) { + $5 = 0; + $2 = 0; + $10 = $7 - $6 | 0; + $0 = ($10 | 0) > ($13 | 0) ? $13 : $10; + if (($0 | 0) >= 0) { + while (1) { + $5 = HEAPF64[($2 << 3) + 23344 >> 3] * HEAPF64[($2 + $6 << 3) + $8 >> 3] + $5; + $3 = ($0 | 0) != ($2 | 0); + $2 = $2 + 1 | 0; + if ($3) { + continue; + } + break; + } + } + HEAPF64[($8 + 160 | 0) + ($10 << 3) >> 3] = $5; + $2 = ($6 | 0) > 0; + $6 = $6 - 1 | 0; + if ($2) { + continue; + } + break; + } + } + label$52: { + label$53: { + label$54: { + switch ($4 | 0) { + case 3: + label$57: { + if (($7 | 0) <= 0) { + break label$57; + } + $5 = HEAPF64[($8 + 160 | 0) + ($7 << 3) >> 3]; + $2 = $7; + while (1) { + $3 = $2 - 1 | 0; + $6 = ($8 + 160 | 0) + ($3 << 3) | 0; + $9 = HEAPF64[$6 >> 3]; + $19 = $9; + $9 = $9 + $5; + HEAPF64[($8 + 160 | 0) + ($2 << 3) >> 3] = $5 + ($19 - $9); + HEAPF64[$6 >> 3] = $9; + $6 = $2 >>> 0 > 1; + $5 = $9; + $2 = $3; + if ($6) { + continue; + } + break; + } + if (($7 | 0) < 2) { + break label$57; + } + $5 = HEAPF64[($8 + 160 | 0) + ($7 << 3) >> 3]; + $2 = $7; + while (1) { + $3 = $2 - 1 | 0; + $6 = ($8 + 160 | 0) + ($3 << 3) | 0; + $9 = HEAPF64[$6 >> 3]; + $19 = $9; + $9 = $9 + $5; + HEAPF64[($8 + 160 | 0) + ($2 << 3) >> 3] = $5 + ($19 - $9); + HEAPF64[$6 >> 3] = $9; + $6 = $2 >>> 0 > 2; + $5 = $9; + $2 = $3; + if ($6) { + continue; + } + break; + } + if (($7 | 0) <= 1) { + break label$57; + } + while (1) { + $20 = $20 + HEAPF64[($8 + 160 | 0) + ($7 << 3) >> 3]; + $2 = ($7 | 0) > 2; + $7 = $7 - 1 | 0; + if ($2) { + continue; + } + break; + } + } + $5 = HEAPF64[$8 + 160 >> 3]; + if ($14) { + break label$53; + } + HEAPF64[$1 >> 3] = $5; + $5 = HEAPF64[$8 + 168 >> 3]; + HEAPF64[$1 + 16 >> 3] = $20; + HEAPF64[$1 + 8 >> 3] = $5; + break label$52; + + case 0: + $5 = 0; + if (($7 | 0) >= 0) { + while (1) { + $2 = $7; + $7 = $2 - 1 | 0; + $5 = $5 + HEAPF64[($8 + 160 | 0) + ($2 << 3) >> 3]; + if ($2) { + continue; + } + break; + } + } + HEAPF64[$1 >> 3] = $14 ? -$5 : $5; + break label$52; + + case 1: + case 2: + break label$54; + + default: + break label$52; + } + } + $5 = 0; + if (($7 | 0) >= 0) { + $3 = $7; + while (1) { + $2 = $3; + $3 = $2 - 1 | 0; + $5 = $5 + HEAPF64[($8 + 160 | 0) + ($2 << 3) >> 3]; + if ($2) { + continue; + } + break; + } + } + HEAPF64[$1 >> 3] = $14 ? -$5 : $5; + $5 = HEAPF64[$8 + 160 >> 3] - $5; + $2 = 1; + if (($7 | 0) > 0) { + while (1) { + $5 = $5 + HEAPF64[($8 + 160 | 0) + ($2 << 3) >> 3]; + $3 = ($2 | 0) != ($7 | 0); + $2 = $2 + 1 | 0; + if ($3) { + continue; + } + break; + } + } + HEAPF64[$1 + 8 >> 3] = $14 ? -$5 : $5; + break label$52; + } + HEAPF64[$1 >> 3] = -$5; + $5 = HEAPF64[$8 + 168 >> 3]; + HEAPF64[$1 + 16 >> 3] = -$20; + HEAPF64[$1 + 8 >> 3] = -$5; + } + __stack_pointer = $8 + 560 | 0; + return $16 & 7; +} + +function b2WheelJoint__SolveVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = Math_fround(0), $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 288 | 0; + __stack_pointer = $2; + HEAP32[$2 + 284 >> 2] = $0; + HEAP32[$2 + 280 >> 2] = $1; + $3 = HEAP32[$2 + 284 >> 2]; + HEAPF32[$2 + 276 >> 2] = HEAPF32[$3 + 176 >> 2]; + HEAPF32[$2 + 272 >> 2] = HEAPF32[$3 + 180 >> 2]; + HEAPF32[$2 + 268 >> 2] = HEAPF32[$3 + 184 >> 2]; + HEAPF32[$2 + 264 >> 2] = HEAPF32[$3 + 188 >> 2]; + $5 = HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0; + $1 = HEAP32[$5 >> 2]; + $0 = HEAP32[$5 + 4 >> 2]; + HEAP32[$2 + 256 >> 2] = $1; + HEAP32[$2 + 260 >> 2] = $0; + HEAPF32[$2 + 252 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0) + 8 >> 2]; + $5 = HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0; + $0 = HEAP32[$5 >> 2]; + $1 = HEAP32[$5 + 4 >> 2]; + HEAP32[$2 + 240 >> 2] = $0; + HEAP32[$2 + 244 >> 2] = $1; + HEAPF32[$2 + 236 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0) + 8 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 224 | 0, $2 + 240 | 0, $2 + 256 | 0); + $4 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 192 | 0, $2 + 224 | 0); + HEAPF32[$2 + 232 >> 2] = Math_fround(Math_fround(-HEAPF32[$3 + 208 >> 2]) * HEAPF32[$2 + 252 >> 2]) + Math_fround(Math_fround(HEAPF32[$3 + 212 >> 2] * HEAPF32[$2 + 236 >> 2]) + $4); + HEAPF32[$2 + 220 >> 2] = Math_fround(-HEAPF32[$3 + 236 >> 2]) * Math_fround(Math_fround(HEAPF32[$3 + 244 >> 2] * HEAPF32[$3 + 108 >> 2]) + Math_fround(HEAPF32[$2 + 232 >> 2] + HEAPF32[$3 + 240 >> 2])); + HEAPF32[$3 + 108 >> 2] = HEAPF32[$3 + 108 >> 2] + HEAPF32[$2 + 220 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 212 | 0, HEAPF32[$2 + 220 >> 2], $3 + 192 | 0); + HEAPF32[$2 + 208 >> 2] = HEAPF32[$2 + 220 >> 2] * HEAPF32[$3 + 208 >> 2]; + HEAPF32[$2 + 204 >> 2] = HEAPF32[$2 + 220 >> 2] * HEAPF32[$3 + 212 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 196 | 0, HEAPF32[$2 + 276 >> 2], $2 + 212 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 256 | 0, $2 + 196 | 0); + HEAPF32[$2 + 252 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 268 >> 2]) * HEAPF32[$2 + 208 >> 2]) + HEAPF32[$2 + 252 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 188 | 0, HEAPF32[$2 + 272 >> 2], $2 + 212 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 240 | 0, $2 + 188 | 0); + HEAPF32[$2 + 236 >> 2] = Math_fround(HEAPF32[$2 + 264 >> 2] * HEAPF32[$2 + 204 >> 2]) + HEAPF32[$2 + 236 >> 2]; + HEAPF32[$2 + 184 >> 2] = Math_fround(HEAPF32[$2 + 236 >> 2] - HEAPF32[$2 + 252 >> 2]) - HEAPF32[$3 + 136 >> 2]; + HEAPF32[$2 + 180 >> 2] = Math_fround(-HEAPF32[$3 + 228 >> 2]) * HEAPF32[$2 + 184 >> 2]; + HEAPF32[$2 + 176 >> 2] = HEAPF32[$3 + 104 >> 2]; + HEAPF32[$2 + 172 >> 2] = HEAPF32[HEAP32[$2 + 280 >> 2] >> 2] * HEAPF32[$3 + 132 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Clamp_float__28float_2c_20float_2c_20float_29(Math_fround(HEAPF32[$3 + 104 >> 2] + HEAPF32[$2 + 180 >> 2]), Math_fround(-HEAPF32[$2 + 172 >> 2]), HEAPF32[$2 + 172 >> 2]), + HEAPF32[wasm2js_i32$0 + 104 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 180 >> 2] = HEAPF32[$3 + 104 >> 2] - HEAPF32[$2 + 176 >> 2]; + HEAPF32[$2 + 252 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 268 >> 2]) * HEAPF32[$2 + 180 >> 2]) + HEAPF32[$2 + 252 >> 2]; + HEAPF32[$2 + 236 >> 2] = Math_fround(HEAPF32[$2 + 264 >> 2] * HEAPF32[$2 + 180 >> 2]) + HEAPF32[$2 + 236 >> 2]; + if (HEAP8[$3 + 140 | 0] & 1) { + HEAPF32[$2 + 168 >> 2] = HEAPF32[$3 + 120 >> 2] - HEAPF32[$3 + 124 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 156 | 0, $2 + 240 | 0, $2 + 256 | 0); + $4 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 192 | 0, $2 + 156 | 0); + HEAPF32[$2 + 164 >> 2] = Math_fround(Math_fround(-HEAPF32[$3 + 208 >> 2]) * HEAPF32[$2 + 252 >> 2]) + Math_fround(Math_fround(HEAPF32[$3 + 212 >> 2] * HEAPF32[$2 + 236 >> 2]) + $4); + $4 = HEAPF32[$2 + 164 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(-HEAPF32[$3 + 232 >> 2]) * Math_fround(Math_fround(float_20b2Max_float__28float_2c_20float_29(HEAPF32[$2 + 168 >> 2], Math_fround(0)) * HEAPF32[HEAP32[$2 + 280 >> 2] + 4 >> 2]) + $4)), + HEAPF32[wasm2js_i32$0 + 152 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 148 >> 2] = HEAPF32[$3 + 112 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(Math_fround(HEAPF32[$3 + 112 >> 2] + HEAPF32[$2 + 152 >> 2]), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 112 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 152 >> 2] = HEAPF32[$3 + 112 >> 2] - HEAPF32[$2 + 148 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 140 | 0, HEAPF32[$2 + 152 >> 2], $3 + 192 | 0); + HEAPF32[$2 + 136 >> 2] = HEAPF32[$2 + 152 >> 2] * HEAPF32[$3 + 208 >> 2]; + HEAPF32[$2 + 132 >> 2] = HEAPF32[$2 + 152 >> 2] * HEAPF32[$3 + 212 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 124 | 0, HEAPF32[$2 + 276 >> 2], $2 + 140 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 256 | 0, $2 + 124 | 0); + HEAPF32[$2 + 252 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 268 >> 2]) * HEAPF32[$2 + 136 >> 2]) + HEAPF32[$2 + 252 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 116 | 0, HEAPF32[$2 + 272 >> 2], $2 + 140 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 240 | 0, $2 + 116 | 0); + HEAPF32[$2 + 236 >> 2] = Math_fround(HEAPF32[$2 + 264 >> 2] * HEAPF32[$2 + 132 >> 2]) + HEAPF32[$2 + 236 >> 2]; + HEAPF32[$2 + 112 >> 2] = HEAPF32[$3 + 128 >> 2] - HEAPF32[$3 + 120 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 100 | 0, $2 + 256 | 0, $2 + 240 | 0); + $4 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 192 | 0, $2 + 100 | 0); + HEAPF32[$2 + 108 >> 2] = Math_fround(Math_fround(-HEAPF32[$3 + 212 >> 2]) * HEAPF32[$2 + 236 >> 2]) + Math_fround(Math_fround(HEAPF32[$3 + 208 >> 2] * HEAPF32[$2 + 252 >> 2]) + $4); + $4 = HEAPF32[$2 + 108 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(-HEAPF32[$3 + 232 >> 2]) * Math_fround(Math_fround(float_20b2Max_float__28float_2c_20float_29(HEAPF32[$2 + 112 >> 2], Math_fround(0)) * HEAPF32[HEAP32[$2 + 280 >> 2] + 4 >> 2]) + $4)), + HEAPF32[wasm2js_i32$0 + 96 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 92 >> 2] = HEAPF32[$3 + 116 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(Math_fround(HEAPF32[$3 + 116 >> 2] + HEAPF32[$2 + 96 >> 2]), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 116 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 96 >> 2] = HEAPF32[$3 + 116 >> 2] - HEAPF32[$2 + 92 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 84 | 0, HEAPF32[$2 + 96 >> 2], $3 + 192 | 0); + HEAPF32[$2 + 80 >> 2] = HEAPF32[$2 + 96 >> 2] * HEAPF32[$3 + 208 >> 2]; + HEAPF32[$2 + 76 >> 2] = HEAPF32[$2 + 96 >> 2] * HEAPF32[$3 + 212 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 68 | 0, HEAPF32[$2 + 276 >> 2], $2 + 84 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 256 | 0, $2 + 68 | 0); + HEAPF32[$2 + 252 >> 2] = Math_fround(HEAPF32[$2 + 268 >> 2] * HEAPF32[$2 + 80 >> 2]) + HEAPF32[$2 + 252 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 60 | 0, HEAPF32[$2 + 272 >> 2], $2 + 84 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 240 | 0, $2 + 60 | 0); + HEAPF32[$2 + 236 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 264 >> 2]) * HEAPF32[$2 + 76 >> 2]) + HEAPF32[$2 + 236 >> 2]; + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 48 | 0, $2 + 240 | 0, $2 + 256 | 0); + $4 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 200 | 0, $2 + 48 | 0); + HEAPF32[$2 + 56 >> 2] = Math_fround(Math_fround(-HEAPF32[$3 + 216 >> 2]) * HEAPF32[$2 + 252 >> 2]) + Math_fround(Math_fround(HEAPF32[$3 + 220 >> 2] * HEAPF32[$2 + 236 >> 2]) + $4); + HEAPF32[$2 + 44 >> 2] = Math_fround(-HEAPF32[$3 + 224 >> 2]) * HEAPF32[$2 + 56 >> 2]; + HEAPF32[$3 + 100 >> 2] = HEAPF32[$3 + 100 >> 2] + HEAPF32[$2 + 44 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 36 | 0, HEAPF32[$2 + 44 >> 2], $3 + 200 | 0); + HEAPF32[$2 + 32 >> 2] = HEAPF32[$2 + 44 >> 2] * HEAPF32[$3 + 216 >> 2]; + HEAPF32[$2 + 28 >> 2] = HEAPF32[$2 + 44 >> 2] * HEAPF32[$3 + 220 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, HEAPF32[$2 + 276 >> 2], $2 + 36 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 256 | 0, $2 + 20 | 0); + HEAPF32[$2 + 252 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 268 >> 2]) * HEAPF32[$2 + 32 >> 2]) + HEAPF32[$2 + 252 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$2 + 272 >> 2], $2 + 36 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 240 | 0, $2 + 12 | 0); + HEAPF32[$2 + 236 >> 2] = Math_fround(HEAPF32[$2 + 264 >> 2] * HEAPF32[$2 + 28 >> 2]) + HEAPF32[$2 + 236 >> 2]; + $0 = HEAP32[$2 + 260 >> 2]; + $1 = HEAP32[$2 + 256 >> 2]; + $5 = $1; + $1 = HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $5; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 252 >> 2]; + $1 = HEAP32[$2 + 244 >> 2]; + $0 = HEAP32[$2 + 240 >> 2]; + $5 = $0; + $0 = HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $5; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 236 >> 2]; + __stack_pointer = $2 + 288 | 0; +} + +function b2PrismaticJoint__SolveVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = Math_fround(0), $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 288 | 0; + __stack_pointer = $2; + HEAP32[$2 + 284 >> 2] = $0; + HEAP32[$2 + 280 >> 2] = $1; + $3 = HEAP32[$2 + 284 >> 2]; + $5 = HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0; + $1 = HEAP32[$5 >> 2]; + $0 = HEAP32[$5 + 4 >> 2]; + HEAP32[$2 + 272 >> 2] = $1; + HEAP32[$2 + 276 >> 2] = $0; + HEAPF32[$2 + 268 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0) + 8 >> 2]; + $5 = HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0; + $0 = HEAP32[$5 >> 2]; + $1 = HEAP32[$5 + 4 >> 2]; + HEAP32[$2 + 256 >> 2] = $0; + HEAP32[$2 + 260 >> 2] = $1; + HEAPF32[$2 + 252 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0) + 8 >> 2]; + HEAPF32[$2 + 248 >> 2] = HEAPF32[$3 + 168 >> 2]; + HEAPF32[$2 + 244 >> 2] = HEAPF32[$3 + 172 >> 2]; + HEAPF32[$2 + 240 >> 2] = HEAPF32[$3 + 176 >> 2]; + HEAPF32[$2 + 236 >> 2] = HEAPF32[$3 + 180 >> 2]; + if (HEAP8[$3 + 141 | 0] & 1) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 224 | 0, $2 + 256 | 0, $2 + 272 | 0); + $4 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 184 | 0, $2 + 224 | 0); + HEAPF32[$2 + 232 >> 2] = Math_fround(Math_fround(-HEAPF32[$3 + 208 >> 2]) * HEAPF32[$2 + 268 >> 2]) + Math_fround(Math_fround(HEAPF32[$3 + 212 >> 2] * HEAPF32[$2 + 252 >> 2]) + $4); + HEAPF32[$2 + 220 >> 2] = HEAPF32[$3 + 236 >> 2] * Math_fround(HEAPF32[$3 + 136 >> 2] - HEAPF32[$2 + 232 >> 2]); + HEAPF32[$2 + 216 >> 2] = HEAPF32[$3 + 112 >> 2]; + HEAPF32[$2 + 212 >> 2] = HEAPF32[HEAP32[$2 + 280 >> 2] >> 2] * HEAPF32[$3 + 132 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Clamp_float__28float_2c_20float_2c_20float_29(Math_fround(HEAPF32[$3 + 112 >> 2] + HEAPF32[$2 + 220 >> 2]), Math_fround(-HEAPF32[$2 + 212 >> 2]), HEAPF32[$2 + 212 >> 2]), + HEAPF32[wasm2js_i32$0 + 112 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 220 >> 2] = HEAPF32[$3 + 112 >> 2] - HEAPF32[$2 + 216 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 204 | 0, HEAPF32[$2 + 220 >> 2], $3 + 184 | 0); + HEAPF32[$2 + 200 >> 2] = HEAPF32[$2 + 220 >> 2] * HEAPF32[$3 + 208 >> 2]; + HEAPF32[$2 + 196 >> 2] = HEAPF32[$2 + 220 >> 2] * HEAPF32[$3 + 212 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 188 | 0, HEAPF32[$2 + 248 >> 2], $2 + 204 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 272 | 0, $2 + 188 | 0); + HEAPF32[$2 + 268 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 240 >> 2]) * HEAPF32[$2 + 200 >> 2]) + HEAPF32[$2 + 268 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 180 | 0, HEAPF32[$2 + 244 >> 2], $2 + 204 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 256 | 0, $2 + 180 | 0); + HEAPF32[$2 + 252 >> 2] = Math_fround(HEAPF32[$2 + 236 >> 2] * HEAPF32[$2 + 196 >> 2]) + HEAPF32[$2 + 252 >> 2]; + } + if (HEAP8[$3 + 140 | 0] & 1) { + HEAPF32[$2 + 176 >> 2] = HEAPF32[$3 + 232 >> 2] - HEAPF32[$3 + 124 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 164 | 0, $2 + 256 | 0, $2 + 272 | 0); + $4 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 184 | 0, $2 + 164 | 0); + HEAPF32[$2 + 172 >> 2] = Math_fround(Math_fround(-HEAPF32[$3 + 208 >> 2]) * HEAPF32[$2 + 268 >> 2]) + Math_fround(Math_fround(HEAPF32[$3 + 212 >> 2] * HEAPF32[$2 + 252 >> 2]) + $4); + $4 = HEAPF32[$2 + 172 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(-HEAPF32[$3 + 236 >> 2]) * Math_fround(Math_fround(float_20b2Max_float__28float_2c_20float_29(HEAPF32[$2 + 176 >> 2], Math_fround(0)) * HEAPF32[HEAP32[$2 + 280 >> 2] + 4 >> 2]) + $4)), + HEAPF32[wasm2js_i32$0 + 160 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 156 >> 2] = HEAPF32[$3 + 116 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(Math_fround(HEAPF32[$3 + 116 >> 2] + HEAPF32[$2 + 160 >> 2]), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 116 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 160 >> 2] = HEAPF32[$3 + 116 >> 2] - HEAPF32[$2 + 156 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 148 | 0, HEAPF32[$2 + 160 >> 2], $3 + 184 | 0); + HEAPF32[$2 + 144 >> 2] = HEAPF32[$2 + 160 >> 2] * HEAPF32[$3 + 208 >> 2]; + HEAPF32[$2 + 140 >> 2] = HEAPF32[$2 + 160 >> 2] * HEAPF32[$3 + 212 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 132 | 0, HEAPF32[$2 + 248 >> 2], $2 + 148 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 272 | 0, $2 + 132 | 0); + HEAPF32[$2 + 268 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 240 >> 2]) * HEAPF32[$2 + 144 >> 2]) + HEAPF32[$2 + 268 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 124 | 0, HEAPF32[$2 + 244 >> 2], $2 + 148 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 256 | 0, $2 + 124 | 0); + HEAPF32[$2 + 252 >> 2] = Math_fround(HEAPF32[$2 + 236 >> 2] * HEAPF32[$2 + 140 >> 2]) + HEAPF32[$2 + 252 >> 2]; + HEAPF32[$2 + 120 >> 2] = HEAPF32[$3 + 128 >> 2] - HEAPF32[$3 + 232 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 108 | 0, $2 + 272 | 0, $2 + 256 | 0); + $4 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 184 | 0, $2 + 108 | 0); + HEAPF32[$2 + 116 >> 2] = Math_fround(Math_fround(-HEAPF32[$3 + 212 >> 2]) * HEAPF32[$2 + 252 >> 2]) + Math_fround(Math_fround(HEAPF32[$3 + 208 >> 2] * HEAPF32[$2 + 268 >> 2]) + $4); + $4 = HEAPF32[$2 + 116 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(-HEAPF32[$3 + 236 >> 2]) * Math_fround(Math_fround(float_20b2Max_float__28float_2c_20float_29(HEAPF32[$2 + 120 >> 2], Math_fround(0)) * HEAPF32[HEAP32[$2 + 280 >> 2] + 4 >> 2]) + $4)), + HEAPF32[wasm2js_i32$0 + 104 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 100 >> 2] = HEAPF32[$3 + 120 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(Math_fround(HEAPF32[$3 + 120 >> 2] + HEAPF32[$2 + 104 >> 2]), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 120 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 104 >> 2] = HEAPF32[$3 + 120 >> 2] - HEAPF32[$2 + 100 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 92 | 0, HEAPF32[$2 + 104 >> 2], $3 + 184 | 0); + HEAPF32[$2 + 88 >> 2] = HEAPF32[$2 + 104 >> 2] * HEAPF32[$3 + 208 >> 2]; + HEAPF32[$2 + 84 >> 2] = HEAPF32[$2 + 104 >> 2] * HEAPF32[$3 + 212 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 76 | 0, HEAPF32[$2 + 248 >> 2], $2 + 92 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 272 | 0, $2 + 76 | 0); + HEAPF32[$2 + 268 >> 2] = Math_fround(HEAPF32[$2 + 240 >> 2] * HEAPF32[$2 + 88 >> 2]) + HEAPF32[$2 + 268 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 68 | 0, HEAPF32[$2 + 244 >> 2], $2 + 92 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 256 | 0, $2 + 68 | 0); + HEAPF32[$2 + 252 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 236 >> 2]) * HEAPF32[$2 + 84 >> 2]) + HEAPF32[$2 + 252 >> 2]; + } + b2Vec2__b2Vec2_28_29($2 + 60 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 52 | 0, $2 + 256 | 0, $2 + 272 | 0); + $4 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 192 | 0, $2 + 52 | 0); + HEAPF32[$2 + 60 >> 2] = Math_fround(Math_fround(-HEAPF32[$3 + 200 >> 2]) * HEAPF32[$2 + 268 >> 2]) + Math_fround(Math_fround(HEAPF32[$3 + 204 >> 2] * HEAPF32[$2 + 252 >> 2]) + $4); + HEAPF32[$2 + 64 >> 2] = HEAPF32[$2 + 252 >> 2] - HEAPF32[$2 + 268 >> 2]; + b2Vec2__operator__28_29_20const($2 + 36 | 0, $2 + 60 | 0); + b2Mat22__Solve_28b2Vec2_20const__29_20const($2 + 44 | 0, $3 + 216 | 0, $2 + 36 | 0); + b2Vec2__operator___28b2Vec2_20const__29($3 + 104 | 0, $2 + 44 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 28 | 0, HEAPF32[$2 + 44 >> 2], $3 + 192 | 0); + HEAPF32[$2 + 24 >> 2] = Math_fround(HEAPF32[$2 + 44 >> 2] * HEAPF32[$3 + 200 >> 2]) + HEAPF32[$2 + 48 >> 2]; + HEAPF32[$2 + 20 >> 2] = Math_fround(HEAPF32[$2 + 44 >> 2] * HEAPF32[$3 + 204 >> 2]) + HEAPF32[$2 + 48 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$2 + 248 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 272 | 0, $2 + 12 | 0); + HEAPF32[$2 + 268 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 240 >> 2]) * HEAPF32[$2 + 24 >> 2]) + HEAPF32[$2 + 268 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 4 | 0, HEAPF32[$2 + 244 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 256 | 0, $2 + 4 | 0); + HEAPF32[$2 + 252 >> 2] = Math_fround(HEAPF32[$2 + 236 >> 2] * HEAPF32[$2 + 20 >> 2]) + HEAPF32[$2 + 252 >> 2]; + $0 = HEAP32[$2 + 276 >> 2]; + $1 = HEAP32[$2 + 272 >> 2]; + $5 = $1; + $1 = HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $5; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 268 >> 2]; + $1 = HEAP32[$2 + 260 >> 2]; + $0 = HEAP32[$2 + 256 >> 2]; + $5 = $0; + $0 = HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $5; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 280 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 252 >> 2]; + __stack_pointer = $2 + 288 | 0; +} + +function b2CollideEdgeAndCircle_28b2Manifold__2c_20b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2CircleShape_20const__2c_20b2Transform_20const__29($0, $1, $2, $3, $4) { + var $5 = 0, $6 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $5 = __stack_pointer - 304 | 0; + __stack_pointer = $5; + HEAP32[$5 + 300 >> 2] = $0; + HEAP32[$5 + 296 >> 2] = $1; + HEAP32[$5 + 292 >> 2] = $2; + HEAP32[$5 + 288 >> 2] = $3; + HEAP32[$5 + 284 >> 2] = $4; + HEAP32[HEAP32[$5 + 300 >> 2] + 60 >> 2] = 0; + $0 = HEAP32[$5 + 292 >> 2]; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 268 | 0, HEAP32[$5 + 284 >> 2], HEAP32[$5 + 288 >> 2] + 12 | 0); + b2MulT_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 276 | 0, $0, $5 + 268 | 0); + $2 = HEAP32[$5 + 296 >> 2]; + $1 = HEAP32[$2 + 12 >> 2]; + $0 = HEAP32[$2 + 16 >> 2]; + HEAP32[$5 + 256 >> 2] = $1; + HEAP32[$5 + 260 >> 2] = $0; + $2 = HEAP32[$5 + 296 >> 2]; + $0 = HEAP32[$2 + 20 >> 2]; + $1 = HEAP32[$2 + 24 >> 2]; + HEAP32[$5 + 248 >> 2] = $0; + HEAP32[$5 + 252 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 240 | 0, $5 + 248 | 0, $5 + 256 | 0); + b2Vec2__b2Vec2_28float_2c_20float_29($5 + 232 | 0, HEAPF32[$5 + 244 >> 2], Math_fround(-HEAPF32[$5 + 240 >> 2])); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 220 | 0, $5 + 276 | 0, $5 + 256 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 232 | 0, $5 + 220 | 0), + HEAPF32[wasm2js_i32$0 + 228 >> 2] = wasm2js_f32$0; + HEAP8[$5 + 219 | 0] = HEAP8[HEAP32[$5 + 296 >> 2] + 44 | 0] & 1; + label$1: { + if (!(!(HEAP8[$5 + 219 | 0] & 1) | !(HEAPF32[$5 + 228 >> 2] < Math_fround(0)))) { + break label$1; + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 204 | 0, $5 + 248 | 0, $5 + 276 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 240 | 0, $5 + 204 | 0), + HEAPF32[wasm2js_i32$0 + 212 >> 2] = wasm2js_f32$0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 192 | 0, $5 + 276 | 0, $5 + 256 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 240 | 0, $5 + 192 | 0), + HEAPF32[wasm2js_i32$0 + 200 >> 2] = wasm2js_f32$0; + HEAPF32[$5 + 188 >> 2] = HEAPF32[HEAP32[$5 + 296 >> 2] + 8 >> 2] + HEAPF32[HEAP32[$5 + 288 >> 2] + 8 >> 2]; + HEAP8[$5 + 185 | 0] = 0; + HEAP8[$5 + 187 | 0] = 0; + if (HEAPF32[$5 + 200 >> 2] <= Math_fround(0)) { + $0 = HEAP32[$5 + 260 >> 2]; + $1 = HEAP32[$5 + 256 >> 2]; + HEAP32[$5 + 176 >> 2] = $1; + HEAP32[$5 + 180 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 168 | 0, $5 + 276 | 0, $5 + 176 | 0); + $0 = $5 + 168 | 0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $0), + HEAPF32[wasm2js_i32$0 + 164 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 164 >> 2] > Math_fround(HEAPF32[$5 + 188 >> 2] * HEAPF32[$5 + 188 >> 2])) { + break label$1; + } + if (HEAP8[HEAP32[$5 + 296 >> 2] + 44 | 0] & 1) { + $2 = HEAP32[$5 + 296 >> 2]; + $0 = HEAP32[$2 + 28 >> 2]; + $1 = HEAP32[$2 + 32 >> 2]; + HEAP32[$5 + 152 >> 2] = $0; + HEAP32[$5 + 156 >> 2] = $1; + $0 = HEAP32[$5 + 260 >> 2]; + $1 = HEAP32[$5 + 256 >> 2]; + HEAP32[$5 + 144 >> 2] = $1; + HEAP32[$5 + 148 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 136 | 0, $5 + 144 | 0, $5 + 152 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 124 | 0, $5 + 144 | 0, $5 + 276 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 136 | 0, $5 + 124 | 0), + HEAPF32[wasm2js_i32$0 + 132 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 132 >> 2] > Math_fround(0)) { + break label$1; + } + } + HEAP8[$5 + 184 | 0] = 0; + HEAP8[$5 + 186 | 0] = 0; + HEAP32[HEAP32[$5 + 300 >> 2] + 60 >> 2] = 1; + HEAP32[HEAP32[$5 + 300 >> 2] + 56 >> 2] = 0; + b2Vec2__SetZero_28_29(HEAP32[$5 + 300 >> 2] + 40 | 0); + $1 = HEAP32[$5 + 180 >> 2]; + $0 = HEAP32[$5 + 176 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 300 >> 2]; + HEAP32[$0 + 48 >> 2] = $2; + HEAP32[$0 + 52 >> 2] = $1; + HEAP32[HEAP32[$5 + 300 >> 2] + 16 >> 2] = 0; + $0 = HEAP32[$5 + 300 >> 2]; + $1 = HEAPU8[$5 + 184 | 0] | HEAPU8[$5 + 185 | 0] << 8 | (HEAPU8[$5 + 186 | 0] << 16 | HEAPU8[$5 + 187 | 0] << 24); + HEAP8[$0 + 16 | 0] = $1; + HEAP8[$0 + 17 | 0] = $1 >>> 8; + HEAP8[$0 + 18 | 0] = $1 >>> 16; + HEAP8[$0 + 19 | 0] = $1 >>> 24; + $2 = HEAP32[$5 + 288 >> 2]; + $1 = HEAP32[$2 + 12 >> 2]; + $0 = HEAP32[$2 + 16 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 300 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + break label$1; + } + if (HEAPF32[$5 + 212 >> 2] <= Math_fround(0)) { + $1 = HEAP32[$5 + 252 >> 2]; + $0 = HEAP32[$5 + 248 >> 2]; + HEAP32[$5 + 112 >> 2] = $0; + HEAP32[$5 + 116 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 104 | 0, $5 + 276 | 0, $5 + 112 | 0); + $0 = $5 + 104 | 0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $0), + HEAPF32[wasm2js_i32$0 + 100 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 100 >> 2] > Math_fround(HEAPF32[$5 + 188 >> 2] * HEAPF32[$5 + 188 >> 2])) { + break label$1; + } + if (HEAP8[HEAP32[$5 + 296 >> 2] + 44 | 0] & 1) { + $2 = HEAP32[$5 + 296 >> 2]; + $1 = HEAP32[$2 + 36 >> 2]; + $0 = HEAP32[$2 + 40 >> 2]; + HEAP32[$5 + 88 >> 2] = $1; + HEAP32[$5 + 92 >> 2] = $0; + $1 = HEAP32[$5 + 252 >> 2]; + $0 = HEAP32[$5 + 248 >> 2]; + HEAP32[$5 + 80 >> 2] = $0; + HEAP32[$5 + 84 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 72 | 0, $5 + 88 | 0, $5 + 80 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 60 | 0, $5 + 276 | 0, $5 + 80 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 72 | 0, $5 + 60 | 0), + HEAPF32[wasm2js_i32$0 + 68 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 68 >> 2] > Math_fround(0)) { + break label$1; + } + } + HEAP8[$5 + 184 | 0] = 1; + HEAP8[$5 + 186 | 0] = 0; + HEAP32[HEAP32[$5 + 300 >> 2] + 60 >> 2] = 1; + HEAP32[HEAP32[$5 + 300 >> 2] + 56 >> 2] = 0; + b2Vec2__SetZero_28_29(HEAP32[$5 + 300 >> 2] + 40 | 0); + $0 = HEAP32[$5 + 116 >> 2]; + $1 = HEAP32[$5 + 112 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 300 >> 2]; + HEAP32[$1 + 48 >> 2] = $2; + HEAP32[$1 + 52 >> 2] = $0; + HEAP32[HEAP32[$5 + 300 >> 2] + 16 >> 2] = 0; + $0 = HEAP32[$5 + 300 >> 2]; + $1 = HEAPU8[$5 + 184 | 0] | HEAPU8[$5 + 185 | 0] << 8 | (HEAPU8[$5 + 186 | 0] << 16 | HEAPU8[$5 + 187 | 0] << 24); + HEAP8[$0 + 16 | 0] = $1; + HEAP8[$0 + 17 | 0] = $1 >>> 8; + HEAP8[$0 + 18 | 0] = $1 >>> 16; + HEAP8[$0 + 19 | 0] = $1 >>> 24; + $2 = HEAP32[$5 + 288 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$2 + 16 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 300 >> 2]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + break label$1; + } + $0 = $5 + 240 | 0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $0), + HEAPF32[wasm2js_i32$0 + 56 >> 2] = wasm2js_f32$0; + if (!(HEAPF32[$5 + 56 >> 2] > Math_fround(0))) { + __assert_fail(8107, 5896, 141, 9628); + wasm2js_trap(); + } + $6 = HEAPF32[$5 + 56 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($5 + 32 | 0, HEAPF32[$5 + 212 >> 2], $5 + 256 | 0); + operator__28float_2c_20b2Vec2_20const__29($5 + 24 | 0, HEAPF32[$5 + 200 >> 2], $5 + 248 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($5 + 40 | 0, $5 + 32 | 0, $5 + 24 | 0); + operator__28float_2c_20b2Vec2_20const__29($5 + 48 | 0, Math_fround(Math_fround(1) / $6), $5 + 40 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 16 | 0, $5 + 276 | 0, $5 + 48 | 0); + $0 = $5 + 16 | 0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $0), + HEAPF32[wasm2js_i32$0 + 12 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 12 >> 2] > Math_fround(HEAPF32[$5 + 188 >> 2] * HEAPF32[$5 + 188 >> 2])) { + break label$1; + } + if (HEAPF32[$5 + 228 >> 2] < Math_fround(0)) { + b2Vec2__Set_28float_2c_20float_29($5 + 232 | 0, Math_fround(-HEAPF32[$5 + 232 >> 2]), Math_fround(-HEAPF32[$5 + 236 >> 2])); + } + b2Vec2__Normalize_28_29($5 + 232 | 0); + HEAP8[$5 + 184 | 0] = 0; + HEAP8[$5 + 186 | 0] = 1; + HEAP32[HEAP32[$5 + 300 >> 2] + 60 >> 2] = 1; + HEAP32[HEAP32[$5 + 300 >> 2] + 56 >> 2] = 1; + $0 = HEAP32[$5 + 236 >> 2]; + $1 = HEAP32[$5 + 232 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 300 >> 2]; + HEAP32[$1 + 40 >> 2] = $2; + HEAP32[$1 + 44 >> 2] = $0; + $1 = HEAP32[$5 + 260 >> 2]; + $0 = HEAP32[$5 + 256 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 300 >> 2]; + HEAP32[$0 + 48 >> 2] = $2; + HEAP32[$0 + 52 >> 2] = $1; + HEAP32[HEAP32[$5 + 300 >> 2] + 16 >> 2] = 0; + $0 = HEAP32[$5 + 300 >> 2]; + $1 = HEAPU8[$5 + 184 | 0] | HEAPU8[$5 + 185 | 0] << 8 | (HEAPU8[$5 + 186 | 0] << 16 | HEAPU8[$5 + 187 | 0] << 24); + HEAP8[$0 + 16 | 0] = $1; + HEAP8[$0 + 17 | 0] = $1 >>> 8; + HEAP8[$0 + 18 | 0] = $1 >>> 16; + HEAP8[$0 + 19 | 0] = $1 >>> 24; + $2 = HEAP32[$5 + 288 >> 2]; + $1 = HEAP32[$2 + 12 >> 2]; + $0 = HEAP32[$2 + 16 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 300 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + } + __stack_pointer = $5 + 304 | 0; +} + +function b2CollidePolygons_28b2Manifold__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__29($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0), wasm2js_i32$1 = 0; + $5 = __stack_pointer - 352 | 0; + __stack_pointer = $5; + HEAP32[$5 + 348 >> 2] = $0; + HEAP32[$5 + 344 >> 2] = $1; + HEAP32[$5 + 340 >> 2] = $2; + HEAP32[$5 + 336 >> 2] = $3; + HEAP32[$5 + 332 >> 2] = $4; + HEAP32[HEAP32[$5 + 348 >> 2] + 60 >> 2] = 0; + HEAPF32[$5 + 328 >> 2] = HEAPF32[HEAP32[$5 + 344 >> 2] + 8 >> 2] + HEAPF32[HEAP32[$5 + 336 >> 2] + 8 >> 2]; + HEAP32[$5 + 324 >> 2] = 0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2FindMaxSeparation_28int__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__29($5 + 324 | 0, HEAP32[$5 + 344 >> 2], HEAP32[$5 + 340 >> 2], HEAP32[$5 + 336 >> 2], HEAP32[$5 + 332 >> 2]), + HEAPF32[wasm2js_i32$0 + 320 >> 2] = wasm2js_f32$0; + label$1: { + if (HEAPF32[$5 + 320 >> 2] > HEAPF32[$5 + 328 >> 2]) { + break label$1; + } + HEAP32[$5 + 316 >> 2] = 0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2FindMaxSeparation_28int__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__29($5 + 316 | 0, HEAP32[$5 + 336 >> 2], HEAP32[$5 + 332 >> 2], HEAP32[$5 + 344 >> 2], HEAP32[$5 + 340 >> 2]), + HEAPF32[wasm2js_i32$0 + 312 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 312 >> 2] > HEAPF32[$5 + 328 >> 2]) { + break label$1; + } + b2Transform__b2Transform_28_29($5 + 288 | 0); + b2Transform__b2Transform_28_29($5 + 272 | 0); + HEAPF32[$5 + 260 >> 2] = .0005000000237487257; + label$2: { + if (HEAPF32[$5 + 312 >> 2] > Math_fround(HEAPF32[$5 + 320 >> 2] + Math_fround(.0005000000237487257))) { + HEAP32[$5 + 308 >> 2] = HEAP32[$5 + 336 >> 2]; + HEAP32[$5 + 304 >> 2] = HEAP32[$5 + 344 >> 2]; + $2 = HEAP32[$5 + 332 >> 2]; + $1 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$5 + 296 >> 2] = $1; + HEAP32[$5 + 300 >> 2] = $0; + $1 = HEAP32[$2 + 4 >> 2]; + $0 = HEAP32[$2 >> 2]; + HEAP32[$5 + 288 >> 2] = $0; + HEAP32[$5 + 292 >> 2] = $1; + $2 = HEAP32[$5 + 340 >> 2]; + $1 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$5 + 280 >> 2] = $1; + HEAP32[$5 + 284 >> 2] = $0; + $1 = HEAP32[$2 + 4 >> 2]; + $0 = HEAP32[$2 >> 2]; + HEAP32[$5 + 272 >> 2] = $0; + HEAP32[$5 + 276 >> 2] = $1; + HEAP32[$5 + 268 >> 2] = HEAP32[$5 + 316 >> 2]; + HEAP32[HEAP32[$5 + 348 >> 2] + 56 >> 2] = 2; + HEAP8[$5 + 267 | 0] = 1; + break label$2; + } + HEAP32[$5 + 308 >> 2] = HEAP32[$5 + 344 >> 2]; + HEAP32[$5 + 304 >> 2] = HEAP32[$5 + 336 >> 2]; + $2 = HEAP32[$5 + 340 >> 2]; + $1 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$5 + 296 >> 2] = $1; + HEAP32[$5 + 300 >> 2] = $0; + $1 = HEAP32[$2 + 4 >> 2]; + $0 = HEAP32[$2 >> 2]; + HEAP32[$5 + 288 >> 2] = $0; + HEAP32[$5 + 292 >> 2] = $1; + $2 = HEAP32[$5 + 332 >> 2]; + $1 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$5 + 280 >> 2] = $1; + HEAP32[$5 + 284 >> 2] = $0; + $1 = HEAP32[$2 + 4 >> 2]; + $0 = HEAP32[$2 >> 2]; + HEAP32[$5 + 272 >> 2] = $0; + HEAP32[$5 + 276 >> 2] = $1; + HEAP32[$5 + 268 >> 2] = HEAP32[$5 + 324 >> 2]; + HEAP32[HEAP32[$5 + 348 >> 2] + 56 >> 2] = 1; + HEAP8[$5 + 267 | 0] = 0; + } + $0 = $5 + 224 | 0; + $1 = $0 + 24 | 0; + while (1) { + b2ClipVertex__b2ClipVertex_28_29($0); + $0 = $0 + 12 | 0; + if (($1 | 0) != ($0 | 0)) { + continue; + } + break; + } + b2FindIncidentEdge_28b2ClipVertex__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__2c_20int_2c_20b2PolygonShape_20const__2c_20b2Transform_20const__29($5 + 224 | 0, HEAP32[$5 + 308 >> 2], $5 + 288 | 0, HEAP32[$5 + 268 >> 2], HEAP32[$5 + 304 >> 2], $5 + 272 | 0); + HEAP32[$5 + 220 >> 2] = HEAP32[HEAP32[$5 + 308 >> 2] + 148 >> 2]; + HEAP32[$5 + 216 >> 2] = HEAP32[$5 + 308 >> 2] + 20; + HEAP32[$5 + 212 >> 2] = HEAP32[$5 + 268 >> 2]; + if (HEAP32[$5 + 220 >> 2] > (HEAP32[$5 + 268 >> 2] + 1 | 0)) { + $0 = HEAP32[$5 + 268 >> 2] + 1 | 0; + } else { + $0 = 0; + } + HEAP32[$5 + 208 >> 2] = $0; + $2 = HEAP32[$5 + 216 >> 2] + (HEAP32[$5 + 212 >> 2] << 3) | 0; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + HEAP32[$5 + 200 >> 2] = $1; + HEAP32[$5 + 204 >> 2] = $0; + $2 = HEAP32[$5 + 216 >> 2] + (HEAP32[$5 + 208 >> 2] << 3) | 0; + $0 = HEAP32[$2 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + HEAP32[$5 + 192 >> 2] = $0; + HEAP32[$5 + 196 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 184 | 0, $5 + 192 | 0, $5 + 200 | 0); + b2Vec2__Normalize_28_29($5 + 184 | 0); + b2Cross_28b2Vec2_20const__2c_20float_29($5 + 176 | 0, $5 + 184 | 0, Math_fround(1)); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($5 + 160 | 0, $5 + 200 | 0, $5 + 192 | 0); + operator__28float_2c_20b2Vec2_20const__29($5 + 168 | 0, Math_fround(.5), $5 + 160 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($5 + 152 | 0, $5 + 296 | 0, $5 + 184 | 0); + b2Cross_28b2Vec2_20const__2c_20float_29($5 + 144 | 0, $5 + 152 | 0, Math_fround(1)); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 136 | 0, $5 + 288 | 0, $5 + 200 | 0); + $0 = HEAP32[$5 + 140 >> 2]; + $1 = HEAP32[$5 + 136 >> 2]; + HEAP32[$5 + 200 >> 2] = $1; + HEAP32[$5 + 204 >> 2] = $0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 128 | 0, $5 + 288 | 0, $5 + 192 | 0); + $1 = HEAP32[$5 + 132 >> 2]; + $0 = HEAP32[$5 + 128 >> 2]; + HEAP32[$5 + 192 >> 2] = $0; + HEAP32[$5 + 196 >> 2] = $1; + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 144 | 0, $5 + 200 | 0), + HEAPF32[wasm2js_i32$0 + 124 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = Math_fround(Math_fround(-b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 152 | 0, $5 + 200 | 0)) + HEAPF32[$5 + 328 >> 2]), + HEAPF32[wasm2js_i32$0 + 120 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = Math_fround(b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 152 | 0, $5 + 192 | 0) + HEAPF32[$5 + 328 >> 2]), + HEAPF32[wasm2js_i32$0 + 116 >> 2] = wasm2js_f32$0; + $0 = $5 + 80 | 0; + $1 = $0 + 24 | 0; + while (1) { + b2ClipVertex__b2ClipVertex_28_29($0); + $0 = $0 + 12 | 0; + if (($1 | 0) != ($0 | 0)) { + continue; + } + break; + } + $0 = $5 + 48 | 0; + $1 = $0 + 24 | 0; + while (1) { + b2ClipVertex__b2ClipVertex_28_29($0); + $0 = $0 + 12 | 0; + if (($1 | 0) != ($0 | 0)) { + continue; + } + break; + } + b2Vec2__operator__28_29_20const($5 + 36 | 0, $5 + 152 | 0); + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2ClipSegmentToLine_28b2ClipVertex__2c_20b2ClipVertex_20const__2c_20b2Vec2_20const__2c_20float_2c_20int_29($5 + 80 | 0, $5 + 224 | 0, $5 + 36 | 0, HEAPF32[$5 + 120 >> 2], HEAP32[$5 + 212 >> 2]), + HEAP32[wasm2js_i32$0 + 44 >> 2] = wasm2js_i32$1; + if (HEAP32[$5 + 44 >> 2] < 2) { + break label$1; + } + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2ClipSegmentToLine_28b2ClipVertex__2c_20b2ClipVertex_20const__2c_20b2Vec2_20const__2c_20float_2c_20int_29($5 + 48 | 0, $5 + 80 | 0, $5 + 152 | 0, HEAPF32[$5 + 116 >> 2], HEAP32[$5 + 208 >> 2]), + HEAP32[wasm2js_i32$0 + 44 >> 2] = wasm2js_i32$1; + if (HEAP32[$5 + 44 >> 2] < 2) { + break label$1; + } + $0 = HEAP32[$5 + 180 >> 2]; + $1 = HEAP32[$5 + 176 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 348 >> 2]; + HEAP32[$1 + 40 >> 2] = $2; + HEAP32[$1 + 44 >> 2] = $0; + $1 = HEAP32[$5 + 172 >> 2]; + $0 = HEAP32[$5 + 168 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 348 >> 2]; + HEAP32[$0 + 48 >> 2] = $2; + HEAP32[$0 + 52 >> 2] = $1; + HEAP32[$5 + 32 >> 2] = 0; + HEAP32[$5 + 28 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 28 >> 2] < 2) { + wasm2js_i32$0 = $5, wasm2js_f32$0 = Math_fround(b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 144 | 0, ($5 + 48 | 0) + Math_imul(HEAP32[$5 + 28 >> 2], 12) | 0) - HEAPF32[$5 + 124 >> 2]), + HEAPF32[wasm2js_i32$0 + 24 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 24 >> 2] <= HEAPF32[$5 + 328 >> 2]) { + HEAP32[$5 + 20 >> 2] = HEAP32[$5 + 348 >> 2] + Math_imul(HEAP32[$5 + 32 >> 2], 20); + b2MulT_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 12 | 0, $5 + 272 | 0, ($5 + 48 | 0) + Math_imul(HEAP32[$5 + 28 >> 2], 12) | 0); + $0 = HEAP32[$5 + 16 >> 2]; + $1 = HEAP32[$5 + 12 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 20 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAP32[HEAP32[$5 + 20 >> 2] + 16 >> 2] = HEAP32[(($5 + 48 | 0) + Math_imul(HEAP32[$5 + 28 >> 2], 12) | 0) + 8 >> 2]; + if (HEAPU8[$5 + 267 | 0]) { + $0 = HEAP32[$5 + 20 >> 2]; + HEAP32[$5 + 8 >> 2] = HEAPU8[$0 + 16 | 0] | HEAPU8[$0 + 17 | 0] << 8 | (HEAPU8[$0 + 18 | 0] << 16 | HEAPU8[$0 + 19 | 0] << 24); + HEAP8[HEAP32[$5 + 20 >> 2] + 16 | 0] = HEAPU8[$5 + 9 | 0]; + HEAP8[HEAP32[$5 + 20 >> 2] + 17 | 0] = HEAPU8[$5 + 8 | 0]; + HEAP8[HEAP32[$5 + 20 >> 2] + 18 | 0] = HEAPU8[$5 + 11 | 0]; + HEAP8[HEAP32[$5 + 20 >> 2] + 19 | 0] = HEAPU8[$5 + 10 | 0]; + } + HEAP32[$5 + 32 >> 2] = HEAP32[$5 + 32 >> 2] + 1; + } + HEAP32[$5 + 28 >> 2] = HEAP32[$5 + 28 >> 2] + 1; + continue; + } + break; + } + HEAP32[HEAP32[$5 + 348 >> 2] + 60 >> 2] = HEAP32[$5 + 32 >> 2]; + } + __stack_pointer = $5 + 352 | 0; +} + +function b2PrismaticJoint__InitVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 256 | 0; + __stack_pointer = $2; + HEAP32[$2 + 252 >> 2] = $0; + HEAP32[$2 + 248 >> 2] = $1; + $3 = HEAP32[$2 + 252 >> 2]; + HEAP32[$3 + 144 >> 2] = HEAP32[HEAP32[$3 + 48 >> 2] + 8 >> 2]; + HEAP32[$3 + 148 >> 2] = HEAP32[HEAP32[$3 + 52 >> 2] + 8 >> 2]; + $4 = HEAP32[$3 + 48 >> 2]; + $0 = HEAP32[$4 + 28 >> 2]; + $1 = HEAP32[$4 + 32 >> 2]; + HEAP32[$3 + 152 >> 2] = $0; + HEAP32[$3 + 156 >> 2] = $1; + $4 = HEAP32[$3 + 52 >> 2]; + $1 = HEAP32[$4 + 28 >> 2]; + $0 = HEAP32[$4 + 32 >> 2]; + HEAP32[$3 + 160 >> 2] = $1; + HEAP32[$3 + 164 >> 2] = $0; + HEAPF32[$3 + 168 >> 2] = HEAPF32[HEAP32[$3 + 48 >> 2] + 120 >> 2]; + HEAPF32[$3 + 172 >> 2] = HEAPF32[HEAP32[$3 + 52 >> 2] + 120 >> 2]; + HEAPF32[$3 + 176 >> 2] = HEAPF32[HEAP32[$3 + 48 >> 2] + 128 >> 2]; + HEAPF32[$3 + 180 >> 2] = HEAPF32[HEAP32[$3 + 52 >> 2] + 128 >> 2]; + $4 = HEAP32[HEAP32[$2 + 248 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 240 >> 2] = $0; + HEAP32[$2 + 244 >> 2] = $1; + HEAPF32[$2 + 236 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 224 >> 2] = $1; + HEAP32[$2 + 228 >> 2] = $0; + HEAPF32[$2 + 220 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 248 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 208 >> 2] = $0; + HEAP32[$2 + 212 >> 2] = $1; + HEAPF32[$2 + 204 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 192 >> 2] = $1; + HEAP32[$2 + 196 >> 2] = $0; + HEAPF32[$2 + 188 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 180 | 0, HEAPF32[$2 + 236 >> 2]); + b2Rot__b2Rot_28float_29($2 + 172 | 0, HEAPF32[$2 + 204 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 156 | 0, $3 + 68 | 0, $3 + 152 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 164 | 0, $2 + 180 | 0, $2 + 156 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 140 | 0, $3 + 76 | 0, $3 + 160 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 148 | 0, $2 + 172 | 0, $2 + 140 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 116 | 0, $2 + 208 | 0, $2 + 240 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 124 | 0, $2 + 116 | 0, $2 + 148 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 132 | 0, $2 + 124 | 0, $2 + 164 | 0); + HEAPF32[$2 + 112 >> 2] = HEAPF32[$3 + 168 >> 2]; + HEAPF32[$2 + 108 >> 2] = HEAPF32[$3 + 172 >> 2]; + HEAPF32[$2 + 104 >> 2] = HEAPF32[$3 + 176 >> 2]; + HEAPF32[$2 + 100 >> 2] = HEAPF32[$3 + 180 >> 2]; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 92 | 0, $2 + 180 | 0, $3 + 84 | 0); + $1 = HEAP32[$2 + 96 >> 2]; + $0 = HEAP32[$2 + 92 >> 2]; + HEAP32[$3 + 184 >> 2] = $0; + HEAP32[$3 + 188 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 84 | 0, $2 + 132 | 0, $2 + 164 | 0); + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 84 | 0, $3 + 184 | 0), + HEAPF32[wasm2js_i32$0 + 208 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 148 | 0, $3 + 184 | 0), + HEAPF32[wasm2js_i32$0 + 212 >> 2] = wasm2js_f32$0; + HEAPF32[$3 + 236 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 100 >> 2] * HEAPF32[$3 + 212 >> 2]) * HEAPF32[$3 + 212 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 104 >> 2] * HEAPF32[$3 + 208 >> 2]) * HEAPF32[$3 + 208 >> 2]) + Math_fround(HEAPF32[$2 + 112 >> 2] + HEAPF32[$2 + 108 >> 2])); + if (HEAPF32[$3 + 236 >> 2] > Math_fround(0)) { + HEAPF32[$3 + 236 >> 2] = Math_fround(1) / HEAPF32[$3 + 236 >> 2]; + } + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 76 | 0, $2 + 180 | 0, $3 + 92 | 0); + $0 = HEAP32[$2 + 80 >> 2]; + $1 = HEAP32[$2 + 76 >> 2]; + HEAP32[$3 + 192 >> 2] = $1; + HEAP32[$3 + 196 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 68 | 0, $2 + 132 | 0, $2 + 164 | 0); + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 68 | 0, $3 + 192 | 0), + HEAPF32[wasm2js_i32$0 + 200 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 148 | 0, $3 + 192 | 0), + HEAPF32[wasm2js_i32$0 + 204 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 64 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 100 >> 2] * HEAPF32[$3 + 204 >> 2]) * HEAPF32[$3 + 204 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 104 >> 2] * HEAPF32[$3 + 200 >> 2]) * HEAPF32[$3 + 200 >> 2]) + Math_fround(HEAPF32[$2 + 112 >> 2] + HEAPF32[$2 + 108 >> 2])); + HEAPF32[$2 + 60 >> 2] = Math_fround(HEAPF32[$2 + 104 >> 2] * HEAPF32[$3 + 200 >> 2]) + Math_fround(HEAPF32[$2 + 100 >> 2] * HEAPF32[$3 + 204 >> 2]); + HEAPF32[$2 + 56 >> 2] = HEAPF32[$2 + 104 >> 2] + HEAPF32[$2 + 100 >> 2]; + if (HEAPF32[$2 + 56 >> 2] == Math_fround(0)) { + HEAPF32[$2 + 56 >> 2] = 1; + } + b2Vec2__Set_28float_2c_20float_29($3 + 216 | 0, HEAPF32[$2 + 64 >> 2], HEAPF32[$2 + 60 >> 2]); + b2Vec2__Set_28float_2c_20float_29($3 + 224 | 0, HEAPF32[$2 + 60 >> 2], HEAPF32[$2 + 56 >> 2]); + label$3: { + if (HEAP8[$3 + 140 | 0] & 1) { + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 184 | 0, $2 + 132 | 0), + HEAPF32[wasm2js_i32$0 + 232 >> 2] = wasm2js_f32$0; + break label$3; + } + HEAPF32[$3 + 116 >> 2] = 0; + HEAPF32[$3 + 120 >> 2] = 0; + } + if (!(HEAP8[$3 + 141 | 0] & 1)) { + HEAPF32[$3 + 112 >> 2] = 0; + } + label$6: { + if (HEAP8[HEAP32[$2 + 248 >> 2] + 20 | 0] & 1) { + b2Vec2__operator___28float_29($3 + 104 | 0, HEAPF32[HEAP32[$2 + 248 >> 2] + 8 >> 2]); + HEAPF32[$3 + 112 >> 2] = HEAPF32[$3 + 112 >> 2] * HEAPF32[HEAP32[$2 + 248 >> 2] + 8 >> 2]; + HEAPF32[$3 + 116 >> 2] = HEAPF32[$3 + 116 >> 2] * HEAPF32[HEAP32[$2 + 248 >> 2] + 8 >> 2]; + HEAPF32[$3 + 120 >> 2] = HEAPF32[$3 + 120 >> 2] * HEAPF32[HEAP32[$2 + 248 >> 2] + 8 >> 2]; + HEAPF32[$2 + 52 >> 2] = Math_fround(HEAPF32[$3 + 112 >> 2] + HEAPF32[$3 + 116 >> 2]) - HEAPF32[$3 + 120 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 36 | 0, HEAPF32[$3 + 104 >> 2], $3 + 192 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 28 | 0, HEAPF32[$2 + 52 >> 2], $3 + 184 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 44 | 0, $2 + 36 | 0, $2 + 28 | 0); + HEAPF32[$2 + 24 >> 2] = Math_fround(HEAPF32[$2 + 52 >> 2] * HEAPF32[$3 + 208 >> 2]) + Math_fround(Math_fround(HEAPF32[$3 + 104 >> 2] * HEAPF32[$3 + 200 >> 2]) + HEAPF32[$3 + 108 >> 2]); + HEAPF32[$2 + 20 >> 2] = Math_fround(HEAPF32[$2 + 52 >> 2] * HEAPF32[$3 + 212 >> 2]) + Math_fround(Math_fround(HEAPF32[$3 + 104 >> 2] * HEAPF32[$3 + 204 >> 2]) + HEAPF32[$3 + 108 >> 2]); + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$2 + 112 >> 2], $2 + 44 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 224 | 0, $2 + 12 | 0); + HEAPF32[$2 + 220 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 104 >> 2]) * HEAPF32[$2 + 24 >> 2]) + HEAPF32[$2 + 220 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 4 | 0, HEAPF32[$2 + 108 >> 2], $2 + 44 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 192 | 0, $2 + 4 | 0); + HEAPF32[$2 + 188 >> 2] = Math_fround(HEAPF32[$2 + 100 >> 2] * HEAPF32[$2 + 20 >> 2]) + HEAPF32[$2 + 188 >> 2]; + break label$6; + } + b2Vec2__SetZero_28_29($3 + 104 | 0); + HEAPF32[$3 + 112 >> 2] = 0; + HEAPF32[$3 + 116 >> 2] = 0; + HEAPF32[$3 + 120 >> 2] = 0; + } + $1 = HEAP32[$2 + 228 >> 2]; + $0 = HEAP32[$2 + 224 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 144 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 220 >> 2]; + $0 = HEAP32[$2 + 196 >> 2]; + $1 = HEAP32[$2 + 192 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 148 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 188 >> 2]; + __stack_pointer = $2 + 256 | 0; +} + +function b2WheelJoint__SolvePositionConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 336 | 0; + __stack_pointer = $2; + HEAP32[$2 + 332 >> 2] = $0; + HEAP32[$2 + 328 >> 2] = $1; + $3 = HEAP32[$2 + 332 >> 2]; + $4 = HEAP32[HEAP32[$2 + 328 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 320 >> 2] = $1; + HEAP32[$2 + 324 >> 2] = $0; + HEAPF32[$2 + 316 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 328 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 328 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 304 >> 2] = $0; + HEAP32[$2 + 308 >> 2] = $1; + HEAPF32[$2 + 300 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 328 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0) + 8 >> 2]; + HEAPF32[$2 + 296 >> 2] = 0; + if (HEAP8[$3 + 140 | 0] & 1) { + b2Rot__b2Rot_28float_29($2 + 288 | 0, HEAPF32[$2 + 316 >> 2]); + b2Rot__b2Rot_28float_29($2 + 280 | 0, HEAPF32[$2 + 300 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 264 | 0, $3 + 68 | 0, $3 + 160 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 272 | 0, $2 + 288 | 0, $2 + 264 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 248 | 0, $3 + 76 | 0, $3 + 168 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 256 | 0, $2 + 280 | 0, $2 + 248 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 224 | 0, $2 + 304 | 0, $2 + 320 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 232 | 0, $2 + 224 | 0, $2 + 256 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 240 | 0, $2 + 232 | 0, $2 + 272 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 216 | 0, $2 + 288 | 0, $3 + 84 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 204 | 0, $2 + 240 | 0, $2 + 272 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 204 | 0, $3 + 192 | 0), + HEAPF32[wasm2js_i32$0 + 212 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 256 | 0, $3 + 192 | 0), + HEAPF32[wasm2js_i32$0 + 200 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 196 >> 2] = 0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 216 | 0, $2 + 240 | 0), + HEAPF32[wasm2js_i32$0 + 192 >> 2] = wasm2js_f32$0; + label$2: { + if (float_20b2Abs_float__28float_29(Math_fround(HEAPF32[$3 + 128 >> 2] - HEAPF32[$3 + 124 >> 2])) < Math_fround(.009999999776482582)) { + HEAPF32[$2 + 196 >> 2] = HEAPF32[$2 + 192 >> 2]; + break label$2; + } + label$4: { + if (HEAPF32[$2 + 192 >> 2] <= HEAPF32[$3 + 124 >> 2]) { + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Min_float__28float_2c_20float_29(Math_fround(HEAPF32[$2 + 192 >> 2] - HEAPF32[$3 + 124 >> 2]), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 196 >> 2] = wasm2js_f32$0; + break label$4; + } + if (HEAPF32[$2 + 192 >> 2] >= HEAPF32[$3 + 128 >> 2]) { + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(Math_fround(HEAPF32[$2 + 192 >> 2] - HEAPF32[$3 + 128 >> 2]), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 196 >> 2] = wasm2js_f32$0; + } + } + } + if (HEAPF32[$2 + 196 >> 2] != Math_fround(0)) { + HEAPF32[$2 + 188 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 188 >> 2] * HEAPF32[$2 + 200 >> 2]) * HEAPF32[$2 + 200 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$3 + 184 >> 2] * HEAPF32[$2 + 212 >> 2]) * HEAPF32[$2 + 212 >> 2]) + Math_fround(HEAPF32[$3 + 176 >> 2] + HEAPF32[$3 + 180 >> 2])); + HEAPF32[$2 + 184 >> 2] = 0; + if (HEAPF32[$2 + 188 >> 2] != Math_fround(0)) { + HEAPF32[$2 + 184 >> 2] = Math_fround(-HEAPF32[$2 + 196 >> 2]) / HEAPF32[$2 + 188 >> 2]; + } + operator__28float_2c_20b2Vec2_20const__29($2 + 176 | 0, HEAPF32[$2 + 184 >> 2], $2 + 216 | 0); + HEAPF32[$2 + 172 >> 2] = HEAPF32[$2 + 184 >> 2] * HEAPF32[$2 + 212 >> 2]; + HEAPF32[$2 + 168 >> 2] = HEAPF32[$2 + 184 >> 2] * HEAPF32[$2 + 200 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 160 | 0, HEAPF32[$3 + 176 >> 2], $2 + 176 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 320 | 0, $2 + 160 | 0); + HEAPF32[$2 + 316 >> 2] = Math_fround(Math_fround(-HEAPF32[$3 + 184 >> 2]) * HEAPF32[$2 + 172 >> 2]) + HEAPF32[$2 + 316 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 152 | 0, HEAPF32[$3 + 180 >> 2], $2 + 176 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 304 | 0, $2 + 152 | 0); + HEAPF32[$2 + 300 >> 2] = Math_fround(HEAPF32[$3 + 188 >> 2] * HEAPF32[$2 + 168 >> 2]) + HEAPF32[$2 + 300 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Abs_float__28float_29(HEAPF32[$2 + 196 >> 2]), + HEAPF32[wasm2js_i32$0 + 296 >> 2] = wasm2js_f32$0; + } + } + b2Rot__b2Rot_28float_29($2 + 144 | 0, HEAPF32[$2 + 316 >> 2]); + b2Rot__b2Rot_28float_29($2 + 136 | 0, HEAPF32[$2 + 300 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 120 | 0, $3 + 68 | 0, $3 + 160 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 128 | 0, $2 + 144 | 0, $2 + 120 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 104 | 0, $3 + 76 | 0, $3 + 168 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 112 | 0, $2 + 136 | 0, $2 + 104 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 80 | 0, $2 + 304 | 0, $2 + 320 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 88 | 0, $2 + 80 | 0, $2 + 112 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 96 | 0, $2 + 88 | 0, $2 + 128 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 72 | 0, $2 + 144 | 0, $3 + 92 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 60 | 0, $2 + 96 | 0, $2 + 128 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 60 | 0, $2 + 72 | 0), + HEAPF32[wasm2js_i32$0 + 68 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 112 | 0, $2 + 72 | 0), + HEAPF32[wasm2js_i32$0 + 56 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 96 | 0, $2 + 72 | 0), + HEAPF32[wasm2js_i32$0 + 52 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 48 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 188 >> 2] * HEAPF32[$3 + 220 >> 2]) * HEAPF32[$3 + 220 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$3 + 184 >> 2] * HEAPF32[$3 + 216 >> 2]) * HEAPF32[$3 + 216 >> 2]) + Math_fround(HEAPF32[$3 + 176 >> 2] + HEAPF32[$3 + 180 >> 2])); + HEAPF32[$2 + 44 >> 2] = 0; + if (HEAPF32[$2 + 48 >> 2] != Math_fround(0)) { + HEAPF32[$2 + 44 >> 2] = Math_fround(-HEAPF32[$2 + 52 >> 2]) / HEAPF32[$2 + 48 >> 2]; + } + operator__28float_2c_20b2Vec2_20const__29($2 + 36 | 0, HEAPF32[$2 + 44 >> 2], $2 + 72 | 0); + HEAPF32[$2 + 32 >> 2] = HEAPF32[$2 + 44 >> 2] * HEAPF32[$2 + 68 >> 2]; + HEAPF32[$2 + 28 >> 2] = HEAPF32[$2 + 44 >> 2] * HEAPF32[$2 + 56 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, HEAPF32[$3 + 176 >> 2], $2 + 36 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 320 | 0, $2 + 20 | 0); + HEAPF32[$2 + 316 >> 2] = Math_fround(Math_fround(-HEAPF32[$3 + 184 >> 2]) * HEAPF32[$2 + 32 >> 2]) + HEAPF32[$2 + 316 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$3 + 180 >> 2], $2 + 36 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 304 | 0, $2 + 12 | 0); + HEAPF32[$2 + 300 >> 2] = Math_fround(HEAPF32[$3 + 188 >> 2] * HEAPF32[$2 + 28 >> 2]) + HEAPF32[$2 + 300 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(HEAPF32[$2 + 296 >> 2], float_20b2Abs_float__28float_29(HEAPF32[$2 + 52 >> 2])), + HEAPF32[wasm2js_i32$0 + 296 >> 2] = wasm2js_f32$0; + $0 = HEAP32[$2 + 324 >> 2]; + $1 = HEAP32[$2 + 320 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 328 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 328 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 152 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 316 >> 2]; + $1 = HEAP32[$2 + 308 >> 2]; + $0 = HEAP32[$2 + 304 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 328 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 328 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 156 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 300 >> 2]; + __stack_pointer = $2 + 336 | 0; + return HEAPF32[$2 + 296 >> 2] <= Math_fround(.004999999888241291) | 0; +} + +function b2DynamicTree__InsertLeaf_28int_29($0, $1) { + var $2 = 0, $3 = Math_fround(0), $4 = 0, $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0), wasm2js_i32$1 = 0; + $2 = __stack_pointer - 176 | 0; + __stack_pointer = $2; + HEAP32[$2 + 172 >> 2] = $0; + HEAP32[$2 + 168 >> 2] = $1; + $1 = HEAP32[$2 + 172 >> 2]; + HEAP32[$1 + 24 >> 2] = HEAP32[$1 + 24 >> 2] + 1; + label$1: { + if (HEAP32[$1 >> 2] == -1) { + HEAP32[$1 >> 2] = HEAP32[$2 + 168 >> 2]; + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$1 >> 2], 40) | 0) + 20 >> 2] = -1; + break label$1; + } + $4 = HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 168 >> 2], 40) | 0; + $5 = HEAP32[$4 + 8 >> 2]; + $0 = HEAP32[$4 + 12 >> 2]; + HEAP32[$2 + 160 >> 2] = $5; + HEAP32[$2 + 164 >> 2] = $0; + $5 = HEAP32[$4 + 4 >> 2]; + $0 = HEAP32[$4 >> 2]; + HEAP32[$2 + 152 >> 2] = $0; + HEAP32[$2 + 156 >> 2] = $5; + HEAP32[$2 + 148 >> 2] = HEAP32[$1 >> 2]; + while (1) { + label$4: { + if (b2TreeNode__IsLeaf_28_29_20const(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 148 >> 2], 40) | 0) & 1) { + break label$4; + } + HEAP32[$2 + 144 >> 2] = HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 148 >> 2], 40) | 0) + 24 >> 2]; + HEAP32[$2 + 140 >> 2] = HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 148 >> 2], 40) | 0) + 28 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2AABB__GetPerimeter_28_29_20const(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 148 >> 2], 40) | 0), + HEAPF32[wasm2js_i32$0 + 136 >> 2] = wasm2js_f32$0; + b2AABB__b2AABB_28_29($2 + 120 | 0); + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29($2 + 120 | 0, HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 148 >> 2], 40) | 0, $2 + 152 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2AABB__GetPerimeter_28_29_20const($2 + 120 | 0), + HEAPF32[wasm2js_i32$0 + 116 >> 2] = wasm2js_f32$0; + $3 = HEAPF32[$2 + 116 >> 2]; + HEAPF32[$2 + 112 >> 2] = $3 + $3; + $3 = Math_fround(HEAPF32[$2 + 116 >> 2] - HEAPF32[$2 + 136 >> 2]); + HEAPF32[$2 + 108 >> 2] = $3 + $3; + label$5: { + if (b2TreeNode__IsLeaf_28_29_20const(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 144 >> 2], 40) | 0) & 1) { + b2AABB__b2AABB_28_29($2 + 88 | 0); + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29($2 + 88 | 0, $2 + 152 | 0, HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 144 >> 2], 40) | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(b2AABB__GetPerimeter_28_29_20const($2 + 88 | 0) + HEAPF32[$2 + 108 >> 2]), + HEAPF32[wasm2js_i32$0 + 104 >> 2] = wasm2js_f32$0; + break label$5; + } + b2AABB__b2AABB_28_29($2 + 72 | 0); + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29($2 + 72 | 0, $2 + 152 | 0, HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 144 >> 2], 40) | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2AABB__GetPerimeter_28_29_20const(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 144 >> 2], 40) | 0), + HEAPF32[wasm2js_i32$0 + 68 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2AABB__GetPerimeter_28_29_20const($2 + 72 | 0), + HEAPF32[wasm2js_i32$0 + 64 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 104 >> 2] = Math_fround(HEAPF32[$2 + 64 >> 2] - HEAPF32[$2 + 68 >> 2]) + HEAPF32[$2 + 108 >> 2]; + } + label$7: { + if (b2TreeNode__IsLeaf_28_29_20const(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 140 >> 2], 40) | 0) & 1) { + b2AABB__b2AABB_28_29($2 + 44 | 0); + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29($2 + 44 | 0, $2 + 152 | 0, HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 140 >> 2], 40) | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(b2AABB__GetPerimeter_28_29_20const($2 + 44 | 0) + HEAPF32[$2 + 108 >> 2]), + HEAPF32[wasm2js_i32$0 + 60 >> 2] = wasm2js_f32$0; + break label$7; + } + b2AABB__b2AABB_28_29($2 + 28 | 0); + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29($2 + 28 | 0, $2 + 152 | 0, HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 140 >> 2], 40) | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2AABB__GetPerimeter_28_29_20const(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 140 >> 2], 40) | 0), + HEAPF32[wasm2js_i32$0 + 24 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2AABB__GetPerimeter_28_29_20const($2 + 28 | 0), + HEAPF32[wasm2js_i32$0 + 20 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 60 >> 2] = Math_fround(HEAPF32[$2 + 20 >> 2] - HEAPF32[$2 + 24 >> 2]) + HEAPF32[$2 + 108 >> 2]; + } + if (!(!(HEAPF32[$2 + 112 >> 2] < HEAPF32[$2 + 104 >> 2]) | !(HEAPF32[$2 + 112 >> 2] < HEAPF32[$2 + 60 >> 2]))) { + break label$4; + } + label$10: { + if (HEAPF32[$2 + 104 >> 2] < HEAPF32[$2 + 60 >> 2]) { + HEAP32[$2 + 148 >> 2] = HEAP32[$2 + 144 >> 2]; + break label$10; + } + HEAP32[$2 + 148 >> 2] = HEAP32[$2 + 140 >> 2]; + } + continue; + } + break; + } + HEAP32[$2 + 16 >> 2] = HEAP32[$2 + 148 >> 2]; + HEAP32[$2 + 12 >> 2] = HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 16 >> 2], 40) | 0) + 20 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2DynamicTree__AllocateNode_28_29($1), HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 20 >> 2] = HEAP32[$2 + 12 >> 2]; + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 16 >> 2] = 0; + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0, $2 + 152 | 0, HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 16 >> 2], 40) | 0); + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 32 >> 2] = HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 16 >> 2], 40) | 0) + 32 >> 2] + 1; + label$12: { + if (HEAP32[$2 + 12 >> 2] != -1) { + label$14: { + if (HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 12 >> 2], 40) | 0) + 24 >> 2] == HEAP32[$2 + 16 >> 2]) { + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 12 >> 2], 40) | 0) + 24 >> 2] = HEAP32[$2 + 8 >> 2]; + break label$14; + } + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 12 >> 2], 40) | 0) + 28 >> 2] = HEAP32[$2 + 8 >> 2]; + } + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 24 >> 2] = HEAP32[$2 + 16 >> 2]; + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 28 >> 2] = HEAP32[$2 + 168 >> 2]; + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 16 >> 2], 40) | 0) + 20 >> 2] = HEAP32[$2 + 8 >> 2]; + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 168 >> 2], 40) | 0) + 20 >> 2] = HEAP32[$2 + 8 >> 2]; + break label$12; + } + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 24 >> 2] = HEAP32[$2 + 16 >> 2]; + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 28 >> 2] = HEAP32[$2 + 168 >> 2]; + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 16 >> 2], 40) | 0) + 20 >> 2] = HEAP32[$2 + 8 >> 2]; + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 168 >> 2], 40) | 0) + 20 >> 2] = HEAP32[$2 + 8 >> 2]; + HEAP32[$1 >> 2] = HEAP32[$2 + 8 >> 2]; + } + HEAP32[$2 + 148 >> 2] = HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 168 >> 2], 40) | 0) + 20 >> 2]; + while (1) { + if (HEAP32[$2 + 148 >> 2] == -1) { + break label$1; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2DynamicTree__Balance_28int_29($1, HEAP32[$2 + 148 >> 2]), + HEAP32[wasm2js_i32$0 + 148 >> 2] = wasm2js_i32$1; + HEAP32[$2 + 4 >> 2] = HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 148 >> 2], 40) | 0) + 24 >> 2]; + HEAP32[$2 >> 2] = HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 148 >> 2], 40) | 0) + 28 >> 2]; + if (HEAP32[$2 + 4 >> 2] == -1) { + __assert_fail(12427, 5965, 327, 8018); + wasm2js_trap(); + } + if (HEAP32[$2 >> 2] == -1) { + __assert_fail(12412, 5965, 328, 8018); + wasm2js_trap(); + } else { + $0 = int_20b2Max_int__28int_2c_20int_29(HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 4 >> 2], 40) | 0) + 32 >> 2], HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 >> 2], 40) | 0) + 32 >> 2]); + HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 148 >> 2], 40) | 0) + 32 >> 2] = $0 + 1; + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 148 >> 2], 40) | 0, HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 4 >> 2], 40) | 0, HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 >> 2], 40) | 0); + HEAP32[$2 + 148 >> 2] = HEAP32[(HEAP32[$1 + 4 >> 2] + Math_imul(HEAP32[$2 + 148 >> 2], 40) | 0) + 20 >> 2]; + continue; + } + } + } + __stack_pointer = $2 + 176 | 0; +} + +function b2DynamicTree__Balance_28int_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 80 | 0; + __stack_pointer = $2; + HEAP32[$2 + 72 >> 2] = $0; + HEAP32[$2 + 68 >> 2] = $1; + $0 = HEAP32[$2 + 72 >> 2]; + if (HEAP32[$2 + 68 >> 2] == -1) { + __assert_fail(12401, 5965, 402, 10013); + wasm2js_trap(); + } + HEAP32[$2 + 64 >> 2] = HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 68 >> 2], 40); + label$2: { + if (!(!(b2TreeNode__IsLeaf_28_29_20const(HEAP32[$2 + 64 >> 2]) & 1) & HEAP32[HEAP32[$2 + 64 >> 2] + 32 >> 2] >= 2)) { + HEAP32[$2 + 76 >> 2] = HEAP32[$2 + 68 >> 2]; + break label$2; + } + HEAP32[$2 + 60 >> 2] = HEAP32[HEAP32[$2 + 64 >> 2] + 24 >> 2]; + HEAP32[$2 + 56 >> 2] = HEAP32[HEAP32[$2 + 64 >> 2] + 28 >> 2]; + if (!(HEAP32[$2 + 60 >> 2] < HEAP32[$0 + 12 >> 2] & HEAP32[$2 + 60 >> 2] >= 0)) { + __assert_fail(1576, 5965, 412, 10013); + wasm2js_trap(); + } + if (!(HEAP32[$2 + 56 >> 2] < HEAP32[$0 + 12 >> 2] & HEAP32[$2 + 56 >> 2] >= 0)) { + __assert_fail(1545, 5965, 413, 10013); + wasm2js_trap(); + } + HEAP32[$2 + 52 >> 2] = HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 60 >> 2], 40); + HEAP32[$2 + 48 >> 2] = HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 56 >> 2], 40); + HEAP32[$2 + 44 >> 2] = HEAP32[HEAP32[$2 + 48 >> 2] + 32 >> 2] - HEAP32[HEAP32[$2 + 52 >> 2] + 32 >> 2]; + if (HEAP32[$2 + 44 >> 2] > 1) { + HEAP32[$2 + 40 >> 2] = HEAP32[HEAP32[$2 + 48 >> 2] + 24 >> 2]; + HEAP32[$2 + 36 >> 2] = HEAP32[HEAP32[$2 + 48 >> 2] + 28 >> 2]; + HEAP32[$2 + 32 >> 2] = HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 40 >> 2], 40); + HEAP32[$2 + 28 >> 2] = HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 36 >> 2], 40); + if (!(HEAP32[$2 + 40 >> 2] < HEAP32[$0 + 12 >> 2] & HEAP32[$2 + 40 >> 2] >= 0)) { + __assert_fail(1452, 5965, 427, 10013); + wasm2js_trap(); + } + if (!(HEAP32[$2 + 36 >> 2] < HEAP32[$0 + 12 >> 2] & HEAP32[$2 + 36 >> 2] >= 0)) { + __assert_fail(1421, 5965, 428, 10013); + wasm2js_trap(); + } + HEAP32[HEAP32[$2 + 48 >> 2] + 24 >> 2] = HEAP32[$2 + 68 >> 2]; + HEAP32[HEAP32[$2 + 48 >> 2] + 20 >> 2] = HEAP32[HEAP32[$2 + 64 >> 2] + 20 >> 2]; + HEAP32[HEAP32[$2 + 64 >> 2] + 20 >> 2] = HEAP32[$2 + 56 >> 2]; + label$14: { + if (HEAP32[HEAP32[$2 + 48 >> 2] + 20 >> 2] != -1) { + if (HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[HEAP32[$2 + 48 >> 2] + 20 >> 2], 40) | 0) + 24 >> 2] == HEAP32[$2 + 68 >> 2]) { + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[HEAP32[$2 + 48 >> 2] + 20 >> 2], 40) | 0) + 24 >> 2] = HEAP32[$2 + 56 >> 2]; + break label$14; + } + if (HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[HEAP32[$2 + 48 >> 2] + 20 >> 2], 40) | 0) + 28 >> 2] != HEAP32[$2 + 68 >> 2]) { + __assert_fail(11187, 5965, 444, 10013); + wasm2js_trap(); + } + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[HEAP32[$2 + 48 >> 2] + 20 >> 2], 40) | 0) + 28 >> 2] = HEAP32[$2 + 56 >> 2]; + break label$14; + } + HEAP32[$0 >> 2] = HEAP32[$2 + 56 >> 2]; + } + label$18: { + if (HEAP32[HEAP32[$2 + 32 >> 2] + 32 >> 2] > HEAP32[HEAP32[$2 + 28 >> 2] + 32 >> 2]) { + HEAP32[HEAP32[$2 + 48 >> 2] + 28 >> 2] = HEAP32[$2 + 40 >> 2]; + HEAP32[HEAP32[$2 + 64 >> 2] + 28 >> 2] = HEAP32[$2 + 36 >> 2]; + HEAP32[HEAP32[$2 + 28 >> 2] + 20 >> 2] = HEAP32[$2 + 68 >> 2]; + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$2 + 64 >> 2], HEAP32[$2 + 52 >> 2], HEAP32[$2 + 28 >> 2]); + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$2 + 48 >> 2], HEAP32[$2 + 64 >> 2], HEAP32[$2 + 32 >> 2]); + $0 = int_20b2Max_int__28int_2c_20int_29(HEAP32[HEAP32[$2 + 52 >> 2] + 32 >> 2], HEAP32[HEAP32[$2 + 28 >> 2] + 32 >> 2]); + HEAP32[HEAP32[$2 + 64 >> 2] + 32 >> 2] = $0 + 1; + $0 = int_20b2Max_int__28int_2c_20int_29(HEAP32[HEAP32[$2 + 64 >> 2] + 32 >> 2], HEAP32[HEAP32[$2 + 32 >> 2] + 32 >> 2]); + HEAP32[HEAP32[$2 + 48 >> 2] + 32 >> 2] = $0 + 1; + break label$18; + } + HEAP32[HEAP32[$2 + 48 >> 2] + 28 >> 2] = HEAP32[$2 + 36 >> 2]; + HEAP32[HEAP32[$2 + 64 >> 2] + 28 >> 2] = HEAP32[$2 + 40 >> 2]; + HEAP32[HEAP32[$2 + 32 >> 2] + 20 >> 2] = HEAP32[$2 + 68 >> 2]; + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$2 + 64 >> 2], HEAP32[$2 + 52 >> 2], HEAP32[$2 + 32 >> 2]); + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$2 + 48 >> 2], HEAP32[$2 + 64 >> 2], HEAP32[$2 + 28 >> 2]); + $0 = int_20b2Max_int__28int_2c_20int_29(HEAP32[HEAP32[$2 + 52 >> 2] + 32 >> 2], HEAP32[HEAP32[$2 + 32 >> 2] + 32 >> 2]); + HEAP32[HEAP32[$2 + 64 >> 2] + 32 >> 2] = $0 + 1; + $0 = int_20b2Max_int__28int_2c_20int_29(HEAP32[HEAP32[$2 + 64 >> 2] + 32 >> 2], HEAP32[HEAP32[$2 + 28 >> 2] + 32 >> 2]); + HEAP32[HEAP32[$2 + 48 >> 2] + 32 >> 2] = $0 + 1; + } + HEAP32[$2 + 76 >> 2] = HEAP32[$2 + 56 >> 2]; + break label$2; + } + if (HEAP32[$2 + 44 >> 2] < -1) { + HEAP32[$2 + 24 >> 2] = HEAP32[HEAP32[$2 + 52 >> 2] + 24 >> 2]; + HEAP32[$2 + 20 >> 2] = HEAP32[HEAP32[$2 + 52 >> 2] + 28 >> 2]; + HEAP32[$2 + 16 >> 2] = HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 24 >> 2], 40); + HEAP32[$2 + 12 >> 2] = HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 20 >> 2], 40); + if (!(HEAP32[$2 + 24 >> 2] < HEAP32[$0 + 12 >> 2] & HEAP32[$2 + 24 >> 2] >= 0)) { + __assert_fail(1514, 5965, 487, 10013); + wasm2js_trap(); + } + if (!(HEAP32[$2 + 20 >> 2] < HEAP32[$0 + 12 >> 2] & HEAP32[$2 + 20 >> 2] >= 0)) { + __assert_fail(1483, 5965, 488, 10013); + wasm2js_trap(); + } + HEAP32[HEAP32[$2 + 52 >> 2] + 24 >> 2] = HEAP32[$2 + 68 >> 2]; + HEAP32[HEAP32[$2 + 52 >> 2] + 20 >> 2] = HEAP32[HEAP32[$2 + 64 >> 2] + 20 >> 2]; + HEAP32[HEAP32[$2 + 64 >> 2] + 20 >> 2] = HEAP32[$2 + 60 >> 2]; + label$25: { + if (HEAP32[HEAP32[$2 + 52 >> 2] + 20 >> 2] != -1) { + if (HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[HEAP32[$2 + 52 >> 2] + 20 >> 2], 40) | 0) + 24 >> 2] == HEAP32[$2 + 68 >> 2]) { + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[HEAP32[$2 + 52 >> 2] + 20 >> 2], 40) | 0) + 24 >> 2] = HEAP32[$2 + 60 >> 2]; + break label$25; + } + if (HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[HEAP32[$2 + 52 >> 2] + 20 >> 2], 40) | 0) + 28 >> 2] != HEAP32[$2 + 68 >> 2]) { + __assert_fail(11219, 5965, 504, 10013); + wasm2js_trap(); + } + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[HEAP32[$2 + 52 >> 2] + 20 >> 2], 40) | 0) + 28 >> 2] = HEAP32[$2 + 60 >> 2]; + break label$25; + } + HEAP32[$0 >> 2] = HEAP32[$2 + 60 >> 2]; + } + label$29: { + if (HEAP32[HEAP32[$2 + 16 >> 2] + 32 >> 2] > HEAP32[HEAP32[$2 + 12 >> 2] + 32 >> 2]) { + HEAP32[HEAP32[$2 + 52 >> 2] + 28 >> 2] = HEAP32[$2 + 24 >> 2]; + HEAP32[HEAP32[$2 + 64 >> 2] + 24 >> 2] = HEAP32[$2 + 20 >> 2]; + HEAP32[HEAP32[$2 + 12 >> 2] + 20 >> 2] = HEAP32[$2 + 68 >> 2]; + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$2 + 64 >> 2], HEAP32[$2 + 48 >> 2], HEAP32[$2 + 12 >> 2]); + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$2 + 52 >> 2], HEAP32[$2 + 64 >> 2], HEAP32[$2 + 16 >> 2]); + $0 = int_20b2Max_int__28int_2c_20int_29(HEAP32[HEAP32[$2 + 48 >> 2] + 32 >> 2], HEAP32[HEAP32[$2 + 12 >> 2] + 32 >> 2]); + HEAP32[HEAP32[$2 + 64 >> 2] + 32 >> 2] = $0 + 1; + $0 = int_20b2Max_int__28int_2c_20int_29(HEAP32[HEAP32[$2 + 64 >> 2] + 32 >> 2], HEAP32[HEAP32[$2 + 16 >> 2] + 32 >> 2]); + HEAP32[HEAP32[$2 + 52 >> 2] + 32 >> 2] = $0 + 1; + break label$29; + } + HEAP32[HEAP32[$2 + 52 >> 2] + 28 >> 2] = HEAP32[$2 + 20 >> 2]; + HEAP32[HEAP32[$2 + 64 >> 2] + 24 >> 2] = HEAP32[$2 + 24 >> 2]; + HEAP32[HEAP32[$2 + 16 >> 2] + 20 >> 2] = HEAP32[$2 + 68 >> 2]; + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$2 + 64 >> 2], HEAP32[$2 + 48 >> 2], HEAP32[$2 + 16 >> 2]); + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$2 + 52 >> 2], HEAP32[$2 + 64 >> 2], HEAP32[$2 + 12 >> 2]); + $0 = int_20b2Max_int__28int_2c_20int_29(HEAP32[HEAP32[$2 + 48 >> 2] + 32 >> 2], HEAP32[HEAP32[$2 + 16 >> 2] + 32 >> 2]); + HEAP32[HEAP32[$2 + 64 >> 2] + 32 >> 2] = $0 + 1; + $0 = int_20b2Max_int__28int_2c_20int_29(HEAP32[HEAP32[$2 + 64 >> 2] + 32 >> 2], HEAP32[HEAP32[$2 + 12 >> 2] + 32 >> 2]); + HEAP32[HEAP32[$2 + 52 >> 2] + 32 >> 2] = $0 + 1; + } + HEAP32[$2 + 76 >> 2] = HEAP32[$2 + 60 >> 2]; + break label$2; + } + HEAP32[$2 + 76 >> 2] = HEAP32[$2 + 68 >> 2]; + } + __stack_pointer = $2 + 80 | 0; + return HEAP32[$2 + 76 >> 2]; +} + +function b2SeparationFunction__Initialize_28b2SimplexCache_20const__2c_20b2DistanceProxy_20const__2c_20b2Sweep_20const__2c_20b2DistanceProxy_20const__2c_20b2Sweep_20const__2c_20float_29($0, $1, $2, $3, $4, $5, $6) { + var $7 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $7 = __stack_pointer - 336 | 0; + __stack_pointer = $7; + HEAP32[$7 + 328 >> 2] = $0; + HEAP32[$7 + 324 >> 2] = $1; + HEAP32[$7 + 320 >> 2] = $2; + HEAP32[$7 + 316 >> 2] = $3; + HEAP32[$7 + 312 >> 2] = $4; + HEAP32[$7 + 308 >> 2] = $5; + HEAPF32[$7 + 304 >> 2] = $6; + $2 = HEAP32[$7 + 328 >> 2]; + HEAP32[$2 >> 2] = HEAP32[$7 + 320 >> 2]; + HEAP32[$2 + 4 >> 2] = HEAP32[$7 + 312 >> 2]; + HEAP32[$7 + 300 >> 2] = HEAPU16[HEAP32[$7 + 324 >> 2] + 4 >> 1]; + if (!(HEAP32[$7 + 300 >> 2] < 3 & HEAP32[$7 + 300 >> 2] > 0)) { + __assert_fail(12024, 5216, 56, 8606); + wasm2js_trap(); + } + $3 = HEAP32[$7 + 316 >> 2]; + $0 = HEAP32[$3 >> 2]; + $1 = HEAP32[$3 + 4 >> 2]; + $4 = $0; + $0 = $2; + HEAP32[$0 + 8 >> 2] = $4; + HEAP32[$0 + 12 >> 2] = $1; + HEAP32[$0 + 40 >> 2] = HEAP32[$3 + 32 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $1 = HEAP32[$3 + 24 >> 2]; + $4 = $1; + $1 = $2; + HEAP32[$1 + 32 >> 2] = $4; + HEAP32[$1 + 36 >> 2] = $0; + $1 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 16 >> 2]; + $4 = $0; + $0 = $2; + HEAP32[$0 + 24 >> 2] = $4; + HEAP32[$0 + 28 >> 2] = $1; + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$3 + 8 >> 2]; + $3 = $1; + $1 = $2; + HEAP32[$1 + 16 >> 2] = $3; + HEAP32[$1 + 20 >> 2] = $0; + $3 = HEAP32[$7 + 308 >> 2]; + $0 = HEAP32[$3 >> 2]; + $1 = HEAP32[$3 + 4 >> 2]; + $4 = $0; + $0 = $2; + HEAP32[$0 + 44 >> 2] = $4; + HEAP32[$0 + 48 >> 2] = $1; + HEAP32[$0 + 76 >> 2] = HEAP32[$3 + 32 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $1 = HEAP32[$3 + 24 >> 2]; + $4 = $1; + $1 = $2; + HEAP32[$1 + 68 >> 2] = $4; + HEAP32[$1 + 72 >> 2] = $0; + $1 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 16 >> 2]; + $4 = $0; + $0 = $2; + HEAP32[$0 + 60 >> 2] = $4; + HEAP32[$0 + 64 >> 2] = $1; + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$3 + 8 >> 2]; + $3 = $1; + $1 = $2; + HEAP32[$1 + 52 >> 2] = $3; + HEAP32[$1 + 56 >> 2] = $0; + b2Transform__b2Transform_28_29($7 + 284 | 0); + b2Transform__b2Transform_28_29($7 + 268 | 0); + b2Sweep__GetTransform_28b2Transform__2c_20float_29_20const($1 + 8 | 0, $7 + 284 | 0, HEAPF32[$7 + 304 >> 2]); + b2Sweep__GetTransform_28b2Transform__2c_20float_29_20const($1 + 44 | 0, $7 + 268 | 0, HEAPF32[$7 + 304 >> 2]); + label$3: { + if (HEAP32[$7 + 300 >> 2] == 1) { + HEAP32[$2 + 80 >> 2] = 0; + $3 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$2 >> 2], HEAPU8[HEAP32[$7 + 324 >> 2] + 6 | 0]); + $0 = HEAP32[$3 >> 2]; + $1 = HEAP32[$3 + 4 >> 2]; + HEAP32[$7 + 256 >> 2] = $0; + HEAP32[$7 + 260 >> 2] = $1; + $3 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$2 + 4 >> 2], HEAPU8[HEAP32[$7 + 324 >> 2] + 9 | 0]); + $1 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + HEAP32[$7 + 248 >> 2] = $1; + HEAP32[$7 + 252 >> 2] = $0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($7 + 240 | 0, $7 + 284 | 0, $7 + 256 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($7 + 232 | 0, $7 + 268 | 0, $7 + 248 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($7 + 224 | 0, $7 + 232 | 0, $7 + 240 | 0); + $1 = HEAP32[$7 + 228 >> 2]; + $0 = HEAP32[$7 + 224 >> 2]; + $3 = $0; + $0 = $2; + HEAP32[$0 + 92 >> 2] = $3; + HEAP32[$0 + 96 >> 2] = $1; + wasm2js_i32$0 = $7, wasm2js_f32$0 = b2Vec2__Normalize_28_29($0 + 92 | 0), HEAPF32[wasm2js_i32$0 + 220 >> 2] = wasm2js_f32$0; + HEAPF32[$7 + 332 >> 2] = HEAPF32[$7 + 220 >> 2]; + break label$3; + } + if (HEAPU8[HEAP32[$7 + 324 >> 2] + 6 | 0] == HEAPU8[HEAP32[$7 + 324 >> 2] + 7 | 0]) { + HEAP32[$2 + 80 >> 2] = 2; + $3 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$7 + 312 >> 2], HEAPU8[HEAP32[$7 + 324 >> 2] + 9 | 0]); + $1 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + HEAP32[$7 + 208 >> 2] = $1; + HEAP32[$7 + 212 >> 2] = $0; + $3 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$7 + 312 >> 2], HEAPU8[HEAP32[$7 + 324 >> 2] + 10 | 0]); + $0 = HEAP32[$3 >> 2]; + $1 = HEAP32[$3 + 4 >> 2]; + HEAP32[$7 + 200 >> 2] = $0; + HEAP32[$7 + 204 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($7 + 184 | 0, $7 + 200 | 0, $7 + 208 | 0); + b2Cross_28b2Vec2_20const__2c_20float_29($7 + 192 | 0, $7 + 184 | 0, Math_fround(1)); + $0 = HEAP32[$7 + 196 >> 2]; + $1 = HEAP32[$7 + 192 >> 2]; + $3 = $1; + $1 = $2; + HEAP32[$1 + 92 >> 2] = $3; + HEAP32[$1 + 96 >> 2] = $0; + b2Vec2__Normalize_28_29($1 + 92 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($7 + 176 | 0, $7 + 276 | 0, $1 + 92 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($7 + 160 | 0, $7 + 208 | 0, $7 + 200 | 0); + operator__28float_2c_20b2Vec2_20const__29($7 + 168 | 0, Math_fround(.5), $7 + 160 | 0); + $1 = HEAP32[$7 + 172 >> 2]; + $0 = HEAP32[$7 + 168 >> 2]; + $3 = $0; + $0 = $2; + HEAP32[$0 + 84 >> 2] = $3; + HEAP32[$0 + 88 >> 2] = $1; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($7 + 152 | 0, $7 + 268 | 0, $0 + 84 | 0); + $3 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$7 + 320 >> 2], HEAPU8[HEAP32[$7 + 324 >> 2] + 6 | 0]); + $1 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + HEAP32[$7 + 144 >> 2] = $1; + HEAP32[$7 + 148 >> 2] = $0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($7 + 136 | 0, $7 + 284 | 0, $7 + 144 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($7 + 124 | 0, $7 + 136 | 0, $7 + 152 | 0); + wasm2js_i32$0 = $7, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($7 + 124 | 0, $7 + 176 | 0), + HEAPF32[wasm2js_i32$0 + 132 >> 2] = wasm2js_f32$0; + if (HEAPF32[$7 + 132 >> 2] < Math_fround(0)) { + b2Vec2__operator__28_29_20const($7 + 116 | 0, $2 + 92 | 0); + $1 = HEAP32[$7 + 120 >> 2]; + $0 = HEAP32[$7 + 116 >> 2]; + $3 = $0; + $0 = $2; + HEAP32[$0 + 92 >> 2] = $3; + HEAP32[$0 + 96 >> 2] = $1; + HEAPF32[$7 + 132 >> 2] = -HEAPF32[$7 + 132 >> 2]; + } + HEAPF32[$7 + 332 >> 2] = HEAPF32[$7 + 132 >> 2]; + break label$3; + } + HEAP32[$2 + 80 >> 2] = 1; + $3 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$2 >> 2], HEAPU8[HEAP32[$7 + 324 >> 2] + 6 | 0]); + $1 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + HEAP32[$7 + 104 >> 2] = $1; + HEAP32[$7 + 108 >> 2] = $0; + $3 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$2 >> 2], HEAPU8[HEAP32[$7 + 324 >> 2] + 7 | 0]); + $0 = HEAP32[$3 >> 2]; + $1 = HEAP32[$3 + 4 >> 2]; + HEAP32[$7 + 96 >> 2] = $0; + HEAP32[$7 + 100 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($7 + 80 | 0, $7 + 96 | 0, $7 + 104 | 0); + b2Cross_28b2Vec2_20const__2c_20float_29($7 + 88 | 0, $7 + 80 | 0, Math_fround(1)); + $0 = HEAP32[$7 + 92 >> 2]; + $1 = HEAP32[$7 + 88 >> 2]; + $3 = $1; + $1 = $2; + HEAP32[$1 + 92 >> 2] = $3; + HEAP32[$1 + 96 >> 2] = $0; + b2Vec2__Normalize_28_29($1 + 92 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($7 + 72 | 0, $7 + 292 | 0, $1 + 92 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($7 + 56 | 0, $7 + 104 | 0, $7 + 96 | 0); + operator__28float_2c_20b2Vec2_20const__29($7 - -64 | 0, Math_fround(.5), $7 + 56 | 0); + $1 = HEAP32[$7 + 68 >> 2]; + $0 = HEAP32[$7 + 64 >> 2]; + $3 = $0; + $0 = $2; + HEAP32[$0 + 84 >> 2] = $3; + HEAP32[$0 + 88 >> 2] = $1; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($7 + 48 | 0, $7 + 284 | 0, $0 + 84 | 0); + $3 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$0 + 4 >> 2], HEAPU8[HEAP32[$7 + 324 >> 2] + 9 | 0]); + $1 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + HEAP32[$7 + 40 >> 2] = $1; + HEAP32[$7 + 44 >> 2] = $0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($7 + 32 | 0, $7 + 268 | 0, $7 + 40 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($7 + 20 | 0, $7 + 32 | 0, $7 + 48 | 0); + wasm2js_i32$0 = $7, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($7 + 20 | 0, $7 + 72 | 0), + HEAPF32[wasm2js_i32$0 + 28 >> 2] = wasm2js_f32$0; + if (HEAPF32[$7 + 28 >> 2] < Math_fround(0)) { + b2Vec2__operator__28_29_20const($7 + 12 | 0, $2 + 92 | 0); + $1 = HEAP32[$7 + 16 >> 2]; + $0 = HEAP32[$7 + 12 >> 2]; + $3 = $0; + $0 = $2; + HEAP32[$0 + 92 >> 2] = $3; + HEAP32[$0 + 96 >> 2] = $1; + HEAPF32[$7 + 28 >> 2] = -HEAPF32[$7 + 28 >> 2]; + } + HEAPF32[$7 + 332 >> 2] = HEAPF32[$7 + 28 >> 2]; + } + __stack_pointer = $7 + 336 | 0; + return HEAPF32[$7 + 332 >> 2]; +} + +function b2WeldJoint__SolvePositionConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 320 | 0; + __stack_pointer = $2; + HEAP32[$2 + 316 >> 2] = $0; + HEAP32[$2 + 312 >> 2] = $1; + $3 = HEAP32[$2 + 316 >> 2]; + $4 = HEAP32[HEAP32[$2 + 312 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 116 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 304 >> 2] = $0; + HEAP32[$2 + 308 >> 2] = $1; + HEAPF32[$2 + 300 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 312 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 116 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 312 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 288 >> 2] = $1; + HEAP32[$2 + 292 >> 2] = $0; + HEAPF32[$2 + 284 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 312 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 276 | 0, HEAPF32[$2 + 300 >> 2]); + b2Rot__b2Rot_28float_29($2 + 268 | 0, HEAPF32[$2 + 284 >> 2]); + HEAPF32[$2 + 264 >> 2] = HEAPF32[$3 + 156 >> 2]; + HEAPF32[$2 + 260 >> 2] = HEAPF32[$3 + 160 >> 2]; + HEAPF32[$2 + 256 >> 2] = HEAPF32[$3 + 164 >> 2]; + HEAPF32[$2 + 252 >> 2] = HEAPF32[$3 + 168 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 236 | 0, $3 + 80 | 0, $3 + 140 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 244 | 0, $2 + 276 | 0, $2 + 236 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 220 | 0, $3 + 88 | 0, $3 + 148 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 228 | 0, $2 + 268 | 0, $2 + 220 | 0); + b2Mat33__b2Mat33_28_29($2 + 176 | 0); + HEAPF32[$2 + 176 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 232 >> 2] * HEAPF32[$2 + 232 >> 2]) * HEAPF32[$2 + 252 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 248 >> 2] * HEAPF32[$2 + 248 >> 2]) * HEAPF32[$2 + 256 >> 2]) + Math_fround(HEAPF32[$2 + 264 >> 2] + HEAPF32[$2 + 260 >> 2])); + HEAPF32[$2 + 188 >> 2] = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 248 >> 2]) * HEAPF32[$2 + 244 >> 2]) * HEAPF32[$2 + 256 >> 2]) - Math_fround(Math_fround(HEAPF32[$2 + 232 >> 2] * HEAPF32[$2 + 228 >> 2]) * HEAPF32[$2 + 252 >> 2]); + HEAPF32[$2 + 200 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 248 >> 2]) * HEAPF32[$2 + 256 >> 2]) - Math_fround(HEAPF32[$2 + 232 >> 2] * HEAPF32[$2 + 252 >> 2]); + HEAPF32[$2 + 180 >> 2] = HEAPF32[$2 + 188 >> 2]; + HEAPF32[$2 + 192 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 228 >> 2] * HEAPF32[$2 + 228 >> 2]) * HEAPF32[$2 + 252 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 244 >> 2] * HEAPF32[$2 + 244 >> 2]) * HEAPF32[$2 + 256 >> 2]) + Math_fround(HEAPF32[$2 + 264 >> 2] + HEAPF32[$2 + 260 >> 2])); + HEAPF32[$2 + 204 >> 2] = Math_fround(HEAPF32[$2 + 244 >> 2] * HEAPF32[$2 + 256 >> 2]) + Math_fround(HEAPF32[$2 + 228 >> 2] * HEAPF32[$2 + 252 >> 2]); + HEAPF32[$2 + 184 >> 2] = HEAPF32[$2 + 200 >> 2]; + HEAPF32[$2 + 196 >> 2] = HEAPF32[$2 + 204 >> 2]; + HEAPF32[$2 + 208 >> 2] = HEAPF32[$2 + 256 >> 2] + HEAPF32[$2 + 252 >> 2]; + label$1: { + if (HEAPF32[$3 + 68 >> 2] > Math_fround(0)) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 152 | 0, $2 + 288 | 0, $2 + 228 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 160 | 0, $2 + 152 | 0, $2 + 304 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 168 | 0, $2 + 160 | 0, $2 + 244 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Vec2__Length_28_29_20const($2 + 168 | 0), + HEAPF32[wasm2js_i32$0 + 216 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 212 >> 2] = 0; + b2Mat33__Solve22_28b2Vec2_20const__29_20const($2 + 136 | 0, $2 + 176 | 0, $2 + 168 | 0); + b2Vec2__operator__28_29_20const($2 + 144 | 0, $2 + 136 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 128 | 0, HEAPF32[$2 + 264 >> 2], $2 + 144 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 304 | 0, $2 + 128 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 256 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 244 | 0, $2 + 144 | 0)) + HEAPF32[$2 + 300 >> 2]), + HEAPF32[wasm2js_i32$0 + 300 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 120 | 0, HEAPF32[$2 + 260 >> 2], $2 + 144 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 288 | 0, $2 + 120 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$2 + 252 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 228 | 0, $2 + 144 | 0)) + HEAPF32[$2 + 284 >> 2]), + HEAPF32[wasm2js_i32$0 + 284 >> 2] = wasm2js_f32$0; + break label$1; + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 96 | 0, $2 + 288 | 0, $2 + 228 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 104 | 0, $2 + 96 | 0, $2 + 304 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 112 | 0, $2 + 104 | 0, $2 + 244 | 0); + HEAPF32[$2 + 92 >> 2] = Math_fround(HEAPF32[$2 + 284 >> 2] - HEAPF32[$2 + 300 >> 2]) - HEAPF32[$3 + 96 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Vec2__Length_28_29_20const($2 + 112 | 0), + HEAPF32[wasm2js_i32$0 + 216 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Abs_float__28float_29(HEAPF32[$2 + 92 >> 2]), + HEAPF32[wasm2js_i32$0 + 212 >> 2] = wasm2js_f32$0; + b2Vec3__b2Vec3_28float_2c_20float_2c_20float_29($2 + 80 | 0, HEAPF32[$2 + 112 >> 2], HEAPF32[$2 + 116 >> 2], HEAPF32[$2 + 92 >> 2]); + b2Vec3__b2Vec3_28_29($2 - -64 | 0); + label$3: { + if (HEAPF32[$2 + 208 >> 2] > Math_fround(0)) { + b2Mat33__Solve33_28b2Vec3_20const__29_20const($2 + 40 | 0, $2 + 176 | 0, $2 + 80 | 0); + b2Vec3__operator__28_29_20const($2 + 52 | 0, $2 + 40 | 0); + HEAP32[$2 + 72 >> 2] = HEAP32[$2 + 60 >> 2]; + $1 = HEAP32[$2 + 56 >> 2]; + $0 = HEAP32[$2 + 52 >> 2]; + HEAP32[$2 + 64 >> 2] = $0; + HEAP32[$2 + 68 >> 2] = $1; + break label$3; + } + b2Mat33__Solve22_28b2Vec2_20const__29_20const($2 + 24 | 0, $2 + 176 | 0, $2 + 112 | 0); + b2Vec2__operator__28_29_20const($2 + 32 | 0, $2 + 24 | 0); + b2Vec3__Set_28float_2c_20float_2c_20float_29($2 - -64 | 0, HEAPF32[$2 + 32 >> 2], HEAPF32[$2 + 36 >> 2], Math_fround(0)); + } + b2Vec2__b2Vec2_28float_2c_20float_29($2 + 16 | 0, HEAPF32[$2 + 64 >> 2], HEAPF32[$2 + 68 >> 2]); + operator__28float_2c_20b2Vec2_20const__29($2 + 8 | 0, HEAPF32[$2 + 264 >> 2], $2 + 16 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 304 | 0, $2 + 8 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 256 >> 2]) * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 244 | 0, $2 + 16 | 0) + HEAPF32[$2 + 72 >> 2])) + HEAPF32[$2 + 300 >> 2]), + HEAPF32[wasm2js_i32$0 + 300 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2, HEAPF32[$2 + 260 >> 2], $2 + 16 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 288 | 0, $2); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$2 + 252 >> 2] * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 228 | 0, $2 + 16 | 0) + HEAPF32[$2 + 72 >> 2])) + HEAPF32[$2 + 284 >> 2]), + HEAPF32[wasm2js_i32$0 + 284 >> 2] = wasm2js_f32$0; + } + $0 = HEAP32[$2 + 308 >> 2]; + $1 = HEAP32[$2 + 304 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 312 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 116 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 312 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 116 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 300 >> 2]; + $1 = HEAP32[$2 + 292 >> 2]; + $0 = HEAP32[$2 + 288 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 312 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 312 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 284 >> 2]; + __stack_pointer = $2 + 320 | 0; + $5 = HEAPF32[$2 + 216 >> 2] <= Math_fround(.004999999888241291) ? HEAPF32[$2 + 212 >> 2] <= Math_fround(.03490658849477768) : $5; + return $5 | 0; +} + +function b2World__Solve_28b2TimeStep_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 176 | 0; + __stack_pointer = $2; + HEAP32[$2 + 172 >> 2] = $0; + HEAP32[$2 + 168 >> 2] = $1; + $0 = HEAP32[$2 + 172 >> 2]; + HEAPF32[$0 + 103008 >> 2] = 0; + HEAPF32[$0 + 103012 >> 2] = 0; + HEAPF32[$0 + 103016 >> 2] = 0; + b2Island__b2Island_28int_2c_20int_2c_20int_2c_20b2StackAllocator__2c_20b2ContactListener__29($2 + 116 | 0, HEAP32[$0 + 102956 >> 2], HEAP32[$0 + 102932 >> 2], HEAP32[$0 + 102960 >> 2], $0 + 68 | 0, HEAP32[$0 + 102940 >> 2]); + HEAP32[$2 + 112 >> 2] = HEAP32[$0 + 102948 >> 2]; + while (1) { + if (HEAP32[$2 + 112 >> 2]) { + $1 = HEAP32[$2 + 112 >> 2]; + HEAP16[$1 + 4 >> 1] = HEAPU16[$1 + 4 >> 1] & -2; + HEAP32[$2 + 112 >> 2] = HEAP32[HEAP32[$2 + 112 >> 2] + 96 >> 2]; + continue; + } + break; + } + HEAP32[$2 + 108 >> 2] = HEAP32[$0 + 102928 >> 2]; + while (1) { + if (HEAP32[$2 + 108 >> 2]) { + $1 = HEAP32[$2 + 108 >> 2]; + HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] & -2; + HEAP32[$2 + 108 >> 2] = HEAP32[HEAP32[$2 + 108 >> 2] + 12 >> 2]; + continue; + } + break; + } + HEAP32[$2 + 104 >> 2] = HEAP32[$0 + 102952 >> 2]; + while (1) { + if (HEAP32[$2 + 104 >> 2]) { + HEAP8[HEAP32[$2 + 104 >> 2] + 60 | 0] = 0; + HEAP32[$2 + 104 >> 2] = HEAP32[HEAP32[$2 + 104 >> 2] + 12 >> 2]; + continue; + } + break; + } + HEAP32[$2 + 100 >> 2] = HEAP32[$0 + 102956 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2StackAllocator__Allocate_28int_29($0 + 68 | 0, HEAP32[$2 + 100 >> 2] << 2), + HEAP32[wasm2js_i32$0 + 96 >> 2] = wasm2js_i32$1; + HEAP32[$2 + 92 >> 2] = HEAP32[$0 + 102948 >> 2]; + while (1) { + if (HEAP32[$2 + 92 >> 2]) { + label$9: { + if (HEAP16[HEAP32[$2 + 92 >> 2] + 4 >> 1] & 1) { + break label$9; + } + if (!(b2Body__IsAwake_28_29_20const(HEAP32[$2 + 92 >> 2]) & 1)) { + break label$9; + } + if (!(b2Body__IsEnabled_28_29_20const(HEAP32[$2 + 92 >> 2]) & 1)) { + break label$9; + } + if (!b2Body__GetType_28_29_20const(HEAP32[$2 + 92 >> 2])) { + break label$9; + } + b2Island__Clear_28_29($2 + 116 | 0); + HEAP32[$2 + 88 >> 2] = 0; + $3 = HEAP32[$2 + 92 >> 2]; + $4 = HEAP32[$2 + 96 >> 2]; + $1 = HEAP32[$2 + 88 >> 2]; + HEAP32[$2 + 88 >> 2] = $1 + 1; + HEAP32[($1 << 2) + $4 >> 2] = $3; + $1 = HEAP32[$2 + 92 >> 2]; + HEAP16[$1 + 4 >> 1] = HEAPU16[$1 + 4 >> 1] | 1; + while (1) { + if (HEAP32[$2 + 88 >> 2] > 0) { + $3 = HEAP32[$2 + 96 >> 2]; + $1 = HEAP32[$2 + 88 >> 2] - 1 | 0; + HEAP32[$2 + 88 >> 2] = $1; + HEAP32[$2 + 84 >> 2] = HEAP32[($1 << 2) + $3 >> 2]; + if (!(b2Body__IsEnabled_28_29_20const(HEAP32[$2 + 84 >> 2]) & 1)) { + __assert_fail(8720, 6161, 453, 8692); + wasm2js_trap(); + } + b2Island__Add_28b2Body__29($2 + 116 | 0, HEAP32[$2 + 84 >> 2]); + if (!b2Body__GetType_28_29_20const(HEAP32[$2 + 84 >> 2])) { + continue; + } + $1 = HEAP32[$2 + 84 >> 2]; + HEAP16[$1 + 4 >> 1] = HEAPU16[$1 + 4 >> 1] | 2; + HEAP32[$2 + 80 >> 2] = HEAP32[HEAP32[$2 + 84 >> 2] + 112 >> 2]; + while (1) { + if (HEAP32[$2 + 80 >> 2]) { + HEAP32[$2 + 76 >> 2] = HEAP32[HEAP32[$2 + 80 >> 2] + 4 >> 2]; + label$16: { + if (HEAP32[HEAP32[$2 + 76 >> 2] + 4 >> 2] & 1) { + break label$16; + } + if (!(b2Contact__IsEnabled_28_29_20const(HEAP32[$2 + 76 >> 2]) & 1)) { + break label$16; + } + if (!(b2Contact__IsTouching_28_29_20const(HEAP32[$2 + 76 >> 2]) & 1)) { + break label$16; + } + HEAP8[$2 + 75 | 0] = HEAP8[HEAP32[HEAP32[$2 + 76 >> 2] + 48 >> 2] + 38 | 0] & 1; + HEAP8[$2 + 74 | 0] = HEAP8[HEAP32[HEAP32[$2 + 76 >> 2] + 52 >> 2] + 38 | 0] & 1; + if (HEAP8[$2 + 75 | 0] & 1 | HEAP8[$2 + 74 | 0] & 1) { + break label$16; + } + b2Island__Add_28b2Contact__29($2 + 116 | 0, HEAP32[$2 + 76 >> 2]); + $1 = HEAP32[$2 + 76 >> 2]; + HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] | 1; + HEAP32[$2 + 68 >> 2] = HEAP32[HEAP32[$2 + 80 >> 2] >> 2]; + if (HEAP16[HEAP32[$2 + 68 >> 2] + 4 >> 1] & 1) { + break label$16; + } + if (HEAP32[$2 + 88 >> 2] >= HEAP32[$2 + 100 >> 2]) { + __assert_fail(8656, 6161, 503, 8692); + wasm2js_trap(); + } + $3 = HEAP32[$2 + 68 >> 2]; + $4 = HEAP32[$2 + 96 >> 2]; + $1 = HEAP32[$2 + 88 >> 2]; + HEAP32[$2 + 88 >> 2] = $1 + 1; + HEAP32[($1 << 2) + $4 >> 2] = $3; + $1 = HEAP32[$2 + 68 >> 2]; + HEAP16[$1 + 4 >> 1] = HEAPU16[$1 + 4 >> 1] | 1; + } + HEAP32[$2 + 80 >> 2] = HEAP32[HEAP32[$2 + 80 >> 2] + 12 >> 2]; + continue; + } + break; + } + HEAP32[$2 + 64 >> 2] = HEAP32[HEAP32[$2 + 84 >> 2] + 108 >> 2]; + while (1) { + if (HEAP32[$2 + 64 >> 2]) { + label$22: { + if (HEAP8[HEAP32[HEAP32[$2 + 64 >> 2] + 4 >> 2] + 60 | 0] & 1) { + break label$22; + } + HEAP32[$2 + 60 >> 2] = HEAP32[HEAP32[$2 + 64 >> 2] >> 2]; + if (!(b2Body__IsEnabled_28_29_20const(HEAP32[$2 + 60 >> 2]) & 1)) { + break label$22; + } + b2Island__Add_28b2Joint__29($2 + 116 | 0, HEAP32[HEAP32[$2 + 64 >> 2] + 4 >> 2]); + HEAP8[HEAP32[HEAP32[$2 + 64 >> 2] + 4 >> 2] + 60 | 0] = 1; + if (HEAP16[HEAP32[$2 + 60 >> 2] + 4 >> 1] & 1) { + break label$22; + } + if (HEAP32[$2 + 88 >> 2] >= HEAP32[$2 + 100 >> 2]) { + __assert_fail(8656, 6161, 532, 8692); + wasm2js_trap(); + } + $3 = HEAP32[$2 + 60 >> 2]; + $4 = HEAP32[$2 + 96 >> 2]; + $1 = HEAP32[$2 + 88 >> 2]; + HEAP32[$2 + 88 >> 2] = $1 + 1; + HEAP32[($1 << 2) + $4 >> 2] = $3; + $1 = HEAP32[$2 + 60 >> 2]; + HEAP16[$1 + 4 >> 1] = HEAPU16[$1 + 4 >> 1] | 1; + } + HEAP32[$2 + 64 >> 2] = HEAP32[HEAP32[$2 + 64 >> 2] + 12 >> 2]; + continue; + } + break; + } + continue; + } + break; + } + b2Island__Solve_28b2Profile__2c_20b2TimeStep_20const__2c_20b2Vec2_20const__2c_20bool_29($2 + 116 | 0, $2 + 28 | 0, HEAP32[$2 + 168 >> 2], $0 + 102964 | 0, HEAP8[$0 + 102972 | 0] & 1); + HEAPF32[$0 + 103008 >> 2] = HEAPF32[$0 + 103008 >> 2] + HEAPF32[$2 + 40 >> 2]; + HEAPF32[$0 + 103012 >> 2] = HEAPF32[$0 + 103012 >> 2] + HEAPF32[$2 + 44 >> 2]; + HEAPF32[$0 + 103016 >> 2] = HEAPF32[$0 + 103016 >> 2] + HEAPF32[$2 + 48 >> 2]; + HEAP32[$2 + 24 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 24 >> 2] < HEAP32[$2 + 144 >> 2]) { + HEAP32[$2 + 20 >> 2] = HEAP32[HEAP32[$2 + 124 >> 2] + (HEAP32[$2 + 24 >> 2] << 2) >> 2]; + if (!b2Body__GetType_28_29_20const(HEAP32[$2 + 20 >> 2])) { + $1 = HEAP32[$2 + 20 >> 2]; + HEAP16[$1 + 4 >> 1] = HEAPU16[$1 + 4 >> 1] & -2; + } + HEAP32[$2 + 24 >> 2] = HEAP32[$2 + 24 >> 2] + 1; + continue; + } + break; + } + } + HEAP32[$2 + 92 >> 2] = HEAP32[HEAP32[$2 + 92 >> 2] + 96 >> 2]; + continue; + } + break; + } + b2StackAllocator__Free_28void__29($0 + 68 | 0, HEAP32[$2 + 96 >> 2]); + b2Timer__b2Timer_28_29($2 + 19 | 0); + HEAP32[$2 + 12 >> 2] = HEAP32[$0 + 102948 >> 2]; + while (1) { + if (HEAP32[$2 + 12 >> 2]) { + label$29: { + if (!(HEAP16[HEAP32[$2 + 12 >> 2] + 4 >> 1] & 1)) { + break label$29; + } + if (!b2Body__GetType_28_29_20const(HEAP32[$2 + 12 >> 2])) { + break label$29; + } + b2Body__SynchronizeFixtures_28_29(HEAP32[$2 + 12 >> 2]); + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Body__GetNext_28_29(HEAP32[$2 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + continue; + } + break; + } + b2ContactManager__FindNewContacts_28_29($0 + 102868 | 0); + wasm2js_i32$0 = $0, wasm2js_f32$0 = b2Timer__GetMilliseconds_28_29_20const($2 + 19 | 0), + HEAPF32[wasm2js_i32$0 + 103020 >> 2] = wasm2js_f32$0; + b2Island___b2Island_28_29($2 + 116 | 0); + __stack_pointer = $2 + 176 | 0; +} + +function b2WeldJoint__InitVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, $5 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 192 | 0; + __stack_pointer = $2; + HEAP32[$2 + 188 >> 2] = $0; + HEAP32[$2 + 184 >> 2] = $1; + $0 = HEAP32[$2 + 188 >> 2]; + HEAP32[$0 + 116 >> 2] = HEAP32[HEAP32[$0 + 48 >> 2] + 8 >> 2]; + HEAP32[$0 + 120 >> 2] = HEAP32[HEAP32[$0 + 52 >> 2] + 8 >> 2]; + $4 = HEAP32[$0 + 48 >> 2]; + $3 = HEAP32[$4 + 28 >> 2]; + $1 = HEAP32[$4 + 32 >> 2]; + HEAP32[$0 + 140 >> 2] = $3; + HEAP32[$0 + 144 >> 2] = $1; + $4 = HEAP32[$0 + 52 >> 2]; + $1 = HEAP32[$4 + 28 >> 2]; + $3 = HEAP32[$4 + 32 >> 2]; + HEAP32[$0 + 148 >> 2] = $1; + HEAP32[$0 + 152 >> 2] = $3; + HEAPF32[$0 + 156 >> 2] = HEAPF32[HEAP32[$0 + 48 >> 2] + 120 >> 2]; + HEAPF32[$0 + 160 >> 2] = HEAPF32[HEAP32[$0 + 52 >> 2] + 120 >> 2]; + HEAPF32[$0 + 164 >> 2] = HEAPF32[HEAP32[$0 + 48 >> 2] + 128 >> 2]; + HEAPF32[$0 + 168 >> 2] = HEAPF32[HEAP32[$0 + 52 >> 2] + 128 >> 2]; + HEAPF32[$2 + 180 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$0 + 116 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 116 >> 2], 12) | 0; + $3 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 168 >> 2] = $3; + HEAP32[$2 + 172 >> 2] = $1; + HEAPF32[$2 + 164 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 116 >> 2], 12) | 0) + 8 >> 2]; + HEAPF32[$2 + 160 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$0 + 120 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 120 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $3 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 152 >> 2] = $1; + HEAP32[$2 + 156 >> 2] = $3; + HEAPF32[$2 + 148 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 120 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 140 | 0, HEAPF32[$2 + 180 >> 2]); + b2Rot__b2Rot_28float_29($2 + 132 | 0, HEAPF32[$2 + 160 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 116 | 0, $0 + 80 | 0, $0 + 140 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 124 | 0, $2 + 140 | 0, $2 + 116 | 0); + $1 = HEAP32[$2 + 128 >> 2]; + $3 = HEAP32[$2 + 124 >> 2]; + HEAP32[$0 + 124 >> 2] = $3; + HEAP32[$0 + 128 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 100 | 0, $0 + 88 | 0, $0 + 148 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 108 | 0, $2 + 132 | 0, $2 + 100 | 0); + $3 = HEAP32[$2 + 112 >> 2]; + $1 = HEAP32[$2 + 108 >> 2]; + HEAP32[$0 + 132 >> 2] = $1; + HEAP32[$0 + 136 >> 2] = $3; + HEAPF32[$2 + 96 >> 2] = HEAPF32[$0 + 156 >> 2]; + HEAPF32[$2 + 92 >> 2] = HEAPF32[$0 + 160 >> 2]; + HEAPF32[$2 + 88 >> 2] = HEAPF32[$0 + 164 >> 2]; + HEAPF32[$2 + 84 >> 2] = HEAPF32[$0 + 168 >> 2]; + b2Mat33__b2Mat33_28_29($2 + 48 | 0); + HEAPF32[$2 + 48 >> 2] = Math_fround(Math_fround(HEAPF32[$0 + 136 >> 2] * HEAPF32[$0 + 136 >> 2]) * HEAPF32[$2 + 84 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$0 + 128 >> 2] * HEAPF32[$0 + 128 >> 2]) * HEAPF32[$2 + 88 >> 2]) + Math_fround(HEAPF32[$2 + 96 >> 2] + HEAPF32[$2 + 92 >> 2])); + HEAPF32[$2 + 60 >> 2] = Math_fround(Math_fround(Math_fround(-HEAPF32[$0 + 128 >> 2]) * HEAPF32[$0 + 124 >> 2]) * HEAPF32[$2 + 88 >> 2]) - Math_fround(Math_fround(HEAPF32[$0 + 136 >> 2] * HEAPF32[$0 + 132 >> 2]) * HEAPF32[$2 + 84 >> 2]); + HEAPF32[$2 + 72 >> 2] = Math_fround(Math_fround(-HEAPF32[$0 + 128 >> 2]) * HEAPF32[$2 + 88 >> 2]) - Math_fround(HEAPF32[$0 + 136 >> 2] * HEAPF32[$2 + 84 >> 2]); + HEAPF32[$2 + 52 >> 2] = HEAPF32[$2 + 60 >> 2]; + HEAPF32[$2 + 64 >> 2] = Math_fround(Math_fround(HEAPF32[$0 + 132 >> 2] * HEAPF32[$0 + 132 >> 2]) * HEAPF32[$2 + 84 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$0 + 124 >> 2] * HEAPF32[$0 + 124 >> 2]) * HEAPF32[$2 + 88 >> 2]) + Math_fround(HEAPF32[$2 + 96 >> 2] + HEAPF32[$2 + 92 >> 2])); + HEAPF32[$2 + 76 >> 2] = Math_fround(HEAPF32[$0 + 124 >> 2] * HEAPF32[$2 + 88 >> 2]) + Math_fround(HEAPF32[$0 + 132 >> 2] * HEAPF32[$2 + 84 >> 2]); + HEAPF32[$2 + 56 >> 2] = HEAPF32[$2 + 72 >> 2]; + HEAPF32[$2 + 68 >> 2] = HEAPF32[$2 + 76 >> 2]; + HEAPF32[$2 + 80 >> 2] = HEAPF32[$2 + 88 >> 2] + HEAPF32[$2 + 84 >> 2]; + label$1: { + if (HEAPF32[$0 + 68 >> 2] > Math_fround(0)) { + b2Mat33__GetInverse22_28b2Mat33__29_20const($2 + 48 | 0, $0 + 172 | 0); + HEAPF32[$2 + 44 >> 2] = HEAPF32[$2 + 88 >> 2] + HEAPF32[$2 + 84 >> 2]; + HEAPF32[$2 + 40 >> 2] = Math_fround(HEAPF32[$2 + 160 >> 2] - HEAPF32[$2 + 180 >> 2]) - HEAPF32[$0 + 96 >> 2]; + HEAPF32[$2 + 36 >> 2] = HEAPF32[$0 + 72 >> 2]; + HEAPF32[$2 + 32 >> 2] = HEAPF32[$0 + 68 >> 2]; + HEAPF32[$2 + 28 >> 2] = HEAPF32[HEAP32[$2 + 184 >> 2] >> 2]; + HEAPF32[$0 + 100 >> 2] = HEAPF32[$2 + 28 >> 2] * Math_fround(Math_fround(HEAPF32[$2 + 28 >> 2] * HEAPF32[$2 + 32 >> 2]) + HEAPF32[$2 + 36 >> 2]); + if (HEAPF32[$0 + 100 >> 2] != Math_fround(0)) { + $5 = Math_fround(Math_fround(1) / HEAPF32[$0 + 100 >> 2]); + } else { + $5 = Math_fround(0); + } + HEAPF32[$0 + 100 >> 2] = $5; + HEAPF32[$0 + 76 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 40 >> 2] * HEAPF32[$2 + 28 >> 2]) * HEAPF32[$2 + 32 >> 2]) * HEAPF32[$0 + 100 >> 2]; + HEAPF32[$2 + 44 >> 2] = HEAPF32[$2 + 44 >> 2] + HEAPF32[$0 + 100 >> 2]; + if (HEAPF32[$2 + 44 >> 2] != Math_fround(0)) { + $5 = Math_fround(Math_fround(1) / HEAPF32[$2 + 44 >> 2]); + } else { + $5 = Math_fround(0); + } + HEAPF32[$0 + 204 >> 2] = $5; + break label$1; + } + label$7: { + if (HEAPF32[$2 + 80 >> 2] == Math_fround(0)) { + b2Mat33__GetInverse22_28b2Mat33__29_20const($2 + 48 | 0, $0 + 172 | 0); + break label$7; + } + b2Mat33__GetSymInverse33_28b2Mat33__29_20const($2 + 48 | 0, $0 + 172 | 0); + } + HEAPF32[$0 + 100 >> 2] = 0; + HEAPF32[$0 + 76 >> 2] = 0; + } + label$9: { + if (HEAP8[HEAP32[$2 + 184 >> 2] + 20 | 0] & 1) { + b2Vec3__operator___28float_29($0 + 104 | 0, HEAPF32[HEAP32[$2 + 184 >> 2] + 8 >> 2]); + b2Vec2__b2Vec2_28float_2c_20float_29($2 + 20 | 0, HEAPF32[$0 + 104 >> 2], HEAPF32[$0 + 108 >> 2]); + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$2 + 96 >> 2], $2 + 20 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 168 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 88 >> 2]) * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($0 + 124 | 0, $2 + 20 | 0) + HEAPF32[$0 + 112 >> 2])) + HEAPF32[$2 + 164 >> 2]), + HEAPF32[wasm2js_i32$0 + 164 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 4 | 0, HEAPF32[$2 + 92 >> 2], $2 + 20 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 152 | 0, $2 + 4 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$2 + 84 >> 2] * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($0 + 132 | 0, $2 + 20 | 0) + HEAPF32[$0 + 112 >> 2])) + HEAPF32[$2 + 148 >> 2]), + HEAPF32[wasm2js_i32$0 + 148 >> 2] = wasm2js_f32$0; + break label$9; + } + b2Vec3__SetZero_28_29($0 + 104 | 0); + } + $1 = HEAP32[$2 + 172 >> 2]; + $3 = HEAP32[$2 + 168 >> 2]; + $4 = $3; + $3 = HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 116 >> 2], 12) | 0; + HEAP32[$3 >> 2] = $4; + HEAP32[$3 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 116 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 164 >> 2]; + $3 = HEAP32[$2 + 156 >> 2]; + $1 = HEAP32[$2 + 152 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 120 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $3; + HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 120 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 148 >> 2]; + __stack_pointer = $2 + 192 | 0; +} + +function b2GearJoint__b2GearJoint_28b2GearJointDef_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 240 | 0; + __stack_pointer = $2; + HEAP32[$2 + 232 >> 2] = $0; + HEAP32[$2 + 228 >> 2] = $1; + $1 = HEAP32[$2 + 232 >> 2]; + HEAP32[$2 + 236 >> 2] = $1; + b2Joint__b2Joint_28b2JointDef_20const__29($1, HEAP32[$2 + 228 >> 2]); + HEAP32[$1 >> 2] = 18656; + b2Vec2__b2Vec2_28_29($1 + 92 | 0); + b2Vec2__b2Vec2_28_29($1 + 100 | 0); + b2Vec2__b2Vec2_28_29($1 + 108 | 0); + b2Vec2__b2Vec2_28_29($1 + 116 | 0); + b2Vec2__b2Vec2_28_29($1 + 124 | 0); + b2Vec2__b2Vec2_28_29($1 + 132 | 0); + b2Vec2__b2Vec2_28_29($1 + 176 | 0); + b2Vec2__b2Vec2_28_29($1 + 184 | 0); + b2Vec2__b2Vec2_28_29($1 + 192 | 0); + b2Vec2__b2Vec2_28_29($1 + 200 | 0); + b2Vec2__b2Vec2_28_29($1 + 240 | 0); + b2Vec2__b2Vec2_28_29($1 + 248 | 0); + HEAP32[$1 + 68 >> 2] = HEAP32[HEAP32[$2 + 228 >> 2] + 20 >> 2]; + HEAP32[$1 + 72 >> 2] = HEAP32[HEAP32[$2 + 228 >> 2] + 24 >> 2]; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Joint__GetType_28_29_20const(HEAP32[$1 + 68 >> 2]), + HEAP32[wasm2js_i32$0 + 76 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Joint__GetType_28_29_20const(HEAP32[$1 + 72 >> 2]), + HEAP32[wasm2js_i32$0 + 80 >> 2] = wasm2js_i32$1; + if (!(HEAP32[$1 + 76 >> 2] == 1 | HEAP32[$1 + 76 >> 2] == 2)) { + __assert_fail(2703, 4295, 57, 2549); + wasm2js_trap(); + } + if (!(HEAP32[$1 + 80 >> 2] == 1 | HEAP32[$1 + 80 >> 2] == 2)) { + __assert_fail(2645, 4295, 58, 2549); + wasm2js_trap(); + } + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Joint__GetBodyA_28_29(HEAP32[$1 + 68 >> 2]), + HEAP32[wasm2js_i32$0 + 84 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Joint__GetBodyB_28_29(HEAP32[$1 + 68 >> 2]), + HEAP32[wasm2js_i32$0 + 48 >> 2] = wasm2js_i32$1; + $3 = HEAP32[$1 + 48 >> 2]; + $4 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$2 + 208 >> 2] = $4; + HEAP32[$2 + 212 >> 2] = $0; + $4 = HEAP32[$3 + 16 >> 2]; + $0 = HEAP32[$3 + 12 >> 2]; + HEAP32[$2 + 200 >> 2] = $0; + HEAP32[$2 + 204 >> 2] = $4; + HEAPF32[$2 + 196 >> 2] = HEAPF32[HEAP32[$1 + 48 >> 2] + 56 >> 2]; + $3 = HEAP32[$1 + 84 >> 2]; + $4 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$2 + 184 >> 2] = $4; + HEAP32[$2 + 188 >> 2] = $0; + $4 = HEAP32[$3 + 16 >> 2]; + $0 = HEAP32[$3 + 12 >> 2]; + HEAP32[$2 + 176 >> 2] = $0; + HEAP32[$2 + 180 >> 2] = $4; + HEAPF32[$2 + 172 >> 2] = HEAPF32[HEAP32[$1 + 84 >> 2] + 56 >> 2]; + label$3: { + if (HEAP32[$1 + 76 >> 2] == 1) { + HEAP32[$2 + 168 >> 2] = HEAP32[HEAP32[$2 + 228 >> 2] + 20 >> 2]; + $3 = HEAP32[$2 + 168 >> 2]; + $4 = HEAP32[$3 + 68 >> 2]; + $0 = HEAP32[$3 + 72 >> 2]; + HEAP32[$1 + 108 >> 2] = $4; + HEAP32[$1 + 112 >> 2] = $0; + $3 = HEAP32[$2 + 168 >> 2]; + $0 = HEAP32[$3 + 76 >> 2]; + $4 = HEAP32[$3 + 80 >> 2]; + HEAP32[$1 + 92 >> 2] = $0; + HEAP32[$1 + 96 >> 2] = $4; + HEAPF32[$1 + 140 >> 2] = HEAPF32[HEAP32[$2 + 168 >> 2] + 120 >> 2]; + b2Vec2__SetZero_28_29($1 + 124 | 0); + HEAPF32[$2 + 224 >> 2] = Math_fround(HEAPF32[$2 + 196 >> 2] - HEAPF32[$2 + 172 >> 2]) - HEAPF32[$1 + 140 >> 2]; + $0 = $1; + break label$3; + } + HEAP32[$2 + 164 >> 2] = HEAP32[HEAP32[$2 + 228 >> 2] + 20 >> 2]; + $3 = HEAP32[$2 + 164 >> 2]; + $4 = HEAP32[$3 + 68 >> 2]; + $0 = HEAP32[$3 + 72 >> 2]; + HEAP32[$1 + 108 >> 2] = $4; + HEAP32[$1 + 112 >> 2] = $0; + $3 = HEAP32[$2 + 164 >> 2]; + $0 = HEAP32[$3 + 76 >> 2]; + $4 = HEAP32[$3 + 80 >> 2]; + HEAP32[$1 + 92 >> 2] = $0; + HEAP32[$1 + 96 >> 2] = $4; + HEAPF32[$1 + 140 >> 2] = HEAPF32[HEAP32[$2 + 164 >> 2] + 100 >> 2]; + $3 = HEAP32[$2 + 164 >> 2]; + $4 = HEAP32[$3 + 84 >> 2]; + $0 = HEAP32[$3 + 88 >> 2]; + HEAP32[$1 + 124 >> 2] = $4; + HEAP32[$1 + 128 >> 2] = $0; + $4 = HEAP32[$1 + 112 >> 2]; + $0 = HEAP32[$1 + 108 >> 2]; + HEAP32[$2 + 152 >> 2] = $0; + HEAP32[$2 + 156 >> 2] = $4; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 128 | 0, $2 + 208 | 0, $1 + 92 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 120 | 0, $2 + 200 | 0, $2 + 176 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 136 | 0, $2 + 128 | 0, $2 + 120 | 0); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 144 | 0, $2 + 184 | 0, $2 + 136 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 112 | 0, $2 + 144 | 0, $2 + 152 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 112 | 0, $1 + 124 | 0), + HEAPF32[wasm2js_i32$0 + 224 >> 2] = wasm2js_f32$0; + $0 = $2; + } + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Joint__GetBodyA_28_29(HEAP32[$1 + 72 >> 2]), + HEAP32[wasm2js_i32$0 + 88 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Joint__GetBodyB_28_29(HEAP32[$1 + 72 >> 2]), + HEAP32[wasm2js_i32$0 + 52 >> 2] = wasm2js_i32$1; + $3 = HEAP32[$1 + 52 >> 2]; + $4 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$2 + 104 >> 2] = $4; + HEAP32[$2 + 108 >> 2] = $0; + $4 = HEAP32[$3 + 16 >> 2]; + $0 = HEAP32[$3 + 12 >> 2]; + HEAP32[$2 + 96 >> 2] = $0; + HEAP32[$2 + 100 >> 2] = $4; + HEAPF32[$2 + 92 >> 2] = HEAPF32[HEAP32[$1 + 52 >> 2] + 56 >> 2]; + $3 = HEAP32[$1 + 88 >> 2]; + $4 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$2 + 80 >> 2] = $4; + HEAP32[$2 + 84 >> 2] = $0; + $4 = HEAP32[$3 + 16 >> 2]; + $0 = HEAP32[$3 + 12 >> 2]; + HEAP32[$2 + 72 >> 2] = $0; + HEAP32[$2 + 76 >> 2] = $4; + HEAPF32[$2 + 68 >> 2] = HEAPF32[HEAP32[$1 + 88 >> 2] + 56 >> 2]; + label$5: { + if (HEAP32[$1 + 80 >> 2] == 1) { + HEAP32[$2 + 64 >> 2] = HEAP32[HEAP32[$2 + 228 >> 2] + 24 >> 2]; + $3 = HEAP32[$2 + 64 >> 2]; + $4 = HEAP32[$3 + 68 >> 2]; + $0 = HEAP32[$3 + 72 >> 2]; + HEAP32[$1 + 116 >> 2] = $4; + HEAP32[$1 + 120 >> 2] = $0; + $3 = HEAP32[$2 + 64 >> 2]; + $0 = HEAP32[$3 + 76 >> 2]; + $4 = HEAP32[$3 + 80 >> 2]; + HEAP32[$1 + 100 >> 2] = $0; + HEAP32[$1 + 104 >> 2] = $4; + HEAPF32[$1 + 144 >> 2] = HEAPF32[HEAP32[$2 + 64 >> 2] + 120 >> 2]; + b2Vec2__SetZero_28_29($1 + 132 | 0); + HEAPF32[$2 + 220 >> 2] = Math_fround(HEAPF32[$2 + 92 >> 2] - HEAPF32[$2 + 68 >> 2]) - HEAPF32[$1 + 144 >> 2]; + $0 = $1; + break label$5; + } + HEAP32[$2 + 60 >> 2] = HEAP32[HEAP32[$2 + 228 >> 2] + 24 >> 2]; + $3 = HEAP32[$2 + 60 >> 2]; + $4 = HEAP32[$3 + 68 >> 2]; + $0 = HEAP32[$3 + 72 >> 2]; + HEAP32[$1 + 116 >> 2] = $4; + HEAP32[$1 + 120 >> 2] = $0; + $3 = HEAP32[$2 + 60 >> 2]; + $0 = HEAP32[$3 + 76 >> 2]; + $4 = HEAP32[$3 + 80 >> 2]; + HEAP32[$1 + 100 >> 2] = $0; + HEAP32[$1 + 104 >> 2] = $4; + HEAPF32[$1 + 144 >> 2] = HEAPF32[HEAP32[$2 + 60 >> 2] + 100 >> 2]; + $3 = HEAP32[$2 + 60 >> 2]; + $4 = HEAP32[$3 + 84 >> 2]; + $0 = HEAP32[$3 + 88 >> 2]; + HEAP32[$1 + 132 >> 2] = $4; + HEAP32[$1 + 136 >> 2] = $0; + $4 = HEAP32[$1 + 120 >> 2]; + $0 = HEAP32[$1 + 116 >> 2]; + HEAP32[$2 + 48 >> 2] = $0; + HEAP32[$2 + 52 >> 2] = $4; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 24 | 0, $2 + 104 | 0, $1 + 100 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 16 | 0, $2 + 96 | 0, $2 + 72 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 32 | 0, $2 + 24 | 0, $2 + 16 | 0); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 40 | 0, $2 + 80 | 0, $2 + 32 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 8 | 0, $2 + 40 | 0, $2 + 48 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 8 | 0, $1 + 132 | 0), + HEAPF32[wasm2js_i32$0 + 220 >> 2] = wasm2js_f32$0; + $0 = $2; + } + HEAPF32[$1 + 152 >> 2] = HEAPF32[HEAP32[$2 + 228 >> 2] + 28 >> 2]; + HEAPF32[$1 + 148 >> 2] = Math_fround(HEAPF32[$1 + 152 >> 2] * HEAPF32[$2 + 220 >> 2]) + HEAPF32[$2 + 224 >> 2]; + HEAPF32[$1 + 156 >> 2] = 0; + __stack_pointer = $2 + 240 | 0; + return HEAP32[$2 + 236 >> 2]; +} + +function b2DistanceJoint__InitVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, $5 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 208 | 0; + __stack_pointer = $2; + HEAP32[$2 + 204 >> 2] = $0; + HEAP32[$2 + 200 >> 2] = $1; + $0 = HEAP32[$2 + 204 >> 2]; + HEAP32[$0 + 108 >> 2] = HEAP32[HEAP32[$0 + 48 >> 2] + 8 >> 2]; + HEAP32[$0 + 112 >> 2] = HEAP32[HEAP32[$0 + 52 >> 2] + 8 >> 2]; + $4 = HEAP32[$0 + 48 >> 2]; + $1 = HEAP32[$4 + 28 >> 2]; + $3 = HEAP32[$4 + 32 >> 2]; + HEAP32[$0 + 140 >> 2] = $1; + HEAP32[$0 + 144 >> 2] = $3; + $4 = HEAP32[$0 + 52 >> 2]; + $3 = HEAP32[$4 + 28 >> 2]; + $1 = HEAP32[$4 + 32 >> 2]; + HEAP32[$0 + 148 >> 2] = $3; + HEAP32[$0 + 152 >> 2] = $1; + HEAPF32[$0 + 156 >> 2] = HEAPF32[HEAP32[$0 + 48 >> 2] + 120 >> 2]; + HEAPF32[$0 + 160 >> 2] = HEAPF32[HEAP32[$0 + 52 >> 2] + 120 >> 2]; + HEAPF32[$0 + 164 >> 2] = HEAPF32[HEAP32[$0 + 48 >> 2] + 128 >> 2]; + HEAPF32[$0 + 168 >> 2] = HEAPF32[HEAP32[$0 + 52 >> 2] + 128 >> 2]; + $4 = HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$0 + 108 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $3 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 192 >> 2] = $1; + HEAP32[$2 + 196 >> 2] = $3; + HEAPF32[$2 + 188 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$0 + 108 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 108 >> 2], 12) | 0; + $3 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 176 >> 2] = $3; + HEAP32[$2 + 180 >> 2] = $1; + HEAPF32[$2 + 172 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 108 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$0 + 112 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $3 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 160 >> 2] = $1; + HEAP32[$2 + 164 >> 2] = $3; + HEAPF32[$2 + 156 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$0 + 112 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 112 >> 2], 12) | 0; + $3 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 144 >> 2] = $3; + HEAP32[$2 + 148 >> 2] = $1; + HEAPF32[$2 + 140 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 112 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 132 | 0, HEAPF32[$2 + 188 >> 2]); + b2Rot__b2Rot_28float_29($2 + 124 | 0, HEAPF32[$2 + 156 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 108 | 0, $0 + 80 | 0, $0 + 140 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 116 | 0, $2 + 132 | 0, $2 + 108 | 0); + $3 = HEAP32[$2 + 120 >> 2]; + $1 = HEAP32[$2 + 116 >> 2]; + HEAP32[$0 + 124 >> 2] = $1; + HEAP32[$0 + 128 >> 2] = $3; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 92 | 0, $0 + 88 | 0, $0 + 148 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 100 | 0, $2 + 124 | 0, $2 + 92 | 0); + $1 = HEAP32[$2 + 104 >> 2]; + $3 = HEAP32[$2 + 100 >> 2]; + HEAP32[$0 + 132 >> 2] = $3; + HEAP32[$0 + 136 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 68 | 0, $2 + 160 | 0, $0 + 132 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 76 | 0, $2 + 68 | 0, $2 + 192 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 84 | 0, $2 + 76 | 0, $0 + 124 | 0); + $3 = HEAP32[$2 + 88 >> 2]; + $1 = HEAP32[$2 + 84 >> 2]; + HEAP32[$0 + 116 >> 2] = $1; + HEAP32[$0 + 120 >> 2] = $3; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Vec2__Length_28_29_20const($0 + 116 | 0), + HEAPF32[wasm2js_i32$0 + 64 >> 2] = wasm2js_f32$0; + label$1: { + if (HEAPF32[$2 + 64 >> 2] > Math_fround(.004999999888241291)) { + b2Vec2__operator___28float_29($0 + 116 | 0, Math_fround(Math_fround(1) / HEAPF32[$2 + 64 >> 2])); + break label$1; + } + b2Vec2__Set_28float_2c_20float_29($0 + 116 | 0, Math_fround(0), Math_fround(0)); + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($0 + 124 | 0, $0 + 116 | 0), + HEAPF32[wasm2js_i32$0 + 60 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($0 + 132 | 0, $0 + 116 | 0), + HEAPF32[wasm2js_i32$0 + 56 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 52 >> 2] = Math_fround(Math_fround(HEAPF32[$0 + 168 >> 2] * HEAPF32[$2 + 56 >> 2]) * HEAPF32[$2 + 56 >> 2]) + Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$0 + 164 >> 2] * HEAPF32[$2 + 60 >> 2]) * HEAPF32[$2 + 60 >> 2]) + HEAPF32[$0 + 156 >> 2]) + HEAPF32[$0 + 160 >> 2]); + label$3: { + if (HEAPF32[$0 + 68 >> 2] > Math_fround(0)) { + HEAPF32[$2 + 48 >> 2] = HEAPF32[$2 + 64 >> 2] - HEAPF32[$0 + 104 >> 2]; + HEAPF32[$2 + 44 >> 2] = HEAPF32[$0 + 72 >> 2]; + HEAPF32[$2 + 40 >> 2] = HEAPF32[$0 + 68 >> 2]; + HEAPF32[$2 + 36 >> 2] = HEAPF32[HEAP32[$2 + 200 >> 2] >> 2]; + HEAPF32[$0 + 96 >> 2] = HEAPF32[$2 + 36 >> 2] * Math_fround(Math_fround(HEAPF32[$2 + 36 >> 2] * HEAPF32[$2 + 40 >> 2]) + HEAPF32[$2 + 44 >> 2]); + if (HEAPF32[$0 + 96 >> 2] != Math_fround(0)) { + $5 = Math_fround(Math_fround(1) / HEAPF32[$0 + 96 >> 2]); + } else { + $5 = Math_fround(0); + } + HEAPF32[$0 + 96 >> 2] = $5; + HEAPF32[$0 + 76 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 48 >> 2] * HEAPF32[$2 + 36 >> 2]) * HEAPF32[$2 + 40 >> 2]) * HEAPF32[$0 + 96 >> 2]; + HEAPF32[$2 + 52 >> 2] = HEAPF32[$2 + 52 >> 2] + HEAPF32[$0 + 96 >> 2]; + break label$3; + } + HEAPF32[$0 + 96 >> 2] = 0; + HEAPF32[$0 + 76 >> 2] = 0; + } + if (HEAPF32[$2 + 52 >> 2] != Math_fround(0)) { + $5 = Math_fround(Math_fround(1) / HEAPF32[$2 + 52 >> 2]); + } else { + $5 = Math_fround(0); + } + HEAPF32[$0 + 172 >> 2] = $5; + label$9: { + if (HEAP8[HEAP32[$2 + 200 >> 2] + 20 | 0] & 1) { + HEAPF32[$0 + 100 >> 2] = HEAPF32[$0 + 100 >> 2] * HEAPF32[HEAP32[$2 + 200 >> 2] + 8 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 28 | 0, HEAPF32[$0 + 100 >> 2], $0 + 116 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, HEAPF32[$0 + 156 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 176 | 0, $2 + 20 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$0 + 164 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($0 + 124 | 0, $2 + 28 | 0)) + HEAPF32[$2 + 172 >> 2]), + HEAPF32[wasm2js_i32$0 + 172 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$0 + 160 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 144 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$0 + 168 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($0 + 132 | 0, $2 + 28 | 0)) + HEAPF32[$2 + 140 >> 2]), + HEAPF32[wasm2js_i32$0 + 140 >> 2] = wasm2js_f32$0; + break label$9; + } + HEAPF32[$0 + 100 >> 2] = 0; + } + $1 = HEAP32[$2 + 180 >> 2]; + $3 = HEAP32[$2 + 176 >> 2]; + $4 = $3; + $3 = HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 108 >> 2], 12) | 0; + HEAP32[$3 >> 2] = $4; + HEAP32[$3 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 108 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 172 >> 2]; + $3 = HEAP32[$2 + 148 >> 2]; + $1 = HEAP32[$2 + 144 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 112 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $3; + HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$0 + 112 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 140 >> 2]; + __stack_pointer = $2 + 208 | 0; +} + +function dlfree($0) { + $0 = $0 | 0; + var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + label$1: { + if (!$0) { + break label$1; + } + $2 = $0 - 8 | 0; + $1 = HEAP32[$0 - 4 >> 2]; + $0 = $1 & -8; + $5 = $2 + $0 | 0; + label$2: { + if ($1 & 1) { + break label$2; + } + if (!($1 & 3)) { + break label$1; + } + $1 = HEAP32[$2 >> 2]; + $2 = $2 - $1 | 0; + $4 = HEAP32[8067]; + if ($2 >>> 0 < $4 >>> 0) { + break label$1; + } + $0 = $0 + $1 | 0; + label$3: { + label$4: { + if (HEAP32[8068] != ($2 | 0)) { + if ($1 >>> 0 <= 255) { + $6 = $1 >>> 3 | 0; + $1 = HEAP32[$2 + 12 >> 2]; + $4 = HEAP32[$2 + 8 >> 2]; + if (($1 | 0) == ($4 | 0)) { + wasm2js_i32$0 = 32252, wasm2js_i32$1 = HEAP32[8063] & __wasm_rotl_i32(-2, $6), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + break label$2; + } + HEAP32[$4 + 12 >> 2] = $1; + HEAP32[$1 + 8 >> 2] = $4; + break label$2; + } + $7 = HEAP32[$2 + 24 >> 2]; + $3 = HEAP32[$2 + 12 >> 2]; + if (($3 | 0) != ($2 | 0)) { + $1 = HEAP32[$2 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $3; + HEAP32[$3 + 8 >> 2] = $1; + break label$3; + } + $4 = $2 + 20 | 0; + $1 = HEAP32[$4 >> 2]; + if (!$1) { + $1 = HEAP32[$2 + 16 >> 2]; + if (!$1) { + break label$4; + } + $4 = $2 + 16 | 0; + } + while (1) { + $6 = $4; + $3 = $1; + $4 = $1 + 20 | 0; + $1 = HEAP32[$4 >> 2]; + if ($1) { + continue; + } + $4 = $3 + 16 | 0; + $1 = HEAP32[$3 + 16 >> 2]; + if ($1) { + continue; + } + break; + } + HEAP32[$6 >> 2] = 0; + break label$3; + } + $1 = HEAP32[$5 + 4 >> 2]; + if (($1 & 3) != 3) { + break label$2; + } + HEAP32[8065] = $0; + HEAP32[$5 + 4 >> 2] = $1 & -2; + HEAP32[$2 + 4 >> 2] = $0 | 1; + HEAP32[$5 >> 2] = $0; + return; + } + $3 = 0; + } + if (!$7) { + break label$2; + } + $4 = HEAP32[$2 + 28 >> 2]; + $1 = ($4 << 2) + 32556 | 0; + label$11: { + if (HEAP32[$1 >> 2] == ($2 | 0)) { + HEAP32[$1 >> 2] = $3; + if ($3) { + break label$11; + } + wasm2js_i32$0 = 32256, wasm2js_i32$1 = HEAP32[8064] & __wasm_rotl_i32(-2, $4), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + break label$2; + } + HEAP32[(HEAP32[$7 + 16 >> 2] == ($2 | 0) ? 16 : 20) + $7 >> 2] = $3; + if (!$3) { + break label$2; + } + } + HEAP32[$3 + 24 >> 2] = $7; + $1 = HEAP32[$2 + 16 >> 2]; + if ($1) { + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$1 + 24 >> 2] = $3; + } + $1 = HEAP32[$2 + 20 >> 2]; + if (!$1) { + break label$2; + } + HEAP32[$3 + 20 >> 2] = $1; + HEAP32[$1 + 24 >> 2] = $3; + } + if ($2 >>> 0 >= $5 >>> 0) { + break label$1; + } + $1 = HEAP32[$5 + 4 >> 2]; + if (!($1 & 1)) { + break label$1; + } + label$14: { + label$15: { + label$16: { + label$17: { + if (!($1 & 2)) { + if (HEAP32[8069] == ($5 | 0)) { + HEAP32[8069] = $2; + $0 = HEAP32[8066] + $0 | 0; + HEAP32[8066] = $0; + HEAP32[$2 + 4 >> 2] = $0 | 1; + if (HEAP32[8068] != ($2 | 0)) { + break label$1; + } + HEAP32[8065] = 0; + HEAP32[8068] = 0; + return; + } + if (HEAP32[8068] == ($5 | 0)) { + HEAP32[8068] = $2; + $0 = HEAP32[8065] + $0 | 0; + HEAP32[8065] = $0; + HEAP32[$2 + 4 >> 2] = $0 | 1; + HEAP32[$0 + $2 >> 2] = $0; + return; + } + $0 = ($1 & -8) + $0 | 0; + if ($1 >>> 0 <= 255) { + $6 = $1 >>> 3 | 0; + $1 = HEAP32[$5 + 12 >> 2]; + $4 = HEAP32[$5 + 8 >> 2]; + if (($1 | 0) == ($4 | 0)) { + wasm2js_i32$0 = 32252, wasm2js_i32$1 = HEAP32[8063] & __wasm_rotl_i32(-2, $6), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + break label$15; + } + HEAP32[$4 + 12 >> 2] = $1; + HEAP32[$1 + 8 >> 2] = $4; + break label$15; + } + $7 = HEAP32[$5 + 24 >> 2]; + $3 = HEAP32[$5 + 12 >> 2]; + if (($5 | 0) != ($3 | 0)) { + $1 = HEAP32[$5 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $3; + HEAP32[$3 + 8 >> 2] = $1; + break label$16; + } + $4 = $5 + 20 | 0; + $1 = HEAP32[$4 >> 2]; + if (!$1) { + $1 = HEAP32[$5 + 16 >> 2]; + if (!$1) { + break label$17; + } + $4 = $5 + 16 | 0; + } + while (1) { + $6 = $4; + $3 = $1; + $4 = $1 + 20 | 0; + $1 = HEAP32[$4 >> 2]; + if ($1) { + continue; + } + $4 = $3 + 16 | 0; + $1 = HEAP32[$3 + 16 >> 2]; + if ($1) { + continue; + } + break; + } + HEAP32[$6 >> 2] = 0; + break label$16; + } + HEAP32[$5 + 4 >> 2] = $1 & -2; + HEAP32[$2 + 4 >> 2] = $0 | 1; + HEAP32[$0 + $2 >> 2] = $0; + break label$14; + } + $3 = 0; + } + if (!$7) { + break label$15; + } + $4 = HEAP32[$5 + 28 >> 2]; + $1 = ($4 << 2) + 32556 | 0; + label$26: { + if (HEAP32[$1 >> 2] == ($5 | 0)) { + HEAP32[$1 >> 2] = $3; + if ($3) { + break label$26; + } + wasm2js_i32$0 = 32256, wasm2js_i32$1 = HEAP32[8064] & __wasm_rotl_i32(-2, $4), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + break label$15; + } + HEAP32[(HEAP32[$7 + 16 >> 2] == ($5 | 0) ? 16 : 20) + $7 >> 2] = $3; + if (!$3) { + break label$15; + } + } + HEAP32[$3 + 24 >> 2] = $7; + $1 = HEAP32[$5 + 16 >> 2]; + if ($1) { + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$1 + 24 >> 2] = $3; + } + $1 = HEAP32[$5 + 20 >> 2]; + if (!$1) { + break label$15; + } + HEAP32[$3 + 20 >> 2] = $1; + HEAP32[$1 + 24 >> 2] = $3; + } + HEAP32[$2 + 4 >> 2] = $0 | 1; + HEAP32[$0 + $2 >> 2] = $0; + if (HEAP32[8068] != ($2 | 0)) { + break label$14; + } + HEAP32[8065] = $0; + return; + } + if ($0 >>> 0 <= 255) { + $1 = ($0 & -8) + 32292 | 0; + $0 = 1 << ($0 >>> 3); + $4 = HEAP32[8063]; + label$30: { + if (!($0 & $4)) { + HEAP32[8063] = $0 | $4; + $0 = $1; + break label$30; + } + $0 = HEAP32[$1 + 8 >> 2]; + } + HEAP32[$1 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $2; + HEAP32[$2 + 12 >> 2] = $1; + HEAP32[$2 + 8 >> 2] = $0; + return; + } + $1 = 31; + if ($0 >>> 0 <= 16777215) { + $1 = Math_clz32($0 >>> 8 | 0); + $1 = (($0 >>> 38 - $1 & 1) - ($1 << 1) | 0) + 62 | 0; + } + HEAP32[$2 + 28 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = 0; + HEAP32[$2 + 20 >> 2] = 0; + $4 = ($1 << 2) + 32556 | 0; + label$33: { + label$34: { + $3 = HEAP32[8064]; + $5 = 1 << $1; + label$35: { + if (!($3 & $5)) { + HEAP32[8064] = $3 | $5; + HEAP32[$4 >> 2] = $2; + break label$35; + } + $1 = $0 << (($1 | 0) != 31 ? 25 - ($1 >>> 1 | 0) | 0 : 0); + $3 = HEAP32[$4 >> 2]; + while (1) { + $4 = $3; + if ((HEAP32[$3 + 4 >> 2] & -8) == ($0 | 0)) { + break label$34; + } + $3 = $1 >>> 29 | 0; + $1 = $1 << 1; + $6 = ($3 & 4) + $4 | 0; + $5 = $6 + 16 | 0; + $3 = HEAP32[$5 >> 2]; + if ($3) { + continue; + } + break; + } + HEAP32[$6 + 16 >> 2] = $2; + } + HEAP32[$2 + 24 >> 2] = $4; + HEAP32[$2 + 12 >> 2] = $2; + HEAP32[$2 + 8 >> 2] = $2; + break label$33; + } + $0 = HEAP32[$4 + 8 >> 2]; + HEAP32[$0 + 12 >> 2] = $2; + HEAP32[$4 + 8 >> 2] = $2; + HEAP32[$2 + 24 >> 2] = 0; + HEAP32[$2 + 12 >> 2] = $4; + HEAP32[$2 + 8 >> 2] = $0; + } + $2 = HEAP32[8071] - 1 | 0; + HEAP32[8071] = $2 ? $2 : -1; + } +} + +function b2CollidePolygonAndCircle_28b2Manifold__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2CircleShape_20const__2c_20b2Transform_20const__29($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $5 = __stack_pointer - 208 | 0; + __stack_pointer = $5; + HEAP32[$5 + 204 >> 2] = $0; + HEAP32[$5 + 200 >> 2] = $1; + HEAP32[$5 + 196 >> 2] = $2; + HEAP32[$5 + 192 >> 2] = $3; + HEAP32[$5 + 188 >> 2] = $4; + HEAP32[HEAP32[$5 + 204 >> 2] + 60 >> 2] = 0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 180 | 0, HEAP32[$5 + 188 >> 2], HEAP32[$5 + 192 >> 2] + 12 | 0); + b2MulT_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 172 | 0, HEAP32[$5 + 196 >> 2], $5 + 180 | 0); + HEAP32[$5 + 168 >> 2] = 0; + HEAPF32[$5 + 164 >> 2] = -34028234663852886e22; + HEAPF32[$5 + 160 >> 2] = HEAPF32[HEAP32[$5 + 200 >> 2] + 8 >> 2] + HEAPF32[HEAP32[$5 + 192 >> 2] + 8 >> 2]; + HEAP32[$5 + 156 >> 2] = HEAP32[HEAP32[$5 + 200 >> 2] + 148 >> 2]; + HEAP32[$5 + 152 >> 2] = HEAP32[$5 + 200 >> 2] + 20; + HEAP32[$5 + 148 >> 2] = HEAP32[$5 + 200 >> 2] + 84; + HEAP32[$5 + 144 >> 2] = 0; + label$1: { + while (1) { + if (HEAP32[$5 + 144 >> 2] < HEAP32[$5 + 156 >> 2]) { + $0 = HEAP32[$5 + 148 >> 2]; + $1 = HEAP32[$5 + 144 >> 2] << 3; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 132 | 0, $5 + 172 | 0, HEAP32[$5 + 152 >> 2] + (HEAP32[$5 + 144 >> 2] << 3) | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0 + $1 | 0, $5 + 132 | 0), + HEAPF32[wasm2js_i32$0 + 140 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 140 >> 2] > HEAPF32[$5 + 160 >> 2]) { + break label$1; + } + if (HEAPF32[$5 + 140 >> 2] > HEAPF32[$5 + 164 >> 2]) { + HEAPF32[$5 + 164 >> 2] = HEAPF32[$5 + 140 >> 2]; + HEAP32[$5 + 168 >> 2] = HEAP32[$5 + 144 >> 2]; + } + HEAP32[$5 + 144 >> 2] = HEAP32[$5 + 144 >> 2] + 1; + continue; + } + break; + } + HEAP32[$5 + 128 >> 2] = HEAP32[$5 + 168 >> 2]; + if (HEAP32[$5 + 156 >> 2] > (HEAP32[$5 + 128 >> 2] + 1 | 0)) { + $0 = HEAP32[$5 + 128 >> 2] + 1 | 0; + } else { + $0 = 0; + } + HEAP32[$5 + 124 >> 2] = $0; + $2 = HEAP32[$5 + 152 >> 2] + (HEAP32[$5 + 128 >> 2] << 3) | 0; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + HEAP32[$5 + 112 >> 2] = $1; + HEAP32[$5 + 116 >> 2] = $0; + $2 = HEAP32[$5 + 152 >> 2] + (HEAP32[$5 + 124 >> 2] << 3) | 0; + $0 = HEAP32[$2 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + HEAP32[$5 + 104 >> 2] = $0; + HEAP32[$5 + 108 >> 2] = $1; + if (HEAPF32[$5 + 164 >> 2] < Math_fround(1.1920928955078125e-7)) { + HEAP32[HEAP32[$5 + 204 >> 2] + 60 >> 2] = 1; + HEAP32[HEAP32[$5 + 204 >> 2] + 56 >> 2] = 1; + $2 = HEAP32[$5 + 148 >> 2] + (HEAP32[$5 + 168 >> 2] << 3) | 0; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 204 >> 2]; + HEAP32[$1 + 40 >> 2] = $2; + HEAP32[$1 + 44 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($5 + 88 | 0, $5 + 112 | 0, $5 + 104 | 0); + operator__28float_2c_20b2Vec2_20const__29($5 + 96 | 0, Math_fround(.5), $5 + 88 | 0); + $1 = HEAP32[$5 + 100 >> 2]; + $0 = HEAP32[$5 + 96 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 204 >> 2]; + HEAP32[$0 + 48 >> 2] = $2; + HEAP32[$0 + 52 >> 2] = $1; + $2 = HEAP32[$5 + 192 >> 2]; + $1 = HEAP32[$2 + 12 >> 2]; + $0 = HEAP32[$2 + 16 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 204 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAP32[HEAP32[$5 + 204 >> 2] + 16 >> 2] = 0; + break label$1; + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 76 | 0, $5 + 172 | 0, $5 + 112 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 68 | 0, $5 + 104 | 0, $5 + 112 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 76 | 0, $5 + 68 | 0), + HEAPF32[wasm2js_i32$0 + 84 >> 2] = wasm2js_f32$0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 56 | 0, $5 + 172 | 0, $5 + 104 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 48 | 0, $5 + 112 | 0, $5 + 104 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 56 | 0, $5 + 48 | 0), + HEAPF32[wasm2js_i32$0 + 64 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 84 >> 2] <= Math_fround(0)) { + if (b2DistanceSquared_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 172 | 0, $5 + 112 | 0) > Math_fround(HEAPF32[$5 + 160 >> 2] * HEAPF32[$5 + 160 >> 2])) { + break label$1; + } + HEAP32[HEAP32[$5 + 204 >> 2] + 60 >> 2] = 1; + HEAP32[HEAP32[$5 + 204 >> 2] + 56 >> 2] = 1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 40 | 0, $5 + 172 | 0, $5 + 112 | 0); + $1 = HEAP32[$5 + 44 >> 2]; + $0 = HEAP32[$5 + 40 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 204 >> 2]; + HEAP32[$0 + 40 >> 2] = $2; + HEAP32[$0 + 44 >> 2] = $1; + b2Vec2__Normalize_28_29(HEAP32[$5 + 204 >> 2] + 40 | 0); + $0 = HEAP32[$5 + 116 >> 2]; + $1 = HEAP32[$5 + 112 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 204 >> 2]; + HEAP32[$1 + 48 >> 2] = $2; + HEAP32[$1 + 52 >> 2] = $0; + $2 = HEAP32[$5 + 192 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$2 + 16 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 204 >> 2]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + HEAP32[HEAP32[$5 + 204 >> 2] + 16 >> 2] = 0; + break label$1; + } + label$9: { + if (HEAPF32[$5 + 64 >> 2] <= Math_fround(0)) { + if (b2DistanceSquared_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 172 | 0, $5 + 104 | 0) > Math_fround(HEAPF32[$5 + 160 >> 2] * HEAPF32[$5 + 160 >> 2])) { + break label$1; + } + HEAP32[HEAP32[$5 + 204 >> 2] + 60 >> 2] = 1; + HEAP32[HEAP32[$5 + 204 >> 2] + 56 >> 2] = 1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 32 | 0, $5 + 172 | 0, $5 + 104 | 0); + $0 = HEAP32[$5 + 36 >> 2]; + $1 = HEAP32[$5 + 32 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 204 >> 2]; + HEAP32[$1 + 40 >> 2] = $2; + HEAP32[$1 + 44 >> 2] = $0; + b2Vec2__Normalize_28_29(HEAP32[$5 + 204 >> 2] + 40 | 0); + $1 = HEAP32[$5 + 108 >> 2]; + $0 = HEAP32[$5 + 104 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 204 >> 2]; + HEAP32[$0 + 48 >> 2] = $2; + HEAP32[$0 + 52 >> 2] = $1; + break label$9; + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($5 + 16 | 0, $5 + 112 | 0, $5 + 104 | 0); + operator__28float_2c_20b2Vec2_20const__29($5 + 24 | 0, Math_fround(.5), $5 + 16 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 4 | 0, $5 + 172 | 0, $5 + 24 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 4 | 0, HEAP32[$5 + 148 >> 2] + (HEAP32[$5 + 128 >> 2] << 3) | 0), + HEAPF32[wasm2js_i32$0 + 12 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 12 >> 2] > HEAPF32[$5 + 160 >> 2]) { + break label$1; + } + HEAP32[HEAP32[$5 + 204 >> 2] + 60 >> 2] = 1; + HEAP32[HEAP32[$5 + 204 >> 2] + 56 >> 2] = 1; + $2 = HEAP32[$5 + 148 >> 2] + (HEAP32[$5 + 128 >> 2] << 3) | 0; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 204 >> 2]; + HEAP32[$1 + 40 >> 2] = $2; + HEAP32[$1 + 44 >> 2] = $0; + $1 = HEAP32[$5 + 28 >> 2]; + $0 = HEAP32[$5 + 24 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 204 >> 2]; + HEAP32[$0 + 48 >> 2] = $2; + HEAP32[$0 + 52 >> 2] = $1; + } + $2 = HEAP32[$5 + 192 >> 2]; + $1 = HEAP32[$2 + 12 >> 2]; + $0 = HEAP32[$2 + 16 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 204 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAP32[HEAP32[$5 + 204 >> 2] + 16 >> 2] = 0; + } + __stack_pointer = $5 + 208 | 0; +} + +function b2Island__SolveTOI_28b2TimeStep_20const__2c_20int_2c_20int_29($0, $1, $2, $3) { + var $4 = 0, $5 = 0, $6 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_f32$0 = Math_fround(0); + $4 = __stack_pointer - 208 | 0; + __stack_pointer = $4; + HEAP32[$4 + 204 >> 2] = $0; + HEAP32[$4 + 200 >> 2] = $1; + HEAP32[$4 + 196 >> 2] = $2; + HEAP32[$4 + 192 >> 2] = $3; + $5 = HEAP32[$4 + 204 >> 2]; + if (HEAP32[$4 + 196 >> 2] >= HEAP32[$5 + 28 >> 2]) { + __assert_fail(2066, 6099, 391, 10871); + wasm2js_trap(); + } + if (HEAP32[$4 + 192 >> 2] >= HEAP32[$5 + 28 >> 2]) { + __assert_fail(2042, 6099, 392, 10871); + wasm2js_trap(); + } + HEAP32[$4 + 188 >> 2] = 0; + while (1) { + if (HEAP32[$4 + 188 >> 2] < HEAP32[$5 + 28 >> 2]) { + HEAP32[$4 + 184 >> 2] = HEAP32[HEAP32[$5 + 8 >> 2] + (HEAP32[$4 + 188 >> 2] << 2) >> 2]; + $3 = HEAP32[$4 + 184 >> 2]; + $0 = HEAP32[$3 + 44 >> 2]; + $1 = HEAP32[$3 + 48 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 20 >> 2] + Math_imul(HEAP32[$4 + 188 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[$5 + 20 >> 2] + Math_imul(HEAP32[$4 + 188 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[HEAP32[$4 + 184 >> 2] + 56 >> 2]; + $3 = HEAP32[$4 + 184 >> 2]; + $1 = HEAP32[$3 + 64 >> 2]; + $0 = HEAP32[$3 + 68 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 24 >> 2] + Math_imul(HEAP32[$4 + 188 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[$5 + 24 >> 2] + Math_imul(HEAP32[$4 + 188 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[HEAP32[$4 + 184 >> 2] + 72 >> 2]; + HEAP32[$4 + 188 >> 2] = HEAP32[$4 + 188 >> 2] + 1; + continue; + } + break; + } + HEAP32[$4 + 164 >> 2] = HEAP32[$5 + 12 >> 2]; + HEAP32[$4 + 168 >> 2] = HEAP32[$5 + 36 >> 2]; + HEAP32[$4 + 180 >> 2] = HEAP32[$5 >> 2]; + $3 = HEAP32[$4 + 200 >> 2]; + $0 = HEAP32[$3 >> 2]; + $1 = HEAP32[$3 + 4 >> 2]; + $6 = $0; + $2 = $4 + 140 | 0; + $0 = $2; + HEAP32[$0 >> 2] = $6; + HEAP32[$0 + 4 >> 2] = $1; + $0 = HEAP32[$3 + 20 >> 2]; + $1 = HEAP32[$3 + 16 >> 2]; + $6 = $1; + $1 = $2; + HEAP32[$1 + 16 >> 2] = $6; + HEAP32[$1 + 20 >> 2] = $0; + $1 = HEAP32[$3 + 12 >> 2]; + $0 = HEAP32[$3 + 8 >> 2]; + $3 = $0; + $0 = $2; + HEAP32[$0 + 8 >> 2] = $3; + HEAP32[$0 + 12 >> 2] = $1; + HEAP32[$4 + 172 >> 2] = HEAP32[$5 + 20 >> 2]; + HEAP32[$4 + 176 >> 2] = HEAP32[$5 + 24 >> 2]; + b2ContactSolver__b2ContactSolver_28b2ContactSolverDef__29($4 + 88 | 0, $4 + 140 | 0); + HEAP32[$4 + 84 >> 2] = 0; + while (1) { + label$6: { + if (HEAP32[$4 + 84 >> 2] >= HEAP32[HEAP32[$4 + 200 >> 2] + 16 >> 2]) { + break label$6; + } + wasm2js_i32$0 = $4, wasm2js_i32$1 = b2ContactSolver__SolveTOIPositionConstraints_28int_2c_20int_29($4 + 88 | 0, HEAP32[$4 + 196 >> 2], HEAP32[$4 + 192 >> 2]) & 1, + HEAP8[wasm2js_i32$0 + 83 | 0] = wasm2js_i32$1; + if (HEAP8[$4 + 83 | 0] & 1) { + break label$6; + } + HEAP32[$4 + 84 >> 2] = HEAP32[$4 + 84 >> 2] + 1; + continue; + } + break; + } + $3 = HEAP32[$5 + 20 >> 2] + Math_imul(HEAP32[$4 + 196 >> 2], 12) | 0; + $1 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + $2 = $1; + $1 = HEAP32[HEAP32[$5 + 8 >> 2] + (HEAP32[$4 + 196 >> 2] << 2) >> 2]; + HEAP32[$1 + 36 >> 2] = $2; + HEAP32[$1 + 40 >> 2] = $0; + HEAPF32[HEAP32[HEAP32[$5 + 8 >> 2] + (HEAP32[$4 + 196 >> 2] << 2) >> 2] + 52 >> 2] = HEAPF32[(HEAP32[$5 + 20 >> 2] + Math_imul(HEAP32[$4 + 196 >> 2], 12) | 0) + 8 >> 2]; + $3 = HEAP32[$5 + 20 >> 2] + Math_imul(HEAP32[$4 + 192 >> 2], 12) | 0; + $0 = HEAP32[$3 >> 2]; + $1 = HEAP32[$3 + 4 >> 2]; + $2 = $0; + $0 = HEAP32[HEAP32[$5 + 8 >> 2] + (HEAP32[$4 + 192 >> 2] << 2) >> 2]; + HEAP32[$0 + 36 >> 2] = $2; + HEAP32[$0 + 40 >> 2] = $1; + HEAPF32[HEAP32[HEAP32[$5 + 8 >> 2] + (HEAP32[$4 + 192 >> 2] << 2) >> 2] + 52 >> 2] = HEAPF32[(HEAP32[$5 + 20 >> 2] + Math_imul(HEAP32[$4 + 192 >> 2], 12) | 0) + 8 >> 2]; + b2ContactSolver__InitializeVelocityConstraints_28_29($4 + 88 | 0); + HEAP32[$4 + 76 >> 2] = 0; + while (1) { + if (HEAP32[$4 + 76 >> 2] < HEAP32[HEAP32[$4 + 200 >> 2] + 12 >> 2]) { + b2ContactSolver__SolveVelocityConstraints_28_29($4 + 88 | 0); + HEAP32[$4 + 76 >> 2] = HEAP32[$4 + 76 >> 2] + 1; + continue; + } + break; + } + HEAPF32[$4 + 72 >> 2] = HEAPF32[HEAP32[$4 + 200 >> 2] >> 2]; + HEAP32[$4 + 68 >> 2] = 0; + while (1) { + if (HEAP32[$4 + 68 >> 2] < HEAP32[$5 + 28 >> 2]) { + $3 = HEAP32[$5 + 20 >> 2] + Math_imul(HEAP32[$4 + 68 >> 2], 12) | 0; + $1 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + HEAP32[$4 + 56 >> 2] = $1; + HEAP32[$4 + 60 >> 2] = $0; + HEAPF32[$4 + 52 >> 2] = HEAPF32[(HEAP32[$5 + 20 >> 2] + Math_imul(HEAP32[$4 + 68 >> 2], 12) | 0) + 8 >> 2]; + $3 = HEAP32[$5 + 24 >> 2] + Math_imul(HEAP32[$4 + 68 >> 2], 12) | 0; + $0 = HEAP32[$3 >> 2]; + $1 = HEAP32[$3 + 4 >> 2]; + HEAP32[$4 + 40 >> 2] = $0; + HEAP32[$4 + 44 >> 2] = $1; + HEAPF32[$4 + 36 >> 2] = HEAPF32[(HEAP32[$5 + 24 >> 2] + Math_imul(HEAP32[$4 + 68 >> 2], 12) | 0) + 8 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($4 + 28 | 0, HEAPF32[$4 + 72 >> 2], $4 + 40 | 0); + $0 = $4 + 28 | 0; + if (b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $0) > Math_fround(4)) { + wasm2js_i32$0 = $4, wasm2js_f32$0 = Math_fround(Math_fround(2) / b2Vec2__Length_28_29_20const($4 + 28 | 0)), + HEAPF32[wasm2js_i32$0 + 24 >> 2] = wasm2js_f32$0; + b2Vec2__operator___28float_29($4 + 40 | 0, HEAPF32[$4 + 24 >> 2]); + } + HEAPF32[$4 + 20 >> 2] = HEAPF32[$4 + 72 >> 2] * HEAPF32[$4 + 36 >> 2]; + if (Math_fround(HEAPF32[$4 + 20 >> 2] * HEAPF32[$4 + 20 >> 2]) > Math_fround(2.4674012660980225)) { + wasm2js_i32$0 = $4, wasm2js_f32$0 = Math_fround(Math_fround(1.5707963705062866) / float_20b2Abs_float__28float_29(HEAPF32[$4 + 20 >> 2])), + HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0; + HEAPF32[$4 + 36 >> 2] = HEAPF32[$4 + 36 >> 2] * HEAPF32[$4 + 16 >> 2]; + } + operator__28float_2c_20b2Vec2_20const__29($4 + 8 | 0, HEAPF32[$4 + 72 >> 2], $4 + 40 | 0); + b2Vec2__operator___28b2Vec2_20const__29($4 + 56 | 0, $4 + 8 | 0); + HEAPF32[$4 + 52 >> 2] = Math_fround(HEAPF32[$4 + 72 >> 2] * HEAPF32[$4 + 36 >> 2]) + HEAPF32[$4 + 52 >> 2]; + $0 = HEAP32[$4 + 60 >> 2]; + $1 = HEAP32[$4 + 56 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 20 >> 2] + Math_imul(HEAP32[$4 + 68 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[$5 + 20 >> 2] + Math_imul(HEAP32[$4 + 68 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$4 + 52 >> 2]; + $1 = HEAP32[$4 + 44 >> 2]; + $0 = HEAP32[$4 + 40 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 24 >> 2] + Math_imul(HEAP32[$4 + 68 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[$5 + 24 >> 2] + Math_imul(HEAP32[$4 + 68 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$4 + 36 >> 2]; + HEAP32[$4 + 4 >> 2] = HEAP32[HEAP32[$5 + 8 >> 2] + (HEAP32[$4 + 68 >> 2] << 2) >> 2]; + $0 = HEAP32[$4 + 60 >> 2]; + $1 = HEAP32[$4 + 56 >> 2]; + $2 = $1; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$1 + 44 >> 2] = $2; + HEAP32[$1 + 48 >> 2] = $0; + HEAPF32[HEAP32[$4 + 4 >> 2] + 56 >> 2] = HEAPF32[$4 + 52 >> 2]; + $1 = HEAP32[$4 + 44 >> 2]; + $0 = HEAP32[$4 + 40 >> 2]; + $2 = $0; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$0 + 64 >> 2] = $2; + HEAP32[$0 + 68 >> 2] = $1; + HEAPF32[HEAP32[$4 + 4 >> 2] + 72 >> 2] = HEAPF32[$4 + 36 >> 2]; + b2Body__SynchronizeTransform_28_29(HEAP32[$4 + 4 >> 2]); + HEAP32[$4 + 68 >> 2] = HEAP32[$4 + 68 >> 2] + 1; + continue; + } + break; + } + b2Island__Report_28b2ContactVelocityConstraint_20const__29($5, HEAP32[$4 + 128 >> 2]); + b2ContactSolver___b2ContactSolver_28_29($4 + 88 | 0); + __stack_pointer = $4 + 208 | 0; +} + +function b2ContactSolver__SolveTOIPositionConstraints_28int_2c_20int_29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 272 | 0; + __stack_pointer = $3; + HEAP32[$3 + 268 >> 2] = $0; + HEAP32[$3 + 264 >> 2] = $1; + HEAP32[$3 + 260 >> 2] = $2; + $4 = HEAP32[$3 + 268 >> 2]; + HEAPF32[$3 + 256 >> 2] = 0; + HEAP32[$3 + 252 >> 2] = 0; + while (1) { + if (HEAP32[$3 + 252 >> 2] < HEAP32[$4 + 48 >> 2]) { + HEAP32[$3 + 248 >> 2] = HEAP32[$4 + 36 >> 2] + Math_imul(HEAP32[$3 + 252 >> 2], 88); + HEAP32[$3 + 244 >> 2] = HEAP32[HEAP32[$3 + 248 >> 2] + 32 >> 2]; + HEAP32[$3 + 240 >> 2] = HEAP32[HEAP32[$3 + 248 >> 2] + 36 >> 2]; + $2 = HEAP32[$3 + 248 >> 2]; + $1 = HEAP32[$2 + 48 >> 2]; + $0 = HEAP32[$2 + 52 >> 2]; + HEAP32[$3 + 232 >> 2] = $1; + HEAP32[$3 + 236 >> 2] = $0; + $2 = HEAP32[$3 + 248 >> 2]; + $0 = HEAP32[$2 + 56 >> 2]; + $1 = HEAP32[$2 + 60 >> 2]; + HEAP32[$3 + 224 >> 2] = $0; + HEAP32[$3 + 228 >> 2] = $1; + HEAP32[$3 + 220 >> 2] = HEAP32[HEAP32[$3 + 248 >> 2] + 84 >> 2]; + HEAPF32[$3 + 216 >> 2] = 0; + HEAPF32[$3 + 212 >> 2] = 0; + if (!(HEAP32[$3 + 244 >> 2] != HEAP32[$3 + 264 >> 2] & HEAP32[$3 + 244 >> 2] != HEAP32[$3 + 260 >> 2])) { + HEAPF32[$3 + 216 >> 2] = HEAPF32[HEAP32[$3 + 248 >> 2] + 40 >> 2]; + HEAPF32[$3 + 212 >> 2] = HEAPF32[HEAP32[$3 + 248 >> 2] + 64 >> 2]; + } + HEAPF32[$3 + 208 >> 2] = 0; + HEAPF32[$3 + 204 >> 2] = 0; + if (!(HEAP32[$3 + 240 >> 2] != HEAP32[$3 + 264 >> 2] & HEAP32[$3 + 240 >> 2] != HEAP32[$3 + 260 >> 2])) { + HEAPF32[$3 + 208 >> 2] = HEAPF32[HEAP32[$3 + 248 >> 2] + 44 >> 2]; + HEAPF32[$3 + 204 >> 2] = HEAPF32[HEAP32[$3 + 248 >> 2] + 68 >> 2]; + } + $2 = HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$3 + 244 >> 2], 12) | 0; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + HEAP32[$3 + 192 >> 2] = $1; + HEAP32[$3 + 196 >> 2] = $0; + HEAPF32[$3 + 188 >> 2] = HEAPF32[(HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$3 + 244 >> 2], 12) | 0) + 8 >> 2]; + $2 = HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$3 + 240 >> 2], 12) | 0; + $0 = HEAP32[$2 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + HEAP32[$3 + 176 >> 2] = $0; + HEAP32[$3 + 180 >> 2] = $1; + HEAPF32[$3 + 172 >> 2] = HEAPF32[(HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$3 + 240 >> 2], 12) | 0) + 8 >> 2]; + HEAP32[$3 + 168 >> 2] = 0; + while (1) { + if (HEAP32[$3 + 168 >> 2] < HEAP32[$3 + 220 >> 2]) { + b2Transform__b2Transform_28_29($3 + 152 | 0); + b2Transform__b2Transform_28_29($3 + 136 | 0); + b2Rot__Set_28float_29($3 + 160 | 0, HEAPF32[$3 + 188 >> 2]); + b2Rot__Set_28float_29($3 + 144 | 0, HEAPF32[$3 + 172 >> 2]); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 120 | 0, $3 + 160 | 0, $3 + 232 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 128 | 0, $3 + 192 | 0, $3 + 120 | 0); + $0 = HEAP32[$3 + 132 >> 2]; + $1 = HEAP32[$3 + 128 >> 2]; + $2 = $1; + $1 = $3 + 152 | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 104 | 0, $3 + 144 | 0, $3 + 224 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 112 | 0, $3 + 176 | 0, $3 + 104 | 0); + $1 = HEAP32[$3 + 116 >> 2]; + $0 = HEAP32[$3 + 112 >> 2]; + $2 = $0; + $0 = $3 + 136 | 0; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + b2PositionSolverManifold__b2PositionSolverManifold_28_29($3 + 84 | 0); + b2PositionSolverManifold__Initialize_28b2ContactPositionConstraint__2c_20b2Transform_20const__2c_20b2Transform_20const__2c_20int_29($3 + 84 | 0, HEAP32[$3 + 248 >> 2], $3 + 152 | 0, $3 + 136 | 0, HEAP32[$3 + 168 >> 2]); + $2 = $3 + 84 | 0; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + HEAP32[$3 + 72 >> 2] = $1; + HEAP32[$3 + 76 >> 2] = $0; + $2 = $3 + 84 | 0; + $0 = HEAP32[$2 + 8 >> 2]; + $1 = HEAP32[$2 + 12 >> 2]; + HEAP32[$3 + 64 >> 2] = $0; + HEAP32[$3 + 68 >> 2] = $1; + HEAPF32[$3 + 60 >> 2] = HEAPF32[$3 + 100 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 52 | 0, $3 - -64 | 0, $3 + 192 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 44 | 0, $3 - -64 | 0, $3 + 176 | 0); + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Min_float__28float_2c_20float_29(HEAPF32[$3 + 256 >> 2], HEAPF32[$3 + 60 >> 2]), + HEAPF32[wasm2js_i32$0 + 256 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Clamp_float__28float_2c_20float_2c_20float_29(Math_fround(Math_fround(HEAPF32[$3 + 60 >> 2] + Math_fround(.004999999888241291)) * Math_fround(.75)), Math_fround(-.20000000298023224), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 40 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 52 | 0, $3 + 72 | 0), + HEAPF32[wasm2js_i32$0 + 36 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 44 | 0, $3 + 72 | 0), + HEAPF32[wasm2js_i32$0 + 32 >> 2] = wasm2js_f32$0; + HEAPF32[$3 + 28 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 204 >> 2] * HEAPF32[$3 + 32 >> 2]) * HEAPF32[$3 + 32 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$3 + 212 >> 2] * HEAPF32[$3 + 36 >> 2]) * HEAPF32[$3 + 36 >> 2]) + Math_fround(HEAPF32[$3 + 216 >> 2] + HEAPF32[$3 + 208 >> 2])); + if (HEAPF32[$3 + 28 >> 2] > Math_fround(0)) { + $5 = Math_fround(Math_fround(-HEAPF32[$3 + 40 >> 2]) / HEAPF32[$3 + 28 >> 2]); + } else { + $5 = Math_fround(0); + } + HEAPF32[$3 + 24 >> 2] = $5; + operator__28float_2c_20b2Vec2_20const__29($3 + 16 | 0, HEAPF32[$3 + 24 >> 2], $3 + 72 | 0); + operator__28float_2c_20b2Vec2_20const__29($3 + 8 | 0, HEAPF32[$3 + 216 >> 2], $3 + 16 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($3 + 192 | 0, $3 + 8 | 0); + wasm2js_i32$0 = $3, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$3 + 212 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 52 | 0, $3 + 16 | 0)) + HEAPF32[$3 + 188 >> 2]), + HEAPF32[wasm2js_i32$0 + 188 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($3, HEAPF32[$3 + 208 >> 2], $3 + 16 | 0); + b2Vec2__operator___28b2Vec2_20const__29($3 + 176 | 0, $3); + wasm2js_i32$0 = $3, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$3 + 204 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 44 | 0, $3 + 16 | 0)) + HEAPF32[$3 + 172 >> 2]), + HEAPF32[wasm2js_i32$0 + 172 >> 2] = wasm2js_f32$0; + HEAP32[$3 + 168 >> 2] = HEAP32[$3 + 168 >> 2] + 1; + continue; + } + break; + } + $0 = HEAP32[$3 + 196 >> 2]; + $1 = HEAP32[$3 + 192 >> 2]; + $2 = $1; + $1 = HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$3 + 244 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$3 + 244 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$3 + 188 >> 2]; + $1 = HEAP32[$3 + 180 >> 2]; + $0 = HEAP32[$3 + 176 >> 2]; + $2 = $0; + $0 = HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$3 + 240 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$3 + 240 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$3 + 172 >> 2]; + HEAP32[$3 + 252 >> 2] = HEAP32[$3 + 252 >> 2] + 1; + continue; + } + break; + } + __stack_pointer = $3 + 272 | 0; + return HEAPF32[$3 + 256 >> 2] >= Math_fround(-.007499999832361937); +} + +function b2Distance_28b2DistanceOutput__2c_20b2SimplexCache__2c_20b2DistanceInput_20const__29($0, $1, $2) { + var $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 336 | 0; + __stack_pointer = $3; + HEAP32[$3 + 332 >> 2] = $0; + HEAP32[$3 + 328 >> 2] = $1; + HEAP32[$3 + 324 >> 2] = $2; + HEAP32[7526] = HEAP32[7526] + 1; + HEAP32[$3 + 320 >> 2] = HEAP32[$3 + 324 >> 2]; + HEAP32[$3 + 316 >> 2] = HEAP32[$3 + 324 >> 2] + 28; + $2 = HEAP32[$3 + 324 >> 2]; + $1 = HEAP32[$2 + 64 >> 2]; + $0 = HEAP32[$2 + 68 >> 2]; + HEAP32[$3 + 304 >> 2] = $1; + HEAP32[$3 + 308 >> 2] = $0; + $1 = HEAP32[$2 + 60 >> 2]; + $0 = HEAP32[$2 + 56 >> 2]; + HEAP32[$3 + 296 >> 2] = $0; + HEAP32[$3 + 300 >> 2] = $1; + $2 = HEAP32[$3 + 324 >> 2]; + $1 = HEAP32[$2 + 80 >> 2]; + $0 = HEAP32[$2 + 84 >> 2]; + HEAP32[$3 + 288 >> 2] = $1; + HEAP32[$3 + 292 >> 2] = $0; + $1 = HEAP32[$2 + 76 >> 2]; + $0 = HEAP32[$2 + 72 >> 2]; + HEAP32[$3 + 280 >> 2] = $0; + HEAP32[$3 + 284 >> 2] = $1; + b2Simplex__b2Simplex_28_29($3 + 168 | 0); + b2Simplex__ReadCache_28b2SimplexCache_20const__2c_20b2DistanceProxy_20const__2c_20b2Transform_20const__2c_20b2DistanceProxy_20const__2c_20b2Transform_20const__29($3 + 168 | 0, HEAP32[$3 + 328 >> 2], HEAP32[$3 + 320 >> 2], $3 + 296 | 0, HEAP32[$3 + 316 >> 2], $3 + 280 | 0); + HEAP32[$3 + 164 >> 2] = $3 + 168; + HEAP32[$3 + 160 >> 2] = 20; + HEAP32[$3 + 132 >> 2] = 0; + HEAP32[$3 + 128 >> 2] = 0; + while (1) { + label$2: { + if (HEAP32[$3 + 128 >> 2] >= 20) { + break label$2; + } + HEAP32[$3 + 132 >> 2] = HEAP32[$3 + 276 >> 2]; + HEAP32[$3 + 124 >> 2] = 0; + while (1) { + if (HEAP32[$3 + 124 >> 2] < HEAP32[$3 + 132 >> 2]) { + HEAP32[($3 + 148 | 0) + (HEAP32[$3 + 124 >> 2] << 2) >> 2] = HEAP32[(HEAP32[$3 + 164 >> 2] + Math_imul(HEAP32[$3 + 124 >> 2], 36) | 0) + 28 >> 2]; + HEAP32[($3 + 136 | 0) + (HEAP32[$3 + 124 >> 2] << 2) >> 2] = HEAP32[(HEAP32[$3 + 164 >> 2] + Math_imul(HEAP32[$3 + 124 >> 2], 36) | 0) + 32 >> 2]; + HEAP32[$3 + 124 >> 2] = HEAP32[$3 + 124 >> 2] + 1; + continue; + } + break; + } + label$5: { + label$6: { + switch (HEAP32[$3 + 276 >> 2] - 1 | 0) { + case 1: + b2Simplex__Solve2_28_29($3 + 168 | 0); + break label$5; + + case 2: + b2Simplex__Solve3_28_29($3 + 168 | 0); + break label$5; + + case 0: + break label$5; + + default: + break label$6; + } + } + __assert_fail(9147, 6034, 505, 9983); + wasm2js_trap(); + } + if (HEAP32[$3 + 276 >> 2] == 3) { + break label$2; + } + b2Simplex__GetSearchDirection_28_29_20const($3 + 116 | 0, $3 + 168 | 0); + if (b2Vec2__LengthSquared_28_29_20const($3 + 116 | 0) < Math_fround(14210854715202004e-30)) { + break label$2; + } + HEAP32[$3 + 112 >> 2] = HEAP32[$3 + 164 >> 2] + Math_imul(HEAP32[$3 + 276 >> 2], 36); + $0 = HEAP32[$3 + 320 >> 2]; + b2Vec2__operator__28_29_20const($3 + 96 | 0, $3 + 116 | 0); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 104 | 0, $3 + 304 | 0, $3 + 96 | 0); + $0 = b2DistanceProxy__GetSupport_28b2Vec2_20const__29_20const($0, $3 + 104 | 0); + HEAP32[HEAP32[$3 + 112 >> 2] + 28 >> 2] = $0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($3 + 88 | 0, $3 + 296 | 0, b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$3 + 320 >> 2], HEAP32[HEAP32[$3 + 112 >> 2] + 28 >> 2])); + $0 = HEAP32[$3 + 92 >> 2]; + $1 = HEAP32[$3 + 88 >> 2]; + $2 = $1; + $1 = HEAP32[$3 + 112 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + $0 = HEAP32[$3 + 316 >> 2]; + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 80 | 0, $3 + 288 | 0, $3 + 116 | 0); + $0 = b2DistanceProxy__GetSupport_28b2Vec2_20const__29_20const($0, $3 + 80 | 0); + HEAP32[HEAP32[$3 + 112 >> 2] + 32 >> 2] = $0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($3 + 72 | 0, $3 + 280 | 0, b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$3 + 316 >> 2], HEAP32[HEAP32[$3 + 112 >> 2] + 32 >> 2])); + $1 = HEAP32[$3 + 76 >> 2]; + $0 = HEAP32[$3 + 72 >> 2]; + $2 = $0; + $0 = HEAP32[$3 + 112 >> 2]; + HEAP32[$0 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 - -64 | 0, HEAP32[$3 + 112 >> 2] + 8 | 0, HEAP32[$3 + 112 >> 2]); + $0 = HEAP32[$3 + 68 >> 2]; + $1 = HEAP32[$3 + 64 >> 2]; + $2 = $1; + $1 = HEAP32[$3 + 112 >> 2]; + HEAP32[$1 + 16 >> 2] = $2; + HEAP32[$1 + 20 >> 2] = $0; + HEAP32[$3 + 128 >> 2] = HEAP32[$3 + 128 >> 2] + 1; + HEAP32[7527] = HEAP32[7527] + 1; + HEAP8[$3 + 63 | 0] = 0; + HEAP32[$3 + 56 >> 2] = 0; + while (1) { + if (HEAP32[$3 + 56 >> 2] < HEAP32[$3 + 132 >> 2]) { + if (HEAP32[HEAP32[$3 + 112 >> 2] + 28 >> 2] != HEAP32[($3 + 148 | 0) + (HEAP32[$3 + 56 >> 2] << 2) >> 2] | HEAP32[HEAP32[$3 + 112 >> 2] + 32 >> 2] != HEAP32[($3 + 136 | 0) + (HEAP32[$3 + 56 >> 2] << 2) >> 2]) { + HEAP32[$3 + 56 >> 2] = HEAP32[$3 + 56 >> 2] + 1; + continue; + } else { + HEAP8[$3 + 63 | 0] = 1; + } + } + break; + } + if (HEAP8[$3 + 63 | 0] & 1) { + break label$2; + } + HEAP32[$3 + 276 >> 2] = HEAP32[$3 + 276 >> 2] + 1; + continue; + } + break; + } + wasm2js_i32$0 = 30112, wasm2js_i32$1 = int_20b2Max_int__28int_2c_20int_29(HEAP32[7528], HEAP32[$3 + 128 >> 2]), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + b2Simplex__GetWitnessPoints_28b2Vec2__2c_20b2Vec2__29_20const($3 + 168 | 0, HEAP32[$3 + 332 >> 2], HEAP32[$3 + 332 >> 2] + 8 | 0); + $4 = b2Distance_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$3 + 332 >> 2], HEAP32[$3 + 332 >> 2] + 8 | 0); + HEAPF32[HEAP32[$3 + 332 >> 2] + 16 >> 2] = $4; + HEAP32[HEAP32[$3 + 332 >> 2] + 20 >> 2] = HEAP32[$3 + 128 >> 2]; + b2Simplex__WriteCache_28b2SimplexCache__29_20const($3 + 168 | 0, HEAP32[$3 + 328 >> 2]); + if (HEAP8[HEAP32[$3 + 324 >> 2] + 88 | 0] & 1) { + HEAPF32[$3 + 52 >> 2] = HEAPF32[HEAP32[$3 + 320 >> 2] + 24 >> 2]; + HEAPF32[$3 + 48 >> 2] = HEAPF32[HEAP32[$3 + 316 >> 2] + 24 >> 2]; + label$13: { + if (!(!(HEAPF32[HEAP32[$3 + 332 >> 2] + 16 >> 2] > Math_fround(HEAPF32[$3 + 52 >> 2] + HEAPF32[$3 + 48 >> 2])) | !(HEAPF32[HEAP32[$3 + 332 >> 2] + 16 >> 2] > Math_fround(1.1920928955078125e-7)))) { + $0 = HEAP32[$3 + 332 >> 2]; + HEAPF32[$0 + 16 >> 2] = HEAPF32[$0 + 16 >> 2] - Math_fround(HEAPF32[$3 + 52 >> 2] + HEAPF32[$3 + 48 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 40 | 0, HEAP32[$3 + 332 >> 2] + 8 | 0, HEAP32[$3 + 332 >> 2]); + b2Vec2__Normalize_28_29($3 + 40 | 0); + operator__28float_2c_20b2Vec2_20const__29($3 + 32 | 0, HEAPF32[$3 + 52 >> 2], $3 + 40 | 0); + b2Vec2__operator___28b2Vec2_20const__29(HEAP32[$3 + 332 >> 2], $3 + 32 | 0); + operator__28float_2c_20b2Vec2_20const__29($3 + 24 | 0, HEAPF32[$3 + 48 >> 2], $3 + 40 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1(HEAP32[$3 + 332 >> 2] + 8 | 0, $3 + 24 | 0); + break label$13; + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 8 | 0, HEAP32[$3 + 332 >> 2], HEAP32[$3 + 332 >> 2] + 8 | 0); + operator__28float_2c_20b2Vec2_20const__29($3 + 16 | 0, Math_fround(.5), $3 + 8 | 0); + $1 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 16 >> 2]; + $2 = $0; + $0 = HEAP32[$3 + 332 >> 2]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + $0 = HEAP32[$3 + 20 >> 2]; + $1 = HEAP32[$3 + 16 >> 2]; + $2 = $1; + $1 = HEAP32[$3 + 332 >> 2]; + HEAP32[$1 + 8 >> 2] = $2; + HEAP32[$1 + 12 >> 2] = $0; + HEAPF32[HEAP32[$3 + 332 >> 2] + 16 >> 2] = 0; + } + } + __stack_pointer = $3 + 336 | 0; +} + +function b2Simplex__Solve3_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer - 144 | 0; + __stack_pointer = $1; + HEAP32[$1 + 140 >> 2] = $0; + $2 = HEAP32[$1 + 140 >> 2]; + $0 = HEAP32[$2 + 16 >> 2]; + $3 = HEAP32[$2 + 20 >> 2]; + HEAP32[$1 + 128 >> 2] = $0; + HEAP32[$1 + 132 >> 2] = $3; + $0 = HEAP32[$2 + 56 >> 2]; + $3 = HEAP32[$2 + 52 >> 2]; + HEAP32[$1 + 120 >> 2] = $3; + HEAP32[$1 + 124 >> 2] = $0; + $3 = HEAP32[$2 + 92 >> 2]; + $0 = HEAP32[$2 + 88 >> 2]; + HEAP32[$1 + 112 >> 2] = $0; + HEAP32[$1 + 116 >> 2] = $3; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 104 | 0, $1 + 120 | 0, $1 + 128 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 128 | 0, $1 + 104 | 0), + HEAPF32[wasm2js_i32$0 + 100 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 120 | 0, $1 + 104 | 0), + HEAPF32[wasm2js_i32$0 + 96 >> 2] = wasm2js_f32$0; + HEAPF32[$1 + 92 >> 2] = HEAPF32[$1 + 96 >> 2]; + HEAPF32[$1 + 88 >> 2] = -HEAPF32[$1 + 100 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 80 | 0, $1 + 112 | 0, $1 + 128 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 128 | 0, $1 + 80 | 0), + HEAPF32[wasm2js_i32$0 + 76 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 112 | 0, $1 + 80 | 0), + HEAPF32[wasm2js_i32$0 + 72 >> 2] = wasm2js_f32$0; + HEAPF32[$1 + 68 >> 2] = HEAPF32[$1 + 72 >> 2]; + HEAPF32[$1 + 64 >> 2] = -HEAPF32[$1 + 76 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 56 | 0, $1 + 112 | 0, $1 + 120 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 120 | 0, $1 + 56 | 0), + HEAPF32[wasm2js_i32$0 + 52 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 112 | 0, $1 + 56 | 0), + HEAPF32[wasm2js_i32$0 + 48 >> 2] = wasm2js_f32$0; + HEAPF32[$1 + 44 >> 2] = HEAPF32[$1 + 48 >> 2]; + HEAPF32[$1 + 40 >> 2] = -HEAPF32[$1 + 52 >> 2]; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 104 | 0, $1 + 80 | 0), + HEAPF32[wasm2js_i32$0 + 36 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(HEAPF32[$1 + 36 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 120 | 0, $1 + 112 | 0)), + HEAPF32[wasm2js_i32$0 + 32 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(HEAPF32[$1 + 36 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 112 | 0, $1 + 128 | 0)), + HEAPF32[wasm2js_i32$0 + 28 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(HEAPF32[$1 + 36 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 128 | 0, $1 + 120 | 0)), + HEAPF32[wasm2js_i32$0 + 24 >> 2] = wasm2js_f32$0; + label$1: { + if (!(!(HEAPF32[$1 + 88 >> 2] <= Math_fround(0)) | !(HEAPF32[$1 + 64 >> 2] <= Math_fround(0)))) { + HEAPF32[$2 + 24 >> 2] = 1; + HEAP32[$2 + 108 >> 2] = 1; + break label$1; + } + if (!(!(HEAPF32[$1 + 24 >> 2] <= Math_fround(0)) | (!(HEAPF32[$1 + 92 >> 2] > Math_fround(0)) | !(HEAPF32[$1 + 88 >> 2] > Math_fround(0))))) { + HEAPF32[$1 + 20 >> 2] = Math_fround(1) / Math_fround(HEAPF32[$1 + 92 >> 2] + HEAPF32[$1 + 88 >> 2]); + HEAPF32[$2 + 24 >> 2] = HEAPF32[$1 + 92 >> 2] * HEAPF32[$1 + 20 >> 2]; + HEAPF32[$2 + 60 >> 2] = HEAPF32[$1 + 88 >> 2] * HEAPF32[$1 + 20 >> 2]; + HEAP32[$2 + 108 >> 2] = 2; + break label$1; + } + if (!(!(HEAPF32[$1 + 28 >> 2] <= Math_fround(0)) | (!(HEAPF32[$1 + 68 >> 2] > Math_fround(0)) | !(HEAPF32[$1 + 64 >> 2] > Math_fround(0))))) { + HEAPF32[$1 + 16 >> 2] = Math_fround(1) / Math_fround(HEAPF32[$1 + 68 >> 2] + HEAPF32[$1 + 64 >> 2]); + HEAPF32[$2 + 24 >> 2] = HEAPF32[$1 + 68 >> 2] * HEAPF32[$1 + 16 >> 2]; + HEAPF32[$2 + 96 >> 2] = HEAPF32[$1 + 64 >> 2] * HEAPF32[$1 + 16 >> 2]; + HEAP32[$2 + 108 >> 2] = 2; + $0 = HEAP32[$2 + 76 >> 2]; + $3 = HEAP32[$2 + 72 >> 2]; + HEAP32[$2 + 36 >> 2] = $3; + HEAP32[$2 + 40 >> 2] = $0; + HEAP32[$2 + 68 >> 2] = HEAP32[$2 + 104 >> 2]; + $3 = HEAP32[$2 + 100 >> 2]; + $0 = HEAP32[$2 + 96 >> 2]; + HEAP32[$2 + 60 >> 2] = $0; + HEAP32[$2 + 64 >> 2] = $3; + $0 = HEAP32[$2 + 92 >> 2]; + $3 = HEAP32[$2 + 88 >> 2]; + HEAP32[$2 + 52 >> 2] = $3; + HEAP32[$2 + 56 >> 2] = $0; + $3 = HEAP32[$2 + 84 >> 2]; + $0 = HEAP32[$2 + 80 >> 2]; + HEAP32[$2 + 44 >> 2] = $0; + HEAP32[$2 + 48 >> 2] = $3; + break label$1; + } + if (!(!(HEAPF32[$1 + 92 >> 2] <= Math_fround(0)) | !(HEAPF32[$1 + 40 >> 2] <= Math_fround(0)))) { + HEAPF32[$2 + 60 >> 2] = 1; + HEAP32[$2 + 108 >> 2] = 1; + $0 = HEAP32[$2 + 40 >> 2]; + $3 = HEAP32[$2 + 36 >> 2]; + HEAP32[$2 >> 2] = $3; + HEAP32[$2 + 4 >> 2] = $0; + HEAP32[$2 + 32 >> 2] = HEAP32[$2 + 68 >> 2]; + $3 = HEAP32[$2 + 64 >> 2]; + $0 = HEAP32[$2 + 60 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 28 >> 2] = $3; + $0 = HEAP32[$2 + 56 >> 2]; + $3 = HEAP32[$2 + 52 >> 2]; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 20 >> 2] = $0; + $3 = HEAP32[$2 + 48 >> 2]; + $0 = HEAP32[$2 + 44 >> 2]; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 12 >> 2] = $3; + break label$1; + } + if (!(!(HEAPF32[$1 + 68 >> 2] <= Math_fround(0)) | !(HEAPF32[$1 + 44 >> 2] <= Math_fround(0)))) { + HEAPF32[$2 + 96 >> 2] = 1; + HEAP32[$2 + 108 >> 2] = 1; + $0 = HEAP32[$2 + 76 >> 2]; + $3 = HEAP32[$2 + 72 >> 2]; + HEAP32[$2 >> 2] = $3; + HEAP32[$2 + 4 >> 2] = $0; + HEAP32[$2 + 32 >> 2] = HEAP32[$2 + 104 >> 2]; + $3 = HEAP32[$2 + 100 >> 2]; + $0 = HEAP32[$2 + 96 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 28 >> 2] = $3; + $0 = HEAP32[$2 + 92 >> 2]; + $3 = HEAP32[$2 + 88 >> 2]; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 20 >> 2] = $0; + $3 = HEAP32[$2 + 84 >> 2]; + $0 = HEAP32[$2 + 80 >> 2]; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 12 >> 2] = $3; + break label$1; + } + if (!(!(HEAPF32[$1 + 32 >> 2] <= Math_fround(0)) | (!(HEAPF32[$1 + 44 >> 2] > Math_fround(0)) | !(HEAPF32[$1 + 40 >> 2] > Math_fround(0))))) { + HEAPF32[$1 + 12 >> 2] = Math_fround(1) / Math_fround(HEAPF32[$1 + 44 >> 2] + HEAPF32[$1 + 40 >> 2]); + HEAPF32[$2 + 60 >> 2] = HEAPF32[$1 + 44 >> 2] * HEAPF32[$1 + 12 >> 2]; + HEAPF32[$2 + 96 >> 2] = HEAPF32[$1 + 40 >> 2] * HEAPF32[$1 + 12 >> 2]; + HEAP32[$2 + 108 >> 2] = 2; + $0 = HEAP32[$2 + 76 >> 2]; + $3 = HEAP32[$2 + 72 >> 2]; + HEAP32[$2 >> 2] = $3; + HEAP32[$2 + 4 >> 2] = $0; + HEAP32[$2 + 32 >> 2] = HEAP32[$2 + 104 >> 2]; + $3 = HEAP32[$2 + 100 >> 2]; + $0 = HEAP32[$2 + 96 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 28 >> 2] = $3; + $0 = HEAP32[$2 + 92 >> 2]; + $3 = HEAP32[$2 + 88 >> 2]; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 20 >> 2] = $0; + $3 = HEAP32[$2 + 84 >> 2]; + $0 = HEAP32[$2 + 80 >> 2]; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 12 >> 2] = $3; + break label$1; + } + HEAPF32[$1 + 8 >> 2] = Math_fround(1) / Math_fround(Math_fround(HEAPF32[$1 + 32 >> 2] + HEAPF32[$1 + 28 >> 2]) + HEAPF32[$1 + 24 >> 2]); + HEAPF32[$2 + 24 >> 2] = HEAPF32[$1 + 32 >> 2] * HEAPF32[$1 + 8 >> 2]; + HEAPF32[$2 + 60 >> 2] = HEAPF32[$1 + 28 >> 2] * HEAPF32[$1 + 8 >> 2]; + HEAPF32[$2 + 96 >> 2] = HEAPF32[$1 + 24 >> 2] * HEAPF32[$1 + 8 >> 2]; + HEAP32[$2 + 108 >> 2] = 3; + } + __stack_pointer = $1 + 144 | 0; +} + +function b2PulleyJoint__InitVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 208 | 0; + __stack_pointer = $2; + HEAP32[$2 + 204 >> 2] = $0; + HEAP32[$2 + 200 >> 2] = $1; + $1 = HEAP32[$2 + 204 >> 2]; + HEAP32[$1 + 120 >> 2] = HEAP32[HEAP32[$1 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 124 >> 2] = HEAP32[HEAP32[$1 + 52 >> 2] + 8 >> 2]; + $4 = HEAP32[$1 + 48 >> 2]; + $3 = HEAP32[$4 + 28 >> 2]; + $0 = HEAP32[$4 + 32 >> 2]; + HEAP32[$1 + 160 >> 2] = $3; + HEAP32[$1 + 164 >> 2] = $0; + $4 = HEAP32[$1 + 52 >> 2]; + $0 = HEAP32[$4 + 28 >> 2]; + $3 = HEAP32[$4 + 32 >> 2]; + HEAP32[$1 + 168 >> 2] = $0; + HEAP32[$1 + 172 >> 2] = $3; + HEAPF32[$1 + 176 >> 2] = HEAPF32[HEAP32[$1 + 48 >> 2] + 120 >> 2]; + HEAPF32[$1 + 180 >> 2] = HEAPF32[HEAP32[$1 + 52 >> 2] + 120 >> 2]; + HEAPF32[$1 + 184 >> 2] = HEAPF32[HEAP32[$1 + 48 >> 2] + 128 >> 2]; + HEAPF32[$1 + 188 >> 2] = HEAPF32[HEAP32[$1 + 52 >> 2] + 128 >> 2]; + $4 = HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 120 >> 2], 12) | 0; + $3 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 192 >> 2] = $3; + HEAP32[$2 + 196 >> 2] = $0; + HEAPF32[$2 + 188 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 120 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 120 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $3 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 176 >> 2] = $0; + HEAP32[$2 + 180 >> 2] = $3; + HEAPF32[$2 + 172 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 120 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 124 >> 2], 12) | 0; + $3 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 160 >> 2] = $3; + HEAP32[$2 + 164 >> 2] = $0; + HEAPF32[$2 + 156 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 124 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 124 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $3 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 144 >> 2] = $0; + HEAP32[$2 + 148 >> 2] = $3; + HEAPF32[$2 + 140 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 124 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 132 | 0, HEAPF32[$2 + 188 >> 2]); + b2Rot__b2Rot_28float_29($2 + 124 | 0, HEAPF32[$2 + 156 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 108 | 0, $1 + 92 | 0, $1 + 160 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 116 | 0, $2 + 132 | 0, $2 + 108 | 0); + $0 = HEAP32[$2 + 120 >> 2]; + $3 = HEAP32[$2 + 116 >> 2]; + HEAP32[$1 + 144 >> 2] = $3; + HEAP32[$1 + 148 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 92 | 0, $1 + 100 | 0, $1 + 168 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 100 | 0, $2 + 124 | 0, $2 + 92 | 0); + $3 = HEAP32[$2 + 104 >> 2]; + $0 = HEAP32[$2 + 100 >> 2]; + HEAP32[$1 + 152 >> 2] = $0; + HEAP32[$1 + 156 >> 2] = $3; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 76 | 0, $2 + 192 | 0, $1 + 144 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 84 | 0, $2 + 76 | 0, $1 + 68 | 0); + $0 = HEAP32[$2 + 88 >> 2]; + $3 = HEAP32[$2 + 84 >> 2]; + HEAP32[$1 + 128 >> 2] = $3; + HEAP32[$1 + 132 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 60 | 0, $2 + 160 | 0, $1 + 152 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 68 | 0, $2 + 60 | 0, $1 + 76 | 0); + $3 = HEAP32[$2 + 72 >> 2]; + $0 = HEAP32[$2 + 68 >> 2]; + HEAP32[$1 + 136 >> 2] = $0; + HEAP32[$1 + 140 >> 2] = $3; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Vec2__Length_28_29_20const($1 + 128 | 0), + HEAPF32[wasm2js_i32$0 + 56 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Vec2__Length_28_29_20const($1 + 136 | 0), + HEAPF32[wasm2js_i32$0 + 52 >> 2] = wasm2js_f32$0; + label$1: { + if (HEAPF32[$2 + 56 >> 2] > Math_fround(.04999999701976776)) { + b2Vec2__operator___28float_29($1 + 128 | 0, Math_fround(Math_fround(1) / HEAPF32[$2 + 56 >> 2])); + break label$1; + } + b2Vec2__SetZero_28_29($1 + 128 | 0); + } + label$3: { + if (HEAPF32[$2 + 52 >> 2] > Math_fround(.04999999701976776)) { + b2Vec2__operator___28float_29($1 + 136 | 0, Math_fround(Math_fround(1) / HEAPF32[$2 + 52 >> 2])); + break label$3; + } + b2Vec2__SetZero_28_29($1 + 136 | 0); + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 144 | 0, $1 + 128 | 0), + HEAPF32[wasm2js_i32$0 + 48 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 152 | 0, $1 + 136 | 0), + HEAPF32[wasm2js_i32$0 + 44 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 40 >> 2] = Math_fround(Math_fround(HEAPF32[$1 + 184 >> 2] * HEAPF32[$2 + 48 >> 2]) * HEAPF32[$2 + 48 >> 2]) + HEAPF32[$1 + 176 >> 2]; + HEAPF32[$2 + 36 >> 2] = Math_fround(Math_fround(HEAPF32[$1 + 188 >> 2] * HEAPF32[$2 + 44 >> 2]) * HEAPF32[$2 + 44 >> 2]) + HEAPF32[$1 + 180 >> 2]; + HEAPF32[$1 + 192 >> 2] = Math_fround(Math_fround(HEAPF32[$1 + 112 >> 2] * HEAPF32[$1 + 112 >> 2]) * HEAPF32[$2 + 36 >> 2]) + HEAPF32[$2 + 40 >> 2]; + if (HEAPF32[$1 + 192 >> 2] > Math_fround(0)) { + HEAPF32[$1 + 192 >> 2] = Math_fround(1) / HEAPF32[$1 + 192 >> 2]; + } + label$6: { + if (HEAP8[HEAP32[$2 + 200 >> 2] + 20 | 0] & 1) { + HEAPF32[$1 + 116 >> 2] = HEAPF32[$1 + 116 >> 2] * HEAPF32[HEAP32[$2 + 200 >> 2] + 8 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 28 | 0, Math_fround(-HEAPF32[$1 + 116 >> 2]), $1 + 128 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, Math_fround(Math_fround(-HEAPF32[$1 + 112 >> 2]) * HEAPF32[$1 + 116 >> 2]), $1 + 136 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$1 + 176 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 176 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$1 + 184 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 144 | 0, $2 + 28 | 0)) + HEAPF32[$2 + 172 >> 2]), + HEAPF32[wasm2js_i32$0 + 172 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 4 | 0, HEAPF32[$1 + 180 >> 2], $2 + 20 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 144 | 0, $2 + 4 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$1 + 188 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 152 | 0, $2 + 20 | 0)) + HEAPF32[$2 + 140 >> 2]), + HEAPF32[wasm2js_i32$0 + 140 >> 2] = wasm2js_f32$0; + break label$6; + } + HEAPF32[$1 + 116 >> 2] = 0; + } + $0 = HEAP32[$2 + 180 >> 2]; + $3 = HEAP32[$2 + 176 >> 2]; + $4 = $3; + $3 = HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 120 >> 2], 12) | 0; + HEAP32[$3 >> 2] = $4; + HEAP32[$3 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 120 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 172 >> 2]; + $3 = HEAP32[$2 + 148 >> 2]; + $0 = HEAP32[$2 + 144 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 124 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $3; + HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 124 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 140 >> 2]; + __stack_pointer = $2 + 208 | 0; +} + +function b2MotorJoint__InitVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 224 | 0; + __stack_pointer = $2; + HEAP32[$2 + 220 >> 2] = $0; + HEAP32[$2 + 216 >> 2] = $1; + $3 = HEAP32[$2 + 220 >> 2]; + HEAP32[$3 + 104 >> 2] = HEAP32[HEAP32[$3 + 48 >> 2] + 8 >> 2]; + HEAP32[$3 + 108 >> 2] = HEAP32[HEAP32[$3 + 52 >> 2] + 8 >> 2]; + $4 = HEAP32[$3 + 48 >> 2]; + $0 = HEAP32[$4 + 28 >> 2]; + $1 = HEAP32[$4 + 32 >> 2]; + HEAP32[$3 + 128 >> 2] = $0; + HEAP32[$3 + 132 >> 2] = $1; + $4 = HEAP32[$3 + 52 >> 2]; + $1 = HEAP32[$4 + 28 >> 2]; + $0 = HEAP32[$4 + 32 >> 2]; + HEAP32[$3 + 136 >> 2] = $1; + HEAP32[$3 + 140 >> 2] = $0; + HEAPF32[$3 + 156 >> 2] = HEAPF32[HEAP32[$3 + 48 >> 2] + 120 >> 2]; + HEAPF32[$3 + 160 >> 2] = HEAPF32[HEAP32[$3 + 52 >> 2] + 120 >> 2]; + HEAPF32[$3 + 164 >> 2] = HEAPF32[HEAP32[$3 + 48 >> 2] + 128 >> 2]; + HEAPF32[$3 + 168 >> 2] = HEAPF32[HEAP32[$3 + 52 >> 2] + 128 >> 2]; + $4 = HEAP32[HEAP32[$2 + 216 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 208 >> 2] = $0; + HEAP32[$2 + 212 >> 2] = $1; + HEAPF32[$2 + 204 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 216 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 216 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 192 >> 2] = $1; + HEAP32[$2 + 196 >> 2] = $0; + HEAPF32[$2 + 188 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 216 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 216 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 176 >> 2] = $0; + HEAP32[$2 + 180 >> 2] = $1; + HEAPF32[$2 + 172 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 216 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 216 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 160 >> 2] = $1; + HEAP32[$2 + 164 >> 2] = $0; + HEAPF32[$2 + 156 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 216 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 148 | 0, HEAPF32[$2 + 204 >> 2]); + b2Rot__b2Rot_28float_29($2 + 140 | 0, HEAPF32[$2 + 172 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 124 | 0, $3 + 68 | 0, $3 + 128 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 132 | 0, $2 + 148 | 0, $2 + 124 | 0); + $1 = HEAP32[$2 + 136 >> 2]; + $0 = HEAP32[$2 + 132 >> 2]; + HEAP32[$3 + 112 >> 2] = $0; + HEAP32[$3 + 116 >> 2] = $1; + b2Vec2__operator__28_29_20const($2 + 108 | 0, $3 + 136 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 116 | 0, $2 + 140 | 0, $2 + 108 | 0); + $0 = HEAP32[$2 + 120 >> 2]; + $1 = HEAP32[$2 + 116 >> 2]; + HEAP32[$3 + 120 >> 2] = $1; + HEAP32[$3 + 124 >> 2] = $0; + HEAPF32[$2 + 104 >> 2] = HEAPF32[$3 + 156 >> 2]; + HEAPF32[$2 + 100 >> 2] = HEAPF32[$3 + 160 >> 2]; + HEAPF32[$2 + 96 >> 2] = HEAPF32[$3 + 164 >> 2]; + HEAPF32[$2 + 92 >> 2] = HEAPF32[$3 + 168 >> 2]; + b2Mat22__b2Mat22_28_29($2 + 76 | 0); + HEAPF32[$2 + 76 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 92 >> 2] * HEAPF32[$3 + 124 >> 2]) * HEAPF32[$3 + 124 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 96 >> 2] * HEAPF32[$3 + 116 >> 2]) * HEAPF32[$3 + 116 >> 2]) + Math_fround(HEAPF32[$2 + 104 >> 2] + HEAPF32[$2 + 100 >> 2])); + HEAPF32[$2 + 80 >> 2] = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 96 >> 2]) * HEAPF32[$3 + 112 >> 2]) * HEAPF32[$3 + 116 >> 2]) - Math_fround(Math_fround(HEAPF32[$2 + 92 >> 2] * HEAPF32[$3 + 120 >> 2]) * HEAPF32[$3 + 124 >> 2]); + HEAPF32[$2 + 84 >> 2] = HEAPF32[$2 + 80 >> 2]; + HEAPF32[$2 + 88 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 92 >> 2] * HEAPF32[$3 + 120 >> 2]) * HEAPF32[$3 + 120 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 96 >> 2] * HEAPF32[$3 + 112 >> 2]) * HEAPF32[$3 + 112 >> 2]) + Math_fround(HEAPF32[$2 + 104 >> 2] + HEAPF32[$2 + 100 >> 2])); + b2Mat22__GetInverse_28_29_20const($2 + 60 | 0, $2 + 76 | 0); + $1 = HEAP32[$2 + 64 >> 2]; + $0 = HEAP32[$2 + 60 >> 2]; + HEAP32[$3 + 172 >> 2] = $0; + HEAP32[$3 + 176 >> 2] = $1; + $0 = HEAP32[$2 + 72 >> 2]; + $1 = HEAP32[$2 + 68 >> 2]; + HEAP32[$3 + 180 >> 2] = $1; + HEAP32[$3 + 184 >> 2] = $0; + HEAPF32[$3 + 188 >> 2] = HEAPF32[$2 + 96 >> 2] + HEAPF32[$2 + 92 >> 2]; + if (HEAPF32[$3 + 188 >> 2] > Math_fround(0)) { + HEAPF32[$3 + 188 >> 2] = Math_fround(1) / HEAPF32[$3 + 188 >> 2]; + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 36 | 0, $2 + 176 | 0, $3 + 120 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 44 | 0, $2 + 36 | 0, $2 + 208 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 52 | 0, $2 + 44 | 0, $3 + 112 | 0); + $1 = HEAP32[$2 + 56 >> 2]; + $0 = HEAP32[$2 + 52 >> 2]; + HEAP32[$3 + 144 >> 2] = $0; + HEAP32[$3 + 148 >> 2] = $1; + HEAPF32[$3 + 152 >> 2] = Math_fround(HEAPF32[$2 + 172 >> 2] - HEAPF32[$2 + 204 >> 2]) - HEAPF32[$3 + 76 >> 2]; + label$2: { + if (HEAP8[HEAP32[$2 + 216 >> 2] + 20 | 0] & 1) { + b2Vec2__operator___28float_29($3 + 80 | 0, HEAPF32[HEAP32[$2 + 216 >> 2] + 8 >> 2]); + HEAPF32[$3 + 88 >> 2] = HEAPF32[$3 + 88 >> 2] * HEAPF32[HEAP32[$2 + 216 >> 2] + 8 >> 2]; + b2Vec2__b2Vec2_28float_2c_20float_29($2 + 28 | 0, HEAPF32[$3 + 80 >> 2], HEAPF32[$3 + 84 >> 2]); + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, HEAPF32[$2 + 104 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 192 | 0, $2 + 20 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 96 >> 2]) * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 112 | 0, $2 + 28 | 0) + HEAPF32[$3 + 88 >> 2])) + HEAPF32[$2 + 188 >> 2]), + HEAPF32[wasm2js_i32$0 + 188 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$2 + 100 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 160 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$2 + 92 >> 2] * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 120 | 0, $2 + 28 | 0) + HEAPF32[$3 + 88 >> 2])) + HEAPF32[$2 + 156 >> 2]), + HEAPF32[wasm2js_i32$0 + 156 >> 2] = wasm2js_f32$0; + break label$2; + } + b2Vec2__SetZero_28_29($3 + 80 | 0); + HEAPF32[$3 + 88 >> 2] = 0; + } + $0 = HEAP32[$2 + 196 >> 2]; + $1 = HEAP32[$2 + 192 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 216 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 216 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 188 >> 2]; + $1 = HEAP32[$2 + 164 >> 2]; + $0 = HEAP32[$2 + 160 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 216 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 216 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 156 >> 2]; + __stack_pointer = $2 + 224 | 0; +} + +function emscripten__class__std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___2c_20emscripten__internal__NoBaseClass__20emscripten__register_vector_b2Vec2__28char_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 256 | 0; + __stack_pointer = $1; + HEAP32[$1 + 80 >> 2] = $0; + HEAP32[$1 + 76 >> 2] = 0; + HEAP32[$1 + 72 >> 2] = 422; + HEAP32[$1 + 68 >> 2] = 0; + HEAP32[$1 + 64 >> 2] = 423; + HEAP32[$1 + 60 >> 2] = 0; + HEAP32[$1 + 56 >> 2] = 424; + $0 = HEAP32[$1 + 80 >> 2]; + HEAP32[$1 + 104 >> 2] = $1 + 55; + HEAP32[$1 + 100 >> 2] = $0; + void_20emscripten__internal__NoBaseClass__verify_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28_29(); + HEAP32[$1 + 96 >> 2] = 425; + wasm2js_i32$0 = $1, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 92 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 88 >> 2] = wasm2js_i32$1; + HEAP32[$1 + 84 >> 2] = 426; + $0 = emscripten__internal__TypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$1 + 240 >> 2] = HEAP32[$1 + 96 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$1 + 96 >> 2]; + HEAP32[$1 + 112 >> 2] = HEAP32[$1 + 92 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$1 + 92 >> 2]; + HEAP32[$1 + 108 >> 2] = HEAP32[$1 + 88 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$1 + 88 >> 2]; + $11 = HEAP32[$1 + 100 >> 2]; + HEAP32[$1 + 244 >> 2] = HEAP32[$1 + 84 >> 2]; + _embind_register_class($0 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$1 + 84 >> 2]); + HEAP32[$1 + 116 >> 2] = $1 + 55; + HEAP32[$1 + 252 >> 2] = HEAP32[$1 + 116 >> 2]; + HEAP32[$1 + 248 >> 2] = 427; + $3 = HEAP32[$1 + 252 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____20_28__29_28_29___invoke_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____20_28__29_28_29_29(HEAP32[$1 + 248 >> 2]); + $0 = HEAP32[$1 + 72 >> 2]; + HEAP32[$1 + 48 >> 2] = HEAP32[$1 + 76 >> 2]; + HEAP32[$1 + 44 >> 2] = $0; + $0 = HEAP32[$1 + 48 >> 2]; + $2 = HEAP32[$1 + 44 >> 2]; + HEAP32[$1 + 120 >> 2] = $2; + HEAP32[$1 + 124 >> 2] = $0; + $0 = HEAP32[$1 + 120 >> 2]; + $2 = HEAP32[$1 + 124 >> 2]; + HEAP32[$1 + 148 >> 2] = $3; + HEAP32[$1 + 144 >> 2] = 7037; + HEAP32[$1 + 140 >> 2] = $2; + HEAP32[$1 + 136 >> 2] = $0; + $3 = HEAP32[$1 + 148 >> 2]; + $4 = HEAP32[$1 + 144 >> 2]; + $0 = HEAP32[$1 + 136 >> 2]; + HEAP32[$1 + 132 >> 2] = HEAP32[$1 + 140 >> 2]; + HEAP32[$1 + 128 >> 2] = $0; + $2 = HEAP32[$1 + 132 >> 2]; + $0 = HEAP32[$1 + 128 >> 2]; + HEAP32[$1 + 16 >> 2] = $0; + HEAP32[$1 + 20 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28b2Vec2_20const__29___invoke_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28char_20const__2c_20void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28b2Vec2_20const__29_29($4, $1 + 16 | 0); + $0 = HEAP32[$1 + 64 >> 2]; + HEAP32[$1 + 40 >> 2] = HEAP32[$1 + 68 >> 2]; + HEAP32[$1 + 36 >> 2] = $0; + $0 = HEAP32[$1 + 40 >> 2]; + $2 = HEAP32[$1 + 36 >> 2]; + HEAP32[$1 + 152 >> 2] = $2; + HEAP32[$1 + 156 >> 2] = $0; + $0 = HEAP32[$1 + 152 >> 2]; + $2 = HEAP32[$1 + 156 >> 2]; + HEAP32[$1 + 180 >> 2] = $3; + HEAP32[$1 + 176 >> 2] = 8590; + HEAP32[$1 + 172 >> 2] = $2; + HEAP32[$1 + 168 >> 2] = $0; + $3 = HEAP32[$1 + 180 >> 2]; + $4 = HEAP32[$1 + 176 >> 2]; + $0 = HEAP32[$1 + 168 >> 2]; + HEAP32[$1 + 164 >> 2] = HEAP32[$1 + 172 >> 2]; + HEAP32[$1 + 160 >> 2] = $0; + $2 = HEAP32[$1 + 164 >> 2]; + $0 = HEAP32[$1 + 160 >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 + 12 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28unsigned_20long_2c_20b2Vec2_20const__29___invoke_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28char_20const__2c_20void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28unsigned_20long_2c_20b2Vec2_20const__29_29($4, $1 + 8 | 0); + $0 = HEAP32[$1 + 56 >> 2]; + HEAP32[$1 + 32 >> 2] = HEAP32[$1 + 60 >> 2]; + HEAP32[$1 + 28 >> 2] = $0; + $0 = HEAP32[$1 + 32 >> 2]; + $2 = HEAP32[$1 + 28 >> 2]; + HEAP32[$1 + 184 >> 2] = $2; + HEAP32[$1 + 188 >> 2] = $0; + $0 = HEAP32[$1 + 184 >> 2]; + $2 = HEAP32[$1 + 188 >> 2]; + HEAP32[$1 + 212 >> 2] = $3; + HEAP32[$1 + 208 >> 2] = 8601; + HEAP32[$1 + 204 >> 2] = $2; + HEAP32[$1 + 200 >> 2] = $0; + $3 = HEAP32[$1 + 212 >> 2]; + $4 = HEAP32[$1 + 208 >> 2]; + $0 = HEAP32[$1 + 200 >> 2]; + HEAP32[$1 + 196 >> 2] = HEAP32[$1 + 204 >> 2]; + HEAP32[$1 + 192 >> 2] = $0; + $2 = HEAP32[$1 + 196 >> 2]; + $0 = HEAP32[$1 + 192 >> 2]; + HEAP32[$1 >> 2] = $0; + HEAP32[$1 + 4 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28_29_20const___invoke_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28char_20const__2c_20unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28_29_20const_29($4, $1); + HEAP32[$1 + 224 >> 2] = $3; + HEAP32[$1 + 220 >> 2] = 3015; + HEAP32[$1 + 216 >> 2] = 428; + $0 = HEAP32[$1 + 224 >> 2]; + void_20emscripten__internal__RegisterClassMethod_emscripten__val_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29___invoke_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28char_20const__2c_20emscripten__val_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29_29(HEAP32[$1 + 220 >> 2], HEAP32[$1 + 216 >> 2]); + HEAP32[$1 + 236 >> 2] = $0; + HEAP32[$1 + 232 >> 2] = 2962; + HEAP32[$1 + 228 >> 2] = 429; + void_20emscripten__internal__RegisterClassMethod_bool_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29___invoke_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28char_20const__2c_20bool_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29_29(HEAP32[$1 + 232 >> 2], HEAP32[$1 + 228 >> 2]); + __stack_pointer = $1 + 256 | 0; +} + +function b2RevoluteJoint__SolvePositionConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 208 | 0; + __stack_pointer = $2; + HEAP32[$2 + 204 >> 2] = $0; + HEAP32[$2 + 200 >> 2] = $1; + $3 = HEAP32[$2 + 204 >> 2]; + $4 = HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 132 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 192 >> 2] = $1; + HEAP32[$2 + 196 >> 2] = $0; + HEAPF32[$2 + 188 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 132 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 136 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 176 >> 2] = $0; + HEAP32[$2 + 180 >> 2] = $1; + HEAPF32[$2 + 172 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 136 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 164 | 0, HEAPF32[$2 + 188 >> 2]); + b2Rot__b2Rot_28float_29($2 + 156 | 0, HEAPF32[$2 + 172 >> 2]); + HEAPF32[$2 + 152 >> 2] = 0; + HEAPF32[$2 + 148 >> 2] = 0; + HEAP8[$2 + 147 | 0] = Math_fround(HEAPF32[$3 + 180 >> 2] + HEAPF32[$3 + 184 >> 2]) == Math_fround(0); + HEAP8[$2 + 146 | 0] = 0; + if (!(!(HEAP8[$3 + 116 | 0] & 1) | HEAP8[$2 + 147 | 0] & 1)) { + HEAPF32[$2 + 140 >> 2] = Math_fround(HEAPF32[$2 + 172 >> 2] - HEAPF32[$2 + 188 >> 2]) - HEAPF32[$3 + 120 >> 2]; + HEAPF32[$2 + 136 >> 2] = 0; + label$2: { + if (float_20b2Abs_float__28float_29(Math_fround(HEAPF32[$3 + 128 >> 2] - HEAPF32[$3 + 124 >> 2])) < Math_fround(.06981317698955536)) { + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Clamp_float__28float_2c_20float_2c_20float_29(Math_fround(HEAPF32[$2 + 140 >> 2] - HEAPF32[$3 + 124 >> 2]), Math_fround(-.13962635397911072), Math_fround(.13962635397911072)), + HEAPF32[wasm2js_i32$0 + 136 >> 2] = wasm2js_f32$0; + break label$2; + } + label$4: { + if (HEAPF32[$2 + 140 >> 2] <= HEAPF32[$3 + 124 >> 2]) { + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Clamp_float__28float_2c_20float_2c_20float_29(Math_fround(Math_fround(HEAPF32[$2 + 140 >> 2] - HEAPF32[$3 + 124 >> 2]) + Math_fround(.03490658849477768)), Math_fround(-.13962635397911072), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 136 >> 2] = wasm2js_f32$0; + break label$4; + } + if (HEAPF32[$2 + 140 >> 2] >= HEAPF32[$3 + 128 >> 2]) { + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Clamp_float__28float_2c_20float_2c_20float_29(Math_fround(Math_fround(HEAPF32[$2 + 140 >> 2] - HEAPF32[$3 + 128 >> 2]) + Math_fround(-.03490658849477768)), Math_fround(0), Math_fround(.13962635397911072)), + HEAPF32[wasm2js_i32$0 + 136 >> 2] = wasm2js_f32$0; + } + } + } + HEAPF32[$2 + 132 >> 2] = Math_fround(-HEAPF32[$3 + 208 >> 2]) * HEAPF32[$2 + 136 >> 2]; + HEAPF32[$2 + 188 >> 2] = Math_fround(Math_fround(-HEAPF32[$3 + 180 >> 2]) * HEAPF32[$2 + 132 >> 2]) + HEAPF32[$2 + 188 >> 2]; + HEAPF32[$2 + 172 >> 2] = Math_fround(HEAPF32[$3 + 184 >> 2] * HEAPF32[$2 + 132 >> 2]) + HEAPF32[$2 + 172 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Abs_float__28float_29(HEAPF32[$2 + 136 >> 2]), + HEAPF32[wasm2js_i32$0 + 152 >> 2] = wasm2js_f32$0; + } + b2Rot__Set_28float_29($2 + 164 | 0, HEAPF32[$2 + 188 >> 2]); + b2Rot__Set_28float_29($2 + 156 | 0, HEAPF32[$2 + 172 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 116 | 0, $3 + 68 | 0, $3 + 156 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 124 | 0, $2 + 164 | 0, $2 + 116 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 100 | 0, $3 + 76 | 0, $3 + 164 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 108 | 0, $2 + 156 | 0, $2 + 100 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 76 | 0, $2 + 176 | 0, $2 + 108 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 84 | 0, $2 + 76 | 0, $2 + 192 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 92 | 0, $2 + 84 | 0, $2 + 124 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Vec2__Length_28_29_20const($2 + 92 | 0), HEAPF32[wasm2js_i32$0 + 148 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 72 >> 2] = HEAPF32[$3 + 172 >> 2]; + HEAPF32[$2 + 68 >> 2] = HEAPF32[$3 + 176 >> 2]; + HEAPF32[$2 + 64 >> 2] = HEAPF32[$3 + 180 >> 2]; + HEAPF32[$2 + 60 >> 2] = HEAPF32[$3 + 184 >> 2]; + b2Mat22__b2Mat22_28_29($2 + 44 | 0); + HEAPF32[$2 + 44 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 60 >> 2] * HEAPF32[$2 + 112 >> 2]) * HEAPF32[$2 + 112 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 64 >> 2] * HEAPF32[$2 + 128 >> 2]) * HEAPF32[$2 + 128 >> 2]) + Math_fround(HEAPF32[$2 + 72 >> 2] + HEAPF32[$2 + 68 >> 2])); + HEAPF32[$2 + 48 >> 2] = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 64 >> 2]) * HEAPF32[$2 + 124 >> 2]) * HEAPF32[$2 + 128 >> 2]) - Math_fround(Math_fround(HEAPF32[$2 + 60 >> 2] * HEAPF32[$2 + 108 >> 2]) * HEAPF32[$2 + 112 >> 2]); + HEAPF32[$2 + 52 >> 2] = HEAPF32[$2 + 48 >> 2]; + HEAPF32[$2 + 56 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 60 >> 2] * HEAPF32[$2 + 108 >> 2]) * HEAPF32[$2 + 108 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 64 >> 2] * HEAPF32[$2 + 124 >> 2]) * HEAPF32[$2 + 124 >> 2]) + Math_fround(HEAPF32[$2 + 72 >> 2] + HEAPF32[$2 + 68 >> 2])); + b2Mat22__Solve_28b2Vec2_20const__29_20const($2 + 28 | 0, $2 + 44 | 0, $2 + 92 | 0); + b2Vec2__operator__28_29_20const($2 + 36 | 0, $2 + 28 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, HEAPF32[$2 + 72 >> 2], $2 + 36 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 192 | 0, $2 + 20 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 64 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 124 | 0, $2 + 36 | 0)) + HEAPF32[$2 + 188 >> 2]), + HEAPF32[wasm2js_i32$0 + 188 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$2 + 68 >> 2], $2 + 36 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 176 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$2 + 60 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 108 | 0, $2 + 36 | 0)) + HEAPF32[$2 + 172 >> 2]), + HEAPF32[wasm2js_i32$0 + 172 >> 2] = wasm2js_f32$0; + $0 = HEAP32[$2 + 196 >> 2]; + $1 = HEAP32[$2 + 192 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 132 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 132 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 188 >> 2]; + $1 = HEAP32[$2 + 180 >> 2]; + $0 = HEAP32[$2 + 176 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 136 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 200 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 136 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 172 >> 2]; + __stack_pointer = $2 + 208 | 0; + $5 = HEAPF32[$2 + 148 >> 2] <= Math_fround(.004999999888241291) ? HEAPF32[$2 + 152 >> 2] <= Math_fround(.03490658849477768) : $5; + return $5 | 0; +} + +function b2ContactSolver__SolvePositionConstraints_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer - 272 | 0; + __stack_pointer = $1; + HEAP32[$1 + 268 >> 2] = $0; + $4 = HEAP32[$1 + 268 >> 2]; + HEAPF32[$1 + 264 >> 2] = 0; + HEAP32[$1 + 260 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 260 >> 2] < HEAP32[$4 + 48 >> 2]) { + HEAP32[$1 + 256 >> 2] = HEAP32[$4 + 36 >> 2] + Math_imul(HEAP32[$1 + 260 >> 2], 88); + HEAP32[$1 + 252 >> 2] = HEAP32[HEAP32[$1 + 256 >> 2] + 32 >> 2]; + HEAP32[$1 + 248 >> 2] = HEAP32[HEAP32[$1 + 256 >> 2] + 36 >> 2]; + $2 = HEAP32[$1 + 256 >> 2]; + $3 = HEAP32[$2 + 48 >> 2]; + $0 = HEAP32[$2 + 52 >> 2]; + HEAP32[$1 + 240 >> 2] = $3; + HEAP32[$1 + 244 >> 2] = $0; + HEAPF32[$1 + 236 >> 2] = HEAPF32[HEAP32[$1 + 256 >> 2] + 40 >> 2]; + HEAPF32[$1 + 232 >> 2] = HEAPF32[HEAP32[$1 + 256 >> 2] + 64 >> 2]; + $2 = HEAP32[$1 + 256 >> 2]; + $0 = HEAP32[$2 + 56 >> 2]; + $3 = HEAP32[$2 + 60 >> 2]; + HEAP32[$1 + 224 >> 2] = $0; + HEAP32[$1 + 228 >> 2] = $3; + HEAPF32[$1 + 220 >> 2] = HEAPF32[HEAP32[$1 + 256 >> 2] + 44 >> 2]; + HEAPF32[$1 + 216 >> 2] = HEAPF32[HEAP32[$1 + 256 >> 2] + 68 >> 2]; + HEAP32[$1 + 212 >> 2] = HEAP32[HEAP32[$1 + 256 >> 2] + 84 >> 2]; + $2 = HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$1 + 252 >> 2], 12) | 0; + $3 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + HEAP32[$1 + 200 >> 2] = $3; + HEAP32[$1 + 204 >> 2] = $0; + HEAPF32[$1 + 196 >> 2] = HEAPF32[(HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$1 + 252 >> 2], 12) | 0) + 8 >> 2]; + $2 = HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$1 + 248 >> 2], 12) | 0; + $0 = HEAP32[$2 >> 2]; + $3 = HEAP32[$2 + 4 >> 2]; + HEAP32[$1 + 184 >> 2] = $0; + HEAP32[$1 + 188 >> 2] = $3; + HEAPF32[$1 + 180 >> 2] = HEAPF32[(HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$1 + 248 >> 2], 12) | 0) + 8 >> 2]; + HEAP32[$1 + 176 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 176 >> 2] < HEAP32[$1 + 212 >> 2]) { + b2Transform__b2Transform_28_29($1 + 160 | 0); + b2Transform__b2Transform_28_29($1 + 144 | 0); + b2Rot__Set_28float_29($1 + 168 | 0, HEAPF32[$1 + 196 >> 2]); + b2Rot__Set_28float_29($1 + 152 | 0, HEAPF32[$1 + 180 >> 2]); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($1 + 128 | 0, $1 + 168 | 0, $1 + 240 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 136 | 0, $1 + 200 | 0, $1 + 128 | 0); + $0 = HEAP32[$1 + 140 >> 2]; + $3 = HEAP32[$1 + 136 >> 2]; + $2 = $3; + $3 = $1 + 160 | 0; + HEAP32[$3 >> 2] = $2; + HEAP32[$3 + 4 >> 2] = $0; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($1 + 112 | 0, $1 + 152 | 0, $1 + 224 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 120 | 0, $1 + 184 | 0, $1 + 112 | 0); + $3 = HEAP32[$1 + 124 >> 2]; + $0 = HEAP32[$1 + 120 >> 2]; + $2 = $0; + $0 = $1 + 144 | 0; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $3; + b2PositionSolverManifold__b2PositionSolverManifold_28_29($1 + 92 | 0); + b2PositionSolverManifold__Initialize_28b2ContactPositionConstraint__2c_20b2Transform_20const__2c_20b2Transform_20const__2c_20int_29($1 + 92 | 0, HEAP32[$1 + 256 >> 2], $1 + 160 | 0, $1 + 144 | 0, HEAP32[$1 + 176 >> 2]); + $2 = $1 + 92 | 0; + $3 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + HEAP32[$1 + 80 >> 2] = $3; + HEAP32[$1 + 84 >> 2] = $0; + $2 = $1 + 92 | 0; + $0 = HEAP32[$2 + 8 >> 2]; + $3 = HEAP32[$2 + 12 >> 2]; + HEAP32[$1 + 72 >> 2] = $0; + HEAP32[$1 + 76 >> 2] = $3; + HEAPF32[$1 + 68 >> 2] = HEAPF32[$1 + 108 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 60 | 0, $1 + 72 | 0, $1 + 200 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 52 | 0, $1 + 72 | 0, $1 + 184 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = float_20b2Min_float__28float_2c_20float_29(HEAPF32[$1 + 264 >> 2], HEAPF32[$1 + 68 >> 2]), + HEAPF32[wasm2js_i32$0 + 264 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = float_20b2Clamp_float__28float_2c_20float_2c_20float_29(Math_fround(Math_fround(HEAPF32[$1 + 68 >> 2] + Math_fround(.004999999888241291)) * Math_fround(.20000000298023224)), Math_fround(-.20000000298023224), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 48 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 60 | 0, $1 + 80 | 0), + HEAPF32[wasm2js_i32$0 + 44 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 52 | 0, $1 + 80 | 0), + HEAPF32[wasm2js_i32$0 + 40 >> 2] = wasm2js_f32$0; + HEAPF32[$1 + 36 >> 2] = Math_fround(Math_fround(HEAPF32[$1 + 216 >> 2] * HEAPF32[$1 + 40 >> 2]) * HEAPF32[$1 + 40 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$1 + 232 >> 2] * HEAPF32[$1 + 44 >> 2]) * HEAPF32[$1 + 44 >> 2]) + Math_fround(HEAPF32[$1 + 236 >> 2] + HEAPF32[$1 + 220 >> 2])); + if (HEAPF32[$1 + 36 >> 2] > Math_fround(0)) { + $5 = Math_fround(Math_fround(-HEAPF32[$1 + 48 >> 2]) / HEAPF32[$1 + 36 >> 2]); + } else { + $5 = Math_fround(0); + } + HEAPF32[$1 + 32 >> 2] = $5; + operator__28float_2c_20b2Vec2_20const__29($1 + 24 | 0, HEAPF32[$1 + 32 >> 2], $1 + 80 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 16 | 0, HEAPF32[$1 + 236 >> 2], $1 + 24 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($1 + 200 | 0, $1 + 16 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$1 + 232 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 60 | 0, $1 + 24 | 0)) + HEAPF32[$1 + 196 >> 2]), + HEAPF32[wasm2js_i32$0 + 196 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($1 + 8 | 0, HEAPF32[$1 + 220 >> 2], $1 + 24 | 0); + b2Vec2__operator___28b2Vec2_20const__29($1 + 184 | 0, $1 + 8 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$1 + 216 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 52 | 0, $1 + 24 | 0)) + HEAPF32[$1 + 180 >> 2]), + HEAPF32[wasm2js_i32$0 + 180 >> 2] = wasm2js_f32$0; + HEAP32[$1 + 176 >> 2] = HEAP32[$1 + 176 >> 2] + 1; + continue; + } + break; + } + $0 = HEAP32[$1 + 204 >> 2]; + $3 = HEAP32[$1 + 200 >> 2]; + $2 = $3; + $3 = HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$1 + 252 >> 2], 12) | 0; + HEAP32[$3 >> 2] = $2; + HEAP32[$3 + 4 >> 2] = $0; + HEAPF32[(HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$1 + 252 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$1 + 196 >> 2]; + $3 = HEAP32[$1 + 188 >> 2]; + $0 = HEAP32[$1 + 184 >> 2]; + $2 = $0; + $0 = HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$1 + 248 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $3; + HEAPF32[(HEAP32[$4 + 24 >> 2] + Math_imul(HEAP32[$1 + 248 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$1 + 180 >> 2]; + HEAP32[$1 + 260 >> 2] = HEAP32[$1 + 260 >> 2] + 1; + continue; + } + break; + } + __stack_pointer = $1 + 272 | 0; + return HEAPF32[$1 + 264 >> 2] >= Math_fround(-.014999999664723873); +} + +function emscripten__class__std____2__vector_int_2c_20std____2__allocator_int___2c_20emscripten__internal__NoBaseClass__20emscripten__register_vector_int__28char_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 256 | 0; + __stack_pointer = $1; + HEAP32[$1 + 80 >> 2] = $0; + HEAP32[$1 + 76 >> 2] = 0; + HEAP32[$1 + 72 >> 2] = 410; + HEAP32[$1 + 68 >> 2] = 0; + HEAP32[$1 + 64 >> 2] = 411; + HEAP32[$1 + 60 >> 2] = 0; + HEAP32[$1 + 56 >> 2] = 412; + $0 = HEAP32[$1 + 80 >> 2]; + HEAP32[$1 + 104 >> 2] = $1 + 55; + HEAP32[$1 + 100 >> 2] = $0; + void_20emscripten__internal__NoBaseClass__verify_std____2__vector_int_2c_20std____2__allocator_int____28_29(); + HEAP32[$1 + 96 >> 2] = 413; + wasm2js_i32$0 = $1, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getUpcaster_std____2__vector_int_2c_20std____2__allocator_int____28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 92 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = void_20_28_emscripten__internal__NoBaseClass__getDowncaster_std____2__vector_int_2c_20std____2__allocator_int____28_29_29_28_29(), + HEAP32[wasm2js_i32$0 + 88 >> 2] = wasm2js_i32$1; + HEAP32[$1 + 84 >> 2] = 414; + $0 = emscripten__internal__TypeID_std____2__vector_int_2c_20std____2__allocator_int___2c_20void___get_28_29(); + $2 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20void___get_28_29(); + $3 = emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20void___get_28_29(); + $4 = emscripten__internal__NoBaseClass__get_28_29(); + HEAP32[$1 + 232 >> 2] = HEAP32[$1 + 96 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29(); + $6 = HEAP32[$1 + 96 >> 2]; + HEAP32[$1 + 240 >> 2] = HEAP32[$1 + 92 >> 2]; + $7 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $8 = HEAP32[$1 + 92 >> 2]; + HEAP32[$1 + 236 >> 2] = HEAP32[$1 + 88 >> 2]; + $9 = char_20const__20emscripten__internal__getGenericSignature_void__28_29(); + $10 = HEAP32[$1 + 88 >> 2]; + $11 = HEAP32[$1 + 100 >> 2]; + HEAP32[$1 + 244 >> 2] = HEAP32[$1 + 84 >> 2]; + _embind_register_class($0 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, $9 | 0, $10 | 0, $11 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$1 + 84 >> 2]); + HEAP32[$1 + 108 >> 2] = $1 + 55; + HEAP32[$1 + 252 >> 2] = HEAP32[$1 + 108 >> 2]; + HEAP32[$1 + 248 >> 2] = 415; + $3 = HEAP32[$1 + 252 >> 2]; + void_20emscripten__internal__RegisterClassConstructor_std____2__vector_int_2c_20std____2__allocator_int____20_28__29_28_29___invoke_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int____20_28__29_28_29_29(HEAP32[$1 + 248 >> 2]); + $0 = HEAP32[$1 + 72 >> 2]; + HEAP32[$1 + 48 >> 2] = HEAP32[$1 + 76 >> 2]; + HEAP32[$1 + 44 >> 2] = $0; + $0 = HEAP32[$1 + 48 >> 2]; + $2 = HEAP32[$1 + 44 >> 2]; + HEAP32[$1 + 112 >> 2] = $2; + HEAP32[$1 + 116 >> 2] = $0; + $0 = HEAP32[$1 + 112 >> 2]; + $2 = HEAP32[$1 + 116 >> 2]; + HEAP32[$1 + 140 >> 2] = $3; + HEAP32[$1 + 136 >> 2] = 7037; + HEAP32[$1 + 132 >> 2] = $2; + HEAP32[$1 + 128 >> 2] = $0; + $3 = HEAP32[$1 + 140 >> 2]; + $4 = HEAP32[$1 + 136 >> 2]; + $0 = HEAP32[$1 + 128 >> 2]; + HEAP32[$1 + 124 >> 2] = HEAP32[$1 + 132 >> 2]; + HEAP32[$1 + 120 >> 2] = $0; + $2 = HEAP32[$1 + 124 >> 2]; + $0 = HEAP32[$1 + 120 >> 2]; + HEAP32[$1 + 16 >> 2] = $0; + HEAP32[$1 + 20 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28int_20const__29___invoke_std____2__vector_int_2c_20std____2__allocator_int____28char_20const__2c_20void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28int_20const__29_29($4, $1 + 16 | 0); + $0 = HEAP32[$1 + 64 >> 2]; + HEAP32[$1 + 40 >> 2] = HEAP32[$1 + 68 >> 2]; + HEAP32[$1 + 36 >> 2] = $0; + $0 = HEAP32[$1 + 40 >> 2]; + $2 = HEAP32[$1 + 36 >> 2]; + HEAP32[$1 + 144 >> 2] = $2; + HEAP32[$1 + 148 >> 2] = $0; + $0 = HEAP32[$1 + 144 >> 2]; + $2 = HEAP32[$1 + 148 >> 2]; + HEAP32[$1 + 172 >> 2] = $3; + HEAP32[$1 + 168 >> 2] = 8590; + HEAP32[$1 + 164 >> 2] = $2; + HEAP32[$1 + 160 >> 2] = $0; + $3 = HEAP32[$1 + 172 >> 2]; + $4 = HEAP32[$1 + 168 >> 2]; + $0 = HEAP32[$1 + 160 >> 2]; + HEAP32[$1 + 156 >> 2] = HEAP32[$1 + 164 >> 2]; + HEAP32[$1 + 152 >> 2] = $0; + $2 = HEAP32[$1 + 156 >> 2]; + $0 = HEAP32[$1 + 152 >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 + 12 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28unsigned_20long_2c_20int_20const__29___invoke_std____2__vector_int_2c_20std____2__allocator_int____28char_20const__2c_20void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28unsigned_20long_2c_20int_20const__29_29($4, $1 + 8 | 0); + $0 = HEAP32[$1 + 56 >> 2]; + HEAP32[$1 + 32 >> 2] = HEAP32[$1 + 60 >> 2]; + HEAP32[$1 + 28 >> 2] = $0; + $0 = HEAP32[$1 + 32 >> 2]; + $2 = HEAP32[$1 + 28 >> 2]; + HEAP32[$1 + 176 >> 2] = $2; + HEAP32[$1 + 180 >> 2] = $0; + $0 = HEAP32[$1 + 176 >> 2]; + $2 = HEAP32[$1 + 180 >> 2]; + HEAP32[$1 + 204 >> 2] = $3; + HEAP32[$1 + 200 >> 2] = 8601; + HEAP32[$1 + 196 >> 2] = $2; + HEAP32[$1 + 192 >> 2] = $0; + $3 = HEAP32[$1 + 204 >> 2]; + $4 = HEAP32[$1 + 200 >> 2]; + $0 = HEAP32[$1 + 192 >> 2]; + HEAP32[$1 + 188 >> 2] = HEAP32[$1 + 196 >> 2]; + HEAP32[$1 + 184 >> 2] = $0; + $2 = HEAP32[$1 + 188 >> 2]; + $0 = HEAP32[$1 + 184 >> 2]; + HEAP32[$1 >> 2] = $0; + HEAP32[$1 + 4 >> 2] = $2; + void_20emscripten__internal__RegisterClassMethod_unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28_29_20const___invoke_std____2__vector_int_2c_20std____2__allocator_int____28char_20const__2c_20unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28_29_20const_29($4, $1); + HEAP32[$1 + 216 >> 2] = $3; + HEAP32[$1 + 212 >> 2] = 3015; + HEAP32[$1 + 208 >> 2] = 416; + $0 = HEAP32[$1 + 216 >> 2]; + void_20emscripten__internal__RegisterClassMethod_emscripten__val_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29___invoke_std____2__vector_int_2c_20std____2__allocator_int____28char_20const__2c_20emscripten__val_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29_29(HEAP32[$1 + 212 >> 2], HEAP32[$1 + 208 >> 2]); + HEAP32[$1 + 228 >> 2] = $0; + HEAP32[$1 + 224 >> 2] = 2962; + HEAP32[$1 + 220 >> 2] = 417; + void_20emscripten__internal__RegisterClassMethod_bool_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29___invoke_std____2__vector_int_2c_20std____2__allocator_int____28char_20const__2c_20bool_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29_29(HEAP32[$1 + 224 >> 2], HEAP32[$1 + 220 >> 2]); + __stack_pointer = $1 + 256 | 0; +} + +function b2ContactSolver__b2ContactSolver_28b2ContactSolverDef__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 80 | 0; + __stack_pointer = $2; + HEAP32[$2 + 72 >> 2] = $0; + HEAP32[$2 + 68 >> 2] = $1; + $4 = HEAP32[$2 + 72 >> 2]; + HEAP32[$2 + 76 >> 2] = $4; + $3 = HEAP32[$2 + 68 >> 2]; + $0 = HEAP32[$3 >> 2]; + $1 = HEAP32[$3 + 4 >> 2]; + HEAP32[$4 >> 2] = $0; + HEAP32[$4 + 4 >> 2] = $1; + $0 = HEAP32[$3 + 20 >> 2]; + $1 = HEAP32[$3 + 16 >> 2]; + HEAP32[$4 + 16 >> 2] = $1; + HEAP32[$4 + 20 >> 2] = $0; + $1 = HEAP32[$3 + 12 >> 2]; + $0 = HEAP32[$3 + 8 >> 2]; + HEAP32[$4 + 8 >> 2] = $0; + HEAP32[$4 + 12 >> 2] = $1; + HEAP32[$4 + 32 >> 2] = HEAP32[HEAP32[$2 + 68 >> 2] + 40 >> 2]; + HEAP32[$4 + 48 >> 2] = HEAP32[HEAP32[$2 + 68 >> 2] + 28 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = b2StackAllocator__Allocate_28int_29(HEAP32[$4 + 32 >> 2], Math_imul(HEAP32[$4 + 48 >> 2], 88)), + HEAP32[wasm2js_i32$0 + 36 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $4, wasm2js_i32$1 = b2StackAllocator__Allocate_28int_29(HEAP32[$4 + 32 >> 2], Math_imul(HEAP32[$4 + 48 >> 2], 156)), + HEAP32[wasm2js_i32$0 + 40 >> 2] = wasm2js_i32$1; + HEAP32[$4 + 24 >> 2] = HEAP32[HEAP32[$2 + 68 >> 2] + 32 >> 2]; + HEAP32[$4 + 28 >> 2] = HEAP32[HEAP32[$2 + 68 >> 2] + 36 >> 2]; + HEAP32[$4 + 44 >> 2] = HEAP32[HEAP32[$2 + 68 >> 2] + 24 >> 2]; + HEAP32[$2 + 64 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 64 >> 2] < HEAP32[$4 + 48 >> 2]) { + HEAP32[$2 + 60 >> 2] = HEAP32[HEAP32[$4 + 44 >> 2] + (HEAP32[$2 + 64 >> 2] << 2) >> 2]; + HEAP32[$2 + 56 >> 2] = HEAP32[HEAP32[$2 + 60 >> 2] + 48 >> 2]; + HEAP32[$2 + 52 >> 2] = HEAP32[HEAP32[$2 + 60 >> 2] + 52 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetShape_28_29(HEAP32[$2 + 56 >> 2]), + HEAP32[wasm2js_i32$0 + 48 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetShape_28_29(HEAP32[$2 + 52 >> 2]), + HEAP32[wasm2js_i32$0 + 44 >> 2] = wasm2js_i32$1; + HEAPF32[$2 + 40 >> 2] = HEAPF32[HEAP32[$2 + 48 >> 2] + 8 >> 2]; + HEAPF32[$2 + 36 >> 2] = HEAPF32[HEAP32[$2 + 44 >> 2] + 8 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$2 + 56 >> 2]), + HEAP32[wasm2js_i32$0 + 32 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$2 + 52 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Contact__GetManifold_28_29(HEAP32[$2 + 60 >> 2]), + HEAP32[wasm2js_i32$0 + 24 >> 2] = wasm2js_i32$1; + HEAP32[$2 + 20 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 60 >> 2]; + if (HEAP32[$2 + 20 >> 2] <= 0) { + __assert_fail(12240, 5487, 78, 3833); + wasm2js_trap(); + } else { + HEAP32[$2 + 16 >> 2] = HEAP32[$4 + 40 >> 2] + Math_imul(HEAP32[$2 + 64 >> 2], 156); + HEAPF32[HEAP32[$2 + 16 >> 2] + 136 >> 2] = HEAPF32[HEAP32[$2 + 60 >> 2] + 136 >> 2]; + HEAPF32[HEAP32[$2 + 16 >> 2] + 140 >> 2] = HEAPF32[HEAP32[$2 + 60 >> 2] + 140 >> 2]; + HEAPF32[HEAP32[$2 + 16 >> 2] + 144 >> 2] = HEAPF32[HEAP32[$2 + 60 >> 2] + 144 >> 2]; + HEAP32[HEAP32[$2 + 16 >> 2] + 112 >> 2] = HEAP32[HEAP32[$2 + 32 >> 2] + 8 >> 2]; + HEAP32[HEAP32[$2 + 16 >> 2] + 116 >> 2] = HEAP32[HEAP32[$2 + 28 >> 2] + 8 >> 2]; + HEAPF32[HEAP32[$2 + 16 >> 2] + 120 >> 2] = HEAPF32[HEAP32[$2 + 32 >> 2] + 120 >> 2]; + HEAPF32[HEAP32[$2 + 16 >> 2] + 124 >> 2] = HEAPF32[HEAP32[$2 + 28 >> 2] + 120 >> 2]; + HEAPF32[HEAP32[$2 + 16 >> 2] + 128 >> 2] = HEAPF32[HEAP32[$2 + 32 >> 2] + 128 >> 2]; + HEAPF32[HEAP32[$2 + 16 >> 2] + 132 >> 2] = HEAPF32[HEAP32[$2 + 28 >> 2] + 128 >> 2]; + HEAP32[HEAP32[$2 + 16 >> 2] + 152 >> 2] = HEAP32[$2 + 64 >> 2]; + HEAP32[HEAP32[$2 + 16 >> 2] + 148 >> 2] = HEAP32[$2 + 20 >> 2]; + b2Mat22__SetZero_28_29(HEAP32[$2 + 16 >> 2] + 96 | 0); + b2Mat22__SetZero_28_29(HEAP32[$2 + 16 >> 2] + 80 | 0); + HEAP32[$2 + 12 >> 2] = HEAP32[$4 + 36 >> 2] + Math_imul(HEAP32[$2 + 64 >> 2], 88); + HEAP32[HEAP32[$2 + 12 >> 2] + 32 >> 2] = HEAP32[HEAP32[$2 + 32 >> 2] + 8 >> 2]; + HEAP32[HEAP32[$2 + 12 >> 2] + 36 >> 2] = HEAP32[HEAP32[$2 + 28 >> 2] + 8 >> 2]; + HEAPF32[HEAP32[$2 + 12 >> 2] + 40 >> 2] = HEAPF32[HEAP32[$2 + 32 >> 2] + 120 >> 2]; + HEAPF32[HEAP32[$2 + 12 >> 2] + 44 >> 2] = HEAPF32[HEAP32[$2 + 28 >> 2] + 120 >> 2]; + $3 = HEAP32[$2 + 32 >> 2]; + $1 = HEAP32[$3 + 28 >> 2]; + $0 = HEAP32[$3 + 32 >> 2]; + $3 = $1; + $1 = HEAP32[$2 + 12 >> 2]; + HEAP32[$1 + 48 >> 2] = $3; + HEAP32[$1 + 52 >> 2] = $0; + $3 = HEAP32[$2 + 28 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $1 = HEAP32[$3 + 32 >> 2]; + $3 = $0; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 + 56 >> 2] = $3; + HEAP32[$0 + 60 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 64 >> 2] = HEAPF32[HEAP32[$2 + 32 >> 2] + 128 >> 2]; + HEAPF32[HEAP32[$2 + 12 >> 2] + 68 >> 2] = HEAPF32[HEAP32[$2 + 28 >> 2] + 128 >> 2]; + $3 = HEAP32[$2 + 24 >> 2]; + $1 = HEAP32[$3 + 40 >> 2]; + $0 = HEAP32[$3 + 44 >> 2]; + $3 = $1; + $1 = HEAP32[$2 + 12 >> 2]; + HEAP32[$1 + 16 >> 2] = $3; + HEAP32[$1 + 20 >> 2] = $0; + $3 = HEAP32[$2 + 24 >> 2]; + $0 = HEAP32[$3 + 48 >> 2]; + $1 = HEAP32[$3 + 52 >> 2]; + $3 = $0; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 + 24 >> 2] = $3; + HEAP32[$0 + 28 >> 2] = $1; + HEAP32[HEAP32[$2 + 12 >> 2] + 84 >> 2] = HEAP32[$2 + 20 >> 2]; + HEAPF32[HEAP32[$2 + 12 >> 2] + 76 >> 2] = HEAPF32[$2 + 40 >> 2]; + HEAPF32[HEAP32[$2 + 12 >> 2] + 80 >> 2] = HEAPF32[$2 + 36 >> 2]; + HEAP32[HEAP32[$2 + 12 >> 2] + 72 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 56 >> 2]; + HEAP32[$2 + 8 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 8 >> 2] < HEAP32[$2 + 20 >> 2]) { + HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 24 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 20); + HEAP32[$2 >> 2] = HEAP32[$2 + 16 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 36); + label$7: { + if (HEAP8[$4 + 20 | 0] & 1) { + HEAPF32[HEAP32[$2 >> 2] + 16 >> 2] = HEAPF32[$4 + 8 >> 2] * HEAPF32[HEAP32[$2 + 4 >> 2] + 8 >> 2]; + HEAPF32[HEAP32[$2 >> 2] + 20 >> 2] = HEAPF32[$4 + 8 >> 2] * HEAPF32[HEAP32[$2 + 4 >> 2] + 12 >> 2]; + break label$7; + } + HEAPF32[HEAP32[$2 >> 2] + 16 >> 2] = 0; + HEAPF32[HEAP32[$2 >> 2] + 20 >> 2] = 0; + } + b2Vec2__SetZero_28_29(HEAP32[$2 >> 2]); + b2Vec2__SetZero_28_29(HEAP32[$2 >> 2] + 8 | 0); + HEAPF32[HEAP32[$2 >> 2] + 24 >> 2] = 0; + HEAPF32[HEAP32[$2 >> 2] + 28 >> 2] = 0; + HEAPF32[HEAP32[$2 >> 2] + 32 >> 2] = 0; + $3 = HEAP32[$2 + 4 >> 2]; + $1 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + $3 = $1; + $1 = HEAP32[$2 + 12 >> 2] + (HEAP32[$2 + 8 >> 2] << 3) | 0; + HEAP32[$1 >> 2] = $3; + HEAP32[$1 + 4 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = HEAP32[$2 + 8 >> 2] + 1; + continue; + } + break; + } + HEAP32[$2 + 64 >> 2] = HEAP32[$2 + 64 >> 2] + 1; + continue; + } + } + break; + } + __stack_pointer = $2 + 80 | 0; + return HEAP32[$2 + 76 >> 2]; +} + +function b2PolygonShape__Set_28b2Vec2_20const__2c_20int_29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 240 | 0; + __stack_pointer = $3; + HEAP32[$3 + 236 >> 2] = $0; + HEAP32[$3 + 232 >> 2] = $1; + HEAP32[$3 + 228 >> 2] = $2; + $4 = HEAP32[$3 + 236 >> 2]; + if (!(HEAP32[$3 + 228 >> 2] <= 8 & HEAP32[$3 + 228 >> 2] >= 3)) { + __assert_fail(11945, 5758, 120, 3019); + wasm2js_trap(); + } + label$3: { + if (HEAP32[$3 + 228 >> 2] < 3) { + b2PolygonShape__SetAsBox_28float_2c_20float_29($4, Math_fround(1), Math_fround(1)); + break label$3; + } + wasm2js_i32$0 = $3, wasm2js_i32$1 = int_20b2Min_int__28int_2c_20int_29(HEAP32[$3 + 228 >> 2], 8), + HEAP32[wasm2js_i32$0 + 224 >> 2] = wasm2js_i32$1; + $0 = $3 + 160 | 0; + $1 = $0 - -64 | 0; + while (1) { + b2Vec2__b2Vec2_28_29($0); + $0 = $0 + 8 | 0; + if (($1 | 0) != ($0 | 0)) { + continue; + } + break; + } + HEAP32[$3 + 156 >> 2] = 0; + HEAP32[$3 + 152 >> 2] = 0; + while (1) { + if (HEAP32[$3 + 152 >> 2] < HEAP32[$3 + 224 >> 2]) { + $1 = HEAP32[$3 + 232 >> 2] + (HEAP32[$3 + 152 >> 2] << 3) | 0; + $0 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$3 + 144 >> 2] = $0; + HEAP32[$3 + 148 >> 2] = $1; + HEAP8[$3 + 143 | 0] = 1; + HEAP32[$3 + 136 >> 2] = 0; + while (1) { + if (HEAP32[$3 + 136 >> 2] < HEAP32[$3 + 156 >> 2]) { + if (b2DistanceSquared_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 144 | 0, ($3 + 160 | 0) + (HEAP32[$3 + 136 >> 2] << 3) | 0) < Math_fround(624999984211172e-20)) { + HEAP8[$3 + 143 | 0] = 0; + } else { + HEAP32[$3 + 136 >> 2] = HEAP32[$3 + 136 >> 2] + 1; + continue; + } + } + break; + } + if (HEAP8[$3 + 143 | 0] & 1) { + $5 = HEAP32[$3 + 156 >> 2]; + HEAP32[$3 + 156 >> 2] = $5 + 1; + $0 = HEAP32[$3 + 148 >> 2]; + $1 = HEAP32[$3 + 144 >> 2]; + $2 = $1; + $1 = ($3 + 160 | 0) + ($5 << 3) | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + } + HEAP32[$3 + 152 >> 2] = HEAP32[$3 + 152 >> 2] + 1; + continue; + } + break; + } + HEAP32[$3 + 224 >> 2] = HEAP32[$3 + 156 >> 2]; + if (HEAP32[$3 + 224 >> 2] < 3) { + __assert_fail(9147, 5758, 156, 3019); + wasm2js_trap(); + } + HEAP32[$3 + 132 >> 2] = 0; + HEAPF32[$3 + 128 >> 2] = HEAPF32[$3 + 160 >> 2]; + HEAP32[$3 + 124 >> 2] = 1; + while (1) { + if (HEAP32[$3 + 124 >> 2] < HEAP32[$3 + 224 >> 2]) { + HEAPF32[$3 + 120 >> 2] = HEAPF32[($3 + 160 | 0) + (HEAP32[$3 + 124 >> 2] << 3) >> 2]; + if (!(!(HEAPF32[$3 + 120 >> 2] > HEAPF32[$3 + 128 >> 2]) & (!(HEAPF32[(($3 + 160 | 0) + (HEAP32[$3 + 124 >> 2] << 3) | 0) + 4 >> 2] < HEAPF32[(($3 + 160 | 0) + (HEAP32[$3 + 132 >> 2] << 3) | 0) + 4 >> 2]) | HEAPF32[$3 + 120 >> 2] != HEAPF32[$3 + 128 >> 2]))) { + HEAP32[$3 + 132 >> 2] = HEAP32[$3 + 124 >> 2]; + HEAPF32[$3 + 128 >> 2] = HEAPF32[$3 + 120 >> 2]; + } + HEAP32[$3 + 124 >> 2] = HEAP32[$3 + 124 >> 2] + 1; + continue; + } + break; + } + HEAP32[$3 + 76 >> 2] = 0; + HEAP32[$3 + 72 >> 2] = HEAP32[$3 + 132 >> 2]; + while (1) { + if (HEAP32[$3 + 76 >> 2] >= 8) { + __assert_fail(11987, 5758, 183, 3019); + wasm2js_trap(); + } + HEAP32[($3 + 80 | 0) + (HEAP32[$3 + 76 >> 2] << 2) >> 2] = HEAP32[$3 + 72 >> 2]; + HEAP32[$3 + 68 >> 2] = 0; + HEAP32[$3 + 64 >> 2] = 1; + while (1) { + if (HEAP32[$3 + 64 >> 2] < HEAP32[$3 + 224 >> 2]) { + label$22: { + if (HEAP32[$3 + 68 >> 2] == HEAP32[$3 + 72 >> 2]) { + HEAP32[$3 + 68 >> 2] = HEAP32[$3 + 64 >> 2]; + break label$22; + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 56 | 0, ($3 + 160 | 0) + (HEAP32[$3 + 68 >> 2] << 3) | 0, ($3 + 160 | 0) + (HEAP32[($3 + 80 | 0) + (HEAP32[$3 + 76 >> 2] << 2) >> 2] << 3) | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 48 | 0, ($3 + 160 | 0) + (HEAP32[$3 + 64 >> 2] << 3) | 0, ($3 + 160 | 0) + (HEAP32[($3 + 80 | 0) + (HEAP32[$3 + 76 >> 2] << 2) >> 2] << 3) | 0); + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 56 | 0, $3 + 48 | 0), + HEAPF32[wasm2js_i32$0 + 44 >> 2] = wasm2js_f32$0; + if (HEAPF32[$3 + 44 >> 2] < Math_fround(0)) { + HEAP32[$3 + 68 >> 2] = HEAP32[$3 + 64 >> 2]; + } + label$25: { + if (HEAPF32[$3 + 44 >> 2] != Math_fround(0)) { + break label$25; + } + if (!(b2Vec2__LengthSquared_28_29_20const($3 + 48 | 0) > b2Vec2__LengthSquared_28_29_20const($3 + 56 | 0))) { + break label$25; + } + HEAP32[$3 + 68 >> 2] = HEAP32[$3 + 64 >> 2]; + } + } + HEAP32[$3 + 64 >> 2] = HEAP32[$3 + 64 >> 2] + 1; + continue; + } + break; + } + HEAP32[$3 + 76 >> 2] = HEAP32[$3 + 76 >> 2] + 1; + HEAP32[$3 + 72 >> 2] = HEAP32[$3 + 68 >> 2]; + if (HEAP32[$3 + 68 >> 2] != HEAP32[$3 + 132 >> 2]) { + continue; + } + break; + } + if (HEAP32[$3 + 76 >> 2] < 3) { + __assert_fail(9147, 5758, 222, 3019); + wasm2js_trap(); + } + HEAP32[$4 + 148 >> 2] = HEAP32[$3 + 76 >> 2]; + HEAP32[$3 + 40 >> 2] = 0; + while (1) { + if (HEAP32[$3 + 40 >> 2] < HEAP32[$3 + 76 >> 2]) { + $1 = ($3 + 160 | 0) + (HEAP32[($3 + 80 | 0) + (HEAP32[$3 + 40 >> 2] << 2) >> 2] << 3) | 0; + $0 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + $2 = $0; + $0 = ($4 + 20 | 0) + (HEAP32[$3 + 40 >> 2] << 3) | 0; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + HEAP32[$3 + 40 >> 2] = HEAP32[$3 + 40 >> 2] + 1; + continue; + } + break; + } + HEAP32[$3 + 36 >> 2] = 0; + while (1) { + if (HEAP32[$3 + 36 >> 2] < HEAP32[$3 + 76 >> 2]) { + HEAP32[$3 + 32 >> 2] = HEAP32[$3 + 36 >> 2]; + if (HEAP32[$3 + 76 >> 2] > (HEAP32[$3 + 36 >> 2] + 1 | 0)) { + $0 = HEAP32[$3 + 36 >> 2] + 1 | 0; + } else { + $0 = 0; + } + HEAP32[$3 + 28 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 20 | 0, ($4 + 20 | 0) + (HEAP32[$3 + 28 >> 2] << 3) | 0, ($4 + 20 | 0) + (HEAP32[$3 + 32 >> 2] << 3) | 0); + if (b2Vec2__LengthSquared_28_29_20const($3 + 20 | 0) > Math_fround(14210854715202004e-30)) { + b2Cross_28b2Vec2_20const__2c_20float_29($3 + 12 | 0, $3 + 20 | 0, Math_fround(1)); + $0 = HEAP32[$3 + 16 >> 2]; + $1 = HEAP32[$3 + 12 >> 2]; + $2 = $1; + $1 = ($4 + 84 | 0) + (HEAP32[$3 + 36 >> 2] << 3) | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + b2Vec2__Normalize_28_29(($4 + 84 | 0) + (HEAP32[$3 + 36 >> 2] << 3) | 0); + HEAP32[$3 + 36 >> 2] = HEAP32[$3 + 36 >> 2] + 1; + continue; + } else { + __assert_fail(10906, 5758, 241, 3019); + wasm2js_trap(); + } + } + break; + } + ComputeCentroid_28b2Vec2_20const__2c_20int_29($3 + 4 | 0, $4 + 20 | 0, HEAP32[$3 + 76 >> 2]); + $1 = HEAP32[$3 + 8 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 16 >> 2] = $1; + } + __stack_pointer = $3 + 240 | 0; +} + +function b2RevoluteJoint__SolveVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, $5 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 176 | 0; + __stack_pointer = $2; + HEAP32[$2 + 172 >> 2] = $0; + HEAP32[$2 + 168 >> 2] = $1; + $3 = HEAP32[$2 + 172 >> 2]; + $4 = HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 132 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 160 >> 2] = $1; + HEAP32[$2 + 164 >> 2] = $0; + HEAPF32[$2 + 156 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 132 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 136 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 144 >> 2] = $0; + HEAP32[$2 + 148 >> 2] = $1; + HEAPF32[$2 + 140 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 136 >> 2], 12) | 0) + 8 >> 2]; + HEAPF32[$2 + 136 >> 2] = HEAPF32[$3 + 172 >> 2]; + HEAPF32[$2 + 132 >> 2] = HEAPF32[$3 + 176 >> 2]; + HEAPF32[$2 + 128 >> 2] = HEAPF32[$3 + 180 >> 2]; + HEAPF32[$2 + 124 >> 2] = HEAPF32[$3 + 184 >> 2]; + HEAP8[$2 + 123 | 0] = Math_fround(HEAPF32[$2 + 128 >> 2] + HEAPF32[$2 + 124 >> 2]) == Math_fround(0); + if (!(!(HEAP8[$3 + 104 | 0] & 1) | HEAP8[$2 + 123 | 0] & 1)) { + HEAPF32[$2 + 116 >> 2] = Math_fround(HEAPF32[$2 + 140 >> 2] - HEAPF32[$2 + 156 >> 2]) - HEAPF32[$3 + 112 >> 2]; + HEAPF32[$2 + 112 >> 2] = Math_fround(-HEAPF32[$3 + 208 >> 2]) * HEAPF32[$2 + 116 >> 2]; + HEAPF32[$2 + 108 >> 2] = HEAPF32[$3 + 92 >> 2]; + HEAPF32[$2 + 104 >> 2] = HEAPF32[HEAP32[$2 + 168 >> 2] >> 2] * HEAPF32[$3 + 108 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Clamp_float__28float_2c_20float_2c_20float_29(Math_fround(HEAPF32[$3 + 92 >> 2] + HEAPF32[$2 + 112 >> 2]), Math_fround(-HEAPF32[$2 + 104 >> 2]), HEAPF32[$2 + 104 >> 2]), + HEAPF32[wasm2js_i32$0 + 92 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 112 >> 2] = HEAPF32[$3 + 92 >> 2] - HEAPF32[$2 + 108 >> 2]; + HEAPF32[$2 + 156 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 128 >> 2]) * HEAPF32[$2 + 112 >> 2]) + HEAPF32[$2 + 156 >> 2]; + HEAPF32[$2 + 140 >> 2] = Math_fround(HEAPF32[$2 + 124 >> 2] * HEAPF32[$2 + 112 >> 2]) + HEAPF32[$2 + 140 >> 2]; + } + if (!(!(HEAP8[$3 + 116 | 0] & 1) | HEAP8[$2 + 123 | 0] & 1)) { + HEAPF32[$2 + 100 >> 2] = HEAPF32[$3 + 204 >> 2] - HEAPF32[$3 + 124 >> 2]; + HEAPF32[$2 + 96 >> 2] = HEAPF32[$2 + 140 >> 2] - HEAPF32[$2 + 156 >> 2]; + $5 = HEAPF32[$2 + 96 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(-HEAPF32[$3 + 208 >> 2]) * Math_fround(Math_fround(float_20b2Max_float__28float_2c_20float_29(HEAPF32[$2 + 100 >> 2], Math_fround(0)) * HEAPF32[HEAP32[$2 + 168 >> 2] + 4 >> 2]) + $5)), + HEAPF32[wasm2js_i32$0 + 92 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 88 >> 2] = HEAPF32[$3 + 96 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(Math_fround(HEAPF32[$3 + 96 >> 2] + HEAPF32[$2 + 92 >> 2]), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 96 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 92 >> 2] = HEAPF32[$3 + 96 >> 2] - HEAPF32[$2 + 88 >> 2]; + HEAPF32[$2 + 156 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 128 >> 2]) * HEAPF32[$2 + 92 >> 2]) + HEAPF32[$2 + 156 >> 2]; + HEAPF32[$2 + 140 >> 2] = Math_fround(HEAPF32[$2 + 124 >> 2] * HEAPF32[$2 + 92 >> 2]) + HEAPF32[$2 + 140 >> 2]; + HEAPF32[$2 + 84 >> 2] = HEAPF32[$3 + 128 >> 2] - HEAPF32[$3 + 204 >> 2]; + HEAPF32[$2 + 80 >> 2] = HEAPF32[$2 + 156 >> 2] - HEAPF32[$2 + 140 >> 2]; + $5 = HEAPF32[$2 + 80 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(-HEAPF32[$3 + 208 >> 2]) * Math_fround(Math_fround(float_20b2Max_float__28float_2c_20float_29(HEAPF32[$2 + 84 >> 2], Math_fround(0)) * HEAPF32[HEAP32[$2 + 168 >> 2] + 4 >> 2]) + $5)), + HEAPF32[wasm2js_i32$0 + 76 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 72 >> 2] = HEAPF32[$3 + 100 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Max_float__28float_2c_20float_29(Math_fround(HEAPF32[$3 + 100 >> 2] + HEAPF32[$2 + 76 >> 2]), Math_fround(0)), + HEAPF32[wasm2js_i32$0 + 100 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 76 >> 2] = HEAPF32[$3 + 100 >> 2] - HEAPF32[$2 + 72 >> 2]; + HEAPF32[$2 + 156 >> 2] = Math_fround(HEAPF32[$2 + 128 >> 2] * HEAPF32[$2 + 76 >> 2]) + HEAPF32[$2 + 156 >> 2]; + HEAPF32[$2 + 140 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 124 >> 2]) * HEAPF32[$2 + 76 >> 2]) + HEAPF32[$2 + 140 >> 2]; + } + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 40 | 0, HEAPF32[$2 + 140 >> 2], $3 + 148 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 48 | 0, $2 + 144 | 0, $2 + 40 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 56 | 0, $2 + 48 | 0, $2 + 160 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 32 | 0, HEAPF32[$2 + 156 >> 2], $3 + 140 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 - -64 | 0, $2 + 56 | 0, $2 + 32 | 0); + b2Vec2__operator__28_29_20const($2 + 16 | 0, $2 - -64 | 0); + b2Mat22__Solve_28b2Vec2_20const__29_20const($2 + 24 | 0, $3 + 188 | 0, $2 + 16 | 0); + HEAPF32[$3 + 84 >> 2] = HEAPF32[$3 + 84 >> 2] + HEAPF32[$2 + 24 >> 2]; + HEAPF32[$3 + 88 >> 2] = HEAPF32[$3 + 88 >> 2] + HEAPF32[$2 + 28 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 8 | 0, HEAPF32[$2 + 136 >> 2], $2 + 24 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 160 | 0, $2 + 8 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 128 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 140 | 0, $2 + 24 | 0)) + HEAPF32[$2 + 156 >> 2]), + HEAPF32[wasm2js_i32$0 + 156 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2, HEAPF32[$2 + 132 >> 2], $2 + 24 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 144 | 0, $2); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$2 + 124 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 148 | 0, $2 + 24 | 0)) + HEAPF32[$2 + 140 >> 2]), + HEAPF32[wasm2js_i32$0 + 140 >> 2] = wasm2js_f32$0; + $0 = HEAP32[$2 + 164 >> 2]; + $1 = HEAP32[$2 + 160 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 132 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 132 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 156 >> 2]; + $1 = HEAP32[$2 + 148 >> 2]; + $0 = HEAP32[$2 + 144 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 136 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 136 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 140 >> 2]; + __stack_pointer = $2 + 176 | 0; +} + +function b2RevoluteJoint__InitVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 144 | 0; + __stack_pointer = $2; + HEAP32[$2 + 140 >> 2] = $0; + HEAP32[$2 + 136 >> 2] = $1; + $1 = HEAP32[$2 + 140 >> 2]; + HEAP32[$1 + 132 >> 2] = HEAP32[HEAP32[$1 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 136 >> 2] = HEAP32[HEAP32[$1 + 52 >> 2] + 8 >> 2]; + $4 = HEAP32[$1 + 48 >> 2]; + $3 = HEAP32[$4 + 28 >> 2]; + $0 = HEAP32[$4 + 32 >> 2]; + HEAP32[$1 + 156 >> 2] = $3; + HEAP32[$1 + 160 >> 2] = $0; + $4 = HEAP32[$1 + 52 >> 2]; + $0 = HEAP32[$4 + 28 >> 2]; + $3 = HEAP32[$4 + 32 >> 2]; + HEAP32[$1 + 164 >> 2] = $0; + HEAP32[$1 + 168 >> 2] = $3; + HEAPF32[$1 + 172 >> 2] = HEAPF32[HEAP32[$1 + 48 >> 2] + 120 >> 2]; + HEAPF32[$1 + 176 >> 2] = HEAPF32[HEAP32[$1 + 52 >> 2] + 120 >> 2]; + HEAPF32[$1 + 180 >> 2] = HEAPF32[HEAP32[$1 + 48 >> 2] + 128 >> 2]; + HEAPF32[$1 + 184 >> 2] = HEAPF32[HEAP32[$1 + 52 >> 2] + 128 >> 2]; + HEAPF32[$2 + 132 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 136 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 132 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 136 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 132 >> 2], 12) | 0; + $3 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 120 >> 2] = $3; + HEAP32[$2 + 124 >> 2] = $0; + HEAPF32[$2 + 116 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 136 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 132 >> 2], 12) | 0) + 8 >> 2]; + HEAPF32[$2 + 112 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 136 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 136 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 136 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 136 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $3 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 104 >> 2] = $0; + HEAP32[$2 + 108 >> 2] = $3; + HEAPF32[$2 + 100 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 136 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 136 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 92 | 0, HEAPF32[$2 + 132 >> 2]); + b2Rot__b2Rot_28float_29($2 + 84 | 0, HEAPF32[$2 + 112 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 68 | 0, $1 + 68 | 0, $1 + 156 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 76 | 0, $2 + 92 | 0, $2 + 68 | 0); + $0 = HEAP32[$2 + 80 >> 2]; + $3 = HEAP32[$2 + 76 >> 2]; + HEAP32[$1 + 140 >> 2] = $3; + HEAP32[$1 + 144 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 52 | 0, $1 + 76 | 0, $1 + 164 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 60 | 0, $2 + 84 | 0, $2 + 52 | 0); + $3 = HEAP32[$2 + 64 >> 2]; + $0 = HEAP32[$2 + 60 >> 2]; + HEAP32[$1 + 148 >> 2] = $0; + HEAP32[$1 + 152 >> 2] = $3; + HEAPF32[$2 + 48 >> 2] = HEAPF32[$1 + 172 >> 2]; + HEAPF32[$2 + 44 >> 2] = HEAPF32[$1 + 176 >> 2]; + HEAPF32[$2 + 40 >> 2] = HEAPF32[$1 + 180 >> 2]; + HEAPF32[$2 + 36 >> 2] = HEAPF32[$1 + 184 >> 2]; + HEAPF32[$1 + 188 >> 2] = Math_fround(Math_fround(HEAPF32[$1 + 152 >> 2] * HEAPF32[$1 + 152 >> 2]) * HEAPF32[$2 + 36 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$1 + 144 >> 2] * HEAPF32[$1 + 144 >> 2]) * HEAPF32[$2 + 40 >> 2]) + Math_fround(HEAPF32[$2 + 48 >> 2] + HEAPF32[$2 + 44 >> 2])); + HEAPF32[$1 + 196 >> 2] = Math_fround(Math_fround(Math_fround(-HEAPF32[$1 + 144 >> 2]) * HEAPF32[$1 + 140 >> 2]) * HEAPF32[$2 + 40 >> 2]) - Math_fround(Math_fround(HEAPF32[$1 + 152 >> 2] * HEAPF32[$1 + 148 >> 2]) * HEAPF32[$2 + 36 >> 2]); + HEAPF32[$1 + 192 >> 2] = HEAPF32[$1 + 196 >> 2]; + HEAPF32[$1 + 200 >> 2] = Math_fround(Math_fround(HEAPF32[$1 + 148 >> 2] * HEAPF32[$1 + 148 >> 2]) * HEAPF32[$2 + 36 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$1 + 140 >> 2] * HEAPF32[$1 + 140 >> 2]) * HEAPF32[$2 + 40 >> 2]) + Math_fround(HEAPF32[$2 + 48 >> 2] + HEAPF32[$2 + 44 >> 2])); + HEAPF32[$1 + 208 >> 2] = HEAPF32[$2 + 40 >> 2] + HEAPF32[$2 + 36 >> 2]; + label$1: { + if (HEAPF32[$1 + 208 >> 2] > Math_fround(0)) { + HEAPF32[$1 + 208 >> 2] = Math_fround(1) / HEAPF32[$1 + 208 >> 2]; + HEAP8[$2 + 35 | 0] = 0; + break label$1; + } + HEAP8[$2 + 35 | 0] = 1; + } + HEAPF32[$1 + 204 >> 2] = Math_fround(HEAPF32[$2 + 112 >> 2] - HEAPF32[$2 + 132 >> 2]) - HEAPF32[$1 + 120 >> 2]; + if (!(!(HEAP8[$2 + 35 | 0] & 1) & (HEAP8[$1 + 116 | 0] & 1))) { + HEAPF32[$1 + 96 >> 2] = 0; + HEAPF32[$1 + 100 >> 2] = 0; + } + if (!(!(HEAP8[$2 + 35 | 0] & 1) & (HEAP8[$1 + 104 | 0] & 1))) { + HEAPF32[$1 + 92 >> 2] = 0; + } + label$7: { + if (HEAP8[HEAP32[$2 + 136 >> 2] + 20 | 0] & 1) { + b2Vec2__operator___28float_29($1 + 84 | 0, HEAPF32[HEAP32[$2 + 136 >> 2] + 8 >> 2]); + HEAPF32[$1 + 92 >> 2] = HEAPF32[$1 + 92 >> 2] * HEAPF32[HEAP32[$2 + 136 >> 2] + 8 >> 2]; + HEAPF32[$1 + 96 >> 2] = HEAPF32[$1 + 96 >> 2] * HEAPF32[HEAP32[$2 + 136 >> 2] + 8 >> 2]; + HEAPF32[$1 + 100 >> 2] = HEAPF32[$1 + 100 >> 2] * HEAPF32[HEAP32[$2 + 136 >> 2] + 8 >> 2]; + HEAPF32[$2 + 28 >> 2] = Math_fround(HEAPF32[$1 + 92 >> 2] + HEAPF32[$1 + 96 >> 2]) - HEAPF32[$1 + 100 >> 2]; + b2Vec2__b2Vec2_28float_2c_20float_29($2 + 20 | 0, HEAPF32[$1 + 84 >> 2], HEAPF32[$1 + 88 >> 2]); + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$2 + 48 >> 2], $2 + 20 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 120 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 40 >> 2]) * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 140 | 0, $2 + 20 | 0) + HEAPF32[$2 + 28 >> 2])) + HEAPF32[$2 + 116 >> 2]), + HEAPF32[wasm2js_i32$0 + 116 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 4 | 0, HEAPF32[$2 + 44 >> 2], $2 + 20 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 104 | 0, $2 + 4 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$2 + 36 >> 2] * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 148 | 0, $2 + 20 | 0) + HEAPF32[$2 + 28 >> 2])) + HEAPF32[$2 + 100 >> 2]), + HEAPF32[wasm2js_i32$0 + 100 >> 2] = wasm2js_f32$0; + break label$7; + } + b2Vec2__SetZero_28_29($1 + 84 | 0); + HEAPF32[$1 + 92 >> 2] = 0; + HEAPF32[$1 + 96 >> 2] = 0; + HEAPF32[$1 + 100 >> 2] = 0; + } + $0 = HEAP32[$2 + 124 >> 2]; + $3 = HEAP32[$2 + 120 >> 2]; + $4 = $3; + $3 = HEAP32[HEAP32[$2 + 136 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 132 >> 2], 12) | 0; + HEAP32[$3 >> 2] = $4; + HEAP32[$3 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 136 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 132 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 116 >> 2]; + $3 = HEAP32[$2 + 108 >> 2]; + $0 = HEAP32[$2 + 104 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 136 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 136 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $3; + HEAPF32[(HEAP32[HEAP32[$2 + 136 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 136 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 100 >> 2]; + __stack_pointer = $2 + 144 | 0; +} + +function b2RopeJoint__InitVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, $5 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 192 | 0; + __stack_pointer = $2; + HEAP32[$2 + 188 >> 2] = $0; + HEAP32[$2 + 184 >> 2] = $1; + $1 = HEAP32[$2 + 188 >> 2]; + HEAP32[$1 + 96 >> 2] = HEAP32[HEAP32[$1 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 100 >> 2] = HEAP32[HEAP32[$1 + 52 >> 2] + 8 >> 2]; + $4 = HEAP32[$1 + 48 >> 2]; + $0 = HEAP32[$4 + 28 >> 2]; + $3 = HEAP32[$4 + 32 >> 2]; + HEAP32[$1 + 128 >> 2] = $0; + HEAP32[$1 + 132 >> 2] = $3; + $4 = HEAP32[$1 + 52 >> 2]; + $3 = HEAP32[$4 + 28 >> 2]; + $0 = HEAP32[$4 + 32 >> 2]; + HEAP32[$1 + 136 >> 2] = $3; + HEAP32[$1 + 140 >> 2] = $0; + HEAPF32[$1 + 144 >> 2] = HEAPF32[HEAP32[$1 + 48 >> 2] + 120 >> 2]; + HEAPF32[$1 + 148 >> 2] = HEAPF32[HEAP32[$1 + 52 >> 2] + 120 >> 2]; + HEAPF32[$1 + 152 >> 2] = HEAPF32[HEAP32[$1 + 48 >> 2] + 128 >> 2]; + HEAPF32[$1 + 156 >> 2] = HEAPF32[HEAP32[$1 + 52 >> 2] + 128 >> 2]; + $4 = HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 96 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $3 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 176 >> 2] = $0; + HEAP32[$2 + 180 >> 2] = $3; + HEAPF32[$2 + 172 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 96 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 96 >> 2], 12) | 0; + $3 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 160 >> 2] = $3; + HEAP32[$2 + 164 >> 2] = $0; + HEAPF32[$2 + 156 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 96 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 100 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $3 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 144 >> 2] = $0; + HEAP32[$2 + 148 >> 2] = $3; + HEAPF32[$2 + 140 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 100 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 100 >> 2], 12) | 0; + $3 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 128 >> 2] = $3; + HEAP32[$2 + 132 >> 2] = $0; + HEAPF32[$2 + 124 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 100 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 116 | 0, HEAPF32[$2 + 172 >> 2]); + b2Rot__b2Rot_28float_29($2 + 108 | 0, HEAPF32[$2 + 140 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 92 | 0, $1 + 68 | 0, $1 + 128 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 100 | 0, $2 + 116 | 0, $2 + 92 | 0); + $3 = HEAP32[$2 + 104 >> 2]; + $0 = HEAP32[$2 + 100 >> 2]; + HEAP32[$1 + 112 >> 2] = $0; + HEAP32[$1 + 116 >> 2] = $3; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 76 | 0, $1 + 76 | 0, $1 + 136 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 84 | 0, $2 + 108 | 0, $2 + 76 | 0); + $0 = HEAP32[$2 + 88 >> 2]; + $3 = HEAP32[$2 + 84 >> 2]; + HEAP32[$1 + 120 >> 2] = $3; + HEAP32[$1 + 124 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 52 | 0, $2 + 144 | 0, $1 + 120 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 60 | 0, $2 + 52 | 0, $2 + 176 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 68 | 0, $2 + 60 | 0, $1 + 112 | 0); + $3 = HEAP32[$2 + 72 >> 2]; + $0 = HEAP32[$2 + 68 >> 2]; + HEAP32[$1 + 104 >> 2] = $0; + HEAP32[$1 + 108 >> 2] = $3; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Vec2__Length_28_29_20const($1 + 104 | 0), + HEAPF32[wasm2js_i32$0 + 88 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 48 >> 2] = HEAPF32[$1 + 88 >> 2] - HEAPF32[$1 + 84 >> 2]; + label$1: { + label$2: { + if (HEAPF32[$1 + 88 >> 2] > Math_fround(.004999999888241291)) { + b2Vec2__operator___28float_29($1 + 104 | 0, Math_fround(Math_fround(1) / HEAPF32[$1 + 88 >> 2])); + break label$2; + } + b2Vec2__SetZero_28_29($1 + 104 | 0); + HEAPF32[$1 + 160 >> 2] = 0; + HEAPF32[$1 + 92 >> 2] = 0; + break label$1; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 112 | 0, $1 + 104 | 0), + HEAPF32[wasm2js_i32$0 + 44 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 120 | 0, $1 + 104 | 0), + HEAPF32[wasm2js_i32$0 + 40 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 36 >> 2] = Math_fround(Math_fround(HEAPF32[$1 + 156 >> 2] * HEAPF32[$2 + 40 >> 2]) * HEAPF32[$2 + 40 >> 2]) + Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$1 + 152 >> 2] * HEAPF32[$2 + 44 >> 2]) * HEAPF32[$2 + 44 >> 2]) + HEAPF32[$1 + 144 >> 2]) + HEAPF32[$1 + 148 >> 2]); + if (HEAPF32[$2 + 36 >> 2] != Math_fround(0)) { + $5 = Math_fround(Math_fround(1) / HEAPF32[$2 + 36 >> 2]); + } else { + $5 = Math_fround(0); + } + HEAPF32[$1 + 160 >> 2] = $5; + label$6: { + if (HEAP8[HEAP32[$2 + 184 >> 2] + 20 | 0] & 1) { + HEAPF32[$1 + 92 >> 2] = HEAPF32[$1 + 92 >> 2] * HEAPF32[HEAP32[$2 + 184 >> 2] + 8 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 28 | 0, HEAPF32[$1 + 92 >> 2], $1 + 104 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, HEAPF32[$1 + 144 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 160 | 0, $2 + 20 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$1 + 152 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 112 | 0, $2 + 28 | 0)) + HEAPF32[$2 + 156 >> 2]), + HEAPF32[wasm2js_i32$0 + 156 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$1 + 148 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 128 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$1 + 156 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 120 | 0, $2 + 28 | 0)) + HEAPF32[$2 + 124 >> 2]), + HEAPF32[wasm2js_i32$0 + 124 >> 2] = wasm2js_f32$0; + break label$6; + } + HEAPF32[$1 + 92 >> 2] = 0; + } + $0 = HEAP32[$2 + 164 >> 2]; + $3 = HEAP32[$2 + 160 >> 2]; + $4 = $3; + $3 = HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 96 >> 2], 12) | 0; + HEAP32[$3 >> 2] = $4; + HEAP32[$3 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 96 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 156 >> 2]; + $3 = HEAP32[$2 + 132 >> 2]; + $0 = HEAP32[$2 + 128 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 100 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $3; + HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 100 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 124 >> 2]; + } + __stack_pointer = $2 + 192 | 0; +} + +function b2WorldManifold__Initialize_28b2Manifold_20const__2c_20b2Transform_20const__2c_20float_2c_20b2Transform_20const__2c_20float_29($0, $1, $2, $3, $4, $5) { + var $6 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $6 = __stack_pointer - 304 | 0; + __stack_pointer = $6; + HEAP32[$6 + 300 >> 2] = $0; + HEAP32[$6 + 296 >> 2] = $1; + HEAP32[$6 + 292 >> 2] = $2; + HEAPF32[$6 + 288 >> 2] = $3; + HEAP32[$6 + 284 >> 2] = $4; + HEAPF32[$6 + 280 >> 2] = $5; + $1 = HEAP32[$6 + 300 >> 2]; + label$1: { + if (!HEAP32[HEAP32[$6 + 296 >> 2] + 60 >> 2]) { + break label$1; + } + label$2: { + switch (HEAP32[HEAP32[$6 + 296 >> 2] + 56 >> 2]) { + case 0: + b2Vec2__Set_28float_2c_20float_29($1, Math_fround(1), Math_fround(0)); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($6 + 272 | 0, HEAP32[$6 + 292 >> 2], HEAP32[$6 + 296 >> 2] + 48 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($6 + 264 | 0, HEAP32[$6 + 284 >> 2], HEAP32[$6 + 296 >> 2]); + if (b2DistanceSquared_28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 272 | 0, $6 + 264 | 0) > Math_fround(14210854715202004e-30)) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 256 | 0, $6 + 264 | 0, $6 + 272 | 0); + $2 = HEAP32[$6 + 260 >> 2]; + $0 = HEAP32[$6 + 256 >> 2]; + HEAP32[$1 >> 2] = $0; + HEAP32[$1 + 4 >> 2] = $2; + b2Vec2__Normalize_28_29($1); + } + operator__28float_2c_20b2Vec2_20const__29($6 + 240 | 0, HEAPF32[$6 + 288 >> 2], $1); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($6 + 248 | 0, $6 + 272 | 0, $6 + 240 | 0); + operator__28float_2c_20b2Vec2_20const__29($6 + 224 | 0, HEAPF32[$6 + 280 >> 2], $1); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 232 | 0, $6 + 264 | 0, $6 + 224 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($6 + 208 | 0, $6 + 248 | 0, $6 + 232 | 0); + operator__28float_2c_20b2Vec2_20const__29($6 + 216 | 0, Math_fround(.5), $6 + 208 | 0); + $0 = HEAP32[$6 + 220 >> 2]; + $2 = HEAP32[$6 + 216 >> 2]; + HEAP32[$1 + 8 >> 2] = $2; + HEAP32[$1 + 12 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 200 | 0, $6 + 232 | 0, $6 + 248 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 200 | 0, $1), + HEAPF32[wasm2js_i32$0 + 24 >> 2] = wasm2js_f32$0; + break label$1; + + case 1: + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($6 + 192 | 0, HEAP32[$6 + 292 >> 2] + 8 | 0, HEAP32[$6 + 296 >> 2] + 40 | 0); + $2 = HEAP32[$6 + 196 >> 2]; + $0 = HEAP32[$6 + 192 >> 2]; + HEAP32[$1 >> 2] = $0; + HEAP32[$1 + 4 >> 2] = $2; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($6 + 184 | 0, HEAP32[$6 + 292 >> 2], HEAP32[$6 + 296 >> 2] + 48 | 0); + HEAP32[$6 + 180 >> 2] = 0; + while (1) { + if (HEAP32[$6 + 180 >> 2] < HEAP32[HEAP32[$6 + 296 >> 2] + 60 >> 2]) { + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($6 + 172 | 0, HEAP32[$6 + 284 >> 2], HEAP32[$6 + 296 >> 2] + Math_imul(HEAP32[$6 + 180 >> 2], 20) | 0); + $3 = HEAPF32[$6 + 288 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 148 | 0, $6 + 172 | 0, $6 + 184 | 0); + operator__28float_2c_20b2Vec2_20const__29($6 + 156 | 0, Math_fround($3 - b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 148 | 0, $1)), $1); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($6 + 164 | 0, $6 + 172 | 0, $6 + 156 | 0); + operator__28float_2c_20b2Vec2_20const__29($6 + 132 | 0, HEAPF32[$6 + 280 >> 2], $1); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 140 | 0, $6 + 172 | 0, $6 + 132 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($6 + 116 | 0, $6 + 164 | 0, $6 + 140 | 0); + operator__28float_2c_20b2Vec2_20const__29($6 + 124 | 0, Math_fround(.5), $6 + 116 | 0); + $0 = HEAP32[$6 + 128 >> 2]; + $2 = HEAP32[$6 + 124 >> 2]; + $4 = $2; + $2 = ($1 + 8 | 0) + (HEAP32[$6 + 180 >> 2] << 3) | 0; + HEAP32[$2 >> 2] = $4; + HEAP32[$2 + 4 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 108 | 0, $6 + 140 | 0, $6 + 164 | 0); + $3 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 108 | 0, $1); + HEAPF32[($1 + 24 | 0) + (HEAP32[$6 + 180 >> 2] << 2) >> 2] = $3; + HEAP32[$6 + 180 >> 2] = HEAP32[$6 + 180 >> 2] + 1; + continue; + } + break; + } + ; + break label$1; + + case 2: + break label$2; + + default: + break label$1; + } + } + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($6 + 100 | 0, HEAP32[$6 + 284 >> 2] + 8 | 0, HEAP32[$6 + 296 >> 2] + 40 | 0); + $2 = HEAP32[$6 + 104 >> 2]; + $0 = HEAP32[$6 + 100 >> 2]; + HEAP32[$1 >> 2] = $0; + HEAP32[$1 + 4 >> 2] = $2; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($6 + 92 | 0, HEAP32[$6 + 284 >> 2], HEAP32[$6 + 296 >> 2] + 48 | 0); + HEAP32[$6 + 88 >> 2] = 0; + while (1) { + if (HEAP32[$6 + 88 >> 2] < HEAP32[HEAP32[$6 + 296 >> 2] + 60 >> 2]) { + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($6 + 80 | 0, HEAP32[$6 + 292 >> 2], HEAP32[$6 + 296 >> 2] + Math_imul(HEAP32[$6 + 88 >> 2], 20) | 0); + $3 = HEAPF32[$6 + 280 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 56 | 0, $6 + 80 | 0, $6 + 92 | 0); + operator__28float_2c_20b2Vec2_20const__29($6 - -64 | 0, Math_fround($3 - b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 56 | 0, $1)), $1); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($6 + 72 | 0, $6 + 80 | 0, $6 - -64 | 0); + operator__28float_2c_20b2Vec2_20const__29($6 + 40 | 0, HEAPF32[$6 + 288 >> 2], $1); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 48 | 0, $6 + 80 | 0, $6 + 40 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($6 + 24 | 0, $6 + 48 | 0, $6 + 72 | 0); + operator__28float_2c_20b2Vec2_20const__29($6 + 32 | 0, Math_fround(.5), $6 + 24 | 0); + $0 = HEAP32[$6 + 36 >> 2]; + $2 = HEAP32[$6 + 32 >> 2]; + $4 = $2; + $2 = ($1 + 8 | 0) + (HEAP32[$6 + 88 >> 2] << 3) | 0; + HEAP32[$2 >> 2] = $4; + HEAP32[$2 + 4 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 16 | 0, $6 + 48 | 0, $6 + 72 | 0); + $3 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 16 | 0, $1); + HEAPF32[($1 + 24 | 0) + (HEAP32[$6 + 88 >> 2] << 2) >> 2] = $3; + HEAP32[$6 + 88 >> 2] = HEAP32[$6 + 88 >> 2] + 1; + continue; + } + break; + } + b2Vec2__operator__28_29_20const($6 + 8 | 0, $1); + $2 = HEAP32[$6 + 12 >> 2]; + $0 = HEAP32[$6 + 8 >> 2]; + HEAP32[$1 >> 2] = $0; + HEAP32[$1 + 4 >> 2] = $2; + } + __stack_pointer = $6 + 304 | 0; +} + +function b2FrictionJoint__InitVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 176 | 0; + __stack_pointer = $2; + HEAP32[$2 + 172 >> 2] = $0; + HEAP32[$2 + 168 >> 2] = $1; + $1 = HEAP32[$2 + 172 >> 2]; + HEAP32[$1 + 104 >> 2] = HEAP32[HEAP32[$1 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 108 >> 2] = HEAP32[HEAP32[$1 + 52 >> 2] + 8 >> 2]; + $4 = HEAP32[$1 + 48 >> 2]; + $3 = HEAP32[$4 + 28 >> 2]; + $0 = HEAP32[$4 + 32 >> 2]; + HEAP32[$1 + 128 >> 2] = $3; + HEAP32[$1 + 132 >> 2] = $0; + $4 = HEAP32[$1 + 52 >> 2]; + $0 = HEAP32[$4 + 28 >> 2]; + $3 = HEAP32[$4 + 32 >> 2]; + HEAP32[$1 + 136 >> 2] = $0; + HEAP32[$1 + 140 >> 2] = $3; + HEAPF32[$1 + 144 >> 2] = HEAPF32[HEAP32[$1 + 48 >> 2] + 120 >> 2]; + HEAPF32[$1 + 148 >> 2] = HEAPF32[HEAP32[$1 + 52 >> 2] + 120 >> 2]; + HEAPF32[$1 + 152 >> 2] = HEAPF32[HEAP32[$1 + 48 >> 2] + 128 >> 2]; + HEAPF32[$1 + 156 >> 2] = HEAPF32[HEAP32[$1 + 52 >> 2] + 128 >> 2]; + HEAPF32[$2 + 164 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 104 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 104 >> 2], 12) | 0; + $3 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 152 >> 2] = $3; + HEAP32[$2 + 156 >> 2] = $0; + HEAPF32[$2 + 148 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 104 >> 2], 12) | 0) + 8 >> 2]; + HEAPF32[$2 + 144 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 108 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 108 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $3 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 136 >> 2] = $0; + HEAP32[$2 + 140 >> 2] = $3; + HEAPF32[$2 + 132 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 108 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 124 | 0, HEAPF32[$2 + 164 >> 2]); + b2Rot__b2Rot_28float_29($2 + 116 | 0, HEAPF32[$2 + 144 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 100 | 0, $1 + 68 | 0, $1 + 128 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 108 | 0, $2 + 124 | 0, $2 + 100 | 0); + $0 = HEAP32[$2 + 112 >> 2]; + $3 = HEAP32[$2 + 108 >> 2]; + HEAP32[$1 + 112 >> 2] = $3; + HEAP32[$1 + 116 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 84 | 0, $1 + 76 | 0, $1 + 136 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 92 | 0, $2 + 116 | 0, $2 + 84 | 0); + $3 = HEAP32[$2 + 96 >> 2]; + $0 = HEAP32[$2 + 92 >> 2]; + HEAP32[$1 + 120 >> 2] = $0; + HEAP32[$1 + 124 >> 2] = $3; + HEAPF32[$2 + 80 >> 2] = HEAPF32[$1 + 144 >> 2]; + HEAPF32[$2 + 76 >> 2] = HEAPF32[$1 + 148 >> 2]; + HEAPF32[$2 + 72 >> 2] = HEAPF32[$1 + 152 >> 2]; + HEAPF32[$2 + 68 >> 2] = HEAPF32[$1 + 156 >> 2]; + b2Mat22__b2Mat22_28_29($2 + 52 | 0); + HEAPF32[$2 + 52 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 68 >> 2] * HEAPF32[$1 + 124 >> 2]) * HEAPF32[$1 + 124 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 72 >> 2] * HEAPF32[$1 + 116 >> 2]) * HEAPF32[$1 + 116 >> 2]) + Math_fround(HEAPF32[$2 + 80 >> 2] + HEAPF32[$2 + 76 >> 2])); + HEAPF32[$2 + 56 >> 2] = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 72 >> 2]) * HEAPF32[$1 + 112 >> 2]) * HEAPF32[$1 + 116 >> 2]) - Math_fround(Math_fround(HEAPF32[$2 + 68 >> 2] * HEAPF32[$1 + 120 >> 2]) * HEAPF32[$1 + 124 >> 2]); + HEAPF32[$2 + 60 >> 2] = HEAPF32[$2 + 56 >> 2]; + HEAPF32[$2 + 64 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 68 >> 2] * HEAPF32[$1 + 120 >> 2]) * HEAPF32[$1 + 120 >> 2]) + Math_fround(Math_fround(Math_fround(HEAPF32[$2 + 72 >> 2] * HEAPF32[$1 + 112 >> 2]) * HEAPF32[$1 + 112 >> 2]) + Math_fround(HEAPF32[$2 + 80 >> 2] + HEAPF32[$2 + 76 >> 2])); + b2Mat22__GetInverse_28_29_20const($2 + 36 | 0, $2 + 52 | 0); + $0 = HEAP32[$2 + 40 >> 2]; + $3 = HEAP32[$2 + 36 >> 2]; + HEAP32[$1 + 160 >> 2] = $3; + HEAP32[$1 + 164 >> 2] = $0; + $3 = HEAP32[$2 + 48 >> 2]; + $0 = HEAP32[$2 + 44 >> 2]; + HEAP32[$1 + 168 >> 2] = $0; + HEAP32[$1 + 172 >> 2] = $3; + HEAPF32[$1 + 176 >> 2] = HEAPF32[$2 + 72 >> 2] + HEAPF32[$2 + 68 >> 2]; + if (HEAPF32[$1 + 176 >> 2] > Math_fround(0)) { + HEAPF32[$1 + 176 >> 2] = Math_fround(1) / HEAPF32[$1 + 176 >> 2]; + } + label$2: { + if (HEAP8[HEAP32[$2 + 168 >> 2] + 20 | 0] & 1) { + b2Vec2__operator___28float_29($1 + 84 | 0, HEAPF32[HEAP32[$2 + 168 >> 2] + 8 >> 2]); + HEAPF32[$1 + 92 >> 2] = HEAPF32[$1 + 92 >> 2] * HEAPF32[HEAP32[$2 + 168 >> 2] + 8 >> 2]; + b2Vec2__b2Vec2_28float_2c_20float_29($2 + 28 | 0, HEAPF32[$1 + 84 >> 2], HEAPF32[$1 + 88 >> 2]); + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, HEAPF32[$2 + 80 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 152 | 0, $2 + 20 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 72 >> 2]) * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 112 | 0, $2 + 28 | 0) + HEAPF32[$1 + 92 >> 2])) + HEAPF32[$2 + 148 >> 2]), + HEAPF32[wasm2js_i32$0 + 148 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$2 + 76 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 136 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$2 + 68 >> 2] * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 120 | 0, $2 + 28 | 0) + HEAPF32[$1 + 92 >> 2])) + HEAPF32[$2 + 132 >> 2]), + HEAPF32[wasm2js_i32$0 + 132 >> 2] = wasm2js_f32$0; + break label$2; + } + b2Vec2__SetZero_28_29($1 + 84 | 0); + HEAPF32[$1 + 92 >> 2] = 0; + } + $0 = HEAP32[$2 + 156 >> 2]; + $3 = HEAP32[$2 + 152 >> 2]; + $4 = $3; + $3 = HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 104 >> 2], 12) | 0; + HEAP32[$3 >> 2] = $4; + HEAP32[$3 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 104 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 148 >> 2]; + $3 = HEAP32[$2 + 140 >> 2]; + $0 = HEAP32[$2 + 136 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 108 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $3; + HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 108 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 132 >> 2]; + __stack_pointer = $2 + 176 | 0; +} + +function b2WeldJoint__SolveVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 256 | 0; + __stack_pointer = $2; + HEAP32[$2 + 252 >> 2] = $0; + HEAP32[$2 + 248 >> 2] = $1; + $3 = HEAP32[$2 + 252 >> 2]; + $4 = HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 116 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 240 >> 2] = $0; + HEAP32[$2 + 244 >> 2] = $1; + HEAPF32[$2 + 236 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 116 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 224 >> 2] = $1; + HEAP32[$2 + 228 >> 2] = $0; + HEAPF32[$2 + 220 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0) + 8 >> 2]; + HEAPF32[$2 + 216 >> 2] = HEAPF32[$3 + 156 >> 2]; + HEAPF32[$2 + 212 >> 2] = HEAPF32[$3 + 160 >> 2]; + HEAPF32[$2 + 208 >> 2] = HEAPF32[$3 + 164 >> 2]; + HEAPF32[$2 + 204 >> 2] = HEAPF32[$3 + 168 >> 2]; + label$1: { + if (HEAPF32[$3 + 68 >> 2] > Math_fround(0)) { + HEAPF32[$2 + 200 >> 2] = HEAPF32[$2 + 220 >> 2] - HEAPF32[$2 + 236 >> 2]; + HEAPF32[$2 + 196 >> 2] = Math_fround(-HEAPF32[$3 + 204 >> 2]) * Math_fround(Math_fround(HEAPF32[$3 + 100 >> 2] * HEAPF32[$3 + 112 >> 2]) + Math_fround(HEAPF32[$2 + 200 >> 2] + HEAPF32[$3 + 76 >> 2])); + HEAPF32[$3 + 112 >> 2] = HEAPF32[$3 + 112 >> 2] + HEAPF32[$2 + 196 >> 2]; + HEAPF32[$2 + 236 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 208 >> 2]) * HEAPF32[$2 + 196 >> 2]) + HEAPF32[$2 + 236 >> 2]; + HEAPF32[$2 + 220 >> 2] = Math_fround(HEAPF32[$2 + 204 >> 2] * HEAPF32[$2 + 196 >> 2]) + HEAPF32[$2 + 220 >> 2]; + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 164 | 0, HEAPF32[$2 + 220 >> 2], $3 + 132 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 172 | 0, $2 + 224 | 0, $2 + 164 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 180 | 0, $2 + 172 | 0, $2 + 240 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 156 | 0, HEAPF32[$2 + 236 >> 2], $3 + 124 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 188 | 0, $2 + 180 | 0, $2 + 156 | 0); + b2Mul22_28b2Mat33_20const__2c_20b2Vec2_20const__29($2 + 140 | 0, $3 + 172 | 0, $2 + 188 | 0); + b2Vec2__operator__28_29_20const($2 + 148 | 0, $2 + 140 | 0); + HEAPF32[$3 + 104 >> 2] = HEAPF32[$3 + 104 >> 2] + HEAPF32[$2 + 148 >> 2]; + HEAPF32[$3 + 108 >> 2] = HEAPF32[$3 + 108 >> 2] + HEAPF32[$2 + 152 >> 2]; + $1 = HEAP32[$2 + 152 >> 2]; + $0 = HEAP32[$2 + 148 >> 2]; + HEAP32[$2 + 128 >> 2] = $0; + HEAP32[$2 + 132 >> 2] = $1; + operator__28float_2c_20b2Vec2_20const__29($2 + 120 | 0, HEAPF32[$2 + 216 >> 2], $2 + 128 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 240 | 0, $2 + 120 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 208 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 124 | 0, $2 + 128 | 0)) + HEAPF32[$2 + 236 >> 2]), + HEAPF32[wasm2js_i32$0 + 236 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 112 | 0, HEAPF32[$2 + 212 >> 2], $2 + 128 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 224 | 0, $2 + 112 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$2 + 204 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 132 | 0, $2 + 128 | 0)) + HEAPF32[$2 + 220 >> 2]), + HEAPF32[wasm2js_i32$0 + 220 >> 2] = wasm2js_f32$0; + break label$1; + } + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 80 | 0, HEAPF32[$2 + 220 >> 2], $3 + 132 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 88 | 0, $2 + 224 | 0, $2 + 80 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 96 | 0, $2 + 88 | 0, $2 + 240 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 72 | 0, HEAPF32[$2 + 236 >> 2], $3 + 124 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 104 | 0, $2 + 96 | 0, $2 + 72 | 0); + HEAPF32[$2 + 68 >> 2] = HEAPF32[$2 + 220 >> 2] - HEAPF32[$2 + 236 >> 2]; + b2Vec3__b2Vec3_28float_2c_20float_2c_20float_29($2 + 56 | 0, HEAPF32[$2 + 104 >> 2], HEAPF32[$2 + 108 >> 2], HEAPF32[$2 + 68 >> 2]); + b2Mul_28b2Mat33_20const__2c_20b2Vec3_20const__29($2 + 32 | 0, $3 + 172 | 0, $2 + 56 | 0); + b2Vec3__operator__28_29_20const($2 + 44 | 0, $2 + 32 | 0); + b2Vec3__operator___28b2Vec3_20const__29($3 + 104 | 0, $2 + 44 | 0); + b2Vec2__b2Vec2_28float_2c_20float_29($2 + 24 | 0, HEAPF32[$2 + 44 >> 2], HEAPF32[$2 + 48 >> 2]); + operator__28float_2c_20b2Vec2_20const__29($2 + 16 | 0, HEAPF32[$2 + 216 >> 2], $2 + 24 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 240 | 0, $2 + 16 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 208 >> 2]) * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 124 | 0, $2 + 24 | 0) + HEAPF32[$2 + 52 >> 2])) + HEAPF32[$2 + 236 >> 2]), + HEAPF32[wasm2js_i32$0 + 236 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 8 | 0, HEAPF32[$2 + 212 >> 2], $2 + 24 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 224 | 0, $2 + 8 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$2 + 204 >> 2] * Math_fround(b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 132 | 0, $2 + 24 | 0) + HEAPF32[$2 + 52 >> 2])) + HEAPF32[$2 + 220 >> 2]), + HEAPF32[wasm2js_i32$0 + 220 >> 2] = wasm2js_f32$0; + } + $0 = HEAP32[$2 + 244 >> 2]; + $1 = HEAP32[$2 + 240 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 116 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 116 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 236 >> 2]; + $1 = HEAP32[$2 + 228 >> 2]; + $0 = HEAP32[$2 + 224 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 248 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 220 >> 2]; + __stack_pointer = $2 + 256 | 0; +} + +function b2PulleyJoint__SolvePositionConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 192 | 0; + __stack_pointer = $2; + HEAP32[$2 + 188 >> 2] = $0; + HEAP32[$2 + 184 >> 2] = $1; + $3 = HEAP32[$2 + 188 >> 2]; + $4 = HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 176 >> 2] = $1; + HEAP32[$2 + 180 >> 2] = $0; + HEAPF32[$2 + 172 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 124 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 160 >> 2] = $0; + HEAP32[$2 + 164 >> 2] = $1; + HEAPF32[$2 + 156 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 124 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 148 | 0, HEAPF32[$2 + 172 >> 2]); + b2Rot__b2Rot_28float_29($2 + 140 | 0, HEAPF32[$2 + 156 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 124 | 0, $3 + 92 | 0, $3 + 160 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 132 | 0, $2 + 148 | 0, $2 + 124 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 108 | 0, $3 + 100 | 0, $3 + 168 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 116 | 0, $2 + 140 | 0, $2 + 108 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 92 | 0, $2 + 176 | 0, $2 + 132 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 100 | 0, $2 + 92 | 0, $3 + 68 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 76 | 0, $2 + 160 | 0, $2 + 116 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 84 | 0, $2 + 76 | 0, $3 + 76 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Vec2__Length_28_29_20const($2 + 100 | 0), + HEAPF32[wasm2js_i32$0 + 72 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Vec2__Length_28_29_20const($2 + 84 | 0), HEAPF32[wasm2js_i32$0 + 68 >> 2] = wasm2js_f32$0; + label$1: { + if (HEAPF32[$2 + 72 >> 2] > Math_fround(.04999999701976776)) { + b2Vec2__operator___28float_29($2 + 100 | 0, Math_fround(Math_fround(1) / HEAPF32[$2 + 72 >> 2])); + break label$1; + } + b2Vec2__SetZero_28_29($2 + 100 | 0); + } + label$3: { + if (HEAPF32[$2 + 68 >> 2] > Math_fround(.04999999701976776)) { + b2Vec2__operator___28float_29($2 + 84 | 0, Math_fround(Math_fround(1) / HEAPF32[$2 + 68 >> 2])); + break label$3; + } + b2Vec2__SetZero_28_29($2 + 84 | 0); + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 132 | 0, $2 + 100 | 0), + HEAPF32[wasm2js_i32$0 + 64 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 116 | 0, $2 + 84 | 0), + HEAPF32[wasm2js_i32$0 + 60 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 56 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 184 >> 2] * HEAPF32[$2 + 64 >> 2]) * HEAPF32[$2 + 64 >> 2]) + HEAPF32[$3 + 176 >> 2]; + HEAPF32[$2 + 52 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 188 >> 2] * HEAPF32[$2 + 60 >> 2]) * HEAPF32[$2 + 60 >> 2]) + HEAPF32[$3 + 180 >> 2]; + HEAPF32[$2 + 48 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 112 >> 2] * HEAPF32[$3 + 112 >> 2]) * HEAPF32[$2 + 52 >> 2]) + HEAPF32[$2 + 56 >> 2]; + if (HEAPF32[$2 + 48 >> 2] > Math_fround(0)) { + HEAPF32[$2 + 48 >> 2] = Math_fround(1) / HEAPF32[$2 + 48 >> 2]; + } + HEAPF32[$2 + 44 >> 2] = Math_fround(Math_fround(-HEAPF32[$3 + 112 >> 2]) * HEAPF32[$2 + 68 >> 2]) + Math_fround(HEAPF32[$3 + 108 >> 2] - HEAPF32[$2 + 72 >> 2]); + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Abs_float__28float_29(HEAPF32[$2 + 44 >> 2]), + HEAPF32[wasm2js_i32$0 + 40 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 36 >> 2] = Math_fround(-HEAPF32[$2 + 48 >> 2]) * HEAPF32[$2 + 44 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 28 | 0, Math_fround(-HEAPF32[$2 + 36 >> 2]), $2 + 100 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, Math_fround(Math_fround(-HEAPF32[$3 + 112 >> 2]) * HEAPF32[$2 + 36 >> 2]), $2 + 84 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$3 + 176 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 176 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$3 + 184 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 132 | 0, $2 + 28 | 0)) + HEAPF32[$2 + 172 >> 2]), + HEAPF32[wasm2js_i32$0 + 172 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 4 | 0, HEAPF32[$3 + 180 >> 2], $2 + 20 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 160 | 0, $2 + 4 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$3 + 188 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 116 | 0, $2 + 20 | 0)) + HEAPF32[$2 + 156 >> 2]), + HEAPF32[wasm2js_i32$0 + 156 >> 2] = wasm2js_f32$0; + $0 = HEAP32[$2 + 180 >> 2]; + $1 = HEAP32[$2 + 176 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 172 >> 2]; + $1 = HEAP32[$2 + 164 >> 2]; + $0 = HEAP32[$2 + 160 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 124 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 124 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 156 >> 2]; + __stack_pointer = $2 + 192 | 0; + return HEAPF32[$2 + 40 >> 2] < Math_fround(.004999999888241291) | 0; +} + +function void_20b2DynamicTree__RayCast_b2WorldRayCastWrapper__28b2WorldRayCastWrapper__2c_20b2RayCastInput_20const__29_20const($0, $1, $2) { + var $3 = 0, $4 = Math_fround(0), $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 1264 | 0; + __stack_pointer = $3; + HEAP32[$3 + 1260 >> 2] = $0; + HEAP32[$3 + 1256 >> 2] = $1; + HEAP32[$3 + 1252 >> 2] = $2; + $5 = HEAP32[$3 + 1260 >> 2]; + $2 = HEAP32[$3 + 1252 >> 2]; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + HEAP32[$3 + 1240 >> 2] = $1; + HEAP32[$3 + 1244 >> 2] = $0; + $2 = HEAP32[$3 + 1252 >> 2]; + $0 = HEAP32[$2 + 8 >> 2]; + $1 = HEAP32[$2 + 12 >> 2]; + HEAP32[$3 + 1232 >> 2] = $0; + HEAP32[$3 + 1236 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 1224 | 0, $3 + 1232 | 0, $3 + 1240 | 0); + if (!(b2Vec2__LengthSquared_28_29_20const($3 + 1224 | 0) > Math_fround(0))) { + __assert_fail(8129, 7408, 230, 1866); + wasm2js_trap(); + } + b2Vec2__Normalize_28_29($3 + 1224 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($3 + 1216 | 0, Math_fround(1), $3 + 1224 | 0); + b2Abs_28b2Vec2_20const__29($3 + 1208 | 0, $3 + 1216 | 0); + HEAPF32[$3 + 1204 >> 2] = HEAPF32[HEAP32[$3 + 1252 >> 2] + 16 >> 2]; + b2AABB__b2AABB_28_29($3 + 1188 | 0); + $4 = HEAPF32[$3 + 1204 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 1164 | 0, $3 + 1232 | 0, $3 + 1240 | 0); + operator__28float_2c_20b2Vec2_20const__29($3 + 1172 | 0, $4, $3 + 1164 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 1180 | 0, $3 + 1240 | 0, $3 + 1172 | 0); + b2Min_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 1156 | 0, $3 + 1240 | 0, $3 + 1180 | 0); + $0 = HEAP32[$3 + 1160 >> 2]; + $1 = HEAP32[$3 + 1156 >> 2]; + $2 = $1; + $1 = $3 + 1188 | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + b2Max_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 1148 | 0, $3 + 1240 | 0, $3 + 1180 | 0); + $1 = HEAP32[$3 + 1152 >> 2]; + $0 = HEAP32[$3 + 1148 >> 2]; + $2 = $0; + $0 = $3 + 1188 | 0; + HEAP32[$0 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $1; + b2GrowableStack_int_2c_20256___b2GrowableStack_28_29($3 + 112 | 0); + b2GrowableStack_int_2c_20256___Push_28int_20const__29($3 + 112 | 0, $5); + label$2: { + while (1) { + if ((b2GrowableStack_int_2c_20256___GetCount_28_29($3 + 112 | 0) | 0) > 0) { + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2GrowableStack_int_2c_20256___Pop_28_29($3 + 112 | 0), + HEAP32[wasm2js_i32$0 + 108 >> 2] = wasm2js_i32$1; + if (HEAP32[$3 + 108 >> 2] == -1) { + continue; + } + HEAP32[$3 + 104 >> 2] = HEAP32[$5 + 4 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 40); + if (!(b2TestOverlap_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$3 + 104 >> 2], $3 + 1188 | 0) & 1)) { + continue; + } + b2AABB__GetCenter_28_29_20const($3 + 96 | 0, HEAP32[$3 + 104 >> 2]); + b2AABB__GetExtents_28_29_20const($3 + 88 | 0, HEAP32[$3 + 104 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 76 | 0, $3 + 1240 | 0, $3 + 96 | 0); + wasm2js_i32$0 = $3, wasm2js_f32$0 = Math_fround(float_20b2Abs_float__28float_29(b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 1216 | 0, $3 + 76 | 0)) - b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 1208 | 0, $3 + 88 | 0)), + HEAPF32[wasm2js_i32$0 + 84 >> 2] = wasm2js_f32$0; + if (HEAPF32[$3 + 84 >> 2] > Math_fround(0)) { + continue; + } + label$5: { + if (b2TreeNode__IsLeaf_28_29_20const(HEAP32[$3 + 104 >> 2]) & 1) { + b2RayCastInput__b2RayCastInput_28_29($3 + 56 | 0); + $2 = HEAP32[$3 + 1252 >> 2]; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + $2 = $1; + $1 = $3 + 56 | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + $2 = HEAP32[$3 + 1252 >> 2]; + $0 = HEAP32[$2 + 8 >> 2]; + $1 = HEAP32[$2 + 12 >> 2]; + $2 = $0; + $0 = $3 + 56 | 0; + HEAP32[$0 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $1; + HEAPF32[$3 + 72 >> 2] = HEAPF32[$3 + 1204 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2WorldRayCastWrapper__RayCastCallback_28b2RayCastInput_20const__2c_20int_29(HEAP32[$3 + 1256 >> 2], $3 + 56 | 0, HEAP32[$3 + 108 >> 2]), + HEAPF32[wasm2js_i32$0 + 52 >> 2] = wasm2js_f32$0; + if (HEAPF32[$3 + 52 >> 2] == Math_fround(0)) { + HEAP32[$3 + 48 >> 2] = 1; + break label$2; + } + if (HEAPF32[$3 + 52 >> 2] > Math_fround(0)) { + HEAPF32[$3 + 1204 >> 2] = HEAPF32[$3 + 52 >> 2]; + $4 = HEAPF32[$3 + 1204 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 24 | 0, $3 + 1232 | 0, $3 + 1240 | 0); + operator__28float_2c_20b2Vec2_20const__29($3 + 32 | 0, $4, $3 + 24 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 40 | 0, $3 + 1240 | 0, $3 + 32 | 0); + b2Min_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 16 | 0, $3 + 1240 | 0, $3 + 40 | 0); + $0 = HEAP32[$3 + 20 >> 2]; + $1 = HEAP32[$3 + 16 >> 2]; + $2 = $1; + $1 = $3 + 1188 | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + b2Max_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 8 | 0, $3 + 1240 | 0, $3 + 40 | 0); + $1 = HEAP32[$3 + 12 >> 2]; + $0 = HEAP32[$3 + 8 >> 2]; + $2 = $0; + $0 = $3 + 1188 | 0; + HEAP32[$0 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $1; + } + break label$5; + } + b2GrowableStack_int_2c_20256___Push_28int_20const__29($3 + 112 | 0, HEAP32[$3 + 104 >> 2] + 24 | 0); + b2GrowableStack_int_2c_20256___Push_28int_20const__29($3 + 112 | 0, HEAP32[$3 + 104 >> 2] + 28 | 0); + } + continue; + } + break; + } + HEAP32[$3 + 48 >> 2] = 0; + } + b2GrowableStack_int_2c_20256____b2GrowableStack_28_29($3 + 112 | 0); + __stack_pointer = $3 + 1264 | 0; +} + +function b2ContactManager__AddPair_28void__2c_20void__29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 80 | 0; + __stack_pointer = $3; + HEAP32[$3 + 76 >> 2] = $0; + HEAP32[$3 + 72 >> 2] = $1; + HEAP32[$3 + 68 >> 2] = $2; + $0 = HEAP32[$3 + 76 >> 2]; + HEAP32[$3 + 64 >> 2] = HEAP32[$3 + 72 >> 2]; + HEAP32[$3 + 60 >> 2] = HEAP32[$3 + 68 >> 2]; + HEAP32[$3 + 56 >> 2] = HEAP32[HEAP32[$3 + 64 >> 2] + 16 >> 2]; + HEAP32[$3 + 52 >> 2] = HEAP32[HEAP32[$3 + 60 >> 2] + 16 >> 2]; + HEAP32[$3 + 48 >> 2] = HEAP32[HEAP32[$3 + 64 >> 2] + 20 >> 2]; + HEAP32[$3 + 44 >> 2] = HEAP32[HEAP32[$3 + 60 >> 2] + 20 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$3 + 56 >> 2]), + HEAP32[wasm2js_i32$0 + 40 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$3 + 52 >> 2]), + HEAP32[wasm2js_i32$0 + 36 >> 2] = wasm2js_i32$1; + label$1: { + if (HEAP32[$3 + 40 >> 2] == HEAP32[$3 + 36 >> 2]) { + break label$1; + } + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Body__GetContactList_28_29(HEAP32[$3 + 36 >> 2]), + HEAP32[wasm2js_i32$0 + 32 >> 2] = wasm2js_i32$1; + while (1) { + if (HEAP32[$3 + 32 >> 2]) { + if (HEAP32[HEAP32[$3 + 32 >> 2] >> 2] == HEAP32[$3 + 40 >> 2]) { + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Contact__GetFixtureA_28_29(HEAP32[HEAP32[$3 + 32 >> 2] + 4 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Contact__GetFixtureB_28_29(HEAP32[HEAP32[$3 + 32 >> 2] + 4 >> 2]), + HEAP32[wasm2js_i32$0 + 24 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Contact__GetChildIndexA_28_29_20const(HEAP32[HEAP32[$3 + 32 >> 2] + 4 >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Contact__GetChildIndexB_28_29_20const(HEAP32[HEAP32[$3 + 32 >> 2] + 4 >> 2]), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + if (!(HEAP32[$3 + 28 >> 2] != HEAP32[$3 + 56 >> 2] | HEAP32[$3 + 24 >> 2] != HEAP32[$3 + 52 >> 2] | (HEAP32[$3 + 20 >> 2] != HEAP32[$3 + 48 >> 2] | HEAP32[$3 + 16 >> 2] != HEAP32[$3 + 44 >> 2]))) { + break label$1; + } + if (!(HEAP32[$3 + 28 >> 2] != HEAP32[$3 + 52 >> 2] | HEAP32[$3 + 24 >> 2] != HEAP32[$3 + 56 >> 2] | (HEAP32[$3 + 20 >> 2] != HEAP32[$3 + 44 >> 2] | HEAP32[$3 + 16 >> 2] != HEAP32[$3 + 48 >> 2]))) { + break label$1; + } + } + HEAP32[$3 + 32 >> 2] = HEAP32[HEAP32[$3 + 32 >> 2] + 12 >> 2]; + continue; + } + break; + } + label$7: { + if (!HEAP32[$0 + 68 >> 2]) { + break label$7; + } + $1 = HEAP32[$0 + 68 >> 2]; + if (FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 8 >> 2]]($1, HEAP32[$3 + 56 >> 2], HEAP32[$3 + 52 >> 2]) & 1) { + break label$7; + } + break label$1; + } + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Contact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29(HEAP32[$3 + 56 >> 2], HEAP32[$3 + 48 >> 2], HEAP32[$3 + 52 >> 2], HEAP32[$3 + 44 >> 2], HEAP32[$0 + 76 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + if (!HEAP32[$3 + 12 >> 2]) { + break label$1; + } + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Contact__GetFixtureA_28_29(HEAP32[$3 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 56 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Contact__GetFixtureB_28_29(HEAP32[$3 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 52 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Contact__GetChildIndexA_28_29_20const(HEAP32[$3 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 48 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Contact__GetChildIndexB_28_29_20const(HEAP32[$3 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 44 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$3 + 56 >> 2]), + HEAP32[wasm2js_i32$0 + 40 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$3 + 52 >> 2]), + HEAP32[wasm2js_i32$0 + 36 >> 2] = wasm2js_i32$1; + HEAP32[HEAP32[$3 + 12 >> 2] + 8 >> 2] = 0; + HEAP32[HEAP32[$3 + 12 >> 2] + 12 >> 2] = HEAP32[$0 + 60 >> 2]; + if (HEAP32[$0 + 60 >> 2]) { + HEAP32[HEAP32[$0 + 60 >> 2] + 8 >> 2] = HEAP32[$3 + 12 >> 2]; + } + HEAP32[$0 + 60 >> 2] = HEAP32[$3 + 12 >> 2]; + HEAP32[HEAP32[$3 + 12 >> 2] + 20 >> 2] = HEAP32[$3 + 12 >> 2]; + HEAP32[HEAP32[$3 + 12 >> 2] + 16 >> 2] = HEAP32[$3 + 36 >> 2]; + HEAP32[HEAP32[$3 + 12 >> 2] + 24 >> 2] = 0; + HEAP32[HEAP32[$3 + 12 >> 2] + 28 >> 2] = HEAP32[HEAP32[$3 + 40 >> 2] + 112 >> 2]; + if (HEAP32[HEAP32[$3 + 40 >> 2] + 112 >> 2]) { + HEAP32[HEAP32[HEAP32[$3 + 40 >> 2] + 112 >> 2] + 8 >> 2] = HEAP32[$3 + 12 >> 2] + 16; + } + HEAP32[HEAP32[$3 + 40 >> 2] + 112 >> 2] = HEAP32[$3 + 12 >> 2] + 16; + HEAP32[HEAP32[$3 + 12 >> 2] + 36 >> 2] = HEAP32[$3 + 12 >> 2]; + HEAP32[HEAP32[$3 + 12 >> 2] + 32 >> 2] = HEAP32[$3 + 40 >> 2]; + HEAP32[HEAP32[$3 + 12 >> 2] + 40 >> 2] = 0; + HEAP32[HEAP32[$3 + 12 >> 2] + 44 >> 2] = HEAP32[HEAP32[$3 + 36 >> 2] + 112 >> 2]; + if (HEAP32[HEAP32[$3 + 36 >> 2] + 112 >> 2]) { + HEAP32[HEAP32[HEAP32[$3 + 36 >> 2] + 112 >> 2] + 8 >> 2] = HEAP32[$3 + 12 >> 2] + 32; + } + HEAP32[HEAP32[$3 + 36 >> 2] + 112 >> 2] = HEAP32[$3 + 12 >> 2] + 32; + label$11: { + if (b2Fixture__IsSensor_28_29_20const(HEAP32[$3 + 56 >> 2]) & 1) { + break label$11; + } + if (b2Fixture__IsSensor_28_29_20const(HEAP32[$3 + 52 >> 2]) & 1) { + break label$11; + } + b2Body__SetAwake_28bool_29(HEAP32[$3 + 40 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$3 + 36 >> 2], 1); + } + HEAP32[$0 + 64 >> 2] = HEAP32[$0 + 64 >> 2] + 1; + } + __stack_pointer = $3 + 80 | 0; +} + +function void_20std____2____tree_balance_after_insert_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____2c_20std____2____tree_node_base_void____29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + HEAP8[HEAP32[$2 + 8 >> 2] + 12 | 0] = HEAP32[$2 + 8 >> 2] == HEAP32[$2 + 12 >> 2]; + while (1) { + $0 = 0; + if (HEAP32[$2 + 8 >> 2] != HEAP32[$2 + 12 >> 2]) { + $0 = HEAPU8[std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]) + 12 | 0] ^ -1; + } + label$3: { + if (!($0 & 1)) { + break label$3; + } + label$4: { + if (bool_20std____2____tree_is_left_child_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2])) & 1) { + wasm2js_i32$0 = $2, wasm2js_i32$1 = HEAP32[std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2])) + 4 >> 2], + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + label$6: { + if (!(!HEAP32[$2 + 4 >> 2] | HEAP8[HEAP32[$2 + 4 >> 2] + 12 | 0] & 1)) { + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + HEAP8[HEAP32[$2 + 8 >> 2] + 12 | 0] = 1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + HEAP8[HEAP32[$2 + 8 >> 2] + 12 | 0] = HEAP32[$2 + 8 >> 2] == HEAP32[$2 + 12 >> 2]; + HEAP8[HEAP32[$2 + 4 >> 2] + 12 | 0] = 1; + break label$6; + } + if (!(bool_20std____2____tree_is_left_child_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 8 >> 2]) & 1)) { + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + void_20std____2____tree_left_rotate_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 8 >> 2]); + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + HEAP8[HEAP32[$2 + 8 >> 2] + 12 | 0] = 1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + HEAP8[HEAP32[$2 + 8 >> 2] + 12 | 0] = 0; + void_20std____2____tree_right_rotate_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 8 >> 2]); + break label$3; + } + break label$4; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = HEAP32[HEAP32[std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]) + 8 >> 2] >> 2], + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + label$9: { + if (!(!HEAP32[$2 >> 2] | HEAP8[HEAP32[$2 >> 2] + 12 | 0] & 1)) { + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + HEAP8[HEAP32[$2 + 8 >> 2] + 12 | 0] = 1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + HEAP8[HEAP32[$2 + 8 >> 2] + 12 | 0] = HEAP32[$2 + 8 >> 2] == HEAP32[$2 + 12 >> 2]; + HEAP8[HEAP32[$2 >> 2] + 12 | 0] = 1; + break label$9; + } + if (bool_20std____2____tree_is_left_child_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 8 >> 2]) & 1) { + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + void_20std____2____tree_right_rotate_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 8 >> 2]); + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + HEAP8[HEAP32[$2 + 8 >> 2] + 12 | 0] = 1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + HEAP8[HEAP32[$2 + 8 >> 2] + 12 | 0] = 0; + void_20std____2____tree_left_rotate_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$2 + 8 >> 2]); + break label$3; + } + } + continue; + } + break; + } + __stack_pointer = $2 + 16 | 0; +} + +function b2GearJoint__SolveVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, $5 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 128 | 0; + __stack_pointer = $2; + HEAP32[$2 + 124 >> 2] = $0; + HEAP32[$2 + 120 >> 2] = $1; + $3 = HEAP32[$2 + 124 >> 2]; + $4 = HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 160 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 112 >> 2] = $0; + HEAP32[$2 + 116 >> 2] = $1; + HEAPF32[$2 + 108 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 160 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 164 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 96 >> 2] = $1; + HEAP32[$2 + 100 >> 2] = $0; + HEAPF32[$2 + 92 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 164 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 168 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 80 >> 2] = $0; + HEAP32[$2 + 84 >> 2] = $1; + HEAPF32[$2 + 76 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 168 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 172 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 64 >> 2] = $1; + HEAP32[$2 + 68 >> 2] = $0; + HEAPF32[$2 + 60 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 172 >> 2], 12) | 0) + 8 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 48 | 0, $2 + 112 | 0, $2 + 80 | 0); + $5 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 240 | 0, $2 + 48 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 40 | 0, $2 + 96 | 0, $2 - -64 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround($5 + b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 248 | 0, $2 + 40 | 0)), + HEAPF32[wasm2js_i32$0 + 56 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 56 >> 2] = HEAPF32[$2 + 56 >> 2] + Math_fround(Math_fround(Math_fround(HEAPF32[$3 + 256 >> 2] * HEAPF32[$2 + 108 >> 2]) - Math_fround(HEAPF32[$3 + 264 >> 2] * HEAPF32[$2 + 76 >> 2])) + Math_fround(Math_fround(HEAPF32[$3 + 260 >> 2] * HEAPF32[$2 + 92 >> 2]) - Math_fround(HEAPF32[$3 + 268 >> 2] * HEAPF32[$2 + 60 >> 2]))); + HEAPF32[$2 + 36 >> 2] = Math_fround(-HEAPF32[$3 + 272 >> 2]) * HEAPF32[$2 + 56 >> 2]; + HEAPF32[$3 + 156 >> 2] = HEAPF32[$3 + 156 >> 2] + HEAPF32[$2 + 36 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 28 | 0, Math_fround(HEAPF32[$3 + 208 >> 2] * HEAPF32[$2 + 36 >> 2]), $3 + 240 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 112 | 0, $2 + 28 | 0); + HEAPF32[$2 + 108 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 224 >> 2] * HEAPF32[$2 + 36 >> 2]) * HEAPF32[$3 + 256 >> 2]) + HEAPF32[$2 + 108 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, Math_fround(HEAPF32[$3 + 212 >> 2] * HEAPF32[$2 + 36 >> 2]), $3 + 248 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 96 | 0, $2 + 20 | 0); + HEAPF32[$2 + 92 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 228 >> 2] * HEAPF32[$2 + 36 >> 2]) * HEAPF32[$3 + 260 >> 2]) + HEAPF32[$2 + 92 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, Math_fround(HEAPF32[$3 + 216 >> 2] * HEAPF32[$2 + 36 >> 2]), $3 + 240 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 80 | 0, $2 + 12 | 0); + HEAPF32[$2 + 76 >> 2] = Math_fround(Math_fround(-Math_fround(HEAPF32[$3 + 232 >> 2] * HEAPF32[$2 + 36 >> 2])) * HEAPF32[$3 + 264 >> 2]) + HEAPF32[$2 + 76 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 4 | 0, Math_fround(HEAPF32[$3 + 220 >> 2] * HEAPF32[$2 + 36 >> 2]), $3 + 248 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 - -64 | 0, $2 + 4 | 0); + HEAPF32[$2 + 60 >> 2] = Math_fround(Math_fround(-Math_fround(HEAPF32[$3 + 236 >> 2] * HEAPF32[$2 + 36 >> 2])) * HEAPF32[$3 + 268 >> 2]) + HEAPF32[$2 + 60 >> 2]; + $1 = HEAP32[$2 + 116 >> 2]; + $0 = HEAP32[$2 + 112 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 160 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 160 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 108 >> 2]; + $0 = HEAP32[$2 + 100 >> 2]; + $1 = HEAP32[$2 + 96 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 164 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 164 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 92 >> 2]; + $1 = HEAP32[$2 + 84 >> 2]; + $0 = HEAP32[$2 + 80 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 168 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 168 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 76 >> 2]; + $0 = HEAP32[$2 + 68 >> 2]; + $1 = HEAP32[$2 + 64 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 172 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 172 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 60 >> 2]; + __stack_pointer = $2 + 128 | 0; +} + +function b2Fixture__Dump_28int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 448 | 0; + __stack_pointer = $2; + HEAP32[$2 + 444 >> 2] = $0; + HEAP32[$2 + 440 >> 2] = $1; + $0 = HEAP32[$2 + 444 >> 2]; + b2Dump_28char_20const__2c_20____29(13710, 0); + HEAPF64[$2 + 400 >> 3] = HEAPF32[$0 + 16 >> 2]; + b2Dump_28char_20const__2c_20____29(12833, $2 + 400 | 0); + HEAPF64[$2 + 384 >> 3] = HEAPF32[$0 + 20 >> 2]; + b2Dump_28char_20const__2c_20____29(12805, $2 + 384 | 0); + HEAPF64[$2 + 368 >> 3] = HEAPF32[$0 >> 2]; + b2Dump_28char_20const__2c_20____29(12620, $2 + 368 | 0); + HEAP32[$2 + 352 >> 2] = HEAP8[$0 + 38 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14745, $2 + 352 | 0); + HEAP32[$2 + 336 >> 2] = HEAPU16[$0 + 32 >> 1]; + b2Dump_28char_20const__2c_20____29(14983, $2 + 336 | 0); + HEAP32[$2 + 320 >> 2] = HEAPU16[$0 + 34 >> 1]; + b2Dump_28char_20const__2c_20____29(15025, $2 + 320 | 0); + HEAP32[$2 + 304 >> 2] = HEAP16[$0 + 36 >> 1]; + b2Dump_28char_20const__2c_20____29(15063, $2 + 304 | 0); + label$1: { + label$2: { + label$3: { + switch (HEAP32[HEAP32[$0 + 12 >> 2] + 4 >> 2]) { + case 0: + HEAP32[$2 + 436 >> 2] = HEAP32[$0 + 12 >> 2]; + b2Dump_28char_20const__2c_20____29(13419, 0); + HEAPF64[$2 + 16 >> 3] = HEAPF32[HEAP32[$2 + 436 >> 2] + 8 >> 2]; + b2Dump_28char_20const__2c_20____29(12702, $2 + 16 | 0); + $0 = HEAP32[$2 + 436 >> 2]; + $3 = HEAPF32[$0 + 12 >> 2]; + HEAPF64[$2 + 40 >> 3] = HEAPF32[$0 + 16 >> 2]; + HEAPF64[$2 + 32 >> 3] = $3; + b2Dump_28char_20const__2c_20____29(14065, $2 + 32 | 0); + break label$2; + + case 1: + HEAP32[$2 + 432 >> 2] = HEAP32[$0 + 12 >> 2]; + b2Dump_28char_20const__2c_20____29(13445, 0); + HEAPF64[$2 + 96 >> 3] = HEAPF32[HEAP32[$2 + 432 >> 2] + 8 >> 2]; + b2Dump_28char_20const__2c_20____29(12702, $2 + 96 | 0); + $0 = HEAP32[$2 + 432 >> 2]; + $3 = HEAPF32[$0 + 32 >> 2]; + HEAPF64[$2 + 80 >> 3] = HEAPF32[$0 + 28 >> 2]; + HEAPF64[$2 + 88 >> 3] = $3; + b2Dump_28char_20const__2c_20____29(14452, $2 + 80 | 0); + $0 = HEAP32[$2 + 432 >> 2]; + $3 = HEAPF32[$0 + 16 >> 2]; + HEAPF64[$2 + 64 >> 3] = HEAPF32[$0 + 12 >> 2]; + HEAPF64[$2 + 72 >> 3] = $3; + b2Dump_28char_20const__2c_20____29(14414, $2 - -64 | 0); + $0 = HEAP32[$2 + 432 >> 2]; + $3 = HEAPF32[$0 + 24 >> 2]; + HEAPF64[$2 + 48 >> 3] = HEAPF32[$0 + 20 >> 2]; + HEAPF64[$2 + 56 >> 3] = $3; + b2Dump_28char_20const__2c_20____29(14376, $2 + 48 | 0); + $0 = HEAP32[$2 + 432 >> 2]; + $3 = HEAPF32[$0 + 36 >> 2]; + HEAPF64[$2 + 120 >> 3] = HEAPF32[$0 + 40 >> 2]; + HEAPF64[$2 + 112 >> 3] = $3; + b2Dump_28char_20const__2c_20____29(14338, $2 + 112 | 0); + HEAP32[$2 + 128 >> 2] = HEAP8[HEAP32[$2 + 432 >> 2] + 44 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14920, $2 + 128 | 0); + break label$2; + + case 2: + HEAP32[$2 + 428 >> 2] = HEAP32[$0 + 12 >> 2]; + b2Dump_28char_20const__2c_20____29(13367, 0); + HEAP32[$2 + 192 >> 2] = 8; + b2Dump_28char_20const__2c_20____29(13749, $2 + 192 | 0); + HEAP32[$2 + 424 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 424 >> 2] < HEAP32[HEAP32[$2 + 428 >> 2] + 148 >> 2]) { + $0 = HEAP32[$2 + 424 >> 2]; + $1 = HEAP32[$2 + 428 >> 2] + ($0 << 3) | 0; + $3 = HEAPF32[$1 + 20 >> 2]; + HEAPF64[$2 + 160 >> 3] = HEAPF32[$1 + 24 >> 2]; + HEAPF64[$2 + 152 >> 3] = $3; + HEAP32[$2 + 144 >> 2] = $0; + b2Dump_28char_20const__2c_20____29(14129, $2 + 144 | 0); + HEAP32[$2 + 424 >> 2] = HEAP32[$2 + 424 >> 2] + 1; + continue; + } + break; + } + ; + HEAP32[$2 + 176 >> 2] = HEAP32[HEAP32[$2 + 428 >> 2] + 148 >> 2]; + b2Dump_28char_20const__2c_20____29(15102, $2 + 176 | 0); + break label$2; + + case 3: + break label$3; + + default: + break label$1; + } + } + HEAP32[$2 + 420 >> 2] = HEAP32[$0 + 12 >> 2]; + b2Dump_28char_20const__2c_20____29(13394, 0); + HEAP32[$2 + 288 >> 2] = HEAP32[HEAP32[$2 + 420 >> 2] + 16 >> 2]; + b2Dump_28char_20const__2c_20____29(13749, $2 + 288 | 0); + HEAP32[$2 + 416 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 416 >> 2] < HEAP32[HEAP32[$2 + 420 >> 2] + 16 >> 2]) { + $0 = HEAP32[$2 + 416 >> 2]; + $1 = HEAP32[HEAP32[$2 + 420 >> 2] + 12 >> 2] + ($0 << 3) | 0; + $3 = HEAPF32[$1 >> 2]; + HEAPF64[$2 + 224 >> 3] = HEAPF32[$1 + 4 >> 2]; + HEAPF64[$2 + 216 >> 3] = $3; + HEAP32[$2 + 208 >> 2] = $0; + b2Dump_28char_20const__2c_20____29(14129, $2 + 208 | 0); + HEAP32[$2 + 416 >> 2] = HEAP32[$2 + 416 >> 2] + 1; + continue; + } + break; + } + HEAP32[$2 + 256 >> 2] = HEAP32[HEAP32[$2 + 420 >> 2] + 16 >> 2]; + b2Dump_28char_20const__2c_20____29(15126, $2 + 256 | 0); + $0 = HEAP32[$2 + 420 >> 2]; + $3 = HEAPF32[$0 + 24 >> 2]; + HEAPF64[$2 + 240 >> 3] = HEAPF32[$0 + 20 >> 2]; + HEAPF64[$2 + 248 >> 3] = $3; + b2Dump_28char_20const__2c_20____29(13947, $2 + 240 | 0); + $0 = HEAP32[$2 + 420 >> 2]; + $3 = HEAPF32[$0 + 28 >> 2]; + HEAPF64[$2 + 280 >> 3] = HEAPF32[$0 + 32 >> 2]; + HEAPF64[$2 + 272 >> 3] = $3; + b2Dump_28char_20const__2c_20____29(13988, $2 + 272 | 0); + } + b2Dump_28char_20const__2c_20____29(15365, 0); + b2Dump_28char_20const__2c_20____29(13343, 0); + b2Dump_28char_20const__2c_20____29(15365, 0); + HEAP32[$2 >> 2] = HEAP32[$2 + 440 >> 2]; + b2Dump_28char_20const__2c_20____29(14581, $2); + } + __stack_pointer = $2 + 448 | 0; +} + +function b2MotorJoint__SolveVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 192 | 0; + __stack_pointer = $2; + HEAP32[$2 + 188 >> 2] = $0; + HEAP32[$2 + 184 >> 2] = $1; + $3 = HEAP32[$2 + 188 >> 2]; + $1 = HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0; + $0 = HEAP32[$1 >> 2]; + $4 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 176 >> 2] = $0; + HEAP32[$2 + 180 >> 2] = $4; + HEAPF32[$2 + 172 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0) + 8 >> 2]; + $1 = HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0; + $4 = HEAP32[$1 >> 2]; + $0 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 160 >> 2] = $4; + HEAP32[$2 + 164 >> 2] = $0; + HEAPF32[$2 + 156 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0) + 8 >> 2]; + HEAPF32[$2 + 152 >> 2] = HEAPF32[$3 + 156 >> 2]; + HEAPF32[$2 + 148 >> 2] = HEAPF32[$3 + 160 >> 2]; + HEAPF32[$2 + 144 >> 2] = HEAPF32[$3 + 164 >> 2]; + HEAPF32[$2 + 140 >> 2] = HEAPF32[$3 + 168 >> 2]; + HEAPF32[$2 + 136 >> 2] = HEAPF32[HEAP32[$2 + 184 >> 2] >> 2]; + HEAPF32[$2 + 132 >> 2] = HEAPF32[HEAP32[$2 + 184 >> 2] + 4 >> 2]; + HEAPF32[$2 + 128 >> 2] = Math_fround(Math_fround(HEAPF32[$2 + 132 >> 2] * HEAPF32[$3 + 100 >> 2]) * HEAPF32[$3 + 152 >> 2]) + Math_fround(HEAPF32[$2 + 156 >> 2] - HEAPF32[$2 + 172 >> 2]); + HEAPF32[$2 + 124 >> 2] = Math_fround(-HEAPF32[$3 + 188 >> 2]) * HEAPF32[$2 + 128 >> 2]; + HEAPF32[$2 + 120 >> 2] = HEAPF32[$3 + 88 >> 2]; + HEAPF32[$2 + 116 >> 2] = HEAPF32[$2 + 136 >> 2] * HEAPF32[$3 + 96 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Clamp_float__28float_2c_20float_2c_20float_29(Math_fround(HEAPF32[$3 + 88 >> 2] + HEAPF32[$2 + 124 >> 2]), Math_fround(-HEAPF32[$2 + 116 >> 2]), HEAPF32[$2 + 116 >> 2]), + HEAPF32[wasm2js_i32$0 + 88 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 124 >> 2] = HEAPF32[$3 + 88 >> 2] - HEAPF32[$2 + 120 >> 2]; + HEAPF32[$2 + 172 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 144 >> 2]) * HEAPF32[$2 + 124 >> 2]) + HEAPF32[$2 + 172 >> 2]; + HEAPF32[$2 + 156 >> 2] = Math_fround(HEAPF32[$2 + 140 >> 2] * HEAPF32[$2 + 124 >> 2]) + HEAPF32[$2 + 156 >> 2]; + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 76 | 0, HEAPF32[$2 + 156 >> 2], $3 + 120 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 84 | 0, $2 + 160 | 0, $2 + 76 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 92 | 0, $2 + 84 | 0, $2 + 176 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 68 | 0, HEAPF32[$2 + 172 >> 2], $3 + 112 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 100 | 0, $2 + 92 | 0, $2 + 68 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 60 | 0, Math_fround(HEAPF32[$2 + 132 >> 2] * HEAPF32[$3 + 100 >> 2]), $3 + 144 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 108 | 0, $2 + 100 | 0, $2 + 60 | 0); + b2Mul_28b2Mat22_20const__2c_20b2Vec2_20const__29($2 + 40 | 0, $3 + 172 | 0, $2 + 108 | 0); + b2Vec2__operator__28_29_20const($2 + 48 | 0, $2 + 40 | 0); + $4 = HEAP32[$3 + 84 >> 2]; + $0 = HEAP32[$3 + 80 >> 2]; + HEAP32[$2 + 32 >> 2] = $0; + HEAP32[$2 + 36 >> 2] = $4; + b2Vec2__operator___28b2Vec2_20const__29($3 + 80 | 0, $2 + 48 | 0); + HEAPF32[$2 + 28 >> 2] = HEAPF32[$2 + 136 >> 2] * HEAPF32[$3 + 92 >> 2]; + if (b2Vec2__LengthSquared_28_29_20const($3 + 80 | 0) > Math_fround(HEAPF32[$2 + 28 >> 2] * HEAPF32[$2 + 28 >> 2])) { + b2Vec2__Normalize_28_29($3 + 80 | 0); + b2Vec2__operator___28float_29($3 + 80 | 0, HEAPF32[$2 + 28 >> 2]); + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 20 | 0, $3 + 80 | 0, $2 + 32 | 0); + $0 = HEAP32[$2 + 24 >> 2]; + $4 = HEAP32[$2 + 20 >> 2]; + HEAP32[$2 + 48 >> 2] = $4; + HEAP32[$2 + 52 >> 2] = $0; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$2 + 152 >> 2], $2 + 48 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 176 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 144 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 112 | 0, $2 + 48 | 0)) + HEAPF32[$2 + 172 >> 2]), + HEAPF32[wasm2js_i32$0 + 172 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 4 | 0, HEAPF32[$2 + 148 >> 2], $2 + 48 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 160 | 0, $2 + 4 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$2 + 140 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 120 | 0, $2 + 48 | 0)) + HEAPF32[$2 + 156 >> 2]), + HEAPF32[wasm2js_i32$0 + 156 >> 2] = wasm2js_f32$0; + $4 = HEAP32[$2 + 180 >> 2]; + $0 = HEAP32[$2 + 176 >> 2]; + $1 = $0; + $0 = HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $4; + HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 172 >> 2]; + $0 = HEAP32[$2 + 164 >> 2]; + $4 = HEAP32[$2 + 160 >> 2]; + $1 = $4; + $4 = HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0; + HEAP32[$4 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 184 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 156 >> 2]; + __stack_pointer = $2 + 192 | 0; +} + +function b2Contact__Update_28b2ContactListener__29($0, $1) { + var $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 128 | 0; + __stack_pointer = $2; + HEAP32[$2 + 124 >> 2] = $0; + HEAP32[$2 + 120 >> 2] = $1; + $1 = HEAP32[$2 + 124 >> 2]; + $3 = HEAP32[$1 + 120 >> 2]; + $0 = HEAP32[$1 + 124 >> 2]; + HEAP32[$2 + 112 >> 2] = $3; + HEAP32[$2 + 116 >> 2] = $0; + $3 = HEAP32[$1 + 116 >> 2]; + $0 = HEAP32[$1 + 112 >> 2]; + HEAP32[$2 + 104 >> 2] = $0; + HEAP32[$2 + 108 >> 2] = $3; + $0 = HEAP32[$1 + 108 >> 2]; + $3 = HEAP32[$1 + 104 >> 2]; + HEAP32[$2 + 96 >> 2] = $3; + HEAP32[$2 + 100 >> 2] = $0; + $3 = HEAP32[$1 + 100 >> 2]; + $0 = HEAP32[$1 + 96 >> 2]; + HEAP32[$2 + 88 >> 2] = $0; + HEAP32[$2 + 92 >> 2] = $3; + $0 = HEAP32[$1 + 92 >> 2]; + $3 = HEAP32[$1 + 88 >> 2]; + HEAP32[$2 + 80 >> 2] = $3; + HEAP32[$2 + 84 >> 2] = $0; + $3 = HEAP32[$1 + 84 >> 2]; + $0 = HEAP32[$1 + 80 >> 2]; + HEAP32[$2 + 72 >> 2] = $0; + HEAP32[$2 + 76 >> 2] = $3; + $0 = HEAP32[$1 + 76 >> 2]; + $3 = HEAP32[$1 + 72 >> 2]; + HEAP32[$2 + 64 >> 2] = $3; + HEAP32[$2 + 68 >> 2] = $0; + $3 = HEAP32[$1 + 68 >> 2]; + $0 = HEAP32[$1 + 64 >> 2]; + HEAP32[$2 + 56 >> 2] = $0; + HEAP32[$2 + 60 >> 2] = $3; + HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] | 4; + HEAP8[$2 + 55 | 0] = 0; + HEAP8[$2 + 54 | 0] = (HEAP32[$1 + 4 >> 2] & 2) == 2; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__IsSensor_28_29_20const(HEAP32[$1 + 48 >> 2]) & 1, + HEAP8[wasm2js_i32$0 + 53 | 0] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__IsSensor_28_29_20const(HEAP32[$1 + 52 >> 2]) & 1, + HEAP8[wasm2js_i32$0 + 52 | 0] = wasm2js_i32$1; + $0 = 1; + $0 = HEAP8[$2 + 53 | 0] & 1 ? $0 : HEAPU8[$2 + 52 | 0]; + HEAP8[$2 + 51 | 0] = $0 & 1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$1 + 48 >> 2]), + HEAP32[wasm2js_i32$0 + 44 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$1 + 52 >> 2]), + HEAP32[wasm2js_i32$0 + 40 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Body__GetTransform_28_29_20const(HEAP32[$2 + 44 >> 2]), + HEAP32[wasm2js_i32$0 + 36 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Body__GetTransform_28_29_20const(HEAP32[$2 + 40 >> 2]), + HEAP32[wasm2js_i32$0 + 32 >> 2] = wasm2js_i32$1; + label$2: { + if (HEAP8[$2 + 51 | 0] & 1) { + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetShape_28_29(HEAP32[$1 + 48 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetShape_28_29(HEAP32[$1 + 52 >> 2]), + HEAP32[wasm2js_i32$0 + 24 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2TestOverlap_28b2Shape_20const__2c_20int_2c_20b2Shape_20const__2c_20int_2c_20b2Transform_20const__2c_20b2Transform_20const__29(HEAP32[$2 + 28 >> 2], HEAP32[$1 + 56 >> 2], HEAP32[$2 + 24 >> 2], HEAP32[$1 + 60 >> 2], HEAP32[$2 + 36 >> 2], HEAP32[$2 + 32 >> 2]) & 1, + HEAP8[wasm2js_i32$0 + 55 | 0] = wasm2js_i32$1; + HEAP32[$1 + 124 >> 2] = 0; + break label$2; + } + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] >> 2]]($1, $1 - -64 | 0, HEAP32[$2 + 36 >> 2], HEAP32[$2 + 32 >> 2]); + HEAP8[$2 + 55 | 0] = HEAP32[$1 + 124 >> 2] > 0; + HEAP32[$2 + 20 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 20 >> 2] < HEAP32[$1 + 124 >> 2]) { + HEAP32[$2 + 16 >> 2] = ($1 - -64 | 0) + Math_imul(HEAP32[$2 + 20 >> 2], 20); + HEAPF32[HEAP32[$2 + 16 >> 2] + 8 >> 2] = 0; + HEAPF32[HEAP32[$2 + 16 >> 2] + 12 >> 2] = 0; + HEAP32[$2 + 12 >> 2] = HEAP32[HEAP32[$2 + 16 >> 2] + 16 >> 2]; + HEAP32[$2 + 8 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 8 >> 2] < HEAP32[$2 + 116 >> 2]) { + HEAP32[$2 + 4 >> 2] = ($2 + 56 | 0) + Math_imul(HEAP32[$2 + 8 >> 2], 20); + if (HEAP32[HEAP32[$2 + 4 >> 2] + 16 >> 2] == HEAP32[$2 + 12 >> 2]) { + HEAPF32[HEAP32[$2 + 16 >> 2] + 8 >> 2] = HEAPF32[HEAP32[$2 + 4 >> 2] + 8 >> 2]; + HEAPF32[HEAP32[$2 + 16 >> 2] + 12 >> 2] = HEAPF32[HEAP32[$2 + 4 >> 2] + 12 >> 2]; + } else { + HEAP32[$2 + 8 >> 2] = HEAP32[$2 + 8 >> 2] + 1; + continue; + } + } + break; + } + HEAP32[$2 + 20 >> 2] = HEAP32[$2 + 20 >> 2] + 1; + continue; + } + break; + } + if ((HEAP8[$2 + 55 | 0] & 1) != (HEAP8[$2 + 54 | 0] & 1)) { + b2Body__SetAwake_28bool_29(HEAP32[$2 + 44 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$2 + 40 >> 2], 1); + } + } + label$11: { + if (HEAP8[$2 + 55 | 0] & 1) { + HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] | 2; + break label$11; + } + HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] & -3; + } + if (!(!HEAP32[$2 + 120 >> 2] | (!(HEAP8[$2 + 55 | 0] & 1) | HEAP8[$2 + 54 | 0] & 1))) { + $0 = HEAP32[$2 + 120 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 8 >> 2]]($0, $1); + } + if (!(!HEAP32[$2 + 120 >> 2] | (!(HEAP8[$2 + 54 | 0] & 1) | HEAP8[$2 + 55 | 0] & 1))) { + $0 = HEAP32[$2 + 120 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 12 >> 2]]($0, $1); + } + if (!(!HEAP32[$2 + 120 >> 2] | (!(HEAP8[$2 + 55 | 0] & 1) | HEAP8[$2 + 51 | 0] & 1))) { + $0 = HEAP32[$2 + 120 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 16 >> 2]]($0, $1, $2 + 56 | 0); + } + __stack_pointer = $2 + 128 | 0; +} + +function b2FrictionJoint__SolveVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 176 | 0; + __stack_pointer = $2; + HEAP32[$2 + 172 >> 2] = $0; + HEAP32[$2 + 168 >> 2] = $1; + $3 = HEAP32[$2 + 172 >> 2]; + $1 = HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0; + $0 = HEAP32[$1 >> 2]; + $4 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 160 >> 2] = $0; + HEAP32[$2 + 164 >> 2] = $4; + HEAPF32[$2 + 156 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0) + 8 >> 2]; + $1 = HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0; + $4 = HEAP32[$1 >> 2]; + $0 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 144 >> 2] = $4; + HEAP32[$2 + 148 >> 2] = $0; + HEAPF32[$2 + 140 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0) + 8 >> 2]; + HEAPF32[$2 + 136 >> 2] = HEAPF32[$3 + 144 >> 2]; + HEAPF32[$2 + 132 >> 2] = HEAPF32[$3 + 148 >> 2]; + HEAPF32[$2 + 128 >> 2] = HEAPF32[$3 + 152 >> 2]; + HEAPF32[$2 + 124 >> 2] = HEAPF32[$3 + 156 >> 2]; + HEAPF32[$2 + 120 >> 2] = HEAPF32[HEAP32[$2 + 168 >> 2] >> 2]; + HEAPF32[$2 + 116 >> 2] = HEAPF32[$2 + 140 >> 2] - HEAPF32[$2 + 156 >> 2]; + HEAPF32[$2 + 112 >> 2] = Math_fround(-HEAPF32[$3 + 176 >> 2]) * HEAPF32[$2 + 116 >> 2]; + HEAPF32[$2 + 108 >> 2] = HEAPF32[$3 + 92 >> 2]; + HEAPF32[$2 + 104 >> 2] = HEAPF32[$2 + 120 >> 2] * HEAPF32[$3 + 100 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Clamp_float__28float_2c_20float_2c_20float_29(Math_fround(HEAPF32[$3 + 92 >> 2] + HEAPF32[$2 + 112 >> 2]), Math_fround(-HEAPF32[$2 + 104 >> 2]), HEAPF32[$2 + 104 >> 2]), + HEAPF32[wasm2js_i32$0 + 92 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 112 >> 2] = HEAPF32[$3 + 92 >> 2] - HEAPF32[$2 + 108 >> 2]; + HEAPF32[$2 + 156 >> 2] = Math_fround(Math_fround(-HEAPF32[$2 + 128 >> 2]) * HEAPF32[$2 + 112 >> 2]) + HEAPF32[$2 + 156 >> 2]; + HEAPF32[$2 + 140 >> 2] = Math_fround(HEAPF32[$2 + 124 >> 2] * HEAPF32[$2 + 112 >> 2]) + HEAPF32[$2 + 140 >> 2]; + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 72 | 0, HEAPF32[$2 + 140 >> 2], $3 + 120 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 80 | 0, $2 + 144 | 0, $2 + 72 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 88 | 0, $2 + 80 | 0, $2 + 160 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($2 - -64 | 0, HEAPF32[$2 + 156 >> 2], $3 + 112 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 96 | 0, $2 + 88 | 0, $2 - -64 | 0); + b2Mul_28b2Mat22_20const__2c_20b2Vec2_20const__29($2 + 48 | 0, $3 + 160 | 0, $2 + 96 | 0); + b2Vec2__operator__28_29_20const($2 + 56 | 0, $2 + 48 | 0); + $4 = HEAP32[$3 + 88 >> 2]; + $0 = HEAP32[$3 + 84 >> 2]; + HEAP32[$2 + 40 >> 2] = $0; + HEAP32[$2 + 44 >> 2] = $4; + b2Vec2__operator___28b2Vec2_20const__29($3 + 84 | 0, $2 + 56 | 0); + HEAPF32[$2 + 36 >> 2] = HEAPF32[$2 + 120 >> 2] * HEAPF32[$3 + 96 >> 2]; + if (b2Vec2__LengthSquared_28_29_20const($3 + 84 | 0) > Math_fround(HEAPF32[$2 + 36 >> 2] * HEAPF32[$2 + 36 >> 2])) { + b2Vec2__Normalize_28_29($3 + 84 | 0); + b2Vec2__operator___28float_29($3 + 84 | 0, HEAPF32[$2 + 36 >> 2]); + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 28 | 0, $3 + 84 | 0, $2 + 40 | 0); + $0 = HEAP32[$2 + 32 >> 2]; + $4 = HEAP32[$2 + 28 >> 2]; + HEAP32[$2 + 56 >> 2] = $4; + HEAP32[$2 + 60 >> 2] = $0; + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, HEAPF32[$2 + 136 >> 2], $2 + 56 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 160 | 0, $2 + 20 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$2 + 128 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 112 | 0, $2 + 56 | 0)) + HEAPF32[$2 + 156 >> 2]), + HEAPF32[wasm2js_i32$0 + 156 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$2 + 132 >> 2], $2 + 56 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 144 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$2 + 124 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 120 | 0, $2 + 56 | 0)) + HEAPF32[$2 + 140 >> 2]), + HEAPF32[wasm2js_i32$0 + 140 >> 2] = wasm2js_f32$0; + $4 = HEAP32[$2 + 164 >> 2]; + $0 = HEAP32[$2 + 160 >> 2]; + $1 = $0; + $0 = HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $4; + HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 104 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 156 >> 2]; + $0 = HEAP32[$2 + 148 >> 2]; + $4 = HEAP32[$2 + 144 >> 2]; + $1 = $4; + $4 = HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0; + HEAP32[$4 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 168 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 140 >> 2]; + __stack_pointer = $2 + 176 | 0; +} + +function b2MouseJoint__InitVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, $5 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 144 | 0; + __stack_pointer = $2; + HEAP32[$2 + 140 >> 2] = $0; + HEAP32[$2 + 136 >> 2] = $1; + $1 = HEAP32[$2 + 140 >> 2]; + HEAP32[$1 + 116 >> 2] = HEAP32[HEAP32[$1 + 52 >> 2] + 8 >> 2]; + $4 = HEAP32[$1 + 52 >> 2]; + $0 = HEAP32[$4 + 28 >> 2]; + $3 = HEAP32[$4 + 32 >> 2]; + HEAP32[$1 + 128 >> 2] = $0; + HEAP32[$1 + 132 >> 2] = $3; + HEAPF32[$1 + 136 >> 2] = HEAPF32[HEAP32[$1 + 52 >> 2] + 120 >> 2]; + HEAPF32[$1 + 140 >> 2] = HEAPF32[HEAP32[$1 + 52 >> 2] + 128 >> 2]; + $4 = HEAP32[HEAP32[$2 + 136 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 116 >> 2], 12) | 0; + $3 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 128 >> 2] = $3; + HEAP32[$2 + 132 >> 2] = $0; + HEAPF32[$2 + 124 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 136 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 116 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 136 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 116 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $3 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 112 >> 2] = $0; + HEAP32[$2 + 116 >> 2] = $3; + HEAPF32[$2 + 108 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 136 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 116 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 100 | 0, HEAPF32[$2 + 124 >> 2]); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Body__GetMass_28_29_20const(HEAP32[$1 + 52 >> 2]), + HEAPF32[wasm2js_i32$0 + 96 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 92 >> 2] = HEAPF32[$1 + 84 >> 2] * Math_fround(6.2831854820251465); + $5 = HEAPF32[$2 + 96 >> 2]; + HEAPF32[$2 + 88 >> 2] = Math_fround(Math_fround($5 + $5) * HEAPF32[$1 + 88 >> 2]) * HEAPF32[$2 + 92 >> 2]; + HEAPF32[$2 + 84 >> 2] = HEAPF32[$2 + 96 >> 2] * Math_fround(HEAPF32[$2 + 92 >> 2] * HEAPF32[$2 + 92 >> 2]); + HEAPF32[$2 + 80 >> 2] = HEAPF32[HEAP32[$2 + 136 >> 2] >> 2]; + HEAPF32[$1 + 108 >> 2] = HEAPF32[$2 + 80 >> 2] * Math_fround(Math_fround(HEAPF32[$2 + 80 >> 2] * HEAPF32[$2 + 84 >> 2]) + HEAPF32[$2 + 88 >> 2]); + if (HEAPF32[$1 + 108 >> 2] != Math_fround(0)) { + HEAPF32[$1 + 108 >> 2] = Math_fround(1) / HEAPF32[$1 + 108 >> 2]; + } + HEAPF32[$1 + 92 >> 2] = Math_fround(HEAPF32[$2 + 80 >> 2] * HEAPF32[$2 + 84 >> 2]) * HEAPF32[$1 + 108 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 - -64 | 0, $1 + 68 | 0, $1 + 128 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 72 | 0, $2 + 100 | 0, $2 - -64 | 0); + $0 = HEAP32[$2 + 76 >> 2]; + $3 = HEAP32[$2 + 72 >> 2]; + HEAP32[$1 + 120 >> 2] = $3; + HEAP32[$1 + 124 >> 2] = $0; + b2Mat22__b2Mat22_28_29($2 + 48 | 0); + HEAPF32[$2 + 48 >> 2] = Math_fround(Math_fround(Math_fround(HEAPF32[$1 + 140 >> 2] * HEAPF32[$1 + 124 >> 2]) * HEAPF32[$1 + 124 >> 2]) + HEAPF32[$1 + 136 >> 2]) + HEAPF32[$1 + 108 >> 2]; + HEAPF32[$2 + 52 >> 2] = Math_fround(Math_fround(-HEAPF32[$1 + 140 >> 2]) * HEAPF32[$1 + 120 >> 2]) * HEAPF32[$1 + 124 >> 2]; + HEAPF32[$2 + 56 >> 2] = HEAPF32[$2 + 52 >> 2]; + HEAPF32[$2 + 60 >> 2] = Math_fround(Math_fround(Math_fround(HEAPF32[$1 + 140 >> 2] * HEAPF32[$1 + 120 >> 2]) * HEAPF32[$1 + 120 >> 2]) + HEAPF32[$1 + 136 >> 2]) + HEAPF32[$1 + 108 >> 2]; + b2Mat22__GetInverse_28_29_20const($2 + 32 | 0, $2 + 48 | 0); + $3 = HEAP32[$2 + 36 >> 2]; + $0 = HEAP32[$2 + 32 >> 2]; + HEAP32[$1 + 144 >> 2] = $0; + HEAP32[$1 + 148 >> 2] = $3; + $0 = HEAP32[$2 + 44 >> 2]; + $3 = HEAP32[$2 + 40 >> 2]; + HEAP32[$1 + 152 >> 2] = $3; + HEAP32[$1 + 156 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 16 | 0, $2 + 128 | 0, $1 + 120 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 24 | 0, $2 + 16 | 0, $1 + 76 | 0); + $3 = HEAP32[$2 + 28 >> 2]; + $0 = HEAP32[$2 + 24 >> 2]; + HEAP32[$1 + 160 >> 2] = $0; + HEAP32[$1 + 164 >> 2] = $3; + b2Vec2__operator___28float_29($1 + 160 | 0, HEAPF32[$1 + 92 >> 2]); + HEAPF32[$2 + 108 >> 2] = HEAPF32[$2 + 108 >> 2] * Math_fround(.9800000190734863); + label$2: { + if (HEAP8[HEAP32[$2 + 136 >> 2] + 20 | 0] & 1) { + b2Vec2__operator___28float_29($1 + 96 | 0, HEAPF32[HEAP32[$2 + 136 >> 2] + 8 >> 2]); + operator__28float_2c_20b2Vec2_20const__29($2 + 8 | 0, HEAPF32[$1 + 136 >> 2], $1 + 96 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 112 | 0, $2 + 8 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$1 + 140 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 120 | 0, $1 + 96 | 0)) + HEAPF32[$2 + 108 >> 2]), + HEAPF32[wasm2js_i32$0 + 108 >> 2] = wasm2js_f32$0; + break label$2; + } + b2Vec2__SetZero_28_29($1 + 96 | 0); + } + $0 = HEAP32[$2 + 116 >> 2]; + $3 = HEAP32[$2 + 112 >> 2]; + $4 = $3; + $3 = HEAP32[HEAP32[$2 + 136 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 116 >> 2], 12) | 0; + HEAP32[$3 >> 2] = $4; + HEAP32[$3 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 136 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 116 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 108 >> 2]; + __stack_pointer = $2 + 144 | 0; +} + +function b2SeparationFunction__FindMinSeparation_28int__2c_20int__2c_20float_29_20const($0, $1, $2, $3) { + var $4 = 0, $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $4 = __stack_pointer - 256 | 0; + __stack_pointer = $4; + HEAP32[$4 + 248 >> 2] = $0; + HEAP32[$4 + 244 >> 2] = $1; + HEAP32[$4 + 240 >> 2] = $2; + HEAPF32[$4 + 236 >> 2] = $3; + $2 = HEAP32[$4 + 248 >> 2]; + b2Transform__b2Transform_28_29($4 + 220 | 0); + b2Transform__b2Transform_28_29($4 + 204 | 0); + b2Sweep__GetTransform_28b2Transform__2c_20float_29_20const($2 + 8 | 0, $4 + 220 | 0, HEAPF32[$4 + 236 >> 2]); + b2Sweep__GetTransform_28b2Transform__2c_20float_29_20const($2 + 44 | 0, $4 + 204 | 0, HEAPF32[$4 + 236 >> 2]); + label$1: { + label$2: { + switch (HEAP32[$2 + 80 >> 2]) { + case 0: + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($4 + 196 | 0, $4 + 228 | 0, $2 + 92 | 0); + b2Vec2__operator__28_29_20const($4 + 180 | 0, $2 + 92 | 0); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($4 + 188 | 0, $4 + 212 | 0, $4 + 180 | 0); + $0 = b2DistanceProxy__GetSupport_28b2Vec2_20const__29_20const(HEAP32[$2 >> 2], $4 + 196 | 0); + HEAP32[HEAP32[$4 + 244 >> 2] >> 2] = $0; + $0 = b2DistanceProxy__GetSupport_28b2Vec2_20const__29_20const(HEAP32[$2 + 4 >> 2], $4 + 188 | 0); + HEAP32[HEAP32[$4 + 240 >> 2] >> 2] = $0; + $5 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$2 >> 2], HEAP32[HEAP32[$4 + 244 >> 2] >> 2]); + $1 = HEAP32[$5 >> 2]; + $0 = HEAP32[$5 + 4 >> 2]; + HEAP32[$4 + 168 >> 2] = $1; + HEAP32[$4 + 172 >> 2] = $0; + $5 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$2 + 4 >> 2], HEAP32[HEAP32[$4 + 240 >> 2] >> 2]); + $0 = HEAP32[$5 >> 2]; + $1 = HEAP32[$5 + 4 >> 2]; + HEAP32[$4 + 160 >> 2] = $0; + HEAP32[$4 + 164 >> 2] = $1; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 152 | 0, $4 + 220 | 0, $4 + 168 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 144 | 0, $4 + 204 | 0, $4 + 160 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 132 | 0, $4 + 144 | 0, $4 + 152 | 0); + wasm2js_i32$0 = $4, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 132 | 0, $2 + 92 | 0), + HEAPF32[wasm2js_i32$0 + 140 >> 2] = wasm2js_f32$0; + HEAPF32[$4 + 252 >> 2] = HEAPF32[$4 + 140 >> 2]; + break label$1; + + case 1: + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($4 + 124 | 0, $4 + 228 | 0, $2 + 92 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 116 | 0, $4 + 220 | 0, $2 + 84 | 0); + b2Vec2__operator__28_29_20const($4 + 100 | 0, $4 + 124 | 0); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($4 + 108 | 0, $4 + 212 | 0, $4 + 100 | 0); + HEAP32[HEAP32[$4 + 244 >> 2] >> 2] = -1; + $0 = b2DistanceProxy__GetSupport_28b2Vec2_20const__29_20const(HEAP32[$2 + 4 >> 2], $4 + 108 | 0); + HEAP32[HEAP32[$4 + 240 >> 2] >> 2] = $0; + $5 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$2 + 4 >> 2], HEAP32[HEAP32[$4 + 240 >> 2] >> 2]); + $1 = HEAP32[$5 >> 2]; + $0 = HEAP32[$5 + 4 >> 2]; + HEAP32[$4 + 88 >> 2] = $1; + HEAP32[$4 + 92 >> 2] = $0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 80 | 0, $4 + 204 | 0, $4 + 88 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 68 | 0, $4 + 80 | 0, $4 + 116 | 0); + wasm2js_i32$0 = $4, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 68 | 0, $4 + 124 | 0), + HEAPF32[wasm2js_i32$0 + 76 >> 2] = wasm2js_f32$0; + HEAPF32[$4 + 252 >> 2] = HEAPF32[$4 + 76 >> 2]; + break label$1; + + case 2: + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($4 + 60 | 0, $4 + 212 | 0, $2 + 92 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 52 | 0, $4 + 204 | 0, $2 + 84 | 0); + b2Vec2__operator__28_29_20const($4 + 36 | 0, $4 + 60 | 0); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($4 + 44 | 0, $4 + 228 | 0, $4 + 36 | 0); + HEAP32[HEAP32[$4 + 240 >> 2] >> 2] = -1; + $0 = b2DistanceProxy__GetSupport_28b2Vec2_20const__29_20const(HEAP32[$2 >> 2], $4 + 44 | 0); + HEAP32[HEAP32[$4 + 244 >> 2] >> 2] = $0; + $5 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$2 >> 2], HEAP32[HEAP32[$4 + 244 >> 2] >> 2]); + $0 = HEAP32[$5 >> 2]; + $1 = HEAP32[$5 + 4 >> 2]; + HEAP32[$4 + 24 >> 2] = $0; + HEAP32[$4 + 28 >> 2] = $1; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 16 | 0, $4 + 220 | 0, $4 + 24 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 4 | 0, $4 + 16 | 0, $4 + 52 | 0); + wasm2js_i32$0 = $4, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 4 | 0, $4 + 60 | 0), + HEAPF32[wasm2js_i32$0 + 12 >> 2] = wasm2js_f32$0; + HEAPF32[$4 + 252 >> 2] = HEAPF32[$4 + 12 >> 2]; + break label$1; + + default: + break label$2; + } + } + __assert_fail(9147, 5216, 190, 6665); + wasm2js_trap(); + } + __stack_pointer = $4 + 256 | 0; + return HEAPF32[$4 + 252 >> 2]; +} + +function b2Simplex__ReadCache_28b2SimplexCache_20const__2c_20b2DistanceProxy_20const__2c_20b2Transform_20const__2c_20b2DistanceProxy_20const__2c_20b2Transform_20const__29($0, $1, $2, $3, $4, $5) { + var $6 = 0, $7 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $6 = __stack_pointer - 144 | 0; + __stack_pointer = $6; + HEAP32[$6 + 140 >> 2] = $0; + HEAP32[$6 + 136 >> 2] = $1; + HEAP32[$6 + 132 >> 2] = $2; + HEAP32[$6 + 128 >> 2] = $3; + HEAP32[$6 + 124 >> 2] = $4; + HEAP32[$6 + 120 >> 2] = $5; + $3 = HEAP32[$6 + 140 >> 2]; + if (HEAPU16[HEAP32[$6 + 136 >> 2] + 4 >> 1] > 3) { + __assert_fail(12006, 6034, 112, 9742); + wasm2js_trap(); + } + HEAP32[$3 + 108 >> 2] = HEAPU16[HEAP32[$6 + 136 >> 2] + 4 >> 1]; + HEAP32[$6 + 116 >> 2] = $3; + HEAP32[$6 + 112 >> 2] = 0; + while (1) { + if (HEAP32[$6 + 112 >> 2] < HEAP32[$3 + 108 >> 2]) { + HEAP32[$6 + 108 >> 2] = HEAP32[$6 + 116 >> 2] + Math_imul(HEAP32[$6 + 112 >> 2], 36); + HEAP32[HEAP32[$6 + 108 >> 2] + 28 >> 2] = HEAPU8[HEAP32[$6 + 112 >> 2] + (HEAP32[$6 + 136 >> 2] + 6 | 0) | 0]; + HEAP32[HEAP32[$6 + 108 >> 2] + 32 >> 2] = HEAPU8[HEAP32[$6 + 112 >> 2] + (HEAP32[$6 + 136 >> 2] + 9 | 0) | 0]; + $2 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$6 + 132 >> 2], HEAP32[HEAP32[$6 + 108 >> 2] + 28 >> 2]); + $0 = HEAP32[$2 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + HEAP32[$6 + 96 >> 2] = $0; + HEAP32[$6 + 100 >> 2] = $1; + $2 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$6 + 124 >> 2], HEAP32[HEAP32[$6 + 108 >> 2] + 32 >> 2]); + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + HEAP32[$6 + 88 >> 2] = $1; + HEAP32[$6 + 92 >> 2] = $0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($6 + 80 | 0, HEAP32[$6 + 128 >> 2], $6 + 96 | 0); + $1 = HEAP32[$6 + 84 >> 2]; + $0 = HEAP32[$6 + 80 >> 2]; + $2 = $0; + $0 = HEAP32[$6 + 108 >> 2]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($6 + 72 | 0, HEAP32[$6 + 120 >> 2], $6 + 88 | 0); + $0 = HEAP32[$6 + 76 >> 2]; + $1 = HEAP32[$6 + 72 >> 2]; + $2 = $1; + $1 = HEAP32[$6 + 108 >> 2]; + HEAP32[$1 + 8 >> 2] = $2; + HEAP32[$1 + 12 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($6 - -64 | 0, HEAP32[$6 + 108 >> 2] + 8 | 0, HEAP32[$6 + 108 >> 2]); + $1 = HEAP32[$6 + 68 >> 2]; + $0 = HEAP32[$6 + 64 >> 2]; + $2 = $0; + $0 = HEAP32[$6 + 108 >> 2]; + HEAP32[$0 + 16 >> 2] = $2; + HEAP32[$0 + 20 >> 2] = $1; + HEAPF32[HEAP32[$6 + 108 >> 2] + 24 >> 2] = 0; + HEAP32[$6 + 112 >> 2] = HEAP32[$6 + 112 >> 2] + 1; + continue; + } + break; + } + if (HEAP32[$3 + 108 >> 2] > 1) { + HEAPF32[$6 + 60 >> 2] = HEAPF32[HEAP32[$6 + 136 >> 2] >> 2]; + wasm2js_i32$0 = $6, wasm2js_f32$0 = b2Simplex__GetMetric_28_29_20const($3), HEAPF32[wasm2js_i32$0 + 56 >> 2] = wasm2js_f32$0; + label$5: { + label$6: { + if (HEAPF32[$6 + 56 >> 2] < Math_fround(HEAPF32[$6 + 60 >> 2] * Math_fround(.5))) { + break label$6; + } + $7 = HEAPF32[$6 + 60 >> 2]; + if (HEAPF32[$6 + 56 >> 2] > Math_fround($7 + $7)) { + break label$6; + } + if (!(HEAPF32[$6 + 56 >> 2] < Math_fround(1.1920928955078125e-7))) { + break label$5; + } + } + HEAP32[$3 + 108 >> 2] = 0; + } + } + if (!HEAP32[$3 + 108 >> 2]) { + HEAP32[$6 + 52 >> 2] = HEAP32[$6 + 116 >> 2]; + HEAP32[HEAP32[$6 + 52 >> 2] + 28 >> 2] = 0; + HEAP32[HEAP32[$6 + 52 >> 2] + 32 >> 2] = 0; + $2 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$6 + 132 >> 2], 0); + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + HEAP32[$6 + 40 >> 2] = $1; + HEAP32[$6 + 44 >> 2] = $0; + $2 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$6 + 124 >> 2], 0); + $0 = HEAP32[$2 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + HEAP32[$6 + 32 >> 2] = $0; + HEAP32[$6 + 36 >> 2] = $1; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($6 + 24 | 0, HEAP32[$6 + 128 >> 2], $6 + 40 | 0); + $0 = HEAP32[$6 + 28 >> 2]; + $1 = HEAP32[$6 + 24 >> 2]; + $2 = $1; + $1 = HEAP32[$6 + 52 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($6 + 16 | 0, HEAP32[$6 + 120 >> 2], $6 + 32 | 0); + $1 = HEAP32[$6 + 20 >> 2]; + $0 = HEAP32[$6 + 16 >> 2]; + $2 = $0; + $0 = HEAP32[$6 + 52 >> 2]; + HEAP32[$0 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 8 | 0, HEAP32[$6 + 52 >> 2] + 8 | 0, HEAP32[$6 + 52 >> 2]); + $0 = HEAP32[$6 + 12 >> 2]; + $1 = HEAP32[$6 + 8 >> 2]; + $2 = $1; + $1 = HEAP32[$6 + 52 >> 2]; + HEAP32[$1 + 16 >> 2] = $2; + HEAP32[$1 + 20 >> 2] = $0; + HEAPF32[HEAP32[$6 + 52 >> 2] + 24 >> 2] = 1; + HEAP32[$3 + 108 >> 2] = 1; + } + __stack_pointer = $6 + 144 | 0; +} + +function b2RevoluteJoint__Draw_28b2Draw__29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 224 | 0; + __stack_pointer = $2; + HEAP32[$2 + 220 >> 2] = $0; + HEAP32[$2 + 216 >> 2] = $1; + $0 = HEAP32[$2 + 220 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Body__GetTransform_28_29_20const(HEAP32[$0 + 48 >> 2]), + HEAP32[wasm2js_i32$0 + 212 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Body__GetTransform_28_29_20const(HEAP32[$0 + 52 >> 2]), + HEAP32[wasm2js_i32$0 + 208 >> 2] = wasm2js_i32$1; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($2 + 200 | 0, HEAP32[$2 + 212 >> 2], $0 + 68 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($2 + 192 | 0, HEAP32[$2 + 208 >> 2], $0 + 76 | 0); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 176 | 0, Math_fround(.699999988079071), Math_fround(.699999988079071), Math_fround(.699999988079071), Math_fround(1)); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 160 | 0, Math_fround(.30000001192092896), Math_fround(.8999999761581421), Math_fround(.30000001192092896), Math_fround(1)); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 144 | 0, Math_fround(.8999999761581421), Math_fround(.30000001192092896), Math_fround(.30000001192092896), Math_fround(1)); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 128 | 0, Math_fround(.30000001192092896), Math_fround(.30000001192092896), Math_fround(.8999999761581421), Math_fround(1)); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 112 | 0, Math_fround(.4000000059604645), Math_fround(.4000000059604645), Math_fround(.4000000059604645), Math_fround(1)); + $1 = HEAP32[$2 + 216 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 32 >> 2]]($1, $2 + 200 | 0, Math_fround(5), $2 + 128 | 0); + $1 = HEAP32[$2 + 216 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 32 >> 2]]($1, $2 + 192 | 0, Math_fround(5), $2 + 112 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Body__GetAngle_28_29_20const(HEAP32[$0 + 48 >> 2]), + HEAPF32[wasm2js_i32$0 + 108 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Body__GetAngle_28_29_20const(HEAP32[$0 + 52 >> 2]), + HEAPF32[wasm2js_i32$0 + 104 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 100 >> 2] = Math_fround(HEAPF32[$2 + 104 >> 2] - HEAPF32[$2 + 108 >> 2]) - HEAPF32[$0 + 120 >> 2]; + HEAPF32[$2 + 96 >> 2] = .5; + b2Vec2__b2Vec2_28float_2c_20float_29($2 + 80 | 0, cosf(HEAPF32[$2 + 100 >> 2]), sinf(HEAPF32[$2 + 100 >> 2])); + operator__28float_2c_20b2Vec2_20const__29($2 + 88 | 0, Math_fround(.5), $2 + 80 | 0); + $1 = HEAP32[$2 + 216 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 72 | 0, $2 + 192 | 0, $2 + 88 | 0); + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 24 >> 2]]($1, $2 + 192 | 0, $2 + 72 | 0, $2 + 176 | 0); + $1 = HEAP32[$2 + 216 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 16 >> 2]]($1, $2 + 192 | 0, Math_fround(.5), $2 + 176 | 0); + if (HEAP8[$0 + 116 | 0] & 1) { + b2Vec2__b2Vec2_28float_2c_20float_29($2 + 56 | 0, cosf(HEAPF32[$0 + 124 >> 2]), sinf(HEAPF32[$0 + 124 >> 2])); + operator__28float_2c_20b2Vec2_20const__29($2 - -64 | 0, Math_fround(.5), $2 + 56 | 0); + b2Vec2__b2Vec2_28float_2c_20float_29($2 + 40 | 0, cosf(HEAPF32[$0 + 128 >> 2]), sinf(HEAPF32[$0 + 128 >> 2])); + operator__28float_2c_20b2Vec2_20const__29($2 + 48 | 0, Math_fround(.5), $2 + 40 | 0); + $0 = HEAP32[$2 + 216 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 32 | 0, $2 + 192 | 0, $2 - -64 | 0); + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 192 | 0, $2 + 32 | 0, $2 + 160 | 0); + $0 = HEAP32[$2 + 216 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 24 | 0, $2 + 192 | 0, $2 + 48 | 0); + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 192 | 0, $2 + 24 | 0, $2 + 144 | 0); + } + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 8 | 0, Math_fround(.5), Math_fround(.800000011920929), Math_fround(.800000011920929), Math_fround(1)); + $0 = HEAP32[$2 + 216 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, HEAP32[$2 + 212 >> 2], $2 + 200 | 0, $2 + 8 | 0); + $0 = HEAP32[$2 + 216 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 200 | 0, $2 + 192 | 0, $2 + 8 | 0); + $0 = HEAP32[$2 + 216 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, HEAP32[$2 + 208 >> 2], $2 + 192 | 0, $2 + 8 | 0); + __stack_pointer = $2 + 224 | 0; +} + +function b2World__DrawShape_28b2Fixture__2c_20b2Transform_20const__2c_20b2Color_20const__29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 192 | 0; + __stack_pointer = $4; + HEAP32[$4 + 188 >> 2] = $0; + HEAP32[$4 + 184 >> 2] = $1; + HEAP32[$4 + 180 >> 2] = $2; + HEAP32[$4 + 176 >> 2] = $3; + $3 = HEAP32[$4 + 188 >> 2]; + label$1: { + label$2: { + switch (b2Fixture__GetType_28_29_20const(HEAP32[$4 + 184 >> 2]) | 0) { + case 0: + wasm2js_i32$0 = $4, wasm2js_i32$1 = b2Fixture__GetShape_28_29(HEAP32[$4 + 184 >> 2]), + HEAP32[wasm2js_i32$0 + 172 >> 2] = wasm2js_i32$1; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 164 | 0, HEAP32[$4 + 180 >> 2], HEAP32[$4 + 172 >> 2] + 12 | 0); + HEAPF32[$4 + 160 >> 2] = HEAPF32[HEAP32[$4 + 172 >> 2] + 8 >> 2]; + $0 = HEAP32[$4 + 180 >> 2]; + b2Vec2__b2Vec2_28float_2c_20float_29($4 + 144 | 0, Math_fround(1), Math_fround(0)); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($4 + 152 | 0, $0 + 8 | 0, $4 + 144 | 0); + $0 = HEAP32[$3 + 102980 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 20 >> 2]]($0, $4 + 164 | 0, HEAPF32[$4 + 160 >> 2], $4 + 152 | 0, HEAP32[$4 + 176 >> 2]); + break label$1; + + case 1: + wasm2js_i32$0 = $4, wasm2js_i32$1 = b2Fixture__GetShape_28_29(HEAP32[$4 + 184 >> 2]), + HEAP32[wasm2js_i32$0 + 140 >> 2] = wasm2js_i32$1; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 132 | 0, HEAP32[$4 + 180 >> 2], HEAP32[$4 + 140 >> 2] + 12 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 124 | 0, HEAP32[$4 + 180 >> 2], HEAP32[$4 + 140 >> 2] + 20 | 0); + $0 = HEAP32[$3 + 102980 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $4 + 132 | 0, $4 + 124 | 0, HEAP32[$4 + 176 >> 2]); + if (!(HEAP8[HEAP32[$4 + 140 >> 2] + 44 | 0] & 1)) { + $0 = HEAP32[$3 + 102980 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 32 >> 2]]($0, $4 + 132 | 0, Math_fround(4), HEAP32[$4 + 176 >> 2]); + $0 = HEAP32[$3 + 102980 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 32 >> 2]]($0, $4 + 124 | 0, Math_fround(4), HEAP32[$4 + 176 >> 2]); + } + break label$1; + + case 3: + wasm2js_i32$0 = $4, wasm2js_i32$1 = b2Fixture__GetShape_28_29(HEAP32[$4 + 184 >> 2]), + HEAP32[wasm2js_i32$0 + 120 >> 2] = wasm2js_i32$1; + HEAP32[$4 + 116 >> 2] = HEAP32[HEAP32[$4 + 120 >> 2] + 16 >> 2]; + HEAP32[$4 + 112 >> 2] = HEAP32[HEAP32[$4 + 120 >> 2] + 12 >> 2]; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 104 | 0, HEAP32[$4 + 180 >> 2], HEAP32[$4 + 112 >> 2]); + HEAP32[$4 + 100 >> 2] = 1; + while (1) { + if (HEAP32[$4 + 100 >> 2] < HEAP32[$4 + 116 >> 2]) { + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 92 | 0, HEAP32[$4 + 180 >> 2], HEAP32[$4 + 112 >> 2] + (HEAP32[$4 + 100 >> 2] << 3) | 0); + $0 = HEAP32[$3 + 102980 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $4 + 104 | 0, $4 + 92 | 0, HEAP32[$4 + 176 >> 2]); + $1 = HEAP32[$4 + 96 >> 2]; + $0 = HEAP32[$4 + 92 >> 2]; + HEAP32[$4 + 104 >> 2] = $0; + HEAP32[$4 + 108 >> 2] = $1; + HEAP32[$4 + 100 >> 2] = HEAP32[$4 + 100 >> 2] + 1; + continue; + } + break; + } + ; + break label$1; + + case 2: + break label$2; + + default: + break label$1; + } + } + wasm2js_i32$0 = $4, wasm2js_i32$1 = b2Fixture__GetShape_28_29(HEAP32[$4 + 184 >> 2]), + HEAP32[wasm2js_i32$0 + 88 >> 2] = wasm2js_i32$1; + HEAP32[$4 + 84 >> 2] = HEAP32[HEAP32[$4 + 88 >> 2] + 148 >> 2]; + if (HEAP32[$4 + 84 >> 2] > 8) { + __assert_fail(11970, 6161, 1090, 9300); + wasm2js_trap(); + } + $0 = $4 + 16 | 0; + $1 = $0 - -64 | 0; + while (1) { + b2Vec2__b2Vec2_28_29($0); + $0 = $0 + 8 | 0; + if (($1 | 0) != ($0 | 0)) { + continue; + } + break; + } + HEAP32[$4 + 12 >> 2] = 0; + while (1) { + if (HEAP32[$4 + 12 >> 2] < HEAP32[$4 + 84 >> 2]) { + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 4 | 0, HEAP32[$4 + 180 >> 2], (HEAP32[$4 + 88 >> 2] + 20 | 0) + (HEAP32[$4 + 12 >> 2] << 3) | 0); + $0 = HEAP32[$4 + 8 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + $2 = $1; + $1 = ($4 + 16 | 0) + (HEAP32[$4 + 12 >> 2] << 3) | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAP32[$4 + 12 >> 2] = HEAP32[$4 + 12 >> 2] + 1; + continue; + } + break; + } + $0 = HEAP32[$3 + 102980 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 12 >> 2]]($0, $4 + 16 | 0, HEAP32[$4 + 84 >> 2], HEAP32[$4 + 176 >> 2]); + } + __stack_pointer = $4 + 192 | 0; +} + +function b2PrismaticJoint__Draw_28b2Draw__29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 256 | 0; + __stack_pointer = $2; + HEAP32[$2 + 252 >> 2] = $0; + HEAP32[$2 + 248 >> 2] = $1; + $0 = HEAP32[$2 + 252 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Body__GetTransform_28_29_20const(HEAP32[$0 + 48 >> 2]), + HEAP32[wasm2js_i32$0 + 244 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Body__GetTransform_28_29_20const(HEAP32[$0 + 52 >> 2]), + HEAP32[wasm2js_i32$0 + 240 >> 2] = wasm2js_i32$1; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($2 + 232 | 0, HEAP32[$2 + 244 >> 2], $0 + 68 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($2 + 224 | 0, HEAP32[$2 + 240 >> 2], $0 + 76 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 216 | 0, HEAP32[$2 + 244 >> 2] + 8 | 0, $0 + 84 | 0); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 200 | 0, Math_fround(.699999988079071), Math_fround(.699999988079071), Math_fround(.699999988079071), Math_fround(1)); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 184 | 0, Math_fround(.30000001192092896), Math_fround(.8999999761581421), Math_fround(.30000001192092896), Math_fround(1)); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 168 | 0, Math_fround(.8999999761581421), Math_fround(.30000001192092896), Math_fround(.30000001192092896), Math_fround(1)); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 152 | 0, Math_fround(.30000001192092896), Math_fround(.30000001192092896), Math_fround(.8999999761581421), Math_fround(1)); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 136 | 0, Math_fround(.4000000059604645), Math_fround(.4000000059604645), Math_fround(.4000000059604645), Math_fround(1)); + $1 = HEAP32[$2 + 248 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 24 >> 2]]($1, $2 + 232 | 0, $2 + 224 | 0, $2 + 136 | 0); + label$1: { + if (HEAP8[$0 + 140 | 0] & 1) { + operator__28float_2c_20b2Vec2_20const__29($2 + 120 | 0, HEAPF32[$0 + 124 >> 2], $2 + 216 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 128 | 0, $2 + 232 | 0, $2 + 120 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 104 | 0, HEAPF32[$0 + 128 >> 2], $2 + 216 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 112 | 0, $2 + 232 | 0, $2 + 104 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 96 | 0, HEAP32[$2 + 244 >> 2] + 8 | 0, $0 + 92 | 0); + $0 = HEAP32[$2 + 248 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 128 | 0, $2 + 112 | 0, $2 + 200 | 0); + $0 = HEAP32[$2 + 248 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 80 | 0, Math_fround(.5), $2 + 96 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 88 | 0, $2 + 128 | 0, $2 + 80 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 - -64 | 0, Math_fround(.5), $2 + 96 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 72 | 0, $2 + 128 | 0, $2 - -64 | 0); + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 88 | 0, $2 + 72 | 0, $2 + 184 | 0); + $0 = HEAP32[$2 + 248 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 48 | 0, Math_fround(.5), $2 + 96 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 56 | 0, $2 + 112 | 0, $2 + 48 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 32 | 0, Math_fround(.5), $2 + 96 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 40 | 0, $2 + 112 | 0, $2 + 32 | 0); + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 56 | 0, $2 + 40 | 0, $2 + 168 | 0); + break label$1; + } + $0 = HEAP32[$2 + 248 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 16 | 0, Math_fround(1), $2 + 216 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 24 | 0, $2 + 232 | 0, $2 + 16 | 0); + operator__28float_2c_20b2Vec2_20const__29($2, Math_fround(1), $2 + 216 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 8 | 0, $2 + 232 | 0, $2); + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 24 | 0, $2 + 8 | 0, $2 + 200 | 0); + } + $0 = HEAP32[$2 + 248 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 32 >> 2]]($0, $2 + 232 | 0, Math_fround(5), $2 + 200 | 0); + $0 = HEAP32[$2 + 248 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 32 >> 2]]($0, $2 + 224 | 0, Math_fround(5), $2 + 152 | 0); + __stack_pointer = $2 + 256 | 0; +} + +function b2WheelJoint__Draw_28b2Draw__29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 256 | 0; + __stack_pointer = $2; + HEAP32[$2 + 252 >> 2] = $0; + HEAP32[$2 + 248 >> 2] = $1; + $0 = HEAP32[$2 + 252 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Body__GetTransform_28_29_20const(HEAP32[$0 + 48 >> 2]), + HEAP32[wasm2js_i32$0 + 244 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Body__GetTransform_28_29_20const(HEAP32[$0 + 52 >> 2]), + HEAP32[wasm2js_i32$0 + 240 >> 2] = wasm2js_i32$1; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($2 + 232 | 0, HEAP32[$2 + 244 >> 2], $0 + 68 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($2 + 224 | 0, HEAP32[$2 + 240 >> 2], $0 + 76 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 216 | 0, HEAP32[$2 + 244 >> 2] + 8 | 0, $0 + 84 | 0); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 200 | 0, Math_fround(.699999988079071), Math_fround(.699999988079071), Math_fround(.699999988079071), Math_fround(1)); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 184 | 0, Math_fround(.30000001192092896), Math_fround(.8999999761581421), Math_fround(.30000001192092896), Math_fround(1)); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 168 | 0, Math_fround(.8999999761581421), Math_fround(.30000001192092896), Math_fround(.30000001192092896), Math_fround(1)); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 152 | 0, Math_fround(.30000001192092896), Math_fround(.30000001192092896), Math_fround(.8999999761581421), Math_fround(1)); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 136 | 0, Math_fround(.4000000059604645), Math_fround(.4000000059604645), Math_fround(.4000000059604645), Math_fround(1)); + $1 = HEAP32[$2 + 248 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 24 >> 2]]($1, $2 + 232 | 0, $2 + 224 | 0, $2 + 136 | 0); + label$1: { + if (HEAP8[$0 + 140 | 0] & 1) { + operator__28float_2c_20b2Vec2_20const__29($2 + 120 | 0, HEAPF32[$0 + 124 >> 2], $2 + 216 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 128 | 0, $2 + 232 | 0, $2 + 120 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 104 | 0, HEAPF32[$0 + 128 >> 2], $2 + 216 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 112 | 0, $2 + 232 | 0, $2 + 104 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 96 | 0, HEAP32[$2 + 244 >> 2] + 8 | 0, $0 + 92 | 0); + $0 = HEAP32[$2 + 248 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 128 | 0, $2 + 112 | 0, $2 + 200 | 0); + $0 = HEAP32[$2 + 248 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 80 | 0, Math_fround(.5), $2 + 96 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 88 | 0, $2 + 128 | 0, $2 + 80 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 - -64 | 0, Math_fround(.5), $2 + 96 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 72 | 0, $2 + 128 | 0, $2 - -64 | 0); + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 88 | 0, $2 + 72 | 0, $2 + 184 | 0); + $0 = HEAP32[$2 + 248 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 48 | 0, Math_fround(.5), $2 + 96 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 56 | 0, $2 + 112 | 0, $2 + 48 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 32 | 0, Math_fround(.5), $2 + 96 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 40 | 0, $2 + 112 | 0, $2 + 32 | 0); + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 56 | 0, $2 + 40 | 0, $2 + 168 | 0); + break label$1; + } + $0 = HEAP32[$2 + 248 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 16 | 0, Math_fround(1), $2 + 216 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 24 | 0, $2 + 232 | 0, $2 + 16 | 0); + operator__28float_2c_20b2Vec2_20const__29($2, Math_fround(1), $2 + 216 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 8 | 0, $2 + 232 | 0, $2); + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 24 | 0, $2 + 8 | 0, $2 + 200 | 0); + } + $0 = HEAP32[$2 + 248 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 32 >> 2]]($0, $2 + 232 | 0, Math_fround(5), $2 + 200 | 0); + $0 = HEAP32[$2 + 248 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 32 >> 2]]($0, $2 + 224 | 0, Math_fround(5), $2 + 152 | 0); + __stack_pointer = $2 + 256 | 0; +} + +function b2PositionSolverManifold__Initialize_28b2ContactPositionConstraint__2c_20b2Transform_20const__2c_20b2Transform_20const__2c_20int_29($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $5 = __stack_pointer - 144 | 0; + __stack_pointer = $5; + HEAP32[$5 + 140 >> 2] = $0; + HEAP32[$5 + 136 >> 2] = $1; + HEAP32[$5 + 132 >> 2] = $2; + HEAP32[$5 + 128 >> 2] = $3; + HEAP32[$5 + 124 >> 2] = $4; + $1 = HEAP32[$5 + 140 >> 2]; + if (HEAP32[HEAP32[$5 + 136 >> 2] + 84 >> 2] <= 0) { + __assert_fail(12236, 5487, 627, 8606); + wasm2js_trap(); + } + label$2: { + label$3: { + switch (HEAP32[HEAP32[$5 + 136 >> 2] + 72 >> 2]) { + case 0: + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 116 | 0, HEAP32[$5 + 132 >> 2], HEAP32[$5 + 136 >> 2] + 24 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 108 | 0, HEAP32[$5 + 128 >> 2], HEAP32[$5 + 136 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 100 | 0, $5 + 108 | 0, $5 + 116 | 0); + $2 = HEAP32[$5 + 104 >> 2]; + $0 = HEAP32[$5 + 100 >> 2]; + $3 = $0; + $0 = $1; + HEAP32[$0 >> 2] = $3; + HEAP32[$0 + 4 >> 2] = $2; + b2Vec2__Normalize_28_29($0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($5 + 84 | 0, $5 + 116 | 0, $5 + 108 | 0); + operator__28float_2c_20b2Vec2_20const__29($5 + 92 | 0, Math_fround(.5), $5 + 84 | 0); + $0 = HEAP32[$5 + 96 >> 2]; + $2 = HEAP32[$5 + 92 >> 2]; + $3 = $2; + $2 = $1; + HEAP32[$2 + 8 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 76 | 0, $5 + 108 | 0, $5 + 116 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 76 | 0, $2) - HEAPF32[HEAP32[$5 + 136 >> 2] + 76 >> 2]) - HEAPF32[HEAP32[$5 + 136 >> 2] + 80 >> 2]), + HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0; + break label$2; + + case 1: + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($5 + 68 | 0, HEAP32[$5 + 132 >> 2] + 8 | 0, HEAP32[$5 + 136 >> 2] + 16 | 0); + $2 = HEAP32[$5 + 72 >> 2]; + $0 = HEAP32[$5 + 68 >> 2]; + $3 = $0; + $0 = $1; + HEAP32[$0 >> 2] = $3; + HEAP32[$0 + 4 >> 2] = $2; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 60 | 0, HEAP32[$5 + 132 >> 2], HEAP32[$5 + 136 >> 2] + 24 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 52 | 0, HEAP32[$5 + 128 >> 2], HEAP32[$5 + 136 >> 2] + (HEAP32[$5 + 124 >> 2] << 3) | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 44 | 0, $5 + 52 | 0, $5 + 60 | 0); + wasm2js_i32$0 = $0, wasm2js_f32$0 = Math_fround(Math_fround(b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 44 | 0, $0) - HEAPF32[HEAP32[$5 + 136 >> 2] + 76 >> 2]) - HEAPF32[HEAP32[$5 + 136 >> 2] + 80 >> 2]), + HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0; + $0 = HEAP32[$5 + 56 >> 2]; + $2 = HEAP32[$5 + 52 >> 2]; + $3 = $2; + $2 = $1; + HEAP32[$2 + 8 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = $0; + break label$2; + + case 2: + break label$3; + + default: + break label$2; + } + } + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($5 + 36 | 0, HEAP32[$5 + 128 >> 2] + 8 | 0, HEAP32[$5 + 136 >> 2] + 16 | 0); + $2 = HEAP32[$5 + 40 >> 2]; + $0 = HEAP32[$5 + 36 >> 2]; + $3 = $0; + $0 = $1; + HEAP32[$0 >> 2] = $3; + HEAP32[$0 + 4 >> 2] = $2; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 28 | 0, HEAP32[$5 + 128 >> 2], HEAP32[$5 + 136 >> 2] + 24 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 20 | 0, HEAP32[$5 + 132 >> 2], HEAP32[$5 + 136 >> 2] + (HEAP32[$5 + 124 >> 2] << 3) | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 12 | 0, $5 + 20 | 0, $5 + 28 | 0); + wasm2js_i32$0 = $0, wasm2js_f32$0 = Math_fround(Math_fround(b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 12 | 0, $0) - HEAPF32[HEAP32[$5 + 136 >> 2] + 76 >> 2]) - HEAPF32[HEAP32[$5 + 136 >> 2] + 80 >> 2]), + HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0; + $0 = HEAP32[$5 + 24 >> 2]; + $2 = HEAP32[$5 + 20 >> 2]; + $3 = $2; + $2 = $1; + HEAP32[$2 + 8 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = $0; + b2Vec2__operator__28_29_20const($5 + 4 | 0, $2); + $2 = HEAP32[$5 + 8 >> 2]; + $0 = HEAP32[$5 + 4 >> 2]; + $3 = $0; + $0 = $1; + HEAP32[$0 >> 2] = $3; + HEAP32[$0 + 4 >> 2] = $2; + } + __stack_pointer = $5 + 144 | 0; +} + +function b2DistanceJoint__SolvePositionConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0), wasm2js_i32$1 = 0; + $2 = __stack_pointer - 160 | 0; + __stack_pointer = $2; + HEAP32[$2 + 152 >> 2] = $0; + HEAP32[$2 + 148 >> 2] = $1; + $3 = HEAP32[$2 + 152 >> 2]; + label$1: { + if (HEAPF32[$3 + 68 >> 2] > Math_fround(0)) { + HEAP8[$2 + 159 | 0] = 1; + break label$1; + } + $4 = HEAP32[HEAP32[$2 + 148 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 136 >> 2] = $0; + HEAP32[$2 + 140 >> 2] = $1; + HEAPF32[$2 + 132 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 148 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 148 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 112 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 120 >> 2] = $1; + HEAP32[$2 + 124 >> 2] = $0; + HEAPF32[$2 + 116 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 148 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 112 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 108 | 0, HEAPF32[$2 + 132 >> 2]); + b2Rot__b2Rot_28float_29($2 + 100 | 0, HEAPF32[$2 + 116 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 84 | 0, $3 + 80 | 0, $3 + 140 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 92 | 0, $2 + 108 | 0, $2 + 84 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 68 | 0, $3 + 88 | 0, $3 + 148 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 76 | 0, $2 + 100 | 0, $2 + 68 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 44 | 0, $2 + 120 | 0, $2 + 76 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 52 | 0, $2 + 44 | 0, $2 + 136 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 60 | 0, $2 + 52 | 0, $2 + 92 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Vec2__Normalize_28_29($2 + 60 | 0), HEAPF32[wasm2js_i32$0 + 40 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 36 >> 2] = HEAPF32[$2 + 40 >> 2] - HEAPF32[$3 + 104 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Clamp_float__28float_2c_20float_2c_20float_29(HEAPF32[$2 + 36 >> 2], Math_fround(-.20000000298023224), Math_fround(.20000000298023224)), + HEAPF32[wasm2js_i32$0 + 36 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 32 >> 2] = Math_fround(-HEAPF32[$3 + 172 >> 2]) * HEAPF32[$2 + 36 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 24 | 0, HEAPF32[$2 + 32 >> 2], $2 + 60 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 16 | 0, HEAPF32[$3 + 156 >> 2], $2 + 24 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 136 | 0, $2 + 16 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$3 + 164 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 92 | 0, $2 + 24 | 0)) + HEAPF32[$2 + 132 >> 2]), + HEAPF32[wasm2js_i32$0 + 132 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 8 | 0, HEAPF32[$3 + 160 >> 2], $2 + 24 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 120 | 0, $2 + 8 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$3 + 168 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 76 | 0, $2 + 24 | 0)) + HEAPF32[$2 + 116 >> 2]), + HEAPF32[wasm2js_i32$0 + 116 >> 2] = wasm2js_f32$0; + $1 = HEAP32[$2 + 140 >> 2]; + $0 = HEAP32[$2 + 136 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 148 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 148 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 132 >> 2]; + $0 = HEAP32[$2 + 124 >> 2]; + $1 = HEAP32[$2 + 120 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 148 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 112 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 148 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 112 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 116 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = float_20b2Abs_float__28float_29(HEAPF32[$2 + 36 >> 2]) < Math_fround(.004999999888241291), + HEAP8[wasm2js_i32$0 + 159 | 0] = wasm2js_i32$1; + } + __stack_pointer = $2 + 160 | 0; + return HEAP8[$2 + 159 | 0] & 1; +} + +function b2EdgeShape__RayCast_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $5 = __stack_pointer - 192 | 0; + __stack_pointer = $5; + HEAP32[$5 + 184 >> 2] = $0; + HEAP32[$5 + 180 >> 2] = $1; + HEAP32[$5 + 176 >> 2] = $2; + HEAP32[$5 + 172 >> 2] = $3; + HEAP32[$5 + 168 >> 2] = $4; + $1 = HEAP32[$5 + 184 >> 2]; + $0 = HEAP32[$5 + 172 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 152 | 0, HEAP32[$5 + 176 >> 2], HEAP32[$5 + 172 >> 2]); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($5 + 160 | 0, $0 + 8 | 0, $5 + 152 | 0); + $0 = HEAP32[$5 + 172 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 136 | 0, HEAP32[$5 + 176 >> 2] + 8 | 0, HEAP32[$5 + 172 >> 2]); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($5 + 144 | 0, $0 + 8 | 0, $5 + 136 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 128 | 0, $5 + 144 | 0, $5 + 160 | 0); + $2 = HEAP32[$1 + 12 >> 2]; + $0 = HEAP32[$1 + 16 >> 2]; + HEAP32[$5 + 120 >> 2] = $2; + HEAP32[$5 + 124 >> 2] = $0; + $2 = HEAP32[$1 + 24 >> 2]; + $0 = HEAP32[$1 + 20 >> 2]; + HEAP32[$5 + 112 >> 2] = $0; + HEAP32[$5 + 116 >> 2] = $2; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 104 | 0, $5 + 112 | 0, $5 + 120 | 0); + b2Vec2__b2Vec2_28float_2c_20float_29($5 + 96 | 0, HEAPF32[$5 + 108 >> 2], Math_fround(-HEAPF32[$5 + 104 >> 2])); + b2Vec2__Normalize_28_29($5 + 96 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 84 | 0, $5 + 120 | 0, $5 + 160 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 96 | 0, $5 + 84 | 0), + HEAPF32[wasm2js_i32$0 + 92 >> 2] = wasm2js_f32$0; + label$1: { + if (!(!(HEAP8[$1 + 44 | 0] & 1) | !(HEAPF32[$5 + 92 >> 2] > Math_fround(0)))) { + HEAP8[$5 + 191 | 0] = 0; + break label$1; + } + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 96 | 0, $5 + 128 | 0), + HEAPF32[wasm2js_i32$0 + 80 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 80 >> 2] == Math_fround(0)) { + HEAP8[$5 + 191 | 0] = 0; + break label$1; + } + HEAPF32[$5 + 76 >> 2] = HEAPF32[$5 + 92 >> 2] / HEAPF32[$5 + 80 >> 2]; + if (HEAPF32[$5 + 76 >> 2] < Math_fround(0) | HEAPF32[HEAP32[$5 + 176 >> 2] + 16 >> 2] < HEAPF32[$5 + 76 >> 2]) { + HEAP8[$5 + 191 | 0] = 0; + break label$1; + } + operator__28float_2c_20b2Vec2_20const__29($5 + 60 | 0, HEAPF32[$5 + 76 >> 2], $5 + 128 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($5 + 68 | 0, $5 + 160 | 0, $5 + 60 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 52 | 0, $5 + 112 | 0, $5 + 120 | 0); + $0 = $5 + 52 | 0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $0), + HEAPF32[wasm2js_i32$0 + 48 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 48 >> 2] == Math_fround(0)) { + HEAP8[$5 + 191 | 0] = 0; + break label$1; + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 36 | 0, $5 + 68 | 0, $5 + 120 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = Math_fround(b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 36 | 0, $5 + 52 | 0) / HEAPF32[$5 + 48 >> 2]), + HEAPF32[wasm2js_i32$0 + 44 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 44 >> 2] < Math_fround(0) | HEAPF32[$5 + 44 >> 2] > Math_fround(1)) { + HEAP8[$5 + 191 | 0] = 0; + break label$1; + } + HEAPF32[HEAP32[$5 + 180 >> 2] + 8 >> 2] = HEAPF32[$5 + 76 >> 2]; + label$9: { + if (HEAPF32[$5 + 92 >> 2] > Math_fround(0)) { + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($5 + 20 | 0, HEAP32[$5 + 172 >> 2] + 8 | 0, $5 + 96 | 0); + b2Vec2__operator__28_29_20const($5 + 28 | 0, $5 + 20 | 0); + $0 = HEAP32[$5 + 32 >> 2]; + $2 = HEAP32[$5 + 28 >> 2]; + $1 = $2; + $2 = HEAP32[$5 + 180 >> 2]; + HEAP32[$2 >> 2] = $1; + HEAP32[$2 + 4 >> 2] = $0; + break label$9; + } + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($5 + 12 | 0, HEAP32[$5 + 172 >> 2] + 8 | 0, $5 + 96 | 0); + $2 = HEAP32[$5 + 16 >> 2]; + $0 = HEAP32[$5 + 12 >> 2]; + $1 = $0; + $0 = HEAP32[$5 + 180 >> 2]; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + } + HEAP8[$5 + 191 | 0] = 1; + } + __stack_pointer = $5 + 192 | 0; + return HEAP8[$5 + 191 | 0] & 1; +} + +function _ZN17compiler_builtins3int4udiv10divmod_u6417h6026910b5ed08e40E($0, $1, $2, $3) { + var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0; + label$1: { + label$2: { + label$3: { + label$4: { + label$5: { + label$6: { + label$7: { + label$8: { + label$9: { + label$11: { + $10 = $1; + $7 = $10; + if ($7) { + $4 = $2; + if (!$4) { + break label$11; + } + $9 = $3; + if (!$9) { + break label$9; + } + $7 = Math_clz32($9) - Math_clz32($7) | 0; + if ($7 >>> 0 <= 31) { + break label$8; + } + break label$2; + } + $5 = $3; + if (($5 | 0) == 1 | $5 >>> 0 > 1) { + break label$2; + } + i64toi32_i32$HIGH_BITS = 0; + $7 = $0; + $4 = $2; + $7 = ($7 >>> 0) / ($4 >>> 0) | 0; + $5 = $7; + return $5; + } + $5 = $3; + $4 = $5; + if (!$0) { + break label$7; + } + if (!$4) { + break label$6; + } + $9 = $4 - 1 | 0; + if ($9 & $4) { + break label$6; + } + $5 = 0; + $6 = $7 >>> __wasm_ctz_i32($4) | 0; + i64toi32_i32$HIGH_BITS = 0; + return $6; + } + $9 = $4 - 1 | 0; + if (!($9 & $4)) { + break label$5; + } + $7 = (Math_clz32($4) + 33 | 0) - Math_clz32($7) | 0; + $4 = 0 - $7 | 0; + break label$3; + } + $4 = 63 - $7 | 0; + $7 = $7 + 1 | 0; + break label$3; + } + $9 = ($7 >>> 0) / ($4 >>> 0) | 0; + i64toi32_i32$HIGH_BITS = 0; + $5 = $9; + return $5; + } + $7 = Math_clz32($4) - Math_clz32($7) | 0; + if ($7 >>> 0 < 31) { + break label$4; + } + break label$2; + } + if (($4 | 0) == 1) { + break label$1; + } + $5 = $1; + $6 = $0; + $9 = 0; + $10 = __wasm_ctz_i32($4); + $8 = $10 & 31; + if (($10 & 63) >>> 0 >= 32) { + $6 = $5 >>> $8 | 0; + } else { + $9 = $5 >>> $8 | 0; + $6 = ((1 << $8) - 1 & $5) << 32 - $8 | $6 >>> $8; + } + i64toi32_i32$HIGH_BITS = $9; + return $6; + } + $4 = 63 - $7 | 0; + $7 = $7 + 1 | 0; + } + $6 = $1; + $5 = $0; + $9 = 0; + $10 = $7 & 63; + $8 = $10 & 31; + if (($10 & 63) >>> 0 >= 32) { + $11 = $6 >>> $8 | 0; + } else { + $9 = $6 >>> $8 | 0; + $11 = ((1 << $8) - 1 & $6) << 32 - $8 | $5 >>> $8; + } + $12 = $9; + $9 = $1; + $6 = $0; + $10 = $4 & 63; + $8 = $10 & 31; + if (($10 & 63) >>> 0 >= 32) { + $5 = $6 << $8; + $0 = 0; + } else { + $5 = (1 << $8) - 1 & $6 >>> 32 - $8 | $9 << $8; + $0 = $6 << $8; + } + $1 = $5; + if ($7) { + $5 = $3; + $4 = $5 - 1 | 0; + $9 = $2; + $8 = $9 - 1 | 0; + $4 = ($8 | 0) != -1 ? $4 + 1 | 0 : $4; + $15 = $8; + $16 = $4; + while (1) { + $4 = $12; + $5 = $11; + $9 = $4 << 1 | $5 >>> 31; + $6 = $5 << 1; + $5 = $9; + $4 = $17; + $4 = $5 | $4; + $12 = $4; + $10 = $1 >>> 31 | 0; + $9 = $6; + $11 = $10 | $9; + $5 = $15; + $10 = $11; + $4 = $16; + $9 = $12; + $8 = $9 + ($5 >>> 0 < $10 >>> 0) | 0; + $8 = $4 - $8 | 0; + $13 = $8 >> 31; + $5 = $8 >> 31; + $14 = $5; + $4 = $3; + $4 = $5 & $4; + $6 = $4; + $5 = $10; + $10 = $2; + $8 = $13; + $10 = $10 & $8; + $9 = $5 - $10 | 0; + $11 = $9; + $4 = $12; + $8 = $6; + $6 = $8 + ($5 >>> 0 < $10 >>> 0) | 0; + $6 = $4 - $6 | 0; + $12 = $6; + $6 = $1; + $4 = $0; + $5 = $6 << 1 | $4 >>> 31; + $10 = $18; + $6 = $4 << 1; + $0 = $10 | $6; + $4 = $17; + $4 = $4 | $5; + $1 = $4; + $6 = 0; + $14 = $6; + $5 = $13; + $13 = $5 & 1; + $18 = $13; + $7 = $7 - 1 | 0; + if ($7) { + continue; + } + break; + } + } + $6 = $1; + $4 = $0; + $5 = $6 << 1 | $4 >>> 31; + $4 = $14; + $4 = $5 | $4; + i64toi32_i32$HIGH_BITS = $4; + $10 = $13; + $6 = $0 << 1; + $6 = $10 | $6; + return $6; + } + $0 = 0; + $1 = 0; + } + $6 = $1; + i64toi32_i32$HIGH_BITS = $6; + $4 = $0; + return $4; +} + +function b2Joint__Create_28b2JointDef_20const__2c_20b2BlockAllocator__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer + -64 | 0; + __stack_pointer = $2; + HEAP32[$2 + 60 >> 2] = $0; + HEAP32[$2 + 56 >> 2] = $1; + HEAP32[$2 + 52 >> 2] = 0; + label$1: { + label$2: { + switch (HEAP32[HEAP32[$2 + 60 >> 2] >> 2] - 1 | 0) { + case 2: + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 56 >> 2], 176), + HEAP32[wasm2js_i32$0 + 48 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 48 >> 2]; + b2DistanceJoint__b2DistanceJoint_28b2DistanceJointDef_20const__29($0, HEAP32[$2 + 60 >> 2]); + HEAP32[$2 + 52 >> 2] = $0; + break label$1; + + case 4: + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 56 >> 2], 168), + HEAP32[wasm2js_i32$0 + 44 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 44 >> 2]; + b2MouseJoint__b2MouseJoint_28b2MouseJointDef_20const__29($0, HEAP32[$2 + 60 >> 2]); + HEAP32[$2 + 52 >> 2] = $0; + break label$1; + + case 1: + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 56 >> 2], 240), + HEAP32[wasm2js_i32$0 + 40 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 40 >> 2]; + b2PrismaticJoint__b2PrismaticJoint_28b2PrismaticJointDef_20const__29($0, HEAP32[$2 + 60 >> 2]); + HEAP32[$2 + 52 >> 2] = $0; + break label$1; + + case 0: + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 56 >> 2], 212), + HEAP32[wasm2js_i32$0 + 36 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 36 >> 2]; + b2RevoluteJoint__b2RevoluteJoint_28b2RevoluteJointDef_20const__29($0, HEAP32[$2 + 60 >> 2]); + HEAP32[$2 + 52 >> 2] = $0; + break label$1; + + case 3: + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 56 >> 2], 196), + HEAP32[wasm2js_i32$0 + 32 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 32 >> 2]; + b2PulleyJoint__b2PulleyJoint_28b2PulleyJointDef_20const__29($0, HEAP32[$2 + 60 >> 2]); + HEAP32[$2 + 52 >> 2] = $0; + break label$1; + + case 5: + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 56 >> 2], 276), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 28 >> 2]; + b2GearJoint__b2GearJoint_28b2GearJointDef_20const__29($0, HEAP32[$2 + 60 >> 2]); + HEAP32[$2 + 52 >> 2] = $0; + break label$1; + + case 6: + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 56 >> 2], 248), + HEAP32[wasm2js_i32$0 + 24 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 24 >> 2]; + b2WheelJoint__b2WheelJoint_28b2WheelJointDef_20const__29($0, HEAP32[$2 + 60 >> 2]); + HEAP32[$2 + 52 >> 2] = $0; + break label$1; + + case 7: + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 56 >> 2], 208), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 20 >> 2]; + b2WeldJoint__b2WeldJoint_28b2WeldJointDef_20const__29($0, HEAP32[$2 + 60 >> 2]); + HEAP32[$2 + 52 >> 2] = $0; + break label$1; + + case 8: + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 56 >> 2], 180), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 16 >> 2]; + b2FrictionJoint__b2FrictionJoint_28b2FrictionJointDef_20const__29($0, HEAP32[$2 + 60 >> 2]); + HEAP32[$2 + 52 >> 2] = $0; + break label$1; + + case 9: + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 56 >> 2], 164), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 12 >> 2]; + b2RopeJoint__b2RopeJoint_28b2RopeJointDef_20const__29($0, HEAP32[$2 + 60 >> 2]); + HEAP32[$2 + 52 >> 2] = $0; + break label$1; + + case 10: + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 56 >> 2], 192), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 8 >> 2]; + b2MotorJoint__b2MotorJoint_28b2MotorJointDef_20const__29($0, HEAP32[$2 + 60 >> 2]); + HEAP32[$2 + 52 >> 2] = $0; + break label$1; + + default: + break label$2; + } + } + __assert_fail(9147, 4569, 175, 8936); + wasm2js_trap(); + } + __stack_pointer = $2 - -64 | 0; + return HEAP32[$2 + 52 >> 2]; +} + +function b2RopeJoint__SolvePositionConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 144 | 0; + __stack_pointer = $2; + HEAP32[$2 + 140 >> 2] = $0; + HEAP32[$2 + 136 >> 2] = $1; + $3 = HEAP32[$2 + 140 >> 2]; + $4 = HEAP32[HEAP32[$2 + 136 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 96 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 128 >> 2] = $0; + HEAP32[$2 + 132 >> 2] = $1; + HEAPF32[$2 + 124 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 136 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 96 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 136 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 100 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 112 >> 2] = $1; + HEAP32[$2 + 116 >> 2] = $0; + HEAPF32[$2 + 108 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 136 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 100 >> 2], 12) | 0) + 8 >> 2]; + b2Rot__b2Rot_28float_29($2 + 100 | 0, HEAPF32[$2 + 124 >> 2]); + b2Rot__b2Rot_28float_29($2 + 92 | 0, HEAPF32[$2 + 108 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 76 | 0, $3 + 68 | 0, $3 + 128 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 84 | 0, $2 + 100 | 0, $2 + 76 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 60 | 0, $3 + 76 | 0, $3 + 136 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($2 + 68 | 0, $2 + 92 | 0, $2 + 60 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 36 | 0, $2 + 112 | 0, $2 + 68 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 44 | 0, $2 + 36 | 0, $2 + 128 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 52 | 0, $2 + 44 | 0, $2 + 84 | 0); + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Vec2__Normalize_28_29($2 + 52 | 0), HEAPF32[wasm2js_i32$0 + 88 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 32 >> 2] = HEAPF32[$3 + 88 >> 2] - HEAPF32[$3 + 84 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = float_20b2Clamp_float__28float_2c_20float_2c_20float_29(HEAPF32[$2 + 32 >> 2], Math_fround(0), Math_fround(.20000000298023224)), + HEAPF32[wasm2js_i32$0 + 32 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 28 >> 2] = Math_fround(-HEAPF32[$3 + 160 >> 2]) * HEAPF32[$2 + 32 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, HEAPF32[$2 + 28 >> 2], $2 + 52 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$3 + 144 >> 2], $2 + 20 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 128 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$3 + 152 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 84 | 0, $2 + 20 | 0)) + HEAPF32[$2 + 124 >> 2]), + HEAPF32[wasm2js_i32$0 + 124 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 4 | 0, HEAPF32[$3 + 148 >> 2], $2 + 20 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 112 | 0, $2 + 4 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$3 + 156 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 68 | 0, $2 + 20 | 0)) + HEAPF32[$2 + 108 >> 2]), + HEAPF32[wasm2js_i32$0 + 108 >> 2] = wasm2js_f32$0; + $1 = HEAP32[$2 + 132 >> 2]; + $0 = HEAP32[$2 + 128 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 136 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 96 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 136 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 96 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 124 >> 2]; + $0 = HEAP32[$2 + 116 >> 2]; + $1 = HEAP32[$2 + 112 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 136 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 100 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 136 >> 2] + 24 >> 2] + Math_imul(HEAP32[$3 + 100 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 108 >> 2]; + __stack_pointer = $2 + 144 | 0; + return Math_fround(HEAPF32[$3 + 88 >> 2] - HEAPF32[$3 + 84 >> 2]) < Math_fround(.004999999888241291) | 0; +} + +function b2PolygonShape__ComputeMass_28b2MassData__2c_20float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0, $5 = Math_fround(0), $6 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 128 | 0; + __stack_pointer = $3; + HEAP32[$3 + 124 >> 2] = $0; + HEAP32[$3 + 120 >> 2] = $1; + HEAPF32[$3 + 116 >> 2] = $2; + $4 = HEAP32[$3 + 124 >> 2]; + if (HEAP32[$4 + 148 >> 2] < 3) { + __assert_fail(11993, 5758, 383, 3436); + wasm2js_trap(); + } + b2Vec2__b2Vec2_28float_2c_20float_29($3 + 108 | 0, Math_fround(0), Math_fround(0)); + HEAPF32[$3 + 104 >> 2] = 0; + HEAPF32[$3 + 100 >> 2] = 0; + $1 = HEAP32[$4 + 24 >> 2]; + $0 = HEAP32[$4 + 20 >> 2]; + HEAP32[$3 + 88 >> 2] = $0; + HEAP32[$3 + 92 >> 2] = $1; + HEAPF32[$3 + 84 >> 2] = .3333333432674408; + HEAP32[$3 + 80 >> 2] = 0; + while (1) { + if (HEAP32[$3 + 80 >> 2] < HEAP32[$4 + 148 >> 2]) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 72 | 0, ($4 + 20 | 0) + (HEAP32[$3 + 80 >> 2] << 3) | 0, $3 + 88 | 0); + label$4: { + if (HEAP32[$4 + 148 >> 2] > (HEAP32[$3 + 80 >> 2] + 1 | 0)) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 - -64 | 0, ((HEAP32[$3 + 80 >> 2] << 3) + $4 | 0) + 28 | 0, $3 + 88 | 0); + break label$4; + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 - -64 | 0, $4 + 20 | 0, $3 + 88 | 0); + } + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 72 | 0, $3 - -64 | 0), + HEAPF32[wasm2js_i32$0 + 60 >> 2] = wasm2js_f32$0; + HEAPF32[$3 + 56 >> 2] = HEAPF32[$3 + 60 >> 2] * Math_fround(.5); + HEAPF32[$3 + 104 >> 2] = HEAPF32[$3 + 104 >> 2] + HEAPF32[$3 + 56 >> 2]; + $2 = HEAPF32[$3 + 56 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 40 | 0, $3 + 72 | 0, $3 - -64 | 0); + operator__28float_2c_20b2Vec2_20const__29($3 + 48 | 0, Math_fround($2 * Math_fround(.3333333432674408)), $3 + 40 | 0); + b2Vec2__operator___28b2Vec2_20const__29($3 + 108 | 0, $3 + 48 | 0); + HEAPF32[$3 + 36 >> 2] = HEAPF32[$3 + 72 >> 2]; + HEAPF32[$3 + 32 >> 2] = HEAPF32[$3 + 76 >> 2]; + HEAPF32[$3 + 28 >> 2] = HEAPF32[$3 + 64 >> 2]; + HEAPF32[$3 + 24 >> 2] = HEAPF32[$3 + 68 >> 2]; + HEAPF32[$3 + 20 >> 2] = Math_fround(HEAPF32[$3 + 28 >> 2] * HEAPF32[$3 + 28 >> 2]) + Math_fround(Math_fround(HEAPF32[$3 + 36 >> 2] * HEAPF32[$3 + 36 >> 2]) + Math_fround(HEAPF32[$3 + 28 >> 2] * HEAPF32[$3 + 36 >> 2])); + HEAPF32[$3 + 16 >> 2] = Math_fround(HEAPF32[$3 + 24 >> 2] * HEAPF32[$3 + 24 >> 2]) + Math_fround(Math_fround(HEAPF32[$3 + 32 >> 2] * HEAPF32[$3 + 32 >> 2]) + Math_fround(HEAPF32[$3 + 24 >> 2] * HEAPF32[$3 + 32 >> 2])); + HEAPF32[$3 + 100 >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 60 >> 2] * Math_fround(.0833333358168602)) * Math_fround(HEAPF32[$3 + 20 >> 2] + HEAPF32[$3 + 16 >> 2])) + HEAPF32[$3 + 100 >> 2]; + HEAP32[$3 + 80 >> 2] = HEAP32[$3 + 80 >> 2] + 1; + continue; + } + break; + } + HEAPF32[HEAP32[$3 + 120 >> 2] >> 2] = HEAPF32[$3 + 116 >> 2] * HEAPF32[$3 + 104 >> 2]; + if (!(HEAPF32[$3 + 104 >> 2] > Math_fround(1.1920928955078125e-7))) { + __assert_fail(10884, 5758, 422, 3436); + wasm2js_trap(); + } + b2Vec2__operator___28float_29($3 + 108 | 0, Math_fround(Math_fround(1) / HEAPF32[$3 + 104 >> 2])); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 8 | 0, $3 + 108 | 0, $3 + 88 | 0); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$3 + 8 >> 2]; + $4 = $1; + $1 = HEAP32[$3 + 120 >> 2]; + HEAP32[$1 + 4 >> 2] = $4; + HEAP32[$1 + 8 >> 2] = $0; + HEAPF32[HEAP32[$3 + 120 >> 2] + 12 >> 2] = HEAPF32[$3 + 116 >> 2] * HEAPF32[$3 + 100 >> 2]; + $2 = HEAPF32[HEAP32[$3 + 120 >> 2] >> 2]; + $5 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$3 + 120 >> 2] + 4 | 0, HEAP32[$3 + 120 >> 2] + 4 | 0); + $0 = $3 + 108 | 0; + $6 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $0); + $0 = HEAP32[$3 + 120 >> 2]; + HEAPF32[$0 + 12 >> 2] = Math_fround($2 * Math_fround($5 - $6)) + HEAPF32[$0 + 12 >> 2]; + __stack_pointer = $3 + 128 | 0; +} + +function b2ContactSolver__WarmStart_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer - 144 | 0; + __stack_pointer = $1; + HEAP32[$1 + 140 >> 2] = $0; + $4 = HEAP32[$1 + 140 >> 2]; + HEAP32[$1 + 136 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 136 >> 2] < HEAP32[$4 + 48 >> 2]) { + HEAP32[$1 + 132 >> 2] = HEAP32[$4 + 40 >> 2] + Math_imul(HEAP32[$1 + 136 >> 2], 156); + HEAP32[$1 + 128 >> 2] = HEAP32[HEAP32[$1 + 132 >> 2] + 112 >> 2]; + HEAP32[$1 + 124 >> 2] = HEAP32[HEAP32[$1 + 132 >> 2] + 116 >> 2]; + HEAPF32[$1 + 120 >> 2] = HEAPF32[HEAP32[$1 + 132 >> 2] + 120 >> 2]; + HEAPF32[$1 + 116 >> 2] = HEAPF32[HEAP32[$1 + 132 >> 2] + 128 >> 2]; + HEAPF32[$1 + 112 >> 2] = HEAPF32[HEAP32[$1 + 132 >> 2] + 124 >> 2]; + HEAPF32[$1 + 108 >> 2] = HEAPF32[HEAP32[$1 + 132 >> 2] + 132 >> 2]; + HEAP32[$1 + 104 >> 2] = HEAP32[HEAP32[$1 + 132 >> 2] + 148 >> 2]; + $2 = HEAP32[$4 + 28 >> 2] + Math_imul(HEAP32[$1 + 128 >> 2], 12) | 0; + $0 = HEAP32[$2 >> 2]; + $3 = HEAP32[$2 + 4 >> 2]; + HEAP32[$1 + 96 >> 2] = $0; + HEAP32[$1 + 100 >> 2] = $3; + HEAPF32[$1 + 92 >> 2] = HEAPF32[(HEAP32[$4 + 28 >> 2] + Math_imul(HEAP32[$1 + 128 >> 2], 12) | 0) + 8 >> 2]; + $2 = HEAP32[$4 + 28 >> 2] + Math_imul(HEAP32[$1 + 124 >> 2], 12) | 0; + $3 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + HEAP32[$1 + 80 >> 2] = $3; + HEAP32[$1 + 84 >> 2] = $0; + HEAPF32[$1 + 76 >> 2] = HEAPF32[(HEAP32[$4 + 28 >> 2] + Math_imul(HEAP32[$1 + 124 >> 2], 12) | 0) + 8 >> 2]; + $2 = HEAP32[$1 + 132 >> 2]; + $0 = HEAP32[$2 + 72 >> 2]; + $3 = HEAP32[$2 + 76 >> 2]; + HEAP32[$1 + 64 >> 2] = $0; + HEAP32[$1 + 68 >> 2] = $3; + b2Cross_28b2Vec2_20const__2c_20float_29($1 + 56 | 0, $1 - -64 | 0, Math_fround(1)); + HEAP32[$1 + 52 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 52 >> 2] < HEAP32[$1 + 104 >> 2]) { + HEAP32[$1 + 48 >> 2] = HEAP32[$1 + 132 >> 2] + Math_imul(HEAP32[$1 + 52 >> 2], 36); + operator__28float_2c_20b2Vec2_20const__29($1 + 32 | 0, HEAPF32[HEAP32[$1 + 48 >> 2] + 16 >> 2], $1 - -64 | 0); + operator__28float_2c_20b2Vec2_20const__29($1 + 24 | 0, HEAPF32[HEAP32[$1 + 48 >> 2] + 20 >> 2], $1 + 56 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 40 | 0, $1 + 32 | 0, $1 + 24 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$1 + 116 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 48 >> 2], $1 + 40 | 0)) + HEAPF32[$1 + 92 >> 2]), + HEAPF32[wasm2js_i32$0 + 92 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($1 + 16 | 0, HEAPF32[$1 + 120 >> 2], $1 + 40 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($1 + 96 | 0, $1 + 16 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$1 + 108 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$1 + 48 >> 2] + 8 | 0, $1 + 40 | 0)) + HEAPF32[$1 + 76 >> 2]), + HEAPF32[wasm2js_i32$0 + 76 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($1 + 8 | 0, HEAPF32[$1 + 112 >> 2], $1 + 40 | 0); + b2Vec2__operator___28b2Vec2_20const__29($1 + 80 | 0, $1 + 8 | 0); + HEAP32[$1 + 52 >> 2] = HEAP32[$1 + 52 >> 2] + 1; + continue; + } + break; + } + $0 = HEAP32[$1 + 100 >> 2]; + $3 = HEAP32[$1 + 96 >> 2]; + $2 = $3; + $3 = HEAP32[$4 + 28 >> 2] + Math_imul(HEAP32[$1 + 128 >> 2], 12) | 0; + HEAP32[$3 >> 2] = $2; + HEAP32[$3 + 4 >> 2] = $0; + HEAPF32[(HEAP32[$4 + 28 >> 2] + Math_imul(HEAP32[$1 + 128 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$1 + 92 >> 2]; + $3 = HEAP32[$1 + 84 >> 2]; + $0 = HEAP32[$1 + 80 >> 2]; + $2 = $0; + $0 = HEAP32[$4 + 28 >> 2] + Math_imul(HEAP32[$1 + 124 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $3; + HEAPF32[(HEAP32[$4 + 28 >> 2] + Math_imul(HEAP32[$1 + 124 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$1 + 76 >> 2]; + HEAP32[$1 + 136 >> 2] = HEAP32[$1 + 136 >> 2] + 1; + continue; + } + break; + } + __stack_pointer = $1 + 144 | 0; +} +function b2RopeJoint__SolveVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 128 | 0; + __stack_pointer = $2; + HEAP32[$2 + 124 >> 2] = $0; + HEAP32[$2 + 120 >> 2] = $1; + $3 = HEAP32[$2 + 124 >> 2]; + $4 = HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 96 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 112 >> 2] = $1; + HEAP32[$2 + 116 >> 2] = $0; + HEAPF32[$2 + 108 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 96 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 100 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 96 >> 2] = $0; + HEAP32[$2 + 100 >> 2] = $1; + HEAPF32[$2 + 92 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 100 >> 2], 12) | 0) + 8 >> 2]; + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 76 | 0, HEAPF32[$2 + 108 >> 2], $3 + 112 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 84 | 0, $2 + 112 | 0, $2 + 76 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 60 | 0, HEAPF32[$2 + 92 >> 2], $3 + 120 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 68 | 0, $2 + 96 | 0, $2 + 60 | 0); + HEAPF32[$2 + 56 >> 2] = HEAPF32[$3 + 88 >> 2] - HEAPF32[$3 + 84 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 44 | 0, $2 + 68 | 0, $2 + 84 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 104 | 0, $2 + 44 | 0), + HEAPF32[wasm2js_i32$0 + 52 >> 2] = wasm2js_f32$0; + if (HEAPF32[$2 + 56 >> 2] < Math_fround(0)) { + HEAPF32[$2 + 52 >> 2] = Math_fround(HEAPF32[HEAP32[$2 + 120 >> 2] + 4 >> 2] * HEAPF32[$2 + 56 >> 2]) + HEAPF32[$2 + 52 >> 2]; + } + HEAPF32[$2 + 40 >> 2] = Math_fround(-HEAPF32[$3 + 160 >> 2]) * HEAPF32[$2 + 52 >> 2]; + HEAPF32[$2 + 36 >> 2] = HEAPF32[$3 + 92 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Min_float__28float_2c_20float_29(Math_fround(0), Math_fround(HEAPF32[$3 + 92 >> 2] + HEAPF32[$2 + 40 >> 2])), + HEAPF32[wasm2js_i32$0 + 92 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 40 >> 2] = HEAPF32[$3 + 92 >> 2] - HEAPF32[$2 + 36 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 28 | 0, HEAPF32[$2 + 40 >> 2], $3 + 104 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, HEAPF32[$3 + 144 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 112 | 0, $2 + 20 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$3 + 152 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 112 | 0, $2 + 28 | 0)) + HEAPF32[$2 + 108 >> 2]), + HEAPF32[wasm2js_i32$0 + 108 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$3 + 148 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 96 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$3 + 156 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 120 | 0, $2 + 28 | 0)) + HEAPF32[$2 + 92 >> 2]), + HEAPF32[wasm2js_i32$0 + 92 >> 2] = wasm2js_f32$0; + $0 = HEAP32[$2 + 116 >> 2]; + $1 = HEAP32[$2 + 112 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 96 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 96 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 108 >> 2]; + $1 = HEAP32[$2 + 100 >> 2]; + $0 = HEAP32[$2 + 96 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 100 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 120 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 100 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 92 >> 2]; + __stack_pointer = $2 + 128 | 0; +} + +function __cxxabiv1____vmi_class_type_info__search_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_2c_20bool_29_20const($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0, $6 = 0, $7 = 0, $8 = 0; + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, HEAP32[$1 + 8 >> 2], $4)) { + __cxxabiv1____class_type_info__process_static_type_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_29_20const($1, $1, $2, $3); + return; + } + label$2: { + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, HEAP32[$1 >> 2], $4)) { + if (!(HEAP32[$1 + 16 >> 2] != ($2 | 0) & HEAP32[$1 + 20 >> 2] != ($2 | 0))) { + if (($3 | 0) != 1) { + break label$2; + } + HEAP32[$1 + 32 >> 2] = 1; + return; + } + HEAP32[$1 + 32 >> 2] = $3; + if (HEAP32[$1 + 44 >> 2] != 4) { + $5 = $0 + 16 | 0; + $3 = $5 + (HEAP32[$0 + 12 >> 2] << 3) | 0; + label$7: { + label$8: { + while (1) { + label$10: { + if ($3 >>> 0 <= $5 >>> 0) { + break label$10; + } + HEAP16[$1 + 52 >> 1] = 0; + __cxxabiv1____base_class_type_info__search_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_2c_20bool_29_20const($5, $1, $2, $2, 1, $4); + if (HEAPU8[$1 + 54 | 0]) { + break label$10; + } + label$11: { + if (!HEAPU8[$1 + 53 | 0]) { + break label$11; + } + if (HEAPU8[$1 + 52 | 0]) { + $6 = 1; + if (HEAP32[$1 + 24 >> 2] == 1) { + break label$8; + } + $7 = 1; + $8 = 1; + if (HEAPU8[$0 + 8 | 0] & 2) { + break label$11; + } + break label$8; + } + $7 = 1; + $6 = $8; + if (!(HEAP8[$0 + 8 | 0] & 1)) { + break label$8; + } + } + $5 = $5 + 8 | 0; + continue; + } + break; + } + $6 = $8; + $5 = 4; + if (!($7 & 1)) { + break label$7; + } + } + $5 = 3; + } + HEAP32[$1 + 44 >> 2] = $5; + if ($6 & 1) { + break label$2; + } + } + HEAP32[$1 + 20 >> 2] = $2; + HEAP32[$1 + 40 >> 2] = HEAP32[$1 + 40 >> 2] + 1; + if (HEAP32[$1 + 36 >> 2] != 1 | HEAP32[$1 + 24 >> 2] != 2) { + break label$2; + } + HEAP8[$1 + 54 | 0] = 1; + return; + } + $6 = HEAP32[$0 + 12 >> 2]; + $7 = $0 + 16 | 0; + __cxxabiv1____base_class_type_info__search_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_2c_20bool_29_20const($7, $1, $2, $3, $4); + $5 = $0 + 24 | 0; + $6 = ($6 << 3) + $7 | 0; + if ($5 >>> 0 >= $6 >>> 0) { + break label$2; + } + $0 = HEAP32[$0 + 8 >> 2]; + if (!(!($0 & 2) & HEAP32[$1 + 36 >> 2] != 1)) { + while (1) { + if (HEAPU8[$1 + 54 | 0]) { + break label$2; + } + __cxxabiv1____base_class_type_info__search_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_2c_20bool_29_20const($5, $1, $2, $3, $4); + $5 = $5 + 8 | 0; + if ($6 >>> 0 > $5 >>> 0) { + continue; + } + break; + } + break label$2; + } + if (!($0 & 1)) { + while (1) { + if (HEAPU8[$1 + 54 | 0] | HEAP32[$1 + 36 >> 2] == 1) { + break label$2; + } + __cxxabiv1____base_class_type_info__search_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_2c_20bool_29_20const($5, $1, $2, $3, $4); + $5 = $5 + 8 | 0; + if ($6 >>> 0 > $5 >>> 0) { + continue; + } + break label$2; + } + } + while (1) { + if (HEAPU8[$1 + 54 | 0] | HEAP32[$1 + 36 >> 2] == 1 & HEAP32[$1 + 24 >> 2] == 1) { + break label$2; + } + __cxxabiv1____base_class_type_info__search_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_2c_20bool_29_20const($5, $1, $2, $3, $4); + $5 = $5 + 8 | 0; + if ($6 >>> 0 > $5 >>> 0) { + continue; + } + break; + } + } +} + +function std____2__pair_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____20std____2____unwrap_and_dispatch_5babi_v160004_5d_std____2____overload_std____2____move_loop_std____2___ClassicAlgPolicy__2c_20std____2____move_trivial__2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_200__28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 80 | 0; + __stack_pointer = $4; + HEAP32[$4 + 76 >> 2] = $1; + HEAP32[$4 + 72 >> 2] = $2; + HEAP32[$4 + 68 >> 2] = $3; + HEAP32[$4 + 56 >> 2] = HEAP32[$4 + 76 >> 2]; + HEAP32[$4 + 52 >> 2] = HEAP32[$4 + 72 >> 2]; + std____2__pair_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____20std____2____unwrap_range_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($4 + 60 | 0, HEAP32[$4 + 56 >> 2], HEAP32[$4 + 52 >> 2]); + HEAP32[$4 + 36 >> 2] = HEAP32[$4 + 60 >> 2]; + HEAP32[$4 + 32 >> 2] = HEAP32[($4 + 60 | 0) + 4 >> 2]; + HEAP32[$4 + 24 >> 2] = HEAP32[$4 + 68 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = decltype_28std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false_____unwrap_28std__declval_std____2__reverse_iterator_b2Vec2____28_29_29_29_20std____2____unwrap_iter_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false__2c_200__28std____2__reverse_iterator_b2Vec2___29(HEAP32[$4 + 24 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + std____2__pair_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____20std____2____move_loop_std____2___ClassicAlgPolicy___operator_28_29_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29_20const($4 + 44 | 0, $4 + 43 | 0, HEAP32[$4 + 36 >> 2], HEAP32[$4 + 32 >> 2], HEAP32[$4 + 28 >> 2]); + HEAP32[$4 + 16 >> 2] = HEAP32[$4 + 76 >> 2]; + HEAP32[$4 + 12 >> 2] = HEAP32[$4 + 44 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = std____2__reverse_iterator_b2Vec2___20std____2____rewrap_range_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29(HEAP32[$4 + 16 >> 2], HEAP32[$4 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + HEAP32[$4 + 4 >> 2] = HEAP32[$4 + 68 >> 2]; + HEAP32[$4 >> 2] = HEAP32[($4 + 44 | 0) + 4 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = std____2__reverse_iterator_b2Vec2___20std____2____rewrap_iter_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false___28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29(HEAP32[$4 + 4 >> 2], HEAP32[$4 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + std____2__pair_std____2____unwrap_ref_decay_std____2__reverse_iterator_b2Vec2_____type_2c_20std____2____unwrap_ref_decay_std____2__reverse_iterator_b2Vec2_____type__20std____2__make_pair_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2_____2c_20std____2__reverse_iterator_b2Vec2_____29($0, $4 + 20 | 0, $4 + 8 | 0); + __stack_pointer = $4 + 80 | 0; +} + +function b2AABB__RayCast_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 80 | 0; + __stack_pointer = $3; + HEAP32[$3 + 72 >> 2] = $0; + HEAP32[$3 + 68 >> 2] = $1; + HEAP32[$3 + 64 >> 2] = $2; + $2 = HEAP32[$3 + 72 >> 2]; + HEAPF32[$3 + 60 >> 2] = -34028234663852886e22; + HEAPF32[$3 + 56 >> 2] = 34028234663852886e22; + $1 = HEAP32[$3 + 64 >> 2]; + $0 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$3 + 48 >> 2] = $0; + HEAP32[$3 + 52 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 40 | 0, HEAP32[$3 + 64 >> 2] + 8 | 0, HEAP32[$3 + 64 >> 2]); + b2Abs_28b2Vec2_20const__29($3 + 32 | 0, $3 + 40 | 0); + b2Vec2__b2Vec2_28_29($3 + 24 | 0); + HEAP32[$3 + 20 >> 2] = 0; + label$1: { + while (1) { + if (HEAP32[$3 + 20 >> 2] < 2) { + label$4: { + if (HEAPF32[b2Vec2__operator_28_29_28int_29($3 + 32 | 0, HEAP32[$3 + 20 >> 2]) >> 2] < Math_fround(1.1920928955078125e-7)) { + if (!(HEAPF32[b2Vec2__operator_28_29_28int_29($3 + 48 | 0, HEAP32[$3 + 20 >> 2]) >> 2] < b2Vec2__operator_28_29_28int_29_20const($2, HEAP32[$3 + 20 >> 2]))) { + if (!(b2Vec2__operator_28_29_28int_29_20const($2 + 8 | 0, HEAP32[$3 + 20 >> 2]) < HEAPF32[b2Vec2__operator_28_29_28int_29($3 + 48 | 0, HEAP32[$3 + 20 >> 2]) >> 2])) { + break label$4; + } + } + HEAP8[$3 + 79 | 0] = 0; + break label$1; + } + wasm2js_i32$0 = $3, wasm2js_f32$0 = Math_fround(Math_fround(1) / HEAPF32[b2Vec2__operator_28_29_28int_29($3 + 40 | 0, HEAP32[$3 + 20 >> 2]) >> 2]), + HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $3, wasm2js_f32$0 = Math_fround(Math_fround(b2Vec2__operator_28_29_28int_29_20const($2, HEAP32[$3 + 20 >> 2]) - HEAPF32[b2Vec2__operator_28_29_28int_29($3 + 48 | 0, HEAP32[$3 + 20 >> 2]) >> 2]) * HEAPF32[$3 + 16 >> 2]), + HEAPF32[wasm2js_i32$0 + 12 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $3, wasm2js_f32$0 = Math_fround(Math_fround(b2Vec2__operator_28_29_28int_29_20const($2 + 8 | 0, HEAP32[$3 + 20 >> 2]) - HEAPF32[b2Vec2__operator_28_29_28int_29($3 + 48 | 0, HEAP32[$3 + 20 >> 2]) >> 2]) * HEAPF32[$3 + 16 >> 2]), + HEAPF32[wasm2js_i32$0 + 8 >> 2] = wasm2js_f32$0; + HEAPF32[$3 + 4 >> 2] = -1; + if (HEAPF32[$3 + 12 >> 2] > HEAPF32[$3 + 8 >> 2]) { + void_20b2Swap_float__28float__2c_20float__29($3 + 12 | 0, $3 + 8 | 0); + HEAPF32[$3 + 4 >> 2] = 1; + } + if (HEAPF32[$3 + 12 >> 2] > HEAPF32[$3 + 60 >> 2]) { + b2Vec2__SetZero_28_29($3 + 24 | 0); + $4 = HEAPF32[$3 + 4 >> 2]; + wasm2js_i32$0 = b2Vec2__operator_28_29_28int_29($3 + 24 | 0, HEAP32[$3 + 20 >> 2]), + wasm2js_f32$0 = $4, HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0; + HEAPF32[$3 + 60 >> 2] = HEAPF32[$3 + 12 >> 2]; + } + wasm2js_i32$0 = $3, wasm2js_f32$0 = float_20b2Min_float__28float_2c_20float_29(HEAPF32[$3 + 56 >> 2], HEAPF32[$3 + 8 >> 2]), + HEAPF32[wasm2js_i32$0 + 56 >> 2] = wasm2js_f32$0; + if (HEAPF32[$3 + 60 >> 2] > HEAPF32[$3 + 56 >> 2]) { + HEAP8[$3 + 79 | 0] = 0; + break label$1; + } + } + HEAP32[$3 + 20 >> 2] = HEAP32[$3 + 20 >> 2] + 1; + continue; + } + break; + } + if (HEAPF32[$3 + 60 >> 2] < Math_fround(0) | HEAPF32[HEAP32[$3 + 64 >> 2] + 16 >> 2] < HEAPF32[$3 + 60 >> 2]) { + HEAP8[$3 + 79 | 0] = 0; + break label$1; + } + HEAPF32[HEAP32[$3 + 68 >> 2] + 8 >> 2] = HEAPF32[$3 + 60 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $1 = HEAP32[$3 + 24 >> 2]; + $2 = $1; + $1 = HEAP32[$3 + 68 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAP8[$3 + 79 | 0] = 1; + } + __stack_pointer = $3 + 80 | 0; + return HEAP8[$3 + 79 | 0] & 1; +} + +function b2Body__b2Body_28b2BodyDef_20const__2c_20b2World__29($0, $1, $2) { + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 8 >> 2] = $0; + HEAP32[$3 + 4 >> 2] = $1; + HEAP32[$3 >> 2] = $2; + $1 = HEAP32[$3 + 8 >> 2]; + HEAP32[$3 + 12 >> 2] = $1; + b2Transform__b2Transform_28_29($1 + 12 | 0); + b2Sweep__b2Sweep_28_29($1 + 28 | 0); + b2Vec2__b2Vec2_28_29($1 - -64 | 0); + b2Vec2__b2Vec2_28_29($1 + 76 | 0); + if (!(b2Vec2__IsValid_28_29_20const(HEAP32[$3 + 4 >> 2] + 4 | 0) & 1)) { + __assert_fail(12519, 4100, 33, 1702); + wasm2js_trap(); + } + if (!(b2Vec2__IsValid_28_29_20const(HEAP32[$3 + 4 >> 2] + 16 | 0) & 1)) { + __assert_fail(12468, 4100, 34, 1702); + wasm2js_trap(); + } + if (!(b2IsValid_28float_29(HEAPF32[HEAP32[$3 + 4 >> 2] + 12 >> 2]) & 1)) { + __assert_fail(12380, 4100, 35, 1702); + wasm2js_trap(); + } + if (!(b2IsValid_28float_29(HEAPF32[HEAP32[$3 + 4 >> 2] + 24 >> 2]) & 1)) { + __assert_fail(12342, 4100, 36, 1702); + wasm2js_trap(); + } + if (!(b2IsValid_28float_29(HEAPF32[HEAP32[$3 + 4 >> 2] + 32 >> 2]) & 1 & HEAPF32[HEAP32[$3 + 4 >> 2] + 32 >> 2] >= Math_fround(0))) { + __assert_fail(8333, 4100, 37, 1702); + wasm2js_trap(); + } + if (!(b2IsValid_28float_29(HEAPF32[HEAP32[$3 + 4 >> 2] + 28 >> 2]) & 1 & HEAPF32[HEAP32[$3 + 4 >> 2] + 28 >> 2] >= Math_fround(0))) { + __assert_fail(8393, 4100, 38, 1702); + wasm2js_trap(); + } + HEAP16[$1 + 4 >> 1] = 0; + if (HEAP8[HEAP32[$3 + 4 >> 2] + 39 | 0] & 1) { + HEAP16[$1 + 4 >> 1] = HEAPU16[$1 + 4 >> 1] | 8; + } + if (HEAP8[HEAP32[$3 + 4 >> 2] + 38 | 0] & 1) { + HEAP16[$1 + 4 >> 1] = HEAPU16[$1 + 4 >> 1] | 16; + } + if (HEAP8[HEAP32[$3 + 4 >> 2] + 36 | 0] & 1) { + HEAP16[$1 + 4 >> 1] = HEAPU16[$1 + 4 >> 1] | 4; + } + if (!(!(HEAP8[HEAP32[$3 + 4 >> 2] + 37 | 0] & 1) | !HEAP32[HEAP32[$3 + 4 >> 2] >> 2])) { + HEAP16[$1 + 4 >> 1] = HEAPU16[$1 + 4 >> 1] | 2; + } + if (HEAP8[HEAP32[$3 + 4 >> 2] + 40 | 0] & 1) { + HEAP16[$1 + 4 >> 1] = HEAPU16[$1 + 4 >> 1] | 32; + } + HEAP32[$1 + 88 >> 2] = HEAP32[$3 >> 2]; + $4 = HEAP32[$3 + 4 >> 2]; + $2 = HEAP32[$4 + 4 >> 2]; + $0 = HEAP32[$4 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $2; + HEAP32[$1 + 16 >> 2] = $0; + b2Rot__Set_28float_29($1 + 20 | 0, HEAPF32[HEAP32[$3 + 4 >> 2] + 12 >> 2]); + b2Vec2__SetZero_28_29($1 + 28 | 0); + $2 = HEAP32[$1 + 16 >> 2]; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$1 + 36 >> 2] = $0; + HEAP32[$1 + 40 >> 2] = $2; + $0 = HEAP32[$1 + 16 >> 2]; + $2 = HEAP32[$1 + 12 >> 2]; + HEAP32[$1 + 44 >> 2] = $2; + HEAP32[$1 + 48 >> 2] = $0; + HEAPF32[$1 + 52 >> 2] = HEAPF32[HEAP32[$3 + 4 >> 2] + 12 >> 2]; + HEAPF32[$1 + 56 >> 2] = HEAPF32[HEAP32[$3 + 4 >> 2] + 12 >> 2]; + HEAPF32[$1 + 60 >> 2] = 0; + HEAP32[$1 + 108 >> 2] = 0; + HEAP32[$1 + 112 >> 2] = 0; + HEAP32[$1 + 92 >> 2] = 0; + HEAP32[$1 + 96 >> 2] = 0; + $4 = HEAP32[$3 + 4 >> 2]; + $0 = HEAP32[$4 + 16 >> 2]; + $2 = HEAP32[$4 + 20 >> 2]; + HEAP32[$1 + 64 >> 2] = $0; + HEAP32[$1 + 68 >> 2] = $2; + HEAPF32[$1 + 72 >> 2] = HEAPF32[HEAP32[$3 + 4 >> 2] + 24 >> 2]; + HEAPF32[$1 + 132 >> 2] = HEAPF32[HEAP32[$3 + 4 >> 2] + 28 >> 2]; + HEAPF32[$1 + 136 >> 2] = HEAPF32[HEAP32[$3 + 4 >> 2] + 32 >> 2]; + HEAPF32[$1 + 140 >> 2] = HEAPF32[HEAP32[$3 + 4 >> 2] + 48 >> 2]; + b2Vec2__SetZero_28_29($1 + 76 | 0); + HEAPF32[$1 + 84 >> 2] = 0; + HEAPF32[$1 + 144 >> 2] = 0; + HEAP32[$1 >> 2] = HEAP32[HEAP32[$3 + 4 >> 2] >> 2]; + label$14: { + if (HEAP32[HEAP32[$3 + 4 >> 2] >> 2] == 2) { + HEAPF32[$1 + 116 >> 2] = 1; + HEAPF32[$1 + 120 >> 2] = 1; + break label$14; + } + HEAPF32[$1 + 116 >> 2] = 0; + HEAPF32[$1 + 120 >> 2] = 0; + } + HEAPF32[$1 + 124 >> 2] = 0; + HEAPF32[$1 + 128 >> 2] = 0; + HEAP32[$1 + 148 >> 2] = HEAP32[HEAP32[$3 + 4 >> 2] + 44 >> 2]; + HEAP32[$1 + 100 >> 2] = 0; + HEAP32[$1 + 104 >> 2] = 0; + __stack_pointer = $3 + 16 | 0; + return HEAP32[$3 + 12 >> 2]; +} + +function std____2__pair_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____20std____2____unwrap_and_dispatch_5babi_v160004_5d_std____2____overload_std____2____move_loop_std____2___ClassicAlgPolicy__2c_20std____2____move_trivial__2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_200__28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 80 | 0; + __stack_pointer = $4; + HEAP32[$4 + 76 >> 2] = $1; + HEAP32[$4 + 72 >> 2] = $2; + HEAP32[$4 + 68 >> 2] = $3; + HEAP32[$4 + 56 >> 2] = HEAP32[$4 + 76 >> 2]; + HEAP32[$4 + 52 >> 2] = HEAP32[$4 + 72 >> 2]; + std____2__pair_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____20std____2____unwrap_range_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($4 + 60 | 0, HEAP32[$4 + 56 >> 2], HEAP32[$4 + 52 >> 2]); + HEAP32[$4 + 36 >> 2] = HEAP32[$4 + 60 >> 2]; + HEAP32[$4 + 32 >> 2] = HEAP32[($4 + 60 | 0) + 4 >> 2]; + HEAP32[$4 + 24 >> 2] = HEAP32[$4 + 68 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = decltype_28std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false_____unwrap_28std__declval_std____2__reverse_iterator_int____28_29_29_29_20std____2____unwrap_iter_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false__2c_200__28std____2__reverse_iterator_int___29(HEAP32[$4 + 24 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + std____2__pair_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____20std____2____move_loop_std____2___ClassicAlgPolicy___operator_28_29_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29_20const($4 + 44 | 0, $4 + 43 | 0, HEAP32[$4 + 36 >> 2], HEAP32[$4 + 32 >> 2], HEAP32[$4 + 28 >> 2]); + HEAP32[$4 + 16 >> 2] = HEAP32[$4 + 76 >> 2]; + HEAP32[$4 + 12 >> 2] = HEAP32[$4 + 44 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = std____2__reverse_iterator_int___20std____2____rewrap_range_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29(HEAP32[$4 + 16 >> 2], HEAP32[$4 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + HEAP32[$4 + 4 >> 2] = HEAP32[$4 + 68 >> 2]; + HEAP32[$4 >> 2] = HEAP32[($4 + 44 | 0) + 4 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = std____2__reverse_iterator_int___20std____2____rewrap_iter_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false___28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29(HEAP32[$4 + 4 >> 2], HEAP32[$4 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + std____2__pair_std____2____unwrap_ref_decay_std____2__reverse_iterator_int_____type_2c_20std____2____unwrap_ref_decay_std____2__reverse_iterator_int_____type__20std____2__make_pair_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int_____2c_20std____2__reverse_iterator_int_____29($0, $4 + 20 | 0, $4 + 8 | 0); + __stack_pointer = $4 + 80 | 0; +} + +function b2PulleyJoint__SolveVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, $5 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 112 | 0; + __stack_pointer = $2; + HEAP32[$2 + 108 >> 2] = $0; + HEAP32[$2 + 104 >> 2] = $1; + $3 = HEAP32[$2 + 108 >> 2]; + $4 = HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 96 >> 2] = $0; + HEAP32[$2 + 100 >> 2] = $1; + HEAPF32[$2 + 92 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 124 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 80 >> 2] = $1; + HEAP32[$2 + 84 >> 2] = $0; + HEAPF32[$2 + 76 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 124 >> 2], 12) | 0) + 8 >> 2]; + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 60 | 0, HEAPF32[$2 + 92 >> 2], $3 + 144 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 68 | 0, $2 + 96 | 0, $2 + 60 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 44 | 0, HEAPF32[$2 + 76 >> 2], $3 + 152 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 52 | 0, $2 + 80 | 0, $2 + 44 | 0); + $5 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 128 | 0, $2 + 68 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$3 + 112 >> 2]) * b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 136 | 0, $2 + 52 | 0)) - $5), + HEAPF32[wasm2js_i32$0 + 40 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 36 >> 2] = Math_fround(-HEAPF32[$3 + 192 >> 2]) * HEAPF32[$2 + 40 >> 2]; + HEAPF32[$3 + 116 >> 2] = HEAPF32[$3 + 116 >> 2] + HEAPF32[$2 + 36 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 28 | 0, Math_fround(-HEAPF32[$2 + 36 >> 2]), $3 + 128 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, Math_fround(Math_fround(-HEAPF32[$3 + 112 >> 2]) * HEAPF32[$2 + 36 >> 2]), $3 + 136 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$3 + 176 >> 2], $2 + 28 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 96 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$3 + 184 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 144 | 0, $2 + 28 | 0)) + HEAPF32[$2 + 92 >> 2]), + HEAPF32[wasm2js_i32$0 + 92 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 4 | 0, HEAPF32[$3 + 180 >> 2], $2 + 20 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 80 | 0, $2 + 4 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$3 + 188 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 152 | 0, $2 + 20 | 0)) + HEAPF32[$2 + 76 >> 2]), + HEAPF32[wasm2js_i32$0 + 76 >> 2] = wasm2js_f32$0; + $1 = HEAP32[$2 + 100 >> 2]; + $0 = HEAP32[$2 + 96 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 120 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 92 >> 2]; + $0 = HEAP32[$2 + 84 >> 2]; + $1 = HEAP32[$2 + 80 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 124 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 124 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 76 >> 2]; + __stack_pointer = $2 + 112 | 0; +} + +function b2SeparationFunction__Evaluate_28int_2c_20int_2c_20float_29_20const($0, $1, $2, $3) { + var $4 = 0, $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $4 = __stack_pointer - 208 | 0; + __stack_pointer = $4; + HEAP32[$4 + 200 >> 2] = $0; + HEAP32[$4 + 196 >> 2] = $1; + HEAP32[$4 + 192 >> 2] = $2; + HEAPF32[$4 + 188 >> 2] = $3; + $2 = HEAP32[$4 + 200 >> 2]; + b2Transform__b2Transform_28_29($4 + 172 | 0); + b2Transform__b2Transform_28_29($4 + 156 | 0); + b2Sweep__GetTransform_28b2Transform__2c_20float_29_20const($2 + 8 | 0, $4 + 172 | 0, HEAPF32[$4 + 188 >> 2]); + b2Sweep__GetTransform_28b2Transform__2c_20float_29_20const($2 + 44 | 0, $4 + 156 | 0, HEAPF32[$4 + 188 >> 2]); + label$1: { + label$2: { + switch (HEAP32[$2 + 80 >> 2]) { + case 0: + $5 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$2 >> 2], HEAP32[$4 + 196 >> 2]); + $1 = HEAP32[$5 >> 2]; + $0 = HEAP32[$5 + 4 >> 2]; + HEAP32[$4 + 144 >> 2] = $1; + HEAP32[$4 + 148 >> 2] = $0; + $5 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$2 + 4 >> 2], HEAP32[$4 + 192 >> 2]); + $0 = HEAP32[$5 >> 2]; + $1 = HEAP32[$5 + 4 >> 2]; + HEAP32[$4 + 136 >> 2] = $0; + HEAP32[$4 + 140 >> 2] = $1; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 128 | 0, $4 + 172 | 0, $4 + 144 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 120 | 0, $4 + 156 | 0, $4 + 136 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 108 | 0, $4 + 120 | 0, $4 + 128 | 0); + wasm2js_i32$0 = $4, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 108 | 0, $2 + 92 | 0), + HEAPF32[wasm2js_i32$0 + 116 >> 2] = wasm2js_f32$0; + HEAPF32[$4 + 204 >> 2] = HEAPF32[$4 + 116 >> 2]; + break label$1; + + case 1: + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($4 + 100 | 0, $4 + 180 | 0, $2 + 92 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 92 | 0, $4 + 172 | 0, $2 + 84 | 0); + $5 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$2 + 4 >> 2], HEAP32[$4 + 192 >> 2]); + $1 = HEAP32[$5 >> 2]; + $0 = HEAP32[$5 + 4 >> 2]; + HEAP32[$4 + 80 >> 2] = $1; + HEAP32[$4 + 84 >> 2] = $0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 72 | 0, $4 + 156 | 0, $4 + 80 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 60 | 0, $4 + 72 | 0, $4 + 92 | 0); + wasm2js_i32$0 = $4, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 60 | 0, $4 + 100 | 0), + HEAPF32[wasm2js_i32$0 + 68 >> 2] = wasm2js_f32$0; + HEAPF32[$4 + 204 >> 2] = HEAPF32[$4 + 68 >> 2]; + break label$1; + + case 2: + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($4 + 52 | 0, $4 + 164 | 0, $2 + 92 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 44 | 0, $4 + 156 | 0, $2 + 84 | 0); + $5 = b2DistanceProxy__GetVertex_28int_29_20const(HEAP32[$2 >> 2], HEAP32[$4 + 196 >> 2]); + $0 = HEAP32[$5 >> 2]; + $1 = HEAP32[$5 + 4 >> 2]; + HEAP32[$4 + 32 >> 2] = $0; + HEAP32[$4 + 36 >> 2] = $1; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 24 | 0, $4 + 172 | 0, $4 + 32 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 12 | 0, $4 + 24 | 0, $4 + 44 | 0); + wasm2js_i32$0 = $4, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 12 | 0, $4 + 52 | 0), + HEAPF32[wasm2js_i32$0 + 20 >> 2] = wasm2js_f32$0; + HEAPF32[$4 + 204 >> 2] = HEAPF32[$4 + 20 >> 2]; + break label$1; + + default: + break label$2; + } + } + __assert_fail(9147, 5216, 243, 8927); + wasm2js_trap(); + } + __stack_pointer = $4 + 208 | 0; + return HEAPF32[$4 + 204 >> 2]; +} + +function b2PolygonShape__RayCast_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $5 = __stack_pointer - 112 | 0; + __stack_pointer = $5; + HEAP32[$5 + 104 >> 2] = $0; + HEAP32[$5 + 100 >> 2] = $1; + HEAP32[$5 + 96 >> 2] = $2; + HEAP32[$5 + 92 >> 2] = $3; + HEAP32[$5 + 88 >> 2] = $4; + $0 = HEAP32[$5 + 104 >> 2]; + $1 = HEAP32[$5 + 92 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 72 | 0, HEAP32[$5 + 96 >> 2], HEAP32[$5 + 92 >> 2]); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($5 + 80 | 0, $1 + 8 | 0, $5 + 72 | 0); + $1 = HEAP32[$5 + 92 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 56 | 0, HEAP32[$5 + 96 >> 2] + 8 | 0, HEAP32[$5 + 92 >> 2]); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($5 - -64 | 0, $1 + 8 | 0, $5 + 56 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 48 | 0, $5 - -64 | 0, $5 + 80 | 0); + HEAPF32[$5 + 44 >> 2] = 0; + HEAPF32[$5 + 40 >> 2] = HEAPF32[HEAP32[$5 + 96 >> 2] + 16 >> 2]; + HEAP32[$5 + 36 >> 2] = -1; + HEAP32[$5 + 32 >> 2] = 0; + label$1: { + while (1) { + if (HEAP32[$5 + 32 >> 2] < HEAP32[$0 + 148 >> 2]) { + $1 = HEAP32[$5 + 32 >> 2] << 3; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 20 | 0, ($0 + 20 | 0) + (HEAP32[$5 + 32 >> 2] << 3) | 0, $5 + 80 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + ($0 + 84 | 0) | 0, $5 + 20 | 0), + HEAPF32[wasm2js_i32$0 + 28 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29(($0 + 84 | 0) + (HEAP32[$5 + 32 >> 2] << 3) | 0, $5 + 48 | 0), + HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0; + label$4: { + if (HEAPF32[$5 + 16 >> 2] == Math_fround(0)) { + if (HEAPF32[$5 + 28 >> 2] < Math_fround(0)) { + HEAP8[$5 + 111 | 0] = 0; + break label$1; + } + break label$4; + } + label$7: { + if (!(!(HEAPF32[$5 + 16 >> 2] < Math_fround(0)) | !(HEAPF32[$5 + 28 >> 2] < Math_fround(HEAPF32[$5 + 44 >> 2] * HEAPF32[$5 + 16 >> 2])))) { + HEAPF32[$5 + 44 >> 2] = HEAPF32[$5 + 28 >> 2] / HEAPF32[$5 + 16 >> 2]; + HEAP32[$5 + 36 >> 2] = HEAP32[$5 + 32 >> 2]; + break label$7; + } + if (!(!(HEAPF32[$5 + 16 >> 2] > Math_fround(0)) | !(HEAPF32[$5 + 28 >> 2] < Math_fround(HEAPF32[$5 + 40 >> 2] * HEAPF32[$5 + 16 >> 2])))) { + HEAPF32[$5 + 40 >> 2] = HEAPF32[$5 + 28 >> 2] / HEAPF32[$5 + 16 >> 2]; + } + } + } + if (HEAPF32[$5 + 40 >> 2] < HEAPF32[$5 + 44 >> 2]) { + HEAP8[$5 + 111 | 0] = 0; + break label$1; + } else { + HEAP32[$5 + 32 >> 2] = HEAP32[$5 + 32 >> 2] + 1; + continue; + } + } + break; + } + if (!(HEAPF32[$5 + 44 >> 2] <= HEAPF32[HEAP32[$5 + 96 >> 2] + 16 >> 2] & HEAPF32[$5 + 44 >> 2] >= Math_fround(0))) { + __assert_fail(6574, 5758, 326, 1866); + wasm2js_trap(); + } + if (HEAP32[$5 + 36 >> 2] >= 0) { + HEAPF32[HEAP32[$5 + 100 >> 2] + 8 >> 2] = HEAPF32[$5 + 44 >> 2]; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($5 + 8 | 0, HEAP32[$5 + 92 >> 2] + 8 | 0, ($0 + 84 | 0) + (HEAP32[$5 + 36 >> 2] << 3) | 0); + $2 = HEAP32[$5 + 12 >> 2]; + $0 = HEAP32[$5 + 8 >> 2]; + $1 = $0; + $0 = HEAP32[$5 + 100 >> 2]; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + HEAP8[$5 + 111 | 0] = 1; + break label$1; + } + HEAP8[$5 + 111 | 0] = 0; + } + __stack_pointer = $5 + 112 | 0; + return HEAP8[$5 + 111 | 0] & 1; +} + +function b2DynamicTree__MoveProxy_28int_2c_20b2AABB_20const__2c_20b2Vec2_20const__29($0, $1, $2, $3) { + var $4 = 0, $5 = 0; + $4 = __stack_pointer - 128 | 0; + __stack_pointer = $4; + HEAP32[$4 + 120 >> 2] = $0; + HEAP32[$4 + 116 >> 2] = $1; + HEAP32[$4 + 112 >> 2] = $2; + HEAP32[$4 + 108 >> 2] = $3; + $5 = HEAP32[$4 + 120 >> 2]; + if (!(HEAP32[$4 + 116 >> 2] < HEAP32[$5 + 12 >> 2] & HEAP32[$4 + 116 >> 2] >= 0)) { + __assert_fail(1341, 5965, 137, 1049); + wasm2js_trap(); + } + if (!(b2TreeNode__IsLeaf_28_29_20const(HEAP32[$5 + 4 >> 2] + Math_imul(HEAP32[$4 + 116 >> 2], 40) | 0) & 1)) { + __assert_fail(12442, 5965, 139, 1049); + wasm2js_trap(); + } + b2AABB__b2AABB_28_29($4 + 92 | 0); + b2Vec2__b2Vec2_28float_2c_20float_29($4 + 84 | 0, Math_fround(.10000000149011612), Math_fround(.10000000149011612)); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 76 | 0, HEAP32[$4 + 112 >> 2], $4 + 84 | 0); + $0 = HEAP32[$4 + 80 >> 2]; + $1 = HEAP32[$4 + 76 >> 2]; + $2 = $1; + $1 = $4 + 92 | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($4 + 68 | 0, HEAP32[$4 + 112 >> 2] + 8 | 0, $4 + 84 | 0); + $1 = HEAP32[$4 + 72 >> 2]; + $0 = HEAP32[$4 + 68 >> 2]; + $2 = $0; + $0 = $4 + 92 | 0; + HEAP32[$0 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $1; + operator__28float_2c_20b2Vec2_20const__29($4 + 60 | 0, Math_fround(4), HEAP32[$4 + 108 >> 2]); + label$4: { + if (HEAPF32[$4 + 60 >> 2] < Math_fround(0)) { + HEAPF32[$4 + 92 >> 2] = HEAPF32[$4 + 92 >> 2] + HEAPF32[$4 + 60 >> 2]; + break label$4; + } + HEAPF32[$4 + 100 >> 2] = HEAPF32[$4 + 100 >> 2] + HEAPF32[$4 + 60 >> 2]; + } + label$6: { + if (HEAPF32[$4 + 64 >> 2] < Math_fround(0)) { + HEAPF32[$4 + 96 >> 2] = HEAPF32[$4 + 96 >> 2] + HEAPF32[$4 + 64 >> 2]; + break label$6; + } + HEAPF32[$4 + 104 >> 2] = HEAPF32[$4 + 104 >> 2] + HEAPF32[$4 + 64 >> 2]; + } + HEAP32[$4 + 56 >> 2] = HEAP32[$5 + 4 >> 2] + Math_imul(HEAP32[$4 + 116 >> 2], 40); + label$8: { + if (b2AABB__Contains_28b2AABB_20const__29_20const(HEAP32[$4 + 56 >> 2], HEAP32[$4 + 112 >> 2]) & 1) { + b2AABB__b2AABB_28_29($4 + 40 | 0); + operator__28float_2c_20b2Vec2_20const__29($4 + 24 | 0, Math_fround(4), $4 + 84 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 32 | 0, $4 + 92 | 0, $4 + 24 | 0); + $0 = HEAP32[$4 + 36 >> 2]; + $1 = HEAP32[$4 + 32 >> 2]; + $2 = $1; + $1 = $4 + 40 | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + operator__28float_2c_20b2Vec2_20const__29($4 + 8 | 0, Math_fround(4), $4 + 84 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($4 + 16 | 0, $4 + 100 | 0, $4 + 8 | 0); + $1 = HEAP32[$4 + 20 >> 2]; + $0 = HEAP32[$4 + 16 >> 2]; + $2 = $0; + $0 = $4 + 40 | 0; + HEAP32[$0 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $1; + if (b2AABB__Contains_28b2AABB_20const__29_20const($4 + 40 | 0, HEAP32[$4 + 56 >> 2]) & 1) { + HEAP8[$4 + 127 | 0] = 0; + break label$8; + } + } + b2DynamicTree__RemoveLeaf_28int_29($5, HEAP32[$4 + 116 >> 2]); + $0 = HEAP32[$4 + 96 >> 2]; + $1 = HEAP32[$4 + 92 >> 2]; + $3 = $1; + $2 = HEAP32[$5 + 4 >> 2] + Math_imul(HEAP32[$4 + 116 >> 2], 40) | 0; + $1 = $2; + HEAP32[$1 >> 2] = $3; + HEAP32[$1 + 4 >> 2] = $0; + $1 = HEAP32[$4 + 104 >> 2]; + $0 = HEAP32[$4 + 100 >> 2]; + $3 = $0; + $0 = $2; + HEAP32[$0 + 8 >> 2] = $3; + HEAP32[$0 + 12 >> 2] = $1; + b2DynamicTree__InsertLeaf_28int_29($5, HEAP32[$4 + 116 >> 2]); + HEAP8[(HEAP32[$5 + 4 >> 2] + Math_imul(HEAP32[$4 + 116 >> 2], 40) | 0) + 36 | 0] = 1; + HEAP8[$4 + 127 | 0] = 1; + } + __stack_pointer = $4 + 128 | 0; + return HEAP8[$4 + 127 | 0] & 1; +} + +function b2DistanceJoint__SolveVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 112 | 0; + __stack_pointer = $2; + HEAP32[$2 + 108 >> 2] = $0; + HEAP32[$2 + 104 >> 2] = $1; + $3 = HEAP32[$2 + 108 >> 2]; + $4 = HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 96 >> 2] = $0; + HEAP32[$2 + 100 >> 2] = $1; + HEAPF32[$2 + 92 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0) + 8 >> 2]; + $4 = HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 112 >> 2], 12) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$2 + 80 >> 2] = $1; + HEAP32[$2 + 84 >> 2] = $0; + HEAPF32[$2 + 76 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 112 >> 2], 12) | 0) + 8 >> 2]; + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 60 | 0, HEAPF32[$2 + 92 >> 2], $3 + 124 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 68 | 0, $2 + 96 | 0, $2 + 60 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 44 | 0, HEAPF32[$2 + 76 >> 2], $3 + 132 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 52 | 0, $2 + 80 | 0, $2 + 44 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 32 | 0, $2 + 52 | 0, $2 + 68 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 116 | 0, $2 + 32 | 0), + HEAPF32[wasm2js_i32$0 + 40 >> 2] = wasm2js_f32$0; + HEAPF32[$2 + 28 >> 2] = Math_fround(-HEAPF32[$3 + 172 >> 2]) * Math_fround(Math_fround(HEAPF32[$3 + 96 >> 2] * HEAPF32[$3 + 100 >> 2]) + Math_fround(HEAPF32[$2 + 40 >> 2] + HEAPF32[$3 + 76 >> 2])); + HEAPF32[$3 + 100 >> 2] = HEAPF32[$3 + 100 >> 2] + HEAPF32[$2 + 28 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 20 | 0, HEAPF32[$2 + 28 >> 2], $3 + 116 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, HEAPF32[$3 + 156 >> 2], $2 + 20 | 0); + b2Vec2__operator___28b2Vec2_20const__29_1($2 + 96 | 0, $2 + 12 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$3 + 164 >> 2]) * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 124 | 0, $2 + 20 | 0)) + HEAPF32[$2 + 92 >> 2]), + HEAPF32[wasm2js_i32$0 + 92 >> 2] = wasm2js_f32$0; + operator__28float_2c_20b2Vec2_20const__29($2 + 4 | 0, HEAPF32[$3 + 160 >> 2], $2 + 20 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 80 | 0, $2 + 4 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$3 + 168 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 132 | 0, $2 + 20 | 0)) + HEAPF32[$2 + 76 >> 2]), + HEAPF32[wasm2js_i32$0 + 76 >> 2] = wasm2js_f32$0; + $1 = HEAP32[$2 + 100 >> 2]; + $0 = HEAP32[$2 + 96 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $1; + HEAPF32[(HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 108 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 92 >> 2]; + $0 = HEAP32[$2 + 84 >> 2]; + $1 = HEAP32[$2 + 80 >> 2]; + $4 = $1; + $1 = HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 112 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + HEAPF32[(HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$3 + 112 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 76 >> 2]; + __stack_pointer = $2 + 112 | 0; +} + +function b2ContactManager__Collide_28_29($0) { + var $1 = 0, $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer + -64 | 0; + __stack_pointer = $1; + HEAP32[$1 + 60 >> 2] = $0; + $0 = HEAP32[$1 + 60 >> 2]; + HEAP32[$1 + 56 >> 2] = HEAP32[$0 + 60 >> 2]; + while (1) { + if (HEAP32[$1 + 56 >> 2]) { + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetFixtureA_28_29(HEAP32[$1 + 56 >> 2]), + HEAP32[wasm2js_i32$0 + 52 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetFixtureB_28_29(HEAP32[$1 + 56 >> 2]), + HEAP32[wasm2js_i32$0 + 48 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetChildIndexA_28_29_20const(HEAP32[$1 + 56 >> 2]), + HEAP32[wasm2js_i32$0 + 44 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetChildIndexB_28_29_20const(HEAP32[$1 + 56 >> 2]), + HEAP32[wasm2js_i32$0 + 40 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$1 + 52 >> 2]), + HEAP32[wasm2js_i32$0 + 36 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$1 + 48 >> 2]), + HEAP32[wasm2js_i32$0 + 32 >> 2] = wasm2js_i32$1; + if (HEAP32[HEAP32[$1 + 56 >> 2] + 4 >> 2] & 8) { + label$4: { + if (!HEAP32[$0 + 68 >> 2]) { + break label$4; + } + $2 = HEAP32[$0 + 68 >> 2]; + if (FUNCTION_TABLE[HEAP32[HEAP32[$2 >> 2] + 8 >> 2]]($2, HEAP32[$1 + 52 >> 2], HEAP32[$1 + 48 >> 2]) & 1) { + break label$4; + } + HEAP32[$1 + 28 >> 2] = HEAP32[$1 + 56 >> 2]; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetNext_28_29(HEAP32[$1 + 28 >> 2]), + HEAP32[wasm2js_i32$0 + 56 >> 2] = wasm2js_i32$1; + b2ContactManager__Destroy_28b2Contact__29($0, HEAP32[$1 + 28 >> 2]); + continue; + } + $2 = HEAP32[$1 + 56 >> 2]; + HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 4 >> 2] & -9; + } + $2 = 0; + if (b2Body__IsAwake_28_29_20const(HEAP32[$1 + 36 >> 2]) & 1) { + $2 = HEAP32[HEAP32[$1 + 36 >> 2] >> 2] != 0; + } + HEAP8[$1 + 27 | 0] = $2; + $2 = 0; + if (b2Body__IsAwake_28_29_20const(HEAP32[$1 + 32 >> 2]) & 1) { + $2 = HEAP32[HEAP32[$1 + 32 >> 2] >> 2] != 0; + } + HEAP8[$1 + 26 | 0] = $2; + if (!(HEAP8[$1 + 27 | 0] & 1 | HEAP8[$1 + 26 | 0] & 1)) { + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetNext_28_29(HEAP32[$1 + 56 >> 2]), + HEAP32[wasm2js_i32$0 + 56 >> 2] = wasm2js_i32$1; + continue; + } + HEAP32[$1 + 20 >> 2] = HEAP32[(HEAP32[HEAP32[$1 + 52 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 44 >> 2], 28) | 0) + 24 >> 2]; + HEAP32[$1 + 16 >> 2] = HEAP32[(HEAP32[HEAP32[$1 + 48 >> 2] + 24 >> 2] + Math_imul(HEAP32[$1 + 40 >> 2], 28) | 0) + 24 >> 2]; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2BroadPhase__TestOverlap_28int_2c_20int_29_20const($0, HEAP32[$1 + 20 >> 2], HEAP32[$1 + 16 >> 2]) & 1, + HEAP8[wasm2js_i32$0 + 15 | 0] = wasm2js_i32$1; + if (HEAP8[$1 + 15 | 0] & 1) { + b2Contact__Update_28b2ContactListener__29(HEAP32[$1 + 56 >> 2], HEAP32[$0 + 72 >> 2]); + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetNext_28_29(HEAP32[$1 + 56 >> 2]), + HEAP32[wasm2js_i32$0 + 56 >> 2] = wasm2js_i32$1; + } else { + HEAP32[$1 + 8 >> 2] = HEAP32[$1 + 56 >> 2]; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetNext_28_29(HEAP32[$1 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 56 >> 2] = wasm2js_i32$1; + b2ContactManager__Destroy_28b2Contact__29($0, HEAP32[$1 + 8 >> 2]); + } + continue; + } + break; + } + __stack_pointer = $1 - -64 | 0; +} + +function __trunctfdf2($0, $1, $2, $3) { + var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0; + $12 = __stack_pointer - 32 | 0; + __stack_pointer = $12; + $6 = $3; + $8 = $6 & 2147483647; + $9 = $8; + $4 = $2; + $2 = $4; + $6 = $4; + $5 = $6; + $7 = 1006698496; + $7 = $8 - $7 | 0; + $6 = $7; + $7 = $8; + $5 = 1140785152; + $5 = $7 - $5 | 0; + $8 = $5; + $5 = $6; + label$1: { + if (($8 | 0) == ($5 | 0) & $4 >>> 0 < $4 >>> 0 | $5 >>> 0 < $8 >>> 0) { + $7 = $3; + $5 = $7 << 4 | $2 >>> 28; + $4 = $5; + $5 = $1; + $8 = $5 >>> 28 | 0; + $5 = $2 << 4; + $2 = $8 | $5; + $7 = $10; + $7 = $4 | $7; + $9 = $7; + $7 = $1; + $5 = $7 & 268435455; + $1 = $5; + $7 = $0; + if (($5 | 0) == 134217728 & ($7 | 0) != 0 | $5 >>> 0 > 134217728) { + $7 = $9; + $4 = $7 + 1073741824 | 0; + $8 = $2; + $6 = $8 + 1 | 0; + $4 = $6 ? $4 : $4 + 1 | 0; + $11 = $6; + $10 = $4; + break label$1; + } + $7 = $2; + $5 = $7; + $11 = $5; + $4 = $9; + $6 = -1073741824; + $6 = $4 - $6 | 0; + $10 = $6; + $4 = $0; + $6 = $1; + if ($4 | ($6 | 0) != 134217728) { + break label$1; + } + $4 = $11; + $7 = $2 & 1; + $8 = $4 + $7 | 0; + $6 = $10; + $4 = $13; + $5 = $6 + $4 | 0; + $11 = $8; + $5 = $7 >>> 0 > $8 >>> 0 ? $5 + 1 | 0 : $5; + $10 = $5; + break label$1; + } + $5 = $1; + $4 = !($5 | $0); + $5 = $9; + $5 = $5 >>> 0 < 2147418112; + $6 = $9; + if (!(!$2 & ($6 | 0) == 2147418112 ? $4 : $5)) { + $7 = $3; + $4 = $2; + $6 = $7 << 4 | $4 >>> 28; + $0 = $4 << 4; + $4 = $6; + $6 = $1; + $5 = $6 >>> 28 | 0; + $7 = $10; + $7 = $4 | $7; + $6 = $0; + $4 = $6 | $5; + $6 = $7 & 524287; + $11 = $4; + $4 = $6 | 2146959360; + $10 = $4; + break label$1; + } + $10 = 2146435072; + $4 = $9; + if ($4 >>> 0 > 1140785151) { + break label$1; + } + $10 = 0; + $6 = $9; + $7 = $6 >>> 16 | 0; + if ($7 >>> 0 < 15249) { + break label$1; + } + $4 = $3; + $5 = $4 & 65535; + $6 = $2; + $6 = $5 | 65536; + $9 = $6; + $6 = $1; + $4 = $9; + __ashlti3($12 + 16 | 0, $0, $6, $2, $4, $7 - 15233 | 0); + $4 = $6; + $6 = $9; + __lshrti3($12, $0, $4, $2, $6, 15361 - $7 | 0); + $5 = $12; + $6 = HEAP32[$5 + 8 >> 2]; + $4 = HEAP32[$5 + 12 >> 2]; + $1 = $6 << 4; + $6 = $4 << 4 | $6 >>> 28; + $0 = $6; + $4 = $12; + $6 = HEAP32[$4 >> 2]; + $5 = HEAP32[$4 + 4 >> 2]; + $9 = $5; + $2 = $6; + $7 = $5 >>> 28 | 0; + $5 = $1; + $11 = $5 | $7; + $6 = $0; + $4 = $13; + $4 = $6 | $4; + $10 = $4; + $6 = $12; + $4 = HEAP32[$6 + 16 >> 2]; + $0 = $4; + $5 = HEAP32[$6 + 20 >> 2]; + $1 = $5; + $5 = HEAP32[$6 + 24 >> 2]; + $7 = $5; + $4 = HEAP32[$6 + 28 >> 2]; + $5 = $4; + $4 = $1; + $5 = $4 | $5; + $6 = $0; + $4 = $6 | $7; + $0 = ($5 | $4) != 0; + $4 = $9; + $5 = $4 & 268435455; + $7 = $2; + $6 = $7; + $4 = $0; + $2 = $6 | $4; + $7 = $5; + $9 = $5; + $5 = $2; + if (($7 | 0) == 134217728 & ($5 | 0) != 0 | $7 >>> 0 > 134217728) { + $5 = $10; + $6 = $11; + $4 = $6 + 1 | 0; + $8 = $4 ? $5 : $5 + 1 | 0; + $11 = $4; + $10 = $8; + break label$1; + } + $8 = $9; + if ($2 | ($8 | 0) != 134217728) { + break label$1; + } + $4 = $11; + $6 = $4; + $5 = $6 & 1; + $7 = $6 + $5 | 0; + $8 = 0; + $4 = $10; + $4 = $8 + $4 | 0; + $11 = $7; + $4 = $7 >>> 0 < $6 >>> 0 ? $4 + 1 | 0 : $4; + $10 = $4; + } + __stack_pointer = $12 + 32 | 0; + $4 = $3; + $5 = $4 & -2147483648; + $6 = 0; + $4 = $11; + wasm2js_scratch_store_i32(0, $6 | $4); + $8 = $5; + $5 = $10; + $8 = $8 | $5; + wasm2js_scratch_store_i32(1, $8 | 0); + return +wasm2js_scratch_load_f64(); +} + +function b2Body__ResetMassData_28_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 80 | 0; + __stack_pointer = $2; + HEAP32[$2 + 76 >> 2] = $0; + $1 = HEAP32[$2 + 76 >> 2]; + HEAPF32[$1 + 116 >> 2] = 0; + HEAPF32[$1 + 120 >> 2] = 0; + HEAPF32[$1 + 124 >> 2] = 0; + HEAPF32[$1 + 128 >> 2] = 0; + b2Vec2__SetZero_28_29($1 + 28 | 0); + label$1: { + if (!(HEAP32[$1 >> 2] != 1 ? HEAP32[$1 >> 2] : 0)) { + $3 = HEAP32[$1 + 16 >> 2]; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$1 + 36 >> 2] = $0; + HEAP32[$1 + 40 >> 2] = $3; + $0 = HEAP32[$1 + 16 >> 2]; + $3 = HEAP32[$1 + 12 >> 2]; + HEAP32[$1 + 44 >> 2] = $3; + HEAP32[$1 + 48 >> 2] = $0; + HEAPF32[$1 + 52 >> 2] = HEAPF32[$1 + 56 >> 2]; + break label$1; + } + if (HEAP32[$1 >> 2] != 2) { + __assert_fail(1677, 4100, 307, 10425); + wasm2js_trap(); + } + $3 = HEAP32[7691]; + $0 = HEAP32[7690]; + HEAP32[$2 + 64 >> 2] = $0; + HEAP32[$2 + 68 >> 2] = $3; + HEAP32[$2 + 60 >> 2] = HEAP32[$1 + 100 >> 2]; + while (1) { + if (HEAP32[$2 + 60 >> 2]) { + if (HEAPF32[HEAP32[$2 + 60 >> 2] >> 2] != Math_fround(0)) { + b2MassData__b2MassData_28_29($2 + 44 | 0); + b2Fixture__GetMassData_28b2MassData__29_20const(HEAP32[$2 + 60 >> 2], $2 + 44 | 0); + HEAPF32[$1 + 116 >> 2] = HEAPF32[$1 + 116 >> 2] + HEAPF32[$2 + 44 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($2 + 36 | 0, HEAPF32[$2 + 44 >> 2], $2 + 48 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 - -64 | 0, $2 + 36 | 0); + HEAPF32[$1 + 124 >> 2] = HEAPF32[$1 + 124 >> 2] + HEAPF32[$2 + 56 >> 2]; + } + HEAP32[$2 + 60 >> 2] = HEAP32[HEAP32[$2 + 60 >> 2] + 4 >> 2]; + continue; + } + break; + } + if (HEAPF32[$1 + 116 >> 2] > Math_fround(0)) { + HEAPF32[$1 + 120 >> 2] = Math_fround(1) / HEAPF32[$1 + 116 >> 2]; + b2Vec2__operator___28float_29($2 - -64 | 0, HEAPF32[$1 + 120 >> 2]); + } + label$9: { + if (!(!(HEAPF32[$1 + 124 >> 2] > Math_fround(0)) | HEAPU16[$1 + 4 >> 1] & 16)) { + $0 = $2 - -64 | 0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$1 + 116 >> 2]) * b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $0)) + HEAPF32[$1 + 124 >> 2]), + HEAPF32[wasm2js_i32$0 + 124 >> 2] = wasm2js_f32$0; + if (!(HEAPF32[$1 + 124 >> 2] > Math_fround(0))) { + __assert_fail(8118, 4100, 336, 10425); + wasm2js_trap(); + } + HEAPF32[$1 + 128 >> 2] = Math_fround(1) / HEAPF32[$1 + 124 >> 2]; + break label$9; + } + HEAPF32[$1 + 124 >> 2] = 0; + HEAPF32[$1 + 128 >> 2] = 0; + } + $0 = HEAP32[$1 + 48 >> 2]; + $3 = HEAP32[$1 + 44 >> 2]; + HEAP32[$2 + 24 >> 2] = $3; + HEAP32[$2 + 28 >> 2] = $0; + $3 = HEAP32[$2 + 68 >> 2]; + $0 = HEAP32[$2 + 64 >> 2]; + HEAP32[$1 + 28 >> 2] = $0; + HEAP32[$1 + 32 >> 2] = $3; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($2 + 16 | 0, $1 + 12 | 0, $1 + 28 | 0); + $0 = HEAP32[$2 + 20 >> 2]; + $3 = HEAP32[$2 + 16 >> 2]; + HEAP32[$1 + 44 >> 2] = $3; + HEAP32[$1 + 48 >> 2] = $0; + $3 = HEAP32[$1 + 48 >> 2]; + $0 = HEAP32[$1 + 44 >> 2]; + HEAP32[$1 + 36 >> 2] = $0; + HEAP32[$1 + 40 >> 2] = $3; + $4 = HEAPF32[$1 + 72 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2, $1 + 44 | 0, $2 + 24 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 8 | 0, $4, $2); + b2Vec2__operator___28b2Vec2_20const__29($1 - -64 | 0, $2 + 8 | 0); + } + __stack_pointer = $2 + 80 | 0; +} +function b2Joint__Draw_28b2Draw__29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 112 | 0; + __stack_pointer = $2; + HEAP32[$2 + 108 >> 2] = $0; + HEAP32[$2 + 104 >> 2] = $1; + $1 = HEAP32[$2 + 108 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Body__GetTransform_28_29_20const(HEAP32[$1 + 48 >> 2]), + HEAP32[wasm2js_i32$0 + 100 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Body__GetTransform_28_29_20const(HEAP32[$1 + 52 >> 2]), + HEAP32[wasm2js_i32$0 + 96 >> 2] = wasm2js_i32$1; + $3 = HEAP32[$2 + 100 >> 2]; + $4 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + HEAP32[$2 + 88 >> 2] = $4; + HEAP32[$2 + 92 >> 2] = $0; + $3 = HEAP32[$2 + 96 >> 2]; + $0 = HEAP32[$3 >> 2]; + $4 = HEAP32[$3 + 4 >> 2]; + HEAP32[$2 + 80 >> 2] = $0; + HEAP32[$2 + 84 >> 2] = $4; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] >> 2]]($2 + 72 | 0, $1); + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 4 >> 2]]($2 - -64 | 0, $1); + b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($2 + 48 | 0, Math_fround(.5), Math_fround(.800000011920929), Math_fround(.800000011920929), Math_fround(1)); + label$1: { + label$2: { + switch (HEAP32[$1 + 4 >> 2] - 3 | 0) { + case 0: + $0 = HEAP32[$2 + 104 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 72 | 0, $2 - -64 | 0, $2 + 48 | 0); + break label$1; + + case 1: + HEAP32[$2 + 44 >> 2] = $1; + b2PulleyJoint__GetGroundAnchorA_28_29_20const($2 + 36 | 0, HEAP32[$2 + 44 >> 2]); + b2PulleyJoint__GetGroundAnchorB_28_29_20const($2 + 28 | 0, HEAP32[$2 + 44 >> 2]); + $0 = HEAP32[$2 + 104 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 36 | 0, $2 + 72 | 0, $2 + 48 | 0); + $0 = HEAP32[$2 + 104 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 28 | 0, $2 - -64 | 0, $2 + 48 | 0); + $0 = HEAP32[$2 + 104 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 36 | 0, $2 + 28 | 0, $2 + 48 | 0); + break label$1; + + case 2: + b2Color__b2Color_28_29($2 + 12 | 0); + b2Color__Set_28float_2c_20float_2c_20float_2c_20float_29($2 + 12 | 0, Math_fround(0), Math_fround(1), Math_fround(0), Math_fround(1)); + $0 = HEAP32[$2 + 104 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 32 >> 2]]($0, $2 + 72 | 0, Math_fround(4), $2 + 12 | 0); + $0 = HEAP32[$2 + 104 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 32 >> 2]]($0, $2 - -64 | 0, Math_fround(4), $2 + 12 | 0); + b2Color__Set_28float_2c_20float_2c_20float_2c_20float_29($2 + 12 | 0, Math_fround(.800000011920929), Math_fround(.800000011920929), Math_fround(.800000011920929), Math_fround(1)); + $0 = HEAP32[$2 + 104 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 72 | 0, $2 - -64 | 0, $2 + 12 | 0); + break label$1; + + default: + break label$2; + } + } + $0 = HEAP32[$2 + 104 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 88 | 0, $2 + 72 | 0, $2 + 48 | 0); + $0 = HEAP32[$2 + 104 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 72 | 0, $2 - -64 | 0, $2 + 48 | 0); + $0 = HEAP32[$2 + 104 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $2 + 80 | 0, $2 - -64 | 0, $2 + 48 | 0); + } + __stack_pointer = $2 + 112 | 0; +} + +function std____2__pair_std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__2c_20bool__20std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______emplace_unique_key_args_b2Fixture__2c_20b2Fixture__20const___28b2Fixture__20const__2c_20b2Fixture__20const__29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 48 | 0; + __stack_pointer = $4; + HEAP32[$4 + 44 >> 2] = $1; + HEAP32[$4 + 40 >> 2] = $2; + HEAP32[$4 + 36 >> 2] = $3; + $1 = HEAP32[$4 + 44 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = std____2____tree_node_base_void_____20std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______find_equal_b2Fixture___28std____2____tree_end_node_std____2____tree_node_base_void_______2c_20b2Fixture__20const__29($1, $4 + 32 | 0, HEAP32[$4 + 40 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + HEAP32[$4 + 24 >> 2] = HEAP32[HEAP32[$4 + 28 >> 2] >> 2]; + HEAP8[$4 + 23 | 0] = 0; + if (!HEAP32[HEAP32[$4 + 28 >> 2] >> 2]) { + std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______20std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______construct_node_b2Fixture__20const___28b2Fixture__20const__29($4 + 8 | 0, $1, HEAP32[$4 + 36 >> 2]); + std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______insert_node_at_28std____2____tree_end_node_std____2____tree_node_base_void______2c_20std____2____tree_node_base_void_____2c_20std____2____tree_node_base_void____29($1, HEAP32[$4 + 32 >> 2], HEAP32[$4 + 28 >> 2], std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______get_5babi_v160004_5d_28_29_20const($4 + 8 | 0)); + wasm2js_i32$0 = $4, wasm2js_i32$1 = std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______release_5babi_v160004_5d_28_29($4 + 8 | 0), + HEAP32[wasm2js_i32$0 + 24 >> 2] = wasm2js_i32$1; + HEAP8[$4 + 23 | 0] = 1; + std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void________unique_ptr_5babi_v160004_5d_28_29($4 + 8 | 0); + } + std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____tree_iterator_5babi_v160004_5d_28std____2____tree_node_b2Fixture__2c_20void____29($4 + 4 | 0, HEAP32[$4 + 24 >> 2]); + std____2__pair_std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__2c_20bool___pair_5babi_v160004_5d_std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__2c_20bool__2c_20_28void__290__28std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long____2c_20bool__29($0, $4 + 4 | 0, $4 + 23 | 0); + __stack_pointer = $4 + 48 | 0; +} + +function b2World__DestroyJoint_28b2Joint__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + if (b2World__IsLocked_28_29_20const($0) & 1) { + __assert_fail(9133, 6161, 282, 2511); + wasm2js_trap(); + } + label$2: { + if (b2World__IsLocked_28_29_20const($0) & 1) { + break label$2; + } + HEAP8[$2 + 23 | 0] = HEAP8[HEAP32[$2 + 24 >> 2] + 61 | 0] & 1; + if (HEAP32[HEAP32[$2 + 24 >> 2] + 8 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 8 >> 2] + 12 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 12 >> 2]; + } + if (HEAP32[HEAP32[$2 + 24 >> 2] + 12 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 12 >> 2] + 8 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 8 >> 2]; + } + if (HEAP32[$2 + 24 >> 2] == HEAP32[$0 + 102952 >> 2]) { + HEAP32[$0 + 102952 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 12 >> 2]; + } + HEAP32[$2 + 16 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 48 >> 2]; + HEAP32[$2 + 12 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 52 >> 2]; + b2Body__SetAwake_28bool_29(HEAP32[$2 + 16 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$2 + 12 >> 2], 1); + if (HEAP32[HEAP32[$2 + 24 >> 2] + 24 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 24 >> 2] + 12 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 28 >> 2]; + } + if (HEAP32[HEAP32[$2 + 24 >> 2] + 28 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 28 >> 2] + 8 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 24 >> 2]; + } + if (HEAP32[HEAP32[$2 + 16 >> 2] + 108 >> 2] == (HEAP32[$2 + 24 >> 2] + 16 | 0)) { + HEAP32[HEAP32[$2 + 16 >> 2] + 108 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 28 >> 2]; + } + HEAP32[HEAP32[$2 + 24 >> 2] + 24 >> 2] = 0; + HEAP32[HEAP32[$2 + 24 >> 2] + 28 >> 2] = 0; + if (HEAP32[HEAP32[$2 + 24 >> 2] + 40 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 40 >> 2] + 12 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 44 >> 2]; + } + if (HEAP32[HEAP32[$2 + 24 >> 2] + 44 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 44 >> 2] + 8 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 40 >> 2]; + } + if (HEAP32[HEAP32[$2 + 12 >> 2] + 108 >> 2] == (HEAP32[$2 + 24 >> 2] + 32 | 0)) { + HEAP32[HEAP32[$2 + 12 >> 2] + 108 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 44 >> 2]; + } + HEAP32[HEAP32[$2 + 24 >> 2] + 40 >> 2] = 0; + HEAP32[HEAP32[$2 + 24 >> 2] + 44 >> 2] = 0; + b2Joint__Destroy_28b2Joint__2c_20b2BlockAllocator__29(HEAP32[$2 + 24 >> 2], $0); + if (HEAP32[$0 + 102960 >> 2] <= 0) { + __assert_fail(12255, 6161, 354, 2511); + wasm2js_trap(); + } + HEAP32[$0 + 102960 >> 2] = HEAP32[$0 + 102960 >> 2] - 1; + if (HEAP8[$2 + 23 | 0] & 1) { + break label$2; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Body__GetContactList_28_29(HEAP32[$2 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + while (1) { + if (HEAP32[$2 + 8 >> 2]) { + if (HEAP32[HEAP32[$2 + 8 >> 2] >> 2] == HEAP32[$2 + 16 >> 2]) { + b2Contact__FlagForFiltering_28_29(HEAP32[HEAP32[$2 + 8 >> 2] + 4 >> 2]); + } + HEAP32[$2 + 8 >> 2] = HEAP32[HEAP32[$2 + 8 >> 2] + 12 >> 2]; + continue; + } + break; + } + } + __stack_pointer = $2 + 32 | 0; +} + +function b2World__DestroyBody_28b2Body__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + if (HEAP32[$0 + 102956 >> 2] <= 0) { + __assert_fail(12195, 6161, 141, 1615); + wasm2js_trap(); + } + if (b2World__IsLocked_28_29_20const($0) & 1) { + __assert_fail(9133, 6161, 142, 1615); + wasm2js_trap(); + } + if (!(b2World__IsLocked_28_29_20const($0) & 1)) { + HEAP32[$2 + 20 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 108 >> 2]; + while (1) { + if (HEAP32[$2 + 20 >> 2]) { + HEAP32[$2 + 16 >> 2] = HEAP32[$2 + 20 >> 2]; + HEAP32[$2 + 20 >> 2] = HEAP32[HEAP32[$2 + 20 >> 2] + 12 >> 2]; + if (HEAP32[$0 + 102976 >> 2]) { + $1 = HEAP32[$0 + 102976 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 8 >> 2]]($1, HEAP32[HEAP32[$2 + 16 >> 2] + 4 >> 2]); + } + b2World__DestroyJoint_28b2Joint__29($0, HEAP32[HEAP32[$2 + 16 >> 2] + 4 >> 2]); + HEAP32[HEAP32[$2 + 24 >> 2] + 108 >> 2] = HEAP32[$2 + 20 >> 2]; + continue; + } + break; + } + HEAP32[HEAP32[$2 + 24 >> 2] + 108 >> 2] = 0; + HEAP32[$2 + 12 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 112 >> 2]; + while (1) { + if (HEAP32[$2 + 12 >> 2]) { + HEAP32[$2 + 8 >> 2] = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 12 >> 2] = HEAP32[HEAP32[$2 + 12 >> 2] + 12 >> 2]; + b2ContactManager__Destroy_28b2Contact__29($0 + 102868 | 0, HEAP32[HEAP32[$2 + 8 >> 2] + 4 >> 2]); + continue; + } + break; + } + HEAP32[HEAP32[$2 + 24 >> 2] + 112 >> 2] = 0; + HEAP32[$2 + 4 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 100 >> 2]; + while (1) { + if (HEAP32[$2 + 4 >> 2]) { + HEAP32[$2 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$2 + 4 >> 2] = HEAP32[HEAP32[$2 + 4 >> 2] + 4 >> 2]; + if (HEAP32[$0 + 102976 >> 2]) { + $1 = HEAP32[$0 + 102976 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 12 >> 2]]($1, HEAP32[$2 >> 2]); + } + b2Fixture__DestroyProxies_28b2BroadPhase__29(HEAP32[$2 >> 2], $0 + 102868 | 0); + b2Fixture__Destroy_28b2BlockAllocator__29(HEAP32[$2 >> 2], $0); + b2BlockAllocator__Free_28void__2c_20int_29($0, HEAP32[$2 >> 2], 44); + HEAP32[HEAP32[$2 + 24 >> 2] + 100 >> 2] = HEAP32[$2 + 4 >> 2]; + $1 = HEAP32[$2 + 24 >> 2]; + HEAP32[$1 + 104 >> 2] = HEAP32[$1 + 104 >> 2] - 1; + continue; + } + break; + } + HEAP32[HEAP32[$2 + 24 >> 2] + 100 >> 2] = 0; + HEAP32[HEAP32[$2 + 24 >> 2] + 104 >> 2] = 0; + if (HEAP32[HEAP32[$2 + 24 >> 2] + 92 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 92 >> 2] + 96 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 96 >> 2]; + } + if (HEAP32[HEAP32[$2 + 24 >> 2] + 96 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 96 >> 2] + 92 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 92 >> 2]; + } + if (HEAP32[$2 + 24 >> 2] == HEAP32[$0 + 102948 >> 2]) { + HEAP32[$0 + 102948 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 96 >> 2]; + } + HEAP32[$0 + 102956 >> 2] = HEAP32[$0 + 102956 >> 2] - 1; + b2Body___b2Body_28_29(HEAP32[$2 + 24 >> 2]); + b2BlockAllocator__Free_28void__2c_20int_29($0, HEAP32[$2 + 24 >> 2], 152); + } + __stack_pointer = $2 + 32 | 0; +} + +function b2BlockAllocator__Allocate_28int_29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer + -64 | 0; + __stack_pointer = $2; + HEAP32[$2 + 56 >> 2] = $0; + HEAP32[$2 + 52 >> 2] = $1; + $0 = HEAP32[$2 + 56 >> 2]; + label$1: { + if (!HEAP32[$2 + 52 >> 2]) { + HEAP32[$2 + 60 >> 2] = 0; + break label$1; + } + if (HEAP32[$2 + 52 >> 2] <= 0) { + __assert_fail(8597, 5349, 118, 8952); + wasm2js_trap(); + } + if (HEAP32[$2 + 52 >> 2] > 640) { + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Alloc_28int_29(HEAP32[$2 + 52 >> 2]), HEAP32[wasm2js_i32$0 + 60 >> 2] = wasm2js_i32$1; + break label$1; + } + HEAP32[$2 + 48 >> 2] = HEAPU8[HEAP32[$2 + 52 >> 2] + 30116 | 0]; + if (!(HEAP32[$2 + 48 >> 2] < 14 & HEAP32[$2 + 48 >> 2] >= 0)) { + __assert_fail(2135, 5349, 126, 8952); + wasm2js_trap(); + } + if (HEAP32[($0 + 12 | 0) + (HEAP32[$2 + 48 >> 2] << 2) >> 2]) { + HEAP32[$2 + 44 >> 2] = HEAP32[($0 + 12 | 0) + (HEAP32[$2 + 48 >> 2] << 2) >> 2]; + HEAP32[($0 + 12 | 0) + (HEAP32[$2 + 48 >> 2] << 2) >> 2] = HEAP32[HEAP32[$2 + 44 >> 2] >> 2]; + HEAP32[$2 + 60 >> 2] = HEAP32[$2 + 44 >> 2]; + break label$1; + } + if (HEAP32[$0 + 4 >> 2] == HEAP32[$0 + 8 >> 2]) { + HEAP32[$2 + 40 >> 2] = HEAP32[$0 >> 2]; + HEAP32[$0 + 8 >> 2] = HEAP32[$0 + 8 >> 2] + 128; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Alloc_28int_29(HEAP32[$0 + 8 >> 2] << 3), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + __memcpy(HEAP32[$0 >> 2], HEAP32[$2 + 40 >> 2], HEAP32[$0 + 4 >> 2] << 3); + __memset(HEAP32[$0 >> 2] + (HEAP32[$0 + 4 >> 2] << 3) | 0, 0, 1024); + b2Free_28void__29(HEAP32[$2 + 40 >> 2]); + } + HEAP32[$2 + 36 >> 2] = HEAP32[$0 >> 2] + (HEAP32[$0 + 4 >> 2] << 3); + $1 = b2Alloc_28int_29(16384); + HEAP32[HEAP32[$2 + 36 >> 2] + 4 >> 2] = $1; + HEAP32[$2 + 32 >> 2] = HEAP32[(HEAP32[$2 + 48 >> 2] << 2) + 18128 >> 2]; + HEAP32[HEAP32[$2 + 36 >> 2] >> 2] = HEAP32[$2 + 32 >> 2]; + HEAP32[$2 + 28 >> 2] = 16384 / HEAP32[$2 + 32 >> 2]; + if ((Math_imul(HEAP32[$2 + 28 >> 2], HEAP32[$2 + 32 >> 2]) | 0) > 16384) { + __assert_fail(8617, 5349, 154, 8952); + wasm2js_trap(); + } + HEAP32[$2 + 24 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 24 >> 2] < (HEAP32[$2 + 28 >> 2] - 1 | 0)) { + HEAP32[$2 + 20 >> 2] = HEAP32[HEAP32[$2 + 36 >> 2] + 4 >> 2] + Math_imul(HEAP32[$2 + 32 >> 2], HEAP32[$2 + 24 >> 2]); + HEAP32[$2 + 16 >> 2] = HEAP32[HEAP32[$2 + 36 >> 2] + 4 >> 2] + Math_imul(HEAP32[$2 + 32 >> 2], HEAP32[$2 + 24 >> 2] + 1 | 0); + HEAP32[HEAP32[$2 + 20 >> 2] >> 2] = HEAP32[$2 + 16 >> 2]; + HEAP32[$2 + 24 >> 2] = HEAP32[$2 + 24 >> 2] + 1; + continue; + } + break; + } + HEAP32[$2 + 12 >> 2] = HEAP32[HEAP32[$2 + 36 >> 2] + 4 >> 2] + Math_imul(HEAP32[$2 + 32 >> 2], HEAP32[$2 + 28 >> 2] - 1 | 0); + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] = 0; + HEAP32[($0 + 12 | 0) + (HEAP32[$2 + 48 >> 2] << 2) >> 2] = HEAP32[HEAP32[HEAP32[$2 + 36 >> 2] + 4 >> 2] >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] + 1; + HEAP32[$2 + 60 >> 2] = HEAP32[HEAP32[$2 + 36 >> 2] + 4 >> 2]; + } + __stack_pointer = $2 - -64 | 0; + return HEAP32[$2 + 60 >> 2]; +} + +function std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______20std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______construct_node_b2Fixture__20const___28b2Fixture__20const__29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $1; + HEAP32[$3 + 24 >> 2] = $2; + wasm2js_i32$0 = $3, wasm2js_i32$1 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______node_alloc_5babi_v160004_5d_28_29(HEAP32[$3 + 28 >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + HEAP8[$3 + 19 | 0] = 0; + $1 = std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______allocate_5babi_v160004_5d_28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20unsigned_20long_29(HEAP32[$3 + 20 >> 2], 1); + std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void________tree_node_destructor_5babi_v160004_5d_28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20bool_29($3 + 8 | 0, HEAP32[$3 + 20 >> 2], 0); + std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______unique_ptr_5babi_v160004_5d_true_2c_20void__28std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____dependent_type_std____2____unique_ptr_deleter_sfinae_std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______2c_20true_____good_rval_ref_type_29($0, $1, $3 + 8 | 0); + void_20std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______construct_5babi_v160004_5d_b2Fixture__2c_20b2Fixture__20const__2c_20void__28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20b2Fixture___2c_20b2Fixture__20const__29(HEAP32[$3 + 20 >> 2], std____2____tree_key_value_types_b2Fixture______get_ptr_5babi_v160004_5d_28b2Fixture___29(std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______operator___5babi_v160004_5d_28_29_20const($0) + 16 | 0), HEAP32[$3 + 24 >> 2]); + wasm2js_i32$0 = std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______get_deleter_5babi_v160004_5d_28_29($0), + wasm2js_i32$1 = 1, HEAP8[wasm2js_i32$0 + 4 | 0] = wasm2js_i32$1; + HEAP8[$3 + 19 | 0] = 1; + if (!(HEAP8[$3 + 19 | 0] & 1)) { + std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void________unique_ptr_5babi_v160004_5d_28_29($0); + } + __stack_pointer = $3 + 32 | 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______swap_out_circular_buffer_28std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_____29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______annotate_delete_5babi_v160004_5d_28_29_20const($0); + $1 = std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______alloc_5babi_v160004_5d_28_29($0); + std____2__reverse_iterator_b2Vec2____reverse_iterator_5babi_v160004_5d_28b2Vec2__29($2 + 16 | 0, HEAP32[$0 + 4 >> 2]); + std____2__reverse_iterator_b2Vec2____reverse_iterator_5babi_v160004_5d_28b2Vec2__29($2 + 12 | 0, HEAP32[$0 >> 2]); + std____2__reverse_iterator_b2Vec2____reverse_iterator_5babi_v160004_5d_28b2Vec2__29($2 + 8 | 0, HEAP32[HEAP32[$2 + 24 >> 2] + 4 >> 2]); + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__reverse_iterator_b2Vec2___20std____2____uninitialized_allocator_move_if_noexcept_5babi_v160004_5d_std____2__allocator_b2Vec2__2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20b2Vec2_2c_20void__28std____2__allocator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($1, HEAP32[$2 + 16 >> 2], HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + $1 = std____2__reverse_iterator_b2Vec2____base_5babi_v160004_5d_28_29_20const($2 + 20 | 0); + HEAP32[HEAP32[$2 + 24 >> 2] + 4 >> 2] = $1; + std____2__enable_if_is_move_constructible_b2Vec2____value_20___20is_move_assignable_b2Vec2____value_2c_20void___type_20std____2__swap_5babi_v160004_5d_b2Vec2___28b2Vec2___2c_20b2Vec2___29($0, HEAP32[$2 + 24 >> 2] + 4 | 0); + std____2__enable_if_is_move_constructible_b2Vec2____value_20___20is_move_assignable_b2Vec2____value_2c_20void___type_20std____2__swap_5babi_v160004_5d_b2Vec2___28b2Vec2___2c_20b2Vec2___29($0 + 4 | 0, HEAP32[$2 + 24 >> 2] + 8 | 0); + std____2__enable_if_is_move_constructible_b2Vec2____value_20___20is_move_assignable_b2Vec2____value_2c_20void___type_20std____2__swap_5babi_v160004_5d_b2Vec2___28b2Vec2___2c_20b2Vec2___29(std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______end_cap_5babi_v160004_5d_28_29($0), std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______end_cap_5babi_v160004_5d_28_29(HEAP32[$2 + 24 >> 2])); + HEAP32[HEAP32[$2 + 24 >> 2] >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 4 >> 2]; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______annotate_new_5babi_v160004_5d_28unsigned_20long_29_20const($0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____size_5babi_v160004_5d_28_29_20const($0)); + void_20std____2____debug_db_invalidate_all_5babi_v160004_5d_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29($0); + __stack_pointer = $2 + 32 | 0; +} + +function b2ClipSegmentToLine_28b2ClipVertex__2c_20b2ClipVertex_20const__2c_20b2Vec2_20const__2c_20float_2c_20int_29($0, $1, $2, $3, $4) { + var $5 = 0, $6 = 0, $7 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $5 = __stack_pointer + -64 | 0; + __stack_pointer = $5; + HEAP32[$5 + 60 >> 2] = $0; + HEAP32[$5 + 56 >> 2] = $1; + HEAP32[$5 + 52 >> 2] = $2; + HEAPF32[$5 + 48 >> 2] = $3; + HEAP32[$5 + 44 >> 2] = $4; + HEAP32[$5 + 40 >> 2] = 0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = Math_fround(b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$5 + 52 >> 2], HEAP32[$5 + 56 >> 2]) - HEAPF32[$5 + 48 >> 2]), + HEAPF32[wasm2js_i32$0 + 36 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = Math_fround(b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$5 + 52 >> 2], HEAP32[$5 + 56 >> 2] + 12 | 0) - HEAPF32[$5 + 48 >> 2]), + HEAPF32[wasm2js_i32$0 + 32 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 36 >> 2] <= Math_fround(0)) { + $0 = HEAP32[$5 + 56 >> 2]; + $7 = HEAP32[$5 + 60 >> 2]; + $6 = HEAP32[$5 + 40 >> 2]; + HEAP32[$5 + 40 >> 2] = $6 + 1; + $1 = HEAP32[$0 >> 2]; + $2 = HEAP32[$0 + 4 >> 2]; + $4 = $1; + $1 = Math_imul($6, 12) + $7 | 0; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $2; + HEAP32[$1 + 8 >> 2] = HEAP32[$0 + 8 >> 2]; + } + if (HEAPF32[$5 + 32 >> 2] <= Math_fround(0)) { + $0 = HEAP32[$5 + 56 >> 2]; + $7 = HEAP32[$5 + 60 >> 2]; + $6 = HEAP32[$5 + 40 >> 2]; + HEAP32[$5 + 40 >> 2] = $6 + 1; + $2 = HEAP32[$0 + 12 >> 2]; + $1 = HEAP32[$0 + 16 >> 2]; + $4 = $2; + $2 = Math_imul($6, 12) + $7 | 0; + HEAP32[$2 >> 2] = $4; + HEAP32[$2 + 4 >> 2] = $1; + HEAP32[$2 + 8 >> 2] = HEAP32[$0 + 20 >> 2]; + } + if (Math_fround(HEAPF32[$5 + 36 >> 2] * HEAPF32[$5 + 32 >> 2]) < Math_fround(0)) { + HEAPF32[$5 + 28 >> 2] = HEAPF32[$5 + 36 >> 2] / Math_fround(HEAPF32[$5 + 36 >> 2] - HEAPF32[$5 + 32 >> 2]); + $0 = HEAP32[$5 + 56 >> 2]; + $3 = HEAPF32[$5 + 28 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 4 | 0, HEAP32[$5 + 56 >> 2] + 12 | 0, HEAP32[$5 + 56 >> 2]); + operator__28float_2c_20b2Vec2_20const__29($5 + 12 | 0, $3, $5 + 4 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($5 + 20 | 0, $0, $5 + 12 | 0); + $2 = HEAP32[$5 + 24 >> 2]; + $1 = HEAP32[$5 + 20 >> 2]; + $0 = $1; + $1 = HEAP32[$5 + 60 >> 2] + Math_imul(HEAP32[$5 + 40 >> 2], 12) | 0; + HEAP32[$1 >> 2] = $0; + HEAP32[$1 + 4 >> 2] = $2; + HEAP8[(HEAP32[$5 + 60 >> 2] + Math_imul(HEAP32[$5 + 40 >> 2], 12) | 0) + 8 | 0] = HEAP32[$5 + 44 >> 2]; + HEAP8[(HEAP32[$5 + 60 >> 2] + Math_imul(HEAP32[$5 + 40 >> 2], 12) | 0) + 9 | 0] = HEAPU8[HEAP32[$5 + 56 >> 2] + 9 | 0]; + HEAP8[(HEAP32[$5 + 60 >> 2] + Math_imul(HEAP32[$5 + 40 >> 2], 12) | 0) + 10 | 0] = 0; + HEAP8[(HEAP32[$5 + 60 >> 2] + Math_imul(HEAP32[$5 + 40 >> 2], 12) | 0) + 11 | 0] = 1; + HEAP32[$5 + 40 >> 2] = HEAP32[$5 + 40 >> 2] + 1; + if (HEAP32[$5 + 40 >> 2] != 2) { + __assert_fail(12083, 5557, 233, 9400); + wasm2js_trap(); + } + } + __stack_pointer = $5 - -64 | 0; + return HEAP32[$5 + 40 >> 2]; +} + +function b2FindIncidentEdge_28b2ClipVertex__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__2c_20int_2c_20b2PolygonShape_20const__2c_20b2Transform_20const__29($0, $1, $2, $3, $4, $5) { + var $6 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $6 = __stack_pointer - 96 | 0; + __stack_pointer = $6; + HEAP32[$6 + 92 >> 2] = $0; + HEAP32[$6 + 88 >> 2] = $1; + HEAP32[$6 + 84 >> 2] = $2; + HEAP32[$6 + 80 >> 2] = $3; + HEAP32[$6 + 76 >> 2] = $4; + HEAP32[$6 + 72 >> 2] = $5; + HEAP32[$6 + 68 >> 2] = HEAP32[$6 + 88 >> 2] + 84; + HEAP32[$6 + 64 >> 2] = HEAP32[HEAP32[$6 + 76 >> 2] + 148 >> 2]; + HEAP32[$6 + 60 >> 2] = HEAP32[$6 + 76 >> 2] + 20; + HEAP32[$6 + 56 >> 2] = HEAP32[$6 + 76 >> 2] + 84; + if (!(HEAP32[$6 + 80 >> 2] < HEAP32[HEAP32[$6 + 88 >> 2] + 148 >> 2] & HEAP32[$6 + 80 >> 2] >= 0)) { + __assert_fail(1930, 5623, 78, 9793); + wasm2js_trap(); + } + $0 = HEAP32[$6 + 72 >> 2]; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($6 + 40 | 0, HEAP32[$6 + 84 >> 2] + 8 | 0, HEAP32[$6 + 68 >> 2] + (HEAP32[$6 + 80 >> 2] << 3) | 0); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($6 + 48 | 0, $0 + 8 | 0, $6 + 40 | 0); + HEAP32[$6 + 36 >> 2] = 0; + HEAPF32[$6 + 32 >> 2] = 34028234663852886e22; + HEAP32[$6 + 28 >> 2] = 0; + while (1) { + if (HEAP32[$6 + 28 >> 2] < HEAP32[$6 + 64 >> 2]) { + wasm2js_i32$0 = $6, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($6 + 48 | 0, HEAP32[$6 + 56 >> 2] + (HEAP32[$6 + 28 >> 2] << 3) | 0), + HEAPF32[wasm2js_i32$0 + 24 >> 2] = wasm2js_f32$0; + if (HEAPF32[$6 + 24 >> 2] < HEAPF32[$6 + 32 >> 2]) { + HEAPF32[$6 + 32 >> 2] = HEAPF32[$6 + 24 >> 2]; + HEAP32[$6 + 36 >> 2] = HEAP32[$6 + 28 >> 2]; + } + HEAP32[$6 + 28 >> 2] = HEAP32[$6 + 28 >> 2] + 1; + continue; + } + break; + } + HEAP32[$6 + 20 >> 2] = HEAP32[$6 + 36 >> 2]; + if (HEAP32[$6 + 64 >> 2] > (HEAP32[$6 + 20 >> 2] + 1 | 0)) { + $0 = HEAP32[$6 + 20 >> 2] + 1 | 0; + } else { + $0 = 0; + } + HEAP32[$6 + 16 >> 2] = $0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($6 + 8 | 0, HEAP32[$6 + 72 >> 2], HEAP32[$6 + 60 >> 2] + (HEAP32[$6 + 20 >> 2] << 3) | 0); + $0 = HEAP32[$6 + 12 >> 2]; + $1 = HEAP32[$6 + 8 >> 2]; + $2 = $1; + $1 = HEAP32[$6 + 92 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAP8[HEAP32[$6 + 92 >> 2] + 8 | 0] = HEAP32[$6 + 80 >> 2]; + HEAP8[HEAP32[$6 + 92 >> 2] + 9 | 0] = HEAP32[$6 + 20 >> 2]; + HEAP8[HEAP32[$6 + 92 >> 2] + 10 | 0] = 1; + HEAP8[HEAP32[$6 + 92 >> 2] + 11 | 0] = 0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($6, HEAP32[$6 + 72 >> 2], HEAP32[$6 + 60 >> 2] + (HEAP32[$6 + 16 >> 2] << 3) | 0); + $1 = HEAP32[$6 + 4 >> 2]; + $0 = HEAP32[$6 >> 2]; + $2 = $0; + $0 = HEAP32[$6 + 92 >> 2]; + HEAP32[$0 + 12 >> 2] = $2; + HEAP32[$0 + 16 >> 2] = $1; + HEAP8[HEAP32[$6 + 92 >> 2] + 20 | 0] = HEAP32[$6 + 80 >> 2]; + HEAP8[HEAP32[$6 + 92 >> 2] + 21 | 0] = HEAP32[$6 + 16 >> 2]; + HEAP8[HEAP32[$6 + 92 >> 2] + 22 | 0] = 1; + HEAP8[HEAP32[$6 + 92 >> 2] + 23 | 0] = 0; + __stack_pointer = $6 + 96 | 0; +} + +function b2DynamicTree__RemoveLeaf_28int_29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + label$1: { + if (HEAP32[$2 + 24 >> 2] == HEAP32[$0 >> 2]) { + HEAP32[$0 >> 2] = -1; + break label$1; + } + HEAP32[$2 + 20 >> 2] = HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 24 >> 2], 40) | 0) + 20 >> 2]; + HEAP32[$2 + 16 >> 2] = HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 20 >> 2], 40) | 0) + 20 >> 2]; + label$3: { + if (HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 20 >> 2], 40) | 0) + 24 >> 2] == HEAP32[$2 + 24 >> 2]) { + HEAP32[$2 + 12 >> 2] = HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 20 >> 2], 40) | 0) + 28 >> 2]; + break label$3; + } + HEAP32[$2 + 12 >> 2] = HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 20 >> 2], 40) | 0) + 24 >> 2]; + } + if (HEAP32[$2 + 16 >> 2] != -1) { + label$6: { + if (HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 16 >> 2], 40) | 0) + 24 >> 2] == HEAP32[$2 + 20 >> 2]) { + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 16 >> 2], 40) | 0) + 24 >> 2] = HEAP32[$2 + 12 >> 2]; + break label$6; + } + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 16 >> 2], 40) | 0) + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + } + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 12 >> 2], 40) | 0) + 20 >> 2] = HEAP32[$2 + 16 >> 2]; + b2DynamicTree__FreeNode_28int_29($0, HEAP32[$2 + 20 >> 2]); + HEAP32[$2 + 8 >> 2] = HEAP32[$2 + 16 >> 2]; + while (1) { + if (HEAP32[$2 + 8 >> 2] != -1) { + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2DynamicTree__Balance_28int_29($0, HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + HEAP32[$2 + 4 >> 2] = HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 24 >> 2]; + HEAP32[$2 >> 2] = HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 28 >> 2]; + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0, HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 4 >> 2], 40) | 0, HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 >> 2], 40) | 0); + $1 = int_20b2Max_int__28int_2c_20int_29(HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 4 >> 2], 40) | 0) + 32 >> 2], HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 >> 2], 40) | 0) + 32 >> 2]); + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 32 >> 2] = $1 + 1; + HEAP32[$2 + 8 >> 2] = HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 20 >> 2]; + continue; + } + break; + } + break label$1; + } + HEAP32[$0 >> 2] = HEAP32[$2 + 12 >> 2]; + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 12 >> 2], 40) | 0) + 20 >> 2] = -1; + b2DynamicTree__FreeNode_28int_29($0, HEAP32[$2 + 20 >> 2]); + } + __stack_pointer = $2 + 32 | 0; +} + +function b2Simplex__GetWitnessPoints_28b2Vec2__2c_20b2Vec2__29_20const($0, $1, $2) { + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 112 | 0; + __stack_pointer = $3; + HEAP32[$3 + 108 >> 2] = $0; + HEAP32[$3 + 104 >> 2] = $1; + HEAP32[$3 + 100 >> 2] = $2; + label$1: { + label$2: { + label$3: { + label$4: { + label$5: { + label$6: { + $2 = HEAP32[$3 + 108 >> 2]; + switch (HEAP32[$2 + 108 >> 2]) { + case 3: + break label$3; + + case 2: + break label$4; + + case 1: + break label$5; + + case 0: + break label$6; + + default: + break label$2; + } + } + __assert_fail(9147, 6034, 228, 3272); + wasm2js_trap(); + } + $0 = HEAP32[$2 + 4 >> 2]; + $1 = HEAP32[$2 >> 2]; + $4 = $1; + $1 = HEAP32[$3 + 104 >> 2]; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + $1 = HEAP32[$2 + 12 >> 2]; + $0 = HEAP32[$2 + 8 >> 2]; + $2 = $0; + $0 = HEAP32[$3 + 100 >> 2]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + break label$1; + } + operator__28float_2c_20b2Vec2_20const__29($3 + 84 | 0, HEAPF32[$2 + 24 >> 2], $2); + operator__28float_2c_20b2Vec2_20const__29($3 + 76 | 0, HEAPF32[$2 + 60 >> 2], $2 + 36 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 92 | 0, $3 + 84 | 0, $3 + 76 | 0); + $0 = HEAP32[$3 + 96 >> 2]; + $1 = HEAP32[$3 + 92 >> 2]; + $4 = $1; + $1 = HEAP32[$3 + 104 >> 2]; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + operator__28float_2c_20b2Vec2_20const__29($3 + 60 | 0, HEAPF32[$2 + 24 >> 2], $2 + 8 | 0); + operator__28float_2c_20b2Vec2_20const__29($3 + 52 | 0, HEAPF32[$2 + 60 >> 2], $2 + 44 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 68 | 0, $3 + 60 | 0, $3 + 52 | 0); + $1 = HEAP32[$3 + 72 >> 2]; + $0 = HEAP32[$3 + 68 >> 2]; + $2 = $0; + $0 = HEAP32[$3 + 100 >> 2]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + break label$1; + } + operator__28float_2c_20b2Vec2_20const__29($3 + 28 | 0, HEAPF32[$2 + 24 >> 2], $2); + operator__28float_2c_20b2Vec2_20const__29($3 + 20 | 0, HEAPF32[$2 + 60 >> 2], $2 + 36 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 36 | 0, $3 + 28 | 0, $3 + 20 | 0); + operator__28float_2c_20b2Vec2_20const__29($3 + 12 | 0, HEAPF32[$2 + 96 >> 2], $2 + 72 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 44 | 0, $3 + 36 | 0, $3 + 12 | 0); + $0 = HEAP32[$3 + 48 >> 2]; + $1 = HEAP32[$3 + 44 >> 2]; + $2 = $1; + $1 = HEAP32[$3 + 104 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + $1 = HEAP32[$3 + 104 >> 2]; + $0 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + $2 = $0; + $0 = HEAP32[$3 + 100 >> 2]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + break label$1; + } + __assert_fail(9147, 6034, 247, 3272); + wasm2js_trap(); + } + __stack_pointer = $3 + 112 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______swap_out_circular_buffer_28std____2____split_buffer_int_2c_20std____2__allocator_int_____29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + std____2__vector_int_2c_20std____2__allocator_int______annotate_delete_5babi_v160004_5d_28_29_20const($0); + $1 = std____2__vector_int_2c_20std____2__allocator_int______alloc_5babi_v160004_5d_28_29($0); + std____2__reverse_iterator_int____reverse_iterator_5babi_v160004_5d_28int__29($2 + 16 | 0, HEAP32[$0 + 4 >> 2]); + std____2__reverse_iterator_int____reverse_iterator_5babi_v160004_5d_28int__29($2 + 12 | 0, HEAP32[$0 >> 2]); + std____2__reverse_iterator_int____reverse_iterator_5babi_v160004_5d_28int__29($2 + 8 | 0, HEAP32[HEAP32[$2 + 24 >> 2] + 4 >> 2]); + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__reverse_iterator_int___20std____2____uninitialized_allocator_move_if_noexcept_5babi_v160004_5d_std____2__allocator_int__2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20int_2c_20void__28std____2__allocator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($1, HEAP32[$2 + 16 >> 2], HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + $1 = std____2__reverse_iterator_int____base_5babi_v160004_5d_28_29_20const($2 + 20 | 0); + HEAP32[HEAP32[$2 + 24 >> 2] + 4 >> 2] = $1; + std____2__enable_if_is_move_constructible_int____value_20___20is_move_assignable_int____value_2c_20void___type_20std____2__swap_5babi_v160004_5d_int___28int___2c_20int___29($0, HEAP32[$2 + 24 >> 2] + 4 | 0); + std____2__enable_if_is_move_constructible_int____value_20___20is_move_assignable_int____value_2c_20void___type_20std____2__swap_5babi_v160004_5d_int___28int___2c_20int___29($0 + 4 | 0, HEAP32[$2 + 24 >> 2] + 8 | 0); + std____2__enable_if_is_move_constructible_int____value_20___20is_move_assignable_int____value_2c_20void___type_20std____2__swap_5babi_v160004_5d_int___28int___2c_20int___29(std____2__vector_int_2c_20std____2__allocator_int______end_cap_5babi_v160004_5d_28_29($0), std____2____split_buffer_int_2c_20std____2__allocator_int_______end_cap_5babi_v160004_5d_28_29(HEAP32[$2 + 24 >> 2])); + HEAP32[HEAP32[$2 + 24 >> 2] >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 4 >> 2]; + std____2__vector_int_2c_20std____2__allocator_int______annotate_new_5babi_v160004_5d_28unsigned_20long_29_20const($0, std____2__vector_int_2c_20std____2__allocator_int____size_5babi_v160004_5d_28_29_20const($0)); + void_20std____2____debug_db_invalidate_all_5babi_v160004_5d_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int____29($0); + __stack_pointer = $2 + 32 | 0; +} + +function b2World__CreateJoint_28b2JointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + $0 = HEAP32[$2 + 24 >> 2]; + if (b2World__IsLocked_28_29_20const($0) & 1) { + __assert_fail(9133, 6161, 222, 2586); + wasm2js_trap(); + } + label$2: { + if (b2World__IsLocked_28_29_20const($0) & 1) { + HEAP32[$2 + 28 >> 2] = 0; + break label$2; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Joint__Create_28b2JointDef_20const__2c_20b2BlockAllocator__29(HEAP32[$2 + 20 >> 2], $0), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + HEAP32[HEAP32[$2 + 16 >> 2] + 8 >> 2] = 0; + HEAP32[HEAP32[$2 + 16 >> 2] + 12 >> 2] = HEAP32[$0 + 102952 >> 2]; + if (HEAP32[$0 + 102952 >> 2]) { + HEAP32[HEAP32[$0 + 102952 >> 2] + 8 >> 2] = HEAP32[$2 + 16 >> 2]; + } + HEAP32[$0 + 102952 >> 2] = HEAP32[$2 + 16 >> 2]; + HEAP32[$0 + 102960 >> 2] = HEAP32[$0 + 102960 >> 2] + 1; + HEAP32[HEAP32[$2 + 16 >> 2] + 20 >> 2] = HEAP32[$2 + 16 >> 2]; + HEAP32[HEAP32[$2 + 16 >> 2] + 16 >> 2] = HEAP32[HEAP32[$2 + 16 >> 2] + 52 >> 2]; + HEAP32[HEAP32[$2 + 16 >> 2] + 24 >> 2] = 0; + HEAP32[HEAP32[$2 + 16 >> 2] + 28 >> 2] = HEAP32[HEAP32[HEAP32[$2 + 16 >> 2] + 48 >> 2] + 108 >> 2]; + if (HEAP32[HEAP32[HEAP32[$2 + 16 >> 2] + 48 >> 2] + 108 >> 2]) { + HEAP32[HEAP32[HEAP32[HEAP32[$2 + 16 >> 2] + 48 >> 2] + 108 >> 2] + 8 >> 2] = HEAP32[$2 + 16 >> 2] + 16; + } + HEAP32[HEAP32[HEAP32[$2 + 16 >> 2] + 48 >> 2] + 108 >> 2] = HEAP32[$2 + 16 >> 2] + 16; + HEAP32[HEAP32[$2 + 16 >> 2] + 36 >> 2] = HEAP32[$2 + 16 >> 2]; + HEAP32[HEAP32[$2 + 16 >> 2] + 32 >> 2] = HEAP32[HEAP32[$2 + 16 >> 2] + 48 >> 2]; + HEAP32[HEAP32[$2 + 16 >> 2] + 40 >> 2] = 0; + HEAP32[HEAP32[$2 + 16 >> 2] + 44 >> 2] = HEAP32[HEAP32[HEAP32[$2 + 16 >> 2] + 52 >> 2] + 108 >> 2]; + if (HEAP32[HEAP32[HEAP32[$2 + 16 >> 2] + 52 >> 2] + 108 >> 2]) { + HEAP32[HEAP32[HEAP32[HEAP32[$2 + 16 >> 2] + 52 >> 2] + 108 >> 2] + 8 >> 2] = HEAP32[$2 + 16 >> 2] + 32; + } + HEAP32[HEAP32[HEAP32[$2 + 16 >> 2] + 52 >> 2] + 108 >> 2] = HEAP32[$2 + 16 >> 2] + 32; + HEAP32[$2 + 12 >> 2] = HEAP32[HEAP32[$2 + 20 >> 2] + 8 >> 2]; + HEAP32[$2 + 8 >> 2] = HEAP32[HEAP32[$2 + 20 >> 2] + 12 >> 2]; + if (!(HEAP8[HEAP32[$2 + 20 >> 2] + 16 | 0] & 1)) { + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Body__GetContactList_28_29(HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + while (1) { + if (HEAP32[$2 + 4 >> 2]) { + if (HEAP32[HEAP32[$2 + 4 >> 2] >> 2] == HEAP32[$2 + 12 >> 2]) { + b2Contact__FlagForFiltering_28_29(HEAP32[HEAP32[$2 + 4 >> 2] + 4 >> 2]); + } + HEAP32[$2 + 4 >> 2] = HEAP32[HEAP32[$2 + 4 >> 2] + 12 >> 2]; + continue; + } + break; + } + } + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 16 >> 2]; + } + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function ComputeCentroid_28b2Vec2_20const__2c_20int_29($0, $1, $2) { + var $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 128 | 0; + __stack_pointer = $3; + HEAP32[$3 + 124 >> 2] = $1; + HEAP32[$3 + 120 >> 2] = $2; + if (HEAP32[$3 + 120 >> 2] < 3) { + __assert_fail(11995, 5758, 82, 10113); + wasm2js_trap(); + } + b2Vec2__b2Vec2_28float_2c_20float_29($0, Math_fround(0), Math_fround(0)); + HEAPF32[$3 + 116 >> 2] = 0; + $2 = HEAP32[$3 + 124 >> 2]; + $1 = HEAP32[$2 >> 2]; + $2 = HEAP32[$2 + 4 >> 2]; + HEAP32[$3 + 104 >> 2] = $1; + HEAP32[$3 + 108 >> 2] = $2; + HEAPF32[$3 + 100 >> 2] = .3333333432674408; + HEAP32[$3 + 96 >> 2] = 0; + while (1) { + if (HEAP32[$3 + 96 >> 2] < HEAP32[$3 + 120 >> 2]) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 88 | 0, HEAP32[$3 + 124 >> 2], $3 + 104 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 80 | 0, HEAP32[$3 + 124 >> 2] + (HEAP32[$3 + 96 >> 2] << 3) | 0, $3 + 104 | 0); + label$4: { + if (HEAP32[$3 + 120 >> 2] > (HEAP32[$3 + 96 >> 2] + 1 | 0)) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 72 | 0, HEAP32[$3 + 124 >> 2] + (HEAP32[$3 + 96 >> 2] + 1 << 3) | 0, $3 + 104 | 0); + break label$4; + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 72 | 0, HEAP32[$3 + 124 >> 2], $3 + 104 | 0); + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 - -64 | 0, $3 + 80 | 0, $3 + 88 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 56 | 0, $3 + 72 | 0, $3 + 88 | 0); + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 - -64 | 0, $3 + 56 | 0), + HEAPF32[wasm2js_i32$0 + 52 >> 2] = wasm2js_f32$0; + HEAPF32[$3 + 48 >> 2] = HEAPF32[$3 + 52 >> 2] * Math_fround(.5); + HEAPF32[$3 + 116 >> 2] = HEAPF32[$3 + 116 >> 2] + HEAPF32[$3 + 48 >> 2]; + $4 = HEAPF32[$3 + 48 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 24 | 0, $3 + 88 | 0, $3 + 80 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 32 | 0, $3 + 24 | 0, $3 + 72 | 0); + operator__28float_2c_20b2Vec2_20const__29($3 + 40 | 0, Math_fround($4 * Math_fround(.3333333432674408)), $3 + 32 | 0); + b2Vec2__operator___28b2Vec2_20const__29($0, $3 + 40 | 0); + HEAP32[$3 + 96 >> 2] = HEAP32[$3 + 96 >> 2] + 1; + continue; + } + break; + } + if (!(HEAPF32[$3 + 116 >> 2] > Math_fround(1.1920928955078125e-7))) { + __assert_fail(10884, 5758, 113, 10113); + wasm2js_trap(); + } + operator__28float_2c_20b2Vec2_20const__29($3 + 8 | 0, Math_fround(Math_fround(1) / HEAPF32[$3 + 116 >> 2]), $0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 16 | 0, $3 + 8 | 0, $3 + 104 | 0); + $1 = HEAP32[$3 + 20 >> 2]; + $2 = HEAP32[$3 + 16 >> 2]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + __stack_pointer = $3 + 128 | 0; +} + +function __cxxabiv1____pointer_type_info__can_catch_28__cxxabiv1____shim_type_info_20const__2c_20void___29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, $4 = 0, $5 = 0, $6 = 0; + $3 = __stack_pointer + -64 | 0; + __stack_pointer = $3; + label$1: { + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($1, 24288, 0)) { + HEAP32[$2 >> 2] = 0; + $5 = 1; + break label$1; + } + if (__cxxabiv1____pbase_type_info__can_catch_28__cxxabiv1____shim_type_info_20const__2c_20void___29_20const($0, $1, $1)) { + $5 = 1; + $1 = HEAP32[$2 >> 2]; + if (!$1) { + break label$1; + } + HEAP32[$2 >> 2] = HEAP32[$1 >> 2]; + break label$1; + } + label$4: { + if (!$1) { + break label$4; + } + $1 = __dynamic_cast($1, 23924, 24068, 0); + if (!$1) { + break label$1; + } + $4 = HEAP32[$2 >> 2]; + if ($4) { + HEAP32[$2 >> 2] = HEAP32[$4 >> 2]; + } + $4 = HEAP32[$1 + 8 >> 2]; + $6 = HEAP32[$0 + 8 >> 2]; + if ($4 & ($6 ^ -1) & 7 | ($4 ^ -1) & $6 & 96) { + break label$1; + } + $5 = 1; + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29(HEAP32[$0 + 12 >> 2], HEAP32[$1 + 12 >> 2], 0)) { + break label$1; + } + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29(HEAP32[$0 + 12 >> 2], 24276, 0)) { + $1 = HEAP32[$1 + 12 >> 2]; + if (!$1) { + break label$1; + } + $5 = !__dynamic_cast($1, 23924, 24120, 0); + break label$1; + } + $4 = HEAP32[$0 + 12 >> 2]; + if (!$4) { + break label$4; + } + $5 = 0; + $6 = __dynamic_cast($4, 23924, 24068, 0); + if ($6) { + if (!(HEAP8[$0 + 8 | 0] & 1)) { + break label$1; + } + $5 = __cxxabiv1____pointer_type_info__can_catch_nested_28__cxxabiv1____shim_type_info_20const__29_20const($6, HEAP32[$1 + 12 >> 2]); + break label$1; + } + $6 = __dynamic_cast($4, 23924, 24180, 0); + if ($6) { + if (!(HEAP8[$0 + 8 | 0] & 1)) { + break label$1; + } + $5 = __cxxabiv1____pointer_to_member_type_info__can_catch_nested_28__cxxabiv1____shim_type_info_20const__29_20const($6, HEAP32[$1 + 12 >> 2]); + break label$1; + } + $0 = __dynamic_cast($4, 23924, 23972, 0); + if (!$0) { + break label$1; + } + $1 = HEAP32[$1 + 12 >> 2]; + if (!$1) { + break label$1; + } + $1 = __dynamic_cast($1, 23924, 23972, 0); + if (!$1) { + break label$1; + } + __memset($3 + 12 | 0, 0, 52); + HEAP32[$3 + 56 >> 2] = 1; + HEAP32[$3 + 20 >> 2] = -1; + HEAP32[$3 + 16 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 28 >> 2]]($1, $3 + 8 | 0, HEAP32[$2 >> 2], 1); + $1 = HEAP32[$3 + 32 >> 2]; + if (!(!HEAP32[$2 >> 2] | ($1 | 0) != 1)) { + HEAP32[$2 >> 2] = HEAP32[$3 + 24 >> 2]; + } + $5 = ($1 | 0) == 1; + break label$1; + } + $5 = 0; + } + __stack_pointer = $3 - -64 | 0; + return $5 | 0; +} + +function std____2____tree_node_base_void_____20std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______find_equal_b2Fixture___28std____2____tree_end_node_std____2____tree_node_base_void_______2c_20b2Fixture__20const__29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 24 >> 2] = $0; + HEAP32[$3 + 20 >> 2] = $1; + HEAP32[$3 + 16 >> 2] = $2; + $0 = HEAP32[$3 + 24 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______root_5babi_v160004_5d_28_29_20const($0), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______root_ptr_28_29_20const($0), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + label$1: { + if (HEAP32[$3 + 12 >> 2]) { + while (1) { + if (std____2__less_b2Fixture____operator_28_29_5babi_v160004_5d_28b2Fixture__20const__2c_20b2Fixture__20const__29_20const(std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____value_comp_5babi_v160004_5d_28_29($0), HEAP32[$3 + 16 >> 2], HEAP32[$3 + 12 >> 2] + 16 | 0) & 1) { + if (HEAP32[HEAP32[$3 + 12 >> 2] >> 2]) { + HEAP32[$3 + 8 >> 2] = HEAP32[$3 + 12 >> 2]; + HEAP32[$3 + 12 >> 2] = HEAP32[HEAP32[$3 + 12 >> 2] >> 2]; + continue; + } + HEAP32[HEAP32[$3 + 20 >> 2] >> 2] = HEAP32[$3 + 12 >> 2]; + HEAP32[$3 + 28 >> 2] = HEAP32[HEAP32[$3 + 20 >> 2] >> 2]; + break label$1; + } + label$6: { + if (std____2__less_b2Fixture____operator_28_29_5babi_v160004_5d_28b2Fixture__20const__2c_20b2Fixture__20const__29_20const(std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____value_comp_5babi_v160004_5d_28_29($0), HEAP32[$3 + 12 >> 2] + 16 | 0, HEAP32[$3 + 16 >> 2]) & 1) { + if (HEAP32[HEAP32[$3 + 12 >> 2] + 4 >> 2]) { + HEAP32[$3 + 8 >> 2] = HEAP32[$3 + 12 >> 2] + 4; + HEAP32[$3 + 12 >> 2] = HEAP32[HEAP32[$3 + 12 >> 2] + 4 >> 2]; + break label$6; + } + HEAP32[HEAP32[$3 + 20 >> 2] >> 2] = HEAP32[$3 + 12 >> 2]; + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 12 >> 2] + 4; + break label$1; + } + HEAP32[HEAP32[$3 + 20 >> 2] >> 2] = HEAP32[$3 + 12 >> 2]; + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 8 >> 2]; + break label$1; + } + continue; + } + } + $0 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______end_node_5babi_v160004_5d_28_29($0); + HEAP32[HEAP32[$3 + 20 >> 2] >> 2] = $0; + HEAP32[$3 + 28 >> 2] = HEAP32[HEAP32[$3 + 20 >> 2] >> 2]; + } + __stack_pointer = $3 + 32 | 0; + return HEAP32[$3 + 28 >> 2]; +} + +function b2MouseJoint__SolveVelocityConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 112 | 0; + __stack_pointer = $2; + HEAP32[$2 + 108 >> 2] = $0; + HEAP32[$2 + 104 >> 2] = $1; + $1 = HEAP32[$2 + 108 >> 2]; + $0 = HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 116 >> 2], 12) | 0; + $3 = HEAP32[$0 >> 2]; + $0 = HEAP32[$0 + 4 >> 2]; + HEAP32[$2 + 96 >> 2] = $3; + HEAP32[$2 + 100 >> 2] = $0; + HEAPF32[$2 + 92 >> 2] = HEAPF32[(HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 116 >> 2], 12) | 0) + 8 >> 2]; + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 76 | 0, HEAPF32[$2 + 92 >> 2], $1 + 120 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 84 | 0, $2 + 96 | 0, $2 + 76 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 40 | 0, $2 + 84 | 0, $1 + 160 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 32 | 0, HEAPF32[$1 + 108 >> 2], $1 + 96 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 48 | 0, $2 + 40 | 0, $2 + 32 | 0); + b2Vec2__operator__28_29_20const($2 + 56 | 0, $2 + 48 | 0); + b2Mul_28b2Mat22_20const__2c_20b2Vec2_20const__29($2 - -64 | 0, $1 + 144 | 0, $2 + 56 | 0); + $3 = HEAP32[$1 + 100 >> 2]; + $0 = HEAP32[$1 + 96 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 28 >> 2] = $3; + b2Vec2__operator___28b2Vec2_20const__29($1 + 96 | 0, $2 - -64 | 0); + HEAPF32[$2 + 20 >> 2] = HEAPF32[HEAP32[$2 + 104 >> 2] >> 2] * HEAPF32[$1 + 104 >> 2]; + if (b2Vec2__LengthSquared_28_29_20const($1 + 96 | 0) > Math_fround(HEAPF32[$2 + 20 >> 2] * HEAPF32[$2 + 20 >> 2])) { + b2Vec2__operator___28float_29($1 + 96 | 0, Math_fround(HEAPF32[$2 + 20 >> 2] / b2Vec2__Length_28_29_20const($1 + 96 | 0))); + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 12 | 0, $1 + 96 | 0, $2 + 24 | 0); + $0 = HEAP32[$2 + 16 >> 2]; + $3 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 64 >> 2] = $3; + HEAP32[$2 + 68 >> 2] = $0; + operator__28float_2c_20b2Vec2_20const__29($2 + 4 | 0, HEAPF32[$1 + 136 >> 2], $2 - -64 | 0); + b2Vec2__operator___28b2Vec2_20const__29($2 + 96 | 0, $2 + 4 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(Math_fround(HEAPF32[$1 + 140 >> 2] * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 120 | 0, $2 - -64 | 0)) + HEAPF32[$2 + 92 >> 2]), + HEAPF32[wasm2js_i32$0 + 92 >> 2] = wasm2js_f32$0; + $3 = HEAP32[$2 + 100 >> 2]; + $0 = HEAP32[$2 + 96 >> 2]; + $4 = $0; + $0 = HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 116 >> 2], 12) | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $3; + HEAPF32[(HEAP32[HEAP32[$2 + 104 >> 2] + 28 >> 2] + Math_imul(HEAP32[$1 + 116 >> 2], 12) | 0) + 8 >> 2] = HEAPF32[$2 + 92 >> 2]; + __stack_pointer = $2 + 112 | 0; +} + +function b2CircleShape__RayCast_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0, $6 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $5 = __stack_pointer - 96 | 0; + __stack_pointer = $5; + HEAP32[$5 + 88 >> 2] = $0; + HEAP32[$5 + 84 >> 2] = $1; + HEAP32[$5 + 80 >> 2] = $2; + HEAP32[$5 + 76 >> 2] = $3; + HEAP32[$5 + 72 >> 2] = $4; + $1 = HEAP32[$5 + 76 >> 2]; + $0 = HEAP32[$5 + 88 >> 2]; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($5 + 56 | 0, HEAP32[$5 + 76 >> 2] + 8 | 0, $0 + 12 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($5 - -64 | 0, $1, $5 + 56 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 48 | 0, HEAP32[$5 + 80 >> 2], $5 - -64 | 0); + $1 = $5 + 48 | 0; + $6 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1, $1); + HEAPF32[$5 + 44 >> 2] = Math_fround(Math_fround(-HEAPF32[$0 + 8 >> 2]) * HEAPF32[$0 + 8 >> 2]) + $6; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 36 | 0, HEAP32[$5 + 80 >> 2] + 8 | 0, HEAP32[$5 + 80 >> 2]); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 48 | 0, $5 + 36 | 0), + HEAPF32[wasm2js_i32$0 + 32 >> 2] = wasm2js_f32$0; + $0 = $5 + 36 | 0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $0), + HEAPF32[wasm2js_i32$0 + 28 >> 2] = wasm2js_f32$0; + HEAPF32[$5 + 24 >> 2] = Math_fround(HEAPF32[$5 + 32 >> 2] * HEAPF32[$5 + 32 >> 2]) - Math_fround(HEAPF32[$5 + 28 >> 2] * HEAPF32[$5 + 44 >> 2]); + label$1: { + if (HEAPF32[$5 + 24 >> 2] < Math_fround(0) | HEAPF32[$5 + 28 >> 2] < Math_fround(1.1920928955078125e-7)) { + HEAP8[$5 + 95 | 0] = 0; + break label$1; + } + HEAPF32[$5 + 20 >> 2] = -Math_fround(HEAPF32[$5 + 32 >> 2] + Math_fround(Math_sqrt(HEAPF32[$5 + 24 >> 2]))); + if (!(!(HEAPF32[$5 + 20 >> 2] >= Math_fround(0)) | !(HEAPF32[$5 + 20 >> 2] <= Math_fround(HEAPF32[HEAP32[$5 + 80 >> 2] + 16 >> 2] * HEAPF32[$5 + 28 >> 2])))) { + HEAPF32[$5 + 20 >> 2] = HEAPF32[$5 + 20 >> 2] / HEAPF32[$5 + 28 >> 2]; + HEAPF32[HEAP32[$5 + 84 >> 2] + 8 >> 2] = HEAPF32[$5 + 20 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($5 + 4 | 0, HEAPF32[$5 + 20 >> 2], $5 + 36 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($5 + 12 | 0, $5 + 48 | 0, $5 + 4 | 0); + $2 = HEAP32[$5 + 16 >> 2]; + $0 = HEAP32[$5 + 12 >> 2]; + $1 = $0; + $0 = HEAP32[$5 + 84 >> 2]; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + b2Vec2__Normalize_28_29(HEAP32[$5 + 84 >> 2]); + HEAP8[$5 + 95 | 0] = 1; + break label$1; + } + HEAP8[$5 + 95 | 0] = 0; + } + __stack_pointer = $5 + 96 | 0; + return HEAP8[$5 + 95 | 0] & 1; +} + +function b2Body__DestroyFixture_28b2Fixture__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 48 | 0; + __stack_pointer = $2; + HEAP32[$2 + 44 >> 2] = $0; + HEAP32[$2 + 40 >> 2] = $1; + $0 = HEAP32[$2 + 44 >> 2]; + label$1: { + if (!HEAP32[$2 + 40 >> 2]) { + break label$1; + } + if (b2World__IsLocked_28_29_20const(HEAP32[$0 + 88 >> 2]) & 1) { + __assert_fail(9124, 4100, 224, 9153); + wasm2js_trap(); + } + if (b2World__IsLocked_28_29_20const(HEAP32[$0 + 88 >> 2]) & 1) { + break label$1; + } + if (HEAP32[HEAP32[$2 + 40 >> 2] + 8 >> 2] != ($0 | 0)) { + __assert_fail(3457, 4100, 230, 9153); + wasm2js_trap(); + } + if (HEAP32[$0 + 104 >> 2] <= 0) { + __assert_fail(12272, 4100, 233, 9153); + wasm2js_trap(); + } + HEAP32[$2 + 36 >> 2] = $0 + 100; + HEAP8[$2 + 35 | 0] = 0; + while (1) { + if (HEAP32[HEAP32[$2 + 36 >> 2] >> 2]) { + if (HEAP32[HEAP32[$2 + 36 >> 2] >> 2] == HEAP32[$2 + 40 >> 2]) { + HEAP32[HEAP32[$2 + 36 >> 2] >> 2] = HEAP32[HEAP32[$2 + 40 >> 2] + 4 >> 2]; + HEAP8[$2 + 35 | 0] = 1; + } else { + HEAP32[$2 + 36 >> 2] = HEAP32[HEAP32[$2 + 36 >> 2] >> 2] + 4; + continue; + } + } + break; + } + if (!(HEAP8[$2 + 35 | 0] & 1)) { + __assert_fail(10021, 4100, 249, 9153); + wasm2js_trap(); + } + HEAP32[$2 + 28 >> 2] = HEAP32[$0 + 112 >> 2]; + while (1) { + if (HEAP32[$2 + 28 >> 2]) { + HEAP32[$2 + 24 >> 2] = HEAP32[HEAP32[$2 + 28 >> 2] + 4 >> 2]; + HEAP32[$2 + 28 >> 2] = HEAP32[HEAP32[$2 + 28 >> 2] + 12 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Contact__GetFixtureA_28_29(HEAP32[$2 + 24 >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Contact__GetFixtureB_28_29(HEAP32[$2 + 24 >> 2]), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + if (!(HEAP32[$2 + 40 >> 2] != HEAP32[$2 + 20 >> 2] & HEAP32[$2 + 40 >> 2] != HEAP32[$2 + 16 >> 2])) { + b2ContactManager__Destroy_28b2Contact__29(HEAP32[$0 + 88 >> 2] + 102868 | 0, HEAP32[$2 + 24 >> 2]); + } + continue; + } + break; + } + HEAP32[$2 + 12 >> 2] = HEAP32[$0 + 88 >> 2]; + if (HEAPU16[$0 + 4 >> 1] & 32) { + HEAP32[$2 + 8 >> 2] = HEAP32[$0 + 88 >> 2] + 102868; + b2Fixture__DestroyProxies_28b2BroadPhase__29(HEAP32[$2 + 40 >> 2], HEAP32[$2 + 8 >> 2]); + } + HEAP32[HEAP32[$2 + 40 >> 2] + 8 >> 2] = 0; + HEAP32[HEAP32[$2 + 40 >> 2] + 4 >> 2] = 0; + b2Fixture__Destroy_28b2BlockAllocator__29(HEAP32[$2 + 40 >> 2], HEAP32[$2 + 12 >> 2]); + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 40 >> 2], 44); + HEAP32[$0 + 104 >> 2] = HEAP32[$0 + 104 >> 2] - 1; + b2Body__ResetMassData_28_29($0); + } + __stack_pointer = $2 + 48 | 0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______init_28char_20const__2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + if (std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____max_size_5babi_v160004_5d_28_29_20const($0) >>> 0 >= $2 >>> 0) { + label$2: { + if (std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______fits_in_sso_5babi_v160004_5d_28unsigned_20long_29($2)) { + std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______set_short_size_5babi_v160004_5d_28unsigned_20long_29($0, $2); + $4 = std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______get_short_pointer_5babi_v160004_5d_28_29($0); + break label$2; + } + std____2____allocation_result_std____2__allocator_traits_std____2__allocator_char____pointer__20std____2____allocate_at_least_5babi_v160004_5d_std____2__allocator_char___28std____2__allocator_char___2c_20unsigned_20long_29($3 + 8 | 0, std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______alloc_5babi_v160004_5d_28_29($0), std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______recommend_5babi_v160004_5d_28unsigned_20long_29($2) + 1 | 0); + $4 = HEAP32[$3 + 8 >> 2]; + std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______begin_lifetime_5babi_v160004_5d_28char__2c_20unsigned_20long_29($4, HEAP32[$3 + 12 >> 2]); + std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______set_long_pointer_5babi_v160004_5d_28char__29($0, $4); + std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______set_long_cap_5babi_v160004_5d_28unsigned_20long_29($0, HEAP32[$3 + 12 >> 2]); + std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______set_long_size_5babi_v160004_5d_28unsigned_20long_29($0, $2); + } + std____2__char_traits_char___copy_28char__2c_20char_20const__2c_20unsigned_20long_29(char__20std____2____to_address_5babi_v160004_5d_char__28char__29($4), $1, $2); + HEAP8[$3 + 7 | 0] = 0; + std____2__char_traits_char___assign_28char__2c_20char_20const__29($2 + $4 | 0, $3 + 7 | 0); + __stack_pointer = $3 + 16 | 0; + return; + } + std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______throw_length_error_5babi_v160004_5d_28_29_20const($0); + wasm2js_trap(); +} + +function b2ContactManager__Destroy_28b2Contact__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Contact__GetFixtureA_28_29(HEAP32[$2 + 24 >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Contact__GetFixtureB_28_29(HEAP32[$2 + 24 >> 2]), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$2 + 20 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$2 + 16 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + label$1: { + if (!HEAP32[$0 + 72 >> 2]) { + break label$1; + } + if (!(b2Contact__IsTouching_28_29_20const(HEAP32[$2 + 24 >> 2]) & 1)) { + break label$1; + } + $1 = HEAP32[$0 + 72 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 12 >> 2]]($1, HEAP32[$2 + 24 >> 2]); + } + if (HEAP32[HEAP32[$2 + 24 >> 2] + 8 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 8 >> 2] + 12 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 12 >> 2]; + } + if (HEAP32[HEAP32[$2 + 24 >> 2] + 12 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 12 >> 2] + 8 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 8 >> 2]; + } + if (HEAP32[$2 + 24 >> 2] == HEAP32[$0 + 60 >> 2]) { + HEAP32[$0 + 60 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 12 >> 2]; + } + if (HEAP32[HEAP32[$2 + 24 >> 2] + 24 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 24 >> 2] + 12 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 28 >> 2]; + } + if (HEAP32[HEAP32[$2 + 24 >> 2] + 28 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 28 >> 2] + 8 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 24 >> 2]; + } + if (HEAP32[HEAP32[$2 + 12 >> 2] + 112 >> 2] == (HEAP32[$2 + 24 >> 2] + 16 | 0)) { + HEAP32[HEAP32[$2 + 12 >> 2] + 112 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 28 >> 2]; + } + if (HEAP32[HEAP32[$2 + 24 >> 2] + 40 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 40 >> 2] + 12 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 44 >> 2]; + } + if (HEAP32[HEAP32[$2 + 24 >> 2] + 44 >> 2]) { + HEAP32[HEAP32[HEAP32[$2 + 24 >> 2] + 44 >> 2] + 8 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 40 >> 2]; + } + if (HEAP32[HEAP32[$2 + 8 >> 2] + 112 >> 2] == (HEAP32[$2 + 24 >> 2] + 32 | 0)) { + HEAP32[HEAP32[$2 + 8 >> 2] + 112 >> 2] = HEAP32[HEAP32[$2 + 24 >> 2] + 44 >> 2]; + } + b2Contact__Destroy_28b2Contact__2c_20b2BlockAllocator__29(HEAP32[$2 + 24 >> 2], HEAP32[$0 + 76 >> 2]); + HEAP32[$0 + 64 >> 2] = HEAP32[$0 + 64 >> 2] - 1; + __stack_pointer = $2 + 32 | 0; +} + +function b2PrismaticJoint__GetJointSpeed_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0, $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer - 160 | 0; + __stack_pointer = $1; + HEAP32[$1 + 156 >> 2] = $0; + $0 = HEAP32[$1 + 156 >> 2]; + HEAP32[$1 + 152 >> 2] = HEAP32[$0 + 48 >> 2]; + HEAP32[$1 + 148 >> 2] = HEAP32[$0 + 52 >> 2]; + $2 = HEAP32[$1 + 152 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 132 | 0, $0 + 68 | 0, HEAP32[$1 + 152 >> 2] + 28 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($1 + 140 | 0, $2 + 20 | 0, $1 + 132 | 0); + $2 = HEAP32[$1 + 148 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 116 | 0, $0 + 76 | 0, HEAP32[$1 + 148 >> 2] + 28 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($1 + 124 | 0, $2 + 20 | 0, $1 + 116 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 108 | 0, HEAP32[$1 + 152 >> 2] + 44 | 0, $1 + 140 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 100 | 0, HEAP32[$1 + 148 >> 2] + 44 | 0, $1 + 124 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 92 | 0, $1 + 100 | 0, $1 + 108 | 0); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($1 + 84 | 0, HEAP32[$1 + 152 >> 2] + 20 | 0, $0 + 84 | 0); + $2 = HEAP32[$1 + 152 >> 2]; + $3 = HEAP32[$2 + 64 >> 2]; + $0 = HEAP32[$2 + 68 >> 2]; + HEAP32[$1 + 72 >> 2] = $3; + HEAP32[$1 + 76 >> 2] = $0; + $2 = HEAP32[$1 + 148 >> 2]; + $0 = HEAP32[$2 + 64 >> 2]; + $3 = HEAP32[$2 + 68 >> 2]; + HEAP32[$1 + 64 >> 2] = $0; + HEAP32[$1 + 68 >> 2] = $3; + HEAPF32[$1 + 60 >> 2] = HEAPF32[HEAP32[$1 + 152 >> 2] + 72 >> 2]; + HEAPF32[$1 + 56 >> 2] = HEAPF32[HEAP32[$1 + 148 >> 2] + 72 >> 2]; + b2Cross_28float_2c_20b2Vec2_20const__29($1 + 44 | 0, HEAPF32[$1 + 60 >> 2], $1 + 84 | 0); + $4 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 92 | 0, $1 + 44 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($1 + 12 | 0, HEAPF32[$1 + 56 >> 2], $1 + 124 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($1 + 20 | 0, $1 - -64 | 0, $1 + 12 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 28 | 0, $1 + 20 | 0, $1 + 72 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($1 + 4 | 0, HEAPF32[$1 + 60 >> 2], $1 + 140 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 36 | 0, $1 + 28 | 0, $1 + 4 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = Math_fround($4 + b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 84 | 0, $1 + 36 | 0)), + HEAPF32[wasm2js_i32$0 + 52 >> 2] = wasm2js_f32$0; + __stack_pointer = $1 + 160 | 0; + return Math_fround(HEAPF32[$1 + 52 >> 2]); +} + +function b2World__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = 0, $3 = Math_fround(0); + $1 = __stack_pointer + -64 | 0; + __stack_pointer = $1; + HEAP32[$1 + 60 >> 2] = $0; + $0 = HEAP32[$1 + 60 >> 2]; + if (!(HEAP8[$0 + 102989 | 0] & 1)) { + b2OpenDump_28char_20const__29(6969); + $3 = HEAPF32[$0 + 102964 >> 2]; + HEAPF64[$1 + 8 >> 3] = HEAPF32[$0 + 102968 >> 2]; + HEAPF64[$1 >> 3] = $3; + b2Dump_28char_20const__2c_20____29(14490, $1); + b2Dump_28char_20const__2c_20____29(14513, 0); + HEAP32[$1 + 16 >> 2] = HEAP32[$0 + 102956 >> 2]; + b2Dump_28char_20const__2c_20____29(15158, $1 + 16 | 0); + HEAP32[$1 + 32 >> 2] = HEAP32[$0 + 102960 >> 2]; + b2Dump_28char_20const__2c_20____29(15218, $1 + 32 | 0); + HEAP32[$1 + 56 >> 2] = 0; + HEAP32[$1 + 52 >> 2] = HEAP32[$0 + 102948 >> 2]; + while (1) { + if (HEAP32[$1 + 52 >> 2]) { + HEAP32[HEAP32[$1 + 52 >> 2] + 8 >> 2] = HEAP32[$1 + 56 >> 2]; + b2Body__Dump_28_29(HEAP32[$1 + 52 >> 2]); + HEAP32[$1 + 56 >> 2] = HEAP32[$1 + 56 >> 2] + 1; + HEAP32[$1 + 52 >> 2] = HEAP32[HEAP32[$1 + 52 >> 2] + 96 >> 2]; + continue; + } + break; + } + HEAP32[$1 + 56 >> 2] = 0; + HEAP32[$1 + 48 >> 2] = HEAP32[$0 + 102952 >> 2]; + while (1) { + if (HEAP32[$1 + 48 >> 2]) { + HEAP32[HEAP32[$1 + 48 >> 2] + 56 >> 2] = HEAP32[$1 + 56 >> 2]; + HEAP32[$1 + 56 >> 2] = HEAP32[$1 + 56 >> 2] + 1; + HEAP32[$1 + 48 >> 2] = HEAP32[HEAP32[$1 + 48 >> 2] + 12 >> 2]; + continue; + } + break; + } + HEAP32[$1 + 44 >> 2] = HEAP32[$0 + 102952 >> 2]; + while (1) { + if (HEAP32[$1 + 44 >> 2]) { + if (HEAP32[HEAP32[$1 + 44 >> 2] + 4 >> 2] != 6) { + b2Dump_28char_20const__2c_20____29(12579, 0); + $2 = HEAP32[$1 + 44 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$2 >> 2] + 16 >> 2]]($2); + b2Dump_28char_20const__2c_20____29(12574, 0); + } + HEAP32[$1 + 44 >> 2] = HEAP32[HEAP32[$1 + 44 >> 2] + 12 >> 2]; + continue; + } + break; + } + HEAP32[$1 + 40 >> 2] = HEAP32[$0 + 102952 >> 2]; + while (1) { + if (HEAP32[$1 + 40 >> 2]) { + if (HEAP32[HEAP32[$1 + 40 >> 2] + 4 >> 2] == 6) { + b2Dump_28char_20const__2c_20____29(12579, 0); + $0 = HEAP32[$1 + 40 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 16 >> 2]]($0); + b2Dump_28char_20const__2c_20____29(12574, 0); + } + HEAP32[$1 + 40 >> 2] = HEAP32[HEAP32[$1 + 40 >> 2] + 12 >> 2]; + continue; + } + break; + } + b2Dump_28char_20const__2c_20____29(13875, 0); + b2Dump_28char_20const__2c_20____29(13892, 0); + b2Dump_28char_20const__2c_20____29(12582, 0); + b2Dump_28char_20const__2c_20____29(12601, 0); + b2CloseDump_28_29(); + } + __stack_pointer = $1 - -64 | 0; +} + +function std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____find_b2Fixture___28b2Fixture__20const__29($0, $1) { + var $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + $0 = HEAP32[$2 + 24 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______lower_bound_b2Fixture___28b2Fixture__20const__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_end_node_std____2____tree_node_base_void______29($0, HEAP32[$2 + 20 >> 2], std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______root_5babi_v160004_5d_28_29_20const($0), std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______end_node_5babi_v160004_5d_28_29($0)), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____end_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + if (std____2__operator___5babi_v160004_5d_28std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__2c_20std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__29_1($2 + 16 | 0, $2 + 12 | 0) & 1) { + $3 = std____2__less_b2Fixture____operator_28_29_5babi_v160004_5d_28b2Fixture__20const__2c_20b2Fixture__20const__29_20const(std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____value_comp_5babi_v160004_5d_28_29($0), HEAP32[$2 + 20 >> 2], std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long___operator__5babi_v160004_5d_28_29_20const($2 + 16 | 0)) ^ -1; + } + label$2: { + if ($3 & 1) { + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 16 >> 2]; + break label$2; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____end_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + } + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function emscripten__internal__WireTypePack_unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____WireTypePack_28unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float__29($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 80 | 0; + __stack_pointer = $5; + HEAP32[$5 + 20 >> 2] = $0; + HEAP32[$5 + 16 >> 2] = $1; + HEAP32[$5 + 12 >> 2] = $2; + HEAP32[$5 + 8 >> 2] = $3; + HEAP32[$5 + 4 >> 2] = $4; + $0 = HEAP32[$5 + 20 >> 2]; + wasm2js_i32$0 = $5, wasm2js_i32$1 = std____2__array_emscripten__internal__GenericWireType_2c_204ul___data_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$5 + 16 >> 2]; + $2 = HEAP32[$5 + 12 >> 2]; + $3 = HEAP32[$5 + 8 >> 2]; + $4 = HEAP32[$5 + 4 >> 2]; + HEAP32[$5 + 40 >> 2] = $5; + HEAP32[$5 + 36 >> 2] = $1; + HEAP32[$5 + 32 >> 2] = $2; + HEAP32[$5 + 28 >> 2] = $3; + HEAP32[$5 + 24 >> 2] = $4; + void_20emscripten__internal__writeGenericWireType_unsigned_20int__28emscripten__internal__GenericWireType___2c_20unsigned_20int_29(HEAP32[$5 + 40 >> 2], emscripten__internal__BindingType_unsigned_20int_2c_20void___toWireType_28unsigned_20int_20const__29(HEAP32[$5 + 36 >> 2])); + $1 = HEAP32[$5 + 32 >> 2]; + $2 = HEAP32[$5 + 28 >> 2]; + $3 = HEAP32[$5 + 24 >> 2]; + HEAP32[$5 + 56 >> 2] = HEAP32[$5 + 40 >> 2]; + HEAP32[$5 + 52 >> 2] = $1; + HEAP32[$5 + 48 >> 2] = $2; + HEAP32[$5 + 44 >> 2] = $3; + void_20emscripten__internal__writeGenericWireType_b2Vec2__28emscripten__internal__GenericWireType___2c_20b2Vec2__29(HEAP32[$5 + 56 >> 2], emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$5 + 52 >> 2])); + $1 = HEAP32[$5 + 48 >> 2]; + $2 = HEAP32[$5 + 44 >> 2]; + HEAP32[$5 + 68 >> 2] = HEAP32[$5 + 56 >> 2]; + HEAP32[$5 + 64 >> 2] = $1; + HEAP32[$5 + 60 >> 2] = $2; + void_20emscripten__internal__writeGenericWireType_b2Vec2__28emscripten__internal__GenericWireType___2c_20b2Vec2__29(HEAP32[$5 + 68 >> 2], emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$5 + 64 >> 2])); + $1 = HEAP32[$5 + 60 >> 2]; + HEAP32[$5 + 76 >> 2] = HEAP32[$5 + 68 >> 2]; + HEAP32[$5 + 72 >> 2] = $1; + emscripten__internal__writeGenericWireType_28emscripten__internal__GenericWireType___2c_20float_29(HEAP32[$5 + 76 >> 2], emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$5 + 72 >> 2])); + emscripten__internal__writeGenericWireTypes_28emscripten__internal__GenericWireType___29(HEAP32[$5 + 76 >> 2]); + __stack_pointer = $5 + 80 | 0; + return $0; +} + +function __memcpy($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0; + if ($2 >>> 0 >= 512) { + emscripten_memcpy_big($0 | 0, $1 | 0, $2 | 0); + return $0; + } + $4 = $0 + $2 | 0; + label$2: { + if (!(($0 ^ $1) & 3)) { + label$4: { + if (!($0 & 3)) { + $2 = $0; + break label$4; + } + if (!$2) { + $2 = $0; + break label$4; + } + $2 = $0; + while (1) { + HEAP8[$2 | 0] = HEAPU8[$1 | 0]; + $1 = $1 + 1 | 0; + $2 = $2 + 1 | 0; + if (!($2 & 3)) { + break label$4; + } + if ($2 >>> 0 < $4 >>> 0) { + continue; + } + break; + } + } + $3 = $4 & -4; + label$8: { + if ($3 >>> 0 < 64) { + break label$8; + } + $5 = $3 + -64 | 0; + if ($5 >>> 0 < $2 >>> 0) { + break label$8; + } + while (1) { + HEAP32[$2 >> 2] = HEAP32[$1 >> 2]; + HEAP32[$2 + 4 >> 2] = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 8 >> 2] = HEAP32[$1 + 8 >> 2]; + HEAP32[$2 + 12 >> 2] = HEAP32[$1 + 12 >> 2]; + HEAP32[$2 + 16 >> 2] = HEAP32[$1 + 16 >> 2]; + HEAP32[$2 + 20 >> 2] = HEAP32[$1 + 20 >> 2]; + HEAP32[$2 + 24 >> 2] = HEAP32[$1 + 24 >> 2]; + HEAP32[$2 + 28 >> 2] = HEAP32[$1 + 28 >> 2]; + HEAP32[$2 + 32 >> 2] = HEAP32[$1 + 32 >> 2]; + HEAP32[$2 + 36 >> 2] = HEAP32[$1 + 36 >> 2]; + HEAP32[$2 + 40 >> 2] = HEAP32[$1 + 40 >> 2]; + HEAP32[$2 + 44 >> 2] = HEAP32[$1 + 44 >> 2]; + HEAP32[$2 + 48 >> 2] = HEAP32[$1 + 48 >> 2]; + HEAP32[$2 + 52 >> 2] = HEAP32[$1 + 52 >> 2]; + HEAP32[$2 + 56 >> 2] = HEAP32[$1 + 56 >> 2]; + HEAP32[$2 + 60 >> 2] = HEAP32[$1 + 60 >> 2]; + $1 = $1 - -64 | 0; + $2 = $2 - -64 | 0; + if ($5 >>> 0 >= $2 >>> 0) { + continue; + } + break; + } + } + if ($2 >>> 0 >= $3 >>> 0) { + break label$2; + } + while (1) { + HEAP32[$2 >> 2] = HEAP32[$1 >> 2]; + $1 = $1 + 4 | 0; + $2 = $2 + 4 | 0; + if ($3 >>> 0 > $2 >>> 0) { + continue; + } + break; + } + break label$2; + } + if ($4 >>> 0 < 4) { + $2 = $0; + break label$2; + } + $3 = $4 - 4 | 0; + if ($3 >>> 0 < $0 >>> 0) { + $2 = $0; + break label$2; + } + $2 = $0; + while (1) { + HEAP8[$2 | 0] = HEAPU8[$1 | 0]; + HEAP8[$2 + 1 | 0] = HEAPU8[$1 + 1 | 0]; + HEAP8[$2 + 2 | 0] = HEAPU8[$1 + 2 | 0]; + HEAP8[$2 + 3 | 0] = HEAPU8[$1 + 3 | 0]; + $1 = $1 + 4 | 0; + $2 = $2 + 4 | 0; + if ($3 >>> 0 >= $2 >>> 0) { + continue; + } + break; + } + } + if ($2 >>> 0 < $4 >>> 0) { + while (1) { + HEAP8[$2 | 0] = HEAPU8[$1 | 0]; + $1 = $1 + 1 | 0; + $2 = $2 + 1 | 0; + if (($4 | 0) != ($2 | 0)) { + continue; + } + break; + } + } + return $0; +} + +function emscripten__internal__WireTypePack_b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const____WireTypePack_28b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const__29($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 80 | 0; + __stack_pointer = $5; + HEAP32[$5 + 20 >> 2] = $0; + HEAP32[$5 + 16 >> 2] = $1; + HEAP32[$5 + 12 >> 2] = $2; + HEAP32[$5 + 8 >> 2] = $3; + HEAP32[$5 + 4 >> 2] = $4; + $0 = HEAP32[$5 + 20 >> 2]; + wasm2js_i32$0 = $5, wasm2js_i32$1 = std____2__array_emscripten__internal__GenericWireType_2c_204ul___data_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$5 + 16 >> 2]; + $2 = HEAP32[$5 + 12 >> 2]; + $3 = HEAP32[$5 + 8 >> 2]; + $4 = HEAP32[$5 + 4 >> 2]; + HEAP32[$5 + 40 >> 2] = $5; + HEAP32[$5 + 36 >> 2] = $1; + HEAP32[$5 + 32 >> 2] = $2; + HEAP32[$5 + 28 >> 2] = $3; + HEAP32[$5 + 24 >> 2] = $4; + void_20emscripten__internal__writeGenericWireType_b2Vec2__28emscripten__internal__GenericWireType___2c_20b2Vec2__29(HEAP32[$5 + 40 >> 2], emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$5 + 36 >> 2])); + $1 = HEAP32[$5 + 32 >> 2]; + $2 = HEAP32[$5 + 28 >> 2]; + $3 = HEAP32[$5 + 24 >> 2]; + HEAP32[$5 + 56 >> 2] = HEAP32[$5 + 40 >> 2]; + HEAP32[$5 + 52 >> 2] = $1; + HEAP32[$5 + 48 >> 2] = $2; + HEAP32[$5 + 44 >> 2] = $3; + emscripten__internal__writeGenericWireType_28emscripten__internal__GenericWireType___2c_20float_29(HEAP32[$5 + 56 >> 2], emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$5 + 52 >> 2])); + $1 = HEAP32[$5 + 48 >> 2]; + $2 = HEAP32[$5 + 44 >> 2]; + HEAP32[$5 + 68 >> 2] = HEAP32[$5 + 56 >> 2]; + HEAP32[$5 + 64 >> 2] = $1; + HEAP32[$5 + 60 >> 2] = $2; + void_20emscripten__internal__writeGenericWireType_b2Vec2__28emscripten__internal__GenericWireType___2c_20b2Vec2__29(HEAP32[$5 + 68 >> 2], emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$5 + 64 >> 2])); + $1 = HEAP32[$5 + 60 >> 2]; + HEAP32[$5 + 76 >> 2] = HEAP32[$5 + 68 >> 2]; + HEAP32[$5 + 72 >> 2] = $1; + void_20emscripten__internal__writeGenericWireType_b2Color__28emscripten__internal__GenericWireType___2c_20b2Color__29(HEAP32[$5 + 76 >> 2], emscripten__internal__GenericBindingType_b2Color___toWireType_28b2Color_20const__29(HEAP32[$5 + 72 >> 2])); + emscripten__internal__writeGenericWireTypes_28emscripten__internal__GenericWireType___29(HEAP32[$5 + 76 >> 2]); + __stack_pointer = $5 + 80 | 0; + return $0; +} + +function b2PolygonShape__SetAsBox_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = Math_fround($1); + $2 = Math_fround($2); + $3 = $3 | 0; + $4 = Math_fround($4); + var $5 = 0, $6 = 0, $7 = 0; + $5 = __stack_pointer + -64 | 0; + __stack_pointer = $5; + HEAP32[$5 + 60 >> 2] = $0; + HEAPF32[$5 + 56 >> 2] = $1; + HEAPF32[$5 + 52 >> 2] = $2; + HEAP32[$5 + 48 >> 2] = $3; + HEAPF32[$5 + 44 >> 2] = $4; + $6 = HEAP32[$5 + 60 >> 2]; + HEAP32[$6 + 148 >> 2] = 4; + b2Vec2__Set_28float_2c_20float_29($6 + 20 | 0, Math_fround(-HEAPF32[$5 + 56 >> 2]), Math_fround(-HEAPF32[$5 + 52 >> 2])); + b2Vec2__Set_28float_2c_20float_29($6 + 28 | 0, HEAPF32[$5 + 56 >> 2], Math_fround(-HEAPF32[$5 + 52 >> 2])); + b2Vec2__Set_28float_2c_20float_29($6 + 36 | 0, HEAPF32[$5 + 56 >> 2], HEAPF32[$5 + 52 >> 2]); + b2Vec2__Set_28float_2c_20float_29($6 + 44 | 0, Math_fround(-HEAPF32[$5 + 56 >> 2]), HEAPF32[$5 + 52 >> 2]); + b2Vec2__Set_28float_2c_20float_29($6 + 84 | 0, Math_fround(0), Math_fround(-1)); + b2Vec2__Set_28float_2c_20float_29($6 + 92 | 0, Math_fround(1), Math_fround(0)); + b2Vec2__Set_28float_2c_20float_29($6 + 100 | 0, Math_fround(0), Math_fround(1)); + b2Vec2__Set_28float_2c_20float_29($6 + 108 | 0, Math_fround(-1), Math_fround(0)); + $7 = HEAP32[$5 + 48 >> 2]; + $3 = HEAP32[$7 >> 2]; + $0 = HEAP32[$7 + 4 >> 2]; + HEAP32[$6 + 12 >> 2] = $3; + HEAP32[$6 + 16 >> 2] = $0; + b2Transform__b2Transform_28_29($5 + 28 | 0); + $7 = HEAP32[$5 + 48 >> 2]; + $0 = HEAP32[$7 >> 2]; + $3 = HEAP32[$7 + 4 >> 2]; + $7 = $0; + $0 = $5 + 28 | 0; + HEAP32[$0 >> 2] = $7; + HEAP32[$0 + 4 >> 2] = $3; + b2Rot__Set_28float_29($5 + 36 | 0, HEAPF32[$5 + 44 >> 2]); + HEAP32[$5 + 24 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 24 >> 2] < HEAP32[$6 + 148 >> 2]) { + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 16 | 0, $5 + 28 | 0, ($6 + 20 | 0) + (HEAP32[$5 + 24 >> 2] << 3) | 0); + $0 = HEAP32[$5 + 20 >> 2]; + $3 = HEAP32[$5 + 16 >> 2]; + $7 = $3; + $3 = ($6 + 20 | 0) + (HEAP32[$5 + 24 >> 2] << 3) | 0; + HEAP32[$3 >> 2] = $7; + HEAP32[$3 + 4 >> 2] = $0; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($5 + 8 | 0, $5 + 36 | 0, ($6 + 84 | 0) + (HEAP32[$5 + 24 >> 2] << 3) | 0); + $3 = HEAP32[$5 + 12 >> 2]; + $0 = HEAP32[$5 + 8 >> 2]; + $7 = $0; + $0 = ($6 + 84 | 0) + (HEAP32[$5 + 24 >> 2] << 3) | 0; + HEAP32[$0 >> 2] = $7; + HEAP32[$0 + 4 >> 2] = $3; + HEAP32[$5 + 24 >> 2] = HEAP32[$5 + 24 >> 2] + 1; + continue; + } + break; + } + __stack_pointer = $5 - -64 | 0; +} + +function b2Body__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 224 | 0; + __stack_pointer = $1; + HEAP32[$1 + 220 >> 2] = $0; + $0 = HEAP32[$1 + 220 >> 2]; + HEAP32[$1 + 216 >> 2] = HEAP32[$0 + 8 >> 2]; + b2Dump_28char_20const__2c_20____29(12579, 0); + b2Dump_28char_20const__2c_20____29(13732, 0); + HEAP32[$1 + 176 >> 2] = HEAP32[$0 >> 2]; + b2Dump_28char_20const__2c_20____29(14954, $1 + 176 | 0); + $2 = HEAPF32[$0 + 12 >> 2]; + HEAPF64[$1 + 168 >> 3] = HEAPF32[$0 + 16 >> 2]; + HEAPF64[$1 + 160 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14097, $1 + 160 | 0); + HEAPF64[$1 + 144 >> 3] = HEAPF32[$0 + 56 >> 2]; + b2Dump_28char_20const__2c_20____29(13097, $1 + 144 | 0); + $2 = HEAPF32[$0 + 64 >> 2]; + HEAPF64[$1 + 136 >> 3] = HEAPF32[$0 + 68 >> 2]; + HEAPF64[$1 + 128 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(13909, $1 + 128 | 0); + HEAPF64[$1 + 112 >> 3] = HEAPF32[$0 + 72 >> 2]; + b2Dump_28char_20const__2c_20____29(12644, $1 + 112 | 0); + HEAPF64[$1 + 96 >> 3] = HEAPF32[$0 + 132 >> 2]; + b2Dump_28char_20const__2c_20____29(13016, $1 + 96 | 0); + HEAPF64[$1 + 80 >> 3] = HEAPF32[$0 + 136 >> 2]; + b2Dump_28char_20const__2c_20____29(12987, $1 + 80 | 0); + HEAP32[$1 + 64 >> 2] = HEAPU16[$0 + 4 >> 1] & 4; + b2Dump_28char_20const__2c_20____29(14774, $1 - -64 | 0); + HEAP32[$1 + 48 >> 2] = HEAPU16[$0 + 4 >> 1] & 2; + b2Dump_28char_20const__2c_20____29(14835, $1 + 48 | 0); + HEAP32[$1 + 32 >> 2] = HEAPU16[$0 + 4 >> 1] & 16; + b2Dump_28char_20const__2c_20____29(14803, $1 + 32 | 0); + HEAP32[$1 + 16 >> 2] = HEAPU16[$0 + 4 >> 1] & 8; + b2Dump_28char_20const__2c_20____29(14690, $1 + 16 | 0); + HEAP32[$1 >> 2] = HEAPU16[$0 + 4 >> 1] & 32; + b2Dump_28char_20const__2c_20____29(14894, $1); + HEAPF64[$1 + 192 >> 3] = HEAPF32[$0 + 140 >> 2]; + b2Dump_28char_20const__2c_20____29(13196, $1 + 192 | 0); + HEAP32[$1 + 208 >> 2] = HEAP32[$0 + 8 >> 2]; + b2Dump_28char_20const__2c_20____29(14618, $1 + 208 | 0); + b2Dump_28char_20const__2c_20____29(15365, 0); + HEAP32[$1 + 212 >> 2] = HEAP32[$0 + 100 >> 2]; + while (1) { + if (HEAP32[$1 + 212 >> 2]) { + b2Dump_28char_20const__2c_20____29(12577, 0); + b2Fixture__Dump_28int_29(HEAP32[$1 + 212 >> 2], HEAP32[$1 + 216 >> 2]); + b2Dump_28char_20const__2c_20____29(12572, 0); + HEAP32[$1 + 212 >> 2] = HEAP32[HEAP32[$1 + 212 >> 2] + 4 >> 2]; + continue; + } + break; + } + b2Dump_28char_20const__2c_20____29(12574, 0); + __stack_pointer = $1 + 224 | 0; +} + +function b2Mat33__GetSymInverse33_28b2Mat33__29_20const($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 48 | 0; + __stack_pointer = $2; + HEAP32[$2 + 44 >> 2] = $0; + HEAP32[$2 + 40 >> 2] = $1; + $0 = HEAP32[$2 + 44 >> 2]; + b2Cross_28b2Vec3_20const__2c_20b2Vec3_20const__29($2 + 24 | 0, $0 + 12 | 0, $0 + 24 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec3_20const__2c_20b2Vec3_20const__29($0, $2 + 24 | 0), + HEAPF32[wasm2js_i32$0 + 36 >> 2] = wasm2js_f32$0; + if (HEAPF32[$2 + 36 >> 2] != Math_fround(0)) { + HEAPF32[$2 + 36 >> 2] = Math_fround(1) / HEAPF32[$2 + 36 >> 2]; + } + HEAPF32[$2 + 20 >> 2] = HEAPF32[$0 >> 2]; + HEAPF32[$2 + 16 >> 2] = HEAPF32[$0 + 12 >> 2]; + HEAPF32[$2 + 12 >> 2] = HEAPF32[$0 + 24 >> 2]; + HEAPF32[$2 + 8 >> 2] = HEAPF32[$0 + 16 >> 2]; + HEAPF32[$2 + 4 >> 2] = HEAPF32[$0 + 28 >> 2]; + HEAPF32[$2 >> 2] = HEAPF32[$0 + 32 >> 2]; + HEAPF32[HEAP32[$2 + 40 >> 2] >> 2] = HEAPF32[$2 + 36 >> 2] * Math_fround(Math_fround(HEAPF32[$2 + 8 >> 2] * HEAPF32[$2 >> 2]) - Math_fround(HEAPF32[$2 + 4 >> 2] * HEAPF32[$2 + 4 >> 2])); + HEAPF32[HEAP32[$2 + 40 >> 2] + 4 >> 2] = HEAPF32[$2 + 36 >> 2] * Math_fround(Math_fround(HEAPF32[$2 + 12 >> 2] * HEAPF32[$2 + 4 >> 2]) - Math_fround(HEAPF32[$2 + 16 >> 2] * HEAPF32[$2 >> 2])); + HEAPF32[HEAP32[$2 + 40 >> 2] + 8 >> 2] = HEAPF32[$2 + 36 >> 2] * Math_fround(Math_fround(HEAPF32[$2 + 16 >> 2] * HEAPF32[$2 + 4 >> 2]) - Math_fround(HEAPF32[$2 + 12 >> 2] * HEAPF32[$2 + 8 >> 2])); + HEAPF32[HEAP32[$2 + 40 >> 2] + 12 >> 2] = HEAPF32[HEAP32[$2 + 40 >> 2] + 4 >> 2]; + HEAPF32[HEAP32[$2 + 40 >> 2] + 16 >> 2] = HEAPF32[$2 + 36 >> 2] * Math_fround(Math_fround(HEAPF32[$2 + 20 >> 2] * HEAPF32[$2 >> 2]) - Math_fround(HEAPF32[$2 + 12 >> 2] * HEAPF32[$2 + 12 >> 2])); + HEAPF32[HEAP32[$2 + 40 >> 2] + 20 >> 2] = HEAPF32[$2 + 36 >> 2] * Math_fround(Math_fround(HEAPF32[$2 + 12 >> 2] * HEAPF32[$2 + 16 >> 2]) - Math_fround(HEAPF32[$2 + 20 >> 2] * HEAPF32[$2 + 4 >> 2])); + HEAPF32[HEAP32[$2 + 40 >> 2] + 24 >> 2] = HEAPF32[HEAP32[$2 + 40 >> 2] + 8 >> 2]; + HEAPF32[HEAP32[$2 + 40 >> 2] + 28 >> 2] = HEAPF32[HEAP32[$2 + 40 >> 2] + 20 >> 2]; + HEAPF32[HEAP32[$2 + 40 >> 2] + 32 >> 2] = HEAPF32[$2 + 36 >> 2] * Math_fround(Math_fround(HEAPF32[$2 + 20 >> 2] * HEAPF32[$2 + 8 >> 2]) - Math_fround(HEAPF32[$2 + 16 >> 2] * HEAPF32[$2 + 16 >> 2])); + __stack_pointer = $2 + 48 | 0; +} + +function b2Body__SetMassData_28b2MassData_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 48 | 0; + __stack_pointer = $2; + HEAP32[$2 + 44 >> 2] = $0; + HEAP32[$2 + 40 >> 2] = $1; + $0 = HEAP32[$2 + 44 >> 2]; + if (b2World__IsLocked_28_29_20const(HEAP32[$0 + 88 >> 2]) & 1) { + __assert_fail(9124, 4100, 357, 10439); + wasm2js_trap(); + } + if (!(b2World__IsLocked_28_29_20const(HEAP32[$0 + 88 >> 2]) & 1 | HEAP32[$0 >> 2] != 2)) { + HEAPF32[$0 + 120 >> 2] = 0; + HEAPF32[$0 + 124 >> 2] = 0; + HEAPF32[$0 + 128 >> 2] = 0; + HEAPF32[$0 + 116 >> 2] = HEAPF32[HEAP32[$2 + 40 >> 2] >> 2]; + if (HEAPF32[$0 + 116 >> 2] <= Math_fround(0)) { + HEAPF32[$0 + 116 >> 2] = 1; + } + HEAPF32[$0 + 120 >> 2] = Math_fround(1) / HEAPF32[$0 + 116 >> 2]; + if (!(!(HEAPF32[HEAP32[$2 + 40 >> 2] + 12 >> 2] > Math_fround(0)) | HEAPU16[$0 + 4 >> 1] & 16)) { + $4 = HEAPF32[HEAP32[$2 + 40 >> 2] + 12 >> 2]; + wasm2js_i32$0 = $0, wasm2js_f32$0 = Math_fround(Math_fround(Math_fround(-HEAPF32[$0 + 116 >> 2]) * b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$2 + 40 >> 2] + 4 | 0, HEAP32[$2 + 40 >> 2] + 4 | 0)) + $4), + HEAPF32[wasm2js_i32$0 + 124 >> 2] = wasm2js_f32$0; + if (!(HEAPF32[$0 + 124 >> 2] > Math_fround(0))) { + __assert_fail(8118, 4100, 383, 10439); + wasm2js_trap(); + } + HEAPF32[$0 + 128 >> 2] = Math_fround(1) / HEAPF32[$0 + 124 >> 2]; + } + $1 = HEAP32[$0 + 48 >> 2]; + $3 = HEAP32[$0 + 44 >> 2]; + HEAP32[$2 + 32 >> 2] = $3; + HEAP32[$2 + 36 >> 2] = $1; + $3 = HEAP32[$2 + 40 >> 2]; + $1 = HEAP32[$3 + 4 >> 2]; + $3 = HEAP32[$3 + 8 >> 2]; + HEAP32[$0 + 28 >> 2] = $1; + HEAP32[$0 + 32 >> 2] = $3; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($2 + 24 | 0, $0 + 12 | 0, $0 + 28 | 0); + $1 = HEAP32[$2 + 28 >> 2]; + $3 = HEAP32[$2 + 24 >> 2]; + HEAP32[$0 + 44 >> 2] = $3; + HEAP32[$0 + 48 >> 2] = $1; + $3 = HEAP32[$0 + 48 >> 2]; + $1 = HEAP32[$0 + 44 >> 2]; + HEAP32[$0 + 36 >> 2] = $1; + HEAP32[$0 + 40 >> 2] = $3; + $4 = HEAPF32[$0 + 72 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 8 | 0, $0 + 44 | 0, $2 + 32 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 16 | 0, $4, $2 + 8 | 0); + b2Vec2__operator___28b2Vec2_20const__29($0 - -64 | 0, $2 + 16 | 0); + } + __stack_pointer = $2 + 48 | 0; +} + +function b2FindMaxSeparation_28int__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__29($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $5 = __stack_pointer - 112 | 0; + __stack_pointer = $5; + HEAP32[$5 + 108 >> 2] = $0; + HEAP32[$5 + 104 >> 2] = $1; + HEAP32[$5 + 100 >> 2] = $2; + HEAP32[$5 + 96 >> 2] = $3; + HEAP32[$5 + 92 >> 2] = $4; + HEAP32[$5 + 88 >> 2] = HEAP32[HEAP32[$5 + 104 >> 2] + 148 >> 2]; + HEAP32[$5 + 84 >> 2] = HEAP32[HEAP32[$5 + 96 >> 2] + 148 >> 2]; + HEAP32[$5 + 80 >> 2] = HEAP32[$5 + 104 >> 2] + 84; + HEAP32[$5 + 76 >> 2] = HEAP32[$5 + 104 >> 2] + 20; + HEAP32[$5 + 72 >> 2] = HEAP32[$5 + 96 >> 2] + 20; + b2MulT_28b2Transform_20const__2c_20b2Transform_20const__29($5 + 56 | 0, HEAP32[$5 + 92 >> 2], HEAP32[$5 + 100 >> 2]); + HEAP32[$5 + 52 >> 2] = 0; + HEAPF32[$5 + 48 >> 2] = -34028234663852886e22; + HEAP32[$5 + 44 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 44 >> 2] < HEAP32[$5 + 88 >> 2]) { + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($5 + 36 | 0, $5 - -64 | 0, HEAP32[$5 + 80 >> 2] + (HEAP32[$5 + 44 >> 2] << 3) | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 28 | 0, $5 + 56 | 0, HEAP32[$5 + 76 >> 2] + (HEAP32[$5 + 44 >> 2] << 3) | 0); + HEAPF32[$5 + 24 >> 2] = 34028234663852886e22; + HEAP32[$5 + 20 >> 2] = 0; + while (1) { + if (HEAP32[$5 + 20 >> 2] < HEAP32[$5 + 84 >> 2]) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 8 | 0, HEAP32[$5 + 72 >> 2] + (HEAP32[$5 + 20 >> 2] << 3) | 0, $5 + 28 | 0); + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 36 | 0, $5 + 8 | 0), + HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0; + if (HEAPF32[$5 + 16 >> 2] < HEAPF32[$5 + 24 >> 2]) { + HEAPF32[$5 + 24 >> 2] = HEAPF32[$5 + 16 >> 2]; + } + HEAP32[$5 + 20 >> 2] = HEAP32[$5 + 20 >> 2] + 1; + continue; + } + break; + } + if (HEAPF32[$5 + 24 >> 2] > HEAPF32[$5 + 48 >> 2]) { + HEAPF32[$5 + 48 >> 2] = HEAPF32[$5 + 24 >> 2]; + HEAP32[$5 + 52 >> 2] = HEAP32[$5 + 44 >> 2]; + } + HEAP32[$5 + 44 >> 2] = HEAP32[$5 + 44 >> 2] + 1; + continue; + } + break; + } + HEAP32[HEAP32[$5 + 108 >> 2] >> 2] = HEAP32[$5 + 52 >> 2]; + __stack_pointer = $5 + 112 | 0; + return HEAPF32[$5 + 48 >> 2]; +} + +function b2World__Step_28float_2c_20int_2c_20int_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = Math_fround($1); + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $4 = __stack_pointer - 48 | 0; + __stack_pointer = $4; + HEAP32[$4 + 44 >> 2] = $0; + HEAPF32[$4 + 40 >> 2] = $1; + HEAP32[$4 + 36 >> 2] = $2; + HEAP32[$4 + 32 >> 2] = $3; + $0 = HEAP32[$4 + 44 >> 2]; + b2Timer__b2Timer_28_29($4 + 31 | 0); + if (HEAP8[$0 + 102988 | 0] & 1) { + b2ContactManager__FindNewContacts_28_29($0 + 102868 | 0); + HEAP8[$0 + 102988 | 0] = 0; + } + HEAP8[$0 + 102989 | 0] = 1; + HEAPF32[$4 + 4 >> 2] = HEAPF32[$4 + 40 >> 2]; + HEAP32[$4 + 16 >> 2] = HEAP32[$4 + 36 >> 2]; + HEAP32[$4 + 20 >> 2] = HEAP32[$4 + 32 >> 2]; + label$2: { + if (HEAPF32[$4 + 40 >> 2] > Math_fround(0)) { + HEAPF32[$4 + 8 >> 2] = Math_fround(1) / HEAPF32[$4 + 40 >> 2]; + break label$2; + } + HEAPF32[$4 + 8 >> 2] = 0; + } + HEAPF32[$4 + 12 >> 2] = HEAPF32[$0 + 102984 >> 2] * HEAPF32[$4 + 40 >> 2]; + HEAP8[$4 + 24 | 0] = HEAP8[$0 + 102991 | 0] & 1; + b2Timer__b2Timer_28_29($4 + 3 | 0); + b2ContactManager__Collide_28_29($0 + 102868 | 0); + wasm2js_i32$0 = $0, wasm2js_f32$0 = b2Timer__GetMilliseconds_28_29_20const($4 + 3 | 0), + HEAPF32[wasm2js_i32$0 + 103e3 >> 2] = wasm2js_f32$0; + if (!(!(HEAP8[$0 + 102994 | 0] & 1) | !(HEAPF32[$4 + 4 >> 2] > Math_fround(0)))) { + b2Timer__b2Timer_28_29($4 + 2 | 0); + b2World__Solve_28b2TimeStep_20const__29($0, $4 + 4 | 0); + wasm2js_i32$0 = $0, wasm2js_f32$0 = b2Timer__GetMilliseconds_28_29_20const($4 + 2 | 0), + HEAPF32[wasm2js_i32$0 + 103004 >> 2] = wasm2js_f32$0; + } + if (!(!(HEAP8[$0 + 102992 | 0] & 1) | !(HEAPF32[$4 + 4 >> 2] > Math_fround(0)))) { + b2Timer__b2Timer_28_29($4 + 1 | 0); + b2World__SolveTOI_28b2TimeStep_20const__29($0, $4 + 4 | 0); + wasm2js_i32$0 = $0, wasm2js_f32$0 = b2Timer__GetMilliseconds_28_29_20const($4 + 1 | 0), + HEAPF32[wasm2js_i32$0 + 103024 >> 2] = wasm2js_f32$0; + } + if (HEAPF32[$4 + 4 >> 2] > Math_fround(0)) { + HEAPF32[$0 + 102984 >> 2] = HEAPF32[$4 + 8 >> 2]; + } + if (HEAP8[$0 + 102990 | 0] & 1) { + b2World__ClearForces_28_29($0); + } + HEAP8[$0 + 102989 | 0] = 0; + wasm2js_i32$0 = $0, wasm2js_f32$0 = b2Timer__GetMilliseconds_28_29_20const($4 + 31 | 0), + HEAPF32[wasm2js_i32$0 + 102996 >> 2] = wasm2js_f32$0; + __stack_pointer = $4 + 48 | 0; +} + +function b2PrismaticJoint__b2PrismaticJoint_28b2PrismaticJointDef_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + $1 = HEAP32[$2 + 24 >> 2]; + HEAP32[$2 + 28 >> 2] = $1; + b2Joint__b2Joint_28b2JointDef_20const__29($1, HEAP32[$2 + 20 >> 2]); + HEAP32[$1 >> 2] = 19184; + b2Vec2__b2Vec2_28_29($1 + 68 | 0); + b2Vec2__b2Vec2_28_29($1 + 76 | 0); + b2Vec2__b2Vec2_28_29($1 + 84 | 0); + b2Vec2__b2Vec2_28_29($1 + 92 | 0); + b2Vec2__b2Vec2_28_29($1 + 104 | 0); + b2Vec2__b2Vec2_28_29($1 + 152 | 0); + b2Vec2__b2Vec2_28_29($1 + 160 | 0); + b2Vec2__b2Vec2_28_29($1 + 184 | 0); + b2Vec2__b2Vec2_28_29($1 + 192 | 0); + b2Mat22__b2Mat22_28_29($1 + 216 | 0); + $3 = HEAP32[$2 + 20 >> 2]; + $4 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$1 + 68 >> 2] = $4; + HEAP32[$1 + 72 >> 2] = $0; + $3 = HEAP32[$2 + 20 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $4 = HEAP32[$3 + 32 >> 2]; + HEAP32[$1 + 76 >> 2] = $0; + HEAP32[$1 + 80 >> 2] = $4; + $3 = HEAP32[$2 + 20 >> 2]; + $4 = HEAP32[$3 + 36 >> 2]; + $0 = HEAP32[$3 + 40 >> 2]; + HEAP32[$1 + 84 >> 2] = $4; + HEAP32[$1 + 88 >> 2] = $0; + b2Vec2__Normalize_28_29($1 + 84 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($2 + 12 | 0, Math_fround(1), $1 + 84 | 0); + $4 = HEAP32[$2 + 16 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$1 + 92 >> 2] = $0; + HEAP32[$1 + 96 >> 2] = $4; + HEAPF32[$1 + 100 >> 2] = HEAPF32[HEAP32[$2 + 20 >> 2] + 44 >> 2]; + b2Vec2__SetZero_28_29($1 + 104 | 0); + HEAPF32[$1 + 236 >> 2] = 0; + HEAPF32[$1 + 112 >> 2] = 0; + HEAPF32[$1 + 116 >> 2] = 0; + HEAPF32[$1 + 120 >> 2] = 0; + HEAPF32[$1 + 124 >> 2] = HEAPF32[HEAP32[$2 + 20 >> 2] + 52 >> 2]; + HEAPF32[$1 + 128 >> 2] = HEAPF32[HEAP32[$2 + 20 >> 2] + 56 >> 2]; + if (!(HEAPF32[$1 + 124 >> 2] <= HEAPF32[$1 + 128 >> 2])) { + __assert_fail(6720, 4498, 102, 2761); + wasm2js_trap(); + } + HEAPF32[$1 + 132 >> 2] = HEAPF32[HEAP32[$2 + 20 >> 2] + 64 >> 2]; + HEAPF32[$1 + 136 >> 2] = HEAPF32[HEAP32[$2 + 20 >> 2] + 68 >> 2]; + HEAP8[$1 + 140 | 0] = HEAP8[HEAP32[$2 + 20 >> 2] + 48 | 0] & 1; + HEAP8[$1 + 141 | 0] = HEAP8[HEAP32[$2 + 20 >> 2] + 60 | 0] & 1; + HEAPF32[$1 + 232 >> 2] = 0; + b2Vec2__SetZero_28_29($1 + 184 | 0); + b2Vec2__SetZero_28_29($1 + 192 | 0); + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function b2DistanceProxy__Set_28b2Shape_20const__2c_20int_29($0, $1, $2) { + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + $1 = HEAP32[$3 + 28 >> 2]; + label$1: { + label$2: { + switch (b2Shape__GetType_28_29_20const(HEAP32[$3 + 24 >> 2]) | 0) { + case 0: + HEAP32[$3 + 16 >> 2] = HEAP32[$3 + 24 >> 2]; + HEAP32[$1 + 16 >> 2] = HEAP32[$3 + 16 >> 2] + 12; + HEAP32[$1 + 20 >> 2] = 1; + HEAPF32[$1 + 24 >> 2] = HEAPF32[HEAP32[$3 + 16 >> 2] + 8 >> 2]; + break label$1; + + case 2: + HEAP32[$3 + 12 >> 2] = HEAP32[$3 + 24 >> 2]; + HEAP32[$1 + 16 >> 2] = HEAP32[$3 + 12 >> 2] + 20; + HEAP32[$1 + 20 >> 2] = HEAP32[HEAP32[$3 + 12 >> 2] + 148 >> 2]; + HEAPF32[$1 + 24 >> 2] = HEAPF32[HEAP32[$3 + 12 >> 2] + 8 >> 2]; + break label$1; + + case 3: + HEAP32[$3 + 8 >> 2] = HEAP32[$3 + 24 >> 2]; + if (!(HEAP32[$3 + 20 >> 2] < HEAP32[HEAP32[$3 + 8 >> 2] + 16 >> 2] & HEAP32[$3 + 20 >> 2] >= 0)) { + __assert_fail(1893, 6034, 57, 3019); + wasm2js_trap(); + } + $4 = HEAP32[HEAP32[$3 + 8 >> 2] + 12 >> 2] + (HEAP32[$3 + 20 >> 2] << 3) | 0; + $0 = HEAP32[$4 >> 2]; + $2 = HEAP32[$4 + 4 >> 2]; + HEAP32[$1 >> 2] = $0; + HEAP32[$1 + 4 >> 2] = $2; + label$9: { + if (HEAP32[HEAP32[$3 + 8 >> 2] + 16 >> 2] > (HEAP32[$3 + 20 >> 2] + 1 | 0)) { + $4 = HEAP32[HEAP32[$3 + 8 >> 2] + 12 >> 2] + (HEAP32[$3 + 20 >> 2] + 1 << 3) | 0; + $2 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + HEAP32[$1 + 8 >> 2] = $2; + HEAP32[$1 + 12 >> 2] = $0; + break label$9; + } + $4 = HEAP32[HEAP32[$3 + 8 >> 2] + 12 >> 2]; + $0 = HEAP32[$4 >> 2]; + $2 = HEAP32[$4 + 4 >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 + 12 >> 2] = $2; + } + HEAP32[$1 + 16 >> 2] = $1; + HEAP32[$1 + 20 >> 2] = 2; + HEAPF32[$1 + 24 >> 2] = HEAPF32[HEAP32[$3 + 8 >> 2] + 8 >> 2]; + break label$1; + + case 1: + HEAP32[$3 + 4 >> 2] = HEAP32[$3 + 24 >> 2]; + HEAP32[$1 + 16 >> 2] = HEAP32[$3 + 4 >> 2] + 12; + HEAP32[$1 + 20 >> 2] = 2; + HEAPF32[$1 + 24 >> 2] = HEAPF32[HEAP32[$3 + 4 >> 2] + 8 >> 2]; + break label$1; + + default: + break label$2; + } + } + __assert_fail(9147, 6034, 85, 3019); + wasm2js_trap(); + } + __stack_pointer = $3 + 32 | 0; +} + +function b2WheelJoint__b2WheelJoint_28b2WheelJointDef_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Joint__b2Joint_28b2JointDef_20const__29($1, HEAP32[$2 + 8 >> 2]); + HEAP32[$1 >> 2] = 19612; + b2Vec2__b2Vec2_28_29($1 + 68 | 0); + b2Vec2__b2Vec2_28_29($1 + 76 | 0); + b2Vec2__b2Vec2_28_29($1 + 84 | 0); + b2Vec2__b2Vec2_28_29($1 + 92 | 0); + b2Vec2__b2Vec2_28_29($1 + 160 | 0); + b2Vec2__b2Vec2_28_29($1 + 168 | 0); + b2Vec2__b2Vec2_28_29($1 + 192 | 0); + b2Vec2__b2Vec2_28_29($1 + 200 | 0); + $3 = HEAP32[$2 + 8 >> 2]; + $4 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$1 + 68 >> 2] = $4; + HEAP32[$1 + 72 >> 2] = $0; + $3 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $4 = HEAP32[$3 + 32 >> 2]; + HEAP32[$1 + 76 >> 2] = $0; + HEAP32[$1 + 80 >> 2] = $4; + $3 = HEAP32[$2 + 8 >> 2]; + $4 = HEAP32[$3 + 36 >> 2]; + $0 = HEAP32[$3 + 40 >> 2]; + HEAP32[$1 + 84 >> 2] = $4; + HEAP32[$1 + 88 >> 2] = $0; + b2Cross_28float_2c_20b2Vec2_20const__29($2, Math_fround(1), $1 + 84 | 0); + $4 = HEAP32[$2 + 4 >> 2]; + $0 = HEAP32[$2 >> 2]; + HEAP32[$1 + 92 >> 2] = $0; + HEAP32[$1 + 96 >> 2] = $4; + HEAPF32[$1 + 224 >> 2] = 0; + HEAPF32[$1 + 100 >> 2] = 0; + HEAPF32[$1 + 228 >> 2] = 0; + HEAPF32[$1 + 104 >> 2] = 0; + HEAPF32[$1 + 236 >> 2] = 0; + HEAPF32[$1 + 108 >> 2] = 0; + HEAPF32[$1 + 232 >> 2] = 0; + HEAPF32[$1 + 112 >> 2] = 0; + HEAPF32[$1 + 116 >> 2] = 0; + HEAPF32[$1 + 124 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 48 >> 2]; + HEAPF32[$1 + 128 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 52 >> 2]; + HEAP8[$1 + 140 | 0] = HEAP8[HEAP32[$2 + 8 >> 2] + 44 | 0] & 1; + HEAPF32[$1 + 132 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 60 >> 2]; + HEAPF32[$1 + 136 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 64 >> 2]; + HEAP8[$1 + 141 | 0] = HEAP8[HEAP32[$2 + 8 >> 2] + 56 | 0] & 1; + HEAPF32[$1 + 240 >> 2] = 0; + HEAPF32[$1 + 244 >> 2] = 0; + b2Vec2__SetZero_28_29($1 + 192 | 0); + b2Vec2__SetZero_28_29($1 + 200 | 0); + HEAPF32[$1 + 144 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 68 >> 2]; + HEAPF32[$1 + 148 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 72 >> 2]; + __stack_pointer = $2 + 16 | 0; + return $1; +} + +function b2DynamicTree__AllocateNode_28_29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if (HEAP32[$0 + 16 >> 2] == -1) { + if (HEAP32[$0 + 8 >> 2] != HEAP32[$0 + 12 >> 2]) { + __assert_fail(1311, 5965, 61, 9830); + wasm2js_trap(); + } + HEAP32[$1 + 8 >> 2] = HEAP32[$0 + 4 >> 2]; + HEAP32[$0 + 12 >> 2] = HEAP32[$0 + 12 >> 2] << 1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Alloc_28int_29(Math_imul(HEAP32[$0 + 12 >> 2], 40)), + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + __memcpy(HEAP32[$0 + 4 >> 2], HEAP32[$1 + 8 >> 2], Math_imul(HEAP32[$0 + 8 >> 2], 40)); + b2Free_28void__29(HEAP32[$1 + 8 >> 2]); + HEAP32[$1 + 4 >> 2] = HEAP32[$0 + 8 >> 2]; + while (1) { + if (HEAP32[$1 + 4 >> 2] < (HEAP32[$0 + 12 >> 2] - 1 | 0)) { + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$1 + 4 >> 2], 40) | 0) + 20 >> 2] = HEAP32[$1 + 4 >> 2] + 1; + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$1 + 4 >> 2], 40) | 0) + 32 >> 2] = -1; + HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] + 1; + continue; + } + break; + } + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$0 + 12 >> 2] - 1 | 0, 40) | 0) + 20 >> 2] = -1; + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$0 + 12 >> 2] - 1 | 0, 40) | 0) + 32 >> 2] = -1; + HEAP32[$0 + 16 >> 2] = HEAP32[$0 + 8 >> 2]; + } + HEAP32[$1 >> 2] = HEAP32[$0 + 16 >> 2]; + HEAP32[$0 + 16 >> 2] = HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$1 >> 2], 40) | 0) + 20 >> 2]; + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$1 >> 2], 40) | 0) + 20 >> 2] = -1; + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$1 >> 2], 40) | 0) + 24 >> 2] = -1; + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$1 >> 2], 40) | 0) + 28 >> 2] = -1; + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$1 >> 2], 40) | 0) + 32 >> 2] = 0; + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$1 >> 2], 40) | 0) + 16 >> 2] = 0; + HEAP8[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$1 >> 2], 40) | 0) + 36 | 0] = 0; + HEAP32[$0 + 8 >> 2] = HEAP32[$0 + 8 >> 2] + 1; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 >> 2]; +} + +function b2Body__SetType_28b2BodyType_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + if (b2World__IsLocked_28_29_20const(HEAP32[$0 + 88 >> 2]) & 1) { + __assert_fail(9124, 4100, 117, 9237); + wasm2js_trap(); + } + label$2: { + if (b2World__IsLocked_28_29_20const(HEAP32[$0 + 88 >> 2]) & 1 | HEAP32[$0 >> 2] == HEAP32[$2 + 24 >> 2]) { + break label$2; + } + HEAP32[$0 >> 2] = HEAP32[$2 + 24 >> 2]; + b2Body__ResetMassData_28_29($0); + if (!HEAP32[$0 >> 2]) { + b2Vec2__SetZero_28_29($0 - -64 | 0); + HEAPF32[$0 + 72 >> 2] = 0; + HEAPF32[$0 + 52 >> 2] = HEAPF32[$0 + 56 >> 2]; + $1 = HEAP32[$0 + 48 >> 2]; + HEAP32[$0 + 36 >> 2] = HEAP32[$0 + 44 >> 2]; + HEAP32[$0 + 40 >> 2] = $1; + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] & -3; + b2Body__SynchronizeFixtures_28_29($0); + } + b2Body__SetAwake_28bool_29($0, 1); + b2Vec2__SetZero_28_29($0 + 76 | 0); + HEAPF32[$0 + 84 >> 2] = 0; + HEAP32[$2 + 20 >> 2] = HEAP32[$0 + 112 >> 2]; + while (1) { + if (HEAP32[$2 + 20 >> 2]) { + HEAP32[$2 + 16 >> 2] = HEAP32[$2 + 20 >> 2]; + HEAP32[$2 + 20 >> 2] = HEAP32[HEAP32[$2 + 20 >> 2] + 12 >> 2]; + b2ContactManager__Destroy_28b2Contact__29(HEAP32[$0 + 88 >> 2] + 102868 | 0, HEAP32[HEAP32[$2 + 16 >> 2] + 4 >> 2]); + continue; + } + break; + } + HEAP32[$0 + 112 >> 2] = 0; + HEAP32[$2 + 12 >> 2] = HEAP32[$0 + 88 >> 2] + 102868; + HEAP32[$2 + 8 >> 2] = HEAP32[$0 + 100 >> 2]; + while (1) { + if (!HEAP32[$2 + 8 >> 2]) { + break label$2; + } + HEAP32[$2 + 4 >> 2] = HEAP32[HEAP32[$2 + 8 >> 2] + 28 >> 2]; + HEAP32[$2 >> 2] = 0; + while (1) { + if (HEAP32[$2 >> 2] < HEAP32[$2 + 4 >> 2]) { + b2BroadPhase__TouchProxy_28int_29(HEAP32[$2 + 12 >> 2], HEAP32[(HEAP32[HEAP32[$2 + 8 >> 2] + 24 >> 2] + Math_imul(HEAP32[$2 >> 2], 28) | 0) + 24 >> 2]); + HEAP32[$2 >> 2] = HEAP32[$2 >> 2] + 1; + continue; + } + break; + } + HEAP32[$2 + 8 >> 2] = HEAP32[HEAP32[$2 + 8 >> 2] + 4 >> 2]; + continue; + } + } + __stack_pointer = $2 + 32 | 0; +} + +function b2MouseJoint__b2MouseJoint_28b2MouseJointDef_20const__29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + $1 = HEAP32[$2 + 24 >> 2]; + HEAP32[$2 + 28 >> 2] = $1; + b2Joint__b2Joint_28b2JointDef_20const__29($1, HEAP32[$2 + 20 >> 2]); + HEAP32[$1 >> 2] = 18988; + b2Vec2__b2Vec2_28_29($1 + 68 | 0); + b2Vec2__b2Vec2_28_29($1 + 76 | 0); + b2Vec2__b2Vec2_28_29($1 + 96 | 0); + b2Vec2__b2Vec2_28_29($1 + 120 | 0); + b2Vec2__b2Vec2_28_29($1 + 128 | 0); + b2Mat22__b2Mat22_28_29($1 + 144 | 0); + b2Vec2__b2Vec2_28_29($1 + 160 | 0); + if (!(b2Vec2__IsValid_28_29_20const(HEAP32[$2 + 20 >> 2] + 20 | 0) & 1)) { + __assert_fail(12497, 4431, 38, 2598); + wasm2js_trap(); + } + if (!(b2IsValid_28float_29(HEAPF32[HEAP32[$2 + 20 >> 2] + 28 >> 2]) & 1 & HEAPF32[HEAP32[$2 + 20 >> 2] + 28 >> 2] >= Math_fround(0))) { + __assert_fail(8521, 4431, 39, 2598); + wasm2js_trap(); + } + if (!(b2IsValid_28float_29(HEAPF32[HEAP32[$2 + 20 >> 2] + 32 >> 2]) & 1 & HEAPF32[HEAP32[$2 + 20 >> 2] + 32 >> 2] >= Math_fround(0))) { + __assert_fail(8154, 4431, 40, 2598); + wasm2js_trap(); + } + if (!(b2IsValid_28float_29(HEAPF32[HEAP32[$2 + 20 >> 2] + 36 >> 2]) & 1 & HEAPF32[HEAP32[$2 + 20 >> 2] + 36 >> 2] >= Math_fround(0))) { + __assert_fail(8275, 4431, 41, 2598); + wasm2js_trap(); + } + $0 = HEAP32[$2 + 20 >> 2]; + $3 = HEAP32[$0 + 20 >> 2]; + $0 = HEAP32[$0 + 24 >> 2]; + HEAP32[$1 + 76 >> 2] = $3; + HEAP32[$1 + 80 >> 2] = $0; + b2MulT_28b2Transform_20const__2c_20b2Vec2_20const__29($2 + 12 | 0, b2Body__GetTransform_28_29_20const(HEAP32[$1 + 52 >> 2]), $1 + 76 | 0); + $3 = HEAP32[$2 + 16 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$1 + 68 >> 2] = $0; + HEAP32[$1 + 72 >> 2] = $3; + HEAPF32[$1 + 104 >> 2] = HEAPF32[HEAP32[$2 + 20 >> 2] + 28 >> 2]; + b2Vec2__SetZero_28_29($1 + 96 | 0); + HEAPF32[$1 + 84 >> 2] = HEAPF32[HEAP32[$2 + 20 >> 2] + 32 >> 2]; + HEAPF32[$1 + 88 >> 2] = HEAPF32[HEAP32[$2 + 20 >> 2] + 36 >> 2]; + HEAPF32[$1 + 92 >> 2] = 0; + HEAPF32[$1 + 108 >> 2] = 0; + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____erase_28std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $1; + HEAP32[$2 + 20 >> 2] = $0; + $0 = HEAP32[$2 + 20 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____get_np_5babi_v160004_5d_28_29_20const($2 + 24 | 0), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______remove_node_pointer_28std____2____tree_node_b2Fixture__2c_20void____29($0, HEAP32[$2 + 16 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______node_alloc_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + void_20std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______destroy_5babi_v160004_5d_b2Fixture__2c_20void_2c_20void__28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20b2Fixture___29(HEAP32[$2 + 12 >> 2], std____2____tree_key_value_types_b2Fixture______get_ptr_5babi_v160004_5d_28b2Fixture___29(std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long___operator__5babi_v160004_5d_28_29_20const($2 + 24 | 0))); + std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______deallocate_5babi_v160004_5d_28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20unsigned_20long_29(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 16 >> 2], 1); + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function std____2__pair_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____20std____2____move_loop_std____2___ClassicAlgPolicy___operator_28_29_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29_20const($0, $1, $2, $3, $4) { + var $5 = 0; + $5 = __stack_pointer - 16 | 0; + __stack_pointer = $5; + HEAP32[$5 + 12 >> 2] = $2; + HEAP32[$5 + 8 >> 2] = $3; + HEAP32[$5 + 4 >> 2] = $4; + HEAP32[$5 >> 2] = $1; + while (1) { + if (bool_20std____2__operator___5babi_v160004_5d_b2Vec2__2c_20b2Vec2___28std____2__reverse_iterator_b2Vec2___20const__2c_20std____2__reverse_iterator_b2Vec2___20const__29($5 + 12 | 0, $5 + 8 | 0) & 1) { + $1 = std____2__enable_if_is_reference_decltype_28_std__declval_std____2__reverse_iterator_b2Vec2_____28_29_29___value_2c_20decltype_28std__move_28_std__declval_std____2__reverse_iterator_b2Vec2_____28_29_29_29___type_20std____2___IterOps_std____2___ClassicAlgPolicy_____iter_move_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2_____28std____2__reverse_iterator_b2Vec2____29($5 + 12 | 0); + $2 = std____2__reverse_iterator_b2Vec2____operator__5babi_v160004_5d_28_29_20const($5 + 4 | 0); + $3 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 >> 2] = HEAP32[$1 >> 2]; + HEAP32[$2 + 4 >> 2] = $3; + std____2__reverse_iterator_b2Vec2____operator___5babi_v160004_5d_28_29($5 + 12 | 0); + std____2__reverse_iterator_b2Vec2____operator___5babi_v160004_5d_28_29($5 + 4 | 0); + continue; + } + break; + } + std____2__pair_std____2____unwrap_ref_decay_std____2__reverse_iterator_b2Vec2_____type_2c_20std____2____unwrap_ref_decay_std____2__reverse_iterator_b2Vec2_____type__20std____2__make_pair_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2_____2c_20std____2__reverse_iterator_b2Vec2_____29($0, $5 + 12 | 0, $5 + 4 | 0); + __stack_pointer = $5 + 16 | 0; +} + +function unsigned_20long_20std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______erase_unique_b2Fixture___28b2Fixture__20const__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + $0 = HEAP32[$2 + 24 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____find_b2Fixture___28b2Fixture__20const__29($0, HEAP32[$2 + 20 >> 2]), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____end_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + label$1: { + if (std____2__operator___5babi_v160004_5d_28std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__2c_20std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__29($2 + 16 | 0, $2 + 12 | 0) & 1) { + HEAP32[$2 + 28 >> 2] = 0; + break label$1; + } + HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 16 >> 2]; + std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____tree_const_iterator_5babi_v160004_5d_28std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__29($2 + 8 | 0, HEAP32[$2 + 4 >> 2]); + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____erase_28std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__29($0, HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP32[$2 + 28 >> 2] = 1; + } + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2PolygonShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2PolygonShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2PolygonShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 552; + $0 = emscripten__internal__TypeID_b2PolygonShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2PolygonShape____emscripten__internal__getContext_bool_20_28b2PolygonShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const__28bool_20_28b2PolygonShape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2PrismaticJoint__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 224 | 0; + __stack_pointer = $1; + HEAP32[$1 + 220 >> 2] = $0; + $0 = HEAP32[$1 + 220 >> 2]; + HEAP32[$1 + 216 >> 2] = HEAP32[HEAP32[$0 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 212 >> 2] = HEAP32[HEAP32[$0 + 52 >> 2] + 8 >> 2]; + b2Dump_28char_20const__2c_20____29(13683, 0); + HEAP32[$1 + 176 >> 2] = HEAP32[$1 + 216 >> 2]; + b2Dump_28char_20const__2c_20____29(13849, $1 + 176 | 0); + HEAP32[$1 + 160 >> 2] = HEAP32[$1 + 212 >> 2]; + b2Dump_28char_20const__2c_20____29(13823, $1 + 160 | 0); + HEAP32[$1 + 144 >> 2] = HEAP8[$0 + 61 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14859, $1 + 144 | 0); + $2 = HEAPF32[$0 + 68 >> 2]; + HEAPF64[$1 + 136 >> 3] = HEAPF32[$0 + 72 >> 2]; + HEAPF64[$1 + 128 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14265, $1 + 128 | 0); + $2 = HEAPF32[$0 + 76 >> 2]; + HEAPF64[$1 + 120 >> 3] = HEAPF32[$0 + 80 >> 2]; + HEAPF64[$1 + 112 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14158, $1 + 112 | 0); + $2 = HEAPF32[$0 + 84 >> 2]; + HEAPF64[$1 + 104 >> 3] = HEAPF32[$0 + 88 >> 2]; + HEAPF64[$1 + 96 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14231, $1 + 96 | 0); + HEAPF64[$1 + 80 >> 3] = HEAPF32[$0 + 100 >> 2]; + b2Dump_28char_20const__2c_20____29(13167, $1 + 80 | 0); + HEAP32[$1 + 64 >> 2] = HEAP8[$0 + 140 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14660, $1 - -64 | 0); + HEAPF64[$1 + 48 >> 3] = HEAPF32[$0 + 124 >> 2]; + b2Dump_28char_20const__2c_20____29(12858, $1 + 48 | 0); + HEAPF64[$1 + 32 >> 3] = HEAPF32[$0 + 128 >> 2]; + b2Dump_28char_20const__2c_20____29(12889, $1 + 32 | 0); + HEAP32[$1 + 16 >> 2] = HEAP8[$0 + 141 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14715, $1 + 16 | 0); + HEAPF64[$1 >> 3] = HEAPF32[$0 + 136 >> 2]; + b2Dump_28char_20const__2c_20____29(13274, $1); + HEAPF64[$1 + 192 >> 3] = HEAPF32[$0 + 132 >> 2]; + b2Dump_28char_20const__2c_20____29(13246, $1 + 192 | 0); + HEAP32[$1 + 208 >> 2] = HEAP32[$0 + 56 >> 2]; + b2Dump_28char_20const__2c_20____29(14538, $1 + 208 | 0); + __stack_pointer = $1 + 224 | 0; +} + +function void_20b2BroadPhase__UpdatePairs_b2ContactManager__28b2ContactManager__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 48 | 0; + __stack_pointer = $2; + HEAP32[$2 + 44 >> 2] = $0; + HEAP32[$2 + 40 >> 2] = $1; + $0 = HEAP32[$2 + 44 >> 2]; + HEAP32[$0 + 52 >> 2] = 0; + HEAP32[$2 + 36 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 36 >> 2] < HEAP32[$0 + 40 >> 2]) { + HEAP32[$0 + 56 >> 2] = HEAP32[HEAP32[$0 + 32 >> 2] + (HEAP32[$2 + 36 >> 2] << 2) >> 2]; + if (HEAP32[$0 + 56 >> 2] != -1) { + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2DynamicTree__GetFatAABB_28int_29_20const($0, HEAP32[$0 + 56 >> 2]), + HEAP32[wasm2js_i32$0 + 32 >> 2] = wasm2js_i32$1; + void_20b2DynamicTree__Query_b2BroadPhase__28b2BroadPhase__2c_20b2AABB_20const__29_20const($0, $0, HEAP32[$2 + 32 >> 2]); + } + HEAP32[$2 + 36 >> 2] = HEAP32[$2 + 36 >> 2] + 1; + continue; + } + break; + } + HEAP32[$2 + 28 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 28 >> 2] < HEAP32[$0 + 52 >> 2]) { + HEAP32[$2 + 24 >> 2] = HEAP32[$0 + 44 >> 2] + (HEAP32[$2 + 28 >> 2] << 3); + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2DynamicTree__GetUserData_28int_29_20const($0, HEAP32[HEAP32[$2 + 24 >> 2] >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2DynamicTree__GetUserData_28int_29_20const($0, HEAP32[HEAP32[$2 + 24 >> 2] + 4 >> 2]), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + b2ContactManager__AddPair_28void__2c_20void__29(HEAP32[$2 + 40 >> 2], HEAP32[$2 + 20 >> 2], HEAP32[$2 + 16 >> 2]); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 28 >> 2] + 1; + continue; + } + break; + } + HEAP32[$2 + 12 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 12 >> 2] < HEAP32[$0 + 40 >> 2]) { + HEAP32[$2 + 8 >> 2] = HEAP32[HEAP32[$0 + 32 >> 2] + (HEAP32[$2 + 12 >> 2] << 2) >> 2]; + if (HEAP32[$2 + 8 >> 2] != -1) { + b2DynamicTree__ClearMoved_28int_29($0, HEAP32[$2 + 8 >> 2]); + } + HEAP32[$2 + 12 >> 2] = HEAP32[$2 + 12 >> 2] + 1; + continue; + } + break; + } + HEAP32[$0 + 40 >> 2] = 0; + __stack_pointer = $2 + 48 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2CircleShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2CircleShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2CircleShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 534; + $0 = emscripten__internal__TypeID_b2CircleShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2CircleShape____emscripten__internal__getContext_bool_20_28b2CircleShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const__28bool_20_28b2CircleShape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2RayCastCallback____29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29___invoke_b2RayCastCallback_2c_20emscripten__pure_virtual_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20float_20_28b2RayCastCallback____29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 473; + $0 = emscripten__internal__TypeID_b2RayCastCallback_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__pure_virtual_2c_20emscripten__allow_raw_pointers___ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RayCastCallback__2c_20unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__pure_virtual_2c_20emscripten__allow_raw_pointers___ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RayCastCallback__2c_20unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2RayCastCallback____emscripten__internal__getContext_float_20_28b2RayCastCallback____29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29__28float_20_28b2RayCastCallback____20const__29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29_29_29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29($2 + 16 | 0) | 0, 1, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2EdgeShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2EdgeShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2EdgeShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 542; + $0 = emscripten__internal__TypeID_b2EdgeShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2EdgeShape____emscripten__internal__getContext_bool_20_28b2EdgeShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const__28bool_20_28b2EdgeShape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function embind_init_builtin_28_29() { + _embind_register_void(24276, 10108); + _embind_register_bool(24300, 6964, 1, 1, 0); + _embind_register_integer(24312, 4093, 1, -128, 127); + _embind_register_integer(24336, 4086, 1, -128, 127); + _embind_register_integer(24324, 4084, 1, 0, 255); + _embind_register_integer(24348, 1883, 2, -32768, 32767); + _embind_register_integer(24360, 1874, 2, 0, 65535); + _embind_register_integer(24372, 2795, 4, -2147483648, 2147483647); + _embind_register_integer(24384, 2786, 4, 0, -1); + _embind_register_integer(24396, 7621, 4, -2147483648, 2147483647); + _embind_register_integer(24408, 7612, 4, 0, -1); + legalfunc$_embind_register_bigint(24420, 3235, 8, 0, -2147483648, -1, 2147483647); + legalfunc$_embind_register_bigint(24432, 3234, 8, 0, 0, -1, -1); + _embind_register_float(24444, 3228, 4); + _embind_register_float(24456, 9667, 8); + _embind_register_std_string(25532, 7652); + _embind_register_std_string(19800, 11774); + _embind_register_std_wstring(19872, 4, 7626); + _embind_register_std_wstring(19948, 2, 7664); + _embind_register_std_wstring(20024, 4, 7679); + _embind_register_emval(25092, 6984); + _embind_register_memory_view(20064, 0, 11705); + _embind_register_memory_view(20104, 0, 11807); + _embind_register_memory_view(20144, 1, 11735); + _embind_register_memory_view(20184, 2, 11270); + _embind_register_memory_view(20224, 3, 11301); + _embind_register_memory_view(20264, 4, 11341); + _embind_register_memory_view(20304, 5, 11370); + _embind_register_memory_view(20344, 4, 11844); + _embind_register_memory_view(20384, 5, 11874); + _embind_register_memory_view(20104, 0, 11472); + _embind_register_memory_view(20144, 1, 11439); + _embind_register_memory_view(20184, 2, 11538); + _embind_register_memory_view(20224, 3, 11504); + _embind_register_memory_view(20264, 4, 11672); + _embind_register_memory_view(20304, 5, 11638); + _embind_register_memory_view(20424, 8, 11605); + _embind_register_memory_view(20464, 9, 11571); + _embind_register_memory_view(20504, 6, 11408); + _embind_register_memory_view(20544, 7, 11913); +} + +function std____2__pair_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____20std____2____move_loop_std____2___ClassicAlgPolicy___operator_28_29_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29_20const($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 16 | 0; + __stack_pointer = $5; + HEAP32[$5 + 12 >> 2] = $2; + HEAP32[$5 + 8 >> 2] = $3; + HEAP32[$5 + 4 >> 2] = $4; + HEAP32[$5 >> 2] = $1; + while (1) { + if (bool_20std____2__operator___5babi_v160004_5d_int__2c_20int___28std____2__reverse_iterator_int___20const__2c_20std____2__reverse_iterator_int___20const__29($5 + 12 | 0, $5 + 8 | 0) & 1) { + $1 = HEAP32[std____2__enable_if_is_reference_decltype_28_std__declval_std____2__reverse_iterator_int_____28_29_29___value_2c_20decltype_28std__move_28_std__declval_std____2__reverse_iterator_int_____28_29_29_29___type_20std____2___IterOps_std____2___ClassicAlgPolicy_____iter_move_5babi_v160004_5d_std____2__reverse_iterator_int_____28std____2__reverse_iterator_int____29($5 + 12 | 0) >> 2]; + wasm2js_i32$0 = std____2__reverse_iterator_int____operator__5babi_v160004_5d_28_29_20const($5 + 4 | 0), + wasm2js_i32$1 = $1, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + std____2__reverse_iterator_int____operator___5babi_v160004_5d_28_29($5 + 12 | 0); + std____2__reverse_iterator_int____operator___5babi_v160004_5d_28_29($5 + 4 | 0); + continue; + } + break; + } + std____2__pair_std____2____unwrap_ref_decay_std____2__reverse_iterator_int_____type_2c_20std____2____unwrap_ref_decay_std____2__reverse_iterator_int_____type__20std____2__make_pair_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int_____2c_20std____2__reverse_iterator_int_____29($0, $5 + 12 | 0, $5 + 4 | 0); + __stack_pointer = $5 + 16 | 0; +} + +function __cxxabiv1____vmi_class_type_info__search_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_2c_20bool_29_20const($0, $1, $2, $3, $4, $5) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + $5 = $5 | 0; + var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0; + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, HEAP32[$1 + 8 >> 2], $5)) { + __cxxabiv1____class_type_info__process_static_type_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_29_20const($1, $1, $2, $3, $4); + return; + } + $6 = HEAPU8[$1 + 53 | 0]; + $8 = HEAP32[$0 + 12 >> 2]; + HEAP8[$1 + 53 | 0] = 0; + $7 = HEAPU8[$1 + 52 | 0]; + HEAP8[$1 + 52 | 0] = 0; + $12 = $0 + 16 | 0; + __cxxabiv1____base_class_type_info__search_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_2c_20bool_29_20const($12, $1, $2, $3, $4, $5); + $9 = HEAPU8[$1 + 53 | 0]; + $11 = $9 | $6; + $10 = HEAPU8[$1 + 52 | 0]; + $7 = $10 | $7; + $6 = $0 + 24 | 0; + $8 = ($8 << 3) + $12 | 0; + label$2: { + if ($6 >>> 0 >= $8 >>> 0) { + break label$2; + } + while (1) { + if (HEAPU8[$1 + 54 | 0]) { + break label$2; + } + label$4: { + if ($10) { + if (HEAP32[$1 + 24 >> 2] == 1) { + break label$2; + } + if (HEAPU8[$0 + 8 | 0] & 2) { + break label$4; + } + break label$2; + } + if (!$9) { + break label$4; + } + if (!(HEAP8[$0 + 8 | 0] & 1)) { + break label$2; + } + } + HEAP16[$1 + 52 >> 1] = 0; + __cxxabiv1____base_class_type_info__search_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_2c_20bool_29_20const($6, $1, $2, $3, $4, $5); + $9 = HEAPU8[$1 + 53 | 0]; + $11 = $9 | $11; + $10 = HEAPU8[$1 + 52 | 0]; + $7 = $10 | $7; + $6 = $6 + 8 | 0; + if ($8 >>> 0 > $6 >>> 0) { + continue; + } + break; + } + } + HEAP8[$1 + 53 | 0] = ($11 & 255) != 0; + HEAP8[$1 + 52 | 0] = ($7 & 255) != 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Shape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2Shape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2Shape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 523; + $0 = emscripten__internal__TypeID_b2Shape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2Shape____emscripten__internal__getContext_bool_20_28b2Shape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const__28bool_20_28b2Shape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2Simplex__Solve2_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 48 | 0; + __stack_pointer = $2; + HEAP32[$2 + 44 >> 2] = $0; + $1 = HEAP32[$2 + 44 >> 2]; + $3 = HEAP32[$1 + 16 >> 2]; + $0 = HEAP32[$1 + 20 >> 2]; + HEAP32[$2 + 32 >> 2] = $3; + HEAP32[$2 + 36 >> 2] = $0; + $3 = HEAP32[$1 + 56 >> 2]; + $0 = HEAP32[$1 + 52 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 28 >> 2] = $3; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 16 | 0, $2 + 24 | 0, $2 + 32 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(-b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 32 | 0, $2 + 16 | 0)), + HEAPF32[wasm2js_i32$0 + 12 >> 2] = wasm2js_f32$0; + label$1: { + if (HEAPF32[$2 + 12 >> 2] <= Math_fround(0)) { + HEAPF32[$1 + 24 >> 2] = 1; + HEAP32[$1 + 108 >> 2] = 1; + break label$1; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 24 | 0, $2 + 16 | 0), + HEAPF32[wasm2js_i32$0 + 8 >> 2] = wasm2js_f32$0; + if (HEAPF32[$2 + 8 >> 2] <= Math_fround(0)) { + HEAPF32[$1 + 60 >> 2] = 1; + HEAP32[$1 + 108 >> 2] = 1; + $0 = HEAP32[$1 + 40 >> 2]; + $3 = HEAP32[$1 + 36 >> 2]; + HEAP32[$1 >> 2] = $3; + HEAP32[$1 + 4 >> 2] = $0; + HEAP32[$1 + 32 >> 2] = HEAP32[$1 + 68 >> 2]; + $3 = HEAP32[$1 + 64 >> 2]; + $0 = HEAP32[$1 + 60 >> 2]; + HEAP32[$1 + 24 >> 2] = $0; + HEAP32[$1 + 28 >> 2] = $3; + $0 = HEAP32[$1 + 56 >> 2]; + $3 = HEAP32[$1 + 52 >> 2]; + HEAP32[$1 + 16 >> 2] = $3; + HEAP32[$1 + 20 >> 2] = $0; + $3 = HEAP32[$1 + 48 >> 2]; + $0 = HEAP32[$1 + 44 >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 + 12 >> 2] = $3; + break label$1; + } + HEAPF32[$2 + 4 >> 2] = Math_fround(1) / Math_fround(HEAPF32[$2 + 8 >> 2] + HEAPF32[$2 + 12 >> 2]); + HEAPF32[$1 + 24 >> 2] = HEAPF32[$2 + 8 >> 2] * HEAPF32[$2 + 4 >> 2]; + HEAPF32[$1 + 60 >> 2] = HEAPF32[$2 + 12 >> 2] * HEAPF32[$2 + 4 >> 2]; + HEAP32[$1 + 108 >> 2] = 2; + } + __stack_pointer = $2 + 48 | 0; +} + +function emscripten__internal__WireTypePack_unsigned_20int__2c_20int__2c_20b2Color_20const____WireTypePack_28unsigned_20int__2c_20int__2c_20b2Color_20const__29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer + -64 | 0; + __stack_pointer = $4; + HEAP32[$4 + 24 >> 2] = $0; + HEAP32[$4 + 20 >> 2] = $1; + HEAP32[$4 + 16 >> 2] = $2; + HEAP32[$4 + 12 >> 2] = $3; + $0 = HEAP32[$4 + 24 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = std____2__array_emscripten__internal__GenericWireType_2c_203ul___data_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$4 + 20 >> 2]; + $2 = HEAP32[$4 + 16 >> 2]; + $3 = HEAP32[$4 + 12 >> 2]; + HEAP32[$4 + 40 >> 2] = $4 + 8; + HEAP32[$4 + 36 >> 2] = $1; + HEAP32[$4 + 32 >> 2] = $2; + HEAP32[$4 + 28 >> 2] = $3; + void_20emscripten__internal__writeGenericWireType_unsigned_20int__28emscripten__internal__GenericWireType___2c_20unsigned_20int_29(HEAP32[$4 + 40 >> 2], emscripten__internal__BindingType_unsigned_20int_2c_20void___toWireType_28unsigned_20int_20const__29(HEAP32[$4 + 36 >> 2])); + $1 = HEAP32[$4 + 32 >> 2]; + $2 = HEAP32[$4 + 28 >> 2]; + HEAP32[$4 + 52 >> 2] = HEAP32[$4 + 40 >> 2]; + HEAP32[$4 + 48 >> 2] = $1; + HEAP32[$4 + 44 >> 2] = $2; + void_20emscripten__internal__writeGenericWireType_int__28emscripten__internal__GenericWireType___2c_20int_29(HEAP32[$4 + 52 >> 2], emscripten__internal__BindingType_int_2c_20void___toWireType_28int_20const__29(HEAP32[$4 + 48 >> 2])); + $1 = HEAP32[$4 + 44 >> 2]; + HEAP32[$4 + 60 >> 2] = HEAP32[$4 + 52 >> 2]; + HEAP32[$4 + 56 >> 2] = $1; + void_20emscripten__internal__writeGenericWireType_b2Color__28emscripten__internal__GenericWireType___2c_20b2Color__29(HEAP32[$4 + 60 >> 2], emscripten__internal__GenericBindingType_b2Color___toWireType_28b2Color_20const__29(HEAP32[$4 + 56 >> 2])); + emscripten__internal__writeGenericWireTypes_28emscripten__internal__GenericWireType___29(HEAP32[$4 + 60 >> 2]); + __stack_pointer = $4 - -64 | 0; + return $0; +} + +function emscripten__internal__WireTypePack_b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____WireTypePack_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer + -64 | 0; + __stack_pointer = $4; + HEAP32[$4 + 24 >> 2] = $0; + HEAP32[$4 + 20 >> 2] = $1; + HEAP32[$4 + 16 >> 2] = $2; + HEAP32[$4 + 12 >> 2] = $3; + $0 = HEAP32[$4 + 24 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = std____2__array_emscripten__internal__GenericWireType_2c_203ul___data_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$4 + 20 >> 2]; + $2 = HEAP32[$4 + 16 >> 2]; + $3 = HEAP32[$4 + 12 >> 2]; + HEAP32[$4 + 40 >> 2] = $4 + 8; + HEAP32[$4 + 36 >> 2] = $1; + HEAP32[$4 + 32 >> 2] = $2; + HEAP32[$4 + 28 >> 2] = $3; + void_20emscripten__internal__writeGenericWireType_b2Vec2__28emscripten__internal__GenericWireType___2c_20b2Vec2__29(HEAP32[$4 + 40 >> 2], emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$4 + 36 >> 2])); + $1 = HEAP32[$4 + 32 >> 2]; + $2 = HEAP32[$4 + 28 >> 2]; + HEAP32[$4 + 52 >> 2] = HEAP32[$4 + 40 >> 2]; + HEAP32[$4 + 48 >> 2] = $1; + HEAP32[$4 + 44 >> 2] = $2; + void_20emscripten__internal__writeGenericWireType_b2Vec2__28emscripten__internal__GenericWireType___2c_20b2Vec2__29(HEAP32[$4 + 52 >> 2], emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$4 + 48 >> 2])); + $1 = HEAP32[$4 + 44 >> 2]; + HEAP32[$4 + 60 >> 2] = HEAP32[$4 + 52 >> 2]; + HEAP32[$4 + 56 >> 2] = $1; + void_20emscripten__internal__writeGenericWireType_b2Color__28emscripten__internal__GenericWireType___2c_20b2Color__29(HEAP32[$4 + 60 >> 2], emscripten__internal__GenericBindingType_b2Color___toWireType_28b2Color_20const__29(HEAP32[$4 + 56 >> 2])); + emscripten__internal__writeGenericWireTypes_28emscripten__internal__GenericWireType___29(HEAP32[$4 + 60 >> 2]); + __stack_pointer = $4 - -64 | 0; + return $0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28unsigned_20long_2c_20b2Vec2_20const__29___invoke_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28char_20const__2c_20void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28unsigned_20long_2c_20b2Vec2_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 704; + $0 = emscripten__internal__TypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______emscripten__internal__getContext_void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28unsigned_20long_2c_20b2Vec2_20const__29__28void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______20const__29_28unsigned_20long_2c_20b2Vec2_20const__29_29_29_28unsigned_20long_2c_20b2Vec2_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______append_28unsigned_20long_2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 48 | 0; + __stack_pointer = $3; + HEAP32[$3 + 44 >> 2] = $0; + HEAP32[$3 + 40 >> 2] = $1; + HEAP32[$3 + 36 >> 2] = $2; + $0 = HEAP32[$3 + 44 >> 2]; + label$1: { + if (HEAP32[std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______end_cap_5babi_v160004_5d_28_29($0) >> 2] - HEAP32[$0 + 4 >> 2] >> 3 >>> 0 >= HEAPU32[$3 + 40 >> 2]) { + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______construct_at_end_28unsigned_20long_2c_20b2Vec2_20const__29($0, HEAP32[$3 + 40 >> 2], HEAP32[$3 + 36 >> 2]); + break label$1; + } + wasm2js_i32$0 = $3, wasm2js_i32$1 = std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______alloc_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 32 >> 2] = wasm2js_i32$1; + std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______split_buffer_28unsigned_20long_2c_20unsigned_20long_2c_20std____2__allocator_b2Vec2___29($3 + 12 | 0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______recommend_5babi_v160004_5d_28unsigned_20long_29_20const($0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____size_5babi_v160004_5d_28_29_20const($0) + HEAP32[$3 + 40 >> 2] | 0), std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____size_5babi_v160004_5d_28_29_20const($0), HEAP32[$3 + 32 >> 2]); + std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______construct_at_end_28unsigned_20long_2c_20b2Vec2_20const__29($3 + 12 | 0, HEAP32[$3 + 40 >> 2], HEAP32[$3 + 36 >> 2]); + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______swap_out_circular_buffer_28std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_____29($0, $3 + 12 | 0); + std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2________split_buffer_28_29($3 + 12 | 0); + } + __stack_pointer = $3 + 48 | 0; +} + +function b2ComputeEdgeSeparation_28b2TempPolygon_20const__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $4 = __stack_pointer + -64 | 0; + __stack_pointer = $4; + HEAP32[$4 + 60 >> 2] = $1; + HEAP32[$4 + 56 >> 2] = $2; + HEAP32[$4 + 52 >> 2] = $3; + b2EPAxis__b2EPAxis_28_29($0); + HEAP32[$0 + 8 >> 2] = 1; + HEAP32[$0 + 12 >> 2] = -1; + HEAPF32[$0 + 16 >> 2] = -34028234663852886e22; + b2Vec2__SetZero_28_29($0); + $3 = HEAP32[$4 + 52 >> 2]; + $1 = HEAP32[$3 >> 2]; + $2 = HEAP32[$3 + 4 >> 2]; + $3 = $1; + $1 = $4 + 32 | 0; + HEAP32[$1 >> 2] = $3; + HEAP32[$1 + 4 >> 2] = $2; + b2Vec2__operator__28_29_20const($1 + 8 | 0, HEAP32[$4 + 52 >> 2]); + HEAP32[$4 + 28 >> 2] = 0; + while (1) { + if (HEAP32[$4 + 28 >> 2] < 2) { + HEAPF32[$4 + 24 >> 2] = 34028234663852886e22; + HEAP32[$4 + 20 >> 2] = 0; + while (1) { + if (HEAP32[$4 + 20 >> 2] < HEAP32[HEAP32[$4 + 60 >> 2] + 128 >> 2]) { + $1 = HEAP32[$4 + 28 >> 2] << 3; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 8 | 0, HEAP32[$4 + 60 >> 2] + (HEAP32[$4 + 20 >> 2] << 3) | 0, HEAP32[$4 + 56 >> 2]); + wasm2js_i32$0 = $4, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + ($4 + 32 | 0) | 0, $4 + 8 | 0), + HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0; + if (HEAPF32[$4 + 16 >> 2] < HEAPF32[$4 + 24 >> 2]) { + HEAPF32[$4 + 24 >> 2] = HEAPF32[$4 + 16 >> 2]; + } + HEAP32[$4 + 20 >> 2] = HEAP32[$4 + 20 >> 2] + 1; + continue; + } + break; + } + if (HEAPF32[$4 + 24 >> 2] > HEAPF32[$0 + 16 >> 2]) { + HEAP32[$0 + 12 >> 2] = HEAP32[$4 + 28 >> 2]; + HEAPF32[$0 + 16 >> 2] = HEAPF32[$4 + 24 >> 2]; + $3 = ($4 + 32 | 0) + (HEAP32[$4 + 28 >> 2] << 3) | 0; + $2 = HEAP32[$3 >> 2]; + $1 = HEAP32[$3 + 4 >> 2]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + } + HEAP32[$4 + 28 >> 2] = HEAP32[$4 + 28 >> 2] + 1; + continue; + } + break; + } + __stack_pointer = $4 - -64 | 0; +} + +function std____2__pair_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____20std____2____unwrap_range_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $1; + HEAP32[$3 + 24 >> 2] = $2; + HEAP32[$3 + 16 >> 2] = HEAP32[$3 + 28 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = decltype_28std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false_____unwrap_28std__declval_std____2__reverse_iterator_b2Vec2____28_29_29_29_20std____2____unwrap_iter_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false__2c_200__28std____2__reverse_iterator_b2Vec2___29(HEAP32[$3 + 16 >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + HEAP32[$3 + 8 >> 2] = HEAP32[$3 + 24 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = decltype_28std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false_____unwrap_28std__declval_std____2__reverse_iterator_b2Vec2____28_29_29_29_20std____2____unwrap_iter_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false__2c_200__28std____2__reverse_iterator_b2Vec2___29(HEAP32[$3 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + std____2__pair_std____2____unwrap_ref_decay_std____2__reverse_iterator_b2Vec2_____type_2c_20std____2____unwrap_ref_decay_std____2__reverse_iterator_b2Vec2_____type__20std____2__make_pair_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2_____2c_20std____2__reverse_iterator_b2Vec2_____29($0, $3 + 20 | 0, $3 + 12 | 0); + __stack_pointer = $3 + 32 | 0; +} + +function b2Fixture__Destroy_28b2BlockAllocator__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + if (HEAP32[$0 + 28 >> 2]) { + __assert_fail(12304, 5695, 76, 1607); + wasm2js_trap(); + } + $1 = HEAP32[$0 + 12 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 12 >> 2]]($1) | 0, + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 24 >> 2], HEAP32[$0 + 24 >> 2], Math_imul(HEAP32[$2 + 20 >> 2], 28)); + HEAP32[$0 + 24 >> 2] = 0; + label$2: { + label$3: { + switch (HEAP32[HEAP32[$0 + 12 >> 2] + 4 >> 2]) { + case 0: + HEAP32[$2 + 16 >> 2] = HEAP32[$0 + 12 >> 2]; + $1 = HEAP32[$2 + 16 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] >> 2]]($1) | 0; + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 24 >> 2], HEAP32[$2 + 16 >> 2], 20); + break label$2; + + case 1: + HEAP32[$2 + 12 >> 2] = HEAP32[$0 + 12 >> 2]; + $1 = HEAP32[$2 + 12 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] >> 2]]($1) | 0; + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 24 >> 2], HEAP32[$2 + 12 >> 2], 48); + break label$2; + + case 2: + HEAP32[$2 + 8 >> 2] = HEAP32[$0 + 12 >> 2]; + $1 = HEAP32[$2 + 8 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] >> 2]]($1) | 0; + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 24 >> 2], HEAP32[$2 + 8 >> 2], 152); + break label$2; + + case 3: + HEAP32[$2 + 4 >> 2] = HEAP32[$0 + 12 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] >> 2]]($1) | 0; + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 24 >> 2], HEAP32[$2 + 4 >> 2], 36); + break label$2; + + default: + break label$3; + } + } + __assert_fail(9147, 5695, 119, 1607); + wasm2js_trap(); + } + HEAP32[$0 + 12 >> 2] = 0; + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__WireTypePack_b2Vec2_20const__2c_20float__2c_20b2Color_20const____WireTypePack_28b2Vec2_20const__2c_20float__2c_20b2Color_20const__29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer + -64 | 0; + __stack_pointer = $4; + HEAP32[$4 + 24 >> 2] = $0; + HEAP32[$4 + 20 >> 2] = $1; + HEAP32[$4 + 16 >> 2] = $2; + HEAP32[$4 + 12 >> 2] = $3; + $0 = HEAP32[$4 + 24 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = std____2__array_emscripten__internal__GenericWireType_2c_203ul___data_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$4 + 20 >> 2]; + $2 = HEAP32[$4 + 16 >> 2]; + $3 = HEAP32[$4 + 12 >> 2]; + HEAP32[$4 + 40 >> 2] = $4 + 8; + HEAP32[$4 + 36 >> 2] = $1; + HEAP32[$4 + 32 >> 2] = $2; + HEAP32[$4 + 28 >> 2] = $3; + void_20emscripten__internal__writeGenericWireType_b2Vec2__28emscripten__internal__GenericWireType___2c_20b2Vec2__29(HEAP32[$4 + 40 >> 2], emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$4 + 36 >> 2])); + $1 = HEAP32[$4 + 32 >> 2]; + $2 = HEAP32[$4 + 28 >> 2]; + HEAP32[$4 + 52 >> 2] = HEAP32[$4 + 40 >> 2]; + HEAP32[$4 + 48 >> 2] = $1; + HEAP32[$4 + 44 >> 2] = $2; + emscripten__internal__writeGenericWireType_28emscripten__internal__GenericWireType___2c_20float_29(HEAP32[$4 + 52 >> 2], emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$4 + 48 >> 2])); + $1 = HEAP32[$4 + 44 >> 2]; + HEAP32[$4 + 60 >> 2] = HEAP32[$4 + 52 >> 2]; + HEAP32[$4 + 56 >> 2] = $1; + void_20emscripten__internal__writeGenericWireType_b2Color__28emscripten__internal__GenericWireType___2c_20b2Color__29(HEAP32[$4 + 60 >> 2], emscripten__internal__GenericBindingType_b2Color___toWireType_28b2Color_20const__29(HEAP32[$4 + 56 >> 2])); + emscripten__internal__writeGenericWireTypes_28emscripten__internal__GenericWireType___29(HEAP32[$4 + 60 >> 2]); + __stack_pointer = $4 - -64 | 0; + return $0; +} + +function b2ComputePolygonSeparation_28b2TempPolygon_20const__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $4 = __stack_pointer + -64 | 0; + __stack_pointer = $4; + HEAP32[$4 + 60 >> 2] = $1; + HEAP32[$4 + 56 >> 2] = $2; + HEAP32[$4 + 52 >> 2] = $3; + b2EPAxis__b2EPAxis_28_29($0); + HEAP32[$0 + 8 >> 2] = 0; + HEAP32[$0 + 12 >> 2] = -1; + HEAPF32[$0 + 16 >> 2] = -34028234663852886e22; + b2Vec2__SetZero_28_29($0); + HEAP32[$4 + 48 >> 2] = 0; + while (1) { + if (HEAP32[$4 + 48 >> 2] < HEAP32[HEAP32[$4 + 60 >> 2] + 128 >> 2]) { + b2Vec2__operator__28_29_20const($4 + 40 | 0, (HEAP32[$4 + 60 >> 2] - -64 | 0) + (HEAP32[$4 + 48 >> 2] << 3) | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 28 | 0, HEAP32[$4 + 60 >> 2] + (HEAP32[$4 + 48 >> 2] << 3) | 0, HEAP32[$4 + 56 >> 2]); + wasm2js_i32$0 = $4, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 40 | 0, $4 + 28 | 0), + HEAPF32[wasm2js_i32$0 + 36 >> 2] = wasm2js_f32$0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 16 | 0, HEAP32[$4 + 60 >> 2] + (HEAP32[$4 + 48 >> 2] << 3) | 0, HEAP32[$4 + 52 >> 2]); + wasm2js_i32$0 = $4, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 40 | 0, $4 + 16 | 0), + HEAPF32[wasm2js_i32$0 + 24 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $4, wasm2js_f32$0 = float_20b2Min_float__28float_2c_20float_29(HEAPF32[$4 + 36 >> 2], HEAPF32[$4 + 24 >> 2]), + HEAPF32[wasm2js_i32$0 + 12 >> 2] = wasm2js_f32$0; + if (HEAPF32[$4 + 12 >> 2] > HEAPF32[$0 + 16 >> 2]) { + HEAP32[$0 + 8 >> 2] = 2; + HEAP32[$0 + 12 >> 2] = HEAP32[$4 + 48 >> 2]; + HEAPF32[$0 + 16 >> 2] = HEAPF32[$4 + 12 >> 2]; + $1 = HEAP32[$4 + 44 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$4 + 40 >> 2]; + HEAP32[$0 + 4 >> 2] = $1; + } + HEAP32[$4 + 48 >> 2] = HEAP32[$4 + 48 >> 2] + 1; + continue; + } + break; + } + __stack_pointer = $4 - -64 | 0; +} + +function b2PolygonShape__ComputeAABB_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 96 | 0; + __stack_pointer = $4; + HEAP32[$4 + 92 >> 2] = $0; + HEAP32[$4 + 88 >> 2] = $1; + HEAP32[$4 + 84 >> 2] = $2; + HEAP32[$4 + 80 >> 2] = $3; + $2 = HEAP32[$4 + 92 >> 2]; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 72 | 0, HEAP32[$4 + 84 >> 2], $2 + 20 | 0); + $1 = HEAP32[$4 + 76 >> 2]; + $0 = HEAP32[$4 + 72 >> 2]; + HEAP32[$4 + 64 >> 2] = $0; + HEAP32[$4 + 68 >> 2] = $1; + HEAP32[$4 + 60 >> 2] = 1; + while (1) { + if (HEAP32[$4 + 60 >> 2] < HEAP32[$2 + 148 >> 2]) { + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 52 | 0, HEAP32[$4 + 84 >> 2], ($2 + 20 | 0) + (HEAP32[$4 + 60 >> 2] << 3) | 0); + b2Min_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 44 | 0, $4 + 72 | 0, $4 + 52 | 0); + $0 = HEAP32[$4 + 48 >> 2]; + $1 = HEAP32[$4 + 44 >> 2]; + HEAP32[$4 + 72 >> 2] = $1; + HEAP32[$4 + 76 >> 2] = $0; + b2Max_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 36 | 0, $4 - -64 | 0, $4 + 52 | 0); + $1 = HEAP32[$4 + 40 >> 2]; + $0 = HEAP32[$4 + 36 >> 2]; + HEAP32[$4 + 64 >> 2] = $0; + HEAP32[$4 + 68 >> 2] = $1; + HEAP32[$4 + 60 >> 2] = HEAP32[$4 + 60 >> 2] + 1; + continue; + } + break; + } + b2Vec2__b2Vec2_28float_2c_20float_29($4 + 28 | 0, HEAPF32[$2 + 8 >> 2], HEAPF32[$2 + 8 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 20 | 0, $4 + 72 | 0, $4 + 28 | 0); + $0 = HEAP32[$4 + 24 >> 2]; + $1 = HEAP32[$4 + 20 >> 2]; + $2 = $1; + $1 = HEAP32[$4 + 88 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($4 + 12 | 0, $4 - -64 | 0, $4 + 28 | 0); + $1 = HEAP32[$4 + 16 >> 2]; + $0 = HEAP32[$4 + 12 >> 2]; + $2 = $0; + $0 = HEAP32[$4 + 88 >> 2]; + HEAP32[$0 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $1; + __stack_pointer = $4 + 96 | 0; +} + +function b2ChainShape__GetChildEdge_28b2EdgeShape__2c_20int_29_20const($0, $1, $2) { + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = HEAP32[$3 + 12 >> 2]; + if (!(HEAP32[$3 + 4 >> 2] < (HEAP32[$2 + 16 >> 2] - 1 | 0) & HEAP32[$3 + 4 >> 2] >= 0)) { + __assert_fail(12132, 5828, 102, 9812); + wasm2js_trap(); + } + HEAP32[HEAP32[$3 + 8 >> 2] + 4 >> 2] = 1; + HEAPF32[HEAP32[$3 + 8 >> 2] + 8 >> 2] = HEAPF32[$2 + 8 >> 2]; + $4 = HEAP32[$2 + 12 >> 2] + (HEAP32[$3 + 4 >> 2] << 3) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + $4 = $0; + $0 = HEAP32[$3 + 8 >> 2]; + HEAP32[$0 + 12 >> 2] = $4; + HEAP32[$0 + 16 >> 2] = $1; + $4 = HEAP32[$2 + 12 >> 2] + (HEAP32[$3 + 4 >> 2] + 1 << 3) | 0; + $1 = HEAP32[$4 >> 2]; + $0 = HEAP32[$4 + 4 >> 2]; + $4 = $1; + $1 = HEAP32[$3 + 8 >> 2]; + HEAP32[$1 + 20 >> 2] = $4; + HEAP32[$1 + 24 >> 2] = $0; + HEAP8[HEAP32[$3 + 8 >> 2] + 44 | 0] = 1; + label$3: { + if (HEAP32[$3 + 4 >> 2] > 0) { + $4 = HEAP32[$2 + 12 >> 2] + (HEAP32[$3 + 4 >> 2] - 1 << 3) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + $4 = $0; + $0 = HEAP32[$3 + 8 >> 2]; + HEAP32[$0 + 28 >> 2] = $4; + HEAP32[$0 + 32 >> 2] = $1; + break label$3; + } + $0 = HEAP32[$2 + 24 >> 2]; + $1 = HEAP32[$2 + 20 >> 2]; + $4 = $1; + $1 = HEAP32[$3 + 8 >> 2]; + HEAP32[$1 + 28 >> 2] = $4; + HEAP32[$1 + 32 >> 2] = $0; + } + label$5: { + if (HEAP32[$3 + 4 >> 2] < (HEAP32[$2 + 16 >> 2] - 2 | 0)) { + $4 = HEAP32[$2 + 12 >> 2] + (HEAP32[$3 + 4 >> 2] + 2 << 3) | 0; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + $2 = $0; + $0 = HEAP32[$3 + 8 >> 2]; + HEAP32[$0 + 36 >> 2] = $2; + HEAP32[$0 + 40 >> 2] = $1; + break label$5; + } + $0 = HEAP32[$2 + 32 >> 2]; + $1 = HEAP32[$2 + 28 >> 2]; + $2 = $1; + $1 = HEAP32[$3 + 8 >> 2]; + HEAP32[$1 + 36 >> 2] = $2; + HEAP32[$1 + 40 >> 2] = $0; + } + __stack_pointer = $3 + 16 | 0; +} + +function b2Fixture__Create_28b2BlockAllocator__2c_20b2Body__2c_20b2FixtureDef_20const__29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 28 >> 2] = $0; + HEAP32[$4 + 24 >> 2] = $1; + HEAP32[$4 + 20 >> 2] = $2; + HEAP32[$4 + 16 >> 2] = $3; + $0 = HEAP32[$4 + 28 >> 2]; + HEAP32[$0 + 40 >> 2] = HEAP32[HEAP32[$4 + 16 >> 2] + 4 >> 2]; + HEAPF32[$0 + 16 >> 2] = HEAPF32[HEAP32[$4 + 16 >> 2] + 8 >> 2]; + HEAPF32[$0 + 20 >> 2] = HEAPF32[HEAP32[$4 + 16 >> 2] + 12 >> 2]; + HEAP32[$0 + 8 >> 2] = HEAP32[$4 + 20 >> 2]; + HEAP32[$0 + 4 >> 2] = 0; + $1 = HEAP32[$4 + 16 >> 2]; + $2 = HEAPU16[$1 + 22 >> 1] | HEAPU16[$1 + 24 >> 1] << 16; + HEAP16[$0 + 32 >> 1] = $2; + HEAP16[$0 + 34 >> 1] = $2 >>> 16; + HEAP16[$0 + 36 >> 1] = HEAPU16[$1 + 26 >> 1]; + HEAP8[$0 + 38 | 0] = HEAP8[HEAP32[$4 + 16 >> 2] + 20 | 0] & 1; + $1 = HEAP32[HEAP32[$4 + 16 >> 2] >> 2]; + wasm2js_i32$0 = $0, wasm2js_i32$1 = FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 8 >> 2]]($1, HEAP32[$4 + 24 >> 2]) | 0, + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$0 + 12 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 12 >> 2]]($1) | 0, + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$4 + 24 >> 2], Math_imul(HEAP32[$4 + 12 >> 2], 28)), + HEAP32[wasm2js_i32$0 + 24 >> 2] = wasm2js_i32$1; + HEAP32[$4 + 8 >> 2] = 0; + while (1) { + if (HEAP32[$4 + 8 >> 2] < HEAP32[$4 + 12 >> 2]) { + HEAP32[(HEAP32[$0 + 24 >> 2] + Math_imul(HEAP32[$4 + 8 >> 2], 28) | 0) + 16 >> 2] = 0; + HEAP32[(HEAP32[$0 + 24 >> 2] + Math_imul(HEAP32[$4 + 8 >> 2], 28) | 0) + 24 >> 2] = -1; + HEAP32[$4 + 8 >> 2] = HEAP32[$4 + 8 >> 2] + 1; + continue; + } + break; + } + HEAP32[$0 + 28 >> 2] = 0; + HEAPF32[$0 >> 2] = HEAPF32[HEAP32[$4 + 16 >> 2] + 16 >> 2]; + __stack_pointer = $4 + 32 | 0; +} + +function b2Contact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 48 | 0; + __stack_pointer = $5; + HEAP32[$5 + 40 >> 2] = $0; + HEAP32[$5 + 36 >> 2] = $1; + HEAP32[$5 + 32 >> 2] = $2; + HEAP32[$5 + 28 >> 2] = $3; + HEAP32[$5 + 24 >> 2] = $4; + if (!(HEAP8[30976] & 1)) { + b2Contact__InitializeRegisters_28_29(); + HEAP8[30976] = 1; + } + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2Fixture__GetType_28_29_20const(HEAP32[$5 + 40 >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2Fixture__GetType_28_29_20const(HEAP32[$5 + 32 >> 2]), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + if (!(HEAP32[$5 + 20 >> 2] < 4 & HEAP32[$5 + 20 >> 2] >= 0)) { + __assert_fail(2326, 5153, 84, 8936); + wasm2js_trap(); + } + if (!(HEAP32[$5 + 16 >> 2] < 4 & HEAP32[$5 + 16 >> 2] >= 0)) { + __assert_fail(2283, 5153, 85, 8936); + wasm2js_trap(); + } + HEAP32[$5 + 12 >> 2] = HEAP32[(Math_imul(HEAP32[$5 + 20 >> 2], 48) + 30784 | 0) + Math_imul(HEAP32[$5 + 16 >> 2], 12) >> 2]; + label$6: { + if (HEAP32[$5 + 12 >> 2]) { + if (HEAP8[((Math_imul(HEAP32[$5 + 20 >> 2], 48) + 30784 | 0) + Math_imul(HEAP32[$5 + 16 >> 2], 12) | 0) + 8 | 0] & 1) { + wasm2js_i32$0 = $5, wasm2js_i32$1 = FUNCTION_TABLE[HEAP32[$5 + 12 >> 2]](HEAP32[$5 + 40 >> 2], HEAP32[$5 + 36 >> 2], HEAP32[$5 + 32 >> 2], HEAP32[$5 + 28 >> 2], HEAP32[$5 + 24 >> 2]) | 0, + HEAP32[wasm2js_i32$0 + 44 >> 2] = wasm2js_i32$1; + break label$6; + } + wasm2js_i32$0 = $5, wasm2js_i32$1 = FUNCTION_TABLE[HEAP32[$5 + 12 >> 2]](HEAP32[$5 + 32 >> 2], HEAP32[$5 + 28 >> 2], HEAP32[$5 + 40 >> 2], HEAP32[$5 + 36 >> 2], HEAP32[$5 + 24 >> 2]) | 0, + HEAP32[wasm2js_i32$0 + 44 >> 2] = wasm2js_i32$1; + break label$6; + } + HEAP32[$5 + 44 >> 2] = 0; + } + __stack_pointer = $5 + 48 | 0; + return HEAP32[$5 + 44 >> 2]; +} + +function std____2__pair_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____20std____2____unwrap_range_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $1; + HEAP32[$3 + 24 >> 2] = $2; + HEAP32[$3 + 16 >> 2] = HEAP32[$3 + 28 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = decltype_28std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false_____unwrap_28std__declval_std____2__reverse_iterator_int____28_29_29_29_20std____2____unwrap_iter_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false__2c_200__28std____2__reverse_iterator_int___29(HEAP32[$3 + 16 >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + HEAP32[$3 + 8 >> 2] = HEAP32[$3 + 24 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = decltype_28std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false_____unwrap_28std__declval_std____2__reverse_iterator_int____28_29_29_29_20std____2____unwrap_iter_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false__2c_200__28std____2__reverse_iterator_int___29(HEAP32[$3 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + std____2__pair_std____2____unwrap_ref_decay_std____2__reverse_iterator_int_____type_2c_20std____2____unwrap_ref_decay_std____2__reverse_iterator_int_____type__20std____2__make_pair_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int_____2c_20std____2__reverse_iterator_int_____29($0, $3 + 20 | 0, $3 + 12 | 0); + __stack_pointer = $3 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28unsigned_20long_2c_20int_20const__29___invoke_std____2__vector_int_2c_20std____2__allocator_int____28char_20const__2c_20void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28unsigned_20long_2c_20int_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 698; + $0 = emscripten__internal__TypeID_std____2__vector_int_2c_20std____2__allocator_int___2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28std____2__vector_int_2c_20std____2__allocator_int______emscripten__internal__getContext_void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28unsigned_20long_2c_20int_20const__29__28void_20_28std____2__vector_int_2c_20std____2__allocator_int______20const__29_28unsigned_20long_2c_20int_20const__29_29_29_28unsigned_20long_2c_20int_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2Joint__Destroy_28b2Joint__2c_20b2BlockAllocator__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 28 >> 2]]($0) | 0; + label$1: { + label$2: { + switch (HEAP32[HEAP32[$2 + 12 >> 2] + 4 >> 2] - 1 | 0) { + case 2: + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 176); + break label$1; + + case 4: + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 168); + break label$1; + + case 1: + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 240); + break label$1; + + case 0: + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 212); + break label$1; + + case 3: + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 196); + break label$1; + + case 5: + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 276); + break label$1; + + case 6: + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 248); + break label$1; + + case 7: + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 208); + break label$1; + + case 8: + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 180); + break label$1; + + case 9: + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 164); + break label$1; + + case 10: + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 192); + break label$1; + + default: + break label$2; + } + } + __assert_fail(9147, 4569, 232, 1607); + wasm2js_trap(); + } + __stack_pointer = $2 + 16 | 0; +} + +function b2RevoluteJoint__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 208 | 0; + __stack_pointer = $1; + HEAP32[$1 + 204 >> 2] = $0; + $0 = HEAP32[$1 + 204 >> 2]; + HEAP32[$1 + 200 >> 2] = HEAP32[HEAP32[$0 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 196 >> 2] = HEAP32[HEAP32[$0 + 52 >> 2] + 8 >> 2]; + b2Dump_28char_20const__2c_20____29(13587, 0); + HEAP32[$1 + 160 >> 2] = HEAP32[$1 + 200 >> 2]; + b2Dump_28char_20const__2c_20____29(13849, $1 + 160 | 0); + HEAP32[$1 + 144 >> 2] = HEAP32[$1 + 196 >> 2]; + b2Dump_28char_20const__2c_20____29(13823, $1 + 144 | 0); + HEAP32[$1 + 128 >> 2] = HEAP8[$0 + 61 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14859, $1 + 128 | 0); + $2 = HEAPF32[$0 + 68 >> 2]; + HEAPF64[$1 + 120 >> 3] = HEAPF32[$0 + 72 >> 2]; + HEAPF64[$1 + 112 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14265, $1 + 112 | 0); + $2 = HEAPF32[$0 + 76 >> 2]; + HEAPF64[$1 + 104 >> 3] = HEAPF32[$0 + 80 >> 2]; + HEAPF64[$1 + 96 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14158, $1 + 96 | 0); + HEAPF64[$1 + 80 >> 3] = HEAPF32[$0 + 120 >> 2]; + b2Dump_28char_20const__2c_20____29(13167, $1 + 80 | 0); + HEAP32[$1 + 64 >> 2] = HEAP8[$0 + 116 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14660, $1 - -64 | 0); + HEAPF64[$1 + 48 >> 3] = HEAPF32[$0 + 124 >> 2]; + b2Dump_28char_20const__2c_20____29(13117, $1 + 48 | 0); + HEAPF64[$1 + 32 >> 3] = HEAPF32[$0 + 128 >> 2]; + b2Dump_28char_20const__2c_20____29(13142, $1 + 32 | 0); + HEAP32[$1 + 16 >> 2] = HEAP8[$0 + 104 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14715, $1 + 16 | 0); + HEAPF64[$1 >> 3] = HEAPF32[$0 + 112 >> 2]; + b2Dump_28char_20const__2c_20____29(13274, $1); + HEAPF64[$1 + 176 >> 3] = HEAPF32[$0 + 108 >> 2]; + b2Dump_28char_20const__2c_20____29(13068, $1 + 176 | 0); + HEAP32[$1 + 192 >> 2] = HEAP32[$0 + 56 >> 2]; + b2Dump_28char_20const__2c_20____29(14538, $1 + 192 | 0); + __stack_pointer = $1 + 208 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______append_28unsigned_20long_2c_20int_20const__29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 48 | 0; + __stack_pointer = $3; + HEAP32[$3 + 44 >> 2] = $0; + HEAP32[$3 + 40 >> 2] = $1; + HEAP32[$3 + 36 >> 2] = $2; + $0 = HEAP32[$3 + 44 >> 2]; + label$1: { + if (HEAP32[std____2__vector_int_2c_20std____2__allocator_int______end_cap_5babi_v160004_5d_28_29($0) >> 2] - HEAP32[$0 + 4 >> 2] >> 2 >>> 0 >= HEAPU32[$3 + 40 >> 2]) { + std____2__vector_int_2c_20std____2__allocator_int______construct_at_end_28unsigned_20long_2c_20int_20const__29($0, HEAP32[$3 + 40 >> 2], HEAP32[$3 + 36 >> 2]); + break label$1; + } + wasm2js_i32$0 = $3, wasm2js_i32$1 = std____2__vector_int_2c_20std____2__allocator_int______alloc_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 32 >> 2] = wasm2js_i32$1; + std____2____split_buffer_int_2c_20std____2__allocator_int_______split_buffer_28unsigned_20long_2c_20unsigned_20long_2c_20std____2__allocator_int___29($3 + 12 | 0, std____2__vector_int_2c_20std____2__allocator_int______recommend_5babi_v160004_5d_28unsigned_20long_29_20const($0, std____2__vector_int_2c_20std____2__allocator_int____size_5babi_v160004_5d_28_29_20const($0) + HEAP32[$3 + 40 >> 2] | 0), std____2__vector_int_2c_20std____2__allocator_int____size_5babi_v160004_5d_28_29_20const($0), HEAP32[$3 + 32 >> 2]); + std____2____split_buffer_int_2c_20std____2__allocator_int_______construct_at_end_28unsigned_20long_2c_20int_20const__29($3 + 12 | 0, HEAP32[$3 + 40 >> 2], HEAP32[$3 + 36 >> 2]); + std____2__vector_int_2c_20std____2__allocator_int______swap_out_circular_buffer_28std____2____split_buffer_int_2c_20std____2__allocator_int_____29($0, $3 + 12 | 0); + std____2____split_buffer_int_2c_20std____2__allocator_int________split_buffer_28_29($3 + 12 | 0); + } + __stack_pointer = $3 + 48 | 0; +} + +function emscripten__internal__MethodInvoker_float_20_28b2RayCastCallback____29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29_2c_20float_2c_20b2RayCastCallback__2c_20unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float___invoke_28float_20_28b2RayCastCallback____20const__29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29_2c_20b2RayCastCallback__2c_20unsigned_20int_2c_20b2Vec2__2c_20b2Vec2__2c_20float_29($0, $1, $2, $3, $4, $5) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + $5 = Math_fround($5); + var $6 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $6 = __stack_pointer - 32 | 0; + __stack_pointer = $6; + HEAP32[$6 + 28 >> 2] = $0; + HEAP32[$6 + 24 >> 2] = $1; + HEAP32[$6 + 20 >> 2] = $2; + HEAP32[$6 + 16 >> 2] = $3; + HEAP32[$6 + 12 >> 2] = $4; + HEAPF32[$6 + 8 >> 2] = $5; + $2 = emscripten__internal__BindingType_b2RayCastCallback__2c_20void___fromWireType_28b2RayCastCallback__29(HEAP32[$6 + 24 >> 2]); + $0 = HEAP32[$6 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $6, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$6 + 20 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$6 + 16 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$6 + 12 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$6 + 8 >> 2]))), + HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $5 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($6 + 4 | 0); + __stack_pointer = $6 + 32 | 0; + return Math_fround($5); +} + +function memmove($0, $1, $2) { + var $3 = 0, $4 = 0; + label$1: { + if (($0 | 0) == ($1 | 0)) { + break label$1; + } + $3 = $0 + $2 | 0; + if ($1 - $3 >>> 0 <= 0 - ($2 << 1) >>> 0) { + return __memcpy($0, $1, $2); + } + $4 = ($0 ^ $1) & 3; + label$3: { + label$4: { + if ($0 >>> 0 < $1 >>> 0) { + if ($4) { + $3 = $0; + break label$3; + } + if (!($0 & 3)) { + $3 = $0; + break label$4; + } + $3 = $0; + while (1) { + if (!$2) { + break label$1; + } + HEAP8[$3 | 0] = HEAPU8[$1 | 0]; + $1 = $1 + 1 | 0; + $2 = $2 - 1 | 0; + $3 = $3 + 1 | 0; + if ($3 & 3) { + continue; + } + break; + } + break label$4; + } + label$9: { + if ($4) { + break label$9; + } + if ($3 & 3) { + while (1) { + if (!$2) { + break label$1; + } + $2 = $2 - 1 | 0; + $3 = $2 + $0 | 0; + HEAP8[$3 | 0] = HEAPU8[$1 + $2 | 0]; + if ($3 & 3) { + continue; + } + break; + } + } + if ($2 >>> 0 <= 3) { + break label$9; + } + while (1) { + $2 = $2 - 4 | 0; + HEAP32[$2 + $0 >> 2] = HEAP32[$1 + $2 >> 2]; + if ($2 >>> 0 > 3) { + continue; + } + break; + } + } + if (!$2) { + break label$1; + } + while (1) { + $2 = $2 - 1 | 0; + HEAP8[$2 + $0 | 0] = HEAPU8[$1 + $2 | 0]; + if ($2) { + continue; + } + break; + } + break label$1; + } + if ($2 >>> 0 <= 3) { + break label$3; + } + while (1) { + HEAP32[$3 >> 2] = HEAP32[$1 >> 2]; + $1 = $1 + 4 | 0; + $3 = $3 + 4 | 0; + $2 = $2 - 4 | 0; + if ($2 >>> 0 > 3) { + continue; + } + break; + } + } + if (!$2) { + break label$1; + } + while (1) { + HEAP8[$3 | 0] = HEAPU8[$1 | 0]; + $3 = $3 + 1 | 0; + $1 = $1 + 1 | 0; + $2 = $2 - 1 | 0; + if ($2) { + continue; + } + break; + } + } + return $0; +} + +function b2ContactFilter__ShouldCollide_28b2Fixture__2c_20b2Fixture__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 48 | 0; + __stack_pointer = $3; + HEAP32[$3 + 40 >> 2] = $0; + HEAP32[$3 + 36 >> 2] = $1; + HEAP32[$3 + 32 >> 2] = $2; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$3 + 36 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$3 + 32 >> 2]), + HEAP32[wasm2js_i32$0 + 24 >> 2] = wasm2js_i32$1; + label$1: { + label$2: { + if (b2Body__GetType_28_29_20const(HEAP32[$3 + 24 >> 2])) { + break label$2; + } + if (b2Body__GetType_28_29_20const(HEAP32[$3 + 28 >> 2])) { + break label$2; + } + HEAP8[$3 + 47 | 0] = 0; + break label$1; + } + if (!(b2Body__ShouldCollideConnected_28b2Body_20const__29_20const(HEAP32[$3 + 24 >> 2], HEAP32[$3 + 28 >> 2]) & 1)) { + HEAP8[$3 + 47 | 0] = 0; + break label$1; + } + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Fixture__GetFilterData_28_29_20const(HEAP32[$3 + 36 >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Fixture__GetFilterData_28_29_20const(HEAP32[$3 + 32 >> 2]), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + if (!(!HEAPU16[HEAP32[$3 + 20 >> 2] + 4 >> 1] | HEAPU16[HEAP32[$3 + 20 >> 2] + 4 >> 1] != HEAPU16[HEAP32[$3 + 16 >> 2] + 4 >> 1])) { + HEAP8[$3 + 47 | 0] = HEAPU16[HEAP32[$3 + 20 >> 2] + 4 >> 1] << 16 >> 16 > 0; + break label$1; + } + $4 = HEAPU16[HEAP32[$3 + 20 >> 2] + 2 >> 1] & HEAPU16[HEAP32[$3 + 16 >> 2] >> 1] ? (HEAPU16[HEAP32[$3 + 20 >> 2] >> 1] & HEAPU16[HEAP32[$3 + 16 >> 2] + 2 >> 1]) != 0 : $4; + HEAP8[$3 + 15 | 0] = $4; + HEAP8[$3 + 47 | 0] = HEAP8[$3 + 15 | 0] & 1; + } + __stack_pointer = $3 + 48 | 0; + return HEAP8[$3 + 47 | 0] & 1; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29___invoke_b2Draw_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 490; + $0 = emscripten__internal__TypeID_b2Draw_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Draw____emscripten__internal__getContext_void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29__28void_20_28b2Draw____20const__29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29_29_29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______insert_node_at_28std____2____tree_end_node_std____2____tree_node_base_void______2c_20std____2____tree_node_base_void_____2c_20std____2____tree_node_base_void____29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $0 = HEAP32[$4 + 12 >> 2]; + HEAP32[HEAP32[$4 >> 2] >> 2] = 0; + HEAP32[HEAP32[$4 >> 2] + 4 >> 2] = 0; + HEAP32[HEAP32[$4 >> 2] + 8 >> 2] = HEAP32[$4 + 8 >> 2]; + HEAP32[HEAP32[$4 + 4 >> 2] >> 2] = HEAP32[$4 >> 2]; + if (HEAP32[HEAP32[std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______begin_node_5babi_v160004_5d_28_29($0) >> 2] >> 2]) { + $1 = HEAP32[HEAP32[std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______begin_node_5babi_v160004_5d_28_29($0) >> 2] >> 2]; + wasm2js_i32$0 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______begin_node_5babi_v160004_5d_28_29($0), + wasm2js_i32$1 = $1, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + } + void_20std____2____tree_balance_after_insert_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____2c_20std____2____tree_node_base_void____29(HEAP32[std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______end_node_5babi_v160004_5d_28_29($0) >> 2], HEAP32[HEAP32[$4 + 4 >> 2] >> 2]); + $0 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____size_5babi_v160004_5d_28_29($0); + HEAP32[$0 >> 2] = HEAP32[$0 >> 2] + 1; + __stack_pointer = $4 + 16 | 0; +} + +function b2CollideCircles_28b2Manifold__2c_20b2CircleShape_20const__2c_20b2Transform_20const__2c_20b2CircleShape_20const__2c_20b2Transform_20const__29($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $5 = __stack_pointer + -64 | 0; + __stack_pointer = $5; + HEAP32[$5 + 60 >> 2] = $0; + HEAP32[$5 + 56 >> 2] = $1; + HEAP32[$5 + 52 >> 2] = $2; + HEAP32[$5 + 48 >> 2] = $3; + HEAP32[$5 + 44 >> 2] = $4; + HEAP32[HEAP32[$5 + 60 >> 2] + 60 >> 2] = 0; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 36 | 0, HEAP32[$5 + 52 >> 2], HEAP32[$5 + 56 >> 2] + 12 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($5 + 28 | 0, HEAP32[$5 + 44 >> 2], HEAP32[$5 + 48 >> 2] + 12 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($5 + 20 | 0, $5 + 28 | 0, $5 + 36 | 0); + $0 = $5 + 20 | 0; + wasm2js_i32$0 = $5, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $0), + HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0; + HEAPF32[$5 + 12 >> 2] = HEAPF32[HEAP32[$5 + 56 >> 2] + 8 >> 2]; + HEAPF32[$5 + 8 >> 2] = HEAPF32[HEAP32[$5 + 48 >> 2] + 8 >> 2]; + HEAPF32[$5 + 4 >> 2] = HEAPF32[$5 + 12 >> 2] + HEAPF32[$5 + 8 >> 2]; + if (!(HEAPF32[$5 + 16 >> 2] > Math_fround(HEAPF32[$5 + 4 >> 2] * HEAPF32[$5 + 4 >> 2]))) { + HEAP32[HEAP32[$5 + 60 >> 2] + 56 >> 2] = 0; + $2 = HEAP32[$5 + 56 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$2 + 16 >> 2]; + $2 = $0; + $0 = HEAP32[$5 + 60 >> 2]; + HEAP32[$0 + 48 >> 2] = $2; + HEAP32[$0 + 52 >> 2] = $1; + b2Vec2__SetZero_28_29(HEAP32[$5 + 60 >> 2] + 40 | 0); + HEAP32[HEAP32[$5 + 60 >> 2] + 60 >> 2] = 1; + $2 = HEAP32[$5 + 48 >> 2]; + $1 = HEAP32[$2 + 12 >> 2]; + $0 = HEAP32[$2 + 16 >> 2]; + $2 = $1; + $1 = HEAP32[$5 + 60 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + HEAP32[HEAP32[$5 + 60 >> 2] + 16 >> 2] = 0; + } + __stack_pointer = $5 - -64 | 0; +} + +function std____2__pair_char_20const__2c_20char___20std____2____unwrap_and_dispatch_5babi_v160004_5d_std____2____overload_std____2____copy_loop_std____2___ClassicAlgPolicy__2c_20std____2____copy_trivial__2c_20char_20const__2c_20char_20const__2c_20char__2c_200__28char_20const__2c_20char_20const__2c_20char__29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + auto_20std____2____unwrap_range_5babi_v160004_5d_char_20const__2c_20char_20const___28char_20const__2c_20char_20const__29($4 + 24 | 0, $1, $2); + std____2__pair_char_20const__2c_20char___20std____2____copy_trivial__operator_28_29_5babi_v160004_5d_char_20const_2c_20char_2c_200__28char_20const__2c_20char_20const__2c_20char__29_20const($4 + 16 | 0, $4 + 12 | 0, HEAP32[$4 + 24 >> 2], HEAP32[$4 + 28 >> 2], decltype_28std____2____unwrap_iter_impl_char__2c_20true_____unwrap_28std__declval_char___28_29_29_29_20std____2____unwrap_iter_5babi_v160004_5d_char__2c_20std____2____unwrap_iter_impl_char__2c_20true__2c_200__28char__29($3)); + wasm2js_i32$0 = $4, wasm2js_i32$1 = char_20const__20std____2____rewrap_range_5babi_v160004_5d_char_20const__2c_20char_20const__2c_20char_20const___28char_20const__2c_20char_20const__29($1, HEAP32[$4 + 16 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $4, wasm2js_i32$1 = char__20std____2____rewrap_iter_5babi_v160004_5d_char__2c_20char__2c_20std____2____unwrap_iter_impl_char__2c_20true___28char__2c_20char__29($3, HEAP32[$4 + 20 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + std____2__pair_std____2____unwrap_ref_decay_char_20const____type_2c_20std____2____unwrap_ref_decay_char____type__20std____2__make_pair_5babi_v160004_5d_char_20const__2c_20char___28char_20const____2c_20char____29($0, $4 + 12 | 0, $4 + 8 | 0); + __stack_pointer = $4 + 32 | 0; +} + +function b2WorldRayCastWrapper__RayCastCallback_28b2RayCastInput_20const__2c_20int_29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 80 | 0; + __stack_pointer = $3; + HEAP32[$3 + 72 >> 2] = $0; + HEAP32[$3 + 68 >> 2] = $1; + HEAP32[$3 + 64 >> 2] = $2; + $0 = HEAP32[$3 + 72 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2BroadPhase__GetUserData_28int_29_20const(HEAP32[$0 >> 2], HEAP32[$3 + 64 >> 2]), + HEAP32[wasm2js_i32$0 + 60 >> 2] = wasm2js_i32$1; + HEAP32[$3 + 56 >> 2] = HEAP32[$3 + 60 >> 2]; + HEAP32[$3 + 52 >> 2] = HEAP32[HEAP32[$3 + 56 >> 2] + 16 >> 2]; + HEAP32[$3 + 48 >> 2] = HEAP32[HEAP32[$3 + 56 >> 2] + 20 >> 2]; + b2RayCastOutput__b2RayCastOutput_28_29($3 + 36 | 0); + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2Fixture__RayCast_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const(HEAP32[$3 + 52 >> 2], $3 + 36 | 0, HEAP32[$3 + 68 >> 2], HEAP32[$3 + 48 >> 2]) & 1, + HEAP8[wasm2js_i32$0 + 35 | 0] = wasm2js_i32$1; + label$1: { + if (HEAP8[$3 + 35 | 0] & 1) { + HEAPF32[$3 + 28 >> 2] = HEAPF32[$3 + 44 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($3 + 12 | 0, Math_fround(Math_fround(1) - HEAPF32[$3 + 28 >> 2]), HEAP32[$3 + 68 >> 2]); + operator__28float_2c_20b2Vec2_20const__29($3 + 4 | 0, HEAPF32[$3 + 28 >> 2], HEAP32[$3 + 68 >> 2] + 8 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 20 | 0, $3 + 12 | 0, $3 + 4 | 0); + $0 = HEAP32[$0 + 4 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 8 >> 2]]($0, HEAP32[$3 + 52 >> 2], $3 + 20 | 0, $3 + 36 | 0, HEAPF32[$3 + 28 >> 2])), + HEAPF32[wasm2js_i32$0 + 76 >> 2] = wasm2js_f32$0; + break label$1; + } + HEAPF32[$3 + 76 >> 2] = HEAPF32[HEAP32[$3 + 68 >> 2] + 16 >> 2]; + } + __stack_pointer = $3 + 80 | 0; + return HEAPF32[$3 + 76 >> 2]; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 515; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_20const__2c_20b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_20const__2c_20b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const__28void_20_28b2World____20const__29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const_29_29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2PulleyJoint__b2PulleyJoint_28b2PulleyJointDef_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 4 >> 2] = $1; + $1 = HEAP32[$2 + 8 >> 2]; + HEAP32[$2 + 12 >> 2] = $1; + b2Joint__b2Joint_28b2JointDef_20const__29($1, HEAP32[$2 + 4 >> 2]); + HEAP32[$1 >> 2] = 19272; + b2Vec2__b2Vec2_28_29($1 + 68 | 0); + b2Vec2__b2Vec2_28_29($1 + 76 | 0); + b2Vec2__b2Vec2_28_29($1 + 92 | 0); + b2Vec2__b2Vec2_28_29($1 + 100 | 0); + b2Vec2__b2Vec2_28_29($1 + 128 | 0); + b2Vec2__b2Vec2_28_29($1 + 136 | 0); + b2Vec2__b2Vec2_28_29($1 + 144 | 0); + b2Vec2__b2Vec2_28_29($1 + 152 | 0); + b2Vec2__b2Vec2_28_29($1 + 160 | 0); + b2Vec2__b2Vec2_28_29($1 + 168 | 0); + $3 = HEAP32[$2 + 4 >> 2]; + $4 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$1 + 68 >> 2] = $4; + HEAP32[$1 + 72 >> 2] = $0; + $3 = HEAP32[$2 + 4 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $4 = HEAP32[$3 + 32 >> 2]; + HEAP32[$1 + 76 >> 2] = $0; + HEAP32[$1 + 80 >> 2] = $4; + $3 = HEAP32[$2 + 4 >> 2]; + $4 = HEAP32[$3 + 36 >> 2]; + $0 = HEAP32[$3 + 40 >> 2]; + HEAP32[$1 + 92 >> 2] = $4; + HEAP32[$1 + 96 >> 2] = $0; + $3 = HEAP32[$2 + 4 >> 2]; + $0 = HEAP32[$3 + 44 >> 2]; + $4 = HEAP32[$3 + 48 >> 2]; + HEAP32[$1 + 100 >> 2] = $0; + HEAP32[$1 + 104 >> 2] = $4; + HEAPF32[$1 + 84 >> 2] = HEAPF32[HEAP32[$2 + 4 >> 2] + 52 >> 2]; + HEAPF32[$1 + 88 >> 2] = HEAPF32[HEAP32[$2 + 4 >> 2] + 56 >> 2]; + if (HEAPF32[HEAP32[$2 + 4 >> 2] + 60 >> 2] == Math_fround(0)) { + __assert_fail(8571, 4160, 69, 2524); + wasm2js_trap(); + } + HEAPF32[$1 + 112 >> 2] = HEAPF32[HEAP32[$2 + 4 >> 2] + 60 >> 2]; + HEAPF32[$1 + 108 >> 2] = Math_fround(HEAPF32[$1 + 112 >> 2] * HEAPF32[HEAP32[$2 + 4 >> 2] + 56 >> 2]) + HEAPF32[HEAP32[$2 + 4 >> 2] + 52 >> 2]; + HEAPF32[$1 + 116 >> 2] = 0; + __stack_pointer = $2 + 16 | 0; + return HEAP32[$2 + 12 >> 2]; +} + +function b2WheelJoint__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 192 | 0; + __stack_pointer = $1; + HEAP32[$1 + 188 >> 2] = $0; + $0 = HEAP32[$1 + 188 >> 2]; + HEAP32[$1 + 184 >> 2] = HEAP32[HEAP32[$0 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 180 >> 2] = HEAP32[HEAP32[$0 + 52 >> 2] + 8 >> 2]; + b2Dump_28char_20const__2c_20____29(13564, 0); + HEAP32[$1 + 144 >> 2] = HEAP32[$1 + 184 >> 2]; + b2Dump_28char_20const__2c_20____29(13849, $1 + 144 | 0); + HEAP32[$1 + 128 >> 2] = HEAP32[$1 + 180 >> 2]; + b2Dump_28char_20const__2c_20____29(13823, $1 + 128 | 0); + HEAP32[$1 + 112 >> 2] = HEAP8[$0 + 61 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14859, $1 + 112 | 0); + $2 = HEAPF32[$0 + 68 >> 2]; + HEAPF64[$1 + 104 >> 3] = HEAPF32[$0 + 72 >> 2]; + HEAPF64[$1 + 96 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14265, $1 + 96 | 0); + $2 = HEAPF32[$0 + 76 >> 2]; + HEAPF64[$1 + 88 >> 3] = HEAPF32[$0 + 80 >> 2]; + HEAPF64[$1 + 80 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14158, $1 + 80 | 0); + $2 = HEAPF32[$0 + 84 >> 2]; + HEAPF64[$1 + 72 >> 3] = HEAPF32[$0 + 88 >> 2]; + HEAPF64[$1 + 64 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14231, $1 - -64 | 0); + HEAP32[$1 + 48 >> 2] = HEAP8[$0 + 141 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14715, $1 + 48 | 0); + HEAPF64[$1 + 32 >> 3] = HEAPF32[$0 + 136 >> 2]; + b2Dump_28char_20const__2c_20____29(13274, $1 + 32 | 0); + HEAPF64[$1 + 16 >> 3] = HEAPF32[$0 + 132 >> 2]; + b2Dump_28char_20const__2c_20____29(13068, $1 + 16 | 0); + HEAPF64[$1 >> 3] = HEAPF32[$0 + 144 >> 2]; + b2Dump_28char_20const__2c_20____29(12730, $1); + HEAPF64[$1 + 160 >> 3] = HEAPF32[$0 + 148 >> 2]; + b2Dump_28char_20const__2c_20____29(12965, $1 + 160 | 0); + HEAP32[$1 + 176 >> 2] = HEAP32[$0 + 56 >> 2]; + b2Dump_28char_20const__2c_20____29(14538, $1 + 176 | 0); + __stack_pointer = $1 + 192 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29___invoke_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28char_20const__2c_20bool_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 707; + $0 = emscripten__internal__TypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28__emscripten__internal__getContext_bool_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29__28bool_20_28__20const__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29_29_29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodCaller_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____call_28emscripten___EM_VAL__2c_20char_20const__2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float__29($0, $1, $2, $3, $4, $5) { + var $6 = 0, $7 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_f64$0 = 0; + $6 = __stack_pointer - 96 | 0; + __stack_pointer = $6; + HEAP32[$6 + 92 >> 2] = $0; + HEAP32[$6 + 88 >> 2] = $1; + HEAP32[$6 + 84 >> 2] = $2; + HEAP32[$6 + 80 >> 2] = $3; + HEAP32[$6 + 76 >> 2] = $4; + HEAP32[$6 + 72 >> 2] = $5; + wasm2js_i32$0 = $6, wasm2js_i32$1 = emscripten__internal__Signature_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____get_method_caller_28_29(), + HEAP32[wasm2js_i32$0 + 68 >> 2] = wasm2js_i32$1; + emscripten__internal__WireTypePack_unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____WireTypePack_28unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float__29($6 + 32 | 0, HEAP32[$6 + 84 >> 2], HEAP32[$6 + 80 >> 2], HEAP32[$6 + 76 >> 2], HEAP32[$6 + 72 >> 2]); + wasm2js_i32$0 = $6, wasm2js_f64$0 = +_emval_call_method(HEAP32[$6 + 68 >> 2], HEAP32[$6 + 92 >> 2], HEAP32[$6 + 88 >> 2], $6 + 28 | 0, emscripten__internal__WireTypePack_unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____operator_20void_20const__28_29_20const($6 + 32 | 0) | 0), + HEAPF64[wasm2js_i32$0 + 16 >> 3] = wasm2js_f64$0; + emscripten__internal__DestructorsRunner__DestructorsRunner_28emscripten__internal___EM_DESTRUCTORS__29($6 + 12 | 0, HEAP32[$6 + 28 >> 2]); + $7 = float_20emscripten__internal__fromGenericWireType_float__28double_29(HEAPF64[$6 + 16 >> 3]); + emscripten__internal__DestructorsRunner___DestructorsRunner_28_29($6 + 12 | 0); + __stack_pointer = $6 + 96 | 0; + return $7; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Fixture____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const___invoke_b2Fixture_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2Fixture____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 570; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2Fixture____emscripten__internal__getContext_bool_20_28b2Fixture____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const__28bool_20_28b2Fixture____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const_29_29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28_29_20const___invoke_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28char_20const__2c_20unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 705; + $0 = emscripten__internal__TypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_unsigned_20long_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_unsigned_20long_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______emscripten__internal__getContext_unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28_29_20const__28unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28b2Vec2_20const__29___invoke_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28char_20const__2c_20void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28b2Vec2_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 703; + $0 = emscripten__internal__TypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20b2Vec2_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______emscripten__internal__getContext_void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28b2Vec2_20const__29__28void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______20const__29_28b2Vec2_20const__29_29_29_28b2Vec2_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_emscripten__val_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29___invoke_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28char_20const__2c_20emscripten__val_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 706; + $0 = emscripten__internal__TypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long___getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], emscripten__val_20_28__emscripten__internal__getContext_emscripten__val_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29__28emscripten__val_20_28__20const__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29_29_29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20b2DynamicTree__Query_b2WorldQueryWrapper__28b2WorldQueryWrapper__2c_20b2AABB_20const__29_20const($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 1072 | 0; + __stack_pointer = $3; + HEAP32[$3 + 1068 >> 2] = $0; + HEAP32[$3 + 1064 >> 2] = $1; + HEAP32[$3 + 1060 >> 2] = $2; + $0 = HEAP32[$3 + 1068 >> 2]; + b2GrowableStack_int_2c_20256___b2GrowableStack_28_29($3 + 24 | 0); + b2GrowableStack_int_2c_20256___Push_28int_20const__29($3 + 24 | 0, $0); + label$1: { + while (1) { + if ((b2GrowableStack_int_2c_20256___GetCount_28_29($3 + 24 | 0) | 0) > 0) { + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2GrowableStack_int_2c_20256___Pop_28_29($3 + 24 | 0), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + if (HEAP32[$3 + 20 >> 2] == -1) { + continue; + } + HEAP32[$3 + 16 >> 2] = HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$3 + 20 >> 2], 40); + if (b2TestOverlap_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$3 + 16 >> 2], HEAP32[$3 + 1060 >> 2]) & 1) { + label$5: { + if (b2TreeNode__IsLeaf_28_29_20const(HEAP32[$3 + 16 >> 2]) & 1) { + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2WorldQueryWrapper__QueryCallback_28int_29(HEAP32[$3 + 1064 >> 2], HEAP32[$3 + 20 >> 2]) & 1, + HEAP8[wasm2js_i32$0 + 15 | 0] = wasm2js_i32$1; + if (!(HEAP8[$3 + 15 | 0] & 1)) { + HEAP32[$3 + 8 >> 2] = 1; + break label$1; + } + break label$5; + } + b2GrowableStack_int_2c_20256___Push_28int_20const__29($3 + 24 | 0, HEAP32[$3 + 16 >> 2] + 24 | 0); + b2GrowableStack_int_2c_20256___Push_28int_20const__29($3 + 24 | 0, HEAP32[$3 + 16 >> 2] + 28 | 0); + } + } + continue; + } + break; + } + HEAP32[$3 + 8 >> 2] = 0; + } + b2GrowableStack_int_2c_20256____b2GrowableStack_28_29($3 + 24 | 0); + __stack_pointer = $3 + 1072 | 0; +} + +function b2Body__SetEnabled_28bool_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP8[$2 + 27 | 0] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + if (b2World__IsLocked_28_29_20const(HEAP32[$0 + 88 >> 2]) & 1) { + __assert_fail(9124, 4100, 483, 10253); + wasm2js_trap(); + } + label$2: { + if ((HEAP8[$2 + 27 | 0] & 1) == (b2Body__IsEnabled_28_29_20const($0) & 1)) { + break label$2; + } + if (HEAP8[$2 + 27 | 0] & 1) { + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] | 32; + HEAP32[$2 + 20 >> 2] = HEAP32[$0 + 88 >> 2] + 102868; + HEAP32[$2 + 16 >> 2] = HEAP32[$0 + 100 >> 2]; + while (1) { + if (HEAP32[$2 + 16 >> 2]) { + b2Fixture__CreateProxies_28b2BroadPhase__2c_20b2Transform_20const__29(HEAP32[$2 + 16 >> 2], HEAP32[$2 + 20 >> 2], $0 + 12 | 0); + HEAP32[$2 + 16 >> 2] = HEAP32[HEAP32[$2 + 16 >> 2] + 4 >> 2]; + continue; + } + break; + } + HEAP8[HEAP32[$0 + 88 >> 2] + 102988 | 0] = 1; + break label$2; + } + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] & -33; + HEAP32[$2 + 12 >> 2] = HEAP32[$0 + 88 >> 2] + 102868; + HEAP32[$2 + 8 >> 2] = HEAP32[$0 + 100 >> 2]; + while (1) { + if (HEAP32[$2 + 8 >> 2]) { + b2Fixture__DestroyProxies_28b2BroadPhase__29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2]); + HEAP32[$2 + 8 >> 2] = HEAP32[HEAP32[$2 + 8 >> 2] + 4 >> 2]; + continue; + } + break; + } + HEAP32[$2 + 4 >> 2] = HEAP32[$0 + 112 >> 2]; + while (1) { + if (HEAP32[$2 + 4 >> 2]) { + HEAP32[$2 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$2 + 4 >> 2] = HEAP32[HEAP32[$2 + 4 >> 2] + 12 >> 2]; + b2ContactManager__Destroy_28b2Contact__29(HEAP32[$0 + 88 >> 2] + 102868 | 0, HEAP32[HEAP32[$2 >> 2] + 4 >> 2]); + continue; + } + break; + } + HEAP32[$0 + 112 >> 2] = 0; + } + __stack_pointer = $2 + 32 | 0; +} + +function b2PolygonShape__Validate_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0, $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer + -64 | 0; + __stack_pointer = $1; + HEAP32[$1 + 56 >> 2] = $0; + $0 = HEAP32[$1 + 56 >> 2]; + HEAP32[$1 + 52 >> 2] = 0; + label$1: { + while (1) { + if (HEAP32[$1 + 52 >> 2] < HEAP32[$0 + 148 >> 2]) { + HEAP32[$1 + 48 >> 2] = HEAP32[$1 + 52 >> 2]; + if (HEAP32[$1 + 52 >> 2] < (HEAP32[$0 + 148 >> 2] - 1 | 0)) { + $2 = HEAP32[$1 + 48 >> 2] + 1 | 0; + } else { + $2 = 0; + } + HEAP32[$1 + 44 >> 2] = $2; + $2 = ($0 + 20 | 0) + (HEAP32[$1 + 48 >> 2] << 3) | 0; + $3 = HEAP32[$2 + 4 >> 2]; + HEAP32[$1 + 32 >> 2] = HEAP32[$2 >> 2]; + HEAP32[$1 + 36 >> 2] = $3; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 24 | 0, ($0 + 20 | 0) + (HEAP32[$1 + 44 >> 2] << 3) | 0, $1 + 32 | 0); + HEAP32[$1 + 20 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 20 >> 2] < HEAP32[$0 + 148 >> 2]) { + if (!(HEAP32[$1 + 20 >> 2] == HEAP32[$1 + 48 >> 2] | HEAP32[$1 + 20 >> 2] == HEAP32[$1 + 44 >> 2])) { + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 12 | 0, ($0 + 20 | 0) + (HEAP32[$1 + 20 >> 2] << 3) | 0, $1 + 32 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 24 | 0, $1 + 12 | 0), + HEAPF32[wasm2js_i32$0 + 8 >> 2] = wasm2js_f32$0; + if (HEAPF32[$1 + 8 >> 2] < Math_fround(0)) { + HEAP8[$1 + 63 | 0] = 0; + break label$1; + } + } + HEAP32[$1 + 20 >> 2] = HEAP32[$1 + 20 >> 2] + 1; + continue; + } + break; + } + HEAP32[$1 + 52 >> 2] = HEAP32[$1 + 52 >> 2] + 1; + continue; + } + break; + } + HEAP8[$1 + 63 | 0] = 1; + } + __stack_pointer = $1 - -64 | 0; + return HEAP8[$1 + 63 | 0] & 1; +} + +function void_20b2DynamicTree__Query_b2BroadPhase__28b2BroadPhase__2c_20b2AABB_20const__29_20const($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 1072 | 0; + __stack_pointer = $3; + HEAP32[$3 + 1068 >> 2] = $0; + HEAP32[$3 + 1064 >> 2] = $1; + HEAP32[$3 + 1060 >> 2] = $2; + $0 = HEAP32[$3 + 1068 >> 2]; + b2GrowableStack_int_2c_20256___b2GrowableStack_28_29($3 + 24 | 0); + b2GrowableStack_int_2c_20256___Push_28int_20const__29($3 + 24 | 0, $0); + label$1: { + while (1) { + if ((b2GrowableStack_int_2c_20256___GetCount_28_29($3 + 24 | 0) | 0) > 0) { + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2GrowableStack_int_2c_20256___Pop_28_29($3 + 24 | 0), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + if (HEAP32[$3 + 20 >> 2] == -1) { + continue; + } + HEAP32[$3 + 16 >> 2] = HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$3 + 20 >> 2], 40); + if (b2TestOverlap_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$3 + 16 >> 2], HEAP32[$3 + 1060 >> 2]) & 1) { + label$5: { + if (b2TreeNode__IsLeaf_28_29_20const(HEAP32[$3 + 16 >> 2]) & 1) { + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2BroadPhase__QueryCallback_28int_29(HEAP32[$3 + 1064 >> 2], HEAP32[$3 + 20 >> 2]) & 1, + HEAP8[wasm2js_i32$0 + 15 | 0] = wasm2js_i32$1; + if (!(HEAP8[$3 + 15 | 0] & 1)) { + HEAP32[$3 + 8 >> 2] = 1; + break label$1; + } + break label$5; + } + b2GrowableStack_int_2c_20256___Push_28int_20const__29($3 + 24 | 0, HEAP32[$3 + 16 >> 2] + 24 | 0); + b2GrowableStack_int_2c_20256___Push_28int_20const__29($3 + 24 | 0, HEAP32[$3 + 16 >> 2] + 28 | 0); + } + } + continue; + } + break; + } + HEAP32[$3 + 8 >> 2] = 0; + } + b2GrowableStack_int_2c_20256____b2GrowableStack_28_29($3 + 24 | 0); + __stack_pointer = $3 + 1072 | 0; +} + +function __stdio_write($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + $3 = HEAP32[$0 + 28 >> 2]; + HEAP32[$4 + 16 >> 2] = $3; + $5 = HEAP32[$0 + 20 >> 2]; + HEAP32[$4 + 28 >> 2] = $2; + HEAP32[$4 + 24 >> 2] = $1; + $1 = $5 - $3 | 0; + HEAP32[$4 + 20 >> 2] = $1; + $7 = $1 + $2 | 0; + $3 = $4 + 16 | 0; + $8 = 2; + label$1: { + label$2: { + label$3: { + label$4: { + if (__wasi_syscall_ret(__wasi_fd_write(HEAP32[$0 + 60 >> 2], $4 + 16 | 0, 2, $4 + 12 | 0) | 0)) { + $5 = $3; + break label$4; + } + while (1) { + $1 = HEAP32[$4 + 12 >> 2]; + if (($7 | 0) == ($1 | 0)) { + break label$3; + } + if (($1 | 0) < 0) { + $5 = $3; + break label$2; + } + $6 = HEAP32[$3 + 4 >> 2]; + $9 = $6 >>> 0 < $1 >>> 0; + $5 = ($9 << 3) + $3 | 0; + $6 = $1 - ($9 ? $6 : 0) | 0; + HEAP32[$5 >> 2] = $6 + HEAP32[$5 >> 2]; + $3 = ($9 ? 12 : 4) + $3 | 0; + HEAP32[$3 >> 2] = HEAP32[$3 >> 2] - $6; + $7 = $7 - $1 | 0; + $3 = $5; + $8 = $8 - $9 | 0; + if (!__wasi_syscall_ret(__wasi_fd_write(HEAP32[$0 + 60 >> 2], $3 | 0, $8 | 0, $4 + 12 | 0) | 0)) { + continue; + } + break; + } + } + if (($7 | 0) != -1) { + break label$2; + } + } + $1 = HEAP32[$0 + 44 >> 2]; + HEAP32[$0 + 28 >> 2] = $1; + HEAP32[$0 + 20 >> 2] = $1; + HEAP32[$0 + 16 >> 2] = HEAP32[$0 + 48 >> 2] + $1; + $1 = $2; + break label$1; + } + HEAP32[$0 + 28 >> 2] = 0; + HEAP32[$0 + 16 >> 2] = 0; + HEAP32[$0 + 20 >> 2] = 0; + HEAP32[$0 >> 2] = HEAP32[$0 >> 2] | 32; + $1 = 0; + if (($8 | 0) == 2) { + break label$1; + } + $1 = $2 - HEAP32[$5 + 4 >> 2] | 0; + } + __stack_pointer = $4 + 32 | 0; + return $1 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2PolygonShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2PolygonShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2PolygonShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 553; + $0 = emscripten__internal__TypeID_b2PolygonShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2PolygonShape____emscripten__internal__getContext_void_20_28b2PolygonShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const__28void_20_28b2PolygonShape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2PulleyJoint__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 176 | 0; + __stack_pointer = $1; + HEAP32[$1 + 172 >> 2] = $0; + $0 = HEAP32[$1 + 172 >> 2]; + HEAP32[$1 + 168 >> 2] = HEAP32[HEAP32[$0 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 164 >> 2] = HEAP32[HEAP32[$0 + 52 >> 2] + 8 >> 2]; + b2Dump_28char_20const__2c_20____29(13469, 0); + HEAP32[$1 + 128 >> 2] = HEAP32[$1 + 168 >> 2]; + b2Dump_28char_20const__2c_20____29(13849, $1 + 128 | 0); + HEAP32[$1 + 112 >> 2] = HEAP32[$1 + 164 >> 2]; + b2Dump_28char_20const__2c_20____29(13823, $1 + 112 | 0); + HEAP32[$1 + 96 >> 2] = HEAP8[$0 + 61 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14859, $1 + 96 | 0); + $2 = HEAPF32[$0 + 68 >> 2]; + HEAPF64[$1 + 88 >> 3] = HEAPF32[$0 + 72 >> 2]; + HEAPF64[$1 + 80 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14301, $1 + 80 | 0); + $2 = HEAPF32[$0 + 76 >> 2]; + HEAPF64[$1 + 72 >> 3] = HEAPF32[$0 + 80 >> 2]; + HEAPF64[$1 + 64 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14194, $1 - -64 | 0); + $2 = HEAPF32[$0 + 92 >> 2]; + HEAPF64[$1 + 56 >> 3] = HEAPF32[$0 + 96 >> 2]; + HEAPF64[$1 + 48 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14265, $1 + 48 | 0); + $2 = HEAPF32[$0 + 100 >> 2]; + HEAPF64[$1 + 40 >> 3] = HEAPF32[$0 + 104 >> 2]; + HEAPF64[$1 + 32 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14158, $1 + 32 | 0); + HEAPF64[$1 + 16 >> 3] = HEAPF32[$0 + 84 >> 2]; + b2Dump_28char_20const__2c_20____29(13321, $1 + 16 | 0); + HEAPF64[$1 >> 3] = HEAPF32[$0 + 88 >> 2]; + b2Dump_28char_20const__2c_20____29(13299, $1); + HEAPF64[$1 + 144 >> 3] = HEAPF32[$0 + 112 >> 2]; + b2Dump_28char_20const__2c_20____29(12785, $1 + 144 | 0); + HEAP32[$1 + 160 >> 2] = HEAP32[$0 + 56 >> 2]; + b2Dump_28char_20const__2c_20____29(14538, $1 + 160 | 0); + __stack_pointer = $1 + 176 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2PolygonShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20bool_2c_20b2PolygonShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___invoke_28bool_20_28b2PolygonShape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2PolygonShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput__2c_20b2Transform__2c_20int_29($0, $1, $2, $3, $4, $5) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + $5 = $5 | 0; + var $6 = 0; + $6 = __stack_pointer - 32 | 0; + __stack_pointer = $6; + HEAP32[$6 + 28 >> 2] = $0; + HEAP32[$6 + 24 >> 2] = $1; + HEAP32[$6 + 20 >> 2] = $2; + HEAP32[$6 + 16 >> 2] = $3; + HEAP32[$6 + 12 >> 2] = $4; + HEAP32[$6 + 8 >> 2] = $5; + $2 = emscripten__internal__BindingType_b2PolygonShape_20const__2c_20void___fromWireType_28b2PolygonShape_20const__29(HEAP32[$6 + 24 >> 2]); + $0 = HEAP32[$6 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2RayCastOutput__2c_20void___fromWireType_28b2RayCastOutput__29(HEAP32[$6 + 20 >> 2]), emscripten__internal__GenericBindingType_b2RayCastInput___fromWireType_28b2RayCastInput__29(HEAP32[$6 + 16 >> 2]), emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$6 + 12 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$6 + 8 >> 2])) & 1); + __stack_pointer = $6 + 32 | 0; + return $0 & 1; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2CircleShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20bool_2c_20b2CircleShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___invoke_28bool_20_28b2CircleShape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2CircleShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput__2c_20b2Transform__2c_20int_29($0, $1, $2, $3, $4, $5) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + $5 = $5 | 0; + var $6 = 0; + $6 = __stack_pointer - 32 | 0; + __stack_pointer = $6; + HEAP32[$6 + 28 >> 2] = $0; + HEAP32[$6 + 24 >> 2] = $1; + HEAP32[$6 + 20 >> 2] = $2; + HEAP32[$6 + 16 >> 2] = $3; + HEAP32[$6 + 12 >> 2] = $4; + HEAP32[$6 + 8 >> 2] = $5; + $2 = emscripten__internal__BindingType_b2CircleShape_20const__2c_20void___fromWireType_28b2CircleShape_20const__29(HEAP32[$6 + 24 >> 2]); + $0 = HEAP32[$6 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2RayCastOutput__2c_20void___fromWireType_28b2RayCastOutput__29(HEAP32[$6 + 20 >> 2]), emscripten__internal__GenericBindingType_b2RayCastInput___fromWireType_28b2RayCastInput__29(HEAP32[$6 + 16 >> 2]), emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$6 + 12 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$6 + 8 >> 2])) & 1); + __stack_pointer = $6 + 32 | 0; + return $0 & 1; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2CircleShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2CircleShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2CircleShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 535; + $0 = emscripten__internal__TypeID_b2CircleShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2CircleShape____emscripten__internal__getContext_void_20_28b2CircleShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const__28void_20_28b2CircleShape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29___invoke_b2Draw_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Draw____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 491; + $0 = emscripten__internal__TypeID_b2Draw_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Draw____emscripten__internal__getContext_void_20_28b2Draw____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29__28void_20_28b2Draw____20const__29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29_29_29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28_29_20const___invoke_std____2__vector_int_2c_20std____2__allocator_int____28char_20const__2c_20unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 699; + $0 = emscripten__internal__TypeID_std____2__vector_int_2c_20std____2__allocator_int___2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_unsigned_20long_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int___20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_unsigned_20long_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int___20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______emscripten__internal__getContext_unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28_29_20const__28unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2EdgeShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20bool_2c_20b2EdgeShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___invoke_28bool_20_28b2EdgeShape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2EdgeShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput__2c_20b2Transform__2c_20int_29($0, $1, $2, $3, $4, $5) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + $5 = $5 | 0; + var $6 = 0; + $6 = __stack_pointer - 32 | 0; + __stack_pointer = $6; + HEAP32[$6 + 28 >> 2] = $0; + HEAP32[$6 + 24 >> 2] = $1; + HEAP32[$6 + 20 >> 2] = $2; + HEAP32[$6 + 16 >> 2] = $3; + HEAP32[$6 + 12 >> 2] = $4; + HEAP32[$6 + 8 >> 2] = $5; + $2 = emscripten__internal__BindingType_b2EdgeShape_20const__2c_20void___fromWireType_28b2EdgeShape_20const__29(HEAP32[$6 + 24 >> 2]); + $0 = HEAP32[$6 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2RayCastOutput__2c_20void___fromWireType_28b2RayCastOutput__29(HEAP32[$6 + 20 >> 2]), emscripten__internal__GenericBindingType_b2RayCastInput___fromWireType_28b2RayCastInput__29(HEAP32[$6 + 16 >> 2]), emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$6 + 12 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$6 + 8 >> 2])) & 1); + __stack_pointer = $6 + 32 | 0; + return $0 & 1; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29___invoke_b2PolygonShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 550; + $0 = emscripten__internal__TypeID_b2PolygonShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int___getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28__emscripten__internal__getContext_void_20_28__29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29__28void_20_28__20const__29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29_29_29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____destroy_28std____2____tree_node_b2Fixture__2c_20void____29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAP32[$2 + 8 >> 2]) { + std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____destroy_28std____2____tree_node_b2Fixture__2c_20void____29($0, HEAP32[HEAP32[$2 + 8 >> 2] >> 2]); + std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____destroy_28std____2____tree_node_b2Fixture__2c_20void____29($0, HEAP32[HEAP32[$2 + 8 >> 2] + 4 >> 2]); + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______node_alloc_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + void_20std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______destroy_5babi_v160004_5d_b2Fixture__2c_20void_2c_20void__28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20b2Fixture___29(HEAP32[$2 + 4 >> 2], std____2____tree_key_value_types_b2Fixture______get_ptr_5babi_v160004_5d_28b2Fixture___29(HEAP32[$2 + 8 >> 2] + 16 | 0)); + std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______deallocate_5babi_v160004_5d_28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20unsigned_20long_29(HEAP32[$2 + 4 >> 2], HEAP32[$2 + 8 >> 2], 1); + } + __stack_pointer = $2 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29___invoke_std____2__vector_int_2c_20std____2__allocator_int____28char_20const__2c_20bool_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 701; + $0 = emscripten__internal__TypeID_std____2__vector_int_2c_20std____2__allocator_int___2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28__emscripten__internal__getContext_bool_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29__28bool_20_28__20const__29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29_29_29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2EdgeShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2EdgeShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2EdgeShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 543; + $0 = emscripten__internal__TypeID_b2EdgeShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2EdgeShape____emscripten__internal__getContext_void_20_28b2EdgeShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const__28void_20_28b2EdgeShape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_emscripten__val_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29___invoke_std____2__vector_int_2c_20std____2__allocator_int____28char_20const__2c_20emscripten__val_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 700; + $0 = emscripten__internal__TypeID_std____2__vector_int_2c_20std____2__allocator_int___2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long___getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], emscripten__val_20_28__emscripten__internal__getContext_emscripten__val_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29__28emscripten__val_20_28__20const__29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29_29_29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______remove_node_pointer_28std____2____tree_node_b2Fixture__2c_20void____29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 4 >> 2] = $1; + $0 = HEAP32[$2 + 8 >> 2]; + std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____tree_iterator_5babi_v160004_5d_28std____2____tree_node_b2Fixture__2c_20void____29($2 + 12 | 0, HEAP32[$2 + 4 >> 2]); + std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long___operator___5babi_v160004_5d_28_29($2 + 12 | 0); + if (HEAP32[std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______begin_node_5babi_v160004_5d_28_29($0) >> 2] == HEAP32[$2 + 4 >> 2]) { + $1 = HEAP32[$2 + 12 >> 2]; + wasm2js_i32$0 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______begin_node_5babi_v160004_5d_28_29($0), + wasm2js_i32$1 = $1, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + } + $1 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____size_5babi_v160004_5d_28_29($0); + HEAP32[$1 >> 2] = HEAP32[$1 >> 2] - 1; + void_20std____2____tree_remove_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____2c_20std____2____tree_node_base_void____29(HEAP32[std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______end_node_5babi_v160004_5d_28_29($0) >> 2], HEAP32[$2 + 4 >> 2]); + __stack_pointer = $2 + 16 | 0; + return HEAP32[$2 + 12 >> 2]; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2Shape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20bool_2c_20b2Shape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___invoke_28bool_20_28b2Shape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2Shape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput__2c_20b2Transform__2c_20int_29($0, $1, $2, $3, $4, $5) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + $5 = $5 | 0; + var $6 = 0; + $6 = __stack_pointer - 32 | 0; + __stack_pointer = $6; + HEAP32[$6 + 28 >> 2] = $0; + HEAP32[$6 + 24 >> 2] = $1; + HEAP32[$6 + 20 >> 2] = $2; + HEAP32[$6 + 16 >> 2] = $3; + HEAP32[$6 + 12 >> 2] = $4; + HEAP32[$6 + 8 >> 2] = $5; + $2 = emscripten__internal__BindingType_b2Shape_20const__2c_20void___fromWireType_28b2Shape_20const__29(HEAP32[$6 + 24 >> 2]); + $0 = HEAP32[$6 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2RayCastOutput__2c_20void___fromWireType_28b2RayCastOutput__29(HEAP32[$6 + 20 >> 2]), emscripten__internal__GenericBindingType_b2RayCastInput___fromWireType_28b2RayCastInput__29(HEAP32[$6 + 16 >> 2]), emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$6 + 12 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$6 + 8 >> 2])) & 1); + __stack_pointer = $6 + 32 | 0; + return $0 & 1; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28int_20const__29___invoke_std____2__vector_int_2c_20std____2__allocator_int____28char_20const__2c_20void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28int_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 697; + $0 = emscripten__internal__TypeID_std____2__vector_int_2c_20std____2__allocator_int___2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20int_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20int_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28std____2__vector_int_2c_20std____2__allocator_int______emscripten__internal__getContext_void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28int_20const__29__28void_20_28std____2__vector_int_2c_20std____2__allocator_int______20const__29_28int_20const__29_29_29_28int_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2AABB____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const___invoke_b2AABB_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2AABB____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 504; + $0 = emscripten__internal__TypeID_b2AABB_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2AABB____emscripten__internal__getContext_bool_20_28b2AABB____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const__28bool_20_28b2AABB____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const_29_29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Shape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const___invoke_b2Shape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Shape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 524; + $0 = emscripten__internal__TypeID_b2Shape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Shape____emscripten__internal__getContext_void_20_28b2Shape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const__28void_20_28b2Shape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______push_back_slow_path_b2Vec2_20const___28b2Vec2_20const__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______alloc_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______split_buffer_28unsigned_20long_2c_20unsigned_20long_2c_20std____2__allocator_b2Vec2___29($2, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______recommend_5babi_v160004_5d_28unsigned_20long_29_20const($0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____size_5babi_v160004_5d_28_29_20const($0) + 1 | 0), std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____size_5babi_v160004_5d_28_29_20const($0), HEAP32[$2 + 20 >> 2]); + void_20std____2__allocator_traits_std____2__allocator_b2Vec2____construct_5babi_v160004_5d_b2Vec2_2c_20b2Vec2_20const__2c_20void__28std____2__allocator_b2Vec2___2c_20b2Vec2__2c_20b2Vec2_20const__29(HEAP32[$2 + 20 >> 2], b2Vec2__20std____2____to_address_5babi_v160004_5d_b2Vec2__28b2Vec2__29(HEAP32[$2 + 8 >> 2]), HEAP32[$2 + 24 >> 2]); + HEAP32[$2 + 8 >> 2] = HEAP32[$2 + 8 >> 2] + 8; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______swap_out_circular_buffer_28std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_____29($0, $2); + std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2________split_buffer_28_29($2); + __stack_pointer = $2 + 32 | 0; +} + +function std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______split_buffer_28unsigned_20long_2c_20unsigned_20long_2c_20std____2__allocator_b2Vec2___29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 24 >> 2] = $0; + HEAP32[$4 + 20 >> 2] = $1; + HEAP32[$4 + 16 >> 2] = $2; + HEAP32[$4 + 12 >> 2] = $3; + $0 = HEAP32[$4 + 24 >> 2]; + HEAP32[$4 + 28 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = 0; + std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2_______compressed_pair_5babi_v160004_5d_std__nullptr_t_2c_20std____2__allocator_b2Vec2____28std__nullptr_t___2c_20std____2__allocator_b2Vec2___29($0 + 12 | 0, $4 + 8 | 0, HEAP32[$4 + 12 >> 2]); + label$1: { + if (!HEAP32[$4 + 20 >> 2]) { + HEAP32[$0 >> 2] = 0; + break label$1; + } + std____2____allocation_result_std____2__allocator_traits_std____2__allocator_b2Vec2____pointer__20std____2____allocate_at_least_5babi_v160004_5d_std____2__allocator_b2Vec2___28std____2__allocator_b2Vec2___2c_20unsigned_20long_29($4, std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______alloc_5babi_v160004_5d_28_29($0), HEAP32[$4 + 20 >> 2]); + HEAP32[$0 >> 2] = HEAP32[$4 >> 2]; + HEAP32[$4 + 20 >> 2] = HEAP32[$4 + 4 >> 2]; + } + $1 = HEAP32[$0 >> 2] + (HEAP32[$4 + 16 >> 2] << 3) | 0; + HEAP32[$0 + 8 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $1; + $1 = HEAP32[$0 >> 2]; + $2 = HEAP32[$4 + 20 >> 2] << 3; + wasm2js_i32$0 = std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______end_cap_5babi_v160004_5d_28_29($0), + wasm2js_i32$1 = $1 + $2 | 0, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + __stack_pointer = $4 + 32 | 0; + return HEAP32[$4 + 28 >> 2]; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29___invoke_b2Draw_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 489; + $0 = emscripten__internal__TypeID_b2Draw_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Color_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Color_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20float_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Draw____emscripten__internal__getContext_void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29__28void_20_28b2Draw____20const__29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29_29_29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2ContactListener____29_28unsigned_20int_2c_20unsigned_20int_29___invoke_b2ContactListener_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2ContactListener____29_28unsigned_20int_2c_20unsigned_20int_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 479; + $0 = emscripten__internal__TypeID_b2ContactListener_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20unsigned_20int_2c_20unsigned_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20unsigned_20int_2c_20unsigned_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2ContactListener____emscripten__internal__getContext_void_20_28b2ContactListener____29_28unsigned_20int_2c_20unsigned_20int_29__28void_20_28b2ContactListener____20const__29_28unsigned_20int_2c_20unsigned_20int_29_29_29_28unsigned_20int_2c_20unsigned_20int_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2PolygonShape____29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29___invoke_b2PolygonShape__28char_20const__2c_20void_20_28b2PolygonShape____29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 557; + $0 = emscripten__internal__TypeID_b2PolygonShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20float_2c_20float_2c_20b2Vec2_20const__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20float_2c_20float_2c_20b2Vec2_20const__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float_2c_20float_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2PolygonShape____emscripten__internal__getContext_void_20_28b2PolygonShape____29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29__28void_20_28b2PolygonShape____20const__29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29_29_29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__Invoker_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const____invoke_28emscripten__val_20_28__29_28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const__29_2c_20emscripten__internal__BindingType_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___2c_20void____unnamed___2c_20emscripten___EM_VAL__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + emscripten__internal__BindingType_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___2c_20void___fromWireType_28emscripten__internal__BindingType_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___2c_20void____unnamed___29($3 + 4 | 0, HEAP32[$3 + 24 >> 2]); + emscripten__internal__BindingType_emscripten__val_2c_20void___fromWireType_28emscripten___EM_VAL__29($3, HEAP32[$3 + 20 >> 2]); + FUNCTION_TABLE[$0 | 0]($3 + 16 | 0, $3 + 4 | 0, $3); + $0 = emscripten__internal__BindingType_emscripten__val_2c_20void___toWireType_28emscripten__val_20const__29($3 + 16 | 0); + emscripten__val___val_28_29($3 + 16 | 0); + emscripten__val___val_28_29($3); + std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char_____basic_string_28_29($3 + 4 | 0); + __stack_pointer = $3 + 32 | 0; + return $0 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2QueryCallback__2c_20b2AABB_20const__29_20const___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28b2QueryCallback__2c_20b2AABB_20const__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 514; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_20const__2c_20b2QueryCallback__2c_20b2AABB_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_20const__2c_20b2QueryCallback__2c_20b2AABB_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2QueryCallback__2c_20b2AABB_20const__29_20const__28void_20_28b2World____20const__29_28b2QueryCallback__2c_20b2AABB_20const__29_20const_29_29_28b2QueryCallback__2c_20b2AABB_20const__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29___invoke_b2Draw_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Draw____29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 488; + $0 = emscripten__internal__TypeID_b2Draw_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20unsigned_20int_2c_20int_2c_20b2Color_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20unsigned_20int_2c_20int_2c_20b2Color_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Draw____emscripten__internal__getContext_void_20_28b2Draw____29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29__28void_20_28b2Draw____20const__29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29_29_29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2Contact__InitializeRegisters_28_29() { + b2Contact__AddType_28b2Contact__20_28__29_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29_2c_20void_20_28__29_28b2Contact__2c_20b2BlockAllocator__29_2c_20b2Shape__Type_2c_20b2Shape__Type_29(800, 801, 0, 0); + b2Contact__AddType_28b2Contact__20_28__29_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29_2c_20void_20_28__29_28b2Contact__2c_20b2BlockAllocator__29_2c_20b2Shape__Type_2c_20b2Shape__Type_29(802, 803, 2, 0); + b2Contact__AddType_28b2Contact__20_28__29_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29_2c_20void_20_28__29_28b2Contact__2c_20b2BlockAllocator__29_2c_20b2Shape__Type_2c_20b2Shape__Type_29(804, 805, 2, 2); + b2Contact__AddType_28b2Contact__20_28__29_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29_2c_20void_20_28__29_28b2Contact__2c_20b2BlockAllocator__29_2c_20b2Shape__Type_2c_20b2Shape__Type_29(806, 807, 1, 0); + b2Contact__AddType_28b2Contact__20_28__29_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29_2c_20void_20_28__29_28b2Contact__2c_20b2BlockAllocator__29_2c_20b2Shape__Type_2c_20b2Shape__Type_29(808, 809, 1, 2); + b2Contact__AddType_28b2Contact__20_28__29_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29_2c_20void_20_28__29_28b2Contact__2c_20b2BlockAllocator__29_2c_20b2Shape__Type_2c_20b2Shape__Type_29(810, 811, 3, 0); + b2Contact__AddType_28b2Contact__20_28__29_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29_2c_20void_20_28__29_28b2Contact__2c_20b2BlockAllocator__29_2c_20b2Shape__Type_2c_20b2Shape__Type_29(812, 813, 3, 2); +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2PolygonShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const___invoke_b2PolygonShape__28char_20const__2c_20bool_20_28b2PolygonShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 551; + $0 = emscripten__internal__TypeID_b2PolygonShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2PolygonShape____emscripten__internal__getContext_bool_20_28b2PolygonShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const__28bool_20_28b2PolygonShape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29_29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2Body__CreateFixture_28b2FixtureDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + $0 = HEAP32[$2 + 24 >> 2]; + if (b2World__IsLocked_28_29_20const(HEAP32[$0 + 88 >> 2]) & 1) { + __assert_fail(9124, 4100, 171, 9207); + wasm2js_trap(); + } + label$2: { + if (b2World__IsLocked_28_29_20const(HEAP32[$0 + 88 >> 2]) & 1) { + HEAP32[$2 + 28 >> 2] = 0; + break label$2; + } + HEAP32[$2 + 16 >> 2] = HEAP32[$0 + 88 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 16 >> 2], 44), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Fixture__b2Fixture_28_29($1); + HEAP32[$2 + 8 >> 2] = $1; + b2Fixture__Create_28b2BlockAllocator__2c_20b2Body__2c_20b2FixtureDef_20const__29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 16 >> 2], $0, HEAP32[$2 + 20 >> 2]); + if (HEAPU16[$0 + 4 >> 1] & 32) { + HEAP32[$2 + 4 >> 2] = HEAP32[$0 + 88 >> 2] + 102868; + b2Fixture__CreateProxies_28b2BroadPhase__2c_20b2Transform_20const__29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 4 >> 2], $0 + 12 | 0); + } + HEAP32[HEAP32[$2 + 8 >> 2] + 4 >> 2] = HEAP32[$0 + 100 >> 2]; + HEAP32[$0 + 100 >> 2] = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 104 >> 2] = HEAP32[$0 + 104 >> 2] + 1; + HEAP32[HEAP32[$2 + 8 >> 2] + 8 >> 2] = $0; + if (HEAPF32[HEAP32[$2 + 8 >> 2] >> 2] > Math_fround(0)) { + b2Body__ResetMassData_28_29($0); + } + HEAP8[HEAP32[$0 + 88 >> 2] + 102988 | 0] = 1; + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 8 >> 2]; + } + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function b2Contact__Destroy_28b2Contact__2c_20b2BlockAllocator__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + if (!(HEAP8[30976] & 1)) { + __assert_fail(8698, 5153, 107, 1607); + wasm2js_trap(); + } + HEAP32[$2 + 20 >> 2] = HEAP32[HEAP32[$2 + 28 >> 2] + 48 >> 2]; + HEAP32[$2 + 16 >> 2] = HEAP32[HEAP32[$2 + 28 >> 2] + 52 >> 2]; + label$2: { + if (HEAP32[HEAP32[$2 + 28 >> 2] + 124 >> 2] <= 0) { + break label$2; + } + if (b2Fixture__IsSensor_28_29_20const(HEAP32[$2 + 20 >> 2]) & 1) { + break label$2; + } + if (b2Fixture__IsSensor_28_29_20const(HEAP32[$2 + 16 >> 2]) & 1) { + break label$2; + } + b2Body__SetAwake_28bool_29(b2Fixture__GetBody_28_29(HEAP32[$2 + 20 >> 2]), 1); + b2Body__SetAwake_28bool_29(b2Fixture__GetBody_28_29(HEAP32[$2 + 16 >> 2]), 1); + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetType_28_29_20const(HEAP32[$2 + 20 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetType_28_29_20const(HEAP32[$2 + 16 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + if (!(HEAP32[$2 + 12 >> 2] < 4 & HEAP32[$2 + 12 >> 2] >= 0)) { + __assert_fail(2240, 5153, 123, 1607); + wasm2js_trap(); + } + if (!(HEAP32[$2 + 8 >> 2] < 4 & HEAP32[$2 + 8 >> 2] >= 0)) { + __assert_fail(2197, 5153, 124, 1607); + wasm2js_trap(); + } + HEAP32[$2 + 4 >> 2] = HEAP32[((Math_imul(HEAP32[$2 + 12 >> 2], 48) + 30784 | 0) + Math_imul(HEAP32[$2 + 8 >> 2], 12) | 0) + 4 >> 2]; + FUNCTION_TABLE[HEAP32[$2 + 4 >> 2]](HEAP32[$2 + 28 >> 2], HEAP32[$2 + 24 >> 2]); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2CircleShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const___invoke_b2CircleShape__28char_20const__2c_20bool_20_28b2CircleShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 533; + $0 = emscripten__internal__TypeID_b2CircleShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2CircleShape____emscripten__internal__getContext_bool_20_28b2CircleShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const__28bool_20_28b2CircleShape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29_29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2____split_buffer_int_2c_20std____2__allocator_int_______split_buffer_28unsigned_20long_2c_20unsigned_20long_2c_20std____2__allocator_int___29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 24 >> 2] = $0; + HEAP32[$4 + 20 >> 2] = $1; + HEAP32[$4 + 16 >> 2] = $2; + HEAP32[$4 + 12 >> 2] = $3; + $0 = HEAP32[$4 + 24 >> 2]; + HEAP32[$4 + 28 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = 0; + std____2____compressed_pair_int__2c_20std____2__allocator_int_______compressed_pair_5babi_v160004_5d_std__nullptr_t_2c_20std____2__allocator_int____28std__nullptr_t___2c_20std____2__allocator_int___29($0 + 12 | 0, $4 + 8 | 0, HEAP32[$4 + 12 >> 2]); + label$1: { + if (!HEAP32[$4 + 20 >> 2]) { + HEAP32[$0 >> 2] = 0; + break label$1; + } + std____2____allocation_result_std____2__allocator_traits_std____2__allocator_int____pointer__20std____2____allocate_at_least_5babi_v160004_5d_std____2__allocator_int___28std____2__allocator_int___2c_20unsigned_20long_29($4, std____2____split_buffer_int_2c_20std____2__allocator_int_______alloc_5babi_v160004_5d_28_29($0), HEAP32[$4 + 20 >> 2]); + HEAP32[$0 >> 2] = HEAP32[$4 >> 2]; + HEAP32[$4 + 20 >> 2] = HEAP32[$4 + 4 >> 2]; + } + $1 = HEAP32[$0 >> 2] + (HEAP32[$4 + 16 >> 2] << 2) | 0; + HEAP32[$0 + 8 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $1; + $1 = HEAP32[$0 >> 2]; + $2 = HEAP32[$4 + 20 >> 2] << 2; + wasm2js_i32$0 = std____2____split_buffer_int_2c_20std____2__allocator_int_______end_cap_5babi_v160004_5d_28_29($0), + wasm2js_i32$1 = $1 + $2 | 0, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + __stack_pointer = $4 + 32 | 0; + return HEAP32[$4 + 28 >> 2]; +} + +function b2Body__SetTransform_28b2Vec2_20const__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAPF32[$3 + 20 >> 2] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + if (b2World__IsLocked_28_29_20const(HEAP32[$0 + 88 >> 2]) & 1) { + __assert_fail(9124, 4100, 433, 6938); + wasm2js_trap(); + } + if (!(b2World__IsLocked_28_29_20const(HEAP32[$0 + 88 >> 2]) & 1)) { + b2Rot__Set_28float_29($0 + 20 | 0, HEAPF32[$3 + 20 >> 2]); + $4 = HEAP32[$3 + 24 >> 2]; + $1 = HEAP32[$4 >> 2]; + $4 = HEAP32[$4 + 4 >> 2]; + HEAP32[$0 + 12 >> 2] = $1; + HEAP32[$0 + 16 >> 2] = $4; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($3 + 12 | 0, $0 + 12 | 0, $0 + 28 | 0); + $1 = HEAP32[$3 + 16 >> 2]; + $4 = HEAP32[$3 + 12 >> 2]; + HEAP32[$0 + 44 >> 2] = $4; + HEAP32[$0 + 48 >> 2] = $1; + HEAPF32[$0 + 56 >> 2] = HEAPF32[$3 + 20 >> 2]; + $4 = HEAP32[$0 + 48 >> 2]; + $1 = HEAP32[$0 + 44 >> 2]; + HEAP32[$0 + 36 >> 2] = $1; + HEAP32[$0 + 40 >> 2] = $4; + HEAPF32[$0 + 52 >> 2] = HEAPF32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = HEAP32[$0 + 88 >> 2] + 102868; + HEAP32[$3 + 4 >> 2] = HEAP32[$0 + 100 >> 2]; + while (1) { + if (HEAP32[$3 + 4 >> 2]) { + b2Fixture__Synchronize_28b2BroadPhase__2c_20b2Transform_20const__2c_20b2Transform_20const__29(HEAP32[$3 + 4 >> 2], HEAP32[$3 + 8 >> 2], $0 + 12 | 0, $0 + 12 | 0); + HEAP32[$3 + 4 >> 2] = HEAP32[HEAP32[$3 + 4 >> 2] + 4 >> 2]; + continue; + } + break; + } + b2ContactManager__FindNewContacts_28_29(HEAP32[$0 + 88 >> 2] + 102868 | 0); + } + __stack_pointer = $3 + 32 | 0; +} + +function b2Fixture__Refilter_28_29($0) { + $0 = $0 | 0; + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 32 | 0; + __stack_pointer = $1; + HEAP32[$1 + 28 >> 2] = $0; + label$1: { + $0 = HEAP32[$1 + 28 >> 2]; + if (!HEAP32[$0 + 8 >> 2]) { + break label$1; + } + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Body__GetContactList_28_29(HEAP32[$0 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 24 >> 2] = wasm2js_i32$1; + while (1) { + if (HEAP32[$1 + 24 >> 2]) { + HEAP32[$1 + 20 >> 2] = HEAP32[HEAP32[$1 + 24 >> 2] + 4 >> 2]; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetFixtureA_28_29(HEAP32[$1 + 20 >> 2]), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetFixtureB_28_29(HEAP32[$1 + 20 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + if (!(HEAP32[$1 + 16 >> 2] != ($0 | 0) & HEAP32[$1 + 12 >> 2] != ($0 | 0))) { + b2Contact__FlagForFiltering_28_29(HEAP32[$1 + 20 >> 2]); + } + HEAP32[$1 + 24 >> 2] = HEAP32[HEAP32[$1 + 24 >> 2] + 12 >> 2]; + continue; + } + break; + } + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Body__GetWorld_28_29(HEAP32[$0 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + if (!HEAP32[$1 + 8 >> 2]) { + break label$1; + } + HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 8 >> 2] + 102868; + HEAP32[$1 >> 2] = 0; + while (1) { + if (HEAP32[$1 >> 2] >= HEAP32[$0 + 28 >> 2]) { + break label$1; + } + b2BroadPhase__TouchProxy_28int_29(HEAP32[$1 + 4 >> 2], HEAP32[(HEAP32[$0 + 24 >> 2] + Math_imul(HEAP32[$1 >> 2], 28) | 0) + 24 >> 2]); + HEAP32[$1 >> 2] = HEAP32[$1 >> 2] + 1; + continue; + } + } + __stack_pointer = $1 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2EdgeShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const___invoke_b2EdgeShape__28char_20const__2c_20bool_20_28b2EdgeShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 541; + $0 = emscripten__internal__TypeID_b2EdgeShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2EdgeShape____emscripten__internal__getContext_bool_20_28b2EdgeShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const__28bool_20_28b2EdgeShape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29_29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2PolygonShape____29_28b2MassData__2c_20float_29_20const___invoke_b2PolygonShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2PolygonShape____29_28b2MassData__2c_20float_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 554; + $0 = emscripten__internal__TypeID_b2PolygonShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2MassData__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2MassData__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2PolygonShape____emscripten__internal__getContext_void_20_28b2PolygonShape____29_28b2MassData__2c_20float_29_20const__28void_20_28b2PolygonShape____20const__29_28b2MassData__2c_20float_29_20const_29_29_28b2MassData__2c_20float_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2Island__b2Island_28int_2c_20int_2c_20int_2c_20b2StackAllocator__2c_20b2ContactListener__29($0, $1, $2, $3, $4, $5) { + var $6 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $6 = __stack_pointer - 32 | 0; + __stack_pointer = $6; + HEAP32[$6 + 28 >> 2] = $0; + HEAP32[$6 + 24 >> 2] = $1; + HEAP32[$6 + 20 >> 2] = $2; + HEAP32[$6 + 16 >> 2] = $3; + HEAP32[$6 + 12 >> 2] = $4; + HEAP32[$6 + 8 >> 2] = $5; + $0 = HEAP32[$6 + 28 >> 2]; + HEAP32[$0 + 40 >> 2] = HEAP32[$6 + 24 >> 2]; + HEAP32[$0 + 44 >> 2] = HEAP32[$6 + 20 >> 2]; + HEAP32[$0 + 48 >> 2] = HEAP32[$6 + 16 >> 2]; + HEAP32[$0 + 28 >> 2] = 0; + HEAP32[$0 + 36 >> 2] = 0; + HEAP32[$0 + 32 >> 2] = 0; + HEAP32[$0 >> 2] = HEAP32[$6 + 12 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$6 + 8 >> 2]; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2StackAllocator__Allocate_28int_29(HEAP32[$0 >> 2], HEAP32[$6 + 24 >> 2] << 2), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2StackAllocator__Allocate_28int_29(HEAP32[$0 >> 2], HEAP32[$6 + 20 >> 2] << 2), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2StackAllocator__Allocate_28int_29(HEAP32[$0 >> 2], HEAP32[$6 + 16 >> 2] << 2), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2StackAllocator__Allocate_28int_29(HEAP32[$0 >> 2], Math_imul(HEAP32[$0 + 40 >> 2], 12)), + HEAP32[wasm2js_i32$0 + 24 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2StackAllocator__Allocate_28int_29(HEAP32[$0 >> 2], Math_imul(HEAP32[$0 + 40 >> 2], 12)), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + __stack_pointer = $6 + 32 | 0; + return $0; +} + +function pop_arg($0, $1, $2, $3) { + label$1: { + switch ($1 - 9 | 0) { + case 0: + $1 = HEAP32[$2 >> 2]; + HEAP32[$2 >> 2] = $1 + 4; + HEAP32[$0 >> 2] = HEAP32[$1 >> 2]; + return; + + case 6: + $1 = HEAP32[$2 >> 2]; + HEAP32[$2 >> 2] = $1 + 4; + $1 = HEAP16[$1 >> 1]; + $2 = $1 >> 31; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + return; + + case 7: + $1 = HEAP32[$2 >> 2]; + HEAP32[$2 >> 2] = $1 + 4; + $2 = HEAPU16[$1 >> 1]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = 0; + return; + + case 8: + $1 = HEAP32[$2 >> 2]; + HEAP32[$2 >> 2] = $1 + 4; + $1 = HEAP8[$1 | 0]; + $2 = $1 >> 31; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + return; + + case 9: + $1 = HEAP32[$2 >> 2]; + HEAP32[$2 >> 2] = $1 + 4; + $2 = HEAPU8[$1 | 0]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = 0; + return; + + case 16: + $1 = HEAP32[$2 >> 2] + 7 & -8; + HEAP32[$2 >> 2] = $1 + 8; + HEAPF64[$0 >> 3] = HEAPF64[$1 >> 3]; + return; + + case 17: + FUNCTION_TABLE[$3 | 0]($0, $2); + + default: + return; + + case 1: + case 4: + case 14: + $1 = HEAP32[$2 >> 2]; + HEAP32[$2 >> 2] = $1 + 4; + $1 = HEAP32[$1 >> 2]; + $2 = $1 >> 31; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + return; + + case 2: + case 5: + case 11: + case 15: + $1 = HEAP32[$2 >> 2]; + HEAP32[$2 >> 2] = $1 + 4; + $2 = HEAP32[$1 >> 2]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = 0; + return; + + case 3: + case 10: + case 12: + case 13: + break label$1; + } + } + $1 = HEAP32[$2 >> 2] + 7 & -8; + HEAP32[$2 >> 2] = $1 + 8; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = HEAP32[$1 >> 2]; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2CircleShape____29_28b2MassData__2c_20float_29_20const___invoke_b2CircleShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2CircleShape____29_28b2MassData__2c_20float_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 536; + $0 = emscripten__internal__TypeID_b2CircleShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2MassData__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2MassData__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2CircleShape____emscripten__internal__getContext_void_20_28b2CircleShape____29_28b2MassData__2c_20float_29_20const__28void_20_28b2CircleShape____20const__29_28b2MassData__2c_20float_29_20const_29_29_28b2MassData__2c_20float_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2Mat33__Solve33_28b2Vec3_20const__29_20const($0, $1, $2) { + var $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer + -64 | 0; + __stack_pointer = $3; + HEAP32[$3 + 60 >> 2] = $1; + HEAP32[$3 + 56 >> 2] = $2; + $1 = HEAP32[$3 + 60 >> 2]; + b2Cross_28b2Vec3_20const__2c_20b2Vec3_20const__29($3 + 40 | 0, $1 + 12 | 0, $1 + 24 | 0); + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Dot_28b2Vec3_20const__2c_20b2Vec3_20const__29($1, $3 + 40 | 0), + HEAPF32[wasm2js_i32$0 + 52 >> 2] = wasm2js_f32$0; + if (HEAPF32[$3 + 52 >> 2] != Math_fround(0)) { + HEAPF32[$3 + 52 >> 2] = Math_fround(1) / HEAPF32[$3 + 52 >> 2]; + } + b2Vec3__b2Vec3_28_29($0); + $4 = HEAPF32[$3 + 52 >> 2]; + $2 = HEAP32[$3 + 56 >> 2]; + b2Cross_28b2Vec3_20const__2c_20b2Vec3_20const__29($3 + 28 | 0, $1 + 12 | 0, $1 + 24 | 0); + wasm2js_i32$0 = $0, wasm2js_f32$0 = Math_fround($4 * b2Dot_28b2Vec3_20const__2c_20b2Vec3_20const__29($2, $3 + 28 | 0)), + HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0; + $4 = HEAPF32[$3 + 52 >> 2]; + b2Cross_28b2Vec3_20const__2c_20b2Vec3_20const__29($3 + 16 | 0, HEAP32[$3 + 56 >> 2], $1 + 24 | 0); + wasm2js_i32$0 = $0, wasm2js_f32$0 = Math_fround($4 * b2Dot_28b2Vec3_20const__2c_20b2Vec3_20const__29($1, $3 + 16 | 0)), + HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $4 = HEAPF32[$3 + 52 >> 2]; + b2Cross_28b2Vec3_20const__2c_20b2Vec3_20const__29($3 + 4 | 0, $1 + 12 | 0, HEAP32[$3 + 56 >> 2]); + wasm2js_i32$0 = $0, wasm2js_f32$0 = Math_fround($4 * b2Dot_28b2Vec3_20const__2c_20b2Vec3_20const__29($1, $3 + 4 | 0)), + HEAPF32[wasm2js_i32$0 + 8 >> 2] = wasm2js_f32$0; + __stack_pointer = $3 - -64 | 0; +} + +function b2TestOverlap_28b2Shape_20const__2c_20int_2c_20b2Shape_20const__2c_20int_2c_20b2Transform_20const__2c_20b2Transform_20const__29($0, $1, $2, $3, $4, $5) { + var $6 = 0; + $6 = __stack_pointer - 160 | 0; + __stack_pointer = $6; + HEAP32[$6 + 156 >> 2] = $0; + HEAP32[$6 + 152 >> 2] = $1; + HEAP32[$6 + 148 >> 2] = $2; + HEAP32[$6 + 144 >> 2] = $3; + HEAP32[$6 + 140 >> 2] = $4; + HEAP32[$6 + 136 >> 2] = $5; + b2DistanceInput__b2DistanceInput_28_29($6 + 44 | 0); + b2DistanceProxy__Set_28b2Shape_20const__2c_20int_29($6 + 44 | 0, HEAP32[$6 + 156 >> 2], HEAP32[$6 + 152 >> 2]); + b2DistanceProxy__Set_28b2Shape_20const__2c_20int_29($6 + 72 | 0, HEAP32[$6 + 148 >> 2], HEAP32[$6 + 144 >> 2]); + $4 = HEAP32[$6 + 140 >> 2]; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + $3 = $0; + $2 = $6 + 44 | 0; + $0 = $2; + HEAP32[$0 + 56 >> 2] = $3; + HEAP32[$0 + 60 >> 2] = $1; + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$4 + 8 >> 2]; + $3 = $1; + $1 = $2; + HEAP32[$1 + 64 >> 2] = $3; + HEAP32[$1 + 68 >> 2] = $0; + $4 = HEAP32[$6 + 136 >> 2]; + $0 = HEAP32[$4 >> 2]; + $1 = HEAP32[$4 + 4 >> 2]; + $3 = $0; + $2 = $6 + 44 | 0; + $0 = $2; + HEAP32[$0 + 72 >> 2] = $3; + HEAP32[$0 + 76 >> 2] = $1; + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$4 + 8 >> 2]; + $3 = $1; + $1 = $2; + HEAP32[$1 + 80 >> 2] = $3; + HEAP32[$1 + 84 >> 2] = $0; + HEAP8[$6 + 132 | 0] = 1; + HEAP16[$6 + 36 >> 1] = 0; + b2DistanceOutput__b2DistanceOutput_28_29($6 + 8 | 0); + b2Distance_28b2DistanceOutput__2c_20b2SimplexCache__2c_20b2DistanceInput_20const__29($6 + 8 | 0, $6 + 32 | 0, $6 + 44 | 0); + __stack_pointer = $6 + 160 | 0; + return HEAPF32[$6 + 24 >> 2] < Math_fround(11920928955078125e-22); +} + +function __dynamic_cast($0, $1, $2, $3) { + var $4 = 0, $5 = 0, $6 = 0; + $4 = __stack_pointer + -64 | 0; + __stack_pointer = $4; + $6 = HEAP32[$0 >> 2]; + $5 = HEAP32[$6 - 4 >> 2]; + $6 = HEAP32[$6 - 8 >> 2]; + HEAP32[$4 + 32 >> 2] = 0; + HEAP32[$4 + 36 >> 2] = 0; + HEAP32[$4 + 40 >> 2] = 0; + HEAP32[$4 + 44 >> 2] = 0; + HEAP32[$4 + 48 >> 2] = 0; + HEAP32[$4 + 52 >> 2] = 0; + HEAP8[$4 + 55 | 0] = 0; + HEAP8[$4 + 56 | 0] = 0; + HEAP8[$4 + 57 | 0] = 0; + HEAP8[$4 + 58 | 0] = 0; + HEAP8[$4 + 59 | 0] = 0; + HEAP8[$4 + 60 | 0] = 0; + HEAP8[$4 + 61 | 0] = 0; + HEAP8[$4 + 62 | 0] = 0; + HEAP32[$4 + 24 >> 2] = 0; + HEAP32[$4 + 28 >> 2] = 0; + HEAP32[$4 + 20 >> 2] = $3; + HEAP32[$4 + 16 >> 2] = $1; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $2; + $0 = $0 + $6 | 0; + $3 = 0; + label$1: { + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($5, $2, 0)) { + HEAP32[$4 + 56 >> 2] = 1; + FUNCTION_TABLE[HEAP32[HEAP32[$5 >> 2] + 20 >> 2]]($5, $4 + 8 | 0, $0, $0, 1, 0); + $3 = HEAP32[$4 + 32 >> 2] == 1 ? $0 : 0; + break label$1; + } + FUNCTION_TABLE[HEAP32[HEAP32[$5 >> 2] + 24 >> 2]]($5, $4 + 8 | 0, $0, 1, 0); + label$3: { + switch (HEAP32[$4 + 44 >> 2]) { + case 0: + $3 = HEAP32[$4 + 48 >> 2] == 1 ? HEAP32[$4 + 36 >> 2] == 1 ? HEAP32[$4 + 40 >> 2] == 1 ? HEAP32[$4 + 28 >> 2] : 0 : 0 : 0; + break label$1; + + case 1: + break label$3; + + default: + break label$1; + } + } + if (HEAP32[$4 + 32 >> 2] != 1) { + if (HEAP32[$4 + 48 >> 2] | HEAP32[$4 + 36 >> 2] != 1 | HEAP32[$4 + 40 >> 2] != 1) { + break label$1; + } + } + $3 = HEAP32[$4 + 24 >> 2]; + } + __stack_pointer = $4 - -64 | 0; + return $3; +} + +function void_20std____2__vector_int_2c_20std____2__allocator_int______push_back_slow_path_int_20const___28int_20const__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__vector_int_2c_20std____2__allocator_int______alloc_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + std____2____split_buffer_int_2c_20std____2__allocator_int_______split_buffer_28unsigned_20long_2c_20unsigned_20long_2c_20std____2__allocator_int___29($2, std____2__vector_int_2c_20std____2__allocator_int______recommend_5babi_v160004_5d_28unsigned_20long_29_20const($0, std____2__vector_int_2c_20std____2__allocator_int____size_5babi_v160004_5d_28_29_20const($0) + 1 | 0), std____2__vector_int_2c_20std____2__allocator_int____size_5babi_v160004_5d_28_29_20const($0), HEAP32[$2 + 20 >> 2]); + void_20std____2__allocator_traits_std____2__allocator_int____construct_5babi_v160004_5d_int_2c_20int_20const__2c_20void__28std____2__allocator_int___2c_20int__2c_20int_20const__29(HEAP32[$2 + 20 >> 2], int__20std____2____to_address_5babi_v160004_5d_int__28int__29(HEAP32[$2 + 8 >> 2]), HEAP32[$2 + 24 >> 2]); + HEAP32[$2 + 8 >> 2] = HEAP32[$2 + 8 >> 2] + 4; + std____2__vector_int_2c_20std____2__allocator_int______swap_out_circular_buffer_28std____2____split_buffer_int_2c_20std____2__allocator_int_____29($0, $2); + std____2____split_buffer_int_2c_20std____2__allocator_int________split_buffer_28_29($2); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Shape__20_28b2PolygonShape____29_28b2BlockAllocator__29_20const___invoke_b2PolygonShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Shape__20_28b2PolygonShape____29_28b2BlockAllocator__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 548; + $0 = emscripten__internal__TypeID_b2PolygonShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2BlockAllocator____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2BlockAllocator____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Shape__20_28b2PolygonShape____emscripten__internal__getContext_b2Shape__20_28b2PolygonShape____29_28b2BlockAllocator__29_20const__28b2Shape__20_28b2PolygonShape____20const__29_28b2BlockAllocator__29_20const_29_29_28b2BlockAllocator__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2EdgeShape____29_28b2MassData__2c_20float_29_20const___invoke_b2EdgeShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2EdgeShape____29_28b2MassData__2c_20float_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 544; + $0 = emscripten__internal__TypeID_b2EdgeShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2MassData__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2MassData__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2EdgeShape____emscripten__internal__getContext_void_20_28b2EdgeShape____29_28b2MassData__2c_20float_29_20const__28void_20_28b2EdgeShape____20const__29_28b2MassData__2c_20float_29_20const_29_29_28b2MassData__2c_20float_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Shape__20_28b2CircleShape____29_28b2BlockAllocator__29_20const___invoke_b2CircleShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Shape__20_28b2CircleShape____29_28b2BlockAllocator__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 531; + $0 = emscripten__internal__TypeID_b2CircleShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2BlockAllocator____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2BlockAllocator____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Shape__20_28b2CircleShape____emscripten__internal__getContext_b2Shape__20_28b2CircleShape____29_28b2BlockAllocator__29_20const__28b2Shape__20_28b2CircleShape____20const__29_28b2BlockAllocator__29_20const_29_29_28b2BlockAllocator__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Shape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const___invoke_b2Shape__28char_20const__2c_20bool_20_28b2Shape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 522; + $0 = emscripten__internal__TypeID_b2Shape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2Shape____emscripten__internal__getContext_bool_20_28b2Shape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const__28bool_20_28b2Shape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29_29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function __memset($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0; + label$1: { + if (!$2) { + break label$1; + } + HEAP8[$0 | 0] = $1; + $3 = $0 + $2 | 0; + HEAP8[$3 - 1 | 0] = $1; + if ($2 >>> 0 < 3) { + break label$1; + } + HEAP8[$0 + 2 | 0] = $1; + HEAP8[$0 + 1 | 0] = $1; + HEAP8[$3 - 3 | 0] = $1; + HEAP8[$3 - 2 | 0] = $1; + if ($2 >>> 0 < 7) { + break label$1; + } + HEAP8[$0 + 3 | 0] = $1; + HEAP8[$3 - 4 | 0] = $1; + if ($2 >>> 0 < 9) { + break label$1; + } + $4 = 0 - $0 & 3; + $3 = $4 + $0 | 0; + $1 = Math_imul($1 & 255, 16843009); + HEAP32[$3 >> 2] = $1; + $4 = $2 - $4 & -4; + $2 = $4 + $3 | 0; + HEAP32[$2 - 4 >> 2] = $1; + if ($4 >>> 0 < 9) { + break label$1; + } + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $1; + HEAP32[$2 - 8 >> 2] = $1; + HEAP32[$2 - 12 >> 2] = $1; + if ($4 >>> 0 < 25) { + break label$1; + } + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $1; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$2 - 16 >> 2] = $1; + HEAP32[$2 - 20 >> 2] = $1; + HEAP32[$2 - 24 >> 2] = $1; + HEAP32[$2 - 28 >> 2] = $1; + $6 = $3 & 4 | 24; + $2 = $4 - $6 | 0; + if ($2 >>> 0 < 32) { + break label$1; + } + $5 = __wasm_i64_mul($1, 0, 1, 1); + $4 = i64toi32_i32$HIGH_BITS; + $1 = $3 + $6 | 0; + while (1) { + HEAP32[$1 + 24 >> 2] = $5; + HEAP32[$1 + 28 >> 2] = $4; + HEAP32[$1 + 16 >> 2] = $5; + HEAP32[$1 + 20 >> 2] = $4; + HEAP32[$1 + 8 >> 2] = $5; + HEAP32[$1 + 12 >> 2] = $4; + HEAP32[$1 >> 2] = $5; + HEAP32[$1 + 4 >> 2] = $4; + $1 = $1 + 32 | 0; + $2 = $2 - 32 | 0; + if ($2 >>> 0 > 31) { + continue; + } + break; + } + } + return $0; +} + +function b2RevoluteJoint__b2RevoluteJoint_28b2RevoluteJointDef_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Joint__b2Joint_28b2JointDef_20const__29($1, HEAP32[$2 + 8 >> 2]); + HEAP32[$1 >> 2] = 19356; + b2Vec2__b2Vec2_28_29($1 + 68 | 0); + b2Vec2__b2Vec2_28_29($1 + 76 | 0); + b2Vec2__b2Vec2_28_29($1 + 84 | 0); + b2Vec2__b2Vec2_28_29($1 + 140 | 0); + b2Vec2__b2Vec2_28_29($1 + 148 | 0); + b2Vec2__b2Vec2_28_29($1 + 156 | 0); + b2Vec2__b2Vec2_28_29($1 + 164 | 0); + b2Mat22__b2Mat22_28_29($1 + 188 | 0); + $3 = HEAP32[$2 + 8 >> 2]; + $4 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$1 + 68 >> 2] = $4; + HEAP32[$1 + 72 >> 2] = $0; + $3 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $4 = HEAP32[$3 + 32 >> 2]; + HEAP32[$1 + 76 >> 2] = $0; + HEAP32[$1 + 80 >> 2] = $4; + HEAPF32[$1 + 120 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 36 >> 2]; + b2Vec2__SetZero_28_29($1 + 84 | 0); + HEAPF32[$1 + 208 >> 2] = 0; + HEAPF32[$1 + 92 >> 2] = 0; + HEAPF32[$1 + 96 >> 2] = 0; + HEAPF32[$1 + 100 >> 2] = 0; + HEAPF32[$1 + 124 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 44 >> 2]; + HEAPF32[$1 + 128 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 48 >> 2]; + HEAPF32[$1 + 108 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 60 >> 2]; + HEAPF32[$1 + 112 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 56 >> 2]; + HEAP8[$1 + 116 | 0] = HEAP8[HEAP32[$2 + 8 >> 2] + 40 | 0] & 1; + HEAP8[$1 + 104 | 0] = HEAP8[HEAP32[$2 + 8 >> 2] + 52 | 0] & 1; + HEAPF32[$1 + 204 >> 2] = 0; + __stack_pointer = $2 + 16 | 0; + return $1; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Shape__20_28b2EdgeShape____29_28b2BlockAllocator__29_20const___invoke_b2EdgeShape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Shape__20_28b2EdgeShape____29_28b2BlockAllocator__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 539; + $0 = emscripten__internal__TypeID_b2EdgeShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2BlockAllocator____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2BlockAllocator____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Shape__20_28b2EdgeShape____emscripten__internal__getContext_b2Shape__20_28b2EdgeShape____29_28b2BlockAllocator__29_20const__28b2Shape__20_28b2EdgeShape____20const__29_28b2BlockAllocator__29_20const_29_29_28b2BlockAllocator__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 586; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29__28void_20_28b2Body____20const__29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29_29_29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Fixture__20_28b2Body____29_28b2Shape_20const__2c_20float_29___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Fixture__20_28b2Body____29_28b2Shape_20const__2c_20float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 578; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Shape_20const__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Shape_20const__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Fixture__20_28b2Body____emscripten__internal__getContext_b2Fixture__20_28b2Body____29_28b2Shape_20const__2c_20float_29__28b2Fixture__20_28b2Body____20const__29_28b2Shape_20const__2c_20float_29_29_29_28b2Shape_20const__2c_20float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2Fixture__Synchronize_28b2BroadPhase__2c_20b2Transform_20const__2c_20b2Transform_20const__29($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 80 | 0; + __stack_pointer = $4; + HEAP32[$4 + 76 >> 2] = $0; + HEAP32[$4 + 72 >> 2] = $1; + HEAP32[$4 + 68 >> 2] = $2; + HEAP32[$4 + 64 >> 2] = $3; + label$1: { + $0 = HEAP32[$4 + 76 >> 2]; + if (!HEAP32[$0 + 28 >> 2]) { + break label$1; + } + HEAP32[$4 + 60 >> 2] = 0; + while (1) { + if (HEAP32[$4 + 60 >> 2] >= HEAP32[$0 + 28 >> 2]) { + break label$1; + } + HEAP32[$4 + 56 >> 2] = HEAP32[$0 + 24 >> 2] + Math_imul(HEAP32[$4 + 60 >> 2], 28); + b2AABB__b2AABB_28_29($4 + 40 | 0); + b2AABB__b2AABB_28_29($4 + 24 | 0); + $1 = HEAP32[$0 + 12 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 24 >> 2]]($1, $4 + 40 | 0, HEAP32[$4 + 68 >> 2], HEAP32[HEAP32[$4 + 56 >> 2] + 20 >> 2]); + $1 = HEAP32[$0 + 12 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 24 >> 2]]($1, $4 + 24 | 0, HEAP32[$4 + 64 >> 2], HEAP32[HEAP32[$4 + 56 >> 2] + 20 >> 2]); + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$4 + 56 >> 2], $4 + 40 | 0, $4 + 24 | 0); + b2AABB__GetCenter_28_29_20const($4 + 8 | 0, $4 + 24 | 0); + b2AABB__GetCenter_28_29_20const($4, $4 + 40 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 16 | 0, $4 + 8 | 0, $4); + b2BroadPhase__MoveProxy_28int_2c_20b2AABB_20const__2c_20b2Vec2_20const__29(HEAP32[$4 + 72 >> 2], HEAP32[HEAP32[$4 + 56 >> 2] + 24 >> 2], HEAP32[$4 + 56 >> 2], $4 + 16 | 0); + HEAP32[$4 + 60 >> 2] = HEAP32[$4 + 60 >> 2] + 1; + continue; + } + } + __stack_pointer = $4 + 80 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Shape____29_28b2MassData__2c_20float_29_20const___invoke_b2Shape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Shape____29_28b2MassData__2c_20float_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 525; + $0 = emscripten__internal__TypeID_b2Shape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2MassData__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2MassData__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Shape____emscripten__internal__getContext_void_20_28b2Shape____29_28b2MassData__2c_20float_29_20const__28void_20_28b2Shape____20const__29_28b2MassData__2c_20float_29_20const_29_29_28b2MassData__2c_20float_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______reset_5babi_v160004_5d_28std____2____tree_node_b2Fixture__2c_20void____29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = HEAP32[std____2____compressed_pair_std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______first_5babi_v160004_5d_28_29($0) >> 2], + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$2 + 8 >> 2]; + wasm2js_i32$0 = std____2____compressed_pair_std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______first_5babi_v160004_5d_28_29($0), + wasm2js_i32$1 = $1, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + if (HEAP32[$2 + 4 >> 2]) { + std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______operator_28_29_5babi_v160004_5d_28std____2____tree_node_b2Fixture__2c_20void____29(std____2____compressed_pair_std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______second_5babi_v160004_5d_28_29($0), HEAP32[$2 + 4 >> 2]); + } + __stack_pointer = $2 + 16 | 0; +} + +function b2LinearStiffness_28float__2c_20float__2c_20float_2c_20float_2c_20b2Body_20const__2c_20b2Body_20const__29($0, $1, $2, $3, $4, $5) { + var $6 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $6 = __stack_pointer - 48 | 0; + __stack_pointer = $6; + HEAP32[$6 + 44 >> 2] = $0; + HEAP32[$6 + 40 >> 2] = $1; + HEAPF32[$6 + 36 >> 2] = $2; + HEAPF32[$6 + 32 >> 2] = $3; + HEAP32[$6 + 28 >> 2] = $4; + HEAP32[$6 + 24 >> 2] = $5; + wasm2js_i32$0 = $6, wasm2js_f32$0 = b2Body__GetMass_28_29_20const(HEAP32[$6 + 28 >> 2]), + HEAPF32[wasm2js_i32$0 + 20 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $6, wasm2js_f32$0 = b2Body__GetMass_28_29_20const(HEAP32[$6 + 24 >> 2]), + HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0; + label$1: { + if (!(!(HEAPF32[$6 + 20 >> 2] > Math_fround(0)) | !(HEAPF32[$6 + 16 >> 2] > Math_fround(0)))) { + HEAPF32[$6 + 12 >> 2] = Math_fround(HEAPF32[$6 + 20 >> 2] * HEAPF32[$6 + 16 >> 2]) / Math_fround(HEAPF32[$6 + 20 >> 2] + HEAPF32[$6 + 16 >> 2]); + break label$1; + } + label$3: { + if (HEAPF32[$6 + 20 >> 2] > Math_fround(0)) { + HEAPF32[$6 + 12 >> 2] = HEAPF32[$6 + 20 >> 2]; + break label$3; + } + HEAPF32[$6 + 12 >> 2] = HEAPF32[$6 + 16 >> 2]; + } + } + HEAPF32[$6 + 8 >> 2] = HEAPF32[$6 + 36 >> 2] * Math_fround(6.2831854820251465); + HEAPF32[HEAP32[$6 + 44 >> 2] >> 2] = Math_fround(HEAPF32[$6 + 12 >> 2] * HEAPF32[$6 + 8 >> 2]) * HEAPF32[$6 + 8 >> 2]; + $2 = HEAPF32[$6 + 12 >> 2]; + HEAPF32[HEAP32[$6 + 40 >> 2] >> 2] = Math_fround(Math_fround($2 + $2) * HEAPF32[$6 + 32 >> 2]) * HEAPF32[$6 + 8 >> 2]; + __stack_pointer = $6 + 48 | 0; +} + +function __cxxabiv1____si_class_type_info__search_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_2c_20bool_29_20const($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, HEAP32[$1 + 8 >> 2], $4)) { + __cxxabiv1____class_type_info__process_static_type_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_29_20const($1, $1, $2, $3); + return; + } + label$2: { + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, HEAP32[$1 >> 2], $4)) { + if (!(HEAP32[$1 + 16 >> 2] != ($2 | 0) & HEAP32[$1 + 20 >> 2] != ($2 | 0))) { + if (($3 | 0) != 1) { + break label$2; + } + HEAP32[$1 + 32 >> 2] = 1; + return; + } + HEAP32[$1 + 32 >> 2] = $3; + label$6: { + if (HEAP32[$1 + 44 >> 2] == 4) { + break label$6; + } + HEAP16[$1 + 52 >> 1] = 0; + $0 = HEAP32[$0 + 8 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 20 >> 2]]($0, $1, $2, $2, 1, $4); + if (HEAPU8[$1 + 53 | 0]) { + HEAP32[$1 + 44 >> 2] = 3; + if (!HEAPU8[$1 + 52 | 0]) { + break label$6; + } + break label$2; + } + HEAP32[$1 + 44 >> 2] = 4; + } + HEAP32[$1 + 20 >> 2] = $2; + HEAP32[$1 + 40 >> 2] = HEAP32[$1 + 40 >> 2] + 1; + if (HEAP32[$1 + 36 >> 2] != 1 | HEAP32[$1 + 24 >> 2] != 2) { + break label$2; + } + HEAP8[$1 + 54 | 0] = 1; + return; + } + $0 = HEAP32[$0 + 8 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $1, $2, $3, $4); + } +} + +function cosf($0) { + var $1 = Math_fround(0), $2 = 0, $3 = 0, $4 = 0, $5 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + $4 = (wasm2js_scratch_store_f32($0), wasm2js_scratch_load_i32(2)); + $3 = $4 & 2147483647; + label$1: { + if ($3 >>> 0 <= 1061752794) { + $1 = Math_fround(1); + if ($3 >>> 0 < 964689920) { + break label$1; + } + $1 = __cosdf(+$0); + break label$1; + } + if ($3 >>> 0 <= 1081824209) { + if ($3 >>> 0 >= 1075235812) { + $1 = Math_fround(-__cosdf((($4 | 0) < 0 ? 3.141592653589793 : -3.141592653589793) + +$0)); + break label$1; + } + $5 = +$0; + if (($4 | 0) < 0) { + $1 = __sindf($5 + 1.5707963267948966); + break label$1; + } + $1 = __sindf(1.5707963267948966 - $5); + break label$1; + } + if ($3 >>> 0 <= 1088565717) { + if ($3 >>> 0 >= 1085271520) { + $1 = __cosdf((($4 | 0) < 0 ? 6.283185307179586 : -6.283185307179586) + +$0); + break label$1; + } + if (($4 | 0) < 0) { + $1 = __sindf(-4.71238898038469 - +$0); + break label$1; + } + $1 = __sindf(+$0 + -4.71238898038469); + break label$1; + } + $1 = Math_fround($0 - $0); + if ($3 >>> 0 >= 2139095040) { + break label$1; + } + label$9: { + switch (__rem_pio2f($0, $2 + 8 | 0) & 3) { + case 0: + $1 = __cosdf(HEAPF64[$2 + 8 >> 3]); + break label$1; + + case 1: + $1 = __sindf(-HEAPF64[$2 + 8 >> 3]); + break label$1; + + case 2: + $1 = Math_fround(-__cosdf(HEAPF64[$2 + 8 >> 3])); + break label$1; + + default: + break label$9; + } + } + $1 = __sindf(HEAPF64[$2 + 8 >> 3]); + } + __stack_pointer = $2 + 16 | 0; + return $1; +} + +function sinf($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + $4 = (wasm2js_scratch_store_f32($0), wasm2js_scratch_load_i32(2)); + $2 = $4 & 2147483647; + label$1: { + if ($2 >>> 0 <= 1061752794) { + if ($2 >>> 0 < 964689920) { + break label$1; + } + $0 = __sindf(+$0); + break label$1; + } + if ($2 >>> 0 <= 1081824209) { + $3 = +$0; + if ($2 >>> 0 <= 1075235811) { + if (($4 | 0) < 0) { + $0 = Math_fround(-__cosdf($3 + 1.5707963267948966)); + break label$1; + } + $0 = __cosdf($3 + -1.5707963267948966); + break label$1; + } + $0 = __sindf(-((($4 | 0) >= 0 ? -3.141592653589793 : 3.141592653589793) + $3)); + break label$1; + } + if ($2 >>> 0 <= 1088565717) { + if ($2 >>> 0 <= 1085271519) { + $3 = +$0; + if (($4 | 0) < 0) { + $0 = __cosdf($3 + 4.71238898038469); + break label$1; + } + $0 = Math_fround(-__cosdf($3 + -4.71238898038469)); + break label$1; + } + $0 = __sindf((($4 | 0) < 0 ? 6.283185307179586 : -6.283185307179586) + +$0); + break label$1; + } + if ($2 >>> 0 >= 2139095040) { + $0 = Math_fround($0 - $0); + break label$1; + } + label$10: { + switch (__rem_pio2f($0, $1 + 8 | 0) & 3) { + case 0: + $0 = __sindf(HEAPF64[$1 + 8 >> 3]); + break label$1; + + case 1: + $0 = __cosdf(HEAPF64[$1 + 8 >> 3]); + break label$1; + + case 2: + $0 = __sindf(-HEAPF64[$1 + 8 >> 3]); + break label$1; + + default: + break label$10; + } + } + $0 = Math_fround(-__cosdf(HEAPF64[$1 + 8 >> 3])); + } + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2ContactListener____29_28unsigned_20int_29___invoke_b2ContactListener_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2ContactListener____29_28unsigned_20int_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 478; + $0 = emscripten__internal__TypeID_b2ContactListener_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20unsigned_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20unsigned_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2ContactListener____emscripten__internal__getContext_void_20_28b2ContactListener____29_28unsigned_20int_29__28void_20_28b2ContactListener____20const__29_28unsigned_20int_29_29_29_28unsigned_20int_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2DynamicTree__CreateProxy_28b2AABB_20const__2c_20void__29($0, $1, $2) { + var $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 48 | 0; + __stack_pointer = $3; + HEAP32[$3 + 44 >> 2] = $0; + HEAP32[$3 + 40 >> 2] = $1; + HEAP32[$3 + 36 >> 2] = $2; + $4 = HEAP32[$3 + 44 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2DynamicTree__AllocateNode_28_29($4), HEAP32[wasm2js_i32$0 + 32 >> 2] = wasm2js_i32$1; + b2Vec2__b2Vec2_28float_2c_20float_29($3 + 24 | 0, Math_fround(.10000000149011612), Math_fround(.10000000149011612)); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 16 | 0, HEAP32[$3 + 40 >> 2], $3 + 24 | 0); + $0 = HEAP32[$3 + 20 >> 2]; + $1 = HEAP32[$3 + 16 >> 2]; + $2 = $1; + $1 = HEAP32[$4 + 4 >> 2] + Math_imul(HEAP32[$3 + 32 >> 2], 40) | 0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 8 | 0, HEAP32[$3 + 40 >> 2] + 8 | 0, $3 + 24 | 0); + $1 = HEAP32[$3 + 12 >> 2]; + $0 = HEAP32[$3 + 8 >> 2]; + $2 = $0; + $0 = HEAP32[$4 + 4 >> 2] + Math_imul(HEAP32[$3 + 32 >> 2], 40) | 0; + HEAP32[$0 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $1; + HEAP32[(HEAP32[$4 + 4 >> 2] + Math_imul(HEAP32[$3 + 32 >> 2], 40) | 0) + 16 >> 2] = HEAP32[$3 + 36 >> 2]; + HEAP32[(HEAP32[$4 + 4 >> 2] + Math_imul(HEAP32[$3 + 32 >> 2], 40) | 0) + 32 >> 2] = 0; + HEAP8[(HEAP32[$4 + 4 >> 2] + Math_imul(HEAP32[$3 + 32 >> 2], 40) | 0) + 36 | 0] = 1; + b2DynamicTree__InsertLeaf_28int_29($4, HEAP32[$3 + 32 >> 2]); + __stack_pointer = $3 + 48 | 0; + return HEAP32[$3 + 32 >> 2]; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Fixture__20_28b2Body____29_28b2FixtureDef_20const__29___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Fixture__20_28b2Body____29_28b2FixtureDef_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 577; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2FixtureDef_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2FixtureDef_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Fixture__20_28b2Body____emscripten__internal__getContext_b2Fixture__20_28b2Body____29_28b2FixtureDef_20const__29__28b2Fixture__20_28b2Body____20const__29_28b2FixtureDef_20const__29_29_29_28b2FixtureDef_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2QueryCallback____29_28unsigned_20int_29___invoke_b2QueryCallback_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20bool_20_28b2QueryCallback____29_28unsigned_20int_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 468; + $0 = emscripten__internal__TypeID_b2QueryCallback_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2QueryCallback__2c_20unsigned_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2QueryCallback__2c_20unsigned_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2QueryCallback____emscripten__internal__getContext_bool_20_28b2QueryCallback____29_28unsigned_20int_29__28bool_20_28b2QueryCallback____20const__29_28unsigned_20int_29_29_29_28unsigned_20int_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function __vfprintf_internal($0, $1, $2, $3, $4) { + var $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $5 = __stack_pointer - 208 | 0; + __stack_pointer = $5; + HEAP32[$5 + 204 >> 2] = $2; + __memset($5 + 160 | 0, 0, 40); + HEAP32[$5 + 200 >> 2] = HEAP32[$5 + 204 >> 2]; + label$1: { + if ((printf_core(0, $1, $5 + 200 | 0, $5 + 80 | 0, $5 + 160 | 0, $3, $4) | 0) < 0) { + $4 = -1; + break label$1; + } + if (HEAP32[$0 + 76 >> 2] >= 0) { + $8 = __lockfile($0); + } + $6 = HEAP32[$0 >> 2]; + if (HEAP32[$0 + 72 >> 2] <= 0) { + HEAP32[$0 >> 2] = $6 & -33; + } + label$5: { + label$6: { + label$7: { + if (!HEAP32[$0 + 48 >> 2]) { + HEAP32[$0 + 48 >> 2] = 80; + HEAP32[$0 + 28 >> 2] = 0; + HEAP32[$0 + 16 >> 2] = 0; + HEAP32[$0 + 20 >> 2] = 0; + $7 = HEAP32[$0 + 44 >> 2]; + HEAP32[$0 + 44 >> 2] = $5; + break label$7; + } + if (HEAP32[$0 + 16 >> 2]) { + break label$6; + } + } + $2 = -1; + if (__towrite($0)) { + break label$5; + } + } + $2 = printf_core($0, $1, $5 + 200 | 0, $5 + 80 | 0, $5 + 160 | 0, $3, $4); + } + $4 = $6 & 32; + if ($7) { + FUNCTION_TABLE[HEAP32[$0 + 36 >> 2]]($0, 0, 0) | 0; + HEAP32[$0 + 48 >> 2] = 0; + HEAP32[$0 + 44 >> 2] = $7; + HEAP32[$0 + 28 >> 2] = 0; + $3 = HEAP32[$0 + 20 >> 2]; + HEAP32[$0 + 16 >> 2] = 0; + HEAP32[$0 + 20 >> 2] = 0; + $2 = $3 ? $2 : -1; + } + $3 = HEAP32[$0 >> 2]; + HEAP32[$0 >> 2] = $4 | $3; + $4 = $3 & 32 ? -1 : $2; + if (!$8) { + break label$1; + } + __unlockfile($0); + } + __stack_pointer = $5 + 208 | 0; + return $4; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Joint__20_28b2World____29_28b2JointDef_20const__29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Joint__20_28b2World____29_28b2JointDef_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 511; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Joint__2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2JointDef_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Joint__2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2JointDef_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Joint__20_28b2World____emscripten__internal__getContext_b2Joint__20_28b2World____29_28b2JointDef_20const__29__28b2Joint__20_28b2World____20const__29_28b2JointDef_20const__29_29_29_28b2JointDef_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2BroadPhase__QueryCallback_28int_29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + $0 = HEAP32[$2 + 24 >> 2]; + label$1: { + if (HEAP32[$2 + 20 >> 2] == HEAP32[$0 + 56 >> 2]) { + break label$1; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2DynamicTree__WasMoved_28int_29_20const($0, HEAP32[$2 + 20 >> 2]) & 1, + HEAP8[wasm2js_i32$0 + 19 | 0] = wasm2js_i32$1; + if (!(!(HEAP8[$2 + 19 | 0] & 1) | HEAP32[$2 + 20 >> 2] <= HEAP32[$0 + 56 >> 2])) { + break label$1; + } + if (HEAP32[$0 + 52 >> 2] == HEAP32[$0 + 48 >> 2]) { + HEAP32[$2 + 12 >> 2] = HEAP32[$0 + 44 >> 2]; + HEAP32[$0 + 48 >> 2] = HEAP32[$0 + 48 >> 2] + (HEAP32[$0 + 48 >> 2] >> 1); + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Alloc_28int_29(HEAP32[$0 + 48 >> 2] << 3), + HEAP32[wasm2js_i32$0 + 44 >> 2] = wasm2js_i32$1; + __memcpy(HEAP32[$0 + 44 >> 2], HEAP32[$2 + 12 >> 2], HEAP32[$0 + 52 >> 2] << 3); + b2Free_28void__29(HEAP32[$2 + 12 >> 2]); + } + $1 = int_20b2Min_int__28int_2c_20int_29(HEAP32[$2 + 20 >> 2], HEAP32[$0 + 56 >> 2]); + HEAP32[HEAP32[$0 + 44 >> 2] + (HEAP32[$0 + 52 >> 2] << 3) >> 2] = $1; + $1 = int_20b2Max_int__28int_2c_20int_29(HEAP32[$2 + 20 >> 2], HEAP32[$0 + 56 >> 2]); + HEAP32[(HEAP32[$0 + 44 >> 2] + (HEAP32[$0 + 52 >> 2] << 3) | 0) + 4 >> 2] = $1; + HEAP32[$0 + 52 >> 2] = HEAP32[$0 + 52 >> 2] + 1; + } + HEAP8[$2 + 31 | 0] = 1; + __stack_pointer = $2 + 32 | 0; + return HEAP8[$2 + 31 | 0] & 1; +} + +function __fdopen($0, $1) { + var $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + label$1: { + label$2: { + label$3: { + if (!strchr(10404, HEAP8[$1 | 0])) { + wasm2js_i32$0 = __errno_location(), wasm2js_i32$1 = 28, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + break label$3; + } + $2 = dlmalloc(1176); + if ($2) { + break label$2; + } + } + $2 = 0; + break label$1; + } + __memset($2, 0, 144); + if (!strchr($1, 43)) { + HEAP32[$2 >> 2] = HEAPU8[$1 | 0] == 114 ? 8 : 4; + } + label$6: { + if (HEAPU8[$1 | 0] != 97) { + $1 = HEAP32[$2 >> 2]; + break label$6; + } + $1 = __syscall_fcntl64($0 | 0, 3, 0) | 0; + if (!($1 & 1024)) { + $1 = $1 | 1024; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $1 >> 31; + __syscall_fcntl64($0 | 0, 4, $3 + 16 | 0) | 0; + } + $1 = HEAP32[$2 >> 2] | 128; + HEAP32[$2 >> 2] = $1; + } + HEAP32[$2 + 80 >> 2] = -1; + HEAP32[$2 + 48 >> 2] = 1024; + HEAP32[$2 + 60 >> 2] = $0; + HEAP32[$2 + 44 >> 2] = $2 + 152; + label$9: { + if ($1 & 8) { + break label$9; + } + HEAP32[$3 >> 2] = $3 + 24; + HEAP32[$3 + 4 >> 2] = 0; + if (__syscall_ioctl($0 | 0, 21523, $3 | 0) | 0) { + break label$9; + } + HEAP32[$2 + 80 >> 2] = 10; + } + HEAP32[$2 + 40 >> 2] = 958; + HEAP32[$2 + 36 >> 2] = 959; + HEAP32[$2 + 32 >> 2] = 960; + HEAP32[$2 + 12 >> 2] = 961; + if (!HEAPU8[31025]) { + HEAP32[$2 + 76 >> 2] = -1; + } + $2 = __ofl_add($2); + } + __stack_pointer = $3 + 32 | 0; + return $2; +} + +function emscripten__value_object_b2Filter___20emscripten__value_object_b2Filter___field_b2Filter_2c_20unsigned_20short__28char_20const__2c_20unsigned_20short_20b2Filter____29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $2; + $0 = HEAP32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = 464; + HEAP32[$3 + 4 >> 2] = 465; + $1 = emscripten__internal__TypeID_b2Filter_2c_20void___get_28_29(); + $2 = HEAP32[$3 + 16 >> 2]; + $4 = emscripten__internal__TypeID_unsigned_20short_2c_20void___get_28_29(); + HEAP32[$3 + 24 >> 2] = HEAP32[$3 + 8 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$3 + 8 >> 2]; + $7 = unsigned_20short_20b2Filter_____20emscripten__internal__getContext_unsigned_20short_20b2Filter_____28unsigned_20short_20b2Filter____20const__29($3 + 12 | 0); + $8 = emscripten__internal__TypeID_unsigned_20short_2c_20void___get_28_29(); + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 4 >> 2]; + _embind_register_value_object_field($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$3 + 4 >> 2], unsigned_20short_20b2Filter_____20emscripten__internal__getContext_unsigned_20short_20b2Filter_____28unsigned_20short_20b2Filter____20const__29($3 + 12 | 0) | 0); + __stack_pointer = $3 + 32 | 0; + return $0; +} + +function emscripten__internal__WireTypePack_unsigned_20int__2c_20unsigned_20int____WireTypePack_28unsigned_20int__2c_20unsigned_20int__29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 48 | 0; + __stack_pointer = $3; + HEAP32[$3 + 24 >> 2] = $0; + HEAP32[$3 + 20 >> 2] = $1; + HEAP32[$3 + 16 >> 2] = $2; + $0 = HEAP32[$3 + 24 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = std____2__array_emscripten__internal__GenericWireType_2c_202ul___data_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$3 + 20 >> 2]; + $2 = HEAP32[$3 + 16 >> 2]; + HEAP32[$3 + 36 >> 2] = $3 + 12; + HEAP32[$3 + 32 >> 2] = $1; + HEAP32[$3 + 28 >> 2] = $2; + void_20emscripten__internal__writeGenericWireType_unsigned_20int__28emscripten__internal__GenericWireType___2c_20unsigned_20int_29(HEAP32[$3 + 36 >> 2], emscripten__internal__BindingType_unsigned_20int_2c_20void___toWireType_28unsigned_20int_20const__29(HEAP32[$3 + 32 >> 2])); + $1 = HEAP32[$3 + 28 >> 2]; + HEAP32[$3 + 44 >> 2] = HEAP32[$3 + 36 >> 2]; + HEAP32[$3 + 40 >> 2] = $1; + void_20emscripten__internal__writeGenericWireType_unsigned_20int__28emscripten__internal__GenericWireType___2c_20unsigned_20int_29(HEAP32[$3 + 44 >> 2], emscripten__internal__BindingType_unsigned_20int_2c_20void___toWireType_28unsigned_20int_20const__29(HEAP32[$3 + 40 >> 2])); + emscripten__internal__writeGenericWireTypes_28emscripten__internal__GenericWireType___29(HEAP32[$3 + 44 >> 2]); + __stack_pointer = $3 + 48 | 0; + return $0; +} + +function emscripten__internal__MethodInvoker_void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28unsigned_20long_2c_20int_20const__29_2c_20void_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const____invoke_28void_20_28std____2__vector_int_2c_20std____2__allocator_int______20const__29_28unsigned_20long_2c_20int_20const__29_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 28 >> 2] = $0; + HEAP32[$4 + 24 >> 2] = $1; + HEAP32[$4 + 20 >> 2] = $2; + HEAP32[$4 + 16 >> 2] = $3; + $2 = emscripten__internal__BindingType_std____2__vector_int_2c_20std____2__allocator_int____2c_20void___fromWireType_28std____2__vector_int_2c_20std____2__allocator_int____29(HEAP32[$4 + 24 >> 2]); + $0 = HEAP32[$4 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $1 = emscripten__internal__BindingType_unsigned_20long_2c_20void___fromWireType_28unsigned_20long_29(HEAP32[$4 + 20 >> 2]); + wasm2js_i32$0 = $4, wasm2js_i32$1 = emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$4 + 16 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + FUNCTION_TABLE[$0 | 0]($2, $1, $4 + 12 | 0); + __stack_pointer = $4 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2PolygonShape____29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29_2c_20void_2c_20b2PolygonShape__2c_20float_2c_20float_2c_20b2Vec2_20const__2c_20float___invoke_28void_20_28b2PolygonShape____20const__29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29_2c_20b2PolygonShape__2c_20float_2c_20float_2c_20b2Vec2__2c_20float_29($0, $1, $2, $3, $4, $5) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + $3 = Math_fround($3); + $4 = $4 | 0; + $5 = Math_fround($5); + var $6 = 0; + $6 = __stack_pointer - 32 | 0; + __stack_pointer = $6; + HEAP32[$6 + 28 >> 2] = $0; + HEAP32[$6 + 24 >> 2] = $1; + HEAPF32[$6 + 20 >> 2] = $2; + HEAPF32[$6 + 16 >> 2] = $3; + HEAP32[$6 + 12 >> 2] = $4; + HEAPF32[$6 + 8 >> 2] = $5; + $4 = emscripten__internal__BindingType_b2PolygonShape__2c_20void___fromWireType_28b2PolygonShape__29(HEAP32[$6 + 24 >> 2]); + $0 = HEAP32[$6 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$6 + 20 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$6 + 16 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$6 + 12 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$6 + 8 >> 2])); + __stack_pointer = $6 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29_2c_20void_2c_20b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const____invoke_28void_20_28b2Draw____20const__29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29_2c_20b2Draw__2c_20b2Vec2__2c_20float_2c_20b2Vec2__2c_20b2Color__29($0, $1, $2, $3, $4, $5) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = Math_fround($3); + $4 = $4 | 0; + $5 = $5 | 0; + var $6 = 0; + $6 = __stack_pointer - 32 | 0; + __stack_pointer = $6; + HEAP32[$6 + 28 >> 2] = $0; + HEAP32[$6 + 24 >> 2] = $1; + HEAP32[$6 + 20 >> 2] = $2; + HEAPF32[$6 + 16 >> 2] = $3; + HEAP32[$6 + 12 >> 2] = $4; + HEAP32[$6 + 8 >> 2] = $5; + $2 = emscripten__internal__BindingType_b2Draw__2c_20void___fromWireType_28b2Draw__29(HEAP32[$6 + 24 >> 2]); + $0 = HEAP32[$6 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$6 + 20 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$6 + 16 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$6 + 12 >> 2]), emscripten__internal__GenericBindingType_b2Color___fromWireType_28b2Color__29(HEAP32[$6 + 8 >> 2])); + __stack_pointer = $6 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28b2MassData__29_20const___invoke_b2Fixture_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Fixture____29_28b2MassData__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 571; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2MassData____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2MassData____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Fixture____emscripten__internal__getContext_void_20_28b2Fixture____29_28b2MassData__29_20const__28void_20_28b2Fixture____20const__29_28b2MassData__29_20const_29_29_28b2MassData__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2Fixture____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const_2c_20bool_2c_20b2Fixture_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int___invoke_28bool_20_28b2Fixture____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const_2c_20b2Fixture_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput__2c_20int_29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + $2 = emscripten__internal__BindingType_b2Fixture_20const__2c_20void___fromWireType_28b2Fixture_20const__29(HEAP32[$5 + 24 >> 2]); + $0 = HEAP32[$5 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2RayCastOutput__2c_20void___fromWireType_28b2RayCastOutput__29(HEAP32[$5 + 20 >> 2]), emscripten__internal__GenericBindingType_b2RayCastInput___fromWireType_28b2RayCastInput__29(HEAP32[$5 + 16 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$5 + 12 >> 2])) & 1); + __stack_pointer = $5 + 32 | 0; + return $0 & 1; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2ContactListenerWrapper____29_28unsigned_20int_29___invoke_b2ContactListener__28char_20const__2c_20void_20_28b2ContactListenerWrapper____29_28unsigned_20int_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 480; + $0 = emscripten__internal__TypeID_b2ContactListenerWrapper_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20unsigned_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20unsigned_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2ContactListenerWrapper____emscripten__internal__getContext_void_20_28b2ContactListenerWrapper____29_28unsigned_20int_29__28void_20_28b2ContactListenerWrapper____20const__29_28unsigned_20int_29_29_29_28unsigned_20int_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2ContactListenerWrapper____29_28unsigned_20int_29___invoke_b2ContactListener__28char_20const__2c_20bool_20_28b2ContactListenerWrapper____29_28unsigned_20int_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 481; + $0 = emscripten__internal__TypeID_b2ContactListenerWrapper_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20unsigned_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20unsigned_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2ContactListenerWrapper____emscripten__internal__getContext_bool_20_28b2ContactListenerWrapper____29_28unsigned_20int_29__28bool_20_28b2ContactListenerWrapper____20const__29_28unsigned_20int_29_29_29_28unsigned_20int_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Body__20_28b2World____29_28b2BodyDef_20const__29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Body__20_28b2World____29_28b2BodyDef_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 509; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2BodyDef_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2BodyDef_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Body__20_28b2World____emscripten__internal__getContext_b2Body__20_28b2World____29_28b2BodyDef_20const__29__28b2Body__20_28b2World____20const__29_28b2BodyDef_20const__29_29_29_28b2BodyDef_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______lower_bound_b2Fixture___28b2Fixture__20const__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_end_node_std____2____tree_node_base_void______29($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 24 >> 2] = $0; + HEAP32[$4 + 20 >> 2] = $1; + HEAP32[$4 + 16 >> 2] = $2; + HEAP32[$4 + 12 >> 2] = $3; + $0 = HEAP32[$4 + 24 >> 2]; + while (1) { + if (HEAP32[$4 + 16 >> 2]) { + if (!(std____2__less_b2Fixture____operator_28_29_5babi_v160004_5d_28b2Fixture__20const__2c_20b2Fixture__20const__29_20const(std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____value_comp_5babi_v160004_5d_28_29($0), HEAP32[$4 + 16 >> 2] + 16 | 0, HEAP32[$4 + 20 >> 2]) & 1)) { + HEAP32[$4 + 12 >> 2] = HEAP32[$4 + 16 >> 2]; + HEAP32[$4 + 16 >> 2] = HEAP32[HEAP32[$4 + 16 >> 2] >> 2]; + continue; + } + HEAP32[$4 + 16 >> 2] = HEAP32[HEAP32[$4 + 16 >> 2] + 4 >> 2]; + continue; + } + break; + } + std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____tree_iterator_5babi_v160004_5d_28std____2____tree_end_node_std____2____tree_node_base_void______29($4 + 28 | 0, HEAP32[$4 + 12 >> 2]); + __stack_pointer = $4 + 32 | 0; + return HEAP32[$4 + 28 >> 2]; +} + +function emscripten__value_object_b2RayCastOutput___20emscripten__value_object_b2RayCastOutput___field_b2RayCastOutput_2c_20b2Vec2__28char_20const__2c_20b2Vec2_20b2RayCastOutput____29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $2; + $0 = HEAP32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = 452; + HEAP32[$3 + 4 >> 2] = 453; + $1 = emscripten__internal__TypeID_b2RayCastOutput_2c_20void___get_28_29(); + $2 = HEAP32[$3 + 16 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$3 + 24 >> 2] = HEAP32[$3 + 8 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$3 + 8 >> 2]; + $7 = b2Vec2_20b2RayCastOutput_____20emscripten__internal__getContext_b2Vec2_20b2RayCastOutput_____28b2Vec2_20b2RayCastOutput____20const__29($3 + 12 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 4 >> 2]; + _embind_register_value_object_field($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$3 + 4 >> 2], b2Vec2_20b2RayCastOutput_____20emscripten__internal__getContext_b2Vec2_20b2RayCastOutput_____28b2Vec2_20b2RayCastOutput____20const__29($3 + 12 | 0) | 0); + __stack_pointer = $3 + 32 | 0; + return $0; +} + +function b2Body__SynchronizeFixtures_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0; + $1 = __stack_pointer - 48 | 0; + __stack_pointer = $1; + HEAP32[$1 + 44 >> 2] = $0; + $2 = HEAP32[$1 + 44 >> 2]; + HEAP32[$1 + 40 >> 2] = HEAP32[$2 + 88 >> 2] + 102868; + label$1: { + if (HEAPU16[$2 + 4 >> 1] & 2) { + b2Transform__b2Transform_28_29($1 + 24 | 0); + b2Rot__Set_28float_29($1 + 32 | 0, HEAPF32[$2 + 52 >> 2]); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($1 + 8 | 0, $1 + 32 | 0, $2 + 28 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 16 | 0, $2 + 36 | 0, $1 + 8 | 0); + $3 = HEAP32[$1 + 20 >> 2]; + $0 = HEAP32[$1 + 16 >> 2]; + $4 = $0; + $0 = $1 + 24 | 0; + HEAP32[$0 >> 2] = $4; + HEAP32[$0 + 4 >> 2] = $3; + HEAP32[$1 + 4 >> 2] = HEAP32[$2 + 100 >> 2]; + while (1) { + if (HEAP32[$1 + 4 >> 2]) { + b2Fixture__Synchronize_28b2BroadPhase__2c_20b2Transform_20const__2c_20b2Transform_20const__29(HEAP32[$1 + 4 >> 2], HEAP32[$1 + 40 >> 2], $1 + 24 | 0, $2 + 12 | 0); + HEAP32[$1 + 4 >> 2] = HEAP32[HEAP32[$1 + 4 >> 2] + 4 >> 2]; + continue; + } + break; + } + break label$1; + } + HEAP32[$1 >> 2] = HEAP32[$2 + 100 >> 2]; + while (1) { + if (HEAP32[$1 >> 2]) { + b2Fixture__Synchronize_28b2BroadPhase__2c_20b2Transform_20const__2c_20b2Transform_20const__29(HEAP32[$1 >> 2], HEAP32[$1 + 40 >> 2], $2 + 12 | 0, $2 + 12 | 0); + HEAP32[$1 >> 2] = HEAP32[HEAP32[$1 >> 2] + 4 >> 2]; + continue; + } + break; + } + } + __stack_pointer = $1 + 48 | 0; +} + +function std____2____compressed_pair_std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_________compressed_pair_5babi_v160004_5d_std____2____tree_node_b2Fixture__2c_20void_____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______28std____2____tree_node_b2Fixture__2c_20void_____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + std____2____compressed_pair_elem_std____2____tree_node_b2Fixture__2c_20void____2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std____2____tree_node_b2Fixture__2c_20void_____2c_20void__28std____2____tree_node_b2Fixture__2c_20void_____29($0, HEAP32[$3 + 8 >> 2]); + std____2____compressed_pair_elem_std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_201_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20void__28std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______29($0 + 4 | 0, HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; + return $0; +} + +function emscripten__internal__FunctionInvoker_bool_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29_2c_20bool_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const____invoke_28bool_20_28___29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 28 >> 2] = $0; + HEAP32[$4 + 24 >> 2] = $1; + HEAP32[$4 + 20 >> 2] = $2; + HEAP32[$4 + 16 >> 2] = $3; + $0 = HEAP32[HEAP32[$4 + 28 >> 2] >> 2]; + $1 = emscripten__internal__GenericBindingType_std____2__vector_int_2c_20std____2__allocator_int_____fromWireType_28std____2__vector_int_2c_20std____2__allocator_int____29(HEAP32[$4 + 24 >> 2]); + $2 = emscripten__internal__BindingType_unsigned_20long_2c_20void___fromWireType_28unsigned_20long_29(HEAP32[$4 + 20 >> 2]); + wasm2js_i32$0 = $4, wasm2js_i32$1 = emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$4 + 16 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($1, $2, $4 + 12 | 0) & 1); + __stack_pointer = $4 + 32 | 0; + return $0 & 1; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28b2Transform_20const__29___invoke_b2Draw_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Draw____29_28b2Transform_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 492; + $0 = emscripten__internal__TypeID_b2Draw_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Transform_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Transform_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Draw____emscripten__internal__getContext_void_20_28b2Draw____29_28b2Transform_20const__29__28void_20_28b2Draw____20const__29_28b2Transform_20const__29_29_29_28b2Transform_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__value_object_b2RayCastOutput___20emscripten__value_object_b2RayCastOutput___field_b2RayCastOutput_2c_20float__28char_20const__2c_20float_20b2RayCastOutput____29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $2; + $0 = HEAP32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = 454; + HEAP32[$3 + 4 >> 2] = 455; + $1 = emscripten__internal__TypeID_b2RayCastOutput_2c_20void___get_28_29(); + $2 = HEAP32[$3 + 16 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$3 + 24 >> 2] = HEAP32[$3 + 8 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$3 + 8 >> 2]; + $7 = float_20b2RayCastOutput_____20emscripten__internal__getContext_float_20b2RayCastOutput_____28float_20b2RayCastOutput____20const__29($3 + 12 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 4 >> 2]; + _embind_register_value_object_field($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$3 + 4 >> 2], float_20b2RayCastOutput_____20emscripten__internal__getContext_float_20b2RayCastOutput_____28float_20b2RayCastOutput____20const__29($3 + 12 | 0) | 0); + __stack_pointer = $3 + 32 | 0; + return $0; +} + +function b2Contact__b2Contact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + $0 = HEAP32[$5 + 28 >> 2]; + HEAP32[$0 >> 2] = 18408; + b2Manifold__b2Manifold_28_29($0 - -64 | 0); + HEAP32[$0 + 4 >> 2] = 4; + HEAP32[$0 + 48 >> 2] = HEAP32[$5 + 24 >> 2]; + HEAP32[$0 + 52 >> 2] = HEAP32[$5 + 16 >> 2]; + HEAP32[$0 + 56 >> 2] = HEAP32[$5 + 20 >> 2]; + HEAP32[$0 + 60 >> 2] = HEAP32[$5 + 12 >> 2]; + HEAP32[$0 + 124 >> 2] = 0; + HEAP32[$0 + 8 >> 2] = 0; + HEAP32[$0 + 12 >> 2] = 0; + HEAP32[$0 + 20 >> 2] = 0; + HEAP32[$0 + 24 >> 2] = 0; + HEAP32[$0 + 28 >> 2] = 0; + HEAP32[$0 + 16 >> 2] = 0; + HEAP32[$0 + 36 >> 2] = 0; + HEAP32[$0 + 40 >> 2] = 0; + HEAP32[$0 + 44 >> 2] = 0; + HEAP32[$0 + 32 >> 2] = 0; + HEAP32[$0 + 128 >> 2] = 0; + wasm2js_i32$0 = $0, wasm2js_f32$0 = b2MixFriction_28float_2c_20float_29(HEAPF32[HEAP32[$0 + 48 >> 2] + 16 >> 2], HEAPF32[HEAP32[$0 + 52 >> 2] + 16 >> 2]), + HEAPF32[wasm2js_i32$0 + 136 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $0, wasm2js_f32$0 = b2MixRestitution_28float_2c_20float_29(HEAPF32[HEAP32[$0 + 48 >> 2] + 20 >> 2], HEAPF32[HEAP32[$0 + 52 >> 2] + 20 >> 2]), + HEAPF32[wasm2js_i32$0 + 140 >> 2] = wasm2js_f32$0; + HEAPF32[$0 + 144 >> 2] = 0; + __stack_pointer = $5 + 32 | 0; + return $0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2ContactListener__29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28b2ContactListener__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 506; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2ContactListener____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2ContactListener____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2ContactListener__29__28void_20_28b2World____20const__29_28b2ContactListener__29_29_29_28b2ContactListener__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2MassData__29_20const___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Body____29_28b2MassData__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 589; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20b2MassData____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20b2MassData____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2MassData__29_20const__28void_20_28b2Body____20const__29_28b2MassData__29_20const_29_29_28b2MassData__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__value_object_b2RayCastInput___20emscripten__value_object_b2RayCastInput___field_b2RayCastInput_2c_20b2Vec2__28char_20const__2c_20b2Vec2_20b2RayCastInput____29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $2; + $0 = HEAP32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = 446; + HEAP32[$3 + 4 >> 2] = 447; + $1 = emscripten__internal__TypeID_b2RayCastInput_2c_20void___get_28_29(); + $2 = HEAP32[$3 + 16 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$3 + 24 >> 2] = HEAP32[$3 + 8 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$3 + 8 >> 2]; + $7 = b2Vec2_20b2RayCastInput_____20emscripten__internal__getContext_b2Vec2_20b2RayCastInput_____28b2Vec2_20b2RayCastInput____20const__29($3 + 12 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 4 >> 2]; + _embind_register_value_object_field($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$3 + 4 >> 2], b2Vec2_20b2RayCastInput_____20emscripten__internal__getContext_b2Vec2_20b2RayCastInput_____28b2Vec2_20b2RayCastInput____20const__29($3 + 12 | 0) | 0); + __stack_pointer = $3 + 32 | 0; + return $0; +} + +function emscripten__value_object_b2RayCastInput___20emscripten__value_object_b2RayCastInput___field_b2RayCastInput_2c_20float__28char_20const__2c_20float_20b2RayCastInput____29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $2; + $0 = HEAP32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = 448; + HEAP32[$3 + 4 >> 2] = 449; + $1 = emscripten__internal__TypeID_b2RayCastInput_2c_20void___get_28_29(); + $2 = HEAP32[$3 + 16 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$3 + 24 >> 2] = HEAP32[$3 + 8 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$3 + 8 >> 2]; + $7 = float_20b2RayCastInput_____20emscripten__internal__getContext_float_20b2RayCastInput_____28float_20b2RayCastInput____20const__29($3 + 12 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 4 >> 2]; + _embind_register_value_object_field($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$3 + 4 >> 2], float_20b2RayCastInput_____20emscripten__internal__getContext_float_20b2RayCastInput_____28float_20b2RayCastInput____20const__29($3 + 12 | 0) | 0); + __stack_pointer = $3 + 32 | 0; + return $0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2PrismaticJoint____29_28float_2c_20float_29___invoke_b2PrismaticJoint__28char_20const__2c_20void_20_28b2PrismaticJoint____29_28float_2c_20float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 647; + $0 = emscripten__internal__TypeID_b2PrismaticJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20float_2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20float_2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2PrismaticJoint____emscripten__internal__getContext_void_20_28b2PrismaticJoint____29_28float_2c_20float_29__28void_20_28b2PrismaticJoint____20const__29_28float_2c_20float_29_29_29_28float_2c_20float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2RevoluteJoint____29_28float_2c_20float_29___invoke_b2RevoluteJoint__28char_20const__2c_20void_20_28b2RevoluteJoint____29_28float_2c_20float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 660; + $0 = emscripten__internal__TypeID_b2RevoluteJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20float_2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20float_2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2RevoluteJoint____emscripten__internal__getContext_void_20_28b2RevoluteJoint____29_28float_2c_20float_29__28void_20_28b2RevoluteJoint____20const__29_28float_2c_20float_29_29_29_28float_2c_20float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2DistanceJoint__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 144 | 0; + __stack_pointer = $1; + HEAP32[$1 + 140 >> 2] = $0; + $0 = HEAP32[$1 + 140 >> 2]; + HEAP32[$1 + 136 >> 2] = HEAP32[HEAP32[$0 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 132 >> 2] = HEAP32[HEAP32[$0 + 52 >> 2] + 8 >> 2]; + b2Dump_28char_20const__2c_20____29(13635, 0); + HEAP32[$1 + 96 >> 2] = HEAP32[$1 + 136 >> 2]; + b2Dump_28char_20const__2c_20____29(13849, $1 + 96 | 0); + HEAP32[$1 + 80 >> 2] = HEAP32[$1 + 132 >> 2]; + b2Dump_28char_20const__2c_20____29(13823, $1 + 80 | 0); + HEAP32[$1 + 64 >> 2] = HEAP8[$0 + 61 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14859, $1 - -64 | 0); + $2 = HEAPF32[$0 + 80 >> 2]; + HEAPF64[$1 + 56 >> 3] = HEAPF32[$0 + 84 >> 2]; + HEAPF64[$1 + 48 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14265, $1 + 48 | 0); + $2 = HEAPF32[$0 + 88 >> 2]; + HEAPF64[$1 + 40 >> 3] = HEAPF32[$0 + 92 >> 2]; + HEAPF64[$1 + 32 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14158, $1 + 32 | 0); + HEAPF64[$1 + 16 >> 3] = HEAPF32[$0 + 104 >> 2]; + b2Dump_28char_20const__2c_20____29(12920, $1 + 16 | 0); + HEAPF64[$1 >> 3] = HEAPF32[$0 + 68 >> 2]; + b2Dump_28char_20const__2c_20____29(12730, $1); + HEAPF64[$1 + 112 >> 3] = HEAPF32[$0 + 72 >> 2]; + b2Dump_28char_20const__2c_20____29(12965, $1 + 112 | 0); + HEAP32[$1 + 128 >> 2] = HEAP32[$0 + 56 >> 2]; + b2Dump_28char_20const__2c_20____29(14538, $1 + 128 | 0); + __stack_pointer = $1 + 144 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20b2Vec2_20const__20_28b2PrismaticJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 643; + $0 = emscripten__internal__TypeID_b2PrismaticJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20const__20_28b2PrismaticJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2PrismaticJoint____29_28_29_20const__28b2Vec2_20const__20_28b2PrismaticJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2WeldJoint__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 144 | 0; + __stack_pointer = $1; + HEAP32[$1 + 140 >> 2] = $0; + $0 = HEAP32[$1 + 140 >> 2]; + HEAP32[$1 + 136 >> 2] = HEAP32[HEAP32[$0 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 132 >> 2] = HEAP32[HEAP32[$0 + 52 >> 2] + 8 >> 2]; + b2Dump_28char_20const__2c_20____29(13661, 0); + HEAP32[$1 + 96 >> 2] = HEAP32[$1 + 136 >> 2]; + b2Dump_28char_20const__2c_20____29(13849, $1 + 96 | 0); + HEAP32[$1 + 80 >> 2] = HEAP32[$1 + 132 >> 2]; + b2Dump_28char_20const__2c_20____29(13823, $1 + 80 | 0); + HEAP32[$1 + 64 >> 2] = HEAP8[$0 + 61 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14859, $1 - -64 | 0); + $2 = HEAPF32[$0 + 80 >> 2]; + HEAPF64[$1 + 56 >> 3] = HEAPF32[$0 + 84 >> 2]; + HEAPF64[$1 + 48 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14265, $1 + 48 | 0); + $2 = HEAPF32[$0 + 88 >> 2]; + HEAPF64[$1 + 40 >> 3] = HEAPF32[$0 + 92 >> 2]; + HEAPF64[$1 + 32 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14158, $1 + 32 | 0); + HEAPF64[$1 + 16 >> 3] = HEAPF32[$0 + 96 >> 2]; + b2Dump_28char_20const__2c_20____29(13167, $1 + 16 | 0); + HEAPF64[$1 >> 3] = HEAPF32[$0 + 68 >> 2]; + b2Dump_28char_20const__2c_20____29(12730, $1); + HEAPF64[$1 + 112 >> 3] = HEAPF32[$0 + 72 >> 2]; + b2Dump_28char_20const__2c_20____29(12965, $1 + 112 | 0); + HEAP32[$1 + 128 >> 2] = HEAP32[$0 + 56 >> 2]; + b2Dump_28char_20const__2c_20____29(14538, $1 + 128 | 0); + __stack_pointer = $1 + 144 | 0; +} + +function void_20std____2____tree_left_rotate_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$1 + 8 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] + 4 >> 2]; + HEAP32[HEAP32[$1 + 12 >> 2] + 4 >> 2] = HEAP32[HEAP32[$1 + 8 >> 2] >> 2]; + if (HEAP32[HEAP32[$1 + 12 >> 2] + 4 >> 2]) { + std____2____tree_node_base_void______set_parent_5babi_v160004_5d_28std____2____tree_node_base_void____29(HEAP32[HEAP32[$1 + 12 >> 2] + 4 >> 2], HEAP32[$1 + 12 >> 2]); + } + HEAP32[HEAP32[$1 + 8 >> 2] + 8 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] + 8 >> 2]; + label$2: { + if (bool_20std____2____tree_is_left_child_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$1 + 12 >> 2]) & 1) { + HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] + 8 >> 2] >> 2] = HEAP32[$1 + 8 >> 2]; + break label$2; + } + $0 = HEAP32[$1 + 8 >> 2]; + wasm2js_i32$0 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]), + wasm2js_i32$1 = $0, HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + } + HEAP32[HEAP32[$1 + 8 >> 2] >> 2] = HEAP32[$1 + 12 >> 2]; + std____2____tree_node_base_void______set_parent_5babi_v160004_5d_28std____2____tree_node_base_void____29(HEAP32[$1 + 12 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2PolygonShape____29_28float_2c_20float_29___invoke_b2PolygonShape__28char_20const__2c_20void_20_28b2PolygonShape____29_28float_2c_20float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 556; + $0 = emscripten__internal__TypeID_b2PolygonShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20float_2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20float_2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2PolygonShape____emscripten__internal__getContext_void_20_28b2PolygonShape____29_28float_2c_20float_29__28void_20_28b2PolygonShape____20const__29_28float_2c_20float_29_29_29_28float_2c_20float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__value_object_b2Transform___20emscripten__value_object_b2Transform___field_b2Transform_2c_20b2Vec2__28char_20const__2c_20b2Vec2_20b2Transform____29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $2; + $0 = HEAP32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = 436; + HEAP32[$3 + 4 >> 2] = 437; + $1 = emscripten__internal__TypeID_b2Transform_2c_20void___get_28_29(); + $2 = HEAP32[$3 + 16 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$3 + 24 >> 2] = HEAP32[$3 + 8 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$3 + 8 >> 2]; + $7 = b2Vec2_20b2Transform_____20emscripten__internal__getContext_b2Vec2_20b2Transform_____28b2Vec2_20b2Transform____20const__29($3 + 12 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 4 >> 2]; + _embind_register_value_object_field($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$3 + 4 >> 2], b2Vec2_20b2Transform_____20emscripten__internal__getContext_b2Vec2_20b2Transform_____28b2Vec2_20b2Transform____20const__29($3 + 12 | 0) | 0); + __stack_pointer = $3 + 32 | 0; + return $0; +} + +function b2Contact__AddType_28b2Contact__20_28__29_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29_2c_20void_20_28__29_28b2Contact__2c_20b2BlockAllocator__29_2c_20b2Shape__Type_2c_20b2Shape__Type_29($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + if (!(HEAP32[$4 + 4 >> 2] < 4 & HEAP32[$4 + 4 >> 2] >= 0)) { + __assert_fail(2326, 5153, 58, 9292); + wasm2js_trap(); + } + if (!(HEAP32[$4 >> 2] < 4 & HEAP32[$4 >> 2] >= 0)) { + __assert_fail(2283, 5153, 59, 9292); + wasm2js_trap(); + } + HEAP32[(Math_imul(HEAP32[$4 + 4 >> 2], 48) + 30784 | 0) + Math_imul(HEAP32[$4 >> 2], 12) >> 2] = HEAP32[$4 + 12 >> 2]; + HEAP32[((Math_imul(HEAP32[$4 + 4 >> 2], 48) + 30784 | 0) + Math_imul(HEAP32[$4 >> 2], 12) | 0) + 4 >> 2] = HEAP32[$4 + 8 >> 2]; + HEAP8[((Math_imul(HEAP32[$4 + 4 >> 2], 48) + 30784 | 0) + Math_imul(HEAP32[$4 >> 2], 12) | 0) + 8 | 0] = 1; + if (HEAP32[$4 + 4 >> 2] != HEAP32[$4 >> 2]) { + HEAP32[(Math_imul(HEAP32[$4 >> 2], 48) + 30784 | 0) + Math_imul(HEAP32[$4 + 4 >> 2], 12) >> 2] = HEAP32[$4 + 12 >> 2]; + HEAP32[((Math_imul(HEAP32[$4 >> 2], 48) + 30784 | 0) + Math_imul(HEAP32[$4 + 4 >> 2], 12) | 0) + 4 >> 2] = HEAP32[$4 + 8 >> 2]; + HEAP8[((Math_imul(HEAP32[$4 >> 2], 48) + 30784 | 0) + Math_imul(HEAP32[$4 + 4 >> 2], 12) | 0) + 8 | 0] = 0; + } + __stack_pointer = $4 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2Vec2_20const__2c_20float_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28b2Vec2_20const__2c_20float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 580; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2Vec2_20const__2c_20float_29__28void_20_28b2Body____20const__29_28b2Vec2_20const__2c_20float_29_29_29_28b2Vec2_20const__2c_20float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20b2Vec2_20const__20_28b2RevoluteJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 656; + $0 = emscripten__internal__TypeID_b2RevoluteJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20const__20_28b2RevoluteJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2RevoluteJoint____29_28_29_20const__28b2Vec2_20const__20_28b2RevoluteJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2DistanceJoint____29_28_29_20const___invoke_b2DistanceJoint__28char_20const__2c_20b2Vec2_20const__20_28b2DistanceJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 614; + $0 = emscripten__internal__TypeID_b2DistanceJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20const__20_28b2DistanceJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2DistanceJoint____29_28_29_20const__28b2Vec2_20const__20_28b2DistanceJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20std____2____tree_right_rotate_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$1 + 8 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[HEAP32[$1 + 12 >> 2] >> 2] = HEAP32[HEAP32[$1 + 8 >> 2] + 4 >> 2]; + if (HEAP32[HEAP32[$1 + 12 >> 2] >> 2]) { + std____2____tree_node_base_void______set_parent_5babi_v160004_5d_28std____2____tree_node_base_void____29(HEAP32[HEAP32[$1 + 12 >> 2] >> 2], HEAP32[$1 + 12 >> 2]); + } + HEAP32[HEAP32[$1 + 8 >> 2] + 8 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] + 8 >> 2]; + label$2: { + if (bool_20std____2____tree_is_left_child_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$1 + 12 >> 2]) & 1) { + HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] + 8 >> 2] >> 2] = HEAP32[$1 + 8 >> 2]; + break label$2; + } + $0 = HEAP32[$1 + 8 >> 2]; + wasm2js_i32$0 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]), + wasm2js_i32$1 = $0, HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + } + HEAP32[HEAP32[$1 + 8 >> 2] + 4 >> 2] = HEAP32[$1 + 12 >> 2]; + std____2____tree_node_base_void______set_parent_5babi_v160004_5d_28std____2____tree_node_base_void____29(HEAP32[$1 + 12 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2PrismaticJoint____29_28float_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20float_20_28b2PrismaticJoint____29_28float_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 649; + $0 = emscripten__internal__TypeID_b2PrismaticJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2PrismaticJoint____emscripten__internal__getContext_float_20_28b2PrismaticJoint____29_28float_29_20const__28float_20_28b2PrismaticJoint____20const__29_28float_29_20const_29_29_28float_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28float_2c_20int_2c_20int_29___invoke_b2World__28char_20const__2c_20void_20_28b2World____29_28float_2c_20int_2c_20int_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 513; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20float_2c_20int_2c_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20float_2c_20int_2c_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28float_2c_20int_2c_20int_29__28void_20_28b2World____20const__29_28float_2c_20int_2c_20int_29_29_29_28float_2c_20int_2c_20int_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Fixture____29_28b2Vec2_20const__29_20const___invoke_b2Fixture__28char_20const__2c_20bool_20_28b2Fixture____29_28b2Vec2_20const__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 569; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2Vec2_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2Fixture____emscripten__internal__getContext_bool_20_28b2Fixture____29_28b2Vec2_20const__29_20const__28bool_20_28b2Fixture____20const__29_28b2Vec2_20const__29_20const_29_29_28b2Vec2_20const__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__value_object_b2Transform___20emscripten__value_object_b2Transform___field_b2Transform_2c_20b2Rot__28char_20const__2c_20b2Rot_20b2Transform____29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $2; + $0 = HEAP32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = 438; + HEAP32[$3 + 4 >> 2] = 439; + $1 = emscripten__internal__TypeID_b2Transform_2c_20void___get_28_29(); + $2 = HEAP32[$3 + 16 >> 2]; + $4 = emscripten__internal__TypeID_b2Rot_2c_20void___get_28_29(); + HEAP32[$3 + 24 >> 2] = HEAP32[$3 + 8 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$3 + 8 >> 2]; + $7 = b2Rot_20b2Transform_____20emscripten__internal__getContext_b2Rot_20b2Transform_____28b2Rot_20b2Transform____20const__29($3 + 12 | 0); + $8 = emscripten__internal__TypeID_b2Rot_2c_20void___get_28_29(); + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 4 >> 2]; + _embind_register_value_object_field($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$3 + 4 >> 2], b2Rot_20b2Transform_____20emscripten__internal__getContext_b2Rot_20b2Transform_____28b2Rot_20b2Transform____20const__29($3 + 12 | 0) | 0); + __stack_pointer = $3 + 32 | 0; + return $0; +} + +function emscripten__value_object_b2MassData___20emscripten__value_object_b2MassData___field_b2MassData_2c_20b2Vec2__28char_20const__2c_20b2Vec2_20b2MassData____29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $2; + $0 = HEAP32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = 460; + HEAP32[$3 + 4 >> 2] = 461; + $1 = emscripten__internal__TypeID_b2MassData_2c_20void___get_28_29(); + $2 = HEAP32[$3 + 16 >> 2]; + $4 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$3 + 24 >> 2] = HEAP32[$3 + 8 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$3 + 8 >> 2]; + $7 = b2Vec2_20b2MassData_____20emscripten__internal__getContext_b2Vec2_20b2MassData_____28b2Vec2_20b2MassData____20const__29($3 + 12 | 0); + $8 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 4 >> 2]; + _embind_register_value_object_field($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$3 + 4 >> 2], b2Vec2_20b2MassData_____20emscripten__internal__getContext_b2Vec2_20b2MassData_____28b2Vec2_20b2MassData____20const__29($3 + 12 | 0) | 0); + __stack_pointer = $3 + 32 | 0; + return $0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2Vec2_20const__2c_20bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28b2Vec2_20const__2c_20bool_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 587; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20bool___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20bool___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2Vec2_20const__2c_20bool_29__28void_20_28b2Body____20const__29_28b2Vec2_20const__2c_20bool_29_29_29_28b2Vec2_20const__2c_20bool_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2RevoluteJoint____29_28float_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20float_20_28b2RevoluteJoint____29_28float_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 662; + $0 = emscripten__internal__TypeID_b2RevoluteJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2RevoluteJoint____emscripten__internal__getContext_float_20_28b2RevoluteJoint____29_28float_29_20const__28float_20_28b2RevoluteJoint____20const__29_28float_29_20const_29_29_28float_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2AABB_20const__20_28b2Fixture____29_28int_29_20const___invoke_b2Fixture__28char_20const__2c_20b2AABB_20const__20_28b2Fixture____29_28int_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 574; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2AABB_20const__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2AABB_20const__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2AABB_20const__20_28b2Fixture____emscripten__internal__getContext_b2AABB_20const__20_28b2Fixture____29_28int_29_20const__28b2AABB_20const__20_28b2Fixture____20const__29_28int_29_20const_29_29_28int_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__value_object_b2MassData___20emscripten__value_object_b2MassData___field_b2MassData_2c_20float__28char_20const__2c_20float_20b2MassData____29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $2; + $0 = HEAP32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = 458; + HEAP32[$3 + 4 >> 2] = 459; + $1 = emscripten__internal__TypeID_b2MassData_2c_20void___get_28_29(); + $2 = HEAP32[$3 + 16 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$3 + 24 >> 2] = HEAP32[$3 + 8 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$3 + 8 >> 2]; + $7 = float_20b2MassData_____20emscripten__internal__getContext_float_20b2MassData_____28float_20b2MassData____20const__29($3 + 12 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 4 >> 2]; + _embind_register_value_object_field($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$3 + 4 >> 2], float_20b2MassData_____20emscripten__internal__getContext_float_20b2MassData_____28float_20b2MassData____20const__29($3 + 12 | 0) | 0); + __stack_pointer = $3 + 32 | 0; + return $0; +} + +function __rem_pio2f($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + $5 = (wasm2js_scratch_store_f32($0), wasm2js_scratch_load_i32(2)); + $2 = $5 & 2147483647; + label$1: { + if ($2 >>> 0 <= 1305022426) { + $6 = +$0; + $3 = $6 * .6366197723675814 + 6755399441055744 + -6755399441055744; + $7 = $6 + $3 * -1.5707963109016418 + $3 * -1.5893254773528196e-8; + HEAPF64[$1 >> 3] = $7; + $5 = $7 < -.7853981852531433; + if (Math_abs($3) < 2147483648) { + $2 = ~~$3; + } else { + $2 = -2147483648; + } + if ($5) { + $3 = $3 + -1; + HEAPF64[$1 >> 3] = $6 + $3 * -1.5707963109016418 + $3 * -1.5893254773528196e-8; + $2 = $2 - 1 | 0; + break label$1; + } + if (!($7 > .7853981852531433)) { + break label$1; + } + $3 = $3 + 1; + HEAPF64[$1 >> 3] = $6 + $3 * -1.5707963109016418 + $3 * -1.5893254773528196e-8; + $2 = $2 + 1 | 0; + break label$1; + } + if ($2 >>> 0 >= 2139095040) { + HEAPF64[$1 >> 3] = Math_fround($0 - $0); + $2 = 0; + break label$1; + } + $8 = ($2 >>> 23 | 0) - 150 | 0; + HEAPF64[$4 + 8 >> 3] = (wasm2js_scratch_store_i32(2, $2 - ($8 << 23) | 0), wasm2js_scratch_load_f32()); + $2 = __rem_pio2_large($4 + 8 | 0, $4, $8, 1, 0); + $3 = HEAPF64[$4 >> 3]; + if (($5 | 0) < 0) { + HEAPF64[$1 >> 3] = -$3; + $2 = 0 - $2 | 0; + break label$1; + } + HEAPF64[$1 >> 3] = $3; + } + __stack_pointer = $4 + 16 | 0; + return $2; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const___invoke_b2Body__28char_20const__2c_20b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 592; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20b2Vec2_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20_28b2Body____emscripten__internal__getContext_b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const__28b2Vec2_20_28b2Body____20const__29_28b2Vec2_20const__29_20const_29_29_28b2Vec2_20const__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2__pair_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____20std____2____dispatch_copy_or_move_5babi_v160004_5d_std____2___ClassicAlgPolicy_2c_20std____2____move_loop_std____2___ClassicAlgPolicy__2c_20std____2____move_trivial_2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 28 >> 2] = $1; + HEAP32[$4 + 24 >> 2] = $2; + HEAP32[$4 + 20 >> 2] = $3; + HEAP32[$4 + 16 >> 2] = HEAP32[$4 + 28 >> 2]; + HEAP32[$4 + 12 >> 2] = HEAP32[$4 + 24 >> 2]; + HEAP32[$4 + 8 >> 2] = HEAP32[$4 + 20 >> 2]; + std____2__pair_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____20std____2____unwrap_and_dispatch_5babi_v160004_5d_std____2____overload_std____2____move_loop_std____2___ClassicAlgPolicy__2c_20std____2____move_trivial__2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_200__28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($0, HEAP32[$4 + 16 >> 2], HEAP32[$4 + 12 >> 2], HEAP32[$4 + 8 >> 2]); + __stack_pointer = $4 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2Fixture__29___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2Body____29_28b2Fixture__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 579; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Fixture____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Fixture____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2Fixture__29__28void_20_28b2Body____20const__29_28b2Fixture__29_29_29_28b2Fixture__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2WheelJoint____29_28_29_20const___invoke_b2WheelJoint__28char_20const__2c_20b2Vec2_20const__20_28b2WheelJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 689; + $0 = emscripten__internal__TypeID_b2WheelJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20const__20_28b2WheelJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2WheelJoint____29_28_29_20const__28b2Vec2_20const__20_28b2WheelJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2MouseJoint____29_28_29_20const___invoke_b2MouseJoint__28char_20const__2c_20b2Vec2_20const__20_28b2MouseJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 634; + $0 = emscripten__internal__TypeID_b2MouseJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20const__20_28b2MouseJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2MouseJoint____29_28_29_20const__28b2Vec2_20const__20_28b2MouseJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2MotorJoint____29_28_29_20const___invoke_b2MotorJoint__28char_20const__2c_20b2Vec2_20const__20_28b2MotorJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 624; + $0 = emscripten__internal__TypeID_b2MotorJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20const__20_28b2MotorJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2MotorJoint____29_28_29_20const__28b2Vec2_20const__20_28b2MotorJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2Joint__29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28b2Joint__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 512; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Joint____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Joint____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2Joint__29__28void_20_28b2World____20const__29_28b2Joint__29_29_29_28b2Joint__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2AABB____29_28b2AABB_20const__29_20const___invoke_b2AABB__28char_20const__2c_20bool_20_28b2AABB____29_28b2AABB_20const__29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 503; + $0 = emscripten__internal__TypeID_b2AABB_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20b2AABB_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20b2AABB_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2AABB____emscripten__internal__getContext_bool_20_28b2AABB____29_28b2AABB_20const__29_20const__28bool_20_28b2AABB____20const__29_28b2AABB_20const__29_20const_29_29_28b2AABB_20const__29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2MouseJoint____29_28b2Vec2_20const__29___invoke_b2MouseJoint__28char_20const__2c_20void_20_28b2MouseJoint____29_28b2Vec2_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 633; + $0 = emscripten__internal__TypeID_b2MouseJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20b2Vec2_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2MouseJoint____emscripten__internal__getContext_void_20_28b2MouseJoint____29_28b2Vec2_20const__29__28void_20_28b2MouseJoint____20const__29_28b2Vec2_20const__29_29_29_28b2Vec2_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2MotorJoint____29_28b2Vec2_20const__29___invoke_b2MotorJoint__28char_20const__2c_20void_20_28b2MotorJoint____29_28b2Vec2_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 623; + $0 = emscripten__internal__TypeID_b2MotorJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20b2Vec2_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2MotorJoint____emscripten__internal__getContext_void_20_28b2MotorJoint____29_28b2Vec2_20const__29__28void_20_28b2MotorJoint____20const__29_28b2Vec2_20const__29_29_29_28b2Vec2_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______recommend_5babi_v160004_5d_28unsigned_20long_29_20const($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + $0 = HEAP32[$2 + 24 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____max_size_28_29_20const($0), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + if (HEAPU32[$2 + 20 >> 2] > HEAPU32[$2 + 16 >> 2]) { + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______throw_length_error_5babi_v160004_5d_28_29_20const($0); + wasm2js_trap(); + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____capacity_5babi_v160004_5d_28_29_20const($0), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + label$2: { + if (HEAPU32[$2 + 12 >> 2] >= HEAP32[$2 + 16 >> 2] >>> 1 >>> 0) { + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 16 >> 2]; + break label$2; + } + HEAP32[$2 + 8 >> 2] = HEAP32[$2 + 12 >> 2] << 1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = HEAP32[unsigned_20long_20const__20std____2__max_5babi_v160004_5d_unsigned_20long__28unsigned_20long_20const__2c_20unsigned_20long_20const__29($2 + 8 | 0, $2 + 20 | 0) >> 2], + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + } + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______construct_at_end_28unsigned_20long_2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____ConstructTransaction___ConstructTransaction_5babi_v160004_5d_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_29($3 + 8 | 0, $0, HEAP32[$3 + 24 >> 2]); + HEAP32[$3 + 4 >> 2] = HEAP32[$3 + 16 >> 2]; + HEAP32[$3 >> 2] = HEAP32[$3 + 12 >> 2]; + while (1) { + if (HEAP32[$3 >> 2] != HEAP32[$3 + 4 >> 2]) { + void_20std____2__allocator_traits_std____2__allocator_b2Vec2____construct_5babi_v160004_5d_b2Vec2_2c_20b2Vec2_20const__2c_20void__28std____2__allocator_b2Vec2___2c_20b2Vec2__2c_20b2Vec2_20const__29(std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______alloc_5babi_v160004_5d_28_29($0), b2Vec2__20std____2____to_address_5babi_v160004_5d_b2Vec2__28b2Vec2__29(HEAP32[$3 >> 2]), HEAP32[$3 + 20 >> 2]); + $1 = HEAP32[$3 >> 2] + 8 | 0; + HEAP32[$3 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $1; + continue; + } + break; + } + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____ConstructTransaction____ConstructTransaction_5babi_v160004_5d_28_29($3 + 8 | 0); + __stack_pointer = $3 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2WeldJoint____29_28_29_20const___invoke_b2WeldJoint__28char_20const__2c_20b2Vec2_20const__20_28b2WeldJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 680; + $0 = emscripten__internal__TypeID_b2WeldJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20const__20_28b2WeldJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2WeldJoint____29_28_29_20const__28b2Vec2_20const__20_28b2WeldJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2RopeJoint____29_28_29_20const___invoke_b2RopeJoint__28char_20const__2c_20b2Vec2_20const__20_28b2RopeJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 669; + $0 = emscripten__internal__TypeID_b2RopeJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20const__20_28b2RopeJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2RopeJoint____29_28_29_20const__28b2Vec2_20const__20_28b2RopeJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2WheelJoint____29_28float_29_20const___invoke_b2WheelJoint__28char_20const__2c_20float_20_28b2WheelJoint____29_28float_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 694; + $0 = emscripten__internal__TypeID_b2WheelJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2WheelJoint____emscripten__internal__getContext_float_20_28b2WheelJoint____29_28float_29_20const__28float_20_28b2WheelJoint____20const__29_28float_29_20const_29_29_28float_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2Draw__29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28b2Draw__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 507; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Draw____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Draw____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2Draw__29__28void_20_28b2World____20const__29_28b2Draw__29_29_29_28b2Draw__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2Body__29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28b2Body__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 510; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Body____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Body____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2Body__29__28void_20_28b2World____20const__29_28b2Body__29_29_29_28b2Body__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2Joint____29_28_29_20const___invoke_b2Joint_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Vec2_20_28b2Joint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 604; + $0 = emscripten__internal__TypeID_b2Joint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20_28b2Joint____emscripten__internal__getContext_b2Vec2_20_28b2Joint____29_28_29_20const__28b2Vec2_20_28b2Joint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__value_object_b2Filter___20emscripten__value_object_b2Filter___field_b2Filter_2c_20short__28char_20const__2c_20short_20b2Filter____29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $2; + $0 = HEAP32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = 466; + HEAP32[$3 + 4 >> 2] = 467; + $1 = emscripten__internal__TypeID_b2Filter_2c_20void___get_28_29(); + $2 = HEAP32[$3 + 16 >> 2]; + $4 = emscripten__internal__TypeID_short_2c_20void___get_28_29(); + HEAP32[$3 + 24 >> 2] = HEAP32[$3 + 8 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$3 + 8 >> 2]; + $7 = short_20b2Filter_____20emscripten__internal__getContext_short_20b2Filter_____28short_20b2Filter____20const__29($3 + 12 | 0); + $8 = emscripten__internal__TypeID_short_2c_20void___get_28_29(); + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 4 >> 2]; + _embind_register_value_object_field($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$3 + 4 >> 2], short_20b2Filter_____20emscripten__internal__getContext_short_20b2Filter_____28short_20b2Filter____20const__29($3 + 12 | 0) | 0); + __stack_pointer = $3 + 32 | 0; + return $0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const_2c_20void_2c_20b2World_20const__2c_20b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const____invoke_28void_20_28b2World____20const__29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const_2c_20b2World_20const__2c_20b2RayCastCallback__2c_20b2Vec2__2c_20b2Vec2__29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + $2 = emscripten__internal__BindingType_b2World_20const__2c_20void___fromWireType_28b2World_20const__29(HEAP32[$5 + 24 >> 2]); + $0 = HEAP32[$5 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2RayCastCallback__2c_20void___fromWireType_28b2RayCastCallback__29(HEAP32[$5 + 20 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$5 + 16 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$5 + 12 >> 2])); + __stack_pointer = $5 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Filter_20const__20_28b2Fixture____29_28_29_20const___invoke_b2Fixture__28char_20const__2c_20b2Filter_20const__20_28b2Fixture____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 566; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Filter_20const__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Filter_20const__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Filter_20const__20_28b2Fixture____emscripten__internal__getContext_b2Filter_20const__20_28b2Fixture____29_28_29_20const__28b2Filter_20const__20_28b2Fixture____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28unsigned_20long_2c_20b2Vec2_20const__29_2c_20void_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const____invoke_28void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______20const__29_28unsigned_20long_2c_20b2Vec2_20const__29_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20void___fromWireType_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_unsigned_20long_2c_20void___fromWireType_28unsigned_20long_29(HEAP32[$4 + 4 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2RopeJoint____29_28float_29_20const___invoke_b2RopeJoint__28char_20const__2c_20b2Vec2_20_28b2RopeJoint____29_28float_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 670; + $0 = emscripten__internal__TypeID_b2RopeJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20_28b2RopeJoint____emscripten__internal__getContext_b2Vec2_20_28b2RopeJoint____29_28float_29_20const__28b2Vec2_20_28b2RopeJoint____20const__29_28float_29_20const_29_29_28float_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2Simplex__GetMetric_28_29_20const($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer - 32 | 0; + __stack_pointer = $1; + HEAP32[$1 + 24 >> 2] = $0; + label$1: { + label$2: { + label$3: { + label$4: { + label$5: { + label$6: { + $0 = HEAP32[$1 + 24 >> 2]; + switch (HEAP32[$0 + 108 >> 2]) { + case 3: + break label$3; + + case 2: + break label$4; + + case 1: + break label$5; + + case 0: + break label$6; + + default: + break label$2; + } + } + __assert_fail(9147, 6034, 257, 10392); + wasm2js_trap(); + } + HEAPF32[$1 + 28 >> 2] = 0; + break label$1; + } + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Distance_28b2Vec2_20const__2c_20b2Vec2_20const__29($0 + 16 | 0, $0 + 52 | 0), + HEAPF32[wasm2js_i32$0 + 28 >> 2] = wasm2js_f32$0; + break label$1; + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 16 | 0, $0 + 52 | 0, $0 + 16 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 8 | 0, $0 + 88 | 0, $0 + 16 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 16 | 0, $1 + 8 | 0), + HEAPF32[wasm2js_i32$0 + 28 >> 2] = wasm2js_f32$0; + break label$1; + } + __assert_fail(9147, 6034, 270, 10392); + wasm2js_trap(); + } + __stack_pointer = $1 + 32 | 0; + return HEAPF32[$1 + 28 >> 2]; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28b2Filter_20const__29___invoke_b2Fixture__28char_20const__2c_20void_20_28b2Fixture____29_28b2Filter_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 565; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20b2Filter_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20b2Filter_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Fixture____emscripten__internal__getContext_void_20_28b2Fixture____29_28b2Filter_20const__29__28void_20_28b2Fixture____20const__29_28b2Filter_20const__29_29_29_28b2Filter_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2RopeJoint____29_28float_29_20const___invoke_b2RopeJoint__28char_20const__2c_20float_20_28b2RopeJoint____29_28float_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 671; + $0 = emscripten__internal__TypeID_b2RopeJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2RopeJoint____emscripten__internal__getContext_float_20_28b2RopeJoint____29_28float_29_20const__28float_20_28b2RopeJoint____20const__29_28float_29_20const_29_29_28float_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Transform_20const__20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20b2Transform_20const__20_28b2Body____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 581; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Transform_20const__2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Transform_20const__2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Transform_20const__20_28b2Body____emscripten__internal__getContext_b2Transform_20const__20_28b2Body____29_28_29_20const__28b2Transform_20const__20_28b2Body____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__value_object_b2Color___20emscripten__value_object_b2Color___field_b2Color_2c_20float__28char_20const__2c_20float_20b2Color____29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $2; + $0 = HEAP32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = 442; + HEAP32[$3 + 4 >> 2] = 443; + $1 = emscripten__internal__TypeID_b2Color_2c_20void___get_28_29(); + $2 = HEAP32[$3 + 16 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$3 + 24 >> 2] = HEAP32[$3 + 8 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$3 + 8 >> 2]; + $7 = float_20b2Color_____20emscripten__internal__getContext_float_20b2Color_____28float_20b2Color____20const__29($3 + 12 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 4 >> 2]; + _embind_register_value_object_field($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$3 + 4 >> 2], float_20b2Color_____20emscripten__internal__getContext_float_20b2Color_____28float_20b2Color____20const__29($3 + 12 | 0) | 0); + __stack_pointer = $3 + 32 | 0; + return $0; +} + +function b2MotorJoint__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 144 | 0; + __stack_pointer = $1; + HEAP32[$1 + 140 >> 2] = $0; + $0 = HEAP32[$1 + 140 >> 2]; + HEAP32[$1 + 136 >> 2] = HEAP32[HEAP32[$0 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 132 >> 2] = HEAP32[HEAP32[$0 + 52 >> 2] + 8 >> 2]; + b2Dump_28char_20const__2c_20____29(13493, 0); + HEAP32[$1 + 96 >> 2] = HEAP32[$1 + 136 >> 2]; + b2Dump_28char_20const__2c_20____29(13849, $1 + 96 | 0); + HEAP32[$1 + 80 >> 2] = HEAP32[$1 + 132 >> 2]; + b2Dump_28char_20const__2c_20____29(13823, $1 + 80 | 0); + HEAP32[$1 + 64 >> 2] = HEAP8[$0 + 61 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14859, $1 - -64 | 0); + $2 = HEAPF32[$0 + 68 >> 2]; + HEAPF64[$1 + 56 >> 3] = HEAPF32[$0 + 72 >> 2]; + HEAPF64[$1 + 48 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14029, $1 + 48 | 0); + HEAPF64[$1 + 32 >> 3] = HEAPF32[$0 + 76 >> 2]; + b2Dump_28char_20const__2c_20____29(12674, $1 + 32 | 0); + HEAPF64[$1 + 16 >> 3] = HEAPF32[$0 + 92 >> 2]; + b2Dump_28char_20const__2c_20____29(13223, $1 + 16 | 0); + HEAPF64[$1 >> 3] = HEAPF32[$0 + 96 >> 2]; + b2Dump_28char_20const__2c_20____29(13044, $1); + HEAPF64[$1 + 112 >> 3] = HEAPF32[$0 + 100 >> 2]; + b2Dump_28char_20const__2c_20____29(12754, $1 + 112 | 0); + HEAP32[$1 + 128 >> 2] = HEAP32[$0 + 56 >> 2]; + b2Dump_28char_20const__2c_20____29(14538, $1 + 128 | 0); + __stack_pointer = $1 + 144 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______recommend_5babi_v160004_5d_28unsigned_20long_29_20const($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + $0 = HEAP32[$2 + 24 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__vector_int_2c_20std____2__allocator_int____max_size_28_29_20const($0), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + if (HEAPU32[$2 + 20 >> 2] > HEAPU32[$2 + 16 >> 2]) { + std____2__vector_int_2c_20std____2__allocator_int______throw_length_error_5babi_v160004_5d_28_29_20const($0); + wasm2js_trap(); + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__vector_int_2c_20std____2__allocator_int____capacity_5babi_v160004_5d_28_29_20const($0), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + label$2: { + if (HEAPU32[$2 + 12 >> 2] >= HEAP32[$2 + 16 >> 2] >>> 1 >>> 0) { + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 16 >> 2]; + break label$2; + } + HEAP32[$2 + 8 >> 2] = HEAP32[$2 + 12 >> 2] << 1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = HEAP32[unsigned_20long_20const__20std____2__max_5babi_v160004_5d_unsigned_20long__28unsigned_20long_20const__2c_20unsigned_20long_20const__29($2 + 8 | 0, $2 + 20 | 0) >> 2], + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + } + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function emscripten__value_object_b2Vec2___20emscripten__value_object_b2Vec2___field_b2Vec2_2c_20float__28char_20const__2c_20float_20b2Vec2____29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $2; + $0 = HEAP32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = 420; + HEAP32[$3 + 4 >> 2] = 421; + $1 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + $2 = HEAP32[$3 + 16 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$3 + 24 >> 2] = HEAP32[$3 + 8 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$3 + 8 >> 2]; + $7 = float_20b2Vec2_____20emscripten__internal__getContext_float_20b2Vec2_____28float_20b2Vec2____20const__29($3 + 12 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 4 >> 2]; + _embind_register_value_object_field($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$3 + 4 >> 2], float_20b2Vec2_____20emscripten__internal__getContext_float_20b2Vec2_____28float_20b2Vec2____20const__29($3 + 12 | 0) | 0); + __stack_pointer = $3 + 32 | 0; + return $0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20float_20_28b2PrismaticJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 644; + $0 = emscripten__internal__TypeID_b2PrismaticJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2PrismaticJoint____emscripten__internal__getContext_float_20_28b2PrismaticJoint____29_28_29_20const__28float_20_28b2PrismaticJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2Island__Report_28b2ContactVelocityConstraint_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 48 | 0; + __stack_pointer = $2; + HEAP32[$2 + 44 >> 2] = $0; + HEAP32[$2 + 40 >> 2] = $1; + label$1: { + $0 = HEAP32[$2 + 44 >> 2]; + if (!HEAP32[$0 + 4 >> 2]) { + break label$1; + } + HEAP32[$2 + 36 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 36 >> 2] >= HEAP32[$0 + 36 >> 2]) { + break label$1; + } + HEAP32[$2 + 32 >> 2] = HEAP32[HEAP32[$0 + 12 >> 2] + (HEAP32[$2 + 36 >> 2] << 2) >> 2]; + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 40 >> 2] + Math_imul(HEAP32[$2 + 36 >> 2], 156); + HEAP32[$2 + 24 >> 2] = HEAP32[HEAP32[$2 + 28 >> 2] + 148 >> 2]; + HEAP32[$2 + 4 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 4 >> 2] < HEAP32[HEAP32[$2 + 28 >> 2] + 148 >> 2]) { + HEAPF32[($2 + 8 | 0) + (HEAP32[$2 + 4 >> 2] << 2) >> 2] = HEAPF32[(HEAP32[$2 + 28 >> 2] + Math_imul(HEAP32[$2 + 4 >> 2], 36) | 0) + 16 >> 2]; + HEAPF32[($2 + 16 | 0) + (HEAP32[$2 + 4 >> 2] << 2) >> 2] = HEAPF32[(HEAP32[$2 + 28 >> 2] + Math_imul(HEAP32[$2 + 4 >> 2], 36) | 0) + 20 >> 2]; + HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 4 >> 2] + 1; + continue; + } + break; + } + $1 = HEAP32[$0 + 4 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 20 >> 2]]($1, HEAP32[$2 + 32 >> 2], $2 + 8 | 0); + HEAP32[$2 + 36 >> 2] = HEAP32[$2 + 36 >> 2] + 1; + continue; + } + } + __stack_pointer = $2 + 48 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2FixtureDef__2c_20b2Shape_20const__29___invoke_b2FixtureDef_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2FixtureDef__2c_20b2Shape_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 559; + $0 = emscripten__internal__TypeID_b2FixtureDef_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2FixtureDef__2c_20b2Shape_20const____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2FixtureDef__2c_20b2Shape_20const____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28__emscripten__internal__getContext_void_20_28__29_28b2FixtureDef__2c_20b2Shape_20const__29__28void_20_28__20const__29_28b2FixtureDef__2c_20b2Shape_20const__29_29_29_28b2FixtureDef__2c_20b2Shape_20const__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Shape__20_28b2Fixture____29_28_29___invoke_b2Fixture_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Shape__20_28b2Fixture____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 562; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2Fixture____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2Fixture____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Shape__20_28b2Fixture____emscripten__internal__getContext_b2Shape__20_28b2Fixture____29_28_29__28b2Shape__20_28b2Fixture____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2PrismaticJoint____29_28float_29___invoke_b2PrismaticJoint__28char_20const__2c_20void_20_28b2PrismaticJoint____29_28float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 648; + $0 = emscripten__internal__TypeID_b2PrismaticJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2PrismaticJoint____emscripten__internal__getContext_void_20_28b2PrismaticJoint____29_28float_29__28void_20_28b2PrismaticJoint____20const__29_28float_29_29_29_28float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20float_20_28b2RevoluteJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 657; + $0 = emscripten__internal__TypeID_b2RevoluteJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2RevoluteJoint____emscripten__internal__getContext_float_20_28b2RevoluteJoint____29_28_29_20const__28float_20_28b2RevoluteJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2DistanceJoint____29_28_29_20const___invoke_b2DistanceJoint__28char_20const__2c_20float_20_28b2DistanceJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 616; + $0 = emscripten__internal__TypeID_b2DistanceJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2DistanceJoint____emscripten__internal__getContext_float_20_28b2DistanceJoint____29_28_29_20const__28float_20_28b2DistanceJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2PrismaticJoint____29_28_29_20const___invoke_b2PrismaticJoint__28char_20const__2c_20bool_20_28b2PrismaticJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 645; + $0 = emscripten__internal__TypeID_b2PrismaticJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2PrismaticJoint____emscripten__internal__getContext_bool_20_28b2PrismaticJoint____29_28_29_20const__28bool_20_28b2PrismaticJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Shape__Type_20_28b2Fixture____29_28_29_20const___invoke_b2Fixture__28char_20const__2c_20b2Shape__Type_20_28b2Fixture____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 561; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Shape__Type_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Shape__Type_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Shape__Type_20_28b2Fixture____emscripten__internal__getContext_b2Shape__Type_20_28b2Fixture____29_28_29_20const__28b2Shape__Type_20_28b2Fixture____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__value_object_b2Rot___20emscripten__value_object_b2Rot___field_b2Rot_2c_20float__28char_20const__2c_20float_20b2Rot____29($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 20 >> 2] = $0; + HEAP32[$3 + 16 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $2; + $0 = HEAP32[$3 + 20 >> 2]; + HEAP32[$3 + 8 >> 2] = 432; + HEAP32[$3 + 4 >> 2] = 433; + $1 = emscripten__internal__TypeID_b2Rot_2c_20void___get_28_29(); + $2 = HEAP32[$3 + 16 >> 2]; + $4 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$3 + 24 >> 2] = HEAP32[$3 + 8 >> 2]; + $5 = char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29(); + $6 = HEAP32[$3 + 8 >> 2]; + $7 = float_20b2Rot_____20emscripten__internal__getContext_float_20b2Rot_____28float_20b2Rot____20const__29($3 + 12 | 0); + $8 = emscripten__internal__TypeID_float_2c_20void___get_28_29(); + HEAP32[$3 + 28 >> 2] = HEAP32[$3 + 4 >> 2]; + _embind_register_value_object_field($1 | 0, $2 | 0, $4 | 0, $5 | 0, $6 | 0, $7 | 0, $8 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$3 + 4 >> 2], float_20b2Rot_____20emscripten__internal__getContext_float_20b2Rot_____28float_20b2Rot____20const__29($3 + 12 | 0) | 0); + __stack_pointer = $3 + 32 | 0; + return $0; +} + +function std____2__pair_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____20std____2____dispatch_copy_or_move_5babi_v160004_5d_std____2___ClassicAlgPolicy_2c_20std____2____move_loop_std____2___ClassicAlgPolicy__2c_20std____2____move_trivial_2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 28 >> 2] = $1; + HEAP32[$4 + 24 >> 2] = $2; + HEAP32[$4 + 20 >> 2] = $3; + HEAP32[$4 + 16 >> 2] = HEAP32[$4 + 28 >> 2]; + HEAP32[$4 + 12 >> 2] = HEAP32[$4 + 24 >> 2]; + HEAP32[$4 + 8 >> 2] = HEAP32[$4 + 20 >> 2]; + std____2__pair_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____20std____2____unwrap_and_dispatch_5babi_v160004_5d_std____2____overload_std____2____move_loop_std____2___ClassicAlgPolicy__2c_20std____2____move_trivial__2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_200__28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($0, HEAP32[$4 + 16 >> 2], HEAP32[$4 + 12 >> 2], HEAP32[$4 + 8 >> 2]); + __stack_pointer = $4 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Body__20_28b2Fixture____29_28_29___invoke_b2Fixture_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Body__20_28b2Fixture____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 568; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Fixture____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Fixture____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Body__20_28b2Fixture____emscripten__internal__getContext_b2Body__20_28b2Fixture____29_28_29__28b2Body__20_28b2Fixture____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2RevoluteJoint____29_28float_29___invoke_b2RevoluteJoint__28char_20const__2c_20void_20_28b2RevoluteJoint____29_28float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 661; + $0 = emscripten__internal__TypeID_b2RevoluteJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2RevoluteJoint____emscripten__internal__getContext_void_20_28b2RevoluteJoint____29_28float_29__28void_20_28b2RevoluteJoint____20const__29_28float_29_29_29_28float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2PrismaticJoint____29_28bool_29___invoke_b2PrismaticJoint__28char_20const__2c_20void_20_28b2PrismaticJoint____29_28bool_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 646; + $0 = emscripten__internal__TypeID_b2PrismaticJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20bool___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20bool___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2PrismaticJoint____emscripten__internal__getContext_void_20_28b2PrismaticJoint____29_28bool_29__28void_20_28b2PrismaticJoint____20const__29_28bool_29_29_29_28bool_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2DistanceJoint____29_28float_29___invoke_b2DistanceJoint__28char_20const__2c_20void_20_28b2DistanceJoint____29_28float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 615; + $0 = emscripten__internal__TypeID_b2DistanceJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2DistanceJoint____emscripten__internal__getContext_void_20_28b2DistanceJoint____29_28float_29__28void_20_28b2DistanceJoint____20const__29_28float_29_29_29_28float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__FunctionInvoker_bool_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29_2c_20bool_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const____invoke_28bool_20_28___29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $0 = HEAP32[HEAP32[$4 + 12 >> 2] >> 2]; + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0](emscripten__internal__GenericBindingType_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____fromWireType_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29(HEAP32[$4 + 8 >> 2]), emscripten__internal__BindingType_unsigned_20long_2c_20void___fromWireType_28unsigned_20long_29(HEAP32[$4 + 4 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$4 >> 2])) & 1); + __stack_pointer = $4 + 16 | 0; + return $0 & 1; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28float_2c_20bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28float_2c_20bool_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 588; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20float_2c_20bool___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20float_2c_20bool___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28float_2c_20bool_29__28void_20_28b2Body____20const__29_28float_2c_20bool_29_29_29_28float_2c_20bool_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Fixture__20_28b2Body____29_28_29___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Fixture__20_28b2Body____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 597; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Fixture__20_28b2Body____emscripten__internal__getContext_b2Fixture__20_28b2Body____29_28_29__28b2Fixture__20_28b2Body____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2RevoluteJoint____29_28_29_20const___invoke_b2RevoluteJoint__28char_20const__2c_20bool_20_28b2RevoluteJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 658; + $0 = emscripten__internal__TypeID_b2RevoluteJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2RevoluteJoint____emscripten__internal__getContext_bool_20_28b2RevoluteJoint____29_28_29_20const__28bool_20_28b2RevoluteJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2Joint____29_28float_29_20const___invoke_b2Joint__28char_20const__2c_20b2Vec2_20_28b2Joint____29_28float_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 605; + $0 = emscripten__internal__TypeID_b2Joint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20_28b2Joint____emscripten__internal__getContext_b2Vec2_20_28b2Joint____29_28float_29_20const__28b2Vec2_20_28b2Joint____20const__29_28float_29_20const_29_29_28float_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2PolygonShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20void_2c_20b2PolygonShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___invoke_28void_20_28b2PolygonShape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2PolygonShape_20const__2c_20b2AABB__2c_20b2Transform__2c_20int_29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + $2 = emscripten__internal__BindingType_b2PolygonShape_20const__2c_20void___fromWireType_28b2PolygonShape_20const__29(HEAP32[$5 + 24 >> 2]); + $0 = HEAP32[$5 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2AABB__2c_20void___fromWireType_28b2AABB__29(HEAP32[$5 + 20 >> 2]), emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$5 + 16 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$5 + 12 >> 2])); + __stack_pointer = $5 + 32 | 0; +} + +function SetLinearFrequencyAndDampingRatio_28b2Joint__2c_20float_2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = Math_fround($1); + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAPF32[$3 + 24 >> 2] = $1; + HEAPF32[$3 + 20 >> 2] = $2; + b2LinearStiffness_28float__2c_20float__2c_20float_2c_20float_2c_20b2Body_20const__2c_20b2Body_20const__29($3 + 16 | 0, $3 + 12 | 0, HEAPF32[$3 + 24 >> 2], HEAPF32[$3 + 20 >> 2], b2Joint__GetBodyA_28_29(HEAP32[$3 + 28 >> 2]), b2Joint__GetBodyB_28_29(HEAP32[$3 + 28 >> 2])); + label$1: { + label$2: { + switch (b2Joint__GetType_28_29_20const(HEAP32[$3 + 28 >> 2]) - 3 | 0) { + case 0: + b2DistanceJoint__SetStiffness_28float_29(HEAP32[$3 + 28 >> 2], HEAPF32[$3 + 16 >> 2]); + b2DistanceJoint__SetDamping_28float_29(HEAP32[$3 + 28 >> 2], HEAPF32[$3 + 12 >> 2]); + break label$1; + + case 5: + b2WeldJoint__SetStiffness_28float_29(HEAP32[$3 + 28 >> 2], HEAPF32[$3 + 16 >> 2]); + b2WeldJoint__SetDamping_28float_29(HEAP32[$3 + 28 >> 2], HEAPF32[$3 + 12 >> 2]); + break label$1; + + case 4: + break label$2; + + default: + break label$1; + } + } + b2WheelJoint__SetStiffness_28float_29(HEAP32[$3 + 28 >> 2], HEAPF32[$3 + 16 >> 2]); + b2WheelJoint__SetDamping_28float_29(HEAP32[$3 + 28 >> 2], HEAPF32[$3 + 12 >> 2]); + } + __stack_pointer = $3 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28b2Vec2_20const__29___invoke_b2World__28char_20const__2c_20void_20_28b2World____29_28b2Vec2_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 518; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Vec2_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2Vec2_20const__29__28void_20_28b2World____20const__29_28b2Vec2_20const__29_29_29_28b2Vec2_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29___invoke_b2AABB_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 502; + $0 = emscripten__internal__TypeID_b2AABB_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2AABB__2c_20b2AABB__2c_20b2AABB____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2AABB__2c_20b2AABB__2c_20b2AABB____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28__emscripten__internal__getContext_void_20_28__29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29__28void_20_28__20const__29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29_29_29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function fflush($0) { + var $1 = 0, $2 = 0, $3 = 0; + if (!$0) { + if (HEAP32[7464]) { + $1 = fflush(HEAP32[7464]); + } + if (HEAP32[7502]) { + $1 = fflush(HEAP32[7502]) | $1; + } + $0 = HEAP32[__ofl_lock() >> 2]; + if ($0) { + while (1) { + $2 = 0; + if (HEAP32[$0 + 76 >> 2] >= 0) { + $2 = __lockfile($0); + } + if (HEAP32[$0 + 20 >> 2] != HEAP32[$0 + 28 >> 2]) { + $1 = fflush($0) | $1; + } + if ($2) { + __unlockfile($0); + } + $0 = HEAP32[$0 + 56 >> 2]; + if ($0) { + continue; + } + break; + } + } + __ofl_unlock(); + return $1; + } + if (HEAP32[$0 + 76 >> 2] >= 0) { + $2 = __lockfile($0); + } + label$10: { + label$11: { + label$12: { + if (HEAP32[$0 + 20 >> 2] == HEAP32[$0 + 28 >> 2]) { + break label$12; + } + FUNCTION_TABLE[HEAP32[$0 + 36 >> 2]]($0, 0, 0) | 0; + if (HEAP32[$0 + 20 >> 2]) { + break label$12; + } + $1 = -1; + if ($2) { + break label$11; + } + break label$10; + } + $1 = HEAP32[$0 + 4 >> 2]; + $3 = HEAP32[$0 + 8 >> 2]; + if (($1 | 0) != ($3 | 0)) { + $1 = $1 - $3 | 0; + FUNCTION_TABLE[HEAP32[$0 + 40 >> 2]]($0, $1, $1 >> 31, 1) | 0; + } + $1 = 0; + HEAP32[$0 + 28 >> 2] = 0; + HEAP32[$0 + 16 >> 2] = 0; + HEAP32[$0 + 20 >> 2] = 0; + HEAP32[$0 + 4 >> 2] = 0; + HEAP32[$0 + 8 >> 2] = 0; + if (!$2) { + break label$10; + } + } + __unlockfile($0); + } + return $1; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20const__20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20b2Vec2_20const__20_28b2Body____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 582; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20const__20_28b2Body____emscripten__internal__getContext_b2Vec2_20const__20_28b2Body____29_28_29_20const__28b2Vec2_20const__20_28b2Body____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2Joint____29_28float_29_20const___invoke_b2Joint__28char_20const__2c_20float_20_28b2Joint____29_28float_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 606; + $0 = emscripten__internal__TypeID_b2Joint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2Joint____emscripten__internal__getContext_float_20_28b2Joint____29_28float_29_20const__28float_20_28b2Joint____20const__29_28float_29_20const_29_29_28float_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2RevoluteJoint____29_28bool_29___invoke_b2RevoluteJoint__28char_20const__2c_20void_20_28b2RevoluteJoint____29_28bool_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 659; + $0 = emscripten__internal__TypeID_b2RevoluteJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20bool___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20bool___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2RevoluteJoint____emscripten__internal__getContext_void_20_28b2RevoluteJoint____29_28bool_29__28void_20_28b2RevoluteJoint____20const__29_28bool_29_29_29_28bool_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2CircleShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20void_2c_20b2CircleShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___invoke_28void_20_28b2CircleShape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2CircleShape_20const__2c_20b2AABB__2c_20b2Transform__2c_20int_29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + $2 = emscripten__internal__BindingType_b2CircleShape_20const__2c_20void___fromWireType_28b2CircleShape_20const__29(HEAP32[$5 + 24 >> 2]); + $0 = HEAP32[$5 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2AABB__2c_20void___fromWireType_28b2AABB__29(HEAP32[$5 + 20 >> 2]), emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$5 + 16 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$5 + 12 >> 2])); + __stack_pointer = $5 + 32 | 0; +} + +function b2EdgeShape__ComputeAABB_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 80 | 0; + __stack_pointer = $4; + HEAP32[$4 + 76 >> 2] = $0; + HEAP32[$4 + 72 >> 2] = $1; + HEAP32[$4 + 68 >> 2] = $2; + HEAP32[$4 + 64 >> 2] = $3; + $0 = HEAP32[$4 + 76 >> 2]; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 56 | 0, HEAP32[$4 + 68 >> 2], $0 + 12 | 0); + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($4 + 48 | 0, HEAP32[$4 + 68 >> 2], $0 + 20 | 0); + b2Min_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 40 | 0, $4 + 56 | 0, $4 + 48 | 0); + b2Max_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 32 | 0, $4 + 56 | 0, $4 + 48 | 0); + b2Vec2__b2Vec2_28float_2c_20float_29($4 + 24 | 0, HEAPF32[$0 + 8 >> 2], HEAPF32[$0 + 8 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 16 | 0, $4 + 40 | 0, $4 + 24 | 0); + $0 = HEAP32[$4 + 20 >> 2]; + $1 = HEAP32[$4 + 16 >> 2]; + $2 = $1; + $1 = HEAP32[$4 + 72 >> 2]; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($4 + 8 | 0, $4 + 32 | 0, $4 + 24 | 0); + $1 = HEAP32[$4 + 12 >> 2]; + $0 = HEAP32[$4 + 8 >> 2]; + $2 = $0; + $0 = HEAP32[$4 + 72 >> 2]; + HEAP32[$0 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $1; + __stack_pointer = $4 + 80 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2PolygonShape____29_28_29_20const___invoke_b2PolygonShape__28char_20const__2c_20bool_20_28b2PolygonShape____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 555; + $0 = emscripten__internal__TypeID_b2PolygonShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2PolygonShape____emscripten__internal__getContext_bool_20_28b2PolygonShape____29_28_29_20const__28bool_20_28b2PolygonShape____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Shape__Type_20_28b2Shape____29_28_29_20const___invoke_b2Shape__28char_20const__2c_20b2Shape__Type_20_28b2Shape____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 520; + $0 = emscripten__internal__TypeID_b2Shape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Shape__Type_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Shape__Type_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Shape__Type_20_28b2Shape____emscripten__internal__getContext_b2Shape__Type_20_28b2Shape____29_28_29_20const__28b2Shape__Type_20_28b2Shape____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2Vec2_20const__29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28b2Vec2_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 584; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2Vec2_20const__29__28void_20_28b2Body____20const__29_28b2Vec2_20const__29_29_29_28b2Vec2_20const__29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_unsigned_20int_20_28b2Draw____29_28_29_20const___invoke_b2Draw__28char_20const__2c_20unsigned_20int_20_28b2Draw____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 487; + $0 = emscripten__internal__TypeID_b2Draw_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_unsigned_20int_2c_20emscripten__internal__AllowedRawPointer_b2Draw_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_unsigned_20int_2c_20emscripten__internal__AllowedRawPointer_b2Draw_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], unsigned_20int_20_28b2Draw____emscripten__internal__getContext_unsigned_20int_20_28b2Draw____29_28_29_20const__28unsigned_20int_20_28b2Draw____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Body__20_28b2Joint____29_28_29___invoke_b2Joint_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Body__20_28b2Joint____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 603; + $0 = emscripten__internal__TypeID_b2Joint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Joint____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Joint____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Body__20_28b2Joint____emscripten__internal__getContext_b2Body__20_28b2Joint____29_28_29__28b2Body__20_28b2Joint____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2World__20_28b2Body____29_28_29___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2World__20_28b2Body____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 598; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2World__2c_20emscripten__internal__AllowedRawPointer_b2Body____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2World__2c_20emscripten__internal__AllowedRawPointer_b2Body____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2World__20_28b2Body____emscripten__internal__getContext_b2World__20_28b2Body____29_28_29__28b2World__20_28b2Body____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodCaller_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const____call_28emscripten___EM_VAL__2c_20char_20const__2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const__29($0, $1, $2, $3, $4, $5) { + var $6 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $6 = __stack_pointer + -64 | 0; + __stack_pointer = $6; + HEAP32[$6 + 60 >> 2] = $0; + HEAP32[$6 + 56 >> 2] = $1; + HEAP32[$6 + 52 >> 2] = $2; + HEAP32[$6 + 48 >> 2] = $3; + HEAP32[$6 + 44 >> 2] = $4; + HEAP32[$6 + 40 >> 2] = $5; + wasm2js_i32$0 = $6, wasm2js_i32$1 = emscripten__internal__Signature_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const____get_method_caller_28_29(), + HEAP32[wasm2js_i32$0 + 36 >> 2] = wasm2js_i32$1; + emscripten__internal__WireTypePack_b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const____WireTypePack_28b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const__29($6, HEAP32[$6 + 52 >> 2], HEAP32[$6 + 48 >> 2], HEAP32[$6 + 44 >> 2], HEAP32[$6 + 40 >> 2]); + _emval_call_void_method(HEAP32[$6 + 36 >> 2], HEAP32[$6 + 60 >> 2], HEAP32[$6 + 56 >> 2], emscripten__internal__WireTypePack_b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const____operator_20void_20const__28_29_20const($6) | 0); + __stack_pointer = $6 - -64 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_int_20_28b2PolygonShape____29_28_29_20const___invoke_b2PolygonShape__28char_20const__2c_20int_20_28b2PolygonShape____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 549; + $0 = emscripten__internal__TypeID_b2PolygonShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], int_20_28b2PolygonShape____emscripten__internal__getContext_int_20_28b2PolygonShape____29_28_29_20const__28int_20_28b2PolygonShape____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______construct_at_end_28unsigned_20long_2c_20int_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + std____2__vector_int_2c_20std____2__allocator_int_____ConstructTransaction___ConstructTransaction_5babi_v160004_5d_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_29($3 + 8 | 0, $0, HEAP32[$3 + 24 >> 2]); + HEAP32[$3 + 4 >> 2] = HEAP32[$3 + 16 >> 2]; + HEAP32[$3 >> 2] = HEAP32[$3 + 12 >> 2]; + while (1) { + if (HEAP32[$3 >> 2] != HEAP32[$3 + 4 >> 2]) { + void_20std____2__allocator_traits_std____2__allocator_int____construct_5babi_v160004_5d_int_2c_20int_20const__2c_20void__28std____2__allocator_int___2c_20int__2c_20int_20const__29(std____2__vector_int_2c_20std____2__allocator_int______alloc_5babi_v160004_5d_28_29($0), int__20std____2____to_address_5babi_v160004_5d_int__28int__29(HEAP32[$3 >> 2]), HEAP32[$3 + 20 >> 2]); + $1 = HEAP32[$3 >> 2] + 4 | 0; + HEAP32[$3 >> 2] = $1; + HEAP32[$3 + 12 >> 2] = $1; + continue; + } + break; + } + std____2__vector_int_2c_20std____2__allocator_int_____ConstructTransaction____ConstructTransaction_5babi_v160004_5d_28_29($3 + 8 | 0); + __stack_pointer = $3 + 32 | 0; +} + +function b2FrictionJoint__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 128 | 0; + __stack_pointer = $1; + HEAP32[$1 + 124 >> 2] = $0; + $0 = HEAP32[$1 + 124 >> 2]; + HEAP32[$1 + 120 >> 2] = HEAP32[HEAP32[$0 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 116 >> 2] = HEAP32[HEAP32[$0 + 52 >> 2] + 8 >> 2]; + b2Dump_28char_20const__2c_20____29(13538, 0); + HEAP32[$1 + 80 >> 2] = HEAP32[$1 + 120 >> 2]; + b2Dump_28char_20const__2c_20____29(13849, $1 + 80 | 0); + HEAP32[$1 + 64 >> 2] = HEAP32[$1 + 116 >> 2]; + b2Dump_28char_20const__2c_20____29(13823, $1 - -64 | 0); + HEAP32[$1 + 48 >> 2] = HEAP8[$0 + 61 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14859, $1 + 48 | 0); + $2 = HEAPF32[$0 + 68 >> 2]; + HEAPF64[$1 + 40 >> 3] = HEAPF32[$0 + 72 >> 2]; + HEAPF64[$1 + 32 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14265, $1 + 32 | 0); + $2 = HEAPF32[$0 + 76 >> 2]; + HEAPF64[$1 + 24 >> 3] = HEAPF32[$0 + 80 >> 2]; + HEAPF64[$1 + 16 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14158, $1 + 16 | 0); + HEAPF64[$1 >> 3] = HEAPF32[$0 + 96 >> 2]; + b2Dump_28char_20const__2c_20____29(13223, $1); + HEAPF64[$1 + 96 >> 3] = HEAPF32[$0 + 100 >> 2]; + b2Dump_28char_20const__2c_20____29(13044, $1 + 96 | 0); + HEAP32[$1 + 112 >> 2] = HEAP32[$0 + 56 >> 2]; + b2Dump_28char_20const__2c_20____29(14538, $1 + 112 | 0); + __stack_pointer = $1 + 128 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Draw____29_28unsigned_20int_29___invoke_b2Draw__28char_20const__2c_20void_20_28b2Draw____29_28unsigned_20int_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 486; + $0 = emscripten__internal__TypeID_b2Draw_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20unsigned_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20unsigned_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Draw____emscripten__internal__getContext_void_20_28b2Draw____29_28unsigned_20int_29__28void_20_28b2Draw____20const__29_28unsigned_20int_29_29_29_28unsigned_20int_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2WheelJoint____29_28_29_20const___invoke_b2WheelJoint__28char_20const__2c_20float_20_28b2WheelJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 690; + $0 = emscripten__internal__TypeID_b2WheelJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2WheelJoint____emscripten__internal__getContext_float_20_28b2WheelJoint____29_28_29_20const__28float_20_28b2WheelJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2MouseJoint____29_28_29_20const___invoke_b2MouseJoint__28char_20const__2c_20float_20_28b2MouseJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 636; + $0 = emscripten__internal__TypeID_b2MouseJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2MouseJoint____emscripten__internal__getContext_float_20_28b2MouseJoint____29_28_29_20const__28float_20_28b2MouseJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2MotorJoint____29_28_29_20const___invoke_b2MotorJoint__28char_20const__2c_20float_20_28b2MotorJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 626; + $0 = emscripten__internal__TypeID_b2MotorJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2MotorJoint____emscripten__internal__getContext_float_20_28b2MotorJoint____29_28_29_20const__28float_20_28b2MotorJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2EdgeShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20void_2c_20b2EdgeShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___invoke_28void_20_28b2EdgeShape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2EdgeShape_20const__2c_20b2AABB__2c_20b2Transform__2c_20int_29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + $2 = emscripten__internal__BindingType_b2EdgeShape_20const__2c_20void___fromWireType_28b2EdgeShape_20const__29(HEAP32[$5 + 24 >> 2]); + $0 = HEAP32[$5 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2AABB__2c_20void___fromWireType_28b2AABB__29(HEAP32[$5 + 20 >> 2]), emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$5 + 16 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$5 + 12 >> 2])); + __stack_pointer = $5 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2Body__2c_20b2MassData_20const__29___invoke_b2Body_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2Body__2c_20b2MassData_20const__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 590; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2Body__2c_20b2MassData_20const____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2Body__2c_20b2MassData_20const____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28__emscripten__internal__getContext_void_20_28__29_28b2Body__2c_20b2MassData_20const__29__28void_20_28__20const__29_28b2Body__2c_20b2MassData_20const__29_29_29_28b2Body__2c_20b2MassData_20const__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2JointType_20_28b2Joint____29_28_29_20const___invoke_b2Joint__28char_20const__2c_20b2JointType_20_28b2Joint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 602; + $0 = emscripten__internal__TypeID_b2Joint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2JointType_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2JointType_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2JointType_20_28b2Joint____emscripten__internal__getContext_b2JointType_20_28b2Joint____29_28_29_20const__28b2JointType_20_28b2Joint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2WheelJoint____29_28float_29___invoke_b2WheelJoint__28char_20const__2c_20void_20_28b2WheelJoint____29_28float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 693; + $0 = emscripten__internal__TypeID_b2WheelJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2WheelJoint____emscripten__internal__getContext_void_20_28b2WheelJoint____29_28float_29__28void_20_28b2WheelJoint____20const__29_28float_29_29_29_28float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2MouseJoint____29_28float_29___invoke_b2MouseJoint__28char_20const__2c_20void_20_28b2MouseJoint____29_28float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 635; + $0 = emscripten__internal__TypeID_b2MouseJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2MouseJoint____emscripten__internal__getContext_void_20_28b2MouseJoint____29_28float_29__28void_20_28b2MouseJoint____20const__29_28float_29_29_29_28float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2MotorJoint____29_28float_29___invoke_b2MotorJoint__28char_20const__2c_20void_20_28b2MotorJoint____29_28float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 625; + $0 = emscripten__internal__TypeID_b2MotorJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2MotorJoint____emscripten__internal__getContext_void_20_28b2MotorJoint____29_28float_29__28void_20_28b2MotorJoint____20const__29_28float_29_29_29_28float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_int_20_28b2CircleShape____29_28_29_20const___invoke_b2CircleShape__28char_20const__2c_20int_20_28b2CircleShape____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 532; + $0 = emscripten__internal__TypeID_b2CircleShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], int_20_28b2CircleShape____emscripten__internal__getContext_int_20_28b2CircleShape____29_28_29_20const__28int_20_28b2CircleShape____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2World__b2World_28b2Vec2_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + $2 = HEAP32[$3 + 12 >> 2]; + b2BlockAllocator__b2BlockAllocator_28_29($2); + b2StackAllocator__b2StackAllocator_28_29($2 + 68 | 0); + b2ContactManager__b2ContactManager_28_29($2 + 102868 | 0); + b2Vec2__b2Vec2_28_29($2 + 102964 | 0); + HEAP32[$2 + 102976 >> 2] = 0; + HEAP32[$2 + 102980 >> 2] = 0; + HEAP32[$2 + 102948 >> 2] = 0; + HEAP32[$2 + 102952 >> 2] = 0; + HEAP32[$2 + 102956 >> 2] = 0; + HEAP32[$2 + 102960 >> 2] = 0; + HEAP8[$2 + 102991 | 0] = 1; + HEAP8[$2 + 102992 | 0] = 1; + HEAP8[$2 + 102993 | 0] = 0; + HEAP8[$2 + 102994 | 0] = 1; + HEAP8[$2 + 102972 | 0] = 1; + $1 = HEAP32[$3 + 8 >> 2]; + $0 = HEAP32[$1 >> 2]; + $4 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = $2 + 102964 | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $4; + HEAP8[$2 + 102988 | 0] = 0; + HEAP8[$2 + 102989 | 0] = 0; + HEAP8[$2 + 102990 | 0] = 1; + HEAPF32[$2 + 102984 >> 2] = 0; + HEAP32[$2 + 102944 >> 2] = $2; + $0 = $2 + 102996 | 0; + HEAP32[$0 >> 2] = 0; + HEAP32[$0 + 4 >> 2] = 0; + HEAP32[$0 + 24 >> 2] = 0; + HEAP32[$0 + 28 >> 2] = 0; + HEAP32[$0 + 16 >> 2] = 0; + HEAP32[$0 + 20 >> 2] = 0; + HEAP32[$0 + 8 >> 2] = 0; + HEAP32[$0 + 12 >> 2] = 0; + __stack_pointer = $3 + 16 | 0; + return $2; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2WeldJoint____29_28_29_20const___invoke_b2WeldJoint__28char_20const__2c_20float_20_28b2WeldJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 681; + $0 = emscripten__internal__TypeID_b2WeldJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2WeldJoint____emscripten__internal__getContext_float_20_28b2WeldJoint____29_28_29_20const__28float_20_28b2WeldJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2RopeJoint____29_28_29_20const___invoke_b2RopeJoint__28char_20const__2c_20float_20_28b2RopeJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 673; + $0 = emscripten__internal__TypeID_b2RopeJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2RopeJoint____emscripten__internal__getContext_float_20_28b2RopeJoint____29_28_29_20const__28float_20_28b2RopeJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2WheelJoint____29_28_29_20const___invoke_b2WheelJoint__28char_20const__2c_20bool_20_28b2WheelJoint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 691; + $0 = emscripten__internal__TypeID_b2WheelJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2WheelJoint____emscripten__internal__getContext_bool_20_28b2WheelJoint____29_28_29_20const__28bool_20_28b2WheelJoint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28_29___invoke_b2World_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28b2World____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 508; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28_29__28void_20_28b2World____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2PolygonShape__TestPoint_28b2Transform_20const__2c_20b2Vec2_20const__29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 48 | 0; + __stack_pointer = $3; + HEAP32[$3 + 40 >> 2] = $0; + HEAP32[$3 + 36 >> 2] = $1; + HEAP32[$3 + 32 >> 2] = $2; + $0 = HEAP32[$3 + 40 >> 2]; + $1 = HEAP32[$3 + 36 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 16 | 0, HEAP32[$3 + 32 >> 2], HEAP32[$3 + 36 >> 2]); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 24 | 0, $1 + 8 | 0, $3 + 16 | 0); + HEAP32[$3 + 12 >> 2] = 0; + label$1: { + while (1) { + if (HEAP32[$3 + 12 >> 2] < HEAP32[$0 + 148 >> 2]) { + $1 = HEAP32[$3 + 12 >> 2] << 3; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3, $3 + 24 | 0, ($0 + 20 | 0) + (HEAP32[$3 + 12 >> 2] << 3) | 0); + wasm2js_i32$0 = $3, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + ($0 + 84 | 0) | 0, $3), + HEAPF32[wasm2js_i32$0 + 8 >> 2] = wasm2js_f32$0; + if (HEAPF32[$3 + 8 >> 2] > Math_fround(0)) { + HEAP8[$3 + 47 | 0] = 0; + break label$1; + } else { + HEAP32[$3 + 12 >> 2] = HEAP32[$3 + 12 >> 2] + 1; + continue; + } + } + break; + } + HEAP8[$3 + 47 | 0] = 1; + } + __stack_pointer = $3 + 48 | 0; + return HEAP8[$3 + 47 | 0] & 1; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2WheelJoint____29_28bool_29___invoke_b2WheelJoint__28char_20const__2c_20void_20_28b2WheelJoint____29_28bool_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 692; + $0 = emscripten__internal__TypeID_b2WheelJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20bool___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20bool___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2WheelJoint____emscripten__internal__getContext_void_20_28b2WheelJoint____29_28bool_29__28void_20_28b2WheelJoint____20const__29_28bool_29_29_29_28bool_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2WeldJoint____29_28float_29___invoke_b2WeldJoint__28char_20const__2c_20void_20_28b2WeldJoint____29_28float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 682; + $0 = emscripten__internal__TypeID_b2WeldJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2WeldJoint____emscripten__internal__getContext_void_20_28b2WeldJoint____29_28float_29__28void_20_28b2WeldJoint____20const__29_28float_29_29_29_28float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2RopeJoint____29_28float_29___invoke_b2RopeJoint__28char_20const__2c_20void_20_28b2RopeJoint____29_28float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 672; + $0 = emscripten__internal__TypeID_b2RopeJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2RopeJoint____emscripten__internal__getContext_void_20_28b2RopeJoint____29_28float_29__28void_20_28b2RopeJoint____20const__29_28float_29_29_29_28float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2____tree_node_base_void____20std____2____tree_next_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + label$1: { + if (HEAP32[HEAP32[$1 + 8 >> 2] + 4 >> 2]) { + wasm2js_i32$0 = $1, wasm2js_i32$1 = std____2____tree_node_base_void____20std____2____tree_min_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[HEAP32[$1 + 8 >> 2] + 4 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + break label$1; + } + while (1) { + if ((bool_20std____2____tree_is_left_child_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$1 + 8 >> 2]) ^ -1) & 1) { + wasm2js_i32$0 = $1, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + continue; + } + break; + } + wasm2js_i32$0 = $1, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + } + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function void_20emscripten__internal__RegisterClassMethod_b2BodyType_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20b2BodyType_20_28b2Body____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 594; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2BodyType_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2BodyType_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2BodyType_20_28b2Body____emscripten__internal__getContext_b2BodyType_20_28b2Body____29_28_29_20const__28b2BodyType_20_28b2Body____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2__pair_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____20std____2____move_5babi_v160004_5d_std____2___ClassicAlgPolicy_2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 28 >> 2] = $1; + HEAP32[$4 + 24 >> 2] = $2; + HEAP32[$4 + 20 >> 2] = $3; + HEAP32[$4 + 16 >> 2] = HEAP32[$4 + 28 >> 2]; + HEAP32[$4 + 12 >> 2] = HEAP32[$4 + 24 >> 2]; + HEAP32[$4 + 8 >> 2] = HEAP32[$4 + 20 >> 2]; + std____2__pair_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____20std____2____dispatch_copy_or_move_5babi_v160004_5d_std____2___ClassicAlgPolicy_2c_20std____2____move_loop_std____2___ClassicAlgPolicy__2c_20std____2____move_trivial_2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($0, HEAP32[$4 + 16 >> 2], HEAP32[$4 + 12 >> 2], HEAP32[$4 + 8 >> 2]); + __stack_pointer = $4 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Shape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20void_2c_20b2Shape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___invoke_28void_20_28b2Shape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2Shape_20const__2c_20b2AABB__2c_20b2Transform__2c_20int_29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + $2 = emscripten__internal__BindingType_b2Shape_20const__2c_20void___fromWireType_28b2Shape_20const__29(HEAP32[$5 + 24 >> 2]); + $0 = HEAP32[$5 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2AABB__2c_20void___fromWireType_28b2AABB__29(HEAP32[$5 + 20 >> 2]), emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$5 + 16 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$5 + 12 >> 2])); + __stack_pointer = $5 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_int_20_28b2EdgeShape____29_28_29_20const___invoke_b2EdgeShape__28char_20const__2c_20int_20_28b2EdgeShape____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 540; + $0 = emscripten__internal__TypeID_b2EdgeShape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], int_20_28b2EdgeShape____emscripten__internal__getContext_int_20_28b2EdgeShape____29_28_29_20const__28int_20_28b2EdgeShape____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28b2BodyType_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28b2BodyType_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 593; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2BodyType___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2BodyType___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2BodyType_29__28void_20_28b2Body____20const__29_28b2BodyType_29_29_29_28b2BodyType_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2Fixture____29_28_29_20const___invoke_b2Fixture__28char_20const__2c_20float_20_28b2Fixture____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 573; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2Fixture____emscripten__internal__getContext_float_20_28b2Fixture____29_28_29_20const__28float_20_28b2Fixture____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodCaller_bool_2c_20unsigned_20int____call_28emscripten___EM_VAL__2c_20char_20const__2c_20unsigned_20int__29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_f64$0 = 0; + $3 = __stack_pointer - 48 | 0; + __stack_pointer = $3; + HEAP32[$3 + 44 >> 2] = $0; + HEAP32[$3 + 40 >> 2] = $1; + HEAP32[$3 + 36 >> 2] = $2; + wasm2js_i32$0 = $3, wasm2js_i32$1 = emscripten__internal__Signature_bool_2c_20unsigned_20int____get_method_caller_28_29(), + HEAP32[wasm2js_i32$0 + 32 >> 2] = wasm2js_i32$1; + emscripten__internal__WireTypePack_unsigned_20int____WireTypePack_28unsigned_20int__29($3 + 24 | 0, HEAP32[$3 + 36 >> 2]); + wasm2js_i32$0 = $3, wasm2js_f64$0 = +_emval_call_method(HEAP32[$3 + 32 >> 2], HEAP32[$3 + 44 >> 2], HEAP32[$3 + 40 >> 2], $3 + 20 | 0, emscripten__internal__WireTypePack_unsigned_20int____operator_20void_20const__28_29_20const($3 + 24 | 0) | 0), + HEAPF64[wasm2js_i32$0 + 8 >> 3] = wasm2js_f64$0; + emscripten__internal__DestructorsRunner__DestructorsRunner_28emscripten__internal___EM_DESTRUCTORS__29($3 + 4 | 0, HEAP32[$3 + 20 >> 2]); + $0 = bool_20emscripten__internal__fromGenericWireType_bool__28double_29(HEAPF64[$3 + 8 >> 3]); + emscripten__internal__DestructorsRunner___DestructorsRunner_28_29($3 + 4 | 0); + __stack_pointer = $3 + 48 | 0; + return $0 & 1; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2PrismaticJoint____29_28_29___invoke_b2PrismaticJoint__28char_20const__2c_20void_20_28b2PrismaticJoint____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 650; + $0 = emscripten__internal__TypeID_b2PrismaticJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2PrismaticJoint____emscripten__internal__getContext_void_20_28b2PrismaticJoint____29_28_29__28void_20_28b2PrismaticJoint____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28float_29___invoke_b2Fixture__28char_20const__2c_20void_20_28b2Fixture____29_28float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 572; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Fixture____emscripten__internal__getContext_void_20_28b2Fixture____29_28float_29__28void_20_28b2Fixture____20const__29_28float_29_29_29_28float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2Fixture__CreateProxies_28b2BroadPhase__2c_20b2Transform_20const__29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + if (HEAP32[$0 + 28 >> 2]) { + __assert_fail(12304, 5695, 128, 3522); + wasm2js_trap(); + } + $1 = HEAP32[$0 + 12 >> 2]; + wasm2js_i32$0 = $0, wasm2js_i32$1 = FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 12 >> 2]]($1) | 0, + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + HEAP32[$3 + 16 >> 2] = 0; + while (1) { + if (HEAP32[$3 + 16 >> 2] < HEAP32[$0 + 28 >> 2]) { + HEAP32[$3 + 12 >> 2] = HEAP32[$0 + 24 >> 2] + Math_imul(HEAP32[$3 + 16 >> 2], 28); + $1 = HEAP32[$0 + 12 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 24 >> 2]]($1, HEAP32[$3 + 12 >> 2], HEAP32[$3 + 20 >> 2], HEAP32[$3 + 16 >> 2]); + $1 = b2BroadPhase__CreateProxy_28b2AABB_20const__2c_20void__29(HEAP32[$3 + 24 >> 2], HEAP32[$3 + 12 >> 2], HEAP32[$3 + 12 >> 2]); + HEAP32[HEAP32[$3 + 12 >> 2] + 24 >> 2] = $1; + HEAP32[HEAP32[$3 + 12 >> 2] + 16 >> 2] = $0; + HEAP32[HEAP32[$3 + 12 >> 2] + 20 >> 2] = HEAP32[$3 + 16 >> 2]; + HEAP32[$3 + 16 >> 2] = HEAP32[$3 + 16 >> 2] + 1; + continue; + } + break; + } + __stack_pointer = $3 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Fixture____29_28_29_20const___invoke_b2Fixture__28char_20const__2c_20bool_20_28b2Fixture____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 564; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2Fixture____emscripten__internal__getContext_bool_20_28b2Fixture____29_28_29_20const__28bool_20_28b2Fixture____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2RevoluteJoint____29_28_29___invoke_b2RevoluteJoint__28char_20const__2c_20void_20_28b2RevoluteJoint____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 663; + $0 = emscripten__internal__TypeID_b2RevoluteJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2RevoluteJoint____emscripten__internal__getContext_void_20_28b2RevoluteJoint____29_28_29__28void_20_28b2RevoluteJoint____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2DistanceJoint____29_28_29___invoke_b2DistanceJoint__28char_20const__2c_20void_20_28b2DistanceJoint____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 617; + $0 = emscripten__internal__TypeID_b2DistanceJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2DistanceJoint____emscripten__internal__getContext_void_20_28b2DistanceJoint____29_28_29__28void_20_28b2DistanceJoint____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Draw____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29_2c_20void_2c_20b2Draw__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____invoke_28void_20_28b2Draw____20const__29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29_2c_20b2Draw__2c_20b2Vec2__2c_20b2Vec2__2c_20b2Color__29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + $2 = emscripten__internal__BindingType_b2Draw__2c_20void___fromWireType_28b2Draw__29(HEAP32[$5 + 24 >> 2]); + $0 = HEAP32[$5 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$5 + 20 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$5 + 16 >> 2]), emscripten__internal__GenericBindingType_b2Color___fromWireType_28b2Color__29(HEAP32[$5 + 12 >> 2])); + __stack_pointer = $5 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28_29_20const_2c_20unsigned_20long_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const____invoke_28unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______20const__29_28_29_20const_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20void___fromWireType_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = FUNCTION_TABLE[$0 | 0]($1) | 0, HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = emscripten__internal__BindingType_unsigned_20long_2c_20void___toWireType_28unsigned_20long_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2World____29_28_29_20const___invoke_b2World__28char_20const__2c_20b2Vec2_20_28b2World____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 519; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2World_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2World_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20_28b2World____emscripten__internal__getContext_b2Vec2_20_28b2World____29_28_29_20const__28b2Vec2_20_28b2World____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28bool_29___invoke_b2Fixture__28char_20const__2c_20void_20_28b2Fixture____29_28bool_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 563; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20bool___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20bool___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Fixture____emscripten__internal__getContext_void_20_28b2Fixture____29_28bool_29__28void_20_28b2Fixture____20const__29_28bool_29_29_29_28bool_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2____tree_end_node_std____2____tree_node_base_void______20std____2____tree_next_iter_5babi_v160004_5d_std____2____tree_end_node_std____2____tree_node_base_void______2c_20std____2____tree_node_base_void_____28std____2____tree_node_base_void____29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + label$1: { + if (HEAP32[HEAP32[$1 + 8 >> 2] + 4 >> 2]) { + wasm2js_i32$0 = $1, wasm2js_i32$1 = std____2____tree_node_base_void____20std____2____tree_min_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[HEAP32[$1 + 8 >> 2] + 4 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + break label$1; + } + while (1) { + if ((bool_20std____2____tree_is_left_child_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$1 + 8 >> 2]) ^ -1) & 1) { + wasm2js_i32$0 = $1, wasm2js_i32$1 = std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + continue; + } + break; + } + HEAP32[$1 + 12 >> 2] = HEAP32[HEAP32[$1 + 8 >> 2] + 8 >> 2]; + } + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function __lshrti3($0, $1, $2, $3, $4, $5) { + var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0; + label$1: { + if ($5 & 64) { + $7 = $4; + $8 = $3; + $9 = $5 + -64 | 0; + $6 = $9 & 31; + if (($9 & 63) >>> 0 >= 32) { + $1 = $7 >>> $6 | 0; + } else { + $10 = $7 >>> $6 | 0; + $1 = ((1 << $6) - 1 & $7) << 32 - $6 | $8 >>> $6; + } + $2 = $10; + $3 = 0; + $4 = 0; + break label$1; + } + if (!$5) { + break label$1; + } + $10 = $4; + $7 = $3; + $9 = 64 - $5 | 0; + $6 = $9 & 31; + if (($9 & 63) >>> 0 >= 32) { + $8 = $7 << $6; + $11 = 0; + } else { + $8 = (1 << $6) - 1 & $7 >>> 32 - $6 | $10 << $6; + $11 = $7 << $6; + } + $12 = $8; + $8 = $2; + $10 = $1; + $7 = 0; + $9 = $5; + $6 = $9 & 31; + if (($9 & 63) >>> 0 >= 32) { + $9 = $8 >>> $6 | 0; + } else { + $7 = $8 >>> $6 | 0; + $9 = ((1 << $6) - 1 & $8) << 32 - $6 | $10 >>> $6; + } + $10 = $7; + $8 = $11; + $1 = $8 | $9; + $7 = $12; + $10 = $7 | $10; + $2 = $10; + $10 = $4; + $7 = $3; + $8 = 0; + $9 = $5; + $6 = $9 & 31; + if (($9 & 63) >>> 0 >= 32) { + $3 = $10 >>> $6 | 0; + } else { + $8 = $10 >>> $6 | 0; + $3 = ((1 << $6) - 1 & $10) << 32 - $6 | $7 >>> $6; + } + $4 = $8; + } + $7 = $0; + HEAP32[$7 >> 2] = $1; + $8 = $2; + HEAP32[$7 + 4 >> 2] = $8; + HEAP32[$7 + 8 >> 2] = $3; + $8 = $4; + HEAP32[$7 + 12 >> 2] = $8; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Shape_20const__20_28__29_28b2FixtureDef__29___invoke_b2FixtureDef_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Shape_20const__20_28__29_28b2FixtureDef__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 560; + $0 = emscripten__internal__TypeID_b2FixtureDef_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape_20const__2c_20b2FixtureDef____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape_20const__2c_20b2FixtureDef____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Shape_20const__20_28__emscripten__internal__getContext_b2Shape_20const__20_28__29_28b2FixtureDef__29__28b2Shape_20const__20_28__20const__29_28b2FixtureDef__29_29_29_28b2FixtureDef__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28int_29___invoke_b2Fixture__28char_20const__2c_20void_20_28b2Fixture____29_28int_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 575; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20int___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20int___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Fixture____emscripten__internal__getContext_void_20_28b2Fixture____29_28int_29__28void_20_28b2Fixture____20const__29_28int_29_29_29_28int_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2JointDef__2c_20b2Body__29___invoke_b2JointDef_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2JointDef__2c_20b2Body__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 600; + $0 = emscripten__internal__TypeID_b2JointDef_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2JointDef__2c_20b2Body____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2JointDef__2c_20b2Body____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28__emscripten__internal__getContext_void_20_28__29_28b2JointDef__2c_20b2Body__29__28void_20_28__20const__29_28b2JointDef__2c_20b2Body__29_29_29_28b2JointDef__2c_20b2Body__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Vec2_20_28b2AABB____29_28_29_20const___invoke_b2AABB__28char_20const__2c_20b2Vec2_20_28b2AABB____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 499; + $0 = emscripten__internal__TypeID_b2AABB_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Vec2_20_28b2AABB____emscripten__internal__getContext_b2Vec2_20_28b2AABB____29_28_29_20const__28b2Vec2_20_28b2AABB____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2StackAllocator__Allocate_28int_29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAP32[$0 + 102796 >> 2] >= 32) { + __assert_fail(3536, 5418, 42, 8952); + wasm2js_trap(); + } + HEAP32[$2 + 4 >> 2] = ($0 + 102412 | 0) + Math_imul(HEAP32[$0 + 102796 >> 2], 12); + HEAP32[HEAP32[$2 + 4 >> 2] + 4 >> 2] = HEAP32[$2 + 8 >> 2]; + label$2: { + if ((HEAP32[$0 + 102400 >> 2] + HEAP32[$2 + 8 >> 2] | 0) > 102400) { + $1 = b2Alloc_28int_29(HEAP32[$2 + 8 >> 2]); + HEAP32[HEAP32[$2 + 4 >> 2] >> 2] = $1; + HEAP8[HEAP32[$2 + 4 >> 2] + 8 | 0] = 1; + break label$2; + } + HEAP32[HEAP32[$2 + 4 >> 2] >> 2] = HEAP32[$0 + 102400 >> 2] + $0; + HEAP8[HEAP32[$2 + 4 >> 2] + 8 | 0] = 0; + HEAP32[$0 + 102400 >> 2] = HEAP32[$2 + 8 >> 2] + HEAP32[$0 + 102400 >> 2]; + } + HEAP32[$0 + 102404 >> 2] = HEAP32[$2 + 8 >> 2] + HEAP32[$0 + 102404 >> 2]; + wasm2js_i32$0 = $0, wasm2js_i32$1 = int_20b2Max_int__28int_2c_20int_29(HEAP32[$0 + 102408 >> 2], HEAP32[$0 + 102404 >> 2]), + HEAP32[wasm2js_i32$0 + 102408 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 102796 >> 2] = HEAP32[$0 + 102796 >> 2] + 1; + __stack_pointer = $2 + 16 | 0; + return HEAP32[HEAP32[$2 + 4 >> 2] >> 2]; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2AABB____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const_2c_20bool_2c_20b2AABB_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const____invoke_28bool_20_28b2AABB____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const_2c_20b2AABB_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_b2AABB_20const__2c_20void___fromWireType_28b2AABB_20const__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2RayCastOutput__2c_20void___fromWireType_28b2RayCastOutput__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__GenericBindingType_b2RayCastInput___fromWireType_28b2RayCastInput__29(HEAP32[$4 >> 2])) & 1); + __stack_pointer = $4 + 16 | 0; + return $0 & 1; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20float_20_28b2Body____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 583; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2Body____emscripten__internal__getContext_float_20_28b2Body____29_28_29_20const__28float_20_28b2Body____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28b2AABB____29_28_29_20const___invoke_b2AABB__28char_20const__2c_20float_20_28b2AABB____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 500; + $0 = emscripten__internal__TypeID_b2AABB_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28b2AABB____emscripten__internal__getContext_float_20_28b2AABB____29_28_29_20const__28float_20_28b2AABB____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2World____29_28_29_20const___invoke_b2World__28char_20const__2c_20bool_20_28b2World____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 517; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2World_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2World_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2World____emscripten__internal__getContext_bool_20_28b2World____29_28_29_20const__28bool_20_28b2World____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Joint____29_28_29_20const___invoke_b2Joint__28char_20const__2c_20bool_20_28b2Joint____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 607; + $0 = emscripten__internal__TypeID_b2Joint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2Joint____emscripten__internal__getContext_bool_20_28b2Joint____29_28_29_20const__28bool_20_28b2Joint____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2PolygonShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20bool_2c_20b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____invoke_28bool_20_28b2PolygonShape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20b2PolygonShape_20const__2c_20b2Transform__2c_20b2Vec2__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_b2PolygonShape_20const__2c_20void___fromWireType_28b2PolygonShape_20const__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$4 >> 2])) & 1); + __stack_pointer = $4 + 16 | 0; + return $0 & 1; +} + +function std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______construct_at_end_28unsigned_20long_2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2______ConstructTransaction___ConstructTransaction_5babi_v160004_5d_28b2Vec2___2c_20unsigned_20long_29($3 + 8 | 0, $0 + 8 | 0, HEAP32[$3 + 24 >> 2]); + while (1) { + if (HEAP32[$3 + 8 >> 2] != HEAP32[$3 + 12 >> 2]) { + void_20std____2__allocator_traits_std____2__allocator_b2Vec2____construct_5babi_v160004_5d_b2Vec2_2c_20b2Vec2_20const__2c_20void__28std____2__allocator_b2Vec2___2c_20b2Vec2__2c_20b2Vec2_20const__29(std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______alloc_5babi_v160004_5d_28_29($0), b2Vec2__20std____2____to_address_5babi_v160004_5d_b2Vec2__28b2Vec2__29(HEAP32[$3 + 8 >> 2]), HEAP32[$3 + 20 >> 2]); + HEAP32[$3 + 8 >> 2] = HEAP32[$3 + 8 >> 2] + 8; + continue; + } + break; + } + std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2______ConstructTransaction____ConstructTransaction_5babi_v160004_5d_28_29($3 + 8 | 0); + __stack_pointer = $3 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29_2c_20void_2c_20b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Color_20const____invoke_28void_20_28b2Draw____20const__29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29_2c_20b2Draw__2c_20b2Vec2__2c_20float_2c_20b2Color__29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = Math_fround($3); + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAPF32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + $2 = emscripten__internal__BindingType_b2Draw__2c_20void___fromWireType_28b2Draw__29(HEAP32[$5 + 24 >> 2]); + $0 = HEAP32[$5 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$5 + 20 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$5 + 16 >> 2]), emscripten__internal__GenericBindingType_b2Color___fromWireType_28b2Color__29(HEAP32[$5 + 12 >> 2])); + __stack_pointer = $5 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28bool_29___invoke_b2World__28char_20const__2c_20void_20_28b2World____29_28bool_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 516; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20bool___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20bool___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28bool_29__28void_20_28b2World____20const__29_28bool_29_29_29_28bool_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28float_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 585; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20float___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20float___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28float_29__28void_20_28b2Body____20const__29_28float_29_29_29_28float_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Draw____29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29_2c_20void_2c_20b2Draw__2c_20unsigned_20int_2c_20int_2c_20b2Color_20const____invoke_28void_20_28b2Draw____20const__29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29_2c_20b2Draw__2c_20unsigned_20int_2c_20int_2c_20b2Color__29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + $2 = emscripten__internal__BindingType_b2Draw__2c_20void___fromWireType_28b2Draw__29(HEAP32[$5 + 24 >> 2]); + $0 = HEAP32[$5 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$5 + 20 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$5 + 16 >> 2]), emscripten__internal__GenericBindingType_b2Color___fromWireType_28b2Color__29(HEAP32[$5 + 12 >> 2])); + __stack_pointer = $5 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_int_20_28b2Shape____29_28_29_20const___invoke_b2Shape__28char_20const__2c_20int_20_28b2Shape____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 521; + $0 = emscripten__internal__TypeID_b2Shape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], int_20_28b2Shape____emscripten__internal__getContext_int_20_28b2Shape____29_28_29_20const__28int_20_28b2Shape____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2CircleShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20bool_2c_20b2CircleShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____invoke_28bool_20_28b2CircleShape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20b2CircleShape_20const__2c_20b2Transform__2c_20b2Vec2__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_b2CircleShape_20const__2c_20void___fromWireType_28b2CircleShape_20const__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$4 >> 2])) & 1); + __stack_pointer = $4 + 16 | 0; + return $0 & 1; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2Body____29_28_29_20const___invoke_b2Body__28char_20const__2c_20bool_20_28b2Body____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 596; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2Body____emscripten__internal__getContext_bool_20_28b2Body____29_28_29_20const__28bool_20_28b2Body____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_bool_20_28b2AABB____29_28_29_20const___invoke_b2AABB__28char_20const__2c_20bool_20_28b2AABB____29_28_29_20const_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 498; + $0 = emscripten__internal__TypeID_b2AABB_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], bool_20_28b2AABB____emscripten__internal__getContext_bool_20_28b2AABB____29_28_29_20const__28bool_20_28b2AABB____20const__29_28_29_20const_29_29_28_29_20const($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2WheelJoint____29_28_29___invoke_b2WheelJoint__28char_20const__2c_20void_20_28b2WheelJoint____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 695; + $0 = emscripten__internal__TypeID_b2WheelJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2WheelJoint____emscripten__internal__getContext_void_20_28b2WheelJoint____29_28_29__28void_20_28b2WheelJoint____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2MouseJoint____29_28_29___invoke_b2MouseJoint__28char_20const__2c_20void_20_28b2MouseJoint____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 637; + $0 = emscripten__internal__TypeID_b2MouseJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2MouseJoint____emscripten__internal__getContext_void_20_28b2MouseJoint____29_28_29__28void_20_28b2MouseJoint____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2MotorJoint____29_28_29___invoke_b2MotorJoint__28char_20const__2c_20void_20_28b2MotorJoint____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 627; + $0 = emscripten__internal__TypeID_b2MotorJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2MotorJoint____emscripten__internal__getContext_void_20_28b2MotorJoint____29_28_29__28void_20_28b2MotorJoint____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__FunctionInvoker_emscripten__val_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29_2c_20emscripten__val_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long___invoke_28emscripten__val_20_28___29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[HEAP32[$3 + 12 >> 2] >> 2]; + FUNCTION_TABLE[$0 | 0]($3, emscripten__internal__GenericBindingType_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____fromWireType_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29(HEAP32[$3 + 8 >> 2]), emscripten__internal__BindingType_unsigned_20long_2c_20void___fromWireType_28unsigned_20long_29(HEAP32[$3 + 4 >> 2])); + $0 = emscripten__internal__BindingType_emscripten__val_2c_20void___toWireType_28emscripten__val_20const__29($3); + emscripten__val___val_28_29($3); + __stack_pointer = $3 + 16 | 0; + return $0 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28bool_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28bool_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 595; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20bool___getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20bool___getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28bool_29__28void_20_28b2Body____20const__29_28bool_29_29_29_28bool_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______unique_ptr_5babi_v160004_5d_true_2c_20void__28std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____dependent_type_std____2____unique_ptr_deleter_sfinae_std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______2c_20true_____good_rval_ref_type_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + std____2____compressed_pair_std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_________compressed_pair_5babi_v160004_5d_std____2____tree_node_b2Fixture__2c_20void_____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______28std____2____tree_node_b2Fixture__2c_20void_____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______29($0, $3 + 8 | 0, HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; + return $0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______tree_28std____2__less_b2Fixture___20const__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + std____2____compressed_pair_std____2____tree_end_node_std____2____tree_node_base_void_____2c_20std____2__allocator_std____2____tree_node_b2Fixture__2c_20void________compressed_pair_5babi_v160004_5d_true_2c_20void__28_29($0 + 4 | 0); + HEAP32[$2 + 4 >> 2] = 0; + std____2____compressed_pair_unsigned_20long_2c_20std____2__less_b2Fixture_______compressed_pair_5babi_v160004_5d_int_2c_20std____2__less_b2Fixture___20const___28int___2c_20std____2__less_b2Fixture___20const__29($0 + 8 | 0, $2 + 4 | 0, HEAP32[$2 + 8 >> 2]); + $1 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______end_node_5babi_v160004_5d_28_29($0); + wasm2js_i32$0 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______begin_node_5babi_v160004_5d_28_29($0), + wasm2js_i32$1 = $1, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function std____2__pair_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____20std____2____move_5babi_v160004_5d_std____2___ClassicAlgPolicy_2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 28 >> 2] = $1; + HEAP32[$4 + 24 >> 2] = $2; + HEAP32[$4 + 20 >> 2] = $3; + HEAP32[$4 + 16 >> 2] = HEAP32[$4 + 28 >> 2]; + HEAP32[$4 + 12 >> 2] = HEAP32[$4 + 24 >> 2]; + HEAP32[$4 + 8 >> 2] = HEAP32[$4 + 20 >> 2]; + std____2__pair_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____20std____2____dispatch_copy_or_move_5babi_v160004_5d_std____2___ClassicAlgPolicy_2c_20std____2____move_loop_std____2___ClassicAlgPolicy__2c_20std____2____move_trivial_2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($0, HEAP32[$4 + 16 >> 2], HEAP32[$4 + 12 >> 2], HEAP32[$4 + 8 >> 2]); + __stack_pointer = $4 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2WeldJoint____29_28_29___invoke_b2WeldJoint__28char_20const__2c_20void_20_28b2WeldJoint____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 683; + $0 = emscripten__internal__TypeID_b2WeldJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2WeldJoint____emscripten__internal__getContext_void_20_28b2WeldJoint____29_28_29__28void_20_28b2WeldJoint____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2RopeJoint____29_28_29___invoke_b2RopeJoint__28char_20const__2c_20void_20_28b2RopeJoint____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 674; + $0 = emscripten__internal__TypeID_b2RopeJoint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2RopeJoint____emscripten__internal__getContext_void_20_28b2RopeJoint____29_28_29__28void_20_28b2RopeJoint____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2EdgeShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20bool_2c_20b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____invoke_28bool_20_28b2EdgeShape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20b2EdgeShape_20const__2c_20b2Transform__2c_20b2Vec2__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_b2EdgeShape_20const__2c_20void___fromWireType_28b2EdgeShape_20const__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$4 >> 2])) & 1); + __stack_pointer = $4 + 16 | 0; + return $0 & 1; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29_2c_20void_2c_20b2Body__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool___invoke_28void_20_28b2Body____20const__29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29_2c_20b2Body__2c_20b2Vec2__2c_20b2Vec2__2c_20bool_29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP8[$5 + 15 | 0] = $4 & 1; + $2 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$5 + 24 >> 2]); + $0 = HEAP32[$5 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$5 + 20 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$5 + 16 >> 2]), emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$5 + 15 | 0] & 1) & 1); + __stack_pointer = $5 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28_29_20const_2c_20unsigned_20long_2c_20std____2__vector_int_2c_20std____2__allocator_int___20const____invoke_28unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______20const__29_28_29_20const_2c_20std____2__vector_int_2c_20std____2__allocator_int___20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20void___fromWireType_28std____2__vector_int_2c_20std____2__allocator_int___20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = FUNCTION_TABLE[$0 | 0]($1) | 0, HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = emscripten__internal__BindingType_unsigned_20long_2c_20void___toWireType_28unsigned_20long_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2ContactSolver__StoreImpulses_28_29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 32 | 0; + __stack_pointer = $1; + HEAP32[$1 + 28 >> 2] = $0; + $0 = HEAP32[$1 + 28 >> 2]; + HEAP32[$1 + 24 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 24 >> 2] < HEAP32[$0 + 48 >> 2]) { + HEAP32[$1 + 20 >> 2] = HEAP32[$0 + 40 >> 2] + Math_imul(HEAP32[$1 + 24 >> 2], 156); + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Contact__GetManifold_28_29(HEAP32[HEAP32[$0 + 44 >> 2] + (HEAP32[HEAP32[$1 + 20 >> 2] + 152 >> 2] << 2) >> 2]), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + HEAP32[$1 + 12 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 12 >> 2] < HEAP32[HEAP32[$1 + 20 >> 2] + 148 >> 2]) { + HEAPF32[(HEAP32[$1 + 16 >> 2] + Math_imul(HEAP32[$1 + 12 >> 2], 20) | 0) + 8 >> 2] = HEAPF32[(HEAP32[$1 + 20 >> 2] + Math_imul(HEAP32[$1 + 12 >> 2], 36) | 0) + 16 >> 2]; + HEAPF32[(HEAP32[$1 + 16 >> 2] + Math_imul(HEAP32[$1 + 12 >> 2], 20) | 0) + 12 >> 2] = HEAPF32[(HEAP32[$1 + 20 >> 2] + Math_imul(HEAP32[$1 + 12 >> 2], 36) | 0) + 20 >> 2]; + HEAP32[$1 + 12 >> 2] = HEAP32[$1 + 12 >> 2] + 1; + continue; + } + break; + } + HEAP32[$1 + 24 >> 2] = HEAP32[$1 + 24 >> 2] + 1; + continue; + } + break; + } + __stack_pointer = $1 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2AABB__2c_20b2AABB__29___invoke_b2AABB_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2AABB__2c_20b2AABB__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 501; + $0 = emscripten__internal__TypeID_b2AABB_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2AABB__2c_20b2AABB____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2AABB__2c_20b2AABB____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28__emscripten__internal__getContext_void_20_28__29_28b2AABB__2c_20b2AABB__29__28void_20_28__20const__29_28b2AABB__2c_20b2AABB__29_29_29_28b2AABB__2c_20b2AABB__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2Shape__2c_20float_29___invoke_b2Shape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2Shape__2c_20float_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 526; + $0 = emscripten__internal__TypeID_b2Shape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2Shape__2c_20float___getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2Shape__2c_20float___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28__emscripten__internal__getContext_void_20_28__29_28b2Shape__2c_20float_29__28void_20_28__20const__29_28b2Shape__2c_20float_29_29_29_28b2Shape__2c_20float_29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____basic_string_5babi_v160004_5d_28char_20const__2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 24 >> 2] = $0; + HEAP32[$3 + 20 >> 2] = $1; + HEAP32[$3 + 16 >> 2] = $2; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$3 + 28 >> 2] = $0; + std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char______compressed_pair_5babi_v160004_5d_std____2____default_init_tag_2c_20std____2____default_init_tag__28std____2____default_init_tag___2c_20std____2____default_init_tag___29($0, $3 + 15 | 0, $3 + 14 | 0); + std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______init_28char_20const__2c_20unsigned_20long_29($0, HEAP32[$3 + 20 >> 2], HEAP32[$3 + 16 >> 2]); + void_20std____2____debug_db_insert_c_5babi_v160004_5d_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____29($0); + __stack_pointer = $3 + 32 | 0; + return HEAP32[$3 + 28 >> 2]; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Fixture____29_28_29___invoke_b2Fixture__28char_20const__2c_20void_20_28b2Fixture____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 567; + $0 = emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Fixture____emscripten__internal__getContext_void_20_28b2Fixture____29_28_29__28void_20_28b2Fixture____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function __ashlti3($0, $1, $2, $3, $4, $5) { + var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0; + label$1: { + if ($5 & 64) { + $7 = $2; + $8 = $1; + $5 = $5 + -64 | 0; + $6 = $5 & 31; + if (($5 & 63) >>> 0 >= 32) { + $9 = $8 << $6; + $3 = 0; + } else { + $9 = (1 << $6) - 1 & $8 >>> 32 - $6 | $7 << $6; + $3 = $8 << $6; + } + $4 = $9; + $1 = 0; + $2 = 0; + break label$1; + } + if (!$5) { + break label$1; + } + $10 = $5; + $9 = $4; + $7 = $3; + $6 = $5 & 31; + if (($5 & 63) >>> 0 >= 32) { + $8 = $7 << $6; + $3 = 0; + } else { + $8 = (1 << $6) - 1 & $7 >>> 32 - $6 | $9 << $6; + $3 = $7 << $6; + } + $4 = $8; + $8 = $2; + $9 = $1; + $7 = 0; + $5 = 64 - $5 | 0; + $6 = $5 & 31; + if (($5 & 63) >>> 0 >= 32) { + $5 = $8 >>> $6 | 0; + } else { + $7 = $8 >>> $6 | 0; + $5 = ((1 << $6) - 1 & $8) << 32 - $6 | $9 >>> $6; + } + $9 = $7; + $8 = $3; + $3 = $8 | $5; + $7 = $4; + $9 = $7 | $9; + $4 = $9; + $9 = $2; + $7 = $1; + $5 = $10; + $6 = $5 & 31; + if (($5 & 63) >>> 0 >= 32) { + $8 = $7 << $6; + $1 = 0; + } else { + $8 = (1 << $6) - 1 & $7 >>> 32 - $6 | $9 << $6; + $1 = $7 << $6; + } + $2 = $8; + } + $7 = $0; + HEAP32[$7 >> 2] = $1; + $8 = $2; + HEAP32[$7 + 4 >> 2] = $8; + HEAP32[$7 + 8 >> 2] = $3; + $8 = $4; + HEAP32[$7 + 12 >> 2] = $8; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2Shape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20bool_2c_20b2Shape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____invoke_28bool_20_28b2Shape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20b2Shape_20const__2c_20b2Transform__2c_20b2Vec2__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_b2Shape_20const__2c_20void___fromWireType_28b2Shape_20const__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$4 >> 2])) & 1); + __stack_pointer = $4 + 16 | 0; + return $0 & 1; +} + +function std____2__reverse_iterator_b2Vec2___20std____2____uninitialized_allocator_move_if_noexcept_5babi_v160004_5d_std____2__allocator_b2Vec2__2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20b2Vec2_2c_20void__28std____2__allocator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 24 >> 2] = $1; + HEAP32[$4 + 20 >> 2] = $2; + HEAP32[$4 + 16 >> 2] = $3; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = HEAP32[$4 + 24 >> 2]; + HEAP32[$4 + 4 >> 2] = HEAP32[$4 + 20 >> 2]; + HEAP32[$4 >> 2] = HEAP32[$4 + 16 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = std____2__reverse_iterator_b2Vec2___20std____2__move_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29(HEAP32[$4 + 8 >> 2], HEAP32[$4 + 4 >> 2], HEAP32[$4 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + __stack_pointer = $4 + 32 | 0; + return HEAP32[$4 + 28 >> 2]; +} + +function emscripten__internal__FunctionInvoker_emscripten__val_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29_2c_20emscripten__val_2c_20std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long___invoke_28emscripten__val_20_28___29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[HEAP32[$3 + 12 >> 2] >> 2]; + FUNCTION_TABLE[$0 | 0]($3, emscripten__internal__GenericBindingType_std____2__vector_int_2c_20std____2__allocator_int_____fromWireType_28std____2__vector_int_2c_20std____2__allocator_int____29(HEAP32[$3 + 8 >> 2]), emscripten__internal__BindingType_unsigned_20long_2c_20void___fromWireType_28unsigned_20long_29(HEAP32[$3 + 4 >> 2])); + $0 = emscripten__internal__BindingType_emscripten__val_2c_20void___toWireType_28emscripten__val_20const__29($3); + emscripten__val___val_28_29($3); + __stack_pointer = $3 + 16 | 0; + return $0 | 0; +} + +function b2DynamicTree__b2DynamicTree_28_29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$0 >> 2] = -1; + HEAP32[$0 + 12 >> 2] = 16; + HEAP32[$0 + 8 >> 2] = 0; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Alloc_28int_29(Math_imul(HEAP32[$0 + 12 >> 2], 40)), + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + __memset(HEAP32[$0 + 4 >> 2], 0, Math_imul(HEAP32[$0 + 12 >> 2], 40)); + HEAP32[$1 + 4 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 4 >> 2] < (HEAP32[$0 + 12 >> 2] - 1 | 0)) { + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$1 + 4 >> 2], 40) | 0) + 20 >> 2] = HEAP32[$1 + 4 >> 2] + 1; + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$1 + 4 >> 2], 40) | 0) + 32 >> 2] = -1; + HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] + 1; + continue; + } + break; + } + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$0 + 12 >> 2] - 1 | 0, 40) | 0) + 20 >> 2] = -1; + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$0 + 12 >> 2] - 1 | 0, 40) | 0) + 32 >> 2] = -1; + HEAP32[$0 + 16 >> 2] = 0; + HEAP32[$0 + 20 >> 2] = 0; + HEAP32[$0 + 24 >> 2] = 0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2World____29_28_29___invoke_b2World__28char_20const__2c_20void_20_28b2World____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 508; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28_29__28void_20_28b2World____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Joint____29_28_29___invoke_b2Joint__28char_20const__2c_20void_20_28b2Joint____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 608; + $0 = emscripten__internal__TypeID_b2Joint_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Joint____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Joint____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Joint____emscripten__internal__getContext_void_20_28b2Joint____29_28_29__28void_20_28b2Joint____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2RopeJoint__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 112 | 0; + __stack_pointer = $1; + HEAP32[$1 + 108 >> 2] = $0; + $0 = HEAP32[$1 + 108 >> 2]; + HEAP32[$1 + 104 >> 2] = HEAP32[HEAP32[$0 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 100 >> 2] = HEAP32[HEAP32[$0 + 52 >> 2] + 8 >> 2]; + b2Dump_28char_20const__2c_20____29(13613, 0); + HEAP32[$1 + 64 >> 2] = HEAP32[$1 + 104 >> 2]; + b2Dump_28char_20const__2c_20____29(13849, $1 - -64 | 0); + HEAP32[$1 + 48 >> 2] = HEAP32[$1 + 100 >> 2]; + b2Dump_28char_20const__2c_20____29(13823, $1 + 48 | 0); + HEAP32[$1 + 32 >> 2] = HEAP8[$0 + 61 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14859, $1 + 32 | 0); + $2 = HEAPF32[$0 + 68 >> 2]; + HEAPF64[$1 + 24 >> 3] = HEAPF32[$0 + 72 >> 2]; + HEAPF64[$1 + 16 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14265, $1 + 16 | 0); + $2 = HEAPF32[$0 + 76 >> 2]; + HEAPF64[$1 + 8 >> 3] = HEAPF32[$0 + 80 >> 2]; + HEAPF64[$1 >> 3] = $2; + b2Dump_28char_20const__2c_20____29(14158, $1); + HEAPF64[$1 + 80 >> 3] = HEAPF32[$0 + 84 >> 2]; + b2Dump_28char_20const__2c_20____29(12941, $1 + 80 | 0); + HEAP32[$1 + 96 >> 2] = HEAP32[$0 + 56 >> 2]; + b2Dump_28char_20const__2c_20____29(14538, $1 + 96 | 0); + __stack_pointer = $1 + 112 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28int_20const__29_2c_20void_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20int_20const____invoke_28void_20_28std____2__vector_int_2c_20std____2__allocator_int______20const__29_28int_20const__29_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_std____2__vector_int_2c_20std____2__allocator_int____2c_20void___fromWireType_28std____2__vector_int_2c_20std____2__allocator_int____29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $3, wasm2js_i32$1 = emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$3 + 4 >> 2]), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + FUNCTION_TABLE[$0 | 0]($2, $3); + __stack_pointer = $3 + 16 | 0; +} + +function b2Mat33__GetInverse22_28b2Mat33__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 32 | 0; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + HEAPF32[$2 + 20 >> 2] = HEAPF32[$0 >> 2]; + HEAPF32[$2 + 16 >> 2] = HEAPF32[$0 + 12 >> 2]; + HEAPF32[$2 + 12 >> 2] = HEAPF32[$0 + 4 >> 2]; + HEAPF32[$2 + 8 >> 2] = HEAPF32[$0 + 16 >> 2]; + HEAPF32[$2 + 4 >> 2] = Math_fround(HEAPF32[$2 + 20 >> 2] * HEAPF32[$2 + 8 >> 2]) - Math_fround(HEAPF32[$2 + 16 >> 2] * HEAPF32[$2 + 12 >> 2]); + if (HEAPF32[$2 + 4 >> 2] != Math_fround(0)) { + HEAPF32[$2 + 4 >> 2] = Math_fround(1) / HEAPF32[$2 + 4 >> 2]; + } + HEAPF32[HEAP32[$2 + 24 >> 2] >> 2] = HEAPF32[$2 + 4 >> 2] * HEAPF32[$2 + 8 >> 2]; + HEAPF32[HEAP32[$2 + 24 >> 2] + 12 >> 2] = Math_fround(-HEAPF32[$2 + 4 >> 2]) * HEAPF32[$2 + 16 >> 2]; + HEAPF32[HEAP32[$2 + 24 >> 2] + 8 >> 2] = 0; + HEAPF32[HEAP32[$2 + 24 >> 2] + 4 >> 2] = Math_fround(-HEAPF32[$2 + 4 >> 2]) * HEAPF32[$2 + 12 >> 2]; + HEAPF32[HEAP32[$2 + 24 >> 2] + 16 >> 2] = HEAPF32[$2 + 4 >> 2] * HEAPF32[$2 + 20 >> 2]; + HEAPF32[HEAP32[$2 + 24 >> 2] + 20 >> 2] = 0; + HEAPF32[HEAP32[$2 + 24 >> 2] + 24 >> 2] = 0; + HEAPF32[HEAP32[$2 + 24 >> 2] + 28 >> 2] = 0; + HEAPF32[HEAP32[$2 + 24 >> 2] + 32 >> 2] = 0; +} + +function std____2____split_buffer_int_2c_20std____2__allocator_int_______construct_at_end_28unsigned_20long_2c_20int_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + std____2____split_buffer_int_2c_20std____2__allocator_int______ConstructTransaction___ConstructTransaction_5babi_v160004_5d_28int___2c_20unsigned_20long_29($3 + 8 | 0, $0 + 8 | 0, HEAP32[$3 + 24 >> 2]); + while (1) { + if (HEAP32[$3 + 8 >> 2] != HEAP32[$3 + 12 >> 2]) { + void_20std____2__allocator_traits_std____2__allocator_int____construct_5babi_v160004_5d_int_2c_20int_20const__2c_20void__28std____2__allocator_int___2c_20int__2c_20int_20const__29(std____2____split_buffer_int_2c_20std____2__allocator_int_______alloc_5babi_v160004_5d_28_29($0), int__20std____2____to_address_5babi_v160004_5d_int__28int__29(HEAP32[$3 + 8 >> 2]), HEAP32[$3 + 20 >> 2]); + HEAP32[$3 + 8 >> 2] = HEAP32[$3 + 8 >> 2] + 4; + continue; + } + break; + } + std____2____split_buffer_int_2c_20std____2__allocator_int______ConstructTransaction____ConstructTransaction_5babi_v160004_5d_28_29($3 + 8 | 0); + __stack_pointer = $3 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28b2Body____29_28_29___invoke_b2Body__28char_20const__2c_20void_20_28b2Body____29_28_29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + $3 = HEAP32[$1 >> 2]; + $1 = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = $3; + HEAP32[$2 + 12 >> 2] = 591; + $0 = emscripten__internal__TypeID_b2Body_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body____getCount_28_29_20const($2 + 11 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body____getTypes_28_29_20const($2 + 11 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28_29__28void_20_28b2Body____20const__29_28_29_29_29_28_29($2 + 16 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2GearJoint__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 128 | 0; + __stack_pointer = $1; + HEAP32[$1 + 124 >> 2] = $0; + $0 = HEAP32[$1 + 124 >> 2]; + HEAP32[$1 + 120 >> 2] = HEAP32[HEAP32[$0 + 48 >> 2] + 8 >> 2]; + HEAP32[$1 + 116 >> 2] = HEAP32[HEAP32[$0 + 52 >> 2] + 8 >> 2]; + HEAP32[$1 + 112 >> 2] = HEAP32[HEAP32[$0 + 68 >> 2] + 56 >> 2]; + HEAP32[$1 + 108 >> 2] = HEAP32[HEAP32[$0 + 72 >> 2] + 56 >> 2]; + b2Dump_28char_20const__2c_20____29(13516, 0); + HEAP32[$1 + 64 >> 2] = HEAP32[$1 + 120 >> 2]; + b2Dump_28char_20const__2c_20____29(13849, $1 - -64 | 0); + HEAP32[$1 + 48 >> 2] = HEAP32[$1 + 116 >> 2]; + b2Dump_28char_20const__2c_20____29(13823, $1 + 48 | 0); + HEAP32[$1 + 32 >> 2] = HEAP8[$0 + 61 | 0] & 1; + b2Dump_28char_20const__2c_20____29(14859, $1 + 32 | 0); + HEAP32[$1 + 16 >> 2] = HEAP32[$1 + 112 >> 2]; + b2Dump_28char_20const__2c_20____29(13796, $1 + 16 | 0); + HEAP32[$1 >> 2] = HEAP32[$1 + 108 >> 2]; + b2Dump_28char_20const__2c_20____29(13769, $1); + HEAPF64[$1 + 80 >> 3] = HEAPF32[$0 + 152 >> 2]; + b2Dump_28char_20const__2c_20____29(12785, $1 + 80 | 0); + HEAP32[$1 + 96 >> 2] = HEAP32[$0 + 56 >> 2]; + b2Dump_28char_20const__2c_20____29(14538, $1 + 96 | 0); + __stack_pointer = $1 + 128 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2RayCastCallbackWrapper__29___invoke_b2RayCastCallbackWrapper__28char_20const__2c_20void_20_28__29_28b2RayCastCallbackWrapper__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 477; + $0 = emscripten__internal__TypeID_b2RayCastCallbackWrapper_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2RayCastCallbackWrapper____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2RayCastCallbackWrapper____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28__emscripten__internal__getContext_void_20_28__29_28b2RayCastCallbackWrapper__29__28void_20_28__20const__29_28b2RayCastCallbackWrapper__29_29_29_28b2RayCastCallbackWrapper__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2ContactListenerWrapper__29___invoke_b2ContactListenerWrapper__28char_20const__2c_20void_20_28__29_28b2ContactListenerWrapper__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 485; + $0 = emscripten__internal__TypeID_b2ContactListenerWrapper_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2ContactListenerWrapper____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2ContactListenerWrapper____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28__emscripten__internal__getContext_void_20_28__29_28b2ContactListenerWrapper__29__28void_20_28__20const__29_28b2ContactListenerWrapper__29_29_29_28b2ContactListenerWrapper__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__FunctionInvoker_void_20_28__29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29_2c_20void_2c_20b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int___invoke_28void_20_28___29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29_2c_20b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $0 = HEAP32[HEAP32[$4 + 12 >> 2] >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_b2PolygonShape__2c_20void___fromWireType_28b2PolygonShape__29(HEAP32[$4 + 8 >> 2]), emscripten__internal__GenericBindingType_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____fromWireType_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29(HEAP32[$4 + 4 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function emscripten__internal__MethodCaller_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____call_28emscripten___EM_VAL__2c_20char_20const__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 48 | 0; + __stack_pointer = $5; + HEAP32[$5 + 44 >> 2] = $0; + HEAP32[$5 + 40 >> 2] = $1; + HEAP32[$5 + 36 >> 2] = $2; + HEAP32[$5 + 32 >> 2] = $3; + HEAP32[$5 + 28 >> 2] = $4; + wasm2js_i32$0 = $5, wasm2js_i32$1 = emscripten__internal__Signature_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____get_method_caller_28_29(), + HEAP32[wasm2js_i32$0 + 24 >> 2] = wasm2js_i32$1; + emscripten__internal__WireTypePack_b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____WireTypePack_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29($5, HEAP32[$5 + 36 >> 2], HEAP32[$5 + 32 >> 2], HEAP32[$5 + 28 >> 2]); + _emval_call_void_method(HEAP32[$5 + 24 >> 2], HEAP32[$5 + 44 >> 2], HEAP32[$5 + 40 >> 2], emscripten__internal__WireTypePack_b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____operator_20void_20const__28_29_20const($5) | 0); + __stack_pointer = $5 + 48 | 0; +} + +function emscripten__internal__MethodInvoker_float_20_28b2PrismaticJoint____29_28float_29_20const_2c_20float_2c_20b2PrismaticJoint_20const__2c_20float___invoke_28float_20_28b2PrismaticJoint____20const__29_28float_29_20const_2c_20b2PrismaticJoint_20const__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2PrismaticJoint_20const__2c_20void___fromWireType_28b2PrismaticJoint_20const__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $3, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]))), + HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0; + $2 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($3); + __stack_pointer = $3 + 16 | 0; + return Math_fround($2); +} + +function b2World__CreateBody_28b2BodyDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + $0 = HEAP32[$2 + 24 >> 2]; + if (b2World__IsLocked_28_29_20const($0) & 1) { + __assert_fail(9133, 6161, 117, 1635); + wasm2js_trap(); + } + label$2: { + if (b2World__IsLocked_28_29_20const($0) & 1) { + HEAP32[$2 + 28 >> 2] = 0; + break label$2; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29($0, 152), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$2 + 16 >> 2]; + b2Body__b2Body_28b2BodyDef_20const__2c_20b2World__29($1, HEAP32[$2 + 20 >> 2], $0); + HEAP32[$2 + 12 >> 2] = $1; + HEAP32[HEAP32[$2 + 12 >> 2] + 92 >> 2] = 0; + HEAP32[HEAP32[$2 + 12 >> 2] + 96 >> 2] = HEAP32[$0 + 102948 >> 2]; + if (HEAP32[$0 + 102948 >> 2]) { + HEAP32[HEAP32[$0 + 102948 >> 2] + 92 >> 2] = HEAP32[$2 + 12 >> 2]; + } + HEAP32[$0 + 102948 >> 2] = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 + 102956 >> 2] = HEAP32[$0 + 102956 >> 2] + 1; + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + } + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function b2Body__ApplyLinearImpulse_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0, $5 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 28 >> 2] = $0; + HEAP32[$4 + 24 >> 2] = $1; + HEAP32[$4 + 20 >> 2] = $2; + HEAP8[$4 + 19 | 0] = $3; + $0 = HEAP32[$4 + 28 >> 2]; + label$1: { + if (HEAP32[$0 >> 2] != 2) { + break label$1; + } + if (!(!(HEAP8[$4 + 19 | 0] & 1) | HEAPU16[$0 + 4 >> 1] & 2)) { + b2Body__SetAwake_28bool_29($0, 1); + } + if (!(HEAPU16[$0 + 4 >> 1] & 2)) { + break label$1; + } + operator__28float_2c_20b2Vec2_20const__29($4 + 8 | 0, HEAPF32[$0 + 120 >> 2], HEAP32[$4 + 24 >> 2]); + b2Vec2__operator___28b2Vec2_20const__29($0 - -64 | 0, $4 + 8 | 0); + $5 = HEAPF32[$0 + 128 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4, HEAP32[$4 + 20 >> 2], $0 + 44 | 0); + wasm2js_i32$0 = $0, wasm2js_f32$0 = Math_fround(Math_fround($5 * b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($4, HEAP32[$4 + 24 >> 2])) + HEAPF32[$0 + 72 >> 2]), + HEAPF32[wasm2js_i32$0 + 72 >> 2] = wasm2js_f32$0; + } + __stack_pointer = $4 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassMethod_b2Body__20_28__29_28b2JointDef__29___invoke_b2JointDef_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Body__20_28__29_28b2JointDef__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 601; + $0 = emscripten__internal__TypeID_b2JointDef_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20b2JointDef____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20b2JointDef____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], b2Body__20_28__emscripten__internal__getContext_b2Body__20_28__29_28b2JointDef__29__28b2Body__20_28__20const__29_28b2JointDef__29_29_29_28b2JointDef__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______annotate_delete_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______annotate_contiguous_container_5babi_v160004_5d_28void_20const__2c_20void_20const__2c_20void_20const__2c_20void_20const__29_20const($0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29_20const($0), std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____capacity_5babi_v160004_5d_28_29_20const($0) << 3) | 0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____size_5babi_v160004_5d_28_29_20const($0) << 3) | 0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____capacity_5babi_v160004_5d_28_29_20const($0) << 3) | 0); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_float_20_28b2RevoluteJoint____29_28float_29_20const_2c_20float_2c_20b2RevoluteJoint_20const__2c_20float___invoke_28float_20_28b2RevoluteJoint____20const__29_28float_29_20const_2c_20b2RevoluteJoint_20const__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2RevoluteJoint_20const__2c_20void___fromWireType_28b2RevoluteJoint_20const__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $3, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]))), + HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0; + $2 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($3); + __stack_pointer = $3 + 16 | 0; + return Math_fround($2); +} + +function void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2QueryCallbackWrapper__29___invoke_b2QueryCallbackWrapper__28char_20const__2c_20void_20_28__29_28b2QueryCallbackWrapper__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 472; + $0 = emscripten__internal__TypeID_b2QueryCallbackWrapper_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2QueryCallbackWrapper____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2QueryCallbackWrapper____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28__emscripten__internal__getContext_void_20_28__29_28b2QueryCallbackWrapper__29__28void_20_28__20const__29_28b2QueryCallbackWrapper__29_29_29_28b2QueryCallbackWrapper__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_b2Fixture__20_28b2Body____29_28b2Shape_20const__2c_20float_29_2c_20b2Fixture__2c_20b2Body__2c_20b2Shape_20const__2c_20float___invoke_28b2Fixture__20_28b2Body____20const__29_28b2Shape_20const__2c_20float_29_2c_20b2Body__2c_20b2Shape_20const__2c_20float_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = Math_fround($3); + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAPF32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_b2Fixture__2c_20void___toWireType_28b2Fixture__29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2Shape_20const__2c_20void___fromWireType_28b2Shape_20const__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 >> 2])) | 0); + __stack_pointer = $4 + 16 | 0; + return $0 | 0; +} + +function std____2__reverse_iterator_int___20std____2____uninitialized_allocator_move_if_noexcept_5babi_v160004_5d_std____2__allocator_int__2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20int_2c_20void__28std____2__allocator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 24 >> 2] = $1; + HEAP32[$4 + 20 >> 2] = $2; + HEAP32[$4 + 16 >> 2] = $3; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = HEAP32[$4 + 24 >> 2]; + HEAP32[$4 + 4 >> 2] = HEAP32[$4 + 20 >> 2]; + HEAP32[$4 >> 2] = HEAP32[$4 + 16 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = std____2__reverse_iterator_int___20std____2__move_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29(HEAP32[$4 + 8 >> 2], HEAP32[$4 + 4 >> 2], HEAP32[$4 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + __stack_pointer = $4 + 32 | 0; + return HEAP32[$4 + 28 >> 2]; +} + +function b2DistanceJoint__b2DistanceJoint_28b2DistanceJointDef_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Joint__b2Joint_28b2JointDef_20const__29($1, HEAP32[$2 + 8 >> 2]); + HEAP32[$1 >> 2] = 18448; + b2Vec2__b2Vec2_28_29($1 + 80 | 0); + b2Vec2__b2Vec2_28_29($1 + 88 | 0); + b2Vec2__b2Vec2_28_29($1 + 116 | 0); + b2Vec2__b2Vec2_28_29($1 + 124 | 0); + b2Vec2__b2Vec2_28_29($1 + 132 | 0); + b2Vec2__b2Vec2_28_29($1 + 140 | 0); + b2Vec2__b2Vec2_28_29($1 + 148 | 0); + $3 = HEAP32[$2 + 8 >> 2]; + $4 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$1 + 80 >> 2] = $4; + HEAP32[$1 + 84 >> 2] = $0; + $3 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $4 = HEAP32[$3 + 32 >> 2]; + HEAP32[$1 + 88 >> 2] = $0; + HEAP32[$1 + 92 >> 2] = $4; + HEAPF32[$1 + 104 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 36 >> 2]; + HEAPF32[$1 + 68 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 40 >> 2]; + HEAPF32[$1 + 72 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 44 >> 2]; + HEAPF32[$1 + 100 >> 2] = 0; + HEAPF32[$1 + 96 >> 2] = 0; + HEAPF32[$1 + 76 >> 2] = 0; + __stack_pointer = $2 + 16 | 0; + return $1; +} + +function emscripten__internal__MethodInvoker_void_20_28b2World____29_28float_2c_20int_2c_20int_29_2c_20void_2c_20b2World__2c_20float_2c_20int_2c_20int___invoke_28void_20_28b2World____20const__29_28float_2c_20int_2c_20int_29_2c_20b2World__2c_20float_2c_20int_2c_20int_29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAPF32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + $3 = emscripten__internal__BindingType_b2World__2c_20void___fromWireType_28b2World__29(HEAP32[$5 + 24 >> 2]); + $0 = HEAP32[$5 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $3 = ($1 >> 1) + $3 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$3 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($3, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$5 + 20 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$5 + 16 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$5 + 12 >> 2])); + __stack_pointer = $5 + 32 | 0; +} + +function b2Simplex__GetSearchDirection_28_29_20const($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $1; + label$1: { + label$2: { + label$3: { + label$4: { + $1 = HEAP32[$2 + 28 >> 2]; + switch (HEAP32[$1 + 108 >> 2] - 1 | 0) { + case 1: + break label$3; + + case 0: + break label$4; + + default: + break label$2; + } + } + b2Vec2__operator__28_29_20const($0, $1 + 16 | 0); + break label$1; + } + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 20 | 0, $1 + 52 | 0, $1 + 16 | 0); + b2Vec2__operator__28_29_20const($2 + 8 | 0, $1 + 16 | 0); + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 20 | 0, $2 + 8 | 0), + HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0; + if (HEAPF32[$2 + 16 >> 2] > Math_fround(0)) { + b2Cross_28float_2c_20b2Vec2_20const__29($0, Math_fround(1), $2 + 20 | 0); + break label$1; + } + b2Cross_28b2Vec2_20const__2c_20float_29($0, $2 + 20 | 0, Math_fround(1)); + break label$1; + } + __assert_fail(9147, 6034, 195, 6546); + wasm2js_trap(); + } + __stack_pointer = $2 + 32 | 0; +} + +function b2Contact__GetWorldManifold_28b2WorldManifold__29_20const($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$0 + 48 >> 2]), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetBody_28_29(HEAP32[$0 + 52 >> 2]), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetShape_28_29(HEAP32[$0 + 48 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2Fixture__GetShape_28_29(HEAP32[$0 + 52 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + b2WorldManifold__Initialize_28b2Manifold_20const__2c_20b2Transform_20const__2c_20float_2c_20b2Transform_20const__2c_20float_29(HEAP32[$2 + 24 >> 2], $0 - -64 | 0, b2Body__GetTransform_28_29_20const(HEAP32[$2 + 20 >> 2]), HEAPF32[HEAP32[$2 + 12 >> 2] + 8 >> 2], b2Body__GetTransform_28_29_20const(HEAP32[$2 + 16 >> 2]), HEAPF32[HEAP32[$2 + 8 >> 2] + 8 >> 2]); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_float_20_28b2WheelJoint____29_28float_29_20const_2c_20float_2c_20b2WheelJoint_20const__2c_20float___invoke_28float_20_28b2WheelJoint____20const__29_28float_29_20const_2c_20b2WheelJoint_20const__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2WheelJoint_20const__2c_20void___fromWireType_28b2WheelJoint_20const__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $3, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]))), + HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0; + $2 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($3); + __stack_pointer = $3 + 16 | 0; + return Math_fround($2); +} + +function emscripten__internal__MethodInvoker_float_20_28b2RopeJoint____29_28float_29_20const_2c_20float_2c_20b2RopeJoint_20const__2c_20float___invoke_28float_20_28b2RopeJoint____20const__29_28float_29_20const_2c_20b2RopeJoint_20const__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2RopeJoint_20const__2c_20void___fromWireType_28b2RopeJoint_20const__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $3, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]))), + HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0; + $2 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($3); + __stack_pointer = $3 + 16 | 0; + return Math_fround($2); +} + +function std____2____unwrap_range_impl_char_20const__2c_20char_20const______unwrap_5babi_v160004_5d_28char_20const__2c_20char_20const__29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + wasm2js_i32$0 = $3, wasm2js_i32$1 = decltype_28std____2____unwrap_iter_impl_char_20const__2c_20true_____unwrap_28std__declval_char_20const___28_29_29_29_20std____2____unwrap_iter_5babi_v160004_5d_char_20const__2c_20std____2____unwrap_iter_impl_char_20const__2c_20true__2c_200__28char_20const__29($1), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = decltype_28std____2____unwrap_iter_impl_char_20const__2c_20true_____unwrap_28std__declval_char_20const___28_29_29_29_20std____2____unwrap_iter_5babi_v160004_5d_char_20const__2c_20std____2____unwrap_iter_impl_char_20const__2c_20true__2c_200__28char_20const__29($2), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + std____2__pair_char_20const__2c_20char_20const____pair_5babi_v160004_5d_char_20const__2c_20char_20const__2c_20_28void__290__28char_20const____2c_20char_20const____29($0, $3 + 12 | 0, $3 + 8 | 0); + __stack_pointer = $3 + 16 | 0; +} + +function std____2__reverse_iterator_b2Vec2___20std____2__move_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 48 | 0; + __stack_pointer = $3; + HEAP32[$3 + 40 >> 2] = $0; + HEAP32[$3 + 36 >> 2] = $1; + HEAP32[$3 + 32 >> 2] = $2; + HEAP32[$3 + 20 >> 2] = HEAP32[$3 + 40 >> 2]; + HEAP32[$3 + 16 >> 2] = HEAP32[$3 + 36 >> 2]; + HEAP32[$3 + 12 >> 2] = HEAP32[$3 + 32 >> 2]; + std____2__pair_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____20std____2____move_5babi_v160004_5d_std____2___ClassicAlgPolicy_2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($3 + 24 | 0, HEAP32[$3 + 20 >> 2], HEAP32[$3 + 16 >> 2], HEAP32[$3 + 12 >> 2]); + HEAP32[$3 + 44 >> 2] = HEAP32[($3 + 24 | 0) + 4 >> 2]; + __stack_pointer = $3 + 48 | 0; + return HEAP32[$3 + 44 >> 2]; +} + +function b2WeldJoint__b2WeldJoint_28b2WeldJointDef_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Joint__b2Joint_28b2JointDef_20const__29($1, HEAP32[$2 + 8 >> 2]); + HEAP32[$1 >> 2] = 19528; + b2Vec2__b2Vec2_28_29($1 + 80 | 0); + b2Vec2__b2Vec2_28_29($1 + 88 | 0); + b2Vec3__b2Vec3_28_29($1 + 104 | 0); + b2Vec2__b2Vec2_28_29($1 + 124 | 0); + b2Vec2__b2Vec2_28_29($1 + 132 | 0); + b2Vec2__b2Vec2_28_29($1 + 140 | 0); + b2Vec2__b2Vec2_28_29($1 + 148 | 0); + b2Mat33__b2Mat33_28_29($1 + 172 | 0); + $3 = HEAP32[$2 + 8 >> 2]; + $4 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$1 + 80 >> 2] = $4; + HEAP32[$1 + 84 >> 2] = $0; + $3 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $4 = HEAP32[$3 + 32 >> 2]; + HEAP32[$1 + 88 >> 2] = $0; + HEAP32[$1 + 92 >> 2] = $4; + HEAPF32[$1 + 96 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 36 >> 2]; + HEAPF32[$1 + 68 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 40 >> 2]; + HEAPF32[$1 + 72 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 44 >> 2]; + b2Vec3__SetZero_28_29($1 + 104 | 0); + __stack_pointer = $2 + 16 | 0; + return $1; +} + +function void_20emscripten__internal__RegisterClassMethod_float_20_28__29_28b2Shape__29___invoke_b2Shape_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20float_20_28__29_28b2Shape__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 527; + $0 = emscripten__internal__TypeID_b2Shape_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_float_2c_20b2Shape____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_float_2c_20b2Shape____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], float_20_28__emscripten__internal__getContext_float_20_28__29_28b2Shape__29__28float_20_28__20const__29_28b2Shape__29_29_29_28b2Shape__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______annotate_new_5babi_v160004_5d_28unsigned_20long_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______annotate_contiguous_container_5babi_v160004_5d_28void_20const__2c_20void_20const__2c_20void_20const__2c_20void_20const__29_20const($0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29_20const($0), std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____capacity_5babi_v160004_5d_28_29_20const($0) << 3) | 0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____capacity_5babi_v160004_5d_28_29_20const($0) << 3) | 0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29_20const($0) + (HEAP32[$2 + 8 >> 2] << 3) | 0); + __stack_pointer = $2 + 16 | 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______annotate_shrink_5babi_v160004_5d_28unsigned_20long_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______annotate_contiguous_container_5babi_v160004_5d_28void_20const__2c_20void_20const__2c_20void_20const__2c_20void_20const__29_20const($0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29_20const($0), std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____capacity_5babi_v160004_5d_28_29_20const($0) << 3) | 0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29_20const($0) + (HEAP32[$2 + 8 >> 2] << 3) | 0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____size_5babi_v160004_5d_28_29_20const($0) << 3) | 0); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2ContactListener____29_28unsigned_20int_2c_20unsigned_20int_29_2c_20void_2c_20b2ContactListener__2c_20unsigned_20int_2c_20unsigned_20int___invoke_28void_20_28b2ContactListener____20const__29_28unsigned_20int_2c_20unsigned_20int_29_2c_20b2ContactListener__2c_20unsigned_20int_2c_20unsigned_20int_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_b2ContactListener__2c_20void___fromWireType_28b2ContactListener__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$4 + 4 >> 2]), emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function void_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______construct_one_at_end_5babi_v160004_5d_b2Vec2_20const___28b2Vec2_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____ConstructTransaction___ConstructTransaction_5babi_v160004_5d_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_29($2 + 12 | 0, $0, 1); + void_20std____2__allocator_traits_std____2__allocator_b2Vec2____construct_5babi_v160004_5d_b2Vec2_2c_20b2Vec2_20const__2c_20void__28std____2__allocator_b2Vec2___2c_20b2Vec2__2c_20b2Vec2_20const__29(std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______alloc_5babi_v160004_5d_28_29($0), b2Vec2__20std____2____to_address_5babi_v160004_5d_b2Vec2__28b2Vec2__29(HEAP32[$2 + 16 >> 2]), HEAP32[$2 + 24 >> 2]); + HEAP32[$2 + 16 >> 2] = HEAP32[$2 + 16 >> 2] + 8; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____ConstructTransaction____ConstructTransaction_5babi_v160004_5d_28_29($2 + 12 | 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2ContactListenerWrapper__isIndexOf_28unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + HEAP32[$2 + 20 >> 2] = HEAP32[$2 + 24 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__set_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____find_5babi_v160004_5d_28b2Fixture__20const__29($0 + 12 | 0, $2 + 20 | 0), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__set_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____end_5babi_v160004_5d_28_29($0 + 12 | 0), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + $0 = std____2__operator___5babi_v160004_5d_28std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__2c_20std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__29($2 + 16 | 0, $2 + 12 | 0); + __stack_pointer = $2 + 32 | 0; + return $0 & 1; +} + +function emscripten__internal__MethodCaller_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const____call_28emscripten___EM_VAL__2c_20char_20const__2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const__29($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 48 | 0; + __stack_pointer = $5; + HEAP32[$5 + 44 >> 2] = $0; + HEAP32[$5 + 40 >> 2] = $1; + HEAP32[$5 + 36 >> 2] = $2; + HEAP32[$5 + 32 >> 2] = $3; + HEAP32[$5 + 28 >> 2] = $4; + wasm2js_i32$0 = $5, wasm2js_i32$1 = emscripten__internal__Signature_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const____get_method_caller_28_29(), + HEAP32[wasm2js_i32$0 + 24 >> 2] = wasm2js_i32$1; + emscripten__internal__WireTypePack_b2Vec2_20const__2c_20float__2c_20b2Color_20const____WireTypePack_28b2Vec2_20const__2c_20float__2c_20b2Color_20const__29($5, HEAP32[$5 + 36 >> 2], HEAP32[$5 + 32 >> 2], HEAP32[$5 + 28 >> 2]); + _emval_call_void_method(HEAP32[$5 + 24 >> 2], HEAP32[$5 + 44 >> 2], HEAP32[$5 + 40 >> 2], emscripten__internal__WireTypePack_b2Vec2_20const__2c_20float__2c_20b2Color_20const____operator_20void_20const__28_29_20const($5) | 0); + __stack_pointer = $5 + 48 | 0; +} + +function emscripten__internal__MethodInvoker_float_20_28b2Joint____29_28float_29_20const_2c_20float_2c_20b2Joint_20const__2c_20float___invoke_28float_20_28b2Joint____20const__29_28float_29_20const_2c_20b2Joint_20const__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2Joint_20const__2c_20void___fromWireType_28b2Joint_20const__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $3, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]))), + HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0; + $2 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($3); + __stack_pointer = $3 + 16 | 0; + return Math_fround($2); +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______destroy_vector__operator_28_29_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______annotate_delete_5babi_v160004_5d_28_29_20const(HEAP32[$0 >> 2]); + void_20std____2____debug_db_erase_c_5babi_v160004_5d_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29(HEAP32[$0 >> 2]); + if (HEAP32[HEAP32[$0 >> 2] >> 2]) { + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______clear_5babi_v160004_5d_28_29(HEAP32[$0 >> 2]); + std____2__allocator_traits_std____2__allocator_b2Vec2____deallocate_5babi_v160004_5d_28std____2__allocator_b2Vec2___2c_20b2Vec2__2c_20unsigned_20long_29(std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______alloc_5babi_v160004_5d_28_29(HEAP32[$0 >> 2]), HEAP32[HEAP32[$0 >> 2] >> 2], std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____capacity_5babi_v160004_5d_28_29_20const(HEAP32[$0 >> 2])); + } + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28b2Vec2_20const__29_2c_20void_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20b2Vec2_20const____invoke_28void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______20const__29_28b2Vec2_20const__29_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20void___fromWireType_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____20_28__29_28_29___invoke_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 702; + $0 = emscripten__internal__TypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______annotate_delete_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2__vector_int_2c_20std____2__allocator_int______annotate_contiguous_container_5babi_v160004_5d_28void_20const__2c_20void_20const__2c_20void_20const__2c_20void_20const__29_20const($0, std____2__vector_int_2c_20std____2__allocator_int____data_5babi_v160004_5d_28_29_20const($0), std____2__vector_int_2c_20std____2__allocator_int____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_int_2c_20std____2__allocator_int____capacity_5babi_v160004_5d_28_29_20const($0) << 2) | 0, std____2__vector_int_2c_20std____2__allocator_int____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_int_2c_20std____2__allocator_int____size_5babi_v160004_5d_28_29_20const($0) << 2) | 0, std____2__vector_int_2c_20std____2__allocator_int____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_int_2c_20std____2__allocator_int____capacity_5babi_v160004_5d_28_29_20const($0) << 2) | 0); + __stack_pointer = $1 + 16 | 0; +} + +function b2PolygonShape__SetAsBox_28float_2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = Math_fround($1); + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAPF32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + HEAP32[$0 + 148 >> 2] = 4; + b2Vec2__Set_28float_2c_20float_29($0 + 20 | 0, Math_fround(-HEAPF32[$3 + 8 >> 2]), Math_fround(-HEAPF32[$3 + 4 >> 2])); + b2Vec2__Set_28float_2c_20float_29($0 + 28 | 0, HEAPF32[$3 + 8 >> 2], Math_fround(-HEAPF32[$3 + 4 >> 2])); + b2Vec2__Set_28float_2c_20float_29($0 + 36 | 0, HEAPF32[$3 + 8 >> 2], HEAPF32[$3 + 4 >> 2]); + b2Vec2__Set_28float_2c_20float_29($0 + 44 | 0, Math_fround(-HEAPF32[$3 + 8 >> 2]), HEAPF32[$3 + 4 >> 2]); + b2Vec2__Set_28float_2c_20float_29($0 + 84 | 0, Math_fround(0), Math_fround(-1)); + b2Vec2__Set_28float_2c_20float_29($0 + 92 | 0, Math_fround(1), Math_fround(0)); + b2Vec2__Set_28float_2c_20float_29($0 + 100 | 0, Math_fround(0), Math_fround(1)); + b2Vec2__Set_28float_2c_20float_29($0 + 108 | 0, Math_fround(-1), Math_fround(0)); + b2Vec2__SetZero_28_29($0 + 12 | 0); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2QueryCallback__2c_20b2AABB_20const__29_20const_2c_20void_2c_20b2World_20const__2c_20b2QueryCallback__2c_20b2AABB_20const____invoke_28void_20_28b2World____20const__29_28b2QueryCallback__2c_20b2AABB_20const__29_20const_2c_20b2World_20const__2c_20b2QueryCallback__2c_20b2AABB__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_b2World_20const__2c_20void___fromWireType_28b2World_20const__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2QueryCallback__2c_20void___fromWireType_28b2QueryCallback__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__GenericBindingType_b2AABB___fromWireType_28b2AABB__29(HEAP32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function emscripten__internal__MethodCaller_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const____call_28emscripten___EM_VAL__2c_20char_20const__2c_20unsigned_20int__2c_20int__2c_20b2Color_20const__29($0, $1, $2, $3, $4) { + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 48 | 0; + __stack_pointer = $5; + HEAP32[$5 + 44 >> 2] = $0; + HEAP32[$5 + 40 >> 2] = $1; + HEAP32[$5 + 36 >> 2] = $2; + HEAP32[$5 + 32 >> 2] = $3; + HEAP32[$5 + 28 >> 2] = $4; + wasm2js_i32$0 = $5, wasm2js_i32$1 = emscripten__internal__Signature_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const____get_method_caller_28_29(), + HEAP32[wasm2js_i32$0 + 24 >> 2] = wasm2js_i32$1; + emscripten__internal__WireTypePack_unsigned_20int__2c_20int__2c_20b2Color_20const____WireTypePack_28unsigned_20int__2c_20int__2c_20b2Color_20const__29($5, HEAP32[$5 + 36 >> 2], HEAP32[$5 + 32 >> 2], HEAP32[$5 + 28 >> 2]); + _emval_call_void_method(HEAP32[$5 + 24 >> 2], HEAP32[$5 + 44 >> 2], HEAP32[$5 + 40 >> 2], emscripten__internal__WireTypePack_unsigned_20int__2c_20int__2c_20b2Color_20const____operator_20void_20const__28_29_20const($5) | 0); + __stack_pointer = $5 + 48 | 0; +} + +function b2FrictionJoint__b2FrictionJoint_28b2FrictionJointDef_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Joint__b2Joint_28b2JointDef_20const__29($1, HEAP32[$2 + 8 >> 2]); + HEAP32[$1 >> 2] = 18740; + b2Vec2__b2Vec2_28_29($1 + 68 | 0); + b2Vec2__b2Vec2_28_29($1 + 76 | 0); + b2Vec2__b2Vec2_28_29($1 + 84 | 0); + b2Vec2__b2Vec2_28_29($1 + 112 | 0); + b2Vec2__b2Vec2_28_29($1 + 120 | 0); + b2Vec2__b2Vec2_28_29($1 + 128 | 0); + b2Vec2__b2Vec2_28_29($1 + 136 | 0); + b2Mat22__b2Mat22_28_29($1 + 160 | 0); + $3 = HEAP32[$2 + 8 >> 2]; + $4 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$1 + 68 >> 2] = $4; + HEAP32[$1 + 72 >> 2] = $0; + $3 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $4 = HEAP32[$3 + 32 >> 2]; + HEAP32[$1 + 76 >> 2] = $0; + HEAP32[$1 + 80 >> 2] = $4; + b2Vec2__SetZero_28_29($1 + 84 | 0); + HEAPF32[$1 + 92 >> 2] = 0; + HEAPF32[$1 + 96 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 36 >> 2]; + HEAPF32[$1 + 100 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 40 >> 2]; + __stack_pointer = $2 + 16 | 0; + return $1; +} + +function emscripten__internal__MethodInvoker_void_20_28b2PolygonShape____29_28b2MassData__2c_20float_29_20const_2c_20void_2c_20b2PolygonShape_20const__2c_20b2MassData__2c_20float___invoke_28void_20_28b2PolygonShape____20const__29_28b2MassData__2c_20float_29_20const_2c_20b2PolygonShape_20const__2c_20b2MassData__2c_20float_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = Math_fround($3); + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAPF32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_b2PolygonShape_20const__2c_20void___fromWireType_28b2PolygonShape_20const__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2MassData__2c_20void___fromWireType_28b2MassData__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______operator_28_29_5babi_v160004_5d_28std____2____tree_node_b2Fixture__2c_20void____29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAP8[$0 + 4 | 0] & 1) { + void_20std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______destroy_5babi_v160004_5d_b2Fixture__2c_20void_2c_20void__28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20b2Fixture___29(HEAP32[$0 >> 2], std____2____tree_key_value_types_b2Fixture______get_ptr_5babi_v160004_5d_28b2Fixture___29(HEAP32[$2 + 8 >> 2] + 16 | 0)); + } + if (HEAP32[$2 + 8 >> 2]) { + std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______deallocate_5babi_v160004_5d_28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20unsigned_20long_29(HEAP32[$0 >> 2], HEAP32[$2 + 8 >> 2], 1); + } + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2CircleShape____29_28b2MassData__2c_20float_29_20const_2c_20void_2c_20b2CircleShape_20const__2c_20b2MassData__2c_20float___invoke_28void_20_28b2CircleShape____20const__29_28b2MassData__2c_20float_29_20const_2c_20b2CircleShape_20const__2c_20b2MassData__2c_20float_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = Math_fround($3); + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAPF32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_b2CircleShape_20const__2c_20void___fromWireType_28b2CircleShape_20const__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2MassData__2c_20void___fromWireType_28b2MassData__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function std____2__reverse_iterator_int___20std____2__move_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 48 | 0; + __stack_pointer = $3; + HEAP32[$3 + 40 >> 2] = $0; + HEAP32[$3 + 36 >> 2] = $1; + HEAP32[$3 + 32 >> 2] = $2; + HEAP32[$3 + 20 >> 2] = HEAP32[$3 + 40 >> 2]; + HEAP32[$3 + 16 >> 2] = HEAP32[$3 + 36 >> 2]; + HEAP32[$3 + 12 >> 2] = HEAP32[$3 + 32 >> 2]; + std____2__pair_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____20std____2____move_5babi_v160004_5d_std____2___ClassicAlgPolicy_2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($3 + 24 | 0, HEAP32[$3 + 20 >> 2], HEAP32[$3 + 16 >> 2], HEAP32[$3 + 12 >> 2]); + HEAP32[$3 + 44 >> 2] = HEAP32[($3 + 24 | 0) + 4 >> 2]; + __stack_pointer = $3 + 48 | 0; + return HEAP32[$3 + 44 >> 2]; +} + +function b2Mat33__Solve22_28b2Vec2_20const__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $1; + HEAP32[$3 + 24 >> 2] = $2; + $1 = HEAP32[$3 + 28 >> 2]; + HEAPF32[$3 + 20 >> 2] = HEAPF32[$1 >> 2]; + HEAPF32[$3 + 16 >> 2] = HEAPF32[$1 + 12 >> 2]; + HEAPF32[$3 + 12 >> 2] = HEAPF32[$1 + 4 >> 2]; + HEAPF32[$3 + 8 >> 2] = HEAPF32[$1 + 16 >> 2]; + HEAPF32[$3 + 4 >> 2] = Math_fround(HEAPF32[$3 + 20 >> 2] * HEAPF32[$3 + 8 >> 2]) - Math_fround(HEAPF32[$3 + 16 >> 2] * HEAPF32[$3 + 12 >> 2]); + if (HEAPF32[$3 + 4 >> 2] != Math_fround(0)) { + HEAPF32[$3 + 4 >> 2] = Math_fround(1) / HEAPF32[$3 + 4 >> 2]; + } + b2Vec2__b2Vec2_28_29($0); + HEAPF32[$0 >> 2] = HEAPF32[$3 + 4 >> 2] * Math_fround(Math_fround(HEAPF32[$3 + 8 >> 2] * HEAPF32[HEAP32[$3 + 24 >> 2] >> 2]) - Math_fround(HEAPF32[$3 + 16 >> 2] * HEAPF32[HEAP32[$3 + 24 >> 2] + 4 >> 2])); + HEAPF32[$0 + 4 >> 2] = HEAPF32[$3 + 4 >> 2] * Math_fround(Math_fround(HEAPF32[$3 + 20 >> 2] * HEAPF32[HEAP32[$3 + 24 >> 2] + 4 >> 2]) - Math_fround(HEAPF32[$3 + 12 >> 2] * HEAPF32[HEAP32[$3 + 24 >> 2] >> 2])); + __stack_pointer = $3 + 32 | 0; +} + +function b2Mat22__Solve_28b2Vec2_20const__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $1; + HEAP32[$3 + 24 >> 2] = $2; + $1 = HEAP32[$3 + 28 >> 2]; + HEAPF32[$3 + 20 >> 2] = HEAPF32[$1 >> 2]; + HEAPF32[$3 + 16 >> 2] = HEAPF32[$1 + 8 >> 2]; + HEAPF32[$3 + 12 >> 2] = HEAPF32[$1 + 4 >> 2]; + HEAPF32[$3 + 8 >> 2] = HEAPF32[$1 + 12 >> 2]; + HEAPF32[$3 + 4 >> 2] = Math_fround(HEAPF32[$3 + 20 >> 2] * HEAPF32[$3 + 8 >> 2]) - Math_fround(HEAPF32[$3 + 16 >> 2] * HEAPF32[$3 + 12 >> 2]); + if (HEAPF32[$3 + 4 >> 2] != Math_fround(0)) { + HEAPF32[$3 + 4 >> 2] = Math_fround(1) / HEAPF32[$3 + 4 >> 2]; + } + b2Vec2__b2Vec2_28_29($0); + HEAPF32[$0 >> 2] = HEAPF32[$3 + 4 >> 2] * Math_fround(Math_fround(HEAPF32[$3 + 8 >> 2] * HEAPF32[HEAP32[$3 + 24 >> 2] >> 2]) - Math_fround(HEAPF32[$3 + 16 >> 2] * HEAPF32[HEAP32[$3 + 24 >> 2] + 4 >> 2])); + HEAPF32[$0 + 4 >> 2] = HEAPF32[$3 + 4 >> 2] * Math_fround(Math_fround(HEAPF32[$3 + 20 >> 2] * HEAPF32[HEAP32[$3 + 24 >> 2] + 4 >> 2]) - Math_fround(HEAPF32[$3 + 12 >> 2] * HEAPF32[HEAP32[$3 + 24 >> 2] >> 2])); + __stack_pointer = $3 + 32 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______annotate_shrink_5babi_v160004_5d_28unsigned_20long_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + std____2__vector_int_2c_20std____2__allocator_int______annotate_contiguous_container_5babi_v160004_5d_28void_20const__2c_20void_20const__2c_20void_20const__2c_20void_20const__29_20const($0, std____2__vector_int_2c_20std____2__allocator_int____data_5babi_v160004_5d_28_29_20const($0), std____2__vector_int_2c_20std____2__allocator_int____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_int_2c_20std____2__allocator_int____capacity_5babi_v160004_5d_28_29_20const($0) << 2) | 0, std____2__vector_int_2c_20std____2__allocator_int____data_5babi_v160004_5d_28_29_20const($0) + (HEAP32[$2 + 8 >> 2] << 2) | 0, std____2__vector_int_2c_20std____2__allocator_int____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_int_2c_20std____2__allocator_int____size_5babi_v160004_5d_28_29_20const($0) << 2) | 0); + __stack_pointer = $2 + 16 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______annotate_new_5babi_v160004_5d_28unsigned_20long_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + std____2__vector_int_2c_20std____2__allocator_int______annotate_contiguous_container_5babi_v160004_5d_28void_20const__2c_20void_20const__2c_20void_20const__2c_20void_20const__29_20const($0, std____2__vector_int_2c_20std____2__allocator_int____data_5babi_v160004_5d_28_29_20const($0), std____2__vector_int_2c_20std____2__allocator_int____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_int_2c_20std____2__allocator_int____capacity_5babi_v160004_5d_28_29_20const($0) << 2) | 0, std____2__vector_int_2c_20std____2__allocator_int____data_5babi_v160004_5d_28_29_20const($0) + (std____2__vector_int_2c_20std____2__allocator_int____capacity_5babi_v160004_5d_28_29_20const($0) << 2) | 0, std____2__vector_int_2c_20std____2__allocator_int____data_5babi_v160004_5d_28_29_20const($0) + (HEAP32[$2 + 8 >> 2] << 2) | 0); + __stack_pointer = $2 + 16 | 0; +} +function void_20emscripten__internal__RegisterClassMethod_void_20_28__29_28b2DrawWrapper__29___invoke_b2DrawWrapper__28char_20const__2c_20void_20_28__29_28b2DrawWrapper__29_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 496; + $0 = emscripten__internal__TypeID_b2DrawWrapper_2c_20void___get_28_29(); + $1 = HEAP32[$2 + 24 >> 2]; + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2DrawWrapper____getCount_28_29_20const($2 + 19 | 0); + $4 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2DrawWrapper____getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_class_function($0 | 0, $1 | 0, $3 | 0, $4 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], void_20_28__emscripten__internal__getContext_void_20_28__29_28b2DrawWrapper__29__28void_20_28__20const__29_28b2DrawWrapper__29_29_29_28b2DrawWrapper__29($2 + 20 | 0) | 0, 0, 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2EdgeShape____29_28b2MassData__2c_20float_29_20const_2c_20void_2c_20b2EdgeShape_20const__2c_20b2MassData__2c_20float___invoke_28void_20_28b2EdgeShape____20const__29_28b2MassData__2c_20float_29_20const_2c_20b2EdgeShape_20const__2c_20b2MassData__2c_20float_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = Math_fround($3); + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAPF32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_b2EdgeShape_20const__2c_20void___fromWireType_28b2EdgeShape_20const__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2MassData__2c_20void___fromWireType_28b2MassData__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_std____2__vector_int_2c_20std____2__allocator_int____20_28__29_28_29___invoke_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int____20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 696; + $0 = emscripten__internal__TypeID_std____2__vector_int_2c_20std____2__allocator_int___2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_std____2__vector_int_2c_20std____2__allocator_int______getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_std____2__vector_int_2c_20std____2__allocator_int______getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function b2MotorJoint__b2MotorJoint_28b2MotorJointDef_20const__29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + b2Joint__b2Joint_28b2JointDef_20const__29($0, HEAP32[$2 + 8 >> 2]); + HEAP32[$0 >> 2] = 18904; + b2Vec2__b2Vec2_28_29($0 + 68 | 0); + b2Vec2__b2Vec2_28_29($0 + 80 | 0); + b2Vec2__b2Vec2_28_29($0 + 112 | 0); + b2Vec2__b2Vec2_28_29($0 + 120 | 0); + b2Vec2__b2Vec2_28_29($0 + 128 | 0); + b2Vec2__b2Vec2_28_29($0 + 136 | 0); + b2Vec2__b2Vec2_28_29($0 + 144 | 0); + b2Mat22__b2Mat22_28_29($0 + 172 | 0); + $1 = HEAP32[$2 + 8 >> 2]; + $3 = HEAP32[$1 + 24 >> 2]; + HEAP32[$0 + 68 >> 2] = HEAP32[$1 + 20 >> 2]; + HEAP32[$0 + 72 >> 2] = $3; + HEAPF32[$0 + 76 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 28 >> 2]; + b2Vec2__SetZero_28_29($0 + 80 | 0); + HEAPF32[$0 + 88 >> 2] = 0; + HEAPF32[$0 + 92 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 32 >> 2]; + HEAPF32[$0 + 96 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 36 >> 2]; + HEAPF32[$0 + 100 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 40 >> 2]; + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function b2Sweep__GetTransform_28b2Transform__2c_20float_29_20const($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0; + $3 = __stack_pointer - 48 | 0; + __stack_pointer = $3; + HEAP32[$3 + 44 >> 2] = $0; + HEAP32[$3 + 40 >> 2] = $1; + HEAPF32[$3 + 36 >> 2] = $2; + $2 = HEAPF32[$3 + 36 >> 2]; + $4 = HEAP32[$3 + 44 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 12 | 0, $4 + 16 | 0, $4 + 8 | 0); + operator__28float_2c_20b2Vec2_20const__29($3 + 20 | 0, $2, $3 + 12 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 28 | 0, $4 + 8 | 0, $3 + 20 | 0); + $5 = HEAP32[$3 + 32 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 40 >> 2]; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $5; + HEAPF32[$3 + 8 >> 2] = Math_fround(HEAPF32[$3 + 36 >> 2] * Math_fround(HEAPF32[$4 + 28 >> 2] - HEAPF32[$4 + 24 >> 2])) + HEAPF32[$4 + 24 >> 2]; + b2Rot__Set_28float_29(HEAP32[$3 + 40 >> 2] + 8 | 0, HEAPF32[$3 + 8 >> 2]); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($3, HEAP32[$3 + 40 >> 2] + 8 | 0, $4); + b2Vec2__operator___28b2Vec2_20const__29_1(HEAP32[$3 + 40 >> 2], $3); + __stack_pointer = $3 + 48 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______destroy_vector__operator_28_29_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2__vector_int_2c_20std____2__allocator_int______annotate_delete_5babi_v160004_5d_28_29_20const(HEAP32[$0 >> 2]); + void_20std____2____debug_db_erase_c_5babi_v160004_5d_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int____29(HEAP32[$0 >> 2]); + if (HEAP32[HEAP32[$0 >> 2] >> 2]) { + std____2__vector_int_2c_20std____2__allocator_int______clear_5babi_v160004_5d_28_29(HEAP32[$0 >> 2]); + std____2__allocator_traits_std____2__allocator_int____deallocate_5babi_v160004_5d_28std____2__allocator_int___2c_20int__2c_20unsigned_20long_29(std____2__vector_int_2c_20std____2__allocator_int______alloc_5babi_v160004_5d_28_29(HEAP32[$0 >> 2]), HEAP32[HEAP32[$0 >> 2] >> 2], std____2__vector_int_2c_20std____2__allocator_int____capacity_5babi_v160004_5d_28_29_20const(HEAP32[$0 >> 2])); + } + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_b2Shape__20_28b2PolygonShape____29_28b2BlockAllocator__29_20const_2c_20b2Shape__2c_20b2PolygonShape_20const__2c_20b2BlockAllocator____invoke_28b2Shape__20_28b2PolygonShape____20const__29_28b2BlockAllocator__29_20const_2c_20b2PolygonShape_20const__2c_20b2BlockAllocator__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2PolygonShape_20const__2c_20void___fromWireType_28b2PolygonShape_20const__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_b2Shape__2c_20void___toWireType_28b2Shape__29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2BlockAllocator__2c_20void___fromWireType_28b2BlockAllocator__29(HEAP32[$3 + 4 >> 2])) | 0); + __stack_pointer = $3 + 16 | 0; + return $0 | 0; +} + +function void_20std____2__vector_int_2c_20std____2__allocator_int______construct_one_at_end_5babi_v160004_5d_int_20const___28int_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + std____2__vector_int_2c_20std____2__allocator_int_____ConstructTransaction___ConstructTransaction_5babi_v160004_5d_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_29($2 + 12 | 0, $0, 1); + void_20std____2__allocator_traits_std____2__allocator_int____construct_5babi_v160004_5d_int_2c_20int_20const__2c_20void__28std____2__allocator_int___2c_20int__2c_20int_20const__29(std____2__vector_int_2c_20std____2__allocator_int______alloc_5babi_v160004_5d_28_29($0), int__20std____2____to_address_5babi_v160004_5d_int__28int__29(HEAP32[$2 + 16 >> 2]), HEAP32[$2 + 24 >> 2]); + HEAP32[$2 + 16 >> 2] = HEAP32[$2 + 16 >> 2] + 4; + std____2__vector_int_2c_20std____2__allocator_int_____ConstructTransaction____ConstructTransaction_5babi_v160004_5d_28_29($2 + 12 | 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Shape____29_28b2MassData__2c_20float_29_20const_2c_20void_2c_20b2Shape_20const__2c_20b2MassData__2c_20float___invoke_28void_20_28b2Shape____20const__29_28b2MassData__2c_20float_29_20const_2c_20b2Shape_20const__2c_20b2MassData__2c_20float_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = Math_fround($3); + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAPF32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_b2Shape_20const__2c_20void___fromWireType_28b2Shape_20const__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2MassData__2c_20void___fromWireType_28b2MassData__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_b2Shape__20_28b2CircleShape____29_28b2BlockAllocator__29_20const_2c_20b2Shape__2c_20b2CircleShape_20const__2c_20b2BlockAllocator____invoke_28b2Shape__20_28b2CircleShape____20const__29_28b2BlockAllocator__29_20const_2c_20b2CircleShape_20const__2c_20b2BlockAllocator__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2CircleShape_20const__2c_20void___fromWireType_28b2CircleShape_20const__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_b2Shape__2c_20void___toWireType_28b2Shape__29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2BlockAllocator__2c_20void___fromWireType_28b2BlockAllocator__29(HEAP32[$3 + 4 >> 2])) | 0); + __stack_pointer = $3 + 16 | 0; + return $0 | 0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char_____basic_string_28_29($0) { + void_20std____2____debug_db_erase_c_5babi_v160004_5d_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____29($0); + if (std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______is_long_5babi_v160004_5d_28_29_20const($0)) { + std____2__allocator_traits_std____2__allocator_char____deallocate_5babi_v160004_5d_28std____2__allocator_char___2c_20char__2c_20unsigned_20long_29(std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______alloc_5babi_v160004_5d_28_29($0), std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______get_long_pointer_5babi_v160004_5d_28_29($0), std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______get_long_cap_5babi_v160004_5d_28_29_20const($0)); + } + return $0; +} + +function __cxxabiv1____vmi_class_type_info__has_unambiguous_public_base_28__cxxabiv1____dynamic_cast_info__2c_20void__2c_20int_29_20const($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0, $5 = 0; + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, HEAP32[$1 + 8 >> 2], 0)) { + __cxxabiv1____class_type_info__process_found_base_class_28__cxxabiv1____dynamic_cast_info__2c_20void__2c_20int_29_20const($0, $1, $2, $3); + return; + } + $4 = HEAP32[$0 + 12 >> 2]; + $5 = $0 + 16 | 0; + __cxxabiv1____base_class_type_info__has_unambiguous_public_base_28__cxxabiv1____dynamic_cast_info__2c_20void__2c_20int_29_20const($5, $1, $2, $3); + $0 = $0 + 24 | 0; + $4 = ($4 << 3) + $5 | 0; + label$2: { + if ($0 >>> 0 >= $4 >>> 0) { + break label$2; + } + while (1) { + __cxxabiv1____base_class_type_info__has_unambiguous_public_base_28__cxxabiv1____dynamic_cast_info__2c_20void__2c_20int_29_20const($0, $1, $2, $3); + if (HEAPU8[$1 + 54 | 0]) { + break label$2; + } + $0 = $0 + 8 | 0; + if ($4 >>> 0 > $0 >>> 0) { + continue; + } + break; + } + } +} + +function b2Joint__b2Joint_28b2JointDef_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 4 >> 2] = $1; + $0 = HEAP32[$2 + 8 >> 2]; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$0 >> 2] = 18828; + if (HEAP32[HEAP32[$2 + 4 >> 2] + 8 >> 2] == HEAP32[HEAP32[$2 + 4 >> 2] + 12 >> 2]) { + __assert_fail(10961, 4569, 239, 2778); + wasm2js_trap(); + } + HEAP32[$0 + 4 >> 2] = HEAP32[HEAP32[$2 + 4 >> 2] >> 2]; + HEAP32[$0 + 8 >> 2] = 0; + HEAP32[$0 + 12 >> 2] = 0; + HEAP32[$0 + 48 >> 2] = HEAP32[HEAP32[$2 + 4 >> 2] + 8 >> 2]; + HEAP32[$0 + 52 >> 2] = HEAP32[HEAP32[$2 + 4 >> 2] + 12 >> 2]; + HEAP32[$0 + 56 >> 2] = 0; + HEAP8[$0 + 61 | 0] = HEAP8[HEAP32[$2 + 4 >> 2] + 16 | 0] & 1; + HEAP8[$0 + 60 | 0] = 0; + HEAP32[$0 + 64 >> 2] = HEAP32[HEAP32[$2 + 4 >> 2] + 4 >> 2]; + HEAP32[$0 + 20 >> 2] = 0; + HEAP32[$0 + 16 >> 2] = 0; + HEAP32[$0 + 24 >> 2] = 0; + HEAP32[$0 + 28 >> 2] = 0; + HEAP32[$0 + 36 >> 2] = 0; + HEAP32[$0 + 32 >> 2] = 0; + HEAP32[$0 + 40 >> 2] = 0; + HEAP32[$0 + 44 >> 2] = 0; + __stack_pointer = $2 + 16 | 0; + return HEAP32[$2 + 12 >> 2]; +} + +function b2DistanceProxy__GetSupport_28b2Vec2_20const__29_20const($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + HEAP32[$2 + 20 >> 2] = 0; + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$0 + 16 >> 2], HEAP32[$2 + 24 >> 2]), + HEAPF32[wasm2js_i32$0 + 16 >> 2] = wasm2js_f32$0; + HEAP32[$2 + 12 >> 2] = 1; + while (1) { + if (HEAP32[$2 + 12 >> 2] < HEAP32[$0 + 20 >> 2]) { + wasm2js_i32$0 = $2, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$0 + 16 >> 2] + (HEAP32[$2 + 12 >> 2] << 3) | 0, HEAP32[$2 + 24 >> 2]), + HEAPF32[wasm2js_i32$0 + 8 >> 2] = wasm2js_f32$0; + if (HEAPF32[$2 + 8 >> 2] > HEAPF32[$2 + 16 >> 2]) { + HEAP32[$2 + 20 >> 2] = HEAP32[$2 + 12 >> 2]; + HEAPF32[$2 + 16 >> 2] = HEAPF32[$2 + 8 >> 2]; + } + HEAP32[$2 + 12 >> 2] = HEAP32[$2 + 12 >> 2] + 1; + continue; + } + break; + } + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 20 >> 2]; +} + +function emscripten__internal__MethodInvoker_void_20_28b2PrismaticJoint____29_28float_2c_20float_29_2c_20void_2c_20b2PrismaticJoint__2c_20float_2c_20float___invoke_28void_20_28b2PrismaticJoint____20const__29_28float_2c_20float_29_2c_20b2PrismaticJoint__2c_20float_2c_20float_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + $3 = Math_fround($3); + var $4 = 0, $5 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAPF32[$4 + 4 >> 2] = $2; + HEAPF32[$4 >> 2] = $3; + $5 = emscripten__internal__BindingType_b2PrismaticJoint__2c_20void___fromWireType_28b2PrismaticJoint__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $5 = ($1 >> 1) + $5 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$5 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($5, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 + 4 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_b2Shape__20_28b2EdgeShape____29_28b2BlockAllocator__29_20const_2c_20b2Shape__2c_20b2EdgeShape_20const__2c_20b2BlockAllocator____invoke_28b2Shape__20_28b2EdgeShape____20const__29_28b2BlockAllocator__29_20const_2c_20b2EdgeShape_20const__2c_20b2BlockAllocator__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2EdgeShape_20const__2c_20void___fromWireType_28b2EdgeShape_20const__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_b2Shape__2c_20void___toWireType_28b2Shape__29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2BlockAllocator__2c_20void___fromWireType_28b2BlockAllocator__29(HEAP32[$3 + 4 >> 2])) | 0); + __stack_pointer = $3 + 16 | 0; + return $0 | 0; +} + +function b2TestOverlap_28b2AABB_20const__2c_20b2AABB_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 48 | 0; + __stack_pointer = $2; + HEAP32[$2 + 40 >> 2] = $0; + HEAP32[$2 + 36 >> 2] = $1; + b2Vec2__b2Vec2_28_29($2 + 24 | 0); + b2Vec2__b2Vec2_28_29($2 + 16 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 8 | 0, HEAP32[$2 + 36 >> 2], HEAP32[$2 + 40 >> 2] + 8 | 0); + $0 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$2 + 8 >> 2]; + HEAP32[$2 + 24 >> 2] = $1; + HEAP32[$2 + 28 >> 2] = $0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2, HEAP32[$2 + 40 >> 2], HEAP32[$2 + 36 >> 2] + 8 | 0); + $1 = HEAP32[$2 + 4 >> 2]; + $0 = HEAP32[$2 >> 2]; + HEAP32[$2 + 16 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + label$1: { + if (HEAPF32[$2 + 24 >> 2] > Math_fround(0) | HEAPF32[$2 + 28 >> 2] > Math_fround(0)) { + HEAP8[$2 + 47 | 0] = 0; + break label$1; + } + if (HEAPF32[$2 + 16 >> 2] > Math_fround(0) | HEAPF32[$2 + 20 >> 2] > Math_fround(0)) { + HEAP8[$2 + 47 | 0] = 0; + break label$1; + } + HEAP8[$2 + 47 | 0] = 1; + } + __stack_pointer = $2 + 48 | 0; + return HEAP8[$2 + 47 | 0] & 1; +} + +function emscripten__internal__MethodInvoker_void_20_28b2RevoluteJoint____29_28float_2c_20float_29_2c_20void_2c_20b2RevoluteJoint__2c_20float_2c_20float___invoke_28void_20_28b2RevoluteJoint____20const__29_28float_2c_20float_29_2c_20b2RevoluteJoint__2c_20float_2c_20float_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + $3 = Math_fround($3); + var $4 = 0, $5 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAPF32[$4 + 4 >> 2] = $2; + HEAPF32[$4 >> 2] = $3; + $5 = emscripten__internal__BindingType_b2RevoluteJoint__2c_20void___fromWireType_28b2RevoluteJoint__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $5 = ($1 >> 1) + $5 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$5 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($5, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 + 4 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function b2ChainAndPolygonContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 80 | 0; + __stack_pointer = $4; + HEAP32[$4 + 76 >> 2] = $0; + HEAP32[$4 + 72 >> 2] = $1; + HEAP32[$4 + 68 >> 2] = $2; + HEAP32[$4 + 64 >> 2] = $3; + $0 = HEAP32[$4 + 76 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = b2Fixture__GetShape_28_29(HEAP32[$0 + 48 >> 2]), + HEAP32[wasm2js_i32$0 + 60 >> 2] = wasm2js_i32$1; + b2EdgeShape__b2EdgeShape_28_29($4 + 12 | 0); + b2ChainShape__GetChildEdge_28b2EdgeShape__2c_20int_29_20const(HEAP32[$4 + 60 >> 2], $4 + 12 | 0, HEAP32[$0 + 56 >> 2]); + b2CollideEdgeAndPolygon_28b2Manifold__2c_20b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__29(HEAP32[$4 + 72 >> 2], $4 + 12 | 0, HEAP32[$4 + 68 >> 2], b2Fixture__GetShape_28_29(HEAP32[$0 + 52 >> 2]), HEAP32[$4 + 64 >> 2]); + b2EdgeShape___b2EdgeShape_28_29($4 + 12 | 0); + __stack_pointer = $4 + 80 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2ContactListenerWrapper____29_28unsigned_20int_29_2c_20bool_2c_20b2ContactListenerWrapper__2c_20unsigned_20int___invoke_28bool_20_28b2ContactListenerWrapper____20const__29_28unsigned_20int_29_2c_20b2ContactListenerWrapper__2c_20unsigned_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2ContactListenerWrapper__2c_20void___fromWireType_28b2ContactListenerWrapper__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$3 + 4 >> 2])) & 1); + __stack_pointer = $3 + 16 | 0; + return $0 & 1; +} + +function b2ChainAndCircleContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 80 | 0; + __stack_pointer = $4; + HEAP32[$4 + 76 >> 2] = $0; + HEAP32[$4 + 72 >> 2] = $1; + HEAP32[$4 + 68 >> 2] = $2; + HEAP32[$4 + 64 >> 2] = $3; + $0 = HEAP32[$4 + 76 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = b2Fixture__GetShape_28_29(HEAP32[$0 + 48 >> 2]), + HEAP32[wasm2js_i32$0 + 60 >> 2] = wasm2js_i32$1; + b2EdgeShape__b2EdgeShape_28_29($4 + 12 | 0); + b2ChainShape__GetChildEdge_28b2EdgeShape__2c_20int_29_20const(HEAP32[$4 + 60 >> 2], $4 + 12 | 0, HEAP32[$0 + 56 >> 2]); + b2CollideEdgeAndCircle_28b2Manifold__2c_20b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2CircleShape_20const__2c_20b2Transform_20const__29(HEAP32[$4 + 72 >> 2], $4 + 12 | 0, HEAP32[$4 + 68 >> 2], b2Fixture__GetShape_28_29(HEAP32[$0 + 52 >> 2]), HEAP32[$4 + 64 >> 2]); + b2EdgeShape___b2EdgeShape_28_29($4 + 12 | 0); + __stack_pointer = $4 + 80 | 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____resize_28unsigned_20long_2c_20b2Vec2_20const__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____size_5babi_v160004_5d_28_29_20const($0), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + label$1: { + if (HEAPU32[$3 >> 2] < HEAPU32[$3 + 8 >> 2]) { + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______append_28unsigned_20long_2c_20b2Vec2_20const__29($0, HEAP32[$3 + 8 >> 2] - HEAP32[$3 >> 2] | 0, HEAP32[$3 + 4 >> 2]); + break label$1; + } + if (HEAPU32[$3 >> 2] > HEAPU32[$3 + 8 >> 2]) { + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______destruct_at_end_5babi_v160004_5d_28b2Vec2__29($0, HEAP32[$0 >> 2] + (HEAP32[$3 + 8 >> 2] << 3) | 0); + } + } + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2PolygonShape____29_28float_2c_20float_29_2c_20void_2c_20b2PolygonShape__2c_20float_2c_20float___invoke_28void_20_28b2PolygonShape____20const__29_28float_2c_20float_29_2c_20b2PolygonShape__2c_20float_2c_20float_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + $3 = Math_fround($3); + var $4 = 0, $5 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAPF32[$4 + 4 >> 2] = $2; + HEAPF32[$4 >> 2] = $3; + $5 = emscripten__internal__BindingType_b2PolygonShape__2c_20void___fromWireType_28b2PolygonShape__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $5 = ($1 >> 1) + $5 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$5 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($5, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 + 4 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function void_20emscripten__function_b2Vec2_2c_20b2Transform_20const__2c_20b2Vec2_20const__2c_20emscripten__allow_raw_pointers__28char_20const__2c_20b2Vec2_20_28__29_28b2Transform_20const__2c_20b2Vec2_20const__29_2c_20emscripten__allow_raw_pointers_29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + HEAP32[$2 + 8 >> 2] = 399; + $0 = HEAP32[$2 + 20 >> 2]; + $1 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Vec2_2c_20b2Transform_20const__2c_20b2Vec2_20const____getCount_28_29_20const($2 + 15 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Vec2_2c_20b2Transform_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($2 + 15 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 8 >> 2]; + _embind_register_function($0 | 0, $1 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 8 >> 2], HEAP32[$2 + 16 >> 2], 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_float_20_28b2PrismaticJoint____29_28_29_20const_2c_20float_2c_20b2PrismaticJoint_20const____invoke_28float_20_28b2PrismaticJoint____20const__29_28_29_20const_2c_20b2PrismaticJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2PrismaticJoint_20const__2c_20void___fromWireType_28b2PrismaticJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($1)), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $4 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($4); +} + +function __cxxabiv1____class_type_info__search_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_2c_20bool_29_20const($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, HEAP32[$1 + 8 >> 2], $4)) { + __cxxabiv1____class_type_info__process_static_type_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_29_20const($1, $1, $2, $3); + return; + } + label$2: { + if (!is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, HEAP32[$1 >> 2], $4)) { + break label$2; + } + if (!(HEAP32[$1 + 16 >> 2] != ($2 | 0) & HEAP32[$1 + 20 >> 2] != ($2 | 0))) { + if (($3 | 0) != 1) { + break label$2; + } + HEAP32[$1 + 32 >> 2] = 1; + return; + } + HEAP32[$1 + 20 >> 2] = $2; + HEAP32[$1 + 32 >> 2] = $3; + HEAP32[$1 + 40 >> 2] = HEAP32[$1 + 40 >> 2] + 1; + if (!(HEAP32[$1 + 36 >> 2] != 1 | HEAP32[$1 + 24 >> 2] != 2)) { + HEAP8[$1 + 54 | 0] = 1; + } + HEAP32[$1 + 44 >> 2] = 4; + } +} + +function emscripten__internal__MethodInvoker_float_20_28b2RevoluteJoint____29_28_29_20const_2c_20float_2c_20b2RevoluteJoint_20const____invoke_28float_20_28b2RevoluteJoint____20const__29_28_29_20const_2c_20b2RevoluteJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2RevoluteJoint_20const__2c_20void___fromWireType_28b2RevoluteJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($1)), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $4 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($4); +} + +function emscripten__internal__MethodInvoker_float_20_28b2DistanceJoint____29_28_29_20const_2c_20float_2c_20b2DistanceJoint_20const____invoke_28float_20_28b2DistanceJoint____20const__29_28_29_20const_2c_20b2DistanceJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2DistanceJoint_20const__2c_20void___fromWireType_28b2DistanceJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($1)), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $4 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($4); +} + +function b2RopeJoint__b2RopeJoint_28b2RopeJointDef_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Joint__b2Joint_28b2JointDef_20const__29($1, HEAP32[$2 + 8 >> 2]); + HEAP32[$1 >> 2] = 19444; + b2Vec2__b2Vec2_28_29($1 + 68 | 0); + b2Vec2__b2Vec2_28_29($1 + 76 | 0); + b2Vec2__b2Vec2_28_29($1 + 104 | 0); + b2Vec2__b2Vec2_28_29($1 + 112 | 0); + b2Vec2__b2Vec2_28_29($1 + 120 | 0); + b2Vec2__b2Vec2_28_29($1 + 128 | 0); + b2Vec2__b2Vec2_28_29($1 + 136 | 0); + $3 = HEAP32[$2 + 8 >> 2]; + $4 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$1 + 68 >> 2] = $4; + HEAP32[$1 + 72 >> 2] = $0; + $3 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$3 + 28 >> 2]; + $4 = HEAP32[$3 + 32 >> 2]; + HEAP32[$1 + 76 >> 2] = $0; + HEAP32[$1 + 80 >> 2] = $4; + HEAPF32[$1 + 84 >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] + 36 >> 2]; + HEAPF32[$1 + 160 >> 2] = 0; + HEAPF32[$1 + 92 >> 2] = 0; + HEAPF32[$1 + 88 >> 2] = 0; + __stack_pointer = $2 + 16 | 0; + return $1; +} + +function emscripten__internal__MethodInvoker_b2Vec2_20_28b2RopeJoint____29_28float_29_20const_2c_20b2Vec2_2c_20b2RopeJoint_20const__2c_20float___invoke_28b2Vec2_20_28b2RopeJoint____20const__29_28float_29_20const_2c_20b2RopeJoint_20const__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAPF32[$3 + 20 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2RopeJoint_20const__2c_20void___fromWireType_28b2RopeJoint_20const__29(HEAP32[$3 + 24 >> 2]); + $0 = HEAP32[$3 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($3 + 12 | 0, $4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 20 >> 2])); + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2___29($3 + 12 | 0); + __stack_pointer = $3 + 32 | 0; + return $0 | 0; +} + +function emscripten__internal__MethodCaller_void_2c_20unsigned_20int__2c_20unsigned_20int____call_28emscripten___EM_VAL__2c_20char_20const__2c_20unsigned_20int__2c_20unsigned_20int__29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 48 | 0; + __stack_pointer = $4; + HEAP32[$4 + 44 >> 2] = $0; + HEAP32[$4 + 40 >> 2] = $1; + HEAP32[$4 + 36 >> 2] = $2; + HEAP32[$4 + 32 >> 2] = $3; + wasm2js_i32$0 = $4, wasm2js_i32$1 = emscripten__internal__Signature_void_2c_20unsigned_20int__2c_20unsigned_20int____get_method_caller_28_29(), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + emscripten__internal__WireTypePack_unsigned_20int__2c_20unsigned_20int____WireTypePack_28unsigned_20int__2c_20unsigned_20int__29($4 + 8 | 0, HEAP32[$4 + 36 >> 2], HEAP32[$4 + 32 >> 2]); + _emval_call_void_method(HEAP32[$4 + 28 >> 2], HEAP32[$4 + 44 >> 2], HEAP32[$4 + 40 >> 2], emscripten__internal__WireTypePack_unsigned_20int__2c_20unsigned_20int____operator_20void_20const__28_29_20const($4 + 8 | 0) | 0); + __stack_pointer = $4 + 48 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int____resize_28unsigned_20long_2c_20int_20const__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = std____2__vector_int_2c_20std____2__allocator_int____size_5babi_v160004_5d_28_29_20const($0), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + label$1: { + if (HEAPU32[$3 >> 2] < HEAPU32[$3 + 8 >> 2]) { + std____2__vector_int_2c_20std____2__allocator_int______append_28unsigned_20long_2c_20int_20const__29($0, HEAP32[$3 + 8 >> 2] - HEAP32[$3 >> 2] | 0, HEAP32[$3 + 4 >> 2]); + break label$1; + } + if (HEAPU32[$3 >> 2] > HEAPU32[$3 + 8 >> 2]) { + std____2__vector_int_2c_20std____2__allocator_int______destruct_at_end_5babi_v160004_5d_28int__29($0, HEAP32[$0 >> 2] + (HEAP32[$3 + 8 >> 2] << 2) | 0); + } + } + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_b2Fixture__20_28b2Body____29_28b2FixtureDef_20const__29_2c_20b2Fixture__2c_20b2Body__2c_20b2FixtureDef_20const____invoke_28b2Fixture__20_28b2Body____20const__29_28b2FixtureDef_20const__29_2c_20b2Body__2c_20b2FixtureDef_20const__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_b2Fixture__2c_20void___toWireType_28b2Fixture__29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2FixtureDef_20const__2c_20void___fromWireType_28b2FixtureDef_20const__29(HEAP32[$3 + 4 >> 2])) | 0); + __stack_pointer = $3 + 16 | 0; + return $0 | 0; +} + +function std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______release_5babi_v160004_5d_28_29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + wasm2js_i32$0 = $1, wasm2js_i32$1 = HEAP32[std____2____compressed_pair_std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______first_5babi_v160004_5d_28_29($0) >> 2], + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = std____2____compressed_pair_std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______first_5babi_v160004_5d_28_29($0), + wasm2js_i32$1 = 0, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function memchr($0, $1, $2) { + var $3 = 0, $4 = 0; + $3 = ($2 | 0) != 0; + label$1: { + label$2: { + label$3: { + if (!($0 & 3) | !$2) { + break label$3; + } + $4 = $1 & 255; + while (1) { + if (HEAPU8[$0 | 0] == ($4 | 0)) { + break label$2; + } + $2 = $2 - 1 | 0; + $3 = ($2 | 0) != 0; + $0 = $0 + 1 | 0; + if (!($0 & 3)) { + break label$3; + } + if ($2) { + continue; + } + break; + } + } + if (!$3) { + break label$1; + } + if (!(HEAPU8[$0 | 0] == ($1 & 255) | $2 >>> 0 < 4)) { + $4 = Math_imul($1 & 255, 16843009); + while (1) { + $3 = HEAP32[$0 >> 2] ^ $4; + if (($3 ^ -1) & $3 - 16843009 & -2139062144) { + break label$2; + } + $0 = $0 + 4 | 0; + $2 = $2 - 4 | 0; + if ($2 >>> 0 > 3) { + continue; + } + break; + } + } + if (!$2) { + break label$1; + } + } + $3 = $1 & 255; + while (1) { + if (HEAPU8[$0 | 0] == ($3 | 0)) { + return $0; + } + $0 = $0 + 1 | 0; + $2 = $2 - 1 | 0; + if ($2) { + continue; + } + break; + } + } + return 0; +} + +function b2World__RayCast_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 48 | 0; + __stack_pointer = $4; + HEAP32[$4 + 44 >> 2] = $0; + HEAP32[$4 + 40 >> 2] = $1; + HEAP32[$4 + 36 >> 2] = $2; + HEAP32[$4 + 32 >> 2] = $3; + $3 = HEAP32[$4 + 44 >> 2]; + HEAP32[$4 + 24 >> 2] = $3 + 102868; + HEAP32[$4 + 28 >> 2] = HEAP32[$4 + 40 >> 2]; + b2RayCastInput__b2RayCastInput_28_29($4 + 4 | 0); + HEAPF32[$4 + 20 >> 2] = 1; + $2 = HEAP32[$4 + 36 >> 2]; + $0 = HEAP32[$2 >> 2]; + $1 = HEAP32[$2 + 4 >> 2]; + $2 = $0; + $0 = $4 + 4 | 0; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + $2 = HEAP32[$4 + 32 >> 2]; + $1 = HEAP32[$2 >> 2]; + $0 = HEAP32[$2 + 4 >> 2]; + $2 = $1; + $1 = $4 + 4 | 0; + HEAP32[$1 + 8 >> 2] = $2; + HEAP32[$1 + 12 >> 2] = $0; + void_20b2BroadPhase__RayCast_b2WorldRayCastWrapper__28b2WorldRayCastWrapper__2c_20b2RayCastInput_20const__29_20const($3 + 102868 | 0, $4 + 24 | 0, $4 + 4 | 0); + __stack_pointer = $4 + 48 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2Vec2_20const__2c_20float_29_2c_20void_2c_20b2Body__2c_20b2Vec2_20const__2c_20float___invoke_28void_20_28b2Body____20const__29_28b2Vec2_20const__2c_20float_29_2c_20b2Body__2c_20b2Vec2__2c_20float_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = Math_fround($3); + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAPF32[$4 >> 2] = $3; + $2 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2Vec2_20const__2c_20bool_29_2c_20void_2c_20b2Body__2c_20b2Vec2_20const__2c_20bool___invoke_28void_20_28b2Body____20const__29_28b2Vec2_20const__2c_20bool_29_2c_20b2Body__2c_20b2Vec2__2c_20bool_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP8[$4 + 3 | 0] = $3 & 1; + $2 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$4 + 3 | 0] & 1) & 1); + __stack_pointer = $4 + 16 | 0; +} + +function void_20emscripten__function_void_2c_20b2Joint__2c_20float_2c_20float_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20void_20_28__29_28b2Joint__2c_20float_2c_20float_29_2c_20emscripten__allow_raw_pointers_29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + HEAP32[$2 + 8 >> 2] = 398; + $0 = HEAP32[$2 + 20 >> 2]; + $1 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2Joint__2c_20float_2c_20float___getCount_28_29_20const($2 + 15 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2Joint__2c_20float_2c_20float___getTypes_28_29_20const($2 + 15 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 8 >> 2]; + _embind_register_function($0 | 0, $1 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float_2c_20float__28_29() | 0, HEAP32[$2 + 8 >> 2], HEAP32[$2 + 16 >> 2], 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_float_20_28b2WheelJoint____29_28_29_20const_2c_20float_2c_20b2WheelJoint_20const____invoke_28float_20_28b2WheelJoint____20const__29_28_29_20const_2c_20b2WheelJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2WheelJoint_20const__2c_20void___fromWireType_28b2WheelJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($1)), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $4 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($4); +} + +function emscripten__internal__MethodInvoker_float_20_28b2MouseJoint____29_28_29_20const_2c_20float_2c_20b2MouseJoint_20const____invoke_28float_20_28b2MouseJoint____20const__29_28_29_20const_2c_20b2MouseJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2MouseJoint_20const__2c_20void___fromWireType_28b2MouseJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($1)), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $4 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($4); +} + +function emscripten__internal__MethodInvoker_float_20_28b2MotorJoint____29_28_29_20const_2c_20float_2c_20b2MotorJoint_20const____invoke_28float_20_28b2MotorJoint____20const__29_28_29_20const_2c_20b2MotorJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2MotorJoint_20const__2c_20void___fromWireType_28b2MotorJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($1)), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $4 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($4); +} + +function emscripten__internal__MethodInvoker_b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const_2c_20b2Vec2_2c_20b2Body_20const__2c_20b2Vec2_20const____invoke_28b2Vec2_20_28b2Body____20const__29_28b2Vec2_20const__29_20const_2c_20b2Body_20const__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2Body_20const__2c_20void___fromWireType_28b2Body_20const__29(HEAP32[$3 + 24 >> 2]); + $0 = HEAP32[$3 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($3 + 12 | 0, $2, emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 20 >> 2])); + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2___29($3 + 12 | 0); + __stack_pointer = $3 + 32 | 0; + return $0 | 0; +} + +function b2World___b2World_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 32 | 0; + __stack_pointer = $1; + HEAP32[$1 + 24 >> 2] = $0; + $0 = HEAP32[$1 + 24 >> 2]; + HEAP32[$1 + 28 >> 2] = $0; + HEAP32[$1 + 20 >> 2] = HEAP32[$0 + 102948 >> 2]; + while (1) { + if (HEAP32[$1 + 20 >> 2]) { + HEAP32[$1 + 16 >> 2] = HEAP32[HEAP32[$1 + 20 >> 2] + 96 >> 2]; + HEAP32[$1 + 12 >> 2] = HEAP32[HEAP32[$1 + 20 >> 2] + 100 >> 2]; + while (1) { + if (HEAP32[$1 + 12 >> 2]) { + HEAP32[$1 + 8 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] + 4 >> 2]; + HEAP32[HEAP32[$1 + 12 >> 2] + 28 >> 2] = 0; + b2Fixture__Destroy_28b2BlockAllocator__29(HEAP32[$1 + 12 >> 2], $0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 + 8 >> 2]; + continue; + } + break; + } + HEAP32[$1 + 20 >> 2] = HEAP32[$1 + 16 >> 2]; + continue; + } + break; + } + b2ContactManager___b2ContactManager_28_29($0 + 102868 | 0); + b2StackAllocator___b2StackAllocator_28_29($0 + 68 | 0); + b2BlockAllocator___b2BlockAllocator_28_29($0); + __stack_pointer = $1 + 32 | 0; + return HEAP32[$1 + 28 >> 2]; +} + +function wcrtomb($0, $1, $2) { + var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = 1; + label$1: { + if ($0) { + if ($1 >>> 0 <= 127) { + break label$1; + } + label$3: { + if (!HEAP32[HEAP32[__get_tp() + 96 >> 2] >> 2]) { + if (($1 & -128) == 57216) { + break label$1; + } + break label$3; + } + if ($1 >>> 0 <= 2047) { + HEAP8[$0 + 1 | 0] = $1 & 63 | 128; + HEAP8[$0 | 0] = $1 >>> 6 | 192; + return 2; + } + if (!(($1 & -8192) != 57344 & $1 >>> 0 >= 55296)) { + HEAP8[$0 + 2 | 0] = $1 & 63 | 128; + HEAP8[$0 | 0] = $1 >>> 12 | 224; + HEAP8[$0 + 1 | 0] = $1 >>> 6 & 63 | 128; + return 3; + } + if ($1 - 65536 >>> 0 <= 1048575) { + HEAP8[$0 + 3 | 0] = $1 & 63 | 128; + HEAP8[$0 | 0] = $1 >>> 18 | 240; + HEAP8[$0 + 2 | 0] = $1 >>> 6 & 63 | 128; + HEAP8[$0 + 1 | 0] = $1 >>> 12 & 63 | 128; + return 4; + } + } + wasm2js_i32$0 = __errno_location(), wasm2js_i32$1 = 25, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + $2 = -1; + } + return $2; + } + HEAP8[$0 | 0] = $1; + return 1; +} + +function emscripten__internal__MethodInvoker_float_20_28b2WeldJoint____29_28_29_20const_2c_20float_2c_20b2WeldJoint_20const____invoke_28float_20_28b2WeldJoint____20const__29_28_29_20const_2c_20b2WeldJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2WeldJoint_20const__2c_20void___fromWireType_28b2WeldJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($1)), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $4 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($4); +} + +function emscripten__internal__MethodInvoker_float_20_28b2RopeJoint____29_28_29_20const_2c_20float_2c_20b2RopeJoint_20const____invoke_28float_20_28b2RopeJoint____20const__29_28_29_20const_2c_20b2RopeJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2RopeJoint_20const__2c_20void___fromWireType_28b2RopeJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($1)), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $4 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($4); +} + +function emscripten__internal__MethodInvoker_b2Joint__20_28b2World____29_28b2JointDef_20const__29_2c_20b2Joint__2c_20b2World__2c_20b2JointDef_20const____invoke_28b2Joint__20_28b2World____20const__29_28b2JointDef_20const__29_2c_20b2World__2c_20b2JointDef_20const__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2World__2c_20void___fromWireType_28b2World__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_b2Joint__2c_20void___toWireType_28b2Joint__29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2JointDef_20const__2c_20void___fromWireType_28b2JointDef_20const__29(HEAP32[$3 + 4 >> 2])) | 0); + __stack_pointer = $3 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__MethodInvoker_b2Vec2_20_28b2Joint____29_28float_29_20const_2c_20b2Vec2_2c_20b2Joint_20const__2c_20float___invoke_28b2Vec2_20_28b2Joint____20const__29_28float_29_20const_2c_20b2Joint_20const__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAPF32[$3 + 20 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2Joint_20const__2c_20void___fromWireType_28b2Joint_20const__29(HEAP32[$3 + 24 >> 2]); + $0 = HEAP32[$3 + 28 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($3 + 12 | 0, $4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 20 >> 2])); + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2___29($3 + 12 | 0); + __stack_pointer = $3 + 32 | 0; + return $0 | 0; +} + +function __stdio_read($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, $4 = 0, $5 = 0, $6 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 16 >> 2] = $1; + $3 = HEAP32[$0 + 48 >> 2]; + HEAP32[$4 + 20 >> 2] = $2 - (($3 | 0) != 0); + $6 = HEAP32[$0 + 44 >> 2]; + HEAP32[$4 + 28 >> 2] = $3; + HEAP32[$4 + 24 >> 2] = $6; + $3 = 32; + label$1: { + label$2: { + if (!__wasi_syscall_ret(__wasi_fd_read(HEAP32[$0 + 60 >> 2], $4 + 16 | 0, 2, $4 + 12 | 0) | 0)) { + $3 = HEAP32[$4 + 12 >> 2]; + if (($3 | 0) > 0) { + break label$2; + } + $3 = $3 ? 32 : 16; + } + HEAP32[$0 >> 2] = HEAP32[$0 >> 2] | $3; + break label$1; + } + $5 = $3; + $6 = HEAP32[$4 + 20 >> 2]; + if ($6 >>> 0 >= $3 >>> 0) { + break label$1; + } + $5 = HEAP32[$0 + 44 >> 2]; + HEAP32[$0 + 4 >> 2] = $5; + HEAP32[$0 + 8 >> 2] = ($3 - $6 | 0) + $5; + if (HEAP32[$0 + 48 >> 2]) { + HEAP32[$0 + 4 >> 2] = $5 + 1; + HEAP8[($1 + $2 | 0) - 1 | 0] = HEAPU8[$5 | 0]; + } + $5 = $2; + } + __stack_pointer = $4 + 32 | 0; + return $5 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2QueryCallback____29_28unsigned_20int_29_2c_20bool_2c_20b2QueryCallback__2c_20unsigned_20int___invoke_28bool_20_28b2QueryCallback____20const__29_28unsigned_20int_29_2c_20b2QueryCallback__2c_20unsigned_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2QueryCallback__2c_20void___fromWireType_28b2QueryCallback__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$3 + 4 >> 2])) & 1); + __stack_pointer = $3 + 16 | 0; + return $0 & 1; +} + +function std____2__set_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____find_5babi_v160004_5d_28b2Fixture__20const__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 4 >> 2] = $1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____find_b2Fixture___28b2Fixture__20const__29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 4 >> 2]), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____tree_const_iterator_5babi_v160004_5d_28std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__29($2 + 12 | 0, HEAP32[$2 >> 2]); + __stack_pointer = $2 + 16 | 0; + return HEAP32[$2 + 12 >> 2]; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Body____29_28float_2c_20bool_29_2c_20void_2c_20b2Body__2c_20float_2c_20bool___invoke_28void_20_28b2Body____20const__29_28float_2c_20bool_29_2c_20b2Body__2c_20float_2c_20bool_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAPF32[$4 + 4 >> 2] = $2; + HEAP8[$4 + 3 | 0] = $3 & 1; + $3 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$4 + 8 >> 2]); + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $3 = ($1 >> 1) + $3 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$3 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($3, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 + 4 >> 2]), emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$4 + 3 | 0] & 1) & 1); + __stack_pointer = $4 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_float_20_28b2Fixture____29_28_29_20const_2c_20float_2c_20b2Fixture_20const____invoke_28float_20_28b2Fixture____20const__29_28_29_20const_2c_20b2Fixture_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Fixture_20const__2c_20void___fromWireType_28b2Fixture_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($1)), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $4 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($4); +} + +function std____2__reverse_iterator_b2Vec2___20std____2____rewrap_range_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = HEAP32[$2 + 24 >> 2]; + HEAP32[$2 + 12 >> 2] = HEAP32[$2 + 20 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__reverse_iterator_b2Vec2___20std____2____rewrap_iter_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false___28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29(HEAP32[$2 + 16 >> 2], HEAP32[$2 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function emscripten__internal__MethodInvoker_b2Body__20_28b2World____29_28b2BodyDef_20const__29_2c_20b2Body__2c_20b2World__2c_20b2BodyDef_20const____invoke_28b2Body__20_28b2World____20const__29_28b2BodyDef_20const__29_2c_20b2World__2c_20b2BodyDef_20const__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2World__2c_20void___fromWireType_28b2World__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_b2Body__2c_20void___toWireType_28b2Body__29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2BodyDef_20const__2c_20void___fromWireType_28b2BodyDef_20const__29(HEAP32[$3 + 4 >> 2])) | 0); + __stack_pointer = $3 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2Fixture____29_28b2Vec2_20const__29_20const_2c_20bool_2c_20b2Fixture_20const__2c_20b2Vec2_20const____invoke_28bool_20_28b2Fixture____20const__29_28b2Vec2_20const__29_20const_2c_20b2Fixture_20const__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2Fixture_20const__2c_20void___fromWireType_28b2Fixture_20const__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2])) & 1); + __stack_pointer = $3 + 16 | 0; + return $0 & 1; +} + +function emscripten__internal__MethodInvoker_b2AABB_20const__20_28b2Fixture____29_28int_29_20const_2c_20b2AABB_20const__2c_20b2Fixture_20const__2c_20int___invoke_28b2AABB_20const__20_28b2Fixture____20const__29_28int_29_20const_2c_20b2Fixture_20const__2c_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2Fixture_20const__2c_20void___fromWireType_28b2Fixture_20const__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__GenericBindingType_b2AABB___toWireType_28b2AABB_20const__29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$3 + 4 >> 2])) | 0); + __stack_pointer = $3 + 16 | 0; + return $0 | 0; +} + +function std____2__pair_std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__2c_20bool___pair_5babi_v160004_5d_std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__2c_20bool_2c_20_28void__290__28std____2__pair_std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__2c_20bool____29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 4 >> 2] = HEAP32[HEAP32[$2 + 8 >> 2] >> 2]; + std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____tree_const_iterator_5babi_v160004_5d_28std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__29($0, HEAP32[$2 + 4 >> 2]); + HEAP8[$0 + 4 | 0] = HEAP8[HEAP32[$2 + 8 >> 2] + 4 | 0] & 1; + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function emscripten__internal__MethodInvoker_float_20_28b2Body____29_28_29_20const_2c_20float_2c_20b2Body_20const____invoke_28float_20_28b2Body____20const__29_28_29_20const_2c_20b2Body_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Body_20const__2c_20void___fromWireType_28b2Body_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($1)), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $4 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($4); +} + +function emscripten__internal__MethodInvoker_float_20_28b2AABB____29_28_29_20const_2c_20float_2c_20b2AABB_20const____invoke_28float_20_28b2AABB____20const__29_28_29_20const_2c_20b2AABB_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2AABB_20const__2c_20void___fromWireType_28b2AABB_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0]($1)), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $4 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($4); +} + +function emscripten__internal__MethodInvoker_bool_20_28b2AABB____29_28b2AABB_20const__29_20const_2c_20bool_2c_20b2AABB_20const__2c_20b2AABB_20const____invoke_28bool_20_28b2AABB____20const__29_28b2AABB_20const__29_20const_2c_20b2AABB_20const__2c_20b2AABB__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2AABB_20const__2c_20void___fromWireType_28b2AABB_20const__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2AABB___fromWireType_28b2AABB__29(HEAP32[$3 + 4 >> 2])) & 1); + __stack_pointer = $3 + 16 | 0; + return $0 & 1; +} + +function emscripten__internal__WireTypePack_unsigned_20int____WireTypePack_28unsigned_20int__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + $0 = HEAP32[$2 + 20 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__array_emscripten__internal__GenericWireType_2c_201ul___data_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$2 + 16 >> 2]; + HEAP32[$2 + 28 >> 2] = $2 + 12; + HEAP32[$2 + 24 >> 2] = $1; + void_20emscripten__internal__writeGenericWireType_unsigned_20int__28emscripten__internal__GenericWireType___2c_20unsigned_20int_29(HEAP32[$2 + 28 >> 2], emscripten__internal__BindingType_unsigned_20int_2c_20void___toWireType_28unsigned_20int_20const__29(HEAP32[$2 + 24 >> 2])); + emscripten__internal__writeGenericWireTypes_28emscripten__internal__GenericWireType___29(HEAP32[$2 + 28 >> 2]); + __stack_pointer = $2 + 32 | 0; + return $0; +} + +function emscripten__internal__MethodInvoker_unsigned_20int_20_28b2Draw____29_28_29_20const_2c_20unsigned_20int_2c_20b2Draw_20const____invoke_28unsigned_20int_20_28b2Draw____20const__29_28_29_20const_2c_20b2Draw_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Draw_20const__2c_20void___fromWireType_28b2Draw_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = FUNCTION_TABLE[$0 | 0]($1) | 0, HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = emscripten__internal__BindingType_unsigned_20int_2c_20void___toWireType_28unsigned_20int_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__WireTypePack_b2Transform_20const____WireTypePack_28b2Transform_20const__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + $0 = HEAP32[$2 + 20 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__array_emscripten__internal__GenericWireType_2c_201ul___data_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$2 + 16 >> 2]; + HEAP32[$2 + 28 >> 2] = $2 + 12; + HEAP32[$2 + 24 >> 2] = $1; + void_20emscripten__internal__writeGenericWireType_b2Transform__28emscripten__internal__GenericWireType___2c_20b2Transform__29(HEAP32[$2 + 28 >> 2], emscripten__internal__GenericBindingType_b2Transform___toWireType_28b2Transform_20const__29(HEAP32[$2 + 24 >> 2])); + emscripten__internal__writeGenericWireTypes_28emscripten__internal__GenericWireType___29(HEAP32[$2 + 28 >> 2]); + __stack_pointer = $2 + 32 | 0; + return $0; +} + +function emscripten__internal__MethodInvoker_int_20_28b2PolygonShape____29_28_29_20const_2c_20int_2c_20b2PolygonShape_20const____invoke_28int_20_28b2PolygonShape____20const__29_28_29_20const_2c_20b2PolygonShape_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2PolygonShape_20const__2c_20void___fromWireType_28b2PolygonShape_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = FUNCTION_TABLE[$0 | 0]($1) | 0, HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = emscripten__internal__BindingType_int_2c_20void___toWireType_28int_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function std____2__reverse_iterator_int___20std____2____rewrap_range_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = HEAP32[$2 + 24 >> 2]; + HEAP32[$2 + 12 >> 2] = HEAP32[$2 + 20 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__reverse_iterator_int___20std____2____rewrap_iter_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false___28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29(HEAP32[$2 + 16 >> 2], HEAP32[$2 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____max_size_28_29_20const($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + wasm2js_i32$0 = $1, wasm2js_i32$1 = unsigned_20long_20std____2__allocator_traits_std____2__allocator_b2Vec2____max_size_5babi_v160004_5d_std____2__allocator_b2Vec2__2c_20void__28std____2__allocator_b2Vec2__20const__29(std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______alloc_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2])), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = std____2__numeric_limits_long___max_5babi_v160004_5d_28_29(), + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = unsigned_20long_20const__20std____2__min_5babi_v160004_5d_unsigned_20long__28unsigned_20long_20const__2c_20unsigned_20long_20const__29($1 + 8 | 0, $1 + 4 | 0); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$0 >> 2]; +} + +function emscripten__internal__MethodInvoker_void_20_28b2ContactListenerWrapper____29_28unsigned_20int_29_2c_20void_2c_20b2ContactListenerWrapper__2c_20unsigned_20int___invoke_28void_20_28b2ContactListenerWrapper____20const__29_28unsigned_20int_29_2c_20b2ContactListenerWrapper__2c_20unsigned_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2ContactListenerWrapper__2c_20void___fromWireType_28b2ContactListenerWrapper__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_int_20_28b2CircleShape____29_28_29_20const_2c_20int_2c_20b2CircleShape_20const____invoke_28int_20_28b2CircleShape____20const__29_28_29_20const_2c_20b2CircleShape_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2CircleShape_20const__2c_20void___fromWireType_28b2CircleShape_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = FUNCTION_TABLE[$0 | 0]($1) | 0, HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = emscripten__internal__BindingType_int_2c_20void___toWireType_28int_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Mat22__GetInverse_28_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $1; + $1 = HEAP32[$2 + 28 >> 2]; + HEAPF32[$2 + 24 >> 2] = HEAPF32[$1 >> 2]; + HEAPF32[$2 + 20 >> 2] = HEAPF32[$1 + 8 >> 2]; + HEAPF32[$2 + 16 >> 2] = HEAPF32[$1 + 4 >> 2]; + HEAPF32[$2 + 12 >> 2] = HEAPF32[$1 + 12 >> 2]; + b2Mat22__b2Mat22_28_29($0); + HEAPF32[$2 + 8 >> 2] = Math_fround(HEAPF32[$2 + 24 >> 2] * HEAPF32[$2 + 12 >> 2]) - Math_fround(HEAPF32[$2 + 20 >> 2] * HEAPF32[$2 + 16 >> 2]); + if (HEAPF32[$2 + 8 >> 2] != Math_fround(0)) { + HEAPF32[$2 + 8 >> 2] = Math_fround(1) / HEAPF32[$2 + 8 >> 2]; + } + HEAPF32[$0 >> 2] = HEAPF32[$2 + 8 >> 2] * HEAPF32[$2 + 12 >> 2]; + HEAPF32[$0 + 8 >> 2] = Math_fround(-HEAPF32[$2 + 8 >> 2]) * HEAPF32[$2 + 20 >> 2]; + HEAPF32[$0 + 4 >> 2] = Math_fround(-HEAPF32[$2 + 8 >> 2]) * HEAPF32[$2 + 16 >> 2]; + HEAPF32[$0 + 12 >> 2] = HEAPF32[$2 + 8 >> 2] * HEAPF32[$2 + 24 >> 2]; + __stack_pointer = $2 + 32 | 0; +} + +function b2ChainAndPolygonContact__b2ChainAndPolygonContact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 24 >> 2] = $0; + HEAP32[$5 + 20 >> 2] = $1; + HEAP32[$5 + 16 >> 2] = $2; + HEAP32[$5 + 12 >> 2] = $3; + HEAP32[$5 + 8 >> 2] = $4; + $0 = HEAP32[$5 + 24 >> 2]; + HEAP32[$5 + 28 >> 2] = $0; + b2Contact__b2Contact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29($0, HEAP32[$5 + 20 >> 2], HEAP32[$5 + 16 >> 2], HEAP32[$5 + 12 >> 2], HEAP32[$5 + 8 >> 2]); + HEAP32[$0 >> 2] = 18348; + if ((b2Fixture__GetType_28_29_20const(HEAP32[$0 + 48 >> 2]) | 0) != 3) { + __assert_fail(6878, 4630, 46, 3034); + wasm2js_trap(); + } + if ((b2Fixture__GetType_28_29_20const(HEAP32[$0 + 52 >> 2]) | 0) != 2) { + __assert_fail(6761, 4630, 47, 3034); + wasm2js_trap(); + } + __stack_pointer = $5 + 32 | 0; + return HEAP32[$5 + 28 >> 2]; +} + +function emscripten__internal__MethodInvoker_int_20_28b2EdgeShape____29_28_29_20const_2c_20int_2c_20b2EdgeShape_20const____invoke_28int_20_28b2EdgeShape____20const__29_28_29_20const_2c_20b2EdgeShape_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2EdgeShape_20const__2c_20void___fromWireType_28b2EdgeShape_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = FUNCTION_TABLE[$0 | 0]($1) | 0, HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = emscripten__internal__BindingType_int_2c_20void___toWireType_28int_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function std____2__reverse_iterator_b2Vec2___20std____2____rewrap_iter_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false___28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = HEAP32[$2 + 24 >> 2]; + HEAP32[$2 + 12 >> 2] = HEAP32[$2 + 20 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false_____rewrap_5babi_v160004_5d_28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29(HEAP32[$2 + 16 >> 2], HEAP32[$2 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function __cxxabiv1____pointer_type_info__can_catch_nested_28__cxxabiv1____shim_type_info_20const__29_20const($0, $1) { + var $2 = 0, $3 = 0; + label$1: { + while (1) { + if (!$1) { + return 0; + } + $1 = __dynamic_cast($1, 23924, 24068, 0); + if (!$1 | HEAP32[$1 + 8 >> 2] & (HEAP32[$0 + 8 >> 2] ^ -1)) { + break label$1; + } + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29(HEAP32[$0 + 12 >> 2], HEAP32[$1 + 12 >> 2], 0)) { + return 1; + } + if (!(HEAP8[$0 + 8 | 0] & 1)) { + break label$1; + } + $2 = HEAP32[$0 + 12 >> 2]; + if (!$2) { + break label$1; + } + $0 = __dynamic_cast($2, 23924, 24068, 0); + if ($0) { + $1 = HEAP32[$1 + 12 >> 2]; + continue; + } + break; + } + $0 = __dynamic_cast($2, 23924, 24180, 0); + if (!$0) { + break label$1; + } + $3 = __cxxabiv1____pointer_to_member_type_info__can_catch_nested_28__cxxabiv1____shim_type_info_20const__29_20const($0, HEAP32[$1 + 12 >> 2]); + } + return $3; +} + +function std____2__vector_int_2c_20std____2__allocator_int____max_size_28_29_20const($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + wasm2js_i32$0 = $1, wasm2js_i32$1 = unsigned_20long_20std____2__allocator_traits_std____2__allocator_int____max_size_5babi_v160004_5d_std____2__allocator_int__2c_20void__28std____2__allocator_int__20const__29(std____2__vector_int_2c_20std____2__allocator_int______alloc_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2])), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $1, wasm2js_i32$1 = std____2__numeric_limits_long___max_5babi_v160004_5d_28_29(), + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = unsigned_20long_20const__20std____2__min_5babi_v160004_5d_unsigned_20long__28unsigned_20long_20const__2c_20unsigned_20long_20const__29($1 + 8 | 0, $1 + 4 | 0); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$0 >> 2]; +} + +function emscripten__internal__WireTypePack_b2Vec2_20const____WireTypePack_28b2Vec2_20const__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + $0 = HEAP32[$2 + 20 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__array_emscripten__internal__GenericWireType_2c_201ul___data_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$2 + 16 >> 2]; + HEAP32[$2 + 28 >> 2] = $2 + 12; + HEAP32[$2 + 24 >> 2] = $1; + void_20emscripten__internal__writeGenericWireType_b2Vec2__28emscripten__internal__GenericWireType___2c_20b2Vec2__29(HEAP32[$2 + 28 >> 2], emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 24 >> 2])); + emscripten__internal__writeGenericWireTypes_28emscripten__internal__GenericWireType___29(HEAP32[$2 + 28 >> 2]); + __stack_pointer = $2 + 32 | 0; + return $0; +} + +function b2CircleShape__ComputeMass_28b2MassData__2c_20float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0, $5 = 0, $6 = Math_fround(0); + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = HEAP32[$3 + 12 >> 2]; + HEAPF32[HEAP32[$3 + 8 >> 2] >> 2] = Math_fround(Math_fround(HEAPF32[$3 + 4 >> 2] * Math_fround(3.1415927410125732)) * HEAPF32[$4 + 8 >> 2]) * HEAPF32[$4 + 8 >> 2]; + $5 = HEAP32[$4 + 16 >> 2]; + $0 = HEAP32[$4 + 12 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2]; + HEAP32[$0 + 4 >> 2] = $1; + HEAP32[$0 + 8 >> 2] = $5; + $2 = HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]; + $6 = Math_fround(Math_fround(Math_fround(HEAPF32[$4 + 8 >> 2] * Math_fround(.5)) * HEAPF32[$4 + 8 >> 2]) + b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 12 | 0, $4 + 12 | 0)); + HEAPF32[HEAP32[$3 + 8 >> 2] + 12 >> 2] = $2 * $6; + __stack_pointer = $3 + 16 | 0; +} + +function b2ChainAndCircleContact__b2ChainAndCircleContact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 24 >> 2] = $0; + HEAP32[$5 + 20 >> 2] = $1; + HEAP32[$5 + 16 >> 2] = $2; + HEAP32[$5 + 12 >> 2] = $3; + HEAP32[$5 + 8 >> 2] = $4; + $0 = HEAP32[$5 + 24 >> 2]; + HEAP32[$5 + 28 >> 2] = $0; + b2Contact__b2Contact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29($0, HEAP32[$5 + 20 >> 2], HEAP32[$5 + 16 >> 2], HEAP32[$5 + 12 >> 2], HEAP32[$5 + 8 >> 2]); + HEAP32[$0 >> 2] = 18288; + if ((b2Fixture__GetType_28_29_20const(HEAP32[$0 + 48 >> 2]) | 0) != 3) { + __assert_fail(6878, 4932, 46, 3139); + wasm2js_trap(); + } + if (b2Fixture__GetType_28_29_20const(HEAP32[$0 + 52 >> 2])) { + __assert_fail(9531, 4932, 47, 3139); + wasm2js_trap(); + } + __stack_pointer = $5 + 32 | 0; + return HEAP32[$5 + 28 >> 2]; +} + +function b2Body__ApplyForce_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0, $5 = Math_fround(0); + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 28 >> 2] = $0; + HEAP32[$4 + 24 >> 2] = $1; + HEAP32[$4 + 20 >> 2] = $2; + HEAP8[$4 + 19 | 0] = $3; + $0 = HEAP32[$4 + 28 >> 2]; + label$1: { + if (HEAP32[$0 >> 2] != 2) { + break label$1; + } + if (!(!(HEAP8[$4 + 19 | 0] & 1) | HEAPU16[$0 + 4 >> 1] & 2)) { + b2Body__SetAwake_28bool_29($0, 1); + } + if (!(HEAPU16[$0 + 4 >> 1] & 2)) { + break label$1; + } + b2Vec2__operator___28b2Vec2_20const__29($0 + 76 | 0, HEAP32[$4 + 24 >> 2]); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 8 | 0, HEAP32[$4 + 20 >> 2], $0 + 44 | 0); + $5 = b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($4 + 8 | 0, HEAP32[$4 + 24 >> 2]); + HEAPF32[$0 + 84 >> 2] = HEAPF32[$0 + 84 >> 2] + $5; + } + __stack_pointer = $4 + 32 | 0; +} + +function b2BlockAllocator__Free_28void__2c_20int_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + label$1: { + if (!HEAP32[$3 + 20 >> 2]) { + break label$1; + } + if (HEAP32[$3 + 20 >> 2] <= 0) { + __assert_fail(8597, 5349, 178, 9825); + wasm2js_trap(); + } + if (HEAP32[$3 + 20 >> 2] > 640) { + b2Free_28void__29(HEAP32[$3 + 24 >> 2]); + break label$1; + } + HEAP32[$3 + 16 >> 2] = HEAPU8[HEAP32[$3 + 20 >> 2] + 30116 | 0]; + if (!(HEAP32[$3 + 16 >> 2] < 14 & HEAP32[$3 + 16 >> 2] >= 0)) { + __assert_fail(2135, 5349, 187, 9825); + wasm2js_trap(); + } + HEAP32[$3 + 12 >> 2] = HEAP32[$3 + 24 >> 2]; + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] = HEAP32[($0 + 12 | 0) + (HEAP32[$3 + 16 >> 2] << 2) >> 2]; + HEAP32[($0 + 12 | 0) + (HEAP32[$3 + 16 >> 2] << 2) >> 2] = HEAP32[$3 + 12 >> 2]; + } + __stack_pointer = $3 + 32 | 0; +} + +function b2WheelJoint__GetJointTranslation_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer - 48 | 0; + __stack_pointer = $1; + HEAP32[$1 + 44 >> 2] = $0; + $0 = HEAP32[$1 + 44 >> 2]; + HEAP32[$1 + 40 >> 2] = HEAP32[$0 + 48 >> 2]; + HEAP32[$1 + 36 >> 2] = HEAP32[$0 + 52 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($1 + 28 | 0, HEAP32[$1 + 40 >> 2], $0 + 68 | 0); + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($1 + 20 | 0, HEAP32[$1 + 36 >> 2], $0 + 76 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 12 | 0, $1 + 20 | 0, $1 + 28 | 0); + b2Body__GetWorldVector_28b2Vec2_20const__29_20const($1 + 4 | 0, HEAP32[$1 + 40 >> 2], $0 + 84 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 12 | 0, $1 + 4 | 0), + HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0; + __stack_pointer = $1 + 48 | 0; + return Math_fround(HEAPF32[$1 >> 2]); +} + +function std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char______compressed_pair_5babi_v160004_5d_std____2____default_init_tag_2c_20std____2____default_init_tag__28std____2____default_init_tag___2c_20std____2____default_init_tag___29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + std____2____compressed_pair_elem_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_28std____2____default_init_tag_29($0); + std____2____compressed_pair_elem_std____2__allocator_char__2c_201_2c_20true_____compressed_pair_elem_5babi_v160004_5d_28std____2____default_init_tag_29($0); + __stack_pointer = $3 + 16 | 0; + return $0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______destruct_at_end_5babi_v160004_5d_28b2Vec2__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______invalidate_iterators_past_5babi_v160004_5d_28b2Vec2__29($0, HEAP32[$2 + 8 >> 2]); + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____size_5babi_v160004_5d_28_29_20const($0), + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______base_destruct_at_end_5babi_v160004_5d_28b2Vec2__29($0, HEAP32[$2 + 8 >> 2]); + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______annotate_shrink_5babi_v160004_5d_28unsigned_20long_29_20const($0, HEAP32[$2 + 4 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function b2CircleShape__ComputeAABB_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 28 >> 2] = $0; + HEAP32[$4 + 24 >> 2] = $1; + HEAP32[$4 + 20 >> 2] = $2; + HEAP32[$4 + 16 >> 2] = $3; + $1 = HEAP32[$4 + 20 >> 2]; + $0 = HEAP32[$4 + 28 >> 2]; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($4, HEAP32[$4 + 20 >> 2] + 8 | 0, $0 + 12 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($4 + 8 | 0, $1, $4); + b2Vec2__Set_28float_2c_20float_29(HEAP32[$4 + 24 >> 2], Math_fround(HEAPF32[$4 + 8 >> 2] - HEAPF32[$0 + 8 >> 2]), Math_fround(HEAPF32[$4 + 12 >> 2] - HEAPF32[$0 + 8 >> 2])); + b2Vec2__Set_28float_2c_20float_29(HEAP32[$4 + 24 >> 2] + 8 | 0, Math_fround(HEAPF32[$4 + 8 >> 2] + HEAPF32[$0 + 8 >> 2]), Math_fround(HEAPF32[$4 + 12 >> 2] + HEAPF32[$0 + 8 >> 2])); + __stack_pointer = $4 + 32 | 0; +} + +function __strchrnul($0, $1) { + var $2 = 0, $3 = 0; + label$1: { + $3 = $1 & 255; + if ($3) { + if ($0 & 3) { + while (1) { + $2 = HEAPU8[$0 | 0]; + if (!$2 | ($1 & 255) == ($2 | 0)) { + break label$1; + } + $0 = $0 + 1 | 0; + if ($0 & 3) { + continue; + } + break; + } + } + $2 = HEAP32[$0 >> 2]; + label$5: { + if (($2 ^ -1) & $2 - 16843009 & -2139062144) { + break label$5; + } + $3 = Math_imul($3, 16843009); + while (1) { + $2 = $2 ^ $3; + if (($2 ^ -1) & $2 - 16843009 & -2139062144) { + break label$5; + } + $2 = HEAP32[$0 + 4 >> 2]; + $0 = $0 + 4 | 0; + if (!($2 - 16843009 & ($2 ^ -1) & -2139062144)) { + continue; + } + break; + } + } + while (1) { + $2 = $0; + $3 = HEAPU8[$2 | 0]; + if ($3) { + $0 = $2 + 1 | 0; + if (($1 & 255) != ($3 | 0)) { + continue; + } + } + break; + } + return $2; + } + return strlen($0) + $0 | 0; + } + return $0; +} + +function __cxxabiv1____class_type_info__process_static_type_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_29_20const($0, $1, $2, $3, $4) { + HEAP8[$1 + 53 | 0] = 1; + label$1: { + if (HEAP32[$1 + 4 >> 2] != ($3 | 0)) { + break label$1; + } + HEAP8[$1 + 52 | 0] = 1; + $3 = HEAP32[$1 + 16 >> 2]; + label$2: { + if (!$3) { + HEAP32[$1 + 36 >> 2] = 1; + HEAP32[$1 + 24 >> 2] = $4; + HEAP32[$1 + 16 >> 2] = $2; + if (($4 | 0) != 1) { + break label$1; + } + if (HEAP32[$1 + 48 >> 2] == 1) { + break label$2; + } + break label$1; + } + if (($2 | 0) == ($3 | 0)) { + $3 = HEAP32[$1 + 24 >> 2]; + if (($3 | 0) == 2) { + HEAP32[$1 + 24 >> 2] = $4; + $3 = $4; + } + if (HEAP32[$1 + 48 >> 2] != 1) { + break label$1; + } + if (($3 | 0) == 1) { + break label$2; + } + break label$1; + } + HEAP32[$1 + 36 >> 2] = HEAP32[$1 + 36 >> 2] + 1; + } + HEAP8[$1 + 54 | 0] = 1; + } +} + +function emscripten__internal__WireTypePack_int_20const____WireTypePack_28int_20const__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + $0 = HEAP32[$2 + 20 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__array_emscripten__internal__GenericWireType_2c_201ul___data_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + $1 = HEAP32[$2 + 16 >> 2]; + HEAP32[$2 + 28 >> 2] = $2 + 12; + HEAP32[$2 + 24 >> 2] = $1; + void_20emscripten__internal__writeGenericWireType_int__28emscripten__internal__GenericWireType___2c_20int_29(HEAP32[$2 + 28 >> 2], emscripten__internal__BindingType_int_2c_20void___toWireType_28int_20const__29(HEAP32[$2 + 24 >> 2])); + emscripten__internal__writeGenericWireTypes_28emscripten__internal__GenericWireType___29(HEAP32[$2 + 28 >> 2]); + __stack_pointer = $2 + 32 | 0; + return $0; +} + +function emscripten__internal__MethodInvoker_int_20_28b2Shape____29_28_29_20const_2c_20int_2c_20b2Shape_20const____invoke_28int_20_28b2Shape____20const__29_28_29_20const_2c_20b2Shape_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Shape_20const__2c_20void___fromWireType_28b2Shape_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + wasm2js_i32$0 = $2, wasm2js_i32$1 = FUNCTION_TABLE[$0 | 0]($1) | 0, HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = emscripten__internal__BindingType_int_2c_20void___toWireType_28int_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Fixture__RayCast_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0, wasm2js_i32$4 = 0, wasm2js_i32$5 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $0 = HEAP32[$4 + 12 >> 2]; + $1 = HEAP32[$0 + 12 >> 2]; + $0 = (wasm2js_i32$1 = $1, wasm2js_i32$2 = HEAP32[$4 + 8 >> 2], wasm2js_i32$3 = HEAP32[$4 + 4 >> 2], + wasm2js_i32$4 = b2Body__GetTransform_28_29_20const(HEAP32[$0 + 8 >> 2]), wasm2js_i32$5 = HEAP32[$4 >> 2], + wasm2js_i32$0 = HEAP32[HEAP32[$1 >> 2] + 20 >> 2], FUNCTION_TABLE[wasm2js_i32$0](wasm2js_i32$1 | 0, wasm2js_i32$2 | 0, wasm2js_i32$3 | 0, wasm2js_i32$4 | 0, wasm2js_i32$5 | 0) | 0); + __stack_pointer = $4 + 16 | 0; + return $0 & 1; +} + +function std____2__set_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____insert_5babi_v160004_5d_28b2Fixture__20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______insert_unique_5babi_v160004_5d_28b2Fixture__20const__29($3, HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2]); + std____2__pair_std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__2c_20bool___pair_5babi_v160004_5d_std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__2c_20bool_2c_20_28void__290__28std____2__pair_std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__2c_20bool____29($0, $3); + __stack_pointer = $3 + 16 | 0; +} + +function b2EdgeShape__operator__28b2EdgeShape_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, $5 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + $5 = HEAP32[$3 + 12 >> 2]; + b2Shape__operator__28b2Shape_20const__29($5, HEAP32[$3 + 8 >> 2]); + $2 = HEAP32[$3 + 8 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$2 + 16 >> 2]; + $4 = $0; + $0 = $5; + HEAP32[$0 + 12 >> 2] = $4; + HEAP32[$0 + 16 >> 2] = $1; + HEAP8[$0 + 44 | 0] = HEAPU8[$2 + 44 | 0]; + $0 = HEAP32[$2 + 40 >> 2]; + $1 = HEAP32[$2 + 36 >> 2]; + $4 = $1; + $1 = $5; + HEAP32[$1 + 36 >> 2] = $4; + HEAP32[$1 + 40 >> 2] = $0; + $1 = HEAP32[$2 + 32 >> 2]; + $0 = HEAP32[$2 + 28 >> 2]; + $4 = $0; + $0 = $5; + HEAP32[$0 + 28 >> 2] = $4; + HEAP32[$0 + 32 >> 2] = $1; + $0 = HEAP32[$2 + 24 >> 2]; + $1 = HEAP32[$2 + 20 >> 2]; + $4 = $1; + $1 = $5; + HEAP32[$1 + 20 >> 2] = $4; + HEAP32[$1 + 24 >> 2] = $0; + __stack_pointer = $3 + 16 | 0; + return $1; +} + +function emscripten__internal__MethodInvoker_void_20_28b2ContactListener____29_28unsigned_20int_29_2c_20void_2c_20b2ContactListener__2c_20unsigned_20int___invoke_28void_20_28b2ContactListener____20const__29_28unsigned_20int_29_2c_20b2ContactListener__2c_20unsigned_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2ContactListener__2c_20void___fromWireType_28b2ContactListener__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__Invoker_float_2c_20unsigned_20int_2c_20int___invoke_28float_20_28__29_28unsigned_20int_2c_20int_29_2c_20unsigned_20int_2c_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, $4 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + wasm2js_i32$0 = $3, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$3 + 8 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$3 + 4 >> 2]))), + HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0; + $4 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($3); + __stack_pointer = $3 + 16 | 0; + return Math_fround($4); +} + +function std____2__reverse_iterator_int___20std____2____rewrap_iter_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false___28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 16 >> 2] = HEAP32[$2 + 24 >> 2]; + HEAP32[$2 + 12 >> 2] = HEAP32[$2 + 20 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false_____rewrap_5babi_v160004_5d_28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29(HEAP32[$2 + 16 >> 2], HEAP32[$2 + 12 >> 2]), + HEAP32[wasm2js_i32$0 + 28 >> 2] = wasm2js_i32$1; + __stack_pointer = $2 + 32 | 0; + return HEAP32[$2 + 28 >> 2]; +} + +function float_20emscripten__val__call_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float___28char_20const__2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float__29_20const($0, $1, $2, $3, $4, $5) { + var $6 = 0, $7 = Math_fround(0); + $6 = __stack_pointer - 32 | 0; + __stack_pointer = $6; + HEAP32[$6 + 28 >> 2] = $0; + HEAP32[$6 + 24 >> 2] = $1; + HEAP32[$6 + 20 >> 2] = $2; + HEAP32[$6 + 16 >> 2] = $3; + HEAP32[$6 + 12 >> 2] = $4; + HEAP32[$6 + 8 >> 2] = $5; + $7 = emscripten__internal__MethodCaller_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____call_28emscripten___EM_VAL__2c_20char_20const__2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float__29(HEAP32[HEAP32[$6 + 28 >> 2] >> 2], HEAP32[$6 + 24 >> 2], HEAP32[$6 + 20 >> 2], HEAP32[$6 + 16 >> 2], HEAP32[$6 + 12 >> 2], HEAP32[$6 + 8 >> 2]); + __stack_pointer = $6 + 32 | 0; + return $7; +} + +function b2StackAllocator__Free_28void__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAP32[$0 + 102796 >> 2] <= 0) { + __assert_fail(12178, 5418, 67, 9825); + wasm2js_trap(); + } + HEAP32[$2 + 4 >> 2] = (Math_imul(HEAP32[$0 + 102796 >> 2], 12) + $0 | 0) + 102400; + if (HEAP32[$2 + 8 >> 2] != HEAP32[HEAP32[$2 + 4 >> 2] >> 2]) { + __assert_fail(10408, 5418, 69, 9825); + wasm2js_trap(); + } + label$3: { + if (HEAP8[HEAP32[$2 + 4 >> 2] + 8 | 0] & 1) { + b2Free_28void__29(HEAP32[$2 + 8 >> 2]); + break label$3; + } + HEAP32[$0 + 102400 >> 2] = HEAP32[$0 + 102400 >> 2] - HEAP32[HEAP32[$2 + 4 >> 2] + 4 >> 2]; + } + HEAP32[$0 + 102404 >> 2] = HEAP32[$0 + 102404 >> 2] - HEAP32[HEAP32[$2 + 4 >> 2] + 4 >> 2]; + HEAP32[$0 + 102796 >> 2] = HEAP32[$0 + 102796 >> 2] - 1; + HEAP32[$2 + 8 >> 2] = 0; + __stack_pointer = $2 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2PrismaticJointDef__20_28__29_28_29___invoke_b2PrismaticJointDef__28b2PrismaticJointDef__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 640; + $0 = emscripten__internal__TypeID_b2PrismaticJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2PrismaticJointDef____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2PrismaticJointDef____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function b2Sweep__Advance_28float_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAPF32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + if (!(HEAPF32[$0 + 32 >> 2] < Math_fround(1))) { + __assert_fail(8093, 7280, 696, 9975); + wasm2js_trap(); + } + HEAPF32[$2 + 20 >> 2] = Math_fround(HEAPF32[$2 + 24 >> 2] - HEAPF32[$0 + 32 >> 2]) / Math_fround(Math_fround(1) - HEAPF32[$0 + 32 >> 2]); + $1 = HEAPF32[$2 + 20 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 4 | 0, $0 + 16 | 0, $0 + 8 | 0); + operator__28float_2c_20b2Vec2_20const__29($2 + 12 | 0, $1, $2 + 4 | 0); + b2Vec2__operator___28b2Vec2_20const__29($0 + 8 | 0, $2 + 12 | 0); + HEAPF32[$0 + 24 >> 2] = Math_fround(HEAPF32[$2 + 20 >> 2] * Math_fround(HEAPF32[$0 + 28 >> 2] - HEAPF32[$0 + 24 >> 2])) + HEAPF32[$0 + 24 >> 2]; + HEAPF32[$0 + 32 >> 2] = HEAPF32[$2 + 24 >> 2]; + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2RevoluteJointDef__20_28__29_28_29___invoke_b2RevoluteJointDef__28b2RevoluteJointDef__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 653; + $0 = emscripten__internal__TypeID_b2RevoluteJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2RevoluteJointDef____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2RevoluteJointDef____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2DistanceJointDef__20_28__29_28_29___invoke_b2DistanceJointDef__28b2DistanceJointDef__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 611; + $0 = emscripten__internal__TypeID_b2DistanceJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2DistanceJointDef____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2DistanceJointDef____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Fixture____29_28b2MassData__29_20const_2c_20void_2c_20b2Fixture_20const__2c_20b2MassData____invoke_28void_20_28b2Fixture____20const__29_28b2MassData__29_20const_2c_20b2Fixture_20const__2c_20b2MassData__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2Fixture_20const__2c_20void___fromWireType_28b2Fixture_20const__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2MassData__2c_20void___fromWireType_28b2MassData__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__Invoker_unsigned_20int_2c_20unsigned_20int_2c_20int___invoke_28unsigned_20int_20_28__29_28unsigned_20int_2c_20int_29_2c_20unsigned_20int_2c_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$3 + 8 >> 2]), emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$3 + 4 >> 2])) | 0, + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + $0 = emscripten__internal__BindingType_unsigned_20int_2c_20void___toWireType_28unsigned_20int_20const__29($3); + __stack_pointer = $3 + 16 | 0; + return $0 | 0; +} + +function float_20emscripten__wrapper_b2RayCastCallback___call_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float___28char_20const__2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float__29_20const($0, $1, $2, $3, $4, $5) { + var $6 = 0, $7 = Math_fround(0); + $6 = __stack_pointer - 32 | 0; + __stack_pointer = $6; + HEAP32[$6 + 28 >> 2] = $0; + HEAP32[$6 + 24 >> 2] = $1; + HEAP32[$6 + 20 >> 2] = $2; + HEAP32[$6 + 16 >> 2] = $3; + HEAP32[$6 + 12 >> 2] = $4; + HEAP32[$6 + 8 >> 2] = $5; + $7 = float_20emscripten__val__call_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float___28char_20const__2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float__29_20const(HEAP32[$6 + 28 >> 2] + 8 | 0, HEAP32[$6 + 24 >> 2], HEAP32[$6 + 20 >> 2], HEAP32[$6 + 16 >> 2], HEAP32[$6 + 12 >> 2], HEAP32[$6 + 8 >> 2]); + __stack_pointer = $6 + 32 | 0; + return $7; +} + +function std____2__vector_int_2c_20std____2__allocator_int______destruct_at_end_5babi_v160004_5d_28int__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + std____2__vector_int_2c_20std____2__allocator_int______invalidate_iterators_past_5babi_v160004_5d_28int__29($0, HEAP32[$2 + 8 >> 2]); + wasm2js_i32$0 = $2, wasm2js_i32$1 = std____2__vector_int_2c_20std____2__allocator_int____size_5babi_v160004_5d_28_29_20const($0), + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + std____2__vector_int_2c_20std____2__allocator_int______base_destruct_at_end_5babi_v160004_5d_28int__29($0, HEAP32[$2 + 8 >> 2]); + std____2__vector_int_2c_20std____2__allocator_int______annotate_shrink_5babi_v160004_5d_28unsigned_20long_29_20const($0, HEAP32[$2 + 4 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function __cxxabiv1____class_type_info__can_catch_28__cxxabiv1____shim_type_info_20const__2c_20void___29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, $4 = 0; + $3 = __stack_pointer + -64 | 0; + __stack_pointer = $3; + $4 = 1; + label$1: { + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, $1, 0)) { + break label$1; + } + $4 = 0; + if (!$1) { + break label$1; + } + $1 = __dynamic_cast($1, 23924, 23972, 0); + $4 = 0; + if (!$1) { + break label$1; + } + __memset($3 + 12 | 0, 0, 52); + HEAP32[$3 + 56 >> 2] = 1; + HEAP32[$3 + 20 >> 2] = -1; + HEAP32[$3 + 16 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 28 >> 2]]($1, $3 + 8 | 0, HEAP32[$2 >> 2], 1); + $4 = HEAP32[$3 + 32 >> 2]; + if (($4 | 0) == 1) { + HEAP32[$2 >> 2] = HEAP32[$3 + 24 >> 2]; + } + $4 = ($4 | 0) == 1; + } + __stack_pointer = $3 - -64 | 0; + return $4 | 0; +} + +function void_20emscripten__function_void_2c_20unsigned_20int_2c_20unsigned_20int__28char_20const__2c_20void_20_28__29_28unsigned_20int_2c_20unsigned_20int_29_29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 406; + $0 = HEAP32[$2 + 24 >> 2]; + $1 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int_2c_20unsigned_20int___getCount_28_29_20const($2 + 19 | 0); + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int_2c_20unsigned_20int___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_function($0 | 0, $1 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 20 >> 2], 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2World__20_28__29_28b2Vec2___29___invoke_b2World__28b2World__20_28__29_28b2Vec2___29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 505; + $0 = emscripten__internal__TypeID_b2World_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2World__2c_20b2Vec2_____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2World__2c_20b2Vec2_____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__function_unsigned_20int_2c_20emscripten__allow_raw_pointers__28char_20const__2c_20unsigned_20int_20_28__29_28_29_2c_20emscripten__allow_raw_pointers_29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + HEAP32[$2 + 8 >> 2] = 408; + $0 = HEAP32[$2 + 20 >> 2]; + $1 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_unsigned_20int___getCount_28_29_20const($2 + 15 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_unsigned_20int___getTypes_28_29_20const($2 + 15 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 8 >> 2]; + _embind_register_function($0 | 0, $1 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$2 + 8 >> 2], HEAP32[$2 + 16 >> 2], 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__function_unsigned_20int_2c_20unsigned_20int_2c_20int__28char_20const__2c_20unsigned_20int_20_28__29_28unsigned_20int_2c_20int_29_29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 407; + $0 = HEAP32[$2 + 24 >> 2]; + $1 = emscripten__internal__WithPolicies____ArgTypeList_unsigned_20int_2c_20unsigned_20int_2c_20int___getCount_28_29_20const($2 + 19 | 0); + $3 = emscripten__internal__WithPolicies____ArgTypeList_unsigned_20int_2c_20unsigned_20int_2c_20int___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_function($0 | 0, $1 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 20 >> 2], 0); + __stack_pointer = $2 + 32 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2WheelJointDef__20_28__29_28_29___invoke_b2WheelJointDef__28b2WheelJointDef__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 686; + $0 = emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2WheelJointDef____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2WheelJointDef____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2MouseJointDef__20_28__29_28_29___invoke_b2MouseJointDef__28b2MouseJointDef__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 630; + $0 = emscripten__internal__TypeID_b2MouseJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2MouseJointDef____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2MouseJointDef____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2MotorJointDef__20_28__29_28_29___invoke_b2MotorJointDef__28b2MotorJointDef__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 620; + $0 = emscripten__internal__TypeID_b2MotorJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2MotorJointDef____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2MotorJointDef____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2ContactListener__29_2c_20void_2c_20b2World__2c_20b2ContactListener____invoke_28void_20_28b2World____20const__29_28b2ContactListener__29_2c_20b2World__2c_20b2ContactListener__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2World__2c_20void___fromWireType_28b2World__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2ContactListener__2c_20void___fromWireType_28b2ContactListener__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2MassData__29_20const_2c_20void_2c_20b2Body_20const__2c_20b2MassData____invoke_28void_20_28b2Body____20const__29_28b2MassData__29_20const_2c_20b2Body_20const__2c_20b2MassData__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2Body_20const__2c_20void___fromWireType_28b2Body_20const__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2MassData__2c_20void___fromWireType_28b2MassData__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2PrismaticJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2PrismaticJoint_20const____invoke_28b2Vec2_20const__20_28b2PrismaticJoint____20const__29_28_29_20const_2c_20b2PrismaticJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2PrismaticJoint_20const__2c_20void___fromWireType_28b2PrismaticJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______base_destruct_at_end_5babi_v160004_5d_28b2Vec2__29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 4 >> 2] = HEAP32[$0 + 4 >> 2]; + while (1) { + if (HEAP32[$2 + 8 >> 2] != HEAP32[$2 + 4 >> 2]) { + $3 = std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______alloc_5babi_v160004_5d_28_29($0); + $1 = HEAP32[$2 + 4 >> 2] - 8 | 0; + HEAP32[$2 + 4 >> 2] = $1; + void_20std____2__allocator_traits_std____2__allocator_b2Vec2____destroy_5babi_v160004_5d_b2Vec2_2c_20void__28std____2__allocator_b2Vec2___2c_20b2Vec2__29($3, b2Vec2__20std____2____to_address_5babi_v160004_5d_b2Vec2__28b2Vec2__29($1)); + continue; + } + break; + } + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 8 >> 2]; + __stack_pointer = $2 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2WeldJointDef__20_28__29_28_29___invoke_b2WeldJointDef__28b2WeldJointDef__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 677; + $0 = emscripten__internal__TypeID_b2WeldJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2WeldJointDef____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2WeldJointDef____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2RopeJointDef__20_28__29_28_29___invoke_b2RopeJointDef__28b2RopeJointDef__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 666; + $0 = emscripten__internal__TypeID_b2RopeJointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2RopeJointDef____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2RopeJointDef____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2PolygonShape__20_28__29_28_29___invoke_b2PolygonShape__28b2PolygonShape__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 547; + $0 = emscripten__internal__TypeID_b2PolygonShape_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2PolygonShape____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2PolygonShape____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2PrismaticJoint____29_28float_29_2c_20void_2c_20b2PrismaticJoint__2c_20float___invoke_28void_20_28b2PrismaticJoint____20const__29_28float_29_2c_20b2PrismaticJoint__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2PrismaticJoint__2c_20void___fromWireType_28b2PrismaticJoint__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodCaller_void_2c_20b2Transform_20const____call_28emscripten___EM_VAL__2c_20char_20const__2c_20b2Transform_20const__29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + wasm2js_i32$0 = $3, wasm2js_i32$1 = emscripten__internal__Signature_void_2c_20b2Transform_20const____get_method_caller_28_29(), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + emscripten__internal__WireTypePack_b2Transform_20const____WireTypePack_28b2Transform_20const__29($3 + 8 | 0, HEAP32[$3 + 20 >> 2]); + _emval_call_void_method(HEAP32[$3 + 16 >> 2], HEAP32[$3 + 28 >> 2], HEAP32[$3 + 24 >> 2], emscripten__internal__WireTypePack_b2Transform_20const____operator_20void_20const__28_29_20const($3 + 8 | 0) | 0); + __stack_pointer = $3 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2RevoluteJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2RevoluteJoint_20const____invoke_28b2Vec2_20const__20_28b2RevoluteJoint____20const__29_28_29_20const_2c_20b2RevoluteJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2RevoluteJoint_20const__2c_20void___fromWireType_28b2RevoluteJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2DistanceJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2DistanceJoint_20const____invoke_28b2Vec2_20const__20_28b2DistanceJoint____20const__29_28_29_20const_2c_20b2DistanceJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2DistanceJoint_20const__2c_20void___fromWireType_28b2DistanceJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function void_20emscripten__val__call_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const___28char_20const__2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const__29_20const($0, $1, $2, $3, $4, $5) { + var $6 = 0; + $6 = __stack_pointer - 32 | 0; + __stack_pointer = $6; + HEAP32[$6 + 28 >> 2] = $0; + HEAP32[$6 + 24 >> 2] = $1; + HEAP32[$6 + 20 >> 2] = $2; + HEAP32[$6 + 16 >> 2] = $3; + HEAP32[$6 + 12 >> 2] = $4; + HEAP32[$6 + 8 >> 2] = $5; + emscripten__internal__MethodCaller_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const____call_28emscripten___EM_VAL__2c_20char_20const__2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const__29(HEAP32[HEAP32[$6 + 28 >> 2] >> 2], HEAP32[$6 + 24 >> 2], HEAP32[$6 + 20 >> 2], HEAP32[$6 + 16 >> 2], HEAP32[$6 + 12 >> 2], HEAP32[$6 + 8 >> 2]); + __stack_pointer = $6 + 32 | 0; +} + +function b2GrowableStack_int_2c_20256___Push_28int_20const__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAP32[$0 + 1028 >> 2] == HEAP32[$0 + 1032 >> 2]) { + HEAP32[$2 + 4 >> 2] = HEAP32[$0 >> 2]; + HEAP32[$0 + 1032 >> 2] = HEAP32[$0 + 1032 >> 2] << 1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Alloc_28int_29(HEAP32[$0 + 1032 >> 2] << 2), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + __memcpy(HEAP32[$0 >> 2], HEAP32[$2 + 4 >> 2], HEAP32[$0 + 1028 >> 2] << 2); + if (HEAP32[$2 + 4 >> 2] != ($0 + 4 | 0)) { + b2Free_28void__29(HEAP32[$2 + 4 >> 2]); + } + } + HEAP32[HEAP32[$0 >> 2] + (HEAP32[$0 + 1028 >> 2] << 2) >> 2] = HEAP32[HEAP32[$2 + 8 >> 2] >> 2]; + HEAP32[$0 + 1028 >> 2] = HEAP32[$0 + 1028 >> 2] + 1; + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__FunctionInvoker_void_20_28__29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29_2c_20void_2c_20b2AABB__2c_20b2AABB__2c_20b2AABB____invoke_28void_20_28___29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29_2c_20b2AABB__2c_20b2AABB__2c_20b2AABB__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $0 = HEAP32[HEAP32[$4 + 12 >> 2] >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_b2AABB__2c_20void___fromWireType_28b2AABB__29(HEAP32[$4 + 8 >> 2]), emscripten__internal__BindingType_b2AABB__2c_20void___fromWireType_28b2AABB__29(HEAP32[$4 + 4 >> 2]), emscripten__internal__BindingType_b2AABB__2c_20void___fromWireType_28b2AABB__29(HEAP32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2CircleShape__20_28__29_28_29___invoke_b2CircleShape__28b2CircleShape__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 530; + $0 = emscripten__internal__TypeID_b2CircleShape_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2CircleShape____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2CircleShape____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2RevoluteJoint____29_28float_29_2c_20void_2c_20b2RevoluteJoint__2c_20float___invoke_28void_20_28b2RevoluteJoint____20const__29_28float_29_2c_20b2RevoluteJoint__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2RevoluteJoint__2c_20void___fromWireType_28b2RevoluteJoint__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2DistanceJoint____29_28float_29_2c_20void_2c_20b2DistanceJoint__2c_20float___invoke_28void_20_28b2DistanceJoint____20const__29_28float_29_2c_20b2DistanceJoint__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2DistanceJoint__2c_20void___fromWireType_28b2DistanceJoint__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function __fwritex($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0; + $3 = HEAP32[$2 + 16 >> 2]; + label$1: { + if (!$3) { + if (__towrite($2)) { + break label$1; + } + $3 = HEAP32[$2 + 16 >> 2]; + } + $5 = HEAP32[$2 + 20 >> 2]; + if ($3 - $5 >>> 0 < $1 >>> 0) { + return FUNCTION_TABLE[HEAP32[$2 + 36 >> 2]]($2, $0, $1) | 0; + } + label$4: { + if (HEAP32[$2 + 80 >> 2] < 0) { + $3 = 0; + break label$4; + } + $4 = $1; + while (1) { + $3 = $4; + if (!$3) { + $3 = 0; + break label$4; + } + $4 = $3 - 1 | 0; + if (HEAPU8[$4 + $0 | 0] != 10) { + continue; + } + break; + } + $4 = FUNCTION_TABLE[HEAP32[$2 + 36 >> 2]]($2, $0, $3) | 0; + if ($4 >>> 0 < $3 >>> 0) { + break label$1; + } + $0 = $0 + $3 | 0; + $1 = $1 - $3 | 0; + $5 = HEAP32[$2 + 20 >> 2]; + } + __memcpy($5, $0, $1); + HEAP32[$2 + 20 >> 2] = HEAP32[$2 + 20 >> 2] + $1; + $4 = $1 + $3 | 0; + } + return $4; +} + +function emscripten__value_object_b2RayCastOutput___value_object_28char_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, $5 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + $0 = HEAP32[$2 + 20 >> 2]; + emscripten__internal__noncopyable__noncopyable_28_29($0); + HEAP32[$2 + 12 >> 2] = 450; + HEAP32[$2 + 8 >> 2] = 451; + $1 = emscripten__internal__TypeID_b2RayCastOutput_2c_20void___get_28_29(); + $3 = HEAP32[$2 + 16 >> 2]; + HEAP32[$2 + 24 >> 2] = HEAP32[$2 + 12 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_int__28_29(); + $5 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 8 >> 2]; + _embind_register_value_object($1 | 0, $3 | 0, $4 | 0, $5 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 32 | 0; + return $0; +} + +function emscripten__class__b2RayCastCallback_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2RayCastCallback_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2RayCastCallbackWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2RayCastCallbackWrapper__29____invoke_28b2RayCastCallbackWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + emscripten__class__b2RayCastCallback_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2RayCastCallback_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2RayCastCallbackWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2RayCastCallbackWrapper__29__operator_28_29_28b2RayCastCallbackWrapper__29_20const($1 + 11 | 0, HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__class__b2ContactListener_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2ContactListener_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2ContactListenerWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2ContactListenerWrapper__29____invoke_28b2ContactListenerWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + emscripten__class__b2ContactListener_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2ContactListener_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2ContactListenerWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2ContactListenerWrapper__29__operator_28_29_28b2ContactListenerWrapper__29_20const($1 + 11 | 0, HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__value_object_b2RayCastInput___value_object_28char_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, $5 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + $0 = HEAP32[$2 + 20 >> 2]; + emscripten__internal__noncopyable__noncopyable_28_29($0); + HEAP32[$2 + 12 >> 2] = 444; + HEAP32[$2 + 8 >> 2] = 445; + $1 = emscripten__internal__TypeID_b2RayCastInput_2c_20void___get_28_29(); + $3 = HEAP32[$2 + 16 >> 2]; + HEAP32[$2 + 24 >> 2] = HEAP32[$2 + 12 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_int__28_29(); + $5 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 8 >> 2]; + _embind_register_value_object($1 | 0, $3 | 0, $4 | 0, $5 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 32 | 0; + return $0; +} + +function emscripten__internal__VectorAccess_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____get_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + label$1: { + if (HEAPU32[$3 + 4 >> 2] < std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____size_5babi_v160004_5d_28_29_20const(HEAP32[$3 + 8 >> 2]) >>> 0) { + emscripten__val__val_b2Vec2_20const___28b2Vec2_20const__29($0, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____operator_5b_5d_5babi_v160004_5d_28unsigned_20long_29_20const(HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2])); + break label$1; + } + emscripten__val__undefined_28_29($0); + } + __stack_pointer = $3 + 16 | 0; +} + +function b2MulT_28b2Transform_20const__2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $1; + HEAP32[$3 + 24 >> 2] = $2; + HEAPF32[$3 + 20 >> 2] = HEAPF32[HEAP32[$3 + 24 >> 2] >> 2] - HEAPF32[HEAP32[$3 + 28 >> 2] >> 2]; + HEAPF32[$3 + 16 >> 2] = HEAPF32[HEAP32[$3 + 24 >> 2] + 4 >> 2] - HEAPF32[HEAP32[$3 + 28 >> 2] + 4 >> 2]; + HEAPF32[$3 + 12 >> 2] = Math_fround(HEAPF32[HEAP32[$3 + 28 >> 2] + 12 >> 2] * HEAPF32[$3 + 20 >> 2]) + Math_fround(HEAPF32[HEAP32[$3 + 28 >> 2] + 8 >> 2] * HEAPF32[$3 + 16 >> 2]); + HEAPF32[$3 + 8 >> 2] = Math_fround(Math_fround(-HEAPF32[HEAP32[$3 + 28 >> 2] + 8 >> 2]) * HEAPF32[$3 + 20 >> 2]) + Math_fround(HEAPF32[HEAP32[$3 + 28 >> 2] + 12 >> 2] * HEAPF32[$3 + 16 >> 2]); + b2Vec2__b2Vec2_28float_2c_20float_29($0, HEAPF32[$3 + 12 >> 2], HEAPF32[$3 + 8 >> 2]); + __stack_pointer = $3 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2MouseJoint____29_28b2Vec2_20const__29_2c_20void_2c_20b2MouseJoint__2c_20b2Vec2_20const____invoke_28void_20_28b2MouseJoint____20const__29_28b2Vec2_20const__29_2c_20b2MouseJoint__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2MouseJoint__2c_20void___fromWireType_28b2MouseJoint__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2MotorJoint____29_28b2Vec2_20const__29_2c_20void_2c_20b2MotorJoint__2c_20b2Vec2_20const____invoke_28void_20_28b2MotorJoint____20const__29_28b2Vec2_20const__29_2c_20b2MotorJoint__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2MotorJoint__2c_20void___fromWireType_28b2MotorJoint__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2FixtureDef__20_28__29_28_29___invoke_b2FixtureDef__28b2FixtureDef__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 558; + $0 = emscripten__internal__TypeID_b2FixtureDef_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2FixtureDef____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2FixtureDef____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__value_object_b2Transform___value_object_28char_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, $5 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + $0 = HEAP32[$2 + 20 >> 2]; + emscripten__internal__noncopyable__noncopyable_28_29($0); + HEAP32[$2 + 12 >> 2] = 434; + HEAP32[$2 + 8 >> 2] = 435; + $1 = emscripten__internal__TypeID_b2Transform_2c_20void___get_28_29(); + $3 = HEAP32[$2 + 16 >> 2]; + HEAP32[$2 + 24 >> 2] = HEAP32[$2 + 12 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_int__28_29(); + $5 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 8 >> 2]; + _embind_register_value_object($1 | 0, $3 | 0, $4 | 0, $5 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 32 | 0; + return $0; +} + +function std____2__pair_std____2____unwrap_ref_decay_std____2__reverse_iterator_b2Vec2_____type_2c_20std____2____unwrap_ref_decay_std____2__reverse_iterator_b2Vec2_____type__20std____2__make_pair_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2____28std____2__reverse_iterator_b2Vec2_____2c_20std____2__reverse_iterator_b2Vec2_____29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + std____2__pair_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2_____pair_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20_28void__290__28std____2__reverse_iterator_b2Vec2_____2c_20std____2__reverse_iterator_b2Vec2_____29($0, HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2PrismaticJoint____29_28bool_29_2c_20void_2c_20b2PrismaticJoint__2c_20bool___invoke_28void_20_28b2PrismaticJoint____20const__29_28bool_29_2c_20b2PrismaticJoint__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2 & 1; + $2 = emscripten__internal__BindingType_b2PrismaticJoint__2c_20void___fromWireType_28b2PrismaticJoint__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$3 + 7 | 0] & 1) & 1); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Fixture____29_28b2Filter_20const__29_2c_20void_2c_20b2Fixture__2c_20b2Filter_20const____invoke_28void_20_28b2Fixture____20const__29_28b2Filter_20const__29_2c_20b2Fixture__2c_20b2Filter__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2Fixture__2c_20void___fromWireType_28b2Fixture__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Filter___fromWireType_28b2Filter__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Draw____29_28b2Transform_20const__29_2c_20void_2c_20b2Draw__2c_20b2Transform_20const____invoke_28void_20_28b2Draw____20const__29_28b2Transform_20const__29_2c_20b2Draw__2c_20b2Transform__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2Draw__2c_20void___fromWireType_28b2Draw__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__value_object_b2MassData___value_object_28char_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, $5 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + $0 = HEAP32[$2 + 20 >> 2]; + emscripten__internal__noncopyable__noncopyable_28_29($0); + HEAP32[$2 + 12 >> 2] = 456; + HEAP32[$2 + 8 >> 2] = 457; + $1 = emscripten__internal__TypeID_b2MassData_2c_20void___get_28_29(); + $3 = HEAP32[$2 + 16 >> 2]; + HEAP32[$2 + 24 >> 2] = HEAP32[$2 + 12 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_int__28_29(); + $5 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 8 >> 2]; + _embind_register_value_object($1 | 0, $3 | 0, $4 | 0, $5 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 32 | 0; + return $0; +} + +function b2PrismaticJoint__GetJointTranslation_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer - 48 | 0; + __stack_pointer = $1; + HEAP32[$1 + 44 >> 2] = $0; + $0 = HEAP32[$1 + 44 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($1 + 36 | 0, HEAP32[$0 + 48 >> 2], $0 + 68 | 0); + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($1 + 28 | 0, HEAP32[$0 + 52 >> 2], $0 + 76 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 20 | 0, $1 + 28 | 0, $1 + 36 | 0); + b2Body__GetWorldVector_28b2Vec2_20const__29_20const($1 + 12 | 0, HEAP32[$0 + 48 >> 2], $0 + 84 | 0); + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 20 | 0, $1 + 12 | 0), + HEAPF32[wasm2js_i32$0 + 8 >> 2] = wasm2js_f32$0; + __stack_pointer = $1 + 48 | 0; + return Math_fround(HEAPF32[$1 + 8 >> 2]); +} + +function b2Simplex__WriteCache_28b2SimplexCache__29_20const($0, $1) { + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + $3 = b2Simplex__GetMetric_28_29_20const($0); + HEAPF32[HEAP32[$2 + 8 >> 2] >> 2] = $3; + HEAP16[HEAP32[$2 + 8 >> 2] + 4 >> 1] = HEAP32[$0 + 108 >> 2]; + HEAP32[$2 + 4 >> 2] = $0; + HEAP32[$2 >> 2] = 0; + while (1) { + if (HEAP32[$2 >> 2] < HEAP32[$0 + 108 >> 2]) { + HEAP8[HEAP32[$2 >> 2] + (HEAP32[$2 + 8 >> 2] + 6 | 0) | 0] = HEAP32[(HEAP32[$2 + 4 >> 2] + Math_imul(HEAP32[$2 >> 2], 36) | 0) + 28 >> 2]; + HEAP8[HEAP32[$2 >> 2] + (HEAP32[$2 + 8 >> 2] + 9 | 0) | 0] = HEAP32[(HEAP32[$2 + 4 >> 2] + Math_imul(HEAP32[$2 >> 2], 36) | 0) + 32 >> 2]; + HEAP32[$2 >> 2] = HEAP32[$2 >> 2] + 1; + continue; + } + break; + } + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2WheelJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2WheelJoint_20const____invoke_28b2Vec2_20const__20_28b2WheelJoint____20const__29_28_29_20const_2c_20b2WheelJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2WheelJoint_20const__2c_20void___fromWireType_28b2WheelJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2MouseJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2MouseJoint_20const____invoke_28b2Vec2_20const__20_28b2MouseJoint____20const__29_28_29_20const_2c_20b2MouseJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2MouseJoint_20const__2c_20void___fromWireType_28b2MouseJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2MotorJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2MotorJoint_20const____invoke_28b2Vec2_20const__20_28b2MotorJoint____20const__29_28_29_20const_2c_20b2MotorJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2MotorJoint_20const__2c_20void___fromWireType_28b2MotorJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function void_20emscripten__function_void_2c_20unsigned_20int_2c_20float__28char_20const__2c_20void_20_28__29_28unsigned_20int_2c_20float_29_29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 402; + $0 = HEAP32[$2 + 24 >> 2]; + $1 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int_2c_20float___getCount_28_29_20const($2 + 19 | 0); + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int_2c_20float___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_function($0 | 0, $1 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 20 >> 2], 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__value_object_b2Filter___value_object_28char_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, $5 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + $0 = HEAP32[$2 + 20 >> 2]; + emscripten__internal__noncopyable__noncopyable_28_29($0); + HEAP32[$2 + 12 >> 2] = 462; + HEAP32[$2 + 8 >> 2] = 463; + $1 = emscripten__internal__TypeID_b2Filter_2c_20void___get_28_29(); + $3 = HEAP32[$2 + 16 >> 2]; + HEAP32[$2 + 24 >> 2] = HEAP32[$2 + 12 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_int__28_29(); + $5 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 8 >> 2]; + _embind_register_value_object($1 | 0, $3 | 0, $4 | 0, $5 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 32 | 0; + return $0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2RevoluteJoint____29_28bool_29_2c_20void_2c_20b2RevoluteJoint__2c_20bool___invoke_28void_20_28b2RevoluteJoint____20const__29_28bool_29_2c_20b2RevoluteJoint__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2 & 1; + $2 = emscripten__internal__BindingType_b2RevoluteJoint__2c_20void___fromWireType_28b2RevoluteJoint__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$3 + 7 | 0] & 1) & 1); + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2JointDef__20_28__29_28_29___invoke_b2JointDef__28b2JointDef__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 599; + $0 = emscripten__internal__TypeID_b2JointDef_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2JointDef____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2JointDef____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__value_object_b2Color___value_object_28char_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, $5 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + $0 = HEAP32[$2 + 20 >> 2]; + emscripten__internal__noncopyable__noncopyable_28_29($0); + HEAP32[$2 + 12 >> 2] = 440; + HEAP32[$2 + 8 >> 2] = 441; + $1 = emscripten__internal__TypeID_b2Color_2c_20void___get_28_29(); + $3 = HEAP32[$2 + 16 >> 2]; + HEAP32[$2 + 24 >> 2] = HEAP32[$2 + 12 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_int__28_29(); + $5 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 8 >> 2]; + _embind_register_value_object($1 | 0, $3 | 0, $4 | 0, $5 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 32 | 0; + return $0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2WheelJoint____29_28float_29_2c_20void_2c_20b2WheelJoint__2c_20float___invoke_28void_20_28b2WheelJoint____20const__29_28float_29_2c_20b2WheelJoint__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2WheelJoint__2c_20void___fromWireType_28b2WheelJoint__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2MouseJoint____29_28float_29_2c_20void_2c_20b2MouseJoint__2c_20float___invoke_28void_20_28b2MouseJoint____20const__29_28float_29_2c_20b2MouseJoint__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2MouseJoint__2c_20void___fromWireType_28b2MouseJoint__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2MotorJoint____29_28float_29_2c_20void_2c_20b2MotorJoint__2c_20float___invoke_28void_20_28b2MotorJoint____20const__29_28float_29_2c_20b2MotorJoint__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2MotorJoint__2c_20void___fromWireType_28b2MotorJoint__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Draw____29_28unsigned_20int_29_2c_20void_2c_20b2Draw__2c_20unsigned_20int___invoke_28void_20_28b2Draw____20const__29_28unsigned_20int_29_2c_20b2Draw__2c_20unsigned_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2Draw__2c_20void___fromWireType_28b2Draw__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__wrapper_b2Draw___call_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const___28char_20const__2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const__29_20const($0, $1, $2, $3, $4, $5) { + var $6 = 0; + $6 = __stack_pointer - 32 | 0; + __stack_pointer = $6; + HEAP32[$6 + 28 >> 2] = $0; + HEAP32[$6 + 24 >> 2] = $1; + HEAP32[$6 + 20 >> 2] = $2; + HEAP32[$6 + 16 >> 2] = $3; + HEAP32[$6 + 12 >> 2] = $4; + HEAP32[$6 + 8 >> 2] = $5; + void_20emscripten__val__call_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const___28char_20const__2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const__29_20const(HEAP32[$6 + 28 >> 2] + 12 | 0, HEAP32[$6 + 24 >> 2], HEAP32[$6 + 20 >> 2], HEAP32[$6 + 16 >> 2], HEAP32[$6 + 12 >> 2], HEAP32[$6 + 8 >> 2]); + __stack_pointer = $6 + 32 | 0; +} + +function std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______destruct_at_end_5babi_v160004_5d_28b2Vec2__2c_20std____2__integral_constant_bool_2c_20false__29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 4 >> 2] = $1; + $0 = HEAP32[$2 + 8 >> 2]; + while (1) { + if (HEAP32[$2 + 4 >> 2] != HEAP32[$0 + 8 >> 2]) { + $3 = std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______alloc_5babi_v160004_5d_28_29($0); + $1 = HEAP32[$0 + 8 >> 2] - 8 | 0; + HEAP32[$0 + 8 >> 2] = $1; + void_20std____2__allocator_traits_std____2__allocator_b2Vec2____destroy_5babi_v160004_5d_b2Vec2_2c_20void__28std____2__allocator_b2Vec2___2c_20b2Vec2__29($3, b2Vec2__20std____2____to_address_5babi_v160004_5d_b2Vec2__28b2Vec2__29($1)); + continue; + } + break; + } + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__value_object_b2Vec2___value_object_28char_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, $5 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + $0 = HEAP32[$2 + 20 >> 2]; + emscripten__internal__noncopyable__noncopyable_28_29($0); + HEAP32[$2 + 12 >> 2] = 418; + HEAP32[$2 + 8 >> 2] = 419; + $1 = emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29(); + $3 = HEAP32[$2 + 16 >> 2]; + HEAP32[$2 + 24 >> 2] = HEAP32[$2 + 12 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_int__28_29(); + $5 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 8 >> 2]; + _embind_register_value_object($1 | 0, $3 | 0, $4 | 0, $5 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 32 | 0; + return $0; +} + +function void_20emscripten__function_float_2c_20unsigned_20int_2c_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_2c_20int_29_29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 397; + $0 = HEAP32[$2 + 24 >> 2]; + $1 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20unsigned_20int_2c_20int___getCount_28_29_20const($2 + 19 | 0); + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20unsigned_20int_2c_20int___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_function($0 | 0, $1 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 20 >> 2], 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2WeldJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2WeldJoint_20const____invoke_28b2Vec2_20const__20_28b2WeldJoint____20const__29_28_29_20const_2c_20b2WeldJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2WeldJoint_20const__2c_20void___fromWireType_28b2WeldJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2RopeJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2RopeJoint_20const____invoke_28b2Vec2_20const__20_28b2RopeJoint____20const__29_28_29_20const_2c_20b2RopeJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2RopeJoint_20const__2c_20void___fromWireType_28b2RopeJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function void_20emscripten__function_void_2c_20unsigned_20int_2c_20bool__28char_20const__2c_20void_20_28__29_28unsigned_20int_2c_20bool_29_29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 400; + $0 = HEAP32[$2 + 24 >> 2]; + $1 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int_2c_20bool___getCount_28_29_20const($2 + 19 | 0); + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int_2c_20bool___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_function($0 | 0, $1 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 20 >> 2], 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__value_object_b2Rot___value_object_28char_20const__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, $5 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 20 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $1; + $0 = HEAP32[$2 + 20 >> 2]; + emscripten__internal__noncopyable__noncopyable_28_29($0); + HEAP32[$2 + 12 >> 2] = 430; + HEAP32[$2 + 8 >> 2] = 431; + $1 = emscripten__internal__TypeID_b2Rot_2c_20void___get_28_29(); + $3 = HEAP32[$2 + 16 >> 2]; + HEAP32[$2 + 24 >> 2] = HEAP32[$2 + 12 >> 2]; + $4 = char_20const__20emscripten__internal__getGenericSignature_int__28_29(); + $5 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 8 >> 2]; + _embind_register_value_object($1 | 0, $3 | 0, $4 | 0, $5 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 32 | 0; + return $0; +} + +function emscripten__class__b2QueryCallback_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2QueryCallback_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2QueryCallbackWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2QueryCallbackWrapper__29____invoke_28b2QueryCallbackWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + emscripten__class__b2QueryCallback_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2QueryCallback_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2QueryCallbackWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2QueryCallbackWrapper__29__operator_28_29_28b2QueryCallbackWrapper__29_20const($1 + 11 | 0, HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_b2Filter_20const__20_28b2Fixture____29_28_29_20const_2c_20b2Filter_20const__2c_20b2Fixture_20const____invoke_28b2Filter_20const__20_28b2Fixture____20const__29_28_29_20const_2c_20b2Fixture_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Fixture_20const__2c_20void___fromWireType_28b2Fixture_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__GenericBindingType_b2Filter___toWireType_28b2Filter_20const__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function decltype_28std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false_____unwrap_28std__declval_std____2__reverse_iterator_b2Vec2____28_29_29_29_20std____2____unwrap_iter_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false__2c_200__28std____2__reverse_iterator_b2Vec2___29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 8 >> 2]; + wasm2js_i32$0 = $1, wasm2js_i32$1 = std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false_____unwrap_5babi_v160004_5d_28std____2__reverse_iterator_b2Vec2___29(HEAP32[$1 + 4 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2BodyDef__20_28__29_28_29___invoke_b2BodyDef__28b2BodyDef__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 576; + $0 = emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2BodyDef____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2BodyDef____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2WeldJoint____29_28float_29_2c_20void_2c_20b2WeldJoint__2c_20float___invoke_28void_20_28b2WeldJoint____20const__29_28float_29_2c_20b2WeldJoint__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2WeldJoint__2c_20void___fromWireType_28b2WeldJoint__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2RopeJoint____29_28float_29_2c_20void_2c_20b2RopeJoint__2c_20float___invoke_28void_20_28b2RopeJoint____20const__29_28float_29_2c_20b2RopeJoint__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2RopeJoint__2c_20void___fromWireType_28b2RopeJoint__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__val_20emscripten__internal__wrapped_extend_b2RayCastCallbackWrapper__28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + emscripten__val__take_ownership_28emscripten___EM_VAL__29($0, _embind_create_inheriting_constructor(std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____c_str_5babi_v160004_5d_28_29_20const(HEAP32[$3 + 8 >> 2]) | 0, emscripten__internal__TypeID_b2RayCastCallbackWrapper_2c_20void___get_28_29() | 0, emscripten__val__as_handle_28_29_20const(HEAP32[$3 + 4 >> 2]) | 0) | 0); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__val_20emscripten__internal__wrapped_extend_b2ContactListenerWrapper__28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + emscripten__val__take_ownership_28emscripten___EM_VAL__29($0, _embind_create_inheriting_constructor(std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____c_str_5babi_v160004_5d_28_29_20const(HEAP32[$3 + 8 >> 2]) | 0, emscripten__internal__TypeID_b2ContactListenerWrapper_2c_20void___get_28_29() | 0, emscripten__val__as_handle_28_29_20const(HEAP32[$3 + 4 >> 2]) | 0) | 0); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_b2Transform_20const__20_28b2Body____29_28_29_20const_2c_20b2Transform_20const__2c_20b2Body_20const____invoke_28b2Transform_20const__20_28b2Body____20const__29_28_29_20const_2c_20b2Body_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Body_20const__2c_20void___fromWireType_28b2Body_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__GenericBindingType_b2Transform___toWireType_28b2Transform_20const__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__MethodCaller_void_2c_20unsigned_20int____call_28emscripten___EM_VAL__2c_20char_20const__2c_20unsigned_20int__29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + wasm2js_i32$0 = $3, wasm2js_i32$1 = emscripten__internal__Signature_void_2c_20unsigned_20int____get_method_caller_28_29(), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + emscripten__internal__WireTypePack_unsigned_20int____WireTypePack_28unsigned_20int__29($3 + 8 | 0, HEAP32[$3 + 20 >> 2]); + _emval_call_void_method(HEAP32[$3 + 16 >> 2], HEAP32[$3 + 28 >> 2], HEAP32[$3 + 24 >> 2], emscripten__internal__WireTypePack_unsigned_20int____operator_20void_20const__28_29_20const($3 + 8 | 0) | 0); + __stack_pointer = $3 + 32 | 0; +} + +function b2BlockAllocator__b2BlockAllocator_28_29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 + 8 >> 2] = 128; + HEAP32[$0 + 4 >> 2] = 0; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Alloc_28int_29(HEAP32[$0 + 8 >> 2] << 3), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + __memset(HEAP32[$0 >> 2], 0, HEAP32[$0 + 8 >> 2] << 3); + HEAP32[$0 + 12 >> 2] = 0; + HEAP32[$0 + 16 >> 2] = 0; + HEAP32[$0 + 60 >> 2] = 0; + HEAP32[$0 + 64 >> 2] = 0; + HEAP32[$0 + 52 >> 2] = 0; + HEAP32[$0 + 56 >> 2] = 0; + HEAP32[$0 + 44 >> 2] = 0; + HEAP32[$0 + 48 >> 2] = 0; + HEAP32[$0 + 36 >> 2] = 0; + HEAP32[$0 + 40 >> 2] = 0; + HEAP32[$0 + 28 >> 2] = 0; + HEAP32[$0 + 32 >> 2] = 0; + HEAP32[$0 + 20 >> 2] = 0; + HEAP32[$0 + 24 >> 2] = 0; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______base_destruct_at_end_5babi_v160004_5d_28int__29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 4 >> 2] = HEAP32[$0 + 4 >> 2]; + while (1) { + if (HEAP32[$2 + 8 >> 2] != HEAP32[$2 + 4 >> 2]) { + $3 = std____2__vector_int_2c_20std____2__allocator_int______alloc_5babi_v160004_5d_28_29($0); + $1 = HEAP32[$2 + 4 >> 2] - 4 | 0; + HEAP32[$2 + 4 >> 2] = $1; + void_20std____2__allocator_traits_std____2__allocator_int____destroy_5babi_v160004_5d_int_2c_20void__28std____2__allocator_int___2c_20int__29($3, int__20std____2____to_address_5babi_v160004_5d_int__28int__29($1)); + continue; + } + break; + } + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 8 >> 2]; + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__val_20emscripten__internal__wrapped_extend_b2QueryCallbackWrapper__28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + emscripten__val__take_ownership_28emscripten___EM_VAL__29($0, _embind_create_inheriting_constructor(std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____c_str_5babi_v160004_5d_28_29_20const(HEAP32[$3 + 8 >> 2]) | 0, emscripten__internal__TypeID_b2QueryCallbackWrapper_2c_20void___get_28_29() | 0, emscripten__val__as_handle_28_29_20const(HEAP32[$3 + 4 >> 2]) | 0) | 0); + __stack_pointer = $3 + 16 | 0; +} + +function b2ChainAndPolygonContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$5 + 12 >> 2], 148), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$5 + 8 >> 2]; + b2ChainAndPolygonContact__b2ChainAndPolygonContact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29($0, HEAP32[$5 + 28 >> 2], HEAP32[$5 + 24 >> 2], HEAP32[$5 + 20 >> 2], HEAP32[$5 + 16 >> 2]); + __stack_pointer = $5 + 32 | 0; + return $0 | 0; +} + +function void_20emscripten__function_unsigned_20int_2c_20unsigned_20int__28char_20const__2c_20unsigned_20int_20_28__29_28unsigned_20int_29_29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 405; + $0 = HEAP32[$2 + 24 >> 2]; + $1 = emscripten__internal__WithPolicies____ArgTypeList_unsigned_20int_2c_20unsigned_20int___getCount_28_29_20const($2 + 19 | 0); + $3 = emscripten__internal__WithPolicies____ArgTypeList_unsigned_20int_2c_20unsigned_20int___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_function($0 | 0, $1 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 20 >> 2], 0); + __stack_pointer = $2 + 32 | 0; +} + +function std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____allocate_5babi_v160004_5d_28unsigned_20long_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + if (HEAPU32[$2 + 8 >> 2] > unsigned_20long_20std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______max_size_5babi_v160004_5d_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void____2c_20void__28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void____20const__29(HEAP32[$2 + 12 >> 2]) >>> 0) { + std____throw_bad_array_new_length_5babi_v160004_5d_28_29(); + wasm2js_trap(); + } + $0 = std____2____libcpp_allocate_5babi_v160004_5d_28unsigned_20long_2c_20unsigned_20long_29(Math_imul(HEAP32[$2 + 8 >> 2], 20), 4); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function b2ChainAndCircleContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$5 + 12 >> 2], 148), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$5 + 8 >> 2]; + b2ChainAndCircleContact__b2ChainAndCircleContact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29($0, HEAP32[$5 + 28 >> 2], HEAP32[$5 + 24 >> 2], HEAP32[$5 + 20 >> 2], HEAP32[$5 + 16 >> 2]); + __stack_pointer = $5 + 32 | 0; + return $0 | 0; +} + +function emscripten__internal__VectorAccess_std____2__vector_int_2c_20std____2__allocator_int_____get_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + label$1: { + if (HEAPU32[$3 + 4 >> 2] < std____2__vector_int_2c_20std____2__allocator_int____size_5babi_v160004_5d_28_29_20const(HEAP32[$3 + 8 >> 2]) >>> 0) { + emscripten__val__val_int_20const___28int_20const__29($0, std____2__vector_int_2c_20std____2__allocator_int____operator_5b_5d_5babi_v160004_5d_28unsigned_20long_29_20const(HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2])); + break label$1; + } + emscripten__val__undefined_28_29($0); + } + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2PrismaticJoint____29_28_29_20const_2c_20bool_2c_20b2PrismaticJoint_20const____invoke_28bool_20_28b2PrismaticJoint____20const__29_28_29_20const_2c_20b2PrismaticJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2PrismaticJoint_20const__2c_20void___fromWireType_28b2PrismaticJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($1) & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2Vec2_20const__29_2c_20void_2c_20b2World__2c_20b2Vec2_20const____invoke_28void_20_28b2World____20const__29_28b2Vec2_20const__29_2c_20b2World__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2World__2c_20void___fromWireType_28b2World__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2WheelJoint____29_28bool_29_2c_20void_2c_20b2WheelJoint__2c_20bool___invoke_28void_20_28b2WheelJoint____20const__29_28bool_29_2c_20b2WheelJoint__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2 & 1; + $2 = emscripten__internal__BindingType_b2WheelJoint__2c_20void___fromWireType_28b2WheelJoint__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$3 + 7 | 0] & 1) & 1); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Fixture____29_28float_29_2c_20void_2c_20b2Fixture__2c_20float___invoke_28void_20_28b2Fixture____20const__29_28float_29_2c_20b2Fixture__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2Fixture__2c_20void___fromWireType_28b2Fixture__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_b2Shape__Type_20_28b2Fixture____29_28_29_20const_2c_20b2Shape__Type_2c_20b2Fixture_20const____invoke_28b2Shape__Type_20_28b2Fixture____20const__29_28_29_20const_2c_20b2Fixture_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Fixture_20const__2c_20void___fromWireType_28b2Fixture_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__EnumBindingType_b2Shape__Type___toWireType_28b2Shape__Type_29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Cross_28b2Vec3_20const__2c_20b2Vec3_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Vec3__b2Vec3_28float_2c_20float_2c_20float_29($0, Math_fround(Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 8 >> 2]) - Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 8 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2])), Math_fround(Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 8 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]) - Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 8 >> 2])), Math_fround(Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2]) - Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]))); + __stack_pointer = $3 + 16 | 0; +} + +function std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2_______compressed_pair_5babi_v160004_5d_std__nullptr_t_2c_20std____2__allocator_b2Vec2____28std__nullptr_t___2c_20std____2__allocator_b2Vec2___29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + std____2____compressed_pair_elem_b2Vec2__2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std__nullptr_t_2c_20void__28std__nullptr_t___29($0, HEAP32[$3 + 8 >> 2]); + std____2____compressed_pair_elem_std____2__allocator_b2Vec2___2c_201_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std____2__allocator_b2Vec2___2c_20void__28std____2__allocator_b2Vec2___29($0 + 4 | 0, HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; + return $0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2RevoluteJoint____29_28_29_20const_2c_20bool_2c_20b2RevoluteJoint_20const____invoke_28bool_20_28b2RevoluteJoint____20const__29_28_29_20const_2c_20b2RevoluteJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2RevoluteJoint_20const__2c_20void___fromWireType_28b2RevoluteJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($1) & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2Vec2_20const__29_2c_20void_2c_20b2Body__2c_20b2Vec2_20const____invoke_28void_20_28b2Body____20const__29_28b2Vec2_20const__29_2c_20b2Body__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__RegisterClassConstructor_b2AABB__20_28__29_28_29___invoke_b2AABB__28b2AABB__20_28__29_28_29_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 >> 2] = 497; + $0 = emscripten__internal__TypeID_b2AABB_2c_20void___get_28_29(); + $2 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2AABB____getCount_28_29_20const($1 + 7 | 0); + $3 = emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2AABB____getTypes_28_29_20const($1 + 7 | 0); + HEAP32[$1 + 12 >> 2] = HEAP32[$1 >> 2]; + _embind_register_class_constructor($0 | 0, $2 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() | 0, HEAP32[$1 >> 2], HEAP32[$1 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2Fixture__29_2c_20void_2c_20b2Body__2c_20b2Fixture____invoke_28void_20_28b2Body____20const__29_28b2Fixture__29_2c_20b2Body__2c_20b2Fixture__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2Fixture__2c_20void___fromWireType_28b2Fixture__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function decltype_28std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false_____unwrap_28std__declval_std____2__reverse_iterator_int____28_29_29_29_20std____2____unwrap_iter_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false__2c_200__28std____2__reverse_iterator_int___29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 8 >> 2]; + wasm2js_i32$0 = $1, wasm2js_i32$1 = std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false_____unwrap_5babi_v160004_5d_28std____2__reverse_iterator_int___29(HEAP32[$1 + 4 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2PolygonShape____29_28_29_20const_2c_20bool_2c_20b2PolygonShape_20const____invoke_28bool_20_28b2PolygonShape____20const__29_28_29_20const_2c_20b2PolygonShape_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2PolygonShape_20const__2c_20void___fromWireType_28b2PolygonShape_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($1) & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function std____2__pair_std____2____unwrap_ref_decay_std____2__reverse_iterator_int_____type_2c_20std____2____unwrap_ref_decay_std____2__reverse_iterator_int_____type__20std____2__make_pair_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int____28std____2__reverse_iterator_int_____2c_20std____2__reverse_iterator_int_____29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + std____2__pair_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int_____pair_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20_28void__290__28std____2__reverse_iterator_int_____2c_20std____2__reverse_iterator_int_____29($0, HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__val_20emscripten__internal__wrapped_extend_b2DrawWrapper__28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + emscripten__val__take_ownership_28emscripten___EM_VAL__29($0, _embind_create_inheriting_constructor(std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____c_str_5babi_v160004_5d_28_29_20const(HEAP32[$3 + 8 >> 2]) | 0, emscripten__internal__TypeID_b2DrawWrapper_2c_20void___get_28_29() | 0, emscripten__val__as_handle_28_29_20const(HEAP32[$3 + 4 >> 2]) | 0) | 0); + __stack_pointer = $3 + 16 | 0; +} + +function b2CircleShape__TestPoint_28b2Transform_20const__2c_20b2Vec2_20const__29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, $4 = Math_fround(0); + $3 = __stack_pointer - 48 | 0; + __stack_pointer = $3; + HEAP32[$3 + 44 >> 2] = $0; + HEAP32[$3 + 40 >> 2] = $1; + HEAP32[$3 + 36 >> 2] = $2; + $1 = HEAP32[$3 + 40 >> 2]; + $0 = HEAP32[$3 + 44 >> 2]; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 20 | 0, HEAP32[$3 + 40 >> 2] + 8 | 0, $0 + 12 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 28 | 0, $1, $3 + 20 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 12 | 0, HEAP32[$3 + 36 >> 2], $3 + 28 | 0); + $1 = $3 + 12 | 0; + $4 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($1, $1); + __stack_pointer = $3 + 48 | 0; + return Math_fround(HEAPF32[$0 + 8 >> 2] * HEAPF32[$0 + 8 >> 2]) >= $4 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2Joint__29_2c_20void_2c_20b2World__2c_20b2Joint____invoke_28void_20_28b2World____20const__29_28b2Joint__29_2c_20b2World__2c_20b2Joint__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2World__2c_20void___fromWireType_28b2World__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2Joint__2c_20void___fromWireType_28b2Joint__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2BodyType_29_2c_20void_2c_20b2Body__2c_20b2BodyType___invoke_28void_20_28b2Body____20const__29_28b2BodyType_29_2c_20b2Body__2c_20b2BodyType_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__EnumBindingType_b2BodyType___fromWireType_28b2BodyType_29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_b2Shape__Type_20_28b2Shape____29_28_29_20const_2c_20b2Shape__Type_2c_20b2Shape_20const____invoke_28b2Shape__Type_20_28b2Shape____20const__29_28_29_20const_2c_20b2Shape_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Shape_20const__2c_20void___fromWireType_28b2Shape_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__EnumBindingType_b2Shape__Type___toWireType_28b2Shape__Type_29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2ContactListenerWrapper__PostSolve_28unsigned_20int_2c_20unsigned_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + label$1: { + if (!(b2ContactListenerWrapper__isIndexOf_28unsigned_20int_29($0, b2Contact__GetFixtureA_28_29(HEAP32[$3 + 8 >> 2])) & 1)) { + if (!(b2ContactListenerWrapper__isIndexOf_28unsigned_20int_29($0, b2Contact__GetFixtureB_28_29(HEAP32[$3 + 8 >> 2])) & 1)) { + break label$1; + } + } + void_20emscripten__wrapper_b2ContactListener___call_void_2c_20unsigned_20int__2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__2c_20unsigned_20int__29_20const($0, 8679, $3 + 8 | 0, $3 + 4 | 0); + } + __stack_pointer = $3 + 16 | 0; +} + +function b2ContactListenerWrapper__PreSolve_28unsigned_20int_2c_20unsigned_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + label$1: { + if (!(b2ContactListenerWrapper__isIndexOf_28unsigned_20int_29($0, b2Contact__GetFixtureA_28_29(HEAP32[$3 + 8 >> 2])) & 1)) { + if (!(b2ContactListenerWrapper__isIndexOf_28unsigned_20int_29($0, b2Contact__GetFixtureB_28_29(HEAP32[$3 + 8 >> 2])) & 1)) { + break label$1; + } + } + void_20emscripten__wrapper_b2ContactListener___call_void_2c_20unsigned_20int__2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__2c_20unsigned_20int__29_20const($0, 8689, $3 + 8 | 0, $3 + 4 | 0); + } + __stack_pointer = $3 + 16 | 0; +} + +function std____2__set_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____end_5babi_v160004_5d_28_29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + wasm2js_i32$0 = $1, wasm2js_i32$1 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____end_5babi_v160004_5d_28_29(HEAP32[$1 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____tree_const_iterator_5babi_v160004_5d_28std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__29($1 + 12 | 0, HEAP32[$1 + 4 >> 2]); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2Body____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2Body_20const____invoke_28b2Vec2_20const__20_28b2Body____20const__29_28_29_20const_2c_20b2Body_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Body_20const__2c_20void___fromWireType_28b2Body_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function std____2____compressed_pair_unsigned_20long_2c_20std____2__less_b2Fixture_______compressed_pair_5babi_v160004_5d_int_2c_20std____2__less_b2Fixture___20const___28int___2c_20std____2__less_b2Fixture___20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + std____2____compressed_pair_elem_unsigned_20long_2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_int_2c_20void__28int___29($0, HEAP32[$3 + 8 >> 2]); + std____2____compressed_pair_elem_std____2__less_b2Fixture___2c_201_2c_20true_____compressed_pair_elem_5babi_v160004_5d_std____2__less_b2Fixture___20const__2c_20void__28std____2__less_b2Fixture___20const__29($0, HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; + return $0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Fixture____29_28bool_29_2c_20void_2c_20b2Fixture__2c_20bool___invoke_28void_20_28b2Fixture____20const__29_28bool_29_2c_20b2Fixture__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2 & 1; + $2 = emscripten__internal__BindingType_b2Fixture__2c_20void___fromWireType_28b2Fixture__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$3 + 7 | 0] & 1) & 1); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Body____29_28float_29_2c_20void_2c_20b2Body__2c_20float___invoke_28void_20_28b2Body____20const__29_28float_29_2c_20b2Body__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $4 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $4 = ($1 >> 1) + $4 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$4 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($4, emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2Draw__29_2c_20void_2c_20b2World__2c_20b2Draw____invoke_28void_20_28b2World____20const__29_28b2Draw__29_2c_20b2World__2c_20b2Draw__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2World__2c_20void___fromWireType_28b2World__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2Draw__2c_20void___fromWireType_28b2Draw__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2Body__29_2c_20void_2c_20b2World__2c_20b2Body____invoke_28void_20_28b2World____20const__29_28b2Body__29_2c_20b2World__2c_20b2Body__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2World__2c_20void___fromWireType_28b2World__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function std____2____split_buffer_int_2c_20std____2__allocator_int_______destruct_at_end_5babi_v160004_5d_28int__2c_20std____2__integral_constant_bool_2c_20false__29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 4 >> 2] = $1; + $0 = HEAP32[$2 + 8 >> 2]; + while (1) { + if (HEAP32[$2 + 4 >> 2] != HEAP32[$0 + 8 >> 2]) { + $3 = std____2____split_buffer_int_2c_20std____2__allocator_int_______alloc_5babi_v160004_5d_28_29($0); + $1 = HEAP32[$0 + 8 >> 2] - 4 | 0; + HEAP32[$0 + 8 >> 2] = $1; + void_20std____2__allocator_traits_std____2__allocator_int____destroy_5babi_v160004_5d_int_2c_20void__28std____2__allocator_int___2c_20int__29($3, int__20std____2____to_address_5babi_v160004_5d_int__28int__29($1)); + continue; + } + break; + } + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2WheelJoint____29_28_29_20const_2c_20bool_2c_20b2WheelJoint_20const____invoke_28bool_20_28b2WheelJoint____20const__29_28_29_20const_2c_20b2WheelJoint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2WheelJoint_20const__2c_20void___fromWireType_28b2WheelJoint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($1) & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function emscripten__internal__MethodInvoker_b2JointType_20_28b2Joint____29_28_29_20const_2c_20b2JointType_2c_20b2Joint_20const____invoke_28b2JointType_20_28b2Joint____20const__29_28_29_20const_2c_20b2Joint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Joint_20const__2c_20void___fromWireType_28b2Joint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__EnumBindingType_b2JointType___toWireType_28b2JointType_29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______insert_unique_5babi_v160004_5d_28b2Fixture__20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + std____2__pair_std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__2c_20bool__20std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______emplace_unique_key_args_b2Fixture__2c_20b2Fixture__20const___28b2Fixture__20const__2c_20b2Fixture__20const__29($0, HEAP32[$3 + 12 >> 2], std____2____tree_key_value_types_b2Fixture______get_key_5babi_v160004_5d_28b2Fixture__20const__29(HEAP32[$3 + 8 >> 2]), HEAP32[$3 + 8 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____push_back_5babi_v160004_5d_28b2Vec2_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + label$1: { + if (HEAP32[$0 + 4 >> 2] != HEAP32[std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______end_cap_5babi_v160004_5d_28_29($0) >> 2]) { + void_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______construct_one_at_end_5babi_v160004_5d_b2Vec2_20const___28b2Vec2_20const__29($0, HEAP32[$2 + 8 >> 2]); + break label$1; + } + void_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______push_back_slow_path_b2Vec2_20const___28b2Vec2_20const__29($0, HEAP32[$2 + 8 >> 2]); + } + __stack_pointer = $2 + 16 | 0; +} + +function std____2____compressed_pair_int__2c_20std____2__allocator_int_______compressed_pair_5babi_v160004_5d_std__nullptr_t_2c_20std____2__allocator_int____28std__nullptr_t___2c_20std____2__allocator_int___29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + std____2____compressed_pair_elem_int__2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std__nullptr_t_2c_20void__28std__nullptr_t___29($0, HEAP32[$3 + 8 >> 2]); + std____2____compressed_pair_elem_std____2__allocator_int___2c_201_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std____2__allocator_int___2c_20void__28std____2__allocator_int___29($0 + 4 | 0, HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; + return $0; +} + +function b2PrismaticJoint__SetLimits_28float_2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = Math_fround($1); + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAPF32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + if (!(HEAPF32[$3 + 8 >> 2] <= HEAPF32[$3 + 4 >> 2])) { + __assert_fail(3971, 4498, 534, 3355); + wasm2js_trap(); + } + if (!(HEAPF32[$3 + 8 >> 2] == HEAPF32[$0 + 124 >> 2] & HEAPF32[$3 + 4 >> 2] == HEAPF32[$0 + 128 >> 2])) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAPF32[$0 + 124 >> 2] = HEAPF32[$3 + 8 >> 2]; + HEAPF32[$0 + 128 >> 2] = HEAPF32[$3 + 4 >> 2]; + HEAPF32[$0 + 116 >> 2] = 0; + HEAPF32[$0 + 120 >> 2] = 0; + } + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2World____29_28bool_29_2c_20void_2c_20b2World__2c_20bool___invoke_28void_20_28b2World____20const__29_28bool_29_2c_20b2World__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2 & 1; + $2 = emscripten__internal__BindingType_b2World__2c_20void___fromWireType_28b2World__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$3 + 7 | 0] & 1) & 1); + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__function_float_2c_20unsigned_20int__28char_20const__2c_20float_20_28__29_28unsigned_20int_29_29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 403; + $0 = HEAP32[$2 + 24 >> 2]; + $1 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20unsigned_20int___getCount_28_29_20const($2 + 19 | 0); + $3 = emscripten__internal__WithPolicies____ArgTypeList_float_2c_20unsigned_20int___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_function($0 | 0, $1 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 20 >> 2], 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2RevoluteJoint__SetLimits_28float_2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = Math_fround($1); + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAPF32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + if (!(HEAPF32[$3 + 8 >> 2] <= HEAPF32[$3 + 4 >> 2])) { + __assert_fail(3971, 4361, 428, 3355); + wasm2js_trap(); + } + if (!(HEAPF32[$3 + 8 >> 2] == HEAPF32[$0 + 124 >> 2] & HEAPF32[$3 + 4 >> 2] == HEAPF32[$0 + 128 >> 2])) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAPF32[$0 + 96 >> 2] = 0; + HEAPF32[$0 + 100 >> 2] = 0; + HEAPF32[$0 + 124 >> 2] = HEAPF32[$3 + 8 >> 2]; + HEAPF32[$0 + 128 >> 2] = HEAPF32[$3 + 4 >> 2]; + } + __stack_pointer = $3 + 16 | 0; +} + +function std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2________split_buffer_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_____clear_5babi_v160004_5d_28_29($0); + if (HEAP32[$0 >> 2]) { + std____2__allocator_traits_std____2__allocator_b2Vec2____deallocate_5babi_v160004_5d_28std____2__allocator_b2Vec2___2c_20b2Vec2__2c_20unsigned_20long_29(std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______alloc_5babi_v160004_5d_28_29($0), HEAP32[$0 >> 2], std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_____capacity_5babi_v160004_5d_28_29_20const($0)); + } + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Fixture____29_28int_29_2c_20void_2c_20b2Fixture__2c_20int___invoke_28void_20_28b2Fixture____20const__29_28int_29_2c_20b2Fixture__2c_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_b2Fixture__2c_20void___fromWireType_28b2Fixture__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_b2BodyType_20_28b2Body____29_28_29_20const_2c_20b2BodyType_2c_20b2Body_20const____invoke_28b2BodyType_20_28b2Body____20const__29_28_29_20const_2c_20b2Body_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Body_20const__2c_20void___fromWireType_28b2Body_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__EnumBindingType_b2BodyType___toWireType_28b2BodyType_29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function void_20emscripten__function_void_2c_20unsigned_20int__28char_20const__2c_20void_20_28__29_28unsigned_20int_29_29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 404; + $0 = HEAP32[$2 + 24 >> 2]; + $1 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int___getCount_28_29_20const($2 + 19 | 0); + $3 = emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_function($0 | 0, $1 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 20 >> 2], 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Body____29_28bool_29_2c_20void_2c_20b2Body__2c_20bool___invoke_28void_20_28b2Body____20const__29_28bool_29_2c_20b2Body__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2 & 1; + $2 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$3 + 8 >> 2]); + $0 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $2 = ($1 >> 1) + $2 | 0; + if ($1 & 1) { + $0 = HEAP32[HEAP32[$2 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$3 + 7 | 0] & 1) & 1); + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__function_bool_2c_20unsigned_20int__28char_20const__2c_20bool_20_28__29_28unsigned_20int_29_29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 401; + $0 = HEAP32[$2 + 24 >> 2]; + $1 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20unsigned_20int___getCount_28_29_20const($2 + 19 | 0); + $3 = emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20unsigned_20int___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_function($0 | 0, $1 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 20 >> 2], 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__Invoker_void_2c_20b2Joint__2c_20float_2c_20float___invoke_28void_20_28__29_28b2Joint__2c_20float_2c_20float_29_2c_20b2Joint__2c_20float_2c_20float_29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + $3 = Math_fround($3); + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAPF32[$4 + 4 >> 2] = $2; + HEAPF32[$4 >> 2] = $3; + $0 = HEAP32[$4 + 12 >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_b2Joint__2c_20void___fromWireType_28b2Joint__29(HEAP32[$4 + 8 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 + 4 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$4 >> 2])); + __stack_pointer = $4 + 16 | 0; +} + +function b2RayCastCallbackWrapper__ReportFixture_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = Math_fround($4); + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAPF32[$5 + 12 >> 2] = $4; + $4 = float_20emscripten__wrapper_b2RayCastCallback___call_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float___28char_20const__2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float__29_20const(HEAP32[$5 + 28 >> 2], 9168, $5 + 24 | 0, HEAP32[$5 + 20 >> 2], HEAP32[$5 + 16 >> 2], $5 + 12 | 0); + __stack_pointer = $5 + 32 | 0; + return Math_fround($4); +} + +function emscripten__internal__MethodInvoker_b2Vec2_20_28b2World____29_28_29_20const_2c_20b2Vec2_2c_20b2World_20const____invoke_28b2Vec2_20_28b2World____20const__29_28_29_20const_2c_20b2World_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2World_20const__2c_20void___fromWireType_28b2World_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, $1); + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2___29($2); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__MethodInvoker_b2Vec2_20_28b2Joint____29_28_29_20const_2c_20b2Vec2_2c_20b2Joint_20const____invoke_28b2Vec2_20_28b2Joint____20const__29_28_29_20const_2c_20b2Joint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Joint_20const__2c_20void___fromWireType_28b2Joint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, $1); + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2___29($2); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + HEAPF32[$3 + 4 >> 2] = Math_fround(Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 12 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]) - Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 8 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2])) + HEAPF32[HEAP32[$3 + 12 >> 2] >> 2]; + HEAPF32[$3 >> 2] = Math_fround(Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 8 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]) + Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 12 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2])) + HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2]; + b2Vec2__b2Vec2_28float_2c_20float_29($0, HEAPF32[$3 + 4 >> 2], HEAPF32[$3 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__Signature_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const____get_method_caller_28_29() { + var $0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $0 = __stack_pointer - 16 | 0; + __stack_pointer = $0; + if (!(HEAP8[30084] & 1)) { + wasm2js_i32$0 = 30080, wasm2js_i32$1 = _emval_get_method_caller(emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const____getCount_28_29_20const($0 + 15 | 0) | 0, emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const____getTypes_28_29_20const($0 + 15 | 0) | 0) | 0, + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP8[30084] = 1; + } + __stack_pointer = $0 + 16 | 0; + return HEAP32[7520]; +} + +function emscripten__internal__Signature_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____get_method_caller_28_29() { + var $0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $0 = __stack_pointer - 16 | 0; + __stack_pointer = $0; + if (!(HEAP8[30044] & 1)) { + wasm2js_i32$0 = 30040, wasm2js_i32$1 = _emval_get_method_caller(emscripten__internal__WithPolicies____ArgTypeList_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____getCount_28_29_20const($0 + 15 | 0) | 0, emscripten__internal__WithPolicies____ArgTypeList_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____getTypes_28_29_20const($0 + 15 | 0) | 0) | 0, + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP8[30044] = 1; + } + __stack_pointer = $0 + 16 | 0; + return HEAP32[7510]; +} + +function void_20emscripten__function_int_2c_20unsigned_20int__28char_20const__2c_20int_20_28__29_28unsigned_20int_29_29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 24 >> 2] = $0; + HEAP32[$2 + 20 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = 409; + $0 = HEAP32[$2 + 24 >> 2]; + $1 = emscripten__internal__WithPolicies____ArgTypeList_int_2c_20unsigned_20int___getCount_28_29_20const($2 + 19 | 0); + $3 = emscripten__internal__WithPolicies____ArgTypeList_int_2c_20unsigned_20int___getTypes_28_29_20const($2 + 19 | 0); + HEAP32[$2 + 28 >> 2] = HEAP32[$2 + 12 >> 2]; + _embind_register_function($0 | 0, $1 | 0, $3 | 0, char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 20 >> 2], 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2Fixture____29_28_29_20const_2c_20bool_2c_20b2Fixture_20const____invoke_28bool_20_28b2Fixture____20const__29_28_29_20const_2c_20b2Fixture_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Fixture_20const__2c_20void___fromWireType_28b2Fixture_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($1) & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function emscripten__internal__Invoker_b2Vec2_2c_20b2Transform_20const__2c_20b2Vec2_20const____invoke_28b2Vec2_20_28__29_28b2Transform_20const__2c_20b2Vec2_20const__29_2c_20b2Transform__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + FUNCTION_TABLE[$0 | 0]($3 + 12 | 0, emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29(HEAP32[$3 + 24 >> 2]), emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 20 >> 2])); + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2___29($3 + 12 | 0); + __stack_pointer = $3 + 32 | 0; + return $0 | 0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______get_pointer_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + label$1: { + if (std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______is_long_5babi_v160004_5d_28_29_20const($0) & 1) { + $0 = std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______get_long_pointer_5babi_v160004_5d_28_29_20const($0); + break label$1; + } + $0 = std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______get_short_pointer_5babi_v160004_5d_28_29_20const($0); + } + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2BroadPhase__BufferMove_28int_29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAP32[$0 + 40 >> 2] == HEAP32[$0 + 36 >> 2]) { + HEAP32[$2 + 4 >> 2] = HEAP32[$0 + 32 >> 2]; + HEAP32[$0 + 36 >> 2] = HEAP32[$0 + 36 >> 2] << 1; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Alloc_28int_29(HEAP32[$0 + 36 >> 2] << 2), + HEAP32[wasm2js_i32$0 + 32 >> 2] = wasm2js_i32$1; + __memcpy(HEAP32[$0 + 32 >> 2], HEAP32[$2 + 4 >> 2], HEAP32[$0 + 40 >> 2] << 2); + b2Free_28void__29(HEAP32[$2 + 4 >> 2]); + } + HEAP32[HEAP32[$0 + 32 >> 2] + (HEAP32[$0 + 40 >> 2] << 2) >> 2] = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 40 >> 2] = HEAP32[$0 + 40 >> 2] + 1; + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_b2Vec2_20_28b2AABB____29_28_29_20const_2c_20b2Vec2_2c_20b2AABB_20const____invoke_28b2Vec2_20_28b2AABB____20const__29_28_29_20const_2c_20b2AABB_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2AABB_20const__2c_20void___fromWireType_28b2AABB_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($2, $1); + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2___29($2); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Body__Advance_28float_29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAPF32[$3 + 24 >> 2] = $1; + $2 = HEAP32[$3 + 28 >> 2]; + b2Sweep__Advance_28float_29($2 + 28 | 0, HEAPF32[$3 + 24 >> 2]); + $0 = HEAP32[$2 + 40 >> 2]; + $4 = HEAP32[$2 + 36 >> 2]; + HEAP32[$2 + 44 >> 2] = $4; + HEAP32[$2 + 48 >> 2] = $0; + HEAPF32[$2 + 56 >> 2] = HEAPF32[$2 + 52 >> 2]; + b2Rot__Set_28float_29($2 + 20 | 0, HEAPF32[$2 + 56 >> 2]); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 8 | 0, $2 + 20 | 0, $2 + 28 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 16 | 0, $2 + 44 | 0, $3 + 8 | 0); + $4 = HEAP32[$3 + 20 >> 2]; + $0 = HEAP32[$3 + 16 >> 2]; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 16 >> 2] = $4; + __stack_pointer = $3 + 32 | 0; +} + +function emscripten__internal__FunctionInvoker_float_20_28__29_28b2Shape__29_2c_20float_2c_20b2Shape____invoke_28float_20_28___29_28b2Shape__29_2c_20b2Shape__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[HEAP32[$2 + 12 >> 2] >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_b2Shape__2c_20void___fromWireType_28b2Shape__29(HEAP32[$2 + 8 >> 2]))), + HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function b2PolygonShape__b2PolygonShape_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 8 >> 2] = $0; + $1 = HEAP32[$2 + 8 >> 2]; + HEAP32[$2 + 12 >> 2] = $1; + b2Shape__b2Shape_28_29($1); + HEAP32[$1 >> 2] = 18064; + b2Vec2__b2Vec2_28_29($1 + 12 | 0); + $0 = $1 + 20 | 0; + $3 = $0 - -64 | 0; + while (1) { + b2Vec2__b2Vec2_28_29($0); + $0 = $0 + 8 | 0; + if (($3 | 0) != ($0 | 0)) { + continue; + } + break; + } + $0 = $1 + 84 | 0; + $3 = $0 - -64 | 0; + while (1) { + b2Vec2__b2Vec2_28_29($0); + $0 = $0 + 8 | 0; + if (($3 | 0) != ($0 | 0)) { + continue; + } + break; + } + HEAP32[$1 + 4 >> 2] = 2; + HEAPF32[$1 + 8 >> 2] = .009999999776482582; + HEAP32[$1 + 148 >> 2] = 0; + b2Vec2__SetZero_28_29($1 + 12 | 0); + __stack_pointer = $2 + 16 | 0; + return HEAP32[$2 + 12 >> 2]; +} + +function b2EdgeAndPolygonContact__b2EdgeAndPolygonContact_28b2Fixture__2c_20b2Fixture__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 8 >> 2] = $0; + HEAP32[$3 + 4 >> 2] = $1; + HEAP32[$3 >> 2] = $2; + $0 = HEAP32[$3 + 8 >> 2]; + HEAP32[$3 + 12 >> 2] = $0; + b2Contact__b2Contact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29($0, HEAP32[$3 + 4 >> 2], 0, HEAP32[$3 >> 2], 0); + HEAP32[$0 >> 2] = 18596; + if ((b2Fixture__GetType_28_29_20const(HEAP32[$0 + 48 >> 2]) | 0) != 1) { + __assert_fail(9752, 4707, 45, 3059); + wasm2js_trap(); + } + if ((b2Fixture__GetType_28_29_20const(HEAP32[$0 + 52 >> 2]) | 0) != 2) { + __assert_fail(6761, 4707, 46, 3059); + wasm2js_trap(); + } + __stack_pointer = $3 + 16 | 0; + return HEAP32[$3 + 12 >> 2]; +} + +function b2MulT_28b2Transform_20const__2c_20b2Transform_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $1; + HEAP32[$3 + 24 >> 2] = $2; + b2Transform__b2Transform_28_29($0); + b2MulT_28b2Rot_20const__2c_20b2Rot_20const__29($3 + 16 | 0, HEAP32[$3 + 28 >> 2] + 8 | 0, HEAP32[$3 + 24 >> 2] + 8 | 0); + $1 = HEAP32[$3 + 20 >> 2]; + $2 = HEAP32[$3 + 16 >> 2]; + HEAP32[$0 + 8 >> 2] = $2; + HEAP32[$0 + 12 >> 2] = $1; + $1 = HEAP32[$3 + 28 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3, HEAP32[$3 + 24 >> 2], HEAP32[$3 + 28 >> 2]); + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($3 + 8 | 0, $1 + 8 | 0, $3); + $2 = HEAP32[$3 + 12 >> 2]; + $1 = HEAP32[$3 + 8 >> 2]; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 32 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2World____29_28_29_20const_2c_20bool_2c_20b2World_20const____invoke_28bool_20_28b2World____20const__29_28_29_20const_2c_20b2World_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2World_20const__2c_20void___fromWireType_28b2World_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($1) & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2Joint____29_28_29_20const_2c_20bool_2c_20b2Joint_20const____invoke_28bool_20_28b2Joint____20const__29_28_29_20const_2c_20b2Joint_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Joint_20const__2c_20void___fromWireType_28b2Joint_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($1) & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function b2PolygonAndCircleContact__b2PolygonAndCircleContact_28b2Fixture__2c_20b2Fixture__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 8 >> 2] = $0; + HEAP32[$3 + 4 >> 2] = $1; + HEAP32[$3 >> 2] = $2; + $0 = HEAP32[$3 + 8 >> 2]; + HEAP32[$3 + 12 >> 2] = $0; + b2Contact__b2Contact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29($0, HEAP32[$3 + 4 >> 2], 0, HEAP32[$3 >> 2], 0); + HEAP32[$0 >> 2] = 19072; + if ((b2Fixture__GetType_28_29_20const(HEAP32[$0 + 48 >> 2]) | 0) != 2) { + __assert_fail(6805, 4854, 45, 3113); + wasm2js_trap(); + } + if (b2Fixture__GetType_28_29_20const(HEAP32[$0 + 52 >> 2])) { + __assert_fail(9531, 4854, 46, 3113); + wasm2js_trap(); + } + __stack_pointer = $3 + 16 | 0; + return HEAP32[$3 + 12 >> 2]; +} + +function b2PolygonAndCircleContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$5 + 12 >> 2], 148), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$5 + 8 >> 2]; + b2PolygonAndCircleContact__b2PolygonAndCircleContact_28b2Fixture__2c_20b2Fixture__29($0, HEAP32[$5 + 28 >> 2], HEAP32[$5 + 20 >> 2]); + __stack_pointer = $5 + 32 | 0; + return $0 | 0; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2Body____29_28_29_20const_2c_20bool_2c_20b2Body_20const____invoke_28bool_20_28b2Body____20const__29_28_29_20const_2c_20b2Body_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Body_20const__2c_20void___fromWireType_28b2Body_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($1) & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function emscripten__internal__MethodInvoker_bool_20_28b2AABB____29_28_29_20const_2c_20bool_2c_20b2AABB_20const____invoke_28bool_20_28b2AABB____20const__29_28_29_20const_2c_20b2AABB_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2AABB_20const__2c_20void___fromWireType_28b2AABB_20const__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0]($1) & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function b2EdgeAndCircleContact__b2EdgeAndCircleContact_28b2Fixture__2c_20b2Fixture__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 8 >> 2] = $0; + HEAP32[$3 + 4 >> 2] = $1; + HEAP32[$3 >> 2] = $2; + $0 = HEAP32[$3 + 8 >> 2]; + HEAP32[$3 + 12 >> 2] = $0; + b2Contact__b2Contact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29($0, HEAP32[$3 + 4 >> 2], 0, HEAP32[$3 >> 2], 0); + HEAP32[$0 >> 2] = 18536; + if ((b2Fixture__GetType_28_29_20const(HEAP32[$0 + 48 >> 2]) | 0) != 1) { + __assert_fail(9752, 5008, 45, 3163); + wasm2js_trap(); + } + if (b2Fixture__GetType_28_29_20const(HEAP32[$0 + 52 >> 2])) { + __assert_fail(9531, 5008, 46, 3163); + wasm2js_trap(); + } + __stack_pointer = $3 + 16 | 0; + return HEAP32[$3 + 12 >> 2]; +} + +function b2PolygonContact__b2PolygonContact_28b2Fixture__2c_20b2Fixture__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 8 >> 2] = $0; + HEAP32[$3 + 4 >> 2] = $1; + HEAP32[$3 >> 2] = $2; + $0 = HEAP32[$3 + 8 >> 2]; + HEAP32[$3 + 12 >> 2] = $0; + b2Contact__b2Contact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29($0, HEAP32[$3 + 4 >> 2], 0, HEAP32[$3 >> 2], 0); + HEAP32[$0 >> 2] = 19132; + if ((b2Fixture__GetType_28_29_20const(HEAP32[$0 + 48 >> 2]) | 0) != 2) { + __assert_fail(6805, 4783, 48, 3083); + wasm2js_trap(); + } + if ((b2Fixture__GetType_28_29_20const(HEAP32[$0 + 52 >> 2]) | 0) != 2) { + __assert_fail(6761, 4783, 49, 3083); + wasm2js_trap(); + } + __stack_pointer = $3 + 16 | 0; + return HEAP32[$3 + 12 >> 2]; +} + +function b2EdgeAndPolygonContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$5 + 12 >> 2], 148), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$5 + 8 >> 2]; + b2EdgeAndPolygonContact__b2EdgeAndPolygonContact_28b2Fixture__2c_20b2Fixture__29($0, HEAP32[$5 + 28 >> 2], HEAP32[$5 + 20 >> 2]); + __stack_pointer = $5 + 32 | 0; + return $0 | 0; +} + +function void_20emscripten__val__call_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const___28char_20const__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29_20const($0, $1, $2, $3, $4) { + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + emscripten__internal__MethodCaller_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____call_28emscripten___EM_VAL__2c_20char_20const__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29(HEAP32[HEAP32[$5 + 28 >> 2] >> 2], HEAP32[$5 + 24 >> 2], HEAP32[$5 + 20 >> 2], HEAP32[$5 + 16 >> 2], HEAP32[$5 + 12 >> 2]); + __stack_pointer = $5 + 32 | 0; +} + +function b2EdgeAndCircleContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$5 + 12 >> 2], 148), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$5 + 8 >> 2]; + b2EdgeAndCircleContact__b2EdgeAndCircleContact_28b2Fixture__2c_20b2Fixture__29($0, HEAP32[$5 + 28 >> 2], HEAP32[$5 + 20 >> 2]); + __stack_pointer = $5 + 32 | 0; + return $0 | 0; +} + +function std____2____split_buffer_int_2c_20std____2__allocator_int________split_buffer_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + std____2____split_buffer_int_2c_20std____2__allocator_int_____clear_5babi_v160004_5d_28_29($0); + if (HEAP32[$0 >> 2]) { + std____2__allocator_traits_std____2__allocator_int____deallocate_5babi_v160004_5d_28std____2__allocator_int___2c_20int__2c_20unsigned_20long_29(std____2____split_buffer_int_2c_20std____2__allocator_int_______alloc_5babi_v160004_5d_28_29($0), HEAP32[$0 >> 2], std____2____split_buffer_int_2c_20std____2__allocator_int_____capacity_5babi_v160004_5d_28_29_20const($0)); + } + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__FunctionInvoker_void_20_28__29_28b2FixtureDef__2c_20b2Shape_20const__29_2c_20void_2c_20b2FixtureDef__2c_20b2Shape_20const____invoke_28void_20_28___29_28b2FixtureDef__2c_20b2Shape_20const__29_2c_20b2FixtureDef__2c_20b2Shape_20const__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[HEAP32[$3 + 12 >> 2] >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_b2FixtureDef__2c_20void___fromWireType_28b2FixtureDef__29(HEAP32[$3 + 8 >> 2]), emscripten__internal__BindingType_b2Shape_20const__2c_20void___fromWireType_28b2Shape_20const__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int____push_back_5babi_v160004_5d_28int_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + label$1: { + if (HEAP32[$0 + 4 >> 2] != HEAP32[std____2__vector_int_2c_20std____2__allocator_int______end_cap_5babi_v160004_5d_28_29($0) >> 2]) { + void_20std____2__vector_int_2c_20std____2__allocator_int______construct_one_at_end_5babi_v160004_5d_int_20const___28int_20const__29($0, HEAP32[$2 + 8 >> 2]); + break label$1; + } + void_20std____2__vector_int_2c_20std____2__allocator_int______push_back_slow_path_int_20const___28int_20const__29($0, HEAP32[$2 + 8 >> 2]); + } + __stack_pointer = $2 + 16 | 0; +} + +function bool_20_28b2PolygonShape____emscripten__internal__getContext_bool_20_28b2PolygonShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const__28bool_20_28b2PolygonShape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__MethodInvoker_b2Shape__20_28b2Fixture____29_28_29_2c_20b2Shape__2c_20b2Fixture____invoke_28b2Shape__20_28b2Fixture____20const__29_28_29_2c_20b2Fixture__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Fixture__2c_20void___fromWireType_28b2Fixture__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_b2Shape__2c_20void___toWireType_28b2Shape__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function std____2__operator___5babi_v160004_5d_28std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__2c_20std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = std____2__operator___5babi_v160004_5d_28std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__2c_20std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__29_1(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]) ^ -1; + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function bool_20_28b2CircleShape____emscripten__internal__getContext_bool_20_28b2CircleShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const__28bool_20_28b2CircleShape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__Invoker_float_2c_20unsigned_20int___invoke_28float_20_28__29_28unsigned_20int_29_2c_20unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + wasm2js_i32$0 = $2, wasm2js_f32$0 = Math_fround(FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$2 + 8 >> 2]))), + HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2______compressed_pair_5babi_v160004_5d_std__nullptr_t_2c_20std____2____default_init_tag__28std__nullptr_t___2c_20std____2____default_init_tag___29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + std____2____compressed_pair_elem_b2Vec2__2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std__nullptr_t_2c_20void__28std__nullptr_t___29($0, HEAP32[$3 + 8 >> 2]); + std____2____compressed_pair_elem_std____2__allocator_b2Vec2__2c_201_2c_20true_____compressed_pair_elem_5babi_v160004_5d_28std____2____default_init_tag_29($0); + __stack_pointer = $3 + 16 | 0; + return $0; +} + +function emscripten__internal__MethodInvoker_b2Body__20_28b2Fixture____29_28_29_2c_20b2Body__2c_20b2Fixture____invoke_28b2Body__20_28b2Fixture____20const__29_28_29_2c_20b2Fixture__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Fixture__2c_20void___fromWireType_28b2Fixture__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_b2Body__2c_20void___toWireType_28b2Body__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2AABB__Contains_28b2AABB_20const__29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP8[$2 + 7 | 0] = 1; + $3 = HEAP8[$2 + 7 | 0] & 1 ? HEAPF32[$0 >> 2] <= HEAPF32[HEAP32[$2 + 8 >> 2] >> 2] : $3; + HEAP8[$2 + 7 | 0] = $3; + $4 = HEAP8[$2 + 7 | 0] & 1 ? HEAPF32[$0 + 4 >> 2] <= HEAPF32[HEAP32[$2 + 8 >> 2] + 4 >> 2] : $4; + HEAP8[$2 + 7 | 0] = $4; + $5 = HEAP8[$2 + 7 | 0] & 1 ? HEAPF32[HEAP32[$2 + 8 >> 2] + 8 >> 2] <= HEAPF32[$0 + 8 >> 2] : $5; + HEAP8[$2 + 7 | 0] = $5; + $6 = HEAP8[$2 + 7 | 0] & 1 ? HEAPF32[HEAP32[$2 + 8 >> 2] + 12 >> 2] <= HEAPF32[$0 + 12 >> 2] : $6; + HEAP8[$2 + 7 | 0] = $6; + return HEAP8[$2 + 7 | 0] & 1; +} + +function emscripten__internal__Signature_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____get_method_caller_28_29() { + var $0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $0 = __stack_pointer - 16 | 0; + __stack_pointer = $0; + if (!(HEAP8[30092] & 1)) { + wasm2js_i32$0 = 30088, wasm2js_i32$1 = _emval_get_method_caller(emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____getCount_28_29_20const($0 + 15 | 0) | 0, emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____getTypes_28_29_20const($0 + 15 | 0) | 0) | 0, + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP8[30092] = 1; + } + __stack_pointer = $0 + 16 | 0; + return HEAP32[7522]; +} + +function bool_20_28b2EdgeShape____emscripten__internal__getContext_bool_20_28b2EdgeShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const__28bool_20_28b2EdgeShape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2____compressed_pair_std____2____tree_end_node_std____2____tree_node_base_void_____2c_20std____2__allocator_std____2____tree_node_b2Fixture__2c_20void________compressed_pair_5babi_v160004_5d_true_2c_20void__28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2____compressed_pair_elem_std____2____tree_end_node_std____2____tree_node_base_void_____2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_28std____2____value_init_tag_29($0); + std____2____compressed_pair_elem_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void____2c_201_2c_20true_____compressed_pair_elem_5babi_v160004_5d_28std____2____value_init_tag_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__MethodInvoker_b2Fixture__20_28b2Body____29_28_29_2c_20b2Fixture__2c_20b2Body____invoke_28b2Fixture__20_28b2Body____20const__29_28_29_2c_20b2Body__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_b2Fixture__2c_20void___toWireType_28b2Fixture__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function emscripten__class__b2Draw_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2Draw_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2DrawWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2DrawWrapper__29____invoke_28b2DrawWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + emscripten__class__b2Draw_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2Draw_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2DrawWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2DrawWrapper__29__operator_28_29_28b2DrawWrapper__29_20const($1 + 11 | 0, HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function b2DrawWrapper__DrawSolidCircle_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAPF32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + void_20emscripten__wrapper_b2Draw___call_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const___28char_20const__2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const__29_20const(HEAP32[$5 + 28 >> 2], 9651, HEAP32[$5 + 24 >> 2], $5 + 20 | 0, HEAP32[$5 + 16 >> 2], HEAP32[$5 + 12 >> 2]); + __stack_pointer = $5 + 32 | 0; +} + +function b2PolygonContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$5 + 12 >> 2], 148), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$5 + 8 >> 2]; + b2PolygonContact__b2PolygonContact_28b2Fixture__2c_20b2Fixture__29($0, HEAP32[$5 + 28 >> 2], HEAP32[$5 + 20 >> 2]); + __stack_pointer = $5 + 32 | 0; + return $0 | 0; +} + +function b2CircleContact__b2CircleContact_28b2Fixture__2c_20b2Fixture__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 8 >> 2] = $0; + HEAP32[$3 + 4 >> 2] = $1; + HEAP32[$3 >> 2] = $2; + $0 = HEAP32[$3 + 8 >> 2]; + HEAP32[$3 + 12 >> 2] = $0; + b2Contact__b2Contact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29($0, HEAP32[$3 + 4 >> 2], 0, HEAP32[$3 >> 2], 0); + HEAP32[$0 >> 2] = 18236; + if (b2Fixture__GetType_28_29_20const(HEAP32[$0 + 48 >> 2])) { + __assert_fail(9574, 5083, 47, 3186); + wasm2js_trap(); + } + if (b2Fixture__GetType_28_29_20const(HEAP32[$0 + 52 >> 2])) { + __assert_fail(9531, 5083, 48, 3186); + wasm2js_trap(); + } + __stack_pointer = $3 + 16 | 0; + return HEAP32[$3 + 12 >> 2]; +} + +function b2CircleContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + var $5 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + wasm2js_i32$0 = $5, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$5 + 12 >> 2], 148), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$5 + 8 >> 2]; + b2CircleContact__b2CircleContact_28b2Fixture__2c_20b2Fixture__29($0, HEAP32[$5 + 28 >> 2], HEAP32[$5 + 20 >> 2]); + __stack_pointer = $5 + 32 | 0; + return $0 | 0; +} + +function void_20emscripten__wrapper_b2Draw___call_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const___28char_20const__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29_20const($0, $1, $2, $3, $4) { + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + void_20emscripten__val__call_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const___28char_20const__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29_20const(HEAP32[$5 + 28 >> 2] + 12 | 0, HEAP32[$5 + 24 >> 2], HEAP32[$5 + 20 >> 2], HEAP32[$5 + 16 >> 2], HEAP32[$5 + 12 >> 2]); + __stack_pointer = $5 + 32 | 0; +} + +function std____2____compressed_pair_int__2c_20std____2__allocator_int______compressed_pair_5babi_v160004_5d_std__nullptr_t_2c_20std____2____default_init_tag__28std__nullptr_t___2c_20std____2____default_init_tag___29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + std____2____compressed_pair_elem_int__2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std__nullptr_t_2c_20void__28std__nullptr_t___29($0, HEAP32[$3 + 8 >> 2]); + std____2____compressed_pair_elem_std____2__allocator_int__2c_201_2c_20true_____compressed_pair_elem_5babi_v160004_5d_28std____2____default_init_tag_29($0); + __stack_pointer = $3 + 16 | 0; + return $0; +} + +function emscripten__internal__MethodInvoker_b2Body__20_28b2Joint____29_28_29_2c_20b2Body__2c_20b2Joint____invoke_28b2Body__20_28b2Joint____20const__29_28_29_2c_20b2Joint__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Joint__2c_20void___fromWireType_28b2Joint__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_b2Body__2c_20void___toWireType_28b2Body__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__MethodInvoker_b2World__20_28b2Body____29_28_29_2c_20b2World__2c_20b2Body____invoke_28b2World__20_28b2Body____20const__29_28_29_2c_20b2Body__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + $0 = emscripten__internal__BindingType_b2World__2c_20void___toWireType_28b2World__29(FUNCTION_TABLE[$0 | 0]($1) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____vector_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 >> 2] = 0; + HEAP32[$0 + 4 >> 2] = 0; + HEAP32[$1 + 8 >> 2] = 0; + std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2______compressed_pair_5babi_v160004_5d_std__nullptr_t_2c_20std____2____default_init_tag__28std__nullptr_t___2c_20std____2____default_init_tag___29($0 + 8 | 0, $1 + 8 | 0, $1 + 7 | 0); + void_20std____2____debug_db_insert_c_5babi_v160004_5d_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__enable_if_is_reference_decltype_28_std__declval_std____2__reverse_iterator_b2Vec2_____28_29_29___value_2c_20decltype_28std__move_28_std__declval_std____2__reverse_iterator_b2Vec2_____28_29_29_29___type_20std____2___IterOps_std____2___ClassicAlgPolicy_____iter_move_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2_____28std____2__reverse_iterator_b2Vec2____29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + void_20std____2___IterOps_std____2___ClassicAlgPolicy_____validate_iter_reference_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2_____28_29(); + $0 = std____2__reverse_iterator_b2Vec2____operator__5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function bool_20_28b2Shape____emscripten__internal__getContext_bool_20_28b2Shape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const__28bool_20_28b2Shape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__Invoker_unsigned_20int_2c_20unsigned_20int___invoke_28unsigned_20int_20_28__29_28unsigned_20int_29_2c_20unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$2 + 8 >> 2])) | 0, + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = emscripten__internal__BindingType_unsigned_20int_2c_20void___toWireType_28unsigned_20int_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Mul_28b2Mat33_20const__2c_20b2Vec3_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer + -64 | 0; + __stack_pointer = $3; + HEAP32[$3 + 60 >> 2] = $1; + HEAP32[$3 + 56 >> 2] = $2; + operator__28float_2c_20b2Vec3_20const__29($3 + 32 | 0, HEAPF32[HEAP32[$3 + 56 >> 2] >> 2], HEAP32[$3 + 60 >> 2]); + operator__28float_2c_20b2Vec3_20const__29($3 + 20 | 0, HEAPF32[HEAP32[$3 + 56 >> 2] + 4 >> 2], HEAP32[$3 + 60 >> 2] + 12 | 0); + operator__28b2Vec3_20const__2c_20b2Vec3_20const__29($3 + 44 | 0, $3 + 32 | 0, $3 + 20 | 0); + operator__28float_2c_20b2Vec3_20const__29($3 + 8 | 0, HEAPF32[HEAP32[$3 + 56 >> 2] + 8 >> 2], HEAP32[$3 + 60 >> 2] + 24 | 0); + operator__28b2Vec3_20const__2c_20b2Vec3_20const__29($0, $3 + 44 | 0, $3 + 8 | 0); + __stack_pointer = $3 - -64 | 0; +} + +function void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______emscripten__internal__getContext_void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28unsigned_20long_2c_20b2Vec2_20const__29__28void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______20const__29_28unsigned_20long_2c_20b2Vec2_20const__29_29_29_28unsigned_20long_2c_20b2Vec2_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2__operator___5babi_v160004_5d_28std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__2c_20std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__29_1($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = std____2__operator___5babi_v160004_5d_28std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__2c_20std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__29(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]) ^ -1; + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function b2EdgeShape__ComputeMass_28b2MassData__2c_20float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0, $4 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAPF32[$3 + 20 >> 2] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + HEAPF32[HEAP32[$3 + 24 >> 2] >> 2] = 0; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 4 | 0, $0 + 12 | 0, $0 + 20 | 0); + operator__28float_2c_20b2Vec2_20const__29($3 + 12 | 0, Math_fround(.5), $3 + 4 | 0); + $4 = HEAP32[$3 + 16 >> 2]; + $0 = HEAP32[$3 + 12 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 24 >> 2]; + HEAP32[$0 + 4 >> 2] = $1; + HEAP32[$0 + 8 >> 2] = $4; + HEAPF32[HEAP32[$3 + 24 >> 2] + 12 >> 2] = 0; + __stack_pointer = $3 + 32 | 0; +} + +function void_20emscripten__val__call_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const___28char_20const__2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const__29_20const($0, $1, $2, $3, $4) { + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + emscripten__internal__MethodCaller_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const____call_28emscripten___EM_VAL__2c_20char_20const__2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const__29(HEAP32[HEAP32[$5 + 28 >> 2] >> 2], HEAP32[$5 + 24 >> 2], HEAP32[$5 + 20 >> 2], HEAP32[$5 + 16 >> 2], HEAP32[$5 + 12 >> 2]); + __stack_pointer = $5 + 32 | 0; +} + +function emscripten__internal__Signature_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const____get_method_caller_28_29() { + var $0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $0 = __stack_pointer - 16 | 0; + __stack_pointer = $0; + if (!(HEAP8[30076] & 1)) { + wasm2js_i32$0 = 30072, wasm2js_i32$1 = _emval_get_method_caller(emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const____getCount_28_29_20const($0 + 15 | 0) | 0, emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const____getTypes_28_29_20const($0 + 15 | 0) | 0) | 0, + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP8[30076] = 1; + } + __stack_pointer = $0 + 16 | 0; + return HEAP32[7518]; +} + +function emscripten__internal__Invoker_b2RayCastCallbackWrapper__2c_20emscripten__val_____invoke_28b2RayCastCallbackWrapper__20_28__29_28emscripten__val___29_2c_20emscripten___EM_VAL__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + emscripten__internal__BindingType_emscripten__val___2c_20void___fromWireType_28emscripten___EM_VAL__29($2 + 4 | 0, HEAP32[$2 + 8 >> 2]); + $0 = emscripten__internal__BindingType_b2RayCastCallbackWrapper__2c_20void___toWireType_28b2RayCastCallbackWrapper__29(FUNCTION_TABLE[$0 | 0]($2 + 4 | 0) | 0); + emscripten__val___val_28_29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__Invoker_b2ContactListenerWrapper__2c_20emscripten__val_____invoke_28b2ContactListenerWrapper__20_28__29_28emscripten__val___29_2c_20emscripten___EM_VAL__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + emscripten__internal__BindingType_emscripten__val___2c_20void___fromWireType_28emscripten___EM_VAL__29($2 + 4 | 0, HEAP32[$2 + 8 >> 2]); + $0 = emscripten__internal__BindingType_b2ContactListenerWrapper__2c_20void___toWireType_28b2ContactListenerWrapper__29(FUNCTION_TABLE[$0 | 0]($2 + 4 | 0) | 0); + emscripten__val___val_28_29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2BroadPhase__TestOverlap_28int_2c_20int_29_20const($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2DynamicTree__GetFatAABB_28int_29_20const($0, HEAP32[$3 + 24 >> 2]), + HEAP32[wasm2js_i32$0 + 16 >> 2] = wasm2js_i32$1; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2DynamicTree__GetFatAABB_28int_29_20const($0, HEAP32[$3 + 20 >> 2]), + HEAP32[wasm2js_i32$0 + 12 >> 2] = wasm2js_i32$1; + $0 = b2TestOverlap_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$3 + 16 >> 2], HEAP32[$3 + 12 >> 2]); + __stack_pointer = $3 + 32 | 0; + return $0 & 1; +} + +function std____2__enable_if_is_reference_decltype_28_std__declval_std____2__reverse_iterator_int_____28_29_29___value_2c_20decltype_28std__move_28_std__declval_std____2__reverse_iterator_int_____28_29_29_29___type_20std____2___IterOps_std____2___ClassicAlgPolicy_____iter_move_5babi_v160004_5d_std____2__reverse_iterator_int_____28std____2__reverse_iterator_int____29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + void_20std____2___IterOps_std____2___ClassicAlgPolicy_____validate_iter_reference_5babi_v160004_5d_std____2__reverse_iterator_int_____28_29(); + $0 = std____2__reverse_iterator_int____operator__5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__val__call_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const___28char_20const__2c_20unsigned_20int__2c_20int__2c_20b2Color_20const__29_20const($0, $1, $2, $3, $4) { + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + emscripten__internal__MethodCaller_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const____call_28emscripten___EM_VAL__2c_20char_20const__2c_20unsigned_20int__2c_20int__2c_20b2Color_20const__29(HEAP32[HEAP32[$5 + 28 >> 2] >> 2], HEAP32[$5 + 24 >> 2], HEAP32[$5 + 20 >> 2], HEAP32[$5 + 16 >> 2], HEAP32[$5 + 12 >> 2]); + __stack_pointer = $5 + 32 | 0; +} + +function b2Vec2__Normalize_28_29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + wasm2js_i32$0 = $1, wasm2js_f32$0 = b2Vec2__Length_28_29_20const($0), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + label$1: { + if (HEAPF32[$1 + 4 >> 2] < Math_fround(1.1920928955078125e-7)) { + HEAPF32[$1 + 12 >> 2] = 0; + break label$1; + } + HEAPF32[$1 >> 2] = Math_fround(1) / HEAPF32[$1 + 4 >> 2]; + HEAPF32[$0 >> 2] = HEAPF32[$0 >> 2] * HEAPF32[$1 >> 2]; + HEAPF32[$0 + 4 >> 2] = HEAPF32[$0 + 4 >> 2] * HEAPF32[$1 >> 2]; + HEAPF32[$1 + 12 >> 2] = HEAPF32[$1 + 4 >> 2]; + } + __stack_pointer = $1 + 16 | 0; + return HEAPF32[$1 + 12 >> 2]; +} + +function emscripten__internal__Signature_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const____get_method_caller_28_29() { + var $0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $0 = __stack_pointer - 16 | 0; + __stack_pointer = $0; + if (!(HEAP8[30068] & 1)) { + wasm2js_i32$0 = 30064, wasm2js_i32$1 = _emval_get_method_caller(emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const____getCount_28_29_20const($0 + 15 | 0) | 0, emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const____getTypes_28_29_20const($0 + 15 | 0) | 0) | 0, + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP8[30068] = 1; + } + __stack_pointer = $0 + 16 | 0; + return HEAP32[7516]; +} + +function b2WheelJointDef__b2WheelJointDef_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2JointDef__b2JointDef_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 20 | 0); + b2Vec2__b2Vec2_28_29($0 + 28 | 0); + b2Vec2__b2Vec2_28_29($0 + 36 | 0); + HEAP32[$0 >> 2] = 7; + b2Vec2__SetZero_28_29($0 + 20 | 0); + b2Vec2__SetZero_28_29($0 + 28 | 0); + b2Vec2__Set_28float_2c_20float_29($0 + 36 | 0, Math_fround(1), Math_fround(0)); + HEAP8[$0 + 44 | 0] = 0; + HEAPF32[$0 + 48 >> 2] = 0; + HEAPF32[$0 + 52 >> 2] = 0; + HEAP8[$0 + 56 | 0] = 0; + HEAPF32[$0 + 60 >> 2] = 0; + HEAPF32[$0 + 64 >> 2] = 0; + HEAPF32[$0 + 68 >> 2] = 0; + HEAPF32[$0 + 72 >> 2] = 0; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__VectorAccess_std____2__vector_int_2c_20std____2__allocator_int_____set_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[HEAP32[$3 + 4 >> 2] >> 2]; + wasm2js_i32$0 = std____2__vector_int_2c_20std____2__allocator_int____operator_5b_5d_5babi_v160004_5d_28unsigned_20long_29(HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2]), + wasm2js_i32$1 = $0, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + __stack_pointer = $3 + 16 | 0; + return 1; +} + +function unsigned_20long_20const__20std____2__min_5babi_v160004_5d_unsigned_20long_2c_20std____2____less_unsigned_20long_2c_20unsigned_20long___28unsigned_20long_20const__2c_20unsigned_20long_20const__2c_20std____2____less_unsigned_20long_2c_20unsigned_20long__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 4 >> 2] = $1; + label$1: { + if (std____2____less_unsigned_20long_2c_20unsigned_20long___operator_28_29_5babi_v160004_5d_28unsigned_20long_20const__2c_20unsigned_20long_20const__29_20const($2 + 15 | 0, HEAP32[$2 + 4 >> 2], HEAP32[$2 + 8 >> 2]) & 1) { + $0 = HEAP32[$2 + 4 >> 2]; + break label$1; + } + $0 = HEAP32[$2 + 8 >> 2]; + } + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function unsigned_20long_20const__20std____2__max_5babi_v160004_5d_unsigned_20long_2c_20std____2____less_unsigned_20long_2c_20unsigned_20long___28unsigned_20long_20const__2c_20unsigned_20long_20const__2c_20std____2____less_unsigned_20long_2c_20unsigned_20long__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 4 >> 2] = $1; + label$1: { + if (std____2____less_unsigned_20long_2c_20unsigned_20long___operator_28_29_5babi_v160004_5d_28unsigned_20long_20const__2c_20unsigned_20long_20const__29_20const($2 + 15 | 0, HEAP32[$2 + 8 >> 2], HEAP32[$2 + 4 >> 2]) & 1) { + $0 = HEAP32[$2 + 4 >> 2]; + break label$1; + } + $0 = HEAP32[$2 + 8 >> 2]; + } + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function emscripten__internal__FunctionInvoker_void_20_28__29_28b2Body__2c_20b2MassData_20const__29_2c_20void_2c_20b2Body__2c_20b2MassData_20const____invoke_28void_20_28___29_28b2Body__2c_20b2MassData_20const__29_2c_20b2Body__2c_20b2MassData__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[HEAP32[$3 + 12 >> 2] >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$3 + 8 >> 2]), emscripten__internal__GenericBindingType_b2MassData___fromWireType_28b2MassData__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int____vector_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 >> 2] = 0; + HEAP32[$0 + 4 >> 2] = 0; + HEAP32[$1 + 8 >> 2] = 0; + std____2____compressed_pair_int__2c_20std____2__allocator_int______compressed_pair_5babi_v160004_5d_std__nullptr_t_2c_20std____2____default_init_tag__28std__nullptr_t___2c_20std____2____default_init_tag___29($0 + 8 | 0, $1 + 8 | 0, $1 + 7 | 0); + void_20std____2____debug_db_insert_c_5babi_v160004_5d_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int____29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__Invoker_b2QueryCallbackWrapper__2c_20emscripten__val_____invoke_28b2QueryCallbackWrapper__20_28__29_28emscripten__val___29_2c_20emscripten___EM_VAL__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + emscripten__internal__BindingType_emscripten__val___2c_20void___fromWireType_28emscripten___EM_VAL__29($2 + 4 | 0, HEAP32[$2 + 8 >> 2]); + $0 = emscripten__internal__BindingType_b2QueryCallbackWrapper__2c_20void___toWireType_28b2QueryCallbackWrapper__29(FUNCTION_TABLE[$0 | 0]($2 + 4 | 0) | 0); + emscripten__val___val_28_29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2DynamicTree__FreeNode_28int_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (!(HEAP32[$2 + 8 >> 2] < HEAP32[$0 + 12 >> 2] & HEAP32[$2 + 8 >> 2] >= 0)) { + __assert_fail(1382, 5965, 98, 9843); + wasm2js_trap(); + } + if (HEAP32[$0 + 8 >> 2] <= 0) { + __assert_fail(2369, 5965, 99, 9843); + wasm2js_trap(); + } + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 20 >> 2] = HEAP32[$0 + 16 >> 2]; + HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 32 >> 2] = -1; + HEAP32[$0 + 16 >> 2] = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 8 >> 2] = HEAP32[$0 + 8 >> 2] - 1; + __stack_pointer = $2 + 16 | 0; +} + +function b2BodyDef__b2BodyDef_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0 + 4 | 0); + b2Vec2__b2Vec2_28_29($0 + 16 | 0); + HEAP32[$0 + 44 >> 2] = 0; + b2Vec2__Set_28float_2c_20float_29($0 + 4 | 0, Math_fround(0), Math_fround(0)); + HEAPF32[$0 + 12 >> 2] = 0; + b2Vec2__Set_28float_2c_20float_29($0 + 16 | 0, Math_fround(0), Math_fround(0)); + HEAPF32[$0 + 24 >> 2] = 0; + HEAPF32[$0 + 28 >> 2] = 0; + HEAPF32[$0 + 32 >> 2] = 0; + HEAP8[$0 + 36 | 0] = 1; + HEAP8[$0 + 37 | 0] = 1; + HEAP8[$0 + 38 | 0] = 0; + HEAP8[$0 + 39 | 0] = 0; + HEAP32[$0 >> 2] = 0; + HEAP8[$0 + 40 | 0] = 1; + HEAPF32[$0 + 48 >> 2] = 1; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function float_20_28b2RayCastCallback____emscripten__internal__getContext_float_20_28b2RayCastCallback____29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29__28float_20_28b2RayCastCallback____20const__29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29_29_29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20emscripten__wrapper_b2Draw___call_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const___28char_20const__2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const__29_20const($0, $1, $2, $3, $4) { + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + void_20emscripten__val__call_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const___28char_20const__2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const__29_20const(HEAP32[$5 + 28 >> 2] + 12 | 0, HEAP32[$5 + 24 >> 2], HEAP32[$5 + 20 >> 2], HEAP32[$5 + 16 >> 2], HEAP32[$5 + 12 >> 2]); + __stack_pointer = $5 + 32 | 0; +} + +function void_20_28std____2__vector_int_2c_20std____2__allocator_int______emscripten__internal__getContext_void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28unsigned_20long_2c_20int_20const__29__28void_20_28std____2__vector_int_2c_20std____2__allocator_int______20const__29_28unsigned_20long_2c_20int_20const__29_29_29_28unsigned_20long_2c_20int_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2SizeMap__b2SizeMap_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$1 + 4 >> 2] = 0; + HEAP8[$0 | 0] = 0; + HEAP32[$1 >> 2] = 1; + while (1) { + if (HEAP32[$1 >> 2] <= 640) { + if (HEAP32[$1 + 4 >> 2] >= 14) { + __assert_fail(2175, 5349, 60, 6253); + wasm2js_trap(); + } else { + if (HEAP32[$1 >> 2] > HEAP32[(HEAP32[$1 + 4 >> 2] << 2) + 18128 >> 2]) { + HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] + 1; + } + HEAP8[HEAP32[$1 >> 2] + $0 | 0] = HEAP32[$1 + 4 >> 2]; + HEAP32[$1 >> 2] = HEAP32[$1 >> 2] + 1; + continue; + } + } + break; + } + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2PrismaticJoint__GetReactionForce_28float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $1; + HEAPF32[$3 + 24 >> 2] = $2; + $2 = HEAPF32[$3 + 24 >> 2]; + $1 = HEAP32[$3 + 28 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($3 + 8 | 0, HEAPF32[$1 + 104 >> 2], $1 + 192 | 0); + operator__28float_2c_20b2Vec2_20const__29($3, Math_fround(Math_fround(HEAPF32[$1 + 112 >> 2] + HEAPF32[$1 + 116 >> 2]) + HEAPF32[$1 + 120 >> 2]), $1 + 184 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 16 | 0, $3 + 8 | 0, $3); + operator__28float_2c_20b2Vec2_20const__29($0, $2, $3 + 16 | 0); + __stack_pointer = $3 + 32 | 0; +} + +function b2Body__ApplyLinearImpulseToCenter_28b2Vec2_20const__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP8[$3 + 23 | 0] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + label$1: { + if (HEAP32[$0 >> 2] != 2) { + break label$1; + } + if (!(!(HEAP8[$3 + 23 | 0] & 1) | HEAPU16[$0 + 4 >> 1] & 2)) { + b2Body__SetAwake_28bool_29($0, 1); + } + if (!(HEAPU16[$0 + 4 >> 1] & 2)) { + break label$1; + } + operator__28float_2c_20b2Vec2_20const__29($3 + 12 | 0, HEAPF32[$0 + 120 >> 2], HEAP32[$3 + 24 >> 2]); + b2Vec2__operator___28b2Vec2_20const__29($0 - -64 | 0, $3 + 12 | 0); + } + __stack_pointer = $3 + 32 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2FixtureDef_2c_20b2Filter___setWire_b2FixtureDef__28b2Filter_20b2FixtureDef____20const__2c_20b2FixtureDef__2c_20b2Filter__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = emscripten__internal__GenericBindingType_b2Filter___fromWireType_28b2Filter__29(HEAP32[$3 + 4 >> 2]); + $1 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + $2 = HEAPU16[$0 >> 1] | HEAPU16[$0 + 2 >> 1] << 16; + HEAP16[$1 >> 1] = $2; + HEAP16[$1 + 2 >> 1] = $2 >>> 16; + HEAP16[$1 + 4 >> 1] = HEAPU16[$0 + 4 >> 1]; + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__VectorAccess_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____set_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 4 >> 2]; + $1 = std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____operator_5b_5d_5babi_v160004_5d_28unsigned_20long_29(HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2]); + $2 = HEAP32[$0 + 4 >> 2]; + HEAP32[$1 >> 2] = HEAP32[$0 >> 2]; + HEAP32[$1 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; + return 1; +} + +function void_20std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______construct_5babi_v160004_5d_b2Fixture__2c_20b2Fixture__20const__2c_20void__28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20b2Fixture___2c_20b2Fixture__20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + void_20std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____construct_5babi_v160004_5d_b2Fixture__2c_20b2Fixture__20const___28b2Fixture___2c_20b2Fixture__20const__29(HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__wrapper_b2Draw___call_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const___28char_20const__2c_20unsigned_20int__2c_20int__2c_20b2Color_20const__29_20const($0, $1, $2, $3, $4) { + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + __stack_pointer = $5; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; + void_20emscripten__val__call_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const___28char_20const__2c_20unsigned_20int__2c_20int__2c_20b2Color_20const__29_20const(HEAP32[$5 + 28 >> 2] + 12 | 0, HEAP32[$5 + 24 >> 2], HEAP32[$5 + 20 >> 2], HEAP32[$5 + 16 >> 2], HEAP32[$5 + 12 >> 2]); + __stack_pointer = $5 + 32 | 0; +} + +function b2PrismaticJointDef__b2PrismaticJointDef_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2JointDef__b2JointDef_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 20 | 0); + b2Vec2__b2Vec2_28_29($0 + 28 | 0); + b2Vec2__b2Vec2_28_29($0 + 36 | 0); + HEAP32[$0 >> 2] = 2; + b2Vec2__SetZero_28_29($0 + 20 | 0); + b2Vec2__SetZero_28_29($0 + 28 | 0); + b2Vec2__Set_28float_2c_20float_29($0 + 36 | 0, Math_fround(1), Math_fround(0)); + HEAPF32[$0 + 44 >> 2] = 0; + HEAP8[$0 + 48 | 0] = 0; + HEAPF32[$0 + 52 >> 2] = 0; + HEAPF32[$0 + 56 >> 2] = 0; + HEAP8[$0 + 60 | 0] = 0; + HEAPF32[$0 + 64 >> 2] = 0; + HEAPF32[$0 + 68 >> 2] = 0; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2ContactListenerWrapper__BeginContact_28unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + label$1: { + if (!(b2ContactListenerWrapper__isIndexOf_28unsigned_20int_29($0, b2Contact__GetFixtureA_28_29(HEAP32[$2 + 8 >> 2])) & 1)) { + if (!(b2ContactListenerWrapper__isIndexOf_28unsigned_20int_29($0, b2Contact__GetFixtureB_28_29(HEAP32[$2 + 8 >> 2])) & 1)) { + break label$1; + } + } + void_20emscripten__wrapper_b2ContactListener___call_void_2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__29_20const($0, 3100, $2 + 8 | 0); + } + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__FunctionInvoker_void_20_28__29_28b2JointDef__2c_20b2Body__29_2c_20void_2c_20b2JointDef__2c_20b2Body____invoke_28void_20_28___29_28b2JointDef__2c_20b2Body__29_2c_20b2JointDef__2c_20b2Body__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[HEAP32[$3 + 12 >> 2] >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_b2JointDef__2c_20void___fromWireType_28b2JointDef__29(HEAP32[$3 + 8 >> 2]), emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function b2ContactListenerWrapper__EndContact_28unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + label$1: { + if (!(b2ContactListenerWrapper__isIndexOf_28unsigned_20int_29($0, b2Contact__GetFixtureA_28_29(HEAP32[$2 + 8 >> 2])) & 1)) { + if (!(b2ContactListenerWrapper__isIndexOf_28unsigned_20int_29($0, b2Contact__GetFixtureB_28_29(HEAP32[$2 + 8 >> 2])) & 1)) { + break label$1; + } + } + void_20emscripten__wrapper_b2ContactListener___call_void_2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__29_20const($0, 3202, $2 + 8 | 0); + } + __stack_pointer = $2 + 16 | 0; +} + +function b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + b2Min_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 12 | 0, HEAP32[$3 + 24 >> 2], HEAP32[$3 + 20 >> 2]); + $1 = HEAP32[$3 + 16 >> 2]; + $2 = HEAP32[$3 + 12 >> 2]; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $1; + b2Max_28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 4 | 0, HEAP32[$3 + 24 >> 2] + 8 | 0, HEAP32[$3 + 20 >> 2] + 8 | 0); + $2 = HEAP32[$3 + 8 >> 2]; + $1 = HEAP32[$3 + 4 >> 2]; + HEAP32[$0 + 8 >> 2] = $1; + HEAP32[$0 + 12 >> 2] = $2; + __stack_pointer = $3 + 32 | 0; +} + +function emscripten__internal__Invoker_int_2c_20unsigned_20int___invoke_28int_20_28__29_28unsigned_20int_29_2c_20unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$2 + 8 >> 2])) | 0, + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = emscripten__internal__BindingType_int_2c_20void___toWireType_28int_20const__29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function std____2__pair_char_20const__2c_20char___20std____2____copy_trivial_impl_5babi_v160004_5d_char_20const_2c_20char__28char_20const__2c_20char_20const__2c_20char__29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $2; + $2 = $2 - $1 | 0; + wasm2js_i32$0 = $4, wasm2js_i32$1 = $2 + memmove($3, $1, $2) | 0, HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + std____2__pair_std____2____unwrap_ref_decay_char_20const_____type_2c_20std____2____unwrap_ref_decay_char____type__20std____2__make_pair_5babi_v160004_5d_char_20const___2c_20char___28char_20const___2c_20char____29($0, $4 + 12 | 0, $4 + 8 | 0); + __stack_pointer = $4 + 16 | 0; +} + +function b2Body__GetMassData_28b2MassData__29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0), $4 = Math_fround(0), $5 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAPF32[HEAP32[$2 + 8 >> 2] >> 2] = HEAPF32[$0 + 116 >> 2]; + $3 = HEAPF32[$0 + 124 >> 2]; + $4 = Math_fround(HEAPF32[$0 + 116 >> 2] * b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0 + 28 | 0, $0 + 28 | 0)); + HEAPF32[HEAP32[$2 + 8 >> 2] + 12 >> 2] = $4 + $3; + $5 = HEAP32[$0 + 32 >> 2]; + $0 = HEAP32[$0 + 28 >> 2]; + $1 = $0; + $0 = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 4 >> 2] = $1; + HEAP32[$0 + 8 >> 2] = $5; + __stack_pointer = $2 + 16 | 0; +} + +function b2PolygonAndCircleContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $0 = HEAP32[$4 + 12 >> 2]; + b2CollidePolygonAndCircle_28b2Manifold__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2CircleShape_20const__2c_20b2Transform_20const__29(HEAP32[$4 + 8 >> 2], b2Fixture__GetShape_28_29(HEAP32[$0 + 48 >> 2]), HEAP32[$4 + 4 >> 2], b2Fixture__GetShape_28_29(HEAP32[$0 + 52 >> 2]), HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function fmt_u($0, $1, $2) { + var $3 = 0, $4 = 0, $5 = 0, $6 = 0; + label$1: { + if (!$1) { + $5 = $0; + $4 = $1; + $6 = $4; + break label$1; + } + while (1) { + $4 = $1; + $3 = __wasm_i64_udiv($0, $4, 10, 0); + $4 = i64toi32_i32$HIGH_BITS; + $6 = $4; + $5 = $3; + $3 = __wasm_i64_mul($5, $4, 10, 0); + $4 = i64toi32_i32$HIGH_BITS; + $2 = $2 - 1 | 0; + HEAP8[$2 | 0] = $0 - $3 | 48; + $3 = $1 >>> 0 > 9; + $0 = $5; + $4 = $6; + $1 = $4; + if ($3) { + continue; + } + break; + } + } + $3 = $5; + if ($3) { + while (1) { + $2 = $2 - 1 | 0; + $0 = ($3 >>> 0) / 10 | 0; + HEAP8[$2 | 0] = $3 - Math_imul($0, 10) | 48; + $1 = $3 >>> 0 > 9; + $3 = $0; + if ($1) { + continue; + } + break; + } + } + return $2; +} + +function emscripten__internal__Signature_void_2c_20unsigned_20int__2c_20unsigned_20int____get_method_caller_28_29() { + var $0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $0 = __stack_pointer - 16 | 0; + __stack_pointer = $0; + if (!(HEAP8[30060] & 1)) { + wasm2js_i32$0 = 30056, wasm2js_i32$1 = _emval_get_method_caller(emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int__2c_20unsigned_20int____getCount_28_29_20const($0 + 15 | 0) | 0, emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int__2c_20unsigned_20int____getTypes_28_29_20const($0 + 15 | 0) | 0) | 0, + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP8[30060] = 1; + } + __stack_pointer = $0 + 16 | 0; + return HEAP32[7514]; +} + +function b2EdgeAndPolygonContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $0 = HEAP32[$4 + 12 >> 2]; + b2CollideEdgeAndPolygon_28b2Manifold__2c_20b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__29(HEAP32[$4 + 8 >> 2], b2Fixture__GetShape_28_29(HEAP32[$0 + 48 >> 2]), HEAP32[$4 + 4 >> 2], b2Fixture__GetShape_28_29(HEAP32[$0 + 52 >> 2]), HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function b2World__SetAllowSleeping_28bool_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + label$1: { + if ((HEAP8[$2 + 11 | 0] & 1) == (HEAP8[$0 + 102972 | 0] & 1)) { + break label$1; + } + HEAP8[$0 + 102972 | 0] = HEAP8[$2 + 11 | 0] & 1; + if (HEAP8[$0 + 102972 | 0] & 1) { + break label$1; + } + HEAP32[$2 + 4 >> 2] = HEAP32[$0 + 102948 >> 2]; + while (1) { + if (HEAP32[$2 + 4 >> 2]) { + b2Body__SetAwake_28bool_29(HEAP32[$2 + 4 >> 2], 1); + HEAP32[$2 + 4 >> 2] = HEAP32[HEAP32[$2 + 4 >> 2] + 96 >> 2]; + continue; + } + break; + } + } + __stack_pointer = $2 + 16 | 0; +} + +function unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______emscripten__internal__getContext_unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28_29_20const__28unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__MethodInvoker_void_20_28b2PrismaticJoint____29_28_29_2c_20void_2c_20b2PrismaticJoint____invoke_28void_20_28b2PrismaticJoint____20const__29_28_29_2c_20b2PrismaticJoint__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2PrismaticJoint__2c_20void___fromWireType_28b2PrismaticJoint__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($1); + __stack_pointer = $2 + 16 | 0; +} + +function b2EdgeAndCircleContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $0 = HEAP32[$4 + 12 >> 2]; + b2CollideEdgeAndCircle_28b2Manifold__2c_20b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2CircleShape_20const__2c_20b2Transform_20const__29(HEAP32[$4 + 8 >> 2], b2Fixture__GetShape_28_29(HEAP32[$0 + 48 >> 2]), HEAP32[$4 + 4 >> 2], b2Fixture__GetShape_28_29(HEAP32[$0 + 52 >> 2]), HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const__28void_20_28b2World____20const__29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const_29_29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Draw____emscripten__internal__getContext_void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29__28void_20_28b2Draw____20const__29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29_29_29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__Invoker_b2DrawWrapper__2c_20emscripten__val_____invoke_28b2DrawWrapper__20_28__29_28emscripten__val___29_2c_20emscripten___EM_VAL__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + emscripten__internal__BindingType_emscripten__val___2c_20void___fromWireType_28emscripten___EM_VAL__29($2 + 4 | 0, HEAP32[$2 + 8 >> 2]); + $0 = emscripten__internal__BindingType_b2DrawWrapper__2c_20void___toWireType_28b2DrawWrapper__29(FUNCTION_TABLE[$0 | 0]($2 + 4 | 0) | 0); + emscripten__val___val_28_29($2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______end_node_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__pointer_traits_std____2____tree_end_node_std____2____tree_node_base_void________pointer_to_5babi_v160004_5d_28std____2____tree_end_node_std____2____tree_node_base_void______29(std____2____compressed_pair_std____2____tree_end_node_std____2____tree_node_base_void_____2c_20std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______first_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2] + 4 | 0)); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__FunctionInvoker_void_20_28__29_28b2Shape__2c_20float_29_2c_20void_2c_20b2Shape__2c_20float___invoke_28void_20_28___29_28b2Shape__2c_20float_29_2c_20b2Shape__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $0 = HEAP32[HEAP32[$3 + 12 >> 2] >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_b2Shape__2c_20void___fromWireType_28b2Shape__29(HEAP32[$3 + 8 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2PrismaticJointDef_2c_20b2Vec2___setWire_b2PrismaticJointDef__28b2Vec2_20b2PrismaticJointDef____20const__2c_20b2PrismaticJointDef__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2RevoluteJoint____29_28_29_2c_20void_2c_20b2RevoluteJoint____invoke_28void_20_28b2RevoluteJoint____20const__29_28_29_2c_20b2RevoluteJoint__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2RevoluteJoint__2c_20void___fromWireType_28b2RevoluteJoint__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($1); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2DistanceJoint____29_28_29_2c_20void_2c_20b2DistanceJoint____invoke_28void_20_28b2DistanceJoint____20const__29_28_29_2c_20b2DistanceJoint__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2DistanceJoint__2c_20void___fromWireType_28b2DistanceJoint__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($1); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__MethodCaller_void___call_28emscripten___EM_VAL__2c_20char_20const__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + wasm2js_i32$0 = $2, wasm2js_i32$1 = emscripten__internal__Signature_void___get_method_caller_28_29(), + HEAP32[wasm2js_i32$0 + 20 >> 2] = wasm2js_i32$1; + emscripten__internal__WireTypePack____WireTypePack_28_29($2 + 8 | 0); + _emval_call_void_method(HEAP32[$2 + 20 >> 2], HEAP32[$2 + 28 >> 2], HEAP32[$2 + 24 >> 2], emscripten__internal__WireTypePack____operator_20void_20const__28_29_20const($2 + 8 | 0) | 0); + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__Invoker_void_2c_20unsigned_20int_2c_20unsigned_20int___invoke_28void_20_28__29_28unsigned_20int_2c_20unsigned_20int_29_2c_20unsigned_20int_2c_20unsigned_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$3 + 8 >> 2]), emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function b2PolygonContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $0 = HEAP32[$4 + 12 >> 2]; + b2CollidePolygons_28b2Manifold__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2PolygonShape_20const__2c_20b2Transform_20const__29(HEAP32[$4 + 8 >> 2], b2Fixture__GetShape_28_29(HEAP32[$0 + 48 >> 2]), HEAP32[$4 + 4 >> 2], b2Fixture__GetShape_28_29(HEAP32[$0 + 52 >> 2]), HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______set_long_cap_5babi_v160004_5d_28unsigned_20long_29($0, $1) { + var $2 = 0; + $2 = std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29($0); + HEAP32[$2 + 8 >> 2] = HEAP32[$2 + 8 >> 2] & -2147483648 | $1 & 2147483647; + $0 = std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29($0); + HEAP32[$0 + 8 >> 2] = HEAP32[$0 + 8 >> 2] | -2147483648; +} + +function std____2____compressed_pair_elem_std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_201_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20void__28std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$1 >> 2]; + $3 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $3; + return $0; +} + +function void_20emscripten__internal__MemberAccess_b2RevoluteJointDef_2c_20b2Vec2___setWire_b2RevoluteJointDef__28b2Vec2_20b2RevoluteJointDef____20const__2c_20b2RevoluteJointDef__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2DistanceJointDef_2c_20b2Vec2___setWire_b2DistanceJointDef__28b2Vec2_20b2DistanceJointDef____20const__2c_20b2DistanceJointDef__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__FunctionInvoker_void_20_28__29_28b2AABB__2c_20b2AABB__29_2c_20void_2c_20b2AABB__2c_20b2AABB____invoke_28void_20_28___29_28b2AABB__2c_20b2AABB__29_2c_20b2AABB__2c_20b2AABB__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[HEAP32[$3 + 12 >> 2] >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_b2AABB__2c_20void___fromWireType_28b2AABB__29(HEAP32[$3 + 8 >> 2]), emscripten__internal__BindingType_b2AABB__2c_20void___fromWireType_28b2AABB__29(HEAP32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__BindingType_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___2c_20void___fromWireType_28emscripten__internal__BindingType_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___2c_20void____unnamed___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____basic_string_5babi_v160004_5d_28char_20const__2c_20unsigned_20long_29($0, HEAP32[$2 + 8 >> 2] + 4 | 0, HEAP32[HEAP32[$2 + 8 >> 2] >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function b2BroadPhase__MoveProxy_28int_2c_20b2AABB_20const__2c_20b2Vec2_20const__29($0, $1, $2, $3) { + var $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $4 = __stack_pointer - 32 | 0; + __stack_pointer = $4; + HEAP32[$4 + 28 >> 2] = $0; + HEAP32[$4 + 24 >> 2] = $1; + HEAP32[$4 + 20 >> 2] = $2; + HEAP32[$4 + 16 >> 2] = $3; + $0 = HEAP32[$4 + 28 >> 2]; + wasm2js_i32$0 = $4, wasm2js_i32$1 = b2DynamicTree__MoveProxy_28int_2c_20b2AABB_20const__2c_20b2Vec2_20const__29($0, HEAP32[$4 + 24 >> 2], HEAP32[$4 + 20 >> 2], HEAP32[$4 + 16 >> 2]) & 1, + HEAP8[wasm2js_i32$0 + 15 | 0] = wasm2js_i32$1; + if (HEAP8[$4 + 15 | 0] & 1) { + b2BroadPhase__BufferMove_28int_29($0, HEAP32[$4 + 24 >> 2]); + } + __stack_pointer = $4 + 32 | 0; +} + +function void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______emscripten__internal__getContext_void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28b2Vec2_20const__29__28void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______20const__29_28b2Vec2_20const__29_29_29_28b2Vec2_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2CircleContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + $0 = HEAP32[$4 + 12 >> 2]; + b2CollideCircles_28b2Manifold__2c_20b2CircleShape_20const__2c_20b2Transform_20const__2c_20b2CircleShape_20const__2c_20b2Transform_20const__29(HEAP32[$4 + 8 >> 2], b2Fixture__GetShape_28_29(HEAP32[$0 + 48 >> 2]), HEAP32[$4 + 4 >> 2], b2Fixture__GetShape_28_29(HEAP32[$0 + 52 >> 2]), HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function bool_20_28__emscripten__internal__getContext_bool_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29__28bool_20_28__20const__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29_29_29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2__allocator_b2Vec2___allocate_5babi_v160004_5d_28unsigned_20long_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + if (HEAPU32[$2 + 8 >> 2] > unsigned_20long_20std____2__allocator_traits_std____2__allocator_b2Vec2____max_size_5babi_v160004_5d_std____2__allocator_b2Vec2__2c_20void__28std____2__allocator_b2Vec2__20const__29(HEAP32[$2 + 12 >> 2]) >>> 0) { + std____throw_bad_array_new_length_5babi_v160004_5d_28_29(); + wasm2js_trap(); + } + $0 = std____2____libcpp_allocate_5babi_v160004_5d_28unsigned_20long_2c_20unsigned_20long_29(HEAP32[$2 + 8 >> 2] << 3, 4); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long___operator___5babi_v160004_5d_28_29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + wasm2js_i32$0 = $0, wasm2js_i32$1 = std____2____tree_end_node_std____2____tree_node_base_void______20std____2____tree_next_iter_5babi_v160004_5d_std____2____tree_end_node_std____2____tree_node_base_void______2c_20std____2____tree_node_base_void_____28std____2____tree_node_base_void____29(HEAP32[$0 >> 2]), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__FunctionInvoker_b2Shape_20const__20_28__29_28b2FixtureDef__29_2c_20b2Shape_20const__2c_20b2FixtureDef____invoke_28b2Shape_20const__20_28___29_28b2FixtureDef__29_2c_20b2FixtureDef__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[HEAP32[$2 + 12 >> 2] >> 2]; + $0 = emscripten__internal__BindingType_b2Shape_20const__2c_20void___toWireType_28b2Shape_20const__29(FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_b2FixtureDef__2c_20void___fromWireType_28b2FixtureDef__29(HEAP32[$2 + 8 >> 2])) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function bool_20_28b2Fixture____emscripten__internal__getContext_bool_20_28b2Fixture____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const__28bool_20_28b2Fixture____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const_29_29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2RevoluteJointDef__b2RevoluteJointDef_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2JointDef__b2JointDef_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 20 | 0); + b2Vec2__b2Vec2_28_29($0 + 28 | 0); + HEAP32[$0 >> 2] = 1; + b2Vec2__Set_28float_2c_20float_29($0 + 20 | 0, Math_fround(0), Math_fround(0)); + b2Vec2__Set_28float_2c_20float_29($0 + 28 | 0, Math_fround(0), Math_fround(0)); + HEAPF32[$0 + 36 >> 2] = 0; + HEAPF32[$0 + 44 >> 2] = 0; + HEAPF32[$0 + 48 >> 2] = 0; + HEAPF32[$0 + 60 >> 2] = 0; + HEAPF32[$0 + 56 >> 2] = 0; + HEAP8[$0 + 40 | 0] = 0; + HEAP8[$0 + 52 | 0] = 0; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______emscripten__internal__getContext_unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28_29_20const__28unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__val__val_b2Vec2_20const___28b2Vec2_20const__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + emscripten__internal__WireTypePack_b2Vec2_20const____WireTypePack_28b2Vec2_20const__29($2, HEAP32[$2 + 8 >> 2]); + wasm2js_i32$0 = $0, wasm2js_i32$1 = _emval_take_value(emscripten__internal__TypeID_b2Vec2_20const__2c_20void___get_28_29() | 0, emscripten__internal__WireTypePack_b2Vec2_20const____operator_20void_20const__28_29_20const($2) | 0) | 0, + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______deallocate_5babi_v160004_5d_28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____deallocate_5babi_v160004_5d_28std____2____tree_node_b2Fixture__2c_20void____2c_20unsigned_20long_29(HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______end_node_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__pointer_traits_std____2____tree_end_node_std____2____tree_node_base_void________pointer_to_5babi_v160004_5d_28std____2____tree_end_node_std____2____tree_node_base_void______29(std____2____compressed_pair_std____2____tree_end_node_std____2____tree_node_base_void_____2c_20std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______first_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 4 | 0)); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__val_20_28__emscripten__internal__getContext_emscripten__val_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29__28emscripten__val_20_28__20const__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29_29_29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__MemberAccess_b2WheelJointDef_2c_20b2Vec2___setWire_b2WheelJointDef__28b2Vec2_20b2WheelJointDef____20const__2c_20b2WheelJointDef__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2RayCastOutput_2c_20b2Vec2___setWire_b2RayCastOutput__28b2Vec2_20b2RayCastOutput____20const__2c_20b2RayCastOutput__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2MouseJointDef_2c_20b2Vec2___setWire_b2MouseJointDef__28b2Vec2_20b2MouseJointDef____20const__2c_20b2MouseJointDef__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2MotorJointDef_2c_20b2Vec2___setWire_b2MotorJointDef__28b2Vec2_20b2MotorJointDef____20const__2c_20b2MotorJointDef__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function fopen($0, $1) { + var $2 = 0, $3 = 0, $4 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + label$1: { + label$2: { + if (!strchr(10404, HEAP8[$1 | 0])) { + wasm2js_i32$0 = __errno_location(), wasm2js_i32$1 = 28, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + break label$2; + } + $4 = __fmodeflags($1); + HEAP32[$2 >> 2] = 438; + HEAP32[$2 + 4 >> 2] = 0; + $0 = __syscall_ret(__syscall_openat(-100, $0 | 0, $4 | 32768, $2 | 0) | 0); + if (($0 | 0) < 0) { + break label$1; + } + $3 = __fdopen($0, $1); + if ($3) { + break label$1; + } + __wasi_fd_close($0 | 0) | 0; + } + $3 = 0; + } + __stack_pointer = $2 + 16 | 0; + return $3; +} + +function b2AABB__IsValid_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $2 = HEAP32[$1 + 12 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 4 | 0, $2 + 8 | 0, $2); + $3 = HEAPF32[$1 + 4 >> 2] >= Math_fround(0) ? HEAPF32[$1 + 8 >> 2] >= Math_fround(0) : $3; + HEAP8[$1 + 3 | 0] = $3; + $0 = 0; + label$2: { + if (!(HEAP8[$1 + 3 | 0] & 1)) { + break label$2; + } + $0 = 0; + if (!(b2Vec2__IsValid_28_29_20const($2) & 1)) { + break label$2; + } + $0 = b2Vec2__IsValid_28_29_20const($2 + 8 | 0); + } + HEAP8[$1 + 3 | 0] = $0 & 1; + __stack_pointer = $1 + 16 | 0; + return HEAP8[$1 + 3 | 0] & 1; +} + +function emscripten__internal__MethodInvoker_void_20_28b2WheelJoint____29_28_29_2c_20void_2c_20b2WheelJoint____invoke_28void_20_28b2WheelJoint____20const__29_28_29_2c_20b2WheelJoint__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2WheelJoint__2c_20void___fromWireType_28b2WheelJoint__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($1); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2MouseJoint____29_28_29_2c_20void_2c_20b2MouseJoint____invoke_28void_20_28b2MouseJoint____20const__29_28_29_2c_20b2MouseJoint__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2MouseJoint__2c_20void___fromWireType_28b2MouseJoint__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($1); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2MotorJoint____29_28_29_2c_20void_2c_20b2MotorJoint____invoke_28void_20_28b2MotorJoint____20const__29_28_29_2c_20b2MotorJoint__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2MotorJoint__2c_20void___fromWireType_28b2MotorJoint__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($1); + __stack_pointer = $2 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2WeldJointDef_2c_20b2Vec2___setWire_b2WeldJointDef__28b2Vec2_20b2WeldJointDef____20const__2c_20b2WeldJointDef__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2RopeJointDef_2c_20b2Vec2___setWire_b2RopeJointDef__28b2Vec2_20b2RopeJointDef____20const__2c_20b2RopeJointDef__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2RayCastInput_2c_20b2Vec2___setWire_b2RayCastInput__28b2Vec2_20b2RayCastInput____20const__2c_20b2RayCastInput__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function b2BroadPhase__b2BroadPhase_28_29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2DynamicTree__b2DynamicTree_28_29($0); + HEAP32[$0 + 28 >> 2] = 0; + HEAP32[$0 + 48 >> 2] = 16; + HEAP32[$0 + 52 >> 2] = 0; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Alloc_28int_29(HEAP32[$0 + 48 >> 2] << 3), + HEAP32[wasm2js_i32$0 + 44 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 36 >> 2] = 16; + HEAP32[$0 + 40 >> 2] = 0; + wasm2js_i32$0 = $0, wasm2js_i32$1 = b2Alloc_28int_29(HEAP32[$0 + 36 >> 2] << 2), + HEAP32[wasm2js_i32$0 + 32 >> 2] = wasm2js_i32$1; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__allocator_int___allocate_5babi_v160004_5d_28unsigned_20long_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + if (HEAPU32[$2 + 8 >> 2] > unsigned_20long_20std____2__allocator_traits_std____2__allocator_int____max_size_5babi_v160004_5d_std____2__allocator_int__2c_20void__28std____2__allocator_int__20const__29(HEAP32[$2 + 12 >> 2]) >>> 0) { + std____throw_bad_array_new_length_5babi_v160004_5d_28_29(); + wasm2js_trap(); + } + $0 = std____2____libcpp_allocate_5babi_v160004_5d_28unsigned_20long_2c_20unsigned_20long_29(HEAP32[$2 + 8 >> 2] << 2, 4); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__MemberAccess_b2CircleShape_2c_20b2Vec2___setWire_b2CircleShape__28b2Vec2_20b2CircleShape____20const__2c_20b2CircleShape__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2WeldJoint____29_28_29_2c_20void_2c_20b2WeldJoint____invoke_28void_20_28b2WeldJoint____20const__29_28_29_2c_20b2WeldJoint__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2WeldJoint__2c_20void___fromWireType_28b2WeldJoint__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($1); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2RopeJoint____29_28_29_2c_20void_2c_20b2RopeJoint____invoke_28void_20_28b2RopeJoint____20const__29_28_29_2c_20b2RopeJoint__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2RopeJoint__2c_20void___fromWireType_28b2RopeJoint__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($1); + __stack_pointer = $2 + 16 | 0; +} + +function std____2____allocation_result_std____2__allocator_traits_std____2__allocator_b2Vec2____pointer__20std____2____allocate_at_least_5babi_v160004_5d_std____2__allocator_b2Vec2___28std____2__allocator_b2Vec2___2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + wasm2js_i32$0 = $0, wasm2js_i32$1 = std____2__allocator_b2Vec2___allocate_5babi_v160004_5d_28unsigned_20long_29(HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2]), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 4 >> 2] = HEAP32[$3 + 8 >> 2]; + __stack_pointer = $3 + 16 | 0; +} + +function std____2__pair_std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__2c_20bool___pair_5babi_v160004_5d_std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__2c_20bool__2c_20_28void__290__28std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long____2c_20bool__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[HEAP32[$3 + 8 >> 2] >> 2]; + HEAP8[$0 + 4 | 0] = HEAP8[HEAP32[$3 + 4 >> 2]] & 1; + return $0; +} + +function void_20_28b2PolygonShape____emscripten__internal__getContext_void_20_28b2PolygonShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const__28void_20_28b2PolygonShape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Draw____emscripten__internal__getContext_void_20_28b2Draw____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29__28void_20_28b2Draw____20const__29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29_29_29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__val__val_int_20const___28int_20const__29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + emscripten__internal__WireTypePack_int_20const____WireTypePack_28int_20const__29($2, HEAP32[$2 + 8 >> 2]); + wasm2js_i32$0 = $0, wasm2js_i32$1 = _emval_take_value(emscripten__internal__TypeID_int_20const__2c_20void___get_28_29() | 0, emscripten__internal__WireTypePack_int_20const____operator_20void_20const__28_29_20const($2) | 0) | 0, + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__MemberAccess_b2Transform_2c_20b2Vec2___setWire_b2Transform__28b2Vec2_20b2Transform____20const__2c_20b2Transform__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______set_short_size_5babi_v160004_5d_28unsigned_20long_29($0, $1) { + var $2 = 0; + $2 = std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29($0); + HEAP8[$2 + 11 | 0] = HEAPU8[$2 + 11 | 0] & 128 | $1; + $0 = std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29($0); + HEAP8[$0 + 11 | 0] = HEAPU8[$0 + 11 | 0] & 127; +} + +function emscripten__val_20_28__emscripten__internal__getContext_emscripten__val_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29__28emscripten__val_20_28__20const__29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29_29_29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28std____2__vector_int_2c_20std____2__allocator_int______emscripten__internal__getContext_void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28int_20const__29__28void_20_28std____2__vector_int_2c_20std____2__allocator_int______20const__29_28int_20const__29_29_29_28int_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2CircleShape____emscripten__internal__getContext_void_20_28b2CircleShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const__28void_20_28b2CircleShape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function bool_20_28b2PolygonShape____emscripten__internal__getContext_bool_20_28b2PolygonShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const__28bool_20_28b2PolygonShape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29_29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Fixture__TestPoint_28b2Vec2_20const__29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$0 + 12 >> 2]; + $0 = (wasm2js_i32$1 = $1, wasm2js_i32$2 = b2Body__GetTransform_28_29_20const(HEAP32[$0 + 8 >> 2]), + wasm2js_i32$3 = HEAP32[$2 + 8 >> 2], wasm2js_i32$0 = HEAP32[HEAP32[$1 >> 2] + 16 >> 2], + FUNCTION_TABLE[wasm2js_i32$0](wasm2js_i32$1 | 0, wasm2js_i32$2 | 0, wasm2js_i32$3 | 0) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function bool_20_28__emscripten__internal__getContext_bool_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29__28bool_20_28__20const__29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29_29_29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20emscripten__internal__MemberAccess_b2MassData_2c_20b2Vec2___setWire_b2MassData__28b2Vec2_20b2MassData____20const__2c_20b2MassData__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20_28b2PolygonShape____emscripten__internal__getContext_void_20_28b2PolygonShape____29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29__28void_20_28b2PolygonShape____20const__29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29_29_29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Fixture____29_28_29_2c_20void_2c_20b2Fixture____invoke_28void_20_28b2Fixture____20const__29_28_29_2c_20b2Fixture__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Fixture__2c_20void___fromWireType_28b2Fixture__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($1); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__Invoker_void_2c_20unsigned_20int_2c_20float___invoke_28void_20_28__29_28unsigned_20int_2c_20float_29_2c_20unsigned_20int_2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$3 + 8 >> 2]), emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function bool_20_28b2CircleShape____emscripten__internal__getContext_bool_20_28b2CircleShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const__28bool_20_28b2CircleShape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29_29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20emscripten__internal__MemberAccess_b2Transform_2c_20b2Rot___setWire_b2Transform__28b2Rot_20b2Transform____20const__2c_20b2Transform__2c_20b2Rot__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Rot___fromWireType_28b2Rot__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function std____2____allocation_result_std____2__allocator_traits_std____2__allocator_int____pointer__20std____2____allocate_at_least_5babi_v160004_5d_std____2__allocator_int___28std____2__allocator_int___2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + wasm2js_i32$0 = $0, wasm2js_i32$1 = std____2__allocator_int___allocate_5babi_v160004_5d_28unsigned_20long_29(HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2]), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 4 >> 2] = HEAP32[$3 + 8 >> 2]; + __stack_pointer = $3 + 16 | 0; +} + +function __cxxabiv1____si_class_type_info__search_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_2c_20bool_29_20const($0, $1, $2, $3, $4, $5) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + $5 = $5 | 0; + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, HEAP32[$1 + 8 >> 2], $5)) { + __cxxabiv1____class_type_info__process_static_type_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_29_20const($1, $1, $2, $3, $4); + return; + } + $0 = HEAP32[$0 + 8 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 20 >> 2]]($0, $1, $2, $3, $4, $5); +} + +function void_20_28b2EdgeShape____emscripten__internal__getContext_void_20_28b2EdgeShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const__28void_20_28b2EdgeShape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__Signature_void_2c_20b2Transform_20const____get_method_caller_28_29() { + var $0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $0 = __stack_pointer - 16 | 0; + __stack_pointer = $0; + if (!(HEAP8[30100] & 1)) { + wasm2js_i32$0 = 30096, wasm2js_i32$1 = _emval_get_method_caller(emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Transform_20const____getCount_28_29_20const($0 + 15 | 0) | 0, emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Transform_20const____getTypes_28_29_20const($0 + 15 | 0) | 0) | 0, + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP8[30100] = 1; + } + __stack_pointer = $0 + 16 | 0; + return HEAP32[7524]; +} + +function void_20emscripten__internal__MemberAccess_b2BodyDef_2c_20b2Vec2___setWire_b2BodyDef__28b2Vec2_20b2BodyDef____20const__2c_20b2BodyDef__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function bool_20_28b2EdgeShape____emscripten__internal__getContext_bool_20_28b2EdgeShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const__28bool_20_28b2EdgeShape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29_29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2DynamicTree__DestroyProxy_28int_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (!(HEAP32[$2 + 8 >> 2] < HEAP32[$0 + 12 >> 2] & HEAP32[$2 + 8 >> 2] >= 0)) { + __assert_fail(1341, 5965, 128, 1036); + wasm2js_trap(); + } + if (!(b2TreeNode__IsLeaf_28_29_20const(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) & 1)) { + __assert_fail(12442, 5965, 129, 1036); + wasm2js_trap(); + } + b2DynamicTree__RemoveLeaf_28int_29($0, HEAP32[$2 + 8 >> 2]); + b2DynamicTree__FreeNode_28int_29($0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function void_20_28__emscripten__internal__getContext_void_20_28__29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29__28void_20_28__20const__29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29_29_29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Body__ApplyAngularImpulse_28float_2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = Math_fround($1); + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAPF32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + label$1: { + if (HEAP32[$0 >> 2] != 2) { + break label$1; + } + if (!(!(HEAP8[$3 + 7 | 0] & 1) | HEAPU16[$0 + 4 >> 1] & 2)) { + b2Body__SetAwake_28bool_29($0, 1); + } + if (!(HEAPU16[$0 + 4 >> 1] & 2)) { + break label$1; + } + HEAPF32[$0 + 72 >> 2] = Math_fround(HEAPF32[$0 + 128 >> 2] * HEAPF32[$3 + 8 >> 2]) + HEAPF32[$0 + 72 >> 2]; + } + __stack_pointer = $3 + 16 | 0; +} + +function bool_20_28b2AABB____emscripten__internal__getContext_bool_20_28b2AABB____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const__28bool_20_28b2AABB____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const_29_29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Body__SetAwake_28bool_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + label$1: { + if (!HEAP32[$0 >> 2]) { + break label$1; + } + if (HEAP8[$2 + 11 | 0] & 1) { + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] | 2; + HEAPF32[$0 + 144 >> 2] = 0; + break label$1; + } + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] & -3; + HEAPF32[$0 + 144 >> 2] = 0; + b2Vec2__SetZero_28_29($0 - -64 | 0); + HEAPF32[$0 + 72 >> 2] = 0; + b2Vec2__SetZero_28_29($0 + 76 | 0); + HEAPF32[$0 + 84 >> 2] = 0; + } + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2World____29_28_29_2c_20void_2c_20b2World____invoke_28void_20_28b2World____20const__29_28_29_2c_20b2World__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2World__2c_20void___fromWireType_28b2World__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($1); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Joint____29_28_29_2c_20void_2c_20b2Joint____invoke_28void_20_28b2Joint____20const__29_28_29_2c_20b2Joint__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Joint__2c_20void___fromWireType_28b2Joint__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($1); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__Invoker_void_2c_20unsigned_20int_2c_20bool___invoke_28void_20_28__29_28unsigned_20int_2c_20bool_29_2c_20unsigned_20int_2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$3 + 8 >> 2]), emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$3 + 7 | 0] & 1) & 1); + __stack_pointer = $3 + 16 | 0; +} + +function b2DrawWrapper__DrawSegment_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + void_20emscripten__wrapper_b2Draw___call_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const___28char_20const__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29_20const(HEAP32[$4 + 12 >> 2], 2799, HEAP32[$4 + 8 >> 2], HEAP32[$4 + 4 >> 2], HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____end_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____tree_iterator_5babi_v160004_5d_28std____2____tree_end_node_std____2____tree_node_base_void______29($1 + 12 | 0, std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______end_node_5babi_v160004_5d_28_29(HEAP32[$1 + 8 >> 2])); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2WheelJoint__GetReactionForce_28float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $1; + HEAPF32[$3 + 24 >> 2] = $2; + $2 = HEAPF32[$3 + 24 >> 2]; + $1 = HEAP32[$3 + 28 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($3 + 8 | 0, HEAPF32[$1 + 100 >> 2], $1 + 200 | 0); + operator__28float_2c_20b2Vec2_20const__29($3, HEAPF32[$1 + 108 >> 2], $1 + 192 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($3 + 16 | 0, $3 + 8 | 0, $3); + operator__28float_2c_20b2Vec2_20const__29($0, $2, $3 + 16 | 0); + __stack_pointer = $3 + 32 | 0; +} + +function void_20_28b2Shape____emscripten__internal__getContext_void_20_28b2Shape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const__28void_20_28b2Shape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_29_29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2PolygonShape__Clone_28b2BlockAllocator__29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 8 >> 2], 152), + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 4 >> 2]; + b2PolygonShape__b2PolygonShape_28_29($0); + HEAP32[$2 >> 2] = $0; + b2PolygonShape__operator__28b2PolygonShape_20const__29(HEAP32[$2 >> 2], $1); + __stack_pointer = $2 + 16 | 0; + return HEAP32[$2 >> 2]; +} + +function b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Vec2__b2Vec2_28float_2c_20float_29($0, Math_fround(Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]) + Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2])), Math_fround(Math_fround(Math_fround(-HEAPF32[HEAP32[$3 + 12 >> 2] >> 2]) * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]) + Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2]))); + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2AABB_2c_20b2Vec2___setWire_b2AABB__28b2Vec2_20b2AABB____20const__2c_20b2AABB__2c_20b2Vec2__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$3 + 4 >> 2]); + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__pure_virtual_2c_20emscripten__allow_raw_pointers___ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RayCastCallback__2c_20unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RayCastCallback__2c_20unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__Signature_void_2c_20unsigned_20int____get_method_caller_28_29() { + var $0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $0 = __stack_pointer - 16 | 0; + __stack_pointer = $0; + if (!(HEAP8[30052] & 1)) { + wasm2js_i32$0 = 30048, wasm2js_i32$1 = _emval_get_method_caller(emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int____getCount_28_29_20const($0 + 15 | 0) | 0, emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int____getTypes_28_29_20const($0 + 15 | 0) | 0) | 0, + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP8[30052] = 1; + } + __stack_pointer = $0 + 16 | 0; + return HEAP32[7512]; +} + +function emscripten__internal__Signature_bool_2c_20unsigned_20int____get_method_caller_28_29() { + var $0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $0 = __stack_pointer - 16 | 0; + __stack_pointer = $0; + if (!(HEAP8[30036] & 1)) { + wasm2js_i32$0 = 30032, wasm2js_i32$1 = _emval_get_method_caller(emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20unsigned_20int____getCount_28_29_20const($0 + 15 | 0) | 0, emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20unsigned_20int____getTypes_28_29_20const($0 + 15 | 0) | 0) | 0, + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP8[30036] = 1; + } + __stack_pointer = $0 + 16 | 0; + return HEAP32[7508]; +} + +function emscripten__internal__MethodInvoker_void_20_28b2Body____29_28_29_2c_20void_2c_20b2Body____invoke_28void_20_28b2Body____20const__29_28_29_2c_20b2Body__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29(HEAP32[$2 + 8 >> 2]); + $0 = HEAP32[$2 + 12 >> 2]; + $3 = HEAP32[$0 + 4 >> 2]; + $0 = HEAP32[$0 >> 2]; + $1 = ($3 >> 1) + $1 | 0; + if ($3 & 1) { + $0 = HEAP32[HEAP32[$1 >> 2] + $0 >> 2]; + } + FUNCTION_TABLE[$0 | 0]($1); + __stack_pointer = $2 + 16 | 0; +} + +function bool_20_28b2Shape____emscripten__internal__getContext_bool_20_28b2Shape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const__28bool_20_28b2Shape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_29_29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2MotorJoint__SetLinearOffset_28b2Vec2_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (!(HEAPF32[HEAP32[$2 + 8 >> 2] >> 2] == HEAPF32[$0 + 68 >> 2] & HEAPF32[HEAP32[$2 + 8 >> 2] + 4 >> 2] == HEAPF32[$0 + 72 >> 2])) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + $1 = HEAP32[$2 + 8 >> 2]; + $3 = HEAP32[$1 + 4 >> 2]; + HEAP32[$0 + 68 >> 2] = HEAP32[$1 >> 2]; + HEAP32[$0 + 72 >> 2] = $3; + } + __stack_pointer = $2 + 16 | 0; +} + +function b2Fixture__DestroyProxies_28b2BroadPhase__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 4 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 4 >> 2] < HEAP32[$0 + 28 >> 2]) { + HEAP32[$2 >> 2] = HEAP32[$0 + 24 >> 2] + Math_imul(HEAP32[$2 + 4 >> 2], 28); + b2BroadPhase__DestroyProxy_28int_29(HEAP32[$2 + 8 >> 2], HEAP32[HEAP32[$2 >> 2] + 24 >> 2]); + HEAP32[HEAP32[$2 >> 2] + 24 >> 2] = -1; + HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 4 >> 2] + 1; + continue; + } + break; + } + HEAP32[$0 + 28 >> 2] = 0; + __stack_pointer = $2 + 16 | 0; +} + +function b2Mul22_28b2Mat33_20const__2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Vec2__b2Vec2_28float_2c_20float_29($0, Math_fround(Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]) + Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 12 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2])), Math_fround(Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]) + Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 16 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2]))); + __stack_pointer = $3 + 16 | 0; +} + +function b2CircleShape__Clone_28b2BlockAllocator__29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 8 >> 2], 20), + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 4 >> 2]; + b2CircleShape__b2CircleShape_28_29($0); + HEAP32[$2 >> 2] = $0; + b2CircleShape__operator__28b2CircleShape_20const__29(HEAP32[$2 >> 2], $1); + __stack_pointer = $2 + 16 | 0; + return HEAP32[$2 >> 2]; +} + +function b2Mul_28b2Mat22_20const__2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Vec2__b2Vec2_28float_2c_20float_29($0, Math_fround(Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]) + Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 8 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2])), Math_fround(Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]) + Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 12 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2]))); + __stack_pointer = $3 + 16 | 0; +} + +function void_20_28b2Draw____emscripten__internal__getContext_void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29__28void_20_28b2Draw____20const__29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29_29_29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2AABB__Combine_28b2AABB_20const__29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + b2Min_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 16 | 0, $0, HEAP32[$2 + 24 >> 2]); + $1 = HEAP32[$2 + 20 >> 2]; + $3 = HEAP32[$2 + 16 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$0 + 4 >> 2] = $1; + b2Max_28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 8 | 0, $0 + 8 | 0, HEAP32[$2 + 24 >> 2] + 8 | 0); + $3 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 8 >> 2] = $1; + HEAP32[$0 + 12 >> 2] = $3; + __stack_pointer = $2 + 32 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_20const__2c_20b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__pair_char_20const__2c_20char___20std____2____dispatch_copy_or_move_5babi_v160004_5d_std____2___ClassicAlgPolicy_2c_20std____2____copy_loop_std____2___ClassicAlgPolicy__2c_20std____2____copy_trivial_2c_20char_20const__2c_20char_20const__2c_20char___28char_20const__2c_20char_20const__2c_20char__29($0, $1, $2, $3) { + std____2__pair_char_20const__2c_20char___20std____2____unwrap_and_dispatch_5babi_v160004_5d_std____2____overload_std____2____copy_loop_std____2___ClassicAlgPolicy__2c_20std____2____copy_trivial__2c_20char_20const__2c_20char_20const__2c_20char__2c_200__28char_20const__2c_20char_20const__2c_20char__29($0, $1, $2, $3); +} + +function void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2QueryCallback__2c_20b2AABB_20const__29_20const__28void_20_28b2World____20const__29_28b2QueryCallback__2c_20b2AABB_20const__29_20const_29_29_28b2QueryCallback__2c_20b2AABB_20const__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29__28void_20_28b2Body____20const__29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29_29_29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__FunctionInvoker_b2Body__20_28__29_28b2JointDef__29_2c_20b2Body__2c_20b2JointDef____invoke_28b2Body__20_28___29_28b2JointDef__29_2c_20b2JointDef__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[HEAP32[$2 + 12 >> 2] >> 2]; + $0 = emscripten__internal__BindingType_b2Body__2c_20void___toWireType_28b2Body__29(FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_b2JointDef__2c_20void___fromWireType_28b2JointDef__29(HEAP32[$2 + 8 >> 2])) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Vec2__b2Vec2_28float_2c_20float_29($0, Math_fround(Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]) - Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2])), Math_fround(Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]) + Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2]))); + __stack_pointer = $3 + 16 | 0; +} + +function b2MulT_28b2Rot_20const__2c_20b2Rot_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Rot__b2Rot_28_29($0); + HEAPF32[$0 >> 2] = Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]) - Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2]); + HEAPF32[$0 + 4 >> 2] = Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2]) + Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function scalbn($0, $1) { + label$1: { + if (($1 | 0) >= 1024) { + $0 = $0 * 898846567431158e293; + if ($1 >>> 0 < 2047) { + $1 = $1 - 1023 | 0; + break label$1; + } + $0 = $0 * 898846567431158e293; + $1 = (($1 | 0) >= 3069 ? 3069 : $1) - 2046 | 0; + break label$1; + } + if (($1 | 0) > -1023) { + break label$1; + } + $0 = $0 * 2004168360008973e-307; + if ($1 >>> 0 > 4294965304) { + $1 = $1 + 969 | 0; + break label$1; + } + $0 = $0 * 2004168360008973e-307; + $1 = (($1 | 0) <= -2960 ? -2960 : $1) + 1938 | 0; + } + wasm2js_scratch_store_i32(0, 0); + wasm2js_scratch_store_i32(1, $1 + 1023 << 20); + return $0 * +wasm2js_scratch_load_f64(); +} + +function b2EdgeShape__Clone_28b2BlockAllocator__29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BlockAllocator__Allocate_28int_29(HEAP32[$2 + 8 >> 2], 48), + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$2 + 4 >> 2]; + b2EdgeShape__b2EdgeShape_28_29($0); + HEAP32[$2 >> 2] = $0; + b2EdgeShape__operator__28b2EdgeShape_20const__29(HEAP32[$2 >> 2], $1); + __stack_pointer = $2 + 16 | 0; + return HEAP32[$2 >> 2]; +} + +function void_20emscripten__val__call_void_2c_20unsigned_20int__2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__2c_20unsigned_20int__29_20const($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + emscripten__internal__MethodCaller_void_2c_20unsigned_20int__2c_20unsigned_20int____call_28emscripten___EM_VAL__2c_20char_20const__2c_20unsigned_20int__2c_20unsigned_20int__29(HEAP32[HEAP32[$4 + 12 >> 2] >> 2], HEAP32[$4 + 8 >> 2], HEAP32[$4 + 4 >> 2], HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function b2BroadPhase__CreateProxy_28b2AABB_20const__2c_20void__29($0, $1, $2) { + var $3 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + wasm2js_i32$0 = $3, wasm2js_i32$1 = b2DynamicTree__CreateProxy_28b2AABB_20const__2c_20void__29($0, HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]), + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP32[$0 + 28 >> 2] = HEAP32[$0 + 28 >> 2] + 1; + b2BroadPhase__BufferMove_28int_29($0, HEAP32[$3 >> 2]); + __stack_pointer = $3 + 16 | 0; + return HEAP32[$3 >> 2]; +} + +function void_20_28b2Draw____emscripten__internal__getContext_void_20_28b2Draw____29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29__28void_20_28b2Draw____20const__29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29_29_29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2ContactListener____emscripten__internal__getContext_void_20_28b2ContactListener____29_28unsigned_20int_2c_20unsigned_20int_29__28void_20_28b2ContactListener____20const__29_28unsigned_20int_2c_20unsigned_20int_29_29_29_28unsigned_20int_2c_20unsigned_20int_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void________unique_ptr_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______reset_5babi_v160004_5d_28std____2____tree_node_b2Fixture__2c_20void____29($0, 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function fclose($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0; + if (HEAP32[$0 + 76 >> 2] < 0) { + $1 = 0; + } else { + $1 = __lockfile($0); + } + $4 = fflush($0); + $5 = FUNCTION_TABLE[HEAP32[$0 + 12 >> 2]]($0) | 0; + $1 = !$1; + if (!$1) { + __unlockfile($0); + } + if (!(HEAP8[$0 | 0] & 1)) { + dummy($0); + $1 = __ofl_lock(); + $2 = HEAP32[$0 + 52 >> 2]; + if ($2) { + HEAP32[$2 + 56 >> 2] = HEAP32[$0 + 56 >> 2]; + } + $3 = HEAP32[$0 + 56 >> 2]; + if ($3) { + HEAP32[$3 + 52 >> 2] = $2; + } + if (HEAP32[$1 >> 2] == ($0 | 0)) { + HEAP32[$1 >> 2] = $3; + } + __ofl_unlock(); + dlfree(HEAP32[$0 + 96 >> 2]); + dlfree($0); + } + return $4 | $5; +} + +function b2DrawWrapper__DrawCircle_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAPF32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + void_20emscripten__wrapper_b2Draw___call_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const___28char_20const__2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const__29_20const(HEAP32[$4 + 12 >> 2], 9617, HEAP32[$4 + 8 >> 2], $4 + 4 | 0, HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function b2DrawWrapper__DrawPoint_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAPF32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + void_20emscripten__wrapper_b2Draw___call_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const___28char_20const__2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const__29_20const(HEAP32[$4 + 12 >> 2], 2399, HEAP32[$4 + 8 >> 2], $4 + 4 | 0, HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function b2Body__ApplyForceToCenter_28b2Vec2_20const__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + label$1: { + if (HEAP32[$0 >> 2] != 2) { + break label$1; + } + if (!(!(HEAP8[$3 + 7 | 0] & 1) | HEAPU16[$0 + 4 >> 1] & 2)) { + b2Body__SetAwake_28bool_29($0, 1); + } + if (!(HEAPU16[$0 + 4 >> 1] & 2)) { + break label$1; + } + b2Vec2__operator___28b2Vec2_20const__29($0 + 76 | 0, HEAP32[$3 + 8 >> 2]); + } + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__class__b2RayCastCallback_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2RayCastCallback_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2RayCastCallbackWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2RayCastCallbackWrapper__29__operator_28_29_28b2RayCastCallbackWrapper__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + emscripten__internal__WrapperBase__setNotifyJSOnDestruction_28bool_29(HEAP32[$2 + 8 >> 2] + 4 | 0, 1); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__class__b2ContactListener_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2ContactListener_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2ContactListenerWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2ContactListenerWrapper__29__operator_28_29_28b2ContactListenerWrapper__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + emscripten__internal__WrapperBase__setNotifyJSOnDestruction_28bool_29(HEAP32[$2 + 8 >> 2] + 4 | 0, 1); + __stack_pointer = $2 + 16 | 0; +} + +function void_20emscripten__wrapper_b2ContactListener___call_void_2c_20unsigned_20int__2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__2c_20unsigned_20int__29_20const($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + void_20emscripten__val__call_void_2c_20unsigned_20int__2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__2c_20unsigned_20int__29_20const(HEAP32[$4 + 12 >> 2] + 8 | 0, HEAP32[$4 + 8 >> 2], HEAP32[$4 + 4 >> 2], HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20b2Transform_20const__2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20b2Transform_20const__2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2BlockAllocator____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2BlockAllocator_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function strlen($0) { + var $1 = 0, $2 = 0, $3 = 0; + label$1: { + label$2: { + $1 = $0; + if (!($1 & 3)) { + break label$2; + } + if (!HEAPU8[$0 | 0]) { + return 0; + } + while (1) { + $1 = $1 + 1 | 0; + if (!($1 & 3)) { + break label$2; + } + if (HEAPU8[$1 | 0]) { + continue; + } + break; + } + break label$1; + } + while (1) { + $2 = $1; + $1 = $1 + 4 | 0; + $3 = HEAP32[$2 >> 2]; + if (!(($3 ^ -1) & $3 - 16843009 & -2139062144)) { + continue; + } + break; + } + while (1) { + $1 = $2; + $2 = $1 + 1 | 0; + if (HEAPU8[$1 | 0]) { + continue; + } + break; + } + } + return $1 - $0 | 0; +} + +function std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______operator___5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______first_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$0 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2BlockAllocator____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2BlockAllocator_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__class__b2QueryCallback_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2QueryCallback_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2QueryCallbackWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2QueryCallbackWrapper__29__operator_28_29_28b2QueryCallbackWrapper__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + emscripten__internal__WrapperBase__setNotifyJSOnDestruction_28bool_29(HEAP32[$2 + 8 >> 2] + 4 | 0, 1); + __stack_pointer = $2 + 16 | 0; +} + +function b2Body__SetFixedRotation_28bool_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP8[$2 + 10 | 0] = (HEAPU16[$0 + 4 >> 1] & 16) == 16; + if ((HEAP8[$2 + 10 | 0] & 1) != (HEAP8[$2 + 11 | 0] & 1)) { + label$2: { + if (HEAP8[$2 + 11 | 0] & 1) { + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] | 16; + break label$2; + } + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] & -17; + } + HEAPF32[$0 + 72 >> 2] = 0; + b2Body__ResetMassData_28_29($0); + } + __stack_pointer = $2 + 16 | 0; +} + +function void_20_28b2PolygonShape____emscripten__internal__getContext_void_20_28b2PolygonShape____29_28b2MassData__2c_20float_29_20const__28void_20_28b2PolygonShape____20const__29_28b2MassData__2c_20float_29_20const_29_29_28b2MassData__2c_20float_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20b2Transform_20const__2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Body__ApplyTorque_28float_2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = Math_fround($1); + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAPF32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + label$1: { + if (HEAP32[$0 >> 2] != 2) { + break label$1; + } + if (!(!(HEAP8[$3 + 7 | 0] & 1) | HEAPU16[$0 + 4 >> 1] & 2)) { + b2Body__SetAwake_28bool_29($0, 1); + } + if (!(HEAPU16[$0 + 4 >> 1] & 2)) { + break label$1; + } + HEAPF32[$0 + 84 >> 2] = HEAPF32[$0 + 84 >> 2] + HEAPF32[$3 + 8 >> 2]; + } + __stack_pointer = $3 + 16 | 0; +} + +function b2Body__GetLinearVelocityFromWorldPoint_28b2Vec2_20const__29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0, $4 = Math_fround(0); + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $1; + HEAP32[$3 + 24 >> 2] = $2; + $1 = HEAP32[$3 + 28 >> 2]; + $4 = HEAPF32[$1 + 72 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($3 + 8 | 0, HEAP32[$3 + 24 >> 2], $1 + 44 | 0); + b2Cross_28float_2c_20b2Vec2_20const__29($3 + 16 | 0, $4, $3 + 8 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($0, $1 - -64 | 0, $3 + 16 | 0); + __stack_pointer = $3 + 32 | 0; +} + +function unsigned_20long_20const__20std____2__min_5babi_v160004_5d_unsigned_20long__28unsigned_20long_20const__2c_20unsigned_20long_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = unsigned_20long_20const__20std____2__min_5babi_v160004_5d_unsigned_20long_2c_20std____2____less_unsigned_20long_2c_20unsigned_20long___28unsigned_20long_20const__2c_20unsigned_20long_20const__2c_20std____2____less_unsigned_20long_2c_20unsigned_20long__29(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function unsigned_20long_20const__20std____2__max_5babi_v160004_5d_unsigned_20long__28unsigned_20long_20const__2c_20unsigned_20long_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = unsigned_20long_20const__20std____2__max_5babi_v160004_5d_unsigned_20long_2c_20std____2____less_unsigned_20long_2c_20unsigned_20long___28unsigned_20long_20const__2c_20unsigned_20long_20const__2c_20std____2____less_unsigned_20long_2c_20unsigned_20long__29(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2BlockAllocator____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2BlockAllocator_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__MemberAccess_b2PrismaticJointDef_2c_20float___setWire_b2PrismaticJointDef__28float_20b2PrismaticJointDef____20const__2c_20b2PrismaticJointDef__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2Filter_2c_20unsigned_20short___setWire_b2Filter__28unsigned_20short_20b2Filter____20const__2c_20b2Filter__2c_20unsigned_20short_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP16[$3 + 6 >> 1] = $2; + $0 = emscripten__internal__BindingType_unsigned_20short_2c_20void___fromWireType_28unsigned_20short_29(HEAPU16[$3 + 6 >> 1]); + HEAP16[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 1] = $0; + __stack_pointer = $3 + 16 | 0; +} + +function void_20_28b2CircleShape____emscripten__internal__getContext_void_20_28b2CircleShape____29_28b2MassData__2c_20float_29_20const__28void_20_28b2CircleShape____20const__29_28b2MassData__2c_20float_29_20const_29_29_28b2MassData__2c_20float_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Shape__20_28b2PolygonShape____emscripten__internal__getContext_b2Shape__20_28b2PolygonShape____29_28b2BlockAllocator__29_20const__28b2Shape__20_28b2PolygonShape____20const__29_28b2BlockAllocator__29_20const_29_29_28b2BlockAllocator__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastOutput__2c_20b2RayCastInput_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Shape_20const__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______get_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______first_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$0 >> 2]; +} + +function __cxxabiv1____pointer_to_member_type_info__can_catch_nested_28__cxxabiv1____shim_type_info_20const__29_20const($0, $1) { + var $2 = 0; + label$1: { + if (!$1) { + break label$1; + } + $1 = __dynamic_cast($1, 23924, 24180, 0); + if (!$1 | HEAP32[$1 + 8 >> 2] & (HEAP32[$0 + 8 >> 2] ^ -1)) { + break label$1; + } + if (!is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29(HEAP32[$0 + 12 >> 2], HEAP32[$1 + 12 >> 2], 0)) { + break label$1; + } + $2 = is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29(HEAP32[$0 + 16 >> 2], HEAP32[$1 + 16 >> 2], 0); + } + return $2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Shape__20_28b2CircleShape____emscripten__internal__getContext_b2Shape__20_28b2CircleShape____29_28b2BlockAllocator__29_20const__28b2Shape__20_28b2CircleShape____20const__29_28b2BlockAllocator__29_20const_29_29_28b2BlockAllocator__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2DrawWrapper__DrawSolidPolygon_28unsigned_20int_2c_20int_2c_20b2Color_20const__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + void_20emscripten__wrapper_b2Draw___call_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const___28char_20const__2c_20unsigned_20int__2c_20int__2c_20b2Color_20const__29_20const(HEAP32[$4 + 12 >> 2], 6861, $4 + 8 | 0, $4 + 4 | 0, HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2RevoluteJointDef_2c_20float___setWire_b2RevoluteJointDef__28float_20b2RevoluteJointDef____20const__2c_20b2RevoluteJointDef__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2DistanceJointDef_2c_20float___setWire_b2DistanceJointDef__28float_20b2DistanceJointDef____20const__2c_20b2DistanceJointDef__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function b2EdgeShape__b2EdgeShape_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Shape__b2Shape_28_29($0); + HEAP32[$0 >> 2] = 17996; + b2Vec2__b2Vec2_28_29($0 + 12 | 0); + b2Vec2__b2Vec2_28_29($0 + 20 | 0); + b2Vec2__b2Vec2_28_29($0 + 28 | 0); + b2Vec2__b2Vec2_28_29($0 + 36 | 0); + HEAP32[$0 + 4 >> 2] = 1; + HEAPF32[$0 + 8 >> 2] = .009999999776482582; + HEAPF32[$0 + 28 >> 2] = 0; + HEAPF32[$0 + 32 >> 2] = 0; + HEAPF32[$0 + 36 >> 2] = 0; + HEAPF32[$0 + 40 >> 2] = 0; + HEAP8[$0 + 44 | 0] = 0; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function frexp($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + wasm2js_scratch_store_f64(+$0); + $2 = wasm2js_scratch_load_i32(1) | 0; + $3 = wasm2js_scratch_load_i32(0) | 0; + $4 = $2; + $2 = $2 >>> 20 & 2047; + if (($2 | 0) != 2047) { + if (!$2) { + if ($0 == 0) { + $2 = 0; + } else { + $0 = frexp($0 * 0x10000000000000000, $1); + $2 = HEAP32[$1 >> 2] + -64 | 0; + } + HEAP32[$1 >> 2] = $2; + return $0; + } + HEAP32[$1 >> 2] = $2 - 1022; + $2 = $3; + wasm2js_scratch_store_i32(0, $2 | 0); + $2 = $4 & -2146435073 | 1071644672; + wasm2js_scratch_store_i32(1, $2 | 0); + $0 = +wasm2js_scratch_load_f64(); + } + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20b2Transform_20const__2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20_28b2EdgeShape____emscripten__internal__getContext_void_20_28b2EdgeShape____29_28b2MassData__2c_20float_29_20const__28void_20_28b2EdgeShape____20const__29_28b2MassData__2c_20float_29_20const_29_29_28b2MassData__2c_20float_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__FunctionInvoker_void_20_28__29_28b2RayCastCallbackWrapper__29_2c_20void_2c_20b2RayCastCallbackWrapper____invoke_28void_20_28___29_28b2RayCastCallbackWrapper__29_2c_20b2RayCastCallbackWrapper__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[HEAP32[$2 + 12 >> 2] >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__GenericBindingType_b2RayCastCallbackWrapper___fromWireType_28b2RayCastCallbackWrapper__29(HEAP32[$2 + 8 >> 2])); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__FunctionInvoker_void_20_28__29_28b2ContactListenerWrapper__29_2c_20void_2c_20b2ContactListenerWrapper____invoke_28void_20_28___29_28b2ContactListenerWrapper__29_2c_20b2ContactListenerWrapper__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[HEAP32[$2 + 12 >> 2] >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__GenericBindingType_b2ContactListenerWrapper___fromWireType_28b2ContactListenerWrapper__29(HEAP32[$2 + 8 >> 2])); + __stack_pointer = $2 + 16 | 0; +} + +function b2DrawWrapper__DrawPolygon_28unsigned_20int_2c_20int_2c_20b2Color_20const__29($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + void_20emscripten__wrapper_b2Draw___call_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const___28char_20const__2c_20unsigned_20int__2c_20int__2c_20b2Color_20const__29_20const(HEAP32[$4 + 12 >> 2], 6849, $4 + 8 | 0, $4 + 4 | 0, HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______get_short_pointer_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__pointer_traits_char_20const____pointer_to_5babi_v160004_5d_28char_20const__29(std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2])); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Shape__20_28b2EdgeShape____emscripten__internal__getContext_b2Shape__20_28b2EdgeShape____29_28b2BlockAllocator__29_20const__28b2Shape__20_28b2EdgeShape____20const__29_28b2BlockAllocator__29_20const_29_29_28b2BlockAllocator__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Body__ShouldCollideConnected_28b2Body_20const__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 4 >> 2] = $1; + HEAP32[$2 >> 2] = HEAP32[HEAP32[$2 + 8 >> 2] + 108 >> 2]; + label$1: { + while (1) { + if (HEAP32[$2 >> 2]) { + if (!(HEAP8[HEAP32[HEAP32[$2 >> 2] + 4 >> 2] + 61 | 0] & 1) & HEAP32[HEAP32[$2 >> 2] >> 2] == HEAP32[$2 + 4 >> 2]) { + HEAP8[$2 + 15 | 0] = 0; + break label$1; + } + HEAP32[$2 >> 2] = HEAP32[HEAP32[$2 >> 2] + 12 >> 2]; + continue; + } + break; + } + HEAP8[$2 + 15 | 0] = 1; + } + return HEAP8[$2 + 15 | 0] & 1; +} + +function b2Fixture__20_28b2Body____emscripten__internal__getContext_b2Fixture__20_28b2Body____29_28b2Shape_20const__2c_20float_29__28b2Fixture__20_28b2Body____20const__29_28b2Shape_20const__2c_20float_29_29_29_28b2Shape_20const__2c_20float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2FixtureDef_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2FixtureDef_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__MemberAccess_b2PrismaticJointDef_2c_20bool___setWire_b2PrismaticJointDef__28bool_20b2PrismaticJointDef____20const__2c_20b2PrismaticJointDef__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2; + $0 = emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$3 + 7 | 0] & 1); + HEAP8[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0] = $0 & 1; + __stack_pointer = $3 + 16 | 0; +} + +function void_20_28b2ContactListenerWrapper____emscripten__internal__getContext_void_20_28b2ContactListenerWrapper____29_28unsigned_20int_29__28void_20_28b2ContactListenerWrapper____20const__29_28unsigned_20int_29_29_29_28unsigned_20int_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_20const__2c_20b2QueryCallback__2c_20b2AABB_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_20const__2c_20emscripten__internal__AllowedRawPointer_b2QueryCallback__2c_20b2AABB_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function bool_20_28b2ContactListenerWrapper____emscripten__internal__getContext_bool_20_28b2ContactListenerWrapper____29_28unsigned_20int_29__28bool_20_28b2ContactListenerWrapper____20const__29_28unsigned_20int_29_29_29_28unsigned_20int_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20emscripten__internal__MemberAccess_b2WheelJointDef_2c_20float___setWire_b2WheelJointDef__28float_20b2WheelJointDef____20const__2c_20b2WheelJointDef__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2RayCastOutput_2c_20float___setWire_b2RayCastOutput__28float_20b2RayCastOutput____20const__2c_20b2RayCastOutput__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2MouseJointDef_2c_20float___setWire_b2MouseJointDef__28float_20b2MouseJointDef____20const__2c_20b2MouseJointDef__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2MotorJointDef_2c_20float___setWire_b2MotorJointDef__28float_20b2MotorJointDef____20const__2c_20b2MotorJointDef__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____max_size_5babi_v160004_5d_28_29_20const($0) { + $0 = unsigned_20long_20std____2__allocator_traits_std____2__allocator_char____max_size_5babi_v160004_5d_std____2__allocator_char__2c_20void_2c_20void__28std____2__allocator_char__20const__29(std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______alloc_5babi_v160004_5d_28_29_20const($0)); + return ($0 >>> (std____2__numeric_limits_unsigned_20long___max_5babi_v160004_5d_28_29() >>> 1 >>> 0 < $0 >>> 0) | 0) - 16 | 0; +} + +function void_20_28b2Shape____emscripten__internal__getContext_void_20_28b2Shape____29_28b2MassData__2c_20float_29_20const__28void_20_28b2Shape____20const__29_28b2MassData__2c_20float_29_20const_29_29_28b2MassData__2c_20float_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__FunctionInvoker_void_20_28__29_28b2QueryCallbackWrapper__29_2c_20void_2c_20b2QueryCallbackWrapper____invoke_28void_20_28___29_28b2QueryCallbackWrapper__29_2c_20b2QueryCallbackWrapper__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[HEAP32[$2 + 12 >> 2] >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__GenericBindingType_b2QueryCallbackWrapper___fromWireType_28b2QueryCallbackWrapper__29(HEAP32[$2 + 8 >> 2])); + __stack_pointer = $2 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2RevoluteJointDef_2c_20bool___setWire_b2RevoluteJointDef__28bool_20b2RevoluteJointDef____20const__2c_20b2RevoluteJointDef__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2; + $0 = emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$3 + 7 | 0] & 1); + HEAP8[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0] = $0 & 1; + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Joint__2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2JointDef_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Joint__2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2JointDef_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__MemberAccess_b2WeldJointDef_2c_20float___setWire_b2WeldJointDef__28float_20b2WeldJointDef____20const__2c_20b2WeldJointDef__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2RopeJointDef_2c_20float___setWire_b2RopeJointDef__28float_20b2RopeJointDef____20const__2c_20b2RopeJointDef__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2RayCastInput_2c_20float___setWire_b2RayCastInput__28float_20b2RayCastInput____20const__2c_20b2RayCastInput__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__GenericBindingType_b2Transform___toWireType_28b2Transform_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + $5 = operator_20new_28unsigned_20long_29(16); + $3 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + $4 = $1; + $1 = $5; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + $1 = HEAP32[$3 + 12 >> 2]; + $0 = HEAP32[$3 + 8 >> 2]; + $4 = $0; + $0 = $5; + HEAP32[$0 + 8 >> 2] = $4; + HEAP32[$0 + 12 >> 2] = $1; + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function std____2__unique_ptr_std____2____tree_node_b2Fixture__2c_20void___2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______get_deleter_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______second_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2DistanceJointDef__b2DistanceJointDef_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2JointDef__b2JointDef_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 20 | 0); + b2Vec2__b2Vec2_28_29($0 + 28 | 0); + HEAP32[$0 >> 2] = 3; + b2Vec2__Set_28float_2c_20float_29($0 + 20 | 0, Math_fround(0), Math_fround(0)); + b2Vec2__Set_28float_2c_20float_29($0 + 28 | 0, Math_fround(0), Math_fround(0)); + HEAPF32[$0 + 36 >> 2] = 1; + HEAPF32[$0 + 40 >> 2] = 0; + HEAPF32[$0 + 44 >> 2] = 0; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture________tree_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____destroy_28std____2____tree_node_b2Fixture__2c_20void____29($0, std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______root_5babi_v160004_5d_28_29_20const($0)); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2BodyDef_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2BodyDef_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__MemberAccess_b2JointDef_2c_20b2JointType___setWire_b2JointDef__28b2JointType_20b2JointDef____20const__2c_20b2JointDef__2c_20b2JointType_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = emscripten__internal__EnumBindingType_b2JointType___fromWireType_28b2JointType_29(HEAP32[$3 + 4 >> 2]); + HEAP32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $0; + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__Signature_void___get_method_caller_28_29() { + var $0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $0 = __stack_pointer - 16 | 0; + __stack_pointer = $0; + if (!(HEAP8[30028] & 1)) { + wasm2js_i32$0 = 30024, wasm2js_i32$1 = _emval_get_method_caller(emscripten__internal__WithPolicies____ArgTypeList_void___getCount_28_29_20const($0 + 15 | 0) | 0, emscripten__internal__WithPolicies____ArgTypeList_void___getTypes_28_29_20const($0 + 15 | 0) | 0) | 0, + HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + HEAP8[30028] = 1; + } + __stack_pointer = $0 + 16 | 0; + return HEAP32[7506]; +} + +function b2Vec2_20const__20_28b2PrismaticJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2PrismaticJoint____29_28_29_20const__28b2Vec2_20const__20_28b2PrismaticJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20emscripten__internal__MemberAccess_b2Shape_2c_20b2Shape__Type___setWire_b2Shape__28b2Shape__Type_20b2Shape____20const__2c_20b2Shape__2c_20b2Shape__Type_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = emscripten__internal__EnumBindingType_b2Shape__Type___fromWireType_28b2Shape__Type_29(HEAP32[$3 + 4 >> 2]); + HEAP32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $0; + __stack_pointer = $3 + 16 | 0; +} + +function embind_init_b2_28_29__$_4____invoke_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + embind_init_b2_28_29__$_4__operator_28_29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29_20const($3 + 3 | 0, HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function b2WorldQueryWrapper__QueryCallback_28int_29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + wasm2js_i32$0 = $2, wasm2js_i32$1 = b2BroadPhase__GetUserData_28int_29_20const(HEAP32[$0 >> 2], HEAP32[$2 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; + $0 = HEAP32[$0 + 4 >> 2]; + $0 = FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 8 >> 2]]($0, HEAP32[HEAP32[$2 + 4 >> 2] + 16 >> 2]) | 0; + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function std____2__pair_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2_____pair_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___2c_20_28void__290__28std____2__reverse_iterator_b2Vec2_____2c_20std____2__reverse_iterator_b2Vec2_____29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[HEAP32[$3 + 8 >> 2] >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[HEAP32[$3 + 4 >> 2] >> 2]; + return $0; +} + +function b2Vec2_20const__20_28b2RevoluteJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2RevoluteJoint____29_28_29_20const__28b2Vec2_20const__20_28b2RevoluteJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20const__20_28b2DistanceJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2DistanceJoint____29_28_29_20const__28b2Vec2_20const__20_28b2DistanceJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20emscripten__internal__MemberAccess_b2FixtureDef_2c_20float___setWire_b2FixtureDef__28float_20b2FixtureDef____20const__2c_20b2FixtureDef__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function b2Body__SetLinearVelocity_28b2Vec2_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAP32[$0 >> 2]) { + if (b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 8 >> 2]) > Math_fround(0)) { + b2Body__SetAwake_28bool_29($0, 1); + } + $1 = HEAP32[$2 + 8 >> 2]; + $3 = HEAP32[$1 + 4 >> 2]; + HEAP32[$0 + 64 >> 2] = HEAP32[$1 >> 2]; + HEAP32[$0 + 68 >> 2] = $3; + } + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__GenericBindingType_b2Color___toWireType_28b2Color_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + $5 = operator_20new_28unsigned_20long_29(16); + $3 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + $4 = $1; + $1 = $5; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + $1 = HEAP32[$3 + 12 >> 2]; + $0 = HEAP32[$3 + 8 >> 2]; + $4 = $0; + $0 = $5; + HEAP32[$0 + 8 >> 2] = $4; + HEAP32[$0 + 12 >> 2] = $1; + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function void_20std____2__allocator_traits_std____2__allocator_b2Vec2____construct_5babi_v160004_5d_b2Vec2_2c_20b2Vec2_20const__2c_20void__28std____2__allocator_b2Vec2___2c_20b2Vec2__2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + void_20std____2__allocator_b2Vec2___construct_5babi_v160004_5d_b2Vec2_2c_20b2Vec2_20const___28b2Vec2__2c_20b2Vec2_20const__29(HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function b2WeldJointDef__b2WeldJointDef_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2JointDef__b2JointDef_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 20 | 0); + b2Vec2__b2Vec2_28_29($0 + 28 | 0); + HEAP32[$0 >> 2] = 8; + b2Vec2__Set_28float_2c_20float_29($0 + 20 | 0, Math_fround(0), Math_fround(0)); + b2Vec2__Set_28float_2c_20float_29($0 + 28 | 0, Math_fround(0), Math_fround(0)); + HEAPF32[$0 + 36 >> 2] = 0; + HEAPF32[$0 + 40 >> 2] = 0; + HEAPF32[$0 + 44 >> 2] = 0; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Fixture__20_28b2Body____emscripten__internal__getContext_b2Fixture__20_28b2Body____29_28b2FixtureDef_20const__29__28b2Fixture__20_28b2Body____20const__29_28b2FixtureDef_20const__29_29_29_28b2FixtureDef_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20emscripten__internal__MemberAccess_b2WheelJointDef_2c_20bool___setWire_b2WheelJointDef__28bool_20b2WheelJointDef____20const__2c_20b2WheelJointDef__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2; + $0 = emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$3 + 7 | 0] & 1); + HEAP8[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0] = $0 & 1; + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2MassData__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2MassData__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__GenericBindingType_b2AABB___toWireType_28b2AABB_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + $5 = operator_20new_28unsigned_20long_29(16); + $3 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$3 >> 2]; + $0 = HEAP32[$3 + 4 >> 2]; + $4 = $1; + $1 = $5; + HEAP32[$1 >> 2] = $4; + HEAP32[$1 + 4 >> 2] = $0; + $1 = HEAP32[$3 + 12 >> 2]; + $0 = HEAP32[$3 + 8 >> 2]; + $4 = $0; + $0 = $5; + HEAP32[$0 + 8 >> 2] = $4; + HEAP32[$0 + 12 >> 2] = $1; + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function emscripten__internal__Invoker_bool_2c_20unsigned_20int___invoke_28bool_20_28__29_28unsigned_20int_29_2c_20unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$2 + 8 >> 2])) & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function void_20emscripten__internal__MemberAccess_b2BodyDef_2c_20b2BodyType___setWire_b2BodyDef__28b2BodyType_20b2BodyDef____20const__2c_20b2BodyDef__2c_20b2BodyType_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = emscripten__internal__EnumBindingType_b2BodyType___fromWireType_28b2BodyType_29(HEAP32[$3 + 4 >> 2]); + HEAP32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $0; + __stack_pointer = $3 + 16 | 0; +} + +function void_20_28b2PrismaticJoint____emscripten__internal__getContext_void_20_28b2PrismaticJoint____29_28float_2c_20float_29__28void_20_28b2PrismaticJoint____20const__29_28float_2c_20float_29_29_29_28float_2c_20float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2Vec2_20const__2c_20float_29__28void_20_28b2Body____20const__29_28b2Vec2_20const__2c_20float_29_29_29_28b2Vec2_20const__2c_20float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2MassData__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2MassData__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function bool_20_28b2Fixture____emscripten__internal__getContext_bool_20_28b2Fixture____29_28b2Vec2_20const__29_20const__28bool_20_28b2Fixture____20const__29_28b2Vec2_20const__29_20const_29_29_28b2Vec2_20const__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20emscripten__internal__MemberAccess_b2MassData_2c_20float___setWire_b2MassData__28float_20b2MassData____20const__2c_20b2MassData__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20_28b2RevoluteJoint____emscripten__internal__getContext_void_20_28b2RevoluteJoint____29_28float_2c_20float_29__28void_20_28b2RevoluteJoint____20const__29_28float_2c_20float_29_29_29_28float_2c_20float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2ContactListener____emscripten__internal__getContext_void_20_28b2ContactListener____29_28unsigned_20int_29__28void_20_28b2ContactListener____20const__29_28unsigned_20int_29_29_29_28unsigned_20int_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2Vec2_20const__2c_20bool_29__28void_20_28b2Body____20const__29_28b2Vec2_20const__2c_20bool_29_29_29_28b2Vec2_20const__2c_20bool_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20const__20_28b2WheelJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2WheelJoint____29_28_29_20const__28b2Vec2_20const__20_28b2WheelJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20const__20_28b2MouseJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2MouseJoint____29_28_29_20const__28b2Vec2_20const__20_28b2MouseJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20const__20_28b2MotorJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2MotorJoint____29_28_29_20const__28b2Vec2_20const__20_28b2MotorJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20_28b2Body____emscripten__internal__getContext_b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const__28b2Vec2_20_28b2Body____20const__29_28b2Vec2_20const__29_20const_29_29_28b2Vec2_20const__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2AABB_20const__20_28b2Fixture____emscripten__internal__getContext_b2AABB_20const__20_28b2Fixture____29_28int_29_20const__28b2AABB_20const__20_28b2Fixture____20const__29_28int_29_20const_29_29_28int_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2MassData__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2MassData__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function unsigned_20long_20std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______max_size_5babi_v160004_5d_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void____2c_20void__28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____max_size_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____ConstructTransaction___ConstructTransaction_5babi_v160004_5d_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$3 + 8 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[HEAP32[$3 + 8 >> 2] + 4 >> 2]; + HEAP32[$0 + 8 >> 2] = HEAP32[HEAP32[$3 + 8 >> 2] + 4 >> 2] + (HEAP32[$3 + 4 >> 2] << 3); + return $0; +} + +function b2World__QueryAABB_28b2QueryCallback__2c_20b2AABB_20const__29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 32 | 0; + __stack_pointer = $3; + HEAP32[$3 + 28 >> 2] = $0; + HEAP32[$3 + 24 >> 2] = $1; + HEAP32[$3 + 20 >> 2] = $2; + $0 = HEAP32[$3 + 28 >> 2]; + HEAP32[$3 + 12 >> 2] = $0 + 102868; + HEAP32[$3 + 16 >> 2] = HEAP32[$3 + 24 >> 2]; + void_20b2BroadPhase__Query_b2WorldQueryWrapper__28b2WorldQueryWrapper__2c_20b2AABB_20const__29_20const($0 + 102868 | 0, $3 + 12 | 0, HEAP32[$3 + 20 >> 2]); + __stack_pointer = $3 + 32 | 0; +} + +function void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28float_2c_20int_2c_20int_29__28void_20_28b2World____20const__29_28float_2c_20int_2c_20int_29_29_29_28float_2c_20int_2c_20int_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2PolygonShape____emscripten__internal__getContext_void_20_28b2PolygonShape____29_28float_2c_20float_29__28void_20_28b2PolygonShape____20const__29_28float_2c_20float_29_29_29_28float_2c_20float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2PrismaticJoint____emscripten__internal__getContext_float_20_28b2PrismaticJoint____29_28float_29_20const__28float_20_28b2PrismaticJoint____20const__29_28float_29_20const_29_29_28float_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__Invoker_b2World__2c_20b2Vec2_____invoke_28b2World__20_28__29_28b2Vec2___29_2c_20b2Vec2__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + emscripten__internal__BindingType_b2Vec2___2c_20void___fromWireType_28b2Vec2__29($2, HEAP32[$2 + 8 >> 2]); + $0 = emscripten__internal__BindingType_b2World__2c_20void___toWireType_28b2World__29(FUNCTION_TABLE[$0 | 0]($2) | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Vec2_20const__20_28b2WeldJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2WeldJoint____29_28_29_20const__28b2Vec2_20const__20_28b2WeldJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20const__20_28b2RopeJoint____emscripten__internal__getContext_b2Vec2_20const__20_28b2RopeJoint____29_28_29_20const__28b2Vec2_20const__20_28b2RopeJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Transform_20const__20_28b2Body____emscripten__internal__getContext_b2Transform_20const__20_28b2Body____29_28_29_20const__28b2Transform_20const__20_28b2Body____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2TempPolygon__b2TempPolygon_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + $3 = $0 - -64 | 0; + $2 = $0; + while (1) { + b2Vec2__b2Vec2_28_29($2); + $2 = $2 + 8 | 0; + if (($3 | 0) != ($2 | 0)) { + continue; + } + break; + } + $0 = $0 - -64 | 0; + $2 = $0 - -64 | 0; + while (1) { + b2Vec2__b2Vec2_28_29($0); + $0 = $0 + 8 | 0; + if (($2 | 0) != ($0 | 0)) { + continue; + } + break; + } + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Joint__20_28b2World____emscripten__internal__getContext_b2Joint__20_28b2World____29_28b2JointDef_20const__29__28b2Joint__20_28b2World____20const__29_28b2JointDef_20const__29_29_29_28b2JointDef_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Filter_20const__20_28b2Fixture____emscripten__internal__getContext_b2Filter_20const__20_28b2Fixture____29_28_29_20const__28b2Filter_20const__20_28b2Fixture____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20emscripten__internal__MemberAccess_b2BodyDef_2c_20float___setWire_b2BodyDef__28float_20b2BodyDef____20const__2c_20b2BodyDef__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function std____2____compressed_pair_std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______second_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_201_2c_20false_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 4 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function float_20emscripten__internal__fromGenericWireType_float__28double_29($0) { + var $1 = 0, $2 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAPF64[$1 + 8 >> 3] = $0; + wasm2js_i32$0 = $1, wasm2js_f32$0 = emscripten__internal__GenericWireTypeConverter_float___from_28double_29(HEAPF64[$1 + 8 >> 3]), + HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$1 + 4 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $2; +} + +function emscripten__class__b2Draw_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2Draw_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2DrawWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2DrawWrapper__29__operator_28_29_28b2DrawWrapper__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + emscripten__internal__WrapperBase__setNotifyJSOnDestruction_28bool_29(HEAP32[$2 + 8 >> 2] + 8 | 0, 1); + __stack_pointer = $2 + 16 | 0; +} + +function b2World__ClearForces_28_29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$1 + 8 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] + 102948 >> 2]; + while (1) { + if (HEAP32[$1 + 8 >> 2]) { + b2Vec2__SetZero_28_29(HEAP32[$1 + 8 >> 2] + 76 | 0); + HEAPF32[HEAP32[$1 + 8 >> 2] + 84 >> 2] = 0; + wasm2js_i32$0 = $1, wasm2js_i32$1 = b2Body__GetNext_28_29(HEAP32[$1 + 8 >> 2]), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + continue; + } + break; + } + __stack_pointer = $1 + 16 | 0; +} + +function float_20emscripten__internal__MemberAccess_b2PrismaticJointDef_2c_20float___getWire_b2PrismaticJointDef__28float_20b2PrismaticJointDef____20const__2c_20b2PrismaticJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function float_20_28b2RevoluteJoint____emscripten__internal__getContext_float_20_28b2RevoluteJoint____29_28float_29_20const__28float_20_28b2RevoluteJoint____20const__29_28float_29_20const_29_29_28float_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function bool_20_28b2QueryCallback____emscripten__internal__getContext_bool_20_28b2QueryCallback____29_28unsigned_20int_29__28bool_20_28b2QueryCallback____20const__29_28unsigned_20int_29_29_29_28unsigned_20int_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function bool_20_28b2AABB____emscripten__internal__getContext_bool_20_28b2AABB____29_28b2AABB_20const__29_20const__28bool_20_28b2AABB____20const__29_28b2AABB_20const__29_20const_29_29_28b2AABB_20const__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Island___b2Island_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2StackAllocator__Free_28void__29(HEAP32[$0 >> 2], HEAP32[$0 + 20 >> 2]); + b2StackAllocator__Free_28void__29(HEAP32[$0 >> 2], HEAP32[$0 + 24 >> 2]); + b2StackAllocator__Free_28void__29(HEAP32[$0 >> 2], HEAP32[$0 + 16 >> 2]); + b2StackAllocator__Free_28void__29(HEAP32[$0 >> 2], HEAP32[$0 + 12 >> 2]); + b2StackAllocator__Free_28void__29(HEAP32[$0 >> 2], HEAP32[$0 + 8 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__MemberAccess_b2FixtureDef_2c_20bool___setWire_b2FixtureDef__28bool_20b2FixtureDef____20const__2c_20b2FixtureDef__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2; + $0 = emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$3 + 7 | 0] & 1); + HEAP8[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0] = $0 & 1; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2Filter_2c_20short___setWire_b2Filter__28short_20b2Filter____20const__2c_20b2Filter__2c_20short_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP16[$3 + 6 >> 1] = $2; + $0 = emscripten__internal__BindingType_short_2c_20void___fromWireType_28short_29(HEAPU16[$3 + 6 >> 1] << 16 >> 16); + HEAP16[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 1] = $0; + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__Invoker_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______invoke_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20void___toWireType_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20_28b2Fixture____emscripten__internal__getContext_void_20_28b2Fixture____29_28b2MassData__29_20const__28void_20_28b2Fixture____20const__29_28b2MassData__29_20const_29_29_28b2MassData__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2__pair_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int_____pair_5babi_v160004_5d_std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___2c_20_28void__290__28std____2__reverse_iterator_int_____2c_20std____2__reverse_iterator_int_____29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[HEAP32[$3 + 8 >> 2] >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[HEAP32[$3 + 4 >> 2] >> 2]; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2MassData__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20emscripten__internal__AllowedRawPointer_b2MassData__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Body__20_28b2World____emscripten__internal__getContext_b2Body__20_28b2World____29_28b2BodyDef_20const__29__28b2Body__20_28b2World____20const__29_28b2BodyDef_20const__29_29_29_28b2BodyDef_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20emscripten__internal__MemberAccess_b2RevoluteJointDef_2c_20float___getWire_b2RevoluteJointDef__28float_20b2RevoluteJointDef____20const__2c_20b2RevoluteJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function float_20emscripten__internal__MemberAccess_b2DistanceJointDef_2c_20float___getWire_b2DistanceJointDef__28float_20b2DistanceJointDef____20const__2c_20b2DistanceJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____vector_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______destroy_vector____destroy_vector_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29($1 + 8 | 0, $0); + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______destroy_vector__operator_28_29_5babi_v160004_5d_28_29($1 + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__MemberAccess_b2Shape_2c_20float___setWire_b2Shape__28float_20b2Shape____20const__2c_20b2Shape__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2Color_2c_20float___setWire_b2Color__28float_20b2Color____20const__2c_20b2Color__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function void_20_28b2MouseJoint____emscripten__internal__getContext_void_20_28b2MouseJoint____29_28b2Vec2_20const__29__28void_20_28b2MouseJoint____20const__29_28b2Vec2_20const__29_29_29_28b2Vec2_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2MotorJoint____emscripten__internal__getContext_void_20_28b2MotorJoint____29_28b2Vec2_20const__29__28void_20_28b2MotorJoint____20const__29_28b2Vec2_20const__29_29_29_28b2Vec2_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_unsigned_20long_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_unsigned_20long_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__vector_int_2c_20std____2__allocator_int_____ConstructTransaction___ConstructTransaction_5babi_v160004_5d_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$3 + 8 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[HEAP32[$3 + 8 >> 2] + 4 >> 2]; + HEAP32[$0 + 8 >> 2] = HEAP32[HEAP32[$3 + 8 >> 2] + 4 >> 2] + (HEAP32[$3 + 4 >> 2] << 2); + return $0; +} + +function embind_init_b2_28_29__$_4__operator_28_29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29_20const($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + b2PolygonShape__Set_28b2Vec2_20const__2c_20int_29(HEAP32[$4 + 8 >> 2], std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29(HEAP32[$4 + 4 >> 2]), HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2JointDef_2c_20bool___setWire_b2JointDef__28bool_20b2JointDef____20const__2c_20b2JointDef__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2; + $0 = emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$3 + 7 | 0] & 1); + HEAP8[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0] = $0 & 1; + __stack_pointer = $3 + 16 | 0; +} + +function void_20_28b2Fixture____emscripten__internal__getContext_void_20_28b2Fixture____29_28b2Filter_20const__29__28void_20_28b2Fixture____20const__29_28b2Filter_20const__29_29_29_28b2Filter_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Draw____emscripten__internal__getContext_void_20_28b2Draw____29_28b2Transform_20const__29__28void_20_28b2Draw____20const__29_28b2Transform_20const__29_29_29_28b2Transform_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2WheelJoint____emscripten__internal__getContext_float_20_28b2WheelJoint____29_28float_29_20const__28float_20_28b2WheelJoint____20const__29_28float_29_20const_29_29_28float_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Color_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Color_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function bool_20std____2__operator___5babi_v160004_5d_b2Vec2__2c_20b2Vec2___28std____2__reverse_iterator_b2Vec2___20const__2c_20std____2__reverse_iterator_b2Vec2___20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = std____2__reverse_iterator_b2Vec2____base_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2]); + $1 = std____2__reverse_iterator_b2Vec2____base_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; + return ($0 | 0) != ($1 | 0); +} + +function b2Vec2_20_28b2RopeJoint____emscripten__internal__getContext_b2Vec2_20_28b2RopeJoint____29_28float_29_20const__28b2Vec2_20_28b2RopeJoint____20const__29_28float_29_20const_29_29_28float_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Shape__Type_20_28b2Fixture____emscripten__internal__getContext_b2Shape__Type_20_28b2Fixture____29_28_29_20const__28b2Shape__Type_20_28b2Fixture____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20emscripten__internal__MemberAccess_b2Vec2_2c_20float___setWire_b2Vec2__28float_20b2Vec2____20const__2c_20b2Vec2__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function __cxxabiv1____si_class_type_info__has_unambiguous_public_base_28__cxxabiv1____dynamic_cast_info__2c_20void__2c_20int_29_20const($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, HEAP32[$1 + 8 >> 2], 0)) { + __cxxabiv1____class_type_info__process_found_base_class_28__cxxabiv1____dynamic_cast_info__2c_20void__2c_20int_29_20const($1, $1, $2, $3); + return; + } + $0 = HEAP32[$0 + 8 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 28 >> 2]]($0, $1, $2, $3); +} + +function std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_200_2c_20false_____get_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function decltype_28fp_29_20emscripten__select_overload_void_20_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29_2c_20b2PolygonShape__28void_20_28b2PolygonShape____29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29_29($0, $1) { + var $2 = 0, $3 = 0; + $3 = HEAP32[$1 >> 2]; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 8 >> 2] = $3; + $1 = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = $1; + $1 = HEAP32[$0 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2]; + HEAP32[$0 >> 2] = $1; +} + +function void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2ContactListener__29__28void_20_28b2World____20const__29_28b2ContactListener__29_29_29_28b2ContactListener__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2MassData__29_20const__28void_20_28b2Body____20const__29_28b2MassData__29_20const_29_29_28b2MassData__29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2RopeJoint____emscripten__internal__getContext_float_20_28b2RopeJoint____29_28float_29_20const__28float_20_28b2RopeJoint____20const__29_28float_29_20const_29_29_28float_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2PrismaticJoint____emscripten__internal__getContext_float_20_28b2PrismaticJoint____29_28_29_20const__28float_20_28b2PrismaticJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20const__20_28b2Body____emscripten__internal__getContext_b2Vec2_20const__20_28b2Body____29_28_29_20const__28b2Vec2_20const__20_28b2Body____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20emscripten__internal__MemberAccess_b2BodyDef_2c_20bool___setWire_b2BodyDef__28bool_20b2BodyDef____20const__2c_20b2BodyDef__2c_20bool_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2; + $0 = emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$3 + 7 | 0] & 1); + HEAP8[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] | 0] = $0 & 1; + __stack_pointer = $3 + 16 | 0; +} + +function b2Body__CreateFixture_28b2Shape_20const__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 48 | 0; + __stack_pointer = $3; + HEAP32[$3 + 44 >> 2] = $0; + HEAP32[$3 + 40 >> 2] = $1; + HEAPF32[$3 + 36 >> 2] = $2; + $0 = HEAP32[$3 + 44 >> 2]; + b2FixtureDef__b2FixtureDef_28_29($3 + 8 | 0); + HEAP32[$3 + 8 >> 2] = HEAP32[$3 + 40 >> 2]; + HEAPF32[$3 + 24 >> 2] = HEAPF32[$3 + 36 >> 2]; + $0 = b2Body__CreateFixture_28b2FixtureDef_20const__29($0, $3 + 8 | 0); + __stack_pointer = $3 + 48 | 0; + return $0 | 0; +} + +function void_20emscripten__internal__MemberAccess_b2Rot_2c_20float___setWire_b2Rot__28float_20b2Rot____20const__2c_20b2Rot__2c_20float_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $2 = emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29(HEAPF32[$3 + 4 >> 2]); + HEAPF32[HEAP32[$3 + 8 >> 2] + HEAP32[HEAP32[$3 + 12 >> 2] >> 2] >> 2] = $2; + __stack_pointer = $3 + 16 | 0; +} + +function unsigned_20short_20emscripten__internal__MemberAccess_b2Filter_2c_20unsigned_20short___getWire_b2Filter__28unsigned_20short_20b2Filter____20const__2c_20b2Filter_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__BindingType_unsigned_20short_2c_20void___toWireType_28unsigned_20short_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 & 65535; +} + +function unsigned_20int_20_28b2Draw____emscripten__internal__getContext_unsigned_20int_20_28b2Draw____29_28_29_20const__28unsigned_20int_20_28b2Draw____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2RevoluteJoint____emscripten__internal__getContext_float_20_28b2RevoluteJoint____29_28_29_20const__28float_20_28b2RevoluteJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2DistanceJoint____emscripten__internal__getContext_float_20_28b2DistanceJoint____29_28_29_20const__28float_20_28b2DistanceJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20unsigned_20int_2c_20int_2c_20b2Color_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20unsigned_20int_2c_20int_2c_20b2Color_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20unsigned_20int_2c_20unsigned_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20unsigned_20int_2c_20unsigned_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function bool_20_28b2PrismaticJoint____emscripten__internal__getContext_bool_20_28b2PrismaticJoint____29_28_29_20const__28bool_20_28b2PrismaticJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Shape__Type_20_28b2Shape____emscripten__internal__getContext_b2Shape__Type_20_28b2Shape____29_28_29_20const__28b2Shape__Type_20_28b2Shape____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20emscripten__internal__MemberAccess_b2WheelJointDef_2c_20float___getWire_b2WheelJointDef__28float_20b2WheelJointDef____20const__2c_20b2WheelJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function float_20emscripten__internal__MemberAccess_b2RayCastOutput_2c_20float___getWire_b2RayCastOutput__28float_20b2RayCastOutput____20const__2c_20b2RayCastOutput_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function float_20emscripten__internal__MemberAccess_b2MouseJointDef_2c_20float___getWire_b2MouseJointDef__28float_20b2MouseJointDef____20const__2c_20b2MouseJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function float_20emscripten__internal__MemberAccess_b2MotorJointDef_2c_20float___getWire_b2MotorJointDef__28float_20b2MotorJointDef____20const__2c_20b2MotorJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function b2MouseJoint__SetTarget_28b2Vec2_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (operator___28b2Vec2_20const__2c_20b2Vec2_20const__29(HEAP32[$2 + 8 >> 2], $0 + 76 | 0) & 1) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + $1 = HEAP32[$2 + 8 >> 2]; + $3 = HEAP32[$1 + 4 >> 2]; + HEAP32[$0 + 76 >> 2] = HEAP32[$1 >> 2]; + HEAP32[$0 + 80 >> 2] = $3; + } + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__WireTypePack____WireTypePack_28_29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + wasm2js_i32$0 = $1, wasm2js_i32$1 = std____2__array_emscripten__internal__GenericWireType_2c_200ul___data_5babi_v160004_5d_28_29($0), + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + emscripten__internal__writeGenericWireTypes_28emscripten__internal__GenericWireType___29($1 + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2BlockAllocator___b2BlockAllocator_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$1 + 4 >> 2] = 0; + while (1) { + if (HEAP32[$1 + 4 >> 2] < HEAP32[$0 + 4 >> 2]) { + b2Free_28void__29(HEAP32[(HEAP32[$0 >> 2] + (HEAP32[$1 + 4 >> 2] << 3) | 0) + 4 >> 2]); + HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] + 1; + continue; + } + break; + } + b2Free_28void__29(HEAP32[$0 >> 2]); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function bool_20_28b2RevoluteJoint____emscripten__internal__getContext_bool_20_28b2RevoluteJoint____29_28_29_20const__28bool_20_28b2RevoluteJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______allocate_5babi_v160004_5d_28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20unsigned_20long_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____allocate_5babi_v160004_5d_28unsigned_20long_29(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_unsigned_20long_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int___20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_unsigned_20long_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int___20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function __cxxabiv1____class_type_info__search_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_2c_20bool_29_20const($0, $1, $2, $3, $4, $5) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + $5 = $5 | 0; + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, HEAP32[$1 + 8 >> 2], $5)) { + __cxxabiv1____class_type_info__process_static_type_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_29_20const($1, $1, $2, $3, $4); + } +} + +function float_20emscripten__internal__MemberAccess_b2WeldJointDef_2c_20float___getWire_b2WeldJointDef__28float_20b2WeldJointDef____20const__2c_20b2WeldJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function float_20emscripten__internal__MemberAccess_b2RopeJointDef_2c_20float___getWire_b2RopeJointDef__28float_20b2RopeJointDef____20const__2c_20b2RopeJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function float_20emscripten__internal__MemberAccess_b2RayCastInput_2c_20float___getWire_b2RayCastInput__28float_20b2RayCastInput____20const__2c_20b2RayCastInput_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function void_20std____2__allocator_traits_std____2__allocator_int____construct_5babi_v160004_5d_int_2c_20int_20const__2c_20void__28std____2__allocator_int___2c_20int__2c_20int_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + void_20std____2__allocator_int___construct_5babi_v160004_5d_int_2c_20int_20const___28int__2c_20int_20const__29(HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2Vec2_20const__29__28void_20_28b2World____20const__29_28b2Vec2_20const__29_29_29_28b2Vec2_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2MassData____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20emscripten__internal__AllowedRawPointer_b2MassData_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20int_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20int_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function bool_20_28b2PolygonShape____emscripten__internal__getContext_bool_20_28b2PolygonShape____29_28_29_20const__28bool_20_28b2PolygonShape____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20_28b2Joint____emscripten__internal__getContext_b2Vec2_20_28b2Joint____29_28float_29_20const__28b2Vec2_20_28b2Joint____20const__29_28float_29_20const_29_29_28float_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2JointType_20_28b2Joint____emscripten__internal__getContext_b2JointType_20_28b2Joint____29_28_29_20const__28b2JointType_20_28b2Joint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20const__20emscripten__internal__getActualType_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20float_2c_20float_2c_20b2Vec2_20const__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20float_2c_20float_2c_20b2Vec2_20const__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20_28b2PrismaticJoint____emscripten__internal__getContext_void_20_28b2PrismaticJoint____29_28float_29__28void_20_28b2PrismaticJoint____20const__29_28float_29_29_29_28float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28float_2c_20bool_29__28void_20_28b2Body____20const__29_28float_2c_20bool_29_29_29_28float_2c_20bool_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2Vec2_20const__29__28void_20_28b2Body____20const__29_28b2Vec2_20const__29_29_29_28b2Vec2_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function int_20_28b2PolygonShape____emscripten__internal__getContext_int_20_28b2PolygonShape____29_28_29_20const__28int_20_28b2PolygonShape____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2WheelJoint____emscripten__internal__getContext_float_20_28b2WheelJoint____29_28_29_20const__28float_20_28b2WheelJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2MouseJoint____emscripten__internal__getContext_float_20_28b2MouseJoint____29_28_29_20const__28float_20_28b2MouseJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2MotorJoint____emscripten__internal__getContext_float_20_28b2MotorJoint____29_28_29_20const__28float_20_28b2MotorJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2Joint____emscripten__internal__getContext_float_20_28b2Joint____29_28float_29_20const__28float_20_28b2Joint____20const__29_28float_29_20const_29_29_28float_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function bool_20emscripten__internal__fromGenericWireType_bool__28double_29($0) { + var $1 = 0, $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAPF64[$1 + 8 >> 3] = $0; + wasm2js_i32$0 = $1, wasm2js_i32$1 = emscripten__internal__GenericWireTypeConverter_bool___from_28double_29(HEAPF64[$1 + 8 >> 3]) & 1, + HEAP8[wasm2js_i32$0 + 7 | 0] = wasm2js_i32$1; + $2 = emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29(HEAP8[$1 + 7 | 0] & 1); + __stack_pointer = $1 + 16 | 0; + return $2 & 1; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2AABB__2c_20b2AABB__2c_20b2AABB____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20emscripten__internal__AllowedRawPointer_b2AABB_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__Invoker_std____2__vector_int_2c_20std____2__allocator_int______invoke_28std____2__vector_int_2c_20std____2__allocator_int____20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_std____2__vector_int_2c_20std____2__allocator_int____2c_20void___toWireType_28std____2__vector_int_2c_20std____2__allocator_int____29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2Body__SynchronizeTransform_28_29($0) { + var $1 = 0, $2 = 0; + $1 = __stack_pointer - 32 | 0; + __stack_pointer = $1; + HEAP32[$1 + 28 >> 2] = $0; + $0 = HEAP32[$1 + 28 >> 2]; + b2Rot__Set_28float_29($0 + 20 | 0, HEAPF32[$0 + 56 >> 2]); + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($1 + 12 | 0, $0 + 20 | 0, $0 + 28 | 0); + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($1 + 20 | 0, $0 + 44 | 0, $1 + 12 | 0); + $2 = HEAP32[$1 + 24 >> 2]; + HEAP32[$0 + 12 >> 2] = HEAP32[$1 + 20 >> 2]; + HEAP32[$0 + 16 >> 2] = $2; + __stack_pointer = $1 + 32 | 0; +} + +function void_20_28b2RevoluteJoint____emscripten__internal__getContext_void_20_28b2RevoluteJoint____29_28float_29__28void_20_28b2RevoluteJoint____20const__29_28float_29_29_29_28float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2PrismaticJoint____emscripten__internal__getContext_void_20_28b2PrismaticJoint____29_28bool_29__28void_20_28b2PrismaticJoint____20const__29_28bool_29_29_29_28bool_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Draw____emscripten__internal__getContext_void_20_28b2Draw____29_28unsigned_20int_29__28void_20_28b2Draw____20const__29_28unsigned_20int_29_29_29_28unsigned_20int_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2DistanceJoint____emscripten__internal__getContext_void_20_28b2DistanceJoint____29_28float_29__28void_20_28b2DistanceJoint____20const__29_28float_29_29_29_28float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2__pair_char_20const__2c_20char___20std____2____copy_5babi_v160004_5d_std____2___ClassicAlgPolicy_2c_20char_20const__2c_20char_20const__2c_20char___28char_20const__2c_20char_20const__2c_20char__29($0, $1, $2, $3) { + std____2__pair_char_20const__2c_20char___20std____2____dispatch_copy_or_move_5babi_v160004_5d_std____2___ClassicAlgPolicy_2c_20std____2____copy_loop_std____2___ClassicAlgPolicy__2c_20std____2____copy_trivial_2c_20char_20const__2c_20char_20const__2c_20char___28char_20const__2c_20char_20const__2c_20char__29($0, $1, $2, $3); +} + +function int_20_28b2CircleShape____emscripten__internal__getContext_int_20_28b2CircleShape____29_28_29_20const__28int_20_28b2CircleShape____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2WeldJoint____emscripten__internal__getContext_float_20_28b2WeldJoint____29_28_29_20const__28float_20_28b2WeldJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2RopeJoint____emscripten__internal__getContext_float_20_28b2RopeJoint____29_28_29_20const__28float_20_28b2RopeJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2ContactListener____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2ContactListener_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20b2MassData____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20emscripten__internal__AllowedRawPointer_b2MassData_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function bool_20std____2__operator___5babi_v160004_5d_int__2c_20int___28std____2__reverse_iterator_int___20const__2c_20std____2__reverse_iterator_int___20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = std____2__reverse_iterator_int____base_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 12 >> 2]); + $1 = std____2__reverse_iterator_int____base_5babi_v160004_5d_28_29_20const(HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; + return ($0 | 0) != ($1 | 0); +} + +function bool_20_28b2WheelJoint____emscripten__internal__getContext_bool_20_28b2WheelJoint____29_28_29_20const__28bool_20_28b2WheelJoint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2PrismaticJointDef_2c_20b2Vec2___getWire_b2PrismaticJointDef__28b2Vec2_20b2PrismaticJointDef____20const__2c_20b2PrismaticJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2BodyType_20_28b2Body____emscripten__internal__getContext_b2BodyType_20_28b2Body____29_28_29_20const__28b2BodyType_20_28b2Body____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function operator__28b2Vec3_20const__2c_20b2Vec3_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Vec3__b2Vec3_28float_2c_20float_2c_20float_29($0, Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2] + HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]), Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2] + HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2]), Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 8 >> 2] + HEAPF32[HEAP32[$3 + 8 >> 2] + 8 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function float_20emscripten__internal__MemberAccess_b2FixtureDef_2c_20float___getWire_b2FixtureDef__28float_20b2FixtureDef____20const__2c_20b2FixtureDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function std____2__vector_int_2c_20std____2__allocator_int_____vector_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2__vector_int_2c_20std____2__allocator_int______destroy_vector____destroy_vector_28std____2__vector_int_2c_20std____2__allocator_int____29($1 + 8 | 0, $0); + std____2__vector_int_2c_20std____2__allocator_int______destroy_vector__operator_28_29_5babi_v160004_5d_28_29($1 + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2ContactListenerWrapper__b2ContactListenerWrapper___28emscripten__val___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + emscripten__wrapper_b2ContactListener___wrapper___28emscripten__val___29($0, HEAP32[$2 + 8 >> 2]); + HEAP32[$0 >> 2] = 25980; + std____2__set_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____set_5babi_v160004_5d_28_29($0 + 12 | 0); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function void_20_28b2RevoluteJoint____emscripten__internal__getContext_void_20_28b2RevoluteJoint____29_28bool_29__28void_20_28b2RevoluteJoint____20const__29_28bool_29_29_29_28bool_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__FunctionInvoker_void_20_28__29_28b2DrawWrapper__29_2c_20void_2c_20b2DrawWrapper____invoke_28void_20_28___29_28b2DrawWrapper__29_2c_20b2DrawWrapper__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[HEAP32[$2 + 12 >> 2] >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__GenericBindingType_b2DrawWrapper___fromWireType_28b2DrawWrapper__29(HEAP32[$2 + 8 >> 2])); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__Invoker_unsigned_20int___invoke_28unsigned_20int_20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + wasm2js_i32$0 = $1, wasm2js_i32$1 = FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0, + HEAP32[wasm2js_i32$0 + 8 >> 2] = wasm2js_i32$1; + $0 = emscripten__internal__BindingType_unsigned_20int_2c_20void___toWireType_28unsigned_20int_20const__29($1 + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2RevoluteJointDef_2c_20b2Vec2___getWire_b2RevoluteJointDef__28b2Vec2_20b2RevoluteJointDef____20const__2c_20b2RevoluteJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2DistanceJointDef_2c_20b2Vec2___getWire_b2DistanceJointDef__28b2Vec2_20b2DistanceJointDef____20const__2c_20b2DistanceJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2PrismaticJoint__EnableLimit_28bool_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if ((HEAP8[$2 + 11 | 0] & 1) != (HEAP8[$0 + 140 | 0] & 1)) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAP8[$0 + 140 | 0] = HEAP8[$2 + 11 | 0] & 1; + HEAPF32[$0 + 116 >> 2] = 0; + HEAPF32[$0 + 120 >> 2] = 0; + } + __stack_pointer = $2 + 16 | 0; +} + +function int_20_28b2EdgeShape____emscripten__internal__getContext_int_20_28b2EdgeShape____29_28_29_20const__28int_20_28b2EdgeShape____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2Fixture____emscripten__internal__getContext_float_20_28b2Fixture____29_28_29_20const__28float_20_28b2Fixture____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function bool_20emscripten__internal__MemberAccess_b2PrismaticJointDef_2c_20bool___getWire_b2PrismaticJointDef__28bool_20b2PrismaticJointDef____20const__2c_20b2PrismaticJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(HEAP8[HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0] & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function b2RevoluteJoint__EnableLimit_28bool_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if ((HEAP8[$2 + 11 | 0] & 1) != (HEAP8[$0 + 116 | 0] & 1)) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAP8[$0 + 116 | 0] = HEAP8[$2 + 11 | 0] & 1; + HEAPF32[$0 + 96 >> 2] = 0; + HEAPF32[$0 + 100 >> 2] = 0; + } + __stack_pointer = $2 + 16 | 0; +} + +function std____2__set_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____erase_5babi_v160004_5d_28b2Fixture__20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = unsigned_20long_20std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______erase_unique_b2Fixture___28b2Fixture__20const__29(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20_28b2WheelJoint____emscripten__internal__getContext_void_20_28b2WheelJoint____29_28float_29__28void_20_28b2WheelJoint____20const__29_28float_29_29_29_28float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2MouseJoint____emscripten__internal__getContext_void_20_28b2MouseJoint____29_28float_29__28void_20_28b2MouseJoint____20const__29_28float_29_29_29_28float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2MotorJoint____emscripten__internal__getContext_void_20_28b2MotorJoint____29_28float_29__28void_20_28b2MotorJoint____20const__29_28float_29_29_29_28float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20emscripten__internal__MemberAccess_b2MassData_2c_20float___getWire_b2MassData__28float_20b2MassData____20const__2c_20b2MassData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function bool_20_28b2Fixture____emscripten__internal__getContext_bool_20_28b2Fixture____29_28_29_20const__28bool_20_28b2Fixture____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20_28b2World____emscripten__internal__getContext_b2Vec2_20_28b2World____29_28_29_20const__28b2Vec2_20_28b2World____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20_28b2Joint____emscripten__internal__getContext_b2Vec2_20_28b2Joint____29_28_29_20const__28b2Vec2_20_28b2Joint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function bool_20emscripten__internal__MemberAccess_b2RevoluteJointDef_2c_20bool___getWire_b2RevoluteJointDef__28bool_20b2RevoluteJointDef____20const__2c_20b2RevoluteJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(HEAP8[HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0] & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function emscripten__wrapper_b2RayCastCallback____wrapper_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$0 >> 2] = 25728; + if (HEAP8[$0 + 4 | 0] & 1) { + void_20emscripten__wrapper_b2RayCastCallback___call_void__28char_20const__29_20const($0, 3023); + } + emscripten__val___val_28_29($0 + 8 | 0); + b2RayCastCallback___b2RayCastCallback_28_29($0); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__wrapper_b2ContactListener____wrapper_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$0 >> 2] = 26012; + if (HEAP8[$0 + 4 | 0] & 1) { + void_20emscripten__wrapper_b2ContactListener___call_void__28char_20const__29_20const($0, 3023); + } + emscripten__val___val_28_29($0 + 8 | 0); + b2ContactListener___b2ContactListener_28_29($0); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function void_20_28b2WheelJoint____emscripten__internal__getContext_void_20_28b2WheelJoint____29_28bool_29__28void_20_28b2WheelJoint____20const__29_28bool_29_29_29_28bool_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2WeldJoint____emscripten__internal__getContext_void_20_28b2WeldJoint____29_28float_29__28void_20_28b2WeldJoint____20const__29_28float_29_29_29_28float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2RopeJoint____emscripten__internal__getContext_void_20_28b2RopeJoint____29_28float_29__28void_20_28b2RopeJoint____20const__29_28float_29_29_29_28float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2PrismaticJoint____emscripten__internal__getContext_void_20_28b2PrismaticJoint____29_28_29__28void_20_28b2PrismaticJoint____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2Fixture__29__28void_20_28b2Body____20const__29_28b2Fixture__29_29_29_28b2Fixture__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28b2BodyType_29__28void_20_28b2Body____20const__29_28b2BodyType_29_29_29_28b2BodyType_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______is_long_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAPU8[std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]) + 11 | 0]; + __stack_pointer = $1 + 16 | 0; + return $0 >>> 7 | 0; +} + +function emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_4__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_4__28embind_init_b2_28_29__$_4_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_4__operator_20void_20_28__29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec2_20_28b2AABB____emscripten__internal__getContext_b2Vec2_20_28b2AABB____29_28_29_20const__28b2Vec2_20_28b2AABB____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____data_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = char_20const__20std____2____to_address_5babi_v160004_5d_char_20const__28char_20const__29(std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______get_pointer_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2])); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function float_20emscripten__internal__MemberAccess_b2BodyDef_2c_20float___getWire_b2BodyDef__28float_20b2BodyDef____20const__2c_20b2BodyDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function bool_20emscripten__val__call_bool_2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = emscripten__internal__MethodCaller_bool_2c_20unsigned_20int____call_28emscripten___EM_VAL__2c_20char_20const__2c_20unsigned_20int__29(HEAP32[HEAP32[$3 + 12 >> 2] >> 2], HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; + return $0 & 1; +} + +function b2MotorJoint__SetCorrectionFactor_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (!(!(!(b2IsValid_28float_29(HEAPF32[$2 + 8 >> 2]) & 1) | !(HEAPF32[$2 + 8 >> 2] >= Math_fround(0))) & HEAPF32[$2 + 8 >> 2] <= Math_fround(1))) { + __assert_fail(8039, 4228, 257, 3741); + wasm2js_trap(); + } + HEAPF32[$0 + 100 >> 2] = HEAPF32[$2 + 8 >> 2]; + __stack_pointer = $2 + 16 | 0; +} + +function __cxxabiv1____class_type_info__process_found_base_class_28__cxxabiv1____dynamic_cast_info__2c_20void__2c_20int_29_20const($0, $1, $2, $3) { + $0 = HEAP32[$1 + 16 >> 2]; + if (!$0) { + HEAP32[$1 + 36 >> 2] = 1; + HEAP32[$1 + 24 >> 2] = $3; + HEAP32[$1 + 16 >> 2] = $2; + return; + } + label$2: { + if (($2 | 0) == ($0 | 0)) { + if (HEAP32[$1 + 24 >> 2] != 2) { + break label$2; + } + HEAP32[$1 + 24 >> 2] = $3; + return; + } + HEAP8[$1 + 54 | 0] = 1; + HEAP32[$1 + 24 >> 2] = 2; + HEAP32[$1 + 36 >> 2] = HEAP32[$1 + 36 >> 2] + 1; + } +} + +function void_20emscripten__val__call_void_2c_20b2Transform_20const___28char_20const__2c_20b2Transform_20const__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + emscripten__internal__MethodCaller_void_2c_20b2Transform_20const____call_28emscripten___EM_VAL__2c_20char_20const__2c_20b2Transform_20const__29(HEAP32[HEAP32[$3 + 12 >> 2] >> 2], HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Island__Add_28b2Body__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAP32[$0 + 28 >> 2] >= HEAP32[$0 + 40 >> 2]) { + __assert_fail(1216, 7552, 58, 10388); + wasm2js_trap(); + } + HEAP32[HEAP32[$2 + 8 >> 2] + 8 >> 2] = HEAP32[$0 + 28 >> 2]; + HEAP32[HEAP32[$0 + 8 >> 2] + (HEAP32[$0 + 28 >> 2] << 2) >> 2] = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 28 >> 2] = HEAP32[$0 + 28 >> 2] + 1; + __stack_pointer = $2 + 16 | 0; +} + +function void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2Joint__29__28void_20_28b2World____20const__29_28b2Joint__29_29_29_28b2Joint__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2RevoluteJoint____emscripten__internal__getContext_void_20_28b2RevoluteJoint____29_28_29__28void_20_28b2RevoluteJoint____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2DistanceJoint____emscripten__internal__getContext_void_20_28b2DistanceJoint____29_28_29__28void_20_28b2DistanceJoint____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2Body____emscripten__internal__getContext_float_20_28b2Body____29_28_29_20const__28float_20_28b2Body____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20_28b2AABB____emscripten__internal__getContext_float_20_28b2AABB____29_28_29_20const__28float_20_28b2AABB____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function bool_20_28b2World____emscripten__internal__getContext_bool_20_28b2World____29_28_29_20const__28bool_20_28b2World____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function bool_20_28b2Joint____emscripten__internal__getContext_bool_20_28b2Joint____29_28_29_20const__28bool_20_28b2Joint____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2RopeJointDef__b2RopeJointDef_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2JointDef__b2JointDef_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 20 | 0); + b2Vec2__b2Vec2_28_29($0 + 28 | 0); + HEAP32[$0 >> 2] = 10; + b2Vec2__Set_28float_2c_20float_29($0 + 20 | 0, Math_fround(-1), Math_fround(0)); + b2Vec2__Set_28float_2c_20float_29($0 + 28 | 0, Math_fround(1), Math_fround(0)); + HEAPF32[$0 + 36 >> 2] = 0; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2JointType_20emscripten__internal__MemberAccess_b2JointDef_2c_20b2JointType___getWire_b2JointDef__28b2JointType_20b2JointDef____20const__2c_20b2JointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__EnumBindingType_b2JointType___toWireType_28b2JointType_29(HEAP32[HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2WheelJointDef_2c_20b2Vec2___getWire_b2WheelJointDef__28b2Vec2_20b2WheelJointDef____20const__2c_20b2WheelJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2RayCastOutput_2c_20b2Vec2___getWire_b2RayCastOutput__28b2Vec2_20b2RayCastOutput____20const__2c_20b2RayCastOutput_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2MouseJointDef_2c_20b2Vec2___getWire_b2MouseJointDef__28b2Vec2_20b2MouseJointDef____20const__2c_20b2MouseJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2MotorJointDef_2c_20b2Vec2___getWire_b2MotorJointDef__28b2Vec2_20b2MotorJointDef____20const__2c_20b2MotorJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______get_long_pointer_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$0 >> 2]; +} + +function b2Shape__Type_20emscripten__internal__MemberAccess_b2Shape_2c_20b2Shape__Type___getWire_b2Shape__28b2Shape__Type_20b2Shape____20const__2c_20b2Shape_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__EnumBindingType_b2Shape__Type___toWireType_28b2Shape__Type_29(HEAP32[HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2Draw__29__28void_20_28b2World____20const__29_28b2Draw__29_29_29_28b2Draw__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28b2Body__29__28void_20_28b2World____20const__29_28b2Body__29_29_29_28b2Body__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Fixture____emscripten__internal__getContext_void_20_28b2Fixture____29_28float_29__28void_20_28b2Fixture____20const__29_28float_29_29_29_28float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2______ConstructTransaction___ConstructTransaction_5babi_v160004_5d_28b2Vec2___2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[HEAP32[$3 + 8 >> 2] >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[HEAP32[$3 + 8 >> 2] >> 2] + (HEAP32[$3 + 4 >> 2] << 3); + HEAP32[$0 + 8 >> 2] = HEAP32[$3 + 8 >> 2]; + return $0; +} + +function std____2____compressed_pair_std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______first_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2____tree_node_b2Fixture__2c_20void____2c_200_2c_20false_____get_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function int_20_28b2Shape____emscripten__internal__getContext_int_20_28b2Shape____29_28_29_20const__28int_20_28b2Shape____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Fixture____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__val_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function bool_20_28b2Body____emscripten__internal__getContext_bool_20_28b2Body____29_28_29_20const__28bool_20_28b2Body____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function bool_20_28b2AABB____emscripten__internal__getContext_bool_20_28b2AABB____29_28_29_20const__28bool_20_28b2AABB____20const__29_28_29_20const_29_29_28_29_20const($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Filter__20emscripten__internal__MemberAccess_b2FixtureDef_2c_20b2Filter___getWire_b2FixtureDef__28b2Filter_20b2FixtureDef____20const__2c_20b2FixtureDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Filter___toWireType_28b2Filter_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int____29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int___20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function emscripten__wrapper_b2QueryCallback____wrapper_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$0 >> 2] = 25476; + if (HEAP8[$0 + 4 | 0] & 1) { + void_20emscripten__wrapper_b2QueryCallback___call_void__28char_20const__29_20const($0, 3023); + } + emscripten__val___val_28_29($0 + 8 | 0); + b2QueryCallback___b2QueryCallback_28_29($0); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2____compressed_pair_std____2____tree_end_node_std____2____tree_node_base_void_____2c_20std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______first_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2____tree_end_node_std____2____tree_node_base_void_____2c_200_2c_20false_____get_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Joint____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2Joint_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2WeldJointDef_2c_20b2Vec2___getWire_b2WeldJointDef__28b2Vec2_20b2WeldJointDef____20const__2c_20b2WeldJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2RopeJointDef_2c_20b2Vec2___getWire_b2RopeJointDef__28b2Vec2_20b2RopeJointDef____20const__2c_20b2RopeJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2RayCastInput_2c_20b2Vec2___getWire_b2RayCastInput__28b2Vec2_20b2RayCastInput____20const__2c_20b2RayCastInput_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function void_20_28b2Fixture____emscripten__internal__getContext_void_20_28b2Fixture____29_28bool_29__28void_20_28b2Fixture____20const__29_28bool_29_29_29_28bool_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20emscripten__internal__MemberAccess_b2Shape_2c_20float___getWire_b2Shape__28float_20b2Shape____20const__2c_20b2Shape_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function float_20emscripten__internal__MemberAccess_b2Color_2c_20float___getWire_b2Color__28float_20b2Color____20const__2c_20b2Color_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function b2Shape__20_28b2Fixture____emscripten__internal__getContext_b2Shape__20_28b2Fixture____29_28_29__28b2Shape__20_28b2Fixture____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____deallocate_5babi_v160004_5d_28std____2____tree_node_b2Fixture__2c_20void____2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + std____2____libcpp_deallocate_5babi_v160004_5d_28void__2c_20unsigned_20long_2c_20unsigned_20long_29(HEAP32[$3 + 8 >> 2], Math_imul(HEAP32[$3 + 4 >> 2], 20), 4); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Draw____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2Draw_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Body____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2Body_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function bool_20emscripten__internal__MemberAccess_b2WheelJointDef_2c_20bool___getWire_b2WheelJointDef__28bool_20b2WheelJointDef____20const__2c_20b2WheelJointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(HEAP8[HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0] & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function void_20_28b2WheelJoint____emscripten__internal__getContext_void_20_28b2WheelJoint____29_28_29__28void_20_28b2WheelJoint____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2MouseJoint____emscripten__internal__getContext_void_20_28b2MouseJoint____29_28_29__28void_20_28b2MouseJoint____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2MotorJoint____emscripten__internal__getContext_void_20_28b2MotorJoint____29_28_29__28void_20_28b2MotorJoint____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Fixture____emscripten__internal__getContext_void_20_28b2Fixture____29_28int_29__28void_20_28b2Fixture____20const__29_28int_29_29_29_28int_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2CircleShape_2c_20b2Vec2___getWire_b2CircleShape__28b2Vec2_20b2CircleShape____20const__2c_20b2CircleShape_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Fixture__20_28b2Body____emscripten__internal__getContext_b2Fixture__20_28b2Body____29_28_29__28b2Fixture__20_28b2Body____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2ContactListenerWrapper__registerContactFixture_28unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 32 | 0; + __stack_pointer = $2; + HEAP32[$2 + 28 >> 2] = $0; + HEAP32[$2 + 24 >> 2] = $1; + $0 = HEAP32[$2 + 28 >> 2]; + HEAP32[$2 + 20 >> 2] = HEAP32[$2 + 24 >> 2]; + std____2__set_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____insert_5babi_v160004_5d_28b2Fixture__20const__29($2 + 12 | 0, $0 + 12 | 0, $2 + 20 | 0); + __stack_pointer = $2 + 32 | 0; +} + +function b2Body__20_28b2Fixture____emscripten__internal__getContext_b2Body__20_28b2Fixture____29_28_29__28b2Body__20_28b2Fixture____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2BodyType_20emscripten__internal__MemberAccess_b2BodyDef_2c_20b2BodyType___getWire_b2BodyDef__28b2BodyType_20b2BodyDef____20const__2c_20b2BodyDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__EnumBindingType_b2BodyType___toWireType_28b2BodyType_29(HEAP32[HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function float_20emscripten__internal__MemberAccess_b2Vec2_2c_20float___getWire_b2Vec2__28float_20b2Vec2____20const__2c_20b2Vec2_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function emscripten__wrapper_b2RayCastCallback___wrapper___28emscripten__val___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = 0; + b2RayCastCallback__b2RayCastCallback_28_29($0); + emscripten__internal__WrapperBase__WrapperBase_28_29($0 + 4 | 0); + HEAP32[$0 >> 2] = 25728; + emscripten__val__val_28emscripten__val___29($0 + 8 | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function emscripten__wrapper_b2ContactListener___wrapper___28emscripten__val___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = 0; + b2ContactListener__b2ContactListener_28_29($0); + emscripten__internal__WrapperBase__WrapperBase_28_29($0 + 4 | 0); + HEAP32[$0 >> 2] = 26012; + emscripten__val__val_28emscripten__val___29($0 + 8 | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28bool_29__28void_20_28b2World____20const__29_28bool_29_29_29_28bool_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2WeldJoint____emscripten__internal__getContext_void_20_28b2WeldJoint____29_28_29__28void_20_28b2WeldJoint____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2RopeJoint____emscripten__internal__getContext_void_20_28b2RopeJoint____29_28_29__28void_20_28b2RopeJoint____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28float_29__28void_20_28b2Body____20const__29_28float_29_29_29_28float_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2____split_buffer_int_2c_20std____2__allocator_int______ConstructTransaction___ConstructTransaction_5babi_v160004_5d_28int___2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[HEAP32[$3 + 8 >> 2] >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[HEAP32[$3 + 8 >> 2] >> 2] + (HEAP32[$3 + 4 >> 2] << 2); + HEAP32[$0 + 8 >> 2] = HEAP32[$3 + 8 >> 2]; + return $0; +} + +function bool_20emscripten__wrapper_b2QueryCallback___call_bool_2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = bool_20emscripten__val__call_bool_2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__29_20const(HEAP32[$3 + 12 >> 2] + 8 | 0, HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; + return $0 & 1; +} + +function void_20emscripten__constant_int__28char_20const__2c_20int_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + _embind_register_constant(HEAP32[$2 + 12 >> 2], emscripten__internal__TypeID_int_20const__2c_20void___get_28_29() | 0, +double_20emscripten__internal__asGenericValue_int__28int_29(emscripten__internal__BindingType_int_2c_20void___toWireType_28int_20const__29(HEAP32[$2 + 8 >> 2]))); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20unsigned_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20unsigned_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function float_20emscripten__internal__MemberAccess_b2Rot_2c_20float___getWire_b2Rot__28float_20b2Rot____20const__2c_20b2Rot_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $3 = emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return Math_fround($3); +} + +function b2BroadPhase__UnBufferMove_28int_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 4 >> 2] = 0; + while (1) { + if (HEAP32[$2 + 4 >> 2] < HEAP32[$0 + 40 >> 2]) { + if (HEAP32[HEAP32[$0 + 32 >> 2] + (HEAP32[$2 + 4 >> 2] << 2) >> 2] == HEAP32[$2 + 8 >> 2]) { + HEAP32[HEAP32[$0 + 32 >> 2] + (HEAP32[$2 + 4 >> 2] << 2) >> 2] = -1; + } + HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 4 >> 2] + 1; + continue; + } + break; + } +} + +function void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28bool_29__28void_20_28b2Body____20const__29_28bool_29_29_29_28bool_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__val_2c_20std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function decltype_28fp_29_20emscripten__select_overload_b2Fixture__20_28b2Shape_20const__2c_20float_29_2c_20b2Body__28b2Fixture__20_28b2Body____29_28b2Shape_20const__2c_20float_29_29($0, $1) { + var $2 = 0, $3 = 0; + $3 = HEAP32[$1 >> 2]; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 8 >> 2] = $3; + $1 = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = $1; + $1 = HEAP32[$0 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2]; + HEAP32[$0 >> 2] = $1; +} + +function b2World__20_28b2Body____emscripten__internal__getContext_b2World__20_28b2Body____29_28_29__28b2World__20_28b2Body____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Body__20_28b2Joint____emscripten__internal__getContext_b2Body__20_28b2Joint____29_28_29__28b2Body__20_28b2Joint____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2____compressed_pair_std____2____tree_end_node_std____2____tree_node_base_void_____2c_20std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______second_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void____2c_201_2c_20true_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__wrapper_b2QueryCallback___wrapper___28emscripten__val___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = 0; + b2QueryCallback__b2QueryCallback_28_29($0); + emscripten__internal__WrapperBase__WrapperBase_28_29($0 + 4 | 0); + HEAP32[$0 >> 2] = 25476; + emscripten__val__val_28emscripten__val___29($0 + 8 | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2QueryCallback__2c_20unsigned_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2QueryCallback__2c_20unsigned_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2Transform_2c_20b2Vec2___getWire_b2Transform__28b2Vec2_20b2Transform____20const__2c_20b2Transform_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function void_20_28b2Fixture____emscripten__internal__getContext_void_20_28b2Fixture____29_28_29__28void_20_28b2Fixture____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20emscripten__val__call_void_2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + emscripten__internal__MethodCaller_void_2c_20unsigned_20int____call_28emscripten___EM_VAL__2c_20char_20const__2c_20unsigned_20int__29(HEAP32[HEAP32[$3 + 12 >> 2] >> 2], HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function std____2____compressed_pair_std____2____tree_node_b2Fixture__2c_20void____2c_20std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_______first_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2____tree_node_b2Fixture__2c_20void____2c_200_2c_20false_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2FixtureDef__2c_20b2Shape_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2FixtureDef__2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function bool_20emscripten__internal__MemberAccess_b2FixtureDef_2c_20bool___getWire_b2FixtureDef__28bool_20b2FixtureDef____20const__2c_20b2FixtureDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(HEAP8[HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0] & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function void_20emscripten__wrapper_b2Draw___call_void_2c_20b2Transform_20const___28char_20const__2c_20b2Transform_20const__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + void_20emscripten__val__call_void_2c_20b2Transform_20const___28char_20const__2c_20b2Transform_20const__29_20const(HEAP32[$3 + 12 >> 2] + 12 | 0, HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______node_alloc_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_std____2____tree_end_node_std____2____tree_node_base_void_____2c_20std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______second_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 4 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____compressed_pair_std____2____tree_end_node_std____2____tree_node_base_void_____2c_20std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______first_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2____tree_end_node_std____2____tree_node_base_void_____2c_200_2c_20false_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2Fixture____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2MassData_2c_20b2Vec2___getWire_b2MassData__28b2Vec2_20b2MassData____20const__2c_20b2MassData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2Rot__20emscripten__internal__MemberAccess_b2Transform_2c_20b2Rot___getWire_b2Transform__28b2Rot_20b2Transform____20const__2c_20b2Transform_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Rot___toWireType_28b2Rot_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Transform_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Transform_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Fixture____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20_28b2World____emscripten__internal__getContext_void_20_28b2World____29_28_29__28void_20_28b2World____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28b2Joint____emscripten__internal__getContext_void_20_28b2Joint____29_28_29__28void_20_28b2Joint____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function short_20emscripten__internal__MemberAccess_b2Filter_2c_20short___getWire_b2Filter__28short_20b2Filter____20const__2c_20b2Filter_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__BindingType_short_2c_20void___toWireType_28short_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 << 16 >> 16; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2BodyDef_2c_20b2Vec2___getWire_b2BodyDef__28b2Vec2_20b2BodyDef____20const__2c_20b2BodyDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2ContactListenerWrapper__unregisterContactFixture_28unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 8 >> 2]; + std____2__set_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____erase_5babi_v160004_5d_28b2Fixture__20const__29($0 + 12 | 0, $2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function void_20_28__emscripten__internal__getContext_void_20_28__29_28b2FixtureDef__2c_20b2Shape_20const__29__28void_20_28__20const__29_28b2FixtureDef__2c_20b2Shape_20const__29_29_29_28b2FixtureDef__2c_20b2Shape_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2__allocator_traits_std____2__allocator_b2Vec2____deallocate_5babi_v160004_5d_28std____2__allocator_b2Vec2___2c_20b2Vec2__2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + std____2__allocator_b2Vec2___deallocate_5babi_v160004_5d_28b2Vec2__2c_20unsigned_20long_29(HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function void_20_28b2Body____emscripten__internal__getContext_void_20_28b2Body____29_28_29__28void_20_28b2Body____20const__29_28_29_29_29_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAP32[$2 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 4 >> 2]; + HEAP32[$0 >> 2] = $3; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2World__2c_20emscripten__internal__AllowedRawPointer_b2Body____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2Body_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Joint____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Joint_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function decltype_28fp_29_20emscripten__select_overload_b2Fixture__20_28b2FixtureDef_20const__29_2c_20b2Body__28b2Fixture__20_28b2Body____29_28b2FixtureDef_20const__29_29($0, $1) { + var $2 = 0, $3 = 0; + $3 = HEAP32[$1 >> 2]; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 8 >> 2] = $3; + $1 = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = $1; + $1 = HEAP32[$0 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2]; + HEAP32[$0 >> 2] = $1; +} + +function bool_20emscripten__internal__MemberAccess_b2JointDef_2c_20bool___getWire_b2JointDef__28bool_20b2JointDef____20const__2c_20b2JointDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(HEAP8[HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0] & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function b2Rot__b2Rot_28float_29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + wasm2js_i32$0 = $0, wasm2js_f32$0 = sinf(HEAPF32[$2 + 8 >> 2]), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $0, wasm2js_f32$0 = cosf(HEAPF32[$2 + 8 >> 2]), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function __cxxabiv1____base_class_type_info__has_unambiguous_public_base_28__cxxabiv1____dynamic_cast_info__2c_20void__2c_20int_29_20const($0, $1, $2, $3) { + var $4 = 0, $5 = 0; + $5 = HEAP32[$0 + 4 >> 2]; + $4 = 0; + label$1: { + if (!$2) { + break label$1; + } + $4 = $5 >> 8; + if (!($5 & 1)) { + break label$1; + } + $4 = update_offset_to_base_28char_20const__2c_20long_29(HEAP32[$2 >> 2], $4); + } + $0 = HEAP32[$0 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 28 >> 2]]($0, $1, $2 + $4 | 0, $5 & 2 ? $3 : 2); +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20unsigned_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20unsigned_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20unsigned_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20unsigned_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Island__Add_28b2Contact__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAP32[$0 + 36 >> 2] >= HEAP32[$0 + 44 >> 2]) { + __assert_fail(1276, 7552, 66, 10388); + wasm2js_trap(); + } + $3 = HEAP32[$2 + 8 >> 2]; + $4 = HEAP32[$0 + 12 >> 2]; + $1 = HEAP32[$0 + 36 >> 2]; + HEAP32[$0 + 36 >> 2] = $1 + 1; + HEAP32[($1 << 2) + $4 >> 2] = $3; + __stack_pointer = $2 + 16 | 0; +} + +function b2DistanceProxy__b2DistanceProxy_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + $3 = $0 + 16 | 0; + $2 = $0; + while (1) { + b2Vec2__b2Vec2_28_29($2); + $2 = $2 + 8 | 0; + if (($3 | 0) != ($2 | 0)) { + continue; + } + break; + } + HEAP32[$0 + 16 >> 2] = 0; + HEAP32[$0 + 20 >> 2] = 0; + HEAPF32[$0 + 24 >> 2] = 0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Manifold__b2Manifold_28_29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + $3 = $0 + 40 | 0; + $2 = $0; + while (1) { + b2ManifoldPoint__b2ManifoldPoint_28_29($2); + $2 = $2 + 20 | 0; + if (($3 | 0) != ($2 | 0)) { + continue; + } + break; + } + b2Vec2__b2Vec2_28_29($0 + 40 | 0); + b2Vec2__b2Vec2_28_29($0 + 48 | 0); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function void_20emscripten__wrapper_b2ContactListener___call_void_2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + void_20emscripten__val__call_void_2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__29_20const(HEAP32[$3 + 12 >> 2] + 8 | 0, HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function bool_20emscripten__internal__MemberAccess_b2BodyDef_2c_20bool___getWire_b2BodyDef__28bool_20b2BodyDef____20const__2c_20b2BodyDef_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29(HEAP8[HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0] & 1); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function b2Island__Add_28b2Joint__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAP32[$0 + 32 >> 2] >= HEAP32[$0 + 48 >> 2]) { + __assert_fail(1245, 7552, 72, 10388); + wasm2js_trap(); + } + $3 = HEAP32[$2 + 8 >> 2]; + $4 = HEAP32[$0 + 16 >> 2]; + $1 = HEAP32[$0 + 32 >> 2]; + HEAP32[$0 + 32 >> 2] = $1 + 1; + HEAP32[($1 << 2) + $4 >> 2] = $3; + __stack_pointer = $2 + 16 | 0; +} + +function void_20_28__emscripten__internal__getContext_void_20_28__29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29__28void_20_28__20const__29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29_29_29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_______get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2RayCastCallbackWrapper__2c_20emscripten__val_____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2RayCastCallbackWrapper__2c_20emscripten__val______get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2ContactListenerWrapper__2c_20emscripten__val_____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20emscripten__val______get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function decltype_28fp_29_20emscripten__select_overload_void_20_28float_2c_20float_29_2c_20b2PolygonShape__28void_20_28b2PolygonShape____29_28float_2c_20float_29_29($0, $1) { + var $2 = 0, $3 = 0; + $3 = HEAP32[$1 >> 2]; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = HEAP32[$1 + 4 >> 2]; + HEAP32[$2 + 8 >> 2] = $3; + $1 = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = $1; + $1 = HEAP32[$0 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2]; + HEAP32[$0 >> 2] = $1; +} + +function char__20std____2__copy_5babi_v160004_5d_char_20const__2c_20char___28char_20const__2c_20char_20const__2c_20char__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + std____2__pair_char_20const__2c_20char___20std____2____copy_5babi_v160004_5d_std____2___ClassicAlgPolicy_2c_20char_20const__2c_20char_20const__2c_20char___28char_20const__2c_20char_20const__2c_20char__29($3 + 8 | 0, $0, $1, $2); + __stack_pointer = $3 + 16 | 0; + $2 = HEAP32[$3 + 12 >> 2]; + return $2; +} + +function b2Min_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Vec2__b2Vec2_28float_2c_20float_29($0, float_20b2Min_float__28float_2c_20float_29(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2], HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]), float_20b2Min_float__28float_2c_20float_29(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2], HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function b2Max_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Vec2__b2Vec2_28float_2c_20float_29($0, float_20b2Max_float__28float_2c_20float_29(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2], HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]), float_20b2Max_float__28float_2c_20float_29(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2], HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function b2Fixture__SetFilterData_28b2Filter_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$2 + 8 >> 2]; + $3 = HEAPU16[$1 >> 1] | HEAPU16[$1 + 2 >> 1] << 16; + HEAP16[$0 + 32 >> 1] = $3; + HEAP16[$0 + 34 >> 1] = $3 >>> 16; + HEAP16[$0 + 36 >> 1] = HEAPU16[$1 + 4 >> 1]; + b2Fixture__Refilter_28_29($0); + __stack_pointer = $2 + 16 | 0; +} + +function void_20b2BroadPhase__RayCast_b2WorldRayCastWrapper__28b2WorldRayCastWrapper__2c_20b2RayCastInput_20const__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + void_20b2DynamicTree__RayCast_b2WorldRayCastWrapper__28b2WorldRayCastWrapper__2c_20b2RayCastInput_20const__29_20const(HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function void_20_28__emscripten__internal__getContext_void_20_28__29_28b2Body__2c_20b2MassData_20const__29__28void_20_28__20const__29_28b2Body__2c_20b2MassData_20const__29_29_29_28b2Body__2c_20b2MassData_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Color__b2Color_28float_2c_20float_2c_20float_2c_20float_29($0, $1, $2, $3, $4) { + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + HEAP32[$5 + 28 >> 2] = $0; + HEAPF32[$5 + 24 >> 2] = $1; + HEAPF32[$5 + 20 >> 2] = $2; + HEAPF32[$5 + 16 >> 2] = $3; + HEAPF32[$5 + 12 >> 2] = $4; + $0 = HEAP32[$5 + 28 >> 2]; + HEAPF32[$0 >> 2] = HEAPF32[$5 + 24 >> 2]; + HEAPF32[$0 + 4 >> 2] = HEAPF32[$5 + 20 >> 2]; + HEAPF32[$0 + 8 >> 2] = HEAPF32[$5 + 16 >> 2]; + HEAPF32[$0 + 12 >> 2] = HEAPF32[$5 + 12 >> 2]; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2QueryCallbackWrapper__2c_20emscripten__val_____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2QueryCallbackWrapper__2c_20emscripten__val______get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec2__20emscripten__internal__MemberAccess_b2AABB_2c_20b2Vec2___getWire_b2AABB__28b2Vec2_20b2AABB____20const__2c_20b2AABB_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29(HEAP32[$2 + 8 >> 2] + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] | 0); + __stack_pointer = $2 + 16 | 0; + return $0 | 0; +} + +function b2RevoluteJoint__SetMaxMotorTorque_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAPF32[$2 + 8 >> 2] != HEAPF32[$0 + 108 >> 2]) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAPF32[$0 + 108 >> 2] = HEAPF32[$2 + 8 >> 2]; + } + __stack_pointer = $2 + 16 | 0; +} + +function b2PrismaticJoint__SetMaxMotorForce_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAPF32[$2 + 8 >> 2] != HEAPF32[$0 + 132 >> 2]) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAPF32[$0 + 132 >> 2] = HEAPF32[$2 + 8 >> 2]; + } + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__wrapper_b2Draw____wrapper_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$0 >> 2] = 26432; + if (HEAP8[$0 + 8 | 0] & 1) { + void_20emscripten__wrapper_b2Draw___call_void__28char_20const__29_20const($0, 3023); + } + emscripten__val___val_28_29($0 + 12 | 0); + b2Draw___b2Draw_28_29($0); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape_20const__2c_20b2FixtureDef____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20emscripten__internal__AllowedRawPointer_b2FixtureDef_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______destruct_at_end_5babi_v160004_5d_28b2Vec2__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______destruct_at_end_5babi_v160004_5d_28b2Vec2__2c_20std____2__integral_constant_bool_2c_20false__29(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function std____2__allocator_traits_std____2__allocator_int____deallocate_5babi_v160004_5d_28std____2__allocator_int___2c_20int__2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + std____2__allocator_int___deallocate_5babi_v160004_5d_28int__2c_20unsigned_20long_29(HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2JointDef__2c_20b2Body____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2JointDef__2c_20emscripten__internal__AllowedRawPointer_b2Body_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20float_2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20float_2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2WheelJoint__SetMaxMotorTorque_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAPF32[$2 + 8 >> 2] != HEAPF32[$0 + 132 >> 2]) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAPF32[$0 + 132 >> 2] = HEAPF32[$2 + 8 >> 2]; + } + __stack_pointer = $2 + 16 | 0; +} + +function b2Rot__Set_28float_29($0, $1) { + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + wasm2js_i32$0 = $0, wasm2js_f32$0 = sinf(HEAPF32[$2 + 8 >> 2]), HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0; + wasm2js_i32$0 = $0, wasm2js_f32$0 = cosf(HEAPF32[$2 + 8 >> 2]), HEAPF32[wasm2js_i32$0 + 4 >> 2] = wasm2js_f32$0; + __stack_pointer = $2 + 16 | 0; +} + +function b2PrismaticJoint__SetMotorSpeed_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAPF32[$2 + 8 >> 2] != HEAPF32[$0 + 136 >> 2]) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAPF32[$0 + 136 >> 2] = HEAPF32[$2 + 8 >> 2]; + } + __stack_pointer = $2 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____vector_5babi_v160004_5d_28_29($0); + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function operator__28float_2c_20b2Vec3_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAPF32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Vec3__b2Vec3_28float_2c_20float_2c_20float_29($0, Math_fround(HEAPF32[$3 + 12 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]), Math_fround(HEAPF32[$3 + 12 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2]), Math_fround(HEAPF32[$3 + 12 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 8 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function b2RevoluteJoint__SetMotorSpeed_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAPF32[$2 + 8 >> 2] != HEAPF32[$0 + 112 >> 2]) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAPF32[$0 + 112 >> 2] = HEAPF32[$2 + 8 >> 2]; + } + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20float_2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20float_2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20bool___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20bool____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2AABB_20const__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2AABB_20const__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2MotorJoint__SetAngularOffset_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAPF32[$2 + 8 >> 2] != HEAPF32[$0 + 76 >> 2]) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAPF32[$0 + 76 >> 2] = HEAPF32[$2 + 8 >> 2]; + } + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_std____2__vector_int_2c_20std____2__allocator_int______getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int_______get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20float_2c_20int_2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20float_2c_20int_2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20float_2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20float_2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2WheelJoint__SetMotorSpeed_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAPF32[$2 + 8 >> 2] != HEAPF32[$0 + 136 >> 2]) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAPF32[$0 + 136 >> 2] = HEAPF32[$2 + 8 >> 2]; + } + __stack_pointer = $2 + 16 | 0; +} + +function std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void________tree_node_destructor_5babi_v160004_5d_28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20bool_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP8[$3 + 7 | 0] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$3 + 8 >> 2]; + HEAP8[$0 + 4 | 0] = HEAP8[$3 + 7 | 0] & 1; + return $0; +} + +function emscripten__internal__Invoker_void_2c_20unsigned_20int___invoke_28void_20_28__29_28unsigned_20int_29_2c_20unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + FUNCTION_TABLE[$0 | 0](emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29(HEAP32[$2 + 8 >> 2])); + __stack_pointer = $2 + 16 | 0; +} + +function b2MouseJointDef__b2MouseJointDef_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2JointDef__b2JointDef_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 20 | 0); + HEAP32[$0 >> 2] = 5; + b2Vec2__Set_28float_2c_20float_29($0 + 20 | 0, Math_fround(0), Math_fround(0)); + HEAPF32[$0 + 28 >> 2] = 0; + HEAPF32[$0 + 32 >> 2] = 5; + HEAPF32[$0 + 36 >> 2] = .699999988079071; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__allocator_char___allocate_5babi_v160004_5d_28unsigned_20long_29($0, $1) { + if (unsigned_20long_20std____2__allocator_traits_std____2__allocator_char____max_size_5babi_v160004_5d_std____2__allocator_char__2c_20void_2c_20void__28std____2__allocator_char__20const__29($0) >>> 0 < $1 >>> 0) { + std____throw_bad_array_new_length_5babi_v160004_5d_28_29(); + wasm2js_trap(); + } + return std____2____libcpp_allocate_5babi_v160004_5d_28unsigned_20long_2c_20unsigned_20long_29($1, 1); +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20b2AABB_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20b2AABB_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__enable_if_is_move_constructible_b2Vec2____value_20___20is_move_assignable_b2Vec2____value_2c_20void___type_20std____2__swap_5babi_v160004_5d_b2Vec2___28b2Vec2___2c_20b2Vec2___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + HEAP32[$2 + 4 >> 2] = HEAP32[HEAP32[$2 + 12 >> 2] >> 2]; + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] = HEAP32[HEAP32[$2 + 8 >> 2] >> 2]; + HEAP32[HEAP32[$2 + 8 >> 2] >> 2] = HEAP32[$2 + 4 >> 2]; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______set_long_size_5babi_v160004_5d_28unsigned_20long_29($0, $1) { + var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + wasm2js_i32$0 = std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29($0), + wasm2js_i32$1 = $1, HEAP32[wasm2js_i32$0 + 4 >> 2] = wasm2js_i32$1; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2AABB__2c_20b2AABB____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20emscripten__internal__AllowedRawPointer_b2AABB_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2PrismaticJoint__EnableMotor_28bool_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if ((HEAP8[$2 + 11 | 0] & 1) != (HEAP8[$0 + 141 | 0] & 1)) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAP8[$0 + 141 | 0] = HEAP8[$2 + 11 | 0] & 1; + } + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_5__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_5__28embind_init_b2_28_29__$_5_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_5__operator_20void_20_28__29_28b2FixtureDef__2c_20b2Shape_20const__29_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2RevoluteJoint__EnableMotor_28bool_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if ((HEAP8[$2 + 11 | 0] & 1) != (HEAP8[$0 + 104 | 0] & 1)) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAP8[$0 + 104 | 0] = HEAP8[$2 + 11 | 0] & 1; + } + __stack_pointer = $2 + 16 | 0; +} + +function _ZN17compiler_builtins3int3mul3Mul3mul17h070e9a1c69faec5bE($0, $1, $2, $3) { + var $4 = 0, $5 = 0; + $4 = $2 >>> 16 | 0; + $5 = $0 >>> 16 | 0; + $3 = (Math_imul($4, $5) + Math_imul($1, $2) | 0) + Math_imul($3, $0) | 0; + $2 = $2 & 65535; + $0 = $0 & 65535; + $1 = Math_imul($2, $0); + $2 = ($1 >>> 16 | 0) + Math_imul($2, $5) | 0; + $3 = $3 + ($2 >>> 16 | 0) | 0; + $2 = Math_imul($0, $4) + ($2 & 65535) | 0; + i64toi32_i32$HIGH_BITS = $3 + ($2 >>> 16 | 0) | 0; + return $1 & 65535 | $2 << 16; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Color__Set_28float_2c_20float_2c_20float_2c_20float_29($0, $1, $2, $3, $4) { + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + HEAP32[$5 + 28 >> 2] = $0; + HEAPF32[$5 + 24 >> 2] = $1; + HEAPF32[$5 + 20 >> 2] = $2; + HEAPF32[$5 + 16 >> 2] = $3; + HEAPF32[$5 + 12 >> 2] = $4; + $0 = HEAP32[$5 + 28 >> 2]; + HEAPF32[$0 >> 2] = HEAPF32[$5 + 24 >> 2]; + HEAPF32[$0 + 4 >> 2] = HEAPF32[$5 + 20 >> 2]; + HEAPF32[$0 + 8 >> 2] = HEAPF32[$5 + 16 >> 2]; + HEAPF32[$0 + 12 >> 2] = HEAPF32[$5 + 12 >> 2]; +} + +function sbrk($0) { + var $1 = 0, $2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = HEAP32[7465]; + $2 = $0 + 7 & -8; + $0 = $1 + $2 | 0; + label$1: { + if ($0 >>> 0 <= $1 >>> 0 ? $2 : 0) { + break label$1; + } + if (emscripten_get_heap_size() >>> 0 < $0 >>> 0) { + if (!(emscripten_resize_heap($0 | 0) | 0)) { + break label$1; + } + } + HEAP32[7465] = $0; + return $1; + } + wasm2js_i32$0 = __errno_location(), wasm2js_i32$1 = 48, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + return -1; +} + +function emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_1__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_1__28embind_init_b2_28_29__$_1_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_1__operator_20void_20_28__29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function embind_init_b2_28_29__$_1____invoke_28b2AABB__2c_20b2AABB__2c_20b2AABB__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + embind_init_b2_28_29__$_1__operator_28_29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29_20const($3 + 3 | 0, HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_7__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_7__28embind_init_b2_28_29__$_7_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_7__operator_20void_20_28__29_28b2Body__2c_20b2MassData_20const__29_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20b2Filter_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20b2Filter_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2WheelJoint__EnableMotor_28bool_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if ((HEAP8[$2 + 11 | 0] & 1) != (HEAP8[$0 + 141 | 0] & 1)) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 48 >> 2], 1); + b2Body__SetAwake_28bool_29(HEAP32[$0 + 52 >> 2], 1); + HEAP8[$0 + 141 | 0] = HEAP8[$2 + 11 | 0] & 1; + } + __stack_pointer = $2 + 16 | 0; +} + +function b2RayCastCallbackWrapper__20emscripten__internal__wrapped_new_b2RayCastCallbackWrapper__2c_20b2RayCastCallbackWrapper_2c_20emscripten__val__28emscripten__val___29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(12); + b2RayCastCallbackWrapper__b2RayCastCallbackWrapper___28emscripten__val___29($0, HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2ContactListenerWrapper__20emscripten__internal__wrapped_new_b2ContactListenerWrapper__2c_20b2ContactListenerWrapper_2c_20emscripten__val__28emscripten__val___29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(24); + b2ContactListenerWrapper__b2ContactListenerWrapper___28emscripten__val___29($0, HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long___operator__5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____get_np_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2DrawWrapper__2c_20emscripten__val_____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2DrawWrapper__2c_20emscripten__val______get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__GenericBindingType_b2Filter___toWireType_28b2Filter_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(6); + $2 = HEAP32[$1 + 12 >> 2]; + $3 = HEAPU16[$2 >> 1] | HEAPU16[$2 + 2 >> 1] << 16; + HEAP16[$0 >> 1] = $3; + HEAP16[$0 + 2 >> 1] = $3 >>> 16; + HEAP16[$0 + 4 >> 1] = HEAPU16[$2 + 4 >> 1]; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20_28__emscripten__internal__getContext_void_20_28__29_28b2RayCastCallbackWrapper__29__28void_20_28__20const__29_28b2RayCastCallbackWrapper__29_29_29_28b2RayCastCallbackWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20_28__emscripten__internal__getContext_void_20_28__29_28b2ContactListenerWrapper__29__28void_20_28__20const__29_28b2ContactListenerWrapper__29_29_29_28b2ContactListenerWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Shape_20const__20_28__emscripten__internal__getContext_b2Shape_20const__20_28__29_28b2FixtureDef__29__28b2Shape_20const__20_28__20const__29_28b2FixtureDef__29_29_29_28b2FixtureDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2MotorJoint__SetMaxTorque_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (!(b2IsValid_28float_29(HEAPF32[$2 + 8 >> 2]) & 1 & HEAPF32[$2 + 8 >> 2] >= Math_fround(0))) { + __assert_fail(8451, 4228, 246, 8765); + wasm2js_trap(); + } + HEAPF32[$0 + 96 >> 2] = HEAPF32[$2 + 8 >> 2]; + __stack_pointer = $2 + 16 | 0; +} + +function b2ContactListenerWrapper___b2ContactListenerWrapper_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 >> 2] = 25980; + std____2__set_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture______set_5babi_v160004_5d_28_29($0 + 12 | 0); + emscripten__wrapper_b2ContactListener____wrapper_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function __cxxabiv1____pbase_type_info__can_catch_28__cxxabiv1____shim_type_info_20const__2c_20void___29_20const($0, $1, $2) { + var $3 = 0; + $2 = 1; + label$1: { + if (!(HEAPU8[$0 + 8 | 0] & 24)) { + $2 = 0; + if (!$1) { + break label$1; + } + $3 = __dynamic_cast($1, 23924, 24020, 0); + if (!$3) { + break label$1; + } + $2 = (HEAPU8[$3 + 8 | 0] & 24) != 0; + } + $2 = is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, $1, $2); + } + return $2; +} + +function emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_10__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_10__28embind_init_b2_28_29__$_10_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_10__operator_20void_20_28__29_28b2JointDef__2c_20b2Body__29_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Transform_20const__2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Transform_20const__2c_20emscripten__internal__AllowedRawPointer_b2Body_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Filter_20const__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Filter_20const__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2MotorJoint__SetMaxForce_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (!(b2IsValid_28float_29(HEAPF32[$2 + 8 >> 2]) & 1 & HEAPF32[$2 + 8 >> 2] >= Math_fround(0))) { + __assert_fail(8487, 4228, 235, 9872); + wasm2js_trap(); + } + HEAPF32[$0 + 92 >> 2] = HEAPF32[$2 + 8 >> 2]; + __stack_pointer = $2 + 16 | 0; +} + +function void_20emscripten__internal__writeGenericWireType_b2Transform__28emscripten__internal__GenericWireType___2c_20b2Transform__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 8 >> 2]; + HEAP32[HEAP32[HEAP32[$2 + 12 >> 2] >> 2] >> 2] = HEAP32[$2 + 4 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$0 >> 2] + 8; + __stack_pointer = $2 + 16 | 0; +} + +function std____2____split_buffer_int_2c_20std____2__allocator_int_______destruct_at_end_5babi_v160004_5d_28int__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + std____2____split_buffer_int_2c_20std____2__allocator_int_______destruct_at_end_5babi_v160004_5d_28int__2c_20std____2__integral_constant_bool_2c_20false__29(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function void_20_28__emscripten__internal__getContext_void_20_28__29_28b2JointDef__2c_20b2Body__29__28void_20_28__20const__29_28b2JointDef__2c_20b2Body__29_29_29_28b2JointDef__2c_20b2Body__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2MotorJointDef__b2MotorJointDef_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2JointDef__b2JointDef_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 20 | 0); + HEAP32[$0 >> 2] = 11; + b2Vec2__SetZero_28_29($0 + 20 | 0); + HEAPF32[$0 + 28 >> 2] = 0; + HEAPF32[$0 + 32 >> 2] = 1; + HEAPF32[$0 + 36 >> 2] = 1; + HEAPF32[$0 + 40 >> 2] = .30000001192092896; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Body__GetLinearVelocityFromLocalPoint_28b2Vec2_20const__29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + $1 = HEAP32[$3 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($3, $1, HEAP32[$3 + 8 >> 2]); + b2Body__GetLinearVelocityFromWorldPoint_28b2Vec2_20const__29_20const($0, $1, $3); + __stack_pointer = $3 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int____29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + std____2__vector_int_2c_20std____2__allocator_int_____vector_5babi_v160004_5d_28_29($0); + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______set_long_pointer_5babi_v160004_5d_28char__29($0, $1) { + var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + wasm2js_i32$0 = std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29($0), + wasm2js_i32$1 = $1, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; +} + +function emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_6__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_6__28embind_init_b2_28_29__$_6_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_6__operator_20b2Shape_20const__20_28__29_28b2FixtureDef__29_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_8__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_8__28embind_init_b2_28_29__$_8_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_8__operator_20void_20_28__29_28b2JointDef__2c_20b2Body__29_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20b2JointDef____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2JointDef_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Fixture__GetAABB_28int_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (!(HEAP32[$2 + 8 >> 2] < HEAP32[$0 + 28 >> 2] & HEAP32[$2 + 8 >> 2] >= 0)) { + __assert_fail(1997, 7346, 346, 11073); + wasm2js_trap(); + } + __stack_pointer = $2 + 16 | 0; + return HEAP32[$0 + 24 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 28) | 0; +} + +function void_20_28__emscripten__internal__getContext_void_20_28__29_28b2QueryCallbackWrapper__29__28void_20_28__20const__29_28b2QueryCallbackWrapper__29_29_29_28b2QueryCallbackWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2DynamicTree__GetUserData_28int_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (!(HEAP32[$2 + 8 >> 2] < HEAP32[$0 + 12 >> 2] & HEAP32[$2 + 8 >> 2] >= 0)) { + __assert_fail(1341, 7408, 167, 10491); + wasm2js_trap(); + } + __stack_pointer = $2 + 16 | 0; + return HEAP32[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 16 >> 2]; +} + +function void_20b2BroadPhase__Query_b2WorldQueryWrapper__28b2WorldQueryWrapper__2c_20b2AABB_20const__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + void_20b2DynamicTree__Query_b2WorldQueryWrapper__28b2WorldQueryWrapper__2c_20b2AABB_20const__29_20const(HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function std____2__enable_if_is_move_constructible_int____value_20___20is_move_assignable_int____value_2c_20void___type_20std____2__swap_5babi_v160004_5d_int___28int___2c_20int___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + HEAP32[$2 + 4 >> 2] = HEAP32[HEAP32[$2 + 12 >> 2] >> 2]; + HEAP32[HEAP32[$2 + 12 >> 2] >> 2] = HEAP32[HEAP32[$2 + 8 >> 2] >> 2]; + HEAP32[HEAP32[$2 + 8 >> 2] >> 2] = HEAP32[$2 + 4 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20float_2c_20bool___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20float_2c_20bool____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2DynamicTree__WasMoved_28int_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (!(HEAP32[$2 + 8 >> 2] < HEAP32[$0 + 12 >> 2] & HEAP32[$2 + 8 >> 2] >= 0)) { + __assert_fail(1341, 7408, 173, 10174); + wasm2js_trap(); + } + __stack_pointer = $2 + 16 | 0; + return HEAP8[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 36 | 0] & 1; +} + +function b2Body__SetAngularVelocity_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (HEAP32[$0 >> 2]) { + if (Math_fround(HEAPF32[$2 + 8 >> 2] * HEAPF32[$2 + 8 >> 2]) > Math_fround(0)) { + b2Body__SetAwake_28bool_29($0, 1); + } + HEAPF32[$0 + 72 >> 2] = HEAPF32[$2 + 8 >> 2]; + } + __stack_pointer = $2 + 16 | 0; +} + +function std____2____compressed_pair_elem_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void____2c_201_2c_20true_____compressed_pair_elem_5babi_v160004_5d_28std____2____value_init_tag_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____allocator_5babi_v160004_5d_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2QueryCallbackWrapper__20emscripten__internal__wrapped_new_b2QueryCallbackWrapper__2c_20b2QueryCallbackWrapper_2c_20emscripten__val__28emscripten__val___29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(12); + b2QueryCallbackWrapper__b2QueryCallbackWrapper___28emscripten__val___29($0, HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2__operator___5babi_v160004_5d_28std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__2c_20std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__29_1($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAP32[HEAP32[$2 + 12 >> 2] >> 2] == HEAP32[HEAP32[$2 + 8 >> 2] >> 2]; +} + +function std____2____compressed_pair_elem_std____2____tree_end_node_std____2____tree_node_base_void_____2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_28std____2____value_init_tag_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + std____2____tree_end_node_std____2____tree_node_base_void________tree_end_node_5babi_v160004_5d_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__wrapper_b2Draw___wrapper___28emscripten__val___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + b2Draw__b2Draw_28_29($0); + emscripten__internal__WrapperBase__WrapperBase_28_29($0 + 8 | 0); + HEAP32[$0 >> 2] = 26432; + emscripten__val__val_28emscripten__val___29($0 + 12 | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_0__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_0__28embind_init_b2_28_29__$_0_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_0__operator_20void_20_28__29_28b2AABB__2c_20b2AABB__29_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2Body__2c_20b2MassData_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2MassData_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20bool___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20bool____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20unsigned_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20unsigned_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Shape__Type_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Shape__Type_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__writeGenericWireType_b2Color__28emscripten__internal__GenericWireType___2c_20b2Color__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 8 >> 2]; + HEAP32[HEAP32[HEAP32[$2 + 12 >> 2] >> 2] >> 2] = HEAP32[$2 + 4 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$0 >> 2] + 8; + __stack_pointer = $2 + 16 | 0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______root_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______end_node_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return HEAP32[$0 >> 2]; +} + +function emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_2__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_2__28embind_init_b2_28_29__$_2_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_2__operator_20void_20_28__29_28b2Shape__2c_20float_29_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Fixture__SetDensity_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (!(b2IsValid_28float_29(HEAPF32[$2 + 8 >> 2]) & 1 & HEAPF32[$2 + 8 >> 2] >= Math_fround(0))) { + __assert_fail(8210, 7346, 300, 1089); + wasm2js_trap(); + } + HEAPF32[$0 >> 2] = HEAPF32[$2 + 8 >> 2]; + __stack_pointer = $2 + 16 | 0; +} + +function std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long___operator__5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____get_np_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 + 16 | 0; +} + +function emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_11__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_11__28embind_init_b2_28_29__$_11_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_11__operator_20b2Body__20_28__29_28b2JointDef__29_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20bool___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20bool____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2Body_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2RevoluteJoint__GetReactionForce_28float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAPF32[$3 + 8 >> 2] = $2; + $1 = HEAP32[$3 + 12 >> 2]; + b2Vec2__b2Vec2_28float_2c_20float_29($3, HEAPF32[$1 + 84 >> 2], HEAPF32[$1 + 88 >> 2]); + operator__28float_2c_20b2Vec2_20const__29($0, HEAPF32[$3 + 8 >> 2], $3); + __stack_pointer = $3 + 16 | 0; +} + +function b2Dot_28b2Vec3_20const__2c_20b2Vec3_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(HEAPF32[HEAP32[$2 + 12 >> 2] + 8 >> 2] * HEAPF32[HEAP32[$2 + 8 >> 2] + 8 >> 2]) + Math_fround(Math_fround(HEAPF32[HEAP32[$2 + 12 >> 2] >> 2] * HEAPF32[HEAP32[$2 + 8 >> 2] >> 2]) + Math_fround(HEAPF32[HEAP32[$2 + 12 >> 2] + 4 >> 2] * HEAPF32[HEAP32[$2 + 8 >> 2] + 4 >> 2]))); +} + +function b2Body__SetSleepingAllowed_28bool_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + label$1: { + if (HEAP8[$2 + 11 | 0] & 1) { + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] | 4; + break label$1; + } + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] & -5; + b2Body__SetAwake_28bool_29($0, 1); + } + __stack_pointer = $2 + 16 | 0; +} + +function void_20emscripten__internal__writeGenericWireType_b2Vec2__28emscripten__internal__GenericWireType___2c_20b2Vec2__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 8 >> 2]; + HEAP32[HEAP32[HEAP32[$2 + 12 >> 2] >> 2] >> 2] = HEAP32[$2 + 4 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$0 >> 2] + 8; + __stack_pointer = $2 + 16 | 0; +} + +function __cxxabiv1____base_class_type_info__search_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_2c_20bool_29_20const($0, $1, $2, $3, $4, $5) { + var $6 = 0, $7 = 0; + $6 = HEAP32[$0 + 4 >> 2]; + $7 = $6 >> 8; + if ($6 & 1) { + $7 = update_offset_to_base_28char_20const__2c_20long_29(HEAP32[$3 >> 2], $7); + } + $0 = HEAP32[$0 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 20 >> 2]]($0, $1, $2, $3 + $7 | 0, $6 & 2 ? $4 : 2, $5); +} + +function std____2__set_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____set_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______tree_28std____2__less_b2Fixture___20const__29($0, $1 + 11 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2Joint__2c_20float_2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Joint__2c_20float_2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_unsigned_20int_2c_20emscripten__internal__AllowedRawPointer_b2Draw_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_unsigned_20int_2c_20emscripten__internal__AllowedRawPointer_b2Draw_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Shape__Type_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Shape__Type_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2WeldJoint__GetReactionForce_28float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAPF32[$3 + 8 >> 2] = $2; + $1 = HEAP32[$3 + 12 >> 2]; + b2Vec2__b2Vec2_28float_2c_20float_29($3, HEAPF32[$1 + 104 >> 2], HEAPF32[$1 + 108 >> 2]); + operator__28float_2c_20b2Vec2_20const__29($0, HEAPF32[$3 + 8 >> 2], $3); + __stack_pointer = $3 + 16 | 0; +} + +function b2CircleShape__operator__28b2CircleShape_20const__29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + b2Shape__operator__28b2Shape_20const__29($0, HEAP32[$2 + 8 >> 2]); + $1 = HEAP32[$2 + 8 >> 2]; + $3 = HEAP32[$1 + 16 >> 2]; + HEAP32[$0 + 12 >> 2] = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 + 16 >> 2] = $3; + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function void_20_28__emscripten__internal__getContext_void_20_28__29_28b2AABB__2c_20b2AABB__29__28void_20_28__20const__29_28b2AABB__2c_20b2AABB__29_29_29_28b2AABB__2c_20b2AABB__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______recommend_5babi_v160004_5d_28unsigned_20long_29($0) { + var $1 = 0; + $1 = 10; + if ($0 >>> 0 >= 11) { + $0 = unsigned_20long_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______align_it_5babi_v160004_5d_16ul__28unsigned_20long_29($0 + 1 | 0); + $1 = $0; + $0 = $0 - 1 | 0; + $1 = ($0 | 0) == 11 ? $1 : $0; + } + return $1; +} + +function emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_9__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_9__28embind_init_b2_28_29__$_9_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_9__operator_20b2Body__20_28__29_28b2JointDef__29_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__BindingType_b2Vec2___2c_20void___fromWireType_28b2Vec2__29($0, $1) { + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $3 = emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29(HEAP32[$2 + 12 >> 2]); + $1 = HEAP32[$3 >> 2]; + $4 = HEAP32[$3 + 4 >> 2]; + $3 = $1; + $1 = $0; + HEAP32[$1 >> 2] = $3; + HEAP32[$1 + 4 >> 2] = $4; + __stack_pointer = $2 + 16 | 0; +} + +function b2PulleyJoint__GetReactionForce_28float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAPF32[$3 + 8 >> 2] = $2; + $1 = HEAP32[$3 + 12 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($3, HEAPF32[$1 + 116 >> 2], $1 + 136 | 0); + operator__28float_2c_20b2Vec2_20const__29($0, HEAPF32[$3 + 8 >> 2], $3); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20bool___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20bool____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2BodyType___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2BodyType____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2JointType_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2JointType_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Contact__ResetRestitution_28_29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + wasm2js_i32$0 = $0, wasm2js_f32$0 = b2MixRestitution_28float_2c_20float_29(HEAPF32[HEAP32[$0 + 48 >> 2] + 20 >> 2], HEAPF32[HEAP32[$0 + 52 >> 2] + 20 >> 2]), + HEAPF32[wasm2js_i32$0 + 140 >> 2] = wasm2js_f32$0; + __stack_pointer = $1 + 16 | 0; +} + +function void_20_28__emscripten__internal__getContext_void_20_28__29_28b2Shape__2c_20float_29__28void_20_28__20const__29_28b2Shape__2c_20float_29_29_29_28b2Shape__2c_20float_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__enum__b2Shape__Type___value_28char_20const__2c_20b2Shape__Type_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + _embind_register_enum_value(emscripten__internal__TypeID_b2Shape__Type_2c_20void___get_28_29() | 0, HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; + return $0; +} + +function b2GearJoint__GetReactionForce_28float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAPF32[$3 + 8 >> 2] = $2; + $1 = HEAP32[$3 + 12 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($3, HEAPF32[$1 + 156 >> 2], $1 + 240 | 0); + operator__28float_2c_20b2Vec2_20const__29($0, HEAPF32[$3 + 8 >> 2], $3); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__remove_class_decltype_28_embind_init_b2_28_29__$_3__operator_28_29_29___type__20emscripten__optional_override_embind_init_b2_28_29__$_3__28embind_init_b2_28_29__$_3_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_3__operator_20float_20_28__29_28b2Shape__29_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2DynamicTree__ClearMoved_28int_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (!(HEAP32[$2 + 8 >> 2] < HEAP32[$0 + 12 >> 2] & HEAP32[$2 + 8 >> 2] >= 0)) { + __assert_fail(1341, 7408, 179, 10183); + wasm2js_trap(); + } + HEAP8[(HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0) + 36 | 0] = 0; + __stack_pointer = $2 + 16 | 0; +} + +function __cxxabiv1____class_type_info__has_unambiguous_public_base_28__cxxabiv1____dynamic_cast_info__2c_20void__2c_20int_29_20const($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + if (is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, HEAP32[$1 + 8 >> 2], 0)) { + __cxxabiv1____class_type_info__process_found_base_class_28__cxxabiv1____dynamic_cast_info__2c_20void__2c_20int_29_20const($1, $1, $2, $3); + } +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2BodyType_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2BodyType_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__operator___5babi_v160004_5d_28std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__2c_20std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAP32[HEAP32[$2 + 12 >> 2] >> 2] == HEAP32[HEAP32[$2 + 8 >> 2] >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20bool___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20bool____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Contact__ResetFriction_28_29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0); + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + wasm2js_i32$0 = $0, wasm2js_f32$0 = b2MixFriction_28float_2c_20float_29(HEAPF32[HEAP32[$0 + 48 >> 2] + 16 >> 2], HEAPF32[HEAP32[$0 + 52 >> 2] + 16 >> 2]), + HEAPF32[wasm2js_i32$0 + 136 >> 2] = wasm2js_f32$0; + __stack_pointer = $1 + 16 | 0; +} + +function std____2____compressed_pair_elem_std____2____tree_node_b2Fixture__2c_20void____2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std____2____tree_node_b2Fixture__2c_20void_____2c_20void__28std____2____tree_node_b2Fixture__2c_20void_____29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[HEAP32[$2 + 8 >> 2] >> 2]; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Vec2_2c_20b2Transform_20const__2c_20b2Vec2_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20b2Transform_20const__2c_20b2Vec2_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20bool___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20bool____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2World_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2World_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__enum__b2BodyType___value_28char_20const__2c_20b2BodyType_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + _embind_register_enum_value(emscripten__internal__TypeID_b2BodyType_2c_20void___get_28_29() | 0, HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; + return $0; +} + +function emscripten__class__b2RayCastCallback_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2RayCastCallback_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2RayCastCallbackWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2RayCastCallbackWrapper__29__operator_20void_20_28__29_28b2RayCastCallbackWrapper__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 476; +} + +function b2Sweep__Normalize_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAPF32[$1 + 8 >> 2] = 6.2831854820251465; + HEAPF32[$1 + 4 >> 2] = HEAPF32[$1 + 8 >> 2] * Math_fround(Math_floor(Math_fround(HEAPF32[$0 + 24 >> 2] / HEAPF32[$1 + 8 >> 2]))); + HEAPF32[$0 + 24 >> 2] = HEAPF32[$0 + 24 >> 2] - HEAPF32[$1 + 4 >> 2]; + HEAPF32[$0 + 28 >> 2] = HEAPF32[$0 + 28 >> 2] - HEAPF32[$1 + 4 >> 2]; +} + +function b2DynamicTree__GetFatAABB_28int_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (!(HEAP32[$2 + 8 >> 2] < HEAP32[$0 + 12 >> 2] & HEAP32[$2 + 8 >> 2] >= 0)) { + __assert_fail(1341, 7408, 185, 11081); + wasm2js_trap(); + } + __stack_pointer = $2 + 16 | 0; + return HEAP32[$0 + 4 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 40) | 0; +} + +function emscripten__class__b2ContactListener_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2ContactListener_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2ContactListenerWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2ContactListenerWrapper__29__operator_20void_20_28__29_28b2ContactListenerWrapper__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 484; +} +function b2WorldManifold__b2WorldManifold_28_29($0) { + var $1 = 0, $2 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + b2Vec2__b2Vec2_28_29($0); + $0 = $0 + 8 | 0; + $2 = $0 + 16 | 0; + while (1) { + b2Vec2__b2Vec2_28_29($0); + $0 = $0 + 8 | 0; + if (($2 | 0) != ($0 | 0)) { + continue; + } + break; + } + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2StackAllocator___b2StackAllocator_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + if (HEAP32[$0 + 102400 >> 2]) { + __assert_fail(12291, 5418, 36, 3781); + wasm2js_trap(); + } + if (HEAP32[$0 + 102796 >> 2]) { + __assert_fail(12322, 5418, 37, 3781); + wasm2js_trap(); + } + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20bool___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20bool____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2PolygonAndCircleContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0) | 0; + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 148); + __stack_pointer = $2 + 16 | 0; +} + +function std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_____capacity_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0, $2 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + $2 = HEAP32[std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______end_cap_5babi_v160004_5d_28_29_20const($0) >> 2]; + __stack_pointer = $1 + 16 | 0; + return $2 - HEAP32[$0 >> 2] >> 3; +} + +function emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $3 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $0 = HEAP32[$2 >> 2]; + $4 = HEAP32[$2 + 4 >> 2]; + $2 = $0; + $0 = $3; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $4; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2ChainAndPolygonContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0) | 0; + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 148); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2World_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2World_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2EdgeAndPolygonContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0) | 0; + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 148); + __stack_pointer = $2 + 16 | 0; +} + +function b2ChainAndCircleContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0) | 0; + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 148); + __stack_pointer = $2 + 16 | 0; +} + +function operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Vec2__b2Vec2_28float_2c_20float_29($0, Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2] + HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]), Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2] + HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__GenericBindingType_b2Rot___toWireType_28b2Rot_20const__29($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $3 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $0 = HEAP32[$2 >> 2]; + $4 = HEAP32[$2 + 4 >> 2]; + $2 = $0; + $0 = $3; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $4; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2EdgeAndCircleContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0) | 0; + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 148); + __stack_pointer = $2 + 16 | 0; +} + +function void_20_28__emscripten__internal__getContext_void_20_28__29_28b2DrawWrapper__29__28void_20_28__20const__29_28b2DrawWrapper__29_29_29_28b2DrawWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Body__GetInertia_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0), $3 = Math_fround(0); + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + $2 = HEAPF32[$0 + 124 >> 2]; + $3 = Math_fround(HEAPF32[$0 + 116 >> 2] * b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0 + 28 | 0, $0 + 28 | 0)); + __stack_pointer = $1 + 16 | 0; + return Math_fround(Math_fround($3 + $2)); +} + +function b2Body__20_28__emscripten__internal__getContext_b2Body__20_28__29_28b2JointDef__29__28b2Body__20_28__20const__29_28b2JointDef__29_29_29_28b2JointDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Vec2__b2Vec2_28float_2c_20float_29($0, Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] >> 2] - HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]), Math_fround(HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2] - HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function b2DistanceProxy__GetVertex_28int_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if (!(HEAP32[$2 + 8 >> 2] < HEAP32[$0 + 20 >> 2] & HEAP32[$2 + 8 >> 2] >= 0)) { + __assert_fail(1967, 7482, 131, 1744); + wasm2js_trap(); + } + __stack_pointer = $2 + 16 | 0; + return HEAP32[$0 + 16 >> 2] + (HEAP32[$2 + 8 >> 2] << 3) | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2Shape__2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape__2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______root_ptr_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______end_node_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__allocator_b2Vec2___deallocate_5babi_v160004_5d_28b2Vec2__2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + std____2____libcpp_deallocate_5babi_v160004_5d_28void__2c_20unsigned_20long_2c_20unsigned_20long_29(HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2] << 3, 4); + __stack_pointer = $3 + 16 | 0; +} + +function std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____tree_const_iterator_5babi_v160004_5d_28std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $1; + HEAP32[$2 + 8 >> 2] = $0; + $0 = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$2 + 12 >> 2]; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__GenericBindingType_b2Vec2___toWireType_28b2Vec2___29($0) { + var $1 = 0, $2 = 0, $3 = 0, $4 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $3 = operator_20new_28unsigned_20long_29(8); + $2 = HEAP32[$1 + 12 >> 2]; + $0 = HEAP32[$2 >> 2]; + $4 = HEAP32[$2 + 4 >> 2]; + $2 = $0; + $0 = $3; + HEAP32[$0 >> 2] = $2; + HEAP32[$0 + 4 >> 2] = $4; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__class__b2QueryCallback_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2QueryCallback_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2QueryCallbackWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2QueryCallbackWrapper__29__operator_20void_20_28__29_28b2QueryCallbackWrapper__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 471; +} + +function b2QueryCallbackWrapper__ReportFixture_28unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = bool_20emscripten__wrapper_b2QueryCallback___call_bool_2c_20unsigned_20int___28char_20const__2c_20unsigned_20int__29_20const(HEAP32[$2 + 12 >> 2], 9168, $2 + 8 | 0); + __stack_pointer = $2 + 16 | 0; + return $0 & 1; +} + +function b2PolygonContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0) | 0; + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 148); + __stack_pointer = $2 + 16 | 0; +} + +function std____2____libcpp_deallocate_5babi_v160004_5d_28void__2c_20unsigned_20long_2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + void_20std____2____do_deallocate_handle_size_5babi_v160004_5d___28void__2c_20unsigned_20long_29(HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec2_20b2PrismaticJointDef_____20emscripten__internal__getContext_b2Vec2_20b2PrismaticJointDef_____28b2Vec2_20b2PrismaticJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2CircleContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0) | 0; + b2BlockAllocator__Free_28void__2c_20int_29(HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], 148); + __stack_pointer = $2 + 16 | 0; +} + +function __cxxabiv1____base_class_type_info__search_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_2c_20bool_29_20const($0, $1, $2, $3, $4) { + var $5 = 0, $6 = 0; + $5 = HEAP32[$0 + 4 >> 2]; + $6 = $5 >> 8; + if ($5 & 1) { + $6 = update_offset_to_base_28char_20const__2c_20long_29(HEAP32[$2 >> 2], $6); + } + $0 = HEAP32[$0 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 24 >> 2]]($0, $1, $2 + $6 | 0, $5 & 2 ? $3 : 2, $4); +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____c_str_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____data_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function unsigned_20short_20b2Filter_____20emscripten__internal__getContext_unsigned_20short_20b2Filter_____28unsigned_20short_20b2Filter____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2____split_buffer_int_2c_20std____2__allocator_int_____capacity_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0, $2 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + $2 = HEAP32[std____2____split_buffer_int_2c_20std____2__allocator_int_______end_cap_5babi_v160004_5d_28_29_20const($0) >> 2]; + __stack_pointer = $1 + 16 | 0; + return $2 - HEAP32[$0 >> 2] >> 2; +} + +function float_20b2PrismaticJointDef_____20emscripten__internal__getContext_float_20b2PrismaticJointDef_____28float_20b2PrismaticJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20b2RevoluteJointDef_____20emscripten__internal__getContext_b2Vec2_20b2RevoluteJointDef_____28b2Vec2_20b2RevoluteJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20b2DistanceJointDef_____20emscripten__internal__getContext_b2Vec2_20b2DistanceJointDef_____28b2Vec2_20b2DistanceJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function std____2__allocator_int___deallocate_5babi_v160004_5d_28int__2c_20unsigned_20long_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + std____2____libcpp_deallocate_5babi_v160004_5d_28void__2c_20unsigned_20long_2c_20unsigned_20long_29(HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2] << 2, 4); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20std____2__allocator_traits_std____2__allocator_b2Vec2____destroy_5babi_v160004_5d_b2Vec2_2c_20void__28std____2__allocator_b2Vec2___2c_20b2Vec2__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + std____2__allocator_b2Vec2___destroy_5babi_v160004_5d_28b2Vec2__29(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function void_20std____2__allocator_b2Vec2___construct_5babi_v160004_5d_b2Vec2_2c_20b2Vec2_20const___28b2Vec2__2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + $1 = HEAP32[$3 + 4 >> 2]; + $0 = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$3 + 8 >> 2]; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $2; +} + +function float_20b2RevoluteJointDef_____20emscripten__internal__getContext_float_20b2RevoluteJointDef_____28float_20b2RevoluteJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20b2DistanceJointDef_____20emscripten__internal__getContext_float_20b2DistanceJointDef_____28float_20b2DistanceJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function embind_init_b2_28_29__$_1__operator_28_29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29_20const($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + HEAP32[$4 + 12 >> 2] = $0; + HEAP32[$4 + 8 >> 2] = $1; + HEAP32[$4 + 4 >> 2] = $2; + HEAP32[$4 >> 2] = $3; + b2AABB__Combine_28b2AABB_20const__2c_20b2AABB_20const__29(HEAP32[$4 + 8 >> 2], HEAP32[$4 + 4 >> 2], HEAP32[$4 >> 2]); + __stack_pointer = $4 + 16 | 0; +} + +function bool_20b2PrismaticJointDef_____20emscripten__internal__getContext_bool_20b2PrismaticJointDef_____28bool_20b2PrismaticJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Joint____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Joint_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____capacity_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0, $2 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + $2 = HEAP32[std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______end_cap_5babi_v160004_5d_28_29_20const($0) >> 2]; + __stack_pointer = $1 + 16 | 0; + return $2 - HEAP32[$0 >> 2] >> 3; +} + +function float_20b2Clamp_float__28float_2c_20float_2c_20float_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAPF32[$3 + 12 >> 2] = $0; + HEAPF32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $0 = float_20b2Max_float__28float_2c_20float_29(HEAPF32[$3 + 8 >> 2], float_20b2Min_float__28float_2c_20float_29(HEAPF32[$3 + 12 >> 2], HEAPF32[$3 + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; + return $0; +} + +function float_20_28__emscripten__internal__getContext_float_20_28__29_28b2Shape__29__28float_20_28__20const__29_28b2Shape__29_29_29_28b2Shape__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function bool_20b2RevoluteJointDef_____20emscripten__internal__getContext_bool_20b2RevoluteJointDef_____28bool_20b2RevoluteJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2World__2c_20b2Vec2_____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2World__2c_20b2Vec2______get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function unsigned_20long_20std____2__allocator_traits_std____2__allocator_b2Vec2____max_size_5babi_v160004_5d_std____2__allocator_b2Vec2__2c_20void__28std____2__allocator_b2Vec2__20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__allocator_b2Vec2___max_size_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____allocator_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2____non_trivial_if_true_2c_20std____2__allocator_std____2____tree_node_b2Fixture__2c_20void________non_trivial_if_5babi_v160004_5d_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec2_20b2WheelJointDef_____20emscripten__internal__getContext_b2Vec2_20b2WheelJointDef_____28b2Vec2_20b2WheelJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20b2RayCastOutput_____20emscripten__internal__getContext_b2Vec2_20b2RayCastOutput_____28b2Vec2_20b2RayCastOutput____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20b2MouseJointDef_____20emscripten__internal__getContext_b2Vec2_20b2MouseJointDef_____28b2Vec2_20b2MouseJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20b2MotorJointDef_____20emscripten__internal__getContext_b2Vec2_20b2MotorJointDef_____28b2Vec2_20b2MotorJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2PulleyJoint__ShiftOrigin_28b2Vec2_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + b2Vec2__operator___28b2Vec2_20const__29_1($0 + 68 | 0, HEAP32[$2 + 8 >> 2]); + b2Vec2__operator___28b2Vec2_20const__29_1($0 + 76 | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function b2JointType_20b2JointDef_____20emscripten__internal__getContext_b2JointType_20b2JointDef_____28b2JointType_20b2JointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2DrawWrapper__DrawTransform_28b2Transform_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + void_20emscripten__wrapper_b2Draw___call_void_2c_20b2Transform_20const___28char_20const__2c_20b2Transform_20const__29_20const(HEAP32[$2 + 12 >> 2], 6924, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____value_comp_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_unsigned_20long_2c_20std____2__less_b2Fixture_____second_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec3__operator___28b2Vec3_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAPF32[$0 >> 2] = HEAPF32[$0 >> 2] + HEAPF32[HEAP32[$2 + 8 >> 2] >> 2]; + HEAPF32[$0 + 4 >> 2] = HEAPF32[$0 + 4 >> 2] + HEAPF32[HEAP32[$2 + 8 >> 2] + 4 >> 2]; + HEAPF32[$0 + 8 >> 2] = HEAPF32[$0 + 8 >> 2] + HEAPF32[HEAP32[$2 + 8 >> 2] + 8 >> 2]; +} + +function b2GrowableStack_int_2c_20256___Pop_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if (HEAP32[$0 + 1028 >> 2] <= 0) { + __assert_fail(12166, 7204, 72, 6222); + wasm2js_trap(); + } + HEAP32[$0 + 1028 >> 2] = HEAP32[$0 + 1028 >> 2] - 1; + __stack_pointer = $1 + 16 | 0; + return HEAP32[HEAP32[$0 >> 2] + (HEAP32[$0 + 1028 >> 2] << 2) >> 2]; +} + +function b2Fixture__b2Fixture_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Filter__b2Filter_28_29($0 + 32 | 0); + HEAP32[$0 + 40 >> 2] = 0; + HEAP32[$0 + 8 >> 2] = 0; + HEAP32[$0 + 4 >> 2] = 0; + HEAP32[$0 + 24 >> 2] = 0; + HEAP32[$0 + 28 >> 2] = 0; + HEAP32[$0 + 12 >> 2] = 0; + HEAPF32[$0 >> 2] = 0; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2DistanceJoint__GetReactionForce_28float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAPF32[$3 + 8 >> 2] = $2; + $1 = HEAP32[$3 + 12 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($0, Math_fround(HEAPF32[$3 + 8 >> 2] * HEAPF32[$1 + 100 >> 2]), $1 + 116 | 0); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2PrismaticJointDef____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2PrismaticJointDef_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WireTypePack_b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const____operator_20void_20const__28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__array_emscripten__internal__GenericWireType_2c_204ul___data_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2DrawWrapper__20emscripten__internal__wrapped_new_b2DrawWrapper__2c_20b2DrawWrapper_2c_20emscripten__val__28emscripten__val___29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(16); + b2DrawWrapper__b2DrawWrapper___28emscripten__val___29($0, HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function float_20b2WheelJointDef_____20emscripten__internal__getContext_float_20b2WheelJointDef_____28float_20b2WheelJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20b2RayCastOutput_____20emscripten__internal__getContext_float_20b2RayCastOutput_____28float_20b2RayCastOutput____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20b2MouseJointDef_____20emscripten__internal__getContext_float_20b2MouseJointDef_____28float_20b2MouseJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20b2MotorJointDef_____20emscripten__internal__getContext_float_20b2MotorJointDef_____28float_20b2MotorJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WireTypePack_unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____operator_20void_20const__28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__array_emscripten__internal__GenericWireType_2c_204ul___data_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec2_20b2WeldJointDef_____20emscripten__internal__getContext_b2Vec2_20b2WeldJointDef_____28b2Vec2_20b2WeldJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20b2RopeJointDef_____20emscripten__internal__getContext_b2Vec2_20b2RopeJointDef_____28b2Vec2_20b2RopeJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20b2RayCastInput_____20emscripten__internal__getContext_b2Vec2_20b2RayCastInput_____28b2Vec2_20b2RayCastInput____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Shape__Type_20b2Shape_____20emscripten__internal__getContext_b2Shape__Type_20b2Shape_____28b2Shape__Type_20b2Shape____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2MotorJoint__GetAnchorB_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $3 = b2Body__GetPosition_28_29_20const(HEAP32[HEAP32[$2 + 12 >> 2] + 52 >> 2]); + $1 = HEAP32[$3 >> 2]; + $4 = HEAP32[$3 + 4 >> 2]; + $3 = $1; + $1 = $0; + HEAP32[$1 >> 2] = $3; + HEAP32[$1 + 4 >> 2] = $4; + __stack_pointer = $2 + 16 | 0; +} + +function b2MotorJoint__GetAnchorA_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0, $4 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $3 = b2Body__GetPosition_28_29_20const(HEAP32[HEAP32[$2 + 12 >> 2] + 48 >> 2]); + $1 = HEAP32[$3 >> 2]; + $4 = HEAP32[$3 + 4 >> 2]; + $3 = $1; + $1 = $0; + HEAP32[$1 >> 2] = $3; + HEAP32[$1 + 4 >> 2] = $4; + __stack_pointer = $2 + 16 | 0; +} + +function b2Filter_20b2FixtureDef_____20emscripten__internal__getContext_b2Filter_20b2FixtureDef_____28b2Filter_20b2FixtureDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2DistanceSquared_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $1) { + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + $3 = b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($2, $2); + __stack_pointer = $2 + 16 | 0; + return $3; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_float_2c_20b2Shape____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Shape_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2RevoluteJointDef____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2RevoluteJointDef_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2DistanceJointDef____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2DistanceJointDef_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__Invoker_b2PrismaticJointDef____invoke_28b2PrismaticJointDef__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2PrismaticJointDef__2c_20void___toWireType_28b2PrismaticJointDef__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2RayCastCallbackWrapper__28b2RayCastCallbackWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2RayCastCallbackWrapper__28b2RayCastCallbackWrapper_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2ContactListenerWrapper__28b2ContactListenerWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2ContactListenerWrapper__28b2ContactListenerWrapper_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2FixtureDef__b2FixtureDef_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Filter__b2Filter_28_29($0 + 22 | 0); + HEAP32[$0 >> 2] = 0; + HEAP32[$0 + 4 >> 2] = 0; + HEAPF32[$0 + 8 >> 2] = .20000000298023224; + HEAPF32[$0 + 12 >> 2] = 0; + HEAPF32[$0 + 16 >> 2] = 0; + HEAP8[$0 + 20 | 0] = 0; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______get_short_pointer_5babi_v160004_5d_28_29($0) { + return std____2__pointer_traits_char____pointer_to_5babi_v160004_5d_28char__29(std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29($0)); +} + +function pad($0, $1, $2, $3, $4) { + var $5 = 0; + $5 = __stack_pointer - 256 | 0; + __stack_pointer = $5; + if (!($4 & 73728 | ($2 | 0) <= ($3 | 0))) { + $3 = $2 - $3 | 0; + $2 = $3 >>> 0 < 256; + __memset($5, $1 & 255, $2 ? $3 : 256); + if (!$2) { + while (1) { + out($0, $5, 256); + $3 = $3 - 256 | 0; + if ($3 >>> 0 > 255) { + continue; + } + break; + } + } + out($0, $5, $3); + } + __stack_pointer = $5 + 256 | 0; +} + +function float_20b2WeldJointDef_____20emscripten__internal__getContext_float_20b2WeldJointDef_____28float_20b2WeldJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20b2RopeJointDef_____20emscripten__internal__getContext_float_20b2RopeJointDef_____28float_20b2RopeJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20b2RayCastInput_____20emscripten__internal__getContext_float_20b2RayCastInput_____28float_20b2RayCastInput____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function bool_20b2WheelJointDef_____20emscripten__internal__getContext_bool_20b2WheelJointDef_____28bool_20b2WheelJointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20b2CircleShape_____20emscripten__internal__getContext_b2Vec2_20b2CircleShape_____28b2Vec2_20b2CircleShape____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2RopeJoint__GetReactionForce_28float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAPF32[$3 + 8 >> 2] = $2; + $1 = HEAP32[$3 + 12 >> 2]; + operator__28float_2c_20b2Vec2_20const__29($0, Math_fround(HEAPF32[$3 + 8 >> 2] * HEAPF32[$1 + 92 >> 2]), $1 + 104 | 0); + __stack_pointer = $3 + 16 | 0; +} + +function b2BodyType_20b2BodyDef_____20emscripten__internal__getContext_b2BodyType_20b2BodyDef_____28b2BodyType_20b2BodyDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2AABB__GetPerimeter_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAPF32[$1 + 8 >> 2] = HEAPF32[$0 + 8 >> 2] - HEAPF32[$0 >> 2]; + HEAPF32[$1 + 4 >> 2] = HEAPF32[$0 + 12 >> 2] - HEAPF32[$0 + 4 >> 2]; + $2 = Math_fround(HEAPF32[$1 + 8 >> 2] + HEAPF32[$1 + 4 >> 2]); + return Math_fround(Math_fround($2 + $2)); +} + +function embind_init_b2_28_29__$_5____invoke_28b2FixtureDef__2c_20b2Shape_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + embind_init_b2_28_29__$_5__operator_28_29_28b2FixtureDef__2c_20b2Shape_20const__29_20const($2 + 7 | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function std____2__set_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture______set_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture________tree_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_____size_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_unsigned_20long_2c_20std____2__less_b2Fixture_____first_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__Invoker_b2RevoluteJointDef____invoke_28b2RevoluteJointDef__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2RevoluteJointDef__2c_20void___toWireType_28b2RevoluteJointDef__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__Invoker_b2DistanceJointDef____invoke_28b2DistanceJointDef__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2DistanceJointDef__2c_20void___toWireType_28b2DistanceJointDef__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int____capacity_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0, $2 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + $2 = HEAP32[std____2__vector_int_2c_20std____2__allocator_int______end_cap_5babi_v160004_5d_28_29_20const($0) >> 2]; + __stack_pointer = $1 + 16 | 0; + return $2 - HEAP32[$0 >> 2] >> 2; +} + +function b2Fixture__SetSensor_28bool_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + if ((HEAP8[$2 + 11 | 0] & 1) != (HEAP8[$0 + 38 | 0] & 1)) { + b2Body__SetAwake_28bool_29(HEAP32[$0 + 8 >> 2], 1); + HEAP8[$0 + 38 | 0] = HEAP8[$2 + 11 | 0] & 1; + } + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2WheelJointDef____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2WheelJointDef_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2MouseJointDef____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2MouseJointDef_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2MotorJointDef____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2MotorJointDef_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Cross_28float_2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAPF32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Vec2__b2Vec2_28float_2c_20float_29($0, Math_fround(Math_fround(-HEAPF32[$3 + 12 >> 2]) * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2]), Math_fround(HEAPF32[$3 + 12 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function b2Cross_28b2Vec2_20const__2c_20float_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAPF32[$3 + 8 >> 2] = $2; + b2Vec2__b2Vec2_28float_2c_20float_29($0, Math_fround(HEAPF32[$3 + 8 >> 2] * HEAPF32[HEAP32[$3 + 12 >> 2] + 4 >> 2]), Math_fround(Math_fround(-HEAPF32[$3 + 8 >> 2]) * HEAPF32[HEAP32[$3 + 12 >> 2] >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function unsigned_20long_20std____2__allocator_traits_std____2__allocator_int____max_size_5babi_v160004_5d_std____2__allocator_int__2c_20void__28std____2__allocator_int__20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__allocator_int___max_size_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20std____2__allocator_traits_std____2__allocator_int____destroy_5babi_v160004_5d_int_2c_20void__28std____2__allocator_int___2c_20int__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + std____2__allocator_int___destroy_5babi_v160004_5d_28int__29(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function getint($0) { + var $1 = 0, $2 = 0, $3 = 0; + if (!isdigit(HEAP8[HEAP32[$0 >> 2]])) { + return 0; + } + while (1) { + $3 = HEAP32[$0 >> 2]; + $1 = -1; + if ($2 >>> 0 <= 214748364) { + $1 = HEAP8[$3 | 0] - 48 | 0; + $2 = Math_imul($2, 10); + $1 = ($2 ^ 2147483647) < ($1 | 0) ? -1 : $1 + $2 | 0; + } + HEAP32[$0 >> 2] = $3 + 1; + $2 = $1; + if (isdigit(HEAP8[$3 + 1 | 0])) { + continue; + } + break; + } + return $1; +} + +function float_20b2FixtureDef_____20emscripten__internal__getContext_float_20b2FixtureDef_____28float_20b2FixtureDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2WeldJointDef____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2WeldJointDef_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2RopeJointDef____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2RopeJointDef_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2PolygonShape____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2PolygonShape_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec2_20b2Transform_____20emscripten__internal__getContext_b2Vec2_20b2Transform_____28b2Vec2_20b2Transform____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function void_20const__20emscripten__internal__getActualType_b2QueryCallbackWrapper__28b2QueryCallbackWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2QueryCallbackWrapper__28b2QueryCallbackWrapper_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function embind_init_b2_28_29__$_7____invoke_28b2Body__2c_20b2MassData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + embind_init_b2_28_29__$_7__operator_28_29_28b2Body__2c_20b2MassData_20const__29_20const($2 + 7 | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2CircleShape____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2CircleShape_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WireTypePack_b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____operator_20void_20const__28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__array_emscripten__internal__GenericWireType_2c_203ul___data_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__InitFunc__InitFunc_28void_20_28__29_28_29_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$2 + 8 >> 2]; + HEAP32[$0 + 4 >> 2] = 0; + FUNCTION_TABLE[HEAP32[$2 + 8 >> 2]](); + _embind_register_bindings($0); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function bool_20b2FixtureDef_____20emscripten__internal__getContext_bool_20b2FixtureDef_____28bool_20b2FixtureDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20b2MassData_____20emscripten__internal__getContext_b2Vec2_20b2MassData_____28b2Vec2_20b2MassData____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Rot_20b2Transform_____20emscripten__internal__getContext_b2Rot_20b2Transform_____28b2Rot_20b2Transform____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2FixtureDef____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2FixtureDef_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2RevoluteJoint__GetJointAngle_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$1 + 8 >> 2] = HEAP32[$0 + 48 >> 2]; + HEAP32[$1 + 4 >> 2] = HEAP32[$0 + 52 >> 2]; + return Math_fround(Math_fround(Math_fround(HEAPF32[HEAP32[$1 + 4 >> 2] + 56 >> 2] - HEAPF32[HEAP32[$1 + 8 >> 2] + 56 >> 2]) - HEAPF32[$0 + 120 >> 2])); +} + +function float_20b2MassData_____20emscripten__internal__getContext_float_20b2MassData_____28float_20b2MassData____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2Vec2_20b2BodyDef_____20emscripten__internal__getContext_b2Vec2_20b2BodyDef_____28b2Vec2_20b2BodyDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2RayCastCallbackWrapper__b2RayCastCallbackWrapper___28emscripten__val___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + emscripten__wrapper_b2RayCastCallback___wrapper___28emscripten__val___29($0, HEAP32[$2 + 8 >> 2]); + HEAP32[$0 >> 2] = 25708; + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function std____2____tree_node_base_void____20std____2____tree_min_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + while (1) { + if (HEAP32[HEAP32[$1 + 12 >> 2] >> 2]) { + HEAP32[$1 + 12 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + continue; + } + break; + } + return HEAP32[$1 + 12 >> 2]; +} + +function b2BroadPhase__DestroyProxy_28int_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + b2BroadPhase__UnBufferMove_28int_29($0, HEAP32[$2 + 8 >> 2]); + HEAP32[$0 + 28 >> 2] = HEAP32[$0 + 28 >> 2] - 1; + b2DynamicTree__DestroyProxy_28int_29($0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2JointDef____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2JointDef_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int__2c_20unsigned_20int____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int__2c_20unsigned_20int_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__Invoker_b2WheelJointDef____invoke_28b2WheelJointDef__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2WheelJointDef__2c_20void___toWireType_28b2WheelJointDef__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__Invoker_b2MouseJointDef____invoke_28b2MouseJointDef__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2MouseJointDef__2c_20void___toWireType_28b2MouseJointDef__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__Invoker_b2MotorJointDef____invoke_28b2MotorJointDef__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2MotorJointDef__2c_20void___toWireType_28b2MotorJointDef__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function float_20b2BodyDef_____20emscripten__internal__getContext_float_20b2BodyDef_____28float_20b2BodyDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function bool_20b2JointDef_____20emscripten__internal__getContext_bool_20b2JointDef_____28bool_20b2JointDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2DistanceInput__b2DistanceInput_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2DistanceProxy__b2DistanceProxy_28_29($0); + b2DistanceProxy__b2DistanceProxy_28_29($0 + 28 | 0); + b2Transform__b2Transform_28_29($0 + 56 | 0); + b2Transform__b2Transform_28_29($0 + 72 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function operator__28float_2c_20b2Vec2_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAPF32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Vec2__b2Vec2_28float_2c_20float_29($0, Math_fround(HEAPF32[$3 + 12 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] >> 2]), Math_fround(HEAPF32[$3 + 12 >> 2] * HEAPF32[HEAP32[$3 + 8 >> 2] + 4 >> 2])); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__value_object_b2RayCastOutput____value_object_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + _embind_finalize_value_object(emscripten__internal__TypeID_b2RayCastOutput_2c_20void___get_28_29() | 0); + emscripten__internal__noncopyable___noncopyable_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2BodyDef____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2BodyDef_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_____clear_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______destruct_at_end_5babi_v160004_5d_28b2Vec2__29($0, HEAP32[$0 + 4 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______end_cap_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2_____first_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2] + 12 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WireTypePack_b2Vec2_20const__2c_20float__2c_20b2Color_20const____operator_20void_20const__28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__array_emscripten__internal__GenericWireType_2c_203ul___data_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2OpenDump_28char_20const__29($0) { + var $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + if (HEAP32[7692]) { + __assert_fail(3589, 5287, 56, 6226); + wasm2js_trap(); + } + wasm2js_i32$0 = 30768, wasm2js_i32$1 = fopen(HEAP32[$1 + 12 >> 2], 1822), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + __stack_pointer = $1 + 16 | 0; +} + +function std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2____second_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2__allocator_b2Vec2__2c_201_2c_20true_____get_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function short_20b2Filter_____20emscripten__internal__getContext_short_20b2Filter_____28short_20b2Filter____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__value_object_b2RayCastInput____value_object_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + _embind_finalize_value_object(emscripten__internal__TypeID_b2RayCastInput_2c_20void___get_28_29() | 0); + emscripten__internal__noncopyable___noncopyable_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int_2c_20unsigned_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int_2c_20unsigned_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__Invoker_b2WeldJointDef____invoke_28b2WeldJointDef__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2WeldJointDef__2c_20void___toWireType_28b2WeldJointDef__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__Invoker_b2RopeJointDef____invoke_28b2RopeJointDef__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2RopeJointDef__2c_20void___toWireType_28b2RopeJointDef__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__Invoker_b2PolygonShape____invoke_28b2PolygonShape__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2PolygonShape__2c_20void___toWireType_28b2PolygonShape__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function bool_20b2BodyDef_____20emscripten__internal__getContext_bool_20b2BodyDef_____28bool_20b2BodyDef____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2QueryCallbackWrapper__b2QueryCallbackWrapper___28emscripten__val___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + emscripten__wrapper_b2QueryCallback___wrapper___28emscripten__val___29($0, HEAP32[$2 + 8 >> 2]); + HEAP32[$0 >> 2] = 25456; + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function void_20const__20emscripten__internal__getActualType_b2PrismaticJointDef__28b2PrismaticJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2PrismaticJointDef__28b2PrismaticJointDef_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__WireTypePack_unsigned_20int__2c_20int__2c_20b2Color_20const____operator_20void_20const__28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__array_emscripten__internal__GenericWireType_2c_203ul___data_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______annotate_contiguous_container_5babi_v160004_5d_28void_20const__2c_20void_20const__2c_20void_20const__2c_20void_20const__29_20const($0, $1, $2, $3, $4) { + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; +} + +function emscripten__internal__WithPolicies____ArgTypeList_unsigned_20int_2c_20unsigned_20int_2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_unsigned_20int_2c_20unsigned_20int_2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function float_20b2Shape_____20emscripten__internal__getContext_float_20b2Shape_____28float_20b2Shape____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function float_20b2Color_____20emscripten__internal__getContext_float_20b2Color_____28float_20b2Color____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function embind_init_b2_28_29__$_10____invoke_28b2JointDef__2c_20b2Body__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + embind_init_b2_28_29__$_10__operator_28_29_28b2JointDef__2c_20b2Body__29_20const($2 + 7 | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function b2Vec2_20b2AABB_____20emscripten__internal__getContext_b2Vec2_20b2AABB_____28b2Vec2_20b2AABB____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2AABB____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2AABB_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__Invoker_b2CircleShape____invoke_28b2CircleShape__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2CircleShape__2c_20void___toWireType_28b2CircleShape__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function embind_init_b2_28_29__$_2____invoke_28b2Shape__2c_20float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + embind_init_b2_28_29__$_2__operator_28_29_28b2Shape__2c_20float_29_20const($2 + 7 | 0, HEAP32[$2 + 12 >> 2], HEAPF32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function b2ContactManager__b2ContactManager_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2BroadPhase__b2BroadPhase_28_29($0); + HEAP32[$0 + 60 >> 2] = 0; + HEAP32[$0 + 64 >> 2] = 0; + HEAP32[$0 + 68 >> 2] = 29696; + HEAP32[$0 + 72 >> 2] = 29700; + HEAP32[$0 + 76 >> 2] = 0; + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20const__20emscripten__internal__getActualType_b2RevoluteJointDef__28b2RevoluteJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2RevoluteJointDef__28b2RevoluteJointDef_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2DistanceJointDef__28b2DistanceJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2DistanceJointDef__28b2DistanceJointDef_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2_____second_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2__allocator_b2Vec2___2c_201_2c_20false_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 4 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__BindingType_emscripten__val___2c_20void___fromWireType_28emscripten___EM_VAL__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + emscripten__internal__BindingType_emscripten__val_2c_20void___fromWireType_28emscripten___EM_VAL__29($0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function embind_init_b2_28_29__$_8____invoke_28b2JointDef__2c_20b2Body__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + embind_init_b2_28_29__$_8__operator_28_29_28b2JointDef__2c_20b2Body__29_20const($2 + 7 | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function float_20b2Vec2_____20emscripten__internal__getContext_float_20b2Vec2_____28float_20b2Vec2____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function emscripten__value_object_b2Transform____value_object_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + _embind_finalize_value_object(emscripten__internal__TypeID_b2Transform_2c_20void___get_28_29() | 0); + emscripten__internal__noncopyable___noncopyable_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____compressed_pair_elem_std____2__allocator_b2Vec2__2c_201_2c_20true_____compressed_pair_elem_5babi_v160004_5d_28std____2____default_init_tag_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + std____2__allocator_b2Vec2___allocator_5babi_v160004_5d_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__class__b2Draw_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2Draw_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2DrawWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2DrawWrapper__29__operator_20void_20_28__29_28b2DrawWrapper__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 495; +} + +function std____2__vector_int_2c_20std____2__allocator_int______annotate_contiguous_container_5babi_v160004_5d_28void_20const__2c_20void_20const__2c_20void_20const__2c_20void_20const__29_20const($0, $1, $2, $3, $4) { + var $5 = 0; + $5 = __stack_pointer - 32 | 0; + HEAP32[$5 + 28 >> 2] = $0; + HEAP32[$5 + 24 >> 2] = $1; + HEAP32[$5 + 20 >> 2] = $2; + HEAP32[$5 + 16 >> 2] = $3; + HEAP32[$5 + 12 >> 2] = $4; +} + +function emscripten__value_object_b2MassData____value_object_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + _embind_finalize_value_object(emscripten__internal__TypeID_b2MassData_2c_20void___get_28_29() | 0); + emscripten__internal__noncopyable___noncopyable_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__Invoker_b2FixtureDef____invoke_28b2FixtureDef__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2FixtureDef__2c_20void___toWireType_28b2FixtureDef__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2RayCastCallback__28b2RayCastCallback__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2RayCastCallback__28b2RayCastCallback_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2ContactListener__28b2ContactListener__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2ContactListener__28b2ContactListener_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2__pair_char_20const__2c_20char___20std____2____copy_trivial__operator_28_29_5babi_v160004_5d_char_20const_2c_20char_2c_200__28char_20const__2c_20char_20const__2c_20char__29_20const($0, $1, $2, $3, $4) { + std____2__pair_char_20const__2c_20char___20std____2____copy_trivial_impl_5babi_v160004_5d_char_20const_2c_20char__28char_20const__2c_20char_20const__2c_20char__29($0, $2, $3, $4); +} + +function std____2____compressed_pair_int__2c_20std____2__allocator_int____second_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2__allocator_int__2c_201_2c_20true_____get_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function float_20b2Rot_____20emscripten__internal__getContext_float_20b2Rot_____28float_20b2Rot____20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(4); + HEAP32[$0 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + HEAP32[$1 + 8 >> 2] = $0; + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 8 >> 2]; +} + +function b2ReferenceFace__b2ReferenceFace_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0 + 8 | 0); + b2Vec2__b2Vec2_28_29($0 + 16 | 0); + b2Vec2__b2Vec2_28_29($0 + 24 | 0); + b2Vec2__b2Vec2_28_29($0 + 32 | 0); + b2Vec2__b2Vec2_28_29($0 + 44 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Fixture__GetMassData_28b2MassData__29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$0 + 12 >> 2]; + FUNCTION_TABLE[HEAP32[HEAP32[$1 >> 2] + 28 >> 2]]($1, HEAP32[$2 + 8 >> 2], HEAPF32[$0 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function b2Distance_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $1) { + var $2 = 0, $3 = Math_fround(0); + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + $3 = b2Vec2__Length_28_29_20const($2); + __stack_pointer = $2 + 16 | 0; + return $3; +} + +function void_20std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____construct_5babi_v160004_5d_b2Fixture__2c_20b2Fixture__20const___28b2Fixture___2c_20b2Fixture__20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + HEAP32[HEAP32[$3 + 8 >> 2] >> 2] = HEAP32[HEAP32[$3 + 4 >> 2] >> 2]; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______end_cap_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2____first_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2] + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____tree_iterator_5babi_v160004_5d_28std____2____tree_end_node_std____2____tree_node_base_void______29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$2 + 8 >> 2]; + return $0; +} + +function std____2____compressed_pair_unsigned_20long_2c_20std____2__less_b2Fixture_____second_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2__less_b2Fixture___2c_201_2c_20true_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29($0) { + return std____2____compressed_pair_elem_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_200_2c_20false_____get_5babi_v160004_5d_28_29($0); +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______alloc_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2____second_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2] + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____split_buffer_int_2c_20std____2__allocator_int_______end_cap_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_int__2c_20std____2__allocator_int_____first_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2] + 12 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____compressed_pair_elem_std____2__allocator_char__2c_201_2c_20true_____compressed_pair_elem_5babi_v160004_5d_28std____2____default_init_tag_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + std____2__allocator_char___allocator_5babi_v160004_5d_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2CircleShape__b2CircleShape_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Shape__b2Shape_28_29($0); + HEAP32[$0 >> 2] = 17928; + b2Vec2__b2Vec2_28_29($0 + 12 | 0); + HEAP32[$0 + 4 >> 2] = 0; + HEAPF32[$0 + 8 >> 2] = 0; + b2Vec2__SetZero_28_29($0 + 12 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__value_object_b2Filter____value_object_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + _embind_finalize_value_object(emscripten__internal__TypeID_b2Filter_2c_20void___get_28_29() | 0); + emscripten__internal__noncopyable___noncopyable_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WireTypePack_unsigned_20int__2c_20unsigned_20int____operator_20void_20const__28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__array_emscripten__internal__GenericWireType_2c_202ul___data_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec3__b2Vec3_28float_2c_20float_2c_20float_29($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + HEAP32[$4 + 12 >> 2] = $0; + HEAPF32[$4 + 8 >> 2] = $1; + HEAPF32[$4 + 4 >> 2] = $2; + HEAPF32[$4 >> 2] = $3; + $0 = HEAP32[$4 + 12 >> 2]; + HEAPF32[$0 >> 2] = HEAPF32[$4 + 8 >> 2]; + HEAPF32[$0 + 4 >> 2] = HEAPF32[$4 + 4 >> 2]; + HEAPF32[$0 + 8 >> 2] = HEAPF32[$4 >> 2]; + return $0; +} + +function void_20const__20emscripten__internal__getActualType_b2PrismaticJoint__28b2PrismaticJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2PrismaticJoint__28b2PrismaticJoint_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function strcmp($0, $1) { + var $2 = 0, $3 = 0; + $2 = HEAPU8[$0 | 0]; + $3 = HEAPU8[$1 | 0]; + label$1: { + if (!$2 | ($2 | 0) != ($3 | 0)) { + break label$1; + } + while (1) { + $3 = HEAPU8[$1 + 1 | 0]; + $2 = HEAPU8[$0 + 1 | 0]; + if (!$2) { + break label$1; + } + $1 = $1 + 1 | 0; + $0 = $0 + 1 | 0; + if (($2 | 0) == ($3 | 0)) { + continue; + } + break; + } + } + return $2 - $3 | 0; +} + +function std____2____libcpp_allocate_5babi_v160004_5d_28unsigned_20long_2c_20unsigned_20long_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = void__20std____2____libcpp_operator_new_5babi_v160004_5d_unsigned_20long__28unsigned_20long_29(HEAP32[$2 + 12 >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function std____2____compressed_pair_elem_std____2__allocator_int__2c_201_2c_20true_____compressed_pair_elem_5babi_v160004_5d_28std____2____default_init_tag_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + std____2__allocator_int___allocator_5babi_v160004_5d_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function embind_init_b2_28_29__$_0____invoke_28b2AABB__2c_20b2AABB__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + embind_init_b2_28_29__$_0__operator_28_29_28b2AABB__2c_20b2AABB__29_20const($2 + 7 | 0, HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______clear_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______base_destruct_at_end_5babi_v160004_5d_28b2Vec2__29($0, HEAP32[$0 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function std____2__enable_if___is_cpp17_random_access_iterator_char_20const____value_2c_20char____type_20std____2__copy_n_5babi_v160004_5d_char_20const__2c_20unsigned_20long_2c_20char___28char_20const__2c_20unsigned_20long_2c_20char__29($0, $1, $2) { + return char__20std____2__copy_5babi_v160004_5d_char_20const__2c_20char___28char_20const__2c_20char_20const__2c_20char__29($0, $0 + $1 | 0, $2); +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______get_long_cap_5babi_v160004_5d_28_29_20const($0) { + return HEAP32[std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29_20const($0) + 8 >> 2] & 2147483647; +} + +function std____2____split_buffer_int_2c_20std____2__allocator_int_____clear_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2____split_buffer_int_2c_20std____2__allocator_int_______destruct_at_end_5babi_v160004_5d_28int__29($0, HEAP32[$0 + 4 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function std____2____compressed_pair_int__2c_20std____2__allocator_int_____second_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2__allocator_int___2c_201_2c_20false_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 4 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__value_object_b2Color____value_object_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + _embind_finalize_value_object(emscripten__internal__TypeID_b2Color_2c_20void___get_28_29() | 0); + emscripten__internal__noncopyable___noncopyable_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__enum__b2Shape__Type___enum__28char_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + _embind_register_enum(emscripten__internal__TypeID_b2Shape__Type_2c_20void___get_28_29() | 0, HEAP32[$2 + 8 >> 2], 4, 0); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function b2PolygonShape__operator__28b2PolygonShape_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + b2Shape__operator__28b2Shape_20const__29($0, HEAP32[$2 + 8 >> 2]); + __memcpy($0 + 12 | 0, HEAP32[$2 + 8 >> 2] + 12 | 0, 140); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function b2AABB__GetCenter_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29_1($2 + 4 | 0, $1, $1 + 8 | 0); + operator__28float_2c_20b2Vec2_20const__29($0, Math_fround(.5), $2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______end_cap_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2_____first_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 12 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____compressed_pair_elem_std____2__allocator_b2Vec2___2c_201_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std____2__allocator_b2Vec2___2c_20void__28std____2__allocator_b2Vec2___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$2 + 8 >> 2]; + return $0; +} + +function b2AABB__GetExtents_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + operator__28b2Vec2_20const__2c_20b2Vec2_20const__29($2 + 4 | 0, $1 + 8 | 0, $1); + operator__28float_2c_20b2Vec2_20const__29($0, Math_fround(.5), $2 + 4 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2_______alloc_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2_____second_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 12 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2____second_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2__allocator_b2Vec2__2c_201_2c_20true_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__value_object_b2Vec2____value_object_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + _embind_finalize_value_object(emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29() | 0); + emscripten__internal__noncopyable___noncopyable_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__Invoker_b2JointDef____invoke_28b2JointDef__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2JointDef__2c_20void___toWireType_28b2JointDef__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2WheelJointDef__28b2WheelJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2WheelJointDef__28b2WheelJointDef_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2RevoluteJoint__28b2RevoluteJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2RevoluteJoint__28b2RevoluteJoint_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2QueryCallback__28b2QueryCallback__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2QueryCallback__28b2QueryCallback_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2MouseJointDef__28b2MouseJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2MouseJointDef__28b2MouseJointDef_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2MotorJointDef__28b2MotorJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2MotorJointDef__28b2MotorJointDef_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2DistanceJoint__28b2DistanceJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2DistanceJoint__28b2DistanceJoint_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2__pair_std____2____unwrap_ref_decay_char_20const_____type_2c_20std____2____unwrap_ref_decay_char____type__20std____2__make_pair_5babi_v160004_5d_char_20const___2c_20char___28char_20const___2c_20char____29($0, $1, $2) { + std____2__pair_char_20const__2c_20char____pair_5babi_v160004_5d_char_20const___2c_20char__2c_20_28void__290__28char_20const___2c_20char____29($0, $1, $2); +} + +function emscripten__value_object_b2Rot____value_object_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + _embind_finalize_value_object(emscripten__internal__TypeID_b2Rot_2c_20void___get_28_29() | 0); + emscripten__internal__noncopyable___noncopyable_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int_2c_20float___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int_2c_20float____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2RayCastCallbackWrapper____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2RayCastCallbackWrapper_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2ContactListenerWrapper____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2ContactListenerWrapper_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__pair_std____2____unwrap_ref_decay_char_20const____type_2c_20std____2____unwrap_ref_decay_char____type__20std____2__make_pair_5babi_v160004_5d_char_20const__2c_20char___28char_20const____2c_20char____29($0, $1, $2) { + std____2__pair_char_20const__2c_20char____pair_5babi_v160004_5d_char_20const__2c_20char__2c_20_28void__290__28char_20const____2c_20char____29($0, $1, $2); +} + +function std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2_____first_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_b2Vec2__2c_200_2c_20false_____get_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2____first_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_b2Vec2__2c_200_2c_20false_____get_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int_2c_20bool___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int_2c_20bool____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_unsigned_20int_2c_20unsigned_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_unsigned_20int_2c_20unsigned_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20unsigned_20int_2c_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20unsigned_20int_2c_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__Invoker_b2BodyDef____invoke_28b2BodyDef__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2BodyDef__2c_20void___toWireType_28b2BodyDef__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function emscripten__enum__b2BodyType___enum__28char_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + _embind_register_enum(emscripten__internal__TypeID_b2BodyType_2c_20void___get_28_29() | 0, HEAP32[$2 + 8 >> 2], 4, 0); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__writeGenericWireType_unsigned_20int__28emscripten__internal__GenericWireType___2c_20unsigned_20int_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + HEAP32[HEAP32[HEAP32[$2 + 12 >> 2] >> 2] >> 2] = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$0 >> 2] + 8; +} + +function void_20const__20emscripten__internal__getActualType_b2WeldJointDef__28b2WeldJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2WeldJointDef__28b2WeldJointDef_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2RopeJointDef__28b2RopeJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2RopeJointDef__28b2RopeJointDef_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2PolygonShape__28b2PolygonShape__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2PolygonShape__28b2PolygonShape_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2____compressed_pair_unsigned_20long_2c_20std____2__less_b2Fixture_____first_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_unsigned_20long_2c_200_2c_20false_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec3__operator__28_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Vec3__b2Vec3_28_29($0); + b2Vec3__Set_28float_2c_20float_2c_20float_29($0, Math_fround(-HEAPF32[$1 >> 2]), Math_fround(-HEAPF32[$1 + 4 >> 2]), Math_fround(-HEAPF32[$1 + 8 >> 2])); + __stack_pointer = $2 + 16 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______end_cap_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_int__2c_20std____2__allocator_int____first_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2] + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2QueryCallbackWrapper____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2QueryCallbackWrapper_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function decltype_28std____2____unwrap_iter_impl_char_20const__2c_20true_____unwrap_28std__declval_char_20const___28_29_29_29_20std____2____unwrap_iter_5babi_v160004_5d_char_20const__2c_20std____2____unwrap_iter_impl_char_20const__2c_20true__2c_200__28char_20const__29($0) { + return std____2____unwrap_iter_impl_char_20const__2c_20true_____unwrap_5babi_v160004_5d_28char_20const__29($0); +} + +function std____2__vector_int_2c_20std____2__allocator_int______alloc_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_int__2c_20std____2__allocator_int____second_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2] + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2TOIInput__b2TOIInput_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2DistanceProxy__b2DistanceProxy_28_29($0); + b2DistanceProxy__b2DistanceProxy_28_29($0 + 28 | 0); + b2Sweep__b2Sweep_28_29($0 + 56 | 0); + b2Sweep__b2Sweep_28_29($0 + 92 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2GearJoint__GetReactionTorque_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAPF32[$2 + 4 >> 2] = HEAPF32[$0 + 156 >> 2] * HEAPF32[$0 + 256 >> 2]; + return Math_fround(Math_fround(HEAPF32[$2 + 8 >> 2] * HEAPF32[$2 + 4 >> 2])); +} + +function void_20emscripten__val__call_void__28char_20const__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + emscripten__internal__MethodCaller_void___call_28emscripten___EM_VAL__2c_20char_20const__29(HEAP32[HEAP32[$2 + 12 >> 2] >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function std____2____compressed_pair_elem_std____2__allocator_int___2c_201_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std____2__allocator_int___2c_20void__28std____2__allocator_int___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$2 + 8 >> 2]; + return $0; +} + +function TransformVector2_28b2Transform_20const__2c_20b2Vec2_20const__29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($0, HEAP32[$3 + 12 >> 2], HEAP32[$3 + 8 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2DrawWrapper__28b2DrawWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2DrawWrapper__28b2DrawWrapper_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2CircleShape__28b2CircleShape__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2CircleShape__28b2CircleShape_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2____less_unsigned_20long_2c_20unsigned_20long___operator_28_29_5babi_v160004_5d_28unsigned_20long_20const__2c_20unsigned_20long_20const__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + return HEAPU32[HEAP32[$3 + 8 >> 2] >> 2] < HEAPU32[HEAP32[$3 + 4 >> 2] >> 2]; +} + +function std____2____compressed_pair_int__2c_20std____2__allocator_int____second_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_std____2__allocator_int__2c_201_2c_20true_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____allocation_result_std____2__allocator_traits_std____2__allocator_char____pointer__20std____2____allocate_at_least_5babi_v160004_5d_std____2__allocator_char___28std____2__allocator_char___2c_20unsigned_20long_29($0, $1, $2) { + $1 = std____2__allocator_char___allocate_5babi_v160004_5d_28unsigned_20long_29($1, $2); + HEAP32[$0 + 4 >> 2] = $2; + HEAP32[$0 >> 2] = $1; +} + +function b2GrowableStack_int_2c_20256____b2GrowableStack_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 8 >> 2] = $0; + $0 = HEAP32[$1 + 8 >> 2]; + HEAP32[$1 + 12 >> 2] = $0; + if (HEAP32[$0 >> 2] != ($0 + 4 | 0)) { + b2Free_28void__29(HEAP32[$0 >> 2]); + HEAP32[$0 >> 2] = 0; + } + __stack_pointer = $1 + 16 | 0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______end_cap_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2____first_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2FrictionJoint__GetReactionForce_28float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAPF32[$3 + 8 >> 2] = $2; + operator__28float_2c_20b2Vec2_20const__29($0, HEAPF32[$3 + 8 >> 2], HEAP32[$3 + 12 >> 2] + 84 | 0); + __stack_pointer = $3 + 16 | 0; +} + +function __towrite($0) { + var $1 = 0; + $1 = HEAP32[$0 + 72 >> 2]; + HEAP32[$0 + 72 >> 2] = $1 | $1 - 1; + $1 = HEAP32[$0 >> 2]; + if ($1 & 8) { + HEAP32[$0 >> 2] = $1 | 32; + return -1; + } + HEAP32[$0 + 4 >> 2] = 0; + HEAP32[$0 + 8 >> 2] = 0; + $1 = HEAP32[$0 + 44 >> 2]; + HEAP32[$0 + 28 >> 2] = $1; + HEAP32[$0 + 20 >> 2] = $1; + HEAP32[$0 + 16 >> 2] = HEAP32[$0 + 48 >> 2] + $1; + return 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______alloc_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2____second_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____tree_iterator_5babi_v160004_5d_28std____2____tree_node_b2Fixture__2c_20void____29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$2 + 8 >> 2]; + return $0; +} + +function std____2____split_buffer_int_2c_20std____2__allocator_int_______end_cap_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_int__2c_20std____2__allocator_int_____first_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 12 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec3__Set_28float_2c_20float_2c_20float_29($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + HEAP32[$4 + 12 >> 2] = $0; + HEAPF32[$4 + 8 >> 2] = $1; + HEAPF32[$4 + 4 >> 2] = $2; + HEAPF32[$4 >> 2] = $3; + $0 = HEAP32[$4 + 12 >> 2]; + HEAPF32[$0 >> 2] = HEAPF32[$4 + 8 >> 2]; + HEAPF32[$0 + 4 >> 2] = HEAPF32[$4 + 4 >> 2]; + HEAPF32[$0 + 8 >> 2] = HEAPF32[$4 >> 2]; +} + +function b2DrawWrapper__b2DrawWrapper___28emscripten__val___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + emscripten__wrapper_b2Draw___wrapper___28emscripten__val___29($0, HEAP32[$2 + 8 >> 2]); + HEAP32[$0 >> 2] = 26388; + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function b2ContactSolver___b2ContactSolver_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2StackAllocator__Free_28void__29(HEAP32[$0 + 32 >> 2], HEAP32[$0 + 40 >> 2]); + b2StackAllocator__Free_28void__29(HEAP32[$0 + 32 >> 2], HEAP32[$0 + 36 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Body__GetLocalPoint_28b2Vec2_20const__29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2MulT_28b2Transform_20const__2c_20b2Vec2_20const__29($0, HEAP32[$3 + 12 >> 2] + 12 | 0, HEAP32[$3 + 8 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function std____2____split_buffer_int_2c_20std____2__allocator_int_______alloc_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_int__2c_20std____2__allocator_int_____second_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 12 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____compressed_pair_int__2c_20std____2__allocator_int_____first_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_int__2c_200_2c_20false_____get_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Transform_20const____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2Transform_20const_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WireTypePack_b2Transform_20const____operator_20void_20const__28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__array_emscripten__internal__GenericWireType_2c_201ul___data_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function embind_init_b2_28_29__$_7__operator_28_29_28b2Body__2c_20b2MassData_20const__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + b2Body__SetMassData_28b2MassData_20const__29(HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Mul_28b2Transform_20const__2c_20b2Vec2_20const__29($0, HEAP32[$3 + 12 >> 2] + 12 | 0, HEAP32[$3 + 8 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2WheelJoint__28b2WheelJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2WheelJoint__28b2WheelJoint_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2MouseJoint__28b2MouseJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2MouseJoint__28b2MouseJoint_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2MotorJoint__28b2MotorJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2MotorJoint__28b2MotorJoint_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2FixtureDef__28b2FixtureDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2FixtureDef__28b2FixtureDef_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______clear_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2__vector_int_2c_20std____2__allocator_int______base_destruct_at_end_5babi_v160004_5d_28int__29($0, HEAP32[$0 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function std____2____compressed_pair_int__2c_20std____2__allocator_int____first_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_int__2c_200_2c_20false_____get_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2MouseJoint__GetReactionForce_28float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAPF32[$3 + 8 >> 2] = $2; + operator__28float_2c_20b2Vec2_20const__29($0, HEAPF32[$3 + 8 >> 2], HEAP32[$3 + 12 >> 2] + 96 | 0); + __stack_pointer = $3 + 16 | 0; +} + +function b2MotorJoint__GetReactionForce_28float_29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = Math_fround($2); + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAPF32[$3 + 8 >> 2] = $2; + operator__28float_2c_20b2Vec2_20const__29($0, HEAPF32[$3 + 8 >> 2], HEAP32[$3 + 12 >> 2] + 80 | 0); + __stack_pointer = $3 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_unsigned_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_unsigned_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2RevoluteJoint__GetJointSpeed_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$1 + 8 >> 2] = HEAP32[$0 + 48 >> 2]; + HEAP32[$1 + 4 >> 2] = HEAP32[$0 + 52 >> 2]; + return Math_fround(Math_fround(HEAPF32[HEAP32[$1 + 4 >> 2] + 72 >> 2] - HEAPF32[HEAP32[$1 + 8 >> 2] + 72 >> 2])); +} + +function std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false_____rewrap_5babi_v160004_5d_28std____2__reverse_iterator_b2Vec2___2c_20std____2__reverse_iterator_b2Vec2___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 4 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = HEAP32[$2 + 4 >> 2]; + return HEAP32[$2 + 12 >> 2]; +} + +function b2SeparationFunction__b2SeparationFunction_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Sweep__b2Sweep_28_29($0 + 8 | 0); + b2Sweep__b2Sweep_28_29($0 + 44 | 0); + b2Vec2__b2Vec2_28_29($0 + 84 | 0); + b2Vec2__b2Vec2_28_29($0 + 92 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__Invoker_b2AABB____invoke_28b2AABB__20_28__29_28_29_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__BindingType_b2AABB__2c_20void___toWireType_28b2AABB__29(FUNCTION_TABLE[HEAP32[$1 + 12 >> 2]]() | 0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2Body__GetLocalVector_28b2Vec2_20const__29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2MulT_28b2Rot_20const__2c_20b2Vec2_20const__29($0, HEAP32[$3 + 12 >> 2] + 20 | 0, HEAP32[$3 + 8 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2WeldJoint__28b2WeldJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2WeldJoint__28b2WeldJoint_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2RopeJoint__28b2RopeJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2RopeJoint__28b2RopeJoint_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2EdgeShape__28b2EdgeShape__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2EdgeShape__28b2EdgeShape_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__WireTypePack_unsigned_20int____operator_20void_20const__28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__array_emscripten__internal__GenericWireType_2c_201ul___data_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WireTypePack_b2Vec2_20const____operator_20void_20const__28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__array_emscripten__internal__GenericWireType_2c_201ul___data_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec3__operator___28float_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAPF32[$0 >> 2] = HEAPF32[$0 >> 2] * HEAPF32[$2 + 8 >> 2]; + HEAPF32[$0 + 4 >> 2] = HEAPF32[$0 + 4 >> 2] * HEAPF32[$2 + 8 >> 2]; + HEAPF32[$0 + 8 >> 2] = HEAPF32[$0 + 8 >> 2] * HEAPF32[$2 + 8 >> 2]; +} + +function b2Body__GetWorldVector_28b2Vec2_20const__29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $1; + HEAP32[$3 + 8 >> 2] = $2; + b2Mul_28b2Rot_20const__2c_20b2Vec2_20const__29($0, HEAP32[$3 + 12 >> 2] + 20 | 0, HEAP32[$3 + 8 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2_____first_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_b2Vec2__2c_200_2c_20false_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__wrapper_b2RayCastCallback___call_void__28char_20const__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + void_20emscripten__val__call_void__28char_20const__29_20const(HEAP32[$2 + 12 >> 2] + 8 | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function void_20emscripten__wrapper_b2ContactListener___call_void__28char_20const__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + void_20emscripten__val__call_void__28char_20const__29_20const(HEAP32[$2 + 12 >> 2] + 8 | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function std____2____compressed_pair_b2Vec2__2c_20std____2__allocator_b2Vec2____first_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_b2Vec2__2c_200_2c_20false_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WireTypePack_int_20const____operator_20void_20const__28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__array_emscripten__internal__GenericWireType_2c_201ul___data_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2World__SetGravity_28b2Vec2_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$1 >> 2]; + $3 = HEAP32[$1 + 4 >> 2]; + $1 = $0; + $0 = HEAP32[$2 + 12 >> 2] + 102964 | 0; + HEAP32[$0 >> 2] = $1; + HEAP32[$0 + 4 >> 2] = $3; +} + +function void_20const__20emscripten__internal__getActualType_b2JointDef__28b2JointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2JointDef__28b2JointDef_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2Body__SetBullet_28bool_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + label$1: { + if (HEAP8[$2 + 11 | 0] & 1) { + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] | 8; + break label$1; + } + HEAP16[$0 + 4 >> 1] = HEAPU16[$0 + 4 >> 1] & -9; + } +} + +function void_20emscripten__wrapper_b2QueryCallback___call_void__28char_20const__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + void_20emscripten__val__call_void__28char_20const__29_20const(HEAP32[$2 + 12 >> 2] + 8 | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______end_cap_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_int__2c_20std____2__allocator_int____first_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20unsigned_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20unsigned_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20unsigned_20int____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20unsigned_20int_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20std____2____do_deallocate_handle_size_5babi_v160004_5d___28void__2c_20unsigned_20long_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + void_20std____2____libcpp_operator_delete_5babi_v160004_5d_void___28void__29(HEAP32[$2 + 12 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______alloc_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_int__2c_20std____2__allocator_int____second_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2] + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2World__20emscripten__internal__operator_new_b2World_2c_20b2Vec2__28b2Vec2___29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(103028); + b2World__b2World_28b2Vec2_20const__29($0, HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false_____rewrap_5babi_v160004_5d_28std____2__reverse_iterator_int___2c_20std____2__reverse_iterator_int___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 8 >> 2] = $0; + HEAP32[$2 + 4 >> 2] = $1; + HEAP32[$2 + 12 >> 2] = HEAP32[$2 + 4 >> 2]; + return HEAP32[$2 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2DrawWrapper____getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2DrawWrapper_____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20unsigned_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20unsigned_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20const__20emscripten__internal__getActualType_b2Fixture__28b2Fixture__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2Fixture__28b2Fixture_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2BodyDef__28b2BodyDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2BodyDef__28b2BodyDef_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2Cross_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(HEAPF32[HEAP32[$2 + 12 >> 2] >> 2] * HEAPF32[HEAP32[$2 + 8 >> 2] + 4 >> 2]) - Math_fround(HEAPF32[HEAP32[$2 + 12 >> 2] + 4 >> 2] * HEAPF32[HEAP32[$2 + 8 >> 2] >> 2])); +} + +function ContactGetWorldManifold_28unsigned_20int_2c_20unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + b2Contact__GetWorldManifold_28b2WorldManifold__29_20const(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_int_2c_20unsigned_20int___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_int_2c_20unsigned_20int____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20std____2__allocator_traits_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void______destroy_5babi_v160004_5d_b2Fixture__2c_20void_2c_20void__28std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_20b2Fixture___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; +} + +function void_20emscripten__internal__writeGenericWireType_int__28emscripten__internal__GenericWireType___2c_20int_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + HEAP32[HEAP32[HEAP32[$2 + 12 >> 2] >> 2] >> 2] = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$0 >> 2] + 8; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______get_long_pointer_5babi_v160004_5d_28_29($0) { + return HEAP32[std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____first_5babi_v160004_5d_28_29($0) >> 2]; +} + +function b2Dot_28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(HEAPF32[HEAP32[$2 + 12 >> 2] >> 2] * HEAPF32[HEAP32[$2 + 8 >> 2] >> 2]) + Math_fround(HEAPF32[HEAP32[$2 + 12 >> 2] + 4 >> 2] * HEAPF32[HEAP32[$2 + 8 >> 2] + 4 >> 2])); +} + +function std____2____compressed_pair_int__2c_20std____2__allocator_int_____first_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_int__2c_200_2c_20false_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function WorldManifoldNew_28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(32); + HEAP32[$0 >> 2] = 0; + HEAP32[$0 + 4 >> 2] = 0; + HEAP32[$0 + 24 >> 2] = 0; + HEAP32[$0 + 28 >> 2] = 0; + HEAP32[$0 + 16 >> 2] = 0; + HEAP32[$0 + 20 >> 2] = 0; + HEAP32[$0 + 8 >> 2] = 0; + HEAP32[$0 + 12 >> 2] = 0; + b2WorldManifold__b2WorldManifold_28_29($0); + return $0 | 0; +} + +function std____2____compressed_pair_int__2c_20std____2__allocator_int____first_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2____compressed_pair_elem_int__2c_200_2c_20false_____get_5babi_v160004_5d_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__wrapper_b2Draw___call_void__28char_20const__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + void_20emscripten__val__call_void__28char_20const__29_20const(HEAP32[$2 + 12 >> 2] + 12 | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = b2Vec2__20std____2____to_address_5babi_v160004_5d_b2Vec2__28b2Vec2__29(HEAP32[HEAP32[$1 + 12 >> 2] >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Simplex__b2Simplex_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2SimplexVertex__b2SimplexVertex_28_29($0); + b2SimplexVertex__b2SimplexVertex_28_29($0 + 36 | 0); + b2SimplexVertex__b2SimplexVertex_28_29($0 + 72 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__char_traits_char___copy_28char__2c_20char_20const__2c_20unsigned_20long_29($0, $1, $2) { + std____2__enable_if___is_cpp17_random_access_iterator_char_20const____value_2c_20char____type_20std____2__copy_n_5babi_v160004_5d_char_20const__2c_20unsigned_20long_2c_20char___28char_20const__2c_20unsigned_20long_2c_20char__29($1, $2, $0); + return $0; +} + +function emscripten__internal__WireTypePack____operator_20void_20const__28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = std____2__array_emscripten__internal__GenericWireType_2c_200ul___data_5babi_v160004_5d_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function embind_init_b2_28_29__$_0__operator_28_29_28b2AABB__2c_20b2AABB__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + __stack_pointer = $3; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + b2AABB__Combine_28b2AABB_20const__29(HEAP32[$3 + 8 >> 2], HEAP32[$3 + 4 >> 2]); + __stack_pointer = $3 + 16 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2World__28b2World__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2World__28b2World_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2Shape__28b2Shape__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2Shape__28b2Shape_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2Joint__28b2Joint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2Joint__28b2Joint_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______alloc_5babi_v160004_5d_28_29_20const($0) { + return std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____second_5babi_v160004_5d_28_29_20const($0); +} + +function emscripten__internal__writeGenericWireType_28emscripten__internal__GenericWireType___2c_20float_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[HEAP32[$2 + 12 >> 2] >> 2] >> 2] = HEAPF32[$2 + 8 >> 2]; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$0 >> 2] + 8; +} + +function emscripten__internal__BindingType_emscripten__val_2c_20void___fromWireType_28emscripten___EM_VAL__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + emscripten__val__take_ownership_28emscripten___EM_VAL__29($0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function operator___28b2Vec2_20const__2c_20b2Vec2_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = 1; + $0 = HEAPF32[HEAP32[$2 + 12 >> 2] >> 2] == HEAPF32[HEAP32[$2 + 8 >> 2] >> 2] ? HEAPF32[HEAP32[$2 + 12 >> 2] + 4 >> 2] != HEAPF32[HEAP32[$2 + 8 >> 2] + 4 >> 2] : $0; + return $0; +} + +function embind_init_b2_28_29__$_3____invoke_28b2Shape__29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $2 = embind_init_b2_28_29__$_3__operator_28_29_28b2Shape__29_20const($1 + 11 | 0, HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return Math_fround($2); +} + +function b2Abs_28b2Vec2_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + b2Vec2__b2Vec2_28float_2c_20float_29($0, float_20b2Abs_float__28float_29(HEAPF32[HEAP32[$2 + 12 >> 2] >> 2]), float_20b2Abs_float__28float_29(HEAPF32[HEAP32[$2 + 12 >> 2] + 4 >> 2])); + __stack_pointer = $2 + 16 | 0; +} + +function std____2__allocator_b2Vec2___allocator_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2____non_trivial_if_true_2c_20std____2__allocator_b2Vec2______non_trivial_if_5babi_v160004_5d_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20const__20emscripten__internal__getActualType_b2Draw__28b2Draw__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2Draw__28b2Draw_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2Body__28b2Body__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2Body__28b2Body_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getActualType_b2AABB__28b2AABB__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = void_20const__20emscripten__internal__getLightTypeID_b2AABB__28b2AABB_20const__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______destroy_vector____destroy_vector_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$2 + 8 >> 2]; + return $0; +} + +function pop_arg_long_double($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0; + $2 = HEAP32[$1 >> 2] + 7 & -8; + HEAP32[$1 >> 2] = $2 + 16; + wasm2js_i32$0 = $0, wasm2js_f64$0 = __trunctfdf2(HEAP32[$2 >> 2], HEAP32[$2 + 4 >> 2], HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2]), + HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0; +} + +function b2RevoluteJoint__GetReactionTorque_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + return Math_fround(Math_fround(HEAPF32[$2 + 8 >> 2] * Math_fround(HEAPF32[$0 + 96 >> 2] + HEAPF32[$0 + 100 >> 2]))); +} + +function void_20emscripten__internal__raw_destructor_b2RayCastCallbackWrapper__28b2RayCastCallbackWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2ContactListenerWrapper__28b2ContactListenerWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function void_20b2Swap_float__28float__2c_20float__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + HEAPF32[$2 + 4 >> 2] = HEAPF32[HEAP32[$2 + 12 >> 2] >> 2]; + HEAPF32[HEAP32[$2 + 12 >> 2] >> 2] = HEAPF32[HEAP32[$2 + 8 >> 2] >> 2]; + HEAPF32[HEAP32[$2 + 8 >> 2] >> 2] = HEAPF32[$2 + 4 >> 2]; +} + +function std____2____compressed_pair_elem_std____2__less_b2Fixture___2c_201_2c_20true_____compressed_pair_elem_5babi_v160004_5d_std____2__less_b2Fixture___20const__2c_20void__28std____2__less_b2Fixture___20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAP32[$2 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__pure_virtual_2c_20emscripten__allow_raw_pointers___ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RayCastCallback__2c_20unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 6; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____data_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = b2Vec2__20std____2____to_address_5babi_v160004_5d_b2Vec2__28b2Vec2__29(HEAP32[HEAP32[$1 + 12 >> 2] >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__allocator_char___allocator_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2____non_trivial_if_true_2c_20std____2__allocator_char______non_trivial_if_5babi_v160004_5d_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____unwrap_range_impl_char_20const__2c_20char_20const______rewrap_5babi_v160004_5d_28char_20const__2c_20char_20const__29($0, $1) { + return char_20const__20std____2____rewrap_iter_5babi_v160004_5d_char_20const__2c_20char_20const__2c_20std____2____unwrap_iter_impl_char_20const__2c_20true___28char_20const__2c_20char_20const__29($0, $1); +} + +function b2Shape__operator__28b2Shape_20const__29($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $1 = HEAP32[$2 + 8 >> 2]; + $0 = HEAP32[$1 + 4 >> 2]; + $3 = HEAP32[$1 + 8 >> 2]; + $1 = $0; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 + 4 >> 2] = $1; + HEAP32[$0 + 8 >> 2] = $3; + return $0; +} + +function void_20emscripten__internal__raw_destructor_b2QueryCallbackWrapper__28b2QueryCallbackWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function std____2__allocator_int___allocator_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + std____2____non_trivial_if_true_2c_20std____2__allocator_int______non_trivial_if_5babi_v160004_5d_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function ContactSetTangentSpeed_28unsigned_20int_2c_20float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + b2Contact__SetTangentSpeed_28float_29(HEAP32[$2 + 12 >> 2], HEAPF32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function b2Vec2__operator___28b2Vec2_20const__29_1($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAPF32[$0 >> 2] = HEAPF32[$0 >> 2] - HEAPF32[HEAP32[$2 + 8 >> 2] >> 2]; + HEAPF32[$0 + 4 >> 2] = HEAPF32[$0 + 4 >> 2] - HEAPF32[HEAP32[$2 + 8 >> 2] + 4 >> 2]; +} + +function std____2__vector_int_2c_20std____2__allocator_int____data_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = int__20std____2____to_address_5babi_v160004_5d_int__28int__29(HEAP32[HEAP32[$1 + 12 >> 2] >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2PolygonAndCircleContact___b2PolygonAndCircleContact_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2PolygonAndCircleContact___b2PolygonAndCircleContact_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function ContactSetRestitution_28unsigned_20int_2c_20float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + b2Contact__SetRestitution_28float_29(HEAP32[$2 + 12 >> 2], HEAPF32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function std____2__less_b2Fixture____operator_28_29_5babi_v160004_5d_28b2Fixture__20const__2c_20b2Fixture__20const__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + return HEAPU32[HEAP32[$3 + 8 >> 2] >> 2] < HEAPU32[HEAP32[$3 + 4 >> 2] >> 2]; +} + +function std____2____compressed_pair_elem_unsigned_20long_2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_int_2c_20void__28int___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[HEAP32[$2 + 8 >> 2] >> 2]; + return $0; +} + +function b2Vec2__operator___28b2Vec2_20const__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAPF32[$0 >> 2] = HEAPF32[$0 >> 2] + HEAPF32[HEAP32[$2 + 8 >> 2] >> 2]; + HEAPF32[$0 + 4 >> 2] = HEAPF32[$0 + 4 >> 2] + HEAPF32[HEAP32[$2 + 8 >> 2] + 4 >> 2]; +} + +function b2Contact__SetEnabled_28bool_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + label$1: { + if (HEAP8[$2 + 11 | 0] & 1) { + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] | 4; + break label$1; + } + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] & -5; + } +} + +function std____2__vector_int_2c_20std____2__allocator_int______destroy_vector____destroy_vector_28std____2__vector_int_2c_20std____2__allocator_int____29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$2 + 8 >> 2]; + return $0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____20emscripten__internal__operator_new_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(12); + std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____vector_5babi_v160004_5d_28_29($0); + return $0 | 0; +} + +function b2MouseJoint__ShiftOrigin_28b2Vec2_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + b2Vec2__operator___28b2Vec2_20const__29_1(HEAP32[$2 + 12 >> 2] + 76 | 0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______alloc_5babi_v160004_5d_28_29($0) { + return std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____second_5babi_v160004_5d_28_29($0); +} + +function b2RayCastCallbackWrapper___b2RayCastCallbackWrapper_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2RayCastCallbackWrapper___b2RayCastCallbackWrapper_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2ContactListenerWrapper___b2ContactListenerWrapper_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2ContactListenerWrapper___b2ContactListenerWrapper_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2ChainAndPolygonContact___b2ChainAndPolygonContact_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2ChainAndPolygonContact___b2ChainAndPolygonContact_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function std____2____compressed_pair_elem_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_28std____2____default_init_tag_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 8 >> 2] = $0; + return HEAP32[$1 + 8 >> 2]; +} + +function is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, $1, $2) { + if (!$2) { + return HEAP32[$0 + 4 >> 2] == HEAP32[$1 + 4 >> 2]; + } + if (($0 | 0) == ($1 | 0)) { + return 1; + } + return !strcmp(std__type_info__name_5babi_v160004_5d_28_29_20const($0), std__type_info__name_5babi_v160004_5d_28_29_20const($1)); +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 6; +} + +function char_20const__20std____2____rewrap_iter_5babi_v160004_5d_char_20const__2c_20char_20const__2c_20std____2____unwrap_iter_impl_char_20const__2c_20true___28char_20const__2c_20char_20const__29($0, $1) { + return std____2____unwrap_iter_impl_char_20const__2c_20true_____rewrap_5babi_v160004_5d_28char_20const__2c_20char_20const__29($0, $1); +} + +function b2BroadPhase___b2BroadPhase_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Free_28void__29(HEAP32[$0 + 32 >> 2]); + b2Free_28void__29(HEAP32[$0 + 44 >> 2]); + b2DynamicTree___b2DynamicTree_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__raw_destructor_b2RayCastCallback__28b2RayCastCallback__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2ContactListener__28b2ContactListener__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____second_5babi_v160004_5d_28_29_20const($0) { + return std____2____compressed_pair_elem_std____2__allocator_char__2c_201_2c_20true_____get_5babi_v160004_5d_28_29_20const($0); +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 6; +} + +function b2Vec2__operator__28_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0); + b2Vec2__Set_28float_2c_20float_29($0, Math_fround(-HEAPF32[$1 >> 2]), Math_fround(-HEAPF32[$1 + 4 >> 2])); + __stack_pointer = $2 + 16 | 0; +} + +function ContactSetFriction_28unsigned_20int_2c_20float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + b2Contact__SetFriction_28float_29(HEAP32[$2 + 12 >> 2], HEAPF32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 6; +} + +function emscripten__internal__BindingType_emscripten__val_2c_20void___toWireType_28emscripten__val_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + _emval_incref(HEAP32[HEAP32[$1 + 12 >> 2] >> 2]); + __stack_pointer = $1 + 16 | 0; + return HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; +} + +function b2EdgeAndPolygonContact___b2EdgeAndPolygonContact_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2EdgeAndPolygonContact___b2EdgeAndPolygonContact_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2ChainAndCircleContact___b2ChainAndCircleContact_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2ChainAndCircleContact___b2ChainAndCircleContact_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function embind_init_b2_28_29__$_6____invoke_28b2FixtureDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_6__operator_28_29_28b2FixtureDef__29_20const($1 + 11 | 0, HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2QueryCallback__28b2QueryCallback__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__wrapper_b2ContactListener____wrapper_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + emscripten__wrapper_b2ContactListener____wrapper_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2RayCastInput__20emscripten__internal__raw_constructor_b2RayCastInput__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(20); + HEAP32[$0 >> 2] = 0; + HEAP32[$0 + 4 >> 2] = 0; + HEAP32[$0 + 16 >> 2] = 0; + HEAP32[$0 + 8 >> 2] = 0; + HEAP32[$0 + 12 >> 2] = 0; + b2RayCastInput__b2RayCastInput_28_29($0); + return $0 | 0; +} + +function b2PrismaticJoint__GetAnchorB_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 52 >> 2], $1 + 76 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2PrismaticJoint__GetAnchorA_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 48 >> 2], $1 + 68 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function __lseek($0, $1, $2, $3) { + var $4 = 0; + $4 = __stack_pointer - 16 | 0; + __stack_pointer = $4; + $3 = __wasi_syscall_ret(legalfunc$__wasi_fd_seek($0, $1, $2, $3 & 255, $4 + 8 | 0)); + __stack_pointer = $4 + 16 | 0; + $2 = HEAP32[$4 + 12 >> 2]; + i64toi32_i32$HIGH_BITS = $3 ? -1 : $2; + $1 = HEAP32[$4 + 8 >> 2]; + return $3 ? -1 : $1; +} + +function operator_20new_28unsigned_20long_29($0) { + var $1 = 0; + $1 = $0 >>> 0 <= 1 ? 1 : $0; + label$1: { + while (1) { + $0 = dlmalloc($1); + if ($0) { + break label$1; + } + $0 = std__get_new_handler_28_29(); + if ($0) { + FUNCTION_TABLE[$0 | 0](); + continue; + } + break; + } + abort(); + wasm2js_trap(); + } + return $0; +} + +function embind_init_b2_28_29__$_11____invoke_28b2JointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_11__operator_28_29_28b2JointDef__29_20const($1 + 11 | 0, HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2RevoluteJoint__GetAnchorB_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 52 >> 2], $1 + 76 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2RevoluteJoint__GetAnchorA_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 48 >> 2], $1 + 68 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2FrictionJoint__GetAnchorB_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 52 >> 2], $1 + 76 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2FrictionJoint__GetAnchorA_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 48 >> 2], $1 + 68 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2DistanceJoint__GetAnchorB_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 52 >> 2], $1 + 88 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2DistanceJoint__GetAnchorA_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 48 >> 2], $1 + 80 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 6; +} + +function b2QueryCallbackWrapper___b2QueryCallbackWrapper_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2QueryCallbackWrapper___b2QueryCallbackWrapper_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2PulleyJoint__GetAnchorB_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 52 >> 2], $1 + 100 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2EdgeAndCircleContact___b2EdgeAndCircleContact_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2EdgeAndCircleContact___b2EdgeAndCircleContact_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function embind_init_b2_28_29__$_9____invoke_28b2JointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = embind_init_b2_28_29__$_9__operator_28_29_28b2JointDef__29_20const($1 + 11 | 0, HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2PulleyJoint__GetAnchorA_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 48 >> 2], $1 + 92 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2DrawWrapper__28b2DrawWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function b2WheelJoint__GetAnchorB_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 52 >> 2], $1 + 76 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2WheelJoint__GetAnchorA_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 48 >> 2], $1 + 68 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2MouseJoint__GetAnchorB_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 52 >> 2], $1 + 68 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2GearJoint__GetAnchorB_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 52 >> 2], $1 + 100 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2World__28b2World__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + b2World___b2World_28_29($0); + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function b2WeldJoint__GetAnchorB_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 52 >> 2], $1 + 88 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2WeldJoint__GetAnchorA_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 48 >> 2], $1 + 80 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2RopeJoint__GetAnchorB_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 52 >> 2], $1 + 76 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2RopeJoint__GetAnchorA_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 48 >> 2], $1 + 68 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function b2GearJoint__GetAnchorA_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $1; + $1 = HEAP32[$2 + 12 >> 2]; + b2Body__GetWorldPoint_28b2Vec2_20const__29_20const($0, HEAP32[$1 + 48 >> 2], $1 + 92 | 0); + __stack_pointer = $2 + 16 | 0; +} + +function decltype_28std____2____unwrap_iter_impl_char__2c_20true_____unwrap_28std__declval_char___28_29_29_29_20std____2____unwrap_iter_5babi_v160004_5d_char__2c_20std____2____unwrap_iter_impl_char__2c_20true__2c_200__28char__29($0) { + return std____2____unwrap_iter_impl_char__2c_20true_____unwrap_5babi_v160004_5d_28char__29($0); +} + +function void_20std____2__allocator_int___construct_5babi_v160004_5d_int_2c_20int_20const___28int__2c_20int_20const__29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + HEAP32[HEAP32[$3 + 8 >> 2] >> 2] = HEAP32[HEAP32[$3 + 4 >> 2] >> 2]; +} + +function void_20emscripten__internal__raw_destructor_b2RopeJoint__28b2RopeJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 32 >> 2]]($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function std____2____compressed_pair_elem_b2Vec2__2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std__nullptr_t_2c_20void__28std__nullptr_t___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void___getTypes_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void____get_28_29(); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2Vec2__IsValid_28_29_20const($0) { + var $1 = 0, $2 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if (b2IsValid_28float_29(HEAPF32[$0 >> 2]) & 1) { + $2 = b2IsValid_28float_29(HEAPF32[$0 + 4 >> 2]); + } + __stack_pointer = $1 + 16 | 0; + return $2 & 1; +} + +function ContactSetEnabled_28unsigned_20int_2c_20bool_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + b2Contact__SetEnabled_28bool_29(HEAP32[$2 + 12 >> 2], HEAP8[$2 + 11 | 0] & 1); + __stack_pointer = $2 + 16 | 0; +} + +function __fmodeflags($0) { + var $1 = 0; + $1 = 2; + if (!strchr($0, 43)) { + $1 = HEAPU8[$0 | 0] != 114; + } + $1 = strchr($0, 120) ? $1 | 128 : $1; + $1 = strchr($0, 101) ? $1 | 524288 : $1; + $0 = HEAPU8[$0 | 0]; + $1 = ($0 | 0) == 114 ? $1 : $1 | 64; + $1 = ($0 | 0) == 119 ? $1 | 512 : $1; + return ($0 | 0) == 97 ? $1 | 1024 : $1; +} + +function std____2__vector_int_2c_20std____2__allocator_int____20emscripten__internal__operator_new_std____2__vector_int_2c_20std____2__allocator_int____28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(12); + std____2__vector_int_2c_20std____2__allocator_int____vector_5babi_v160004_5d_28_29($0); + return $0 | 0; +} + +function std____2____compressed_pair_elem_int__2c_200_2c_20false_____compressed_pair_elem_5babi_v160004_5d_std__nullptr_t_2c_20void__28std__nullptr_t___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = 0; + return $0; +} + +function void_20emscripten__internal__raw_destructor_b2PrismaticJointDef__28b2PrismaticJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function std____2____compressed_pair_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_20std____2__allocator_char____second_5babi_v160004_5d_28_29($0) { + return std____2____compressed_pair_elem_std____2__allocator_char__2c_201_2c_20true_____get_5babi_v160004_5d_28_29($0); +} + +function void_20emscripten__internal__raw_destructor_b2RevoluteJointDef__28b2RevoluteJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2DistanceJointDef__28b2DistanceJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function b2World__GetGravity_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $1; + $2 = HEAP32[$2 + 12 >> 2] + 102964 | 0; + $1 = HEAP32[$2 >> 2]; + $3 = HEAP32[$2 + 4 >> 2]; + $2 = $1; + $1 = $0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $3; +} + +function b2BroadPhase__GetUserData_28int_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = b2DynamicTree__GetUserData_28int_29_20const(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function b2MouseJoint__GetAnchorA_28_29_20const($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $1; + $2 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$2 + 76 >> 2]; + $3 = HEAP32[$2 + 80 >> 2]; + $2 = $1; + $1 = $0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $3; +} + +function b2BroadPhase__GetFatAABB_28int_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = b2DynamicTree__GetFatAABB_28int_29_20const(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; + return $0; +} + +function void_20emscripten__internal__raw_destructor_b2Draw__28b2Draw__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + FUNCTION_TABLE[HEAP32[HEAP32[$0 >> 2] + 4 >> 2]]($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function b2SimplexVertex__b2SimplexVertex_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 8 | 0); + b2Vec2__b2Vec2_28_29($0 + 16 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2RayCastCallbackWrapper___b2RayCastCallbackWrapper_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + emscripten__wrapper_b2RayCastCallback____wrapper_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2WheelJointDef__28b2WheelJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2RayCastOutput__28b2RayCastOutput__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2MouseJointDef__28b2MouseJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2MotorJointDef__28b2MotorJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function std____2____split_buffer_b2Vec2_2c_20std____2__allocator_b2Vec2______ConstructTransaction____ConstructTransaction_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[HEAP32[$0 + 8 >> 2] >> 2] = HEAP32[$0 >> 2]; + return $0; +} + +function b2Vec2__b2Vec2_28float_2c_20float_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAPF32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + HEAPF32[$0 >> 2] = HEAPF32[$3 + 8 >> 2]; + HEAPF32[$0 + 4 >> 2] = HEAPF32[$3 + 4 >> 2]; + return $0; +} + +function void_20emscripten__internal__raw_destructor_b2WeldJointDef__28b2WeldJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2RopeJointDef__28b2RopeJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2RayCastInput__28b2RayCastInput__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_20const__2c_20b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 5; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 6; +} + +function emscripten__internal__BindingType_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20void___fromWireType_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2ContactListener___b2ContactListener_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2ContactListener___b2ContactListener_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function ContactGetTangentSpeed_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $2 = b2Contact__GetTangentSpeed_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return Math_fround($2); +} + +function void__20std____2____libcpp_operator_new_5babi_v160004_5d_unsigned_20long__28unsigned_20long_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = operator_20new_28unsigned_20long_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____operator_5b_5d_5babi_v160004_5d_28unsigned_20long_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAP32[HEAP32[$2 + 12 >> 2] >> 2] + (HEAP32[$2 + 8 >> 2] << 3) | 0; +} + +function fmt_x($0, $1, $2, $3) { + var $4 = 0; + if ($0 | $1) { + while (1) { + $2 = $2 - 1 | 0; + HEAP8[$2 | 0] = HEAPU8[($0 & 15) + 23872 | 0] | $3; + $4 = !$1 & $0 >>> 0 > 15 | ($1 | 0) != 0; + $0 = ($1 & 15) << 28 | $0 >>> 4; + $1 = $1 >>> 4 | 0; + if ($4) { + continue; + } + break; + } + } + return $2; +} + +function void_20std____2____debug_db_insert_c_5babi_v160004_5d_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______throw_length_error_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + std____2____throw_length_error_5babi_v160004_5d_28char_20const__29(3664); + wasm2js_trap(); +} + +function char_20const__20std____2____rewrap_range_5babi_v160004_5d_char_20const__2c_20char_20const__2c_20char_20const___28char_20const__2c_20char_20const__29($0, $1) { + return std____2____unwrap_range_impl_char_20const__2c_20char_20const______rewrap_5babi_v160004_5d_28char_20const__2c_20char_20const__29($0, $1); +} + +function b2QueryCallbackWrapper___b2QueryCallbackWrapper_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + emscripten__wrapper_b2QueryCallback____wrapper_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function ContactGetRestitution_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $2 = b2Contact__GetRestitution_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return Math_fround($2); +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____ConstructTransaction____ConstructTransaction_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[HEAP32[$0 >> 2] + 4 >> 2] = HEAP32[$0 + 4 >> 2]; + return $0; +} + +function std____2____split_buffer_int_2c_20std____2__allocator_int______ConstructTransaction____ConstructTransaction_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[HEAP32[$0 + 8 >> 2] >> 2] = HEAP32[$0 >> 2]; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 5; +} + +function b2PrismaticJoint___b2PrismaticJoint_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2PrismaticJoint___b2PrismaticJoint_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2PolygonContact___b2PolygonContact_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2PolygonContact___b2PolygonContact_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2PrismaticJoint__GetReactionTorque_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(HEAPF32[$2 + 8 >> 2] * HEAPF32[HEAP32[$2 + 12 >> 2] + 108 >> 2])); +} + +function WorldManifoldDelete_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + if (HEAP32[$1 + 12 >> 2]) { + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + } + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2Transform__28b2Transform__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function WorldManifoldGetPointValueY_28unsigned_20int_2c_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return Math_fround(HEAPF32[((HEAP32[$2 + 12 >> 2] + 8 | 0) + (HEAP32[$2 + 8 >> 2] << 3) | 0) + 4 >> 2]); +} + +function std____2__vector_int_2c_20std____2__allocator_int____operator_5b_5d_5babi_v160004_5d_28unsigned_20long_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAP32[HEAP32[$2 + 12 >> 2] >> 2] + (HEAP32[$2 + 8 >> 2] << 2) | 0; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int____get_28_29() { + return 27712; +} + +function b2FrictionJoint__GetReactionTorque_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(HEAPF32[$2 + 8 >> 2] * HEAPF32[HEAP32[$2 + 12 >> 2] + 92 >> 2])); +} + +function void_20emscripten__internal__raw_destructor_b2MassData__28b2MassData__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2JointDef__28b2JointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______throw_length_error_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + std____2____throw_length_error_5babi_v160004_5d_28char_20const__29(3664); + wasm2js_trap(); +} + +function std____2____compressed_pair_elem_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_200_2c_20false_____get_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int____get_28_29() { + return 27376; +} + +function b2Vec2__operator___28float_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAPF32[$0 >> 2] = HEAPF32[$0 >> 2] * HEAPF32[$2 + 8 >> 2]; + HEAPF32[$0 + 4 >> 2] = HEAPF32[$0 + 4 >> 2] * HEAPF32[$2 + 8 >> 2]; +} + +function b2RevoluteJoint___b2RevoluteJoint_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2RevoluteJoint___b2RevoluteJoint_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2FrictionJoint___b2FrictionJoint_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2FrictionJoint___b2FrictionJoint_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2DistanceJoint___b2DistanceJoint_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2DistanceJoint___b2DistanceJoint_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2ContactFilter___b2ContactFilter_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2ContactFilter___b2ContactFilter_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2CircleContact___b2CircleContact_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2CircleContact___b2CircleContact_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function ContactGetFriction_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0, $2 = Math_fround(0); + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $2 = b2Contact__GetFriction_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return Math_fround($2); +} + +function std____2__vector_int_2c_20std____2__allocator_int_____ConstructTransaction____ConstructTransaction_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[HEAP32[$0 >> 2] + 4 >> 2] = HEAP32[$0 + 4 >> 2]; + return $0; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____operator_5b_5d_5babi_v160004_5d_28unsigned_20long_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAP32[HEAP32[$2 + 12 >> 2] >> 2] + (HEAP32[$2 + 8 >> 2] << 3) | 0; +} + +function std____2____unwrap_iter_impl_std____2__reverse_iterator_b2Vec2___2c_20false_____unwrap_5babi_v160004_5d_28std____2__reverse_iterator_b2Vec2___29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 + 12 >> 2] = HEAP32[$1 + 8 >> 2]; + return HEAP32[$1 + 12 >> 2]; +} + +function b2WheelJoint__GetReactionTorque_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(HEAPF32[$2 + 8 >> 2] * HEAPF32[HEAP32[$2 + 12 >> 2] + 104 >> 2])); +} + +function b2PrismaticJoint__GetMotorForce_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(HEAPF32[$2 + 8 >> 2] * HEAPF32[HEAP32[$2 + 12 >> 2] + 112 >> 2])); +} + +function void_20emscripten__internal__raw_destructor_b2Fixture__28b2Fixture__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__val__take_ownership_28emscripten___EM_VAL__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + emscripten__val__val_28emscripten___EM_VAL__29($0, HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int____get_28_29() { + return 27536; +} + +function b2WeldJoint__GetReactionTorque_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(HEAPF32[$2 + 8 >> 2] * HEAPF32[HEAP32[$2 + 12 >> 2] + 112 >> 2])); +} + +function b2RevoluteJoint__GetMotorTorque_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(HEAPF32[$2 + 8 >> 2] * HEAPF32[HEAP32[$2 + 12 >> 2] + 92 >> 2])); +} + +function b2MotorJoint__GetReactionTorque_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(HEAPF32[$2 + 8 >> 2] * HEAPF32[HEAP32[$2 + 12 >> 2] + 88 >> 2])); +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 5; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 5; +} + +function b2Mat33__b2Mat33_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec3__b2Vec3_28_29($0); + b2Vec3__b2Vec3_28_29($0 + 12 | 0); + b2Vec3__b2Vec3_28_29($0 + 24 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function WorldManifoldGetSeparationValue_28unsigned_20int_2c_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return Math_fround(HEAPF32[(HEAP32[$2 + 12 >> 2] + 24 | 0) + (HEAP32[$2 + 8 >> 2] << 2) >> 2]); +} + +function void_20emscripten__internal__raw_destructor_b2Filter__28b2Filter__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function std____2__pointer_traits_std____2____tree_end_node_std____2____tree_node_base_void________pointer_to_5babi_v160004_5d_28std____2____tree_end_node_std____2____tree_node_base_void______29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 5; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__BindingType_std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20void___fromWireType_28std____2__vector_int_2c_20std____2__allocator_int___20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2WheelJoint__GetMotorTorque_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(HEAPF32[$2 + 8 >> 2] * HEAPF32[HEAP32[$2 + 12 >> 2] + 104 >> 2])); +} + +function b2Sweep__b2Sweep_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 8 | 0); + b2Vec2__b2Vec2_28_29($0 + 16 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2PolygonShape___b2PolygonShape_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2PolygonShape___b2PolygonShape_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function ContactImpulseGetTangentImpulse_28unsigned_20int_2c_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return Math_fround(HEAPF32[(HEAP32[$2 + 12 >> 2] + 8 | 0) + (HEAP32[$2 + 8 >> 2] << 2) >> 2]); +} + +function bool_20std____2____tree_is_left_child_5babi_v160004_5d_std____2____tree_node_base_void_____28std____2____tree_node_base_void____29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] == HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] + 8 >> 2] >> 2]; +} + +function b2Dump_28char_20const__2c_20____29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + if (HEAP32[7692]) { + HEAP32[$2 + 8 >> 2] = $1; + vfprintf(HEAP32[7692], HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + } + __stack_pointer = $2 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2Color__28b2Color__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 5; +} + +function emscripten__internal__DestructorsRunner__DestructorsRunner_28emscripten__internal___EM_DESTRUCTORS__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$2 + 8 >> 2]; + return $0; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int____get_28_29() { + return 27120; +} + +function b2Vec2__Set_28float_2c_20float_29($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAPF32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + $0 = HEAP32[$3 + 12 >> 2]; + HEAPF32[$0 >> 2] = HEAPF32[$3 + 8 >> 2]; + HEAPF32[$0 + 4 >> 2] = HEAPF32[$3 + 4 >> 2]; +} + +function b2PositionSolverManifold__b2PositionSolverManifold_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2__vector_int_2c_20std____2__allocator_int____operator_5b_5d_5babi_v160004_5d_28unsigned_20long_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAP32[HEAP32[$2 + 12 >> 2] >> 2] + (HEAP32[$2 + 8 >> 2] << 2) | 0; +} + +function std____2____unwrap_iter_impl_std____2__reverse_iterator_int___2c_20false_____unwrap_5babi_v160004_5d_28std____2__reverse_iterator_int___29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 8 >> 2] = $0; + HEAP32[$1 + 12 >> 2] = HEAP32[$1 + 8 >> 2]; + return HEAP32[$1 + 12 >> 2]; +} + +function float_20b2Min_float__28float_2c_20float_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAPF32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + if (HEAPF32[$2 + 12 >> 2] < HEAPF32[$2 + 8 >> 2]) { + $0 = HEAPF32[$2 + 12 >> 2]; + } else { + $0 = HEAPF32[$2 + 8 >> 2]; + } + return $0; +} + +function float_20b2Max_float__28float_2c_20float_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAPF32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + if (HEAPF32[$2 + 12 >> 2] > HEAPF32[$2 + 8 >> 2]) { + $0 = HEAPF32[$2 + 12 >> 2]; + } else { + $0 = HEAPF32[$2 + 8 >> 2]; + } + return $0; +} + +function void_20emscripten__internal__raw_destructor_b2Vec2__28b2Vec2__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2AABB__28b2AABB__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function std____2____compressed_pair_elem_std____2____tree_node_destructor_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____2c_201_2c_20false_____get_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__BindingType_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20void___fromWireType_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2PulleyJoint___b2PulleyJoint_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2PulleyJoint___b2PulleyJoint_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2PulleyJoint__GetGroundAnchorB_28_29_20const($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $1; + $2 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$2 + 76 >> 2]; + $3 = HEAP32[$2 + 80 >> 2]; + $2 = $1; + $1 = $0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $3; +} + +function b2PulleyJoint__GetGroundAnchorA_28_29_20const($0, $1) { + var $2 = 0, $3 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $1; + $2 = HEAP32[$2 + 12 >> 2]; + $1 = HEAP32[$2 + 68 >> 2]; + $3 = HEAP32[$2 + 72 >> 2]; + $2 = $1; + $1 = $0; + HEAP32[$1 >> 2] = $2; + HEAP32[$1 + 4 >> 2] = $3; +} + +function b2DrawWrapper___b2DrawWrapper_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2DrawWrapper___b2DrawWrapper_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2CircleShape___b2CircleShape_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2CircleShape___b2CircleShape_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function WorldManifoldGetPointValueX_28unsigned_20int_2c_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return Math_fround(HEAPF32[(HEAP32[$2 + 12 >> 2] + 8 | 0) + (HEAP32[$2 + 8 >> 2] << 3) >> 2]); +} + +function b2Vec2__Length_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + return Math_fround(Math_sqrt(Math_fround(Math_fround(HEAPF32[$0 >> 2] * HEAPF32[$0 >> 2]) + Math_fround(HEAPF32[$0 + 4 >> 2] * HEAPF32[$0 + 4 >> 2])))); +} + +function void_20emscripten__internal__raw_destructor_b2Rot__28b2Rot__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + if ($0) { + operator_20delete_28void__29($0); + } + __stack_pointer = $1 + 16 | 0; +} + +function std____2__reverse_iterator_b2Vec2____operator__5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$1 + 8 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + $0 = HEAP32[$1 + 8 >> 2] - 8 | 0; + HEAP32[$1 + 8 >> 2] = $0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 5; +} + +function emscripten__internal__BindingType_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20void___toWireType_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function embind_init_b2_28_29__$_5__operator_28_29_28b2FixtureDef__2c_20b2Shape_20const__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + HEAP32[HEAP32[$3 + 8 >> 2] >> 2] = HEAP32[$3 + 4 >> 2]; +} + +function b2MixRestitution_28float_2c_20float_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAPF32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + if (HEAPF32[$2 + 12 >> 2] > HEAPF32[$2 + 8 >> 2]) { + $0 = HEAPF32[$2 + 12 >> 2]; + } else { + $0 = HEAPF32[$2 + 8 >> 2]; + } + return $0; +} + +function emscripten__internal__GenericBindingType_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____fromWireType_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2WheelJoint___b2WheelJoint_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2WheelJoint___b2WheelJoint_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2MouseJoint___b2MouseJoint_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2MouseJoint___b2MouseJoint_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2MotorJoint___b2MotorJoint_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2MotorJoint___b2MotorJoint_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function std____2__reverse_iterator_int____operator__5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + HEAP32[$1 + 8 >> 2] = HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; + $0 = HEAP32[$1 + 8 >> 2] - 4 | 0; + HEAP32[$1 + 8 >> 2] = $0; + return $0; +} + +function emscripten__val__val_28emscripten__val___29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[HEAP32[$2 + 8 >> 2] >> 2]; + HEAP32[HEAP32[$2 + 8 >> 2] >> 2] = 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Color_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 5; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const____get_28_29(); +} + +function b2PolygonAndCircleContact___b2PolygonAndCircleContact_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Contact___b2Contact_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2MassData__20emscripten__internal__raw_constructor_b2MassData__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(16); + HEAP32[$0 >> 2] = 0; + HEAP32[$0 + 4 >> 2] = 0; + HEAP32[$0 + 8 >> 2] = 0; + HEAP32[$0 + 12 >> 2] = 0; + b2MassData__b2MassData_28_29($0); + return $0 | 0; +} + +function b2ContactManager__FindNewContacts_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + void_20b2BroadPhase__UpdatePairs_b2ContactManager__28b2ContactManager__29($0, $0); + __stack_pointer = $1 + 16 | 0; +} + +function EmBindInit_b2__EmBindInit_b2_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + emscripten__internal__InitFunc__InitFunc_28void_20_28__29_28_29_29($0, 1); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_20const__2c_20b2QueryCallback__2c_20b2AABB_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function embind_init_b2_28_29__$_10__operator_28_29_28b2JointDef__2c_20b2Body__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + HEAP32[HEAP32[$3 + 8 >> 2] + 12 >> 2] = HEAP32[$3 + 4 >> 2]; +} + +function b2StackAllocator__b2StackAllocator_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 + 102400 >> 2] = 0; + HEAP32[$0 + 102404 >> 2] = 0; + HEAP32[$0 + 102408 >> 2] = 0; + HEAP32[$0 + 102796 >> 2] = 0; + return $0; +} + +function b2ChainAndPolygonContact___b2ChainAndPolygonContact_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Contact___b2Contact_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function ContactImpulseGetNormalImpulse_28unsigned_20int_2c_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return Math_fround(HEAPF32[HEAP32[$2 + 12 >> 2] + (HEAP32[$2 + 8 >> 2] << 2) >> 2]); +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20unsigned_20int_2c_20int_2c_20b2Color_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 5; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20unsigned_20int_2c_20unsigned_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function b2WeldJoint___b2WeldJoint_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2WeldJoint___b2WeldJoint_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2RopeJoint___b2RopeJoint_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2RopeJoint___b2RopeJoint_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2GearJoint___b2GearJoint_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2GearJoint___b2GearJoint_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function b2EdgeShape___b2EdgeShape_28_29_1($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2EdgeShape___b2EdgeShape_28_29($0); + operator_20delete_28void__29($0); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__DestructorsRunner___DestructorsRunner_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + _emval_run_destructors(HEAP32[$0 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function embind_init_b2_28_29__$_8__operator_28_29_28b2JointDef__2c_20b2Body__29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + HEAP32[HEAP32[$3 + 8 >> 2] + 8 >> 2] = HEAP32[$3 + 4 >> 2]; +} + +function b2EdgeAndPolygonContact___b2EdgeAndPolygonContact_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Contact___b2Contact_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2ChainAndCircleContact___b2ChainAndCircleContact_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Contact___b2Contact_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2BlockAllocator_____get_28_29() { + return 27652; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2BlockAllocator_____get_28_29() { + return 27312; +} + +function embind_init_b2_28_29__$_2__operator_28_29_28b2Shape__2c_20float_29_20const($0, $1, $2) { + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAPF32[$3 + 4 >> 2] = $2; + HEAPF32[HEAP32[$3 + 8 >> 2] + 8 >> 2] = HEAPF32[$3 + 4 >> 2]; +} + +function b2EdgeAndCircleContact___b2EdgeAndCircleContact_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Contact___b2Contact_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__BindingType_std____2__vector_int_2c_20std____2__allocator_int____2c_20void___fromWireType_28std____2__vector_int_2c_20std____2__allocator_int____29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2RayCastOutput__20emscripten__internal__raw_constructor_b2RayCastOutput__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(12); + HEAP32[$0 >> 2] = 0; + HEAP32[$0 + 4 >> 2] = 0; + HEAP32[$0 + 8 >> 2] = 0; + b2RayCastOutput__b2RayCastOutput_28_29($0); + return $0 | 0; +} + +function int_20b2Min_int__28int_2c_20int_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + if (HEAP32[$2 + 12 >> 2] < HEAP32[$2 + 8 >> 2]) { + $0 = HEAP32[$2 + 12 >> 2]; + } else { + $0 = HEAP32[$2 + 8 >> 2]; + } + return $0; +} + +function int_20b2Max_int__28int_2c_20int_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + if (HEAP32[$2 + 12 >> 2] > HEAP32[$2 + 8 >> 2]) { + $0 = HEAP32[$2 + 12 >> 2]; + } else { + $0 = HEAP32[$2 + 8 >> 2]; + } + return $0; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2BlockAllocator_____get_28_29() { + return 27488; +} + +function b2Draw__ClearFlags_28unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] & (HEAP32[$2 + 8 >> 2] ^ -1); +} + +function b2DrawWrapper___b2DrawWrapper_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + emscripten__wrapper_b2Draw____wrapper_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2BroadPhase__TouchProxy_28int_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + b2BroadPhase__BufferMove_28int_29(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function auto_20std____2____unwrap_range_5babi_v160004_5d_char_20const__2c_20char_20const___28char_20const__2c_20char_20const__29($0, $1, $2) { + std____2____unwrap_range_impl_char_20const__2c_20char_20const______unwrap_5babi_v160004_5d_28char_20const__2c_20char_20const__29($0, $1, $2); +} + +function std____2____tree_node_base_void______set_parent_5babi_v160004_5d_28std____2____tree_node_base_void____29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + HEAP32[HEAP32[$2 + 12 >> 2] + 8 >> 2] = HEAP32[$2 + 8 >> 2]; +} + +function fmt_o($0, $1, $2) { + var $3 = 0; + if ($0 | $1) { + while (1) { + $2 = $2 - 1 | 0; + HEAP8[$2 | 0] = $0 & 7 | 48; + $3 = !$1 & $0 >>> 0 > 7 | ($1 | 0) != 0; + $0 = ($1 & 7) << 29 | $0 >>> 3; + $1 = $1 >>> 3 | 0; + if ($3) { + continue; + } + break; + } + } + return $2; +} + +function emscripten__internal__BindingType_std____2__vector_int_2c_20std____2__allocator_int____2c_20void___toWireType_28std____2__vector_int_2c_20std____2__allocator_int____29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20float____get_28_29() { + return 28176; +} + +function b2DistanceOutput__b2DistanceOutput_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2MassData__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function b2RayCastCallback__20emscripten__base_b2RayCastCallback___convertPointer_b2RayCastCallbackWrapper_2c_20b2RayCastCallback__28b2RayCastCallbackWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2RayCastCallbackWrapper__20emscripten__base_b2RayCastCallback___convertPointer_b2RayCastCallback_2c_20b2RayCastCallbackWrapper__28b2RayCastCallback__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2ContactListener__20emscripten__base_b2ContactListener___convertPointer_b2ContactListenerWrapper_2c_20b2ContactListener__28b2ContactListenerWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2ContactListenerWrapper__20emscripten__base_b2ContactListener___convertPointer_b2ContactListener_2c_20b2ContactListenerWrapper__28b2ContactListener__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2MassData__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2BlockAllocator____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__GenericBindingType_std____2__vector_int_2c_20std____2__allocator_int_____fromWireType_28std____2__vector_int_2c_20std____2__allocator_int____29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Fixture__GetType_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = b2Shape__GetType_28_29_20const(HEAP32[HEAP32[$1 + 12 >> 2] + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2__reverse_iterator_b2Vec2____reverse_iterator_5babi_v160004_5d_28b2Vec2__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$2 + 8 >> 2]; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2BlockAllocator____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_std____2__vector_int_2c_20std____2__allocator_int___20const____get_28_29(); +} + +function b2JointDef__b2JointDef_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 >> 2] = 0; + HEAP32[$0 + 4 >> 2] = 0; + HEAP32[$0 + 8 >> 2] = 0; + HEAP32[$0 + 12 >> 2] = 0; + HEAP8[$0 + 16 | 0] = 0; + return $0; +} + +function void_20_28_emscripten__select_overload_void_20_28b2RayCastCallbackWrapper__29__28void_20_28__29_28b2RayCastCallbackWrapper__29_29_29_28b2RayCastCallbackWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function void_20_28_emscripten__select_overload_void_20_28b2ContactListenerWrapper__29__28void_20_28__29_28b2ContactListenerWrapper__29_29_29_28b2ContactListenerWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function unsigned_20long_20std____2__allocator_traits_std____2__allocator_char____max_size_5babi_v160004_5d_std____2__allocator_char__2c_20void_2c_20void__28std____2__allocator_char__20const__29($0) { + return std____2__numeric_limits_unsigned_20long___max_5babi_v160004_5d_28_29(); +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2MassData__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const_____get_28_29() { + return 26976; +} + +function b2Vec2__LengthSquared_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + return Math_fround(Math_fround(HEAPF32[$0 >> 2] * HEAPF32[$0 >> 2]) + Math_fround(HEAPF32[$0 + 4 >> 2] * HEAPF32[$0 + 4 >> 2])); +} + +function b2RayCastInput__b2RayCastInput_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2BlockAllocator____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_unsigned_20long_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function b2MouseJoint__GetReactionTorque_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(HEAPF32[$2 + 8 >> 2] * Math_fround(0))); +} + +function b2EdgeShape__TestPoint_28b2Transform_20const__2c_20b2Vec2_20const__29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; + return 0; +} + +function b2Draw__AppendFlags_28unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 + 8 >> 2] | HEAP32[$0 + 4 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Shape_20const__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2FixtureDef_20const_____get_28_29() { + return 28160; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______get_28_29(); +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2MassData__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int____get_28_29() { + return 28048; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____size_5babi_v160004_5d_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + return HEAP32[$0 + 4 >> 2] - HEAP32[$0 >> 2] >> 3; +} + +function std____2__reverse_iterator_int____reverse_iterator_5babi_v160004_5d_28int__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$2 + 8 >> 2]; + return $0; +} + +function std____2__pair_char_20const__2c_20char_20const____pair_5babi_v160004_5d_char_20const__2c_20char_20const__2c_20_28void__290__28char_20const____2c_20char_20const____29($0, $1, $2) { + HEAP32[$0 >> 2] = HEAP32[$1 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 >> 2]; + return $0; +} + +function std____2____tree_const_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____get_np_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Joint__2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2JointDef_20const_____get_28_29() { + return 26872; +} + +function b2PolygonContact___b2PolygonContact_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Contact___b2Contact_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2IsValid_28float_29($0) { + var $1 = 0, $2 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAPF32[$1 + 12 >> 2] = $0; + $2 = bool_20isfinite_5babi_v160004_5d_float_2c_200__28float_29(HEAPF32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $2 & 1; +} + +function void_20_28_emscripten__select_overload_void_20_28b2QueryCallbackWrapper__29__28void_20_28__29_28b2QueryCallbackWrapper__29_29_29_28b2QueryCallbackWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2AABB__20emscripten__internal__operator_new_b2AABB__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(16); + HEAP32[$0 >> 2] = 0; + HEAP32[$0 + 4 >> 2] = 0; + HEAP32[$0 + 8 >> 2] = 0; + HEAP32[$0 + 12 >> 2] = 0; + b2AABB__b2AABB_28_29($0); + return $0 | 0; +} + +function __cxxabiv1____fundamental_type_info__can_catch_28__cxxabiv1____shim_type_info_20const__2c_20void___29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + return is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, $1, 0) | 0; +} + +function ContactIsTouching_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = b2Contact__IsTouching_28_29_20const(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 & 1; +} + +function emscripten__internal__WithPolicies____ArgTypeList_unsigned_20long_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int___20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2BodyDef_20const_____get_28_29() { + return 26800; +} + +function b2QueryCallback__20emscripten__base_b2QueryCallback___convertPointer_b2QueryCallbackWrapper_2c_20b2QueryCallback__28b2QueryCallbackWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2QueryCallbackWrapper__20emscripten__base_b2QueryCallback___convertPointer_b2QueryCallback_2c_20b2QueryCallbackWrapper__28b2QueryCallback__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2CircleContact___b2CircleContact_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Contact___b2Contact_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function ManifoldGetManifoldPointPtr_28unsigned_20int_2c_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAP32[$2 + 12 >> 2] + Math_imul(HEAP32[$2 + 8 >> 2], 20) | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2FixtureDef_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20int_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function b2Transform__b2Transform_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0); + b2Rot__b2Rot_28_29($0 + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20std____2____libcpp_operator_delete_5babi_v160004_5d_void___28void__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + operator_20delete_28void__29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20float_2c_20float_2c_20b2Vec2_20const__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 6; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20emscripten__internal__AllowedRawPointer_b2AABB_____get_28_29() { + return 26656; +} + +function b2PrismaticJoint___b2PrismaticJoint_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Joint___b2Joint_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function GetFloat32_28unsigned_20int_2c_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return Math_fround(HEAPF32[HEAP32[$2 + 12 >> 2] + (HEAP32[$2 + 8 >> 2] << 2) >> 2]); +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20unsigned_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function std____2__vector_int_2c_20std____2__allocator_int____size_5babi_v160004_5d_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + return HEAP32[$0 + 4 >> 2] - HEAP32[$0 >> 2] >> 2; +} + +function std____2__allocator_traits_std____2__allocator_char____deallocate_5babi_v160004_5d_28std____2__allocator_char___2c_20char__2c_20unsigned_20long_29($0, $1, $2) { + std____2__allocator_char___deallocate_5babi_v160004_5d_28char__2c_20unsigned_20long_29($0, $1, $2); +} + +function std____2____tree_iterator_b2Fixture__2c_20std____2____tree_node_b2Fixture__2c_20void____2c_20long_____get_np_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Joint__2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2JointDef_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20b2Transform_20const__2c_20int____get_28_29() { + return 27744; +} + +function char__20std____2____rewrap_iter_5babi_v160004_5d_char__2c_20char__2c_20std____2____unwrap_iter_impl_char__2c_20true___28char__2c_20char__29($0, $1) { + return std____2____unwrap_iter_impl_char__2c_20true_____rewrap_5babi_v160004_5d_28char__2c_20char__29($0, $1); +} + +function b2RevoluteJoint___b2RevoluteJoint_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Joint___b2Joint_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2FrictionJoint___b2FrictionJoint_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Joint___b2Joint_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2DistanceJoint___b2DistanceJoint_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Joint___b2Joint_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function std____2____compressed_pair_elem_std____2____tree_end_node_std____2____tree_node_base_void_____2c_200_2c_20false_____get_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2QueryCallback__2c_20unsigned_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20b2Transform_20const__2c_20int____get_28_29() { + return 27408; +} + +function ContactGetManifold_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = b2Contact__GetManifold_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function ContactGetFixtureB_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = b2Contact__GetFixtureB_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function ContactGetFixtureA_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = b2Contact__GetFixtureA_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2MassData____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2BodyDef_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function b2PolygonShape___b2PolygonShape_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Shape___b2Shape_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function __cxxabiv1____enum_type_info__can_catch_28__cxxabiv1____shim_type_info_20const__2c_20void___29_20const($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + return is_equal_28std__type_info_20const__2c_20std__type_info_20const__2c_20bool_29($0, $1, 0) | 0; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20b2Transform_20const__2c_20int____get_28_29() { + return 27568; +} + +function b2Mat22__b2Mat22_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2GrowableStack_int_2c_20256___b2GrowableStack_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 >> 2] = $0 + 4; + HEAP32[$0 + 1028 >> 2] = 0; + HEAP32[$0 + 1032 >> 2] = 256; + return $0; +} + +function float_20b2Abs_float__28float_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAPF32[$1 + 12 >> 2] = $0; + if (HEAPF32[$1 + 12 >> 2] > Math_fround(0)) { + $0 = HEAPF32[$1 + 12 >> 2]; + } else { + $0 = Math_fround(-HEAPF32[$1 + 12 >> 2]); + } + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Transform_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_std____2__vector_int_2c_20std____2__allocator_int______get_28_29(); +} + +function b2PulleyJoint___b2PulleyJoint_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Joint___b2Joint_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2CircleShape___b2CircleShape_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Shape___b2Shape_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function void_20const__20emscripten__internal__getLightTypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 25120; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2RayCastCallbackWrapper__28b2RayCastCallbackWrapper_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2ContactListenerWrapper__28b2ContactListenerWrapper_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2ContactListener____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20b2MassData____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20emscripten__internal__AllowedRawPointer_b2RayCastOutput__2c_20b2RayCastInput_20const_____get_28_29() { + return 26688; +} + +function b2World__SetContactListener_28b2ContactListener__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + HEAP32[HEAP32[$2 + 12 >> 2] + 102940 >> 2] = HEAP32[$2 + 8 >> 2]; +} + +function b2AABB__b2AABB_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0); + b2Vec2__b2Vec2_28_29($0 + 8 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____compressed_pair_elem_std____2__allocator_std____2____tree_node_b2Fixture__2c_20void____2c_201_2c_20true_____get_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2WheelJoint___b2WheelJoint_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Joint___b2Joint_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2MouseJoint___b2MouseJoint_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Joint___b2Joint_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2MotorJoint___b2MotorJoint_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Joint___b2Joint_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2ContactManager___b2ContactManager_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2BroadPhase___b2BroadPhase_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function __cxxabiv1____class_type_info__process_static_type_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_29_20const($0, $1, $2, $3) { + if (!(HEAP32[$1 + 28 >> 2] == 1 | HEAP32[$1 + 4 >> 2] != ($2 | 0))) { + HEAP32[$1 + 28 >> 2] = $3; + } +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20b2Transform_20const__2c_20int____get_28_29() { + return 27152; +} + +function std____2____non_trivial_if_true_2c_20std____2__allocator_std____2____tree_node_b2Fixture__2c_20void________non_trivial_if_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 5; +} + +function b2WeldJoint___b2WeldJoint_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Joint___b2Joint_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2RopeJoint___b2RopeJoint_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Joint___b2Joint_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2MouseJoint__SetDampingRatio_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 88 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function b2GearJoint___b2GearJoint_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Joint___b2Joint_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2EdgeShape___b2EdgeShape_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Shape___b2Shape_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0 | 0; +} + +function b2DistanceJoint__SetStiffness_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 68 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2QueryCallbackWrapper__28b2QueryCallbackWrapper_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function std____2____compressed_pair_elem_std____2____tree_end_node_std____2____tree_node_base_void_____2c_200_2c_20false_____get_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const_____get_28_29() { + return 25520; +} + +function b2WheelJoint__SetStiffness_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 144 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function b2Log_28char_20const__2c_20____29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + __stack_pointer = $2; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + vprintf(HEAP32[$2 + 12 >> 2], HEAP32[$2 + 8 >> 2]); + __stack_pointer = $2 + 16 | 0; +} + +function b2DistanceJoint__SetLength_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 104 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function b2DistanceJoint__SetDamping_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 72 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function b2ContactListener__PostSolve_28unsigned_20int_2c_20unsigned_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; +} + +function void_20std____2____debug_db_erase_c_5babi_v160004_5d_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char____29($0) {} + +function std____2____unwrap_iter_impl_char_20const__2c_20true_____rewrap_5babi_v160004_5d_28char_20const__2c_20char_20const__29($0, $1) { + return ($1 - char_20const__20std____2____to_address_5babi_v160004_5d_char_20const__28char_20const__29($0) | 0) + $0 | 0; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const_____get_28_29() { + return 25184; +} + +function b2MouseJoint__SetMaxForce_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 104 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function b2MouseJoint__SetFrequency_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 84 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function b2DynamicTree___b2DynamicTree_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Free_28void__29(HEAP32[$0 + 4 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2ContactListener__PreSolve_28unsigned_20int_2c_20unsigned_20int_29($0, $1, $2) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + var $3 = 0; + $3 = __stack_pointer - 16 | 0; + HEAP32[$3 + 12 >> 2] = $0; + HEAP32[$3 + 8 >> 2] = $1; + HEAP32[$3 + 4 >> 2] = $2; +} + +function b2Body__SetAngularDamping_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 136 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_20const__2c_20emscripten__internal__AllowedRawPointer_b2QueryCallback__2c_20b2AABB_20const_____get_28_29() { + return 26960; +} + +function b2WheelJoint__SetDamping_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 148 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function b2WeldJoint__SetStiffness_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 68 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function b2RopeJoint__SetMaxLength_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 84 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function b2Fixture__SetRestitution_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 20 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function b2Body__SetLinearDamping_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 132 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function ContactResetRestitution_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + b2Contact__ResetRestitution_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function b2Body__SetGravityScale_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 140 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Fixture____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function b2WeldJoint__SetDamping_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 72 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Joint____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_emscripten__val_2c_20std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function b2Fixture__SetFriction_28float_29($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 16 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Draw____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Body____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function std____2____compressed_pair_elem_std____2____tree_node_b2Fixture__2c_20void____2c_200_2c_20false_____get_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2PrismaticJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2PrismaticJointDef__28b2JointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2PrismaticJointDef_2c_20b2JointDef__28b2PrismaticJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function void_20const__20emscripten__internal__getLightTypeID_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int___20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 25e3; +} + +function std____2__pair_char_20const__2c_20char____pair_5babi_v160004_5d_char_20const___2c_20char__2c_20_28void__290__28char_20const___2c_20char____29($0, $1, $2) { + HEAP32[$0 >> 2] = HEAP32[$1 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 >> 2]; + return $0; +} + +function std____2__pair_char_20const__2c_20char____pair_5babi_v160004_5d_char_20const__2c_20char__2c_20_28void__290__28char_20const____2c_20char____29($0, $1, $2) { + HEAP32[$0 >> 2] = HEAP32[$1 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$2 >> 2]; + return $0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______throw_length_error_5babi_v160004_5d_28_29_20const($0) { + std____2____throw_length_error_5babi_v160004_5d_28char_20const__29(7639); + wasm2js_trap(); +} + +function std____2____tree_b2Fixture__2c_20std____2__less_b2Fixture___2c_20std____2__allocator_b2Fixture_______begin_node_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function ContactResetFriction_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + b2Contact__ResetFriction_28_29(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2RayCastCallback__28b2RayCastCallback_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2ContactListener__28b2ContactListener_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function std____2____tree_end_node_std____2____tree_node_base_void________tree_end_node_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 >> 2] = 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2RayCastCallbackWrapper__2c_20emscripten__val_____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2ContactListenerWrapper__2c_20emscripten__val_____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RayCastCallback__2c_20unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____get_28_29() { + return 25584; +} + +function b2RevoluteJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2RevoluteJointDef__28b2JointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2RevoluteJointDef_2c_20b2JointDef__28b2RevoluteJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2DistanceJointDef_2c_20b2JointDef__28b2DistanceJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2DistanceJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2DistanceJointDef__28b2JointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const_____get_28_29() { + return 25056; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2MassData__2c_20float____get_28_29() { + return 27776; +} + +function void_20std____2____debug_db_invalidate_all_5babi_v160004_5d_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2PrismaticJoint__28b2PrismaticJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2QueryCallbackWrapper__2c_20emscripten__val_____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2MassData__2c_20float____get_28_29() { + return 27440; +} + +function void_20_28_emscripten__select_overload_void_20_28b2DrawWrapper__29__28void_20_28__29_28b2DrawWrapper__29_29_29_28b2DrawWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20unsigned_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20unsigned_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function b2World__SetDebugDraw_28b2Draw__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + HEAP32[HEAP32[$2 + 12 >> 2] + 102980 >> 2] = HEAP32[$2 + 8 >> 2]; +} + +function b2RayCastOutput__b2RayCastOutput_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function b2ManifoldPoint__b2ManifoldPoint_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2RevoluteJoint__28b2RevoluteJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2QueryCallback__28b2QueryCallback_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2DistanceJoint__28b2DistanceJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2Fixture____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int____get_28_29() { + return 27680; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20emscripten__internal__AllowedRawPointer_b2MassData__2c_20float____get_28_29() { + return 27600; +} + +function b2MixFriction_28float_2c_20float_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAPF32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + return Math_fround(Math_sqrt(Math_fround(HEAPF32[$2 + 12 >> 2] * HEAPF32[$2 + 8 >> 2]))); +} + +function b2DistanceJoint__GetReactionTorque_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(0)); +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Fixture____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function b2MassData__b2MassData_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0 + 4 | 0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2PolygonShape__28b2PolygonShape_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function std____2____compressed_pair_elem_std____2____tree_node_b2Fixture__2c_20void____2c_200_2c_20false_____get_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__val__val_28emscripten___EM_VAL__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + $0 = HEAP32[$2 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$2 + 8 >> 2]; + return $0; +} + +function b2WheelJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2WheelJointDef__28b2JointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2PulleyJoint__GetReactionTorque_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(0)); +} + +function b2MouseJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2MouseJointDef__28b2JointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2MotorJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2MotorJointDef__28b2JointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2WheelJointDef_2c_20b2JointDef__28b2WheelJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2MouseJointDef_2c_20b2JointDef__28b2MouseJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2MotorJointDef_2c_20b2JointDef__28b2MotorJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Draw__SetFlags_28unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + HEAP32[HEAP32[$2 + 12 >> 2] + 4 >> 2] = HEAP32[$2 + 8 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2World__2c_20emscripten__internal__AllowedRawPointer_b2Body____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Joint____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function void_20std____2____debug_db_insert_c_5babi_v160004_5d_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2DrawWrapper__28b2DrawWrapper_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2CircleShape__28b2CircleShape_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function emscripten__val___val_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + _emval_decref(HEAP32[$0 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20emscripten__internal__AllowedRawPointer_b2MassData__2c_20float____get_28_29() { + return 27184; +} + +function b2WeldJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2WeldJointDef__28b2JointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2RopeJoint__GetReactionTorque_28float_29_20const($0, $1) { + $0 = $0 | 0; + $1 = Math_fround($1); + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + return Math_fround(Math_fround(0)); +} + +function b2RopeJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2RopeJointDef__28b2JointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Mat22__SetZero_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAPF32[$0 >> 2] = 0; + HEAPF32[$0 + 8 >> 2] = 0; + HEAPF32[$0 + 4 >> 2] = 0; + HEAPF32[$0 + 12 >> 2] = 0; +} + +function b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2WeldJointDef_2c_20b2JointDef__28b2WeldJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2RopeJointDef_2c_20b2JointDef__28b2RopeJointDef__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function void_20std____2____debug_db_erase_c_5babi_v160004_5d_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function emscripten__internal__WrapperBase__setNotifyJSOnDestruction_28bool_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP8[$2 + 11 | 0] = $1; + HEAP8[HEAP32[$2 + 12 >> 2]] = HEAP8[$2 + 11 | 0] & 1; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20float_2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function b2ClipVertex__b2ClipVertex_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2WheelJoint__28b2WheelJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2MouseJoint__28b2MouseJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2MotorJoint__28b2MotorJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function std____2____compressed_pair_elem_std____2__allocator_b2Vec2___2c_201_2c_20false_____get_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20float_2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20bool___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2AABB_20const__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const_____get_28_29() { + return 26224; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointer_emscripten__ret_val____ArgTypeList_b2DrawWrapper__2c_20emscripten__val_____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20float_2c_20int_2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 5; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20float_2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function embind_init_b2_28_29__$_4__operator_20void_20_28__29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 712; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2WeldJoint__28b2WeldJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2RopeJoint__28b2RopeJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2EdgeShape__28b2EdgeShape_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20b2AABB_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function std____2__reverse_iterator_b2Vec2____operator___5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$0 >> 2] - 8; + return $0; +} + +function std____2____compressed_pair_elem_std____2__allocator_int___2c_201_2c_20false_____get_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20b2Vec2_20const_____get_28_29() { + return 25164; +} + +function b2PrismaticJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2PrismaticJoint__28b2Joint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Joint__20emscripten__base_b2Joint___convertPointer_b2PrismaticJoint_2c_20b2Joint__28b2PrismaticJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function __syscall_ret($0) { + var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + if ($0 >>> 0 >= 4294963201) { + wasm2js_i32$0 = __errno_location(), wasm2js_i32$1 = 0 - $0 | 0, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + $0 = -1; + } + return $0; +} + +function void_20std____2____debug_db_invalidate_all_5babi_v160004_5d_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int____29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Vec2_2c_20b2Transform_20const__2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20b2Filter_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__TypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____get_28_29(); +} + +function emscripten__internal__BindingType_unsigned_20short_2c_20void___toWireType_28unsigned_20short_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAPU16[HEAP32[$1 + 12 >> 2] >> 1]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_unsigned_20long_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const_____get_28_29() { + return 25200; +} + +function b2RevoluteJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2RevoluteJoint__28b2Joint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Joint__20emscripten__base_b2Joint___convertPointer_b2RevoluteJoint_2c_20b2Joint__28b2RevoluteJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Joint__20emscripten__base_b2Joint___convertPointer_b2DistanceJoint_2c_20b2Joint__28b2DistanceJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2DistanceJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2DistanceJoint__28b2Joint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______invalidate_iterators_past_5babi_v160004_5d_28b2Vec2__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; +} + +function std____2__reverse_iterator_int____operator___5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 >> 2] = HEAP32[$0 >> 2] - 4; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_std____2__vector_int_2c_20std____2__allocator_int______getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function __wasm_call_ctors() { + _GLOBAL__sub_I_Box2DWebBindings_cpp(); + _GLOBAL__sub_I_b2_block_allocator_cpp(); + _GLOBAL__sub_I_b2_math_cpp(); + _GLOBAL__sub_I_b2_contact_manager_cpp(); + _GLOBAL__sub_I_bind_cpp(); + init_pthread_self(); +} + +function __cxx_global_array_dtor_2($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + b2ContactListener___b2ContactListener_28_29(29700); + __stack_pointer = $1 + 16 | 0; +} + +function std____2____compressed_pair_elem_std____2__allocator_b2Vec2__2c_201_2c_20true_____get_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Transform_20const__2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Filter_20const__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20emscripten__internal__AllowedRawPointer_b2MassData_____get_28_29() { + return 28068; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2FixtureDef__2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const_____get_28_29() { + return 27892; +} + +function b2Shape__20emscripten__base_b2Shape___convertPointer_b2PolygonShape_2c_20b2Shape__28b2PolygonShape__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2PolygonShape__20emscripten__base_b2Shape___convertPointer_b2Shape_2c_20b2PolygonShape__28b2Shape__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2EPAxis__b2EPAxis_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + b2Vec2__b2Vec2_28_29($0); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 5; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 5; +} + +function emscripten__internal__BindingType_unsigned_20long_2c_20void___toWireType_28unsigned_20long_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; +} + +function emscripten__internal__BindingType_b2PrismaticJoint_20const__2c_20void___fromWireType_28b2PrismaticJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2ContactListenerWrapper__2c_20void___fromWireType_28b2ContactListenerWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function embind_init_b2_28_29__$_11__operator_28_29_28b2JointDef__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAP32[HEAP32[$2 + 8 >> 2] + 12 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function b2Shape__20emscripten__base_b2Shape___convertPointer_b2CircleShape_2c_20b2Shape__28b2CircleShape__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2CircleShape__20emscripten__base_b2Shape___convertPointer_b2Shape_2c_20b2CircleShape__28b2Shape__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function void_20std____2____debug_db_insert_c_5babi_v160004_5d_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int____29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2Shape__28b2Shape_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2Joint__28b2Joint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function std____2____compressed_pair_elem_std____2__allocator_int__2c_201_2c_20true_____get_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__val__undefined_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + emscripten__val__val_28emscripten___EM_VAL__29($0, 1); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20float_2c_20bool___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__BindingType_unsigned_20int_2c_20void___toWireType_28unsigned_20int_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; +} + +function emscripten__internal__BindingType_b2RevoluteJoint_20const__2c_20void___fromWireType_28b2RevoluteJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2RayCastCallbackWrapper__2c_20void___toWireType_28b2RayCastCallbackWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2DistanceJoint_20const__2c_20void___fromWireType_28b2DistanceJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2ContactListenerWrapper__2c_20void___toWireType_28b2ContactListenerWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2ContactListener_____get_28_29() { + return 26768; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20emscripten__internal__AllowedRawPointer_b2MassData_____get_28_29() { + return 28336; +} + +function embind_init_b2_28_29__$_9__operator_28_29_28b2JointDef__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAP32[HEAP32[$2 + 8 >> 2] + 8 >> 2]; +} + +function b2Vec2__operator_28_29_28int_29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAPF32[HEAP32[$2 + 12 >> 2] + (HEAP32[$2 + 8 >> 2] << 2) >> 2]; +} + +function void_20std____2____debug_db_erase_c_5babi_v160004_5d_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int____29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20bool___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20unsigned_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Shape__Type_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const_____get_28_29() { + return 26256; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_unsigned_20long_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int___20const_____get_28_29() { + return 25072; +} + +function b2WheelJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2WheelJoint__28b2Joint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2MouseJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2MouseJoint__28b2Joint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2MotorJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2MotorJoint__28b2Joint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Joint__20emscripten__base_b2Joint___convertPointer_b2WheelJoint_2c_20b2Joint__28b2WheelJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Joint__20emscripten__base_b2Joint___convertPointer_b2MouseJoint_2c_20b2Joint__28b2MouseJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Joint__20emscripten__base_b2Joint___convertPointer_b2MotorJoint_2c_20b2Joint__28b2MotorJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Filter__b2Filter_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP16[$0 >> 1] = 1; + HEAP16[$0 + 2 >> 1] = 65535; + HEAP16[$0 + 4 >> 1] = 0; + return $0; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2Draw__28b2Draw_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[HEAP32[$1 + 12 >> 2] >> 2] - 4 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20bool___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__GenericBindingType_b2RayCastCallbackWrapper___fromWireType_28b2RayCastCallbackWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__GenericBindingType_b2ContactListenerWrapper___fromWireType_28b2ContactListenerWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2PolygonShape_20const__2c_20void___fromWireType_28b2PolygonShape_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int____2c_20int_20const_____get_28_29() { + return 25044; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const_____get_28_29() { + return 27696; +} + +function embind_init_b2_28_29__$_6__operator_28_29_28b2FixtureDef__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAP32[HEAP32[$2 + 8 >> 2] >> 2]; +} + +function embind_init_b2_28_29__$_3__operator_28_29_28b2Shape__29_20const($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAPF32[HEAP32[$2 + 8 >> 2] + 8 >> 2]; +} + +function b2Draw__20emscripten__base_b2Draw___convertPointer_b2DrawWrapper_2c_20b2Draw__28b2DrawWrapper__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2DrawWrapper__20emscripten__base_b2Draw___convertPointer_b2Draw_2c_20b2DrawWrapper__28b2Draw__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function __cxx_global_array_dtor($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + b2ContactFilter___b2ContactFilter_28_29(29696); + __stack_pointer = $1 + 16 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2FixtureDef__2c_20b2Shape_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_unsigned_20int_2c_20emscripten__internal__AllowedRawPointer_b2Draw_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Shape__Type_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RayCastCallbackWrapper_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RayCastCallbackWrapper_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2ContactListenerWrapper_20const____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20float_2c_20float_2c_20b2Vec2_20const__2c_20float____get_28_29() { + return 27824; +} + +function b2WeldJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2WeldJoint__28b2Joint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Shape__20emscripten__base_b2Shape___convertPointer_b2EdgeShape_2c_20b2Shape__28b2EdgeShape__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2RopeJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2RopeJoint__28b2Joint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Joint__20emscripten__base_b2Joint___convertPointer_b2WeldJoint_2c_20b2Joint__28b2WeldJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Joint__20emscripten__base_b2Joint___convertPointer_b2RopeJoint_2c_20b2Joint__28b2RopeJoint__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2EdgeShape__20emscripten__base_b2Shape___convertPointer_b2Shape_2c_20b2EdgeShape__28b2Shape__29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function __sindf($0) { + var $1 = 0, $2 = 0; + $1 = $0 * $0; + $2 = $1 * $0; + return Math_fround($2 * ($1 * $1) * ($1 * 2718311493989822e-21 + -.00019839334836096632) + ($2 * ($1 * .008333329385889463 + -.16666666641626524) + $0)); +} + +function legalstub$dynCall_jiji($0, $1, $2, $3, $4) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $4 = $4 | 0; + $3 = dynCall_jiji($0, $1, $2, $3, $4); + $2 = i64toi32_i32$HIGH_BITS; + setTempRet0($2); + return $3 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__BindingType_b2QueryCallbackWrapper__2c_20void___toWireType_28b2QueryCallbackWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2CircleShape_20const__2c_20void___fromWireType_28b2CircleShape_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const_____get_28_29() { + return 27360; +} +function b2MouseJoint__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + b2Log_28char_20const__2c_20____29(15328, 0); + __stack_pointer = $1 + 16 | 0; +} + +function std____2__vector_int_2c_20std____2__allocator_int______invalidate_iterators_past_5babi_v160004_5d_28int__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; +} + +function std____2____compressed_pair_elem_std____2__allocator_b2Vec2__2c_201_2c_20true_____get_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2AABB__2c_20b2AABB__2c_20b2AABB____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20bool___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2BodyType___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2JointType_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__BindingType_short_2c_20void___toWireType_28short_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAPU16[HEAP32[$1 + 12 >> 2] >> 1] << 16 >> 16; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const_____get_28_29() { + return 27520; +} + +function b2PrismaticJointDef__20emscripten__internal__operator_new_b2PrismaticJointDef__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(72); + b2PrismaticJointDef__b2PrismaticJointDef_28_29($0); + return $0 | 0; +} + +function b2FrictionJoint__SolvePositionConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return 1; +} + +function std____2____compressed_pair_elem_std____2__less_b2Fixture___2c_201_2c_20true_____get_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2Body__2c_20b2MassData_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__GenericBindingType_b2QueryCallbackWrapper___fromWireType_28b2QueryCallbackWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2WheelJoint_20const__2c_20void___fromWireType_28b2WheelJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2MouseJoint_20const__2c_20void___fromWireType_28b2MouseJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2MotorJoint_20const__2c_20void___fromWireType_28b2MotorJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2FixtureDef_20const__2c_20void___fromWireType_28b2FixtureDef_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2____non_trivial_if_true_2c_20std____2__allocator_b2Vec2______non_trivial_if_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2BodyType_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__TypeID_std____2__vector_int_2c_20std____2__allocator_int___2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_std____2__vector_int_2c_20std____2__allocator_int_____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2QueryCallbackWrapper_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2QueryCallbackWrapper_20const____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20emscripten__internal__AllowedRawPointer_b2FixtureDef_____get_28_29() { + return 27904; +} + +function bool_20isfinite_5babi_v160004_5d_float_2c_200__28float_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAPF32[$1 + 12 >> 2] = $0; + return Math_fround(Math_abs(HEAPF32[$1 + 12 >> 2])) < Math_fround(Infinity); +} + +function __ofl_add($0) { + var $1 = 0, $2 = 0; + $1 = __ofl_lock(); + HEAP32[$0 + 56 >> 2] = HEAP32[$1 >> 2]; + $2 = HEAP32[$1 >> 2]; + if ($2) { + HEAP32[$2 + 52 >> 2] = $0; + } + HEAP32[$1 >> 2] = $0; + __ofl_unlock(); + return $0; +} + +function std____2____compressed_pair_elem_std____2__allocator_int__2c_201_2c_20true_____get_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2Joint__2c_20float_2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20bool___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__BindingType_b2WeldJoint_20const__2c_20void___fromWireType_28b2WeldJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2RopeJoint_20const__2c_20void___fromWireType_28b2RopeJoint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2EdgeShape_20const__2c_20void___fromWireType_28b2EdgeShape_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2JointDef__2c_20emscripten__internal__AllowedRawPointer_b2Body_____get_28_29() { + return 28464; +} + +function b2MouseJoint__SolvePositionConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return 1; +} + +function b2MotorJoint__SolvePositionConstraints_28b2SolverData_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return 1; +} + +function b2Joint__Dump_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + b2Dump_28char_20const__2c_20____29(15281, 0); + __stack_pointer = $1 + 16 | 0; +} + +function b2Contact__SetTangentSpeed_28float_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 144 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function std____2__allocator_char___deallocate_5babi_v160004_5d_28char__2c_20unsigned_20long_29($0, $1, $2) { + std____2____libcpp_deallocate_5babi_v160004_5d_28void__2c_20unsigned_20long_2c_20unsigned_20long_29($1, $2, 1); +} + +function std____2____non_trivial_if_true_2c_20std____2__allocator_char______non_trivial_if_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_____get_28_29() { + return 28192; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const_____get_28_29() { + return 27104; +} + +function b2RevoluteJointDef__20emscripten__internal__operator_new_b2RevoluteJointDef__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(64); + b2RevoluteJointDef__b2RevoluteJointDef_28_29($0); + return $0 | 0; +} + +function b2DistanceJointDef__20emscripten__internal__operator_new_b2DistanceJointDef__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(48); + b2DistanceJointDef__b2DistanceJointDef_28_29($0); + return $0 | 0; +} + +function b2Contact__SetRestitution_28float_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 140 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function std____2____non_trivial_if_true_2c_20std____2__allocator_int______non_trivial_if_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20bool___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2World_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__BindingType_b2PrismaticJointDef__2c_20void___toWireType_28b2PrismaticJointDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2JointDef_20const__2c_20void___fromWireType_28b2JointDef_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2Joint_____get_28_29() { + return 26908; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20bool___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2Draw_____get_28_29() { + return 26780; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2Body_____get_28_29() { + return 26860; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Color_20const_____get_28_29() { + return 26192; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2World_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__BindingType_b2RevoluteJointDef__2c_20void___toWireType_28b2RevoluteJointDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2RayCastCallback__2c_20void___fromWireType_28b2RayCastCallback__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Fixture_20const__2c_20void___fromWireType_28b2Fixture_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2DistanceJointDef__2c_20void___toWireType_28b2DistanceJointDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2ContactListener__2c_20void___fromWireType_28b2ContactListener__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2BodyDef_20const__2c_20void___fromWireType_28b2BodyDef_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2AABB__2c_20emscripten__internal__AllowedRawPointer_b2AABB_____get_28_29() { + return 26636; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const_____get_28_29() { + return 25232; +} + +function b2Contact__SetFriction_28float_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAPF32[$2 + 8 >> 2] = $1; + HEAPF32[HEAP32[$2 + 12 >> 2] + 136 >> 2] = HEAPF32[$2 + 8 >> 2]; +} + +function std__get_new_handler_28_29() { + return void_20_28_std____2___28anonymous_20namespace_29____libcpp_atomic_load_5babi_v160004_5d_void_20_28__29_28_29__28void_20_28__20const__29_28_29_2c_20int_29_29_28_29(32756); +} + +function std____2__array_emscripten__internal__GenericWireType_2c_204ul___data_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2__array_emscripten__internal__GenericWireType_2c_203ul___data_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2__array_emscripten__internal__GenericWireType_2c_202ul___data_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2__array_emscripten__internal__GenericWireType_2c_201ul___data_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Shape_20const__2c_20b2FixtureDef____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2PrismaticJointDef_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2PrismaticJointDef_20const____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool____get_28_29() { + return 28272; +} + +function b2Island__Clear_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 + 28 >> 2] = 0; + HEAP32[$0 + 36 >> 2] = 0; + HEAP32[$0 + 32 >> 2] = 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2JointDef__2c_20b2Body____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__BindingType_b2PrismaticJoint__2c_20void___fromWireType_28b2PrismaticJoint__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2BlockAllocator__2c_20void___fromWireType_28b2BlockAllocator__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20unsigned_20int_2c_20int_2c_20b2Color_20const_____get_28_29() { + return 26160; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20unsigned_20int_2c_20unsigned_20int____get_28_29() { + return 25840; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__val_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long____get_28_29() { + return 25208; +} + +function std____2____unwrap_iter_impl_char_20const__2c_20true_____unwrap_5babi_v160004_5d_28char_20const__29($0) { + return char_20const__20std____2____to_address_5babi_v160004_5d_char_20const__28char_20const__29($0); +} + +function std____2____tree_node_base_void______parent_unsafe_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 8 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RevoluteJointDef_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RevoluteJointDef_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2DistanceJointDef_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2DistanceJointDef_20const____get_28_29(); +} + +function emscripten__internal__BindingType_unsigned_20short_2c_20void___fromWireType_28unsigned_20short_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP16[$1 + 14 >> 1] = $0; + return HEAPU16[$1 + 14 >> 1]; +} + +function __wasi_syscall_ret($0) { + var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + if (!$0) { + return 0; + } + wasm2js_i32$0 = __errno_location(), wasm2js_i32$1 = $0, HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; + return -1; +} + +function std____2____tree_key_value_types_b2Fixture______get_key_5babi_v160004_5d_28b2Fixture__20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2____compressed_pair_elem_unsigned_20long_2c_200_2c_20false_____get_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2____compressed_pair_elem_b2Vec2__2c_200_2c_20false_____get_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__BindingType_b2World_20const__2c_20void___fromWireType_28b2World_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Shape_20const__2c_20void___fromWireType_28b2Shape_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2RevoluteJoint__2c_20void___fromWireType_28b2RevoluteJoint__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2RayCastOutput__2c_20void___fromWireType_28b2RayCastOutput__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2QueryCallback__2c_20void___fromWireType_28b2QueryCallback__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Joint_20const__2c_20void___fromWireType_28b2Joint_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2DistanceJoint__2c_20void___fromWireType_28b2DistanceJoint__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RayCastCallback_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RayCastCallback_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2ContactListener_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2ContactListener_20const____get_28_29(); +} + +function emscripten__internal__BindingType_float_2c_20void___toWireType_28float_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAPF32[HEAP32[$1 + 12 >> 2] >> 2]; +} + +function b2Vec3__SetZero_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAPF32[$0 >> 2] = 0; + HEAPF32[$0 + 4 >> 2] = 0; + HEAPF32[$0 + 8 >> 2] = 0; +} + +function b2PrismaticJoint__GetReferenceAngle_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 100 >> 2]); +} + +function _embind_initialize_bindings() { + var $0 = 0; + $0 = HEAP32[7752]; + if ($0) { + while (1) { + FUNCTION_TABLE[HEAP32[$0 >> 2]](); + $0 = HEAP32[$0 + 4 >> 2]; + if ($0) { + continue; + } + break; + } + } +} + +function ManifoldPointGetTangentImpulse_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 12 >> 2]); +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2AABB__2c_20b2AABB____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__BindingType_unsigned_20long_2c_20void___fromWireType_28unsigned_20long_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2WheelJointDef__2c_20void___toWireType_28b2WheelJointDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Shape_20const__2c_20void___toWireType_28b2Shape_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2PolygonShape__2c_20void___fromWireType_28b2PolygonShape__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2MouseJointDef__2c_20void___toWireType_28b2MouseJointDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2MotorJointDef__2c_20void___toWireType_28b2MotorJointDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Draw_20const__2c_20void___fromWireType_28b2Draw_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Body_20const__2c_20void___fromWireType_28b2Body_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2AABB_20const__2c_20void___fromWireType_28b2AABB_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Shape__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_____get_28_29() { + return 27960; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2JointDef_____get_28_29() { + return 28476; +} + +function b2Vec2__operator_28_29_28int_29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; + return HEAP32[$2 + 12 >> 2] + (HEAP32[$2 + 8 >> 2] << 2) | 0; +} + +function b2RevoluteJoint__GetReferenceAngle_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 120 >> 2]); +} + +function b2RevoluteJoint__GetMaxMotorTorque_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 108 >> 2]); +} + +function b2PrismaticJoint__GetMaxMotorForce_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 132 >> 2]); +} + +function std____2____compressed_pair_elem_int__2c_200_2c_20false_____get_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_void_2c_20b2Shape__2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RayCastCallbackWrapper__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RayCastCallbackWrapper____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2PrismaticJoint_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2ContactListenerWrapper____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Fixture__2c_20emscripten__internal__AllowedRawPointer_b2Body_____get_28_29() { + return 28420; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_____get_28_29() { + return 28016; +} + +function b2MotorJoint__GetCorrectionFactor_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 100 >> 2]); +} + +function ManifoldPointGetNormalImpulse_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 8 >> 2]); +} + +function ManifoldGetLocalNormalValueY_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 44 >> 2]); +} + +function ManifoldGetLocalNormalValueX_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 40 >> 2]); +} + +function std____2____unwrap_iter_impl_char__2c_20true_____rewrap_5babi_v160004_5d_28char__2c_20char__29($0, $1) { + return ($1 - char__20std____2____to_address_5babi_v160004_5d_char__28char__29($0) | 0) + $0 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Joint____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__BindingType_unsigned_20int_2c_20void___fromWireType_28unsigned_20int_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2WeldJointDef__2c_20void___toWireType_28b2WeldJointDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2RopeJointDef__2c_20void___toWireType_28b2RopeJointDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2PolygonShape__2c_20void___toWireType_28b2PolygonShape__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__val_2c_20std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long____get_28_29() { + return 25080; +} + +function WorldManifoldGetNormalValueY_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 4 >> 2]); +} + +function ManifoldGetLocalPointValueY_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 52 >> 2]); +} + +function ManifoldGetLocalPointValueX_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 48 >> 2]); +} + +function std____2__array_emscripten__internal__GenericWireType_2c_204ul___data_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2__array_emscripten__internal__GenericWireType_2c_203ul___data_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2__array_emscripten__internal__GenericWireType_2c_202ul___data_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2__array_emscripten__internal__GenericWireType_2c_201ul___data_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 4; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WheelJointDef_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2WheelJointDef_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RevoluteJoint_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2QueryCallback_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2QueryCallback_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MouseJointDef_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2MouseJointDef_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MotorJointDef_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2MotorJointDef_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2DistanceJoint_20const____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2World__2c_20emscripten__internal__AllowedRawPointer_b2Body_____get_28_29() { + return 28428; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2Body__2c_20emscripten__internal__AllowedRawPointer_b2Joint_____get_28_29() { + return 28508; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const_____get_28_29() { + return 25104; +} + +function b2WheelJoint__GetMaxMotorTorque_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 132 >> 2]); +} + +function b2WheelJointDef__20emscripten__internal__operator_new_b2WheelJointDef__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(76); + b2WheelJointDef__b2WheelJointDef_28_29($0); + return $0 | 0; +} + +function b2PrismaticJoint__GetUpperLimit_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 128 >> 2]); +} + +function b2PrismaticJoint__GetMotorSpeed_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 136 >> 2]); +} + +function b2PrismaticJoint__GetLowerLimit_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 124 >> 2]); +} + +function b2MouseJointDef__20emscripten__internal__operator_new_b2MouseJointDef__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(40); + b2MouseJointDef__b2MouseJointDef_28_29($0); + return $0 | 0; +} + +function b2MotorJointDef__20emscripten__internal__operator_new_b2MotorJointDef__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(44); + b2MotorJointDef__b2MotorJointDef_28_29($0); + return $0 | 0; +} + +function ManifoldPointGetLocalPointY_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 4 >> 2]); +} + +function emscripten__internal__GenericBindingType_b2RayCastInput___fromWireType_28b2RayCastInput__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_int_2c_20void___toWireType_28int_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; +} + +function emscripten__internal__BindingType_b2WheelJoint__2c_20void___fromWireType_28b2WheelJoint__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2MouseJoint__2c_20void___fromWireType_28b2MouseJoint__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2MotorJoint__2c_20void___fromWireType_28b2MotorJoint__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2FixtureDef__2c_20void___fromWireType_28b2FixtureDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2DrawWrapper__2c_20void___toWireType_28b2DrawWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2CircleShape__2c_20void___toWireType_28b2CircleShape__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2RevoluteJoint__GetUpperLimit_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 128 >> 2]); +} + +function b2RevoluteJoint__GetMotorSpeed_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 112 >> 2]); +} + +function b2RevoluteJoint__GetLowerLimit_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 124 >> 2]); +} + +function b2Alloc_28int_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + $0 = dlmalloc(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; + return $0; +} + +function std____2____compressed_pair_elem_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______rep_2c_200_2c_20false_____get_5babi_v160004_5d_28_29($0) { + return $0; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WeldJointDef_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2WeldJointDef_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RopeJointDef_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RopeJointDef_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2QueryCallbackWrapper__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2QueryCallbackWrapper____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2PolygonShape_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2PolygonShape_20const____get_28_29(); +} + +function b2WeldJoint__GetReferenceAngle_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 96 >> 2]); +} + +function b2MotorJoint__GetAngularOffset_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 76 >> 2]); +} + +function std____2____tree_key_value_types_b2Fixture______get_ptr_5babi_v160004_5d_28b2Fixture___29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2____compressed_pair_elem_b2Vec2__2c_200_2c_20false_____get_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2Body__2c_20b2JointDef____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__GenericBindingType_b2DrawWrapper___fromWireType_28b2DrawWrapper__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2WeldJoint__2c_20void___fromWireType_28b2WeldJoint__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2RopeJoint__2c_20void___fromWireType_28b2RopeJoint__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2FixtureDef__2c_20void___toWireType_28b2FixtureDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_______get_28_29() { + return 25160; +} + +function b2PolygonShape__20emscripten__internal__operator_new_b2PolygonShape__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(152); + b2PolygonShape__b2PolygonShape_28_29($0); + return $0 | 0; +} + +function b2MouseJoint__GetDampingRatio_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 88 >> 2]); +} + +function b2DistanceJoint__GetStiffness_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 68 >> 2]); +} + +function __cosdf($0) { + var $1 = 0; + $0 = $0 * $0; + $1 = $0 * $0; + return Math_fround($0 * $1 * ($0 * 2439044879627741e-20 + -.001388676377460993) + ($1 * .04166662332373906 + ($0 * -.499999997251031 + 1))); +} + +function WorldManifoldGetNormalValueX_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] >> 2]); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2DrawWrapper_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2DrawWrapper_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2CircleShape_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2CircleShape_20const____get_28_29(); +} + +function emscripten__internal__BindingType_short_2c_20void___fromWireType_28short_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP16[$1 + 14 >> 1] = $0; + return HEAPU16[$1 + 14 >> 1] << 16 >> 16; +} + +function char_20const__20std____2____to_address_5babi_v160004_5d_char_20const__28char_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2WheelJoint__GetMotorSpeed_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 136 >> 2]); +} + +function b2WeldJointDef__20emscripten__internal__operator_new_b2WeldJointDef__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(48); + b2WeldJointDef__b2WeldJointDef_28_29($0); + return $0 | 0; +} + +function b2RopeJointDef__20emscripten__internal__operator_new_b2RopeJointDef__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(40); + b2RopeJointDef__b2RopeJointDef_28_29($0); + return $0 | 0; +} + +function ManifoldPointGetLocalPointX_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] >> 2]); +} + +function std____2__pointer_traits_char_20const____pointer_to_5babi_v160004_5d_28char_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2World__2c_20b2Vec2_____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__BindingType_b2MassData__2c_20void___fromWireType_28b2MassData__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2JointDef__2c_20void___fromWireType_28b2JointDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2WheelJoint__GetStiffness_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 144 >> 2]); +} + +function b2DistanceJoint__GetLength_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 104 >> 2]); +} + +function b2DistanceJoint__GetDamping_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 72 >> 2]); +} + +function unsigned_20long_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______align_it_5babi_v160004_5d_16ul__28unsigned_20long_29($0) { + return $0 + 15 & -16; +} + +function std____2____throw_length_error_5babi_v160004_5d_28char_20const__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + abort(); + wasm2js_trap(); +} + +function std____2____compressed_pair_elem_int__2c_200_2c_20false_____get_5babi_v160004_5d_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WheelJoint_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2WheelJoint_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MouseJoint_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2MouseJoint_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MotorJoint_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2MotorJoint_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2FixtureDef_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2FixtureDef_20const____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20unsigned_20int____get_28_29() { + return 25900; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20unsigned_20int____get_28_29() { + return 25928; +} + +function b2MouseJoint__GetMaxForce_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 104 >> 2]); +} + +function b2MouseJoint__GetFrequency_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 84 >> 2]); +} + +function b2MotorJoint__GetMaxTorque_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 96 >> 2]); +} + +function b2Body__IsSleepingAllowed_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return (HEAPU16[HEAP32[$1 + 12 >> 2] + 4 >> 1] & 4) == 4 | 0; +} + +function b2Body__IsFixedRotation_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return (HEAPU16[HEAP32[$1 + 12 >> 2] + 4 >> 1] & 16) == 16 | 0; +} + +function b2Body__GetAngularVelocity_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 72 >> 2]); +} + +function b2Body__GetAngularDamping_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 136 >> 2]); +} + +function std____2__reverse_iterator_b2Vec2____base_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2PrismaticJointDef____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__GenericBindingType_b2Transform___fromWireType_28b2Transform__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__EnumBindingType_b2Shape__Type___fromWireType_28b2Shape__Type_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2JointDef__2c_20void___toWireType_28b2JointDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Fixture__2c_20void___fromWireType_28b2Fixture__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2WheelJoint__GetDamping_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 148 >> 2]); +} + +function b2WeldJoint__GetStiffness_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 68 >> 2]); +} + +function b2RopeJoint__GetMaxLength_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 84 >> 2]); +} + +function b2MotorJoint__GetMaxForce_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 92 >> 2]); +} + +function b2Fixture__GetRestitution_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 20 >> 2]); +} + +function b2Body__GetLinearDamping_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 132 >> 2]); +} + +function void_20_28_std____2___28anonymous_20namespace_29____libcpp_atomic_load_5babi_v160004_5d_void_20_28__29_28_29__28void_20_28__20const__29_28_29_2c_20int_29_29_28_29($0) { + return HEAP32[$0 >> 2]; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_float_2c_20b2Shape____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2RevoluteJointDef____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2DistanceJointDef____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WeldJoint_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2WeldJoint_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RopeJoint_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2PrismaticJointDef__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2PrismaticJointDef____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2EdgeShape_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2EdgeShape_20const____get_28_29(); +} + +function emscripten__internal__GenericWireTypeConverter_float___from_28double_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAPF64[$1 + 8 >> 3] = $0; + return Math_fround(HEAPF64[$1 + 8 >> 3]); +} + +function b2CircleShape__20emscripten__internal__operator_new_b2CircleShape__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(20); + b2CircleShape__b2CircleShape_28_29($0); + return $0 | 0; +} + +function b2Body__GetGravityScale_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 140 >> 2]); +} + +function __DOUBLE_BITS($0) { + var $1 = 0, $2 = 0; + wasm2js_scratch_store_f64(+$0); + $1 = wasm2js_scratch_load_i32(1) | 0; + $2 = wasm2js_scratch_load_i32(0) | 0; + i64toi32_i32$HIGH_BITS = $1; + return $2; +} + +function emscripten__internal__GenericBindingType_b2MassData___fromWireType_28b2MassData__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__EnumBindingType_b2Shape__Type___toWireType_28b2Shape__Type_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Fixture__2c_20void___toWireType_28b2Fixture__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2BodyDef__2c_20void___toWireType_28b2BodyDef__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_std____2__vector_int_2c_20std____2__allocator_int_______get_28_29() { + return 25040; +} + +function b2WeldJoint__GetDamping_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 72 >> 2]); +} + +function std____2__reverse_iterator_int____base_5babi_v160004_5d_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; +} + +function emscripten__internal__WrapperBase__WrapperBase_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP8[$0 | 0] = 0; + return $0; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RevoluteJointDef__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RevoluteJointDef____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2JointDef_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2JointDef_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2DistanceJointDef__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2DistanceJointDef____get_28_29(); +} + +function b2RopeJoint__GetLength_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 88 >> 2]); +} + +function b2Fixture__GetFriction_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 16 >> 2]); +} + +function b2Draw__b2Draw_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 >> 2] = 18192; + HEAP32[$0 + 4 >> 2] = 0; + return $0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2WheelJointDef____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2MouseJointDef____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2MotorJointDef____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int__2c_20unsigned_20int____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__EnumBindingType_b2JointType___fromWireType_28b2JointType_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2World__2c_20void___fromWireType_28b2World__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Shape__2c_20void___fromWireType_28b2Shape__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Joint__2c_20void___fromWireType_28b2Joint__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2PrismaticJoint__IsMotorEnabled_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP8[HEAP32[$1 + 12 >> 2] + 141 | 0] & 1; +} + +function b2PrismaticJoint__IsLimitEnabled_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP8[HEAP32[$1 + 12 >> 2] + 140 | 0] & 1; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2WeldJointDef____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2RopeJointDef____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2PolygonShape____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RayCastCallback__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RayCastCallback____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Fixture_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2ContactListener____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2BodyDef_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2BodyDef_20const____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20float_2c_20float____get_28_29() { + return 29056; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20float____get_28_29() { + return 28208; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20b2Vec2_20const_____get_28_29() { + return 28024; +} + +function b2RevoluteJoint__IsMotorEnabled_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP8[HEAP32[$1 + 12 >> 2] + 104 | 0] & 1; +} + +function b2RevoluteJoint__IsLimitEnabled_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP8[HEAP32[$1 + 12 >> 2] + 116 | 0] & 1; +} + +function b2FixtureDef__20emscripten__internal__operator_new_b2FixtureDef__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(28); + b2FixtureDef__b2FixtureDef_28_29($0); + return $0 | 0; +} + +function b2ContactListener__BeginContact_28unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; +} + +function b2Body__IsEnabled_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return (HEAPU16[HEAP32[$1 + 12 >> 2] + 4 >> 1] & 32) == 32 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_unsigned_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2CircleShape____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int_2c_20unsigned_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__GenericBindingType_b2Filter___fromWireType_28b2Filter__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__EnumBindingType_b2JointType___toWireType_28b2JointType_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__EnumBindingType_b2BodyType___fromWireType_28b2BodyType_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2World__2c_20void___toWireType_28b2World__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Shape__2c_20void___toWireType_28b2Shape__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Joint__2c_20void___toWireType_28b2Joint__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Draw__2c_20void___fromWireType_28b2Draw__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Body__2c_20void___fromWireType_28b2Body__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2AABB__2c_20void___fromWireType_28b2AABB__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20float_2c_20float____get_28_29() { + return 29232; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2ContactListener__2c_20unsigned_20int____get_28_29() { + return 25820; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const__2c_20bool____get_28_29() { + return 28304; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2RayCastCallbackWrapper__2c_20emscripten__val______get_28_29() { + return 25692; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2ContactListenerWrapper__2c_20emscripten__val______get_28_29() { + return 25964; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20b2Vec2_20const_____get_28_29() { + return 28368; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2AABB_20const__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const__2c_20int____get_28_29() { + return 28100; +} + +function b2Transform__20emscripten__internal__raw_constructor_b2Transform__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(16); + b2Transform__b2Transform_28_29($0); + return $0 | 0; +} + +function b2Contact__FlagForFiltering_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] | 8; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2FixtureDef____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__WithPolicies____ArgTypeList_unsigned_20int_2c_20unsigned_20int_2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2PrismaticJoint____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20float_2c_20int_2c_20int____get_28_29() { + return 26928; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20float_2c_20float____get_28_29() { + return 27808; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const__2c_20float____get_28_29() { + return 29084; +} + +function b2RayCastCallback__b2RayCastCallback_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 >> 2] = 25748; + return $0; +} + +function b2ContactListener__b2ContactListener_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 >> 2] = 26044; + return $0; +} + +function b2ContactListener__EndContact_28unsigned_20int_29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; +} + +function emscripten__internal__GenericBindingType_b2Color___fromWireType_28b2Color__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__EnumBindingType_b2BodyType___toWireType_28b2BodyType_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_float_2c_20void___fromWireType_28float_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAPF32[$1 + 12 >> 2] = $0; + return HEAPF32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2Body__2c_20void___toWireType_28b2Body__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_b2AABB__2c_20void___toWireType_28b2AABB__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const__2c_20float____get_28_29() { + return 29260; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2QueryCallbackWrapper__2c_20emscripten__val______get_28_29() { + return 25440; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2QueryCallback__2c_20unsigned_20int____get_28_29() { + return 25336; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20b2AABB_20const_____get_28_29() { + return 26672; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const_____get_28_29() { + return 29016; +} + +function b2World__GetAllowSleeping_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP8[HEAP32[$1 + 12 >> 2] + 102972 | 0] & 1; +} + +function b2WheelJoint__IsMotorEnabled_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP8[HEAP32[$1 + 12 >> 2] + 141 | 0] & 1; +} + +function b2Body__IsBullet_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return (HEAPU16[HEAP32[$1 + 12 >> 2] + 4 >> 1] & 8) == 8 | 0; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2JointDef____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2World_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2World_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WheelJointDef__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2WheelJointDef____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Shape_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Shape_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RevoluteJoint____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2QueryCallback__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2QueryCallback____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MouseJointDef__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2MouseJointDef____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MotorJointDef__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2MotorJointDef____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Joint_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2DistanceJoint__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2DistanceJoint____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const_____get_28_29() { + return 29184; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const_____get_28_29() { + return 28644; +} + +function b2Joint__GetCollideConnected_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP8[HEAP32[$1 + 12 >> 2] + 61 | 0] & 1; +} + +function b2Fixture__GetDensity_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] >> 2]); +} + +function b2Body__IsAwake_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return (HEAPU16[HEAP32[$1 + 12 >> 2] + 4 >> 1] & 2) == 2 | 0; +} + +function b2Body__GetMass_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 116 >> 2]); +} + +function b2Body__GetAngle_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return Math_fround(HEAPF32[HEAP32[$1 + 12 >> 2] + 56 >> 2]); +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2BodyDef____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__GenericWireTypeConverter_bool___from_28double_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAPF64[$1 + 8 >> 3] = $0; + return HEAPF64[$1 + 8 >> 3] != 0; +} + +function emscripten__internal__GenericBindingType_b2Vec2___fromWireType_28b2Vec2__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__GenericBindingType_b2AABB___fromWireType_28b2AABB__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20b2Vec2_20const_____get_28_29() { + return 28888; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20b2Vec2_20const_____get_28_29() { + return 28760; +} + +function std____2__allocator_std____2____tree_node_b2Fixture__2c_20void_____max_size_5babi_v160004_5d_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 214748364; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WeldJointDef__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2WeldJointDef____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RopeJointDef__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RopeJointDef____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2PolygonShape__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2PolygonShape____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Draw_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Draw_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Body_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Body_20const____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2AABB_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2AABB_20const____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20b2Filter_20const_____get_28_29() { + return 27988; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20b2Transform_20const_____get_28_29() { + return 26276; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const__2c_20float____get_28_29() { + return 29664; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20float____get_28_29() { + return 29368; +} + +function b2QueryCallback__b2QueryCallback_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 >> 2] = 25496; + return $0; +} + +function ContactImpulseGetCount_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 16 >> 2]; +} + +function emscripten__internal__GenericBindingType_b2Rot___fromWireType_28b2Rot__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_bool_2c_20void___fromWireType_28bool_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP8[$1 + 15 | 0] = $0; + return HEAP8[$1 + 15 | 0] & 1; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2MassData_20const_____get_28_29() { + return 28348; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const__2c_20float____get_28_29() { + return 29380; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const_____get_28_29() { + return 29616; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_20const_____get_28_29() { + return 28900; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_20const_____get_28_29() { + return 28772; +} + +function b2Free_28void__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + __stack_pointer = $1; + HEAP32[$1 + 12 >> 2] = $0; + dlfree(HEAP32[$1 + 12 >> 2]); + __stack_pointer = $1 + 16 | 0; +} + +function ManifoldGetPointCount_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 60 >> 2]; +} + +function init_pthread_self() { + var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0; + HEAP32[8054] = 31056; + wasm2js_i32$0 = 32144, wasm2js_i32$1 = getpid(), HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1; +} + +function emscripten__internal__WithPolicies_emscripten__allow_raw_pointers___ArgTypeList_b2AABB____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2DrawWrapper__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2DrawWrapper____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2CircleShape__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2CircleShape____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_20const_____get_28_29() { + return 29500; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const_____get_28_29() { + return 29360; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Transform_20const__2c_20emscripten__internal__AllowedRawPointer_b2Body_20const_____get_28_29() { + return 28224; +} + +function b2JointDef__20emscripten__internal__operator_new_b2JointDef__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(20); + b2JointDef__b2JointDef_28_29($0); + return $0 | 0; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2PrismaticJointDef__28b2PrismaticJointDef_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 28936; +} + +function emscripten__internal__BindingType_int_2c_20void___fromWireType_28int_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__BindingType_bool_2c_20void___toWireType_28bool_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP8[$1 + 15 | 0] = $0; + return HEAP8[$1 + 15 | 0] & 1; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Joint__2c_20float_2c_20float____get_28_29() { + return 24832; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Vec2_20const__2c_20b2Color_20const_____get_28_29() { + return 26512; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20unsigned_20int__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_____get_28_29() { + return 25760; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Filter_20const__2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const_____get_28_29() { + return 28e3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int_2c_20float___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2RayCastCallbackWrapper____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2ContactListenerWrapper____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2WheelJoint____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2MouseJoint____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2MotorJoint____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2FixtureDef__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2FixtureDef____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20b2Vec2_20const_____get_28_29() { + return 27016; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20float____get_28_29() { + return 28524; +} + +function b2Vec2__20std____2____to_address_5babi_v160004_5d_b2Vec2__28b2Vec2__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2PrismaticJoint__GetLocalAnchorB_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 76 | 0; +} + +function b2PrismaticJoint__GetLocalAnchorA_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 68 | 0; +} + +function b2Joint__ShiftOrigin_28b2Vec2_20const__29($0, $1) { + $0 = $0 | 0; + $1 = $1 | 0; + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2RevoluteJointDef__28b2RevoluteJointDef_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 29104; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2DistanceJointDef__28b2DistanceJointDef_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 28564; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int_2c_20bool___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__WithPolicies____ArgTypeList_unsigned_20int_2c_20unsigned_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20unsigned_20int_2c_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 3; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20float____get_28_29() { + return 29072; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20float_2c_20bool____get_28_29() { + return 28320; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2Vec2_20const_____get_28_29() { + return 28248; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const__2c_20float____get_28_29() { + return 28536; +} + +function embind_init_b2_28_29__$_5__operator_20void_20_28__29_28b2FixtureDef__2c_20b2Shape_20const__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 713; +} + +function b2Vec2__SetZero_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAPF32[$0 >> 2] = 0; + HEAPF32[$0 + 4 >> 2] = 0; +} + +function b2RevoluteJoint__GetLocalAnchorB_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 76 | 0; +} + +function b2RevoluteJoint__GetLocalAnchorA_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 68 | 0; +} + +function b2DistanceJoint__GetLocalAnchorB_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 88 | 0; +} + +function b2DistanceJoint__GetLocalAnchorA_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 80 | 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2QueryCallbackWrapper____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2WeldJoint__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2WeldJoint____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2RopeJoint__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RopeJoint____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2EdgeShape__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2EdgeShape____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20float____get_28_29() { + return 29248; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint__2c_20bool____get_28_29() { + return 29040; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Draw__2c_20unsigned_20int____get_28_29() { + return 26128; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint__2c_20float____get_28_29() { + return 28652; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2DrawWrapper__2c_20emscripten__val______get_28_29() { + return 26372; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Shape__Type_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const_____get_28_29() { + return 27952; +} + +function b2PrismaticJoint__GetLocalAxisA_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 84 | 0; +} + +function b2BodyDef__20emscripten__internal__operator_new_b2BodyDef__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(52); + b2BodyDef__b2BodyDef_28_29($0); + return $0 | 0; +} + +function __cxxabiv1____fundamental_type_info_____fundamental_type_info_28_29($0) { + $0 = $0 | 0; + operator_20delete_28void__29(__cxxabiv1____shim_type_info_____shim_type_info_28_29($0)); +} + +function std____2__allocator_b2Vec2___destroy_5babi_v160004_5d_28b2Vec2__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint__2c_20bool____get_28_29() { + return 29208; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const_____get_28_29() { + return 29024; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_20const__2c_20emscripten__internal__AllowedRawPointer_b2Body_20const_____get_28_29() { + return 28232; +} + +function embind_init_b2_28_29__$_1__operator_20void_20_28__29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 709; +} + +function b2Fixture__IsSensor_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP8[HEAP32[$1 + 12 >> 2] + 38 | 0] & 1; +} + +function ManifoldGetType_28unsigned_20int_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 56 >> 2]; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2JointDef__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2JointDef____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_unsigned_20int_2c_20emscripten__internal__AllowedRawPointer_b2Draw_20const_____get_28_29() { + return 26140; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const_____get_28_29() { + return 29192; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_20const_____get_28_29() { + return 28664; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_20const_____get_28_29() { + return 29032; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Shape__Type_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const_____get_28_29() { + return 27076; +} + +function embind_init_b2_28_29__$_7__operator_20void_20_28__29_28b2Body__2c_20b2MassData_20const__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 715; +} + +function b2WheelJoint__GetLocalAnchorB_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 76 | 0; +} + +function b2WheelJoint__GetLocalAnchorA_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 68 | 0; +} + +function b2MotorJoint__GetLinearOffset_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 68 | 0; +} + +function b2Filter__20emscripten__internal__raw_constructor_b2Filter__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(6); + b2Filter__b2Filter_28_29($0); + return $0 | 0; +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______fits_in_sso_5babi_v160004_5d_28unsigned_20long_29($0) { + return $0 >>> 0 < 11; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2Transform_20const____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20float____get_28_29() { + return 29652; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint__2c_20float____get_28_29() { + return 28908; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint__2c_20float____get_28_29() { + return 28780; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_20const_____get_28_29() { + return 29200; +} + +function b2WeldJoint__GetLocalAnchorB_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 88 | 0; +} + +function b2WeldJoint__GetLocalAnchorA_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 80 | 0; +} + +function b2RopeJoint__GetLocalAnchorB_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 76 | 0; +} + +function b2RopeJoint__GetLocalAnchorA_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 68 | 0; +} + +function b2GrowableStack_int_2c_20256___GetCount_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 1028 >> 2]; +} + +function std____2__numeric_limits_unsigned_20long___max_5babi_v160004_5d_28_29() { + return std____2____libcpp_numeric_limits_unsigned_20long_2c_20true___max_5babi_v160004_5d_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Fixture__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Fixture____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2BodyDef__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2BodyDef____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint__2c_20bool____get_28_29() { + return 29640; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint__2c_20float____get_28_29() { + return 29516; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint__2c_20float____get_28_29() { + return 29392; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20b2BodyType____get_28_29() { + return 28380; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const_____get_28_29() { + return 27792; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2JointType_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const_____get_28_29() { + return 28500; +} + +function b2WheelJoint__GetLocalAxisA_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 84 | 0; +} + +function __cxxabiv1____vmi_class_type_info_____vmi_class_type_info_28_29($0) { + $0 = $0 | 0; + operator_20delete_28void__29(__cxxabiv1____shim_type_info_____shim_type_info_28_29($0)); +} + +function void_20const__20emscripten__internal__getLightTypeID_b2WheelJointDef__28b2WheelJointDef_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 29536; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2MouseJointDef__28b2MouseJointDef_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 28808; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2MotorJointDef__28b2MotorJointDef_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 28680; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2PolygonShape_20const_____get_28_29() { + return 27664; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const_____get_28_29() { + return 29624; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_20const_____get_28_29() { + return 28920; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_20const_____get_28_29() { + return 28792; +} + +function b2Contact__IsTouching_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return (HEAP32[HEAP32[$1 + 12 >> 2] + 4 >> 2] & 2) == 2; +} + +function b2Color__20emscripten__internal__raw_constructor_b2Color__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(16); + b2Color__b2Color_28_29($0); + return $0 | 0; +} + +function b2Body__GetLinearVelocity_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] - -64 | 0; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20float____get_28_29() { + return 28080; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2CircleShape_20const_____get_28_29() { + return 27348; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_20const_____get_28_29() { + return 29508; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_20const_____get_28_29() { + return 29404; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_20const_____get_28_29() { + return 29632; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2BodyType_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const_____get_28_29() { + return 28392; +} + +function b2Contact__IsEnabled_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return (HEAP32[HEAP32[$1 + 12 >> 2] + 4 >> 2] & 4) == 4; +} + +function __cxxabiv1____si_class_type_info_____si_class_type_info_28_29($0) { + $0 = $0 | 0; + operator_20delete_28void__29(__cxxabiv1____shim_type_info_____shim_type_info_28_29($0)); +} + +function void_20const__20emscripten__internal__getLightTypeID_b2WeldJointDef__28b2WeldJointDef_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 29420; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2RopeJointDef__28b2RopeJointDef_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 29280; +} + +function std____2__allocator_int___destroy_5babi_v160004_5d_28int__29($0, $1) { + var $2 = 0; + $2 = __stack_pointer - 16 | 0; + HEAP32[$2 + 12 >> 2] = $0; + HEAP32[$2 + 8 >> 2] = $1; +} + +function int__20std____2____to_address_5babi_v160004_5d_int__28int__29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20bool____get_28_29() { + return 27968; +} + +function b2Shape__GetType_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 4 >> 2]; +} + +function b2Joint__GetType_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 4 >> 2]; +} + +function b2Fixture__GetFilterData_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 32 | 0; +} + +function b2Draw__GetFlags_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 4 >> 2]; +} + +function b2Body__GetFixtureList_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 100 >> 2]; +} + +function std____2__array_emscripten__internal__GenericWireType_2c_200ul___data_5babi_v160004_5d_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_float_2c_20unsigned_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20unsigned_20int____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2World__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2World____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Shape__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Shape____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Joint__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Joint____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Shape__2c_20float____get_28_29() { + return 27216; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture__2c_20int____get_28_29() { + return 28112; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2EdgeShape_20const_____get_28_29() { + return 27500; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const_____get_28_29() { + return 28092; +} + +function double_20emscripten__internal__asGenericValue_int__28int_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return +HEAP32[$1 + 12 >> 2]; +} + +function b2MouseJoint__GetTarget_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 76 | 0; +} + +function b2Contact__GetTangentSpeed_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAPF32[HEAP32[$1 + 12 >> 2] + 144 >> 2]; +} + +function __cxxabiv1____pointer_type_info_____pointer_type_info_28_29($0) { + $0 = $0 | 0; + operator_20delete_28void__29(__cxxabiv1____shim_type_info_____shim_type_info_28_29($0)); +} + +function std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char______begin_lifetime_5babi_v160004_5d_28char__2c_20unsigned_20long_29($0, $1) {} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20unsigned_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void_2c_20b2DrawWrapper____getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__WithPolicies____ArgTypeList_bool_2c_20unsigned_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World__2c_20bool____get_28_29() { + return 26996; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20float____get_28_29() { + return 28260; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const_____get_28_29() { + return 26544; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_20const_____get_28_29() { + return 27980; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2World_20const_____get_28_29() { + return 27028; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const_____get_28_29() { + return 28516; +} + +function embind_init_b2_28_29__$_6__operator_20b2Shape_20const__20_28__29_28b2FixtureDef__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 714; +} + +function embind_init_b2_28_29__$_10__operator_20void_20_28__29_28b2JointDef__2c_20b2Body__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 718; +} + +function b2Contact__GetRestitution_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAPF32[HEAP32[$1 + 12 >> 2] + 140 >> 2]; +} + +function b2Body__GetWorldCenter_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 44 | 0; +} + +function b2Body__GetLocalCenter_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 28 | 0; +} + +function std____2____unwrap_iter_impl_char__2c_20true_____unwrap_5babi_v160004_5d_28char__29($0) { + return char__20std____2____to_address_5babi_v160004_5d_char__28char__29($0); +} + +function emscripten__internal__WithPolicies____ArgTypeList_int_2c_20unsigned_20int___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 2; +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Draw__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Draw____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2Body__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Body____get_28_29(); +} + +function emscripten__internal__TypeID_emscripten__internal__AllowedRawPointer_b2AABB__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2AABB____get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2PrismaticJoint_____get_28_29() { + return 29096; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body__2c_20bool____get_28_29() { + return 28400; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const_____get_28_29() { + return 26620; +} + +function embind_init_b2_28_29__$_8__operator_20void_20_28__29_28b2JointDef__2c_20b2Body__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 716; +} + +function b2Vec2__20emscripten__internal__raw_constructor_b2Vec2__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(8); + b2Vec2__b2Vec2_28_29($0); + return $0 | 0; +} + +function b2Shape__b2Shape_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + $0 = HEAP32[$1 + 12 >> 2]; + HEAP32[$0 >> 2] = 27280; + return $0; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2FixtureDef__28b2FixtureDef_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 27848; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RevoluteJoint_____get_28_29() { + return 29272; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2DistanceJoint_____get_28_29() { + return 28672; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const_____get_28_29() { + return 28240; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const_____get_28_29() { + return 26628; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2World_20const_____get_28_29() { + return 27008; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Joint_20const_____get_28_29() { + return 28548; +} + +function b2RayCastCallback___b2RayCastCallback_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Fixture__GetShape_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 12 >> 2]; +} + +function b2Contact__GetChildIndexB_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 60 >> 2]; +} + +function b2Contact__GetChildIndexA_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 56 >> 2]; +} + +function b2ContactListener___b2ContactListener_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Body__GetTransform_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 12 | 0; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_int_2c_20emscripten__internal__AllowedRawPointer_b2Shape_20const_____get_28_29() { + return 27084; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2Body_20const_____get_28_29() { + return 28412; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20emscripten__internal__AllowedRawPointer_b2AABB_20const_____get_28_29() { + return 26612; +} + +function b2TreeNode__IsLeaf_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 24 >> 2] == -1; +} + +function b2Contact__GetFriction_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAPF32[HEAP32[$1 + 12 >> 2] + 136 >> 2]; +} + +function b2Body__GetType_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; +} + +function b2Body__GetPosition_28_29_20const($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] + 12 | 0; +} + +function __cxxabiv1____class_type_info_____class_type_info_28_29($0) { + $0 = $0 | 0; + operator_20delete_28void__29(__cxxabiv1____shim_type_info_____shim_type_info_28_29($0)); +} + +function b2World__IsLocked_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP8[HEAP32[$1 + 12 >> 2] + 102989 | 0] & 1; +} + +function b2Joint__GetBodyB_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 52 >> 2]; +} + +function b2Joint__GetBodyA_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 48 >> 2]; +} + +function b2Fixture__GetBody_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 8 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WheelJoint_____get_28_29() { + return 29676; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MouseJoint_____get_28_29() { + return 28928; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2MotorJoint_____get_28_29() { + return 28800; +} + +function embind_init_b2_28_29__$_0__operator_20void_20_28__29_28b2AABB__2c_20b2AABB__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 708; +} + +function b2Rot__20emscripten__internal__raw_constructor_b2Rot__28_29() { + var $0 = 0; + $0 = operator_20new_28unsigned_20long_29(8); + b2Rot__b2Rot_28_29($0); + return $0 | 0; +} + +function b2Body__GetWorld_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 88 >> 2]; +} + +function __cxxabiv1____enum_type_info_____enum_type_info_28_29($0) { + $0 = $0 | 0; + operator_20delete_28void__29(__cxxabiv1____shim_type_info_____shim_type_info_28_29($0)); +} + +function void_20const__20emscripten__internal__getLightTypeID_b2JointDef__28b2JointDef_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 26884; +} + +function emscripten__val__as_handle_28_29_20const($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] >> 2]; +} + +function emscripten__internal__noncopyable___noncopyable_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2WeldJoint_____get_28_29() { + return 29528; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2RopeJoint_____get_28_29() { + return 29412; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2World__2c_20b2Vec2______get_28_29() { + return 26760; +} + +function embind_init_b2_28_29__$_2__operator_20void_20_28__29_28b2Shape__2c_20float_29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 710; +} + +function b2QueryCallback___b2QueryCallback_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2ContactFilter___b2ContactFilter_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2__array_emscripten__internal__GenericWireType_2c_200ul___data_5babi_v160004_5d_28_29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 0; +} + +function emscripten__internal__noncopyable__noncopyable_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__TypeID_b2RayCastCallbackWrapper_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RayCastCallbackWrapper___get_28_29(); +} + +function emscripten__internal__TypeID_b2ContactListenerWrapper_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2ContactListenerWrapper___get_28_29(); +} + +function void_20const__20emscripten__internal__getLightTypeID_b2Fixture__28b2Fixture_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 27912; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2BodyDef__28b2BodyDef_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 26836; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Fixture_____get_28_29() { + return 28008; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2PrismaticJointDef_____get_28_29() { + return 28980; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2Vec2_20const__2c_20float__2c_20b2Color_20const_____get_28_29() { + return 26496; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20emscripten__internal__AllowedRawPointer_b2Shape_____get_28_29() { + return 27228; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2RevoluteJointDef_____get_28_29() { + return 29148; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2DistanceJointDef_____get_28_29() { + return 28608; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2World_____get_28_29() { + return 26792; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Joint_____get_28_29() { + return 28556; +} + +function embind_init_b2_28_29__$_11__operator_20b2Body__20_28__29_28b2JointDef__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 719; +} + +function b2RayCastCallbackWrapper__20_28_emscripten__base_b2RayCastCallback___getDowncaster_b2RayCastCallbackWrapper__28_29_29_28b2RayCastCallback__29() { + return 475; +} + +function b2ContactListenerWrapper__20_28_emscripten__base_b2ContactListener___getDowncaster_b2ContactListenerWrapper__28_29_29_28b2ContactListener__29() { + return 483; +} + +function legalfunc$_embind_register_bigint($0, $1, $2, $3, $4, $5, $6) { + legalimport$_embind_register_bigint($0 | 0, $1 | 0, $2 | 0, $3 | 0, $4 | 0, $5 | 0, $6 | 0); +} + +function emscripten__internal__TypeID_b2QueryCallbackWrapper_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2QueryCallbackWrapper___get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int__2c_20int__2c_20b2Color_20const_____get_28_29() { + return 26480; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20emscripten__internal__AllowedRawPointer_b2Body_____get_28_29() { + return 28360; +} + +function embind_init_b2_28_29__$_9__operator_20b2Body__20_28__29_28b2JointDef__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 717; +} + +function void_20emscripten__internal__raw_destructor_b2PrismaticJoint__28b2PrismaticJoint__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2World__28b2World_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 26720; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2WheelJointDef_____get_28_29() { + return 29580; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2MouseJointDef_____get_28_29() { + return 28852; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2MotorJointDef_____get_28_29() { + return 28724; +} + +function b2RayCastCallback__20_28_emscripten__base_b2RayCastCallback___getUpcaster_b2RayCastCallbackWrapper__28_29_29_28b2RayCastCallbackWrapper__29() { + return 474; +} + +function b2ContactListener__20_28_emscripten__base_b2ContactListener___getUpcaster_b2ContactListenerWrapper__28_29_29_28b2ContactListenerWrapper__29() { + return 482; +} + +function b2Body__GetContactList_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 112 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2WeldJointDef_____get_28_29() { + return 29464; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2RopeJointDef_____get_28_29() { + return 29324; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2PolygonShape_____get_28_29() { + return 27648; +} + +function b2Contact__GetFixtureB_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 52 >> 2]; +} + +function b2Contact__GetFixtureA_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 48 >> 2]; +} + +function void_20emscripten__internal__raw_destructor_b2RevoluteJoint__28b2RevoluteJoint__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20emscripten__internal__raw_destructor_b2DistanceJoint__28b2DistanceJoint__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2Body__28b2Body_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 26812; +} + +function void_20const__20emscripten__internal__getLightTypeID_b2AABB__28b2AABB_20const__29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 26568; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2CircleShape_____get_28_29() { + return 27268; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2FixtureDef_____get_28_29() { + return 27888; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_b2Vec2_2c_20b2Transform_20const__2c_20b2Vec2_20const_____get_28_29() { + return 24864; +} + +function void_20emscripten__internal__raw_destructor_b2PolygonShape__28b2PolygonShape__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function embind_init_b2_28_29__$_3__operator_20float_20_28__29_28b2Shape__29_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 711; +} + +function std____2__numeric_limits_long___max_5babi_v160004_5d_28_29() { + return std____2____libcpp_numeric_limits_long_2c_20true___max_5babi_v160004_5d_28_29(); +} + +function emscripten__internal__TypeID_b2PrismaticJointDef_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2PrismaticJointDef___get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2JointDef_____get_28_29() { + return 28452; +} + +function b2Contact__GetNext_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 12 >> 2]; +} + +function __stdio_seek($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + $2 = __lseek(HEAP32[$0 + 60 >> 2], $1, $2, $3); + return $2 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2CircleShape__28b2CircleShape__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2BodyDef_____get_28_29() { + return 28140; +} + +function b2QueryCallbackWrapper__20_28_emscripten__base_b2QueryCallback___getDowncaster_b2QueryCallbackWrapper__28_29_29_28b2QueryCallback__29() { + return 470; +} + +function b2Fixture__GetNext_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 4 >> 2]; +} + +function b2Contact___b2Contact_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function _GLOBAL__sub_I_bind_cpp() { + HEAP32[7753] = 957; + HEAP32[7754] = 0; + embind_init_builtin_28_29(); + HEAP32[7754] = HEAP32[7752]; + HEAP32[7752] = 31012; +} + +function emscripten__internal__TypeID_b2RevoluteJointDef_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RevoluteJointDef___get_28_29(); +} + +function emscripten__internal__TypeID_b2DistanceJointDef_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2DistanceJointDef___get_28_29(); +} + +function b2Joint__GetNext_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 12 >> 2]; +} + +function void_20emscripten__internal__raw_destructor_b2WheelJoint__28b2WheelJoint__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20emscripten__internal__raw_destructor_b2MouseJoint__28b2MouseJoint__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20emscripten__internal__raw_destructor_b2MotorJoint__28b2MotorJoint__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20emscripten__internal__raw_destructor_b2FixtureDef__28b2FixtureDef__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28_29_29_28_29() { + return 0; +} + +function emscripten__internal__WithPolicies____ArgTypeList_void___getCount_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float_2c_20float_2c_20int_2c_20float__28_29() { + return 16978; +} + +function b2QueryCallback__20_28_emscripten__base_b2QueryCallback___getUpcaster_b2QueryCallbackWrapper__28_29_29_28b2QueryCallbackWrapper__29() { + return 469; +} + +function b2Body__GetNext_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[HEAP32[$1 + 12 >> 2] + 96 >> 2]; +} + +function emscripten__internal__TypeID_b2RayCastCallback_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RayCastCallback___get_28_29(); +} + +function emscripten__internal__TypeID_b2ContactListener_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2ContactListener___get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_emscripten__internal__AllowedRawPointer_b2AABB_____get_28_29() { + return 26608; +} + +function b2Contact__GetManifold_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2] - -64 | 0; +} + +function void_20emscripten__internal__raw_destructor_b2WeldJoint__28b2WeldJoint__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20emscripten__internal__raw_destructor_b2EdgeShape__28b2EdgeShape__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28_29_29_28_29() { + return 0; +} + +function emscripten__internal__writeGenericWireTypes_28emscripten__internal__GenericWireType___29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int__2c_20unsigned_20int_____get_28_29() { + return 26076; +} + +function b2Shape___b2Shape_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Joint___b2Joint_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function void_20std____2___IterOps_std____2___ClassicAlgPolicy_____validate_iter_reference_5babi_v160004_5d_std____2__reverse_iterator_b2Vec2_____28_29() {} + +function std____2__allocator_b2Vec2___max_size_5babi_v160004_5d_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 536870911; +} + +function emscripten__wrapper_b2RayCastCallback____wrapper_28_29_1($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + wasm2js_trap(); +} + +function emscripten__internal__TypeID_unsigned_20short_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_unsigned_20short___get_28_29(); +} + +function emscripten__internal__TypeID_b2PrismaticJoint_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2PrismaticJoint___get_28_29(); +} + +function char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20float__28_29() { + return 16167; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int_2c_20unsigned_20int____get_28_29() { + return 24948; +} + +function char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20float_2c_20int_2c_20int__28_29() { + return 16535; +} + +function b2Draw___b2Draw_28_29($0) { + $0 = $0 | 0; + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function std____2__allocator_int___max_size_5babi_v160004_5d_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1073741823; +} + +function emscripten__wrapper_b2QueryCallback____wrapper_28_29_1($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + wasm2js_trap(); +} + +function emscripten__internal__TypeID_b2WheelJointDef_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2WheelJointDef___get_28_29(); +} + +function emscripten__internal__TypeID_b2Vec2_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Vec2_20const____get_28_29(); +} + +function emscripten__internal__TypeID_b2RevoluteJoint_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RevoluteJoint___get_28_29(); +} + +function emscripten__internal__TypeID_b2RayCastOutput_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RayCastOutput___get_28_29(); +} + +function emscripten__internal__TypeID_b2QueryCallback_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2QueryCallback___get_28_29(); +} + +function emscripten__internal__TypeID_b2MouseJointDef_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2MouseJointDef___get_28_29(); +} + +function emscripten__internal__TypeID_b2MotorJointDef_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2MotorJointDef___get_28_29(); +} + +function emscripten__internal__TypeID_b2DistanceJoint_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2DistanceJoint___get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_unsigned_20int_2c_20unsigned_20int_2c_20int____get_28_29() { + return 24960; +} + +function void_20std____2___IterOps_std____2___ClassicAlgPolicy_____validate_iter_reference_5babi_v160004_5d_std____2__reverse_iterator_int_____28_29() {} + +function void_20emscripten__internal__raw_destructor_b2BodyDef__28b2BodyDef__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_std____2__vector_int_2c_20std____2__allocator_int____28_29_29_28_29() { + return 0; +} + +function emscripten__internal__TypeID_b2WeldJointDef_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2WeldJointDef___get_28_29(); +} + +function emscripten__internal__TypeID_b2RopeJointDef_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RopeJointDef___get_28_29(); +} + +function emscripten__internal__TypeID_b2RayCastInput_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RayCastInput___get_28_29(); +} + +function emscripten__internal__TypeID_b2PolygonShape_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2PolygonShape___get_28_29(); +} + +function char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() { + return 16808; +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_std____2__vector_int_2c_20std____2__allocator_int____28_29_29_28_29() { + return 0; +} + +function emscripten__internal__TypeID_b2Shape__Type_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Shape__Type___get_28_29(); +} + +function emscripten__internal__TypeID_b2DrawWrapper_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2DrawWrapper___get_28_29(); +} + +function emscripten__internal__TypeID_b2CircleShape_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2CircleShape___get_28_29(); +} + +function void_20emscripten__internal__raw_destructor_b2Shape__28b2Shape__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function void_20emscripten__internal__raw_destructor_b2Joint__28b2Joint__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function __emscripten_stdout_seek($0, $1, $2, $3) { + $0 = $0 | 0; + $1 = $1 | 0; + $2 = $2 | 0; + $3 = $3 | 0; + i64toi32_i32$HIGH_BITS = 0; + return 0; +} + +function emscripten__internal__TypeID_int_20const__2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_int_20const____get_28_29(); +} + +function emscripten__internal__TypeID_b2WheelJoint_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2WheelJoint___get_28_29(); +} + +function emscripten__internal__TypeID_b2MouseJoint_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2MouseJoint___get_28_29(); +} + +function emscripten__internal__TypeID_b2MotorJoint_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2MotorJoint___get_28_29(); +} + +function emscripten__internal__TypeID_b2FixtureDef_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2FixtureDef___get_28_29(); +} + +function void_20emscripten__internal__raw_destructor_b2Body__28b2Body__29($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function strdup($0) { + var $1 = 0, $2 = 0; + $1 = strlen($0) + 1 | 0; + $2 = dlmalloc($1); + if (!$2) { + return 0; + } + return __memcpy($2, $0, $1); +} + +function emscripten__internal__TypeID_b2WeldJoint_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2WeldJoint___get_28_29(); +} + +function emscripten__internal__TypeID_b2Transform_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Transform___get_28_29(); +} + +function emscripten__internal__TypeID_b2RopeJoint_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2RopeJoint___get_28_29(); +} + +function emscripten__internal__TypeID_b2JointType_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2JointType___get_28_29(); +} + +function emscripten__internal__TypeID_b2EdgeShape_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2EdgeShape___get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int_2c_20float____get_28_29() { + return 24912; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2RayCastCallbackWrapper_____get_28_29() { + return 25684; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2ContactListenerWrapper_____get_28_29() { + return 25956; +} + +function char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20float_2c_20int__28_29() { + return 16528; +} + +function char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float_2c_20int_2c_20int__28_29() { + return 16771; +} + +function emscripten__wrapper_b2Draw____wrapper_28_29_1($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + wasm2js_trap(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int_2c_20bool____get_28_29() { + return 24892; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_unsigned_20int_2c_20unsigned_20int____get_28_29() { + return 24940; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20unsigned_20int_2c_20int____get_28_29() { + return 24816; +} + +function b2RayCastCallback___b2RayCastCallback_28_29_1($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + wasm2js_trap(); +} + +function b2PrismaticJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2PrismaticJointDef__28_29_29_28b2JointDef__29() { + return 639; +} + +function emscripten__internal__TypeID_b2MassData_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2MassData___get_28_29(); +} + +function emscripten__internal__TypeID_b2JointDef_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2JointDef___get_28_29(); +} + +function emscripten__internal__TypeID_b2BodyType_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2BodyType___get_28_29(); +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2QueryCallbackWrapper_____get_28_29() { + return 25432; +} + +function char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() { + return 16521; +} + +function std____2____compressed_pair_elem_std____2__allocator_char__2c_201_2c_20true_____get_5babi_v160004_5d_28_29_20const($0) { + return $0; +} + +function char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() { + return 17070; +} + +function b2RevoluteJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2RevoluteJointDef__28_29_29_28b2JointDef__29() { + return 652; +} + +function b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2PrismaticJointDef__28_29_29_28b2PrismaticJointDef__29() { + return 638; +} + +function b2DistanceJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2DistanceJointDef__28_29_29_28b2JointDef__29() { + return 610; +} + +function __wasm_i64_udiv($0, $1, $2, $3) { + $3 = _ZN17compiler_builtins3int4udiv10divmod_u6417h6026910b5ed08e40E($0, $1, $2, $3); + return $3; +} + +function emscripten__internal__TypeID_b2Fixture_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Fixture___get_28_29(); +} + +function emscripten__internal__TypeID_b2BodyDef_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2BodyDef___get_28_29(); +} + +function emscripten__internal__LightTypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const____get_28_29() { + return 25144; +} + +function b2Timer__b2Timer_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Color__b2Color_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2Transform_20const_____get_28_29() { + return 26560; +} + +function emscripten__base_b2RayCastCallback___get_28_29() { + return emscripten__internal__TypeID_b2RayCastCallback_2c_20void___get_28_29(); +} + +function emscripten__base_b2ContactListener___get_28_29() { + return emscripten__internal__TypeID_b2ContactListener_2c_20void___get_28_29(); +} + +function b2QueryCallback___b2QueryCallback_28_29_1($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + wasm2js_trap(); +} + +function b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2RevoluteJointDef__28_29_29_28b2RevoluteJointDef__29() { + return 651; +} + +function b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2DistanceJointDef__28_29_29_28b2DistanceJointDef__29() { + return 609; +} + +function b2Body___b2Body_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function emscripten__internal__TypeID_b2Filter_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Filter___get_28_29(); +} + +function b2Vec3__b2Vec3_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function b2Vec2__b2Vec2_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float_2c_20float__28_29() { + return 15382; +} + +function __wasm_rotl_i32($0, $1) { + var $2 = 0; + $2 = $1 & 31; + $1 = 0 - $1 & 31; + return (-1 >>> $2 & $0) << $2 | (-1 << $1 & $0) >>> $1; +} +function emscripten__internal__TypeID_b2World_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2World___get_28_29(); +} + +function emscripten__internal__TypeID_b2Shape_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Shape___get_28_29(); +} + +function emscripten__internal__TypeID_b2Joint_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Joint___get_28_29(); +} + +function emscripten__internal__TypeID_b2Color_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Color___get_28_29(); +} + +function b2Rot__b2Rot_28_29($0) { + var $1 = 0; + $1 = __stack_pointer - 16 | 0; + HEAP32[$1 + 12 >> 2] = $0; + return HEAP32[$1 + 12 >> 2]; +} + +function legalfunc$__wasi_fd_seek($0, $1, $2, $3, $4) { + return legalimport$__wasi_fd_seek($0 | 0, $1 | 0, $2 | 0, $3 | 0, $4 | 0) | 0; +} + +function emscripten__base_b2QueryCallback___get_28_29() { + return emscripten__internal__TypeID_b2QueryCallback_2c_20void___get_28_29(); +} + +function char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20float__28_29() { + return 16830; +} + +function char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float_2c_20int__28_29() { + return 17105; +} + +function b2WheelJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2WheelJointDef__28_29_29_28b2JointDef__29() { + return 685; +} + +function b2PolygonShape__GetChildCount_28_29_20const($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function b2MouseJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2MouseJointDef__28_29_29_28b2JointDef__29() { + return 629; +} + +function b2MotorJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2MotorJointDef__28_29_29_28b2JointDef__29() { + return 619; +} + +function __wasm_i64_mul($0, $1, $2, $3) { + $3 = _ZN17compiler_builtins3int3mul3Mul3mul17h070e9a1c69faec5bE($0, $1, $2, $3); + return $3; +} + +function emscripten__internal__TypeID_b2Vec2_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Vec2___get_28_29(); +} + +function emscripten__internal__TypeID_b2Draw_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Draw___get_28_29(); +} + +function emscripten__internal__TypeID_b2Body_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Body___get_28_29(); +} + +function emscripten__internal__TypeID_b2AABB_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2AABB___get_28_29(); +} + +function emscripten__internal__LightTypeID_std____2__vector_int_2c_20std____2__allocator_int___20const____get_28_29() { + return 25024; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int_____get_28_29() { + return 26068; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_float_2c_20unsigned_20int____get_28_29() { + return 24924; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20unsigned_20int_____get_28_29() { + return 25512; +} + +function char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20float__28_29() { + return 17099; +} + +function b2CircleShape__GetChildCount_28_29_20const($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function std____2____compressed_pair_elem_std____2__allocator_char__2c_201_2c_20true_____get_5babi_v160004_5d_28_29($0) { + return $0; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20unsigned_20int____get_28_29() { + return 24932; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void_2c_20b2DrawWrapper_____get_28_29() { + return 26364; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_bool_2c_20unsigned_20int____get_28_29() { + return 24904; +} + +function char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int_2c_20int__28_29() { + return 15585; +} + +function b2WeldJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2WeldJointDef__28_29_29_28b2JointDef__29() { + return 676; +} + +function b2RopeJointDef__20_28_emscripten__base_b2JointDef___getDowncaster_b2RopeJointDef__28_29_29_28b2JointDef__29() { + return 665; +} + +function b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2WheelJointDef__28_29_29_28b2WheelJointDef__29() { + return 684; +} + +function b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2MouseJointDef__28_29_29_28b2MouseJointDef__29() { + return 628; +} + +function b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2MotorJointDef__28_29_29_28b2MotorJointDef__29() { + return 618; +} + +function emscripten__internal__TypeID_short_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_short___get_28_29(); +} + +function emscripten__internal__TypeID_float_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_float___get_28_29(); +} + +function emscripten__internal__TypeID_b2Rot_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_b2Rot___get_28_29(); +} + +function emscripten__internal__LightTypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______get_28_29() { + return 25128; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_int_2c_20unsigned_20int____get_28_29() { + return 24976; +} + +function char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int_2c_20int__28_29() { + return 15610; +} + +function b2EdgeShape__GetChildCount_28_29_20const($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return 1; +} + +function __cxxabiv1____shim_type_info_____shim_type_info_28_29($0) { + $0 = $0 | 0; + return std__type_info___type_info_28_29($0) | 0; +} + +function emscripten__internal__LightTypeID_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____get_28_29() { + return 25120; +} + +function b2PrismaticJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2PrismaticJoint__28_29_29_28b2Joint__29() { + return 642; +} + +function b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2WeldJointDef__28_29_29_28b2WeldJointDef__29() { + return 675; +} + +function b2JointDef__20_28_emscripten__base_b2JointDef___getUpcaster_b2RopeJointDef__28_29_29_28b2RopeJointDef__29() { + return 664; +} + +function emscripten__internal__TypeID_bool_2c_20void___get_28_29() { + return emscripten__internal__LightTypeID_bool___get_28_29(); +} + +function b2Timer__GetMilliseconds_28_29_20const($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + return Math_fround(0); +} + +function b2RevoluteJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2RevoluteJoint__28_29_29_28b2Joint__29() { + return 655; +} + +function b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2PrismaticJoint__28_29_29_28b2PrismaticJoint__29() { + return 641; +} + +function b2DistanceJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2DistanceJoint__28_29_29_28b2Joint__29() { + return 613; +} + +function char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int_2c_20float__28_29() { + return 17155; +} + +function b2PolygonShape__20_28_emscripten__base_b2Shape___getDowncaster_b2PolygonShape__28_29_29_28b2Shape__29() { + return 546; +} + +function b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2RevoluteJoint__28_29_29_28b2RevoluteJoint__29() { + return 654; +} + +function b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2DistanceJoint__28_29_29_28b2DistanceJoint__29() { + return 612; +} + +function b2Contact___b2Contact_28_29_1($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + wasm2js_trap(); +} + +function emscripten__internal__LightTypeID_std____2__vector_int_2c_20std____2__allocator_int______get_28_29() { + return 25008; +} + +function char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20float__28_29() { + return 15424; +} + +function void_20emscripten__internal__NoBaseClass__verify_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28_29() {} + +function emscripten__base_b2JointDef___get_28_29() { + return emscripten__internal__TypeID_b2JointDef_2c_20void___get_28_29(); +} + +function char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20float__28_29() { + return 17150; +} + +function char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int_2c_20int__28_29() { + return 15367; +} + +function b2Shape__20_28_emscripten__base_b2Shape___getUpcaster_b2PolygonShape__28_29_29_28b2PolygonShape__29() { + return 545; +} + +function b2CircleShape__20_28_emscripten__base_b2Shape___getDowncaster_b2CircleShape__28_29_29_28b2Shape__29() { + return 529; +} + +function emscripten__internal__LightTypeID_std____2__vector_int_2c_20std____2__allocator_int_____get_28_29() { + return 25e3; +} + +function char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int_2c_20int__28_29() { + return 15415; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_unsigned_20int____get_28_29() { + return 24972; +} + +function char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int_2c_20int__28_29() { + return 15410; +} + +function b2WheelJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2WheelJoint__28_29_29_28b2Joint__29() { + return 688; +} + +function b2Shape___b2Shape_28_29_1($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + wasm2js_trap(); +} + +function b2Shape__20_28_emscripten__base_b2Shape___getUpcaster_b2CircleShape__28_29_29_28b2CircleShape__29() { + return 528; +} + +function b2MouseJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2MouseJoint__28_29_29_28b2Joint__29() { + return 632; +} + +function b2MotorJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2MotorJoint__28_29_29_28b2Joint__29() { + return 622; +} + +function b2Joint___b2Joint_28_29_1($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + wasm2js_trap(); +} + +function b2DrawWrapper__20_28_emscripten__base_b2Draw___getDowncaster_b2DrawWrapper__28_29_29_28b2Draw__29() { + return 494; +} + +function b2WeldJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2WeldJoint__28_29_29_28b2Joint__29() { + return 679; +} + +function b2RopeJoint__20_28_emscripten__base_b2Joint___getDowncaster_b2RopeJoint__28_29_29_28b2Joint__29() { + return 668; +} + +function b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2WheelJoint__28_29_29_28b2WheelJoint__29() { + return 687; +} + +function b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2MouseJoint__28_29_29_28b2MouseJoint__29() { + return 631; +} + +function b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2MotorJoint__28_29_29_28b2MotorJoint__29() { + return 621; +} + +function b2EdgeShape__20_28_emscripten__base_b2Shape___getDowncaster_b2EdgeShape__28_29_29_28b2Shape__29() { + return 538; +} + +function b2Draw___b2Draw_28_29_1($0) { + $0 = $0 | 0; + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; + wasm2js_trap(); +} + +function b2Draw__20_28_emscripten__base_b2Draw___getUpcaster_b2DrawWrapper__28_29_29_28b2DrawWrapper__29() { + return 493; +} + +function void_20emscripten__internal__NoBaseClass__verify_std____2__vector_int_2c_20std____2__allocator_int____28_29() {} + +function emscripten__base_b2Shape___get_28_29() { + return emscripten__internal__TypeID_b2Shape_2c_20void___get_28_29(); +} + +function emscripten__base_b2Joint___get_28_29() { + return emscripten__internal__TypeID_b2Joint_2c_20void___get_28_29(); +} + +function b2Shape__20_28_emscripten__base_b2Shape___getUpcaster_b2EdgeShape__28_29_29_28b2EdgeShape__29() { + return 537; +} + +function b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2WeldJoint__28_29_29_28b2WeldJoint__29() { + return 678; +} + +function b2Joint__20_28_emscripten__base_b2Joint___getUpcaster_b2RopeJoint__28_29_29_28b2RopeJoint__29() { + return 667; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2RayCastCallback__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2ContactListener__28_29_29_28_29() { + return 0; +} + +function std____2__char_traits_char___assign_28char__2c_20char_20const__29($0, $1) { + HEAP8[$0 | 0] = HEAPU8[$1 | 0]; +} + +function emscripten__base_b2Draw___get_28_29() { + return emscripten__internal__TypeID_b2Draw_2c_20void___get_28_29(); +} + +function char_20const__20emscripten__internal__getGenericSignature_float_2c_20int_2c_20int__28_29() { + return 15429; +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2RayCastCallback__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2ContactListener__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2QueryCallback__28_29_29_28_29() { + return 0; +} + +function char_20const__20emscripten__internal__getGenericSignature_void_2c_20int_2c_20int__28_29() { + return 15433; +} + +function char_20const__20emscripten__internal__getGenericSignature_int_2c_20int_2c_20int__28_29() { + return 15420; +} + +function __cxx_global_var_init_2() { + b2Vec2__b2Vec2_28float_2c_20float_29(30760, Math_fround(0), Math_fround(0)); +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2QueryCallback__28_29_29_28_29() { + return 0; +} + +function std____2____libcpp_numeric_limits_unsigned_20long_2c_20true___max_5babi_v160004_5d_28_29() { + return -1; +} + +function emscripten__internal__ArgArrayGetter_emscripten__internal__TypeList_void____get_28_29() { + return 25508; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2FixtureDef__28_29_29_28_29() { + return 0; +} + +function stackAlloc($0) { + $0 = $0 | 0; + $0 = __stack_pointer - $0 & -16; + __stack_pointer = $0; + return $0 | 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2FixtureDef__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2JointDef__28_29_29_28_29() { + return 0; +} + +function std____2____libcpp_numeric_limits_long_2c_20true___max_5babi_v160004_5d_28_29() { + return 2147483647; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2Fixture__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2BodyDef__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2JointDef__28_29_29_28_29() { + return 0; +} + +function _GLOBAL__sub_I_b2_contact_manager_cpp() { + __cxx_global_var_init_3(); + __cxx_global_var_init_1_1(); +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2Fixture__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2BodyDef__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2World__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2Shape__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2Joint__28_29_29_28_29() { + return 0; +} + +function emscripten__internal__LightTypeID_b2RayCastCallbackWrapper_20const____get_28_29() { + return 25668; +} + +function emscripten__internal__LightTypeID_b2ContactListenerWrapper_20const____get_28_29() { + return 25940; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2Draw__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2Body__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getDowncaster_b2AABB__28_29_29_28_29() { + return 0; +} + +function char_20const__20emscripten__internal__getGenericSignature_void_2c_20int__28_29() { + return 15582; +} + +function __stdio_close($0) { + $0 = $0 | 0; + return __wasi_fd_close(dummy_1(HEAP32[$0 + 60 >> 2]) | 0) | 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2World__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2Shape__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2Joint__28_29_29_28_29() { + return 0; +} + +function emscripten__internal__LightTypeID_b2QueryCallbackWrapper_20const____get_28_29() { + return 25416; +} + +function dynCall_jiji($0, $1, $2, $3, $4) { + $3 = FUNCTION_TABLE[$0 | 0]($1, $2, $3, $4) | 0; + return $3; +} + +function char_20const__20emscripten__internal__getGenericSignature_int_2c_20int__28_29() { + return 15437; +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2Draw__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2Body__28_29_29_28_29() { + return 0; +} + +function void_20_28_emscripten__internal__NoBaseClass__getUpcaster_b2AABB__28_29_29_28_29() { + return 0; +} + +function emscripten__internal__LightTypeID_b2PrismaticJointDef_20const____get_28_29() { + return 28964; +} + +function emscripten__internal__LightTypeID_b2RevoluteJointDef_20const____get_28_29() { + return 29132; +} + +function emscripten__internal__LightTypeID_b2DistanceJointDef_20const____get_28_29() { + return 28592; +} + +function emscripten__internal__LightTypeID_b2RayCastCallback_20const____get_28_29() { + return 25564; +} + +function emscripten__internal__LightTypeID_b2ContactListener_20const____get_28_29() { + return 25804; +} + +function update_offset_to_base_28char_20const__2c_20long_29($0, $1) { + return HEAP32[$0 + $1 >> 2]; +} + +function strchr($0, $1) { + $0 = __strchrnul($0, $1); + return HEAPU8[$0 | 0] == ($1 & 255) ? $0 : 0; +} + +function emscripten__internal__LightTypeID_b2RayCastCallbackWrapper____get_28_29() { + return 25652; +} + +function emscripten__internal__LightTypeID_b2ContactListenerWrapper____get_28_29() { + return 25912; +} + +function std____2__pointer_traits_char____pointer_to_5babi_v160004_5d_28char__29($0) { + return $0; +} + +function emscripten__internal__LightTypeID_b2WheelJointDef_20const____get_28_29() { + return 29564; +} + +function emscripten__internal__LightTypeID_b2RevoluteJoint_20const____get_28_29() { + return 29168; +} + +function emscripten__internal__LightTypeID_b2RayCastCallbackWrapper___get_28_29() { + return 25640; +} + +function emscripten__internal__LightTypeID_b2QueryCallback_20const____get_28_29() { + return 25320; +} + +function emscripten__internal__LightTypeID_b2PrismaticJoint_20const____get_28_29() { + return 29e3; +} + +function emscripten__internal__LightTypeID_b2MouseJointDef_20const____get_28_29() { + return 28836; +} + +function emscripten__internal__LightTypeID_b2MotorJointDef_20const____get_28_29() { + return 28708; +} + +function emscripten__internal__LightTypeID_b2DistanceJoint_20const____get_28_29() { + return 28628; +} + +function emscripten__internal__LightTypeID_b2ContactListenerWrapper___get_28_29() { + return 25888; +} + +function __wasm_ctz_i32($0) { + if ($0) { + return 31 - Math_clz32($0 - 1 ^ $0) | 0; + } + return 32; +} + +function emscripten__internal__LightTypeID_b2WeldJointDef_20const____get_28_29() { + return 29448; +} + +function emscripten__internal__LightTypeID_b2RopeJointDef_20const____get_28_29() { + return 29308; +} + +function emscripten__internal__LightTypeID_b2QueryCallbackWrapper____get_28_29() { + return 25400; +} + +function emscripten__internal__LightTypeID_b2PolygonShape_20const____get_28_29() { + return 27632; +} + +function char_20const__20emscripten__internal__getGenericSignature_void__28_29() { + return 15580; +} + +function _embind_register_bindings($0) { + HEAP32[$0 + 4 >> 2] = HEAP32[7752]; + HEAP32[7752] = $0; +} + +function std____throw_bad_array_new_length_5babi_v160004_5d_28_29() { + abort(); + wasm2js_trap(); +} + +function emscripten__internal__LightTypeID_b2QueryCallbackWrapper___get_28_29() { + return 25388; +} + +function emscripten__internal__LightTypeID_b2DrawWrapper_20const____get_28_29() { + return 26348; +} + +function emscripten__internal__LightTypeID_b2CircleShape_20const____get_28_29() { + return 27252; +} + +function char_20const__20emscripten__internal__getGenericSignature_int__28_29() { + return 15616; +} + +function strnlen($0, $1) { + var $2 = 0; + $2 = memchr($0, 0, $1); + return $2 ? $2 - $0 | 0 : $1; +} + +function std__type_info__name_5babi_v160004_5d_28_29_20const($0) { + return HEAP32[$0 + 4 >> 2]; +} + +function emscripten__internal__LightTypeID_b2WheelJoint_20const____get_28_29() { + return 29600; +} + +function emscripten__internal__LightTypeID_b2MouseJoint_20const____get_28_29() { + return 28872; +} + +function emscripten__internal__LightTypeID_b2MotorJoint_20const____get_28_29() { + return 28744; +} + +function emscripten__internal__LightTypeID_b2FixtureDef_20const____get_28_29() { + return 27872; +} + +function void_20emscripten__base_b2RayCastCallback___verify_b2RayCastCallbackWrapper__28_29() {} + +function void_20emscripten__base_b2ContactListener___verify_b2ContactListenerWrapper__28_29() {} + +function emscripten__internal__LightTypeID_b2WeldJoint_20const____get_28_29() { + return 29484; +} + +function emscripten__internal__LightTypeID_b2RopeJoint_20const____get_28_29() { + return 29344; +} + +function emscripten__internal__LightTypeID_b2PrismaticJointDef____get_28_29() { + return 28948; +} + +function emscripten__internal__LightTypeID_b2EdgeShape_20const____get_28_29() { + return 27472; +} + +function emscripten__internal__LightTypeID_b2RevoluteJointDef____get_28_29() { + return 29116; +} + +function emscripten__internal__LightTypeID_b2PrismaticJointDef___get_28_29() { + return 28936; +} + +function emscripten__internal__LightTypeID_b2JointDef_20const____get_28_29() { + return 26892; +} + +function emscripten__internal__LightTypeID_b2DistanceJointDef____get_28_29() { + return 28576; +} + +function emscripten__internal__LightTypeID_b2RevoluteJointDef___get_28_29() { + return 29104; +} + +function emscripten__internal__LightTypeID_b2RayCastCallback____get_28_29() { + return 25548; +} + +function emscripten__internal__LightTypeID_b2Fixture_20const____get_28_29() { + return 27936; +} + +function emscripten__internal__LightTypeID_b2DistanceJointDef___get_28_29() { + return 28564; +} + +function emscripten__internal__LightTypeID_b2ContactListener____get_28_29() { + return 25788; +} + +function emscripten__internal__LightTypeID_b2BodyDef_20const____get_28_29() { + return 26844; +} + +function emscripten__internal__LightTypeID_b2RayCastCallback___get_28_29() { + return 25540; +} + +function emscripten__internal__LightTypeID_b2PrismaticJoint____get_28_29() { + return 28984; +} + +function emscripten__internal__LightTypeID_b2ContactListener___get_28_29() { + return 25780; +} + +function char__20std____2____to_address_5babi_v160004_5d_char__28char__29($0) { + return $0; +} + +function void_20emscripten__base_b2QueryCallback___verify_b2QueryCallbackWrapper__28_29() {} + +function emscripten__internal__LightTypeID_unsigned_20short___get_28_29() { + return 24360; +} + +function emscripten__internal__LightTypeID_b2World_20const____get_28_29() { + return 26744; +} + +function emscripten__internal__LightTypeID_b2WheelJointDef____get_28_29() { + return 29548; +} + +function emscripten__internal__LightTypeID_b2Shape_20const____get_28_29() { + return 27060; +} + +function emscripten__internal__LightTypeID_b2RevoluteJoint____get_28_29() { + return 29152; +} + +function emscripten__internal__LightTypeID_b2QueryCallback____get_28_29() { + return 25304; +} + +function emscripten__internal__LightTypeID_b2PrismaticJoint___get_28_29() { + return 19252; +} + +function emscripten__internal__LightTypeID_b2MouseJointDef____get_28_29() { + return 28820; +} + +function emscripten__internal__LightTypeID_b2MotorJointDef____get_28_29() { + return 28692; +} + +function emscripten__internal__LightTypeID_b2Joint_20const____get_28_29() { + return 28484; +} + +function emscripten__internal__LightTypeID_b2DistanceJoint____get_28_29() { + return 28612; +} + +function emscripten__internal__LightTypeID_b2WheelJointDef___get_28_29() { + return 29536; +} + +function emscripten__internal__LightTypeID_b2WeldJointDef____get_28_29() { + return 29432; +} + +function emscripten__internal__LightTypeID_b2Vec2_20const____get_28_29() { + return 24876; +} + +function emscripten__internal__LightTypeID_b2RopeJointDef____get_28_29() { + return 29292; +} + +function emscripten__internal__LightTypeID_b2RevoluteJoint___get_28_29() { + return 19424; +} + +function emscripten__internal__LightTypeID_b2RayCastOutput___get_28_29() { + return 25272; +} + +function emscripten__internal__LightTypeID_b2QueryCallback___get_28_29() { + return 25296; +} + +function emscripten__internal__LightTypeID_b2PolygonShape____get_28_29() { + return 27616; +} + +function emscripten__internal__LightTypeID_b2MouseJointDef___get_28_29() { + return 28808; +} + +function emscripten__internal__LightTypeID_b2MotorJointDef___get_28_29() { + return 28680; +} + +function emscripten__internal__LightTypeID_b2Draw_20const____get_28_29() { + return 26112; +} + +function emscripten__internal__LightTypeID_b2DistanceJoint___get_28_29() { + return 18516; +} + +function emscripten__internal__LightTypeID_b2Body_20const____get_28_29() { + return 28144; +} + +function emscripten__internal__LightTypeID_b2AABB_20const____get_28_29() { + return 26592; +} + +function emscripten__internal__LightTypeID_b2WeldJointDef___get_28_29() { + return 29420; +} + +function emscripten__internal__LightTypeID_b2RopeJointDef___get_28_29() { + return 29280; +} + +function emscripten__internal__LightTypeID_b2RayCastInput___get_28_29() { + return 25264; +} + +function emscripten__internal__LightTypeID_b2PolygonShape___get_28_29() { + return 18116; +} + +function emscripten__internal__LightTypeID_b2DrawWrapper____get_28_29() { + return 26332; +} + +function emscripten__internal__LightTypeID_b2CircleShape____get_28_29() { + return 27236; +} + +function emscripten__internal__LightTypeID_b2WheelJoint____get_28_29() { + return 29584; +} + +function emscripten__internal__LightTypeID_b2Shape__Type___get_28_29() { + return 24984; +} + +function emscripten__internal__LightTypeID_b2MouseJoint____get_28_29() { + return 28856; +} + +function emscripten__internal__LightTypeID_b2MotorJoint____get_28_29() { + return 28728; +} + +function emscripten__internal__LightTypeID_b2FixtureDef____get_28_29() { + return 27856; +} + +function emscripten__internal__LightTypeID_b2DrawWrapper___get_28_29() { + return 26320; +} + +function emscripten__internal__LightTypeID_b2CircleShape___get_28_29() { + return 17976; +} + +function b2Timer__Reset_28_29($0) { + HEAP32[(__stack_pointer - 16 | 0) + 12 >> 2] = $0; +} + +function emscripten__internal__LightTypeID_int_20const____get_28_29() { + return 24372; +} + +function emscripten__internal__LightTypeID_b2WheelJoint___get_28_29() { + return 19676; +} + +function emscripten__internal__LightTypeID_b2WeldJoint____get_28_29() { + return 29468; +} + +function emscripten__internal__LightTypeID_b2RopeJoint____get_28_29() { + return 29328; +} + +function emscripten__internal__LightTypeID_b2MouseJoint___get_28_29() { + return 19052; +} + +function emscripten__internal__LightTypeID_b2MotorJoint___get_28_29() { + return 18968; +} + +function emscripten__internal__LightTypeID_b2FixtureDef___get_28_29() { + return 27848; +} + +function emscripten__internal__LightTypeID_b2EdgeShape____get_28_29() { + return 27456; +} + +function void_20emscripten__internal__NoBaseClass__verify_b2RayCastCallback__28_29() {} + +function void_20emscripten__internal__NoBaseClass__verify_b2ContactListener__28_29() {} + +function out($0, $1, $2) { + if (!(HEAPU8[$0 | 0] & 32)) { + __fwritex($1, $2, $0); + } +} + +function emscripten__internal__LightTypeID_b2WeldJoint___get_28_29() { + return 19592; +} + +function emscripten__internal__LightTypeID_b2Transform___get_28_29() { + return 24884; +} + +function emscripten__internal__LightTypeID_b2RopeJoint___get_28_29() { + return 19508; +} + +function emscripten__internal__LightTypeID_b2JointType___get_28_29() { + return 28456; +} + +function emscripten__internal__LightTypeID_b2JointDef____get_28_29() { + return 28436; +} + +function emscripten__internal__LightTypeID_b2EdgeShape___get_28_29() { + return 18044; +} + +function emscripten__internal__LightTypeID_b2MassData___get_28_29() { + return 25280; +} + +function emscripten__internal__LightTypeID_b2JointDef___get_28_29() { + return 26884; +} + +function emscripten__internal__LightTypeID_b2Fixture____get_28_29() { + return 27920; +} + +function emscripten__internal__LightTypeID_b2BodyType___get_28_29() { + return 24992; +} + +function emscripten__internal__LightTypeID_b2BodyDef____get_28_29() { + return 28124; +} + +function void_20emscripten__internal__NoBaseClass__verify_b2QueryCallback__28_29() {} + +function emscripten__internal__LightTypeID_b2Fixture___get_28_29() { + return 27912; +} + +function emscripten__internal__LightTypeID_b2BodyDef___get_28_29() { + return 26836; +} + +function __getTypeName($0) { + $0 = $0 | 0; + return strdup(HEAP32[$0 + 4 >> 2]) | 0; +} + +function void_20emscripten__base_b2JointDef___verify_b2PrismaticJointDef__28_29() {} + +function vfprintf($0, $1, $2) { + return __vfprintf_internal($0, $1, $2, 962, 963); +} + +function emscripten__internal__LightTypeID_b2World____get_28_29() { + return 26728; +} + +function emscripten__internal__LightTypeID_b2Shape____get_28_29() { + return 27044; +} + +function emscripten__internal__LightTypeID_b2Joint____get_28_29() { + return 24848; +} + +function emscripten__internal__LightTypeID_b2Filter___get_28_29() { + return 25288; +} + +function void_20emscripten__base_b2JointDef___verify_b2RevoluteJointDef__28_29() {} + +function void_20emscripten__base_b2JointDef___verify_b2DistanceJointDef__28_29() {} + +function emscripten__internal__LightTypeID_b2World___get_28_29() { + return 26720; +} + +function emscripten__internal__LightTypeID_b2Shape___get_28_29() { + return 27036; +} + +function emscripten__internal__LightTypeID_b2Joint___get_28_29() { + return 18888; +} + +function emscripten__internal__LightTypeID_b2Draw____get_28_29() { + return 26096; +} + +function emscripten__internal__LightTypeID_b2Color___get_28_29() { + return 25256; +} + +function emscripten__internal__LightTypeID_b2Body____get_28_29() { + return 26820; +} + +function emscripten__internal__LightTypeID_b2AABB____get_28_29() { + return 26576; +} + +function wctomb($0, $1) { + if (!$0) { + return 0; + } + return wcrtomb($0, $1, 0); +} + +function void_20emscripten__internal__NoBaseClass__verify_b2FixtureDef__28_29() {} + +function emscripten__internal__LightTypeID_b2Vec2___get_28_29() { + return 24876; +} + +function emscripten__internal__LightTypeID_b2Draw___get_28_29() { + return 26088; +} + +function emscripten__internal__LightTypeID_b2Body___get_28_29() { + return 26812; +} + +function emscripten__internal__LightTypeID_b2AABB___get_28_29() { + return 26568; +} + +function emscripten__internal__LightTypeID_short___get_28_29() { + return 24348; +} + +function emscripten__internal__LightTypeID_float___get_28_29() { + return 24444; +} + +function emscripten__internal__LightTypeID_b2Rot___get_28_29() { + return 25248; +} + +function void_20emscripten__internal__NoBaseClass__verify_b2JointDef__28_29() {} + +function void_20emscripten__base_b2JointDef___verify_b2WheelJointDef__28_29() {} + +function void_20emscripten__base_b2JointDef___verify_b2MouseJointDef__28_29() {} + +function void_20emscripten__base_b2JointDef___verify_b2MotorJointDef__28_29() {} + +function emscripten__internal__LightTypeID_bool___get_28_29() { + return 24300; +} + +function __cxxabiv1____shim_type_info__noop2_28_29_20const($0) { + $0 = $0 | 0; +} + +function __cxxabiv1____shim_type_info__noop1_28_29_20const($0) { + $0 = $0 | 0; +} + +function __cxx_global_var_init() { + EmBindInit_b2__EmBindInit_b2_28_29(30016); +} + +function _GLOBAL__sub_I_b2_block_allocator_cpp() { + __cxx_global_var_init_1(); +} + +function void_20emscripten__internal__NoBaseClass__verify_b2Fixture__28_29() {} + +function void_20emscripten__internal__NoBaseClass__verify_b2BodyDef__28_29() {} + +function void_20emscripten__base_b2JointDef___verify_b2WeldJointDef__28_29() {} + +function void_20emscripten__base_b2JointDef___verify_b2RopeJointDef__28_29() {} + +function void_20emscripten__base_b2Joint___verify_b2PrismaticJoint__28_29() {} + +function void_20emscripten__internal__NoBaseClass__verify_b2World__28_29() {} + +function void_20emscripten__internal__NoBaseClass__verify_b2Shape__28_29() {} + +function void_20emscripten__internal__NoBaseClass__verify_b2Joint__28_29() {} + +function void_20emscripten__base_b2Joint___verify_b2RevoluteJoint__28_29() {} + +function void_20emscripten__base_b2Joint___verify_b2DistanceJoint__28_29() {} + +function void_20emscripten__internal__NoBaseClass__verify_b2Draw__28_29() {} + +function void_20emscripten__internal__NoBaseClass__verify_b2Body__28_29() {} + +function void_20emscripten__internal__NoBaseClass__verify_b2AABB__28_29() {} + +function void_20emscripten__base_b2Shape___verify_b2PolygonShape__28_29() {} + +function __cxa_pure_virtual() { + abort_message(12542, 0); + wasm2js_trap(); +} + +function _GLOBAL__sub_I_Box2DWebBindings_cpp() { + __cxx_global_var_init(); +} + +function void_20emscripten__base_b2Shape___verify_b2CircleShape__28_29() {} + +function emscripten_get_heap_size() { + return __wasm_memory_size() << 16; +} + +function void_20emscripten__base_b2Joint___verify_b2WheelJoint__28_29() {} + +function void_20emscripten__base_b2Joint___verify_b2MouseJoint__28_29() {} + +function void_20emscripten__base_b2Joint___verify_b2MotorJoint__28_29() {} + +function void_20emscripten__base_b2Draw___verify_b2DrawWrapper__28_29() {} + +function b2CloseDump_28_29() { + fclose(HEAP32[7692]); + HEAP32[7692] = 0; +} + +function __cxx_global_var_init_1() { + b2SizeMap__b2SizeMap_28_29(30116); +} + +function void_20emscripten__base_b2Shape___verify_b2EdgeShape__28_29() {} + +function void_20emscripten__base_b2Joint___verify_b2WeldJoint__28_29() {} + +function void_20emscripten__base_b2Joint___verify_b2RopeJoint__28_29() {} + +function emscripten__internal__NoBaseClass__get_28_29() { + return 0; +} + +function __cxx_global_var_init_1_1() { + __cxa_atexit(817, 0, 1024); +} + +function _GLOBAL__sub_I_b2_math_cpp() { + __cxx_global_var_init_2(); +} + +function __emscripten_stdout_close($0) { + $0 = $0 | 0; + return 0; +} + +function __cxx_global_var_init_3() { + __cxa_atexit(816, 0, 1024); +} + +function stackRestore($0) { + $0 = $0 | 0; + __stack_pointer = $0; +} + +function vprintf($0, $1) { + return vfprintf(29712, $0, $1); +} + +function std__type_info___type_info_28_29($0) { + return $0; +} + +function abort_message($0, $1) { + abort(); + wasm2js_trap(); +} + +function operator_20delete_28void__29($0) { + dlfree($0); +} + +function __ofl_lock() { + __lock(31080); + return 31084; +} + +function stackSave() { + return __stack_pointer | 0; +} + +function isdigit($0) { + return $0 - 48 >>> 0 < 10; +} + +function getpid() { + return __syscall_getpid(); +} + +function __cxa_atexit($0, $1, $2) { + return 0; +} + +function floor($0) { + return Math_floor($0); +} + +function __errno_location() { + return 31020; +} + +function __ofl_unlock() { + __unlock(31080); +} + +function __syscall_getpid() { + return 42; +} + +function __lockfile($0) { + return 1; +} + +function __get_tp() { + return 32120; +} + +function dummy_1($0) { + return $0; +} + +function __unlockfile($0) {} + +function setTempRet0($0) {} + +function __unlock($0) {} + +function __lock($0) {} + +function dummy($0) {} + + +// EMSCRIPTEN_END_FUNCS + +; + bufferView = HEAPU8; + initActiveSegments(imports); + var FUNCTION_TABLE = Table([null, embind_init_b2_28_29, GetFloat32_28unsigned_20int_2c_20int_29, SetLinearFrequencyAndDampingRatio_28b2Joint__2c_20float_2c_20float_29, TransformVector2_28b2Transform_20const__2c_20b2Vec2_20const__29, ContactSetEnabled_28unsigned_20int_2c_20bool_29, ContactIsTouching_28unsigned_20int_29, ContactSetTangentSpeed_28unsigned_20int_2c_20float_29, ContactGetTangentSpeed_28unsigned_20int_29, ContactSetFriction_28unsigned_20int_2c_20float_29, ContactGetFriction_28unsigned_20int_29, ContactResetFriction_28unsigned_20int_29, ContactSetRestitution_28unsigned_20int_2c_20float_29, ContactGetRestitution_28unsigned_20int_29, ContactResetRestitution_28unsigned_20int_29, ContactGetFixtureA_28unsigned_20int_29, ContactGetFixtureB_28unsigned_20int_29, ContactGetWorldManifold_28unsigned_20int_2c_20unsigned_20int_29, ContactGetManifold_28unsigned_20int_29, ManifoldGetType_28unsigned_20int_29, ManifoldGetPointCount_28unsigned_20int_29, ManifoldGetManifoldPointPtr_28unsigned_20int_2c_20int_29, ManifoldGetLocalPointValueX_28unsigned_20int_29, ManifoldGetLocalPointValueY_28unsigned_20int_29, ManifoldGetLocalNormalValueX_28unsigned_20int_29, ManifoldGetLocalNormalValueY_28unsigned_20int_29, ManifoldPointGetLocalPointX_28unsigned_20int_29, ManifoldPointGetLocalPointY_28unsigned_20int_29, ManifoldPointGetNormalImpulse_28unsigned_20int_29, ManifoldPointGetTangentImpulse_28unsigned_20int_29, WorldManifoldNew_28_29, WorldManifoldGetPointValueX_28unsigned_20int_2c_20int_29, WorldManifoldGetPointValueY_28unsigned_20int_2c_20int_29, WorldManifoldGetSeparationValue_28unsigned_20int_2c_20int_29, WorldManifoldGetNormalValueX_28unsigned_20int_29, WorldManifoldGetNormalValueY_28unsigned_20int_29, WorldManifoldDelete_28unsigned_20int_29, ContactImpulseGetNormalImpulse_28unsigned_20int_2c_20int_29, ContactImpulseGetTangentImpulse_28unsigned_20int_2c_20int_29, ContactImpulseGetCount_28unsigned_20int_29, void_20const__20emscripten__internal__getActualType_b2QueryCallback__28b2QueryCallback__29, void_20emscripten__internal__raw_destructor_b2QueryCallback__28b2QueryCallback__29, void_20const__20emscripten__internal__getActualType_b2QueryCallbackWrapper__28b2QueryCallbackWrapper__29, void_20emscripten__internal__raw_destructor_b2QueryCallbackWrapper__28b2QueryCallbackWrapper__29, b2QueryCallbackWrapper__20emscripten__internal__wrapped_new_b2QueryCallbackWrapper__2c_20b2QueryCallbackWrapper_2c_20emscripten__val__28emscripten__val___29, emscripten__internal__Invoker_b2QueryCallbackWrapper__2c_20emscripten__val_____invoke_28b2QueryCallbackWrapper__20_28__29_28emscripten__val___29_2c_20emscripten___EM_VAL__29, emscripten__val_20emscripten__internal__wrapped_extend_b2QueryCallbackWrapper__28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const__29, emscripten__internal__Invoker_emscripten__val_2c_20std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const____invoke_28emscripten__val_20_28__29_28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const__29_2c_20emscripten__internal__BindingType_std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___2c_20void____unnamed___2c_20emscripten___EM_VAL__29, void_20const__20emscripten__internal__getActualType_b2RayCastCallback__28b2RayCastCallback__29, void_20emscripten__internal__raw_destructor_b2RayCastCallback__28b2RayCastCallback__29, void_20const__20emscripten__internal__getActualType_b2RayCastCallbackWrapper__28b2RayCastCallbackWrapper__29, void_20emscripten__internal__raw_destructor_b2RayCastCallbackWrapper__28b2RayCastCallbackWrapper__29, b2RayCastCallbackWrapper__20emscripten__internal__wrapped_new_b2RayCastCallbackWrapper__2c_20b2RayCastCallbackWrapper_2c_20emscripten__val__28emscripten__val___29, emscripten__internal__Invoker_b2RayCastCallbackWrapper__2c_20emscripten__val_____invoke_28b2RayCastCallbackWrapper__20_28__29_28emscripten__val___29_2c_20emscripten___EM_VAL__29, emscripten__val_20emscripten__internal__wrapped_extend_b2RayCastCallbackWrapper__28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const__29, void_20const__20emscripten__internal__getActualType_b2ContactListener__28b2ContactListener__29, void_20emscripten__internal__raw_destructor_b2ContactListener__28b2ContactListener__29, b2ContactListenerWrapper__registerContactFixture_28unsigned_20int_29, b2ContactListenerWrapper__unregisterContactFixture_28unsigned_20int_29, b2ContactListenerWrapper__isIndexOf_28unsigned_20int_29, void_20const__20emscripten__internal__getActualType_b2ContactListenerWrapper__28b2ContactListenerWrapper__29, void_20emscripten__internal__raw_destructor_b2ContactListenerWrapper__28b2ContactListenerWrapper__29, b2ContactListenerWrapper__20emscripten__internal__wrapped_new_b2ContactListenerWrapper__2c_20b2ContactListenerWrapper_2c_20emscripten__val__28emscripten__val___29, emscripten__internal__Invoker_b2ContactListenerWrapper__2c_20emscripten__val_____invoke_28b2ContactListenerWrapper__20_28__29_28emscripten__val___29_2c_20emscripten___EM_VAL__29, emscripten__val_20emscripten__internal__wrapped_extend_b2ContactListenerWrapper__28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const__29, void_20const__20emscripten__internal__getActualType_b2Draw__28b2Draw__29, void_20emscripten__internal__raw_destructor_b2Draw__28b2Draw__29, b2Draw__SetFlags_28unsigned_20int_29, b2Draw__GetFlags_28_29_20const, b2Draw__AppendFlags_28unsigned_20int_29, b2Draw__ClearFlags_28unsigned_20int_29, void_20const__20emscripten__internal__getActualType_b2DrawWrapper__28b2DrawWrapper__29, void_20emscripten__internal__raw_destructor_b2DrawWrapper__28b2DrawWrapper__29, b2DrawWrapper__20emscripten__internal__wrapped_new_b2DrawWrapper__2c_20b2DrawWrapper_2c_20emscripten__val__28emscripten__val___29, emscripten__internal__Invoker_b2DrawWrapper__2c_20emscripten__val_____invoke_28b2DrawWrapper__20_28__29_28emscripten__val___29_2c_20emscripten___EM_VAL__29, emscripten__val_20emscripten__internal__wrapped_extend_b2DrawWrapper__28std____2__basic_string_char_2c_20std____2__char_traits_char__2c_20std____2__allocator_char___20const__2c_20emscripten__val_20const__29, void_20const__20emscripten__internal__getActualType_b2AABB__28b2AABB__29, void_20emscripten__internal__raw_destructor_b2AABB__28b2AABB__29, b2AABB__20emscripten__internal__operator_new_b2AABB__28_29, b2AABB__IsValid_28_29_20const, b2AABB__GetCenter_28_29_20const, b2AABB__GetExtents_28_29_20const, b2AABB__GetPerimeter_28_29_20const, b2AABB__Contains_28b2AABB_20const__29_20const, b2AABB__RayCast_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const, b2Vec2__20emscripten__internal__MemberAccess_b2AABB_2c_20b2Vec2___getWire_b2AABB__28b2Vec2_20b2AABB____20const__2c_20b2AABB_20const__29, void_20emscripten__internal__MemberAccess_b2AABB_2c_20b2Vec2___setWire_b2AABB__28b2Vec2_20b2AABB____20const__2c_20b2AABB__2c_20b2Vec2__29, void_20const__20emscripten__internal__getActualType_b2World__28b2World__29, void_20emscripten__internal__raw_destructor_b2World__28b2World__29, b2World__20emscripten__internal__operator_new_b2World_2c_20b2Vec2__28b2Vec2___29, b2World__SetContactListener_28b2ContactListener__29, b2World__SetDebugDraw_28b2Draw__29, b2World__DebugDraw_28_29, b2World__CreateBody_28b2BodyDef_20const__29, b2World__DestroyBody_28b2Body__29, b2World__CreateJoint_28b2JointDef_20const__29, b2World__DestroyJoint_28b2Joint__29, b2World__Step_28float_2c_20int_2c_20int_29, b2World__QueryAABB_28b2QueryCallback__2c_20b2AABB_20const__29_20const, b2World__RayCast_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const, b2World__SetAllowSleeping_28bool_29, b2World__GetAllowSleeping_28_29_20const, b2World__SetGravity_28b2Vec2_20const__29, b2World__GetGravity_28_29_20const, b2World__Dump_28_29, void_20const__20emscripten__internal__getActualType_b2Shape__28b2Shape__29, void_20emscripten__internal__raw_destructor_b2Shape__28b2Shape__29, b2Shape__Type_20emscripten__internal__MemberAccess_b2Shape_2c_20b2Shape__Type___getWire_b2Shape__28b2Shape__Type_20b2Shape____20const__2c_20b2Shape_20const__29, void_20emscripten__internal__MemberAccess_b2Shape_2c_20b2Shape__Type___setWire_b2Shape__28b2Shape__Type_20b2Shape____20const__2c_20b2Shape__2c_20b2Shape__Type_29, float_20emscripten__internal__MemberAccess_b2Shape_2c_20float___getWire_b2Shape__28float_20b2Shape____20const__2c_20b2Shape_20const__29, void_20emscripten__internal__MemberAccess_b2Shape_2c_20float___setWire_b2Shape__28float_20b2Shape____20const__2c_20b2Shape__2c_20float_29, b2Shape__GetType_28_29_20const, void_20const__20emscripten__internal__getActualType_b2CircleShape__28b2CircleShape__29, void_20emscripten__internal__raw_destructor_b2CircleShape__28b2CircleShape__29, b2CircleShape__20emscripten__internal__operator_new_b2CircleShape__28_29, b2Vec2__20emscripten__internal__MemberAccess_b2CircleShape_2c_20b2Vec2___getWire_b2CircleShape__28b2Vec2_20b2CircleShape____20const__2c_20b2CircleShape_20const__29, void_20emscripten__internal__MemberAccess_b2CircleShape_2c_20b2Vec2___setWire_b2CircleShape__28b2Vec2_20b2CircleShape____20const__2c_20b2CircleShape__2c_20b2Vec2__29, void_20const__20emscripten__internal__getActualType_b2EdgeShape__28b2EdgeShape__29, void_20emscripten__internal__raw_destructor_b2EdgeShape__28b2EdgeShape__29, void_20const__20emscripten__internal__getActualType_b2PolygonShape__28b2PolygonShape__29, void_20emscripten__internal__raw_destructor_b2PolygonShape__28b2PolygonShape__29, b2PolygonShape__20emscripten__internal__operator_new_b2PolygonShape__28_29, b2PolygonShape__Validate_28_29_20const, b2PolygonShape__SetAsBox_28float_2c_20float_29, b2PolygonShape__SetAsBox_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29, void_20const__20emscripten__internal__getActualType_b2FixtureDef__28b2FixtureDef__29, void_20emscripten__internal__raw_destructor_b2FixtureDef__28b2FixtureDef__29, b2FixtureDef__20emscripten__internal__operator_new_b2FixtureDef__28_29, float_20emscripten__internal__MemberAccess_b2FixtureDef_2c_20float___getWire_b2FixtureDef__28float_20b2FixtureDef____20const__2c_20b2FixtureDef_20const__29, void_20emscripten__internal__MemberAccess_b2FixtureDef_2c_20float___setWire_b2FixtureDef__28float_20b2FixtureDef____20const__2c_20b2FixtureDef__2c_20float_29, bool_20emscripten__internal__MemberAccess_b2FixtureDef_2c_20bool___getWire_b2FixtureDef__28bool_20b2FixtureDef____20const__2c_20b2FixtureDef_20const__29, void_20emscripten__internal__MemberAccess_b2FixtureDef_2c_20bool___setWire_b2FixtureDef__28bool_20b2FixtureDef____20const__2c_20b2FixtureDef__2c_20bool_29, b2Filter__20emscripten__internal__MemberAccess_b2FixtureDef_2c_20b2Filter___getWire_b2FixtureDef__28b2Filter_20b2FixtureDef____20const__2c_20b2FixtureDef_20const__29, void_20emscripten__internal__MemberAccess_b2FixtureDef_2c_20b2Filter___setWire_b2FixtureDef__28b2Filter_20b2FixtureDef____20const__2c_20b2FixtureDef__2c_20b2Filter__29, void_20const__20emscripten__internal__getActualType_b2Fixture__28b2Fixture__29, void_20emscripten__internal__raw_destructor_b2Fixture__28b2Fixture__29, b2Fixture__GetType_28_29_20const, b2Fixture__GetShape_28_29, b2Fixture__SetSensor_28bool_29, b2Fixture__IsSensor_28_29_20const, b2Fixture__SetFilterData_28b2Filter_20const__29, b2Fixture__GetFilterData_28_29_20const, b2Fixture__Refilter_28_29, b2Fixture__GetBody_28_29, b2Fixture__TestPoint_28b2Vec2_20const__29_20const, b2Fixture__RayCast_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const, b2Fixture__GetMassData_28b2MassData__29_20const, b2Fixture__SetDensity_28float_29, b2Fixture__GetDensity_28_29_20const, b2Fixture__GetFriction_28_29_20const, b2Fixture__SetFriction_28float_29, b2Fixture__GetRestitution_28_29_20const, b2Fixture__SetRestitution_28float_29, b2Fixture__GetAABB_28int_29_20const, b2Fixture__Dump_28int_29, void_20const__20emscripten__internal__getActualType_b2BodyDef__28b2BodyDef__29, void_20emscripten__internal__raw_destructor_b2BodyDef__28b2BodyDef__29, b2BodyDef__20emscripten__internal__operator_new_b2BodyDef__28_29, b2BodyType_20emscripten__internal__MemberAccess_b2BodyDef_2c_20b2BodyType___getWire_b2BodyDef__28b2BodyType_20b2BodyDef____20const__2c_20b2BodyDef_20const__29, void_20emscripten__internal__MemberAccess_b2BodyDef_2c_20b2BodyType___setWire_b2BodyDef__28b2BodyType_20b2BodyDef____20const__2c_20b2BodyDef__2c_20b2BodyType_29, b2Vec2__20emscripten__internal__MemberAccess_b2BodyDef_2c_20b2Vec2___getWire_b2BodyDef__28b2Vec2_20b2BodyDef____20const__2c_20b2BodyDef_20const__29, void_20emscripten__internal__MemberAccess_b2BodyDef_2c_20b2Vec2___setWire_b2BodyDef__28b2Vec2_20b2BodyDef____20const__2c_20b2BodyDef__2c_20b2Vec2__29, float_20emscripten__internal__MemberAccess_b2BodyDef_2c_20float___getWire_b2BodyDef__28float_20b2BodyDef____20const__2c_20b2BodyDef_20const__29, void_20emscripten__internal__MemberAccess_b2BodyDef_2c_20float___setWire_b2BodyDef__28float_20b2BodyDef____20const__2c_20b2BodyDef__2c_20float_29, bool_20emscripten__internal__MemberAccess_b2BodyDef_2c_20bool___getWire_b2BodyDef__28bool_20b2BodyDef____20const__2c_20b2BodyDef_20const__29, void_20emscripten__internal__MemberAccess_b2BodyDef_2c_20bool___setWire_b2BodyDef__28bool_20b2BodyDef____20const__2c_20b2BodyDef__2c_20bool_29, void_20const__20emscripten__internal__getActualType_b2Body__28b2Body__29, void_20emscripten__internal__raw_destructor_b2Body__28b2Body__29, b2Body__CreateFixture_28b2FixtureDef_20const__29, b2Body__CreateFixture_28b2Shape_20const__2c_20float_29, b2Body__DestroyFixture_28b2Fixture__29, b2Body__SetTransform_28b2Vec2_20const__2c_20float_29, b2Body__GetTransform_28_29_20const, b2Body__GetPosition_28_29_20const, b2Body__GetAngle_28_29_20const, b2Body__GetWorldCenter_28_29_20const, b2Body__GetLocalCenter_28_29_20const, b2Body__SetLinearVelocity_28b2Vec2_20const__29, b2Body__GetLinearVelocity_28_29_20const, b2Body__SetAngularVelocity_28float_29, b2Body__GetAngularVelocity_28_29_20const, b2Body__ApplyForce_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29, b2Body__ApplyForceToCenter_28b2Vec2_20const__2c_20bool_29, b2Body__ApplyTorque_28float_2c_20bool_29, b2Body__ApplyLinearImpulse_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29, b2Body__ApplyLinearImpulseToCenter_28b2Vec2_20const__2c_20bool_29, b2Body__ApplyAngularImpulse_28float_2c_20bool_29, b2Body__GetMass_28_29_20const, b2Body__GetInertia_28_29_20const, b2Body__GetMassData_28b2MassData__29_20const, b2Body__ResetMassData_28_29, b2Body__GetWorldPoint_28b2Vec2_20const__29_20const, b2Body__GetWorldVector_28b2Vec2_20const__29_20const, b2Body__GetLocalPoint_28b2Vec2_20const__29_20const, b2Body__GetLocalVector_28b2Vec2_20const__29_20const, b2Body__GetLinearVelocityFromWorldPoint_28b2Vec2_20const__29_20const, b2Body__GetLinearVelocityFromLocalPoint_28b2Vec2_20const__29_20const, b2Body__GetLinearDamping_28_29_20const, b2Body__SetLinearDamping_28float_29, b2Body__GetAngularDamping_28_29_20const, b2Body__SetAngularDamping_28float_29, b2Body__GetGravityScale_28_29_20const, b2Body__SetGravityScale_28float_29, b2Body__SetType_28b2BodyType_29, b2Body__GetType_28_29_20const, b2Body__SetBullet_28bool_29, b2Body__IsBullet_28_29_20const, b2Body__SetSleepingAllowed_28bool_29, b2Body__IsSleepingAllowed_28_29_20const, b2Body__SetAwake_28bool_29, b2Body__IsAwake_28_29_20const, b2Body__SetEnabled_28bool_29, b2Body__IsEnabled_28_29_20const, b2Body__SetFixedRotation_28bool_29, b2Body__IsFixedRotation_28_29_20const, b2Body__GetFixtureList_28_29, b2Body__GetWorld_28_29, b2Body__Dump_28_29, void_20const__20emscripten__internal__getActualType_b2JointDef__28b2JointDef__29, void_20emscripten__internal__raw_destructor_b2JointDef__28b2JointDef__29, b2JointDef__20emscripten__internal__operator_new_b2JointDef__28_29, b2JointType_20emscripten__internal__MemberAccess_b2JointDef_2c_20b2JointType___getWire_b2JointDef__28b2JointType_20b2JointDef____20const__2c_20b2JointDef_20const__29, void_20emscripten__internal__MemberAccess_b2JointDef_2c_20b2JointType___setWire_b2JointDef__28b2JointType_20b2JointDef____20const__2c_20b2JointDef__2c_20b2JointType_29, bool_20emscripten__internal__MemberAccess_b2JointDef_2c_20bool___getWire_b2JointDef__28bool_20b2JointDef____20const__2c_20b2JointDef_20const__29, void_20emscripten__internal__MemberAccess_b2JointDef_2c_20bool___setWire_b2JointDef__28bool_20b2JointDef____20const__2c_20b2JointDef__2c_20bool_29, void_20const__20emscripten__internal__getActualType_b2Joint__28b2Joint__29, void_20emscripten__internal__raw_destructor_b2Joint__28b2Joint__29, b2Joint__GetType_28_29_20const, b2Joint__GetBodyA_28_29, b2Joint__GetBodyB_28_29, b2Joint__GetCollideConnected_28_29_20const, void_20const__20emscripten__internal__getActualType_b2DistanceJointDef__28b2DistanceJointDef__29, void_20emscripten__internal__raw_destructor_b2DistanceJointDef__28b2DistanceJointDef__29, b2DistanceJointDef__20emscripten__internal__operator_new_b2DistanceJointDef__28_29, b2Vec2__20emscripten__internal__MemberAccess_b2DistanceJointDef_2c_20b2Vec2___getWire_b2DistanceJointDef__28b2Vec2_20b2DistanceJointDef____20const__2c_20b2DistanceJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2DistanceJointDef_2c_20b2Vec2___setWire_b2DistanceJointDef__28b2Vec2_20b2DistanceJointDef____20const__2c_20b2DistanceJointDef__2c_20b2Vec2__29, float_20emscripten__internal__MemberAccess_b2DistanceJointDef_2c_20float___getWire_b2DistanceJointDef__28float_20b2DistanceJointDef____20const__2c_20b2DistanceJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2DistanceJointDef_2c_20float___setWire_b2DistanceJointDef__28float_20b2DistanceJointDef____20const__2c_20b2DistanceJointDef__2c_20float_29, void_20const__20emscripten__internal__getActualType_b2DistanceJoint__28b2DistanceJoint__29, void_20emscripten__internal__raw_destructor_b2DistanceJoint__28b2DistanceJoint__29, b2DistanceJoint__GetLocalAnchorA_28_29_20const, b2DistanceJoint__GetLocalAnchorB_28_29_20const, b2DistanceJoint__SetLength_28float_29, b2DistanceJoint__GetLength_28_29_20const, b2DistanceJoint__SetStiffness_28float_29, b2DistanceJoint__GetStiffness_28_29_20const, b2DistanceJoint__SetDamping_28float_29, b2DistanceJoint__GetDamping_28_29_20const, void_20const__20emscripten__internal__getActualType_b2MotorJointDef__28b2MotorJointDef__29, void_20emscripten__internal__raw_destructor_b2MotorJointDef__28b2MotorJointDef__29, b2MotorJointDef__20emscripten__internal__operator_new_b2MotorJointDef__28_29, b2Vec2__20emscripten__internal__MemberAccess_b2MotorJointDef_2c_20b2Vec2___getWire_b2MotorJointDef__28b2Vec2_20b2MotorJointDef____20const__2c_20b2MotorJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2MotorJointDef_2c_20b2Vec2___setWire_b2MotorJointDef__28b2Vec2_20b2MotorJointDef____20const__2c_20b2MotorJointDef__2c_20b2Vec2__29, float_20emscripten__internal__MemberAccess_b2MotorJointDef_2c_20float___getWire_b2MotorJointDef__28float_20b2MotorJointDef____20const__2c_20b2MotorJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2MotorJointDef_2c_20float___setWire_b2MotorJointDef__28float_20b2MotorJointDef____20const__2c_20b2MotorJointDef__2c_20float_29, void_20const__20emscripten__internal__getActualType_b2MotorJoint__28b2MotorJoint__29, void_20emscripten__internal__raw_destructor_b2MotorJoint__28b2MotorJoint__29, b2MotorJoint__SetLinearOffset_28b2Vec2_20const__29, b2MotorJoint__GetLinearOffset_28_29_20const, b2MotorJoint__SetAngularOffset_28float_29, b2MotorJoint__GetAngularOffset_28_29_20const, b2MotorJoint__SetMaxForce_28float_29, b2MotorJoint__GetMaxForce_28_29_20const, b2MotorJoint__SetMaxTorque_28float_29, b2MotorJoint__GetMaxTorque_28_29_20const, b2MotorJoint__SetCorrectionFactor_28float_29, b2MotorJoint__GetCorrectionFactor_28_29_20const, void_20const__20emscripten__internal__getActualType_b2MouseJointDef__28b2MouseJointDef__29, void_20emscripten__internal__raw_destructor_b2MouseJointDef__28b2MouseJointDef__29, b2MouseJointDef__20emscripten__internal__operator_new_b2MouseJointDef__28_29, b2Vec2__20emscripten__internal__MemberAccess_b2MouseJointDef_2c_20b2Vec2___getWire_b2MouseJointDef__28b2Vec2_20b2MouseJointDef____20const__2c_20b2MouseJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2MouseJointDef_2c_20b2Vec2___setWire_b2MouseJointDef__28b2Vec2_20b2MouseJointDef____20const__2c_20b2MouseJointDef__2c_20b2Vec2__29, float_20emscripten__internal__MemberAccess_b2MouseJointDef_2c_20float___getWire_b2MouseJointDef__28float_20b2MouseJointDef____20const__2c_20b2MouseJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2MouseJointDef_2c_20float___setWire_b2MouseJointDef__28float_20b2MouseJointDef____20const__2c_20b2MouseJointDef__2c_20float_29, void_20const__20emscripten__internal__getActualType_b2MouseJoint__28b2MouseJoint__29, void_20emscripten__internal__raw_destructor_b2MouseJoint__28b2MouseJoint__29, b2MouseJoint__SetTarget_28b2Vec2_20const__29, b2MouseJoint__GetTarget_28_29_20const, b2MouseJoint__SetMaxForce_28float_29, b2MouseJoint__GetMaxForce_28_29_20const, b2MouseJoint__SetFrequency_28float_29, b2MouseJoint__GetFrequency_28_29_20const, b2MouseJoint__SetDampingRatio_28float_29, b2MouseJoint__GetDampingRatio_28_29_20const, void_20const__20emscripten__internal__getActualType_b2PrismaticJointDef__28b2PrismaticJointDef__29, void_20emscripten__internal__raw_destructor_b2PrismaticJointDef__28b2PrismaticJointDef__29, b2PrismaticJointDef__20emscripten__internal__operator_new_b2PrismaticJointDef__28_29, b2Vec2__20emscripten__internal__MemberAccess_b2PrismaticJointDef_2c_20b2Vec2___getWire_b2PrismaticJointDef__28b2Vec2_20b2PrismaticJointDef____20const__2c_20b2PrismaticJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2PrismaticJointDef_2c_20b2Vec2___setWire_b2PrismaticJointDef__28b2Vec2_20b2PrismaticJointDef____20const__2c_20b2PrismaticJointDef__2c_20b2Vec2__29, float_20emscripten__internal__MemberAccess_b2PrismaticJointDef_2c_20float___getWire_b2PrismaticJointDef__28float_20b2PrismaticJointDef____20const__2c_20b2PrismaticJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2PrismaticJointDef_2c_20float___setWire_b2PrismaticJointDef__28float_20b2PrismaticJointDef____20const__2c_20b2PrismaticJointDef__2c_20float_29, bool_20emscripten__internal__MemberAccess_b2PrismaticJointDef_2c_20bool___getWire_b2PrismaticJointDef__28bool_20b2PrismaticJointDef____20const__2c_20b2PrismaticJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2PrismaticJointDef_2c_20bool___setWire_b2PrismaticJointDef__28bool_20b2PrismaticJointDef____20const__2c_20b2PrismaticJointDef__2c_20bool_29, void_20const__20emscripten__internal__getActualType_b2PrismaticJoint__28b2PrismaticJoint__29, void_20emscripten__internal__raw_destructor_b2PrismaticJoint__28b2PrismaticJoint__29, b2PrismaticJoint__GetLocalAnchorA_28_29_20const, b2PrismaticJoint__GetLocalAnchorB_28_29_20const, b2PrismaticJoint__GetLocalAxisA_28_29_20const, b2PrismaticJoint__GetReferenceAngle_28_29_20const, b2PrismaticJoint__GetJointTranslation_28_29_20const, b2PrismaticJoint__GetJointSpeed_28_29_20const, b2PrismaticJoint__IsLimitEnabled_28_29_20const, b2PrismaticJoint__EnableLimit_28bool_29, b2PrismaticJoint__GetLowerLimit_28_29_20const, b2PrismaticJoint__GetUpperLimit_28_29_20const, b2PrismaticJoint__SetLimits_28float_2c_20float_29, b2PrismaticJoint__IsMotorEnabled_28_29_20const, b2PrismaticJoint__EnableMotor_28bool_29, b2PrismaticJoint__SetMotorSpeed_28float_29, b2PrismaticJoint__GetMotorSpeed_28_29_20const, b2PrismaticJoint__SetMaxMotorForce_28float_29, b2PrismaticJoint__GetMaxMotorForce_28_29_20const, b2PrismaticJoint__GetMotorForce_28float_29_20const, void_20const__20emscripten__internal__getActualType_b2RevoluteJointDef__28b2RevoluteJointDef__29, void_20emscripten__internal__raw_destructor_b2RevoluteJointDef__28b2RevoluteJointDef__29, b2RevoluteJointDef__20emscripten__internal__operator_new_b2RevoluteJointDef__28_29, b2Vec2__20emscripten__internal__MemberAccess_b2RevoluteJointDef_2c_20b2Vec2___getWire_b2RevoluteJointDef__28b2Vec2_20b2RevoluteJointDef____20const__2c_20b2RevoluteJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2RevoluteJointDef_2c_20b2Vec2___setWire_b2RevoluteJointDef__28b2Vec2_20b2RevoluteJointDef____20const__2c_20b2RevoluteJointDef__2c_20b2Vec2__29, float_20emscripten__internal__MemberAccess_b2RevoluteJointDef_2c_20float___getWire_b2RevoluteJointDef__28float_20b2RevoluteJointDef____20const__2c_20b2RevoluteJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2RevoluteJointDef_2c_20float___setWire_b2RevoluteJointDef__28float_20b2RevoluteJointDef____20const__2c_20b2RevoluteJointDef__2c_20float_29, bool_20emscripten__internal__MemberAccess_b2RevoluteJointDef_2c_20bool___getWire_b2RevoluteJointDef__28bool_20b2RevoluteJointDef____20const__2c_20b2RevoluteJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2RevoluteJointDef_2c_20bool___setWire_b2RevoluteJointDef__28bool_20b2RevoluteJointDef____20const__2c_20b2RevoluteJointDef__2c_20bool_29, void_20const__20emscripten__internal__getActualType_b2RevoluteJoint__28b2RevoluteJoint__29, void_20emscripten__internal__raw_destructor_b2RevoluteJoint__28b2RevoluteJoint__29, b2RevoluteJoint__GetLocalAnchorA_28_29_20const, b2RevoluteJoint__GetLocalAnchorB_28_29_20const, b2RevoluteJoint__GetReferenceAngle_28_29_20const, b2RevoluteJoint__GetJointAngle_28_29_20const, b2RevoluteJoint__GetJointSpeed_28_29_20const, b2RevoluteJoint__IsLimitEnabled_28_29_20const, b2RevoluteJoint__EnableLimit_28bool_29, b2RevoluteJoint__GetLowerLimit_28_29_20const, b2RevoluteJoint__GetUpperLimit_28_29_20const, b2RevoluteJoint__SetLimits_28float_2c_20float_29, b2RevoluteJoint__IsMotorEnabled_28_29_20const, b2RevoluteJoint__EnableMotor_28bool_29, b2RevoluteJoint__SetMotorSpeed_28float_29, b2RevoluteJoint__GetMotorSpeed_28_29_20const, b2RevoluteJoint__SetMaxMotorTorque_28float_29, b2RevoluteJoint__GetMaxMotorTorque_28_29_20const, b2RevoluteJoint__GetMotorTorque_28float_29_20const, void_20const__20emscripten__internal__getActualType_b2RopeJointDef__28b2RopeJointDef__29, void_20emscripten__internal__raw_destructor_b2RopeJointDef__28b2RopeJointDef__29, b2RopeJointDef__20emscripten__internal__operator_new_b2RopeJointDef__28_29, b2Vec2__20emscripten__internal__MemberAccess_b2RopeJointDef_2c_20b2Vec2___getWire_b2RopeJointDef__28b2Vec2_20b2RopeJointDef____20const__2c_20b2RopeJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2RopeJointDef_2c_20b2Vec2___setWire_b2RopeJointDef__28b2Vec2_20b2RopeJointDef____20const__2c_20b2RopeJointDef__2c_20b2Vec2__29, float_20emscripten__internal__MemberAccess_b2RopeJointDef_2c_20float___getWire_b2RopeJointDef__28float_20b2RopeJointDef____20const__2c_20b2RopeJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2RopeJointDef_2c_20float___setWire_b2RopeJointDef__28float_20b2RopeJointDef____20const__2c_20b2RopeJointDef__2c_20float_29, void_20const__20emscripten__internal__getActualType_b2RopeJoint__28b2RopeJoint__29, void_20emscripten__internal__raw_destructor_b2RopeJoint__28b2RopeJoint__29, b2RopeJoint__GetLocalAnchorA_28_29_20const, b2RopeJoint__GetLocalAnchorB_28_29_20const, b2RopeJoint__SetMaxLength_28float_29, b2RopeJoint__GetMaxLength_28_29_20const, b2RopeJoint__GetLength_28_29_20const, void_20const__20emscripten__internal__getActualType_b2WeldJointDef__28b2WeldJointDef__29, void_20emscripten__internal__raw_destructor_b2WeldJointDef__28b2WeldJointDef__29, b2WeldJointDef__20emscripten__internal__operator_new_b2WeldJointDef__28_29, b2Vec2__20emscripten__internal__MemberAccess_b2WeldJointDef_2c_20b2Vec2___getWire_b2WeldJointDef__28b2Vec2_20b2WeldJointDef____20const__2c_20b2WeldJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2WeldJointDef_2c_20b2Vec2___setWire_b2WeldJointDef__28b2Vec2_20b2WeldJointDef____20const__2c_20b2WeldJointDef__2c_20b2Vec2__29, float_20emscripten__internal__MemberAccess_b2WeldJointDef_2c_20float___getWire_b2WeldJointDef__28float_20b2WeldJointDef____20const__2c_20b2WeldJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2WeldJointDef_2c_20float___setWire_b2WeldJointDef__28float_20b2WeldJointDef____20const__2c_20b2WeldJointDef__2c_20float_29, void_20const__20emscripten__internal__getActualType_b2WeldJoint__28b2WeldJoint__29, void_20emscripten__internal__raw_destructor_b2WeldJoint__28b2WeldJoint__29, b2WeldJoint__GetLocalAnchorA_28_29_20const, b2WeldJoint__GetLocalAnchorB_28_29_20const, b2WeldJoint__GetReferenceAngle_28_29_20const, b2WeldJoint__SetStiffness_28float_29, b2WeldJoint__GetStiffness_28_29_20const, b2WeldJoint__SetDamping_28float_29, b2WeldJoint__GetDamping_28_29_20const, void_20const__20emscripten__internal__getActualType_b2WheelJointDef__28b2WheelJointDef__29, void_20emscripten__internal__raw_destructor_b2WheelJointDef__28b2WheelJointDef__29, b2WheelJointDef__20emscripten__internal__operator_new_b2WheelJointDef__28_29, b2Vec2__20emscripten__internal__MemberAccess_b2WheelJointDef_2c_20b2Vec2___getWire_b2WheelJointDef__28b2Vec2_20b2WheelJointDef____20const__2c_20b2WheelJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2WheelJointDef_2c_20b2Vec2___setWire_b2WheelJointDef__28b2Vec2_20b2WheelJointDef____20const__2c_20b2WheelJointDef__2c_20b2Vec2__29, bool_20emscripten__internal__MemberAccess_b2WheelJointDef_2c_20bool___getWire_b2WheelJointDef__28bool_20b2WheelJointDef____20const__2c_20b2WheelJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2WheelJointDef_2c_20bool___setWire_b2WheelJointDef__28bool_20b2WheelJointDef____20const__2c_20b2WheelJointDef__2c_20bool_29, float_20emscripten__internal__MemberAccess_b2WheelJointDef_2c_20float___getWire_b2WheelJointDef__28float_20b2WheelJointDef____20const__2c_20b2WheelJointDef_20const__29, void_20emscripten__internal__MemberAccess_b2WheelJointDef_2c_20float___setWire_b2WheelJointDef__28float_20b2WheelJointDef____20const__2c_20b2WheelJointDef__2c_20float_29, void_20const__20emscripten__internal__getActualType_b2WheelJoint__28b2WheelJoint__29, void_20emscripten__internal__raw_destructor_b2WheelJoint__28b2WheelJoint__29, b2WheelJoint__GetLocalAnchorA_28_29_20const, b2WheelJoint__GetLocalAnchorB_28_29_20const, b2WheelJoint__GetLocalAxisA_28_29_20const, b2WheelJoint__GetJointTranslation_28_29_20const, b2WheelJoint__IsMotorEnabled_28_29_20const, b2WheelJoint__EnableMotor_28bool_29, b2WheelJoint__SetMotorSpeed_28float_29, b2WheelJoint__GetMotorSpeed_28_29_20const, b2WheelJoint__SetMaxMotorTorque_28float_29, b2WheelJoint__GetMaxMotorTorque_28_29_20const, b2WheelJoint__GetMotorTorque_28float_29_20const, b2WheelJoint__SetStiffness_28float_29, b2WheelJoint__GetStiffness_28_29_20const, b2WheelJoint__SetDamping_28float_29, b2WheelJoint__GetDamping_28_29_20const, emscripten__internal__Invoker_float_2c_20unsigned_20int_2c_20int___invoke_28float_20_28__29_28unsigned_20int_2c_20int_29_2c_20unsigned_20int_2c_20int_29, emscripten__internal__Invoker_void_2c_20b2Joint__2c_20float_2c_20float___invoke_28void_20_28__29_28b2Joint__2c_20float_2c_20float_29_2c_20b2Joint__2c_20float_2c_20float_29, emscripten__internal__Invoker_b2Vec2_2c_20b2Transform_20const__2c_20b2Vec2_20const____invoke_28b2Vec2_20_28__29_28b2Transform_20const__2c_20b2Vec2_20const__29_2c_20b2Transform__2c_20b2Vec2__29, emscripten__internal__Invoker_void_2c_20unsigned_20int_2c_20bool___invoke_28void_20_28__29_28unsigned_20int_2c_20bool_29_2c_20unsigned_20int_2c_20bool_29, emscripten__internal__Invoker_bool_2c_20unsigned_20int___invoke_28bool_20_28__29_28unsigned_20int_29_2c_20unsigned_20int_29, emscripten__internal__Invoker_void_2c_20unsigned_20int_2c_20float___invoke_28void_20_28__29_28unsigned_20int_2c_20float_29_2c_20unsigned_20int_2c_20float_29, emscripten__internal__Invoker_float_2c_20unsigned_20int___invoke_28float_20_28__29_28unsigned_20int_29_2c_20unsigned_20int_29, emscripten__internal__Invoker_void_2c_20unsigned_20int___invoke_28void_20_28__29_28unsigned_20int_29_2c_20unsigned_20int_29, emscripten__internal__Invoker_unsigned_20int_2c_20unsigned_20int___invoke_28unsigned_20int_20_28__29_28unsigned_20int_29_2c_20unsigned_20int_29, emscripten__internal__Invoker_void_2c_20unsigned_20int_2c_20unsigned_20int___invoke_28void_20_28__29_28unsigned_20int_2c_20unsigned_20int_29_2c_20unsigned_20int_2c_20unsigned_20int_29, emscripten__internal__Invoker_unsigned_20int_2c_20unsigned_20int_2c_20int___invoke_28unsigned_20int_20_28__29_28unsigned_20int_2c_20int_29_2c_20unsigned_20int_2c_20int_29, emscripten__internal__Invoker_unsigned_20int___invoke_28unsigned_20int_20_28__29_28_29_29, emscripten__internal__Invoker_int_2c_20unsigned_20int___invoke_28int_20_28__29_28unsigned_20int_29_2c_20unsigned_20int_29, std____2__vector_int_2c_20std____2__allocator_int____push_back_5babi_v160004_5d_28int_20const__29, std____2__vector_int_2c_20std____2__allocator_int____resize_28unsigned_20long_2c_20int_20const__29, std____2__vector_int_2c_20std____2__allocator_int____size_5babi_v160004_5d_28_29_20const, void_20const__20emscripten__internal__getActualType_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int____29, void_20emscripten__internal__raw_destructor_std____2__vector_int_2c_20std____2__allocator_int____28std____2__vector_int_2c_20std____2__allocator_int____29, std____2__vector_int_2c_20std____2__allocator_int____20emscripten__internal__operator_new_std____2__vector_int_2c_20std____2__allocator_int____28_29, emscripten__internal__VectorAccess_std____2__vector_int_2c_20std____2__allocator_int_____get_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29, emscripten__internal__VectorAccess_std____2__vector_int_2c_20std____2__allocator_int_____set_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29, b2Vec2__20emscripten__internal__raw_constructor_b2Vec2__28_29, void_20emscripten__internal__raw_destructor_b2Vec2__28b2Vec2__29, float_20emscripten__internal__MemberAccess_b2Vec2_2c_20float___getWire_b2Vec2__28float_20b2Vec2____20const__2c_20b2Vec2_20const__29, void_20emscripten__internal__MemberAccess_b2Vec2_2c_20float___setWire_b2Vec2__28float_20b2Vec2____20const__2c_20b2Vec2__2c_20float_29, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____push_back_5babi_v160004_5d_28b2Vec2_20const__29, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____resize_28unsigned_20long_2c_20b2Vec2_20const__29, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____size_5babi_v160004_5d_28_29_20const, void_20const__20emscripten__internal__getActualType_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29, void_20emscripten__internal__raw_destructor_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____29, std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____20emscripten__internal__operator_new_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____28_29, emscripten__internal__VectorAccess_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____get_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29, emscripten__internal__VectorAccess_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2_____set_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29, b2Rot__20emscripten__internal__raw_constructor_b2Rot__28_29, void_20emscripten__internal__raw_destructor_b2Rot__28b2Rot__29, float_20emscripten__internal__MemberAccess_b2Rot_2c_20float___getWire_b2Rot__28float_20b2Rot____20const__2c_20b2Rot_20const__29, void_20emscripten__internal__MemberAccess_b2Rot_2c_20float___setWire_b2Rot__28float_20b2Rot____20const__2c_20b2Rot__2c_20float_29, b2Transform__20emscripten__internal__raw_constructor_b2Transform__28_29, void_20emscripten__internal__raw_destructor_b2Transform__28b2Transform__29, b2Vec2__20emscripten__internal__MemberAccess_b2Transform_2c_20b2Vec2___getWire_b2Transform__28b2Vec2_20b2Transform____20const__2c_20b2Transform_20const__29, void_20emscripten__internal__MemberAccess_b2Transform_2c_20b2Vec2___setWire_b2Transform__28b2Vec2_20b2Transform____20const__2c_20b2Transform__2c_20b2Vec2__29, b2Rot__20emscripten__internal__MemberAccess_b2Transform_2c_20b2Rot___getWire_b2Transform__28b2Rot_20b2Transform____20const__2c_20b2Transform_20const__29, void_20emscripten__internal__MemberAccess_b2Transform_2c_20b2Rot___setWire_b2Transform__28b2Rot_20b2Transform____20const__2c_20b2Transform__2c_20b2Rot__29, b2Color__20emscripten__internal__raw_constructor_b2Color__28_29, void_20emscripten__internal__raw_destructor_b2Color__28b2Color__29, float_20emscripten__internal__MemberAccess_b2Color_2c_20float___getWire_b2Color__28float_20b2Color____20const__2c_20b2Color_20const__29, void_20emscripten__internal__MemberAccess_b2Color_2c_20float___setWire_b2Color__28float_20b2Color____20const__2c_20b2Color__2c_20float_29, b2RayCastInput__20emscripten__internal__raw_constructor_b2RayCastInput__28_29, void_20emscripten__internal__raw_destructor_b2RayCastInput__28b2RayCastInput__29, b2Vec2__20emscripten__internal__MemberAccess_b2RayCastInput_2c_20b2Vec2___getWire_b2RayCastInput__28b2Vec2_20b2RayCastInput____20const__2c_20b2RayCastInput_20const__29, void_20emscripten__internal__MemberAccess_b2RayCastInput_2c_20b2Vec2___setWire_b2RayCastInput__28b2Vec2_20b2RayCastInput____20const__2c_20b2RayCastInput__2c_20b2Vec2__29, float_20emscripten__internal__MemberAccess_b2RayCastInput_2c_20float___getWire_b2RayCastInput__28float_20b2RayCastInput____20const__2c_20b2RayCastInput_20const__29, void_20emscripten__internal__MemberAccess_b2RayCastInput_2c_20float___setWire_b2RayCastInput__28float_20b2RayCastInput____20const__2c_20b2RayCastInput__2c_20float_29, b2RayCastOutput__20emscripten__internal__raw_constructor_b2RayCastOutput__28_29, void_20emscripten__internal__raw_destructor_b2RayCastOutput__28b2RayCastOutput__29, b2Vec2__20emscripten__internal__MemberAccess_b2RayCastOutput_2c_20b2Vec2___getWire_b2RayCastOutput__28b2Vec2_20b2RayCastOutput____20const__2c_20b2RayCastOutput_20const__29, void_20emscripten__internal__MemberAccess_b2RayCastOutput_2c_20b2Vec2___setWire_b2RayCastOutput__28b2Vec2_20b2RayCastOutput____20const__2c_20b2RayCastOutput__2c_20b2Vec2__29, float_20emscripten__internal__MemberAccess_b2RayCastOutput_2c_20float___getWire_b2RayCastOutput__28float_20b2RayCastOutput____20const__2c_20b2RayCastOutput_20const__29, void_20emscripten__internal__MemberAccess_b2RayCastOutput_2c_20float___setWire_b2RayCastOutput__28float_20b2RayCastOutput____20const__2c_20b2RayCastOutput__2c_20float_29, b2MassData__20emscripten__internal__raw_constructor_b2MassData__28_29, void_20emscripten__internal__raw_destructor_b2MassData__28b2MassData__29, float_20emscripten__internal__MemberAccess_b2MassData_2c_20float___getWire_b2MassData__28float_20b2MassData____20const__2c_20b2MassData_20const__29, void_20emscripten__internal__MemberAccess_b2MassData_2c_20float___setWire_b2MassData__28float_20b2MassData____20const__2c_20b2MassData__2c_20float_29, b2Vec2__20emscripten__internal__MemberAccess_b2MassData_2c_20b2Vec2___getWire_b2MassData__28b2Vec2_20b2MassData____20const__2c_20b2MassData_20const__29, void_20emscripten__internal__MemberAccess_b2MassData_2c_20b2Vec2___setWire_b2MassData__28b2Vec2_20b2MassData____20const__2c_20b2MassData__2c_20b2Vec2__29, b2Filter__20emscripten__internal__raw_constructor_b2Filter__28_29, void_20emscripten__internal__raw_destructor_b2Filter__28b2Filter__29, unsigned_20short_20emscripten__internal__MemberAccess_b2Filter_2c_20unsigned_20short___getWire_b2Filter__28unsigned_20short_20b2Filter____20const__2c_20b2Filter_20const__29, void_20emscripten__internal__MemberAccess_b2Filter_2c_20unsigned_20short___setWire_b2Filter__28unsigned_20short_20b2Filter____20const__2c_20b2Filter__2c_20unsigned_20short_29, short_20emscripten__internal__MemberAccess_b2Filter_2c_20short___getWire_b2Filter__28short_20b2Filter____20const__2c_20b2Filter_20const__29, void_20emscripten__internal__MemberAccess_b2Filter_2c_20short___setWire_b2Filter__28short_20b2Filter____20const__2c_20b2Filter__2c_20short_29, emscripten__internal__MethodInvoker_bool_20_28b2QueryCallback____29_28unsigned_20int_29_2c_20bool_2c_20b2QueryCallback__2c_20unsigned_20int___invoke_28bool_20_28b2QueryCallback____20const__29_28unsigned_20int_29_2c_20b2QueryCallback__2c_20unsigned_20int_29, b2QueryCallback__20emscripten__base_b2QueryCallback___convertPointer_b2QueryCallbackWrapper_2c_20b2QueryCallback__28b2QueryCallbackWrapper__29, b2QueryCallbackWrapper__20emscripten__base_b2QueryCallback___convertPointer_b2QueryCallback_2c_20b2QueryCallbackWrapper__28b2QueryCallback__29, emscripten__class__b2QueryCallback_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2QueryCallback_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2QueryCallbackWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2QueryCallbackWrapper__29____invoke_28b2QueryCallbackWrapper__29, emscripten__internal__FunctionInvoker_void_20_28__29_28b2QueryCallbackWrapper__29_2c_20void_2c_20b2QueryCallbackWrapper____invoke_28void_20_28___29_28b2QueryCallbackWrapper__29_2c_20b2QueryCallbackWrapper__29, emscripten__internal__MethodInvoker_float_20_28b2RayCastCallback____29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29_2c_20float_2c_20b2RayCastCallback__2c_20unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float___invoke_28float_20_28b2RayCastCallback____20const__29_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29_2c_20b2RayCastCallback__2c_20unsigned_20int_2c_20b2Vec2__2c_20b2Vec2__2c_20float_29, b2RayCastCallback__20emscripten__base_b2RayCastCallback___convertPointer_b2RayCastCallbackWrapper_2c_20b2RayCastCallback__28b2RayCastCallbackWrapper__29, b2RayCastCallbackWrapper__20emscripten__base_b2RayCastCallback___convertPointer_b2RayCastCallback_2c_20b2RayCastCallbackWrapper__28b2RayCastCallback__29, emscripten__class__b2RayCastCallback_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2RayCastCallback_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2RayCastCallbackWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2RayCastCallbackWrapper__29____invoke_28b2RayCastCallbackWrapper__29, emscripten__internal__FunctionInvoker_void_20_28__29_28b2RayCastCallbackWrapper__29_2c_20void_2c_20b2RayCastCallbackWrapper____invoke_28void_20_28___29_28b2RayCastCallbackWrapper__29_2c_20b2RayCastCallbackWrapper__29, emscripten__internal__MethodInvoker_void_20_28b2ContactListener____29_28unsigned_20int_29_2c_20void_2c_20b2ContactListener__2c_20unsigned_20int___invoke_28void_20_28b2ContactListener____20const__29_28unsigned_20int_29_2c_20b2ContactListener__2c_20unsigned_20int_29, emscripten__internal__MethodInvoker_void_20_28b2ContactListener____29_28unsigned_20int_2c_20unsigned_20int_29_2c_20void_2c_20b2ContactListener__2c_20unsigned_20int_2c_20unsigned_20int___invoke_28void_20_28b2ContactListener____20const__29_28unsigned_20int_2c_20unsigned_20int_29_2c_20b2ContactListener__2c_20unsigned_20int_2c_20unsigned_20int_29, emscripten__internal__MethodInvoker_void_20_28b2ContactListenerWrapper____29_28unsigned_20int_29_2c_20void_2c_20b2ContactListenerWrapper__2c_20unsigned_20int___invoke_28void_20_28b2ContactListenerWrapper____20const__29_28unsigned_20int_29_2c_20b2ContactListenerWrapper__2c_20unsigned_20int_29, emscripten__internal__MethodInvoker_bool_20_28b2ContactListenerWrapper____29_28unsigned_20int_29_2c_20bool_2c_20b2ContactListenerWrapper__2c_20unsigned_20int___invoke_28bool_20_28b2ContactListenerWrapper____20const__29_28unsigned_20int_29_2c_20b2ContactListenerWrapper__2c_20unsigned_20int_29, b2ContactListener__20emscripten__base_b2ContactListener___convertPointer_b2ContactListenerWrapper_2c_20b2ContactListener__28b2ContactListenerWrapper__29, b2ContactListenerWrapper__20emscripten__base_b2ContactListener___convertPointer_b2ContactListener_2c_20b2ContactListenerWrapper__28b2ContactListener__29, emscripten__class__b2ContactListener_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2ContactListener_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2ContactListenerWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2ContactListenerWrapper__29____invoke_28b2ContactListenerWrapper__29, emscripten__internal__FunctionInvoker_void_20_28__29_28b2ContactListenerWrapper__29_2c_20void_2c_20b2ContactListenerWrapper____invoke_28void_20_28___29_28b2ContactListenerWrapper__29_2c_20b2ContactListenerWrapper__29, emscripten__internal__MethodInvoker_void_20_28b2Draw____29_28unsigned_20int_29_2c_20void_2c_20b2Draw__2c_20unsigned_20int___invoke_28void_20_28b2Draw____20const__29_28unsigned_20int_29_2c_20b2Draw__2c_20unsigned_20int_29, emscripten__internal__MethodInvoker_unsigned_20int_20_28b2Draw____29_28_29_20const_2c_20unsigned_20int_2c_20b2Draw_20const____invoke_28unsigned_20int_20_28b2Draw____20const__29_28_29_20const_2c_20b2Draw_20const__29, emscripten__internal__MethodInvoker_void_20_28b2Draw____29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29_2c_20void_2c_20b2Draw__2c_20unsigned_20int_2c_20int_2c_20b2Color_20const____invoke_28void_20_28b2Draw____20const__29_28unsigned_20int_2c_20int_2c_20b2Color_20const__29_2c_20b2Draw__2c_20unsigned_20int_2c_20int_2c_20b2Color__29, emscripten__internal__MethodInvoker_void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29_2c_20void_2c_20b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Color_20const____invoke_28void_20_28b2Draw____20const__29_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29_2c_20b2Draw__2c_20b2Vec2__2c_20float_2c_20b2Color__29, emscripten__internal__MethodInvoker_void_20_28b2Draw____29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29_2c_20void_2c_20b2Draw__2c_20b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const____invoke_28void_20_28b2Draw____20const__29_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29_2c_20b2Draw__2c_20b2Vec2__2c_20float_2c_20b2Vec2__2c_20b2Color__29, emscripten__internal__MethodInvoker_void_20_28b2Draw____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29_2c_20void_2c_20b2Draw__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const____invoke_28void_20_28b2Draw____20const__29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29_2c_20b2Draw__2c_20b2Vec2__2c_20b2Vec2__2c_20b2Color__29, emscripten__internal__MethodInvoker_void_20_28b2Draw____29_28b2Transform_20const__29_2c_20void_2c_20b2Draw__2c_20b2Transform_20const____invoke_28void_20_28b2Draw____20const__29_28b2Transform_20const__29_2c_20b2Draw__2c_20b2Transform__29, b2Draw__20emscripten__base_b2Draw___convertPointer_b2DrawWrapper_2c_20b2Draw__28b2DrawWrapper__29, b2DrawWrapper__20emscripten__base_b2Draw___convertPointer_b2Draw_2c_20b2DrawWrapper__28b2Draw__29, emscripten__class__b2Draw_2c_20emscripten__internal__NoBaseClass__20const__20emscripten__class__b2Draw_2c_20emscripten__internal__NoBaseClass___allow_subclass_b2DrawWrapper__28char_20const__2c_20emscripten__constructor___29_20const___lambda__28b2DrawWrapper__29____invoke_28b2DrawWrapper__29, emscripten__internal__FunctionInvoker_void_20_28__29_28b2DrawWrapper__29_2c_20void_2c_20b2DrawWrapper____invoke_28void_20_28___29_28b2DrawWrapper__29_2c_20b2DrawWrapper__29, emscripten__internal__Invoker_b2AABB____invoke_28b2AABB__20_28__29_28_29_29, emscripten__internal__MethodInvoker_bool_20_28b2AABB____29_28_29_20const_2c_20bool_2c_20b2AABB_20const____invoke_28bool_20_28b2AABB____20const__29_28_29_20const_2c_20b2AABB_20const__29, emscripten__internal__MethodInvoker_b2Vec2_20_28b2AABB____29_28_29_20const_2c_20b2Vec2_2c_20b2AABB_20const____invoke_28b2Vec2_20_28b2AABB____20const__29_28_29_20const_2c_20b2AABB_20const__29, emscripten__internal__MethodInvoker_float_20_28b2AABB____29_28_29_20const_2c_20float_2c_20b2AABB_20const____invoke_28float_20_28b2AABB____20const__29_28_29_20const_2c_20b2AABB_20const__29, emscripten__internal__FunctionInvoker_void_20_28__29_28b2AABB__2c_20b2AABB__29_2c_20void_2c_20b2AABB__2c_20b2AABB____invoke_28void_20_28___29_28b2AABB__2c_20b2AABB__29_2c_20b2AABB__2c_20b2AABB__29, emscripten__internal__FunctionInvoker_void_20_28__29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29_2c_20void_2c_20b2AABB__2c_20b2AABB__2c_20b2AABB____invoke_28void_20_28___29_28b2AABB__2c_20b2AABB__2c_20b2AABB__29_2c_20b2AABB__2c_20b2AABB__2c_20b2AABB__29, emscripten__internal__MethodInvoker_bool_20_28b2AABB____29_28b2AABB_20const__29_20const_2c_20bool_2c_20b2AABB_20const__2c_20b2AABB_20const____invoke_28bool_20_28b2AABB____20const__29_28b2AABB_20const__29_20const_2c_20b2AABB_20const__2c_20b2AABB__29, emscripten__internal__MethodInvoker_bool_20_28b2AABB____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const_2c_20bool_2c_20b2AABB_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const____invoke_28bool_20_28b2AABB____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__29_20const_2c_20b2AABB_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput__29, emscripten__internal__Invoker_b2World__2c_20b2Vec2_____invoke_28b2World__20_28__29_28b2Vec2___29_2c_20b2Vec2__29, emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2ContactListener__29_2c_20void_2c_20b2World__2c_20b2ContactListener____invoke_28void_20_28b2World____20const__29_28b2ContactListener__29_2c_20b2World__2c_20b2ContactListener__29, emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2Draw__29_2c_20void_2c_20b2World__2c_20b2Draw____invoke_28void_20_28b2World____20const__29_28b2Draw__29_2c_20b2World__2c_20b2Draw__29, emscripten__internal__MethodInvoker_void_20_28b2World____29_28_29_2c_20void_2c_20b2World____invoke_28void_20_28b2World____20const__29_28_29_2c_20b2World__29, emscripten__internal__MethodInvoker_b2Body__20_28b2World____29_28b2BodyDef_20const__29_2c_20b2Body__2c_20b2World__2c_20b2BodyDef_20const____invoke_28b2Body__20_28b2World____20const__29_28b2BodyDef_20const__29_2c_20b2World__2c_20b2BodyDef_20const__29, emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2Body__29_2c_20void_2c_20b2World__2c_20b2Body____invoke_28void_20_28b2World____20const__29_28b2Body__29_2c_20b2World__2c_20b2Body__29, emscripten__internal__MethodInvoker_b2Joint__20_28b2World____29_28b2JointDef_20const__29_2c_20b2Joint__2c_20b2World__2c_20b2JointDef_20const____invoke_28b2Joint__20_28b2World____20const__29_28b2JointDef_20const__29_2c_20b2World__2c_20b2JointDef_20const__29, emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2Joint__29_2c_20void_2c_20b2World__2c_20b2Joint____invoke_28void_20_28b2World____20const__29_28b2Joint__29_2c_20b2World__2c_20b2Joint__29, emscripten__internal__MethodInvoker_void_20_28b2World____29_28float_2c_20int_2c_20int_29_2c_20void_2c_20b2World__2c_20float_2c_20int_2c_20int___invoke_28void_20_28b2World____20const__29_28float_2c_20int_2c_20int_29_2c_20b2World__2c_20float_2c_20int_2c_20int_29, emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2QueryCallback__2c_20b2AABB_20const__29_20const_2c_20void_2c_20b2World_20const__2c_20b2QueryCallback__2c_20b2AABB_20const____invoke_28void_20_28b2World____20const__29_28b2QueryCallback__2c_20b2AABB_20const__29_20const_2c_20b2World_20const__2c_20b2QueryCallback__2c_20b2AABB__29, emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const_2c_20void_2c_20b2World_20const__2c_20b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const____invoke_28void_20_28b2World____20const__29_28b2RayCastCallback__2c_20b2Vec2_20const__2c_20b2Vec2_20const__29_20const_2c_20b2World_20const__2c_20b2RayCastCallback__2c_20b2Vec2__2c_20b2Vec2__29, emscripten__internal__MethodInvoker_void_20_28b2World____29_28bool_29_2c_20void_2c_20b2World__2c_20bool___invoke_28void_20_28b2World____20const__29_28bool_29_2c_20b2World__2c_20bool_29, emscripten__internal__MethodInvoker_bool_20_28b2World____29_28_29_20const_2c_20bool_2c_20b2World_20const____invoke_28bool_20_28b2World____20const__29_28_29_20const_2c_20b2World_20const__29, emscripten__internal__MethodInvoker_void_20_28b2World____29_28b2Vec2_20const__29_2c_20void_2c_20b2World__2c_20b2Vec2_20const____invoke_28void_20_28b2World____20const__29_28b2Vec2_20const__29_2c_20b2World__2c_20b2Vec2__29, emscripten__internal__MethodInvoker_b2Vec2_20_28b2World____29_28_29_20const_2c_20b2Vec2_2c_20b2World_20const____invoke_28b2Vec2_20_28b2World____20const__29_28_29_20const_2c_20b2World_20const__29, emscripten__internal__MethodInvoker_b2Shape__Type_20_28b2Shape____29_28_29_20const_2c_20b2Shape__Type_2c_20b2Shape_20const____invoke_28b2Shape__Type_20_28b2Shape____20const__29_28_29_20const_2c_20b2Shape_20const__29, emscripten__internal__MethodInvoker_int_20_28b2Shape____29_28_29_20const_2c_20int_2c_20b2Shape_20const____invoke_28int_20_28b2Shape____20const__29_28_29_20const_2c_20b2Shape_20const__29, emscripten__internal__MethodInvoker_bool_20_28b2Shape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20bool_2c_20b2Shape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____invoke_28bool_20_28b2Shape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20b2Shape_20const__2c_20b2Transform__2c_20b2Vec2__29, emscripten__internal__MethodInvoker_bool_20_28b2Shape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20bool_2c_20b2Shape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___invoke_28bool_20_28b2Shape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2Shape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput__2c_20b2Transform__2c_20int_29, emscripten__internal__MethodInvoker_void_20_28b2Shape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20void_2c_20b2Shape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___invoke_28void_20_28b2Shape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2Shape_20const__2c_20b2AABB__2c_20b2Transform__2c_20int_29, emscripten__internal__MethodInvoker_void_20_28b2Shape____29_28b2MassData__2c_20float_29_20const_2c_20void_2c_20b2Shape_20const__2c_20b2MassData__2c_20float___invoke_28void_20_28b2Shape____20const__29_28b2MassData__2c_20float_29_20const_2c_20b2Shape_20const__2c_20b2MassData__2c_20float_29, emscripten__internal__FunctionInvoker_void_20_28__29_28b2Shape__2c_20float_29_2c_20void_2c_20b2Shape__2c_20float___invoke_28void_20_28___29_28b2Shape__2c_20float_29_2c_20b2Shape__2c_20float_29, emscripten__internal__FunctionInvoker_float_20_28__29_28b2Shape__29_2c_20float_2c_20b2Shape____invoke_28float_20_28___29_28b2Shape__29_2c_20b2Shape__29, b2Shape__20emscripten__base_b2Shape___convertPointer_b2CircleShape_2c_20b2Shape__28b2CircleShape__29, b2CircleShape__20emscripten__base_b2Shape___convertPointer_b2Shape_2c_20b2CircleShape__28b2Shape__29, emscripten__internal__Invoker_b2CircleShape____invoke_28b2CircleShape__20_28__29_28_29_29, emscripten__internal__MethodInvoker_b2Shape__20_28b2CircleShape____29_28b2BlockAllocator__29_20const_2c_20b2Shape__2c_20b2CircleShape_20const__2c_20b2BlockAllocator____invoke_28b2Shape__20_28b2CircleShape____20const__29_28b2BlockAllocator__29_20const_2c_20b2CircleShape_20const__2c_20b2BlockAllocator__29, emscripten__internal__MethodInvoker_int_20_28b2CircleShape____29_28_29_20const_2c_20int_2c_20b2CircleShape_20const____invoke_28int_20_28b2CircleShape____20const__29_28_29_20const_2c_20b2CircleShape_20const__29, emscripten__internal__MethodInvoker_bool_20_28b2CircleShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20bool_2c_20b2CircleShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____invoke_28bool_20_28b2CircleShape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20b2CircleShape_20const__2c_20b2Transform__2c_20b2Vec2__29, emscripten__internal__MethodInvoker_bool_20_28b2CircleShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20bool_2c_20b2CircleShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___invoke_28bool_20_28b2CircleShape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2CircleShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput__2c_20b2Transform__2c_20int_29, emscripten__internal__MethodInvoker_void_20_28b2CircleShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20void_2c_20b2CircleShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___invoke_28void_20_28b2CircleShape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2CircleShape_20const__2c_20b2AABB__2c_20b2Transform__2c_20int_29, emscripten__internal__MethodInvoker_void_20_28b2CircleShape____29_28b2MassData__2c_20float_29_20const_2c_20void_2c_20b2CircleShape_20const__2c_20b2MassData__2c_20float___invoke_28void_20_28b2CircleShape____20const__29_28b2MassData__2c_20float_29_20const_2c_20b2CircleShape_20const__2c_20b2MassData__2c_20float_29, b2Shape__20emscripten__base_b2Shape___convertPointer_b2EdgeShape_2c_20b2Shape__28b2EdgeShape__29, b2EdgeShape__20emscripten__base_b2Shape___convertPointer_b2Shape_2c_20b2EdgeShape__28b2Shape__29, emscripten__internal__MethodInvoker_b2Shape__20_28b2EdgeShape____29_28b2BlockAllocator__29_20const_2c_20b2Shape__2c_20b2EdgeShape_20const__2c_20b2BlockAllocator____invoke_28b2Shape__20_28b2EdgeShape____20const__29_28b2BlockAllocator__29_20const_2c_20b2EdgeShape_20const__2c_20b2BlockAllocator__29, emscripten__internal__MethodInvoker_int_20_28b2EdgeShape____29_28_29_20const_2c_20int_2c_20b2EdgeShape_20const____invoke_28int_20_28b2EdgeShape____20const__29_28_29_20const_2c_20b2EdgeShape_20const__29, emscripten__internal__MethodInvoker_bool_20_28b2EdgeShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20bool_2c_20b2EdgeShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____invoke_28bool_20_28b2EdgeShape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20b2EdgeShape_20const__2c_20b2Transform__2c_20b2Vec2__29, emscripten__internal__MethodInvoker_bool_20_28b2EdgeShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20bool_2c_20b2EdgeShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___invoke_28bool_20_28b2EdgeShape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2EdgeShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput__2c_20b2Transform__2c_20int_29, emscripten__internal__MethodInvoker_void_20_28b2EdgeShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20void_2c_20b2EdgeShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___invoke_28void_20_28b2EdgeShape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2EdgeShape_20const__2c_20b2AABB__2c_20b2Transform__2c_20int_29, emscripten__internal__MethodInvoker_void_20_28b2EdgeShape____29_28b2MassData__2c_20float_29_20const_2c_20void_2c_20b2EdgeShape_20const__2c_20b2MassData__2c_20float___invoke_28void_20_28b2EdgeShape____20const__29_28b2MassData__2c_20float_29_20const_2c_20b2EdgeShape_20const__2c_20b2MassData__2c_20float_29, b2Shape__20emscripten__base_b2Shape___convertPointer_b2PolygonShape_2c_20b2Shape__28b2PolygonShape__29, b2PolygonShape__20emscripten__base_b2Shape___convertPointer_b2Shape_2c_20b2PolygonShape__28b2Shape__29, emscripten__internal__Invoker_b2PolygonShape____invoke_28b2PolygonShape__20_28__29_28_29_29, emscripten__internal__MethodInvoker_b2Shape__20_28b2PolygonShape____29_28b2BlockAllocator__29_20const_2c_20b2Shape__2c_20b2PolygonShape_20const__2c_20b2BlockAllocator____invoke_28b2Shape__20_28b2PolygonShape____20const__29_28b2BlockAllocator__29_20const_2c_20b2PolygonShape_20const__2c_20b2BlockAllocator__29, emscripten__internal__MethodInvoker_int_20_28b2PolygonShape____29_28_29_20const_2c_20int_2c_20b2PolygonShape_20const____invoke_28int_20_28b2PolygonShape____20const__29_28_29_20const_2c_20b2PolygonShape_20const__29, emscripten__internal__FunctionInvoker_void_20_28__29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29_2c_20void_2c_20b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int___invoke_28void_20_28___29_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29_2c_20b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29, emscripten__internal__MethodInvoker_bool_20_28b2PolygonShape____29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20bool_2c_20b2PolygonShape_20const__2c_20b2Transform_20const__2c_20b2Vec2_20const____invoke_28bool_20_28b2PolygonShape____20const__29_28b2Transform_20const__2c_20b2Vec2_20const__29_20const_2c_20b2PolygonShape_20const__2c_20b2Transform__2c_20b2Vec2__29, emscripten__internal__MethodInvoker_bool_20_28b2PolygonShape____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20bool_2c_20b2PolygonShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int___invoke_28bool_20_28b2PolygonShape____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2PolygonShape_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput__2c_20b2Transform__2c_20int_29, emscripten__internal__MethodInvoker_void_20_28b2PolygonShape____29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20void_2c_20b2PolygonShape_20const__2c_20b2AABB__2c_20b2Transform_20const__2c_20int___invoke_28void_20_28b2PolygonShape____20const__29_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const_2c_20b2PolygonShape_20const__2c_20b2AABB__2c_20b2Transform__2c_20int_29, emscripten__internal__MethodInvoker_void_20_28b2PolygonShape____29_28b2MassData__2c_20float_29_20const_2c_20void_2c_20b2PolygonShape_20const__2c_20b2MassData__2c_20float___invoke_28void_20_28b2PolygonShape____20const__29_28b2MassData__2c_20float_29_20const_2c_20b2PolygonShape_20const__2c_20b2MassData__2c_20float_29, emscripten__internal__MethodInvoker_bool_20_28b2PolygonShape____29_28_29_20const_2c_20bool_2c_20b2PolygonShape_20const____invoke_28bool_20_28b2PolygonShape____20const__29_28_29_20const_2c_20b2PolygonShape_20const__29, emscripten__internal__MethodInvoker_void_20_28b2PolygonShape____29_28float_2c_20float_29_2c_20void_2c_20b2PolygonShape__2c_20float_2c_20float___invoke_28void_20_28b2PolygonShape____20const__29_28float_2c_20float_29_2c_20b2PolygonShape__2c_20float_2c_20float_29, emscripten__internal__MethodInvoker_void_20_28b2PolygonShape____29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29_2c_20void_2c_20b2PolygonShape__2c_20float_2c_20float_2c_20b2Vec2_20const__2c_20float___invoke_28void_20_28b2PolygonShape____20const__29_28float_2c_20float_2c_20b2Vec2_20const__2c_20float_29_2c_20b2PolygonShape__2c_20float_2c_20float_2c_20b2Vec2__2c_20float_29, emscripten__internal__Invoker_b2FixtureDef____invoke_28b2FixtureDef__20_28__29_28_29_29, emscripten__internal__FunctionInvoker_void_20_28__29_28b2FixtureDef__2c_20b2Shape_20const__29_2c_20void_2c_20b2FixtureDef__2c_20b2Shape_20const____invoke_28void_20_28___29_28b2FixtureDef__2c_20b2Shape_20const__29_2c_20b2FixtureDef__2c_20b2Shape_20const__29, emscripten__internal__FunctionInvoker_b2Shape_20const__20_28__29_28b2FixtureDef__29_2c_20b2Shape_20const__2c_20b2FixtureDef____invoke_28b2Shape_20const__20_28___29_28b2FixtureDef__29_2c_20b2FixtureDef__29, emscripten__internal__MethodInvoker_b2Shape__Type_20_28b2Fixture____29_28_29_20const_2c_20b2Shape__Type_2c_20b2Fixture_20const____invoke_28b2Shape__Type_20_28b2Fixture____20const__29_28_29_20const_2c_20b2Fixture_20const__29, emscripten__internal__MethodInvoker_b2Shape__20_28b2Fixture____29_28_29_2c_20b2Shape__2c_20b2Fixture____invoke_28b2Shape__20_28b2Fixture____20const__29_28_29_2c_20b2Fixture__29, emscripten__internal__MethodInvoker_void_20_28b2Fixture____29_28bool_29_2c_20void_2c_20b2Fixture__2c_20bool___invoke_28void_20_28b2Fixture____20const__29_28bool_29_2c_20b2Fixture__2c_20bool_29, emscripten__internal__MethodInvoker_bool_20_28b2Fixture____29_28_29_20const_2c_20bool_2c_20b2Fixture_20const____invoke_28bool_20_28b2Fixture____20const__29_28_29_20const_2c_20b2Fixture_20const__29, emscripten__internal__MethodInvoker_void_20_28b2Fixture____29_28b2Filter_20const__29_2c_20void_2c_20b2Fixture__2c_20b2Filter_20const____invoke_28void_20_28b2Fixture____20const__29_28b2Filter_20const__29_2c_20b2Fixture__2c_20b2Filter__29, emscripten__internal__MethodInvoker_b2Filter_20const__20_28b2Fixture____29_28_29_20const_2c_20b2Filter_20const__2c_20b2Fixture_20const____invoke_28b2Filter_20const__20_28b2Fixture____20const__29_28_29_20const_2c_20b2Fixture_20const__29, emscripten__internal__MethodInvoker_void_20_28b2Fixture____29_28_29_2c_20void_2c_20b2Fixture____invoke_28void_20_28b2Fixture____20const__29_28_29_2c_20b2Fixture__29, emscripten__internal__MethodInvoker_b2Body__20_28b2Fixture____29_28_29_2c_20b2Body__2c_20b2Fixture____invoke_28b2Body__20_28b2Fixture____20const__29_28_29_2c_20b2Fixture__29, emscripten__internal__MethodInvoker_bool_20_28b2Fixture____29_28b2Vec2_20const__29_20const_2c_20bool_2c_20b2Fixture_20const__2c_20b2Vec2_20const____invoke_28bool_20_28b2Fixture____20const__29_28b2Vec2_20const__29_20const_2c_20b2Fixture_20const__2c_20b2Vec2__29, emscripten__internal__MethodInvoker_bool_20_28b2Fixture____29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const_2c_20bool_2c_20b2Fixture_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int___invoke_28bool_20_28b2Fixture____20const__29_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20int_29_20const_2c_20b2Fixture_20const__2c_20b2RayCastOutput__2c_20b2RayCastInput__2c_20int_29, emscripten__internal__MethodInvoker_void_20_28b2Fixture____29_28b2MassData__29_20const_2c_20void_2c_20b2Fixture_20const__2c_20b2MassData____invoke_28void_20_28b2Fixture____20const__29_28b2MassData__29_20const_2c_20b2Fixture_20const__2c_20b2MassData__29, emscripten__internal__MethodInvoker_void_20_28b2Fixture____29_28float_29_2c_20void_2c_20b2Fixture__2c_20float___invoke_28void_20_28b2Fixture____20const__29_28float_29_2c_20b2Fixture__2c_20float_29, emscripten__internal__MethodInvoker_float_20_28b2Fixture____29_28_29_20const_2c_20float_2c_20b2Fixture_20const____invoke_28float_20_28b2Fixture____20const__29_28_29_20const_2c_20b2Fixture_20const__29, emscripten__internal__MethodInvoker_b2AABB_20const__20_28b2Fixture____29_28int_29_20const_2c_20b2AABB_20const__2c_20b2Fixture_20const__2c_20int___invoke_28b2AABB_20const__20_28b2Fixture____20const__29_28int_29_20const_2c_20b2Fixture_20const__2c_20int_29, emscripten__internal__MethodInvoker_void_20_28b2Fixture____29_28int_29_2c_20void_2c_20b2Fixture__2c_20int___invoke_28void_20_28b2Fixture____20const__29_28int_29_2c_20b2Fixture__2c_20int_29, emscripten__internal__Invoker_b2BodyDef____invoke_28b2BodyDef__20_28__29_28_29_29, emscripten__internal__MethodInvoker_b2Fixture__20_28b2Body____29_28b2FixtureDef_20const__29_2c_20b2Fixture__2c_20b2Body__2c_20b2FixtureDef_20const____invoke_28b2Fixture__20_28b2Body____20const__29_28b2FixtureDef_20const__29_2c_20b2Body__2c_20b2FixtureDef_20const__29, emscripten__internal__MethodInvoker_b2Fixture__20_28b2Body____29_28b2Shape_20const__2c_20float_29_2c_20b2Fixture__2c_20b2Body__2c_20b2Shape_20const__2c_20float___invoke_28b2Fixture__20_28b2Body____20const__29_28b2Shape_20const__2c_20float_29_2c_20b2Body__2c_20b2Shape_20const__2c_20float_29, emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2Fixture__29_2c_20void_2c_20b2Body__2c_20b2Fixture____invoke_28void_20_28b2Body____20const__29_28b2Fixture__29_2c_20b2Body__2c_20b2Fixture__29, emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2Vec2_20const__2c_20float_29_2c_20void_2c_20b2Body__2c_20b2Vec2_20const__2c_20float___invoke_28void_20_28b2Body____20const__29_28b2Vec2_20const__2c_20float_29_2c_20b2Body__2c_20b2Vec2__2c_20float_29, emscripten__internal__MethodInvoker_b2Transform_20const__20_28b2Body____29_28_29_20const_2c_20b2Transform_20const__2c_20b2Body_20const____invoke_28b2Transform_20const__20_28b2Body____20const__29_28_29_20const_2c_20b2Body_20const__29, emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2Body____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2Body_20const____invoke_28b2Vec2_20const__20_28b2Body____20const__29_28_29_20const_2c_20b2Body_20const__29, emscripten__internal__MethodInvoker_float_20_28b2Body____29_28_29_20const_2c_20float_2c_20b2Body_20const____invoke_28float_20_28b2Body____20const__29_28_29_20const_2c_20b2Body_20const__29, emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2Vec2_20const__29_2c_20void_2c_20b2Body__2c_20b2Vec2_20const____invoke_28void_20_28b2Body____20const__29_28b2Vec2_20const__29_2c_20b2Body__2c_20b2Vec2__29, emscripten__internal__MethodInvoker_void_20_28b2Body____29_28float_29_2c_20void_2c_20b2Body__2c_20float___invoke_28void_20_28b2Body____20const__29_28float_29_2c_20b2Body__2c_20float_29, emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29_2c_20void_2c_20b2Body__2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool___invoke_28void_20_28b2Body____20const__29_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20bool_29_2c_20b2Body__2c_20b2Vec2__2c_20b2Vec2__2c_20bool_29, emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2Vec2_20const__2c_20bool_29_2c_20void_2c_20b2Body__2c_20b2Vec2_20const__2c_20bool___invoke_28void_20_28b2Body____20const__29_28b2Vec2_20const__2c_20bool_29_2c_20b2Body__2c_20b2Vec2__2c_20bool_29, emscripten__internal__MethodInvoker_void_20_28b2Body____29_28float_2c_20bool_29_2c_20void_2c_20b2Body__2c_20float_2c_20bool___invoke_28void_20_28b2Body____20const__29_28float_2c_20bool_29_2c_20b2Body__2c_20float_2c_20bool_29, emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2MassData__29_20const_2c_20void_2c_20b2Body_20const__2c_20b2MassData____invoke_28void_20_28b2Body____20const__29_28b2MassData__29_20const_2c_20b2Body_20const__2c_20b2MassData__29, emscripten__internal__FunctionInvoker_void_20_28__29_28b2Body__2c_20b2MassData_20const__29_2c_20void_2c_20b2Body__2c_20b2MassData_20const____invoke_28void_20_28___29_28b2Body__2c_20b2MassData_20const__29_2c_20b2Body__2c_20b2MassData__29, emscripten__internal__MethodInvoker_void_20_28b2Body____29_28_29_2c_20void_2c_20b2Body____invoke_28void_20_28b2Body____20const__29_28_29_2c_20b2Body__29, emscripten__internal__MethodInvoker_b2Vec2_20_28b2Body____29_28b2Vec2_20const__29_20const_2c_20b2Vec2_2c_20b2Body_20const__2c_20b2Vec2_20const____invoke_28b2Vec2_20_28b2Body____20const__29_28b2Vec2_20const__29_20const_2c_20b2Body_20const__2c_20b2Vec2__29, emscripten__internal__MethodInvoker_void_20_28b2Body____29_28b2BodyType_29_2c_20void_2c_20b2Body__2c_20b2BodyType___invoke_28void_20_28b2Body____20const__29_28b2BodyType_29_2c_20b2Body__2c_20b2BodyType_29, emscripten__internal__MethodInvoker_b2BodyType_20_28b2Body____29_28_29_20const_2c_20b2BodyType_2c_20b2Body_20const____invoke_28b2BodyType_20_28b2Body____20const__29_28_29_20const_2c_20b2Body_20const__29, emscripten__internal__MethodInvoker_void_20_28b2Body____29_28bool_29_2c_20void_2c_20b2Body__2c_20bool___invoke_28void_20_28b2Body____20const__29_28bool_29_2c_20b2Body__2c_20bool_29, emscripten__internal__MethodInvoker_bool_20_28b2Body____29_28_29_20const_2c_20bool_2c_20b2Body_20const____invoke_28bool_20_28b2Body____20const__29_28_29_20const_2c_20b2Body_20const__29, emscripten__internal__MethodInvoker_b2Fixture__20_28b2Body____29_28_29_2c_20b2Fixture__2c_20b2Body____invoke_28b2Fixture__20_28b2Body____20const__29_28_29_2c_20b2Body__29, emscripten__internal__MethodInvoker_b2World__20_28b2Body____29_28_29_2c_20b2World__2c_20b2Body____invoke_28b2World__20_28b2Body____20const__29_28_29_2c_20b2Body__29, emscripten__internal__Invoker_b2JointDef____invoke_28b2JointDef__20_28__29_28_29_29, emscripten__internal__FunctionInvoker_void_20_28__29_28b2JointDef__2c_20b2Body__29_2c_20void_2c_20b2JointDef__2c_20b2Body____invoke_28void_20_28___29_28b2JointDef__2c_20b2Body__29_2c_20b2JointDef__2c_20b2Body__29, emscripten__internal__FunctionInvoker_b2Body__20_28__29_28b2JointDef__29_2c_20b2Body__2c_20b2JointDef____invoke_28b2Body__20_28___29_28b2JointDef__29_2c_20b2JointDef__29, emscripten__internal__MethodInvoker_b2JointType_20_28b2Joint____29_28_29_20const_2c_20b2JointType_2c_20b2Joint_20const____invoke_28b2JointType_20_28b2Joint____20const__29_28_29_20const_2c_20b2Joint_20const__29, emscripten__internal__MethodInvoker_b2Body__20_28b2Joint____29_28_29_2c_20b2Body__2c_20b2Joint____invoke_28b2Body__20_28b2Joint____20const__29_28_29_2c_20b2Joint__29, emscripten__internal__MethodInvoker_b2Vec2_20_28b2Joint____29_28_29_20const_2c_20b2Vec2_2c_20b2Joint_20const____invoke_28b2Vec2_20_28b2Joint____20const__29_28_29_20const_2c_20b2Joint_20const__29, emscripten__internal__MethodInvoker_b2Vec2_20_28b2Joint____29_28float_29_20const_2c_20b2Vec2_2c_20b2Joint_20const__2c_20float___invoke_28b2Vec2_20_28b2Joint____20const__29_28float_29_20const_2c_20b2Joint_20const__2c_20float_29, emscripten__internal__MethodInvoker_float_20_28b2Joint____29_28float_29_20const_2c_20float_2c_20b2Joint_20const__2c_20float___invoke_28float_20_28b2Joint____20const__29_28float_29_20const_2c_20b2Joint_20const__2c_20float_29, emscripten__internal__MethodInvoker_bool_20_28b2Joint____29_28_29_20const_2c_20bool_2c_20b2Joint_20const____invoke_28bool_20_28b2Joint____20const__29_28_29_20const_2c_20b2Joint_20const__29, emscripten__internal__MethodInvoker_void_20_28b2Joint____29_28_29_2c_20void_2c_20b2Joint____invoke_28void_20_28b2Joint____20const__29_28_29_2c_20b2Joint__29, b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2DistanceJointDef_2c_20b2JointDef__28b2DistanceJointDef__29, b2DistanceJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2DistanceJointDef__28b2JointDef__29, emscripten__internal__Invoker_b2DistanceJointDef____invoke_28b2DistanceJointDef__20_28__29_28_29_29, b2Joint__20emscripten__base_b2Joint___convertPointer_b2DistanceJoint_2c_20b2Joint__28b2DistanceJoint__29, b2DistanceJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2DistanceJoint__28b2Joint__29, emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2DistanceJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2DistanceJoint_20const____invoke_28b2Vec2_20const__20_28b2DistanceJoint____20const__29_28_29_20const_2c_20b2DistanceJoint_20const__29, emscripten__internal__MethodInvoker_void_20_28b2DistanceJoint____29_28float_29_2c_20void_2c_20b2DistanceJoint__2c_20float___invoke_28void_20_28b2DistanceJoint____20const__29_28float_29_2c_20b2DistanceJoint__2c_20float_29, emscripten__internal__MethodInvoker_float_20_28b2DistanceJoint____29_28_29_20const_2c_20float_2c_20b2DistanceJoint_20const____invoke_28float_20_28b2DistanceJoint____20const__29_28_29_20const_2c_20b2DistanceJoint_20const__29, emscripten__internal__MethodInvoker_void_20_28b2DistanceJoint____29_28_29_2c_20void_2c_20b2DistanceJoint____invoke_28void_20_28b2DistanceJoint____20const__29_28_29_2c_20b2DistanceJoint__29, b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2MotorJointDef_2c_20b2JointDef__28b2MotorJointDef__29, b2MotorJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2MotorJointDef__28b2JointDef__29, emscripten__internal__Invoker_b2MotorJointDef____invoke_28b2MotorJointDef__20_28__29_28_29_29, b2Joint__20emscripten__base_b2Joint___convertPointer_b2MotorJoint_2c_20b2Joint__28b2MotorJoint__29, b2MotorJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2MotorJoint__28b2Joint__29, emscripten__internal__MethodInvoker_void_20_28b2MotorJoint____29_28b2Vec2_20const__29_2c_20void_2c_20b2MotorJoint__2c_20b2Vec2_20const____invoke_28void_20_28b2MotorJoint____20const__29_28b2Vec2_20const__29_2c_20b2MotorJoint__2c_20b2Vec2__29, emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2MotorJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2MotorJoint_20const____invoke_28b2Vec2_20const__20_28b2MotorJoint____20const__29_28_29_20const_2c_20b2MotorJoint_20const__29, emscripten__internal__MethodInvoker_void_20_28b2MotorJoint____29_28float_29_2c_20void_2c_20b2MotorJoint__2c_20float___invoke_28void_20_28b2MotorJoint____20const__29_28float_29_2c_20b2MotorJoint__2c_20float_29, emscripten__internal__MethodInvoker_float_20_28b2MotorJoint____29_28_29_20const_2c_20float_2c_20b2MotorJoint_20const____invoke_28float_20_28b2MotorJoint____20const__29_28_29_20const_2c_20b2MotorJoint_20const__29, emscripten__internal__MethodInvoker_void_20_28b2MotorJoint____29_28_29_2c_20void_2c_20b2MotorJoint____invoke_28void_20_28b2MotorJoint____20const__29_28_29_2c_20b2MotorJoint__29, b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2MouseJointDef_2c_20b2JointDef__28b2MouseJointDef__29, b2MouseJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2MouseJointDef__28b2JointDef__29, emscripten__internal__Invoker_b2MouseJointDef____invoke_28b2MouseJointDef__20_28__29_28_29_29, b2Joint__20emscripten__base_b2Joint___convertPointer_b2MouseJoint_2c_20b2Joint__28b2MouseJoint__29, b2MouseJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2MouseJoint__28b2Joint__29, emscripten__internal__MethodInvoker_void_20_28b2MouseJoint____29_28b2Vec2_20const__29_2c_20void_2c_20b2MouseJoint__2c_20b2Vec2_20const____invoke_28void_20_28b2MouseJoint____20const__29_28b2Vec2_20const__29_2c_20b2MouseJoint__2c_20b2Vec2__29, emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2MouseJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2MouseJoint_20const____invoke_28b2Vec2_20const__20_28b2MouseJoint____20const__29_28_29_20const_2c_20b2MouseJoint_20const__29, emscripten__internal__MethodInvoker_void_20_28b2MouseJoint____29_28float_29_2c_20void_2c_20b2MouseJoint__2c_20float___invoke_28void_20_28b2MouseJoint____20const__29_28float_29_2c_20b2MouseJoint__2c_20float_29, emscripten__internal__MethodInvoker_float_20_28b2MouseJoint____29_28_29_20const_2c_20float_2c_20b2MouseJoint_20const____invoke_28float_20_28b2MouseJoint____20const__29_28_29_20const_2c_20b2MouseJoint_20const__29, emscripten__internal__MethodInvoker_void_20_28b2MouseJoint____29_28_29_2c_20void_2c_20b2MouseJoint____invoke_28void_20_28b2MouseJoint____20const__29_28_29_2c_20b2MouseJoint__29, b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2PrismaticJointDef_2c_20b2JointDef__28b2PrismaticJointDef__29, b2PrismaticJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2PrismaticJointDef__28b2JointDef__29, emscripten__internal__Invoker_b2PrismaticJointDef____invoke_28b2PrismaticJointDef__20_28__29_28_29_29, b2Joint__20emscripten__base_b2Joint___convertPointer_b2PrismaticJoint_2c_20b2Joint__28b2PrismaticJoint__29, b2PrismaticJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2PrismaticJoint__28b2Joint__29, emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2PrismaticJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2PrismaticJoint_20const____invoke_28b2Vec2_20const__20_28b2PrismaticJoint____20const__29_28_29_20const_2c_20b2PrismaticJoint_20const__29, emscripten__internal__MethodInvoker_float_20_28b2PrismaticJoint____29_28_29_20const_2c_20float_2c_20b2PrismaticJoint_20const____invoke_28float_20_28b2PrismaticJoint____20const__29_28_29_20const_2c_20b2PrismaticJoint_20const__29, emscripten__internal__MethodInvoker_bool_20_28b2PrismaticJoint____29_28_29_20const_2c_20bool_2c_20b2PrismaticJoint_20const____invoke_28bool_20_28b2PrismaticJoint____20const__29_28_29_20const_2c_20b2PrismaticJoint_20const__29, emscripten__internal__MethodInvoker_void_20_28b2PrismaticJoint____29_28bool_29_2c_20void_2c_20b2PrismaticJoint__2c_20bool___invoke_28void_20_28b2PrismaticJoint____20const__29_28bool_29_2c_20b2PrismaticJoint__2c_20bool_29, emscripten__internal__MethodInvoker_void_20_28b2PrismaticJoint____29_28float_2c_20float_29_2c_20void_2c_20b2PrismaticJoint__2c_20float_2c_20float___invoke_28void_20_28b2PrismaticJoint____20const__29_28float_2c_20float_29_2c_20b2PrismaticJoint__2c_20float_2c_20float_29, emscripten__internal__MethodInvoker_void_20_28b2PrismaticJoint____29_28float_29_2c_20void_2c_20b2PrismaticJoint__2c_20float___invoke_28void_20_28b2PrismaticJoint____20const__29_28float_29_2c_20b2PrismaticJoint__2c_20float_29, emscripten__internal__MethodInvoker_float_20_28b2PrismaticJoint____29_28float_29_20const_2c_20float_2c_20b2PrismaticJoint_20const__2c_20float___invoke_28float_20_28b2PrismaticJoint____20const__29_28float_29_20const_2c_20b2PrismaticJoint_20const__2c_20float_29, emscripten__internal__MethodInvoker_void_20_28b2PrismaticJoint____29_28_29_2c_20void_2c_20b2PrismaticJoint____invoke_28void_20_28b2PrismaticJoint____20const__29_28_29_2c_20b2PrismaticJoint__29, b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2RevoluteJointDef_2c_20b2JointDef__28b2RevoluteJointDef__29, b2RevoluteJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2RevoluteJointDef__28b2JointDef__29, emscripten__internal__Invoker_b2RevoluteJointDef____invoke_28b2RevoluteJointDef__20_28__29_28_29_29, b2Joint__20emscripten__base_b2Joint___convertPointer_b2RevoluteJoint_2c_20b2Joint__28b2RevoluteJoint__29, b2RevoluteJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2RevoluteJoint__28b2Joint__29, emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2RevoluteJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2RevoluteJoint_20const____invoke_28b2Vec2_20const__20_28b2RevoluteJoint____20const__29_28_29_20const_2c_20b2RevoluteJoint_20const__29, emscripten__internal__MethodInvoker_float_20_28b2RevoluteJoint____29_28_29_20const_2c_20float_2c_20b2RevoluteJoint_20const____invoke_28float_20_28b2RevoluteJoint____20const__29_28_29_20const_2c_20b2RevoluteJoint_20const__29, emscripten__internal__MethodInvoker_bool_20_28b2RevoluteJoint____29_28_29_20const_2c_20bool_2c_20b2RevoluteJoint_20const____invoke_28bool_20_28b2RevoluteJoint____20const__29_28_29_20const_2c_20b2RevoluteJoint_20const__29, emscripten__internal__MethodInvoker_void_20_28b2RevoluteJoint____29_28bool_29_2c_20void_2c_20b2RevoluteJoint__2c_20bool___invoke_28void_20_28b2RevoluteJoint____20const__29_28bool_29_2c_20b2RevoluteJoint__2c_20bool_29, emscripten__internal__MethodInvoker_void_20_28b2RevoluteJoint____29_28float_2c_20float_29_2c_20void_2c_20b2RevoluteJoint__2c_20float_2c_20float___invoke_28void_20_28b2RevoluteJoint____20const__29_28float_2c_20float_29_2c_20b2RevoluteJoint__2c_20float_2c_20float_29, emscripten__internal__MethodInvoker_void_20_28b2RevoluteJoint____29_28float_29_2c_20void_2c_20b2RevoluteJoint__2c_20float___invoke_28void_20_28b2RevoluteJoint____20const__29_28float_29_2c_20b2RevoluteJoint__2c_20float_29, emscripten__internal__MethodInvoker_float_20_28b2RevoluteJoint____29_28float_29_20const_2c_20float_2c_20b2RevoluteJoint_20const__2c_20float___invoke_28float_20_28b2RevoluteJoint____20const__29_28float_29_20const_2c_20b2RevoluteJoint_20const__2c_20float_29, emscripten__internal__MethodInvoker_void_20_28b2RevoluteJoint____29_28_29_2c_20void_2c_20b2RevoluteJoint____invoke_28void_20_28b2RevoluteJoint____20const__29_28_29_2c_20b2RevoluteJoint__29, b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2RopeJointDef_2c_20b2JointDef__28b2RopeJointDef__29, b2RopeJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2RopeJointDef__28b2JointDef__29, emscripten__internal__Invoker_b2RopeJointDef____invoke_28b2RopeJointDef__20_28__29_28_29_29, b2Joint__20emscripten__base_b2Joint___convertPointer_b2RopeJoint_2c_20b2Joint__28b2RopeJoint__29, b2RopeJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2RopeJoint__28b2Joint__29, emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2RopeJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2RopeJoint_20const____invoke_28b2Vec2_20const__20_28b2RopeJoint____20const__29_28_29_20const_2c_20b2RopeJoint_20const__29, emscripten__internal__MethodInvoker_b2Vec2_20_28b2RopeJoint____29_28float_29_20const_2c_20b2Vec2_2c_20b2RopeJoint_20const__2c_20float___invoke_28b2Vec2_20_28b2RopeJoint____20const__29_28float_29_20const_2c_20b2RopeJoint_20const__2c_20float_29, emscripten__internal__MethodInvoker_float_20_28b2RopeJoint____29_28float_29_20const_2c_20float_2c_20b2RopeJoint_20const__2c_20float___invoke_28float_20_28b2RopeJoint____20const__29_28float_29_20const_2c_20b2RopeJoint_20const__2c_20float_29, emscripten__internal__MethodInvoker_void_20_28b2RopeJoint____29_28float_29_2c_20void_2c_20b2RopeJoint__2c_20float___invoke_28void_20_28b2RopeJoint____20const__29_28float_29_2c_20b2RopeJoint__2c_20float_29, emscripten__internal__MethodInvoker_float_20_28b2RopeJoint____29_28_29_20const_2c_20float_2c_20b2RopeJoint_20const____invoke_28float_20_28b2RopeJoint____20const__29_28_29_20const_2c_20b2RopeJoint_20const__29, emscripten__internal__MethodInvoker_void_20_28b2RopeJoint____29_28_29_2c_20void_2c_20b2RopeJoint____invoke_28void_20_28b2RopeJoint____20const__29_28_29_2c_20b2RopeJoint__29, b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2WeldJointDef_2c_20b2JointDef__28b2WeldJointDef__29, b2WeldJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2WeldJointDef__28b2JointDef__29, emscripten__internal__Invoker_b2WeldJointDef____invoke_28b2WeldJointDef__20_28__29_28_29_29, b2Joint__20emscripten__base_b2Joint___convertPointer_b2WeldJoint_2c_20b2Joint__28b2WeldJoint__29, b2WeldJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2WeldJoint__28b2Joint__29, emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2WeldJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2WeldJoint_20const____invoke_28b2Vec2_20const__20_28b2WeldJoint____20const__29_28_29_20const_2c_20b2WeldJoint_20const__29, emscripten__internal__MethodInvoker_float_20_28b2WeldJoint____29_28_29_20const_2c_20float_2c_20b2WeldJoint_20const____invoke_28float_20_28b2WeldJoint____20const__29_28_29_20const_2c_20b2WeldJoint_20const__29, emscripten__internal__MethodInvoker_void_20_28b2WeldJoint____29_28float_29_2c_20void_2c_20b2WeldJoint__2c_20float___invoke_28void_20_28b2WeldJoint____20const__29_28float_29_2c_20b2WeldJoint__2c_20float_29, emscripten__internal__MethodInvoker_void_20_28b2WeldJoint____29_28_29_2c_20void_2c_20b2WeldJoint____invoke_28void_20_28b2WeldJoint____20const__29_28_29_2c_20b2WeldJoint__29, b2JointDef__20emscripten__base_b2JointDef___convertPointer_b2WheelJointDef_2c_20b2JointDef__28b2WheelJointDef__29, b2WheelJointDef__20emscripten__base_b2JointDef___convertPointer_b2JointDef_2c_20b2WheelJointDef__28b2JointDef__29, emscripten__internal__Invoker_b2WheelJointDef____invoke_28b2WheelJointDef__20_28__29_28_29_29, b2Joint__20emscripten__base_b2Joint___convertPointer_b2WheelJoint_2c_20b2Joint__28b2WheelJoint__29, b2WheelJoint__20emscripten__base_b2Joint___convertPointer_b2Joint_2c_20b2WheelJoint__28b2Joint__29, emscripten__internal__MethodInvoker_b2Vec2_20const__20_28b2WheelJoint____29_28_29_20const_2c_20b2Vec2_20const__2c_20b2WheelJoint_20const____invoke_28b2Vec2_20const__20_28b2WheelJoint____20const__29_28_29_20const_2c_20b2WheelJoint_20const__29, emscripten__internal__MethodInvoker_float_20_28b2WheelJoint____29_28_29_20const_2c_20float_2c_20b2WheelJoint_20const____invoke_28float_20_28b2WheelJoint____20const__29_28_29_20const_2c_20b2WheelJoint_20const__29, emscripten__internal__MethodInvoker_bool_20_28b2WheelJoint____29_28_29_20const_2c_20bool_2c_20b2WheelJoint_20const____invoke_28bool_20_28b2WheelJoint____20const__29_28_29_20const_2c_20b2WheelJoint_20const__29, emscripten__internal__MethodInvoker_void_20_28b2WheelJoint____29_28bool_29_2c_20void_2c_20b2WheelJoint__2c_20bool___invoke_28void_20_28b2WheelJoint____20const__29_28bool_29_2c_20b2WheelJoint__2c_20bool_29, emscripten__internal__MethodInvoker_void_20_28b2WheelJoint____29_28float_29_2c_20void_2c_20b2WheelJoint__2c_20float___invoke_28void_20_28b2WheelJoint____20const__29_28float_29_2c_20b2WheelJoint__2c_20float_29, emscripten__internal__MethodInvoker_float_20_28b2WheelJoint____29_28float_29_20const_2c_20float_2c_20b2WheelJoint_20const__2c_20float___invoke_28float_20_28b2WheelJoint____20const__29_28float_29_20const_2c_20b2WheelJoint_20const__2c_20float_29, emscripten__internal__MethodInvoker_void_20_28b2WheelJoint____29_28_29_2c_20void_2c_20b2WheelJoint____invoke_28void_20_28b2WheelJoint____20const__29_28_29_2c_20b2WheelJoint__29, emscripten__internal__Invoker_std____2__vector_int_2c_20std____2__allocator_int______invoke_28std____2__vector_int_2c_20std____2__allocator_int____20_28__29_28_29_29, emscripten__internal__MethodInvoker_void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28int_20const__29_2c_20void_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20int_20const____invoke_28void_20_28std____2__vector_int_2c_20std____2__allocator_int______20const__29_28int_20const__29_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20int_29, emscripten__internal__MethodInvoker_void_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28unsigned_20long_2c_20int_20const__29_2c_20void_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const____invoke_28void_20_28std____2__vector_int_2c_20std____2__allocator_int______20const__29_28unsigned_20long_2c_20int_20const__29_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_29, emscripten__internal__MethodInvoker_unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______29_28_29_20const_2c_20unsigned_20long_2c_20std____2__vector_int_2c_20std____2__allocator_int___20const____invoke_28unsigned_20long_20_28std____2__vector_int_2c_20std____2__allocator_int______20const__29_28_29_20const_2c_20std____2__vector_int_2c_20std____2__allocator_int___20const__29, emscripten__internal__FunctionInvoker_emscripten__val_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29_2c_20emscripten__val_2c_20std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long___invoke_28emscripten__val_20_28___29_28std____2__vector_int_2c_20std____2__allocator_int___20const__2c_20unsigned_20long_29_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_29, emscripten__internal__FunctionInvoker_bool_20_28__29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29_2c_20bool_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const____invoke_28bool_20_28___29_28std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_20const__29_2c_20std____2__vector_int_2c_20std____2__allocator_int____2c_20unsigned_20long_2c_20int_29, emscripten__internal__Invoker_std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______invoke_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____20_28__29_28_29_29, emscripten__internal__MethodInvoker_void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28b2Vec2_20const__29_2c_20void_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20b2Vec2_20const____invoke_28void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______20const__29_28b2Vec2_20const__29_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20b2Vec2__29, emscripten__internal__MethodInvoker_void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28unsigned_20long_2c_20b2Vec2_20const__29_2c_20void_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const____invoke_28void_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______20const__29_28unsigned_20long_2c_20b2Vec2_20const__29_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2__29, emscripten__internal__MethodInvoker_unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______29_28_29_20const_2c_20unsigned_20long_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const____invoke_28unsigned_20long_20_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2______20const__29_28_29_20const_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__29, emscripten__internal__FunctionInvoker_emscripten__val_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29_2c_20emscripten__val_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long___invoke_28emscripten__val_20_28___29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2___20const__2c_20unsigned_20long_29_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_29, emscripten__internal__FunctionInvoker_bool_20_28__29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29_2c_20bool_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const____invoke_28bool_20_28___29_28std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2_20const__29_2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20unsigned_20long_2c_20b2Vec2__29, embind_init_b2_28_29__$_0____invoke_28b2AABB__2c_20b2AABB__29, embind_init_b2_28_29__$_1____invoke_28b2AABB__2c_20b2AABB__2c_20b2AABB__29, embind_init_b2_28_29__$_2____invoke_28b2Shape__2c_20float_29, embind_init_b2_28_29__$_3____invoke_28b2Shape__29, embind_init_b2_28_29__$_4____invoke_28b2PolygonShape__2c_20std____2__vector_b2Vec2_2c_20std____2__allocator_b2Vec2____2c_20int_29, embind_init_b2_28_29__$_5____invoke_28b2FixtureDef__2c_20b2Shape_20const__29, embind_init_b2_28_29__$_6____invoke_28b2FixtureDef__29, embind_init_b2_28_29__$_7____invoke_28b2Body__2c_20b2MassData_20const__29, embind_init_b2_28_29__$_8____invoke_28b2JointDef__2c_20b2Body__29, embind_init_b2_28_29__$_9____invoke_28b2JointDef__29, embind_init_b2_28_29__$_10____invoke_28b2JointDef__2c_20b2Body__29, embind_init_b2_28_29__$_11____invoke_28b2JointDef__29, b2QueryCallbackWrapper___b2QueryCallbackWrapper_28_29, b2QueryCallbackWrapper___b2QueryCallbackWrapper_28_29_1, b2QueryCallbackWrapper__ReportFixture_28unsigned_20int_29, emscripten__wrapper_b2QueryCallback____wrapper_28_29, emscripten__wrapper_b2QueryCallback____wrapper_28_29_1, __cxa_pure_virtual, b2QueryCallback___b2QueryCallback_28_29, b2QueryCallback___b2QueryCallback_28_29_1, b2RayCastCallbackWrapper___b2RayCastCallbackWrapper_28_29, b2RayCastCallbackWrapper___b2RayCastCallbackWrapper_28_29_1, b2RayCastCallbackWrapper__ReportFixture_28unsigned_20int_2c_20b2Vec2_20const__2c_20b2Vec2_20const__2c_20float_29, emscripten__wrapper_b2RayCastCallback____wrapper_28_29, emscripten__wrapper_b2RayCastCallback____wrapper_28_29_1, b2RayCastCallback___b2RayCastCallback_28_29, b2RayCastCallback___b2RayCastCallback_28_29_1, b2ContactListenerWrapper___b2ContactListenerWrapper_28_29, b2ContactListenerWrapper___b2ContactListenerWrapper_28_29_1, b2ContactListenerWrapper__BeginContact_28unsigned_20int_29, b2ContactListenerWrapper__EndContact_28unsigned_20int_29, b2ContactListenerWrapper__PreSolve_28unsigned_20int_2c_20unsigned_20int_29, b2ContactListenerWrapper__PostSolve_28unsigned_20int_2c_20unsigned_20int_29, emscripten__wrapper_b2ContactListener____wrapper_28_29, emscripten__wrapper_b2ContactListener____wrapper_28_29_1, b2ContactListener__BeginContact_28unsigned_20int_29, b2ContactListener__EndContact_28unsigned_20int_29, b2ContactListener__PreSolve_28unsigned_20int_2c_20unsigned_20int_29, b2ContactListener__PostSolve_28unsigned_20int_2c_20unsigned_20int_29, b2ContactListener___b2ContactListener_28_29, b2ContactListener___b2ContactListener_28_29_1, b2DrawWrapper___b2DrawWrapper_28_29, b2DrawWrapper___b2DrawWrapper_28_29_1, b2DrawWrapper__DrawPolygon_28unsigned_20int_2c_20int_2c_20b2Color_20const__29, b2DrawWrapper__DrawSolidPolygon_28unsigned_20int_2c_20int_2c_20b2Color_20const__29, b2DrawWrapper__DrawCircle_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29, b2DrawWrapper__DrawSolidCircle_28b2Vec2_20const__2c_20float_2c_20b2Vec2_20const__2c_20b2Color_20const__29, b2DrawWrapper__DrawSegment_28b2Vec2_20const__2c_20b2Vec2_20const__2c_20b2Color_20const__29, b2DrawWrapper__DrawTransform_28b2Transform_20const__29, b2DrawWrapper__DrawPoint_28b2Vec2_20const__2c_20float_2c_20b2Color_20const__29, emscripten__wrapper_b2Draw____wrapper_28_29, emscripten__wrapper_b2Draw____wrapper_28_29_1, b2Shape___b2Shape_28_29, b2Shape___b2Shape_28_29_1, b2CircleShape___b2CircleShape_28_29, b2CircleShape___b2CircleShape_28_29_1, b2CircleShape__Clone_28b2BlockAllocator__29_20const, b2CircleShape__GetChildCount_28_29_20const, b2CircleShape__TestPoint_28b2Transform_20const__2c_20b2Vec2_20const__29_20const, b2CircleShape__RayCast_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const, b2CircleShape__ComputeAABB_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const, b2CircleShape__ComputeMass_28b2MassData__2c_20float_29_20const, b2EdgeShape___b2EdgeShape_28_29, b2EdgeShape___b2EdgeShape_28_29_1, b2EdgeShape__Clone_28b2BlockAllocator__29_20const, b2EdgeShape__GetChildCount_28_29_20const, b2EdgeShape__TestPoint_28b2Transform_20const__2c_20b2Vec2_20const__29_20const, b2EdgeShape__RayCast_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const, b2EdgeShape__ComputeAABB_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const, b2EdgeShape__ComputeMass_28b2MassData__2c_20float_29_20const, b2PolygonShape___b2PolygonShape_28_29, b2PolygonShape___b2PolygonShape_28_29_1, b2PolygonShape__Clone_28b2BlockAllocator__29_20const, b2PolygonShape__GetChildCount_28_29_20const, b2PolygonShape__TestPoint_28b2Transform_20const__2c_20b2Vec2_20const__29_20const, b2PolygonShape__RayCast_28b2RayCastOutput__2c_20b2RayCastInput_20const__2c_20b2Transform_20const__2c_20int_29_20const, b2PolygonShape__ComputeAABB_28b2AABB__2c_20b2Transform_20const__2c_20int_29_20const, b2PolygonShape__ComputeMass_28b2MassData__2c_20float_29_20const, b2Draw___b2Draw_28_29, b2Draw___b2Draw_28_29_1, b2CircleContact__b2CircleContact_28b2Fixture__2c_20b2Fixture__29, b2CircleContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29, b2CircleContact___b2CircleContact_28_29, b2CircleContact___b2CircleContact_28_29_1, b2ChainAndCircleContact__b2ChainAndCircleContact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29, b2ChainAndCircleContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29, b2ChainAndCircleContact___b2ChainAndCircleContact_28_29, b2ChainAndCircleContact___b2ChainAndCircleContact_28_29_1, b2ChainAndPolygonContact__b2ChainAndPolygonContact_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_29, b2ChainAndPolygonContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29, b2ChainAndPolygonContact___b2ChainAndPolygonContact_28_29, b2ChainAndPolygonContact___b2ChainAndPolygonContact_28_29_1, b2CircleContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29, b2CircleContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29, b2PolygonAndCircleContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29, b2PolygonAndCircleContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29, b2PolygonContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29, b2PolygonContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29, b2EdgeAndCircleContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29, b2EdgeAndCircleContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29, b2EdgeAndPolygonContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29, b2EdgeAndPolygonContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29, b2ChainAndCircleContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29, b2ChainAndCircleContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29, b2ChainAndPolygonContact__Create_28b2Fixture__2c_20int_2c_20b2Fixture__2c_20int_2c_20b2BlockAllocator__29, b2ChainAndPolygonContact__Destroy_28b2Contact__2c_20b2BlockAllocator__29, b2Contact___b2Contact_28_29, b2Contact___b2Contact_28_29_1, __cxx_global_array_dtor, __cxx_global_array_dtor_2, b2DistanceJoint__GetAnchorA_28_29_20const, b2DistanceJoint__GetAnchorB_28_29_20const, b2DistanceJoint__GetReactionForce_28float_29_20const, b2DistanceJoint__GetReactionTorque_28float_29_20const, b2DistanceJoint__Dump_28_29, b2Joint__ShiftOrigin_28b2Vec2_20const__29, b2Joint__Draw_28b2Draw__29_20const, b2DistanceJoint___b2DistanceJoint_28_29, b2DistanceJoint___b2DistanceJoint_28_29_1, b2DistanceJoint__InitVelocityConstraints_28b2SolverData_20const__29, b2DistanceJoint__SolveVelocityConstraints_28b2SolverData_20const__29, b2DistanceJoint__SolvePositionConstraints_28b2SolverData_20const__29, b2EdgeAndCircleContact__b2EdgeAndCircleContact_28b2Fixture__2c_20b2Fixture__29, b2EdgeAndCircleContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29, b2EdgeAndCircleContact___b2EdgeAndCircleContact_28_29, b2EdgeAndCircleContact___b2EdgeAndCircleContact_28_29_1, b2EdgeAndPolygonContact__b2EdgeAndPolygonContact_28b2Fixture__2c_20b2Fixture__29, b2EdgeAndPolygonContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29, b2EdgeAndPolygonContact___b2EdgeAndPolygonContact_28_29, b2EdgeAndPolygonContact___b2EdgeAndPolygonContact_28_29_1, b2GearJoint__GetAnchorA_28_29_20const, b2GearJoint__GetAnchorB_28_29_20const, b2GearJoint__GetReactionForce_28float_29_20const, b2GearJoint__GetReactionTorque_28float_29_20const, b2GearJoint__Dump_28_29, b2GearJoint___b2GearJoint_28_29, b2GearJoint___b2GearJoint_28_29_1, b2GearJoint__InitVelocityConstraints_28b2SolverData_20const__29, b2GearJoint__SolveVelocityConstraints_28b2SolverData_20const__29, b2GearJoint__SolvePositionConstraints_28b2SolverData_20const__29, b2FrictionJoint__GetAnchorA_28_29_20const, b2FrictionJoint__GetAnchorB_28_29_20const, b2FrictionJoint__GetReactionForce_28float_29_20const, b2FrictionJoint__GetReactionTorque_28float_29_20const, b2FrictionJoint__Dump_28_29, b2FrictionJoint___b2FrictionJoint_28_29, b2FrictionJoint___b2FrictionJoint_28_29_1, b2FrictionJoint__InitVelocityConstraints_28b2SolverData_20const__29, b2FrictionJoint__SolveVelocityConstraints_28b2SolverData_20const__29, b2FrictionJoint__SolvePositionConstraints_28b2SolverData_20const__29, b2Joint__Dump_28_29, b2Joint___b2Joint_28_29, b2Joint___b2Joint_28_29_1, b2MotorJoint__GetAnchorA_28_29_20const, b2MotorJoint__GetAnchorB_28_29_20const, b2MotorJoint__GetReactionForce_28float_29_20const, b2MotorJoint__GetReactionTorque_28float_29_20const, b2MotorJoint__Dump_28_29, b2MotorJoint___b2MotorJoint_28_29, b2MotorJoint___b2MotorJoint_28_29_1, b2MotorJoint__InitVelocityConstraints_28b2SolverData_20const__29, b2MotorJoint__SolveVelocityConstraints_28b2SolverData_20const__29, b2MotorJoint__SolvePositionConstraints_28b2SolverData_20const__29, b2MouseJoint__GetAnchorA_28_29_20const, b2MouseJoint__GetAnchorB_28_29_20const, b2MouseJoint__GetReactionForce_28float_29_20const, b2MouseJoint__GetReactionTorque_28float_29_20const, b2MouseJoint__Dump_28_29, b2MouseJoint__ShiftOrigin_28b2Vec2_20const__29, b2MouseJoint___b2MouseJoint_28_29, b2MouseJoint___b2MouseJoint_28_29_1, b2MouseJoint__InitVelocityConstraints_28b2SolverData_20const__29, b2MouseJoint__SolveVelocityConstraints_28b2SolverData_20const__29, b2MouseJoint__SolvePositionConstraints_28b2SolverData_20const__29, b2PolygonAndCircleContact__b2PolygonAndCircleContact_28b2Fixture__2c_20b2Fixture__29, b2PolygonAndCircleContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29, b2PolygonAndCircleContact___b2PolygonAndCircleContact_28_29, b2PolygonAndCircleContact___b2PolygonAndCircleContact_28_29_1, b2PolygonContact__b2PolygonContact_28b2Fixture__2c_20b2Fixture__29, b2PolygonContact__Evaluate_28b2Manifold__2c_20b2Transform_20const__2c_20b2Transform_20const__29, b2PolygonContact___b2PolygonContact_28_29, b2PolygonContact___b2PolygonContact_28_29_1, b2PrismaticJoint__GetAnchorA_28_29_20const, b2PrismaticJoint__GetAnchorB_28_29_20const, b2PrismaticJoint__GetReactionForce_28float_29_20const, b2PrismaticJoint__GetReactionTorque_28float_29_20const, b2PrismaticJoint__Dump_28_29, b2PrismaticJoint__Draw_28b2Draw__29_20const, b2PrismaticJoint___b2PrismaticJoint_28_29, b2PrismaticJoint___b2PrismaticJoint_28_29_1, b2PrismaticJoint__InitVelocityConstraints_28b2SolverData_20const__29, b2PrismaticJoint__SolveVelocityConstraints_28b2SolverData_20const__29, b2PrismaticJoint__SolvePositionConstraints_28b2SolverData_20const__29, b2PulleyJoint__GetAnchorA_28_29_20const, b2PulleyJoint__GetAnchorB_28_29_20const, b2PulleyJoint__GetReactionForce_28float_29_20const, b2PulleyJoint__GetReactionTorque_28float_29_20const, b2PulleyJoint__Dump_28_29, b2PulleyJoint__ShiftOrigin_28b2Vec2_20const__29, b2PulleyJoint___b2PulleyJoint_28_29, b2PulleyJoint___b2PulleyJoint_28_29_1, b2PulleyJoint__InitVelocityConstraints_28b2SolverData_20const__29, b2PulleyJoint__SolveVelocityConstraints_28b2SolverData_20const__29, b2PulleyJoint__SolvePositionConstraints_28b2SolverData_20const__29, b2RevoluteJoint__GetAnchorA_28_29_20const, b2RevoluteJoint__GetAnchorB_28_29_20const, b2RevoluteJoint__GetReactionForce_28float_29_20const, b2RevoluteJoint__GetReactionTorque_28float_29_20const, b2RevoluteJoint__Dump_28_29, b2RevoluteJoint__Draw_28b2Draw__29_20const, b2RevoluteJoint___b2RevoluteJoint_28_29, b2RevoluteJoint___b2RevoluteJoint_28_29_1, b2RevoluteJoint__InitVelocityConstraints_28b2SolverData_20const__29, b2RevoluteJoint__SolveVelocityConstraints_28b2SolverData_20const__29, b2RevoluteJoint__SolvePositionConstraints_28b2SolverData_20const__29, b2RopeJoint__GetAnchorA_28_29_20const, b2RopeJoint__GetAnchorB_28_29_20const, b2RopeJoint__GetReactionForce_28float_29_20const, b2RopeJoint__GetReactionTorque_28float_29_20const, b2RopeJoint__Dump_28_29, b2RopeJoint___b2RopeJoint_28_29, b2RopeJoint___b2RopeJoint_28_29_1, b2RopeJoint__InitVelocityConstraints_28b2SolverData_20const__29, b2RopeJoint__SolveVelocityConstraints_28b2SolverData_20const__29, b2RopeJoint__SolvePositionConstraints_28b2SolverData_20const__29, b2WeldJoint__GetAnchorA_28_29_20const, b2WeldJoint__GetAnchorB_28_29_20const, b2WeldJoint__GetReactionForce_28float_29_20const, b2WeldJoint__GetReactionTorque_28float_29_20const, b2WeldJoint__Dump_28_29, b2WeldJoint___b2WeldJoint_28_29, b2WeldJoint___b2WeldJoint_28_29_1, b2WeldJoint__InitVelocityConstraints_28b2SolverData_20const__29, b2WeldJoint__SolveVelocityConstraints_28b2SolverData_20const__29, b2WeldJoint__SolvePositionConstraints_28b2SolverData_20const__29, b2WheelJoint__GetAnchorA_28_29_20const, b2WheelJoint__GetAnchorB_28_29_20const, b2WheelJoint__GetReactionForce_28float_29_20const, b2WheelJoint__GetReactionTorque_28float_29_20const, b2WheelJoint__Dump_28_29, b2WheelJoint__Draw_28b2Draw__29_20const, b2WheelJoint___b2WheelJoint_28_29, b2WheelJoint___b2WheelJoint_28_29_1, b2WheelJoint__InitVelocityConstraints_28b2SolverData_20const__29, b2WheelJoint__SolveVelocityConstraints_28b2SolverData_20const__29, b2WheelJoint__SolvePositionConstraints_28b2SolverData_20const__29, b2ContactFilter___b2ContactFilter_28_29, b2ContactFilter___b2ContactFilter_28_29_1, b2ContactFilter__ShouldCollide_28b2Fixture__2c_20b2Fixture__29, embind_init_builtin_28_29, __stdio_seek, __stdio_write, __stdio_read, __stdio_close, fmt_fp, pop_arg_long_double, __emscripten_stdout_close, __emscripten_stdout_seek, __cxxabiv1____shim_type_info_____shim_type_info_28_29, __cxxabiv1____fundamental_type_info_____fundamental_type_info_28_29, __cxxabiv1____shim_type_info__noop1_28_29_20const, __cxxabiv1____shim_type_info__noop2_28_29_20const, __cxxabiv1____fundamental_type_info__can_catch_28__cxxabiv1____shim_type_info_20const__2c_20void___29_20const, __cxxabiv1____enum_type_info_____enum_type_info_28_29, __cxxabiv1____enum_type_info__can_catch_28__cxxabiv1____shim_type_info_20const__2c_20void___29_20const, __cxxabiv1____class_type_info_____class_type_info_28_29, __cxxabiv1____class_type_info__can_catch_28__cxxabiv1____shim_type_info_20const__2c_20void___29_20const, __cxxabiv1____class_type_info__search_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_2c_20bool_29_20const, __cxxabiv1____class_type_info__search_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_2c_20bool_29_20const, __cxxabiv1____class_type_info__has_unambiguous_public_base_28__cxxabiv1____dynamic_cast_info__2c_20void__2c_20int_29_20const, __cxxabiv1____si_class_type_info_____si_class_type_info_28_29, __cxxabiv1____si_class_type_info__search_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_2c_20bool_29_20const, __cxxabiv1____si_class_type_info__search_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_2c_20bool_29_20const, __cxxabiv1____si_class_type_info__has_unambiguous_public_base_28__cxxabiv1____dynamic_cast_info__2c_20void__2c_20int_29_20const, __cxxabiv1____vmi_class_type_info_____vmi_class_type_info_28_29, __cxxabiv1____vmi_class_type_info__search_above_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20void_20const__2c_20int_2c_20bool_29_20const, __cxxabiv1____vmi_class_type_info__search_below_dst_28__cxxabiv1____dynamic_cast_info__2c_20void_20const__2c_20int_2c_20bool_29_20const, __cxxabiv1____vmi_class_type_info__has_unambiguous_public_base_28__cxxabiv1____dynamic_cast_info__2c_20void__2c_20int_29_20const, __cxxabiv1____pointer_type_info_____pointer_type_info_28_29, __cxxabiv1____pointer_type_info__can_catch_28__cxxabiv1____shim_type_info_20const__2c_20void___29_20const]); + function __wasm_memory_size() { + return buffer.byteLength / 65536 | 0; +} + + function __wasm_memory_grow(pagesToAdd) { + pagesToAdd = pagesToAdd | 0; + var oldPages = __wasm_memory_size() | 0; + var newPages = oldPages + pagesToAdd | 0; + if ((oldPages < newPages) && (newPages < 65536)) { + var newBuffer = new ArrayBuffer(Math_imul(newPages, 65536)); + var newHEAP8 = new Int8Array(newBuffer); + newHEAP8.set(HEAP8); + HEAP8 = new Int8Array(newBuffer); + HEAP16 = new Int16Array(newBuffer); + HEAP32 = new Int32Array(newBuffer); + HEAPU8 = new Uint8Array(newBuffer); + HEAPU16 = new Uint16Array(newBuffer); + HEAPU32 = new Uint32Array(newBuffer); + HEAPF32 = new Float32Array(newBuffer); + HEAPF64 = new Float64Array(newBuffer); + buffer = newBuffer; + memory.buffer = buffer; + bufferView = HEAPU8; + } + return oldPages; +} + + return { + "__wasm_call_ctors": __wasm_call_ctors, + "__indirect_function_table": FUNCTION_TABLE, + "malloc": dlmalloc, + "free": dlfree, + "__getTypeName": __getTypeName, + "_embind_initialize_bindings": _embind_initialize_bindings, + "__errno_location": __errno_location, + "stackSave": stackSave, + "stackRestore": stackRestore, + "stackAlloc": stackAlloc, + "dynCall_jiji": legalstub$dynCall_jiji +}; +} + + return asmFunc(info); +} +// EMSCRIPTEN_END_ASM + + +)(info); + }, + + instantiate: /** @suppress{checkTypes} */ function(binary, info) { + return { + then: function(ok) { + var module = new WebAssembly.Module(binary); + ok({ + 'instance': new WebAssembly.Instance(module, info) + }); + } + }; + }, + + RuntimeError: Error +}; + +// We don't need to actually download a wasm binary, mark it as present but empty. +wasmBinary = []; + +// end include: wasm2js.js +if (typeof WebAssembly != 'object') { + abort('no native wasm support detected'); +} + +// Wasm globals + +var wasmMemory; + +//======================================== +// Runtime essentials +//======================================== + +// whether we are quitting the application. no code should run after this. +// set in exit() and abort() +var ABORT = false; + +// set by exit() and abort(). Passed to 'onExit' handler. +// NOTE: This is also used as the process return code code in shell environments +// but only when noExitRuntime is false. +var EXITSTATUS; + +/** @type {function(*, string=)} */ +function assert(condition, text) { + if (!condition) { + // This build was created without ASSERTIONS defined. `assert()` should not + // ever be called in this configuration but in case there are callers in + // the wild leave this simple abort() implemenation here for now. + abort(text); + } +} + +// Memory management + +var HEAP, +/** @type {!Int8Array} */ + HEAP8, +/** @type {!Uint8Array} */ + HEAPU8, +/** @type {!Int16Array} */ + HEAP16, +/** @type {!Uint16Array} */ + HEAPU16, +/** @type {!Int32Array} */ + HEAP32, +/** @type {!Uint32Array} */ + HEAPU32, +/** @type {!Float32Array} */ + HEAPF32, +/** @type {!Float64Array} */ + HEAPF64; + +function updateMemoryViews() { + var b = wasmMemory.buffer; + Module['HEAP8'] = HEAP8 = new Int8Array(b); + Module['HEAP16'] = HEAP16 = new Int16Array(b); + Module['HEAP32'] = HEAP32 = new Int32Array(b); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(b); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(b); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(b); + Module['HEAPF32'] = HEAPF32 = new Float32Array(b); + Module['HEAPF64'] = HEAPF64 = new Float64Array(b); +} + +// In non-standalone/normal mode, we create the memory here. +// include: runtime_init_memory.js +// Create the wasm memory. (Note: this only applies if IMPORTED_MEMORY is defined) + +var INITIAL_MEMORY = Module['INITIAL_MEMORY'] || 16777216; + +assert(INITIAL_MEMORY >= 65536, 'INITIAL_MEMORY should be larger than STACK_SIZE, was ' + INITIAL_MEMORY + '! (STACK_SIZE=' + 65536 + ')'); + +// check for full engine support (use string 'subarray' to avoid closure compiler confusion) + + if (Module['wasmMemory']) { + wasmMemory = Module['wasmMemory']; + } else + { + wasmMemory = new WebAssembly.Memory({ + 'initial': INITIAL_MEMORY / 65536, + // In theory we should not need to emit the maximum if we want "unlimited" + // or 4GB of memory, but VMs error on that atm, see + // https://github.com/emscripten-core/emscripten/issues/14130 + // And in the pthreads case we definitely need to emit a maximum. So + // always emit one. + 'maximum': 2147483648 / 65536 + }); + } + +updateMemoryViews(); + +// If the user provides an incorrect length, just use that length instead rather than providing the user to +// specifically provide the memory length with Module['INITIAL_MEMORY']. +INITIAL_MEMORY = wasmMemory.buffer.byteLength; + +// end include: runtime_init_memory.js + +// include: runtime_init_table.js +// In regular non-RELOCATABLE mode the table is exported +// from the wasm module and this will be assigned once +// the exports are available. +var wasmTable; + +// end include: runtime_init_table.js +// include: runtime_stack_check.js +// end include: runtime_stack_check.js +// include: runtime_assertions.js +// end include: runtime_assertions.js +var __ATPRERUN__ = []; // functions called before the runtime is initialized +var __ATINIT__ = []; // functions called during startup +var __ATEXIT__ = []; // functions called during shutdown +var __ATPOSTRUN__ = []; // functions called after the main() is called + +var runtimeInitialized = false; + +var runtimeKeepaliveCounter = 0; + +function keepRuntimeAlive() { + return noExitRuntime || runtimeKeepaliveCounter > 0; +} + +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 initRuntime() { + runtimeInitialized = true; + + +if (!Module["noFSInit"] && !FS.init.initialized) + FS.init(); +FS.ignorePermissions = false; + +TTY.init(); + callRuntimeCallbacks(__ATINIT__); +} + +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); +} + +function addOnInit(cb) { + __ATINIT__.unshift(cb); +} + +function addOnExit(cb) { +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +// include: runtime_math.js +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32 + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc + +// end include: runtime_math.js +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; +var runDependencyWatcher = null; +var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled + +function getUniqueRunDependency(id) { + return id; +} + +function addRunDependency(id) { + runDependencies++; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + +} + +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(); // can add another dependenciesFulfilled + } + } +} + +/** @param {string|number=} what */ +function abort(what) { + if (Module['onAbort']) { + Module['onAbort'](what); + } + + what = 'Aborted(' + what + ')'; + // TODO(sbc): Should we remove printing and leave it up to whoever + // catches the exception? + err(what); + + ABORT = true; + EXITSTATUS = 1; + + what += '. Build with -sASSERTIONS for more info.'; + + // Use a wasm runtime error, because a JS error might be seen as a foreign + // exception, which means we'd run destructors on it. We need the error to + // simply make the program stop. + // FIXME This approach does not work in Wasm EH because it currently does not assume + // all RuntimeErrors are from traps; it decides whether a RuntimeError is from + // a trap or not based on a hidden field within the object. So at the moment + // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that + // allows this in the wasm spec. + + // Suppress closure compiler warning here. Closure compiler's builtin extern + // defintion for WebAssembly.RuntimeError claims it takes no arguments even + // though it can. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed. + /** @suppress {checkTypes} */ + var e = new WebAssembly.RuntimeError(what); + + readyPromiseReject(e); + // Throw the error whether or not MODULARIZE is set because abort is used + // in code paths apart from instantiation where an exception is expected + // to be thrown when abort is called. + throw e; +} + +// include: memoryprofiler.js +// end include: memoryprofiler.js +// include: URIUtils.js +// Prefix of data URIs emitted by SINGLE_FILE and related options. +var dataURIPrefix = 'data:application/octet-stream;base64,'; + +// Indicates whether filename is a base64 data URI. +function isDataURI(filename) { + // Prefix of data URIs emitted by SINGLE_FILE and related options. + return filename.startsWith(dataURIPrefix); +} + +// Indicates whether filename is delivered via file protocol (as opposed to http/https) +function isFileURI(filename) { + return filename.startsWith('file://'); +} + +// end include: URIUtils.js +// include: runtime_exceptions.js +// end include: runtime_exceptions.js +var wasmBinaryFile; + wasmBinaryFile = '<<< WASM_BINARY_FILE >>>'; + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); + } + +function getBinary(file) { + try { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + var binary = tryParseAsDataURI(file); + if (binary) { + return binary; + } + if (readBinary) { + return readBinary(file); + } + throw "both async and sync fetching of the wasm failed"; + } + catch (err) { + abort(err); + } +} + +function getBinaryPromise(binaryFile) { + // If we don't have the binary yet, try to load it asynchronously. + // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url. + // See https://github.com/github/fetch/pull/92#issuecomment-140665932 + // Cordova or Electron apps are typically loaded from a file:// url. + // So use fetch if it is available and the url is not a file, otherwise fall back to XHR. + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { + if (typeof fetch == 'function' + ) { + return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => { + if (!response['ok']) { + throw "failed to load wasm binary file at '" + binaryFile + "'"; + } + return response['arrayBuffer'](); + }).catch(() => getBinary(binaryFile)); + } + } + + // Otherwise, getBinary should be able to get it synchronously + return Promise.resolve().then(() => getBinary(binaryFile)); +} + +function instantiateArrayBuffer(binaryFile, imports, receiver) { + return getBinaryPromise(binaryFile).then((binary) => { + return WebAssembly.instantiate(binary, imports); + }).then((instance) => { + return instance; + }).then(receiver, (reason) => { + err('failed to asynchronously prepare wasm: ' + reason); + + abort(reason); + }); +} + +function instantiateAsync(binary, binaryFile, imports, callback) { + if (!binary && + typeof WebAssembly.instantiateStreaming == 'function' && + !isDataURI(binaryFile) && + typeof fetch == 'function') { + return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => { + // Suppress closure warning here since the upstream definition for + // instantiateStreaming only allows Promise rather than + // an actual Response. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed. + /** @suppress {checkTypes} */ + var result = WebAssembly.instantiateStreaming(response, imports); + + return result.then( + callback, + function(reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err('wasm streaming compile failed: ' + reason); + err('falling back to ArrayBuffer instantiation'); + return instantiateArrayBuffer(binaryFile, imports, callback); + }); + }); + } else { + return instantiateArrayBuffer(binaryFile, imports, callback); + } +} + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +function createWasm() { + // prepare imports + var info = { + 'env': wasmImports, + 'wasi_snapshot_preview1': wasmImports, + }; + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + /** @param {WebAssembly.Module=} module*/ + function receiveInstance(instance, module) { + var exports = instance.exports; + + Module['asm'] = exports; + + wasmTable = Module['asm']['__indirect_function_table']; + + addOnInit(Module['asm']['__wasm_call_ctors']); + + removeRunDependency('wasm-instantiate'); + return exports; + } + // wait for the pthread pool (if any) + addRunDependency('wasm-instantiate'); + + // Prefer streaming instantiation if available. + function receiveInstantiationResult(result) { + // 'result' is a ResultObject object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above PTHREADS-enabled path. + receiveInstance(result['instance']); + } + + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to + // run the instantiation parallel to any other async startup actions they are + // performing. + // Also pthreads and wasm workers initialize the wasm instance through this + // path. + if (Module['instantiateWasm']) { + + try { + return Module['instantiateWasm'](info, receiveInstance); + } catch(e) { + err('Module.instantiateWasm callback failed with error: ' + e); + // If instantiation fails, reject the module ready promise. + readyPromiseReject(e); + } + } + + // If instantiation fails, reject the module ready promise. + instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject); + return {}; // no exports yet; we'll fill them in later +} + +// Globals used by JS i64 conversions (see makeSetValue) +var tempDouble; +var tempI64; + +// include: runtime_debug.js +// end include: runtime_debug.js +// === Body === + + +// end include: preamble.js + + /** @constructor */ + function ExitStatus(status) { + this.name = 'ExitStatus'; + this.message = `Program terminated with exit(${status})`; + this.status = status; + } + + function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + // Pass the module as the first argument. + callbacks.shift()(Module); + } + } + + + /** + * @param {number} ptr + * @param {string} type + */ + function getValue(ptr, type = 'i8') { + if (type.endsWith('*')) type = '*'; + 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': abort('to do getValue(i64) use WASM_BIGINT'); + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return HEAPF64[((ptr)>>3)]; + case '*': return HEAPU32[((ptr)>>2)]; + default: abort(`invalid type for getValue: ${type}`); + } + } + + function intArrayToString(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + var chr = array[i]; + if (chr > 0xFF) { + chr &= 0xFF; + } + ret.push(String.fromCharCode(chr)); + } + return ret.join(''); + } + + + /** + * @param {number} ptr + * @param {number} value + * @param {string} type + */ + function setValue(ptr, value, type = 'i8') { + if (type.endsWith('*')) type = '*'; + 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': abort('to do setValue(i64) use WASM_BIGINT'); + case 'float': HEAPF32[((ptr)>>2)] = value; break; + case 'double': HEAPF64[((ptr)>>3)] = value; break; + case '*': HEAPU32[((ptr)>>2)] = value; break; + default: abort(`invalid type for setValue: ${type}`); + } + } + + var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined; + + /** + * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given + * array that contains uint8 values, returns a copy of that string as a + * Javascript String object. + * heapOrArray is either a regular array, or a JavaScript typed array view. + * @param {number} idx + * @param {number=} maxBytesToRead + * @return {string} + */ + function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on + // null terminator by itself. Also, use the length info to avoid running tiny + // strings through TextDecoder, since .subarray() allocates garbage. + // (As a tiny code save trick, compare endPtr against endIdx using a negation, + // so that undefined means Infinity) + while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { + return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); + } + var str = ''; + // If building with TextDecoder, we have already computed the string length + // above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = heapOrArray[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); + } + + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + return str; + } + + + /** + * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the + * emscripten HEAP, returns a copy of that string as a Javascript String object. + * + * @param {number} ptr + * @param {number=} maxBytesToRead - An optional length that specifies the + * maximum number of bytes to read. You can omit this parameter to scan the + * string until the first 0 byte. If maxBytesToRead is passed, and the string + * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the + * string will cut short at that byte index (i.e. maxBytesToRead will not + * produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing + * frequent uses of UTF8ToString() with and without maxBytesToRead may throw + * JS JIT optimizations off, so it is worth to consider consistently using one + * @return {string} + */ + function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ''; + } + function ___assert_fail(condition, filename, line, func) { + abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']); + } + + function setErrNo(value) { + HEAP32[((___errno_location())>>2)] = value; + return value; + } + + var PATH = {isAbs:(path) => path.charAt(0) === '/',splitPath:(filename) => { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + },normalizeArray:(parts, allowAboveRoot) => { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift('..'); + } + } + return parts; + },normalize:(path) => { + var isAbsolute = PATH.isAbs(path), + trailingSlash = path.substr(-1) === '/'; + // Normalize the path + path = PATH.normalizeArray(path.split('/').filter((p) => !!p), !isAbsolute).join('/'); + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + return (isAbsolute ? '/' : '') + path; + },dirname:(path) => { + var result = PATH.splitPath(path), + root = result[0], + dir = result[1]; + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + },basename:(path) => { + // EMSCRIPTEN return '/'' for '/', not an empty string + if (path === '/') return '/'; + path = PATH.normalize(path); + path = path.replace(/\/$/, ""); + var lastSlash = path.lastIndexOf('/'); + if (lastSlash === -1) return path; + return path.substr(lastSlash+1); + },join:function() { + var paths = Array.prototype.slice.call(arguments); + return PATH.normalize(paths.join('/')); + },join2:(l, r) => { + return PATH.normalize(l + '/' + r); + }}; + + function initRandomFill() { + if (typeof crypto == 'object' && typeof crypto['getRandomValues'] == 'function') { + // for modern web browsers + return (view) => crypto.getRandomValues(view); + } else + // we couldn't find a proper implementation, as Math.random() is not suitable for /dev/random, see emscripten-core/emscripten/pull/7096 + abort("initRandomDevice"); + } + function randomFill(view) { + // Lazily init on the first invocation. + return (randomFill = initRandomFill())(view); + } + + + + var PATH_FS = {resolve:function() { + var resolvedPath = '', + resolvedAbsolute = false; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) ? arguments[i] : FS.cwd(); + // Skip empty and invalid entries + if (typeof path != 'string') { + throw new TypeError('Arguments to path.resolve must be strings'); + } else if (!path) { + return ''; // an invalid portion invalidates the whole thing + } + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = PATH.isAbs(path); + } + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter((p) => !!p), !resolvedAbsolute).join('/'); + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; + },relative:(from, to) => { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.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('/'); + }}; + + + function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var c = str.charCodeAt(i); // possibly a lead surrogate + if (c <= 0x7F) { + len++; + } else if (c <= 0x7FF) { + len += 2; + } else if (c >= 0xD800 && c <= 0xDFFF) { + len += 4; ++i; + } else { + len += 3; + } + } + return len; + } + + function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { + // Parameter maxBytesToWrite is not optional. Negative values, 0, null, + // undefined and false each don't write out any bytes. + if (!(maxBytesToWrite > 0)) + return 0; + + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description + // and https://www.ietf.org/rfc/rfc2279.txt + // and https://tools.ietf.org/html/rfc3629 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 0xC0 | (u >> 6); + heap[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 0xE0 | (u >> 12); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + heap[outIdx++] = 0xF0 | (u >> 18); + heap[outIdx++] = 0x80 | ((u >> 12) & 63); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + heap[outIdx] = 0; + return outIdx - startIdx; + } + /** @type {function(string, boolean=, number=)} */ + function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy)+1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; + } + + var TTY = {ttys:[],init:function () { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // currently, FS.init does not distinguish if process.stdin is a file or TTY + // // device, it always assumes it's a TTY device. because of this, we're forcing + // // process.stdin to UTF8 encoding to at least make stdin reading compatible + // // with text files until FS.init can be refactored. + // process.stdin.setEncoding('utf8'); + // } + },shutdown:function() { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)? + // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation + // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists? + // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle + // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call + // process.stdin.pause(); + // } + },register:function(dev, ops) { + TTY.ttys[dev] = { input: [], output: [], ops: ops }; + FS.registerDevice(dev, TTY.stream_ops); + },stream_ops:{open:function(stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43); + } + stream.tty = tty; + stream.seekable = false; + },close:function(stream) { + // flush any pending line data + stream.tty.ops.fsync(stream.tty); + },fsync:function(stream) { + stream.tty.ops.fsync(stream.tty); + },read:function(stream, buffer, offset, length, pos /* ignored */) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60); + } + 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(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + 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(60); + } + try { + for (var i = 0; i < length; i++) { + stream.tty.ops.put_char(stream.tty, buffer[offset+i]); + } + } catch (e) { + throw new FS.ErrnoError(29); + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }},default_tty_ops:{get_char:function(tty) { + if (!tty.input.length) { + var result = null; + if (typeof window != 'undefined' && + typeof window.prompt == 'function') { + // Browser. + result = window.prompt('Input: '); // returns null on cancel + if (result !== null) { + result += '\n'; + } + } else if (typeof readline == 'function') { + // Command line. + result = readline(); + if (result !== null) { + result += '\n'; + } + } + if (!result) { + return null; + } + tty.input = intArrayFromString(result, true); + } + return tty.input.shift(); + },put_char:function(tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); // val == 0 would cut text output off in the middle. + } + },fsync:function(tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }},default_tty1_ops:{put_char:function(tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + },fsync:function(tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }}}; + + + function zeroMemory(address, size) { + HEAPU8.fill(0, address, address + size); + return address; + } + + function alignMemory(size, alignment) { + return Math.ceil(size / alignment) * alignment; + } + function mmapAlloc(size) { + abort(); + } + var MEMFS = {ops_table:null,mount:function(mount) { + return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0); + },createNode:function(parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + // no supported + throw new FS.ErrnoError(63); + } + 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, + msync: MEMFS.stream_ops.msync + } + }, + 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; // The actual number of bytes used in the typed array, as opposed to contents.length which gives the whole capacity. + // When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred + // for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size + // penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme. + 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(); + // add the new node to the parent + if (parent) { + parent.contents[name] = node; + parent.timestamp = node.timestamp; + } + return node; + },getFileDataAsTypedArray:function(node) { + if (!node.contents) return new Uint8Array(0); + if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); // Make sure to not return excess unused bytes. + return new Uint8Array(node.contents); + },expandFileStorage:function(node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) return; // No need to expand, the storage was already large enough. + // Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity. + // For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to + // avoid overshooting the allocation cap by a very large margin. + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max(newCapacity, (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2.0 : 1.125)) >>> 0); + if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); // At minimum allocate 256b for each file when expanding. + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); // Allocate new storage. + if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); // Copy old data over to the new storage. + },resizeFileStorage:function(node, newSize) { + if (node.usedBytes == newSize) return; + if (newSize == 0) { + node.contents = null; // Fully decommit when requesting a resize to zero. + node.usedBytes = 0; + } else { + var oldContents = node.contents; + node.contents = new Uint8Array(newSize); // Allocate new storage. + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); // Copy old data over to the new storage. + } + node.usedBytes = newSize; + } + },node_ops:{getattr:function(node) { + var attr = {}; + // device numbers reuse inode numbers. + attr.dev = FS.isChrdev(node.mode) ? node.id : 1; + attr.ino = node.id; + attr.mode = node.mode; + attr.nlink = 1; + attr.uid = 0; + attr.gid = 0; + attr.rdev = node.rdev; + if (FS.isDir(node.mode)) { + attr.size = 4096; + } else if (FS.isFile(node.mode)) { + attr.size = node.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); + // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize), + // but this is not required by the standard. + attr.blksize = 4096; + attr.blocks = Math.ceil(attr.size / attr.blksize); + return attr; + },setattr:function(node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp; + } + if (attr.size !== undefined) { + MEMFS.resizeFileStorage(node, attr.size); + } + },lookup:function(parent, name) { + throw FS.genericErrors[44]; + },mknod:function(parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev); + },rename:function(old_node, new_dir, new_name) { + // if we're overwriting a directory at new_name, make sure it's empty. + if (FS.isDir(old_node.mode)) { + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + } + if (new_node) { + for (var i in new_node.contents) { + throw new FS.ErrnoError(55); + } + } + } + // do the internal rewiring + delete old_node.parent.contents[old_node.name]; + old_node.parent.timestamp = Date.now() + old_node.name = new_name; + new_dir.contents[new_name] = old_node; + new_dir.timestamp = old_node.parent.timestamp; + old_node.parent = new_dir; + },unlink:function(parent, name) { + delete parent.contents[name]; + parent.timestamp = Date.now(); + },rmdir:function(parent, name) { + var node = FS.lookupNode(parent, name); + for (var i in node.contents) { + throw new FS.ErrnoError(55); + } + delete parent.contents[name]; + parent.timestamp = Date.now(); + },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 /* 0777 */ | 40960, 0); + node.link = oldpath; + return node; + },readlink:function(node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28); + } + 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); + if (size > 8 && contents.subarray) { // non-trivial, and typed array + buffer.set(contents.subarray(position, position + size), offset); + } else { + for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i]; + } + return size; + },write:function(stream, buffer, offset, length, position, canOwn) { + // If the buffer is located in main memory (HEAP), and if + // memory can grow, we can't hold on to references of the + // memory buffer, as they may get invalidated. That means we + // need to do copy its contents. + if (buffer.buffer === HEAP8.buffer) { + canOwn = false; + } + + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + + if (buffer.subarray && (!node.contents || node.contents.subarray)) { // This write is from a typed array to a typed array? + if (canOwn) { + node.contents = buffer.subarray(offset, offset + length); + node.usedBytes = length; + return length; + } else if (node.usedBytes === 0 && position === 0) { // If this is a simple first write to an empty file, do a fast set since we don't need to care about old data. + node.contents = buffer.slice(offset, offset + length); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { // Writing to an already allocated and used subrange of the file? + node.contents.set(buffer.subarray(offset, offset + length), position); + return length; + } + } + + // Appending to an existing file and we need to reallocate, or source data did not come as a typed array. + MEMFS.expandFileStorage(node, position+length); + if (node.contents.subarray && buffer.subarray) { + // Use typed array write which is available. + node.contents.set(buffer.subarray(offset, offset + length), position); + } else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i]; // Or fall back to manual write if not. + } + } + 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(28); + } + 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, length, position, prot, flags) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + var ptr; + var allocated; + var contents = stream.node.contents; + // Only make a new copy when MAP_PRIVATE is specified. + if (!(flags & 2) && contents.buffer === HEAP8.buffer) { + // We can't emulate MAP_SHARED when the file is not backed by the + // buffer we're mapping to (e.g. the HEAP buffer). + allocated = false; + ptr = contents.byteOffset; + } else { + // Try to avoid unnecessary slices. + if (position > 0 || position + length < contents.length) { + if (contents.subarray) { + contents = contents.subarray(position, position + length); + } else { + contents = Array.prototype.slice.call(contents, position, position + length); + } + } + allocated = true; + ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + HEAP8.set(contents, ptr); + } + return { ptr: ptr, allocated: allocated }; + },msync:function(stream, buffer, offset, length, mmapFlags) { + MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + // should we check if bytesWritten and length are the same? + return 0; + }}}; + + /** @param {boolean=} noRunDep */ + function asyncLoad(url, onload, onerror, noRunDep) { + var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : ''; + readAsync(url, (arrayBuffer) => { + assert(arrayBuffer, `Loading data file "${url}" failed (no arrayBuffer).`); + onload(new Uint8Array(arrayBuffer)); + if (dep) removeRunDependency(dep); + }, (event) => { + if (onerror) { + onerror(); + } else { + throw `Loading data file "${url}" failed.`; + } + }); + if (dep) addRunDependency(dep); + } + + var preloadPlugins = Module['preloadPlugins'] || []; + function FS_handledByPreloadPlugin(byteArray, fullname, finish, onerror) { + // Ensure plugins are ready. + if (typeof Browser != 'undefined') Browser.init(); + + var handled = false; + preloadPlugins.forEach(function(plugin) { + if (handled) return; + if (plugin['canHandle'](fullname)) { + plugin['handle'](byteArray, fullname, finish, onerror); + handled = true; + } + }); + return handled; + } + function FS_createPreloadedFile(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) { + // TODO we should allow people to just pass in a complete filename instead + // of parent and name being that we just join them anyways + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency(`cp ${fullname}`); // might have several active requests for the same fullname + function processData(byteArray) { + function finish(byteArray) { + if (preFinish) preFinish(); + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn); + } + if (onload) onload(); + removeRunDependency(dep); + } + if (FS_handledByPreloadPlugin(byteArray, fullname, finish, () => { + if (onerror) onerror(); + removeRunDependency(dep); + })) { + return; + } + finish(byteArray); + } + addRunDependency(dep); + if (typeof url == 'string') { + asyncLoad(url, (byteArray) => processData(byteArray), onerror); + } else { + processData(url); + } + } + + function FS_modeStringToFlags(str) { + var flagModes = { + 'r': 0, + 'r+': 2, + 'w': 512 | 64 | 1, + 'w+': 512 | 64 | 2, + 'a': 1024 | 64 | 1, + 'a+': 1024 | 64 | 2, + }; + var flags = flagModes[str]; + if (typeof flags == 'undefined') { + throw new Error(`Unknown file open mode: ${str}`); + } + return flags; + } + + function FS_getMode(canRead, canWrite) { + var mode = 0; + if (canRead) mode |= 292 | 73; + if (canWrite) mode |= 146; + return mode; + } + + + + var FS = {root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,lookupPath:(path, opts = {}) => { + path = PATH_FS.resolve(path); + + if (!path) return { path: '', node: null }; + + var defaults = { + follow_mount: true, + recurse_count: 0 + }; + opts = Object.assign(defaults, opts) + + if (opts.recurse_count > 8) { // max recursive lookup of 8 + throw new FS.ErrnoError(32); + } + + // split the absolute path + var parts = path.split('/').filter((p) => !!p); + + // start at the root + var current = FS.root; + var current_path = '/'; + + for (var i = 0; i < parts.length; i++) { + var islast = (i === parts.length-1); + if (islast && opts.parent) { + // stop resolving + break; + } + + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + + // jump to the mount's root node if this is a mountpoint + if (FS.isMountpoint(current)) { + if (!islast || (islast && opts.follow_mount)) { + current = current.mounted.root; + } + } + + // by default, lookupPath will not follow a symlink if it is the final path component. + // setting opts.follow = true will override this behavior. + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + + var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 }); + current = lookup.node; + + if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX). + throw new FS.ErrnoError(32); + } + } + } + } + + return { path: current_path, node: current }; + },getPath:(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:(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:(node) => { + var hash = FS.hashName(node.parent.id, node.name); + node.name_next = FS.nameTable[hash]; + FS.nameTable[hash] = node; + },hashRemoveNode:(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:(parent, name) => { + var errCode = FS.mayLookup(parent); + if (errCode) { + throw new FS.ErrnoError(errCode, parent); + } + var hash = FS.hashName(parent.id, name); + for (var node = FS.nameTable[hash]; node; node = node.name_next) { + var nodeName = node.name; + if (node.parent.id === parent.id && nodeName === name) { + return node; + } + } + // if we failed to find it in the cache, call into the VFS + return FS.lookup(parent, name); + },createNode:(parent, name, mode, rdev) => { + var node = new FS.FSNode(parent, name, mode, rdev); + + FS.hashAddNode(node); + + return node; + },destroyNode:(node) => { + FS.hashRemoveNode(node); + },isRoot:(node) => { + return node === node.parent; + },isMountpoint:(node) => { + return !!node.mounted; + },isFile:(mode) => { + return (mode & 61440) === 32768; + },isDir:(mode) => { + return (mode & 61440) === 16384; + },isLink:(mode) => { + return (mode & 61440) === 40960; + },isChrdev:(mode) => { + return (mode & 61440) === 8192; + },isBlkdev:(mode) => { + return (mode & 61440) === 24576; + },isFIFO:(mode) => { + return (mode & 61440) === 4096; + },isSocket:(mode) => { + return (mode & 49152) === 49152; + },flagsToPermissionString:(flag) => { + var perms = ['r', 'w', 'rw'][flag & 3]; + if ((flag & 512)) { + perms += 'w'; + } + return perms; + },nodePermissions:(node, perms) => { + if (FS.ignorePermissions) { + return 0; + } + // return 0 if any user, group or owner bits are set. + if (perms.includes('r') && !(node.mode & 292)) { + return 2; + } else if (perms.includes('w') && !(node.mode & 146)) { + return 2; + } else if (perms.includes('x') && !(node.mode & 73)) { + return 2; + } + return 0; + },mayLookup:(dir) => { + var errCode = FS.nodePermissions(dir, 'x'); + if (errCode) return errCode; + if (!dir.node_ops.lookup) return 2; + return 0; + },mayCreate:(dir, name) => { + try { + var node = FS.lookupNode(dir, name); + return 20; + } catch (e) { + } + return FS.nodePermissions(dir, 'wx'); + },mayDelete:(dir, name, isdir) => { + var node; + try { + node = FS.lookupNode(dir, name); + } catch (e) { + return e.errno; + } + var errCode = FS.nodePermissions(dir, 'wx'); + if (errCode) { + return errCode; + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return 54; + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return 10; + } + } else { + if (FS.isDir(node.mode)) { + return 31; + } + } + return 0; + },mayOpen:(node, flags) => { + if (!node) { + return 44; + } + if (FS.isLink(node.mode)) { + return 32; + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== 'r' || // opening for write + (flags & 512)) { // TODO: check for O_SEARCH? (== search for dir only) + return 31; + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); + },MAX_OPEN_FDS:4096,nextfd:() => { + for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) { + if (!FS.streams[fd]) { + return fd; + } + } + throw new FS.ErrnoError(33); + },getStream:(fd) => FS.streams[fd],createStream:(stream, fd = -1) => { + if (!FS.FSStream) { + FS.FSStream = /** @constructor */ function() { + this.shared = { }; + }; + FS.FSStream.prototype = {}; + Object.defineProperties(FS.FSStream.prototype, { + object: { + /** @this {FS.FSStream} */ + get: function() { return this.node; }, + /** @this {FS.FSStream} */ + set: function(val) { this.node = val; } + }, + isRead: { + /** @this {FS.FSStream} */ + get: function() { return (this.flags & 2097155) !== 1; } + }, + isWrite: { + /** @this {FS.FSStream} */ + get: function() { return (this.flags & 2097155) !== 0; } + }, + isAppend: { + /** @this {FS.FSStream} */ + get: function() { return (this.flags & 1024); } + }, + flags: { + /** @this {FS.FSStream} */ + get: function() { return this.shared.flags; }, + /** @this {FS.FSStream} */ + set: function(val) { this.shared.flags = val; }, + }, + position : { + /** @this {FS.FSStream} */ + get: function() { return this.shared.position; }, + /** @this {FS.FSStream} */ + set: function(val) { this.shared.position = val; }, + }, + }); + } + // clone it, so we can return an instance of FSStream + stream = Object.assign(new FS.FSStream(), stream); + if (fd == -1) { + fd = FS.nextfd(); + } + stream.fd = fd; + FS.streams[fd] = stream; + return stream; + },closeStream:(fd) => { + FS.streams[fd] = null; + },chrdev_stream_ops:{open:(stream) => { + var device = FS.getDevice(stream.node.rdev); + // override node's stream ops with the device's + stream.stream_ops = device.stream_ops; + // forward the open call + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + },llseek:() => { + throw new FS.ErrnoError(70); + }},major:(dev) => ((dev) >> 8),minor:(dev) => ((dev) & 0xff),makedev:(ma, mi) => ((ma) << 8 | (mi)),registerDevice:(dev, ops) => { + FS.devices[dev] = { stream_ops: ops }; + },getDevice:(dev) => FS.devices[dev],getMounts:(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:(populate, callback) => { + if (typeof populate == 'function') { + callback = populate; + populate = false; + } + + FS.syncFSRequests++; + + if (FS.syncFSRequests > 1) { + err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`); + } + + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + + function doCallback(errCode) { + FS.syncFSRequests--; + return callback(errCode); + } + + function done(errCode) { + if (errCode) { + if (!done.errored) { + done.errored = true; + return doCallback(errCode); + } + return; + } + if (++completed >= mounts.length) { + doCallback(null); + } + }; + + // sync all mounts + mounts.forEach((mount) => { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + }); + },mount:(type, opts, mountpoint) => { + var root = mountpoint === '/'; + var pseudo = !mountpoint; + var node; + + if (root && FS.root) { + throw new FS.ErrnoError(10); + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + mountpoint = lookup.path; // use the absolute path + node = lookup.node; + + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + } + + var mount = { + type: type, + opts: opts, + mountpoint: mountpoint, + mounts: [] + }; + + // create a root node for the fs + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + + if (root) { + FS.root = mountRoot; + } else if (node) { + // set as a mountpoint + node.mounted = mount; + + // add the new mount to the current mount's children + if (node.mount) { + node.mount.mounts.push(mount); + } + } + + return mountRoot; + },unmount:(mountpoint) => { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28); + } + + // destroy the nodes for this mount, and all its child mounts + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + + Object.keys(FS.nameTable).forEach((hash) => { + var current = FS.nameTable[hash]; + + while (current) { + var next = current.name_next; + + if (mounts.includes(current.mount)) { + FS.destroyNode(current); + } + + current = next; + } + }); + + // no longer a mountpoint + node.mounted = null; + + // remove this mount from the child mounts + var idx = node.mount.mounts.indexOf(mount); + node.mount.mounts.splice(idx, 1); + },lookup:(parent, name) => { + return parent.node_ops.lookup(parent, name); + },mknod:(path, mode, dev) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + if (!name || name === '.' || name === '..') { + throw new FS.ErrnoError(28); + } + var errCode = FS.mayCreate(parent, name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.mknod(parent, name, mode, dev); + },create:(path, mode) => { + mode = mode !== undefined ? mode : 438 /* 0666 */; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + },mkdir:(path, mode) => { + mode = mode !== undefined ? mode : 511 /* 0777 */; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0); + },mkdirTree:(path, mode) => { + var dirs = path.split('/'); + var d = ''; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) continue; + d += '/' + dirs[i]; + try { + FS.mkdir(d, mode); + } catch(e) { + if (e.errno != 20) throw e; + } + } + },mkdev:(path, mode, dev) => { + if (typeof dev == 'undefined') { + dev = mode; + mode = 438 /* 0666 */; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + },symlink:(oldpath, newpath) => { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44); + } + var lookup = FS.lookupPath(newpath, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.symlink(parent, newname, oldpath); + },rename:(old_path, new_path) => { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + // parents must exist + var lookup, old_dir, new_dir; + + // let the errors from non existant directories percolate up + lookup = FS.lookupPath(old_path, { parent: true }); + old_dir = lookup.node; + lookup = FS.lookupPath(new_path, { parent: true }); + new_dir = lookup.node; + + if (!old_dir || !new_dir) throw new FS.ErrnoError(44); + // need to be part of the same mount + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + // source must exist + var old_node = FS.lookupNode(old_dir, old_name); + // old path should not be an ancestor of the new path + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(28); + } + // new path should not be an ancestor of the old path + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(55); + } + // see if the new path already exists + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + // not fatal + } + // early out if nothing needs to change + if (old_node === new_node) { + return; + } + // we'll need to delete the old entry + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + // need delete permissions if we'll be overwriting. + // need create permissions if new doesn't already exist. + errCode = new_node ? + FS.mayDelete(new_dir, new_name, isdir) : + FS.mayCreate(new_dir, new_name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) { + throw new FS.ErrnoError(10); + } + // if we are going to change the parent, check write permissions + if (new_dir !== old_dir) { + errCode = FS.nodePermissions(old_dir, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // remove the node from the lookup hash + FS.hashRemoveNode(old_node); + // do the underlying fs rename + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + // add the node back to the hash (in case node_ops.rename + // changed its name) + FS.hashAddNode(old_node); + } + },rmdir:(path) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, true); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.rmdir(parent, name); + FS.destroyNode(node); + },readdir:(path) => { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54); + } + return node.node_ops.readdir(node); + },unlink:(path) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, false); + if (errCode) { + // According to POSIX, we should map EISDIR to EPERM, but + // we instead do what Linux does (and we must, as we use + // the musl linux libc). + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.unlink(parent, name); + FS.destroyNode(node); + },readlink:(path) => { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44); + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28); + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)); + },stat:(path, dontFollow) => { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44); + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63); + } + return node.node_ops.getattr(node); + },lstat:(path) => { + return FS.stat(path, true); + },chmod:(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(63); + } + node.node_ops.setattr(node, { + mode: (mode & 4095) | (node.mode & ~4095), + timestamp: Date.now() + }); + },lchmod:(path, mode) => { + FS.chmod(path, mode, true); + },fchmod:(fd, mode) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chmod(stream.node, mode); + },chown:(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(63); + } + node.node_ops.setattr(node, { + timestamp: Date.now() + // we ignore the uid / gid for now + }); + },lchown:(path, uid, gid) => { + FS.chown(path, uid, gid, true); + },fchown:(fd, uid, gid) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chown(stream.node, uid, gid); + },truncate:(path, len) => { + if (len < 0) { + throw new FS.ErrnoError(28); + } + 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(63); + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31); + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28); + } + var errCode = FS.nodePermissions(node, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + node.node_ops.setattr(node, { + size: len, + timestamp: Date.now() + }); + },ftruncate:(fd, len) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(28); + } + FS.truncate(stream.node, len); + },utime:(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:(path, flags, mode) => { + if (path === "") { + throw new FS.ErrnoError(44); + } + flags = typeof flags == 'string' ? FS_modeStringToFlags(flags) : flags; + mode = typeof mode == 'undefined' ? 438 /* 0666 */ : mode; + if ((flags & 64)) { + mode = (mode & 4095) | 32768; + } else { + mode = 0; + } + var node; + if (typeof path == 'object') { + node = path; + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { + follow: !(flags & 131072) + }); + node = lookup.node; + } catch (e) { + // ignore + } + } + // perhaps we need to create the node + var created = false; + if ((flags & 64)) { + if (node) { + // if O_CREAT and O_EXCL are set, error out if the node already exists + if ((flags & 128)) { + throw new FS.ErrnoError(20); + } + } else { + // node doesn't exist, try to create it + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + // can't truncate a device + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + // if asked only for a directory, then this must be one + if ((flags & 65536) && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + // check permissions, if this is not a file we just created now (it is ok to + // create and write to a file with read-only permissions; it is read-only + // for later use) + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // do truncation if necessary + if ((flags & 512) && !created) { + FS.truncate(node, 0); + } + // we've already handled these, don't pass down to the underlying vfs + flags &= ~(128 | 512 | 131072); + + // register the stream with the filesystem + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), // we want the absolute path to the node + flags: flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + // used by the file family libc calls (fopen, fwrite, ferror, etc.) + ungotten: [], + error: false + }); + // call the new stream's open function + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + if (Module['logReadFiles'] && !(flags & 1)) { + if (!FS.readFiles) FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1; + } + } + return stream; + },close:(stream) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (stream.getdents) stream.getdents = null; // free readdir state + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream); + } + } catch (e) { + throw e; + } finally { + FS.closeStream(stream.fd); + } + stream.fd = null; + },isClosed:(stream) => { + return stream.fd === null; + },llseek:(stream, offset, whence) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70); + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28); + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position; + },read:(stream, buffer, offset, length, position) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position != 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead; + },write:(stream, buffer, offset, length, position, canOwn) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + // seek to the end before writing in append mode + FS.llseek(stream, 0, 2); + } + var seeking = typeof position != 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); + if (!seeking) stream.position += bytesWritten; + return bytesWritten; + },allocate:(stream, offset, length) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138); + } + stream.stream_ops.allocate(stream, offset, length); + },mmap:(stream, length, position, prot, flags) => { + // User requests writing to file (prot & PROT_WRITE != 0). + // Checking if we have permissions to write to the file unless + // MAP_PRIVATE flag is set. According to POSIX spec it is possible + // to write to file opened in read-only mode with MAP_PRIVATE flag, + // as all modifications will be visible only in the memory of + // the current process. + if ((prot & 2) !== 0 + && (flags & 2) === 0 + && (stream.flags & 2097155) !== 2) { + throw new FS.ErrnoError(2); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(2); + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(43); + } + return stream.stream_ops.mmap(stream, length, position, prot, flags); + },msync:(stream, buffer, offset, length, mmapFlags) => { + if (!stream.stream_ops.msync) { + return 0; + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); + },munmap:(stream) => 0,ioctl:(stream, cmd, arg) => { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59); + } + return stream.stream_ops.ioctl(stream, cmd, arg); + },readFile:(path, opts = {}) => { + opts.flags = opts.flags || 0; + 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 = UTF8ArrayToString(buf, 0); + } else if (opts.encoding === 'binary') { + ret = buf; + } + FS.close(stream); + return ret; + },writeFile:(path, data, opts = {}) => { + opts.flags = opts.flags || 577; + var stream = FS.open(path, opts.flags, opts.mode); + if (typeof data == 'string') { + var buf = new Uint8Array(lengthBytesUTF8(data)+1); + var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); + FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn); + } else if (ArrayBuffer.isView(data)) { + FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn); + } else { + throw new Error('Unsupported data type'); + } + FS.close(stream); + },cwd:() => FS.currentPath,chdir:(path) => { + var lookup = FS.lookupPath(path, { follow: true }); + if (lookup.node === null) { + throw new FS.ErrnoError(44); + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54); + } + var errCode = FS.nodePermissions(lookup.node, 'x'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + FS.currentPath = lookup.path; + },createDefaultDirectories:() => { + FS.mkdir('/tmp'); + FS.mkdir('/home'); + FS.mkdir('/home/web_user'); + },createDefaultDevices:() => { + // create /dev + FS.mkdir('/dev'); + // setup /dev/null + FS.registerDevice(FS.makedev(1, 3), { + read: () => 0, + write: (stream, buffer, offset, length, pos) => length, + }); + FS.mkdev('/dev/null', FS.makedev(1, 3)); + // setup /dev/tty and /dev/tty1 + // stderr needs to print output using err() rather than out() + // so we register a second tty just for it. + TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); + TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); + FS.mkdev('/dev/tty', FS.makedev(5, 0)); + FS.mkdev('/dev/tty1', FS.makedev(6, 0)); + // setup /dev/[u]random + // use a buffer to avoid overhead of individual crypto calls per byte + var randomBuffer = new Uint8Array(1024), randomLeft = 0; + var randomByte = () => { + if (randomLeft === 0) { + randomLeft = randomFill(randomBuffer).byteLength; + } + return randomBuffer[--randomLeft]; + }; + FS.createDevice('/dev', 'random', randomByte); + FS.createDevice('/dev', 'urandom', randomByte); + // we're not going to emulate the actual shm device, + // just create the tmp dirs that reside in it commonly + FS.mkdir('/dev/shm'); + FS.mkdir('/dev/shm/tmp'); + },createSpecialDirectories:() => { + // create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the + // name of the stream for fd 6 (see test_unistd_ttyname) + FS.mkdir('/proc'); + var proc_self = FS.mkdir('/proc/self'); + FS.mkdir('/proc/self/fd'); + FS.mount({ + mount: () => { + var node = FS.createNode(proc_self, 'fd', 16384 | 511 /* 0777 */, 73); + node.node_ops = { + lookup: (parent, name) => { + var fd = +name; + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + var ret = { + parent: null, + mount: { mountpoint: 'fake' }, + node_ops: { readlink: () => stream.path }, + }; + ret.parent = ret; // make it look like a simple root node + return ret; + } + }; + return node; + } + }, {}, '/proc/self/fd'); + },createStandardStreams:() => { + // TODO deprecate the old functionality of a single + // input / output callback and that utilizes FS.createDevice + // and instead require a unique set of stream ops + + // by default, we symlink the standard streams to the + // default tty devices. however, if the standard streams + // have been overwritten we create a unique device for + // them instead. + if (Module['stdin']) { + FS.createDevice('/dev', 'stdin', Module['stdin']); + } else { + FS.symlink('/dev/tty', '/dev/stdin'); + } + if (Module['stdout']) { + FS.createDevice('/dev', 'stdout', null, Module['stdout']); + } else { + FS.symlink('/dev/tty', '/dev/stdout'); + } + if (Module['stderr']) { + FS.createDevice('/dev', 'stderr', null, Module['stderr']); + } else { + FS.symlink('/dev/tty1', '/dev/stderr'); + } + + // open default streams for the stdin, stdout and stderr devices + var stdin = FS.open('/dev/stdin', 0); + var stdout = FS.open('/dev/stdout', 1); + var stderr = FS.open('/dev/stderr', 1); + },ensureErrnoError:() => { + if (FS.ErrnoError) return; + FS.ErrnoError = /** @this{Object} */ function ErrnoError(errno, node) { + // We set the `name` property to be able to identify `FS.ErrnoError` + // - the `name` is a standard ECMA-262 property of error objects. Kind of good to have it anyway. + // - when using PROXYFS, an error can come from an underlying FS + // as different FS objects have their own FS.ErrnoError each, + // the test `err instanceof FS.ErrnoError` won't detect an error coming from another filesystem, causing bugs. + // we'll use the reliable test `err.name == "ErrnoError"` instead + this.name = 'ErrnoError'; + this.node = node; + this.setErrno = /** @this{Object} */ function(errno) { + this.errno = errno; + }; + this.setErrno(errno); + this.message = 'FS error'; + + }; + FS.ErrnoError.prototype = new Error(); + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info) + [44].forEach((code) => { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = ''; + }); + },staticInit:() => { + FS.ensureErrnoError(); + + FS.nameTable = new Array(4096); + + FS.mount(MEMFS, {}, '/'); + + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + + FS.filesystems = { + 'MEMFS': MEMFS, + }; + },init:(input, output, error) => { + FS.init.initialized = true; + + FS.ensureErrnoError(); + + // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here + Module['stdin'] = input || Module['stdin']; + Module['stdout'] = output || Module['stdout']; + Module['stderr'] = error || Module['stderr']; + + FS.createStandardStreams(); + },quit:() => { + FS.init.initialized = false; + // force-flush all streams, so we get musl std streams printed out + // close all of our streams + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue; + } + FS.close(stream); + } + },findObject:(path, dontResolveLastLink) => { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (!ret.exists) { + return null; + } + return ret.object; + },analyzePath:(path, dontResolveLastLink) => { + // operate from within the context of the symlink's target + try { + var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + path = lookup.path; + } catch (e) { + } + var ret = { + isRoot: false, exists: false, error: 0, name: null, path: null, object: null, + parentExists: false, parentPath: null, parentObject: null + }; + try { + var lookup = FS.lookupPath(path, { parent: true }); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === '/'; + } catch (e) { + ret.error = e.errno; + }; + return ret; + },createPath:(parent, path, canRead, canWrite) => { + parent = typeof parent == 'string' ? parent : FS.getPath(parent); + var parts = path.split('/').reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current); + } catch (e) { + // ignore EEXIST + } + parent = current; + } + return current; + },createFile:(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:(parent, name, data, canRead, canWrite, canOwn) => { + var path = name; + if (parent) { + parent = typeof parent == 'string' ? parent : FS.getPath(parent); + path = name ? PATH.join2(parent, name) : parent; + } + var mode = FS_getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data == 'string') { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i); + data = arr; + } + // make sure we can write to the file + FS.chmod(node, mode | 146); + var stream = FS.open(node, 577); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode); + } + return node; + },createDevice:(parent, name, input, output) => { + var path = PATH.join2(typeof parent == 'string' ? parent : FS.getPath(parent), name); + var mode = FS_getMode(!!input, !!output); + if (!FS.createDevice.major) FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + // Create a fake device that a set of stream ops to emulate + // the old behavior. + FS.registerDevice(dev, { + open: (stream) => { + stream.seekable = false; + }, + close: (stream) => { + // flush any pending line data + if (output && output.buffer && output.buffer.length) { + output(10); + } + }, + read: (stream, buffer, offset, length, pos /* ignored */) => { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input(); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write: (stream, buffer, offset, length, pos) => { + for (var i = 0; i < length; i++) { + try { + output(buffer[offset+i]); + } catch (e) { + throw new FS.ErrnoError(29); + } + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + } + }); + return FS.mkdev(path, mode, dev); + },forceLoadFile:(obj) => { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return 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 (read_) { + // Command-line. + try { + // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as + // read() will try to parse UTF8. + obj.contents = intArrayFromString(read_(obj.url), true); + obj.usedBytes = obj.contents.length; + } catch (e) { + throw new FS.ErrnoError(29); + } + } else { + throw new Error('Cannot load without read() or XMLHttpRequest.'); + } + },createLazyFile:(parent, name, url, canRead, canWrite) => { + // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse. + /** @constructor */ + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; // Loaded chunks. Index is the chunk number + } + LazyUint8Array.prototype.get = /** @this{Object} */ function LazyUint8Array_get(idx) { + if (idx > this.length-1 || idx < 0) { + return undefined; + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = (idx / this.chunkSize)|0; + return this.getter(chunkNum)[chunkOffset]; + }; + LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { + this.getter = getter; + }; + LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { + // Find length + var xhr = new XMLHttpRequest(); + xhr.open('HEAD', url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + + var chunkSize = 1024*1024; // Chunk size in bytes + + if (!hasByteServing) chunkSize = datalength; + + // Function to get a range from the remote URL. + var doXHR = (from, to) => { + if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!"); + + // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available. + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + + // Some hints to the browser that we want binary data. + 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(/** @type{Array} */(xhr.response || [])); + } + return intArrayFromString(xhr.responseText || '', true); + }; + var lazyArray = this; + lazyArray.setDataGetter((chunkNum) => { + var start = chunkNum * chunkSize; + var end = (chunkNum+1) * chunkSize - 1; // including this byte + end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block + if (typeof lazyArray.chunks[chunkNum] == 'undefined') { + lazyArray.chunks[chunkNum] = doXHR(start, end); + } + if (typeof lazyArray.chunks[chunkNum] == 'undefined') throw new Error('doXHR failed!'); + return lazyArray.chunks[chunkNum]; + }); + + if (usesGzip || !datalength) { + // if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length + chunkSize = datalength = 1; // this will force getter(0)/doXHR do download the whole file + datalength = this.getter(0).length; + chunkSize = datalength; + out("LazyFiles on gzip forces download of the whole file when length is accessed"); + } + + 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.defineProperties(lazyArray, { + length: { + get: /** @this{Object} */ function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + } + }, + chunkSize: { + get: /** @this{Object} */ function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._chunkSize; + } + } + }); + + var properties = { isDevice: false, contents: lazyArray }; + } else { + var properties = { isDevice: false, url: url }; + } + + var node = FS.createFile(parent, name, properties, canRead, canWrite); + // This is a total hack, but I want to get this lazy file code out of the + // core of MEMFS. If we want to keep this lazy file concept I feel it should + // be its own thin LAZYFS proxying calls to MEMFS. + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + // Add a function that defers querying the file size until it is asked the first time. + Object.defineProperties(node, { + usedBytes: { + get: /** @this {FSNode} */ function() { return this.contents.length; } + } + }); + // override each stream op with one that tries to force load the lazy file first + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach((key) => { + var fn = node.stream_ops[key]; + stream_ops[key] = function forceLoadLazyFile() { + FS.forceLoadFile(node); + return fn.apply(null, arguments); + }; + }); + function writeChunks(stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= contents.length) + return 0; + var size = Math.min(contents.length - position, length); + if (contents.slice) { // normal array + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR + buffer[offset + i] = contents.get(position + i); + } + } + return size; + } + // use a custom read function + stream_ops.read = (stream, buffer, offset, length, position) => { + FS.forceLoadFile(node); + return writeChunks(stream, buffer, offset, length, position) + }; + // use a custom mmap function + stream_ops.mmap = (stream, length, position, prot, flags) => { + FS.forceLoadFile(node); + var ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + writeChunks(stream, HEAP8, ptr, length, position); + return { ptr: ptr, allocated: true }; + }; + node.stream_ops = stream_ops; + return node; + }}; + + var SYSCALLS = {DEFAULT_POLLMASK:5,calculateAt:function(dirfd, path, allowEmpty) { + if (PATH.isAbs(path)) { + return path; + } + // relative path + var dir; + if (dirfd === -100) { + dir = FS.cwd(); + } else { + var dirstream = SYSCALLS.getStreamFromFD(dirfd); + dir = dirstream.path; + } + if (path.length == 0) { + if (!allowEmpty) { + throw new FS.ErrnoError(44);; + } + return dir; + } + return PATH.join2(dir, path); + },doStat:function(func, path, buf) { + try { + var stat = func(path); + } catch (e) { + if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) { + // an error occurred while trying to look up the path; we should just report ENOTDIR + return -54; + } + throw e; + } + HEAP32[((buf)>>2)] = stat.dev; + HEAP32[(((buf)+(8))>>2)] = stat.ino; + HEAP32[(((buf)+(12))>>2)] = stat.mode; + HEAPU32[(((buf)+(16))>>2)] = stat.nlink; + HEAP32[(((buf)+(20))>>2)] = stat.uid; + HEAP32[(((buf)+(24))>>2)] = stat.gid; + HEAP32[(((buf)+(28))>>2)] = stat.rdev; + (tempI64 = [stat.size>>>0,(tempDouble=stat.size,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(40))>>2)] = tempI64[0],HEAP32[(((buf)+(44))>>2)] = tempI64[1]); + HEAP32[(((buf)+(48))>>2)] = 4096; + HEAP32[(((buf)+(52))>>2)] = stat.blocks; + var atime = stat.atime.getTime(); + var mtime = stat.mtime.getTime(); + var ctime = stat.ctime.getTime(); + (tempI64 = [Math.floor(atime / 1000)>>>0,(tempDouble=Math.floor(atime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(56))>>2)] = tempI64[0],HEAP32[(((buf)+(60))>>2)] = tempI64[1]); + HEAPU32[(((buf)+(64))>>2)] = (atime % 1000) * 1000; + (tempI64 = [Math.floor(mtime / 1000)>>>0,(tempDouble=Math.floor(mtime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(72))>>2)] = tempI64[0],HEAP32[(((buf)+(76))>>2)] = tempI64[1]); + HEAPU32[(((buf)+(80))>>2)] = (mtime % 1000) * 1000; + (tempI64 = [Math.floor(ctime / 1000)>>>0,(tempDouble=Math.floor(ctime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(88))>>2)] = tempI64[0],HEAP32[(((buf)+(92))>>2)] = tempI64[1]); + HEAPU32[(((buf)+(96))>>2)] = (ctime % 1000) * 1000; + (tempI64 = [stat.ino>>>0,(tempDouble=stat.ino,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(104))>>2)] = tempI64[0],HEAP32[(((buf)+(108))>>2)] = tempI64[1]); + return 0; + },doMsync:function(addr, stream, len, flags, offset) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (flags & 2) { + // MAP_PRIVATE calls need not to be synced back to underlying fs + return 0; + } + var buffer = HEAPU8.slice(addr, addr + len); + FS.msync(stream, buffer, offset, len, flags); + },varargs:undefined,get:function() { + SYSCALLS.varargs += 4; + var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)]; + return ret; + },getStr:function(ptr) { + var ret = UTF8ToString(ptr); + return ret; + },getStreamFromFD:function(fd) { + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + return stream; + }}; + function ___syscall_fcntl64(fd, cmd, varargs) { + SYSCALLS.varargs = varargs; + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + switch (cmd) { + case 0: { + var arg = SYSCALLS.get(); + if (arg < 0) { + return -28; + } + var newStream; + newStream = FS.createStream(stream, arg); + return newStream.fd; + } + case 1: + case 2: + return 0; // FD_CLOEXEC makes no sense for a single process. + case 3: + return stream.flags; + case 4: { + var arg = SYSCALLS.get(); + stream.flags |= arg; + return 0; + } + case 5: + /* case 5: Currently in musl F_GETLK64 has same value as F_GETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ { + + var arg = SYSCALLS.get(); + var offset = 0; + // We're always unlocked. + HEAP16[(((arg)+(offset))>>1)] = 2; + return 0; + } + case 6: + case 7: + /* case 6: Currently in musl F_SETLK64 has same value as F_SETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ + /* case 7: Currently in musl F_SETLKW64 has same value as F_SETLKW, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ + + + return 0; // Pretend that the locking is successful. + case 16: + case 8: + return -28; // These are for sockets. We don't have them fully implemented yet. + case 9: + // musl trusts getown return values, due to a bug where they must be, as they overlap with errors. just return -1 here, so fcntl() returns that, and we set errno ourselves. + setErrNo(28); + return -1; + default: { + return -28; + } + } + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + function ___syscall_ioctl(fd, op, varargs) { + SYSCALLS.varargs = varargs; + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + switch (op) { + case 21509: + case 21505: { + if (!stream.tty) return -59; + return 0; + } + case 21510: + case 21511: + case 21512: + case 21506: + case 21507: + case 21508: { + if (!stream.tty) return -59; + return 0; // no-op, not actually adjusting terminal settings + } + case 21519: { + if (!stream.tty) return -59; + var argp = SYSCALLS.get(); + HEAP32[((argp)>>2)] = 0; + return 0; + } + case 21520: { + if (!stream.tty) return -59; + return -28; // not supported + } + case 21531: { + var argp = SYSCALLS.get(); + return FS.ioctl(stream, op, argp); + } + case 21523: { + // TODO: in theory we should write to the winsize struct that gets + // passed in, but for now musl doesn't read anything on it + if (!stream.tty) return -59; + return 0; + } + case 21524: { + // TODO: technically, this ioctl call should change the window size. + // but, since emscripten doesn't have any concept of a terminal window + // yet, we'll just silently throw it away as we do TIOCGWINSZ + if (!stream.tty) return -59; + return 0; + } + default: return -28; // not supported + } + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + function ___syscall_openat(dirfd, path, flags, varargs) { + SYSCALLS.varargs = varargs; + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + var mode = varargs ? SYSCALLS.get() : 0; + return FS.open(path, flags, mode).fd; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + var char_0 = 48; + + var char_9 = 57; + function makeLegalFunctionName(name) { + if (undefined === name) { + return '_unknown'; + } + name = name.replace(/[^a-zA-Z0-9_]/g, '$'); + var f = name.charCodeAt(0); + if (f >= char_0 && f <= char_9) { + return `_${name}`; + } + return name; + } + function createNamedFunction(name, body) { + name = makeLegalFunctionName(name); + // Use an abject with a computed property name to create a new function with + // a name specified at runtime, but without using `new Function` or `eval`. + return { + [name]: function() { + return body.apply(this, arguments); + } + }[name]; + } + + /** @constructor */ + function HandleAllocator() { + // Reserve slot 0 so that 0 is always an invalid handle + this.allocated = [undefined]; + this.freelist = []; + this.get = function(id) { + return this.allocated[id]; + }; + this.has = function(id) { + return this.allocated[id] !== undefined; + }; + this.allocate = function(handle) { + var id = this.freelist.pop() || this.allocated.length; + this.allocated[id] = handle; + return id; + }; + this.free = function(id) { + // Set the slot to `undefined` rather than using `delete` here since + // apparently arrays with holes in them can be less efficient. + this.allocated[id] = undefined; + this.freelist.push(id); + }; + } + var emval_handles = new HandleAllocator();; + + function extendError(baseErrorType, errorName) { + var errorClass = createNamedFunction(errorName, function(message) { + this.name = errorName; + this.message = message; + + var stack = (new Error(message)).stack; + if (stack !== undefined) { + this.stack = this.toString() + '\n' + + stack.replace(/^Error(:[^\n]*)?\n/, ''); + } + }); + errorClass.prototype = Object.create(baseErrorType.prototype); + errorClass.prototype.constructor = errorClass; + errorClass.prototype.toString = function() { + if (this.message === undefined) { + return this.name; + } else { + return `${this.name}: ${this.message}`; + } + }; + + return errorClass; + } + var BindingError = undefined; + function throwBindingError(message) { + throw new BindingError(message); + } + + function count_emval_handles() { + var count = 0; + for (var i = emval_handles.reserved; i < emval_handles.allocated.length; ++i) { + if (emval_handles.allocated[i] !== undefined) { + ++count; + } + } + return count; + } + + function init_emval() { + // reserve some special values. These never get de-allocated. + // The HandleAllocator takes care of reserving zero. + emval_handles.allocated.push( + {value: undefined}, + {value: null}, + {value: true}, + {value: false}, + ); + emval_handles.reserved = emval_handles.allocated.length + Module['count_emval_handles'] = count_emval_handles; + } + var Emval = {toValue:(handle) => { + if (!handle) { + throwBindingError('Cannot use deleted val. handle = ' + handle); + } + return emval_handles.get(handle).value; + },toHandle:(value) => { + switch (value) { + case undefined: return 1; + case null: return 2; + case true: return 3; + case false: return 4; + default:{ + return emval_handles.allocate({refcount: 1, value: value}); + } + } + }}; + + var PureVirtualError = undefined; + + function embind_init_charCodes() { + var codes = new Array(256); + for (var i = 0; i < 256; ++i) { + codes[i] = String.fromCharCode(i); + } + embind_charCodes = codes; + } + var embind_charCodes = undefined; + function readLatin1String(ptr) { + var ret = ""; + var c = ptr; + while (HEAPU8[c]) { + ret += embind_charCodes[HEAPU8[c++]]; + } + return ret; + } + + function getInheritedInstanceCount() { + return Object.keys(registeredInstances).length; + } + + function getLiveInheritedInstances() { + var rv = []; + for (var k in registeredInstances) { + if (registeredInstances.hasOwnProperty(k)) { + rv.push(registeredInstances[k]); + } + } + return rv; + } + + var deletionQueue = []; + function flushPendingDeletes() { + while (deletionQueue.length) { + var obj = deletionQueue.pop(); + obj.$$.deleteScheduled = false; + obj['delete'](); + } + } + + var delayFunction = undefined; + + + function setDelayFunction(fn) { + delayFunction = fn; + if (deletionQueue.length && delayFunction) { + delayFunction(flushPendingDeletes); + } + } + function init_embind() { + Module['getInheritedInstanceCount'] = getInheritedInstanceCount; + Module['getLiveInheritedInstances'] = getLiveInheritedInstances; + Module['flushPendingDeletes'] = flushPendingDeletes; + Module['setDelayFunction'] = setDelayFunction; + } + var registeredInstances = {}; + + function getBasestPointer(class_, ptr) { + if (ptr === undefined) { + throwBindingError('ptr should not be undefined'); + } + while (class_.baseClass) { + ptr = class_.upcast(ptr); + class_ = class_.baseClass; + } + return ptr; + } + + function registerInheritedInstance(class_, ptr, instance) { + ptr = getBasestPointer(class_, ptr); + if (registeredInstances.hasOwnProperty(ptr)) { + throwBindingError(`Tried to register registered instance: ${ptr}`); + } else { + registeredInstances[ptr] = instance; + } + } + + var registeredTypes = {}; + + + + function getTypeName(type) { + var ptr = ___getTypeName(type); + var rv = readLatin1String(ptr); + _free(ptr); + return rv; + } + + function requireRegisteredType(rawType, humanName) { + var impl = registeredTypes[rawType]; + if (undefined === impl) { + throwBindingError(humanName + " has unknown type " + getTypeName(rawType)); + } + return impl; + } + + + + + function unregisterInheritedInstance(class_, ptr) { + ptr = getBasestPointer(class_, ptr); + if (registeredInstances.hasOwnProperty(ptr)) { + delete registeredInstances[ptr]; + } else { + throwBindingError(`Tried to unregister unregistered instance: ${ptr}`); + } + } + + function detachFinalizer(handle) {} + + var finalizationRegistry = false; + + + function runDestructor($$) { + if ($$.smartPtr) { + $$.smartPtrType.rawDestructor($$.smartPtr); + } else { + $$.ptrType.registeredClass.rawDestructor($$.ptr); + } + } + function releaseClassHandle($$) { + $$.count.value -= 1; + var toDelete = 0 === $$.count.value; + if (toDelete) { + runDestructor($$); + } + } + + function downcastPointer(ptr, ptrClass, desiredClass) { + if (ptrClass === desiredClass) { + return ptr; + } + if (undefined === desiredClass.baseClass) { + return null; // no conversion + } + + var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass); + if (rv === null) { + return null; + } + return desiredClass.downcast(rv); + } + + var registeredPointers = {}; + + + function getInheritedInstance(class_, ptr) { + ptr = getBasestPointer(class_, ptr); + return registeredInstances[ptr]; + } + + var InternalError = undefined; + function throwInternalError(message) { + throw new InternalError(message); + } + + function makeClassHandle(prototype, record) { + if (!record.ptrType || !record.ptr) { + throwInternalError('makeClassHandle requires ptr and ptrType'); + } + var hasSmartPtrType = !!record.smartPtrType; + var hasSmartPtr = !!record.smartPtr; + if (hasSmartPtrType !== hasSmartPtr) { + throwInternalError('Both smartPtrType and smartPtr must be specified'); + } + record.count = { value: 1 }; + return attachFinalizer(Object.create(prototype, { + $$: { + value: record, + }, + })); + } + function RegisteredPointer_fromWireType(ptr) { + // ptr is a raw pointer (or a raw smartpointer) + + // rawPointer is a maybe-null raw pointer + var rawPointer = this.getPointee(ptr); + if (!rawPointer) { + this.destructor(ptr); + return null; + } + + var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer); + if (undefined !== registeredInstance) { + // JS object has been neutered, time to repopulate it + if (0 === registeredInstance.$$.count.value) { + registeredInstance.$$.ptr = rawPointer; + registeredInstance.$$.smartPtr = ptr; + return registeredInstance['clone'](); + } else { + // else, just increment reference count on existing object + // it already has a reference to the smart pointer + var rv = registeredInstance['clone'](); + this.destructor(ptr); + return rv; + } + } + + function makeDefaultHandle() { + if (this.isSmartPointer) { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this.pointeeType, + ptr: rawPointer, + smartPtrType: this, + smartPtr: ptr, + }); + } else { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this, + ptr: ptr, + }); + } + } + + var actualType = this.registeredClass.getActualType(rawPointer); + var registeredPointerRecord = registeredPointers[actualType]; + if (!registeredPointerRecord) { + return makeDefaultHandle.call(this); + } + + var toType; + if (this.isConst) { + toType = registeredPointerRecord.constPointerType; + } else { + toType = registeredPointerRecord.pointerType; + } + var dp = downcastPointer( + rawPointer, + this.registeredClass, + toType.registeredClass); + if (dp === null) { + return makeDefaultHandle.call(this); + } + if (this.isSmartPointer) { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp, + smartPtrType: this, + smartPtr: ptr, + }); + } else { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp, + }); + } + } + function attachFinalizer(handle) { + if ('undefined' === typeof FinalizationRegistry) { + attachFinalizer = (handle) => handle; + return handle; + } + // If the running environment has a FinalizationRegistry (see + // https://github.com/tc39/proposal-weakrefs), then attach finalizers + // for class handles. We check for the presence of FinalizationRegistry + // at run-time, not build-time. + finalizationRegistry = new FinalizationRegistry((info) => { + releaseClassHandle(info.$$); + }); + attachFinalizer = (handle) => { + var $$ = handle.$$; + var hasSmartPtr = !!$$.smartPtr; + if (hasSmartPtr) { + // We should not call the destructor on raw pointers in case other code expects the pointee to live + var info = { $$: $$ }; + finalizationRegistry.register(handle, info, handle); + } + return handle; + }; + detachFinalizer = (handle) => finalizationRegistry.unregister(handle); + return attachFinalizer(handle); + } + function __embind_create_inheriting_constructor(constructorName, wrapperType, properties) { + constructorName = readLatin1String(constructorName); + wrapperType = requireRegisteredType(wrapperType, 'wrapper'); + properties = Emval.toValue(properties); + + var arraySlice = [].slice; + + var registeredClass = wrapperType.registeredClass; + var wrapperPrototype = registeredClass.instancePrototype; + var baseClass = registeredClass.baseClass; + var baseClassPrototype = baseClass.instancePrototype; + var baseConstructor = registeredClass.baseClass.constructor; + var ctor = createNamedFunction(constructorName, function() { + registeredClass.baseClass.pureVirtualFunctions.forEach(function(name) { + if (this[name] === baseClassPrototype[name]) { + throw new PureVirtualError(`Pure virtual function ${name} must be implemented in JavaScript`); + } + }.bind(this)); + + Object.defineProperty(this, '__parent', { + value: wrapperPrototype + }); + this["__construct"].apply(this, arraySlice.call(arguments)); + }); + + // It's a little nasty that we're modifying the wrapper prototype here. + + wrapperPrototype["__construct"] = function __construct() { + if (this === wrapperPrototype) { + throwBindingError("Pass correct 'this' to __construct"); + } + + var inner = baseConstructor["implement"].apply( + undefined, + [this].concat(arraySlice.call(arguments))); + detachFinalizer(inner); + var $$ = inner.$$; + inner["notifyOnDestruction"](); + $$.preservePointerOnDelete = true; + Object.defineProperties(this, { $$: { + value: $$ + }}); + attachFinalizer(this); + registerInheritedInstance(registeredClass, $$.ptr, this); + }; + + wrapperPrototype["__destruct"] = function __destruct() { + if (this === wrapperPrototype) { + throwBindingError("Pass correct 'this' to __destruct"); + } + + detachFinalizer(this); + unregisterInheritedInstance(registeredClass, this.$$.ptr); + }; + + ctor.prototype = Object.create(wrapperPrototype); + for (var p in properties) { + ctor.prototype[p] = properties[p]; + } + return Emval.toHandle(ctor); + } + + var structRegistrations = {}; + + function runDestructors(destructors) { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } + } + + function simpleReadValueFromPointer(pointer) { + return this['fromWireType'](HEAP32[((pointer)>>2)]); + } + + var awaitingDependencies = {}; + + + var typeDependencies = {}; + + function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) { + myTypes.forEach(function(type) { + typeDependencies[type] = dependentTypes; + }); + + function onComplete(typeConverters) { + var myTypeConverters = getTypeConverters(typeConverters); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError('Mismatched type converter count'); + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]); + } + } + + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach((dt, i) => { + if (registeredTypes.hasOwnProperty(dt)) { + typeConverters[i] = registeredTypes[dt]; + } else { + unregisteredTypes.push(dt); + if (!awaitingDependencies.hasOwnProperty(dt)) { + awaitingDependencies[dt] = []; + } + awaitingDependencies[dt].push(() => { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters); + } + }); + } + }); + if (0 === unregisteredTypes.length) { + onComplete(typeConverters); + } + } + function __embind_finalize_value_object(structType) { + var reg = structRegistrations[structType]; + delete structRegistrations[structType]; + + var rawConstructor = reg.rawConstructor; + var rawDestructor = reg.rawDestructor; + var fieldRecords = reg.fields; + var fieldTypes = fieldRecords.map((field) => field.getterReturnType). + concat(fieldRecords.map((field) => field.setterArgumentType)); + whenDependentTypesAreResolved([structType], fieldTypes, (fieldTypes) => { + var fields = {}; + fieldRecords.forEach((field, i) => { + var fieldName = field.fieldName; + var getterReturnType = fieldTypes[i]; + var getter = field.getter; + var getterContext = field.getterContext; + var setterArgumentType = fieldTypes[i + fieldRecords.length]; + var setter = field.setter; + var setterContext = field.setterContext; + fields[fieldName] = { + read: (ptr) => { + return getterReturnType['fromWireType']( + getter(getterContext, ptr)); + }, + write: (ptr, o) => { + var destructors = []; + setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, o)); + runDestructors(destructors); + } + }; + }); + + return [{ + name: reg.name, + 'fromWireType': function(ptr) { + var rv = {}; + for (var i in fields) { + rv[i] = fields[i].read(ptr); + } + rawDestructor(ptr); + return rv; + }, + 'toWireType': function(destructors, o) { + // todo: Here we have an opportunity for -O3 level "unsafe" optimizations: + // assume all fields are present without checking. + for (var fieldName in fields) { + if (!(fieldName in o)) { + throw new TypeError(`Missing field: "${fieldName}"`); + } + } + var ptr = rawConstructor(); + for (fieldName in fields) { + fields[fieldName].write(ptr, o[fieldName]); + } + if (destructors !== null) { + destructors.push(rawDestructor, ptr); + } + return ptr; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: rawDestructor, + }]; + }); + } + + function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {} + + function getShiftFromSize(size) { + switch (size) { + case 1: return 0; + case 2: return 1; + case 4: return 2; + case 8: return 3; + default: + throw new TypeError(`Unknown type size: ${size}`); + } + } + + + + + + + /** @param {Object=} options */ + function registerType(rawType, registeredInstance, options = {}) { + if (!('argPackAdvance' in registeredInstance)) { + throw new TypeError('registerType registeredInstance requires argPackAdvance'); + } + + var name = registeredInstance.name; + if (!rawType) { + throwBindingError(`type "${name}" must have a positive integer typeid pointer`); + } + if (registeredTypes.hasOwnProperty(rawType)) { + if (options.ignoreDuplicateRegistrations) { + return; + } else { + throwBindingError(`Cannot register type '${name}' twice`); + } + } + + registeredTypes[rawType] = registeredInstance; + delete typeDependencies[rawType]; + + if (awaitingDependencies.hasOwnProperty(rawType)) { + var callbacks = awaitingDependencies[rawType]; + delete awaitingDependencies[rawType]; + callbacks.forEach((cb) => cb()); + } + } + function __embind_register_bool(rawType, name, size, trueValue, falseValue) { + var shift = getShiftFromSize(size); + + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(wt) { + // ambiguous emscripten ABI: sometimes return values are + // true or false, and sometimes integers (0 or 1) + return !!wt; + }, + 'toWireType': function(destructors, o) { + return o ? trueValue : falseValue; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': function(pointer) { + // TODO: if heap is fixed (like in asm.js) this could be executed outside + var heap; + if (size === 1) { + heap = HEAP8; + } else if (size === 2) { + heap = HEAP16; + } else if (size === 4) { + heap = HEAP32; + } else { + throw new TypeError("Unknown boolean type size: " + name); + } + return this['fromWireType'](heap[pointer >> shift]); + }, + destructorFunction: null, // This type does not need a destructor + }); + } + + + function ClassHandle_isAliasOf(other) { + if (!(this instanceof ClassHandle)) { + return false; + } + if (!(other instanceof ClassHandle)) { + return false; + } + + var leftClass = this.$$.ptrType.registeredClass; + var left = this.$$.ptr; + var rightClass = other.$$.ptrType.registeredClass; + var right = other.$$.ptr; + + while (leftClass.baseClass) { + left = leftClass.upcast(left); + leftClass = leftClass.baseClass; + } + + while (rightClass.baseClass) { + right = rightClass.upcast(right); + rightClass = rightClass.baseClass; + } + + return leftClass === rightClass && left === right; + } + + function shallowCopyInternalPointer(o) { + return { + count: o.count, + deleteScheduled: o.deleteScheduled, + preservePointerOnDelete: o.preservePointerOnDelete, + ptr: o.ptr, + ptrType: o.ptrType, + smartPtr: o.smartPtr, + smartPtrType: o.smartPtrType, + }; + } + + function throwInstanceAlreadyDeleted(obj) { + function getInstanceTypeName(handle) { + return handle.$$.ptrType.registeredClass.name; + } + throwBindingError(getInstanceTypeName(obj) + ' instance already deleted'); + } + + function ClassHandle_clone() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + + if (this.$$.preservePointerOnDelete) { + this.$$.count.value += 1; + return this; + } else { + var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), { + $$: { + value: shallowCopyInternalPointer(this.$$), + } + })); + + clone.$$.count.value += 1; + clone.$$.deleteScheduled = false; + return clone; + } + } + + + + + function ClassHandle_delete() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError('Object already scheduled for deletion'); + } + + detachFinalizer(this); + releaseClassHandle(this.$$); + + if (!this.$$.preservePointerOnDelete) { + this.$$.smartPtr = undefined; + this.$$.ptr = undefined; + } + } + + function ClassHandle_isDeleted() { + return !this.$$.ptr; + } + + + + function ClassHandle_deleteLater() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError('Object already scheduled for deletion'); + } + deletionQueue.push(this); + if (deletionQueue.length === 1 && delayFunction) { + delayFunction(flushPendingDeletes); + } + this.$$.deleteScheduled = true; + return this; + } + function init_ClassHandle() { + ClassHandle.prototype['isAliasOf'] = ClassHandle_isAliasOf; + ClassHandle.prototype['clone'] = ClassHandle_clone; + ClassHandle.prototype['delete'] = ClassHandle_delete; + ClassHandle.prototype['isDeleted'] = ClassHandle_isDeleted; + ClassHandle.prototype['deleteLater'] = ClassHandle_deleteLater; + } + function ClassHandle() { + } + + + + function ensureOverloadTable(proto, methodName, humanName) { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments. + proto[methodName] = function() { + // TODO This check can be removed in -O3 level "unsafe" optimizations. + if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) { + throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${arguments.length}) - expects one of (${proto[methodName].overloadTable})!`); + } + return proto[methodName].overloadTable[arguments.length].apply(this, arguments); + }; + // Move the previous function into the overload table. + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } + } + + /** @param {number=} numArguments */ + function exposePublicSymbol(name, value, numArguments) { + if (Module.hasOwnProperty(name)) { + if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) { + throwBindingError(`Cannot register public name '${name}' twice`); + } + + // We are exposing a function with the same name as an existing function. Create an overload table and a function selector + // that routes between the two. + ensureOverloadTable(Module, name, name); + if (Module.hasOwnProperty(numArguments)) { + throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`); + } + // Add the new function into the overload table. + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + if (undefined !== numArguments) { + Module[name].numArguments = numArguments; + } + } + } + + + + /** @constructor */ + function RegisteredClass(name, + constructor, + instancePrototype, + rawDestructor, + baseClass, + getActualType, + upcast, + downcast) { + this.name = name; + this.constructor = constructor; + this.instancePrototype = instancePrototype; + this.rawDestructor = rawDestructor; + this.baseClass = baseClass; + this.getActualType = getActualType; + this.upcast = upcast; + this.downcast = downcast; + this.pureVirtualFunctions = []; + } + + + function upcastPointer(ptr, ptrClass, desiredClass) { + while (ptrClass !== desiredClass) { + if (!ptrClass.upcast) { + throwBindingError(`Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`); + } + ptr = ptrClass.upcast(ptr); + ptrClass = ptrClass.baseClass; + } + return ptr; + } + function constNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError(`null is not a valid ${this.name}`); + } + return 0; + } + + if (!handle.$$) { + throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`); + } + if (!handle.$$.ptr) { + throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; + } + + + function genericPointerToWireType(destructors, handle) { + var ptr; + if (handle === null) { + if (this.isReference) { + throwBindingError(`null is not a valid ${this.name}`); + } + + if (this.isSmartPointer) { + ptr = this.rawConstructor(); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + return ptr; + } else { + return 0; + } + } + + if (!handle.$$) { + throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`); + } + if (!handle.$$.ptr) { + throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`); + } + if (!this.isConst && handle.$$.ptrType.isConst) { + throwBindingError(`Cannot convert argument of type ${(handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name)} to parameter type ${this.name}`); + } + var handleClass = handle.$$.ptrType.registeredClass; + ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + + if (this.isSmartPointer) { + // TODO: this is not strictly true + // We could support BY_EMVAL conversions from raw pointers to smart pointers + // because the smart pointer can hold a reference to the handle + if (undefined === handle.$$.smartPtr) { + throwBindingError('Passing raw pointer to smart pointer is illegal'); + } + + switch (this.sharingPolicy) { + case 0: // NONE + // no upcasting + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + throwBindingError(`Cannot convert argument of type ${(handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name)} to parameter type ${this.name}`); + } + break; + + case 1: // INTRUSIVE + ptr = handle.$$.smartPtr; + break; + + case 2: // BY_EMVAL + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + var clonedHandle = handle['clone'](); + ptr = this.rawShare( + ptr, + Emval.toHandle(function() { + clonedHandle['delete'](); + }) + ); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + } + break; + + default: + throwBindingError('Unsupporting sharing policy'); + } + } + return ptr; + } + + + function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError(`null is not a valid ${this.name}`); + } + return 0; + } + + if (!handle.$$) { + throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`); + } + if (!handle.$$.ptr) { + throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`); + } + if (handle.$$.ptrType.isConst) { + throwBindingError(`Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; + } + + + function RegisteredPointer_getPointee(ptr) { + if (this.rawGetPointee) { + ptr = this.rawGetPointee(ptr); + } + return ptr; + } + + function RegisteredPointer_destructor(ptr) { + if (this.rawDestructor) { + this.rawDestructor(ptr); + } + } + + function RegisteredPointer_deleteObject(handle) { + if (handle !== null) { + handle['delete'](); + } + } + + function init_RegisteredPointer() { + RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee; + RegisteredPointer.prototype.destructor = RegisteredPointer_destructor; + RegisteredPointer.prototype['argPackAdvance'] = 8; + RegisteredPointer.prototype['readValueFromPointer'] = simpleReadValueFromPointer; + RegisteredPointer.prototype['deleteObject'] = RegisteredPointer_deleteObject; + RegisteredPointer.prototype['fromWireType'] = RegisteredPointer_fromWireType; + } + /** @constructor + @param {*=} pointeeType, + @param {*=} sharingPolicy, + @param {*=} rawGetPointee, + @param {*=} rawConstructor, + @param {*=} rawShare, + @param {*=} rawDestructor, + */ + function RegisteredPointer( + name, + registeredClass, + isReference, + isConst, + + // smart pointer properties + isSmartPointer, + pointeeType, + sharingPolicy, + rawGetPointee, + rawConstructor, + rawShare, + rawDestructor + ) { + this.name = name; + this.registeredClass = registeredClass; + this.isReference = isReference; + this.isConst = isConst; + + // smart pointer properties + this.isSmartPointer = isSmartPointer; + this.pointeeType = pointeeType; + this.sharingPolicy = sharingPolicy; + this.rawGetPointee = rawGetPointee; + this.rawConstructor = rawConstructor; + this.rawShare = rawShare; + this.rawDestructor = rawDestructor; + + if (!isSmartPointer && registeredClass.baseClass === undefined) { + if (isConst) { + this['toWireType'] = constNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } else { + this['toWireType'] = nonConstNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } + } else { + this['toWireType'] = genericPointerToWireType; + // Here we must leave this.destructorFunction undefined, since whether genericPointerToWireType returns + // a pointer that needs to be freed up is runtime-dependent, and cannot be evaluated at registration time. + // TODO: Create an alternative mechanism that allows removing the use of var destructors = []; array in + // craftInvokerFunction altogether. + } + } + + /** @param {number=} numArguments */ + function replacePublicSymbol(name, value, numArguments) { + if (!Module.hasOwnProperty(name)) { + throwInternalError('Replacing nonexistant public symbol'); + } + // If there's an overload table for this symbol, replace the symbol in the overload table instead. + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + Module[name].argCount = numArguments; + } + } + + + + function dynCallLegacy(sig, ptr, args) { + var f = Module['dynCall_' + sig]; + return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr); + } + + var wasmTableMirror = []; + + function getWasmTableEntry(funcPtr) { + var func = wasmTableMirror[funcPtr]; + if (!func) { + if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1; + wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); + } + return func; + } + + /** @param {Object=} args */ + function dynCall(sig, ptr, args) { + // Without WASM_BIGINT support we cannot directly call function with i64 as + // part of thier signature, so we rely the dynCall functions generated by + // wasm-emscripten-finalize + if (sig.includes('j')) { + return dynCallLegacy(sig, ptr, args); + } + var rtn = getWasmTableEntry(ptr).apply(null, args); + return rtn; + + } + + function getDynCaller(sig, ptr) { + var argCache = []; + return function() { + argCache.length = 0; + Object.assign(argCache, arguments); + return dynCall(sig, ptr, argCache); + }; + } + + + function embind__requireFunction(signature, rawFunction) { + signature = readLatin1String(signature); + + function makeDynCaller() { + if (signature.includes('j')) { + return getDynCaller(signature, rawFunction); + } + return getWasmTableEntry(rawFunction); + } + + var fp = makeDynCaller(); + if (typeof fp != "function") { + throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`); + } + return fp; + } + + + + var UnboundTypeError = undefined; + + function throwUnboundTypeError(message, types) { + var unboundTypes = []; + var seen = {}; + function visit(type) { + if (seen[type]) { + return; + } + if (registeredTypes[type]) { + return; + } + if (typeDependencies[type]) { + typeDependencies[type].forEach(visit); + return; + } + unboundTypes.push(type); + seen[type] = true; + } + types.forEach(visit); + + throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([', '])); + } + + function __embind_register_class(rawType, + rawPointerType, + rawConstPointerType, + baseClassRawType, + getActualTypeSignature, + getActualType, + upcastSignature, + upcast, + downcastSignature, + downcast, + name, + destructorSignature, + rawDestructor) { + name = readLatin1String(name); + getActualType = embind__requireFunction(getActualTypeSignature, getActualType); + if (upcast) { + upcast = embind__requireFunction(upcastSignature, upcast); + } + if (downcast) { + downcast = embind__requireFunction(downcastSignature, downcast); + } + rawDestructor = embind__requireFunction(destructorSignature, rawDestructor); + var legalFunctionName = makeLegalFunctionName(name); + + exposePublicSymbol(legalFunctionName, function() { + // this code cannot run if baseClassRawType is zero + throwUnboundTypeError(`Cannot construct ${name} due to unbound types`, [baseClassRawType]); + }); + + whenDependentTypesAreResolved( + [rawType, rawPointerType, rawConstPointerType], + baseClassRawType ? [baseClassRawType] : [], + function(base) { + base = base[0]; + + var baseClass; + var basePrototype; + if (baseClassRawType) { + baseClass = base.registeredClass; + basePrototype = baseClass.instancePrototype; + } else { + basePrototype = ClassHandle.prototype; + } + + var constructor = createNamedFunction(legalFunctionName, function() { + if (Object.getPrototypeOf(this) !== instancePrototype) { + throw new BindingError("Use 'new' to construct " + name); + } + if (undefined === registeredClass.constructor_body) { + throw new BindingError(name + " has no accessible constructor"); + } + var body = registeredClass.constructor_body[arguments.length]; + if (undefined === body) { + throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${arguments.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`); + } + return body.apply(this, arguments); + }); + + var instancePrototype = Object.create(basePrototype, { + constructor: { value: constructor }, + }); + + constructor.prototype = instancePrototype; + + var registeredClass = new RegisteredClass(name, + constructor, + instancePrototype, + rawDestructor, + baseClass, + getActualType, + upcast, + downcast); + + if (registeredClass.baseClass) { + // Keep track of class hierarchy. Used to allow sub-classes to inherit class functions. + if (registeredClass.baseClass.__derivedClasses === undefined) { + registeredClass.baseClass.__derivedClasses = []; + } + + registeredClass.baseClass.__derivedClasses.push(registeredClass); + } + + var referenceConverter = new RegisteredPointer(name, + registeredClass, + true, + false, + false); + + var pointerConverter = new RegisteredPointer(name + '*', + registeredClass, + false, + false, + false); + + var constPointerConverter = new RegisteredPointer(name + ' const*', + registeredClass, + false, + true, + false); + + registeredPointers[rawType] = { + pointerType: pointerConverter, + constPointerType: constPointerConverter + }; + + replacePublicSymbol(legalFunctionName, constructor); + + return [referenceConverter, pointerConverter, constPointerConverter]; + } + ); + } + + + + function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, /** boolean= */ isAsync) { + // humanName: a human-readable string name for the function to be generated. + // argTypes: An array that contains the embind type objects for all types in the function signature. + // argTypes[0] is the type object for the function return value. + // argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method. + // argTypes[2...] are the actual function parameters. + // classType: The embind type object for the class to be bound, or null if this is not a method of a class. + // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code. + // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling. + // isAsync: Optional. If true, returns an async function. Async bindings are only supported with JSPI. + var argCount = argTypes.length; + + if (argCount < 2) { + throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!"); + } + + var isClassMethodFunc = (argTypes[1] !== null && classType !== null); + + // Free functions with signature "void function()" do not need an invoker that marshalls between wire types. + // TODO: This omits argument count check - enable only at -O3 or similar. + // if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) { + // return FUNCTION_TABLE[fn]; + // } + + // Determine if we need to use a dynamic stack to store the destructors for the function parameters. + // TODO: Remove this completely once all function invokers are being dynamically generated. + var needsDestructorStack = false; + + for (var i = 1; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { // The type does not define a destructor function - must use dynamic stack + needsDestructorStack = true; + break; + } + } + + var returns = (argTypes[0].name !== "void"); + + var expectedArgCount = argCount - 2; + var argsWired = new Array(expectedArgCount); + var invokerFuncArgs = []; + var destructors = []; + return function() { + if (arguments.length !== expectedArgCount) { + throwBindingError(`function ${humanName} called with ${arguments.length} arguments, expected ${expectedArgCount} args!`); + } + destructors.length = 0; + var thisWired; + invokerFuncArgs.length = isClassMethodFunc ? 2 : 1; + invokerFuncArgs[0] = cppTargetFunc; + if (isClassMethodFunc) { + thisWired = argTypes[1]['toWireType'](destructors, this); + invokerFuncArgs[1] = thisWired; + } + for (var i = 0; i < expectedArgCount; ++i) { + argsWired[i] = argTypes[i + 2]['toWireType'](destructors, arguments[i]); + invokerFuncArgs.push(argsWired[i]); + } + + var rv = cppInvokerFunc.apply(null, invokerFuncArgs); + + function onDone(rv) { + if (needsDestructorStack) { + runDestructors(destructors); + } else { + for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; i++) { + var param = i === 1 ? thisWired : argsWired[i - 2]; + if (argTypes[i].destructorFunction !== null) { + argTypes[i].destructorFunction(param); + } + } + } + + if (returns) { + return argTypes[0]['fromWireType'](rv); + } + } + + return onDone(rv); + }; + } + + + function heap32VectorToArray(count, firstElement) { + var array = []; + for (var i = 0; i < count; i++) { + // TODO(https://github.com/emscripten-core/emscripten/issues/17310): + // Find a way to hoist the `>> 2` or `>> 3` out of this loop. + array.push(HEAPU32[(((firstElement)+(i * 4))>>2)]); + } + return array; + } + + + + + function __embind_register_class_class_function(rawClassType, + methodName, + argCount, + rawArgTypesAddr, + invokerSignature, + rawInvoker, + fn, + isAsync) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = `${classType.name}.${methodName}`; + + function unboundTypesHandler() { + throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`, rawArgTypes); + } + + if (methodName.startsWith("@@")) { + methodName = Symbol[methodName.substring(2)]; + } + + var proto = classType.registeredClass.constructor; + if (undefined === proto[methodName]) { + // This is the first function to be registered with this name. + unboundTypesHandler.argCount = argCount-1; + proto[methodName] = unboundTypesHandler; + } else { + // There was an existing function with the same name registered. Set up + // a function overload routing table. + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount-1] = unboundTypesHandler; + } + + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + // Replace the initial unbound-types-handler stub with the proper + // function. If multiple overloads are registered, the function handlers + // go into an overload table. + var invokerArgsArray = [argTypes[0] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */); + var func = craftInvokerFunction(humanName, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn, isAsync); + if (undefined === proto[methodName].overloadTable) { + func.argCount = argCount-1; + proto[methodName] = func; + } else { + proto[methodName].overloadTable[argCount-1] = func; + } + + if (classType.registeredClass.__derivedClasses) { + for (const derivedClass of classType.registeredClass.__derivedClasses) { + if (!derivedClass.constructor.hasOwnProperty(methodName)) { + // TODO: Add support for overloads + derivedClass.constructor[methodName] = func; + } + } + } + + return []; + }); + return []; + }); + } + + + + + + + + function __embind_register_class_constructor( + rawClassType, + argCount, + rawArgTypesAddr, + invokerSignature, + invoker, + rawConstructor + ) { + assert(argCount > 0); + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + invoker = embind__requireFunction(invokerSignature, invoker); + var args = [rawConstructor]; + var destructors = []; + + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = `constructor ${classType.name}`; + + if (undefined === classType.registeredClass.constructor_body) { + classType.registeredClass.constructor_body = []; + } + if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) { + throw new BindingError(`Cannot register multiple constructors with identical number of parameters (${argCount-1}) for class '${classType.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`); + } + classType.registeredClass.constructor_body[argCount - 1] = () => { + throwUnboundTypeError(`Cannot construct ${classType.name} due to unbound types`, rawArgTypes); + }; + + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + // Insert empty slot for context type (argTypes[1]). + argTypes.splice(1, 0, null); + classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor); + return []; + }); + return []; + }); + } + + + + + + + function __embind_register_class_function(rawClassType, + methodName, + argCount, + rawArgTypesAddr, // [ReturnType, ThisType, Args...] + invokerSignature, + rawInvoker, + context, + isPureVirtual, + isAsync) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = `${classType.name}.${methodName}`; + + if (methodName.startsWith("@@")) { + methodName = Symbol[methodName.substring(2)]; + } + + if (isPureVirtual) { + classType.registeredClass.pureVirtualFunctions.push(methodName); + } + + function unboundTypesHandler() { + throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`, rawArgTypes); + } + + var proto = classType.registeredClass.instancePrototype; + var method = proto[methodName]; + if (undefined === method || (undefined === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2)) { + // This is the first overload to be registered, OR we are replacing a + // function in the base class with a function in the derived class. + unboundTypesHandler.argCount = argCount - 2; + unboundTypesHandler.className = classType.name; + proto[methodName] = unboundTypesHandler; + } else { + // There was an existing function with the same name registered. Set up + // a function overload routing table. + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler; + } + + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context, isAsync); + + // Replace the initial unbound-handler-stub function with the appropriate member function, now that all types + // are resolved. If multiple overloads are registered for this function, the function goes into an overload table. + if (undefined === proto[methodName].overloadTable) { + // Set argCount in case an overload is registered later + memberFunction.argCount = argCount - 2; + proto[methodName] = memberFunction; + } else { + proto[methodName].overloadTable[argCount - 2] = memberFunction; + } + + return []; + }); + return []; + }); + } + + + + + + + + + function validateThis(this_, classType, humanName) { + if (!(this_ instanceof Object)) { + throwBindingError(`${humanName} with invalid "this": ${this_}`); + } + if (!(this_ instanceof classType.registeredClass.constructor)) { + throwBindingError(`${humanName} incompatible with "this" of type ${this_.constructor.name}`); + } + if (!this_.$$.ptr) { + throwBindingError(`cannot call emscripten binding method ${humanName} on deleted object`); + } + + // todo: kill this + return upcastPointer(this_.$$.ptr, + this_.$$.ptrType.registeredClass, + classType.registeredClass); + } + function __embind_register_class_property(classType, + fieldName, + getterReturnType, + getterSignature, + getter, + getterContext, + setterArgumentType, + setterSignature, + setter, + setterContext) { + fieldName = readLatin1String(fieldName); + getter = embind__requireFunction(getterSignature, getter); + + whenDependentTypesAreResolved([], [classType], function(classType) { + classType = classType[0]; + var humanName = `${classType.name}.${fieldName}`; + var desc = { + get: function() { + throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`, [getterReturnType, setterArgumentType]); + }, + enumerable: true, + configurable: true + }; + if (setter) { + desc.set = () => { + throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`, [getterReturnType, setterArgumentType]); + }; + } else { + desc.set = (v) => { + throwBindingError(humanName + ' is a read-only property'); + }; + } + + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + + whenDependentTypesAreResolved( + [], + (setter ? [getterReturnType, setterArgumentType] : [getterReturnType]), + function(types) { + var getterReturnType = types[0]; + var desc = { + get: function() { + var ptr = validateThis(this, classType, humanName + ' getter'); + return getterReturnType['fromWireType'](getter(getterContext, ptr)); + }, + enumerable: true + }; + + if (setter) { + setter = embind__requireFunction(setterSignature, setter); + var setterArgumentType = types[1]; + desc.set = function(v) { + var ptr = validateThis(this, classType, humanName + ' setter'); + var destructors = []; + setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, v)); + runDestructors(destructors); + }; + } + + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + return []; + }); + + return []; + }); + } + + + function __embind_register_constant(name, type, value) { + name = readLatin1String(name); + whenDependentTypesAreResolved([], [type], function(type) { + type = type[0]; + Module[name] = type['fromWireType'](value); + return []; + }); + } + + function __emval_decref(handle) { + if (handle >= emval_handles.reserved && 0 === --emval_handles.get(handle).refcount) { + emval_handles.free(handle); + } + } + + + + + function __embind_register_emval(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(handle) { + var rv = Emval.toValue(handle); + __emval_decref(handle); + return rv; + }, + 'toWireType': function(destructors, value) { + return Emval.toHandle(value); + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: null, // This type does not need a destructor + + // TODO: do we need a deleteObject here? write a test where + // emval is passed into JS via an interface + }); + } + + + + function enumReadValueFromPointer(name, shift, signed) { + switch (shift) { + case 0: return function(pointer) { + var heap = signed ? HEAP8 : HEAPU8; + return this['fromWireType'](heap[pointer]); + }; + case 1: return function(pointer) { + var heap = signed ? HEAP16 : HEAPU16; + return this['fromWireType'](heap[pointer >> 1]); + }; + case 2: return function(pointer) { + var heap = signed ? HEAP32 : HEAPU32; + return this['fromWireType'](heap[pointer >> 2]); + }; + default: + throw new TypeError("Unknown integer type: " + name); + } + } + + + function __embind_register_enum(rawType, name, size, isSigned) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + + function ctor() {} + ctor.values = {}; + + registerType(rawType, { + name: name, + constructor: ctor, + 'fromWireType': function(c) { + return this.constructor.values[c]; + }, + 'toWireType': function(destructors, c) { + return c.value; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': enumReadValueFromPointer(name, shift, isSigned), + destructorFunction: null, + }); + exposePublicSymbol(name, ctor); + } + + + + function __embind_register_enum_value(rawEnumType, name, enumValue) { + var enumType = requireRegisteredType(rawEnumType, 'enum'); + name = readLatin1String(name); + + var Enum = enumType.constructor; + + var Value = Object.create(enumType.constructor.prototype, { + value: {value: enumValue}, + constructor: {value: createNamedFunction(`${enumType.name}_${name}`, function() {})}, + }); + Enum.values[enumValue] = Value; + Enum[name] = Value; + } + + function embindRepr(v) { + if (v === null) { + return 'null'; + } + var t = typeof v; + if (t === 'object' || t === 'array' || t === 'function') { + return v.toString(); + } else { + return '' + v; + } + } + + function floatReadValueFromPointer(name, shift) { + switch (shift) { + case 2: return function(pointer) { + return this['fromWireType'](HEAPF32[pointer >> 2]); + }; + case 3: return function(pointer) { + return this['fromWireType'](HEAPF64[pointer >> 3]); + }; + default: + throw new TypeError("Unknown float type: " + name); + } + } + + + + function __embind_register_float(rawType, name, size) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + return value; + }, + 'toWireType': function(destructors, value) { + // The VM will perform JS to Wasm value conversion, according to the spec: + // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue + return value; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': floatReadValueFromPointer(name, shift), + destructorFunction: null, // This type does not need a destructor + }); + } + + + + + + + + + function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync) { + var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + name = readLatin1String(name); + + rawInvoker = embind__requireFunction(signature, rawInvoker); + + exposePublicSymbol(name, function() { + throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes); + }, argCount - 1); + + whenDependentTypesAreResolved([], argTypes, function(argTypes) { + var invokerArgsArray = [argTypes[0] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */); + replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn, isAsync), argCount - 1); + return []; + }); + } + + + + function integerReadValueFromPointer(name, shift, signed) { + // integers are quite common, so generate very specialized functions + switch (shift) { + case 0: return signed ? + function readS8FromPointer(pointer) { return HEAP8[pointer]; } : + function readU8FromPointer(pointer) { return HEAPU8[pointer]; }; + case 1: return signed ? + function readS16FromPointer(pointer) { return HEAP16[pointer >> 1]; } : + function readU16FromPointer(pointer) { return HEAPU16[pointer >> 1]; }; + case 2: return signed ? + function readS32FromPointer(pointer) { return HEAP32[pointer >> 2]; } : + function readU32FromPointer(pointer) { return HEAPU32[pointer >> 2]; }; + default: + throw new TypeError("Unknown integer type: " + name); + } + } + + + function __embind_register_integer(primitiveType, name, size, minRange, maxRange) { + name = readLatin1String(name); + // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come + // out as 'i32 -1'. Always treat those as max u32. + if (maxRange === -1) { + maxRange = 4294967295; + } + + var shift = getShiftFromSize(size); + + var fromWireType = (value) => value; + + if (minRange === 0) { + var bitshift = 32 - 8*size; + fromWireType = (value) => (value << bitshift) >>> bitshift; + } + + var isUnsignedType = (name.includes('unsigned')); + var checkAssertions = (value, toTypeName) => { + } + var toWireType; + if (isUnsignedType) { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + return value >>> 0; + } + } else { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + // The VM will perform JS to Wasm value conversion, according to the spec: + // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue + return value; + } + } + registerType(primitiveType, { + name: name, + 'fromWireType': fromWireType, + 'toWireType': toWireType, + 'argPackAdvance': 8, + 'readValueFromPointer': integerReadValueFromPointer(name, shift, minRange !== 0), + destructorFunction: null, // This type does not need a destructor + }); + } + + + function __embind_register_memory_view(rawType, dataTypeIndex, name) { + var typeMapping = [ + Int8Array, + Uint8Array, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float32Array, + Float64Array, + ]; + + var TA = typeMapping[dataTypeIndex]; + + function decodeMemoryView(handle) { + handle = handle >> 2; + var heap = HEAPU32; + var size = heap[handle]; // in elements + var data = heap[handle + 1]; // byte offset into emscripten heap + return new TA(heap.buffer, data, size); + } + + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': decodeMemoryView, + 'argPackAdvance': 8, + 'readValueFromPointer': decodeMemoryView, + }, { + ignoreDuplicateRegistrations: true, + }); + } + + + + + + function stringToUTF8(str, outPtr, maxBytesToWrite) { + return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite); + } + + + + + function __embind_register_std_string(rawType, name) { + name = readLatin1String(name); + var stdStringIsUTF8 + //process only std::string bindings with UTF8 support, in contrast to e.g. std::basic_string + = (name === "std::string"); + + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + var length = HEAPU32[((value)>>2)]; + var payload = value + 4; + + var str; + if (stdStringIsUTF8) { + var decodeStartPtr = payload; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = payload + i; + if (i == length || HEAPU8[currentBytePtr] == 0) { + var maxRead = currentBytePtr - decodeStartPtr; + var stringSegment = UTF8ToString(decodeStartPtr, maxRead); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + 1; + } + } + } else { + var a = new Array(length); + for (var i = 0; i < length; ++i) { + a[i] = String.fromCharCode(HEAPU8[payload + i]); + } + str = a.join(''); + } + + _free(value); + + return str; + }, + 'toWireType': function(destructors, value) { + if (value instanceof ArrayBuffer) { + value = new Uint8Array(value); + } + + var length; + var valueIsOfTypeString = (typeof value == 'string'); + + if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) { + throwBindingError('Cannot pass non-string to std::string'); + } + if (stdStringIsUTF8 && valueIsOfTypeString) { + length = lengthBytesUTF8(value); + } else { + length = value.length; + } + + // assumes 4-byte alignment + var base = _malloc(4 + length + 1); + var ptr = base + 4; + HEAPU32[((base)>>2)] = length; + if (stdStringIsUTF8 && valueIsOfTypeString) { + stringToUTF8(value, ptr, length + 1); + } else { + if (valueIsOfTypeString) { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(ptr); + throwBindingError('String has UTF-16 code units that do not fit in 8 bits'); + } + HEAPU8[ptr + i] = charCode; + } + } else { + for (var i = 0; i < length; ++i) { + HEAPU8[ptr + i] = value[i]; + } + } + } + + if (destructors !== null) { + destructors.push(_free, base); + } + return base; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: function(ptr) { _free(ptr); }, + }); + } + + + + + var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf-16le') : undefined;; + function UTF16ToString(ptr, maxBytesToRead) { + var endPtr = ptr; + // TextDecoder needs to know the byte length in advance, it doesn't stop on + // null terminator by itself. + // Also, use the length info to avoid running tiny strings through + // TextDecoder, since .subarray() allocates garbage. + var idx = endPtr >> 1; + var maxIdx = idx + maxBytesToRead / 2; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx; + endPtr = idx << 1; + + if (endPtr - ptr > 32 && UTF16Decoder) + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + + // Fallback: decode without UTF16Decoder + var str = ''; + + // If maxBytesToRead is not passed explicitly, it will be undefined, and the + // for-loop's condition will always evaluate to true. The loop is then + // terminated on the first null char. + for (var i = 0; !(i >= maxBytesToRead / 2); ++i) { + var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; + if (codeUnit == 0) break; + // fromCharCode constructs a character from a UTF-16 code unit, so we can + // pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + + return str; + } + + function stringToUTF16(str, outPtr, maxBytesToWrite) { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + HEAP16[((outPtr)>>1)] = codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr)>>1)] = 0; + return outPtr - startPtr; + } + + function lengthBytesUTF16(str) { + return str.length*2; + } + + function UTF32ToString(ptr, maxBytesToRead) { + var i = 0; + + var str = ''; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(i >= maxBytesToRead / 4)) { + var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; + if (utf32 == 0) break; + ++i; + // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + if (utf32 >= 0x10000) { + var ch = utf32 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } else { + str += String.fromCharCode(utf32); + } + } + return str; + } + + function stringToUTF32(str, outPtr, maxBytesToWrite) { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); + } + HEAP32[((outPtr)>>2)] = codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr)>>2)] = 0; + return outPtr - startPtr; + } + + function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. + len += 4; + } + + return len; + } + function __embind_register_std_wstring(rawType, charSize, name) { + name = readLatin1String(name); + var decodeString, encodeString, getHeap, lengthBytesUTF, shift; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + getHeap = () => HEAPU16; + shift = 1; + } else if (charSize === 4) { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + getHeap = () => HEAPU32; + shift = 2; + } + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + // Code mostly taken from _embind_register_std_string fromWireType + var length = HEAPU32[value >> 2]; + var HEAP = getHeap(); + var str; + + var decodeStartPtr = value + 4; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (i == length || HEAP[currentBytePtr >> shift] == 0) { + var maxReadBytes = currentBytePtr - decodeStartPtr; + var stringSegment = decodeString(decodeStartPtr, maxReadBytes); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + charSize; + } + } + + _free(value); + + return str; + }, + 'toWireType': function(destructors, value) { + if (!(typeof value == 'string')) { + throwBindingError(`Cannot pass non-string to C++ string type ${name}`); + } + + // assumes 4-byte alignment + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + HEAPU32[ptr >> 2] = length >> shift; + + encodeString(value, ptr + 4, length + charSize); + + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: function(ptr) { _free(ptr); }, + }); + } + + + + function __embind_register_value_object( + rawType, + name, + constructorSignature, + rawConstructor, + destructorSignature, + rawDestructor + ) { + structRegistrations[rawType] = { + name: readLatin1String(name), + rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), + rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), + fields: [], + }; + } + + + + function __embind_register_value_object_field( + structType, + fieldName, + getterReturnType, + getterSignature, + getter, + getterContext, + setterArgumentType, + setterSignature, + setter, + setterContext + ) { + structRegistrations[structType].fields.push({ + fieldName: readLatin1String(fieldName), + getterReturnType: getterReturnType, + getter: embind__requireFunction(getterSignature, getter), + getterContext: getterContext, + setterArgumentType: setterArgumentType, + setter: embind__requireFunction(setterSignature, setter), + setterContext: setterContext, + }); + } + + + function __embind_register_void(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + isVoid: true, // void return values can be optimized out sometimes + name: name, + 'argPackAdvance': 0, + 'fromWireType': function() { + return undefined; + }, + 'toWireType': function(destructors, o) { + // TODO: assert if anything else is given? + return undefined; + }, + }); + } + + function emval_allocateDestructors(destructorsRef) { + var destructors = []; + HEAPU32[((destructorsRef)>>2)] = Emval.toHandle(destructors); + return destructors; + } + + var emval_symbols = {}; + + function getStringOrSymbol(address) { + var symbol = emval_symbols[address]; + if (symbol === undefined) { + return readLatin1String(address); + } + return symbol; + } + + var emval_methodCallers = []; + + function __emval_call_method(caller, handle, methodName, destructorsRef, args) { + caller = emval_methodCallers[caller]; + handle = Emval.toValue(handle); + methodName = getStringOrSymbol(methodName); + return caller(handle, methodName, emval_allocateDestructors(destructorsRef), args); + } + + + + + function __emval_call_void_method(caller, handle, methodName, args) { + caller = emval_methodCallers[caller]; + handle = Emval.toValue(handle); + methodName = getStringOrSymbol(methodName); + caller(handle, methodName, null, args); + } + + + function emval_addMethodCaller(caller) { + var id = emval_methodCallers.length; + emval_methodCallers.push(caller); + return id; + } + + function emval_lookupTypes(argCount, argTypes) { + var a = new Array(argCount); + for (var i = 0; i < argCount; ++i) { + a[i] = requireRegisteredType(HEAPU32[(((argTypes)+(i * 4))>>2)], + "parameter " + i); + } + return a; + } + + + var emval_registeredMethods = []; + function __emval_get_method_caller(argCount, argTypes) { + var types = emval_lookupTypes(argCount, argTypes); + var retType = types[0]; + var signatureName = retType.name + "_$" + types.slice(1).map(function (t) { return t.name; }).join("_") + "$"; + var returnId = emval_registeredMethods[signatureName]; + if (returnId !== undefined) { + return returnId; + } + + var argN = new Array(argCount - 1); + var invokerFunction = (handle, name, destructors, args) => { + var offset = 0; + for (var i = 0; i < argCount - 1; ++i) { + argN[i] = types[i + 1]['readValueFromPointer'](args + offset); + offset += types[i + 1]['argPackAdvance']; + } + var rv = handle[name].apply(handle, argN); + for (var i = 0; i < argCount - 1; ++i) { + if (types[i + 1].deleteObject) { + types[i + 1].deleteObject(argN[i]); + } + } + if (!retType.isVoid) { + return retType['toWireType'](destructors, rv); + } + }; + returnId = emval_addMethodCaller(invokerFunction); + emval_registeredMethods[signatureName] = returnId; + return returnId; + } + + function __emval_incref(handle) { + if (handle > 4) { + emval_handles.get(handle).refcount += 1; + } + } + + + + function __emval_run_destructors(handle) { + var destructors = Emval.toValue(handle); + runDestructors(destructors); + __emval_decref(handle); + } + + + function __emval_take_value(type, arg) { + type = requireRegisteredType(type, '_emval_take_value'); + var v = type['readValueFromPointer'](arg); + return Emval.toHandle(v); + } + + function _abort() { + abort(''); + } + + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.copyWithin(dest, src, src + num); + } + + function getHeapMax() { + // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate + // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side + // for any code that deals with heap sizes, which would require special + // casing all heap size related code to treat 0 specially. + return 2147483648; + } + + function emscripten_realloc_buffer(size) { + var b = wasmMemory.buffer; + var pages = (size - b.byteLength + 65535) >>> 16; + try { + // round size grow request up to wasm page size (fixed 64KB per spec) + wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size + updateMemoryViews(); + return 1 /*success*/; + } catch(e) { + } + // implicit 0 return to save code size (caller will cast "undefined" into 0 + // anyhow) + } + function _emscripten_resize_heap(requestedSize) { + var oldSize = HEAPU8.length; + requestedSize = requestedSize >>> 0; + // With multithreaded builds, races can happen (another thread might increase the size + // in between), so return a failure, and let the caller retry. + + // Memory resize rules: + // 1. Always increase heap size to at least the requested size, rounded up + // to next page multiple. + // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap + // geometrically: increase the heap size according to + // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most + // overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB). + // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap + // linearly: increase the heap size by at least + // MEMORY_GROWTH_LINEAR_STEP bytes. + // 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by + // MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest + // 4. If we were unable to allocate as much memory, it may be due to + // over-eager decision to excessively reserve due to (3) above. + // Hence if an allocation fails, cut down on the amount of excess + // growth, in an attempt to succeed to perform a smaller allocation. + + // A limit is set for how much we can grow. We should not exceed that + // (the wasm binary specifies it, so if we tried, we'd fail anyhow). + var maxHeapSize = getHeapMax(); + if (requestedSize > maxHeapSize) { + return false; + } + + var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple; + + // Loop through potential heap size increases. If we attempt a too eager + // reservation that fails, cut down on the attempted size and reserve a + // smaller bump instead. (max 3 times, chosen somewhat arbitrarily) + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth + // but limit overreserving (default to capping at +96MB overgrowth at most) + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 ); + + var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536)); + + var replacement = emscripten_realloc_buffer(newSize); + if (replacement) { + + return true; + } + } + return false; + } + + function _fd_close(fd) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + FS.close(stream); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return e.errno; + } + } + + /** @param {number=} offset */ + function doReadv(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + var curr = FS.read(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; // nothing more to read + if (typeof offset !== 'undefined') { + offset += curr; + } + } + return ret; + } + + function _fd_read(fd, iov, iovcnt, pnum) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doReadv(stream, iov, iovcnt); + HEAPU32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return e.errno; + } + } + + function convertI32PairToI53Checked(lo, hi) { + return ((hi + 0x200000) >>> 0 < 0x400001 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN; + } + + + + + function _fd_seek(fd, offset_low, offset_high, whence, newOffset) { + try { + + var offset = convertI32PairToI53Checked(offset_low, offset_high); if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd); + FS.llseek(stream, offset, whence); + (tempI64 = [stream.position>>>0,(tempDouble=stream.position,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[((newOffset)>>2)] = tempI64[0],HEAP32[(((newOffset)+(4))>>2)] = tempI64[1]); + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return e.errno; + } + } + + /** @param {number=} offset */ + function doWritev(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + var curr = FS.write(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (typeof offset !== 'undefined') { + offset += curr; + } + } + return ret; + } + + function _fd_write(fd, iov, iovcnt, pnum) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doWritev(stream, iov, iovcnt); + HEAPU32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return e.errno; + } + } + + var FSNode = /** @constructor */ function(parent, name, mode, rdev) { + if (!parent) { + parent = this; // root node sets parent to itself + } + 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; + }; + var readMode = 292/*292*/ | 73/*73*/; + var writeMode = 146/*146*/; + Object.defineProperties(FSNode.prototype, { + read: { + get: /** @this{FSNode} */function() { + return (this.mode & readMode) === readMode; + }, + set: /** @this{FSNode} */function(val) { + val ? this.mode |= readMode : this.mode &= ~readMode; + } + }, + write: { + get: /** @this{FSNode} */function() { + return (this.mode & writeMode) === writeMode; + }, + set: /** @this{FSNode} */function(val) { + val ? this.mode |= writeMode : this.mode &= ~writeMode; + } + }, + isFolder: { + get: /** @this{FSNode} */function() { + return FS.isDir(this.mode); + } + }, + isDevice: { + get: /** @this{FSNode} */function() { + return FS.isChrdev(this.mode); + } + } + }); + FS.FSNode = FSNode; + FS.createPreloadedFile = FS_createPreloadedFile; + FS.staticInit();; +BindingError = Module['BindingError'] = extendError(Error, 'BindingError');; +init_emval();; +PureVirtualError = Module['PureVirtualError'] = extendError(Error, 'PureVirtualError');; +embind_init_charCodes(); +init_embind();; +InternalError = Module['InternalError'] = extendError(Error, 'InternalError');; +init_ClassHandle(); +init_RegisteredPointer(); +UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');; +// include: base64Utils.js +// Copied from https://github.com/strophe/strophejs/blob/e06d027/src/polyfills.js#L149 + +// This code was written by Tyler Akins and has been placed in the +// public domain. It would be nice if you left this header intact. +// Base64 code from Tyler Akins -- http://rumkin.com + +/** + * Decodes a base64 string. + * @param {string} input The string to decode. + */ +var decodeBase64 = typeof atob == 'function' ? atob : function (input) { + var keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='; + + var output = ''; + var chr1, chr2, chr3; + var enc1, enc2, enc3, enc4; + var i = 0; + // remove all characters that are not A-Z, a-z, 0-9, +, /, or = + input = input.replace(/[^A-Za-z0-9\+\/\=]/g, ''); + do { + enc1 = keyStr.indexOf(input.charAt(i++)); + enc2 = keyStr.indexOf(input.charAt(i++)); + enc3 = keyStr.indexOf(input.charAt(i++)); + enc4 = keyStr.indexOf(input.charAt(i++)); + + chr1 = (enc1 << 2) | (enc2 >> 4); + chr2 = ((enc2 & 15) << 4) | (enc3 >> 2); + chr3 = ((enc3 & 3) << 6) | enc4; + + output = output + String.fromCharCode(chr1); + + if (enc3 !== 64) { + output = output + String.fromCharCode(chr2); + } + if (enc4 !== 64) { + output = output + String.fromCharCode(chr3); + } + } while (i < input.length); + return output; +}; + +// Converts a string of base64 into a byte array. +// Throws error on invalid input. +function intArrayFromBase64(s) { + + try { + var decoded = decodeBase64(s); + var bytes = new Uint8Array(decoded.length); + for (var i = 0 ; i < decoded.length ; ++i) { + bytes[i] = decoded.charCodeAt(i); + } + return bytes; + } catch (_) { + throw new Error('Converting base64 string to bytes failed.'); + } +} + +// If filename is a base64 data URI, parses and returns data (Buffer on node, +// Uint8Array otherwise). If filename is not a base64 data URI, returns undefined. +function tryParseAsDataURI(filename) { + if (!isDataURI(filename)) { + return; + } + + return intArrayFromBase64(filename.slice(dataURIPrefix.length)); +} + + +// end include: base64Utils.js +var wasmImports = { + "__assert_fail": ___assert_fail, + "__syscall_fcntl64": ___syscall_fcntl64, + "__syscall_ioctl": ___syscall_ioctl, + "__syscall_openat": ___syscall_openat, + "_embind_create_inheriting_constructor": __embind_create_inheriting_constructor, + "_embind_finalize_value_object": __embind_finalize_value_object, + "_embind_register_bigint": __embind_register_bigint, + "_embind_register_bool": __embind_register_bool, + "_embind_register_class": __embind_register_class, + "_embind_register_class_class_function": __embind_register_class_class_function, + "_embind_register_class_constructor": __embind_register_class_constructor, + "_embind_register_class_function": __embind_register_class_function, + "_embind_register_class_property": __embind_register_class_property, + "_embind_register_constant": __embind_register_constant, + "_embind_register_emval": __embind_register_emval, + "_embind_register_enum": __embind_register_enum, + "_embind_register_enum_value": __embind_register_enum_value, + "_embind_register_float": __embind_register_float, + "_embind_register_function": __embind_register_function, + "_embind_register_integer": __embind_register_integer, + "_embind_register_memory_view": __embind_register_memory_view, + "_embind_register_std_string": __embind_register_std_string, + "_embind_register_std_wstring": __embind_register_std_wstring, + "_embind_register_value_object": __embind_register_value_object, + "_embind_register_value_object_field": __embind_register_value_object_field, + "_embind_register_void": __embind_register_void, + "_emval_call_method": __emval_call_method, + "_emval_call_void_method": __emval_call_void_method, + "_emval_decref": __emval_decref, + "_emval_get_method_caller": __emval_get_method_caller, + "_emval_incref": __emval_incref, + "_emval_run_destructors": __emval_run_destructors, + "_emval_take_value": __emval_take_value, + "abort": _abort, + "emscripten_memcpy_big": _emscripten_memcpy_big, + "emscripten_resize_heap": _emscripten_resize_heap, + "fd_close": _fd_close, + "fd_read": _fd_read, + "fd_seek": _fd_seek, + "fd_write": _fd_write, + "memory": wasmMemory +}; +var asm = createWasm(); +/** @type {function(...*):?} */ +var ___wasm_call_ctors = function() { + return (___wasm_call_ctors = Module["asm"]["__wasm_call_ctors"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _malloc = function() { + return (_malloc = Module["asm"]["malloc"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _free = function() { + return (_free = Module["asm"]["free"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var ___getTypeName = function() { + return (___getTypeName = Module["asm"]["__getTypeName"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var __embind_initialize_bindings = Module["__embind_initialize_bindings"] = function() { + return (__embind_initialize_bindings = Module["__embind_initialize_bindings"] = Module["asm"]["_embind_initialize_bindings"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var ___errno_location = function() { + return (___errno_location = Module["asm"]["__errno_location"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var stackSave = function() { + return (stackSave = Module["asm"]["stackSave"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var stackRestore = function() { + return (stackRestore = Module["asm"]["stackRestore"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var stackAlloc = function() { + return (stackAlloc = Module["asm"]["stackAlloc"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var dynCall_jiji = Module["dynCall_jiji"] = function() { + return (dynCall_jiji = Module["dynCall_jiji"] = Module["asm"]["dynCall_jiji"]).apply(null, arguments); +}; + + + +// include: postamble.js +// === Auto-generated postamble setup entry stuff === + + + + +var calledRun; + +dependenciesFulfilled = function runCaller() { + // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false) + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled +}; + +function run() { + + if (runDependencies > 0) { + return; + } + + preRun(); + + // a preRun added a dependency, run will be called later + if (runDependencies > 0) { + return; + } + + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + if (calledRun) return; + calledRun = true; + Module['calledRun'] = true; + + if (ABORT) return; + + initRuntime(); + + readyPromiseResolve(Module); + if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); + + postRun(); + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + } else + { + doRun(); + } +} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + +run(); + + +// end include: postamble.js + + + return BOX2D.ready +} + +); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = BOX2D; +else if (typeof define === 'function' && define['amd']) + define([], function() { return BOX2D; }); +else if (typeof exports === 'object') + exports["BOX2D"] = BOX2D; diff --git a/emscripten/box2d/box2d.debug.wasm.js b/emscripten/box2d/box2d.debug.wasm.js new file mode 100644 index 000000000..880f27cde --- /dev/null +++ b/emscripten/box2d/box2d.debug.wasm.js @@ -0,0 +1,4297 @@ + +var BOX2D = (() => { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + + return ( +function(BOX2D = {}) { + +// include: shell.js +// The Module object: Our interface to the outside world. We import +// and export values on it. There are various ways Module can be used: +// 1. Not defined. We create it here +// 2. A function parameter, function(Module) { ..generated code.. } +// 3. pre-run appended it, var Module = {}; ..generated code.. +// 4. External script tag defines var Module. +// We need to check if Module already exists (e.g. case 3 above). +// Substitution will be replaced with actual code on later stage of the build, +// this way Closure Compiler will not mangle it (e.g. case 4. above). +// Note that if you want to run closure, and also to use Module +// after the generated code, you will need to define var Module = {}; +// before the code. Then that object will be used in the code, and you +// can continue to use Module afterwards as well. +var Module = typeof BOX2D != 'undefined' ? BOX2D : {}; + +// Set up the promise that indicates the Module is initialized +var readyPromiseResolve, readyPromiseReject; +Module['ready'] = new Promise((resolve, reject) => { + readyPromiseResolve = resolve; + readyPromiseReject = reject; +}); +["_main","__embind_initialize_bindings","_fflush","onRuntimeInitialized"].forEach((prop) => { + if (!Object.getOwnPropertyDescriptor(Module['ready'], prop)) { + Object.defineProperty(Module['ready'], prop, { + get: () => abort('You are getting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'), + set: () => abort('You are setting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'), + }); + } +}); + +// --pre-jses are emitted after the Module integration code, so that they can +// refer to Module (if they choose; they can also define Module) + + +// Sometimes an existing Module object exists with properties +// meant to overwrite the default module functionality. Here +// we collect those properties and reapply _after_ we configure +// the current environment's defaults to avoid having to be so +// defensive during initialization. +var moduleOverrides = Object.assign({}, Module); + +var arguments_ = []; +var thisProgram = './this.program'; +var quit_ = (status, toThrow) => { + throw toThrow; +}; + +// Determine the runtime environment we are in. You can customize this by +// setting the ENVIRONMENT setting at compile time (see settings.js). + +var ENVIRONMENT_IS_WEB = true; +var ENVIRONMENT_IS_WORKER = false; +var ENVIRONMENT_IS_NODE = false; +var ENVIRONMENT_IS_SHELL = false; + +if (Module['ENVIRONMENT']) { + throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)'); +} + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ''; +function locateFile(path) { + if (Module['locateFile']) { + return Module['locateFile'](path, scriptDirectory); + } + return scriptDirectory + path; +} + +// Hooks that are implemented differently in different runtime environments. +var read_, + readAsync, + readBinary, + setWindowTitle; + +if (ENVIRONMENT_IS_SHELL) { + + if ((typeof process == 'object' && typeof require === 'function') || typeof window == 'object' || typeof importScripts == 'function') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + + if (typeof read != 'undefined') { + read_ = (f) => { + return read(f); + }; + } + + readBinary = (f) => { + let data; + if (typeof readbuffer == 'function') { + return new Uint8Array(readbuffer(f)); + } + data = read(f, 'binary'); + assert(typeof data == 'object'); + return data; + }; + + readAsync = (f, onload, onerror) => { + setTimeout(() => onload(readBinary(f)), 0); + }; + + if (typeof clearTimeout == 'undefined') { + globalThis.clearTimeout = (id) => {}; + } + + if (typeof scriptArgs != 'undefined') { + arguments_ = scriptArgs; + } else if (typeof arguments != 'undefined') { + arguments_ = arguments; + } + + if (typeof quit == 'function') { + quit_ = (status, toThrow) => { + // Unlike node which has process.exitCode, d8 has no such mechanism. So we + // have no way to set the exit code and then let the program exit with + // that code when it naturally stops running (say, when all setTimeouts + // have completed). For that reason, we must call `quit` - the only way to + // set the exit code - but quit also halts immediately. To increase + // consistency with node (and the web) we schedule the actual quit call + // using a setTimeout to give the current stack and any exception handlers + // a chance to run. This enables features such as addOnPostRun (which + // expected to be able to run code after main returns). + setTimeout(() => { + if (!(toThrow instanceof ExitStatus)) { + let toLog = toThrow; + if (toThrow && typeof toThrow == 'object' && toThrow.stack) { + toLog = [toThrow, toThrow.stack]; + } + err(`exiting due to exception: ${toLog}`); + } + quit(status); + }); + throw toThrow; + }; + } + + if (typeof print != 'undefined') { + // Prefer to use print/printErr where they exist, as they usually work better. + if (typeof console == 'undefined') console = /** @type{!Console} */({}); + console.log = /** @type{!function(this:Console, ...*): undefined} */ (print); + console.warn = console.error = /** @type{!function(this:Console, ...*): undefined} */ (typeof printErr != 'undefined' ? printErr : print); + } + +} else + +// Note that this includes Node.js workers when relevant (pthreads is enabled). +// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and +// ENVIRONMENT_IS_NODE. +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled + scriptDirectory = self.location.href; + } else if (typeof document != 'undefined' && document.currentScript) { // web + scriptDirectory = document.currentScript.src; + } + // When MODULARIZE, this JS may be executed later, after document.currentScript + // is gone, so we saved it, and we use it here instead of any other info. + if (_scriptDir) { + scriptDirectory = _scriptDir; + } + // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. + // otherwise, slice off the final part of the url to find the script directory. + // if scriptDirectory does not contain a slash, lastIndexOf will return -1, + // and scriptDirectory will correctly be replaced with an empty string. + // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #), + // they are removed because they could contain a slash. + if (scriptDirectory.indexOf('blob:') !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf('/')+1); + } else { + scriptDirectory = ''; + } + + if (!(typeof window == 'object' || typeof importScripts == 'function')) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + + // Differentiate the Web Worker from the Node Worker case, as reading must + // be done differently. + { +// include: web_or_worker_shell_read.js +read_ = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + } + + if (ENVIRONMENT_IS_WORKER) { + readBinary = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.responseType = 'arraybuffer'; + xhr.send(null); + return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response)); + }; + } + + readAsync = (url, onload, onerror) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = () => { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + } + +// end include: web_or_worker_shell_read.js + } + + setWindowTitle = (title) => document.title = title; +} else +{ + throw new Error('environment detection error'); +} + +var out = Module['print'] || console.log.bind(console); +var err = Module['printErr'] || console.error.bind(console); + +// Merge back in the overrides +Object.assign(Module, moduleOverrides); +// Free the object hierarchy contained in the overrides, this lets the GC +// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array. +moduleOverrides = null; +checkIncomingModuleAPI(); + +// Emit code to handle expected values on the Module object. This applies Module.x +// to the proper local x. This has two benefits: first, we only emit it if it is +// expected to arrive, and second, by using a local everywhere else that can be +// minified. + +if (Module['arguments']) arguments_ = Module['arguments'];legacyModuleProp('arguments', 'arguments_'); + +if (Module['thisProgram']) thisProgram = Module['thisProgram'];legacyModuleProp('thisProgram', 'thisProgram'); + +if (Module['quit']) quit_ = Module['quit'];legacyModuleProp('quit', 'quit_'); + +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message +// Assertions on removed incoming Module JS APIs. +assert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['read'] == 'undefined', 'Module.read option was removed (modify read_ in JS)'); +assert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)'); +assert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)'); +assert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify setWindowTitle in JS)'); +assert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY'); +legacyModuleProp('read', 'read_'); +legacyModuleProp('readAsync', 'readAsync'); +legacyModuleProp('readBinary', 'readBinary'); +legacyModuleProp('setWindowTitle', 'setWindowTitle'); +var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js'; +var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js'; +var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js'; +var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js'; + +assert(!ENVIRONMENT_IS_WORKER, "worker environment detected but not enabled at build time. Add 'worker' to `-sENVIRONMENT` to enable."); + +assert(!ENVIRONMENT_IS_NODE, "node environment detected but not enabled at build time. Add 'node' to `-sENVIRONMENT` to enable."); + +assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time. Add 'shell' to `-sENVIRONMENT` to enable."); + + +// end include: shell.js +// include: preamble.js +// === Preamble library stuff === + +// Documentation for the public APIs defined in this file must be updated in: +// site/source/docs/api_reference/preamble.js.rst +// A prebuilt local version of the documentation is available at: +// site/build/text/docs/api_reference/preamble.js.txt +// You can also build docs locally as HTML or other formats in site/ +// An online HTML version (which may be of a different version of Emscripten) +// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html + +var wasmBinary; +if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];legacyModuleProp('wasmBinary', 'wasmBinary'); +var noExitRuntime = Module['noExitRuntime'] || true;legacyModuleProp('noExitRuntime', 'noExitRuntime'); + +if (typeof WebAssembly != 'object') { + abort('no native wasm support detected'); +} + +// Wasm globals + +var wasmMemory; + +//======================================== +// Runtime essentials +//======================================== + +// whether we are quitting the application. no code should run after this. +// set in exit() and abort() +var ABORT = false; + +// set by exit() and abort(). Passed to 'onExit' handler. +// NOTE: This is also used as the process return code code in shell environments +// but only when noExitRuntime is false. +var EXITSTATUS; + +/** @type {function(*, string=)} */ +function assert(condition, text) { + if (!condition) { + abort('Assertion failed' + (text ? ': ' + text : '')); + } +} + +// We used to include malloc/free by default in the past. Show a helpful error in +// builds with assertions. + +// Memory management + +var HEAP, +/** @type {!Int8Array} */ + HEAP8, +/** @type {!Uint8Array} */ + HEAPU8, +/** @type {!Int16Array} */ + HEAP16, +/** @type {!Uint16Array} */ + HEAPU16, +/** @type {!Int32Array} */ + HEAP32, +/** @type {!Uint32Array} */ + HEAPU32, +/** @type {!Float32Array} */ + HEAPF32, +/** @type {!Float64Array} */ + HEAPF64; + +function updateMemoryViews() { + var b = wasmMemory.buffer; + Module['HEAP8'] = HEAP8 = new Int8Array(b); + Module['HEAP16'] = HEAP16 = new Int16Array(b); + Module['HEAP32'] = HEAP32 = new Int32Array(b); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(b); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(b); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(b); + Module['HEAPF32'] = HEAPF32 = new Float32Array(b); + Module['HEAPF64'] = HEAPF64 = new Float64Array(b); +} + +assert(!Module['STACK_SIZE'], 'STACK_SIZE can no longer be set at runtime. Use -sSTACK_SIZE at link time') + +assert(typeof Int32Array != 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, + 'JS engine does not provide full typed array support'); + +// If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY +assert(!Module['wasmMemory'], 'Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally'); +assert(!Module['INITIAL_MEMORY'], 'Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically'); + +// include: runtime_init_table.js +// In regular non-RELOCATABLE mode the table is exported +// from the wasm module and this will be assigned once +// the exports are available. +var wasmTable; + +// end include: runtime_init_table.js +// include: runtime_stack_check.js +// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode. +function writeStackCookie() { + var max = _emscripten_stack_get_end(); + assert((max & 3) == 0); + // If the stack ends at address zero we write our cookies 4 bytes into the + // stack. This prevents interference with SAFE_HEAP and ASAN which also + // monitor writes to address zero. + if (max == 0) { + max += 4; + } + // The stack grow downwards towards _emscripten_stack_get_end. + // We write cookies to the final two words in the stack and detect if they are + // ever overwritten. + HEAPU32[((max)>>2)] = 0x02135467; + HEAPU32[(((max)+(4))>>2)] = 0x89BACDFE; + // Also test the global address 0 for integrity. + HEAPU32[((0)>>2)] = 1668509029; +} + +function checkStackCookie() { + if (ABORT) return; + var max = _emscripten_stack_get_end(); + // See writeStackCookie(). + if (max == 0) { + max += 4; + } + var cookie1 = HEAPU32[((max)>>2)]; + var cookie2 = HEAPU32[(((max)+(4))>>2)]; + if (cookie1 != 0x02135467 || cookie2 != 0x89BACDFE) { + abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`); + } + // Also test the global address 0 for integrity. + if (HEAPU32[((0)>>2)] != 0x63736d65 /* 'emsc' */) { + abort('Runtime error: The application has corrupted its heap memory area (address zero)!'); + } +} + +// end include: runtime_stack_check.js +// include: runtime_assertions.js +// Endianness check +(function() { + var h16 = new Int16Array(1); + var h8 = new Int8Array(h16.buffer); + h16[0] = 0x6373; + if (h8[0] !== 0x73 || h8[1] !== 0x63) throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)'; +})(); + +// end include: runtime_assertions.js +var __ATPRERUN__ = []; // functions called before the runtime is initialized +var __ATINIT__ = []; // functions called during startup +var __ATEXIT__ = []; // functions called during shutdown +var __ATPOSTRUN__ = []; // functions called after the main() is called + +var runtimeInitialized = false; + +var runtimeKeepaliveCounter = 0; + +function keepRuntimeAlive() { + return noExitRuntime || runtimeKeepaliveCounter > 0; +} + +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 initRuntime() { + assert(!runtimeInitialized); + runtimeInitialized = true; + + checkStackCookie(); + + + callRuntimeCallbacks(__ATINIT__); +} + +function postRun() { + checkStackCookie(); + + 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); +} + +function addOnInit(cb) { + __ATINIT__.unshift(cb); +} + +function addOnExit(cb) { +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +// include: runtime_math.js +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32 + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc + +assert(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); + +// end include: runtime_math.js +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; +var runDependencyWatcher = null; +var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled +var runDependencyTracking = {}; + +function getUniqueRunDependency(id) { + var orig = id; + while (1) { + if (!runDependencyTracking[id]) return id; + id = orig + Math.random(); + } +} + +function addRunDependency(id) { + runDependencies++; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + + if (id) { + assert(!runDependencyTracking[id]); + runDependencyTracking[id] = 1; + if (runDependencyWatcher === null && typeof setInterval != 'undefined') { + // Check for missing dependencies every few seconds + runDependencyWatcher = setInterval(() => { + if (ABORT) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + return; + } + var shown = false; + for (var dep in runDependencyTracking) { + if (!shown) { + shown = true; + err('still waiting on run dependencies:'); + } + err('dependency: ' + dep); + } + if (shown) { + err('(end of list)'); + } + }, 10000); + } + } else { + err('warning: run dependency added without ID'); + } +} + +function removeRunDependency(id) { + runDependencies--; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + + if (id) { + assert(runDependencyTracking[id]); + delete runDependencyTracking[id]; + } else { + err('warning: run dependency removed without ID'); + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); // can add another dependenciesFulfilled + } + } +} + +/** @param {string|number=} what */ +function abort(what) { + if (Module['onAbort']) { + Module['onAbort'](what); + } + + what = 'Aborted(' + what + ')'; + // TODO(sbc): Should we remove printing and leave it up to whoever + // catches the exception? + err(what); + + ABORT = true; + EXITSTATUS = 1; + + // Use a wasm runtime error, because a JS error might be seen as a foreign + // exception, which means we'd run destructors on it. We need the error to + // simply make the program stop. + // FIXME This approach does not work in Wasm EH because it currently does not assume + // all RuntimeErrors are from traps; it decides whether a RuntimeError is from + // a trap or not based on a hidden field within the object. So at the moment + // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that + // allows this in the wasm spec. + + // Suppress closure compiler warning here. Closure compiler's builtin extern + // defintion for WebAssembly.RuntimeError claims it takes no arguments even + // though it can. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed. + /** @suppress {checkTypes} */ + var e = new WebAssembly.RuntimeError(what); + + readyPromiseReject(e); + // Throw the error whether or not MODULARIZE is set because abort is used + // in code paths apart from instantiation where an exception is expected + // to be thrown when abort is called. + throw e; +} + +// include: memoryprofiler.js +// end include: memoryprofiler.js +// show errors on likely calls to FS when it was not included +var FS = { + error: function() { + abort('Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -sFORCE_FILESYSTEM'); + }, + init: function() { FS.error() }, + createDataFile: function() { FS.error() }, + createPreloadedFile: function() { FS.error() }, + createLazyFile: function() { FS.error() }, + open: function() { FS.error() }, + mkdev: function() { FS.error() }, + registerDevice: function() { FS.error() }, + analyzePath: function() { FS.error() }, + + ErrnoError: function ErrnoError() { FS.error() }, +}; +Module['FS_createDataFile'] = FS.createDataFile; +Module['FS_createPreloadedFile'] = FS.createPreloadedFile; + +// include: URIUtils.js +// Prefix of data URIs emitted by SINGLE_FILE and related options. +var dataURIPrefix = 'data:application/octet-stream;base64,'; + +// Indicates whether filename is a base64 data URI. +function isDataURI(filename) { + // Prefix of data URIs emitted by SINGLE_FILE and related options. + return filename.startsWith(dataURIPrefix); +} + +// Indicates whether filename is delivered via file protocol (as opposed to http/https) +function isFileURI(filename) { + return filename.startsWith('file://'); +} + +// end include: URIUtils.js +/** @param {boolean=} fixedasm */ +function createExportWrapper(name, fixedasm) { + return function() { + var displayName = name; + var asm = fixedasm; + if (!fixedasm) { + asm = Module['asm']; + } + assert(runtimeInitialized, 'native function `' + displayName + '` called before runtime initialization'); + if (!asm[name]) { + assert(asm[name], 'exported native function `' + displayName + '` not found'); + } + return asm[name].apply(null, arguments); + }; +} + +// include: runtime_exceptions.js +// end include: runtime_exceptions.js +var wasmBinaryFile; + wasmBinaryFile = 'box2d.debug.wasm.wasm'; + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); + } + +function getBinary(file) { + try { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } + throw "both async and sync fetching of the wasm failed"; + } + catch (err) { + abort(err); + } +} + +function getBinaryPromise(binaryFile) { + // If we don't have the binary yet, try to load it asynchronously. + // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url. + // See https://github.com/github/fetch/pull/92#issuecomment-140665932 + // Cordova or Electron apps are typically loaded from a file:// url. + // So use fetch if it is available and the url is not a file, otherwise fall back to XHR. + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { + if (typeof fetch == 'function' + ) { + return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => { + if (!response['ok']) { + throw "failed to load wasm binary file at '" + binaryFile + "'"; + } + return response['arrayBuffer'](); + }).catch(() => getBinary(binaryFile)); + } + } + + // Otherwise, getBinary should be able to get it synchronously + return Promise.resolve().then(() => getBinary(binaryFile)); +} + +function instantiateArrayBuffer(binaryFile, imports, receiver) { + return getBinaryPromise(binaryFile).then((binary) => { + return WebAssembly.instantiate(binary, imports); + }).then((instance) => { + return instance; + }).then(receiver, (reason) => { + err('failed to asynchronously prepare wasm: ' + reason); + + // Warn on some common problems. + if (isFileURI(wasmBinaryFile)) { + err('warning: Loading from a file URI (' + wasmBinaryFile + ') is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing'); + } + abort(reason); + }); +} + +function instantiateAsync(binary, binaryFile, imports, callback) { + if (!binary && + typeof WebAssembly.instantiateStreaming == 'function' && + !isDataURI(binaryFile) && + typeof fetch == 'function') { + return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => { + // Suppress closure warning here since the upstream definition for + // instantiateStreaming only allows Promise rather than + // an actual Response. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed. + /** @suppress {checkTypes} */ + var result = WebAssembly.instantiateStreaming(response, imports); + + return result.then( + callback, + function(reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err('wasm streaming compile failed: ' + reason); + err('falling back to ArrayBuffer instantiation'); + return instantiateArrayBuffer(binaryFile, imports, callback); + }); + }); + } else { + return instantiateArrayBuffer(binaryFile, imports, callback); + } +} + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +function createWasm() { + // prepare imports + var info = { + 'env': wasmImports, + 'wasi_snapshot_preview1': wasmImports, + }; + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + /** @param {WebAssembly.Module=} module*/ + function receiveInstance(instance, module) { + var exports = instance.exports; + + Module['asm'] = exports; + + wasmMemory = Module['asm']['memory']; + assert(wasmMemory, "memory not found in wasm exports"); + // This assertion doesn't hold when emscripten is run in --post-link + // mode. + // TODO(sbc): Read INITIAL_MEMORY out of the wasm file in post-link mode. + //assert(wasmMemory.buffer.byteLength === 16777216); + updateMemoryViews(); + + wasmTable = Module['asm']['__indirect_function_table']; + assert(wasmTable, "table not found in wasm exports"); + + addOnInit(Module['asm']['__wasm_call_ctors']); + + removeRunDependency('wasm-instantiate'); + return exports; + } + // wait for the pthread pool (if any) + addRunDependency('wasm-instantiate'); + + // Prefer streaming instantiation if available. + // Async compilation can be confusing when an error on the page overwrites Module + // (for example, if the order of elements is wrong, and the one defining Module is + // later), so we save Module and check it later. + var trueModule = Module; + function receiveInstantiationResult(result) { + // 'result' is a ResultObject object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?'); + trueModule = null; + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above PTHREADS-enabled path. + receiveInstance(result['instance']); + } + + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to + // run the instantiation parallel to any other async startup actions they are + // performing. + // Also pthreads and wasm workers initialize the wasm instance through this + // path. + if (Module['instantiateWasm']) { + + try { + return Module['instantiateWasm'](info, receiveInstance); + } catch(e) { + err('Module.instantiateWasm callback failed with error: ' + e); + // If instantiation fails, reject the module ready promise. + readyPromiseReject(e); + } + } + + // If instantiation fails, reject the module ready promise. + instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject); + return {}; // no exports yet; we'll fill them in later +} + +// Globals used by JS i64 conversions (see makeSetValue) +var tempDouble; +var tempI64; + +// include: runtime_debug.js +function legacyModuleProp(prop, newName) { + if (!Object.getOwnPropertyDescriptor(Module, prop)) { + Object.defineProperty(Module, prop, { + configurable: true, + get: function() { + abort('Module.' + prop + ' has been replaced with plain ' + newName + ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)'); + } + }); + } +} + +function ignoredModuleProp(prop) { + if (Object.getOwnPropertyDescriptor(Module, prop)) { + abort('`Module.' + prop + '` was supplied but `' + prop + '` not included in INCOMING_MODULE_JS_API'); + } +} + +// forcing the filesystem exports a few things by default +function isExportedByForceFilesystem(name) { + return name === 'FS_createPath' || + name === 'FS_createDataFile' || + name === 'FS_createPreloadedFile' || + name === 'FS_unlink' || + name === 'addRunDependency' || + // The old FS has some functionality that WasmFS lacks. + name === 'FS_createLazyFile' || + name === 'FS_createDevice' || + name === 'removeRunDependency'; +} + +function missingGlobal(sym, msg) { + if (typeof globalThis !== 'undefined') { + Object.defineProperty(globalThis, sym, { + configurable: true, + get: function() { + warnOnce('`' + sym + '` is not longer defined by emscripten. ' + msg); + return undefined; + } + }); + } +} + +missingGlobal('buffer', 'Please use HEAP8.buffer or wasmMemory.buffer'); + +function missingLibrarySymbol(sym) { + if (typeof globalThis !== 'undefined' && !Object.getOwnPropertyDescriptor(globalThis, sym)) { + Object.defineProperty(globalThis, sym, { + configurable: true, + get: function() { + // Can't `abort()` here because it would break code that does runtime + // checks. e.g. `if (typeof SDL === 'undefined')`. + var msg = '`' + sym + '` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line'; + // DEFAULT_LIBRARY_FUNCS_TO_INCLUDE requires the name as it appears in + // library.js, which means $name for a JS name with no prefix, or name + // for a JS name like _name. + var librarySymbol = sym; + if (!librarySymbol.startsWith('_')) { + librarySymbol = '$' + sym; + } + msg += " (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE=" + librarySymbol + ")"; + if (isExportedByForceFilesystem(sym)) { + msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you'; + } + warnOnce(msg); + return undefined; + } + }); + } + // Any symbol that is not included from the JS libary is also (by definition) + // not exported on the Module object. + unexportedRuntimeSymbol(sym); +} + +function unexportedRuntimeSymbol(sym) { + if (!Object.getOwnPropertyDescriptor(Module, sym)) { + Object.defineProperty(Module, sym, { + configurable: true, + get: function() { + var msg = "'" + sym + "' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"; + if (isExportedByForceFilesystem(sym)) { + msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you'; + } + abort(msg); + } + }); + } +} + +// Used by XXXXX_DEBUG settings to output debug messages. +function dbg(text) { + // TODO(sbc): Make this configurable somehow. Its not always convenient for + // logging to show up as warnings. + console.warn.apply(console, arguments); +} + +// end include: runtime_debug.js +// === Body === + + +// end include: preamble.js + + /** @constructor */ + function ExitStatus(status) { + this.name = 'ExitStatus'; + this.message = `Program terminated with exit(${status})`; + this.status = status; + } + + function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + // Pass the module as the first argument. + callbacks.shift()(Module); + } + } + + + /** + * @param {number} ptr + * @param {string} type + */ + function getValue(ptr, type = 'i8') { + if (type.endsWith('*')) type = '*'; + 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': abort('to do getValue(i64) use WASM_BIGINT'); + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return HEAPF64[((ptr)>>3)]; + case '*': return HEAPU32[((ptr)>>2)]; + default: abort(`invalid type for getValue: ${type}`); + } + } + + function ptrToString(ptr) { + assert(typeof ptr === 'number'); + return '0x' + ptr.toString(16).padStart(8, '0'); + } + + + /** + * @param {number} ptr + * @param {number} value + * @param {string} type + */ + function setValue(ptr, value, type = 'i8') { + if (type.endsWith('*')) type = '*'; + 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': abort('to do setValue(i64) use WASM_BIGINT'); + case 'float': HEAPF32[((ptr)>>2)] = value; break; + case 'double': HEAPF64[((ptr)>>3)] = value; break; + case '*': HEAPU32[((ptr)>>2)] = value; break; + default: abort(`invalid type for setValue: ${type}`); + } + } + + function warnOnce(text) { + if (!warnOnce.shown) warnOnce.shown = {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + err(text); + } + } + + var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined; + + /** + * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given + * array that contains uint8 values, returns a copy of that string as a + * Javascript String object. + * heapOrArray is either a regular array, or a JavaScript typed array view. + * @param {number} idx + * @param {number=} maxBytesToRead + * @return {string} + */ + function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on + // null terminator by itself. Also, use the length info to avoid running tiny + // strings through TextDecoder, since .subarray() allocates garbage. + // (As a tiny code save trick, compare endPtr against endIdx using a negation, + // so that undefined means Infinity) + while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { + return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); + } + var str = ''; + // If building with TextDecoder, we have already computed the string length + // above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = heapOrArray[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte ' + ptrToString(u0) + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!'); + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); + } + + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + return str; + } + + + /** + * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the + * emscripten HEAP, returns a copy of that string as a Javascript String object. + * + * @param {number} ptr + * @param {number=} maxBytesToRead - An optional length that specifies the + * maximum number of bytes to read. You can omit this parameter to scan the + * string until the first 0 byte. If maxBytesToRead is passed, and the string + * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the + * string will cut short at that byte index (i.e. maxBytesToRead will not + * produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing + * frequent uses of UTF8ToString() with and without maxBytesToRead may throw + * JS JIT optimizations off, so it is worth to consider consistently using one + * @return {string} + */ + function UTF8ToString(ptr, maxBytesToRead) { + assert(typeof ptr == 'number'); + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ''; + } + function ___assert_fail(condition, filename, line, func) { + abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']); + } + + function setErrNo(value) { + HEAP32[((___errno_location())>>2)] = value; + return value; + } + + var SYSCALLS = {varargs:undefined,get:function() { + assert(SYSCALLS.varargs != undefined); + SYSCALLS.varargs += 4; + var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)]; + return ret; + },getStr:function(ptr) { + var ret = UTF8ToString(ptr); + return ret; + }}; + function ___syscall_fcntl64(fd, cmd, varargs) { + SYSCALLS.varargs = varargs; + + return 0; + } + + function ___syscall_ioctl(fd, op, varargs) { + SYSCALLS.varargs = varargs; + + return 0; + } + + function ___syscall_openat(dirfd, path, flags, varargs) { + SYSCALLS.varargs = varargs; + + abort('it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM'); + } + + var char_0 = 48; + + var char_9 = 57; + function makeLegalFunctionName(name) { + if (undefined === name) { + return '_unknown'; + } + name = name.replace(/[^a-zA-Z0-9_]/g, '$'); + var f = name.charCodeAt(0); + if (f >= char_0 && f <= char_9) { + return `_${name}`; + } + return name; + } + function createNamedFunction(name, body) { + name = makeLegalFunctionName(name); + // Use an abject with a computed property name to create a new function with + // a name specified at runtime, but without using `new Function` or `eval`. + return { + [name]: function() { + return body.apply(this, arguments); + } + }[name]; + } + + /** @constructor */ + function HandleAllocator() { + // Reserve slot 0 so that 0 is always an invalid handle + this.allocated = [undefined]; + this.freelist = []; + this.get = function(id) { + assert(this.allocated[id] !== undefined, `invalid handle: ${id}`); + return this.allocated[id]; + }; + this.has = function(id) { + return this.allocated[id] !== undefined; + }; + this.allocate = function(handle) { + var id = this.freelist.pop() || this.allocated.length; + this.allocated[id] = handle; + return id; + }; + this.free = function(id) { + assert(this.allocated[id] !== undefined); + // Set the slot to `undefined` rather than using `delete` here since + // apparently arrays with holes in them can be less efficient. + this.allocated[id] = undefined; + this.freelist.push(id); + }; + } + var emval_handles = new HandleAllocator();; + + function extendError(baseErrorType, errorName) { + var errorClass = createNamedFunction(errorName, function(message) { + this.name = errorName; + this.message = message; + + var stack = (new Error(message)).stack; + if (stack !== undefined) { + this.stack = this.toString() + '\n' + + stack.replace(/^Error(:[^\n]*)?\n/, ''); + } + }); + errorClass.prototype = Object.create(baseErrorType.prototype); + errorClass.prototype.constructor = errorClass; + errorClass.prototype.toString = function() { + if (this.message === undefined) { + return this.name; + } else { + return `${this.name}: ${this.message}`; + } + }; + + return errorClass; + } + var BindingError = undefined; + function throwBindingError(message) { + throw new BindingError(message); + } + + function count_emval_handles() { + var count = 0; + for (var i = emval_handles.reserved; i < emval_handles.allocated.length; ++i) { + if (emval_handles.allocated[i] !== undefined) { + ++count; + } + } + return count; + } + + function init_emval() { + // reserve some special values. These never get de-allocated. + // The HandleAllocator takes care of reserving zero. + emval_handles.allocated.push( + {value: undefined}, + {value: null}, + {value: true}, + {value: false}, + ); + emval_handles.reserved = emval_handles.allocated.length + Module['count_emval_handles'] = count_emval_handles; + } + var Emval = {toValue:(handle) => { + if (!handle) { + throwBindingError('Cannot use deleted val. handle = ' + handle); + } + return emval_handles.get(handle).value; + },toHandle:(value) => { + switch (value) { + case undefined: return 1; + case null: return 2; + case true: return 3; + case false: return 4; + default:{ + return emval_handles.allocate({refcount: 1, value: value}); + } + } + }}; + + var PureVirtualError = undefined; + + function embind_init_charCodes() { + var codes = new Array(256); + for (var i = 0; i < 256; ++i) { + codes[i] = String.fromCharCode(i); + } + embind_charCodes = codes; + } + var embind_charCodes = undefined; + function readLatin1String(ptr) { + var ret = ""; + var c = ptr; + while (HEAPU8[c]) { + ret += embind_charCodes[HEAPU8[c++]]; + } + return ret; + } + + function getInheritedInstanceCount() { + return Object.keys(registeredInstances).length; + } + + function getLiveInheritedInstances() { + var rv = []; + for (var k in registeredInstances) { + if (registeredInstances.hasOwnProperty(k)) { + rv.push(registeredInstances[k]); + } + } + return rv; + } + + var deletionQueue = []; + function flushPendingDeletes() { + while (deletionQueue.length) { + var obj = deletionQueue.pop(); + obj.$$.deleteScheduled = false; + obj['delete'](); + } + } + + var delayFunction = undefined; + + + function setDelayFunction(fn) { + delayFunction = fn; + if (deletionQueue.length && delayFunction) { + delayFunction(flushPendingDeletes); + } + } + function init_embind() { + Module['getInheritedInstanceCount'] = getInheritedInstanceCount; + Module['getLiveInheritedInstances'] = getLiveInheritedInstances; + Module['flushPendingDeletes'] = flushPendingDeletes; + Module['setDelayFunction'] = setDelayFunction; + } + var registeredInstances = {}; + + function getBasestPointer(class_, ptr) { + if (ptr === undefined) { + throwBindingError('ptr should not be undefined'); + } + while (class_.baseClass) { + ptr = class_.upcast(ptr); + class_ = class_.baseClass; + } + return ptr; + } + + function registerInheritedInstance(class_, ptr, instance) { + ptr = getBasestPointer(class_, ptr); + if (registeredInstances.hasOwnProperty(ptr)) { + throwBindingError(`Tried to register registered instance: ${ptr}`); + } else { + registeredInstances[ptr] = instance; + } + } + + var registeredTypes = {}; + + + + function getTypeName(type) { + var ptr = ___getTypeName(type); + var rv = readLatin1String(ptr); + _free(ptr); + return rv; + } + + function requireRegisteredType(rawType, humanName) { + var impl = registeredTypes[rawType]; + if (undefined === impl) { + throwBindingError(humanName + " has unknown type " + getTypeName(rawType)); + } + return impl; + } + + + + + function unregisterInheritedInstance(class_, ptr) { + ptr = getBasestPointer(class_, ptr); + if (registeredInstances.hasOwnProperty(ptr)) { + delete registeredInstances[ptr]; + } else { + throwBindingError(`Tried to unregister unregistered instance: ${ptr}`); + } + } + + function detachFinalizer(handle) {} + + var finalizationRegistry = false; + + + function runDestructor($$) { + if ($$.smartPtr) { + $$.smartPtrType.rawDestructor($$.smartPtr); + } else { + $$.ptrType.registeredClass.rawDestructor($$.ptr); + } + } + function releaseClassHandle($$) { + $$.count.value -= 1; + var toDelete = 0 === $$.count.value; + if (toDelete) { + runDestructor($$); + } + } + + function downcastPointer(ptr, ptrClass, desiredClass) { + if (ptrClass === desiredClass) { + return ptr; + } + if (undefined === desiredClass.baseClass) { + return null; // no conversion + } + + var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass); + if (rv === null) { + return null; + } + return desiredClass.downcast(rv); + } + + var registeredPointers = {}; + + + function getInheritedInstance(class_, ptr) { + ptr = getBasestPointer(class_, ptr); + return registeredInstances[ptr]; + } + + var InternalError = undefined; + function throwInternalError(message) { + throw new InternalError(message); + } + + function makeClassHandle(prototype, record) { + if (!record.ptrType || !record.ptr) { + throwInternalError('makeClassHandle requires ptr and ptrType'); + } + var hasSmartPtrType = !!record.smartPtrType; + var hasSmartPtr = !!record.smartPtr; + if (hasSmartPtrType !== hasSmartPtr) { + throwInternalError('Both smartPtrType and smartPtr must be specified'); + } + record.count = { value: 1 }; + return attachFinalizer(Object.create(prototype, { + $$: { + value: record, + }, + })); + } + function RegisteredPointer_fromWireType(ptr) { + // ptr is a raw pointer (or a raw smartpointer) + + // rawPointer is a maybe-null raw pointer + var rawPointer = this.getPointee(ptr); + if (!rawPointer) { + this.destructor(ptr); + return null; + } + + var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer); + if (undefined !== registeredInstance) { + // JS object has been neutered, time to repopulate it + if (0 === registeredInstance.$$.count.value) { + registeredInstance.$$.ptr = rawPointer; + registeredInstance.$$.smartPtr = ptr; + return registeredInstance['clone'](); + } else { + // else, just increment reference count on existing object + // it already has a reference to the smart pointer + var rv = registeredInstance['clone'](); + this.destructor(ptr); + return rv; + } + } + + function makeDefaultHandle() { + if (this.isSmartPointer) { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this.pointeeType, + ptr: rawPointer, + smartPtrType: this, + smartPtr: ptr, + }); + } else { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this, + ptr: ptr, + }); + } + } + + var actualType = this.registeredClass.getActualType(rawPointer); + var registeredPointerRecord = registeredPointers[actualType]; + if (!registeredPointerRecord) { + return makeDefaultHandle.call(this); + } + + var toType; + if (this.isConst) { + toType = registeredPointerRecord.constPointerType; + } else { + toType = registeredPointerRecord.pointerType; + } + var dp = downcastPointer( + rawPointer, + this.registeredClass, + toType.registeredClass); + if (dp === null) { + return makeDefaultHandle.call(this); + } + if (this.isSmartPointer) { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp, + smartPtrType: this, + smartPtr: ptr, + }); + } else { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp, + }); + } + } + function attachFinalizer(handle) { + if ('undefined' === typeof FinalizationRegistry) { + attachFinalizer = (handle) => handle; + return handle; + } + // If the running environment has a FinalizationRegistry (see + // https://github.com/tc39/proposal-weakrefs), then attach finalizers + // for class handles. We check for the presence of FinalizationRegistry + // at run-time, not build-time. + finalizationRegistry = new FinalizationRegistry((info) => { + console.warn(info.leakWarning.stack.replace(/^Error: /, '')); + releaseClassHandle(info.$$); + }); + attachFinalizer = (handle) => { + var $$ = handle.$$; + var hasSmartPtr = !!$$.smartPtr; + if (hasSmartPtr) { + // We should not call the destructor on raw pointers in case other code expects the pointee to live + var info = { $$: $$ }; + // Create a warning as an Error instance in advance so that we can store + // the current stacktrace and point to it when / if a leak is detected. + // This is more useful than the empty stacktrace of `FinalizationRegistry` + // callback. + var cls = $$.ptrType.registeredClass; + info.leakWarning = new Error(`Embind found a leaked C++ instance ${cls.name} <${ptrToString($$.ptr)}>.\n` + + "We'll free it automatically in this case, but this functionality is not reliable across various environments.\n" + + "Make sure to invoke .delete() manually once you're done with the instance instead.\n" + + "Originally allocated"); // `.stack` will add "at ..." after this sentence + if ('captureStackTrace' in Error) { + Error.captureStackTrace(info.leakWarning, RegisteredPointer_fromWireType); + } + finalizationRegistry.register(handle, info, handle); + } + return handle; + }; + detachFinalizer = (handle) => finalizationRegistry.unregister(handle); + return attachFinalizer(handle); + } + function __embind_create_inheriting_constructor(constructorName, wrapperType, properties) { + constructorName = readLatin1String(constructorName); + wrapperType = requireRegisteredType(wrapperType, 'wrapper'); + properties = Emval.toValue(properties); + + var arraySlice = [].slice; + + var registeredClass = wrapperType.registeredClass; + var wrapperPrototype = registeredClass.instancePrototype; + var baseClass = registeredClass.baseClass; + var baseClassPrototype = baseClass.instancePrototype; + var baseConstructor = registeredClass.baseClass.constructor; + var ctor = createNamedFunction(constructorName, function() { + registeredClass.baseClass.pureVirtualFunctions.forEach(function(name) { + if (this[name] === baseClassPrototype[name]) { + throw new PureVirtualError(`Pure virtual function ${name} must be implemented in JavaScript`); + } + }.bind(this)); + + Object.defineProperty(this, '__parent', { + value: wrapperPrototype + }); + this["__construct"].apply(this, arraySlice.call(arguments)); + }); + + // It's a little nasty that we're modifying the wrapper prototype here. + + wrapperPrototype["__construct"] = function __construct() { + if (this === wrapperPrototype) { + throwBindingError("Pass correct 'this' to __construct"); + } + + var inner = baseConstructor["implement"].apply( + undefined, + [this].concat(arraySlice.call(arguments))); + detachFinalizer(inner); + var $$ = inner.$$; + inner["notifyOnDestruction"](); + $$.preservePointerOnDelete = true; + Object.defineProperties(this, { $$: { + value: $$ + }}); + attachFinalizer(this); + registerInheritedInstance(registeredClass, $$.ptr, this); + }; + + wrapperPrototype["__destruct"] = function __destruct() { + if (this === wrapperPrototype) { + throwBindingError("Pass correct 'this' to __destruct"); + } + + detachFinalizer(this); + unregisterInheritedInstance(registeredClass, this.$$.ptr); + }; + + ctor.prototype = Object.create(wrapperPrototype); + for (var p in properties) { + ctor.prototype[p] = properties[p]; + } + return Emval.toHandle(ctor); + } + + var structRegistrations = {}; + + function runDestructors(destructors) { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } + } + + function simpleReadValueFromPointer(pointer) { + return this['fromWireType'](HEAP32[((pointer)>>2)]); + } + + var awaitingDependencies = {}; + + + var typeDependencies = {}; + + function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) { + myTypes.forEach(function(type) { + typeDependencies[type] = dependentTypes; + }); + + function onComplete(typeConverters) { + var myTypeConverters = getTypeConverters(typeConverters); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError('Mismatched type converter count'); + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]); + } + } + + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach((dt, i) => { + if (registeredTypes.hasOwnProperty(dt)) { + typeConverters[i] = registeredTypes[dt]; + } else { + unregisteredTypes.push(dt); + if (!awaitingDependencies.hasOwnProperty(dt)) { + awaitingDependencies[dt] = []; + } + awaitingDependencies[dt].push(() => { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters); + } + }); + } + }); + if (0 === unregisteredTypes.length) { + onComplete(typeConverters); + } + } + function __embind_finalize_value_object(structType) { + var reg = structRegistrations[structType]; + delete structRegistrations[structType]; + + var rawConstructor = reg.rawConstructor; + var rawDestructor = reg.rawDestructor; + var fieldRecords = reg.fields; + var fieldTypes = fieldRecords.map((field) => field.getterReturnType). + concat(fieldRecords.map((field) => field.setterArgumentType)); + whenDependentTypesAreResolved([structType], fieldTypes, (fieldTypes) => { + var fields = {}; + fieldRecords.forEach((field, i) => { + var fieldName = field.fieldName; + var getterReturnType = fieldTypes[i]; + var getter = field.getter; + var getterContext = field.getterContext; + var setterArgumentType = fieldTypes[i + fieldRecords.length]; + var setter = field.setter; + var setterContext = field.setterContext; + fields[fieldName] = { + read: (ptr) => { + return getterReturnType['fromWireType']( + getter(getterContext, ptr)); + }, + write: (ptr, o) => { + var destructors = []; + setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, o)); + runDestructors(destructors); + } + }; + }); + + return [{ + name: reg.name, + 'fromWireType': function(ptr) { + var rv = {}; + for (var i in fields) { + rv[i] = fields[i].read(ptr); + } + rawDestructor(ptr); + return rv; + }, + 'toWireType': function(destructors, o) { + // todo: Here we have an opportunity for -O3 level "unsafe" optimizations: + // assume all fields are present without checking. + for (var fieldName in fields) { + if (!(fieldName in o)) { + throw new TypeError(`Missing field: "${fieldName}"`); + } + } + var ptr = rawConstructor(); + for (fieldName in fields) { + fields[fieldName].write(ptr, o[fieldName]); + } + if (destructors !== null) { + destructors.push(rawDestructor, ptr); + } + return ptr; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: rawDestructor, + }]; + }); + } + + function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {} + + function getShiftFromSize(size) { + switch (size) { + case 1: return 0; + case 2: return 1; + case 4: return 2; + case 8: return 3; + default: + throw new TypeError(`Unknown type size: ${size}`); + } + } + + + + + + + /** @param {Object=} options */ + function registerType(rawType, registeredInstance, options = {}) { + if (!('argPackAdvance' in registeredInstance)) { + throw new TypeError('registerType registeredInstance requires argPackAdvance'); + } + + var name = registeredInstance.name; + if (!rawType) { + throwBindingError(`type "${name}" must have a positive integer typeid pointer`); + } + if (registeredTypes.hasOwnProperty(rawType)) { + if (options.ignoreDuplicateRegistrations) { + return; + } else { + throwBindingError(`Cannot register type '${name}' twice`); + } + } + + registeredTypes[rawType] = registeredInstance; + delete typeDependencies[rawType]; + + if (awaitingDependencies.hasOwnProperty(rawType)) { + var callbacks = awaitingDependencies[rawType]; + delete awaitingDependencies[rawType]; + callbacks.forEach((cb) => cb()); + } + } + function __embind_register_bool(rawType, name, size, trueValue, falseValue) { + var shift = getShiftFromSize(size); + + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(wt) { + // ambiguous emscripten ABI: sometimes return values are + // true or false, and sometimes integers (0 or 1) + return !!wt; + }, + 'toWireType': function(destructors, o) { + return o ? trueValue : falseValue; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': function(pointer) { + // TODO: if heap is fixed (like in asm.js) this could be executed outside + var heap; + if (size === 1) { + heap = HEAP8; + } else if (size === 2) { + heap = HEAP16; + } else if (size === 4) { + heap = HEAP32; + } else { + throw new TypeError("Unknown boolean type size: " + name); + } + return this['fromWireType'](heap[pointer >> shift]); + }, + destructorFunction: null, // This type does not need a destructor + }); + } + + + function ClassHandle_isAliasOf(other) { + if (!(this instanceof ClassHandle)) { + return false; + } + if (!(other instanceof ClassHandle)) { + return false; + } + + var leftClass = this.$$.ptrType.registeredClass; + var left = this.$$.ptr; + var rightClass = other.$$.ptrType.registeredClass; + var right = other.$$.ptr; + + while (leftClass.baseClass) { + left = leftClass.upcast(left); + leftClass = leftClass.baseClass; + } + + while (rightClass.baseClass) { + right = rightClass.upcast(right); + rightClass = rightClass.baseClass; + } + + return leftClass === rightClass && left === right; + } + + function shallowCopyInternalPointer(o) { + return { + count: o.count, + deleteScheduled: o.deleteScheduled, + preservePointerOnDelete: o.preservePointerOnDelete, + ptr: o.ptr, + ptrType: o.ptrType, + smartPtr: o.smartPtr, + smartPtrType: o.smartPtrType, + }; + } + + function throwInstanceAlreadyDeleted(obj) { + function getInstanceTypeName(handle) { + return handle.$$.ptrType.registeredClass.name; + } + throwBindingError(getInstanceTypeName(obj) + ' instance already deleted'); + } + + function ClassHandle_clone() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + + if (this.$$.preservePointerOnDelete) { + this.$$.count.value += 1; + return this; + } else { + var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), { + $$: { + value: shallowCopyInternalPointer(this.$$), + } + })); + + clone.$$.count.value += 1; + clone.$$.deleteScheduled = false; + return clone; + } + } + + + + + function ClassHandle_delete() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError('Object already scheduled for deletion'); + } + + detachFinalizer(this); + releaseClassHandle(this.$$); + + if (!this.$$.preservePointerOnDelete) { + this.$$.smartPtr = undefined; + this.$$.ptr = undefined; + } + } + + function ClassHandle_isDeleted() { + return !this.$$.ptr; + } + + + + function ClassHandle_deleteLater() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError('Object already scheduled for deletion'); + } + deletionQueue.push(this); + if (deletionQueue.length === 1 && delayFunction) { + delayFunction(flushPendingDeletes); + } + this.$$.deleteScheduled = true; + return this; + } + function init_ClassHandle() { + ClassHandle.prototype['isAliasOf'] = ClassHandle_isAliasOf; + ClassHandle.prototype['clone'] = ClassHandle_clone; + ClassHandle.prototype['delete'] = ClassHandle_delete; + ClassHandle.prototype['isDeleted'] = ClassHandle_isDeleted; + ClassHandle.prototype['deleteLater'] = ClassHandle_deleteLater; + } + function ClassHandle() { + } + + + + function ensureOverloadTable(proto, methodName, humanName) { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments. + proto[methodName] = function() { + // TODO This check can be removed in -O3 level "unsafe" optimizations. + if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) { + throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${arguments.length}) - expects one of (${proto[methodName].overloadTable})!`); + } + return proto[methodName].overloadTable[arguments.length].apply(this, arguments); + }; + // Move the previous function into the overload table. + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } + } + + /** @param {number=} numArguments */ + function exposePublicSymbol(name, value, numArguments) { + if (Module.hasOwnProperty(name)) { + if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) { + throwBindingError(`Cannot register public name '${name}' twice`); + } + + // We are exposing a function with the same name as an existing function. Create an overload table and a function selector + // that routes between the two. + ensureOverloadTable(Module, name, name); + if (Module.hasOwnProperty(numArguments)) { + throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`); + } + // Add the new function into the overload table. + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + if (undefined !== numArguments) { + Module[name].numArguments = numArguments; + } + } + } + + + + /** @constructor */ + function RegisteredClass(name, + constructor, + instancePrototype, + rawDestructor, + baseClass, + getActualType, + upcast, + downcast) { + this.name = name; + this.constructor = constructor; + this.instancePrototype = instancePrototype; + this.rawDestructor = rawDestructor; + this.baseClass = baseClass; + this.getActualType = getActualType; + this.upcast = upcast; + this.downcast = downcast; + this.pureVirtualFunctions = []; + } + + + function upcastPointer(ptr, ptrClass, desiredClass) { + while (ptrClass !== desiredClass) { + if (!ptrClass.upcast) { + throwBindingError(`Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`); + } + ptr = ptrClass.upcast(ptr); + ptrClass = ptrClass.baseClass; + } + return ptr; + } + function constNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError(`null is not a valid ${this.name}`); + } + return 0; + } + + if (!handle.$$) { + throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`); + } + if (!handle.$$.ptr) { + throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; + } + + + function genericPointerToWireType(destructors, handle) { + var ptr; + if (handle === null) { + if (this.isReference) { + throwBindingError(`null is not a valid ${this.name}`); + } + + if (this.isSmartPointer) { + ptr = this.rawConstructor(); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + return ptr; + } else { + return 0; + } + } + + if (!handle.$$) { + throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`); + } + if (!handle.$$.ptr) { + throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`); + } + if (!this.isConst && handle.$$.ptrType.isConst) { + throwBindingError(`Cannot convert argument of type ${(handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name)} to parameter type ${this.name}`); + } + var handleClass = handle.$$.ptrType.registeredClass; + ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + + if (this.isSmartPointer) { + // TODO: this is not strictly true + // We could support BY_EMVAL conversions from raw pointers to smart pointers + // because the smart pointer can hold a reference to the handle + if (undefined === handle.$$.smartPtr) { + throwBindingError('Passing raw pointer to smart pointer is illegal'); + } + + switch (this.sharingPolicy) { + case 0: // NONE + // no upcasting + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + throwBindingError(`Cannot convert argument of type ${(handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name)} to parameter type ${this.name}`); + } + break; + + case 1: // INTRUSIVE + ptr = handle.$$.smartPtr; + break; + + case 2: // BY_EMVAL + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + var clonedHandle = handle['clone'](); + ptr = this.rawShare( + ptr, + Emval.toHandle(function() { + clonedHandle['delete'](); + }) + ); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + } + break; + + default: + throwBindingError('Unsupporting sharing policy'); + } + } + return ptr; + } + + + function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError(`null is not a valid ${this.name}`); + } + return 0; + } + + if (!handle.$$) { + throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`); + } + if (!handle.$$.ptr) { + throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`); + } + if (handle.$$.ptrType.isConst) { + throwBindingError(`Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; + } + + + function RegisteredPointer_getPointee(ptr) { + if (this.rawGetPointee) { + ptr = this.rawGetPointee(ptr); + } + return ptr; + } + + function RegisteredPointer_destructor(ptr) { + if (this.rawDestructor) { + this.rawDestructor(ptr); + } + } + + function RegisteredPointer_deleteObject(handle) { + if (handle !== null) { + handle['delete'](); + } + } + + function init_RegisteredPointer() { + RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee; + RegisteredPointer.prototype.destructor = RegisteredPointer_destructor; + RegisteredPointer.prototype['argPackAdvance'] = 8; + RegisteredPointer.prototype['readValueFromPointer'] = simpleReadValueFromPointer; + RegisteredPointer.prototype['deleteObject'] = RegisteredPointer_deleteObject; + RegisteredPointer.prototype['fromWireType'] = RegisteredPointer_fromWireType; + } + /** @constructor + @param {*=} pointeeType, + @param {*=} sharingPolicy, + @param {*=} rawGetPointee, + @param {*=} rawConstructor, + @param {*=} rawShare, + @param {*=} rawDestructor, + */ + function RegisteredPointer( + name, + registeredClass, + isReference, + isConst, + + // smart pointer properties + isSmartPointer, + pointeeType, + sharingPolicy, + rawGetPointee, + rawConstructor, + rawShare, + rawDestructor + ) { + this.name = name; + this.registeredClass = registeredClass; + this.isReference = isReference; + this.isConst = isConst; + + // smart pointer properties + this.isSmartPointer = isSmartPointer; + this.pointeeType = pointeeType; + this.sharingPolicy = sharingPolicy; + this.rawGetPointee = rawGetPointee; + this.rawConstructor = rawConstructor; + this.rawShare = rawShare; + this.rawDestructor = rawDestructor; + + if (!isSmartPointer && registeredClass.baseClass === undefined) { + if (isConst) { + this['toWireType'] = constNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } else { + this['toWireType'] = nonConstNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } + } else { + this['toWireType'] = genericPointerToWireType; + // Here we must leave this.destructorFunction undefined, since whether genericPointerToWireType returns + // a pointer that needs to be freed up is runtime-dependent, and cannot be evaluated at registration time. + // TODO: Create an alternative mechanism that allows removing the use of var destructors = []; array in + // craftInvokerFunction altogether. + } + } + + /** @param {number=} numArguments */ + function replacePublicSymbol(name, value, numArguments) { + if (!Module.hasOwnProperty(name)) { + throwInternalError('Replacing nonexistant public symbol'); + } + // If there's an overload table for this symbol, replace the symbol in the overload table instead. + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + Module[name].argCount = numArguments; + } + } + + + + function dynCallLegacy(sig, ptr, args) { + assert(('dynCall_' + sig) in Module, `bad function pointer type - dynCall function not found for sig '${sig}'`); + if (args && args.length) { + // j (64-bit integer) must be passed in as two numbers [low 32, high 32]. + assert(args.length === sig.substring(1).replace(/j/g, '--').length); + } else { + assert(sig.length == 1); + } + var f = Module['dynCall_' + sig]; + return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr); + } + + var wasmTableMirror = []; + + function getWasmTableEntry(funcPtr) { + var func = wasmTableMirror[funcPtr]; + if (!func) { + if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1; + wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); + } + assert(wasmTable.get(funcPtr) == func, "JavaScript-side Wasm function table mirror is out of date!"); + return func; + } + + /** @param {Object=} args */ + function dynCall(sig, ptr, args) { + // Without WASM_BIGINT support we cannot directly call function with i64 as + // part of thier signature, so we rely the dynCall functions generated by + // wasm-emscripten-finalize + if (sig.includes('j')) { + return dynCallLegacy(sig, ptr, args); + } + assert(getWasmTableEntry(ptr), `missing table entry in dynCall: ${ptr}`); + var rtn = getWasmTableEntry(ptr).apply(null, args); + return rtn; + + } + + function getDynCaller(sig, ptr) { + assert(sig.includes('j') || sig.includes('p'), 'getDynCaller should only be called with i64 sigs') + var argCache = []; + return function() { + argCache.length = 0; + Object.assign(argCache, arguments); + return dynCall(sig, ptr, argCache); + }; + } + + + function embind__requireFunction(signature, rawFunction) { + signature = readLatin1String(signature); + + function makeDynCaller() { + if (signature.includes('j')) { + return getDynCaller(signature, rawFunction); + } + return getWasmTableEntry(rawFunction); + } + + var fp = makeDynCaller(); + if (typeof fp != "function") { + throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`); + } + return fp; + } + + + + var UnboundTypeError = undefined; + + function throwUnboundTypeError(message, types) { + var unboundTypes = []; + var seen = {}; + function visit(type) { + if (seen[type]) { + return; + } + if (registeredTypes[type]) { + return; + } + if (typeDependencies[type]) { + typeDependencies[type].forEach(visit); + return; + } + unboundTypes.push(type); + seen[type] = true; + } + types.forEach(visit); + + throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([', '])); + } + + function __embind_register_class(rawType, + rawPointerType, + rawConstPointerType, + baseClassRawType, + getActualTypeSignature, + getActualType, + upcastSignature, + upcast, + downcastSignature, + downcast, + name, + destructorSignature, + rawDestructor) { + name = readLatin1String(name); + getActualType = embind__requireFunction(getActualTypeSignature, getActualType); + if (upcast) { + upcast = embind__requireFunction(upcastSignature, upcast); + } + if (downcast) { + downcast = embind__requireFunction(downcastSignature, downcast); + } + rawDestructor = embind__requireFunction(destructorSignature, rawDestructor); + var legalFunctionName = makeLegalFunctionName(name); + + exposePublicSymbol(legalFunctionName, function() { + // this code cannot run if baseClassRawType is zero + throwUnboundTypeError(`Cannot construct ${name} due to unbound types`, [baseClassRawType]); + }); + + whenDependentTypesAreResolved( + [rawType, rawPointerType, rawConstPointerType], + baseClassRawType ? [baseClassRawType] : [], + function(base) { + base = base[0]; + + var baseClass; + var basePrototype; + if (baseClassRawType) { + baseClass = base.registeredClass; + basePrototype = baseClass.instancePrototype; + } else { + basePrototype = ClassHandle.prototype; + } + + var constructor = createNamedFunction(legalFunctionName, function() { + if (Object.getPrototypeOf(this) !== instancePrototype) { + throw new BindingError("Use 'new' to construct " + name); + } + if (undefined === registeredClass.constructor_body) { + throw new BindingError(name + " has no accessible constructor"); + } + var body = registeredClass.constructor_body[arguments.length]; + if (undefined === body) { + throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${arguments.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`); + } + return body.apply(this, arguments); + }); + + var instancePrototype = Object.create(basePrototype, { + constructor: { value: constructor }, + }); + + constructor.prototype = instancePrototype; + + var registeredClass = new RegisteredClass(name, + constructor, + instancePrototype, + rawDestructor, + baseClass, + getActualType, + upcast, + downcast); + + if (registeredClass.baseClass) { + // Keep track of class hierarchy. Used to allow sub-classes to inherit class functions. + if (registeredClass.baseClass.__derivedClasses === undefined) { + registeredClass.baseClass.__derivedClasses = []; + } + + registeredClass.baseClass.__derivedClasses.push(registeredClass); + } + + var referenceConverter = new RegisteredPointer(name, + registeredClass, + true, + false, + false); + + var pointerConverter = new RegisteredPointer(name + '*', + registeredClass, + false, + false, + false); + + var constPointerConverter = new RegisteredPointer(name + ' const*', + registeredClass, + false, + true, + false); + + registeredPointers[rawType] = { + pointerType: pointerConverter, + constPointerType: constPointerConverter + }; + + replacePublicSymbol(legalFunctionName, constructor); + + return [referenceConverter, pointerConverter, constPointerConverter]; + } + ); + } + + + + function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, /** boolean= */ isAsync) { + // humanName: a human-readable string name for the function to be generated. + // argTypes: An array that contains the embind type objects for all types in the function signature. + // argTypes[0] is the type object for the function return value. + // argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method. + // argTypes[2...] are the actual function parameters. + // classType: The embind type object for the class to be bound, or null if this is not a method of a class. + // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code. + // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling. + // isAsync: Optional. If true, returns an async function. Async bindings are only supported with JSPI. + var argCount = argTypes.length; + + if (argCount < 2) { + throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!"); + } + + assert(!isAsync, 'Async bindings are only supported with JSPI.'); + + var isClassMethodFunc = (argTypes[1] !== null && classType !== null); + + // Free functions with signature "void function()" do not need an invoker that marshalls between wire types. + // TODO: This omits argument count check - enable only at -O3 or similar. + // if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) { + // return FUNCTION_TABLE[fn]; + // } + + // Determine if we need to use a dynamic stack to store the destructors for the function parameters. + // TODO: Remove this completely once all function invokers are being dynamically generated. + var needsDestructorStack = false; + + for (var i = 1; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { // The type does not define a destructor function - must use dynamic stack + needsDestructorStack = true; + break; + } + } + + var returns = (argTypes[0].name !== "void"); + + var expectedArgCount = argCount - 2; + var argsWired = new Array(expectedArgCount); + var invokerFuncArgs = []; + var destructors = []; + return function() { + if (arguments.length !== expectedArgCount) { + throwBindingError(`function ${humanName} called with ${arguments.length} arguments, expected ${expectedArgCount} args!`); + } + destructors.length = 0; + var thisWired; + invokerFuncArgs.length = isClassMethodFunc ? 2 : 1; + invokerFuncArgs[0] = cppTargetFunc; + if (isClassMethodFunc) { + thisWired = argTypes[1]['toWireType'](destructors, this); + invokerFuncArgs[1] = thisWired; + } + for (var i = 0; i < expectedArgCount; ++i) { + argsWired[i] = argTypes[i + 2]['toWireType'](destructors, arguments[i]); + invokerFuncArgs.push(argsWired[i]); + } + + var rv = cppInvokerFunc.apply(null, invokerFuncArgs); + + function onDone(rv) { + if (needsDestructorStack) { + runDestructors(destructors); + } else { + for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; i++) { + var param = i === 1 ? thisWired : argsWired[i - 2]; + if (argTypes[i].destructorFunction !== null) { + argTypes[i].destructorFunction(param); + } + } + } + + if (returns) { + return argTypes[0]['fromWireType'](rv); + } + } + + return onDone(rv); + }; + } + + + function heap32VectorToArray(count, firstElement) { + var array = []; + for (var i = 0; i < count; i++) { + // TODO(https://github.com/emscripten-core/emscripten/issues/17310): + // Find a way to hoist the `>> 2` or `>> 3` out of this loop. + array.push(HEAPU32[(((firstElement)+(i * 4))>>2)]); + } + return array; + } + + + + + function __embind_register_class_class_function(rawClassType, + methodName, + argCount, + rawArgTypesAddr, + invokerSignature, + rawInvoker, + fn, + isAsync) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = `${classType.name}.${methodName}`; + + function unboundTypesHandler() { + throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`, rawArgTypes); + } + + if (methodName.startsWith("@@")) { + methodName = Symbol[methodName.substring(2)]; + } + + var proto = classType.registeredClass.constructor; + if (undefined === proto[methodName]) { + // This is the first function to be registered with this name. + unboundTypesHandler.argCount = argCount-1; + proto[methodName] = unboundTypesHandler; + } else { + // There was an existing function with the same name registered. Set up + // a function overload routing table. + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount-1] = unboundTypesHandler; + } + + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + // Replace the initial unbound-types-handler stub with the proper + // function. If multiple overloads are registered, the function handlers + // go into an overload table. + var invokerArgsArray = [argTypes[0] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */); + var func = craftInvokerFunction(humanName, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn, isAsync); + if (undefined === proto[methodName].overloadTable) { + func.argCount = argCount-1; + proto[methodName] = func; + } else { + proto[methodName].overloadTable[argCount-1] = func; + } + + if (classType.registeredClass.__derivedClasses) { + for (const derivedClass of classType.registeredClass.__derivedClasses) { + if (!derivedClass.constructor.hasOwnProperty(methodName)) { + // TODO: Add support for overloads + derivedClass.constructor[methodName] = func; + } + } + } + + return []; + }); + return []; + }); + } + + + + + + + + function __embind_register_class_constructor( + rawClassType, + argCount, + rawArgTypesAddr, + invokerSignature, + invoker, + rawConstructor + ) { + assert(argCount > 0); + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + invoker = embind__requireFunction(invokerSignature, invoker); + var args = [rawConstructor]; + var destructors = []; + + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = `constructor ${classType.name}`; + + if (undefined === classType.registeredClass.constructor_body) { + classType.registeredClass.constructor_body = []; + } + if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) { + throw new BindingError(`Cannot register multiple constructors with identical number of parameters (${argCount-1}) for class '${classType.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`); + } + classType.registeredClass.constructor_body[argCount - 1] = () => { + throwUnboundTypeError(`Cannot construct ${classType.name} due to unbound types`, rawArgTypes); + }; + + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + // Insert empty slot for context type (argTypes[1]). + argTypes.splice(1, 0, null); + classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor); + return []; + }); + return []; + }); + } + + + + + + + function __embind_register_class_function(rawClassType, + methodName, + argCount, + rawArgTypesAddr, // [ReturnType, ThisType, Args...] + invokerSignature, + rawInvoker, + context, + isPureVirtual, + isAsync) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = `${classType.name}.${methodName}`; + + if (methodName.startsWith("@@")) { + methodName = Symbol[methodName.substring(2)]; + } + + if (isPureVirtual) { + classType.registeredClass.pureVirtualFunctions.push(methodName); + } + + function unboundTypesHandler() { + throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`, rawArgTypes); + } + + var proto = classType.registeredClass.instancePrototype; + var method = proto[methodName]; + if (undefined === method || (undefined === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2)) { + // This is the first overload to be registered, OR we are replacing a + // function in the base class with a function in the derived class. + unboundTypesHandler.argCount = argCount - 2; + unboundTypesHandler.className = classType.name; + proto[methodName] = unboundTypesHandler; + } else { + // There was an existing function with the same name registered. Set up + // a function overload routing table. + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler; + } + + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context, isAsync); + + // Replace the initial unbound-handler-stub function with the appropriate member function, now that all types + // are resolved. If multiple overloads are registered for this function, the function goes into an overload table. + if (undefined === proto[methodName].overloadTable) { + // Set argCount in case an overload is registered later + memberFunction.argCount = argCount - 2; + proto[methodName] = memberFunction; + } else { + proto[methodName].overloadTable[argCount - 2] = memberFunction; + } + + return []; + }); + return []; + }); + } + + + + + + + + + function validateThis(this_, classType, humanName) { + if (!(this_ instanceof Object)) { + throwBindingError(`${humanName} with invalid "this": ${this_}`); + } + if (!(this_ instanceof classType.registeredClass.constructor)) { + throwBindingError(`${humanName} incompatible with "this" of type ${this_.constructor.name}`); + } + if (!this_.$$.ptr) { + throwBindingError(`cannot call emscripten binding method ${humanName} on deleted object`); + } + + // todo: kill this + return upcastPointer(this_.$$.ptr, + this_.$$.ptrType.registeredClass, + classType.registeredClass); + } + function __embind_register_class_property(classType, + fieldName, + getterReturnType, + getterSignature, + getter, + getterContext, + setterArgumentType, + setterSignature, + setter, + setterContext) { + fieldName = readLatin1String(fieldName); + getter = embind__requireFunction(getterSignature, getter); + + whenDependentTypesAreResolved([], [classType], function(classType) { + classType = classType[0]; + var humanName = `${classType.name}.${fieldName}`; + var desc = { + get: function() { + throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`, [getterReturnType, setterArgumentType]); + }, + enumerable: true, + configurable: true + }; + if (setter) { + desc.set = () => { + throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`, [getterReturnType, setterArgumentType]); + }; + } else { + desc.set = (v) => { + throwBindingError(humanName + ' is a read-only property'); + }; + } + + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + + whenDependentTypesAreResolved( + [], + (setter ? [getterReturnType, setterArgumentType] : [getterReturnType]), + function(types) { + var getterReturnType = types[0]; + var desc = { + get: function() { + var ptr = validateThis(this, classType, humanName + ' getter'); + return getterReturnType['fromWireType'](getter(getterContext, ptr)); + }, + enumerable: true + }; + + if (setter) { + setter = embind__requireFunction(setterSignature, setter); + var setterArgumentType = types[1]; + desc.set = function(v) { + var ptr = validateThis(this, classType, humanName + ' setter'); + var destructors = []; + setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, v)); + runDestructors(destructors); + }; + } + + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + return []; + }); + + return []; + }); + } + + + function __embind_register_constant(name, type, value) { + name = readLatin1String(name); + whenDependentTypesAreResolved([], [type], function(type) { + type = type[0]; + Module[name] = type['fromWireType'](value); + return []; + }); + } + + function __emval_decref(handle) { + if (handle >= emval_handles.reserved && 0 === --emval_handles.get(handle).refcount) { + emval_handles.free(handle); + } + } + + + + + function __embind_register_emval(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(handle) { + var rv = Emval.toValue(handle); + __emval_decref(handle); + return rv; + }, + 'toWireType': function(destructors, value) { + return Emval.toHandle(value); + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: null, // This type does not need a destructor + + // TODO: do we need a deleteObject here? write a test where + // emval is passed into JS via an interface + }); + } + + + + function enumReadValueFromPointer(name, shift, signed) { + switch (shift) { + case 0: return function(pointer) { + var heap = signed ? HEAP8 : HEAPU8; + return this['fromWireType'](heap[pointer]); + }; + case 1: return function(pointer) { + var heap = signed ? HEAP16 : HEAPU16; + return this['fromWireType'](heap[pointer >> 1]); + }; + case 2: return function(pointer) { + var heap = signed ? HEAP32 : HEAPU32; + return this['fromWireType'](heap[pointer >> 2]); + }; + default: + throw new TypeError("Unknown integer type: " + name); + } + } + + + function __embind_register_enum(rawType, name, size, isSigned) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + + function ctor() {} + ctor.values = {}; + + registerType(rawType, { + name: name, + constructor: ctor, + 'fromWireType': function(c) { + return this.constructor.values[c]; + }, + 'toWireType': function(destructors, c) { + return c.value; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': enumReadValueFromPointer(name, shift, isSigned), + destructorFunction: null, + }); + exposePublicSymbol(name, ctor); + } + + + + function __embind_register_enum_value(rawEnumType, name, enumValue) { + var enumType = requireRegisteredType(rawEnumType, 'enum'); + name = readLatin1String(name); + + var Enum = enumType.constructor; + + var Value = Object.create(enumType.constructor.prototype, { + value: {value: enumValue}, + constructor: {value: createNamedFunction(`${enumType.name}_${name}`, function() {})}, + }); + Enum.values[enumValue] = Value; + Enum[name] = Value; + } + + function embindRepr(v) { + if (v === null) { + return 'null'; + } + var t = typeof v; + if (t === 'object' || t === 'array' || t === 'function') { + return v.toString(); + } else { + return '' + v; + } + } + + function floatReadValueFromPointer(name, shift) { + switch (shift) { + case 2: return function(pointer) { + return this['fromWireType'](HEAPF32[pointer >> 2]); + }; + case 3: return function(pointer) { + return this['fromWireType'](HEAPF64[pointer >> 3]); + }; + default: + throw new TypeError("Unknown float type: " + name); + } + } + + + + function __embind_register_float(rawType, name, size) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + return value; + }, + 'toWireType': function(destructors, value) { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError(`Cannot convert ${embindRepr(value)} to ${this.name}`); + } + // The VM will perform JS to Wasm value conversion, according to the spec: + // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue + return value; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': floatReadValueFromPointer(name, shift), + destructorFunction: null, // This type does not need a destructor + }); + } + + + + + + + + + function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync) { + var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + name = readLatin1String(name); + + rawInvoker = embind__requireFunction(signature, rawInvoker); + + exposePublicSymbol(name, function() { + throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes); + }, argCount - 1); + + whenDependentTypesAreResolved([], argTypes, function(argTypes) { + var invokerArgsArray = [argTypes[0] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */); + replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn, isAsync), argCount - 1); + return []; + }); + } + + + + function integerReadValueFromPointer(name, shift, signed) { + // integers are quite common, so generate very specialized functions + switch (shift) { + case 0: return signed ? + function readS8FromPointer(pointer) { return HEAP8[pointer]; } : + function readU8FromPointer(pointer) { return HEAPU8[pointer]; }; + case 1: return signed ? + function readS16FromPointer(pointer) { return HEAP16[pointer >> 1]; } : + function readU16FromPointer(pointer) { return HEAPU16[pointer >> 1]; }; + case 2: return signed ? + function readS32FromPointer(pointer) { return HEAP32[pointer >> 2]; } : + function readU32FromPointer(pointer) { return HEAPU32[pointer >> 2]; }; + default: + throw new TypeError("Unknown integer type: " + name); + } + } + + + function __embind_register_integer(primitiveType, name, size, minRange, maxRange) { + name = readLatin1String(name); + // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come + // out as 'i32 -1'. Always treat those as max u32. + if (maxRange === -1) { + maxRange = 4294967295; + } + + var shift = getShiftFromSize(size); + + var fromWireType = (value) => value; + + if (minRange === 0) { + var bitshift = 32 - 8*size; + fromWireType = (value) => (value << bitshift) >>> bitshift; + } + + var isUnsignedType = (name.includes('unsigned')); + var checkAssertions = (value, toTypeName) => { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError(`Cannot convert "${embindRepr(value)}" to ${toTypeName}`); + } + if (value < minRange || value > maxRange) { + throw new TypeError(`Passing a number "${embindRepr(value)}" from JS side to C/C++ side to an argument of type "${name}", which is outside the valid range [${minRange}, ${maxRange}]!`); + } + } + var toWireType; + if (isUnsignedType) { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + return value >>> 0; + } + } else { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + // The VM will perform JS to Wasm value conversion, according to the spec: + // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue + return value; + } + } + registerType(primitiveType, { + name: name, + 'fromWireType': fromWireType, + 'toWireType': toWireType, + 'argPackAdvance': 8, + 'readValueFromPointer': integerReadValueFromPointer(name, shift, minRange !== 0), + destructorFunction: null, // This type does not need a destructor + }); + } + + + function __embind_register_memory_view(rawType, dataTypeIndex, name) { + var typeMapping = [ + Int8Array, + Uint8Array, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float32Array, + Float64Array, + ]; + + var TA = typeMapping[dataTypeIndex]; + + function decodeMemoryView(handle) { + handle = handle >> 2; + var heap = HEAPU32; + var size = heap[handle]; // in elements + var data = heap[handle + 1]; // byte offset into emscripten heap + return new TA(heap.buffer, data, size); + } + + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': decodeMemoryView, + 'argPackAdvance': 8, + 'readValueFromPointer': decodeMemoryView, + }, { + ignoreDuplicateRegistrations: true, + }); + } + + + + + + function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { + assert(typeof str === 'string'); + // Parameter maxBytesToWrite is not optional. Negative values, 0, null, + // undefined and false each don't write out any bytes. + if (!(maxBytesToWrite > 0)) + return 0; + + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description + // and https://www.ietf.org/rfc/rfc2279.txt + // and https://tools.ietf.org/html/rfc3629 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 0xC0 | (u >> 6); + heap[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 0xE0 | (u >> 12); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + if (u > 0x10FFFF) warnOnce('Invalid Unicode code point ' + ptrToString(u) + ' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).'); + heap[outIdx++] = 0xF0 | (u >> 18); + heap[outIdx++] = 0x80 | ((u >> 12) & 63); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + heap[outIdx] = 0; + return outIdx - startIdx; + } + function stringToUTF8(str, outPtr, maxBytesToWrite) { + assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite); + } + + function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var c = str.charCodeAt(i); // possibly a lead surrogate + if (c <= 0x7F) { + len++; + } else if (c <= 0x7FF) { + len += 2; + } else if (c >= 0xD800 && c <= 0xDFFF) { + len += 4; ++i; + } else { + len += 3; + } + } + return len; + } + + + + function __embind_register_std_string(rawType, name) { + name = readLatin1String(name); + var stdStringIsUTF8 + //process only std::string bindings with UTF8 support, in contrast to e.g. std::basic_string + = (name === "std::string"); + + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + var length = HEAPU32[((value)>>2)]; + var payload = value + 4; + + var str; + if (stdStringIsUTF8) { + var decodeStartPtr = payload; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = payload + i; + if (i == length || HEAPU8[currentBytePtr] == 0) { + var maxRead = currentBytePtr - decodeStartPtr; + var stringSegment = UTF8ToString(decodeStartPtr, maxRead); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + 1; + } + } + } else { + var a = new Array(length); + for (var i = 0; i < length; ++i) { + a[i] = String.fromCharCode(HEAPU8[payload + i]); + } + str = a.join(''); + } + + _free(value); + + return str; + }, + 'toWireType': function(destructors, value) { + if (value instanceof ArrayBuffer) { + value = new Uint8Array(value); + } + + var length; + var valueIsOfTypeString = (typeof value == 'string'); + + if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) { + throwBindingError('Cannot pass non-string to std::string'); + } + if (stdStringIsUTF8 && valueIsOfTypeString) { + length = lengthBytesUTF8(value); + } else { + length = value.length; + } + + // assumes 4-byte alignment + var base = _malloc(4 + length + 1); + var ptr = base + 4; + HEAPU32[((base)>>2)] = length; + if (stdStringIsUTF8 && valueIsOfTypeString) { + stringToUTF8(value, ptr, length + 1); + } else { + if (valueIsOfTypeString) { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(ptr); + throwBindingError('String has UTF-16 code units that do not fit in 8 bits'); + } + HEAPU8[ptr + i] = charCode; + } + } else { + for (var i = 0; i < length; ++i) { + HEAPU8[ptr + i] = value[i]; + } + } + } + + if (destructors !== null) { + destructors.push(_free, base); + } + return base; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: function(ptr) { _free(ptr); }, + }); + } + + + + + var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf-16le') : undefined;; + function UTF16ToString(ptr, maxBytesToRead) { + assert(ptr % 2 == 0, 'Pointer passed to UTF16ToString must be aligned to two bytes!'); + var endPtr = ptr; + // TextDecoder needs to know the byte length in advance, it doesn't stop on + // null terminator by itself. + // Also, use the length info to avoid running tiny strings through + // TextDecoder, since .subarray() allocates garbage. + var idx = endPtr >> 1; + var maxIdx = idx + maxBytesToRead / 2; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx; + endPtr = idx << 1; + + if (endPtr - ptr > 32 && UTF16Decoder) + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + + // Fallback: decode without UTF16Decoder + var str = ''; + + // If maxBytesToRead is not passed explicitly, it will be undefined, and the + // for-loop's condition will always evaluate to true. The loop is then + // terminated on the first null char. + for (var i = 0; !(i >= maxBytesToRead / 2); ++i) { + var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; + if (codeUnit == 0) break; + // fromCharCode constructs a character from a UTF-16 code unit, so we can + // pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + + return str; + } + + function stringToUTF16(str, outPtr, maxBytesToWrite) { + assert(outPtr % 2 == 0, 'Pointer passed to stringToUTF16 must be aligned to two bytes!'); + assert(typeof maxBytesToWrite == 'number', 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + HEAP16[((outPtr)>>1)] = codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr)>>1)] = 0; + return outPtr - startPtr; + } + + function lengthBytesUTF16(str) { + return str.length*2; + } + + function UTF32ToString(ptr, maxBytesToRead) { + assert(ptr % 4 == 0, 'Pointer passed to UTF32ToString must be aligned to four bytes!'); + var i = 0; + + var str = ''; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(i >= maxBytesToRead / 4)) { + var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; + if (utf32 == 0) break; + ++i; + // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + if (utf32 >= 0x10000) { + var ch = utf32 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } else { + str += String.fromCharCode(utf32); + } + } + return str; + } + + function stringToUTF32(str, outPtr, maxBytesToWrite) { + assert(outPtr % 4 == 0, 'Pointer passed to stringToUTF32 must be aligned to four bytes!'); + assert(typeof maxBytesToWrite == 'number', 'stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); + } + HEAP32[((outPtr)>>2)] = codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr)>>2)] = 0; + return outPtr - startPtr; + } + + function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. + len += 4; + } + + return len; + } + function __embind_register_std_wstring(rawType, charSize, name) { + name = readLatin1String(name); + var decodeString, encodeString, getHeap, lengthBytesUTF, shift; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + getHeap = () => HEAPU16; + shift = 1; + } else if (charSize === 4) { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + getHeap = () => HEAPU32; + shift = 2; + } + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + // Code mostly taken from _embind_register_std_string fromWireType + var length = HEAPU32[value >> 2]; + var HEAP = getHeap(); + var str; + + var decodeStartPtr = value + 4; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (i == length || HEAP[currentBytePtr >> shift] == 0) { + var maxReadBytes = currentBytePtr - decodeStartPtr; + var stringSegment = decodeString(decodeStartPtr, maxReadBytes); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + charSize; + } + } + + _free(value); + + return str; + }, + 'toWireType': function(destructors, value) { + if (!(typeof value == 'string')) { + throwBindingError(`Cannot pass non-string to C++ string type ${name}`); + } + + // assumes 4-byte alignment + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + HEAPU32[ptr >> 2] = length >> shift; + + encodeString(value, ptr + 4, length + charSize); + + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: function(ptr) { _free(ptr); }, + }); + } + + + + function __embind_register_value_object( + rawType, + name, + constructorSignature, + rawConstructor, + destructorSignature, + rawDestructor + ) { + structRegistrations[rawType] = { + name: readLatin1String(name), + rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), + rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), + fields: [], + }; + } + + + + function __embind_register_value_object_field( + structType, + fieldName, + getterReturnType, + getterSignature, + getter, + getterContext, + setterArgumentType, + setterSignature, + setter, + setterContext + ) { + structRegistrations[structType].fields.push({ + fieldName: readLatin1String(fieldName), + getterReturnType: getterReturnType, + getter: embind__requireFunction(getterSignature, getter), + getterContext: getterContext, + setterArgumentType: setterArgumentType, + setter: embind__requireFunction(setterSignature, setter), + setterContext: setterContext, + }); + } + + + function __embind_register_void(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + isVoid: true, // void return values can be optimized out sometimes + name: name, + 'argPackAdvance': 0, + 'fromWireType': function() { + return undefined; + }, + 'toWireType': function(destructors, o) { + // TODO: assert if anything else is given? + return undefined; + }, + }); + } + + function emval_allocateDestructors(destructorsRef) { + var destructors = []; + HEAPU32[((destructorsRef)>>2)] = Emval.toHandle(destructors); + return destructors; + } + + var emval_symbols = {}; + + function getStringOrSymbol(address) { + var symbol = emval_symbols[address]; + if (symbol === undefined) { + return readLatin1String(address); + } + return symbol; + } + + var emval_methodCallers = []; + + function __emval_call_method(caller, handle, methodName, destructorsRef, args) { + caller = emval_methodCallers[caller]; + handle = Emval.toValue(handle); + methodName = getStringOrSymbol(methodName); + return caller(handle, methodName, emval_allocateDestructors(destructorsRef), args); + } + + + + + function __emval_call_void_method(caller, handle, methodName, args) { + caller = emval_methodCallers[caller]; + handle = Emval.toValue(handle); + methodName = getStringOrSymbol(methodName); + caller(handle, methodName, null, args); + } + + + function emval_addMethodCaller(caller) { + var id = emval_methodCallers.length; + emval_methodCallers.push(caller); + return id; + } + + function emval_lookupTypes(argCount, argTypes) { + var a = new Array(argCount); + for (var i = 0; i < argCount; ++i) { + a[i] = requireRegisteredType(HEAPU32[(((argTypes)+(i * 4))>>2)], + "parameter " + i); + } + return a; + } + + + var emval_registeredMethods = []; + function __emval_get_method_caller(argCount, argTypes) { + var types = emval_lookupTypes(argCount, argTypes); + var retType = types[0]; + var signatureName = retType.name + "_$" + types.slice(1).map(function (t) { return t.name; }).join("_") + "$"; + var returnId = emval_registeredMethods[signatureName]; + if (returnId !== undefined) { + return returnId; + } + + var argN = new Array(argCount - 1); + var invokerFunction = (handle, name, destructors, args) => { + var offset = 0; + for (var i = 0; i < argCount - 1; ++i) { + argN[i] = types[i + 1]['readValueFromPointer'](args + offset); + offset += types[i + 1]['argPackAdvance']; + } + var rv = handle[name].apply(handle, argN); + for (var i = 0; i < argCount - 1; ++i) { + if (types[i + 1].deleteObject) { + types[i + 1].deleteObject(argN[i]); + } + } + if (!retType.isVoid) { + return retType['toWireType'](destructors, rv); + } + }; + returnId = emval_addMethodCaller(invokerFunction); + emval_registeredMethods[signatureName] = returnId; + return returnId; + } + + function __emval_incref(handle) { + if (handle > 4) { + emval_handles.get(handle).refcount += 1; + } + } + + + + function __emval_run_destructors(handle) { + var destructors = Emval.toValue(handle); + runDestructors(destructors); + __emval_decref(handle); + } + + + function __emval_take_value(type, arg) { + type = requireRegisteredType(type, '_emval_take_value'); + var v = type['readValueFromPointer'](arg); + return Emval.toHandle(v); + } + + function _abort() { + abort('native code called abort()'); + } + + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.copyWithin(dest, src, src + num); + } + + function getHeapMax() { + // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate + // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side + // for any code that deals with heap sizes, which would require special + // casing all heap size related code to treat 0 specially. + return 2147483648; + } + + function emscripten_realloc_buffer(size) { + var b = wasmMemory.buffer; + var pages = (size - b.byteLength + 65535) >>> 16; + try { + // round size grow request up to wasm page size (fixed 64KB per spec) + wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size + updateMemoryViews(); + return 1 /*success*/; + } catch(e) { + err(`emscripten_realloc_buffer: Attempted to grow heap from ${b.byteLength} bytes to ${size} bytes, but got error: ${e}`); + } + // implicit 0 return to save code size (caller will cast "undefined" into 0 + // anyhow) + } + function _emscripten_resize_heap(requestedSize) { + var oldSize = HEAPU8.length; + requestedSize = requestedSize >>> 0; + // With multithreaded builds, races can happen (another thread might increase the size + // in between), so return a failure, and let the caller retry. + assert(requestedSize > oldSize); + + // Memory resize rules: + // 1. Always increase heap size to at least the requested size, rounded up + // to next page multiple. + // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap + // geometrically: increase the heap size according to + // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most + // overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB). + // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap + // linearly: increase the heap size by at least + // MEMORY_GROWTH_LINEAR_STEP bytes. + // 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by + // MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest + // 4. If we were unable to allocate as much memory, it may be due to + // over-eager decision to excessively reserve due to (3) above. + // Hence if an allocation fails, cut down on the amount of excess + // growth, in an attempt to succeed to perform a smaller allocation. + + // A limit is set for how much we can grow. We should not exceed that + // (the wasm binary specifies it, so if we tried, we'd fail anyhow). + var maxHeapSize = getHeapMax(); + if (requestedSize > maxHeapSize) { + err(`Cannot enlarge memory, asked to go up to ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`); + return false; + } + + var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple; + + // Loop through potential heap size increases. If we attempt a too eager + // reservation that fails, cut down on the attempted size and reserve a + // smaller bump instead. (max 3 times, chosen somewhat arbitrarily) + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth + // but limit overreserving (default to capping at +96MB overgrowth at most) + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 ); + + var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536)); + + var replacement = emscripten_realloc_buffer(newSize); + if (replacement) { + + return true; + } + } + err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`); + return false; + } + + function _fd_close(fd) { + abort('fd_close called without SYSCALLS_REQUIRE_FILESYSTEM'); + } + + function _fd_read(fd, iov, iovcnt, pnum) { + abort('fd_read called without SYSCALLS_REQUIRE_FILESYSTEM'); + } + + function convertI32PairToI53Checked(lo, hi) { + assert(lo == (lo >>> 0) || lo == (lo|0)); // lo should either be a i32 or a u32 + assert(hi === (hi|0)); // hi should be a i32 + return ((hi + 0x200000) >>> 0 < 0x400001 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN; + } + + + + + function _fd_seek(fd, offset_low, offset_high, whence, newOffset) { + return 70; + } + + var printCharBuffers = [null,[],[]]; + + function printChar(stream, curr) { + var buffer = printCharBuffers[stream]; + assert(buffer); + if (curr === 0 || curr === 10) { + (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0)); + buffer.length = 0; + } else { + buffer.push(curr); + } + } + + function flush_NO_FILESYSTEM() { + // flush anything remaining in the buffers during shutdown + _fflush(0); + if (printCharBuffers[1].length) printChar(1, 10); + if (printCharBuffers[2].length) printChar(2, 10); + } + + + function _fd_write(fd, iov, iovcnt, pnum) { + // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0 + var num = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + for (var j = 0; j < len; j++) { + printChar(fd, HEAPU8[ptr+j]); + } + num += len; + } + HEAPU32[((pnum)>>2)] = num; + return 0; + } +BindingError = Module['BindingError'] = extendError(Error, 'BindingError');; +init_emval();; +PureVirtualError = Module['PureVirtualError'] = extendError(Error, 'PureVirtualError');; +embind_init_charCodes(); +init_embind();; +InternalError = Module['InternalError'] = extendError(Error, 'InternalError');; +init_ClassHandle(); +init_RegisteredPointer(); +UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');; +function checkIncomingModuleAPI() { + ignoredModuleProp('fetchSettings'); +} +var wasmImports = { + "__assert_fail": ___assert_fail, + "__syscall_fcntl64": ___syscall_fcntl64, + "__syscall_ioctl": ___syscall_ioctl, + "__syscall_openat": ___syscall_openat, + "_embind_create_inheriting_constructor": __embind_create_inheriting_constructor, + "_embind_finalize_value_object": __embind_finalize_value_object, + "_embind_register_bigint": __embind_register_bigint, + "_embind_register_bool": __embind_register_bool, + "_embind_register_class": __embind_register_class, + "_embind_register_class_class_function": __embind_register_class_class_function, + "_embind_register_class_constructor": __embind_register_class_constructor, + "_embind_register_class_function": __embind_register_class_function, + "_embind_register_class_property": __embind_register_class_property, + "_embind_register_constant": __embind_register_constant, + "_embind_register_emval": __embind_register_emval, + "_embind_register_enum": __embind_register_enum, + "_embind_register_enum_value": __embind_register_enum_value, + "_embind_register_float": __embind_register_float, + "_embind_register_function": __embind_register_function, + "_embind_register_integer": __embind_register_integer, + "_embind_register_memory_view": __embind_register_memory_view, + "_embind_register_std_string": __embind_register_std_string, + "_embind_register_std_wstring": __embind_register_std_wstring, + "_embind_register_value_object": __embind_register_value_object, + "_embind_register_value_object_field": __embind_register_value_object_field, + "_embind_register_void": __embind_register_void, + "_emval_call_method": __emval_call_method, + "_emval_call_void_method": __emval_call_void_method, + "_emval_decref": __emval_decref, + "_emval_get_method_caller": __emval_get_method_caller, + "_emval_incref": __emval_incref, + "_emval_run_destructors": __emval_run_destructors, + "_emval_take_value": __emval_take_value, + "abort": _abort, + "emscripten_memcpy_big": _emscripten_memcpy_big, + "emscripten_resize_heap": _emscripten_resize_heap, + "fd_close": _fd_close, + "fd_read": _fd_read, + "fd_seek": _fd_seek, + "fd_write": _fd_write +}; +var asm = createWasm(); +/** @type {function(...*):?} */ +var ___wasm_call_ctors = createExportWrapper("__wasm_call_ctors"); +/** @type {function(...*):?} */ +var _malloc = createExportWrapper("malloc"); +/** @type {function(...*):?} */ +var _free = createExportWrapper("free"); +/** @type {function(...*):?} */ +var ___getTypeName = createExportWrapper("__getTypeName"); +/** @type {function(...*):?} */ +var __embind_initialize_bindings = Module["__embind_initialize_bindings"] = createExportWrapper("_embind_initialize_bindings"); +/** @type {function(...*):?} */ +var ___errno_location = createExportWrapper("__errno_location"); +/** @type {function(...*):?} */ +var _fflush = Module["_fflush"] = createExportWrapper("fflush"); +/** @type {function(...*):?} */ +var _emscripten_stack_init = function() { + return (_emscripten_stack_init = Module["asm"]["emscripten_stack_init"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _emscripten_stack_get_free = function() { + return (_emscripten_stack_get_free = Module["asm"]["emscripten_stack_get_free"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _emscripten_stack_get_base = function() { + return (_emscripten_stack_get_base = Module["asm"]["emscripten_stack_get_base"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _emscripten_stack_get_end = function() { + return (_emscripten_stack_get_end = Module["asm"]["emscripten_stack_get_end"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var stackSave = createExportWrapper("stackSave"); +/** @type {function(...*):?} */ +var stackRestore = createExportWrapper("stackRestore"); +/** @type {function(...*):?} */ +var stackAlloc = createExportWrapper("stackAlloc"); +/** @type {function(...*):?} */ +var _emscripten_stack_get_current = function() { + return (_emscripten_stack_get_current = Module["asm"]["emscripten_stack_get_current"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji"); + + +// include: postamble.js +// === Auto-generated postamble setup entry stuff === + +var missingLibrarySymbols = [ + 'zeroMemory', + 'exitJS', + 'isLeapYear', + 'ydayFromDate', + 'arraySum', + 'addDays', + 'inetPton4', + 'inetNtop4', + 'inetPton6', + 'inetNtop6', + 'readSockaddr', + 'writeSockaddr', + 'getHostByName', + 'initRandomFill', + 'randomFill', + 'traverseStack', + 'getCallstack', + 'emscriptenLog', + 'convertPCtoSourceLocation', + 'readEmAsmArgs', + 'jstoi_q', + 'jstoi_s', + 'getExecutableName', + 'listenOnce', + 'autoResumeAudioContext', + 'handleException', + 'runtimeKeepalivePush', + 'runtimeKeepalivePop', + 'callUserCallback', + 'maybeExit', + 'safeSetTimeout', + 'asmjsMangle', + 'asyncLoad', + 'alignMemory', + 'mmapAlloc', + 'getNativeTypeSize', + 'STACK_SIZE', + 'STACK_ALIGN', + 'POINTER_SIZE', + 'ASSERTIONS', + 'writeI53ToI64', + 'writeI53ToI64Clamped', + 'writeI53ToI64Signaling', + 'writeI53ToU64Clamped', + 'writeI53ToU64Signaling', + 'readI53FromI64', + 'readI53FromU64', + 'convertI32PairToI53', + 'convertU32PairToI53', + 'getCFunc', + 'ccall', + 'cwrap', + 'uleb128Encode', + 'sigToWasmTypes', + 'generateFuncType', + 'convertJsFunctionToWasm', + 'getEmptyTableSlot', + 'updateTableMap', + 'getFunctionAddress', + 'addFunction', + 'removeFunction', + 'reallyNegative', + 'unSign', + 'strLen', + 'reSign', + 'formatString', + 'intArrayFromString', + 'intArrayToString', + 'AsciiToString', + 'stringToAscii', + 'stringToNewUTF8', + 'stringToUTF8OnStack', + 'writeArrayToMemory', + 'registerKeyEventCallback', + 'maybeCStringToJsString', + 'findEventTarget', + 'findCanvasEventTarget', + 'getBoundingClientRect', + 'fillMouseEventData', + 'registerMouseEventCallback', + 'registerWheelEventCallback', + 'registerUiEventCallback', + 'registerFocusEventCallback', + 'fillDeviceOrientationEventData', + 'registerDeviceOrientationEventCallback', + 'fillDeviceMotionEventData', + 'registerDeviceMotionEventCallback', + 'screenOrientation', + 'fillOrientationChangeEventData', + 'registerOrientationChangeEventCallback', + 'fillFullscreenChangeEventData', + 'registerFullscreenChangeEventCallback', + 'JSEvents_requestFullscreen', + 'JSEvents_resizeCanvasForFullscreen', + 'registerRestoreOldStyle', + 'hideEverythingExceptGivenElement', + 'restoreHiddenElements', + 'setLetterbox', + 'softFullscreenResizeWebGLRenderTarget', + 'doRequestFullscreen', + 'fillPointerlockChangeEventData', + 'registerPointerlockChangeEventCallback', + 'registerPointerlockErrorEventCallback', + 'requestPointerLock', + 'fillVisibilityChangeEventData', + 'registerVisibilityChangeEventCallback', + 'registerTouchEventCallback', + 'fillGamepadEventData', + 'registerGamepadEventCallback', + 'registerBeforeUnloadEventCallback', + 'fillBatteryEventData', + 'battery', + 'registerBatteryEventCallback', + 'setCanvasElementSize', + 'getCanvasElementSize', + 'demangle', + 'demangleAll', + 'jsStackTrace', + 'stackTrace', + 'getEnvStrings', + 'checkWasiClock', + 'wasiRightsToMuslOFlags', + 'wasiOFlagsToMuslOFlags', + 'createDyncallWrapper', + 'setImmediateWrapped', + 'clearImmediateWrapped', + 'polyfillSetImmediate', + 'getPromise', + 'makePromise', + 'idsToPromises', + 'makePromiseCallback', + 'setMainLoop', + 'getSocketFromFD', + 'getSocketAddress', + 'heapObjectForWebGLType', + 'heapAccessShiftForWebGLHeap', + 'webgl_enable_ANGLE_instanced_arrays', + 'webgl_enable_OES_vertex_array_object', + 'webgl_enable_WEBGL_draw_buffers', + 'webgl_enable_WEBGL_multi_draw', + 'emscriptenWebGLGet', + 'computeUnpackAlignedImageSize', + 'colorChannelsInGlTextureFormat', + 'emscriptenWebGLGetTexPixelData', + '__glGenObject', + 'emscriptenWebGLGetUniform', + 'webglGetUniformLocation', + 'webglPrepareUniformLocationsBeforeFirstUse', + 'webglGetLeftBracePos', + 'emscriptenWebGLGetVertexAttrib', + '__glGetActiveAttribOrUniform', + 'writeGLArray', + 'registerWebGlEventCallback', + 'runAndAbortIfError', + 'SDL_unicode', + 'SDL_ttfContext', + 'SDL_audio', + 'GLFW_Window', + 'ALLOC_NORMAL', + 'ALLOC_STACK', + 'allocate', + 'writeStringToMemory', + 'writeAsciiToMemory', + 'craftEmvalAllocator', + 'emval_get_global', +]; +missingLibrarySymbols.forEach(missingLibrarySymbol) + +var unexportedSymbols = [ + 'run', + 'addOnPreRun', + 'addOnInit', + 'addOnPreMain', + 'addOnExit', + 'addOnPostRun', + 'addRunDependency', + 'removeRunDependency', + 'FS_createFolder', + 'FS_createPath', + 'FS_createDataFile', + 'FS_createLazyFile', + 'FS_createLink', + 'FS_createDevice', + 'FS_unlink', + 'out', + 'err', + 'callMain', + 'abort', + 'keepRuntimeAlive', + 'wasmMemory', + 'stackAlloc', + 'stackSave', + 'stackRestore', + 'getTempRet0', + 'setTempRet0', + 'writeStackCookie', + 'checkStackCookie', + 'ptrToString', + 'getHeapMax', + 'emscripten_realloc_buffer', + 'ENV', + 'MONTH_DAYS_REGULAR', + 'MONTH_DAYS_LEAP', + 'MONTH_DAYS_REGULAR_CUMULATIVE', + 'MONTH_DAYS_LEAP_CUMULATIVE', + 'ERRNO_CODES', + 'ERRNO_MESSAGES', + 'setErrNo', + 'DNS', + 'Protocols', + 'Sockets', + 'timers', + 'warnOnce', + 'UNWIND_CACHE', + 'readEmAsmArgsArray', + 'dynCallLegacy', + 'getDynCaller', + 'dynCall', + 'HandleAllocator', + 'convertI32PairToI53Checked', + 'freeTableIndexes', + 'functionsInTableMap', + 'setValue', + 'getValue', + 'PATH', + 'PATH_FS', + 'UTF8Decoder', + 'UTF8ArrayToString', + 'UTF8ToString', + 'stringToUTF8Array', + 'stringToUTF8', + 'lengthBytesUTF8', + 'UTF16Decoder', + 'UTF16ToString', + 'stringToUTF16', + 'lengthBytesUTF16', + 'UTF32ToString', + 'stringToUTF32', + 'lengthBytesUTF32', + 'JSEvents', + 'specialHTMLTargets', + 'currentFullscreenStrategy', + 'restoreOldWindowedStyle', + 'ExitStatus', + 'flush_NO_FILESYSTEM', + 'dlopenMissingError', + 'promiseMap', + 'Browser', + 'wget', + 'SYSCALLS', + 'tempFixedLengthArray', + 'miniTempWebGLFloatBuffers', + 'miniTempWebGLIntBuffers', + 'GL', + 'emscripten_webgl_power_preferences', + 'AL', + 'GLUT', + 'EGL', + 'GLEW', + 'IDBStore', + 'SDL', + 'SDL_gfx', + 'GLFW', + 'allocateUTF8', + 'allocateUTF8OnStack', + 'InternalError', + 'BindingError', + 'UnboundTypeError', + 'PureVirtualError', + 'init_embind', + 'throwInternalError', + 'throwBindingError', + 'throwUnboundTypeError', + 'ensureOverloadTable', + 'exposePublicSymbol', + 'replacePublicSymbol', + 'extendError', + 'createNamedFunction', + 'embindRepr', + 'registeredInstances', + 'getBasestPointer', + 'registerInheritedInstance', + 'unregisterInheritedInstance', + 'getInheritedInstance', + 'getInheritedInstanceCount', + 'getLiveInheritedInstances', + 'registeredTypes', + 'awaitingDependencies', + 'typeDependencies', + 'registeredPointers', + 'registerType', + 'whenDependentTypesAreResolved', + 'embind_charCodes', + 'embind_init_charCodes', + 'readLatin1String', + 'getTypeName', + 'heap32VectorToArray', + 'requireRegisteredType', + 'getShiftFromSize', + 'integerReadValueFromPointer', + 'enumReadValueFromPointer', + 'floatReadValueFromPointer', + 'simpleReadValueFromPointer', + 'runDestructors', + 'craftInvokerFunction', + 'embind__requireFunction', + 'tupleRegistrations', + 'structRegistrations', + 'genericPointerToWireType', + 'constNoSmartPtrRawPointerToWireType', + 'nonConstNoSmartPtrRawPointerToWireType', + 'init_RegisteredPointer', + 'RegisteredPointer', + 'RegisteredPointer_getPointee', + 'RegisteredPointer_destructor', + 'RegisteredPointer_deleteObject', + 'RegisteredPointer_fromWireType', + 'runDestructor', + 'releaseClassHandle', + 'finalizationRegistry', + 'detachFinalizer_deps', + 'detachFinalizer', + 'attachFinalizer', + 'makeClassHandle', + 'init_ClassHandle', + 'ClassHandle', + 'ClassHandle_isAliasOf', + 'throwInstanceAlreadyDeleted', + 'ClassHandle_clone', + 'ClassHandle_delete', + 'deletionQueue', + 'ClassHandle_isDeleted', + 'ClassHandle_deleteLater', + 'flushPendingDeletes', + 'delayFunction', + 'setDelayFunction', + 'RegisteredClass', + 'shallowCopyInternalPointer', + 'downcastPointer', + 'upcastPointer', + 'validateThis', + 'char_0', + 'char_9', + 'makeLegalFunctionName', + 'emval_handles', + 'emval_symbols', + 'init_emval', + 'count_emval_handles', + 'getStringOrSymbol', + 'Emval', + 'emval_newers', + 'emval_lookupTypes', + 'emval_allocateDestructors', + 'emval_methodCallers', + 'emval_addMethodCaller', + 'emval_registeredMethods', +]; +unexportedSymbols.forEach(unexportedRuntimeSymbol); + + + +var calledRun; + +dependenciesFulfilled = function runCaller() { + // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false) + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled +}; + +function stackCheckInit() { + // This is normally called automatically during __wasm_call_ctors but need to + // get these values before even running any of the ctors so we call it redundantly + // here. + _emscripten_stack_init(); + // TODO(sbc): Move writeStackCookie to native to to avoid this. + writeStackCookie(); +} + +function run() { + + if (runDependencies > 0) { + return; + } + + stackCheckInit(); + + preRun(); + + // a preRun added a dependency, run will be called later + if (runDependencies > 0) { + return; + } + + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + if (calledRun) return; + calledRun = true; + Module['calledRun'] = true; + + if (ABORT) return; + + initRuntime(); + + readyPromiseResolve(Module); + if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); + + assert(!Module['_main'], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]'); + + postRun(); + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + } else + { + doRun(); + } + checkStackCookie(); +} + +function checkUnflushedContent() { + // Compiler settings do not allow exiting the runtime, so flushing + // the streams is not possible. but in ASSERTIONS mode we check + // if there was something to flush, and if so tell the user they + // should request that the runtime be exitable. + // Normally we would not even include flush() at all, but in ASSERTIONS + // builds we do so just for this check, and here we see if there is any + // content to flush, that is, we check if there would have been + // something a non-ASSERTIONS build would have not seen. + // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0 + // mode (which has its own special function for this; otherwise, all + // the code is inside libc) + var oldOut = out; + var oldErr = err; + var has = false; + out = err = (x) => { + has = true; + } + try { // it doesn't matter if it fails + flush_NO_FILESYSTEM(); + } catch(e) {} + out = oldOut; + err = oldErr; + if (has) { + warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc.'); + warnOnce('(this may also be due to not including full filesystem support - try building with -sFORCE_FILESYSTEM)'); + } +} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + +run(); + + +// end include: postamble.js + + + return BOX2D.ready +} + +); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = BOX2D; +else if (typeof define === 'function' && define['amd']) + define([], function() { return BOX2D; }); +else if (typeof exports === 'object') + exports["BOX2D"] = BOX2D; diff --git a/emscripten/box2d/box2d.debug.wasm.wasm b/emscripten/box2d/box2d.debug.wasm.wasm new file mode 100644 index 0000000000000000000000000000000000000000..37fd8d20fb3ee3e45bf9f750d0f9e38e7856ba69 GIT binary patch literal 4124286 zcmeEv31E$BmiGO=``slW$!E{KH1BaONi4lr@7?oF&%W>bjIORy-O{xUp{D1rB?y8b z2!bF8f*=TjAP9mW2!bF8f*=Tj;D63}b1Sr}?*3={r)R3>)^nb7p7WmfyzjT%@7}uU zalJa^EyLw<8QZKs{DJY2@zD=l_}BdCBNqdx0p|XQeMST<7=e!#f`9P_Y_ z1Z~3ur055by&^+Loe!ky2N>!W-mEo`k?==6#{JQU9~mFY2m}odnIAA3?*lN=2hII` zfT1$)b2A|$QqQUT@-;in3qlbdg-X0MDdhR+gAaH;yi%F#{f~_I(fIp35@{y7;p7iL zME_CE<+O4Az#sOd{`;;UM1%t^d-6W--ut|0o?5S(C*sz5PdFl-fIQ!d&XwMDs_t2; z;0VBTe<1s!$H{~U=v`s*@lpAJ*UEnLZpbn}kmLP6It%X+SNu?)2Jhnlm>+%!5!)h% zgIoCUL*6DyG51Eqxd*;ItmA-zZ~bu4+piB8Jn%<@h9nIfJm9rAUmY^U)sMxVpDgN> z0dEX_`?aJ&@4W5m&$-<`CHLLI@4P#3aMDj*#94utv)*}oNYblsC%HcV$@<5$bZ5Q8 zOXCN=J@hS?kG0O9s0|qQ>YGCcx;&imxtB6T9PrK$69>MQP8^40`+3HwXReKs{Bsn#I+k1`NP%V*LZ&cy-X5x=+umKYV9!k}HDs?k~+I+dtqn z-j%^aUrTytux{(qw)f-h`GTHq;9FSIfI)A+HhAD0uI3hW?Dc^yu{M~N^O9cuNpsgO zH;@1LfFt$Qq=BgOsXAx8*PJ3J z-pez{DnD)fTLa&EXYfx43>!4?J>5iyfo~0YZSbIXlLo$x-F)k{cYiwIhl75kHG9B- zAwL}=M*&yb+vq!n*W9Kh{KjipPIlWUVHPMAp>15IkwNOV(`Ere8v2D z;H&Rykx!==j}cag!{qAzb7mhhaNti|(eC0dTf0O=;EJ+d{KsrvDVf-)7TdBV2}I8TuddW5uXoqh(r`#ai<}lBX-7XU=OKX&|{d z&f~c$`Nwj5UQE|D!aB+}%N+kW$|YJyy0|p|8(t!ZKYqE*7!2XV;BVz`g@!*Kt%sp0 z43@FzL{G~Fut2VYfj%6{_NLF%-tU*P9@E4Ba5;Y~o=4AxBO6|l93(6Wk4(^T#6PYt zz8(?o7RMAix(GLh9DUZb^0yp@7jvY|j|=<~+6x`Hunzpg%lX+FFXVlCT6h>Q2YdT+ zo#wSb$LY^I|Kdz9EEq|=iPDeZ`cep|aRC3~boO|l;M{gax?HVVyIfociiL}bqb`={1pUU~fNB(-IKv;Pt$VAv&%JP!hstn#b+tfTz8l+ts7B*&5w? z+FKmJVfP!Zpgb^t86KbEojZ$Rz+ye7+l?jg5?$^XtO+Y|S$xfVa07@zhGlWga3hG7 z@n(R4MexF-ygr}LgEtYkhh5xYBd~T^F^2Jthx0KN- zmub0TSZrzX5W-FW*z-`LG#|6YE0z$Ze zVO)F}0}#avH&oMQ;SRzjSoC^%u{}Y}o`wlmZ;^INF@;C!{k6McA{;Y0_>nUYK zyShMce7w2173(rMI6k-6{(6B$0A-Y&g!x<}ECD5!XSm5uR= zAVPW_pSTH@FUr?8>T_*;QKqLYCX9-b1I0}m&D?0y1{;JTVINKCZe+K(FTI~GqX)+g zT;JiH=xd){&{pz}*DcDpDHu3-Uk?;vndWf2Kn7yePmqJds|L^dP4=rg=FD zF+`tB)obwh_%d}FKQl&(;m+wYzJ`DK|H5tQEiv`Y0`Ha0J@A0=F=*L{7RD!-95ZQw zk0xr0%v+!jm~KvjE%UWwxp|E)IfC+GtMY!CGT*!9hUUxR)4KonjKx05Hia*OpSK6kb*eY)QQ~Ner~ZMJf7CBZ{h7S0=G;Hh}#O@EAWhn%gc-R5Fg&AamMlO-rW_Cx{(+Z6%}oI zeJ;xr6@@!HpRAr}Ga3Pn5k6QM5@EUU!doi8Kf7^rcJnFBn-JkPziqm|W15k+1s@~1 zphg!zZTj%`&kyPRLJrm;Z|-65yKV^I`!zJxoFPx5cr@Y<83?*T`2U(!w9s5U%4wr# z!9ZLRzm6qF+I~MCcKz+}QKc2P^KntE^*N8T>{hKL^~E?(iO)B8#?LK{?yb0#-xMJlN z5aH$9pw+kU@1lRXi}9hsBO^aP$y+dFw1f%p7|M6dmWM9ffN@A6d0_a=#QB2{L2g+V zFAcqTy)k%5^SOOqD{|_vm@vc$jtMYk#hLLP0 zC!5}quderhWH`ymRx23S^Wb9Fm@Fs3aKRCRBL!0gM+uG=93z-2I970+;CR6_!3lyB1t$rn3r-fCA~;nr zLvWhlbio;dnSwI~X9><0%o3ao z6@n`TR|)0|t`=M)xK^-0aGl_K!3~0if*S=l32qiF65JxVRdAbNvEX*W9fCUrO9Xcb z?iSo5SSq+zaG&6Q!7{-Ef(Hc;36={U7Ca(&RIozunBZ~26M~h3Ck0Olo))YUJR^8k z@SI?^;CaCdf)@pA1TP6*7Q7-@D|l7#n&5T8I>8%)HwAAA)(hSiyd!v5utD&i;C;ad zf{lU?1s@4M7HkrHBKTDBnP9TXccI~eBLqhZrU;G_94$CTFja7@;5fnYf@y*i1Sbkk z5=!TEv<1Q!bC2rd#_EVx84 zS8%D|GQs77d4ekhR|>8Y%okiOxJGcTV1eK|!S#Y01PcW>3T_hIELbGCMR2R&Ho;=S z?SeZ5cM6sW?h@QBxJR&5aIfG#!To||f(HZ-3LX+H7d$L@MDVC!h2Sy4wzTg7Eg@QSPiv*Vn zE)!fXm?yYGaHZfX!F<8hf@=iV3Kj^i6I?I2L9kG8qu?gN&4NXOTLiZXZWAmP+%C97 zaHn92;4Z=4f_nr@1@{W>6WlLYCU`*bpx`0Fa>2ubM+A=wo~*|spUbJeE#{gw6(SuI zJT7=buu`y8580~CNr{~jJS|uyct-H7;5or+!SjL_1TPBK2woDrEOSa6>=aJxJ!6v~cf=>mX3Gy>C-US3l z2#yp?5ga8rT5ycuVLd^aHmMRDD>zPYykMH(1i^`dlLXTRCksvyoGO?hI8AW6;0(b` z!I^@y1ZN9o3CzRuTX4SM0>OoXIf9D>7Yi;C%oSWJxJ+=lV4mO#!Igrm1oH(~ z3$77dD_9`7PH?^82EjtXje?s5HwzXCZV}unxJ|HFaJ%3R!JUF7g1ZEF3+@pt72GSh zPjJ6rncxAzgMxg0}?qS*I`SI}*7o*dTaM@V?*!!A8M{f{z3r z3pNQp5qv86OfXqK5e^p|AvjVnMR1hhXu&apse)q##|e%XOcR_SI8kttV7lOB!6|}M z1v3Pv2~HQBA($yRQ*f5xY{4wSIf8Qq=Lu#D&KF!DxKJ=haFO6*!6kyZf=dOL2`(4R z6I>ya}UoCPmMhrcH)6+1li3ldnyoHpSYMYE!OF zwKnzIG-z`}pP|WmMd{jPYBO4|EMI$Nx|ejlUBx&)n2(amD*HmQ>#sp-nx8k>UFSDn^e8`ncAf4V^F5ON^NSjY1AfJr(|i9uT9+r zIYzbGl;~iC_Ug4M)xmOYYMRGs)1=K>eNCt9Qy@j31Et!l(56P425p+O$<+BE6; z8nr3b!3u4vw5e;()Fyq0G+(SunKrfBWayKxQhN>Br08IpHU-*LXp?eLiY05)po3}J zOVy@H2UANVGhLf(ZSu7#(q@{zrIl+hOMCU&Td2MCT~Z}qn-XpEc1y5cdrjJ;>0p*N zIoecelc76HZ#H{mc$W4uwaM1OoMum(d>zcwUamIfI#|%0qD{39)@oC)O>(K;0&Oz1 z$=lbwJF!8TASp(GCWnAOl@+t$=9Yxn^JAcwMpA2<1)1=(q@u=%P7}gy*A1F zB{M^tY;AJ2DbS`!n-Xm*w5idiPMhR1sZyY4NY`GzHv5{V)n2_eP1=;C$hedPx(RL4 zbTCJIx!RO#)1XcAK^c&)O};ke+N6#Wty+8a+9V&6V461B+T?3fu1$Tjr-vt(>lw7k z(7|l&_eO{O;4+T?0epiPN3 z70up6-KX|ywQ1BQ`Lt-M+N5iftxdi*McR~VQ?5;wHg(!GX;VK*iX~TxN!KP@n_O-3 zwJFr5T$^fb>a=OpCi#q1Nz*1vn>=kw(nZVHUa>ai+Ei*&qfNawP1>ZK)it%r)FxM( z!sg&)Nh#7^nKo70)M!(uO`|r+=X6bNvb4$5rcM{j*IuzU<=RwgQ>{&{HVxV&SL>QE zz8bTwSO1>Wbm2Fl_^sz#@=M$S{M+IouDHMe{L1(BL4)xF=#PKVjo$_T@XdjS%lj67 zvir_!u1lS*HwF(J=(^k)zh}lTdjI05?+*Nj>6+Z%h?I&nuP?D>%OW?U* zifVy>M=U*@{1owrui|H>r@F*`;>dw-zwSESB|=L5`K!YQx~jUg7U$3K6XSOV4|JXB z5-GkT>pk10%O{q3ZRp^^1M!p8b6r}${?oU=&p&)l9F#c7b+Jptm>7fqgWzdjpYMFn z`TlSI_V51wAN=7T|H+^J*(YS8Z8MlnvMuTy-)45L7 zoz8bkHb-!N~P_2xtK^P}BgNOK?Uw5L;P zr!4oE7r1lXOWn)edG1y2e0PC+gL|`ki#s_`?0yov)BQAdx4YE6&t2v|=q`63aUXS8 zxR1GyyN3r(xxZNLzTm#-zU;o@zUsc_u5;gT*So(oDKki2wU$|V z)=F!Ym2a)Krp2zYrpK+Hc${)7sv~& z2&@dO3gib?2Nrr3dzN|fJS#k_Jo%orp08~R6a}^fwg$EZiUZpNI|AE0J3PBRrJlW> z{hl(??&%tZ;^MK_nW)Cd%UIIecm$f z0q;TYVQ+=E(tFB#+Iz-()?4j8@2&BE>zcRDd&9dsxF=W|+#9^(-50#;-5)Fq9ta)` z9tuA6KJgCsjq;84P4G?j&G60h<@lER@_hNewY~!1I^PE0Cf`=yPTwwHsc)}uzpu=9 z$XD(=>^tf^?mOi>=R5Da=&SKv_FeH^^pR!Ne=j==NHT#y`U_Z2<*~x82wHenYz0I^X zbK5LzliOxRn>B4Vv?*${r%hR#iZ&P9Ty1l!O+%Z9ZJxFn**3N9gtk-KX11Nvc0t=E zZCAA2&~|6reQnFz9&3B5ZFSpAZLhVx)wZGS!?sV`rnDQ|ZgRWn?Pj;jZnvo2vUaQ5 z6|~#hZg;zb?as8j*siwSjdpk2J#6>1T}t~=?Z>rGZ$G*HwDz;x&u_oDeO~(&?boy~ zY`?Mnmi9Z_?`?mu{n7R(+n;KGuKlI z$9J66aazY&9p`mi)NxtI{En+TuJ2gXaZAVT9rtuB>v*JNWyg~p&vvZoc&X#nj<-5C zbbQ$HS;v%4V>|7OsE9ZfaXz9p;z2}pfqc%qsMQw@N8nrEIQ&e%(?C3esbEC7P=SMG$UKG6~dTDf4bYAp&dxJf*)2vRD zI!);`wNpl?8J#ja?d(+2X>+Hoowju?{v7+^5_el zvSR1N&W)WHyCQaF?5f!O*tM|*vFl>j$IgnK9eXfvC~zWB8Mq!>7kfMQPVDm7yx7&T zYht&>7RT<0-4%Nw_F`;J?4{Vtu~%Z}1!`lj#h!^h7h4^BBlc$Ot=Rh5yRi+i_hRqI zjt-0oqz1+Y#s$U)(gGs`DS=UejKH+O^uUZjW?*JuR$x+Ka$ss;LEvia!a#0dX<%7k zd0>5DL!dCQD6lxNB(OWMCr}#L8`vM%7bpuH2L$ENoF}NwXIan0j5?mR~53UdH z2<{A)1a}3?gNK7hf=7efg2ln@!JVJ)TOjbQI~yPA~TMDd25$W zF1xaeJ+YHr)yb~wWS@?;=XJKLJGbiQ=D(UWK60urc*qs9$WVrIC6cL3J0Td;>K`Mt z{yc_UWH>fb3}ya=+{)dqJmghgy!HND#{8n4`Om2Ni{|`~)c-C0|4$ebUPIWn>}fa>w*NWG%hg-v z`TxUS?np=eeer)=jsHJ8@Uyf2ax4F&75>{}FVFe2U463u^0OQ z`{I##G0Ivv61FWpg(G46U#o;?4clMUb^O2Y@rx^N+4axZXFKrk*?||&s~5d+-EcH) zb^Jw-W8p~HhR1)V{O{SFmyi8tXG?fb!uG%Rx(Lr2w*R%W|Ia$}U*5x(-TdFfUfzXp zBy9CwguSqRKKf#e6&?AHiihhxe^g$c;pN$$&;N}7q8<3;{R>CKwxvoq61M;Sl;=Bp zp0{-R8T(~+;FI?*91Yu+O5sS@{?AaJU(NHpWp)3X*(dKvI2yJsI~0zDtyaQb*#5jI zYvH`G{YCYEnK94TdY-q`{*3)^*@2gje>f7hdMCnO*tYCXI1;v>DJ?tjpL6}TRBf3_ z@BZ`0;CbGX_Zj~mY=2&qwQye8{=EEfPT2lx=6?FBe;MWZwLj1G zUi{C*m)9ANgson;_I}w|%emLGYvHkB`-_y9XMA~NOO4N1%MQG}PvJ<|>fEpww*M8; z=jVE!w{-s*`=7r9FCY1EBy9gH&c&a-ONHkS+h2_yp6~W!jvwE z{T?o-qRb*Ue!XwuxAyKt{QBODU*CI_*Z#I+;RpC$Lvm03v$cRX!NENC4Q2o>j zYO6$Q?OcEw1vM&>qE)nNZGT&ts?{rI6*+gNS`-5*CXsBXil_~gHi^_$*{Usy7}O3w z_iwM-t9FUh!O1;tQAcEVOr%b#lj>l9*D)y;YHT6}oV80W3PKGgQfJj!1?*pQ+|&hX zmqhxUGYMn6LhYJJ-BdUAIs4bK00mVg5;>zwE$R-ndm@EYNRj;;j)!_c?U6`5oz?3s z>IJn|BK20iRZsi3952N|jZ36>XB);QKut)bKB|w3w|~d+QD3Ni6RDqb9BO~4{S)c) z>hr3f{d?G&FF^f5B7M=RTV~OhpnfTlzO25izKF3A^cARINu;kj&!D~n^_4{Wn);gh zD#k|A*P(trk-p)afcj0S-%O-$sc)%o*ni}-qHja}b|QVpd5GQkF4XTP()ZN&)OS$1 zHT@dYUrQv%nS`;w4)xa)>HF&Y%0cBQ`VFYRkx0MkoX6PTg8EyD^xNvU)o-G5H2n_L z-$|t3b?zRr==Y%hULyUz`hE4g_Mba3^aoJ?Ad&vi$vJ4zA3^=2MEYa($LbHE+Vm$- z|0I$A)T!BR(Vs#6vqbuH_2=qO?Z0x`&|g6Pi$wZM=P=a2g8Em9^w;XI)n8(4TlyQQ zf0Iam>&z*(=deA`bTG3szv_<^`8=HfEu9w5o&w-0n{HP z(yLBZhDASw`olzeO}(aGwg2AfK(9l6J&^`FmHRDv1L_-z^dt2nH4wYek$w#I$B8t^ z*|*Q4M5u|0^b_?HH3(`adK2oKiS(8;87KGKP~T3Zcho!TEvT{dF4T7u>7SjEs5}_z z;6xgthNypr8lWVoNr^Pn$%Z-%>aaw5PravxLJiWtK>e3Q`l&Mo^ZqN;e@&$SqyCTj zDb&vNKGgRU=>zA=R*OD_`e7n{q&`v~K^nzKg3A7d!IMj7@%rz@p$Rw|-n4W|f=j^nIx@W&epudxQMzHXGp zS!sw)Fr1ZWcp_&_gg?npcun9eMd_TCj_72=S-!=hDV#M0{!~NZHJP)BGB_&((P@U$ zfElNA)^zwY429P;?!G%^a#kjyGY#i5W}L-Yv*6D*6kanqD@0kGm4)aW!`Y7+=W^Cu z`11^f*Bk@qbPvkrtZYQ*8_uY07A@ec1@IRd3a|OxS5L~}tQ^_ca@>= zT4C7l2A$NM7UgqZK7`fy-$bT0lDw9a*CJM6D7;o1YK>w4Gp#e6O(hns=Mn3nZZL4? zEHu%62eKzJH>gY;GQ-VUMHo;VN_)}yU@iMPCf(mtf8t51@zg&f?WR` zk2?pY+ECSo{a()2ku=%;dR@v-w!$ub1iD%yaovOB=0`w-G}?Y zP++#8=ddSHSp*}KHqoIJU><@!n|1pny45i6XO@{qZ(7B5P_k{DGAo|pB z4ii1&q-SuGO@-G}!%jAEkWhHIiNxV%B8@OPaU>pF)JV7~rowB4$ydm5gGQOocD##^ z=Iqgs$CzrAsenFKQ%z?9c4{oEW1)^SRjR3gtympzI_bF4q_LU?b%Kev(ut-TZ>kBV znrI>?$a7EPxhEkZ-BjtOJp$2{IH;3(++>8Om`*v-RL+_TH^WqTO)>3}NIZ}8avCR2 zgECzbXK>;SxS6KHYq~5Y#h{s{la1_IoIMNjY*WoN6|j{JHOq7kF1Kh7t8<{vHSzvC z&s15anro_gracO?p^a>=o{fb0rkZcsqY=$UvkQ3K0)!Wu&LN^4&dPzi$W(YOH0?1+ zti)Nem=hO6St5zKoR|xDsj2WwhEPzoe*9Vf1XyWUiI z6-Xm#25m5%vC}OopR)d>0MCUldYLR3oGs_fO8e zgv^>D_FRK5hvQdFb;4AYraFlmx~b3uX2(RB0@Y9l6_9+zv|T7rXuM*U5C}f96vM^? zsg_IEnqPA_A`)jd5?z(*O+?pB-tg<3a2@+v$D|HTWOjGT@r-eUH~a>Kn=IUfkkK9F z8b~^ms~~A0aTq|ikQ0Xlsuz;hoo)+B?@o6>)Ey+Jb_cl)k^&MBq`NHLMRSEQPGJl+ zu-kwc@0kj9?wK~8fJ}7@Lvp%1>t^_BCHzX8E&)9ng zuXc#N$e?7mz1X1PZhMJABiwebK_lHfeZvq+0Z}RLSImMWK5s^a^mc5Kc?tOE_D~XC~2nw==cD zMGIJ7fMN^XYN6X+X;6+97O}7h!eX~t?6y}Kv_yucB~dO*xhPqZWak^SG#pG(XANz8g=?yp}x7vVv=_fRL9IilUY5t%R4G6pE%* z?5%>AElbFkY4Vb2wcA;OC9Gk24Qi})tF>->tw9A^SjWOT2{gg(wObXq6-FTe5`w%0XDd+=7brsQEljqcQc-v320v%> zinc=7#=mIUcCwn{L<#x9> z8&u-9iwxT3wzn9x+s!xLJxGW{B`W32Qe>9N>AyD|-zOx$JMHI${Ya>g`)XM@en3cG zcRI)k2a!-N35UY*av_D?>9CO8?sSARk8q}3Ku5#z3b!h8t6grj+pW+Tdcf?M2veXM z>YxIWD{uj!0N;2EaeL((ZvkvPkdATbWA3lHi@Wo}io4Tssb12ZPPlo)D>+ugOkM3(s8j8>@nH&YF&I+U-Pwm5?Rh@v=aF%NQ!hZMl@98<(?vw$ z;8Km-xze33al$2JUS@KcGx-)!15%S@Z!1i!*N_GiNB@XzRoA+d`_6 z=nf~`K|-!1+zrPYgj6QcJx;iXggi;OAC5l|QjQE%}jWlIw zs2!znu@n?bMmP>4jj}@RX*7pNBixw8m*f~Jmok)6E$12TLStDTi(baz>lDjAfX^3N zNMj)l!URiAuP2Nhnz`ly9Wz;rL`B$wO(1r7%ybrN-mi7fT@l5`xV) z(oq5GjnLD15M?MQxVSKFyAxNhH|$VQZaKVO|zV-_gplc^QNPz8F)jo_@0@m zg_$hOgfI)ALM*;#&X%ERLn(`;EY!{(%Jmd=~K6&TVw~Xc4=M z;5K%*j~cX?-NkSlx`#T^684tBtM6_fGbq=xkK@hBvQOaSipBTLJY*Ki znY3Eak4c`i38w=YY6r+UN%xyB+1X3tP zOF~pEMTVw~I<+QsfJ%(&Z9sI%L$ z@imNoFUaO~P2}erSy&d)9!}nav8mESYKTe^i8Iqew3nq~Oq3IHMohM7AFpH|>h5P@ zKZI;;86!b(m~>ZRL)X4y2*}l zvSa8lyN5C35qx=tZ=s%BNd~WE9#)brD@i9h%E?DDwpMzm4N(OmxDAEq7)xcCD5ZyU zd$UEyc_qhD_XGeK&oP?3f*MJIGHhYhTSum@vNm#=d5Mp%P)OQQVCzPpJV+T3Z%$#Qi!TKQjG$o z(nx8D&La|MmWAj7OO;5j2{~7=oQu4iizr^hLJfp!?&ktX6_fKIl~Sc9M39qRuHaEuK*~YlfpnFntLP>@#z~K%YwTXbjMpuNI@g<*vj&eF$rOsE zI@aq@phwTP$5da!C)T8XxcKc{%kcew&5c5Q;HI z-2y3MaucKwBn|`U4s!4e(}V5`DeOTFLW+9OJrH#d$pt+?8bIojB zY79MK_W@>Xv=r(zS~k9&Id!Sko~pvQ>dvgtuh zEZsqJP7miSmh*&{^9048vhWl_HpZwXkSr#TK{7$`S+NH_Lk>PG_Ml`Blgu78Tu4?A z8Udn4cyQV9sNo>#Ah>LL&`6d>dcNjPj&YJ>D23e={Lg!h@+j096>Om8QRQI4sJbV(8D|ysJkP47^Af>aEj&2&GoyKUI%2|&Ro2yP34}ZA|r!SGa%GU2Ms-F8X|FUX}ZU`)q`em!VF|) zGRfpw`Q3XuNcm9voDu3wGg+C5K-p0Hyg{?rodvgasC@x%(d^EKTQW4%g|gVof>%7$ zuEG1X$G&9HT#tR(pm`qq3O)lO0oyo~=5ywJWTp?}XTk;H_(CD2Ln((7a*&WA35&w< z#X?Gk(h^Qsf`m*-$PLGr3Mn5-%Y+mUrRAKt9GO|e_?a*-9ADv4b3AIUN6qsnG=?59 zJ0`*usD?VIfaDb(JQLpRK`Xh;O6=7tk6PuiYYocxsC>c@+3MkB#ry@!1_Y4V=u+g!My1pQH6$Y(2ttGPGeR zZSaJ;QXz*65w01^j~pANT>Vhm=M-_SO8wPFB!d4cxLfGa}+dTG7 zgNkKn%~0CT(sq>09>&jvJHqjuLh6Q6iAQ0cO&+zyqc92ykPvKsCftCbsl!l%p9xcj zg}Tu$uDA=~WDfH)VWV`rTPmguqdgwy8M-ayyizo^*Q54&_?d8@7WT8SA3~W&m3jD? z@PG_$97+dSI*8h7!}yu-P&i&LBzYJe_9)D=$D{Un6hMS zkU1)P(oK(pZNJ3{x3IhQOzJVVuBS5-zuLIX+kP9u9Tx6DsO<@I6QqX84W0%Bk1##y zE^_eMwkI_RsqRVlgw*t;`ylE*lB;@x+ykiui3idHmL8zF`e>&V^|-90_C!taz&{eNkxHtl#Da; zd(v1$@a0ZV8pl#HlFNEJ>#>~iUMy!kil?!V2BDPu83$6rWGqOrR4MC86QoLMPnsyC zxF<~#Qqq&sd3ZXKi+I!|kV24nAWddzGP3r z3=}Ap<&-L##*t|#kS>j+_oV5F;M?w=G=rrHNY3l&EXQ&(c{!OVK9hx+5OTSn86Y`K zrh{ZlmAsxbORD7dq}f8Uds3E=oSrm?htENB7LUpT$pnc9(p;A2qMOQSr!t!6u{#el zW_uOtWH&E|zmh7(0{APbB3Ve0qWPRVpN~r~IWE0u0U|gqy=WmzvoKFtFK7D-i*k4& zIVih`g+&lbF-9!}DPghzq!g0KC{I^&A>|VeN;m=d~vXXp7D>!)t9}-lHGt+y~ zN6#A2cJ88(OMzd zy{JG)PA^&qqShffs~1QCNG1plNiSN@(t31L8ts%u(*|}oV8%kPLY>0rR+7sr;m=b! zvXUG{8##F+#@3@6F8yA#2@zcSy=XH_YcNq-Z)fsOi;8$9MX0-lg)Ia#)0+KB;!$NFnIJeO zz3CuJ2hmMov{M*OhuA%Y8Oyy2b;`Xq{wuydyV4bY2z8kC!zhp@%SprgI7g14K)y7R z-+W|;>TGy4xyC$sQ@WqaulRks+9Gn6H=wLH&qHL z?oB6!l=P-kJp2@ri+I#YkU|h#EWPP8OQ*S;XeU3Ks@Sc1cCq?1+ zRcBd0ivr2AoMc7kIC2gJ%B7L=-c*f9oLSME&a-p^$#uP*G<@NIftPau#V@jO5kf8Z za~`CINi|5dRH^GtHBzOvH(e4^-J328sp(Buc=#10SMjLJAeA6^$LvkDEY+f$+-N5^ zny#{Y6*FG*D%82=wV#HU)7T9^%ev0`brfjm#swO>Q5{F>csadz73IC?1|nEaFS^N6 z4U+46Ip^>rpj*70TPR-7LOq09j8Qj1YM9&rsRqFVKrgzD96SK@qB}yWd(mAXHNB_- zL^U9}su##zkV+6Nrx)F0=^nbtj&`!6={~#nG2;WTLY)WAm(6VqY3%Jx!AGe^?x_(O z4>|QAga+Br#@_S@5nTSg>9N#!?8D7-Sg1D*XKy&XykT~VNh5srD3eC|?9nEr`0OzzjY2{k zD$!`p9F5E-d3+obj;9JK7)E0`VJs4o-{a3(F<-_<%eXf+N z8b2|qP ztRF^sKIb~RUBP)P(9}wwTIu7DQmeF(&q6+g)jqY_#~-EE$k3W$w3el{sNEht%kmNYp%L#jt zP$&ue!twn=(&DI0NE6=EIP(B9Gvr!07>*zEsck-0>{Hu)3XP!$%#MjL1*)MADj@lg zTnpW(oXeDBiw-k6%=O}UH5qYqgd;}~$$Br;kB+i;6kg_gtY^JP6^P(VvG?ehPaX5w zGx@CNk7jkIV9)ssIws1An`z| zW~rLHiFPuh={&pVG2;cFLY)gZuHog>bPIi+F0y_R1*&B^)!nFuBQ+>cDUDRd(IrIi zyTW-qppKggTw>r21_^4O?tGG9!)pdy@?rb`4sBh^4W93%c<%X`U2InUXKEm zvYg6pbeki$QJ_#7DU72#h{TyiadelZt4OZEa`02G23}4Bir-`59)xo4=PpPYlRF@# zQl%n}?n{;OIC>zYG>#gDl*Q3Q9{v!?B|NGTq!=U~NRL>0gleI#eZJNI#PhWoLc z;rM^HFoJ~)hmgzDWPs$zGKudc$(=~ z;4}TU{K%5;1f|_VU!qxDV-|*%$iXS;Mzc9G8{3gD#q#4ROKKG0&5)%TNG^+a8gZ`8 z)rLJ&MM z$5ReVIq0S_%4v+EMeHuZjEnsWbr$>W#ogq?XB2kQ%8{A5SZ!N?kmy6jBpU ztAy0XQ$7#RM{+ffS_M)C5)Y)+EUiX2^-)fJ6s=)*4Q5>HSE#erZ{w$|c#Fo6%mioo zZi@=IrvhZGRv?8Qs%cIDaaD1!ZNl&0{tZu{H#eP-nx0mA`Rfg}7wA2LJ$q73# zJoi02&!m!Ye3uO0&FXFp-{V(%WO%7xp_5I1g$6L!R=?WrSEz=8yZoxuZ}Z~Uqh3ma zvmT4z%ZuNO3j4U!J_yOYczheu#5>EYZDhg=ZHVWE?w1yl6R1o&Js@slJRRf$2a%Q| z3q2H$m;0Tjcsk7LVa#*HuZ~EkM`d`0q&39TF-|y!;d!#qplbFEDL9O z-UNGv8G41zao`*Rxe4|vld9RRhMSXM=bLn%-Scp>6GC633+!Ehmz7|zG3lb;UTac~ z-!3relAoW9E+YZolO)g;&b)%me0ege4actv$w{DVoNx^Z1@ho?JshtSlAS;|IN=6Y zkc6Az_$?uM2~;m6D}iov=4~z|Peymb@wXKifG4z1hF%hOfHPk@`B;WPp zQv&v`fy*>ti|#SG$MxiLC`h3D9J!B3(R-n<(*yP%z$=s|qoVhy5fOYidXFCZ)kD9H zpKa^wDZg9j8}x|NA0a(YZXkKx=rKngkr+nO= zqN!&rJcCfq=j#)YGA2zRrBbCLfs!M*jq(Hz+4Ph%ksLOu604y2CBSddz&(vUzCq)L4P zO%zg_K$C>jB~UsKPe*bMkD3Hh4T2}51e(m!WOP#<3(a`Ji9R%!rMbMh zQBGwP&0}{SX3UOIsFNLG<1Ya8a?-kmzD@I4pU>0Ea#Fj|0*)*|flO&6vkxsq1P=^- zD2Jt4NG|B(T*RL#E#l=YLh;2cEQXNJ{p5h;Fe?4a+a2(oAM~9Jc{zz&BKfao#D3nGD`%pe2cy8@Ot65rt$beQ1Y}+CH>XNL?Q);o&7nuHjKT zL8?J;?ew8tEbT%!#ZgXi6zyhrH)h-up-^W}gpEHa(aWjr8u}iUvR=xSWH~imX)j0i zqClfG(%6UgA%bhC5AA1ZJCZZ{I)}zvRL09GL-7MF9DtDC7i2$38k2n>sUWy^`qDwE zlHQjN2}$is(qSHc7|AI-svIO41lLYqI>OQsbW<4R6h_fec8_AliU@@|6%qE9 z@N%lVhJKBXv3?8%s$@A;UFkSSj-x=PG?LkuP9TD7r!Q5qbP&k}eVsFSgg(j3If>$@ zSU3eCpZlo<$zyT?Bv+~w^rh2MCBH9K3CZnCXN2VSrL#QzERu70)ESU$5L`Qb=^RVv z&`o}nlOILZ>{esO^AQSl&PUkz!ybKfD!PUoy1@Dc6eySFly{|z9J$E*A&nIFr5Z$V z?ewKfES*MjMPFwFzDc>v%ejo=S6H~hRk)u^AZ1KyKuV=bMPI6wD&>9Ys*uvYbWKQE zU%Jl2uOqpHM_mIc2Enz{m+DxmLpQlmPHq(4VD|=QycwZT=VpYBzf980DeW5ib-Km+ zEv_WXDd|e}9H~cvN@=9BFWp82*G^x$!%{7h8+clN?yhHY2a!4^w?S%UR6}37E2HZB zQiG7%zI0DWU0=G-b?zg%hDY54sRqHd(w82v^Z>JGM>*M1)W~il+J6|KQ0HNUT^w$| zxNGS9^oaFGC{QHr7j>n_9C?fajnYVCUur@G*GgY{!qQzNXY_L>;jjLl^3iyT;?G!k z1|hv4$PCQTrzAh=fgQF0`c^nNs4NNPVCAtbFIjRa96BXO3gusbRePXUn%bw)?p+r!H#>>BzF8pHY+6ey786yVRTIg-i+q>;>iG!_wD zEB$C3OUazv&&kGe#z$f~<54_~g)|8H+|M|WJSJm7a-~W^Kbjy_^83+5A-Vl%l90T9 zl+MG`k(|S$CV^yw;9BWNlUbUKZqlQibUX#HI|VaNjZ~;JHPXgkv+0v7zia3>DTDP4 zo?n)e*OjJmWEu(-N+X5+XgVUeR{GHlmL?#%qMx%c8BYPcoJJlnc?~aT4T`U2VJ(F8{vfMC(wO9fq=Mj*=}!ex zCAB}T6Oz`S*7KO!DAtu@wsZeKQq+Mz{v%AtJ zj&DMIGn37zkk{YI!IwKl+*uKXEi7z-klWwhYleP@wsK%A0y+Kd{rCo&-EDBQ``cys zDw^G5xLN%}zf0TM+YT?YzkR@@9g+4ylXgbhhw$k+l0TE}LIQr>*q?TD=5Ayb%V)AZ z;drT#?EbWu6ZRq@Pk$L5j_((e)t|~Zp$rMRl5ij#KPV)(KOGX1*`LZevmBWv@|o;# zIDRBj?TA!6BUMSHLSyIwv+s*km;%*M2NjTfBod#=uy;qf%u#Gn1(OQyy}vUGf2Mzo z_wE>k<18G9P{hXvU)>eTu`KRSCn7_?N0lsBLN4eZ`h7ad-br}*vR9|z;)?E1rz7nn zCRK@B(4Wq5+8Lyk%18UN;rO{or?5X&vs#U*&qw}Wrrtcf#lCABeT&1;R(olw4)^^Y zzjb6Edq2-Vw^@zlG7sh6-?!&^p672Ldq4N{>?tUMASi+&D1ss=f+8q_AP9mYD1sm; zf?}WN^5uQ}!@1VE*16WY=3KdQ)jY_xu62-yn*K<`0>4Qs16q+D(U10zv;HTV{*>%f zq$hJtQq!O18gz0e*PsE^x}R$v<{GFW@ky?EmaF$LZbC2io4o^1f7me9rp6XnH%@ zcBFsJHD5LTTdqMT>0E;bP^&H1e9SdaL*kcQ^X!Xa0And-Ooy`A2c) z!Q;%saZN{$|0Xlw!Ex<3nMo>z;I`lF&DdmS_sR;JEgi%p)}q-K6vFbiT}|IUf}lvsU4^u&$r|G(m=BTo$t&u(Ak-1=`YQ>HKo`&pHfL`=gD7X7lU^( zS9^%}k=^iMzvv?YQd?1|t&bhUrT!kSgFVpQOJXmGG+PM(qzHBcBvqxYkL**GbRTI{ zknAJ-6{Pye0j3{7a4WO+10(>jU-XfKqz0BrU(nVFn*YZbo~^^pPX*V87@iO{DgrP;Fm3g)a||a+0IaJx1af2v1*tCIC0V z5daqe_KUu9Tva@MC8WUBS57E!_mz`OKZ)QPW}N_V0${)BE2l`ELO0=jJDe}gG@DWJ zbe@6E={zgZ!M^jWoT2{={Acsb**xn(2MN=298$i%b|Vhr=h*8xM4Tsa9z-3Bg#oU1AH;hdf36f^{ZTB?j?v^&NG+utVbOrO3wv|H1xHPq0AMQ zxq^tRB(8$+vrH7AUd#CV$~9H5?<=u9102h_BT>v;#cmuJ1`AougE6mCT$0Q*{BdBDgAh>Yun%fqbyk%C}fX=Okw0$McSan}Dt zL1SNe%7CW`Nc^}Ro%KIc5b7(>6$JXq3r4;`WUF4dq_X~(dFF1OxtC||=NUAH9#9>H zP$HRUpaTU2zs$ph3zpq0%DloNdQI>edSPAMVSE=$Pa2-oUmX8T-q3mjE2%e=Q-6`S z@ZeFSzsS2h^DfWQw=BFxKucfyBi~xXh2I9{_so0`BF;6+#~@=`qNT5V$aDO2`AGgF z_-J3pzabe~8CVfr+Ml#Yysv!DWxsmc0h=QDi{**W=mc}>2VtLd(MgHAr@88m=e z-}20id;>Kk&dxWke7*GH5iZK(0=w74LgZJON3D7JIIQc?iM}#li?#NZ1*AS8xV^8v z9h<8=A4|-QvI|KpM0Xi3u?1|CU_L-vRoeT?B2~%smBk9ueZ`}ot*4d4&}=-n#)kJHs3&}Hs8{hU2u>v2jR+U)=8RwmE{axj$CIyE=6ZQ zSpg3o)$b=ONi9O5I#7C|_Y$mxrJ>Ehlg-rGjNk@l z)dTne{)~TR3#l!r9>})?`LdPfR&?&qH_-9tTl(4%cHYR&d14P}=Yd~k8-uqYH>5p; z`pI^9@RPQFvV+t{6l!5bp4j6AJK%{CYzK&HR!cu=(5!er*{LAfPj)GY^^@Jy*^S@` zvvvW50sf4CB|s{G>i&G&pD%l8?m_2!^9^+N=398r$&b^apPlo>Uay_k|0??!ybrkv z?IF=m8sYgf(qLD$sy_- zLU4*%L4YIxw)1{+nABlZ_vPEZd^tk%2s&@dH_&Oyx9}pCAD!2+bDqe(+PU{vIm+Op z$aVH-!_NM43?6Lf{pC2R11MAnN>AKgg5&Vist3TMS>FB<(kxGZIiaAozno^zJbo^eCuNednL}-^q+zMEWueQH1@ZBICg}2 z>y)J^AvC<};Ljo^PP@Jm1on`0zmC;v76U*XSTMzsd^+zd&wWdx-a!6g;?& z?k_J%wW3fPEAmrVn&2foDS{M0QnT9n%PY-F_m|fSlKmyEAk|;qQ0EPTTbY#xNC4ov zxxc(6^%m7#`L-)x-qC!A&fD@0blUPQXGeJ0xs#pq;N1QTbK8HB_Y8iI+>G{+=`SDP z!F6+g`AF&&3e^q(;KA8L@DUz2!3O{r0Irh1xEb}Bg=fSyEJ8%6(<}r94 za)a7KaDdE*2iLFzWC5v}C=_Ew9-N~D3*d`17xLw^Z@ZP-HVtc zgI5By0{j{O$|_Q;P&AomC-Y=A&DCglO?LyGHQlY6j`mIb%$NQ;_}3Dwg@R|GoyHxV zb$luFIuPqgtOwy9XwB~E__xJJhYt?dKx=MC*+6px%$k9gtD|hBxe=ywpyS_>O|&+_ zY9CnQczt@#~gb9ZY&N7>Sy2j{H_z~jCH#m`7TRrS!iE$iQ|pk|=#V89LpxHX_5 z>))xsIZ$>nU>5>B8n8R-4=8XClsyXC2gqJV?nPv+9-Q}O{f*sCeRs3DyV=s+pfU7- z>L`Q~P=gK>5Zu_EpF@6;{gl~{MRb7R0QClPnp!;GMbANa>i%&2yAq@ogysE%eBB>% z2p&8P_JJU^LLFv&w zKyVbE27)F4zh*TKlw+C|7%0aT_yx@{NBh(-a+&_i@JG9wXm`ugQLfMvhE(f7`@&+pB$oTZRYY7PaScR* z#jXIfXp5}_B?jtG@XK`tEd%97cLRK*yR{^{fSR~~coGTf0t)^jHz{}%EhbebIZ)!7 zo*F2(NX1a1W)J{RB2I!^@U*jf93Z1vHG|}~W;qAR9R-${ zW!4h_4**^XF-Vf6lBgcev%`7vjOH_R{=B<^&hzfpvTWz|?3^bNpLXv1MP4xY1#t`Ze!M5fHVL${y{R2)I4+($g=}^GN0yrR9sMC zptGRBT9F;c`HSP<7dLq~>sL^qy+Rh!vk(IQJiF!>SwwRY1Qz3`b$Q~U>4CYVz$`8> zOA4%&(8H&(Ut}pL>@m0~V9YX(0!_1&ZK`-%h18O&g}4iIBY3bZ*DUv7SwU(xg6jv{ zXJ_MGkX%+PQOQff3&O``wF01yU^#$SRq6-JDpm0fmemTpgJq3^y1`P%^g0CBGHVTh z2LQXNqTCj3|=PwHvb!`xh8HWir71=cEER*2jJ3ct>+kgbf_3e5zU)fRvj6>q5! zKPf*~gih%nEZa1zVX$l`wF<$_gKgi*PO^i`Y6mJckZ1rA;;`ERnh3T51XU$8SazyP zaIoxB&@@G4#E)|Y_07mL7G9B(ZSZbj&g|R zA()ZDj{isw(>e?*JlI;_QH~T?zK+sVU~T9qM+^96^)UqCN&3NZoRP;7>C-EvP}YA! zL3FU3WWY%T)a!TAr?UQL1(CsWngOS&paEyH{<8|=gC(pWJXp>#@*Jh~TI+n)f1$t} zDKJe1=4gRIW9R|ZQ3xfV1|29M_(B1$wXp0Wl!;&wT_m^&y@al+#9+BZ&n0*o{&4)q za+%g;Sbn|MYWPE<@Zh=WKjcb*xl&+l>S*7tkgE*43cYIu=30SO-%(=pM3I;pY~SOz z;9M!!5pjdW4G>AL_!vN|mQD?pn<||gEO7;`gXLC%0lrmWZSH8tE95qFZ$soxfw@y) zZRsd2^xT9SKb0r6p1`WF z8iKUH8iRLV=TFH!ncfq7M6ZSN?rH9f6i z^_B950dJ7r^asDcew+2b)ATm7ZAgD#VBTx`hXR96k_840pjN8Dye=?ML*lyv^Pxa* zV7EfgS7~40)=55c_K#4=P$~nWj1F4{nyd>*i zT4>i)$}+OcP_eeq)N0SmHGPGKwGWn+3|NWuW*ym^^{>+O)nr#AeNCZRqv>^p2AwP_ zG-v>|mKK`jg$8O!Tvcf5evIsfUbxbJupBS1=g4cJu#QseScr4+0yU%~hbv`$q2oUj zA9)}6rb@?uE*ofVfECpBy%8pENmt6ILTe{Jn5x-SDVrI#nbrQV@N3^KS^w5TJ5(ut zvVPRwR%o^rTDv;Rc1_=*VZlmiU_b-XBY*HGHaoNaU7Eg|>~5q73Qa)M_Y@j*vZ>IZ z0o2-BXtoy`s3CDzq1p3e`1R0hskD>$ecfITzZVMoD76nnywWa_Mp})qVwH~nLiW?z z4=Y;f_%G!Etpl(kI`~1De?pc73#~mkg{T>=l*0@=%p@KBNY>v}XvZq$DA}W^d#unL zE421@l;fHn(y&OSoM6BScA$fw%=%AhdNbK(q@OM{r#1adp+P6XLW2fStEtc&FEmg? z;;BM&27}u-D&#El&LS^N5QcnPrTrCeo;%0oa1O+I66ZmrE3JJU9siYFpyL7@sY+{q zM~Tpkz)V(J2Rh0{nipZVRyzJ`xkT#{tVE?1>?oHDtwS9pT4)`{$G}3KF|Q&3*Qk|p zjgi+78P_vrEbG6nAXzCl7;pmtb$UX)nf1pNv{uS32HZk`R|9Tm{dW|kE2Tw2qEhZM z@-8A<^o)5g>%U)UE*F|;p}A6M&=`6^breDgs6ht`2)Au+f@_$S1aJc2X66uiPU<rJb6L$1xlw14Rlh4 zmcApKpDday9RIDnB>xfuA)O{vA+P9p1p%)%;vFKd;lW*&A(AHb1i_6g%X4dhAPr9g z!D|4&W;G6xH<}d~B5xJ=hsZkx4MU`jI&BE9XVyCa9{}!<43YPw-lMuR&vxd?2bv$y z{>MTCosWeU-sJt`gHcn3+E5*s4lR3$n@zAFe15vN7n$Pk$UU}jiYqResv zgaB}xbBN3&HPgbTk!xpiWfsj@7Cwqu20AsCrSBu>+GwnB;4O^gXG0*M;{+;X4n1=q z5Z6ZHLu4*IxYs#ET%^9C$F?E%bBr_3!Z`CFKA*&VsHEAC3m`=>7a*xBZ9`;%s-%aA zTS0P&EL4yhB8!;52*It)S_qH;z&-vUvY6Cjbd%1t)4AfI=|ROMmVwR^%Q}%=I}H_% z|3Q|LUkU-gj^nS8W%MlL^3X;yL!=fS+~^-7%SkOjaP3h0{<%)Fg5#`!_(~EhL3oA& zEC+BC)B?Bwu&)diuc~;4$|?n}p|VnsDEb(W>Cf9Kk%uW5gyUxoPS@j<|=jd+L326(Wq43&+fya;X_ zYQMxdn>fxUh}V;-2N7UD8vz;!HURilrE#ciR+Yd|*`mNdRJJN;7%G0I`w?8vtgQe( z0PH(MWgDq&=q8bCCvs&w&F!eT!!pp>VOe+`{EvO7uEOy@Ndx%?2zYfIZ-wlnXD0-L z+DLGy?1BgT&QRG+YBPdkL+vLxaRxX}0OET{>;VyFKf3`U1iJvjsuCM2dsQVmRQ4$d z50yp*k)g7m>H87f%&bO$5CHa_p>lxK0dy13wd1*Rkmf;D3|a;{LCeCc?f>OHk_yNF zEQiP+f`D7caaYJ;dJa=S8;K82A6JFre~~lf&p@C?$Em@|o1U`}$Y>*(p%R7%`_51~N9s6&Yli{o zmt+Lz;Bga#0bBssSBA-X&GHPB3kqDrB%;7QOfFLAB8xIB0^kI|zA{WMk-CKH;aoeM zE0<|rM*C6AKqqQh=d$g$mplGfxkCO51Ty6m$dt=fdagpitBrVv$u)SeuMCqIsq+YK zWLf>Dj35S21Hm-_zh*TKlk1ul7$!Fq_=m|&1r5U_PMtV{>zQ>Ezz2YRW0>3`bqm!) zxppX5ZqvMt_U~8*I(IBf{~!Z*^>n%8f0GvSEf7eRQy^6?cj>tcfuJ@L947bR!M-s} z?vuKX;Mg$x8g}&rH>L!{ACPzeBFcX514Ib!0fbd0HcTF>N_3b!QV<>{tqLN;>I=638^RS2G42d%2S$8Q88&5=p-$Re@8+$rewL}U&u4^&mhoRPJz~P zc}~xBu8rZG!aH1Ez=O3hTvDVSBDit5eFC3}UUHn55PwDD6^HGhOHA22AaF3AhO#hDH8fJY1Z~|ao86nOd@Hl(m zCR(oT&y^W8XW%cb&g@~JGqZM+<`xRKz>#aY(F|qtXyj7sewRT$B7S@+3?`V zHC*P9YDcxU;r5&zon&qgj58PFE)p)Nq`7$K0Hg?J10+?YZMe)+mGp3#uOK;G7AQy! z7dO-02ySK80)PYnj$FfKA*qGv#+PgRa%B!nJN^&xkoQ0!qT@u$ zWeGh?AdnfxDKf)kDLhy^!(@7} zH@0xO;y;=Gyo)3rEQo5R3$x3_9#dWlf4R3!(<=R_aV5IS$hEz z0NB`uNh7I7bmPjkUAeNK=6+N>(8ECIz)x!@Snl{k4w63zfyQzQG?q({o*)Fgx)Xax z$RT)eWE&xeNd*`@!ajkg$&YZHBM@&Q(F7vEefcmz1HmBxzp6BjkfW*+7$L_L_(#Zb z1q~x4#Pkq?>zQ>Nzz2XM+Xy*9>IAxR=Gx9&IZ5**DxT_LpmVB+bu)V?2$VbiD$V4Z zSzpI#D3{apoQ6P98wrk(Gw@(z8zE;&9Yt`QW%+Bd7{OV1q6B9EBAOK&Az{smjF58* zq9f!y)6XL&%;0kX%>ekecZ6IZbpb^)-Rw*^iO`Io>x(@MbT0O=;vMZB<#LJsOYmPN zxD18#2>UF4G#TZBje@vB;tGh=2{=*J)jc)iT1m+fi=xuEW65A&&q^|+&a*7PqLmca>?0qsa{)B9Rqv;J?I{+;Z1q&tg@vxw<4 ziVQk=*TbLz)cV-NeC}bOhQx0@%#0$vf%_VIfsyuR9HC|wVfdLv_#@0kkeXG5J&D8P zw|0J=Jup&giX8u+%qBe>bp1$&Ge_pooCDK0lAGFGnD`QVq_~Rs$oM=p>qp9bhRsJ< zMu%UJ^}CB~|43O#b|GpnDl&_TtYk-7tmz&N^No}x3|NA6=U;g@b7|JUOw()0)*^j* zky) z`F({i>)%jhyQ^d)*^Q{asmN?9vR>dWu%>U;u$n5_!hkJEulp;%uh^RP`!#(V*=%lPSzF~G=N$gicEcxff^G1MP|p3@mEoAq`hzk{%jq`Z-By1O6>&U<+|t1 z`&wQ3b$Ce!DXw=9DXww1uJPU4jCZ62bd~K<(=$@`GJY?@+I5ZZ%laFO?AnpCpX`2A zJWyl~=qfv?=|K&1kCa0UIE3^XUE_zd{v(>+M79a(M~lo+O+Qv-&`F@kpaIlsEHVd+ z4AhW#q{tlmG4d|xIjiiOxR^c8k&iKce7=iZXobhqQdvxSmS^w=K zyLF`8A$tcETZ&AJ_Iy{Xp5a%yJQKdabosgfG9HO06qTWn?*Tdz9GoMNWW z)v#EVxESCMB{Ljn}H#TqVmHzZ?pUI`@jKe`T>9t`aXJ&}*u)Z{s8FM$Wwv z3Y#dk2}H2U{#T`*Rz17cxtpqFGd-L;ke$0h=iUN8UU60>TeWe&nt>|W#`ta2)48{2 z{X2^7#wuwb+kmn=i_K1Le3z#0*06>u2{0gl^svsoC+pv<>HEm;LwaMeY1H)n#Ri>h zEjDNXwRRMnUBw1!NZea&_WziBGxYpb_6j^2d4O{tfWkpa9RyKdW&djuq!ona)4Bas za)=(zU6-BPt8*WQAHQhAyPLG}CN=A-{amp@Cr6468bGb%#pYzOff^Fe6q|ED z<~{_y=8^V!Z0F}W_jxE>pwtBrp^-LzNJ=Zhu6ab`p)Hs_v^DCX?V>gk8Y!2Gd6{xq z&EQChGBJuouO8a2Wc^o*?WU1(jqEj4ixrz#F)vfDYx)fhYaA&z8E_Nn4SHycXZ^P{ z{WjU#NWW8T?r3^Tu|X%7iVYe-t*gc6da;2T5^oio7L03e$NfX*-9_F#f_so}ud@Ak z(Wxej`n4KdJ=y?E7Tb1>uqdcVf5N5i{dfQPR(R>6mRppqIBds)B zVJ54rcOB(%vDMa5o)lZ}@%%|KKP@E@fS0mY$umYiLuB-?{MF6#tpA0Abd{tSkV1f4 zKMcLh`d=wXRmp1xyheaa1JYUl8wHsvd8;5kmtyP3Ur0q{J1FcewHax-f#fC~V>7aJw>NX_esudlk<$!;>A=6qCK z(9=L?K~IZ+1NO(~zH)~vN8Ai>L!rHl3hiaGke-E5NOZGn%4HGFMNnAW(@t~~4^0ou zB|XjJo@Pl;>&M@cMdVUY_#jy>%NVl^nr+ZDO99d6pGzvRt$3N689O zvk}}h%KnOvtSh;&R-%%Zgcn4R)2;w$Bv=j*P?e@pvPxBgqhz&$z$jUxpmCJcF})7K z4a`~t;0M4jFh|K+Qftvoyqg{GChKUfL&fzy4RqG`v_54QRjI z4fJe)LP$FajgpP<;GvgMvWe6x1hVv zzL&&a5E(WU0B9rF4Ukrq_EEA=RWhTbQ9*i?>{rk>N)9mn0D@D@+7FNfz^^q&$w5*F z(M`CU9quMUnn6@N)YCxcP)`egrufG^@iNDP968K@!%&FnJh3u4LeCK>I7f2~=V)ny z2Tuu)mZPNhA-Ha|y%qBu<2=Wpew@T{5MJb%qX4x8O#mKMsT(aJRq>9N6AC<|<)nhz z(Q=CErx5IB)=2;t0CvvN(oCuu-GsW?p>A@T=4n(s)6+obOi$};cAjXN!;L>3&VaK} zi0C|#G6~ZY<~+8}W6L>sFpn+gNrezxXWP4Q*W&``xd8PDi3kWUa?E*vT7q)`9#yHc z<)W&1ZMmetW6Na)wYEf=9!0R5S(gD^0GP*?E2OTVn_xFP*iEj|yo!p~dK&0l>uG(@ z&J!+kEXh=l7ZKb(#!lcyMx67+p?-_R zEf5*xn417?1UCTEs?t72ZmUXWjNDO>9wRLZ+Q!ITrr$+yidiiHNdRnbW8@yGd*~+6 z%?@;v`!w&PVxp&kPNJtZqZ2&5X%;GTEW){%0S}O?+GanDab_`V$gQKxDYVv;wpdJOW6oO8aPesw$b$l2ni$EzcCRjh5$3 ze~#c3vz`GY0Wi;Kc|qz0y770j{oN!*GlhyTdm8Ax{Av9J%N&dGC&(G_3JQ%nPh*+9 zrsp*jLfT1aw4~v|@olucA@vl&Eu-x)=6TC`-a`EyiFY94Z0HR@j35mVRh5>}(xxi$ z(ehqFbhLa>5F0HYnf?*M5oUb=2m|2wHd->IGU&#K(|R}gMDr6We(q_Y^ZBQF0%ZiPER`&oMSnLbF6%Y2m8-h`9`V@!F6NpI@~$>&UwB=-PsF-vlsRs z5(WtM{4u~NhI8l=0KH4DH6fcI+FM1QFx{UI5TYFdrbGDovwhk*Wko%VGtA(c)3iI9ir4 zeF=ganB@WR1K@l*T9%Spif%mJY)>~?Mspb|*7h>csqOXmU5sE zGFd^-3Me?o>G~NbE8)TV87E#+ix@o4eu~>%t2oapsIMlm8iW@)#tTqOuoA$dDs|&z zjjDLZNu2`EI9aQpcATtZ`Z@%=nY9+c1%UN4PS%rJk8WJuY*#n&(e$C>hF%6b8+uu; zPVn$};4O13!=Ghkz(zKp^VF8fCVDnOA*4s9&={$Q2m8+$*-UB;f?LMepE1uC&a(yT zTS;sM5$6GFGeC@>9w4eJEn~#5D)BM0O+j>wY*!E)BRiPB1HlnyZ3hSgVE-8-4Wt^l zbi3KkZnBf+PE_30%RpyWufHGPJY|kr{3#p;?1q9{=W&-wfSv&7(Ip!iCwt(*JmX|9 zDL;Z+#@X%7on#;9*$4GT5{)3@T)=w)Vg!2tqN>s|PWG!xe4HFm5FIB66~x9#km*4L zN0@aGAPj(c#>pX4htN%?tDWg8hiM*0#Us58bdL107IcD#>&I2*Se_$I3}}Kvjm}e3 zCP(Qx$|W*hx3}?f3?6K6Lh|&#@kz)I>|-Oa}ny7 zNL&IDXG0Ny7{LXAsH(J#m&>XWA1_e_(eZLcL2SHSW%^YFN0@a5APj)@GhVKdx`u9& zUF~F7iP4Oq;`LqzI@fzyi?j1&N*yb6?4iAoR zOxP6?x8r$1b&hr%NNfJpA88-9;ppD=$Kw4GW$H_BQ z$&8cd3ew}`g@U$ml45!a!6|0F07wGh`e2;AB=r*A#Jk$@uJVfJD^z^l%RuM#Pup9v z)Uhf@(hNvLp;hN;EtNO)yy5!MEyXup-ok_RGhW`2dWPVp@pcI7r;YQpLH#|6_aK7Y zVBP^V61)Wns7lj#`JgJn@$ykYV7z1$G>(@~O#g)724-ad`~X-#AU~u~Jz; z&jKhowG-zUal?b-+Zb6$Y8Ha)#@KVu44vY~|lwFGVekE+y-5s#{P z$H)=|o-wjiLG2h>#`I+fb~9@!fC~V}w=q&nsutaZy4spbC7@zUdkLPEEc#CTZ+5B8t&vYM0!!OjT)e8R4s8^~&SG6bst+BC~K zLDpzi`*^8S&^BJyD#(nNb<|mh;54(=0;B-&yx(|PPij4?2fNzAuHvKVL;o8}40JY> zSSvc&XG>)x{Tt!mRAM%jSokX#_4KTPlzW1G7Ec3i=Ca<5h%F?xfN-(tdVm@L{K|WR zYz2keDHFu6pk{(>D>1;^N-S?D1nb9;QpegH*-nw|$ZgWa)Kn@v=-Gir1F9C7APp+g zI6-!j+KS-F1p5$L*~M0Np_Sbvc7q7Bm7M_11PuToRf$ZHfU1Ni$Q}iu39?r~^90$) z^nD0!V%A=OAOQYg(FAEE)yQtT+JUaJpXPp4JWyhwbD+dpm7OP8>R6W}2N`e>3XM8X zW2pq`2|^(~kqad~Q4Ya_840&oIg z8Bda6ixoI0$#DfWlO)9S5Q5uL(i{iK0N|O?I9@sbhVPG&7(X3Jp3>L#dpm=QI?eI!|<>oPh_w8=WX;NgYLSYNGw57B6t( zJYlGxBXJHyk`0{&XeBrUkWiJ>L^-c2$%%47L1Lmr6tqs1i%h?W;1*^@0OA1nE1whP z5~)k*#@E&Mb(PCBFQa0##6Tzd(>(rChc8F2FyIOl>UEy_Qn^acRVW0slfXo|1`mD- zIZ3nkcsvG*6V< zOuvobCT86N2m)Yxn<#fk-9b0ruC}+Uw9srp#k(a2I(L7X$5-mukR$gPa1RP~I!|4x z+^6S06g=9AXQCwF!Lt$*rApC6T0YE)L0>Gy#4HKnR zRs0j>u>#*jd7_|xqC92#Qv}yB>j{7t0Dtm#q9jQr*$w`PR9AUM^BF2WFEP-0{?k0( zQpd&|dBK1eP^i^;YD*A+vJ*oHT#?{q! zb(Ie^KcM2r5(Ax&Kh5JQb!^I!3T_f^17<^^M(3$1l{xgx zfkHxW$R%u<3lHkr;v)48O}5+iH+=6uuQ%qI2le?R=0hdJ`*JRTHiEeTX;o>rWr3<> zY;h|{+p~NMk zHs{Dv1}ud_I{-e0^p<7xEaN~=V`Vw11q>c*zr;K%IL`{GuOzV&M27cC zmIJgA)B>bcrG2b;RV6c4Rw+o2mDLK`#>yI|uR(B%S*rn(0GMa2)RC$~H|Z{Rx{Iu( zxfT`I^)}F1*Zc1u<1@V-TXJMQ1J<(v0K7-JxA^GsK_R3|He|~Nc<`~xmW`ym2yU_M zi@;#|NR0b&Fj0HUhWV#{V#iQBS8LDZJ53SzeSneIn$gjrhw!T|VK zWy>~F+t5w2i=FHu+i7k`#T~s3bawo-e$u@iTXUp=0S!<{0pLQWx9p^6C+E>68yYLS z;K4j&WjCqK2yPi`AHh5U&J%$89uj*%#JPZX1H=e+0Yp`$WvuK~mH1fMryx338WqIG z%6_KrM{tB$jR0W)%rjOFkUD^F5?$;>7dc4tASwoX8|VaoT0hC&4u6guV!$CNv;yFl z3%%tqJ%^#-(v3!*C9EJKZ630LUxqzDh8VQa71XQKT zmgA}tv?Zh9{`u_wwxk$3f;uJ*zqpXOtTpkPxm&^IsMc6 zN%VGX%aJn-I0Jvm8Nm(Ax&+_{z&v9mN-BzOqFwB0 z7r8?73MyXhZJ=}Yr}Y!>?bx0p*BEdO3Ne5`<6j{#F(`QS%F8oJuET@#=_I*9D#E&x z?B)2{?L&@8rD;KM9kcEL zcmZ%eog{Zj-9p(7E5++M2z7i}rTx$dLpC5>Vjc`!oKP2lPCE zLO?qSOp=H2;Cg40JR)_A!K}-l^M(l?!P89e5Fn&kkx9Z07=M#{k~~%rnj}vYG*6PJ z)Om{FCT2YW2m;{xW|AaHB~d-p#SV3mXEdLo|L468be{LNwq^Sd_jWYkdVm2h*Z=^Y zV?2wRiyKHP^>$sHaJ!K_ro5UIDZcyaY(7 zN@}vaQI+Imd8;5XS>7pVoh&?-nl=QtFzX#a902Ff$?~4mdvp`*Vh6j(2bv#H@ndfT zosYe(9ocz8y&XGoJ-~nr6u58y8UM;BdOkrRJ%wYWr^sh`aD6jHzL0u@VE0seE9PnE zJnc~bO5!UB*HnNn05t@k0h|E1zL_fDRK+z_zAJD}6(>&F`1m|kW&oHOr8tkFq;Udd z0Py)>ip(T6vlLrL7dy~JX3?BgitB+=1D%>uYiD+zU~k7RTn{i{HWYZU#P1b)%N%;< zP(hb$V6x1G2iw^GY$#JgCnnF&`>nE?^fxGr?Sdkg7x`%K}vi zPZnND{Rw_qsGxbWEMod11UE5jAwUoS+uLMWOlmQ@@prNPxE`SCLB%Dd20BYh|Gs_# zy&b!8J-~paP-xJ38gM;8&oU@Pb^S!A2ro^sy-ktjq!u7JHN|egJS#ZQ3aGCnu@Xd* z3wSv|D?u$lLRC^z#H%XFDY8mIVv4L*&^krdFntYzTbQ*PAP#`-ZHn+R-_)TSUl-el z>j9c;QE^?VfzG<0){nop1J3}iXTW+W)ayL;xE`R#2L+EVSwxJtu7u$>L0h-%UaYw0v&W@kfkFU3553UCo&_F4jrw-Qx^z4K}K$mP_ zitK_1+uIb`O=>fOBU9`-xUC=HJOQZhA+ZNUmeLsSmnAHdn1i&B zDAejawYVOj=P(q~dZbNHk|XfocrZzLkHqXnuzRw-FpTQ~&T|y%$4DFl;o<^r0;nN4 z0^kI|@nEtXR~6S}2`O;muNNt(nJg!neiFg$JYJsw$msDpGf7U7I)!drU2GSw2WU2< z;^|TYozp+9A5U+`K3oql;0zSpI*%LI1N5Bb6452=nIgO+hV5;NoFjD{!3|SvFXlPV zdCo)q0*MPC{9M520O|?C06tY|m?9BX@lTP93Vc)Kl7jjva+&Fu5nRWtO8{N~Y;RK} zN-BzOoLy`ut_NsdLB*@320B-NT0gGdjz(M$FyI;#YIL3&To2F_gF;l-PZZY!@ZflW z>j6>`1g9q1Nj&&@lk?n!dYnWYM3M{m20$ypb%2Dbq;Nf;DoI=qC`jOXKtU_62bkW1 z;1*`x0f+B zTvOz!0_PM-DyW$v&zSxU!R_2ilK>e2oPQ?Eb5hUQO=mmZSzge5fr_b81D(`Q>!+>6 zaUe%tGTmv)?kka3^t^(CN6&ZSv=5&%boaYVH-;#I> z!q3xa8laxwHGof58m7uSRq;=iHU++^@?JsxRQbU44+ySf)_VXi0JgWO@{!a>bd&6C zCp$}qW(E~Ml^W=LDz)}!&!@=}$H5%=%z)2O;O!QCJ}8kd^n8IrKsyOcm3DY=e48p? zNxegGbgCUbgFjWsdA>pYJBjZgB5dd@K$xH%pjlO-xEjFshx1UK+L1%CkOCzuaUJ;6KxpJw?d$O6ss zO%Q&;i;ou*WFgZRBBqYPZU8R;R>K5YL~0R=#yi{b&a#;1VzlikGtlvr;Wn;)r$m;} zzXblJ1WTcioN6CC&`Fk+VaYB7!EeV+Er`~sR%5qhig>RQumsxnmZcP~$3j!3RR3Sv`bDR0|f+cE8{!(N@P1_wqqgfAlL!Dlx}RP zslta?OanZve{~$e!+SJ$!c6>?O||}2cEN+W|0=u7%|_nsQ_hrS>4QZK~sFj_jqm7iL-)@IIAopDK-I7A^qxtJyYH4lwKh!jk#~ z`N6C|SY~G~{DT}KeF&2rE;EPAtkbwPulamd3YX|pDHIR&0-IbUXg&zD(eJK6CPxxm~D z5Q&tTNSTE*??rmT5D8S<&rs$P%UnXlWfGS`G_cG?0Kb+AR7+IV8>;1s0)Mq!Ei=GZ z%dB&q>>DL=jk(t#5-T&YG7I0+U8g4s5qGuy{9-4$!7?`xag)SN5H6Ov4p5_I+|?3S zbyv0AQczPZx62IhZJj1oB6pa32O=$HrlriffOjU+6NgBBwfzod?y<~0MBFEFAB2x( z?gG?lnfhu;sJgFO9w?}*mWO2q_#vl3a00>2)%I0f=0Bp`BgnN}`N+JF$jcC9px;t$w=C==pST!4f%r_~Gl+P#b-9xx zgooGY`2tU@+PZ?ztu)(VMysu>o#ZRcuP`IkjuScZjpjF);cDv|o?R=mVx7cUZe7Rs z)a5)T&cxH}xW1~ES$v*-RymFVdQ7az`e!SMR?8d)%t1i=zp(J-;@qs?r65u*^B6FX z3K}p!>tCQCUM+l59(OgWWg#OMQc91Bi?aU3<>q^tah97ISr5MghVVrDOVM#eorMe9!s%5DbX|0xJON zvlnh>yf2d>SO!lU!BT*xCOZ2yfVj^-TkGr-Tf+JB%#w$ZZ<3Qq0B zIZd|1gZm}ZWCy7Y2(DvY9zVPUJK(7$*bd;)th#B!Hyz+GJWX~g@Jy3k3TmgxZtCnt zu$x)C09*igykMFHNCi+m)Y%SomOV80p#Qz)20DBHW&iwZBlsHq$BB?%%>TJVeTnR2 z@IK@ww1>nr;mad%TAe2QNj0EQ`!svO<4HgXaq>BO8Ybk zs!C>>98!>;CWjTYO_L)`KZ4*Cvkn6!0k9=a6TXMTG@+YdXFJ$gj?z4eipRKvCLwt6k$ak)AQeQNmT7i74(TU3$VteaB5?{t zoSmEih!KPUqN>s|P57o0T>4Ct(+Z-~kL2`0Q=`O36lz=n?Pqf z&{@vWJco+s%MEnS|1^j`8^V_#>L4DRU>SP>sm|%F?3^wUc(5%^my4vDQKxRY{R9^l zmpI5J$X+IK8H5)(<|05XK?J~~Ds|H(sw&>;az%k>x?ELIJ6*0Z{ThPZ%(@ET0>HL4 zUHBRv6GJ!t&bGg^T&H;*6>pRq=-eo`TC!_|57_9>>s>mDt3+-x_$G3F+JkSp#NokS zJzZ{*ilR`{bbA%fYqvScZRp-1aR)?@t=s}=B!~k9RHbRU@J&Z}sA#&}RS=ji_Y^cv zm-|e=kKhJo-2?CgU@xC82~r7m)7kcQmIpK+pyI=F1D%KE*4^x0UQ^;YjfdD6@CXWg z017Y5DUnusTA>iqPD0b=F+AABrppsjEeLLzZa>0l{we2q3iTw3B#1a0dIAt5cnlC# zm6qx9OjY93<++0Bba|m5HeFIoPa!zMtQP=b0BmB@v98~ z*X7pz?3%%2U_Y)f_$(PdDff~zgVV@OXb*|$@&+F4_0#1osb?tE&WijTl_7WwPaDA- zfV5_1rpr6cN>7(I1#Q#iJ=5PKCdJ@3fFuBR?&OlJjF?C;hSTqjgmPw}pd3M+{ps#RFeItkx0huaXp z%WOu@X5`=a*REN0|lM7saR9|wA}{v{P=MunMKVP;hrG=?5f9feQ=YS4iKf|pd_a}<`|Qpzl? z`0r&I!7}K1e`iha?@~)oEj+b)3+YwNTm_;D()x1bpwMN{Qc$!S} zw`g48ciGB-t;qNNjc*j;dp7@slCteb{&v#ak-wwD?9lv%3WHwORT#8@Y8xxe<_ZHj zWNxc44gWt=Z};EQy1fsthW0q#j;P+FS*@!6&VHZI^Bg=U^DkK5-{0RY>_1?yz1KG= zf+8q_A}E3)2!bLAf*=TjA}E3&2!i6duF>z@+etsy7~>k(J;ps}I_Ev-%uILv4*FUM zHvM7E$2s$EPQY#`?4i^i1Ol7@zHOmVC!pyM*~<`H_cO$%8?%<2T3g^Aal{UPVNJ8wDUyqdW`Bt}{c zw7@_49+eBW|6+G5j|sTM@Fff%?{4DVo$s*R)ch;T%l;u(Nw|vq&_DSim4xlT)}DWz z;p@o1(cRq8{A727TF!MhC;_8g>~1c1H;_Z-weBX_J^`m8nEAsxhUZ;xasqBb;TENC zA<+7VRVBA+-G-IcS;+h$DSFs{3nz%3r?m4s@Z(?WA97bKzo%x)AHv_6FfE`pY3KKC z|AX#U8l696_#wtkcQ0&38K0?73}{*vOz(tuWVEh?<@RmCgTS=%B+n55dgd@u&-=lXcLO_lvth; z*-UdYM%>cFKxa!2=QsOwFw@PIC=&g>r$#97s|>if-c7bLWh)eXT8Xc(Y=Z|c*Xt|W z8Cnl=sIOIzBS(P!1fafyfgK10S?^wz1o{ep91E}D>MOgM zz8mC5W;Fr$0q}CYzOsj*J*dWAV!2CXFU`Fe5x=kno!~G1q`SGU;o2t&`=G$Dgy79tJwc zdpLjC+b7k{bsaxIL;eXU@Y^3>^l!zQ5IseonKW z(@;Odz!?O*{Q*t^)Dc7gJODUN>Mv1M@%ERq3OxPgoPxUka-QkuL9S)iIRG~R77zVJ zf5a|^YI4O^u2?RRc>yC{>|vmDv4_)L3=c0-C%U*h)pNs5FN z6!?WOJdD##?$C1w3Ms85)lcrigLiHAlY0zZ13BN%x{iMEyO$kJ3)Js3a36sj3%Uo8 zCAbTaQI&i@d7vt}e)3R3rk|u0Wc$e@rauC?m04+kGyvYU*-sub^cdBoi>-9AJfZmn zBewQ1&}sc;`$W3AZsIyE2~VNWto<~1lV|iiV?VlmQhnt)Jm{ydWEgq?a=x#%ibq!V z^8)HG8F-06jvwd@K$hS+Kt@&aedU#^y0Zz zp|`B2*h&>kj%E%czUyJ2^X`}J6Yl1^RV438cn<}BZ4nRSbdwMCe1Jk&XExkV^6=no zoBiY?L$5$i_OmvjpHJ-P6VyL5@EL&wC-@^koFESnQtDX2=KpL|ge>nC3o#QVuN zrhfxD%B-&d5di$Z?k8;wwV|3sv6U#6?=-(-#2-BjbbkEr_Ti-={jMf2s5faRP2J=t z$v=_n)6cN4zwl>w@t>`~%mOe43>4xgmdo8B!K_lG6Sx5anicFXvo$NwU*;%i>M#7g zVN(lEBgu0B`~dg|)?el_G`AF26^pG{vCN}6uM}T$E;Z1ZU+SD&Z0+hM`qRZ8_!p3{ z01EN`)>XVWbYUsxbRhzZ7+8crtiN+!vFkQoUP4bDJkkD6Pq8efxfo`ozjHycETOps zW^;d6sz{d7TnaPX-?^w*yrs^%Vp&$|TwE;6OS#-#0Rk>!^p|=v>%mOuxx-4^ze+)* zzpN%r&lY%E z|LMAe<2TJlm}y<^w*FJL!h_p}|CDW|W?QLqDgXa&CBMJ*Vo68Y&iUUCY5gtt05iFb z`CC9OI!0@M*-`4ci|-*(dM5~}{;qpPvWw;}m`R=RruJd_%kEMxclW57>Mwgq+Y4Go zSAP77dt7JiFZ)WZmg~RCeunpB_yeWpK&f+iv4k}Lpz@OaNLKn|JVQgf_Sm%BS47#d(5!2~pO0-B+4oKnXT z2o3Tp_l*X~iBeZfk(?yqBnW{4uKPt2p&5bMIDmWHDVSJ@50KNPT=|_*GcZ7+ zq(wo?>2lz#?LSv)HQo44&NF--!^cWZtkk&@$4t$?sJzAja*2dX$anw6m0#TUUvAI8 z!tfR3UoACPH9t{mP|N93gAy>>xl(hX)IbiImrG5eeF9EE&_BSMkISpqI04t7aGg@u z5oq89@Ku98odEv;xxo-yuV;u&d$sALR?{#*ZfeoD)T|#Mx5>W^T3(w@+5S7FmJdze zW%w?JyjN=OY0)j3e_wgt0rG%^2gtA0rXSk=bbJ0Ih94pSajAK%`A

YPnfzPy$A~ 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

rn8D)H4G@?Ey#TQu_U+P=_S+p;U_D{n9RkSa> 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%0DdkQ_x6$OA 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 z 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 =A8lafsTh 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%0AgUyj3Lxa(#u&#~CU2dip0h4Hmg7SUS$9 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

h~0}<@M=OjT+YH1IhV8Az|bIDQ!r24 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

tbgcPR28$zxn{7-Is5K7NgkiJ(Sqvp2&9v{ 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

*jiU+Om4(wx?y}|P=sBZFnzT%af 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�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%0A>u^xdZ6o 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Ν(wTX5mAVsZ>%jM>I_LI|G!& ze)mnJCyF2*<5tV@RBm`VP{T|$j^KLD5%i+B)oZRdpqe;xl?t37)hu6vsadRk&{@DW zn55Kf50F)}5kMPaKsjPEK#h&D?+2)hD9%Nv3L?Siee(QW)TCp04~VGA%Q?plT$8DS zUMRPkm>Sv$#;Ko4(YuvoqJNI`pSe`il<3a^WJSLO(BCnj9I*``JA^OOAn5cE)w$@> z>N(;sz^sO?0jn!obC}VP=4|uVHPfoMmtxFEg6a;@i&Lp89SBq}V~A7S5OV~*tZogV zs?-T>1EHh3D{d#Eq9s4&Z&aly0oMnR{v_$CGx_LXIk zrWaRwj-c25tLD9&_W<Tsf=SaSDEFMdr3O5AEc5q#8rKy5W3b0nXMhABa z_@*9~Ryqh))=JBfevunsk+Ra?09h;T0qDA(tielAxIqQK^N8|uzkA3llYIR>6lj7{ zPsv`^3V>~?rIGGC$`~$Jr5*&xmf8ZK!ZD!rA}z!3>@dYX3Q*|rKzqNl47ETJDT$WX zsYCe*<^FwE}+o=v1&*lJrvzjK$Vy7J91Y`VZWR=x|-CETr=-%QsA-5pSX zM5Fj4IwaDoytoZiPR5p>j*4qIy}I9-rkDoZ9~6NcJcw?I^m;DQOM>o_favAR?>!O^ zA{SD1hSjS(7F2x*I;(VbNgJCKRTYUl$AeC7X%X^PvDrs{|?68Cz6n6?E}&X%xN)iT;-)r1Ctn;PT8w2vv;wFa7vdWdVxnlg#gE`Ld8prc)|l=|KpQVg zbjo6C)S9mze3F`N3G}$rpUMV=n(evibTV(@@YSo`{E?X6^}xfJCuL{w{TlDe>h1;t`CJ-60kBJZ|OBiKq(SM zk`mDHEihR2fmJ~V z^%pUq4QF=f4bYQMCpyP5zin&!2RH^9k{U|cp%kDYfNunoayrQV<|N0I*RKKSYh$7f z0PTtvfF4f+DXyNAaTSc89PfAPE1E?2SI{ibG_o&1k*6942Z7&xbQS_G3+7#>=3S-) z&PV_l-UNnWV}*v9L8lMzpUF@b>WJjjW;3X{^`Gp=$P>^0-<(8u0MfIOOtx_7S#VO> zB4uY6%;sgRgU)1``@6Ec!1ecMT{rz#h4Bv_JxSHttLZ;JD_Oy@&qFm z4(y}uV5OBKZD+&p-kOD=kjP|^(Ifmgo-Vf2RGmMHN_jg?rNj*?S9ZFJml7GcMIl#E zh<)-+Lm@f5kV|A&%<)6&&dMSIHy5CL@F`ur;Bu~3U9VboWna*C{^)^w0<;xO$$dLe7lH|E zqM7WYtvE{lf*1s0wGo2uOpvUK7XT&6DATQz;c%1=heN=?J`KJEgOWVZYb!c%M;qz> z252sibpMd4bHs#)={yqIXoGIqjyS*|Fh_UcZlz|chY&Z*uJblCo+>9t0Ndnvs>725 z)JO;2tI~2Pa7#cB1yW@HyJCQb0;G4ffqrwKTELxx!Y1*kW(IszMS(rO_pv|=mVtXG zA;=w2K`uvRLaA0p-UDE9-rrx#>lyM$c{dq(3rcx6nekte906UBBOoeb<02Gs(SI6@ zI{btJCO}&1EY^7fl3enWB(!JaWwf8FrtGXvcrWRElB#N1G_?@8SP?3^zY#cKW{E`kLg7ZoWB<1z+OD=2lfoip~fMrwwn6!DFjU|qO zNvFC9!_iDo)7xKVewzPIEY&Aoh&ys7^DmU;;r6Pe3=}n1*1|wlBu6>6CMGs;8Eda$X)<;p3S22EC5H(NpObo@n1evJXxj6I#_bOpaCo@<2BIzY6|!a zbW@^f09rhUh4HfhJ{U6b6P4Nmsi7ZHcCKg>mGuB+wMX5}62vlD z9uXIA2y4A(1kCr3nk6|6*+r)yA>bTpUG2_bWz3;b8!L%DxHv-ZIw+ip&!#!Mzyd~c z#N9zU+$!Zaq-8DU8S=Fl;|%i1Iw!nzF6*i^RRx=sb}3ruB4kaaLNV?DIKxPpmW>UW zNVauU3X%X+&Sm4cdH{8f0fqYkQ_(OQs7sa0qFK@^sOrB^8>R(?O6odLWK+^x%rJZy;(KDMFnw zalARv*@%3SLOvg9L{Cq|^marBNgn1TcYtJbeH`N!{hR`DEr8Yt4*+--8h*i_f#t}e z*~5^PO2_zx#^MU^X$`?2d0L@5Wj1^THD5x7*MOVm2x0ht70i1Of0TLUX;<>R(QtYd zX5*&f-)v00n2lR_ZM>3fd>+R64>-#9s%=~WOtW_JjCeM_41I1=b)De8rsPQ1HYUNT z>b*8r8zmc?UzHjA9Un9HQm;cV3lbM=>^Fn= zb7QXz{zb-q0t~K#qcrwf<_IwIEz zmG1_{sL+ULyO^1?38nX99z0x`^KpQzIqwIkd<-bu3oY2L&h7DJ2$cE;{Ejv<>`ci7Fd$M%)Hm=DD~NE_55ZE+&Fh#TB`cj3C>M!3!o+1lbWJRxtRD z(v5Zo>qB5`|6Re+&@1yNh_DqLrNQ?ogWm|ISsQqUH8^!mR0Ihf1}d9=!tzV+lk#X$b0U8to z3TG|zJG~8NcQ>`HL`xaL5xx#Es}n8@gsq7yT57%Bhr~qGe+v+~#zNa9BgX#rL=LE6;+6GTz zPjs|s5`00<$#=*GRdtkwnsh2*OctCZ3S#=aU2uYs=jqDj2-=B+4$bSpHaAwN3&FFC z-vjUJ1H3Cz;3N?vbbX{(+JW~bkVVDIv+7o>;$;{L237H4P{Ewik(}|cXM!M}2ou72 z9(gw-FNl3D=+>kUMjD-9Iud{J58Gb>Xp1Y%p7`D6AZx3OlapfWRP|=P$tq?KKo4|c zW6gIID0u|~odak%2W=q`Gz6z6sBceeq&YBfH{S$oSjRzI)B>9W zu0P*U50`l@P(R4us?M6>fP{Z*hQyCG!?EyI)(k&{teNRx(6xrQ8FoZk)=8MoX2fZR z;o307&q~Jxcc+pgT{k`woT7t#$k@iG9x|%&Ay++Qdg$kR{a$E`Bq1I$D_L9Yg7hW4 znf;{dp(Q|#OpOi)XmboGM|=-Aw9R7yKyL>hH)I1T|zG{*#bj5TsZa&5NcoZ5$$oDbf}8W0@{OUlXFf)2iI zsR)KS;yqB=CFho)8kv}s7KchNIlpkdQcNi3kSMfhb=k33Z5+sFpgIq z!!sv5y&+q2KC6srmYnH`RI;94a+X}f*^Ste^L6=@_2n9Mw?sPjlvLA8&PGVRA4Xx4j{Ya90q7yQ3aBdAligx$ysmkG)vA`idYPu*8{G8lcaoYgtUa3g#WsnLd~3 zSr-wHZDQV2wlAh%OEA!%1ad`@2%Dm_GWN;Z$YC1+_tnt+TzHd|{yLAK#BwdRWXD7u*m zM)~`}&UG;)j8*{LX2TqK^3ZcA=vD{tXfbAvE6|cgpK8fj@4MAY&Q?aUzFKmYGJ@%^ zU}_(3A-Gg$(ig9 z2Qf>|zI>h~XS&5Aa6gQF?UHk)`)JAeh7JkNs#2zF0y>j1V6cpq|K;tr_G&%d3m2u}oP1^25IQaB>&0%ZNp^0bIj<3n*O&J|l>-Dgd!8351+3lg1y z*@EWVW{lLI>7_-2jCRTl`mS-A{(HbfSQYZQ`tG-LXz^?k{fWhga zjMxMg8V1-^-|jn^X77RIYFS1?7KP6^AF+YukHnXoorD5t9XMIXN_r^h?2p6gK^W4m z`c?+0L5$D1qQO>Xht2?X_$9%~;dUqummovZBdhFCeS%l5_nDLvKsJ|?lvhrB6d=3m zy9%K4(E`vDLa+MDM@mGz0QK#v?-9`aQ%KoJK8~sJ{g11@HNnuX`qt!rIi`jKnBbRpMz=|ZmchCkcKR(WU5l$`V` zZ*x3U(&$I8@}}=+-tsGCihzp^gJj~oRbE{yPl5#fL^bFt^)Sww;UrX%PI&zR?^?tL z2$5H8cq>@gRo*pol&Wf#m$bktFa2@FW#ERI2r&gk6z$*tmDO=O>&q_JA%B_h7cyXbRPU;;utT9fL2)%B`XR~}bx`&-n> z`Wv)%mAB2nptG$Q6V^m8waVKBSs*C@VeKmKaF8TllVp_XNy+eMR(Z#RfqkyN3kDDJ zz^<)W_6ru-jsWxvk8E|x)H$N(YCoogb*C=hAX??UsC!Lvl~?!L%_^@R9hg;K8V7Y~ z_jb%GukL-DRbJ|SlitBKZ0_a>6!wdbNb;eji<0$lS$$LsJ zJA<}EK1{lmTt)?e$$-PG`~E4IEUfEyW=AtYP5*L;`RQ2zze>DITQ1i83#Iu{WvO4W zRo;w8gU&Jj;PF&h6Thi4y~-=?77^#b!alqDgT;NE1wA(C*`-%`Wi^L8-tLX8UGRiX zqwkBT$pjbKe3f^gH~Y<~?D3v#OntyYeClI42E@6daa8JVnc6-o^-rX_;wu>4uIDy^ z2A|aPJDcDp_Mt+S0dVLyEdKTfaPuPx&KE@(uouK`z%%63 zovC)c2KUK#tP}ExD%h;&s!#6hf~=`jXhf9y51WlUiu7lZZ0o2ig}{ht1&|#iB@Yfd zFUNqwTq$jZP9wPrxlu1I5FSzj+09y5L z18^mP)$v5Pw(Lo^%x;dXRQl>rC<|9uYHWl*@@q@#5bSVm)VW>BZJHw8<{B%x#0Fku zR&x8I0Nk3D-2Ip_&Ag0?xM;k{tTKXW)&ZVjy@;*k`hLKggsM+`|5(XkR&q&ZYLR-C zakZ*#vy!V`$F4jCijoZ2TMAYg#x>d?{Z}Mgy9`r4R_F-xu|WWd-qE1&Az-YLH)|i$ zt6U_6lf8gSr7tdpR^kfgor^!pymBR1_Fco-^_h(y$^UOQCSJ_Oqr5gQ3>h=afxgNE9adYyJ8(y}V^jCiI@J<8T;PbfLeIxUH7O*zb0?RuCz zwEHP2Mup-{kz>qQ$B{ma+aXsOt0q9!Sl2y`V-aFN;q$;)|7?I_P^#H!ph~4rYK2;Z zTCc+1fy+Gibiy4FHE5AgzS?|!Dl=!yDlD;rIn65UB8X$HyDPW}QfGb$5iWwGe1_;% z*t1B>dX;BbbFx*~O(;5>e!^9MW~;FGDT&M~EJ<$-+uiq;%Jr_o)*1>slW^G40ai8+ zbVB+E+=O2!J3GHHJ3k4~p%_s3ZD6dOztuA7HC7S=eYr{KNZYlcEnu@Lc)kFO#->vx zd%;y?FBnn$IPZS{1*#=&gU(I=vUEz5v>ht0jafR~h-u)wrBg!5rBhd&fanoNS8&&1 z7?(^%64Z-ZGlF>kfo-(4MOnJb<=>1BQr%tQ29w@{U5$jj+W zh2(O$%=2>np!=l}bM@f`{>{~iA9M9nkcqkaX>#>j!QiFFURUppw5-bz$Y#WG_3&6| z@QG3~!TnOnVH}(U|91yRt_s3Ed@2Z+9}a&f2_vH8ugu?@ApM3u?2&eTGE5v1PXlD* z%KZRUhymq@N8w@CnsD{syfBb#{ZCih0_nb*eZi)}oI!K*+U zj6QI-hUvmgRP4!93cb_=)xq(A_(()kbAl015)lRj~m zM&GVdgOiJ(9IYsWZevcl(C49CMq=nR1K7-g3l4PpA?jD_$*v^OhE4Wuw(iUD

XBMEG%cJ0uo%9?O{S;T>Pf>_fbT(3$qJE&5qV)NrG%8IUZGc_H;)XrkU^g;>~=EZ*%W+5nTKz^N5F7$aQV}uz4aGo%^ zqFqO?y@p|I5TcK^tQXy3N^#ZQK zccTz%^^cIk6dei_v-+M&_%Jh-udKcUlvdF|Nk+NQ=b>EWqff{%tN)5(@)%`@#zL4) zU=ZGj4PsW99L{pKF9E1)3zKmtbAg?la-o+pMwqt%&J!kAtZe4p@UyrS#n3IVqFs#o z5TZ;$OYgRnb%N#RUvkBbzk4g~BamnRMjFzWM6&;)t8%5GYb1<#xg=O= zXka%a_Sfv?lPFRA0>PZ{eL(1?KEFFjA+FPiXK{`Vmr5px(-6!FUjm}3LHwW)$_xqObKJrV4bONvKTe!Czb_n2UD~&X=C#Fi z^GsX4p>1g9EPK5-yKq$YK2LV8ScQCEr&my9uGkcnTDmNyeiW73TBgp75_*A5T@aPJ z9jT!m<57bNg_@?~``p{P|KxL97BEI~C zjamLg`Yt5fzQ`SF%<>OFcFa<20^YQV0fpZ`%esDLRHj86SF`c+Dbogu0?qRg8KP+1v|1@@9{T%0A-B&K1QW2qzz3f!y`xsMO^$ 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 z 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

*%3QXaR%!vbZd{Twng@5`kdtaatmb9c^6 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%0AhZy&JrXo+ykcgDd?CBVFRIbcIM(3$jAi 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 bH5QP%YcBYz8XFNbLq{E{E>Itqt7iQTirzWM literal 0 HcmV?d00001 diff --git a/emscripten/box2d/box2d.release.asm.js b/emscripten/box2d/box2d.release.asm.js new file mode 100644 index 000000000..9e9935013 --- /dev/null +++ b/emscripten/box2d/box2d.release.asm.js @@ -0,0 +1,33 @@ + +var BOX2D = (() => { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + + return ( +function(BOX2D = {}) { + +var Module=typeof BOX2D!="undefined"?BOX2D:{};var readyPromiseResolve,readyPromiseReject;Module["ready"]=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject});var moduleOverrides=Object.assign({},Module);var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var ENVIRONMENT_IS_WEB=true;var ENVIRONMENT_IS_WORKER=false;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var read_,readAsync,readBinary,setWindowTitle;if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src}if(_scriptDir){scriptDirectory=_scriptDir}if(scriptDirectory.indexOf("blob:")!==0){scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1)}else{scriptDirectory=""}{read_=url=>{try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText}catch(err){var data=tryParseAsDataURI(url);if(data){return intArrayToString(data)}throw err}};if(ENVIRONMENT_IS_WORKER){readBinary=url=>{try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}catch(err){var data=tryParseAsDataURI(url);if(data){return data}throw err}}}readAsync=(url,onload,onerror)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}var data=tryParseAsDataURI(url);if(data){onload(data.buffer);return}onerror()};xhr.onerror=onerror;xhr.send(null)}}setWindowTitle=title=>document.title=title}else{}var out=Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.error.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["quit"])quit_=Module["quit"];var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];var noExitRuntime=Module["noExitRuntime"]||true;var WebAssembly={Memory:function(opts){this.buffer=new ArrayBuffer(opts["initial"]*65536)},Module:function(binary){},Instance:function(module,info){this.exports=( +// EMSCRIPTEN_START_ASM +function instantiate(Wa){function c(d){d.set=function(a,b){this[a]=b};d.get=function(a){return this[a]};return d}var e;var f=new Uint8Array(123);for(var a=25;a>=0;--a){f[48+a]=52+a;f[65+a]=a;f[97+a]=26+a}f[43]=62;f[47]=63;function l(m,n,o){var g,h,a=0,i=n,j=o.length,k=n+(j*3>>2)-(o[j-2]=="=")-(o[j-1]=="=");for(;a>4;if(i>2;if(i>2]=0;J[a>>2]=695;Z(19048,3304,3,19092,9376,696,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=697;Z(19048,3880,4,19104,9546,698,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=699;Z(19048,3882,2,19120,9381,700,a|0,0,0);a=Xa(4);J[a>>2]=701;Z(19048,2022,3,19128,9371,702,a|0,0,0);a=Xa(4);J[a>>2]=703;Z(19048,1969,4,19152,9571,704,a|0,0,0);ka(18924,6475,9577,53,9543,52);a=Xa(4);J[a>>2]=0;b=Xa(4);J[b>>2]=0;ca(18924,1343,18492,9390,55,a|0,18492,9385,54,b|0);a=Xa(4);J[a>>2]=4;b=Xa(4);J[b>>2]=4;ca(18924,1294,18492,9390,55,a|0,18492,9385,54,b|0);ja(18924);$(19168,19176,19192,0,9398,706,9541,0,9541,0,2364,9543,705);fa(19168,1,19208,9398,708,707);a=Xa(8);J[a+4>>2]=0;J[a>>2]=709;Z(19168,3304,3,19212,9376,710,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=711;Z(19168,3880,4,19232,9546,712,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=713;Z(19168,3882,2,19248,9381,714,a|0,0,0);a=Xa(4);J[a>>2]=715;Z(19168,2022,3,19256,9371,716,a|0,0,0);a=Xa(4);J[a>>2]=717;Z(19168,1969,4,19280,9571,718,a|0,0,0);ka(19296,1440,9577,57,9543,56);a=Xa(4);J[a>>2]=0;b=Xa(4);J[b>>2]=0;ca(19296,2280,18492,9390,59,a|0,18492,9385,58,b|0);a=Xa(4);J[a>>2]=4;b=Xa(4);J[b>>2]=4;ca(19296,5147,18492,9390,59,a|0,18492,9385,58,b|0);ja(19296);ka(18932,3221,9577,61,9543,60);a=Xa(4);J[a>>2]=0;b=Xa(4);J[b>>2]=0;ca(18932,2737,18924,9381,63,a|0,18924,9376,62,b|0);a=Xa(4);J[a>>2]=8;b=Xa(4);J[b>>2]=8;ca(18932,2712,19296,9381,65,a|0,19296,9376,64,b|0);ja(18932);ka(19304,2472,9577,67,9543,66);a=Xa(4);J[a>>2]=0;b=Xa(4);J[b>>2]=0;ca(19304,2710,18492,9390,69,a|0,18492,9385,68,b|0);a=Xa(4);J[a>>2]=4;b=Xa(4);J[b>>2]=4;ca(19304,3687,18492,9390,69,a|0,18492,9385,68,b|0);a=Xa(4);J[a>>2]=8;b=Xa(4);J[b>>2]=8;ca(19304,5149,18492,9390,69,a|0,18492,9385,68,b|0);a=Xa(4);J[a>>2]=12;b=Xa(4);J[b>>2]=12;ca(19304,5230,18492,9390,69,a|0,18492,9385,68,b|0);ja(19304);ka(19312,1389,9577,71,9543,70);a=Xa(4);J[a>>2]=0;b=Xa(4);J[b>>2]=0;ca(19312,6491,18924,9381,73,a|0,18924,9376,72,b|0);a=Xa(4);J[a>>2]=8;b=Xa(4);J[b>>2]=8;ca(19312,6472,18924,9381,73,a|0,18924,9376,72,b|0);a=Xa(4);J[a>>2]=16;b=Xa(4);J[b>>2]=16;ca(19312,3027,18492,9390,75,a|0,18492,9385,74,b|0);ja(19312);ka(19320,1375,9577,77,9543,76);a=Xa(4);J[a>>2]=0;b=Xa(4);J[b>>2]=0;ca(19320,3267,18924,9381,79,a|0,18924,9376,78,b|0);a=Xa(4);J[a>>2]=8;b=Xa(4);J[b>>2]=8;ca(19320,3018,18492,9390,81,a|0,18492,9385,80,b|0);ja(19320);ka(19328,5184,9577,83,9543,82);a=Xa(4);J[a>>2]=0;b=Xa(4);J[b>>2]=0;ca(19328,2188,18492,9390,85,a|0,18492,9385,84,b|0);a=Xa(4);J[a>>2]=4;b=Xa(4);J[b>>2]=4;ca(19328,2478,18924,9381,87,a|0,18924,9376,86,b|0);a=Xa(4);J[a>>2]=12;b=Xa(4);J[b>>2]=12;ca(19328,5565,18492,9390,85,a|0,18492,9385,84,b|0);ja(19328);ka(19336,2580,9577,89,9543,88);a=Xa(4);J[a>>2]=0;b=Xa(4);J[b>>2]=0;ca(19336,2130,18408,9381,91,a|0,18408,9376,90,b|0);a=Xa(4);J[a>>2]=2;b=Xa(4);J[b>>2]=2;ca(19336,2143,18408,9381,91,a|0,18408,9376,90,b|0);a=Xa(4);J[a>>2]=4;b=Xa(4);J[b>>2]=4;ca(19336,1305,18396,9381,93,a|0,18396,9376,92,b|0);ja(19336);$(19344,19352,19368,0,9398,95,9541,0,9541,0,3274,9543,94);a=Xa(8);J[a>>2]=8;J[a+4>>2]=1;Z(19344,4277,3,19384,9371,96,a|0,0,0);$(19436,19448,19464,19344,9398,100,9398,99,9398,98,2635,9543,97);a=Xa(4);J[a>>2]=101;Z(19436,2930,2,19480,9394,102,a|0,0,0);ia(19344,1818,2,19488,9381,104,103,0);ia(19344,4844,3,19548,9371,106,105,0);$(19568,19576,19592,0,9398,108,9541,0,9541,0,3288,9543,107);a=Xa(8);J[a>>2]=8;J[a+4>>2]=1;Z(19568,4277,6,19616,10128,109,a|0,1,0);$(19672,19684,19700,19568,9398,113,9398,112,9398,111,2656,9543,110);a=Xa(4);J[a>>2]=114;Z(19672,2930,2,19716,9394,115,a|0,0,0);ia(19568,1818,2,19724,9381,117,116,0);ia(19568,4844,3,19548,9371,106,118,0);$(19796,19804,19820,0,9398,120,9541,0,9541,0,2682,9543,119);a=Xa(8);J[a>>2]=8;J[a+4>>2]=1;Z(19796,2041,3,19836,9376,121,a|0,0,0);a=Xa(8);J[a>>2]=12;J[a+4>>2]=1;Z(19796,2054,3,19836,9376,121,a|0,0,0);a=Xa(8);J[a>>2]=16;J[a+4>>2]=1;Z(19796,3897,4,19856,9546,122,a|0,0,0);a=Xa(8);J[a>>2]=20;J[a+4>>2]=1;Z(19796,3887,4,19856,9546,122,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=123;Z(19904,4293,3,19916,9376,124,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=125;Z(19904,4291,3,19916,9376,124,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=126;Z(19904,3832,3,19944,9371,127,a|0,0,0);$(19904,19928,19956,19796,9398,131,9398,130,9398,129,2612,9543,128);a=Xa(4);J[a>>2]=132;Z(19904,2930,2,19972,9394,133,a|0,0,0);ia(19796,1818,2,19980,9381,135,134,0);ia(19796,4844,3,19548,9371,106,136,0);$(20072,20080,20096,0,9398,138,9541,0,9541,0,1370,9543,137);a=Xa(8);J[a+4>>2]=0;J[a>>2]=139;Z(20072,2222,3,20112,9376,140,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=141;Z(20072,2231,2,20124,9381,142,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=143;Z(20072,2251,3,20112,9376,140,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=144;Z(20072,2240,3,20112,9376,140,a|0,0,0);a=Xa(8);J[a>>2]=8;J[a+4>>2]=1;Z(20072,3150,5,20144,10482,145,a|0,0,0);a=Xa(8);J[a>>2]=12;J[a+4>>2]=1;Z(20072,3162,5,20144,10482,145,a|0,0,0);a=Xa(8);J[a>>2]=16;J[a+4>>2]=1;Z(20072,4590,5,20176,10489,146,a|0,0,0);a=Xa(8);J[a>>2]=20;J[a+4>>2]=1;Z(20072,4601,6,20208,10496,147,a|0,0,0);a=Xa(8);J[a>>2]=24;J[a+4>>2]=1;Z(20072,1806,5,20240,10482,148,a|0,0,0);a=Xa(8);J[a>>2]=28;J[a+4>>2]=1;Z(20072,3191,3,20260,9376,149,a|0,0,0);a=Xa(8);J[a>>2]=32;J[a+4>>2]=1;Z(20072,1560,5,20176,10489,146,a|0,0,0);$(20304,20316,20332,20072,9398,153,9398,152,9398,151,2600,9543,150);a=Xa(4);J[a>>2]=154;Z(20304,2930,2,20348,9394,155,a|0,0,0);ia(20072,1818,2,20356,9381,157,156,0);ia(20072,4844,3,19548,9371,106,158,0);$(20552,20560,20576,0,9398,160,9541,0,9541,0,5673,9543,159);fa(20552,1,20592,9398,162,161);a=Xa(8);J[a+4>>2]=0;J[a>>2]=163;Z(20552,4908,2,20596,9381,164,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=165;Z(20552,2485,2,20604,9381,166,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=167;Z(20552,2109,2,20604,9381,166,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=168;Z(20552,2587,2,20612,9390,169,a|0,0,0);a=Xa(4);J[a>>2]=170;Z(20552,4462,3,20620,9376,171,a|0,0,0);a=Xa(4);J[a>>2]=172;Z(20552,2739,4,20640,9546,173,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=174;Z(20552,2213,3,20656,9371,175,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=176;Z(20552,1417,4,20672,9571,177,a|0,0,0);a=Xa(4);J[a>>2]=0;b=Xa(4);J[b>>2]=0;_(20552,4822,18924,9381,179,a|0,18924,9376,178,b|0);a=Xa(4);J[a>>2]=8;b=Xa(4);J[b>>2]=8;_(20552,4833,18924,9381,179,a|0,18924,9376,178,b|0);$(20704,20712,20728,0,9398,181,9541,0,9541,0,4854,9543,180);fa(20704,2,20744,9381,183,182);a=Xa(8);J[a+4>>2]=0;J[a>>2]=184;Z(20704,2679,3,20752,9376,185,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=186;Z(20704,1362,3,20764,9376,187,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=188;Z(20704,1365,2,20776,9394,189,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=190;Z(20704,1213,3,20784,9371,191,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=192;Z(20704,1193,3,20844,9376,193,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=194;Z(20704,1721,3,20856,9371,195,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=196;Z(20704,1672,3,20892,9376,197,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=198;Z(20704,2719,5,20912,10732,199,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=200;Z(20704,5648,4,20944,9546,201,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=202;Z(20704,1417,5,20960,10482,203,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=204;Z(20704,3637,3,20980,9376,205,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=206;Z(20704,3654,2,20992,9381,207,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=208;Z(20704,1036,3,21e3,9376,209,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=210;Z(20704,1047,2,21012,9381,211,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=212;Z(20704,2714,2,20776,9394,189,a|0,0,0);$(21020,21028,21044,0,9398,214,9541,0,9541,0,4450,9543,213);a=Xa(4);J[a>>2]=4;b=Xa(4);J[b>>2]=4;_(21020,4330,19032,9381,216,a|0,19032,9376,215,b|0);a=Xa(4);J[a>>2]=8;b=Xa(4);J[b>>2]=8;_(21020,2080,18492,9390,218,a|0,18492,9385,217,b|0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=219;Z(21020,4362,2,21060,9381,220,a|0,0,0);a=Xa(8);J[a>>2]=12;J[a+4>>2]=1;Z(21020,1546,2,21068,9381,221,a|0,0,0);a=Xa(8);J[a>>2]=16;J[a+4>>2]=1;Z(21020,1570,4,21088,9571,222,a|0,0,0);a=Xa(8);J[a>>2]=20;J[a+4>>2]=1;Z(21020,1417,6,21104,10769,223,a|0,0,0);a=Xa(8);J[a>>2]=24;J[a+4>>2]=1;Z(21020,5666,5,21136,10482,224,a|0,0,0);a=Xa(8);J[a>>2]=28;J[a+4>>2]=1;Z(21020,2201,4,21168,10791,225,a|0,0,0);a=Xa(4);J[a>>2]=226;Z(21020,2089,3,21200,9385,227,a|0,0,0);a=Xa(4);J[a>>2]=228;Z(21020,2099,2,21212,9390,229,a|0,0,0);$(11940,21220,21236,21020,9398,233,9398,232,9398,231,4434,9543,230);fa(11940,1,21252,9398,235,234);a=Xa(4);J[a>>2]=12;b=Xa(4);J[b>>2]=12;_(11940,2735,18924,9381,237,a|0,18924,9376,236,b|0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=8;Z(11940,4456,3,21256,9371,238,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=12;Z(11940,1546,2,21292,9381,239,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=16;Z(11940,1570,4,21312,9571,240,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=20;Z(11940,1417,6,21328,10769,241,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=24;Z(11940,5666,5,21360,10482,242,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=28;Z(11940,2201,4,21392,10791,243,a|0,0,0);$(12008,21408,21424,21020,9398,247,9398,246,9398,245,4446,9543,244);a=Xa(8);J[a+4>>2]=1;J[a>>2]=8;Z(12008,4456,3,21440,9371,248,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=12;Z(12008,1546,2,21452,9381,249,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=16;Z(12008,1570,4,21472,9571,250,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=20;Z(12008,1417,6,21488,10769,251,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=24;Z(12008,5666,5,21520,10482,252,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=28;Z(12008,2201,4,21552,10791,253,a|0,0,0);$(12080,21568,21584,21020,9398,257,9398,256,9398,255,4398,9543,254);fa(12080,1,21600,9398,259,258);a=Xa(8);J[a+4>>2]=1;J[a>>2]=8;Z(12080,4456,3,21604,9371,260,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=12;Z(12080,1546,2,21616,9381,261,a|0,0,0);a=Xa(4);J[a>>2]=262;Z(12080,2026,4,21632,9546,263,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=16;Z(12080,1570,4,21648,9571,264,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=20;Z(12080,1417,6,21664,10769,265,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=24;Z(12080,5666,5,21696,10482,266,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=28;Z(12080,2201,4,21728,10791,267,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=268;Z(12080,4090,2,21744,9381,269,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=270;Z(12080,1296,4,21760,9343,271,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=272;Z(12080,4554,6,21776,10939,273,a|0,0,0);$(21800,21808,21824,0,9398,275,9541,0,9541,0,3821,9543,274);fa(21800,1,21840,9398,277,276);a=Xa(4);J[a>>2]=278;Z(21800,4380,3,21844,9376,279,a|0,0,0);a=Xa(4);J[a>>2]=280;Z(21800,4389,2,21856,9381,281,a|0,0,0);a=Xa(4);J[a>>2]=8;b=Xa(4);J[b>>2]=8;_(21800,2950,18492,9390,283,a|0,18492,9385,282,b|0);a=Xa(4);J[a>>2]=12;b=Xa(4);J[b>>2]=12;_(21800,2829,18492,9390,283,a|0,18492,9385,282,b|0);a=Xa(4);J[a>>2]=16;b=Xa(4);J[b>>2]=16;_(21800,1058,18492,9390,283,a|0,18492,9385,282,b|0);a=Xa(4);J[a>>2]=20;b=Xa(4);J[b>>2]=20;_(21800,2454,18348,9381,285,a|0,18348,9376,284,b|0);a=Xa(4);J[a>>2]=22;b=Xa(4);J[b>>2]=22;_(21800,2573,19336,9381,287,a|0,19336,9376,286,b|0);$(21864,21872,21888,0,9398,289,9541,0,9541,0,4322,9543,288);a=Xa(8);J[a+4>>2]=0;J[a>>2]=290;Z(21864,4362,2,21904,9381,291,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=292;Z(21864,4389,2,21912,9381,293,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=294;Z(21864,2444,3,21920,9376,295,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=296;Z(21864,2463,2,21932,9381,297,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=298;Z(21864,5193,3,21940,9376,299,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=300;Z(21864,5207,2,21952,9381,301,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=302;Z(21864,2571,2,21960,9394,303,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=304;Z(21864,1205,2,21968,9381,305,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=306;Z(21864,1570,3,21976,9371,307,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=308;Z(21864,1417,5,22e3,11031,309,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=310;Z(21864,5181,3,22020,9376,311,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=312;Z(21864,1066,3,22032,9385,313,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=314;Z(21864,1077,2,22044,9390,315,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=316;Z(21864,3006,2,22044,9390,315,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=317;Z(21864,2987,3,22032,9385,313,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=318;Z(21864,2894,2,22044,9390,315,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=319;Z(21864,2872,3,22032,9385,313,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=320;Z(21864,5658,3,22052,9371,321,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=322;Z(21864,2714,3,22064,9376,323,a|0,0,0);$(20820,22076,20828,0,9398,325,9541,0,9541,0,3693,9543,324);fa(20820,1,22092,9398,327,326);a=Xa(4);J[a>>2]=0;b=Xa(4);J[b>>2]=0;_(20820,4332,19040,9381,329,a|0,19040,9376,328,b|0);a=Xa(4);J[a>>2]=4;b=Xa(4);J[b>>2]=4;_(20820,2909,18924,9381,331,a|0,18924,9376,330,b|0);a=Xa(4);J[a>>2]=12;b=Xa(4);J[b>>2]=12;_(20820,4470,18492,9390,333,a|0,18492,9385,332,b|0);a=Xa(4);J[a>>2]=16;b=Xa(4);J[b>>2]=16;_(20820,1142,18924,9381,331,a|0,18924,9376,330,b|0);a=Xa(4);J[a>>2]=24;b=Xa(4);J[b>>2]=24;_(20820,1088,18492,9390,333,a|0,18492,9385,332,b|0);a=Xa(4);J[a>>2]=28;b=Xa(4);J[b>>2]=28;_(20820,3589,18492,9390,333,a|0,18492,9385,332,b|0);a=Xa(4);J[a>>2]=32;b=Xa(4);J[b>>2]=32;_(20820,3538,18492,9390,333,a|0,18492,9385,332,b|0);a=Xa(4);J[a>>2]=36;b=Xa(4);J[b>>2]=36;_(20820,2724,18348,9381,335,a|0,18348,9376,334,b|0);a=Xa(4);J[a>>2]=37;b=Xa(4);J[b>>2]=37;_(20820,4669,18348,9381,335,a|0,18348,9376,334,b|0);a=Xa(4);J[a>>2]=38;b=Xa(4);J[b>>2]=38;_(20820,3039,18348,9381,335,a|0,18348,9376,334,b|0);a=Xa(4);J[a>>2]=39;b=Xa(4);J[b>>2]=39;_(20820,1973,18348,9381,335,a|0,18348,9376,334,b|0);a=Xa(4);J[a>>2]=48;b=Xa(4);J[b>>2]=48;_(20820,4624,18492,9390,333,a|0,18492,9385,332,b|0);$(20796,20804,22096,0,9398,337,9541,0,9541,0,1265,9543,336);a=Xa(8);J[a+4>>2]=0;J[a>>2]=338;Z(20796,4316,3,22112,9371,339,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=340;Z(20796,4411,4,22128,11060,341,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=342;Z(20796,4262,3,22144,9376,343,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=344;Z(20796,3205,4,22160,10791,345,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=346;Z(20796,3218,2,22176,9381,347,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=348;Z(20796,2918,2,22184,9381,349,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=350;Z(20796,4490,2,22192,9390,351,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=352;Z(20796,2556,2,22184,9381,349,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=353;Z(20796,2541,2,22184,9381,349,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=354;Z(20796,1157,3,22200,9376,355,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=356;Z(20796,1175,2,22184,9381,349,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=357;Z(20796,1104,3,22212,9385,358,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=359;Z(20796,1123,2,22192,9390,351,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=360;Z(20796,4699,5,22224,10482,361,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=362;Z(20796,2522,4,22256,9546,363,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=364;Z(20796,3906,4,22272,11066,365,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=366;Z(20796,4182,5,22224,10482,361,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=367;Z(20796,2495,4,22256,9546,363,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=368;Z(20796,4162,4,22272,11066,365,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=369;Z(20796,2193,2,22192,9390,351,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=370;Z(20796,5221,2,22192,9390,351,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=371;Z(20796,5181,3,22288,9376,372,a|0,0,0);a=Xa(4);J[a>>2]=373;Z(20796,5169,3,22300,9376,374,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=375;Z(20796,5155,2,22312,9394,376,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=377;Z(20796,1626,3,22320,9371,378,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=379;Z(20796,2349,3,22320,9371,378,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=380;Z(20796,1580,3,22320,9371,378,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=381;Z(20796,2334,3,22320,9371,378,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=382;Z(20796,1640,3,22320,9371,378,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=383;Z(20796,1594,3,22320,9371,378,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=384;Z(20796,3620,2,22192,9390,351,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=385;Z(20796,3603,3,22212,9385,358,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=386;Z(20796,3571,2,22192,9390,351,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=387;Z(20796,3553,3,22212,9385,358,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=388;Z(20796,4653,2,22192,9390,351,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=389;Z(20796,4637,3,22212,9385,358,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=390;Z(20796,4346,3,22332,9376,391,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=392;Z(20796,4362,2,22344,9381,393,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=394;Z(20796,1980,3,22352,9376,395,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=396;Z(20796,1990,2,22364,9381,397,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=398;Z(20796,4916,3,22352,9376,395,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=399;Z(20796,4935,2,22364,9381,397,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=400;Z(20796,4675,3,22352,9376,395,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=401;Z(20796,4684,2,22364,9381,397,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=402;Z(20796,5012,3,22352,9376,395,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=403;Z(20796,5023,2,22364,9381,397,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=404;Z(20796,3053,3,22352,9376,395,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=405;Z(20796,3070,2,22364,9381,397,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=406;Z(20796,1402,2,22372,9381,407,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=408;Z(20796,4851,2,22380,9381,409,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=410;Z(20796,2714,2,22312,9394,376,a|0,0,0);$(20868,22388,20876,0,9398,412,9541,0,9541,0,3812,9543,411);fa(20868,1,22404,9398,414,413);a=Xa(4);J[a>>2]=0;b=Xa(4);J[b>>2]=0;_(20868,4332,22408,9381,416,a|0,22408,9376,415,b|0);a=Xa(4);J[a>>2]=417;Z(20868,5678,3,22416,9376,418,a|0,0,0);a=Xa(4);J[a>>2]=419;Z(20868,5687,2,22428,9381,420,a|0,0,0);a=Xa(4);J[a>>2]=421;Z(20868,5571,3,22416,9376,418,a|0,0,0);a=Xa(4);J[a>>2]=422;Z(20868,5580,2,22428,9381,420,a|0,0,0);a=Xa(4);J[a>>2]=16;b=Xa(4);J[b>>2]=16;_(20868,4953,18348,9381,424,a|0,18348,9376,423,b|0);$(12896,18896,22436,0,9398,426,9541,0,9541,0,1787,9543,425);a=Xa(8);J[a+4>>2]=0;J[a>>2]=427;Z(12896,4362,2,22452,9381,428,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=429;Z(12896,5687,2,22460,9381,430,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=431;Z(12896,5580,2,22460,9381,430,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=0;Z(12896,5721,2,22468,9381,432,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=4;Z(12896,5589,2,22468,9381,432,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=8;Z(12896,4805,3,22476,11111,433,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=12;Z(12896,4020,3,22488,11116,434,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=435;Z(12896,4970,2,22500,9381,436,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=16;Z(12896,2714,2,22508,9394,437,a|0,0,0);$(22516,22528,22544,20868,9398,441,9398,440,9398,439,3773,9543,438);fa(22516,1,22560,9398,443,442);a=Xa(4);J[a>>2]=20;b=Xa(4);J[b>>2]=20;_(22516,5732,18924,9381,445,a|0,18924,9376,444,b|0);a=Xa(4);J[a>>2]=28;b=Xa(4);J[b>>2]=28;_(22516,5600,18924,9381,445,a|0,18924,9376,444,b|0);a=Xa(4);J[a>>2]=36;b=Xa(4);J[b>>2]=36;_(22516,3314,18492,9390,447,a|0,18492,9385,446,b|0);a=Xa(4);J[a>>2]=40;b=Xa(4);J[b>>2]=40;_(22516,2152,18492,9390,447,a|0,18492,9385,446,b|0);a=Xa(4);J[a>>2]=44;b=Xa(4);J[b>>2]=44;_(22516,3508,18492,9390,447,a|0,18492,9385,446,b|0);$(12524,22564,22580,12896,9398,451,9398,450,9398,449,1754,9543,448);a=Xa(8);J[a+4>>2]=0;J[a>>2]=452;Z(12524,5745,2,22596,9381,453,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=454;Z(12524,5613,2,22596,9381,453,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=455;Z(12524,3357,3,22604,9385,456,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=457;Z(12524,3367,2,22616,9390,458,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=459;Z(12524,2162,3,22604,9385,456,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=460;Z(12524,2175,2,22616,9390,458,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=461;Z(12524,3516,3,22604,9385,456,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=462;Z(12524,3527,2,22616,9390,458,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=16;Z(12524,2714,2,22624,9394,463,a|0,0,0);$(22632,22644,22660,20868,9398,467,9398,466,9398,465,3701,9543,464);fa(22632,1,22676,9398,469,468);a=Xa(4);J[a>>2]=20;b=Xa(4);J[b>>2]=20;_(22632,1928,18924,9381,471,a|0,18924,9376,470,b|0);a=Xa(4);J[a>>2]=28;b=Xa(4);J[b>>2]=28;_(22632,1880,18492,9390,473,a|0,18492,9385,472,b|0);a=Xa(4);J[a>>2]=32;b=Xa(4);J[b>>2]=32;_(22632,4710,18492,9390,473,a|0,18492,9385,472,b|0);a=Xa(4);J[a>>2]=36;b=Xa(4);J[b>>2]=36;_(22632,3918,18492,9390,473,a|0,18492,9385,472,b|0);a=Xa(4);J[a>>2]=40;b=Xa(4);J[b>>2]=40;_(22632,2387,18492,9390,473,a|0,18492,9385,472,b|0);$(13020,22680,22696,12896,9398,477,9398,476,9398,475,1685,9543,474);a=Xa(8);J[a+4>>2]=0;J[a>>2]=478;Z(13020,1941,3,22712,9376,479,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=480;Z(13020,1957,2,22724,9381,481,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=482;Z(13020,1894,3,22732,9385,483,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=484;Z(13020,1911,2,22744,9390,485,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=486;Z(13020,4719,3,22732,9385,483,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=487;Z(13020,4731,2,22744,9390,485,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=488;Z(13020,3928,3,22732,9385,483,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=489;Z(13020,3941,2,22744,9390,485,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=490;Z(13020,2404,3,22732,9385,483,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=491;Z(13020,2424,2,22744,9390,485,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=16;Z(13020,2714,2,22752,9394,492,a|0,0,0);$(22760,22772,22788,20868,9398,496,9398,495,9398,494,3746,9543,493);fa(22760,1,22804,9398,498,497);a=Xa(4);J[a>>2]=20;b=Xa(4);J[b>>2]=20;_(22760,1999,18924,9381,500,a|0,18924,9376,499,b|0);a=Xa(4);J[a>>2]=28;b=Xa(4);J[b>>2]=28;_(22760,4710,18492,9390,502,a|0,18492,9385,501,b|0);a=Xa(4);J[a>>2]=32;b=Xa(4);J[b>>2]=32;_(22760,1024,18492,9390,502,a|0,18492,9385,501,b|0);a=Xa(4);J[a>>2]=36;b=Xa(4);J[b>>2]=36;_(22760,2750,18492,9390,502,a|0,18492,9385,501,b|0);$(13104,22808,22824,12896,9398,506,9398,505,9398,504,1733,9543,503);a=Xa(8);J[a+4>>2]=0;J[a>>2]=507;Z(13104,2006,3,22840,9376,508,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=509;Z(13104,2016,2,22852,9381,510,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=511;Z(13104,4719,3,22860,9385,512,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=513;Z(13104,4731,2,22872,9390,514,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=515;Z(13104,1270,3,22860,9385,512,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=516;Z(13104,1283,2,22872,9390,514,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=517;Z(13104,2763,3,22860,9385,512,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=518;Z(13104,2779,2,22872,9390,514,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=16;Z(13104,2714,2,22880,9394,519,a|0,0,0);$(22888,22900,22916,20868,9398,523,9398,522,9398,521,3803,9543,520);fa(22888,1,22932,9398,525,524);a=Xa(4);J[a>>2]=20;b=Xa(4);J[b>>2]=20;_(22888,5732,18924,9381,527,a|0,18924,9376,526,b|0);a=Xa(4);J[a>>2]=28;b=Xa(4);J[b>>2]=28;_(22888,5600,18924,9381,527,a|0,18924,9376,526,b|0);a=Xa(4);J[a>>2]=36;b=Xa(4);J[b>>2]=36;_(22888,5696,18924,9381,527,a|0,18924,9376,526,b|0);a=Xa(4);J[a>>2]=44;b=Xa(4);J[b>>2]=44;_(22888,4521,18492,9390,529,a|0,18492,9385,528,b|0);a=Xa(4);J[a>>2]=48;b=Xa(4);J[b>>2]=48;_(22888,1856,18348,9381,531,a|0,18348,9376,530,b|0);a=Xa(4);J[a>>2]=52;b=Xa(4);J[b>>2]=52;_(22888,3106,18492,9390,529,a|0,18492,9385,528,b|0);a=Xa(4);J[a>>2]=56;b=Xa(4);J[b>>2]=56;_(22888,3123,18492,9390,529,a|0,18492,9385,528,b|0);a=Xa(4);J[a>>2]=60;b=Xa(4);J[b>>2]=60;_(22888,2310,18348,9381,531,a|0,18348,9376,530,b|0);a=Xa(4);J[a>>2]=68;b=Xa(4);J[b>>2]=68;_(22888,5108,18492,9390,529,a|0,18492,9385,528,b|0);a=Xa(4);J[a>>2]=64;b=Xa(4);J[b>>2]=64;_(22888,4743,18492,9390,529,a|0,18492,9385,528,b|0);$(13304,22936,22952,12896,9398,535,9398,534,9398,533,1778,9543,532);a=Xa(8);J[a+4>>2]=0;J[a>>2]=536;Z(13304,5745,2,22968,9381,537,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=538;Z(13304,5613,2,22968,9381,537,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=539;Z(13304,5707,2,22968,9381,537,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=540;Z(13304,4536,2,22976,9390,541,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=542;Z(13304,3086,2,22976,9390,541,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=543;Z(13304,5048,2,22976,9390,541,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=544;Z(13304,4990,2,22984,9381,545,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=546;Z(13304,1868,3,22992,9376,547,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=548;Z(13304,1828,2,22976,9390,541,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=549;Z(13304,1842,2,22976,9390,541,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=550;Z(13304,2120,4,23008,9343,551,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=552;Z(13304,5033,2,22984,9381,545,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=553;Z(13304,2322,3,22992,9376,547,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=554;Z(13304,5119,3,23024,9385,555,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=556;Z(13304,5133,2,22976,9390,541,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=557;Z(13304,4757,3,23024,9385,555,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=558;Z(13304,4774,2,22976,9390,541,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=559;Z(13304,4791,3,23036,11116,560,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=16;Z(13304,2714,2,23048,9394,561,a|0,0,0);$(23056,23068,23084,20868,9398,565,9398,564,9398,563,3729,9543,562);fa(23056,1,23100,9398,567,566);a=Xa(4);J[a>>2]=20;b=Xa(4);J[b>>2]=20;_(23056,5732,18924,9381,569,a|0,18924,9376,568,b|0);a=Xa(4);J[a>>2]=28;b=Xa(4);J[b>>2]=28;_(23056,5600,18924,9381,569,a|0,18924,9376,568,b|0);a=Xa(4);J[a>>2]=36;b=Xa(4);J[b>>2]=36;_(23056,4521,18492,9390,571,a|0,18492,9385,570,b|0);a=Xa(4);J[a>>2]=40;b=Xa(4);J[b>>2]=40;_(23056,1856,18348,9381,573,a|0,18348,9376,572,b|0);a=Xa(4);J[a>>2]=44;b=Xa(4);J[b>>2]=44;_(23056,4499,18492,9390,571,a|0,18492,9385,570,b|0);a=Xa(4);J[a>>2]=48;b=Xa(4);J[b>>2]=48;_(23056,4510,18492,9390,571,a|0,18492,9385,570,b|0);a=Xa(4);J[a>>2]=52;b=Xa(4);J[b>>2]=52;_(23056,2310,18348,9381,573,a|0,18348,9376,572,b|0);a=Xa(4);J[a>>2]=56;b=Xa(4);J[b>>2]=56;_(23056,5108,18492,9390,571,a|0,18492,9385,570,b|0);a=Xa(4);J[a>>2]=60;b=Xa(4);J[b>>2]=60;_(23056,3954,18492,9390,571,a|0,18492,9385,570,b|0);$(13476,23104,23120,12896,9398,577,9398,576,9398,575,1707,9543,574);a=Xa(8);J[a+4>>2]=0;J[a>>2]=578;Z(13476,5745,2,23136,9381,579,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=580;Z(13476,5613,2,23136,9381,579,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=581;Z(13476,4536,2,23144,9390,582,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=583;Z(13476,4476,2,23144,9390,582,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=584;Z(13476,5048,2,23144,9390,582,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=585;Z(13476,4990,2,23152,9381,586,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=587;Z(13476,1868,3,23160,9376,588,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=589;Z(13476,1828,2,23144,9390,582,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=590;Z(13476,1842,2,23144,9390,582,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=591;Z(13476,2120,4,23184,9343,592,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=593;Z(13476,5033,2,23152,9381,586,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=594;Z(13476,2322,3,23160,9376,588,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=595;Z(13476,5119,3,23200,9385,596,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=597;Z(13476,5133,2,23144,9390,582,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=598;Z(13476,3969,3,23200,9385,596,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=599;Z(13476,3987,2,23144,9390,582,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=600;Z(13476,4005,3,23212,11116,601,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=16;Z(13476,2714,2,23224,9394,602,a|0,0,0);$(23232,23244,23260,20868,9398,606,9398,605,9398,604,3760,9543,603);fa(23232,1,23276,9398,608,607);a=Xa(4);J[a>>2]=20;b=Xa(4);J[b>>2]=20;_(23232,5732,18924,9381,610,a|0,18924,9376,609,b|0);a=Xa(4);J[a>>2]=28;b=Xa(4);J[b>>2]=28;_(23232,5600,18924,9381,610,a|0,18924,9376,609,b|0);a=Xa(4);J[a>>2]=36;b=Xa(4);J[b>>2]=36;_(23232,3321,18492,9390,612,a|0,18492,9385,611,b|0);$(13560,23280,23296,12896,9398,616,9398,615,9398,614,1744,9543,613);a=Xa(8);J[a+4>>2]=0;J[a>>2]=617;Z(13560,5745,2,23312,9381,618,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=619;Z(13560,5613,2,23312,9381,618,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=8;Z(13560,4805,3,23320,11111,620,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=12;Z(13560,4020,3,23332,11116,621,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=622;Z(13560,3331,3,23344,9385,623,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=624;Z(13560,3344,2,23356,9390,625,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=626;Z(13560,3367,2,23356,9390,625,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=16;Z(13560,2714,2,23364,9394,627,a|0,0,0);$(23372,23384,23400,20868,9398,631,9398,630,9398,629,3790,9543,628);fa(23372,1,23416,9398,633,632);a=Xa(4);J[a>>2]=20;b=Xa(4);J[b>>2]=20;_(23372,5732,18924,9381,635,a|0,18924,9376,634,b|0);a=Xa(4);J[a>>2]=28;b=Xa(4);J[b>>2]=28;_(23372,5600,18924,9381,635,a|0,18924,9376,634,b|0);a=Xa(4);J[a>>2]=36;b=Xa(4);J[b>>2]=36;_(23372,4521,18492,9390,637,a|0,18492,9385,636,b|0);a=Xa(4);J[a>>2]=40;b=Xa(4);J[b>>2]=40;_(23372,2152,18492,9390,637,a|0,18492,9385,636,b|0);a=Xa(4);J[a>>2]=44;b=Xa(4);J[b>>2]=44;_(23372,3508,18492,9390,637,a|0,18492,9385,636,b|0);$(13644,23420,23436,12896,9398,641,9398,640,9398,639,1768,9543,638);a=Xa(8);J[a+4>>2]=0;J[a>>2]=642;Z(13644,5745,2,23452,9381,643,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=644;Z(13644,5613,2,23452,9381,643,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=645;Z(13644,4536,2,23460,9390,646,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=647;Z(13644,2162,3,23468,9385,648,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=649;Z(13644,2175,2,23460,9390,646,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=650;Z(13644,3516,3,23468,9385,648,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=651;Z(13644,3527,2,23460,9390,646,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=16;Z(13644,2714,2,23480,9394,652,a|0,0,0);$(23488,23500,23516,20868,9398,656,9398,655,9398,654,3715,9543,653);fa(23488,1,23532,9398,658,657);a=Xa(4);J[a>>2]=20;b=Xa(4);J[b>>2]=20;_(23488,5732,18924,9381,660,a|0,18924,9376,659,b|0);a=Xa(4);J[a>>2]=28;b=Xa(4);J[b>>2]=28;_(23488,5600,18924,9381,660,a|0,18924,9376,659,b|0);a=Xa(4);J[a>>2]=36;b=Xa(4);J[b>>2]=36;_(23488,5696,18924,9381,660,a|0,18924,9376,659,b|0);a=Xa(4);J[a>>2]=44;b=Xa(4);J[b>>2]=44;_(23488,1856,18348,9381,662,a|0,18348,9376,661,b|0);a=Xa(4);J[a>>2]=48;b=Xa(4);J[b>>2]=48;_(23488,3106,18492,9390,664,a|0,18492,9385,663,b|0);a=Xa(4);J[a>>2]=52;b=Xa(4);J[b>>2]=52;_(23488,3123,18492,9390,664,a|0,18492,9385,663,b|0);a=Xa(4);J[a>>2]=56;b=Xa(4);J[b>>2]=56;_(23488,2310,18348,9381,662,a|0,18348,9376,661,b|0);a=Xa(4);J[a>>2]=60;b=Xa(4);J[b>>2]=60;_(23488,3954,18492,9390,664,a|0,18492,9385,663,b|0);a=Xa(4);J[a>>2]=64;b=Xa(4);J[b>>2]=64;_(23488,5108,18492,9390,664,a|0,18492,9385,663,b|0);a=Xa(4);J[a>>2]=68;b=Xa(4);J[b>>2]=68;_(23488,2152,18492,9390,664,a|0,18492,9385,663,b|0);a=Xa(4);J[a>>2]=72;b=Xa(4);J[b>>2]=72;_(23488,3508,18492,9390,664,a|0,18492,9385,663,b|0);$(13728,23536,23552,12896,9398,668,9398,667,9398,666,1696,9543,665);a=Xa(8);J[a+4>>2]=0;J[a>>2]=669;Z(13728,5745,2,23568,9381,670,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=671;Z(13728,5613,2,23568,9381,670,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=672;Z(13728,5707,2,23568,9381,670,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=673;Z(13728,3086,2,23576,9390,674,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=675;Z(13728,5033,2,23584,9381,676,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=677;Z(13728,2322,3,23592,9376,678,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=679;Z(13728,5119,3,23604,9385,680,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=681;Z(13728,5133,2,23576,9390,674,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=682;Z(13728,3969,3,23604,9385,680,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=683;Z(13728,3987,2,23576,9390,674,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=684;Z(13728,4005,3,23616,11116,685,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=686;Z(13728,2162,3,23604,9385,680,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=687;Z(13728,2175,2,23576,9390,674,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=688;Z(13728,3516,3,23604,9385,680,a|0,0,0);a=Xa(8);J[a+4>>2]=0;J[a>>2]=689;Z(13728,3527,2,23576,9390,674,a|0,0,0);a=Xa(8);J[a+4>>2]=1;J[a>>2]=16;Z(13728,2714,2,23628,9394,690,a|0,0,0)}function Gf(a,b,c,d){a=a|0;b=Q(b);c=c|0;d=d|0;var e=0,f=Q(0),g=0,h=0,i=0,j=0,k=Q(0),l=0,m=Q(0),n=Q(0),o=0,p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=0,u=0,v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=0,C=0,D=0,E=Q(0),F=0,G=Q(0),M=Q(0),O=Q(0),R=Q(0),S=0,T=Q(0),U=Q(0),W=Q(0),X=Q(0),Z=Q(0),_=0,$=0,aa=Q(0),ba=Q(0),ca=Q(0),da=0,ea=0,fa=Q(0),ga=0,ha=Q(0),ia=Q(0),ja=0,ka=Q(0),la=Q(0),ma=Q(0),na=Q(0),oa=Q(0),pa=Q(0),qa=Q(0),ra=Q(0),sa=0,ta=Q(0),ua=Q(0),va=Q(0),wa=Q(0),xa=Q(0),ya=Q(0),za=Q(0),Aa=Q(0);D=La-32|0;La=D;if(K[a+102988|0]){fc(a+102868|0);H[a+102988|0]=0}H[a+102989|0]=1;J[D+20>>2]=d;J[D+16>>2]=c;N[D+4>>2]=b;o=b>Q(0);N[D+8>>2]=o?Q(Q(1)/b):Q(0);N[D+12>>2]=N[a+102984>>2]*b;H[D+24|0]=K[a+102991|0];h=a+102868|0;c=J[h+60>>2];if(c){while(1){d=c;t=J[d+60>>2];F=J[d+56>>2];e=J[d+52>>2];g=J[e+8>>2];j=J[d+48>>2];l=J[j+8>>2];a:{b:{c:{c=J[d+4>>2];d:{if(c&8){i=J[h+68>>2];if(i){if(!(Na[J[J[i>>2]+8>>2]](i,j,e)|0)){break d}c=J[d+4>>2]}J[d+4>>2]=c&-9}c=0;if(!((K[l+4|0]&2?J[l>>2]!=0:c)|(K[g+4|0]&2?J[g>>2]!=0:0))){break b}c=P(J[(J[e+24>>2]+P(t,28)|0)+24>>2],40);e=J[h+4>>2];c=c+e|0;e=e+P(J[(J[j+24>>2]+P(F,28)|0)+24>>2],40)|0;if(Q(N[c>>2]-N[e+8>>2])>Q(0)|Q(N[c+4>>2]-N[e+12>>2])>Q(0)|Q(N[e>>2]-N[c+8>>2])>Q(0)){break d}if(!(Q(N[e+4>>2]-N[c+12>>2])>Q(0))){break c}}c=J[d+12>>2];Rb(h,d);break a}vc(d,J[h+72>>2])}c=J[d+12>>2]}if(c){continue}break}}N[a+103e3>>2]=0;if(!(!K[a+102994|0]|!o)){o=La-96|0;La=o;J[a+103016>>2]=0;c=a+103008|0;J[c>>2]=0;J[c+4>>2]=0;$=a+68|0;e=dd(o+44|0,J[a+102956>>2],J[a+102932>>2],J[a+102960>>2],$,J[a+102940>>2]);d=J[a+102948>>2];if(d){while(1){I[d+4>>1]=L[d+4>>1]&65534;d=J[d+96>>2];if(d){continue}break}}d=J[a+102928>>2];if(d){while(1){J[d+4>>2]=J[d+4>>2]&-2;d=J[d+12>>2];if(d){continue}break}}d=J[a+102952>>2];if(d){while(1){H[d+60|0]=0;d=J[d+12>>2];if(d){continue}break}}F=Fb($,J[a+102956>>2]<<2);t=J[a+102948>>2];if(t){_=a+102964|0;while(1){c=L[t+4>>1];e:{if(!J[t>>2]|(c&35)!=34){break e}J[F>>2]=t;h=1;I[t+4>>1]=c|1;i=0;j=0;g=0;while(1){h=h-1|0;c=J[F+(h<<2)>>2];J[c+8>>2]=i;J[J[e+8>>2]+(i<<2)>>2]=c;f:{if(!J[c>>2]){break f}I[c+4>>1]=L[c+4>>1]|2;d=J[c+112>>2];if(d){while(1){l=J[d+4>>2];u=J[l+4>>2];g:{if((u&7)!=6|K[J[l+48>>2]+38|0]|K[J[l+52>>2]+38|0]){break g}J[J[e+12>>2]+(j<<2)>>2]=l;J[l+4>>2]=u|1;j=j+1|0;l=J[d>>2];u=L[l+4>>1];if(u&1){break g}J[F+(h<<2)>>2]=l;I[l+4>>1]=u|1;h=h+1|0}d=J[d+12>>2];if(d){continue}break}}d=J[c+108>>2];if(!d){break f}while(1){u=J[d+4>>2];h:{if(K[u+60|0]){break h}c=J[d>>2];l=L[c+4>>1];if(!(l&32)){break h}J[J[e+16>>2]+(g<<2)>>2]=u;H[J[d+4>>2]+60|0]=1;g=g+1|0;if(l&1){break h}J[F+(h<<2)>>2]=c;I[c+4>>1]=l|1;h=h+1|0}d=J[d+12>>2];if(d){continue}break}}i=i+1|0;if((h|0)>0){continue}break}J[e+36>>2]=j;J[e+28>>2]=i;J[e+32>>2]=g;ja=K[a+102972|0];g=0;h=0;j=La-160|0;La=j;m=N[D+4>>2];if(J[e+28>>2]>0){while(1){d=J[J[e+8>>2]+(g<<2)>>2];x=N[d+56>>2];N[d+52>>2]=x;l=J[d+48>>2];c=J[d+44>>2];J[d+36>>2]=c;J[d+40>>2]=l;b=N[d+72>>2];k=N[d+64>>2];f=N[d+68>>2];if(J[d>>2]==2){n=Q(m*N[d+120>>2]);q=Q(N[d+140>>2]*N[d+116>>2]);G=Q(Q(1)/Q(Q(m*N[d+132>>2])+Q(1)));f=Q(Q(f+Q(n*Q(Q(q*N[_+4>>2])+N[d+80>>2])))*G);k=Q(Q(k+Q(n*Q(Q(N[_>>2]*q)+N[d+76>>2])))*G);b=Q(Q(Q(Q(m*N[d+128>>2])*N[d+84>>2])+b)*Q(Q(1)/Q(Q(m*N[d+136>>2])+Q(1))))}d=P(g,12);i=d+J[e+20>>2]|0;J[i>>2]=c;J[i+4>>2]=l;N[(d+J[e+20>>2]|0)+8>>2]=x;c=d+J[e+24>>2]|0;N[c+4>>2]=f;N[c>>2]=k;N[(d+J[e+24>>2]|0)+8>>2]=b;g=g+1|0;if((g|0)>2]){continue}break}}c=J[D+24>>2];J[j+120>>2]=J[D+20>>2];J[j+124>>2]=c;c=J[D+16>>2];J[j+112>>2]=J[D+12>>2];J[j+116>>2]=c;c=J[D+8>>2];J[j+104>>2]=J[D+4>>2];J[j+108>>2]=c;c=J[e+20>>2];J[j+128>>2]=c;d=J[e+24>>2];J[j+132>>2]=d;g=J[D+24>>2];J[j+72>>2]=J[D+20>>2];J[j+76>>2]=g;l=J[D+16>>2];g=j- -64|0;J[g>>2]=J[D+12>>2];J[g+4>>2]=l;g=J[D+8>>2];J[j+56>>2]=J[D+4>>2];J[j+60>>2]=g;J[j+80>>2]=J[e+12>>2];g=J[e+36>>2];J[j+92>>2]=d;J[j+88>>2]=c;J[j+84>>2]=g;J[j+96>>2]=J[e>>2];l=id(j+4|0,j+56|0);gd(l);if(J[l+48>>2]>0?K[D+24|0]:0){g=J[l+28>>2];while(1){c=J[l+40>>2]+P(h,156)|0;u=P(J[c+116>>2],12);d=u+g|0;b=N[d+8>>2];k=N[d+4>>2];f=N[d>>2];B=P(J[c+112>>2],12);g=B+g|0;n=N[g+8>>2];q=N[g+4>>2];p=N[g>>2];C=J[c+148>>2];if((C|0)>0){A=N[c+72>>2];M=N[c+132>>2];r=N[c+124>>2];v=N[c+120>>2];z=N[c+76>>2];w=Q(-N[c+128>>2]);i=0;while(1){d=c+P(i,36)|0;G=N[d+16>>2];R=N[d+20>>2];x=Q(Q(z*G)-Q(A*R));G=Q(Q(A*G)+Q(z*R));b=Q(Q(M*Q(Q(N[d+8>>2]*x)-Q(G*N[d+12>>2])))+b);n=Q(Q(w*Q(Q(N[d>>2]*x)-Q(G*N[d+4>>2])))+n);k=Q(k+Q(r*x));f=Q(f+Q(r*G));q=Q(q-Q(v*x));p=Q(p-Q(v*G));i=i+1|0;if((C|0)!=(i|0)){continue}break}}N[g+4>>2]=q;N[g>>2]=p;c=J[l+28>>2];N[(c+B|0)+8>>2]=n;c=c+u|0;N[c+4>>2]=k;N[c>>2]=f;g=J[l+28>>2];N[(u+g|0)+8>>2]=b;h=h+1|0;if((h|0)>2]){continue}break}}if(J[e+32>>2]>0){d=0;while(1){c=J[J[e+16>>2]+(d<<2)>>2];Na[J[J[c>>2]+36>>2]](c,j+104|0);d=d+1|0;if((d|0)>2]){continue}break}}N[o+24>>2]=0;if(J[D+16>>2]>0){c=0;while(1){d=0;if(J[e+32>>2]>0){while(1){h=J[J[e+16>>2]+(d<<2)>>2];Na[J[J[h>>2]+40>>2]](h,j+104|0);d=d+1|0;if((d|0)>2]){continue}break}}fd(l);c=c+1|0;if((c|0)>2]){continue}break}}c=0;B=J[l+48>>2];if((B|0)>0){C=J[l+44>>2];ga=J[l+40>>2];while(1){g=ga+P(c,156)|0;i=J[g+148>>2];i:{if((i|0)<=0){break i}u=J[C+(J[g+152>>2]<<2)>>2]- -64|0;d=0;if((i|0)!=1){da=i&-2;h=0;while(1){S=u+P(d,20)|0;ea=g+P(d,36)|0;N[S+8>>2]=N[ea+16>>2];N[S+12>>2]=N[ea+20>>2];S=d|1;ea=u+P(S,20)|0;S=g+P(S,36)|0;N[ea+8>>2]=N[S+16>>2];N[ea+12>>2]=N[S+20>>2];d=d+2|0;h=h+2|0;if((da|0)!=(h|0)){continue}break}}if(!(i&1)){break i}h=u+P(d,20)|0;d=g+P(d,36)|0;N[h+8>>2]=N[d+16>>2];N[h+12>>2]=N[d+20>>2]}c=c+1|0;if((B|0)!=(c|0)){continue}break}}N[o+28>>2]=0;h=1;if(J[e+28>>2]>0){g=J[e+24>>2];c=0;while(1){d=P(c,12);i=d+g|0;b=N[i>>2];f=Q(m*b);w=Q(f*f);k=N[i+4>>2];f=Q(m*k);f=Q(w+Q(f*f));if(f>Q(4)){f=Q(Q(2)/Q(Y(f)));k=Q(k*f);b=Q(b*f)}g=d+J[e+20>>2]|0;n=N[g+8>>2];q=N[g+4>>2];G=N[g>>2];f=N[i+8>>2];x=Q(m*f);if(Q(x*x)>Q(2.4674012660980225)){f=Q(f*Q(Q(1.5707963705062866)/(x>Q(0)?x:Q(-x))))}N[g+4>>2]=q+Q(m*k);N[g>>2]=G+Q(m*b);N[(d+J[e+20>>2]|0)+8>>2]=Q(m*f)+n;g=d+J[e+24>>2]|0;N[g+4>>2]=k;N[g>>2]=b;g=J[e+24>>2];N[(d+g|0)+8>>2]=f;c=c+1|0;if((c|0)>2]){continue}break}}if(J[D+20>>2]>0){c=0;while(1){G=Q(0);i=0;d=La+-64|0;La=d;if(J[l+48>>2]>0){h=J[l+24>>2];while(1){g=J[l+36>>2]+P(i,88)|0;u=P(J[g+36>>2],12);B=u+h|0;b=N[B+8>>2];k=N[B+4>>2];f=N[B>>2];B=P(J[g+32>>2],12);C=B+h|0;n=N[C+8>>2];q=N[C+4>>2];p=N[C>>2];C=J[g+84>>2];if((C|0)>0){r=N[g+68>>2];v=N[g+56>>2];z=N[g+48>>2];M=N[g+60>>2];w=N[g+52>>2];R=N[g+40>>2];O=N[g+44>>2];fa=Q(R+O);T=N[g+64>>2];y=Q(-T);h=0;while(1){x=_a(n);N[d+60>>2]=x;A=Za(n);N[d+56>>2]=A;s=_a(b);N[d+44>>2]=s;U=Za(b);N[d+40>>2]=U;N[d+52>>2]=q-Q(Q(A*z)+Q(w*x));N[d+48>>2]=p-Q(Q(x*z)-Q(w*A));N[d+36>>2]=k-Q(Q(U*v)+Q(M*s));N[d+32>>2]=f-Q(Q(s*v)-Q(M*U));ed(d+8|0,g,d+48|0,d+32|0,h);A=Q(0);x=N[d+24>>2];ga=x>G;s=N[d+20>>2];W=Q(s-k);X=Q(-W);Z=Q(s-q);aa=Q(-Z);ca=N[d+16>>2];ha=Q(ca-f);s=N[d+12>>2];U=N[d+8>>2];W=Q(Q(ha*s)-Q(U*W));E=Q(Q(r*W)*W);W=Q(ca-p);Z=Q(Q(W*s)-Q(U*Z));Z=Q(E+Q(Q(Q(T*Z)*Z)+fa));if(Z>Q(0)){A=Q(Q(x+Q(.004999999888241291))*Q(.20000000298023224));A=A>2]}h=h+B|0;N[h+4>>2]=q;N[h>>2]=p;h=J[l+24>>2];N[(h+B|0)+8>>2]=n;h=h+u|0;N[h+4>>2]=k;N[h>>2]=f;h=J[l+24>>2];N[(u+h|0)+8>>2]=b;i=i+1|0;if((i|0)>2]){continue}break}}La=d- -64|0;g=1;d=0;if(J[e+32>>2]>0){while(1){h=J[J[e+16>>2]+(d<<2)>>2];g=Na[J[J[h>>2]+44>>2]](h,j+104|0)&g;d=d+1|0;if((d|0)>2]){continue}break}}d=G>=Q(-.014999999664723873)&g;if(!d){c=c+1|0;if((c|0)>2]){continue}}break}h=!d}if(J[e+28>>2]>0){g=0;while(1){u=P(g,12);d=u+J[e+20>>2]|0;n=N[d>>2];c=J[d>>2];w=N[d+4>>2];d=J[d+4>>2];i=J[J[e+8>>2]+(g<<2)>>2];J[i+44>>2]=c;J[i+48>>2]=d;b=N[(u+J[e+20>>2]|0)+8>>2];N[i+56>>2]=b;c=u+J[e+24>>2]|0;B=J[c+4>>2];J[i+64>>2]=J[c>>2];J[i+68>>2]=B;k=N[(u+J[e+24>>2]|0)+8>>2];f=_a(b);N[i+24>>2]=f;b=Za(b);N[i+20>>2]=b;N[i+72>>2]=k;k=N[i+28>>2];x=N[i+32>>2];N[i+16>>2]=w-Q(Q(b*k)+Q(f*x));N[i+12>>2]=n-Q(Q(f*k)-Q(x*b));g=g+1|0;if((g|0)>2]){continue}break}}N[o+32>>2]=0;if(!(!J[e+4>>2]|J[e+36>>2]<=0)){B=J[l+40>>2];g=0;while(1){C=J[J[e+12>>2]+(g<<2)>>2];u=B+P(g,156)|0;i=J[u+148>>2];J[j+156>>2]=i;j:{if((i|0)<=0){break j}d=0;if((i|0)!=1){ga=i&-2;c=0;while(1){da=d<<2;S=j+140|0;ea=u+P(d,36)|0;N[da+S>>2]=N[ea+16>>2];sa=j+148|0;N[da+sa>>2]=N[ea+20>>2];ea=S;da=d|1;S=da<<2;da=u+P(da,36)|0;N[ea+S>>2]=N[da+16>>2];N[S+sa>>2]=N[da+20>>2];d=d+2|0;c=c+2|0;if((ga|0)!=(c|0)){continue}break}}if(!(i&1)){break j}c=(j+140|0)+(d<<2)|0;d=u+P(d,36)|0;N[c>>2]=N[d+16>>2];N[c+8>>2]=N[d+20>>2]}c=J[e+4>>2];Na[J[J[c>>2]+20>>2]](c,C,j+140|0);g=g+1|0;if((g|0)>2]){continue}break}}k:{if(!ja){break k}g=J[e+28>>2];if((g|0)<=0){break k}i=J[e+8>>2];b=Q(34028234663852886e22);d=0;while(1){c=J[i+(d<<2)>>2];l:{if(!J[c>>2]){break l}m:{n:{if(!(K[c+4|0]&4)){break n}f=N[c+72>>2];if(Q(f*f)>Q(.001218469929881394)){break n}f=N[c+64>>2];k=Q(f*f);f=N[c+68>>2];if(!(Q(k+Q(f*f))>Q(9999999747378752e-20))){break m}}J[c+144>>2]=0;b=Q(0);break l}f=Q(m+N[c+144>>2]);N[c+144>>2]=f;b=b=Q(.5))|h){break k}c=J[e+28>>2];if((c|0)<=0){break k}g=0;while(1){d=J[J[e+8>>2]+(g<<2)>>2];if(J[d>>2]){J[d+144>>2]=0;J[d+64>>2]=0;J[d+68>>2]=0;J[d+72>>2]=0;J[d+76>>2]=0;J[d+80>>2]=0;J[d+84>>2]=0;I[d+4>>1]=L[d+4>>1]&65533;c=J[e+28>>2]}g=g+1|0;if((c|0)>(g|0)){continue}break}}hd(l);La=j+160|0;N[a+103008>>2]=N[o+24>>2]+N[a+103008>>2];N[a+103012>>2]=N[o+28>>2]+N[a+103012>>2];N[a+103016>>2]=N[o+32>>2]+N[a+103016>>2];c=J[e+28>>2];if((c|0)<=0){break e}h=J[e+8>>2];d=0;if((c|0)!=1){j=c&-2;i=0;while(1){l=d<<2;g=J[l+h>>2];if(!J[g>>2]){I[g+4>>1]=L[g+4>>1]&65534}g=J[h+(l|4)>>2];if(!J[g>>2]){I[g+4>>1]=L[g+4>>1]&65534}d=d+2|0;i=i+2|0;if((j|0)!=(i|0)){continue}break}}if(!(c&1)){break e}c=J[h+(d<<2)>>2];if(J[c>>2]){break e}I[c+4>>1]=L[c+4>>1]&65534}t=J[t+96>>2];if(t){continue}break}}Eb($,F);d=J[a+102948>>2];if(d){while(1){if(!(!(H[d+4|0]&1)|!J[d>>2])){Md(d)}d=J[d+96>>2];if(d){continue}break}}fc(a+102868|0);N[a+103020>>2]=0;cd(e);La=o+96|0;N[a+103004>>2]=0;b=N[D+4>>2]}if(!(!K[a+102992|0]|!(b>Q(0)))){g=La-272|0;La=g;l=dd(g+220|0,64,32,0,a+68|0,J[a+102940>>2]);o:{if(!K[a+102994|0]){break o}j=J[a+102948>>2];if(j){while(1){J[j+60>>2]=0;I[j+4>>1]=L[j+4>>1]&65534;j=J[j+96>>2];if(j){continue}break}}j=J[a+102928>>2];if(!j){break o}while(1){J[j+128>>2]=0;J[j+132>>2]=1065353216;J[j+4>>2]=J[j+4>>2]&-34;j=J[j+12>>2];if(j){continue}break}}ja=a+102868|0;ga=g+116|0;while(1){p:{h=0;A=Q(1);q:{j=J[a+102928>>2];r:{if(!j){break r}while(1){c=J[j+4>>2];s:{if(!(c&4)|J[j+128>>2]>8){break s}t:{if(c&32){f=N[j+132>>2];break t}i=J[j+48>>2];if(K[i+38|0]){break s}o=J[j+52>>2];if(K[o+38|0]){break s}d=J[o+8>>2];c=J[d>>2];e=J[i+8>>2];t=L[e+4>>1];F=J[e>>2];u=L[d+4>>1];if(!(t>>>1&(F|0)!=0|u>>>1&(c|0)!=0)){break s}if(!(u&8|(t&8|(F|0)!=2))){if((c|0)==2){break s}}b=N[d+60>>2];f=N[e+60>>2];u:{if(b>f){N[e+60>>2]=b;k=N[e+40>>2];f=Q(Q(b-f)/Q(Q(1)-f));N[e+40>>2]=k+Q(f*Q(N[e+48>>2]-k));k=N[e+36>>2];N[e+36>>2]=k+Q(f*Q(N[e+44>>2]-k));k=f;f=N[e+52>>2];N[e+52>>2]=Q(k*Q(N[e+56>>2]-f))+f;break u}if(b>2]=f;k=N[d+40>>2];b=Q(Q(f-b)/Q(Q(1)-b));N[d+40>>2]=k+Q(b*Q(N[d+48>>2]-k));k=N[d+36>>2];N[d+36>>2]=k+Q(b*Q(N[d+44>>2]-k));k=b;b=N[d+52>>2];N[d+52>>2]=Q(k*Q(N[d+56>>2]-b))+b}b=f}t=J[j+60>>2];F=J[j+56>>2];J[g+140>>2]=0;J[g+132>>2]=0;J[g+136>>2]=0;J[g+112>>2]=0;J[g+104>>2]=0;J[g+108>>2]=0;c=g+88|0;gc(c,J[i+12>>2],F);gc(ga,J[o+12>>2],t);J[g+176>>2]=J[e+60>>2];i=J[e+56>>2];J[g+168>>2]=J[e+52>>2];J[g+172>>2]=i;i=J[e+48>>2];J[g+160>>2]=J[e+44>>2];J[g+164>>2]=i;i=J[e+40>>2];J[g+152>>2]=J[e+36>>2];J[g+156>>2]=i;i=J[e+32>>2];J[g+144>>2]=J[e+28>>2];J[g+148>>2]=i;J[g+212>>2]=J[d+60>>2];e=J[d+56>>2];J[g+204>>2]=J[d+52>>2];J[g+208>>2]=e;e=J[d+48>>2];J[g+196>>2]=J[d+44>>2];J[g+200>>2]=e;e=J[d+40>>2];J[g+188>>2]=J[d+36>>2];J[g+192>>2]=e;e=J[d+32>>2];J[g+180>>2]=J[d+28>>2];J[g+184>>2]=e;J[g+216>>2]=1065353216;i=0;G=Q(0);e=La-320|0;La=e;J[6195]=J[6195]+1;J[g+48>>2]=0;x=N[c+128>>2];N[g+52>>2]=x;J[e+312>>2]=J[c+88>>2];d=J[c+84>>2];J[e+304>>2]=J[c+80>>2];J[e+308>>2]=d;d=J[c+76>>2];J[e+296>>2]=J[c+72>>2];J[e+300>>2]=d;d=c- -64|0;o=J[d+4>>2];J[e+288>>2]=J[d>>2];J[e+292>>2]=o;d=J[c+60>>2];J[e+280>>2]=J[c+56>>2];J[e+284>>2]=d;J[e+272>>2]=J[c+124>>2];d=J[c+120>>2];J[e+264>>2]=J[c+116>>2];J[e+268>>2]=d;d=J[c+112>>2];J[e+256>>2]=J[c+108>>2];J[e+260>>2]=d;d=J[c+104>>2];J[e+248>>2]=J[c+100>>2];J[e+252>>2]=d;d=J[c+96>>2];J[e+240>>2]=J[c+92>>2];J[e+244>>2]=d;k=N[e+304>>2];f=Q(Q(V(Q(k/Q(6.2831854820251465))))*Q(6.2831854820251465));n=Q(k-f);N[e+304>>2]=n;m=N[e+264>>2];k=Q(Q(V(Q(m/Q(6.2831854820251465))))*Q(6.2831854820251465));p=Q(m-k);N[e+264>>2]=p;r=Q(N[e+268>>2]-k);N[e+268>>2]=r;q=Q(N[e+308>>2]-f);N[e+308>>2]=q;f=N[c+52>>2];k=N[c+24>>2];I[e+232>>1]=0;J[e+160>>2]=J[c+24>>2];d=J[c+20>>2];J[e+152>>2]=J[c+16>>2];J[e+156>>2]=d;d=J[c+12>>2];J[e+144>>2]=J[c+8>>2];J[e+148>>2]=d;d=J[c+4>>2];J[e+136>>2]=J[c>>2];J[e+140>>2]=d;d=J[c+40>>2];J[e+172>>2]=J[c+36>>2];J[e+176>>2]=d;d=J[c+48>>2];J[e+180>>2]=J[c+44>>2];J[e+184>>2]=d;J[e+188>>2]=J[c+52>>2];d=J[c+32>>2];J[e+164>>2]=J[c+28>>2];J[e+168>>2]=d;H[e+224|0]=0;f=Q(Q(k+f)+Q(-.014999999664723873));U=f>2]=f;m=Za(m);N[e+216>>2]=m;q=Q(Q(k*Q(q-n))+n);n=_a(q);N[e+204>>2]=n;q=Za(q);N[e+200>>2]=q;p=N[e+252>>2];w=Q(p+Q(k*Q(N[e+260>>2]-p)));p=N[e+240>>2];r=N[e+244>>2];N[e+212>>2]=w-Q(Q(m*p)+Q(f*r));v=N[e+248>>2];N[e+208>>2]=Q(v+Q(k*Q(N[e+256>>2]-v)))-Q(Q(f*p)-Q(r*m));f=N[e+292>>2];w=Q(f+Q(k*Q(N[e+300>>2]-f)));f=N[e+280>>2];m=N[e+284>>2];N[e+196>>2]=w-Q(Q(q*f)+Q(n*m));p=N[e+288>>2];N[e+192>>2]=Q(p+Q(k*Q(N[e+296>>2]-p)))-Q(Q(n*f)-Q(m*q));Ud(e+112|0,e+228|0,e+136|0);f=N[e+128>>2];if(f<=Q(0)){d=2;break w}if(f>2]=da;J[d>>2]=c;o=L[e+232>>1];J[d+40>>2]=J[e+312>>2];t=J[e+308>>2];J[d+32>>2]=J[e+304>>2];J[d+36>>2]=t;t=J[e+300>>2];J[d+24>>2]=J[e+296>>2];J[d+28>>2]=t;t=J[e+292>>2];J[d+16>>2]=J[e+288>>2];J[d+20>>2]=t;t=J[e+284>>2];J[d+8>>2]=J[e+280>>2];J[d+12>>2]=t;t=J[e+244>>2];J[d+44>>2]=J[e+240>>2];J[d+48>>2]=t;t=J[e+252>>2];J[d+52>>2]=J[e+248>>2];J[d+56>>2]=t;t=J[e+260>>2];J[d+60>>2]=J[e+256>>2];J[d+64>>2]=t;t=J[e+268>>2];J[d+68>>2]=J[e+264>>2];J[d+72>>2]=t;J[d+76>>2]=J[e+272>>2];f=N[d+48>>2];m=N[d+68>>2];q=Q(Q(k*Q(N[d+72>>2]-m))+m);m=_a(q);n=N[d+44>>2];p=Za(q);q=N[d+56>>2];M=Q(Q(q+Q(Q(N[d- -64>>2]-q)*k))-Q(Q(p*n)+Q(f*m)));q=N[d+52>>2];w=Q(Q(q+Q(Q(N[d+60>>2]-q)*k))-Q(Q(m*n)-Q(f*p)));f=N[d+12>>2];n=N[d+32>>2];r=Q(Q(k*Q(N[d+36>>2]-n))+n);q=_a(r);n=N[d+8>>2];r=Za(r);v=N[d+20>>2];R=Q(Q(v+Q(Q(N[d+28>>2]-v)*k))-Q(Q(r*n)+Q(f*q)));v=N[d+16>>2];O=Q(Q(v+Q(Q(N[d+24>>2]-v)*k))-Q(Q(q*n)-Q(f*r)));v=Q(-p);z=Q(-r);x:{if((o|0)==1){J[d+80>>2]=0;o=J[c+44>>2]+(K[e+237|0]<<3)|0;n=N[o>>2];f=Q(p*n);p=N[o+4>>2];s=Q(M+Q(f+Q(m*p)));f=r;o=J[c+16>>2]+(K[e+234|0]<<3)|0;r=N[o>>2];M=N[o+4>>2];f=Q(s-Q(R+Q(Q(f*r)+Q(q*M))));N[d+96>>2]=f;m=Q(Q(w+Q(Q(m*n)+Q(p*v)))-Q(O+Q(Q(q*r)+Q(M*z))));N[d+92>>2]=m;n=Q(Y(Q(Q(m*m)+Q(f*f))));if(n>2]=w*f;N[d+92>>2]=m*f;break x}y:{if(K[e+234|0]==K[e+235|0]){J[d+80>>2]=2;o=J[c+44>>2];t=o+(K[e+238|0]<<3)|0;s=N[t>>2];o=o+(K[e+237|0]<<3)|0;T=N[o>>2];W=N[t+4>>2];X=N[o+4>>2];f=Q(W-X);N[d+92>>2]=f;y=Q(s-T);n=Q(-y);N[d+96>>2]=n;y=Q(Y(Q(Q(f*f)+Q(y*y))));if(!(y>2]=n;f=Q(f*y);N[d+92>>2]=f}y=Q(Q(X+W)*Q(.5));N[d+88>>2]=y;s=Q(Q(T+s)*Q(.5));N[d+84>>2]=s;E=O;o=J[c+16>>2]+(K[e+234|0]<<3)|0;O=N[o>>2];T=N[o+4>>2];if(!(Q(Q(Q(Q(E+Q(Q(q*O)+Q(T*z)))-Q(w+Q(Q(m*s)+Q(y*v))))*Q(Q(m*f)+Q(n*v)))+Q(Q(Q(p*f)+Q(m*n))*Q(Q(R+Q(Q(r*O)+Q(q*T)))-Q(M+Q(Q(p*s)+Q(m*y))))))>2]=1;o=J[c+16>>2];t=o+(K[e+235|0]<<3)|0;s=N[t>>2];o=o+(K[e+234|0]<<3)|0;T=N[o>>2];W=N[t+4>>2];X=N[o+4>>2];f=Q(W-X);N[d+92>>2]=f;y=Q(s-T);n=Q(-y);N[d+96>>2]=n;y=Q(Y(Q(Q(f*f)+Q(y*y))));if(!(y>2]=n;f=Q(f*y);N[d+92>>2]=f}y=Q(Q(X+W)*Q(.5));N[d+88>>2]=y;s=Q(Q(T+s)*Q(.5));N[d+84>>2]=s;E=w;o=J[c+44>>2]+(K[e+237|0]<<3)|0;w=N[o>>2];T=N[o+4>>2];if(!(Q(Q(Q(Q(E+Q(Q(m*w)+Q(T*v)))-Q(O+Q(Q(q*s)+Q(y*z))))*Q(Q(q*f)+Q(n*z)))+Q(Q(Q(r*f)+Q(q*n))*Q(Q(M+Q(Q(p*w)+Q(m*T)))-Q(R+Q(Q(r*s)+Q(q*y))))))>2]=-n;N[d+92>>2]=-f}$=0;t=4;z:{f=x;R=ad(d,e+8|0,e+4|0,f);A:{if(!(fata)){T=N[e+60>>2];ka=N[e+80>>2];ua=Q(N[e+84>>2]-ka);n=Q(Q(k*ua)+ka);m=_a(n);y=N[e+56>>2];q=Za(n);la=N[e+68>>2];va=Q(N[e+76>>2]-la);M=Q(Q(la+Q(k*va))-Q(Q(q*y)+Q(T*m)));ma=N[e+64>>2];wa=Q(N[e+72>>2]-ma);w=Q(Q(ma+Q(k*wa))-Q(Q(m*y)-Q(T*q)));W=N[e+24>>2];na=N[e+44>>2];xa=Q(N[e+48>>2]-na);p=Q(Q(k*xa)+na);n=_a(p);X=N[e+20>>2];p=Za(p);oa=N[e+32>>2];ya=Q(N[e+40>>2]-oa);O=Q(Q(oa+Q(k*ya))-Q(Q(p*X)+Q(W*n)));pa=N[e+28>>2];za=Q(N[e+36>>2]-pa);s=Q(Q(pa+Q(k*za))-Q(Q(n*X)-Q(W*p)));r=Q(-q);v=Q(-p);z=Q(0);o=J[e+4>>2];F=J[e+8>>2];C:{D:{E:{F:{S=J[e+92>>2];switch(S|0){case 2:break D;case 1:break E;case 0:break F;default:break C}}E=w;d=J[J[e+16>>2]+16>>2]+(o<<3)|0;z=N[d>>2];w=N[d+4>>2];ba=Q(E+Q(Q(m*z)+Q(w*r)));E=s;d=J[J[e+12>>2]+16>>2]+(F<<3)|0;r=N[d>>2];s=N[d+4>>2];z=Q(Q(Q(ba-Q(E+Q(Q(n*r)+Q(s*v))))*N[e+104>>2])+Q(N[e+108>>2]*Q(Q(M+Q(Q(q*z)+Q(m*w)))-Q(O+Q(Q(p*r)+Q(n*s))))));break C}E=w;d=J[J[e+16>>2]+16>>2]+(o<<3)|0;z=N[d>>2];w=N[d+4>>2];ba=Q(E+Q(Q(m*z)+Q(w*r)));E=s;r=N[e+96>>2];s=N[e+100>>2];Z=N[e+104>>2];aa=N[e+108>>2];z=Q(Q(Q(ba-Q(E+Q(Q(n*r)+Q(s*v))))*Q(Q(n*Z)+Q(aa*v)))+Q(Q(Q(p*Z)+Q(n*aa))*Q(Q(M+Q(Q(q*z)+Q(m*w)))-Q(O+Q(Q(p*r)+Q(n*s))))));break C}E=s;d=J[J[e+12>>2]+16>>2]+(F<<3)|0;z=N[d>>2];s=N[d+4>>2];ba=Q(E+Q(Q(n*z)+Q(s*v)));E=w;v=N[e+96>>2];w=N[e+100>>2];Z=N[e+104>>2];aa=N[e+108>>2];z=Q(Q(Q(ba-Q(E+Q(Q(m*v)+Q(w*r))))*Q(Q(m*Z)+Q(aa*r)))+Q(Q(Q(q*Z)+Q(m*aa))*Q(Q(O+Q(Q(p*z)+Q(n*s)))-Q(M+Q(Q(q*v)+Q(m*w))))))}if(z>2];C=J[e+12>>2];Z=N[e+100>>2];aa=N[e+96>>2];O=N[e+108>>2];s=N[e+104>>2];n=k;q=f;G:{while(1){_=_+1|0;J[6198]=_;m=d&1?Q(n+Q(Q(Q(U-z)*Q(q-n))/Q(R-z))):Q(Q(n+q)*Q(.5));r=Q(Q(m*ua)+ka);p=_a(r);M=Za(r);qa=Q(Q(la+Q(va*m))-Q(Q(M*y)+Q(T*p)));E=Q(Q(ma+Q(wa*m))-Q(Q(p*y)-Q(T*M)));r=Q(Q(m*xa)+na);v=_a(r);w=Za(r);ra=Q(Q(oa+Q(ya*m))-Q(Q(w*X)+Q(W*v)));ba=Q(Q(pa+Q(za*m))-Q(Q(v*X)-Q(W*w)));ca=Q(-M);ha=Q(-w);r=Q(0);H:{I:{switch(S|0){case 0:ia=E;u=J[B+16>>2]+(o<<3)|0;r=N[u>>2];E=N[u+4>>2];Aa=Q(ia+Q(Q(p*r)+Q(E*ca)));ia=ba;u=J[C+16>>2]+(F<<3)|0;ca=N[u>>2];ba=N[u+4>>2];r=Q(Q(Q(Aa-Q(ia+Q(Q(v*ca)+Q(ba*ha))))*s)+Q(O*Q(Q(qa+Q(Q(M*r)+Q(p*E)))-Q(ra+Q(Q(w*ca)+Q(v*ba))))));break H;case 1:ia=E;u=J[B+16>>2]+(o<<3)|0;r=N[u>>2];E=N[u+4>>2];r=Q(Q(Q(Q(ia+Q(Q(p*r)+Q(E*ca)))-Q(ba+Q(Q(v*aa)+Q(Z*ha))))*Q(Q(v*s)+Q(O*ha)))+Q(Q(Q(w*s)+Q(v*O))*Q(Q(qa+Q(Q(M*r)+Q(p*E)))-Q(ra+Q(Q(w*aa)+Q(v*Z))))));break H;case 2:break I;default:break H}}ia=ba;u=J[C+16>>2]+(F<<3)|0;r=N[u>>2];ba=N[u+4>>2];r=Q(Q(Q(Q(ia+Q(Q(v*r)+Q(ba*ha)))-Q(E+Q(Q(p*aa)+Q(Z*ca))))*Q(Q(p*s)+Q(O*ca)))+Q(Q(Q(M*s)+Q(p*O))*Q(Q(ra+Q(Q(w*r)+Q(v*ba)))-Q(qa+Q(Q(M*aa)+Q(p*Z))))))}d=d+1|0;p=Q(r-U);if((p>Q(0)?p:Q(-p))U;q=u?q:m;n=u?m:n;z=u?r:z;R=u?R:r;if((d|0)!=50){continue}break}d=50}o=J[6199];J[6199]=(d|0)<(o|0)?o:d;$=$+1|0;if(($|0)!=8){break B}f=k}J[6196]=J[6196]+1;i=i+1|0;if((i|0)!=20){break z}N[g+52>>2]=f;J[g+48>>2]=1;i=20;break v}R=ad(e+12|0,e+8|0,e+4|0,f);if(!(fa>2]=k;J[g+48>>2]=t;J[6196]=J[6196]+1;i=i+1|0;break v}r=N[e+268>>2];p=N[e+264>>2];q=N[e+308>>2];n=N[e+304>>2];k=f;continue}break}N[g+52>>2]=G;J[g+48>>2]=d}c=J[6197];J[6197]=(c|0)>(i|0)?c:i;N[6193]=N[6193]+Q(0);f=N[6194];N[6194]=f>Q(0)?f:Q(0);La=e+320|0;f=Q(1);if(J[g+48>>2]==3){b=Q(Q(Q(Q(1)-b)*N[g+52>>2])+b);f=b>2]=f;J[j+4>>2]=J[j+4>>2]|32}c=f>2];if(j){continue}break}if(!h){break r}if(!(A>Q(.9999988079071045))){break q}}H[a+102994|0]=1;break p}e=J[J[h+52>>2]+8>>2];i=J[J[h+48>>2]+8>>2];d=i;J[g+120>>2]=J[d+60>>2];c=J[d+56>>2];J[g+112>>2]=J[d+52>>2];J[g+116>>2]=c;c=J[d+48>>2];J[g+104>>2]=J[d+44>>2];J[g+108>>2]=c;c=J[d+40>>2];J[g+96>>2]=J[d+36>>2];J[g+100>>2]=c;c=J[d+32>>2];J[g+88>>2]=J[d+28>>2];J[g+92>>2]=c;J[g+80>>2]=J[e+60>>2];c=J[e+56>>2];J[g+72>>2]=J[e+52>>2];J[g+76>>2]=c;o=J[e+48>>2];j=g- -64|0;c=j;J[c>>2]=J[e+44>>2];J[c+4>>2]=o;c=J[e+40>>2];J[g+56>>2]=J[e+36>>2];J[g+60>>2]=c;c=J[e+32>>2];J[g+48>>2]=J[e+28>>2];J[g+52>>2]=c;f=N[d+36>>2];b=N[d+60>>2];b=Q(Q(A-b)/Q(Q(1)-b));N[d+36>>2]=f+Q(b*Q(N[d+44>>2]-f));f=N[d+40>>2];N[d+40>>2]=f+Q(b*Q(N[d+48>>2]-f));N[d+60>>2]=A;f=b;b=N[d+52>>2];b=Q(Q(f*Q(N[d+56>>2]-b))+b);N[d+56>>2]=b;N[d+52>>2]=b;f=_a(b);N[d+24>>2]=f;b=Za(b);N[d+20>>2]=b;w=N[d+40>>2];o=J[d+40>>2];x=N[d+36>>2];J[d+44>>2]=J[d+36>>2];J[d+48>>2]=o;k=N[d+28>>2];m=N[d+32>>2];N[d+16>>2]=w-Q(Q(b*k)+Q(f*m));N[d+12>>2]=x-Q(Q(f*k)-Q(m*b));f=N[e+40>>2];b=N[e+60>>2];b=Q(Q(A-b)/Q(Q(1)-b));N[e+40>>2]=f+Q(b*Q(N[e+48>>2]-f));f=N[e+36>>2];N[e+36>>2]=f+Q(b*Q(N[e+44>>2]-f));N[e+60>>2]=A;f=b;b=N[e+52>>2];b=Q(Q(f*Q(N[e+56>>2]-b))+b);N[e+56>>2]=b;N[e+52>>2]=b;f=_a(b);N[e+24>>2]=f;b=Za(b);N[e+20>>2]=b;s=N[e+40>>2];d=J[e+40>>2];k=N[e+36>>2];J[e+44>>2]=J[e+36>>2];J[e+48>>2]=d;w=k;k=N[e+28>>2];m=N[e+32>>2];N[e+12>>2]=w-Q(Q(f*k)-Q(b*m));N[e+16>>2]=s-Q(Q(b*k)+Q(f*m));vc(h,J[a+102940>>2]);J[h+128>>2]=J[h+128>>2]+1;d=J[h+4>>2];J:{if((d&6)!=6){J[h+4>>2]=d&-37;J[i+60>>2]=J[g+120>>2];c=J[g+116>>2];J[i+52>>2]=J[g+112>>2];J[i+56>>2]=c;c=J[g+108>>2];J[i+44>>2]=J[g+104>>2];J[i+48>>2]=c;c=J[g+100>>2];J[i+36>>2]=J[g+96>>2];J[i+40>>2]=c;c=J[g+92>>2];J[i+28>>2]=J[g+88>>2];J[i+32>>2]=c;J[e+60>>2]=J[g+80>>2];c=J[g+76>>2];J[e+52>>2]=J[g+72>>2];J[e+56>>2]=c;c=J[j+4>>2];J[e+44>>2]=J[j>>2];J[e+48>>2]=c;c=J[g+60>>2];J[e+36>>2]=J[g+56>>2];J[e+40>>2]=c;c=J[g+52>>2];J[e+28>>2]=J[g+48>>2];J[e+32>>2]=c;f=N[i+56>>2];b=_a(f);N[i+24>>2]=b;f=Za(f);N[i+20>>2]=f;k=N[i+28>>2];m=N[i+32>>2];N[i+16>>2]=N[i+48>>2]-Q(Q(f*k)+Q(b*m));N[i+12>>2]=N[i+44>>2]-Q(Q(b*k)-Q(m*f));f=N[e+56>>2];b=Za(f);N[e+20>>2]=b;f=_a(f);N[e+24>>2]=f;k=N[e+28>>2];m=N[e+32>>2];N[e+16>>2]=N[e+48>>2]-Q(Q(b*k)+Q(f*m));N[e+12>>2]=N[e+44>>2]-Q(Q(f*k)-Q(m*b));c=9;break J}if(J[i>>2]){J[i+144>>2]=0;I[i+4>>1]=L[i+4>>1]|2}if(J[e>>2]){J[e+144>>2]=0;I[e+4>>1]=L[e+4>>1]|2}j=0;J[l+32>>2]=0;J[i+8>>2]=0;J[J[l+8>>2]>>2]=i;c=1;J[e+8>>2]=1;J[J[l+8>>2]+4>>2]=e;J[l+28>>2]=2;J[l+36>>2]=1;J[J[l+12>>2]>>2]=h;I[i+4>>1]=L[i+4>>1]|1;I[e+4>>1]=L[e+4>>1]|1;J[h+4>>2]=d&-34|1;J[g+44>>2]=e;J[g+40>>2]=i;while(1){t=J[(g+40|0)+(j<<2)>>2];K:{if(J[t>>2]!=2){break K}j=J[t+112>>2];if(!j){break K}while(1){if(J[l+28>>2]==J[l+40>>2]|J[l+36>>2]==J[l+44>>2]){break K}o=J[j+4>>2];L:{if(H[o+4|0]&1){break L}h=J[j>>2];if(!(K[t+4|0]&8|J[h>>2]!=2|K[h+4|0]&8)|(K[J[o+48>>2]+38|0]|K[J[o+52>>2]+38|0])){break L}J[g+32>>2]=J[h+60>>2];d=J[h+56>>2];J[g+24>>2]=J[h+52>>2];J[g+28>>2]=d;d=J[h+48>>2];J[g+16>>2]=J[h+44>>2];J[g+20>>2]=d;d=J[h+40>>2];J[g+8>>2]=J[h+36>>2];J[g+12>>2]=d;d=J[h+32>>2];J[g>>2]=J[h+28>>2];J[g+4>>2]=d;if(!(H[h+4|0]&1)){f=N[h+40>>2];b=N[h+60>>2];b=Q(Q(A-b)/Q(Q(1)-b));N[h+40>>2]=f+Q(b*Q(N[h+48>>2]-f));f=N[h+36>>2];N[h+36>>2]=f+Q(b*Q(N[h+44>>2]-f));N[h+60>>2]=A;f=b;b=N[h+52>>2];b=Q(Q(f*Q(N[h+56>>2]-b))+b);N[h+56>>2]=b;N[h+52>>2]=b;f=_a(b);N[h+24>>2]=f;b=Za(b);N[h+20>>2]=b;s=N[h+40>>2];F=J[h+40>>2];k=N[h+36>>2];J[h+44>>2]=J[h+36>>2];J[h+48>>2]=F;w=k;k=N[h+28>>2];m=N[h+32>>2];N[h+12>>2]=w-Q(Q(f*k)-Q(b*m));N[h+16>>2]=s-Q(Q(b*k)+Q(f*m))}vc(o,J[a+102940>>2]);d=J[o+4>>2];if(!(d&4)){d=J[g+4>>2];J[h+28>>2]=J[g>>2];J[h+32>>2]=d;J[h+60>>2]=J[g+32>>2];d=J[g+28>>2];J[h+52>>2]=J[g+24>>2];J[h+56>>2]=d;d=J[g+20>>2];J[h+44>>2]=J[g+16>>2];J[h+48>>2]=d;d=J[g+12>>2];J[h+36>>2]=J[g+8>>2];J[h+40>>2]=d;f=N[h+56>>2];b=_a(f);N[h+24>>2]=b;f=Za(f);N[h+20>>2]=f;k=N[h+28>>2];m=N[h+32>>2];N[h+16>>2]=N[h+48>>2]-Q(Q(f*k)+Q(b*m));N[h+12>>2]=N[h+44>>2]-Q(Q(b*k)-Q(m*f));break L}if(!(d&2)){d=J[g+4>>2];J[h+28>>2]=J[g>>2];J[h+32>>2]=d;J[h+60>>2]=J[g+32>>2];d=J[g+28>>2];J[h+52>>2]=J[g+24>>2];J[h+56>>2]=d;d=J[g+20>>2];J[h+44>>2]=J[g+16>>2];J[h+48>>2]=d;d=J[g+12>>2];J[h+36>>2]=J[g+8>>2];J[h+40>>2]=d;f=N[h+56>>2];b=_a(f);N[h+24>>2]=b;f=Za(f);N[h+20>>2]=f;k=N[h+28>>2];m=N[h+32>>2];N[h+16>>2]=N[h+48>>2]-Q(Q(f*k)+Q(b*m));N[h+12>>2]=N[h+44>>2]-Q(Q(b*k)-Q(m*f));break L}J[o+4>>2]=d|1;d=J[l+36>>2];J[l+36>>2]=d+1;J[J[l+12>>2]+(d<<2)>>2]=o;d=L[h+4>>1];if(d&1){break L}I[h+4>>1]=d|1;if(J[h>>2]){J[h+144>>2]=0;I[h+4>>1]=d|3}d=J[l+28>>2];J[h+8>>2]=d;J[J[l+8>>2]+(d<<2)>>2]=h;J[l+28>>2]=d+1}j=J[j+12>>2];if(j){continue}break}}j=1;d=c;c=0;if(d){continue}break}b=N[D+4>>2];J[g+16>>2]=20;J[g+8>>2]=1065353216;b=Q(b*Q(Q(1)-A));N[g>>2]=b;N[g+4>>2]=Q(1)/b;c=J[D+16>>2];h=0;H[g+20|0]=0;J[g+12>>2]=c;F=J[i+8>>2];u=J[e+8>>2];j=0;e=La-128|0;La=e;M:{if(J[l+28>>2]<=0){d=J[l+24>>2];break M}while(1){c=J[J[l+8>>2]+(j<<2)>>2];o=J[c+48>>2];i=P(j,12);d=i+J[l+20>>2]|0;J[d>>2]=J[c+44>>2];J[d+4>>2]=o;N[(i+J[l+20>>2]|0)+8>>2]=N[c+56>>2];o=J[c+68>>2];d=i+J[l+24>>2]|0;J[d>>2]=J[c+64>>2];J[d+4>>2]=o;d=J[l+24>>2];N[(i+d|0)+8>>2]=N[c+72>>2];j=j+1|0;if((j|0)>2]){continue}break}}J[e+88>>2]=J[l+12>>2];J[e+92>>2]=J[l+36>>2];J[e+104>>2]=J[l>>2];c=J[g+12>>2];J[e+72>>2]=J[g+8>>2];J[e+76>>2]=c;c=J[g+20>>2];J[e+80>>2]=J[g+16>>2];J[e+84>>2]=c;c=J[g+4>>2];J[e+64>>2]=J[g>>2];J[e+68>>2]=c;c=J[l+20>>2];J[e+100>>2]=d;J[e+96>>2]=c;o=id(e+12|0,e- -64|0);j=0;N:{if(J[g+16>>2]<=0){break N}while(1){f=Q(0);t=0;d=La+-64|0;La=d;if(J[o+48>>2]>0){while(1){i=J[o+36>>2]+P(t,88)|0;$=J[i+36>>2];_=J[i+32>>2];O:{if((_|0)!=(F|0)){A=Q(0);m=Q(0);if((u|0)!=(_|0)){break O}}A=N[i+64>>2];m=N[i+40>>2]}B=J[i+84>>2];P:{if((F|0)!=($|0)){n=Q(0);x=Q(0);if((u|0)!=($|0)){break P}}n=N[i+68>>2];x=N[i+44>>2]}c=J[o+24>>2];$=P($,12);C=c+$|0;b=N[C+8>>2];k=N[C+4>>2];r=N[C>>2];_=P(_,12);C=_+c|0;q=N[C+8>>2];p=N[C+4>>2];G=N[C>>2];if((B|0)>0){M=N[i+56>>2];w=N[i+48>>2];R=N[i+60>>2];O=N[i+52>>2];fa=Q(m+x);T=Q(-A);c=0;while(1){v=_a(q);N[d+60>>2]=v;z=Za(q);N[d+56>>2]=z;s=_a(b);N[d+44>>2]=s;U=Za(b);N[d+40>>2]=U;N[d+52>>2]=p-Q(Q(z*w)+Q(O*v));N[d+48>>2]=G-Q(Q(v*w)-Q(O*z));N[d+36>>2]=k-Q(Q(U*M)+Q(R*s));N[d+32>>2]=r-Q(Q(s*M)-Q(R*U));ed(d+8|0,i,d+48|0,d+32|0,c);v=Q(0);z=N[d+24>>2];C=z>f;s=N[d+20>>2];y=Q(s-k);W=Q(-y);X=Q(s-p);Z=Q(-X);aa=N[d+16>>2];ca=Q(aa-r);s=N[d+12>>2];U=N[d+8>>2];y=Q(Q(ca*s)-Q(U*y));E=Q(Q(n*y)*y);y=Q(aa-G);X=Q(Q(y*s)-Q(U*X));X=Q(E+Q(Q(Q(A*X)*X)+fa));if(X>Q(0)){v=Q(Q(z+Q(.004999999888241291))*Q(.75));v=v>2]}c=c+_|0;N[c+4>>2]=p;N[c>>2]=G;c=J[o+24>>2];N[(c+_|0)+8>>2]=q;c=c+$|0;N[c+4>>2]=k;N[c>>2]=r;N[($+J[o+24>>2]|0)+8>>2]=b;t=t+1|0;if((t|0)>2]){continue}break}}La=d- -64|0;if(f>=Q(-.007499999832361937)){break N}j=j+1|0;if((j|0)>2]){continue}break}}j=P(F,12);i=j+J[l+20>>2]|0;t=J[i+4>>2];c=F<<2;d=J[c+J[l+8>>2]>>2];J[d+36>>2]=J[i>>2];J[d+40>>2]=t;i=c;c=J[l+8>>2];d=J[l+20>>2];N[J[i+c>>2]+52>>2]=N[(d+j|0)+8>>2];i=d;d=P(u,12);i=i+d|0;t=J[i+4>>2];j=c;c=u<<2;j=J[j+c>>2];J[j+36>>2]=J[i>>2];J[j+40>>2]=t;N[J[c+J[l+8>>2]>>2]+52>>2]=N[(d+J[l+20>>2]|0)+8>>2];gd(o);j=0;if(J[g+12>>2]>0){while(1){fd(o);j=j+1|0;if((j|0)>2]){continue}break}}i=0;if(J[l+28>>2]>0){b=N[g>>2];while(1){c=P(i,12);j=c+J[l+24>>2]|0;n=N[j>>2];f=Q(b*n);k=Q(f*f);p=N[j+4>>2];f=Q(b*p);f=Q(k+Q(f*f));if(f>Q(4)){f=Q(Q(2)/Q(Y(f)));p=Q(p*f);n=Q(n*f)}d=c+J[l+20>>2]|0;x=N[d+8>>2];k=N[d+4>>2];m=N[d>>2];q=N[j+8>>2];f=Q(b*q);if(Q(f*f)>Q(2.4674012660980225)){q=Q(q*Q(Q(1.5707963705062866)/(f>Q(0)?f:Q(-f))))}k=Q(k+Q(b*p));N[d+4>>2]=k;m=Q(m+Q(b*n));N[d>>2]=m;f=Q(Q(b*q)+x);N[(c+J[l+20>>2]|0)+8>>2]=f;d=c+J[l+24>>2]|0;N[d+4>>2]=p;N[d>>2]=n;N[(c+J[l+24>>2]|0)+8>>2]=q;c=J[J[l+8>>2]+(i<<2)>>2];N[c+72>>2]=q;N[c+64>>2]=n;N[c+68>>2]=p;N[c+56>>2]=f;N[c+48>>2]=k;N[c+44>>2]=m;x=_a(f);N[c+24>>2]=x;f=Za(f);N[c+20>>2]=f;w=k;k=N[c+28>>2];n=N[c+32>>2];N[c+16>>2]=w-Q(Q(f*k)+Q(x*n));N[c+12>>2]=m-Q(Q(x*k)-Q(n*f));i=i+1|0;if((i|0)>2]){continue}break}}if(!(!J[l+4>>2]|J[l+36>>2]<=0)){F=J[o+40>>2];c=0;while(1){u=J[J[l+12>>2]+(c<<2)>>2];t=F+P(c,156)|0;d=J[t+148>>2];J[e+124>>2]=d;Q:{if((d|0)<=0){break Q}j=0;if((d|0)!=1){$=d&-2;i=0;while(1){_=j<<2;B=e+108|0;C=t+P(j,36)|0;N[_+B>>2]=N[C+16>>2];S=_;_=e+116|0;N[S+_>>2]=N[C+20>>2];S=B;B=j|1;C=B<<2;B=t+P(B,36)|0;N[S+C>>2]=N[B+16>>2];N[C+_>>2]=N[B+20>>2];j=j+2|0;i=i+2|0;if(($|0)!=(i|0)){continue}break}}if(!(d&1)){break Q}d=(e+108|0)+(j<<2)|0;j=t+P(j,36)|0;N[d>>2]=N[j+16>>2];N[d+8>>2]=N[j+20>>2]}d=J[l+4>>2];Na[J[J[d>>2]+20>>2]](d,u,e+108|0);c=c+1|0;if((c|0)>2]){continue}break}}hd(o);La=e+128|0;if(J[l+28>>2]>0){while(1){c=J[J[l+8>>2]+(h<<2)>>2];I[c+4>>1]=L[c+4>>1]&65534;R:{if(J[c>>2]!=2){break R}Md(c);j=J[c+112>>2];if(!j){break R}while(1){c=J[j+4>>2];J[c+4>>2]=J[c+4>>2]&-34;j=J[j+12>>2];if(j){continue}break}}h=h+1|0;if((h|0)>2]){continue}break}}fc(ja);c=0;if(!K[a+102993|0]){break J}H[a+102994|0]=0;c=8}if((c|0)!=8){continue}}break}cd(l);La=g+272|0;N[a+103024>>2]=0;b=N[D+4>>2]}if(b>Q(0)){N[a+102984>>2]=N[D+8>>2]}S:{if(!K[a+102990|0]){break S}d=J[a+102948>>2];if(!d){break S}while(1){J[d+84>>2]=0;J[d+76>>2]=0;J[d+80>>2]=0;d=J[d+96>>2];if(d){continue}break}}H[a+102989|0]=0;N[a+102996>>2]=0;La=D+32|0}function fb(a){a=a|0;var 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;l=La-16|0;La=l;a:{b:{c:{d:{e:{f:{g:{h:{i:{j:{k:{l:{m:{n:{if(a>>>0<=244){g=J[6515];h=a>>>0<11?16:a+11&-8;c=h>>>3|0;b=g>>>c|0;if(b&3){c=c+((b^-1)&1)|0;a=c<<3;b=a+26100|0;d=J[a+26108>>2];a=J[d+8>>2];o:{if((b|0)==(a|0)){m=26060,n=ml(c)&g,J[m>>2]=n;break o}J[a+12>>2]=b;J[b+8>>2]=a}a=d+8|0;b=c<<3;J[d+4>>2]=b|3;b=b+d|0;J[b+4>>2]=J[b+4>>2]|1;break a}k=J[6517];if(k>>>0>=h>>>0){break n}if(b){a=2<>2];a=J[e+8>>2];p:{if((b|0)==(a|0)){g=ml(d)&g;J[6515]=g;break p}J[a+12>>2]=b;J[b+8>>2]=a}J[e+4>>2]=h|3;c=e+h|0;a=d<<3;d=a-h|0;J[c+4>>2]=d|1;J[a+e>>2]=d;if(k){b=(k&-8)+26100|0;f=J[6520];a=1<<(k>>>3);q:{if(!(a&g)){J[6515]=a|g;a=b;break q}a=J[b+8>>2]}J[b+8>>2]=f;J[a+12>>2]=f;J[f+12>>2]=b;J[f+8>>2]=a}a=e+8|0;J[6520]=c;J[6517]=d;break a}j=J[6516];if(!j){break n}c=J[(jl(0-j&j)<<2)+26364>>2];f=(J[c+4>>2]&-8)-h|0;b=c;while(1){r:{a=J[b+16>>2];if(!a){a=J[b+20>>2];if(!a){break r}}b=(J[a+4>>2]&-8)-h|0;d=b>>>0>>0;f=d?b:f;c=d?a:c;b=a;continue}break}i=J[c+24>>2];d=J[c+12>>2];if((d|0)!=(c|0)){a=J[c+8>>2];J[a+12>>2]=d;J[d+8>>2]=a;break b}b=c+20|0;a=J[b>>2];if(!a){a=J[c+16>>2];if(!a){break m}b=c+16|0}while(1){e=b;d=a;b=a+20|0;a=J[b>>2];if(a){continue}b=d+16|0;a=J[d+16>>2];if(a){continue}break}J[e>>2]=0;break b}h=-1;if(a>>>0>4294967231){break n}a=a+11|0;h=a&-8;j=J[6516];if(!j){break n}f=0-h|0;g=0;s:{if(h>>>0<256){break s}g=31;if(h>>>0>16777215){break s}a=S(a>>>8|0);g=((h>>>38-a&1)-(a<<1)|0)+62|0}b=J[(g<<2)+26364>>2];t:{u:{v:{if(!b){a=0;break v}a=0;c=h<<((g|0)!=31?25-(g>>>1|0)|0:0);while(1){w:{e=(J[b+4>>2]&-8)-h|0;if(e>>>0>=f>>>0){break w}d=b;f=e;if(e){break w}f=0;a=b;break u}e=J[b+20>>2];b=J[((c>>>29&4)+b|0)+16>>2];a=e?(e|0)==(b|0)?a:e:a;c=c<<1;if(b){continue}break}}if(!(a|d)){d=0;a=2<>2]}if(!a){break t}}while(1){b=(J[a+4>>2]&-8)-h|0;c=b>>>0>>0;f=c?b:f;d=c?a:d;b=J[a+16>>2];if(b){a=b}else{a=J[a+20>>2]}if(a){continue}break}}if(!d|J[6517]-h>>>0<=f>>>0){break n}g=J[d+24>>2];c=J[d+12>>2];if((d|0)!=(c|0)){a=J[d+8>>2];J[a+12>>2]=c;J[c+8>>2]=a;break c}b=d+20|0;a=J[b>>2];if(!a){a=J[d+16>>2];if(!a){break l}b=d+16|0}while(1){e=b;c=a;b=a+20|0;a=J[b>>2];if(a){continue}b=c+16|0;a=J[c+16>>2];if(a){continue}break}J[e>>2]=0;break c}a=J[6517];if(a>>>0>=h>>>0){d=J[6520];b=a-h|0;x:{if(b>>>0>=16){c=d+h|0;J[c+4>>2]=b|1;J[a+d>>2]=b;J[d+4>>2]=h|3;break x}J[d+4>>2]=a|3;a=a+d|0;J[a+4>>2]=J[a+4>>2]|1;c=0;b=0}J[6517]=b;J[6520]=c;a=d+8|0;break a}i=J[6518];if(i>>>0>h>>>0){b=i-h|0;J[6518]=b;c=J[6521];a=c+h|0;J[6521]=a;J[a+4>>2]=b|1;J[c+4>>2]=h|3;a=c+8|0;break a}a=0;j=h+47|0;if(J[6633]){c=J[6635]}else{J[6636]=-1;J[6637]=-1;J[6634]=4096;J[6635]=4096;J[6633]=l+12&-16^1431655768;J[6638]=0;J[6626]=0;c=4096}e=j+c|0;f=0-c|0;b=e&f;if(b>>>0<=h>>>0){break a}d=J[6625];if(d){c=J[6623];g=c+b|0;if(d>>>0>>0|c>>>0>=g>>>0){break a}}y:{if(!(K[26504]&4)){z:{A:{B:{C:{d=J[6521];if(d){a=26508;while(1){c=J[a>>2];if(c>>>0<=d>>>0&d>>>0>2]>>>0){break C}a=J[a+8>>2];if(a){continue}break}}c=Jb(0);if((c|0)==-1){break z}g=b;d=J[6634];a=d-1|0;if(a&c){g=(b-c|0)+(a+c&0-d)|0}if(g>>>0<=h>>>0){break z}d=J[6625];if(d){a=J[6623];f=a+g|0;if(d>>>0>>0|a>>>0>=f>>>0){break z}}a=Jb(g);if((c|0)!=(a|0)){break B}break y}g=f&e-i;c=Jb(g);if((c|0)==(J[a>>2]+J[a+4>>2]|0)){break A}a=c}if((a|0)==-1){break z}if(h+48>>>0<=g>>>0){c=a;break y}c=J[6635];c=c+(j-g|0)&0-c;if((Jb(c)|0)==-1){break z}g=c+g|0;c=a;break y}if((c|0)!=-1){break y}}J[6626]=J[6626]|4}c=Jb(b);a=Jb(0);if((c|0)==-1|(a|0)==-1|a>>>0<=c>>>0){break i}g=a-c|0;if(g>>>0<=h+40>>>0){break i}}a=J[6623]+g|0;J[6623]=a;if(a>>>0>M[6624]){J[6624]=a}D:{e=J[6521];if(e){a=26508;while(1){d=J[a>>2];b=J[a+4>>2];if((d+b|0)==(c|0)){break D}a=J[a+8>>2];if(a){continue}break}break k}a=J[6519];if(!(a>>>0<=c>>>0?a:0)){J[6519]=c}a=0;J[6628]=g;J[6627]=c;J[6523]=-1;J[6524]=J[6633];J[6630]=0;while(1){d=a<<3;b=d+26100|0;J[d+26108>>2]=b;J[d+26112>>2]=b;a=a+1|0;if((a|0)!=32){continue}break}d=g-40|0;a=c+8&7?-8-c&7:0;b=d-a|0;J[6518]=b;a=a+c|0;J[6521]=a;J[a+4>>2]=b|1;J[(c+d|0)+4>>2]=40;J[6522]=J[6637];break j}if(J[a+12>>2]&8|(c>>>0<=e>>>0|d>>>0>e>>>0)){break k}J[a+4>>2]=b+g;a=e+8&7?-8-e&7:0;c=a+e|0;J[6521]=c;b=J[6518]+g|0;a=b-a|0;J[6518]=a;J[c+4>>2]=a|1;J[(b+e|0)+4>>2]=40;J[6522]=J[6637];break j}d=0;break b}c=0;break c}if(M[6519]>c>>>0){J[6519]=c}b=c+g|0;a=26508;E:{F:{G:{while(1){if((b|0)!=J[a>>2]){a=J[a+8>>2];if(a){continue}break G}break}if(!(K[a+12|0]&8)){break F}}a=26508;while(1){b=J[a>>2];if(b>>>0<=e>>>0){f=b+J[a+4>>2]|0;if(f>>>0>e>>>0){break E}}a=J[a+8>>2];continue}}J[a>>2]=c;J[a+4>>2]=J[a+4>>2]+g;j=(c+8&7?-8-c&7:0)+c|0;J[j+4>>2]=h|3;g=b+(b+8&7?-8-b&7:0)|0;i=h+j|0;a=g-i|0;if((e|0)==(g|0)){J[6521]=i;a=J[6518]+a|0;J[6518]=a;J[i+4>>2]=a|1;break d}if(J[6520]==(g|0)){J[6520]=i;a=J[6517]+a|0;J[6517]=a;J[i+4>>2]=a|1;J[a+i>>2]=a;break d}f=J[g+4>>2];if((f&3)!=1){break e}e=f&-8;if(f>>>0<=255){c=J[g+12>>2];b=J[g+8>>2];if((c|0)==(b|0)){m=26060,n=J[6515]&ml(f>>>3|0),J[m>>2]=n;break f}J[b+12>>2]=c;J[c+8>>2]=b;break f}h=J[g+24>>2];c=J[g+12>>2];if((g|0)!=(c|0)){b=J[g+8>>2];J[b+12>>2]=c;J[c+8>>2]=b;break g}b=g+20|0;f=J[b>>2];if(!f){f=J[g+16>>2];if(!f){break h}b=g+16|0}while(1){d=b;c=f;b=c+20|0;f=J[b>>2];if(f){continue}b=c+16|0;f=J[c+16>>2];if(f){continue}break}J[d>>2]=0;break g}d=g-40|0;a=c+8&7?-8-c&7:0;b=d-a|0;J[6518]=b;a=a+c|0;J[6521]=a;J[a+4>>2]=b|1;J[(c+d|0)+4>>2]=40;J[6522]=J[6637];a=(f+(f-39&7?39-f&7:0)|0)-47|0;d=a>>>0>>0?e:a;J[d+4>>2]=27;a=J[6630];J[d+16>>2]=J[6629];J[d+20>>2]=a;a=J[6628];J[d+8>>2]=J[6627];J[d+12>>2]=a;J[6629]=d+8;J[6628]=g;J[6627]=c;J[6630]=0;a=d+24|0;while(1){J[a+4>>2]=7;b=a+8|0;a=a+4|0;if(b>>>0>>0){continue}break}if((d|0)==(e|0)){break j}J[d+4>>2]=J[d+4>>2]&-2;f=d-e|0;J[e+4>>2]=f|1;J[d>>2]=f;if(f>>>0<=255){b=(f&-8)+26100|0;c=J[6515];a=1<<(f>>>3);H:{if(!(c&a)){J[6515]=a|c;a=b;break H}a=J[b+8>>2]}J[b+8>>2]=e;J[a+12>>2]=e;J[e+12>>2]=b;J[e+8>>2]=a;break j}a=31;if(f>>>0<=16777215){a=S(f>>>8|0);a=((f>>>38-a&1)-(a<<1)|0)+62|0}J[e+28>>2]=a;J[e+16>>2]=0;J[e+20>>2]=0;b=(a<<2)+26364|0;I:{d=J[6516];c=1<>2]=e;break J}a=f<<((a|0)!=31?25-(a>>>1|0)|0:0);d=J[b>>2];while(1){b=d;if((f|0)==(J[b+4>>2]&-8)){break I}c=a>>>29|0;a=a<<1;c=(c&4)+b|0;d=J[c+16>>2];if(d){continue}break}J[c+16>>2]=e}J[e+24>>2]=b;J[e+12>>2]=e;J[e+8>>2]=e;break j}a=J[b+8>>2];J[a+12>>2]=e;J[b+8>>2]=e;J[e+24>>2]=0;J[e+12>>2]=b;J[e+8>>2]=a}a=J[6518];if(a>>>0<=h>>>0){break i}b=a-h|0;J[6518]=b;c=J[6521];a=c+h|0;J[6521]=a;J[a+4>>2]=b|1;J[c+4>>2]=h|3;a=c+8|0;break a}J[6204]=48;a=0;break a}c=0}if(!h){break f}d=J[g+28>>2];b=(d<<2)+26364|0;K:{if(J[b>>2]==(g|0)){J[b>>2]=c;if(c){break K}m=26064,n=J[6516]&ml(d),J[m>>2]=n;break f}J[h+(J[h+16>>2]==(g|0)?16:20)>>2]=c;if(!c){break f}}J[c+24>>2]=h;b=J[g+16>>2];if(b){J[c+16>>2]=b;J[b+24>>2]=c}b=J[g+20>>2];if(!b){break f}J[c+20>>2]=b;J[b+24>>2]=c}a=a+e|0;g=e+g|0;f=J[g+4>>2]}J[g+4>>2]=f&-2;J[i+4>>2]=a|1;J[a+i>>2]=a;if(a>>>0<=255){b=(a&-8)+26100|0;c=J[6515];a=1<<(a>>>3);L:{if(!(c&a)){J[6515]=a|c;a=b;break L}a=J[b+8>>2]}J[b+8>>2]=i;J[a+12>>2]=i;J[i+12>>2]=b;J[i+8>>2]=a;break d}f=31;if(a>>>0<=16777215){b=S(a>>>8|0);f=((a>>>38-b&1)-(b<<1)|0)+62|0}J[i+28>>2]=f;J[i+16>>2]=0;J[i+20>>2]=0;b=(f<<2)+26364|0;M:{d=J[6516];c=1<>2]=i;break N}f=a<<((f|0)!=31?25-(f>>>1|0)|0:0);c=J[b>>2];while(1){b=c;if((J[c+4>>2]&-8)==(a|0)){break M}c=f>>>29|0;f=f<<1;d=(c&4)+b|0;c=J[d+16>>2];if(c){continue}break}J[d+16>>2]=i}J[i+24>>2]=b;J[i+12>>2]=i;J[i+8>>2]=i;break d}a=J[b+8>>2];J[a+12>>2]=i;J[b+8>>2]=i;J[i+24>>2]=0;J[i+12>>2]=b;J[i+8>>2]=a}a=j+8|0;break a}O:{if(!g){break O}b=J[d+28>>2];a=(b<<2)+26364|0;P:{if(J[a>>2]==(d|0)){J[a>>2]=c;if(c){break P}j=ml(b)&j;J[6516]=j;break O}J[g+(J[g+16>>2]==(d|0)?16:20)>>2]=c;if(!c){break O}}J[c+24>>2]=g;a=J[d+16>>2];if(a){J[c+16>>2]=a;J[a+24>>2]=c}a=J[d+20>>2];if(!a){break O}J[c+20>>2]=a;J[a+24>>2]=c}Q:{if(f>>>0<=15){a=f+h|0;J[d+4>>2]=a|3;a=a+d|0;J[a+4>>2]=J[a+4>>2]|1;break Q}J[d+4>>2]=h|3;e=d+h|0;J[e+4>>2]=f|1;J[e+f>>2]=f;if(f>>>0<=255){b=(f&-8)+26100|0;c=J[6515];a=1<<(f>>>3);R:{if(!(c&a)){J[6515]=a|c;a=b;break R}a=J[b+8>>2]}J[b+8>>2]=e;J[a+12>>2]=e;J[e+12>>2]=b;J[e+8>>2]=a;break Q}a=31;if(f>>>0<=16777215){a=S(f>>>8|0);a=((f>>>38-a&1)-(a<<1)|0)+62|0}J[e+28>>2]=a;J[e+16>>2]=0;J[e+20>>2]=0;b=(a<<2)+26364|0;S:{c=1<>2]=e;break T}a=f<<((a|0)!=31?25-(a>>>1|0)|0:0);h=J[b>>2];while(1){b=h;if((J[b+4>>2]&-8)==(f|0)){break S}c=a>>>29|0;a=a<<1;c=(c&4)+b|0;h=J[c+16>>2];if(h){continue}break}J[c+16>>2]=e}J[e+24>>2]=b;J[e+12>>2]=e;J[e+8>>2]=e;break Q}a=J[b+8>>2];J[a+12>>2]=e;J[b+8>>2]=e;J[e+24>>2]=0;J[e+12>>2]=b;J[e+8>>2]=a}a=d+8|0;break a}U:{if(!i){break U}b=J[c+28>>2];a=(b<<2)+26364|0;V:{if(J[a>>2]==(c|0)){J[a>>2]=d;if(d){break V}m=26064,n=ml(b)&j,J[m>>2]=n;break U}J[i+(J[i+16>>2]==(c|0)?16:20)>>2]=d;if(!d){break U}}J[d+24>>2]=i;a=J[c+16>>2];if(a){J[d+16>>2]=a;J[a+24>>2]=d}a=J[c+20>>2];if(!a){break U}J[d+20>>2]=a;J[a+24>>2]=d}W:{if(f>>>0<=15){a=f+h|0;J[c+4>>2]=a|3;a=a+c|0;J[a+4>>2]=J[a+4>>2]|1;break W}J[c+4>>2]=h|3;d=c+h|0;J[d+4>>2]=f|1;J[d+f>>2]=f;if(k){b=(k&-8)+26100|0;e=J[6520];a=1<<(k>>>3);X:{if(!(a&g)){J[6515]=a|g;a=b;break X}a=J[b+8>>2]}J[b+8>>2]=e;J[a+12>>2]=e;J[e+12>>2]=b;J[e+8>>2]=a}J[6520]=d;J[6517]=f}a=c+8|0}La=l+16|0;return a|0}function Ud(a,b,c){var d=0,e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=0,m=Q(0),n=0,o=0,p=0,q=0,r=0,s=0,t=Q(0),u=0,v=Q(0),w=0,x=0,y=0,z=Q(0),A=Q(0),B=Q(0),C=0,D=0,E=Q(0),F=Q(0),G=Q(0),M=Q(0),O=Q(0),R=Q(0),S=Q(0),T=Q(0),U=0,V=Q(0),W=0,X=Q(0),Z=Q(0),_=Q(0),$=Q(0);d=La-176|0;La=d;J[5978]=J[5978]+1;r=c- -64|0;w=J[r+4>>2];J[d+168>>2]=J[r>>2];J[d+172>>2]=w;r=J[c+60>>2];J[d+160>>2]=J[c+56>>2];J[d+164>>2]=r;r=J[c+84>>2];J[d+152>>2]=J[c+80>>2];J[d+156>>2]=r;r=J[c+76>>2];J[d+144>>2]=J[c+72>>2];J[d+148>>2]=r;r=c;w=b;c=d+32|0;b=L[b+4>>1];J[c+108>>2]=b;a:{b:{if(!b){break b}while(1){b=c+P(o,36)|0;l=o+w|0;p=K[l+6|0];J[b+28>>2]=p;l=K[l+9|0];J[b+32>>2]=l;l=J[r+44>>2]+(l<<3)|0;e=N[l>>2];f=N[l+4>>2];m=N[d+160>>2];j=N[d+168>>2];l=J[r+16>>2]+(p<<3)|0;g=N[l>>2];h=N[l+4>>2];i=N[d+172>>2];k=Q(Q(Q(j*g)+Q(h*i))+N[d+164>>2]);N[b+4>>2]=k;g=Q(m+Q(Q(i*g)-Q(h*j)));N[b>>2]=g;h=N[d+144>>2];i=N[d+148>>2];m=N[d+152>>2];j=N[d+156>>2];J[b+24>>2]=0;i=Q(i+Q(Q(m*e)+Q(f*j)));N[b+12>>2]=i;e=Q(h+Q(Q(j*e)-Q(f*m)));N[b+8>>2]=e;N[b+20>>2]=i-k;N[b+16>>2]=e-g;o=o+1|0;b=J[c+108>>2];if((o|0)<(b|0)){continue}break}if((b|0)>1){f=N[w>>2];e=Q(0);c:{d:{switch(b-2|0){case 0:e=Q(N[c+16>>2]-N[c+52>>2]);j=Q(e*e);e=Q(N[c+20>>2]-N[c+56>>2]);e=Q(Y(Q(j+Q(e*e))));break c;case 1:break d;default:break c}}e=N[c+16>>2];m=N[c+20>>2];e=Q(Q(Q(N[c+52>>2]-e)*Q(N[c+92>>2]-m))-Q(Q(N[c+88>>2]-e)*Q(N[c+56>>2]-m)))}if(!(Q(f+f)e|e>2]=0;break b}if(b){break a}}J[c+28>>2]=0;J[c+32>>2]=0;b=J[r+44>>2];e=N[b>>2];f=N[b+4>>2];m=N[d+160>>2];j=N[d+168>>2];b=J[r+16>>2];g=N[b>>2];h=N[b+4>>2];i=N[d+172>>2];k=Q(Q(Q(j*g)+Q(h*i))+N[d+164>>2]);N[c+4>>2]=k;g=Q(m+Q(Q(i*g)-Q(h*j)));N[c>>2]=g;m=N[d+156>>2];h=N[d+144>>2];i=N[d+148>>2];j=N[d+152>>2];J[c+108>>2]=1;J[c+24>>2]=1065353216;i=Q(i+Q(Q(j*e)+Q(f*m)));N[c+12>>2]=i;e=Q(h+Q(Q(m*e)-Q(f*j)));N[c+8>>2]=e;N[c+20>>2]=i-k;N[c+16>>2]=e-g}v=N[d+156>>2];E=N[d+172>>2];m=N[3050];j=N[3049];C=J[5979];M=N[d+152>>2];V=Q(-M);F=N[d+168>>2];X=Q(-F);c=J[d+140>>2];Z=N[d+148>>2];_=N[d+144>>2];$=N[d+164>>2];O=N[d+160>>2];e:{f:{g:{h:{i:{j:{k:{l:{while(1){W=(c|0)<=0;m:{if(W){break m}b=0;if((c|0)!=1){l=c&-2;o=0;while(1){p=b<<2;n=d+20|0;s=d+32|0;q=s+P(b,36)|0;J[p+n>>2]=J[q+28>>2];x=p;p=d+8|0;J[x+p>>2]=J[q+32>>2];x=n;n=b|1;q=n<<2;n=s+P(n,36)|0;J[x+q>>2]=J[n+28>>2];J[p+q>>2]=J[n+32>>2];b=b+2|0;o=o+2|0;if((l|0)!=(o|0)){continue}break}}if(!(c&1)){break m}o=b<<2;b=(d+32|0)+P(b,36)|0;J[o+(d+20|0)>>2]=J[b+28>>2];J[o+(d+8|0)>>2]=J[b+32>>2]}n:{o:{p:{q:{r:{s:{t:{u:{b=c;switch(b-2|0){case 1:break t;case 0:break u;default:break s}}k=N[d+84>>2];g=N[d+48>>2];e=Q(k-g);t=N[d+88>>2];h=N[d+52>>2];f=Q(t-h);i=Q(Q(g*e)+Q(h*f));if(i>=Q(0)){J[d+140>>2]=1;J[d+56>>2]=1065353216;break o}k=Q(Q(k*e)+Q(t*f));if(!(k<=Q(0))){break r}J[d+140>>2]=1;J[d+92>>2]=1065353216;b=J[d+80>>2];J[d+40>>2]=J[d+76>>2];J[d+44>>2]=b;b=J[d+88>>2];J[d+48>>2]=J[d+84>>2];J[d+52>>2]=b;b=J[d+96>>2];J[d+56>>2]=J[d+92>>2];J[d+60>>2]=b;J[d- -64>>2]=J[d+100>>2];b=J[d+72>>2];J[d+32>>2]=J[d+68>>2];J[d+36>>2]=b;break o}e=N[d+120>>2];f=N[d+48>>2];z=Q(e-f);g=N[d+124>>2];h=N[d+52>>2];B=Q(g-h);i=N[d+84>>2];A=Q(i-f);k=N[d+88>>2];R=Q(k-h);G=Q(Q(f*A)+Q(h*R));t=Q(Q(f*z)+Q(h*B));v:{if(!(!(G>=Q(0))|!(t>=Q(0)))){J[d+140>>2]=1;J[d+56>>2]=1065353216;break v}S=Q(Q(A*B)-Q(z*R));T=Q(Q(Q(f*k)-Q(i*h))*S);A=Q(Q(i*A)+Q(k*R));if(!(!(T<=Q(0))|(!(A>Q(0))|!(G>2]=2;e=Q(Q(1)/Q(A-G));N[d+92>>2]=e*Q(-G);N[d+56>>2]=A*e;break v}z=Q(Q(e*z)+Q(g*B));B=Q(S*Q(Q(e*h)-Q(f*g)));if(!(!(tQ(0))))){J[d+140>>2]=2;e=Q(Q(1)/Q(z-t));N[d+128>>2]=e*Q(-t);N[d+56>>2]=z*e;J[d+100>>2]=J[d+136>>2];b=J[d+132>>2];J[d+92>>2]=J[d+128>>2];J[d+96>>2]=b;b=J[d+124>>2];J[d+84>>2]=J[d+120>>2];J[d+88>>2]=b;b=J[d+116>>2];J[d+76>>2]=J[d+112>>2];J[d+80>>2]=b;b=J[d+108>>2];J[d+68>>2]=J[d+104>>2];J[d+72>>2]=b;break v}h=Q(e-i);t=Q(g-k);f=Q(Q(i*h)+Q(k*t));if(!(!(A<=Q(0))|!(f>=Q(0)))){J[d+140>>2]=1;J[d+92>>2]=1065353216;b=J[d+72>>2];J[d+32>>2]=J[d+68>>2];J[d+36>>2]=b;b=J[d+80>>2];J[d+40>>2]=J[d+76>>2];J[d+44>>2]=b;b=J[d+88>>2];J[d+48>>2]=J[d+84>>2];J[d+52>>2]=b;b=J[d+96>>2];J[d+56>>2]=J[d+92>>2];J[d+60>>2]=b;J[d+64>>2]=J[d+100>>2];break v}w:{h=Q(Q(e*h)+Q(g*t));if(!(!(z<=Q(0))|!(h<=Q(0)))){J[d+140>>2]=1;J[d+128>>2]=1065353216;break w}e=Q(Q(Q(i*g)-Q(e*k))*S);if(!(!(fQ(0))))){J[d+140>>2]=2;e=Q(Q(1)/Q(h-f));N[d+128>>2]=e*Q(-f);N[d+92>>2]=h*e;break w}J[d+140>>2]=3;f=Q(Q(1)/Q(T+Q(e+B)));N[d+128>>2]=T*f;N[d+92>>2]=B*f;N[d+56>>2]=e*f;break v}b=J[d+108>>2];J[d+32>>2]=J[d+104>>2];J[d+36>>2]=b;b=J[d+116>>2];J[d+40>>2]=J[d+112>>2];J[d+44>>2]=b;b=J[d+124>>2];J[d+48>>2]=J[d+120>>2];J[d+52>>2]=b;b=J[d+132>>2];J[d+56>>2]=J[d+128>>2];J[d+60>>2]=b;J[d+64>>2]=J[d+136>>2]}b=J[d+140>>2]}f=j;e=m;x:{switch(b-1|0){case 0:break o;case 2:break p;case 1:break x;default:break n}}h=N[d+52>>2];f=Q(N[d+88>>2]-h);g=N[d+48>>2];e=Q(N[d+84>>2]-g);break q}J[d+140>>2]=2;t=Q(Q(1)/Q(k-i));N[d+92>>2]=t*Q(-i);N[d+56>>2]=k*t}y:{if(Q(Q(g*f)-Q(e*h))>Q(0)){f=Q(-f);break y}e=Q(-e)}b=2;break n}b=J[5980];J[5980]=(b|0)>(u|0)?b:u;b=u;break j}e=Q(-N[d+52>>2]);f=Q(-N[d+48>>2]);b=1}if(Q(Q(f*f)+Q(e*e))>2];p=0;o=0;s=J[r+20>>2];z:{if((s|0)<2){break z}h=Q(Q(E*Q(-f))-Q(F*e));i=Q(Q(F*f)-Q(E*e));g=Q(Q(N[n>>2]*h)+Q(i*N[n+4>>2]));b=1;q=s-1|0;U=q&1;if((s|0)!=2){x=q&-2;s=0;while(1){q=n+(b<<3)|0;k=Q(Q(N[q>>2]*h)+Q(i*N[q+4>>2]));q=k>g;D=b+1|0;y=n+(D<<3)|0;t=Q(Q(N[y>>2]*h)+Q(i*N[y+4>>2]));g=q?k:g;y=t>g;g=y?t:g;o=y?D:q?b:o;b=b+2|0;s=s+2|0;if((x|0)!=(s|0)){continue}break}}if(!U){break z}x=b;b=n+(b<<3)|0;o=Q(Q(N[b>>2]*h)+Q(i*N[b+4>>2]))>g?x:o}J[l+28>>2]=o;b=n+(o<<3)|0;g=N[b>>2];h=N[b+4>>2];i=Q(Q(Q(F*g)+Q(E*h))+$);N[l+4>>2]=i;k=Q(O+Q(Q(E*g)+Q(h*X)));N[l>>2]=k;n=J[r+44>>2];s=J[r+48>>2];A:{if((s|0)<2){break A}h=Q(Q(v*f)+Q(e*M));e=Q(Q(V*f)+Q(e*v));g=Q(Q(N[n>>2]*h)+Q(e*N[n+4>>2]));b=1;q=s-1|0;U=q&1;if((s|0)!=2){x=q&-2;s=0;while(1){q=n+(b<<3)|0;f=Q(Q(N[q>>2]*h)+Q(e*N[q+4>>2]));q=f>g;D=b+1|0;y=n+(D<<3)|0;t=Q(Q(N[y>>2]*h)+Q(e*N[y+4>>2]));f=q?f:g;y=t>f;g=y?t:f;p=y?D:q?b:p;b=b+2|0;s=s+2|0;if((x|0)!=(s|0)){continue}break}}if(!U){break A}x=b;b=n+(b<<3)|0;p=Q(Q(N[b>>2]*h)+Q(e*N[b+4>>2]))>g?x:p}J[l+32>>2]=p;b=n+(p<<3)|0;e=N[b>>2];f=N[b+4>>2];g=Q(Q(Q(M*e)+Q(v*f))+Z);N[l+12>>2]=g;e=Q(_+Q(Q(v*e)+Q(f*V)));N[l+8>>2]=e;N[l+20>>2]=g-i;N[l+16>>2]=e-k;b=0;C=C+1|0;J[5979]=C;u=u+1|0;B:{if(!W){while(1){l=b<<2;if(J[l+(d+20|0)>>2]==(o|0)&J[l+(d+8|0)>>2]==(p|0)){break B}b=b+1|0;if((c|0)!=(b|0)){continue}break}}c=J[d+140>>2]+1|0;J[d+140>>2]=c;b=20;if((u|0)!=20){continue}break k}break}b=J[d+140>>2]}c=b;b=u}u=J[5980];J[5980]=(b|0)<(u|0)?u:b;C:{switch(c-1|0){case 0:break h;case 2:break j;case 1:break C;default:break i}}m=N[d+72>>2];j=N[d+36>>2];e=N[d+56>>2];f=N[d+92>>2];g=Q(Q(e*N[d+32>>2])+Q(f*N[d+68>>2]));N[a>>2]=g;m=Q(Q(e*j)+Q(f*m));N[a+4>>2]=m;j=N[d+76>>2];h=N[d+44>>2];i=N[d+80>>2];k=N[d+40>>2];J[a+20>>2]=b;h=Q(Q(e*h)+Q(f*i));N[a+12>>2]=h;e=Q(Q(e*k)+Q(f*j));N[a+8>>2]=e;e=Q(g-e);j=Q(e*e);e=Q(m-h);N[a+16>>2]=Y(Q(j+Q(e*e)));e=Q(N[d+48>>2]-N[d+84>>2]);j=Q(e*e);e=Q(N[d+52>>2]-N[d+88>>2]);g=Q(Y(Q(j+Q(e*e))));u=a+16|0;b=2;c=2;break g}g=N[d+108>>2];h=N[d+72>>2];f=N[d+128>>2];i=N[d+36>>2];e=N[d+104>>2];k=N[d+32>>2];m=N[d+56>>2];v=N[d+68>>2];j=N[d+92>>2];J[a+20>>2]=b;e=Q(Q(Q(m*k)+Q(j*v))+Q(f*e));N[a+8>>2]=e;N[a>>2]=e;f=Q(Q(Q(m*i)+Q(j*h))+Q(f*g));N[a+12>>2]=f;N[a+4>>2]=f;e=Q(e-e);j=Q(e*e);e=Q(f-f);N[a+16>>2]=Y(Q(j+Q(e*e)));e=N[d+48>>2];f=N[d+52>>2];g=Q(Q(Q(N[d+84>>2]-e)*Q(N[d+124>>2]-f))-Q(Q(N[d+120>>2]-e)*Q(N[d+88>>2]-f)));u=a+16|0;b=3;c=3;break g}J[a+20>>2]=b;e=Q(N[a>>2]-N[a+8>>2]);j=Q(e*e);e=Q(N[a+4>>2]-N[a+12>>2]);N[a+16>>2]=Y(Q(j+Q(e*e)));I[w+4>>1]=c;J[w>>2]=0;u=a+16|0;if((c|0)>0){break f}break e}O=N[d+36>>2];o=J[d+36>>2];e=N[d+32>>2];J[a>>2]=J[d+32>>2];J[a+4>>2]=o;f=N[d+40>>2];u=J[d+40>>2];m=N[d+44>>2];l=J[d+44>>2];J[a+20>>2]=b;J[a+8>>2]=u;J[a+12>>2]=l;e=Q(e-f);j=Q(e*e);e=Q(O-m);N[a+16>>2]=Y(Q(j+Q(e*e)));u=a+16|0;g=Q(0);b=c;c=1}I[w+4>>1]=b;N[w>>2]=g}s=c&1;b=0;if((c|0)!=1){C=c&-2;o=w+6|0;l=w+9|0;c=0;while(1){n=d+32|0;p=n+P(b,36)|0;H[b+o|0]=J[p+28>>2];H[b+l|0]=J[p+32>>2];p=b|1;n=n+P(p,36)|0;H[o+p|0]=J[n+28>>2];H[l+p|0]=J[n+32>>2];b=b+2|0;c=c+2|0;if((C|0)!=(c|0)){continue}break}}if(!s){break e}c=b+w|0;b=(d+32|0)+P(b,36)|0;H[c+6|0]=J[b+28>>2];H[c+9|0]=J[b+32>>2]}D:{if(!K[r+88|0]){break D}e=N[u>>2];f=N[r+24>>2];m=N[r+52>>2];j=Q(f+m);if(!(!(e>j)|!(e>Q(1.1920928955078125e-7)))){N[a+16>>2]=e-j;e=N[a+8>>2];j=N[a>>2];g=Q(e-j);i=N[a+12>>2];k=N[a+4>>2];h=Q(i-k);v=Q(Y(Q(Q(g*g)+Q(h*h))));if(!(v>2]=i-Q(m*h);N[a+8>>2]=e-Q(m*g);N[a+4>>2]=k+Q(f*h);N[a>>2]=j+Q(f*g);break D}J[a+16>>2]=0;e=Q(Q(N[a+4>>2]+N[a+12>>2])*Q(.5));N[a+12>>2]=e;f=Q(Q(N[a>>2]+N[a+8>>2])*Q(.5));N[a+8>>2]=f;N[a+4>>2]=e;N[a>>2]=f}La=d+176|0}function Wk(a,b,c){a=a|0;b=b|0;c=c|0;var d=Q(0),e=Q(0),f=0,g=0,h=0,i=Q(0),j=0,k=0,l=Q(0),m=Q(0),n=Q(0),o=0,p=Q(0),q=0,r=0,s=0,t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=0,z=Q(0),A=Q(0),B=Q(0),C=Q(0),D=Q(0),E=Q(0),F=Q(0),G=Q(0),H=Q(0);a:{k=a;j=J[b>>2];b:{if((c|0)<=2){break b}a=J[j+4>>2];f=La-96|0;J[f+32>>2]=J[j>>2];J[f+36>>2]=a;g=1;h=(c|0)>=8?8:c;c:{if((h|0)==1){break c}o=J[j+12>>2];i=N[j+12>>2];c=J[j+8>>2];e=N[j+8>>2];a=0;d:{while(1){b=(f+32|0)+(a<<3)|0;d=Q(e-N[b>>2]);p=Q(d*d);d=Q(i-N[b+4>>2]);if(Q(p+Q(d*d))>2]=o;J[f+40>>2]=c;g=2}if((h|0)==2){break c}o=J[j+20>>2];i=N[j+20>>2];c=J[j+16>>2];e=N[j+16>>2];a=0;e:{while(1){b=(f+32|0)+(a<<3)|0;d=Q(e-N[b>>2]);p=Q(d*d);d=Q(i-N[b+4>>2]);if(Q(p+Q(d*d))>2]=o;J[a>>2]=c;g=g+1|0}if((h|0)==3){break c}e=N[j+28>>2];o=J[j+28>>2];d=N[j+24>>2];c=J[j+24>>2];f:{if((g|0)>0){a=0;while(1){b=(f+32|0)+(a<<3)|0;i=Q(d-N[b>>2]);p=Q(i*i);i=Q(e-N[b+4>>2]);if(Q(p+Q(i*i))>2]=o;J[a>>2]=c;g=g+1|0}if((h|0)==4){break c}e=N[j+36>>2];o=J[j+36>>2];d=N[j+32>>2];c=J[j+32>>2];g:{if((g|0)>0){a=0;while(1){b=(f+32|0)+(a<<3)|0;i=Q(d-N[b>>2]);p=Q(i*i);i=Q(e-N[b+4>>2]);if(Q(p+Q(i*i))>2]=o;J[a>>2]=c;g=g+1|0}if((h|0)==5){break c}e=N[j+44>>2];o=J[j+44>>2];d=N[j+40>>2];c=J[j+40>>2];h:{if((g|0)>0){a=0;while(1){b=(f+32|0)+(a<<3)|0;i=Q(d-N[b>>2]);p=Q(i*i);i=Q(e-N[b+4>>2]);if(Q(p+Q(i*i))>2]=o;J[a>>2]=c;g=g+1|0}if((h|0)==6){break c}e=N[j+52>>2];o=J[j+52>>2];d=N[j+48>>2];c=J[j+48>>2];i:{if((g|0)>0){a=0;while(1){b=(f+32|0)+(a<<3)|0;i=Q(d-N[b>>2]);p=Q(i*i);i=Q(e-N[b+4>>2]);if(Q(p+Q(i*i))>2]=o;J[a>>2]=c;g=g+1|0}if((h|0)==7){break c}e=N[j+60>>2];o=J[j+60>>2];d=N[j+56>>2];c=J[j+56>>2];if((g|0)>0){a=0;while(1){b=(f+32|0)+(a<<3)|0;i=Q(d-N[b>>2]);p=Q(i*i);i=Q(e-N[b+4>>2]);if(Q(p+Q(i*i))>2]=o;J[a>>2]=c;g=g+1|0}if((g|0)<3){break b}d=N[f+32>>2];e=N[f+40>>2];j:{if(!(d>2]>2])|d!=e){break j}}d=e;h=1}k:{if((g|0)==2){break k}e=N[f+48>>2];if(!(!(e>d)&(!(N[f+52>>2]>2])|d!=e))){h=2;d=e}if((g|0)==3){break k}e=N[f+56>>2];if(!(!(e>d)&(!(N[f+60>>2]>2])|d!=e))){h=3;d=e}if((g|0)==4){break k}e=N[f+64>>2];if(!(!(e>d)&(!(N[f+68>>2]>2])|d!=e))){h=4;d=e}if((g|0)==5){break k}e=N[f+72>>2];if(!(!(e>d)&(!(N[f+76>>2]>2])|d!=e))){h=5;d=e}if((g|0)==6){break k}e=N[f+80>>2];if(!(!(e>d)&(!(N[f+84>>2]>2])|d!=e))){h=6;d=e}if((g|0)==7){break k}e=N[f+88>>2];if(!(e>d)&(!(N[f+92>>2]>2])|d!=e)){break k}h=7}l:{m:{n:{if((g|0)>=2){D=N[f+92>>2];E=N[f+84>>2];F=N[f+76>>2];G=N[f+68>>2];H=N[f+60>>2];C=N[f+52>>2];b=0;t=N[f+88>>2];u=N[f+80>>2];v=N[f+72>>2];w=N[f+64>>2];x=N[f+56>>2];z=N[f+48>>2];A=N[f+44>>2];B=N[f+40>>2];p=N[f+36>>2];i=N[f+32>>2];y=(g|0)==5;s=(g|0)==6;j=(g|0)==7;a=h;while(1){o=b;c=a;J[(b<<2)+f>>2]=a;q=(f+32|0)+(a<<3)|0;r=q|4;a=1;o:{if(!c){break o}e=N[q>>2];l=Q(i-e);d=N[r>>2];m=Q(A-d);n=Q(B-e);e=Q(p-d);d=Q(Q(l*m)-Q(n*e));a=dQ(Q(l*l)+Q(e*e)))|d!=Q(0)){break o}a=1}p:{if((g|0)==2){break p}b=2;q:{if((a|0)==(c|0)){break q}b=a;a=f+32|a<<3;e=N[q>>2];l=Q(N[a>>2]-e);d=N[r>>2];m=Q(C-d);n=Q(z-e);e=Q(N[a+4>>2]-d);d=Q(Q(l*m)-Q(n*e));b=dQ(Q(l*l)+Q(e*e)))|d!=Q(0)){break q}b=2}if((g|0)==3){a=b;break p}a=3;r:{if((b|0)==(c|0)){break r}a=(f+32|0)+(b<<3)|0;e=N[q>>2];l=Q(N[a>>2]-e);d=N[r>>2];m=Q(H-d);n=Q(x-e);e=Q(N[a+4>>2]-d);d=Q(Q(l*m)-Q(n*e));a=dQ(Q(l*l)+Q(e*e)))|d!=Q(0)){break r}a=3}if((g|0)==4){break p}b=4;s:{if((a|0)==(c|0)){break s}b=a;a=(f+32|0)+(a<<3)|0;e=N[q>>2];l=Q(N[a>>2]-e);d=N[r>>2];m=Q(G-d);n=Q(w-e);e=Q(N[a+4>>2]-d);d=Q(Q(l*m)-Q(n*e));b=dQ(Q(l*l)+Q(e*e)))|d!=Q(0)){break s}b=4}if(y){a=b;break p}a=5;t:{if((b|0)==(c|0)){break t}a=(f+32|0)+(b<<3)|0;e=N[q>>2];l=Q(N[a>>2]-e);d=N[r>>2];m=Q(F-d);n=Q(v-e);e=Q(N[a+4>>2]-d);d=Q(Q(l*m)-Q(n*e));a=dQ(Q(l*l)+Q(e*e)))|d!=Q(0)){break t}a=5}if(s){break p}b=6;u:{if((a|0)==(c|0)){break u}b=a;a=(f+32|0)+(a<<3)|0;e=N[q>>2];l=Q(N[a>>2]-e);d=N[r>>2];m=Q(E-d);n=Q(u-e);e=Q(N[a+4>>2]-d);d=Q(Q(l*m)-Q(n*e));b=dQ(Q(l*l)+Q(e*e)))|d!=Q(0)){break u}b=6}if(j){a=b;break p}a=7;if((b|0)==(c|0)){break p}a=(f+32|0)+(b<<3)|0;e=N[q>>2];l=Q(N[a>>2]-e);d=N[r>>2];m=Q(D-d);n=Q(t-e);e=Q(N[a+4>>2]-d);d=Q(Q(l*m)-Q(n*e));a=dQ(Q(l*l)+Q(e*e)))|d!=Q(0)){break p}a=7}b=o+1|0;if((a|0)!=(h|0)){continue}break}if(o>>>0>1){break n}break m}if(!h){break m}a=1;while(1){J[(a<<2)+f>>2]=0;a=a+1|0;continue}}J[k+148>>2]=b;b=o+1|0;r=b&3;g=0;a=0;if((o|0)!=2){j=b&-4;q=k+20|0;y=0;while(1){s=f+32|0;c=s+(J[(a<<2)+f>>2]<<3)|0;b=J[c+4>>2];h=q+(a<<3)|0;J[h>>2]=J[c>>2];J[h+4>>2]=b;b=a|1;h=q+(b<<3)|0;c=s+(J[(b<<2)+f>>2]<<3)|0;b=J[c+4>>2];J[h>>2]=J[c>>2];J[h+4>>2]=b;b=a|2;h=q+(b<<3)|0;c=s+(J[(b<<2)+f>>2]<<3)|0;b=J[c+4>>2];J[h>>2]=J[c>>2];J[h+4>>2]=b;b=a|3;h=q+(b<<3)|0;c=(J[(b<<2)+f>>2]<<3)+s|0;b=J[c+4>>2];J[h>>2]=J[c>>2];J[h+4>>2]=b;a=a+4|0;y=y+4|0;if((j|0)!=(y|0)){continue}break}}if(r){while(1){c=(f+32|0)+(J[(a<<2)+f>>2]<<3)|0;b=J[c+4>>2];h=(a<<3)+k|0;J[h+20>>2]=J[c>>2];J[h+24>>2]=b;a=a+1|0;g=g+1|0;if((r|0)!=(g|0)){continue}break}}s=k+20|0;a=0;while(1){j=a<<3;h=j+s|0;e=N[h>>2];b=a+1|0;c=s+((a>>>0>>0?b:0)<<3)|0;d=N[c>>2];j=j+k|0;i=Q(N[c+4>>2]-N[h+4>>2]);N[j+84>>2]=i;d=Q(d-e);e=Q(-d);N[j+88>>2]=e;d=Q(Y(Q(Q(i*i)+Q(d*d))));if(!(d>2]=i*d;N[j+88>>2]=d*e}c=(a|0)==(o|0);a=b;if(!c){continue}break}h=k+20|0;t=N[k+24>>2];i=Q(t-t);u=N[k+20>>2];e=Q(u-u);a=0;v=Q(0);w=Q(0);x=Q(0);while(1){b=a+1|0;c=h+(a<<3)|0;z=Q(N[c+4>>2]-t);A=Q(N[c>>2]-u);p=e;d=i;if(a>>>0>>0){c=h+(b<<3)|0;d=Q(N[c+4>>2]-t);p=Q(N[c>>2]-u)}B=Q(Q(Q(Q(A-e)*Q(d-i))-Q(Q(p-e)*Q(z-i)))*Q(.5));x=Q(x+B);C=Q(Q(i+z)+d);d=Q(B*Q(.3333333432674408));v=Q(v+Q(C*d));w=Q(w+Q(Q(Q(e+A)+p)*d));c=(a|0)!=(o|0);a=b;if(c){continue}break}d=Q(Q(1)/x);p=Q(t+Q(d*v));e=Q(u+Q(d*w));break l}a=k;J[a+84>>2]=0;J[a+88>>2]=-1082130432;J[a+20>>2]=-1082130432;J[a+24>>2]=-1082130432;J[a+148>>2]=4;J[a+108>>2]=-1082130432;J[a+112>>2]=0;J[a+100>>2]=0;J[a+104>>2]=1065353216;J[a+92>>2]=1065353216;J[a+96>>2]=0;J[a+44>>2]=-1082130432;J[a+48>>2]=1065353216;J[a+36>>2]=1065353216;J[a+40>>2]=1065353216;J[a+28>>2]=1065353216;J[a+32>>2]=-1082130432;p=Q(0);e=Q(0)}N[k+12>>2]=e;N[k+16>>2]=p;break a}J[k+84>>2]=0;J[k+88>>2]=-1082130432;J[k+20>>2]=-1082130432;J[k+24>>2]=-1082130432;J[k+148>>2]=4;J[k+12>>2]=0;J[k+16>>2]=0;J[k+108>>2]=-1082130432;J[k+112>>2]=0;J[k+100>>2]=0;J[k+104>>2]=1065353216;J[k+92>>2]=1065353216;J[k+96>>2]=0;J[k+44>>2]=-1082130432;J[k+48>>2]=1065353216;J[k+36>>2]=1065353216;J[k+40>>2]=1065353216;J[k+28>>2]=1065353216;J[k+32>>2]=-1082130432}}function If(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,f=0,g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=0,l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=0,q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),w=Q(0),x=0,y=Q(0);a:{if(K[a+102989|0]){break a}b:{c:{switch(J[b>>2]-1|0){case 2:c=xb(eb(a,176),b);J[c>>2]=12456;d=J[b+24>>2];J[c+80>>2]=J[b+20>>2];J[c+84>>2]=d;d=J[b+32>>2];J[c+88>>2]=J[b+28>>2];J[c+92>>2]=d;N[c+104>>2]=N[b+36>>2];N[c+68>>2]=N[b+40>>2];N[c+72>>2]=N[b+44>>2];J[c+96>>2]=0;J[c+100>>2]=0;J[c+76>>2]=0;break b;case 4:c=xb(eb(a,168),b);J[c>>2]=13040;j=N[b+24>>2];f=J[b+24>>2];g=N[b+20>>2];J[c+76>>2]=J[b+20>>2];J[c+80>>2]=f;d=J[c+52>>2];h=N[d+24>>2];i=Q(j-N[d+16>>2]);l=N[d+20>>2];g=Q(g-N[d+12>>2]);N[c+72>>2]=Q(h*i)-Q(l*g);N[c+68>>2]=Q(h*g)+Q(i*l);N[c+104>>2]=N[b+28>>2];J[c+96>>2]=0;J[c+100>>2]=0;N[c+84>>2]=N[b+32>>2];N[c+88>>2]=N[b+36>>2];J[c+108>>2]=0;J[c+92>>2]=0;break b;case 1:c=xb(eb(a,240),b);J[c>>2]=13236;d=J[b+24>>2];J[c+68>>2]=J[b+20>>2];J[c+72>>2]=d;d=J[b+32>>2];J[c+76>>2]=J[b+28>>2];J[c+80>>2]=d;h=N[b+40>>2];f=J[b+40>>2];g=N[b+36>>2];d=J[b+36>>2];J[c+84>>2]=d;J[c+88>>2]=f;i=Q(Y(Q(Q(g*g)+Q(h*h))));if(!(i>2]=h;g=Q(i*g);N[c+84>>2]=g;d=(C(g),v(2))}J[c+96>>2]=d;N[c+92>>2]=-h;g=N[b+44>>2];J[c+236>>2]=0;N[c+100>>2]=g;J[c+104>>2]=0;J[c+108>>2]=0;J[c+112>>2]=0;J[c+116>>2]=0;J[c+120>>2]=0;N[c+124>>2]=N[b+52>>2];N[c+128>>2]=N[b+56>>2];N[c+132>>2]=N[b+64>>2];N[c+136>>2]=N[b+68>>2];H[c+140|0]=K[b+48|0];d=K[b+60|0];J[c+232>>2]=0;H[c+141|0]=d;J[c+184>>2]=0;J[c+188>>2]=0;J[c+192>>2]=0;J[c+196>>2]=0;break b;case 0:c=xb(eb(a,212),b);J[c>>2]=13408;d=J[b+24>>2];J[c+68>>2]=J[b+20>>2];J[c+72>>2]=d;d=J[b+32>>2];J[c+76>>2]=J[b+28>>2];J[c+80>>2]=d;g=N[b+36>>2];J[c+208>>2]=0;N[c+120>>2]=g;J[c+84>>2]=0;J[c+88>>2]=0;J[c+92>>2]=0;J[c+96>>2]=0;J[c+100>>2]=0;N[c+124>>2]=N[b+44>>2];N[c+128>>2]=N[b+48>>2];N[c+108>>2]=N[b+60>>2];N[c+112>>2]=N[b+56>>2];H[c+116|0]=K[b+40|0];d=K[b+52|0];J[c+204>>2]=0;H[c+104|0]=d;break b;case 3:c=xb(eb(a,196),b);J[c>>2]=13324;d=J[b+24>>2];J[c+68>>2]=J[b+20>>2];J[c+72>>2]=d;d=J[b+32>>2];J[c+76>>2]=J[b+28>>2];J[c+80>>2]=d;d=J[b+40>>2];J[c+92>>2]=J[b+36>>2];J[c+96>>2]=d;d=J[b+48>>2];J[c+100>>2]=J[b+44>>2];J[c+104>>2]=d;h=N[b+52>>2];N[c+84>>2]=h;i=N[b+56>>2];N[c+88>>2]=i;g=N[b+60>>2];J[c+116>>2]=0;N[c+112>>2]=g;N[c+108>>2]=h+Q(g*i);break b;case 5:c=xb(eb(a,276),b);J[c>>2]=12664;e=J[b+20>>2];J[c+68>>2]=e;p=J[b+24>>2];J[c+72>>2]=p;k=J[e+4>>2];J[c+76>>2]=k;x=J[p+4>>2];J[c+80>>2]=x;d=J[e+48>>2];J[c+84>>2]=d;f=J[e+52>>2];J[c+48>>2]=f;d:{if((k|0)==1){h=N[d+56>>2];i=N[f+56>>2];d=J[e+72>>2];J[c+108>>2]=J[e+68>>2];J[c+112>>2]=d;d=J[e+80>>2];J[c+92>>2]=J[e+76>>2];J[c+96>>2]=d;g=N[e+120>>2];J[c+124>>2]=0;J[c+128>>2]=0;N[c+140>>2]=g;g=Q(Q(i-h)-g);break d}h=N[d+20>>2];i=N[d+24>>2];l=N[f+20>>2];o=N[f+24>>2];q=N[f+16>>2];r=N[d+16>>2];n=N[f+12>>2];j=N[d+12>>2];s=N[e+72>>2];f=J[e+72>>2];m=N[e+68>>2];J[c+108>>2]=J[e+68>>2];J[c+112>>2]=f;t=N[e+80>>2];d=J[e+80>>2];g=N[e+76>>2];k=J[e+76>>2];J[c+92>>2]=k;J[c+96>>2]=d;N[c+140>>2]=N[e+100>>2];u=N[e+84>>2];k=J[e+84>>2];w=N[e+88>>2];e=J[e+88>>2];J[c+124>>2]=k;J[c+128>>2]=e;j=Q(n-j);n=t;j=Q(j+Q(Q(o*g)-Q(l*n)));g=Q(Q(q-r)+Q(Q(l*g)+Q(o*n)));g=Q(Q(Q(Q(Q(i*j)+Q(h*g))-m)*u)+Q(Q(Q(Q(i*g)-Q(h*j))-s)*w))}d=J[p+48>>2];J[c+88>>2]=d;f=J[p+52>>2];J[c+52>>2]=f;e:{if((x|0)==1){i=N[d+56>>2];l=N[f+56>>2];d=J[b+24>>2];f=J[d+72>>2];J[c+116>>2]=J[d+68>>2];J[c+120>>2]=f;f=J[d+80>>2];J[c+100>>2]=J[d+76>>2];J[c+104>>2]=f;h=N[d+120>>2];J[c+132>>2]=0;J[c+136>>2]=0;N[c+144>>2]=h;h=Q(Q(l-i)-h);break e}i=N[d+20>>2];l=N[d+24>>2];o=N[f+20>>2];q=N[f+24>>2];r=N[f+16>>2];n=N[d+16>>2];j=N[f+12>>2];m=N[d+12>>2];e=J[b+24>>2];d=e;u=N[d+68>>2];d=J[d+68>>2];s=N[e+72>>2];f=J[e+72>>2];J[c+116>>2]=d;J[c+120>>2]=f;t=N[e+80>>2];d=J[e+80>>2];h=N[e+76>>2];k=J[e+76>>2];J[c+100>>2]=k;J[c+104>>2]=d;N[c+144>>2]=N[e+100>>2];w=N[e+84>>2];k=J[e+84>>2];y=N[e+88>>2];e=J[e+88>>2];J[c+132>>2]=k;J[c+136>>2]=e;m=Q(j-m);j=t;m=Q(m+Q(Q(q*h)-Q(o*j)));h=Q(Q(r-n)+Q(Q(o*h)+Q(q*j)));h=Q(Q(Q(Q(Q(l*m)+Q(i*h))-u)*w)+Q(Q(Q(Q(l*h)-Q(i*m))-s)*y))}i=N[b+28>>2];J[c+156>>2]=0;N[c+152>>2]=i;N[c+148>>2]=Q(i*h)+g;break b;case 6:c=xb(eb(a,248),b);J[c>>2]=13664;d=J[b+24>>2];J[c+68>>2]=J[b+20>>2];J[c+72>>2]=d;d=J[b+32>>2];J[c+76>>2]=J[b+28>>2];J[c+80>>2]=d;f=J[b+36>>2];d=J[b+40>>2];J[c+100>>2]=0;J[c+104>>2]=0;J[c+96>>2]=f;J[c+84>>2]=f;J[c+88>>2]=d;J[c+108>>2]=0;J[c+112>>2]=0;J[c+116>>2]=0;J[c+224>>2]=0;J[c+228>>2]=0;J[c+232>>2]=0;J[c+236>>2]=0;J[c+92>>2]=d^-2147483648;N[c+124>>2]=N[b+48>>2];N[c+128>>2]=N[b+52>>2];H[c+140|0]=K[b+44|0];N[c+132>>2]=N[b+60>>2];N[c+136>>2]=N[b+64>>2];d=K[b+56|0];J[c+240>>2]=0;J[c+244>>2]=0;H[c+141|0]=d;J[c+192>>2]=0;J[c+196>>2]=0;J[c+200>>2]=0;J[c+204>>2]=0;N[c+144>>2]=N[b+68>>2];N[c+148>>2]=N[b+72>>2];break b;case 7:c=xb(eb(a,208),b);J[c>>2]=13580;d=J[b+24>>2];J[c+80>>2]=J[b+20>>2];J[c+84>>2]=d;d=J[b+32>>2];J[c+88>>2]=J[b+28>>2];J[c+92>>2]=d;N[c+96>>2]=N[b+36>>2];N[c+68>>2]=N[b+40>>2];g=N[b+44>>2];J[c+112>>2]=0;J[c+104>>2]=0;J[c+108>>2]=0;N[c+72>>2]=g;break b;case 8:c=xb(eb(a,180),b);J[c>>2]=12748;d=J[b+24>>2];J[c+68>>2]=J[b+20>>2];J[c+72>>2]=d;d=J[b+28>>2];f=J[b+32>>2];J[c+92>>2]=0;J[c+84>>2]=0;J[c+88>>2]=0;J[c+76>>2]=d;J[c+80>>2]=f;N[c+96>>2]=N[b+36>>2];N[c+100>>2]=N[b+40>>2];break b;case 9:c=xb(eb(a,164),b);J[c>>2]=13496;d=J[b+24>>2];J[c+68>>2]=J[b+20>>2];J[c+72>>2]=d;d=J[b+32>>2];J[c+76>>2]=J[b+28>>2];J[c+80>>2]=d;g=N[b+36>>2];J[c+160>>2]=0;N[c+84>>2]=g;J[c+88>>2]=0;J[c+92>>2]=0;break b;case 10:break c;default:break b}}c=xb(eb(a,192),b);J[c>>2]=12956;d=J[b+24>>2];J[c+68>>2]=J[b+20>>2];J[c+72>>2]=d;g=N[b+28>>2];J[c+88>>2]=0;J[c+80>>2]=0;J[c+84>>2]=0;N[c+76>>2]=g;N[c+92>>2]=N[b+32>>2];N[c+96>>2]=N[b+36>>2];N[c+100>>2]=N[b+40>>2]}J[c+8>>2]=0;d=J[a+102952>>2];J[c+12>>2]=d;if(d){J[d+8>>2]=c}J[a+102952>>2]=c;J[a+102960>>2]=J[a+102960>>2]+1;J[c+24>>2]=0;J[c+20>>2]=c;a=J[c+52>>2];J[c+16>>2]=a;d=J[c+48>>2];f=J[d+108>>2];J[c+28>>2]=f;k=c+16|0;if(f){J[f+8>>2]=k}J[d+108>>2]=k;J[c+40>>2]=0;J[c+32>>2]=d;J[c+36>>2]=c;d=J[a+108>>2];J[c+44>>2]=d;f=c+32|0;if(d){J[d+8>>2]=f}J[a+108>>2]=f;if(K[b+16|0]){break a}a=J[J[b+12>>2]+112>>2];if(!a){break a}b=J[b+8>>2];while(1){if((b|0)==J[a>>2]){d=J[a+4>>2];J[d+4>>2]=J[d+4>>2]|8}a=J[a+12>>2];if(a){continue}break}}return c|0}function Hd(a,b,c,d,e){var f=0,g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=0,n=Q(0),o=Q(0),p=0,q=Q(0),r=Q(0),s=0,t=0,u=Q(0),v=Q(0),w=Q(0),y=Q(0),z=Q(0),A=0,B=Q(0),C=0,E=Q(0),F=Q(0),G=0,L=0,M=Q(0),O=Q(0),R=Q(0),S=Q(0),T=Q(0),U=0,V=0,W=0,X=0,Z=Q(0),_=Q(0),$=0;f=La-272|0;La=f;J[a+60>>2]=0;g=N[c+12>>2];i=N[e+12>>2];l=Q(g*i);o=N[e+8>>2];h=N[c+8>>2];y=Q(o*h);z=Q(N[e+4>>2]-N[c+4>>2]);j=Q(g*z);n=Q(N[e>>2]-N[c>>2]);q=Q(h*n);U=J[b+20>>2];V=J[b+12>>2];W=J[b+24>>2];X=J[b+16>>2];M=N[b+20>>2];u=N[b+12>>2];r=Q(M-u);O=N[b+24>>2];v=N[b+16>>2];k=Q(O-v);w=Q(Y(Q(Q(r*r)+Q(k*k))));if(!(w>2];h=N[d+16>>2];if(Q(Q(k*Q(Q(S+Q(Q(w*g)-Q(h*F)))-u))-Q(Q(Q(R+Q(Q(F*g)+Q(w*h)))-v)*r))>2];J[f+268>>2]=m;b:{c:{d:{e:{if((m|0)>0){while(1){e=p<<3;c=e+(f+140|0)|0;e=d+e|0;g=N[e+20>>2];h=N[e+24>>2];N[c+4>>2]=R+Q(Q(F*g)+Q(w*h));N[c>>2]=S+Q(Q(w*g)+Q(h*T));g=N[e+84>>2];h=N[e+88>>2];N[c+68>>2]=Q(F*g)+Q(w*h);N[c- -64>>2]=Q(w*g)+Q(h*T);p=p+1|0;if((m|0)!=(p|0)){continue}break}E=Q(N[d+8>>2]+N[b+8>>2]);y=Q(-k);m=J[f+268>>2];if((m|0)<=0){break e}p=m&1;s=m-1|0;f:{if(!s){j=Q(34028234663852886e22);e=0;break f}A=m&-2;j=Q(34028234663852886e22);e=0;c=0;while(1){G=f+140|0;t=e<<3;L=G+(t|8)|0;g=Q(Q(k*Q(N[L>>2]-u))+Q(Q(N[L+4>>2]-v)*z));t=t+G|0;h=Q(Q(k*Q(N[t>>2]-u))+Q(Q(N[t+4>>2]-v)*z));h=h>2]-u))+Q(Q(N[c+4>>2]-v)*z));j=gQ(-34028234663852886e22)){break d}A=-1;j=Q(-34028234663852886e22);h=Q(0);g=Q(0);break c}E=Q(N[d+8>>2]+N[b+8>>2]);y=Q(-k)}j=Q(34028234663852886e22);if(E>2]-u))+Q(r*Q(N[L+4>>2]-v)));t=t+G|0;o=Q(Q(y*Q(N[t>>2]-u))+Q(r*Q(N[t+4>>2]-v)));i=i>o?o:i;i=i>l?l:i;e=e+2|0;c=c+2|0;if((s|0)!=(c|0)){continue}break}}if(p){c=(f+140|0)+(e<<3)|0;l=Q(Q(y*Q(N[c>>2]-u))+Q(r*Q(N[c+4>>2]-v)));i=i>l?l:i}if(i>j){A=1;j=i;h=y;g=r}if(j>E){break a}i=Q(-34028234663852886e22);p=-1;e=0;l=Q(0);o=Q(0);c=0;while(1){s=(f+140|0)+(c<<3)|0;n=Q(-N[s- -64>>2]);q=N[s>>2];Z=N[s+4>>2];B=N[s+68>>2];_=Q(Q(n*Q(q-u))-Q(Q(Z-v)*B));q=Q(Q(n*Q(q-M))-Q(Q(Z-O)*B));q=q>_?_:q;if(q>i){o=Q(-B);l=n;p=c;i=q;e=2}c=c+1|0;if((m|0)!=(c|0)){continue}break}}if(i>E){break a}if(!(Q(Q(Q(j-E)*Q(.9800000190734863))+Q(.0010000000474974513))>2]);i=Q(v-N[b+32>>2]);n=Q(Y(Q(Q(j*j)+Q(i*i))));if(!(n>2]-M);q=Q(N[b+40>>2]-O);B=Q(Y(Q(Q(n*n)+Q(q*q))));if(!(B=Q(0))){break j}if(!(Q(Q(l*Q(-j))-Q(i*o))>Q(.10000000149011612))){break k}break a}if(!(Q(Q(r*q)+Q(n*y))>=Q(0))){break j}if(Q(Q(q*o)+Q(l*n))>Q(.10000000149011612)){break a}}if((e|0)==1){break i}J[a+56>>2]=2;A=0;H[f+132|0]=0;J[f+128>>2]=X;I[f+134>>1]=256;H[f+133|0]=p;J[f+124>>2]=V;I[f+122>>1]=256;H[f+121|0]=p;J[f+116>>2]=W;J[f+112>>2]=U;J[f+56>>2]=p;s=f+140|0;c=s+(p<<3)|0;u=N[c>>2];b=J[c>>2];v=N[c+4>>2];e=J[c+4>>2];J[f+64>>2]=b;J[f+68>>2]=e;H[f+120|0]=1;b=p+1|0;b=(b|0)<(m|0)?b:0;J[f+60>>2]=b;m=s+(b<<3)|0;b=m;M=N[b>>2];b=J[b>>2];O=N[m+4>>2];m=J[m+4>>2];J[f+72>>2]=b;J[f+76>>2]=m;c=c- -64|0;k=N[c>>2];b=J[c>>2];z=N[c+4>>2];c=J[c+4>>2];J[f+104>>2]=b;y=Q(-k);N[f+92>>2]=y;J[f+80>>2]=b;J[f+84>>2]=c;J[f+88>>2]=c;r=Q(-z);N[f+100>>2]=r;break h}l=h;o=g}A=1;J[a+56>>2]=1;p=0;c=0;l:{if((m|0)<2){break l}j=Q(Q(l*N[f+204>>2])+Q(o*N[f+208>>2]));e=1;b=m-1|0;G=b&1;if((m|0)!=2){L=b&-2;s=f+204|0;b=0;while(1){C=s+(e<<3)|0;g=Q(Q(l*N[C>>2])+Q(o*N[C+4>>2]));C=g>2])+Q(o*N[t+4>>2]));g=C?g:j;t=h>2])+Q(o*N[b+68>>2]))>2]=k;N[f+92>>2]=y;N[f+84>>2]=o;J[f+76>>2]=W;J[f+68>>2]=X;I[f+122>>1]=1;H[f+120|0]=0;I[f+134>>1]=1;N[f+100>>2]=r;N[f+88>>2]=z;N[f+80>>2]=l;J[f+72>>2]=U;J[f+64>>2]=V;J[f+56>>2]=0;J[f+60>>2]=1;H[f+121|0]=c;b=f+140|0;e=b+(c<<3)|0;s=J[e+4>>2];J[f+112>>2]=J[e>>2];J[f+116>>2]=s;c=c+1|0;c=(c|0)<(m|0)?c:0;H[f+133|0]=c;b=b+(c<<3)|0;c=J[b+4>>2];J[f+124>>2]=J[b>>2];J[f+128>>2]=c}N[f+108>>2]=Q(r*M)+Q(k*O);g=Q(Q(z*u)+Q(y*v));N[f+96>>2]=g;if((hc(f+32|0,f+112|0,f+88|0,g,p)|0)<2){break a}if((hc(f,f+32|0,f+100|0,N[f+108>>2],J[f+60>>2])|0)<2){break a}m:{if(A){u=N[f+84>>2];c=J[f+84>>2];g=N[f+80>>2];J[a+40>>2]=J[f+80>>2];J[a+44>>2]=c;b=J[f+64>>2];c=J[f+68>>2];v=(x(2,c),D());i=N[f+64>>2];break m}c=(J[f+56>>2]<<3)+d|0;b=J[c+88>>2];J[a+40>>2]=J[c+84>>2];J[a+44>>2]=b;b=J[c+20>>2];c=J[c+24>>2];u=N[f+84>>2];v=N[f+68>>2];g=N[f+80>>2];i=N[f+64>>2]}J[a+48>>2]=b;J[a+52>>2]=c;e=0;h=N[f>>2];k=N[f+4>>2];if(Q(Q(g*Q(h-i))+Q(Q(k-v)*u))<=E){n:{if(A){h=Q(h-S);k=Q(k-R);N[a+4>>2]=Q(T*h)+Q(w*k);N[a>>2]=Q(w*h)+Q(F*k);J[a+16>>2]=J[f+8>>2];break n}b=J[f+4>>2];J[a>>2]=J[f>>2];J[a+4>>2]=b;H[a+18|0]=K[f+11|0];H[a+19|0]=K[f+10|0];H[a+16|0]=K[f+9|0];H[a+17|0]=K[f+8|0]}e=1}b=a;l=g;g=N[f+12>>2];h=N[f+16>>2];if(Q(Q(l*Q(g-i))+Q(Q(h-v)*u))<=E){a=P(e,20)+a|0;o:{if(!A){c=J[f+16>>2];J[a>>2]=J[f+12>>2];J[a+4>>2]=c;H[a+18|0]=K[f+23|0];H[a+19|0]=K[f+22|0];H[a+16|0]=K[f+21|0];H[a+17|0]=K[f+20|0];break o}g=Q(g-S);h=Q(h-R);N[a+4>>2]=Q(T*g)+Q(w*h);N[a>>2]=Q(w*g)+Q(F*h);J[a+16>>2]=J[f+20>>2]}e=e+1|0}J[b+60>>2]=e}La=f+272|0}function Qc(a,b,c,d,e,f){a=a|0;b=+b;c=c|0;d=d|0;e=e|0;f=f|0;var g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,w=0,x=0,y=0,z=0,B=0,C=0;m=La-560|0;La=m;J[m+44>>2]=0;A(+b);g=v(1)|0;v(0)|0;a:{if((g|0)<0){s=1;y=1326;b=-b;A(+b);g=v(1)|0;v(0)|0;break a}if(e&2048){s=1;y=1329;break a}s=e&1;y=s?1332:1327;z=!s}b:{if((g&2146435072)==2146435072){g=s+3|0;kb(a,32,c,g,e&-65537);jb(a,y,s);d=f&32;jb(a,b!=b?d?3187:5561:d?3689:5567,3);kb(a,32,c,g,e^8192);n=(c|0)<(g|0)?g:c;break b}u=m+16|0;c:{d:{e:{b=Vc(b,m+44|0);b=b+b;if(b!=0){g=J[m+44>>2];J[m+44>>2]=g-1;w=f|32;if((w|0)!=97){break e}break c}w=f|32;if((w|0)==97){break c}k=J[m+44>>2];l=(d|0)<0?6:d;break d}k=g-29|0;J[m+44>>2]=k;b=b*268435456;l=(d|0)<0?6:d}q=(m+48|0)+((k|0)>=0?288:0)|0;h=q;while(1){if(b<4294967296&b>=0){d=~~b>>>0}else{d=0}J[h>>2]=d;h=h+4|0;b=(b-+(d>>>0))*1e9;if(b!=0){continue}break}f:{if((k|0)<=0){d=k;g=h;i=q;break f}i=q;d=k;while(1){o=(d|0)>=29?29:d;g=h-4|0;g:{if(i>>>0>g>>>0){break g}d=0;while(1){j=J[g>>2];x=d;d=o&31;if((o&63)>>>0>=32){n=j<>>32-d;d=j<>>0>x>>>0?j+1|0:j,1e9);B=g,C=x-kl(d,Ma,1e9,0)|0,J[B>>2]=C;g=g-4|0;if(i>>>0<=g>>>0){continue}break}if(!d){break g}i=i-4|0;J[i>>2]=d}while(1){g=h;if(i>>>0>>0){h=g-4|0;if(!J[h>>2]){continue}}break}d=J[m+44>>2]-o|0;J[m+44>>2]=d;h=g;if((d|0)>0){continue}break}}if((d|0)<0){t=((l+25>>>0)/9|0)+1|0;p=(w|0)==102;while(1){d=0-d|0;n=(d|0)>=9?9:d;h:{if(g>>>0<=i>>>0){h=J[i>>2];break h}o=1e9>>>n|0;j=-1<>2];J[h>>2]=x+(d>>>n|0);d=P(o,d&j);h=h+4|0;if(h>>>0>>0){continue}break}h=J[i>>2];if(!d){break h}J[g>>2]=d;g=g+4|0}d=n+J[m+44>>2]|0;J[m+44>>2]=d;i=(!h<<2)+i|0;h=p?q:i;g=g-h>>2>(t|0)?h+(t<<2)|0:g;if((d|0)<0){continue}break}}d=0;i:{if(g>>>0<=i>>>0){break i}d=P(q-i>>2,9);h=10;j=J[i>>2];if(j>>>0<10){break i}while(1){d=d+1|0;h=P(h,10);if(j>>>0>=h>>>0){continue}break}}h=(l-((w|0)!=102?d:0)|0)-((w|0)==103&(l|0)!=0)|0;if((h|0)<(P(g-q>>2,9)-9|0)){o=h+9216|0;j=(o|0)/9|0;k=((((k|0)<0?4:292)+m|0)+(j<<2)|0)-4048|0;h=10;n=o-P(j,9)|0;if((n|0)<=7){while(1){h=P(h,10);n=n+1|0;if((n|0)!=8){continue}break}}o=J[k>>2];t=(o>>>0)/(h>>>0)|0;p=o-P(h,t)|0;j=k+4|0;j:{if(!p&(j|0)==(g|0)){break j}k:{if(!(t&1)){b=9007199254740992;if(!(H[k-4|0]&1)|((h|0)!=1e9|i>>>0>=k>>>0)){break k}}b=9007199254740994}r=(g|0)==(j|0)?1:1.5;j=h>>>1|0;r=j>>>0>p>>>0?.5:(j|0)==(p|0)?r:1.5;if(!(K[y|0]!=45|z)){r=-r;b=-b}j=o-p|0;J[k>>2]=j;if(b+r==b){break j}d=h+j|0;J[k>>2]=d;if(d>>>0>=1e9){while(1){J[k>>2]=0;k=k-4|0;if(k>>>0>>0){i=i-4|0;J[i>>2]=0}d=J[k>>2]+1|0;J[k>>2]=d;if(d>>>0>999999999){continue}break}}d=P(q-i>>2,9);h=10;j=J[i>>2];if(j>>>0<10){break j}while(1){d=d+1|0;h=P(h,10);if(j>>>0>=h>>>0){continue}break}}h=k+4|0;g=g>>>0>h>>>0?h:g}while(1){j=g;o=g>>>0<=i>>>0;if(!o){g=j-4|0;if(!J[g>>2]){continue}}break}l:{if((w|0)!=103){k=e&8;break l}h=l?l:1;g=(h|0)>(d|0)&(d|0)>-5;l=(g?d^-1:-1)+h|0;f=(g?-1:-2)+f|0;k=e&8;if(k){break l}g=-9;m:{if(o){break m}k=J[j-4>>2];if(!k){break m}n=10;g=0;if((k>>>0)%10|0){break m}while(1){h=g;g=g+1|0;n=P(n,10);if(!((k>>>0)%(n>>>0)|0)){continue}break}g=h^-1}h=P(j-q>>2,9);if((f&-33)==70){k=0;g=(g+h|0)-9|0;g=(g|0)>0?g:0;l=(g|0)>(l|0)?l:g;break l}k=0;g=((d+h|0)+g|0)-9|0;g=(g|0)>0?g:0;l=(g|0)>(l|0)?l:g}n=-1;o=k|l;if(((o?2147483645:2147483646)|0)<(l|0)){break b}p=(((o|0)!=0)+l|0)+1|0;h=f&-33;n:{if((h|0)==70){if((p^2147483647)<(d|0)){break b}g=(d|0)>0?d:0;break n}g=d>>31;g=Kb((g^d)-g|0,0,u);if((u-g|0)<=1){while(1){g=g-1|0;H[g|0]=48;if((u-g|0)<2){continue}break}}t=g-2|0;H[t|0]=f;H[g-1|0]=(d|0)<0?45:43;g=u-t|0;if((g|0)>(p^2147483647)){break b}}d=g+p|0;if((d|0)>(s^2147483647)){break b}p=d+s|0;kb(a,32,c,p,e);jb(a,y,s);kb(a,48,c,p,e^65536);o:{p:{q:{if((h|0)==70){f=m+16|0;d=f|8;k=f|9;h=i>>>0>q>>>0?q:i;i=h;while(1){g=Kb(J[i>>2],0,k);r:{if((h|0)!=(i|0)){if(m+16>>>0>=g>>>0){break r}while(1){g=g-1|0;H[g|0]=48;if(m+16>>>0>>0){continue}break}break r}if((g|0)!=(k|0)){break r}H[m+24|0]=48;g=d}jb(a,g,k-g|0);i=i+4|0;if(q>>>0>=i>>>0){continue}break}if(o){jb(a,6494,1)}if((l|0)<=0|i>>>0>=j>>>0){break q}while(1){g=Kb(J[i>>2],0,k);if(g>>>0>m+16>>>0){while(1){g=g-1|0;H[g|0]=48;if(m+16>>>0>>0){continue}break}}jb(a,g,(l|0)>=9?9:l);g=l-9|0;i=i+4|0;if(j>>>0<=i>>>0){break p}d=(l|0)>9;l=g;if(d){continue}break}break p}s:{if((l|0)<0){break s}q=i>>>0>>0?j:i+4|0;f=m+16|0;d=f|8;j=f|9;h=i;while(1){g=Kb(J[h>>2],0,j);if((j|0)==(g|0)){H[m+24|0]=48;g=d}t:{if((h|0)!=(i|0)){if(m+16>>>0>=g>>>0){break t}while(1){g=g-1|0;H[g|0]=48;if(m+16>>>0>>0){continue}break}break t}jb(a,g,1);g=g+1|0;if(!(k|l)){break t}jb(a,6494,1)}f=j-g|0;jb(a,g,(f|0)>(l|0)?l:f);l=l-f|0;h=h+4|0;if(q>>>0<=h>>>0){break s}if((l|0)>=0){continue}break}}kb(a,48,l+18|0,18,0);jb(a,t,u-t|0);break o}g=l}kb(a,48,g+9|0,9,0)}kb(a,32,c,p,e^8192);n=(c|0)<(p|0)?p:c;break b}k=(f<<26>>31&9)+y|0;u:{if(d>>>0>11){break u}g=12-d|0;r=16;while(1){r=r*16;g=g-1|0;if(g){continue}break}if(K[k|0]==45){b=-(r+(-b-r));break u}b=b+r-r}g=J[m+44>>2];h=g>>31;g=Kb((g^h)-h|0,0,u);if((u|0)==(g|0)){H[m+15|0]=48;g=m+15|0}q=s|2;i=f&32;h=J[m+44>>2];l=g-2|0;H[l|0]=f+15;H[g-1|0]=(h|0)<0?45:43;g=e&8;h=m+16|0;while(1){f=h;if(R(b)<2147483648){j=~~b}else{j=-2147483648}H[h|0]=i|K[j+17920|0];b=(b-+(j|0))*16;h=f+1|0;if(!(!((d|0)>0|g)&b==0|(h-(m+16|0)|0)!=1)){H[f+1|0]=46;h=f+2|0}if(b!=0){continue}break}n=-1;g=u-l|0;f=g+q|0;if((2147483645-f|0)<(d|0)){break b}j=f;f=m+16|0;i=h-f|0;d=d?(i-2|0)<(d|0)?d+2|0:i:i;h=j+d|0;kb(a,32,c,h,e);jb(a,k,q);kb(a,48,c,h,e^65536);jb(a,f,i);kb(a,48,d-i|0,0,0);jb(a,l,g);kb(a,32,c,h,e^8192);n=(c|0)<(h|0)?h:c}La=m+560|0;return n|0}function Uc(a,b,c,d,e){var 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;h=La-80|0;La=h;J[h+76>>2]=b;w=h+55|0;r=h+56|0;a:{b:{c:{d:{e:while(1){i=b;if((o^2147483647)<(f|0)){break d}o=f+o|0;f:{g:{h:{f=i;g=K[f|0];if(g){while(1){i:{b=g&255;j:{if(!b){b=f;break j}if((b|0)!=37){break i}g=f;while(1){if(K[g+1|0]!=37){b=g;break j}f=f+1|0;k=K[g+2|0];b=g+2|0;g=b;if((k|0)==37){continue}break}}f=f-i|0;v=o^2147483647;if((f|0)>(v|0)){break d}if(a){jb(a,i,f)}if(f){continue e}J[h+76>>2]=b;f=b+1|0;p=-1;if(!(K[b+2|0]!=36|H[b+1|0]-48>>>0>=10)){p=H[b+1|0]-48|0;s=1;f=b+3|0}J[h+76>>2]=f;m=0;g=H[f|0];b=g-32|0;k:{if(b>>>0>31){l=f;break k}l=f;b=1<>2]=l;m=b|m;g=H[f+1|0];b=g-32|0;if(b>>>0>=32){break k}f=l;b=1<>>0>=10)){J[((H[l+1|0]<<2)+e|0)-192>>2]=10;g=l+3|0;s=1;b=J[((H[l+1|0]<<3)+d|0)-384>>2];break m}if(s){break h}g=l+1|0;if(!a){J[h+76>>2]=g;s=0;q=0;break l}b=J[c>>2];J[c>>2]=b+4;s=0;b=J[b>>2]}J[h+76>>2]=g;q=b;if((b|0)>=0){break l}q=0-q|0;m=m|8192;break l}q=Tc(h+76|0);if((q|0)<0){break d}g=J[h+76>>2]}f=0;j=-1;n:{if(K[g|0]!=46){b=g;u=0;break n}if(K[g+1|0]==42){o:{if(!(K[g+3|0]!=36|H[g+2|0]-48>>>0>=10)){J[((H[g+2|0]<<2)+e|0)-192>>2]=10;b=g+4|0;j=J[((H[g+2|0]<<3)+d|0)-384>>2];break o}if(s){break h}b=g+2|0;j=0;if(!a){break o}g=J[c>>2];J[c>>2]=g+4;j=J[g>>2]}J[h+76>>2]=b;u=(j^-1)>>>31|0;break n}J[h+76>>2]=g+1;j=Tc(h+76|0);b=J[h+76>>2];u=1}while(1){n=f;l=28;k=b;f=H[b|0];if(f-123>>>0<4294967238){break c}b=k+1|0;f=K[(f+P(n,58)|0)+17391|0];if(f-1>>>0<8){continue}break}J[h+76>>2]=b;p:{q:{if((f|0)!=27){if(!f){break c}if((p|0)>=0){J[(p<<2)+e>>2]=f;g=(p<<3)+d|0;f=J[g+4>>2];J[h+64>>2]=J[g>>2];J[h+68>>2]=f;break q}if(!a){break f}Sc(h- -64|0,f,c);break p}if((p|0)>=0){break c}}f=0;if(!a){continue e}}g=m&-65537;m=m&8192?g:m;p=0;t=1316;l=r;r:{s:{t:{u:{v:{w:{x:{y:{z:{A:{B:{C:{D:{E:{F:{G:{f=H[k|0];f=n?(f&15)==3?f&-33:f:f;switch(f-88|0){case 11:break r;case 9:case 13:case 14:case 15:break s;case 27:break x;case 12:case 17:break A;case 23:break B;case 0:case 32:break C;case 24:break D;case 22:break E;case 29:break F;case 1:case 2:case 3:case 4:case 5:case 6:case 7:case 8:case 10:case 16:case 18:case 19:case 20:case 21:case 25:case 26:case 28:case 30:case 31:break g;default:break G}}H:{switch(f-65|0){case 0:case 4:case 5:case 6:break s;case 2:break v;case 1:case 3:break g;default:break H}}if((f|0)==83){break w}break g}g=J[h+64>>2];k=J[h+68>>2];t=1316;break z}f=0;I:{switch(n&255){case 0:J[J[h+64>>2]>>2]=o;continue e;case 1:J[J[h+64>>2]>>2]=o;continue e;case 2:i=J[h+64>>2];J[i>>2]=o;J[i+4>>2]=o>>31;continue e;case 3:I[J[h+64>>2]>>1]=o;continue e;case 4:H[J[h+64>>2]]=o;continue e;case 6:J[J[h+64>>2]>>2]=o;continue e;case 7:break I;default:continue e}}i=J[h+64>>2];J[i>>2]=o;J[i+4>>2]=o>>31;continue e}j=j>>>0<=8?8:j;m=m|8;f=120}i=r;g=J[h+64>>2];k=J[h+68>>2];if(g|k){x=f&32;while(1){i=i-1|0;H[i|0]=x|K[(g&15)+17920|0];y=!k&g>>>0>15|(k|0)!=0;n=k;k=k>>>4|0;g=(n&15)<<28|g>>>4;if(y){continue}break}}if(!(J[h+64>>2]|J[h+68>>2])|!(m&8)){break y}t=(f>>>4|0)+1316|0;p=2;break y}f=r;i=J[h+68>>2];k=i;g=J[h+64>>2];if(i|g){while(1){f=f-1|0;H[f|0]=g&7|48;n=!k&g>>>0>7|(k|0)!=0;i=k;k=i>>>3|0;g=(i&7)<<29|g>>>3;if(n){continue}break}}i=f;if(!(m&8)){break y}f=r-i|0;j=(f|0)<(j|0)?j:f+1|0;break y}g=J[h+64>>2];f=J[h+68>>2];k=f;if((f|0)<0){i=0-(k+((g|0)!=0)|0)|0;k=i;g=0-g|0;J[h+64>>2]=g;J[h+68>>2]=i;p=1;t=1316;break z}if(m&2048){p=1;t=1317;break z}p=m&1;t=p?1318:1316}i=Kb(g,k,r)}if((j|0)<0?u:0){break d}m=u?m&-65537:m;f=J[h+64>>2];g=J[h+68>>2];if(!(j|(f|g)!=0)){i=r;j=0;break g}f=!(f|g)+(r-i|0)|0;j=(f|0)<(j|0)?j:f;break g}l=j>>>0>=2147483647?2147483647:j;n=l;m=(l|0)!=0;f=J[h+64>>2];i=f?f:6496;f=i;J:{K:{L:{M:{if(!(f&3)|!l){break M}while(1){if(!K[f|0]){break L}n=n-1|0;m=(n|0)!=0;f=f+1|0;if(!(f&3)){break M}if(n){continue}break}}if(!m){break K}if(!(!K[f|0]|n>>>0<4)){while(1){k=J[f>>2];if((k^-1)&k-16843009&-2139062144){break L}f=f+4|0;n=n-4|0;if(n>>>0>3){continue}break}}if(!n){break K}}while(1){if(!K[f|0]){break J}f=f+1|0;n=n-1|0;if(n){continue}break}}f=0}f=f?f-i|0:l;l=f+i|0;if((j|0)>=0){m=g;j=f;break g}m=g;j=f;if(K[l|0]){break d}break g}if(j){g=J[h+64>>2];break u}f=0;kb(a,32,q,0,m);break t}J[h+12>>2]=0;J[h+8>>2]=J[h+64>>2];g=h+8|0;J[h+64>>2]=g;j=-1}f=0;N:{while(1){i=J[g>>2];if(!i){break N}k=Oc(h+4|0,i);i=(k|0)<0;if(!(i|k>>>0>j-f>>>0)){g=g+4|0;f=f+k|0;if(j>>>0>f>>>0){continue}break N}break}if(i){break b}}l=61;if((f|0)<0){break c}kb(a,32,q,f,m);if(!f){f=0;break t}l=0;g=J[h+64>>2];while(1){i=J[g>>2];if(!i){break t}i=Oc(h+4|0,i);l=i+l|0;if(l>>>0>f>>>0){break t}jb(a,h+4|0,i);g=g+4|0;if(f>>>0>l>>>0){continue}break}}kb(a,32,q,f,m^8192);f=(f|0)<(q|0)?q:f;continue e}if((j|0)<0?u:0){break d}l=61;f=Qc(a,O[h+64>>3],q,j,m,f);if((f|0)>=0){continue e}break c}H[h+55|0]=J[h+64>>2];j=1;i=w;m=g;break g}g=K[f+1|0];f=f+1|0;continue}}if(a){break a}if(!s){break f}f=1;while(1){a=J[(f<<2)+e>>2];if(a){Sc((f<<3)+d|0,a,c);o=1;f=f+1|0;if((f|0)!=10){continue}break a}break}o=1;if(f>>>0>=10){break a}while(1){if(J[(f<<2)+e>>2]){break h}f=f+1|0;if((f|0)!=10){continue}break}break a}l=28;break c}k=l-i|0;g=(j|0)>(k|0)?j:k;if((g|0)>(p^2147483647)){break d}l=61;j=g+p|0;f=(j|0)<(q|0)?q:j;if((v|0)<(f|0)){break c}kb(a,32,f,j,m);jb(a,t,p);kb(a,48,f,j,m^65536);kb(a,48,g,k,0);jb(a,i,k);kb(a,32,f,j,m^8192);continue}break}o=0;break a}l=61}J[6204]=l}o=-1}La=h+80|0;return o}function Df(a){a=a|0;var b=0,c=0,d=0,e=0,f=0,g=Q(0),h=Q(0),i=Q(0),j=0,k=Q(0),l=Q(0),m=0,n=0,o=0,p=0,q=Q(0),r=0,s=Q(0);b=La+-64|0;La=b;d=J[a+102980>>2];a:{if(!d){break a}p=J[d+4>>2];b:{if(!(p&1)){break b}j=J[a+102948>>2];if(!j){break b}while(1){d=J[j+100>>2];if(d){f=j+12|0;while(1){c:{d:{e:{e=J[j>>2];if((e|0)==2){if(N[j+116>>2]==Q(0)){J[b+8>>2]=0;J[b+12>>2]=1065353216;J[b>>2]=1065353216;J[b+4>>2]=0;break c}c=L[j+4>>1];if(c&32){break e}break d}c=L[j+4>>1];if(!(c&32)){break d}f:{switch(e|0){case 0:J[b+8>>2]=1056964608;J[b+12>>2]=1065353216;J[b>>2]=1056964608;J[b+4>>2]=1063675494;break c;case 1:break f;default:break e}}J[b+8>>2]=1063675494;J[b+12>>2]=1065353216;J[b>>2]=1056964608;J[b+4>>2]=1056964608;break c}if(!(c&2)){J[b+8>>2]=1058642330;J[b+12>>2]=1065353216;J[b>>2]=1058642330;J[b+4>>2]=1058642330;break c}J[b+8>>2]=1060320051;J[b+12>>2]=1065353216;J[b>>2]=1063675494;J[b+4>>2]=1060320051;break c}J[b+8>>2]=1050253722;J[b+12>>2]=1065353216;J[b>>2]=1056964608;J[b+4>>2]=1056964608}c=La-80|0;La=c;g:{h:{i:{j:{k:{e=J[d+12>>2];switch(J[e+4>>2]){case 0:break h;case 2:break i;case 3:break j;case 1:break k;default:break g}}k=N[f>>2];h=N[f+8>>2];i=N[e+12>>2];g=N[f+12>>2];l=N[e+16>>2];q=N[f+4>>2];N[c+4>>2]=Q(Q(h*i)+Q(g*l))+q;N[c>>2]=k+Q(Q(g*i)-Q(l*h));i=N[e+20>>2];l=N[e+24>>2];N[c+76>>2]=q+Q(Q(h*i)+Q(g*l));N[c+72>>2]=k+Q(Q(g*i)-Q(l*h));n=J[a+102980>>2];Na[J[J[n>>2]+24>>2]](n,c,c+72|0,b);if(K[e+44|0]){break g}e=J[a+102980>>2];Na[J[J[e>>2]+32>>2]](e,c,Q(4),b);e=J[a+102980>>2];Na[J[J[e>>2]+32>>2]](e,c+72|0,Q(4),b);break g}n=J[e+16>>2];h=N[f>>2];g=N[f+8>>2];o=J[e+12>>2];k=N[o>>2];i=N[f+12>>2];l=N[o+4>>2];N[c+4>>2]=Q(Q(g*k)+Q(i*l))+N[f+4>>2];N[c>>2]=h+Q(Q(i*k)-Q(l*g));if((n|0)<2){break g}e=1;while(1){h=N[f>>2];g=N[f+8>>2];m=o+(e<<3)|0;k=N[m>>2];i=N[f+12>>2];l=N[m+4>>2];N[c+76>>2]=Q(Q(g*k)+Q(i*l))+N[f+4>>2];N[c+72>>2]=h+Q(Q(i*k)-Q(l*g));m=J[a+102980>>2];Na[J[J[m>>2]+24>>2]](m,c,c+72|0,b);m=J[c+76>>2];J[c>>2]=J[c+72>>2];J[c+4>>2]=m;e=e+1|0;if((n|0)!=(e|0)){continue}break}break g}o=J[e+148>>2];if((o|0)>0){h=N[f+12>>2];g=N[f+4>>2];k=N[f>>2];i=N[f+8>>2];l=Q(-i);n=0;while(1){m=n<<3;r=m+c|0;m=e+m|0;q=N[m+20>>2];s=N[m+24>>2];N[r+4>>2]=Q(Q(i*q)+Q(h*s))+g;N[r>>2]=k+Q(Q(h*q)+Q(s*l));n=n+1|0;if((o|0)!=(n|0)){continue}break}}e=J[a+102980>>2];Na[J[J[e>>2]+12>>2]](e,c,o,b);break g}k=N[f>>2];h=N[f+8>>2];i=N[e+12>>2];g=N[f+12>>2];l=N[e+16>>2];N[c+4>>2]=Q(Q(h*i)+Q(g*l))+N[f+4>>2];N[c>>2]=k+Q(Q(g*i)-Q(l*h));k=N[e+8>>2];N[c+76>>2]=h+Q(g*Q(0));N[c+72>>2]=g-Q(h*Q(0));e=J[a+102980>>2];Na[J[J[e>>2]+20>>2]](e,c,k,c+72|0,b)}La=c+80|0;d=J[d+4>>2];if(d){continue}break}}j=J[j+96>>2];if(j){continue}break}}l:{if(!(p&2)){break l}d=J[a+102952>>2];if(!d){break l}while(1){Na[J[J[d>>2]+24>>2]](d,J[a+102980>>2]);d=J[d+12>>2];if(d){continue}break}}m:{if(!(p&8)){break m}J[b+8>>2]=1063675494;J[b+12>>2]=1065353216;J[b>>2]=1050253722;J[b+4>>2]=1063675494;d=J[a+102928>>2];if(!d){break m}while(1){f=J[d+52>>2];j=J[d+60>>2];c=J[J[d+48>>2]+24>>2]+P(J[d+56>>2],28)|0;h=N[c+4>>2];g=N[c+12>>2];N[b+40>>2]=Q(N[c>>2]+N[c+8>>2])*Q(.5);N[b+44>>2]=Q(h+g)*Q(.5);c=J[f+24>>2]+P(j,28)|0;h=N[c+4>>2];g=N[c+12>>2];N[b+56>>2]=Q(N[c>>2]+N[c+8>>2])*Q(.5);N[b+60>>2]=Q(h+g)*Q(.5);c=J[a+102980>>2];Na[J[J[c>>2]+24>>2]](c,b+40|0,b+56|0,b);d=J[d+12>>2];if(d){continue}break}}n:{if(!(p&4)){break n}J[b+48>>2]=1063675494;J[b+52>>2]=1065353216;J[b+40>>2]=1063675494;J[b+44>>2]=1050253722;c=J[a+102948>>2];if(!c){break n}while(1){o:{if(!(K[c+4|0]&32)){break o}d=J[c+100>>2];if(!d){break o}while(1){if(J[d+28>>2]>0){j=0;while(1){f=J[a+102872>>2]+P(J[(J[d+24>>2]+P(j,28)|0)+24>>2],40)|0;h=N[f+4>>2];g=N[f+8>>2];k=N[f>>2];i=N[f+12>>2];N[b+28>>2]=i;N[b+24>>2]=k;N[b+20>>2]=i;N[b+16>>2]=g;N[b+12>>2]=h;N[b+8>>2]=g;N[b+4>>2]=h;N[b>>2]=k;f=J[a+102980>>2];Na[J[J[f>>2]+8>>2]](f,b,4,b+40|0);j=j+1|0;if((j|0)>2]){continue}break}}d=J[d+4>>2];if(d){continue}break}}c=J[c+96>>2];if(c){continue}break}}if(!(p&16)){break a}d=J[a+102948>>2];if(!d){break a}while(1){c=J[d+24>>2];J[b+8>>2]=J[d+20>>2];J[b+12>>2]=c;c=J[d+16>>2];J[b>>2]=J[d+12>>2];J[b+4>>2]=c;c=J[d+48>>2];J[b>>2]=J[d+44>>2];J[b+4>>2]=c;c=J[a+102980>>2];Na[J[J[c>>2]+28>>2]](c,b);d=J[d+96>>2];if(d){continue}break}}La=b- -64|0}function fc(a){var b=0,c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0,k=0,l=0;J[a+52>>2]=0;b=J[a+40>>2];a:{if((b|0)<=0){break a}while(1){f=J[J[a+32>>2]+(i<<2)>>2];J[a+56>>2]=f;if((f|0)!=-1){h=J[a+4>>2]+P(f,40)|0;d=La-1040|0;La=d;J[d+1036>>2]=256;f=d+8|0;J[d+4>>2]=f;J[d+8>>2]=J[a>>2];b=f;c=1;while(1){b:{c=c-1|0;J[d+1032>>2]=c;g=J[(c<<2)+b>>2];c:{if((g|0)==-1){break c}e=J[a+4>>2]+P(g,40)|0;if(Q(N[h>>2]-N[e+8>>2])>Q(0)|Q(N[h+4>>2]-N[e+12>>2])>Q(0)|(Q(N[e>>2]-N[h+8>>2])>Q(0)|Q(N[e+4>>2]-N[h+12>>2])>Q(0))){break c}if(J[e+24>>2]==-1){c=J[a+56>>2];if(!((g|0)==(c|0)|(K[(J[a+4>>2]+P(g,40)|0)+36|0]?(c|0)<(g|0):0))){b=J[a+52>>2];if((b|0)==J[a+48>>2]){c=(b>>1)+b|0;J[a+48>>2]=c;b=J[a+44>>2];c=fb(c<<3);J[a+44>>2]=c;rb(c,b,J[a+52>>2]<<3);ab(b);c=J[a+56>>2];b=J[a+52>>2]}e=J[a+44>>2]+(b<<3)|0;J[e+4>>2]=(c|0)<(g|0)?g:c;J[e>>2]=(c|0)>(g|0)?g:c;J[a+52>>2]=b+1}b=J[d+4>>2];c=J[d+1032>>2];if((c|0)>0){continue}break b}d:{if(J[d+1036>>2]!=(c|0)){break d}J[d+1036>>2]=c<<1;c=fb(c<<3);J[d+4>>2]=c;rb(c,b,J[d+1032>>2]<<2);if((b|0)==(f|0)){break d}ab(b)}b=J[d+4>>2];J[b+(J[d+1032>>2]<<2)>>2]=J[e+24>>2];c=J[d+1032>>2]+1|0;J[d+1032>>2]=c;e:{if((c|0)!=J[d+1036>>2]){break e}J[d+1036>>2]=c<<1;c=fb(c<<3);J[d+4>>2]=c;rb(c,b,J[d+1032>>2]<<2);if((b|0)==(f|0)){break e}ab(b)}b=J[d+4>>2];J[b+(J[d+1032>>2]<<2)>>2]=J[e+28>>2];c=J[d+1032>>2]+1|0;J[d+1032>>2]=c}if((c|0)>0){continue}}break}if((b|0)!=(f|0)){ab(b)}La=d+1040|0;b=J[a+40>>2]}i=i+1|0;if((i|0)<(b|0)){continue}break}if(J[a+52>>2]>0){i=0;while(1){d=J[a+4>>2];f=J[a+44>>2]+(i<<3)|0;c=J[(d+P(J[f>>2],40)|0)+16>>2];b=J[c+16>>2];j=J[b+8>>2];d=J[(d+P(J[f+4>>2],40)|0)+16>>2];f=J[d+16>>2];e=J[f+8>>2];f:{if((j|0)==(e|0)){break f}d=J[d+20>>2];g=J[c+20>>2];c=J[e+112>>2];if(c){while(1){g:{if((j|0)!=J[c>>2]){break g}e=J[c+4>>2];h=J[e+60>>2];k=J[e+56>>2];l=J[e+52>>2];e=J[e+48>>2];if(!((e|0)!=(b|0)|(f|0)!=(l|0)|(g|0)!=(k|0))){if((d|0)==(h|0)){break f}}if((f|0)!=(e|0)|(b|0)!=(l|0)|(d|0)!=(k|0)){break g}if((g|0)==(h|0)){break f}}c=J[c+12>>2];if(c){continue}break}}c=J[a+68>>2];if(c){if(!(Na[J[J[c>>2]+8>>2]](c,b,f)|0)){break f}}c=J[a+76>>2];if(!K[24768]){J[6168]=782;H[24584]=1;J[6145]=783;J[6144]=784;J[6150]=782;J[6156]=785;J[6180]=786;J[6147]=785;H[24680]=1;J[6169]=787;H[24704]=1;J[6175]=788;J[6174]=789;H[24608]=0;J[6151]=787;H[24632]=1;J[6157]=790;H[24728]=1;J[6181]=791;H[24692]=0;J[6172]=792;J[6171]=793;H[24656]=1;J[6163]=792;J[6162]=793;H[24596]=0;J[6148]=790;H[24752]=1;J[6187]=794;J[6186]=795;H[24620]=0;J[6154]=791;J[6153]=786;J[6177]=795;J[6178]=794;H[24716]=0;H[24768]=1}h=(P(J[J[b+12>>2]+4>>2],48)+24576|0)+P(J[J[f+12>>2]+4>>2],12)|0;e=J[h>>2];h:{if(e){if(K[h+8|0]){b=Na[e|0](b,g,f,d,c)|0;break h}b=Na[e|0](f,d,b,g,c)|0}else{b=0}}if(!b){break f}e=J[b+52>>2];f=J[e+8>>2];h=J[b+48>>2];d=J[h+8>>2];J[b+8>>2]=0;c=J[a+60>>2];J[b+12>>2]=c;if(c){J[c+8>>2]=b}J[a+60>>2]=b;J[b+24>>2]=0;J[b+16>>2]=f;J[b+20>>2]=b;c=J[d+112>>2];J[b+28>>2]=c;g=b+16|0;if(c){J[c+8>>2]=g}J[d+112>>2]=g;J[b+40>>2]=0;J[b+32>>2]=d;J[b+36>>2]=b;c=J[f+112>>2];J[b+44>>2]=c;b=b+32|0;if(c){J[c+8>>2]=b}J[f+112>>2]=b;i:{if(K[h+38|0]|K[e+38|0]){break i}if(J[d>>2]){J[d+144>>2]=0;I[d+4>>1]=L[d+4>>1]|2}if(!J[f>>2]){break i}J[f+144>>2]=0;I[f+4>>1]=L[f+4>>1]|2}J[a+64>>2]=J[a+64>>2]+1}i=i+1|0;if((i|0)>2]){continue}break}b=J[a+40>>2]}if((b|0)<=0){break a}c=b&1;f=J[a+4>>2];d=J[a+32>>2];i=0;if((b|0)!=1){g=b&-2;b=0;while(1){e=i<<2;h=J[e+d>>2];if((h|0)!=-1){H[(f+P(h,40)|0)+36|0]=0}e=J[d+(e|4)>>2];if((e|0)!=-1){H[(f+P(e,40)|0)+36|0]=0}i=i+2|0;b=b+2|0;if((g|0)!=(b|0)){continue}break}}if(!c){break a}b=J[d+(i<<2)>>2];if((b|0)==-1){break a}H[(f+P(b,40)|0)+36|0]=0}J[a+40>>2]=0}function Zc(a,b){var c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,w=0,y=0,z=0,A=0;o=La-16|0;La=o;s=(C(a),v(2));e=s&2147483647;a:{if(e>>>0<=1305022426){j=+a;d=j*.6366197723675814+6755399441055744+-6755399441055744;r=j+d*-1.5707963109016418+d*-1.5893254773528196e-8;O[b>>3]=r;c=r<-.7853981852531433;if(R(d)<2147483648){e=~~d}else{e=-2147483648}if(c){d=d+-1;O[b>>3]=j+d*-1.5707963109016418+d*-1.5893254773528196e-8;e=e-1|0;break a}if(!(r>.7853981852531433)){break a}d=d+1;O[b>>3]=j+d*-1.5707963109016418+d*-1.5893254773528196e-8;e=e+1|0;break a}if(e>>>0>=2139095040){O[b>>3]=Q(a-a);e=0;break a}c=e;e=(e>>>23|0)-150|0;O[o+8>>3]=(x(2,c-(e<<23)|0),D());t=o+8|0;g=La-560|0;La=g;c=(e-3|0)/24|0;p=(c|0)>0?c:0;i=e+P(p,-24)|0;l=J[3652];if((l|0)>=0){e=l+1|0;c=p;while(1){O[(g+320|0)+(f<<3)>>3]=(c|0)<0?0:+J[(c<<2)+14624>>2];c=c+1|0;f=f+1|0;if((e|0)!=(f|0)){continue}break}}k=i-24|0;e=0;f=(l|0)>0?l:0;while(1){c=0;d=0;while(1){d=O[(c<<3)+t>>3]*O[(g+320|0)+(e-c<<3)>>3]+d;c=c+1|0;if((c|0)!=1){continue}break}O[(e<<3)+g>>3]=d;c=(e|0)==(f|0);e=e+1|0;if(!c){continue}break}z=47-i|0;u=48-i|0;A=i-25|0;e=l;b:{while(1){d=O[(e<<3)+g>>3];c=0;f=e;n=(e|0)<=0;if(!n){while(1){m=(g+480|0)+(c<<2)|0;j=d*5.960464477539063e-8;c:{if(R(j)<2147483648){h=~~j;break c}h=-2147483648}j=+(h|0);d=j*-16777216+d;d:{if(R(d)<2147483648){h=~~d;break d}h=-2147483648}J[m>>2]=h;f=f-1|0;d=O[(f<<3)+g>>3]+j;c=c+1|0;if((e|0)!=(c|0)){continue}break}}d=cc(d,k);d=d+V(d*.125)*-8;e:{if(R(d)<2147483648){m=~~d;break e}m=-2147483648}d=d-+(m|0);f:{g:{h:{w=(k|0)<=0;i:{if(!w){f=(e<<2)+g|0;h=J[f+476>>2];c=h>>u;q=f;f=h-(c<>2]=f;m=c+m|0;h=f>>z;break i}if(k){break h}h=J[((e<<2)+g|0)+476>>2]>>23}if((h|0)<=0){break f}break g}h=2;if(d>=.5){break g}h=0;break f}c=0;f=0;if(!n){while(1){q=(g+480|0)+(c<<2)|0;n=J[q>>2];y=16777215;j:{k:{if(f){break k}y=16777216;if(n){break k}f=0;break j}J[q>>2]=y-n;f=1}c=c+1|0;if((e|0)!=(c|0)){continue}break}}l:{if(w){break l}c=8388607;m:{switch(A|0){case 1:c=4194303;break;case 0:break m;default:break l}}n=(e<<2)+g|0;J[n+476>>2]=J[n+476>>2]&c}m=m+1|0;if((h|0)!=2){break f}d=1-d;h=2;if(!f){break f}d=d-cc(1,k)}if(d==0){f=0;n:{c=e;if((l|0)>=(e|0)){break n}while(1){c=c-1|0;f=J[(g+480|0)+(c<<2)>>2]|f;if((c|0)>(l|0)){continue}break}if(!f){break n}i=k;while(1){i=i-24|0;e=e-1|0;if(!J[(g+480|0)+(e<<2)>>2]){continue}break}break b}c=1;while(1){f=c;c=c+1|0;if(!J[(g+480|0)+(l-f<<2)>>2]){continue}break}f=e+f|0;while(1){e=e+1|0;O[(g+320|0)+(e<<3)>>3]=J[(e+p<<2)+14624>>2];c=0;d=0;while(1){d=O[(c<<3)+t>>3]*O[(g+320|0)+(e-c<<3)>>3]+d;c=c+1|0;if((c|0)!=1){continue}break}O[(e<<3)+g>>3]=d;if((e|0)<(f|0)){continue}break}e=f;continue}break}d=cc(d,24-i|0);o:{if(d>=16777216){k=(g+480|0)+(e<<2)|0;j=d*5.960464477539063e-8;p:{if(R(j)<2147483648){c=~~j;break p}c=-2147483648}d=+(c|0)*-16777216+d;q:{if(R(d)<2147483648){f=~~d;break q}f=-2147483648}J[k>>2]=f;e=e+1|0;break o}if(R(d)<2147483648){c=~~d}else{c=-2147483648}i=k}J[(g+480|0)+(e<<2)>>2]=c}d=cc(1,i);r:{if((e|0)<0){break r}c=e;while(1){f=c;O[(c<<3)+g>>3]=d*+J[(g+480|0)+(c<<2)>>2];c=c-1|0;d=d*5.960464477539063e-8;if(f){continue}break}if((e|0)<0){break r}f=e;while(1){d=0;c=0;i=e-f|0;k=(i|0)>(l|0)?l:i;if((k|0)>=0){while(1){d=O[(c<<3)+17392>>3]*O[(c+f<<3)+g>>3]+d;p=(c|0)!=(k|0);c=c+1|0;if(p){continue}break}}O[(g+160|0)+(i<<3)>>3]=d;c=(f|0)>0;f=f-1|0;if(c){continue}break}}d=0;if((e|0)>=0){while(1){c=e;e=e-1|0;d=d+O[(g+160|0)+(c<<3)>>3];if(c){continue}break}}O[o>>3]=h?-d:d;La=g+560|0;e=m&7;d=O[o>>3];if((s|0)<0){O[b>>3]=-d;e=0-e|0;break a}O[b>>3]=d}La=o+16|0;return e}function ad(a,b,c,d){var e=0,f=0,g=Q(0),h=Q(0),i=Q(0),j=0,k=Q(0),l=0,m=Q(0),n=Q(0),o=0,p=Q(0),q=Q(0),r=Q(0),s=0,t=0,u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=0,C=0,D=0;g=N[a+48>>2];h=N[a+68>>2];n=Q(Q(d*Q(N[a+72>>2]-h))+h);h=_a(n);m=N[a+44>>2];n=Za(n);q=N[a+56>>2];x=Q(Q(q+Q(Q(N[a- -64>>2]-q)*d))-Q(Q(n*m)+Q(g*h)));q=N[a+52>>2];u=Q(Q(q+Q(Q(N[a+60>>2]-q)*d))-Q(Q(h*m)-Q(g*n)));q=N[a+12>>2];g=N[a+32>>2];m=Q(Q(d*Q(N[a+36>>2]-g))+g);g=_a(m);r=N[a+8>>2];m=Za(m);i=N[a+20>>2];y=Q(Q(i+Q(Q(N[a+28>>2]-i)*d))-Q(Q(m*r)+Q(q*g)));i=N[a+16>>2];v=Q(Q(i+Q(Q(N[a+24>>2]-i)*d))-Q(Q(g*r)-Q(q*m)));w=Q(-n);q=Q(-m);a:{switch(J[a+80>>2]){case 0:r=N[a+92>>2];i=N[a+96>>2];e=J[a>>2];o=J[e+16>>2];j=J[e+20>>2];b:{if((j|0)<2){break b}k=Q(Q(g*r)+Q(m*i));p=Q(Q(q*r)+Q(g*i));d=Q(Q(N[o>>2]*k)+Q(p*N[o+4>>2]));e=1;f=j-1|0;C=f&1;c:{if((j|0)==2){f=0;break c}B=f&-2;f=0;j=0;while(1){s=o+(e<<3)|0;z=Q(Q(N[s>>2]*k)+Q(p*N[s+4>>2]));s=z>d;D=e+1|0;t=o+(D<<3)|0;A=Q(Q(N[t>>2]*k)+Q(p*N[t+4>>2]));d=s?z:d;t=A>d;d=t?A:d;f=t?D:s?e:f;e=e+2|0;j=j+2|0;if((B|0)!=(j|0)){continue}break}}if(!C){break b}j=e;e=o+(e<<3)|0;f=Q(Q(N[e>>2]*k)+Q(p*N[e+4>>2]))>d?j:f}J[b>>2]=f;a=J[a+4>>2];e=J[a+16>>2];f=J[a+20>>2];d:{if((f|0)<2){break d}k=Q(Q(h*Q(-r))-Q(n*i));p=Q(Q(n*r)-Q(h*i));d=Q(Q(N[e>>2]*k)+Q(p*N[e+4>>2]));a=1;l=f-1|0;t=l&1;e:{if((f|0)==2){l=0;break e}C=l&-2;l=0;f=0;while(1){j=e+(a<<3)|0;z=Q(Q(N[j>>2]*k)+Q(p*N[j+4>>2]));j=z>d;B=a+1|0;s=e+(B<<3)|0;A=Q(Q(N[s>>2]*k)+Q(p*N[s+4>>2]));d=j?z:d;s=A>d;d=s?A:d;l=s?B:j?a:l;a=a+2|0;f=f+2|0;if((C|0)!=(f|0)){continue}break}}if(!t){break d}j=a;a=e+(a<<3)|0;l=Q(Q(N[a>>2]*k)+Q(p*N[a+4>>2]))>d?j:l}J[c>>2]=l;k=u;a=e+(l<<3)|0;d=N[a>>2];u=N[a+4>>2];p=Q(k+Q(Q(h*d)+Q(u*w)));k=v;a=o+(J[b>>2]<<3)|0;w=N[a>>2];v=N[a+4>>2];return Q(Q(Q(p-Q(k+Q(Q(g*w)+Q(v*q))))*r)+Q(i*Q(Q(x+Q(Q(n*d)+Q(h*u)))-Q(y+Q(Q(m*w)+Q(g*v))))));case 1:d=N[a+88>>2];i=N[a+96>>2];k=N[a+84>>2];p=N[a+92>>2];J[b>>2]=-1;r=Q(Q(m*p)+Q(g*i));i=Q(Q(g*p)+Q(i*q));y=Q(y+Q(Q(m*k)+Q(g*d)));q=Q(v+Q(Q(g*k)+Q(d*q)));a=J[a+4>>2];b=J[a+16>>2];f=J[a+20>>2];f:{if((f|0)<2){break f}g=Q(Q(h*Q(-i))-Q(n*r));m=Q(Q(n*i)-Q(h*r));d=Q(Q(N[b>>2]*g)+Q(m*N[b+4>>2]));a=1;e=f-1|0;j=e&1;g:{if((f|0)==2){e=0;break g}s=e&-2;e=0;f=0;while(1){l=b+(a<<3)|0;v=Q(Q(N[l>>2]*g)+Q(m*N[l+4>>2]));l=v>d;t=a+1|0;o=b+(t<<3)|0;k=Q(Q(N[o>>2]*g)+Q(m*N[o+4>>2]));d=l?v:d;o=k>d;d=o?k:d;e=o?t:l?a:e;a=a+2|0;f=f+2|0;if((s|0)!=(f|0)){continue}break}}if(!j){break f}j=a;a=b+(a<<3)|0;e=Q(Q(N[a>>2]*g)+Q(m*N[a+4>>2]))>d?j:e}J[c>>2]=e;a=b+(e<<3)|0;d=N[a>>2];g=N[a+4>>2];return Q(Q(Q(Q(u+Q(Q(h*d)+Q(g*w)))-q)*i)+Q(r*Q(Q(x+Q(Q(n*d)+Q(h*g)))-y)));case 2:d=N[a+88>>2];i=N[a+96>>2];k=N[a+84>>2];p=N[a+92>>2];J[c>>2]=-1;r=Q(Q(n*p)+Q(h*i));i=Q(Q(h*p)+Q(i*w));x=Q(x+Q(Q(n*k)+Q(h*d)));w=Q(u+Q(Q(h*k)+Q(d*w)));a=J[a>>2];c=J[a+16>>2];f=J[a+20>>2];h:{if((f|0)<2){break h}h=Q(Q(g*Q(-i))-Q(m*r));n=Q(Q(m*i)-Q(g*r));d=Q(Q(N[c>>2]*h)+Q(n*N[c+4>>2]));a=1;e=f-1|0;j=e&1;i:{if((f|0)==2){e=0;break i}s=e&-2;e=0;f=0;while(1){l=c+(a<<3)|0;u=Q(Q(N[l>>2]*h)+Q(n*N[l+4>>2]));l=u>d;t=a+1|0;o=c+(t<<3)|0;k=Q(Q(N[o>>2]*h)+Q(n*N[o+4>>2]));d=l?u:d;o=k>d;d=o?k:d;e=o?t:l?a:e;a=a+2|0;f=f+2|0;if((s|0)!=(f|0)){continue}break}}if(!j){break h}j=a;a=c+(a<<3)|0;e=Q(Q(N[a>>2]*h)+Q(n*N[a+4>>2]))>d?j:e}J[b>>2]=e;a=c+(e<<3)|0;d=N[a>>2];h=N[a+4>>2];return Q(Q(Q(Q(v+Q(Q(g*d)+Q(h*q)))-w)*i)+Q(r*Q(Q(y+Q(Q(m*d)+Q(g*h)))-x)));default:break a}}J[b>>2]=-1;J[c>>2]=-1;return Q(0)}function fd(a){var b=Q(0),c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=0,k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=0,r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=Q(0),C=0,D=Q(0),E=0,F=0,G=Q(0),H=0,I=0,L=0,M=0,O=Q(0),R=Q(0);if(J[a+48>>2]>0){q=J[a+28>>2];I=K[23656];while(1){c=J[a+40>>2]+P(F,156)|0;G=N[c+132>>2];A=N[c+124>>2];g=N[c+128>>2];B=N[c+120>>2];l=N[c+72>>2];i=N[c+76>>2];H=P(J[c+116>>2],12);j=H+q|0;o=N[j+8>>2];r=N[j+4>>2];s=N[j>>2];L=P(J[c+112>>2],12);C=L+q|0;b=N[C+8>>2];t=N[C+4>>2];u=N[C>>2];E=J[c+148>>2];M=(E|0)<=0;a:{b:{if(!M){v=N[c+136>>2];d=Q(-l);k=N[c+144>>2];h=Q(-g);q=0;while(1){j=c+P(q,36)|0;e=Q(v*N[j+16>>2]);f=Q(-e);w=N[j+20>>2];n=N[j+12>>2];m=N[j+4>>2];x=N[j+8>>2];y=N[j>>2];z=Q(w-Q(N[j+28>>2]*Q(Q(Q(Q(Q(Q(s-Q(o*n))-u)+Q(b*m))*i)+Q(Q(Q(Q(r+Q(o*x))-t)-Q(b*y))*d))-k)));e=e>z?z:e;e=e>2]=e;f=Q(e-w);e=Q(f*d);f=Q(i*f);o=Q(Q(G*Q(Q(x*e)-Q(n*f)))+o);b=Q(Q(h*Q(Q(y*e)-Q(f*m)))+b);r=Q(r+Q(A*e));s=Q(s+Q(A*f));t=Q(t-Q(B*e));u=Q(u-Q(B*f));q=q+1|0;if((E|0)!=(q|0)){continue}break}if(I?(E|0)!=1:0){break b}if(M){break a}q=0;while(1){j=c+P(q,36)|0;e=N[j+16>>2];f=N[j+12>>2];g=N[j+4>>2];d=N[j+8>>2];v=N[j>>2];k=Q(e-Q(N[j+24>>2]*Q(Q(Q(Q(Q(Q(s-Q(o*f))-u)+Q(b*g))*l)+Q(i*Q(Q(Q(r+Q(o*d))-t)-Q(b*v))))-N[j+32>>2])));k=k>Q(0)?k:Q(0);N[j+16>>2]=k;m=d;d=Q(k-e);e=Q(i*d);p=f;f=Q(l*d);o=Q(Q(G*Q(Q(m*e)-Q(p*f)))+o);b=Q(Q(h*Q(Q(v*e)-Q(f*g)))+b);r=Q(r+Q(A*e));s=Q(s+Q(A*f));t=Q(t-Q(B*e));u=Q(u-Q(B*f));q=q+1|0;if((E|0)!=(q|0)){continue}break}break a}if(!I){break a}}c:{d:{v=N[c+12>>2];k=N[c+4>>2];w=N[c+8>>2];n=N[c>>2];d=N[c+16>>2];h=N[c+52>>2];O=N[c+104>>2];m=Q(Q(Q(Q(Q(Q(Q(s-Q(o*v))-u)+Q(b*k))*l)+Q(i*Q(Q(Q(r+Q(o*w))-t)-Q(b*n))))-N[c+32>>2])-Q(Q(N[c+96>>2]*d)+Q(h*O)));x=N[c+48>>2];y=N[c+40>>2];z=N[c+44>>2];D=N[c+36>>2];f=N[c+100>>2];p=Q(Q(Q(Q(Q(Q(Q(s-Q(o*x))-u)+Q(b*y))*l)+Q(i*Q(Q(Q(r+Q(o*z))-t)-Q(b*D))))-N[c+68>>2])-Q(Q(f*d)+Q(h*N[c+108>>2])));e=Q(Q(N[c+80>>2]*m)+Q(N[c+88>>2]*p));if(!(e<=Q(0))){break d}R=Q(Q(N[c+84>>2]*m)+Q(p*N[c+92>>2]));if(!(R<=Q(0))){break d}m=b;p=g;e=Q(-e);b=Q(e-d);g=Q(i*b);d=Q(l*b);n=Q(Q(n*g)-Q(d*k));f=Q(-R);b=Q(f-h);h=Q(i*b);k=Q(l*b);b=Q(m-Q(p*Q(n+Q(Q(D*h)-Q(k*y)))));i=Q(g+h);l=Q(d+k);g=Q(Q(w*g)-Q(d*v));d=Q(Q(z*h)-Q(k*x));break c}e=Q(m*Q(-N[c+24>>2]));if(!(!(e>=Q(0))|!(Q(Q(f*e)+p)>=Q(0)))){f=Q(0);m=b;p=g;b=Q(Q(0)-h);g=Q(i*b);h=Q(l*b);b=Q(e-d);d=Q(i*b);i=Q(n*d);n=Q(l*b);b=Q(m-Q(p*Q(Q(Q(D*g)-Q(h*y))+Q(i-Q(n*k)))));i=Q(g+d);l=Q(h+n);g=Q(Q(z*g)-Q(h*x));d=Q(Q(w*d)-Q(n*v));break c}f=Q(p*Q(-N[c+60>>2]));if(!(!(f>=Q(0))|!(Q(Q(O*f)+m)>=Q(0)))){e=Q(0);m=b;p=g;b=Q(Q(0)-d);g=Q(i*b);d=Q(l*b);n=Q(Q(n*g)-Q(d*k));b=Q(f-h);h=Q(i*b);k=Q(l*b);b=Q(m-Q(p*Q(n+Q(Q(D*h)-Q(k*y)))));i=Q(g+h);l=Q(d+k);g=Q(Q(w*g)-Q(d*v));d=Q(Q(z*h)-Q(k*x));break c}if(!(m>=Q(0))|!(p>=Q(0))){break a}e=Q(0);m=b;p=g;b=Q(Q(0)-d);f=Q(i*b);g=Q(l*b);b=Q(Q(0)-h);d=Q(i*b);h=Q(l*b);b=Q(m-Q(p*Q(Q(Q(n*f)-Q(g*k))+Q(Q(D*d)-Q(h*y)))));i=Q(f+d);l=Q(g+h);g=Q(Q(w*f)-Q(g*v));f=Q(0);d=Q(Q(z*d)-Q(h*x))}N[c+52>>2]=f;N[c+16>>2]=e;s=Q(s+Q(A*l));r=Q(r+Q(A*i));u=Q(u-Q(B*l));t=Q(t-Q(B*i));o=Q(Q(G*Q(g+d))+o)}N[C+4>>2]=t;N[C>>2]=u;c=J[a+28>>2];N[(c+L|0)+8>>2]=b;c=c+H|0;N[c+4>>2]=r;N[c>>2]=s;q=J[a+28>>2];N[(H+q|0)+8>>2]=o;F=F+1|0;if((F|0)>2]){continue}break}}}function yh(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=0,f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=0,l=0,m=0,n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=0,s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=Q(0),C=0,D=Q(0),E=Q(0),F=Q(0),G=Q(0),H=Q(0),I=Q(0),L=Q(0),M=Q(0),O=Q(0),R=Q(0),S=Q(0),T=Q(0),U=Q(0),V=Q(0),W=Q(0),X=Q(0),Y=Q(0),Z=0,_=0,$=Q(0),aa=Q(0);l=J[a+48>>2];C=J[l+8>>2];J[a+160>>2]=C;m=J[a+52>>2];r=J[m+8>>2];J[a+164>>2]=r;k=J[a+84>>2];Z=J[k+8>>2];J[a+168>>2]=Z;c=J[a+88>>2];_=J[c+8>>2];J[a+172>>2]=_;D=N[l+32>>2];e=J[l+32>>2];i=N[l+28>>2];J[a+176>>2]=J[l+28>>2];J[a+180>>2]=e;e=J[m+32>>2];J[a+184>>2]=J[m+28>>2];J[a+188>>2]=e;w=N[k+32>>2];e=J[k+32>>2];n=N[k+28>>2];J[a+192>>2]=J[k+28>>2];J[a+196>>2]=e;$=N[c+32>>2];e=J[c+32>>2];aa=N[c+28>>2];J[a+200>>2]=J[c+28>>2];J[a+204>>2]=e;E=N[l+120>>2];N[a+208>>2]=E;F=N[m+120>>2];N[a+212>>2]=F;G=N[k+120>>2];N[a+216>>2]=G;H=N[c+120>>2];N[a+220>>2]=H;x=N[l+128>>2];N[a+224>>2]=x;y=N[m+128>>2];N[a+228>>2]=y;z=N[k+128>>2];N[a+232>>2]=z;A=N[c+128>>2];N[a+236>>2]=A;l=J[a+76>>2];c=J[b+28>>2];k=P(_,12);e=c+k|0;I=N[e+8>>2];L=N[e+4>>2];M=N[e>>2];m=P(Z,12);e=m+c|0;O=N[e+8>>2];R=N[e+4>>2];S=N[e>>2];r=P(r,12);e=r+c|0;T=N[e+8>>2];U=N[e+4>>2];V=N[e>>2];e=P(C,12);c=e+c|0;W=N[c+8>>2];X=N[c+4>>2];Y=N[c>>2];c=J[b+24>>2];d=N[(c+r|0)+8>>2];f=N[(c+k|0)+8>>2];h=_a(f);g=Za(f);s=_a(d);t=Za(d);a:{if((l|0)==1){o=Q(1);j=Q(1);d=Q(x+z);break a}p=N[a+96>>2];d=N[(c+e|0)+8>>2];o=_a(d);B=N[a+92>>2];j=Za(d);q=N[a+128>>2];i=Q(B-i);p=Q(p-D);f=N[(c+m|0)+8>>2];d=Za(f);u=N[a+124>>2];f=_a(f);v=Q(Q(d*u)+Q(q*f));q=Q(Q(f*u)-Q(q*d));o=Q(Q(Q(Q(o*i)-Q(j*p))*v)-Q(q*Q(Q(j*i)+Q(o*p))));j=Q(N[a+108>>2]-n);i=Q(N[a+112>>2]-w);j=Q(Q(Q(Q(f*j)-Q(d*i))*v)-Q(q*Q(Q(d*j)+Q(f*i))));d=Q(Q(Q(x*o)*o)+Q(Q(Q(z*j)*j)+Q(E+G)))}N[a+264>>2]=j;N[a+256>>2]=o;N[a+240>>2]=q;N[a+244>>2]=v;i=Q(0);n=Q(d+Q(0));b:{if(J[a+80>>2]==1){J[a+248>>2]=0;d=N[a+152>>2];g=Q(Q(Q(d*d)*Q(y+A))+n);h=d;f=Q(0);break b}d=N[a+132>>2];B=N[a+136>>2];p=Q(Q(h*d)-Q(B*g));f=N[a+152>>2];i=Q(p*f);N[a+248>>2]=i;D=n;u=Q(N[a+100>>2]-N[a+184>>2]);w=Q(N[a+104>>2]-N[a+188>>2]);n=Q(Q(g*d)+Q(h*B));d=Q(f*Q(Q(Q(Q(s*u)-Q(w*t))*n)-Q(p*Q(Q(t*u)+Q(s*w)))));s=Q(N[a+116>>2]-aa);t=Q(N[a+120>>2]-$);h=Q(f*Q(Q(Q(Q(h*s)-Q(t*g))*n)-Q(p*Q(Q(g*s)+Q(h*t)))));g=Q(D+Q(Q(Q(y*d)*d)+Q(Q(Q(f*f)*Q(F+H))+Q(h*Q(A*h)))));f=Q(n*f)}N[a+268>>2]=h;N[a+260>>2]=d;N[a+252>>2]=f;N[a+272>>2]=g>Q(0)?Q(Q(1)/g):Q(0);c:{if(K[b+20|0]){g=N[a+156>>2];I=Q(I-Q(Q(g*A)*h));h=Q(H*g);L=Q(L-Q(h*f));M=Q(M-Q(h*i));O=Q(O-Q(Q(g*z)*j));h=Q(G*g);R=Q(R-Q(h*v));S=Q(S-Q(q*h));T=Q(Q(Q(y*g)*d)+T);d=Q(F*g);U=Q(U+Q(d*f));V=Q(V+Q(d*i));W=Q(Q(Q(x*g)*o)+W);d=Q(E*g);X=Q(X+Q(d*v));Y=Q(Y+Q(q*d));break c}J[a+156>>2]=0}c=J[b+28>>2]+P(C,12)|0;N[c+4>>2]=X;N[c>>2]=Y;c=J[b+28>>2];N[(c+P(J[a+160>>2],12)|0)+8>>2]=W;c=c+P(J[a+164>>2],12)|0;N[c+4>>2]=U;N[c>>2]=V;c=J[b+28>>2];N[(c+P(J[a+164>>2],12)|0)+8>>2]=T;c=c+P(J[a+168>>2],12)|0;N[c+4>>2]=R;N[c>>2]=S;c=J[b+28>>2];N[(c+P(J[a+168>>2],12)|0)+8>>2]=O;c=c+P(J[a+172>>2],12)|0;N[c+4>>2]=L;N[c>>2]=M;N[(J[b+28>>2]+P(J[a+172>>2],12)|0)+8>>2]=I}function ab(a){a=a|0;var b=0,c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0;a:{if(!a){break a}d=a-8|0;b=J[a-4>>2];a=b&-8;f=d+a|0;b:{if(b&1){break b}if(!(b&3)){break a}b=J[d>>2];d=d-b|0;if(d>>>0>>0<=255){e=b>>>3|0;b=J[d+12>>2];c=J[d+8>>2];if((b|0)==(c|0)){i=26060,j=J[6515]&ml(e),J[i>>2]=j;break b}J[c+12>>2]=b;J[b+8>>2]=c;break b}g=J[d+24>>2];b=J[d+12>>2];if((d|0)!=(b|0)){c=J[d+8>>2];J[c+12>>2]=b;J[b+8>>2]=c;break c}e=d+20|0;c=J[e>>2];if(!c){c=J[d+16>>2];if(!c){break d}e=d+16|0}while(1){h=e;b=c;e=b+20|0;c=J[e>>2];if(c){continue}e=b+16|0;c=J[b+16>>2];if(c){continue}break}J[h>>2]=0;break c}b=J[f+4>>2];if((b&3)!=3){break b}J[6517]=a;J[f+4>>2]=b&-2;J[d+4>>2]=a|1;J[f>>2]=a;return}b=0}if(!g){break b}c=J[d+28>>2];e=(c<<2)+26364|0;e:{if(J[e>>2]==(d|0)){J[e>>2]=b;if(b){break e}i=26064,j=J[6516]&ml(c),J[i>>2]=j;break b}J[g+(J[g+16>>2]==(d|0)?16:20)>>2]=b;if(!b){break b}}J[b+24>>2]=g;c=J[d+16>>2];if(c){J[b+16>>2]=c;J[c+24>>2]=b}c=J[d+20>>2];if(!c){break b}J[b+20>>2]=c;J[c+24>>2]=b}if(d>>>0>=f>>>0){break a}b=J[f+4>>2];if(!(b&1)){break a}f:{g:{h:{i:{if(!(b&2)){if(J[6521]==(f|0)){J[6521]=d;a=J[6518]+a|0;J[6518]=a;J[d+4>>2]=a|1;if(J[6520]!=(d|0)){break a}J[6517]=0;J[6520]=0;return}if(J[6520]==(f|0)){J[6520]=d;a=J[6517]+a|0;J[6517]=a;J[d+4>>2]=a|1;J[a+d>>2]=a;return}a=(b&-8)+a|0;if(b>>>0<=255){e=b>>>3|0;b=J[f+12>>2];c=J[f+8>>2];if((b|0)==(c|0)){i=26060,j=J[6515]&ml(e),J[i>>2]=j;break g}J[c+12>>2]=b;J[b+8>>2]=c;break g}g=J[f+24>>2];b=J[f+12>>2];if((f|0)!=(b|0)){c=J[f+8>>2];J[c+12>>2]=b;J[b+8>>2]=c;break h}e=f+20|0;c=J[e>>2];if(!c){c=J[f+16>>2];if(!c){break i}e=f+16|0}while(1){h=e;b=c;e=b+20|0;c=J[e>>2];if(c){continue}e=b+16|0;c=J[b+16>>2];if(c){continue}break}J[h>>2]=0;break h}J[f+4>>2]=b&-2;J[d+4>>2]=a|1;J[a+d>>2]=a;break f}b=0}if(!g){break g}c=J[f+28>>2];e=(c<<2)+26364|0;j:{if(J[e>>2]==(f|0)){J[e>>2]=b;if(b){break j}i=26064,j=J[6516]&ml(c),J[i>>2]=j;break g}J[g+(J[g+16>>2]==(f|0)?16:20)>>2]=b;if(!b){break g}}J[b+24>>2]=g;c=J[f+16>>2];if(c){J[b+16>>2]=c;J[c+24>>2]=b}c=J[f+20>>2];if(!c){break g}J[b+20>>2]=c;J[c+24>>2]=b}J[d+4>>2]=a|1;J[a+d>>2]=a;if(J[6520]!=(d|0)){break f}J[6517]=a;return}if(a>>>0<=255){b=(a&-8)+26100|0;c=J[6515];a=1<<(a>>>3);k:{if(!(c&a)){J[6515]=a|c;a=b;break k}a=J[b+8>>2]}J[b+8>>2]=d;J[a+12>>2]=d;J[d+12>>2]=b;J[d+8>>2]=a;return}c=31;if(a>>>0<=16777215){b=S(a>>>8|0);c=((a>>>38-b&1)-(b<<1)|0)+62|0}J[d+28>>2]=c;J[d+16>>2]=0;J[d+20>>2]=0;b=(c<<2)+26364|0;l:{m:{e=J[6516];h=1<>2]=d;J[d+24>>2]=b;break n}c=a<<((c|0)!=31?25-(c>>>1|0)|0:0);b=J[b>>2];while(1){e=b;if((J[b+4>>2]&-8)==(a|0)){break m}b=c>>>29|0;c=c<<1;h=e+(b&4)|0;b=J[h+16>>2];if(b){continue}break}J[h+16>>2]=d;J[d+24>>2]=e}J[d+12>>2]=d;J[d+8>>2]=d;break l}a=J[e+8>>2];J[a+12>>2]=d;J[e+8>>2]=d;J[d+24>>2]=0;J[d+12>>2]=e;J[d+8>>2]=a}a=J[6523]-1|0;J[6523]=a?a:-1}}function Uf(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=0,i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=0,n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=0,t=Q(0),u=Q(0),v=Q(0),w=0,x=Q(0),y=Q(0),z=Q(0),A=0,B=Q(0),C=Q(0),D=Q(0),E=Q(0),F=Q(0),G=Q(0),H=Q(0),I=Q(0),L=Q(0),M=Q(0),O=Q(0);c=J[a+48>>2];A=J[c+8>>2];J[a+152>>2]=A;m=J[a+52>>2];s=J[m+8>>2];J[a+156>>2]=s;H=N[c+32>>2];h=J[c+32>>2];d=N[c+28>>2];J[a+160>>2]=J[c+28>>2];J[a+164>>2]=h;I=N[m+32>>2];w=J[m+32>>2];o=N[m+28>>2];h=J[m+28>>2];J[a+168>>2]=h;J[a+172>>2]=w;x=N[c+120>>2];N[a+176>>2]=x;y=N[m+120>>2];N[a+180>>2]=y;t=N[c+128>>2];N[a+184>>2]=t;u=N[m+128>>2];N[a+188>>2]=u;k=N[a+96>>2];m=J[b+24>>2];c=P(A,12);h=m+c|0;g=N[h+8>>2];e=_a(g);j=N[a+92>>2];g=Za(g);w=J[b+28>>2];c=c+w|0;B=N[c>>2];C=N[c+4>>2];D=N[c+8>>2];s=P(s,12);c=s+w|0;E=N[c>>2];F=N[c+4>>2];G=N[c+8>>2];l=N[h>>2];c=m+s|0;q=N[c>>2];p=N[h+4>>2];L=N[c+4>>2];M=N[a+72>>2];n=N[c+8>>2];f=N[a+80>>2];O=N[a+68>>2];i=N[a+76>>2];r=Q(Q(g*j)+Q(e*k));N[a+204>>2]=r;z=Q(Q(e*j)-Q(k*g));N[a+200>>2]=z;j=N[a+84>>2];v=N[a+88>>2];k=Q(Q(g*j)+Q(e*v));N[a+196>>2]=k;j=Q(Q(e*j)-Q(v*g));N[a+192>>2]=j;v=_a(n);o=Q(i-o);i=Q(f-I);n=Za(n);f=Q(Q(v*o)-Q(i*n));i=Q(Q(n*o)+Q(v*i));n=Q(Q(f*r)-Q(z*i));N[a+220>>2]=n;o=Q(Q(f*k)-Q(j*i));N[a+212>>2]=o;f=Q(Q(q+f)-l);d=Q(O-d);l=Q(M-H);q=Q(Q(e*d)-Q(g*l));f=Q(f-q);g=Q(Q(g*d)+Q(e*l));e=Q(Q(Q(L+i)-p)-g);i=Q(q+f);d=Q(g+e);g=Q(Q(i*r)-Q(z*d));N[a+216>>2]=g;i=Q(Q(i*k)-Q(j*d));N[a+208>>2]=i;l=Q(x+y);d=Q(Q(Q(u*n)*n)+Q(Q(Q(t*g)*g)+l));N[a+224>>2]=d>Q(0)?Q(Q(1)/d):d;a:{b:{d=Q(Q(Q(u*o)*o)+Q(Q(Q(t*i)*i)+l));if(!(d>Q(0))){J[a+232>>2]=0;J[a+236>>2]=0;J[a+240>>2]=0;J[a+244>>2]=0;break b}J[a+244>>2]=0;J[a+236>>2]=0;J[a+240>>2]=0;N[a+232>>2]=Q(1)/d;l=N[a+144>>2];if(!(l>Q(0))){break b}q=N[b>>2];p=Q(q*Q(Q(q*l)+N[a+148>>2]));p=p>Q(0)?Q(Q(1)/p):p;N[a+244>>2]=p;N[a+240>>2]=Q(l*Q(q*Q(Q(f*j)+Q(e*k))))*p;d=Q(d+p);N[a+236>>2]=d>Q(0)?Q(Q(1)/d):d;break a}J[a+108>>2]=0}c:{if(K[a+140|0]){N[a+120>>2]=Q(j*f)+Q(e*k);break c}J[a+112>>2]=0;J[a+116>>2]=0}d:{if(K[a+141|0]){e=Q(t+u);N[a+228>>2]=e;if(!(e>Q(0))){break d}N[a+228>>2]=Q(1)/e;break d}J[a+104>>2]=0;J[a+228>>2]=0}e:{if(K[b+20|0]){f=N[b+8>>2];e=Q(f*N[a+100>>2]);N[a+100>>2]=e;d=Q(f*N[a+108>>2]);N[a+108>>2]=d;f=Q(f*N[a+104>>2]);N[a+104>>2]=f;l=k;k=Q(Q(d+N[a+112>>2])-N[a+116>>2]);r=Q(Q(r*e)+Q(l*k));F=Q(F+Q(y*r));j=Q(Q(z*e)+Q(j*k));E=Q(E+Q(y*j));C=Q(C-Q(x*r));B=Q(B-Q(x*j));G=Q(Q(u*Q(f+Q(Q(e*n)+Q(o*k))))+G);D=Q(D-Q(t*Q(f+Q(Q(e*g)+Q(i*k)))));break e}J[a+100>>2]=0;J[a+104>>2]=0;J[a+116>>2]=0;J[a+108>>2]=0;J[a+112>>2]=0}h=J[b+28>>2]+P(A,12)|0;N[h+4>>2]=C;N[h>>2]=B;h=J[b+28>>2];N[(h+P(J[a+152>>2],12)|0)+8>>2]=D;h=h+P(J[a+156>>2],12)|0;N[h+4>>2]=F;N[h>>2]=E;N[(J[b+28>>2]+P(J[a+156>>2],12)|0)+8>>2]=G}function Mg(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=Q(0),f=0,g=0,h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=0,m=Q(0),n=0,o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=0,t=0,u=0,v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=0,C=0,D=Q(0),E=Q(0),F=Q(0),G=Q(0),K=0,L=0,M=Q(0),O=Q(0),R=0,S=0;g=J[J[a+48>>2]+12>>2];a=J[J[a+52>>2]+12>>2];f=La-96|0;La=f;l=b;J[b+60>>2]=0;e=N[a+8>>2];k=N[g+8>>2];J[f+92>>2]=0;r=Q(k+e);e=td(f+92|0,g,c,a,d);a:{if(r>2]=0;k=td(f+88|0,a,d,g,c);if(k>r){break a}B=k>Q(e+Q(.0005000000237487257));b:{if(B){n=2;b=c;c=g;g=f+88|0;break b}n=1;b=d;d=c;c=a;a=g;g=f+92|0}v=N[b>>2];w=N[b+4>>2];F=N[d>>2];G=N[d+4>>2];k=N[b+12>>2];p=N[b+8>>2];h=N[d+12>>2];m=N[d+8>>2];s=J[g>>2];J[l+56>>2]=n;K=s<<3;x=Q(-p);d=0;n=J[c+148>>2];c:{if((n|0)<=0){break c}b=a+K|0;e=N[b+84>>2];i=N[b+88>>2];j=Q(Q(m*e)+Q(h*i));e=Q(Q(h*e)-Q(i*m));i=Q(Q(k*j)-Q(p*e));j=Q(Q(k*e)+Q(p*j));C=c+84|0;R=n&1;d:{if((n|0)==1){e=Q(34028234663852886e22);g=0;break d}S=n&-2;e=Q(34028234663852886e22);g=0;b=0;while(1){t=(g<<3)+C|0;o=Q(Q(j*N[t>>2])+Q(i*N[t+4>>2]));t=o>2])+Q(i*N[u+4>>2]));e=t?o:e;u=q>2])+Q(i*N[b+4>>2]))>2];i=N[c+4>>2];I[f+74>>1]=1;H[f+73|0]=d;H[f+72|0]=s;N[f+68>>2]=w+Q(Q(p*e)+Q(k*i));N[f+64>>2]=v+Q(Q(k*e)+Q(i*x));c=d+1|0;c=(c|0)<(n|0)?c:0;b=b+(c<<3)|0;e=N[b>>2];i=N[b+4>>2];H[f+84|0]=s;N[f+80>>2]=w+Q(Q(p*e)+Q(k*i));I[f+86>>1]=1;H[f+85|0]=c;N[f+76>>2]=v+Q(Q(k*e)+Q(i*x));b=s+1|0;b=(b|0)>2]?b:0;a=a+20|0;c=(b<<3)+a|0;q=N[c>>2];a=a+K|0;y=N[a>>2];e=Q(q-y);z=N[c+4>>2];A=N[a+4>>2];i=Q(z-A);j=Q(Y(Q(Q(e*e)+Q(i*i))));if(!(j>2]=j;D=Q(-m);o=Q(Q(h*e)+Q(i*D));N[f+56>>2]=o;N[f+4>>2]=-j;E=Q(-o);N[f>>2]=E;M=Q(F+Q(Q(h*y)+Q(A*D)));O=Q(G+Q(Q(m*y)+Q(h*A)));if((hc(f+32|0,f- -64|0,f,Q(r-Q(Q(o*M)+Q(O*j))),s)|0)<2){break a}if((hc(f,f+32|0,f+56|0,Q(r+Q(Q(o*Q(F+Q(Q(h*q)+Q(z*D))))+Q(Q(G+Q(Q(m*q)+Q(h*z)))*j))),b)|0)<2){break a}N[l+48>>2]=Q(y+q)*Q(.5);N[l+40>>2]=i;N[l+52>>2]=Q(A+z)*Q(.5);N[l+44>>2]=-e;g=0;e=N[f>>2];h=N[f+4>>2];m=Q(Q(j*M)-Q(O*o));e:{if(!(Q(Q(Q(j*e)+Q(h*E))-m)<=r)){break e}e=Q(e-v);h=Q(h-w);N[l+4>>2]=Q(x*e)+Q(k*h);N[l>>2]=Q(k*e)+Q(p*h);a=J[f+8>>2];J[l+16>>2]=a;g=1;if(!B){break e}H[l+17|0]=a;H[l+19|0]=a>>>16;H[l+18|0]=a>>>24;H[l+16|0]=a>>>8}e=N[f+12>>2];h=N[f+16>>2];if(Q(Q(Q(j*e)+Q(h*E))-m)<=r){a=P(g,20)+l|0;e=Q(e-v);h=Q(h-w);N[a+4>>2]=Q(x*e)+Q(k*h);N[a>>2]=Q(k*e)+Q(p*h);b=J[f+20>>2];J[a+16>>2]=b;if(B){H[a+17|0]=b;H[a+19|0]=b>>>16;H[a+18|0]=b>>>24;H[a+16|0]=b>>>8}g=g+1|0}J[l+60>>2]=g}La=f+96|0}function Re(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,f=0,g=0,h=0;a:{g=a+16|0;e=J[g>>2];if(!e){break a}c=g;d=e;while(1){f=M[d+16>>2]>>0;c=f?c:d;d=J[(f?d+4|0:d)>>2];if(d){continue}break}if((c|0)==(g|0)|M[c+16>>2]>b>>>0){break a}b=J[c+4>>2];b:{if(!b){b=c;while(1){d=J[b+8>>2];g=J[d>>2]!=(b|0);b=d;if(g){continue}break}break b}while(1){d=b;b=J[b>>2];if(b){continue}break}}if(J[a+12>>2]==(c|0)){J[a+12>>2]=d}J[a+20>>2]=J[a+20>>2]-1;d=e;g=c;c:{d:{b=c;c=J[b>>2];if(c){a=J[g+4>>2];if(!a){break d}while(1){b=a;a=J[a>>2];if(a){continue}break}}c=J[b+4>>2];if(c){break d}c=0;e=1;break c}J[c+8>>2]=J[b+8>>2];e=0}f=J[b+8>>2];a=J[f>>2];e:{if((b|0)==(a|0)){J[f>>2]=c;if((b|0)==(d|0)){a=0;d=c;break e}a=J[f+4>>2];break e}J[f+4>>2]=c}h=!K[b+12|0];if((b|0)!=(g|0)){f=J[g+8>>2];J[b+8>>2]=f;J[f+(((g|0)!=J[J[g+8>>2]>>2])<<2)>>2]=b;f=J[g>>2];J[b>>2]=f;J[f+8>>2]=b;f=J[g+4>>2];J[b+4>>2]=f;if(f){J[f+8>>2]=b}H[b+12|0]=K[g+12|0];d=(d|0)==(g|0)?b:d}f:{if(h|!d){break f}if(e){while(1){b=K[a+12|0];g:{e=J[a+8>>2];if(J[e>>2]!=(a|0)){if(!b){H[a+12|0]=1;H[e+12|0]=0;c=J[e+4>>2];b=J[c>>2];J[e+4>>2]=b;if(b){J[b+8>>2]=e}J[c+8>>2]=J[e+8>>2];b=J[e+8>>2];J[(((e|0)!=J[b>>2])<<2)+b>>2]=c;J[c>>2]=e;J[e+8>>2]=c;b=a;a=J[a>>2];d=(a|0)==(d|0)?b:d;a=J[a+4>>2]}h:{i:{b=J[a>>2];j:{if(!(K[b+12|0]?0:b)){c=J[a+4>>2];if(K[c+12|0]?0:c){break j}H[a+12|0]=0;a=J[a+8>>2];k:{if((d|0)==(a|0)){a=d;break k}if(K[a+12|0]){break g}}H[a+12|0]=1;break f}c=J[a+4>>2];if(!c){break i}}if(K[c+12|0]){break i}b=a;break h}H[b+12|0]=1;H[a+12|0]=0;c=J[b+4>>2];J[a>>2]=c;if(c){J[c+8>>2]=a}J[b+8>>2]=J[a+8>>2];c=J[a+8>>2];J[((J[c>>2]!=(a|0))<<2)+c>>2]=b;J[b+4>>2]=a;J[a+8>>2]=b;c=a}d=J[b+8>>2];H[b+12|0]=K[d+12|0];H[d+12|0]=1;H[c+12|0]=1;b=J[d+4>>2];a=J[b>>2];J[d+4>>2]=a;if(a){J[a+8>>2]=d}J[b+8>>2]=J[d+8>>2];a=J[d+8>>2];J[(((d|0)!=J[a>>2])<<2)+a>>2]=b;J[b>>2]=d;J[d+8>>2]=b;break f}if(!b){H[a+12|0]=1;H[e+12|0]=0;b=J[a+4>>2];J[e>>2]=b;if(b){J[b+8>>2]=e}J[a+8>>2]=J[e+8>>2];b=J[e+8>>2];J[(((e|0)!=J[b>>2])<<2)+b>>2]=a;J[a+4>>2]=e;J[e+8>>2]=a;d=(d|0)==(e|0)?a:d;a=J[e>>2]}c=J[a>>2];l:{if(!(!c|K[c+12|0])){b=a;break l}b=J[a+4>>2];if(!(K[b+12|0]?0:b)){H[a+12|0]=0;a=J[a+8>>2];if((a|0)!=(d|0)?K[a+12|0]:0){break g}H[a+12|0]=1;break f}if(c){if(!K[c+12|0]){b=a;break l}b=J[a+4>>2]}H[b+12|0]=1;H[a+12|0]=0;c=J[b>>2];J[a+4>>2]=c;if(c){J[c+8>>2]=a}J[b+8>>2]=J[a+8>>2];c=J[a+8>>2];J[((J[c>>2]!=(a|0))<<2)+c>>2]=b;J[b>>2]=a;J[a+8>>2]=b;c=a}d=J[b+8>>2];H[b+12|0]=K[d+12|0];H[d+12|0]=1;H[c+12|0]=1;b=J[d>>2];a=J[b+4>>2];J[d>>2]=a;if(a){J[a+8>>2]=d}J[b+8>>2]=J[d+8>>2];a=J[d+8>>2];J[(((d|0)!=J[a>>2])<<2)+a>>2]=b;J[b+4>>2]=d;J[d+8>>2]=b;break f}b=a;a=J[a+8>>2];a=J[(((b|0)==J[a>>2])<<2)+a>>2];continue}}H[c+12|0]=1}ab(g)}}function _f(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=0,g=0,h=Q(0),i=Q(0),j=0,k=0,l=Q(0),m=Q(0),n=0,o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=0,C=0;g=La-48|0;La=g;n=J[a+48>>2];B=J[n+8>>2];J[a+116>>2]=B;j=J[a+52>>2];C=J[j+8>>2];J[a+120>>2]=C;o=N[n+32>>2];f=J[n+32>>2];c=N[n+28>>2];k=J[n+28>>2];J[a+140>>2]=k;J[a+144>>2]=f;s=N[j+32>>2];f=J[j+32>>2];l=N[j+28>>2];J[a+148>>2]=J[j+28>>2];J[a+152>>2]=f;t=N[n+120>>2];N[a+156>>2]=t;u=N[j+120>>2];N[a+160>>2]=u;q=N[n+128>>2];N[a+164>>2]=q;r=N[j+128>>2];N[a+168>>2]=r;i=N[a+84>>2];n=J[b+24>>2];k=P(B,12);p=N[(n+k|0)+8>>2];e=Za(p);h=N[a+80>>2];d=_a(p);j=J[b+28>>2];k=j+k|0;v=N[k>>2];w=N[k+4>>2];x=N[k+8>>2];f=j;j=P(C,12);k=f+j|0;y=N[k>>2];z=N[k+4>>2];A=N[k+8>>2];m=N[(j+n|0)+8>>2];h=Q(h-c);i=Q(i-o);c=Q(Q(d*h)-Q(e*i));N[a+124>>2]=c;i=Q(Q(e*h)+Q(d*i));N[a+128>>2]=i;e=N[a+92>>2];d=Za(m);h=N[a+88>>2];o=_a(m);l=Q(h-l);h=Q(e-s);e=Q(Q(o*l)-Q(d*h));N[a+132>>2]=e;d=Q(Q(d*l)+Q(o*h));N[a+136>>2]=d;h=Q(Q(c*q)+Q(r*e));N[g+40>>2]=h;l=Q(q+r);N[g+44>>2]=l;N[g+32>>2]=h;h=Q(t+u);N[g+28>>2]=Q(r*Q(e*e))+Q(Q(q*Q(c*c))+h);o=Q(-i);s=Q(Q(q*o)-Q(r*d));N[g+36>>2]=s;N[g+20>>2]=s;c=Q(Q(q*Q(c*o))-Q(r*Q(e*d)));N[g+24>>2]=c;N[g+12>>2]=Q(r*Q(d*d))+Q(Q(q*Q(i*i))+h);N[g+16>>2]=c;a:{if(N[a+68>>2]>Q(0)){Rd(g+12|0,a+172|0);c=N[b>>2];d=N[a+68>>2];e=Q(c*Q(Q(c*d)+N[a+72>>2]));e=e!=Q(0)?Q(Q(1)/e):Q(0);N[a+100>>2]=e;N[a+76>>2]=Q(d*Q(c*Q(Q(m-p)-N[a+96>>2])))*e;c=Q(l+e);N[a+204>>2]=c!=Q(0)?Q(Q(1)/c):Q(0);break a}f=a+172|0;if(l==Q(0)){Rd(g+12|0,f);J[a+76>>2]=0;J[a+100>>2]=0;break a}m=N[g+24>>2];e=N[g+40>>2];p=N[g+28>>2];d=N[g+36>>2];h=Q(Q(m*e)-Q(p*d));i=N[g+12>>2];l=N[g+44>>2];o=Q(p*l);c=N[g+32>>2];s=Q(l*Q(-m));c=Q(Q(N[g+20>>2]*h)+Q(Q(i*Q(o-Q(e*c)))+Q(N[g+16>>2]*Q(Q(c*d)+s))));c=c!=Q(0)?Q(Q(1)/c):c;N[f+32>>2]=Q(Q(i*p)-Q(m*m))*c;m=Q(c*Q(Q(d*m)-Q(e*i)));N[f+28>>2]=m;p=Q(h*c);N[f+24>>2]=p;N[f+20>>2]=m;N[f+16>>2]=c*Q(Q(i*l)-Q(d*d));d=Q(c*Q(Q(d*e)+s));N[f+12>>2]=d;N[f+8>>2]=p;N[f+4>>2]=d;N[f>>2]=c*Q(o-Q(e*e));J[a+76>>2]=0;J[a+100>>2]=0}b:{if(K[b+20|0]){d=N[b+8>>2];c=Q(d*N[a+104>>2]);N[a+104>>2]=c;e=Q(d*N[a+108>>2]);N[a+108>>2]=e;d=Q(d*N[a+112>>2]);N[a+112>>2]=d;A=Q(Q(r*Q(d+Q(Q(N[a+132>>2]*e)-Q(c*N[a+136>>2]))))+A);x=Q(x-Q(q*Q(d+Q(Q(N[a+124>>2]*e)-Q(c*N[a+128>>2])))));y=Q(y+Q(u*c));v=Q(v-Q(t*c));z=Q(z+Q(u*e));w=Q(w-Q(t*e));break b}J[a+104>>2]=0;J[a+108>>2]=0;J[a+112>>2]=0}f=J[b+28>>2]+P(J[a+116>>2],12)|0;N[f+4>>2]=w;N[f>>2]=v;f=J[b+28>>2];N[(f+P(J[a+116>>2],12)|0)+8>>2]=x;f=f+P(J[a+120>>2],12)|0;N[f+4>>2]=z;N[f>>2]=y;N[(J[b+28>>2]+P(J[a+120>>2],12)|0)+8>>2]=A;La=g+48|0}function wh(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=0,g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=0,l=Q(0),m=Q(0),n=Q(0),o=0,p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=Q(0),C=Q(0),D=Q(0),E=Q(0),F=Q(0),G=0,H=Q(0),I=Q(0),K=Q(0),L=Q(0),M=Q(0),O=Q(0),R=Q(0),S=Q(0);f=J[a+76>>2];k=J[b+24>>2];G=k+P(J[a+172>>2],12)|0;H=N[G+4>>2];I=N[G>>2];o=k+P(J[a+168>>2],12)|0;u=N[o+8>>2];K=N[o+4>>2];L=N[o>>2];o=k+P(J[a+164>>2],12)|0;M=N[o+4>>2];O=N[o>>2];k=k+P(J[a+160>>2],12)|0;v=N[k+8>>2];R=N[k+4>>2];S=N[k>>2];w=N[o+8>>2];x=N[G+8>>2];r=_a(x);s=Za(x);g=_a(w);n=Za(w);a:{if((f|0)==1){y=N[a+224>>2];z=N[a+232>>2];p=Q(y+z);A=Q(1);B=Q(1);c=Q(Q(v-u)-N[a+140>>2]);break a}q=N[a+124>>2];l=_a(u);j=N[a+128>>2];m=Za(u);d=N[a+180>>2];c=N[a+96>>2];i=_a(v);e=Q(N[a+92>>2]-N[a+176>>2]);h=Za(v);c=Q(c-d);d=Q(Q(i*e)-Q(h*c));C=Q(Q(m*q)+Q(l*j));D=Q(Q(l*q)-Q(j*m));c=Q(Q(h*e)+Q(i*c));A=Q(Q(d*C)-Q(D*c));y=N[a+224>>2];e=Q(N[a+108>>2]-N[a+192>>2]);h=Q(N[a+112>>2]-N[a+196>>2]);B=Q(Q(Q(Q(l*e)-Q(m*h))*C)-Q(D*Q(Q(m*e)+Q(l*h))));z=N[a+232>>2];p=Q(Q(Q(y*A)*A)+Q(Q(Q(B*z)*B)+Q(N[a+216>>2]+N[a+208>>2])));d=Q(Q(S-L)+d);c=Q(Q(R-K)+c);c=Q(Q(q*Q(Q(Q(l*d)+Q(m*c))-e))+Q(j*Q(Q(Q(l*c)-Q(m*d))-h)))}j=Q(0);d=Q(p+Q(0));b:{if(J[a+80>>2]==1){i=Q(Q(w-x)-N[a+144>>2]);e=N[a+152>>2];E=N[a+228>>2];F=N[a+236>>2];t=Q(Q(Q(e*e)*Q(E+F))+d);h=e;p=e;d=Q(0);break b}t=d;E=N[a+228>>2];e=N[a+152>>2];h=Q(N[a+100>>2]-N[a+184>>2]);d=Q(N[a+104>>2]-N[a+188>>2]);i=Q(Q(g*h)-Q(d*n));l=N[a+132>>2];m=N[a+136>>2];q=Q(Q(s*l)+Q(r*m));j=Q(Q(r*l)-Q(m*s));d=Q(Q(n*h)+Q(g*d));h=Q(e*Q(Q(i*q)-Q(j*d)));g=Q(N[a+116>>2]-N[a+200>>2]);n=Q(N[a+120>>2]-N[a+204>>2]);p=Q(e*Q(Q(Q(Q(r*g)-Q(n*s))*q)-Q(j*Q(Q(s*g)+Q(r*n)))));F=N[a+236>>2];t=Q(t+Q(Q(Q(E*h)*h)+Q(Q(Q(e*e)*Q(N[a+220>>2]+N[a+212>>2]))+Q(p*Q(p*F)))));i=Q(Q(O-I)+i);d=Q(Q(M-H)+d);i=Q(Q(Q(Q(Q(r*i)+Q(s*d))-g)*l)+Q(m*Q(Q(Q(r*d)-Q(s*i))-n)));j=Q(j*e);d=Q(q*e)}g=Q(0);g=t>Q(0)?Q(Q(-Q(Q(Q(e*i)+c)-N[a+148>>2]))/t):g;n=N[a+220>>2];i=N[a+216>>2];e=N[a+212>>2];c=Q(g*N[a+208>>2]);N[k+4>>2]=R+Q(C*c);N[k>>2]=S+Q(D*c);f=J[b+24>>2];N[(f+P(J[a+160>>2],12)|0)+8>>2]=Q(Q(g*y)*A)+v;f=f+P(J[a+164>>2],12)|0;c=Q(g*e);N[f+4>>2]=M+Q(d*c);N[f>>2]=O+Q(j*c);f=J[b+24>>2];N[(f+P(J[a+164>>2],12)|0)+8>>2]=Q(Q(g*E)*h)+w;f=f+P(J[a+168>>2],12)|0;c=Q(g*i);N[f+4>>2]=K-Q(C*c);N[f>>2]=L-Q(D*c);f=J[b+24>>2];N[(f+P(J[a+168>>2],12)|0)+8>>2]=u-Q(Q(g*z)*B);f=f+P(J[a+172>>2],12)|0;c=Q(g*n);N[f+4>>2]=H-Q(d*c);N[f>>2]=I-Q(j*c);N[(J[b+24>>2]+P(J[a+172>>2],12)|0)+8>>2]=x-Q(Q(g*F)*p);return 1}function Od(a,b){var c=Q(0),d=Q(0),e=Q(0),f=Q(0),g=0,h=0,i=0,j=0,k=0,l=0,m=Q(0),n=Q(0),o=0,p=0,q=0,r=0,s=Q(0),t=0,u=0,v=0,w=0,x=0;k=J[a+4>>2];h=k+P(b,40)|0;p=J[h+24>>2];if((p|0)==-1){return b}if(J[h+32>>2]<2){return b}j=P(b,40)+k|0;q=J[j+28>>2];g=P(q,40)+k|0;t=J[g+32>>2];l=P(p,40)+k|0;u=J[l+32>>2];i=t-u|0;a:{if((i|0)>=2){o=J[g+24>>2];J[g+24>>2]=b;J[g+20>>2]=J[j+20>>2];r=J[g+28>>2];J[j+20>>2]=q;t=P(r,40);v=t+k|0;p=P(o,40);w=p+k|0;i=J[g+20>>2];if((i|0)!=-1){a=J[a+4>>2]+P(i,40)|0;a=J[a+24>>2]==(b|0)?a+24|0:a+28|0}J[a>>2]=q;t=k+t|0;a=J[t+32>>2];p=k+p|0;i=J[p+32>>2];b:{if((a|0)<(i|0)){x=p+32|0;J[g+28>>2]=o;J[j+28>>2]=r;J[t+20>>2]=b;f=N[v>>2];e=N[l>>2];d=N[l+4>>2];c=N[v+4>>2];m=c>d?d:c;N[h+4>>2]=m;n=e>2]=n;s=N[v+8>>2];e=N[l+8>>2];d=N[l+12>>2];c=N[v+12>>2];f=c>2]=f;e=e>s?e:s;N[h+8>>2]=e;d=N[w>>2];c=N[w+4>>2];N[g+4>>2]=c>m?m:c;N[g>>2]=d>n?n:d;c=N[w+12>>2];d=c>2];c=c>2]=r;J[j+28>>2]=o;J[p+20>>2]=b;f=N[w>>2];e=N[l>>2];d=N[l+4>>2];c=N[w+4>>2];m=c>d?d:c;N[h+4>>2]=m;n=e>2]=n;s=N[w+8>>2];e=N[l+8>>2];d=N[l+12>>2];c=N[w+12>>2];f=c>2]=f;e=e>s?e:s;N[h+8>>2]=e;d=N[v>>2];c=N[v+4>>2];N[g+4>>2]=c>m?m:c;N[g>>2]=d>n?n:d;c=N[v+12>>2];d=c>2];c=c>2]=c;a=(a|0)<(u|0)?u:a;break a}if((i|0)>-2){return b}r=P(p,40)+k|0;u=J[r+24>>2];J[r+24>>2]=b;i=P(b,40)+k|0;J[r+20>>2]=J[i+20>>2];q=J[r+28>>2];J[i+20>>2]=p;i=J[r+20>>2];if((i|0)!=-1){a=J[a+4>>2]+P(i,40)|0;a=J[a+24>>2]==(b|0)?a+24|0:a+28|0}J[a>>2]=p;j=P(q,40)+k|0;a=J[j+32>>2];o=P(u,40)+k|0;i=J[o+32>>2];c:{if((a|0)<(i|0)){x=o+32|0;J[r+28>>2]=u;J[h+24>>2]=q;J[(P(q,40)+k|0)+20>>2]=b;f=N[j>>2];e=N[g>>2];d=N[g+4>>2];c=N[j+4>>2];m=c>d?d:c;N[h+4>>2]=m;n=e>2]=n;s=N[j+8>>2];e=N[g+8>>2];d=N[g+12>>2];c=N[j+12>>2];f=c>2]=f;e=e>s?e:s;N[h+8>>2]=e;d=N[o>>2];c=N[o+4>>2];N[l+4>>2]=c>m?m:c;N[l>>2]=d>n?n:d;c=N[o+12>>2];d=c>2];c=c>2]=q;J[h+24>>2]=u;J[(P(u,40)+k|0)+20>>2]=b;f=N[o>>2];e=N[g>>2];d=N[g+4>>2];c=N[o+4>>2];m=c>d?d:c;N[h+4>>2]=m;n=e>2]=n;s=N[o+8>>2];e=N[g+8>>2];d=N[g+12>>2];c=N[o+12>>2];f=c>2]=f;e=e>s?e:s;N[h+8>>2]=e;d=N[j>>2];c=N[j+4>>2];N[l+4>>2]=c>m?m:c;N[l>>2]=d>n?n:d;c=N[j+12>>2];d=c>2];c=c>2]=c;q=p;a=(a|0)<(t|0)?t:a}b=a+1|0;J[h+32>>2]=b;a=J[x>>2];N[(P(q,40)+k|0)+12>>2]=d;J[i>>2]=((a|0)<(b|0)?b:a)+1;return q}function Lg(a,b){a=a|0;b=b|0;var c=Q(0),d=0,e=Q(0),f=0,g=Q(0),h=0,i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=0,z=Q(0),A=Q(0),B=Q(0),C=Q(0),D=Q(0),E=Q(0),F=0,G=Q(0),H=Q(0),I=0,L=Q(0),M=Q(0),O=Q(0);f=J[a+48>>2];y=J[f+8>>2];J[a+144>>2]=y;h=J[a+52>>2];F=J[h+8>>2];J[a+148>>2]=F;G=N[f+32>>2];d=J[f+32>>2];n=N[f+28>>2];J[a+152>>2]=J[f+28>>2];J[a+156>>2]=d;H=N[h+32>>2];I=J[h+32>>2];m=N[h+28>>2];d=J[h+28>>2];J[a+160>>2]=d;J[a+164>>2]=I;v=N[f+120>>2];N[a+168>>2]=v;w=N[h+120>>2];N[a+172>>2]=w;o=N[f+128>>2];N[a+176>>2]=o;t=N[h+128>>2];N[a+180>>2]=t;f=P(y,12);h=J[b+28>>2];d=f+h|0;z=N[d>>2];A=N[d+4>>2];B=N[d+8>>2];d=h;h=P(F,12);d=d+h|0;C=N[d>>2];D=N[d+4>>2];E=N[d+8>>2];d=f;f=J[b+24>>2];d=d+f|0;k=N[d>>2];f=f+h|0;j=N[f>>2];x=N[d+4>>2];L=N[f+4>>2];M=N[a+72>>2];l=N[f+8>>2];i=N[a+80>>2];p=N[a+88>>2];c=N[d+8>>2];O=N[a+68>>2];g=N[a+76>>2];q=N[a+84>>2];e=Q(o+t);N[a+228>>2]=e==Q(0)?Q(1):e;e=_a(c);c=Za(c);u=Q(Q(q*c)+Q(e*p));N[a+188>>2]=u;p=Q(Q(e*q)-Q(p*c));N[a+184>>2]=p;r=N[a+92>>2];s=N[a+96>>2];q=Q(Q(c*r)+Q(e*s));N[a+196>>2]=q;r=Q(Q(e*r)-Q(s*c));N[a+192>>2]=r;s=_a(l);m=Q(g-m);g=Q(i-H);l=Za(l);i=Q(Q(s*m)-Q(g*l));g=Q(Q(l*m)+Q(s*g));l=Q(Q(i*u)-Q(p*g));N[a+212>>2]=l;m=Q(Q(i*q)-Q(r*g));N[a+204>>2]=m;s=Q(Q(j-k)+i);i=Q(O-n);k=Q(M-G);j=Q(Q(e*i)-Q(c*k));n=Q(s-j);c=Q(Q(c*i)+Q(e*k));e=Q(Q(Q(L-x)+g)-c);g=Q(j+n);c=Q(c+e);i=Q(Q(g*u)-Q(p*c));N[a+208>>2]=i;g=Q(Q(g*q)-Q(r*c));N[a+200>>2]=g;c=Q(o*g);k=Q(t*m);j=Q(c+k);N[a+224>>2]=j;N[a+220>>2]=j;j=Q(c*g);c=Q(v+w);N[a+216>>2]=Q(k*m)+Q(j+c);c=Q(Q(Q(t*l)*l)+Q(Q(Q(o*i)*i)+c));N[a+236>>2]=c>Q(0)?Q(Q(1)/c):c;a:{if(K[a+140|0]){N[a+232>>2]=Q(p*n)+Q(u*e);break a}J[a+116>>2]=0;J[a+120>>2]=0}if(!K[a+141|0]){J[a+112>>2]=0}b:{if(K[b+20|0]){e=N[b+8>>2];c=Q(e*N[a+104>>2]);N[a+104>>2]=c;k=Q(e*N[a+112>>2]);N[a+112>>2]=k;j=Q(e*N[a+116>>2]);N[a+116>>2]=j;x=Q(e*N[a+120>>2]);N[a+120>>2]=x;n=Q(e*N[a+108>>2]);N[a+108>>2]=n;e=Q(Q(k+j)-x);E=Q(Q(t*Q(Q(e*l)+Q(Q(c*m)+n)))+E);B=Q(B-Q(o*Q(Q(e*i)+Q(Q(c*g)+n))));o=Q(Q(q*c)+Q(u*e));D=Q(D+Q(w*o));e=Q(Q(r*c)+Q(p*e));C=Q(C+Q(w*e));A=Q(A-Q(v*o));z=Q(z-Q(v*e));break b}J[a+104>>2]=0;J[a+108>>2]=0;J[a+120>>2]=0;J[a+112>>2]=0;J[a+116>>2]=0}d=J[b+28>>2]+P(y,12)|0;N[d+4>>2]=A;N[d>>2]=z;d=J[b+28>>2];N[(d+P(J[a+144>>2],12)|0)+8>>2]=B;d=d+P(J[a+148>>2],12)|0;N[d+4>>2]=D;N[d>>2]=C;N[(J[b+28>>2]+P(J[a+148>>2],12)|0)+8>>2]=E}function Jg(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=0,f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=0,n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=0,w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=Q(0),C=Q(0),D=Q(0),E=Q(0),F=Q(0),G=Q(0);e=La+-64|0;La=e;h=N[a+156>>2];u=N[a+72>>2];v=J[b+24>>2];m=v+P(J[a+144>>2],12)|0;x=N[m+8>>2];c=_a(x);n=N[a+152>>2];o=N[a+68>>2];k=Za(x);r=N[a+164>>2];j=N[a+80>>2];v=v+P(J[a+148>>2],12)|0;y=N[v+8>>2];l=_a(y);s=N[a+160>>2];f=N[a+76>>2];p=Za(y);w=N[a+92>>2];t=N[a+96>>2];z=Q(Q(c*w)-Q(k*t));D=N[v>>2];f=Q(f-s);j=Q(j-r);r=Q(Q(l*f)-Q(p*j));E=N[m>>2];n=Q(o-n);h=Q(u-h);o=Q(Q(c*n)-Q(k*h));d=Q(Q(Q(D+r)-E)-o);s=Q(Q(k*w)+Q(c*t));F=N[v+4>>2];l=Q(Q(p*f)+Q(l*j));G=N[m+4>>2];p=Q(Q(k*n)+Q(c*h));g=Q(Q(Q(F+l)-G)-p);f=Q(Q(z*d)+Q(s*g));w=Q(-f);u=f>Q(0)?f:w;h=Q(o+d);n=Q(p+g);p=Q(Q(h*s)-Q(z*n));j=h;h=N[a+84>>2];o=N[a+88>>2];t=Q(Q(k*h)+Q(c*o));A=Q(Q(c*h)-Q(o*k));n=Q(Q(j*t)-Q(A*n));h=Q(Q(r*s)-Q(z*l));r=Q(Q(r*t)-Q(A*l));B=Q(Q(y-x)-N[a+100>>2]);C=Q(-B);k=N[a+180>>2];l=N[a+176>>2];o=N[a+172>>2];j=N[a+168>>2];a:{b:{if(!K[a+140|0]){break b}c=Q(Q(A*d)+Q(t*g));g=N[a+128>>2];d=N[a+124>>2];i=Q(g-d);c:{if((i>Q(0)?i:Q(-i))Q(0)?c:Q(-c);break c}if(c<=d){q=Q(d-c);c=Q(c-d);c=c=g)){break b}q=Q(c-g);c=q>Q(0)?q:Q(0)}f=Q(l*n);d=Q(k*r);g=Q(f+d);N[e+56>>2]=g;N[e+48>>2]=g;g=Q(l+k);N[e+44>>2]=g==Q(0)?Q(1):g;g=Q(j+o);N[e+60>>2]=Q(d*r)+Q(Q(f*n)+g);f=Q(l*p);d=Q(k*h);i=Q(f+d);N[e+40>>2]=i;N[e+32>>2]=i;i=Q(Q(f*n)+Q(r*d));N[e+52>>2]=i;N[e+36>>2]=i;N[e+28>>2]=Q(d*h)+Q(Q(f*p)+g);N[e+12>>2]=-c;N[e+8>>2]=C;N[e+4>>2]=w;u=q>2];f=N[e+20>>2];c=N[e+16>>2];break a}c=Q(k*h);d=Q(l*p);g=Q(Q(c*h)+Q(Q(d*p)+Q(j+o)));i=Q(l+k);i=i==Q(0)?Q(1):i;c=Q(d+c);d=Q(Q(g*i)-Q(c*c));d=d!=Q(0)?Q(Q(1)/d):d;f=Q(Q(Q(g*C)+Q(f*c))*d);c=Q(Q(Q(i*w)+Q(B*c))*d)}m=J[b+24>>2]+P(J[a+144>>2],12)|0;s=Q(Q(s*c)+Q(t*q));N[m+4>>2]=G-Q(j*s);d=j;j=Q(Q(z*c)+Q(A*q));N[m>>2]=E-Q(d*j);m=J[b+24>>2];N[(m+P(J[a+144>>2],12)|0)+8>>2]=x-Q(l*Q(Q(q*n)+Q(Q(c*p)+f)));m=m+P(J[a+148>>2],12)|0;N[m+4>>2]=F+Q(o*s);N[m>>2]=D+Q(o*j);N[(J[b+24>>2]+P(J[a+148>>2],12)|0)+8>>2]=Q(k*Q(Q(q*r)+Q(Q(c*h)+f)))+y;La=e- -64|0;return(B>Q(0)?B:C)<=Q(.03490658849477768)&u<=Q(.004999999888241291)}function Ef(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=Q(0),f=0,g=Q(0),h=0,i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=0,q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=0,y=Q(0),z=Q(0);f=La-32|0;La=f;J[f+28>>2]=b;p=a+102868|0;J[f+24>>2]=p;J[f+16>>2]=1065353216;a=J[c+4>>2];J[f>>2]=J[c>>2];J[f+4>>2]=a;a=J[d+4>>2];J[f+8>>2]=J[d>>2];J[f+12>>2]=a;a=La-1088|0;La=a;i=N[f>>2];m=Q(N[f+8>>2]-i);n=m;j=N[f+4>>2];o=Q(N[f+12>>2]-j);e=o;g=Q(Y(Q(Q(m*m)+Q(e*e))));if(!(g>2];J[a+1064>>2]=256;d=a+36|0;J[a+32>>2]=d;J[a+36>>2]=J[p>>2];k=Q(j+Q(o*g));t=j>k?j:k;l=Q(i+Q(m*g));u=i>l?i:l;v=jQ(0)?n:Q(-n);w=Q(-e);z=e>2]=c;h=J[a+32>>2];b=J[h+(c<<2)>>2];b:{if((b|0)==-1){break b}x=P(b,40);b=x+J[p+4>>2]|0;e=N[b+8>>2];if(Q(k-e)>Q(0)){break b}l=N[b+12>>2];if(Q(v-l)>Q(0)){break b}q=N[b>>2];if(Q(q-u)>Q(0)){break b}r=N[b+4>>2];if(Q(r-t)>Q(0)){break b}s=Q(Q(w*Q(i-Q(Q(e+q)*Q(.5))))+Q(n*Q(j-Q(Q(l+r)*Q(.5)))));if(Q((s>Q(0)?s:Q(-s))-Q(Q(z*Q(Q(e-q)*Q(.5)))+Q(y*Q(Q(l-r)*Q(.5)))))>Q(0)){break b}if(J[b+24>>2]==-1){b=J[f+4>>2];J[a+8>>2]=J[f>>2];J[a+12>>2]=b;b=J[f+12>>2];c=J[f+8>>2];N[a+24>>2]=g;J[a+16>>2]=c;J[a+20>>2]=b;c=J[(J[J[f+24>>2]+4>>2]+x|0)+16>>2];b=J[c+16>>2];h=J[b+12>>2];c:{if(Na[J[J[h>>2]+20>>2]](h,a+1076|0,a+8|0,J[b+8>>2]+12|0,J[c+20>>2])|0){e=N[a+1084>>2];l=Q(Q(1)-e);N[a+1072>>2]=Q(l*N[a+12>>2])+Q(e*N[a+20>>2]);N[a+1068>>2]=Q(l*N[a+8>>2])+Q(e*N[a+16>>2]);c=J[f+28>>2];e=Q(Na[J[J[c>>2]+8>>2]](c,b,a+1068|0,a+1076|0,e));break c}e=N[a+24>>2]}if(e>Q(0)){g=Q(j+Q(o*e));t=gk?i:k;v=g>j?j:g;k=i>2];break b}d:{if(J[a+1064>>2]!=(c|0)){break d}J[a+1064>>2]=c<<1;c=fb(c<<3);J[a+32>>2]=c;rb(c,h,J[a+1060>>2]<<2);if((d|0)==(h|0)){break d}ab(h)}c=J[a+32>>2];J[c+(J[a+1060>>2]<<2)>>2]=J[b+24>>2];h=J[a+1060>>2]+1|0;J[a+1060>>2]=h;e:{if((h|0)!=J[a+1064>>2]){break e}J[a+1064>>2]=h<<1;h=fb(h<<3);J[a+32>>2]=h;rb(h,c,J[a+1060>>2]<<2);if((c|0)==(d|0)){break e}ab(c)}J[J[a+32>>2]+(J[a+1060>>2]<<2)>>2]=J[b+28>>2];c=J[a+1060>>2]+1|0;J[a+1060>>2]=c}if((c|0)>0){continue}}break}b=J[a+32>>2];if((b|0)!=(d|0)){ab(b)}La=a+1088|0;La=f+32|0}function gd(a){var b=0,c=Q(0),d=0,e=Q(0),f=Q(0),g=Q(0),h=0,i=0,j=0,k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=0,s=0,t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=Q(0),C=Q(0),D=Q(0),E=Q(0),F=Q(0),G=0;h=La+-64|0;La=h;if(J[a+48>>2]>0){while(1){b=J[a+40>>2]+P(s,156)|0;o=N[b+132>>2];p=N[b+128>>2];q=N[b+124>>2];z=N[b+120>>2];i=J[a+28>>2];j=P(J[b+116>>2],12);d=i+j|0;t=N[d+8>>2];A=N[d+4>>2];B=N[d>>2];r=P(J[b+112>>2],12);d=r+i|0;u=N[d+8>>2];C=N[d+4>>2];D=N[d>>2];d=J[a+36>>2]+P(s,88)|0;E=N[d+80>>2];F=N[d+76>>2];G=J[J[a+44>>2]+(J[b+152>>2]<<2)>>2];i=j;j=J[a+24>>2];i=i+j|0;v=N[i>>2];w=N[i+4>>2];c=N[d+56>>2];g=N[d+60>>2];j=j+r|0;x=N[j>>2];y=N[j+4>>2];f=N[d+48>>2];l=N[d+52>>2];k=N[i+8>>2];m=N[j+8>>2];n=_a(m);N[h+60>>2]=n;m=Za(m);N[h+56>>2]=m;e=_a(k);N[h+44>>2]=e;k=Za(k);N[h+40>>2]=k;N[h+52>>2]=y-Q(Q(m*f)+Q(l*n));N[h+48>>2]=x-Q(Q(n*f)-Q(l*m));N[h+36>>2]=w-Q(Q(k*c)+Q(g*e));N[h+32>>2]=v-Q(Q(e*c)-Q(g*k));Vd(h,G- -64|0,h+48|0,F,h+32|0,E);d=J[h+4>>2];J[b+72>>2]=J[h>>2];J[b+76>>2]=d;r=J[b+148>>2];a:{if((r|0)<=0){break a}g=Q(z+q);i=0;while(1){j=(i<<3)+h|0;c=N[j+8>>2];d=P(i,36)+b|0;l=Q(N[j+12>>2]-y);N[d+4>>2]=l;k=Q(c-x);N[d>>2]=k;c=N[j+8>>2];n=Q(N[j+12>>2]-w);N[d+12>>2]=n;m=Q(c-v);N[d+8>>2]=m;f=N[b+76>>2];c=N[b+72>>2];J[d+32>>2]=0;e=Q(Q(m*f)-Q(c*n));q=Q(Q(o*e)*e);e=Q(Q(k*f)-Q(c*l));e=Q(q+Q(Q(Q(p*e)*e)+g));N[d+24>>2]=e>Q(0)?Q(Q(1)/e):Q(0);e=Q(-c);q=Q(Q(m*e)-Q(f*n));e=Q(Q(k*e)-Q(f*l));e=Q(Q(Q(o*q)*q)+Q(Q(Q(p*e)*e)+g));N[d+28>>2]=e>Q(0)?Q(Q(1)/e):Q(0);f=Q(Q(c*Q(Q(u*l)+Q(Q(B-Q(t*n))-D)))+Q(f*Q(Q(Q(A+Q(t*m))-C)-Q(u*k))));if(f>2]=f*Q(-N[b+140>>2])}i=i+1|0;if((r|0)!=(i|0)){continue}break}if(!K[23656]|J[b+148>>2]!=2){break a}l=N[b+76>>2];f=Q(Q(N[b+8>>2]*l)-Q(c*N[b+12>>2]));k=Q(o*f);e=Q(k*f);f=Q(Q(N[b>>2]*l)-Q(c*N[b+4>>2]));n=Q(p*f);f=Q(e+Q(Q(n*f)+g));e=o;o=Q(Q(N[b+44>>2]*l)-Q(c*N[b+48>>2]));c=Q(Q(N[b+36>>2]*l)-Q(c*N[b+40>>2]));p=Q(Q(Q(e*o)*o)+Q(Q(Q(p*c)*c)+g));c=Q(Q(k*o)+Q(Q(n*c)+g));g=Q(Q(f*p)-Q(c*c));if(Q(f*f)>2]=f;N[b+108>>2]=p;N[b+104>>2]=c;N[b+100>>2]=c;g=g!=Q(0)?Q(Q(1)/g):g;N[b+92>>2]=f*g;N[b+80>>2]=p*g;c=Q(c*Q(-g));N[b+88>>2]=c;N[b+84>>2]=c;break a}J[b+148>>2]=1}s=s+1|0;if((s|0)>2]){continue}break}}La=h- -64|0}function Vd(a,b,c,d,e,f){var g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=0,q=Q(0),r=Q(0),s=0,t=Q(0);a:{if(!J[b+60>>2]){break a}b:{switch(J[b+56>>2]){case 0:J[a>>2]=1065353216;J[a+4>>2]=0;h=N[c+12>>2];g=N[b+48>>2];j=N[b+52>>2];k=N[c+8>>2];i=Q(N[c>>2]+Q(Q(h*g)-Q(j*k)));o=N[e+12>>2];m=N[b>>2];n=N[b+4>>2];q=N[e+8>>2];l=Q(N[e>>2]+Q(Q(o*m)-Q(n*q)));r=Q(i-l);j=Q(Q(Q(k*g)+Q(h*j))+N[c+4>>2]);k=Q(Q(Q(q*m)+Q(o*n))+N[e+4>>2]);h=Q(j-k);c:{if(!(Q(Q(r*r)+Q(h*h))>Q(14210854715202004e-30))){h=Q(1);g=Q(0);break c}g=Q(k-j);N[a+4>>2]=g;h=Q(l-i);N[a>>2]=h;o=Q(Y(Q(Q(h*h)+Q(g*g))));if(o>2]=g;h=Q(h*o);N[a>>2]=h}j=Q(j+Q(g*d));k=Q(k-Q(g*f));N[a+12>>2]=Q(j+k)*Q(.5);d=Q(i+Q(h*d));f=Q(l-Q(h*f));N[a+8>>2]=Q(d+f)*Q(.5);N[a+24>>2]=Q(Q(f-d)*h)+Q(g*Q(k-j));return;case 1:g=N[c+8>>2];i=N[b+40>>2];l=N[c+12>>2];j=N[b+44>>2];h=Q(Q(g*i)+Q(l*j));N[a+4>>2]=h;g=Q(Q(l*i)-Q(j*g));N[a>>2]=g;if(J[b+60>>2]<=0){break a}i=N[c+8>>2];l=N[b+48>>2];j=N[c+12>>2];k=N[b+52>>2];o=Q(Q(Q(i*l)+Q(j*k))+N[c+4>>2]);l=Q(N[c>>2]+Q(Q(j*l)-Q(k*i)));j=Q(h*f);k=Q(g*f);while(1){c=(p<<3)+a|0;i=N[e+8>>2];s=P(p,20)+b|0;m=N[s>>2];n=N[e+12>>2];q=N[s+4>>2];f=Q(Q(Q(i*m)+Q(n*q))+N[e+4>>2]);r=Q(f-j);t=f;i=Q(N[e>>2]+Q(Q(n*m)-Q(q*i)));f=Q(d-Q(Q(Q(i-l)*g)+Q(Q(f-o)*h)));m=Q(t+Q(h*f));N[c+12>>2]=Q(r+m)*Q(.5);n=Q(i-k);f=Q(i+Q(g*f));N[c+8>>2]=Q(n+f)*Q(.5);N[((p<<2)+a|0)+24>>2]=Q(Q(n-f)*g)+Q(h*Q(r-m));p=p+1|0;if((p|0)>2]){continue}break};break a;case 2:break b;default:break a}}g=N[e+8>>2];i=N[b+40>>2];l=N[e+12>>2];j=N[b+44>>2];h=Q(Q(g*i)+Q(l*j));N[a+4>>2]=h;g=Q(Q(l*i)-Q(j*g));N[a>>2]=g;if(J[b+60>>2]>0){i=N[e+8>>2];l=N[b+48>>2];j=N[e+12>>2];k=N[b+52>>2];o=Q(Q(Q(i*l)+Q(j*k))+N[e+4>>2]);l=Q(N[e>>2]+Q(Q(j*l)-Q(k*i)));j=Q(h*d);k=Q(g*d);while(1){e=(p<<3)+a|0;i=N[c+8>>2];s=P(p,20)+b|0;m=N[s>>2];n=N[c+12>>2];q=N[s+4>>2];d=Q(Q(Q(i*m)+Q(n*q))+N[c+4>>2]);r=Q(d-j);t=d;i=Q(N[c>>2]+Q(Q(n*m)-Q(q*i)));d=Q(f-Q(Q(Q(i-l)*g)+Q(Q(d-o)*h)));m=Q(t+Q(h*d));N[e+12>>2]=Q(r+m)*Q(.5);n=Q(i-k);d=Q(i+Q(g*d));N[e+8>>2]=Q(n+d)*Q(.5);N[((p<<2)+a|0)+24>>2]=Q(Q(n-d)*g)+Q(h*Q(r-m));p=p+1|0;if((p|0)>2]){continue}break}}N[a+4>>2]=-h;N[a>>2]=-g}}function vc(a,b){var c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0;e=La+-64|0;La=e;c=J[a+124>>2];J[e+56>>2]=J[a+120>>2];J[e+60>>2]=c;c=J[a+116>>2];J[e+48>>2]=J[a+112>>2];J[e+52>>2]=c;c=J[a+108>>2];J[e+40>>2]=J[a+104>>2];J[e+44>>2]=c;c=J[a+100>>2];J[e+32>>2]=J[a+96>>2];J[e+36>>2]=c;c=J[a+92>>2];J[e+24>>2]=J[a+88>>2];J[e+28>>2]=c;c=J[a+84>>2];J[e+16>>2]=J[a+80>>2];J[e+20>>2]=c;c=J[a+76>>2];J[e+8>>2]=J[a+72>>2];J[e+12>>2]=c;c=J[a+68>>2];J[e>>2]=J[a+64>>2];J[e+4>>2]=c;c=J[a+4>>2];J[a+4>>2]=c|4;n=c&2;h=J[a+52>>2];l=J[h+8>>2];g=l+12|0;j=J[a+48>>2];m=J[j+8>>2];c=m+12|0;o=K[h+38|0]|K[j+38|0];a:{if(o){l=J[j+12>>2];m=J[a+56>>2];h=J[h+12>>2];i=J[a+60>>2];d=La-128|0;La=d;J[d+88>>2]=0;J[d+80>>2]=0;J[d+84>>2]=0;J[d+60>>2]=0;J[d+52>>2]=0;J[d+56>>2]=0;j=d+36|0;gc(j,l,m);gc(d- -64|0,h,i);i=J[c+12>>2];J[d+100>>2]=J[c+8>>2];J[d+104>>2]=i;i=J[c+4>>2];J[d+92>>2]=J[c>>2];J[d+96>>2]=i;c=J[g+12>>2];J[d+116>>2]=J[g+8>>2];J[d+120>>2]=c;c=J[g+4>>2];J[d+108>>2]=J[g>>2];J[d+112>>2]=c;H[d+124|0]=1;I[d+28>>1]=0;Ud(d,d+24|0,j);La=d+128|0;f=N[d+16>>2]>2]=0;break a}d=a- -64|0;Na[J[J[a>>2]>>2]](a,d,c,g);h=J[a+124>>2];b:{if((h|0)<=0){break b}g=J[e+60>>2];if((g|0)>0){while(1){j=d+P(k,20)|0;c=j;J[c+8>>2]=0;J[c+12>>2]=0;c=J[c+16>>2];f=0;c:{while(1){i=P(f,20)+e|0;if(J[i+16>>2]!=(c|0)){f=f+1|0;if((g|0)!=(f|0)){continue}break c}break}N[j+8>>2]=N[i+8>>2];N[j+12>>2]=N[i+12>>2]}k=k+1|0;if((h|0)!=(k|0)){continue}break}break b}if(h>>>0>=4){g=h&-4;while(1){c=d+P(f,20)|0;J[c+8>>2]=0;J[c+12>>2]=0;c=d+P(f|1,20)|0;J[c+8>>2]=0;J[c+12>>2]=0;c=d+P(f|2,20)|0;J[c+8>>2]=0;J[c+12>>2]=0;c=d+P(f|3,20)|0;J[c+8>>2]=0;J[c+12>>2]=0;f=f+4|0;k=k+4|0;if((g|0)!=(k|0)){continue}break}}g=h&3;if(!g){break b}while(1){c=d+P(f,20)|0;J[c+8>>2]=0;J[c+12>>2]=0;f=f+1|0;i=i+1|0;if((g|0)!=(i|0)){continue}break}}f=(h|0)>0;if((f|0)==(n>>>1|0)){break a}if(J[m>>2]){J[m+144>>2]=0;I[m+4>>1]=L[m+4>>1]|2}if(!J[l>>2]){break a}J[l+144>>2]=0;I[l+4>>1]=L[l+4>>1]|2}k=2;J[a+4>>2]=J[a+4>>2]&-3|(f?2:0);c=(b|0)!=0&f;d:{if(!(c&!n)){if(!n){break d}k=3;if(!b|f){break d}}Na[J[J[b>>2]+(k<<2)>>2]](b,a)}if(!(!c|(o|0)!=0)){Na[J[J[b>>2]+16>>2]](b,a,e)}La=e- -64|0}function Sf(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=0,i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=0,B=Q(0),C=Q(0);A=J[b+24>>2];h=A+P(J[a+156>>2],12)|0;s=N[h+8>>2];u=N[h+4>>2];v=N[h>>2];h=P(J[a+152>>2],12)+A|0;t=N[h+8>>2];p=N[h+4>>2];w=N[h>>2];a:{if(!K[a+140|0]){m=Q(N[a+80>>2]-N[a+172>>2]);n=Q(N[a+72>>2]-N[a+164>>2]);o=Q(N[a+76>>2]-N[a+168>>2]);l=Q(N[a+68>>2]-N[a+160>>2]);break a}n=N[a+164>>2];e=N[a+72>>2];c=_a(t);l=N[a+160>>2];f=N[a+68>>2];d=Za(t);m=N[a+172>>2];i=N[a+80>>2];g=_a(s);o=N[a+168>>2];k=N[a+76>>2];j=Za(s);q=N[a+84>>2];r=N[a+88>>2];x=Q(Q(c*q)-Q(d*r));o=Q(k-o);m=Q(i-m);i=Q(Q(g*o)-Q(j*m));l=Q(f-l);n=Q(e-n);k=Q(Q(c*l)-Q(d*n));y=Q(Q(Q(v-w)+i)-k);q=Q(Q(d*q)+Q(c*r));r=Q(Q(j*o)+Q(g*m));z=Q(Q(d*l)+Q(c*n));B=Q(Q(Q(u-p)+r)-z);c=Q(Q(x*y)+Q(q*B));g=N[a+192>>2];j=N[a+196>>2];e=N[a+128>>2];f=N[a+124>>2];d=Q(e-f);b:{if((d>Q(0)?d:Q(-d))=e)){break a}c=Q(c-e);if(!(c>Q(0))){break a}}if(c==Q(0)){d=Q(0);break a}C=Q(-c);e=Q(Q(i*j)-Q(g*r));i=N[a+188>>2];g=Q(Q(Q(k+y)*j)-Q(g*Q(z+B)));k=N[a+184>>2];j=N[a+176>>2];f=N[a+180>>2];d=Q(Q(e*Q(e*i))+Q(Q(Q(g*k)*g)+Q(j+f)));d=d!=Q(0)?Q(C/d):Q(0);s=Q(Q(i*Q(e*d))+s);e=Q(q*d);u=Q(u+Q(f*e));i=f;f=Q(x*d);v=Q(v+Q(i*f));t=Q(t-Q(k*Q(g*d)));p=Q(p-Q(j*e));w=Q(w-Q(j*f));d=c>Q(0)?c:C}c=_a(t);g=Za(t);f=_a(s);i=Za(s);e=N[a+92>>2];k=N[a+96>>2];j=Q(Q(g*e)+Q(c*k));q=Q(Q(f*o)-Q(m*i));r=Q(Q(c*l)-Q(n*g));x=Q(Q(Q(v-w)+q)-r);e=Q(Q(c*e)-Q(k*g));f=Q(Q(i*o)+Q(f*m));g=Q(Q(g*l)+Q(c*n));i=Q(Q(Q(u-p)+f)-g);m=Q(Q(x*e)+Q(j*i));k=Q(-m);y=N[a+188>>2];c=N[a+220>>2];l=Q(Q(y*c)*c);z=N[a+184>>2];c=N[a+216>>2];n=N[a+176>>2];o=N[a+180>>2];c=Q(l+Q(Q(Q(z*c)*c)+Q(n+o)));c=c!=Q(0)?Q(k/c):Q(0);l=Q(j*c);N[h+4>>2]=p-Q(n*l);p=Q(e*c);N[h>>2]=w-Q(n*p);h=J[b+24>>2];N[(h+P(J[a+152>>2],12)|0)+8>>2]=t-Q(z*Q(Q(Q(Q(r+x)*j)-Q(e*Q(g+i)))*c));h=h+P(J[a+156>>2],12)|0;N[h+4>>2]=u+Q(o*l);N[h>>2]=v+Q(o*p);N[(J[b+24>>2]+P(J[a+156>>2],12)|0)+8>>2]=Q(y*Q(Q(Q(q*j)-Q(e*f))*c))+s;c=m>Q(0)?m:k;return(c>2]+7&-8;J[c>>2]=b+16;o=a;i=J[b>>2];d=J[b+4>>2];a=J[b+12>>2];m=a;g=La-32|0;La=g;a=a&2147483647;h=a;e=a-1006698496|0;a=a-1140785152|0;c=J[b+8>>2];b=c;a:{if((e|0)==(a|0)&b>>>0>>0|a>>>0>e>>>0){a=c;c=m<<4|a>>>28;b=a<<4|d>>>28;a=c;d=d&268435455;if((d|0)==134217728&(i|0)!=0|d>>>0>134217728){a=a+1073741824|0;b=b+1|0;a=b?a:a+1|0;break a}a=a+1073741824|0;if(i|(d|0)!=134217728){break a}d=b&1;b=d+b|0;a=b>>>0>>0?a+1|0:a;break a}if(!(!b&(h|0)==2147418112?!(d|i):h>>>0<2147418112)){a=c;c=m<<4|a>>>28;b=a<<4|d>>>28;a=c&524287|2146959360;break a}b=0;a=2146435072;if(h>>>0>1140785151){break a}a=0;n=h>>>16|0;if(n>>>0<15249){break a}b=i;a=d;e=m&65535|65536;h=e;l=c;f=c;j=n-15233|0;b:{if(j&64){c=b;e=j+-64|0;b=e&31;if((e&63)>>>0>=32){a=c<>>32-b|a<>>0>=32){c=k<>>32-f|e<>>0>=32){c=0;b=a>>>f|0}else{c=a>>>f|0;b=((1<>>f}f=p|b;e=c|e;b=j&31;if((j&63)>>>0>=32){c=k<>>32-b|a<>2]=b;J[g+20>>2]=a;J[g+24>>2]=f;J[g+28>>2]=e;b=15361-n|0;c:{if(b&64){d=l;b=b+-64|0;a=b&31;if((b&63)>>>0>=32){c=0;i=h>>>a|0}else{c=h>>>a|0;i=((1<>>a}d=c;l=0;h=0;break c}if(!b){break c}e=l;a=64-b|0;c=a&31;if((a&63)>>>0>=32){a=e<>>32-c|h<>>0>=32){c=0;e=d>>>i|0}else{c=d>>>i|0;e=((1<>>i}i=f|e;d=a|c;e=l;c=b&31;if((b&63)>>>0>=32){a=0;l=h>>>c|0}else{a=h>>>c|0;l=((1<>>c}h=a}J[g>>2]=i;J[g+4>>2]=d;J[g+8>>2]=l;J[g+12>>2]=h;b=J[g+8>>2];a=J[g+12>>2]<<4|b>>>28;b=b<<4;c=J[g>>2];h=J[g+4>>2];b=h>>>28|b;d=h&268435455;c=c|(J[g+16>>2]|J[g+24>>2]|(J[g+20>>2]|J[g+28>>2]))!=0;if((d|0)==134217728&(c|0)!=0|d>>>0>134217728){b=b+1|0;a=b?a:a+1|0;break a}if(c|(d|0)!=134217728){break a}c=b;b=b+(b&1)|0;a=c>>>0>b>>>0?a+1|0:a}La=g+32|0;x(0,b|0);x(1,m&-2147483648|a);q=o,r=+z(),O[q>>3]=r}function Pd(a,b){var c=0,d=Q(0),e=Q(0),f=0,g=0,h=Q(0),i=0,j=Q(0),k=0,l=0,m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=0,y=Q(0);J[a+24>>2]=J[a+24>>2]+1;c=J[a>>2];if((c|0)==-1){J[a>>2]=b;J[(J[a+4>>2]+P(b,40)|0)+20>>2]=-1;return}i=J[a+4>>2];g=i+P(b,40)|0;n=N[g+12>>2];o=N[g+8>>2];p=N[g+4>>2];q=N[g>>2];while(1){k=c;c=i+P(c,40)|0;g=J[c+24>>2];if((g|0)!=-1){m=N[c+8>>2];j=N[c>>2];h=N[c+12>>2];d=N[c+4>>2];e=Q(Q((on?h:n)-(d>2];t=o>s?o:s;u=N[f+4>>2];v=p>2];j=q>2];d=h>2];a:{if(J[f+24>>2]==-1){d=Q(Q(t-j)+Q(d-v));h=Q(d+d);break a}d=Q(Q(t-j)+Q(d-v));w=Q(d+d);d=Q(Q(s-m)+Q(h-u));h=Q(w-Q(d+d))}y=Q(r+r);f=i+P(c,40)|0;r=N[f+8>>2];s=o>r?o:r;t=N[f+4>>2];u=p>2];m=q>2];d=j>2]==-1){d=Q(Q(s-m)+Q(d-u));w=Q(d+d);break b}d=Q(Q(s-m)+Q(d-u));w=Q(d+d);d=Q(Q(r-v)+Q(j-t));w=Q(w-Q(d+d))}e=Q(e+w);c=hy)|!(e>y)){continue}}break}f=P(k,40);i=J[(f+i|0)+20>>2];x=Qd(a);g=P(x,40);J[(g+J[a+4>>2]|0)+20>>2]=i;c=J[a+4>>2];l=c+g|0;J[l+16>>2]=0;c=c+f|0;d=N[c>>2];e=N[c+4>>2];N[l+4>>2]=e>p?p:e;N[l>>2]=d>q?q:d;d=N[c+8>>2];e=N[c+12>>2];N[l+12>>2]=e>2]=d>2];l=c+g|0;g=c+f|0;J[l+32>>2]=J[g+32>>2]+1;c:{if((i|0)!=-1){c=c+P(i,40)|0;J[((k|0)==J[c+24>>2]?c+24|0:c+28|0)>>2]=x;J[l+28>>2]=b;J[l+24>>2]=k;J[g+20>>2]=x;c=(J[a+4>>2]+P(b,40)|0)+20|0;break c}J[l+28>>2]=b;J[l+24>>2]=k;J[g+20>>2]=x;J[(J[a+4>>2]+P(b,40)|0)+20>>2]=x;c=a}J[c>>2]=x;c=J[(J[a+4>>2]+P(b,40)|0)+20>>2];if((c|0)!=-1){while(1){b=Od(a,c);k=J[a+4>>2];c=P(b,40);i=k+c|0;f=P(J[i+24>>2],40)+k|0;g=J[f+32>>2];k=k+P(J[i+28>>2],40)|0;b=J[k+32>>2];J[i+32>>2]=((b|0)<(g|0)?g:b)+1;j=N[k>>2];h=N[f>>2];d=N[f+4>>2];e=N[k+4>>2];N[i+4>>2]=d>2]=h>2];h=N[k+8>>2];d=N[f+12>>2];e=N[k+12>>2];N[i+12>>2]=d>e?d:e;N[i+8>>2]=h>2]|0)+20>>2];if((c|0)!=-1){continue}break}}}function Kg(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=0,j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=0;y=J[b+28>>2];i=y+P(J[a+148>>2],12)|0;l=N[i+8>>2];m=N[i+4>>2];n=N[i>>2];i=P(J[a+144>>2],12)+y|0;d=N[i+8>>2];g=N[i+4>>2];f=N[i>>2];w=N[a+180>>2];x=N[a+176>>2];r=N[a+172>>2];s=N[a+168>>2];if(K[a+141|0]){c=Q(N[b>>2]*N[a+132>>2]);h=Q(-c);j=N[a+112>>2];k=N[a+212>>2];o=N[a+184>>2];e=N[a+188>>2];p=N[a+208>>2];t=Q(j+Q(N[a+236>>2]*Q(N[a+136>>2]-Q(Q(Q(k*l)+Q(Q(o*Q(n-f))+Q(Q(m-g)*e)))-Q(p*d)))));c=c>t?t:c;c=c>2]=c;c=Q(c-j);l=Q(Q(w*Q(k*c))+l);h=Q(e*c);m=Q(m+Q(r*h));j=Q(o*c);n=Q(n+Q(r*j));g=Q(g-Q(s*h));f=Q(f-Q(s*j));d=Q(d-Q(x*Q(p*c)))}if(K[a+140|0]){o=N[a+116>>2];e=N[a+236>>2];p=N[a+232>>2];c=Q(p-N[a+124>>2]);t=N[b+4>>2];q=Q((c>Q(0)?c:Q(0))*t);c=N[a+212>>2];h=N[a+184>>2];j=N[a+188>>2];k=N[a+208>>2];u=Q(o-Q(e*Q(q+Q(Q(Q(c*l)+Q(Q(h*Q(n-f))+Q(Q(m-g)*j)))-Q(k*d)))));u=u>Q(0)?u:Q(0);N[a+116>>2]=u;v=N[a+120>>2];q=e;e=Q(N[a+128>>2]-p);p=Q(t*(e>Q(0)?e:Q(0)));e=d;d=Q(u-o);o=Q(e-Q(x*Q(k*d)));e=f;f=Q(h*d);e=Q(e-Q(s*f));n=Q(n+Q(r*f));f=g;g=Q(j*d);f=Q(f-Q(s*g));m=Q(m+Q(r*g));l=Q(Q(w*Q(c*d))+l);d=Q(v-Q(q*Q(p+Q(Q(Q(k*o)+Q(Q(h*Q(e-n))+Q(j*Q(f-m))))-Q(c*l)))));d=d>Q(0)?d:Q(0);N[a+120>>2]=d;d=Q(d-v);l=Q(l-Q(w*Q(c*d)));g=Q(j*d);m=Q(m-Q(r*g));c=Q(h*d);n=Q(n-Q(r*c));g=Q(f+Q(s*g));f=Q(e+Q(s*c));d=Q(Q(x*Q(k*d))+o)}j=N[a+216>>2];k=N[a+228>>2];o=N[a+220>>2];e=N[a+224>>2];c=Q(Q(j*k)-Q(o*e));h=c!=Q(0)?Q(Q(1)/c):c;p=Q(l-d);c=Q(p*e);q=k;k=N[a+204>>2];e=N[a+192>>2];t=N[a+196>>2];u=N[a+200>>2];v=Q(Q(Q(k*l)+Q(Q(e*Q(n-f))+Q(Q(m-g)*t)))-Q(u*d));c=Q(Q(c-Q(q*v))*h);N[a+104>>2]=N[a+104>>2]+c;h=Q(Q(Q(v*o)-Q(j*p))*h);N[a+108>>2]=N[a+108>>2]+h;q=g;g=Q(t*c);N[i+4>>2]=q-Q(s*g);q=f;f=Q(e*c);N[i>>2]=q-Q(s*f);i=J[b+28>>2];N[(i+P(J[a+144>>2],12)|0)+8>>2]=Q(Q(-x)*Q(Q(c*u)+h))+d;i=i+P(J[a+148>>2],12)|0;N[i+4>>2]=m+Q(r*g);N[i>>2]=n+Q(r*f);N[(J[b+28>>2]+P(J[a+148>>2],12)|0)+8>>2]=Q(w*Q(Q(c*k)+h))+l}function zg(a,b){a=a|0;b=b|0;var c=Q(0),d=0,e=Q(0),f=Q(0),g=Q(0),h=0,i=Q(0),j=Q(0),k=0,l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=0,r=0,s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=0,x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=Q(0),C=Q(0),D=Q(0),E=Q(0);d=J[a+48>>2];w=J[d+8>>2];J[a+120>>2]=w;k=J[a+52>>2];q=J[k+8>>2];J[a+124>>2]=q;o=N[d+32>>2];h=J[d+32>>2];c=N[d+28>>2];r=J[d+28>>2];J[a+160>>2]=r;J[a+164>>2]=h;s=N[k+32>>2];h=J[k+32>>2];j=N[k+28>>2];J[a+168>>2]=J[k+28>>2];J[a+172>>2]=h;t=N[d+120>>2];N[a+176>>2]=t;u=N[k+120>>2];N[a+180>>2]=u;x=N[d+128>>2];N[a+184>>2]=x;y=N[k+128>>2];N[a+188>>2]=y;p=N[a+96>>2];k=J[b+24>>2];d=P(w,12);r=k+d|0;e=N[r+8>>2];g=Za(e);l=N[a+92>>2];e=_a(e);h=J[b+28>>2];d=d+h|0;z=N[d>>2];A=N[d+4>>2];B=N[d+8>>2];q=P(q,12);d=q+h|0;C=N[d>>2];D=N[d+4>>2];E=N[d+8>>2];d=k+q|0;m=N[d>>2];f=N[d+4>>2];n=N[r>>2];v=N[r+4>>2];i=N[d+8>>2];c=Q(l-c);l=Q(p-o);p=Q(Q(e*c)-Q(g*l));N[a+144>>2]=p;l=Q(Q(g*c)+Q(e*l));N[a+148>>2]=l;e=N[a+104>>2];g=Za(i);c=N[a+100>>2];i=_a(i);c=Q(c-j);e=Q(e-s);j=Q(Q(i*c)-Q(g*e));N[a+152>>2]=j;o=Q(Q(g*c)+Q(i*e));N[a+156>>2]=o;m=Q(Q(m+j)-N[a+76>>2]);f=Q(Q(f+o)-N[a+80>>2]);s=Q(Y(Q(Q(m*m)+Q(f*f))));g=Q(0);e=Q(0);i=Q(0);c=Q(Q(n+p)-N[a+68>>2]);n=Q(Q(v+l)-N[a+72>>2]);v=Q(Y(Q(Q(c*c)+Q(n*n))));if(v>Q(.04999999701976776)){e=Q(Q(1)/v);i=Q(n*e);e=Q(c*e)}N[a+132>>2]=i;N[a+128>>2]=e;c=Q(0);if(s>Q(.04999999701976776)){g=Q(Q(1)/s);c=Q(f*g);g=Q(m*g)}N[a+140>>2]=c;N[a+136>>2]=g;m=N[a+112>>2];f=Q(Q(j*c)-Q(g*o));n=Q(Q(m*m)*Q(Q(Q(y*f)*f)+u));f=Q(Q(p*i)-Q(e*l));f=Q(n+Q(Q(Q(x*f)*f)+t));N[a+192>>2]=f>Q(0)?Q(Q(1)/f):f;a:{if(K[b+20|0]){f=Q(N[b+8>>2]*N[a+116>>2]);N[a+116>>2]=f;n=j;j=c;c=Q(f*Q(-m));j=Q(j*c);g=Q(g*c);E=Q(Q(y*Q(Q(n*j)+Q(g*Q(-o))))+E);c=i;i=Q(-f);c=Q(c*i);e=Q(e*i);B=Q(Q(x*Q(Q(p*c)+Q(e*Q(-l))))+B);D=Q(D+Q(u*j));C=Q(C+Q(u*g));A=Q(A+Q(t*c));z=Q(z+Q(t*e));break a}J[a+116>>2]=0}h=J[b+28>>2]+P(w,12)|0;N[h+4>>2]=A;N[h>>2]=z;h=J[b+28>>2];N[(h+P(J[a+120>>2],12)|0)+8>>2]=B;h=h+P(J[a+124>>2],12)|0;N[h+4>>2]=D;N[h>>2]=C;N[(J[b+28>>2]+P(J[a+124>>2],12)|0)+8>>2]=E}function Cf(a){a=a|0;var b=0,c=0,d=0,e=0,f=0,g=0,h=0,i=Q(0);g=La-48|0;La=g;if(!K[a+102989|0]){h=La-16|0;La=h;a:{b:{if(!Lb(5151,H[1373])){J[6204]=28;break b}b=2;if(!Lb(1373,43)){b=K[1373]!=114}b=Lb(1373,120)?b|128:b;b=Lb(1373,101)?b|524288:b;e=b;d=b|64;b=K[1373];d=(b|0)==114?e:d;d=(b|0)==119?d|512:d;J[h>>2]=438;J[h+4>>2]=0;b=Ga(-100,3236,((b|0)==97?d|1024:d)|32768,h|0)|0;if(b>>>0>=4294963201){J[6204]=0-b;b=-1}if((b|0)<0){break a}d=La-32|0;La=d;c:{d:{e:{if(!Lb(5151,H[1373])){J[6204]=28;break e}c=fb(1176);if(c){break d}}c=0;break c}Db(c,0,144);if(!Lb(1373,43)){J[c>>2]=K[1373]==114?8:4}f:{if(K[1373]!=97){e=J[c>>2];break f}e=sa(b|0,3,0)|0;if(!(e&1024)){e=e|1024;J[d+16>>2]=e;J[d+20>>2]=e>>31;sa(b|0,4,d+16|0)|0}e=J[c>>2]|128;J[c>>2]=e}J[c+80>>2]=-1;J[c+48>>2]=1024;J[c+60>>2]=b;J[c+44>>2]=c+152;g:{if(e&8){break g}J[d>>2]=d+24;J[d+4>>2]=0;if(Fa(b|0,21523,d|0)|0){break g}J[c+80>>2]=10}J[c+40>>2]=920;J[c+36>>2]=921;J[c+32>>2]=922;J[c+12>>2]=923;if(!K[24821]){J[c+76>>2]=-1}J[c+56>>2]=J[6220];e=J[6220];if(e){J[e+52>>2]=c}J[6220]=c}La=d+32|0;if(c){break a}qa(b|0)|0}c=0}La=h+16|0;J[6142]=c;i=N[a+102964>>2];O[g+40>>3]=N[a+102968>>2];O[g+32>>3]=i;Ya(8451,g+32|0);Ya(8474,0);J[g+16>>2]=J[a+102956>>2];Ya(9119,g+16|0);J[g>>2]=J[a+102960>>2];Ya(9179,g);b=J[a+102948>>2];if(b){while(1){J[b+8>>2]=f;Kd(b);f=f+1|0;b=J[b+96>>2];if(b){continue}break}}c=J[a+102952>>2];h:{if(!c){break h}b=0;f=c;while(1){J[f+56>>2]=b;b=b+1|0;f=J[f+12>>2];if(f){continue}break}if(!c){break h}while(1){if(J[c+4>>2]!=6){Ya(6540,0);Na[J[J[c>>2]+16>>2]](c);Ya(6535,0)}c=J[c+12>>2];if(c){continue}break}b=J[a+102952>>2];if(!b){break h}while(1){if(J[b+4>>2]==6){Ya(6540,0);Na[J[J[b>>2]+16>>2]](b);Ya(6535,0)}b=J[b+12>>2];if(b){continue}break}}Ya(7836,0);Ya(7853,0);Ya(6543,0);Ya(6562,0);a=J[6142];dc(a);Na[J[a+12>>2]](a)|0;if(!(H[a|0]&1)){c=J[a+52>>2];if(c){J[c+56>>2]=J[a+56>>2]}f=J[a+56>>2];if(f){J[f+52>>2]=c}if((a|0)==J[6220]){J[6220]=f}ab(J[a+96>>2]);ab(a)}J[6142]=0}La=g+48|0}function Lh(a,b){a=a|0;b=b|0;var c=Q(0),d=0,e=Q(0),f=Q(0),g=0,h=Q(0),i=0,j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=0,p=0,q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=0,v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=Q(0),C=Q(0),D=Q(0),E=Q(0),F=Q(0);d=J[a+48>>2];u=J[d+8>>2];J[a+108>>2]=u;i=J[a+52>>2];o=J[i+8>>2];J[a+112>>2]=o;E=N[d+32>>2];g=J[d+32>>2];m=N[d+28>>2];p=J[d+28>>2];J[a+140>>2]=p;J[a+144>>2]=g;F=N[i+32>>2];g=J[i+32>>2];n=N[i+28>>2];J[a+148>>2]=J[i+28>>2];J[a+152>>2]=g;s=N[d+120>>2];N[a+156>>2]=s;t=N[i+120>>2];N[a+160>>2]=t;v=N[d+128>>2];N[a+164>>2]=v;w=N[i+128>>2];N[a+168>>2]=w;j=N[a+84>>2];i=J[b+24>>2];d=P(u,12);p=i+d|0;e=N[p+8>>2];f=Za(e);h=N[a+80>>2];e=_a(e);g=J[b+28>>2];d=d+g|0;x=N[d>>2];y=N[d+4>>2];z=N[d+8>>2];o=P(o,12);d=o+g|0;A=N[d>>2];B=N[d+4>>2];C=N[d+8>>2];k=N[p>>2];d=i+o|0;q=N[d>>2];r=N[p+4>>2];l=N[d+4>>2];c=N[d+8>>2];h=Q(h-m);j=Q(j-E);m=Q(Q(e*h)-Q(f*j));N[a+124>>2]=m;j=Q(Q(f*h)+Q(e*j));N[a+128>>2]=j;e=N[a+92>>2];f=Za(c);h=N[a+88>>2];c=_a(c);h=Q(h-n);e=Q(e-F);n=Q(Q(c*h)-Q(f*e));N[a+132>>2]=n;h=Q(Q(f*h)+Q(c*e));N[a+136>>2]=h;f=Q(0);e=Q(0);c=Q(Q(Q(q+n)-k)-m);k=Q(Q(Q(l+h)-r)-j);q=Q(Y(Q(Q(c*c)+Q(k*k))));if(q>Q(.004999999888241291)){f=Q(Q(1)/q);e=Q(k*f);f=Q(c*f)}N[a+120>>2]=e;N[a+116>>2]=f;c=Q(Q(n*e)-Q(f*h));l=Q(Q(w*c)*c);c=Q(Q(m*e)-Q(f*j));c=Q(l+Q(t+Q(Q(Q(v*c)*c)+s)));k=N[a+68>>2];if(k>Q(0)){l=c;r=N[b>>2];c=Q(r*Q(Q(r*k)+N[a+72>>2]));D=c!=Q(0)?Q(Q(1)/c):Q(0);c=Q(l+D);l=Q(Q(k*Q(Q(q-N[a+104>>2])*r))*D)}else{l=Q(0)}N[a+76>>2]=l;N[a+96>>2]=D;N[a+172>>2]=c!=Q(0)?Q(Q(1)/c):Q(0);a:{if(K[b+20|0]){c=Q(N[b+8>>2]*N[a+100>>2]);N[a+100>>2]=c;e=Q(e*c);f=Q(f*c);C=Q(Q(w*Q(Q(n*e)+Q(f*Q(-h))))+C);z=Q(z-Q(v*Q(Q(m*e)+Q(f*Q(-j)))));B=Q(B+Q(t*e));A=Q(A+Q(t*f));y=Q(y-Q(s*e));x=Q(x-Q(s*f));break a}J[a+100>>2]=0}g=J[b+28>>2]+P(u,12)|0;N[g+4>>2]=y;N[g>>2]=x;g=J[b+28>>2];N[(g+P(J[a+108>>2],12)|0)+8>>2]=z;g=g+P(J[a+112>>2],12)|0;N[g+4>>2]=B;N[g>>2]=A;N[(J[b+28>>2]+P(J[a+112>>2],12)|0)+8>>2]=C}function tg(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=0,g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=0,p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=0,u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=0,B=0,C=Q(0);f=J[a+48>>2];t=J[f+8>>2];J[a+132>>2]=t;c=J[a+52>>2];A=J[c+8>>2];J[a+136>>2]=A;n=N[f+32>>2];B=J[f+32>>2];l=N[f+28>>2];o=J[f+28>>2];J[a+156>>2]=o;J[a+160>>2]=B;C=N[c+32>>2];o=J[c+32>>2];i=N[c+28>>2];J[a+164>>2]=J[c+28>>2];J[a+168>>2]=o;r=N[f+120>>2];N[a+172>>2]=r;s=N[c+120>>2];N[a+176>>2]=s;p=N[f+128>>2];N[a+180>>2]=p;k=N[c+128>>2];N[a+184>>2]=k;d=N[a+72>>2];o=J[b+24>>2];c=P(t,12);q=N[(o+c|0)+8>>2];j=Za(q);g=N[a+68>>2];h=_a(q);f=J[b+28>>2];c=c+f|0;u=N[c>>2];v=N[c+4>>2];w=N[c+8>>2];c=f;f=P(A,12);c=c+f|0;x=N[c>>2];y=N[c+4>>2];z=N[c+8>>2];e=N[(f+o|0)+8>>2];g=Q(g-l);d=Q(d-n);l=Q(Q(h*g)-Q(j*d));N[a+140>>2]=l;d=Q(Q(j*g)+Q(h*d));N[a+144>>2]=d;g=Q(p+k);c=g>Q(0);N[a+208>>2]=c?Q(Q(1)/g):g;j=N[a+80>>2];h=Za(e);m=N[a+76>>2];n=_a(e);i=Q(m-i);m=Q(j-C);j=Q(Q(n*i)-Q(h*m));N[a+148>>2]=j;h=Q(Q(h*i)+Q(n*m));N[a+152>>2]=h;i=Q(r+s);N[a+188>>2]=Q(k*Q(h*h))+Q(Q(p*Q(d*d))+i);m=Q(-d);d=Q(Q(p*Q(l*m))-Q(k*Q(j*h)));N[a+196>>2]=d;N[a+192>>2]=d;N[a+200>>2]=Q(k*Q(j*j))+Q(Q(p*Q(l*l))+i);N[a+204>>2]=Q(e-q)-N[a+120>>2];if(!(K[a+116|0]?c:0)){J[a+96>>2]=0;J[a+100>>2]=0}if(!(K[a+104|0]?g>Q(0):0)){J[a+92>>2]=0}a:{if(K[b+20|0]){e=N[b+8>>2];d=Q(e*N[a+84>>2]);N[a+84>>2]=d;g=Q(e*N[a+92>>2]);N[a+92>>2]=g;q=Q(e*N[a+96>>2]);N[a+96>>2]=q;i=Q(e*N[a+100>>2]);N[a+100>>2]=i;e=Q(e*N[a+88>>2]);N[a+88>>2]=e;n=k;k=Q(Q(g+q)-i);z=Q(Q(n*Q(k+Q(Q(j*e)+Q(d*Q(-h)))))+z);w=Q(w-Q(p*Q(k+Q(Q(l*e)+Q(d*m)))));x=Q(x+Q(s*d));u=Q(u-Q(r*d));y=Q(y+Q(s*e));v=Q(v-Q(r*e));break a}J[a+84>>2]=0;J[a+88>>2]=0;J[a+100>>2]=0;J[a+92>>2]=0;J[a+96>>2]=0}c=J[b+28>>2]+P(t,12)|0;N[c+4>>2]=v;N[c>>2]=u;c=J[b+28>>2];N[(c+P(J[a+132>>2],12)|0)+8>>2]=w;c=c+P(J[a+136>>2],12)|0;N[c+4>>2]=y;N[c>>2]=x;N[(J[b+28>>2]+P(J[a+136>>2],12)|0)+8>>2]=z}function Xf(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=0,i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=0,p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=Q(0),C=Q(0);c=La-80|0;La=c;h=J[b+24>>2];o=h+P(J[a+116>>2],12)|0;w=N[o>>2];h=h+P(J[a+120>>2],12)|0;x=N[h>>2];y=N[o+4>>2];z=N[h+4>>2];q=N[o+8>>2];j=N[a+144>>2];l=N[a+84>>2];r=N[h+8>>2];i=N[a+152>>2];s=N[a+92>>2];u=N[a+160>>2];v=N[a+156>>2];m=N[a+140>>2];p=N[a+80>>2];n=N[a+148>>2];t=N[a+88>>2];k=N[a+164>>2];e=N[a+168>>2];A=Q(k+e);N[c+76>>2]=A;g=Za(r);f=_a(r);d=Za(q);B=_a(q);m=Q(p-m);p=Q(l-j);l=Q(Q(B*m)-Q(d*p));n=Q(t-n);t=Q(s-i);j=Q(Q(f*n)-Q(g*t));i=Q(Q(k*l)+Q(e*j));N[c+72>>2]=i;N[c- -64>>2]=i;C=Q(v+u);N[c+60>>2]=Q(e*Q(j*j))+Q(Q(k*Q(l*l))+C);i=Q(Q(d*m)+Q(B*p));s=Q(-i);d=Q(Q(g*n)+Q(f*t));g=Q(Q(k*s)-Q(e*d));N[c+68>>2]=g;N[c+52>>2]=g;g=Q(Q(k*Q(l*s))-Q(e*Q(j*d)));N[c+56>>2]=g;N[c+44>>2]=Q(e*Q(d*d))+Q(Q(k*Q(i*i))+C);N[c+48>>2]=g;g=Q(Q(Q(z+d)-y)-i);f=Q(Q(Q(x+j)-w)-l);a:{if(N[a+68>>2]>Q(0)){N[c+24>>2]=f;N[c+28>>2]=g;Sd(c+12|0,c+44|0,c+24|0);n=e;m=d;d=N[c+12>>2];e=N[c+16>>2];j=Q(Q(n*Q(Q(m*d)-Q(j*e)))+r);k=Q(q-Q(k*Q(Q(i*d)-Q(l*e))));i=Q(Y(Q(Q(f*f)+Q(g*g))));e=Q(-e);f=Q(-d);o=1;break a}m=Q(-d);N[c+40>>2]=g;N[c+36>>2]=f;d=N[a+96>>2];N[c+28>>2]=g;N[c+24>>2]=f;d=Q(Q(r-q)-d);N[c+32>>2]=d;p=d>Q(0)?d:Q(-d);i=Q(Y(Q(Q(f*f)+Q(g*g))));n=e;b:{if(A>Q(0)){Td(c+12|0,c+44|0,c+24|0);d=Q(-N[c+20>>2]);f=Q(-N[c+12>>2]);e=Q(-N[c+16>>2]);break b}Sd(c+12|0,c+44|0,c+36|0);f=Q(-N[c+12>>2]);d=Q(0);e=Q(-N[c+16>>2])}j=Q(Q(n*Q(Q(Q(j*e)+Q(f*m))+d))+r);k=Q(q-Q(k*Q(Q(Q(l*e)+Q(f*s))+d)));o=p<=Q(.03490658849477768)}h=J[b+24>>2]+P(J[a+116>>2],12)|0;N[h+4>>2]=y-Q(v*e);N[h>>2]=w-Q(v*f);h=J[b+24>>2];N[(h+P(J[a+116>>2],12)|0)+8>>2]=k;h=h+P(J[a+120>>2],12)|0;N[h+4>>2]=z+Q(u*e);N[h>>2]=x+Q(u*f);N[(J[b+24>>2]+P(J[a+120>>2],12)|0)+8>>2]=j;La=c+80|0;return o&i<=Q(.004999999888241291)}function Tf(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=0,i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=0,z=Q(0);n=N[a+176>>2];s=N[a+180>>2];u=N[a+188>>2];t=N[a+184>>2];c=N[a+108>>2];f=N[a+212>>2];h=J[b+28>>2];y=h+P(J[a+156>>2],12)|0;i=N[y+8>>2];k=N[a+192>>2];d=N[y>>2];h=h+P(J[a+152>>2],12)|0;g=N[h>>2];o=N[y+4>>2];q=N[h+4>>2];l=N[a+196>>2];m=N[a+208>>2];p=N[h+8>>2];j=Q(Q(Q(c*N[a+244>>2])+Q(Q(Q(Q(f*i)+Q(Q(k*Q(d-g))+Q(Q(o-q)*l)))-Q(m*p))+N[a+240>>2]))*Q(-N[a+236>>2]));N[a+108>>2]=c+j;c=Q(N[b>>2]*N[a+132>>2]);e=Q(-c);v=N[a+104>>2];i=Q(i+Q(u*Q(f*j)));p=Q(p-Q(t*Q(m*j)));r=Q(v-Q(N[a+228>>2]*Q(Q(i-p)-N[a+136>>2])));c=c>r?r:c;c=c>2]=c;e=Q(c-v);c=Q(Q(u*e)+i);i=Q(p-Q(t*e));p=Q(l*j);o=Q(o+Q(s*p));e=Q(k*j);j=Q(d+Q(s*e));d=Q(q-Q(n*p));g=Q(g-Q(n*e));p=Q(-t);if(K[a+140|0]){q=N[a+112>>2];e=N[a+232>>2];v=N[a+120>>2];r=Q(v-N[a+124>>2]);w=r>Q(0)?r:Q(0);r=N[b+4>>2];x=Q(q-Q(e*Q(Q(w*r)+Q(Q(Q(-m)*i)+Q(Q(f*c)+Q(Q(k*Q(j-g))+Q(l*Q(o-d))))))));x=x>Q(0)?x:Q(0);N[a+112>>2]=x;z=N[a+116>>2];w=e;e=Q(N[a+128>>2]-v);r=Q(r*(e>Q(0)?e:Q(0)));q=Q(x-q);i=Q(Q(p*Q(m*q))+i);e=g;g=Q(k*q);e=Q(e-Q(n*g));j=Q(j+Q(s*g));g=d;d=Q(l*q);g=Q(g-Q(n*d));o=Q(o+Q(s*d));c=Q(Q(u*Q(f*q))+c);d=Q(z-Q(w*Q(r+Q(Q(Q(m*i)+Q(Q(k*Q(e-j))+Q(l*Q(g-o))))-Q(f*c)))));d=d>Q(0)?d:Q(0);N[a+116>>2]=d;w=f;f=Q(d-z);c=Q(c-Q(u*Q(w*f)));l=Q(l*f);o=Q(o-Q(s*l));k=Q(k*f);j=Q(j-Q(s*k));d=Q(g+Q(n*l));g=Q(e+Q(n*k));i=Q(Q(t*Q(m*f))+i)}k=N[a+220>>2];l=N[a+200>>2];m=N[a+204>>2];t=N[a+216>>2];f=Q(Q(Q(Q(k*c)+Q(Q(l*Q(j-g))+Q(Q(o-d)*m)))-Q(t*i))*Q(-N[a+224>>2]));N[a+100>>2]=N[a+100>>2]+f;m=Q(m*f);N[h+4>>2]=d-Q(n*m);d=n;n=Q(l*f);N[h>>2]=g-Q(d*n);h=J[b+28>>2];N[(h+P(J[a+152>>2],12)|0)+8>>2]=Q(p*Q(t*f))+i;h=h+P(J[a+156>>2],12)|0;N[h+4>>2]=o+Q(s*m);N[h>>2]=j+Q(s*n);N[(J[b+28>>2]+P(J[a+156>>2],12)|0)+8>>2]=Q(u*Q(k*f))+c}function nh(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=0,f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=0,k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=0,q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=0,w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=Q(0),C=Q(0),D=Q(0),E=0,F=Q(0);e=J[a+48>>2];v=J[e+8>>2];J[a+104>>2]=v;j=J[a+52>>2];p=J[j+8>>2];J[a+108>>2]=p;D=N[e+32>>2];c=J[e+32>>2];f=N[e+28>>2];J[a+128>>2]=J[e+28>>2];J[a+132>>2]=c;k=N[j+32>>2];E=J[j+32>>2];i=N[j+28>>2];c=J[j+28>>2];J[a+136>>2]=c;J[a+140>>2]=E;r=N[e+120>>2];N[a+156>>2]=r;s=N[j+120>>2];N[a+160>>2]=s;d=N[e+128>>2];N[a+164>>2]=d;q=N[j+128>>2];N[a+168>>2]=q;e=J[b+28>>2];j=P(p,12);c=e+j|0;w=N[c+8>>2];x=N[c+4>>2];y=N[c>>2];p=P(v,12);c=e+p|0;z=N[c+8>>2];A=N[c+4>>2];B=N[c>>2];e=J[b+24>>2];c=e+p|0;o=N[c>>2];e=e+j|0;t=N[e>>2];u=N[c+4>>2];F=N[e+4>>2];g=N[c+8>>2];n=N[e+8>>2];l=Q(d+q);N[a+188>>2]=l>Q(0)?Q(Q(1)/l):l;h=_a(n);m=Za(n);l=Q(Q(m*Q(-i))-Q(h*k));N[a+124>>2]=l;m=Q(Q(m*k)-Q(h*i));N[a+120>>2]=m;i=N[a+72>>2];h=_a(g);k=N[a+68>>2];C=Za(g);f=Q(k-f);k=Q(i-D);i=Q(Q(C*f)+Q(h*k));N[a+116>>2]=i;h=Q(Q(h*f)-Q(k*C));N[a+112>>2]=h;N[a+148>>2]=Q(Q(F+l)-u)-i;N[a+144>>2]=Q(Q(t+m)-o)-h;f=Q(r+s);o=Q(Q(Q(q*l)*l)+Q(Q(Q(d*i)*i)+f));k=o;o=Q(q*m);t=Q(Q(o*m)+Q(Q(Q(d*h)*h)+f));u=Q(-d);d=Q(Q(Q(h*u)*i)-Q(l*o));f=Q(Q(k*t)-Q(d*d));f=f!=Q(0)?Q(Q(1)/f):f;N[a+184>>2]=k*f;N[a+172>>2]=t*f;d=Q(d*Q(-f));N[a+180>>2]=d;N[a+176>>2]=d;N[a+152>>2]=Q(n-g)-N[a+76>>2];a:{if(K[b+20|0]){g=N[b+8>>2];d=Q(g*N[a+80>>2]);N[a+80>>2]=d;n=Q(g*N[a+88>>2]);N[a+88>>2]=n;g=Q(g*N[a+84>>2]);N[a+84>>2]=g;w=Q(Q(q*Q(Q(Q(m*g)-Q(d*l))+n))+w);z=Q(Q(u*Q(Q(Q(h*g)-Q(d*i))+n))+z);y=Q(y+Q(s*d));B=Q(B-Q(r*d));x=Q(x+Q(s*g));A=Q(A-Q(r*g));break a}J[a+88>>2]=0;J[a+80>>2]=0;J[a+84>>2]=0}c=J[b+28>>2]+P(v,12)|0;N[c+4>>2]=A;N[c>>2]=B;c=J[b+28>>2];N[(c+P(J[a+104>>2],12)|0)+8>>2]=z;c=c+P(J[a+108>>2],12)|0;N[c+4>>2]=x;N[c>>2]=y;N[(J[b+28>>2]+P(J[a+108>>2],12)|0)+8>>2]=w}function Pg(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=Q(0),f=Q(0),g=0,h=Q(0),i=Q(0),j=0,k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=0,p=0,q=Q(0),r=0,s=0,t=0;g=J[J[a+48>>2]+12>>2];p=J[J[a+52>>2]+12>>2];J[b+60>>2]=0;e=N[c+12>>2];f=N[d+8>>2];h=N[p+12>>2];l=N[d+12>>2];m=N[p+16>>2];n=Q(Q(Q(Q(f*h)+Q(l*m))+N[d+4>>2])-N[c+4>>2]);i=N[c+8>>2];f=Q(Q(N[d>>2]+Q(Q(l*h)-Q(m*f)))-N[c>>2]);q=Q(Q(e*n)-Q(i*f));n=Q(Q(e*f)+Q(n*i));d=g+84|0;o=g+20|0;e=Q(N[g+8>>2]+N[p+8>>2]);a=1;c=0;g=J[g+148>>2];a:{if((g|0)>0){f=Q(-34028234663852886e22);a=0;while(1){j=a<<3;r=j+d|0;j=j+o|0;h=Q(Q(N[r>>2]*Q(n-N[j>>2]))+Q(Q(q-N[j+4>>2])*N[r+4>>2]));if(h>e){break a}j=f(j|0)?j:0)<<3)|0;j=J[g+4>>2];f=N[g+4>>2];r=J[g>>2];h=N[g>>2];g=o;o=c<<3;g=g+o|0;s=J[g+4>>2];l=N[g+4>>2];t=J[g>>2];m=N[g>>2];b:{if(a){J[b+56>>2]=1;J[b+60>>2]=1;a=d+o|0;c=J[a>>2];a=J[a+4>>2];N[b+52>>2]=Q(l+f)*Q(.5);N[b+48>>2]=Q(m+h)*Q(.5);J[b+40>>2]=c;J[b+44>>2]=a;break b}i=Q(n-m);k=Q(q-l);if(Q(Q(i*Q(h-m))+Q(k*Q(f-l)))<=Q(0)){f=Q(e*e);e=Q(Q(i*i)+Q(k*k));if(f>2]=1;J[b+60>>2]=1;N[b+40>>2]=i;N[b+44>>2]=k;e=Q(Y(e));if(!(e>2]=k*e;N[b+40>>2]=i*e}J[b+48>>2]=t;J[b+52>>2]=s;break b}i=Q(n-h);k=Q(q-f);if(Q(Q(i*Q(m-h))+Q(k*Q(l-f)))<=Q(0)){f=Q(e*e);e=Q(Q(i*i)+Q(k*k));if(f>2]=1;J[b+60>>2]=1;N[b+40>>2]=i;N[b+44>>2]=k;e=Q(Y(e));if(!(e>2]=k*e;N[b+40>>2]=i*e}J[b+48>>2]=r;J[b+52>>2]=j;break b}h=Q(Q(m+h)*Q(.5));a=d+(c<<3)|0;f=Q(Q(l+f)*Q(.5));if(e>2])+Q(Q(q-f)*N[a+4>>2]))){break a}J[b+56>>2]=1;J[b+60>>2]=1;c=J[a+4>>2];a=J[a>>2];N[b+52>>2]=f;N[b+48>>2]=h;J[b+40>>2]=a;J[b+44>>2]=c}a=J[p+16>>2];c=J[p+12>>2];J[b+16>>2]=0;J[b>>2]=c;J[b+4>>2]=a}}function id(a,b){var c=0,d=0,e=0,f=0,g=Q(0),h=0,i=0,j=Q(0),k=0,l=Q(0),m=0,n=0,o=0;c=J[b+4>>2];J[a>>2]=J[b>>2];J[a+4>>2]=c;c=J[b+20>>2];J[a+16>>2]=J[b+16>>2];J[a+20>>2]=c;c=J[b+12>>2];J[a+8>>2]=J[b+8>>2];J[a+12>>2]=c;c=J[b+40>>2];J[a+32>>2]=c;d=J[b+28>>2];J[a+48>>2]=d;n=a,o=Fb(c,P(d,88)),J[n+36>>2]=o;n=a,o=Fb(J[a+32>>2],P(J[a+48>>2],156)),J[n+40>>2]=o;J[a+24>>2]=J[b+32>>2];J[a+28>>2]=J[b+36>>2];J[a+44>>2]=J[b+24>>2];if(J[a+48>>2]>0){while(1){b=J[J[a+44>>2]+(h<<2)>>2];c=J[b+48>>2];j=N[J[c+12>>2]+8>>2];d=J[b+52>>2];g=N[J[d+12>>2]+8>>2];k=J[b+124>>2];e=J[d+8>>2];f=J[c+8>>2];c=J[a+40>>2]+P(h,156)|0;N[c+136>>2]=N[b+136>>2];N[c+140>>2]=N[b+140>>2];N[c+144>>2]=N[b+144>>2];J[c+112>>2]=J[f+8>>2];J[c+116>>2]=J[e+8>>2];N[c+120>>2]=N[f+120>>2];N[c+124>>2]=N[e+120>>2];N[c+128>>2]=N[f+128>>2];l=N[e+128>>2];J[c+152>>2]=h;N[c+132>>2]=l;J[c+148>>2]=k;J[c+80>>2]=0;J[c+84>>2]=0;J[c+88>>2]=0;J[c+92>>2]=0;J[c+96>>2]=0;J[c+100>>2]=0;J[c+104>>2]=0;J[c+108>>2]=0;d=J[a+36>>2]+P(h,88)|0;J[d+32>>2]=J[f+8>>2];J[d+36>>2]=J[e+8>>2];N[d+40>>2]=N[f+120>>2];N[d+44>>2]=N[e+120>>2];i=J[f+32>>2];J[d+48>>2]=J[f+28>>2];J[d+52>>2]=i;i=J[e+32>>2];J[d+56>>2]=J[e+28>>2];J[d+60>>2]=i;N[d+64>>2]=N[f+128>>2];N[d+68>>2]=N[e+128>>2];e=J[b+108>>2];J[d+16>>2]=J[b+104>>2];J[d+20>>2]=e;e=J[b+116>>2];f=J[b+112>>2];J[d+84>>2]=k;J[d+24>>2]=f;J[d+28>>2]=e;N[d+80>>2]=g;N[d+76>>2]=j;J[d+72>>2]=J[b+120>>2];if((k|0)>0){i=b- -64|0;e=0;while(1){b=c+P(e,36)|0;f=P(e,20)+i|0;a:{if(!K[a+20|0]){j=Q(0);g=Q(0);break a}g=N[a+8>>2];j=Q(g*N[f+12>>2]);g=Q(g*N[f+8>>2])}J[b+32>>2]=0;J[b+24>>2]=0;J[b+28>>2]=0;N[b+20>>2]=j;N[b+16>>2]=g;J[b+8>>2]=0;J[b+12>>2]=0;J[b>>2]=0;J[b+4>>2]=0;m=J[f+4>>2];b=d+(e<<3)|0;J[b>>2]=J[f>>2];J[b+4>>2]=m;e=e+1|0;if((k|0)!=(e|0)){continue}break}}h=h+1|0;if((h|0)>2]){continue}break}}return a}function dg(a,b){a=a|0;b=b|0;var c=Q(0),d=0,e=Q(0),f=0,g=Q(0),h=Q(0),i=0,j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=0,o=Q(0),p=0,q=Q(0),r=Q(0),s=0,t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=Q(0),C=Q(0),D=Q(0),E=Q(0);d=J[a+48>>2];s=J[d+8>>2];J[a+96>>2]=s;i=J[a+52>>2];n=J[i+8>>2];J[a+100>>2]=n;o=N[d+32>>2];f=J[d+32>>2];l=N[d+28>>2];p=J[d+28>>2];J[a+128>>2]=p;J[a+132>>2]=f;A=N[i+32>>2];f=J[i+32>>2];h=N[i+28>>2];J[a+136>>2]=J[i+28>>2];J[a+140>>2]=f;q=N[d+120>>2];N[a+144>>2]=q;r=N[i+120>>2];N[a+148>>2]=r;t=N[d+128>>2];N[a+152>>2]=t;u=N[i+128>>2];N[a+156>>2]=u;e=N[a+72>>2];i=J[b+24>>2];d=P(s,12);p=i+d|0;m=N[p+8>>2];k=Za(m);c=N[a+68>>2];g=_a(m);f=J[b+28>>2];d=d+f|0;m=N[d>>2];v=N[d+4>>2];w=N[d+8>>2];n=P(n,12);d=n+f|0;x=N[d>>2];y=N[d+4>>2];z=N[d+8>>2];B=N[p>>2];d=i+n|0;C=N[d>>2];D=N[p+4>>2];E=N[d+4>>2];j=N[d+8>>2];c=Q(c-l);e=Q(e-o);l=Q(Q(g*c)-Q(k*e));N[a+112>>2]=l;k=Q(Q(k*c)+Q(g*e));N[a+116>>2]=k;g=N[a+80>>2];e=Za(j);c=N[a+76>>2];j=_a(j);h=Q(c-h);c=Q(g-A);g=Q(Q(j*h)-Q(e*c));N[a+120>>2]=g;j=Q(Q(e*h)+Q(j*c));N[a+124>>2]=j;h=Q(Q(Q(C+g)-B)-l);e=Q(Q(Q(E+j)-D)-k);c=Q(Y(Q(Q(h*h)+Q(e*e))));N[a+88>>2]=c;if(c>Q(.004999999888241291)){c=Q(Q(1)/c);e=Q(e*c);N[a+108>>2]=e;h=Q(h*c);N[a+104>>2]=h;c=Q(Q(g*e)-Q(h*j));o=Q(Q(u*c)*c);c=Q(Q(l*e)-Q(h*k));c=Q(o+Q(r+Q(Q(Q(t*c)*c)+q)));N[a+160>>2]=c!=Q(0)?Q(Q(1)/c):Q(0);a:{if(K[b+20|0]){c=Q(N[b+8>>2]*N[a+92>>2]);N[a+92>>2]=c;o=g;g=Q(e*c);e=Q(h*c);z=Q(Q(u*Q(Q(o*g)+Q(e*Q(-j))))+z);w=Q(w-Q(t*Q(Q(l*g)+Q(e*Q(-k)))));y=Q(y+Q(r*g));x=Q(x+Q(r*e));v=Q(v-Q(q*g));m=Q(m-Q(q*e));break a}J[a+92>>2]=0}f=J[b+28>>2]+P(s,12)|0;N[f+4>>2]=v;N[f>>2]=m;f=J[b+28>>2];N[(f+P(J[a+96>>2],12)|0)+8>>2]=w;f=f+P(J[a+100>>2],12)|0;N[f+4>>2]=y;N[f>>2]=x;N[(J[b+28>>2]+P(J[a+100>>2],12)|0)+8>>2]=z;return}J[a+160>>2]=0;J[a+104>>2]=0;J[a+108>>2]=0;J[a+92>>2]=0}function aj(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,f=0,g=0,h=0,i=0,j=0,k=0;d=J[a>>2];g=J[a+4>>2]-d>>3;if(g>>>0>>0){d=b-g|0;g=a;a:{e=J[a+8>>2];b=J[a+4>>2];if(d>>>0<=e-b>>3>>>0){b:{if(!d){break b}a=b;f=d&7;if(f){e=0;while(1){i=J[c+4>>2];J[a>>2]=J[c>>2];J[a+4>>2]=i;a=a+8|0;e=e+1|0;if((f|0)!=(e|0)){continue}break}}b=(d<<3)+b|0;if((d-1&536870911)>>>0<7){break b}while(1){d=J[c+4>>2];J[a>>2]=J[c>>2];J[a+4>>2]=d;d=J[c+4>>2];J[a+8>>2]=J[c>>2];J[a+12>>2]=d;d=J[c+4>>2];J[a+16>>2]=J[c>>2];J[a+20>>2]=d;d=J[c+4>>2];J[a+24>>2]=J[c>>2];J[a+28>>2]=d;d=J[c+4>>2];J[a+32>>2]=J[c>>2];J[a+36>>2]=d;d=J[c+4>>2];J[a+40>>2]=J[c>>2];J[a+44>>2]=d;d=J[c+4>>2];J[a+48>>2]=J[c>>2];J[a+52>>2]=d;d=J[c+4>>2];J[a+56>>2]=J[c>>2];J[a+60>>2]=d;a=a- -64|0;if((b|0)!=(a|0)){continue}break}}J[g+4>>2]=b;break a}c:{f=J[g>>2];h=b-f>>3;a=h+d|0;if(a>>>0<536870912){e=e-f|0;f=e>>2;f=e>>>0>=2147483640?536870911:a>>>0>>0?f:a;if(f){if(f>>>0>=536870912){break c}i=Xa(f<<3)}e=(h<<3)+i|0;a=e;h=d&7;if(h){while(1){j=J[c+4>>2];J[a>>2]=J[c>>2];J[a+4>>2]=j;a=a+8|0;k=k+1|0;if((h|0)!=(k|0)){continue}break}}h=(d<<3)+e|0;if((d-1&536870911)>>>0>=7){while(1){d=J[c+4>>2];J[a>>2]=J[c>>2];J[a+4>>2]=d;d=J[c+4>>2];J[a+8>>2]=J[c>>2];J[a+12>>2]=d;d=J[c+4>>2];J[a+16>>2]=J[c>>2];J[a+20>>2]=d;d=J[c+4>>2];J[a+24>>2]=J[c>>2];J[a+28>>2]=d;d=J[c+4>>2];J[a+32>>2]=J[c>>2];J[a+36>>2]=d;d=J[c+4>>2];J[a+40>>2]=J[c>>2];J[a+44>>2]=d;d=J[c+4>>2];J[a+48>>2]=J[c>>2];J[a+52>>2]=d;d=J[c+4>>2];J[a+56>>2]=J[c>>2];J[a+60>>2]=d;a=a- -64|0;if((h|0)!=(a|0)){continue}break}}c=J[g>>2];if((c|0)!=(b|0)){while(1){b=b-8|0;a=b;j=J[a+4>>2];e=e-8|0;d=e;J[d>>2]=J[a>>2];J[d+4>>2]=j;if((a|0)!=(c|0)){continue}break}b=J[g>>2]}J[g+8>>2]=(f<<3)+i;J[g+4>>2]=h;J[g>>2]=e;if(b){ab(b)}break a}ma();B()}Tb();B()}return}if(b>>>0>>0){J[a+4>>2]=d+(b<<3)}}function qg(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=0,f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=0,m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0);e=J[b+24>>2];l=e+P(J[a+136>>2],12)|0;m=N[l+8>>2];u=N[l+4>>2];v=N[l>>2];e=e+P(J[a+132>>2],12)|0;n=N[e+8>>2];k=N[e+4>>2];w=N[e>>2];l=1;o=N[a+180>>2];p=N[a+184>>2];if(!(!K[a+116|0]|Q(o+p)==Q(0))){d=Q(Q(m-n)-N[a+120>>2]);g=N[a+128>>2];f=N[a+124>>2];c=Q(g-f);a:{if((c>Q(0)?c:Q(-c))=g)){break a}c=Q(Q(d-g)+Q(-.03490658849477768));c=cQ(0)?c:Q(-c))<=Q(.03490658849477768);c=Q(c*Q(-N[a+208>>2]));m=Q(Q(p*c)+m);n=Q(n-Q(o*c))}h=N[a+168>>2];i=N[a+80>>2];x=Za(m);d=N[a+164>>2];f=N[a+76>>2];y=_a(m);g=N[a+160>>2];c=N[a+72>>2];j=Q(f-d);h=Q(i-h);q=Q(Q(x*j)+Q(y*h));i=Za(n);d=Q(N[a+68>>2]-N[a+156>>2]);f=_a(n);c=Q(c-g);r=Q(Q(i*d)+Q(f*c));s=N[a+172>>2];t=N[a+176>>2];g=Q(s+t);z=Q(Q(Q(q*p)*q)+Q(Q(Q(r*o)*r)+g));A=k;k=Q(Q(Q(u+q)-k)-r);h=Q(Q(y*j)-Q(h*x));j=Q(Q(f*d)-Q(c*i));i=Q(Q(Q(v+h)-w)-j);c=Q(h*p);d=Q(Q(Q(j*Q(-o))*r)-Q(q*c));g=Q(Q(c*h)+Q(Q(Q(j*o)*j)+g));c=Q(Q(z*g)-Q(d*d));c=Q(-(c!=Q(0)?Q(Q(1)/c):c));f=Q(Q(Q(z*k)-Q(i*d))*c);N[e+4>>2]=A-Q(s*f);c=Q(Q(Q(g*i)-Q(k*d))*c);N[e>>2]=w-Q(s*c);e=J[b+24>>2];N[(e+P(J[a+132>>2],12)|0)+8>>2]=n-Q(o*Q(Q(j*f)-Q(c*r)));e=e+P(J[a+136>>2],12)|0;N[e+4>>2]=u+Q(t*f);N[e>>2]=v+Q(t*c);N[(J[b+24>>2]+P(J[a+136>>2],12)|0)+8>>2]=Q(p*Q(Q(h*f)-Q(c*q)))+m;return Q(Y(Q(Q(i*i)+Q(k*k))))<=Q(.004999999888241291)&l}function kd(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=0,j=Q(0),k=Q(0),l=0;c=La-128|0;La=c;l=J[a+52>>2];i=J[a+48>>2];g=N[i+12>>2];f=N[i+20>>2];d=N[a+68>>2];e=N[i+24>>2];h=N[a+72>>2];N[c+124>>2]=Q(Q(f*d)+Q(e*h))+N[i+16>>2];N[c+120>>2]=g+Q(Q(e*d)-Q(h*f));g=N[l+12>>2];d=N[l+20>>2];h=N[a+76>>2];j=N[l+24>>2];k=N[a+80>>2];N[c+116>>2]=Q(Q(d*h)+Q(j*k))+N[l+16>>2];N[c+112>>2]=g+Q(Q(j*h)-Q(k*d));d=N[a+88>>2];h=N[a+84>>2];J[c+104>>2]=1060320051;J[c+108>>2]=1065353216;J[c+96>>2]=1060320051;J[c+100>>2]=1060320051;J[c+88>>2]=1050253722;J[c+92>>2]=1065353216;J[c+80>>2]=1050253722;J[c+84>>2]=1063675494;J[c+72>>2]=1050253722;J[c+76>>2]=1065353216;J[c+64>>2]=1063675494;J[c+68>>2]=1050253722;J[c+56>>2]=1063675494;J[c+60>>2]=1065353216;J[c+48>>2]=1050253722;J[c+52>>2]=1050253722;J[c+40>>2]=1053609165;J[c+44>>2]=1065353216;J[c+32>>2]=1053609165;J[c+36>>2]=1053609165;Na[J[J[b>>2]+24>>2]](b,c+120|0,c+112|0,c+32|0);g=Q(Q(f*h)+Q(e*d));f=Q(Q(e*h)-Q(d*f));a:{if(K[a+140|0]){e=N[a+124>>2];d=N[c+124>>2];N[c+28>>2]=Q(g*e)+d;h=N[c+120>>2];N[c+24>>2]=h+Q(f*e);e=g;g=N[a+128>>2];N[c+20>>2]=d+Q(e*g);N[c+16>>2]=h+Q(f*g);f=N[a+96>>2];e=N[i+20>>2];d=N[a+92>>2];h=N[i+24>>2];Na[J[J[b>>2]+24>>2]](b,c+24|0,c+16|0,c+96|0);j=N[c+28>>2];g=Q(Q(Q(e*d)+Q(h*f))*Q(.5));N[c+12>>2]=j-g;k=N[c+24>>2];f=Q(Q(Q(h*d)-Q(f*e))*Q(.5));N[c+8>>2]=k-f;N[c+4>>2]=g+j;N[c>>2]=f+k;a=c+8|0;Na[J[J[b>>2]+24>>2]](b,a,c,c+80|0);e=N[c+20>>2];N[c+12>>2]=e-g;d=N[c+16>>2];N[c+8>>2]=d-f;N[c+4>>2]=g+e;N[c>>2]=f+d;Na[J[J[b>>2]+24>>2]](b,a,c,c- -64|0);break a}e=N[c+124>>2];N[c+28>>2]=e-g;d=N[c+120>>2];N[c+24>>2]=d-f;N[c+20>>2]=g+e;N[c+16>>2]=f+d;Na[J[J[b>>2]+24>>2]](b,c+24|0,c+16|0,c+96|0)}Na[J[J[b>>2]+32>>2]](b,c+120|0,Q(5),c+96|0);Na[J[J[b>>2]+32>>2]](b,c+112|0,Q(5),c+48|0);La=c+128|0}function sh(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=0,g=Q(0),h=Q(0),i=Q(0),j=0,k=0,l=0,m=Q(0),n=Q(0),o=0,p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=0,v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0);j=J[a+48>>2];u=J[j+8>>2];J[a+104>>2]=u;k=J[a+52>>2];o=J[k+8>>2];J[a+108>>2]=o;q=N[j+32>>2];f=J[j+32>>2];n=N[j+28>>2];l=J[j+28>>2];J[a+128>>2]=l;J[a+132>>2]=f;r=N[k+32>>2];f=J[k+32>>2];g=N[k+28>>2];J[a+136>>2]=J[k+28>>2];J[a+140>>2]=f;s=N[j+120>>2];N[a+144>>2]=s;t=N[k+120>>2];N[a+148>>2]=t;d=N[j+128>>2];N[a+152>>2]=d;p=N[k+128>>2];N[a+156>>2]=p;h=N[a+72>>2];j=P(u,12);k=J[b+24>>2];e=N[(j+k|0)+8>>2];m=_a(e);i=N[a+68>>2];e=Za(e);f=J[b+28>>2];o=P(o,12);l=f+o|0;v=N[l+8>>2];w=N[l+4>>2];x=N[l>>2];l=j+f|0;y=N[l+8>>2];z=N[l+4>>2];A=N[l>>2];c=N[(k+o|0)+8>>2];i=Q(i-n);h=Q(h-q);n=Q(Q(e*i)+Q(m*h));N[a+116>>2]=n;m=Q(Q(m*i)-Q(h*e));N[a+112>>2]=m;e=Q(d+p);N[a+176>>2]=e>Q(0)?Q(Q(1)/e):e;e=N[a+80>>2];h=_a(c);i=N[a+76>>2];c=Za(c);g=Q(i-g);i=Q(e-r);e=Q(Q(c*g)+Q(h*i));N[a+124>>2]=e;h=Q(Q(h*g)-Q(i*c));N[a+120>>2]=h;c=Q(s+t);g=Q(Q(Q(p*e)*e)+Q(Q(Q(d*n)*n)+c));q=g;g=Q(p*h);i=Q(Q(g*h)+Q(Q(Q(d*m)*m)+c));r=Q(-d);d=Q(Q(Q(m*r)*n)-Q(e*g));c=Q(Q(q*i)-Q(d*d));c=c!=Q(0)?Q(Q(1)/c):c;N[a+172>>2]=q*c;N[a+160>>2]=i*c;d=Q(d*Q(-c));N[a+168>>2]=d;N[a+164>>2]=d;a:{if(K[b+20|0]){c=N[b+8>>2];d=Q(c*N[a+84>>2]);N[a+84>>2]=d;g=Q(c*N[a+92>>2]);N[a+92>>2]=g;c=Q(c*N[a+88>>2]);N[a+88>>2]=c;v=Q(Q(p*Q(g+Q(Q(h*c)-Q(d*e))))+v);y=Q(Q(r*Q(g+Q(Q(m*c)-Q(d*n))))+y);x=Q(x+Q(t*d));A=Q(A-Q(s*d));w=Q(w+Q(t*c));z=Q(z-Q(s*c));break a}J[a+92>>2]=0;J[a+84>>2]=0;J[a+88>>2]=0}f=J[b+28>>2]+P(u,12)|0;N[f+4>>2]=z;N[f>>2]=A;f=J[b+28>>2];N[(f+P(J[a+104>>2],12)|0)+8>>2]=y;f=f+P(J[a+108>>2],12)|0;N[f+4>>2]=w;N[f>>2]=x;N[(J[b+28>>2]+P(J[a+108>>2],12)|0)+8>>2]=v}function Dd(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=0,f=0;c=La-416|0;La=c;Ya(7671,0);O[c+400>>3]=N[a+16>>2];Ya(6794,c+400|0);O[c+384>>3]=N[a+20>>2];Ya(6766,c+384|0);O[c+368>>3]=N[a>>2];Ya(6581,c+368|0);J[c+352>>2]=K[a+38|0];Ya(8706,c+352|0);J[c+336>>2]=L[a+32>>1];Ya(8944,c+336|0);J[c+320>>2]=L[a+34>>1];Ya(8986,c+320|0);J[c+304>>2]=I[a+36>>1];Ya(9024,c+304|0);a:{b:{c:{d:{e:{f:{a=J[a+12>>2];switch(J[a+4>>2]){case 0:break c;case 3:break d;case 2:break e;case 1:break f;default:break a}}Ya(7406,0);O[c+128>>3]=N[a+8>>2];Ya(6663,c+128|0);d=N[a+28>>2];O[c+120>>3]=N[a+32>>2];O[c+112>>3]=d;Ya(8413,c+112|0);d=N[a+12>>2];O[c+104>>3]=N[a+16>>2];O[c+96>>3]=d;Ya(8375,c+96|0);d=N[a+20>>2];O[c+88>>3]=N[a+24>>2];O[c+80>>3]=d;Ya(8337,c+80|0);d=N[a+36>>2];O[c+72>>3]=N[a+40>>2];O[c+64>>3]=d;Ya(8299,c- -64|0);J[c+48>>2]=K[a+44|0];Ya(8881,c+48|0);break b}Ya(7328,0);J[c+192>>2]=8;Ya(7710,c+192|0);e=J[a+148>>2];if((e|0)>0){while(1){e=a+(f<<3)|0;d=N[e+20>>2];O[c+176>>3]=N[e+24>>2];J[c+160>>2]=f;O[c+168>>3]=d;Ya(8090,c+160|0);f=f+1|0;e=J[a+148>>2];if((f|0)<(e|0)){continue}break}}J[c+144>>2]=e;Ya(9063,c+144|0);break b}Ya(7355,0);J[c+288>>2]=J[a+16>>2];Ya(7710,c+288|0);e=J[a+16>>2];if((e|0)>0){while(1){e=J[a+12>>2]+(f<<3)|0;d=N[e>>2];O[c+272>>3]=N[e+4>>2];J[c+256>>2]=f;O[c+264>>3]=d;Ya(8090,c+256|0);f=f+1|0;e=J[a+16>>2];if((f|0)<(e|0)){continue}break}}J[c+240>>2]=e;Ya(9087,c+240|0);d=N[a+20>>2];O[c+232>>3]=N[a+24>>2];O[c+224>>3]=d;Ya(7908,c+224|0);d=N[a+28>>2];O[c+216>>3]=N[a+32>>2];O[c+208>>3]=d;Ya(7949,c+208|0);break b}Ya(7380,0);O[c+32>>3]=N[a+8>>2];Ya(6663,c+32|0);d=N[a+12>>2];O[c+24>>3]=N[a+16>>2];O[c+16>>3]=d;Ya(8026,c+16|0)}Ya(9326,0);Ya(7304,0);Ya(9326,0);J[c>>2]=b;Ya(8542,c)}La=c+416|0}function eg(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=0,g=Q(0),h=0,i=Q(0),j=Q(0),k=0,l=0,m=0,n=Q(0);c=La-112|0;La=c;h=J[a+52>>2];f=J[a+48>>2];d=N[f+12>>2];e=N[f+20>>2];g=N[a+68>>2];i=N[f+24>>2];j=N[a+72>>2];N[c+108>>2]=Q(Q(e*g)+Q(i*j))+N[f+16>>2];N[c+104>>2]=d+Q(Q(i*g)-Q(j*e));d=N[h+12>>2];e=N[h+20>>2];g=N[a+76>>2];i=N[h+24>>2];j=N[a+80>>2];N[c+100>>2]=Q(Q(e*g)+Q(i*j))+N[h+16>>2];N[c+96>>2]=d+Q(Q(i*g)-Q(j*e));J[c+88>>2]=1060320051;J[c+92>>2]=1065353216;J[c+80>>2]=1060320051;J[c+84>>2]=1060320051;J[c+72>>2]=1050253722;J[c+76>>2]=1065353216;J[c+64>>2]=1050253722;J[c+68>>2]=1063675494;J[c+56>>2]=1050253722;J[c+60>>2]=1065353216;J[c+48>>2]=1063675494;J[c+52>>2]=1050253722;J[c+40>>2]=1063675494;J[c+44>>2]=1065353216;J[c+32>>2]=1050253722;J[c+36>>2]=1050253722;J[c+24>>2]=1053609165;J[c+28>>2]=1065353216;J[c+16>>2]=1053609165;J[c+20>>2]=1053609165;Na[J[J[b>>2]+32>>2]](b,c+104|0,Q(5),c+32|0);k=c+96|0;Na[J[J[b>>2]+32>>2]](b,k,Q(5),c+16|0);d=Q(Q(N[J[a+52>>2]+56>>2]-N[J[a+48>>2]+56>>2])-N[a+120>>2]);m=c,n=Q(Q(Za(d)*Q(.5))+N[c+100>>2]),N[m+4>>2]=n;d=_a(d);N[c>>2]=N[c+96>>2]+Q(d*Q(.5));l=c+80|0;Na[J[J[b>>2]+24>>2]](b,k,c,l);Na[J[J[b>>2]+16>>2]](b,k,Q(.5),l);if(K[a+116|0]){e=N[a+124>>2];g=Za(e);d=N[a+128>>2];N[c+4>>2]=Q(g*Q(.5))+N[c+100>>2];m=c,n=Q(Q(_a(e)*Q(.5))+N[c+96>>2]),N[m>>2]=n;a=c+96|0;Na[J[J[b>>2]+24>>2]](b,a,c,c- -64|0);m=c,n=Q(Q(Za(d)*Q(.5))+N[c+100>>2]),N[m+4>>2]=n;m=c,n=Q(Q(_a(d)*Q(.5))+N[c+96>>2]),N[m>>2]=n;Na[J[J[b>>2]+24>>2]](b,a,c,c+48|0)}J[c+8>>2]=1061997773;J[c+12>>2]=1065353216;J[c>>2]=1056964608;J[c+4>>2]=1061997773;a=c+104|0;Na[J[J[b>>2]+24>>2]](b,f+12|0,a,c);f=a;a=c+96|0;Na[J[J[b>>2]+24>>2]](b,f,a,c);Na[J[J[b>>2]+24>>2]](b,h+12|0,a,c);La=c+112|0}function ed(a,b,c,d,e){var f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0);a:{switch(J[b+72>>2]){case 0:g=N[d>>2];f=N[c>>2];h=N[d+8>>2];i=N[b>>2];k=N[d+12>>2];m=N[b+4>>2];n=Q(Q(Q(h*i)+Q(k*m))+N[d+4>>2]);o=N[c+8>>2];p=N[b+24>>2];l=N[c+12>>2];q=N[b+28>>2];r=Q(Q(Q(o*p)+Q(l*q))+N[c+4>>2]);j=Q(n-r);N[a+4>>2]=j;h=Q(g+Q(Q(k*i)-Q(m*h)));i=Q(f+Q(Q(l*p)-Q(q*o)));g=Q(h-i);N[a>>2]=g;f=Q(Q(g*g)+Q(j*j));k=Q(Y(f));if(!(k>2]=k;f=Q(g*f);N[a>>2]=f;f=Q(Q(g*f)+Q(j*k))}N[a+12>>2]=Q(r+n)*Q(.5);N[a+8>>2]=Q(i+h)*Q(.5);N[a+16>>2]=Q(f-N[b+76>>2])-N[b+80>>2];return;case 1:j=N[c+8>>2];g=N[b+16>>2];f=N[c+12>>2];h=N[b+20>>2];i=Q(Q(j*g)+Q(f*h));N[a+4>>2]=i;k=Q(Q(f*g)-Q(h*j));N[a>>2]=k;j=N[b+28>>2];g=N[c+12>>2];m=N[b+80>>2];n=N[b+76>>2];o=N[c>>2];p=N[c+4>>2];f=N[c+8>>2];h=N[b+24>>2];l=N[d>>2];q=N[d+8>>2];b=(e<<3)+b|0;r=N[b>>2];t=N[d+12>>2];u=N[b+4>>2];s=Q(Q(Q(q*r)+Q(t*u))+N[d+4>>2]);N[a+12>>2]=s;l=Q(l+Q(Q(t*r)-Q(u*q)));N[a+8>>2]=l;N[a+16>>2]=Q(Q(Q(Q(l-Q(o+Q(Q(g*h)-Q(j*f))))*k)+Q(Q(s-Q(p+Q(Q(f*h)+Q(g*j))))*i))-n)-m;return;case 2:g=N[d+8>>2];f=N[b+16>>2];h=N[d+12>>2];i=N[b+20>>2];j=Q(Q(g*f)+Q(h*i));N[a+4>>2]=j;g=Q(Q(h*f)-Q(i*g));N[a>>2]=g;f=N[b+28>>2];h=N[d+12>>2];e=(e<<3)+b|0;i=N[e>>2];k=N[e+4>>2];m=N[c+12>>2];l=N[b+80>>2];q=N[b+76>>2];r=N[d>>2];t=N[d+4>>2];n=N[d+8>>2];o=N[b+24>>2];u=N[c>>2];s=N[c+4>>2];p=N[c+8>>2];N[a+4>>2]=-j;N[a>>2]=-g;s=Q(s+Q(Q(p*i)+Q(m*k)));N[a+12>>2]=s;i=Q(u+Q(Q(m*i)-Q(k*p)));N[a+8>>2]=i;N[a+16>>2]=Q(Q(Q(Q(i-Q(r+Q(Q(h*o)-Q(f*n))))*g)+Q(Q(s-Q(t+Q(Q(n*o)+Q(h*f))))*j))-q)-l;break;default:break a}}}function ec(a,b,c,d){var e=0,f=0,g=0,h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=0,n=Q(0),o=Q(0),p=Q(0),q=0,r=Q(0);f=La-48|0;La=f;if(J[a+28>>2]>0){while(1){g=J[a+12>>2];e=J[a+24>>2]+P(q,28)|0;Na[J[J[g>>2]+24>>2]](g,f+32|0,c,J[e+20>>2]);g=J[a+12>>2];Na[J[J[g>>2]+24>>2]](g,f+16|0,d,J[e+20>>2]);h=N[f+16>>2];j=N[f+32>>2];i=N[f+36>>2];k=N[f+20>>2];N[e+4>>2]=i>2]=h>j?j:h;h=N[f+24>>2];j=N[f+40>>2];i=N[f+44>>2];k=N[f+28>>2];N[e+12>>2]=i>k?i:k;N[e+8>>2]=h>2]=Q(Q(N[f+20>>2]+N[f+28>>2])*Q(.5))-Q(Q(N[f+36>>2]+N[f+44>>2])*Q(.5));N[f+8>>2]=Q(Q(N[f+16>>2]+N[f+24>>2])*Q(.5))-Q(Q(N[f+32>>2]+N[f+40>>2])*Q(.5));h=Q(N[f+12>>2]*Q(4));g=h>2];j=Q(Q(n+Q(.10000000149011612))+(g?Q(-0):h));o=N[e+4>>2];h=Q(Q(o+Q(-.10000000149011612))+(g?h:Q(-0)));i=Q(N[f+8>>2]*Q(4));g=i>2];k=Q(Q(p+Q(.10000000149011612))+(g?Q(-0):i));l=N[e>>2];i=Q(Q(l+Q(-.10000000149011612))+(g?i:Q(-0)));g=J[e+24>>2];m=P(g,40);e=m+J[b+4>>2]|0;r=N[e>>2];a:{b:{if(!(l>=r)){break b}l=o;o=N[e+4>>2];if(!(l>=o)){break b}l=p;p=N[e+8>>2];if(!(l<=p)){break b}l=n;n=N[e+12>>2];if(!(l<=n)|!(Q(i+Q(-.4000000059604645))<=r)|(!(o>=Q(h+Q(-.4000000059604645)))|!(p<=Q(k+Q(.4000000059604645))))){break b}e=0;if(n<=Q(j+Q(.4000000059604645))){break a}}Nd(b,g);e=m+J[b+4>>2]|0;N[e+12>>2]=j;N[e+8>>2]=k;N[e+4>>2]=h;N[e>>2]=i;Pd(b,g);H[(m+J[b+4>>2]|0)+36|0]=1;e=1}if(e){e=J[b+40>>2];if((e|0)==J[b+36>>2]){J[b+36>>2]=e<<1;m=J[b+32>>2];e=fb(e<<3);J[b+32>>2]=e;rb(e,m,J[b+40>>2]<<2);ab(m);e=J[b+40>>2]}J[J[b+32>>2]+(e<<2)>>2]=g;J[b+40>>2]=J[b+40>>2]+1}q=q+1|0;if((q|0)>2]){continue}break}}La=f+48|0}function sg(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=0,g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=0,r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0);q=J[b+28>>2];f=q+P(J[a+136>>2],12)|0;g=N[f+8>>2];r=N[f+4>>2];s=N[f>>2];f=P(J[a+132>>2],12)+q|0;d=N[f+8>>2];t=N[f+4>>2];u=N[f>>2];l=N[a+180>>2];m=N[a+184>>2];e=Q(l+m);if(!(!K[a+104|0]|e==Q(0))){c=Q(N[b>>2]*N[a+108>>2]);n=Q(-c);o=N[a+92>>2];i=Q(o-Q(N[a+208>>2]*Q(Q(g-d)-N[a+112>>2])));c=c>i?i:c;c=c>2]=c;c=Q(c-o);g=Q(Q(m*c)+g);d=Q(d-Q(l*c))}n=N[a+176>>2];o=N[a+172>>2];if(!(!K[a+116|0]|e==Q(0))){e=N[a+96>>2];c=N[a+208>>2];i=N[a+204>>2];h=Q(i-N[a+124>>2]);p=h>Q(0)?h:Q(0);h=N[b+4>>2];j=Q(e-Q(c*Q(Q(p*h)+Q(g-d))));j=j>Q(0)?j:Q(0);N[a+96>>2]=j;k=N[a+100>>2];p=c;c=Q(N[a+128>>2]-i);i=d;d=Q(j-e);e=Q(i-Q(l*d));g=Q(Q(m*d)+g);d=Q(k-Q(p*Q(Q(h*(c>Q(0)?c:Q(0)))+Q(e-g))));d=d>Q(0)?d:Q(0);N[a+100>>2]=d;d=Q(d-k);g=Q(g-Q(m*d));d=Q(Q(l*d)+e)}i=N[a+188>>2];h=N[a+200>>2];j=N[a+192>>2];k=N[a+196>>2];e=Q(Q(i*h)-Q(j*k));c=e!=Q(0)?Q(Q(1)/e):e;v=N[a+148>>2];w=N[a+140>>2];x=Q(Q(Q(r+Q(g*v))-t)-Q(d*w));e=Q(x*k);p=h;h=N[a+152>>2];k=N[a+144>>2];y=Q(Q(Q(s-Q(g*h))-u)+Q(d*k));e=Q(Q(e-Q(p*y))*c);N[a+84>>2]=N[a+84>>2]+e;c=Q(Q(Q(y*j)-Q(i*x))*c);N[a+88>>2]=N[a+88>>2]+c;N[f+4>>2]=t-Q(o*c);N[f>>2]=u-Q(o*e);f=J[b+28>>2];N[(f+P(J[a+132>>2],12)|0)+8>>2]=Q(Q(-l)*Q(Q(w*c)-Q(e*k)))+d;f=f+P(J[a+136>>2],12)|0;N[f+4>>2]=r+Q(n*c);N[f>>2]=s+Q(n*e);N[(J[b+28>>2]+P(J[a+136>>2],12)|0)+8>>2]=Q(m*Q(Q(v*c)-Q(e*h)))+g}function td(a,b,c,d,e){var f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=0,k=Q(0),l=Q(0),m=0,n=0,o=0,p=Q(0),q=Q(0),r=Q(0),s=0,t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=0,y=0,z=0,A=0;j=J[b+148>>2];if((j|0)<=0){J[a>>2]=0;return Q(-34028234663852886e22)}a:{b:{c:{o=J[d+148>>2];if((o|0)<=0){c=j&3;if(j>>>0>=4){break c}g=Q(-34028234663852886e22);b=0;break b}g=N[e+12>>2];k=Q(N[c+4>>2]-N[e+4>>2]);f=N[e+8>>2];h=Q(N[c>>2]-N[e>>2]);v=Q(Q(g*k)-Q(f*h));w=Q(Q(g*h)+Q(f*k));h=N[c+12>>2];i=N[c+8>>2];k=Q(Q(g*h)+Q(i*f));d=d+20|0;x=b+20|0;y=b+84|0;p=Q(Q(g*i)-Q(h*f));r=Q(-p);z=o&-2;A=o&1;g=Q(-34028234663852886e22);c=0;while(1){b=c<<3;e=b+y|0;f=N[e>>2];i=N[e+4>>2];h=Q(Q(p*f)+Q(k*i));i=Q(Q(k*f)+Q(i*r));b=b+x|0;f=N[b>>2];l=N[b+4>>2];q=Q(v+Q(Q(p*f)+Q(k*l)));l=Q(w+Q(Q(k*f)+Q(l*r)));f=Q(34028234663852886e22);b=0;e=0;if((o|0)!=1){while(1){n=b<<3;s=d+(n|8)|0;t=Q(Q(i*Q(N[s>>2]-l))+Q(h*Q(N[s+4>>2]-q)));n=d+n|0;u=Q(Q(i*Q(N[n>>2]-l))+Q(h*Q(N[n+4>>2]-q)));f=f>u?u:f;f=f>t?t:f;b=b+2|0;e=e+2|0;if((z|0)!=(e|0)){continue}break}}if(A){b=d+(b<<3)|0;h=Q(Q(i*Q(N[b>>2]-l))+Q(h*Q(N[b+4>>2]-q)));f=f>h?h:f}b=f>g;m=b?c:m;g=b?f:g;c=c+1|0;if((j|0)!=(c|0)){continue}break}break a}d=j&-4;g=Q(-34028234663852886e22);b=0;e=0;while(1){j=g>2]=m;return g}function xg(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=Q(0),g=0,h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=0,q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0);r=N[a+164>>2];k=N[a+96>>2];p=J[b+24>>2];g=p+P(J[a+120>>2],12)|0;u=N[g+8>>2];j=_a(u);l=N[a+160>>2];n=N[a+92>>2];h=Za(u);w=N[g+4>>2];t=N[a+72>>2];x=N[g>>2];m=N[a+68>>2];d=N[a+172>>2];c=N[a+104>>2];p=p+P(J[a+124>>2],12)|0;v=N[p+8>>2];i=_a(v);s=N[a+168>>2];e=N[a+100>>2];f=Za(v);y=N[p>>2];q=Q(e-s);d=Q(c-d);s=Q(Q(i*q)-Q(f*d));e=Q(Q(y+s)-N[a+76>>2]);z=N[p+4>>2];q=Q(Q(f*q)+Q(i*d));o=Q(Q(z+q)-N[a+80>>2]);i=Q(Y(Q(Q(e*e)+Q(o*o))));f=Q(0);d=Q(0);c=Q(0);l=Q(n-l);n=Q(k-r);r=Q(Q(j*l)-Q(h*n));k=Q(Q(x+r)-m);l=Q(Q(h*l)+Q(j*n));j=Q(Q(w+l)-t);h=Q(Y(Q(Q(k*k)+Q(j*j))));if(h>Q(.04999999701976776)){d=Q(Q(1)/h);c=Q(j*d);d=Q(k*d)}j=Q(0);if(i>Q(.04999999701976776)){f=Q(Q(1)/i);j=Q(o*f);f=Q(e*f)}A=c;m=Q(N[a+108>>2]-h);h=N[a+112>>2];i=Q(m-Q(h*i));e=Q(Q(s*j)-Q(f*q));k=N[a+188>>2];m=Q(Q(e*k)*e);e=N[a+180>>2];o=N[a+176>>2];c=Q(Q(r*c)-Q(d*l));n=N[a+184>>2];c=Q(Q(Q(h*h)*Q(m+e))+Q(o+Q(Q(c*n)*c)));t=Q(i*Q(-(c>Q(0)?Q(Q(1)/c):c)));m=Q(-t);c=Q(A*m);N[g+4>>2]=w+Q(o*c);d=Q(d*m);N[g>>2]=x+Q(o*d);g=J[b+24>>2];N[(g+P(J[a+120>>2],12)|0)+8>>2]=Q(n*Q(Q(r*c)-Q(d*l)))+u;g=g+P(J[a+124>>2],12)|0;d=Q(t*Q(-h));c=Q(j*d);N[g+4>>2]=z+Q(e*c);f=Q(f*d);N[g>>2]=y+Q(e*f);N[(J[b+24>>2]+P(J[a+124>>2],12)|0)+8>>2]=Q(k*Q(Q(s*c)-Q(f*q)))+v;return(i>Q(0)?i:Q(-i))>2];c=s+P(J[a+120>>2],12)|0;e=N[c+8>>2];m=N[c+4>>2];n=N[c>>2];c=P(J[a+116>>2],12)+s|0;f=N[c+8>>2];o=N[c+4>>2];p=N[c>>2];q=N[a+168>>2];r=N[a+164>>2];t=N[a+160>>2];u=N[a+156>>2];a:{if(N[a+68>>2]>Q(0)){d=N[a+112>>2];g=Q(Q(Q(d*N[a+100>>2])+Q(Q(e-f)+N[a+76>>2]))*Q(-N[a+204>>2]));N[a+112>>2]=d+g;f=Q(f-Q(r*g));h=N[a+128>>2];i=N[a+136>>2];e=Q(Q(q*g)+e);d=Q(Q(f*h)+Q(Q(n-Q(i*e))-p));j=N[a+132>>2];k=N[a+124>>2];l=Q(Q(Q(m+Q(j*e))-o)-Q(f*k));g=Q(Q(N[a+172>>2]*d)+Q(N[a+184>>2]*l));N[a+104>>2]=N[a+104>>2]-g;d=Q(Q(N[a+176>>2]*d)+Q(l*N[a+188>>2]));N[a+108>>2]=N[a+108>>2]-d;f=Q(f-Q(r*Q(Q(h*g)-Q(k*d))));e=Q(Q(q*Q(Q(i*g)-Q(j*d)))+e);break a}k=N[a+136>>2];l=N[a+128>>2];h=Q(Q(Q(n-Q(e*k))-p)+Q(f*l));v=N[a+132>>2];w=N[a+124>>2];i=Q(Q(Q(m+Q(e*v))-o)-Q(f*w));j=Q(e-f);g=Q(Q(Q(h*N[a+172>>2])+Q(i*N[a+184>>2]))+Q(j*N[a+196>>2]));N[a+104>>2]=N[a+104>>2]-g;d=Q(Q(Q(h*N[a+176>>2])+Q(i*N[a+188>>2]))+Q(j*N[a+200>>2]));N[a+108>>2]=N[a+108>>2]-d;h=Q(Q(Q(h*N[a+180>>2])+Q(i*N[a+192>>2]))+Q(j*N[a+204>>2]));N[a+112>>2]=N[a+112>>2]-h;f=Q(f-Q(r*Q(Q(Q(l*g)-Q(w*d))-h)));e=Q(Q(q*Q(Q(Q(k*g)-Q(v*d))-h))+e)}N[c+4>>2]=o+Q(u*d);N[c>>2]=p+Q(u*g);c=J[b+28>>2];N[(c+P(J[a+116>>2],12)|0)+8>>2]=f;c=c+P(J[a+120>>2],12)|0;N[c+4>>2]=m-Q(t*d);N[c>>2]=n-Q(t*g);N[(J[b+28>>2]+P(J[a+120>>2],12)|0)+8>>2]=e}function fl(a){a=a|0;var b=0,c=0,d=0,e=0,f=0,g=0,h=0;c=Xa(103028);b=c;J[b+4>>2]=0;J[b+8>>2]=128;d=fb(1024);J[b>>2]=d;Db(d,0,J[b+8>>2]<<3);J[b+60>>2]=0;J[b+64>>2]=0;J[b+52>>2]=0;J[b+56>>2]=0;J[b+44>>2]=0;J[b+48>>2]=0;J[b+36>>2]=0;J[b+40>>2]=0;J[b+28>>2]=0;J[b+32>>2]=0;J[b+20>>2]=0;J[b+24>>2]=0;J[b+12>>2]=0;J[b+16>>2]=0;b=b+68|0;J[b+102796>>2]=0;J[b+102408>>2]=0;J[b+102400>>2]=0;J[b+102404>>2]=0;b=c+102868|0;J[b>>2]=-1;J[b+8>>2]=0;J[b+12>>2]=16;d=fb(640);J[b+4>>2]=d;Db(d,0,P(J[b+12>>2],40));d=J[b+12>>2];a:{if((d|0)<=1){e=d-1|0;d=J[b+4>>2];break a}d=J[b+4>>2];while(1){e=P(f,40);f=f+1|0;J[(e+d|0)+20>>2]=f;d=J[b+4>>2];J[(e+d|0)+32>>2]=-1;e=J[b+12>>2]-1|0;if((e|0)>(f|0)){continue}break}}J[(P(e,40)+d|0)+20>>2]=-1;J[(J[b+4>>2]+P(J[b+12>>2],40)|0)-8>>2]=-1;J[b+24>>2]=0;J[b+16>>2]=0;J[b+20>>2]=0;J[b+48>>2]=16;J[b+52>>2]=0;J[b+28>>2]=0;d=fb(128);J[b+36>>2]=16;J[b+40>>2]=0;J[b+44>>2]=d;g=b,h=fb(64),J[g+32>>2]=h;J[b+76>>2]=0;J[b+72>>2]=23652;J[b+68>>2]=23648;J[b+60>>2]=0;J[b+64>>2]=0;J[c+102948>>2]=0;J[c+102952>>2]=0;J[c+102976>>2]=0;J[c+102980>>2]=0;b=c+102956|0;J[b>>2]=0;J[b+4>>2]=0;H[c+102991|0]=1;H[c+102992|0]=1;H[c+102993|0]=0;H[c+102994|0]=1;H[c+102972|0]=1;b=J[a+4>>2];a=J[a>>2];H[c+102990|0]=1;I[c+102988>>1]=0;J[c+102964>>2]=a;J[c+102968>>2]=b;J[c+102984>>2]=0;J[c+102996>>2]=0;J[c+103e3>>2]=0;J[c+102944>>2]=c;a=c+103004|0;J[a>>2]=0;J[a+4>>2]=0;a=c+103012|0;J[a>>2]=0;J[a+4>>2]=0;a=c+103020|0;J[a>>2]=0;J[a+4>>2]=0;return c|0}function Id(a,b,c,d,e){var f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=0,r=0,s=Q(0),t=0,u=Q(0),v=0,w=0;J[a+60>>2]=0;t=J[b+24>>2];q=J[b+16>>2];f=N[c+12>>2];g=N[e+12>>2];h=N[d+12>>2];i=N[d+16>>2];k=N[e+8>>2];l=Q(Q(N[e>>2]+Q(Q(g*h)-Q(i*k)))-N[c>>2]);h=Q(Q(Q(Q(k*h)+Q(g*i))+N[e+4>>2])-N[c+4>>2]);m=N[c+8>>2];i=Q(Q(f*l)+Q(h*m));e=J[b+12>>2];c=J[b+20>>2];r=K[b+44|0];k=N[b+24>>2];j=N[b+16>>2];g=Q(k-j);n=N[b+12>>2];o=Q(i-n);l=Q(Q(f*h)-Q(m*l));p=Q(l-j);m=N[b+20>>2];f=Q(m-n);u=Q(Q(g*o)-Q(p*f));a:{if(u>2]+N[d+8>>2]);s=Q(Q(f*o)+Q(p*g));b:{if(s<=Q(0)){if(Q(Q(o*o)+Q(p*p))>Q(h*h)){break a}if(!r){g=Q(0);f=Q(0);break b}g=Q(0);f=Q(0);if(!(Q(Q(Q(n-N[b+28>>2])*Q(n-i))+Q(Q(j-l)*Q(j-N[b+32>>2])))>Q(0))){break b}break a}o=Q(Q(f*Q(m-i))+Q(g*Q(k-l)));if(o<=Q(0)){i=Q(i-m);j=Q(l-k);if(Q(Q(i*i)+Q(j*j))>Q(h*h)){break a}v=1;if(!r){g=Q(0);f=Q(0);e=c;q=t;break b}g=Q(0);f=Q(0);e=c;q=t;if(!(Q(Q(Q(N[b+36>>2]-m)*i)+Q(j*Q(N[b+40>>2]-k)))>Q(0))){break b}break a}p=i;i=Q(Q(1)/Q(Q(f*f)+Q(g*g)));n=Q(p-Q(i*Q(Q(o*n)+Q(s*m))));i=Q(l-Q(i*Q(Q(o*j)+Q(s*k))));if(Q(Q(n*n)+Q(i*i))>Q(h*h)){break a}v=65536;w=1;b=u>2]=w;J[a+60>>2]=1;J[a+48>>2]=e;N[a+40>>2]=g;J[a+16>>2]=v;J[a+52>>2]=q;N[a+44>>2]=f;b=J[d+16>>2];J[a>>2]=J[d+12>>2];J[a+4>>2]=b}}function Se(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,f=0;e=a+16|0;d=e;c=J[a+16>>2];a:{b:{if(!c){break b}while(1){d=c;c=J[c+16>>2];if(c>>>0>b>>>0){e=d;c=J[d>>2];if(c){continue}break b}if(b>>>0<=c>>>0){break a}c=J[d+4>>2];if(c){continue}break}e=d+4|0}c=Xa(20);J[c+8>>2]=d;J[c>>2]=0;J[c+4>>2]=0;J[c+16>>2]=b;J[e>>2]=c;b=J[J[a+12>>2]>>2];if(b){J[a+12>>2]=b;b=J[e>>2]}else{b=c}f=J[a+16>>2];d=(f|0)==(b|0);H[b+12|0]=d;c:{if(d){break c}while(1){c=J[b+8>>2];if(K[c+12|0]){break c}d:{d=J[c+8>>2];e=J[d>>2];if((e|0)==(c|0)){e=J[d+4>>2];if(!(!e|K[e+12|0])){break d}e:{if(J[c>>2]==(b|0)){b=c;break e}b=J[c+4>>2];e=J[b>>2];J[c+4>>2]=e;if(e){J[e+8>>2]=c;d=J[c+8>>2]}J[b+8>>2]=d;d=J[c+8>>2];J[((J[d>>2]!=(c|0))<<2)+d>>2]=b;J[b>>2]=c;J[c+8>>2]=b;d=J[b+8>>2];c=J[d>>2]}H[b+12|0]=1;H[d+12|0]=0;b=J[c+4>>2];J[d>>2]=b;if(b){J[b+8>>2]=d}J[c+8>>2]=J[d+8>>2];b=J[d+8>>2];J[((J[b>>2]!=(d|0))<<2)+b>>2]=c;J[c+4>>2]=d;J[d+8>>2]=c;break c}if(!(K[e+12|0]|!e)){break d}f:{if(J[c>>2]!=(b|0)){b=c;break f}e=J[b+4>>2];J[c>>2]=e;if(e){J[e+8>>2]=c;d=J[c+8>>2]}J[b+8>>2]=d;d=J[c+8>>2];J[((J[d>>2]!=(c|0))<<2)+d>>2]=b;J[b+4>>2]=c;J[c+8>>2]=b;d=J[b+8>>2]}H[b+12|0]=1;H[d+12|0]=0;b=J[d+4>>2];c=J[b>>2];J[d+4>>2]=c;if(c){J[c+8>>2]=d}J[b+8>>2]=J[d+8>>2];c=J[d+8>>2];J[((J[c>>2]!=(d|0))<<2)+c>>2]=b;J[b>>2]=d;J[d+8>>2]=b;break c}H[c+12|0]=1;H[d+12|0]=(d|0)==(f|0);H[e+12|0]=1;b=d;if((f|0)!=(d|0)){continue}break}}J[a+20>>2]=J[a+20>>2]+1}}function xh(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=0,f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=0,k=Q(0),l=0,m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0),z=Q(0),A=Q(0),B=Q(0),C=Q(0),D=Q(0),E=Q(0),F=Q(0),G=Q(0),H=Q(0),I=Q(0);g=N[a+240>>2];e=J[b+28>>2];c=e+P(J[a+160>>2],12)|0;i=N[c>>2];j=e+P(J[a+168>>2],12)|0;n=N[j>>2];f=N[c+4>>2];o=N[j+4>>2];h=N[a+244>>2];k=N[a+248>>2];l=e+P(J[a+164>>2],12)|0;p=N[l>>2];e=e+P(J[a+172>>2],12)|0;q=N[e>>2];r=N[l+4>>2];s=N[e+4>>2];m=N[a+252>>2];t=N[a+256>>2];u=N[c+8>>2];v=N[j+8>>2];w=N[a+264>>2];x=N[a+260>>2];y=N[l+8>>2];z=N[e+8>>2];A=N[a+268>>2];d=Q(Q(Q(Q(Q(g*Q(i-n))+Q(Q(f-o)*h))+Q(Q(k*Q(p-q))+Q(Q(r-s)*m)))+Q(Q(Q(t*u)-Q(v*w))+Q(Q(x*y)-Q(z*A))))*Q(-N[a+272>>2]));N[a+156>>2]=N[a+156>>2]+d;B=N[a+236>>2];C=N[a+220>>2];D=N[a+232>>2];E=N[a+216>>2];F=N[a+228>>2];G=N[a+212>>2];H=N[a+224>>2];I=f;f=Q(N[a+208>>2]*d);N[c+4>>2]=I+Q(h*f);N[c>>2]=i+Q(g*f);c=J[b+28>>2];N[(c+P(J[a+160>>2],12)|0)+8>>2]=u+Q(t*Q(H*d));c=c+P(J[a+164>>2],12)|0;i=Q(d*G);N[c+4>>2]=r+Q(m*i);N[c>>2]=p+Q(k*i);c=J[b+28>>2];N[(c+P(J[a+164>>2],12)|0)+8>>2]=y+Q(x*Q(d*F));c=c+P(J[a+168>>2],12)|0;f=h;h=Q(d*E);N[c+4>>2]=o-Q(f*h);N[c>>2]=n-Q(g*h);c=J[b+28>>2];N[(c+P(J[a+168>>2],12)|0)+8>>2]=v-Q(w*Q(d*D));c=c+P(J[a+172>>2],12)|0;g=Q(d*C);N[c+4>>2]=s-Q(m*g);N[c>>2]=q-Q(k*g);N[(J[b+28>>2]+P(J[a+172>>2],12)|0)+8>>2]=z-Q(A*Q(d*B))}function Yg(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=0,g=Q(0),h=Q(0),i=Q(0),j=0,k=Q(0),l=Q(0),m=0,n=Q(0),o=0,p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0);j=J[a+52>>2];o=J[j+8>>2];J[a+116>>2]=o;s=N[j+32>>2];m=J[j+32>>2];e=N[j+28>>2];f=J[j+28>>2];J[a+128>>2]=f;J[a+132>>2]=m;k=N[j+120>>2];N[a+136>>2]=k;l=N[j+128>>2];N[a+140>>2]=l;m=P(o,12);f=m+J[b+28>>2]|0;p=N[f+4>>2];q=N[f>>2];t=N[f+8>>2];f=J[b+24>>2]+m|0;u=N[f>>2];v=N[f+4>>2];i=N[f+8>>2];g=N[b>>2];d=N[j+116>>2];c=Q(N[a+84>>2]*Q(6.2831854820251465));h=Q(g*Q(d*Q(c*c)));d=Q(g*Q(h+Q(c*Q(Q(d+d)*N[a+88>>2]))));c=d!=Q(0)?Q(Q(1)/d):d;N[a+108>>2]=c;h=Q(h*c);N[a+92>>2]=h;g=N[a+72>>2];d=Za(i);n=N[a+68>>2];r=_a(i);e=Q(n-e);g=Q(g-s);i=Q(Q(r*e)-Q(d*g));N[a+120>>2]=i;d=Q(Q(d*e)+Q(r*g));N[a+124>>2]=d;g=Q(c+Q(k+Q(Q(l*i)*i)));n=Q(c+Q(k+Q(Q(l*d)*d)));e=Q(d*Q(i*Q(-l)));c=Q(Q(g*n)-Q(e*e));c=c!=Q(0)?Q(Q(1)/c):c;N[a+144>>2]=g*c;N[a+156>>2]=n*c;c=Q(e*Q(-c));N[a+148>>2]=c;N[a+152>>2]=c;N[a+164>>2]=h*Q(Q(v+d)-N[a+80>>2]);N[a+160>>2]=h*Q(Q(u+i)-N[a+76>>2]);c=Q(t*Q(.9800000190734863));a:{if(K[b+20|0]){e=N[b+8>>2];h=Q(e*N[a+96>>2]);N[a+96>>2]=h;e=Q(e*N[a+100>>2]);N[a+100>>2]=e;c=Q(Q(l*Q(Q(i*e)-Q(h*d)))+c);q=Q(q+Q(k*h));p=Q(p+Q(k*e));break a}J[a+96>>2]=0;J[a+100>>2]=0}f=J[b+28>>2]+P(o,12)|0;N[f+4>>2]=p;N[f>>2]=q;N[(J[b+28>>2]+P(J[a+116>>2],12)|0)+8>>2]=c}function lf(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,f=0,g=0;f=La+-64|0;La=f;a:{if(gb(b,18336,0)){J[c>>2]=0;d=1;break a}b:{if(K[a+8|0]&24){e=1}else{if(!b){break b}e=sb(b,18068);if(!e){break b}e=(K[e+8|0]&24)!=0}g=gb(a,b,e)}if(g){d=1;a=J[c>>2];if(!a){break a}J[c>>2]=J[a>>2];break a}c:{if(!b){break c}e=sb(b,18116);if(!e){break a}b=J[c>>2];if(b){J[c>>2]=J[b>>2]}g=J[e+8>>2];b=J[a+8>>2];if(g&(b^-1)&7|b&(g^-1)&96){break a}d=1;if(gb(J[a+12>>2],J[e+12>>2],0)){break a}if(gb(J[a+12>>2],18324,0)){a=J[e+12>>2];if(!a){break a}d=!sb(a,18168);break a}g=J[a+12>>2];if(!g){break c}d=0;b=sb(g,18116);if(b){if(!(H[a+8|0]&1)){break a}a=J[e+12>>2];c=0;d:{e:{while(1){d=0;if(!a){break d}a=sb(a,18116);if(!a|J[a+8>>2]&(J[b+8>>2]^-1)){break e}d=1;if(gb(J[b+12>>2],J[a+12>>2],0)){break d}if(!(H[b+8|0]&1)){break e}d=J[b+12>>2];if(!d){break e}b=sb(d,18116);if(b){a=J[a+12>>2];continue}break}b=sb(d,18228);if(!b){break e}c=Lc(b,J[a+12>>2])}d=c}break a}b=sb(g,18228);if(b){if(!(H[a+8|0]&1)){break a}d=Lc(b,J[e+12>>2]);break a}b=sb(g,18020);if(!b){break a}a=J[e+12>>2];if(!a){break a}a=sb(a,18020);if(!a){break a}Db(f+12|0,0,52);J[f+56>>2]=1;J[f+20>>2]=-1;J[f+16>>2]=b;J[f+8>>2]=a;Na[J[J[a>>2]+28>>2]](a,f+8|0,J[c>>2],1);a=J[f+32>>2];if(!(!J[c>>2]|(a|0)!=1)){J[c>>2]=J[f+24>>2]}d=(a|0)==1;break a}d=0}La=f- -64|0;return d|0}function mh(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=0,g=Q(0),h=0,i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0);h=J[b+28>>2];f=h+P(J[a+104>>2],12)|0;m=N[f>>2];h=h+P(J[a+108>>2],12)|0;n=N[h>>2];o=N[f+4>>2];p=N[h+4>>2];q=N[a+160>>2];r=N[a+156>>2];s=N[a+168>>2];t=N[a+164>>2];g=N[b>>2];c=Q(g*N[a+96>>2]);i=Q(-c);j=N[a+88>>2];d=Q(N[b+4>>2]*N[a+100>>2]);e=N[h+8>>2];k=N[f+8>>2];l=Q(j-Q(N[a+188>>2]*Q(Q(d*N[a+152>>2])+Q(e-k))));c=c>l?l:c;c=c>2]=c;l=N[a+80>>2];u=N[a+116>>2];c=Q(c-j);i=Q(k-Q(t*c));k=N[a+124>>2];j=Q(e+Q(s*c));e=Q(Q(d*N[a+144>>2])+Q(Q(u*i)+Q(Q(n-Q(k*j))-m)));v=N[a+120>>2];w=N[a+112>>2];d=Q(Q(d*N[a+148>>2])+Q(Q(Q(p+Q(v*j))-o)-Q(w*i)));c=Q(l-Q(Q(N[a+172>>2]*e)+Q(N[a+180>>2]*d)));N[a+80>>2]=c;x=N[a+84>>2];d=Q(x-Q(Q(N[a+176>>2]*e)+Q(N[a+184>>2]*d)));N[a+84>>2]=d;e=Q(Q(c*c)+Q(d*d));g=Q(g*N[a+92>>2]);if(e>Q(g*g)){e=Q(Y(e));if(!(e>2]=d;c=Q(g*c);N[a+80>>2]=c}d=Q(d-x);N[f+4>>2]=o-Q(r*d);c=Q(c-l);N[f>>2]=m-Q(r*c);f=J[b+28>>2];N[(f+P(J[a+104>>2],12)|0)+8>>2]=Q(Q(-t)*Q(Q(w*d)-Q(c*u)))+i;f=f+P(J[a+108>>2],12)|0;N[f+4>>2]=p+Q(q*d);N[f>>2]=n+Q(q*c);N[(J[b+28>>2]+P(J[a+108>>2],12)|0)+8>>2]=Q(s*Q(Q(v*d)-Q(c*k)))+j}function ij(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,f=0,g=0,h=0,i=0,j=0,k=0;e=J[a>>2];f=J[a+4>>2]-e>>2;if(f>>>0>>0){e=b-f|0;f=a;a:{d=J[a+8>>2];b=J[a+4>>2];if(e>>>0<=d-b>>2>>>0){b:{if(!e){break b}a=b;g=e&7;if(g){d=0;while(1){J[a>>2]=J[c>>2];a=a+4|0;d=d+1|0;if((g|0)!=(d|0)){continue}break}}b=(e<<2)+b|0;if((e-1&1073741823)>>>0<7){break b}while(1){J[a>>2]=J[c>>2];J[a+4>>2]=J[c>>2];J[a+8>>2]=J[c>>2];J[a+12>>2]=J[c>>2];J[a+16>>2]=J[c>>2];J[a+20>>2]=J[c>>2];J[a+24>>2]=J[c>>2];J[a+28>>2]=J[c>>2];a=a+32|0;if((b|0)!=(a|0)){continue}break}}J[f+4>>2]=b;break a}c:{g=J[f>>2];h=b-g>>2;a=h+e|0;if(a>>>0<1073741824){d=d-g|0;i=d>>1;i=d>>>0>=2147483644?1073741823:a>>>0>>0?i:a;if(i){if(i>>>0>=1073741824){break c}j=Xa(i<<2)}d=(h<<2)+j|0;a=d;h=e&7;if(h){while(1){J[a>>2]=J[c>>2];a=a+4|0;k=k+1|0;if((h|0)!=(k|0)){continue}break}}h=(e<<2)+d|0;if((e-1&1073741823)>>>0>=7){while(1){J[a>>2]=J[c>>2];J[a+4>>2]=J[c>>2];J[a+8>>2]=J[c>>2];J[a+12>>2]=J[c>>2];J[a+16>>2]=J[c>>2];J[a+20>>2]=J[c>>2];J[a+24>>2]=J[c>>2];J[a+28>>2]=J[c>>2];a=a+32|0;if((h|0)!=(a|0)){continue}break}}if((b|0)!=(g|0)){while(1){d=d-4|0;b=b-4|0;J[d>>2]=J[b>>2];if((b|0)!=(g|0)){continue}break}}J[f+8>>2]=(i<<2)+j;J[f+4>>2]=h;J[f>>2]=d;if(g){ab(g)}break a}ma();B()}Tb();B()}return}if(b>>>0>>0){J[a+4>>2]=e+(b<<2)}}function Jh(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=0,g=Q(0),h=Q(0),i=Q(0),j=0,k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0);if(N[a+68>>2]>Q(0)){a=1}else{d=N[a+144>>2];i=N[a+84>>2];j=J[b+24>>2];f=j+P(J[a+108>>2],12)|0;q=N[f+8>>2];c=_a(q);k=N[a+140>>2];n=N[a+80>>2];e=Za(q);g=N[a+152>>2];o=N[a+92>>2];j=j+P(J[a+112>>2],12)|0;r=N[j+8>>2];h=_a(r);l=N[a+148>>2];p=N[a+88>>2];m=Za(r);s=N[j>>2];l=Q(p-l);g=Q(o-g);o=Q(Q(h*l)-Q(m*g));p=N[f>>2];k=Q(n-k);i=Q(i-d);n=Q(Q(c*k)-Q(e*i));d=Q(Q(Q(s+o)-p)-n);t=N[j+4>>2];m=Q(Q(m*l)+Q(h*g));g=N[f+4>>2];i=Q(Q(e*k)+Q(c*i));c=Q(Q(Q(t+m)-g)-i);e=Q(Y(Q(Q(d*d)+Q(c*c))));a:{if(e>2];h=N[a+160>>2];l=N[a+164>>2];v=g;g=N[a+156>>2];w=c;c=Q(e-N[a+104>>2]);c=c>2]));e=Q(w*u);N[f+4>>2]=v-Q(g*e);d=Q(d*u);N[f>>2]=p-Q(g*d);f=J[b+24>>2];N[(f+P(J[a+108>>2],12)|0)+8>>2]=q-Q(l*Q(Q(n*e)-Q(d*i)));f=f+P(J[a+112>>2],12)|0;N[f+4>>2]=t+Q(h*e);N[f>>2]=s+Q(h*d);N[(J[b+24>>2]+P(J[a+112>>2],12)|0)+8>>2]=Q(k*Q(Q(o*e)-Q(d*m)))+r;a=(c>Q(0)?c:Q(-c))>2];e=h+P(J[a+104>>2],12)|0;m=N[e>>2];h=h+P(J[a+108>>2],12)|0;n=N[h>>2];o=N[e+4>>2];p=N[h+4>>2];q=N[a+148>>2];r=N[a+144>>2];s=N[a+156>>2];t=N[a+152>>2];g=N[b>>2];c=Q(g*N[a+100>>2]);d=Q(-c);i=N[a+92>>2];j=N[h+8>>2];k=N[e+8>>2];l=Q(i-Q(Q(j-k)*N[a+176>>2]));c=c>l?l:c;c=c>2]=c;l=N[a+84>>2];u=N[a+116>>2];c=Q(c-i);i=Q(k-Q(t*c));k=N[a+124>>2];j=Q(j+Q(s*c));d=Q(Q(u*i)+Q(Q(n-Q(k*j))-m));v=N[a+120>>2];w=N[a+112>>2];f=Q(Q(Q(p+Q(v*j))-o)-Q(w*i));c=Q(l-Q(Q(N[a+160>>2]*d)+Q(N[a+168>>2]*f)));N[a+84>>2]=c;x=N[a+88>>2];d=Q(x-Q(Q(N[a+164>>2]*d)+Q(N[a+172>>2]*f)));N[a+88>>2]=d;f=Q(Q(c*c)+Q(d*d));g=Q(g*N[a+96>>2]);if(f>Q(g*g)){f=Q(Y(f));if(!(f>2]=d;c=Q(g*c);N[a+84>>2]=c}d=Q(d-x);N[e+4>>2]=o-Q(r*d);c=Q(c-l);N[e>>2]=m-Q(r*c);e=J[b+28>>2];N[(e+P(J[a+104>>2],12)|0)+8>>2]=Q(Q(-t)*Q(Q(w*d)-Q(c*u)))+i;e=e+P(J[a+108>>2],12)|0;N[e+4>>2]=p+Q(q*d);N[e>>2]=n+Q(q*c);N[(J[b+28>>2]+P(J[a+108>>2],12)|0)+8>>2]=Q(s*Q(Q(v*d)-Q(c*k)))+j}function bg(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=0,f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=0,k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0);d=N[a+132>>2];i=N[a+72>>2];j=J[b+24>>2];e=j+P(J[a+96>>2],12)|0;q=N[e+8>>2];c=_a(q);k=N[a+128>>2];n=N[a+68>>2];f=Za(q);g=N[a+140>>2];o=N[a+80>>2];j=j+P(J[a+100>>2],12)|0;r=N[j+8>>2];h=_a(r);l=N[a+136>>2];p=N[a+76>>2];m=Za(r);s=N[j>>2];l=Q(p-l);g=Q(o-g);o=Q(Q(h*l)-Q(m*g));p=N[e>>2];k=Q(n-k);i=Q(i-d);n=Q(Q(c*k)-Q(f*i));d=Q(Q(Q(s+o)-p)-n);t=N[j+4>>2];m=Q(Q(m*l)+Q(h*g));g=N[e+4>>2];i=Q(Q(f*k)+Q(c*i));c=Q(Q(Q(t+m)-g)-i);f=Q(Y(Q(Q(d*d)+Q(c*c))));a:{if(f>2]=f;k=N[a+156>>2];h=N[a+148>>2];l=N[a+152>>2];u=g;g=N[a+144>>2];v=c;c=Q(f-N[a+84>>2]);c=c>2]));c=Q(v*f);N[e+4>>2]=u-Q(g*c);d=Q(d*f);N[e>>2]=p-Q(g*d);e=J[b+24>>2];N[(e+P(J[a+96>>2],12)|0)+8>>2]=q-Q(l*Q(Q(n*c)-Q(d*i)));e=e+P(J[a+100>>2],12)|0;N[e+4>>2]=t+Q(h*c);N[e>>2]=s+Q(h*d);N[(J[b+24>>2]+P(J[a+100>>2],12)|0)+8>>2]=Q(k*Q(Q(o*c)-Q(d*m)))+r;return Q(N[a+88>>2]-N[a+84>>2])>2],e)){if(!(J[b+28>>2]==1|J[b+4>>2]!=(c|0))){J[b+28>>2]=d}return}a:{if(gb(a,J[b>>2],e)){if(!(J[b+16>>2]!=(c|0)&J[b+20>>2]!=(c|0))){if((d|0)!=1){break a}J[b+32>>2]=1;return}J[b+32>>2]=d;if(J[b+44>>2]!=4){f=a+16|0;h=f+(J[a+12>>2]<<3)|0;d=0;b:{c:{while(1){d:{if(f>>>0>=h>>>0){break d}I[b+52>>1]=0;nc(f,b,c,c,1,e);if(K[b+54|0]){break d}e:{if(!K[b+53|0]){break e}if(K[b+52|0]){d=1;if(J[b+24>>2]==1){break c}g=1;if(K[a+8|0]&2){break e}break c}g=1;if(!(H[a+8|0]&1)){break c}}f=f+8|0;continue}break}a=4;if(!g){break b}}a=3}J[b+44>>2]=a;if(d&1){break a}}J[b+20>>2]=c;J[b+40>>2]=J[b+40>>2]+1;if(J[b+36>>2]!=1|J[b+24>>2]!=2){break a}H[b+54|0]=1;return}g=J[a+12>>2];h=a+16|0;bc(h,b,c,d,e);f=a+24|0;g=h+(g<<3)|0;if(f>>>0>=g>>>0){break a}a=J[a+8>>2];if(!(!(a&2)&J[b+36>>2]!=1)){while(1){if(K[b+54|0]){break a}bc(f,b,c,d,e);f=f+8|0;if(g>>>0>f>>>0){continue}break}break a}if(!(a&1)){while(1){if(K[b+54|0]|J[b+36>>2]==1){break a}bc(f,b,c,d,e);f=f+8|0;if(g>>>0>f>>>0){continue}break a}}while(1){if(K[b+54|0]|J[b+36>>2]==1&J[b+24>>2]==1){break a}bc(f,b,c,d,e);f=f+8|0;if(g>>>0>f>>>0){continue}break}}}function Ld(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=Q(0);e=J[a+88>>2];if(!K[e+102989|0]){c=eb(e,44);J[c+40>>2]=0;J[c+32>>2]=-65535;J[c+24>>2]=0;J[c+28>>2]=0;J[c>>2]=0;J[c+4>>2]=0;I[c+36>>1]=0;J[c+8>>2]=0;J[c+12>>2]=0;J[c+40>>2]=J[b+4>>2];N[c+16>>2]=N[b+8>>2];j=N[b+12>>2];J[c+8>>2]=a;N[c+20>>2]=j;J[c+4>>2]=0;d=L[b+22>>1]|L[b+24>>1]<<16;I[c+32>>1]=d;I[c+34>>1]=d>>>16;I[c+36>>1]=L[b+26>>1];H[c+38|0]=K[b+20|0];d=J[b>>2];d=Na[J[J[d>>2]+8>>2]](d,e)|0;J[c+12>>2]=d;g=Na[J[J[d>>2]+12>>2]](d)|0;d=eb(e,P(g,28));J[c+24>>2]=d;a:{if((g|0)<=0){break a}e=0;if(g>>>0>=4){i=g&-4;while(1){f=d+P(e,28)|0;J[f+24>>2]=-1;J[f+16>>2]=0;f=d+P(e|1,28)|0;J[f+24>>2]=-1;J[f+16>>2]=0;f=d+P(e|2,28)|0;J[f+24>>2]=-1;J[f+16>>2]=0;f=d+P(e|3,28)|0;J[f+24>>2]=-1;J[f+16>>2]=0;e=e+4|0;h=h+4|0;if((i|0)!=(h|0)){continue}break}}g=g&3;if(!g){break a}h=0;while(1){i=d+P(e,28)|0;J[i+24>>2]=-1;J[i+16>>2]=0;e=e+1|0;h=h+1|0;if((g|0)!=(h|0)){continue}break}}J[c+28>>2]=0;N[c>>2]=N[b+16>>2];if(K[a+4|0]&32){Ed(c,J[a+88>>2]+102868|0,a+12|0)}J[c+4>>2]=J[a+100>>2];J[a+100>>2]=c;J[a+104>>2]=J[a+104>>2]+1;J[c+8>>2]=a;if(N[c>>2]>Q(0)){Sb(a)}H[J[a+88>>2]+102988|0]=1}return c|0}function ph(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,f=0;c=La-80|0;La=c;d=J[a+52>>2];e=J[a+48>>2];f=J[e+16>>2];J[c+72>>2]=J[e+12>>2];J[c+76>>2]=f;e=J[d+16>>2];J[c+64>>2]=J[d+12>>2];J[c+68>>2]=e;Na[J[J[a>>2]>>2]](c+56|0,a);Na[J[J[a>>2]+4>>2]](c+48|0,a);J[c+40>>2]=1061997773;J[c+44>>2]=1065353216;J[c+32>>2]=1056964608;J[c+36>>2]=1061997773;a:{b:{switch(J[a+4>>2]-3|0){case 0:Na[J[J[b>>2]+24>>2]](b,c+56|0,c+48|0,c+32|0);break a;case 1:f=J[a+72>>2];e=c+8|0;d=e;J[d>>2]=J[a+68>>2];J[d+4>>2]=f;f=J[a+80>>2];d=c+24|0;J[d>>2]=J[a+76>>2];J[d+4>>2]=f;a=c+32|0;Na[J[J[b>>2]+24>>2]](b,e,c+56|0,a);Na[J[J[b>>2]+24>>2]](b,d,c+48|0,a);Na[J[J[b>>2]+24>>2]](b,e,d,a);break a;case 2:J[c+16>>2]=0;J[c+20>>2]=1065353216;J[c+8>>2]=0;J[c+12>>2]=1065353216;d=c+56|0;a=c+8|0;Na[J[J[b>>2]+32>>2]](b,d,Q(4),a);e=c+48|0;Na[J[J[b>>2]+32>>2]](b,e,Q(4),a);J[c+16>>2]=1061997773;J[c+20>>2]=1065353216;J[c+8>>2]=1061997773;J[c+12>>2]=1061997773;Na[J[J[b>>2]+24>>2]](b,d,e,a);break a;default:break b}}d=c+56|0;a=c+32|0;Na[J[J[b>>2]+24>>2]](b,c+72|0,d,a);e=d;d=c+48|0;Na[J[J[b>>2]+24>>2]](b,e,d,a);Na[J[J[b>>2]+24>>2]](b,c- -64|0,d,a)}La=c+80|0}function rb(a,b,c){var d=0,e=0,f=0;if(c>>>0>=512){Ha(a|0,b|0,c|0);return a}e=a+c|0;a:{if(!((a^b)&3)){b:{if(!(a&3)){c=a;break b}if(!c){c=a;break b}c=a;while(1){H[c|0]=K[b|0];b=b+1|0;c=c+1|0;if(!(c&3)){break b}if(c>>>0>>0){continue}break}}d=e&-4;c:{if(d>>>0<64){break c}f=d+-64|0;if(f>>>0>>0){break c}while(1){J[c>>2]=J[b>>2];J[c+4>>2]=J[b+4>>2];J[c+8>>2]=J[b+8>>2];J[c+12>>2]=J[b+12>>2];J[c+16>>2]=J[b+16>>2];J[c+20>>2]=J[b+20>>2];J[c+24>>2]=J[b+24>>2];J[c+28>>2]=J[b+28>>2];J[c+32>>2]=J[b+32>>2];J[c+36>>2]=J[b+36>>2];J[c+40>>2]=J[b+40>>2];J[c+44>>2]=J[b+44>>2];J[c+48>>2]=J[b+48>>2];J[c+52>>2]=J[b+52>>2];J[c+56>>2]=J[b+56>>2];J[c+60>>2]=J[b+60>>2];b=b- -64|0;c=c- -64|0;if(f>>>0>=c>>>0){continue}break}}if(c>>>0>=d>>>0){break a}while(1){J[c>>2]=J[b>>2];b=b+4|0;c=c+4|0;if(d>>>0>c>>>0){continue}break}break a}if(e>>>0<4){c=a;break a}d=e-4|0;if(d>>>0>>0){c=a;break a}c=a;while(1){H[c|0]=K[b|0];H[c+1|0]=K[b+1|0];H[c+2|0]=K[b+2|0];H[c+3|0]=K[b+3|0];b=b+4|0;c=c+4|0;if(d>>>0>=c>>>0){continue}break}}if(c>>>0>>0){while(1){H[c|0]=K[b|0];b=b+1|0;c=c+1|0;if((e|0)!=(c|0)){continue}break}}return a}function Ff(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,f=0,g=0,h=0,i=0;g=La-16|0;La=g;J[g+12>>2]=b;h=a+102868|0;J[g+8>>2]=h;d=La-1040|0;La=d;J[d+1036>>2]=256;b=d+8|0;J[d+4>>2]=b;J[d+8>>2]=J[h>>2];a=b;e=1;while(1){a:{e=e-1|0;J[d+1032>>2]=e;f=J[(e<<2)+a>>2];b:{if((f|0)==-1){break b}i=P(f,40);f=i+J[h+4>>2]|0;if(Q(N[c>>2]-N[f+8>>2])>Q(0)|Q(N[c+4>>2]-N[f+12>>2])>Q(0)|(Q(N[f>>2]-N[c+8>>2])>Q(0)|Q(N[f+4>>2]-N[c+12>>2])>Q(0))){break b}if(J[f+24>>2]==-1){a=J[g+12>>2];e=Na[J[J[a>>2]+8>>2]](a,J[J[(J[J[g+8>>2]+4>>2]+i|0)+16>>2]+16>>2])|0;a=J[d+4>>2];if(!e){break a}e=J[d+1032>>2];if((e|0)>0){continue}break a}c:{if(J[d+1036>>2]!=(e|0)){break c}J[d+1036>>2]=e<<1;e=fb(e<<3);J[d+4>>2]=e;rb(e,a,J[d+1032>>2]<<2);if((a|0)==(b|0)){break c}ab(a)}a=J[d+4>>2];J[a+(J[d+1032>>2]<<2)>>2]=J[f+24>>2];e=J[d+1032>>2]+1|0;J[d+1032>>2]=e;d:{if((e|0)!=J[d+1036>>2]){break d}J[d+1036>>2]=e<<1;e=fb(e<<3);J[d+4>>2]=e;rb(e,a,J[d+1032>>2]<<2);if((a|0)==(b|0)){break d}ab(a)}a=J[d+4>>2];J[a+(J[d+1032>>2]<<2)>>2]=J[f+28>>2];e=J[d+1032>>2]+1|0;J[d+1032>>2]=e}if((e|0)>0){continue}}break}if((a|0)!=(b|0)){ab(a)}La=d+1040|0;La=g+16|0} +function Sb(a){a=a|0;var b=Q(0),c=Q(0),d=Q(0),e=Q(0),f=0,g=0,h=Q(0),i=0,j=Q(0),k=Q(0);g=La-16|0;La=g;J[a+116>>2]=0;J[a+120>>2]=0;J[a+28>>2]=0;J[a+32>>2]=0;J[a+124>>2]=0;J[a+128>>2]=0;a:{if(M[a>>2]<=1){f=J[a+16>>2];i=J[a+12>>2];J[a+44>>2]=i;J[a+48>>2]=f;J[a+36>>2]=i;J[a+40>>2]=f;N[a+52>>2]=N[a+56>>2];break a}c=N[3050];d=N[3049];b:{c:{f=J[a+100>>2];if(!f){break c}while(1){b=N[f>>2];if(b!=Q(0)){i=J[f+12>>2];Na[J[J[i>>2]+28>>2]](i,g,b);b=N[g>>2];e=Q(b+N[a+116>>2]);N[a+116>>2]=e;j=N[g+4>>2];k=N[g+8>>2];h=Q(N[g+12>>2]+N[a+124>>2]);N[a+124>>2]=h;d=Q(d+Q(b*j));c=Q(c+Q(b*k))}f=J[f+4>>2];if(f){continue}break}if(e>Q(0)){b=Q(Q(1)/e);N[a+120>>2]=b;d=Q(d*b);c=Q(c*b)}if(!(h>Q(0))|K[a+4|0]&16){break c}e=Q(h-Q(e*Q(Q(d*d)+Q(c*c))));N[a+124>>2]=e;b=Q(Q(1)/e);break b}J[a+124>>2]=0;b=Q(0)}N[a+128>>2]=b;N[a+32>>2]=c;N[a+28>>2]=d;b=N[a+44>>2];h=N[a+24>>2];j=N[a+20>>2];e=Q(N[a+12>>2]+Q(Q(h*d)-Q(c*j)));N[a+44>>2]=e;k=N[a+48>>2];c=Q(Q(Q(j*d)+Q(h*c))+N[a+16>>2]);N[a+48>>2]=c;N[a+40>>2]=c;N[a+36>>2]=e;d=N[a+72>>2];N[a+64>>2]=N[a+64>>2]-Q(d*Q(c-k));N[a+68>>2]=Q(d*Q(e-b))+N[a+68>>2]}La=g+16|0}function Kf(a,b){a=a|0;b=b|0;var c=0,d=0,e=Q(0),f=0,g=0,h=Q(0);if(!K[a+102989|0]){c=eb(a,152);d=K[b+39|0];I[c+4>>1]=((d|0)!=0)<<3;d=d<<3;if(K[b+38|0]){d=d|16;I[c+4>>1]=d}if(K[b+36|0]){d=d|4;I[c+4>>1]=d}if(!(!K[b+37|0]|!J[b>>2])){d=d|2;I[c+4>>1]=d}if(K[b+40|0]){I[c+4>>1]=d|32}J[c+88>>2]=a;f=J[b+8>>2];d=J[b+4>>2];J[c+12>>2]=d;J[c+16>>2]=f;e=N[b+12>>2];J[c+44>>2]=d;J[c+48>>2]=f;J[c+36>>2]=d;J[c+40>>2]=f;J[c+28>>2]=0;J[c+32>>2]=0;g=c,h=_a(e),N[g+24>>2]=h;g=c,h=Za(e),N[g+20>>2]=h;e=N[b+12>>2];J[c+108>>2]=0;J[c+112>>2]=0;J[c+60>>2]=0;N[c+56>>2]=e;N[c+52>>2]=e;J[c+92>>2]=0;J[c+96>>2]=0;d=J[b+20>>2];J[c+64>>2]=J[b+16>>2];J[c+68>>2]=d;N[c+72>>2]=N[b+24>>2];N[c+132>>2]=N[b+28>>2];N[c+136>>2]=N[b+32>>2];e=N[b+48>>2];J[c+144>>2]=0;J[c+84>>2]=0;J[c+76>>2]=0;J[c+80>>2]=0;N[c+140>>2]=e;d=J[b>>2];J[c+124>>2]=0;J[c+128>>2]=0;J[c>>2]=d;e=(d|0)==2?Q(1):Q(0);N[c+120>>2]=e;N[c+116>>2]=e;b=J[b+44>>2];J[c+100>>2]=0;J[c+104>>2]=0;J[c+148>>2]=b;d=c;J[c+92>>2]=0;b=J[a+102948>>2];J[c+96>>2]=b;if(b){J[b+92>>2]=d}J[a+102948>>2]=d;J[a+102956>>2]=J[a+102956>>2]+1}return d|0}function Nd(a,b){var c=0,d=0,e=0,f=0,g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=0;if(J[a>>2]==(b|0)){J[a>>2]=-1;return}f=J[a+4>>2];d=J[(f+P(b,40)|0)+20>>2];e=P(d,40)+f|0;c=J[e+20>>2];k=b;b=J[e+24>>2];if((k|0)==(b|0)){b=J[e+28>>2]}a:{if((c|0)!=-1){e=f+P(c,40)|0;J[((d|0)==J[e+24>>2]?e+24|0:e+28|0)>>2]=b;J[(f+P(b,40)|0)+20>>2]=c;b=P(d,40);J[(b+J[a+4>>2]|0)+20>>2]=J[a+16>>2];J[(b+J[a+4>>2]|0)+32>>2]=-1;J[a+16>>2]=d;J[a+8>>2]=J[a+8>>2]-1;while(1){b=Od(a,c);c=J[a+4>>2];e=P(b,40);b=c+e|0;f=P(J[b+28>>2],40);d=c+f|0;g=N[d>>2];k=P(J[b+24>>2],40);c=k+c|0;h=N[c>>2];i=N[c+4>>2];j=N[d+4>>2];N[b+4>>2]=i>2]=g>h?h:g;g=N[c+8>>2];h=N[d+8>>2];i=N[c+12>>2];j=N[d+12>>2];N[b+12>>2]=i>j?i:j;N[b+8>>2]=g>h?g:h;b=J[a+4>>2];d=b+e|0;c=J[(b+k|0)+32>>2];b=J[(b+f|0)+32>>2];J[d+32>>2]=((b|0)<(c|0)?c:b)+1;c=J[d+20>>2];if((c|0)!=-1){continue}break}break a}J[a>>2]=b;J[(f+P(b,40)|0)+20>>2]=-1;b=P(d,40);J[(b+J[a+4>>2]|0)+20>>2]=J[a+16>>2];J[(b+J[a+4>>2]|0)+32>>2]=-1;J[a+16>>2]=d;J[a+8>>2]=J[a+8>>2]-1}}function yg(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=0,n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0),w=Q(0),x=Q(0),y=Q(0);k=Q(-N[a+112>>2]);l=N[a+136>>2];m=J[b+28>>2];c=m+P(J[a+124>>2],12)|0;n=N[c>>2];j=N[c+8>>2];o=N[a+156>>2];p=N[c+4>>2];q=N[a+152>>2];r=N[a+140>>2];f=N[a+128>>2];c=P(J[a+120>>2],12)+m|0;s=N[c>>2];d=N[c+8>>2];t=N[a+148>>2];g=N[c+4>>2];u=N[a+144>>2];h=N[a+132>>2];e=Q(Q(Q(k*Q(Q(l*Q(n-Q(j*o)))+Q(Q(p+Q(j*q))*r)))-Q(Q(f*Q(s-Q(d*t)))+Q(Q(g+Q(d*u))*h)))*Q(-N[a+192>>2]));N[a+116>>2]=N[a+116>>2]+e;w=N[a+188>>2];v=N[a+180>>2];x=N[a+184>>2];y=g;g=N[a+176>>2];i=h;h=Q(-e);i=Q(i*h);N[c+4>>2]=y+Q(g*i);f=Q(f*h);N[c>>2]=s+Q(g*f);c=J[b+28>>2];N[(c+P(J[a+120>>2],12)|0)+8>>2]=d+Q(x*Q(Q(u*i)-Q(f*t)));c=c+P(J[a+124>>2],12)|0;d=Q(e*k);e=Q(r*d);N[c+4>>2]=p+Q(v*e);d=Q(l*d);N[c>>2]=n+Q(v*d);N[(J[b+28>>2]+P(J[a+124>>2],12)|0)+8>>2]=j+Q(w*Q(Q(q*e)-Q(d*o)))}function pi(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0);j=N[d+12>>2];g=N[d+4>>2];f=Q(N[c+4>>2]-g);k=N[d+8>>2];i=N[d>>2];h=Q(N[c>>2]-i);o=Q(Q(j*f)-Q(k*h));p=Q(Q(j*h)+Q(f*k));q=N[a+12>>2];m=Q(N[a+20>>2]-q);l=Q(-m);n=N[c+12>>2];u=N[c+8>>2];d=0;e=K[a+44|0];r=N[a+16>>2];h=Q(N[a+24>>2]-r);s=Q(Q(h*h)+Q(m*m));f=Q(Y(s));a:{if(fQ(0)?e:0){break b}i=Q(u-i);g=Q(n-g);n=Q(Q(Q(j*i)+Q(k*g))-p);i=Q(Q(Q(j*g)-Q(k*i))-o);g=Q(Q(f*n)+Q(i*l));if(g==Q(0)){break b}g=Q(t/g);if(gN[c+16>>2]|s==Q(0)){break b}h=Q(Q(Q(Q(Q(p+Q(n*g))-q)*m)+Q(h*Q(Q(o+Q(i*g))-r)))/s);if(hQ(1)){break b}N[b+8>>2]=g;h=Q(Q(k*f)+Q(j*l));a=t>Q(0);N[b+4>>2]=a?Q(-h):h;f=Q(Q(j*f)+Q(l*Q(-k)));N[b>>2]=a?Q(-f):f;d=1}return d|0}function cg(a,b){a=a|0;b=b|0;var c=Q(0),d=0,e=Q(0),f=Q(0),g=Q(0),h=0,i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0),v=Q(0);e=N[a+92>>2];c=Q(N[a+88>>2]-N[a+84>>2]);k=N[a+104>>2];d=J[b+28>>2];h=d+P(J[a+100>>2],12)|0;l=N[h>>2];i=N[h+8>>2];m=N[a+124>>2];d=d+P(J[a+96>>2],12)|0;n=N[d>>2];j=N[d+8>>2];o=N[a+116>>2];p=N[h+4>>2];q=N[a+120>>2];f=N[d+4>>2];r=N[a+112>>2];s=N[a+108>>2];g=Q(Q(k*Q(Q(l-Q(i*m))-Q(n-Q(j*o))))+Q(Q(Q(p+Q(i*q))-Q(f+Q(j*r)))*s));c=Q(e-Q(N[a+160>>2]*(c>2]*c)+g):g)));c=c>Q(0)?Q(0):c;N[a+92>>2]=c;t=N[a+156>>2];g=N[a+148>>2];u=N[a+152>>2];v=f;f=N[a+144>>2];c=Q(c-e);e=Q(s*c);N[d+4>>2]=v-Q(f*e);c=Q(k*c);N[d>>2]=n-Q(f*c);d=J[b+28>>2];N[(d+P(J[a+96>>2],12)|0)+8>>2]=j-Q(u*Q(Q(r*e)-Q(c*o)));d=d+P(J[a+100>>2],12)|0;N[d+4>>2]=p+Q(g*e);N[d>>2]=l+Q(g*c);N[(J[b+28>>2]+P(J[a+100>>2],12)|0)+8>>2]=i+Q(t*Q(Q(q*e)-Q(c*m)))}function gi(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=0,m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0);l=J[a+148>>2];if((l|0)<=0){return 0}g=N[d+4>>2];f=Q(N[c+12>>2]-g);h=N[d>>2];i=Q(N[c+8>>2]-h);j=N[d+12>>2];k=Q(N[c+4>>2]-g);g=N[d+8>>2];h=Q(N[c>>2]-h);m=Q(Q(j*k)-Q(g*h));p=Q(Q(Q(j*f)-Q(g*i))-m);n=Q(Q(j*h)+Q(k*g));q=Q(Q(Q(j*i)+Q(g*f))-n);r=Q(-g);k=N[c+16>>2];e=-1;d=0;h=Q(0);a:{while(1){c=(d<<3)+a|0;f=N[c+84>>2];o=N[c+88>>2];i=Q(Q(f*Q(N[c+20>>2]-n))+Q(Q(N[c+24>>2]-m)*o));f=Q(Q(f*q)+Q(p*o));b:{if(f==Q(0)){if(!(iQ(0))|!(ik)){d=d+1|0;if((l|0)==(d|0)){break a}continue}break}return 0}if((e|0)>=0){N[b+8>>2]=h;a=(e<<3)+a|0;f=N[a+84>>2];h=Q(g*f);g=N[a+88>>2];N[b+4>>2]=h+Q(j*g);N[b>>2]=Q(j*f)+Q(g*r);a=1}else{a=0}return a|0}function ti(a,b,c){a=a|0;b=b|0;c=c|0;var d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=0,j=Q(0),k=0;g=N[c+12>>2];f=N[c+4>>2];d=N[c>>2];e=Q(N[c+8>>2]-d);a:{b:{if((e>Q(0)?e:Q(-e))>2]|d>N[a+8>>2]){break a}e=Q(34028234663852886e22);d=Q(-34028234663852886e22);break b}e=Q(Q(1)/e);h=Q(e*Q(N[a+8>>2]-d));d=Q(e*Q(N[a>>2]-d));i=hQ(34028234663852886e22)?Q(34028234663852886e22):e;d=i?h:d;d=d>Q(-34028234663852886e22)?d:Q(-34028234663852886e22);if(eQ(0)?g:Q(-g))>2]-f));f=Q(j*Q(N[a+4>>2]-f));a=gd;d=i?j:d;f=a?f:g;if(d>(e>2]){break a}e=Q(0);if(f>N[a+12>>2]){break a}}if(d>2]>2]=e;N[b>>2]=h;N[b+8>>2]=d;k=1}return k|0}function $c(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,f=0,g=0;a:{if(K[a+102989|0]){break a}g=K[b+61|0];c=J[b+8>>2];if(c){J[c+12>>2]=J[b+12>>2]}d=J[b+12>>2];if(d){J[d+8>>2]=c}if(J[a+102952>>2]==(b|0)){J[a+102952>>2]=d}c=J[b+52>>2];d=J[b+48>>2];if(J[d>>2]){J[d+144>>2]=0;I[d+4>>1]=L[d+4>>1]|2}if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}e=J[b+24>>2];if(e){J[e+12>>2]=J[b+28>>2]}f=J[b+28>>2];if(f){J[f+8>>2]=e}if(J[d+108>>2]==(b+16|0)){J[d+108>>2]=f}J[b+24>>2]=0;J[b+28>>2]=0;e=J[b+40>>2];if(e){J[e+12>>2]=J[b+44>>2]}f=J[b+44>>2];if(f){J[f+8>>2]=e}if(J[c+108>>2]==(b+32|0)){J[c+108>>2]=f}J[b+40>>2]=0;J[b+44>>2]=0;Na[J[J[b>>2]+28>>2]](b)|0;e=J[b+4>>2]-1|0;if(e>>>0<=10){Ib(a,b,J[(e<<2)+12904>>2])}J[a+102960>>2]=J[a+102960>>2]-1;if(g){break a}b=J[c+112>>2];if(!b){break a}while(1){if((d|0)==J[b>>2]){a=J[b+4>>2];J[a+4>>2]=J[a+4>>2]|8}b=J[b+12>>2];if(b){continue}break}}}function eb(a,b){var c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0,k=0,l=0;if(!b){return 0}if((b|0)>=641){return fb(b)}d=K[b+23924|0];g=(d<<2)+a|0;b=J[g+12>>2];if(b){J[g+12>>2]=J[b>>2];return b}b=J[a+4>>2];if((b|0)==J[a+8>>2]){c=b+128|0;J[a+8>>2]=c;b=J[a>>2];c=fb(c<<3);J[a>>2]=c;rb(c,b,J[a+4>>2]<<3);Db(J[a>>2]+(J[a+4>>2]<<3)|0,0,1024);ab(b);b=J[a+4>>2]}h=J[a>>2]+(b<<3)|0;c=fb(16384);J[h+4>>2]=c;d=J[(d<<2)+12096>>2];J[h>>2]=d;e=16384/(d|0)|0;i=e-1|0;a:{if((e|0)<2){break a}b=0;if(e-2>>>0>=3){l=i&-4;e=0;while(1){f=c+P(d,b|1)|0;J[c+P(b,d)>>2]=f;j=f;f=c+P(d,b|2)|0;J[j>>2]=f;j=f;f=c+P(d,b|3)|0;J[j>>2]=f;b=b+4|0;J[f>>2]=c+P(d,b);e=e+4|0;if((l|0)!=(e|0)){continue}break}}e=i&3;if(!e){break a}while(1){f=c+P(b,d)|0;b=b+1|0;J[f>>2]=c+P(d,b);k=k+1|0;if((e|0)!=(k|0)){continue}break}}J[c+P(d,i)>>2]=0;J[g+12>>2]=J[c>>2];J[a+4>>2]=J[a+4>>2]+1;return J[h+4>>2]}function ll(a,b,c){var d=0,e=0,f=0,g=0,h=0,i=0,j=0,k=0,l=0;a:{b:{c:{d:{e:{f:{g:{h:{i:{j:{if(b){if(!c){break j}break i}Ma=0;a=(a>>>0)/(c>>>0)|0;break a}if(!a){break h}break g}if(!(c-1&c)){break f}f=(S(c)+33|0)-S(b)|0;g=0-f|0;break d}Ma=0;a=(b>>>0)/0|0;break a}d=32-S(b)|0;if(d>>>0<31){break e}break c}if((c|0)==1){break b}f=jl(c);c=f&31;if((f&63)>>>0>=32){a=b>>>c|0}else{d=b>>>c|0;a=((1<>>c}Ma=d;break a}f=d+1|0;g=63-d|0}d=f&63;e=d&31;if(d>>>0>=32){d=0;h=b>>>e|0}else{d=b>>>e|0;h=((1<>>e}g=g&63;e=g&31;if(g>>>0>=32){b=a<>>32-e|b<>>31;d=h<<1|b>>>31;e=l-(i+(d>>>0>g>>>0)|0)>>31;j=c&e;h=d-j|0;d=i-(d>>>0>>0)|0;b=b<<1|a>>>31;a=k|a<<1;k=e&1;f=f-1|0;if(f){continue}break}}Ma=b<<1|a>>>31;a=k|a<<1;break a}a=0;b=0}Ma=b}return a}function Kh(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=Q(0),g=0,h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0),u=Q(0);f=N[a+100>>2];l=N[a+116>>2];c=J[b+28>>2];g=c+P(J[a+112>>2],12)|0;m=N[g>>2];h=N[g+8>>2];n=N[a+136>>2];c=c+P(J[a+108>>2],12)|0;o=N[c>>2];i=N[c+8>>2];p=N[a+128>>2];e=N[a+120>>2];q=N[g+4>>2];r=N[a+132>>2];d=N[c+4>>2];s=N[a+124>>2];j=Q(Q(Q(f*N[a+96>>2])+Q(N[a+76>>2]+Q(Q(l*Q(Q(m-Q(h*n))-Q(o-Q(i*p))))+Q(e*Q(Q(q+Q(h*r))-Q(d+Q(i*s)))))))*Q(-N[a+172>>2]));N[a+100>>2]=f+j;u=N[a+168>>2];t=N[a+160>>2];f=N[a+164>>2];k=d;d=N[a+156>>2];e=Q(e*j);N[c+4>>2]=k-Q(d*e);k=d;d=Q(l*j);N[c>>2]=o-Q(k*d);c=J[b+28>>2];N[(c+P(J[a+108>>2],12)|0)+8>>2]=i-Q(f*Q(Q(s*e)-Q(d*p)));c=c+P(J[a+112>>2],12)|0;N[c+4>>2]=q+Q(e*t);N[c>>2]=m+Q(d*t);N[(J[b+28>>2]+P(J[a+112>>2],12)|0)+8>>2]=h+Q(u*Q(Q(r*e)-Q(d*n)))}function Kd(a){a=a|0;var b=0,c=Q(0),d=0;b=La-224|0;La=b;d=J[a+8>>2];Ya(6540,0);Ya(7693,0);J[b+208>>2]=J[a>>2];Ya(8915,b+208|0);c=N[a+12>>2];O[b+200>>3]=N[a+16>>2];O[b+192>>3]=c;Ya(8058,b+192|0);O[b+176>>3]=N[a+56>>2];Ya(7058,b+176|0);c=N[a+64>>2];O[b+168>>3]=N[a+68>>2];O[b+160>>3]=c;Ya(7870,b+160|0);O[b+144>>3]=N[a+72>>2];Ya(6605,b+144|0);O[b+128>>3]=N[a+132>>2];Ya(6977,b+128|0);O[b+112>>3]=N[a+136>>2];Ya(6948,b+112|0);J[b+96>>2]=L[a+4>>1]&4;Ya(8735,b+96|0);J[b+80>>2]=L[a+4>>1]&2;Ya(8796,b+80|0);J[b+64>>2]=L[a+4>>1]&16;Ya(8764,b- -64|0);J[b+48>>2]=L[a+4>>1]&8;Ya(8651,b+48|0);J[b+32>>2]=L[a+4>>1]&32;Ya(8855,b+32|0);O[b+16>>3]=N[a+140>>2];Ya(7157,b+16|0);J[b>>2]=J[a+8>>2];Ya(8579,b);Ya(9326,0);a=J[a+100>>2];if(a){while(1){Ya(6538,0);Dd(a,d);Ya(6533,0);a=J[a+4>>2];if(a){continue}break}}Ya(6535,0);La=b+224|0}function _c(){Ka(18324,4903);Ja(18348,3231,1,1,0);ha(18360,2707,1,-128,127);ha(18384,2700,1,-128,127);ha(18372,2698,1,0,255);ha(18396,1434,2,-32768,32767);ha(18408,1425,2,0,65535);ha(18420,1802,4,-2147483648,2147483647);ha(18432,1793,4,0,-1);ha(18444,3448,4,-2147483648,2147483647);ha(18456,3439,4,0,-1);Kc(18468,2072,-2147483648,2147483647);Kc(18480,2071,0,-1);ua(18492,2065,4);ua(18504,4617,8);ta(19560,3466);ta(13852,6284);pa(13924,4,3453);pa(14e3,2,3478);pa(14076,4,3493);Ia(19140,3251);ea(14116,0,6215);ea(14156,0,6317);ea(14196,1,6245);ea(14236,2,5780);ea(14276,3,5811);ea(14316,4,5851);ea(14356,5,5880);ea(14396,4,6354);ea(14436,5,6384);ea(14156,0,5982);ea(14196,1,5949);ea(14236,2,6048);ea(14276,3,6014);ea(14316,4,6182);ea(14356,5,6148);ea(14476,8,6115);ea(14516,9,6081);ea(14556,6,5918);ea(14596,7,6423)}function _h(a,b){a=a|0;b=b|0;var c=0,d=0;a:{if(K[J[a+88>>2]+102989|0]|J[a>>2]==(b|0)){break a}J[a>>2]=b;Sb(a);b:{if(!J[a>>2]){J[a+72>>2]=0;J[a+64>>2]=0;J[a+68>>2]=0;N[a+52>>2]=N[a+56>>2];b=J[a+48>>2];J[a+36>>2]=J[a+44>>2];J[a+40>>2]=b;I[a+4>>1]=L[a+4>>1]&65533;b=J[a+100>>2];if(!b){break b}d=J[a+88>>2]+102868|0;c=a+12|0;while(1){ec(b,d,c,c);b=J[b+4>>2];if(b){continue}break}if(!J[a>>2]){break b}}J[a+144>>2]=0;I[a+4>>1]=L[a+4>>1]|2}J[a+84>>2]=0;J[a+76>>2]=0;J[a+80>>2]=0;b=J[a+112>>2];if(b){while(1){c=J[b+12>>2];Rb(J[a+88>>2]+102868|0,J[b+4>>2]);b=c;if(b){continue}break}}J[a+112>>2]=0;c=J[a+100>>2];if(!c){break a}a=J[a+88>>2]+102868|0;while(1){d=J[c+28>>2];if((d|0)>0){b=0;while(1){wc(a,J[(J[c+24>>2]+P(b,28)|0)+24>>2]);b=b+1|0;if((d|0)!=(b|0)){continue}break}}c=J[c+4>>2];if(c){continue}break}}}function Rb(a,b){var c=0,d=0,e=0,f=0;f=J[J[b+52>>2]+8>>2];d=J[J[b+48>>2]+8>>2];c=J[a+72>>2];if(!(!c|!(K[b+4|0]&2))){Na[J[J[c>>2]+12>>2]](c,b)}c=J[b+8>>2];if(c){J[c+12>>2]=J[b+12>>2]}e=J[b+12>>2];if(e){J[e+8>>2]=c}if(J[a+60>>2]==(b|0)){J[a+60>>2]=e}c=J[b+24>>2];if(c){J[c+12>>2]=J[b+28>>2]}e=J[b+28>>2];if(e){J[e+8>>2]=c}if(J[d+112>>2]==(b+16|0)){J[d+112>>2]=e}d=J[b+40>>2];if(d){J[d+12>>2]=J[b+44>>2]}c=J[b+44>>2];if(c){J[c+8>>2]=d}if(J[f+112>>2]==(b+32|0)){J[f+112>>2]=c}e=J[a+76>>2];f=J[b+52>>2];d=J[b+48>>2];a:{if(K[f+38|0]|(K[d+38|0]|J[b+124>>2]<=0)){break a}c=J[d+8>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}c=J[f+8>>2];if(!J[c>>2]){break a}J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}Na[J[((P(J[J[d+12>>2]+4>>2],48)+24576|0)+P(J[J[f+12>>2]+4>>2],12)|0)+4>>2]](b,e);J[a+64>>2]=J[a+64>>2]-1}function vf(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,f=0,g=0,h=0,i=0,j=0;f=La-32|0;La=f;d=J[a+28>>2];J[f+16>>2]=d;g=J[a+20>>2];J[f+28>>2]=c;J[f+24>>2]=b;b=g-d|0;J[f+20>>2]=b;g=b+c|0;i=2;a:{b:{b=f+16|0;d=ra(J[a+60>>2],b|0,2,f+12|0)|0;if(d){J[6204]=d;d=-1}else{d=0}c:{d:{if(d){d=b;break d}while(1){e=J[f+12>>2];if((e|0)==(g|0)){break c}if((e|0)<0){d=b;break b}h=J[b+4>>2];j=h>>>0>>0;d=(j<<3)+b|0;h=e-(j?h:0)|0;J[d>>2]=h+J[d>>2];b=(j?12:4)+b|0;J[b>>2]=J[b>>2]-h;g=g-e|0;b=d;i=i-j|0;e=ra(J[a+60>>2],b|0,i|0,f+12|0)|0;if(e){J[6204]=e;e=-1}else{e=0}if(!e){continue}break}}if((g|0)!=-1){break b}}b=J[a+44>>2];J[a+28>>2]=b;J[a+20>>2]=b;J[a+16>>2]=b+J[a+48>>2];a=c;break a}J[a+28>>2]=0;J[a+16>>2]=0;J[a+20>>2]=0;J[a>>2]=J[a>>2]|32;a=0;if((i|0)==2){break a}a=c-J[d+4>>2]|0}La=f+32|0;return a|0}function _a(a){var b=Q(0),c=0,d=0,e=0,f=0;c=La-16|0;La=c;e=(C(a),v(2));d=e&2147483647;a:{if(d>>>0<=1061752794){b=Q(1);if(d>>>0<964689920){break a}b=wb(+a);break a}if(d>>>0<=1081824209){if(d>>>0>=1075235812){b=Q(-wb(((e|0)<0?3.141592653589793:-3.141592653589793)+ +a));break a}f=+a;if((e|0)<0){b=vb(f+1.5707963267948966);break a}b=vb(1.5707963267948966-f);break a}if(d>>>0<=1088565717){if(d>>>0>=1085271520){b=wb(((e|0)<0?6.283185307179586:-6.283185307179586)+ +a);break a}if((e|0)<0){b=vb(-4.71238898038469-+a);break a}b=vb(+a+-4.71238898038469);break a}b=Q(a-a);if(d>>>0>=2139095040){break a}b:{switch(Zc(a,c+8|0)&3){case 0:b=wb(O[c+8>>3]);break a;case 1:b=vb(-O[c+8>>3]);break a;case 2:b=Q(-wb(O[c+8>>3]));break a;default:break b}}b=vb(O[c+8>>3])}a=b;La=c+16|0;return a}function Ed(a,b,c){var d=0,e=0,f=0,g=0,h=0,i=Q(0);e=J[a+12>>2];e=Na[J[J[e>>2]+12>>2]](e)|0;J[a+28>>2]=e;if((e|0)>0){while(1){g=J[a+12>>2];e=J[a+24>>2]+P(h,28)|0;Na[J[J[g>>2]+24>>2]](g,e,c,h);g=Qd(b);i=N[e>>2];d=P(g,40);f=d+J[b+4>>2]|0;N[f+4>>2]=N[e+4>>2]+Q(-.10000000149011612);N[f>>2]=i+Q(-.10000000149011612);i=N[e+12>>2];f=d+J[b+4>>2]|0;N[f+8>>2]=N[e+8>>2]+Q(.10000000149011612);N[f+12>>2]=i+Q(.10000000149011612);d=d+J[b+4>>2]|0;H[d+36|0]=1;J[d+32>>2]=0;J[d+16>>2]=e;Pd(b,g);J[b+28>>2]=J[b+28>>2]+1;d=J[b+40>>2];if((d|0)==J[b+36>>2]){J[b+36>>2]=d<<1;f=J[b+32>>2];d=fb(d<<3);J[b+32>>2]=d;rb(d,f,J[b+40>>2]<<2);ab(f);d=J[b+40>>2]}J[J[b+32>>2]+(d<<2)>>2]=g;J[b+40>>2]=J[b+40>>2]+1;J[e+20>>2]=h;J[e+16>>2]=a;J[e+24>>2]=g;h=h+1|0;if((h|0)>2]){continue}break}}}function Za(a){var b=0,c=0,d=0,e=0;b=La-16|0;La=b;e=(C(a),v(2));c=e&2147483647;a:{if(c>>>0<=1061752794){if(c>>>0<964689920){break a}a=vb(+a);break a}if(c>>>0<=1081824209){d=+a;if(c>>>0<=1075235811){if((e|0)<0){a=Q(-wb(d+1.5707963267948966));break a}a=wb(d+-1.5707963267948966);break a}a=vb(-(((e|0)>=0?-3.141592653589793:3.141592653589793)+d));break a}if(c>>>0<=1088565717){if(c>>>0<=1085271519){d=+a;if((e|0)<0){a=wb(d+4.71238898038469);break a}a=Q(-wb(d+-4.71238898038469));break a}a=vb(((e|0)<0?6.283185307179586:-6.283185307179586)+ +a);break a}if(c>>>0>=2139095040){a=Q(a-a);break a}b:{switch(Zc(a,b+8|0)&3){case 0:a=vb(O[b+8>>3]);break a;case 1:a=wb(O[b+8>>3]);break a;case 2:a=vb(-O[b+8>>3]);break a;default:break b}}a=Q(-wb(O[b+8>>3]))}La=b+16|0;return a}function ei(a,b,c){a=a|0;b=b|0;c=Q(c);var d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=0,j=Q(0),k=Q(0),l=0,m=Q(0),n=0,o=0,p=0,q=0,r=Q(0),s=Q(0),t=Q(0);n=a+24|0;j=N[n>>2];k=N[a+20>>2];l=J[a+148>>2];if((l|0)>0){a=a+20|0;while(1){o=a+(i<<3)|0;g=Q(N[o>>2]-k);i=i+1|0;p=a+(i<<3)|0;q=(i|0)<(l|0);d=Q(N[(q?p+4|0:n)>>2]-j);e=Q(N[(q?p:a)>>2]-k);f=Q(N[o+4>>2]-j);h=Q(Q(g*d)-Q(e*f));r=Q(Q(Q(h*Q(.0833333358168602))*Q(Q(Q(d*d)+Q(Q(f*f)+Q(f*d)))+Q(Q(e*e)+Q(Q(g*g)+Q(g*e)))))+r);h=Q(h*Q(.5));m=Q(m+h);f=Q(f+d);d=Q(h*Q(.3333333432674408));s=Q(s+Q(f*d));t=Q(t+Q(Q(g+e)*d));if((i|0)!=(l|0)){continue}break}}h=Q(m*c);N[b>>2]=h;e=Q(Q(1)/m);g=Q(s*e);d=Q(j+g);N[b+8>>2]=d;e=Q(t*e);f=Q(k+e);N[b+4>>2]=f;N[b+12>>2]=Q(h*Q(Q(Q(f*f)+Q(d*d))-Q(Q(e*e)+Q(g*g))))+Q(r*c)}function Jf(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,f=0;if(!K[a+102989|0]){c=J[b+108>>2];if(c){while(1){d=J[c+12>>2];e=J[a+102976>>2];if(e){Na[J[J[e>>2]+8>>2]](e,J[c+4>>2])}$c(a,J[c+4>>2]);J[b+108>>2]=d;c=d;if(c){continue}break}}J[b+108>>2]=0;c=J[b+112>>2];if(c){e=a+102868|0;while(1){d=J[c+12>>2];Rb(e,J[c+4>>2]);c=d;if(c){continue}break}}J[b+112>>2]=0;c=J[b+100>>2];if(c){f=a+102868|0;while(1){d=J[c+4>>2];e=J[a+102976>>2];if(e){Na[J[J[e>>2]+12>>2]](e,c)}sc(c,f);tc(c,a);Ib(a,c,44);J[b+100>>2]=d;J[b+104>>2]=J[b+104>>2]-1;c=d;if(c){continue}break}}J[b+100>>2]=0;J[b+104>>2]=0;c=J[b+92>>2];if(c){J[c+96>>2]=J[b+96>>2]}d=J[b+96>>2];if(d){J[d+92>>2]=c}if(J[a+102948>>2]==(b|0)){J[a+102948>>2]=d}J[a+102956>>2]=J[a+102956>>2]-1;Ib(a,b,152)}}function wi(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0);e=0;k=N[c>>2];i=Q(N[c+8>>2]-k);l=N[c+4>>2];f=Q(N[c+12>>2]-l);h=Q(Q(i*i)+Q(f*f));a:{if(h>2];j=N[a+12>>2];n=N[a+16>>2];m=N[d+8>>2];k=Q(k-Q(N[d>>2]+Q(Q(g*j)-Q(n*m))));l=Q(l-Q(N[d+4>>2]+Q(Q(m*j)+Q(g*n))));g=Q(Q(k*i)+Q(l*f));j=N[a+8>>2];j=Q(Q(g*g)-Q(Q(Q(Q(k*k)+Q(l*l))-Q(j*j))*h));if(j>2]))){break a}h=Q(g/h);N[b+8>>2]=h;f=Q(l+Q(f*h));N[b+4>>2]=f;i=Q(k+Q(i*h));N[b>>2]=i;e=1;h=Q(Y(Q(Q(i*i)+Q(f*f))));if(h>2]=m*f;N[b>>2]=i*f}return e|0}function Ag(a){a=a|0;var b=0,c=Q(0),d=0,e=0;b=La-224|0;La=b;d=J[J[a+52>>2]+8>>2];e=J[J[a+48>>2]+8>>2];Ya(7644,0);J[b+208>>2]=e;Ya(7810,b+208|0);J[b+192>>2]=d;Ya(7784,b+192|0);J[b+176>>2]=K[a+61|0];Ya(8820,b+176|0);c=N[a+68>>2];O[b+168>>3]=N[a+72>>2];O[b+160>>3]=c;Ya(8226,b+160|0);c=N[a+76>>2];O[b+152>>3]=N[a+80>>2];O[b+144>>3]=c;Ya(8119,b+144|0);c=N[a+84>>2];O[b+136>>3]=N[a+88>>2];O[b+128>>3]=c;Ya(8192,b+128|0);O[b+112>>3]=N[a+100>>2];Ya(7128,b+112|0);J[b+96>>2]=K[a+140|0];Ya(8621,b+96|0);O[b+80>>3]=N[a+124>>2];Ya(6819,b+80|0);O[b+64>>3]=N[a+128>>2];Ya(6850,b- -64|0);J[b+48>>2]=K[a+141|0];Ya(8676,b+48|0);O[b+32>>3]=N[a+136>>2];Ya(7235,b+32|0);O[b+16>>3]=N[a+132>>2];Ya(7207,b+16|0);J[b>>2]=J[a+56>>2];Ya(8499,b);La=b+224|0}function Sc(a,b,c){a:{switch(b-9|0){case 0:b=J[c>>2];J[c>>2]=b+4;J[a>>2]=J[b>>2];return;case 6:b=J[c>>2];J[c>>2]=b+4;b=I[b>>1];J[a>>2]=b;J[a+4>>2]=b>>31;return;case 7:b=J[c>>2];J[c>>2]=b+4;J[a>>2]=L[b>>1];J[a+4>>2]=0;return;case 8:b=J[c>>2];J[c>>2]=b+4;b=H[b|0];J[a>>2]=b;J[a+4>>2]=b>>31;return;case 9:b=J[c>>2];J[c>>2]=b+4;J[a>>2]=K[b|0];J[a+4>>2]=0;return;case 16:b=J[c>>2]+7&-8;J[c>>2]=b+8;O[a>>3]=O[b>>3];return;case 17:Pc(a,c);default:return;case 1:case 4:case 14:b=J[c>>2];J[c>>2]=b+4;b=J[b>>2];J[a>>2]=b;J[a+4>>2]=b>>31;return;case 2:case 5:case 11:case 15:b=J[c>>2];J[c>>2]=b+4;J[a>>2]=J[b>>2];J[a+4>>2]=0;return;case 3:case 10:case 12:case 13:break a}}b=J[c>>2]+7&-8;J[c>>2]=b+8;c=J[b+4>>2];J[a>>2]=J[b>>2];J[a+4>>2]=c}function sb(a,b){var c=0,d=0,e=0;c=La+-64|0;La=c;d=J[a>>2];e=J[d-4>>2];d=J[d-8>>2];J[c+32>>2]=0;J[c+36>>2]=0;J[c+40>>2]=0;J[c+44>>2]=0;J[c+48>>2]=0;J[c+52>>2]=0;H[c+55|0]=0;H[c+56|0]=0;H[c+57|0]=0;H[c+58|0]=0;H[c+59|0]=0;H[c+60|0]=0;H[c+61|0]=0;H[c+62|0]=0;J[c+24>>2]=0;J[c+28>>2]=0;J[c+20>>2]=0;J[c+16>>2]=17972;J[c+12>>2]=a;J[c+8>>2]=b;a=a+d|0;d=0;a:{if(gb(e,b,0)){J[c+56>>2]=1;Na[J[J[e>>2]+20>>2]](e,c+8|0,a,a,1,0);d=J[c+32>>2]==1?a:0;break a}Na[J[J[e>>2]+24>>2]](e,c+8|0,a,1,0);b:{switch(J[c+44>>2]){case 0:d=J[c+48>>2]==1?J[c+36>>2]==1?J[c+40>>2]==1?J[c+28>>2]:0:0:0;break a;case 1:break b;default:break a}}if(J[c+32>>2]!=1){if(J[c+48>>2]|J[c+36>>2]!=1|J[c+40>>2]!=1){break a}}d=J[c+24>>2]}La=c- -64|0;return d}function Xg(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=Q(0),g=0,h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0);g=J[b+28>>2]+P(J[a+116>>2],12)|0;j=N[g>>2];h=N[g+8>>2];k=N[a+124>>2];c=N[a+108>>2];i=N[a+96>>2];d=Q(-Q(Q(Q(j-Q(h*k))+N[a+160>>2])+Q(c*i)));l=N[g+4>>2];m=N[a+120>>2];f=N[a+100>>2];e=Q(Q(Q(l+Q(h*m))+N[a+164>>2])+Q(c*f));c=Q(f+Q(Q(N[a+148>>2]*d)-Q(N[a+156>>2]*e)));N[a+100>>2]=c;d=Q(i+Q(Q(N[a+144>>2]*d)-Q(N[a+152>>2]*e)));N[a+96>>2]=d;n=Q(Q(d*d)+Q(c*c));e=Q(N[b>>2]*N[a+104>>2]);if(n>Q(e*e)){e=Q(e/Q(Y(n)));c=Q(c*e);N[a+100>>2]=c;d=Q(d*e);N[a+96>>2]=d}e=N[a+140>>2];c=Q(c-f);f=N[a+136>>2];N[g+4>>2]=l+Q(c*f);d=Q(d-i);N[g>>2]=j+Q(f*d);N[(J[b+28>>2]+P(J[a+116>>2],12)|0)+8>>2]=Q(e*Q(Q(m*c)-Q(d*k)))+h}function ki(a,b,c,d,e){a=a|0;b=Q(b);c=Q(c);d=d|0;e=Q(e);var f=Q(0),g=Q(0),h=0,i=0,j=Q(0),k=Q(0);J[a+84>>2]=0;J[a+88>>2]=-1082130432;J[a+148>>2]=4;J[a+108>>2]=-1082130432;J[a+112>>2]=0;J[a+100>>2]=0;J[a+104>>2]=1065353216;J[a+92>>2]=1065353216;J[a+96>>2]=0;N[a+48>>2]=c;f=Q(-b);N[a+44>>2]=f;N[a+40>>2]=c;N[a+36>>2]=b;c=Q(-c);N[a+32>>2]=c;N[a+28>>2]=b;N[a+24>>2]=c;N[a+20>>2]=f;i=J[d+4>>2];J[a+12>>2]=J[d>>2];J[a+16>>2]=i;c=Za(e);f=Q(-c);j=N[d+4>>2];k=N[d>>2];b=_a(e);while(1){d=(h<<3)+a|0;e=N[d+84>>2];g=N[d+88>>2];N[d+84>>2]=Q(b*e)+Q(g*f);N[d+88>>2]=Q(c*e)+Q(b*g);e=N[d+20>>2];g=N[d+24>>2];N[d+24>>2]=j+Q(Q(c*e)+Q(b*g));N[d+20>>2]=k+Q(Q(b*e)+Q(g*f));h=h+1|0;if((h|0)>2]){continue}break}}function Db(a,b,c){var d=0,e=0;a:{if(!c){break a}H[a|0]=b;d=a+c|0;H[d-1|0]=b;if(c>>>0<3){break a}H[a+2|0]=b;H[a+1|0]=b;H[d-3|0]=b;H[d-2|0]=b;if(c>>>0<7){break a}H[a+3|0]=b;H[d-4|0]=b;if(c>>>0<9){break a}d=0-a&3;e=d+a|0;a=P(b&255,16843009);J[e>>2]=a;c=c-d&-4;b=c+e|0;J[b-4>>2]=a;if(c>>>0<9){break a}J[e+8>>2]=a;J[e+4>>2]=a;J[b-8>>2]=a;J[b-12>>2]=a;if(c>>>0<25){break a}J[e+24>>2]=a;J[e+20>>2]=a;J[e+16>>2]=a;J[e+12>>2]=a;J[b-16>>2]=a;J[b-20>>2]=a;J[b-24>>2]=a;J[b-28>>2]=a;b=e&4|24;c=c-b|0;if(c>>>0<32){break a}a=kl(a,0,1,1);d=Ma;b=b+e|0;while(1){J[b+24>>2]=a;J[b+28>>2]=d;J[b+16>>2]=a;J[b+20>>2]=d;J[b+8>>2]=a;J[b+12>>2]=d;J[b>>2]=a;J[b+4>>2]=d;b=b+32|0;c=c-32|0;if(c>>>0>31){continue}break}}}function Gg(a){a=a|0;var b=0,c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0);b=J[a+52>>2];f=N[b+20>>2];g=Q(N[a+76>>2]-N[b+28>>2]);i=N[b+24>>2];j=Q(N[a+80>>2]-N[b+32>>2]);k=Q(Q(f*g)+Q(i*j));c=J[a+48>>2];d=N[c+20>>2];l=Q(N[a+68>>2]-N[c+28>>2]);e=N[c+24>>2];m=Q(N[a+72>>2]-N[c+32>>2]);n=Q(Q(d*l)+Q(e*m));o=N[a+84>>2];p=N[a+88>>2];q=Q(Q(e*o)-Q(p*d));h=N[c+72>>2];f=Q(Q(i*g)-Q(j*f));g=Q(Q(e*l)-Q(m*d));d=Q(Q(d*o)+Q(e*p));e=N[b+72>>2];return Q(Q(Q(Q(Q(Q(k+N[b+48>>2])-Q(n+N[c+48>>2]))*Q(q*h))-Q(Q(Q(f+N[b+44>>2])-Q(g+N[c+44>>2]))*Q(d*h)))+Q(Q(q*Q(Q(n*h)+Q(Q(N[b+64>>2]-Q(k*e))-N[c+64>>2])))+Q(d*Q(Q(Q(N[b+68>>2]+Q(f*e))-N[c+68>>2])-Q(g*h))))))}function dk(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=0,i=Q(0),j=Q(0);if(!(K[J[a+88>>2]+102989|0]|J[a>>2]!=2)){J[a+124>>2]=0;J[a+128>>2]=0;c=N[b>>2];c=c<=Q(0)?Q(1):c;N[a+116>>2]=c;N[a+120>>2]=Q(1)/c;e=N[b+12>>2];if(!(!(e>Q(0))|K[a+4|0]&16)){f=c;c=N[b+4>>2];d=Q(c*c);c=N[b+8>>2];c=Q(e-Q(f*Q(d+Q(c*c))));N[a+124>>2]=c;N[a+128>>2]=Q(1)/c}f=N[b+8>>2];h=J[b+8>>2];c=N[b+4>>2];b=J[b+4>>2];J[a+28>>2]=b;J[a+32>>2]=h;i=N[a+48>>2];d=N[a+20>>2];g=N[a+24>>2];e=Q(Q(Q(d*c)+Q(g*f))+N[a+16>>2]);N[a+48>>2]=e;j=N[a+44>>2];c=Q(N[a+12>>2]+Q(Q(g*c)-Q(f*d)));N[a+44>>2]=c;N[a+40>>2]=e;N[a+36>>2]=c;d=N[a+72>>2];N[a+64>>2]=N[a+64>>2]-Q(d*Q(e-i));N[a+68>>2]=Q(d*Q(c-j))+N[a+68>>2]}}function fg(a){a=a|0;var b=0,c=Q(0),d=0,e=0;b=La-208|0;La=b;d=J[J[a+52>>2]+8>>2];e=J[J[a+48>>2]+8>>2];Ya(7548,0);J[b+192>>2]=e;Ya(7810,b+192|0);J[b+176>>2]=d;Ya(7784,b+176|0);J[b+160>>2]=K[a+61|0];Ya(8820,b+160|0);c=N[a+68>>2];O[b+152>>3]=N[a+72>>2];O[b+144>>3]=c;Ya(8226,b+144|0);c=N[a+76>>2];O[b+136>>3]=N[a+80>>2];O[b+128>>3]=c;Ya(8119,b+128|0);O[b+112>>3]=N[a+120>>2];Ya(7128,b+112|0);J[b+96>>2]=K[a+116|0];Ya(8621,b+96|0);O[b+80>>3]=N[a+124>>2];Ya(7078,b+80|0);O[b+64>>3]=N[a+128>>2];Ya(7103,b- -64|0);J[b+48>>2]=K[a+104|0];Ya(8676,b+48|0);O[b+32>>3]=N[a+112>>2];Ya(7235,b+32|0);O[b+16>>3]=N[a+108>>2];Ya(7029,b+16|0);J[b>>2]=J[a+56>>2];Ya(8499,b);La=b+208|0}function Nf(a){a=a|0;var b=0,c=Q(0),d=0,e=0;b=La-192|0;La=b;d=J[J[a+52>>2]+8>>2];e=J[J[a+48>>2]+8>>2];Ya(7525,0);J[b+176>>2]=e;Ya(7810,b+176|0);J[b+160>>2]=d;Ya(7784,b+160|0);J[b+144>>2]=K[a+61|0];Ya(8820,b+144|0);c=N[a+68>>2];O[b+136>>3]=N[a+72>>2];O[b+128>>3]=c;Ya(8226,b+128|0);c=N[a+76>>2];O[b+120>>3]=N[a+80>>2];O[b+112>>3]=c;Ya(8119,b+112|0);c=N[a+84>>2];O[b+104>>3]=N[a+88>>2];O[b+96>>3]=c;Ya(8192,b+96|0);J[b+80>>2]=K[a+141|0];Ya(8676,b+80|0);O[b+64>>3]=N[a+136>>2];Ya(7235,b- -64|0);O[b+48>>3]=N[a+132>>2];Ya(7029,b+48|0);O[b+32>>3]=N[a+144>>2];Ya(6691,b+32|0);O[b+16>>3]=N[a+148>>2];Ya(6926,b+16|0);J[b>>2]=J[a+56>>2];Ya(8499,b);La=b+192|0}function vg(a){a=a|0;var b=0,c=Q(0),d=0,e=0;b=La-176|0;La=b;d=J[J[a+52>>2]+8>>2];e=J[J[a+48>>2]+8>>2];Ya(7430,0);J[b+160>>2]=e;Ya(7810,b+160|0);J[b+144>>2]=d;Ya(7784,b+144|0);J[b+128>>2]=K[a+61|0];Ya(8820,b+128|0);c=N[a+68>>2];O[b+120>>3]=N[a+72>>2];O[b+112>>3]=c;Ya(8262,b+112|0);c=N[a+76>>2];O[b+104>>3]=N[a+80>>2];O[b+96>>3]=c;Ya(8155,b+96|0);c=N[a+92>>2];O[b+88>>3]=N[a+96>>2];O[b+80>>3]=c;Ya(8226,b+80|0);c=N[a+100>>2];O[b+72>>3]=N[a+104>>2];O[b+64>>3]=c;Ya(8119,b- -64|0);O[b+48>>3]=N[a+84>>2];Ya(7282,b+48|0);O[b+32>>3]=N[a+88>>2];Ya(7260,b+32|0);O[b+16>>3]=N[a+112>>2];Ya(6746,b+16|0);J[b>>2]=J[a+56>>2];Ya(8499,b);La=b+176|0}function Rh(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=Q(0),f=0,g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0);f=J[J[a+48>>2]+12>>2];a=J[J[a+52>>2]+12>>2];J[b+60>>2]=0;e=N[d+12>>2];g=N[a+12>>2];h=N[a+16>>2];i=N[d+8>>2];j=N[c+12>>2];k=N[f+12>>2];l=N[f+16>>2];m=N[c+8>>2];n=Q(Q(N[d>>2]+Q(Q(e*g)-Q(h*i)))-Q(N[c>>2]+Q(Q(j*k)-Q(l*m))));e=Q(Q(Q(Q(i*g)+Q(e*h))+N[d+4>>2])-Q(Q(Q(m*k)+Q(j*l))+N[c+4>>2]));g=Q(Q(n*n)+Q(e*e));e=Q(N[f+8>>2]+N[a+8>>2]);if(!(g>Q(e*e))){J[b+56>>2]=0;c=J[f+12>>2];d=J[f+16>>2];J[b+60>>2]=1;J[b+40>>2]=0;J[b+44>>2]=0;J[b+48>>2]=c;J[b+52>>2]=d;c=J[a+12>>2];a=J[a+16>>2];J[b+16>>2]=0;J[b>>2]=c;J[b+4>>2]=a}}function Td(a,b,c){var d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=Q(0),q=Q(0),r=Q(0),s=Q(0),t=Q(0);l=N[b+8>>2];g=N[b+12>>2];h=N[b+28>>2];i=N[b+24>>2];d=N[b+16>>2];p=Q(Q(g*h)-Q(i*d));m=N[b>>2];j=N[b+32>>2];k=N[b+20>>2];q=Q(Q(d*j)-Q(h*k));n=N[b+4>>2];r=Q(Q(k*i)-Q(j*g));e=Q(Q(l*p)+Q(Q(m*q)+Q(n*r)));o=e!=Q(0)?Q(Q(1)/e):e;e=N[c+4>>2];f=N[c>>2];s=Q(l*Q(Q(g*e)-Q(f*d)));t=d;d=N[c+8>>2];N[a+8>>2]=o*Q(s+Q(Q(m*Q(Q(t*d)-Q(e*k)))+Q(n*Q(Q(k*f)-Q(d*g)))));N[a+4>>2]=o*Q(Q(l*Q(Q(f*h)-Q(i*e)))+Q(Q(m*Q(Q(e*j)-Q(h*d)))+Q(n*Q(Q(d*i)-Q(j*f)))));N[a>>2]=o*Q(Q(d*p)+Q(Q(f*q)+Q(r*e)))}function Qd(a){var b=0,c=0,d=0;b=J[a+4>>2];c=J[a+16>>2];if((c|0)==-1){c=J[a+12>>2];J[a+12>>2]=c<<1;c=fb(P(c,80));J[a+4>>2]=c;rb(c,b,P(J[a+8>>2],40));ab(b);c=J[a+4>>2];b=J[a+8>>2];d=J[a+12>>2]-1|0;if((b|0)<(d|0)){while(1){d=P(b,40);b=b+1|0;J[(d+c|0)+20>>2]=b;c=J[a+4>>2];J[(d+c|0)+32>>2]=-1;d=J[a+12>>2]-1|0;if((d|0)>(b|0)){continue}break}}J[(P(d,40)+c|0)+20>>2]=-1;b=J[a+4>>2];J[(b+P(J[a+12>>2],40)|0)-8>>2]=-1;c=J[a+8>>2];J[a+16>>2]=c}d=b;b=P(c,40);d=d+b|0;J[a+16>>2]=J[d+20>>2];J[d+20>>2]=-1;b=b+J[a+4>>2]|0;J[b+32>>2]=0;J[b+24>>2]=-1;J[b+28>>2]=-1;H[b+36|0]=0;J[b+16>>2]=0;J[a+8>>2]=J[a+8>>2]+1;return c}function gf(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;var g=0,h=0,i=0,j=0,k=0,l=0,m=0;if(gb(a,J[b+8>>2],f)){oc(b,c,d,e);return}g=K[b+53|0];j=J[a+12>>2];H[b+53|0]=0;h=K[b+52|0];H[b+52|0]=0;m=a+16|0;nc(m,b,c,d,e,f);k=K[b+53|0];g=g|k;l=K[b+52|0];h=h|l;i=a+24|0;j=(j<<3)+m|0;a:{if(i>>>0>=j>>>0){break a}while(1){if(K[b+54|0]){break a}b:{if(l){if(J[b+24>>2]==1){break a}if(K[a+8|0]&2){break b}break a}if(!k){break b}if(!(H[a+8|0]&1)){break a}}I[b+52>>1]=0;nc(i,b,c,d,e,f);k=K[b+53|0];g=k|g;l=K[b+52|0];h=l|h;i=i+8|0;if(j>>>0>i>>>0){continue}break}}H[b+53|0]=(g&255)!=0;H[b+52|0]=(h&255)!=0}function bj(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,f=0,g=0,h=0;c=J[a+4>>2];if((c|0)!=J[a+8>>2]){e=J[b+4>>2];J[c>>2]=J[b>>2];J[c+4>>2]=e;J[a+4>>2]=c+8;return}a:{h=J[a>>2];e=c-h|0;g=e>>3;d=g+1|0;if(d>>>0<536870912){f=e>>2;f=e>>>0>=2147483640?536870911:d>>>0>>0?f:d;if(f){if(f>>>0>=536870912){break a}e=Xa(f<<3)}else{e=0}d=e+(g<<3)|0;g=J[b+4>>2];J[d>>2]=J[b>>2];J[d+4>>2]=g;b=d+8|0;if((c|0)!=(h|0)){while(1){c=c-8|0;g=J[c+4>>2];d=d-8|0;J[d>>2]=J[c>>2];J[d+4>>2]=g;if((c|0)!=(h|0)){continue}break}c=J[a>>2]}J[a+8>>2]=e+(f<<3);J[a+4>>2]=b;J[a>>2]=d;if(c){ab(c)}return}ma();B()}Tb();B()}function fi(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0),o=Q(0),p=0,q=Q(0);j=N[c+8>>2];f=N[a+20>>2];k=N[c+12>>2];e=N[a+24>>2];n=N[c+4>>2];h=Q(Q(Q(j*f)+Q(k*e))+n);o=N[c>>2];i=Q(o+Q(Q(k*f)-Q(e*j)));c=1;p=J[a+148>>2];a:{if((p|0)<=1){f=i;e=h;break a}m=Q(-j);e=h;f=i;while(1){d=(c<<3)+a|0;q=N[d+20>>2];g=N[d+24>>2];l=Q(n+Q(Q(j*q)+Q(k*g)));e=e>l?e:l;g=Q(o+Q(Q(k*q)+Q(g*m)));f=f>g?f:g;h=h>2];N[b+12>>2]=m+e;N[b+8>>2]=f+e;N[b+4>>2]=h-e;N[b>>2]=i-e}function hc(a,b,c,d,e){var f=Q(0),g=Q(0),h=Q(0),i=0,j=0,k=0,l=Q(0),m=Q(0);f=N[c>>2];g=N[c+4>>2];h=Q(Q(Q(f*N[b+12>>2])+Q(g*N[b+16>>2]))-d);c=0;d=Q(Q(Q(f*N[b>>2])+Q(g*N[b+4>>2]))-d);if(d<=Q(0)){c=J[b+4>>2];J[a>>2]=J[b>>2];J[a+4>>2]=c;J[a+8>>2]=J[b+8>>2];c=1}if(h<=Q(0)){i=b+12|0;k=J[i+4>>2];j=P(c,12)+a|0;J[j>>2]=J[i>>2];J[j+4>>2]=k;J[j+8>>2]=J[i+8>>2];c=c+1|0}if(Q(d*h)>2];l=N[b+12>>2];g=N[b+4>>2];m=N[b+16>>2];a=P(c,12)+a|0;H[a+8|0]=e;d=Q(d/Q(d-h));N[a+4>>2]=g+Q(d*Q(m-g));N[a>>2]=f+Q(d*Q(l-f));b=K[b+9|0];I[a+10>>1]=256;H[a+9|0]=b;c=c+1|0}return c}function jf(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;if(gb(a,J[b+8>>2],e)){if(!(J[b+28>>2]==1|J[b+4>>2]!=(c|0))){J[b+28>>2]=d}return}a:{if(gb(a,J[b>>2],e)){if(!(J[b+16>>2]!=(c|0)&J[b+20>>2]!=(c|0))){if((d|0)!=1){break a}J[b+32>>2]=1;return}J[b+32>>2]=d;b:{if(J[b+44>>2]==4){break b}I[b+52>>1]=0;a=J[a+8>>2];Na[J[J[a>>2]+20>>2]](a,b,c,c,1,e);if(K[b+53|0]){J[b+44>>2]=3;if(!K[b+52|0]){break b}break a}J[b+44>>2]=4}J[b+20>>2]=c;J[b+40>>2]=J[b+40>>2]+1;if(J[b+36>>2]!=1|J[b+24>>2]!=2){break a}H[b+54|0]=1;return}a=J[a+8>>2];Na[J[J[a>>2]+24>>2]](a,b,c,d,e)}}function Rc(a,b,c){var d=0,e=0,f=0;d=La-208|0;La=d;J[d+204>>2]=c;c=d+160|0;Db(c,0,40);J[d+200>>2]=J[d+204>>2];a:{if((Uc(0,b,d+200|0,d+80|0,c)|0)<0){break a}f=J[a+76>>2]>=0;c=J[a>>2];if(J[a+72>>2]<=0){J[a>>2]=c&-33}b:{c:{d:{if(!J[a+48>>2]){J[a+48>>2]=80;J[a+28>>2]=0;J[a+16>>2]=0;J[a+20>>2]=0;e=J[a+44>>2];J[a+44>>2]=d;break d}if(J[a+16>>2]){break c}}if(Wc(a)){break b}}Uc(a,b,d+200|0,d+80|0,d+160|0)}if(e){Na[J[a+36>>2]](a,0,0)|0;J[a+48>>2]=0;J[a+44>>2]=e;J[a+28>>2]=0;J[a+16>>2]=0;J[a+20>>2]=0}J[a>>2]=J[a>>2]|c&32;if(!f){break a}}La=d+208|0}function Mi(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,f=0,g=0,h=0,i=0,j=0;h=La-16|0;La=h;f=a+16|0;g=J[f>>2];a:{if(!g){break a}j=J[b+48>>2];e=f;d=g;while(1){i=M[d+16>>2]>>0;e=i?e:d;d=J[(i?d+4|0:d)>>2];if(d){continue}break}if(!((e|0)!=(f|0)&M[e+16>>2]<=j>>>0)){i=J[b+52>>2];d=f;while(1){e=i>>>0>M[g+16>>2];d=e?d:g;e=J[(e?g+4|0:g)>>2];g=e;if(e){continue}break}if((d|0)==(f|0)|i>>>0>2]){break a}}f=J[a+8>>2];if(!(H[23868]&1)){a=ba(3,20060)|0;H[23868]=1;J[5966]=a}a=J[5966];J[h+8>>2]=c;J[h>>2]=b;da(a|0,f|0,3897,h|0)}La=h+16|0}function Li(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,f=0,g=0,h=0,i=0,j=0;h=La-16|0;La=h;f=a+16|0;g=J[f>>2];a:{if(!g){break a}j=J[b+48>>2];e=f;d=g;while(1){i=M[d+16>>2]>>0;e=i?e:d;d=J[(i?d+4|0:d)>>2];if(d){continue}break}if(!((e|0)!=(f|0)&M[e+16>>2]<=j>>>0)){i=J[b+52>>2];d=f;while(1){e=i>>>0>M[g+16>>2];d=e?d:g;e=J[(e?g+4|0:g)>>2];g=e;if(e){continue}break}if((d|0)==(f|0)|i>>>0>2]){break a}}f=J[a+8>>2];if(!(H[23868]&1)){a=ba(3,20060)|0;H[23868]=1;J[5966]=a}a=J[5966];J[h+8>>2]=c;J[h>>2]=b;da(a|0,f|0,3887,h|0)}La=h+16|0}function Oi(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,f=0,g=0,h=0,i=0;h=La-16|0;La=h;e=a+16|0;f=J[e>>2];a:{if(!f){break a}i=J[b+48>>2];d=e;c=f;while(1){g=M[c+16>>2]>>0;d=g?d:c;c=J[(g?c+4|0:c)>>2];if(c){continue}break}if(!((d|0)!=(e|0)&M[d+16>>2]<=i>>>0)){g=J[b+52>>2];c=e;while(1){d=g>>>0>M[f+16>>2];c=d?c:f;d=J[(d?f+4|0:f)>>2];f=d;if(d){continue}break}if((c|0)==(e|0)|g>>>0>2]){break a}}e=J[a+8>>2];if(!(H[23860]&1)){a=ba(2,20052)|0;H[23860]=1;J[5964]=a}a=J[5964];J[h+8>>2]=b;da(a|0,e|0,2041,h+8|0)}La=h+16|0}function Ni(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,f=0,g=0,h=0,i=0;h=La-16|0;La=h;e=a+16|0;f=J[e>>2];a:{if(!f){break a}i=J[b+48>>2];d=e;c=f;while(1){g=M[c+16>>2]>>0;d=g?d:c;c=J[(g?c+4|0:c)>>2];if(c){continue}break}if(!((d|0)!=(e|0)&M[d+16>>2]<=i>>>0)){g=J[b+52>>2];c=e;while(1){d=g>>>0>M[f+16>>2];c=d?c:f;d=J[(d?f+4|0:f)>>2];f=d;if(d){continue}break}if((c|0)==(e|0)|g>>>0>2]){break a}}e=J[a+8>>2];if(!(H[23860]&1)){a=ba(2,20052)|0;H[23860]=1;J[5964]=a}a=J[5964];J[h+8>>2]=b;da(a|0,e|0,2054,h+8|0)}La=h+16|0}function Wh(a,b,c){a=a|0;b=b|0;c=Q(c);var d=0,e=Q(0),f=Q(0),g=Q(0),h=0,i=Q(0),j=Q(0);d=J[a+88>>2];if(!K[d+102989|0]){f=_a(c);N[a+24>>2]=f;g=Za(c);N[a+20>>2]=g;j=N[b+4>>2];h=J[b+4>>2];e=N[b>>2];b=J[b>>2];J[a+12>>2]=b;J[a+16>>2]=h;N[a+56>>2]=c;N[a+52>>2]=c;c=N[a+28>>2];i=N[a+32>>2];e=Q(Q(Q(f*c)-Q(g*i))+e);N[a+44>>2]=e;N[a+36>>2]=e;c=Q(Q(Q(g*c)+Q(f*i))+j);N[a+48>>2]=c;N[a+40>>2]=c;b=J[a+100>>2];if(b){h=d+102868|0;d=a+12|0;while(1){ec(b,h,d,d);b=J[b+4>>2];if(b){continue}break}d=J[a+88>>2]}fc(d+102868|0)}}function Xh(a,b){a=a|0;b=b|0;var c=0,d=0;if(!(K[J[a+88>>2]+102989|0]|!b)){c=J[a+100>>2];a:{if(!c){break a}if((b|0)==(c|0)){d=a+100|0}else{while(1){d=c;c=J[c+4>>2];if(!c){break a}if((b|0)!=(c|0)){continue}break}d=d+4|0}J[d>>2]=J[b+4>>2]}c=J[a+112>>2];if(c){while(1){d=J[c+4>>2];c=J[c+12>>2];if(!(J[d+48>>2]!=(b|0)&J[d+52>>2]!=(b|0))){Rb(J[a+88>>2]+102868|0,d)}if(c){continue}break}}d=J[a+88>>2];if(K[a+4|0]&32){sc(b,d+102868|0)}J[b+4>>2]=0;J[b+8>>2]=0;tc(b,d);Ib(d,b,44);J[a+104>>2]=J[a+104>>2]-1;Sb(a)}}function kj(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,f=0,g=0,h=0;e=J[a+4>>2];if((e|0)!=J[a+8>>2]){J[e>>2]=J[b>>2];J[a+4>>2]=e+4;return}a:{g=J[a>>2];f=e-g|0;c=f>>2;d=c+1|0;if(d>>>0<1073741824){h=c<<2;c=f>>1;c=f>>>0>=2147483644?1073741823:c>>>0>d>>>0?c:d;if(c){if(c>>>0>=1073741824){break a}f=Xa(c<<2)}else{f=0}d=h+f|0;J[d>>2]=J[b>>2];b=d+4|0;if((e|0)!=(g|0)){while(1){d=d-4|0;e=e-4|0;J[d>>2]=J[e>>2];if((e|0)!=(g|0)){continue}break}}J[a+8>>2]=f+(c<<2);J[a+4>>2]=b;J[a>>2]=d;if(g){ab(g)}return}ma();B()}Tb();B()}function Gh(a){a=a|0;var b=0,c=Q(0),d=0,e=0;b=La-144|0;La=b;d=J[J[a+52>>2]+8>>2];e=J[J[a+48>>2]+8>>2];Ya(7596,0);J[b+128>>2]=e;Ya(7810,b+128|0);J[b+112>>2]=d;Ya(7784,b+112|0);J[b+96>>2]=K[a+61|0];Ya(8820,b+96|0);c=N[a+80>>2];O[b+88>>3]=N[a+84>>2];O[b+80>>3]=c;Ya(8226,b+80|0);c=N[a+88>>2];O[b+72>>3]=N[a+92>>2];O[b+64>>3]=c;Ya(8119,b- -64|0);O[b+48>>3]=N[a+104>>2];Ya(6881,b+48|0);O[b+32>>3]=N[a+68>>2];Ya(6691,b+32|0);O[b+16>>3]=N[a+72>>2];Ya(6926,b+16|0);J[b>>2]=J[a+56>>2];Ya(8499,b);La=b+144|0}function Vf(a){a=a|0;var b=0,c=Q(0),d=0,e=0;b=La-144|0;La=b;d=J[J[a+52>>2]+8>>2];e=J[J[a+48>>2]+8>>2];Ya(7622,0);J[b+128>>2]=e;Ya(7810,b+128|0);J[b+112>>2]=d;Ya(7784,b+112|0);J[b+96>>2]=K[a+61|0];Ya(8820,b+96|0);c=N[a+80>>2];O[b+88>>3]=N[a+84>>2];O[b+80>>3]=c;Ya(8226,b+80|0);c=N[a+88>>2];O[b+72>>3]=N[a+92>>2];O[b+64>>3]=c;Ya(8119,b- -64|0);O[b+48>>3]=N[a+96>>2];Ya(7128,b+48|0);O[b+32>>3]=N[a+68>>2];Ya(6691,b+32|0);O[b+16>>3]=N[a+72>>2];Ya(6926,b+16|0);J[b>>2]=J[a+56>>2];Ya(8499,b);La=b+144|0}function $e(a,b,c){a=a|0;b=Q(b);c=Q(c);var d=0,e=Q(0),f=Q(0),g=0;d=La-16|0;La=d;b=Q(b*Q(6.2831854820251465));f=N[J[a+48>>2]+116>>2];g=f>Q(0);e=N[J[a+52>>2]+116>>2];a:{if(!(!g|!(e>Q(0)))){e=Q(Q(f*e)/Q(f+e));break a}e=g?f:e}N[d+12>>2]=b*Q(b*e);N[d+8>>2]=b*Q(Q(e+e)*c);b:{c:{switch(J[a+4>>2]-3|0){case 0:N[a+68>>2]=N[d+12>>2];N[a+72>>2]=N[d+8>>2];break b;case 5:N[a+68>>2]=N[d+12>>2];N[a+72>>2]=N[d+8>>2];break b;case 4:break c;default:break b}}N[a+144>>2]=N[d+12>>2];N[a+148>>2]=N[d+8>>2]}La=d+16|0}function di(a){a=a|0;var b=0,c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=Q(0),k=Q(0),l=0,m=Q(0),n=Q(0);f=1;c=J[a+148>>2];a:{if((c|0)<=0){break a}l=c-1|0;h=a+20|0;f=0;while(1){g=d+1|0;i=(d|0)<(l|0)?g:0;b=(i<<3)+h|0;e=(d<<3)+h|0;j=N[e>>2];m=Q(N[b>>2]-j);k=N[e+4>>2];n=Q(-Q(N[b+4>>2]-k));b=0;while(1){if(!((b|0)==(d|0)|(b|0)==(i|0))){e=(b<<3)+a|0;if(Q(Q(m*Q(N[e+24>>2]-k))+Q(Q(N[e+20>>2]-j)*n))>2];d=1;a:{if((g|0)<=0){break a}e=N[b+12>>2];h=Q(N[c>>2]-N[b>>2]);i=Q(N[c+4>>2]-N[b+4>>2]);j=N[b+8>>2];k=Q(Q(e*h)+Q(i*j));e=Q(Q(e*i)-Q(j*h));d=0;if(Q(Q(N[a+84>>2]*Q(k-N[a+20>>2]))+Q(Q(e-N[a+24>>2])*N[a+88>>2]))>Q(0)){break a}while(1){f=f+1|0;if((g|0)!=(f|0)){b=(f<<3)+a|0;if(!(Q(Q(N[b+84>>2]*Q(k-N[b+20>>2]))+Q(Q(e-N[b+24>>2])*N[b+88>>2]))>Q(0))){continue}}break}d=(f|0)>=(g|0)}return d|0}function dc(a){var b=0,c=0,d=0;if(!a){if(J[5952]){b=dc(J[5952])}if(J[6203]){b=dc(J[6203])|b}a=J[6220];if(a){while(1){if(J[a+20>>2]!=J[a+28>>2]){b=dc(a)|b}a=J[a+56>>2];if(a){continue}break}}return b}d=J[a+76>>2]>=0;a:{b:{if(J[a+20>>2]==J[a+28>>2]){break b}Na[J[a+36>>2]](a,0,0)|0;if(J[a+20>>2]){break b}b=-1;break a}b=J[a+8>>2];c=J[a+4>>2];if((b|0)!=(c|0)){b=c-b|0;Na[J[a+40>>2]](a,b,b>>31,1)|0}b=0;J[a+28>>2]=0;J[a+16>>2]=0;J[a+20>>2]=0;J[a+4>>2]=0;J[a+8>>2]=0;if(!d){break a}}return b}function Md(a){var b=0,c=0,d=Q(0),e=Q(0),f=0,g=Q(0),h=Q(0),i=Q(0);c=La-16|0;La=c;f=J[a+88>>2]+102868|0;a:{if(K[a+4|0]&2){d=N[a+52>>2];e=_a(d);N[c+12>>2]=e;d=Za(d);N[c+8>>2]=d;i=N[a+36>>2];g=N[a+28>>2];h=N[a+32>>2];N[c+4>>2]=N[a+40>>2]-Q(Q(d*g)+Q(e*h));N[c>>2]=i-Q(Q(e*g)-Q(h*d));b=J[a+100>>2];if(!b){break a}a=a+12|0;while(1){ec(b,f,c,a);b=J[b+4>>2];if(b){continue}break}break a}b=J[a+100>>2];if(!b){break a}a=a+12|0;while(1){ec(b,f,a,a);b=J[b+4>>2];if(b){continue}break}}La=c+16|0}function uf(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,f=0,g=0;e=La-32|0;La=e;J[e+16>>2]=b;d=J[a+48>>2];J[e+20>>2]=c-((d|0)!=0);f=J[a+44>>2];J[e+28>>2]=d;J[e+24>>2]=f;a:{b:{d=Ea(J[a+60>>2],e+16|0,2,e+12|0)|0;if(d){J[6204]=d;d=-1}else{d=0}if(d){b=32}else{d=J[e+12>>2];if((d|0)>0){break b}b=d?32:16}J[a>>2]=b|J[a>>2];break a}g=d;f=J[e+20>>2];if(f>>>0>=d>>>0){break a}d=J[a+44>>2];J[a+4>>2]=d;J[a+8>>2]=d+(g-f|0);if(J[a+48>>2]){J[a+4>>2]=d+1;H[(b+c|0)-1|0]=K[d|0]}g=c}La=e+32|0;return g|0}function $g(a){a=a|0;var b=0,c=0,d=0,e=Q(0);b=La-144|0;La=b;c=J[J[a+52>>2]+8>>2];d=J[J[a+48>>2]+8>>2];Ya(7454,0);J[b+128>>2]=d;Ya(7810,b+128|0);J[b+112>>2]=c;Ya(7784,b+112|0);J[b+96>>2]=K[a+61|0];Ya(8820,b+96|0);e=N[a+68>>2];O[b+88>>3]=N[a+72>>2];O[b+80>>3]=e;Ya(7990,b+80|0);O[b+64>>3]=N[a+76>>2];Ya(6635,b- -64|0);O[b+48>>3]=N[a+92>>2];Ya(7184,b+48|0);O[b+32>>3]=N[a+96>>2];Ya(7005,b+32|0);O[b+16>>3]=N[a+100>>2];Ya(6715,b+16|0);J[b>>2]=J[a+56>>2];Ya(8499,b);La=b+144|0}function sc(a,b){var c=0,d=0,e=0,f=0,g=0,h=0,i=0;if(J[a+28>>2]>0){while(1){g=J[a+24>>2]+P(e,28)|0;d=J[g+24>>2];c=0;f=J[b+40>>2];if((f|0)>0){i=J[b+32>>2];while(1){h=(c<<2)+i|0;if(J[h>>2]==(d|0)){J[h>>2]=-1;f=J[b+40>>2]}c=c+1|0;if((f|0)>(c|0)){continue}break}}J[b+28>>2]=J[b+28>>2]-1;Nd(b,d);c=P(d,40);J[(c+J[b+4>>2]|0)+20>>2]=J[b+16>>2];J[(c+J[b+4>>2]|0)+32>>2]=-1;J[b+16>>2]=d;J[b+8>>2]=J[b+8>>2]-1;J[g+24>>2]=-1;e=e+1|0;if((e|0)>2]){continue}break}}J[a+28>>2]=0}function Vh(a,b){a=a|0;b=b|0;var c=0,d=0;c=L[a+4>>1];if(((c&32)>>>5|0)!=(b|0)){if(b){I[a+4>>1]=c|32;c=J[a+88>>2];b=J[a+100>>2];if(b){c=c+102868|0;d=a+12|0;while(1){Ed(b,c,d);b=J[b+4>>2];if(b){continue}break}c=J[a+88>>2]}H[c+102988|0]=1;return}I[a+4>>1]=c&65503;b=J[a+100>>2];if(b){c=J[a+88>>2]+102868|0;while(1){sc(b,c);b=J[b+4>>2];if(b){continue}break}}b=J[a+112>>2];if(b){while(1){c=J[b+12>>2];Rb(J[a+88>>2]+102868|0,J[b+4>>2]);b=c;if(b){continue}break}}J[a+112>>2]=0}}function Oc(a,b){if(!a){return 0}a:{b:{if(a){if(b>>>0<=127){break b}c:{if(!J[J[6506]>>2]){if((b&-128)==57216){break b}break c}if(b>>>0<=2047){H[a+1|0]=b&63|128;H[a|0]=b>>>6|192;a=2;break a}if(!((b&-8192)!=57344&b>>>0>=55296)){H[a+2|0]=b&63|128;H[a|0]=b>>>12|224;H[a+1|0]=b>>>6&63|128;a=3;break a}if(b-65536>>>0<=1048575){H[a+3|0]=b&63|128;H[a|0]=b>>>18|240;H[a+2|0]=b>>>6&63|128;H[a+1|0]=b>>>12&63|128;a=4;break a}}J[6204]=25;a=-1}else{a=1}break a}H[a|0]=b;a=1}return a}function qh(a){a=a|0;var b=0,c=Q(0),d=0,e=0;b=La-128|0;La=b;d=J[J[a+52>>2]+8>>2];e=J[J[a+48>>2]+8>>2];Ya(7499,0);J[b+112>>2]=e;Ya(7810,b+112|0);J[b+96>>2]=d;Ya(7784,b+96|0);J[b+80>>2]=K[a+61|0];Ya(8820,b+80|0);c=N[a+68>>2];O[b+72>>3]=N[a+72>>2];O[b+64>>3]=c;Ya(8226,b- -64|0);c=N[a+76>>2];O[b+56>>3]=N[a+80>>2];O[b+48>>3]=c;Ya(8119,b+48|0);O[b+32>>3]=N[a+96>>2];Ya(7184,b+32|0);O[b+16>>3]=N[a+100>>2];Ya(7005,b+16|0);J[b>>2]=J[a+56>>2];Ya(8499,b);La=b+128|0}function Lb(a,b){var c=0,d=0;d=b&255;a:{if(d){if(a&3){while(1){c=K[a|0];if(!c|(c|0)==(b&255)){break a}a=a+1|0;if(a&3){continue}break}}c=J[a>>2];b:{if((c^-1)&c-16843009&-2139062144){break b}d=P(d,16843009);while(1){c=c^d;if((c^-1)&c-16843009&-2139062144){break b}c=J[a+4>>2];a=a+4|0;if(!(c-16843009&(c^-1)&-2139062144)){continue}break}}while(1){c=a;d=K[a|0];if(d){a=c+1|0;if((d|0)!=(b&255)){continue}}break}a=c;break a}a=Xc(a)+a|0}return K[a|0]==(b&255)?a:0}function sd(a){a=a|0;var b=0,c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0);b=J[a+52>>2];f=N[b+24>>2];c=J[a+48>>2];d=N[c+24>>2];g=N[a+76>>2];h=N[a+80>>2];i=N[b+20>>2];j=N[a+68>>2];k=N[a+72>>2];e=N[c+20>>2];l=N[a+84>>2];m=N[a+88>>2];return Q(Q(Q(Q(Q(N[b+12>>2]+Q(Q(f*g)-Q(h*i)))-Q(N[c+12>>2]+Q(Q(d*j)-Q(k*e))))*Q(Q(d*l)-Q(m*e)))+Q(Q(Q(Q(Q(i*g)+Q(f*h))+N[b+16>>2])-Q(Q(Q(e*j)+Q(d*k))+N[c+16>>2]))*Q(Q(e*l)+Q(d*m)))))}function Bh(a,b){a=a|0;b=b|0;var c=0,d=0;c=L[b>>1]|L[b+2>>1]<<16;I[a+32>>1]=c;I[a+34>>1]=c>>>16;I[a+36>>1]=L[b+4>>1];d=J[a+8>>2];a:{if(!d){break a}b=J[d+112>>2];if(b){while(1){c=J[b+4>>2];if(!(J[c+48>>2]!=(a|0)&J[c+52>>2]!=(a|0))){J[c+4>>2]=J[c+4>>2]|8}b=J[b+12>>2];if(b){continue}break}}b=J[d+88>>2];if(!b|J[a+28>>2]<=0){break a}c=b+102868|0;b=0;while(1){wc(c,J[(J[a+24>>2]+P(b,28)|0)+24>>2]);b=b+1|0;if((b|0)>2]){continue}break}}}function Di(a,b,c,d,e){a=a|0;b=b|0;c=Q(c);d=d|0;e=e|0;var f=0,g=0,h=0,i=0;f=La-32|0;La=f;g=J[a+12>>2];if(!(H[23892]&1)){a=ba(5,20496)|0;H[23892]=1;J[5972]=a}h=J[5972];a=Xa(8);i=J[b+4>>2];J[a>>2]=J[b>>2];J[a+4>>2]=i;N[f+8>>2]=c;J[f>>2]=a;a=Xa(8);b=J[d+4>>2];J[a>>2]=J[d>>2];J[a+4>>2]=b;J[f+16>>2]=a;a=Xa(16);b=J[e+12>>2];J[a+8>>2]=J[e+8>>2];J[a+12>>2]=b;b=J[e+4>>2];J[a>>2]=J[e>>2];J[a+4>>2]=b;J[f+24>>2]=a;da(h|0,g|0,4601,f|0);La=f+32|0}function ri(a,b){a=a|0;b=b|0;var c=0;b=eb(b,48);J[b+4>>2]=1;J[b+8>>2]=1008981770;J[b>>2]=11960;J[b+28>>2]=0;J[b+32>>2]=0;J[b+36>>2]=0;J[b+40>>2]=0;H[b+44|0]=0;c=J[a+8>>2];J[b+4>>2]=J[a+4>>2];J[b+8>>2]=c;c=J[a+16>>2];J[b+12>>2]=J[a+12>>2];J[b+16>>2]=c;c=J[a+24>>2];J[b+20>>2]=J[a+20>>2];J[b+24>>2]=c;c=J[a+32>>2];J[b+28>>2]=J[a+28>>2];J[b+32>>2]=c;c=J[a+40>>2];J[b+36>>2]=J[a+36>>2];J[b+40>>2]=c;H[b+44|0]=K[a+44|0];return b|0}function Ci(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0,g=0,h=0;e=La-32|0;La=e;f=J[a+12>>2];if(!(H[23900]&1)){a=ba(4,20528)|0;H[23900]=1;J[5974]=a}g=J[5974];a=Xa(8);h=J[b+4>>2];J[a>>2]=J[b>>2];J[a+4>>2]=h;J[e+8>>2]=a;a=Xa(8);b=J[c+4>>2];J[a>>2]=J[c>>2];J[a+4>>2]=b;J[e+16>>2]=a;a=Xa(16);b=J[d+12>>2];J[a+8>>2]=J[d+8>>2];J[a+12>>2]=b;b=J[d+4>>2];J[a>>2]=J[d>>2];J[a+4>>2]=b;J[e+24>>2]=a;da(g|0,f|0,1806,e+8|0);La=e+32|0}function We(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,f=0,g=0,h=0,i=0;d=La-32|0;La=d;e=J[b>>2];if(e>>>0<2147483632){a:{if(e>>>0<=10){H[d+27|0]=e;f=d+16|0;break a}g=(e|15)+1|0;f=Xa(g);J[d+24>>2]=g|-2147483648;J[d+16>>2]=f;J[d+20>>2]=e}h=rb(f,b+4|0,e)+e|0,i=0,H[h|0]=i;J[d+12>>2]=c;Na[a|0](d+28|0,d+16|0,d+12|0);ya(J[d+28>>2]);a=J[d+28>>2];ga(a|0);ga(J[d+12>>2]);if(H[d+27|0]<0){ab(J[d+16>>2])}La=d+32|0;return a|0}ma();B()}function $f(a){a=a|0;var b=0,c=Q(0),d=0,e=0;b=La-112|0;La=b;d=J[J[a+52>>2]+8>>2];e=J[J[a+48>>2]+8>>2];Ya(7574,0);J[b+96>>2]=e;Ya(7810,b+96|0);J[b+80>>2]=d;Ya(7784,b+80|0);J[b+64>>2]=K[a+61|0];Ya(8820,b- -64|0);c=N[a+68>>2];O[b+56>>3]=N[a+72>>2];O[b+48>>3]=c;Ya(8226,b+48|0);c=N[a+76>>2];O[b+40>>3]=N[a+80>>2];O[b+32>>3]=c;Ya(8119,b+32|0);O[b+16>>3]=N[a+84>>2];Ya(6902,b+16|0);J[b>>2]=J[a+56>>2];Ya(8499,b);La=b+112|0}function oi(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0),l=Q(0),m=Q(0),n=Q(0);k=N[c>>2];h=N[a+8>>2];e=N[c+8>>2];f=N[a+12>>2];i=N[c+12>>2];l=N[a+16>>2];g=N[c+4>>2];j=Q(Q(Q(e*f)+Q(i*l))+g);m=N[a+20>>2];n=N[a+24>>2];g=Q(g+Q(Q(e*m)+Q(i*n)));N[b+12>>2]=h+(g>2]=h+(e>2]=(g>j?j:g)-h;N[b>>2]=(e>f?f:e)-h}function gc(a,b,c){var d=0,e=0;a:{b:{c:{d:{switch(J[b+4>>2]){case 0:J[a+16>>2]=b+12;c=1;break b;case 2:J[a+16>>2]=b+20;c=J[b+148>>2];break b;case 3:d=J[b+12>>2]+(c<<3)|0;e=J[d+4>>2];J[a>>2]=J[d>>2];J[a+4>>2]=e;c=c+1|0;c=J[b+12>>2]+(((c|0)>2]?c:0)<<3)|0;d=J[c+4>>2];J[a+8>>2]=J[c>>2];J[a+12>>2]=d;J[a+16>>2]=a;break c;case 1:break d;default:break a}}J[a+16>>2]=b+12}c=2}J[a+20>>2]=c;N[a+24>>2]=N[b+8>>2]}}function Jd(a,b,c){var d=0,e=0,f=0;J[b+4>>2]=1;N[b+8>>2]=N[a+8>>2];f=c<<3;d=f+J[a+12>>2]|0;e=J[d+4>>2];J[b+12>>2]=J[d>>2];J[b+16>>2]=e;d=J[a+12>>2]+f|0;e=J[d+8>>2];d=J[d+12>>2];H[b+44|0]=1;J[b+20>>2]=e;J[b+24>>2]=d;d=(c|0)>0?(J[a+12>>2]+f|0)-8|0:a+20|0;e=J[d+4>>2];J[b+28>>2]=J[d>>2];J[b+32>>2]=e;a=(J[a+16>>2]-2|0)>(c|0)?(J[a+12>>2]+f|0)+16|0:a+28|0;c=J[a+4>>2];J[b+36>>2]=J[a>>2];J[b+40>>2]=c}function tc(a,b){var c=0,d=0;c=J[a+12>>2];c=Na[J[J[c>>2]+12>>2]](c)|0;Ib(b,J[a+24>>2],P(c,28));J[a+24>>2]=0;a:{b:{c:{d:{e:{f:{c=J[a+12>>2];switch(J[c+4>>2]){case 3:break c;case 2:break d;case 1:break e;case 0:break f;default:break a}}Na[J[J[c>>2]>>2]](c)|0;d=20;break b}Na[J[J[c>>2]>>2]](c)|0;d=48;break b}Na[J[J[c>>2]>>2]](c)|0;d=152;break b}Na[J[J[c>>2]>>2]](c)|0;d=36}Ib(b,c,d)}J[a+12>>2]=0}function th(a){a=a|0;var b=0,c=0,d=0,e=0,f=0;b=La-112|0;La=b;c=J[J[a+72>>2]+56>>2];d=J[J[a+68>>2]+56>>2];e=J[J[a+52>>2]+8>>2];f=J[J[a+48>>2]+8>>2];Ya(7477,0);J[b+96>>2]=f;Ya(7810,b+96|0);J[b+80>>2]=e;Ya(7784,b+80|0);J[b+64>>2]=K[a+61|0];Ya(8820,b- -64|0);J[b+48>>2]=d;Ya(7757,b+48|0);J[b+32>>2]=c;Ya(7730,b+32|0);O[b+16>>3]=N[a+152>>2];Ya(6746,b+16|0);J[b>>2]=J[a+56>>2];Ya(8499,b);La=b+112|0}function jb(a,b,c){var d=0,e=0,f=0;if(!(K[a|0]&32)){a:{d=b;b=a;a=J[b+16>>2];b:{if(!a){if(Wc(b)){break b}a=J[b+16>>2]}f=J[b+20>>2];if(a-f>>>0>>0){Na[J[b+36>>2]](b,d,c)|0;break a}c:{if(J[b+80>>2]<0){break c}a=c;while(1){e=a;if(!a){break c}a=e-1|0;if(K[d+a|0]!=10){continue}break}if(Na[J[b+36>>2]](b,d,e)>>>0>>0){break b}d=d+e|0;c=c-e|0;f=J[b+20>>2]}rb(f,d,c);J[b+20>>2]=J[b+20>>2]+c}}}}function Si(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=Q(e);var f=0,g=0,h=0,i=0;f=La-48|0;La=f;g=J[a+8>>2];if(!(H[23852]&1)){a=ba(5,19776)|0;H[23852]=1;J[5962]=a}h=J[5962];J[f+16>>2]=b;a=Xa(8);b=J[c+4>>2];J[a>>2]=J[c>>2];J[a+4>>2]=b;J[f+24>>2]=a;a=Xa(8);b=J[d+4>>2];J[a>>2]=J[d>>2];J[a+4>>2]=b;N[f+40>>2]=e;J[f+32>>2]=a;i=+wa(h|0,g|0,4277,f+12|0,f+16|0);va(J[f+12>>2]);La=f+48|0;return Q(Q(i))}function Gb(a,b,c,d,e){var f=Q(0),g=Q(0);J[a+60>>2]=e;J[a+56>>2]=c;J[a+52>>2]=d;J[a+48>>2]=b;J[a+4>>2]=4;J[a+8>>2]=0;J[a+12>>2]=0;J[a+124>>2]=0;J[a+128>>2]=0;J[a>>2]=12384;J[a+16>>2]=0;J[a+20>>2]=0;J[a+24>>2]=0;J[a+28>>2]=0;J[a+32>>2]=0;J[a+36>>2]=0;J[a+40>>2]=0;J[a+44>>2]=0;N[a+136>>2]=Y(Q(N[b+16>>2]*N[d+16>>2]));f=N[d+20>>2];g=N[b+20>>2];J[a+144>>2]=0;N[a+140>>2]=f>2]=0;J[a+8>>2]=0;J[a>>2]=1;J[a+56>>2]=0;J[a+60>>2]=0;J[a+20>>2]=0;J[a+24>>2]=0;J[a+44>>2]=0;J[a+48>>2]=0;H[a+9|0]=0;H[a+10|0]=0;H[a+11|0]=0;H[a+12|0]=0;H[a+13|0]=0;H[a+14|0]=0;H[a+15|0]=0;H[a+16|0]=0;J[a+28>>2]=0;J[a+32>>2]=0;H[a+33|0]=0;H[a+34|0]=0;H[a+35|0]=0;H[a+36|0]=0;H[a+37|0]=0;H[a+38|0]=0;H[a+39|0]=0;H[a+40|0]=0;H[a+52|0]=0;return a|0}function hl(a){a=a|0;var b=0,c=0,d=0;if(a){b=a;c=J[a+102948>>2];if(c){while(1){a=J[c+100>>2];c=J[c+96>>2];if(a){while(1){J[a+28>>2]=0;d=J[a+4>>2];tc(a,b);a=d;if(a){continue}break}}if(c){continue}break}}a=b+102868|0;ab(J[a+32>>2]);ab(J[a+44>>2]);ab(J[a+4>>2]);a=0;if(J[b+4>>2]>0){while(1){ab(J[(J[b>>2]+(a<<3)|0)+4>>2]);a=a+1|0;if((a|0)>2]){continue}break}}ab(J[b>>2]);ab(b)}}function jk(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=Q(0),f=0,g=Q(0);a:{if(J[a>>2]!=2){break a}f=!d;d=L[a+4>>1];if(!(f|d&2)){J[a+144>>2]=0;d=d|2;I[a+4>>1]=d}if(!(d&2)){break a}g=N[b+4>>2];e=N[a+120>>2];N[a+64>>2]=Q(e*N[b>>2])+N[a+64>>2];N[a+68>>2]=Q(e*g)+N[a+68>>2];N[a+72>>2]=Q(N[a+128>>2]*Q(Q(Q(N[c>>2]-N[a+44>>2])*N[b+4>>2])-Q(N[b>>2]*Q(N[c+4>>2]-N[a+48>>2]))))+N[a+72>>2]}}function Ei(a,b,c,d){a=a|0;b=b|0;c=Q(c);d=d|0;var e=0,f=0,g=0,h=0;e=La-32|0;La=e;f=J[a+12>>2];if(!(H[23884]&1)){a=ba(4,20480)|0;H[23884]=1;J[5970]=a}g=J[5970];a=Xa(8);h=J[b+4>>2];J[a>>2]=J[b>>2];J[a+4>>2]=h;N[e+16>>2]=c;J[e+8>>2]=a;a=Xa(16);b=J[d+12>>2];J[a+8>>2]=J[d+8>>2];J[a+12>>2]=b;b=J[d+4>>2];J[a>>2]=J[d>>2];J[a+4>>2]=b;J[e+24>>2]=a;da(g|0,f|0,4590,e+8|0);La=e+32|0}function Ai(a,b,c,d){a=a|0;b=b|0;c=Q(c);d=d|0;var e=0,f=0,g=0,h=0;e=La-32|0;La=e;f=J[a+12>>2];if(!(H[23884]&1)){a=ba(4,20480)|0;H[23884]=1;J[5970]=a}g=J[5970];a=Xa(8);h=J[b+4>>2];J[a>>2]=J[b>>2];J[a+4>>2]=h;N[e+16>>2]=c;J[e+8>>2]=a;a=Xa(16);b=J[d+12>>2];J[a+8>>2]=J[d+8>>2];J[a+12>>2]=b;b=J[d+4>>2];J[a>>2]=J[d>>2];J[a+4>>2]=b;J[e+24>>2]=a;da(g|0,f|0,1560,e+8|0);La=e+32|0}function Bf(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;a=J[c+8>>2];e=J[b+8>>2];if(!(J[a>>2]|J[e>>2])){return 0}a=J[a+108>>2];a:{if(a){while(1){d=0;if(!(K[J[a+4>>2]+61|0]|(e|0)!=J[a>>2])){break a}a=J[a+12>>2];if(a){continue}break}}d=1}if(d){a=I[b+36>>1];if(!(!a|L[c+36>>1]!=(a&65535))){return(a|0)>0|0}a=(L[c+32>>1]&L[b+34>>1])!=0&(L[c+34>>1]&L[b+32>>1])!=0}else{a=0}return a|0}function mj(){var a=0;a=Xa(76);J[a+4>>2]=0;J[a+8>>2]=0;J[a+20>>2]=0;J[a+24>>2]=0;J[a>>2]=7;J[a+48>>2]=0;J[a+52>>2]=0;H[a+44|0]=0;J[a+36>>2]=1065353216;J[a+40>>2]=0;J[a+60>>2]=0;J[a+64>>2]=0;H[a+9|0]=0;H[a+10|0]=0;H[a+11|0]=0;H[a+12|0]=0;H[a+13|0]=0;H[a+14|0]=0;H[a+15|0]=0;H[a+16|0]=0;J[a+28>>2]=0;J[a+32>>2]=0;H[a+56|0]=0;J[a+68>>2]=0;J[a+72>>2]=0;return a|0}function hf(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;if(gb(a,J[b+8>>2],e)){if(!(J[b+28>>2]==1|J[b+4>>2]!=(c|0))){J[b+28>>2]=d}return}a:{if(!gb(a,J[b>>2],e)){break a}if(!(J[b+16>>2]!=(c|0)&J[b+20>>2]!=(c|0))){if((d|0)!=1){break a}J[b+32>>2]=1;return}J[b+20>>2]=c;J[b+32>>2]=d;J[b+40>>2]=J[b+40>>2]+1;if(!(J[b+36>>2]!=1|J[b+24>>2]!=2)){H[b+54|0]=1}J[b+44>>2]=4}}function Ah(a){a=a|0;var b=0,c=0,d=0;a:{d=J[a+8>>2];if(!d){break a}b=J[d+112>>2];if(b){while(1){c=J[b+4>>2];if(!(J[c+48>>2]!=(a|0)&J[c+52>>2]!=(a|0))){J[c+4>>2]=J[c+4>>2]|8}b=J[b+12>>2];if(b){continue}break}}b=J[d+88>>2];if(!b|J[a+28>>2]<=0){break a}c=b+102868|0;b=0;while(1){wc(c,J[(J[a+24>>2]+P(b,28)|0)+24>>2]);b=b+1|0;if((b|0)>2]){continue}break}}}function li(a,b,c){a=a|0;b=Q(b);c=Q(c);var d=Q(0);J[a+84>>2]=0;J[a+88>>2]=-1082130432;J[a+148>>2]=4;J[a+12>>2]=0;J[a+16>>2]=0;J[a+108>>2]=-1082130432;J[a+112>>2]=0;J[a+100>>2]=0;J[a+104>>2]=1065353216;J[a+92>>2]=1065353216;J[a+96>>2]=0;N[a+48>>2]=c;d=Q(-b);N[a+44>>2]=d;N[a+40>>2]=c;N[a+36>>2]=b;c=Q(-c);N[a+32>>2]=c;N[a+28>>2]=b;N[a+24>>2]=c;N[a+20>>2]=d}function Fb(a,b){var c=0,d=0,e=0,f=0;f=a+102412|0;c=J[a+102796>>2];J[(f+P(c,12)|0)+4>>2]=b;d=J[a+102400>>2];e=d+b|0;a:{if((e|0)>=102401){e=1;d=fb(b);break a}J[a+102400>>2]=e;e=0;d=a+d|0}c=f+P(c,12)|0;H[c+8|0]=e;J[c>>2]=d;b=J[a+102404>>2]+b|0;J[a+102404>>2]=b;J[a+102796>>2]=J[a+102796>>2]+1;c=a;a=J[a+102408>>2];J[c+102408>>2]=(a|0)>(b|0)?a:b;return d}function zj(){var a=0;a=Xa(72);J[a+4>>2]=0;J[a+8>>2]=0;J[a+20>>2]=0;J[a+24>>2]=0;J[a>>2]=2;J[a+64>>2]=0;J[a+68>>2]=0;J[a+36>>2]=1065353216;J[a+52>>2]=0;J[a+56>>2]=0;H[a+9|0]=0;H[a+10|0]=0;H[a+11|0]=0;H[a+12|0]=0;H[a+13|0]=0;H[a+14|0]=0;H[a+15|0]=0;H[a+16|0]=0;J[a+28>>2]=0;J[a+32>>2]=0;J[a+40>>2]=0;J[a+44>>2]=0;H[a+48|0]=0;H[a+60|0]=0;return a|0}function oc(a,b,c,d){H[a+53|0]=1;a:{if(J[a+4>>2]!=(c|0)){break a}H[a+52|0]=1;c=J[a+16>>2];b:{if(!c){J[a+36>>2]=1;J[a+24>>2]=d;J[a+16>>2]=b;if((d|0)!=1){break a}if(J[a+48>>2]==1){break b}break a}if((b|0)==(c|0)){c=J[a+24>>2];if((c|0)==2){J[a+24>>2]=d;c=d}if(J[a+48>>2]!=1){break a}if((c|0)==1){break b}break a}J[a+36>>2]=J[a+36>>2]+1}H[a+54|0]=1}}function dd(a,b,c,d,e,f){var g=0,h=0;J[a+48>>2]=d;J[a+44>>2]=c;J[a+40>>2]=b;J[a+36>>2]=0;J[a+28>>2]=0;J[a+32>>2]=0;J[a+4>>2]=f;J[a>>2]=e;g=a,h=Fb(e,b<<2),J[g+8>>2]=h;g=a,h=Fb(J[a>>2],c<<2),J[g+12>>2]=h;g=a,h=Fb(J[a>>2],d<<2),J[g+16>>2]=h;g=a,h=Fb(J[a>>2],P(J[a+40>>2],12)),J[g+24>>2]=h;g=a,h=Fb(J[a>>2],P(J[a+40>>2],12)),J[g+20>>2]=h;return a}function cc(a,b){a:{if((b|0)>=1024){a=a*898846567431158e293;if(b>>>0<2047){b=b-1023|0;break a}a=a*898846567431158e293;b=((b|0)>=3069?3069:b)-2046|0;break a}if((b|0)>-1023){break a}a=a*2004168360008973e-307;if(b>>>0>4294965304){b=b+969|0;break a}a=a*2004168360008973e-307;b=((b|0)<=-2960?-2960:b)+1938|0}x(0,0);x(1,b+1023<<20);return a*+z()}function qf(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=La+-64|0;La=d;e=1;a:{if(gb(a,b,0)){break a}e=0;if(!b){break a}b=sb(b,18020);e=0;if(!b){break a}Db(d+12|0,0,52);J[d+56>>2]=1;J[d+20>>2]=-1;J[d+16>>2]=a;J[d+8>>2]=b;Na[J[J[b>>2]+28>>2]](b,d+8|0,J[c>>2],1);a=J[d+32>>2];if((a|0)==1){J[c>>2]=J[d+24>>2]}e=(a|0)==1}a=e;La=d- -64|0;return a|0}function ze(){var a=0,b=0;J[5957]=0;J[5956]=719;oe();J[5957]=J[6200];J[6200]=23824;H[23924]=0;a=1;while(1){b=(J[(b<<2)+12096>>2]<(a|0))+b|0;H[a+23924|0]=b;b=b+(J[(b<<2)+12096>>2]<=(a|0))|0;H[a+23925|0]=b;a=a+2|0;if((a|0)!=641){continue}break}J[6201]=919;J[6202]=0;_c();J[6202]=J[6200];J[6200]=24804;J[6506]=24852;J[6488]=42}function Ge(a){a=a|0;var b=Q(0),c=Q(0),d=Q(0),e=Q(0),f=0;c=N[a+8>>2];b=N[a>>2];a:{if(!(Q(c-b)>=Q(0))){break a}d=N[a+12>>2];e=N[a+4>>2];if(!(Q(d-e)>=Q(0))){break a}b=Q(R(b));if(!(b>Q(Infinity)|bQ(Infinity)|b>2]=12836;c=J[b>>2];J[a+8>>2]=0;J[a+12>>2]=0;J[a+4>>2]=c;J[a+48>>2]=J[b+8>>2];c=J[b+12>>2];J[a+56>>2]=0;J[a+52>>2]=c;c=K[b+16|0];H[a+60|0]=0;H[a+61|0]=c;b=J[b+4>>2];J[a+16>>2]=0;J[a+20>>2]=0;J[a+64>>2]=b;J[a+24>>2]=0;J[a+28>>2]=0;J[a+32>>2]=0;J[a+36>>2]=0;J[a+40>>2]=0;J[a+44>>2]=0;return a}function Gi(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0,g=0;e=La-32|0;La=e;f=J[a+12>>2];if(!(H[23876]&1)){a=ba(4,20464)|0;H[23876]=1;J[5968]=a}g=J[5968];J[e+16>>2]=c;J[e+8>>2]=b;a=Xa(16);b=J[d+12>>2];J[a+8>>2]=J[d+8>>2];J[a+12>>2]=b;b=J[d+4>>2];J[a>>2]=J[d>>2];J[a+4>>2]=b;J[e+24>>2]=a;da(g|0,f|0,3150,e+8|0);La=e+32|0}function Fi(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0,g=0;e=La-32|0;La=e;f=J[a+12>>2];if(!(H[23876]&1)){a=ba(4,20464)|0;H[23876]=1;J[5968]=a}g=J[5968];J[e+16>>2]=c;J[e+8>>2]=b;a=Xa(16);b=J[d+12>>2];J[a+8>>2]=J[d+8>>2];J[a+12>>2]=b;b=J[d+4>>2];J[a>>2]=J[d>>2];J[a+4>>2]=b;J[e+24>>2]=a;da(g|0,f|0,3162,e+8|0);La=e+32|0}function nk(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0;a:{if(J[a>>2]!=2){break a}e=!d;d=L[a+4>>1];if(!(e|d&2)){J[a+144>>2]=0;d=d|2;I[a+4>>1]=d}if(!(d&2)){break a}N[a+76>>2]=N[b>>2]+N[a+76>>2];N[a+80>>2]=N[b+4>>2]+N[a+80>>2];N[a+84>>2]=N[a+84>>2]+Q(Q(Q(N[c>>2]-N[a+44>>2])*N[b+4>>2])-Q(N[b>>2]*Q(N[c+4>>2]-N[a+48>>2])))}}function Yj(a,b,c){a=a|0;b=b|0;c=c|0;var d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0);i=N[b+48>>2];j=N[b+16>>2];k=N[b+64>>2];d=N[b+72>>2];e=N[b+24>>2];f=N[c>>2];g=N[c+4>>2];h=N[b+20>>2];N[a+4>>2]=Q(d*Q(Q(N[b+12>>2]+Q(Q(e*f)-Q(g*h)))-N[b+44>>2]))+N[b+68>>2];N[a>>2]=k-Q(d*Q(Q(j+Q(Q(h*f)+Q(e*g)))-i))}function Xc(a){var b=0,c=0,d=0;a:{b:{b=a;if(!(b&3)){break b}if(!K[a|0]){return 0}while(1){b=b+1|0;if(!(b&3)){break b}if(K[b|0]){continue}break}break a}while(1){c=b;b=b+4|0;d=J[c>>2];if(!((d^-1)&d-16843009&-2139062144)){continue}break}while(1){b=c;c=b+1|0;if(K[b|0]){continue}break}}return b-a|0}function vi(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0),k=Q(0);e=N[c>>2];g=N[c+8>>2];h=N[a+12>>2];i=N[c+12>>2];j=N[a+16>>2];k=Q(N[c+4>>2]+Q(Q(g*h)+Q(i*j)));f=N[a+8>>2];N[b+12>>2]=k+f;e=Q(e+Q(Q(i*h)-Q(j*g)));N[b+8>>2]=f+e;N[b+4>>2]=k-f;N[b>>2]=e-f}function Bi(a,b){a=a|0;b=b|0;var c=0,d=0,e=0,f=0;c=La-16|0;La=c;e=J[a+12>>2];if(!(H[23908]&1)){a=ba(2,20544)|0;H[23908]=1;J[5976]=a}f=J[5976];a=Xa(16);d=J[b+12>>2];J[a+8>>2]=J[b+8>>2];J[a+12>>2]=d;d=J[b+4>>2];J[a>>2]=J[b>>2];J[a+4>>2]=d;J[c+8>>2]=a;da(f|0,e|0,3191,c+8|0);La=c+16|0}function Rd(a,b){var c=Q(0),d=Q(0),e=Q(0),f=Q(0),g=Q(0);c=N[a+16>>2];d=N[a>>2];e=N[a+4>>2];f=N[a+12>>2];J[b+8>>2]=0;J[b+20>>2]=0;J[b+24>>2]=0;J[b+28>>2]=0;J[b+32>>2]=0;g=c;c=Q(Q(d*c)-Q(e*f));c=c!=Q(0)?Q(Q(1)/c):c;N[b>>2]=g*c;N[b+16>>2]=d*c;c=Q(-c);N[b+12>>2]=f*c;N[b+4>>2]=e*c}function Dj(){var a=0;a=Xa(44);J[a+4>>2]=0;J[a+8>>2]=0;J[a+36>>2]=1065353216;J[a+40>>2]=1050253722;J[a+28>>2]=0;J[a+32>>2]=1065353216;J[a+20>>2]=0;J[a+24>>2]=0;J[a>>2]=11;H[a+9|0]=0;H[a+10|0]=0;H[a+11|0]=0;H[a+12|0]=0;H[a+13|0]=0;H[a+14|0]=0;H[a+15|0]=0;H[a+16|0]=0;return a|0}function gb(a,b,c){var d=0;if(!c){return J[a+4>>2]==J[b+4>>2]}if((a|0)==(b|0)){return 1}d=J[a+4>>2];a=K[d|0];c=J[b+4>>2];b=K[c|0];a:{if(!a|(b|0)!=(a|0)){break a}while(1){b=K[c+1|0];a=K[d+1|0];if(!a){break a}c=c+1|0;d=d+1|0;if((a|0)==(b|0)){continue}break}}return(a|0)==(b|0)}function ui(a,b,c){a=a|0;b=b|0;c=Q(c);var d=Q(0),e=0,f=Q(0),g=Q(0);d=N[a+8>>2];c=Q(d*Q(d*Q(c*Q(3.1415927410125732))));N[b>>2]=c;e=J[a+16>>2];J[b+4>>2]=J[a+12>>2];J[b+8>>2]=e;d=c;c=N[a+8>>2];f=Q(Q(c*Q(.5))*c);c=N[a+12>>2];g=Q(c*c);c=N[a+16>>2];N[b+12>>2]=d*Q(f+Q(g+Q(c*c)))}function Fj(){var a=0;a=Xa(48);J[a+4>>2]=0;J[a+8>>2]=0;J[a+20>>2]=0;J[a+24>>2]=0;J[a>>2]=3;J[a+44>>2]=0;J[a+36>>2]=1065353216;J[a+40>>2]=0;H[a+9|0]=0;H[a+10|0]=0;H[a+11|0]=0;H[a+12|0]=0;H[a+13|0]=0;H[a+14|0]=0;H[a+15|0]=0;H[a+16|0]=0;J[a+28>>2]=0;J[a+32>>2]=0;return a|0}function Ph(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0;e=La-48|0;La=e;f=J[J[a+48>>2]+12>>2];J[e+36>>2]=0;J[e+40>>2]=0;H[e+44|0]=0;J[e+28>>2]=0;J[e+32>>2]=0;J[e+4>>2]=1;J[e+8>>2]=1008981770;J[e>>2]=11960;Jd(f,e,J[a+56>>2]);Id(b,e,c,J[J[a+52>>2]+12>>2],d);La=e+48|0}function Nh(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0;e=La-48|0;La=e;f=J[J[a+48>>2]+12>>2];J[e+36>>2]=0;J[e+40>>2]=0;H[e+44|0]=0;J[e+28>>2]=0;J[e+32>>2]=0;J[e+4>>2]=1;J[e+8>>2]=1008981770;J[e>>2]=11960;Jd(f,e,J[a+56>>2]);Hd(b,e,c,J[J[a+52>>2]+12>>2],d);La=e+48|0}function nf(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0;if(gb(a,J[b+8>>2],0)){pc(b,c,d);return}e=J[a+12>>2];f=a+16|0;Mc(f,b,c,d);a=a+24|0;e=(e<<3)+f|0;a:{if(a>>>0>=e>>>0){break a}while(1){Mc(a,b,c,d);if(K[b+54|0]){break a}a=a+8|0;if(e>>>0>a>>>0){continue}break}}}function xi(a,b,c){a=a|0;b=b|0;c=c|0;var d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0);d=N[b+12>>2];e=N[a+12>>2];f=N[a+16>>2];g=N[b+8>>2];h=Q(N[c>>2]-Q(N[b>>2]+Q(Q(d*e)-Q(f*g))));d=Q(N[c+4>>2]-Q(N[b+4>>2]+Q(Q(g*e)+Q(d*f))));e=Q(Q(h*h)+Q(d*d));d=N[a+8>>2];return e<=Q(d*d)|0}function Cg(a,b,c){a=a|0;b=Q(b);c=Q(c);var d=0;if(!(N[a+124>>2]==b&N[a+128>>2]==c)){d=J[a+48>>2];if(J[d>>2]){J[d+144>>2]=0;I[d+4>>1]=L[d+4>>1]|2}d=J[a+52>>2];if(J[d>>2]){J[d+144>>2]=0;I[d+4>>1]=L[d+4>>1]|2}N[a+128>>2]=c;N[a+124>>2]=b;J[a+116>>2]=0;J[a+120>>2]=0}}function pj(){var a=0;a=Xa(48);J[a+4>>2]=0;J[a+8>>2]=0;J[a+20>>2]=0;J[a+24>>2]=0;J[a>>2]=8;H[a+9|0]=0;H[a+10|0]=0;H[a+11|0]=0;H[a+12|0]=0;H[a+13|0]=0;H[a+14|0]=0;H[a+15|0]=0;H[a+16|0]=0;J[a+28>>2]=0;J[a+32>>2]=0;J[a+36>>2]=0;J[a+40>>2]=0;J[a+44>>2]=0;return a|0}function gg(a,b,c){a=a|0;b=Q(b);c=Q(c);var d=0;if(!(N[a+124>>2]==b&N[a+128>>2]==c)){d=J[a+48>>2];if(J[d>>2]){J[d+144>>2]=0;I[d+4>>1]=L[d+4>>1]|2}d=J[a+52>>2];if(J[d>>2]){J[d+144>>2]=0;I[d+4>>1]=L[d+4>>1]|2}N[a+128>>2]=c;N[a+124>>2]=b;J[a+96>>2]=0;J[a+100>>2]=0}}function ik(a,b,c){a=a|0;b=b|0;c=c|0;var d=Q(0),e=0,f=Q(0);a:{if(J[a>>2]!=2){break a}e=!c;c=L[a+4>>1];if(!(e|c&2)){J[a+144>>2]=0;c=c|2;I[a+4>>1]=c}if(!(c&2)){break a}f=N[b+4>>2];d=N[a+120>>2];N[a+64>>2]=Q(d*N[b>>2])+N[a+64>>2];N[a+68>>2]=Q(d*f)+N[a+68>>2]}}function sj(){var a=0;a=Xa(40);J[a+4>>2]=0;J[a+8>>2]=0;J[a+36>>2]=0;J[a+28>>2]=1065353216;J[a+32>>2]=0;J[a+20>>2]=-1082130432;J[a+24>>2]=0;J[a>>2]=10;H[a+9|0]=0;H[a+10|0]=0;H[a+11|0]=0;H[a+12|0]=0;H[a+13|0]=0;H[a+14|0]=0;H[a+15|0]=0;H[a+16|0]=0;return a|0}function Kb(a,b,c){var d=0,e=0,f=0,g=0;if(b){while(1){c=c-1|0;e=a;a=ll(a,b,10);d=Ma;f=c,g=e-kl(a,d,10,0)|48,H[f|0]=g;e=b>>>0>9;b=d;if(e){continue}break}}if(a){while(1){c=c-1|0;b=(a>>>0)/10|0;H[c|0]=a-P(b,10)|48;d=a>>>0>9;a=b;if(d){continue}break}}return c}function Bj(){var a=0;a=Xa(40);J[a+4>>2]=0;J[a+8>>2]=0;J[a+36>>2]=1060320051;J[a+28>>2]=0;J[a+32>>2]=1084227584;J[a+20>>2]=0;J[a+24>>2]=0;J[a>>2]=5;H[a+9|0]=0;H[a+10|0]=0;H[a+11|0]=0;H[a+12|0]=0;H[a+13|0]=0;H[a+14|0]=0;H[a+15|0]=0;H[a+16|0]=0;return a|0}function ch(a,b){a=a|0;b=b|0;var c=0;if(!(N[b>>2]==N[a+68>>2]&N[b+4>>2]==N[a+72>>2])){c=J[a+48>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}c=J[a+52>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}c=J[b+4>>2];J[a+68>>2]=J[b>>2];J[a+72>>2]=c}}function Vc(a,b){var c=0,d=0,e=0;A(+a);d=v(1)|0;e=v(0)|0;c=d>>>20&2047;if((c|0)!=2047){if(!c){if(a==0){c=0}else{a=Vc(a*0x10000000000000000,b);c=J[b>>2]+-64|0}J[b>>2]=c;return a}J[b>>2]=c-1022;x(0,e|0);x(1,d&-2146435073|1071644672);a=+z()}return a}function Qe(a,b){a=a|0;b=b|0;var c=0,d=0,e=0;d=a+16|0;a=J[d>>2];a:{b:{if(!a){break b}c=d;while(1){e=M[a+16>>2]>>0;c=e?c:a;a=J[(e?a+4|0:a)>>2];if(a){continue}break}if((c|0)==(d|0)){break b}if(M[c+16>>2]<=b>>>0){break a}}c=d}return(c|0)!=(d|0)|0}function Sd(a,b,c){var d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0),i=Q(0),j=Q(0);e=N[b>>2];f=N[b+16>>2];g=N[b+4>>2];h=N[b+12>>2];d=Q(Q(e*f)-Q(g*h));d=d!=Q(0)?Q(Q(1)/d):d;j=e;e=N[c+4>>2];i=N[c>>2];N[a+4>>2]=d*Q(Q(j*e)-Q(i*g));N[a>>2]=d*Q(Q(f*i)-Q(e*h))}function Yh(a,b,c){a=a|0;b=b|0;c=Q(c);var d=0;d=La-32|0;La=d;I[d+30>>1]=0;H[d+24|0]=0;J[d+16>>2]=0;J[d+20>>2]=0;I[d+26>>1]=1;I[d+28>>1]=65535;J[d+8>>2]=0;J[d+12>>2]=1045220557;J[d+4>>2]=b;N[d+20>>2]=c;a=Ld(a,d+4|0);La=d+32|0;return a|0}function Eb(a,b){var c=0,d=0,e=0;c=J[a+102796>>2];d=P(c,12)+a|0;e=d+102412|0;a:{if(K[d+102408|0]){ab(b);b=J[e-8>>2];c=J[a+102796>>2];break a}b=J[e-8>>2];J[a+102400>>2]=J[a+102400>>2]-b}J[a+102796>>2]=c-1;J[a+102404>>2]=J[a+102404>>2]-b}function Be(a,b,c){a=a|0;b=b|0;c=c|0;var d=Q(0),e=Q(0),f=Q(0),g=Q(0);d=N[c>>2];e=N[b>>2];f=N[b+4>>2];g=N[c+4>>2];N[a+4>>2]=f>2]=d>e?e:d;d=N[c+8>>2];e=N[b+8>>2];f=N[b+12>>2];g=N[c+12>>2];N[a+12>>2]=f>g?f:g;N[a+8>>2]=d>2];g=N[b+192>>2];d=N[b+104>>2];e=Q(Q(N[b+112>>2]+N[b+116>>2])+N[b+120>>2]);N[a+4>>2]=Q(Q(d*N[b+196>>2])+Q(e*N[b+188>>2]))*c;N[a>>2]=Q(Q(d*g)+Q(f*e))*c}function Tc(a){var b=0,c=0,d=0;if(H[J[a>>2]]-48>>>0>=10){return 0}while(1){d=J[a>>2];c=-1;if(b>>>0<=214748364){c=H[d|0]-48|0;b=P(b,10);c=(c|0)>(b^2147483647)?-1:c+b|0}J[a>>2]=d+1;b=c;if(H[d+1|0]-48>>>0<10){continue}break}return b}function yk(a,b,c){a=a|0;b=b|0;c=c|0;var d=0;d=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){d=J[d+J[b>>2]>>2]}a=Na[d|0](b,c)|0;b=Xa(16);c=J[a+12>>2];J[b+8>>2]=J[a+8>>2];J[b+12>>2]=c;c=J[a+4>>2];J[b>>2]=J[a>>2];J[b+4>>2]=c;return b|0}function _i(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=La-16|0;La=d;e=a;a=J[b>>2];if(J[b+4>>2]-a>>3>>>0>c>>>0){b=Xa(8);c=a+(c<<3)|0;a=J[c+4>>2];J[b>>2]=J[c>>2];J[b+4>>2]=a;J[d+8>>2]=b;a=za(18924,d+8|0)|0}else{a=1}J[e>>2]=a;La=d+16|0}function pe(a,b,c){a=a|0;b=b|0;c=Q(c);var d=0,e=0,f=0;d=La-16|0;La=d;e=J[a>>2];f=d+8|0;a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){e=J[e+J[b>>2]>>2]}Na[e|0](f,b,c);a=Xa(8);b=J[d+12>>2];J[a>>2]=J[d+8>>2];J[a+4>>2]=b;La=d+16|0;return a|0}function bk(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0,f=0;d=La-16|0;La=d;e=J[a>>2];f=d+8|0;a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){e=J[e+J[b>>2]>>2]}Na[e|0](f,b,c);a=Xa(8);b=J[d+12>>2];J[a>>2]=J[d+8>>2];J[a+4>>2]=b;La=d+16|0;return a|0}function Dg(a,b){a=a|0;b=b|0;var c=0;if(K[a+140|0]!=(b|0)){c=J[a+48>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}c=J[a+52>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}J[a+116>>2]=0;J[a+120>>2]=0;H[a+140|0]=b}}function hg(a,b){a=a|0;b=b|0;var c=0;if(K[a+116|0]!=(b|0)){c=J[a+48>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}c=J[a+52>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}J[a+96>>2]=0;J[a+100>>2]=0;H[a+116|0]=b}}function Hf(a,b){a=a|0;b=b|0;a:{if(K[a+102972|0]==(b|0)){break a}H[a+102972|0]=b;if(b){break a}b=J[a+102948>>2];if(!b){break a}while(1){if(J[b>>2]){J[b+144>>2]=0;I[b+4>>1]=L[b+4>>1]|2}b=J[b+96>>2];if(b){continue}break}}}function tk(a,b){a=a|0;b=b|0;var c=0;c=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){c=J[c+J[b>>2]>>2]}a=Na[c|0](b)|0;b=Xa(16);c=J[a+12>>2];J[b+8>>2]=J[a+8>>2];J[b+12>>2]=c;c=J[a+4>>2];J[b>>2]=J[a>>2];J[b+4>>2]=c;return b|0}function Vi(a,b){a=a|0;b=b|0;var c=0,d=0,e=0;c=La-16|0;La=c;a=J[a+8>>2];if(!(H[23844]&1)){d=ba(2,19540)|0;H[23844]=1;J[5960]=d}d=J[5960];J[c+8>>2]=b;e=+wa(d|0,a|0,4277,c+4|0,c+8|0);va(J[c+4>>2]);La=c+16|0;return e!=0|0}function Ce(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0);d=N[b>>2];c=N[a+4>>2];e=N[b+4>>2];N[a+4>>2]=c>2];N[a>>2]=c>2];c=N[a+12>>2];e=N[b+12>>2];N[a+12>>2]=c>e?c:e;c=N[a+8>>2];N[a+8>>2]=c>d?c:d}function Bd(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0);c=J[b+52>>2];h=N[c+12>>2];d=N[c+20>>2];e=N[b+100>>2];f=N[c+24>>2];g=N[b+104>>2];N[a+4>>2]=Q(Q(d*e)+Q(f*g))+N[c+16>>2];N[a>>2]=h+Q(Q(f*e)-Q(g*d))}function wk(){var a=0;a=Xa(52);J[a+4>>2]=0;J[a+8>>2]=0;J[a+44>>2]=0;J[a+48>>2]=1065353216;J[a+36>>2]=257;H[a+40|0]=1;J[a>>2]=0;J[a+12>>2]=0;J[a+16>>2]=0;J[a+20>>2]=0;J[a+24>>2]=0;J[a+28>>2]=0;J[a+32>>2]=0;return a|0}function kl(a,b,c,d){var e=0,f=0,g=0,h=0,i=0,j=0;e=c>>>16|0;f=a>>>16|0;j=P(e,f);g=c&65535;h=a&65535;i=P(g,h);f=(i>>>16|0)+P(f,g)|0;e=(f&65535)+P(e,h)|0;Ma=(P(b,c)+j|0)+P(a,d)+(f>>>16)+(e>>>16)|0;return i&65535|e<<16}function yi(a,b){a=a|0;b=b|0;var c=0;b=eb(b,20);J[b+4>>2]=0;J[b+8>>2]=0;J[b>>2]=11892;J[b+12>>2]=0;J[b+16>>2]=0;c=J[a+8>>2];J[b+4>>2]=J[a+4>>2];J[b+8>>2]=c;c=J[a+16>>2];J[b+12>>2]=J[a+12>>2];J[b+16>>2]=c;return b|0}function mk(a,b,c){a=a|0;b=b|0;c=c|0;var d=0;a:{if(J[a>>2]!=2){break a}d=!c;c=L[a+4>>1];if(!(d|c&2)){J[a+144>>2]=0;c=c|2;I[a+4>>1]=c}if(!(c&2)){break a}N[a+76>>2]=N[b>>2]+N[a+76>>2];N[a+80>>2]=N[b+4>>2]+N[a+80>>2]}}function Vg(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0);c=J[b+52>>2];h=N[c+12>>2];d=N[c+20>>2];e=N[b+68>>2];f=N[c+24>>2];g=N[b+72>>2];N[a+4>>2]=Q(Q(d*e)+Q(f*g))+N[c+16>>2];N[a>>2]=h+Q(Q(f*e)-Q(g*d))}function Qb(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0);c=J[b+48>>2];h=N[c+12>>2];d=N[c+20>>2];e=N[b+68>>2];f=N[c+24>>2];g=N[b+72>>2];N[a+4>>2]=Q(Q(d*e)+Q(f*g))+N[c+16>>2];N[a>>2]=h+Q(Q(f*e)-Q(g*d))}function Pb(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0);c=J[b+52>>2];h=N[c+12>>2];d=N[c+20>>2];e=N[b+76>>2];f=N[c+24>>2];g=N[b+80>>2];N[a+4>>2]=Q(Q(d*e)+Q(f*g))+N[c+16>>2];N[a>>2]=h+Q(Q(f*e)-Q(g*d))}function Gd(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0);c=J[b+48>>2];h=N[c+12>>2];d=N[c+20>>2];e=N[b+80>>2];f=N[c+24>>2];g=N[b+84>>2];N[a+4>>2]=Q(Q(d*e)+Q(f*g))+N[c+16>>2];N[a>>2]=h+Q(Q(f*e)-Q(g*d))}function Fd(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0);c=J[b+52>>2];h=N[c+12>>2];d=N[c+20>>2];e=N[b+88>>2];f=N[c+24>>2];g=N[b+92>>2];N[a+4>>2]=Q(Q(d*e)+Q(f*g))+N[c+16>>2];N[a>>2]=h+Q(Q(f*e)-Q(g*d))}function Cd(a,b){a=a|0;b=b|0;var c=0,d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0);c=J[b+48>>2];h=N[c+12>>2];d=N[c+20>>2];e=N[b+92>>2];f=N[c+24>>2];g=N[b+96>>2];N[a+4>>2]=Q(Q(d*e)+Q(f*g))+N[c+16>>2];N[a>>2]=h+Q(Q(f*e)-Q(g*d))}function lc(a,b){a=a|0;b=b|0;var c=0,d=0,e=0;c=La-16|0;La=c;d=J[a>>2];e=c+8|0;a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){d=J[d+J[b>>2]>>2]}Na[d|0](e,b);a=Xa(8);b=J[c+12>>2];J[a>>2]=J[c+8>>2];J[a+4>>2]=b;La=c+16|0;return a|0}function mi(a,b){a=a|0;b=b|0;var c=0;b=eb(b,152);J[b+148>>2]=0;J[b+4>>2]=2;J[b+8>>2]=1008981770;J[b>>2]=12028;J[b+12>>2]=0;J[b+16>>2]=0;c=J[a+8>>2];J[b+4>>2]=J[a+4>>2];J[b+8>>2]=c;rb(b+12|0,a+12|0,140);return b|0}function Sj(a,b){a=a|0;b=b|0;var c=0;if(J[a>>2]){c=L[a+4>>1];if(b){J[a+144>>2]=0;I[a+4>>1]=c|2;return}J[a+144>>2]=0;J[a+64>>2]=0;J[a+68>>2]=0;I[a+4>>1]=c&65533;J[a+72>>2]=0;J[a+76>>2]=0;J[a+80>>2]=0;J[a+84>>2]=0}}function Qi(a){a=a|0;var b=0,c=0;J[a>>2]=19996;ic(a+12|0,J[a+16>>2]);J[a>>2]=20028;if(K[a+4|0]){b=J[a+8>>2];if(!(H[23836]&1)){c=ba(1,19536)|0;H[23836]=1;J[5958]=c}da(J[5958],b|0,2030,0)}ga(J[a+8>>2]);return a|0}function pc(a,b,c){var d=0;d=J[a+16>>2];if(!d){J[a+36>>2]=1;J[a+24>>2]=c;J[a+16>>2]=b;return}a:{if((b|0)==(d|0)){if(J[a+24>>2]!=2){break a}J[a+24>>2]=c;return}H[a+54|0]=1;J[a+24>>2]=2;J[a+36>>2]=J[a+36>>2]+1}}function wc(a,b){var c=0,d=0;c=J[a+40>>2];if((c|0)==J[a+36>>2]){J[a+36>>2]=c<<1;d=J[a+32>>2];c=fb(c<<3);J[a+32>>2]=c;rb(c,d,J[a+40>>2]<<2);ab(d);c=J[a+40>>2]}J[J[a+32>>2]+(c<<2)>>2]=b;J[a+40>>2]=J[a+40>>2]+1}function ek(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=Q(0),f=0;c=N[a+116>>2];N[b>>2]=c;d=c;c=N[a+28>>2];e=Q(c*c);c=N[a+32>>2];N[b+12>>2]=Q(d*Q(e+Q(c*c)))+N[a+124>>2];f=J[a+32>>2];J[b+4>>2]=J[a+28>>2];J[b+8>>2]=f}function Pi(a){a=a|0;var b=0,c=0;J[a>>2]=19996;ic(a+12|0,J[a+16>>2]);J[a>>2]=20028;if(K[a+4|0]){b=J[a+8>>2];if(!(H[23836]&1)){c=ba(1,19536)|0;H[23836]=1;J[5958]=c}da(J[5958],b|0,2030,0)}ga(J[a+8>>2]);ab(a)}function kb(a,b,c,d,e){var f=0;f=La-256|0;La=f;if(!(e&73728|(c|0)<=(d|0))){d=c-d|0;c=d>>>0<256;Db(f,b&255,c?d:256);if(!c){while(1){jb(a,f,256);d=d-256|0;if(d>>>0>255){continue}break}}jb(a,f,d)}La=f+256|0}function Kk(a,b){a=a|0;b=b|0;var c=0;c=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){c=J[c+J[b>>2]>>2]}a=Na[c|0](b)|0;b=Xa(6);I[b+4>>1]=L[a+4>>1];a=L[a>>1]|L[a+2>>1]<<16;I[b>>1]=a;I[b+2>>1]=a>>>16;return b|0}function ck(a,b,c){a=a|0;b=b|0;c=c|0;var d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0);h=N[b+12>>2];d=N[b+20>>2];e=N[c>>2];f=N[b+24>>2];g=N[c+4>>2];N[a+4>>2]=Q(Q(d*e)+Q(f*g))+N[b+16>>2];N[a>>2]=h+Q(Q(f*e)-Q(g*d))}function Rf(a,b,c){a=a|0;b=b|0;c=Q(c);var d=Q(0),e=Q(0),f=Q(0),g=Q(0);f=N[b+204>>2];g=N[b+196>>2];d=N[b+100>>2];e=N[b+108>>2];N[a>>2]=Q(Q(d*N[b+200>>2])+Q(e*N[b+192>>2]))*c;N[a+4>>2]=Q(Q(d*f)+Q(e*g))*c}function Oe(a,b,c){a=a|0;b=b|0;c=c|0;var d=Q(0),e=Q(0),f=Q(0),g=Q(0),h=Q(0);h=N[b>>2];d=N[b+8>>2];e=N[c>>2];f=N[b+12>>2];g=N[c+4>>2];N[a+4>>2]=Q(Q(d*e)+Q(f*g))+N[b+4>>2];N[a>>2]=h+Q(Q(f*e)-Q(g*d))}function pk(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0),e=0;if(J[a>>2]){c=N[b>>2];d=Q(c*c);c=N[b+4>>2];if(Q(d+Q(c*c))>Q(0)){J[a+144>>2]=0;I[a+4>>1]=L[a+4>>1]|2}e=J[b+4>>2];J[a+64>>2]=J[b>>2];J[a+68>>2]=e}}function od(a,b){a=a|0;b=b|0;var c=0;if(K[a+141|0]!=(b|0)){c=J[a+48>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}c=J[a+52>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}H[a+141|0]=b}}function lg(a,b){a=a|0;b=b|0;var c=0;if(K[a+104|0]!=(b|0)){c=J[a+48>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}c=J[a+52>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}H[a+104|0]=b}}function nd(a,b){a=a|0;b=Q(b);var c=0;if(N[a+136>>2]!=b){c=J[a+48>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}c=J[a+52>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}N[a+136>>2]=b}}function md(a,b){a=a|0;b=Q(b);var c=0;if(N[a+132>>2]!=b){c=J[a+48>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}c=J[a+52>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}N[a+132>>2]=b}}function kg(a,b){a=a|0;b=Q(b);var c=0;if(N[a+112>>2]!=b){c=J[a+48>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}c=J[a+52>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}N[a+112>>2]=b}}function jg(a,b){a=a|0;b=Q(b);var c=0;if(N[a+108>>2]!=b){c=J[a+48>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}c=J[a+52>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}N[a+108>>2]=b}}function hk(a,b,c){a=a|0;b=Q(b);c=c|0;var d=0;a:{if(J[a>>2]!=2){break a}d=!c;c=L[a+4>>1];if(!(d|c&2)){J[a+144>>2]=0;c=c|2;I[a+4>>1]=c}if(!(c&2)){break a}N[a+72>>2]=Q(N[a+128>>2]*b)+N[a+72>>2]}}function bh(a,b){a=a|0;b=Q(b);var c=0;if(N[a+76>>2]!=b){c=J[a+48>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}c=J[a+52>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}N[a+76>>2]=b}}function _g(a,b){a=a|0;b=b|0;var c=0;if(!(N[b>>2]==N[a+76>>2]&N[b+4>>2]==N[a+80>>2])){c=J[a+52>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}c=J[b+4>>2];J[a+76>>2]=J[b>>2];J[a+80>>2]=c}}function wf(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0;e=La-16|0;La=e;a=Ba(J[a+60>>2],b|0,c|0,d&255,e+8|0)|0;if(a){J[6204]=a;a=-1}else{a=0}La=e+16|0;Ma=a?-1:J[e+12>>2];return(a?-1:J[e+8>>2])|0}function $j(a,b,c){a=a|0;b=b|0;c=c|0;var d=Q(0),e=Q(0),f=Q(0),g=Q(0);d=N[b+24>>2];e=Q(N[c+4>>2]-N[b+16>>2]);f=N[b+20>>2];g=Q(N[c>>2]-N[b+12>>2]);N[a+4>>2]=Q(d*e)-Q(f*g);N[a>>2]=Q(d*g)+Q(e*f)}function Zj(a,b,c){a=a|0;b=b|0;c=c|0;var d=Q(0),e=Q(0),f=Q(0),g=Q(0);e=N[b+48>>2];f=N[b+64>>2];g=N[c+4>>2];d=N[b+72>>2];N[a+4>>2]=Q(d*Q(N[c>>2]-N[b+44>>2]))+N[b+68>>2];N[a>>2]=f-Q(d*Q(g-e))}function Wc(a){var b=0;b=J[a+72>>2];J[a+72>>2]=b-1|b;b=J[a>>2];if(b&8){J[a>>2]=b|32;return-1}J[a+4>>2]=0;J[a+8>>2]=0;b=J[a+44>>2];J[a+28>>2]=b;J[a+20>>2]=b;J[a+16>>2]=b+J[a+48>>2];return 0}function ni(a,b,c){a=a|0;b=b|0;c=Q(c);var d=Q(0),e=Q(0),f=Q(0);J[b>>2]=0;c=N[a+24>>2];d=N[a+16>>2];e=N[a+20>>2];f=N[a+12>>2];J[b+12>>2]=0;N[b+8>>2]=Q(d+c)*Q(.5);N[b+4>>2]=Q(f+e)*Q(.5)}function fj(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=La-16|0;La=d;e=J[b+4>>2];b=J[b>>2];if(e-b>>2>>>0>c>>>0){J[d+8>>2]=J[b+(c<<2)>>2];b=za(18420,d+8|0)|0}else{b=1}J[a>>2]=b;La=d+16|0}function lk(a,b,c){a=a|0;b=Q(b);c=c|0;var d=0;a:{if(J[a>>2]!=2){break a}d=!c;c=L[a+4>>1];if(!(d|c&2)){J[a+144>>2]=0;c=c|2;I[a+4>>1]=c}if(!(c&2)){break a}N[a+84>>2]=N[a+84>>2]+b}}function Lc(a,b){var c=0;a:{if(!b){break a}b=sb(b,18228);if(!b|J[b+8>>2]&(J[a+8>>2]^-1)){break a}if(!gb(J[a+12>>2],J[b+12>>2],0)){break a}c=gb(J[a+16>>2],J[b+16>>2],0)}return c}function Ii(a){a=a|0;var b=0,c=0;J[a>>2]=20416;if(K[a+8|0]){b=J[a+12>>2];if(!(H[23836]&1)){c=ba(1,19536)|0;H[23836]=1;J[5958]=c}da(J[5958],b|0,2030,0)}ga(J[a+12>>2]);return a|0}function Xi(a){a=a|0;var b=0,c=0;J[a>>2]=19524;if(K[a+4|0]){b=J[a+8>>2];if(!(H[23836]&1)){c=ba(1,19536)|0;H[23836]=1;J[5958]=c}da(J[5958],b|0,2030,0)}ga(J[a+8>>2]);return a|0}function Ui(a){a=a|0;var b=0,c=0;J[a>>2]=19760;if(K[a+4|0]){b=J[a+8>>2];if(!(H[23836]&1)){c=ba(1,19536)|0;H[23836]=1;J[5958]=c}da(J[5958],b|0,2030,0)}ga(J[a+8>>2]);return a|0}function Ki(a){a=a|0;var b=0,c=0;J[a>>2]=20028;if(K[a+4|0]){b=J[a+8>>2];if(!(H[23836]&1)){c=ba(1,19536)|0;H[23836]=1;J[5958]=c}da(J[5958],b|0,2030,0)}ga(J[a+8>>2]);return a|0}function hj(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0,f=0;e=La-16|0;La=e;f=J[a+4>>2];b=(f>>1)+b|0;a=J[a>>2];a=f&1?J[J[b>>2]+a>>2]:a;J[e+12>>2]=d;Na[a|0](b,c,e+12|0);La=e+16|0}function Jb(a){var b=0,c=0;b=J[5953];c=a+7&-8;a=b+c|0;a:{if(a>>>0<=b>>>0?c:0){break a}if(a>>>0>Oa()<<16>>>0){if(!(Da(a|0)|0)){break a}}J[5953]=a;return b}J[6204]=48;return-1}function Hi(a){a=a|0;var b=0,c=0;J[a>>2]=20416;if(K[a+8|0]){b=J[a+12>>2];if(!(H[23836]&1)){c=ba(1,19536)|0;H[23836]=1;J[5958]=c}da(J[5958],b|0,2030,0)}ga(J[a+12>>2]);ab(a)}function Ab(a,b){a=a|0;b=b|0;var c=0;c=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){c=J[c+J[b>>2]>>2]}a=Na[c|0](b)|0;b=Xa(8);c=J[a+4>>2];J[b>>2]=J[a>>2];J[b+4>>2]=c;return b|0}function Wi(a){a=a|0;var b=0,c=0;J[a>>2]=19524;if(K[a+4|0]){b=J[a+8>>2];if(!(H[23836]&1)){c=ba(1,19536)|0;H[23836]=1;J[5958]=c}da(J[5958],b|0,2030,0)}ga(J[a+8>>2]);ab(a)}function Ti(a){a=a|0;var b=0,c=0;J[a>>2]=19760;if(K[a+4|0]){b=J[a+8>>2];if(!(H[23836]&1)){c=ba(1,19536)|0;H[23836]=1;J[5958]=c}da(J[5958],b|0,2030,0)}ga(J[a+8>>2]);ab(a)}function Ji(a){a=a|0;var b=0,c=0;J[a>>2]=20028;if(K[a+4|0]){b=J[a+8>>2];if(!(H[23836]&1)){c=ba(1,19536)|0;H[23836]=1;J[5958]=c}da(J[5958],b|0,2030,0)}ga(J[a+8>>2]);ab(a)}function Fk(a,b){a=a|0;b=Q(b);var c=0,d=0;c=(C(b),v(2));d=c&2147483647;if(!(!d|c-1>>>0<8388607|d-8388608>>>0<2130706432&(c|0)>=0)){Aa(3842,3377,300,1066);B()}N[a>>2]=b}function Tk(){var a=0;a=Xa(28);I[a+22>>1]=1;I[a+24>>1]=65535;J[a+12>>2]=0;J[a+16>>2]=0;J[a+8>>2]=1045220557;J[a>>2]=0;J[a+4>>2]=0;I[a+26>>1]=0;H[a+20|0]=0;return a|0}function jj(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=La-16|0;La=d;e=J[a+4>>2];b=(e>>1)+b|0;a=J[a>>2];a=e&1?J[J[b>>2]+a>>2]:a;J[d+12>>2]=c;Na[a|0](b,d+12|0);La=d+16|0}function ak(a,b,c){a=a|0;b=b|0;c=c|0;var d=Q(0),e=Q(0),f=Q(0),g=Q(0);d=N[b+20>>2];e=N[c>>2];f=N[b+24>>2];g=N[c+4>>2];N[a+4>>2]=Q(d*e)+Q(f*g);N[a>>2]=Q(f*e)-Q(g*d)}function _j(a,b,c){a=a|0;b=b|0;c=c|0;var d=Q(0),e=Q(0),f=Q(0),g=Q(0);d=N[b+24>>2];e=N[c+4>>2];f=N[b+20>>2];g=N[c>>2];N[a+4>>2]=Q(d*e)-Q(f*g);N[a>>2]=Q(d*g)+Q(f*e)}function Ve(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=Q(f);var g=0;g=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){g=J[g+J[b>>2]>>2]}return Q(Q(Na[g|0](b,c,d,e,f)))}function Mc(a,b,c,d){var e=0,f=0;e=J[a+4>>2];f=J[a>>2];a=0;a:{if(!c){break a}a=e>>8;if(!(e&1)){break a}a=J[a+J[c>>2]>>2]}Na[J[J[f>>2]+28>>2]](f,b,a+c|0,e&2?d:2)}function kc(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;var g=0;g=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){g=J[g+J[b>>2]>>2]}return Na[g|0](b,c,d,e,f)|0}function Ri(a,b){a=a|0;b=b|0;var c=0,d=0;c=b;d=a- -64|0;b=J[a+48>>2];a=J[a+52>>2];Vd(c,d,J[b+8>>2]+12|0,N[J[b+12>>2]+8>>2],J[a+8>>2]+12|0,N[J[a+12>>2]+8>>2])}function vb(a){var b=0,c=0;b=a*a;c=b*a;return Q(c*(b*b)*(b*2718311493989822e-21+-.00019839334836096632)+(c*(b*.008333329385889463+-.16666666641626524)+a))}function ug(a,b){a=a|0;b=b|0;N[a+68>>2]=N[a+68>>2]-N[b>>2];N[a+72>>2]=N[a+72>>2]-N[b+4>>2];N[a+76>>2]=N[a+76>>2]-N[b>>2];N[a+80>>2]=N[a+80>>2]-N[b+4>>2]}function Vk(a,b,c,d,e,f){a=a|0;b=b|0;c=Q(c);d=Q(d);e=e|0;f=Q(f);var g=0;g=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){g=J[g+J[b>>2]>>2]}Na[g|0](b,c,d,e,f)}function Xe(a,b,c){a=a|0;b=b|0;c=c|0;var d=0;d=La-16|0;La=d;Na[a|0](d+8|0,b,c);a=Xa(8);b=J[d+12>>2];J[a>>2]=J[d+8>>2];J[a+4>>2]=b;La=d+16|0;return a|0}function Le(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=Q(d);e=e|0;f=f|0;var g=0;g=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){g=J[g+J[b>>2]>>2]}Na[g|0](b,c,d,e,f)}function Ae(a,b){a=a|0;b=b|0;var c=0;if(!(!(N[b+8>>2]<=N[a+8>>2])|(!(N[a>>2]<=N[b>>2])|!(N[a+4>>2]<=N[b+4>>2])))){c=N[b+12>>2]<=N[a+12>>2]}return c|0}function ff(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;if(gb(a,J[b+8>>2],f)){oc(b,c,d,e);return}a=J[a+8>>2];Na[J[J[a>>2]+20>>2]](a,b,c,d,e,f)}function Hk(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0;f=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){f=J[f+J[b>>2]>>2]}return Na[f|0](b,c,d,e)|0}function Pe(a){a=a|0;var b=0;b=Xa(24);H[b+4|0]=0;J[b+8>>2]=J[a>>2];J[a>>2]=0;a=b+16|0;J[a>>2]=0;J[a+4>>2]=0;J[b>>2]=19996;J[b+12>>2]=a;return b|0}function Pk(a,b){a=a|0;b=b|0;var c=0;c=J[a>>2];a=Xa(6);b=b+c|0;c=L[b>>1]|L[b+2>>1]<<16;I[a>>1]=c;I[a+2>>1]=c>>>16;I[a+4>>1]=L[b+4>>1];return a|0}function wb(a){var b=0;a=a*a;b=a*a;return Q(a*b*(a*2439044879627741e-20+-.001388676377460993)+(b*.04166662332373906+(a*-.499999997251031+1)))}function Zd(a,b,c){a=a|0;b=b|0;c=c|0;var d=0;d=La-16|0;La=d;Na[J[a>>2]](d+12|0,b,c);ya(J[d+12>>2]);a=J[d+12>>2];ga(a|0);La=d+16|0;return a|0}function Og(){var a=0;a=Xa(32);J[a>>2]=0;J[a+4>>2]=0;J[a+24>>2]=0;J[a+28>>2]=0;J[a+16>>2]=0;J[a+20>>2]=0;J[a+8>>2]=0;J[a+12>>2]=0;return a|0}function dl(a,b,c,d,e){a=a|0;b=b|0;c=Q(c);d=d|0;e=e|0;var f=0;f=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){f=J[f+J[b>>2]>>2]}Na[f|0](b,c,d,e)}function Me(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=Q(d);e=e|0;var f=0;f=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){f=J[f+J[b>>2]>>2]}Na[f|0](b,c,d,e)}function uk(a,b,c,d){a=a|0;b=b|0;c=c|0;d=Q(d);var e=0;e=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){e=J[e+J[b>>2]>>2]}return Na[e|0](b,c,d)|0}function el(a,b){a=a|0;b=b|0;var c=0,d=0;c=La-16|0;La=c;d=J[b+4>>2];J[c+8>>2]=J[b>>2];J[c+12>>2]=d;a=Na[a|0](c+8|0)|0;La=c+16|0;return a|0}function Uj(a,b){a=a|0;b=b|0;var c=0;c=L[a+4>>1];if(b){I[a+4>>1]=c|4;return}b=c&65531;I[a+4>>1]=b;if(J[a>>2]){J[a+144>>2]=0;I[a+4>>1]=b|2}}function Bb(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0;f=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){f=J[f+J[b>>2]>>2]}Na[f|0](b,c,d,e)}function Yb(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0;e=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){e=J[e+J[b>>2]>>2]}return Na[e|0](b,c,d)|0}function nc(a,b,c,d,e,f){var g=0,h=0;g=J[a+4>>2];h=g>>8;a=J[a>>2];if(g&1){h=J[J[d>>2]+h>>2]}Na[J[J[a>>2]+20>>2]](a,b,c,d+h|0,g&2?e:2,f)}function dj(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0;e=La-16|0;La=e;a=J[a>>2];J[e+12>>2]=d;a=Na[a|0](b,c,e+12|0)|0;La=e+16|0;return a|0}function Wb(a,b,c){a=a|0;b=b|0;c=Q(c);var d=0;d=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){d=J[d+J[b>>2]>>2]}return Q(Q(Na[d|0](b,c)))}function bc(a,b,c,d,e){var f=0,g=0;f=J[a+4>>2];g=f>>8;a=J[a>>2];if(f&1){g=J[J[c>>2]+g>>2]}Na[J[J[a>>2]+24>>2]](a,b,c+g|0,f&2?d:2,e)}function zh(a,b){a=a|0;b=b|0;var c=0;if(K[a+38|0]!=(b|0)){c=J[a+8>>2];if(J[c>>2]){J[c+144>>2]=0;I[c+4>>1]=L[c+4>>1]|2}H[a+38|0]=b}}function Xa(a){var b=0;a=a>>>0<=1?1:a;a:{while(1){b=fb(a);if(b){break a}b=J[6639];if(b){Na[b|0]();continue}break}ma();B()}return b}function Bc(a,b,c,d){a=a|0;b=b|0;c=Q(c);d=Q(d);var e=0;e=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){e=J[e+J[b>>2]>>2]}Na[e|0](b,c,d)}function wg(a,b,c){a=a|0;b=b|0;c=Q(c);var d=Q(0),e=Q(0);e=N[b+140>>2];d=N[b+116>>2];N[a>>2]=Q(d*N[b+136>>2])*c;N[a+4>>2]=Q(d*e)*c}function vh(a,b,c){a=a|0;b=b|0;c=Q(c);var d=Q(0),e=Q(0);e=N[b+244>>2];d=N[b+156>>2];N[a>>2]=Q(d*N[b+240>>2])*c;N[a+4>>2]=Q(d*e)*c}function kk(a,b,c,d){a=a|0;b=b|0;c=Q(c);d=d|0;var e=0;e=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){e=J[e+J[b>>2]>>2]}Na[e|0](b,c,d)}function Xk(){var a=0;a=Xa(152);J[a+148>>2]=0;J[a+4>>2]=2;J[a+8>>2]=1008981770;J[a>>2]=12028;J[a+12>>2]=0;J[a+16>>2]=0;return a|0}function Xb(a,b,c,d){a=a|0;b=b|0;c=c|0;d=Q(d);var e=0;e=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){e=J[e+J[b>>2]>>2]}Na[e|0](b,c,d)}function Fe(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0);c=N[b+12>>2];d=N[b+4>>2];N[a>>2]=Q(N[b>>2]+N[b+8>>2])*Q(.5);N[a+4>>2]=Q(d+c)*Q(.5)}function Ee(a,b){a=a|0;b=b|0;var c=Q(0),d=Q(0);c=N[b+12>>2];d=N[b+4>>2];N[a>>2]=Q(N[b+8>>2]-N[b>>2])*Q(.5);N[a+4>>2]=Q(c-d)*Q(.5)}function cd(a){Eb(J[a>>2],J[a+20>>2]);Eb(J[a>>2],J[a+24>>2]);Eb(J[a>>2],J[a+16>>2]);Eb(J[a>>2],J[a+12>>2]);Eb(J[a>>2],J[a+8>>2])}function _b(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0;e=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){e=J[e+J[b>>2]>>2]}Na[e|0](b,c,d)}function Je(a){a=a|0;var b=0;b=Xa(16);J[b+4>>2]=0;J[b>>2]=12160;H[b+8|0]=0;J[b+12>>2]=J[a>>2];J[a>>2]=0;J[b>>2]=20372;return b|0}function yb(a,b,c){a=a|0;b=b|0;c=c|0;var d=0;d=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){d=J[d+J[b>>2]>>2]}return Na[d|0](b,c)|0}function of(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;if(gb(a,J[b+8>>2],0)){pc(b,c,d);return}a=J[a+8>>2];Na[J[J[a>>2]+28>>2]](a,b,c,d)}function fk(a){a=a|0;var b=Q(0),c=Q(0);b=N[a+28>>2];c=Q(b*b);b=N[a+32>>2];return Q(Q(Q(N[a+116>>2]*Q(c+Q(b*b)))+N[a+124>>2]))}function ub(a,b){a=a|0;b=b|0;var c=0;c=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){c=J[c+J[b>>2]>>2]}return Q(Q(Na[c|0](b)))}function Th(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;b=eb(e,148);f=Gb(b,a,0,c,0),g=12212,J[f>>2]=g;return b|0}function Qk(a,b,c){a=a|0;b=b|0;c=c|0;a=J[a>>2]+b|0;b=L[c>>1]|L[c+2>>1]<<16;I[a>>1]=b;I[a+2>>1]=b>>>16;I[a+4>>1]=L[c+4>>1]}function Qh(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;e=eb(e,148);f=Gb(e,a,b,c,d),g=12264,J[f>>2]=g;return e|0}function Qg(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;b=eb(e,148);f=Gb(b,a,0,c,0),g=13124,J[f>>2]=g;return b|0}function Oh(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;e=eb(e,148);f=Gb(e,a,b,c,d),g=12324,J[f>>2]=g;return e|0}function Ng(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;b=eb(e,148);f=Gb(b,a,0,c,0),g=13184,J[f>>2]=g;return b|0}function Fh(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;b=eb(e,148);f=Gb(b,a,0,c,0),g=12544,J[f>>2]=g;return b|0}function Dh(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;var f=0,g=0;b=eb(e,148);f=Gb(b,a,0,c,0),g=12604,J[f>>2]=g;return b|0}function $b(a,b){a=a|0;b=b|0;var c=0;c=La-16|0;La=c;J[c+12>>2]=b;a=Na[a|0](c+12|0)|0;ga(J[c+12>>2]);La=c+16|0;return a|0}function zb(a,b,c){a=a|0;b=b|0;c=Q(c);var d=0;d=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){d=J[d+J[b>>2]>>2]}Na[d|0](b,c)}function Ik(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;var e=0;e=J[a+12>>2];return Na[J[J[e>>2]+20>>2]](e,b,c,J[a+8>>2]+12|0,d)|0}function db(a,b,c){a=a|0;b=b|0;c=c|0;var d=0;d=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){d=J[d+J[b>>2]>>2]}Na[d|0](b,c)}function cb(a,b){a=a|0;b=b|0;var c=0;c=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){c=J[c+J[b>>2]>>2]}return Na[c|0](b)|0}function Ih(a,b,c){a=a|0;b=b|0;c=Q(c);var d=Q(0);d=N[b+116>>2];c=Q(N[b+100>>2]*c);N[a+4>>2]=c*N[b+120>>2];N[a>>2]=c*d}function ag(a,b,c){a=a|0;b=b|0;c=Q(c);var d=Q(0);d=N[b+104>>2];c=Q(N[b+92>>2]*c);N[a+4>>2]=c*N[b+108>>2];N[a>>2]=c*d}function Ak(a,b){a=a|0;b=b|0;if(!(J[a+28>>2]>(b|0)&(b|0)>=0)){Aa(1444,3377,346,5658);B()}return J[a+24>>2]+P(b,28)|0}function pb(a,b){a=a|0;b=b|0;var c=0;c=J[a>>2];a=Xa(8);b=b+c|0;c=J[b+4>>2];J[a>>2]=J[b>>2];J[a+4>>2]=c;return a|0}function Uh(a,b){a=a|0;b=b|0;var c=0;c=L[a+4>>1];if(!(!(c&16)^b)){J[a+72>>2]=0;I[a+4>>1]=c&65519|(b?16:0);Sb(a)}}function Ye(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=a,e=na((H[b+11|0]<0?J[b>>2]:b)|0,19436,J[c>>2])|0,J[d>>2]=e}function Te(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=a,e=na((H[b+11|0]<0?J[b>>2]:b)|0,19672,J[c>>2])|0,J[d>>2]=e}function Ne(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=a,e=na((H[b+11|0]<0?J[b>>2]:b)|0,19904,J[c>>2])|0,J[d>>2]=e}function Ie(a,b,c){a=a|0;b=b|0;c=c|0;var d=0,e=0;d=a,e=na((H[b+11|0]<0?J[b>>2]:b)|0,20304,J[c>>2])|0,J[d>>2]=e}function Ib(a,b,c){if(c){if((c|0)>=641){ab(b);return}a=(K[c+23924|0]<<2)+a|0;J[b>>2]=J[a+12>>2];J[a+12>>2]=b}}function tb(a,b){a=a|0;b=b|0;var c=0;c=J[a>>2];a=J[a+4>>2];b=(a>>1)+b|0;if(a&1){c=J[c+J[b>>2]>>2]}Na[c|0](b)}function ok(a,b){a=a|0;b=Q(b);if(J[a>>2]){if(Q(b*b)>Q(0)){J[a+144>>2]=0;I[a+4>>1]=L[a+4>>1]|2}N[a+72>>2]=b}}function Yk(){var a=0;a=Xa(20);J[a+4>>2]=0;J[a+8>>2]=0;J[a>>2]=11892;J[a+12>>2]=0;J[a+16>>2]=0;return a|0}function Zi(a,b,c){a=a|0;b=b|0;c=c|0;a=J[a>>2]+(b<<3)|0;b=J[c+4>>2];J[a>>2]=J[c>>2];J[a+4>>2]=b;return 1}function oj(a){a=a|0;var b=Q(0),c=Q(0);b=N[J[a+48>>2]+20>>2];c=N[J[a+52>>2]+20>>2];N[a+140>>2]=b>c?b:c}function Af(a){a=a|0;var b=0,c=0;a=J[a+4>>2];b=Xc(a)+1|0;c=fb(b);if(c){a=rb(c,a,b)}else{a=0}return a|0}function mf(){var a=0;a=Xa(20);J[a>>2]=0;J[a+4>>2]=0;J[a+16>>2]=0;J[a+8>>2]=0;J[a+12>>2]=0;return a|0}function Ze(a){a=a|0;var b=0;b=Xa(12);H[b+4|0]=0;J[b+8>>2]=J[a>>2];J[a>>2]=0;J[b>>2]=19504;return b|0}function Ue(a){a=a|0;var b=0;b=Xa(12);H[b+4|0]=0;J[b+8>>2]=J[a>>2];J[a>>2]=0;J[b>>2]=19740;return b|0}function Lj(){var a=0;a=Xa(20);J[a>>2]=0;J[a+4>>2]=0;H[a+16|0]=0;J[a+8>>2]=0;J[a+12>>2]=0;return a|0}function Jk(a,b){a=a|0;b=b|0;var c=0;c=J[a+12>>2];return Na[J[J[c>>2]+16>>2]](c,J[a+8>>2]+12|0,b)|0}function Wf(a,b,c){a=a|0;b=b|0;c=Q(c);var d=Q(0);d=N[b+108>>2];N[a>>2]=N[b+104>>2]*c;N[a+4>>2]=d*c}function De(a){a=a|0;var b=Q(0);b=Q(Q(N[a+8>>2]-N[a>>2])+Q(N[a+12>>2]-N[a+4>>2]));return Q(Q(b+b))}function Ug(a,b,c){a=a|0;b=b|0;c=Q(c);var d=Q(0);d=N[b+100>>2];N[a>>2]=N[b+96>>2]*c;N[a+4>>2]=d*c}function zd(a,b,c){a=a|0;b=b|0;c=Q(c);var d=Q(0);d=N[b+88>>2];N[a>>2]=N[b+84>>2]*c;N[a+4>>2]=d*c}function jh(a,b,c){a=a|0;b=b|0;c=Q(c);var d=Q(0);d=N[b+84>>2];N[a>>2]=N[b+80>>2]*c;N[a+4>>2]=d*c}function zf(){var a=0;a=J[6200];if(a){while(1){Na[J[a>>2]]();a=J[a+4>>2];if(a){continue}break}}}function df(a,b,c,d,e,f){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;f=f|0;if(gb(a,J[b+8>>2],f)){oc(b,c,d,e)}}function Eh(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;Id(b,J[J[a+48>>2]+12>>2],c,J[J[a+52>>2]+12>>2],d)}function Ch(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;Hd(b,J[J[a+48>>2]+12>>2],c,J[J[a+52>>2]+12>>2],d)}function lh(a,b){a=a|0;b=b|0;var c=0;b=J[b+48>>2];c=J[b+16>>2];J[a>>2]=J[b+12>>2];J[a+4>>2]=c}function kh(a,b){a=a|0;b=b|0;var c=0;b=J[b+52>>2];c=J[b+16>>2];J[a>>2]=J[b+12>>2];J[a+4>>2]=c}function qb(a,b,c){a=a|0;b=b|0;c=c|0;a=J[a>>2]+b|0;b=J[c+4>>2];J[a>>2]=J[c>>2];J[a+4>>2]=b}function Ya(a,b){var c=0;c=La-16|0;La=c;if(J[6142]){J[c+12>>2]=b;Rc(J[6142],a,b)}La=c+16|0}function Sg(a,b){a=a|0;b=b|0;N[a+76>>2]=N[a+76>>2]-N[b>>2];N[a+80>>2]=N[a+80>>2]-N[b+4>>2]}function og(a){a=a|0;return Q(Q(Q(N[J[a+52>>2]+56>>2]-N[J[a+48>>2]+56>>2])-N[a+120>>2]))}function bl(a,b){a=a|0;b=b|0;var c=0;c=J[b+4>>2];J[a+102964>>2]=J[b>>2];J[a+102968>>2]=c}function al(a,b){a=a|0;b=b|0;var c=0;c=J[b+102968>>2];J[a>>2]=J[b+102964>>2];J[a+4>>2]=c}function Jc(){var a=0;a=Xa(16);J[a>>2]=0;J[a+4>>2]=0;J[a+8>>2]=0;J[a+12>>2]=0;return a|0}function Gk(a,b){a=a|0;b=b|0;var c=0;c=J[a+12>>2];Na[J[J[c>>2]+28>>2]](c,b,N[a>>2])}function Wg(a,b){a=a|0;b=b|0;var c=0;c=J[b+80>>2];J[a>>2]=J[b+76>>2];J[a+4>>2]=c}function cf(a,b,c,d,e){a=a|0;b=b|0;c=c|0;d=d|0;e=e|0;return Na[a|0](b,c,d,e)|0}function bf(){var a=0;a=Xa(6);I[a+4>>1]=0;I[a>>1]=1;I[a+2>>1]=65535;return a|0}function Hj(a){a=a|0;N[a+136>>2]=Y(Q(N[J[a+48>>2]+16>>2]*N[J[a+52>>2]+16>>2]))}function pf(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;if(gb(a,J[b+8>>2],0)){pc(b,c,d)}}function ml(a){var b=0;b=a&31;a=0-a&31;return(-1>>>b&-2)<>>a} +function ef(){var a=0;a=Xa(12);J[a>>2]=0;J[a+4>>2]=0;J[a+8>>2]=0;return a|0}function ae(a){a=a|0;var b=0;if(a){b=J[a>>2];if(b){J[a+4>>2]=b;ab(b)}ab(a)}}function Rg(a){a=a|0;a=La-16|0;La=a;J[a+12>>2]=0;Rc(23664,9289,0);La=a+16|0}function $d(){var a=0;a=Xa(12);J[a+8>>2]=0;J[a>>2]=0;J[a+4>>2]=0;return a|0}function ej(a,b,c){a=a|0;b=b|0;c=c|0;J[J[a>>2]+(b<<2)>>2]=J[c>>2];return 1}function ng(a){a=a|0;return Q(Q(N[J[a+52>>2]+72>>2]-N[J[a+48>>2]+72>>2]))}function Yi(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;return Na[J[a>>2]](b,c,d)|0}function uh(a,b){a=a|0;b=Q(b);return Q(Q(Q(N[a+156>>2]*N[a+256>>2])*b))}function pg(a,b){a=a|0;b=Q(b);return Q(Q(Q(N[a+96>>2]+N[a+100>>2])*b))}function hd(a){Eb(J[a+32>>2],J[a+40>>2]);Eb(J[a+32>>2],J[a+36>>2])}function Hb(a,b){a=a|0;b=b|0;Na[J[J[a>>2]+4>>2]](a)|0;Ib(b,a,148)}function Gc(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;Na[J[a>>2]](b,c,d)}function ji(a,b,c){a=a|0;b=b|0;c=c|0;return Q(Q(Na[a|0](b,c)))}function Wj(a,b){a=a|0;b=b|0;I[a+4>>1]=L[a+4>>1]&65527|(b?8:0)}function yf(a,b,c,d){a=a|0;b=b|0;c=Q(c);d=Q(d);Na[a|0](b,c,d)}function rg(a,b){a=a|0;b=b|0;return Q(N[((b<<2)+a|0)+24>>2])}function Bg(a,b){a=a|0;b=b|0;return Q(N[((b<<3)+a|0)+12>>2])}function il(a,b){a=a|0;b=b|0;J[a+4>>2]=J[a+4>>2]&-5|(b?4:0)}function ic(a,b){if(b){ic(a,J[b>>2]);ic(a,J[b+4>>2]);ab(b)}}function Yf(a,b){a=a|0;b=b|0;return Q(N[((b<<2)+a|0)+8>>2])}function Fg(a,b){a=a|0;b=b|0;return Q(N[((b<<3)+a|0)+8>>2])}function rf(a,b,c,d){a=a|0;b=b|0;c=c|0;d=d|0;Ma=0;return 0}function ii(a,b,c){a=a|0;b=b|0;c=c|0;return Na[a|0](b,c)|0}function ld(a,b){a=a|0;b=Q(b);return Q(Q(N[a+112>>2]*b))}function jd(a,b){a=a|0;b=Q(b);return Q(Q(N[a+104>>2]*b))}function Zk(a,b){a=a|0;b=b|0;return Q(Q(Na[J[a>>2]](b)))}function Hg(a,b){a=a|0;b=Q(b);return Q(Q(N[a+108>>2]*b))}function yd(a,b){a=a|0;b=Q(b);return Q(Q(N[a+92>>2]*b))}function mb(a,b,c){a=a|0;b=b|0;c=Q(c);N[J[a>>2]+b>>2]=c}function ih(a,b){a=a|0;b=Q(b);return Q(Q(N[a+88>>2]*b))}function ai(a,b){a=a|0;b=b|0;J[a+4>>2]=J[a+4>>2]&(b^-1)}function Nc(a,b,c){a=a|0;b=b|0;c=c|0;return gb(a,b,0)|0}function lb(a,b){a=a|0;b=b|0;return Q(N[J[a>>2]+b>>2])}function _k(a,b,c){a=a|0;b=b|0;c=Q(c);Na[J[a>>2]](b,c)}function Ic(a,b,c){a=a|0;b=b|0;c=c|0;I[J[a>>2]+b>>1]=c}function Ec(a,b,c){a=a|0;b=b|0;c=c|0;J[J[a>>2]+b>>2]=c}function ud(a,b){a=a|0;b=b|0;return Q(N[(b<<2)+a>>2])}function Zb(a,b,c){a=a|0;b=b|0;c=c|0;Na[J[a>>2]](b,c)}function Ob(a,b,c){a=a|0;b=b|0;c=c|0;H[J[a>>2]+b|0]=c}function zk(a,b){a=a|0;b=b|0;return Q(Q(Na[a|0](b)))}function we(a,b){a=a|0;b=b|0;return Na[J[a>>2]](b)|0}function rj(a){a=a|0;if(a){Na[J[J[a>>2]+32>>2]](a)}}function jl(a){if(a){return 31-S(a-1^a)|0}return 32}function af(a,b){a=a|0;b=b|0;return L[J[a>>2]+b>>1]}function _e(a,b){a=a|0;b=b|0;return I[J[a>>2]+b>>1]}function Dc(a,b){a=a|0;b=b|0;return J[J[a>>2]+b>>2]}function bi(a,b){a=a|0;b=b|0;J[a+4>>2]=J[a+4>>2]|b}function Rk(a,b,c){a=a|0;b=b|0;c=Q(c);Na[a|0](b,c)}function Nb(a,b){a=a|0;b=b|0;return K[J[a>>2]+b|0]}function Cb(a){a=a|0;if(a){Na[J[J[a>>2]+4>>2]](a)}}function Tg(a,b){a=a|0;b=Q(b);return Q(Q(b*Q(0)))}function Hc(a,b,c){a=a|0;b=b|0;c=c|0;Na[a|0](b,c)}function gj(a){a=a|0;return J[a+4>>2]-J[a>>2]>>2}function Fc(a,b){a=a|0;b=b|0;return Na[a|0](b)|0}function $i(a){a=a|0;return J[a+4>>2]-J[a>>2]>>3}function Kc(a,b,c,d){Ca(a|0,b|0,8,0,c|0,-1,d|0)}function $h(a,b){a=a|0;b=b|0;return P(b,20)+a|0}function Rj(a){a=a|0;return(K[a+4|0]&32)>>>5|0}function Pj(a){a=a|0;return(K[a+4|0]&16)>>>4|0}function Nk(a){a=a|0;return J[J[a+12>>2]+4>>2]}function ye(a){a=a|0;return(K[a+4|0]&2)>>>1|0}function qi(a,b,c){a=a|0;b=b|0;c=c|0;return 0}function Vj(a){a=a|0;return(K[a+4|0]&8)>>>3|0}function Tj(a){a=a|0;return(K[a+4|0]&4)>>>2|0}function Mf(a,b){a=a|0;b=b|0;J[a+102940>>2]=b}function Lf(a,b){a=a|0;b=b|0;J[a+102980>>2]=b}function uc(a,b){a=a|0;b=Q(b);return Q(Q(0))}function tf(a){a=a|0;return qa(J[a+60>>2])|0}function te(a,b){a=a|0;b=Q(b);N[a+144>>2]=b}function qe(a,b){a=a|0;b=Q(b);N[a+136>>2]=b}function le(a,b){a=a|0;b=Q(b);N[a+104>>2]=b}function hb(a){a=a|0;return J[J[a>>2]-4>>2]}function ge(a,b){a=a|0;b=Q(b);N[a+140>>2]=b}function dh(a,b){a=a|0;b=Q(b);N[a+100>>2]=b}function ac(a,b){a=a|0;b=b|0;Na[J[a>>2]](b)}function Xj(a,b){a=a|0;b=Q(b);N[a+132>>2]=b}function Qf(a,b){a=a|0;b=Q(b);N[a+148>>2]=b}function zc(a){a=a|0;return Q(N[a+132>>2])}function wj(a){a=a|0;return Q(N[a+120>>2])}function vj(a){a=a|0;return Q(N[a+112>>2])}function uj(a){a=a|0;return Q(N[a+108>>2])}function re(a){a=a|0;return Q(N[a+144>>2])}function rd(a){a=a|0;return Q(N[a+124>>2])}function qd(a){a=a|0;return Q(N[a+128>>2])}function ke(a){a=a|0;return Q(N[a+104>>2])}function je(a,b){a=a|0;b=Q(b);N[a+68>>2]=b}function jc(a){a=a|0;return Q(N[a+136>>2])}function hh(a,b){a=a|0;b=Q(b);N[a+92>>2]=b}function he(a,b){a=a|0;b=Q(b);N[a+72>>2]=b}function gk(a){a=a|0;return Q(N[a+116>>2])}function eh(a,b){a=a|0;b=Q(b);N[a+96>>2]=b}function ee(a){a=a|0;return Q(N[a+100>>2])}function de(a){a=a|0;return Q(N[a+140>>2])}function ce(a,b){a=a|0;b=Q(b);N[a+84>>2]=b}function Zg(a,b){a=a|0;b=Q(b);N[a+88>>2]=b}function Pf(a){a=a|0;return Q(N[a+148>>2])}function Dk(a,b){a=a|0;b=Q(b);N[a+16>>2]=b}function Bk(a,b){a=a|0;b=Q(b);N[a+20>>2]=b}function wd(a){a=a|0;return Q(N[a+84>>2])}function vd(a){a=a|0;return Q(N[a+88>>2])}function sk(a){a=a|0;return Q(N[a+56>>2])}function ie(a){a=a|0;return Q(N[a+68>>2])}function gh(a){a=a|0;return Q(N[a+92>>2])}function fh(a){a=a|0;return Q(N[a+12>>2])}function cl(a){a=a|0;return K[a+102972|0]}function be(a){a=a|0;return Q(N[a+96>>2])}function ah(a){a=a|0;return Q(N[a+76>>2])}function Zh(a){a=a|0;return Q(N[a+48>>2])}function Sh(a){a=a|0;return Q(N[a+52>>2])}function Mh(a){a=a|0;return Q(N[a+40>>2])}function Jj(a,b){a=a|0;b=b|0;J[a+12>>2]=b}function Hh(a){a=a|0;return Q(N[a+44>>2])}function Ek(a){a=a|0;return Q(N[a+16>>2])}function Ck(a){a=a|0;return Q(N[a+20>>2])}function Ac(a){a=a|0;return Q(N[a+72>>2])}function $k(a,b){a=a|0;b=Q(b);N[a+8>>2]=b}function xd(a){a=a|0;return Q(N[a+8>>2])}function ci(a,b){a=a|0;b=b|0;J[a+4>>2]=b}function Kj(a,b){a=a|0;b=b|0;J[a+8>>2]=b}function Ad(a){a=a|0;return Q(N[a+4>>2])}function nb(a){a=a|0;return Na[a|0]()|0}function Qj(a,b){a=a|0;b=b|0;Na[a|0](b)}function Oj(a){a=a|0;return J[a+100>>2]}function zi(a){a=a|0;return J[a+56>>2]}function ve(a){a=a|0;return J[a+12>>2]}function si(a){a=a|0;return J[a+60>>2]}function rc(a){a=a|0;return Q(N[a>>2])}function pd(a){a=a|0;return K[a+141|0]}function mg(a){a=a|0;return K[a+104|0]}function ig(a){a=a|0;return K[a+116|0]}function _d(a){a=a|0;return J[a+48>>2]}function Yd(a){a=a|0;return J[a+52>>2]}function Sk(a,b){a=a|0;b=b|0;J[a>>2]=b}function Of(a){a=a|0;return J[a+16>>2]}function Nj(a){a=a|0;return J[a+88>>2]}function Eg(a){a=a|0;return K[a+140|0]}function ue(a){a=a|0;return J[a+8>>2]}function qc(a,b){a=a|0;b=b|0;return 1}function Mk(a){a=a|0;return K[a+38|0]}function Ij(a){a=a|0;return K[a+61|0]}function Cc(a){a=a|0;return J[a+4>>2]}function Xd(a){a=a|0;return a- -64|0}function Wd(a,b,c){a=a|0;b=b|0;c=c|0}function xe(a){a=a|0;return J[a>>2]}function se(a){a=a|0;return a+12|0}function rk(a){a=a|0;return a+44|0}function qk(a){a=a|0;return a+28|0}function ne(a){a=a|0;return a+80|0}function me(a){a=a|0;return a+88|0}function fe(a){a=a|0;return a+84|0}function Vb(a){a=a|0;return a+68|0}function Ub(a){a=a|0;return a+76|0}function Lk(a){a=a|0;return a+32|0}function yj(a){a=a|0;return 23056}function xk(a){a=a|0;return 20820}function vk(a){a=a|0;return 20796}function tj(a){a=a|0;return 23232}function qj(a){a=a|0;return 23372}function nj(a){a=a|0;return 23488}function lj(a){a=a|0;return 19048}function ib(a){a=a|0;if(a){ab(a)}}function gl(a){a=a|0;return 20704}function cj(a){a=a|0;return 19168}function Uk(a){a=a|0;return 21800}function Ok(a){a=a|0;return 21864}function Mj(a){a=a|0;return 20868}function He(a){a=a|0;return 20552}function Gj(a){a=a|0;return 22516}function Ej(a){a=a|0;return 22632}function Cj(a){a=a|0;return 22760}function Aj(a){a=a|0;return 22888}function oh(a){a=a|0;Ya(9242,0)}function mc(a){a=a|0;H[a+4|0]=1}function Ke(a){a=a|0;H[a+8|0]=1}function $a(a){a=a|0;return a|0}function xc(a){a=a|0;return 1}function sf(a){a=a|0;return 0}function Yc(){return Xa(16)|0}function yc(a,b){a=a|0;b=b|0}function bd(){return Xa(8)|0}function xf(){return 24816}function bb(a){a=a|0;ab(a)}function Mb(a){a=a|0;B()}function Tb(){ma();B()}function ob(a){a=a|0} +// EMSCRIPTEN_END_FUNCS +e=K;p(q);var Na=c([null,ji,ud,yf,$e,Xe,Oe,Hc,il,Fc,ye,Rk,te,zk,re,qe,jc,Qj,Hj,ge,de,oj,Fc,_d,Yd,Hc,Ri,Xd,zi,si,ii,$h,Zh,Sh,Mh,Hh,rc,Ad,xd,fh,nb,Og,Fg,Bg,rg,rc,Ad,ib,ud,Yf,Fc,Of,ib,bd,mb,lb,ib,bd,mb,lb,ib,Yc,qb,pb,qb,pb,ib,Yc,mb,lb,ib,mf,qb,pb,mb,lb,ib,ef,qb,pb,mb,lb,ib,Jc,mb,lb,qb,pb,ib,bf,Ic,af,Ic,_e,Cb,hb,yb,Cb,$a,$a,hb,mc,ac,Ze,$b,Ye,We,Cb,hb,Ve,Cb,$a,$a,hb,mc,ac,Ue,$b,Te,Cb,hb,db,_b,Se,db,Re,Qe,yb,Cb,$a,$a,hb,mc,ac,Pe,$b,Ne,Cb,hb,ci,db,Cc,cb,bi,ai,Bb,Me,Le,Bb,db,Cb,$a,$a,hb,Ke,ac,Je,$b,Ie,ib,He,Jc,nb,Ge,cb,Fe,lc,Ee,De,ub,Ce,Zb,Be,Gc,Ae,yb,ti,Yb,qb,pb,hl,gl,fl,el,Mf,db,Lf,db,Df,tb,Kf,yb,Jf,db,If,yb,$c,db,Gf,dl,Ff,_b,Ef,Bb,Hf,db,cl,cb,bl,db,al,lc,Cf,ob,hb,Ec,Dc,mb,lb,Cc,cb,cb,Yb,kc,Bb,Xb,$k,_k,xd,Zk,ob,$a,$a,hb,Yk,nb,qb,pb,yb,cb,Yb,kc,Bb,Xb,ob,$a,$a,hb,yb,cb,Yb,kc,Bb,Xb,ob,$a,$a,hb,Xk,nb,yb,cb,Wk,Gc,Yb,kc,Bb,Xb,di,cb,li,Bc,ki,Vk,ob,Uk,Tk,nb,Sk,Zb,xe,we,mb,lb,Ob,Nb,Qk,Pk,ib,Ok,Nk,cb,ve,cb,zh,db,Mk,cb,Bh,db,Lk,Kk,Ah,tb,ue,cb,Jk,yb,Ik,Hk,Gk,db,Fk,zb,rc,ub,Ek,Dk,Ck,Bk,Ak,yk,Dd,db,ob,xk,wk,nb,Ec,Dc,qb,pb,mb,lb,Ob,Nb,ob,vk,Ld,yb,Yh,uk,Xh,db,Wh,Xb,se,tk,se,Ab,sk,ub,rk,qk,pk,db,Xd,ok,zb,Ac,nk,Bb,mk,_b,lk,kk,jk,ik,hk,gk,fk,ek,db,dk,Zb,Sb,tb,ck,bk,ak,$j,_j,Zj,Yj,zc,Xj,jc,qe,de,ge,_h,db,xe,cb,Wj,db,Vj,cb,Uj,Tj,Sj,ye,Vh,Rj,Uh,Pj,Oj,cb,Nj,cb,Kd,ib,Mj,Lj,nb,Ec,Dc,Kj,Zb,ue,we,Jj,ve,Ob,Nb,ob,hb,Cc,cb,_d,cb,Yd,lc,pe,Wb,Ij,cb,tb,ib,$a,$a,Gj,Fj,nb,qb,pb,mb,lb,ob,$a,$a,hb,ne,Ab,me,le,zb,ke,ub,je,ie,he,Ac,tb,ib,$a,$a,Ej,Dj,nb,qb,pb,mb,lb,ob,$a,$a,hb,ch,db,Vb,Ab,bh,zb,ah,ub,hh,gh,eh,be,dh,ee,tb,ib,$a,$a,Cj,Bj,nb,qb,pb,mb,lb,ob,$a,$a,hb,_g,db,Ub,Ab,le,zb,ke,ub,ce,wd,Zg,vd,tb,ib,$a,$a,Aj,zj,nb,qb,pb,mb,lb,Ob,Nb,ob,$a,$a,hb,Vb,Ab,Ub,fe,ee,ub,sd,Gg,Eg,cb,Dg,db,rd,qd,Cg,Bc,pd,od,nd,zb,jc,md,zc,ld,Wb,tb,ib,$a,$a,yj,xj,nb,qb,pb,mb,lb,Ob,Nb,ob,$a,$a,hb,Vb,Ab,Ub,wj,ub,og,ng,ig,cb,hg,db,rd,qd,gg,Bc,mg,lg,kg,zb,vj,jg,uj,yd,Wb,tb,ib,$a,$a,tj,sj,nb,qb,pb,mb,lb,rj,$a,$a,hb,Vb,Ab,Ub,pe,Wb,ce,zb,wd,ub,vd,tb,ib,$a,$a,qj,pj,nb,qb,pb,mb,lb,ob,$a,$a,hb,ne,Ab,me,be,ub,je,zb,ie,he,Ac,tb,ib,$a,$a,nj,mj,nb,qb,pb,Ob,Nb,mb,lb,ob,$a,$a,hb,Vb,Ab,Ub,fe,sd,ub,pd,cb,od,db,nd,zb,jc,md,zc,jd,Wb,te,re,Qf,Pf,tb,ae,lj,$d,nb,kj,jj,ij,hj,gj,cb,fj,Zd,ej,dj,ae,cj,$d,nb,bj,db,aj,_b,$i,cb,_i,Zd,Zi,Yi,oe,Xi,Wi,Vi,Mb,Tb,Ui,Ti,Si,Mb,Qi,Pi,Oi,Ni,Mi,Li,Ki,Ji,yc,yc,Wd,Wd,Ii,Hi,Gi,Fi,Ei,Di,Ci,Bi,Ai,Mb,$a,bb,yi,xc,xi,wi,vi,ui,bb,ri,xc,qi,pi,oi,ni,bb,mi,xc,hi,gi,fi,ei,$a,Mb,Rh,$a,bb,Ph,bb,Nh,bb,Qg,Hb,Th,Fh,Qh,Hb,Hb,Ng,Hb,Hb,Hb,Dh,Hb,Oh,Mb,$a,bb,Gd,Fd,Ih,uc,Gh,yc,ph,$a,bb,Lh,Kh,Jh,Eh,bb,Ch,bb,Cd,Bd,vh,uh,th,bb,yh,xh,wh,Qb,Pb,zd,yd,qh,bb,sh,rh,qc,oh,Mb,lh,kh,jh,ih,$g,bb,nh,mh,qc,Wg,Vg,Ug,Tg,Rg,Sg,bb,Yg,Xg,qc,Pg,bb,Mg,bb,Qb,Pb,Ig,Hg,Ag,kd,bb,Lg,Kg,Jg,Cd,Bd,wg,uc,vg,ug,bb,zg,yg,xg,Qb,Pb,zd,pg,fg,eg,bb,tg,sg,qg,Qb,Pb,ag,uc,$f,bb,dg,cg,bg,Gd,Fd,Wf,ld,Vf,bb,_f,Zf,Xf,Qb,Pb,Rf,jd,Nf,kd,bb,Uf,Tf,Sf,$a,bb,Bf,_c,wf,vf,uf,tf,Qc,Pc,sf,rf,$a,bb,ob,ob,Nc,bb,Nc,bb,qf,df,hf,pf,bb,ff,jf,of,bb,gf,kf,nf,bb,lf]);function Oa(){return G.byteLength/65536|0}function Ta(Ua){Ua=Ua|0;var Pa=Oa()|0;var Qa=Pa+Ua|0;if(Pa=65536,"INITIAL_MEMORY should be larger than STACK_SIZE, was "+INITIAL_MEMORY+"! (STACK_SIZE="+65536+")");if(Module["wasmMemory"]){wasmMemory=Module["wasmMemory"]}else{wasmMemory=new WebAssembly.Memory({"initial":INITIAL_MEMORY/65536,"maximum":2147483648/65536})}updateMemoryViews();INITIAL_MEMORY=wasmMemory.buffer.byteLength;var wasmTable;var __ATPRERUN__=[];var __ATINIT__=[];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 initRuntime(){runtimeInitialized=true;if(!Module["noFSInit"]&&!FS.init.initialized)FS.init();FS.ignorePermissions=false;TTY.init();callRuntimeCallbacks(__ATINIT__)}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)}function addOnInit(cb){__ATINIT__.unshift(cb)}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}var runDependencies=0;var runDependencyWatcher=null;var dependenciesFulfilled=null;function getUniqueRunDependency(id){return id}function addRunDependency(id){runDependencies++;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}}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()}}}function abort(what){if(Module["onAbort"]){Module["onAbort"](what)}what="Aborted("+what+")";err(what);ABORT=true;EXITSTATUS=1;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var dataURIPrefix="data:application/octet-stream;base64,";function isDataURI(filename){return filename.startsWith(dataURIPrefix)}var wasmBinaryFile;wasmBinaryFile="<<< WASM_BINARY_FILE >>>";if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile)}function getBinary(file){try{if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}var binary=tryParseAsDataURI(file);if(binary){return binary}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}catch(err){abort(err)}}function getBinaryPromise(binaryFile){if(!wasmBinary&&(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)){if(typeof fetch=="function"){return fetch(binaryFile,{credentials:"same-origin"}).then(response=>{if(!response["ok"]){throw"failed to load wasm binary file at '"+binaryFile+"'"}return response["arrayBuffer"]()}).catch(()=>getBinary(binaryFile))}}return Promise.resolve().then(()=>getBinary(binaryFile))}function instantiateArrayBuffer(binaryFile,imports,receiver){return getBinaryPromise(binaryFile).then(binary=>{return WebAssembly.instantiate(binary,imports)}).then(instance=>{return instance}).then(receiver,reason=>{err("failed to asynchronously prepare wasm: "+reason);abort(reason)})}function instantiateAsync(binary,binaryFile,imports,callback){if(!binary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(binaryFile)&&typeof fetch=="function"){return fetch(binaryFile,{credentials:"same-origin"}).then(response=>{var result=WebAssembly.instantiateStreaming(response,imports);return result.then(callback,function(reason){err("wasm streaming compile failed: "+reason);err("falling back to ArrayBuffer instantiation");return instantiateArrayBuffer(binaryFile,imports,callback)})})}else{return instantiateArrayBuffer(binaryFile,imports,callback)}}function createWasm(){var info={"a":wasmImports};function receiveInstance(instance,module){var exports=instance.exports;Module["asm"]=exports;wasmTable=Module["asm"]["Q"];addOnInit(Module["asm"]["P"]);removeRunDependency("wasm-instantiate");return exports}addRunDependency("wasm-instantiate");function receiveInstantiationResult(result){receiveInstance(result["instance"])}if(Module["instantiateWasm"]){try{return Module["instantiateWasm"](info,receiveInstance)}catch(e){err("Module.instantiateWasm callback failed with error: "+e);readyPromiseReject(e)}}instantiateAsync(wasmBinary,wasmBinaryFile,info,receiveInstantiationResult).catch(readyPromiseReject);return{}}var tempDouble;var tempI64;function callRuntimeCallbacks(callbacks){while(callbacks.length>0){callbacks.shift()(Module)}}function intArrayToString(array){var ret=[];for(var i=0;i255){chr&=255}ret.push(String.fromCharCode(chr))}return ret.join("")}var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf8"):undefined;function UTF8ArrayToString(heapOrArray,idx,maxBytesToRead){var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx>10,56320|ch&1023)}}return str}function UTF8ToString(ptr,maxBytesToRead){return ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):""}function ___assert_fail(condition,filename,line,func){abort(`Assertion failed: ${UTF8ToString(condition)}, at: `+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"])}function setErrNo(value){HEAP32[___errno_location()>>2]=value;return value}var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(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:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.substr(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname: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:path=>{if(path==="/")return"/";path=PATH.normalize(path);path=path.replace(/\/$/,"");var lastSlash=path.lastIndexOf("/");if(lastSlash===-1)return path;return path.substr(lastSlash+1)},join:function(){var paths=Array.prototype.slice.call(arguments);return PATH.normalize(paths.join("/"))},join2:(l,r)=>{return PATH.normalize(l+"/"+r)}};function initRandomFill(){if(typeof crypto=="object"&&typeof crypto["getRandomValues"]=="function"){return view=>crypto.getRandomValues(view)}else abort("initRandomDevice")}function randomFill(view){return(randomFill=initRandomFill())(view)}var PATH_FS={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){return""}resolvedPath=path+"/"+resolvedPath;resolvedAbsolute=PATH.isAbs(path)}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).substr(1);to=PATH_FS.resolve(to).substr(1);function trim(arr){var start=0;for(;start=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=55296&&c<=57343){len+=4;++i}else{len+=3}}return len}function stringToUTF8Array(str,heap,outIdx,maxBytesToWrite){if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}}heap[outIdx]=0;return outIdx-startIdx}function intArrayFromString(stringy,dontAddNull,length){var len=length>0?length:lengthBytesUTF8(stringy)+1;var u8array=new Array(len);var numBytesWritten=stringToUTF8Array(stringy,u8array,0,u8array.length);if(dontAddNull)u8array.length=numBytesWritten;return u8array}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(43)}stream.tty=tty;stream.seekable=false},close:function(stream){stream.tty.ops.fsync(stream.tty)},fsync:function(stream){stream.tty.ops.fsync(stream.tty)},read:function(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.get_char){throw new FS.ErrnoError(60)}var bytesRead=0;for(var i=0;i0){out(UTF8ArrayToString(tty.output,0));tty.output=[]}}},default_tty1_ops:{put_char:function(tty,val){if(val===null||val===10){err(UTF8ArrayToString(tty.output,0));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync:function(tty){if(tty.output&&tty.output.length>0){err(UTF8ArrayToString(tty.output,0));tty.output=[]}}}};function mmapAlloc(size){abort()}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(63)}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,msync:MEMFS.stream_ops.msync}},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;parent.timestamp=node.timestamp}return node},getFileDataAsTypedArray:function(node){if(!node.contents)return new Uint8Array(0);if(node.contents.subarray)return node.contents.subarray(0,node.usedBytes);return new Uint8Array(node.contents)},expandFileStorage:function(node,newCapacity){var prevCapacity=node.contents?node.contents.length:0;if(prevCapacity>=newCapacity)return;var CAPACITY_DOUBLING_MAX=1024*1024;newCapacity=Math.max(newCapacity,prevCapacity*(prevCapacity>>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)},resizeFileStorage:function(node,newSize){if(node.usedBytes==newSize)return;if(newSize==0){node.contents=null;node.usedBytes=0}else{var oldContents=node.contents;node.contents=new Uint8Array(newSize);if(oldContents){node.contents.set(oldContents.subarray(0,Math.min(newSize,node.usedBytes)))}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[44]},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(55)}}}delete old_node.parent.contents[old_node.name];old_node.parent.timestamp=Date.now();old_node.name=new_name;new_dir.contents[new_name]=old_node;new_dir.timestamp=old_node.parent.timestamp;old_node.parent=new_dir},unlink:function(parent,name){delete parent.contents[name];parent.timestamp=Date.now()},rmdir:function(parent,name){var node=FS.lookupNode(parent,name);for(var i in node.contents){throw new FS.ErrnoError(55)}delete parent.contents[name];parent.timestamp=Date.now()},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(28)}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);if(size>8&&contents.subarray){buffer.set(contents.subarray(position,position+size),offset)}else{for(var i=0;i0||position+length{assert(arrayBuffer,`Loading data file "${url}" failed (no arrayBuffer).`);onload(new Uint8Array(arrayBuffer));if(dep)removeRunDependency(dep)},event=>{if(onerror){onerror()}else{throw`Loading data file "${url}" failed.`}});if(dep)addRunDependency(dep)}var preloadPlugins=Module["preloadPlugins"]||[];function FS_handledByPreloadPlugin(byteArray,fullname,finish,onerror){if(typeof Browser!="undefined")Browser.init();var handled=false;preloadPlugins.forEach(function(plugin){if(handled)return;if(plugin["canHandle"](fullname)){plugin["handle"](byteArray,fullname,finish,onerror);handled=true}});return handled}function FS_createPreloadedFile(parent,name,url,canRead,canWrite,onload,onerror,dontCreateFile,canOwn,preFinish){var fullname=name?PATH_FS.resolve(PATH.join2(parent,name)):parent;var dep=getUniqueRunDependency(`cp ${fullname}`);function processData(byteArray){function finish(byteArray){if(preFinish)preFinish();if(!dontCreateFile){FS.createDataFile(parent,name,byteArray,canRead,canWrite,canOwn)}if(onload)onload();removeRunDependency(dep)}if(FS_handledByPreloadPlugin(byteArray,fullname,finish,()=>{if(onerror)onerror();removeRunDependency(dep)})){return}finish(byteArray)}addRunDependency(dep);if(typeof url=="string"){asyncLoad(url,byteArray=>processData(byteArray),onerror)}else{processData(url)}}function FS_modeStringToFlags(str){var flagModes={"r":0,"r+":2,"w":512|64|1,"w+":512|64|2,"a":1024|64|1,"a+":1024|64|2};var flags=flagModes[str];if(typeof flags=="undefined"){throw new Error(`Unknown file open mode: ${str}`)}return flags}function FS_getMode(canRead,canWrite){var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode}var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,lookupPath:(path,opts={})=>{path=PATH_FS.resolve(path);if(!path)return{path:"",node:null};var defaults={follow_mount:true,recurse_count:0};opts=Object.assign(defaults,opts);if(opts.recurse_count>8){throw new FS.ErrnoError(32)}var parts=path.split("/").filter(p=>!!p);var current=FS.root;var current_path="/";for(var i=0;i40){throw new FS.ErrnoError(32)}}}}return{path:current_path,node:current}},getPath: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:(parentid,name)=>{var hash=0;for(var i=0;i>>0)%FS.nameTable.length},hashAddNode:node=>{var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode: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:(parent,name)=>{var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode,parent)}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:(parent,name,mode,rdev)=>{var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode:node=>{FS.hashRemoveNode(node)},isRoot:node=>{return node===node.parent},isMountpoint:node=>{return!!node.mounted},isFile:mode=>{return(mode&61440)===32768},isDir:mode=>{return(mode&61440)===16384},isLink:mode=>{return(mode&61440)===40960},isChrdev:mode=>{return(mode&61440)===8192},isBlkdev:mode=>{return(mode&61440)===24576},isFIFO:mode=>{return(mode&61440)===4096},isSocket:mode=>{return(mode&49152)===49152},flagsToPermissionString:flag=>{var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions:(node,perms)=>{if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}else if(perms.includes("w")&&!(node.mode&146)){return 2}else if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup:dir=>{var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate:(dir,name)=>{try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete:(dir,name,isdir)=>{var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else{if(FS.isDir(node.mode)){return 31}}return 0},mayOpen:(node,flags)=>{if(!node){return 44}if(FS.isLink(node.mode)){return 32}else if(FS.isDir(node.mode)){if(FS.flagsToPermissionString(flags)!=="r"||flags&512){return 31}}return FS.nodePermissions(node,FS.flagsToPermissionString(flags))},MAX_OPEN_FDS:4096,nextfd:()=>{for(var fd=0;fd<=FS.MAX_OPEN_FDS;fd++){if(!FS.streams[fd]){return fd}}throw new FS.ErrnoError(33)},getStream:fd=>FS.streams[fd],createStream:(stream,fd=-1)=>{if(!FS.FSStream){FS.FSStream=function(){this.shared={}};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}},flags:{get:function(){return this.shared.flags},set:function(val){this.shared.flags=val}},position:{get:function(){return this.shared.position},set:function(val){this.shared.position=val}}})}stream=Object.assign(new FS.FSStream,stream);if(fd==-1){fd=FS.nextfd()}stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream:fd=>{FS.streams[fd]=null},chrdev_stream_ops:{open: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:()=>{throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice:(dev,ops)=>{FS.devices[dev]={stream_ops:ops}},getDevice:dev=>FS.devices[dev],getMounts: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:(populate,callback)=>{if(typeof populate=="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`)}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null)}}mounts.forEach(mount=>{if(!mount.type.syncfs){return done(null)}mount.type.syncfs(mount,populate,done)})},mount:(type,opts,mountpoint)=>{var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}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(10)}if(!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}}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:mountpoint=>{var lookup=FS.lookupPath(mountpoint,{follow_mount:false});if(!FS.isMountpoint(lookup.node)){throw new FS.ErrnoError(28)}var node=lookup.node;var mount=node.mounted;var mounts=FS.getMounts(mount);Object.keys(FS.nameTable).forEach(hash=>{var current=FS.nameTable[hash];while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current)}current=next}});node.mounted=null;var idx=node.mount.mounts.indexOf(mount);node.mount.mounts.splice(idx,1)},lookup:(parent,name)=>{return parent.node_ops.lookup(parent,name)},mknod:(path,mode,dev)=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name||name==="."||name===".."){throw new FS.ErrnoError(28)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},create:(path,mode)=>{mode=mode!==undefined?mode:438;mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir:(path,mode)=>{mode=mode!==undefined?mode:511;mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree:(path,mode)=>{var dirs=path.split("/");var d="";for(var i=0;i{if(typeof dev=="undefined"){dev=mode;mode=438}mode|=8192;return FS.mknod(path,mode,dev)},symlink:(oldpath,newpath)=>{if(!PATH_FS.resolve(oldpath)){throw new FS.ErrnoError(44)}var lookup=FS.lookupPath(newpath,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var newname=PATH.basename(newpath);var errCode=FS.mayCreate(parent,newname);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.symlink){throw new FS.ErrnoError(63)}return parent.node_ops.symlink(parent,newname,oldpath)},rename:(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;lookup=FS.lookupPath(old_path,{parent:true});old_dir=lookup.node;lookup=FS.lookupPath(new_path,{parent:true});new_dir=lookup.node;if(!old_dir||!new_dir)throw new FS.ErrnoError(44);if(old_dir.mount!==new_dir.mount){throw new FS.ErrnoError(75)}var old_node=FS.lookupNode(old_dir,old_name);var relative=PATH_FS.relative(old_path,new_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(28)}relative=PATH_FS.relative(new_path,old_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(55)}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 errCode=FS.mayDelete(old_dir,old_name,isdir);if(errCode){throw new FS.ErrnoError(errCode)}errCode=new_node?FS.mayDelete(new_dir,new_name,isdir):FS.mayCreate(new_dir,new_name);if(errCode){throw new FS.ErrnoError(errCode)}if(!old_dir.node_ops.rename){throw new FS.ErrnoError(63)}if(FS.isMountpoint(old_node)||new_node&&FS.isMountpoint(new_node)){throw new FS.ErrnoError(10)}if(new_dir!==old_dir){errCode=FS.nodePermissions(old_dir,"w");if(errCode){throw new FS.ErrnoError(errCode)}}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)}},rmdir:path=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,true);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.rmdir){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.rmdir(parent,name);FS.destroyNode(node)},readdir:path=>{var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;if(!node.node_ops.readdir){throw new FS.ErrnoError(54)}return node.node_ops.readdir(node)},unlink:path=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,false);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.unlink){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.unlink(parent,name);FS.destroyNode(node)},readlink:path=>{var lookup=FS.lookupPath(path);var link=lookup.node;if(!link){throw new FS.ErrnoError(44)}if(!link.node_ops.readlink){throw new FS.ErrnoError(28)}return PATH_FS.resolve(FS.getPath(link.parent),link.node_ops.readlink(link))},stat:(path,dontFollow)=>{var lookup=FS.lookupPath(path,{follow:!dontFollow});var node=lookup.node;if(!node){throw new FS.ErrnoError(44)}if(!node.node_ops.getattr){throw new FS.ErrnoError(63)}return node.node_ops.getattr(node)},lstat:path=>{return FS.stat(path,true)},chmod:(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(63)}node.node_ops.setattr(node,{mode:mode&4095|node.mode&~4095,timestamp:Date.now()})},lchmod:(path,mode)=>{FS.chmod(path,mode,true)},fchmod:(fd,mode)=>{var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}FS.chmod(stream.node,mode)},chown:(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(63)}node.node_ops.setattr(node,{timestamp:Date.now()})},lchown:(path,uid,gid)=>{FS.chown(path,uid,gid,true)},fchown:(fd,uid,gid)=>{var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}FS.chown(stream.node,uid,gid)},truncate:(path,len)=>{if(len<0){throw new FS.ErrnoError(28)}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(63)}if(FS.isDir(node.mode)){throw new FS.ErrnoError(31)}if(!FS.isFile(node.mode)){throw new FS.ErrnoError(28)}var errCode=FS.nodePermissions(node,"w");if(errCode){throw new FS.ErrnoError(errCode)}node.node_ops.setattr(node,{size:len,timestamp:Date.now()})},ftruncate:(fd,len)=>{var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(28)}FS.truncate(stream.node,len)},utime:(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:(path,flags,mode)=>{if(path===""){throw new FS.ErrnoError(44)}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){}}var created=false;if(flags&64){if(node){if(flags&128){throw new FS.ErrnoError(20)}}else{node=FS.mknod(path,mode,0);created=true}}if(!node){throw new FS.ErrnoError(44)}if(FS.isChrdev(node.mode)){flags&=~512}if(flags&65536&&!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}if(!created){var errCode=FS.mayOpen(node,flags);if(errCode){throw new FS.ErrnoError(errCode)}}if(flags&512&&!created){FS.truncate(node,0)}flags&=~(128|512|131072);var stream=FS.createStream({node:node,path:FS.getPath(node),flags:flags,seekable:true,position:0,stream_ops:node.stream_ops,ungotten:[],error:false});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}}return stream},close:stream=>{if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(stream.getdents)stream.getdents=null;try{if(stream.stream_ops.close){stream.stream_ops.close(stream)}}catch(e){throw e}finally{FS.closeStream(stream.fd)}stream.fd=null},isClosed:stream=>{return stream.fd===null},llseek:(stream,offset,whence)=>{if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(!stream.seekable||!stream.stream_ops.llseek){throw new FS.ErrnoError(70)}if(whence!=0&&whence!=1&&whence!=2){throw new FS.ErrnoError(28)}stream.position=stream.stream_ops.llseek(stream,offset,whence);stream.ungotten=[];return stream.position},read:(stream,buffer,offset,length,position)=>{if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.read){throw new FS.ErrnoError(28)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesRead=stream.stream_ops.read(stream,buffer,offset,length,position);if(!seeking)stream.position+=bytesRead;return bytesRead},write:(stream,buffer,offset,length,position,canOwn)=>{if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.write){throw new FS.ErrnoError(28)}if(stream.seekable&&stream.flags&1024){FS.llseek(stream,0,2)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesWritten=stream.stream_ops.write(stream,buffer,offset,length,position,canOwn);if(!seeking)stream.position+=bytesWritten;return bytesWritten},allocate:(stream,offset,length)=>{if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(offset<0||length<=0){throw new FS.ErrnoError(28)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(!FS.isFile(stream.node.mode)&&!FS.isDir(stream.node.mode)){throw new FS.ErrnoError(43)}if(!stream.stream_ops.allocate){throw new FS.ErrnoError(138)}stream.stream_ops.allocate(stream,offset,length)},mmap:(stream,length,position,prot,flags)=>{if((prot&2)!==0&&(flags&2)===0&&(stream.flags&2097155)!==2){throw new FS.ErrnoError(2)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(2)}if(!stream.stream_ops.mmap){throw new FS.ErrnoError(43)}return stream.stream_ops.mmap(stream,length,position,prot,flags)},msync:(stream,buffer,offset,length,mmapFlags)=>{if(!stream.stream_ops.msync){return 0}return stream.stream_ops.msync(stream,buffer,offset,length,mmapFlags)},munmap:stream=>0,ioctl:(stream,cmd,arg)=>{if(!stream.stream_ops.ioctl){throw new FS.ErrnoError(59)}return stream.stream_ops.ioctl(stream,cmd,arg)},readFile:(path,opts={})=>{opts.flags=opts.flags||0;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=UTF8ArrayToString(buf,0)}else if(opts.encoding==="binary"){ret=buf}FS.close(stream);return ret},writeFile:(path,data,opts={})=>{opts.flags=opts.flags||577;var stream=FS.open(path,opts.flags,opts.mode);if(typeof data=="string"){var buf=new Uint8Array(lengthBytesUTF8(data)+1);var actualNumBytes=stringToUTF8Array(data,buf,0,buf.length);FS.write(stream,buf,0,actualNumBytes,undefined,opts.canOwn)}else if(ArrayBuffer.isView(data)){FS.write(stream,data,0,data.byteLength,undefined,opts.canOwn)}else{throw new Error("Unsupported data type")}FS.close(stream)},cwd:()=>FS.currentPath,chdir:path=>{var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path},createDefaultDirectories:()=>{FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices:()=>{FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>length});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));var randomBuffer=new Uint8Array(1024),randomLeft=0;var randomByte=()=>{if(randomLeft===0){randomLeft=randomFill(randomBuffer).byteLength}return randomBuffer[--randomLeft]};FS.createDevice("/dev","random",randomByte);FS.createDevice("/dev","urandom",randomByte);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories:()=>{FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount:()=>{var node=FS.createNode(proc_self,"fd",16384|511,73);node.node_ops={lookup:(parent,name)=>{var fd=+name;var stream=FS.getStream(fd);if(!stream)throw new FS.ErrnoError(8);var ret={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>stream.path}};ret.parent=ret;return ret}};return node}},{},"/proc/self/fd")},createStandardStreams:()=>{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",0);var stdout=FS.open("/dev/stdout",1);var stderr=FS.open("/dev/stderr",1)},ensureErrnoError:()=>{if(FS.ErrnoError)return;FS.ErrnoError=function ErrnoError(errno,node){this.name="ErrnoError";this.node=node;this.setErrno=function(errno){this.errno=errno};this.setErrno(errno);this.message="FS error"};FS.ErrnoError.prototype=new Error;FS.ErrnoError.prototype.constructor=FS.ErrnoError;[44].forEach(code=>{FS.genericErrors[code]=new FS.ErrnoError(code);FS.genericErrors[code].stack=""})},staticInit:()=>{FS.ensureErrnoError();FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={"MEMFS":MEMFS}},init:(input,output,error)=>{FS.init.initialized=true;FS.ensureErrnoError();Module["stdin"]=input||Module["stdin"];Module["stdout"]=output||Module["stdout"];Module["stderr"]=error||Module["stderr"];FS.createStandardStreams()},quit:()=>{FS.init.initialized=false;for(var i=0;i{var ret=FS.analyzePath(path,dontResolveLastLink);if(!ret.exists){return null}return ret.object},analyzePath:(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},createPath:(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:(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:(parent,name,data,canRead,canWrite,canOwn)=>{var path=name;if(parent){parent=typeof parent=="string"?parent:FS.getPath(parent);path=name?PATH.join2(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{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:stream=>{stream.seekable=false},close:stream=>{if(output&&output.buffer&&output.buffer.length){output(10)}},read:(stream,buffer,offset,length,pos)=>{var bytesRead=0;for(var i=0;i{for(var i=0;i{if(obj.isDevice||obj.isFolder||obj.link||obj.contents)return 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(read_){try{obj.contents=intArrayFromString(read_(obj.url),true);obj.usedBytes=obj.contents.length}catch(e){throw new FS.ErrnoError(29)}}else{throw new Error("Cannot load without read() or XMLHttpRequest.")}},createLazyFile:(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=idx/this.chunkSize|0;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 usesGzip=(header=xhr.getResponseHeader("Content-Encoding"))&&header==="gzip";var chunkSize=1024*1024;if(!hasByteServing)chunkSize=datalength;var doXHR=(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);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||[])}return intArrayFromString(xhr.responseText||"",true)};var lazyArray=this;lazyArray.setDataGetter(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]});if(usesGzip||!datalength){chunkSize=datalength=1;datalength=this.getter(0).length;chunkSize=datalength;out("LazyFiles on gzip forces download of the whole file when length is accessed")}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.defineProperties(lazyArray,{length:{get:function(){if(!this.lengthKnown){this.cacheLength()}return this._length}},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.defineProperties(node,{usedBytes:{get:function(){return this.contents.length}}});var stream_ops={};var keys=Object.keys(node.stream_ops);keys.forEach(key=>{var fn=node.stream_ops[key];stream_ops[key]=function forceLoadLazyFile(){FS.forceLoadFile(node);return fn.apply(null,arguments)}});function writeChunks(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);if(contents.slice){for(var i=0;i{FS.forceLoadFile(node);return writeChunks(stream,buffer,offset,length,position)};stream_ops.mmap=(stream,length,position,prot,flags)=>{FS.forceLoadFile(node);var ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}writeChunks(stream,HEAP8,ptr,length,position);return{ptr:ptr,allocated:true}};node.stream_ops=stream_ops;return node}};var SYSCALLS={DEFAULT_POLLMASK:5,calculateAt:function(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=SYSCALLS.getStreamFromFD(dirfd);dir=dirstream.path}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return PATH.join2(dir,path)},doStat:function(func,path,buf){try{var stat=func(path)}catch(e){if(e&&e.node&&PATH.normalize(path)!==PATH.normalize(FS.getPath(e.node))){return-54}throw e}HEAP32[buf>>2]=stat.dev;HEAP32[buf+8>>2]=stat.ino;HEAP32[buf+12>>2]=stat.mode;HEAPU32[buf+16>>2]=stat.nlink;HEAP32[buf+20>>2]=stat.uid;HEAP32[buf+24>>2]=stat.gid;HEAP32[buf+28>>2]=stat.rdev;tempI64=[stat.size>>>0,(tempDouble=stat.size,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+40>>2]=tempI64[0],HEAP32[buf+44>>2]=tempI64[1];HEAP32[buf+48>>2]=4096;HEAP32[buf+52>>2]=stat.blocks;var atime=stat.atime.getTime();var mtime=stat.mtime.getTime();var ctime=stat.ctime.getTime();tempI64=[Math.floor(atime/1e3)>>>0,(tempDouble=Math.floor(atime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+56>>2]=tempI64[0],HEAP32[buf+60>>2]=tempI64[1];HEAPU32[buf+64>>2]=atime%1e3*1e3;tempI64=[Math.floor(mtime/1e3)>>>0,(tempDouble=Math.floor(mtime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+72>>2]=tempI64[0],HEAP32[buf+76>>2]=tempI64[1];HEAPU32[buf+80>>2]=mtime%1e3*1e3;tempI64=[Math.floor(ctime/1e3)>>>0,(tempDouble=Math.floor(ctime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+88>>2]=tempI64[0],HEAP32[buf+92>>2]=tempI64[1];HEAPU32[buf+96>>2]=ctime%1e3*1e3;tempI64=[stat.ino>>>0,(tempDouble=stat.ino,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+104>>2]=tempI64[0],HEAP32[buf+108>>2]=tempI64[1];return 0},doMsync:function(addr,stream,len,flags,offset){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}if(flags&2){return 0}var buffer=HEAPU8.slice(addr,addr+len);FS.msync(stream,buffer,offset,len,flags)},varargs:undefined,get:function(){SYSCALLS.varargs+=4;var ret=HEAP32[SYSCALLS.varargs-4>>2];return ret},getStr:function(ptr){var ret=UTF8ToString(ptr);return ret},getStreamFromFD:function(fd){var stream=FS.getStream(fd);if(!stream)throw new FS.ErrnoError(8);return stream}};function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(cmd){case 0:{var arg=SYSCALLS.get();if(arg<0){return-28}var newStream;newStream=FS.createStream(stream,arg);return newStream.fd}case 1:case 2:return 0;case 3:return stream.flags;case 4:{var arg=SYSCALLS.get();stream.flags|=arg;return 0}case 5:{var arg=SYSCALLS.get();var offset=0;HEAP16[arg+offset>>1]=2;return 0}case 6:case 7:return 0;case 16:case 8:return-28;case 9:setErrNo(28);return-1;default:{return-28}}}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_ioctl(fd,op,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(op){case 21509:case 21505:{if(!stream.tty)return-59;return 0}case 21510:case 21511:case 21512:case 21506:case 21507:case 21508:{if(!stream.tty)return-59;return 0}case 21519:{if(!stream.tty)return-59;var argp=SYSCALLS.get();HEAP32[argp>>2]=0;return 0}case 21520:{if(!stream.tty)return-59;return-28}case 21531:{var argp=SYSCALLS.get();return FS.ioctl(stream,op,argp)}case 21523:{if(!stream.tty)return-59;return 0}case 21524:{if(!stream.tty)return-59;return 0}default:return-28}}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs;try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);var mode=varargs?SYSCALLS.get():0;return FS.open(path,flags,mode).fd}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var char_0=48;var char_9=57;function makeLegalFunctionName(name){if(undefined===name){return"_unknown"}name=name.replace(/[^a-zA-Z0-9_]/g,"$");var f=name.charCodeAt(0);if(f>=char_0&&f<=char_9){return`_${name}`}return name}function createNamedFunction(name,body){name=makeLegalFunctionName(name);return{[name]:function(){return body.apply(this,arguments)}}[name]}function HandleAllocator(){this.allocated=[undefined];this.freelist=[];this.get=function(id){return this.allocated[id]};this.has=function(id){return this.allocated[id]!==undefined};this.allocate=function(handle){var id=this.freelist.pop()||this.allocated.length;this.allocated[id]=handle;return id};this.free=function(id){this.allocated[id]=undefined;this.freelist.push(id)}}var emval_handles=new HandleAllocator;function extendError(baseErrorType,errorName){var errorClass=createNamedFunction(errorName,function(message){this.name=errorName;this.message=message;var stack=new Error(message).stack;if(stack!==undefined){this.stack=this.toString()+"\n"+stack.replace(/^Error(:[^\n]*)?\n/,"")}});errorClass.prototype=Object.create(baseErrorType.prototype);errorClass.prototype.constructor=errorClass;errorClass.prototype.toString=function(){if(this.message===undefined){return this.name}else{return`${this.name}: ${this.message}`}};return errorClass}var BindingError=undefined;function throwBindingError(message){throw new BindingError(message)}function count_emval_handles(){var count=0;for(var i=emval_handles.reserved;i{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles.get(handle).value},toHandle:value=>{switch(value){case undefined:return 1;case null:return 2;case true:return 3;case false:return 4;default:{return emval_handles.allocate({refcount:1,value:value})}}}};var PureVirtualError=undefined;function embind_init_charCodes(){var codes=new Array(256);for(var i=0;i<256;++i){codes[i]=String.fromCharCode(i)}embind_charCodes=codes}var embind_charCodes=undefined;function readLatin1String(ptr){var ret="";var c=ptr;while(HEAPU8[c]){ret+=embind_charCodes[HEAPU8[c++]]}return ret}function getInheritedInstanceCount(){return Object.keys(registeredInstances).length}function getLiveInheritedInstances(){var rv=[];for(var k in registeredInstances){if(registeredInstances.hasOwnProperty(k)){rv.push(registeredInstances[k])}}return rv}var deletionQueue=[];function flushPendingDeletes(){while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]()}}var delayFunction=undefined;function setDelayFunction(fn){delayFunction=fn;if(deletionQueue.length&&delayFunction){delayFunction(flushPendingDeletes)}}function init_embind(){Module["getInheritedInstanceCount"]=getInheritedInstanceCount;Module["getLiveInheritedInstances"]=getLiveInheritedInstances;Module["flushPendingDeletes"]=flushPendingDeletes;Module["setDelayFunction"]=setDelayFunction}var registeredInstances={};function getBasestPointer(class_,ptr){if(ptr===undefined){throwBindingError("ptr should not be undefined")}while(class_.baseClass){ptr=class_.upcast(ptr);class_=class_.baseClass}return ptr}function registerInheritedInstance(class_,ptr,instance){ptr=getBasestPointer(class_,ptr);if(registeredInstances.hasOwnProperty(ptr)){throwBindingError(`Tried to register registered instance: ${ptr}`)}else{registeredInstances[ptr]=instance}}var registeredTypes={};function getTypeName(type){var ptr=___getTypeName(type);var rv=readLatin1String(ptr);_free(ptr);return rv}function requireRegisteredType(rawType,humanName){var impl=registeredTypes[rawType];if(undefined===impl){throwBindingError(humanName+" has unknown type "+getTypeName(rawType))}return impl}function unregisterInheritedInstance(class_,ptr){ptr=getBasestPointer(class_,ptr);if(registeredInstances.hasOwnProperty(ptr)){delete registeredInstances[ptr]}else{throwBindingError(`Tried to unregister unregistered instance: ${ptr}`)}}function detachFinalizer(handle){}var finalizationRegistry=false;function runDestructor($$){if($$.smartPtr){$$.smartPtrType.rawDestructor($$.smartPtr)}else{$$.ptrType.registeredClass.rawDestructor($$.ptr)}}function releaseClassHandle($$){$$.count.value-=1;var toDelete=0===$$.count.value;if(toDelete){runDestructor($$)}}function downcastPointer(ptr,ptrClass,desiredClass){if(ptrClass===desiredClass){return ptr}if(undefined===desiredClass.baseClass){return null}var rv=downcastPointer(ptr,ptrClass,desiredClass.baseClass);if(rv===null){return null}return desiredClass.downcast(rv)}var registeredPointers={};function getInheritedInstance(class_,ptr){ptr=getBasestPointer(class_,ptr);return registeredInstances[ptr]}var InternalError=undefined;function throwInternalError(message){throw new InternalError(message)}function makeClassHandle(prototype,record){if(!record.ptrType||!record.ptr){throwInternalError("makeClassHandle requires ptr and ptrType")}var hasSmartPtrType=!!record.smartPtrType;var hasSmartPtr=!!record.smartPtr;if(hasSmartPtrType!==hasSmartPtr){throwInternalError("Both smartPtrType and smartPtr must be specified")}record.count={value:1};return attachFinalizer(Object.create(prototype,{$$:{value:record}}))}function RegisteredPointer_fromWireType(ptr){var rawPointer=this.getPointee(ptr);if(!rawPointer){this.destructor(ptr);return null}var registeredInstance=getInheritedInstance(this.registeredClass,rawPointer);if(undefined!==registeredInstance){if(0===registeredInstance.$$.count.value){registeredInstance.$$.ptr=rawPointer;registeredInstance.$$.smartPtr=ptr;return registeredInstance["clone"]()}else{var rv=registeredInstance["clone"]();this.destructor(ptr);return rv}}function makeDefaultHandle(){if(this.isSmartPointer){return makeClassHandle(this.registeredClass.instancePrototype,{ptrType:this.pointeeType,ptr:rawPointer,smartPtrType:this,smartPtr:ptr})}else{return makeClassHandle(this.registeredClass.instancePrototype,{ptrType:this,ptr:ptr})}}var actualType=this.registeredClass.getActualType(rawPointer);var registeredPointerRecord=registeredPointers[actualType];if(!registeredPointerRecord){return makeDefaultHandle.call(this)}var toType;if(this.isConst){toType=registeredPointerRecord.constPointerType}else{toType=registeredPointerRecord.pointerType}var dp=downcastPointer(rawPointer,this.registeredClass,toType.registeredClass);if(dp===null){return makeDefaultHandle.call(this)}if(this.isSmartPointer){return makeClassHandle(toType.registeredClass.instancePrototype,{ptrType:toType,ptr:dp,smartPtrType:this,smartPtr:ptr})}else{return makeClassHandle(toType.registeredClass.instancePrototype,{ptrType:toType,ptr:dp})}}function attachFinalizer(handle){if("undefined"===typeof FinalizationRegistry){attachFinalizer=handle=>handle;return handle}finalizationRegistry=new FinalizationRegistry(info=>{releaseClassHandle(info.$$)});attachFinalizer=handle=>{var $$=handle.$$;var hasSmartPtr=!!$$.smartPtr;if(hasSmartPtr){var info={$$:$$};finalizationRegistry.register(handle,info,handle)}return handle};detachFinalizer=handle=>finalizationRegistry.unregister(handle);return attachFinalizer(handle)}function __embind_create_inheriting_constructor(constructorName,wrapperType,properties){constructorName=readLatin1String(constructorName);wrapperType=requireRegisteredType(wrapperType,"wrapper");properties=Emval.toValue(properties);var arraySlice=[].slice;var registeredClass=wrapperType.registeredClass;var wrapperPrototype=registeredClass.instancePrototype;var baseClass=registeredClass.baseClass;var baseClassPrototype=baseClass.instancePrototype;var baseConstructor=registeredClass.baseClass.constructor;var ctor=createNamedFunction(constructorName,function(){registeredClass.baseClass.pureVirtualFunctions.forEach(function(name){if(this[name]===baseClassPrototype[name]){throw new PureVirtualError(`Pure virtual function ${name} must be implemented in JavaScript`)}}.bind(this));Object.defineProperty(this,"__parent",{value:wrapperPrototype});this["__construct"].apply(this,arraySlice.call(arguments))});wrapperPrototype["__construct"]=function __construct(){if(this===wrapperPrototype){throwBindingError("Pass correct 'this' to __construct")}var inner=baseConstructor["implement"].apply(undefined,[this].concat(arraySlice.call(arguments)));detachFinalizer(inner);var $$=inner.$$;inner["notifyOnDestruction"]();$$.preservePointerOnDelete=true;Object.defineProperties(this,{$$:{value:$$}});attachFinalizer(this);registerInheritedInstance(registeredClass,$$.ptr,this)};wrapperPrototype["__destruct"]=function __destruct(){if(this===wrapperPrototype){throwBindingError("Pass correct 'this' to __destruct")}detachFinalizer(this);unregisterInheritedInstance(registeredClass,this.$$.ptr)};ctor.prototype=Object.create(wrapperPrototype);for(var p in properties){ctor.prototype[p]=properties[p]}return Emval.toHandle(ctor)}var structRegistrations={};function runDestructors(destructors){while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr)}}function simpleReadValueFromPointer(pointer){return this["fromWireType"](HEAP32[pointer>>2])}var awaitingDependencies={};var typeDependencies={};function whenDependentTypesAreResolved(myTypes,dependentTypes,getTypeConverters){myTypes.forEach(function(type){typeDependencies[type]=dependentTypes});function onComplete(typeConverters){var myTypeConverters=getTypeConverters(typeConverters);if(myTypeConverters.length!==myTypes.length){throwInternalError("Mismatched type converter count")}for(var i=0;i{if(registeredTypes.hasOwnProperty(dt)){typeConverters[i]=registeredTypes[dt]}else{unregisteredTypes.push(dt);if(!awaitingDependencies.hasOwnProperty(dt)){awaitingDependencies[dt]=[]}awaitingDependencies[dt].push(()=>{typeConverters[i]=registeredTypes[dt];++registered;if(registered===unregisteredTypes.length){onComplete(typeConverters)}})}});if(0===unregisteredTypes.length){onComplete(typeConverters)}}function __embind_finalize_value_object(structType){var reg=structRegistrations[structType];delete structRegistrations[structType];var rawConstructor=reg.rawConstructor;var rawDestructor=reg.rawDestructor;var fieldRecords=reg.fields;var fieldTypes=fieldRecords.map(field=>field.getterReturnType).concat(fieldRecords.map(field=>field.setterArgumentType));whenDependentTypesAreResolved([structType],fieldTypes,fieldTypes=>{var fields={};fieldRecords.forEach((field,i)=>{var fieldName=field.fieldName;var getterReturnType=fieldTypes[i];var getter=field.getter;var getterContext=field.getterContext;var setterArgumentType=fieldTypes[i+fieldRecords.length];var setter=field.setter;var setterContext=field.setterContext;fields[fieldName]={read:ptr=>{return getterReturnType["fromWireType"](getter(getterContext,ptr))},write:(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}}});return[{name:reg.name,"fromWireType":function(ptr){var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv},"toWireType":function(destructors,o){for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError(`Missing field: "${fieldName}"`)}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:rawDestructor}]})}function __embind_register_bigint(primitiveType,name,size,minRange,maxRange){}function getShiftFromSize(size){switch(size){case 1:return 0;case 2:return 1;case 4:return 2;case 8:return 3;default:throw new TypeError(`Unknown type size: ${size}`)}}function registerType(rawType,registeredInstance,options={}){if(!("argPackAdvance"in registeredInstance)){throw new TypeError("registerType registeredInstance requires argPackAdvance")}var name=registeredInstance.name;if(!rawType){throwBindingError(`type "${name}" must have a positive integer typeid pointer`)}if(registeredTypes.hasOwnProperty(rawType)){if(options.ignoreDuplicateRegistrations){return}else{throwBindingError(`Cannot register type '${name}' twice`)}}registeredTypes[rawType]=registeredInstance;delete typeDependencies[rawType];if(awaitingDependencies.hasOwnProperty(rawType)){var callbacks=awaitingDependencies[rawType];delete awaitingDependencies[rawType];callbacks.forEach(cb=>cb())}}function __embind_register_bool(rawType,name,size,trueValue,falseValue){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(wt){return!!wt},"toWireType":function(destructors,o){return o?trueValue:falseValue},"argPackAdvance":8,"readValueFromPointer":function(pointer){var heap;if(size===1){heap=HEAP8}else if(size===2){heap=HEAP16}else if(size===4){heap=HEAP32}else{throw new TypeError("Unknown boolean type size: "+name)}return this["fromWireType"](heap[pointer>>shift])},destructorFunction:null})}function ClassHandle_isAliasOf(other){if(!(this instanceof ClassHandle)){return false}if(!(other instanceof ClassHandle)){return false}var leftClass=this.$$.ptrType.registeredClass;var left=this.$$.ptr;var rightClass=other.$$.ptrType.registeredClass;var right=other.$$.ptr;while(leftClass.baseClass){left=leftClass.upcast(left);leftClass=leftClass.baseClass}while(rightClass.baseClass){right=rightClass.upcast(right);rightClass=rightClass.baseClass}return leftClass===rightClass&&left===right}function shallowCopyInternalPointer(o){return{count:o.count,deleteScheduled:o.deleteScheduled,preservePointerOnDelete:o.preservePointerOnDelete,ptr:o.ptr,ptrType:o.ptrType,smartPtr:o.smartPtr,smartPtrType:o.smartPtrType}}function throwInstanceAlreadyDeleted(obj){function getInstanceTypeName(handle){return handle.$$.ptrType.registeredClass.name}throwBindingError(getInstanceTypeName(obj)+" instance already deleted")}function ClassHandle_clone(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.preservePointerOnDelete){this.$$.count.value+=1;return this}else{var clone=attachFinalizer(Object.create(Object.getPrototypeOf(this),{$$:{value:shallowCopyInternalPointer(this.$$)}}));clone.$$.count.value+=1;clone.$$.deleteScheduled=false;return clone}}function ClassHandle_delete(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}detachFinalizer(this);releaseClassHandle(this.$$);if(!this.$$.preservePointerOnDelete){this.$$.smartPtr=undefined;this.$$.ptr=undefined}}function ClassHandle_isDeleted(){return!this.$$.ptr}function ClassHandle_deleteLater(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}deletionQueue.push(this);if(deletionQueue.length===1&&delayFunction){delayFunction(flushPendingDeletes)}this.$$.deleteScheduled=true;return this}function init_ClassHandle(){ClassHandle.prototype["isAliasOf"]=ClassHandle_isAliasOf;ClassHandle.prototype["clone"]=ClassHandle_clone;ClassHandle.prototype["delete"]=ClassHandle_delete;ClassHandle.prototype["isDeleted"]=ClassHandle_isDeleted;ClassHandle.prototype["deleteLater"]=ClassHandle_deleteLater}function ClassHandle(){}function ensureOverloadTable(proto,methodName,humanName){if(undefined===proto[methodName].overloadTable){var prevFunc=proto[methodName];proto[methodName]=function(){if(!proto[methodName].overloadTable.hasOwnProperty(arguments.length)){throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${arguments.length}) - expects one of (${proto[methodName].overloadTable})!`)}return proto[methodName].overloadTable[arguments.length].apply(this,arguments)};proto[methodName].overloadTable=[];proto[methodName].overloadTable[prevFunc.argCount]=prevFunc}}function exposePublicSymbol(name,value,numArguments){if(Module.hasOwnProperty(name)){if(undefined===numArguments||undefined!==Module[name].overloadTable&&undefined!==Module[name].overloadTable[numArguments]){throwBindingError(`Cannot register public name '${name}' twice`)}ensureOverloadTable(Module,name,name);if(Module.hasOwnProperty(numArguments)){throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`)}Module[name].overloadTable[numArguments]=value}else{Module[name]=value;if(undefined!==numArguments){Module[name].numArguments=numArguments}}}function RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast){this.name=name;this.constructor=constructor;this.instancePrototype=instancePrototype;this.rawDestructor=rawDestructor;this.baseClass=baseClass;this.getActualType=getActualType;this.upcast=upcast;this.downcast=downcast;this.pureVirtualFunctions=[]}function upcastPointer(ptr,ptrClass,desiredClass){while(ptrClass!==desiredClass){if(!ptrClass.upcast){throwBindingError(`Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`)}ptr=ptrClass.upcast(ptr);ptrClass=ptrClass.baseClass}return ptr}function constNoSmartPtrRawPointerToWireType(destructors,handle){if(handle===null){if(this.isReference){throwBindingError(`null is not a valid ${this.name}`)}return 0}if(!handle.$$){throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)}if(!handle.$$.ptr){throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function genericPointerToWireType(destructors,handle){var ptr;if(handle===null){if(this.isReference){throwBindingError(`null is not a valid ${this.name}`)}if(this.isSmartPointer){ptr=this.rawConstructor();if(destructors!==null){destructors.push(this.rawDestructor,ptr)}return ptr}else{return 0}}if(!handle.$$){throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)}if(!handle.$$.ptr){throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)}if(!this.isConst&&handle.$$.ptrType.isConst){throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType?handle.$$.smartPtrType.name:handle.$$.ptrType.name} to parameter type ${this.name}`)}var handleClass=handle.$$.ptrType.registeredClass;ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);if(this.isSmartPointer){if(undefined===handle.$$.smartPtr){throwBindingError("Passing raw pointer to smart pointer is illegal")}switch(this.sharingPolicy){case 0:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType?handle.$$.smartPtrType.name:handle.$$.ptrType.name} to parameter type ${this.name}`)}break;case 1:ptr=handle.$$.smartPtr;break;case 2:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{var clonedHandle=handle["clone"]();ptr=this.rawShare(ptr,Emval.toHandle(function(){clonedHandle["delete"]()}));if(destructors!==null){destructors.push(this.rawDestructor,ptr)}}break;default:throwBindingError("Unsupporting sharing policy")}}return ptr}function nonConstNoSmartPtrRawPointerToWireType(destructors,handle){if(handle===null){if(this.isReference){throwBindingError(`null is not a valid ${this.name}`)}return 0}if(!handle.$$){throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)}if(!handle.$$.ptr){throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)}if(handle.$$.ptrType.isConst){throwBindingError(`Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`)}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function RegisteredPointer_getPointee(ptr){if(this.rawGetPointee){ptr=this.rawGetPointee(ptr)}return ptr}function RegisteredPointer_destructor(ptr){if(this.rawDestructor){this.rawDestructor(ptr)}}function RegisteredPointer_deleteObject(handle){if(handle!==null){handle["delete"]()}}function init_RegisteredPointer(){RegisteredPointer.prototype.getPointee=RegisteredPointer_getPointee;RegisteredPointer.prototype.destructor=RegisteredPointer_destructor;RegisteredPointer.prototype["argPackAdvance"]=8;RegisteredPointer.prototype["readValueFromPointer"]=simpleReadValueFromPointer;RegisteredPointer.prototype["deleteObject"]=RegisteredPointer_deleteObject;RegisteredPointer.prototype["fromWireType"]=RegisteredPointer_fromWireType}function RegisteredPointer(name,registeredClass,isReference,isConst,isSmartPointer,pointeeType,sharingPolicy,rawGetPointee,rawConstructor,rawShare,rawDestructor){this.name=name;this.registeredClass=registeredClass;this.isReference=isReference;this.isConst=isConst;this.isSmartPointer=isSmartPointer;this.pointeeType=pointeeType;this.sharingPolicy=sharingPolicy;this.rawGetPointee=rawGetPointee;this.rawConstructor=rawConstructor;this.rawShare=rawShare;this.rawDestructor=rawDestructor;if(!isSmartPointer&®isteredClass.baseClass===undefined){if(isConst){this["toWireType"]=constNoSmartPtrRawPointerToWireType;this.destructorFunction=null}else{this["toWireType"]=nonConstNoSmartPtrRawPointerToWireType;this.destructorFunction=null}}else{this["toWireType"]=genericPointerToWireType}}function replacePublicSymbol(name,value,numArguments){if(!Module.hasOwnProperty(name)){throwInternalError("Replacing nonexistant public symbol")}if(undefined!==Module[name].overloadTable&&undefined!==numArguments){Module[name].overloadTable[numArguments]=value}else{Module[name]=value;Module[name].argCount=numArguments}}function dynCallLegacy(sig,ptr,args){var f=Module["dynCall_"+sig];return args&&args.length?f.apply(null,[ptr].concat(args)):f.call(null,ptr)}var wasmTableMirror=[];function getWasmTableEntry(funcPtr){var func=wasmTableMirror[funcPtr];if(!func){if(funcPtr>=wasmTableMirror.length)wasmTableMirror.length=funcPtr+1;wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}return func}function dynCall(sig,ptr,args){if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}var rtn=getWasmTableEntry(ptr).apply(null,args);return rtn}function getDynCaller(sig,ptr){var argCache=[];return function(){argCache.length=0;Object.assign(argCache,arguments);return dynCall(sig,ptr,argCache)}}function embind__requireFunction(signature,rawFunction){signature=readLatin1String(signature);function makeDynCaller(){if(signature.includes("j")){return getDynCaller(signature,rawFunction)}return getWasmTableEntry(rawFunction)}var fp=makeDynCaller();if(typeof fp!="function"){throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`)}return fp}var UnboundTypeError=undefined;function throwUnboundTypeError(message,types){var unboundTypes=[];var seen={};function visit(type){if(seen[type]){return}if(registeredTypes[type]){return}if(typeDependencies[type]){typeDependencies[type].forEach(visit);return}unboundTypes.push(type);seen[type]=true}types.forEach(visit);throw new UnboundTypeError(`${message}: `+unboundTypes.map(getTypeName).join([", "]))}function __embind_register_class(rawType,rawPointerType,rawConstPointerType,baseClassRawType,getActualTypeSignature,getActualType,upcastSignature,upcast,downcastSignature,downcast,name,destructorSignature,rawDestructor){name=readLatin1String(name);getActualType=embind__requireFunction(getActualTypeSignature,getActualType);if(upcast){upcast=embind__requireFunction(upcastSignature,upcast)}if(downcast){downcast=embind__requireFunction(downcastSignature,downcast)}rawDestructor=embind__requireFunction(destructorSignature,rawDestructor);var legalFunctionName=makeLegalFunctionName(name);exposePublicSymbol(legalFunctionName,function(){throwUnboundTypeError(`Cannot construct ${name} due to unbound types`,[baseClassRawType])});whenDependentTypesAreResolved([rawType,rawPointerType,rawConstPointerType],baseClassRawType?[baseClassRawType]:[],function(base){base=base[0];var baseClass;var basePrototype;if(baseClassRawType){baseClass=base.registeredClass;basePrototype=baseClass.instancePrototype}else{basePrototype=ClassHandle.prototype}var constructor=createNamedFunction(legalFunctionName,function(){if(Object.getPrototypeOf(this)!==instancePrototype){throw new BindingError("Use 'new' to construct "+name)}if(undefined===registeredClass.constructor_body){throw new BindingError(name+" has no accessible constructor")}var body=registeredClass.constructor_body[arguments.length];if(undefined===body){throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${arguments.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`)}return body.apply(this,arguments)});var instancePrototype=Object.create(basePrototype,{constructor:{value:constructor}});constructor.prototype=instancePrototype;var registeredClass=new RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast);if(registeredClass.baseClass){if(registeredClass.baseClass.__derivedClasses===undefined){registeredClass.baseClass.__derivedClasses=[]}registeredClass.baseClass.__derivedClasses.push(registeredClass)}var referenceConverter=new RegisteredPointer(name,registeredClass,true,false,false);var pointerConverter=new RegisteredPointer(name+"*",registeredClass,false,false,false);var constPointerConverter=new RegisteredPointer(name+" const*",registeredClass,false,true,false);registeredPointers[rawType]={pointerType:pointerConverter,constPointerType:constPointerConverter};replacePublicSymbol(legalFunctionName,constructor);return[referenceConverter,pointerConverter,constPointerConverter]})}function craftInvokerFunction(humanName,argTypes,classType,cppInvokerFunc,cppTargetFunc,isAsync){var argCount=argTypes.length;if(argCount<2){throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!")}var isClassMethodFunc=argTypes[1]!==null&&classType!==null;var needsDestructorStack=false;for(var i=1;i>2])}return array}function __embind_register_class_class_function(rawClassType,methodName,argCount,rawArgTypesAddr,invokerSignature,rawInvoker,fn,isAsync){var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);methodName=readLatin1String(methodName);rawInvoker=embind__requireFunction(invokerSignature,rawInvoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName=`${classType.name}.${methodName}`;function unboundTypesHandler(){throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`,rawArgTypes)}if(methodName.startsWith("@@")){methodName=Symbol[methodName.substring(2)]}var proto=classType.registeredClass.constructor;if(undefined===proto[methodName]){unboundTypesHandler.argCount=argCount-1;proto[methodName]=unboundTypesHandler}else{ensureOverloadTable(proto,methodName,humanName);proto[methodName].overloadTable[argCount-1]=unboundTypesHandler}whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){var invokerArgsArray=[argTypes[0],null].concat(argTypes.slice(1));var func=craftInvokerFunction(humanName,invokerArgsArray,null,rawInvoker,fn,isAsync);if(undefined===proto[methodName].overloadTable){func.argCount=argCount-1;proto[methodName]=func}else{proto[methodName].overloadTable[argCount-1]=func}if(classType.registeredClass.__derivedClasses){for(const derivedClass of classType.registeredClass.__derivedClasses){if(!derivedClass.constructor.hasOwnProperty(methodName)){derivedClass.constructor[methodName]=func}}}return[]});return[]})}function __embind_register_class_constructor(rawClassType,argCount,rawArgTypesAddr,invokerSignature,invoker,rawConstructor){assert(argCount>0);var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);invoker=embind__requireFunction(invokerSignature,invoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName=`constructor ${classType.name}`;if(undefined===classType.registeredClass.constructor_body){classType.registeredClass.constructor_body=[]}if(undefined!==classType.registeredClass.constructor_body[argCount-1]){throw new BindingError(`Cannot register multiple constructors with identical number of parameters (${argCount-1}) for class '${classType.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`)}classType.registeredClass.constructor_body[argCount-1]=()=>{throwUnboundTypeError(`Cannot construct ${classType.name} due to unbound types`,rawArgTypes)};whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){argTypes.splice(1,0,null);classType.registeredClass.constructor_body[argCount-1]=craftInvokerFunction(humanName,argTypes,null,invoker,rawConstructor);return[]});return[]})}function __embind_register_class_function(rawClassType,methodName,argCount,rawArgTypesAddr,invokerSignature,rawInvoker,context,isPureVirtual,isAsync){var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);methodName=readLatin1String(methodName);rawInvoker=embind__requireFunction(invokerSignature,rawInvoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName=`${classType.name}.${methodName}`;if(methodName.startsWith("@@")){methodName=Symbol[methodName.substring(2)]}if(isPureVirtual){classType.registeredClass.pureVirtualFunctions.push(methodName)}function unboundTypesHandler(){throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`,rawArgTypes)}var proto=classType.registeredClass.instancePrototype;var method=proto[methodName];if(undefined===method||undefined===method.overloadTable&&method.className!==classType.name&&method.argCount===argCount-2){unboundTypesHandler.argCount=argCount-2;unboundTypesHandler.className=classType.name;proto[methodName]=unboundTypesHandler}else{ensureOverloadTable(proto,methodName,humanName);proto[methodName].overloadTable[argCount-2]=unboundTypesHandler}whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){var memberFunction=craftInvokerFunction(humanName,argTypes,classType,rawInvoker,context,isAsync);if(undefined===proto[methodName].overloadTable){memberFunction.argCount=argCount-2;proto[methodName]=memberFunction}else{proto[methodName].overloadTable[argCount-2]=memberFunction}return[]});return[]})}function validateThis(this_,classType,humanName){if(!(this_ instanceof Object)){throwBindingError(`${humanName} with invalid "this": ${this_}`)}if(!(this_ instanceof classType.registeredClass.constructor)){throwBindingError(`${humanName} incompatible with "this" of type ${this_.constructor.name}`)}if(!this_.$$.ptr){throwBindingError(`cannot call emscripten binding method ${humanName} on deleted object`)}return upcastPointer(this_.$$.ptr,this_.$$.ptrType.registeredClass,classType.registeredClass)}function __embind_register_class_property(classType,fieldName,getterReturnType,getterSignature,getter,getterContext,setterArgumentType,setterSignature,setter,setterContext){fieldName=readLatin1String(fieldName);getter=embind__requireFunction(getterSignature,getter);whenDependentTypesAreResolved([],[classType],function(classType){classType=classType[0];var humanName=`${classType.name}.${fieldName}`;var desc={get:function(){throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`,[getterReturnType,setterArgumentType])},enumerable:true,configurable:true};if(setter){desc.set=()=>{throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`,[getterReturnType,setterArgumentType])}}else{desc.set=v=>{throwBindingError(humanName+" is a read-only property")}}Object.defineProperty(classType.registeredClass.instancePrototype,fieldName,desc);whenDependentTypesAreResolved([],setter?[getterReturnType,setterArgumentType]:[getterReturnType],function(types){var getterReturnType=types[0];var desc={get:function(){var ptr=validateThis(this,classType,humanName+" getter");return getterReturnType["fromWireType"](getter(getterContext,ptr))},enumerable:true};if(setter){setter=embind__requireFunction(setterSignature,setter);var setterArgumentType=types[1];desc.set=function(v){var ptr=validateThis(this,classType,humanName+" setter");var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,v));runDestructors(destructors)}}Object.defineProperty(classType.registeredClass.instancePrototype,fieldName,desc);return[]});return[]})}function __embind_register_constant(name,type,value){name=readLatin1String(name);whenDependentTypesAreResolved([],[type],function(type){type=type[0];Module[name]=type["fromWireType"](value);return[]})}function __emval_decref(handle){if(handle>=emval_handles.reserved&&0===--emval_handles.get(handle).refcount){emval_handles.free(handle)}}function __embind_register_emval(rawType,name){name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(handle){var rv=Emval.toValue(handle);__emval_decref(handle);return rv},"toWireType":function(destructors,value){return Emval.toHandle(value)},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:null})}function enumReadValueFromPointer(name,shift,signed){switch(shift){case 0:return function(pointer){var heap=signed?HEAP8:HEAPU8;return this["fromWireType"](heap[pointer])};case 1:return function(pointer){var heap=signed?HEAP16:HEAPU16;return this["fromWireType"](heap[pointer>>1])};case 2:return function(pointer){var heap=signed?HEAP32:HEAPU32;return this["fromWireType"](heap[pointer>>2])};default:throw new TypeError("Unknown integer type: "+name)}}function __embind_register_enum(rawType,name,size,isSigned){var shift=getShiftFromSize(size);name=readLatin1String(name);function ctor(){}ctor.values={};registerType(rawType,{name:name,constructor:ctor,"fromWireType":function(c){return this.constructor.values[c]},"toWireType":function(destructors,c){return c.value},"argPackAdvance":8,"readValueFromPointer":enumReadValueFromPointer(name,shift,isSigned),destructorFunction:null});exposePublicSymbol(name,ctor)}function __embind_register_enum_value(rawEnumType,name,enumValue){var enumType=requireRegisteredType(rawEnumType,"enum");name=readLatin1String(name);var Enum=enumType.constructor;var Value=Object.create(enumType.constructor.prototype,{value:{value:enumValue},constructor:{value:createNamedFunction(`${enumType.name}_${name}`,function(){})}});Enum.values[enumValue]=Value;Enum[name]=Value}function embindRepr(v){if(v===null){return"null"}var t=typeof v;if(t==="object"||t==="array"||t==="function"){return v.toString()}else{return""+v}}function floatReadValueFromPointer(name,shift){switch(shift){case 2:return function(pointer){return this["fromWireType"](HEAPF32[pointer>>2])};case 3:return function(pointer){return this["fromWireType"](HEAPF64[pointer>>3])};default:throw new TypeError("Unknown float type: "+name)}}function __embind_register_float(rawType,name,size){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(value){return value},"toWireType":function(destructors,value){return value},"argPackAdvance":8,"readValueFromPointer":floatReadValueFromPointer(name,shift),destructorFunction:null})}function __embind_register_function(name,argCount,rawArgTypesAddr,signature,rawInvoker,fn,isAsync){var argTypes=heap32VectorToArray(argCount,rawArgTypesAddr);name=readLatin1String(name);rawInvoker=embind__requireFunction(signature,rawInvoker);exposePublicSymbol(name,function(){throwUnboundTypeError(`Cannot call ${name} due to unbound types`,argTypes)},argCount-1);whenDependentTypesAreResolved([],argTypes,function(argTypes){var invokerArgsArray=[argTypes[0],null].concat(argTypes.slice(1));replacePublicSymbol(name,craftInvokerFunction(name,invokerArgsArray,null,rawInvoker,fn,isAsync),argCount-1);return[]})}function integerReadValueFromPointer(name,shift,signed){switch(shift){case 0:return signed?function readS8FromPointer(pointer){return HEAP8[pointer]}:function readU8FromPointer(pointer){return HEAPU8[pointer]};case 1:return signed?function readS16FromPointer(pointer){return HEAP16[pointer>>1]}:function readU16FromPointer(pointer){return HEAPU16[pointer>>1]};case 2:return signed?function readS32FromPointer(pointer){return HEAP32[pointer>>2]}:function readU32FromPointer(pointer){return HEAPU32[pointer>>2]};default:throw new TypeError("Unknown integer type: "+name)}}function __embind_register_integer(primitiveType,name,size,minRange,maxRange){name=readLatin1String(name);if(maxRange===-1){maxRange=4294967295}var shift=getShiftFromSize(size);var fromWireType=value=>value;if(minRange===0){var bitshift=32-8*size;fromWireType=value=>value<>>bitshift}var isUnsignedType=name.includes("unsigned");var checkAssertions=(value,toTypeName)=>{};var toWireType;if(isUnsignedType){toWireType=function(destructors,value){checkAssertions(value,this.name);return value>>>0}}else{toWireType=function(destructors,value){checkAssertions(value,this.name);return value}}registerType(primitiveType,{name:name,"fromWireType":fromWireType,"toWireType":toWireType,"argPackAdvance":8,"readValueFromPointer":integerReadValueFromPointer(name,shift,minRange!==0),destructorFunction:null})}function __embind_register_memory_view(rawType,dataTypeIndex,name){var typeMapping=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array];var TA=typeMapping[dataTypeIndex];function decodeMemoryView(handle){handle=handle>>2;var heap=HEAPU32;var size=heap[handle];var data=heap[handle+1];return new TA(heap.buffer,data,size)}name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":decodeMemoryView,"argPackAdvance":8,"readValueFromPointer":decodeMemoryView},{ignoreDuplicateRegistrations:true})}function stringToUTF8(str,outPtr,maxBytesToWrite){return stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite)}function __embind_register_std_string(rawType,name){name=readLatin1String(name);var stdStringIsUTF8=name==="std::string";registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var payload=value+4;var str;if(stdStringIsUTF8){var decodeStartPtr=payload;for(var i=0;i<=length;++i){var currentBytePtr=payload+i;if(i==length||HEAPU8[currentBytePtr]==0){var maxRead=currentBytePtr-decodeStartPtr;var stringSegment=UTF8ToString(decodeStartPtr,maxRead);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+1}}}else{var a=new Array(length);for(var i=0;i>2]=length;if(stdStringIsUTF8&&valueIsOfTypeString){stringToUTF8(value,ptr,length+1)}else{if(valueIsOfTypeString){for(var i=0;i255){_free(ptr);throwBindingError("String has UTF-16 code units that do not fit in 8 bits")}HEAPU8[ptr+i]=charCode}}else{for(var i=0;i>1;var maxIdx=idx+maxBytesToRead/2;while(!(idx>=maxIdx)&&HEAPU16[idx])++idx;endPtr=idx<<1;if(endPtr-ptr>32&&UTF16Decoder)return UTF16Decoder.decode(HEAPU8.subarray(ptr,endPtr));var str="";for(var i=0;!(i>=maxBytesToRead/2);++i){var codeUnit=HEAP16[ptr+i*2>>1];if(codeUnit==0)break;str+=String.fromCharCode(codeUnit)}return str}function stringToUTF16(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647}if(maxBytesToWrite<2)return 0;maxBytesToWrite-=2;var startPtr=outPtr;var numCharsToWrite=maxBytesToWrite>1]=codeUnit;outPtr+=2}HEAP16[outPtr>>1]=0;return outPtr-startPtr}function lengthBytesUTF16(str){return str.length*2}function UTF32ToString(ptr,maxBytesToRead){var i=0;var str="";while(!(i>=maxBytesToRead/4)){var utf32=HEAP32[ptr+i*4>>2];if(utf32==0)break;++i;if(utf32>=65536){var ch=utf32-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}else{str+=String.fromCharCode(utf32)}}return str}function stringToUTF32(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647}if(maxBytesToWrite<4)return 0;var startPtr=outPtr;var endPtr=startPtr+maxBytesToWrite-4;for(var i=0;i=55296&&codeUnit<=57343){var trailSurrogate=str.charCodeAt(++i);codeUnit=65536+((codeUnit&1023)<<10)|trailSurrogate&1023}HEAP32[outPtr>>2]=codeUnit;outPtr+=4;if(outPtr+4>endPtr)break}HEAP32[outPtr>>2]=0;return outPtr-startPtr}function lengthBytesUTF32(str){var len=0;for(var i=0;i=55296&&codeUnit<=57343)++i;len+=4}return len}function __embind_register_std_wstring(rawType,charSize,name){name=readLatin1String(name);var decodeString,encodeString,getHeap,lengthBytesUTF,shift;if(charSize===2){decodeString=UTF16ToString;encodeString=stringToUTF16;lengthBytesUTF=lengthBytesUTF16;getHeap=()=>HEAPU16;shift=1}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;getHeap=()=>HEAPU32;shift=2}registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var HEAP=getHeap();var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||HEAP[currentBytePtr>>shift]==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str},"toWireType":function(destructors,value){if(!(typeof value=="string")){throwBindingError(`Cannot pass non-string to C++ string type ${name}`)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length>>shift;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:function(ptr){_free(ptr)}})}function __embind_register_value_object(rawType,name,constructorSignature,rawConstructor,destructorSignature,rawDestructor){structRegistrations[rawType]={name:readLatin1String(name),rawConstructor:embind__requireFunction(constructorSignature,rawConstructor),rawDestructor:embind__requireFunction(destructorSignature,rawDestructor),fields:[]}}function __embind_register_value_object_field(structType,fieldName,getterReturnType,getterSignature,getter,getterContext,setterArgumentType,setterSignature,setter,setterContext){structRegistrations[structType].fields.push({fieldName:readLatin1String(fieldName),getterReturnType:getterReturnType,getter:embind__requireFunction(getterSignature,getter),getterContext:getterContext,setterArgumentType:setterArgumentType,setter:embind__requireFunction(setterSignature,setter),setterContext:setterContext})}function __embind_register_void(rawType,name){name=readLatin1String(name);registerType(rawType,{isVoid:true,name:name,"argPackAdvance":0,"fromWireType":function(){return undefined},"toWireType":function(destructors,o){return undefined}})}function emval_allocateDestructors(destructorsRef){var destructors=[];HEAPU32[destructorsRef>>2]=Emval.toHandle(destructors);return destructors}var emval_symbols={};function getStringOrSymbol(address){var symbol=emval_symbols[address];if(symbol===undefined){return readLatin1String(address)}return symbol}var emval_methodCallers=[];function __emval_call_method(caller,handle,methodName,destructorsRef,args){caller=emval_methodCallers[caller];handle=Emval.toValue(handle);methodName=getStringOrSymbol(methodName);return caller(handle,methodName,emval_allocateDestructors(destructorsRef),args)}function __emval_call_void_method(caller,handle,methodName,args){caller=emval_methodCallers[caller];handle=Emval.toValue(handle);methodName=getStringOrSymbol(methodName);caller(handle,methodName,null,args)}function emval_addMethodCaller(caller){var id=emval_methodCallers.length;emval_methodCallers.push(caller);return id}function emval_lookupTypes(argCount,argTypes){var a=new Array(argCount);for(var i=0;i>2],"parameter "+i)}return a}var emval_registeredMethods=[];function __emval_get_method_caller(argCount,argTypes){var types=emval_lookupTypes(argCount,argTypes);var retType=types[0];var signatureName=retType.name+"_$"+types.slice(1).map(function(t){return t.name}).join("_")+"$";var returnId=emval_registeredMethods[signatureName];if(returnId!==undefined){return returnId}var argN=new Array(argCount-1);var invokerFunction=(handle,name,destructors,args)=>{var offset=0;for(var i=0;i4){emval_handles.get(handle).refcount+=1}}function __emval_run_destructors(handle){var destructors=Emval.toValue(handle);runDestructors(destructors);__emval_decref(handle)}function __emval_take_value(type,arg){type=requireRegisteredType(type,"_emval_take_value");var v=type["readValueFromPointer"](arg);return Emval.toHandle(v)}function _abort(){abort("")}function _emscripten_memcpy_big(dest,src,num){HEAPU8.copyWithin(dest,src,src+num)}function getHeapMax(){return 2147483648}function emscripten_realloc_buffer(size){var b=wasmMemory.buffer;var pages=size-b.byteLength+65535>>>16;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}}function _emscripten_resize_heap(requestedSize){var oldSize=HEAPU8.length;requestedSize=requestedSize>>>0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}var alignUp=(x,multiple)=>x+(multiple-x%multiple)%multiple;for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignUp(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=emscripten_realloc_buffer(newSize);if(replacement){return true}}return false}function _fd_close(fd){try{var stream=SYSCALLS.getStreamFromFD(fd);FS.close(stream);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function doReadv(stream,iov,iovcnt,offset){var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.read(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function convertI32PairToI53Checked(lo,hi){return hi+2097152>>>0<4194305-!!lo?(lo>>>0)+hi*4294967296:NaN}function _fd_seek(fd,offset_low,offset_high,whence,newOffset){try{var offset=convertI32PairToI53Checked(offset_low,offset_high);if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);FS.llseek(stream,offset,whence);tempI64=[stream.position>>>0,(tempDouble=stream.position,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[newOffset>>2]=tempI64[0],HEAP32[newOffset+4>>2]=tempI64[1];if(stream.getdents&&offset===0&&whence===0)stream.getdents=null;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function doWritev(stream,iov,iovcnt,offset){var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.write(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(typeof offset!=="undefined"){offset+=curr}}return ret}function _fd_write(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt);HEAPU32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var 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};var readMode=292|73;var writeMode=146;Object.defineProperties(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)}}});FS.FSNode=FSNode;FS.createPreloadedFile=FS_createPreloadedFile;FS.staticInit();BindingError=Module["BindingError"]=extendError(Error,"BindingError");init_emval();PureVirtualError=Module["PureVirtualError"]=extendError(Error,"PureVirtualError");embind_init_charCodes();init_embind();InternalError=Module["InternalError"]=extendError(Error,"InternalError");init_ClassHandle();init_RegisteredPointer();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");var decodeBase64=typeof atob=="function"?atob:function(input){var keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";var output="";var chr1,chr2,chr3;var enc1,enc2,enc3,enc4;var i=0;input=input.replace(/[^A-Za-z0-9\+\/\=]/g,"");do{enc1=keyStr.indexOf(input.charAt(i++));enc2=keyStr.indexOf(input.charAt(i++));enc3=keyStr.indexOf(input.charAt(i++));enc4=keyStr.indexOf(input.charAt(i++));chr1=enc1<<2|enc2>>4;chr2=(enc2&15)<<4|enc3>>2;chr3=(enc3&3)<<6|enc4;output=output+String.fromCharCode(chr1);if(enc3!==64){output=output+String.fromCharCode(chr2)}if(enc4!==64){output=output+String.fromCharCode(chr3)}}while(i0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("")},1);doRun()},1)}else{doRun()}}if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}run(); + + + return BOX2D.ready +} + +); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = BOX2D; +else if (typeof define === 'function' && define['amd']) + define([], function() { return BOX2D; }); +else if (typeof exports === 'object') + exports["BOX2D"] = BOX2D; diff --git a/emscripten/box2d/box2d.release.wasm.js b/emscripten/box2d/box2d.release.wasm.js new file mode 100644 index 000000000..fcdd6980a --- /dev/null +++ b/emscripten/box2d/box2d.release.wasm.js @@ -0,0 +1,21 @@ + +var BOX2D = (() => { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + + return ( +function(BOX2D = {}) { + +var Module=typeof BOX2D!="undefined"?BOX2D:{};var readyPromiseResolve,readyPromiseReject;Module["ready"]=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject});var moduleOverrides=Object.assign({},Module);var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var ENVIRONMENT_IS_WEB=true;var ENVIRONMENT_IS_WORKER=false;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var read_,readAsync,readBinary,setWindowTitle;if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src}if(_scriptDir){scriptDirectory=_scriptDir}if(scriptDirectory.indexOf("blob:")!==0){scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1)}else{scriptDirectory=""}{read_=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText};if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=(url,onload,onerror)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}onerror()};xhr.onerror=onerror;xhr.send(null)}}setWindowTitle=title=>document.title=title}else{}var out=Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.error.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["quit"])quit_=Module["quit"];var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];var noExitRuntime=Module["noExitRuntime"]||true;if(typeof WebAssembly!="object"){abort("no native wasm support detected")}var wasmMemory;var ABORT=false;var EXITSTATUS;function assert(condition,text){if(!condition){abort(text)}}var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateMemoryViews(){var b=wasmMemory.buffer;Module["HEAP8"]=HEAP8=new Int8Array(b);Module["HEAP16"]=HEAP16=new Int16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);Module["HEAPF64"]=HEAPF64=new Float64Array(b)}var wasmTable;var __ATPRERUN__=[];var __ATINIT__=[];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 initRuntime(){runtimeInitialized=true;callRuntimeCallbacks(__ATINIT__)}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)}function addOnInit(cb){__ATINIT__.unshift(cb)}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}var runDependencies=0;var runDependencyWatcher=null;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}}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()}}}function abort(what){if(Module["onAbort"]){Module["onAbort"](what)}what="Aborted("+what+")";err(what);ABORT=true;EXITSTATUS=1;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var dataURIPrefix="data:application/octet-stream;base64,";function isDataURI(filename){return filename.startsWith(dataURIPrefix)}var wasmBinaryFile;wasmBinaryFile="box2d.release.wasm.wasm";if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile)}function getBinary(file){try{if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}catch(err){abort(err)}}function getBinaryPromise(binaryFile){if(!wasmBinary&&(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)){if(typeof fetch=="function"){return fetch(binaryFile,{credentials:"same-origin"}).then(response=>{if(!response["ok"]){throw"failed to load wasm binary file at '"+binaryFile+"'"}return response["arrayBuffer"]()}).catch(()=>getBinary(binaryFile))}}return Promise.resolve().then(()=>getBinary(binaryFile))}function instantiateArrayBuffer(binaryFile,imports,receiver){return getBinaryPromise(binaryFile).then(binary=>{return WebAssembly.instantiate(binary,imports)}).then(instance=>{return instance}).then(receiver,reason=>{err("failed to asynchronously prepare wasm: "+reason);abort(reason)})}function instantiateAsync(binary,binaryFile,imports,callback){if(!binary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(binaryFile)&&typeof fetch=="function"){return fetch(binaryFile,{credentials:"same-origin"}).then(response=>{var result=WebAssembly.instantiateStreaming(response,imports);return result.then(callback,function(reason){err("wasm streaming compile failed: "+reason);err("falling back to ArrayBuffer instantiation");return instantiateArrayBuffer(binaryFile,imports,callback)})})}else{return instantiateArrayBuffer(binaryFile,imports,callback)}}function createWasm(){var info={"a":wasmImports};function receiveInstance(instance,module){var exports=instance.exports;Module["asm"]=exports;wasmMemory=Module["asm"]["O"];updateMemoryViews();wasmTable=Module["asm"]["Q"];addOnInit(Module["asm"]["P"]);removeRunDependency("wasm-instantiate");return exports}addRunDependency("wasm-instantiate");function receiveInstantiationResult(result){receiveInstance(result["instance"])}if(Module["instantiateWasm"]){try{return Module["instantiateWasm"](info,receiveInstance)}catch(e){err("Module.instantiateWasm callback failed with error: "+e);readyPromiseReject(e)}}instantiateAsync(wasmBinary,wasmBinaryFile,info,receiveInstantiationResult).catch(readyPromiseReject);return{}}function callRuntimeCallbacks(callbacks){while(callbacks.length>0){callbacks.shift()(Module)}}var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf8"):undefined;function UTF8ArrayToString(heapOrArray,idx,maxBytesToRead){var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx>10,56320|ch&1023)}}return str}function UTF8ToString(ptr,maxBytesToRead){return ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):""}function ___assert_fail(condition,filename,line,func){abort(`Assertion failed: ${UTF8ToString(condition)}, at: `+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"])}var SYSCALLS={varargs:undefined,get:function(){SYSCALLS.varargs+=4;var ret=HEAP32[SYSCALLS.varargs-4>>2];return ret},getStr:function(ptr){var ret=UTF8ToString(ptr);return ret}};function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;return 0}function ___syscall_ioctl(fd,op,varargs){SYSCALLS.varargs=varargs;return 0}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs}var char_0=48;var char_9=57;function makeLegalFunctionName(name){if(undefined===name){return"_unknown"}name=name.replace(/[^a-zA-Z0-9_]/g,"$");var f=name.charCodeAt(0);if(f>=char_0&&f<=char_9){return`_${name}`}return name}function createNamedFunction(name,body){name=makeLegalFunctionName(name);return{[name]:function(){return body.apply(this,arguments)}}[name]}function HandleAllocator(){this.allocated=[undefined];this.freelist=[];this.get=function(id){return this.allocated[id]};this.has=function(id){return this.allocated[id]!==undefined};this.allocate=function(handle){var id=this.freelist.pop()||this.allocated.length;this.allocated[id]=handle;return id};this.free=function(id){this.allocated[id]=undefined;this.freelist.push(id)}}var emval_handles=new HandleAllocator;function extendError(baseErrorType,errorName){var errorClass=createNamedFunction(errorName,function(message){this.name=errorName;this.message=message;var stack=new Error(message).stack;if(stack!==undefined){this.stack=this.toString()+"\n"+stack.replace(/^Error(:[^\n]*)?\n/,"")}});errorClass.prototype=Object.create(baseErrorType.prototype);errorClass.prototype.constructor=errorClass;errorClass.prototype.toString=function(){if(this.message===undefined){return this.name}else{return`${this.name}: ${this.message}`}};return errorClass}var BindingError=undefined;function throwBindingError(message){throw new BindingError(message)}function count_emval_handles(){var count=0;for(var i=emval_handles.reserved;i{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles.get(handle).value},toHandle:value=>{switch(value){case undefined:return 1;case null:return 2;case true:return 3;case false:return 4;default:{return emval_handles.allocate({refcount:1,value:value})}}}};var PureVirtualError=undefined;function embind_init_charCodes(){var codes=new Array(256);for(var i=0;i<256;++i){codes[i]=String.fromCharCode(i)}embind_charCodes=codes}var embind_charCodes=undefined;function readLatin1String(ptr){var ret="";var c=ptr;while(HEAPU8[c]){ret+=embind_charCodes[HEAPU8[c++]]}return ret}function getInheritedInstanceCount(){return Object.keys(registeredInstances).length}function getLiveInheritedInstances(){var rv=[];for(var k in registeredInstances){if(registeredInstances.hasOwnProperty(k)){rv.push(registeredInstances[k])}}return rv}var deletionQueue=[];function flushPendingDeletes(){while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]()}}var delayFunction=undefined;function setDelayFunction(fn){delayFunction=fn;if(deletionQueue.length&&delayFunction){delayFunction(flushPendingDeletes)}}function init_embind(){Module["getInheritedInstanceCount"]=getInheritedInstanceCount;Module["getLiveInheritedInstances"]=getLiveInheritedInstances;Module["flushPendingDeletes"]=flushPendingDeletes;Module["setDelayFunction"]=setDelayFunction}var registeredInstances={};function getBasestPointer(class_,ptr){if(ptr===undefined){throwBindingError("ptr should not be undefined")}while(class_.baseClass){ptr=class_.upcast(ptr);class_=class_.baseClass}return ptr}function registerInheritedInstance(class_,ptr,instance){ptr=getBasestPointer(class_,ptr);if(registeredInstances.hasOwnProperty(ptr)){throwBindingError(`Tried to register registered instance: ${ptr}`)}else{registeredInstances[ptr]=instance}}var registeredTypes={};function getTypeName(type){var ptr=___getTypeName(type);var rv=readLatin1String(ptr);_free(ptr);return rv}function requireRegisteredType(rawType,humanName){var impl=registeredTypes[rawType];if(undefined===impl){throwBindingError(humanName+" has unknown type "+getTypeName(rawType))}return impl}function unregisterInheritedInstance(class_,ptr){ptr=getBasestPointer(class_,ptr);if(registeredInstances.hasOwnProperty(ptr)){delete registeredInstances[ptr]}else{throwBindingError(`Tried to unregister unregistered instance: ${ptr}`)}}function detachFinalizer(handle){}var finalizationRegistry=false;function runDestructor($$){if($$.smartPtr){$$.smartPtrType.rawDestructor($$.smartPtr)}else{$$.ptrType.registeredClass.rawDestructor($$.ptr)}}function releaseClassHandle($$){$$.count.value-=1;var toDelete=0===$$.count.value;if(toDelete){runDestructor($$)}}function downcastPointer(ptr,ptrClass,desiredClass){if(ptrClass===desiredClass){return ptr}if(undefined===desiredClass.baseClass){return null}var rv=downcastPointer(ptr,ptrClass,desiredClass.baseClass);if(rv===null){return null}return desiredClass.downcast(rv)}var registeredPointers={};function getInheritedInstance(class_,ptr){ptr=getBasestPointer(class_,ptr);return registeredInstances[ptr]}var InternalError=undefined;function throwInternalError(message){throw new InternalError(message)}function makeClassHandle(prototype,record){if(!record.ptrType||!record.ptr){throwInternalError("makeClassHandle requires ptr and ptrType")}var hasSmartPtrType=!!record.smartPtrType;var hasSmartPtr=!!record.smartPtr;if(hasSmartPtrType!==hasSmartPtr){throwInternalError("Both smartPtrType and smartPtr must be specified")}record.count={value:1};return attachFinalizer(Object.create(prototype,{$$:{value:record}}))}function RegisteredPointer_fromWireType(ptr){var rawPointer=this.getPointee(ptr);if(!rawPointer){this.destructor(ptr);return null}var registeredInstance=getInheritedInstance(this.registeredClass,rawPointer);if(undefined!==registeredInstance){if(0===registeredInstance.$$.count.value){registeredInstance.$$.ptr=rawPointer;registeredInstance.$$.smartPtr=ptr;return registeredInstance["clone"]()}else{var rv=registeredInstance["clone"]();this.destructor(ptr);return rv}}function makeDefaultHandle(){if(this.isSmartPointer){return makeClassHandle(this.registeredClass.instancePrototype,{ptrType:this.pointeeType,ptr:rawPointer,smartPtrType:this,smartPtr:ptr})}else{return makeClassHandle(this.registeredClass.instancePrototype,{ptrType:this,ptr:ptr})}}var actualType=this.registeredClass.getActualType(rawPointer);var registeredPointerRecord=registeredPointers[actualType];if(!registeredPointerRecord){return makeDefaultHandle.call(this)}var toType;if(this.isConst){toType=registeredPointerRecord.constPointerType}else{toType=registeredPointerRecord.pointerType}var dp=downcastPointer(rawPointer,this.registeredClass,toType.registeredClass);if(dp===null){return makeDefaultHandle.call(this)}if(this.isSmartPointer){return makeClassHandle(toType.registeredClass.instancePrototype,{ptrType:toType,ptr:dp,smartPtrType:this,smartPtr:ptr})}else{return makeClassHandle(toType.registeredClass.instancePrototype,{ptrType:toType,ptr:dp})}}function attachFinalizer(handle){if("undefined"===typeof FinalizationRegistry){attachFinalizer=handle=>handle;return handle}finalizationRegistry=new FinalizationRegistry(info=>{releaseClassHandle(info.$$)});attachFinalizer=handle=>{var $$=handle.$$;var hasSmartPtr=!!$$.smartPtr;if(hasSmartPtr){var info={$$:$$};finalizationRegistry.register(handle,info,handle)}return handle};detachFinalizer=handle=>finalizationRegistry.unregister(handle);return attachFinalizer(handle)}function __embind_create_inheriting_constructor(constructorName,wrapperType,properties){constructorName=readLatin1String(constructorName);wrapperType=requireRegisteredType(wrapperType,"wrapper");properties=Emval.toValue(properties);var arraySlice=[].slice;var registeredClass=wrapperType.registeredClass;var wrapperPrototype=registeredClass.instancePrototype;var baseClass=registeredClass.baseClass;var baseClassPrototype=baseClass.instancePrototype;var baseConstructor=registeredClass.baseClass.constructor;var ctor=createNamedFunction(constructorName,function(){registeredClass.baseClass.pureVirtualFunctions.forEach(function(name){if(this[name]===baseClassPrototype[name]){throw new PureVirtualError(`Pure virtual function ${name} must be implemented in JavaScript`)}}.bind(this));Object.defineProperty(this,"__parent",{value:wrapperPrototype});this["__construct"].apply(this,arraySlice.call(arguments))});wrapperPrototype["__construct"]=function __construct(){if(this===wrapperPrototype){throwBindingError("Pass correct 'this' to __construct")}var inner=baseConstructor["implement"].apply(undefined,[this].concat(arraySlice.call(arguments)));detachFinalizer(inner);var $$=inner.$$;inner["notifyOnDestruction"]();$$.preservePointerOnDelete=true;Object.defineProperties(this,{$$:{value:$$}});attachFinalizer(this);registerInheritedInstance(registeredClass,$$.ptr,this)};wrapperPrototype["__destruct"]=function __destruct(){if(this===wrapperPrototype){throwBindingError("Pass correct 'this' to __destruct")}detachFinalizer(this);unregisterInheritedInstance(registeredClass,this.$$.ptr)};ctor.prototype=Object.create(wrapperPrototype);for(var p in properties){ctor.prototype[p]=properties[p]}return Emval.toHandle(ctor)}var structRegistrations={};function runDestructors(destructors){while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr)}}function simpleReadValueFromPointer(pointer){return this["fromWireType"](HEAP32[pointer>>2])}var awaitingDependencies={};var typeDependencies={};function whenDependentTypesAreResolved(myTypes,dependentTypes,getTypeConverters){myTypes.forEach(function(type){typeDependencies[type]=dependentTypes});function onComplete(typeConverters){var myTypeConverters=getTypeConverters(typeConverters);if(myTypeConverters.length!==myTypes.length){throwInternalError("Mismatched type converter count")}for(var i=0;i{if(registeredTypes.hasOwnProperty(dt)){typeConverters[i]=registeredTypes[dt]}else{unregisteredTypes.push(dt);if(!awaitingDependencies.hasOwnProperty(dt)){awaitingDependencies[dt]=[]}awaitingDependencies[dt].push(()=>{typeConverters[i]=registeredTypes[dt];++registered;if(registered===unregisteredTypes.length){onComplete(typeConverters)}})}});if(0===unregisteredTypes.length){onComplete(typeConverters)}}function __embind_finalize_value_object(structType){var reg=structRegistrations[structType];delete structRegistrations[structType];var rawConstructor=reg.rawConstructor;var rawDestructor=reg.rawDestructor;var fieldRecords=reg.fields;var fieldTypes=fieldRecords.map(field=>field.getterReturnType).concat(fieldRecords.map(field=>field.setterArgumentType));whenDependentTypesAreResolved([structType],fieldTypes,fieldTypes=>{var fields={};fieldRecords.forEach((field,i)=>{var fieldName=field.fieldName;var getterReturnType=fieldTypes[i];var getter=field.getter;var getterContext=field.getterContext;var setterArgumentType=fieldTypes[i+fieldRecords.length];var setter=field.setter;var setterContext=field.setterContext;fields[fieldName]={read:ptr=>{return getterReturnType["fromWireType"](getter(getterContext,ptr))},write:(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}}});return[{name:reg.name,"fromWireType":function(ptr){var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv},"toWireType":function(destructors,o){for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError(`Missing field: "${fieldName}"`)}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:rawDestructor}]})}function __embind_register_bigint(primitiveType,name,size,minRange,maxRange){}function getShiftFromSize(size){switch(size){case 1:return 0;case 2:return 1;case 4:return 2;case 8:return 3;default:throw new TypeError(`Unknown type size: ${size}`)}}function registerType(rawType,registeredInstance,options={}){if(!("argPackAdvance"in registeredInstance)){throw new TypeError("registerType registeredInstance requires argPackAdvance")}var name=registeredInstance.name;if(!rawType){throwBindingError(`type "${name}" must have a positive integer typeid pointer`)}if(registeredTypes.hasOwnProperty(rawType)){if(options.ignoreDuplicateRegistrations){return}else{throwBindingError(`Cannot register type '${name}' twice`)}}registeredTypes[rawType]=registeredInstance;delete typeDependencies[rawType];if(awaitingDependencies.hasOwnProperty(rawType)){var callbacks=awaitingDependencies[rawType];delete awaitingDependencies[rawType];callbacks.forEach(cb=>cb())}}function __embind_register_bool(rawType,name,size,trueValue,falseValue){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(wt){return!!wt},"toWireType":function(destructors,o){return o?trueValue:falseValue},"argPackAdvance":8,"readValueFromPointer":function(pointer){var heap;if(size===1){heap=HEAP8}else if(size===2){heap=HEAP16}else if(size===4){heap=HEAP32}else{throw new TypeError("Unknown boolean type size: "+name)}return this["fromWireType"](heap[pointer>>shift])},destructorFunction:null})}function ClassHandle_isAliasOf(other){if(!(this instanceof ClassHandle)){return false}if(!(other instanceof ClassHandle)){return false}var leftClass=this.$$.ptrType.registeredClass;var left=this.$$.ptr;var rightClass=other.$$.ptrType.registeredClass;var right=other.$$.ptr;while(leftClass.baseClass){left=leftClass.upcast(left);leftClass=leftClass.baseClass}while(rightClass.baseClass){right=rightClass.upcast(right);rightClass=rightClass.baseClass}return leftClass===rightClass&&left===right}function shallowCopyInternalPointer(o){return{count:o.count,deleteScheduled:o.deleteScheduled,preservePointerOnDelete:o.preservePointerOnDelete,ptr:o.ptr,ptrType:o.ptrType,smartPtr:o.smartPtr,smartPtrType:o.smartPtrType}}function throwInstanceAlreadyDeleted(obj){function getInstanceTypeName(handle){return handle.$$.ptrType.registeredClass.name}throwBindingError(getInstanceTypeName(obj)+" instance already deleted")}function ClassHandle_clone(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.preservePointerOnDelete){this.$$.count.value+=1;return this}else{var clone=attachFinalizer(Object.create(Object.getPrototypeOf(this),{$$:{value:shallowCopyInternalPointer(this.$$)}}));clone.$$.count.value+=1;clone.$$.deleteScheduled=false;return clone}}function ClassHandle_delete(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}detachFinalizer(this);releaseClassHandle(this.$$);if(!this.$$.preservePointerOnDelete){this.$$.smartPtr=undefined;this.$$.ptr=undefined}}function ClassHandle_isDeleted(){return!this.$$.ptr}function ClassHandle_deleteLater(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}deletionQueue.push(this);if(deletionQueue.length===1&&delayFunction){delayFunction(flushPendingDeletes)}this.$$.deleteScheduled=true;return this}function init_ClassHandle(){ClassHandle.prototype["isAliasOf"]=ClassHandle_isAliasOf;ClassHandle.prototype["clone"]=ClassHandle_clone;ClassHandle.prototype["delete"]=ClassHandle_delete;ClassHandle.prototype["isDeleted"]=ClassHandle_isDeleted;ClassHandle.prototype["deleteLater"]=ClassHandle_deleteLater}function ClassHandle(){}function ensureOverloadTable(proto,methodName,humanName){if(undefined===proto[methodName].overloadTable){var prevFunc=proto[methodName];proto[methodName]=function(){if(!proto[methodName].overloadTable.hasOwnProperty(arguments.length)){throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${arguments.length}) - expects one of (${proto[methodName].overloadTable})!`)}return proto[methodName].overloadTable[arguments.length].apply(this,arguments)};proto[methodName].overloadTable=[];proto[methodName].overloadTable[prevFunc.argCount]=prevFunc}}function exposePublicSymbol(name,value,numArguments){if(Module.hasOwnProperty(name)){if(undefined===numArguments||undefined!==Module[name].overloadTable&&undefined!==Module[name].overloadTable[numArguments]){throwBindingError(`Cannot register public name '${name}' twice`)}ensureOverloadTable(Module,name,name);if(Module.hasOwnProperty(numArguments)){throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`)}Module[name].overloadTable[numArguments]=value}else{Module[name]=value;if(undefined!==numArguments){Module[name].numArguments=numArguments}}}function RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast){this.name=name;this.constructor=constructor;this.instancePrototype=instancePrototype;this.rawDestructor=rawDestructor;this.baseClass=baseClass;this.getActualType=getActualType;this.upcast=upcast;this.downcast=downcast;this.pureVirtualFunctions=[]}function upcastPointer(ptr,ptrClass,desiredClass){while(ptrClass!==desiredClass){if(!ptrClass.upcast){throwBindingError(`Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`)}ptr=ptrClass.upcast(ptr);ptrClass=ptrClass.baseClass}return ptr}function constNoSmartPtrRawPointerToWireType(destructors,handle){if(handle===null){if(this.isReference){throwBindingError(`null is not a valid ${this.name}`)}return 0}if(!handle.$$){throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)}if(!handle.$$.ptr){throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function genericPointerToWireType(destructors,handle){var ptr;if(handle===null){if(this.isReference){throwBindingError(`null is not a valid ${this.name}`)}if(this.isSmartPointer){ptr=this.rawConstructor();if(destructors!==null){destructors.push(this.rawDestructor,ptr)}return ptr}else{return 0}}if(!handle.$$){throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)}if(!handle.$$.ptr){throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)}if(!this.isConst&&handle.$$.ptrType.isConst){throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType?handle.$$.smartPtrType.name:handle.$$.ptrType.name} to parameter type ${this.name}`)}var handleClass=handle.$$.ptrType.registeredClass;ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);if(this.isSmartPointer){if(undefined===handle.$$.smartPtr){throwBindingError("Passing raw pointer to smart pointer is illegal")}switch(this.sharingPolicy){case 0:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType?handle.$$.smartPtrType.name:handle.$$.ptrType.name} to parameter type ${this.name}`)}break;case 1:ptr=handle.$$.smartPtr;break;case 2:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{var clonedHandle=handle["clone"]();ptr=this.rawShare(ptr,Emval.toHandle(function(){clonedHandle["delete"]()}));if(destructors!==null){destructors.push(this.rawDestructor,ptr)}}break;default:throwBindingError("Unsupporting sharing policy")}}return ptr}function nonConstNoSmartPtrRawPointerToWireType(destructors,handle){if(handle===null){if(this.isReference){throwBindingError(`null is not a valid ${this.name}`)}return 0}if(!handle.$$){throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)}if(!handle.$$.ptr){throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)}if(handle.$$.ptrType.isConst){throwBindingError(`Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`)}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function RegisteredPointer_getPointee(ptr){if(this.rawGetPointee){ptr=this.rawGetPointee(ptr)}return ptr}function RegisteredPointer_destructor(ptr){if(this.rawDestructor){this.rawDestructor(ptr)}}function RegisteredPointer_deleteObject(handle){if(handle!==null){handle["delete"]()}}function init_RegisteredPointer(){RegisteredPointer.prototype.getPointee=RegisteredPointer_getPointee;RegisteredPointer.prototype.destructor=RegisteredPointer_destructor;RegisteredPointer.prototype["argPackAdvance"]=8;RegisteredPointer.prototype["readValueFromPointer"]=simpleReadValueFromPointer;RegisteredPointer.prototype["deleteObject"]=RegisteredPointer_deleteObject;RegisteredPointer.prototype["fromWireType"]=RegisteredPointer_fromWireType}function RegisteredPointer(name,registeredClass,isReference,isConst,isSmartPointer,pointeeType,sharingPolicy,rawGetPointee,rawConstructor,rawShare,rawDestructor){this.name=name;this.registeredClass=registeredClass;this.isReference=isReference;this.isConst=isConst;this.isSmartPointer=isSmartPointer;this.pointeeType=pointeeType;this.sharingPolicy=sharingPolicy;this.rawGetPointee=rawGetPointee;this.rawConstructor=rawConstructor;this.rawShare=rawShare;this.rawDestructor=rawDestructor;if(!isSmartPointer&®isteredClass.baseClass===undefined){if(isConst){this["toWireType"]=constNoSmartPtrRawPointerToWireType;this.destructorFunction=null}else{this["toWireType"]=nonConstNoSmartPtrRawPointerToWireType;this.destructorFunction=null}}else{this["toWireType"]=genericPointerToWireType}}function replacePublicSymbol(name,value,numArguments){if(!Module.hasOwnProperty(name)){throwInternalError("Replacing nonexistant public symbol")}if(undefined!==Module[name].overloadTable&&undefined!==numArguments){Module[name].overloadTable[numArguments]=value}else{Module[name]=value;Module[name].argCount=numArguments}}function dynCallLegacy(sig,ptr,args){var f=Module["dynCall_"+sig];return args&&args.length?f.apply(null,[ptr].concat(args)):f.call(null,ptr)}var wasmTableMirror=[];function getWasmTableEntry(funcPtr){var func=wasmTableMirror[funcPtr];if(!func){if(funcPtr>=wasmTableMirror.length)wasmTableMirror.length=funcPtr+1;wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}return func}function dynCall(sig,ptr,args){if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}var rtn=getWasmTableEntry(ptr).apply(null,args);return rtn}function getDynCaller(sig,ptr){var argCache=[];return function(){argCache.length=0;Object.assign(argCache,arguments);return dynCall(sig,ptr,argCache)}}function embind__requireFunction(signature,rawFunction){signature=readLatin1String(signature);function makeDynCaller(){if(signature.includes("j")){return getDynCaller(signature,rawFunction)}return getWasmTableEntry(rawFunction)}var fp=makeDynCaller();if(typeof fp!="function"){throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`)}return fp}var UnboundTypeError=undefined;function throwUnboundTypeError(message,types){var unboundTypes=[];var seen={};function visit(type){if(seen[type]){return}if(registeredTypes[type]){return}if(typeDependencies[type]){typeDependencies[type].forEach(visit);return}unboundTypes.push(type);seen[type]=true}types.forEach(visit);throw new UnboundTypeError(`${message}: `+unboundTypes.map(getTypeName).join([", "]))}function __embind_register_class(rawType,rawPointerType,rawConstPointerType,baseClassRawType,getActualTypeSignature,getActualType,upcastSignature,upcast,downcastSignature,downcast,name,destructorSignature,rawDestructor){name=readLatin1String(name);getActualType=embind__requireFunction(getActualTypeSignature,getActualType);if(upcast){upcast=embind__requireFunction(upcastSignature,upcast)}if(downcast){downcast=embind__requireFunction(downcastSignature,downcast)}rawDestructor=embind__requireFunction(destructorSignature,rawDestructor);var legalFunctionName=makeLegalFunctionName(name);exposePublicSymbol(legalFunctionName,function(){throwUnboundTypeError(`Cannot construct ${name} due to unbound types`,[baseClassRawType])});whenDependentTypesAreResolved([rawType,rawPointerType,rawConstPointerType],baseClassRawType?[baseClassRawType]:[],function(base){base=base[0];var baseClass;var basePrototype;if(baseClassRawType){baseClass=base.registeredClass;basePrototype=baseClass.instancePrototype}else{basePrototype=ClassHandle.prototype}var constructor=createNamedFunction(legalFunctionName,function(){if(Object.getPrototypeOf(this)!==instancePrototype){throw new BindingError("Use 'new' to construct "+name)}if(undefined===registeredClass.constructor_body){throw new BindingError(name+" has no accessible constructor")}var body=registeredClass.constructor_body[arguments.length];if(undefined===body){throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${arguments.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`)}return body.apply(this,arguments)});var instancePrototype=Object.create(basePrototype,{constructor:{value:constructor}});constructor.prototype=instancePrototype;var registeredClass=new RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast);if(registeredClass.baseClass){if(registeredClass.baseClass.__derivedClasses===undefined){registeredClass.baseClass.__derivedClasses=[]}registeredClass.baseClass.__derivedClasses.push(registeredClass)}var referenceConverter=new RegisteredPointer(name,registeredClass,true,false,false);var pointerConverter=new RegisteredPointer(name+"*",registeredClass,false,false,false);var constPointerConverter=new RegisteredPointer(name+" const*",registeredClass,false,true,false);registeredPointers[rawType]={pointerType:pointerConverter,constPointerType:constPointerConverter};replacePublicSymbol(legalFunctionName,constructor);return[referenceConverter,pointerConverter,constPointerConverter]})}function craftInvokerFunction(humanName,argTypes,classType,cppInvokerFunc,cppTargetFunc,isAsync){var argCount=argTypes.length;if(argCount<2){throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!")}var isClassMethodFunc=argTypes[1]!==null&&classType!==null;var needsDestructorStack=false;for(var i=1;i>2])}return array}function __embind_register_class_class_function(rawClassType,methodName,argCount,rawArgTypesAddr,invokerSignature,rawInvoker,fn,isAsync){var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);methodName=readLatin1String(methodName);rawInvoker=embind__requireFunction(invokerSignature,rawInvoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName=`${classType.name}.${methodName}`;function unboundTypesHandler(){throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`,rawArgTypes)}if(methodName.startsWith("@@")){methodName=Symbol[methodName.substring(2)]}var proto=classType.registeredClass.constructor;if(undefined===proto[methodName]){unboundTypesHandler.argCount=argCount-1;proto[methodName]=unboundTypesHandler}else{ensureOverloadTable(proto,methodName,humanName);proto[methodName].overloadTable[argCount-1]=unboundTypesHandler}whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){var invokerArgsArray=[argTypes[0],null].concat(argTypes.slice(1));var func=craftInvokerFunction(humanName,invokerArgsArray,null,rawInvoker,fn,isAsync);if(undefined===proto[methodName].overloadTable){func.argCount=argCount-1;proto[methodName]=func}else{proto[methodName].overloadTable[argCount-1]=func}if(classType.registeredClass.__derivedClasses){for(const derivedClass of classType.registeredClass.__derivedClasses){if(!derivedClass.constructor.hasOwnProperty(methodName)){derivedClass.constructor[methodName]=func}}}return[]});return[]})}function __embind_register_class_constructor(rawClassType,argCount,rawArgTypesAddr,invokerSignature,invoker,rawConstructor){assert(argCount>0);var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);invoker=embind__requireFunction(invokerSignature,invoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName=`constructor ${classType.name}`;if(undefined===classType.registeredClass.constructor_body){classType.registeredClass.constructor_body=[]}if(undefined!==classType.registeredClass.constructor_body[argCount-1]){throw new BindingError(`Cannot register multiple constructors with identical number of parameters (${argCount-1}) for class '${classType.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`)}classType.registeredClass.constructor_body[argCount-1]=()=>{throwUnboundTypeError(`Cannot construct ${classType.name} due to unbound types`,rawArgTypes)};whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){argTypes.splice(1,0,null);classType.registeredClass.constructor_body[argCount-1]=craftInvokerFunction(humanName,argTypes,null,invoker,rawConstructor);return[]});return[]})}function __embind_register_class_function(rawClassType,methodName,argCount,rawArgTypesAddr,invokerSignature,rawInvoker,context,isPureVirtual,isAsync){var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);methodName=readLatin1String(methodName);rawInvoker=embind__requireFunction(invokerSignature,rawInvoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName=`${classType.name}.${methodName}`;if(methodName.startsWith("@@")){methodName=Symbol[methodName.substring(2)]}if(isPureVirtual){classType.registeredClass.pureVirtualFunctions.push(methodName)}function unboundTypesHandler(){throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`,rawArgTypes)}var proto=classType.registeredClass.instancePrototype;var method=proto[methodName];if(undefined===method||undefined===method.overloadTable&&method.className!==classType.name&&method.argCount===argCount-2){unboundTypesHandler.argCount=argCount-2;unboundTypesHandler.className=classType.name;proto[methodName]=unboundTypesHandler}else{ensureOverloadTable(proto,methodName,humanName);proto[methodName].overloadTable[argCount-2]=unboundTypesHandler}whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){var memberFunction=craftInvokerFunction(humanName,argTypes,classType,rawInvoker,context,isAsync);if(undefined===proto[methodName].overloadTable){memberFunction.argCount=argCount-2;proto[methodName]=memberFunction}else{proto[methodName].overloadTable[argCount-2]=memberFunction}return[]});return[]})}function validateThis(this_,classType,humanName){if(!(this_ instanceof Object)){throwBindingError(`${humanName} with invalid "this": ${this_}`)}if(!(this_ instanceof classType.registeredClass.constructor)){throwBindingError(`${humanName} incompatible with "this" of type ${this_.constructor.name}`)}if(!this_.$$.ptr){throwBindingError(`cannot call emscripten binding method ${humanName} on deleted object`)}return upcastPointer(this_.$$.ptr,this_.$$.ptrType.registeredClass,classType.registeredClass)}function __embind_register_class_property(classType,fieldName,getterReturnType,getterSignature,getter,getterContext,setterArgumentType,setterSignature,setter,setterContext){fieldName=readLatin1String(fieldName);getter=embind__requireFunction(getterSignature,getter);whenDependentTypesAreResolved([],[classType],function(classType){classType=classType[0];var humanName=`${classType.name}.${fieldName}`;var desc={get:function(){throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`,[getterReturnType,setterArgumentType])},enumerable:true,configurable:true};if(setter){desc.set=()=>{throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`,[getterReturnType,setterArgumentType])}}else{desc.set=v=>{throwBindingError(humanName+" is a read-only property")}}Object.defineProperty(classType.registeredClass.instancePrototype,fieldName,desc);whenDependentTypesAreResolved([],setter?[getterReturnType,setterArgumentType]:[getterReturnType],function(types){var getterReturnType=types[0];var desc={get:function(){var ptr=validateThis(this,classType,humanName+" getter");return getterReturnType["fromWireType"](getter(getterContext,ptr))},enumerable:true};if(setter){setter=embind__requireFunction(setterSignature,setter);var setterArgumentType=types[1];desc.set=function(v){var ptr=validateThis(this,classType,humanName+" setter");var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,v));runDestructors(destructors)}}Object.defineProperty(classType.registeredClass.instancePrototype,fieldName,desc);return[]});return[]})}function __embind_register_constant(name,type,value){name=readLatin1String(name);whenDependentTypesAreResolved([],[type],function(type){type=type[0];Module[name]=type["fromWireType"](value);return[]})}function __emval_decref(handle){if(handle>=emval_handles.reserved&&0===--emval_handles.get(handle).refcount){emval_handles.free(handle)}}function __embind_register_emval(rawType,name){name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(handle){var rv=Emval.toValue(handle);__emval_decref(handle);return rv},"toWireType":function(destructors,value){return Emval.toHandle(value)},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:null})}function enumReadValueFromPointer(name,shift,signed){switch(shift){case 0:return function(pointer){var heap=signed?HEAP8:HEAPU8;return this["fromWireType"](heap[pointer])};case 1:return function(pointer){var heap=signed?HEAP16:HEAPU16;return this["fromWireType"](heap[pointer>>1])};case 2:return function(pointer){var heap=signed?HEAP32:HEAPU32;return this["fromWireType"](heap[pointer>>2])};default:throw new TypeError("Unknown integer type: "+name)}}function __embind_register_enum(rawType,name,size,isSigned){var shift=getShiftFromSize(size);name=readLatin1String(name);function ctor(){}ctor.values={};registerType(rawType,{name:name,constructor:ctor,"fromWireType":function(c){return this.constructor.values[c]},"toWireType":function(destructors,c){return c.value},"argPackAdvance":8,"readValueFromPointer":enumReadValueFromPointer(name,shift,isSigned),destructorFunction:null});exposePublicSymbol(name,ctor)}function __embind_register_enum_value(rawEnumType,name,enumValue){var enumType=requireRegisteredType(rawEnumType,"enum");name=readLatin1String(name);var Enum=enumType.constructor;var Value=Object.create(enumType.constructor.prototype,{value:{value:enumValue},constructor:{value:createNamedFunction(`${enumType.name}_${name}`,function(){})}});Enum.values[enumValue]=Value;Enum[name]=Value}function embindRepr(v){if(v===null){return"null"}var t=typeof v;if(t==="object"||t==="array"||t==="function"){return v.toString()}else{return""+v}}function floatReadValueFromPointer(name,shift){switch(shift){case 2:return function(pointer){return this["fromWireType"](HEAPF32[pointer>>2])};case 3:return function(pointer){return this["fromWireType"](HEAPF64[pointer>>3])};default:throw new TypeError("Unknown float type: "+name)}}function __embind_register_float(rawType,name,size){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(value){return value},"toWireType":function(destructors,value){return value},"argPackAdvance":8,"readValueFromPointer":floatReadValueFromPointer(name,shift),destructorFunction:null})}function __embind_register_function(name,argCount,rawArgTypesAddr,signature,rawInvoker,fn,isAsync){var argTypes=heap32VectorToArray(argCount,rawArgTypesAddr);name=readLatin1String(name);rawInvoker=embind__requireFunction(signature,rawInvoker);exposePublicSymbol(name,function(){throwUnboundTypeError(`Cannot call ${name} due to unbound types`,argTypes)},argCount-1);whenDependentTypesAreResolved([],argTypes,function(argTypes){var invokerArgsArray=[argTypes[0],null].concat(argTypes.slice(1));replacePublicSymbol(name,craftInvokerFunction(name,invokerArgsArray,null,rawInvoker,fn,isAsync),argCount-1);return[]})}function integerReadValueFromPointer(name,shift,signed){switch(shift){case 0:return signed?function readS8FromPointer(pointer){return HEAP8[pointer]}:function readU8FromPointer(pointer){return HEAPU8[pointer]};case 1:return signed?function readS16FromPointer(pointer){return HEAP16[pointer>>1]}:function readU16FromPointer(pointer){return HEAPU16[pointer>>1]};case 2:return signed?function readS32FromPointer(pointer){return HEAP32[pointer>>2]}:function readU32FromPointer(pointer){return HEAPU32[pointer>>2]};default:throw new TypeError("Unknown integer type: "+name)}}function __embind_register_integer(primitiveType,name,size,minRange,maxRange){name=readLatin1String(name);if(maxRange===-1){maxRange=4294967295}var shift=getShiftFromSize(size);var fromWireType=value=>value;if(minRange===0){var bitshift=32-8*size;fromWireType=value=>value<>>bitshift}var isUnsignedType=name.includes("unsigned");var checkAssertions=(value,toTypeName)=>{};var toWireType;if(isUnsignedType){toWireType=function(destructors,value){checkAssertions(value,this.name);return value>>>0}}else{toWireType=function(destructors,value){checkAssertions(value,this.name);return value}}registerType(primitiveType,{name:name,"fromWireType":fromWireType,"toWireType":toWireType,"argPackAdvance":8,"readValueFromPointer":integerReadValueFromPointer(name,shift,minRange!==0),destructorFunction:null})}function __embind_register_memory_view(rawType,dataTypeIndex,name){var typeMapping=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array];var TA=typeMapping[dataTypeIndex];function decodeMemoryView(handle){handle=handle>>2;var heap=HEAPU32;var size=heap[handle];var data=heap[handle+1];return new TA(heap.buffer,data,size)}name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":decodeMemoryView,"argPackAdvance":8,"readValueFromPointer":decodeMemoryView},{ignoreDuplicateRegistrations:true})}function stringToUTF8Array(str,heap,outIdx,maxBytesToWrite){if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}}heap[outIdx]=0;return outIdx-startIdx}function stringToUTF8(str,outPtr,maxBytesToWrite){return stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite)}function lengthBytesUTF8(str){var len=0;for(var i=0;i=55296&&c<=57343){len+=4;++i}else{len+=3}}return len}function __embind_register_std_string(rawType,name){name=readLatin1String(name);var stdStringIsUTF8=name==="std::string";registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var payload=value+4;var str;if(stdStringIsUTF8){var decodeStartPtr=payload;for(var i=0;i<=length;++i){var currentBytePtr=payload+i;if(i==length||HEAPU8[currentBytePtr]==0){var maxRead=currentBytePtr-decodeStartPtr;var stringSegment=UTF8ToString(decodeStartPtr,maxRead);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+1}}}else{var a=new Array(length);for(var i=0;i>2]=length;if(stdStringIsUTF8&&valueIsOfTypeString){stringToUTF8(value,ptr,length+1)}else{if(valueIsOfTypeString){for(var i=0;i255){_free(ptr);throwBindingError("String has UTF-16 code units that do not fit in 8 bits")}HEAPU8[ptr+i]=charCode}}else{for(var i=0;i>1;var maxIdx=idx+maxBytesToRead/2;while(!(idx>=maxIdx)&&HEAPU16[idx])++idx;endPtr=idx<<1;if(endPtr-ptr>32&&UTF16Decoder)return UTF16Decoder.decode(HEAPU8.subarray(ptr,endPtr));var str="";for(var i=0;!(i>=maxBytesToRead/2);++i){var codeUnit=HEAP16[ptr+i*2>>1];if(codeUnit==0)break;str+=String.fromCharCode(codeUnit)}return str}function stringToUTF16(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647}if(maxBytesToWrite<2)return 0;maxBytesToWrite-=2;var startPtr=outPtr;var numCharsToWrite=maxBytesToWrite>1]=codeUnit;outPtr+=2}HEAP16[outPtr>>1]=0;return outPtr-startPtr}function lengthBytesUTF16(str){return str.length*2}function UTF32ToString(ptr,maxBytesToRead){var i=0;var str="";while(!(i>=maxBytesToRead/4)){var utf32=HEAP32[ptr+i*4>>2];if(utf32==0)break;++i;if(utf32>=65536){var ch=utf32-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}else{str+=String.fromCharCode(utf32)}}return str}function stringToUTF32(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647}if(maxBytesToWrite<4)return 0;var startPtr=outPtr;var endPtr=startPtr+maxBytesToWrite-4;for(var i=0;i=55296&&codeUnit<=57343){var trailSurrogate=str.charCodeAt(++i);codeUnit=65536+((codeUnit&1023)<<10)|trailSurrogate&1023}HEAP32[outPtr>>2]=codeUnit;outPtr+=4;if(outPtr+4>endPtr)break}HEAP32[outPtr>>2]=0;return outPtr-startPtr}function lengthBytesUTF32(str){var len=0;for(var i=0;i=55296&&codeUnit<=57343)++i;len+=4}return len}function __embind_register_std_wstring(rawType,charSize,name){name=readLatin1String(name);var decodeString,encodeString,getHeap,lengthBytesUTF,shift;if(charSize===2){decodeString=UTF16ToString;encodeString=stringToUTF16;lengthBytesUTF=lengthBytesUTF16;getHeap=()=>HEAPU16;shift=1}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;getHeap=()=>HEAPU32;shift=2}registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var HEAP=getHeap();var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||HEAP[currentBytePtr>>shift]==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str},"toWireType":function(destructors,value){if(!(typeof value=="string")){throwBindingError(`Cannot pass non-string to C++ string type ${name}`)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length>>shift;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:function(ptr){_free(ptr)}})}function __embind_register_value_object(rawType,name,constructorSignature,rawConstructor,destructorSignature,rawDestructor){structRegistrations[rawType]={name:readLatin1String(name),rawConstructor:embind__requireFunction(constructorSignature,rawConstructor),rawDestructor:embind__requireFunction(destructorSignature,rawDestructor),fields:[]}}function __embind_register_value_object_field(structType,fieldName,getterReturnType,getterSignature,getter,getterContext,setterArgumentType,setterSignature,setter,setterContext){structRegistrations[structType].fields.push({fieldName:readLatin1String(fieldName),getterReturnType:getterReturnType,getter:embind__requireFunction(getterSignature,getter),getterContext:getterContext,setterArgumentType:setterArgumentType,setter:embind__requireFunction(setterSignature,setter),setterContext:setterContext})}function __embind_register_void(rawType,name){name=readLatin1String(name);registerType(rawType,{isVoid:true,name:name,"argPackAdvance":0,"fromWireType":function(){return undefined},"toWireType":function(destructors,o){return undefined}})}function emval_allocateDestructors(destructorsRef){var destructors=[];HEAPU32[destructorsRef>>2]=Emval.toHandle(destructors);return destructors}var emval_symbols={};function getStringOrSymbol(address){var symbol=emval_symbols[address];if(symbol===undefined){return readLatin1String(address)}return symbol}var emval_methodCallers=[];function __emval_call_method(caller,handle,methodName,destructorsRef,args){caller=emval_methodCallers[caller];handle=Emval.toValue(handle);methodName=getStringOrSymbol(methodName);return caller(handle,methodName,emval_allocateDestructors(destructorsRef),args)}function __emval_call_void_method(caller,handle,methodName,args){caller=emval_methodCallers[caller];handle=Emval.toValue(handle);methodName=getStringOrSymbol(methodName);caller(handle,methodName,null,args)}function emval_addMethodCaller(caller){var id=emval_methodCallers.length;emval_methodCallers.push(caller);return id}function emval_lookupTypes(argCount,argTypes){var a=new Array(argCount);for(var i=0;i>2],"parameter "+i)}return a}var emval_registeredMethods=[];function __emval_get_method_caller(argCount,argTypes){var types=emval_lookupTypes(argCount,argTypes);var retType=types[0];var signatureName=retType.name+"_$"+types.slice(1).map(function(t){return t.name}).join("_")+"$";var returnId=emval_registeredMethods[signatureName];if(returnId!==undefined){return returnId}var argN=new Array(argCount-1);var invokerFunction=(handle,name,destructors,args)=>{var offset=0;for(var i=0;i4){emval_handles.get(handle).refcount+=1}}function __emval_run_destructors(handle){var destructors=Emval.toValue(handle);runDestructors(destructors);__emval_decref(handle)}function __emval_take_value(type,arg){type=requireRegisteredType(type,"_emval_take_value");var v=type["readValueFromPointer"](arg);return Emval.toHandle(v)}function _abort(){abort("")}function _emscripten_memcpy_big(dest,src,num){HEAPU8.copyWithin(dest,src,src+num)}function getHeapMax(){return 2147483648}function emscripten_realloc_buffer(size){var b=wasmMemory.buffer;var pages=size-b.byteLength+65535>>>16;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}}function _emscripten_resize_heap(requestedSize){var oldSize=HEAPU8.length;requestedSize=requestedSize>>>0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}var alignUp=(x,multiple)=>x+(multiple-x%multiple)%multiple;for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignUp(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=emscripten_realloc_buffer(newSize);if(replacement){return true}}return false}function _fd_close(fd){return 52}function _fd_read(fd,iov,iovcnt,pnum){return 52}function _fd_seek(fd,offset_low,offset_high,whence,newOffset){return 70}var printCharBuffers=[null,[],[]];function printChar(stream,curr){var buffer=printCharBuffers[stream];if(curr===0||curr===10){(stream===1?out:err)(UTF8ArrayToString(buffer,0));buffer.length=0}else{buffer.push(curr)}}function _fd_write(fd,iov,iovcnt,pnum){var num=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;for(var j=0;j>2]=num;return 0}BindingError=Module["BindingError"]=extendError(Error,"BindingError");init_emval();PureVirtualError=Module["PureVirtualError"]=extendError(Error,"PureVirtualError");embind_init_charCodes();init_embind();InternalError=Module["InternalError"]=extendError(Error,"InternalError");init_ClassHandle();init_RegisteredPointer();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");var wasmImports={"D":___assert_fail,"v":___syscall_fcntl64,"I":___syscall_ioctl,"J":___syscall_openat,"q":__embind_create_inheriting_constructor,"m":__embind_finalize_value_object,"F":__embind_register_bigint,"M":__embind_register_bool,"c":__embind_register_class,"l":__embind_register_class_class_function,"i":__embind_register_class_constructor,"a":__embind_register_class_function,"b":__embind_register_class_property,"r":__embind_register_constant,"L":__embind_register_emval,"A":__embind_register_enum,"o":__embind_register_enum_value,"x":__embind_register_float,"d":__embind_register_function,"k":__embind_register_integer,"h":__embind_register_memory_view,"w":__embind_register_std_string,"s":__embind_register_std_wstring,"n":__embind_register_value_object,"f":__embind_register_value_object_field,"N":__embind_register_void,"z":__emval_call_method,"g":__emval_call_void_method,"j":__emval_decref,"e":__emval_get_method_caller,"B":__emval_incref,"y":__emval_run_destructors,"C":__emval_take_value,"p":_abort,"K":_emscripten_memcpy_big,"G":_emscripten_resize_heap,"t":_fd_close,"H":_fd_read,"E":_fd_seek,"u":_fd_write};var asm=createWasm();var ___wasm_call_ctors=function(){return(___wasm_call_ctors=Module["asm"]["P"]).apply(null,arguments)};var _malloc=function(){return(_malloc=Module["asm"]["R"]).apply(null,arguments)};var _free=function(){return(_free=Module["asm"]["S"]).apply(null,arguments)};var ___getTypeName=function(){return(___getTypeName=Module["asm"]["T"]).apply(null,arguments)};var __embind_initialize_bindings=Module["__embind_initialize_bindings"]=function(){return(__embind_initialize_bindings=Module["__embind_initialize_bindings"]=Module["asm"]["U"]).apply(null,arguments)};var ___errno_location=function(){return(___errno_location=Module["asm"]["__errno_location"]).apply(null,arguments)};var dynCall_jiji=Module["dynCall_jiji"]=function(){return(dynCall_jiji=Module["dynCall_jiji"]=Module["asm"]["V"]).apply(null,arguments)};var calledRun;dependenciesFulfilled=function runCaller(){if(!calledRun)run();if(!calledRun)dependenciesFulfilled=runCaller};function run(){if(runDependencies>0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("")},1);doRun()},1)}else{doRun()}}if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}run(); + + + return BOX2D.ready +} + +); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = BOX2D; +else if (typeof define === 'function' && define['amd']) + define([], function() { return BOX2D; }); +else if (typeof exports === 'object') + exports["BOX2D"] = BOX2D; diff --git a/emscripten/box2d/box2d.release.wasm.wasm b/emscripten/box2d/box2d.release.wasm.wasm new file mode 100644 index 0000000000000000000000000000000000000000..f05b3be6e35f9b0193d8b8933b06bb486e855469 GIT binary patch literal 183227 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 literal 0 HcmV?d00001