text: var Box2D = {};
  (function(F, G) {
      function K() {}
      if (!(Object.defineProperty instanceof Function) && Object.prototype.__defineGetter__ instanceof Function && Object.prototype.__defineSetter__ instanceof Function) Object.defineProperty = function(y, w, A) {
          A.get instanceof Function && y.__defineGetter__(w, A.get);
          A.set instanceof Function && y.__defineSetter__(w, A.set)
      };
      F.inherit = function(y, w) {
          K.prototype = w.prototype;
          y.prototype = new K;
          y.prototype.constructor = y
      };
      F.generateCallback = function(y, w) {
          return function() {
              w.apply(y, arguments)
          }
      };
      F.NVector = function(y) {
          if (y === G) y = 0;
          for (var w = Array(y || 0), A = 0; A < y; ++A) w[A] = 0;
          return w
      };
      F.is = function(y, w) {
          if (y === null) return false;
          if (w instanceof Function && y instanceof w) return true;
          if (y.constructor.__implements != G && y.constructor.__implements[w]) return true;
          return false
      };
      F.parseUInt = function(y) {
          return Math.abs(parseInt(y))
      }
  })(Box2D);
  var Vector = Array,
      Vector_a2j_Number = Box2D.NVector;
  if (typeof Box2D === "undefined") Box2D = {};
  if (typeof Box2D.Collision === "undefined") Box2D.Collision = {};
  if (typeof Box2D.Collision.Shapes === "undefined") Box2D.Collision.Shapes = {};
  if (typeof Box2D.Common === "undefined") Box2D.Common = {};
  if (typeof Box2D.Common.Math === "undefined") Box2D.Common.Math = {};
  if (typeof Box2D.Dynamics === "undefined") Box2D.Dynamics = {};
  if (typeof Box2D.Dynamics.Contacts === "undefined") Box2D.Dynamics.Contacts = {};
  if (typeof Box2D.Dynamics.Controllers === "undefined") Box2D.Dynamics.Controllers = {};
  if (typeof Box2D.Dynamics.Joints === "undefined") Box2D.Dynamics.Joints = {};
  (function() {
      function F() {
          F.b2AABB.apply(this, arguments)
      }
      function G() {
          G.b2Bound.apply(this, arguments)
      }
      function K() {
          K.b2BoundValues.apply(this, arguments);
          this.constructor === K && this.b2BoundValues.apply(this, arguments)
      }
      function y() {
          y.b2Collision.apply(this, arguments)
      }
      function w() {
          w.b2ContactID.apply(this, arguments);
          this.constructor === w && this.b2ContactID.apply(this, arguments)
      }
      function A() {
          A.b2ContactPoint.apply(this, arguments)
      }
      function U() {
          U.b2Distance.apply(this, arguments)
      }
      function p() {
          p.b2DistanceInput.apply(this,
              arguments)
      }
      function B() {
          B.b2DistanceOutput.apply(this, arguments)
      }
      function Q() {
          Q.b2DistanceProxy.apply(this, arguments)
      }
      function V() {
          V.b2DynamicTree.apply(this, arguments);
          this.constructor === V && this.b2DynamicTree.apply(this, arguments)
      }
      function M() {
          M.b2DynamicTreeBroadPhase.apply(this, arguments)
      }
      function L() {
          L.b2DynamicTreeNode.apply(this, arguments)
      }
      function I() {
          I.b2DynamicTreePair.apply(this, arguments)
      }
      function W() {
          W.b2Manifold.apply(this, arguments);
          this.constructor === W && this.b2Manifold.apply(this, arguments)
      }
      function Y() {
          Y.b2ManifoldPoint.apply(this, arguments);
          this.constructor === Y && this.b2ManifoldPoint.apply(this, arguments)
      }
      function k() {
          k.b2Point.apply(this, arguments)
      }
      function z() {
          z.b2RayCastInput.apply(this, arguments);
          this.constructor === z && this.b2RayCastInput.apply(this, arguments)
      }
      function u() {
          u.b2RayCastOutput.apply(this, arguments)
      }
      function D() {
          D.b2Segment.apply(this, arguments)
      }
      function H() {
          H.b2SeparationFunction.apply(this, arguments)
      }
      function O() {
          O.b2Simplex.apply(this, arguments);
          this.constructor ===
              O && this.b2Simplex.apply(this, arguments)
      }
      function E() {
          E.b2SimplexCache.apply(this, arguments)
      }
      function R() {
          R.b2SimplexVertex.apply(this, arguments)
      }
      function N() {
          N.b2TimeOfImpact.apply(this, arguments)
      }
      function S() {
          S.b2TOIInput.apply(this, arguments)
      }
      function aa() {
          aa.b2WorldManifold.apply(this, arguments);
          this.constructor === aa && this.b2WorldManifold.apply(this, arguments)
      }
      function Z() {
          Z.ClipVertex.apply(this, arguments)
      }
      function d() {
          d.Features.apply(this, arguments)
      }
      function h() {
          h.b2CircleShape.apply(this, arguments);
          this.constructor === h && this.b2CircleShape.apply(this, arguments)
      }
      function l() {
          l.b2EdgeChainDef.apply(this, arguments);
          this.constructor === l && this.b2EdgeChainDef.apply(this, arguments)
      }
      function j() {
          j.b2EdgeShape.apply(this, arguments);
          this.constructor === j && this.b2EdgeShape.apply(this, arguments)
      }
      function o() {
          o.b2MassData.apply(this, arguments)
      }
      function q() {
          q.b2PolygonShape.apply(this, arguments);
          this.constructor === q && this.b2PolygonShape.apply(this, arguments)
      }
      function n() {
          n.b2Shape.apply(this, arguments);
          this.constructor ===
              n && this.b2Shape.apply(this, arguments)
      }
      function a() {
          a.b2Color.apply(this, arguments);
          this.constructor === a && this.b2Color.apply(this, arguments)
      }
      function c() {
          c.b2Settings.apply(this, arguments)
      }
      function g() {
          g.b2Mat22.apply(this, arguments);
          this.constructor === g && this.b2Mat22.apply(this, arguments)
      }
      function b() {
          b.b2Mat33.apply(this, arguments);
          this.constructor === b && this.b2Mat33.apply(this, arguments)
      }
      function e() {
          e.b2Math.apply(this, arguments)
      }
      function f() {
          f.b2Sweep.apply(this, arguments)
      }
      function m() {
          m.b2Transform.apply(this,
              arguments);
          this.constructor === m && this.b2Transform.apply(this, arguments)
      }
      function r() {
          r.b2Vec2.apply(this, arguments);
          this.constructor === r && this.b2Vec2.apply(this, arguments)
      }
      function s() {
          s.b2Vec3.apply(this, arguments);
          this.constructor === s && this.b2Vec3.apply(this, arguments)
      }
      function v() {
          v.b2Body.apply(this, arguments);
          this.constructor === v && this.b2Body.apply(this, arguments)
      }
      function t() {
          t.b2BodyDef.apply(this, arguments);
          this.constructor === t && this.b2BodyDef.apply(this, arguments)
      }
      function x() {
          x.b2ContactFilter.apply(this,
              arguments)
      }
      function C() {
          C.b2ContactImpulse.apply(this, arguments)
      }
      function J() {
          J.b2ContactListener.apply(this, arguments)
      }
      function T() {
          T.b2ContactManager.apply(this, arguments);
          this.constructor === T && this.b2ContactManager.apply(this, arguments)
      }
      function P() {
          P.b2DebugDraw.apply(this, arguments);
          this.constructor === P && this.b2DebugDraw.apply(this, arguments)
      }
      function X() {
          X.b2DestructionListener.apply(this, arguments)
      }
      function $() {
          $.b2FilterData.apply(this, arguments)
      }
      function ba() {
          ba.b2Fixture.apply(this, arguments);
          this.constructor === ba && this.b2Fixture.apply(this, arguments)
      }
      function ca() {
          ca.b2FixtureDef.apply(this, arguments);
          this.constructor === ca && this.b2FixtureDef.apply(this, arguments)
      }
      function da() {
          da.b2Island.apply(this, arguments);
          this.constructor === da && this.b2Island.apply(this, arguments)
      }
      function Fa() {
          Fa.b2TimeStep.apply(this, arguments)
      }
      function ea() {
          ea.b2World.apply(this, arguments);
          this.constructor === ea && this.b2World.apply(this, arguments)
      }
      function Ga() {
          Ga.b2CircleContact.apply(this, arguments)
      }
      function fa() {
          fa.b2Contact.apply(this,
              arguments);
          this.constructor === fa && this.b2Contact.apply(this, arguments)
      }
      function ga() {
          ga.b2ContactConstraint.apply(this, arguments);
          this.constructor === ga && this.b2ContactConstraint.apply(this, arguments)
      }
      function Ha() {
          Ha.b2ContactConstraintPoint.apply(this, arguments)
      }
      function Ia() {
          Ia.b2ContactEdge.apply(this, arguments)
      }
      function ha() {
          ha.b2ContactFactory.apply(this, arguments);
          this.constructor === ha && this.b2ContactFactory.apply(this, arguments)
      }
      function Ja() {
          Ja.b2ContactRegister.apply(this, arguments)
      }
      function Ka() {
          Ka.b2ContactResult.apply(this,
              arguments)
      }
      function ia() {
          ia.b2ContactSolver.apply(this, arguments);
          this.constructor === ia && this.b2ContactSolver.apply(this, arguments)
      }
      function La() {
          La.b2EdgeAndCircleContact.apply(this, arguments)
      }
      function ja() {
          ja.b2NullContact.apply(this, arguments);
          this.constructor === ja && this.b2NullContact.apply(this, arguments)
      }
      function Ma() {
          Ma.b2PolyAndCircleContact.apply(this, arguments)
      }
      function Na() {
          Na.b2PolyAndEdgeContact.apply(this, arguments)
      }
      function Oa() {
          Oa.b2PolygonContact.apply(this, arguments)
      }
      function ka() {
          ka.b2PositionSolverManifold.apply(this,
              arguments);
          this.constructor === ka && this.b2PositionSolverManifold.apply(this, arguments)
      }
      function Pa() {
          Pa.b2BuoyancyController.apply(this, arguments)
      }
      function Qa() {
          Qa.b2ConstantAccelController.apply(this, arguments)
      }
      function Ra() {
          Ra.b2ConstantForceController.apply(this, arguments)
      }
      function Sa() {
          Sa.b2Controller.apply(this, arguments)
      }
      function Ta() {
          Ta.b2ControllerEdge.apply(this, arguments)
      }
      function Ua() {
          Ua.b2GravityController.apply(this, arguments)
      }
      function Va() {
          Va.b2TensorDampingController.apply(this, arguments)
      }
      function la() {
          la.b2DistanceJoint.apply(this, arguments);
          this.constructor === la && this.b2DistanceJoint.apply(this, arguments)
      }
      function ma() {
          ma.b2DistanceJointDef.apply(this, arguments);
          this.constructor === ma && this.b2DistanceJointDef.apply(this, arguments)
      }
      function na() {
          na.b2FrictionJoint.apply(this, arguments);
          this.constructor === na && this.b2FrictionJoint.apply(this, arguments)
      }
      function oa() {
          oa.b2FrictionJointDef.apply(this, arguments);
          this.constructor === oa && this.b2FrictionJointDef.apply(this, arguments)
      }
      function pa() {
          pa.b2GearJoint.apply(this,
              arguments);
          this.constructor === pa && this.b2GearJoint.apply(this, arguments)
      }
      function qa() {
          qa.b2GearJointDef.apply(this, arguments);
          this.constructor === qa && this.b2GearJointDef.apply(this, arguments)
      }
      function Wa() {
          Wa.b2Jacobian.apply(this, arguments)
      }
      function ra() {
          ra.b2Joint.apply(this, arguments);
          this.constructor === ra && this.b2Joint.apply(this, arguments)
      }
      function sa() {
          sa.b2JointDef.apply(this, arguments);
          this.constructor === sa && this.b2JointDef.apply(this, arguments)
      }
      function Xa() {
          Xa.b2JointEdge.apply(this, arguments)
      }
      function ta() {
          ta.b2LineJoint.apply(this, arguments);
          this.constructor === ta && this.b2LineJoint.apply(this, arguments)
      }
      function ua() {
          ua.b2LineJointDef.apply(this, arguments);
          this.constructor === ua && this.b2LineJointDef.apply(this, arguments)
      }
      function va() {
          va.b2MouseJoint.apply(this, arguments);
          this.constructor === va && this.b2MouseJoint.apply(this, arguments)
      }
      function wa() {
          wa.b2MouseJointDef.apply(this, arguments);
          this.constructor === wa && this.b2MouseJointDef.apply(this, arguments)
      }
      function xa() {
          xa.b2PrismaticJoint.apply(this,
              arguments);
          this.constructor === xa && this.b2PrismaticJoint.apply(this, arguments)
      }
      function ya() {
          ya.b2PrismaticJointDef.apply(this, arguments);
          this.constructor === ya && this.b2PrismaticJointDef.apply(this, arguments)
      }
      function za() {
          za.b2PulleyJoint.apply(this, arguments);
          this.constructor === za && this.b2PulleyJoint.apply(this, arguments)
      }
      function Aa() {
          Aa.b2PulleyJointDef.apply(this, arguments);
          this.constructor === Aa && this.b2PulleyJointDef.apply(this, arguments)
      }
      function Ba() {
          Ba.b2RevoluteJoint.apply(this, arguments);
          this.constructor === Ba && this.b2RevoluteJoint.apply(this, arguments)
      }
      function Ca() {
          Ca.b2RevoluteJointDef.apply(this, arguments);
          this.constructor === Ca && this.b2RevoluteJointDef.apply(this, arguments)
      }
      function Da() {
          Da.b2WeldJoint.apply(this, arguments);
          this.constructor === Da && this.b2WeldJoint.apply(this, arguments)
      }
      function Ea() {
          Ea.b2WeldJointDef.apply(this, arguments);
          this.constructor === Ea && this.b2WeldJointDef.apply(this, arguments)
      }
      Box2D.Collision.IBroadPhase = "Box2D.Collision.IBroadPhase";
      Box2D.Collision.b2AABB =
          F;
      Box2D.Collision.b2Bound = G;
      Box2D.Collision.b2BoundValues = K;
      Box2D.Collision.b2Collision = y;
      Box2D.Collision.b2ContactID = w;
      Box2D.Collision.b2ContactPoint = A;
      Box2D.Collision.b2Distance = U;
      Box2D.Collision.b2DistanceInput = p;
      Box2D.Collision.b2DistanceOutput = B;
      Box2D.Collision.b2DistanceProxy = Q;
      Box2D.Collision.b2DynamicTree = V;
      Box2D.Collision.b2DynamicTreeBroadPhase = M;
      Box2D.Collision.b2DynamicTreeNode = L;
      Box2D.Collision.b2DynamicTreePair = I;
      Box2D.Collision.b2Manifold = W;
      Box2D.Collision.b2ManifoldPoint = Y;
      Box2D.Collision.b2Point =
          k;
      Box2D.Collision.b2RayCastInput = z;
      Box2D.Collision.b2RayCastOutput = u;
      Box2D.Collision.b2Segment = D;
      Box2D.Collision.b2SeparationFunction = H;
      Box2D.Collision.b2Simplex = O;
      Box2D.Collision.b2SimplexCache = E;
      Box2D.Collision.b2SimplexVertex = R;
      Box2D.Collision.b2TimeOfImpact = N;
      Box2D.Collision.b2TOIInput = S;
      Box2D.Collision.b2WorldManifold = aa;
      Box2D.Collision.ClipVertex = Z;
      Box2D.Collision.Features = d;
      Box2D.Collision.Shapes.b2CircleShape = h;
      Box2D.Collision.Shapes.b2EdgeChainDef = l;
      Box2D.Collision.Shapes.b2EdgeShape = j;
      Box2D.Collision.Shapes.b2MassData =
          o;
      Box2D.Collision.Shapes.b2PolygonShape = q;
      Box2D.Collision.Shapes.b2Shape = n;
      Box2D.Common.b2internal = "Box2D.Common.b2internal";
      Box2D.Common.b2Color = a;
      Box2D.Common.b2Settings = c;
      Box2D.Common.Math.b2Mat22 = g;
      Box2D.Common.Math.b2Mat33 = b;
      Box2D.Common.Math.b2Math = e;
      Box2D.Common.Math.b2Sweep = f;
      Box2D.Common.Math.b2Transform = m;
      Box2D.Common.Math.b2Vec2 = r;
      Box2D.Common.Math.b2Vec3 = s;
      Box2D.Dynamics.b2Body = v;
      Box2D.Dynamics.b2BodyDef = t;
      Box2D.Dynamics.b2ContactFilter = x;
      Box2D.Dynamics.b2ContactImpulse = C;
      Box2D.Dynamics.b2ContactListener =
          J;
      Box2D.Dynamics.b2ContactManager = T;
      Box2D.Dynamics.b2DebugDraw = P;
      Box2D.Dynamics.b2DestructionListener = X;
      Box2D.Dynamics.b2FilterData = $;
      Box2D.Dynamics.b2Fixture = ba;
      Box2D.Dynamics.b2FixtureDef = ca;
      Box2D.Dynamics.b2Island = da;
      Box2D.Dynamics.b2TimeStep = Fa;
      Box2D.Dynamics.b2World = ea;
      Box2D.Dynamics.Contacts.b2CircleContact = Ga;
      Box2D.Dynamics.Contacts.b2Contact = fa;
      Box2D.Dynamics.Contacts.b2ContactConstraint = ga;
      Box2D.Dynamics.Contacts.b2ContactConstraintPoint = Ha;
      Box2D.Dynamics.Contacts.b2ContactEdge = Ia;
      Box2D.Dynamics.Contacts.b2ContactFactory =
          ha;
      Box2D.Dynamics.Contacts.b2ContactRegister = Ja;
      Box2D.Dynamics.Contacts.b2ContactResult = Ka;
      Box2D.Dynamics.Contacts.b2ContactSolver = ia;
      Box2D.Dynamics.Contacts.b2EdgeAndCircleContact = La;
      Box2D.Dynamics.Contacts.b2NullContact = ja;
      Box2D.Dynamics.Contacts.b2PolyAndCircleContact = Ma;
      Box2D.Dynamics.Contacts.b2PolyAndEdgeContact = Na;
      Box2D.Dynamics.Contacts.b2PolygonContact = Oa;
      Box2D.Dynamics.Contacts.b2PositionSolverManifold = ka;
      Box2D.Dynamics.Controllers.b2BuoyancyController = Pa;
      Box2D.Dynamics.Controllers.b2ConstantAccelController =
          Qa;
      Box2D.Dynamics.Controllers.b2ConstantForceController = Ra;
      Box2D.Dynamics.Controllers.b2Controller = Sa;
      Box2D.Dynamics.Controllers.b2ControllerEdge = Ta;
      Box2D.Dynamics.Controllers.b2GravityController = Ua;
      Box2D.Dynamics.Controllers.b2TensorDampingController = Va;
      Box2D.Dynamics.Joints.b2DistanceJoint = la;
      Box2D.Dynamics.Joints.b2DistanceJointDef = ma;
      Box2D.Dynamics.Joints.b2FrictionJoint = na;
      Box2D.Dynamics.Joints.b2FrictionJointDef = oa;
      Box2D.Dynamics.Joints.b2GearJoint = pa;
      Box2D.Dynamics.Joints.b2GearJointDef = qa;
      Box2D.Dynamics.Joints.b2Jacobian = Wa;
      Box2D.Dynamics.Joints.b2Joint = ra;
      Box2D.Dynamics.Joints.b2JointDef = sa;
      Box2D.Dynamics.Joints.b2JointEdge = Xa;
      Box2D.Dynamics.Joints.b2LineJoint = ta;
      Box2D.Dynamics.Joints.b2LineJointDef = ua;
      Box2D.Dynamics.Joints.b2MouseJoint = va;
      Box2D.Dynamics.Joints.b2MouseJointDef = wa;
      Box2D.Dynamics.Joints.b2PrismaticJoint = xa;
      Box2D.Dynamics.Joints.b2PrismaticJointDef = ya;
      Box2D.Dynamics.Joints.b2PulleyJoint = za;
      Box2D.Dynamics.Joints.b2PulleyJointDef = Aa;
      Box2D.Dynamics.Joints.b2RevoluteJoint =
          Ba;
      Box2D.Dynamics.Joints.b2RevoluteJointDef = Ca;
      Box2D.Dynamics.Joints.b2WeldJoint = Da;
      Box2D.Dynamics.Joints.b2WeldJointDef = Ea
  })();
  Box2D.postDefs = [];
  (function() {
      var F = Box2D.Collision.Shapes.b2CircleShape,
          G = Box2D.Collision.Shapes.b2PolygonShape,
          K = Box2D.Collision.Shapes.b2Shape,
          y = Box2D.Common.b2Settings,
          w = Box2D.Common.Math.b2Math,
          A = Box2D.Common.Math.b2Sweep,
          U = Box2D.Common.Math.b2Transform,
          p = Box2D.Common.Math.b2Vec2,
          B = Box2D.Collision.b2AABB,
          Q = Box2D.Collision.b2Bound,
          V = Box2D.Collision.b2BoundValues,
          M = Box2D.Collision.b2Collision,
          L = Box2D.Collision.b2ContactID,
          I = Box2D.Collision.b2ContactPoint,
          W = Box2D.Collision.b2Distance,
          Y = Box2D.Collision.b2DistanceInput,
          k = Box2D.Collision.b2DistanceOutput,
          z = Box2D.Collision.b2DistanceProxy,
          u = Box2D.Collision.b2DynamicTree,
          D = Box2D.Collision.b2DynamicTreeBroadPhase,
          H = Box2D.Collision.b2DynamicTreeNode,
          O = Box2D.Collision.b2DynamicTreePair,
          E = Box2D.Collision.b2Manifold,
          R = Box2D.Collision.b2ManifoldPoint,
          N = Box2D.Collision.b2Point,
          S = Box2D.Collision.b2RayCastInput,
          aa = Box2D.Collision.b2RayCastOutput,
          Z = Box2D.Collision.b2Segment,
          d = Box2D.Collision.b2SeparationFunction,
          h = Box2D.Collision.b2Simplex,
          l = Box2D.Collision.b2SimplexCache,
          j =
          Box2D.Collision.b2SimplexVertex,
          o = Box2D.Collision.b2TimeOfImpact,
          q = Box2D.Collision.b2TOIInput,
          n = Box2D.Collision.b2WorldManifold,
          a = Box2D.Collision.ClipVertex,
          c = Box2D.Collision.Features,
          g = Box2D.Collision.IBroadPhase;
      B.b2AABB = function() {
          this.lowerBound = new p;
          this.upperBound = new p
      };
      B.prototype.IsValid = function() {
          var b = this.upperBound.y - this.lowerBound.y;
          return b = (b = this.upperBound.x - this.lowerBound.x >= 0 && b >= 0) && this.lowerBound.IsValid() && this.upperBound.IsValid()
      };
      B.prototype.GetCenter = function() {
          return new p((this.lowerBound.x +
              this.upperBound.x) / 2, (this.lowerBound.y + this.upperBound.y) / 2)
      };
      B.prototype.GetExtents = function() {
          return new p((this.upperBound.x - this.lowerBound.x) / 2, (this.upperBound.y - this.lowerBound.y) / 2)
      };
      B.prototype.Contains = function(b) {
          var e = true;
          return e = (e = (e = (e = e && this.lowerBound.x <= b.lowerBound.x) && this.lowerBound.y <= b.lowerBound.y) && b.upperBound.x <= this.upperBound.x) && b.upperBound.y <= this.upperBound.y
      };
      B.prototype.RayCast = function(b, e) {
          var f = -Number.MAX_VALUE,
              m = Number.MAX_VALUE,
              r = e.p1.x,
              s = e.p1.y,
              v = e.p2.x -
              e.p1.x,
              t = e.p2.y - e.p1.y,
              x = Math.abs(t),
              C = b.normal,
              J = 0,
              T = 0,
              P = J = 0;
          P = 0;
          if (Math.abs(v) < Number.MIN_VALUE) {
              if (r < this.lowerBound.x || this.upperBound.x < r) return false
          } else {
              J = 1 / v;
              T = (this.lowerBound.x - r) * J;
              J = (this.upperBound.x - r) * J;
              P = -1;
              if (T > J) {
                  P = T;
                  T = J;
                  J = P;
                  P = 1
              }
              if (T > f) {
                  C.x = P;
                  C.y = 0;
                  f = T
              }
              m = Math.min(m, J);
              if (f > m) return false
          }
          if (x < Number.MIN_VALUE) {
              if (s < this.lowerBound.y || this.upperBound.y < s) return false
          } else {
              J = 1 / t;
              T = (this.lowerBound.y - s) * J;
              J = (this.upperBound.y - s) * J;
              P = -1;
              if (T > J) {
                  P = T;
                  T = J;
                  J = P;
                  P = 1
              }
              if (T > f) {
                  C.y = P;
                  C.x = 0;
                  f =
                      T
              }
              m = Math.min(m, J);
              if (f > m) return false
          }
          b.fraction = f;
          return true
      };
      B.prototype.TestOverlap = function(b) {
          var e = b.lowerBound.y - this.upperBound.y,
              f = this.lowerBound.y - b.upperBound.y;
          if (b.lowerBound.x - this.upperBound.x > 0 || e > 0) return false;
          if (this.lowerBound.x - b.upperBound.x > 0 || f > 0) return false;
          return true
      };
      B.Combine = function(b, e) {
          var f = new B;
          f.Combine(b, e);
          return f
      };
      B.prototype.Combine = function(b, e) {
          this.lowerBound.x = Math.min(b.lowerBound.x, e.lowerBound.x);
          this.lowerBound.y = Math.min(b.lowerBound.y, e.lowerBound.y);
          this.upperBound.x = Math.max(b.upperBound.x, e.upperBound.x);
          this.upperBound.y = Math.max(b.upperBound.y, e.upperBound.y)
      };
      Q.b2Bound = function() {};
      Q.prototype.IsLower = function() {
          return (this.value & 1) == 0
      };
      Q.prototype.IsUpper = function() {
          return (this.value & 1) == 1
      };
      Q.prototype.Swap = function(b) {
          var e = this.value,
              f = this.proxy,
              m = this.stabbingCount;
          this.value = b.value;
          this.proxy = b.proxy;
          this.stabbingCount = b.stabbingCount;
          b.value = e;
          b.proxy = f;
          b.stabbingCount = m
      };
      V.b2BoundValues = function() {};
      V.prototype.b2BoundValues = function() {
          this.lowerValues =
              new Vector_a2j_Number;
          this.lowerValues[0] = 0;
          this.lowerValues[1] = 0;
          this.upperValues = new Vector_a2j_Number;
          this.upperValues[0] = 0;
          this.upperValues[1] = 0
      };
      M.b2Collision = function() {};
      M.ClipSegmentToLine = function(b, e, f, m) {
          if (m === undefined) m = 0;
          var r, s = 0;
          r = e[0];
          var v = r.v;
          r = e[1];
          var t = r.v,
              x = f.x * v.x + f.y * v.y - m;
          r = f.x * t.x + f.y * t.y - m;
          x <= 0 && b[s++].Set(e[0]);
          r <= 0 && b[s++].Set(e[1]);
          if (x * r < 0) {
              f = x / (x - r);
              r = b[s];
              r = r.v;
              r.x = v.x + f * (t.x - v.x);
              r.y = v.y + f * (t.y - v.y);
              r = b[s];
              r.id = (x > 0 ? e[0] : e[1]).id;
              ++s
          }
          return s
      };
      M.EdgeSeparation =
          function(b, e, f, m, r) {
              if (f === undefined) f = 0;
              parseInt(b.m_vertexCount);
              var s = b.m_vertices;
              b = b.m_normals;
              var v = parseInt(m.m_vertexCount),
                  t = m.m_vertices,
                  x, C;
              x = e.R;
              C = b[f];
              b = x.col1.x * C.x + x.col2.x * C.y;
              m = x.col1.y * C.x + x.col2.y * C.y;
              x = r.R;
              var J = x.col1.x * b + x.col1.y * m;
              x = x.col2.x * b + x.col2.y * m;
              for (var T = 0, P = Number.MAX_VALUE, X = 0; X < v; ++X) {
                  C = t[X];
                  C = C.x * J + C.y * x;
                  if (C < P) {
                      P = C;
                      T = X
                  }
              }
              C = s[f];
              x = e.R;
              f = e.position.x + (x.col1.x * C.x + x.col2.x * C.y);
              e = e.position.y + (x.col1.y * C.x + x.col2.y * C.y);
              C = t[T];
              x = r.R;
              s = r.position.x + (x.col1.x * C.x +
                  x.col2.x * C.y);
              r = r.position.y + (x.col1.y * C.x + x.col2.y * C.y);
              s -= f;
              r -= e;
              return s * b + r * m
          };
      M.FindMaxSeparation = function(b, e, f, m, r) {
          var s = parseInt(e.m_vertexCount),
              v = e.m_normals,
              t, x;
          x = r.R;
          t = m.m_centroid;
          var C = r.position.x + (x.col1.x * t.x + x.col2.x * t.y),
              J = r.position.y + (x.col1.y * t.x + x.col2.y * t.y);
          x = f.R;
          t = e.m_centroid;
          C -= f.position.x + (x.col1.x * t.x + x.col2.x * t.y);
          J -= f.position.y + (x.col1.y * t.x + x.col2.y * t.y);
          x = C * f.R.col1.x + J * f.R.col1.y;
          J = C * f.R.col2.x + J * f.R.col2.y;
          C = 0;
          for (var T = -Number.MAX_VALUE, P = 0; P < s; ++P) {
              t = v[P];
              t = t.x * x + t.y * J;
              if (t > T) {
                  T = t;
                  C = P
              }
          }
          v = M.EdgeSeparation(e, f, C, m, r);
          t = parseInt(C - 1 >= 0 ? C - 1 : s - 1);
          x = M.EdgeSeparation(e, f, t, m, r);
          J = parseInt(C + 1 < s ? C + 1 : 0);
          T = M.EdgeSeparation(e, f, J, m, r);
          var X = P = 0,
              $ = 0;
          if (x > v && x > T) {
              $ = -1;
              P = t;
              X = x
          } else if (T > v) {
              $ = 1;
              P = J;
              X = T
          } else {
              b[0] = C;
              return v
          }
          for (;;) {
              C = $ == -1 ? P - 1 >= 0 ? P - 1 : s - 1 : P + 1 < s ? P + 1 : 0;
              v = M.EdgeSeparation(e, f, C, m, r);
              if (v > X) {
                  P = C;
                  X = v
              } else break
          }
          b[0] = P;
          return X
      };
      M.FindIncidentEdge = function(b, e, f, m, r, s) {
          if (m === undefined) m = 0;
          parseInt(e.m_vertexCount);
          var v = e.m_normals,
              t = parseInt(r.m_vertexCount);
          e = r.m_vertices;
          r = r.m_normals;
          var x;
          x = f.R;
          f = v[m];
          v = x.col1.x * f.x + x.col2.x * f.y;
          var C = x.col1.y * f.x + x.col2.y * f.y;
          x = s.R;
          f = x.col1.x * v + x.col1.y * C;
          C = x.col2.x * v + x.col2.y * C;
          v = f;
          x = 0;
          for (var J = Number.MAX_VALUE, T = 0; T < t; ++T) {
              f = r[T];
              f = v * f.x + C * f.y;
              if (f < J) {
                  J = f;
                  x = T
              }
          }
          r = parseInt(x);
          v = parseInt(r + 1 < t ? r + 1 : 0);
          t = b[0];
          f = e[r];
          x = s.R;
          t.v.x = s.position.x + (x.col1.x * f.x + x.col2.x * f.y);
          t.v.y = s.position.y + (x.col1.y * f.x + x.col2.y * f.y);
          t.id.features.referenceEdge = m;
          t.id.features.incidentEdge = r;
          t.id.features.incidentVertex = 0;
          t = b[1];
          f = e[v];
          x = s.R;
          t.v.x = s.position.x + (x.col1.x * f.x + x.col2.x * f.y);
          t.v.y = s.position.y + (x.col1.y * f.x + x.col2.y * f.y);
          t.id.features.referenceEdge = m;
          t.id.features.incidentEdge = v;
          t.id.features.incidentVertex = 1
      };
      M.MakeClipPointVector = function() {
          var b = new Vector(2);
          b[0] = new a;
          b[1] = new a;
          return b
      };
      M.CollidePolygons = function(b, e, f, m, r) {
          var s;
          b.m_pointCount = 0;
          var v = e.m_radius + m.m_radius;
          s = 0;
          M.s_edgeAO[0] = s;
          var t = M.FindMaxSeparation(M.s_edgeAO, e, f, m, r);
          s = M.s_edgeAO[0];
          if (!(t > v)) {
              var x = 0;
              M.s_edgeBO[0] = x;
              var C = M.FindMaxSeparation(M.s_edgeBO,
                  m, r, e, f);
              x = M.s_edgeBO[0];
              if (!(C > v)) {
                  var J = 0,
                      T = 0;
                  if (C > 0.98 * t + 0.0010) {
                      t = m;
                      m = e;
                      e = r;
                      f = f;
                      J = x;
                      b.m_type = E.e_faceB;
                      T = 1
                  } else {
                      t = e;
                      m = m;
                      e = f;
                      f = r;
                      J = s;
                      b.m_type = E.e_faceA;
                      T = 0
                  }
                  s = M.s_incidentEdge;
                  M.FindIncidentEdge(s, t, e, J, m, f);
                  x = parseInt(t.m_vertexCount);
                  r = t.m_vertices;
                  t = r[J];
                  var P;
                  P = J + 1 < x ? r[parseInt(J + 1)] : r[0];
                  J = M.s_localTangent;
                  J.Set(P.x - t.x, P.y - t.y);
                  J.Normalize();
                  r = M.s_localNormal;
                  r.x = J.y;
                  r.y = -J.x;
                  m = M.s_planePoint;
                  m.Set(0.5 * (t.x + P.x), 0.5 * (t.y + P.y));
                  C = M.s_tangent;
                  x = e.R;
                  C.x = x.col1.x * J.x + x.col2.x * J.y;
                  C.y = x.col1.y *
                      J.x + x.col2.y * J.y;
                  var X = M.s_tangent2;
                  X.x = -C.x;
                  X.y = -C.y;
                  J = M.s_normal;
                  J.x = C.y;
                  J.y = -C.x;
                  var $ = M.s_v11,
                      ba = M.s_v12;
                  $.x = e.position.x + (x.col1.x * t.x + x.col2.x * t.y);
                  $.y = e.position.y + (x.col1.y * t.x + x.col2.y * t.y);
                  ba.x = e.position.x + (x.col1.x * P.x + x.col2.x * P.y);
                  ba.y = e.position.y + (x.col1.y * P.x + x.col2.y * P.y);
                  e = J.x * $.x + J.y * $.y;
                  x = C.x * ba.x + C.y * ba.y + v;
                  P = M.s_clipPoints1;
                  t = M.s_clipPoints2;
                  ba = 0;
                  ba = M.ClipSegmentToLine(P, s, X, -C.x * $.x - C.y * $.y + v);
                  if (!(ba < 2)) {
                      ba = M.ClipSegmentToLine(t, P, C, x);
                      if (!(ba < 2)) {
                          b.m_localPlaneNormal.SetV(r);
                          b.m_localPoint.SetV(m);
                          for (m = r = 0; m < y.b2_maxManifoldPoints; ++m) {
                              s = t[m];
                              if (J.x * s.v.x + J.y * s.v.y - e <= v) {
                                  C = b.m_points[r];
                                  x = f.R;
                                  X = s.v.x - f.position.x;
                                  $ = s.v.y - f.position.y;
                                  C.m_localPoint.x = X * x.col1.x + $ * x.col1.y;
                                  C.m_localPoint.y = X * x.col2.x + $ * x.col2.y;
                                  C.m_id.Set(s.id);
                                  C.m_id.features.flip = T;
                                  ++r
                              }
                          }
                          b.m_pointCount = r
                      }
                  }
              }
          }
      };
      M.CollideCircles = function(b, e, f, m, r) {
          b.m_pointCount = 0;
          var s, v;
          s = f.R;
          v = e.m_p;
          var t = f.position.x + (s.col1.x * v.x + s.col2.x * v.y);
          f = f.position.y + (s.col1.y * v.x + s.col2.y * v.y);
          s = r.R;
          v = m.m_p;
          t = r.position.x +
              (s.col1.x * v.x + s.col2.x * v.y) - t;
          r = r.position.y + (s.col1.y * v.x + s.col2.y * v.y) - f;
          s = e.m_radius + m.m_radius;
          if (!(t * t + r * r > s * s)) {
              b.m_type = E.e_circles;
              b.m_localPoint.SetV(e.m_p);
              b.m_localPlaneNormal.SetZero();
              b.m_pointCount = 1;
              b.m_points[0].m_localPoint.SetV(m.m_p);
              b.m_points[0].m_id.key = 0
          }
      };
      M.CollidePolygonAndCircle = function(b, e, f, m, r) {
          var s = b.m_pointCount = 0,
              v = 0,
              t, x;
          x = r.R;
          t = m.m_p;
          var C = r.position.y + (x.col1.y * t.x + x.col2.y * t.y);
          s = r.position.x + (x.col1.x * t.x + x.col2.x * t.y) - f.position.x;
          v = C - f.position.y;
          x = f.R;
          f = s *
              x.col1.x + v * x.col1.y;
          x = s * x.col2.x + v * x.col2.y;
          var J = 0;
          C = -Number.MAX_VALUE;
          r = e.m_radius + m.m_radius;
          var T = parseInt(e.m_vertexCount),
              P = e.m_vertices;
          e = e.m_normals;
          for (var X = 0; X < T; ++X) {
              t = P[X];
              s = f - t.x;
              v = x - t.y;
              t = e[X];
              s = t.x * s + t.y * v;
              if (s > r) return;
              if (s > C) {
                  C = s;
                  J = X
              }
          }
          s = parseInt(J);
          v = parseInt(s + 1 < T ? s + 1 : 0);
          t = P[s];
          P = P[v];
          if (C < Number.MIN_VALUE) {
              b.m_pointCount = 1;
              b.m_type = E.e_faceA;
              b.m_localPlaneNormal.SetV(e[J]);
              b.m_localPoint.x = 0.5 * (t.x + P.x);
              b.m_localPoint.y = 0.5 * (t.y + P.y)
          } else {
              C = (f - P.x) * (t.x - P.x) + (x - P.y) * (t.y - P.y);
              if ((f - t.x) * (P.x - t.x) + (x - t.y) * (P.y - t.y) <= 0) {
                  if ((f - t.x) * (f - t.x) + (x - t.y) * (x - t.y) > r * r) return;
                  b.m_pointCount = 1;
                  b.m_type = E.e_faceA;
                  b.m_localPlaneNormal.x = f - t.x;
                  b.m_localPlaneNormal.y = x - t.y;
                  b.m_localPlaneNormal.Normalize();
                  b.m_localPoint.SetV(t)
              } else if (C <= 0) {
                  if ((f - P.x) * (f - P.x) + (x - P.y) * (x - P.y) > r * r) return;
                  b.m_pointCount = 1;
                  b.m_type = E.e_faceA;
                  b.m_localPlaneNormal.x = f - P.x;
                  b.m_localPlaneNormal.y = x - P.y;
                  b.m_localPlaneNormal.Normalize();
                  b.m_localPoint.SetV(P)
              } else {
                  J = 0.5 * (t.x + P.x);
                  t = 0.5 * (t.y + P.y);
                  C = (f - J) * e[s].x +
                      (x - t) * e[s].y;
                  if (C > r) return;
                  b.m_pointCount = 1;
                  b.m_type = E.e_faceA;
                  b.m_localPlaneNormal.x = e[s].x;
                  b.m_localPlaneNormal.y = e[s].y;
                  b.m_localPlaneNormal.Normalize();
                  b.m_localPoint.Set(J, t)
              }
          }
          b.m_points[0].m_localPoint.SetV(m.m_p);
          b.m_points[0].m_id.key = 0
      };
      M.TestOverlap = function(b, e) {
          var f = e.lowerBound,
              m = b.upperBound,
              r = f.x - m.x,
              s = f.y - m.y;
          f = b.lowerBound;
          m = e.upperBound;
          var v = f.y - m.y;
          if (r > 0 || s > 0) return false;
          if (f.x - m.x > 0 || v > 0) return false;
          return true
      };
      Box2D.postDefs.push(function() {
          Box2D.Collision.b2Collision.s_incidentEdge =
              M.MakeClipPointVector();
          Box2D.Collision.b2Collision.s_clipPoints1 = M.MakeClipPointVector();
          Box2D.Collision.b2Collision.s_clipPoints2 = M.MakeClipPointVector();
          Box2D.Collision.b2Collision.s_edgeAO = new Vector_a2j_Number(1);
          Box2D.Collision.b2Collision.s_edgeBO = new Vector_a2j_Number(1);
          Box2D.Collision.b2Collision.s_localTangent = new p;
          Box2D.Collision.b2Collision.s_localNormal = new p;
          Box2D.Collision.b2Collision.s_planePoint = new p;
          Box2D.Collision.b2Collision.s_normal = new p;
          Box2D.Collision.b2Collision.s_tangent =
              new p;
          Box2D.Collision.b2Collision.s_tangent2 = new p;
          Box2D.Collision.b2Collision.s_v11 = new p;
          Box2D.Collision.b2Collision.s_v12 = new p;
          Box2D.Collision.b2Collision.b2CollidePolyTempVec = new p;
          Box2D.Collision.b2Collision.b2_nullFeature = 255
      });
      L.b2ContactID = function() {
          this.features = new c
      };
      L.prototype.b2ContactID = function() {
          this.features._m_id = this
      };
      L.prototype.Set = function(b) {
          this.key = b._key
      };
      L.prototype.Copy = function() {
          var b = new L;
          b.key = this.key;
          return b
      };
      Object.defineProperty(L.prototype, "key", {
          enumerable: false,
          configurable: true,
          get: function() {
              return this._key
          }
      });
      Object.defineProperty(L.prototype, "key", {
          enumerable: false,
          configurable: true,
          set: function(b) {
              if (b === undefined) b = 0;
              this._key = b;
              this.features._referenceEdge = this._key & 255;
              this.features._incidentEdge = (this._key & 65280) >> 8 & 255;
              this.features._incidentVertex = (this._key & 16711680) >> 16 & 255;
              this.features._flip = (this._key & 4278190080) >> 24 & 255
          }
      });
      I.b2ContactPoint = function() {
          this.position = new p;
          this.velocity = new p;
          this.normal = new p;
          this.id = new L
      };
      W.b2Distance =
          function() {};
      W.Distance = function(b, e, f) {
          ++W.b2_gjkCalls;
          var m = f.proxyA,
              r = f.proxyB,
              s = f.transformA,
              v = f.transformB,
              t = W.s_simplex;
          t.ReadCache(e, m, s, r, v);
          var x = t.m_vertices,
              C = W.s_saveA,
              J = W.s_saveB,
              T = 0;
          t.GetClosestPoint().LengthSquared();
          for (var P = 0, X, $ = 0; $ < 20;) {
              T = t.m_count;
              for (P = 0; P < T; P++) {
                  C[P] = x[P].indexA;
                  J[P] = x[P].indexB
              }
              switch (t.m_count) {
                  case 1:
                      break;
                  case 2:
                      t.Solve2();
                      break;
                  case 3:
                      t.Solve3();
                      break;
                  default:
                      y.b2Assert(false)
              }
              if (t.m_count == 3) break;
              X = t.GetClosestPoint();
              X.LengthSquared();
              P = t.GetSearchDirection();
              if (P.LengthSquared() < Number.MIN_VALUE * Number.MIN_VALUE) break;
              X = x[t.m_count];
              X.indexA = m.GetSupport(w.MulTMV(s.R, P.GetNegative()));
              X.wA = w.MulX(s, m.GetVertex(X.indexA));
              X.indexB = r.GetSupport(w.MulTMV(v.R, P));
              X.wB = w.MulX(v, r.GetVertex(X.indexB));
              X.w = w.SubtractVV(X.wB, X.wA);
              ++$;
              ++W.b2_gjkIters;
              var ba = false;
              for (P = 0; P < T; P++)
                  if (X.indexA == C[P] && X.indexB == J[P]) {
                      ba = true;
                      break
                  }
              if (ba) break;
              ++t.m_count
          }
          W.b2_gjkMaxIters = w.Max(W.b2_gjkMaxIters, $);
          t.GetWitnessPoints(b.pointA, b.pointB);
          b.distance = w.SubtractVV(b.pointA,
              b.pointB).Length();
          b.iterations = $;
          t.WriteCache(e);
          if (f.useRadii) {
              e = m.m_radius;
              r = r.m_radius;
              if (b.distance > e + r && b.distance > Number.MIN_VALUE) {
                  b.distance -= e + r;
                  f = w.SubtractVV(b.pointB, b.pointA);
                  f.Normalize();
                  b.pointA.x += e * f.x;
                  b.pointA.y += e * f.y;
                  b.pointB.x -= r * f.x;
                  b.pointB.y -= r * f.y
              } else {
                  X = new p;
                  X.x = 0.5 * (b.pointA.x + b.pointB.x);
                  X.y = 0.5 * (b.pointA.y + b.pointB.y);
                  b.pointA.x = b.pointB.x = X.x;
                  b.pointA.y = b.pointB.y = X.y;
                  b.distance = 0
              }
          }
      };
      Box2D.postDefs.push(function() {
          Box2D.Collision.b2Distance.s_simplex = new h;
          Box2D.Collision.b2Distance.s_saveA =
              new Vector_a2j_Number(3);
          Box2D.Collision.b2Distance.s_saveB = new Vector_a2j_Number(3)
      });
      Y.b2DistanceInput = function() {};
      k.b2DistanceOutput = function() {
          this.pointA = new p;
          this.pointB = new p
      };
      z.b2DistanceProxy = function() {};
      z.prototype.Set = function(b) {
          switch (b.GetType()) {
              case K.e_circleShape:
                  b = b instanceof F ? b : null;
                  this.m_vertices = new Vector(1, true);
                  this.m_vertices[0] = b.m_p;
                  this.m_count = 1;
                  this.m_radius = b.m_radius;
                  break;
              case K.e_polygonShape:
                  b = b instanceof G ? b : null;
                  this.m_vertices = b.m_vertices;
                  this.m_count =
                      b.m_vertexCount;
                  this.m_radius = b.m_radius;
                  break;
              default:
                  y.b2Assert(false)
          }
      };
      z.prototype.GetSupport = function(b) {
          for (var e = 0, f = this.m_vertices[0].x * b.x + this.m_vertices[0].y * b.y, m = 1; m < this.m_count; ++m) {
              var r = this.m_vertices[m].x * b.x + this.m_vertices[m].y * b.y;
              if (r > f) {
                  e = m;
                  f = r
              }
          }
          return e
      };
      z.prototype.GetSupportVertex = function(b) {
          for (var e = 0, f = this.m_vertices[0].x * b.x + this.m_vertices[0].y * b.y, m = 1; m < this.m_count; ++m) {
              var r = this.m_vertices[m].x * b.x + this.m_vertices[m].y * b.y;
              if (r > f) {
                  e = m;
                  f = r
              }
          }
          return this.m_vertices[e]
      };
      z.prototype.GetVertexCount = function() {
          return this.m_count
      };
      z.prototype.GetVertex = function(b) {
          if (b === undefined) b = 0;
          y.b2Assert(0 <= b && b < this.m_count);
          return this.m_vertices[b]
      };
      u.b2DynamicTree = function() {};
      u.prototype.b2DynamicTree = function() {
          this.m_freeList = this.m_root = null;
          this.m_insertionCount = this.m_path = 0
      };
      u.prototype.CreateProxy = function(b, e) {
          var f = this.AllocateNode(),
              m = y.b2_aabbExtension,
              r = y.b2_aabbExtension;
          f.aabb.lowerBound.x = b.lowerBound.x - m;
          f.aabb.lowerBound.y = b.lowerBound.y - r;
          f.aabb.upperBound.x =
              b.upperBound.x + m;
          f.aabb.upperBound.y = b.upperBound.y + r;
          f.userData = e;
          this.InsertLeaf(f);
          return f
      };
      u.prototype.DestroyProxy = function(b) {
          this.RemoveLeaf(b);
          this.FreeNode(b)
      };
      u.prototype.MoveProxy = function(b, e, f) {
          y.b2Assert(b.IsLeaf());
          if (b.aabb.Contains(e)) return false;
          this.RemoveLeaf(b);
          var m = y.b2_aabbExtension + y.b2_aabbMultiplier * (f.x > 0 ? f.x : -f.x);
          f = y.b2_aabbExtension + y.b2_aabbMultiplier * (f.y > 0 ? f.y : -f.y);
          b.aabb.lowerBound.x = e.lowerBound.x - m;
          b.aabb.lowerBound.y = e.lowerBound.y - f;
          b.aabb.upperBound.x = e.upperBound.x +
              m;
          b.aabb.upperBound.y = e.upperBound.y + f;
          this.InsertLeaf(b);
          return true
      };
      u.prototype.Rebalance = function(b) {
          if (b === undefined) b = 0;
          if (this.m_root != null)
              for (var e = 0; e < b; e++) {
                  for (var f = this.m_root, m = 0; f.IsLeaf() == false;) {
                      f = this.m_path >> m & 1 ? f.child2 : f.child1;
                      m = m + 1 & 31
                  }++this.m_path;
                  this.RemoveLeaf(f);
                  this.InsertLeaf(f)
              }
      };
      u.prototype.GetFatAABB = function(b) {
          return b.aabb
      };
      u.prototype.GetUserData = function(b) {
          return b.userData
      };
      u.prototype.Query = function(b, e) {
          if (this.m_root != null) {
              var f = new Vector,
                  m = 0;
              for (f[m++] =
                  this.m_root; m > 0;) {
                  var r = f[--m];
                  if (r.aabb.TestOverlap(e))
                      if (r.IsLeaf()) {
                          if (!b(r)) break
                      } else {
                          f[m++] = r.child1;
                          f[m++] = r.child2
                      }
              }
          }
      };
      u.prototype.RayCast = function(b, e) {
          if (this.m_root != null) {
              var f = e.p1,
                  m = e.p2,
                  r = w.SubtractVV(f, m);
              r.Normalize();
              r = w.CrossFV(1, r);
              var s = w.AbsV(r),
                  v = e.maxFraction,
                  t = new B,
                  x = 0,
                  C = 0;
              x = f.x + v * (m.x - f.x);
              C = f.y + v * (m.y - f.y);
              t.lowerBound.x = Math.min(f.x, x);
              t.lowerBound.y = Math.min(f.y, C);
              t.upperBound.x = Math.max(f.x, x);
              t.upperBound.y = Math.max(f.y, C);
              var J = new Vector,
                  T = 0;
              for (J[T++] = this.m_root; T >
                  0;) {
                  v = J[--T];
                  if (v.aabb.TestOverlap(t) != false) {
                      x = v.aabb.GetCenter();
                      C = v.aabb.GetExtents();
                      if (!(Math.abs(r.x * (f.x - x.x) + r.y * (f.y - x.y)) - s.x * C.x - s.y * C.y > 0))
                          if (v.IsLeaf()) {
                              x = new S;
                              x.p1 = e.p1;
                              x.p2 = e.p2;
                              x.maxFraction = e.maxFraction;
                              v = b(x, v);
                              if (v == 0) break;
                              if (v > 0) {
                                  x = f.x + v * (m.x - f.x);
                                  C = f.y + v * (m.y - f.y);
                                  t.lowerBound.x = Math.min(f.x, x);
                                  t.lowerBound.y = Math.min(f.y, C);
                                  t.upperBound.x = Math.max(f.x, x);
                                  t.upperBound.y = Math.max(f.y, C)
                              }
                          } else {
                              J[T++] = v.child1;
                              J[T++] = v.child2
                          }
                  }
              }
          }
      };
      u.prototype.AllocateNode = function() {
          if (this.m_freeList) {
              var b =
                  this.m_freeList;
              this.m_freeList = b.parent;
              b.parent = null;
              b.child1 = null;
              b.child2 = null;
              return b
          }
          return new H
      };
      u.prototype.FreeNode = function(b) {
          b.parent = this.m_freeList;
          this.m_freeList = b
      };
      u.prototype.InsertLeaf = function(b) {
          ++this.m_insertionCount;
          if (this.m_root == null) {
              this.m_root = b;
              this.m_root.parent = null
          } else {
              var e = b.aabb.GetCenter(),
                  f = this.m_root;
              if (f.IsLeaf() == false) {
                  do {
                      var m = f.child1;
                      f = f.child2;
                      f = Math.abs((m.aabb.lowerBound.x + m.aabb.upperBound.x) / 2 - e.x) + Math.abs((m.aabb.lowerBound.y + m.aabb.upperBound.y) /
                          2 - e.y) < Math.abs((f.aabb.lowerBound.x + f.aabb.upperBound.x) / 2 - e.x) + Math.abs((f.aabb.lowerBound.y + f.aabb.upperBound.y) / 2 - e.y) ? m : f
                  } while (f.IsLeaf() == false)
              }
              e = f.parent;
              m = this.AllocateNode();
              m.parent = e;
              m.userData = null;
              m.aabb.Combine(b.aabb, f.aabb);
              if (e) {
                  if (f.parent.child1 == f) e.child1 = m;
                  else e.child2 = m;
                  m.child1 = f;
                  m.child2 = b;
                  f.parent = m;
                  b.parent = m;
                  do {
                      if (e.aabb.Contains(m.aabb)) break;
                      e.aabb.Combine(e.child1.aabb, e.child2.aabb);
                      m = e;
                      e = e.parent
                  } while (e)
              } else {
                  m.child1 = f;
                  m.child2 = b;
                  f.parent = m;
                  this.m_root = b.parent =
                      m
              }
          }
      };
      u.prototype.RemoveLeaf = function(b) {
          if (b == this.m_root) this.m_root = null;
          else {
              var e = b.parent,
                  f = e.parent;
              b = e.child1 == b ? e.child2 : e.child1;
              if (f) {
                  if (f.child1 == e) f.child1 = b;
                  else f.child2 = b;
                  b.parent = f;
                  for (this.FreeNode(e); f;) {
                      e = f.aabb;
                      f.aabb = B.Combine(f.child1.aabb, f.child2.aabb);
                      if (e.Contains(f.aabb)) break;
                      f = f.parent
                  }
              } else {
                  this.m_root = b;
                  b.parent = null;
                  this.FreeNode(e)
              }
          }
      };
      D.b2DynamicTreeBroadPhase = function() {
          this.m_tree = new u;
          this.m_moveBuffer = new Vector;
          this.m_pairBuffer = new Vector;
          this.m_pairCount = 0
      };
      D.prototype.CreateProxy = function(b, e) {
          var f = this.m_tree.CreateProxy(b, e);
          ++this.m_proxyCount;
          this.BufferMove(f);
          return f
      };
      D.prototype.DestroyProxy = function(b) {
          this.UnBufferMove(b);
          --this.m_proxyCount;
          this.m_tree.DestroyProxy(b)
      };
      D.prototype.MoveProxy = function(b, e, f) {
          this.m_tree.MoveProxy(b, e, f) && this.BufferMove(b)
      };
      D.prototype.TestOverlap = function(b, e) {
          var f = this.m_tree.GetFatAABB(b),
              m = this.m_tree.GetFatAABB(e);
          return f.TestOverlap(m)
      };
      D.prototype.GetUserData = function(b) {
          return this.m_tree.GetUserData(b)
      };
      D.prototype.GetFatAABB = function(b) {
          return this.m_tree.GetFatAABB(b)
      };
      D.prototype.GetProxyCount = function() {
          return this.m_proxyCount
      };
      D.prototype.UpdatePairs = function(b) {
          var e = this;
          var f = e.m_pairCount = 0,
              m;
          for (f = 0; f < e.m_moveBuffer.length; ++f) {
              m = e.m_moveBuffer[f];
              var r = e.m_tree.GetFatAABB(m);
              e.m_tree.Query(function(t) {
                      if (t == m) return true;
                      if (e.m_pairCount == e.m_pairBuffer.length) e.m_pairBuffer[e.m_pairCount] = new O;
                      var x = e.m_pairBuffer[e.m_pairCount];
                      x.proxyA = t < m ? t : m;
                      x.proxyB = t >= m ? t : m;
                      ++e.m_pairCount;
                      return true
                  },
                  r)
          }
          for (f = e.m_moveBuffer.length = 0; f < e.m_pairCount;) {
              r = e.m_pairBuffer[f];
              var s = e.m_tree.GetUserData(r.proxyA),
                  v = e.m_tree.GetUserData(r.proxyB);
              b(s, v);
              for (++f; f < e.m_pairCount;) {
                  s = e.m_pairBuffer[f];
                  if (s.proxyA != r.proxyA || s.proxyB != r.proxyB) break;
                  ++f
              }
          }
      };
      D.prototype.Query = function(b, e) {
          this.m_tree.Query(b, e)
      };
      D.prototype.RayCast = function(b, e) {
          this.m_tree.RayCast(b, e)
      };
      D.prototype.Validate = function() {};
      D.prototype.Rebalance = function(b) {
          if (b === undefined) b = 0;
          this.m_tree.Rebalance(b)
      };
      D.prototype.BufferMove =
          function(b) {
              this.m_moveBuffer[this.m_moveBuffer.length] = b
          };
      D.prototype.UnBufferMove = function(b) {
          this.m_moveBuffer.splice(parseInt(this.m_moveBuffer.indexOf(b)), 1)
      };
      D.prototype.ComparePairs = function() {
          return 0
      };
      D.__implements = {};
      D.__implements[g] = true;
      H.b2DynamicTreeNode = function() {
          this.aabb = new B
      };
      H.prototype.IsLeaf = function() {
          return this.child1 == null
      };
      O.b2DynamicTreePair = function() {};
      E.b2Manifold = function() {
          this.m_pointCount = 0
      };
      E.prototype.b2Manifold = function() {
          this.m_points = new Vector(y.b2_maxManifoldPoints);
          for (var b = 0; b < y.b2_maxManifoldPoints; b++) this.m_points[b] = new R;
          this.m_localPlaneNormal = new p;
          this.m_localPoint = new p
      };
      E.prototype.Reset = function() {
          for (var b = 0; b < y.b2_maxManifoldPoints; b++)(this.m_points[b] instanceof R ? this.m_points[b] : null).Reset();
          this.m_localPlaneNormal.SetZero();
          this.m_localPoint.SetZero();
          this.m_pointCount = this.m_type = 0
      };
      E.prototype.Set = function(b) {
          this.m_pointCount = b.m_pointCount;
          for (var e = 0; e < y.b2_maxManifoldPoints; e++)(this.m_points[e] instanceof R ? this.m_points[e] : null).Set(b.m_points[e]);
          this.m_localPlaneNormal.SetV(b.m_localPlaneNormal);
          this.m_localPoint.SetV(b.m_localPoint);
          this.m_type = b.m_type
      };
      E.prototype.Copy = function() {
          var b = new E;
          b.Set(this);
          return b
      };
      Box2D.postDefs.push(function() {
          Box2D.Collision.b2Manifold.e_circles = 1;
          Box2D.Collision.b2Manifold.e_faceA = 2;
          Box2D.Collision.b2Manifold.e_faceB = 4
      });
      R.b2ManifoldPoint = function() {
          this.m_localPoint = new p;
          this.m_id = new L
      };
      R.prototype.b2ManifoldPoint = function() {
          this.Reset()
      };
      R.prototype.Reset = function() {
          this.m_localPoint.SetZero();
          this.m_tangentImpulse =
              this.m_normalImpulse = 0;
          this.m_id.key = 0
      };
      R.prototype.Set = function(b) {
          this.m_localPoint.SetV(b.m_localPoint);
          this.m_normalImpulse = b.m_normalImpulse;
          this.m_tangentImpulse = b.m_tangentImpulse;
          this.m_id.Set(b.m_id)
      };
      N.b2Point = function() {
          this.p = new p
      };
      N.prototype.Support = function() {
          return this.p
      };
      N.prototype.GetFirstVertex = function() {
          return this.p
      };
      S.b2RayCastInput = function() {
          this.p1 = new p;
          this.p2 = new p
      };
      S.prototype.b2RayCastInput = function(b, e, f) {
          if (b === undefined) b = null;
          if (e === undefined) e = null;
          if (f === undefined) f =
              1;
          b && this.p1.SetV(b);
          e && this.p2.SetV(e);
          this.maxFraction = f
      };
      aa.b2RayCastOutput = function() {
          this.normal = new p
      };
      Z.b2Segment = function() {
          this.p1 = new p;
          this.p2 = new p
      };
      Z.prototype.TestSegment = function(b, e, f, m) {
          if (m === undefined) m = 0;
          var r = f.p1,
              s = f.p2.x - r.x,
              v = f.p2.y - r.y;
          f = this.p2.y - this.p1.y;
          var t = -(this.p2.x - this.p1.x),
              x = 100 * Number.MIN_VALUE,
              C = -(s * f + v * t);
          if (C > x) {
              var J = r.x - this.p1.x,
                  T = r.y - this.p1.y;
              r = J * f + T * t;
              if (0 <= r && r <= m * C) {
                  m = -s * T + v * J;
                  if (-x * C <= m && m <= C * (1 + x)) {
                      r /= C;
                      m = Math.sqrt(f * f + t * t);
                      f /= m;
                      t /= m;
                      b[0] = r;
                      e.Set(f,
                          t);
                      return true
                  }
              }
          }
          return false
      };
      Z.prototype.Extend = function(b) {
          this.ExtendForward(b);
          this.ExtendBackward(b)
      };
      Z.prototype.ExtendForward = function(b) {
          var e = this.p2.x - this.p1.x,
              f = this.p2.y - this.p1.y;
          b = Math.min(e > 0 ? (b.upperBound.x - this.p1.x) / e : e < 0 ? (b.lowerBound.x - this.p1.x) / e : Number.POSITIVE_INFINITY, f > 0 ? (b.upperBound.y - this.p1.y) / f : f < 0 ? (b.lowerBound.y - this.p1.y) / f : Number.POSITIVE_INFINITY);
          this.p2.x = this.p1.x + e * b;
          this.p2.y = this.p1.y + f * b
      };
      Z.prototype.ExtendBackward = function(b) {
          var e = -this.p2.x + this.p1.x,
              f = -this.p2.y + this.p1.y;
          b = Math.min(e > 0 ? (b.upperBound.x - this.p2.x) / e : e < 0 ? (b.lowerBound.x - this.p2.x) / e : Number.POSITIVE_INFINITY, f > 0 ? (b.upperBound.y - this.p2.y) / f : f < 0 ? (b.lowerBound.y - this.p2.y) / f : Number.POSITIVE_INFINITY);
          this.p1.x = this.p2.x + e * b;
          this.p1.y = this.p2.y + f * b
      };
      d.b2SeparationFunction = function() {
          this.m_localPoint = new p;
          this.m_axis = new p
      };
      d.prototype.Initialize = function(b, e, f, m, r) {
          this.m_proxyA = e;
          this.m_proxyB = m;
          var s = parseInt(b.count);
          y.b2Assert(0 < s && s < 3);
          var v, t, x, C, J = C = x = m = e = 0,
              T = 0;
          J = 0;
          if (s ==
              1) {
              this.m_type = d.e_points;
              v = this.m_proxyA.GetVertex(b.indexA[0]);
              t = this.m_proxyB.GetVertex(b.indexB[0]);
              s = v;
              b = f.R;
              e = f.position.x + (b.col1.x * s.x + b.col2.x * s.y);
              m = f.position.y + (b.col1.y * s.x + b.col2.y * s.y);
              s = t;
              b = r.R;
              x = r.position.x + (b.col1.x * s.x + b.col2.x * s.y);
              C = r.position.y + (b.col1.y * s.x + b.col2.y * s.y);
              this.m_axis.x = x - e;
              this.m_axis.y = C - m;
              this.m_axis.Normalize()
          } else {
              if (b.indexB[0] == b.indexB[1]) {
                  this.m_type = d.e_faceA;
                  e = this.m_proxyA.GetVertex(b.indexA[0]);
                  m = this.m_proxyA.GetVertex(b.indexA[1]);
                  t = this.m_proxyB.GetVertex(b.indexB[0]);
                  this.m_localPoint.x = 0.5 * (e.x + m.x);
                  this.m_localPoint.y = 0.5 * (e.y + m.y);
                  this.m_axis = w.CrossVF(w.SubtractVV(m, e), 1);
                  this.m_axis.Normalize();
                  s = this.m_axis;
                  b = f.R;
                  J = b.col1.x * s.x + b.col2.x * s.y;
                  T = b.col1.y * s.x + b.col2.y * s.y;
                  s = this.m_localPoint;
                  b = f.R;
                  e = f.position.x + (b.col1.x * s.x + b.col2.x * s.y);
                  m = f.position.y + (b.col1.y * s.x + b.col2.y * s.y);
                  s = t;
                  b = r.R;
                  x = r.position.x + (b.col1.x * s.x + b.col2.x * s.y);
                  C = r.position.y + (b.col1.y * s.x + b.col2.y * s.y);
                  J = (x - e) * J + (C - m) * T
              } else if (b.indexA[0] == b.indexA[0]) {
                  this.m_type = d.e_faceB;
                  x = this.m_proxyB.GetVertex(b.indexB[0]);
                  C = this.m_proxyB.GetVertex(b.indexB[1]);
                  v = this.m_proxyA.GetVertex(b.indexA[0]);
                  this.m_localPoint.x = 0.5 * (x.x + C.x);
                  this.m_localPoint.y = 0.5 * (x.y + C.y);
                  this.m_axis = w.CrossVF(w.SubtractVV(C, x), 1);
                  this.m_axis.Normalize();
                  s = this.m_axis;
                  b = r.R;
                  J = b.col1.x * s.x + b.col2.x * s.y;
                  T = b.col1.y * s.x + b.col2.y * s.y;
                  s = this.m_localPoint;
                  b = r.R;
                  x = r.position.x + (b.col1.x * s.x + b.col2.x * s.y);
                  C = r.position.y + (b.col1.y * s.x + b.col2.y * s.y);
                  s = v;
                  b = f.R;
                  e = f.position.x + (b.col1.x * s.x + b.col2.x * s.y);
                  m = f.position.y + (b.col1.y * s.x + b.col2.y * s.y);
                  J = (e -
                      x) * J + (m - C) * T
              } else {
                  e = this.m_proxyA.GetVertex(b.indexA[0]);
                  m = this.m_proxyA.GetVertex(b.indexA[1]);
                  x = this.m_proxyB.GetVertex(b.indexB[0]);
                  C = this.m_proxyB.GetVertex(b.indexB[1]);
                  w.MulX(f, v);
                  v = w.MulMV(f.R, w.SubtractVV(m, e));
                  w.MulX(r, t);
                  J = w.MulMV(r.R, w.SubtractVV(C, x));
                  r = v.x * v.x + v.y * v.y;
                  t = J.x * J.x + J.y * J.y;
                  b = w.SubtractVV(J, v);
                  f = v.x * b.x + v.y * b.y;
                  b = J.x * b.x + J.y * b.y;
                  v = v.x * J.x + v.y * J.y;
                  T = r * t - v * v;
                  J = 0;
                  if (T != 0) J = w.Clamp((v * b - f * t) / T, 0, 1);
                  if ((v * J + b) / t < 0) J = w.Clamp((v - f) / r, 0, 1);
                  v = new p;
                  v.x = e.x + J * (m.x - e.x);
                  v.y = e.y + J * (m.y -
                      e.y);
                  t = new p;
                  t.x = x.x + J * (C.x - x.x);
                  t.y = x.y + J * (C.y - x.y);
                  if (J == 0 || J == 1) {
                      this.m_type = d.e_faceB;
                      this.m_axis = w.CrossVF(w.SubtractVV(C, x), 1);
                      this.m_axis.Normalize();
                      this.m_localPoint = t
                  } else {
                      this.m_type = d.e_faceA;
                      this.m_axis = w.CrossVF(w.SubtractVV(m, e), 1);
                      this.m_localPoint = v
                  }
              }
              J < 0 && this.m_axis.NegativeSelf()
          }
      };
      d.prototype.Evaluate = function(b, e) {
          var f, m, r = 0;
          switch (this.m_type) {
              case d.e_points:
                  f = w.MulTMV(b.R, this.m_axis);
                  m = w.MulTMV(e.R, this.m_axis.GetNegative());
                  f = this.m_proxyA.GetSupportVertex(f);
                  m = this.m_proxyB.GetSupportVertex(m);
                  f = w.MulX(b, f);
                  m = w.MulX(e, m);
                  return r = (m.x - f.x) * this.m_axis.x + (m.y - f.y) * this.m_axis.y;
              case d.e_faceA:
                  r = w.MulMV(b.R, this.m_axis);
                  f = w.MulX(b, this.m_localPoint);
                  m = w.MulTMV(e.R, r.GetNegative());
                  m = this.m_proxyB.GetSupportVertex(m);
                  m = w.MulX(e, m);
                  return r = (m.x - f.x) * r.x + (m.y - f.y) * r.y;
              case d.e_faceB:
                  r = w.MulMV(e.R, this.m_axis);
                  m = w.MulX(e, this.m_localPoint);
                  f = w.MulTMV(b.R, r.GetNegative());
                  f = this.m_proxyA.GetSupportVertex(f);
                  f = w.MulX(b, f);
                  return r = (f.x - m.x) * r.x + (f.y - m.y) * r.y;
              default:
                  y.b2Assert(false);
                  return 0
          }
      };
      Box2D.postDefs.push(function() {
          Box2D.Collision.b2SeparationFunction.e_points = 1;
          Box2D.Collision.b2SeparationFunction.e_faceA = 2;
          Box2D.Collision.b2SeparationFunction.e_faceB = 4
      });
      h.b2Simplex = function() {
          this.m_v1 = new j;
          this.m_v2 = new j;
          this.m_v3 = new j;
          this.m_vertices = new Vector(3)
      };
      h.prototype.b2Simplex = function() {
          this.m_vertices[0] = this.m_v1;
          this.m_vertices[1] = this.m_v2;
          this.m_vertices[2] = this.m_v3
      };
      h.prototype.ReadCache = function(b, e, f, m, r) {
          y.b2Assert(0 <= b.count && b.count <= 3);
          var s, v;
          this.m_count = b.count;
          for (var t = this.m_vertices, x = 0; x < this.m_count; x++) {
              var C = t[x];
              C.indexA = b.indexA[x];
              C.indexB = b.indexB[x];
              s = e.GetVertex(C.indexA);
              v = m.GetVertex(C.indexB);
              C.wA = w.MulX(f, s);
              C.wB = w.MulX(r, v);
              C.w = w.SubtractVV(C.wB, C.wA);
              C.a = 0
          }
          if (this.m_count > 1) {
              b = b.metric;
              s = this.GetMetric();
              if (s < 0.5 * b || 2 * b < s || s < Number.MIN_VALUE) this.m_count = 0
          }
          if (this.m_count == 0) {
              C = t[0];
              C.indexA = 0;
              C.indexB = 0;
              s = e.GetVertex(0);
              v = m.GetVertex(0);
              C.wA = w.MulX(f, s);
              C.wB = w.MulX(r, v);
              C.w = w.SubtractVV(C.wB, C.wA);
              this.m_count = 1
          }
      };
      h.prototype.WriteCache =
          function(b) {
              b.metric = this.GetMetric();
              b.count = Box2D.parseUInt(this.m_count);
              for (var e = this.m_vertices, f = 0; f < this.m_count; f++) {
                  b.indexA[f] = Box2D.parseUInt(e[f].indexA);
                  b.indexB[f] = Box2D.parseUInt(e[f].indexB)
              }
          };
      h.prototype.GetSearchDirection = function() {
          switch (this.m_count) {
              case 1:
                  return this.m_v1.w.GetNegative();
              case 2:
                  var b = w.SubtractVV(this.m_v2.w, this.m_v1.w);
                  return w.CrossVV(b, this.m_v1.w.GetNegative()) > 0 ? w.CrossFV(1, b) : w.CrossVF(b, 1);
              default:
                  y.b2Assert(false);
                  return new p
          }
      };
      h.prototype.GetClosestPoint =
          function() {
              switch (this.m_count) {
                  case 0:
                      y.b2Assert(false);
                      return new p;
                  case 1:
                      return this.m_v1.w;
                  case 2:
                      return new p(this.m_v1.a * this.m_v1.w.x + this.m_v2.a * this.m_v2.w.x, this.m_v1.a * this.m_v1.w.y + this.m_v2.a * this.m_v2.w.y);
                  default:
                      y.b2Assert(false);
                      return new p
              }
          };
      h.prototype.GetWitnessPoints = function(b, e) {
          switch (this.m_count) {
              case 0:
                  y.b2Assert(false);
                  break;
              case 1:
                  b.SetV(this.m_v1.wA);
                  e.SetV(this.m_v1.wB);
                  break;
              case 2:
                  b.x = this.m_v1.a * this.m_v1.wA.x + this.m_v2.a * this.m_v2.wA.x;
                  b.y = this.m_v1.a * this.m_v1.wA.y +
                      this.m_v2.a * this.m_v2.wA.y;
                  e.x = this.m_v1.a * this.m_v1.wB.x + this.m_v2.a * this.m_v2.wB.x;
                  e.y = this.m_v1.a * this.m_v1.wB.y + this.m_v2.a * this.m_v2.wB.y;
                  break;
              case 3:
                  e.x = b.x = this.m_v1.a * this.m_v1.wA.x + this.m_v2.a * this.m_v2.wA.x + this.m_v3.a * this.m_v3.wA.x;
                  e.y = b.y = this.m_v1.a * this.m_v1.wA.y + this.m_v2.a * this.m_v2.wA.y + this.m_v3.a * this.m_v3.wA.y;
                  break;
              default:
                  y.b2Assert(false)
          }
      };
      h.prototype.GetMetric = function() {
          switch (this.m_count) {
              case 0:
                  y.b2Assert(false);
                  return 0;
              case 1:
                  return 0;
              case 2:
                  return w.SubtractVV(this.m_v1.w,
                      this.m_v2.w).Length();
              case 3:
                  return w.CrossVV(w.SubtractVV(this.m_v2.w, this.m_v1.w), w.SubtractVV(this.m_v3.w, this.m_v1.w));
              default:
                  y.b2Assert(false);
                  return 0
          }
      };
      h.prototype.Solve2 = function() {
          var b = this.m_v1.w,
              e = this.m_v2.w,
              f = w.SubtractVV(e, b);
          b = -(b.x * f.x + b.y * f.y);
          if (b <= 0) this.m_count = this.m_v1.a = 1;
          else {
              e = e.x * f.x + e.y * f.y;
              if (e <= 0) {
                  this.m_count = this.m_v2.a = 1;
                  this.m_v1.Set(this.m_v2)
              } else {
                  f = 1 / (e + b);
                  this.m_v1.a = e * f;
                  this.m_v2.a = b * f;
                  this.m_count = 2
              }
          }
      };
      h.prototype.Solve3 = function() {
          var b = this.m_v1.w,
              e = this.m_v2.w,
              f = this.m_v3.w,
              m = w.SubtractVV(e, b),
              r = w.Dot(b, m),
              s = w.Dot(e, m);
          r = -r;
          var v = w.SubtractVV(f, b),
              t = w.Dot(b, v),
              x = w.Dot(f, v);
          t = -t;
          var C = w.SubtractVV(f, e),
              J = w.Dot(e, C);
          C = w.Dot(f, C);
          J = -J;
          v = w.CrossVV(m, v);
          m = v * w.CrossVV(e, f);
          f = v * w.CrossVV(f, b);
          b = v * w.CrossVV(b, e);
          if (r <= 0 && t <= 0) this.m_count = this.m_v1.a = 1;
          else if (s > 0 && r > 0 && b <= 0) {
              x = 1 / (s + r);
              this.m_v1.a = s * x;
              this.m_v2.a = r * x;
              this.m_count = 2
          } else if (x > 0 && t > 0 && f <= 0) {
              s = 1 / (x + t);
              this.m_v1.a = x * s;
              this.m_v3.a = t * s;
              this.m_count = 2;
              this.m_v2.Set(this.m_v3)
          } else if (s <= 0 && J <= 0) {
              this.m_count =
                  this.m_v2.a = 1;
              this.m_v1.Set(this.m_v2)
          } else if (x <= 0 && C <= 0) {
              this.m_count = this.m_v3.a = 1;
              this.m_v1.Set(this.m_v3)
          } else if (C > 0 && J > 0 && m <= 0) {
              s = 1 / (C + J);
              this.m_v2.a = C * s;
              this.m_v3.a = J * s;
              this.m_count = 2;
              this.m_v1.Set(this.m_v3)
          } else {
              s = 1 / (m + f + b);
              this.m_v1.a = m * s;
              this.m_v2.a = f * s;
              this.m_v3.a = b * s;
              this.m_count = 3
          }
      };
      l.b2SimplexCache = function() {
          this.indexA = new Vector_a2j_Number(3);
          this.indexB = new Vector_a2j_Number(3)
      };
      j.b2SimplexVertex = function() {};
      j.prototype.Set = function(b) {
          this.wA.SetV(b.wA);
          this.wB.SetV(b.wB);
          this.w.SetV(b.w);
          this.a = b.a;
          this.indexA = b.indexA;
          this.indexB = b.indexB
      };
      o.b2TimeOfImpact = function() {};
      o.TimeOfImpact = function(b) {
          ++o.b2_toiCalls;
          var e = b.proxyA,
              f = b.proxyB,
              m = b.sweepA,
              r = b.sweepB;
          y.b2Assert(m.t0 == r.t0);
          y.b2Assert(1 - m.t0 > Number.MIN_VALUE);
          var s = e.m_radius + f.m_radius;
          b = b.tolerance;
          var v = 0,
              t = 0,
              x = 0;
          o.s_cache.count = 0;
          for (o.s_distanceInput.useRadii = false;;) {
              m.GetTransform(o.s_xfA, v);
              r.GetTransform(o.s_xfB, v);
              o.s_distanceInput.proxyA = e;
              o.s_distanceInput.proxyB = f;
              o.s_distanceInput.transformA = o.s_xfA;
              o.s_distanceInput.transformB =
                  o.s_xfB;
              W.Distance(o.s_distanceOutput, o.s_cache, o.s_distanceInput);
              if (o.s_distanceOutput.distance <= 0) {
                  v = 1;
                  break
              }
              o.s_fcn.Initialize(o.s_cache, e, o.s_xfA, f, o.s_xfB);
              var C = o.s_fcn.Evaluate(o.s_xfA, o.s_xfB);
              if (C <= 0) {
                  v = 1;
                  break
              }
              if (t == 0) x = C > s ? w.Max(s - b, 0.75 * s) : w.Max(C - b, 0.02 * s);
              if (C - x < 0.5 * b) {
                  if (t == 0) {
                      v = 1;
                      break
                  }
                  break
              }
              var J = v,
                  T = v,
                  P = 1;
              C = C;
              m.GetTransform(o.s_xfA, P);
              r.GetTransform(o.s_xfB, P);
              var X = o.s_fcn.Evaluate(o.s_xfA, o.s_xfB);
              if (X >= x) {
                  v = 1;
                  break
              }
              for (var $ = 0;;) {
                  var ba = 0;
                  ba = $ & 1 ? T + (x - C) * (P - T) / (X - C) : 0.5 * (T + P);
                  m.GetTransform(o.s_xfA, ba);
                  r.GetTransform(o.s_xfB, ba);
                  var ca = o.s_fcn.Evaluate(o.s_xfA, o.s_xfB);
                  if (w.Abs(ca - x) < 0.025 * b) {
                      J = ba;
                      break
                  }
                  if (ca > x) {
                      T = ba;
                      C = ca
                  } else {
                      P = ba;
                      X = ca
                  }++$;
                  ++o.b2_toiRootIters;
                  if ($ == 50) break
              }
              o.b2_toiMaxRootIters = w.Max(o.b2_toiMaxRootIters, $);
              if (J < (1 + 100 * Number.MIN_VALUE) * v) break;
              v = J;
              t++;
              ++o.b2_toiIters;
              if (t == 1E3) break
          }
          o.b2_toiMaxIters = w.Max(o.b2_toiMaxIters, t);
          return v
      };
      Box2D.postDefs.push(function() {
          Box2D.Collision.b2TimeOfImpact.b2_toiCalls = 0;
          Box2D.Collision.b2TimeOfImpact.b2_toiIters =
              0;
          Box2D.Collision.b2TimeOfImpact.b2_toiMaxIters = 0;
          Box2D.Collision.b2TimeOfImpact.b2_toiRootIters = 0;
          Box2D.Collision.b2TimeOfImpact.b2_toiMaxRootIters = 0;
          Box2D.Collision.b2TimeOfImpact.s_cache = new l;
          Box2D.Collision.b2TimeOfImpact.s_distanceInput = new Y;
          Box2D.Collision.b2TimeOfImpact.s_xfA = new U;
          Box2D.Collision.b2TimeOfImpact.s_xfB = new U;
          Box2D.Collision.b2TimeOfImpact.s_fcn = new d;
          Box2D.Collision.b2TimeOfImpact.s_distanceOutput = new k
      });
      q.b2TOIInput = function() {
          this.proxyA = new z;
          this.proxyB = new z;
          this.sweepA =
              new A;
          this.sweepB = new A
      };
      n.b2WorldManifold = function() {
          this.m_normal = new p
      };
      n.prototype.b2WorldManifold = function() {
          this.m_points = new Vector(y.b2_maxManifoldPoints);
          for (var b = 0; b < y.b2_maxManifoldPoints; b++) this.m_points[b] = new p
      };
      n.prototype.Initialize = function(b, e, f, m, r) {
          if (f === undefined) f = 0;
          if (r === undefined) r = 0;
          if (b.m_pointCount != 0) {
              var s = 0,
                  v, t, x = 0,
                  C = 0,
                  J = 0,
                  T = 0,
                  P = 0;
              v = 0;
              switch (b.m_type) {
                  case E.e_circles:
                      t = e.R;
                      v = b.m_localPoint;
                      s = e.position.x + t.col1.x * v.x + t.col2.x * v.y;
                      e = e.position.y + t.col1.y * v.x + t.col2.y *
                          v.y;
                      t = m.R;
                      v = b.m_points[0].m_localPoint;
                      b = m.position.x + t.col1.x * v.x + t.col2.x * v.y;
                      m = m.position.y + t.col1.y * v.x + t.col2.y * v.y;
                      v = b - s;
                      t = m - e;
                      x = v * v + t * t;
                      if (x > Number.MIN_VALUE * Number.MIN_VALUE) {
                          x = Math.sqrt(x);
                          this.m_normal.x = v / x;
                          this.m_normal.y = t / x
                      } else {
                          this.m_normal.x = 1;
                          this.m_normal.y = 0
                      }
                      v = e + f * this.m_normal.y;
                      m = m - r * this.m_normal.y;
                      this.m_points[0].x = 0.5 * (s + f * this.m_normal.x + (b - r * this.m_normal.x));
                      this.m_points[0].y = 0.5 * (v + m);
                      break;
                  case E.e_faceA:
                      t = e.R;
                      v = b.m_localPlaneNormal;
                      x = t.col1.x * v.x + t.col2.x * v.y;
                      C = t.col1.y *
                          v.x + t.col2.y * v.y;
                      t = e.R;
                      v = b.m_localPoint;
                      J = e.position.x + t.col1.x * v.x + t.col2.x * v.y;
                      T = e.position.y + t.col1.y * v.x + t.col2.y * v.y;
                      this.m_normal.x = x;
                      this.m_normal.y = C;
                      for (s = 0; s < b.m_pointCount; s++) {
                          t = m.R;
                          v = b.m_points[s].m_localPoint;
                          P = m.position.x + t.col1.x * v.x + t.col2.x * v.y;
                          v = m.position.y + t.col1.y * v.x + t.col2.y * v.y;
                          this.m_points[s].x = P + 0.5 * (f - (P - J) * x - (v - T) * C - r) * x;
                          this.m_points[s].y = v + 0.5 * (f - (P - J) * x - (v - T) * C - r) * C
                      }
                      break;
                  case E.e_faceB:
                      t = m.R;
                      v = b.m_localPlaneNormal;
                      x = t.col1.x * v.x + t.col2.x * v.y;
                      C = t.col1.y * v.x + t.col2.y *
                          v.y;
                      t = m.R;
                      v = b.m_localPoint;
                      J = m.position.x + t.col1.x * v.x + t.col2.x * v.y;
                      T = m.position.y + t.col1.y * v.x + t.col2.y * v.y;
                      this.m_normal.x = -x;
                      this.m_normal.y = -C;
                      for (s = 0; s < b.m_pointCount; s++) {
                          t = e.R;
                          v = b.m_points[s].m_localPoint;
                          P = e.position.x + t.col1.x * v.x + t.col2.x * v.y;
                          v = e.position.y + t.col1.y * v.x + t.col2.y * v.y;
                          this.m_points[s].x = P + 0.5 * (r - (P - J) * x - (v - T) * C - f) * x;
                          this.m_points[s].y = v + 0.5 * (r - (P - J) * x - (v - T) * C - f) * C
                      }
              }
          }
      };
      a.ClipVertex = function() {
          this.v = new p;
          this.id = new L
      };
      a.prototype.Set = function(b) {
          this.v.SetV(b.v);
          this.id.Set(b.id)
      };
      c.Features = function() {};
      Object.defineProperty(c.prototype, "referenceEdge", {
          enumerable: false,
          configurable: true,
          get: function() {
              return this._referenceEdge
          }
      });
      Object.defineProperty(c.prototype, "referenceEdge", {
          enumerable: false,
          configurable: true,
          set: function(b) {
              if (b === undefined) b = 0;
              this._referenceEdge = b;
              this._m_id._key = this._m_id._key & 4294967040 | this._referenceEdge & 255
          }
      });
      Object.defineProperty(c.prototype, "incidentEdge", {
          enumerable: false,
          configurable: true,
          get: function() {
              return this._incidentEdge
          }
      });
      Object.defineProperty(c.prototype,
          "incidentEdge", {
              enumerable: false,
              configurable: true,
              set: function(b) {
                  if (b === undefined) b = 0;
                  this._incidentEdge = b;
                  this._m_id._key = this._m_id._key & 4294902015 | this._incidentEdge << 8 & 65280
              }
          });
      Object.defineProperty(c.prototype, "incidentVertex", {
          enumerable: false,
          configurable: true,
          get: function() {
              return this._incidentVertex
          }
      });
      Object.defineProperty(c.prototype, "incidentVertex", {
          enumerable: false,
          configurable: true,
          set: function(b) {
              if (b === undefined) b = 0;
              this._incidentVertex = b;
              this._m_id._key = this._m_id._key & 4278255615 |
                  this._incidentVertex << 16 & 16711680
          }
      });
      Object.defineProperty(c.prototype, "flip", {
          enumerable: false,
          configurable: true,
          get: function() {
              return this._flip
          }
      });
      Object.defineProperty(c.prototype, "flip", {
          enumerable: false,
          configurable: true,
          set: function(b) {
              if (b === undefined) b = 0;
              this._flip = b;
              this._m_id._key = this._m_id._key & 16777215 | this._flip << 24 & 4278190080
          }
      })
  })();
  (function() {
      var F = Box2D.Common.b2Settings,
          G = Box2D.Collision.Shapes.b2CircleShape,
          K = Box2D.Collision.Shapes.b2EdgeChainDef,
          y = Box2D.Collision.Shapes.b2EdgeShape,
          w = Box2D.Collision.Shapes.b2MassData,
          A = Box2D.Collision.Shapes.b2PolygonShape,
          U = Box2D.Collision.Shapes.b2Shape,
          p = Box2D.Common.Math.b2Mat22,
          B = Box2D.Common.Math.b2Math,
          Q = Box2D.Common.Math.b2Transform,
          V = Box2D.Common.Math.b2Vec2,
          M = Box2D.Collision.b2Distance,
          L = Box2D.Collision.b2DistanceInput,
          I = Box2D.Collision.b2DistanceOutput,
          W = Box2D.Collision.b2DistanceProxy,
          Y = Box2D.Collision.b2SimplexCache;
      Box2D.inherit(G, Box2D.Collision.Shapes.b2Shape);
      G.prototype.__super = Box2D.Collision.Shapes.b2Shape.prototype;
      G.b2CircleShape = function() {
          Box2D.Collision.Shapes.b2Shape.b2Shape.apply(this, arguments);
          this.m_p = new V
      };
      G.prototype.Copy = function() {
          var k = new G;
          k.Set(this);
          return k
      };
      G.prototype.Set = function(k) {
          this.__super.Set.call(this, k);
          if (Box2D.is(k, G)) this.m_p.SetV((k instanceof G ? k : null).m_p)
      };
      G.prototype.TestPoint = function(k, z) {
          var u = k.R,
              D = k.position.x + (u.col1.x * this.m_p.x +
                  u.col2.x * this.m_p.y);
          u = k.position.y + (u.col1.y * this.m_p.x + u.col2.y * this.m_p.y);
          D = z.x - D;
          u = z.y - u;
          return D * D + u * u <= this.m_radius * this.m_radius
      };
      G.prototype.RayCast = function(k, z, u) {
          var D = u.R,
              H = z.p1.x - (u.position.x + (D.col1.x * this.m_p.x + D.col2.x * this.m_p.y));
          u = z.p1.y - (u.position.y + (D.col1.y * this.m_p.x + D.col2.y * this.m_p.y));
          D = z.p2.x - z.p1.x;
          var O = z.p2.y - z.p1.y,
              E = H * D + u * O,
              R = D * D + O * O,
              N = E * E - R * (H * H + u * u - this.m_radius * this.m_radius);
          if (N < 0 || R < Number.MIN_VALUE) return false;
          E = -(E + Math.sqrt(N));
          if (0 <= E && E <= z.maxFraction *
              R) {
              E /= R;
              k.fraction = E;
              k.normal.x = H + E * D;
              k.normal.y = u + E * O;
              k.normal.Normalize();
              return true
          }
          return false
      };
      G.prototype.ComputeAABB = function(k, z) {
          var u = z.R,
              D = z.position.x + (u.col1.x * this.m_p.x + u.col2.x * this.m_p.y);
          u = z.position.y + (u.col1.y * this.m_p.x + u.col2.y * this.m_p.y);
          k.lowerBound.Set(D - this.m_radius, u - this.m_radius);
          k.upperBound.Set(D + this.m_radius, u + this.m_radius)
      };
      G.prototype.ComputeMass = function(k, z) {
          if (z === undefined) z = 0;
          k.mass = z * F.b2_pi * this.m_radius * this.m_radius;
          k.center.SetV(this.m_p);
          k.I = k.mass *
              (0.5 * this.m_radius * this.m_radius + (this.m_p.x * this.m_p.x + this.m_p.y * this.m_p.y))
      };
      G.prototype.ComputeSubmergedArea = function(k, z, u, D) {
          if (z === undefined) z = 0;
          u = B.MulX(u, this.m_p);
          var H = -(B.Dot(k, u) - z);
          if (H < -this.m_radius + Number.MIN_VALUE) return 0;
          if (H > this.m_radius) {
              D.SetV(u);
              return Math.PI * this.m_radius * this.m_radius
          }
          z = this.m_radius * this.m_radius;
          var O = H * H;
          H = z * (Math.asin(H / this.m_radius) + Math.PI / 2) + H * Math.sqrt(z - O);
          z = -2 / 3 * Math.pow(z - O, 1.5) / H;
          D.x = u.x + k.x * z;
          D.y = u.y + k.y * z;
          return H
      };
      G.prototype.GetLocalPosition =
          function() {
              return this.m_p
          };
      G.prototype.SetLocalPosition = function(k) {
          this.m_p.SetV(k)
      };
      G.prototype.GetRadius = function() {
          return this.m_radius
      };
      G.prototype.SetRadius = function(k) {
          if (k === undefined) k = 0;
          this.m_radius = k
      };
      G.prototype.b2CircleShape = function(k) {
          if (k === undefined) k = 0;
          this.__super.b2Shape.call(this);
          this.m_type = U.e_circleShape;
          this.m_radius = k
      };
      K.b2EdgeChainDef = function() {};
      K.prototype.b2EdgeChainDef = function() {
          this.vertexCount = 0;
          this.isALoop = true;
          this.vertices = []
      };
      Box2D.inherit(y, Box2D.Collision.Shapes.b2Shape);
      y.prototype.__super = Box2D.Collision.Shapes.b2Shape.prototype;
      y.b2EdgeShape = function() {
          Box2D.Collision.Shapes.b2Shape.b2Shape.apply(this, arguments);
          this.s_supportVec = new V;
          this.m_v1 = new V;
          this.m_v2 = new V;
          this.m_coreV1 = new V;
          this.m_coreV2 = new V;
          this.m_normal = new V;
          this.m_direction = new V;
          this.m_cornerDir1 = new V;
          this.m_cornerDir2 = new V
      };
      y.prototype.TestPoint = function() {
          return false
      };
      y.prototype.RayCast = function(k, z, u) {
          var D, H = z.p2.x - z.p1.x,
              O = z.p2.y - z.p1.y;
          D = u.R;
          var E = u.position.x + (D.col1.x * this.m_v1.x +
                  D.col2.x * this.m_v1.y),
              R = u.position.y + (D.col1.y * this.m_v1.x + D.col2.y * this.m_v1.y),
              N = u.position.y + (D.col1.y * this.m_v2.x + D.col2.y * this.m_v2.y) - R;
          u = -(u.position.x + (D.col1.x * this.m_v2.x + D.col2.x * this.m_v2.y) - E);
          D = 100 * Number.MIN_VALUE;
          var S = -(H * N + O * u);
          if (S > D) {
              E = z.p1.x - E;
              var aa = z.p1.y - R;
              R = E * N + aa * u;
              if (0 <= R && R <= z.maxFraction * S) {
                  z = -H * aa + O * E;
                  if (-D * S <= z && z <= S * (1 + D)) {
                      R /= S;
                      k.fraction = R;
                      z = Math.sqrt(N * N + u * u);
                      k.normal.x = N / z;
                      k.normal.y = u / z;
                      return true
                  }
              }
          }
          return false
      };
      y.prototype.ComputeAABB = function(k, z) {
          var u = z.R,
              D = z.position.x + (u.col1.x * this.m_v1.x + u.col2.x * this.m_v1.y),
              H = z.position.y + (u.col1.y * this.m_v1.x + u.col2.y * this.m_v1.y),
              O = z.position.x + (u.col1.x * this.m_v2.x + u.col2.x * this.m_v2.y);
          u = z.position.y + (u.col1.y * this.m_v2.x + u.col2.y * this.m_v2.y);
          if (D < O) {
              k.lowerBound.x = D;
              k.upperBound.x = O
          } else {
              k.lowerBound.x = O;
              k.upperBound.x = D
          }
          if (H < u) {
              k.lowerBound.y = H;
              k.upperBound.y = u
          } else {
              k.lowerBound.y = u;
              k.upperBound.y = H
          }
      };
      y.prototype.ComputeMass = function(k) {
          k.mass = 0;
          k.center.SetV(this.m_v1);
          k.I = 0
      };
      y.prototype.ComputeSubmergedArea =
          function(k, z, u, D) {
              if (z === undefined) z = 0;
              var H = new V(k.x * z, k.y * z),
                  O = B.MulX(u, this.m_v1);
              u = B.MulX(u, this.m_v2);
              var E = B.Dot(k, O) - z;
              k = B.Dot(k, u) - z;
              if (E > 0)
                  if (k > 0) return 0;
                  else {
                      O.x = -k / (E - k) * O.x + E / (E - k) * u.x;
                      O.y = -k / (E - k) * O.y + E / (E - k) * u.y
                  }
              else if (k > 0) {
                  u.x = -k / (E - k) * O.x + E / (E - k) * u.x;
                  u.y = -k / (E - k) * O.y + E / (E - k) * u.y
              }
              D.x = (H.x + O.x + u.x) / 3;
              D.y = (H.y + O.y + u.y) / 3;
              return 0.5 * ((O.x - H.x) * (u.y - H.y) - (O.y - H.y) * (u.x - H.x))
          };
      y.prototype.GetLength = function() {
          return this.m_length
      };
      y.prototype.GetVertex1 = function() {
          return this.m_v1
      };
      y.prototype.GetVertex2 =
          function() {
              return this.m_v2
          };
      y.prototype.GetCoreVertex1 = function() {
          return this.m_coreV1
      };
      y.prototype.GetCoreVertex2 = function() {
          return this.m_coreV2
      };
      y.prototype.GetNormalVector = function() {
          return this.m_normal
      };
      y.prototype.GetDirectionVector = function() {
          return this.m_direction
      };
      y.prototype.GetCorner1Vector = function() {
          return this.m_cornerDir1
      };
      y.prototype.GetCorner2Vector = function() {
          return this.m_cornerDir2
      };
      y.prototype.Corner1IsConvex = function() {
          return this.m_cornerConvex1
      };
      y.prototype.Corner2IsConvex =
          function() {
              return this.m_cornerConvex2
          };
      y.prototype.GetFirstVertex = function(k) {
          var z = k.R;
          return new V(k.position.x + (z.col1.x * this.m_coreV1.x + z.col2.x * this.m_coreV1.y), k.position.y + (z.col1.y * this.m_coreV1.x + z.col2.y * this.m_coreV1.y))
      };
      y.prototype.GetNextEdge = function() {
          return this.m_nextEdge
      };
      y.prototype.GetPrevEdge = function() {
          return this.m_prevEdge
      };
      y.prototype.Support = function(k, z, u) {
          if (z === undefined) z = 0;
          if (u === undefined) u = 0;
          var D = k.R,
              H = k.position.x + (D.col1.x * this.m_coreV1.x + D.col2.x * this.m_coreV1.y),
              O = k.position.y + (D.col1.y * this.m_coreV1.x + D.col2.y * this.m_coreV1.y),
              E = k.position.x + (D.col1.x * this.m_coreV2.x + D.col2.x * this.m_coreV2.y);
          k = k.position.y + (D.col1.y * this.m_coreV2.x + D.col2.y * this.m_coreV2.y);
          if (H * z + O * u > E * z + k * u) {
              this.s_supportVec.x = H;
              this.s_supportVec.y = O
          } else {
              this.s_supportVec.x = E;
              this.s_supportVec.y = k
          }
          return this.s_supportVec
      };
      y.prototype.b2EdgeShape = function(k, z) {
          this.__super.b2Shape.call(this);
          this.m_type = U.e_edgeShape;
          this.m_nextEdge = this.m_prevEdge = null;
          this.m_v1 = k;
          this.m_v2 = z;
          this.m_direction.Set(this.m_v2.x -
              this.m_v1.x, this.m_v2.y - this.m_v1.y);
          this.m_length = this.m_direction.Normalize();
          this.m_normal.Set(this.m_direction.y, -this.m_direction.x);
          this.m_coreV1.Set(-F.b2_toiSlop * (this.m_normal.x - this.m_direction.x) + this.m_v1.x, -F.b2_toiSlop * (this.m_normal.y - this.m_direction.y) + this.m_v1.y);
          this.m_coreV2.Set(-F.b2_toiSlop * (this.m_normal.x + this.m_direction.x) + this.m_v2.x, -F.b2_toiSlop * (this.m_normal.y + this.m_direction.y) + this.m_v2.y);
          this.m_cornerDir1 = this.m_normal;
          this.m_cornerDir2.Set(-this.m_normal.x, -this.m_normal.y)
      };
      y.prototype.SetPrevEdge = function(k, z, u, D) {
          this.m_prevEdge = k;
          this.m_coreV1 = z;
          this.m_cornerDir1 = u;
          this.m_cornerConvex1 = D
      };
      y.prototype.SetNextEdge = function(k, z, u, D) {
          this.m_nextEdge = k;
          this.m_coreV2 = z;
          this.m_cornerDir2 = u;
          this.m_cornerConvex2 = D
      };
      w.b2MassData = function() {
          this.mass = 0;
          this.center = new V(0, 0);
          this.I = 0
      };
      Box2D.inherit(A, Box2D.Collision.Shapes.b2Shape);
      A.prototype.__super = Box2D.Collision.Shapes.b2Shape.prototype;
      A.b2PolygonShape = function() {
          Box2D.Collision.Shapes.b2Shape.b2Shape.apply(this, arguments)
      };
      A.prototype.Copy = function() {
          var k = new A;
          k.Set(this);
          return k
      };
      A.prototype.Set = function(k) {
          this.__super.Set.call(this, k);
          if (Box2D.is(k, A)) {
              k = k instanceof A ? k : null;
              this.m_centroid.SetV(k.m_centroid);
              this.m_vertexCount = k.m_vertexCount;
              this.Reserve(this.m_vertexCount);
              for (var z = 0; z < this.m_vertexCount; z++) {
                  this.m_vertices[z].SetV(k.m_vertices[z]);
                  this.m_normals[z].SetV(k.m_normals[z])
              }
          }
      };
      A.prototype.SetAsArray = function(k, z) {
          if (z === undefined) z = 0;
          var u = new Vector,
              D = 0,
              H;
          for (D = 0; D < k.length; ++D) {
              H = k[D];
              u.push(H)
          }
          this.SetAsVector(u,
              z)
      };
      A.AsArray = function(k, z) {
          if (z === undefined) z = 0;
          var u = new A;
          u.SetAsArray(k, z);
          return u
      };
      A.prototype.SetAsVector = function(k, z) {
          if (z === undefined) z = 0;
          if (z == 0) z = k.length;
          F.b2Assert(2 <= z);
          this.m_vertexCount = z;
          this.Reserve(z);
          var u = 0;
          for (u = 0; u < this.m_vertexCount; u++) this.m_vertices[u].SetV(k[u]);
          for (u = 0; u < this.m_vertexCount; ++u) {
              var D = parseInt(u),
                  H = parseInt(u + 1 < this.m_vertexCount ? u + 1 : 0);
              D = B.SubtractVV(this.m_vertices[H], this.m_vertices[D]);
              F.b2Assert(D.LengthSquared() > Number.MIN_VALUE);
              this.m_normals[u].SetV(B.CrossVF(D,
                  1));
              this.m_normals[u].Normalize()
          }
          this.m_centroid = A.ComputeCentroid(this.m_vertices, this.m_vertexCount)
      };
      A.AsVector = function(k, z) {
          if (z === undefined) z = 0;
          var u = new A;
          u.SetAsVector(k, z);
          return u
      };
      A.prototype.SetAsBox = function(k, z) {
          if (k === undefined) k = 0;
          if (z === undefined) z = 0;
          this.m_vertexCount = 4;
          this.Reserve(4);
          this.m_vertices[0].Set(-k, -z);
          this.m_vertices[1].Set(k, -z);
          this.m_vertices[2].Set(k, z);
          this.m_vertices[3].Set(-k, z);
          this.m_normals[0].Set(0, -1);
          this.m_normals[1].Set(1, 0);
          this.m_normals[2].Set(0,
              1);
          this.m_normals[3].Set(-1, 0);
          this.m_centroid.SetZero()
      };
      A.AsBox = function(k, z) {
          if (k === undefined) k = 0;
          if (z === undefined) z = 0;
          var u = new A;
          u.SetAsBox(k, z);
          return u
      };
      A.prototype.SetAsOrientedBox = function(k, z, u, D) {
          if (k === undefined) k = 0;
          if (z === undefined) z = 0;
          if (u === undefined) u = null;
          if (D === undefined) D = 0;
          this.m_vertexCount = 4;
          this.Reserve(4);
          this.m_vertices[0].Set(-k, -z);
          this.m_vertices[1].Set(k, -z);
          this.m_vertices[2].Set(k, z);
          this.m_vertices[3].Set(-k, z);
          this.m_normals[0].Set(0, -1);
          this.m_normals[1].Set(1, 0);
          this.m_normals[2].Set(0, 1);
          this.m_normals[3].Set(-1, 0);
          this.m_centroid = u;
          k = new Q;
          k.position = u;
          k.R.Set(D);
          for (u = 0; u < this.m_vertexCount; ++u) {
              this.m_vertices[u] = B.MulX(k, this.m_vertices[u]);
              this.m_normals[u] = B.MulMV(k.R, this.m_normals[u])
          }
      };
      A.AsOrientedBox = function(k, z, u, D) {
          if (k === undefined) k = 0;
          if (z === undefined) z = 0;
          if (u === undefined) u = null;
          if (D === undefined) D = 0;
          var H = new A;
          H.SetAsOrientedBox(k, z, u, D);
          return H
      };
      A.prototype.SetAsEdge = function(k, z) {
          this.m_vertexCount = 2;
          this.Reserve(2);
          this.m_vertices[0].SetV(k);
          this.m_vertices[1].SetV(z);
          this.m_centroid.x = 0.5 * (k.x + z.x);
          this.m_centroid.y = 0.5 * (k.y + z.y);
          this.m_normals[0] = B.CrossVF(B.SubtractVV(z, k), 1);
          this.m_normals[0].Normalize();
          this.m_normals[1].x = -this.m_normals[0].x;
          this.m_normals[1].y = -this.m_normals[0].y
      };
      A.AsEdge = function(k, z) {
          var u = new A;
          u.SetAsEdge(k, z);
          return u
      };
      A.prototype.TestPoint = function(k, z) {
          var u;
          u = k.R;
          for (var D = z.x - k.position.x, H = z.y - k.position.y, O = D * u.col1.x + H * u.col1.y, E = D * u.col2.x + H * u.col2.y, R = 0; R < this.m_vertexCount; ++R) {
              u = this.m_vertices[R];
              D = O - u.x;
              H = E - u.y;
              u = this.m_normals[R];
              if (u.x * D + u.y * H > 0) return false
          }
          return true
      };
      A.prototype.RayCast = function(k, z, u) {
          var D = 0,
              H = z.maxFraction,
              O = 0,
              E = 0,
              R, N;
          O = z.p1.x - u.position.x;
          E = z.p1.y - u.position.y;
          R = u.R;
          var S = O * R.col1.x + E * R.col1.y,
              aa = O * R.col2.x + E * R.col2.y;
          O = z.p2.x - u.position.x;
          E = z.p2.y - u.position.y;
          R = u.R;
          z = O * R.col1.x + E * R.col1.y - S;
          R = O * R.col2.x + E * R.col2.y - aa;
          for (var Z = parseInt(-1), d = 0; d < this.m_vertexCount; ++d) {
              N = this.m_vertices[d];
              O = N.x - S;
              E = N.y - aa;
              N = this.m_normals[d];
              O = N.x * O + N.y * E;
              E = N.x * z + N.y * R;
              if (E ==
                  0) {
                  if (O < 0) return false
              } else if (E < 0 && O < D * E) {
                  D = O / E;
                  Z = d
              } else if (E > 0 && O < H * E) H = O / E;
              if (H < D - Number.MIN_VALUE) return false
          }
          if (Z >= 0) {
              k.fraction = D;
              R = u.R;
              N = this.m_normals[Z];
              k.normal.x = R.col1.x * N.x + R.col2.x * N.y;
              k.normal.y = R.col1.y * N.x + R.col2.y * N.y;
              return true
          }
          return false
      };
      A.prototype.ComputeAABB = function(k, z) {
          for (var u = z.R, D = this.m_vertices[0], H = z.position.x + (u.col1.x * D.x + u.col2.x * D.y), O = z.position.y + (u.col1.y * D.x + u.col2.y * D.y), E = H, R = O, N = 1; N < this.m_vertexCount; ++N) {
              D = this.m_vertices[N];
              var S = z.position.x + (u.col1.x *
                  D.x + u.col2.x * D.y);
              D = z.position.y + (u.col1.y * D.x + u.col2.y * D.y);
              H = H < S ? H : S;
              O = O < D ? O : D;
              E = E > S ? E : S;
              R = R > D ? R : D
          }
          k.lowerBound.x = H - this.m_radius;
          k.lowerBound.y = O - this.m_radius;
          k.upperBound.x = E + this.m_radius;
          k.upperBound.y = R + this.m_radius
      };
      A.prototype.ComputeMass = function(k, z) {
          if (z === undefined) z = 0;
          if (this.m_vertexCount == 2) {
              k.center.x = 0.5 * (this.m_vertices[0].x + this.m_vertices[1].x);
              k.center.y = 0.5 * (this.m_vertices[0].y + this.m_vertices[1].y);
              k.mass = 0;
              k.I = 0
          } else {
              for (var u = 0, D = 0, H = 0, O = 0, E = 1 / 3, R = 0; R < this.m_vertexCount; ++R) {
                  var N =
                      this.m_vertices[R],
                      S = R + 1 < this.m_vertexCount ? this.m_vertices[parseInt(R + 1)] : this.m_vertices[0],
                      aa = N.x - 0,
                      Z = N.y - 0,
                      d = S.x - 0,
                      h = S.y - 0,
                      l = aa * h - Z * d,
                      j = 0.5 * l;
                  H += j;
                  u += j * E * (0 + N.x + S.x);
                  D += j * E * (0 + N.y + S.y);
                  N = aa;
                  Z = Z;
                  d = d;
                  h = h;
                  O += l * (E * (0.25 * (N * N + d * N + d * d) + (0 * N + 0 * d)) + 0 + (E * (0.25 * (Z * Z + h * Z + h * h) + (0 * Z + 0 * h)) + 0))
              }
              k.mass = z * H;
              u *= 1 / H;
              D *= 1 / H;
              k.center.Set(u, D);
              k.I = z * O
          }
      };
      A.prototype.ComputeSubmergedArea = function(k, z, u, D) {
          if (z === undefined) z = 0;
          var H = B.MulTMV(u.R, k),
              O = z - B.Dot(k, u.position),
              E = new Vector_a2j_Number,
              R = 0,
              N = parseInt(-1);
          z =
              parseInt(-1);
          var S = false;
          for (k = k = 0; k < this.m_vertexCount; ++k) {
              E[k] = B.Dot(H, this.m_vertices[k]) - O;
              var aa = E[k] < -Number.MIN_VALUE;
              if (k > 0)
                  if (aa) {
                      if (!S) {
                          N = k - 1;
                          R++
                      }
                  } else if (S) {
                  z = k - 1;
                  R++
              }
              S = aa
          }
          switch (R) {
              case 0:
                  if (S) {
                      k = new w;
                      this.ComputeMass(k, 1);
                      D.SetV(B.MulX(u, k.center));
                      return k.mass
                  } else return 0;
              case 1:
                  if (N == -1) N = this.m_vertexCount - 1;
                  else z = this.m_vertexCount - 1
          }
          k = parseInt((N + 1) % this.m_vertexCount);
          H = parseInt((z + 1) % this.m_vertexCount);
          O = (0 - E[N]) / (E[k] - E[N]);
          E = (0 - E[z]) / (E[H] - E[z]);
          N = new V(this.m_vertices[N].x *
              (1 - O) + this.m_vertices[k].x * O, this.m_vertices[N].y * (1 - O) + this.m_vertices[k].y * O);
          z = new V(this.m_vertices[z].x * (1 - E) + this.m_vertices[H].x * E, this.m_vertices[z].y * (1 - E) + this.m_vertices[H].y * E);
          E = 0;
          O = new V;
          R = this.m_vertices[k];
          for (k = k; k != H;) {
              k = (k + 1) % this.m_vertexCount;
              S = k == H ? z : this.m_vertices[k];
              aa = 0.5 * ((R.x - N.x) * (S.y - N.y) - (R.y - N.y) * (S.x - N.x));
              E += aa;
              O.x += aa * (N.x + R.x + S.x) / 3;
              O.y += aa * (N.y + R.y + S.y) / 3;
              R = S
          }
          O.Multiply(1 / E);
          D.SetV(B.MulX(u, O));
          return E
      };
      A.prototype.GetVertexCount = function() {
          return this.m_vertexCount
      };
      A.prototype.GetVertices = function() {
          return this.m_vertices
      };
      A.prototype.GetNormals = function() {
          return this.m_normals
      };
      A.prototype.GetSupport = function(k) {
          for (var z = 0, u = this.m_vertices[0].x * k.x + this.m_vertices[0].y * k.y, D = 1; D < this.m_vertexCount; ++D) {
              var H = this.m_vertices[D].x * k.x + this.m_vertices[D].y * k.y;
              if (H > u) {
                  z = D;
                  u = H
              }
          }
          return z
      };
      A.prototype.GetSupportVertex = function(k) {
          for (var z = 0, u = this.m_vertices[0].x * k.x + this.m_vertices[0].y * k.y, D = 1; D < this.m_vertexCount; ++D) {
              var H = this.m_vertices[D].x * k.x + this.m_vertices[D].y *
                  k.y;
              if (H > u) {
                  z = D;
                  u = H
              }
          }
          return this.m_vertices[z]
      };
      A.prototype.Validate = function() {
          return false
      };
      A.prototype.b2PolygonShape = function() {
          this.__super.b2Shape.call(this);
          this.m_type = U.e_polygonShape;
          this.m_centroid = new V;
          this.m_vertices = new Vector;
          this.m_normals = new Vector
      };
      A.prototype.Reserve = function(k) {
          if (k === undefined) k = 0;
          for (var z = parseInt(this.m_vertices.length); z < k; z++) {
              this.m_vertices[z] = new V;
              this.m_normals[z] = new V
          }
      };
      A.ComputeCentroid = function(k, z) {
          if (z === undefined) z = 0;
          for (var u = new V, D = 0, H = 1 /
                  3, O = 0; O < z; ++O) {
              var E = k[O],
                  R = O + 1 < z ? k[parseInt(O + 1)] : k[0],
                  N = 0.5 * ((E.x - 0) * (R.y - 0) - (E.y - 0) * (R.x - 0));
              D += N;
              u.x += N * H * (0 + E.x + R.x);
              u.y += N * H * (0 + E.y + R.y)
          }
          u.x *= 1 / D;
          u.y *= 1 / D;
          return u
      };
      A.ComputeOBB = function(k, z, u) {
          if (u === undefined) u = 0;
          var D = 0,
              H = new Vector(u + 1);
          for (D = 0; D < u; ++D) H[D] = z[D];
          H[u] = H[0];
          z = Number.MAX_VALUE;
          for (D = 1; D <= u; ++D) {
              var O = H[parseInt(D - 1)],
                  E = H[D].x - O.x,
                  R = H[D].y - O.y,
                  N = Math.sqrt(E * E + R * R);
              E /= N;
              R /= N;
              for (var S = -R, aa = E, Z = N = Number.MAX_VALUE, d = -Number.MAX_VALUE, h = -Number.MAX_VALUE, l = 0; l < u; ++l) {
                  var j = H[l].x -
                      O.x,
                      o = H[l].y - O.y,
                      q = E * j + R * o;
                  j = S * j + aa * o;
                  if (q < N) N = q;
                  if (j < Z) Z = j;
                  if (q > d) d = q;
                  if (j > h) h = j
              }
              l = (d - N) * (h - Z);
              if (l < 0.95 * z) {
                  z = l;
                  k.R.col1.x = E;
                  k.R.col1.y = R;
                  k.R.col2.x = S;
                  k.R.col2.y = aa;
                  E = 0.5 * (N + d);
                  R = 0.5 * (Z + h);
                  S = k.R;
                  k.center.x = O.x + (S.col1.x * E + S.col2.x * R);
                  k.center.y = O.y + (S.col1.y * E + S.col2.y * R);
                  k.extents.x = 0.5 * (d - N);
                  k.extents.y = 0.5 * (h - Z)
              }
          }
      };
      Box2D.postDefs.push(function() {
          Box2D.Collision.Shapes.b2PolygonShape.s_mat = new p
      });
      U.b2Shape = function() {};
      U.prototype.Copy = function() {
          return null
      };
      U.prototype.Set = function(k) {
          this.m_radius =
              k.m_radius
      };
      U.prototype.GetType = function() {
          return this.m_type
      };
      U.prototype.TestPoint = function() {
          return false
      };
      U.prototype.RayCast = function() {
          return false
      };
      U.prototype.ComputeAABB = function() {};
      U.prototype.ComputeMass = function() {};
      U.prototype.ComputeSubmergedArea = function() {
          return 0
      };
      U.TestOverlap = function(k, z, u, D) {
          var H = new L;
          H.proxyA = new W;
          H.proxyA.Set(k);
          H.proxyB = new W;
          H.proxyB.Set(u);
          H.transformA = z;
          H.transformB = D;
          H.useRadii = true;
          k = new Y;
          k.count = 0;
          z = new I;
          M.Distance(z, k, H);
          return z.distance < 10 * Number.MIN_VALUE
      };
      U.prototype.b2Shape = function() {
          this.m_type = U.e_unknownShape;
          this.m_radius = F.b2_linearSlop
      };
      Box2D.postDefs.push(function() {
          Box2D.Collision.Shapes.b2Shape.e_unknownShape = parseInt(-1);
          Box2D.Collision.Shapes.b2Shape.e_circleShape = 0;
          Box2D.Collision.Shapes.b2Shape.e_polygonShape = 1;
          Box2D.Collision.Shapes.b2Shape.e_edgeShape = 2;
          Box2D.Collision.Shapes.b2Shape.e_shapeTypeCount = 3;
          Box2D.Collision.Shapes.b2Shape.e_hitCollide = 1;
          Box2D.Collision.Shapes.b2Shape.e_missCollide = 0;
          Box2D.Collision.Shapes.b2Shape.e_startsInsideCollide =
              parseInt(-1)
      })
  })();
  (function() {
      var F = Box2D.Common.b2Color,
          G = Box2D.Common.b2Settings,
          K = Box2D.Common.Math.b2Math;
      F.b2Color = function() {
          this._b = this._g = this._r = 0
      };
      F.prototype.b2Color = function(y, w, A) {
          if (y === undefined) y = 0;
          if (w === undefined) w = 0;
          if (A === undefined) A = 0;
          this._r = Box2D.parseUInt(255 * K.Clamp(y, 0, 1));
          this._g = Box2D.parseUInt(255 * K.Clamp(w, 0, 1));
          this._b = Box2D.parseUInt(255 * K.Clamp(A, 0, 1))
      };
      F.prototype.Set = function(y, w, A) {
          if (y === undefined) y = 0;
          if (w === undefined) w = 0;
          if (A === undefined) A = 0;
          this._r = Box2D.parseUInt(255 * K.Clamp(y,
              0, 1));
          this._g = Box2D.parseUInt(255 * K.Clamp(w, 0, 1));
          this._b = Box2D.parseUInt(255 * K.Clamp(A, 0, 1))
      };
      Object.defineProperty(F.prototype, "r", {
          enumerable: false,
          configurable: true,
          set: function(y) {
              if (y === undefined) y = 0;
              this._r = Box2D.parseUInt(255 * K.Clamp(y, 0, 1))
          }
      });
      Object.defineProperty(F.prototype, "g", {
          enumerable: false,
          configurable: true,
          set: function(y) {
              if (y === undefined) y = 0;
              this._g = Box2D.parseUInt(255 * K.Clamp(y, 0, 1))
          }
      });
      Object.defineProperty(F.prototype, "b", {
          enumerable: false,
          configurable: true,
          set: function(y) {
              if (y ===
                  undefined) y = 0;
              this._b = Box2D.parseUInt(255 * K.Clamp(y, 0, 1))
          }
      });
      Object.defineProperty(F.prototype, "color", {
          enumerable: false,
          configurable: true,
          get: function() {
              return this._r << 16 | this._g << 8 | this._b
          }
      });
      G.b2Settings = function() {};
      G.b2MixFriction = function(y, w) {
          if (y === undefined) y = 0;
          if (w === undefined) w = 0;
          return Math.sqrt(y * w)
      };
      G.b2MixRestitution = function(y, w) {
          if (y === undefined) y = 0;
          if (w === undefined) w = 0;
          return y > w ? y : w
      };
      G.b2Assert = function(y) {
          if (!y) throw "Assertion Failed";
      };
      Box2D.postDefs.push(function() {
          Box2D.Common.b2Settings.VERSION =
              "2.1alpha";
          Box2D.Common.b2Settings.USHRT_MAX = 65535;
          Box2D.Common.b2Settings.b2_pi = Math.PI;
          Box2D.Common.b2Settings.b2_maxManifoldPoints = 2;
          Box2D.Common.b2Settings.b2_aabbExtension = 0.1;
          Box2D.Common.b2Settings.b2_aabbMultiplier = 2;
          Box2D.Common.b2Settings.b2_polygonRadius = 2 * G.b2_linearSlop;
          Box2D.Common.b2Settings.b2_linearSlop = 0.0050;
          Box2D.Common.b2Settings.b2_angularSlop = 2 / 180 * G.b2_pi;
          Box2D.Common.b2Settings.b2_toiSlop = 8 * G.b2_linearSlop;
          Box2D.Common.b2Settings.b2_maxTOIContactsPerIsland = 32;
          Box2D.Common.b2Settings.b2_maxTOIJointsPerIsland =
              32;
          Box2D.Common.b2Settings.b2_velocityThreshold = 1;
          Box2D.Common.b2Settings.b2_maxLinearCorrection = 0.2;
          Box2D.Common.b2Settings.b2_maxAngularCorrection = 8 / 180 * G.b2_pi;
          Box2D.Common.b2Settings.b2_maxTranslation = 2;
          Box2D.Common.b2Settings.b2_maxTranslationSquared = G.b2_maxTranslation * G.b2_maxTranslation;
          Box2D.Common.b2Settings.b2_maxRotation = 0.5 * G.b2_pi;
          Box2D.Common.b2Settings.b2_maxRotationSquared = G.b2_maxRotation * G.b2_maxRotation;
          Box2D.Common.b2Settings.b2_contactBaumgarte = 0.2;
          Box2D.Common.b2Settings.b2_timeToSleep =
              0.5;
          Box2D.Common.b2Settings.b2_linearSleepTolerance = 0.01;
          Box2D.Common.b2Settings.b2_angularSleepTolerance = 2 / 180 * G.b2_pi
      })
  })();
  (function() {
      var F = Box2D.Common.Math.b2Mat22,
          G = Box2D.Common.Math.b2Mat33,
          K = Box2D.Common.Math.b2Math,
          y = Box2D.Common.Math.b2Sweep,
          w = Box2D.Common.Math.b2Transform,
          A = Box2D.Common.Math.b2Vec2,
          U = Box2D.Common.Math.b2Vec3;
      F.b2Mat22 = function() {
          this.col1 = new A;
          this.col2 = new A
      };
      F.prototype.b2Mat22 = function() {
          this.SetIdentity()
      };
      F.FromAngle = function(p) {
          if (p === undefined) p = 0;
          var B = new F;
          B.Set(p);
          return B
      };
      F.FromVV = function(p, B) {
          var Q = new F;
          Q.SetVV(p, B);
          return Q
      };
      F.prototype.Set = function(p) {
          if (p === undefined) p = 0;
          var B = Math.cos(p);
          p = Math.sin(p);
          this.col1.x = B;
          this.col2.x = -p;
          this.col1.y = p;
          this.col2.y = B
      };
      F.prototype.SetVV = function(p, B) {
          this.col1.SetV(p);
          this.col2.SetV(B)
      };
      F.prototype.Copy = function() {
          var p = new F;
          p.SetM(this);
          return p
      };
      F.prototype.SetM = function(p) {
          this.col1.SetV(p.col1);
          this.col2.SetV(p.col2)
      };
      F.prototype.AddM = function(p) {
          this.col1.x += p.col1.x;
          this.col1.y += p.col1.y;
          this.col2.x += p.col2.x;
          this.col2.y += p.col2.y
      };
      F.prototype.SetIdentity = function() {
          this.col1.x = 1;
          this.col2.x = 0;
          this.col1.y = 0;
          this.col2.y =
              1
      };
      F.prototype.SetZero = function() {
          this.col1.x = 0;
          this.col2.x = 0;
          this.col1.y = 0;
          this.col2.y = 0
      };
      F.prototype.GetAngle = function() {
          return Math.atan2(this.col1.y, this.col1.x)
      };
      F.prototype.GetInverse = function(p) {
          var B = this.col1.x,
              Q = this.col2.x,
              V = this.col1.y,
              M = this.col2.y,
              L = B * M - Q * V;
          if (L != 0) L = 1 / L;
          p.col1.x = L * M;
          p.col2.x = -L * Q;
          p.col1.y = -L * V;
          p.col2.y = L * B;
          return p
      };
      F.prototype.Solve = function(p, B, Q) {
          if (B === undefined) B = 0;
          if (Q === undefined) Q = 0;
          var V = this.col1.x,
              M = this.col2.x,
              L = this.col1.y,
              I = this.col2.y,
              W = V * I - M * L;
          if (W !=
              0) W = 1 / W;
          p.x = W * (I * B - M * Q);
          p.y = W * (V * Q - L * B);
          return p
      };
      F.prototype.Abs = function() {
          this.col1.Abs();
          this.col2.Abs()
      };
      G.b2Mat33 = function() {
          this.col1 = new U;
          this.col2 = new U;
          this.col3 = new U
      };
      G.prototype.b2Mat33 = function(p, B, Q) {
          if (p === undefined) p = null;
          if (B === undefined) B = null;
          if (Q === undefined) Q = null;
          if (!p && !B && !Q) {
              this.col1.SetZero();
              this.col2.SetZero();
              this.col3.SetZero()
          } else {
              this.col1.SetV(p);
              this.col2.SetV(B);
              this.col3.SetV(Q)
          }
      };
      G.prototype.SetVVV = function(p, B, Q) {
          this.col1.SetV(p);
          this.col2.SetV(B);
          this.col3.SetV(Q)
      };
      G.prototype.Copy = function() {
          return new G(this.col1, this.col2, this.col3)
      };
      G.prototype.SetM = function(p) {
          this.col1.SetV(p.col1);
          this.col2.SetV(p.col2);
          this.col3.SetV(p.col3)
      };
      G.prototype.AddM = function(p) {
          this.col1.x += p.col1.x;
          this.col1.y += p.col1.y;
          this.col1.z += p.col1.z;
          this.col2.x += p.col2.x;
          this.col2.y += p.col2.y;
          this.col2.z += p.col2.z;
          this.col3.x += p.col3.x;
          this.col3.y += p.col3.y;
          this.col3.z += p.col3.z
      };
      G.prototype.SetIdentity = function() {
          this.col1.x = 1;
          this.col2.x = 0;
          this.col3.x = 0;
          this.col1.y = 0;
          this.col2.y =
              1;
          this.col3.y = 0;
          this.col1.z = 0;
          this.col2.z = 0;
          this.col3.z = 1
      };
      G.prototype.SetZero = function() {
          this.col1.x = 0;
          this.col2.x = 0;
          this.col3.x = 0;
          this.col1.y = 0;
          this.col2.y = 0;
          this.col3.y = 0;
          this.col1.z = 0;
          this.col2.z = 0;
          this.col3.z = 0
      };
      G.prototype.Solve22 = function(p, B, Q) {
          if (B === undefined) B = 0;
          if (Q === undefined) Q = 0;
          var V = this.col1.x,
              M = this.col2.x,
              L = this.col1.y,
              I = this.col2.y,
              W = V * I - M * L;
          if (W != 0) W = 1 / W;
          p.x = W * (I * B - M * Q);
          p.y = W * (V * Q - L * B);
          return p
      };
      G.prototype.Solve33 = function(p, B, Q, V) {
          if (B === undefined) B = 0;
          if (Q === undefined) Q = 0;
          if (V === undefined) V = 0;
          var M = this.col1.x,
              L = this.col1.y,
              I = this.col1.z,
              W = this.col2.x,
              Y = this.col2.y,
              k = this.col2.z,
              z = this.col3.x,
              u = this.col3.y,
              D = this.col3.z,
              H = M * (Y * D - k * u) + L * (k * z - W * D) + I * (W * u - Y * z);
          if (H != 0) H = 1 / H;
          p.x = H * (B * (Y * D - k * u) + Q * (k * z - W * D) + V * (W * u - Y * z));
          p.y = H * (M * (Q * D - V * u) + L * (V * z - B * D) + I * (B * u - Q * z));
          p.z = H * (M * (Y * V - k * Q) + L * (k * B - W * V) + I * (W * Q - Y * B));
          return p
      };
      K.b2Math = function() {};
      K.IsValid = function(p) {
          if (p === undefined) p = 0;
          return isFinite(p)
      };
      K.Dot = function(p, B) {
          return p.x * B.x + p.y * B.y
      };
      K.CrossVV = function(p, B) {
          return p.x *
              B.y - p.y * B.x
      };
      K.CrossVF = function(p, B) {
          if (B === undefined) B = 0;
          return new A(B * p.y, -B * p.x)
      };
      K.CrossFV = function(p, B) {
          if (p === undefined) p = 0;
          return new A(-p * B.y, p * B.x)
      };
      K.MulMV = function(p, B) {
          return new A(p.col1.x * B.x + p.col2.x * B.y, p.col1.y * B.x + p.col2.y * B.y)
      };
      K.MulTMV = function(p, B) {
          return new A(K.Dot(B, p.col1), K.Dot(B, p.col2))
      };
      K.MulX = function(p, B) {
          var Q = K.MulMV(p.R, B);
          Q.x += p.position.x;
          Q.y += p.position.y;
          return Q
      };
      K.MulXT = function(p, B) {
          var Q = K.SubtractVV(B, p.position),
              V = Q.x * p.R.col1.x + Q.y * p.R.col1.y;
          Q.y = Q.x *
              p.R.col2.x + Q.y * p.R.col2.y;
          Q.x = V;
          return Q
      };
      K.AddVV = function(p, B) {
          return new A(p.x + B.x, p.y + B.y)
      };
      K.SubtractVV = function(p, B) {
          return new A(p.x - B.x, p.y - B.y)
      };
      K.Distance = function(p, B) {
          var Q = p.x - B.x,
              V = p.y - B.y;
          return Math.sqrt(Q * Q + V * V)
      };
      K.DistanceSquared = function(p, B) {
          var Q = p.x - B.x,
              V = p.y - B.y;
          return Q * Q + V * V
      };
      K.MulFV = function(p, B) {
          if (p === undefined) p = 0;
          return new A(p * B.x, p * B.y)
      };
      K.AddMM = function(p, B) {
          return F.FromVV(K.AddVV(p.col1, B.col1), K.AddVV(p.col2, B.col2))
      };
      K.MulMM = function(p, B) {
          return F.FromVV(K.MulMV(p,
              B.col1), K.MulMV(p, B.col2))
      };
      K.MulTMM = function(p, B) {
          var Q = new A(K.Dot(p.col1, B.col1), K.Dot(p.col2, B.col1)),
              V = new A(K.Dot(p.col1, B.col2), K.Dot(p.col2, B.col2));
          return F.FromVV(Q, V)
      };
      K.Abs = function(p) {
          if (p === undefined) p = 0;
          return p > 0 ? p : -p
      };
      K.AbsV = function(p) {
          return new A(K.Abs(p.x), K.Abs(p.y))
      };
      K.AbsM = function(p) {
          return F.FromVV(K.AbsV(p.col1), K.AbsV(p.col2))
      };
      K.Min = function(p, B) {
          if (p === undefined) p = 0;
          if (B === undefined) B = 0;
          return p < B ? p : B
      };
      K.MinV = function(p, B) {
          return new A(K.Min(p.x, B.x), K.Min(p.y, B.y))
      };
      K.Max = function(p, B) {
          if (p === undefined) p = 0;
          if (B === undefined) B = 0;
          return p > B ? p : B
      };
      K.MaxV = function(p, B) {
          return new A(K.Max(p.x, B.x), K.Max(p.y, B.y))
      };
      K.Clamp = function(p, B, Q) {
          if (p === undefined) p = 0;
          if (B === undefined) B = 0;
          if (Q === undefined) Q = 0;
          return p < B ? B : p > Q ? Q : p
      };
      K.ClampV = function(p, B, Q) {
          return K.MaxV(B, K.MinV(p, Q))
      };
      K.Swap = function(p, B) {
          var Q = p[0];
          p[0] = B[0];
          B[0] = Q
      };
      K.Random = function() {
          return Math.random() * 2 - 1
      };
      K.RandomRange = function(p, B) {
          if (p === undefined) p = 0;
          if (B === undefined) B = 0;
          var Q = Math.random();
          return Q =
              (B - p) * Q + p
      };
      K.NextPowerOfTwo = function(p) {
          if (p === undefined) p = 0;
          p |= p >> 1 & 2147483647;
          p |= p >> 2 & 1073741823;
          p |= p >> 4 & 268435455;
          p |= p >> 8 & 16777215;
          p |= p >> 16 & 65535;
          return p + 1
      };
      K.IsPowerOfTwo = function(p) {
          if (p === undefined) p = 0;
          return p > 0 && (p & p - 1) == 0
      };
      Box2D.postDefs.push(function() {
          Box2D.Common.Math.b2Math.b2Vec2_zero = new A(0, 0);
          Box2D.Common.Math.b2Math.b2Mat22_identity = F.FromVV(new A(1, 0), new A(0, 1));
          Box2D.Common.Math.b2Math.b2Transform_identity = new w(K.b2Vec2_zero, K.b2Mat22_identity)
      });
      y.b2Sweep = function() {
          this.localCenter =
              new A;
          this.c0 = new A;
          this.c = new A
      };
      y.prototype.Set = function(p) {
          this.localCenter.SetV(p.localCenter);
          this.c0.SetV(p.c0);
          this.c.SetV(p.c);
          this.a0 = p.a0;
          this.a = p.a;
          this.t0 = p.t0
      };
      y.prototype.Copy = function() {
          var p = new y;
          p.localCenter.SetV(this.localCenter);
          p.c0.SetV(this.c0);
          p.c.SetV(this.c);
          p.a0 = this.a0;
          p.a = this.a;
          p.t0 = this.t0;
          return p
      };
      y.prototype.GetTransform = function(p, B) {
          if (B === undefined) B = 0;
          p.position.x = (1 - B) * this.c0.x + B * this.c.x;
          p.position.y = (1 - B) * this.c0.y + B * this.c.y;
          p.R.Set((1 - B) * this.a0 + B * this.a);
          var Q = p.R;
          p.position.x -= Q.col1.x * this.localCenter.x + Q.col2.x * this.localCenter.y;
          p.position.y -= Q.col1.y * this.localCenter.x + Q.col2.y * this.localCenter.y
      };
      y.prototype.Advance = function(p) {
          if (p === undefined) p = 0;
          if (this.t0 < p && 1 - this.t0 > Number.MIN_VALUE) {
              var B = (p - this.t0) / (1 - this.t0);
              this.c0.x = (1 - B) * this.c0.x + B * this.c.x;
              this.c0.y = (1 - B) * this.c0.y + B * this.c.y;
              this.a0 = (1 - B) * this.a0 + B * this.a;
              this.t0 = p
          }
      };
      w.b2Transform = function() {
          this.position = new A;
          this.R = new F
      };
      w.prototype.b2Transform = function(p, B) {
          if (p === undefined) p =
              null;
          if (B === undefined) B = null;
          if (p) {
              this.position.SetV(p);
              this.R.SetM(B)
          }
      };
      w.prototype.Initialize = function(p, B) {
          this.position.SetV(p);
          this.R.SetM(B)
      };
      w.prototype.SetIdentity = function() {
          this.position.SetZero();
          this.R.SetIdentity()
      };
      w.prototype.Set = function(p) {
          this.position.SetV(p.position);
          this.R.SetM(p.R)
      };
      w.prototype.GetAngle = function() {
          return Math.atan2(this.R.col1.y, this.R.col1.x)
      };
      A.b2Vec2 = function() {};
      A.prototype.b2Vec2 = function(p, B) {
          if (p === undefined) p = 0;
          if (B === undefined) B = 0;
          this.x = p;
          this.y = B
      };
      A.prototype.SetZero = function() {
          this.y = this.x = 0
      };
      A.prototype.Set = function(p, B) {
          if (p === undefined) p = 0;
          if (B === undefined) B = 0;
          this.x = p;
          this.y = B
      };
      A.prototype.SetV = function(p) {
          this.x = p.x;
          this.y = p.y
      };
      A.prototype.GetNegative = function() {
          return new A(-this.x, -this.y)
      };
      A.prototype.NegativeSelf = function() {
          this.x = -this.x;
          this.y = -this.y
      };
      A.Make = function(p, B) {
          if (p === undefined) p = 0;
          if (B === undefined) B = 0;
          return new A(p, B)
      };
      A.prototype.Copy = function() {
          return new A(this.x, this.y)
      };
      A.prototype.Add = function(p) {
          this.x += p.x;
          this.y += p.y
      };
      A.prototype.Subtract = function(p) {
          this.x -= p.x;
          this.y -= p.y
      };
      A.prototype.Multiply = function(p) {
          if (p === undefined) p = 0;
          this.x *= p;
          this.y *= p
      };
      A.prototype.MulM = function(p) {
          var B = this.x;
          this.x = p.col1.x * B + p.col2.x * this.y;
          this.y = p.col1.y * B + p.col2.y * this.y
      };
      A.prototype.MulTM = function(p) {
          var B = K.Dot(this, p.col1);
          this.y = K.Dot(this, p.col2);
          this.x = B
      };
      A.prototype.CrossVF = function(p) {
          if (p === undefined) p = 0;
          var B = this.x;
          this.x = p * this.y;
          this.y = -p * B
      };
      A.prototype.CrossFV = function(p) {
          if (p === undefined) p = 0;
          var B =
              this.x;
          this.x = -p * this.y;
          this.y = p * B
      };
      A.prototype.MinV = function(p) {
          this.x = this.x < p.x ? this.x : p.x;
          this.y = this.y < p.y ? this.y : p.y
      };
      A.prototype.MaxV = function(p) {
          this.x = this.x > p.x ? this.x : p.x;
          this.y = this.y > p.y ? this.y : p.y
      };
      A.prototype.Abs = function() {
          if (this.x < 0) this.x = -this.x;
          if (this.y < 0) this.y = -this.y
      };
      A.prototype.Length = function() {
          return Math.sqrt(this.x * this.x + this.y * this.y)
      };
      A.prototype.LengthSquared = function() {
          return this.x * this.x + this.y * this.y
      };
      A.prototype.Normalize = function() {
          var p = Math.sqrt(this.x * this.x +
              this.y * this.y);
          if (p < Number.MIN_VALUE) return 0;
          var B = 1 / p;
          this.x *= B;
          this.y *= B;
          return p
      };
      A.prototype.IsValid = function() {
          return K.IsValid(this.x) && K.IsValid(this.y)
      };
      U.b2Vec3 = function() {};
      U.prototype.b2Vec3 = function(p, B, Q) {
          if (p === undefined) p = 0;
          if (B === undefined) B = 0;
          if (Q === undefined) Q = 0;
          this.x = p;
          this.y = B;
          this.z = Q
      };
      U.prototype.SetZero = function() {
          this.x = this.y = this.z = 0
      };
      U.prototype.Set = function(p, B, Q) {
          if (p === undefined) p = 0;
          if (B === undefined) B = 0;
          if (Q === undefined) Q = 0;
          this.x = p;
          this.y = B;
          this.z = Q
      };
      U.prototype.SetV =
          function(p) {
              this.x = p.x;
              this.y = p.y;
              this.z = p.z
          };
      U.prototype.GetNegative = function() {
          return new U(-this.x, -this.y, -this.z)
      };
      U.prototype.NegativeSelf = function() {
          this.x = -this.x;
          this.y = -this.y;
          this.z = -this.z
      };
      U.prototype.Copy = function() {
          return new U(this.x, this.y, this.z)
      };
      U.prototype.Add = function(p) {
          this.x += p.x;
          this.y += p.y;
          this.z += p.z
      };
      U.prototype.Subtract = function(p) {
          this.x -= p.x;
          this.y -= p.y;
          this.z -= p.z
      };
      U.prototype.Multiply = function(p) {
          if (p === undefined) p = 0;
          this.x *= p;
          this.y *= p;
          this.z *= p
      }
  })();
  (function() {
      var F = Box2D.Common.Math.b2Math,
          G = Box2D.Common.Math.b2Sweep,
          K = Box2D.Common.Math.b2Transform,
          y = Box2D.Common.Math.b2Vec2,
          w = Box2D.Common.b2Color,
          A = Box2D.Common.b2Settings,
          U = Box2D.Collision.b2AABB,
          p = Box2D.Collision.b2ContactPoint,
          B = Box2D.Collision.b2DynamicTreeBroadPhase,
          Q = Box2D.Collision.b2RayCastInput,
          V = Box2D.Collision.b2RayCastOutput,
          M = Box2D.Collision.Shapes.b2CircleShape,
          L = Box2D.Collision.Shapes.b2EdgeShape,
          I = Box2D.Collision.Shapes.b2MassData,
          W = Box2D.Collision.Shapes.b2PolygonShape,
          Y = Box2D.Collision.Shapes.b2Shape,
          k = Box2D.Dynamics.b2Body,
          z = Box2D.Dynamics.b2BodyDef,
          u = Box2D.Dynamics.b2ContactFilter,
          D = Box2D.Dynamics.b2ContactImpulse,
          H = Box2D.Dynamics.b2ContactListener,
          O = Box2D.Dynamics.b2ContactManager,
          E = Box2D.Dynamics.b2DebugDraw,
          R = Box2D.Dynamics.b2DestructionListener,
          N = Box2D.Dynamics.b2FilterData,
          S = Box2D.Dynamics.b2Fixture,
          aa = Box2D.Dynamics.b2FixtureDef,
          Z = Box2D.Dynamics.b2Island,
          d = Box2D.Dynamics.b2TimeStep,
          h = Box2D.Dynamics.b2World,
          l = Box2D.Dynamics.Contacts.b2Contact,
          j = Box2D.Dynamics.Contacts.b2ContactFactory,
          o = Box2D.Dynamics.Contacts.b2ContactSolver,
          q = Box2D.Dynamics.Joints.b2Joint,
          n = Box2D.Dynamics.Joints.b2PulleyJoint;
      k.b2Body = function() {
          this.m_xf = new K;
          this.m_sweep = new G;
          this.m_linearVelocity = new y;
          this.m_force = new y
      };
      k.prototype.connectEdges = function(a, c, g) {
          if (g === undefined) g = 0;
          var b = Math.atan2(c.GetDirectionVector().y, c.GetDirectionVector().x);
          g = F.MulFV(Math.tan((b - g) * 0.5), c.GetDirectionVector());
          g = F.SubtractVV(g, c.GetNormalVector());
          g = F.MulFV(A.b2_toiSlop, g);
          g = F.AddVV(g, c.GetVertex1());
          var e = F.AddVV(a.GetDirectionVector(),
              c.GetDirectionVector());
          e.Normalize();
          var f = F.Dot(a.GetDirectionVector(), c.GetNormalVector()) > 0;
          a.SetNextEdge(c, g, e, f);
          c.SetPrevEdge(a, g, e, f);
          return b
      };
      k.prototype.CreateFixture = function(a) {
          if (this.m_world.IsLocked() == true) return null;
          var c = new S;
          c.Create(this, this.m_xf, a);
          this.m_flags & k.e_activeFlag && c.CreateProxy(this.m_world.m_contactManager.m_broadPhase, this.m_xf);
          c.m_next = this.m_fixtureList;
          this.m_fixtureList = c;
          ++this.m_fixtureCount;
          c.m_body = this;
          c.m_density > 0 && this.ResetMassData();
          this.m_world.m_flags |=
              h.e_newFixture;
          return c
      };
      k.prototype.CreateFixture2 = function(a, c) {
          if (c === undefined) c = 0;
          var g = new aa;
          g.shape = a;
          g.density = c;
          return this.CreateFixture(g)
      };
      k.prototype.DestroyFixture = function(a) {
          if (this.m_world.IsLocked() != true) {
              for (var c = this.m_fixtureList, g = null; c != null;) {
                  if (c == a) {
                      if (g) g.m_next = a.m_next;
                      else this.m_fixtureList = a.m_next;
                      break
                  }
                  g = c;
                  c = c.m_next
              }
              for (c = this.m_contactList; c;) {
                  g = c.contact;
                  c = c.next;
                  var b = g.GetFixtureA(),
                      e = g.GetFixtureB();
                  if (a == b || a == e) this.m_world.m_contactManager.Destroy(g)
              }
              this.m_flags &
                  k.e_activeFlag && a.DestroyProxy(this.m_world.m_contactManager.m_broadPhase);
              a.Destroy();
              a.m_body = null;
              a.m_next = null;
              --this.m_fixtureCount;
              this.ResetMassData()
          }
      };
      k.prototype.SetPositionAndAngle = function(a, c) {
          if (c === undefined) c = 0;
          var g;
          if (this.m_world.IsLocked() != true) {
              this.m_xf.R.Set(c);
              this.m_xf.position.SetV(a);
              g = this.m_xf.R;
              var b = this.m_sweep.localCenter;
              this.m_sweep.c.x = g.col1.x * b.x + g.col2.x * b.y;
              this.m_sweep.c.y = g.col1.y * b.x + g.col2.y * b.y;
              this.m_sweep.c.x += this.m_xf.position.x;
              this.m_sweep.c.y +=
                  this.m_xf.position.y;
              this.m_sweep.c0.SetV(this.m_sweep.c);
              this.m_sweep.a0 = this.m_sweep.a = c;
              b = this.m_world.m_contactManager.m_broadPhase;
              for (g = this.m_fixtureList; g; g = g.m_next) g.Synchronize(b, this.m_xf, this.m_xf);
              this.m_world.m_contactManager.FindNewContacts()
          }
      };
      k.prototype.SetTransform = function(a) {
          this.SetPositionAndAngle(a.position, a.GetAngle())
      };
      k.prototype.GetTransform = function() {
          return this.m_xf
      };
      k.prototype.GetPosition = function() {
          return this.m_xf.position
      };
      k.prototype.SetPosition = function(a) {
          this.SetPositionAndAngle(a,
              this.GetAngle())
      };
      k.prototype.GetAngle = function() {
          return this.m_sweep.a
      };
      k.prototype.SetAngle = function(a) {
          if (a === undefined) a = 0;
          this.SetPositionAndAngle(this.GetPosition(), a)
      };
      k.prototype.GetWorldCenter = function() {
          return this.m_sweep.c
      };
      k.prototype.GetLocalCenter = function() {
          return this.m_sweep.localCenter
      };
      k.prototype.SetLinearVelocity = function(a) {
          this.m_type != k.b2_staticBody && this.m_linearVelocity.SetV(a)
      };
      k.prototype.GetLinearVelocity = function() {
          return this.m_linearVelocity
      };
      k.prototype.SetAngularVelocity =
          function(a) {
              if (a === undefined) a = 0;
              if (this.m_type != k.b2_staticBody) this.m_angularVelocity = a
          };
      k.prototype.GetAngularVelocity = function() {
          return this.m_angularVelocity
      };
      k.prototype.GetDefinition = function() {
          var a = new z;
          a.type = this.GetType();
          a.allowSleep = (this.m_flags & k.e_allowSleepFlag) == k.e_allowSleepFlag;
          a.angle = this.GetAngle();
          a.angularDamping = this.m_angularDamping;
          a.angularVelocity = this.m_angularVelocity;
          a.fixedRotation = (this.m_flags & k.e_fixedRotationFlag) == k.e_fixedRotationFlag;
          a.bullet = (this.m_flags &
              k.e_bulletFlag) == k.e_bulletFlag;
          a.awake = (this.m_flags & k.e_awakeFlag) == k.e_awakeFlag;
          a.linearDamping = this.m_linearDamping;
          a.linearVelocity.SetV(this.GetLinearVelocity());
          a.position = this.GetPosition();
          a.userData = this.GetUserData();
          return a
      };
      k.prototype.ApplyForce = function(a, c) {
          if (this.m_type == k.b2_dynamicBody) {
              this.IsAwake() == false && this.SetAwake(true);
              this.m_force.x += a.x;
              this.m_force.y += a.y;
              this.m_torque += (c.x - this.m_sweep.c.x) * a.y - (c.y - this.m_sweep.c.y) * a.x
          }
      };
      k.prototype.ApplyTorque = function(a) {
          if (a ===
              undefined) a = 0;
          if (this.m_type == k.b2_dynamicBody) {
              this.IsAwake() == false && this.SetAwake(true);
              this.m_torque += a
          }
      };
      k.prototype.ApplyImpulse = function(a, c) {
          if (this.m_type == k.b2_dynamicBody) {
              this.IsAwake() == false && this.SetAwake(true);
              this.m_linearVelocity.x += this.m_invMass * a.x;
              this.m_linearVelocity.y += this.m_invMass * a.y;
              this.m_angularVelocity += this.m_invI * ((c.x - this.m_sweep.c.x) * a.y - (c.y - this.m_sweep.c.y) * a.x)
          }
      };
      k.prototype.Split = function(a) {
          for (var c = this.GetLinearVelocity().Copy(), g = this.GetAngularVelocity(),
                  b = this.GetWorldCenter(), e = this.m_world.CreateBody(this.GetDefinition()), f, m = this.m_fixtureList; m;)
              if (a(m)) {
                  var r = m.m_next;
                  if (f) f.m_next = r;
                  else this.m_fixtureList = r;
                  this.m_fixtureCount--;
                  m.m_next = e.m_fixtureList;
                  e.m_fixtureList = m;
                  e.m_fixtureCount++;
                  m.m_body = e;
                  m = r
              } else {
                  f = m;
                  m = m.m_next
              }
          this.ResetMassData();
          e.ResetMassData();
          f = this.GetWorldCenter();
          a = e.GetWorldCenter();
          f = F.AddVV(c, F.CrossFV(g, F.SubtractVV(f, b)));
          c = F.AddVV(c, F.CrossFV(g, F.SubtractVV(a, b)));
          this.SetLinearVelocity(f);
          e.SetLinearVelocity(c);
          this.SetAngularVelocity(g);
          e.SetAngularVelocity(g);
          this.SynchronizeFixtures();
          e.SynchronizeFixtures();
          return e
      };
      k.prototype.Merge = function(a) {
          var c;
          for (c = a.m_fixtureList; c;) {
              var g = c.m_next;
              a.m_fixtureCount--;
              c.m_next = this.m_fixtureList;
              this.m_fixtureList = c;
              this.m_fixtureCount++;
              c.m_body = e;
              c = g
          }
          b.m_fixtureCount = 0;
          var b = this,
              e = a;
          b.GetWorldCenter();
          e.GetWorldCenter();
          b.GetLinearVelocity().Copy();
          e.GetLinearVelocity().Copy();
          b.GetAngularVelocity();
          e.GetAngularVelocity();
          b.ResetMassData();
          this.SynchronizeFixtures()
      };
      k.prototype.GetMass = function() {
          return this.m_mass
      };
      k.prototype.GetInertia = function() {
          return this.m_I
      };
      k.prototype.GetMassData = function(a) {
          a.mass = this.m_mass;
          a.I = this.m_I;
          a.center.SetV(this.m_sweep.localCenter)
      };
      k.prototype.SetMassData = function(a) {
          A.b2Assert(this.m_world.IsLocked() == false);
          if (this.m_world.IsLocked() != true)
              if (this.m_type == k.b2_dynamicBody) {
                  this.m_invI = this.m_I = this.m_invMass = 0;
                  this.m_mass = a.mass;
                  if (this.m_mass <= 0) this.m_mass = 1;
                  this.m_invMass = 1 / this.m_mass;
                  if (a.I > 0 && (this.m_flags & k.e_fixedRotationFlag) ==
                      0) {
                      this.m_I = a.I - this.m_mass * (a.center.x * a.center.x + a.center.y * a.center.y);
                      this.m_invI = 1 / this.m_I
                  }
                  var c = this.m_sweep.c.Copy();
                  this.m_sweep.localCenter.SetV(a.center);
                  this.m_sweep.c0.SetV(F.MulX(this.m_xf, this.m_sweep.localCenter));
                  this.m_sweep.c.SetV(this.m_sweep.c0);
                  this.m_linearVelocity.x += this.m_angularVelocity * -(this.m_sweep.c.y - c.y);
                  this.m_linearVelocity.y += this.m_angularVelocity * +(this.m_sweep.c.x - c.x)
              }
      };
      k.prototype.ResetMassData = function() {
          this.m_invI = this.m_I = this.m_invMass = this.m_mass = 0;
          this.m_sweep.localCenter.SetZero();
          if (!(this.m_type == k.b2_staticBody || this.m_type == k.b2_kinematicBody)) {
              for (var a = y.Make(0, 0), c = this.m_fixtureList; c; c = c.m_next)
                  if (c.m_density != 0) {
                      var g = c.GetMassData();
                      this.m_mass += g.mass;
                      a.x += g.center.x * g.mass;
                      a.y += g.center.y * g.mass;
                      this.m_I += g.I
                  }
              if (this.m_mass > 0) {
                  this.m_invMass = 1 / this.m_mass;
                  a.x *= this.m_invMass;
                  a.y *= this.m_invMass
              } else this.m_invMass = this.m_mass = 1;
              if (this.m_I > 0 && (this.m_flags & k.e_fixedRotationFlag) == 0) {
                  this.m_I -= this.m_mass * (a.x * a.x + a.y * a.y);
                  this.m_I *= this.m_inertiaScale;
                  A.b2Assert(this.m_I >
                      0);
                  this.m_invI = 1 / this.m_I
              } else this.m_invI = this.m_I = 0;
              c = this.m_sweep.c.Copy();
              this.m_sweep.localCenter.SetV(a);
              this.m_sweep.c0.SetV(F.MulX(this.m_xf, this.m_sweep.localCenter));
              this.m_sweep.c.SetV(this.m_sweep.c0);
              this.m_linearVelocity.x += this.m_angularVelocity * -(this.m_sweep.c.y - c.y);
              this.m_linearVelocity.y += this.m_angularVelocity * +(this.m_sweep.c.x - c.x)
          }
      };
      k.prototype.GetWorldPoint = function(a) {
          var c = this.m_xf.R;
          a = new y(c.col1.x * a.x + c.col2.x * a.y, c.col1.y * a.x + c.col2.y * a.y);
          a.x += this.m_xf.position.x;
          a.y += this.m_xf.position.y;
          return a
      };
      k.prototype.GetWorldVector = function(a) {
          return F.MulMV(this.m_xf.R, a)
      };
      k.prototype.GetLocalPoint = function(a) {
          return F.MulXT(this.m_xf, a)
      };
      k.prototype.GetLocalVector = function(a) {
          return F.MulTMV(this.m_xf.R, a)
      };
      k.prototype.GetLinearVelocityFromWorldPoint = function(a) {
          return new y(this.m_linearVelocity.x - this.m_angularVelocity * (a.y - this.m_sweep.c.y), this.m_linearVelocity.y + this.m_angularVelocity * (a.x - this.m_sweep.c.x))
      };
      k.prototype.GetLinearVelocityFromLocalPoint = function(a) {
          var c =
              this.m_xf.R;
          a = new y(c.col1.x * a.x + c.col2.x * a.y, c.col1.y * a.x + c.col2.y * a.y);
          a.x += this.m_xf.position.x;
          a.y += this.m_xf.position.y;
          return new y(this.m_linearVelocity.x - this.m_angularVelocity * (a.y - this.m_sweep.c.y), this.m_linearVelocity.y + this.m_angularVelocity * (a.x - this.m_sweep.c.x))
      };
      k.prototype.GetLinearDamping = function() {
          return this.m_linearDamping
      };
      k.prototype.SetLinearDamping = function(a) {
          if (a === undefined) a = 0;
          this.m_linearDamping = a
      };
      k.prototype.GetAngularDamping = function() {
          return this.m_angularDamping
      };
      k.prototype.SetAngularDamping = function(a) {
          if (a === undefined) a = 0;
          this.m_angularDamping = a
      };
      k.prototype.SetType = function(a) {
          if (a === undefined) a = 0;
          if (this.m_type != a) {
              this.m_type = a;
              this.ResetMassData();
              if (this.m_type == k.b2_staticBody) {
                  this.m_linearVelocity.SetZero();
                  this.m_angularVelocity = 0
              }
              this.SetAwake(true);
              this.m_force.SetZero();
              this.m_torque = 0;
              for (a = this.m_contactList; a; a = a.next) a.contact.FlagForFiltering()
          }
      };
      k.prototype.GetType = function() {
          return this.m_type
      };
      k.prototype.SetBullet = function(a) {
          if (a) this.m_flags |=
              k.e_bulletFlag;
          else this.m_flags &= ~k.e_bulletFlag
      };
      k.prototype.IsBullet = function() {
          return (this.m_flags & k.e_bulletFlag) == k.e_bulletFlag
      };
      k.prototype.SetSleepingAllowed = function(a) {
          if (a) this.m_flags |= k.e_allowSleepFlag;
          else {
              this.m_flags &= ~k.e_allowSleepFlag;
              this.SetAwake(true)
          }
      };
      k.prototype.SetAwake = function(a) {
          if (a) {
              this.m_flags |= k.e_awakeFlag;
              this.m_sleepTime = 0
          } else {
              this.m_flags &= ~k.e_awakeFlag;
              this.m_sleepTime = 0;
              this.m_linearVelocity.SetZero();
              this.m_angularVelocity = 0;
              this.m_force.SetZero();
              this.m_torque =
                  0
          }
      };
      k.prototype.IsAwake = function() {
          return (this.m_flags & k.e_awakeFlag) == k.e_awakeFlag
      };
      k.prototype.SetFixedRotation = function(a) {
          if (a) this.m_flags |= k.e_fixedRotationFlag;
          else this.m_flags &= ~k.e_fixedRotationFlag;
          this.ResetMassData()
      };
      k.prototype.IsFixedRotation = function() {
          return (this.m_flags & k.e_fixedRotationFlag) == k.e_fixedRotationFlag
      };
      k.prototype.SetActive = function(a) {
          if (a != this.IsActive()) {
              var c;
              if (a) {
                  this.m_flags |= k.e_activeFlag;
                  a = this.m_world.m_contactManager.m_broadPhase;
                  for (c = this.m_fixtureList; c; c =
                      c.m_next) c.CreateProxy(a, this.m_xf)
              } else {
                  this.m_flags &= ~k.e_activeFlag;
                  a = this.m_world.m_contactManager.m_broadPhase;
                  for (c = this.m_fixtureList; c; c = c.m_next) c.DestroyProxy(a);
                  for (a = this.m_contactList; a;) {
                      c = a;
                      a = a.next;
                      this.m_world.m_contactManager.Destroy(c.contact)
                  }
                  this.m_contactList = null
              }
          }
      };
      k.prototype.IsActive = function() {
          return (this.m_flags & k.e_activeFlag) == k.e_activeFlag
      };
      k.prototype.IsSleepingAllowed = function() {
          return (this.m_flags & k.e_allowSleepFlag) == k.e_allowSleepFlag
      };
      k.prototype.GetFixtureList =
          function() {
              return this.m_fixtureList
          };
      k.prototype.GetJointList = function() {
          return this.m_jointList
      };
      k.prototype.GetControllerList = function() {
          return this.m_controllerList
      };
      k.prototype.GetContactList = function() {
          return this.m_contactList
      };
      k.prototype.GetNext = function() {
          return this.m_next
      };
      k.prototype.GetUserData = function() {
          return this.m_userData
      };
      k.prototype.SetUserData = function(a) {
          this.m_userData = a
      };
      k.prototype.GetWorld = function() {
          return this.m_world
      };
      k.prototype.b2Body = function(a, c) {
          this.m_flags = 0;
          if (a.bullet) this.m_flags |= k.e_bulletFlag;
          if (a.fixedRotation) this.m_flags |= k.e_fixedRotationFlag;
          if (a.allowSleep) this.m_flags |= k.e_allowSleepFlag;
          if (a.awake) this.m_flags |= k.e_awakeFlag;
          if (a.active) this.m_flags |= k.e_activeFlag;
          this.m_world = c;
          this.m_xf.position.SetV(a.position);
          this.m_xf.R.Set(a.angle);
          this.m_sweep.localCenter.SetZero();
          this.m_sweep.t0 = 1;
          this.m_sweep.a0 = this.m_sweep.a = a.angle;
          var g = this.m_xf.R,
              b = this.m_sweep.localCenter;
          this.m_sweep.c.x = g.col1.x * b.x + g.col2.x * b.y;
          this.m_sweep.c.y = g.col1.y *
              b.x + g.col2.y * b.y;
          this.m_sweep.c.x += this.m_xf.position.x;
          this.m_sweep.c.y += this.m_xf.position.y;
          this.m_sweep.c0.SetV(this.m_sweep.c);
          this.m_contactList = this.m_controllerList = this.m_jointList = null;
          this.m_controllerCount = 0;
          this.m_next = this.m_prev = null;
          this.m_linearVelocity.SetV(a.linearVelocity);
          this.m_angularVelocity = a.angularVelocity;
          this.m_linearDamping = a.linearDamping;
          this.m_angularDamping = a.angularDamping;
          this.m_force.Set(0, 0);
          this.m_sleepTime = this.m_torque = 0;
          this.m_type = a.type;
          if (this.m_type ==
              k.b2_dynamicBody) this.m_invMass = this.m_mass = 1;
          else this.m_invMass = this.m_mass = 0;
          this.m_invI = this.m_I = 0;
          this.m_inertiaScale = a.inertiaScale;
          this.m_userData = a.userData;
          this.m_fixtureList = null;
          this.m_fixtureCount = 0
      };
      k.prototype.SynchronizeFixtures = function() {
          var a = k.s_xf1;
          a.R.Set(this.m_sweep.a0);
          var c = a.R,
              g = this.m_sweep.localCenter;
          a.position.x = this.m_sweep.c0.x - (c.col1.x * g.x + c.col2.x * g.y);
          a.position.y = this.m_sweep.c0.y - (c.col1.y * g.x + c.col2.y * g.y);
          g = this.m_world.m_contactManager.m_broadPhase;
          for (c = this.m_fixtureList; c; c =
              c.m_next) c.Synchronize(g, a, this.m_xf)
      };
      k.prototype.SynchronizeTransform = function() {
          this.m_xf.R.Set(this.m_sweep.a);
          var a = this.m_xf.R,
              c = this.m_sweep.localCenter;
          this.m_xf.position.x = this.m_sweep.c.x - (a.col1.x * c.x + a.col2.x * c.y);
          this.m_xf.position.y = this.m_sweep.c.y - (a.col1.y * c.x + a.col2.y * c.y)
      };
      k.prototype.ShouldCollide = function(a) {
          if (this.m_type != k.b2_dynamicBody && a.m_type != k.b2_dynamicBody) return false;
          for (var c = this.m_jointList; c; c = c.next)
              if (c.other == a)
                  if (c.joint.m_collideConnected == false) return false;
          return true
      };
      k.prototype.Advance = function(a) {
          if (a === undefined) a = 0;
          this.m_sweep.Advance(a);
          this.m_sweep.c.SetV(this.m_sweep.c0);
          this.m_sweep.a = this.m_sweep.a0;
          this.SynchronizeTransform()
      };
      Box2D.postDefs.push(function() {
          Box2D.Dynamics.b2Body.s_xf1 = new K;
          Box2D.Dynamics.b2Body.e_islandFlag = 1;
          Box2D.Dynamics.b2Body.e_awakeFlag = 2;
          Box2D.Dynamics.b2Body.e_allowSleepFlag = 4;
          Box2D.Dynamics.b2Body.e_bulletFlag = 8;
          Box2D.Dynamics.b2Body.e_fixedRotationFlag = 16;
          Box2D.Dynamics.b2Body.e_activeFlag = 32;
          Box2D.Dynamics.b2Body.b2_staticBody =
              0;
          Box2D.Dynamics.b2Body.b2_kinematicBody = 1;
          Box2D.Dynamics.b2Body.b2_dynamicBody = 2
      });
      z.b2BodyDef = function() {
          this.position = new y;
          this.linearVelocity = new y
      };
      z.prototype.b2BodyDef = function() {
          this.userData = null;
          this.position.Set(0, 0);
          this.angle = 0;
          this.linearVelocity.Set(0, 0);
          this.angularDamping = this.linearDamping = this.angularVelocity = 0;
          this.awake = this.allowSleep = true;
          this.bullet = this.fixedRotation = false;
          this.type = k.b2_staticBody;
          this.active = true;
          this.inertiaScale = 1
      };
      u.b2ContactFilter = function() {};
      u.prototype.ShouldCollide =
          function(a, c) {
              var g = a.GetFilterData(),
                  b = c.GetFilterData();
              if (g.groupIndex == b.groupIndex && g.groupIndex != 0) return g.groupIndex > 0;
              return (g.maskBits & b.categoryBits) != 0 && (g.categoryBits & b.maskBits) != 0
          };
      u.prototype.RayCollide = function(a, c) {
          if (!a) return true;
          return this.ShouldCollide(a instanceof S ? a : null, c)
      };
      Box2D.postDefs.push(function() {
          Box2D.Dynamics.b2ContactFilter.b2_defaultFilter = new u
      });
      D.b2ContactImpulse = function() {
          this.normalImpulses = new Vector_a2j_Number(A.b2_maxManifoldPoints);
          this.tangentImpulses =
              new Vector_a2j_Number(A.b2_maxManifoldPoints)
      };
      H.b2ContactListener = function() {};
      H.prototype.BeginContact = function() {};
      H.prototype.EndContact = function() {};
      H.prototype.PreSolve = function() {};
      H.prototype.PostSolve = function() {};
      Box2D.postDefs.push(function() {
          Box2D.Dynamics.b2ContactListener.b2_defaultListener = new H
      });
      O.b2ContactManager = function() {};
      O.prototype.b2ContactManager = function() {
          this.m_world = null;
          this.m_contactCount = 0;
          this.m_contactFilter = u.b2_defaultFilter;
          this.m_contactListener = H.b2_defaultListener;
          this.m_contactFactory = new j(this.m_allocator);
          this.m_broadPhase = new B
      };
      O.prototype.AddPair = function(a, c) {
          var g = a instanceof S ? a : null,
              b = c instanceof S ? c : null,
              e = g.GetBody(),
              f = b.GetBody();
          if (e != f) {
              for (var m = f.GetContactList(); m;) {
                  if (m.other == e) {
                      var r = m.contact.GetFixtureA(),
                          s = m.contact.GetFixtureB();
                      if (r == g && s == b) return;
                      if (r == b && s == g) return
                  }
                  m = m.next
              }
              if (f.ShouldCollide(e) != false)
                  if (this.m_contactFilter.ShouldCollide(g, b) != false) {
                      m = this.m_contactFactory.Create(g, b);
                      g = m.GetFixtureA();
                      b = m.GetFixtureB();
                      e = g.m_body;
                      f = b.m_body;
                      m.m_prev = null;
                      m.m_next = this.m_world.m_contactList;
                      if (this.m_world.m_contactList != null) this.m_world.m_contactList.m_prev = m;
                      this.m_world.m_contactList = m;
                      m.m_nodeA.contact = m;
                      m.m_nodeA.other = f;
                      m.m_nodeA.prev = null;
                      m.m_nodeA.next = e.m_contactList;
                      if (e.m_contactList != null) e.m_contactList.prev = m.m_nodeA;
                      e.m_contactList = m.m_nodeA;
                      m.m_nodeB.contact = m;
                      m.m_nodeB.other = e;
                      m.m_nodeB.prev = null;
                      m.m_nodeB.next = f.m_contactList;
                      if (f.m_contactList != null) f.m_contactList.prev = m.m_nodeB;
                      f.m_contactList =
                          m.m_nodeB;
                      ++this.m_world.m_contactCount
                  }
          }
      };
      O.prototype.FindNewContacts = function() {
          this.m_broadPhase.UpdatePairs(Box2D.generateCallback(this, this.AddPair))
      };
      O.prototype.Destroy = function(a) {
          var c = a.GetFixtureA(),
              g = a.GetFixtureB();
          c = c.GetBody();
          g = g.GetBody();
          a.IsTouching() && this.m_contactListener.EndContact(a);
          if (a.m_prev) a.m_prev.m_next = a.m_next;
          if (a.m_next) a.m_next.m_prev = a.m_prev;
          if (a == this.m_world.m_contactList) this.m_world.m_contactList = a.m_next;
          if (a.m_nodeA.prev) a.m_nodeA.prev.next = a.m_nodeA.next;
          if (a.m_nodeA.next) a.m_nodeA.next.prev = a.m_nodeA.prev;
          if (a.m_nodeA == c.m_contactList) c.m_contactList = a.m_nodeA.next;
          if (a.m_nodeB.prev) a.m_nodeB.prev.next = a.m_nodeB.next;
          if (a.m_nodeB.next) a.m_nodeB.next.prev = a.m_nodeB.prev;
          if (a.m_nodeB == g.m_contactList) g.m_contactList = a.m_nodeB.next;
          this.m_contactFactory.Destroy(a);
          --this.m_contactCount
      };
      O.prototype.Collide = function() {
          for (var a = this.m_world.m_contactList; a;) {
              var c = a.GetFixtureA(),
                  g = a.GetFixtureB(),
                  b = c.GetBody(),
                  e = g.GetBody();
              if (b.IsAwake() == false && e.IsAwake() ==
                  false) a = a.GetNext();
              else {
                  if (a.m_flags & l.e_filterFlag) {
                      if (e.ShouldCollide(b) == false) {
                          c = a;
                          a = c.GetNext();
                          this.Destroy(c);
                          continue
                      }
                      if (this.m_contactFilter.ShouldCollide(c, g) == false) {
                          c = a;
                          a = c.GetNext();
                          this.Destroy(c);
                          continue
                      }
                      a.m_flags &= ~l.e_filterFlag
                  }
                  if (this.m_broadPhase.TestOverlap(c.m_proxy, g.m_proxy) == false) {
                      c = a;
                      a = c.GetNext();
                      this.Destroy(c)
                  } else {
                      a.Update(this.m_contactListener);
                      a = a.GetNext()
                  }
              }
          }
      };
      Box2D.postDefs.push(function() {
          Box2D.Dynamics.b2ContactManager.s_evalCP = new p
      });
      E.b2DebugDraw = function() {};
      E.prototype.b2DebugDraw = function() {};
      E.prototype.SetFlags = function() {};
      E.prototype.GetFlags = function() {};
      E.prototype.AppendFlags = function() {};
      E.prototype.ClearFlags = function() {};
      E.prototype.SetSprite = function() {};
      E.prototype.GetSprite = function() {};
      E.prototype.SetDrawScale = function() {};
      E.prototype.GetDrawScale = function() {};
      E.prototype.SetLineThickness = function() {};
      E.prototype.GetLineThickness = function() {};
      E.prototype.SetAlpha = function() {};
      E.prototype.GetAlpha = function() {};
      E.prototype.SetFillAlpha =
          function() {};
      E.prototype.GetFillAlpha = function() {};
      E.prototype.SetXFormScale = function() {};
      E.prototype.GetXFormScale = function() {};
      E.prototype.DrawPolygon = function() {};
      E.prototype.DrawSolidPolygon = function() {};
      E.prototype.DrawCircle = function() {};
      E.prototype.DrawSolidCircle = function() {};
      E.prototype.DrawSegment = function() {};
      E.prototype.DrawTransform = function() {};
      Box2D.postDefs.push(function() {
          Box2D.Dynamics.b2DebugDraw.e_shapeBit = 1;
          Box2D.Dynamics.b2DebugDraw.e_jointBit = 2;
          Box2D.Dynamics.b2DebugDraw.e_aabbBit =
              4;
          Box2D.Dynamics.b2DebugDraw.e_pairBit = 8;
          Box2D.Dynamics.b2DebugDraw.e_centerOfMassBit = 16;
          Box2D.Dynamics.b2DebugDraw.e_controllerBit = 32
      });
      R.b2DestructionListener = function() {};
      R.prototype.SayGoodbyeJoint = function() {};
      R.prototype.SayGoodbyeFixture = function() {};
      N.b2FilterData = function() {
          this.categoryBits = 1;
          this.maskBits = 65535;
          this.groupIndex = 0
      };
      N.prototype.Copy = function() {
          var a = new N;
          a.categoryBits = this.categoryBits;
          a.maskBits = this.maskBits;
          a.groupIndex = this.groupIndex;
          return a
      };
      S.b2Fixture = function() {
          this.m_filter =
              new N
      };
      S.prototype.GetType = function() {
          return this.m_shape.GetType()
      };
      S.prototype.GetShape = function() {
          return this.m_shape
      };
      S.prototype.SetSensor = function(a) {
          if (this.m_isSensor != a) {
              this.m_isSensor = a;
              if (this.m_body != null)
                  for (a = this.m_body.GetContactList(); a;) {
                      var c = a.contact,
                          g = c.GetFixtureA(),
                          b = c.GetFixtureB();
                      if (g == this || b == this) c.SetSensor(g.IsSensor() || b.IsSensor());
                      a = a.next
                  }
          }
      };
      S.prototype.IsSensor = function() {
          return this.m_isSensor
      };
      S.prototype.SetFilterData = function(a) {
          this.m_filter = a.Copy();
          if (!this.m_body)
              for (a =
                  this.m_body.GetContactList(); a;) {
                  var c = a.contact,
                      g = c.GetFixtureA(),
                      b = c.GetFixtureB();
                  if (g == this || b == this) c.FlagForFiltering();
                  a = a.next
              }
      };
      S.prototype.GetFilterData = function() {
          return this.m_filter.Copy()
      };
      S.prototype.GetBody = function() {
          return this.m_body
      };
      S.prototype.GetNext = function() {
          return this.m_next
      };
      S.prototype.GetUserData = function() {
          return this.m_userData
      };
      S.prototype.SetUserData = function(a) {
          this.m_userData = a
      };
      S.prototype.TestPoint = function(a) {
          return this.m_shape.TestPoint(this.m_body.GetTransform(),
              a)
      };
      S.prototype.RayCast = function(a, c) {
          return this.m_shape.RayCast(a, c, this.m_body.GetTransform())
      };
      S.prototype.GetMassData = function(a) {
          if (a === undefined) a = null;
          if (a == null) a = new I;
          this.m_shape.ComputeMass(a, this.m_density);
          return a
      };
      S.prototype.SetDensity = function(a) {
          if (a === undefined) a = 0;
          this.m_density = a
      };
      S.prototype.GetDensity = function() {
          return this.m_density
      };
      S.prototype.GetFriction = function() {
          return this.m_friction
      };
      S.prototype.SetFriction = function(a) {
          if (a === undefined) a = 0;
          this.m_friction = a
      };
      S.prototype.GetRestitution =
          function() {
              return this.m_restitution
          };
      S.prototype.SetRestitution = function(a) {
          if (a === undefined) a = 0;
          this.m_restitution = a
      };
      S.prototype.GetAABB = function() {
          return this.m_aabb
      };
      S.prototype.b2Fixture = function() {
          this.m_aabb = new U;
          this.m_shape = this.m_next = this.m_body = this.m_userData = null;
          this.m_restitution = this.m_friction = this.m_density = 0
      };
      S.prototype.Create = function(a, c, g) {
          this.m_userData = g.userData;
          this.m_friction = g.friction;
          this.m_restitution = g.restitution;
          this.m_body = a;
          this.m_next = null;
          this.m_filter = g.filter.Copy();
          this.m_isSensor = g.isSensor;
          this.m_shape = g.shape.Copy();
          this.m_density = g.density
      };
      S.prototype.Destroy = function() {
          this.m_shape = null
      };
      S.prototype.CreateProxy = function(a, c) {
          this.m_shape.ComputeAABB(this.m_aabb, c);
          this.m_proxy = a.CreateProxy(this.m_aabb, this)
      };
      S.prototype.DestroyProxy = function(a) {
          if (this.m_proxy != null) {
              a.DestroyProxy(this.m_proxy);
              this.m_proxy = null
          }
      };
      S.prototype.Synchronize = function(a, c, g) {
          if (this.m_proxy) {
              var b = new U,
                  e = new U;
              this.m_shape.ComputeAABB(b, c);
              this.m_shape.ComputeAABB(e, g);
              this.m_aabb.Combine(b, e);
              c = F.SubtractVV(g.position, c.position);
              a.MoveProxy(this.m_proxy, this.m_aabb, c)
          }
      };
      aa.b2FixtureDef = function() {
          this.filter = new N
      };
      aa.prototype.b2FixtureDef = function() {
          this.userData = this.shape = null;
          this.friction = 0.2;
          this.density = this.restitution = 0;
          this.filter.categoryBits = 1;
          this.filter.maskBits = 65535;
          this.filter.groupIndex = 0;
          this.isSensor = false
      };
      Z.b2Island = function() {};
      Z.prototype.b2Island = function() {
          this.m_bodies = new Vector;
          this.m_contacts = new Vector;
          this.m_joints = new Vector
      };
      Z.prototype.Initialize = function(a, c, g, b, e, f) {
          if (a === undefined) a = 0;
          if (c === undefined) c = 0;
          if (g === undefined) g = 0;
          var m = 0;
          this.m_bodyCapacity = a;
          this.m_contactCapacity = c;
          this.m_jointCapacity = g;
          this.m_jointCount = this.m_contactCount = this.m_bodyCount = 0;
          this.m_allocator = b;
          this.m_listener = e;
          this.m_contactSolver = f;
          for (m = this.m_bodies.length; m < a; m++) this.m_bodies[m] = null;
          for (m = this.m_contacts.length; m < c; m++) this.m_contacts[m] = null;
          for (m = this.m_joints.length; m < g; m++) this.m_joints[m] = null
      };
      Z.prototype.Clear = function() {
          this.m_jointCount =
              this.m_contactCount = this.m_bodyCount = 0
      };
      Z.prototype.Solve = function(a, c, g) {
          var b = 0,
              e = 0,
              f;
          for (b = 0; b < this.m_bodyCount; ++b) {
              e = this.m_bodies[b];
              if (e.GetType() == k.b2_dynamicBody) {
                  e.m_linearVelocity.x += a.dt * (c.x + e.m_invMass * e.m_force.x);
                  e.m_linearVelocity.y += a.dt * (c.y + e.m_invMass * e.m_force.y);
                  e.m_angularVelocity += a.dt * e.m_invI * e.m_torque;
                  e.m_linearVelocity.Multiply(F.Clamp(1 - a.dt * e.m_linearDamping, 0, 1));
                  e.m_angularVelocity *= F.Clamp(1 - a.dt * e.m_angularDamping, 0, 1)
              }
          }
          this.m_contactSolver.Initialize(a, this.m_contacts,
              this.m_contactCount, this.m_allocator);
          c = this.m_contactSolver;
          c.InitVelocityConstraints(a);
          for (b = 0; b < this.m_jointCount; ++b) {
              f = this.m_joints[b];
              f.InitVelocityConstraints(a)
          }
          for (b = 0; b < a.velocityIterations; ++b) {
              for (e = 0; e < this.m_jointCount; ++e) {
                  f = this.m_joints[e];
                  f.SolveVelocityConstraints(a)
              }
              c.SolveVelocityConstraints()
          }
          for (b = 0; b < this.m_jointCount; ++b) {
              f = this.m_joints[b];
              f.FinalizeVelocityConstraints()
          }
          c.FinalizeVelocityConstraints();
          for (b = 0; b < this.m_bodyCount; ++b) {
              e = this.m_bodies[b];
              if (e.GetType() !=
                  k.b2_staticBody) {
                  var m = a.dt * e.m_linearVelocity.x,
                      r = a.dt * e.m_linearVelocity.y;
                  if (m * m + r * r > A.b2_maxTranslationSquared) {
                      e.m_linearVelocity.Normalize();
                      e.m_linearVelocity.x *= A.b2_maxTranslation * a.inv_dt;
                      e.m_linearVelocity.y *= A.b2_maxTranslation * a.inv_dt
                  }
                  m = a.dt * e.m_angularVelocity;
                  if (m * m > A.b2_maxRotationSquared) e.m_angularVelocity = e.m_angularVelocity < 0 ? -A.b2_maxRotation * a.inv_dt : A.b2_maxRotation * a.inv_dt;
                  e.m_sweep.c0.SetV(e.m_sweep.c);
                  e.m_sweep.a0 = e.m_sweep.a;
                  e.m_sweep.c.x += a.dt * e.m_linearVelocity.x;
                  e.m_sweep.c.y +=
                      a.dt * e.m_linearVelocity.y;
                  e.m_sweep.a += a.dt * e.m_angularVelocity;
                  e.SynchronizeTransform()
              }
          }
          for (b = 0; b < a.positionIterations; ++b) {
              m = c.SolvePositionConstraints(A.b2_contactBaumgarte);
              r = true;
              for (e = 0; e < this.m_jointCount; ++e) {
                  f = this.m_joints[e];
                  f = f.SolvePositionConstraints(A.b2_contactBaumgarte);
                  r = r && f
              }
              if (m && r) break
          }
          this.Report(c.m_constraints);
          if (g) {
              g = Number.MAX_VALUE;
              c = A.b2_linearSleepTolerance * A.b2_linearSleepTolerance;
              m = A.b2_angularSleepTolerance * A.b2_angularSleepTolerance;
              for (b = 0; b < this.m_bodyCount; ++b) {
                  e =
                      this.m_bodies[b];
                  if (e.GetType() != k.b2_staticBody) {
                      if ((e.m_flags & k.e_allowSleepFlag) == 0) g = e.m_sleepTime = 0;
                      if ((e.m_flags & k.e_allowSleepFlag) == 0 || e.m_angularVelocity * e.m_angularVelocity > m || F.Dot(e.m_linearVelocity, e.m_linearVelocity) > c) g = e.m_sleepTime = 0;
                      else {
                          e.m_sleepTime += a.dt;
                          g = F.Min(g, e.m_sleepTime)
                      }
                  }
              }
              if (g >= A.b2_timeToSleep)
                  for (b = 0; b < this.m_bodyCount; ++b) {
                      e = this.m_bodies[b];
                      e.SetAwake(false)
                  }
          }
      };
      Z.prototype.SolveTOI = function(a) {
          var c = 0,
              g = 0;
          this.m_contactSolver.Initialize(a, this.m_contacts, this.m_contactCount,
              this.m_allocator);
          var b = this.m_contactSolver;
          for (c = 0; c < this.m_jointCount; ++c) this.m_joints[c].InitVelocityConstraints(a);
          for (c = 0; c < a.velocityIterations; ++c) {
              b.SolveVelocityConstraints();
              for (g = 0; g < this.m_jointCount; ++g) this.m_joints[g].SolveVelocityConstraints(a)
          }
          for (c = 0; c < this.m_bodyCount; ++c) {
              g = this.m_bodies[c];
              if (g.GetType() != k.b2_staticBody) {
                  var e = a.dt * g.m_linearVelocity.x,
                      f = a.dt * g.m_linearVelocity.y;
                  if (e * e + f * f > A.b2_maxTranslationSquared) {
                      g.m_linearVelocity.Normalize();
                      g.m_linearVelocity.x *= A.b2_maxTranslation *
                          a.inv_dt;
                      g.m_linearVelocity.y *= A.b2_maxTranslation * a.inv_dt
                  }
                  e = a.dt * g.m_angularVelocity;
                  if (e * e > A.b2_maxRotationSquared) g.m_angularVelocity = g.m_angularVelocity < 0 ? -A.b2_maxRotation * a.inv_dt : A.b2_maxRotation * a.inv_dt;
                  g.m_sweep.c0.SetV(g.m_sweep.c);
                  g.m_sweep.a0 = g.m_sweep.a;
                  g.m_sweep.c.x += a.dt * g.m_linearVelocity.x;
                  g.m_sweep.c.y += a.dt * g.m_linearVelocity.y;
                  g.m_sweep.a += a.dt * g.m_angularVelocity;
                  g.SynchronizeTransform()
              }
          }
          for (c = 0; c < a.positionIterations; ++c) {
              e = b.SolvePositionConstraints(0.75);
              f = true;
              for (g = 0; g <
                  this.m_jointCount; ++g) {
                  var m = this.m_joints[g].SolvePositionConstraints(A.b2_contactBaumgarte);
                  f = f && m
              }
              if (e && f) break
          }
          this.Report(b.m_constraints)
      };
      Z.prototype.Report = function(a) {
          if (this.m_listener != null)
              for (var c = 0; c < this.m_contactCount; ++c) {
                  for (var g = this.m_contacts[c], b = a[c], e = 0; e < b.pointCount; ++e) {
                      Z.s_impulse.normalImpulses[e] = b.points[e].normalImpulse;
                      Z.s_impulse.tangentImpulses[e] = b.points[e].tangentImpulse
                  }
                  this.m_listener.PostSolve(g, Z.s_impulse)
              }
      };
      Z.prototype.AddBody = function(a) {
          a.m_islandIndex =
              this.m_bodyCount;
          this.m_bodies[this.m_bodyCount++] = a
      };
      Z.prototype.AddContact = function(a) {
          this.m_contacts[this.m_contactCount++] = a
      };
      Z.prototype.AddJoint = function(a) {
          this.m_joints[this.m_jointCount++] = a
      };
      Box2D.postDefs.push(function() {
          Box2D.Dynamics.b2Island.s_impulse = new D
      });
      d.b2TimeStep = function() {};
      d.prototype.Set = function(a) {
          this.dt = a.dt;
          this.inv_dt = a.inv_dt;
          this.positionIterations = a.positionIterations;
          this.velocityIterations = a.velocityIterations;
          this.warmStarting = a.warmStarting
      };
      h.b2World = function() {
          this.s_stack =
              new Vector;
          this.m_contactManager = new O;
          this.m_contactSolver = new o;
          this.m_island = new Z
      };
      h.prototype.b2World = function(a, c) {
          this.m_controllerList = this.m_jointList = this.m_contactList = this.m_bodyList = this.m_debugDraw = this.m_destructionListener = null;
          this.m_controllerCount = this.m_jointCount = this.m_contactCount = this.m_bodyCount = 0;
          h.m_warmStarting = true;
          h.m_continuousPhysics = true;
          this.m_allowSleep = c;
          this.m_gravity = a;
          this.m_inv_dt0 = 0;
          this.m_contactManager.m_world = this;
          this.m_groundBody = this.CreateBody(new z)
      };
      h.prototype.SetDestructionListener = function(a) {
          this.m_destructionListener = a
      };
      h.prototype.SetContactFilter = function(a) {
          this.m_contactManager.m_contactFilter = a
      };
      h.prototype.SetContactListener = function(a) {
          this.m_contactManager.m_contactListener = a
      };
      h.prototype.SetDebugDraw = function(a) {
          this.m_debugDraw = a
      };
      h.prototype.SetBroadPhase = function(a) {
          var c = this.m_contactManager.m_broadPhase;
          this.m_contactManager.m_broadPhase = a;
          for (var g = this.m_bodyList; g; g = g.m_next)
              for (var b = g.m_fixtureList; b; b = b.m_next) b.m_proxy =
                  a.CreateProxy(c.GetFatAABB(b.m_proxy), b)
      };
      h.prototype.Validate = function() {
          this.m_contactManager.m_broadPhase.Validate()
      };
      h.prototype.GetProxyCount = function() {
          return this.m_contactManager.m_broadPhase.GetProxyCount()
      };
      h.prototype.CreateBody = function(a) {
          if (this.IsLocked() == true) return null;
          a = new k(a, this);
          a.m_prev = null;
          if (a.m_next = this.m_bodyList) this.m_bodyList.m_prev = a;
          this.m_bodyList = a;
          ++this.m_bodyCount;
          return a
      };
      h.prototype.DestroyBody = function(a) {
          if (this.IsLocked() != true) {
              for (var c = a.m_jointList; c;) {
                  var g =
                      c;
                  c = c.next;
                  this.m_destructionListener && this.m_destructionListener.SayGoodbyeJoint(g.joint);
                  this.DestroyJoint(g.joint)
              }
              for (c = a.m_controllerList; c;) {
                  g = c;
                  c = c.nextController;
                  g.controller.RemoveBody(a)
              }
              for (c = a.m_contactList; c;) {
                  g = c;
                  c = c.next;
                  this.m_contactManager.Destroy(g.contact)
              }
              a.m_contactList = null;
              for (c = a.m_fixtureList; c;) {
                  g = c;
                  c = c.m_next;
                  this.m_destructionListener && this.m_destructionListener.SayGoodbyeFixture(g);
                  g.DestroyProxy(this.m_contactManager.m_broadPhase);
                  g.Destroy()
              }
              a.m_fixtureList = null;
              a.m_fixtureCount =
                  0;
              if (a.m_prev) a.m_prev.m_next = a.m_next;
              if (a.m_next) a.m_next.m_prev = a.m_prev;
              if (a == this.m_bodyList) this.m_bodyList = a.m_next;
              --this.m_bodyCount
          }
      };
      h.prototype.CreateJoint = function(a) {
          var c = q.Create(a, null);
          c.m_prev = null;
          if (c.m_next = this.m_jointList) this.m_jointList.m_prev = c;
          this.m_jointList = c;
          ++this.m_jointCount;
          c.m_edgeA.joint = c;
          c.m_edgeA.other = c.m_bodyB;
          c.m_edgeA.prev = null;
          if (c.m_edgeA.next = c.m_bodyA.m_jointList) c.m_bodyA.m_jointList.prev = c.m_edgeA;
          c.m_bodyA.m_jointList = c.m_edgeA;
          c.m_edgeB.joint = c;
          c.m_edgeB.other = c.m_bodyA;
          c.m_edgeB.prev = null;
          if (c.m_edgeB.next = c.m_bodyB.m_jointList) c.m_bodyB.m_jointList.prev = c.m_edgeB;
          c.m_bodyB.m_jointList = c.m_edgeB;
          var g = a.bodyA,
              b = a.bodyB;
          if (a.collideConnected == false)
              for (a = b.GetContactList(); a;) {
                  a.other == g && a.contact.FlagForFiltering();
                  a = a.next
              }
          return c
      };
      h.prototype.DestroyJoint = function(a) {
          var c = a.m_collideConnected;
          if (a.m_prev) a.m_prev.m_next = a.m_next;
          if (a.m_next) a.m_next.m_prev = a.m_prev;
          if (a == this.m_jointList) this.m_jointList = a.m_next;
          var g = a.m_bodyA,
              b =
              a.m_bodyB;
          g.SetAwake(true);
          b.SetAwake(true);
          if (a.m_edgeA.prev) a.m_edgeA.prev.next = a.m_edgeA.next;
          if (a.m_edgeA.next) a.m_edgeA.next.prev = a.m_edgeA.prev;
          if (a.m_edgeA == g.m_jointList) g.m_jointList = a.m_edgeA.next;
          a.m_edgeA.prev = null;
          a.m_edgeA.next = null;
          if (a.m_edgeB.prev) a.m_edgeB.prev.next = a.m_edgeB.next;
          if (a.m_edgeB.next) a.m_edgeB.next.prev = a.m_edgeB.prev;
          if (a.m_edgeB == b.m_jointList) b.m_jointList = a.m_edgeB.next;
          a.m_edgeB.prev = null;
          a.m_edgeB.next = null;
          q.Destroy(a, null);
          --this.m_jointCount;
          if (c == false)
              for (a =
                  b.GetContactList(); a;) {
                  a.other == g && a.contact.FlagForFiltering();
                  a = a.next
              }
      };
      h.prototype.AddController = function(a) {
          a.m_next = this.m_controllerList;
          a.m_prev = null;
          this.m_controllerList = a;
          a.m_world = this;
          this.m_controllerCount++;
          return a
      };
      h.prototype.RemoveController = function(a) {
          if (a.m_prev) a.m_prev.m_next = a.m_next;
          if (a.m_next) a.m_next.m_prev = a.m_prev;
          if (this.m_controllerList == a) this.m_controllerList = a.m_next;
          this.m_controllerCount--
      };
      h.prototype.CreateController = function(a) {
          if (a.m_world != this) throw Error("Controller can only be a member of one world");
          a.m_next = this.m_controllerList;
          a.m_prev = null;
          if (this.m_controllerList) this.m_controllerList.m_prev = a;
          this.m_controllerList = a;
          ++this.m_controllerCount;
          a.m_world = this;
          return a
      };
      h.prototype.DestroyController = function(a) {
          a.Clear();
          if (a.m_next) a.m_next.m_prev = a.m_prev;
          if (a.m_prev) a.m_prev.m_next = a.m_next;
          if (a == this.m_controllerList) this.m_controllerList = a.m_next;
          --this.m_controllerCount
      };
      h.prototype.SetWarmStarting = function(a) {
          h.m_warmStarting = a
      };
      h.prototype.SetContinuousPhysics = function(a) {
          h.m_continuousPhysics =
              a
      };
      h.prototype.GetBodyCount = function() {
          return this.m_bodyCount
      };
      h.prototype.GetJointCount = function() {
          return this.m_jointCount
      };
      h.prototype.GetContactCount = function() {
          return this.m_contactCount
      };
      h.prototype.SetGravity = function(a) {
          this.m_gravity = a
      };
      h.prototype.GetGravity = function() {
          return this.m_gravity
      };
      h.prototype.GetGroundBody = function() {
          return this.m_groundBody
      };
      h.prototype.Step = function(a, c, g) {
          if (a === undefined) a = 0;
          if (c === undefined) c = 0;
          if (g === undefined) g = 0;
          if (this.m_flags & h.e_newFixture) {
              this.m_contactManager.FindNewContacts();
              this.m_flags &= ~h.e_newFixture
          }
          this.m_flags |= h.e_locked;
          var b = h.s_timestep2;
          b.dt = a;
          b.velocityIterations = c;
          b.positionIterations = g;
          b.inv_dt = a > 0 ? 1 / a : 0;
          b.dtRatio = this.m_inv_dt0 * a;
          b.warmStarting = h.m_warmStarting;
          this.m_contactManager.Collide();
          b.dt > 0 && this.Solve(b);
          h.m_continuousPhysics && b.dt > 0 && this.SolveTOI(b);
          if (b.dt > 0) this.m_inv_dt0 = b.inv_dt;
          this.m_flags &= ~h.e_locked
      };
      h.prototype.ClearForces = function() {
          for (var a = this.m_bodyList; a; a = a.m_next) {
              a.m_force.SetZero();
              a.m_torque = 0
          }
      };
      h.prototype.DrawDebugData =
          function() {
              if (this.m_debugDraw != null) {
                  this.m_debugDraw.m_sprite.graphics.clear();
                  var a = this.m_debugDraw.GetFlags(),
                      c, g, b;
                  new y;
                  new y;
                  new y;
                  var e;
                  new U;
                  new U;
                  e = [new y, new y, new y, new y];
                  var f = new w(0, 0, 0);
                  if (a & E.e_shapeBit)
                      for (c = this.m_bodyList; c; c = c.m_next) {
                          e = c.m_xf;
                          for (g = c.GetFixtureList(); g; g = g.m_next) {
                              b = g.GetShape();
                              if (c.IsActive() == false) f.Set(0.5, 0.5, 0.3);
                              else if (c.GetType() == k.b2_staticBody) f.Set(0.5, 0.9, 0.5);
                              else if (c.GetType() == k.b2_kinematicBody) f.Set(0.5, 0.5, 0.9);
                              else c.IsAwake() == false ?
                                  f.Set(0.6, 0.6, 0.6) : f.Set(0.9, 0.7, 0.7);
                              this.DrawShape(b, e, f)
                          }
                      }
                  if (a & E.e_jointBit)
                      for (c = this.m_jointList; c; c = c.m_next) this.DrawJoint(c);
                  if (a & E.e_controllerBit)
                      for (c = this.m_controllerList; c; c = c.m_next) c.Draw(this.m_debugDraw);
                  if (a & E.e_pairBit) {
                      f.Set(0.3, 0.9, 0.9);
                      for (c = this.m_contactManager.m_contactList; c; c = c.GetNext()) {
                          b = c.GetFixtureA();
                          g = c.GetFixtureB();
                          b = b.GetAABB().GetCenter();
                          g = g.GetAABB().GetCenter();
                          this.m_debugDraw.DrawSegment(b, g, f)
                      }
                  }
                  if (a & E.e_aabbBit) {
                      b = this.m_contactManager.m_broadPhase;
                      e = [new y,
                          new y, new y, new y
                      ];
                      for (c = this.m_bodyList; c; c = c.GetNext())
                          if (c.IsActive() != false)
                              for (g = c.GetFixtureList(); g; g = g.GetNext()) {
                                  var m = b.GetFatAABB(g.m_proxy);
                                  e[0].Set(m.lowerBound.x, m.lowerBound.y);
                                  e[1].Set(m.upperBound.x, m.lowerBound.y);
                                  e[2].Set(m.upperBound.x, m.upperBound.y);
                                  e[3].Set(m.lowerBound.x, m.upperBound.y);
                                  this.m_debugDraw.DrawPolygon(e, 4, f)
                              }
                  }
                  if (a & E.e_centerOfMassBit)
                      for (c = this.m_bodyList; c; c = c.m_next) {
                          e = h.s_xf;
                          e.R = c.m_xf.R;
                          e.position = c.GetWorldCenter();
                          this.m_debugDraw.DrawTransform(e)
                      }
              }
          };
      h.prototype.QueryAABB =
          function(a, c) {
              var g = this.m_contactManager.m_broadPhase;
              g.Query(function(b) {
                  return a(g.GetUserData(b))
              }, c)
          };
      h.prototype.QueryShape = function(a, c, g) {
          if (g === undefined) g = null;
          if (g == null) {
              g = new K;
              g.SetIdentity()
          }
          var b = this.m_contactManager.m_broadPhase,
              e = new U;
          c.ComputeAABB(e, g);
          b.Query(function(f) {
              f = b.GetUserData(f) instanceof S ? b.GetUserData(f) : null;
              if (Y.TestOverlap(c, g, f.GetShape(), f.GetBody().GetTransform())) return a(f);
              return true
          }, e)
      };
      h.prototype.QueryPoint = function(a, c) {
          var g = this.m_contactManager.m_broadPhase,
              b = new U;
          b.lowerBound.Set(c.x - A.b2_linearSlop, c.y - A.b2_linearSlop);
          b.upperBound.Set(c.x + A.b2_linearSlop, c.y + A.b2_linearSlop);
          g.Query(function(e) {
              e = g.GetUserData(e) instanceof S ? g.GetUserData(e) : null;
              if (e.TestPoint(c)) return a(e);
              return true
          }, b)
      };
      h.prototype.RayCast = function(a, c, g) {
          var b = this.m_contactManager.m_broadPhase,
              e = new V,
              f = new Q(c, g);
          b.RayCast(function(m, r) {
              var s = b.GetUserData(r);
              s = s instanceof S ? s : null;
              if (s.RayCast(e, m)) {
                  var v = e.fraction,
                      t = new y((1 - v) * c.x + v * g.x, (1 - v) * c.y + v * g.y);
                  return a(s,
                      t, e.normal, v)
              }
              return m.maxFraction
          }, f)
      };
      h.prototype.RayCastOne = function(a, c) {
          var g;
          this.RayCast(function(b, e, f, m) {
              if (m === undefined) m = 0;
              g = b;
              return m
          }, a, c);
          return g
      };
      h.prototype.RayCastAll = function(a, c) {
          var g = new Vector;
          this.RayCast(function(b) {
              g[g.length] = b;
              return 1
          }, a, c);
          return g
      };
      h.prototype.GetBodyList = function() {
          return this.m_bodyList
      };
      h.prototype.GetJointList = function() {
          return this.m_jointList
      };
      h.prototype.GetContactList = function() {
          return this.m_contactList
      };
      h.prototype.IsLocked = function() {
          return (this.m_flags &
              h.e_locked) > 0
      };
      h.prototype.Solve = function(a) {
          for (var c, g = this.m_controllerList; g; g = g.m_next) g.Step(a);
          g = this.m_island;
          g.Initialize(this.m_bodyCount, this.m_contactCount, this.m_jointCount, null, this.m_contactManager.m_contactListener, this.m_contactSolver);
          for (c = this.m_bodyList; c; c = c.m_next) c.m_flags &= ~k.e_islandFlag;
          for (var b = this.m_contactList; b; b = b.m_next) b.m_flags &= ~l.e_islandFlag;
          for (b = this.m_jointList; b; b = b.m_next) b.m_islandFlag = false;
          parseInt(this.m_bodyCount);
          b = this.s_stack;
          for (var e = this.m_bodyList; e; e =
              e.m_next)
              if (!(e.m_flags & k.e_islandFlag))
                  if (!(e.IsAwake() == false || e.IsActive() == false))
                      if (e.GetType() != k.b2_staticBody) {
                          g.Clear();
                          var f = 0;
                          b[f++] = e;
                          for (e.m_flags |= k.e_islandFlag; f > 0;) {
                              c = b[--f];
                              g.AddBody(c);
                              c.IsAwake() == false && c.SetAwake(true);
                              if (c.GetType() != k.b2_staticBody) {
                                  for (var m, r = c.m_contactList; r; r = r.next)
                                      if (!(r.contact.m_flags & l.e_islandFlag))
                                          if (!(r.contact.IsSensor() == true || r.contact.IsEnabled() == false || r.contact.IsTouching() == false)) {
                                              g.AddContact(r.contact);
                                              r.contact.m_flags |= l.e_islandFlag;
                                              m = r.other;
                                              if (!(m.m_flags & k.e_islandFlag)) {
                                                  b[f++] = m;
                                                  m.m_flags |= k.e_islandFlag
                                              }
                                          }
                                  for (c = c.m_jointList; c; c = c.next)
                                      if (c.joint.m_islandFlag != true) {
                                          m = c.other;
                                          if (m.IsActive() != false) {
                                              g.AddJoint(c.joint);
                                              c.joint.m_islandFlag = true;
                                              if (!(m.m_flags & k.e_islandFlag)) {
                                                  b[f++] = m;
                                                  m.m_flags |= k.e_islandFlag
                                              }
                                          }
                                      }
                              }
                          }
                          g.Solve(a, this.m_gravity, this.m_allowSleep);
                          for (f = 0; f < g.m_bodyCount; ++f) {
                              c = g.m_bodies[f];
                              if (c.GetType() == k.b2_staticBody) c.m_flags &= ~k.e_islandFlag
                          }
                      }
          for (f = 0; f < b.length; ++f) {
              if (!b[f]) break;
              b[f] = null
          }
          for (c = this.m_bodyList; c; c =
              c.m_next) c.IsAwake() == false || c.IsActive() == false || c.GetType() != k.b2_staticBody && c.SynchronizeFixtures();
          this.m_contactManager.FindNewContacts()
      };
      h.prototype.SolveTOI = function(a) {
          var c, g, b, e = this.m_island;
          e.Initialize(this.m_bodyCount, A.b2_maxTOIContactsPerIsland, A.b2_maxTOIJointsPerIsland, null, this.m_contactManager.m_contactListener, this.m_contactSolver);
          var f = h.s_queue;
          for (c = this.m_bodyList; c; c = c.m_next) {
              c.m_flags &= ~k.e_islandFlag;
              c.m_sweep.t0 = 0
          }
          for (b = this.m_contactList; b; b = b.m_next) b.m_flags &= ~(l.e_toiFlag |
              l.e_islandFlag);
          for (b = this.m_jointList; b; b = b.m_next) b.m_islandFlag = false;
          for (;;) {
              var m = null,
                  r = 1;
              for (b = this.m_contactList; b; b = b.m_next)
                  if (!(b.IsSensor() == true || b.IsEnabled() == false || b.IsContinuous() == false)) {
                      c = 1;
                      if (b.m_flags & l.e_toiFlag) c = b.m_toi;
                      else {
                          c = b.m_fixtureA;
                          g = b.m_fixtureB;
                          c = c.m_body;
                          g = g.m_body;
                          if ((c.GetType() != k.b2_dynamicBody || c.IsAwake() == false) && (g.GetType() != k.b2_dynamicBody || g.IsAwake() == false)) continue;
                          var s = c.m_sweep.t0;
                          if (c.m_sweep.t0 < g.m_sweep.t0) {
                              s = g.m_sweep.t0;
                              c.m_sweep.Advance(s)
                          } else if (g.m_sweep.t0 <
                              c.m_sweep.t0) {
                              s = c.m_sweep.t0;
                              g.m_sweep.Advance(s)
                          }
                          c = b.ComputeTOI(c.m_sweep, g.m_sweep);
                          A.b2Assert(0 <= c && c <= 1);
                          if (c > 0 && c < 1) {
                              c = (1 - c) * s + c;
                              if (c > 1) c = 1
                          }
                          b.m_toi = c;
                          b.m_flags |= l.e_toiFlag
                      }
                      if (Number.MIN_VALUE < c && c < r) {
                          m = b;
                          r = c
                      }
                  }
              if (m == null || 1 - 100 * Number.MIN_VALUE < r) break;
              c = m.m_fixtureA;
              g = m.m_fixtureB;
              c = c.m_body;
              g = g.m_body;
              h.s_backupA.Set(c.m_sweep);
              h.s_backupB.Set(g.m_sweep);
              c.Advance(r);
              g.Advance(r);
              m.Update(this.m_contactManager.m_contactListener);
              m.m_flags &= ~l.e_toiFlag;
              if (m.IsSensor() == true || m.IsEnabled() ==
                  false) {
                  c.m_sweep.Set(h.s_backupA);
                  g.m_sweep.Set(h.s_backupB);
                  c.SynchronizeTransform();
                  g.SynchronizeTransform()
              } else if (m.IsTouching() != false) {
                  c = c;
                  if (c.GetType() != k.b2_dynamicBody) c = g;
                  e.Clear();
                  m = b = 0;
                  f[b + m++] = c;
                  for (c.m_flags |= k.e_islandFlag; m > 0;) {
                      c = f[b++];
                      --m;
                      e.AddBody(c);
                      c.IsAwake() == false && c.SetAwake(true);
                      if (c.GetType() == k.b2_dynamicBody) {
                          for (g = c.m_contactList; g; g = g.next) {
                              if (e.m_contactCount == e.m_contactCapacity) break;
                              if (!(g.contact.m_flags & l.e_islandFlag))
                                  if (!(g.contact.IsSensor() == true || g.contact.IsEnabled() ==
                                          false || g.contact.IsTouching() == false)) {
                                      e.AddContact(g.contact);
                                      g.contact.m_flags |= l.e_islandFlag;
                                      s = g.other;
                                      if (!(s.m_flags & k.e_islandFlag)) {
                                          if (s.GetType() != k.b2_staticBody) {
                                              s.Advance(r);
                                              s.SetAwake(true)
                                          }
                                          f[b + m] = s;
                                          ++m;
                                          s.m_flags |= k.e_islandFlag
                                      }
                                  }
                          }
                          for (c = c.m_jointList; c; c = c.next)
                              if (e.m_jointCount != e.m_jointCapacity)
                                  if (c.joint.m_islandFlag != true) {
                                      s = c.other;
                                      if (s.IsActive() != false) {
                                          e.AddJoint(c.joint);
                                          c.joint.m_islandFlag = true;
                                          if (!(s.m_flags & k.e_islandFlag)) {
                                              if (s.GetType() != k.b2_staticBody) {
                                                  s.Advance(r);
                                                  s.SetAwake(true)
                                              }
                                              f[b +
                                                  m] = s;
                                              ++m;
                                              s.m_flags |= k.e_islandFlag
                                          }
                                      }
                                  }
                      }
                  }
                  b = h.s_timestep;
                  b.warmStarting = false;
                  b.dt = (1 - r) * a.dt;
                  b.inv_dt = 1 / b.dt;
                  b.dtRatio = 0;
                  b.velocityIterations = a.velocityIterations;
                  b.positionIterations = a.positionIterations;
                  e.SolveTOI(b);
                  for (r = r = 0; r < e.m_bodyCount; ++r) {
                      c = e.m_bodies[r];
                      c.m_flags &= ~k.e_islandFlag;
                      if (c.IsAwake() != false)
                          if (c.GetType() == k.b2_dynamicBody) {
                              c.SynchronizeFixtures();
                              for (g = c.m_contactList; g; g = g.next) g.contact.m_flags &= ~l.e_toiFlag
                          }
                  }
                  for (r = 0; r < e.m_contactCount; ++r) {
                      b = e.m_contacts[r];
                      b.m_flags &= ~(l.e_toiFlag |
                          l.e_islandFlag)
                  }
                  for (r = 0; r < e.m_jointCount; ++r) {
                      b = e.m_joints[r];
                      b.m_islandFlag = false
                  }
                  this.m_contactManager.FindNewContacts()
              }
          }
      };
      h.prototype.DrawJoint = function(a) {
          var c = a.GetBodyA(),
              g = a.GetBodyB(),
              b = c.m_xf.position,
              e = g.m_xf.position,
              f = a.GetAnchorA(),
              m = a.GetAnchorB(),
              r = h.s_jointColor;
          switch (a.m_type) {
              case q.e_distanceJoint:
                  this.m_debugDraw.DrawSegment(f, m, r);
                  break;
              case q.e_pulleyJoint:
                  c = a instanceof n ? a : null;
                  a = c.GetGroundAnchorA();
                  c = c.GetGroundAnchorB();
                  this.m_debugDraw.DrawSegment(a, f, r);
                  this.m_debugDraw.DrawSegment(c,
                      m, r);
                  this.m_debugDraw.DrawSegment(a, c, r);
                  break;
              case q.e_mouseJoint:
                  this.m_debugDraw.DrawSegment(f, m, r);
                  break;
              default:
                  c != this.m_groundBody && this.m_debugDraw.DrawSegment(b, f, r);
                  this.m_debugDraw.DrawSegment(f, m, r);
                  g != this.m_groundBody && this.m_debugDraw.DrawSegment(e, m, r)
          }
      };
      h.prototype.DrawShape = function(a, c, g) {
          switch (a.m_type) {
              case Y.e_circleShape:
                  var b = a instanceof M ? a : null;
                  this.m_debugDraw.DrawSolidCircle(F.MulX(c, b.m_p), b.m_radius, c.R.col1, g);
                  break;
              case Y.e_polygonShape:
                  b = 0;
                  b = a instanceof W ? a : null;
                  a = parseInt(b.GetVertexCount());
                  var e = b.GetVertices(),
                      f = new Vector(a);
                  for (b = 0; b < a; ++b) f[b] = F.MulX(c, e[b]);
                  this.m_debugDraw.DrawSolidPolygon(f, a, g);
                  break;
              case Y.e_edgeShape:
                  b = a instanceof L ? a : null;
                  this.m_debugDraw.DrawSegment(F.MulX(c, b.GetVertex1()), F.MulX(c, b.GetVertex2()), g)
          }
      };
      Box2D.postDefs.push(function() {
          Box2D.Dynamics.b2World.s_timestep2 = new d;
          Box2D.Dynamics.b2World.s_xf = new K;
          Box2D.Dynamics.b2World.s_backupA = new G;
          Box2D.Dynamics.b2World.s_backupB = new G;
          Box2D.Dynamics.b2World.s_timestep = new d;
          Box2D.Dynamics.b2World.s_queue = new Vector;
          Box2D.Dynamics.b2World.s_jointColor = new w(0.5, 0.8, 0.8);
          Box2D.Dynamics.b2World.e_newFixture = 1;
          Box2D.Dynamics.b2World.e_locked = 2
      })
  })();
  (function() {
      var F = Box2D.Collision.Shapes.b2CircleShape,
          G = Box2D.Collision.Shapes.b2EdgeShape,
          K = Box2D.Collision.Shapes.b2PolygonShape,
          y = Box2D.Collision.Shapes.b2Shape,
          w = Box2D.Dynamics.Contacts.b2CircleContact,
          A = Box2D.Dynamics.Contacts.b2Contact,
          U = Box2D.Dynamics.Contacts.b2ContactConstraint,
          p = Box2D.Dynamics.Contacts.b2ContactConstraintPoint,
          B = Box2D.Dynamics.Contacts.b2ContactEdge,
          Q = Box2D.Dynamics.Contacts.b2ContactFactory,
          V = Box2D.Dynamics.Contacts.b2ContactRegister,
          M = Box2D.Dynamics.Contacts.b2ContactResult,
          L = Box2D.Dynamics.Contacts.b2ContactSolver,
          I = Box2D.Dynamics.Contacts.b2EdgeAndCircleContact,
          W = Box2D.Dynamics.Contacts.b2NullContact,
          Y = Box2D.Dynamics.Contacts.b2PolyAndCircleContact,
          k = Box2D.Dynamics.Contacts.b2PolyAndEdgeContact,
          z = Box2D.Dynamics.Contacts.b2PolygonContact,
          u = Box2D.Dynamics.Contacts.b2PositionSolverManifold,
          D = Box2D.Dynamics.b2Body,
          H = Box2D.Dynamics.b2TimeStep,
          O = Box2D.Common.b2Settings,
          E = Box2D.Common.Math.b2Mat22,
          R = Box2D.Common.Math.b2Math,
          N = Box2D.Common.Math.b2Vec2,
          S = Box2D.Collision.b2Collision,
          aa = Box2D.Collision.b2ContactID,
          Z = Box2D.Collision.b2Manifold,
          d = Box2D.Collision.b2TimeOfImpact,
          h = Box2D.Collision.b2TOIInput,
          l = Box2D.Collision.b2WorldManifold;
      Box2D.inherit(w, Box2D.Dynamics.Contacts.b2Contact);
      w.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
      w.b2CircleContact = function() {
          Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments)
      };
      w.Create = function() {
          return new w
      };
      w.Destroy = function() {};
      w.prototype.Reset = function(j, o) {
          this.__super.Reset.call(this, j, o)
      };
      w.prototype.Evaluate =
          function() {
              var j = this.m_fixtureA.GetBody(),
                  o = this.m_fixtureB.GetBody();
              S.CollideCircles(this.m_manifold, this.m_fixtureA.GetShape() instanceof F ? this.m_fixtureA.GetShape() : null, j.m_xf, this.m_fixtureB.GetShape() instanceof F ? this.m_fixtureB.GetShape() : null, o.m_xf)
          };
      A.b2Contact = function() {
          this.m_nodeA = new B;
          this.m_nodeB = new B;
          this.m_manifold = new Z;
          this.m_oldManifold = new Z
      };
      A.prototype.GetManifold = function() {
          return this.m_manifold
      };
      A.prototype.GetWorldManifold = function(j) {
          var o = this.m_fixtureA.GetBody(),
              q = this.m_fixtureB.GetBody(),
              n = this.m_fixtureA.GetShape(),
              a = this.m_fixtureB.GetShape();
          j.Initialize(this.m_manifold, o.GetTransform(), n.m_radius, q.GetTransform(), a.m_radius)
      };
      A.prototype.IsTouching = function() {
          return (this.m_flags & A.e_touchingFlag) == A.e_touchingFlag
      };
      A.prototype.IsContinuous = function() {
          return (this.m_flags & A.e_continuousFlag) == A.e_continuousFlag
      };
      A.prototype.SetSensor = function(j) {
          if (j) this.m_flags |= A.e_sensorFlag;
          else this.m_flags &= ~A.e_sensorFlag
      };
      A.prototype.IsSensor = function() {
          return (this.m_flags &
              A.e_sensorFlag) == A.e_sensorFlag
      };
      A.prototype.SetEnabled = function(j) {
          if (j) this.m_flags |= A.e_enabledFlag;
          else this.m_flags &= ~A.e_enabledFlag
      };
      A.prototype.IsEnabled = function() {
          return (this.m_flags & A.e_enabledFlag) == A.e_enabledFlag
      };
      A.prototype.GetNext = function() {
          return this.m_next
      };
      A.prototype.GetFixtureA = function() {
          return this.m_fixtureA
      };
      A.prototype.GetFixtureB = function() {
          return this.m_fixtureB
      };
      A.prototype.FlagForFiltering = function() {
          this.m_flags |= A.e_filterFlag
      };
      A.prototype.b2Contact = function() {};
      A.prototype.Reset = function(j, o) {
          if (j === undefined) j = null;
          if (o === undefined) o = null;
          this.m_flags = A.e_enabledFlag;
          if (!j || !o) this.m_fixtureB = this.m_fixtureA = null;
          else {
              if (j.IsSensor() || o.IsSensor()) this.m_flags |= A.e_sensorFlag;
              var q = j.GetBody(),
                  n = o.GetBody();
              if (q.GetType() != D.b2_dynamicBody || q.IsBullet() || n.GetType() != D.b2_dynamicBody || n.IsBullet()) this.m_flags |= A.e_continuousFlag;
              this.m_fixtureA = j;
              this.m_fixtureB = o;
              this.m_manifold.m_pointCount = 0;
              this.m_next = this.m_prev = null;
              this.m_nodeA.contact = null;
              this.m_nodeA.prev =
                  null;
              this.m_nodeA.next = null;
              this.m_nodeA.other = null;
              this.m_nodeB.contact = null;
              this.m_nodeB.prev = null;
              this.m_nodeB.next = null;
              this.m_nodeB.other = null
          }
      };
      A.prototype.Update = function(j) {
          var o = this.m_oldManifold;
          this.m_oldManifold = this.m_manifold;
          this.m_manifold = o;
          this.m_flags |= A.e_enabledFlag;
          var q = false;
          o = (this.m_flags & A.e_touchingFlag) == A.e_touchingFlag;
          var n = this.m_fixtureA.m_body,
              a = this.m_fixtureB.m_body,
              c = this.m_fixtureA.m_aabb.TestOverlap(this.m_fixtureB.m_aabb);
          if (this.m_flags & A.e_sensorFlag) {
              if (c) {
                  q =
                      this.m_fixtureA.GetShape();
                  c = this.m_fixtureB.GetShape();
                  n = n.GetTransform();
                  a = a.GetTransform();
                  q = y.TestOverlap(q, n, c, a)
              }
              this.m_manifold.m_pointCount = 0
          } else {
              if (n.GetType() != D.b2_dynamicBody || n.IsBullet() || a.GetType() != D.b2_dynamicBody || a.IsBullet()) this.m_flags |= A.e_continuousFlag;
              else this.m_flags &= ~A.e_continuousFlag;
              if (c) {
                  this.Evaluate();
                  q = this.m_manifold.m_pointCount > 0;
                  for (c = 0; c < this.m_manifold.m_pointCount; ++c) {
                      var g = this.m_manifold.m_points[c];
                      g.m_normalImpulse = 0;
                      g.m_tangentImpulse = 0;
                      for (var b =
                              g.m_id, e = 0; e < this.m_oldManifold.m_pointCount; ++e) {
                          var f = this.m_oldManifold.m_points[e];
                          if (f.m_id.key == b.key) {
                              g.m_normalImpulse = f.m_normalImpulse;
                              g.m_tangentImpulse = f.m_tangentImpulse;
                              break
                          }
                      }
                  }
              } else this.m_manifold.m_pointCount = 0;
              if (q != o) {
                  n.SetAwake(true);
                  a.SetAwake(true)
              }
          }
          if (q) this.m_flags |= A.e_touchingFlag;
          else this.m_flags &= ~A.e_touchingFlag;
          o == false && q == true && j.BeginContact(this);
          o == true && q == false && j.EndContact(this);
          (this.m_flags & A.e_sensorFlag) == 0 && j.PreSolve(this, this.m_oldManifold)
      };
      A.prototype.Evaluate =
          function() {};
      A.prototype.ComputeTOI = function(j, o) {
          A.s_input.proxyA.Set(this.m_fixtureA.GetShape());
          A.s_input.proxyB.Set(this.m_fixtureB.GetShape());
          A.s_input.sweepA = j;
          A.s_input.sweepB = o;
          A.s_input.tolerance = O.b2_linearSlop;
          return d.TimeOfImpact(A.s_input)
      };
      Box2D.postDefs.push(function() {
          Box2D.Dynamics.Contacts.b2Contact.e_sensorFlag = 1;
          Box2D.Dynamics.Contacts.b2Contact.e_continuousFlag = 2;
          Box2D.Dynamics.Contacts.b2Contact.e_islandFlag = 4;
          Box2D.Dynamics.Contacts.b2Contact.e_toiFlag = 8;
          Box2D.Dynamics.Contacts.b2Contact.e_touchingFlag =
              16;
          Box2D.Dynamics.Contacts.b2Contact.e_enabledFlag = 32;
          Box2D.Dynamics.Contacts.b2Contact.e_filterFlag = 64;
          Box2D.Dynamics.Contacts.b2Contact.s_input = new h
      });
      U.b2ContactConstraint = function() {
          this.localPlaneNormal = new N;
          this.localPoint = new N;
          this.normal = new N;
          this.normalMass = new E;
          this.K = new E
      };
      U.prototype.b2ContactConstraint = function() {
          this.points = new Vector(O.b2_maxManifoldPoints);
          for (var j = 0; j < O.b2_maxManifoldPoints; j++) this.points[j] = new p
      };
      p.b2ContactConstraintPoint = function() {
          this.localPoint = new N;
          this.rA = new N;
          this.rB = new N
      };
      B.b2ContactEdge = function() {};
      Q.b2ContactFactory = function() {};
      Q.prototype.b2ContactFactory = function(j) {
          this.m_allocator = j;
          this.InitializeRegisters()
      };
      Q.prototype.AddType = function(j, o, q, n) {
          if (q === undefined) q = 0;
          if (n === undefined) n = 0;
          this.m_registers[q][n].createFcn = j;
          this.m_registers[q][n].destroyFcn = o;
          this.m_registers[q][n].primary = true;
          if (q != n) {
              this.m_registers[n][q].createFcn = j;
              this.m_registers[n][q].destroyFcn = o;
              this.m_registers[n][q].primary = false
          }
      };
      Q.prototype.InitializeRegisters =
          function() {
              this.m_registers = new Vector(y.e_shapeTypeCount);
              for (var j = 0; j < y.e_shapeTypeCount; j++) {
                  this.m_registers[j] = new Vector(y.e_shapeTypeCount);
                  for (var o = 0; o < y.e_shapeTypeCount; o++) this.m_registers[j][o] = new V
              }
              this.AddType(w.Create, w.Destroy, y.e_circleShape, y.e_circleShape);
              this.AddType(Y.Create, Y.Destroy, y.e_polygonShape, y.e_circleShape);
              this.AddType(z.Create, z.Destroy, y.e_polygonShape, y.e_polygonShape);
              this.AddType(I.Create, I.Destroy, y.e_edgeShape, y.e_circleShape);
              this.AddType(k.Create, k.Destroy,
                  y.e_polygonShape, y.e_edgeShape)
          };
      Q.prototype.Create = function(j, o) {
          var q = parseInt(j.GetType()),
              n = parseInt(o.GetType());
          q = this.m_registers[q][n];
          if (q.pool) {
              n = q.pool;
              q.pool = n.m_next;
              q.poolCount--;
              n.Reset(j, o);
              return n
          }
          n = q.createFcn;
          if (n != null) {
              if (q.primary) {
                  n = n(this.m_allocator);
                  n.Reset(j, o)
              } else {
                  n = n(this.m_allocator);
                  n.Reset(o, j)
              }
              return n
          } else return null
      };
      Q.prototype.Destroy = function(j) {
          if (j.m_manifold.m_pointCount > 0) {
              j.m_fixtureA.m_body.SetAwake(true);
              j.m_fixtureB.m_body.SetAwake(true)
          }
          var o = parseInt(j.m_fixtureA.GetType()),
              q = parseInt(j.m_fixtureB.GetType());
          o = this.m_registers[o][q];
          o.poolCount++;
          j.m_next = o.pool;
          o.pool = j;
          o = o.destroyFcn;
          o(j, this.m_allocator)
      };
      V.b2ContactRegister = function() {};
      M.b2ContactResult = function() {
          this.position = new N;
          this.normal = new N;
          this.id = new aa
      };
      L.b2ContactSolver = function() {
          this.m_step = new H;
          this.m_constraints = new Vector
      };
      L.prototype.b2ContactSolver = function() {};
      L.prototype.Initialize = function(j, o, q, n) {
          if (q === undefined) q = 0;
          var a;
          this.m_step.Set(j);
          this.m_allocator = n;
          j = 0;
          for (this.m_constraintCount =
              q; this.m_constraints.length < this.m_constraintCount;) this.m_constraints[this.m_constraints.length] = new U;
          for (j = 0; j < q; ++j) {
              a = o[j];
              n = a.m_fixtureA;
              var c = a.m_fixtureB,
                  g = n.m_shape.m_radius,
                  b = c.m_shape.m_radius,
                  e = n.m_body,
                  f = c.m_body,
                  m = a.GetManifold(),
                  r = O.b2MixFriction(n.GetFriction(), c.GetFriction()),
                  s = O.b2MixRestitution(n.GetRestitution(), c.GetRestitution()),
                  v = e.m_linearVelocity.x,
                  t = e.m_linearVelocity.y,
                  x = f.m_linearVelocity.x,
                  C = f.m_linearVelocity.y,
                  J = e.m_angularVelocity,
                  T = f.m_angularVelocity;
              O.b2Assert(m.m_pointCount >
                  0);
              L.s_worldManifold.Initialize(m, e.m_xf, g, f.m_xf, b);
              c = L.s_worldManifold.m_normal.x;
              a = L.s_worldManifold.m_normal.y;
              n = this.m_constraints[j];
              n.bodyA = e;
              n.bodyB = f;
              n.manifold = m;
              n.normal.x = c;
              n.normal.y = a;
              n.pointCount = m.m_pointCount;
              n.friction = r;
              n.restitution = s;
              n.localPlaneNormal.x = m.m_localPlaneNormal.x;
              n.localPlaneNormal.y = m.m_localPlaneNormal.y;
              n.localPoint.x = m.m_localPoint.x;
              n.localPoint.y = m.m_localPoint.y;
              n.radius = g + b;
              n.type = m.m_type;
              for (g = 0; g < n.pointCount; ++g) {
                  r = m.m_points[g];
                  b = n.points[g];
                  b.normalImpulse =
                      r.m_normalImpulse;
                  b.tangentImpulse = r.m_tangentImpulse;
                  b.localPoint.SetV(r.m_localPoint);
                  r = b.rA.x = L.s_worldManifold.m_points[g].x - e.m_sweep.c.x;
                  s = b.rA.y = L.s_worldManifold.m_points[g].y - e.m_sweep.c.y;
                  var P = b.rB.x = L.s_worldManifold.m_points[g].x - f.m_sweep.c.x,
                      X = b.rB.y = L.s_worldManifold.m_points[g].y - f.m_sweep.c.y,
                      $ = r * a - s * c,
                      ba = P * a - X * c;
                  $ *= $;
                  ba *= ba;
                  b.normalMass = 1 / (e.m_invMass + f.m_invMass + e.m_invI * $ + f.m_invI * ba);
                  var ca = e.m_mass * e.m_invMass + f.m_mass * f.m_invMass;
                  ca += e.m_mass * e.m_invI * $ + f.m_mass * f.m_invI * ba;
                  b.equalizedMass = 1 / ca;
                  ba = a;
                  ca = -c;
                  $ = r * ca - s * ba;
                  ba = P * ca - X * ba;
                  $ *= $;
                  ba *= ba;
                  b.tangentMass = 1 / (e.m_invMass + f.m_invMass + e.m_invI * $ + f.m_invI * ba);
                  b.velocityBias = 0;
                  r = n.normal.x * (x + -T * X - v - -J * s) + n.normal.y * (C + T * P - t - J * r);
                  if (r < -O.b2_velocityThreshold) b.velocityBias += -n.restitution * r
              }
              if (n.pointCount == 2) {
                  C = n.points[0];
                  x = n.points[1];
                  m = e.m_invMass;
                  e = e.m_invI;
                  v = f.m_invMass;
                  f = f.m_invI;
                  t = C.rA.x * a - C.rA.y * c;
                  C = C.rB.x * a - C.rB.y * c;
                  J = x.rA.x * a - x.rA.y * c;
                  x = x.rB.x * a - x.rB.y * c;
                  c = m + v + e * t * t + f * C * C;
                  a = m + v + e * J * J + f * x * x;
                  f = m + v + e * t * J + f * C * x;
                  if (c *
                      c < 100 * (c * a - f * f)) {
                      n.K.col1.Set(c, f);
                      n.K.col2.Set(f, a);
                      n.K.GetInverse(n.normalMass)
                  } else n.pointCount = 1
              }
          }
      };
      L.prototype.InitVelocityConstraints = function(j) {
          for (var o = 0; o < this.m_constraintCount; ++o) {
              var q = this.m_constraints[o],
                  n = q.bodyA,
                  a = q.bodyB,
                  c = n.m_invMass,
                  g = n.m_invI,
                  b = a.m_invMass,
                  e = a.m_invI,
                  f = q.normal.x,
                  m = q.normal.y,
                  r = m,
                  s = -f,
                  v = 0,
                  t = 0;
              if (j.warmStarting) {
                  t = q.pointCount;
                  for (v = 0; v < t; ++v) {
                      var x = q.points[v];
                      x.normalImpulse *= j.dtRatio;
                      x.tangentImpulse *= j.dtRatio;
                      var C = x.normalImpulse * f + x.tangentImpulse *
                          r,
                          J = x.normalImpulse * m + x.tangentImpulse * s;
                      n.m_angularVelocity -= g * (x.rA.x * J - x.rA.y * C);
                      n.m_linearVelocity.x -= c * C;
                      n.m_linearVelocity.y -= c * J;
                      a.m_angularVelocity += e * (x.rB.x * J - x.rB.y * C);
                      a.m_linearVelocity.x += b * C;
                      a.m_linearVelocity.y += b * J
                  }
              } else {
                  t = q.pointCount;
                  for (v = 0; v < t; ++v) {
                      n = q.points[v];
                      n.normalImpulse = 0;
                      n.tangentImpulse = 0
                  }
              }
          }
      };
      L.prototype.SolveVelocityConstraints = function() {
          for (var j = 0, o, q = 0, n = 0, a = 0, c = n = n = q = q = 0, g = q = q = 0, b = q = a = 0, e = 0, f, m = 0; m < this.m_constraintCount; ++m) {
              a = this.m_constraints[m];
              var r = a.bodyA,
                  s = a.bodyB,
                  v = r.m_angularVelocity,
                  t = s.m_angularVelocity,
                  x = r.m_linearVelocity,
                  C = s.m_linearVelocity,
                  J = r.m_invMass,
                  T = r.m_invI,
                  P = s.m_invMass,
                  X = s.m_invI;
              b = a.normal.x;
              var $ = e = a.normal.y;
              f = -b;
              g = a.friction;
              for (j = 0; j < a.pointCount; j++) {
                  o = a.points[j];
                  q = C.x - t * o.rB.y - x.x + v * o.rA.y;
                  n = C.y + t * o.rB.x - x.y - v * o.rA.x;
                  q = q * $ + n * f;
                  q = o.tangentMass * -q;
                  n = g * o.normalImpulse;
                  n = R.Clamp(o.tangentImpulse + q, -n, n);
                  q = n - o.tangentImpulse;
                  c = q * $;
                  q = q * f;
                  x.x -= J * c;
                  x.y -= J * q;
                  v -= T * (o.rA.x * q - o.rA.y * c);
                  C.x += P * c;
                  C.y += P * q;
                  t += X * (o.rB.x * q - o.rB.y * c);
                  o.tangentImpulse =
                      n
              }
              parseInt(a.pointCount);
              if (a.pointCount == 1) {
                  o = a.points[0];
                  q = C.x + -t * o.rB.y - x.x - -v * o.rA.y;
                  n = C.y + t * o.rB.x - x.y - v * o.rA.x;
                  a = q * b + n * e;
                  q = -o.normalMass * (a - o.velocityBias);
                  n = o.normalImpulse + q;
                  n = n > 0 ? n : 0;
                  q = n - o.normalImpulse;
                  c = q * b;
                  q = q * e;
                  x.x -= J * c;
                  x.y -= J * q;
                  v -= T * (o.rA.x * q - o.rA.y * c);
                  C.x += P * c;
                  C.y += P * q;
                  t += X * (o.rB.x * q - o.rB.y * c);
                  o.normalImpulse = n
              } else {
                  o = a.points[0];
                  j = a.points[1];
                  q = o.normalImpulse;
                  g = j.normalImpulse;
                  var ba = (C.x - t * o.rB.y - x.x + v * o.rA.y) * b + (C.y + t * o.rB.x - x.y - v * o.rA.x) * e,
                      ca = (C.x - t * j.rB.y - x.x + v * j.rA.y) * b + (C.y +
                          t * j.rB.x - x.y - v * j.rA.x) * e;
                  n = ba - o.velocityBias;
                  c = ca - j.velocityBias;
                  f = a.K;
                  n -= f.col1.x * q + f.col2.x * g;
                  for (c -= f.col1.y * q + f.col2.y * g;;) {
                      f = a.normalMass;
                      $ = -(f.col1.x * n + f.col2.x * c);
                      f = -(f.col1.y * n + f.col2.y * c);
                      if ($ >= 0 && f >= 0) {
                          q = $ - q;
                          g = f - g;
                          a = q * b;
                          q = q * e;
                          b = g * b;
                          e = g * e;
                          x.x -= J * (a + b);
                          x.y -= J * (q + e);
                          v -= T * (o.rA.x * q - o.rA.y * a + j.rA.x * e - j.rA.y * b);
                          C.x += P * (a + b);
                          C.y += P * (q + e);
                          t += X * (o.rB.x * q - o.rB.y * a + j.rB.x * e - j.rB.y * b);
                          o.normalImpulse = $;
                          j.normalImpulse = f;
                          break
                      }
                      $ = -o.normalMass * n;
                      f = 0;
                      ca = a.K.col1.y * $ + c;
                      if ($ >= 0 && ca >= 0) {
                          q = $ - q;
                          g = f - g;
                          a = q * b;
                          q = q * e;
                          b = g * b;
                          e = g * e;
                          x.x -= J * (a + b);
                          x.y -= J * (q + e);
                          v -= T * (o.rA.x * q - o.rA.y * a + j.rA.x * e - j.rA.y * b);
                          C.x += P * (a + b);
                          C.y += P * (q + e);
                          t += X * (o.rB.x * q - o.rB.y * a + j.rB.x * e - j.rB.y * b);
                          o.normalImpulse = $;
                          j.normalImpulse = f;
                          break
                      }
                      $ = 0;
                      f = -j.normalMass * c;
                      ba = a.K.col2.x * f + n;
                      if (f >= 0 && ba >= 0) {
                          q = $ - q;
                          g = f - g;
                          a = q * b;
                          q = q * e;
                          b = g * b;
                          e = g * e;
                          x.x -= J * (a + b);
                          x.y -= J * (q + e);
                          v -= T * (o.rA.x * q - o.rA.y * a + j.rA.x * e - j.rA.y * b);
                          C.x += P * (a + b);
                          C.y += P * (q + e);
                          t += X * (o.rB.x * q - o.rB.y * a + j.rB.x * e - j.rB.y * b);
                          o.normalImpulse = $;
                          j.normalImpulse = f;
                          break
                      }
                      f = $ = 0;
                      ba = n;
                      ca = c;
                      if (ba >= 0 && ca >= 0) {
                          q =
                              $ - q;
                          g = f - g;
                          a = q * b;
                          q = q * e;
                          b = g * b;
                          e = g * e;
                          x.x -= J * (a + b);
                          x.y -= J * (q + e);
                          v -= T * (o.rA.x * q - o.rA.y * a + j.rA.x * e - j.rA.y * b);
                          C.x += P * (a + b);
                          C.y += P * (q + e);
                          t += X * (o.rB.x * q - o.rB.y * a + j.rB.x * e - j.rB.y * b);
                          o.normalImpulse = $;
                          j.normalImpulse = f;
                          break
                      }
                      break
                  }
              }
              r.m_angularVelocity = v;
              s.m_angularVelocity = t
          }
      };
      L.prototype.FinalizeVelocityConstraints = function() {
          for (var j = 0; j < this.m_constraintCount; ++j)
              for (var o = this.m_constraints[j], q = o.manifold, n = 0; n < o.pointCount; ++n) {
                  var a = q.m_points[n],
                      c = o.points[n];
                  a.m_normalImpulse = c.normalImpulse;
                  a.m_tangentImpulse =
                      c.tangentImpulse
              }
      };
      L.prototype.SolvePositionConstraints = function(j) {
          if (j === undefined) j = 0;
          for (var o = 0, q = 0; q < this.m_constraintCount; q++) {
              var n = this.m_constraints[q],
                  a = n.bodyA,
                  c = n.bodyB,
                  g = a.m_mass * a.m_invMass,
                  b = a.m_mass * a.m_invI,
                  e = c.m_mass * c.m_invMass,
                  f = c.m_mass * c.m_invI;
              L.s_psm.Initialize(n);
              for (var m = L.s_psm.m_normal, r = 0; r < n.pointCount; r++) {
                  var s = n.points[r],
                      v = L.s_psm.m_points[r],
                      t = L.s_psm.m_separations[r],
                      x = v.x - a.m_sweep.c.x,
                      C = v.y - a.m_sweep.c.y,
                      J = v.x - c.m_sweep.c.x;
                  v = v.y - c.m_sweep.c.y;
                  o = o < t ? o : t;
                  t =
                      R.Clamp(j * (t + O.b2_linearSlop), -O.b2_maxLinearCorrection, 0);
                  t = -s.equalizedMass * t;
                  s = t * m.x;
                  t = t * m.y;
                  a.m_sweep.c.x -= g * s;
                  a.m_sweep.c.y -= g * t;
                  a.m_sweep.a -= b * (x * t - C * s);
                  a.SynchronizeTransform();
                  c.m_sweep.c.x += e * s;
                  c.m_sweep.c.y += e * t;
                  c.m_sweep.a += f * (J * t - v * s);
                  c.SynchronizeTransform()
              }
          }
          return o > -1.5 * O.b2_linearSlop
      };
      Box2D.postDefs.push(function() {
          Box2D.Dynamics.Contacts.b2ContactSolver.s_worldManifold = new l;
          Box2D.Dynamics.Contacts.b2ContactSolver.s_psm = new u
      });
      Box2D.inherit(I, Box2D.Dynamics.Contacts.b2Contact);
      I.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
      I.b2EdgeAndCircleContact = function() {
          Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments)
      };
      I.Create = function() {
          return new I
      };
      I.Destroy = function() {};
      I.prototype.Reset = function(j, o) {
          this.__super.Reset.call(this, j, o)
      };
      I.prototype.Evaluate = function() {
          var j = this.m_fixtureA.GetBody(),
              o = this.m_fixtureB.GetBody();
          this.b2CollideEdgeAndCircle(this.m_manifold, this.m_fixtureA.GetShape() instanceof G ? this.m_fixtureA.GetShape() : null, j.m_xf,
              this.m_fixtureB.GetShape() instanceof F ? this.m_fixtureB.GetShape() : null, o.m_xf)
      };
      I.prototype.b2CollideEdgeAndCircle = function() {};
      Box2D.inherit(W, Box2D.Dynamics.Contacts.b2Contact);
      W.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
      W.b2NullContact = function() {
          Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments)
      };
      W.prototype.b2NullContact = function() {
          this.__super.b2Contact.call(this)
      };
      W.prototype.Evaluate = function() {};
      Box2D.inherit(Y, Box2D.Dynamics.Contacts.b2Contact);
      Y.prototype.__super =
          Box2D.Dynamics.Contacts.b2Contact.prototype;
      Y.b2PolyAndCircleContact = function() {
          Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments)
      };
      Y.Create = function() {
          return new Y
      };
      Y.Destroy = function() {};
      Y.prototype.Reset = function(j, o) {
          this.__super.Reset.call(this, j, o);
          O.b2Assert(j.GetType() == y.e_polygonShape);
          O.b2Assert(o.GetType() == y.e_circleShape)
      };
      Y.prototype.Evaluate = function() {
          var j = this.m_fixtureA.m_body,
              o = this.m_fixtureB.m_body;
          S.CollidePolygonAndCircle(this.m_manifold, this.m_fixtureA.GetShape() instanceof K ? this.m_fixtureA.GetShape() : null, j.m_xf, this.m_fixtureB.GetShape() instanceof F ? this.m_fixtureB.GetShape() : null, o.m_xf)
      };
      Box2D.inherit(k, Box2D.Dynamics.Contacts.b2Contact);
      k.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
      k.b2PolyAndEdgeContact = function() {
          Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments)
      };
      k.Create = function() {
          return new k
      };
      k.Destroy = function() {};
      k.prototype.Reset = function(j, o) {
          this.__super.Reset.call(this, j, o);
          O.b2Assert(j.GetType() == y.e_polygonShape);
          O.b2Assert(o.GetType() == y.e_edgeShape)
      };
      k.prototype.Evaluate = function() {
          var j = this.m_fixtureA.GetBody(),
              o = this.m_fixtureB.GetBody();
          this.b2CollidePolyAndEdge(this.m_manifold, this.m_fixtureA.GetShape() instanceof K ? this.m_fixtureA.GetShape() : null, j.m_xf, this.m_fixtureB.GetShape() instanceof G ? this.m_fixtureB.GetShape() : null, o.m_xf)
      };
      k.prototype.b2CollidePolyAndEdge = function() {};
      Box2D.inherit(z, Box2D.Dynamics.Contacts.b2Contact);
      z.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
      z.b2PolygonContact =
          function() {
              Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments)
          };
      z.Create = function() {
          return new z
      };
      z.Destroy = function() {};
      z.prototype.Reset = function(j, o) {
          this.__super.Reset.call(this, j, o)
      };
      z.prototype.Evaluate = function() {
          var j = this.m_fixtureA.GetBody(),
              o = this.m_fixtureB.GetBody();
          S.CollidePolygons(this.m_manifold, this.m_fixtureA.GetShape() instanceof K ? this.m_fixtureA.GetShape() : null, j.m_xf, this.m_fixtureB.GetShape() instanceof K ? this.m_fixtureB.GetShape() : null, o.m_xf)
      };
      u.b2PositionSolverManifold =
          function() {};
      u.prototype.b2PositionSolverManifold = function() {
          this.m_normal = new N;
          this.m_separations = new Vector_a2j_Number(O.b2_maxManifoldPoints);
          this.m_points = new Vector(O.b2_maxManifoldPoints);
          for (var j = 0; j < O.b2_maxManifoldPoints; j++) this.m_points[j] = new N
      };
      u.prototype.Initialize = function(j) {
          O.b2Assert(j.pointCount > 0);
          var o = 0,
              q = 0,
              n = 0,
              a, c = 0,
              g = 0;
          switch (j.type) {
              case Z.e_circles:
                  a = j.bodyA.m_xf.R;
                  n = j.localPoint;
                  o = j.bodyA.m_xf.position.x + (a.col1.x * n.x + a.col2.x * n.y);
                  q = j.bodyA.m_xf.position.y + (a.col1.y *
                      n.x + a.col2.y * n.y);
                  a = j.bodyB.m_xf.R;
                  n = j.points[0].localPoint;
                  c = j.bodyB.m_xf.position.x + (a.col1.x * n.x + a.col2.x * n.y);
                  a = j.bodyB.m_xf.position.y + (a.col1.y * n.x + a.col2.y * n.y);
                  n = c - o;
                  g = a - q;
                  var b = n * n + g * g;
                  if (b > Number.MIN_VALUE * Number.MIN_VALUE) {
                      b = Math.sqrt(b);
                      this.m_normal.x = n / b;
                      this.m_normal.y = g / b
                  } else {
                      this.m_normal.x = 1;
                      this.m_normal.y = 0
                  }
                  this.m_points[0].x = 0.5 * (o + c);
                  this.m_points[0].y = 0.5 * (q + a);
                  this.m_separations[0] = n * this.m_normal.x + g * this.m_normal.y - j.radius;
                  break;
              case Z.e_faceA:
                  a = j.bodyA.m_xf.R;
                  n = j.localPlaneNormal;
                  this.m_normal.x = a.col1.x * n.x + a.col2.x * n.y;
                  this.m_normal.y = a.col1.y * n.x + a.col2.y * n.y;
                  a = j.bodyA.m_xf.R;
                  n = j.localPoint;
                  c = j.bodyA.m_xf.position.x + (a.col1.x * n.x + a.col2.x * n.y);
                  g = j.bodyA.m_xf.position.y + (a.col1.y * n.x + a.col2.y * n.y);
                  a = j.bodyB.m_xf.R;
                  for (o = 0; o < j.pointCount; ++o) {
                      n = j.points[o].localPoint;
                      q = j.bodyB.m_xf.position.x + (a.col1.x * n.x + a.col2.x * n.y);
                      n = j.bodyB.m_xf.position.y + (a.col1.y * n.x + a.col2.y * n.y);
                      this.m_separations[o] = (q - c) * this.m_normal.x + (n - g) * this.m_normal.y - j.radius;
                      this.m_points[o].x = q;
                      this.m_points[o].y =
                          n
                  }
                  break;
              case Z.e_faceB:
                  a = j.bodyB.m_xf.R;
                  n = j.localPlaneNormal;
                  this.m_normal.x = a.col1.x * n.x + a.col2.x * n.y;
                  this.m_normal.y = a.col1.y * n.x + a.col2.y * n.y;
                  a = j.bodyB.m_xf.R;
                  n = j.localPoint;
                  c = j.bodyB.m_xf.position.x + (a.col1.x * n.x + a.col2.x * n.y);
                  g = j.bodyB.m_xf.position.y + (a.col1.y * n.x + a.col2.y * n.y);
                  a = j.bodyA.m_xf.R;
                  for (o = 0; o < j.pointCount; ++o) {
                      n = j.points[o].localPoint;
                      q = j.bodyA.m_xf.position.x + (a.col1.x * n.x + a.col2.x * n.y);
                      n = j.bodyA.m_xf.position.y + (a.col1.y * n.x + a.col2.y * n.y);
                      this.m_separations[o] = (q - c) * this.m_normal.x +
                          (n - g) * this.m_normal.y - j.radius;
                      this.m_points[o].Set(q, n)
                  }
                  this.m_normal.x *= -1;
                  this.m_normal.y *= -1
          }
      };
      Box2D.postDefs.push(function() {
          Box2D.Dynamics.Contacts.b2PositionSolverManifold.circlePointA = new N;
          Box2D.Dynamics.Contacts.b2PositionSolverManifold.circlePointB = new N
      })
  })();
  (function() {
      var F = Box2D.Common.Math.b2Mat22,
          G = Box2D.Common.Math.b2Math,
          K = Box2D.Common.Math.b2Vec2,
          y = Box2D.Common.b2Color,
          w = Box2D.Dynamics.Controllers.b2BuoyancyController,
          A = Box2D.Dynamics.Controllers.b2ConstantAccelController,
          U = Box2D.Dynamics.Controllers.b2ConstantForceController,
          p = Box2D.Dynamics.Controllers.b2Controller,
          B = Box2D.Dynamics.Controllers.b2ControllerEdge,
          Q = Box2D.Dynamics.Controllers.b2GravityController,
          V = Box2D.Dynamics.Controllers.b2TensorDampingController;
      Box2D.inherit(w, Box2D.Dynamics.Controllers.b2Controller);
      w.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
      w.b2BuoyancyController = function() {
          Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
          this.normal = new K(0, -1);
          this.density = this.offset = 0;
          this.velocity = new K(0, 0);
          this.linearDrag = 2;
          this.angularDrag = 1;
          this.useDensity = false;
          this.useWorldGravity = true;
          this.gravity = null
      };
      w.prototype.Step = function() {
          if (this.m_bodyList) {
              if (this.useWorldGravity) this.gravity = this.GetWorld().GetGravity().Copy();
              for (var M = this.m_bodyList; M; M =
                  M.nextBody) {
                  var L = M.body;
                  if (L.IsAwake() != false) {
                      for (var I = new K, W = new K, Y = 0, k = 0, z = L.GetFixtureList(); z; z = z.GetNext()) {
                          var u = new K,
                              D = z.GetShape().ComputeSubmergedArea(this.normal, this.offset, L.GetTransform(), u);
                          Y += D;
                          I.x += D * u.x;
                          I.y += D * u.y;
                          var H = 0;
                          H = 1;
                          k += D * H;
                          W.x += D * u.x * H;
                          W.y += D * u.y * H
                      }
                      I.x /= Y;
                      I.y /= Y;
                      W.x /= k;
                      W.y /= k;
                      if (!(Y < Number.MIN_VALUE)) {
                          k = this.gravity.GetNegative();
                          k.Multiply(this.density * Y);
                          L.ApplyForce(k, W);
                          W = L.GetLinearVelocityFromWorldPoint(I);
                          W.Subtract(this.velocity);
                          W.Multiply(-this.linearDrag *
                              Y);
                          L.ApplyForce(W, I);
                          L.ApplyTorque(-L.GetInertia() / L.GetMass() * Y * L.GetAngularVelocity() * this.angularDrag)
                      }
                  }
              }
          }
      };
      w.prototype.Draw = function(M) {
          var L = new K,
              I = new K;
          L.x = this.normal.x * this.offset + this.normal.y * 1E3;
          L.y = this.normal.y * this.offset - this.normal.x * 1E3;
          I.x = this.normal.x * this.offset - this.normal.y * 1E3;
          I.y = this.normal.y * this.offset + this.normal.x * 1E3;
          var W = new y(0, 0, 1);
          M.DrawSegment(L, I, W)
      };
      Box2D.inherit(A, Box2D.Dynamics.Controllers.b2Controller);
      A.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
      A.b2ConstantAccelController = function() {
          Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
          this.A = new K(0, 0)
      };
      A.prototype.Step = function(M) {
          M = new K(this.A.x * M.dt, this.A.y * M.dt);
          for (var L = this.m_bodyList; L; L = L.nextBody) {
              var I = L.body;
              I.IsAwake() && I.SetLinearVelocity(new K(I.GetLinearVelocity().x + M.x, I.GetLinearVelocity().y + M.y))
          }
      };
      Box2D.inherit(U, Box2D.Dynamics.Controllers.b2Controller);
      U.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
      U.b2ConstantForceController =
          function() {
              Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
              this.F = new K(0, 0)
          };
      U.prototype.Step = function() {
          for (var M = this.m_bodyList; M; M = M.nextBody) {
              var L = M.body;
              L.IsAwake() && L.ApplyForce(this.F, L.GetWorldCenter())
          }
      };
      p.b2Controller = function() {};
      p.prototype.Step = function() {};
      p.prototype.Draw = function() {};
      p.prototype.AddBody = function(M) {
          var L = new B;
          L.controller = this;
          L.body = M;
          L.nextBody = this.m_bodyList;
          L.prevBody = null;
          this.m_bodyList = L;
          if (L.nextBody) L.nextBody.prevBody = L;
          this.m_bodyCount++;
          L.nextController = M.m_controllerList;
          L.prevController = null;
          M.m_controllerList = L;
          if (L.nextController) L.nextController.prevController = L;
          M.m_controllerCount++
      };
      p.prototype.RemoveBody = function(M) {
          for (var L = M.m_controllerList; L && L.controller != this;) L = L.nextController;
          if (L.prevBody) L.prevBody.nextBody = L.nextBody;
          if (L.nextBody) L.nextBody.prevBody = L.prevBody;
          if (L.nextController) L.nextController.prevController = L.prevController;
          if (L.prevController) L.prevController.nextController = L.nextController;
          if (this.m_bodyList ==
              L) this.m_bodyList = L.nextBody;
          if (M.m_controllerList == L) M.m_controllerList = L.nextController;
          M.m_controllerCount--;
          this.m_bodyCount--
      };
      p.prototype.Clear = function() {
          for (; this.m_bodyList;) this.RemoveBody(this.m_bodyList.body)
      };
      p.prototype.GetNext = function() {
          return this.m_next
      };
      p.prototype.GetWorld = function() {
          return this.m_world
      };
      p.prototype.GetBodyList = function() {
          return this.m_bodyList
      };
      B.b2ControllerEdge = function() {};
      Box2D.inherit(Q, Box2D.Dynamics.Controllers.b2Controller);
      Q.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
      Q.b2GravityController = function() {
          Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
          this.G = 1;
          this.invSqr = true
      };
      Q.prototype.Step = function() {
          var M = null,
              L = null,
              I = null,
              W = 0,
              Y = null,
              k = null,
              z = null,
              u = 0,
              D = 0,
              H = 0;
          u = null;
          if (this.invSqr)
              for (M = this.m_bodyList; M; M = M.nextBody) {
                  L = M.body;
                  I = L.GetWorldCenter();
                  W = L.GetMass();
                  for (Y = this.m_bodyList; Y != M; Y = Y.nextBody) {
                      k = Y.body;
                      z = k.GetWorldCenter();
                      u = z.x - I.x;
                      D = z.y - I.y;
                      H = u * u + D * D;
                      if (!(H < Number.MIN_VALUE)) {
                          u = new K(u, D);
                          u.Multiply(this.G / H / Math.sqrt(H) *
                              W * k.GetMass());
                          L.IsAwake() && L.ApplyForce(u, I);
                          u.Multiply(-1);
                          k.IsAwake() && k.ApplyForce(u, z)
                      }
                  }
              } else
                  for (M = this.m_bodyList; M; M = M.nextBody) {
                      L = M.body;
                      I = L.GetWorldCenter();
                      W = L.GetMass();
                      for (Y = this.m_bodyList; Y != M; Y = Y.nextBody) {
                          k = Y.body;
                          z = k.GetWorldCenter();
                          u = z.x - I.x;
                          D = z.y - I.y;
                          H = u * u + D * D;
                          if (!(H < Number.MIN_VALUE)) {
                              u = new K(u, D);
                              u.Multiply(this.G / H * W * k.GetMass());
                              L.IsAwake() && L.ApplyForce(u, I);
                              u.Multiply(-1);
                              k.IsAwake() && k.ApplyForce(u, z)
                          }
                      }
                  }
      };
      Box2D.inherit(V, Box2D.Dynamics.Controllers.b2Controller);
      V.prototype.__super =
          Box2D.Dynamics.Controllers.b2Controller.prototype;
      V.b2TensorDampingController = function() {
          Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
          this.T = new F;
          this.maxTimestep = 0
      };
      V.prototype.SetAxisAligned = function(M, L) {
          if (M === undefined) M = 0;
          if (L === undefined) L = 0;
          this.T.col1.x = -M;
          this.T.col1.y = 0;
          this.T.col2.x = 0;
          this.T.col2.y = -L;
          this.maxTimestep = M > 0 || L > 0 ? 1 / Math.max(M, L) : 0
      };
      V.prototype.Step = function(M) {
          M = M.dt;
          if (!(M <= Number.MIN_VALUE)) {
              if (M > this.maxTimestep && this.maxTimestep > 0) M = this.maxTimestep;
              for (var L = this.m_bodyList; L; L = L.nextBody) {
                  var I = L.body;
                  if (I.IsAwake()) {
                      var W = I.GetWorldVector(G.MulMV(this.T, I.GetLocalVector(I.GetLinearVelocity())));
                      I.SetLinearVelocity(new K(I.GetLinearVelocity().x + W.x * M, I.GetLinearVelocity().y + W.y * M))
                  }
              }
          }
      }
  })();
  (function() {
      var F = Box2D.Common.b2Settings,
          G = Box2D.Common.Math.b2Mat22,
          K = Box2D.Common.Math.b2Mat33,
          y = Box2D.Common.Math.b2Math,
          w = Box2D.Common.Math.b2Vec2,
          A = Box2D.Common.Math.b2Vec3,
          U = Box2D.Dynamics.Joints.b2DistanceJoint,
          p = Box2D.Dynamics.Joints.b2DistanceJointDef,
          B = Box2D.Dynamics.Joints.b2FrictionJoint,
          Q = Box2D.Dynamics.Joints.b2FrictionJointDef,
          V = Box2D.Dynamics.Joints.b2GearJoint,
          M = Box2D.Dynamics.Joints.b2GearJointDef,
          L = Box2D.Dynamics.Joints.b2Jacobian,
          I = Box2D.Dynamics.Joints.b2Joint,
          W = Box2D.Dynamics.Joints.b2JointDef,
          Y = Box2D.Dynamics.Joints.b2JointEdge,
          k = Box2D.Dynamics.Joints.b2LineJoint,
          z = Box2D.Dynamics.Joints.b2LineJointDef,
          u = Box2D.Dynamics.Joints.b2MouseJoint,
          D = Box2D.Dynamics.Joints.b2MouseJointDef,
          H = Box2D.Dynamics.Joints.b2PrismaticJoint,
          O = Box2D.Dynamics.Joints.b2PrismaticJointDef,
          E = Box2D.Dynamics.Joints.b2PulleyJoint,
          R = Box2D.Dynamics.Joints.b2PulleyJointDef,
          N = Box2D.Dynamics.Joints.b2RevoluteJoint,
          S = Box2D.Dynamics.Joints.b2RevoluteJointDef,
          aa = Box2D.Dynamics.Joints.b2WeldJoint,
          Z = Box2D.Dynamics.Joints.b2WeldJointDef;
      Box2D.inherit(U, Box2D.Dynamics.Joints.b2Joint);
      U.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
      U.b2DistanceJoint = function() {
          Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
          this.m_localAnchor1 = new w;
          this.m_localAnchor2 = new w;
          this.m_u = new w
      };
      U.prototype.GetAnchorA = function() {
          return this.m_bodyA.GetWorldPoint(this.m_localAnchor1)
      };
      U.prototype.GetAnchorB = function() {
          return this.m_bodyB.GetWorldPoint(this.m_localAnchor2)
      };
      U.prototype.GetReactionForce = function(d) {
          if (d === undefined) d =
              0;
          return new w(d * this.m_impulse * this.m_u.x, d * this.m_impulse * this.m_u.y)
      };
      U.prototype.GetReactionTorque = function() {
          return 0
      };
      U.prototype.GetLength = function() {
          return this.m_length
      };
      U.prototype.SetLength = function(d) {
          if (d === undefined) d = 0;
          this.m_length = d
      };
      U.prototype.GetFrequency = function() {
          return this.m_frequencyHz
      };
      U.prototype.SetFrequency = function(d) {
          if (d === undefined) d = 0;
          this.m_frequencyHz = d
      };
      U.prototype.GetDampingRatio = function() {
          return this.m_dampingRatio
      };
      U.prototype.SetDampingRatio = function(d) {
          if (d ===
              undefined) d = 0;
          this.m_dampingRatio = d
      };
      U.prototype.b2DistanceJoint = function(d) {
          this.__super.b2Joint.call(this, d);
          this.m_localAnchor1.SetV(d.localAnchorA);
          this.m_localAnchor2.SetV(d.localAnchorB);
          this.m_length = d.length;
          this.m_frequencyHz = d.frequencyHz;
          this.m_dampingRatio = d.dampingRatio;
          this.m_bias = this.m_gamma = this.m_impulse = 0
      };
      U.prototype.InitVelocityConstraints = function(d) {
          var h, l = 0,
              j = this.m_bodyA,
              o = this.m_bodyB;
          h = j.m_xf.R;
          var q = this.m_localAnchor1.x - j.m_sweep.localCenter.x,
              n = this.m_localAnchor1.y -
              j.m_sweep.localCenter.y;
          l = h.col1.x * q + h.col2.x * n;
          n = h.col1.y * q + h.col2.y * n;
          q = l;
          h = o.m_xf.R;
          var a = this.m_localAnchor2.x - o.m_sweep.localCenter.x,
              c = this.m_localAnchor2.y - o.m_sweep.localCenter.y;
          l = h.col1.x * a + h.col2.x * c;
          c = h.col1.y * a + h.col2.y * c;
          a = l;
          this.m_u.x = o.m_sweep.c.x + a - j.m_sweep.c.x - q;
          this.m_u.y = o.m_sweep.c.y + c - j.m_sweep.c.y - n;
          l = Math.sqrt(this.m_u.x * this.m_u.x + this.m_u.y * this.m_u.y);
          l > F.b2_linearSlop ? this.m_u.Multiply(1 / l) : this.m_u.SetZero();
          h = q * this.m_u.y - n * this.m_u.x;
          var g = a * this.m_u.y - c * this.m_u.x;
          h = j.m_invMass + j.m_invI * h * h + o.m_invMass + o.m_invI * g * g;
          this.m_mass = h != 0 ? 1 / h : 0;
          if (this.m_frequencyHz > 0) {
              l = l - this.m_length;
              g = 2 * Math.PI * this.m_frequencyHz;
              var b = this.m_mass * g * g;
              this.m_gamma = d.dt * (2 * this.m_mass * this.m_dampingRatio * g + d.dt * b);
              this.m_gamma = this.m_gamma != 0 ? 1 / this.m_gamma : 0;
              this.m_bias = l * d.dt * b * this.m_gamma;
              this.m_mass = h + this.m_gamma;
              this.m_mass = this.m_mass != 0 ? 1 / this.m_mass : 0
          }
          if (d.warmStarting) {
              this.m_impulse *= d.dtRatio;
              d = this.m_impulse * this.m_u.x;
              h = this.m_impulse * this.m_u.y;
              j.m_linearVelocity.x -=
                  j.m_invMass * d;
              j.m_linearVelocity.y -= j.m_invMass * h;
              j.m_angularVelocity -= j.m_invI * (q * h - n * d);
              o.m_linearVelocity.x += o.m_invMass * d;
              o.m_linearVelocity.y += o.m_invMass * h;
              o.m_angularVelocity += o.m_invI * (a * h - c * d)
          } else this.m_impulse = 0
      };
      U.prototype.SolveVelocityConstraints = function() {
          var d, h = this.m_bodyA,
              l = this.m_bodyB;
          d = h.m_xf.R;
          var j = this.m_localAnchor1.x - h.m_sweep.localCenter.x,
              o = this.m_localAnchor1.y - h.m_sweep.localCenter.y,
              q = d.col1.x * j + d.col2.x * o;
          o = d.col1.y * j + d.col2.y * o;
          j = q;
          d = l.m_xf.R;
          var n = this.m_localAnchor2.x -
              l.m_sweep.localCenter.x,
              a = this.m_localAnchor2.y - l.m_sweep.localCenter.y;
          q = d.col1.x * n + d.col2.x * a;
          a = d.col1.y * n + d.col2.y * a;
          n = q;
          q = -this.m_mass * (this.m_u.x * (l.m_linearVelocity.x + -l.m_angularVelocity * a - (h.m_linearVelocity.x + -h.m_angularVelocity * o)) + this.m_u.y * (l.m_linearVelocity.y + l.m_angularVelocity * n - (h.m_linearVelocity.y + h.m_angularVelocity * j)) + this.m_bias + this.m_gamma * this.m_impulse);
          this.m_impulse += q;
          d = q * this.m_u.x;
          q = q * this.m_u.y;
          h.m_linearVelocity.x -= h.m_invMass * d;
          h.m_linearVelocity.y -= h.m_invMass *
              q;
          h.m_angularVelocity -= h.m_invI * (j * q - o * d);
          l.m_linearVelocity.x += l.m_invMass * d;
          l.m_linearVelocity.y += l.m_invMass * q;
          l.m_angularVelocity += l.m_invI * (n * q - a * d)
      };
      U.prototype.SolvePositionConstraints = function() {
          var d;
          if (this.m_frequencyHz > 0) return true;
          var h = this.m_bodyA,
              l = this.m_bodyB;
          d = h.m_xf.R;
          var j = this.m_localAnchor1.x - h.m_sweep.localCenter.x,
              o = this.m_localAnchor1.y - h.m_sweep.localCenter.y,
              q = d.col1.x * j + d.col2.x * o;
          o = d.col1.y * j + d.col2.y * o;
          j = q;
          d = l.m_xf.R;
          var n = this.m_localAnchor2.x - l.m_sweep.localCenter.x,
              a = this.m_localAnchor2.y - l.m_sweep.localCenter.y;
          q = d.col1.x * n + d.col2.x * a;
          a = d.col1.y * n + d.col2.y * a;
          n = q;
          q = l.m_sweep.c.x + n - h.m_sweep.c.x - j;
          var c = l.m_sweep.c.y + a - h.m_sweep.c.y - o;
          d = Math.sqrt(q * q + c * c);
          q /= d;
          c /= d;
          d = d - this.m_length;
          d = y.Clamp(d, -F.b2_maxLinearCorrection, F.b2_maxLinearCorrection);
          var g = -this.m_mass * d;
          this.m_u.Set(q, c);
          q = g * this.m_u.x;
          c = g * this.m_u.y;
          h.m_sweep.c.x -= h.m_invMass * q;
          h.m_sweep.c.y -= h.m_invMass * c;
          h.m_sweep.a -= h.m_invI * (j * c - o * q);
          l.m_sweep.c.x += l.m_invMass * q;
          l.m_sweep.c.y += l.m_invMass * c;
          l.m_sweep.a += l.m_invI * (n * c - a * q);
          h.SynchronizeTransform();
          l.SynchronizeTransform();
          return y.Abs(d) < F.b2_linearSlop
      };
      Box2D.inherit(p, Box2D.Dynamics.Joints.b2JointDef);
      p.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
      p.b2DistanceJointDef = function() {
          Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
          this.localAnchorA = new w;
          this.localAnchorB = new w
      };
      p.prototype.b2DistanceJointDef = function() {
          this.__super.b2JointDef.call(this);
          this.type = I.e_distanceJoint;
          this.length = 1;
          this.dampingRatio =
              this.frequencyHz = 0
      };
      p.prototype.Initialize = function(d, h, l, j) {
          this.bodyA = d;
          this.bodyB = h;
          this.localAnchorA.SetV(this.bodyA.GetLocalPoint(l));
          this.localAnchorB.SetV(this.bodyB.GetLocalPoint(j));
          d = j.x - l.x;
          l = j.y - l.y;
          this.length = Math.sqrt(d * d + l * l);
          this.dampingRatio = this.frequencyHz = 0
      };
      Box2D.inherit(B, Box2D.Dynamics.Joints.b2Joint);
      B.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
      B.b2FrictionJoint = function() {
          Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
          this.m_localAnchorA = new w;
          this.m_localAnchorB = new w;
          this.m_linearMass = new G;
          this.m_linearImpulse = new w
      };
      B.prototype.GetAnchorA = function() {
          return this.m_bodyA.GetWorldPoint(this.m_localAnchorA)
      };
      B.prototype.GetAnchorB = function() {
          return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
      };
      B.prototype.GetReactionForce = function(d) {
          if (d === undefined) d = 0;
          return new w(d * this.m_linearImpulse.x, d * this.m_linearImpulse.y)
      };
      B.prototype.GetReactionTorque = function(d) {
          if (d === undefined) d = 0;
          return d * this.m_angularImpulse
      };
      B.prototype.SetMaxForce =
          function(d) {
              if (d === undefined) d = 0;
              this.m_maxForce = d
          };
      B.prototype.GetMaxForce = function() {
          return this.m_maxForce
      };
      B.prototype.SetMaxTorque = function(d) {
          if (d === undefined) d = 0;
          this.m_maxTorque = d
      };
      B.prototype.GetMaxTorque = function() {
          return this.m_maxTorque
      };
      B.prototype.b2FrictionJoint = function(d) {
          this.__super.b2Joint.call(this, d);
          this.m_localAnchorA.SetV(d.localAnchorA);
          this.m_localAnchorB.SetV(d.localAnchorB);
          this.m_linearMass.SetZero();
          this.m_angularMass = 0;
          this.m_linearImpulse.SetZero();
          this.m_angularImpulse =
              0;
          this.m_maxForce = d.maxForce;
          this.m_maxTorque = d.maxTorque
      };
      B.prototype.InitVelocityConstraints = function(d) {
          var h, l = 0,
              j = this.m_bodyA,
              o = this.m_bodyB;
          h = j.m_xf.R;
          var q = this.m_localAnchorA.x - j.m_sweep.localCenter.x,
              n = this.m_localAnchorA.y - j.m_sweep.localCenter.y;
          l = h.col1.x * q + h.col2.x * n;
          n = h.col1.y * q + h.col2.y * n;
          q = l;
          h = o.m_xf.R;
          var a = this.m_localAnchorB.x - o.m_sweep.localCenter.x,
              c = this.m_localAnchorB.y - o.m_sweep.localCenter.y;
          l = h.col1.x * a + h.col2.x * c;
          c = h.col1.y * a + h.col2.y * c;
          a = l;
          h = j.m_invMass;
          l = o.m_invMass;
          var g = j.m_invI,
              b = o.m_invI,
              e = new G;
          e.col1.x = h + l;
          e.col2.x = 0;
          e.col1.y = 0;
          e.col2.y = h + l;
          e.col1.x += g * n * n;
          e.col2.x += -g * q * n;
          e.col1.y += -g * q * n;
          e.col2.y += g * q * q;
          e.col1.x += b * c * c;
          e.col2.x += -b * a * c;
          e.col1.y += -b * a * c;
          e.col2.y += b * a * a;
          e.GetInverse(this.m_linearMass);
          this.m_angularMass = g + b;
          if (this.m_angularMass > 0) this.m_angularMass = 1 / this.m_angularMass;
          if (d.warmStarting) {
              this.m_linearImpulse.x *= d.dtRatio;
              this.m_linearImpulse.y *= d.dtRatio;
              this.m_angularImpulse *= d.dtRatio;
              d = this.m_linearImpulse;
              j.m_linearVelocity.x -= h * d.x;
              j.m_linearVelocity.y -= h * d.y;
              j.m_angularVelocity -= g * (q * d.y - n * d.x + this.m_angularImpulse);
              o.m_linearVelocity.x += l * d.x;
              o.m_linearVelocity.y += l * d.y;
              o.m_angularVelocity += b * (a * d.y - c * d.x + this.m_angularImpulse)
          } else {
              this.m_linearImpulse.SetZero();
              this.m_angularImpulse = 0
          }
      };
      B.prototype.SolveVelocityConstraints = function(d) {
          var h, l = 0,
              j = this.m_bodyA,
              o = this.m_bodyB,
              q = j.m_linearVelocity,
              n = j.m_angularVelocity,
              a = o.m_linearVelocity,
              c = o.m_angularVelocity,
              g = j.m_invMass,
              b = o.m_invMass,
              e = j.m_invI,
              f = o.m_invI;
          h = j.m_xf.R;
          var m =
              this.m_localAnchorA.x - j.m_sweep.localCenter.x,
              r = this.m_localAnchorA.y - j.m_sweep.localCenter.y;
          l = h.col1.x * m + h.col2.x * r;
          r = h.col1.y * m + h.col2.y * r;
          m = l;
          h = o.m_xf.R;
          var s = this.m_localAnchorB.x - o.m_sweep.localCenter.x,
              v = this.m_localAnchorB.y - o.m_sweep.localCenter.y;
          l = h.col1.x * s + h.col2.x * v;
          v = h.col1.y * s + h.col2.y * v;
          s = l;
          h = 0;
          l = -this.m_angularMass * (c - n);
          var t = this.m_angularImpulse;
          h = d.dt * this.m_maxTorque;
          this.m_angularImpulse = y.Clamp(this.m_angularImpulse + l, -h, h);
          l = this.m_angularImpulse - t;
          n -= e * l;
          c += f * l;
          h = y.MulMV(this.m_linearMass,
              new w(-(a.x - c * v - q.x + n * r), -(a.y + c * s - q.y - n * m)));
          l = this.m_linearImpulse.Copy();
          this.m_linearImpulse.Add(h);
          h = d.dt * this.m_maxForce;
          if (this.m_linearImpulse.LengthSquared() > h * h) {
              this.m_linearImpulse.Normalize();
              this.m_linearImpulse.Multiply(h)
          }
          h = y.SubtractVV(this.m_linearImpulse, l);
          q.x -= g * h.x;
          q.y -= g * h.y;
          n -= e * (m * h.y - r * h.x);
          a.x += b * h.x;
          a.y += b * h.y;
          c += f * (s * h.y - v * h.x);
          j.m_angularVelocity = n;
          o.m_angularVelocity = c
      };
      B.prototype.SolvePositionConstraints = function() {
          return true
      };
      Box2D.inherit(Q, Box2D.Dynamics.Joints.b2JointDef);
      Q.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
      Q.b2FrictionJointDef = function() {
          Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
          this.localAnchorA = new w;
          this.localAnchorB = new w
      };
      Q.prototype.b2FrictionJointDef = function() {
          this.__super.b2JointDef.call(this);
          this.type = I.e_frictionJoint;
          this.maxTorque = this.maxForce = 0
      };
      Q.prototype.Initialize = function(d, h, l) {
          this.bodyA = d;
          this.bodyB = h;
          this.localAnchorA.SetV(this.bodyA.GetLocalPoint(l));
          this.localAnchorB.SetV(this.bodyB.GetLocalPoint(l))
      };
      Box2D.inherit(V, Box2D.Dynamics.Joints.b2Joint);
      V.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
      V.b2GearJoint = function() {
          Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
          this.m_groundAnchor1 = new w;
          this.m_groundAnchor2 = new w;
          this.m_localAnchor1 = new w;
          this.m_localAnchor2 = new w;
          this.m_J = new L
      };
      V.prototype.GetAnchorA = function() {
          return this.m_bodyA.GetWorldPoint(this.m_localAnchor1)
      };
      V.prototype.GetAnchorB = function() {
          return this.m_bodyB.GetWorldPoint(this.m_localAnchor2)
      };
      V.prototype.GetReactionForce =
          function(d) {
              if (d === undefined) d = 0;
              return new w(d * this.m_impulse * this.m_J.linearB.x, d * this.m_impulse * this.m_J.linearB.y)
          };
      V.prototype.GetReactionTorque = function(d) {
          if (d === undefined) d = 0;
          var h = this.m_bodyB.m_xf.R,
              l = this.m_localAnchor1.x - this.m_bodyB.m_sweep.localCenter.x,
              j = this.m_localAnchor1.y - this.m_bodyB.m_sweep.localCenter.y,
              o = h.col1.x * l + h.col2.x * j;
          j = h.col1.y * l + h.col2.y * j;
          l = o;
          return d * (this.m_impulse * this.m_J.angularB - l * this.m_impulse * this.m_J.linearB.y + j * this.m_impulse * this.m_J.linearB.x)
      };
      V.prototype.GetRatio =
          function() {
              return this.m_ratio
          };
      V.prototype.SetRatio = function(d) {
          if (d === undefined) d = 0;
          this.m_ratio = d
      };
      V.prototype.b2GearJoint = function(d) {
          this.__super.b2Joint.call(this, d);
          var h = parseInt(d.joint1.m_type),
              l = parseInt(d.joint2.m_type);
          this.m_prismatic2 = this.m_revolute2 = this.m_prismatic1 = this.m_revolute1 = null;
          var j = 0,
              o = 0;
          this.m_ground1 = d.joint1.GetBodyA();
          this.m_bodyA = d.joint1.GetBodyB();
          if (h == I.e_revoluteJoint) {
              this.m_revolute1 = d.joint1 instanceof N ? d.joint1 : null;
              this.m_groundAnchor1.SetV(this.m_revolute1.m_localAnchor1);
              this.m_localAnchor1.SetV(this.m_revolute1.m_localAnchor2);
              j = this.m_revolute1.GetJointAngle()
          } else {
              this.m_prismatic1 = d.joint1 instanceof H ? d.joint1 : null;
              this.m_groundAnchor1.SetV(this.m_prismatic1.m_localAnchor1);
              this.m_localAnchor1.SetV(this.m_prismatic1.m_localAnchor2);
              j = this.m_prismatic1.GetJointTranslation()
          }
          this.m_ground2 = d.joint2.GetBodyA();
          this.m_bodyB = d.joint2.GetBodyB();
          if (l == I.e_revoluteJoint) {
              this.m_revolute2 = d.joint2 instanceof N ? d.joint2 : null;
              this.m_groundAnchor2.SetV(this.m_revolute2.m_localAnchor1);
              this.m_localAnchor2.SetV(this.m_revolute2.m_localAnchor2);
              o = this.m_revolute2.GetJointAngle()
          } else {
              this.m_prismatic2 = d.joint2 instanceof H ? d.joint2 : null;
              this.m_groundAnchor2.SetV(this.m_prismatic2.m_localAnchor1);
              this.m_localAnchor2.SetV(this.m_prismatic2.m_localAnchor2);
              o = this.m_prismatic2.GetJointTranslation()
          }
          this.m_ratio = d.ratio;
          this.m_constant = j + this.m_ratio * o;
          this.m_impulse = 0
      };
      V.prototype.InitVelocityConstraints = function(d) {
          var h = this.m_ground1,
              l = this.m_ground2,
              j = this.m_bodyA,
              o = this.m_bodyB,
              q = 0,
              n = 0,
              a = 0,
              c = 0,
              g = a = 0,
              b = 0;
          this.m_J.SetZero();
          if (this.m_revolute1) {
              this.m_J.angularA = -1;
              b += j.m_invI
          } else {
              h = h.m_xf.R;
              n = this.m_prismatic1.m_localXAxis1;
              q = h.col1.x * n.x + h.col2.x * n.y;
              n = h.col1.y * n.x + h.col2.y * n.y;
              h = j.m_xf.R;
              a = this.m_localAnchor1.x - j.m_sweep.localCenter.x;
              c = this.m_localAnchor1.y - j.m_sweep.localCenter.y;
              g = h.col1.x * a + h.col2.x * c;
              c = h.col1.y * a + h.col2.y * c;
              a = g;
              a = a * n - c * q;
              this.m_J.linearA.Set(-q, -n);
              this.m_J.angularA = -a;
              b += j.m_invMass + j.m_invI * a * a
          }
          if (this.m_revolute2) {
              this.m_J.angularB = -this.m_ratio;
              b += this.m_ratio * this.m_ratio * o.m_invI
          } else {
              h = l.m_xf.R;
              n = this.m_prismatic2.m_localXAxis1;
              q = h.col1.x * n.x + h.col2.x * n.y;
              n = h.col1.y * n.x + h.col2.y * n.y;
              h = o.m_xf.R;
              a = this.m_localAnchor2.x - o.m_sweep.localCenter.x;
              c = this.m_localAnchor2.y - o.m_sweep.localCenter.y;
              g = h.col1.x * a + h.col2.x * c;
              c = h.col1.y * a + h.col2.y * c;
              a = g;
              a = a * n - c * q;
              this.m_J.linearB.Set(-this.m_ratio * q, -this.m_ratio * n);
              this.m_J.angularB = -this.m_ratio * a;
              b += this.m_ratio * this.m_ratio * (o.m_invMass + o.m_invI * a * a)
          }
          this.m_mass = b > 0 ? 1 / b : 0;
          if (d.warmStarting) {
              j.m_linearVelocity.x +=
                  j.m_invMass * this.m_impulse * this.m_J.linearA.x;
              j.m_linearVelocity.y += j.m_invMass * this.m_impulse * this.m_J.linearA.y;
              j.m_angularVelocity += j.m_invI * this.m_impulse * this.m_J.angularA;
              o.m_linearVelocity.x += o.m_invMass * this.m_impulse * this.m_J.linearB.x;
              o.m_linearVelocity.y += o.m_invMass * this.m_impulse * this.m_J.linearB.y;
              o.m_angularVelocity += o.m_invI * this.m_impulse * this.m_J.angularB
          } else this.m_impulse = 0
      };
      V.prototype.SolveVelocityConstraints = function() {
          var d = this.m_bodyA,
              h = this.m_bodyB,
              l = -this.m_mass * this.m_J.Compute(d.m_linearVelocity,
                  d.m_angularVelocity, h.m_linearVelocity, h.m_angularVelocity);
          this.m_impulse += l;
          d.m_linearVelocity.x += d.m_invMass * l * this.m_J.linearA.x;
          d.m_linearVelocity.y += d.m_invMass * l * this.m_J.linearA.y;
          d.m_angularVelocity += d.m_invI * l * this.m_J.angularA;
          h.m_linearVelocity.x += h.m_invMass * l * this.m_J.linearB.x;
          h.m_linearVelocity.y += h.m_invMass * l * this.m_J.linearB.y;
          h.m_angularVelocity += h.m_invI * l * this.m_J.angularB
      };
      V.prototype.SolvePositionConstraints = function() {
          var d = this.m_bodyA,
              h = this.m_bodyB,
              l = 0,
              j = 0;
          l = this.m_revolute1 ?
              this.m_revolute1.GetJointAngle() : this.m_prismatic1.GetJointTranslation();
          j = this.m_revolute2 ? this.m_revolute2.GetJointAngle() : this.m_prismatic2.GetJointTranslation();
          l = -this.m_mass * (this.m_constant - (l + this.m_ratio * j));
          d.m_sweep.c.x += d.m_invMass * l * this.m_J.linearA.x;
          d.m_sweep.c.y += d.m_invMass * l * this.m_J.linearA.y;
          d.m_sweep.a += d.m_invI * l * this.m_J.angularA;
          h.m_sweep.c.x += h.m_invMass * l * this.m_J.linearB.x;
          h.m_sweep.c.y += h.m_invMass * l * this.m_J.linearB.y;
          h.m_sweep.a += h.m_invI * l * this.m_J.angularB;
          d.SynchronizeTransform();
          h.SynchronizeTransform();
          return 0 < F.b2_linearSlop
      };
      Box2D.inherit(M, Box2D.Dynamics.Joints.b2JointDef);
      M.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
      M.b2GearJointDef = function() {
          Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments)
      };
      M.prototype.b2GearJointDef = function() {
          this.__super.b2JointDef.call(this);
          this.type = I.e_gearJoint;
          this.joint2 = this.joint1 = null;
          this.ratio = 1
      };
      L.b2Jacobian = function() {
          this.linearA = new w;
          this.linearB = new w
      };
      L.prototype.SetZero = function() {
          this.linearA.SetZero();
          this.angularA = 0;
          this.linearB.SetZero();
          this.angularB = 0
      };
      L.prototype.Set = function(d, h, l, j) {
          if (h === undefined) h = 0;
          if (j === undefined) j = 0;
          this.linearA.SetV(d);
          this.angularA = h;
          this.linearB.SetV(l);
          this.angularB = j
      };
      L.prototype.Compute = function(d, h, l, j) {
          if (h === undefined) h = 0;
          if (j === undefined) j = 0;
          return this.linearA.x * d.x + this.linearA.y * d.y + this.angularA * h + (this.linearB.x * l.x + this.linearB.y * l.y) + this.angularB * j
      };
      I.b2Joint = function() {
          this.m_edgeA = new Y;
          this.m_edgeB = new Y;
          this.m_localCenterA = new w;
          this.m_localCenterB =
              new w
      };
      I.prototype.GetType = function() {
          return this.m_type
      };
      I.prototype.GetAnchorA = function() {
          return null
      };
      I.prototype.GetAnchorB = function() {
          return null
      };
      I.prototype.GetReactionForce = function() {
          return null
      };
      I.prototype.GetReactionTorque = function() {
          return 0
      };
      I.prototype.GetBodyA = function() {
          return this.m_bodyA
      };
      I.prototype.GetBodyB = function() {
          return this.m_bodyB
      };
      I.prototype.GetNext = function() {
          return this.m_next
      };
      I.prototype.GetUserData = function() {
          return this.m_userData
      };
      I.prototype.SetUserData = function(d) {
          this.m_userData =
              d
      };
      I.prototype.IsActive = function() {
          return this.m_bodyA.IsActive() && this.m_bodyB.IsActive()
      };
      I.Create = function(d) {
          var h = null;
          switch (d.type) {
              case I.e_distanceJoint:
                  h = new U(d instanceof p ? d : null);
                  break;
              case I.e_mouseJoint:
                  h = new u(d instanceof D ? d : null);
                  break;
              case I.e_prismaticJoint:
                  h = new H(d instanceof O ? d : null);
                  break;
              case I.e_revoluteJoint:
                  h = new N(d instanceof S ? d : null);
                  break;
              case I.e_pulleyJoint:
                  h = new E(d instanceof R ? d : null);
                  break;
              case I.e_gearJoint:
                  h = new V(d instanceof M ? d : null);
                  break;
              case I.e_lineJoint:
                  h =
                      new k(d instanceof z ? d : null);
                  break;
              case I.e_weldJoint:
                  h = new aa(d instanceof Z ? d : null);
                  break;
              case I.e_frictionJoint:
                  h = new B(d instanceof Q ? d : null)
          }
          return h
      };
      I.Destroy = function() {};
      I.prototype.b2Joint = function(d) {
          F.b2Assert(d.bodyA != d.bodyB);
          this.m_type = d.type;
          this.m_next = this.m_prev = null;
          this.m_bodyA = d.bodyA;
          this.m_bodyB = d.bodyB;
          this.m_collideConnected = d.collideConnected;
          this.m_islandFlag = false;
          this.m_userData = d.userData
      };
      I.prototype.InitVelocityConstraints = function() {};
      I.prototype.SolveVelocityConstraints =
          function() {};
      I.prototype.FinalizeVelocityConstraints = function() {};
      I.prototype.SolvePositionConstraints = function() {
          return false
      };
      Box2D.postDefs.push(function() {
          Box2D.Dynamics.Joints.b2Joint.e_unknownJoint = 0;
          Box2D.Dynamics.Joints.b2Joint.e_revoluteJoint = 1;
          Box2D.Dynamics.Joints.b2Joint.e_prismaticJoint = 2;
          Box2D.Dynamics.Joints.b2Joint.e_distanceJoint = 3;
          Box2D.Dynamics.Joints.b2Joint.e_pulleyJoint = 4;
          Box2D.Dynamics.Joints.b2Joint.e_mouseJoint = 5;
          Box2D.Dynamics.Joints.b2Joint.e_gearJoint = 6;
          Box2D.Dynamics.Joints.b2Joint.e_lineJoint =
              7;
          Box2D.Dynamics.Joints.b2Joint.e_weldJoint = 8;
          Box2D.Dynamics.Joints.b2Joint.e_frictionJoint = 9;
          Box2D.Dynamics.Joints.b2Joint.e_inactiveLimit = 0;
          Box2D.Dynamics.Joints.b2Joint.e_atLowerLimit = 1;
          Box2D.Dynamics.Joints.b2Joint.e_atUpperLimit = 2;
          Box2D.Dynamics.Joints.b2Joint.e_equalLimits = 3
      });
      W.b2JointDef = function() {};
      W.prototype.b2JointDef = function() {
          this.type = I.e_unknownJoint;
          this.bodyB = this.bodyA = this.userData = null;
          this.collideConnected = false
      };
      Y.b2JointEdge = function() {};
      Box2D.inherit(k, Box2D.Dynamics.Joints.b2Joint);
      k.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
      k.b2LineJoint = function() {
          Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
          this.m_localAnchor1 = new w;
          this.m_localAnchor2 = new w;
          this.m_localXAxis1 = new w;
          this.m_localYAxis1 = new w;
          this.m_axis = new w;
          this.m_perp = new w;
          this.m_K = new G;
          this.m_impulse = new w
      };
      k.prototype.GetAnchorA = function() {
          return this.m_bodyA.GetWorldPoint(this.m_localAnchor1)
      };
      k.prototype.GetAnchorB = function() {
          return this.m_bodyB.GetWorldPoint(this.m_localAnchor2)
      };
      k.prototype.GetReactionForce =
          function(d) {
              if (d === undefined) d = 0;
              return new w(d * (this.m_impulse.x * this.m_perp.x + (this.m_motorImpulse + this.m_impulse.y) * this.m_axis.x), d * (this.m_impulse.x * this.m_perp.y + (this.m_motorImpulse + this.m_impulse.y) * this.m_axis.y))
          };
      k.prototype.GetReactionTorque = function(d) {
          if (d === undefined) d = 0;
          return d * this.m_impulse.y
      };
      k.prototype.GetJointTranslation = function() {
          var d = this.m_bodyA,
              h = this.m_bodyB,
              l = d.GetWorldPoint(this.m_localAnchor1),
              j = h.GetWorldPoint(this.m_localAnchor2);
          h = j.x - l.x;
          l = j.y - l.y;
          d = d.GetWorldVector(this.m_localXAxis1);
          return d.x * h + d.y * l
      };
      k.prototype.GetJointSpeed = function() {
          var d = this.m_bodyA,
              h = this.m_bodyB,
              l;
          l = d.m_xf.R;
          var j = this.m_localAnchor1.x - d.m_sweep.localCenter.x,
              o = this.m_localAnchor1.y - d.m_sweep.localCenter.y,
              q = l.col1.x * j + l.col2.x * o;
          o = l.col1.y * j + l.col2.y * o;
          j = q;
          l = h.m_xf.R;
          var n = this.m_localAnchor2.x - h.m_sweep.localCenter.x,
              a = this.m_localAnchor2.y - h.m_sweep.localCenter.y;
          q = l.col1.x * n + l.col2.x * a;
          a = l.col1.y * n + l.col2.y * a;
          n = q;
          l = h.m_sweep.c.x + n - (d.m_sweep.c.x + j);
          q = h.m_sweep.c.y + a - (d.m_sweep.c.y + o);
          var c = d.GetWorldVector(this.m_localXAxis1),
              g = d.m_linearVelocity,
              b = h.m_linearVelocity;
          d = d.m_angularVelocity;
          h = h.m_angularVelocity;
          return l * -d * c.y + q * d * c.x + (c.x * (b.x + -h * a - g.x - -d * o) + c.y * (b.y + h * n - g.y - d * j))
      };
      k.prototype.IsLimitEnabled = function() {
          return this.m_enableLimit
      };
      k.prototype.EnableLimit = function(d) {
          this.m_bodyA.SetAwake(true);
          this.m_bodyB.SetAwake(true);
          this.m_enableLimit = d
      };
      k.prototype.GetLowerLimit = function() {
          return this.m_lowerTranslation
      };
      k.prototype.GetUpperLimit = function() {
          return this.m_upperTranslation
      };
      k.prototype.SetLimits = function(d,
          h) {
          if (d === undefined) d = 0;
          if (h === undefined) h = 0;
          this.m_bodyA.SetAwake(true);
          this.m_bodyB.SetAwake(true);
          this.m_lowerTranslation = d;
          this.m_upperTranslation = h
      };
      k.prototype.IsMotorEnabled = function() {
          return this.m_enableMotor
      };
      k.prototype.EnableMotor = function(d) {
          this.m_bodyA.SetAwake(true);
          this.m_bodyB.SetAwake(true);
          this.m_enableMotor = d
      };
      k.prototype.SetMotorSpeed = function(d) {
          if (d === undefined) d = 0;
          this.m_bodyA.SetAwake(true);
          this.m_bodyB.SetAwake(true);
          this.m_motorSpeed = d
      };
      k.prototype.GetMotorSpeed = function() {
          return this.m_motorSpeed
      };
      k.prototype.SetMaxMotorForce = function(d) {
          if (d === undefined) d = 0;
          this.m_bodyA.SetAwake(true);
          this.m_bodyB.SetAwake(true);
          this.m_maxMotorForce = d
      };
      k.prototype.GetMaxMotorForce = function() {
          return this.m_maxMotorForce
      };
      k.prototype.GetMotorForce = function() {
          return this.m_motorImpulse
      };
      k.prototype.b2LineJoint = function(d) {
          this.__super.b2Joint.call(this, d);
          this.m_localAnchor1.SetV(d.localAnchorA);
          this.m_localAnchor2.SetV(d.localAnchorB);
          this.m_localXAxis1.SetV(d.localAxisA);
          this.m_localYAxis1.x = -this.m_localXAxis1.y;
          this.m_localYAxis1.y = this.m_localXAxis1.x;
          this.m_impulse.SetZero();
          this.m_motorImpulse = this.m_motorMass = 0;
          this.m_lowerTranslation = d.lowerTranslation;
          this.m_upperTranslation = d.upperTranslation;
          this.m_maxMotorForce = d.maxMotorForce;
          this.m_motorSpeed = d.motorSpeed;
          this.m_enableLimit = d.enableLimit;
          this.m_enableMotor = d.enableMotor;
          this.m_limitState = I.e_inactiveLimit;
          this.m_axis.SetZero();
          this.m_perp.SetZero()
      };
      k.prototype.InitVelocityConstraints = function(d) {
          var h = this.m_bodyA,
              l = this.m_bodyB,
              j, o = 0;
          this.m_localCenterA.SetV(h.GetLocalCenter());
          this.m_localCenterB.SetV(l.GetLocalCenter());
          var q = h.GetTransform();
          l.GetTransform();
          j = h.m_xf.R;
          var n = this.m_localAnchor1.x - this.m_localCenterA.x,
              a = this.m_localAnchor1.y - this.m_localCenterA.y;
          o = j.col1.x * n + j.col2.x * a;
          a = j.col1.y * n + j.col2.y * a;
          n = o;
          j = l.m_xf.R;
          var c = this.m_localAnchor2.x - this.m_localCenterB.x,
              g = this.m_localAnchor2.y - this.m_localCenterB.y;
          o = j.col1.x * c + j.col2.x * g;
          g = j.col1.y * c + j.col2.y * g;
          c = o;
          j = l.m_sweep.c.x + c - h.m_sweep.c.x - n;
          o = l.m_sweep.c.y + g - h.m_sweep.c.y - a;
          this.m_invMassA = h.m_invMass;
          this.m_invMassB =
              l.m_invMass;
          this.m_invIA = h.m_invI;
          this.m_invIB = l.m_invI;
          this.m_axis.SetV(y.MulMV(q.R, this.m_localXAxis1));
          this.m_a1 = (j + n) * this.m_axis.y - (o + a) * this.m_axis.x;
          this.m_a2 = c * this.m_axis.y - g * this.m_axis.x;
          this.m_motorMass = this.m_invMassA + this.m_invMassB + this.m_invIA * this.m_a1 * this.m_a1 + this.m_invIB * this.m_a2 * this.m_a2;
          this.m_motorMass = this.m_motorMass > Number.MIN_VALUE ? 1 / this.m_motorMass : 0;
          this.m_perp.SetV(y.MulMV(q.R, this.m_localYAxis1));
          this.m_s1 = (j + n) * this.m_perp.y - (o + a) * this.m_perp.x;
          this.m_s2 = c * this.m_perp.y -
              g * this.m_perp.x;
          q = this.m_invMassA;
          n = this.m_invMassB;
          a = this.m_invIA;
          c = this.m_invIB;
          this.m_K.col1.x = q + n + a * this.m_s1 * this.m_s1 + c * this.m_s2 * this.m_s2;
          this.m_K.col1.y = a * this.m_s1 * this.m_a1 + c * this.m_s2 * this.m_a2;
          this.m_K.col2.x = this.m_K.col1.y;
          this.m_K.col2.y = q + n + a * this.m_a1 * this.m_a1 + c * this.m_a2 * this.m_a2;
          if (this.m_enableLimit) {
              j = this.m_axis.x * j + this.m_axis.y * o;
              if (y.Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2 * F.b2_linearSlop) this.m_limitState = I.e_equalLimits;
              else if (j <= this.m_lowerTranslation) {
                  if (this.m_limitState !=
                      I.e_atLowerLimit) {
                      this.m_limitState = I.e_atLowerLimit;
                      this.m_impulse.y = 0
                  }
              } else if (j >= this.m_upperTranslation) {
                  if (this.m_limitState != I.e_atUpperLimit) {
                      this.m_limitState = I.e_atUpperLimit;
                      this.m_impulse.y = 0
                  }
              } else {
                  this.m_limitState = I.e_inactiveLimit;
                  this.m_impulse.y = 0
              }
          } else this.m_limitState = I.e_inactiveLimit;
          if (this.m_enableMotor == false) this.m_motorImpulse = 0;
          if (d.warmStarting) {
              this.m_impulse.x *= d.dtRatio;
              this.m_impulse.y *= d.dtRatio;
              this.m_motorImpulse *= d.dtRatio;
              d = this.m_impulse.x * this.m_perp.x + (this.m_motorImpulse +
                  this.m_impulse.y) * this.m_axis.x;
              j = this.m_impulse.x * this.m_perp.y + (this.m_motorImpulse + this.m_impulse.y) * this.m_axis.y;
              o = this.m_impulse.x * this.m_s1 + (this.m_motorImpulse + this.m_impulse.y) * this.m_a1;
              q = this.m_impulse.x * this.m_s2 + (this.m_motorImpulse + this.m_impulse.y) * this.m_a2;
              h.m_linearVelocity.x -= this.m_invMassA * d;
              h.m_linearVelocity.y -= this.m_invMassA * j;
              h.m_angularVelocity -= this.m_invIA * o;
              l.m_linearVelocity.x += this.m_invMassB * d;
              l.m_linearVelocity.y += this.m_invMassB * j;
              l.m_angularVelocity += this.m_invIB *
                  q
          } else {
              this.m_impulse.SetZero();
              this.m_motorImpulse = 0
          }
      };
      k.prototype.SolveVelocityConstraints = function(d) {
          var h = this.m_bodyA,
              l = this.m_bodyB,
              j = h.m_linearVelocity,
              o = h.m_angularVelocity,
              q = l.m_linearVelocity,
              n = l.m_angularVelocity,
              a = 0,
              c = 0,
              g = 0,
              b = 0;
          if (this.m_enableMotor && this.m_limitState != I.e_equalLimits) {
              b = this.m_motorMass * (this.m_motorSpeed - (this.m_axis.x * (q.x - j.x) + this.m_axis.y * (q.y - j.y) + this.m_a2 * n - this.m_a1 * o));
              a = this.m_motorImpulse;
              c = d.dt * this.m_maxMotorForce;
              this.m_motorImpulse = y.Clamp(this.m_motorImpulse +
                  b, -c, c);
              b = this.m_motorImpulse - a;
              a = b * this.m_axis.x;
              c = b * this.m_axis.y;
              g = b * this.m_a1;
              b = b * this.m_a2;
              j.x -= this.m_invMassA * a;
              j.y -= this.m_invMassA * c;
              o -= this.m_invIA * g;
              q.x += this.m_invMassB * a;
              q.y += this.m_invMassB * c;
              n += this.m_invIB * b
          }
          c = this.m_perp.x * (q.x - j.x) + this.m_perp.y * (q.y - j.y) + this.m_s2 * n - this.m_s1 * o;
          if (this.m_enableLimit && this.m_limitState != I.e_inactiveLimit) {
              g = this.m_axis.x * (q.x - j.x) + this.m_axis.y * (q.y - j.y) + this.m_a2 * n - this.m_a1 * o;
              a = this.m_impulse.Copy();
              d = this.m_K.Solve(new w, -c, -g);
              this.m_impulse.Add(d);
              if (this.m_limitState == I.e_atLowerLimit) this.m_impulse.y = y.Max(this.m_impulse.y, 0);
              else if (this.m_limitState == I.e_atUpperLimit) this.m_impulse.y = y.Min(this.m_impulse.y, 0);
              c = -c - (this.m_impulse.y - a.y) * this.m_K.col2.x;
              g = 0;
              g = this.m_K.col1.x != 0 ? c / this.m_K.col1.x + a.x : a.x;
              this.m_impulse.x = g;
              d.x = this.m_impulse.x - a.x;
              d.y = this.m_impulse.y - a.y;
              a = d.x * this.m_perp.x + d.y * this.m_axis.x;
              c = d.x * this.m_perp.y + d.y * this.m_axis.y;
              g = d.x * this.m_s1 + d.y * this.m_a1;
              b = d.x * this.m_s2 + d.y * this.m_a2
          } else {
              d = 0;
              d = this.m_K.col1.x != 0 ? -c /
                  this.m_K.col1.x : 0;
              this.m_impulse.x += d;
              a = d * this.m_perp.x;
              c = d * this.m_perp.y;
              g = d * this.m_s1;
              b = d * this.m_s2
          }
          j.x -= this.m_invMassA * a;
          j.y -= this.m_invMassA * c;
          o -= this.m_invIA * g;
          q.x += this.m_invMassB * a;
          q.y += this.m_invMassB * c;
          n += this.m_invIB * b;
          h.m_linearVelocity.SetV(j);
          h.m_angularVelocity = o;
          l.m_linearVelocity.SetV(q);
          l.m_angularVelocity = n
      };
      k.prototype.SolvePositionConstraints = function() {
          var d = this.m_bodyA,
              h = this.m_bodyB,
              l = d.m_sweep.c,
              j = d.m_sweep.a,
              o = h.m_sweep.c,
              q = h.m_sweep.a,
              n, a = 0,
              c = 0,
              g = 0,
              b = 0,
              e = n = 0,
              f = 0;
          c = false;
          var m = 0,
              r = G.FromAngle(j);
          g = G.FromAngle(q);
          n = r;
          f = this.m_localAnchor1.x - this.m_localCenterA.x;
          var s = this.m_localAnchor1.y - this.m_localCenterA.y;
          a = n.col1.x * f + n.col2.x * s;
          s = n.col1.y * f + n.col2.y * s;
          f = a;
          n = g;
          g = this.m_localAnchor2.x - this.m_localCenterB.x;
          b = this.m_localAnchor2.y - this.m_localCenterB.y;
          a = n.col1.x * g + n.col2.x * b;
          b = n.col1.y * g + n.col2.y * b;
          g = a;
          n = o.x + g - l.x - f;
          a = o.y + b - l.y - s;
          if (this.m_enableLimit) {
              this.m_axis = y.MulMV(r, this.m_localXAxis1);
              this.m_a1 = (n + f) * this.m_axis.y - (a + s) * this.m_axis.x;
              this.m_a2 = g * this.m_axis.y -
                  b * this.m_axis.x;
              var v = this.m_axis.x * n + this.m_axis.y * a;
              if (y.Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2 * F.b2_linearSlop) {
                  m = y.Clamp(v, -F.b2_maxLinearCorrection, F.b2_maxLinearCorrection);
                  e = y.Abs(v);
                  c = true
              } else if (v <= this.m_lowerTranslation) {
                  m = y.Clamp(v - this.m_lowerTranslation + F.b2_linearSlop, -F.b2_maxLinearCorrection, 0);
                  e = this.m_lowerTranslation - v;
                  c = true
              } else if (v >= this.m_upperTranslation) {
                  m = y.Clamp(v - this.m_upperTranslation + F.b2_linearSlop, 0, F.b2_maxLinearCorrection);
                  e = v - this.m_upperTranslation;
                  c = true
              }
          }
          this.m_perp = y.MulMV(r, this.m_localYAxis1);
          this.m_s1 = (n + f) * this.m_perp.y - (a + s) * this.m_perp.x;
          this.m_s2 = g * this.m_perp.y - b * this.m_perp.x;
          r = new w;
          s = this.m_perp.x * n + this.m_perp.y * a;
          e = y.Max(e, y.Abs(s));
          f = 0;
          if (c) {
              c = this.m_invMassA;
              g = this.m_invMassB;
              b = this.m_invIA;
              n = this.m_invIB;
              this.m_K.col1.x = c + g + b * this.m_s1 * this.m_s1 + n * this.m_s2 * this.m_s2;
              this.m_K.col1.y = b * this.m_s1 * this.m_a1 + n * this.m_s2 * this.m_a2;
              this.m_K.col2.x = this.m_K.col1.y;
              this.m_K.col2.y = c + g + b * this.m_a1 * this.m_a1 + n * this.m_a2 * this.m_a2;
              this.m_K.Solve(r, -s, -m)
          } else {
              c = this.m_invMassA;
              g = this.m_invMassB;
              b = this.m_invIA;
              n = this.m_invIB;
              m = c + g + b * this.m_s1 * this.m_s1 + n * this.m_s2 * this.m_s2;
              c = 0;
              c = m != 0 ? -s / m : 0;
              r.x = c;
              r.y = 0
          }
          m = r.x * this.m_perp.x + r.y * this.m_axis.x;
          c = r.x * this.m_perp.y + r.y * this.m_axis.y;
          s = r.x * this.m_s1 + r.y * this.m_a1;
          r = r.x * this.m_s2 + r.y * this.m_a2;
          l.x -= this.m_invMassA * m;
          l.y -= this.m_invMassA * c;
          j -= this.m_invIA * s;
          o.x += this.m_invMassB * m;
          o.y += this.m_invMassB * c;
          q += this.m_invIB * r;
          d.m_sweep.a = j;
          h.m_sweep.a = q;
          d.SynchronizeTransform();
          h.SynchronizeTransform();
          return e <=
              F.b2_linearSlop && f <= F.b2_angularSlop
      };
      Box2D.inherit(z, Box2D.Dynamics.Joints.b2JointDef);
      z.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
      z.b2LineJointDef = function() {
          Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
          this.localAnchorA = new w;
          this.localAnchorB = new w;
          this.localAxisA = new w
      };
      z.prototype.b2LineJointDef = function() {
          this.__super.b2JointDef.call(this);
          this.type = I.e_lineJoint;
          this.localAxisA.Set(1, 0);
          this.enableLimit = false;
          this.upperTranslation = this.lowerTranslation =
              0;
          this.enableMotor = false;
          this.motorSpeed = this.maxMotorForce = 0
      };
      z.prototype.Initialize = function(d, h, l, j) {
          this.bodyA = d;
          this.bodyB = h;
          this.localAnchorA = this.bodyA.GetLocalPoint(l);
          this.localAnchorB = this.bodyB.GetLocalPoint(l);
          this.localAxisA = this.bodyA.GetLocalVector(j)
      };
      Box2D.inherit(u, Box2D.Dynamics.Joints.b2Joint);
      u.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
      u.b2MouseJoint = function() {
          Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
          this.K = new G;
          this.K1 = new G;
          this.K2 = new G;
          this.m_localAnchor = new w;
          this.m_target = new w;
          this.m_impulse = new w;
          this.m_mass = new G;
          this.m_C = new w
      };
      u.prototype.GetAnchorA = function() {
          return this.m_target
      };
      u.prototype.GetAnchorB = function() {
          return this.m_bodyB.GetWorldPoint(this.m_localAnchor)
      };
      u.prototype.GetReactionForce = function(d) {
          if (d === undefined) d = 0;
          return new w(d * this.m_impulse.x, d * this.m_impulse.y)
      };
      u.prototype.GetReactionTorque = function() {
          return 0
      };
      u.prototype.GetTarget = function() {
          return this.m_target
      };
      u.prototype.SetTarget = function(d) {
          this.m_bodyB.IsAwake() ==
              false && this.m_bodyB.SetAwake(true);
          this.m_target = d
      };
      u.prototype.GetMaxForce = function() {
          return this.m_maxForce
      };
      u.prototype.SetMaxForce = function(d) {
          if (d === undefined) d = 0;
          this.m_maxForce = d
      };
      u.prototype.GetFrequency = function() {
          return this.m_frequencyHz
      };
      u.prototype.SetFrequency = function(d) {
          if (d === undefined) d = 0;
          this.m_frequencyHz = d
      };
      u.prototype.GetDampingRatio = function() {
          return this.m_dampingRatio
      };
      u.prototype.SetDampingRatio = function(d) {
          if (d === undefined) d = 0;
          this.m_dampingRatio = d
      };
      u.prototype.b2MouseJoint =
          function(d) {
              this.__super.b2Joint.call(this, d);
              this.m_target.SetV(d.target);
              var h = this.m_target.x - this.m_bodyB.m_xf.position.x,
                  l = this.m_target.y - this.m_bodyB.m_xf.position.y,
                  j = this.m_bodyB.m_xf.R;
              this.m_localAnchor.x = h * j.col1.x + l * j.col1.y;
              this.m_localAnchor.y = h * j.col2.x + l * j.col2.y;
              this.m_maxForce = d.maxForce;
              this.m_impulse.SetZero();
              this.m_frequencyHz = d.frequencyHz;
              this.m_dampingRatio = d.dampingRatio;
              this.m_gamma = this.m_beta = 0
          };
      u.prototype.InitVelocityConstraints = function(d) {
          var h = this.m_bodyB,
              l = h.GetMass(),
              j = 2 * Math.PI * this.m_frequencyHz,
              o = l * j * j;
          this.m_gamma = d.dt * (2 * l * this.m_dampingRatio * j + d.dt * o);
          this.m_gamma = this.m_gamma != 0 ? 1 / this.m_gamma : 0;
          this.m_beta = d.dt * o * this.m_gamma;
          o = h.m_xf.R;
          l = this.m_localAnchor.x - h.m_sweep.localCenter.x;
          j = this.m_localAnchor.y - h.m_sweep.localCenter.y;
          var q = o.col1.x * l + o.col2.x * j;
          j = o.col1.y * l + o.col2.y * j;
          l = q;
          o = h.m_invMass;
          q = h.m_invI;
          this.K1.col1.x = o;
          this.K1.col2.x = 0;
          this.K1.col1.y = 0;
          this.K1.col2.y = o;
          this.K2.col1.x = q * j * j;
          this.K2.col2.x = -q * l * j;
          this.K2.col1.y = -q * l * j;
          this.K2.col2.y =
              q * l * l;
          this.K.SetM(this.K1);
          this.K.AddM(this.K2);
          this.K.col1.x += this.m_gamma;
          this.K.col2.y += this.m_gamma;
          this.K.GetInverse(this.m_mass);
          this.m_C.x = h.m_sweep.c.x + l - this.m_target.x;
          this.m_C.y = h.m_sweep.c.y + j - this.m_target.y;
          h.m_angularVelocity *= 0.98;
          this.m_impulse.x *= d.dtRatio;
          this.m_impulse.y *= d.dtRatio;
          h.m_linearVelocity.x += o * this.m_impulse.x;
          h.m_linearVelocity.y += o * this.m_impulse.y;
          h.m_angularVelocity += q * (l * this.m_impulse.y - j * this.m_impulse.x)
      };
      u.prototype.SolveVelocityConstraints = function(d) {
          var h =
              this.m_bodyB,
              l, j = 0,
              o = 0;
          l = h.m_xf.R;
          var q = this.m_localAnchor.x - h.m_sweep.localCenter.x,
              n = this.m_localAnchor.y - h.m_sweep.localCenter.y;
          j = l.col1.x * q + l.col2.x * n;
          n = l.col1.y * q + l.col2.y * n;
          q = j;
          j = h.m_linearVelocity.x + -h.m_angularVelocity * n;
          var a = h.m_linearVelocity.y + h.m_angularVelocity * q;
          l = this.m_mass;
          j = j + this.m_beta * this.m_C.x + this.m_gamma * this.m_impulse.x;
          o = a + this.m_beta * this.m_C.y + this.m_gamma * this.m_impulse.y;
          a = -(l.col1.x * j + l.col2.x * o);
          o = -(l.col1.y * j + l.col2.y * o);
          l = this.m_impulse.x;
          j = this.m_impulse.y;
          this.m_impulse.x +=
              a;
          this.m_impulse.y += o;
          d = d.dt * this.m_maxForce;
          this.m_impulse.LengthSquared() > d * d && this.m_impulse.Multiply(d / this.m_impulse.Length());
          a = this.m_impulse.x - l;
          o = this.m_impulse.y - j;
          h.m_linearVelocity.x += h.m_invMass * a;
          h.m_linearVelocity.y += h.m_invMass * o;
          h.m_angularVelocity += h.m_invI * (q * o - n * a)
      };
      u.prototype.SolvePositionConstraints = function() {
          return true
      };
      Box2D.inherit(D, Box2D.Dynamics.Joints.b2JointDef);
      D.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
      D.b2MouseJointDef = function() {
          Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this,
              arguments);
          this.target = new w
      };
      D.prototype.b2MouseJointDef = function() {
          this.__super.b2JointDef.call(this);
          this.type = I.e_mouseJoint;
          this.maxForce = 0;
          this.frequencyHz = 5;
          this.dampingRatio = 0.7
      };
      Box2D.inherit(H, Box2D.Dynamics.Joints.b2Joint);
      H.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
      H.b2PrismaticJoint = function() {
          Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
          this.m_localAnchor1 = new w;
          this.m_localAnchor2 = new w;
          this.m_localXAxis1 = new w;
          this.m_localYAxis1 = new w;
          this.m_axis = new w;
          this.m_perp = new w;
          this.m_K = new K;
          this.m_impulse = new A
      };
      H.prototype.GetAnchorA = function() {
          return this.m_bodyA.GetWorldPoint(this.m_localAnchor1)
      };
      H.prototype.GetAnchorB = function() {
          return this.m_bodyB.GetWorldPoint(this.m_localAnchor2)
      };
      H.prototype.GetReactionForce = function(d) {
          if (d === undefined) d = 0;
          return new w(d * (this.m_impulse.x * this.m_perp.x + (this.m_motorImpulse + this.m_impulse.z) * this.m_axis.x), d * (this.m_impulse.x * this.m_perp.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_axis.y))
      };
      H.prototype.GetReactionTorque =
          function(d) {
              if (d === undefined) d = 0;
              return d * this.m_impulse.y
          };
      H.prototype.GetJointTranslation = function() {
          var d = this.m_bodyA,
              h = this.m_bodyB,
              l = d.GetWorldPoint(this.m_localAnchor1),
              j = h.GetWorldPoint(this.m_localAnchor2);
          h = j.x - l.x;
          l = j.y - l.y;
          d = d.GetWorldVector(this.m_localXAxis1);
          return d.x * h + d.y * l
      };
      H.prototype.GetJointSpeed = function() {
          var d = this.m_bodyA,
              h = this.m_bodyB,
              l;
          l = d.m_xf.R;
          var j = this.m_localAnchor1.x - d.m_sweep.localCenter.x,
              o = this.m_localAnchor1.y - d.m_sweep.localCenter.y,
              q = l.col1.x * j + l.col2.x * o;
          o = l.col1.y * j + l.col2.y * o;
          j = q;
          l = h.m_xf.R;
          var n = this.m_localAnchor2.x - h.m_sweep.localCenter.x,
              a = this.m_localAnchor2.y - h.m_sweep.localCenter.y;
          q = l.col1.x * n + l.col2.x * a;
          a = l.col1.y * n + l.col2.y * a;
          n = q;
          l = h.m_sweep.c.x + n - (d.m_sweep.c.x + j);
          q = h.m_sweep.c.y + a - (d.m_sweep.c.y + o);
          var c = d.GetWorldVector(this.m_localXAxis1),
              g = d.m_linearVelocity,
              b = h.m_linearVelocity;
          d = d.m_angularVelocity;
          h = h.m_angularVelocity;
          return l * -d * c.y + q * d * c.x + (c.x * (b.x + -h * a - g.x - -d * o) + c.y * (b.y + h * n - g.y - d * j))
      };
      H.prototype.IsLimitEnabled = function() {
          return this.m_enableLimit
      };
      H.prototype.EnableLimit = function(d) {
          this.m_bodyA.SetAwake(true);
          this.m_bodyB.SetAwake(true);
          this.m_enableLimit = d
      };
      H.prototype.GetLowerLimit = function() {
          return this.m_lowerTranslation
      };
      H.prototype.GetUpperLimit = function() {
          return this.m_upperTranslation
      };
      H.prototype.SetLimits = function(d, h) {
          if (d === undefined) d = 0;
          if (h === undefined) h = 0;
          this.m_bodyA.SetAwake(true);
          this.m_bodyB.SetAwake(true);
          this.m_lowerTranslation = d;
          this.m_upperTranslation = h
      };
      H.prototype.IsMotorEnabled = function() {
          return this.m_enableMotor
      };
      H.prototype.EnableMotor = function(d) {
          this.m_bodyA.SetAwake(true);
          this.m_bodyB.SetAwake(true);
          this.m_enableMotor = d
      };
      H.prototype.SetMotorSpeed = function(d) {
          if (d === undefined) d = 0;
          this.m_bodyA.SetAwake(true);
          this.m_bodyB.SetAwake(true);
          this.m_motorSpeed = d
      };
      H.prototype.GetMotorSpeed = function() {
          return this.m_motorSpeed
      };
      H.prototype.SetMaxMotorForce = function(d) {
          if (d === undefined) d = 0;
          this.m_bodyA.SetAwake(true);
          this.m_bodyB.SetAwake(true);
          this.m_maxMotorForce = d
      };
      H.prototype.GetMotorForce = function() {
          return this.m_motorImpulse
      };
      H.prototype.b2PrismaticJoint = function(d) {
          this.__super.b2Joint.call(this, d);
          this.m_localAnchor1.SetV(d.localAnchorA);
          this.m_localAnchor2.SetV(d.localAnchorB);
          this.m_localXAxis1.SetV(d.localAxisA);
          this.m_localYAxis1.x = -this.m_localXAxis1.y;
          this.m_localYAxis1.y = this.m_localXAxis1.x;
          this.m_refAngle = d.referenceAngle;
          this.m_impulse.SetZero();
          this.m_motorImpulse = this.m_motorMass = 0;
          this.m_lowerTranslation = d.lowerTranslation;
          this.m_upperTranslation = d.upperTranslation;
          this.m_maxMotorForce = d.maxMotorForce;
          this.m_motorSpeed =
              d.motorSpeed;
          this.m_enableLimit = d.enableLimit;
          this.m_enableMotor = d.enableMotor;
          this.m_limitState = I.e_inactiveLimit;
          this.m_axis.SetZero();
          this.m_perp.SetZero()
      };
      H.prototype.InitVelocityConstraints = function(d) {
          var h = this.m_bodyA,
              l = this.m_bodyB,
              j, o = 0;
          this.m_localCenterA.SetV(h.GetLocalCenter());
          this.m_localCenterB.SetV(l.GetLocalCenter());
          var q = h.GetTransform();
          l.GetTransform();
          j = h.m_xf.R;
          var n = this.m_localAnchor1.x - this.m_localCenterA.x,
              a = this.m_localAnchor1.y - this.m_localCenterA.y;
          o = j.col1.x * n + j.col2.x *
              a;
          a = j.col1.y * n + j.col2.y * a;
          n = o;
          j = l.m_xf.R;
          var c = this.m_localAnchor2.x - this.m_localCenterB.x,
              g = this.m_localAnchor2.y - this.m_localCenterB.y;
          o = j.col1.x * c + j.col2.x * g;
          g = j.col1.y * c + j.col2.y * g;
          c = o;
          j = l.m_sweep.c.x + c - h.m_sweep.c.x - n;
          o = l.m_sweep.c.y + g - h.m_sweep.c.y - a;
          this.m_invMassA = h.m_invMass;
          this.m_invMassB = l.m_invMass;
          this.m_invIA = h.m_invI;
          this.m_invIB = l.m_invI;
          this.m_axis.SetV(y.MulMV(q.R, this.m_localXAxis1));
          this.m_a1 = (j + n) * this.m_axis.y - (o + a) * this.m_axis.x;
          this.m_a2 = c * this.m_axis.y - g * this.m_axis.x;
          this.m_motorMass =
              this.m_invMassA + this.m_invMassB + this.m_invIA * this.m_a1 * this.m_a1 + this.m_invIB * this.m_a2 * this.m_a2;
          if (this.m_motorMass > Number.MIN_VALUE) this.m_motorMass = 1 / this.m_motorMass;
          this.m_perp.SetV(y.MulMV(q.R, this.m_localYAxis1));
          this.m_s1 = (j + n) * this.m_perp.y - (o + a) * this.m_perp.x;
          this.m_s2 = c * this.m_perp.y - g * this.m_perp.x;
          q = this.m_invMassA;
          n = this.m_invMassB;
          a = this.m_invIA;
          c = this.m_invIB;
          this.m_K.col1.x = q + n + a * this.m_s1 * this.m_s1 + c * this.m_s2 * this.m_s2;
          this.m_K.col1.y = a * this.m_s1 + c * this.m_s2;
          this.m_K.col1.z = a *
              this.m_s1 * this.m_a1 + c * this.m_s2 * this.m_a2;
          this.m_K.col2.x = this.m_K.col1.y;
          this.m_K.col2.y = a + c;
          this.m_K.col2.z = a * this.m_a1 + c * this.m_a2;
          this.m_K.col3.x = this.m_K.col1.z;
          this.m_K.col3.y = this.m_K.col2.z;
          this.m_K.col3.z = q + n + a * this.m_a1 * this.m_a1 + c * this.m_a2 * this.m_a2;
          if (this.m_enableLimit) {
              j = this.m_axis.x * j + this.m_axis.y * o;
              if (y.Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2 * F.b2_linearSlop) this.m_limitState = I.e_equalLimits;
              else if (j <= this.m_lowerTranslation) {
                  if (this.m_limitState != I.e_atLowerLimit) {
                      this.m_limitState =
                          I.e_atLowerLimit;
                      this.m_impulse.z = 0
                  }
              } else if (j >= this.m_upperTranslation) {
                  if (this.m_limitState != I.e_atUpperLimit) {
                      this.m_limitState = I.e_atUpperLimit;
                      this.m_impulse.z = 0
                  }
              } else {
                  this.m_limitState = I.e_inactiveLimit;
                  this.m_impulse.z = 0
              }
          } else this.m_limitState = I.e_inactiveLimit;
          if (this.m_enableMotor == false) this.m_motorImpulse = 0;
          if (d.warmStarting) {
              this.m_impulse.x *= d.dtRatio;
              this.m_impulse.y *= d.dtRatio;
              this.m_motorImpulse *= d.dtRatio;
              d = this.m_impulse.x * this.m_perp.x + (this.m_motorImpulse + this.m_impulse.z) * this.m_axis.x;
              j = this.m_impulse.x * this.m_perp.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_axis.y;
              o = this.m_impulse.x * this.m_s1 + this.m_impulse.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_a1;
              q = this.m_impulse.x * this.m_s2 + this.m_impulse.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_a2;
              h.m_linearVelocity.x -= this.m_invMassA * d;
              h.m_linearVelocity.y -= this.m_invMassA * j;
              h.m_angularVelocity -= this.m_invIA * o;
              l.m_linearVelocity.x += this.m_invMassB * d;
              l.m_linearVelocity.y += this.m_invMassB * j;
              l.m_angularVelocity += this.m_invIB *
                  q
          } else {
              this.m_impulse.SetZero();
              this.m_motorImpulse = 0
          }
      };
      H.prototype.SolveVelocityConstraints = function(d) {
          var h = this.m_bodyA,
              l = this.m_bodyB,
              j = h.m_linearVelocity,
              o = h.m_angularVelocity,
              q = l.m_linearVelocity,
              n = l.m_angularVelocity,
              a = 0,
              c = 0,
              g = 0,
              b = 0;
          if (this.m_enableMotor && this.m_limitState != I.e_equalLimits) {
              b = this.m_motorMass * (this.m_motorSpeed - (this.m_axis.x * (q.x - j.x) + this.m_axis.y * (q.y - j.y) + this.m_a2 * n - this.m_a1 * o));
              a = this.m_motorImpulse;
              d = d.dt * this.m_maxMotorForce;
              this.m_motorImpulse = y.Clamp(this.m_motorImpulse +
                  b, -d, d);
              b = this.m_motorImpulse - a;
              a = b * this.m_axis.x;
              c = b * this.m_axis.y;
              g = b * this.m_a1;
              b = b * this.m_a2;
              j.x -= this.m_invMassA * a;
              j.y -= this.m_invMassA * c;
              o -= this.m_invIA * g;
              q.x += this.m_invMassB * a;
              q.y += this.m_invMassB * c;
              n += this.m_invIB * b
          }
          g = this.m_perp.x * (q.x - j.x) + this.m_perp.y * (q.y - j.y) + this.m_s2 * n - this.m_s1 * o;
          c = n - o;
          if (this.m_enableLimit && this.m_limitState != I.e_inactiveLimit) {
              d = this.m_axis.x * (q.x - j.x) + this.m_axis.y * (q.y - j.y) + this.m_a2 * n - this.m_a1 * o;
              a = this.m_impulse.Copy();
              d = this.m_K.Solve33(new A, -g, -c, -d);
              this.m_impulse.Add(d);
              if (this.m_limitState == I.e_atLowerLimit) this.m_impulse.z = y.Max(this.m_impulse.z, 0);
              else if (this.m_limitState == I.e_atUpperLimit) this.m_impulse.z = y.Min(this.m_impulse.z, 0);
              g = -g - (this.m_impulse.z - a.z) * this.m_K.col3.x;
              c = -c - (this.m_impulse.z - a.z) * this.m_K.col3.y;
              c = this.m_K.Solve22(new w, g, c);
              c.x += a.x;
              c.y += a.y;
              this.m_impulse.x = c.x;
              this.m_impulse.y = c.y;
              d.x = this.m_impulse.x - a.x;
              d.y = this.m_impulse.y - a.y;
              d.z = this.m_impulse.z - a.z;
              a = d.x * this.m_perp.x + d.z * this.m_axis.x;
              c = d.x * this.m_perp.y + d.z * this.m_axis.y;
              g = d.x *
                  this.m_s1 + d.y + d.z * this.m_a1;
              b = d.x * this.m_s2 + d.y + d.z * this.m_a2
          } else {
              d = this.m_K.Solve22(new w, -g, -c);
              this.m_impulse.x += d.x;
              this.m_impulse.y += d.y;
              a = d.x * this.m_perp.x;
              c = d.x * this.m_perp.y;
              g = d.x * this.m_s1 + d.y;
              b = d.x * this.m_s2 + d.y
          }
          j.x -= this.m_invMassA * a;
          j.y -= this.m_invMassA * c;
          o -= this.m_invIA * g;
          q.x += this.m_invMassB * a;
          q.y += this.m_invMassB * c;
          n += this.m_invIB * b;
          h.m_linearVelocity.SetV(j);
          h.m_angularVelocity = o;
          l.m_linearVelocity.SetV(q);
          l.m_angularVelocity = n
      };
      H.prototype.SolvePositionConstraints = function() {
          var d =
              this.m_bodyA,
              h = this.m_bodyB,
              l = d.m_sweep.c,
              j = d.m_sweep.a,
              o = h.m_sweep.c,
              q = h.m_sweep.a,
              n, a = 0,
              c = 0,
              g = 0,
              b = a = n = 0,
              e = 0;
          c = false;
          var f = 0,
              m = G.FromAngle(j),
              r = G.FromAngle(q);
          n = m;
          e = this.m_localAnchor1.x - this.m_localCenterA.x;
          var s = this.m_localAnchor1.y - this.m_localCenterA.y;
          a = n.col1.x * e + n.col2.x * s;
          s = n.col1.y * e + n.col2.y * s;
          e = a;
          n = r;
          r = this.m_localAnchor2.x - this.m_localCenterB.x;
          g = this.m_localAnchor2.y - this.m_localCenterB.y;
          a = n.col1.x * r + n.col2.x * g;
          g = n.col1.y * r + n.col2.y * g;
          r = a;
          n = o.x + r - l.x - e;
          a = o.y + g - l.y - s;
          if (this.m_enableLimit) {
              this.m_axis =
                  y.MulMV(m, this.m_localXAxis1);
              this.m_a1 = (n + e) * this.m_axis.y - (a + s) * this.m_axis.x;
              this.m_a2 = r * this.m_axis.y - g * this.m_axis.x;
              var v = this.m_axis.x * n + this.m_axis.y * a;
              if (y.Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2 * F.b2_linearSlop) {
                  f = y.Clamp(v, -F.b2_maxLinearCorrection, F.b2_maxLinearCorrection);
                  b = y.Abs(v);
                  c = true
              } else if (v <= this.m_lowerTranslation) {
                  f = y.Clamp(v - this.m_lowerTranslation + F.b2_linearSlop, -F.b2_maxLinearCorrection, 0);
                  b = this.m_lowerTranslation - v;
                  c = true
              } else if (v >= this.m_upperTranslation) {
                  f =
                      y.Clamp(v - this.m_upperTranslation + F.b2_linearSlop, 0, F.b2_maxLinearCorrection);
                  b = v - this.m_upperTranslation;
                  c = true
              }
          }
          this.m_perp = y.MulMV(m, this.m_localYAxis1);
          this.m_s1 = (n + e) * this.m_perp.y - (a + s) * this.m_perp.x;
          this.m_s2 = r * this.m_perp.y - g * this.m_perp.x;
          m = new A;
          s = this.m_perp.x * n + this.m_perp.y * a;
          r = q - j - this.m_refAngle;
          b = y.Max(b, y.Abs(s));
          e = y.Abs(r);
          if (c) {
              c = this.m_invMassA;
              g = this.m_invMassB;
              n = this.m_invIA;
              a = this.m_invIB;
              this.m_K.col1.x = c + g + n * this.m_s1 * this.m_s1 + a * this.m_s2 * this.m_s2;
              this.m_K.col1.y = n * this.m_s1 +
                  a * this.m_s2;
              this.m_K.col1.z = n * this.m_s1 * this.m_a1 + a * this.m_s2 * this.m_a2;
              this.m_K.col2.x = this.m_K.col1.y;
              this.m_K.col2.y = n + a;
              this.m_K.col2.z = n * this.m_a1 + a * this.m_a2;
              this.m_K.col3.x = this.m_K.col1.z;
              this.m_K.col3.y = this.m_K.col2.z;
              this.m_K.col3.z = c + g + n * this.m_a1 * this.m_a1 + a * this.m_a2 * this.m_a2;
              this.m_K.Solve33(m, -s, -r, -f)
          } else {
              c = this.m_invMassA;
              g = this.m_invMassB;
              n = this.m_invIA;
              a = this.m_invIB;
              f = n * this.m_s1 + a * this.m_s2;
              v = n + a;
              this.m_K.col1.Set(c + g + n * this.m_s1 * this.m_s1 + a * this.m_s2 * this.m_s2, f, 0);
              this.m_K.col2.Set(f,
                  v, 0);
              f = this.m_K.Solve22(new w, -s, -r);
              m.x = f.x;
              m.y = f.y;
              m.z = 0
          }
          f = m.x * this.m_perp.x + m.z * this.m_axis.x;
          c = m.x * this.m_perp.y + m.z * this.m_axis.y;
          s = m.x * this.m_s1 + m.y + m.z * this.m_a1;
          m = m.x * this.m_s2 + m.y + m.z * this.m_a2;
          l.x -= this.m_invMassA * f;
          l.y -= this.m_invMassA * c;
          j -= this.m_invIA * s;
          o.x += this.m_invMassB * f;
          o.y += this.m_invMassB * c;
          q += this.m_invIB * m;
          d.m_sweep.a = j;
          h.m_sweep.a = q;
          d.SynchronizeTransform();
          h.SynchronizeTransform();
          return b <= F.b2_linearSlop && e <= F.b2_angularSlop
      };
      Box2D.inherit(O, Box2D.Dynamics.Joints.b2JointDef);
      O.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
      O.b2PrismaticJointDef = function() {
          Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
          this.localAnchorA = new w;
          this.localAnchorB = new w;
          this.localAxisA = new w
      };
      O.prototype.b2PrismaticJointDef = function() {
          this.__super.b2JointDef.call(this);
          this.type = I.e_prismaticJoint;
          this.localAxisA.Set(1, 0);
          this.referenceAngle = 0;
          this.enableLimit = false;
          this.upperTranslation = this.lowerTranslation = 0;
          this.enableMotor = false;
          this.motorSpeed = this.maxMotorForce =
              0
      };
      O.prototype.Initialize = function(d, h, l, j) {
          this.bodyA = d;
          this.bodyB = h;
          this.localAnchorA = this.bodyA.GetLocalPoint(l);
          this.localAnchorB = this.bodyB.GetLocalPoint(l);
          this.localAxisA = this.bodyA.GetLocalVector(j);
          this.referenceAngle = this.bodyB.GetAngle() - this.bodyA.GetAngle()
      };
      Box2D.inherit(E, Box2D.Dynamics.Joints.b2Joint);
      E.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
      E.b2PulleyJoint = function() {
          Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
          this.m_groundAnchor1 = new w;
          this.m_groundAnchor2 =
              new w;
          this.m_localAnchor1 = new w;
          this.m_localAnchor2 = new w;
          this.m_u1 = new w;
          this.m_u2 = new w
      };
      E.prototype.GetAnchorA = function() {
          return this.m_bodyA.GetWorldPoint(this.m_localAnchor1)
      };
      E.prototype.GetAnchorB = function() {
          return this.m_bodyB.GetWorldPoint(this.m_localAnchor2)
      };
      E.prototype.GetReactionForce = function(d) {
          if (d === undefined) d = 0;
          return new w(d * this.m_impulse * this.m_u2.x, d * this.m_impulse * this.m_u2.y)
      };
      E.prototype.GetReactionTorque = function() {
          return 0
      };
      E.prototype.GetGroundAnchorA = function() {
          var d =
              this.m_ground.m_xf.position.Copy();
          d.Add(this.m_groundAnchor1);
          return d
      };
      E.prototype.GetGroundAnchorB = function() {
          var d = this.m_ground.m_xf.position.Copy();
          d.Add(this.m_groundAnchor2);
          return d
      };
      E.prototype.GetLength1 = function() {
          var d = this.m_bodyA.GetWorldPoint(this.m_localAnchor1),
              h = d.x - (this.m_ground.m_xf.position.x + this.m_groundAnchor1.x);
          d = d.y - (this.m_ground.m_xf.position.y + this.m_groundAnchor1.y);
          return Math.sqrt(h * h + d * d)
      };
      E.prototype.GetLength2 = function() {
          var d = this.m_bodyB.GetWorldPoint(this.m_localAnchor2),
              h = d.x - (this.m_ground.m_xf.position.x + this.m_groundAnchor2.x);
          d = d.y - (this.m_ground.m_xf.position.y + this.m_groundAnchor2.y);
          return Math.sqrt(h * h + d * d)
      };
      E.prototype.GetRatio = function() {
          return this.m_ratio
      };
      E.prototype.b2PulleyJoint = function(d) {
          this.__super.b2Joint.call(this, d);
          this.m_ground = this.m_bodyA.m_world.m_groundBody;
          this.m_groundAnchor1.x = d.groundAnchorA.x - this.m_ground.m_xf.position.x;
          this.m_groundAnchor1.y = d.groundAnchorA.y - this.m_ground.m_xf.position.y;
          this.m_groundAnchor2.x = d.groundAnchorB.x -
              this.m_ground.m_xf.position.x;
          this.m_groundAnchor2.y = d.groundAnchorB.y - this.m_ground.m_xf.position.y;
          this.m_localAnchor1.SetV(d.localAnchorA);
          this.m_localAnchor2.SetV(d.localAnchorB);
          this.m_ratio = d.ratio;
          this.m_constant = d.lengthA + this.m_ratio * d.lengthB;
          this.m_maxLength1 = y.Min(d.maxLengthA, this.m_constant - this.m_ratio * E.b2_minPulleyLength);
          this.m_maxLength2 = y.Min(d.maxLengthB, (this.m_constant - E.b2_minPulleyLength) / this.m_ratio);
          this.m_limitImpulse2 = this.m_limitImpulse1 = this.m_impulse = 0
      };
      E.prototype.InitVelocityConstraints =
          function(d) {
              var h = this.m_bodyA,
                  l = this.m_bodyB,
                  j;
              j = h.m_xf.R;
              var o = this.m_localAnchor1.x - h.m_sweep.localCenter.x,
                  q = this.m_localAnchor1.y - h.m_sweep.localCenter.y,
                  n = j.col1.x * o + j.col2.x * q;
              q = j.col1.y * o + j.col2.y * q;
              o = n;
              j = l.m_xf.R;
              var a = this.m_localAnchor2.x - l.m_sweep.localCenter.x,
                  c = this.m_localAnchor2.y - l.m_sweep.localCenter.y;
              n = j.col1.x * a + j.col2.x * c;
              c = j.col1.y * a + j.col2.y * c;
              a = n;
              j = l.m_sweep.c.x + a;
              n = l.m_sweep.c.y + c;
              var g = this.m_ground.m_xf.position.x + this.m_groundAnchor2.x,
                  b = this.m_ground.m_xf.position.y +
                  this.m_groundAnchor2.y;
              this.m_u1.Set(h.m_sweep.c.x + o - (this.m_ground.m_xf.position.x + this.m_groundAnchor1.x), h.m_sweep.c.y + q - (this.m_ground.m_xf.position.y + this.m_groundAnchor1.y));
              this.m_u2.Set(j - g, n - b);
              j = this.m_u1.Length();
              n = this.m_u2.Length();
              j > F.b2_linearSlop ? this.m_u1.Multiply(1 / j) : this.m_u1.SetZero();
              n > F.b2_linearSlop ? this.m_u2.Multiply(1 / n) : this.m_u2.SetZero();
              if (this.m_constant - j - this.m_ratio * n > 0) {
                  this.m_state = I.e_inactiveLimit;
                  this.m_impulse = 0
              } else this.m_state = I.e_atUpperLimit;
              if (j < this.m_maxLength1) {
                  this.m_limitState1 =
                      I.e_inactiveLimit;
                  this.m_limitImpulse1 = 0
              } else this.m_limitState1 = I.e_atUpperLimit;
              if (n < this.m_maxLength2) {
                  this.m_limitState2 = I.e_inactiveLimit;
                  this.m_limitImpulse2 = 0
              } else this.m_limitState2 = I.e_atUpperLimit;
              j = o * this.m_u1.y - q * this.m_u1.x;
              n = a * this.m_u2.y - c * this.m_u2.x;
              this.m_limitMass1 = h.m_invMass + h.m_invI * j * j;
              this.m_limitMass2 = l.m_invMass + l.m_invI * n * n;
              this.m_pulleyMass = this.m_limitMass1 + this.m_ratio * this.m_ratio * this.m_limitMass2;
              this.m_limitMass1 = 1 / this.m_limitMass1;
              this.m_limitMass2 = 1 / this.m_limitMass2;
              this.m_pulleyMass = 1 / this.m_pulleyMass;
              if (d.warmStarting) {
                  this.m_impulse *= d.dtRatio;
                  this.m_limitImpulse1 *= d.dtRatio;
                  this.m_limitImpulse2 *= d.dtRatio;
                  d = (-this.m_impulse - this.m_limitImpulse1) * this.m_u1.x;
                  j = (-this.m_impulse - this.m_limitImpulse1) * this.m_u1.y;
                  n = (-this.m_ratio * this.m_impulse - this.m_limitImpulse2) * this.m_u2.x;
                  g = (-this.m_ratio * this.m_impulse - this.m_limitImpulse2) * this.m_u2.y;
                  h.m_linearVelocity.x += h.m_invMass * d;
                  h.m_linearVelocity.y += h.m_invMass * j;
                  h.m_angularVelocity += h.m_invI * (o * j - q * d);
                  l.m_linearVelocity.x +=
                      l.m_invMass * n;
                  l.m_linearVelocity.y += l.m_invMass * g;
                  l.m_angularVelocity += l.m_invI * (a * g - c * n)
              } else this.m_limitImpulse2 = this.m_limitImpulse1 = this.m_impulse = 0
          };
      E.prototype.SolveVelocityConstraints = function() {
          var d = this.m_bodyA,
              h = this.m_bodyB,
              l;
          l = d.m_xf.R;
          var j = this.m_localAnchor1.x - d.m_sweep.localCenter.x,
              o = this.m_localAnchor1.y - d.m_sweep.localCenter.y,
              q = l.col1.x * j + l.col2.x * o;
          o = l.col1.y * j + l.col2.y * o;
          j = q;
          l = h.m_xf.R;
          var n = this.m_localAnchor2.x - h.m_sweep.localCenter.x,
              a = this.m_localAnchor2.y - h.m_sweep.localCenter.y;
          q = l.col1.x * n + l.col2.x * a;
          a = l.col1.y * n + l.col2.y * a;
          n = q;
          var c = q = l = 0,
              g = 0;
          l = g = l = g = c = q = l = 0;
          if (this.m_state == I.e_atUpperLimit) {
              l = d.m_linearVelocity.x + -d.m_angularVelocity * o;
              q = d.m_linearVelocity.y + d.m_angularVelocity * j;
              c = h.m_linearVelocity.x + -h.m_angularVelocity * a;
              g = h.m_linearVelocity.y + h.m_angularVelocity * n;
              l = -(this.m_u1.x * l + this.m_u1.y * q) - this.m_ratio * (this.m_u2.x * c + this.m_u2.y * g);
              g = this.m_pulleyMass * -l;
              l = this.m_impulse;
              this.m_impulse = y.Max(0, this.m_impulse + g);
              g = this.m_impulse - l;
              l = -g * this.m_u1.x;
              q = -g * this.m_u1.y;
              c = -this.m_ratio * g * this.m_u2.x;
              g = -this.m_ratio * g * this.m_u2.y;
              d.m_linearVelocity.x += d.m_invMass * l;
              d.m_linearVelocity.y += d.m_invMass * q;
              d.m_angularVelocity += d.m_invI * (j * q - o * l);
              h.m_linearVelocity.x += h.m_invMass * c;
              h.m_linearVelocity.y += h.m_invMass * g;
              h.m_angularVelocity += h.m_invI * (n * g - a * c)
          }
          if (this.m_limitState1 == I.e_atUpperLimit) {
              l = d.m_linearVelocity.x + -d.m_angularVelocity * o;
              q = d.m_linearVelocity.y + d.m_angularVelocity * j;
              l = -(this.m_u1.x * l + this.m_u1.y * q);
              g = -this.m_limitMass1 * l;
              l = this.m_limitImpulse1;
              this.m_limitImpulse1 =
                  y.Max(0, this.m_limitImpulse1 + g);
              g = this.m_limitImpulse1 - l;
              l = -g * this.m_u1.x;
              q = -g * this.m_u1.y;
              d.m_linearVelocity.x += d.m_invMass * l;
              d.m_linearVelocity.y += d.m_invMass * q;
              d.m_angularVelocity += d.m_invI * (j * q - o * l)
          }
          if (this.m_limitState2 == I.e_atUpperLimit) {
              c = h.m_linearVelocity.x + -h.m_angularVelocity * a;
              g = h.m_linearVelocity.y + h.m_angularVelocity * n;
              l = -(this.m_u2.x * c + this.m_u2.y * g);
              g = -this.m_limitMass2 * l;
              l = this.m_limitImpulse2;
              this.m_limitImpulse2 = y.Max(0, this.m_limitImpulse2 + g);
              g = this.m_limitImpulse2 - l;
              c = -g * this.m_u2.x;
              g = -g * this.m_u2.y;
              h.m_linearVelocity.x += h.m_invMass * c;
              h.m_linearVelocity.y += h.m_invMass * g;
              h.m_angularVelocity += h.m_invI * (n * g - a * c)
          }
      };
      E.prototype.SolvePositionConstraints = function() {
          var d = this.m_bodyA,
              h = this.m_bodyB,
              l, j = this.m_ground.m_xf.position.x + this.m_groundAnchor1.x,
              o = this.m_ground.m_xf.position.y + this.m_groundAnchor1.y,
              q = this.m_ground.m_xf.position.x + this.m_groundAnchor2.x,
              n = this.m_ground.m_xf.position.y + this.m_groundAnchor2.y,
              a = 0,
              c = 0,
              g = 0,
              b = 0,
              e = l = 0,
              f = 0,
              m = 0,
              r = e = m = l = e = l = 0;
          if (this.m_state == I.e_atUpperLimit) {
              l =
                  d.m_xf.R;
              a = this.m_localAnchor1.x - d.m_sweep.localCenter.x;
              c = this.m_localAnchor1.y - d.m_sweep.localCenter.y;
              e = l.col1.x * a + l.col2.x * c;
              c = l.col1.y * a + l.col2.y * c;
              a = e;
              l = h.m_xf.R;
              g = this.m_localAnchor2.x - h.m_sweep.localCenter.x;
              b = this.m_localAnchor2.y - h.m_sweep.localCenter.y;
              e = l.col1.x * g + l.col2.x * b;
              b = l.col1.y * g + l.col2.y * b;
              g = e;
              l = d.m_sweep.c.x + a;
              e = d.m_sweep.c.y + c;
              f = h.m_sweep.c.x + g;
              m = h.m_sweep.c.y + b;
              this.m_u1.Set(l - j, e - o);
              this.m_u2.Set(f - q, m - n);
              l = this.m_u1.Length();
              e = this.m_u2.Length();
              l > F.b2_linearSlop ? this.m_u1.Multiply(1 /
                  l) : this.m_u1.SetZero();
              e > F.b2_linearSlop ? this.m_u2.Multiply(1 / e) : this.m_u2.SetZero();
              l = this.m_constant - l - this.m_ratio * e;
              r = y.Max(r, -l);
              l = y.Clamp(l + F.b2_linearSlop, -F.b2_maxLinearCorrection, 0);
              m = -this.m_pulleyMass * l;
              l = -m * this.m_u1.x;
              e = -m * this.m_u1.y;
              f = -this.m_ratio * m * this.m_u2.x;
              m = -this.m_ratio * m * this.m_u2.y;
              d.m_sweep.c.x += d.m_invMass * l;
              d.m_sweep.c.y += d.m_invMass * e;
              d.m_sweep.a += d.m_invI * (a * e - c * l);
              h.m_sweep.c.x += h.m_invMass * f;
              h.m_sweep.c.y += h.m_invMass * m;
              h.m_sweep.a += h.m_invI * (g * m - b * f);
              d.SynchronizeTransform();
              h.SynchronizeTransform()
          }
          if (this.m_limitState1 == I.e_atUpperLimit) {
              l = d.m_xf.R;
              a = this.m_localAnchor1.x - d.m_sweep.localCenter.x;
              c = this.m_localAnchor1.y - d.m_sweep.localCenter.y;
              e = l.col1.x * a + l.col2.x * c;
              c = l.col1.y * a + l.col2.y * c;
              a = e;
              l = d.m_sweep.c.x + a;
              e = d.m_sweep.c.y + c;
              this.m_u1.Set(l - j, e - o);
              l = this.m_u1.Length();
              if (l > F.b2_linearSlop) {
                  this.m_u1.x *= 1 / l;
                  this.m_u1.y *= 1 / l
              } else this.m_u1.SetZero();
              l = this.m_maxLength1 - l;
              r = y.Max(r, -l);
              l = y.Clamp(l + F.b2_linearSlop, -F.b2_maxLinearCorrection, 0);
              m = -this.m_limitMass1 * l;
              l = -m * this.m_u1.x;
              e = -m * this.m_u1.y;
              d.m_sweep.c.x += d.m_invMass * l;
              d.m_sweep.c.y += d.m_invMass * e;
              d.m_sweep.a += d.m_invI * (a * e - c * l);
              d.SynchronizeTransform()
          }
          if (this.m_limitState2 == I.e_atUpperLimit) {
              l = h.m_xf.R;
              g = this.m_localAnchor2.x - h.m_sweep.localCenter.x;
              b = this.m_localAnchor2.y - h.m_sweep.localCenter.y;
              e = l.col1.x * g + l.col2.x * b;
              b = l.col1.y * g + l.col2.y * b;
              g = e;
              f = h.m_sweep.c.x + g;
              m = h.m_sweep.c.y + b;
              this.m_u2.Set(f - q, m - n);
              e = this.m_u2.Length();
              if (e > F.b2_linearSlop) {
                  this.m_u2.x *= 1 / e;
                  this.m_u2.y *= 1 / e
              } else this.m_u2.SetZero();
              l = this.m_maxLength2 - e;
              r = y.Max(r, -l);
              l = y.Clamp(l + F.b2_linearSlop, -F.b2_maxLinearCorrection, 0);
              m = -this.m_limitMass2 * l;
              f = -m * this.m_u2.x;
              m = -m * this.m_u2.y;
              h.m_sweep.c.x += h.m_invMass * f;
              h.m_sweep.c.y += h.m_invMass * m;
              h.m_sweep.a += h.m_invI * (g * m - b * f);
              h.SynchronizeTransform()
          }
          return r < F.b2_linearSlop
      };
      Box2D.postDefs.push(function() {
          Box2D.Dynamics.Joints.b2PulleyJoint.b2_minPulleyLength = 2
      });
      Box2D.inherit(R, Box2D.Dynamics.Joints.b2JointDef);
      R.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
      R.b2PulleyJointDef =
          function() {
              Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
              this.groundAnchorA = new w;
              this.groundAnchorB = new w;
              this.localAnchorA = new w;
              this.localAnchorB = new w
          };
      R.prototype.b2PulleyJointDef = function() {
          this.__super.b2JointDef.call(this);
          this.type = I.e_pulleyJoint;
          this.groundAnchorA.Set(-1, 1);
          this.groundAnchorB.Set(1, 1);
          this.localAnchorA.Set(-1, 0);
          this.localAnchorB.Set(1, 0);
          this.maxLengthB = this.lengthB = this.maxLengthA = this.lengthA = 0;
          this.ratio = 1;
          this.collideConnected = true
      };
      R.prototype.Initialize =
          function(d, h, l, j, o, q, n) {
              if (n === undefined) n = 0;
              this.bodyA = d;
              this.bodyB = h;
              this.groundAnchorA.SetV(l);
              this.groundAnchorB.SetV(j);
              this.localAnchorA = this.bodyA.GetLocalPoint(o);
              this.localAnchorB = this.bodyB.GetLocalPoint(q);
              d = o.x - l.x;
              l = o.y - l.y;
              this.lengthA = Math.sqrt(d * d + l * l);
              l = q.x - j.x;
              j = q.y - j.y;
              this.lengthB = Math.sqrt(l * l + j * j);
              this.ratio = n;
              n = this.lengthA + this.ratio * this.lengthB;
              this.maxLengthA = n - this.ratio * E.b2_minPulleyLength;
              this.maxLengthB = (n - E.b2_minPulleyLength) / this.ratio
          };
      Box2D.inherit(N, Box2D.Dynamics.Joints.b2Joint);
      N.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
      N.b2RevoluteJoint = function() {
          Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
          this.K = new G;
          this.K1 = new G;
          this.K2 = new G;
          this.K3 = new G;
          this.impulse3 = new A;
          this.impulse2 = new w;
          this.reduced = new w;
          this.m_localAnchor1 = new w;
          this.m_localAnchor2 = new w;
          this.m_impulse = new A;
          this.m_mass = new K
      };
      N.prototype.GetAnchorA = function() {
          return this.m_bodyA.GetWorldPoint(this.m_localAnchor1)
      };
      N.prototype.GetAnchorB = function() {
          return this.m_bodyB.GetWorldPoint(this.m_localAnchor2)
      };
      N.prototype.GetReactionForce = function(d) {
          if (d === undefined) d = 0;
          return new w(d * this.m_impulse.x, d * this.m_impulse.y)
      };
      N.prototype.GetReactionTorque = function(d) {
          if (d === undefined) d = 0;
          return d * this.m_impulse.z
      };
      N.prototype.GetJointAngle = function() {
          return this.m_bodyB.m_sweep.a - this.m_bodyA.m_sweep.a - this.m_referenceAngle
      };
      N.prototype.GetJointSpeed = function() {
          return this.m_bodyB.m_angularVelocity - this.m_bodyA.m_angularVelocity
      };
      N.prototype.IsLimitEnabled = function() {
          return this.m_enableLimit
      };
      N.prototype.EnableLimit =
          function(d) {
              this.m_enableLimit = d
          };
      N.prototype.GetLowerLimit = function() {
          return this.m_lowerAngle
      };
      N.prototype.GetUpperLimit = function() {
          return this.m_upperAngle
      };
      N.prototype.SetLimits = function(d, h) {
          if (d === undefined) d = 0;
          if (h === undefined) h = 0;
          this.m_lowerAngle = d;
          this.m_upperAngle = h
      };
      N.prototype.IsMotorEnabled = function() {
          this.m_bodyA.SetAwake(true);
          this.m_bodyB.SetAwake(true);
          return this.m_enableMotor
      };
      N.prototype.EnableMotor = function(d) {
          this.m_enableMotor = d
      };
      N.prototype.SetMotorSpeed = function(d) {
          if (d ===
              undefined) d = 0;
          this.m_bodyA.SetAwake(true);
          this.m_bodyB.SetAwake(true);
          this.m_motorSpeed = d
      };
      N.prototype.GetMotorSpeed = function() {
          return this.m_motorSpeed
      };
      N.prototype.SetMaxMotorTorque = function(d) {
          if (d === undefined) d = 0;
          this.m_maxMotorTorque = d
      };
      N.prototype.GetMotorTorque = function() {
          return this.m_maxMotorTorque
      };
      N.prototype.b2RevoluteJoint = function(d) {
          this.__super.b2Joint.call(this, d);
          this.m_localAnchor1.SetV(d.localAnchorA);
          this.m_localAnchor2.SetV(d.localAnchorB);
          this.m_referenceAngle = d.referenceAngle;
          this.m_impulse.SetZero();
          this.m_motorImpulse = 0;
          this.m_lowerAngle = d.lowerAngle;
          this.m_upperAngle = d.upperAngle;
          this.m_maxMotorTorque = d.maxMotorTorque;
          this.m_motorSpeed = d.motorSpeed;
          this.m_enableLimit = d.enableLimit;
          this.m_enableMotor = d.enableMotor;
          this.m_limitState = I.e_inactiveLimit
      };
      N.prototype.InitVelocityConstraints = function(d) {
          var h = this.m_bodyA,
              l = this.m_bodyB,
              j, o = 0;
          j = h.m_xf.R;
          var q = this.m_localAnchor1.x - h.m_sweep.localCenter.x,
              n = this.m_localAnchor1.y - h.m_sweep.localCenter.y;
          o = j.col1.x * q + j.col2.x *
              n;
          n = j.col1.y * q + j.col2.y * n;
          q = o;
          j = l.m_xf.R;
          var a = this.m_localAnchor2.x - l.m_sweep.localCenter.x,
              c = this.m_localAnchor2.y - l.m_sweep.localCenter.y;
          o = j.col1.x * a + j.col2.x * c;
          c = j.col1.y * a + j.col2.y * c;
          a = o;
          j = h.m_invMass;
          o = l.m_invMass;
          var g = h.m_invI,
              b = l.m_invI;
          this.m_mass.col1.x = j + o + n * n * g + c * c * b;
          this.m_mass.col2.x = -n * q * g - c * a * b;
          this.m_mass.col3.x = -n * g - c * b;
          this.m_mass.col1.y = this.m_mass.col2.x;
          this.m_mass.col2.y = j + o + q * q * g + a * a * b;
          this.m_mass.col3.y = q * g + a * b;
          this.m_mass.col1.z = this.m_mass.col3.x;
          this.m_mass.col2.z = this.m_mass.col3.y;
          this.m_mass.col3.z = g + b;
          this.m_motorMass = 1 / (g + b);
          if (this.m_enableMotor == false) this.m_motorImpulse = 0;
          if (this.m_enableLimit) {
              var e = l.m_sweep.a - h.m_sweep.a - this.m_referenceAngle;
              if (y.Abs(this.m_upperAngle - this.m_lowerAngle) < 2 * F.b2_angularSlop) this.m_limitState = I.e_equalLimits;
              else if (e <= this.m_lowerAngle) {
                  if (this.m_limitState != I.e_atLowerLimit) this.m_impulse.z = 0;
                  this.m_limitState = I.e_atLowerLimit
              } else if (e >= this.m_upperAngle) {
                  if (this.m_limitState != I.e_atUpperLimit) this.m_impulse.z = 0;
                  this.m_limitState =
                      I.e_atUpperLimit
              } else {
                  this.m_limitState = I.e_inactiveLimit;
                  this.m_impulse.z = 0
              }
          } else this.m_limitState = I.e_inactiveLimit;
          if (d.warmStarting) {
              this.m_impulse.x *= d.dtRatio;
              this.m_impulse.y *= d.dtRatio;
              this.m_motorImpulse *= d.dtRatio;
              d = this.m_impulse.x;
              e = this.m_impulse.y;
              h.m_linearVelocity.x -= j * d;
              h.m_linearVelocity.y -= j * e;
              h.m_angularVelocity -= g * (q * e - n * d + this.m_motorImpulse + this.m_impulse.z);
              l.m_linearVelocity.x += o * d;
              l.m_linearVelocity.y += o * e;
              l.m_angularVelocity += b * (a * e - c * d + this.m_motorImpulse + this.m_impulse.z)
          } else {
              this.m_impulse.SetZero();
              this.m_motorImpulse = 0
          }
      };
      N.prototype.SolveVelocityConstraints = function(d) {
          var h = this.m_bodyA,
              l = this.m_bodyB,
              j = 0,
              o = j = 0,
              q = 0,
              n = 0,
              a = 0,
              c = h.m_linearVelocity,
              g = h.m_angularVelocity,
              b = l.m_linearVelocity,
              e = l.m_angularVelocity,
              f = h.m_invMass,
              m = l.m_invMass,
              r = h.m_invI,
              s = l.m_invI;
          if (this.m_enableMotor && this.m_limitState != I.e_equalLimits) {
              o = this.m_motorMass * -(e - g - this.m_motorSpeed);
              q = this.m_motorImpulse;
              n = d.dt * this.m_maxMotorTorque;
              this.m_motorImpulse = y.Clamp(this.m_motorImpulse + o, -n, n);
              o = this.m_motorImpulse - q;
              g -=
                  r * o;
              e += s * o
          }
          if (this.m_enableLimit && this.m_limitState != I.e_inactiveLimit) {
              d = h.m_xf.R;
              o = this.m_localAnchor1.x - h.m_sweep.localCenter.x;
              q = this.m_localAnchor1.y - h.m_sweep.localCenter.y;
              j = d.col1.x * o + d.col2.x * q;
              q = d.col1.y * o + d.col2.y * q;
              o = j;
              d = l.m_xf.R;
              n = this.m_localAnchor2.x - l.m_sweep.localCenter.x;
              a = this.m_localAnchor2.y - l.m_sweep.localCenter.y;
              j = d.col1.x * n + d.col2.x * a;
              a = d.col1.y * n + d.col2.y * a;
              n = j;
              d = b.x + -e * a - c.x - -g * q;
              var v = b.y + e * n - c.y - g * o;
              this.m_mass.Solve33(this.impulse3, -d, -v, -(e - g));
              if (this.m_limitState ==
                  I.e_equalLimits) this.m_impulse.Add(this.impulse3);
              else if (this.m_limitState == I.e_atLowerLimit) {
                  j = this.m_impulse.z + this.impulse3.z;
                  if (j < 0) {
                      this.m_mass.Solve22(this.reduced, -d, -v);
                      this.impulse3.x = this.reduced.x;
                      this.impulse3.y = this.reduced.y;
                      this.impulse3.z = -this.m_impulse.z;
                      this.m_impulse.x += this.reduced.x;
                      this.m_impulse.y += this.reduced.y;
                      this.m_impulse.z = 0
                  }
              } else if (this.m_limitState == I.e_atUpperLimit) {
                  j = this.m_impulse.z + this.impulse3.z;
                  if (j > 0) {
                      this.m_mass.Solve22(this.reduced, -d, -v);
                      this.impulse3.x =
                          this.reduced.x;
                      this.impulse3.y = this.reduced.y;
                      this.impulse3.z = -this.m_impulse.z;
                      this.m_impulse.x += this.reduced.x;
                      this.m_impulse.y += this.reduced.y;
                      this.m_impulse.z = 0
                  }
              }
              c.x -= f * this.impulse3.x;
              c.y -= f * this.impulse3.y;
              g -= r * (o * this.impulse3.y - q * this.impulse3.x + this.impulse3.z);
              b.x += m * this.impulse3.x;
              b.y += m * this.impulse3.y;
              e += s * (n * this.impulse3.y - a * this.impulse3.x + this.impulse3.z)
          } else {
              d = h.m_xf.R;
              o = this.m_localAnchor1.x - h.m_sweep.localCenter.x;
              q = this.m_localAnchor1.y - h.m_sweep.localCenter.y;
              j = d.col1.x * o +
                  d.col2.x * q;
              q = d.col1.y * o + d.col2.y * q;
              o = j;
              d = l.m_xf.R;
              n = this.m_localAnchor2.x - l.m_sweep.localCenter.x;
              a = this.m_localAnchor2.y - l.m_sweep.localCenter.y;
              j = d.col1.x * n + d.col2.x * a;
              a = d.col1.y * n + d.col2.y * a;
              n = j;
              this.m_mass.Solve22(this.impulse2, -(b.x + -e * a - c.x - -g * q), -(b.y + e * n - c.y - g * o));
              this.m_impulse.x += this.impulse2.x;
              this.m_impulse.y += this.impulse2.y;
              c.x -= f * this.impulse2.x;
              c.y -= f * this.impulse2.y;
              g -= r * (o * this.impulse2.y - q * this.impulse2.x);
              b.x += m * this.impulse2.x;
              b.y += m * this.impulse2.y;
              e += s * (n * this.impulse2.y -
                  a * this.impulse2.x)
          }
          h.m_linearVelocity.SetV(c);
          h.m_angularVelocity = g;
          l.m_linearVelocity.SetV(b);
          l.m_angularVelocity = e
      };
      N.prototype.SolvePositionConstraints = function() {
          var d = 0,
              h, l = this.m_bodyA,
              j = this.m_bodyB,
              o = 0,
              q = h = 0,
              n = 0,
              a = 0;
          if (this.m_enableLimit && this.m_limitState != I.e_inactiveLimit) {
              d = j.m_sweep.a - l.m_sweep.a - this.m_referenceAngle;
              var c = 0;
              if (this.m_limitState == I.e_equalLimits) {
                  d = y.Clamp(d - this.m_lowerAngle, -F.b2_maxAngularCorrection, F.b2_maxAngularCorrection);
                  c = -this.m_motorMass * d;
                  o = y.Abs(d)
              } else if (this.m_limitState ==
                  I.e_atLowerLimit) {
                  d = d - this.m_lowerAngle;
                  o = -d;
                  d = y.Clamp(d + F.b2_angularSlop, -F.b2_maxAngularCorrection, 0);
                  c = -this.m_motorMass * d
              } else if (this.m_limitState == I.e_atUpperLimit) {
                  o = d = d - this.m_upperAngle;
                  d = y.Clamp(d - F.b2_angularSlop, 0, F.b2_maxAngularCorrection);
                  c = -this.m_motorMass * d
              }
              l.m_sweep.a -= l.m_invI * c;
              j.m_sweep.a += j.m_invI * c;
              l.SynchronizeTransform();
              j.SynchronizeTransform()
          }
          h = l.m_xf.R;
          c = this.m_localAnchor1.x - l.m_sweep.localCenter.x;
          d = this.m_localAnchor1.y - l.m_sweep.localCenter.y;
          q = h.col1.x * c + h.col2.x *
              d;
          d = h.col1.y * c + h.col2.y * d;
          c = q;
          h = j.m_xf.R;
          var g = this.m_localAnchor2.x - j.m_sweep.localCenter.x,
              b = this.m_localAnchor2.y - j.m_sweep.localCenter.y;
          q = h.col1.x * g + h.col2.x * b;
          b = h.col1.y * g + h.col2.y * b;
          g = q;
          n = j.m_sweep.c.x + g - l.m_sweep.c.x - c;
          a = j.m_sweep.c.y + b - l.m_sweep.c.y - d;
          var e = n * n + a * a;
          h = Math.sqrt(e);
          q = l.m_invMass;
          var f = j.m_invMass,
              m = l.m_invI,
              r = j.m_invI,
              s = 10 * F.b2_linearSlop;
          if (e > s * s) {
              e = 1 / (q + f);
              n = e * -n;
              a = e * -a;
              l.m_sweep.c.x -= 0.5 * q * n;
              l.m_sweep.c.y -= 0.5 * q * a;
              j.m_sweep.c.x += 0.5 * f * n;
              j.m_sweep.c.y += 0.5 * f * a;
              n = j.m_sweep.c.x +
                  g - l.m_sweep.c.x - c;
              a = j.m_sweep.c.y + b - l.m_sweep.c.y - d
          }
          this.K1.col1.x = q + f;
          this.K1.col2.x = 0;
          this.K1.col1.y = 0;
          this.K1.col2.y = q + f;
          this.K2.col1.x = m * d * d;
          this.K2.col2.x = -m * c * d;
          this.K2.col1.y = -m * c * d;
          this.K2.col2.y = m * c * c;
          this.K3.col1.x = r * b * b;
          this.K3.col2.x = -r * g * b;
          this.K3.col1.y = -r * g * b;
          this.K3.col2.y = r * g * g;
          this.K.SetM(this.K1);
          this.K.AddM(this.K2);
          this.K.AddM(this.K3);
          this.K.Solve(N.tImpulse, -n, -a);
          n = N.tImpulse.x;
          a = N.tImpulse.y;
          l.m_sweep.c.x -= l.m_invMass * n;
          l.m_sweep.c.y -= l.m_invMass * a;
          l.m_sweep.a -= l.m_invI * (c *
              a - d * n);
          j.m_sweep.c.x += j.m_invMass * n;
          j.m_sweep.c.y += j.m_invMass * a;
          j.m_sweep.a += j.m_invI * (g * a - b * n);
          l.SynchronizeTransform();
          j.SynchronizeTransform();
          return h <= F.b2_linearSlop && o <= F.b2_angularSlop
      };
      Box2D.postDefs.push(function() {
          Box2D.Dynamics.Joints.b2RevoluteJoint.tImpulse = new w
      });
      Box2D.inherit(S, Box2D.Dynamics.Joints.b2JointDef);
      S.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
      S.b2RevoluteJointDef = function() {
          Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
          this.localAnchorA =
              new w;
          this.localAnchorB = new w
      };
      S.prototype.b2RevoluteJointDef = function() {
          this.__super.b2JointDef.call(this);
          this.type = I.e_revoluteJoint;
          this.localAnchorA.Set(0, 0);
          this.localAnchorB.Set(0, 0);
          this.motorSpeed = this.maxMotorTorque = this.upperAngle = this.lowerAngle = this.referenceAngle = 0;
          this.enableMotor = this.enableLimit = false
      };
      S.prototype.Initialize = function(d, h, l) {
          this.bodyA = d;
          this.bodyB = h;
          this.localAnchorA = this.bodyA.GetLocalPoint(l);
          this.localAnchorB = this.bodyB.GetLocalPoint(l);
          this.referenceAngle = this.bodyB.GetAngle() -
              this.bodyA.GetAngle()
      };
      Box2D.inherit(aa, Box2D.Dynamics.Joints.b2Joint);
      aa.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
      aa.b2WeldJoint = function() {
          Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
          this.m_localAnchorA = new w;
          this.m_localAnchorB = new w;
          this.m_impulse = new A;
          this.m_mass = new K
      };
      aa.prototype.GetAnchorA = function() {
          return this.m_bodyA.GetWorldPoint(this.m_localAnchorA)
      };
      aa.prototype.GetAnchorB = function() {
          return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
      };
      aa.prototype.GetReactionForce =
          function(d) {
              if (d === undefined) d = 0;
              return new w(d * this.m_impulse.x, d * this.m_impulse.y)
          };
      aa.prototype.GetReactionTorque = function(d) {
          if (d === undefined) d = 0;
          return d * this.m_impulse.z
      };
      aa.prototype.b2WeldJoint = function(d) {
          this.__super.b2Joint.call(this, d);
          this.m_localAnchorA.SetV(d.localAnchorA);
          this.m_localAnchorB.SetV(d.localAnchorB);
          this.m_referenceAngle = d.referenceAngle;
          this.m_impulse.SetZero();
          this.m_mass = new K
      };
      aa.prototype.InitVelocityConstraints = function(d) {
          var h, l = 0,
              j = this.m_bodyA,
              o = this.m_bodyB;
          h = j.m_xf.R;
          var q = this.m_localAnchorA.x - j.m_sweep.localCenter.x,
              n = this.m_localAnchorA.y - j.m_sweep.localCenter.y;
          l = h.col1.x * q + h.col2.x * n;
          n = h.col1.y * q + h.col2.y * n;
          q = l;
          h = o.m_xf.R;
          var a = this.m_localAnchorB.x - o.m_sweep.localCenter.x,
              c = this.m_localAnchorB.y - o.m_sweep.localCenter.y;
          l = h.col1.x * a + h.col2.x * c;
          c = h.col1.y * a + h.col2.y * c;
          a = l;
          h = j.m_invMass;
          l = o.m_invMass;
          var g = j.m_invI,
              b = o.m_invI;
          this.m_mass.col1.x = h + l + n * n * g + c * c * b;
          this.m_mass.col2.x = -n * q * g - c * a * b;
          this.m_mass.col3.x = -n * g - c * b;
          this.m_mass.col1.y = this.m_mass.col2.x;
          this.m_mass.col2.y = h + l + q * q * g + a * a * b;
          this.m_mass.col3.y = q * g + a * b;
          this.m_mass.col1.z = this.m_mass.col3.x;
          this.m_mass.col2.z = this.m_mass.col3.y;
          this.m_mass.col3.z = g + b;
          if (d.warmStarting) {
              this.m_impulse.x *= d.dtRatio;
              this.m_impulse.y *= d.dtRatio;
              this.m_impulse.z *= d.dtRatio;
              j.m_linearVelocity.x -= h * this.m_impulse.x;
              j.m_linearVelocity.y -= h * this.m_impulse.y;
              j.m_angularVelocity -= g * (q * this.m_impulse.y - n * this.m_impulse.x + this.m_impulse.z);
              o.m_linearVelocity.x += l * this.m_impulse.x;
              o.m_linearVelocity.y += l * this.m_impulse.y;
              o.m_angularVelocity += b * (a * this.m_impulse.y - c * this.m_impulse.x + this.m_impulse.z)
          } else this.m_impulse.SetZero()
      };
      aa.prototype.SolveVelocityConstraints = function() {
          var d, h = 0,
              l = this.m_bodyA,
              j = this.m_bodyB,
              o = l.m_linearVelocity,
              q = l.m_angularVelocity,
              n = j.m_linearVelocity,
              a = j.m_angularVelocity,
              c = l.m_invMass,
              g = j.m_invMass,
              b = l.m_invI,
              e = j.m_invI;
          d = l.m_xf.R;
          var f = this.m_localAnchorA.x - l.m_sweep.localCenter.x,
              m = this.m_localAnchorA.y - l.m_sweep.localCenter.y;
          h = d.col1.x * f + d.col2.x * m;
          m = d.col1.y * f + d.col2.y * m;
          f = h;
          d =
              j.m_xf.R;
          var r = this.m_localAnchorB.x - j.m_sweep.localCenter.x,
              s = this.m_localAnchorB.y - j.m_sweep.localCenter.y;
          h = d.col1.x * r + d.col2.x * s;
          s = d.col1.y * r + d.col2.y * s;
          r = h;
          d = n.x - a * s - o.x + q * m;
          h = n.y + a * r - o.y - q * f;
          var v = a - q,
              t = new A;
          this.m_mass.Solve33(t, -d, -h, -v);
          this.m_impulse.Add(t);
          o.x -= c * t.x;
          o.y -= c * t.y;
          q -= b * (f * t.y - m * t.x + t.z);
          n.x += g * t.x;
          n.y += g * t.y;
          a += e * (r * t.y - s * t.x + t.z);
          l.m_angularVelocity = q;
          j.m_angularVelocity = a
      };
      aa.prototype.SolvePositionConstraints = function() {
          var d, h = 0,
              l = this.m_bodyA,
              j = this.m_bodyB;
          d = l.m_xf.R;
          var o = this.m_localAnchorA.x - l.m_sweep.localCenter.x,
              q = this.m_localAnchorA.y - l.m_sweep.localCenter.y;
          h = d.col1.x * o + d.col2.x * q;
          q = d.col1.y * o + d.col2.y * q;
          o = h;
          d = j.m_xf.R;
          var n = this.m_localAnchorB.x - j.m_sweep.localCenter.x,
              a = this.m_localAnchorB.y - j.m_sweep.localCenter.y;
          h = d.col1.x * n + d.col2.x * a;
          a = d.col1.y * n + d.col2.y * a;
          n = h;
          d = l.m_invMass;
          h = j.m_invMass;
          var c = l.m_invI,
              g = j.m_invI,
              b = j.m_sweep.c.x + n - l.m_sweep.c.x - o,
              e = j.m_sweep.c.y + a - l.m_sweep.c.y - q,
              f = j.m_sweep.a - l.m_sweep.a - this.m_referenceAngle,
              m = 10 * F.b2_linearSlop,
              r = Math.sqrt(b * b + e * e),
              s = y.Abs(f);
          if (r > m) {
              c *= 1;
              g *= 1
          }
          this.m_mass.col1.x = d + h + q * q * c + a * a * g;
          this.m_mass.col2.x = -q * o * c - a * n * g;
          this.m_mass.col3.x = -q * c - a * g;
          this.m_mass.col1.y = this.m_mass.col2.x;
          this.m_mass.col2.y = d + h + o * o * c + n * n * g;
          this.m_mass.col3.y = o * c + n * g;
          this.m_mass.col1.z = this.m_mass.col3.x;
          this.m_mass.col2.z = this.m_mass.col3.y;
          this.m_mass.col3.z = c + g;
          m = new A;
          this.m_mass.Solve33(m, -b, -e, -f);
          l.m_sweep.c.x -= d * m.x;
          l.m_sweep.c.y -= d * m.y;
          l.m_sweep.a -= c * (o * m.y - q * m.x + m.z);
          j.m_sweep.c.x += h * m.x;
          j.m_sweep.c.y += h * m.y;
          j.m_sweep.a += g * (n * m.y - a * m.x + m.z);
          l.SynchronizeTransform();
          j.SynchronizeTransform();
          return r <= F.b2_linearSlop && s <= F.b2_angularSlop
      };
      Box2D.inherit(Z, Box2D.Dynamics.Joints.b2JointDef);
      Z.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
      Z.b2WeldJointDef = function() {
          Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
          this.localAnchorA = new w;
          this.localAnchorB = new w
      };
      Z.prototype.b2WeldJointDef = function() {
          this.__super.b2JointDef.call(this);
          this.type = I.e_weldJoint;
          this.referenceAngle =
              0
      };
      Z.prototype.Initialize = function(d, h, l) {
          this.bodyA = d;
          this.bodyB = h;
          this.localAnchorA.SetV(this.bodyA.GetLocalPoint(l));
          this.localAnchorB.SetV(this.bodyB.GetLocalPoint(l));
          this.referenceAngle = this.bodyB.GetAngle() - this.bodyA.GetAngle()
      }
  })();
  (function() {
      var F = Box2D.Dynamics.b2DebugDraw;
      F.b2DebugDraw = function() {
          this.m_xformScale = this.m_fillAlpha = this.m_alpha = this.m_lineThickness = this.m_drawScale = 1;
          var G = this;
          this.m_sprite = {
              graphics: {
                  clear: function() {
                      G.m_ctx.clearRect(0, 0, G.m_ctx.canvas.width, G.m_ctx.canvas.height)
                  }
              }
          }
      };
      F.prototype._color = function(G, K) {
          return "rgba(" + ((G & 16711680) >> 16) + "," + ((G & 65280) >> 8) + "," + (G & 255) + "," + K + ")"
      };
      F.prototype.b2DebugDraw = function() {
          this.m_drawFlags = 0
      };
      F.prototype.SetFlags = function(G) {
          if (G === undefined) G = 0;
          this.m_drawFlags =
              G
      };
      F.prototype.GetFlags = function() {
          return this.m_drawFlags
      };
      F.prototype.AppendFlags = function(G) {
          if (G === undefined) G = 0;
          this.m_drawFlags |= G
      };
      F.prototype.ClearFlags = function(G) {
          if (G === undefined) G = 0;
          this.m_drawFlags &= ~G
      };
      F.prototype.SetSprite = function(G) {
          this.m_ctx = G
      };
      F.prototype.GetSprite = function() {
          return this.m_ctx
      };
      F.prototype.SetDrawScale = function(G) {
          if (G === undefined) G = 0;
          this.m_drawScale = G
      };
      F.prototype.GetDrawScale = function() {
          return this.m_drawScale
      };
      F.prototype.SetLineThickness = function(G) {
          if (G ===
              undefined) G = 0;
          this.m_lineThickness = G;
          this.m_ctx.strokeWidth = G
      };
      F.prototype.GetLineThickness = function() {
          return this.m_lineThickness
      };
      F.prototype.SetAlpha = function(G) {
          if (G === undefined) G = 0;
          this.m_alpha = G
      };
      F.prototype.GetAlpha = function() {
          return this.m_alpha
      };
      F.prototype.SetFillAlpha = function(G) {
          if (G === undefined) G = 0;
          this.m_fillAlpha = G
      };
      F.prototype.GetFillAlpha = function() {
          return this.m_fillAlpha
      };
      F.prototype.SetXFormScale = function(G) {
          if (G === undefined) G = 0;
          this.m_xformScale = G
      };
      F.prototype.GetXFormScale = function() {
          return this.m_xformScale
      };
      F.prototype.DrawPolygon = function(G, K, y) {
          if (K) {
              var w = this.m_ctx,
                  A = this.m_drawScale;
              w.beginPath();
              w.strokeStyle = this._color(y.color, this.m_alpha);
              w.moveTo(G[0].x * A, G[0].y * A);
              for (y = 1; y < K; y++) w.lineTo(G[y].x * A, G[y].y * A);
              w.lineTo(G[0].x * A, G[0].y * A);
              w.closePath();
              w.stroke()
          }
      };
      F.prototype.DrawSolidPolygon = function(G, K, y) {
          if (K) {
              var w = this.m_ctx,
                  A = this.m_drawScale;
              w.beginPath();
              w.strokeStyle = this._color(y.color, this.m_alpha);
              w.fillStyle = this._color(y.color, this.m_fillAlpha);
              w.moveTo(G[0].x * A, G[0].y * A);
              for (y =
                  1; y < K; y++) w.lineTo(G[y].x * A, G[y].y * A);
              w.lineTo(G[0].x * A, G[0].y * A);
              w.closePath();
              w.fill();
              w.stroke()
          }
      };
      F.prototype.DrawCircle = function(G, K, y) {
          if (K) {
              var w = this.m_ctx,
                  A = this.m_drawScale;
              w.beginPath();
              w.strokeStyle = this._color(y.color, this.m_alpha);
              w.arc(G.x * A, G.y * A, K * A, 0, Math.PI * 2, true);
              w.closePath();
              w.stroke()
          }
      };
      F.prototype.DrawSolidCircle = function(G, K, y, w) {
          if (K) {
              var A = this.m_ctx,
                  U = this.m_drawScale,
                  p = G.x * U,
                  B = G.y * U;
              A.moveTo(0, 0);
              A.beginPath();
              A.strokeStyle = this._color(w.color, this.m_alpha);
              A.fillStyle =
                  this._color(w.color, this.m_fillAlpha);
              A.arc(p, B, K * U, 0, Math.PI * 2, true);
              A.moveTo(p, B);
              A.lineTo((G.x + y.x * K) * U, (G.y + y.y * K) * U);
              A.closePath();
              A.fill();
              A.stroke()
          }
      };
      F.prototype.DrawSegment = function(G, K, y) {
          var w = this.m_ctx,
              A = this.m_drawScale;
          w.strokeStyle = this._color(y.color, this.m_alpha);
          w.beginPath();
          w.moveTo(G.x * A, G.y * A);
          w.lineTo(K.x * A, K.y * A);
          w.closePath();
          w.stroke()
      };
      F.prototype.DrawTransform = function(G) {
          var K = this.m_ctx,
              y = this.m_drawScale;
          K.beginPath();
          K.strokeStyle = this._color(16711680, this.m_alpha);
          K.moveTo(G.position.x * y, G.position.y * y);
          K.lineTo((G.position.x + this.m_xformScale * G.R.col1.x) * y, (G.position.y + this.m_xformScale * G.R.col1.y) * y);
          K.strokeStyle = this._color(65280, this.m_alpha);
          K.moveTo(G.position.x * y, G.position.y * y);
          K.lineTo((G.position.x + this.m_xformScale * G.R.col2.x) * y, (G.position.y + this.m_xformScale * G.R.col2.y) * y);
          K.closePath();
          K.stroke()
      }
  })();
  var i;
  for (i = 0; i < Box2D.postDefs.length; ++i) Box2D.postDefs[i]();
  delete Box2D.postDefs;
  function MakeNewWorld() {
      var Vec2 = Box2D.Common.Math.b2Vec2,
          BodyDef = Box2D.Dynamics.b2BodyDef,
          Body = Box2D.Dynamics.b2Body,
          FixtureDef = Box2D.Dynamics.b2FixtureDef,
          Fixture = Box2D.Dynamics.b2Fixture,
          World = Box2D.Dynamics.b2World,
          MassData = Box2D.Collision.Shapes.b2MassData,
          PolygonShape = Box2D.Collision.Shapes.b2PolygonShape,
          CircleShape = Box2D.Collision.Shapes.b2CircleShape;
      var gravity = new Vec2(0, -10);
      var world = new World(gravity, true);
      var shape = new PolygonShape();
      shape.SetAsEdge(new Vec2(-40.0, 0), new Vec2(40.0, 0));
      var fd = new FixtureDef();
      fd.density = 0.0;
      fd.shape = shape;
      var bd = new BodyDef();
      var ground = world.CreateBody(bd);
      ground.CreateFixture(fd);
      var a = .5;
      var shape = new PolygonShape();
      shape.SetAsBox(a, a);
      var x = new Vec2(-7.0, 0.75);
      var y = new Vec2();
      var deltaX = new Vec2(0.5625, 1);
      var deltaY = new Vec2(1.125, 0.0);
      for (var i = 0; i < 10; ++i) {
          y.Set(x.x, x.y);
          for (var j = 0; j < 5; ++j) {
              var fd = new FixtureDef();
              fd.density = 5.0;
              fd.shape = shape;
              var bd = new BodyDef();
              bd.type = Body.b2_dynamicBody;
              bd.position.Set(y.x, y.y);
              var body = world.CreateBody(bd);
              body.CreateFixture(fd);
              y.Add(deltaY);
          }
          x.Add(deltaX);
      }
      return world;
  }
  var world = null;
  function runBox2D() {
      var world = MakeNewWorld();
      for (var i = 0; i < 20; i++) {
          world.Step(1 / 60, 10, 3);
      }
  }
  function setupBox2D() {}
  function tearDownBox2D() {
      world = null;
      Box2D = null;
  }
  var performance = {};
  performance.now = function() {
    return Date.now();
  };
  var BM_RunFunc = runBox2D;
  var BM_SetupFunc = setupBox2D;
  var BM_TearDownFunc = tearDownBox2D;
  var BM_Iterations = 60;
  var BM_Min_Iterations = 16;
  var BM_Results = [];
  function BM_Start() {
  	var data = { runs: 0, elapsed: 0 };
  	var elapsed = 0;
  	var start = Date.now();
  	var midpoint = null;
  	var end = null;
  	var i = 0;
  	function doRun(){
  		BM_SetupFunc();
  		console.log("Iteration : "+i);
  		if (i === BM_Iterations / 2) midpoint = Date.now();
  		BM_RunFunc();
  		elapsed = Date.now() - start;
  		BM_TearDownFunc();
  		i ++;
  		if (i < BM_Iterations){
  			setImmediate(doRun);
  		}
  		else {
  			if (data != null) {
  				data.runs += i;
  				data.elapsed += elapsed;
  			}
  			console.log("Runs: "+data.runs+"\t|\tElapsed: "+data.elapsed);
  			end = Date.now();
  			console.log("Total time : "+(end - start)+" ms");
  			var usec = (data.elapsed * 1000) / data.runs;
  			var rms = 0;
  			BM_Results.push({ time: usec, latency: rms });
  		 }
  	}
  	setImmediate(doRun);
  }
  BM_Start();